*/
#include <unistd.h>
-//! [Interesting]
#include "mraa/iio.h"
+static void
+printword(uint16_t input, mraa_iio_channel *chan)
+{
+ int16_t res;
+ if (!chan->lendian) {
+ input = be16toh(input);
+ } else {
+ input = le16toh(input);
+ }
+
+ // currently we don't treat scales
+ chan->scale = 1.0f;
+
+ input >>= chan->shift;
+ input &= chan->mask;
+ if (chan->signedd) {
+ res = (int16_t)(input << (16 - chan->bits_used)) >> (16 - chan->bits_used);
+ } else {
+ res = input;
+ }
+ printf("chan %d == %05f\n", chan->index, ((float)res + chan->offset) * chan->scale);
+}
+
+mraa_iio_context iio_device0;
+
+void
+interrupt(char* data)
+{
+ mraa_iio_channel* channels = mraa_iio_get_channels(iio_device0);
+ int i = 0;
+
+ for (i; i < mraa_iio_get_channel_count(iio_device0); i++) {
+ printf("channel bytes %d\n", channels[i].bytes);
+ switch (channels[i].bytes) {
+ case 2:
+ printword(*(uint16_t *)(data + channels[i].location), &channels[i]);
+ }
+ }
+ printf("data %s\n", (char*) data);
+}
+
int
main()
{
- mraa_iio_context iio_device0;
-
+ //! [Interesting]
iio_device0 = mraa_iio_init(0);
if (iio_device0 == NULL) {
return EXIT_FAILURE;
fprintf(stdout, "IIO read %f\n", iio_value);
}
- return EXIT_SUCCESS;
+ if (mraa_iio_trigger_buffer(iio_device0, interrupt, NULL) == MRAA_SUCCESS) {
+ sleep(100);
+ return EXIT_SUCCESS;
+ }
+
+ //! [Interesting]
+ return EXIT_FAILURE;
}
-//! [Interesting]
#include "mraa_internal.h"
#include "dirent.h"
#include <string.h>
+#include <poll.h>
-#define IIO_SYSFS_DEVICE "/sys/bus/iio/devices/iio:device"
+#define MAX_SIZE 128
+#define IIO_DEVICE "iio:device"
+#define IIO_SCAN_ELEM "scan_elements"
+#define IIO_SLASH_DEV "/dev/"IIO_DEVICE
+#define IIO_SYSFS_DEVICE "/sys/bus/iio/devices/"IIO_DEVICE
mraa_iio_context
mraa_iio_init(int device)
return NULL;
}
+ mraa_iio_get_channel_data(&plat->iio_devices[device]);
return &plat->iio_devices[device];
}
+int
+mraa_iio_read_size(mraa_iio_context dev)
+{
+ return dev->datasize;
+}
+
+mraa_iio_channel*
+mraa_iio_get_channels(mraa_iio_context dev)
+{
+ return dev->channels;
+}
+
+int
+mraa_iio_get_channel_count(mraa_iio_context dev)
+{
+ return dev->chan_num;
+}
+
+mraa_result_t
+mraa_iio_get_channel_data(mraa_iio_context dev)
+{
+ const struct dirent *ent;
+ DIR* dir;
+ int chan_num = 0;
+ char buf[MAX_SIZE];
+ char readbuf[32];
+ int fd;
+ int ret = 0;
+ int padint = 0;
+ int curr_bytes = 0;
+ char shortbuf, signchar;
+ memset(buf, 0, MAX_SIZE);
+ snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM, dev->num);
+ dir = opendir(buf);
+ if (dir != NULL) {
+ while ((ent = readdir(dir)) != NULL) {
+ if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), "_en") == 0) {
+ chan_num++;
+ }
+ }
+ }
+ dev->chan_num = chan_num;
+ mraa_iio_channel* chan;
+ dev->channels = calloc(chan_num, sizeof(mraa_iio_channel));
+ seekdir(dir, 0);
+ while ((ent = readdir(dir)) != NULL) {
+ if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_index"), "_index") == 0) {
+ snprintf(buf, MAX_SIZE, IIO_SYSFS_DEVICE "%d/" IIO_SCAN_ELEM "/%s", dev->num, ent->d_name);
+ fd = open(buf, O_RDONLY);
+ if (fd > 0) {
+ if (read(fd, readbuf, 2 * sizeof(char)) != 2) {
+ break;
+ }
+ chan_num = ((int) strtol(readbuf, NULL, 10));
+ chan = &dev->channels[chan_num];
+ chan->index = chan_num;
+ close(fd);
+
+ buf[(strlen(buf)-5)] = '\0';
+ char* str = strdup(buf);
+ snprintf(buf, MAX_SIZE, "%stype", str);
+ fd = open(buf, O_RDONLY);
+ if (fd > 0) {
+ read(fd, readbuf, 31 * sizeof(char));
+ ret = sscanf(readbuf, "%ce:%c%u/%u>>%u", &shortbuf,
+ &signchar, &chan->bits_used,
+ &padint, &chan->shift);
+ chan->bytes = padint / 8;
+ if (curr_bytes % chan->bytes == 0) {
+ chan->location = curr_bytes;
+ } else {
+ chan->location = curr_bytes - curr_bytes%chan->bytes + chan->bytes;
+ }
+ curr_bytes = chan->location + chan->bytes;
+ if (ret < 0) {
+ // probably should be 5?
+ return MRAA_IO_SETUP_FAILURE;
+ }
+ chan->signedd = (signchar == 's');
+ chan->lendian = (shortbuf == 'l');
+ if (chan->bits_used == 64) {
+ chan->mask = ~0;
+ } else {
+ chan->mask = (1 << chan->bits_used) - 1;
+ }
+
+ close(fd);
+ }
+ // todo - read scale & _en attributes
+ }
+ }
+ }
+ dev->datasize = curr_bytes;
+
+ return MRAA_SUCCESS;
+}
+
const char*
mraa_iio_get_device_name(mraa_iio_context dev)
{
mraa_iio_read(mraa_iio_context dev, const char* attr_chan, float* data)
{
char buf[64];
- snprintf(buf, 64, IIO_SYSFS_DEVICE, "%d/%s", dev->num, attr_chan);
+ snprintf(buf, 64, IIO_SYSFS_DEVICE "%d/%s", dev->num, attr_chan);
int fd = open(buf, O_RDONLY);
if (fd != -1) {
int len = read(fd, &buf, 64);
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
+static mraa_result_t
+mraa_iio_wait_event(int fd, char* data)
+{
+ struct pollfd pfd;
+
+ if (fd < 0) {
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
+
+ pfd.fd = fd;
+ pfd.events = POLLIN;
+
+ // Wait for it forever or until pthread_cancel
+ // poll is a cancelable point like sleep()
+ int x = poll(&pfd, 1, -1);
+
+ memset(data, 0, 100);
+ read(fd, data, 100);
+
+ return MRAA_SUCCESS;
+}
+
+static void*
+mraa_iio_trigger_handler(void* arg)
+{
+ mraa_iio_context dev = (mraa_iio_context) arg;
+ char data[MAX_SIZE*100];
+
+ for (;;) {
+ if (mraa_iio_wait_event(dev->fp, &data[0]) == MRAA_SUCCESS) {
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+ dev->isr(&data);
+ pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+ } else {
+ // we must have got an error code so die nicely
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+ return NULL;
+ }
+ }
+}
+
+mraa_result_t
+mraa_iio_trigger_buffer(mraa_iio_context dev, void (*fptr)(char* data), void* args)
+{
+ char bu[MAX_SIZE];
+ if (dev->thread_id != 0) {
+ return MRAA_ERROR_NO_RESOURCES;
+ }
+
+ sprintf(bu, IIO_SLASH_DEV "%d", dev->num);
+ dev->fp = open(bu, O_RDONLY | O_NONBLOCK);
+ if (dev->fp == -1) {
+ return MRAA_ERROR_INVALID_RESOURCE;
+ }
+
+ dev->isr = fptr;
+ pthread_create(&dev->thread_id, NULL, mraa_iio_trigger_handler, (void*) dev);
+
+ return MRAA_SUCCESS;
+}
+
#if 0
+// does stop make any sense on iio devices?
mraa_result_t
mraa_iio_stop(mraa_iio_context dev)
{
projects / contrib / mraa.git / commitdiff