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,43 @@
+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.
+* Updated README to denote the PocketCHIP Pin names better
+
+0.2.6
+----
+* Fix to keep the GPIO value file open until the pin is unexported (issue #34)
+
 0.2.5
 ----
 * Updates to the pytest code for HWPWM and SoftPWM

CHIP_IO/LRADC.py

@@ -42,8 +42,11 @@ 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
+    if DEBUG:
+        DEBUG = False
+    else:
         DEBUG = True
 
 def setup(rate=250):
@@ -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,8 +53,11 @@ _FOLDERS = {
   "CUST" : "chip-cust"
 }
 
-def enable_debug():
+def toggle_debug():
     global DEBUG
+    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
-    voltage=round((voltage - 1.8) / 0.1) << 4
+    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("/")

Makefile

@@ -6,7 +6,7 @@ publish: package
 
 clean:
 	rm -rf CHIP_IO.* build dist
-	rm -f *.pyo
+	rm -f *.pyo *.pyc
 	rm -f *.egg
 	rm -f overlays/*.pyo overlays/*.pyc
 tests:

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
+    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 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
+    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 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**
 
@@ -44,115 +42,115 @@ All scripts that require GPIO, PWM (HW and/or SW), and Overlay Manager need to b
 
 **Allowable Pin Names for the Library**
 
-The following "table" is the allowable pin names that are able to be used by the library.
+The following "table" is the allowable pin names that are able to be used by the library. The Name column is the normal name used on the CHIP Headers, the Alt Name column is the value used by the PocketCHIP header (if it's broken out), and the Key is the Header and Pin Number the the Pin is physically located.  Either of these 3 means is able to specify a pin in CHIP_IO.
 
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
-  |   Name    |  Alt Name   |  Key   |
+  |   CHIP (Name)    |  PocketCHIP (Alt Name)   |  Key   |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | TWI1-SDA         | KPD-I2C-SDA              | U13_9  |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | TWI1-SCK         | KPD-I2C-SCL              | U13_11 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D2           | LCD-D2                   | U13_17 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | PWM0             | PWM0                     | U13_18 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D4           | LCD-D4                   | U13_19 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D3           | LCD-D3                   | U13_20 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D6           | LCD-D6                   | U13_21 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D5           | LCD-D5                   | U13_22 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D10          | LCD-D10                  | U13_23 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D7           | LCD-D7                   | U13_24 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D12          | LCD-D12                  | U13_25 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D11          | LCD-D11                  | U13_26 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D14          | LCD-D14                  | U13_27 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D13          | LCD-D13                  | U13_28 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D18          | LCD-D18                  | U13_29 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D15          | LCD-D15                  | U13_30 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D20          | LCD-D20                  | U13_31 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D19          | LCD-D19                  | U13_32 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D22          | LCD-D22                  | U13_33 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D21          | LCD-D21                  | U13_34 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-CLK          | LCD-CLK                  | U13_35 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-D23          | LCD-D23                  | U13_36 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-VSYNC        | LCD-VSYNC                | U13_37 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-HSYNC        | LCD-HSYNC                | U13_38 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LCD-DE           | LCD-DE                   | U13_40 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | UART1-TX         | UART-TX                  | U14_3  |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | UART1-RX         | UART-RX                  | U14_5  |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | LRADC            | ADC                      | U14_11 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P0           | XIO-P0                   | U14_13 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P1           | XIO-P1                   | U14_14 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P2           | GPIO1                    | U14_15 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P3           | GPIO2                    | U14_16 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P4           | GPIO3                    | U14_17 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P5           | GPIO4                    | U14_18 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P6           | GPIO5                    | U14_19 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | XIO-P7           | GPIO6                    | U14_20 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | AP-EINT1         | KPD-INT                  | U14_23 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | AP-EINT3         | AP-INT3                  | U14_24 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | TWI2-SDA         | I2C-SDA                  | U14_25 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | TWI2-SCK         | I2C-SCL                  | U14_26 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSIPCK           | SPI-SEL                  | U14_27 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSICK            | SPI-CLK                  | U14_28 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSIHSYNC         | SPI-MOSI                 | U14_29 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSIVSYNC         | SPI-MISO                 | U14_30 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID0            | CSID0                    | U14_31 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID1            | CSID1                    | U14_32 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID2            | CSID2                    | U14_33 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID3            | CSID3                    | U14_34 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID4            | CSID4                    | U14_35 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID5            | CSID5                    | U14_36 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID6            | CSID6                    | U14_37 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
   | CSID7            | CSID7                    | U14_38 |
-  +-----------+-------------+--------+
+  +------------------+--------------------------+--------+
 
 **GPIO Setup**
 
@@ -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
+    # Enable/Disable Debug
-    ADC.enable_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
+    # The toggle_debug() function turns on/off debug printing
-    #OM.enable_debug()
+    #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,8 +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-i2c1.dtbo", "-b", "o", "-@", "overlays/chip-i2c1.dts"])
     call(["dtc", "-O", "dtb", "-o", "overlays/chip-pwm0.dtbo", "-b", "o", "-@", "overlays/chip-pwm0.dts"])
 
 def copy():
@@ -21,6 +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-i2c1.dtbo", overlay_path+"/chip-i2c1.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.5',
+      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);
+        ssize_t s = write(fd, str_gpio, len); e_no = errno;
-        if (DEBUG)
-            printf(" ** IN initialize_pwm: s = %d, len = %d\n", s, len);
         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);
+                printf(" ** pwm_set_frequency: s = %d, len = %d\n", s, len);
-            if (DEBUG)
+            }
-                printf(" ** IN 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)
+        ssize_t s = write(pwm->polarity_fd, buffer, len);  e_no = errno;
-            printf(" ** pwm_set_poliarity: buffer: %s\n", buffer);
+        if (DEBUG) {
-        ssize_t s = write(pwm->polarity_fd, buffer, len);  //ASSRT(s == len);
+            printf(" ** pwm_set_polarity: pwm_initialized = %d\n", pwm_initialized);
-        if (DEBUG)
+            printf(" ** pwm_set_polarity: buffer: %s\n", buffer);
-            printf(" ** IN pwm_set_polarity: s = %d, len = %d\n", s, len);
+            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);
+            printf(" ** pwm_set_duty_cycle: s = %d, len = %d\n", s, len);
-        if (DEBUG)
+        }
-            printf(" ** IN 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(" ** pwm_start: pwm_base_path: %s\n", pwm_base_path);
-        printf(" ** IN pwm_start: enable_path:   %s\n", enable_path);
+        printf(" ** pwm_start: enable_path:   %s\n", enable_path);
-        printf(" ** IN pwm_start: period_path:   %s\n", period_path);
+        printf(" ** pwm_start: period_path:   %s\n", period_path);
-        printf(" ** IN pwm_start: duty_path:     %s\n", duty_path);
+        printf(" ** pwm_start: duty_path:     %s\n", duty_path);
-        printf(" **IN pwm_start: polarity_path: %s\n", polarity_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);
+    // 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,11 +567,20 @@ int pwm_disable(const char *key)
 
     if ((fd = open("/sys/class/pwm/pwmchip0/unexport", O_WRONLY)) < 0)
     {
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_disable: could not open unexport file");
+        add_error_msg(err);
         return -1;
     }
     len = snprintf(str_gpio, sizeof(str_gpio), "%d", gpio); BUF2SMALL(str_gpio);
-    ssize_t s = write(fd, str_gpio, len);  ASSRT(s == len);
+    ssize_t s = write(fd, str_gpio, len); e_no = errno;
     close(fd);
+    if (s != len) {
+        char err[256];
+        snprintf(err, sizeof(err), "pwm_disable: could not unexport pwm (%s)", strerror(e_no));
+        add_error_msg(err);
+        return -1;
+    }
     
     // remove from list
     pwm = exported_pwms;
@@ -433,6 +588,9 @@ int pwm_disable(const char *key)
     {
         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,90 +49,92 @@ SOFTWARE.
 int setup_error = 0;
 int module_setup = 0;
 
-pins_t pins_info[] = {
+// Library Debug
-  { "GND",       "GND",         "U13_1",   -1, BASE_METHOD_AS_IS, -1, -1},
+int DEBUG = 0;
-  { "CHG-IN",    "CHG-IN",      "U13_2",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "VCC-5V",    "VCC-5V",      "U13_3",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U13_4",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "VCC-3V3",   "VCC-3V3",     "U13_5",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "TS",        "TS",          "U13_6",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "VCC-1V8",   "VCC-1V8",     "U13_7",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "BAT",       "BAT",         "U13_8",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "TWI1-SDA",  "KPD-I2C-SDA", "U13_9",   48, BASE_METHOD_AS_IS, -1, -1},
-  { "PWRON",     "PWRON",       "U13_10",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "TWI1-SCK",  "KPD-I2C-SCL", "U13_11",  47, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U13_12",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "X1",        "X1",          "U13_13",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "X2",        "X2",          "U13_14",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "Y1",        "Y1",          "U13_15",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "Y2",        "Y2",          "U13_16",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D2",    "LCD-D2",      "U13_17",  98, BASE_METHOD_AS_IS, -1, -1},
-  { "PWM0",      "PWM0",        "U13_18",  34, BASE_METHOD_AS_IS,  0, -1},
-  { "LCD-D4",    "LCD-D4",      "U13_19", 100, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D3",    "LCD-D3",      "U13_20",  99, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D6",    "LCD-D6",      "U13_21", 102, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D5",    "LCD-D5",      "U13_22", 101, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D10",   "LCD-D10",     "U13_23", 106, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D7",    "LCD-D7",      "U13_24", 103, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D12",   "LCD-D12",     "U13_25", 108, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D11",   "LCD-D11",     "U13_26", 107, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D14",   "LCD-D14",     "U13_27", 110, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D13",   "LCD-D13",     "U13_28", 109, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D18",   "LCD-D18",     "U13_29", 114, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D15",   "LCD-D15",     "U13_30", 111, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D20",   "LCD-D20",     "U13_31", 116, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D19",   "LCD-D19",     "U13_32", 115, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D22",   "LCD-D22",     "U13_33", 118, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D21",   "LCD-D21",     "U13_34", 117, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-CLK",   "LCD-CLK",     "U13_35", 120, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-D23",   "LCD-D23",     "U13_36", 119, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-VSYNC", "LCD-VSYNC",   "U13_37", 123, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-HSYNC", "LCD-HSYNC",   "U13_38", 122, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U13_39",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "LCD-DE",    "LCD-DE",      "U13_40", 121, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U14_1",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "VCC-5V",    "VCC-5V",      "U14_2",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "UART1-TX",  "UART-TX",     "U14_3",  195, BASE_METHOD_AS_IS, -1, -1},
-  { "HPL",       "HPL",         "U14_4",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "UART1-RX",  "UART-RX",     "U14_5",  196, BASE_METHOD_AS_IS, -1, -1},
-  { "HPCOM",     "HPCOM",       "U14_6",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "FEL",       "FEL",         "U14_7",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "HPR",       "HPR",         "U14_8",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "VCC-3V3",   "VCC-3V3",     "U14_9",   -1, BASE_METHOD_AS_IS, -1, -1},
-  { "MICM",      "MICM",        "U14_10",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "LRADC",     "ADC",         "U14_11",  -1, BASE_METHOD_AS_IS, -1,  0},
-  { "MICIN1",    "MICIN1",      "U14_12",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "XIO-P0",    "XIO-P0",      "U14_13",   0, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P1",    "XIO-P1",      "U14_14",   1, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P2",    "GPIO1",       "U14_15",   2, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P3",    "GPIO2",       "U14_16",   3, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P4",    "GPIO3",       "U14_17",   4, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P5",    "GPIO4",       "U14_18",   5, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P6",    "GPIO5",       "U14_19",   6, BASE_METHOD_XIO,   -1, -1},
-  { "XIO-P7",    "GPIO6",       "U14_20",   7, BASE_METHOD_XIO,   -1, -1},
-  { "GND",       "GND",         "U14_21",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U14_22",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "AP-EINT1",  "KPD-INT",     "U14_23", 193, BASE_METHOD_AS_IS, -1, -1},
-  { "AP-EINT3",  "AP-INT3",     "U14_24",  35, BASE_METHOD_AS_IS, -1, -1},
-  { "TWI2-SDA",  "I2C-SDA",     "U14_25",  50, BASE_METHOD_AS_IS, -1, -1},
-  { "TWI2-SCK",  "I2C-SCL",     "U14_26",  49, BASE_METHOD_AS_IS, -1, -1},
-  { "CSIPCK",    "SPI-SEL",     "U14_27", 128, BASE_METHOD_AS_IS, -1, -1},
-  { "CSICK",     "SPI-CLK",     "U14_28", 129, BASE_METHOD_AS_IS, -1, -1},
-  { "CSIHSYNC",  "SPI-MOSI",    "U14_29", 130, BASE_METHOD_AS_IS,  1, -1},
-  { "CSIVSYNC",  "SPI-MISO",    "U14_30", 131, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID0",     "CSID0",       "U14_31", 132, BASE_METHOD_AS_IS,  1, -1},
-  { "CSID1",     "CSID1",       "U14_32", 133, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID2",     "CSID2",       "U14_33", 134, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID3",     "CSID3",       "U14_34", 135, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID4",     "CSID4",       "U14_35", 136, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID5",     "CSID5",       "U14_36", 137, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID6",     "CSID6",       "U14_37", 138, BASE_METHOD_AS_IS, -1, -1},
-  { "CSID7",     "CSID7",       "U14_38", 139, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U14_39",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { "GND",       "GND",         "U14_40",  -1, BASE_METHOD_AS_IS, -1, -1},
-  { NULL,        NULL,          NULL,      -1, 0,                 -1, -1}
-};
 
+pins_t pins_info[] = {
+  { "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
@@ -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

@@ -54,20 +54,27 @@ SOFTWARE.
 #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.
 #define BASE_METHOD_AS_IS 1  /* use the gpio value directly */
 #define BASE_METHOD_XIO   2  /* add the gpio value to the XIO base */
+#define SPWM_ENABLED      1  /* pin able to be used by software pwm */
+#define SPWM_DISABLED     0  /* pin unable to be used by software pwm */
 
 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;
+    int pwm_mux_mode;   /* pwm pin */
-    int ain;
+    int ain;            /* analog pin */
+    int sbc_type;     /* which sbc pin is allowed */
 } pins_t;
 
 
