cleanup of brettcvz's read_byte function, added read_word since he really needs 12 bits of data. finally fixed the gpio cleanup() without argument issue once and for all, sorry for lying howientc

Merge pull request #59 from brettcvz/master
Added the ability to read a full byte from a set of channels
2025-07-20 12:53:22 +00:00 · 2017-01-29 22:58:41 +00:00 · 2017-01-29 15:21:26 -06:00 · 2017-01-29 12:32:53 -08:00 · 2017-01-29 20:21:02 +00:00 · 2017-01-29 20:10:09 +00:00
13 changed files with 642 additions and 247 deletions
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@ -1,3 +1,19 @@
+0.3.5
+---
+* Merged in brettcvz's code to read a byte of data from the GPIO
+  - Cleaned the code up and expanded it (in the low level C code) to read up to 32 bits of data
+  - Presented 8 bit and 16 bits of data functions to the Python interface with brettcvz's read_byte() and my read_word()
+* I think I finally fixed the GPIO.cleanup() code one and for all
+
+0.3.4.1
+---
+* Quick fix as I borked XIO setup as inputs with the latest change that enabled PUD
+
+0.3.4
+---
+* Pull Up/Pull Down resistor setting now available for the R8 GPIO.
+* Some general cleanup
+
 0.3.3
 ----
 * Added Debug printing for all the capabilities with the toggle_debug() function
--- a/README.rst
+++ b/README.rst
@ -19,7 +19,6 @@ For Python2.7::
    cd CHIP_IO
    sudo python setup.py install
    cd ..
-    sudo rm -rf CHIP_IO

 For Python3::

@ -34,7 +33,6 @@ For Python3::
    cd CHIP_IO
    sudo python3 setup.py install
    cd ..
-    sudo rm -rf CHIP_IO

 **Usage**

@ -191,6 +189,15 @@ Inputs work similarly to outputs.::
    import CHIP_IO.GPIO as GPIO
    GPIO.setup("CSID0", GPIO.IN)

+Other options when setting up pins::
+
+    # Specify pull up/pull down settings on a pin
+    GPIO.setup("CSID0", GPIO.IN, pull_up_down=GPIO.PUD_UP)
+    # Specify initial value for an output
+    GPIO.setup("CSID0", GPIO.OUT, initial=1)
+    
+Pull Up/Down values are only for pins that are provided by the R8, the XIO are not capable of this.  The allowable values are: PUD_OFF, PUD_UP, and PUD_DOWN.
+
 Polling inputs::

    if GPIO.input("CSID0"):
@ -198,6 +205,15 @@ Polling inputs::
    else:
        print("LOW")

