dev->adc_in_fp = open(file_path, O_RDONLY);
if (dev->adc_in_fp == -1) {
- syslog(LOG_ERR, "Failed to open Analog input raw file %s for "
- "reading!", file_path);
+ syslog(LOG_ERR, "aio: Failed to open input raw file %s for reading!",
+ file_path);
return MRAA_ERROR_INVALID_RESOURCE;
}
if (checked_pin < 0) {
switch (checked_pin) {
case MRAA_NO_SUCH_IO:
- syslog(LOG_ERR, "Invalid analog input channel %d specified",
+ syslog(LOG_ERR, "aio: Invalid input channel %d specified",
aio_channel);
return NULL;
case MRAA_IO_SETUP_FAILURE:
- syslog(LOG_ERR, "Failed to set-up analog input channel %d "
+ syslog(LOG_ERR, "aio: Failed to set-up input channel %d "
"multiplexer", aio_channel);
return NULL;
case MRAA_PLATFORM_NO_INIT:
- syslog(LOG_ERR, "Platform not initialised");
+ syslog(LOG_ERR, "aio: Platform not initialised");
return NULL;
default:
return NULL;
//Create ADC device connected to specified channel
mraa_aio_context dev = malloc(sizeof(struct _aio));
if (dev == NULL) {
- syslog(LOG_ERR, "Insufficient memory for specified Analog input channel "
+ syslog(LOG_ERR, "aio: Insufficient memory for specified input channel "
"%d\n", aio_channel);
return NULL;
}
lseek(dev->adc_in_fp, 0, SEEK_SET);
if (read(dev->adc_in_fp, buffer, sizeof(buffer)) < 1) {
- syslog(LOG_ERR, "Failed to read a sensible value");
+ syslog(LOG_ERR, "aio: Failed to read a sensible value");
}
// force NULL termination of string
buffer[16] = '\0';
char *end;
unsigned int analog_value = (unsigned int) strtoul(buffer, &end, 10);
if (end == &buffer[0]) {
- syslog(LOG_ERR, "value is not a decimal number");
+ syslog(LOG_ERR, "aio: Value is not a decimal number");
}
else if (errno != 0) {
- syslog(LOG_ERR, "errno was set");
+ syslog(LOG_ERR, "aio: Errno was set");
}
if (dev->value_bit != raw_bits) {
mraa_result_t
mraa_aio_set_bit(mraa_aio_context dev, int bits)
{
- if (dev == NULL) {
- syslog(LOG_ERR, "AIO Device not valid");
+ if (dev == NULL || bits < 1) {
+ syslog(LOG_ERR, "aio: Device not valid");
return MRAA_ERROR_INVALID_RESOURCE;
}
- if (bits < 1) {
- syslog(LOG_ERR, "AIO Device not valid");
- return MRAA_ERROR_INVALID_PARAMETER;
- }
dev->value_bit = bits;
return MRAA_SUCCESS;
}
mraa_aio_get_bit(mraa_aio_context dev)
{
if (dev == NULL) {
- syslog(LOG_ERR, "AIO Device not valid");
+ syslog(LOG_ERR, "aio: Device not valid");
return 0;
}
return dev->value_bit;
mraa_gpio_context dev = (mraa_gpio_context) malloc(sizeof(struct _gpio));
if (dev == NULL) {
- syslog(LOG_CRIT, "Failed to allocate memory for context");
+ syslog(LOG_CRIT, "gpio: Failed to allocate memory for context");
return NULL;
}
} else {
int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
if (export == -1) {
- syslog(LOG_ERR, "Failed to open export for writing");
+ syslog(LOG_ERR, "gpio: Failed to open export for writing");
free(dev);
return NULL;
}
length = snprintf(bu, sizeof(bu), "%d", dev->pin);
if (write(export, bu, length*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to export");
+ syslog(LOG_ERR, "gpio: Failed to write to export");
close(export);
return NULL;
}
PyObject *ret;
arglist = Py_BuildValue("(i)", dev->isr_args);
if (arglist == NULL) {
- syslog(LOG_ERR, "Py_BuildValue NULL");
+ syslog(LOG_ERR, "gpio: Py_BuildValue NULL");
} else {
ret = PyEval_CallObject((PyObject*)dev->isr, arglist);
if (ret == NULL) {
- syslog(LOG_ERR, "PyEval_CallObject failed");
+ syslog(LOG_ERR, "gpio: PyEval_CallObject failed");
} else {
Py_DECREF(ret);
}
int edge = open(filepath, O_RDWR);
if (edge == -1) {
- syslog(LOG_ERR, "Failed to open edge for writing");
+ syslog(LOG_ERR, "gpio: Failed to open edge for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
if (write(edge, bu, length*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to edge");
+ syslog(LOG_ERR, "gpio: Failed to write to edge");
close(edge);
return MRAA_ERROR_INVALID_RESOURCE;
}
int drive = open(filepath, O_WRONLY);
if (drive == -1) {
- syslog(LOG_ERR, "Failed to open drive for writing");
+ syslog(LOG_ERR, "gpio: Failed to open drive for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
if (write(drive, bu, length*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to drive mode");
+ syslog(LOG_ERR, "gpio: Failed to write to drive mode");
close(drive);
return MRAA_ERROR_INVALID_RESOURCE;
if (dev->value_fp == -1) {
if (mraa_gpio_get_valfp(dev) != MRAA_SUCCESS) {
- syslog(LOG_ERR, "Failed to get value file pointer");
+ syslog(LOG_ERR, "gpio: Failed to get value file pointer");
}
}
else {
}
char bu[2];
if (read(dev->value_fp, bu, 2*sizeof(char)) != 2) {
- syslog(LOG_ERR, "Failed to read a sensible value from sysfs");
+ syslog(LOG_ERR, "gpio: Failed to read a sensible value from sysfs");
return -1;
}
lseek(dev->value_fp, 0, SEEK_SET);
{
int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
if (unexport == -1) {
- syslog(LOG_ERR, "Failed to open unexport for writing");
+ syslog(LOG_ERR, "gpio: Failed to open unexport for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
char bu[MAX_SIZE];
int length = snprintf(bu, sizeof(bu), "%d", dev->pin);
if (write(unexport, bu, length*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to unexport");
+ syslog(LOG_ERR, "gpio: Failed to write to unexport");
close(unexport);
return MRAA_ERROR_INVALID_RESOURCE;
}
int fd;
fd = open(mmp->mem_dev, O_RDWR);
if (fd < 1) {
- syslog(LOG_ERR, "Unable to open memory device");
+ syslog(LOG_ERR, "gpio: Unable to open memory device");
close(fd);
return MRAA_ERROR_INVALID_RESOURCE;
}
if (checked_pin < 0) {
switch(checked_pin) {
case MRAA_NO_SUCH_IO:
- syslog(LOG_ERR, "No i2c on board");
+ syslog(LOG_ERR, "i2c: No i2c on board");
return NULL;
case MRAA_IO_SETUP_FAILURE:
- syslog(LOG_ERR, "Failed to set-up i2c multiplexer");
+ syslog(LOG_ERR, "i2c: Failed to set-up i2c multiplexer");
return NULL;
case MRAA_PLATFORM_NO_INIT:
- syslog(LOG_ERR, "Platform Not Initialised");
+ syslog(LOG_ERR, "i2c: Platform Not Initialised");
return NULL;
default: return NULL;
}
}
mraa_i2c_context dev = (mraa_i2c_context) malloc(sizeof(struct _i2c));
if (dev == NULL) {
- syslog(LOG_CRIT, "Failed to allocate memory for context");
+ syslog(LOG_CRIT, "i2c: Failed to allocate memory for context");
return NULL;
}
char filepath[32];
snprintf(filepath, 32, "/dev/i2c-%u", bus);
if ((dev->fh = open(filepath, O_RDWR)) < 1) {
- syslog(LOG_ERR, "Failed to open requested i2c port %s", filepath);
+ syslog(LOG_ERR, "i2c: Failed to open requested i2c port %s", filepath);
}
if (advance_func->i2c_init_post != NULL) {
mraa_i2c_write(mraa_i2c_context dev, const uint8_t* data, int length)
{
if (i2c_smbus_write_i2c_block_data(dev->fh, data[0], length-1, (uint8_t*) data+1) < 0) {
- syslog(LOG_ERR, "Failed to write to i2c");
+ syslog(LOG_ERR, "i2c: Failed to write");
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
mraa_i2c_write_byte(mraa_i2c_context dev, const uint8_t data)
{
if (i2c_smbus_write_byte(dev->fh, data) < 0) {
- syslog(LOG_ERR, "Failed to write to i2c");
+ syslog(LOG_ERR, "i2c: Failed to write");
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
{
dev->addr = addr;
if (ioctl(dev->fh, I2C_SLAVE_FORCE, addr) < 0) {
- syslog(LOG_ERR, "Failed to set slave address %d", addr);
+ syslog(LOG_ERR, "i2c: Failed to set slave address %d", addr);
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
snprintf(buffer, MAX_SIZE, SYSFS_PINMODE_PATH "%i/current_pinmux",sysfs);
int modef = open(buffer, O_WRONLY);
if (modef == -1) {
- syslog(LOG_ERR, "Failed to open SoC pinmode for opening");
+ syslog(LOG_ERR, "edison: Failed to open SoC pinmode for opening");
return MRAA_ERROR_INVALID_RESOURCE;
}
{
if (miniboard == 0) {
if(bus != 6) {
- syslog(LOG_ERR, "Edison: You can't use that bus, switching to bus 6");
+ syslog(LOG_ERR, "edison: You can't use that bus, switching to bus 6");
bus = 6;
}
mraa_gpio_write(tristate, 0);
mraa_gpio_write(tristate, 1);
} else {
if(bus != 6 && bus != 1) {
- syslog(LOG_ERR, "Edison: You can't use that bus, switching to bus 6");
+ syslog(LOG_ERR, "edison: You can't use that bus, switching to bus 6");
bus = 6;
}
int scl = plat->pins[plat->i2c_bus[bus].scl].gpio.pinmap;
dev->adc_in_fp = open(file_path, O_RDONLY);
if (dev->adc_in_fp == -1) {
- syslog(LOG_ERR, "Failed to open Analog input raw file %s for "
+ syslog(LOG_ERR, "edison: Failed to open Analog input raw file %s for "
"reading!", file_path);
return MRAA_ERROR_INVALID_RESOURCE;
}
mraa_intel_edison_aio_init_pre(unsigned int aio)
{
if (aio > plat->aio_count) {
- syslog(LOG_ERR, "Invalid analog input channel");
+ syslog(LOG_ERR, "edison: Invalid analog input channel");
return MRAA_ERROR_INVALID_RESOURCE;
}
pullup_e = mraa_gpio_init_raw(pullup_map[dev->phy_pin]);
mraa_result_t sta = mraa_gpio_dir(pullup_e, MRAA_GPIO_IN);
if(sta != MRAA_SUCCESS) {
- syslog(LOG_ERR, "Edison: Failed to set gpio mode-pullup");
+ syslog(LOG_ERR, "edison: Failed to set gpio mode-pullup");
return MRAA_ERROR_INVALID_RESOURCE;
}
sta = mraa_gpio_dir(pullup_e, MRAA_GPIO_OUT);
sta = mraa_gpio_write(pullup_e, value);
if (sta != MRAA_SUCCESS) {
- syslog(LOG_ERR, "Edison: Error Setting pullup");
+ syslog(LOG_ERR, "edison: Error setting pullup");
return sta;
}
}
int drive = open(filepath, O_WRONLY);
if (drive == -1) {
- syslog(LOG_ERR, "Edison: Failed to open drive for writing");
+ syslog(LOG_ERR, "edison: Failed to open drive for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
if (write(drive, bu, length*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to drive mode");
+ syslog(LOG_ERR, "edison: Failed to write to drive mode");
close(drive);
return MRAA_ERROR_INVALID_RESOURCE;
// This seciton will also check if the arduino board is there
tristate = mraa_gpio_init_raw(214);
if (tristate == NULL) {
- syslog(LOG_INFO, "Intel Edison Failed to initialise Arduino board TriState,\
+ syslog(LOG_INFO, "edison: Failed to initialise Arduino board TriState,\
assuming Intel Edison Miniboard\n");
if (mraa_intel_edsion_miniboard(b) != MRAA_SUCCESS) {
free(b);
int period_f = open(bu, O_RDWR);
if (period_f == -1) {
- syslog(LOG_ERR, "Failed to open period for writing!");
+ syslog(LOG_ERR, "galileo2: Failed to open period for writing!");
return MRAA_ERROR_INVALID_RESOURCE;
}
char out[MAX_SIZE];
pullup_e = mraa_gpio_init_raw(pullup_map[dev->phy_pin]);
mraa_result_t sta = mraa_gpio_dir(pullup_e, MRAA_GPIO_IN);
if (sta != MRAA_SUCCESS) {
- syslog(LOG_ERR, "Galileo Gen 2: Failed to set gpio pullup");
+ syslog(LOG_ERR, "galileo2: Failed to set gpio pullup");
return MRAA_ERROR_INVALID_RESOURCE;
}
int drive = open(filepath, O_WRONLY);
if (drive == -1) {
- syslog(LOG_ERR, "Failed to open drive for writing");
+ syslog(LOG_ERR, "galileo2: Failed to open drive for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
if (write(drive, bu, length*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to drive mode");
+ syslog(LOG_ERR, "galileo2: Failed to write to drive mode");
close(drive);
return MRAA_ERROR_INVALID_RESOURCE;
}
sta = mraa_gpio_dir(pullup_e, MRAA_GPIO_OUT);
sta += mraa_gpio_write(pullup_e, value);
if (sta != MRAA_SUCCESS) {
- syslog(LOG_ERR, "Galileo Gen 2: Error Setting pullup");
+ syslog(LOG_ERR, "galileo2: Error Setting pullup");
close(drive);
return sta;
}
int period_f = open(bu, O_RDWR);
if (period_f == -1) {
- syslog(LOG_ERR, "Failed to open period for writing");
+ syslog(LOG_ERR, "pwm: Failed to open period for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
char out[MAX_SIZE];
int period_f = open(bu, O_RDWR);
if (period_f == -1) {
- syslog(LOG_ERR, "Failed to open period for reading");
+ syslog(LOG_ERR, "pwm: Failed to open period for reading");
return 0;
}
off_t size = lseek(period_f, 0, SEEK_END);
char *endptr;
long int ret = strtol(output, &endptr, 10);
if ('\0' != *endptr) {
- syslog(LOG_ERR, "error in string converstion");
+ syslog(LOG_ERR, "pwm: Error in string converstion");
return -1;
}
else if (ret > INT_MAX || ret < INT_MIN) {
- syslog(LOG_ERR, "number is invalid");
+ syslog(LOG_ERR, "pwm: Number is invalid");
return -1;
}
return (int) ret;
char *endptr;
long int ret = strtol(output, &endptr, 10);
if ('\0' != *endptr) {
- syslog(LOG_ERR, "error in string converstion");
+ syslog(LOG_ERR, "pwm: Error in string converstion");
return -1;
}
else if (ret > INT_MAX || ret < INT_MIN) {
- syslog(LOG_ERR, "number is invalid");
+ syslog(LOG_ERR, "pwm: Number is invalid");
return -1;
}
return (int) ret;
snprintf(directory, MAX_SIZE, SYSFS_PWM "/pwmchip%d/pwm%d", dev->chipid, dev->pin);
struct stat dir;
if (stat(directory, &dir) == 0 && S_ISDIR(dir.st_mode)) {
- syslog(LOG_NOTICE, "PWM Pin already exporting, continuing");
+ syslog(LOG_NOTICE, "pwm: Pin already exported, continuing");
dev->owner = 0; // Not Owner
} else {
char buffer[MAX_SIZE];
snprintf(buffer, MAX_SIZE, "/sys/class/pwm/pwmchip%d/export", dev->chipid);
int export_f = open(buffer, O_WRONLY);
if (export_f == -1) {
- syslog(LOG_ERR, "Failed to open export for writing");
+ syslog(LOG_ERR, "pwm: Failed to open export for writing");
free(dev);
return NULL;
}
char out[MAX_SIZE];
int size = snprintf(out, MAX_SIZE, "%d", dev->pin);
if (write(export_f, out, size*sizeof(char)) == -1) {
- syslog(LOG_WARNING, "Failed to write to export! Potentially already enabled");
+ syslog(LOG_WARNING, "pwm: Failed to write to export! Potentially already enabled");
close(export_f);
free(dev);
return NULL;
int enable_f = open(bu, O_RDWR);
if (enable_f == -1) {
- syslog(LOG_ERR, "Failed to open enable for writing");
+ syslog(LOG_ERR, "pwm: Failed to open enable for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
char out[2];
int size = snprintf(out, sizeof(out), "%d", enable);
if (write(enable_f, out, size * sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to enable");
+ syslog(LOG_ERR, "pwm: Failed to write to enable");
close(enable_f);
return MRAA_ERROR_INVALID_RESOURCE;
}
int unexport_f = open(filepath, O_WRONLY);
if (unexport_f == -1) {
- syslog(LOG_ERR, "Failed to open unexport for writing");
+ syslog(LOG_ERR, "pwm: Failed to open unexport for writing");
return MRAA_ERROR_INVALID_RESOURCE;
}
char out[MAX_SIZE];
int size = snprintf(out, MAX_SIZE, "%d", dev->pin);
if (write(unexport_f, out, size*sizeof(char)) == -1) {
- syslog(LOG_ERR, "Failed to write to unexport");
+ syslog(LOG_ERR, "pwm: Failed to write to unexport");
close(unexport_f);
return MRAA_ERROR_INVALID_RESOURCE;
}
mraa_spi_bus_t *spi = mraa_setup_spi(bus);
if (bus < 0) {
- syslog(LOG_ERR, "Failed. SPI platform Error");
+ syslog(LOG_ERR, "spi: Failed. SPI platform Error");
return NULL;
}
mraa_spi_context dev = (mraa_spi_context) malloc(sizeof(struct _spi));
dev->devfd = open(path, O_RDWR);
if (dev->devfd < 0) {
- syslog(LOG_ERR, "Failed opening SPI Device. bus:%s", path);
+ syslog(LOG_ERR, "spi: Failed opening SPI Device. bus:%s", path);
free(dev);
return NULL;
}
}
if (ioctl (dev->devfd, SPI_IOC_WR_MODE, &spi_mode) < 0) {
- syslog(LOG_ERR, "Failed to set spi mode");
+ syslog(LOG_ERR, "spi: Failed to set spi mode");
return MRAA_ERROR_INVALID_RESOURCE;
}
lsb_mode = 1;
}
if (ioctl (dev->devfd, SPI_IOC_WR_LSB_FIRST, &lsb_mode) < 0) {
- syslog(LOG_ERR, "Failed to set bit order");
+ syslog(LOG_ERR, "spi: Failed to set bit order");
return MRAA_ERROR_INVALID_RESOURCE;
}
dev->lsb = lsb;
msg.delay_usecs = 0;
msg.len = length;
if (ioctl(dev->devfd, SPI_IOC_MESSAGE(1), &msg) < 0) {
- syslog(LOG_ERR, "Failed to perform dev transfer");
+ syslog(LOG_ERR, "spi: Failed to perform dev transfer");
return -1;
}
return recv;
msg.delay_usecs = 0;
msg.len = length;
if (ioctl(dev->devfd, SPI_IOC_MESSAGE(1), &msg) < 0) {
- syslog(LOG_ERR, "Failed to perform dev transfer");
+ syslog(LOG_ERR, "spi: Failed to perform dev transfer");
return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_SUCCESS;
return NULL;
}
- if ( mraa_setup_uart(index) != MRAA_SUCCESS)
+ if (mraa_setup_uart(index) != MRAA_SUCCESS)
return NULL;
mraa_uart_context dev = (mraa_uart_context) malloc(sizeof(struct _uart));