@@ -81,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);
@@ -98,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.5");
+   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);

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;
@@ -215,7 +283,11 @@ int open_value_file(int gpio)
     // create file descriptor of value file
     snprintf(filename, sizeof(filename), "/sys/class/gpio/gpio%d/value", gpio); BUF2SMALL(filename);
 
-    if ((fd = open(filename, O_RDONLY | O_NONBLOCK)) < 0) {
+    // 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));
         add_error_msg(err);
@@ -234,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));
@@ -251,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);
@@ -272,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)
@@ -313,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)) {
@@ -359,6 +441,9 @@ int gpio_get_direction(int gpio, unsigned int *value)
         return -1;
     }
     
+    if (DEBUG)
+        printf(" ** gpio_get_direction: %s **\n",direction);
+
     if (strcmp(direction, "out") == 0)
         *value = OUTPUT;
     else if (strcmp(direction, "in") == 0)
@@ -376,18 +461,24 @@ int gpio_get_direction(int gpio, unsigned int *value)
 
 int gpio_set_value(int gpio, unsigned int value)
 {
-    int fd, e_no;
+    // This now uses the value file descriptor that is set in the other struct
+    // in an effort to minimize opening/closing this
+    int fd = fd_lookup(gpio);
+    int e_no;
     char filename[MAX_FILENAME];
     char vstr[16];
 
     snprintf(filename, sizeof(filename), "/sys/class/gpio/gpio%d/value", gpio); BUF2SMALL(filename);
 
-    if ((fd = open(filename, O_WRONLY)) < 0) {
+    if (!fd)
+    {
+        if ((fd = open_value_file(gpio)) == -1) {
             char err[256];
-        snprintf(err, sizeof(err), "gpio_set_value: could not open '%s' (%s)", filename, strerror(errno));
+            snprintf(err, sizeof(err), "gpio_get_value: could not open GPIO %d value file", gpio);
             add_error_msg(err);
             return -1;
         }
+    }
 
     if (value) {
         strncpy(vstr, "1", ARRAY_SIZE(vstr) - 1);
@@ -395,8 +486,10 @@ 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;
-    close(fd);
 
     if (s != strlen(vstr)) {
         char err[256];
@@ -437,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') {
@@ -465,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];
@@ -514,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;
@@ -546,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);
 }
@@ -555,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);
@@ -604,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);
             }
 
