sensor/stmemsc: Align stmemsc i/f to v2.02

set(stmems_pids

  a3g4250d

  ais25ba

  ais2dw12

  ais2ih

  ais328dq

  ais3624dq

  asm330lhb

  asm330lhh

  asm330lhhx

  h3lis100dl

  iis3dhhc

  iis3dwb

  ilps22qs

  ilps28qsw

  ism303dac

  ism330dhcx

  ism330dlc

  ism330is

  l20g20is

  l3gd20h

  lis25ba

  lis2dh12

  lis2ds12

  lis2dtw12

  lis2du12

  lis2dux12

  lis2duxs12

  lis2dw12

  lis2hh12

  lis2mdl

  lsm6dsl

  lsm6dsm

  lsm6dso

  lsm6dso16is

  lsm6dso32

  lsm6dso32x

  lsm6dsox

  lsm6dsr

  lsm6dsrx

  lsm6dsv16bx

  lsm6dsv16x

  lsm6dsv

  lsm9ds1

  stts22h

  stts751

   https://www.st.com/en/embedded-software/c-driver-mems.html

Status:

   version v2.01

   version v2.02

Purpose:

   ST Microelectronics standard C platform-independent drivers for MEMS

   The driver is platform-independent, you only need to define the two

   functions for read and write transactions from the sensor hardware bus

   (ie. SPI or I2C).

   (ie. SPI or I2C). In addition you may define a mdelay (milliseconds) 

   routine.

   Define in your 'xyz' driver code the read and write functions that use the

   I2C or SPI platform driver like the following:

   I2C or SPI platform driver (plus the optional mdelay function) like the following:

   /** Please note that is MANDATORY: return 0 -> no Error.**/

   int platform_wr(void *handle, u8_t reg, const u8_t *bufp, u16_t len);

   int platform_rd(void *handle, u8_t reg, u8_t *bufp, u16_t len);

   /** Component optional fields **/

   void platform_mdelay(u32_t millisec);

   stmdev_ctx_t stmdev_ctx = {

       .read_reg = (stmdev_read_ptr) platform_rd,

       .write_reg = (stmdev_write_ptr) platform_wr,

       /** Component optional fields **/

       .mdelay = (stmdev_mdelay_ptr) platform_mdelay,

   };

Dependencies:

   https://www.st.com/en/embedded-software/c-driver-mems.html

commit:

   version v2.01

   version v2.02

Maintained-by:

   ST Microelectronics

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include "st_fifo.h"

uint16_t out_slot_size;

int main(int argc, char *argv[])

{

	if (argc != 3) {

		printf("Error: please specify input and output as commandline args\n");

		return -1;

	}

	FILE *fp;

	char *line = NULL;

	fp = fopen(argv[1], "r");

	size_t len = 0;

	ssize_t read;

	FILE *out_file;

	out_file = fopen(argv[2], "w");

	int lines = 0;

	size_t pos = ftell(fp);

	while(!feof(fp)) {

		char ch = fgetc(fp);

		if(ch == '\n') {

			lines++;

		}

	}

	fseek(fp, pos, SEEK_SET);

	printf("File length: %d\n", lines);

	st_fifo_conf conf;

	conf.device = ST_FIFO_LSM6DSV16X;

	conf.bdr_xl = 0;

	conf.bdr_gy = 0;

	conf.bdr_vsens = 0;

	st_fifo_init(&conf);

	st_fifo_raw_slot *raw_slot;

	st_fifo_out_slot *out_slot;

	raw_slot = malloc(lines * sizeof(st_fifo_raw_slot));

	out_slot = malloc(lines * 3 * sizeof(st_fifo_out_slot));

	int i = 0;

	printf("Running test...\n");

	while((read = getline(&line, &len, fp)) != -1) {

		int data_in[7];

		sscanf(line, "%d\t%d\t%d\t%d\t%d\t%d\t%d\r\n", &data_in[0], &data_in[1], &data_in[2], &data_in[3], &data_in[4], &data_in[5], &data_in[6]);

		for (uint8_t j = 0; j < 7; j++)

			raw_slot[i].fifo_data_out[j] = data_in[j];

		i++;

  	}

	st_fifo_decode(out_slot, raw_slot, &out_slot_size, lines);

	st_fifo_sort(out_slot, out_slot_size);

	uint16_t acc_samples = st_fifo_get_sensor_occurrence(out_slot, out_slot_size, ST_FIFO_ACCELEROMETER);

	uint16_t gyr_samples = st_fifo_get_sensor_occurrence(out_slot, out_slot_size, ST_FIFO_GYROSCOPE);

	printf("acc samples: %d\n", acc_samples);

	printf("gyr samples: %d\n", gyr_samples);

	st_fifo_out_slot *acc_slot = malloc(acc_samples * sizeof(st_fifo_out_slot));

	st_fifo_out_slot *gyr_slot = malloc(gyr_samples * sizeof(st_fifo_out_slot));

	st_fifo_extract_sensor(acc_slot, out_slot, out_slot_size, ST_FIFO_ACCELEROMETER);

	st_fifo_extract_sensor(gyr_slot, out_slot, out_slot_size, ST_FIFO_GYROSCOPE);

	for (int i = 0; i < out_slot_size; i++) {

		fprintf(out_file, "%u\t%d\t%d\t%d\t%d\r\n", out_slot[i].timestamp, out_slot[i].sensor_tag, out_slot[i].sensor_data.data[0], out_slot[i].sensor_data.data[1], out_slot[i].sensor_data.data[2]);

	}

	/*

	for (int i = 0; i < acc_samples; i++) {

		printf("ACC SLOT:\t%lld\t%d\t%d\t%d\t%d\r\n", acc_slot[i].timestamp, acc_slot[i].sensor_tag, acc_slot[i].data[0], acc_slot[i].data[1], acc_slot[i].data[2]);

	}

	for (int i = 0; i < gyr_samples; i++) {

		printf("GYR SLOT:\t%lld\t%d\t%d\t%d\t%d\r\n", gyr_slot[i].timestamp, gyr_slot[i].sensor_tag, gyr_slot[i].data[0], gyr_slot[i].data[1], gyr_slot[i].data[2]);

	}

	*/

	printf("Test finished: see %s file\n", argv[2]);

  	fclose(fp);

  	fclose(out_file);

  	return 0;

}

CC = gcc

SRC = main.c st_fifo.c

CFLAGS = -Wall -Wextra -Werror -std=gnu99 

default:

	$(CC) $(CFLAGS) $(SRC) -o st_fifo.run

clean:

	rm -fr *.o

	rm -fr st_fifo.run