wiringpi 0.0.1-armv6l-linux → 1.0.0-armv6l-linux

data/ext/wiringpi/serial.c

@@ -0,0 +1,184 @@
+/*
+ * serial.c:
+ *	Handle a serial port
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "serial.h"
+
+/*
+ * serialOpen:
+ *	Open and initialise the serial port, setting all the right
+ *	port parameters - or as many as are required - hopefully!
+ *********************************************************************************
+ */
+
+int serialOpen (char *device, int baud)
+{
+  struct termios options ;
+  speed_t myBaud ;
+  int     status, fd ;
+
+#ifdef	DEBUG
+  printf ("openSerialPort: <%s> baud: $d\n", device, baud) ;
+#endif
+
+  switch (baud)
+  {
+    case     50:	myBaud =     B50 ; break ;
+    case     75:	myBaud =     B75 ; break ;
+    case    110:	myBaud =    B110 ; break ;
+    case    134:	myBaud =    B134 ; break ;
+    case    150:	myBaud =    B150 ; break ;
+    case    200:	myBaud =    B200 ; break ;
+    case    300:	myBaud =    B300 ; break ;
+    case    600:	myBaud =    B600 ; break ;
+    case   1200:	myBaud =   B1200 ; break ;
+    case   1800:	myBaud =   B1800 ; break ;
+    case   2400:	myBaud =   B2400 ; break ;
+    case   9600:	myBaud =   B9600 ; break ;
+    case  19200:	myBaud =  B19200 ; break ;
+    case  38400:	myBaud =  B38400 ; break ;
+    case  57600:	myBaud =  B57600 ; break ;
+    case 115200:	myBaud = B115200 ; break ;
+    case 230400:	myBaud = B230400 ; break ;
+
+    default:
+      return -2 ;
+  }
+
+  if ((fd = open (device, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK)) == -1)
+    return -1 ;
+
+  fcntl (fd, F_SETFL, O_RDWR) ;
+
+// Get and modify current options:
+
+  tcgetattr (fd, &options) ;
+
+  cfmakeraw   (&options) ;
+  cfsetispeed (&options, myBaud) ;
+  cfsetospeed (&options, myBaud) ;
+
+  options.c_cflag |= (CLOCAL | CREAD) ;
+  options.c_cflag &= ~PARENB ;
+  options.c_cflag &= ~CSTOPB ;
+  options.c_cflag &= ~CSIZE ;
+  options.c_cflag |= CS8 ;
+  options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG) ;
+  options.c_oflag &= ~OPOST ;
+
+  options.c_cc [VMIN]  =   0 ;
+  options.c_cc [VTIME] = 100 ;	// Ten seconds (100 deciseconds)
+
+  tcsetattr (fd, TCSANOW, &options) ;
+
+  ioctl (fd, TIOCMGET, &status);
+
+  status |= TIOCM_DTR ;
+  status |= TIOCM_RTS ;
+
+  ioctl (fd, TIOCMSET, &status);
+
+  usleep (10000) ;	// 10mS
+
+  return fd ;
+}
+
+
+/*
+ * serialClose:
+ *	Release the serial port
+ *********************************************************************************
+ */
+
+void serialClose (int fd)
+{
+  close (fd) ;
+}
+
+
+/*
+ * serialPutchar:
+ *	Send a single character to the serial port
+ *********************************************************************************
+ */
+
+void serialPutchar (int fd, uint8_t c)
+{
+  write (fd, &c, 1) ;
+}
+
+
+/*
+ * serialPuts:
+ *	Send a string to the serial port
+ *********************************************************************************
+ */
+
+void serialPuts (int fd, char *s)
+{
+  write (fd, s, strlen (s)) ;
+}
+
+/*
+ * serialDataAvail:
+ *	Return the number of bytes of data avalable to be read in the serial port
+ *********************************************************************************
+ */
+
+int serialDataAvail (int fd)
+{
+  int result ;
+
+  if (ioctl (fd, FIONREAD, &result) == -1)
+    return -1 ;
+
+  return result ;
+}
+
+
+/*
+ * serialGetchar:
+ *	Get a single character from the serial device.
+ *	Note: Zero is a valid character and this function will time-out after
+ *	10 seconds.
+ *********************************************************************************
+ */
+
+int serialGetchar (int fd)
+{
+  uint8_t x ;
+
+  if (read (fd, &x, 1) != 1)
+    return -1 ;
+
+  return ((int)x) & 0xFF ;
+}