@@ -622,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;
@@ -755,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;
@@ -821,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);
 
@@ -864,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));
@@ -942,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()
+// Dummy function to mimic RPi.GPIO for easier porting.
-static PyObject *py_cleanup(PyObject *self, PyObject *args)
+// 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
+    // 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;
 }
@@ -101,15 +148,16 @@ static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwar
         init_module();
     }
  
-
     if (direction != INPUT && direction != OUTPUT)
     {
         PyErr_SetString(PyExc_ValueError, "An invalid direction was passed to setup()");
         return NULL;
     }
     
-   if (direction == OUTPUT)
+    // Force pud to be off if we're configured for output
+    if (direction == OUTPUT) {
         pud = PUD_OFF;
+    }
  
     if (pud != PUD_OFF && pud != PUD_DOWN && pud != PUD_UP)
     {
@@ -136,6 +184,23 @@ static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwar
         PyErr_SetString(PyExc_RuntimeError, err);
         return NULL;
     }
+    
+    // Pull Up/Down
+    // Only if the pin we want is able to use it (R8 Owned, no XIO)
+    int port, pin;
+    if (compute_port_pin(channel, gpio, &port, &pin) == 0) {
+        // Set the PUD
+        gpio_set_pud(port, pin, pud);
+        // Check it was set properly
+        int pudr = gpio_get_pud(port, pin);
+        if (pudr != pud) {
+            char err[2000];
+            snprintf(err, sizeof(err), "Error setting pull up down %d on channel %s", pud, channel);
+            PyErr_SetString(PyExc_RuntimeError, err);
+            return NULL;
+        }
+    }
+    
     if (direction == OUTPUT) {
         if (gpio_set_value(gpio, initial) < 0) {
             char err[2000];
@@ -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)

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) {
+    if (pwm_set_frequency(key, frequency) < 0) {
-        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_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
+    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_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_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"},
+    {"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"},
-    //{"setwarnings", py_setwarnings, METH_VARARGS, "Enable or disable warning messages"},
+    {"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")