quick fix because i broke xio input setup with the pud code, this closes #58

Updated rpigpiomodule to chipgpiomodule so python3 compile works

CHANGELOG.rst

@@ -1,3 +1,34 @@
+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
+* Added 2 functions from @streamnsight for PWM that allow for setting the period of the PWM and the Pulse Width, both in nanoseconds
+* Fixed the SPI2 overlay stuff by using the NTC overlay instead of mine.
+
+0.3.2
+----
+* Fixing issue #53 to handle the return values of the set functions in pwm_enable.
+* Start of whole library debug for #55
+
+0.3.1
+----
+* Fixing issue #50 where I broke GPIO.cleanup() and SOFTPWM.cleanup() when no input is specified.
+
+0.3.0
+----
+* Added setmode() function for GPIO to maintain compatibility with Raspberry Pi scripts, this function literally does nothing
+* Added per pin cleanup functionality for GPIO and SoftPWM so you can unexport a pin without unexporting every pin
+* Updated README to make edge detection wording a little better and to add the per pin cleanup code
+* Version update since I blasted through 3 issues on github and feel like we need a nice bump to 0.3
+
 0.2.7
 ----
 * Fix to the Enable 1.8V Pin code as it wasn't working due to bit shifting isn't allowed on a float.

CHIP_IO/LRADC.py

@@ -42,9 +42,12 @@ CURRENT_SAMPLE_RATE_FILE = "/in_voltage_sampling_frequency"
 RAW_VOLTAGE_CHAN0_FILE = "/in_voltage0_raw"
 RAW_VOLTAGE_CHAN1_FILE = "/in_voltage1_raw"
 
-def enable_debug():
+def toggle_debug():
     global DEBUG
-    DEBUG = True
+    if DEBUG:
+        DEBUG = False
+    else:
+        DEBUG = True
 
 def setup(rate=250):
     # First we determine if the device exists
@@ -75,7 +78,7 @@ def get_scale_factor():
 
     # Debug
     if DEBUG:
-        print("Current LRADC Scaling Factor: {0}").format(SCALE_FACTOR)
+        print("lradc.get_scale_factor: {0}".format(SCALE_FACTOR))
 
     return SCALE_FACTOR
 
@@ -91,7 +94,7 @@ def get_allowable_sample_rates():
 
     global SAMPLE_RATES
     tmp = dat.strip().split(" ")
-    for i in xrange(len(tmp)):
+    for i in range(len(tmp)):
         if "." in tmp[i]:
             tmp[i] = float(tmp[i])
         else:
@@ -100,9 +103,9 @@ def get_allowable_sample_rates():
 
     # Debug
     if DEBUG:
-        print("Allowable Sampling Rates:")
+        print("lradc.get_allowable_sample_rates:")
         for rate in SAMPLE_RATES:
-            print("{0}").format(rate)
+            print("{0}".format(rate))
 
     return tuple(SAMPLE_RATES)
 
@@ -111,10 +114,6 @@ def set_sample_rate(rate):
     if not DEVICE_EXIST:
         raise Exception("LRADC Device does not exist")
 
-    # Debug
-    if DEBUG:
-        print("Setting Sample Rate to: {0}").format(rate)
-
     # Check to see if the rates were gathered already
     global SAMPLE_RATES
     if SAMPLE_RATES == []:
@@ -124,6 +123,10 @@ def set_sample_rate(rate):
     if rate not in SAMPLE_RATES:
         raise ValueError("Input Rate an Acceptable Value")
 
+    # Debug
+    if DEBUG:
+        print("lradc.set_sample_rate: {0}".format(rate))
+
     # Write the rate
     f = open(LRADC_BASE_DEVICE_FILE+CURRENT_SAMPLE_RATE_FILE,"w")
     mystr = "%.2f" % rate
@@ -153,7 +156,7 @@ def get_sample_rate():
 
     # Debug
     if DEBUG:
-        print("Current Sampling Rate: {0}").format(dat)
+        print("lradc.get_sample_rate: {0}".format(dat))
 
     return dat
 
@@ -171,7 +174,7 @@ def get_chan0_raw():
 
     # Debug
     if DEBUG:
-        print("CHAN0 RAW: {0}").format(dat)
+        print("lradc.get_chan0_raw: {0}".format(dat))
 
     return dat
 
@@ -189,7 +192,7 @@ def get_chan1_raw():
 
     # Debug
     if DEBUG:
-        print("CHAN1 RAW: {0}").format(dat)
+        print("lradc.get_chan1_raw: {0}".format(dat))
 
     return dat
 
@@ -205,7 +208,7 @@ def get_chan0():
 
     # Debug
     if DEBUG:
-        print("CHAN0: {0}").format(dat)
+        print("lradc.get_chan0: {0}".format(dat))
 
     return dat
 
@@ -221,7 +224,7 @@ def get_chan1():
 
     # Debug
     if DEBUG:
-        print("CHAN1: {0}").format(dat)
+        print("lradc.get_chan1: {0}".format(dat))
 
     return dat
 

CHIP_IO/OverlayManager.py

@@ -24,6 +24,7 @@ import time
 DEBUG = False
 
 OVERLAYINSTALLPATH = "/lib/firmware/chip_io"
+SPIINSTALLPATH = "/lib/firmware/nextthingco/chip"
 OVERLAYCONFIGPATH  = "/sys/kernel/config/device-tree/overlays"
 CUSTOMOVERLAYFILEPATH = ""
 
@@ -41,7 +42,7 @@ _LOADED = {
 }
 
 _OVERLAYS = {
-  "SPI2" : "chip-spi2.dtbo",
+  "SPI2" : "sample-spi.dtbo",
   "PWM0" : "chip-pwm0.dtbo",
   "CUST" : ""
 }
@@ -52,9 +53,12 @@ _FOLDERS = {
   "CUST" : "chip-cust"
 }
 
-def enable_debug():
+def toggle_debug():
     global DEBUG