+Read lots of data::
+
+    # Get 8 bits of data in one shot
+    mybyte = GPIO.read_byte("LCD-D3")
+    # Get 16 bits of data in one shot
+    myword = GPIO.read_word("XIO-P4")
+
+This code was initially added by brettcvz and I cleaned it up and expanded it.
+
 The edge detection code below only works for the AP-EINT1, AP-EINT3, and XPO Pins on the CHIP.

 Waiting for an edge (GPIO.RISING, GPIO.FALLING, or GPIO.BOTH::
--- a/setup.py
+++ b/setup.py
@ -20,7 +20,7 @@ classifiers = ['Development Status :: 3 - Alpha',
               'Topic :: System :: Hardware']

 setup(name             = 'CHIP_IO',
-      version          = '0.3.3',
+      version          = '0.3.5',
      author           = 'Robert Wolterman',
      author_email     = 'robert.wolterman@gmail.com',
      description      = 'A module to control CHIP IO channels',
--- a/source/c_pwm.c
+++ b/source/c_pwm.c
@ -33,6 +33,7 @@ SOFTWARE.
 #include <stdlib.h>
 #include <sys/types.h>
 #include <string.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include "c_pwm.h"
@ -102,6 +103,7 @@ struct pwm_exp *lookup_exported_pwm(const char *key)

 int initialize_pwm(void)
 {
+    int e_no;
    if (!pwm_initialized) {
        int fd, len;
        char str_gpio[80];
@ -113,23 +115,37 @@ int initialize_pwm(void)
            printf(" ** initialize_pwm **\n");
        if ((fd = open("/sys/class/pwm/pwmchip0/export", O_WRONLY)) < 0)
        {
+            char err[256];
+            snprintf(err, sizeof(err), "initialize_pwm: could not open export file");
+            add_error_msg(err);
            return -1;
        }
        len = snprintf(str_gpio, sizeof(str_gpio), "%d", gpio); BUF2SMALL(str_gpio);
-        ssize_t s = write(fd, str_gpio, len);  ASSRT(s == len);
+        ssize_t s = write(fd, str_gpio, len); e_no = errno;
+        close(fd);
+        
+        if (s != len) {
+            char err[256];
+            snprintf(err, sizeof(err), "initialize_pwm: could not export pwm (%s)", strerror(e_no));
+            add_error_msg(err);
+            return -1;
+        }
+        
        if (DEBUG)
            printf(" ** initialize_pwm: export pin: s = %d, len = %d\n", s, len);
-        close(fd);
        
        pwm_initialized = 1;
        return 1;
+    } else {
+        if (DEBUG)
+            printf(" ** initialize_pwm: pwm is already initialized\n");
    }

    return 0;
 }

 int pwm_set_frequency(const char *key, float freq) {
-    int len;
+    int len, e_no;
    int rtnval = -1;
    char buffer[80];
    unsigned long period_ns;
@ -151,13 +167,16 @@ int pwm_set_frequency(const char *key, float freq) {
            pwm->period_ns = period_ns;

            len = snprintf(buffer, sizeof(buffer), "%lu", period_ns); BUF2SMALL(buffer);
-            ssize_t s = write(pwm->period_fd, buffer, len);  //ASSRT(s == len);
+            ssize_t s = write(pwm->period_fd, buffer, len);  e_no = errno;
            if (DEBUG) {
                printf(" ** pwm_set_frequency: pwm_initialized = %d\n", pwm_initialized);
                printf(" ** pwm_set_frequency: buffer: %s\n", buffer);
                printf(" ** pwm_set_frequency: s = %d, len = %d\n", s, len);
            }
            if (s != len) {
+                char err[256];
+                snprintf(err, sizeof(err), "pwm_set_frequency: could not change frequency of pwm (%s)", strerror(e_no));
+                add_error_msg(err);
                rtnval = -1;
            } else {
                rtnval = 1;
@ -173,7 +192,7 @@ int pwm_set_frequency(const char *key, float freq) {
 }

 int pwm_set_period_ns(const char *key, unsigned long period_ns) {
-    int len;
+    int len, e_no;
    int rtnval = -1;
    char buffer[80];
    struct pwm_exp *pwm;
@ -191,13 +210,16 @@ int pwm_set_period_ns(const char *key, unsigned long period_ns) {
            pwm->period_ns = period_ns;

            len = snprintf(buffer, sizeof(buffer), "%lu", period_ns); BUF2SMALL(buffer);
-            ssize_t s = write(pwm->period_fd, buffer, len);  //ASSRT(s == len);
+            ssize_t s = write(pwm->period_fd, buffer, len);  e_no = errno;
            if (DEBUG) {
                printf(" ** pwm_set_period_ns: pwm_initialized = %d\n", pwm_initialized);
                printf(" ** pwm_set_period_ns: buffer: %s\n", buffer);
                printf(" ** pwm_set_period_ns: s = %d, len = %d\n", s, len);
            }
            if (s != len) {
+                char err[256];
+                snprintf(err, sizeof(err), "pwm_set_period_ns: could not change period of pwm (%s)", strerror(e_no));
+                add_error_msg(err);
                rtnval = -1;
            } else {
                rtnval = 1;
@ -233,7 +255,7 @@ int pwm_get_period_ns(const char *key, unsigned long *period_ns) {
 }

 int pwm_set_polarity(const char *key, int polarity) {
-    int len;
+    int len, e_no;
    int rtnval = -1;
    char buffer[80];
    struct pwm_exp *pwm;
@ -256,13 +278,16 @@ int pwm_set_polarity(const char *key, int polarity) {
        {
            len = snprintf(buffer, sizeof(buffer), "%s", "inverted"); BUF2SMALL(buffer);
        }
-        ssize_t s = write(pwm->polarity_fd, buffer, len);  //ASSRT(s == len);
+        ssize_t s = write(pwm->polarity_fd, buffer, len);  e_no = errno;
        if (DEBUG) {
            printf(" ** pwm_set_polarity: pwm_initialized = %d\n", pwm_initialized);
            printf(" ** pwm_set_polarity: buffer: %s\n", buffer);
            printf(" ** pwm_set_polarity: s = %d, len = %d\n", s, len);
        }
        if (s != len) {
+            char err[256];
+            snprintf(err, sizeof(err), "pwm_set_polarity: could not change polarity of pwm (%s)", strerror(e_no));
+            add_error_msg(err);
            rtnval = -1;
        } else {
            rtnval = 1;
@ -274,7 +299,7 @@ int pwm_set_polarity(const char *key, int polarity) {
 }

 int pwm_set_duty_cycle(const char *key, float duty) {
-    int len;
+    int len, e_no;
    int rtnval = -1;
    char buffer[80];
    struct pwm_exp *pwm;
@ -293,13 +318,16 @@ int pwm_set_duty_cycle(const char *key, float duty) {

    if (pwm->enable) {
        len = snprintf(buffer, sizeof(buffer), "%lu", pwm->duty); BUF2SMALL(buffer);
-        ssize_t s = write(pwm->duty_fd, buffer, len);  //ASSRT(s == len);
+        ssize_t s = write(pwm->duty_fd, buffer, len);  e_no = errno;
        if (DEBUG) {
            printf(" ** pwm_set_duty_cycle: pwm_initialized = %d\n", pwm_initialized);
            printf(" ** pwm_set_duty_cycle: buffer: %s\n", buffer);
            printf(" ** pwm_set_duty_cycle: s = %d, len = %d\n", s, len);
        }
        if (s != len) {
+            char err[256];
+            snprintf(err, sizeof(err), "pwm_set_duty_cycle: could not change duty cycle of pwm (%s)", strerror(e_no));
+            add_error_msg(err);
            rtnval = -1;
        } else {
            rtnval = 1;
@ -312,7 +340,7 @@ int pwm_set_duty_cycle(const char *key, float duty) {
 }

 int pwm_set_pulse_width_ns(const char *key, unsigned long pulse_width_ns) {
-    int len;
+    int len, e_no;
    int rtnval = -1;
    char buffer[80];
    struct pwm_exp *pwm;
@ -330,13 +358,16 @@ int pwm_set_pulse_width_ns(const char *key, unsigned long pulse_width_ns) {
    
    if (pwm->enable) {
        len = snprintf(buffer, sizeof(buffer), "%lu", pwm->duty); BUF2SMALL(buffer);
-        ssize_t s = write(pwm->duty_fd, buffer, len);  //ASSRT(s == len);
+        ssize_t s = write(pwm->duty_fd, buffer, len);  e_no = errno;
        if (DEBUG) {
            printf(" ** pwm_set_pulse_width_ns: pwm_initialized = %d\n", pwm_initialized);
            printf(" ** pwm_set_pulse_width_ns: buffer: %s\n", buffer);
            printf(" ** pwm_set_pulse_width_ns: s = %d, len = %d\n", s, len);
        }
        if (s != len) {
+            char err[256];
+            snprintf(err, sizeof(err), "pwm_set_pulse_width_ns: could not change pulse width of pwm (%s)", strerror(e_no));
+            add_error_msg(err);
            rtnval = -1;
        } else {
            rtnval = 1;
@ -351,7 +382,7 @@ int pwm_set_pulse_width_ns(const char *key, unsigned long pulse_width_ns) {

 int pwm_set_enable(const char *key, int enable)
 {
-    int len;
+    int len, e_no;
    int rtnval = -1;
    char buffer[80];
    struct pwm_exp *pwm;
@ -372,7 +403,7 @@ int pwm_set_enable(const char *key, int enable)


    len = snprintf(buffer, sizeof(buffer), "%d", enable); BUF2SMALL(buffer);
-    ssize_t s = write(pwm->enable_fd, buffer, len);  //ASSRT(s == len);
+    ssize_t s = write(pwm->enable_fd, buffer, len);  e_no = errno;
    if (DEBUG) {
        printf(" ** pwm_set_enable: pwm_initialized = %d\n", pwm_initialized);
        printf(" ** pwm_set_enable: buffer: %s\n", buffer);
@ -386,6 +417,9 @@ int pwm_set_enable(const char *key, int enable)
        pwm->enable = enable;
        rtnval = 0;
    } else {
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_set_enable: could not enable/disable pwm (%s)", strerror(e_no));
+        add_error_msg(err);
        rtnval = -1;
    }

@ -432,11 +466,18 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
    }
    
    //add period and duty fd to pwm list
-    if ((enable_fd = open(enable_path, O_WRONLY)) < 0)
+    if ((enable_fd = open(enable_path, O_WRONLY)) < 0) {
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_start: could not open enable file");
+        add_error_msg(err);
        return -1;
+    }

    if ((period_fd = open(period_path, O_WRONLY)) < 0) {
        close(enable_fd);
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_start: could not open period file");
+        add_error_msg(err);
        return -1;
    }

@ -444,6 +485,9 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
        //error, close already opened period_fd.
        close(enable_fd);
        close(period_fd);
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_start: could not open duty cycle file");
+        add_error_msg(err);
        return -1;
    }

@ -452,13 +496,19 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
        close(enable_fd);
        close(period_fd);
        close(duty_fd);
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_start: could not open polarity file");
+        add_error_msg(err);
        return -1;
    }

    // add to list
    new_pwm = malloc(sizeof(struct pwm_exp));
    if (new_pwm == 0) {
-        return -1; // out of memory
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_start: unable to allocate memory");
+        add_error_msg(err);
+        return -1;
    }

    if (DEBUG)
@ -503,7 +553,7 @@ int pwm_disable(const char *key)
 {
    struct pwm_exp *pwm, *temp, *prev_pwm = NULL;

-    int fd, len;
+    int fd, len, e_no;
    char str_gpio[80];
    // Per https://github.com/NextThingCo/CHIP-linux/pull/4
    // we need to export 0 here to enable pwm0
@ -517,11 +567,20 @@ int pwm_disable(const char *key)

    if ((fd = open("/sys/class/pwm/pwmchip0/unexport", O_WRONLY)) < 0)
    {
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_disable: could not open unexport file");
+        add_error_msg(err);
        return -1;
    }
    len = snprintf(str_gpio, sizeof(str_gpio), "%d", gpio); BUF2SMALL(str_gpio);
-    ssize_t s = write(fd, str_gpio, len);  ASSRT(s == len);
+    ssize_t s = write(fd, str_gpio, len); e_no = errno;
    close(fd);
+    if (s != len) {
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_disable: could not unexport pwm (%s)", strerror(e_no));
+        add_error_msg(err);
+        return -1;
+    }
    
    // remove from list
    pwm = exported_pwms;
--- a/source/c_softpwm.c
+++ b/source/c_softpwm.c
@ -35,6 +35,7 @@ SOFTWARE.
 #include <sys/types.h>
 #include <string.h>
 #include <fcntl.h>
+#include <errno.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <time.h>
--- a/source/common.c
+++ b/source/common.c
@ -53,90 +53,89 @@ int module_setup = 0;
 int DEBUG = 0;

 pins_t pins_info[] = {
-  { "GND",       "GND",         "U13_1",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CHG-IN",    "CHG-IN",      "U13_2",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "VCC-5V",    "VCC-5V",      "U13_3",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U13_4",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "VCC-3V3",   "VCC-3V3",     "U13_5",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "TS",        "TS",          "U13_6",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "VCC-1V8",   "VCC-1V8",     "U13_7",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "BAT",       "BAT",         "U13_8",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "TWI1-SDA",  "KPD-I2C-SDA", "U13_9",   48, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "PWRON",     "PWRON",       "U13_10",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "TWI1-SCK",  "KPD-I2C-SCL", "U13_11",  47, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U13_12",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "X1",        "X1",          "U13_13",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "X2",        "X2",          "U13_14",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "Y1",        "Y1",          "U13_15",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "Y2",        "Y2",          "U13_16",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D2",    "LCD-D2",      "U13_17",  98, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "PWM0",      "PWM0",        "U13_18",  34, BASE_METHOD_AS_IS,  0, -1, SPWM_DISABLED},
-  { "LCD-D4",    "LCD-D4",      "U13_19", 100, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D3",    "LCD-D3",      "U13_20",  99, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D6",    "LCD-D6",      "U13_21", 102, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D5",    "LCD-D5",      "U13_22", 101, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D10",   "LCD-D10",     "U13_23", 106, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D7",    "LCD-D7",      "U13_24", 103, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D12",   "LCD-D12",     "U13_25", 108, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D11",   "LCD-D11",     "U13_26", 107, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D14",   "LCD-D14",     "U13_27", 110, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D13",   "LCD-D13",     "U13_28", 109, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D18",   "LCD-D18",     "U13_29", 114, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D15",   "LCD-D15",     "U13_30", 111, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D20",   "LCD-D20",     "U13_31", 116, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D19",   "LCD-D19",     "U13_32", 115, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D22",   "LCD-D22",     "U13_33", 118, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D21",   "LCD-D21",     "U13_34", 117, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-CLK",   "LCD-CLK",     "U13_35", 120, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-D23",   "LCD-D23",     "U13_36", 119, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-VSYNC", "LCD-VSYNC",   "U13_37", 123, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-HSYNC", "LCD-HSYNC",   "U13_38", 122, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U13_39",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LCD-DE",    "LCD-DE",      "U13_40", 121, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U14_1",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "VCC-5V",    "VCC-5V",      "U14_2",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "UART1-TX",  "UART-TX",     "U14_3",  195, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "HPL",       "HPL",         "U14_4",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "UART1-RX",  "UART-RX",     "U14_5",  196, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "HPCOM",     "HPCOM",       "U14_6",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "FEL",       "FEL",         "U14_7",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "HPR",       "HPR",         "U14_8",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "VCC-3V3",   "VCC-3V3",     "U14_9",   -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "MICM",      "MICM",        "U14_10",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "LRADC",     "ADC",         "U14_11",  -1, BASE_METHOD_AS_IS, -1,  0, SPWM_DISABLED},
-  { "MICIN1",    "MICIN1",      "U14_12",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "XIO-P0",    "XIO-P0",      "U14_13",   0, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P1",    "XIO-P1",      "U14_14",   1, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P2",    "GPIO1",       "U14_15",   2, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P3",    "GPIO2",       "U14_16",   3, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P4",    "GPIO3",       "U14_17",   4, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P5",    "GPIO4",       "U14_18",   5, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P6",    "GPIO5",       "U14_19",   6, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "XIO-P7",    "GPIO6",       "U14_20",   7, BASE_METHOD_XIO,   -1, -1, SPWM_ENABLED},
-  { "GND",       "GND",         "U14_21",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U14_22",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "AP-EINT1",  "KPD-INT",     "U14_23", 193, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "AP-EINT3",  "AP-INT3",     "U14_24",  35, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "TWI2-SDA",  "I2C-SDA",     "U14_25",  50, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "TWI2-SCK",  "I2C-SCL",     "U14_26",  49, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSIPCK",    "SPI-SEL",     "U14_27", 128, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSICK",     "SPI-CLK",     "U14_28", 129, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSIHSYNC",  "SPI-MOSI",    "U14_29", 130, BASE_METHOD_AS_IS,  1, -1, SPWM_DISABLED},
-  { "CSIVSYNC",  "SPI-MISO",    "U14_30", 131, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID0",     "CSID0",       "U14_31", 132, BASE_METHOD_AS_IS,  1, -1, SPWM_DISABLED},
-  { "CSID1",     "CSID1",       "U14_32", 133, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID2",     "CSID2",       "U14_33", 134, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID3",     "CSID3",       "U14_34", 135, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID4",     "CSID4",       "U14_35", 136, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID5",     "CSID5",       "U14_36", 137, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID6",     "CSID6",       "U14_37", 138, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "CSID7",     "CSID7",       "U14_38", 139, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U14_39",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
-  { "GND",       "GND",         "U14_40",  -1, BASE_METHOD_AS_IS, -1, -1, SPWM_DISABLED},
+  { "GND",       "GND",         "U13_1",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CHG-IN",    "CHG-IN",      "U13_2",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "VCC-5V",    "VCC-5V",      "U13_3",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U13_4",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "VCC-3V3",   "VCC-3V3",     "U13_5",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "TS",        "TS",          "U13_6",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "VCC-1V8",   "VCC-1V8",     "U13_7",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "BAT",       "BAT",         "U13_8",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "TWI1-SDA",  "KPD-I2C-SDA", "U13_9",   48, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "PWRON",     "PWRON",       "U13_10",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "TWI1-SCK",  "KPD-I2C-SCL", "U13_11",  47, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U13_12",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "X1",        "X1",          "U13_13",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "X2",        "X2",          "U13_14",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "Y1",        "Y1",          "U13_15",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "Y2",        "Y2",          "U13_16",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D2",    "LCD-D2",      "U13_17",  98, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "PWM0",      "PWM0",        "U13_18",  34, BASE_METHOD_AS_IS,  0, -1, BOTH},
+  { "LCD-D4",    "LCD-D4",      "U13_19", 100, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D3",    "LCD-D3",      "U13_20",  99, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D6",    "LCD-D6",      "U13_21", 102, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D5",    "LCD-D5",      "U13_22", 101, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D10",   "LCD-D10",     "U13_23", 106, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D7",    "LCD-D7",      "U13_24", 103, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D12",   "LCD-D12",     "U13_25", 108, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D11",   "LCD-D11",     "U13_26", 107, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D14",   "LCD-D14",     "U13_27", 110, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D13",   "LCD-D13",     "U13_28", 109, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D18",   "LCD-D18",     "U13_29", 114, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D15",   "LCD-D15",     "U13_30", 111, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D20",   "LCD-D20",     "U13_31", 116, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D19",   "LCD-D19",     "U13_32", 115, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D22",   "LCD-D22",     "U13_33", 118, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D21",   "LCD-D21",     "U13_34", 117, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-CLK",   "LCD-CLK",     "U13_35", 120, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-D23",   "LCD-D23",     "U13_36", 119, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-VSYNC", "LCD-VSYNC",   "U13_37", 123, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-HSYNC", "LCD-HSYNC",   "U13_38", 122, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U13_39",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LCD-DE",    "LCD-DE",      "U13_40", 121, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U14_1",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "VCC-5V",    "VCC-5V",      "U14_2",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "UART1-TX",  "UART-TX",     "U14_3",  195, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "HPL",       "HPL",         "U14_4",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "UART1-RX",  "UART-RX",     "U14_5",  196, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "HPCOM",     "HPCOM",       "U14_6",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "FEL",       "FEL",         "U14_7",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "HPR",       "HPR",         "U14_8",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "VCC-3V3",   "VCC-3V3",     "U14_9",   -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "MICM",      "MICM",        "U14_10",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "LRADC",     "ADC",         "U14_11",  -1, BASE_METHOD_AS_IS, -1,  0, BOTH},
+  { "MICIN1",    "MICIN1",      "U14_12",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "XIO-P0",    "XIO-P0",      "U14_13",   0, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P1",    "XIO-P1",      "U14_14",   1, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P2",    "GPIO1",       "U14_15",   2, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P3",    "GPIO2",       "U14_16",   3, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P4",    "GPIO3",       "U14_17",   4, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P5",    "GPIO4",       "U14_18",   5, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P6",    "GPIO5",       "U14_19",   6, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "XIO-P7",    "GPIO6",       "U14_20",   7, BASE_METHOD_XIO,   -1, -1, CHIP},
+  { "GND",       "GND",         "U14_21",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U14_22",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "AP-EINT1",  "KPD-INT",     "U14_23", 193, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "AP-EINT3",  "AP-INT3",     "U14_24",  35, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "TWI2-SDA",  "I2C-SDA",     "U14_25",  50, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "TWI2-SCK",  "I2C-SCL",     "U14_26",  49, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSIPCK",    "SPI-SEL",     "U14_27", 128, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSICK",     "SPI-CLK",     "U14_28", 129, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSIHSYNC",  "SPI-MOSI",    "U14_29", 130, BASE_METHOD_AS_IS,  1, -1, BOTH},
+  { "CSIVSYNC",  "SPI-MISO",    "U14_30", 131, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID0",     "CSID0",       "U14_31", 132, BASE_METHOD_AS_IS,  1, -1, BOTH},
+  { "CSID1",     "CSID1",       "U14_32", 133, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID2",     "CSID2",       "U14_33", 134, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID3",     "CSID3",       "U14_34", 135, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID4",     "CSID4",       "U14_35", 136, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID5",     "CSID5",       "U14_36", 137, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID6",     "CSID6",       "U14_37", 138, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "CSID7",     "CSID7",       "U14_38", 139, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U14_39",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
+  { "GND",       "GND",         "U14_40",  -1, BASE_METHOD_AS_IS, -1, -1, BOTH},
  { NULL,        NULL,          NULL,      -1, 0,                 -1, -1, -1}
 };

-
 // CREDIT FOR THIS FUNCTION DUE TO HOWIE KATZ OF NTC AND STEVE FORD
 // THIS WILL FIND THE PROPER XIO BASE SYSFS NUMBER
 // PORTED TO C FORM HOWIE'S PYTHON CODE WITH THE HELP OF STEVE:
@ -250,6 +249,22 @@ int gpio_number(pins_t *pin)
  return gpio_num;
 }  /* gpio_number */

+int gpio_pud_capable(pins_t *pin)
+{
+  int capable = -1;
+
+  switch (pin->base_method) {
+    case BASE_METHOD_AS_IS:
+      capable = 1;
+      break;
+    
+    case BASE_METHOD_XIO:
+      capable = 0;
+      break;
+  }
+
+  return capable;
+}

 int lookup_gpio_by_key(const char *key)
 {
@ -284,6 +299,39 @@ int lookup_gpio_by_altname(const char *altname)
  return -1;
 }

+int lookup_pud_capable_by_key(const char *key)
+{
+  pins_t *p;
+  for (p = pins_info; p->key != NULL; ++p) {
+      if (strcmp(p->key, key) == 0) {
+          return gpio_pud_capable(p);
+      }
+  }
+  return -1;
+}
+
+int lookup_pud_capable_by_name(const char *name)
+{
+  pins_t *p;
+  for (p = pins_info; p->name != NULL; ++p) {
+      if (strcmp(p->name, name) == 0) {
+          return gpio_pud_capable(p);
+      }
+  }
+  return -1;
+}
+
+int lookup_pud_capable_by_altname(const char *altname)
+{
+  pins_t *p;
+  for (p = pins_info; p->altname != NULL; ++p) {
+      if (strcmp(p->altname, altname) == 0) {
+          return gpio_pud_capable(p);
+      }
+  }
+  return -1;
+}
+
 int lookup_ain_by_key(const char *key)
 {
  pins_t *p;
@ -397,6 +445,33 @@ int get_gpio_number(const char *key, int *gpio)
    return status;
 }

+int compute_port_pin(const char *key, int gpio, int *port, int *pin)
+{
+    int capable = 0;
+    int rtn = -1;
+
+    capable = lookup_pud_capable_by_key(key);
+    if (capable < 0) {
+        capable = lookup_pud_capable_by_name(key);
+        if (capable < 0) {
+             capable = lookup_gpio_by_altname(key);
+             if (capable < 0) {
+                 capable = 0;  // default to false
+             }
+        }
+    }
+
+    if (capable) {
+        // Method from:
+        // https://bbs.nextthing.co/t/chippy-gonzales-fast-gpio/14056/6?u=xtacocorex
+        *port = gpio / 32;
+        *pin = gpio % 32;
+        rtn = 0;
+    }
+    
+    return rtn;
+}
+
 int get_key(const char *input, char *key)
 {
    if (!copy_key_by_key(input, key)) {
@ -455,33 +530,6 @@ int build_path(const char *partial_path, const char *prefix, char *full_path, si
    return 0;
 }

-int get_spi_bus_path_number(unsigned int spi)
-{
-  char path[FILENAME_BUFFER_SIZE];
-  char ocp_dir[FILENAME_BUFFER_SIZE];
-
-  build_path("/sys/devices", "ocp", ocp_dir, sizeof(ocp_dir)); BUF2SMALL(ocp_dir);
-
-  if (spi == 0) {
-    snprintf(path, sizeof(path), "%s/48030000.spi/spi_master/spi1", ocp_dir); BUF2SMALL(path);
-  } else {
-    snprintf(path, sizeof(path), "%s/481a0000.spi/spi_master/spi1", ocp_dir); BUF2SMALL(path);
-  }
-
-  DIR* dir = opendir(path);
-  if (dir) {
-    closedir(dir);
-    //device is using /dev/spidev1.x
-    return 1;
-  } else if (ENOENT == errno) {
-    //device is using /dev/spidev2.x
-    return 2;
-  } else {
-    return -1;
-  }
-}
-
-
 // We do not know at compile time how many GPIOs there are, so it is not safe
 // to declare per-GPIO arrays with a static size.  The "dyn_int_array_*"
 // functions implement a dynamic integer array which grows as needed at run
--- a/source/common.h
+++ b/source/common.h
@ -56,6 +56,7 @@ SOFTWARE.
 #define BCM          11
 #define CHIP         0
 #define CHIPPRO      1
+#define BOTH         2

 // In the pins_t structure, the "base_method" field tells how
 // the "gpio" field should be interpreted.
@ -68,11 +69,12 @@ typedef struct pins_t {
    const char *name;
    const char *altname; /* alternate name as referenced on pocketchip pin header */
    const char *key;
+    //const char *altkey; /* alternate key for chip pro */
    int gpio;           /* port number to use under /sys/class/gpio */
    int base_method;    /* modifier for port number; see BASE_METHOD_... */
    int pwm_mux_mode;   /* pwm pin */
    int ain;            /* analog pin */
-    int spwm_allow;     /* pin allowed for software pwm */
+    int sbc_type;     /* which sbc pin is allowed */
 } pins_t;


@ -90,9 +92,13 @@ int DEBUG;

 int get_xio_base(void);
 int gpio_number(pins_t *pin);
+int gpio_pud_capable(pins_t *pin);
 int lookup_gpio_by_key(const char *key);
 int lookup_gpio_by_name(const char *name);
 int lookup_gpio_by_altname(const char *altname);
+int lookup_pud_capable_by_key(const char *key);
+int lookup_pud_capable_by_name(const char *name);
+int lookup_pud_capable_by_altname(const char *altname);
 int lookup_ain_by_key(const char *key);
 int lookup_ain_by_name(const char *name);
 int copy_key_by_key(const char *input_key, char *key);
@ -104,7 +110,6 @@ int get_key(const char *input, char *key);
 int get_pwm_key(const char *input, char *key);
 int get_adc_ain(const char *key, unsigned int *ain);
 int build_path(const char *partial_path, const char *prefix, char *full_path, size_t full_path_len);
-int get_spi_bus_path_number(unsigned int spi);
 void dyn_int_array_set(dyn_int_array_t **in_array, int i, int val, int initial_val);
 int dyn_int_array_get(dyn_int_array_t **in_array, int i, int initial_val);
 void dyn_int_array_delete(dyn_int_array_t **in_array);
@ -112,3 +117,4 @@ void clear_error_msg(void);
 char *get_error_msg(void);
 void add_error_msg(char *msg);
 void toggle_debug(void);
+int compute_port_pin(const char *key, int gpio, int *port, int *pin);
--- a/source/constants.c
+++ b/source/constants.c
@ -88,6 +88,6 @@ void define_constants(PyObject *module)
   module_debug = Py_BuildValue("i", DEBUG ? Py_True: Py_False);
   PyModule_AddObject(module, "DEBUG", module_debug);

-   version = Py_BuildValue("s", "0.3.3");
+   version = Py_BuildValue("s", "0.3.5");
   PyModule_AddObject(module, "VERSION", version);
 }
--- a/source/event_gpio.c
+++ b/source/event_gpio.c
@ -38,17 +38,23 @@ SOFTWARE.

 #include <pthread.h>
 #include <sys/epoll.h>
+#include <sys/mman.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <string.h>
+#include <unistd.h>
+#include <stdint.h>
 #include "event_gpio.h"
 #include "common.h"

 const char *stredge[4] = {"none", "rising", "falling", "both"};

+// Memory Map for PUD
+uint8_t *memmap;
+
 // file descriptors
 struct fdx
 {
@ -85,6 +91,63 @@ dyn_int_array_t *event_occurred = NULL;
 int thread_running = 0;
 int epfd = -1;

+// Thanks to WereCatf and Chippy-Gonzales for the Memory Mapping code/help
+int map_pio_memory()
+{
+    if (DEBUG)
+        printf(" ** map_pio_memory: opening /dev/mem **\n");
+    int fd = open("/dev/mem", O_RDWR|O_SYNC);
+	if(fd < 0) {
+        char err[256];
+        snprintf(err, sizeof(err), "map_pio_memory: could not open /dev/mem (%s)", strerror(errno));
+        add_error_msg(err);
+        return -1;
+	}
+	// uint32_t addr = 0x01c20800 & ~(getpagesize() - 1);
+	//Requires memmap to be on pagesize-boundary
+	if (DEBUG)
+        printf(" ** map_pio_memory: mapping memory **\n");
+	memmap = (uint8_t *)mmap(NULL, getpagesize()*2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x01C20000);
+	if(memmap == NULL) {
+        char err[256];
+        snprintf(err, sizeof(err), "map_pio_memory: mmap failed (%s)", strerror(errno));
+        add_error_msg(err);
+        return -1;
+	}
+	close(fd);
+
+	//Set memmap to point to PIO-registers
+	if (DEBUG)
+        printf(" ** map_pio_memory: moving to pio registers **\n");
+	memmap=memmap+0x800;
+	
+	return 0;
+}
+
+int gpio_get_pud(int port, int pin)
+{
+	if (DEBUG)
+        printf(" ** gpio_get_pud: port %d, pin %d **\n", port, pin);
+	volatile uint32_t *pioMem32, *configRegister;
+	pioMem32=(uint32_t *)(memmap+port*0x24+0x1c); //0x1c == pull-register
+	configRegister=pioMem32+(pin >> 4);
+	return *configRegister >> ((pin & 15) * 2) & 3;
+}
+
+int gpio_set_pud(int port, int pin, uint8_t value)
+{
+	if (DEBUG)
+        printf(" ** gpio_set_pud: port %d, pin %d, value %d **\n", port, pin, value);
+	value &= 3;
+	volatile uint32_t *pioMem32, *configRegister;
+	uint32_t mask;
+	pioMem32=(uint32_t *)(memmap+port*0x24+0x1c); //0x1c == pull-register
+	configRegister=pioMem32+(pin >> 4);
+	mask = ~(3 << ((pin & 15) * 2));
+	*configRegister &= mask;
+	*configRegister |= value << ((pin & 15) * 2);
+	return 0;
+}

 int gpio_export(int gpio)
 {
@ -443,8 +506,7 @@ int gpio_get_value(int gpio, unsigned int *value)
    int fd = fd_lookup(gpio);
    char ch;

-    if (!fd)
-    {
+    if (!fd) {
        if ((fd = open_value_file(gpio)) == -1) {
            char err[256];
            snprintf(err, sizeof(err), "gpio_get_value: could not open GPIO %d value file", gpio);
@ -484,6 +546,58 @@ int gpio_get_value(int gpio, unsigned int *value)
    return 0;
 }

+int gpio_get_more(int gpio, int bits, unsigned int *value)
+{
+    int fd = fd_lookup(gpio);
+    char ch;
+    
+    if (!fd) {
+        if ((fd = open_value_file(gpio)) == -1) {
+            char err[256];
+            snprintf(err, sizeof(err), "gpio_get_more: could not open GPIO %d value file", gpio);
+            add_error_msg(err);
+            return -1;
+        }
+    }
+
+    // Loop for our number of bits
+    int i;
+    for (i = 0; i < bits; i++) {
+
+        if (lseek(fd, 0, SEEK_SET) < 0) {
+            char err[256];
+            snprintf(err, sizeof(err), "gpio_get_more: could not seek GPIO %d (%s)", gpio, strerror(errno));
+            add_error_msg(err);
+            return -1;
+        }
+        ssize_t s = read(fd, &ch, sizeof(ch));
+        if (s < 0) {
+            char err[256];
+            snprintf(err, sizeof(err), "gpio_get_more: could not read GPIO %d (%s)", gpio, strerror(errno));
+            add_error_msg(err);
+            return -1;
+        }
+    
+        if (ch == '1') {
+            *value |= (1 << i);
+        } else if (ch == '0') {
+            *value |= (0 << i);
+        } else {
+            char err[256];
+            snprintf(err, sizeof(err), "gpio_get_more: unrecognized read GPIO %d (%c)", gpio, ch);
+            add_error_msg(err);
+            return -1;
+        }
+        if (DEBUG) {
+            printf(" ** gpio_get_more: %c **\n", ch);
+            printf(" ** gpio_get_more: current value: %u **\n", *value);
+        }
+    }
+
+    return 0;
+    
+}
+
 int gpio_set_edge(int gpio, unsigned int edge)
 {
    int fd;
--- a/source/event_gpio.h
+++ b/source/event_gpio.h
@ -36,6 +36,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */

+#include <stdint.h>
+
 #define NO_EDGE      0
 #define RISING_EDGE  1
 #define FALLING_EDGE 2
@ -54,6 +56,12 @@ SOFTWARE.
 #define PUD_DOWN 1
 #define PUD_UP   2

+extern uint8_t *memmap;
+
+int map_pio_memory(void);
+int gpio_get_pud(int port, int pin);
+int gpio_set_pud(int port, int pin, uint8_t value);
+
 int gpio_export(int gpio);
 int gpio_unexport(int gpio);
 void exports_cleanup(void);
@ -61,6 +69,7 @@ int gpio_set_direction(int gpio, unsigned int in_flag);
 int gpio_get_direction(int gpio, unsigned int *value);
 int gpio_set_value(int gpio, unsigned int value);
 int gpio_get_value(int gpio, unsigned int *value);
+int gpio_get_more(int gpio, int bits, unsigned int *value);
 int fd_lookup(int gpio);
 int open_value_file(int gpio);

--- a/source/py_gpio.c
+++ b/source/py_gpio.c
@ -58,14 +58,34 @@ struct py_callback
 };
 static struct py_callback *py_callbacks = NULL;

+// python function toggle_debug()
+static PyObject *py_toggle_debug(PyObject *self, PyObject *args)
+{
+    // toggle debug printing
+    toggle_debug();
+
+    Py_RETURN_NONE;
+}
+
 static int init_module(void)
 {
+    clear_error_msg();
+    
+    if (map_pio_memory() < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "init_module error (%s)", get_error_msg());
+        PyErr_SetString(PyExc_RuntimeError, err);
+        return 0;
+    }
+
+    // If we make it here, we're good to go
+    if (DEBUG)
+        printf(" ** init_module: setup complete **\n");
    module_setup = 1;

    return 0;
 }

-
 static void remember_gpio_direction(int gpio, int direction)
 {
    dyn_int_array_set(&gpio_direction, gpio, direction, -1);
@ -93,14 +113,11 @@ static PyObject *py_cleanup(PyObject *self, PyObject *args, PyObject *kwargs)
    }

    // The !channel fixes issues #50
-    if (!channel || strcmp(channel, "") == 0) {
+    if (channel == NULL || strcmp(channel, "\0") == 0) {
        event_cleanup();
    } else {
        if (get_gpio_number(channel, &gpio) < 0) {
-            char err[2000];
-            snprintf(err, sizeof(err), "Invalid channel %s. (%s)", channel, get_error_msg());
-            PyErr_SetString(PyExc_ValueError, err);
-            return NULL;
+            event_cleanup();
        }
        gpio_unexport(gpio);
    }
@ -127,15 +144,16 @@ static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwar
        init_module();
    }
 
-
    if (direction != INPUT && direction != OUTPUT)
    {
        PyErr_SetString(PyExc_ValueError, "An invalid direction was passed to setup()");
        return NULL;
    }
    
-   if (direction == OUTPUT)
+    // Force pud to be off if we're configured for output
+    if (direction == OUTPUT) {
        pud = PUD_OFF;
+    }
 
    if (pud != PUD_OFF && pud != PUD_DOWN && pud != PUD_UP)
    {
@ -162,6 +180,23 @@ static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwar
        PyErr_SetString(PyExc_RuntimeError, err);
        return NULL;
    }
+    
+    // Pull Up/Down
+    // Only if the pin we want is able to use it (R8 Owned, no XIO)
+    int port, pin;
+    if (compute_port_pin(channel, gpio, &port, &pin) == 0) {
+        // Set the PUD
+        gpio_set_pud(port, pin, pud);
+        // Check it was set properly
+        int pudr = gpio_get_pud(port, pin);
+        if (pudr != pud) {
+            char err[2000];
+            snprintf(err, sizeof(err), "Error setting pull up down %d on channel %s", pud, channel);
+            PyErr_SetString(PyExc_RuntimeError, err);
+            return NULL;
+        }
+    }
+    
    if (direction == OUTPUT) {
        if (gpio_set_value(gpio, initial) < 0) {
            char err[2000];
@ -251,6 +286,83 @@ static PyObject *py_input_gpio(PyObject *self, PyObject *args)
    return py_value;
 }

+//TODO: Come up with a way to merge py_read_byte_gpio and py_read_word_gpio
+// python function value = read_byte(channel)
+static PyObject *py_read_byte_gpio(PyObject *self, PyObject *args)
+{
+    int gpio;
+    char *channel;
+    unsigned int value = 0;
+    PyObject *py_value;
+
+    clear_error_msg();
+
+    if (!PyArg_ParseTuple(args, "s", &channel))
+        return NULL;
+
+    if (get_gpio_number(channel, &gpio)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid channel");
+        return NULL;
+    }
+
+   // check channel is set up as an input or output
+    if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1))
+    {
+        PyErr_SetString(PyExc_RuntimeError, "You must setup() the GPIO channel first");
+        return NULL;
+    }
+
+    // We only want to get a 8 bits here
+    if (gpio_get_more(gpio, 8, &value) < 0) {
+      char err[1024];
+      snprintf(err, sizeof(err), "Could not get 8 bits of data ('%s')", get_error_msg());
+      PyErr_SetString(PyExc_RuntimeError, err);
+      return NULL;
+    }
+
+    py_value = Py_BuildValue("i", value);
+
+    return py_value;
+}
+
+// python function value = read_word(channel)
+static PyObject *py_read_word_gpio(PyObject *self, PyObject *args)
+{
+    int gpio;
+    char *channel;
+    unsigned int value = 0;
+    PyObject *py_value;
+
+    clear_error_msg();
+
+    if (!PyArg_ParseTuple(args, "s", &channel))
+        return NULL;
+
+    if (get_gpio_number(channel, &gpio)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid channel");
+        return NULL;
+    }
+
+   // check channel is set up as an input or output
+    if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1))
+    {
+        PyErr_SetString(PyExc_RuntimeError, "You must setup() the GPIO channel first");
+        return NULL;
+    }
+
+    // We only want to get a 8 bits here
+    if (gpio_get_more(gpio, 16, &value) < 0) {
+      char err[1024];
+      snprintf(err, sizeof(err), "Could not get 16 bits of data ('%s')", get_error_msg());
+      PyErr_SetString(PyExc_RuntimeError, err);
+      return NULL;
+    }
+
+    py_value = Py_BuildValue("i", value);
+
+    return py_value;
+}
+
 static void run_py_callbacks(int gpio, void* data)
 {
   PyObject *result;
@ -743,10 +855,6 @@ static PyObject *py_selftest(PyObject *self, PyObject *args)
  ASSRT(0 == build_path("/home", "ip", fp, sizeof(fp)));
  ASSRT(0 == build_path("/NOTFOUND", "ch", fp, sizeof(fp)));

-  printf("Testing get_spi_bus_path_number\n");
-  ASSRT(2 == get_spi_bus_path_number(0));  /* doesn't really work on CHIP */
-  ASSRT(2 == get_spi_bus_path_number(1));  /* doesn't really work on CHIP */
-
  printf("Testing error message buffer\n");
  clear_error_msg();
  ASSRT(0 == strlen(get_error_msg()));
@ -825,6 +933,8 @@ PyMethodDef gpio_methods[] = {
   {"cleanup", (PyCFunction)py_cleanup, METH_VARARGS | METH_KEYWORDS, "Clean up by resetting all GPIO channels that have been used by this program to INPUT with no pullup/pulldown and no event detection"},
   {"output", py_output_gpio, METH_VARARGS, "Output to a GPIO channel\ngpio  - gpio channel\nvalue - 0/1 or False/True or LOW/HIGH"},
   {"input", py_input_gpio, METH_VARARGS, "Input from a GPIO channel.  Returns HIGH=1=True or LOW=0=False\ngpio - gpio channel"},
+   {"read_byte", py_read_byte_gpio, METH_VARARGS, "Read a byte (8 bits) from a set of GPIO channels. Returns 8-bits of integer data\ngpio - gpio channel."},
+   {"read_word", py_read_word_gpio, METH_VARARGS, "Read a word (16 bits) from a set of GPIO channels. Returns 16-bits of integer data\ngpio - gpio channel."},
   {"add_event_detect", (PyCFunction)py_add_event_detect, METH_VARARGS | METH_KEYWORDS, "Enable edge detection events for a particular GPIO channel.\nchannel      - either board pin number or BCM number depending on which mode is set.\nedge         - RISING, FALLING or BOTH\n[callback]   - A callback function for the event (optional)\n[bouncetime] - Switch bounce timeout in ms for callback"},
   {"remove_event_detect", py_remove_event_detect, METH_VARARGS, "Remove edge detection for a particular GPIO channel\ngpio - gpio channel"},
   {"event_detected", py_event_detected, METH_VARARGS, "Returns True if an edge has occured on a given GPIO.  You need to enable edge detection using add_event_detect() first.\ngpio - gpio channel"},
@ -836,6 +946,7 @@ PyMethodDef gpio_methods[] = {
   {"selftest", py_selftest, METH_VARARGS, "Internal unit tests"},
   {"direction", (PyCFunction)py_set_direction, METH_VARARGS | METH_KEYWORDS, "Change direction of gpio channel. Either INPUT or OUTPUT\n" },
   {"setmode", (PyCFunction)py_setmode, METH_VARARGS, "Dummy function that does nothing but maintain compatibility with RPi.GPIO\n" },
+   {"toggle_debug", py_toggle_debug, METH_VARARGS, "Toggles the enabling/disabling of Debug print output"},
   {NULL, NULL, 0, NULL}
 };

--- a/source/py_pwm.c
+++ b/source/py_pwm.c
@ -73,14 +73,12 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
        return NULL;
    }

-    if (duty_cycle < 0.0 || duty_cycle > 100.0)
-    {
+    if (duty_cycle < 0.0 || duty_cycle > 100.0) {
        PyErr_SetString(PyExc_ValueError, "duty_cycle must have a value from 0.0 to 100.0");
        return NULL;
    }

-    if (frequency <= 0.0)
-    {
+    if (frequency <= 0.0) {
        PyErr_SetString(PyExc_ValueError, "frequency must be greater than 0.0");
        return NULL;
    }
@ -90,8 +88,12 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
        return NULL;
    }

-    if (!pwm_start(key, duty_cycle, frequency, polarity))
+    if (pwm_start(key, duty_cycle, frequency, polarity) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "Unable to start PWM: %s (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
        return NULL;
+    }

    Py_RETURN_NONE;
 }
@ -112,7 +114,12 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
        return NULL;
    }

-    pwm_disable(key);
+    if (pwm_disable(key) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
+        return NULL;
+    }

    Py_RETURN_NONE;
 }
@ -130,8 +137,7 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", kwlist, &channel, &duty_cycle))
        return NULL;

-    if (duty_cycle < 0.0 || duty_cycle > 100.0)
-    {
+    if (duty_cycle < 0.0 || duty_cycle > 100.0) {
        PyErr_SetString(PyExc_ValueError, "duty_cycle must have a value from 0.0 to 100.0");
        return NULL;
    }
@ -142,7 +148,9 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
    }

    if (pwm_set_duty_cycle(key, duty_cycle) == -1) {
-        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
+        char err[2000];
+        snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
        return NULL;
    }

@ -170,20 +178,20 @@ static PyObject *py_set_pulse_width_ns(PyObject *self, PyObject *args, PyObject

    // Get the period out of the data struct
    int rtn = pwm_get_period_ns(key, &period_ns);
-    if (rtn == -1)
-    {
+    if (rtn == -1) {
        PyErr_SetString(PyExc_ValueError, "period unable to be obtained");
        return NULL;
    }

-	if (pulse_width_ns < 0.0 || pulse_width_ns > period_ns)
-    {
+	if (pulse_width_ns < 0.0 || pulse_width_ns > period_ns) {
        PyErr_SetString(PyExc_ValueError, "pulse width must have a value from 0 to period");
        return NULL;
    }

-    if (pwm_set_pulse_width_ns(key, pulse_width_ns) == -1) {
-        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
+    if (pwm_set_pulse_width_ns(key, pulse_width_ns) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
        return NULL;
    }

@ -203,8 +211,7 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", kwlist, &channel, &frequency))
        return NULL;

-    if (frequency <= 0.0)
-    {
+    if (frequency <= 0.0) {
        PyErr_SetString(PyExc_ValueError, "frequency must be greater than 0.0");
        return NULL;
    }
@ -214,8 +221,10 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
        return NULL;
    }

-    if (pwm_set_frequency(key, frequency) == -1) {
-        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
+    if (pwm_set_frequency(key, frequency) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
        return NULL;
    }

@ -235,8 +244,7 @@ static PyObject *py_set_period_ns(PyObject *self, PyObject *args, PyObject *kwar
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|k", kwlist, &channel, &period_ns))
        return NULL;

-    if (period_ns <= 0)
-    {
+    if (period_ns <= 0) {
        PyErr_SetString(PyExc_ValueError, "period must be greater than 0ns");
        return NULL;
    }
@ -246,8 +254,10 @@ static PyObject *py_set_period_ns(PyObject *self, PyObject *args, PyObject *kwar
        return NULL;
    }

-    if (pwm_set_period_ns(key, period_ns) == -1) {
-        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
+    if (pwm_set_period_ns(key, period_ns) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
        return NULL;
    }

--- a/source/py_softpwm.c
+++ b/source/py_softpwm.c
@ -34,6 +34,15 @@ SOFTWARE.
 #include "common.h"
 #include "c_softpwm.h"

+// python function toggle_debug()
+static PyObject *py_toggle_debug(PyObject *self, PyObject *args)
+{
+    // toggle debug printing
+    toggle_debug();
+
+    Py_RETURN_NONE;
+}
+
 // python function cleanup(channel=None)
 static PyObject *py_cleanup(PyObject *self, PyObject *args)
 {
@ -48,12 +57,12 @@ static PyObject *py_cleanup(PyObject *self, PyObject *args)
        return NULL;
                    
    // The !channel fixes issue #50
-    if (!channel || strcmp(channel, "") == 0) {
+    if (channel == NULL || strcmp(channel, "\0") == 0) {
        softpwm_cleanup();
+        return NULL;
    } else {
        if (!get_key(channel, key)) {
-            PyErr_SetString(PyExc_ValueError, "Invalid SOFTPWM key or name.");
-            return NULL;
+            softpwm_cleanup();
        }
        softpwm_disable(key);
    }
@ -83,14 +92,12 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
        return NULL;
    }

-    if (duty_cycle < 0.0 || duty_cycle > 100.0)
-    {
+    if (duty_cycle < 0.0 || duty_cycle > 100.0) {
        PyErr_SetString(PyExc_ValueError, "duty_cycle must have a value from 0.0 to 100.0");
        return NULL;
    }

-    if (frequency <= 0.0)
-    {
+    if (frequency <= 0.0) {
        PyErr_SetString(PyExc_ValueError, "frequency must be greater than 0.0");
        return NULL;
    }
@ -100,8 +107,7 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
        return NULL;
    }

-    if (softpwm_start(key, duty_cycle, frequency, polarity) < 0)
-    {
+    if (softpwm_start(key, duty_cycle, frequency, polarity) < 0) {
       printf("softpwm_start failed");
       char err[2000];
       snprintf(err, sizeof(err), "Error starting softpwm on pin %s (%s)", key, get_error_msg());
@ -146,8 +152,7 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", kwlist, &channel, &duty_cycle))
        return NULL;

-    if (duty_cycle < 0.0 || duty_cycle > 100.0)
-    {
+    if (duty_cycle < 0.0 || duty_cycle > 100.0) {
        PyErr_SetString(PyExc_ValueError, "duty_cycle must have a value from 0.0 to 100.0");
        return NULL;
    }
@ -178,8 +183,7 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", kwlist, &channel, &frequency))
        return NULL;

-    if ((frequency <= 0.0) || (frequency > 10000.0))
-    {
+    if ((frequency <= 0.0) || (frequency > 10000.0)) {
        PyErr_SetString(PyExc_ValueError, "frequency must be greater than 0.0 and less than 10000.0");
        return NULL;
    }
@ -205,6 +209,7 @@ PyMethodDef pwm_methods[] = {
    {"set_duty_cycle", (PyCFunction)py_set_duty_cycle, METH_VARARGS, "Change the duty cycle\ndutycycle - between 0.0 and 100.0" },
    {"set_frequency", (PyCFunction)py_set_frequency, METH_VARARGS, "Change the frequency\nfrequency - frequency in Hz (freq > 0.0)" },
    {"cleanup", (PyCFunction)py_cleanup, METH_VARARGS, "Clean up by resetting all GPIO channels that have been used by this program to INPUT with no pullup/pulldown and no event detection"},
+    {"toggle_debug", py_toggle_debug, METH_VARARGS, "Toggles the enabling/disabling of Debug print output"},
    {NULL, NULL, 0, NULL}
 };
Author	SHA1	Message	Date
Robert Wolterman	cd85e2b5eb	cleanup of brettcvz's read_byte function, added read_word since he really needs 12 bits of data. finally fixed the gpio cleanup() without argument issue once and for all, sorry for lying howientc	2017-01-29 22:58:41 +00:00
Robert Wolterman	6beacbb382	Merge pull request #59 from brettcvz/master Added the ability to read a full byte from a set of channels	2017-01-29 15:21:26 -06:00
Brett van Zuiden	a498fc12bd	Added the ability to read a full byte from a set of channels For example, you can hook up to the 8 XIO pins and 8 CSID pins to read a word in just two calls: `GPIO.read_byte("XIO") + GPIO.read_byte("CSID") << 8` For fast-changing inputs (e.g. reading from a counter), this is more accurate than reading the bits individually.	2017-01-29 12:32:53 -08:00
Robert Wolterman	2e2177da26	quick fix because i broke xio input setup with the pud code, this closes #58	2017-01-29 20:21:02 +00:00
Robert Wolterman	541d76f641	updating readme to remove the commands that remove the source directory.	2017-01-29 20:10:09 +00:00
Robert Wolterman	2b23e2d165	pull up/down feature addition to close #48 . fixed gpio cleanup() function again, 3rd time is a charm. version bump to 0.3.4	2017-01-29 03:50:37 +00:00
Robert Wolterman	a839661c3b	randomness for #32 and #48 . cleanup of removing the spi function in common.c/.h since it isn't chip specific	2017-01-28 20:05:53 +00:00
Robert Wolterman	cb4e272a35	adding the code to py_pwm.c to get the error data out of c_pwm.c. general code cleanup. this should close #56 as the softpwm code had the error string support already in it	2017-01-28 19:04:31 +00:00
Robert Wolterman	05b936ca1d	added error string info (a la gpio) to the pwm code for #56	2017-01-28 18:50:09 +00:00