data/ext/wiringpi/serial.h

@@ -0,0 +1,40 @@
+/*
+ * serial.h:
+ *	Handle a serial port
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#ifndef	_STDINT_H
+#  include <stdint.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int   serialOpen      (char *device, int baud) ;
+extern void  serialClose     (int fd) ;
+extern void  serialPutchar   (int fd, uint8_t c) ;
+extern void  serialPuts      (int fd, char *s) ;
+extern int   serialDataAvail (int fd) ;
+extern int   serialGetchar   (int fd) ;
+
+#ifdef __cplusplus
+}
+#endif

data/ext/wiringpi/{wiringpi.c → wiringPi.c}

@@ -47,9 +47,10 @@
 #include <string.h>
 #include <time.h>
 #include <fcntl.h>
+#include <sys/time.h>
 #include <sys/mman.h>
 
-#include "wiringpi.h"
+#include "wiringPi.h"
 
 #ifndef	TRUE
 #define	TRUE	(1==1)
@@ -150,7 +151,7 @@ static int pinToGpio [] =
   17, 18, 21, 22, 23, 24, 25, 4,	// From the Original Wiki - GPIO 0 through 7
    0,  1,				// I2C  - SDA0, SCL0
    8,  7,				// SPI  - CE1, CE0
-  10,  9, 11, 				// SPI  - MISO, MOSI, SCLK
+  10,  9, 11, 				// SPI  - MOSI, MISO, SCLK
   14, 15,				// UART - Tx, Rx
 } ;
 
@@ -244,6 +245,10 @@ static uint8_t gpioToPwmPort [] =
 } ;
 
 
+// Time for easy calculations
+
+static unsigned long long epoch ;
+
 //////////////////////////////////////////////////////////////////////////////////
 
 
@@ -269,6 +274,7 @@ int wiringPiSetup (void)
 {
   int      fd ;
   uint8_t *gpioMem, *pwmMem, *clkMem ;
+  struct timeval tv ;
 
 #ifdef	DEBUG_PADS
   uint8_t *gpioMem, *padsMem, *pwmMem, *clkMem ;
@@ -373,6 +379,9 @@ int wiringPiSetup (void)
   printf ("%08X %08X %08X\n", *(pads + 11), *(pads + 12), *(pads + 13)) ;
 #endif
 
+  gettimeofday (&tv, NULL) ;
+  epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
+
   return 0 ;
 }
 
@@ -462,6 +471,9 @@ void digitalWrite (int pin, int value)
 {
   int gpioPin ;
 
+  if ((pin < 0) || (pin >= NUM_PINS))
+    return ;
+
   if (gpioPinMode == WPI_MODE_PINS)
   {
     if ((pin < 0) || (pin >= NUM_PINS))
@@ -585,3 +597,21 @@ void delayMicroseconds (unsigned int howLong)
 
   nanosleep (&sleeper, &dummy) ;
 }
+
+/*
+ * millis:
+ *	Return a number of milliseconds as an unsigned int.
+ *********************************************************************************
+ */
+
+unsigned int millis (void)
+{
+  struct timeval tv ;
+  unsigned long long t1 ;
+
+  gettimeofday (&tv, NULL) ;
+
+  t1 = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
+
+  return (uint32_t)(t1 - epoch) ;
+}

data/ext/wiringpi/{wiringpi.h → wiringPi.h}