-    DEBUG = True
+    if DEBUG:
+        DEBUG = False
+    else:
+        DEBUG = True
 
 def get_spi_loaded():
     """
@@ -157,7 +161,11 @@ def load(overlay, path=""):
 
         # SET UP THE OVERLAY PATH FOR OUR USE
         if overlay.upper() != "CUST":
-            opath = OVERLAYINSTALLPATH + "/" + _OVERLAYS[overlay.upper()]
+            opath = OVERLAYINSTALLPATH
+            # IF THE OVERLAY IS SPI, USE THE NTC PATH
+            if overlay.upper() == "SPI2":
+                opath = SPIINSTALLPATH
+            opath += "/" + _OVERLAYS[overlay.upper()]
         else:
             opath = path
         if DEBUG:

CHIP_IO/Utilities.py

@@ -28,6 +28,16 @@ import subprocess
 import glob
 import re
 
+# Global Variables
+DEBUG = False
+
+def toggle_debug():
+    global DEBUG
+    if DEBUG:
+        DEBUG = False
+    else:
+        DEBUG = True
+
 # Set the 1.8V-pin on the CHIP U13-header to given voltage
 # Return False on error
 def set_1v8_pin_voltage(voltage):
@@ -35,10 +45,16 @@ def set_1v8_pin_voltage(voltage):
         return False
     if voltage < 1.8 or voltage > 3.3:
         return False
+    if DEBUG:
+        print("Setting 1.8V Pin voltage: {0}".format(voltage))
     voltage=int(round((voltage - 1.8) / 0.1)) << 4
     if subprocess.call(["/usr/sbin/i2cset", "-f", "-y" ,"0", "0x34", "0x90", "0x03"]):
+        if DEBUG:
+            print("Pin enable command failed")
         return False
     if subprocess.call(["/usr/sbin/i2cset", "-f", "-y", "0", "0x34", "0x91", str(voltage)]):
+        if DEBUG:
+            print("Pin set voltage command failed")
         return False
     return True
 
@@ -49,10 +65,14 @@ def get_1v8_pin_voltage():
     output=p.communicate()[0].decode("utf-8").strip()
     #Not configured as an output
     if output != "0x03":
+        if DEBUG:
+            print("1.8V Pin is currently disabled")
         return False
     p=subprocess.Popen(["/usr/sbin/i2cget", "-f", "-y", "0", "0x34", "0x91"], stdout=subprocess.PIPE)
     output=p.communicate()[0].decode("utf-8").strip()
     voltage=round((int(output, 16) >> 4) * 0.1 + 1.8, 1)
+    if DEBUG:
+        print("Current 1.8V Pin voltage: {0}".format(voltage))
     return voltage
 
 # Enable 1.8V Pin on CHIP U13 Header
@@ -61,6 +81,8 @@ def enable_1v8_pin():
 
 # Disable 1.8V Pin on CHIP U13 Header
 def disable_1v8_pin():
+    if DEBUG:
+        print("Disabling the 1.8V Pin")
     # CANNOT USE I2C LIB AS WE NEED TO FORCE THE COMMAND DUE TO THE KERNEL OWNING THE DEVICE
     # First we have to write 0x05 to AXP-209 Register 0x91
     subprocess.call('/usr/sbin/i2cset -f -y 0 0x34 0x91 0x05', shell=True)
@@ -69,6 +91,8 @@ def disable_1v8_pin():
 
 # Unexport All
 def unexport_all():
+    if DEBUG:
+        print("Unexporting all the pins")
     gpios = glob.glob("/sys/class/gpio/gpio[0-9]*")
     for g in gpios:
         tmp = g.split("/")

README.rst

@@ -9,8 +9,8 @@ Manual::
 For Python2.7::
 
     sudo apt-get update
-    sudo apt-get install git build-essential python-dev python-pip flex bison -y
-    git clone https://github.com/atenart/dtc
+    sudo apt-get install git build-essential python-dev python-pip flex bison chip-dt-overlays -y
+    git clone https://github.com/atenart/dtc.git
     cd dtc
     make
     sudo  make install PREFIX=/usr
@@ -19,13 +19,12 @@ For Python2.7::
     cd CHIP_IO
     sudo python setup.py install
     cd ..
-    sudo rm -rf CHIP_IO
 
 For Python3::
 
     sudo apt-get update
-    sudo apt-get install git build-essential python3-dev python3-pip flex bison -y
-    git clone https://github.com/atenart/dtc
+    sudo apt-get install git build-essential python3-dev python3-pip flex bison chip-dt-overlays -y
+    git clone https://github.com/atenart/dtc.git
     cd dtc
     make
     sudo  make install PREFIX=/usr
@@ -34,7 +33,6 @@ For Python3::
     cd CHIP_IO
     sudo python3 setup.py install
     cd ..
-    sudo rm -rf CHIP_IO
 
 **Usage**
 
@@ -169,6 +167,13 @@ You can also refer to the bin based upon its alternate name::
 
     GPIO.setup("GPIO1", GPIO.IN)
 
+**GPIO Debug**
+
+Debug can be enabled/disabled by the following command::
+
+    # Enable Debug
+    GPIO.toggle_debug()
+
 **GPIO Output**
 
 Setup the pin for output, and write GPIO.HIGH or GPIO.LOW. Or you can use 1 or 0.::
@@ -184,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"):
@@ -191,12 +205,12 @@ Polling inputs::
     else:
         print("LOW")
 
+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::
 
     GPIO.wait_for_edge(channel, GPIO.RISING)
 
-This only works for the AP-EINT1, AP-EINT3, and XPO Pins on the CHIP
-
 Detecting events::
 
     GPIO.setup("XIO-P0", GPIO.IN)
@@ -206,17 +220,38 @@ Detecting events::
     if GPIO.event_detected("XIO-P0"):
         print "event detected!"
 
+CHIP_IO can also handle adding callback functions on any pin that supports edge detection.::
+
+    def mycallback(channel):
+        print("we hit the edge we want")
+
+    GPIO.setup("GPIO3", GPIO.IN)
+    # Add Callback: Falling Edge
+    GPIO.add_event_callback("GPIO3", GPIO.FALLING, mycallback)
+    # Add Callback: Rising Edge
+    GPIO.add_event_callback("GPIO3", GPIO.RISING, mycallback)
+    # Add Callback: Both Edges
+    GPIO.add_event_callback("GPIO3", GPIO.BOTH, mycallback)
+    # Remove callback
+    GPIO.remove_event_detect("GPIO3")
+
+
 **GPIO Cleanup**
 
 To clean up the GPIO when done, do the following::
 
+    # Clean up every exported GPIO Pin
     GPIO.cleanup()
+    # Clean up a single pin (keeping everything else intact)
+    GPIO.cleanup("XIO-P0")
 
 **PWM**::
 
 Hardware PWM requires a DTB Overlay loaded on the CHIP to allow the kernel to know there is a PWM device available to use.
 ::
     import CHIP_IO.PWM as PWM
+    # Enable/Disable Debug
+    PWM.toggle_debug()
     #PWM.start(channel, duty, freq=2000, polarity=0)
     #duty values are valid 0 (off) to 100 (on)
     PWM.start("PWM0", 50)
@@ -231,6 +266,8 @@ Hardware PWM requires a DTB Overlay loaded on the CHIP to allow the kernel to kn
 **SOFTPWM**::
 
     import CHIP_IO.SOFTPWM as SPWM
+    # Enable/Disable Debug
+    SPWM.toggle_debug()
     #SPWM.start(channel, duty, freq=2000, polarity=0)
     #duty values are valid 0 (off) to 100 (on)
     #you can choose any pin
@@ -239,7 +276,10 @@ Hardware PWM requires a DTB Overlay loaded on the CHIP to allow the kernel to kn
     SPWM.set_frequency("XIO-P7", 10)
     # To Stop SPWM
     SPWM.stop("XIO-P7")
+    # Cleanup can have no argument to clean up all SoftPWM outputs
     SPWM.cleanup()
+    # Or you can specify a single SoftPWM output to cleanup (keeping the rest intact)
+    SPWM.cleanup("XIO-P7")
     #For specific polarity: this example sets polarity to 1 on start:
     SPWM.start("XIO-P7", 50, 2000, 1)
 
@@ -253,8 +293,8 @@ The LRADC was enabled in the 4.4.13-ntc-mlc.  This is a 6 bit ADC that is 2 Volt
 Sample code below details how to talk to the LRADC.::
 
     import CHIP_IO.LRADC as ADC
-    # Enable Debug
-    ADC.enable_debug()
+    # Enable/Disable Debug
+    ADC.toggle_debug()
     # Check to see if the LRADC Device exists
     # Returns True/False
     ADC.get_device_exists()
@@ -288,8 +328,8 @@ PWM0, SPI2, I2C1, CUST
 Only one of each type of overlay can be loaded at a time, but all three options can be loaded simultaneously.  So you can have SPI2 and I2C1 without PWM0, but you cannot have SPI2 loaded twice.
 ::
     import CHIP_IO.OverlayManager as OM
-    # The enable_debug() function turns on debug printing
-    #OM.enable_debug()
+    # The toggle_debug() function turns on/off debug printing
+    #OM.toggle_debug()
     # To load an overlay, feed in the name to load()
     OM.load("PWM0")
     # To verify the overlay was properly loaded, the get_ functions return booleans
@@ -318,6 +358,8 @@ CHIP_IO now supports the ability to enable and disable the 1.8V port on U13.  Th
 To use the utilities, here is sample code::
 
     import CHIP_IO.Utilities as UT
+    # Enable/Disable Debug
+    UT.toggle_debug()
     # Enable 1.8V Output
     UT.enable_1v8_pin()
     # Set 2.0V Output
@@ -337,11 +379,19 @@ To use the utilities, here is sample code::
 
 Install py.test to run the tests. You'll also need the python compiler package for py.test.::
 
+    # Python 2.7
     sudo apt-get install python-pytest
+    # Python 3
+    sudo apt-get install python3-pytest
 
-Execute the following in the root of the project::
+To run the tests, do the following.::
 
+    # If only one version of Python is installed
     sudo py.test
+    # If more than one version of Python
+    cd test
+    sudo python2 -m pytest
+    sudo python3 -m pytest
 
 **Credits**
 

overlays/builder.py

@@ -6,7 +6,6 @@ import sys
 
 def compile():
     print("Compiling DTS Files")
-    call(["dtc", "-O", "dtb", "-o", "overlays/chip-spi2.dtbo", "-b", "o", "-@", "overlays/chip-spi2.dts"])
     call(["dtc", "-O", "dtb", "-o", "overlays/chip-pwm0.dtbo", "-b", "o", "-@", "overlays/chip-pwm0.dts"])
 
 def copy():
@@ -20,5 +19,4 @@ def copy():
     for fl in glob.glob(overlay_path+"/chip-*-.dtbo"):
         os.remove(fl)
     print("Moving DTBO files to "+overlay_path)
-    shutil.move("overlays/chip-spi2.dtbo", overlay_path+"/chip-spi2.dtbo")
     shutil.move("overlays/chip-pwm0.dtbo", overlay_path+"/chip-pwm0.dtbo")

overlays/chip-spi2.dts

@@ -1,93 +0,0 @@
-/*
- * Copyright 2016, Robert Wolterman
- * This file is an amalgamation of stuff from Kolja Windeler, Maxime Ripard, and Renzo.
- *
- * This file is dual-licensed: you can use it either under the terms
- * of the GPL or the X11 license, at your option. Note that this dual
- * licensing only applies to this file, and not this project as a
- * whole.
- *
- *  a) This file 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 2 of the
- *     License, or (at your option) any later version.
- *
- *     This file 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.
- *
- * Or, alternatively,
- *
- *  b) Permission is hereby granted, free of charge, to any person
- *     obtaining a copy of this software and associated documentation
- *     files (the "Software"), to deal in the Software without
- *     restriction, including without limitation the rights to use,
- *     copy, modify, merge, publish, distribute, sublicense, and/or
- *     sell copies of the Software, and to permit persons to whom the
- *     Software is furnished to do so, subject to the following
- *     conditions:
- *
- *     The above copyright notice and this permission notice shall be
- *     included in all copies or substantial portions of the Software.
- *
- *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- *     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- *     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- *     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- *     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- *     OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/dts-v1/;
-/plugin/;
-
-/ {
-    compatible = "nextthing,chip", "allwinner,sun5i-r8";
-
-    /* activate the gpio for interrupt */
-    fragment@0 {
-        target-path = <&pio>;
-
-        __overlay__ {
-            chip_spi2_pins: spi2@0 {
-                allwinner,pins = "PE1", "PE2", "PE3";
-                allwinner,function = "spi2";
-                allwinner,drive = "0"; //<SUN4I_PINCTRL_10_MA>;
-                allwinner,pull = "0"; //<SUN4I_PINCTRL_NO_PULL>;
-            };
-
-            chip_spi2_cs0_pins: spi2_cs0@0 {
-                allwinner,pins = "PE0";
-                allwinner,function = "spi2";
-                allwinner,drive = "0"; //<SUN4I_PINCTRL_10_MA>;
-                allwinner,pull = "0"; //<SUN4I_PINCTRL_NO_PULL>;
-            };
-        };
-    };
-
-    /*
-     * Enable our SPI device, with an spidev device connected
-     * to it
-    */
-    fragment@1 {
-        target = <&spi2>;
-
-        __overlay__ {
-            #address-cells = <1>;
-            #size-cells = <0>;
-            pinctrl-names = "default";
-            pinctrl-0 = <&chip_spi2_pins>, <&chip_spi2_cs0_pins>;
-            status = "okay";
-
-            spi2@0 {
-                compatible = "rohm,dh2228fv";
-                reg = <0>;
-                spi-max-frequency = <24000000>;
-            };
-        };
-    };
-};
-

setup.py

@@ -20,7 +20,7 @@ classifiers = ['Development Status :: 3 - Alpha',
                'Topic :: System :: Hardware']
 
 setup(name             = 'CHIP_IO',
-      version          = '0.2.7',
+      version          = '0.3.4.1',
       author           = 'Robert Wolterman',
       author_email     = 'robert.wolterman@gmail.com',
       description      = 'A module to control CHIP IO channels',

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"
@@ -47,9 +48,6 @@ SOFTWARE.
 
 // Global variables
 int pwm_initialized = 0;
-int DEBUG = 0;
-//int ENABLE = 1;
-//int DISABLE = 0;
 
 // pwm devices (future chip pro use)
 struct pwm_dev
@@ -105,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,26 +112,40 @@ int initialize_pwm(void)
         int gpio = 0;
 
         if (DEBUG)
-            printf(" ** EXPORTING PWM0 **\n");
+            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);
-        if (DEBUG)
-            printf(" ** IN initialize_pwm: s = %d, len = %d\n", 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);
+        
         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;
@@ -150,18 +163,20 @@ int pwm_set_frequency(const char *key, float freq) {
     period_ns = (unsigned long)(1e9 / freq);
 
     if (pwm->enable) {
-        if (DEBUG)
-            printf(" ** IN pwm_set_frequency: pwm_initialized = %d\n", pwm_initialized);
         if (period_ns != pwm->period_ns) {
             pwm->period_ns = period_ns;
 
             len = snprintf(buffer, sizeof(buffer), "%lu", period_ns); BUF2SMALL(buffer);
-            if (DEBUG)
+            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);
-            ssize_t s = write(pwm->period_fd, buffer, len);  //ASSRT(s == len);
-            if (DEBUG)
-                printf(" ** IN pwm_set_frequency: s = %d, len = %d\n", s, len);
+                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;
@@ -176,8 +191,71 @@ int pwm_set_frequency(const char *key, float freq) {
     return rtnval;
 }
 
+int pwm_set_period_ns(const char *key, unsigned long period_ns) {
+    int len, e_no;
+    int rtnval = -1;
+    char buffer[80];
+    struct pwm_exp *pwm;
+
+    //TODO: ADD CHECK FOR period_ns
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return rtnval;
+    }
+    
+    if (pwm->enable) {
+        if (period_ns != pwm->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);  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;
+            }
+        } else {
+            rtnval = 0;
+        }
+    } else {
+        rtnval = 0;
+    }
+
+    return rtnval;
+}
+
+int pwm_get_period_ns(const char *key, unsigned long *period_ns) {
+    int rtnval = -1;
+    struct pwm_exp *pwm;
+    
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return rtnval;
+    }
+    
+    if (DEBUG)
+        printf(" ** pwm_get_period_ns: %lu **\n",pwm->period_ns);
+    
+    // Set period_ns to what we have in the struct
+    *period_ns = pwm->period_ns;
+    
+    rtnval = 0;
+    return rtnval;
+}
+
 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;
@@ -193,8 +271,6 @@ int pwm_set_polarity(const char *key, int polarity) {
     }
 
     if (pwm->enable) {
-        if (DEBUG)
-            printf(" ** IN pwm_set_polarity: pwm_initialized = %d\n", pwm_initialized);
         if (polarity == 0) {
             len = snprintf(buffer, sizeof(buffer), "%s", "normal"); BUF2SMALL(buffer);
         }
@@ -202,12 +278,16 @@ int pwm_set_polarity(const char *key, int polarity) {
         {
             len = snprintf(buffer, sizeof(buffer), "%s", "inverted"); BUF2SMALL(buffer);
         }
-        if (DEBUG)
-            printf(" ** pwm_set_poliarity: buffer: %s\n", buffer);
-        ssize_t s = write(pwm->polarity_fd, buffer, len);  //ASSRT(s == len);
-        if (DEBUG)
-            printf(" ** IN pwm_set_polarity: s = %d, len = %d\n", 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;
@@ -219,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;
@@ -237,15 +317,17 @@ int pwm_set_duty_cycle(const char *key, float duty) {
     pwm->duty = (unsigned long)(pwm->period_ns * (duty / 100.0));
 
     if (pwm->enable) {
-        if (DEBUG)
-            printf(" ** IN pwm_set_duty_cycle: pwm_initialized = %d\n", pwm_initialized);
         len = snprintf(buffer, sizeof(buffer), "%lu", pwm->duty); BUF2SMALL(buffer);
-        if (DEBUG)
+        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);
-        ssize_t s = write(pwm->duty_fd, buffer, len);  //ASSRT(s == len);
-        if (DEBUG)
-            printf(" ** IN pwm_set_duty_cycle: s = %d, len = %d\n", s, len);
+            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;
@@ -257,16 +339,57 @@ int pwm_set_duty_cycle(const char *key, float duty) {
     return rtnval;
 }
 
+int pwm_set_pulse_width_ns(const char *key, unsigned long pulse_width_ns) {
+    int len, e_no;
+    int rtnval = -1;
+    char buffer[80];
+    struct pwm_exp *pwm;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return rtnval;
+    }
+
+    if (pulse_width_ns < 0 || pulse_width_ns > pwm->period_ns)
+        return rtnval;
+
+    pwm->duty = pulse_width_ns / pwm->period_ns;
+    
+    if (pwm->enable) {
+        len = snprintf(buffer, sizeof(buffer), "%lu", pwm->duty); BUF2SMALL(buffer);
+        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;
+        }
+    } else {
+        rtnval = 0;
+    }
+
+    return rtnval;
+       
+}
+
 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;
 
     if (enable != 0 && enable != 1) {
         if (DEBUG)
-            printf(" ** INVALID ENABLE OPTION, NEEDS TO BE EITHER 0 OR 1! **\n");
+            printf(" ** pwm_set_enable: enable needs to be 0 or 1! **\n");
         return rtnval;
     }
 
@@ -274,26 +397,29 @@ int pwm_set_enable(const char *key, int enable)
 
     if (pwm == NULL) {
         if (DEBUG)
-            printf(" ** SOMETHING BAD HAPPEND IN pwm_set_enable, WE'RE EXITING WITH -1 NOW! **\n");
+            printf(" ** pwm_set_enable: pwm struct is null **\n");
         return rtnval;
     }
 
 
     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(" ** IN pwm_set_enable: pwm_initialized = %d\n", pwm_initialized);
+        printf(" ** pwm_set_enable: pwm_initialized = %d\n", pwm_initialized);
         printf(" ** pwm_set_enable: buffer: %s\n", buffer);
-        printf(" ** IN pwm_set_enable: s = %d, len = %d\n", s, len);
+        printf(" ** pwm_set_enable: s = %d, len = %d\n", s, len);
     }
 
     if (s == len)
     {
         if (DEBUG)
-            printf(" ** SETTING pwm->enable to %d\n", enable);
+            printf(" ** pwm_set_enable: pwm->enable to %d\n", 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;
     }
 
@@ -311,16 +437,16 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
     struct pwm_exp *new_pwm, *pwm;
 
     if (DEBUG)
-        printf(" ** IN pwm_start: pwm_initialized = %d\n", pwm_initialized);
+        printf(" ** pwm_start: pwm_initialized = %d\n", pwm_initialized);
     if(!pwm_initialized) {
         initialize_pwm();
     } else {
         if (DEBUG)
-            printf(" ** ALREADY INITIALIZED, CALLING CLEANUP TO START FRESH **");
+            printf(" ** pwm_start: pwm already initialized, cleaning up **");
         pwm_cleanup();   
     }
     if (DEBUG)
-        printf(" ** IN pwm_start: pwm_initialized = %d\n", pwm_initialized);
+        printf(" ** pwm_start: pwm_initialized = %d\n", pwm_initialized);
 
     //setup the pwm base path, the chip only has one pwm
     snprintf(pwm_base_path, sizeof(pwm_base_path), "/sys/class/pwm/pwmchip0/pwm%d", 0); BUF2SMALL(pwm_base_path);
@@ -332,19 +458,26 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
     snprintf(polarity_path, sizeof(polarity_path), "%s/polarity", pwm_base_path); BUF2SMALL(polarity_path);
 
     if (DEBUG) {
-        printf(" ** IN pwm_start: pwm_base_path: %s\n", pwm_base_path);
-        printf(" ** IN pwm_start: enable_path:   %s\n", enable_path);
-        printf(" ** IN pwm_start: period_path:   %s\n", period_path);
-        printf(" ** IN pwm_start: duty_path:     %s\n", duty_path);
-        printf(" **IN pwm_start: polarity_path: %s\n", polarity_path);
+        printf(" ** pwm_start: pwm_base_path: %s\n", pwm_base_path);
+        printf(" ** pwm_start: enable_path:   %s\n", enable_path);
+        printf(" ** pwm_start: period_path:   %s\n", period_path);
+        printf(" ** pwm_start: duty_path:     %s\n", duty_path);
+        printf(" ** pwm_start: polarity_path: %s\n", polarity_path);
     }
     
     //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;
     }
 
@@ -352,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;
     }
 
@@ -360,17 +496,23 @@ 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)
-        printf(" ** IN pwm_start: IF WE MAKE IT HERE, THE FILES WERE SUCCESSFULLY OPEN **\n");
+        printf(" ** pwm_start: sysfs files opened successfully **\n");
     strncpy(new_pwm->key, key, KEYLEN);  /* can leave string unterminated */
     new_pwm->key[KEYLEN] = '\0'; /* terminate string */
     new_pwm->period_fd = period_fd;
@@ -393,13 +535,17 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
 
     int rtnval = 0;
     rtnval = pwm_set_enable(key, ENABLE);
-    rtnval = 0;
-    rtnval = pwm_set_frequency(key, freq);
-    rtnval = 0;
-    //rtnval = pwm_set_polarity(key, polarity);
-    //rtnval = 0;
-    rtnval = pwm_set_duty_cycle(key, duty);
-
+    // Fix for issue #53
+    if (rtnval != -1) {
+        rtnval = 0;
+        rtnval = pwm_set_frequency(key, freq);
+        if (rtnval != -1) {
+            rtnval = 0;
+            //rtnval = pwm_set_polarity(key, polarity);
+            //rtnval = 0;
+            rtnval = pwm_set_duty_cycle(key, duty);
+        }
+    }
     return rtnval;
 }
 
@@ -407,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
@@ -421,18 +567,30 @@ 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;
     while (pwm != NULL)
     {
         if (strcmp(pwm->key, key) == 0)
         {
+            if (DEBUG) {
+                printf(" ** pwm_disable: freeing memory %s\n", key);
+            }
             //close the fd
             close(pwm->enable_fd);
             close(pwm->period_fd);
@@ -464,11 +622,3 @@ void pwm_cleanup(void)
     }
 }
 
-void pwm_toggle_debug(void)
-{
-    if (DEBUG) {
-        DEBUG = 0;
-    } else {
-        DEBUG = 1;
-    }
-}

source/c_pwm.h

@@ -32,7 +32,9 @@ SOFTWARE.
 int pwm_start(const char *key, float duty, float freq, int polarity);
 int pwm_disable(const char *key);
 int pwm_set_frequency(const char *key, float freq);
+int pwm_set_period_ns(const char *key, unsigned long period_ns);
+int pwm_get_period_ns(const char *key, unsigned long *period_ns);
 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 pwm_set_enable(const char *key, int enable);
 void pwm_cleanup(void);
-void pwm_toggle_debug(void);

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>
@@ -96,6 +97,8 @@ int softpwm_set_frequency(const char *key, float freq) {
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** softpwm_set_frequency: %f **\n", freq);
     pthread_mutex_lock(pwm->params_lock);
     pwm->params.freq = freq;
     pthread_mutex_unlock(pwm->params_lock);
@@ -116,6 +119,8 @@ int softpwm_set_polarity(const char *key, int polarity) {
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** softpwm_set_polarity: %d **\n", polarity);
     pthread_mutex_lock(pwm->params_lock);
     pwm->params.polarity = polarity;
     pthread_mutex_unlock(pwm->params_lock);
@@ -135,6 +140,8 @@ int softpwm_set_duty_cycle(const char *key, float duty) {;
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** softpwm_set_duty_cycle: %f **\n", duty);
     pthread_mutex_lock(pwm->params_lock);
     pwm->params.duty = duty;
     pthread_mutex_unlock(pwm->params_lock);
@@ -194,7 +201,6 @@ void *softpwm_thread_toggle(void *arg)
 
     if (enabled_local)
     {
-
       /* Force 0 duty cycle to be 0 */
       if (duty_local != 0)
       {
@@ -238,16 +244,27 @@ int softpwm_start(const char *key, float duty, float freq, int polarity)
     int gpio;
     int ret;
 
-    if (get_gpio_number(key, &gpio) < 0)
+    if (get_gpio_number(key, &gpio) < 0) {
+        if (DEBUG)
+            printf(" ** softpwm_start: invalid gpio specified **\n");
         return -1;
+    }
+        
     if (gpio_export(gpio) < 0) {
        char err[2000];
        snprintf(err, sizeof(err), "Error setting up softpwm on pin %d, maybe already exported? (%s)", gpio, get_error_msg());
        add_error_msg(err);
        return -1;
     }
-    if (gpio_set_direction(gpio, OUTPUT) < 0)
+    
+    if (DEBUG)
+        printf(" ** softpwm_start: %d exported **\n", gpio);
+    
+    if (gpio_set_direction(gpio, OUTPUT) < 0) {
+        if (DEBUG)
+            printf(" ** softpwm_start: gpio_set_direction failed **\n");
         return -1;
+    }
 
     // add to list
     new_pwm = malloc(sizeof(struct softpwm));  ASSRT(new_pwm != NULL);
@@ -279,12 +296,16 @@ int softpwm_start(const char *key, float duty, float freq, int polarity)
     }
     pthread_mutex_unlock(new_params_lock);
 
+    if (DEBUG)
+        printf(" ** softpwm_enable: setting softpwm parameters **\n");
     ASSRT(softpwm_set_duty_cycle(new_pwm->key, duty) == 0);
     ASSRT(softpwm_set_frequency(new_pwm->key, freq) == 0);
     ASSRT(softpwm_set_polarity(new_pwm->key, polarity) == 0);
 
     pthread_mutex_lock(new_params_lock);
     // create thread for pwm
+    if (DEBUG)
+        printf(" ** softpwm_enable: creating thread **\n");
     ret = pthread_create(&new_thread, NULL, softpwm_thread_toggle, (void *)new_pwm);
     ASSRT(ret == 0);
 
@@ -299,17 +320,23 @@ int softpwm_disable(const char *key)
 {
     struct softpwm *pwm, *temp, *prev_pwm = NULL;
 
+    if (DEBUG)
+        printf(" ** in softpwm_disable **\n");
     // remove from list
     pwm = exported_pwms;
     while (pwm != NULL)
     {
         if (strcmp(pwm->key, key) == 0)
         {
+            if (DEBUG)
+                printf(" ** softpwm_disable: found pin **\n");
             pthread_mutex_lock(pwm->params_lock);
             pwm->params.stop_flag = true;
             pthread_mutex_unlock(pwm->params_lock);
             pthread_join(pwm->thread, NULL);  /* wait for thread to exit */
 
+            if (DEBUG)
+                printf(" ** softpwm_disable: unexporting %d **\n", pwm->gpio);
             gpio_unexport(pwm->gpio);
 
             if (prev_pwm == NULL)

source/common.c

@@ -49,91 +49,93 @@ SOFTWARE.
 int setup_error = 0;
 int module_setup = 0;
 
+// Library Debug
+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:
@@ -214,6 +216,14 @@ int get_xio_base(void)
   return xio_base_address; 
 }  /* get_xio_base */
 
+void toggle_debug(void)
+{
+    if (DEBUG) {
+        DEBUG = 0;
+    } else {
+        DEBUG = 1;
+    }
+}
 
 int gpio_number(pins_t *pin)
 {
@@ -239,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)
 {
@@ -273,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;
@@ -351,12 +410,16 @@ int get_pwm_key_by_name(const char *name, char *key)
     pins_t *p;
     for (p = pins_info; p->name != NULL; ++p) {
         if (strcmp(p->name, name) == 0) {
-            printf("## FOUND PWM KEY, VALIDATING MUX MODE ##\n");
+            if (DEBUG) {
+                printf(" ** get_pwm_key_by_name: FOUND PWM KEY, VALIDATING MUX MODE **\n");
+            }
             //validate it's a valid pwm pin
             if (p->pwm_mux_mode == -1)
                 return 0;
 
-            printf("## PWM KEY IS VALID ##\n");
+            if (DEBUG) {
+                printf(" ** get_pwm_key_by_name: PWM KEY IS VALID ##\n");
+            }
             strncpy(key, p->key, 7);
             key[7] = '\0';
             return 1;
@@ -382,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)) {
@@ -440,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

source/common.h

@@ -52,8 +52,11 @@ SOFTWARE.
 } while (0)
 
 #define MODE_UNKNOWN -1
+#define BOARD        10
+#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.
@@ -66,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;
 
 
@@ -84,12 +88,17 @@ typedef struct dyn_int_array_s dyn_int_array_t;
 
 int setup_error;
 int module_setup;
+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);
@@ -101,10 +110,11 @@ 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);
 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);

source/constants.c

@@ -76,6 +76,18 @@ void define_constants(PyObject *module)
    both_edge = Py_BuildValue("i", BOTH_EDGE);
    PyModule_AddObject(module, "BOTH", both_edge);
 
-   version = Py_BuildValue("s", "0.2.7");
+   unknown = Py_BuildValue("i", MODE_UNKNOWN);
+   PyModule_AddObject(module, "UNKNOWN", unknown);
+
+   board = Py_BuildValue("i", BOARD);
+   PyModule_AddObject(module, "BOARD", board);
+
+   bcm = Py_BuildValue("i", BCM);
+   PyModule_AddObject(module, "BCM", bcm);
+   
+   module_debug = Py_BuildValue("i", DEBUG ? Py_True: Py_False);
+   PyModule_AddObject(module, "DEBUG", module_debug);
+
+   version = Py_BuildValue("s", "0.3.4.1");
    PyModule_AddObject(module, "VERSION", version);
 }

source/constants.h

@@ -10,5 +10,9 @@ PyObject *rising_edge;
 PyObject *falling_edge;
 PyObject *both_edge;
 PyObject *version;
+PyObject *unknown;
+PyObject *board;
+PyObject *bcm;
+PyObject *module_debug;
 
-void define_constants(PyObject *module);
+void define_constants(PyObject *module);

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)
 {
@@ -93,6 +156,9 @@ int gpio_export(int gpio)
     char str_gpio[80];
     struct gpio_exp *new_gpio, *g;
 
+    if (DEBUG)
+        printf(" ** gpio_export **\n");
+
     snprintf(filename, sizeof(filename), "/sys/class/gpio/export"); BUF2SMALL(filename);
 
     if ((fd = open(filename, O_WRONLY)) < 0)
@@ -115,6 +181,8 @@ int gpio_export(int gpio)
     }
 
     // add to list
+    if (DEBUG)
+        printf(" ** gpio_export: creating data struct **\n");
     new_gpio = malloc(sizeof(struct gpio_exp));  ASSRT(new_gpio != NULL);
 
     new_gpio->gpio = gpio;
@@ -217,6 +285,8 @@ int open_value_file(int gpio)
 
     // Changed this to open Read/Write to prevent a ton of file open/closes from happening when using
     // the GPIO for SOFTPWM
+    if (DEBUG)
+        printf(" ** open_value_file **\n");
     if ((fd = open(filename, O_RDWR | O_NONBLOCK)) < 0) {
         char err[256];
         snprintf(err, sizeof(err), "open_value_file: could not open '%s' (%s)", filename, strerror(errno));
@@ -236,6 +306,8 @@ int open_edge_file(int gpio)
     // create file descriptor of value file
     snprintf(filename, sizeof(filename), "/sys/class/gpio/gpio%d/edge", gpio); BUF2SMALL(filename);
 
+    if (DEBUG)
+        printf(" ** open_edge_file **\n");
     if ((fd = open(filename, O_RDONLY | O_NONBLOCK)) < 0) {
         char err[256];
         snprintf(err, sizeof(err), "open_edge_file: could not open '%s' (%s)", filename, strerror(errno));
@@ -253,6 +325,9 @@ int gpio_unexport(int gpio)
     char str_gpio[16];
     struct gpio_exp *g, *temp, *prev_g = NULL;
 
+    if (DEBUG)
+        printf(" ** gpio_unexport **\n");
+
     close_value_fd(gpio);
 
     snprintf(filename, sizeof(filename), "/sys/class/gpio/unexport"); BUF2SMALL(filename);
@@ -274,6 +349,8 @@ int gpio_unexport(int gpio)
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** gpio_unexport: freeing memory **\n");
     // remove from list
     g = exported_gpios;
     while (g != NULL)
@@ -315,6 +392,9 @@ int gpio_set_direction(int gpio, unsigned int in_flag)
     } else {
         strncpy(direction, "in", ARRAY_SIZE(direction) - 1);
     }
+    if (DEBUG)
+        printf(" ** gpio_set_direction: %s **\n",direction);
+    
     ssize_t s = write(fd, direction, strlen(direction));  e_no = errno;
     close(fd);
     if (s != strlen(direction)) {
@@ -360,6 +440,9 @@ int gpio_get_direction(int gpio, unsigned int *value)
         add_error_msg(err);
         return -1;
     }
+    
+    if (DEBUG)
+        printf(" ** gpio_get_direction: %s **\n",direction);
 
     if (strcmp(direction, "out") == 0)
         *value = OUTPUT;
@@ -403,6 +486,9 @@ int gpio_set_value(int gpio, unsigned int value)
         strncpy(vstr, "0", ARRAY_SIZE(vstr) - 1);
     }
 
+    if (DEBUG)
+        printf(" ** gpio_set_value: writing %s **\n", vstr);
+
     ssize_t s = write(fd, vstr, strlen(vstr));  e_no = errno;
 
     if (s != strlen(vstr)) {
@@ -444,6 +530,9 @@ int gpio_get_value(int gpio, unsigned int *value)
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** gpio_get_value: %c **\n", ch);
+
     if (ch == '1') {
         *value = 1;
     } else if (ch == '0') {
@@ -472,6 +561,9 @@ int gpio_set_edge(int gpio, unsigned int edge)
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** gpio_set_edge: %s **\n", stredge[edge]);
+
     ssize_t s = write(fd, stredge[edge], strlen(stredge[edge]) + 1);
     if (s < 0) {
         char err[256];
@@ -521,6 +613,9 @@ int gpio_get_edge(int gpio)
         return -1;
     }
 
+    if (DEBUG)
+        printf(" ** gpio_get_edge: %s **\n", edge);
+
     if (strcmp(edge, "rising") == 0)
     {
         rtnedge = 1;
@@ -553,6 +648,8 @@ int gpio_lookup(int fd)
 void exports_cleanup(void)
 {
     // unexport everything
+    if (DEBUG)
+        printf(" ** exports_cleanup **\n");
     while (exported_gpios != NULL)
         gpio_unexport(exported_gpios->gpio);
 }
@@ -562,6 +659,8 @@ int add_edge_callback(int gpio, int edge, void (*func)(int gpio, void* data), vo
     struct callback *cb = callbacks;
     struct callback *new_cb;
 
+    if (DEBUG)
+        printf(" ** add_edge_callback **\n");
     new_cb = malloc(sizeof(struct callback));  ASSRT(new_cb != NULL);
 
     new_cb->fde  = open_edge_file(gpio);
@@ -611,6 +710,8 @@ void run_callbacks(int gpio)
             // Only run if we are allowed
             if (canrun)
             {
+                if (DEBUG)
+                    printf(" ** run_callbacks: gpio triggered: %d **\n", gpio);
                 cb->func(cb->gpio, cb->data);
             }
 
@@ -629,6 +730,8 @@ void remove_callbacks(int gpio)
     {
         if (cb->gpio == gpio)
         {
+            if (DEBUG)
+                printf(" ** remove_callbacks: gpio: %d **\n", gpio);
             close(cb->fde);
             if (prev == NULL)
                 callbacks = cb->next;
@@ -762,6 +865,9 @@ int add_edge_detect(int gpio, unsigned int edge)
     struct epoll_event ev;
     long t = 0;
 
+    if (DEBUG)
+        printf(" ** add_edge_detect: gpio: %d **\n", gpio);
+
     // check to see if this gpio has been added already
     if (gpio_event_add(gpio) != 0)
         return 1;
@@ -828,6 +934,9 @@ void remove_edge_detect(int gpio)
     struct epoll_event ev;
     int fd = fd_lookup(gpio);
 
+    if (DEBUG)
+        printf(" ** remove_edge_detect: gpio : %d **\n", gpio);
+
     // delete callbacks for gpio
     remove_callbacks(gpio);
 
@@ -871,6 +980,9 @@ int blocking_wait_for_edge(int gpio, unsigned int edge)
     struct epoll_event events, ev;
     char buf;
 
+    if (DEBUG)
+        printf(" ** blocking_wait_for_edge: gpio: %d **\n", gpio);
+
     if ((epfd = epoll_create(1)) == -1) {
         char err[256];
         snprintf(err, sizeof(err), "blocking_wait_for_edge: could not epoll_create GPIO %d (%s)", gpio, strerror(errno));
@@ -949,6 +1061,9 @@ int blocking_wait_for_edge(int gpio, unsigned int edge)
         }
     }
 
+    if (DEBUG)
+        printf(" ** blocking_wait_for_edge: gpio triggered: %d **\n", gpio);
+
     gpio_event_remove(gpio);
     close(epfd);
     return 0;

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);

source/py_gpio.c

@@ -58,8 +58,29 @@ 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;
@@ -71,13 +92,39 @@ static void remember_gpio_direction(int gpio, int direction)
     dyn_int_array_set(&gpio_direction, gpio, direction, -1);
 }
 
-// python function cleanup()
-static PyObject *py_cleanup(PyObject *self, PyObject *args)
+// Dummy function to mimic RPi.GPIO for easier porting.
+// python function setmode(mode)
+static PyObject *py_setmode(PyObject *self, PyObject *args)
 {
+    Py_RETURN_NONE;
+}
+
+// python function cleanup(channel=None)
+static PyObject *py_cleanup(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    int gpio;
+    char *channel;
+    static char *kwlist[] = {"channel", NULL};
+
     clear_error_msg();
 
-    // clean up any exports
-    event_cleanup();
+    // Channel is optional
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwlist, &channel)) {
+        return NULL;
+    }
+
+    // The !channel fixes issues #50
+    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;
+        }
+        gpio_unexport(gpio);
+    }
 
     Py_RETURN_NONE;
 }
@@ -85,69 +132,87 @@ static PyObject *py_cleanup(PyObject *self, PyObject *args)
 // python function setup(channel, direction, pull_up_down=PUD_OFF, initial=None)
 static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwargs)
 {
-   int gpio;
-   char *channel;
-   int direction;
-   int pud = PUD_OFF;
-   int initial = 0;
-   static char *kwlist[] = {"channel", "direction", "pull_up_down", "initial", NULL};
-
-   clear_error_msg();
-
-   if (!PyArg_ParseTupleAndKeywords(args, kwargs, "si|ii", kwlist, &channel, &direction, &pud, &initial))
-      return NULL;
-
-   if (!module_setup) {
-      init_module();
-   }
-
-
-   if (direction != INPUT && direction != OUTPUT)
-   {
-      PyErr_SetString(PyExc_ValueError, "An invalid direction was passed to setup()");
-      return NULL;
-   }
-
-   if (direction == OUTPUT)
-      pud = PUD_OFF;
-
-   if (pud != PUD_OFF && pud != PUD_DOWN && pud != PUD_UP)
-   {
-      PyErr_SetString(PyExc_ValueError, "Invalid value for pull_up_down - should be either PUD_OFF, PUD_UP or PUD_DOWN");
-      return NULL;
-   }
-
-   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;
-   }
-
-   if (gpio_export(gpio) < 0) {
-      char err[2000];
-      snprintf(err, sizeof(err), "Error setting up channel %s, maybe already exported? (%s)", channel, get_error_msg());
-      PyErr_SetString(PyExc_RuntimeError, err);
-      return NULL;
-   }
-   if (gpio_set_direction(gpio, direction) < 0) {
-      char err[2000];
-      snprintf(err, sizeof(err), "Error setting direction %d on channel %s. (%s)", direction, channel, get_error_msg());
-      PyErr_SetString(PyExc_RuntimeError, err);
-      return NULL;
-   }
-   if (direction == OUTPUT) {
-       if (gpio_set_value(gpio, initial) < 0) {
+    int gpio;
+    char *channel;
+    int direction;
+    int pud = PUD_OFF;
+    int initial = 0;
+    static char *kwlist[] = {"channel", "direction", "pull_up_down", "initial", NULL};
+ 
+    clear_error_msg();
+ 
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "si|ii", kwlist, &channel, &direction, &pud, &initial))
+        return NULL;
+ 
+    if (!module_setup) {
+        init_module();
+    }
+ 
+    if (direction != INPUT && direction != OUTPUT)
+    {
+        PyErr_SetString(PyExc_ValueError, "An invalid direction was passed to setup()");
+        return NULL;
+    }
+    
+    // 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)
+    {
+        PyErr_SetString(PyExc_ValueError, "Invalid value for pull_up_down - should be either PUD_OFF, PUD_UP or PUD_DOWN");
+        return NULL;
+    }
+ 
+    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;
+    }
+ 
+    if (gpio_export(gpio) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "Error setting up channel %s, maybe already exported? (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_RuntimeError, err);
+        return NULL;
+    }
+    if (gpio_set_direction(gpio, direction) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "Error setting direction %d on channel %s. (%s)", direction, channel, get_error_msg());
+        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];
             snprintf(err, sizeof(err), "Error setting initial value %d on channel %s. (%s)", initial, channel, get_error_msg());
             PyErr_SetString(PyExc_RuntimeError, err);
             return NULL;
-       }
-   }
-
-   remember_gpio_direction(gpio, direction);
-
-   Py_RETURN_NONE;
+        }
+    }
+ 
+    remember_gpio_direction(gpio, direction);
+ 
+    Py_RETURN_NONE;
 }  /* py_setup_channel */
 
 
@@ -717,10 +782,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()));
@@ -749,9 +810,6 @@ static PyObject *py_selftest(PyObject *self, PyObject *args)
 
 static const char moduledocstring[] = "GPIO functionality of a CHIP using Python";
 
-
-
-
 /*
 mine for changing pin directipn
 */
@@ -799,7 +857,7 @@ static PyObject *py_set_direction(PyObject *self, PyObject *args, PyObject *kwar
 
 PyMethodDef gpio_methods[] = {
    {"setup", (PyCFunction)py_setup_channel, METH_VARARGS | METH_KEYWORDS, "Set up the GPIO channel, direction and (optional) pull/up down control\nchannel        - Either: CHIP board pin number (not R8 GPIO 00..nn number).  Pins start from 1\n                 or    : CHIP GPIO name\ndirection      - INPUT or OUTPUT\n[pull_up_down] - PUD_OFF (default), PUD_UP or PUD_DOWN\n[initial]      - Initial value for an output channel"},
-   {"cleanup", 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"},
+   {"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"},
    {"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"},
@@ -811,13 +869,15 @@ PyMethodDef gpio_methods[] = {
    {"setwarnings", py_setwarnings, METH_VARARGS, "Enable or disable warning messages"},
    {"get_gpio_base", py_gpio_base, METH_VARARGS, "Get the XIO base number for sysfs"},
    {"selftest", py_selftest, METH_VARARGS, "Internal unit tests"},
-   { "direction", (PyCFunction)py_set_direction, METH_VARARGS, "Change direction of gpio channel. Either INPUT or OUTPUT\n" },
+   {"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}
 };
 
 
 #if PY_MAJOR_VERSION > 2
-static struct PyModuleDef rpigpiomodule = {
+static struct PyModuleDef chipgpiomodule = {
    PyModuleDef_HEAD_INIT,
    "GPIO",       // name of module
    moduledocstring,  // module documentation, may be NULL
@@ -837,7 +897,7 @@ PyMODINIT_FUNC initGPIO(void)
    clear_error_msg();
 
 #if PY_MAJOR_VERSION > 2
-   if ((module = PyModule_Create(&rpigpiomodule)) == NULL)
+   if ((module = PyModule_Create(&chipgpiomodule)) == NULL)
       return NULL;
 #else
    if ((module = Py_InitModule3("GPIO", gpio_methods, moduledocstring)) == NULL)
@@ -865,4 +925,4 @@ PyMODINIT_FUNC initGPIO(void)
 #else
    return;
 #endif
-}
+}

source/py_pwm.c

@@ -47,7 +47,7 @@ static PyObject *py_cleanup(PyObject *self, PyObject *args)
 static PyObject *py_toggle_debug(PyObject *self, PyObject *args)
 {
     // toggle debug printing
-    pwm_toggle_debug();
+    toggle_debug();
 
     Py_RETURN_NONE;
 }
@@ -62,6 +62,8 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
     int polarity = 0;
     static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
 
+    clear_error_msg();
+
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ffi", kwlist, &channel, &duty_cycle, &frequency, &polarity)) {
         return NULL;
     }
@@ -71,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;
     }
@@ -88,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;
 }
@@ -100,6 +104,8 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
     char key[8];
     char *channel;
 
+    clear_error_msg();
+
     if (!PyArg_ParseTuple(args, "s", &channel))
         return NULL;
 
@@ -108,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;
 }
@@ -121,11 +132,12 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
     float duty_cycle = 0.0;
     static char *kwlist[] = {"channel", "duty_cycle", NULL};
 
+    clear_error_msg();
+
     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;
     }
@@ -136,7 +148,50 @@ 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;
+    }
+
+    Py_RETURN_NONE;
+}
+
+// python method PWM.set_pulse_width(channel, pulse_width_ns)
+static PyObject *py_set_pulse_width_ns(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char key[8];
+    char *channel;
+    unsigned long pulse_width_ns = 0.0;
+    unsigned long period_ns;
+    static char *kwlist[] = {"channel", "pulse_width_ns", NULL};
+
+    clear_error_msg();
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|k", kwlist, &channel, &pulse_width_ns))
+        return NULL;
+
+    if (!get_pwm_key(channel, key)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name.");
+        return NULL;
+    }
+
+    // Get the period out of the data struct
+    int rtn = pwm_get_period_ns(key, &period_ns);
+    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) {
+        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) < 0) {
+        char err[2000];
+        snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
+        PyErr_SetString(PyExc_ValueError, err);
         return NULL;
     }
 
@@ -151,11 +206,12 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
     float frequency = 1.0;
     static char *kwlist[] = {"channel", "frequency", NULL};
 
+    clear_error_msg();
+
     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;
     }
@@ -165,14 +221,48 @@ 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;
     }
 
     Py_RETURN_NONE;
 }
 
+// python method PWM.set_period_ns(channel, period_ns)
+static PyObject *py_set_period_ns(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char key[8];
+    char *channel;
+    unsigned long period_ns = 2e6;
+    static char *kwlist[] = {"channel", "period_ns", NULL};
+
+    clear_error_msg();
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|k", kwlist, &channel, &period_ns))
+        return NULL;
+
+    if (period_ns <= 0) {
+        PyErr_SetString(PyExc_ValueError, "period must be greater than 0ns");
+        return NULL;
+    }
+
+    if (!get_pwm_key(channel, key)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name.");
+        return NULL;
+    }
+
+    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;
+    }
+
+    Py_RETURN_NONE;
+}
 
 static const char moduledocstring[] = "Hardware PWM functionality of a CHIP using Python";
 
@@ -181,9 +271,10 @@ PyMethodDef pwm_methods[] = {
     {"stop", (PyCFunction)py_stop_channel, METH_VARARGS | METH_KEYWORDS, "Stop the PWM channel.  channel can be in the form of 'PWM0', or 'U13_18'"},
     {"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)" },
+    {"set_period_ns", (PyCFunction)py_set_period_ns, METH_VARARGS, "Change the period\nperiod_ns - period in nanoseconds" },
+    {"set_pulse_width_ns", (PyCFunction)py_set_pulse_width_ns, METH_VARARGS, "Change the period\npulse_width_ns - pulse width in nanoseconds" },
     {"cleanup", 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"},
-    //{"setwarnings", py_setwarnings, METH_VARARGS, "Enable or disable warning messages"},
     {NULL, NULL, 0, NULL}
 };
 

source/py_softpwm.c

@@ -34,11 +34,39 @@ SOFTWARE.
 #include "common.h"
 #include "c_softpwm.h"
 
-// python function cleanup()
+// 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)
 {
     // unexport the PWM
-    softpwm_cleanup();
+    char key[8];
+    char *channel = NULL;
+    
+    clear_error_msg();
+    
+    // Channel is optional
+    if (!PyArg_ParseTuple(args, "|s", &channel))
+        return NULL;
+                    
+    // The !channel fixes issue #50
+    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_disable(key);
+    }
 
     Py_RETURN_NONE;
 }
@@ -53,6 +81,8 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
     int polarity = 0;
     static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
 
+    clear_error_msg();
+
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ffi", kwlist, &channel, &duty_cycle, &frequency, &polarity)) {
         return NULL;
     }
@@ -63,14 +93,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;
     }
@@ -80,8 +108,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());
@@ -98,6 +125,8 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
     char key[8];
     char *channel;
 
+    clear_error_msg();
+
     if (!PyArg_ParseTuple(args, "s", &channel))
         return NULL;
 
@@ -119,11 +148,12 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
     float duty_cycle = 0.0;
     static char *kwlist[] = {"channel", "duty_cycle", NULL};
 
+    clear_error_msg();
+
     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;
     }
@@ -149,11 +179,12 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
     float frequency = 1.0;
     static char *kwlist[] = {"channel", "frequency", NULL};
 
+    clear_error_msg();
+
     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;
     }
@@ -171,21 +202,20 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
     Py_RETURN_NONE;
 }
 
-
 static const char moduledocstring[] = "Software PWM functionality of a CHIP using Python";
 
 PyMethodDef pwm_methods[] = {
     {"start", (PyCFunction)py_start_channel, METH_VARARGS | METH_KEYWORDS, "Set up and start the PWM channel.  channel can be in the form of 'XIO-P0', or 'U14_13'"},
     {"stop", (PyCFunction)py_stop_channel, METH_VARARGS | METH_KEYWORDS, "Stop the PWM channel.  channel can be in the form of 'XIO-P0', or 'U14_13'"},
-    { "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", 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"},
-    //{"setwarnings", py_setwarnings, METH_VARARGS, "Enable or disable warning messages"},
+    {"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}
 };
 
 #if PY_MAJOR_VERSION > 2
-static struct PyModuleDef chippwmmodule = {
+static struct PyModuleDef chipspwmmodule = {
     PyModuleDef_HEAD_INIT,
     "SOFTPWM",       // name of module
     moduledocstring,  // module documentation, may be NULL
@@ -203,7 +233,7 @@ PyMODINIT_FUNC initSOFTPWM(void)
     PyObject *module = NULL;
 
 #if PY_MAJOR_VERSION > 2
-    if ((module = PyModule_Create(&chippwmmodule)) == NULL)
+    if ((module = PyModule_Create(&chipspwmmodule)) == NULL)
        return NULL;
 #else
     if ((module = Py_InitModule3("SOFTPWM", pwm_methods, moduledocstring)) == NULL)

test/lradc_test.py

@@ -4,7 +4,7 @@ import CHIP_IO.LRADC as ADC
 
 # == ENABLE DEBUG ==
 print("ENABLING LRADC DEBUG OUTPUT")
-ADC.enable_debug()
+ADC.toggle_debug()
 
 # == SETUP ==
 print("LRADC SETUP WITH SAMPLE RATE OF 125")

test/omtest.py

@@ -5,7 +5,7 @@ import os
 
 # ENABLE DEBUG
 print("ENABLING OVERLAY MANAGER DEBUG")
-OM.enable_debug()
+OM.toggle_debug()
 
 # **************** PWM *******************
 print("\nIS PWM ENABLED: {0}".format(OM.get_pwm_loaded()))
@@ -20,19 +20,6 @@ print("UNLOADING PWM0")
 OM.unload("PWM0")
 print("IS PWM ENABLED: {0}".format(OM.get_pwm_loaded()))
 
-# **************** I2C-1 *******************
-print("\nIS I2C ENABLED: {0}".format(OM.get_i2c_loaded()))
-OM.load("I2C1")
-print("IS I2C ENABLED: {0}".format(OM.get_i2c_loaded()))
-# VERIFY I2C-1 EXISTS
-if os.path.exists('/sys/class/i2c-dev/i2c-1'):
-    print("I2C1 DEVICE EXISTS")
-else:
-    print("I2C1 DEVICE DID NOT LOAD PROPERLY")
-print("UNLOADING I2C1")
-OM.unload("I2C1")
-print("IS I2C ENABLED: {0}".format(OM.get_i2c_loaded()))
-
 # **************** SPI2 *******************
 print("\nIS SPI ENABLED: {0}".format(OM.get_spi_loaded()))
 OM.load("SPI2")