Take this example :

    // Set INT1 to wake up
    lsm6dsl_int1_route_t int1 = {
        .int1_wu = 1,
    };
    lsm6dsl_pin_int1_route_set(&dev_ctx, int1);
    
    // Disable INT2
    lsm6dsl_int2_route_t int2 = {0};
    lsm6dsl_pin_int2_route_set(&dev_ctx, int2);

The call to lsm6dsl_pin_int2_route_set sets TAP_CFG.INTERRUPTS_ENABLE to 0, which globally disables all interrupts, including the INT1 one

Possible fixes :

• Merge lsm6dsl_pin_int1_route_set and lsm6dsl_pin_int2_route_set into a single function
• Set TAP_CFG.INTERRUPTS_ENABLE if one interrupt is enabled, but never clear it

This bug seems to apply to the following drivers :

• iis2dlpc
• ism330dlc
• lis2dw12
• lsm6dsl
• lsm6dsm
• lsm6dso

Within the function lsm6dsox_all_sources_get there is incorrect axis assigned from the Tap sources

val->tap_x = tap_src.z_tap;
val->tap_y = tap_src.y_tap;
val->tap_z = tap_src.x_tap;

should be

val->tap_x = tap_src.x_tap;
val->tap_y = tap_src.y_tap;
val->tap_z = tap_src.z_tap;

Hey There,
In the libary are some defines, that doesn't fit each other.
Setting up the filters of the accelerometer with:
typedef enum {
LSM9DS1_LP_DISABLE = 0x00,
LSM9DS1_LP_ODR_DIV_50 = 0x10,
LSM9DS1_LP_ODR_DIV_100 = 0x11,
LSM9DS1_LP_ODR_DIV_9 = 0x12,
LSM9DS1_LP_ODR_DIV_400 = 0x13,
} lsm9ds1_xl_lp_bw_t;

doesn't match the lines
ctrl_reg7_xl.dcf = ((uint8_t)val & 0x10U) >> 4;
ctrl_reg7_xl.hr = ((uint8_t)val & 0x03U);

in:
int32_t lsm9ds1_xl_filter_lp_bandwidth_set(lsm9ds1_ctx_t *ctx,
lsm9ds1_xl_lp_bw_t val)
{
lsm9ds1_ctrl_reg7_xl_t ctrl_reg7_xl;
int32_t ret;

ret = lsm9ds1_read_reg(ctx, LSM9DS1_CTRL_REG7_XL,
(uint8_t*)&ctrl_reg7_xl, 1);
if(ret == 0){
ctrl_reg7_xl.dcf = ((uint8_t)val & 0x10U) >> 4;
ctrl_reg7_xl.hr = ((uint8_t)val & 0x03U);
ret = lsm9ds1_write_reg(ctx, LSM9DS1_CTRL_REG7_XL,
(uint8_t*)&ctrl_reg7_xl, 1);
}
return ret;
}

because dcf has two bits, see:

#define LSM9DS1_CTRL_REG7_XL 0x21U
typedef struct {
uint8_t hpis1 : 1;
uint8_t not_used_01 : 1;
uint8_t fds : 1;
uint8_t not_used_02 : 2;
uint8_t dcf : 2;
uint8_t hr : 1;
} lsm9ds1_ctrl_reg7_xl_t;

So the right code must be

ctrl_reg7_xl.hr = ((uint8_t)val & 0x10U) >> 4;
ctrl_reg7_xl.dcf = ((uint8_t)val & 0x03U);

I tried renaming all lis3dh references to lis3de, but some structures and defines still seem to be different.

It appears that your functions
hts221_temp_deg_point_0_get, hts221_temp_deg_point_1_get

discard 3 bits of precision to make the result fit in a uin8_t. This makes absolutely no sense -- return a uint16_t and leave it to the user to divide by 8 or return a float.

When converting LSB to Celsius, +16 LSB/°C sensitivity must be considered as below.

float_t lsm6ds3_from_lsb_to_celsius(int16_t lsb)
{
  return ((float_t)lsb/16.0f + 25.0f );
}

