Others/CHIP_IO
1
0
Fork 0
mirror of https://github.com/xtacocorex/CHIP_IO synced 2025-07-20 04:43:21 +00:00
Code Issues Releases Activity

More work on #32, Checks for gpio being invalid on specific hardware, pwm invalid checks done. Need to do proper export of PWM1 on CHIP Pro

Browse Source
This commit is contained in:
Robert Wolterman
2017-02-20 05:03:04 +00:00
parent e179e52b5e
commit ca7d221b33
7 changed files with 613 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
README.rst
View File

@ -44,113 +44,115 @@ All scripts that require GPIO, PWM (HW and/or SW), and Overlay Manager need to b
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.
+------------------+--------------------------+--------+
| 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 | D0 | U14_31 |
+------------------+--------------------------+--------+
| CSID1 | D1 | U14_32 |
+------------------+--------------------------+--------+
| CSID2 | D2 | U14_33 |
+------------------+--------------------------+--------+
| CSID3 | D3 | U14_34 |
+------------------+--------------------------+--------+
| CSID4 | D4 | U14_35 |
+------------------+--------------------------+--------+
| CSID5 | D5 | U14_36 |
+------------------+--------------------------+--------+
| CSID6 | D6 | U14_37 |
+------------------+--------------------------+--------+
| CSID7 | D7 | U14_38 |
+------------------+--------------------------+--------+
+------------------+--------------------------+-------------+-----------------+
| CHIP (Name) | PocketCHIP/CHIP Pro Name | CHIP Key | HW Support |
+------------------+--------------------------+-------------+-----------------+
| TWI1-SDA | KPD-I2C-SDA | U13_9 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| TWI1-SCK | KPD-I2C-SCL | U13_11 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| LCD-D2 | UART2-TX | U13_17 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| PWM0 | PWM0 | U13_18 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| PWM1 | PWM1 | EINT13 | CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| LCD-D4 | UART2-CTS | U13_19 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| LCD-D3 | UART2-RX | U13_20 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| LCD-D6 | LCD-D6 | U13_21 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D5 | UART2-RTS | U13_22 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| LCD-D10 | LCD-D10 | U13_23 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D7 | LCD-D7 | U13_24 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D12 | LCD-D12 | U13_25 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D11 | LCD-D11 | U13_26 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D14 | LCD-D14 | U13_27 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D13 | LCD-D13 | U13_28 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D18 | LCD-D18 | U13_29 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D15 | LCD-D15 | U13_30 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D20 | LCD-D20 | U13_31 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D19 | LCD-D19 | U13_32 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D22 | LCD-D22 | U13_33 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D21 | LCD-D21 | U13_34 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-CLK | LCD-CLK | U13_35 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-D23 | LCD-D23 | U13_36 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-VSYNC | LCD-VSYNC | U13_37 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-HSYNC | LCD-HSYNC | U13_38 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| LCD-DE | LCD-DE | U13_40 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| UART1-TX | UART-TX | U14_3 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| UART1-RX | UART-RX | U14_5 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| LRADC | ADC | U14_11 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| XIO-P0 | XIO-P0 | U14_13 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P1 | XIO-P1 | U14_14 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P2 | GPIO1 | U14_15 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P3 | GPIO2 | U14_16 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P4 | GPIO3 | U14_17 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P5 | GPIO4 | U14_18 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P6 | GPIO5 | U14_19 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| XIO-P7 | GPIO6 | U14_20 | CHIP |
+------------------+--------------------------+-------------+-----------------+
| AP-EINT1 | KPD-INT | U14_23 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| AP-EINT3 | AP-INT3 | U14_24 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| TWI2-SDA | I2C-SDA | U14_25 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| TWI2-SCK | I2C-SCL | U14_26 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSIPCK | SPI-SEL | U14_27 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSICK | SPI-CLK | U14_28 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSIHSYNC | SPI-MOSI | U14_29 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSIVSYNC | SPI-MISO | U14_30 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID0 | D0 | U14_31 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID1 | D1 | U14_32 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID2 | D2 | U14_33 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID3 | D3 | U14_34 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID4 | D4 | U14_35 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID5 | D5 | U14_36 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID6 | D6 | U14_37 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
| CSID7 | D7 | U14_38 | CHIP/CHIP PRO |
+------------------+--------------------------+-------------+-----------------+
**GPIO Setup**
@ -167,12 +169,16 @@ You can also refer to the bin based upon its alternate name::
GPIO.setup("GPIO1", GPIO.IN)
**GPIO Debug**
**GPIO Miscellaneous**
Debug can be enabled/disabled by the following command::
# Enable Debug
GPIO.toggle_debug()
You can determine if the hardware is a CHIP/CHIP Pro using the following::
GPIO.is_chip_pro()
**GPIO Output**