@@ -55,8 +55,9 @@ extern void digitalWrite      (int pin, int value) ;
 extern void pwmWrite          (int pin, int value) ;
 extern int  digitalRead       (int pin) ;
 
-extern void delay             (unsigned int howLong) ;
-extern void delayMicroseconds (unsigned int howLong) ;
+extern void         delay             (unsigned int howLong) ;
+extern void         delayMicroseconds (unsigned int howLong) ;
+extern unsigned int millis            (void) ;
 
 #ifdef __cplusplus
 }

data/ext/wiringpi/wiringShift.c

@@ -0,0 +1,84 @@
+/*
+ * wiringShift.c:
+ *	Emulate some of the Arduino wiring functionality. 
+ *
+ * Copyright (c) 2009-2012 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdint.h>
+
+#include "wiringPi.h"
+#include "wiringShift.h"
+
+/*
+ * shiftIn:
+ *	Shift data in from a clocked source
+ *********************************************************************************
+ */
+
+uint8_t shiftIn (uint8_t dPin, uint8_t cPin, uint8_t order)
+{
+  uint8_t value = 0 ;
+  int8_t  i ;
+ 
+  if (order == MSBFIRST)
+    for (i = 7 ; i >= 0 ; --i)
+    {
+      digitalWrite (cPin, HIGH) ;
+      value |= digitalRead (dPin) << i ;
+      digitalWrite (cPin, LOW) ;
+    }
+  else
+    for (i = 0 ; i < 8 ; ++i)
+    {
+      digitalWrite (cPin, HIGH) ;
+      value |= digitalRead (dPin) << i ;
+      digitalWrite (cPin, LOW) ;
+    }
+
+  return value;
+}
+
+
+/*
+ * shiftOut:
+ *	Shift data out to a clocked source
+ *********************************************************************************
+ */
+
+void shiftOut (uint8_t dPin, uint8_t cPin, uint8_t order, uint8_t val)
+{
+  int8_t i;
+
+  if (order == MSBFIRST)
+    for (i = 7 ; i >= 0 ; --i)
+    {
+      digitalWrite (dPin, val & (1 << i)) ;
+      digitalWrite (cPin, HIGH) ;
+      digitalWrite (cPin, LOW) ;
+    }
+  else
+    for (i = 0 ; i < 8 ; ++i)
+    {
+      digitalWrite (dPin, val & (1 << i)) ;
+      digitalWrite (cPin, HIGH) ;
+      digitalWrite (cPin, LOW) ;
+    }
+}

data/ext/wiringpi/wiringShift.h

