* De-Initilise MRAA
*
* This is not a strict requirement but useful to test memory leaks and for
- * people who like super clean code.
+ * people who like super clean code. If dynamically loading & unloading
+ * libmraa you need to call this before unloading the library.
*/
void mraa_deinit();
*/
unsigned int mraa_adc_supported_bits();
+
+/**
+ * Sets the log level to use from 0-7 where 7 is very verbose. These are the
+ * syslog log levels, see syslog(3) for more information on the levels.
+ *
+ * @return Result of operation
+ */
+mraa_result_t mraa_set_log_level(int level);
+
#ifdef __cplusplus
}
#endif
return mraa_adc_supported_bits();
}
+/**
+ * Sets the log level to use from 0-7 where 7 is very verbose. These are the
+ * syslog log levels, see syslog(3) for more information on the levels.
+ *
+ * @return Result of operation
+ */
+mraa_result_t setLogLevel(int level)
+{
+ return mraa_set_log_level(level);
+}
+
}
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#include "stdio.h"
+#include <stdio.h>
+#include <syslog.h>
//! [Interesting]
#include "mraa.h"
int
main(int argc, char **argv)
{
+ mraa_result_t ret;
+
+ ret = mraa_set_log_level(LOG_DEBUG);
+
fprintf(stdout, "hello mraa\n Version: %s\n", mraa_get_version());
+
mraa_deinit();
- return 0;
+
+ return ret;
}
//! [Interesting]
#include "common.h"
+// general status failures for internal functions
+#define MRAA_PLATFORM_NO_INIT -3
+#define MRAA_IO_SETUP_FAILURE -2
+#define MRAA_NO_SUCH_IO -1
+
/**
* A structure representing a gpio pin.
*/
dev->adc_in_fp = open(file_path, O_RDONLY);
if (dev->adc_in_fp == -1) {
- fprintf(stderr, "Failed to open Analog input raw file %s for "
- "reading!\n", file_path);
+ syslog(LOG_ERR, "Failed to open Analog input raw file %s for "
+ "reading!", file_path);
return MRAA_ERROR_INVALID_RESOURCE;
}
int checked_pin = mraa_setup_aio(aio_channel);
if (checked_pin < 0) {
switch (checked_pin) {
- case -1:
- fprintf(stderr, "Invalid analog input channel %d specified\n",
+ case MRAA_NO_SUCH_IO:
+ syslog(LOG_ERR, "Invalid analog input channel %d specified",
aio_channel);
return NULL;
- case -2:
- fprintf(stderr, "Failed to set-up analog input channel %d "
- "multiplexer\n", aio_channel);
+ case MRAA_IO_SETUP_FAILURE:
+ syslog(LOG_ERR, "Failed to set-up analog input channel %d "
+ "multiplexer", aio_channel);
return NULL;
- case -3:
- fprintf(stderr, "Platform not initialised");
+ case MRAA_PLATFORM_NO_INIT:
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Insufficient memory for specified Analog input channel "
+ syslog(LOG_ERR, "Insufficient memory for specified Analog 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) {
- fprintf(stderr, "Failed to read a sensible value\n");
+ syslog(LOG_ERR, "Failed to read a sensible value");
}
lseek(dev->adc_in_fp, 0, SEEK_SET);
char *end;
unsigned int analog_value = (unsigned int) strtoul(buffer, &end, 10);
if (end == &buffer[0]) {
- fprintf(stderr, "%s is not a decimal number\n", buffer);
+ syslog(LOG_ERR, "%s is not a decimal number", buffer);
}
else if (errno != 0) {
- fprintf(stderr, "errno was set\n");
+ syslog(LOG_ERR, "errno was set");
}
if (dev->value_bit != raw_bits) {
mraa_aio_set_bit(mraa_aio_context dev, int bits)
{
if (dev == NULL) {
- fprintf(stderr, "AIO Device not valid\n");
+ syslog(LOG_ERR, "AIO Device not valid");
return MRAA_ERROR_INVALID_RESOURCE;
}
if (bits < 1) {
- fprintf(stderr, "AIO Device not valid\n");
+ syslog(LOG_ERR, "AIO Device not valid");
return MRAA_ERROR_INVALID_PARAMETER;
}
dev->value_bit = bits;
mraa_aio_get_bit(mraa_aio_context dev)
{
if (dev == NULL) {
- fprintf(stderr, "AIO Device not valid\n");
+ syslog(LOG_ERR, "AIO Device not valid");
return 0;
}
return dev->value_bit;
} else {
int export = open(SYSFS_CLASS_GPIO "/export", O_WRONLY);
if (export == -1) {
- fprintf(stderr, "Failed to open export for writing!\n");
+ syslog(LOG_ERR, "Failed to open export for writing");
return NULL;
}
length = snprintf(bu, sizeof(bu), "%d", dev->pin);
if (write(export, bu, length*sizeof(char)) == -1) {
- fprintf(stderr, "Failed to write to export\n");
+ syslog(LOG_ERR, "Failed to write to export");
close(export);
return NULL;
}
PyObject *ret;
arglist = Py_BuildValue("(i)", dev->isr_args);
if (arglist == NULL) {
- fprintf(stdout, "Py_BuildValue NULL\n");
+ syslog(LOG_ERR, "Py_BuildValue NULL");
} else {
ret = PyEval_CallObject((PyObject*)dev->isr, arglist);
if (ret == NULL) {
- fprintf(stdout, "PyEval_CallObject failed\n");
+ syslog(LOG_ERR, "PyEval_CallObject failed");
} else {
Py_DECREF(ret);
}
int edge = open(filepath, O_RDWR);
if (edge == -1) {
- fprintf(stderr, "Failed to open edge for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to edge\n");
+ syslog(LOG_ERR, "Failed to write to edge");
close(edge);
return MRAA_ERROR_INVALID_RESOURCE;
}
int drive = open(filepath, O_WRONLY);
if (drive == -1) {
- fprintf(stderr, "Failed to open drive for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to drive mode!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to get value file pointer\n");
+ syslog(LOG_ERR, "Failed to get value file pointer");
}
}
else {
}
char bu[2];
if (read(dev->value_fp, bu, 2*sizeof(char)) != 2) {
- fprintf(stderr, "Failed to read a sensible value from sysfs");
+ syslog(LOG_ERR, "Failed to read a sensible value from sysfs");
}
lseek(dev->value_fp, 0, SEEK_SET);
int ret = strtol(bu, NULL, 10);
{
int unexport = open(SYSFS_CLASS_GPIO "/unexport", O_WRONLY);
if (unexport == -1) {
- fprintf(stderr, "Failed to open unexport for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to unexport\n");
+ syslog(LOG_ERR, "Failed to write to unexport");
close(unexport);
return MRAA_ERROR_INVALID_RESOURCE;
}
int fd;
fd = open(mmp->mem_dev, O_RDWR);
if (fd < 1) {
- fprintf(stderr, "Unable to open memory device\n");
+ syslog(LOG_ERR, "Unable to open memory device");
return MRAA_ERROR_INVALID_RESOURCE;
}
dev->reg_sz = mmp->mem_sz;
int checked_pin = mraa_setup_i2c(bus);
if (checked_pin < 0) {
switch(checked_pin) {
- case -1:
- fprintf(stderr, "No i2c on board\n");
+ case MRAA_NO_SUCH_IO:
+ syslog(LOG_ERR, "No i2c on board");
return NULL;
- case -2:
- fprintf(stderr, "Failed to set-up i2c multiplexer!\n");
+ case MRAA_IO_SETUP_FAILURE:
+ syslog(LOG_ERR, "Failed to set-up i2c multiplexer");
return NULL;
- case -3:
- fprintf(stderr, "Platform Not Initialised\n");
+ case MRAA_PLATFORM_NO_INIT:
+ syslog(LOG_ERR, "Platform Not Initialised");
return NULL;
default: return NULL;
}
char filepath[32];
snprintf(filepath, 32, "/dev/i2c-%u", bus);
if ((dev->fh = open(filepath, O_RDWR)) < 1) {
- fprintf(stderr, "Failed to open requested i2c port %s\n", filepath);
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to i2c\n");
+ syslog(LOG_ERR, "Failed to write to i2c");
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) {
- fprintf(stderr, "Failed to write to i2c\n");
+ syslog(LOG_ERR, "Failed to write to i2c");
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
{
dev->addr = addr;
if (ioctl(dev->fh, I2C_SLAVE_FORCE, addr) < 0) {
- fprintf(stderr, "Failed to set slave address %d\n", addr);
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to open SoC pinmode for opening\n");
+ syslog(LOG_ERR, "Failed to open SoC pinmode for opening");
return MRAA_ERROR_INVALID_RESOURCE;
}
mraa_intel_edison_i2c_init_pre(unsigned int bus)
{
if(bus != 6) {
- fprintf(stderr, "Edison: You can use that bus, ERR\n");
+ syslog(LOG_ERR, "Edison: You can't use that bus :/");
return MRAA_ERROR_INVALID_RESOURCE;
}
mraa_gpio_write(tristate, 0);
char file_path[64]= "";
snprintf(file_path, 64, "/sys/bus/iio/devices/iio:device1/in_voltage%d_raw",
- dev->channel );
+ dev->channel );
dev->adc_in_fp = open(file_path, O_RDONLY);
if (dev->adc_in_fp == -1) {
- fprintf(stderr, "Failed to open Analog input raw file %s for "
- "reading!\n", file_path); return( MRAA_ERROR_INVALID_RESOURCE);
+ syslog(LOG_ERR, "Failed to open Analog input raw file %s for "
+ "reading!", file_path);
+ return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_SUCCESS;
mraa_intel_edison_aio_init_pre(unsigned int aio)
{
if (aio > plat->aio_count) {
- fprintf(stderr, "Invalid analog input channel\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "MRAA: Edison: Failed to set gpio mode-pullup\n");
- return MRAA_ERROR_INVALID_RESOURCE;
+ syslog(LOG_ERR, "Edison: Failed to set gpio mode-pullup");
+ return MRAA_ERROR_INVALID_RESOURCE;
}
int value = -1;
sta = mraa_gpio_dir(pullup_e, MRAA_GPIO_OUT);
sta = mraa_gpio_write(pullup_e, value);
if (sta != MRAA_SUCCESS) {
- fprintf(stderr, "MRAA: Edison: Error Setting pullup");
+ syslog(LOG_ERR, "Edison: Error Setting pullup");
return sta;
}
}
tristate = mraa_gpio_init_raw(214);
if (tristate == NULL) {
- fprintf(stderr, "Intel Edison Failed to initialise Arduino board TriState,\
- check i2c devices! FATAL\n");
+ syslog(LOG_CRIT, "Intel Edison Failed to initialise Arduino board TriState,\
+ check i2c devices! FATAL\n");
return NULL;
}
mraa_gpio_dir(tristate, MRAA_GPIO_OUT);
b->spi_bus[0].sclk = 13;
int il;
-
- for(il =0; il < MRAA_INTEL_EDISON_PINCOUNT; il++) {
+ for (il =0; il < MRAA_INTEL_EDISON_PINCOUNT; il++) {
pinmodes[il].gpio.sysfs = -1;
pinmodes[il].gpio.mode = -1;
pinmodes[il].pwm.sysfs = -1;
int period_f = open(bu, O_RDWR);
if (period_f == -1) {
- fprintf(stderr, "Failed to open period for writing!\n");
+ syslog(LOG_ERR, "Failed to open period for writing!");
return MRAA_ERROR_INVALID_RESOURCE;
}
char out[MAX_SIZE];
mraa_gpio_context pullup_e;
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) {
- fprintf(stderr, "MRAA: Galileo Gen 2: Failed to set gpio pullup\n");
- return MRAA_ERROR_INVALID_RESOURCE;
+ if (sta != MRAA_SUCCESS) {
+ syslog(LOG_ERR, "Galileo Gen 2: Failed to set gpio pullup");
+ return MRAA_ERROR_INVALID_RESOURCE;
}
char filepath[MAX_SIZE];
int drive = open(filepath, O_WRONLY);
if (drive == -1) {
- fprintf(stderr, "Failed to open drive for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to drive mode!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "MRAA: Galileo Gen 2: Error Setting pullup");
+ syslog(LOG_ERR, "Galileo Gen 2: Error Setting pullup");
return sta;
}
}
return gVERSION;
}
+mraa_result_t
+mraa_set_log_level(int level)
+{
+ if (level <= 7 && level >= 0) {
+ setlogmask(LOG_UPTO(level));
+ return MRAA_SUCCESS;
+ }
+ return MRAA_ERROR_INVALID_PARAMETER;
+}
+
mraa_result_t __attribute__((constructor))
mraa_init()
{
- /** Once more board definitions have been added,
- * A method for detecting them will need to be devised.
- */
+#ifdef DEBUG
+ setlogmask(LOG_UPTO(LOG_DEBUG));
+#else
+ setlogmask(LOG_UPTO(LOG_NOTICE));
+#endif
+
+ openlog("libmraa", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
+ syslog(LOG_DEBUG, "libmraa initialised by user %d", getuid());
+
if (plat != NULL) {
return MRAA_ERROR_PLATFORM_ALREADY_INITIALISED;
}
break;
default:
plat = mraa_intel_galileo_rev_d();
- fprintf(stderr, "Platform not found, initialising MRAA_INTEL_GALILEO_GEN1\n");
+ syslog(LOG_ERR, "Platform not found, initialising MRAA_INTEL_GALILEO_GEN1");
}
+ syslog(LOG_NOTICE, "libmraa initialised for platform %d", platform_type);
return MRAA_SUCCESS;
}
{
free(plat->pins);
free(plat);
+ closelog();
}
int
mraa_setup_gpio(int pin)
{
if (plat == NULL)
- return -1;
+ return MRAA_PLATFORM_NO_INIT;
if (pin < 0 || pin > plat->phy_pin_count)
- return -1;
+ return MRAA_NO_SUCH_IO;
if(plat->pins[pin].capabilites.gpio != 1)
- return -1;
+ return MRAA_NO_SUCH_IO;
if (plat->pins[pin].gpio.mux_total > 0)
if (mraa_setup_mux_mapped(plat->pins[pin].gpio) != MRAA_SUCCESS)
- return -1;
+ return MRAA_NO_SUCH_IO;
return plat->pins[pin].gpio.pinmap;
}
mraa_setup_aio(int aio)
{
if (plat == NULL)
- return -3;
+ return MRAA_PLATFORM_NO_INIT;
if (aio < 0 || aio > plat->aio_count)
- return -1;
+ return MRAA_NO_SUCH_IO;
int pin = aio + plat->gpio_count;
if (plat->pins[pin].capabilites.aio != 1)
- return -1;
+ return MRAA_NO_SUCH_IO;
if (plat->pins[pin].aio.mux_total > 0)
if (mraa_setup_mux_mapped(plat->pins[pin].aio) != MRAA_SUCCESS)
- return -1;
+ return MRAA_NO_SUCH_IO;
return plat->pins[pin].aio.pinmap;
}
mraa_setup_i2c(int bus)
{
if (plat == NULL)
- return -3;
+ return MRAA_PLATFORM_NO_INIT;
if (plat->i2c_bus_count == 0) {
- fprintf(stderr, "No i2c buses defined in platform");
- return -1;
+ syslog(LOG_ERR, "No i2c buses defined in platform");
+ return MRAA_NO_SUCH_IO;
}
if (bus >= plat->i2c_bus_count) {
- fprintf(stderr, "Above i2c bus count");
- return -1;
+ syslog(LOG_ERR, "Above i2c bus count");
+ return MRAA_NO_SUCH_IO;
}
if (plat->i2c_bus[bus].bus_id == -1) {
- fprintf(stderr, "Platform not currently allowed for mraa use\n");
- return -1;
+ syslog(LOG_ERR, "Platform not currently allowed for mraa use");
+ return MRAA_NO_SUCH_IO;
}
int pos = plat->i2c_bus[bus].sda;
if (plat->pins[pos].i2c.mux_total > 0)
if (mraa_setup_mux_mapped(plat->pins[pos].i2c) != MRAA_SUCCESS)
- return -2;
+ return MRAA_IO_SETUP_FAILURE;
pos = plat->i2c_bus[bus].scl;
if (plat->pins[pos].i2c.mux_total > 0)
if (mraa_setup_mux_mapped(plat->pins[pos].i2c) != MRAA_SUCCESS)
- return -2;
+ return MRAA_IO_SETUP_FAILURE;
return plat->i2c_bus[bus].bus_id;
}
return NULL;
if (plat->spi_bus_count >! 0) {
- fprintf(stderr, "No spi buses defined in platform");
+ syslog(LOG_ERR, "No spi buses defined in platform");
return NULL;
}
if (plat->spi_bus_count == 1) {
bus = plat->def_spi_bus;
}
if (bus >= plat->spi_bus_count) {
- fprintf(stderr, "Above spi bus count");
+ syslog(LOG_ERR, "Above spi bus count");
return NULL;
}
mraa_result_print(mraa_result_t result)
{
switch (result) {
- case MRAA_SUCCESS: fprintf(stderr, "MRAA: SUCCESS\n");
- break;
+ case MRAA_SUCCESS:
+ fprintf(stdout, "MRAA: SUCCESS\n");
+ break;
case MRAA_ERROR_FEATURE_NOT_IMPLEMENTED:
- fprintf(stderr, "MRAA: Feature not implemented.\n");
- break;
+ fprintf(stdout, "MRAA: Feature not implemented.\n");
+ break;
case MRAA_ERROR_FEATURE_NOT_SUPPORTED:
- fprintf(stderr, "MRAA: Feature not supported by Hardware.\n");
- break;
+ fprintf(stdout, "MRAA: Feature not supported by Hardware.\n");
+ break;
case MRAA_ERROR_INVALID_VERBOSITY_LEVEL:
- fprintf(stderr, "MRAA: Invalid verbosity level.\n");
- break;
+ fprintf(stdout, "MRAA: Invalid verbosity level.\n");
+ break;
case MRAA_ERROR_INVALID_PARAMETER:
- fprintf(stderr, "MRAA: Invalid parameter.\n");
- break;
+ fprintf(stdout, "MRAA: Invalid parameter.\n");
+ break;
case MRAA_ERROR_INVALID_HANDLE:
- fprintf(stderr, "MRAA: Invalid Handle.\n");
- break;
+ fprintf(stdout, "MRAA: Invalid Handle.\n");
+ break;
case MRAA_ERROR_NO_RESOURCES:
- fprintf(stderr, "MRAA: No resources.\n");
- break;
+ fprintf(stdout, "MRAA: No resources.\n");
+ break;
case MRAA_ERROR_INVALID_RESOURCE:
- fprintf(stderr, "MRAA: Invalid resource.\n");
- break;
+ fprintf(stdout, "MRAA: Invalid resource.\n");
+ break;
case MRAA_ERROR_INVALID_QUEUE_TYPE:
- fprintf(stderr, "MRAA: Invalid Queue Type.\n");
- break;
+ fprintf(stdout, "MRAA: Invalid Queue Type.\n");
+ break;
case MRAA_ERROR_NO_DATA_AVAILABLE:
- fprintf(stderr, "MRAA: No Data available.\n");
- break;
+ fprintf(stdout, "MRAA: No Data available.\n");
+ break;
case MRAA_ERROR_INVALID_PLATFORM:
- fprintf(stderr, "MRAA: Platform not recognised.\n");
- break;
+ fprintf(stdout, "MRAA: Platform not recognised.\n");
+ break;
case MRAA_ERROR_PLATFORM_NOT_INITIALISED:
- fprintf(stderr, "MRAA: Platform not initialised.\n");
- break;
+ fprintf(stdout, "MRAA: Platform not initialised.\n");
+ break;
case MRAA_ERROR_PLATFORM_ALREADY_INITIALISED:
- fprintf(stderr, "MRAA: Platform already initialised.\n");
- break;
+ fprintf(stdout, "MRAA: Platform already initialised.\n");
+ break;
case MRAA_ERROR_UNSPECIFIED:
- fprintf(stderr, "MRAA: Unspecified Error.\n");
- break;
- default: fprintf(stderr, "MRAA: Unrecognised error.\n");
- break;
+ fprintf(stdout, "MRAA: Unspecified Error.\n");
+ break;
+ default:
+ fprintf(stdout, "MRAA: Unrecognised error.\n");
+ break;
}
}
int period_f = open(bu, O_RDWR);
if (period_f == -1) {
- fprintf(stderr, "Failed to open period for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to open period for reading!\n");
+ syslog(LOG_ERR, "Failed to open period for reading");
return 0;
}
off_t size = lseek(period_f, 0, SEEK_END);
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)) {
- fprintf(stderr, "PWM Pin already exporting, continuing.\n");
+ syslog(LOG_NOTICE, "PWM Pin already exporting, 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) {
- fprintf(stderr, "Failed to open export for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to export! Potentially already enabled\n");
+ syslog(LOG_WARNING, "Failed to write to export! Potentially already enabled");
close(export_f);
return NULL;
}
int enable_f = open(bu, O_RDWR);
if (enable_f == -1) {
- fprintf(stderr, "Failed to open enable for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to enable!\n");
+ syslog(LOG_ERR, "Failed to write to enable");
close(enable_f);
return MRAA_ERROR_INVALID_RESOURCE;
}
int unexport_f = open(filepath, O_WRONLY);
if (unexport_f == -1) {
- fprintf(stderr, "Failed to open unexport for writing!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to write to unexport!\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed. SPI platform Error\n");
+ if (bus < 0) {
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed opening SPI Device. bus:%s\n", path);
+ syslog(LOG_ERR, "Failed opening SPI Device. bus:%s", path);
free(dev);
return NULL;
}
}
if (ioctl (dev->devfd, SPI_IOC_WR_MODE, &spi_mode) < 0) {
- fprintf(stderr, "Failed to set spi mode\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to set bit order\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to perform dev transfer\n");
+ syslog(LOG_ERR, "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) {
- fprintf(stderr, "Failed to perform dev transfer\n");
+ syslog(LOG_ERR, "Failed to perform dev transfer");
return NULL;
}
return recv;
projects / contrib / mraa.git / commitdiff