Hi,
I am interested in using the LSM9DS1 as a component in a multi-sensor IMU run on an STM32. Are there any plans to add a C driver for this component, or would you be willing to take a pull request if I were to write one myself?
Thanks

Hi.
in lis2dtw12_reg.c file you are using very different Sensitivity. for example in lis2dtw12_from_fs8_lp1_to_mg function you are using 0.244 Sensitivity. according to the datasheet, it should be 0.976 or 1.952 according to the power mode.

thank you

IIS3DWB_XL_BATCHED_AT_6667Hz
undefined at:

CTRL_REG4 allows to set the range of the gyro.
This is not supported by the current driver.

the value i get is not stable, why? how to handle the case

File lsm303agr_STdC/driver/lsm303agr_reg.h contains some macros for converting the raw acceleration values depending on the mode and scale such as the following:
#define LSM303AGR_FROM_FS_2g_HR_TO_mg(lsb) (float)((int16_t)lsb>>4)* 1.0f
The drivers are supposed to be platform agnostic, however the shifting of signed numbers is implementation specific, as shown in the C99 standard, 6.5.7 Bitwise shift operators:

The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
or if E1 has a signed type and a nonnegative value, the value of the result is the integral
part of the quotient of E1 / 2E2. If E1 has a signed type and a negative value, the
resulting value is implementation-defined.

(The same applies for C89 and C11). Sure, in most platforms the right shifting of negative signed numbers will act with sign extension, but I think it is better to be safe by substituting the bitwise operation with arithmetic. I made a pull request fixing this, please see #5

According to the register address map in the documentation of the LPS22HB there are 3 x 8 bit registers for the measured pressure output value: -

PRESS_OUT_XL (0x28) (Pressure value bits 7 to 0)
PRESS_OUT_L (0x29) (Pressure value bits 15 to 8)
PRESS_OUT_H . (0x2A) (Pressure value bits 23 to 16)

The lps22hb_pressure_raw_get() function correctly reads the 3 consecutive addresses to retrieve the full data, however a subsequent call to lps22hb_from_lsb_to_hpa() (as per the example) only accepts a int16_t so the MSBs are lost in truncation.

The correct function should take a uint32_t or int32_t (and probably mask off the top 8 bits)

Hi,

The datasheet for IIS3DHHC doesn't mention any support for I2C. However, there are some references to I2C in example code.

From what I can see, most drivers that support I2C have a *_I2C_ADD_* address define in the corresponding header file, IIS3DHHC does not.

Is I2C supported with IIS3DHHC?

Function
float lis2dh12_from_fs2_hr_to_mg(int16_t lsb)
{
return ( (float)lsb / 16.0f ) * 1.0f;
}
is not implented right. According to datasheet page 16 where modes are described, the conversation for high res fs2 mode is 1 mg/digit, so the function doesnt have to do anything at all :) Check the other conversation functions as well, because I thing they are foo to :)

Hi

I've found an error in the LSM6DSL api. I tried to extend the DEN functionallity to the accelerometer with a call of lsm6dsl_den_enable_set function.

The following code snippet is from your api function, whereas val = 2 (LSM6DSL_STAMP_IN_GY_XL_DATA).
reg.ctrl4_c.den_xl_en = (uint8_t)val & 0x02U;

The problem is that "val & 0x02" will return 0x02 instead of 0x01 --> the bit won't get set. The code should be fixed with "val && 0x02U".

Kind regards

Hello,

The _resources/STMems_Finite_State_Machine @ 1c74d4e
is not on any branch of the FSM project. Maybe something has been force-pushed over commits

1c74d4e lsm6dsr: modified licence format
fb969ba lsm6dsox: modified licence format
2f2aba9 lsm6dso: modified licence format

maybe something else, but in any case it would be nice to point the submodule to some commit of the FSM master

I have MPU6050 accerlometer, i need to interface with stm32f0 (via I2C).

Firstly i am check if the sensor is responding by reading the

"WHO_AM_I (0x75)" Register.

