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

2
source/common.h
View File

@ -120,3 +120,5 @@ char *get_error_msg(void);
void add_error_msg(char *msg); void add_error_msg(char *msg);
void toggle_debug(void); void toggle_debug(void);
int compute_port_pin(const char *key, int gpio, int *port, int *pin); 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) static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwargs)
{ {
int gpio; int gpio;
int allowed = -1;
char *channel; char *channel;
int direction; int direction;
int pud = PUD_OFF; int pud = PUD_OFF;
@ -190,6 +191,21 @@ static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwar
PyErr_SetString(PyExc_ValueError, err); PyErr_SetString(PyExc_ValueError, err);
return NULL; 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) { if (gpio_export(gpio) < 0) {
char err[2000]; char err[2000];
@ -241,6 +257,7 @@ static PyObject *py_output_gpio(PyObject *self, PyObject *args)
int gpio; int gpio;
int value; int value;
char *channel; char *channel;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -252,6 +269,21 @@ static PyObject *py_output_gpio(PyObject *self, PyObject *args)
return NULL; 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) if (!module_setup || dyn_int_array_get(&gpio_direction, gpio, -1) != OUTPUT)
{ {
char err[2000]; char err[2000];
@ -279,6 +311,7 @@ static PyObject *py_input_gpio(PyObject *self, PyObject *args)
char *channel; char *channel;
unsigned int value; unsigned int value;
PyObject *py_value; PyObject *py_value;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -290,6 +323,21 @@ static PyObject *py_input_gpio(PyObject *self, PyObject *args)
return NULL; 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 // check channel is set up as an input or output
if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1)) 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; char *channel;
unsigned int value = 0; unsigned int value = 0;
PyObject *py_value; PyObject *py_value;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -328,6 +377,21 @@ static PyObject *py_read_byte_gpio(PyObject *self, PyObject *args)
return NULL; 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 // check channel is set up as an input or output
if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1)) 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; char *channel;
unsigned int value = 0; unsigned int value = 0;
PyObject *py_value; PyObject *py_value;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -365,8 +430,23 @@ static PyObject *py_read_word_gpio(PyObject *self, PyObject *args)
PyErr_SetString(PyExc_ValueError, "Invalid channel"); PyErr_SetString(PyExc_ValueError, "Invalid channel");
return NULL; 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)) if (!module_setup || (dyn_int_array_get(&gpio_direction, gpio, -1) == -1))
{ {
PyErr_SetString(PyExc_RuntimeError, "You must setup() the GPIO channel first"); 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; int gpio;
char *channel; char *channel;
int allowed = -1;
unsigned int bouncetime = 0; unsigned int bouncetime = 0;
PyObject *cb_func; PyObject *cb_func;
char *kwlist[] = {"gpio", "callback", "bouncetime", NULL}; char *kwlist[] = {"gpio", "callback", "bouncetime", NULL};
@ -484,6 +565,21 @@ static PyObject *py_add_event_callback(PyObject *self, PyObject *args, PyObject
return NULL; 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 // check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3") if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1") && 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; char *channel;
int edge, result; int edge, result;
unsigned int bouncetime = 0; unsigned int bouncetime = 0;
int allowed = -1;
PyObject *cb_func = NULL; PyObject *cb_func = NULL;
char *kwlist[] = {"gpio", "edge", "callback", "bouncetime", 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; 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 // check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3") if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1") && 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 *cb = py_callbacks;
struct py_callback *temp; struct py_callback *temp;
struct py_callback *prev = NULL; struct py_callback *prev = NULL;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -597,6 +710,21 @@ static PyObject *py_remove_event_detect(PyObject *self, PyObject *args)
return NULL; 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 // check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3") if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1") && gpio != lookup_gpio_by_name("AP-EINT1")
@ -634,6 +762,7 @@ static PyObject *py_event_detected(PyObject *self, PyObject *args)
{ {
int gpio; int gpio;
char *channel; char *channel;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -645,6 +774,21 @@ static PyObject *py_event_detected(PyObject *self, PyObject *args)
return NULL; 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)) if (event_detected(gpio))
Py_RETURN_TRUE; Py_RETURN_TRUE;
else else
@ -658,6 +802,7 @@ static PyObject *py_wait_for_edge(PyObject *self, PyObject *args)
int edge, result; int edge, result;
char *channel; char *channel;
char error[81]; char error[81];
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -669,6 +814,21 @@ static PyObject *py_wait_for_edge(PyObject *self, PyObject *args)
return NULL; 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 // check to ensure gpio is one of the allowed pins
if (gpio != lookup_gpio_by_name("AP-EINT3") if (gpio != lookup_gpio_by_name("AP-EINT3")
&& gpio != lookup_gpio_by_name("AP-EINT1") && gpio != lookup_gpio_by_name("AP-EINT1")
@ -717,6 +877,7 @@ static PyObject *py_gpio_function(PyObject *self, PyObject *args)
unsigned int value; unsigned int value;
PyObject *func; PyObject *func;
char *channel; char *channel;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -728,6 +889,21 @@ static PyObject *py_gpio_function(PyObject *self, PyObject *args)
return NULL; 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) if (setup_error)
{ {
PyErr_SetString(PyExc_RuntimeError, "Module not imported correctly!"); 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; int gpio;
char *channel; char *channel;
int direction; int direction;
int allowed = -1;
static char *kwlist[] = { "channel", "direction", NULL }; static char *kwlist[] = { "channel", "direction", NULL };
clear_error_msg(); clear_error_msg();
@ -939,6 +1116,21 @@ static PyObject *py_set_direction(PyObject *self, PyObject *args, PyObject *kwar
return NULL; 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) { if (gpio_set_direction(gpio, direction) < 0) {
char err[2000]; char err[2000];
snprintf(err, sizeof(err), "Error setting direction %d on channel %s. (%s)", direction, channel, get_error_msg()); 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 frequency = 2000.0;
float duty_cycle = 0.0; float duty_cycle = 0.0;
int polarity = 0; int polarity = 0;
int allowed = -1;
static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL}; static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
clear_error_msg(); clear_error_msg();
@ -112,6 +113,21 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
return NULL; 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) { 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"); PyErr_SetString(PyExc_ValueError, "duty_cycle must have a value from 0.0 to 100.0");
return NULL; return NULL;
@ -142,6 +158,7 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
{ {
char key[8]; char key[8];
char *channel; char *channel;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -153,6 +170,21 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
return NULL; 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) { if (pwm_disable(key) < 0) {
char err[2000]; char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg()); 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 key[8];
char *channel; char *channel;
int allowed = -1;
float duty_cycle = 0.0; float duty_cycle = 0.0;
static char *kwlist[] = {"channel", "duty_cycle", NULL}; 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; 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) { if (pwm_set_duty_cycle(key, duty_cycle) == -1) {
char err[2000]; char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg()); 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 key[8];
char *channel; char *channel;
int allowed = -1;
unsigned long pulse_width_ns = 0.0; unsigned long pulse_width_ns = 0.0;
unsigned long period_ns; unsigned long period_ns;
static char *kwlist[] = {"channel", "pulse_width_ns", NULL}; 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; 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 // Get the period out of the data struct
int rtn = pwm_get_period_ns(key, &period_ns); int rtn = pwm_get_period_ns(key, &period_ns);
if (rtn == -1) { if (rtn == -1) {
@ -242,6 +306,7 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
{ {
char key[8]; char key[8];
char *channel; char *channel;
int allowed = -1;
float frequency = 1.0; float frequency = 1.0;
static char *kwlist[] = {"channel", "frequency", NULL}; static char *kwlist[] = {"channel", "frequency", NULL};
@ -260,6 +325,21 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
return NULL; 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) { if (pwm_set_frequency(key, frequency) < 0) {
char err[2000]; char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg()); 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 key[8];
char *channel; char *channel;
int allowed = -1;
unsigned long period_ns = 2e6; unsigned long period_ns = 2e6;
static char *kwlist[] = {"channel", "period_ns", NULL}; 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; 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) { if (pwm_set_period_ns(key, period_ns) < 0) {
char err[2000]; char err[2000];
snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg()); 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; char *channel = NULL;
float angle = 0.0; float angle = 0.0;
float range = 180.0; float range = 180.0;
int allowed = -1;
static char *kwlist[] = {"channel", "angle", "range", NULL}; static char *kwlist[] = {"channel", "angle", "range", NULL};
clear_error_msg(); clear_error_msg();
@ -125,6 +126,21 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
return NULL; 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) { if (servo_start(key, angle, range) < 0) {
printf("servo_start failed"); printf("servo_start failed");
char err[2000]; char err[2000];
@ -141,6 +157,7 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
{ {
int gpio; int gpio;
char key[8]; char key[8];
int allowed = -1;
char *channel; char *channel;
clear_error_msg(); clear_error_msg();
@ -161,6 +178,21 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
return NULL; 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); servo_disable(key);
Py_RETURN_NONE; Py_RETURN_NONE;
@ -173,6 +205,7 @@ static PyObject *py_set_range(PyObject *self, PyObject *args, PyObject *kwargs)
char key[8]; char key[8];
char *channel; char *channel;
float range = 180.0; float range = 180.0;
int allowed = -1;
static char *kwlist[] = {"channel", "range", NULL}; static char *kwlist[] = {"channel", "range", NULL};
clear_error_msg(); clear_error_msg();
@ -198,6 +231,21 @@ static PyObject *py_set_range(PyObject *self, PyObject *args, PyObject *kwargs)
return NULL; 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) { if (servo_set_range(key, range) == -1) {
PyErr_SetString(PyExc_RuntimeError, "You must start() the Servo channel first"); PyErr_SetString(PyExc_RuntimeError, "You must start() the Servo channel first");
return NULL; return NULL;
@ -213,6 +261,7 @@ static PyObject *py_set_angle(PyObject *self, PyObject *args, PyObject *kwargs)
char key[8]; char key[8];
char *channel; char *channel;
float angle = 0.0; float angle = 0.0;
int allowed = -1;
static char *kwlist[] = {"channel", "angle", NULL}; static char *kwlist[] = {"channel", "angle", NULL};
clear_error_msg(); clear_error_msg();
@ -238,6 +287,21 @@ static PyObject *py_set_angle(PyObject *self, PyObject *args, PyObject *kwargs)
return NULL; 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) { if (servo_set_angle(key, angle) == -1) {
char err[2000]; char err[2000];
snprintf(err, sizeof(err), "Error setting servo angle on pin %s (%s)", key, get_error_msg()); 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 frequency = 2000.0;
float duty_cycle = 0.0; float duty_cycle = 0.0;
int polarity = 0; int polarity = 0;
int gpio;
int allowed = -1;
static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL}; static char *kwlist[] = {"channel", "duty_cycle", "frequency", "polarity", NULL};
clear_error_msg(); clear_error_msg();
@ -113,6 +115,25 @@ static PyObject *py_start_channel(PyObject *self, PyObject *args, PyObject *kwar
return NULL; 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) { 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"); PyErr_SetString(PyExc_ValueError, "duty_cycle must have a value from 0.0 to 100.0");
return NULL; return NULL;
@ -144,6 +165,8 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
{ {
char key[8]; char key[8];
char *channel; char *channel;
int gpio;
int allowed = -1;
clear_error_msg(); clear_error_msg();
@ -155,6 +178,25 @@ static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwarg
return NULL; 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); softpwm_disable(key);
Py_RETURN_NONE; Py_RETURN_NONE;
@ -165,6 +207,8 @@ static PyObject *py_set_duty_cycle(PyObject *self, PyObject *args, PyObject *kwa
{ {
char key[8]; char key[8];
char *channel; char *channel;
int gpio;
int allowed = -1;
float duty_cycle = 0.0; float duty_cycle = 0.0;
static char *kwlist[] = {"channel", "duty_cycle", NULL}; 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; 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) { if (softpwm_set_duty_cycle(key, duty_cycle) == -1) {
PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first"); PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
return NULL; return NULL;
@ -196,6 +259,8 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
{ {
char key[8]; char key[8];
char *channel; char *channel;
int gpio;
int allowed = -1;
float frequency = 1.0; float frequency = 1.0;
static char *kwlist[] = {"channel", "frequency", NULL}; static char *kwlist[] = {"channel", "frequency", NULL};
@ -214,6 +279,25 @@ static PyObject *py_set_frequency(PyObject *self, PyObject *args, PyObject *kwar
return NULL; 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) { if (softpwm_set_frequency(key, frequency) == -1) {
PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first"); PyErr_SetString(PyExc_RuntimeError, "You must start() the PWM channel first");
return NULL; return NULL;