diff options
Diffstat (limited to 'libsensors_iio/software/simple_apps/mpu_iio/mpu_iio.c')
| -rw-r--r-- | libsensors_iio/software/simple_apps/mpu_iio/mpu_iio.c | 685 |
1 files changed, 685 insertions, 0 deletions
diff --git a/libsensors_iio/software/simple_apps/mpu_iio/mpu_iio.c b/libsensors_iio/software/simple_apps/mpu_iio/mpu_iio.c new file mode 100644 index 0000000..b3d323c --- /dev/null +++ b/libsensors_iio/software/simple_apps/mpu_iio/mpu_iio.c @@ -0,0 +1,685 @@ +/* Industrialio buffer test code. + * + * Copyright (c) 2008 Jonathan Cameron + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published by + * the Free Software Foundation. + * + * This program is primarily intended as an example application. + * Reads the current buffer setup from sysfs and starts a short capture + * from the specified device, pretty printing the result after appropriate + * conversion. + * + * Command line parameters + * generic_buffer -n <device_name> -t <trigger_name> + * If trigger name is not specified the program assumes you want a dataready + * trigger associated with the device and goes looking for it. + * + */ + +#include <unistd.h> +#include <dirent.h> +#include <fcntl.h> +#include <stdio.h> +#include <errno.h> +#include <sys/stat.h> +#include <dirent.h> +#include <linux/types.h> +#include <string.h> +#include <poll.h> +#include "iio_utils.h" +#include "ml_load_dmp.h" +#include "ml_sysfs_helper.h" +#include "authenticate.h" + +#define FLICK_SUPPORTED (0) + +/** + * size_from_channelarray() - calculate the storage size of a scan + * @channels: the channel info array + * @num_channels: size of the channel info array + * + * Has the side effect of filling the channels[i].location values used + * in processing the buffer output. + **/ +int size_from_channelarray(struct iio_channel_info *channels, int num_channels) +{ + int bytes = 0; + int i = 0; + while (i < num_channels) { + if (bytes % channels[i].bytes == 0) + channels[i].location = bytes; + else + channels[i].location = bytes - bytes%channels[i].bytes + + channels[i].bytes; + bytes = channels[i].location + channels[i].bytes; + i++; + } + return bytes; +} + +void print2byte(int input, struct iio_channel_info *info) +{ + /* shift before conversion to avoid sign extension + of left aligned data */ + input = input >> info->shift; + if (info->is_signed) { + int16_t val = input; + val &= (1 << info->bits_used) - 1; + val = (int16_t)(val << (16 - info->bits_used)) >> + (16 - info->bits_used); + /*printf("%d, %05f, scale=%05f", val, + (float)(val + info->offset)*info->scale, info->scale);*/ + printf("%d, ", val); + + } else { + uint16_t val = input; + val &= (1 << info->bits_used) - 1; + printf("%05f ", ((float)val + info->offset)*info->scale); + } +} +/** + * process_scan() - print out the values in SI units + * @data: pointer to the start of the scan + * @infoarray: information about the channels. Note + * size_from_channelarray must have been called first to fill the + * location offsets. + * @num_channels: the number of active channels + **/ +void process_scan(char *data, + struct iio_channel_info *infoarray, + int num_channels) +{ + int k; + //char *tmp; + for (k = 0; k < num_channels; k++) { + switch (infoarray[k].bytes) { + /* only a few cases implemented so far */ + case 2: + print2byte(*(uint16_t *)(data + infoarray[k].location), + &infoarray[k]); + //tmp = data + infoarray[k].location; + break; + case 4: + if (infoarray[k].is_signed) { + int32_t val = *(int32_t *) + (data + + infoarray[k].location); + if ((val >> infoarray[k].bits_used) & 1) + val = (val & infoarray[k].mask) | + ~infoarray[k].mask; + /* special case for timestamp */ + printf(" %d ", val); + } + break; + case 8: + if (infoarray[k].is_signed) { + int64_t val = *(int64_t *) + (data + + infoarray[k].location); + if ((val >> infoarray[k].bits_used) & 1) + val = (val & infoarray[k].mask) | + ~infoarray[k].mask; + /* special case for timestamp */ + if (infoarray[k].scale == 1.0f && + infoarray[k].offset == 0.0f) + printf(" %lld", val); + else + printf("%05f ", ((float)val + + infoarray[k].offset)* + infoarray[k].scale); + } + break; + default: + break; + } + } + printf("\n"); +} + +#if FLICK_SUPPORTED /* hide flick, not offially supported */ +void enable_flick(char *p, int on){ + int ret; + printf("flick:%s\n", p); + ret = write_sysfs_int_and_verify("flick_int_on", p, on); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("flick_upper", p, 3147790); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("flick_lower", p, -3147790); + if (ret < 0) + return; + + ret = write_sysfs_int_and_verify("flick_counter", p, 50); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("flick_message_on", p, 0); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("flick_axis", p, 0); +} +#endif + +void HandleOrient(int orient) +{ + if (orient & 0x01) + printf("INV_X_UP\n"); + if (orient & 0x02) + printf("INV_X_DOWN\n"); + if (orient & 0x04) + printf("INV_Y_UP\n"); + if (orient & 0x08) + printf("INV_Y_DOWN\n"); + if (orient & 0x10) + printf("INV_Z_UP\n"); + if (orient & 0x20) + printf("INV_Z_DOWN\n"); + if (orient & 0x40) + printf("INV_ORIENTATION_FLIP\n"); +} + +void HandleTap(int tap) +{ + int tap_dir = tap/8; + int tap_num = tap%8 + 1; + + switch (tap_dir) { + case 1: + printf("INV_TAP_AXIS_X_POS\n"); + break; + case 2: + printf("INV_TAP_AXIS_X_NEG\n"); + break; + case 3: + printf("INV_TAP_AXIS_Y_POS\n"); + break; + case 4: + printf("INV_TAP_AXIS_Y_NEG\n"); + break; + case 5: + printf("INV_TAP_AXIS_Z_POS\n"); + break; + case 6: + printf("INV_TAP_AXIS_Z_NEG\n"); + break; + default: + break; + } + printf("Tap number: %d\n", tap_num); +} +#define DMP_CODE_SIZE 3060 +void verify_img(char *dmp_path){ + FILE *fp; + int i; + char dmp_img[DMP_CODE_SIZE]; + if ((fp = fopen(dmp_path, "rb")) < 0 ) { + perror("dmp fail"); + } + i = fread(dmp_img, 1, DMP_CODE_SIZE, fp); + printf("Result=%d\n", i); + fclose(fp); + fp = fopen("/dev/read_img.h", "wt"); + fprintf(fp, "char rec[]={\n"); + for(i=0; i<DMP_CODE_SIZE; i++) { + fprintf(fp, "0x%02x, ", dmp_img[i]); + if(((i+1)%16) == 0) { + fprintf(fp, "\n"); + } + } + fprintf(fp, "};\n "); + fclose(fp); +} + +void setup_dmp(char *dev_path, int p_event){ + char sysfs_path[200]; + char dmp_path[200]; + int ret; + FILE *fd; + sprintf(sysfs_path, "%s", dev_path); + printf("sysfs: %s\n", sysfs_path); + ret = write_sysfs_int_and_verify("power_state", sysfs_path, 1); + if (ret < 0) + return; + + ret = write_sysfs_int("in_accel_scale", dev_path, 0); + if (ret < 0) + return; + ret = write_sysfs_int("in_anglvel_scale", dev_path, 2); + if (ret < 0) + return; + ret = write_sysfs_int("sampling_frequency", sysfs_path, 200); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("firmware_loaded", sysfs_path, 0); + if (ret < 0) + return; + sprintf(dmp_path, "%s/dmp_firmware", dev_path); + if ((fd = fopen(dmp_path, "wb")) < 0 ) { + perror("dmp fail"); + } + inv_load_dmp(fd); + fclose(fd); + printf("firmware_loaded=%d\n", read_sysfs_posint("firmware_loaded", sysfs_path)); + ret = write_sysfs_int_and_verify("in_accel_x_offset", sysfs_path, 0xabcd0000); + ret = write_sysfs_int_and_verify("in_accel_y_offset", sysfs_path, 0xffff0000); + ret = write_sysfs_int_and_verify("in_accel_z_offset", sysfs_path, 0xcdef0000); + + ret = write_sysfs_int_and_verify("dmp_on", sysfs_path, 1); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("dmp_int_on", sysfs_path, 1); + if (ret < 0) + return; + /* selelct which event to enable and interrupt on/off here */ + //enable_flick(sysfs_path, 1); + ret = write_sysfs_int_and_verify("tap_on", sysfs_path, 1); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("display_orientation_on", sysfs_path, 1); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("orientation_on", sysfs_path, 1); + if (ret < 0) + return; + printf("rate\n"); + ret = write_sysfs_int_and_verify("dmp_output_rate", sysfs_path, 25); + if (ret < 0) + return; + ret = write_sysfs_int_and_verify("dmp_event_int_on", sysfs_path, p_event); + if (ret < 0) + return; + //verify_img(dmp_path); +} + +void get_dmp_event(char *dev_dir_name) +{ + char file_name[100]; + int i; +#if FLICK_SUPPORTED /* hide flick, not offially supported */ + int fp_tap, fp_orient, fp_disp, fp_flick; + const int n_gest = 6; +#else + int fp_tap, fp_orient, fp_disp, fp_motion; + //int fp_no_motion; + const int n_gest = 4; +#endif + int data; + char d[6]; + FILE *fp; + struct pollfd pfd[4]; + printf("%s\n", dev_dir_name); + while(1) { + sprintf(file_name, "%s/event_tap", dev_dir_name); + fp_tap = open(file_name, O_RDONLY | O_NONBLOCK); + sprintf(file_name, "%s/event_orientation", dev_dir_name); + fp_orient = open(file_name, O_RDONLY | O_NONBLOCK); + sprintf(file_name, "%s/event_display_orientation", dev_dir_name); + fp_disp = open(file_name, O_RDONLY | O_NONBLOCK); + + //sprintf(file_name, "%s/event_accel_motion", dev_dir_name); + sprintf(file_name, "%s/event_accel_wom", dev_dir_name); + fp_motion = open(file_name, O_RDONLY | O_NONBLOCK); + //sprintf(file_name, "%s/event_accel_no_motion", dev_dir_name); + //fp_no_motion = open(file_name, O_RDONLY | O_NONBLOCK); +#if FLICK_SUPPORTED /* hide flick, not offially supported */ + sprintf(file_name, "%s/event_flick", dev_dir_name); + fp_flick = open(file_name, O_RDONLY | O_NONBLOCK); +#endif + + pfd[0].fd = fp_tap; + pfd[0].events = POLLPRI|POLLERR, + pfd[0].revents = 0; + + pfd[1].fd = fp_orient; + pfd[1].events = POLLPRI|POLLERR, + pfd[1].revents = 0; + + pfd[2].fd = fp_disp; + pfd[2].events = POLLPRI|POLLERR, + pfd[2].revents = 0; + + pfd[3].fd = fp_motion; + pfd[3].events = POLLPRI|POLLERR, + pfd[3].revents = 0; + + //pfd[4].fd = fp_no_motion; + //pfd[4].events = POLLPRI|POLLERR, + //pfd[4].revents = 0; + +#if FLICK_SUPPORTED /* hide flick, not offially supported */ + pfd[5].fd = fp_flick; + pfd[5].events = POLLPRI|POLLERR, + pfd[5].revents = 0; +#endif + + read(fp_tap, d, 4); + read(fp_orient, d, 4); + read(fp_disp, d, 4); + read(fp_motion, d, 4); + //read(fp_no_motion, d, 4); +#if FLICK_SUPPORTED /* hide flick, not offially supported */ + read(fp_flick, d, 4); +#endif + + poll(pfd, n_gest, -1); + close(fp_tap); + close(fp_orient); + close(fp_disp); + close(fp_motion); + //close(fp_no_motion); +#if FLICK_SUPPORTED /* hide flick, not offially supported */ + close(fp_flick); +#endif + for (i = 0; i < ARRAY_SIZE(pfd); i++) { + if(pfd[i].revents != 0) { + switch (i){ + case 0: + sprintf(file_name, "%s/event_tap", dev_dir_name); + fp = fopen(file_name, "rt"); + fscanf(fp, "%d\n", &data); + printf("tap=%x\n", data); + HandleTap(data); + fclose(fp); + break; + case 1: + sprintf(file_name, "%s/event_orientation", dev_dir_name); + fp = fopen(file_name, "rt"); + fscanf(fp, "%d\n", &data); + printf("orient=%x\n", data); + HandleOrient(data); + fclose(fp); + break; + case 2: + sprintf(file_name, "%s/event_display_orientation", dev_dir_name); + fp = fopen(file_name, "rt"); + fscanf(fp, "%d\n", &data); + printf("display_orient=%x\n", data); + fclose(fp); + break; + case 3: + sprintf(file_name, "%s/event_accel_wom", dev_dir_name); + fp = fopen(file_name, "rt"); + fscanf(fp, "%d\n", &data); + printf("motion=%x\n", data); + fclose(fp); + break; + case 4: + sprintf(file_name, "%s/event_accel_no_motion", dev_dir_name); + fp = fopen(file_name, "rt"); + fscanf(fp, "%d\n", &data); + printf("No motion=%x\n", data); + fclose(fp); + break; + +#if FLICK_SUPPORTED /* hide flick, not offially supported */ + case 5: + sprintf(file_name, "%s/event_flick", dev_dir_name); + fp = fopen(file_name, "rt"); + fscanf(fp, "%d\n", &data); + printf("flick=%x\n", data); + fclose(fp); + break; +#endif + } + } + } + } +} + + +int main(int argc, char **argv) +{ + unsigned long num_loops = 2; + unsigned long timedelay = 100000; + unsigned long buf_len = 128; + + int ret, c, i, j, toread; + int fp; + + int num_channels; + char *trigger_name = NULL; + char *dev_dir_name, *buf_dir_name; + + int datardytrigger = 1; + char *data; + int read_size; + int dev_num, trig_num; + char *buffer_access; + int scan_size; + int noevents = 0; + int p_event = 0, nodmp = 0; + char *dummy; + char chip_name[10]; + char device_name[10]; + char sysfs[100]; + + struct iio_channel_info *infoarray; + /* -r means no DMP is enabled (raw) -> should be used for mpu3050. + -p means no print of data */ + /* when using -p, 1 means orientation, 2 means tap, 3 means flick */ + while ((c = getopt(argc, argv, "l:w:c:pret:")) != -1) { + switch (c) { + case 't': + trigger_name = optarg; + datardytrigger = 0; + break; + case 'e': + noevents = 1; + break; + case 'p': + p_event = 1; + break; + case 'r': + nodmp = 1; + break; + case 'c': + num_loops = strtoul(optarg, &dummy, 10); + break; + case 'w': + timedelay = strtoul(optarg, &dummy, 10); + break; + case 'l': + buf_len = strtoul(optarg, &dummy, 10); + break; + case '?': + return -1; + } + } + inv_get_sysfs_path(sysfs); + printf("sss:::%s\n", sysfs); + if (inv_get_chip_name(chip_name) != INV_SUCCESS) { + printf("get chip name fail\n"); + exit(0); + } + printf("chip_name=%s\n", chip_name); + if (INV_SUCCESS != inv_check_key()) + printf("key check fail\n"); + else + printf("key authenticated\n"); + + for (i=0; i<strlen(chip_name); i++) { + device_name[i] = tolower(chip_name[i]); + } + device_name[strlen(chip_name)] = '\0'; + printf("device name: %s\n", device_name); + + /* Find the device requested */ + dev_num = find_type_by_name(device_name, "iio:device"); + if (dev_num < 0) { + printf("Failed to find the %s\n", device_name); + ret = -ENODEV; + goto error_ret; + } + printf("iio device number being used is %d\n", dev_num); + asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num); + if (trigger_name == NULL) { + /* + * Build the trigger name. If it is device associated it's + * name is <device_name>_dev[n] where n matches the device + * number found above + */ + ret = asprintf(&trigger_name, + "%s-dev%d", device_name, dev_num); + if (ret < 0) { + ret = -ENOMEM; + goto error_ret; + } + } + ret = write_sysfs_int("buffer/enable", dev_dir_name, 0); + + ret = write_sysfs_int_and_verify("power_state", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("gyro_enable", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("accl_enable", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("compass_enable", dev_dir_name, 1); +/* + ret = write_sysfs_int_and_verify("zero_motion_on", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("zero_motion_dur", dev_dir_name, 12); + ret = write_sysfs_int_and_verify("zero_motion_threshold", dev_dir_name, 13); + + ret = write_sysfs_int_and_verify("motion_on", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("motion_dur", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("motion_threshold", dev_dir_name, 1); +*/ + ret = write_sysfs_int_and_verify("accel_wom_on", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("accel_wom_threshold", dev_dir_name, 100); + /* Verify the trigger exists */ + trig_num = find_type_by_name(trigger_name, "trigger"); + if (trig_num < 0) { + printf("Failed to find the trigger %s\n", trigger_name); + ret = -ENODEV; + goto error_free_triggername; + } + printf("iio trigger number being used is %d\n", trig_num); + /* + * Parse the files in scan_elements to identify what channels are + * present + */ + ret = 0; + ret = enable(dev_dir_name, &infoarray, &num_channels); + if (ret) { + printf("error enable\n"); + goto error_free_triggername; + } + if (!nodmp) + setup_dmp(dev_dir_name, p_event); + + /* + * Construct the directory name for the associated buffer. + * As we know that the lis3l02dq has only one buffer this may + * be built rather than found. + */ + ret = asprintf(&buf_dir_name, "%siio:device%d/buffer", iio_dir, dev_num); + if (ret < 0) { + ret = -ENOMEM; + goto error_free_triggername; + } + printf("%s %s\n", dev_dir_name, trigger_name); + + /* Set the device trigger to be the data rdy trigger found above */ + ret = write_sysfs_string_and_verify("trigger/current_trigger", + dev_dir_name, + trigger_name); + if (ret < 0) { + printf("Failed to write current_trigger file\n"); + goto error_free_buf_dir_name; + } + /* Setup ring buffer parameters */ + /* length must be even number because iio_store_to_sw_ring is expecting + half pointer to be equal to the read pointer, which is impossible + when buflen is odd number. This is actually a bug in the code */ + ret = write_sysfs_int("length", buf_dir_name, buf_len*2); + if (ret < 0) + goto exit_here; + ret = write_sysfs_int_and_verify("gyro_enable", dev_dir_name, 1); + ret = write_sysfs_int_and_verify("accl_enable", dev_dir_name, 1); + //ret = write_sysfs_int_and_verify("compass_enable", dev_dir_name, 0); + if (nodmp == 0) { + ret = write_sysfs_int_and_verify("quaternion_on", dev_dir_name, 1); + } else { + ret = disable_q_out(dev_dir_name, &infoarray, &num_channels); + ret = write_sysfs_int_and_verify("dmp_on", dev_dir_name, 0); + } + ret = build_channel_array(dev_dir_name, &infoarray, &num_channels); + if (ret) { + printf("Problem reading scan element information\n"); + goto exit_here; + } + + /* Enable the buffer */ + ret = write_sysfs_int("enable", buf_dir_name, 1); + if (ret < 0) + goto exit_here; + scan_size = size_from_channelarray(infoarray, num_channels); + data = malloc(scan_size*buf_len); + if (!data) { + ret = -ENOMEM; + goto exit_here; + } + + ret = asprintf(&buffer_access, + "/dev/iio:device%d", + dev_num); + if (ret < 0) { + ret = -ENOMEM; + goto error_free_data; + } + if (p_event) { + get_dmp_event(dev_dir_name); + goto error_free_buffer_access; + } + /* Attempt to open non blocking the access dev */ + fp = open(buffer_access, O_RDONLY | O_NONBLOCK); + if (fp == -1) { /*If it isn't there make the node */ + printf("Failed to open %s\n", buffer_access); + ret = -errno; + goto error_free_buffer_access; + } + /* Wait for events 10 times */ + for (j = 0; j < num_loops; j++) { + if (!noevents) { + struct pollfd pfd = { + .fd = fp, + .events = POLLIN, + }; + poll(&pfd, 1, -1); + toread = 1; + if ((j%128)==0) + usleep(timedelay); + + } else { + usleep(timedelay); + toread = 1; + } + read_size = read(fp, + data, + toread*scan_size); + if (read_size == -EAGAIN) { + printf("nothing available\n"); + continue; + } + if (0 == p_event) { + for (i = 0; i < read_size/scan_size; i++) + process_scan(data + scan_size*i, + infoarray, + num_channels); + } + } + close(fp); +error_free_buffer_access: + free(buffer_access); +error_free_data: + free(data); +exit_here: + /* Stop the ring buffer */ + ret = write_sysfs_int("enable", buf_dir_name, 0); + +error_free_buf_dir_name: + free(buf_dir_name); +error_free_triggername: + if (datardytrigger) + free(trigger_name); +error_ret: + return ret; +} |