Adds softpwm files

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'], 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_pwm.c

@@ -147,7 +147,7 @@ int pwm_set_polarity(const char *key, int polarity) {
     else
     {
         len = snprintf(buffer, sizeof(buffer), "%s", "inverted");
-    } 
+    }
     write(pwm->polarity_fd, buffer, len);
 
     return 0;

source/c_softpwm.c

@@ -0,0 +1,344 @@
+/*
+Copyright (c) 2016 Robert Wolterman
+
+Original BBIO Author Justin Cooper
+Modified for CHIP_IO Author Robert Wolterman
+
+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 <sys/types.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "c_pwm.h"
+#include "common.h"
+
+#define KEYLEN 7
+
+#define PERIOD 0
+#define DUTY 1
+
+int pwm_initialized = 0;
+
+// pwm exports
+struct pwm_exp
+{
+    char key[KEYLEN+1]; /* leave room for terminating NUL byte */
+    int period_fd;
+    int duty_fd;
+    int polarity_fd;
+    int enable_fd;
+    int enable;
+    unsigned long duty;
+    unsigned long period_ns;
+    struct pwm_exp *next;
+};
+struct pwm_exp *exported_pwms = NULL;
+
+struct pwm_exp *lookup_exported_pwm(const char *key)
+{
+    struct pwm_exp *pwm = exported_pwms;
+
+    while (pwm != NULL)
+    {
+        if (strcmp(pwm->key, key) == 0) {
+            return pwm;
+        }
+        pwm = pwm->next;
+    }
+
+    return NULL; /* standard for pointers */
+}
+
+int initialize_pwm(void)
+{
+    if  (!pwm_initialized) {
+        int fd, len;
+        char str_gpio[2];
+        // Per https://github.com/NextThingCo/CHIP-linux/pull/4
+        // we need to export 0 here to enable pwm0
+        int gpio = 0;
+
+        if ((fd = open("/sys/class/pwm/pwmchip0/export", O_WRONLY)) < 0)
+        {
+            return -1;
+        }
+        len = snprintf(str_gpio, sizeof(str_gpio), "%d", gpio);
+        write(fd, str_gpio, len);
+        close(fd);
+
+        pwm_initialized = 1;
+        return 1;
+    }
+
+    return 0;
+}
+
+int softpwm_set_frequency(const char *key, float freq) {
+    int len;
+    char buffer[20];
+    unsigned long period_ns;
+    struct pwm_exp *pwm;
+
+    if (freq <= 0.0)
+        return -1;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    period_ns = (unsigned long)(1e9 / freq);
+
+    if (period_ns != pwm->period_ns) {
+        pwm->period_ns = period_ns;
+
+        len = snprintf(buffer, sizeof(buffer), "%lu", period_ns);
+        write(pwm->period_fd, buffer, len);
+    }
+
+    return 1;
+}
+
+int softpwm_set_polarity(const char *key, int polarity) {
+    int len;
+    char buffer[9]; /* allow room for trailing NUL byte */
+    struct pwm_exp *pwm;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    if (polarity < 0 || polarity > 1) {
+        return -1;
+    }
+
+    if (polarity == 0) {
+        len = snprintf(buffer, sizeof(buffer), "%s", "normal");
+    }
+    else
+    {
+        len = snprintf(buffer, sizeof(buffer), "%s", "inverted");
+    }
+    write(pwm->polarity_fd, buffer, len);
+
+    return 0;
+}
+
+int softpwm_set_duty_cycle(const char *key, float duty) {
+    int len;
+    char buffer[20];
+    struct pwm_exp *pwm;
+
+    if (duty < 0.0 || duty > 100.0)
+        return -1;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    pwm->duty = (unsigned long)(pwm->period_ns * (duty / 100.0));
+
+    len = snprintf(buffer, sizeof(buffer), "%lu", pwm->duty);
+    write(pwm->duty_fd, buffer, len);
+
+    return 0;
+}
+
+int softpwm_set_enable(const char *key, int enable)
+{
+    int len;
+    char buffer[20];
+    struct pwm_exp *pwm;
+
+    if (enable != 0 || enable != 1)
+        return -1;
+
+    pwm = lookup_exported_pwm(key);
+
+    if (pwm == NULL) {
+        return -1;
+    }
+
+    pwm->enable = enable;
+
+    len = snprintf(buffer, sizeof(buffer), "%d", pwm->enable);
+    write(pwm->enable_fd, buffer, len);
+
+    return 0;
+}
+
+int softpwm_start(const char *key, float duty, float freq, int polarity)
+{
+    char pwm_base_path[45];
+    char period_path[50];
+    char duty_path[50];
+    char enable_path[50];
+    char polarity_path[55];
+    int period_fd, duty_fd, polarity_fd, enable_fd;
+    struct pwm_exp *new_pwm, *pwm;
+
+    if(!pwm_initialized) {
+        initialize_pwm();
+    }
+
+    //setup the pwm base path, the chip only has one pwm
+    snprintf(pwm_base_path, sizeof(pwm_base_path), "/sys/class/pwm/pwmchip0/%d", "pwm0");
+
+    //create the path for the period and duty
+    snprintf(enable_path, sizeof(enable_path), "%s/enable", pwm_base_path);
+    snprintf(period_path, sizeof(period_path), "%s/period", pwm_base_path);
+    snprintf(duty_path, sizeof(duty_path), "%s/duty_cycle", pwm_base_path);
+    snprintf(polarity_path, sizeof(polarity_path), "%s/polarity", pwm_base_path);
+
+    //add period and duty fd to pwm list
+    if ((enable_fd = open(enable_path, O_RDWR)) < 0)
+        return -1;
+
+    if ((period_fd = open(period_path, O_RDWR)) < 0) {
+        close(enable_fd);
+        return -1;
+    }
+
+
+    if ((duty_fd = open(duty_path, O_RDWR)) < 0) {
+        //error, close already opened period_fd.
+        close(enable_fd);
+        close(period_fd);
+        return -1;
+    }
+
+    if ((polarity_fd = open(polarity_path, O_RDWR)) < 0) {
+        //error, close already opened period_fd and duty_fd.
+        close(enable_fd);
+        close(period_fd);
+        close(duty_fd);
+        return -1;
+    }
+
+    // add to list
+    new_pwm = malloc(sizeof(struct pwm_exp));
+    if (new_pwm == 0) {
+        return -1; // out of memory
+    }
+
+    strncpy(new_pwm->key, key, KEYLEN);  /* can leave string unterminated */
+    new_pwm->key[KEYLEN] = '\0'; /* terminate string */
+    new_pwm->period_fd = period_fd;
+    new_pwm->duty_fd = duty_fd;
+    new_pwm->polarity_fd = polarity_fd;
+    new_pwm->enable_fd = enable_fd;
+    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_frequency(key, freq);
+    softpwm_set_polarity(key, polarity);
+    softpwm_set_enable(key, 1);
+    softpwm_set_duty_cycle(key, duty);
+
+    return 1;
+}
+
+int softpwm_disable(const char *key)
+{
+    struct pwm_exp *pwm, *temp, *prev_pwm = NULL;
+    char fragment[18];
+
+    int fd, len;
+    char str_gpio[2];
+    // Per https://github.com/NextThingCo/CHIP-linux/pull/4
+    // we need to export 0 here to enable pwm0
+    int gpio = 0;
+
+    // Disable the PWM
+    softpwm_set_frequency(key, 0);
+    softpwm_set_polarity(key, 0);
+    softpwm_set_enable(key, 0);
+    softpwm_set_duty_cycle(key, 0);
+
+    if ((fd = open("/sys/class/pwm/pwmchip0/unexport", O_WRONLY)) < 0)
+    {
+        return -1;
+    }
+    len = snprintf(str_gpio, sizeof(str_gpio), "%d", gpio);
+    write(fd, str_gpio, len);
+    close(fd);
+
+    // remove from list
+    pwm = exported_pwms;
+    while (pwm != NULL)
+    {
+        if (strcmp(pwm->key, key) == 0)
+        {
+            //close the fd
+            close(pwm->enable_fd);
+            close(pwm->period_fd);
+            close(pwm->duty_fd);
+            close(pwm->polarity_fd);
+
+            if (prev_pwm == NULL)
+            {
+                exported_pwms = pwm->next;
+                prev_pwm = pwm;
+            } else {
+                prev_pwm->next = pwm->next;
+            }
+
+            temp = pwm;
+            pwm = pwm->next;
+            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 Robert Wolterman
+
+Original BBIO Author Justin Cooper
+Modified for CHIP_IO Author Robert Wolterman
+
+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

@@ -187,7 +187,20 @@ 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)
 {
@@ -204,9 +217,22 @@ 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)
+int get_pwm_key_by_name(const char *name, char *key)
 {
     pins_t *p;
     for (p = table; p->name != NULL; ++p) {
@@ -232,7 +258,16 @@ 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)
 {
@@ -241,8 +276,8 @@ int get_pwm_key(const char *input, char *key)
     }
 
     return 1;
-}
+}
-
+
 int get_adc_ain(const char *key, unsigned int *ain)
 {
     *ain = lookup_ain_by_key(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 Robert Wolterman
+
+Original BBIO Author Justin Cooper
+Modified for CHIP_IO Author Robert Wolterman
+
+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 PWM 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 (pwm_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
+}