63
source/common.c
View File

@ -68,10 +68,10 @@ pins_t pins_info[] = {
{ "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},
{ "X1", "X1", "U13_13", -1, BASE_METHOD_AS_IS, -1, -1, CHIP},
{ "X2", "X2", "U13_14", -1, BASE_METHOD_AS_IS, -1, -1, CHIP},
{ "Y1", "Y1", "U13_15", -1, BASE_METHOD_AS_IS, -1, -1, CHIP},
{ "Y2", "Y2", "U13_16", -1, BASE_METHOD_AS_IS, -1, -1, CHIP},
{ "LCD-D2", "UART2-TX", "U13_17", 98, BASE_METHOD_AS_IS, -1, -1, BOTH},
{ "PWM0", "PWM0", "U13_18", 34, BASE_METHOD_AS_IS, 0, -1, BOTH},
{ "PWM1", "PWM1", "EINT13", 205, BASE_METHOD_AS_IS, 0, -1, CHIPPRO},
@ -265,6 +265,61 @@ int is_this_chippro(void)
return rtnval;
}
int gpio_allowed(int gpio)
{
int rtnval = -1;
pins_t *p;
// Determine if we are CHIP Pro
// Running because we cannot be sure if it was previously run
int iscpro = is_this_chippro();
// If the return is good, we should be good to go, so let's check the data
if (iscpro != -1) {
// Loop through the pins
for (p = pins_info; p->key != NULL; ++p) {
if (p->gpio == gpio) {
// We have a CHIP and the pin is for CHIP/BOTH
if (((p->sbc_type == CHIP) || (p->sbc_type == BOTH)) && (ISCHIPPRO == 0)) {
rtnval = 1;
// We have a CHIP Pro and the pin is for CHIPPRO/BOTH
} else if (((p->sbc_type == CHIPPRO) || (p->sbc_type == BOTH)) && (ISCHIPPRO == 1)) {
rtnval = 1;
} else {
rtnval = 0;
}
}
}
}
return rtnval;
}
int pwm_allowed(const char *key)
{
int rtnval = -1;
pins_t *p;
// Determine if we are CHIP Pro
// Running because we cannot be sure if it was previously run
int iscpro = is_this_chippro();
// If the return is good, we should be good to go, so let's check the data
if (iscpro != -1) {
for (p = pins_info; p->key != NULL; ++p) {
if (strcmp(p->key, key) == 0) {
// We have a CHIP and the pin is for CHIP/BOTH
if ((p->sbc_type == BOTH) && (ISCHIPPRO == 0)) {
rtnval = 1;
// We have a CHIP Pro and the pin is for CHIPPRO/BOTH
} else if (((p->sbc_type == CHIPPRO) || (p->sbc_type == BOTH)) && (ISCHIPPRO == 1)) {
rtnval = 1;
} else {
rtnval = 0;
}
}
}
}
return rtnval;
}
void toggle_debug(void)
{
if (DEBUG) {

2
source/common.h
View File

@ -120,3 +120,5 @@ 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);
int gpio_allowed(int gpio);
int pwm_allowed(const char *key);

196
source/py_gpio.c
View File

@ -152,6 +152,7 @@ static PyObject *py_cleanup(PyObject *self, PyObject *args, PyObject *kwargs)
static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwargs)
{
int gpio;
int allowed = -1;
char *channel;
int direction;
int pud = PUD_OFF;
@ -190,6 +191,21 @@ static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwar
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (gpio_export(gpio) < 0) {
char err[2000];
@ -241,6 +257,7 @@ static PyObject *py_output_gpio(PyObject *self, PyObject *args)
int gpio;
int value;
char *channel;
int allowed = -1;
clear_error_msg();
@ -252,6 +269,21 @@ static PyObject *py_output_gpio(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (!module_setup || dyn_int_array_get(&gpio_direction, gpio, -1) != OUTPUT)
{
char err[2000];
@ -279,6 +311,7 @@ static PyObject *py_input_gpio(PyObject *self, PyObject *args)
char *channel;
unsigned int value;
PyObject *py_value;
int allowed = -1;
clear_error_msg();
@ -290,6 +323,21 @@ static PyObject *py_input_gpio(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check channel is set up as an input or output
if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1))
{
@ -317,6 +365,7 @@ static PyObject *py_read_byte_gpio(PyObject *self, PyObject *args)
char *channel;
unsigned int value = 0;
PyObject *py_value;
int allowed = -1;
clear_error_msg();
@ -328,6 +377,21 @@ static PyObject *py_read_byte_gpio(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check channel is set up as an input or output
if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1))
{
@ -355,6 +419,7 @@ static PyObject *py_read_word_gpio(PyObject *self, PyObject *args)
char *channel;
unsigned int value = 0;
PyObject *py_value;
int allowed = -1;
clear_error_msg();
@ -365,8 +430,23 @@ static PyObject *py_read_word_gpio(PyObject *self, PyObject *args)
PyErr_SetString(PyExc_ValueError, "Invalid channel");
return NULL;
}
// check channel is set up as an input or output
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check channel is set up as an input or output
if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1))
{
PyErr_SetString(PyExc_RuntimeError, "You must setup() the GPIO channel first");
@ -464,6 +544,7 @@ static PyObject *py_add_event_callback(PyObject *self, PyObject *args, PyObject
{
int gpio;
char *channel;
int allowed = -1;
unsigned int bouncetime = 0;
PyObject *cb_func;
char *kwlist[] = {"gpio", "callback", "bouncetime", NULL};
@ -484,6 +565,21 @@ static PyObject *py_add_event_callback(PyObject *self, PyObject *args, PyObject
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1")
@ -518,6 +614,7 @@ static PyObject *py_add_event_detect(PyObject *self, PyObject *args, PyObject *k
char *channel;
int edge, result;
unsigned int bouncetime = 0;
int allowed = -1;
PyObject *cb_func = NULL;
char *kwlist[] = {"gpio", "edge", "callback", "bouncetime", NULL};
@ -537,6 +634,21 @@ static PyObject *py_add_event_detect(PyObject *self, PyObject *args, PyObject *k
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1")
@ -586,6 +698,7 @@ static PyObject *py_remove_event_detect(PyObject *self, PyObject *args)
struct py_callback *cb = py_callbacks;
struct py_callback *temp;
struct py_callback *prev = NULL;
int allowed = -1;
clear_error_msg();
@ -597,6 +710,21 @@ static PyObject *py_remove_event_detect(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1")
@ -634,6 +762,7 @@ static PyObject *py_event_detected(PyObject *self, PyObject *args)
{
int gpio;
char *channel;
int allowed = -1;
clear_error_msg();
@ -645,6 +774,21 @@ static PyObject *py_event_detected(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (event_detected(gpio))
Py_RETURN_TRUE;
else
@ -658,6 +802,7 @@ static PyObject *py_wait_for_edge(PyObject *self, PyObject *args)
int edge, result;
char *channel;
char error[81];
int allowed = -1;
clear_error_msg();
@ -669,6 +814,21 @@ static PyObject *py_wait_for_edge(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1")
@ -717,6 +877,7 @@ static PyObject *py_gpio_function(PyObject *self, PyObject *args)
unsigned int value;
PyObject *func;
char *channel;
int allowed = -1;
clear_error_msg();
@ -728,6 +889,21 @@ static PyObject *py_gpio_function(PyObject *self, PyObject *args)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (setup_error)
{
PyErr_SetString(PyExc_RuntimeError, "Module not imported correctly!");
@ -915,6 +1091,7 @@ static PyObject *py_set_direction(PyObject *self, PyObject *args, PyObject *kwar
int gpio;
char *channel;
int direction;
int allowed = -1;
static char *kwlist[] = { "channel", "direction", NULL };
clear_error_msg();
@ -939,6 +1116,21 @@ static PyObject *py_set_direction(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (gpio_set_direction(gpio, direction) < 0) {
char err[2000];
snprintf(err, sizeof(err), "Error setting direction %d on channel %s. (%s)", direction, channel, get_error_msg());

96
source/py_pwm.c
View File

@ -95,6 +95,7 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
float frequency = 2000.0;
float duty_cycle = 0.0;
int polarity = 0;
int allowed = -1;
static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
clear_error_msg();
@ -112,6 +113,21 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// Check to see if PWM is allowed on the hardware
// A 1 means we're good to go
allowed = pwm_allowed(key);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key);
PyErr_SetString(PyExc_ValueError, err);
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;
@ -142,6 +158,7 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
{
char key[8];
char *channel;
int allowed = -1;
clear_error_msg();
@ -153,6 +170,21 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
return NULL;
}
// Check to see if PWM is allowed on the hardware
// A 1 means we're good to go
allowed = pwm_allowed(key);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (pwm_disable(key) < 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
@ -168,6 +200,7 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
{
char key[8];
char *channel;
int allowed = -1;
float duty_cycle = 0.0;
static char *kwlist[] = {"channel", "duty_cycle", NULL};
@ -186,6 +219,21 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
return NULL;
}
// Check to see if PWM is allowed on the hardware
// A 1 means we're good to go
allowed = pwm_allowed(key);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (pwm_set_duty_cycle(key, duty_cycle) == -1) {
char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
@ -201,6 +249,7 @@ static PyObject *py_set_pulse_width_ns(PyObject *self, PyObject *args, PyObject
{
char key[8];
char *channel;
int allowed = -1;
unsigned long pulse_width_ns = 0.0;
unsigned long period_ns;
static char *kwlist[] = {"channel", "pulse_width_ns", NULL};
@ -215,6 +264,21 @@ static PyObject *py_set_pulse_width_ns(PyObject *self, PyObject *args, PyObject
return NULL;
}
// Check to see if PWM is allowed on the hardware
// A 1 means we're good to go
allowed = pwm_allowed(key);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
// Get the period out of the data struct
int rtn = pwm_get_period_ns(key, &period_ns);
if (rtn == -1) {
@ -242,6 +306,7 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
{
char key[8];
char *channel;
int allowed = -1;
float frequency = 1.0;
static char *kwlist[] = {"channel", "frequency", NULL};
@ -260,6 +325,21 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// Check to see if PWM is allowed on the hardware
// A 1 means we're good to go
allowed = pwm_allowed(key);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (pwm_set_frequency(key, frequency) < 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg());
@ -275,6 +355,7 @@ static PyObject *py_set_period_ns(PyObject *self, PyObject *args, PyObject *kwar
{
char key[8];
char *channel;
int allowed = -1;
unsigned long period_ns = 2e6;
static char *kwlist[] = {"channel", "period_ns", NULL};
@ -293,6 +374,21 @@ static PyObject *py_set_period_ns(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// Check to see if PWM is allowed on the hardware
// A 1 means we're good to go
allowed = pwm_allowed(key);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key);
PyErr_SetString(PyExc_ValueError, err);
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());

64
source/py_servo.c
View File

@ -99,6 +99,7 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
char *channel = NULL;
float angle = 0.0;
float range = 180.0;
int allowed = -1;
static char *kwlist[] = {"channel", "angle", "range", NULL};
clear_error_msg();
@ -125,6 +126,21 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (servo_start(key, angle, range) < 0) {
printf("servo_start failed");
char err[2000];
@ -141,6 +157,7 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
{
int gpio;
char key[8];
int allowed = -1;
char *channel;
clear_error_msg();
@ -161,6 +178,21 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
servo_disable(key);
Py_RETURN_NONE;
@ -173,6 +205,7 @@ static PyObject *py_set_range(PyObject *self, PyObject *args, PyObject *kwargs)
char key[8];
char *channel;
float range = 180.0;
int allowed = -1;
static char *kwlist[] = {"channel", "range", NULL};
clear_error_msg();
@ -198,6 +231,21 @@ static PyObject *py_set_range(PyObject *self, PyObject *args, PyObject *kwargs)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (servo_set_range(key, range) == -1) {
PyErr_SetString(PyExc_RuntimeError, "You must start() the Servo channel first");
return NULL;
@ -213,6 +261,7 @@ static PyObject *py_set_angle(PyObject *self, PyObject *args, PyObject *kwargs)
char key[8];
char *channel;
float angle = 0.0;
int allowed = -1;
static char *kwlist[] = {"channel", "angle", NULL};
clear_error_msg();
@ -238,6 +287,21 @@ static PyObject *py_set_angle(PyObject *self, PyObject *args, PyObject *kwargs)
return NULL;
}
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (servo_set_angle(key, angle) == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error setting servo angle on pin %s (%s)", key, get_error_msg());

84
source/py_softpwm.c
View File

@ -95,6 +95,8 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
float frequency = 2000.0;
float duty_cycle = 0.0;
int polarity = 0;
int gpio;
int allowed = -1;
static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
clear_error_msg();
@ -113,6 +115,25 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// check to ensure gpio is one of the allowed pins
// Not protecting the call as if the get_key() fails, we won't make it here
get_gpio_number(channel, &gpio);
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
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;
@ -144,6 +165,8 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
{
char key[8];
char *channel;
int gpio;
int allowed = -1;
clear_error_msg();
@ -155,6 +178,25 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
return NULL;
}
// check to ensure gpio is one of the allowed pins
// Not protecting the call as if the get_key() fails, we won't make it here
get_gpio_number(channel, &gpio);
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
softpwm_disable(key);
Py_RETURN_NONE;
@ -165,6 +207,8 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
{
char key[8];
char *channel;
int gpio;
int allowed = -1;
float duty_cycle = 0.0;
static char *kwlist[] = {"channel", "duty_cycle", NULL};
@ -183,6 +227,25 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
return NULL;
}
// check to ensure gpio is one of the allowed pins
// Not protecting the call as if the get_key() fails, we won't make it here
get_gpio_number(channel, &gpio);
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (softpwm_set_duty_cycle(key, duty_cycle) == -1) {
PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
return NULL;
@ -196,6 +259,8 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
{
char key[8];
char *channel;
int gpio;
int allowed = -1;
float frequency = 1.0;
static char *kwlist[] = {"channel", "frequency", NULL};
@ -214,6 +279,25 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
return NULL;
}
// check to ensure gpio is one of the allowed pins
// Not protecting the call as if the get_key() fails, we won't make it here
get_gpio_number(channel, &gpio);
// Check to see if GPIO is allowed on the hardware
// A 1 means we're good to go
allowed = gpio_allowed(gpio);
if (allowed == -1) {
char err[2000];
snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg());
PyErr_SetString(PyExc_ValueError, err);
return NULL;
} else if (allowed == 0) {
char err[2000];
snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio);
PyErr_SetString(PyExc_ValueError, err);
return NULL;
}
if (softpwm_set_frequency(key, frequency) == -1) {
PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
return NULL;