If the sensor responds with 0x68, this means it’s available and good to go.

but the code is stuck in while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET){} ,

why this happens?

__inline static void stm32_I2cSetup(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure;
	I2C_InitTypeDef  I2C_InitStructure;
  
#if	_I2C1_ENABLE__
  /* Configure the I2C clock source. The clock is derived from the HSI */
  RCC_I2CCLKConfig(RCC_I2C1CLK_HSI);
    
  /* I2C_SCL_GPIO_CLK and I2C_SDA_GPIO_CLK Periph clock enable */
  RCC_AHBPeriphClockCmd(I2C1_SCL_GPIO_CLK | I2C1_SDA_GPIO_CLK, ENABLE);
  
  /* I2C Periph clock enable */
  RCC_APB1PeriphClockCmd(I2C1_CLK, ENABLE);
  
  /* Connect PXx to I2C_SCL*/
  GPIO_PinAFConfig(I2C1_SCL_GPIO_PORT, I2C1_SCL_SOURCE, I2C1_SCL_AF);
  
  /* Connect PXx to I2C_SDA*/
  GPIO_PinAFConfig(I2C1_SDA_GPIO_PORT, I2C1_SDA_SOURCE, I2C1_SDA_AF);
  
  /* GPIO configuration */  
  /* Configure I2C pins: SCL */
  GPIO_InitStructure.GPIO_Pin = I2C1_SCL_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(I2C1_SCL_GPIO_PORT, &GPIO_InitStructure);
  
  /* Configure I2C pins: SDA */
  GPIO_InitStructure.GPIO_Pin = I2C1_SDA_PIN;
  GPIO_Init(I2C1_SDA_GPIO_PORT, &GPIO_InitStructure);	
	
  /* I2C configuration */
  /* sEE_I2C configuration */
  I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  I2C_InitStructure.I2C_AnalogFilter = I2C_AnalogFilter_Enable;
  I2C_InitStructure.I2C_DigitalFilter = 0x00;
  I2C_InitStructure.I2C_OwnAddress1 = 0x00;
  I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
  I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  I2C_InitStructure.I2C_Timing = I2C1_TIMING;
  
  /* Apply sEE_I2C configuration after enabling it */
  I2C_Init(I2C1, &I2C_InitStructure);
   
  /* sEE_I2C Peripheral Enable */
  I2C_Cmd(I2C1, ENABLE);
  
//  /* Select the EEPROM address */
// SlaveAddr = 0x60;  
	Current_I2C	 = I2C1; 
#endif

#if _I2C2_ENABLE__

#endif
}

void reg_read(void)
{
uint32_t Data = 0;


 while(I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET){;;}

 I2C_TransferHandling(I2C1,0x68, 1, I2C_Reload_Mode,       I2C_Generate_Start_Write);  //I2C_SoftEnd_Mode


 while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET){}

 I2C_SendData(I2C1,0x75);
while(I2C_GetFlagStatus(I2C1, I2C_ISR_TC) == RESET){} 

 I2C_TransferHandling(I2C1, 0x68, 1,          I2C_AutoEnd_Mode,I2C_Generate_Start_Read);

 while(I2C_GetFlagStatus(I2C1, I2C_ISR_RXNE) == RESET) { }

Data= I2C_ReceiveData(I2C1);

while(I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET) {}

I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);

 memset(ucGBuff1,0,sizeof(ucGBuff1));
 sprintf((char *)ucGBuff1,"C:  %d",Data);

printk((char *)ucGBuff1);

  }

I believe that there are a couple typos in lsm6dsox_STdC/example/lsm6dsox_self_test.c, specifically during the gyro section of the self-test there are a couple of accelerometer functions called.

on line 281 lsm6dsox_xl_flag_data_ready_get(&dev_ctx, &drdy);
on line 306 lsm6dsox_xl_flag_data_ready_get(&dev_ctx, &drdy);
on line 335 lsm6dsox_xl_data_rate_set(&dev_ctx, LSM6DSOX_GY_ODR_OFF);