@@ -0,0 +1,41 @@
+/*
+ * wiringShift.h:
+ *	Emulate some of the Arduino wiring functionality. 
+ *
+ * Copyright (c) 2009-2012 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#define	LSBFIRST	0
+#define	MSBFIRST	1
+
+#ifndef	_STDINT_H
+#  include <stdint.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern uint8_t shiftIn  (uint8_t dPin, uint8_t cPin, uint8_t order) ;
+extern void    shiftOut (uint8_t dPin, uint8_t cPin, uint8_t order, uint8_t val) ;
+
+#ifdef __cplusplus
+}
+#endif

data/ext/wiringpi/wiringpi_wrap.c

@@ -1883,7 +1883,122 @@ SWIG_AsVal_int (VALUE obj, int *val)
 }
 
 
-#include "wiringpi.h"
+/*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
+{
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  unsigned long *res = (unsigned long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UCHAR_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = (unsigned char)(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_char  (unsigned char value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    #if defined(StringValuePtr)
+    char *cstr = StringValuePtr(obj); 
+    #else
+    char *cstr = STR2CSTR(obj);
+    #endif
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+#include "wiringPi.h";
+#include "wiringShift.h";
+#include "serial.h";
 
 SWIGINTERN VALUE
 _wrap_wiringPiSetup(int argc, VALUE *argv, VALUE self) {
@@ -2062,6 +2177,256 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_shiftOut(int argc, VALUE *argv, VALUE self) {
+  uint8_t arg1 ;
+  uint8_t arg2 ;
+  uint8_t arg3 ;
+  uint8_t arg4 ;
+  unsigned char val1 ;
+  int ecode1 = 0 ;
+  unsigned char val2 ;
+  int ecode2 = 0 ;
+  unsigned char val3 ;
+  int ecode3 = 0 ;
+  unsigned char val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "uint8_t","shiftOut", 1, argv[0] ));
+  } 
+  arg1 = (uint8_t)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","shiftOut", 2, argv[1] ));
+  } 
+  arg2 = (uint8_t)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint8_t","shiftOut", 3, argv[2] ));
+  } 
+  arg3 = (uint8_t)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_char(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint8_t","shiftOut", 4, argv[3] ));
+  } 
+  arg4 = (uint8_t)(val4);
+  shiftOut(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_shiftIn(int argc, VALUE *argv, VALUE self) {
+  uint8_t arg1 ;
+  uint8_t arg2 ;
+  uint8_t arg3 ;
+  unsigned char val1 ;
+  int ecode1 = 0 ;
+  unsigned char val2 ;
+  int ecode2 = 0 ;
+  unsigned char val3 ;
+  int ecode3 = 0 ;
+  uint8_t result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "uint8_t","shiftIn", 1, argv[0] ));
+  } 
+  arg1 = (uint8_t)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","shiftIn", 2, argv[1] ));
+  } 
+  arg2 = (uint8_t)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint8_t","shiftIn", 3, argv[2] ));
+  } 
+  arg3 = (uint8_t)(val3);
+  result = shiftIn(arg1,arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_char((unsigned char)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_serialOpen(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char *","serialOpen", 1, argv[0] ));
+  }
+  arg1 = (char *)(buf1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","serialOpen", 2, argv[1] ));
+  } 
+  arg2 = (int)(val2);
+  result = (int)serialOpen(arg1,arg2);
+  vresult = SWIG_From_int((int)(result));
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  return vresult;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_serialClose(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","serialClose", 1, argv[0] ));
+  } 
+  arg1 = (int)(val1);
+  serialClose(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_serialPutchar(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  uint8_t arg2 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  unsigned char val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","serialPutchar", 1, argv[0] ));
+  } 
+  arg1 = (int)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","serialPutchar", 2, argv[1] ));
+  } 
+  arg2 = (uint8_t)(val2);
+  serialPutchar(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_serialPuts(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  char *arg2 = (char *) 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","serialPuts", 1, argv[0] ));
+  } 
+  arg1 = (int)(val1);
+  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","serialPuts", 2, argv[1] ));
+  }
+  arg2 = (char *)(buf2);
+  serialPuts(arg1,arg2);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return Qnil;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_serialDataAvail(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","serialDataAvail", 1, argv[0] ));
+  } 
+  arg1 = (int)(val1);
+  result = (int)serialDataAvail(arg1);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_serialGetchar(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","serialGetchar", 1, argv[0] ));
+  } 
+  arg1 = (int)(val1);
+  result = (int)serialGetchar(arg1);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
@@ -2342,5 +2707,13 @@ SWIGEXPORT void Init_wiringpi(void) {
   rb_define_module_function(mWiringpi, "digitalWrite", _wrap_digitalWrite, -1);
   rb_define_module_function(mWiringpi, "pwmWrite", _wrap_pwmWrite, -1);
   rb_define_module_function(mWiringpi, "digitalRead", _wrap_digitalRead, -1);
+  rb_define_module_function(mWiringpi, "shiftOut", _wrap_shiftOut, -1);
+  rb_define_module_function(mWiringpi, "shiftIn", _wrap_shiftIn, -1);
+  rb_define_module_function(mWiringpi, "serialOpen", _wrap_serialOpen, -1);
+  rb_define_module_function(mWiringpi, "serialClose", _wrap_serialClose, -1);
+  rb_define_module_function(mWiringpi, "serialPutchar", _wrap_serialPutchar, -1);
+  rb_define_module_function(mWiringpi, "serialPuts", _wrap_serialPuts, -1);
+  rb_define_module_function(mWiringpi, "serialDataAvail", _wrap_serialDataAvail, -1);
+  rb_define_module_function(mWiringpi, "serialGetchar", _wrap_serialGetchar, -1);
 }
 

data/lib/wiringpi.rb

@@ -1,111 +1,233 @@
 require 'wiringpi/wiringpi'
 
-WPI_MODE_PINS = 0
-WPI_MODE_GPIO = 1
+WPI_MODE_PINS = 0 # Use sane pin numbering
+WPI_MODE_GPIO = 1 # Use Broadcom barmy GPIO pin numbering
 
-INPUT		= 0
-OUTPUT		= 1
-PWM_OUTPUT	= 2
+# Constants for mode()
+INPUT = 0
+OUTPUT = 1
+PWM_OUTPUT = 2
 
-HIGH		= 1
-LOW			= 0
+# Constants for digitalWrite()
+HIGH = 1
+LOW = 0
 
-PUD_OFF		= 0
-PUD_DOWN	= 1
-PUD_UP		= 2
+PUD_OFF = 0
+PUD_DOWN = 1
+PUD_UP = 2
 
-class WiringPi
+# Bit-order for shiftOut and shiftIn
+LSBFIRST = 0 # Least Significant Bit First
+MSBFIRST = 1 # Most Significant Bit First
 
-	@@gpioPins = [
-		0,1,4,7,8,9,10,11,14,15,17,18,21,22,23,24,25 # seemingly random indeed!
-		]
+module WiringPi
 
-	@@pins = [
-		0,1,2,3,4,5,6,7, # basic IO pins
-		8,9,			 # i2c with 1k8 pull up resistor
-		10,11,12,13,14,	 # SPI pins, can also be used for IO
-        15,16,17
-		]
+  class Serial
 
-	@@mode = WPI_MODE_PINS
-	@@init = false
+    @id = 0
+    @device = '/dev/ttyAMA0'
+    @baud = 9600
 
-	def self.readAll
+    def initialize(device='/dev/ttyAMA0',baud=9600)
 
-		self.wiringPiSetup unless @@init
+      @device = device
+      @baud = baud
 
-		pinValues = Hash.new
+      @id = Wiringpi.serialOpen( @device,@baud )
 
-		@@pins.each do |pin|
-		
-			pinValues[pin] = self.read(pin)
-		
-		end
+    end
 
-		pinValues
+    def serialClose
 
-	end
+      Wiringpi.serialClose( @id )
+      @id = 0
 
-	def self.wiringPiMode( mode )
+    end
 
-		@@mode = mode
-		Wiringpi.wiringPiGpioMode( @@mode )
+    def serialPutchar( char )
 
-	end
+      Wiringpi.serialPutchar( @id, char )
 
-	def self.wiringPiSetup
+    end
 
-		begin		
-			Wiringpi.wiringPiSetup
-		rescue Exception=>e
-			raise e
-		end
+    def serialPuts( string )
 
-		Wiringpi.wiringPiGpioMode( @@mode )
-		@@init = true
-	
-	end
+      Wiringpi.serialPuts( @id, string )
 
-	def self.read(pin)
+    end
 
-		self.wiringPiSetup unless @@init
+    def serialDataAvail
+    
+      Wiringpi.serialDataAvail( @id )
 
-		raise ArgumentError, "invalid pin, available gpio pins: #{@@pins}" unless ( @@mode = WPI_MODE_PINS and @@pins.include?(pin) ) or ( @@mode = WPI_MODE_GPIO and @@gpioPins.include?(pin) )
+    end
 
-		Wiringpi.digitalRead(pin)
+    def serialGetchar
 
-	end
+      Wiringpi.serialGetchar( @id )
 
-	def self.pwmWrite(pin,value)
+    end
 
-		self.wiringPiSetup unless @@init
+  end
 
-		raise ArgumentError, "invalid pin, available gpio pins: #{@@pins}" unless ( @@mode = WPI_MODE_PINS and @@pins.include?(pin) ) or ( @@mode = WPI_MODE_GPIO and @@gpioPins.include?(pin) )
+  class GPIO
 
-		Wiringpi.pwmWrite(pin,value)
+    GPIO_PINS = [
+      0,1,4,7,8,9,10,11,14,15,17,18,21,22,23,24,25 # seemingly random indeed!
+      ]
 
-	end
+    PINS = [
+      0,1,2,3,4,5,6,7, # basic IO pins
+      8,9,             # i2c with 1k8 pull up resistor
+      10,11,12,13,14,     # SPI pins, can also be used for IO
+      15,16,17
+      ]
 
-	def self.write(pin,value)
+    @mode = WPI_MODE_PINS
 
-		self.wiringPiSetup unless @@init
-	
-		raise ArgumentError, "invalid pin, available gpio pins: #{@@pins}" unless ( @@mode = WPI_MODE_PINS and @@pins.include?(pin) ) or ( @@mode = WPI_MODE_GPIO and @@gpioPins.include?(pin) )
-		raise ArgumentError, 'invalid value' unless [0,1].include?(value)
+    @@init = false  # once wiringPiSetup has been called, we don't have to do it again
 
-		Wiringpi.digitalWrite(pin,value)
+    def initialize( mode=WPI_MODE_PINS )
 
-	end
+	  @mode = mode
+      self.wiringPiSetup unless @@init
 
-	def self.mode(pin,mode)
+    end
 
-		self.wiringPiSetup unless @@init
+    def wiringPiMode( mode )
 
-		raise ArgumentError, "invalid pin, available gpio pins: #{@@pins}" unless ( @@mode = WPI_MODE_PINS and @@pins.include?(pin) ) or ( @@mode = WPI_MODE_GPIO and @@gpioPins.include?(pin) )
-		raise ArgumentError, "invalid mode" unless [INPUT,OUTPUT,PWM_OUTPUT].include?(mode)
+      @mode = mode
+      Wiringpi.wiringPiGpioMode( @mode )
 
-		Wiringpi.pinMode(pin, mode)
+    end
 
-	end
+    def wiringPiSetup
 
-end
+      begin        
+        Wiringpi.wiringPiSetup
+      rescue Exception=>e
+        raise e
+      end
+
+      Wiringpi.wiringPiGpioMode( @mode )
+      @@init = true
+    
+    end
+
+    def checkPin(pin)
+
+      ( @mode = WPI_MODE_PINS and PINS.include?(pin) ) or ( @mode = WPI_MODE_GPIO and GPIO_PINS.include?(pin) )
+
+    end
+
+    def pinError(pin)
+      "invalid #{pin}, available gpio pins: #{PINS}" if @mode == WPI_MODE_PINS
+      "invalid #{pin}, available gpio pins: #{GPIO_PINS}" if @mode == WPI_MODE_GPIO
+    end
+
+    def read(pin)
+
+      raise ArgumentError, pinError(pin) unless checkPin(pin)
+
+      Wiringpi.digitalRead(pin)
+
+    end
+
+    def pwmWrite(pin,value)
+
+      raise ArgumentError, pinError(pin) unless checkPin(pin)
+
+      Wiringpi.pwmWrite(pin,value)
+
+    end
+
+    def write(pin,value)
+    
+      raise ArgumentError, pinError(pin) unless checkPin(pin)
+      raise ArgumentError, 'invalid value' unless [0,1].include?(value)
+
+      Wiringpi.digitalWrite(pin,value)
+
+    end
+
+    def mode(pin,mode)
+
+      raise ArgumentError, pinError(pin) unless checkPin(pin)
+      raise ArgumentError, "invalid mode" unless [INPUT,OUTPUT,PWM_OUTPUT].include?(mode)
+
+      Wiringpi.pinMode(pin, mode)
+
+    end
+
+=begin
+shiftOutArray int dataPin, int clockPin, int latchPin, int[] bits
+Shifts out an array of ints by converting them into bytes
+and handing to Wiringpi.shiftOut, must contain only 1s or 0s
+=end
+    def shiftOutArray(dataPin, clockPin, latchPin, bits)
+
+      raise ArgumentError, "invalid data pin, available gpio pins: #{PINS}" unless checkPin(dataPin)
+      raise ArgumentError, "invalid clock pin, available gpio pins: #{PINS}" unless checkPin(clockPin)
+      raise ArgumentError, "invalid latch pin, available gpio pins: #{PINS}" unless checkPin(latchPin)
+
+      WiringPi.write( latchPin, LOW )
+
+      bits.each_slice(8) do |slice|
+        Wiringpi.shiftOut(dataPin, clockPin, LSBFIRST, slice.reverse.join.to_i(2)) 
+      end
+
+      WiringPi.write( latchPin, HIGH )
+
+    end
+
+=begin
+shiftOut int dataPin, int clockPin, int latchPin, char
+Shift out a single 8-bit integer 0-255
+=end
+    def shiftOut(dataPin, clockPin, latchPin, char)
+
+      raise ArgumentError, "invalid data pin, available gpio pins: #{PINS}" unless checkPin(dataPin)
+      raise ArgumentError, "invalid clock pin, available gpio pins: #{PINS}" unless checkPin(clockPin)
+      raise ArgumentError, "invalid latch pin, available gpio pins: #{PINS}" unless checkPin(latchPin)
+        
+      WiringPi.write( latchPin, LOW )
+
+      Wiringpi.shiftOut(dataPin, clockPin, LSBFIRST, char)
+
+      WiringPi.write( latchPin, HIGH )
+
+    end
+
+=begin
+readAll
+Reads values of all pins and returns them as a hash
+=end
+    def readAll
+
+      pinValues = Hash.new
+
+      if @mode == WPI_MODE_GPIO
+
+        GPIO_PINS.each do |pin|
+        
+          pinValues[pin] = self.read(pin)
+        
+        end
+
+      else
+      
+        PINS.each do |pin|
+        
+          pinValues[pin] = self.read(pin)
+        
+        end
+
+      end
+
+      pinValues
+
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wiringpi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
   prerelease: 
 platform: armv6l-linux
 authors:
@@ -12,8 +12,10 @@ bindir: bin
 cert_chain: []
 date: 2012-06-22 00:00:00.000000000 Z
 dependencies: []
-description: ! 'Alpha version of the WiringPi library wrapper. WiringPi can be found
-  here: http://projects.drogon.net/raspberry-pi/wiringpi/'
+description: ! 'WiringPi library wrapper for the Raspberry Pi only. Wraps up the Arduino
+  wiring-like WiringPi library into a convinient Ruby gem. Currently includes GPIO
+  functionality, serial and shiftOut/shiftIn support. Credit to Gordon for the WiringPi
+  library, which can be found here: http://projects.drogon.net/raspberry-pi/wiringpi/'
 email: phil@gadgetoid.com
 executables: []
 extensions:
@@ -21,9 +23,13 @@ extensions:
 extra_rdoc_files: []
 files:
 - lib/wiringpi.rb
-- ext/wiringpi/wiringpi.c
+- ext/wiringpi/wiringShift.c
+- ext/wiringpi/wiringPi.c
+- ext/wiringpi/serial.c
 - ext/wiringpi/wiringpi_wrap.c
-- ext/wiringpi/wiringpi.h
+- ext/wiringpi/wiringShift.h
+- ext/wiringpi/serial.h
+- ext/wiringpi/wiringPi.h
 - ext/wiringpi/extconf.rb
 homepage: http://rubygems.org/gems/wiringpi
 licenses: