Merge pull request #3 from aninternetof/feature/Add_softpwm_rebased

Add software PWM

README.rst

@@ -80,6 +80,24 @@ Detecting events::
     #set polarity to 1 on start:
     PWM.start("PWM0", 50, 2000, 1)
 
+**SOFTPWM**::
+
+    import CHIP_IO.SOFTPWM as PWM
+    #PWM.start(channel, duty, freq=2000, polarity=0)
+    #duty values are valid 0 (off) to 100 (on)
+    #you can choose any pin
+    PWM.start("XIO-P7", 50)
+    PWM.set_duty_cycle("XIO-P7", 25.5)
+    PWM.set_frequency("XIO-P7", 10)
+
+    PWM.stop("XIO-P7")
+    PWM.cleanup()
+
+    #set polarity to 1 on start:
+    PWM.start("XIO-P7", 50, 2000, 1)
+
+Use SOFTPWM at low speeds (hundreds of Hz) for the best results. Do not use for anything that needs high precision or reliability.
+
 **ADC**::
 
     Not Implemented yet

setup.py

@@ -31,5 +31,6 @@ setup(name             = 'CHIP_IO',
       classifiers      = classifiers,
       packages         = find_packages(),
       ext_modules      = [Extension('CHIP_IO.GPIO', ['source/py_gpio.c', 'source/event_gpio.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security']),
-                          Extension('CHIP_IO.PWM', ['source/py_pwm.c', 'source/c_pwm.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'])]) #,
+                          Extension('CHIP_IO.PWM', ['source/py_pwm.c', 'source/c_pwm.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security']),
+                          Extension('CHIP_IO.SOFTPWM', ['source/py_softpwm.c', 'source/c_softpwm.c', 'source/constants.c', 'source/common.c', 'source/event_gpio.c'], extra_compile_args=['-Wno-format-security'])]) #,
 #                          Extension('CHIP_IO.ADC', ['source/py_adc.c', 'source/c_adc.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security']),

source/c_softpwm.c

@@ -0,0 +1,339 @@
+/*
+Copyright (c) 2016 Brady Hurlburt
+
+Original BBIO Author Justin Cooper
+Modified for CHIP_IO Author Brady Hurlburt
+
+This file incorporates work covered by the following copyright and
+permission notice, all modified code adopts the original license:
+
+Copyright (c) 2013 Adafruit
+Author: Justin Cooper
+
+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.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <time.h>
+#include "c_pwm.h"
+#include "common.h"
+#include "event_gpio.h"
+#include "Python.h"
+
+#define KEYLEN 7
+
+#define PERIOD 0
+#define DUTY 1
+
+int pwm_initialized = 0;
+
+struct pwm_params
+{
+  float duty;
+  float freq;
+  bool enabled;
+  bool stop_flag;
+  int polarity;
+};
+
+struct softpwm
+{
+    char key[KEYLEN+1]; /* leave room for terminating NUL byte */
+    struct pwm_params params;
+    pthread_mutex_t* params_lock;
+    pthread_t thread;
+    struct softpwm *next;
+};
+struct softpwm *exported_pwms = NULL;
+
+struct softpwm *lookup_exported_pwm(const char *key)
+{
+    struct softpwm *pwm = exported_pwms;
+
+    while (pwm != NULL)
+    {
+        if (strcmp(pwm->key, key) == 0) {
+            return pwm;
+        }
+        pwm = pwm->next;
+    }
+
+    return NULL; /* standard for pointers */
+}
+
+int softpwm_set_frequency(const char *key, float freq) {
+    struct softpwm *pwm;
+
+    if (freq <= 0.0)
+        return -1;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    pthread_mutex_lock(pwm->params_lock);
+    pwm->params.freq = freq;
+    pthread_mutex_unlock(pwm->params_lock);
+
+    return 1;
+}
+
+int softpwm_set_polarity(const char *key, int polarity) {
+    struct softpwm *pwm;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    if (polarity < 0 || polarity > 1) {
+        return -1;
+    }
+
+    pthread_mutex_lock(pwm->params_lock);
+    pwm->params.polarity = polarity;
+    pthread_mutex_unlock(pwm->params_lock);
+
+    return 0;
+}
+
+int softpwm_set_duty_cycle(const char *key, float duty) {;
+    struct softpwm *pwm;
+
+    if (duty < 0.0 || duty > 100.0)
+        return -1;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    pthread_mutex_lock(pwm->params_lock);
+    pwm->params.duty = duty;
+    pthread_mutex_unlock(pwm->params_lock);
+
+    return 0;
+}
+
+void *softpwm_thread_toggle(void *key)
+{
+  struct softpwm *pwm;
+  unsigned int gpio;
+  struct timespec tim_on;
+  struct timespec tim_off;
+  unsigned int sec;
+  unsigned int period_ns;
+  unsigned int on_ns;
+  unsigned int off_ns;
+
+  /* Used to determine if something has
+   * has changed
+   */
+  float freq_local = 0;
+  float duty_local = 0;
+  unsigned int polarity_local = 0;
+  bool stop_flag_local = false;
+  bool enabled_local = false;
+  bool recalculate_timing = false;
+
+
+  get_gpio_number(key, &gpio);
+  pwm = lookup_exported_pwm((char*)key);
+
+  while (!stop_flag_local) {
+    pthread_mutex_lock(pwm->params_lock);
+    if ((freq_local != pwm->params.freq) || (duty_local != pwm->params.duty)) {
+      recalculate_timing = true;
+    }
+    freq_local = pwm->params.freq;
+    duty_local = pwm->params.duty;
+    enabled_local = pwm->params.enabled;
+    stop_flag_local = pwm->params.stop_flag;
+    polarity_local = pwm->params.polarity;
+    pthread_mutex_unlock(pwm->params_lock);
+    /* If freq or duty has been changed, update the
+     * sleep times
+     */
+    if (recalculate_timing) {
+      period_ns = (unsigned long)(1e9 / freq_local);
+      on_ns = (unsigned long)(period_ns * (duty_local/100));
+      off_ns = period_ns - on_ns;
+      sec = (unsigned int)(on_ns/1e9); /* Intentional truncation */
+      tim_on.tv_sec = sec;
+      tim_on.tv_nsec = on_ns - (sec*1e9);
+      sec = (unsigned int)(off_ns/1e9); /* Intentional truncation */
+      tim_off.tv_sec = sec;
+      tim_off.tv_nsec = off_ns - (sec*1e9);
+      recalculate_timing = false;
+    }
+
+    if (enabled_local)
+    {
+
+      /* Force 0 duty cycle to be 0 */
+      if (duty_local != 0)
+      {
+        /* Set gpio */
+        if (!polarity_local)
+          gpio_set_value(gpio, HIGH);
+        else
+          gpio_set_value(gpio, LOW);
+      }
+
+      nanosleep(&tim_on, NULL);
+
+      /* Force 100 duty cycle to be 100 */
+      if (duty_local != 100)
+      {
+        /* Unset gpio */
+        if (!polarity_local)
+          gpio_set_value(gpio, LOW);
+        else
+          gpio_set_value(gpio, HIGH);
+      }
+
+      nanosleep(&tim_off, NULL);
+    }
+  }
+
+  if (!polarity_local)
+    gpio_set_value(gpio, LOW);
+  else
+    gpio_set_value(gpio, HIGH);
+
+  /* This pwm has been disabled */
+  pthread_exit(NULL);
+}
+
+int softpwm_start(const char *key, float duty, float freq, int polarity)
+{
+    struct softpwm *new_pwm, *pwm;
+    pthread_t new_thread;
+    pthread_mutex_t *new_params_lock;
+    unsigned int gpio;
+    int ret;
+
+    get_gpio_number(key, &gpio);
+    gpio_export(gpio);
+    gpio_set_direction(gpio, OUTPUT);
+
+    // add to list
+    new_pwm = malloc(sizeof(struct softpwm));
+    if (new_pwm == 0) {
+        return -1; // out of memory
+    }
+    new_params_lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+    if (new_pwm == 0) {
+        return -1; // out of memory
+    }
+    pthread_mutex_init(new_params_lock, NULL);
+
+    strncpy(new_pwm->key, key, KEYLEN);  /* can leave string unterminated */
+    new_pwm->key[KEYLEN] = '\0'; /* terminate string */
+    new_pwm->params.enabled = false;
+    new_pwm->params.stop_flag = false;
+    new_pwm->params_lock = new_params_lock;
+    new_pwm->next = NULL;
+
+    if (exported_pwms == NULL)
+    {
+        // create new list
+        exported_pwms = new_pwm;
+    } else {
+        // add to end of existing list
+        pwm = exported_pwms;
+        while (pwm->next != NULL)
+            pwm = pwm->next;
+        pwm->next = new_pwm;
+    }
+
+    softpwm_set_duty_cycle(new_pwm->key, duty);
+    softpwm_set_frequency(new_pwm->key, freq);
+    softpwm_set_polarity(new_pwm->key, polarity);
+
+    // create thread for pwm
+    ret = pthread_create(&new_thread, NULL, softpwm_thread_toggle, (void *)new_pwm->key);
+    if (ret) {
+       PySys_WriteStderr("DEBUG; soft_pwm ERROR IN pthread_create\n");
+       exit(-1);
+    }
+
+    new_pwm->thread = new_thread;
+    pthread_mutex_lock(new_params_lock);
+    new_pwm->params.enabled = true;
+    pthread_mutex_unlock(new_params_lock);
+
+    return 1;
+}
+
+int softpwm_disable(const char *key)
+{
+    struct softpwm *pwm, *temp, *prev_pwm = NULL;
+    unsigned int gpio = 0;
+
+    // remove from list
+    pwm = exported_pwms;
+    while (pwm != NULL)
+    {
+        if (strcmp(pwm->key, key) == 0)
+        {
+            pthread_mutex_lock(pwm->params_lock);
+            pwm->params.stop_flag = true;
+            pthread_mutex_unlock(pwm->params_lock);
+            get_gpio_number(key, &gpio);
+            gpio_set_value(gpio, LOW);
+            gpio_unexport(gpio);
+
+            if (prev_pwm == NULL)
+            {
+                exported_pwms = pwm->next;
+                prev_pwm = pwm;
+            } else {
+                prev_pwm->next = pwm->next;
+            }
+
+            temp = pwm;
+            pwm = pwm->next;
+            free(temp->params_lock);
+            free(temp);
+        } else {
+            prev_pwm = pwm;
+            pwm = pwm->next;
+        }
+    }
+    return 0;
+}
+
+void softpwm_cleanup(void)
+{
+    while (exported_pwms != NULL) {
+        softpwm_disable(exported_pwms->key);
+    }
+}

source/c_softpwm.h

@@ -0,0 +1,37 @@
+/*
+Copyright (c) 2016 Brady Hurlburt
+
+Original BBIO Author Justin Cooper
+Modified for CHIP_IO Author Brady Hurlburt
+
+This file incorporates work covered by the following copyright and
+permission notice, all modified code adopts the original license:
+
+Copyright (c) 2013 Adafruit
+Author: Justin Cooper
+
+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.
+*/
+
+int softpwm_start(const char *key, float duty, float freq, int polarity);
+int softpwm_disable(const char *key);
+int softpwm_set_frequency(const char *key, float freq);
+int softpwm_set_duty_cycle(const char *key, float duty);
+int softpwm_set_enable(const char *key, int enable);
+void softpwm_cleanup(void);

source/common.c

@@ -189,6 +189,19 @@ int lookup_ain_by_name(const char *name)
   return -1;
 }
 
+int copy_key_by_key(const char *input_key, char *key)
+{
+    pins_t *p;
+    for (p = table; p->key != NULL; ++p) {
+        if (strcmp(p->key, input_key) == 0) {
+            strncpy(key, p->key, 7);
+            key[7] = '\0';
+            return 1;
+        }
+    }
+    return 0;
+}
+
 int copy_pwm_key_by_key(const char *input_key, char *key)
 {
     pins_t *p;
@@ -206,6 +219,19 @@ int copy_pwm_key_by_key(const char *input_key, char *key)
     return 0;
 }
 
+int get_key_by_name(const char *name, char *key)
+{
+    pins_t *p;
+    for (p = table; p->name != NULL; ++p) {
+        if (strcmp(p->name, name) == 0) {
+            strncpy(key, p->key, 7);
+            key[7] = '\0';
+            return 1;
+        }
+    }
+    return 0;
+}
+
 int get_pwm_key_by_name(const char *name, char *key)
 {
     pins_t *p;
@@ -234,6 +260,15 @@ int get_gpio_number(const char *key, unsigned int *gpio)
     return 0;
 }
 
+int get_key(const char *input, char *key)
+{
+    if (!copy_key_by_key(input, key)) {
+        return get_key_by_name(input, key);
+    }
+
+    return 1;
+}
+
 int get_pwm_key(const char *input, char *key)
 {
     if (!copy_pwm_key_by_key(input, key)) {

source/common.h

@@ -52,6 +52,7 @@ char ocp_dir[25];
 
 int get_gpio_number(const char *key, unsigned int *gpio);
 int get_pwm_key(const char *input, char *key);
+int get_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);

source/py_softpwm.c

@@ -0,0 +1,214 @@
+/*
+Copyright (c) 2016 Brady Hurlburt
+
+Original BBIO Author Justin Cooper
+Modified for CHIP_IO Author Brady Hurlburt
+
+This file incorporates work covered by the following copyright and
+permission notice, all modified code adopts the original license:
+
+Copyright (c) 2013 Adafruit
+Author: Justin Cooper
+
+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.
+*/
+
+#include "Python.h"
+#include "constants.h"
+#include "common.h"
+#include "c_softpwm.h"
+
+// python function cleanup()
+static PyObject *py_cleanup(PyObject *self, PyObject *args)
+{
+    // unexport the PWM
+    softpwm_cleanup();
+
+    Py_RETURN_NONE;
+}
+
+// python function start(channel, duty_cycle, freq)
+static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char key[8];
+    char *channel;
+    float frequency = 2000.0;
+    float duty_cycle = 0.0;
+    int polarity = 0;
+    static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ffi", kwlist, &channel, &duty_cycle, &frequency, &polarity)) {
+        return NULL;
+    }
+
+    if (!get_key(channel, key)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid SOFTPWM key or name.");
+        return NULL;
+    }
+
+    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)
+    {
+        PyErr_SetString(PyExc_ValueError, "frequency must be greater than 0.0");
+        return NULL;
+    }
+
+    if (polarity < 0 || polarity > 1) {
+        PyErr_SetString(PyExc_ValueError, "polarity must be either 0 or 1");
+        return NULL;
+    }
+
+    if (!softpwm_start(key, duty_cycle, frequency, polarity))
+        return NULL;
+
+    Py_RETURN_NONE;
+}
+
+// python function stop(channel)
+static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char key[8];
+    char *channel;
+
+    if (!PyArg_ParseTuple(args, "s", &channel))
+        return NULL;
+
+    if (!get_key(channel, key)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name.");
+        return NULL;
+    }
+
+    softpwm_disable(key);
+
+    Py_RETURN_NONE;
+}
+
+// python method PWM.set_duty_cycle(channel, duty_cycle)
+static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char key[8];
+    char *channel;
+    float duty_cycle = 0.0;
+    static char *kwlist[] = {"channel", "duty_cycle", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", kwlist, &channel, &duty_cycle))
+        return NULL;
+
+    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 (!get_key(channel, key)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name.");
+        return NULL;
+    }
+
+    if (softpwm_set_duty_cycle(key, duty_cycle) == -1) {
+        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
+// python method PWM.set_frequency(channel, frequency)
+static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char key[8];
+    char *channel;
+    float frequency = 1.0;
+    static char *kwlist[] = {"channel", "frequency", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", kwlist, &channel, &frequency))
+        return NULL;
+
+    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;
+    }
+
+    if (!get_key(channel, key)) {
+        PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name.");
+        return NULL;
+    }
+
+    if (softpwm_set_frequency(key, frequency) == -1) {
+        PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
+
+static const char moduledocstring[] = "Software PWM functionality of a CHIP using Python";
+
+PyMethodDef pwm_methods[] = {
+    {"start", (PyCFunction)py_start_channel, METH_VARARGS | METH_KEYWORDS, "Set up and start the PWM channel.  channel can be in the form of 'XIO-P0', or 'U14_13'"},
+    {"stop", (PyCFunction)py_stop_channel, METH_VARARGS | METH_KEYWORDS, "Stop the PWM channel.  channel can be in the form of 'XIO-P0', or 'U14_13'"},
+    { "set_duty_cycle", (PyCFunction)py_set_duty_cycle, METH_VARARGS, "Change the duty cycle\ndutycycle - between 0.0 and 100.0" },
+    { "set_frequency", (PyCFunction)py_set_frequency, METH_VARARGS, "Change the frequency\nfrequency - frequency in Hz (freq > 0.0)" },
+    {"cleanup", py_cleanup, METH_VARARGS, "Clean up by resetting all GPIO channels that have been used by this program to INPUT with no pullup/pulldown and no event detection"},
+    //{"setwarnings", py_setwarnings, METH_VARARGS, "Enable or disable warning messages"},
+    {NULL, NULL, 0, NULL}
+};
+
+#if PY_MAJOR_VERSION > 2
+static struct PyModuleDef chippwmmodule = {
+    PyModuleDef_HEAD_INIT,
+    "SOFTPWM",       // name of module
+    moduledocstring,  // module documentation, may be NULL
+    -1,               // size of per-interpreter state of the module, or -1 if the module keeps state in global variables.
+    pwm_methods
+};
+#endif
+
+#if PY_MAJOR_VERSION > 2
+PyMODINIT_FUNC PyInit_SOFTPWM(void)
+#else
+PyMODINIT_FUNC initSOFTPWM(void)
+#endif
+{
+    PyObject *module = NULL;
+
+#if PY_MAJOR_VERSION > 2
+    if ((module = PyModule_Create(&chippwmmodule)) == NULL)
+       return NULL;
+#else
+    if ((module = Py_InitModule3("SOFTPWM", pwm_methods, moduledocstring)) == NULL)
+       return;
+#endif
+
+   define_constants(module);
+
+
+#if PY_MAJOR_VERSION > 2
+    return module;
+#else
+    return;
+#endif
+}

test/test_softpwm_setup.py

@@ -0,0 +1,104 @@
+import pytest
+import os
+
+import CHIP_IO.SOFTPWM as PWM
+
+def teardown_module(module):
+    PWM.cleanup()
+
+class TestSoftpwmSetup:
+    def test_start_pwm(self):
+        PWM.start("XIO-P7", 50, 10)
+        assert os.path.exists('/sys/class/gpio/gpio415')
+        direction = open('/sys/class/gpio/gpio415/direction').read()
+        assert direction == 'out\n'
+        PWM.cleanup()
+
+    def test_pwm_start_invalid_pwm_key(self):
+        with pytest.raises(ValueError):
+            PWM.start("P8_25", -1)
+
+    def test_pwm_start_invalid_duty_cycle_negative(self):
+        with pytest.raises(ValueError):
+            PWM.start("XIO-P7", -1)
+
+    def test_pwm_start_valid_duty_cycle_min(self):
+        #testing an exception isn't thrown
+        PWM.start("XIO-P7", 0)
+        PWM.cleanup()
+
+    def test_pwm_start_valid_duty_cycle_max(self):
+        #testing an exception isn't thrown
+        PWM.start("XIO-P7", 100)
+        PWM.cleanup()
+
+    def test_pwm_start_invalid_duty_cycle_high(self):
+        with pytest.raises(ValueError):
+            PWM.start("XIO-P7", 101)
+
+    def test_pwm_start_invalid_duty_cycle_string(self):
+        with pytest.raises(TypeError):
+            PWM.start("XIO-P7", "1")
+
+    def test_pwm_start_invalid_frequency_negative(self):
+        with pytest.raises(ValueError):
+            PWM.start("XIO-P7", 0, -1)
+
+    def test_pwm_start_invalid_frequency_string(self):
+        with pytest.raises(TypeError):
+            PWM.start("XIO-P7", 0, "1")
+
+    def test_pwm_start_negative_polarity(self):
+        with pytest.raises(ValueError):
+            PWM.start("XIO-P7", 0, 100, -1)
+
+    def test_pwm_start_invalid_positive_polarity(self):
+        with pytest.raises(ValueError):
+            PWM.start("XIO-P7", 0, 100, 2)
+
+    def test_pwm_start_invalid_polarity_type(self):
+        with pytest.raises(TypeError):
+            PWM.start("XIO-P7", 0, 100, "1")
+
+    def test_pwm_duty_cycle_non_setup_key(self):
+        with pytest.raises(RuntimeError):
+            PWM.set_duty_cycle("XIO-P7", 100)
+            PWM.cleanup()
+
+    def test_pwm_duty_cycle_invalid_key(self):
+        with pytest.raises(ValueError):
+            PWM.set_duty_cycle("P9_15", 100)
+            PWM.cleanup()
+
+    def test_pwm_duty_cycle_invalid_value_high(self):
+        PWM.start("XIO-P7", 0)
+        with pytest.raises(ValueError):
+            PWM.set_duty_cycle("XIO-P7", 101)
+            PWM.cleanup()
+
+    def test_pwm_duty_cycle_invalid_value_negative(self):
+        PWM.start("XIO-P7", 0)
+        with pytest.raises(ValueError):
+            PWM.set_duty_cycle("XIO-P7", -1)
+            PWM.cleanup()
+
+    def test_pwm_duty_cycle_invalid_value_string(self):
+        PWM.start("XIO-P7", 0)
+        with pytest.raises(TypeError):
+            PWM.set_duty_cycle("XIO-P7", "a")
+            PWM.cleanup()
+
+    def test_pwm_frequency_invalid_value_negative(self):
+        PWM.start("XIO-P7", 0)
+        with pytest.raises(ValueError):
+            PWM.set_frequency("XIO-P7", -1)
+            PWM.cleanup()
+
+    def test_pwm_frequency_invalid_value_string(self):
+        PWM.start("XIO-P7", 0)
+        with pytest.raises(TypeError):
+            PWM.set_frequency("XIO-P7", "11")
+            PWM.cleanup()
+
+    def test_stop_pwm(self):
+        pass