I had to change all of the "lsm6dsox_xl_..." to "lsm6dsox_gy_..." to get the test to complete successfully. Without these changes, the test loops forever waiting for a accelerometer data ready flag.

The lis2mdl driver contains a struct variable named 'xor' within the [lis2mdl_status_reg_t struct] (

The variable name should be changed such that it doesn't conflict. I will submit a PR to address this.

In lsm6dsox_fifo_sensor_tag_get missed case for timestamp:

    case LSM6DSOX_TIMESTAMP_TAG:
      *val = LSM6DSOX_TIMESTAMP_TAG;
      break;

Hi,

Why are the conversion factors used in functions lis2dw12_from_*_to_mg not the same as the ones in the LIS2DW12 datasheet (page 6, sensitivity values) ?

Thank you,
Greg

where is the function: lis3dh_temperature_meas_set(&dev_ctx, LIS3DH_TEMP_ENABLE); ,i cannot find it
who share me
thanks

where is the function: lis3dh_temperature_meas_set(&dev_ctx, LIS3DH_TEMP_ENABLE); ,i cannot find it
who share me
thanks

Hey There,
ive got a question related to sowtware Triggering the LIS2DW12 Sensor.

for (int i=0; i<0x3FF; i++);
lis2dw12_data_rate_set(&dev_ctx, LIS2DW12_XL_SET_SW_TRIG);

what purpose has the loop there? i dont get it ..
the code is taken from the lis2dw12_read_data_single example

I was reading through the datasheet page 30, table 20; I believe there is a fix needed for
https://github.com/STMicroelectronics/STMems_Standard_C_drivers/blob/master/lsm9ds1_STdC/driver/lsm9ds1_reg.h

on Line 127
/** I2C Device Address 8 bit format if SA0=0 -> 0x3D if SA0=1 -> 0x39 **/
#define LSM9DS1_MAG_I2C_ADD_L 0x3DU
#define LSM9DS1_MAG_I2C_ADD_H 0x39U

should be:
#define LSM9DS1_MAG_I2C_ADD_L 0x39U
#define LSM9DS1_MAG_I2C_ADD_H 0x3DU

Addresses are inverted

Hi,

The lis2dw12 driver sets the following enum values:

LIS2DW12_XL_SET_SW_TRIG        = 0x32,  /* Use this only in SINGLE mode */
LIS2DW12_XL_SET_PIN_TRIG       = 0x22,  /* Use this only in SINGLE mode */

Then in the C file, the CTRL3 register is written like this:

ctrl3.slp_mode = ( (uint8_t) val & 0x30U ) >> 4;
ret = lis2dw12_write_reg(ctx, LIS2DW12_CTRL3,(uint8_t*) &ctrl3, 1);

This will set the SLP_MODE_SEL bit1 of CTRL3 in both cases (SW and PIN trig). But the datasheet says it shall be 0 when enabled with external trigger on INT2.

This is a bug or did I miss something?

Also the driver will assign 0x02 for the ODR (CTRL1). Why?

Thank you,
Greg

I use your sensors in my board.
I want to use Unico to capture, process, display sensor data.
I may need to implement the communication protocol via serial port.
Do you have some document about how to do it?

By the way, I just need Unico to receive and handle data from MCU, I don't need it send command to MCU, do you have a more light weight solution?

What is the procedure to read data from iis328dq sensor
By datasheet format isn't responding
Simply sending to read WHO_I_AM register
0x8F is it ok or want to send another other form or want to add any other previous steps

Are the drivers on this repository MISRA C compliant?

I see there are some references to MISRA C compliance within some header files, but there is no statement related to that on the documents/resources.
How do the drivers relate to MISRA C on a general level?

I think this should be better specified somewhere.

Hi, I was looking at the code of for LSM6DS used as a sensor hub.

There must be a mistake in the example code line 195 or in the structure declaration lsm6ds3_sh_read_t : there is no .byte member in that structure.

I believe there is another mistake in the driver L5563 : the second read to registers should be LSM6DS3_SENSORHUB13_REG , I believe.

Best Regards

Alexandre Barsacq

lsm6dsox_reg.c

About FSM operation
Line 7839, 7865, 7964:

• @brief Final State Machine

FSM --> Finite State Machine

mm_error is overwritten by second operation. Needs an if statement.

`int32_t lsm6dsm_spi_mode_set(lsm6dsm_ctx_t *ctx, lsm6dsm_sim_t val)
{
lsm6dsm_reg_t reg;
int32_t mm_error;

mm_error = lsm6dsm_read_reg(ctx, LSM6DSM_CTRL3_C, &reg.byte, 1);
reg.ctrl3_c.sim = val;
mm_error = lsm6dsm_write_reg(ctx, LSM6DSM_CTRL3_C, &reg.byte, 1);

return mm_error;
}
`

Description

When integrating LIS2DH12 driver to my project, I have to define platform read function as

int32_t spi_stm_platform_read(void* dev_id, uint8_t reg_addr, uint8_t *data,
                              uint16_t len)
{
  uint8_t ss = *(uint8_t*)dev_id;
  // bit 0: READ bit. The value is 1.
  // bit 1: MS bit. When 0, does not increment the address; when 1, increments the address in
  // multiple reads.
  uint8_t read_cmd = reg_addr | 0x80;
  if(len > 1) { read_cmd |= 0x40; }
  return spi_platform_read(ss, read_cmd, data, len);
}

because the driver does not set appropriate bit flags when reading registers.

Proposed fix:

Implement int32_t lis2dh12_read_reg as

int32_t lis2dh12_read_reg(lis2dh12_ctx_t* ctx, uint8_t reg, uint8_t* data,
                          uint16_t len)
{
  uint8_t read_cmd = reg | 0x80;
  if(len > 1) { read_cmd |= 0x40; }
  return ctx->read_reg(ctx->handle, read_cmd, data, len);
}

Action

Would you accept pull request for the change if I opened one?
I'm fine with assigning copyrights of contribution to you under any MIT-compatible license in case your legal department asks :)

In the function "int32_t h3lis100dl_acceleration_raw_get(stmdev_ctx_t *ctx, uint8_t *buff)",
the buff pointer should be incremented after each read, otherwise all of the data is loaded into the first buffer location.

Do the app using on LSM6DSO can be used on LSM6DSOX without any change?

To communicate with Unico, I try to implement commands on my own board as your ducument.
I met a strange thing, which may not be mentioned in the doucument.
Once I click conncet on Unico, Unico send "0x00 0x80" continously.

How should I respond to this?
I thought it should send "*setdbXXXVY" at first.
Do I miss anything?

Hello,

I'm trying the wake-up example of the LIS2DW12. It's working except that the accelerometer generates a pulse on the INT1 pin ~1ms after the setup (i.e. after enabling the wake-up in CTRL4).
It's systematic, even if the accelerometer is motionless. The pulse duration is 5ms.
If I add some delay, few milliseconds, before configuring CTRL4, then the pulse disappear. But it's something I'd like to avoid, I would prefer to understand why the chip generates the pulse after enabling the wake-up feature. This pulse is a wrong information coming from the LIS2DW12.

Capture:

Thank you.

(

Hello,
I have performed a simple formal verification using TrustInSoft CI on the ais2dw12 driver.
The results are available at https://ci.trust-in-soft.com/projects/monate/STMems_Standard_C_drivers/6?page=1&test=3
The analysis is performed on a fork of this repository that contains one additional commit to configure TrustInSoft CI.
The analyzer identifies a buffer overflow that comes from this type definition:

Feel free to retrieve the commits in my fork and/or to get in touch with me if you are interested in deploying TrustInSoft CI on your repository for this or other drivers.

See: https://community.st.com/s/question/0D50X0000B6QVmzSQG/lis3dh-error-in-cdrivermems

The LIS3DH Temperature Sensor is connected to ADC3

But lis3dh_temperature_raw_get() reads ADC1:

 /**
  * @brief  Temperature output value.[get]
  *
  * @param  ctx      read / write interface definitions
  * @param  buff     buffer that stores data read
  * @retval          interface status (MANDATORY: return 0 -> no Error)
  *
  */
int32_t lis3dh_temperature_raw_get(lis3dh_ctx_t *ctx, uint8_t *buff)
{
  int32_t ret;
  ret = lis3dh_read_reg(ctx, LIS3DH_OUT_ADC1_H, buff, 1);   // <<<<< HERE !!
  return ret;
} 

And why is it only reading the High byte?

When will there be published example code for the iis3dwb? I'm a developer working on that accelerometer, but i'm having trouble configuring the wake-up interrupt.

Hello, I am having some issues connecting an Arduino to a ISM330DLC(connected through a STEVAL-MKI182V2) using these drivers. When running the driver the device id is always 255. This is my current code:

static int32_t platform_write(void *handle, uint8_t Reg, uint8_t *Bufp, uint16_t len) { 
  SPI.beginTransaction(SPISettings(14000000, MSBFIRST, SPI_MODE3));
  digitalWrite(SSpin, LOW);
  SPI.transfer(Reg);
  SPI.transfer(Bufp);
  digitalWrite(SSpin, HIGH);
  SPI.endTransaction();
  return 0;
}
static int32_t platform_read(void *handle, uint8_t Reg, uint8_t *Bufp, uint16_t len) {
  Reg |= 0x80; //Set bit 0 (MSB) in order to read
  SPI.beginTransaction(SPISettings(14000000, MSBFIRST, SPI_MODE3));
  digitalWrite(SSpin, LOW);
  SPI.transfer(Reg);
  *Bufp = SPI.transfer(0x00); //Dummy send to get value from module
  digitalWrite(SSpin, HIGH);
  SPI.endTransaction();
  return 0;
}
void setup() {
  delay(100);
  Serial.begin(9600);
  pinMode(SSpin, OUTPUT);
  digitalWrite(SSpin, HIGH);

  /* Initialize SPI */
  SPI.begin();
  ....
  ....

Does anyone know what might be wrong?

Hi,

The function used for polling reset completion should use the | operator to combine the reset flags. In its present form, the *val value will be zero even if one of the sensors is still under reset. This does not appear to be the desired function behaviour based on the example usage.

Hello,

I tried to use lsm6dsox_data_get() function in lsm6dsox_reg.c

I noticed that aux_ctx is used instead of ctx to read data in register

Then later in code, register is read in a sense : temperature, accelerometer and gyroscope [Link].
However, in the datasheet, the order of register is temperature, gyroscope and accelerometer [Link].

Inverting angular conversion with acceleration conversion seems to solve this problem.

I don't use ois chain, I suspect similar issue for it:

Conversion of accelerometer comes before gyroscope [Link]. It is inversed in datasheet [Link].

Then, the read of register should starts with gyroscope instead of accelerometer here:

Hi,
I'm working on a project which requires LSM9DS1 to be integrated. I saw in one of the older closed issues indicating there will be a driver releasing soon (august 16th). The issue was closed although I could not find a driver in your repo. Could you please redirect me to any Beta version for now? or may be let me know when it would be made available?

Best Regards,
Sathya

It appears that there is a correction needed for the LSM9DS1 selftest example at Line 129
https://github.com/STMicroelectronics/STMems_Standard_C_drivers/blob/master/lsm9ds1_STdC/example/lsm9ds1_self_test.c

Current:
static sensbus_t imu_bus = {&SENSOR_BUS, LSM9DS1_MAG_I2C_ADD_L, 0, 0};
static sensbus_t mag_bus = {&SENSOR_BUS, LSM9DS1_IMU_I2C_ADD_H 0, 0};

I believe should be:
static sensbus_t imu_bus = {&SENSOR_BUS, LSM9DS1_IMU_I2C_ADD_H, 0, 0};
static sensbus_t mag_bus = {&SENSOR_BUS, LSM9DS1_MAG_I2C_ADD_L, 0, 0};

MAG_I2C_ADD and IMU_I2C_ADD are inverted