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

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;