From 9d593828ae2634edf4da2fe658048ca090df1132 Mon Sep 17 00:00:00 2001 From: Robert Wolterman Date: Thu, 25 Feb 2016 22:38:58 -0600 Subject: [PATCH] Initial PWM support for the CHIP even though the base .dtb does not support, this is untested --- setup.py | 6 +- source/c_pwm.c | 291 ++++++++++++++++++++++++++++++++++++++++++++++++ source/c_pwm.h | 36 ++++++ source/common.c | 4 +- source/py_pwm.c | 214 +++++++++++++++++++++++++++++++++++ source/setup.py | 36 ------ 6 files changed, 546 insertions(+), 41 deletions(-) create mode 100644 source/c_pwm.c create mode 100644 source/c_pwm.h create mode 100644 source/py_pwm.c delete mode 100644 source/setup.py diff --git a/setup.py b/setup.py index 1603471..18df3ed 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ classifiers = ['Development Status :: 3 - Alpha', 'Topic :: System :: Hardware'] setup(name = 'CHIP_IO', - version = '0.0.2', + version = '0.0.5', author = 'Robert Wolterman', author_email = 'robert.wolterman@gmail.com', description = 'A module to control CHIP IO channels', @@ -30,7 +30,7 @@ setup(name = 'CHIP_IO', url = 'https://github.com/xtacocorex/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']), + 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.ADC', ['source/py_adc.c', 'source/c_adc.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security']), # Extension('CHIP_IO.SPI', ['source/spimodule.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'])]) diff --git a/source/c_pwm.c b/source/c_pwm.c new file mode 100644 index 0000000..355ec55 --- /dev/null +++ b/source/c_pwm.c @@ -0,0 +1,291 @@ +/* +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 +#include +#include +#include +#include +#include +#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; + 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 pwm_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 pwm_set_polarity(const char *key, int polarity) { + int len; + char buffer[7]; /* allow room for trailing NUL byte */ + struct pwm_exp *pwm; + + pwm = lookup_exported_pwm(key); + + if (pwm == NULL) { + return -1; + } + + len = snprintf(buffer, sizeof(buffer), "%d", polarity); + write(pwm->polarity_fd, buffer, len); + + return 0; +} + +int pwm_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 pwm_start(const char *key, float duty, float freq, int polarity) +{ + char pwm_base_path[45]; + char period_path[50]; + char duty_path[50]; + char polarity_path[55]; + int period_fd, duty_fd, polarity_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(period_path, sizeof(period_path), "%s/period", pwm_base_path); + snprintf(duty_path, sizeof(duty_path), "%s/duty", pwm_base_path); + snprintf(polarity_path, sizeof(polarity_path), "%s/polarity", pwm_base_path); + + //add period and duty fd to pwm list + if ((period_fd = open(period_path, O_RDWR)) < 0) + return -1; + + + if ((duty_fd = open(duty_path, O_RDWR)) < 0) { + //error, close already opened period_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(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->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; + } + + pwm_set_frequency(key, freq); + pwm_set_polarity(key, polarity); + pwm_set_duty_cycle(key, duty); + + return 1; +} + +int pwm_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; + + 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->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 pwm_cleanup(void) +{ + while (exported_pwms != NULL) { + pwm_disable(exported_pwms->key); + } +} diff --git a/source/c_pwm.h b/source/c_pwm.h new file mode 100644 index 0000000..319e1d6 --- /dev/null +++ b/source/c_pwm.h @@ -0,0 +1,36 @@ +/* +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 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_duty_cycle(const char *key, float duty); +void pwm_cleanup(void); diff --git a/source/common.c b/source/common.c index 2bbc19d..05b6091 100644 --- a/source/common.c +++ b/source/common.c @@ -71,7 +71,7 @@ pins_t table[] = { { "Y1", "U13_15", 0, -1, -1}, { "Y2", "U13_16", 0, -1, -1}, { "LCD-D2", "U13_17", 98, -1, -1}, - { "PWM0", "U13_18", 34, -1, -1}, + { "PWM0", "U13_18", 34, 0, -1}, { "LCD-D4", "U13_19", 100, -1, -1}, { "LCD-D3", "U13_20", 99, -1, -1}, { "LCD-D6", "U13_21", 102, -1, -1}, @@ -104,7 +104,7 @@ pins_t table[] = { { "HPR", "U14_8", 0, -1, -1}, { "VCC-3V3", "U14_9", 0, -1, -1}, { "MICM", "U14_10", 0, -1, -1}, - { "LRADC", "U14_11", 0, -1, -1}, + { "LRADC", "U14_11", 0, -1, 0}, { "MICIN1", "U14_12", 0, -1, -1}, { "XIO-P0", "U14_13", 408, -1, -1}, { "XIO-P1", "U14_14", 409, -1, -1}, diff --git a/source/py_pwm.c b/source/py_pwm.c new file mode 100644 index 0000000..6631a74 --- /dev/null +++ b/source/py_pwm.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_pwm.h" + +// python function cleanup() +static PyObject *py_cleanup(PyObject *self, PyObject *args) +{ + // unexport the PWM + pwm_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_pwm_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 (!pwm_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_pwm_key(channel, key)) { + PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name."); + return NULL; + } + + pwm_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_pwm_key(channel, key)) { + PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name."); + return NULL; + } + + if (pwm_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) + { + PyErr_SetString(PyExc_ValueError, "frequency must be greater than 0.0"); + return NULL; + } + + if (!get_pwm_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[] = "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 'PWM0', or 'U13_18'"}, + {"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)" }, + {"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 bbpwmmodule = { + PyModuleDef_HEAD_INIT, + "PWM", // 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_PWM(void) +#else +PyMODINIT_FUNC initPWM(void) +#endif +{ + PyObject *module = NULL; + +#if PY_MAJOR_VERSION > 2 + if ((module = PyModule_Create(&bbpwmmodule)) == NULL) + return NULL; +#else + if ((module = Py_InitModule3("PWM", pwm_methods, moduledocstring)) == NULL) + return; +#endif + + define_constants(module); + + +#if PY_MAJOR_VERSION > 2 + return module; +#else + return; +#endif +} diff --git a/source/setup.py b/source/setup.py deleted file mode 100644 index f95ef40..0000000 --- a/source/setup.py +++ /dev/null @@ -1,36 +0,0 @@ -try: - from overlays import builder - builder.compile() - builder.copy() -except: - pass - -import distribute_setup -distribute_setup.use_setuptools() -from setuptools import setup, Extension, find_packages - -classifiers = ['Development Status :: 3 - Alpha', - 'Operating System :: POSIX :: Linux', - 'License :: OSI Approved :: MIT License', - 'Intended Audience :: Developers', - 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3', - 'Topic :: Software Development', - 'Topic :: Home Automation', - 'Topic :: System :: Hardware'] - -setup(name = 'CHIP_IO', - version = '0.0.4', - author = 'Robert Wolterman', - author_email = 'robert.wolterman@gmail.com', - description = 'A module to control CHIP IO channels', - long_description = open('README.md').read() + open('CHANGELOG.rst').read(), - license = 'MIT', - keywords = 'CHIP NextThingCo IO GPIO PWM ADC', - url = 'https://github.com/xtacocorex/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.ADC', ['source/py_adc.c', 'source/c_adc.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security']), -# Extension('CHIP_IO.SPI', ['source/spimodule.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'])])