/**
* Gets the offsets currently set
*
* @param The sensor interface
* @param Pointer to location to store X offset
* @param Pointer to location to store Y offset
* @param Pointer to location to store Z offset
*
* @return 0 on success, non-zero error on failure.
*/
int
lis2dw12_get_offsets(struct sensor_itf *itf, int8_t *offset_x,
int8_t *offset_y, int8_t *offset_z, uint8_t *weight)
{
uint8_t reg;
int rc;
rc = lis2dw12_read8(itf, LIS2DW12_REG_X_OFS, (uint8_t *)offset_x);
if (rc) {
return rc;
}
rc = lis2dw12_read8(itf, LIS2DW12_REG_Y_OFS, (uint8_t *)offset_y);
if (rc) {
return rc;
}
rc = lis2dw12_read8(itf, LIS2DW12_REG_Z_OFS, (uint8_t *)offset_z);
if (rc) {
return rc;
}
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG7, ®);
if (rc) {
return rc;
}
*weight = reg & LIS2DW12_CTRL_REG7_USR_OFF_W ? 1 : 0;
return 0;
}
/**
* Set filter config
*
* @param the sensor interface
* @param the filter bandwidth
* @param filter type (1 = high pass, 0 = low pass)
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_set_filter_cfg(struct sensor_itf *itf, uint8_t bw, uint8_t type)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG6, ®);
if (rc) {
goto err;
}
reg &= ~LIS2DW12_CTRL_REG6_BW_FILT;
reg &= ~LIS2DW12_CTRL_REG6_FDS;
reg |= (bw & LIS2DW12_CTRL_REG6_BW_FILT);
if (type) {
reg |= LIS2DW12_CTRL_REG6_FDS;
}
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG6, reg);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
/**
* Sets the low noise enable
*
* @param The sensor interface
* @param low noise enabled
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_set_low_noise(struct sensor_itf *itf, uint8_t en)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG6, ®);
if (rc) {
goto err;
}
if (en) {
reg |= LIS2DW12_CTRL_REG6_LOW_NOISE;
} else {
reg &= ~LIS2DW12_CTRL_REG6_LOW_NOISE;
}
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG6, reg);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
/**
* Sets the rate
*
* @param The sensor interface
* @param The rate
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_set_rate(struct sensor_itf *itf, uint8_t rate)
{
int rc;
uint8_t reg;
if (rate > LIS2DW12_DATA_RATE_1600HZ) {
LIS2DW12_ERR("Invalid rate value\n");
rc = SYS_EINVAL;
goto err;
}
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG1, ®);
if (rc) {
goto err;
}
reg = (reg & ~LIS2DW12_CTRL_REG1_ODR) | rate;
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG1, reg);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
/**
* Sets the full scale selection
*
* @param The sensor interface
* @param The fs setting
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_set_full_scale(struct sensor_itf *itf, uint8_t fs)
{
int rc;
uint8_t reg;
if (fs > LIS2DW12_FS_16G) {
LIS2DW12_ERR("Invalid full scale value\n");
rc = SYS_EINVAL;
goto err;
}
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG6, ®);
if (rc) {
goto err;
}
reg = (reg & ~LIS2DW12_CTRL_REG6_FS) | fs;
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG6, reg);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
/**
* Sets new offsets in sensor
*
* @param The sensor interface
* @param X offset
* @param Y offset
* @param Z offset
*
* @return 0 on success, non-zero error on failure.
*/
int
lis2dw12_set_offsets(struct sensor_itf *itf, int8_t offset_x,
int8_t offset_y, int8_t offset_z, uint8_t weight)
{
uint8_t reg;
int rc;
rc = lis2dw12_write8(itf, LIS2DW12_REG_X_OFS, offset_x);
if (rc) {
return rc;
}
rc = lis2dw12_write8(itf, LIS2DW12_REG_Y_OFS, offset_y);
if (rc) {
return rc;
}
rc = lis2dw12_write8(itf, LIS2DW12_REG_Z_OFS, offset_z);
if (rc) {
return rc;
}
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG7, ®);
if (rc) {
return rc;
}
if (weight) {
reg |= LIS2DW12_CTRL_REG7_USR_OFF_W;
} else {
reg &= ~LIS2DW12_CTRL_REG7_USR_OFF_W;
}
return lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG7, reg);
}
static int
lis2dw12_shell_cmd_peek(int argc, char **argv)
{
int rc;
uint8_t value;
uint8_t reg;
if (argc > 3) {
return lis2dw12_shell_err_too_many_args(argv[1]);
} else if (argc < 3) {
return lis2dw12_shell_err_too_few_args(argv[1]);
}
reg = parse_ll_bounds(argv[2], LIS2DW12_CLI_FIRST_REGISTER, LIS2DW12_CLI_LAST_REGISTER, &rc);
if (rc != 0) {
return lis2dw12_shell_err_invalid_arg(argv[2]);
}
rc = lis2dw12_read8(&g_sensor_itf, reg, &value);
if (rc) {
console_printf("peek failed %d\n", rc);
}else{
console_printf("reg 0x%02X(%d) = 0x%02X\n", reg, reg, value);
}
return 0;
}
/**
* Get tap detection config
*
* @param the sensor interface
* @param ptr to the tap settings
* @return 0 on success, non-zero on failure
*/
int lis2dw12_get_tap_cfg(struct sensor_itf *itf, struct lis2dw12_tap_settings *cfg)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_TAP_THS_X, ®);
if (rc) {
return rc;
}
cfg->en_4d = (reg & LIS2DW12_TAP_THS_X_4D_EN) > 0;
cfg->ths_6d = (reg & LIS2DW12_TAP_THS_X_6D_THS) >> 5;
cfg->tap_ths_x = reg & LIS2DW12_TAP_THS_X_THS;
rc = lis2dw12_read8(itf, LIS2DW12_REG_TAP_THS_Y, ®);
if (rc) {
return rc;
}
cfg->tap_priority = (reg & LIS2DW12_TAP_THS_Y_PRIOR) >> 5;
cfg->tap_ths_y = reg & LIS2DW12_TAP_THS_Y_THS;
rc = lis2dw12_read8(itf, LIS2DW12_REG_TAP_THS_Z, ®);
if (rc) {
return rc;
}
cfg->en_x = (reg & LIS2DW12_TAP_THS_Z_X_EN) > 0;
cfg->en_y = (reg & LIS2DW12_TAP_THS_Z_Y_EN) > 0;
cfg->en_z = (reg & LIS2DW12_TAP_THS_Z_Z_EN) > 0;
cfg->tap_ths_z = reg & LIS2DW12_TAP_THS_Z_THS;
rc = lis2dw12_read8(itf, LIS2DW12_REG_INT_DUR, ®);
if (rc) {
return rc;
}
cfg->latency = (reg & LIS2DW12_INT_DUR_LATENCY) >> 4;
cfg->quiet = (reg & LIS2DW12_INT_DUR_QUIET) >> 2;
cfg->shock = reg & LIS2DW12_INT_DUR_SHOCK;
return 0;
}
/**
* Get Number of Samples in FIFO
*
* @param the sensor interface
* @patam Pointer to return number of samples in
* @return 0 on success, non-zero on failure
*/
int lis2dw12_get_fifo_samples(struct sensor_itf *itf, uint8_t *samples)
{
uint8_t reg;
int rc;
rc = lis2dw12_read8(itf, LIS2DW12_REG_FIFO_SAMPLES, ®);
if (rc) {
return rc;
}
*samples = reg & LIS2DW12_FIFO_SAMPLES;
return 0;
}
/**
* Get freefall detection config
*
* @param the sensor interface
* @param ptr to freefall duration
* @param ptr to freefall threshold
* @return 0 on success, non-zero on failure
*/
int lis2dw12_get_freefall(struct sensor_itf *itf, uint8_t *dur, uint8_t *ths)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_FREEFALL, ®);
if (rc) {
return rc;
}
*dur = (reg & LIS2DW12_FREEFALL_DUR) >> 3;
*ths = reg & LIS2DW12_FREEFALL_THS;
return 0;
}
/**
* Gets the power mode of the sensor
*
* @param The sensor interface
* @param ptr to power mode setting read from sensor
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_get_power_mode(struct sensor_itf *itf, uint8_t *mode)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG1, ®);
if (rc) {
goto err;
}
*mode = reg & (LIS2DW12_CTRL_REG1_MODE | LIS2DW12_CTRL_REG1_LP_MODE);
return 0;
err:
return rc;
}
/**
* Gets whether low noise is enabled
*
* @param The sensor interface
* @param ptr to low noise settings read from sensor
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_get_low_noise(struct sensor_itf *itf, uint8_t *en)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG6, ®);
if (rc) {
goto err;
}
*en = (reg & LIS2DW12_CTRL_REG6_LOW_NOISE) > 0;
return 0;
err:
return rc;
}
/**
* Gets the rate
*
* @param The sensor ineterface
* @param ptr to the rate
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_get_rate(struct sensor_itf *itf, uint8_t *rate)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG1, ®);
if (rc) {
goto err;
}
*rate = reg & LIS2DW12_CTRL_REG1_ODR;
return 0;
err:
return rc;
}
/**
* Gets the full scale selection
*
* @param The sensor interface
* @param ptr to fs
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_get_full_scale(struct sensor_itf *itf, uint8_t *fs)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG6, ®);
if (rc) {
goto err;
}
*fs = reg & LIS2DW12_CTRL_REG6_FS;
return 0;
err:
return rc;
}
/**
* Get chip ID
*
* @param sensor interface
* @param ptr to chip id to be filled up
*/
int
lis2dw12_get_chip_id(struct sensor_itf *itf, uint8_t *chip_id)
{
uint8_t reg;
int rc;
rc = lis2dw12_read8(itf, LIS2DW12_REG_WHO_AM_I, ®);
if (rc) {
goto err;
}
*chip_id = reg;
err:
return rc;
}
/**
* Gets the self test mode of the sensor
*
* @param The sensor interface
* @param ptr to self test mode read from sensor
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_get_self_test(struct sensor_itf *itf, uint8_t *mode)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG3, ®);
if (rc) {
goto err;
}
*mode = reg & LIS2DW12_CTRL_REG3_ST_MODE;
return 0;
err:
return rc;
}
static int
lis2dw12_shell_cmd_read_chipid(int argc, char **argv)
{
int rc;
uint8_t chipid;
rc = lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_WHO_AM_I, &chipid);
if (rc) {
goto err;
}
console_printf("CHIP_ID:0x%02X\n", chipid);
return 0;
err:
return rc;
}
/**
* Sets whether offset are enabled (only work when low pass filtering is enabled)
*
* @param The sensor interface
* @param value to set (0 = disabled, 1 = enabled)
*
* @return 0 on success, non-zero error on failure.
*/
int lis2dw12_set_offset_enable(struct sensor_itf *itf, uint8_t enabled)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG7, ®);
if (rc) {
return rc;
}
if (enabled) {
reg |= LIS2DW12_CTRL_REG7_USR_OFF_OUT;
} else {
reg &= ~LIS2DW12_CTRL_REG7_USR_OFF_OUT;
}
return lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG7, reg);
}
/**
* Set whether interrupts are enabled
*
* @param the sensor interface
* @param value to set (0 = disabled, 1 = enabled)
* @return 0 on success, non-zero on failure
*/
int lis2dw12_set_int_enable(struct sensor_itf *itf, uint8_t enabled)
{
uint8_t reg;
int rc;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG7, ®);
if (rc) {
return rc;
}
if (enabled) {
reg |= LIS2DW12_CTRL_REG7_INT_EN;
} else {
reg &= ~LIS2DW12_CTRL_REG7_INT_EN;
}
return lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG7, reg);
}
/**
* Get filter config
*
* @param the sensor interface
* @param ptr to the filter bandwidth
* @param ptr to filter type (1 = high pass, 0 = low pass)
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_get_filter_cfg(struct sensor_itf *itf, uint8_t *bw, uint8_t *type)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG6, ®);
if (rc) {
goto err;
}
*bw = reg & LIS2DW12_CTRL_REG6_BW_FILT;
*type = (reg & LIS2DW12_CTRL_REG6_FDS) > 0;
return 0;
err:
return rc;
}
/**
* Reset lis2dw12
*
* @param The sensor interface
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_reset(struct sensor_itf *itf)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG2, ®);
if (rc) {
goto err;
}
reg |= LIS2DW12_CTRL_REG2_SOFT_RESET | LIS2DW12_CTRL_REG2_BOOT;
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG2, reg);
if (rc) {
goto err;
}
os_time_delay((OS_TICKS_PER_SEC * 6/1000) + 1);
err:
return rc;
}
/**
* Sets the self test mode of the sensor
*
* @param The sensor interface
* @param self test mode
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_set_self_test(struct sensor_itf *itf, uint8_t mode)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG3, ®);
if (rc) {
goto err;
}
reg &= ~LIS2DW12_CTRL_REG3_ST_MODE;
reg |= (mode & LIS2DW12_CTRL_REG3_ST_MODE);
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG3, reg);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
/**
* Sets the power mode of the sensor
*
* @param The sensor interface
* @param power mode
*
* @return 0 on success, non-zero on failure
*/
int
lis2dw12_set_power_mode(struct sensor_itf *itf, uint8_t mode)
{
int rc;
uint8_t reg;
rc = lis2dw12_read8(itf, LIS2DW12_REG_CTRL_REG1, ®);
if (rc) {
goto err;
}
reg &= ~LIS2DW12_CTRL_REG1_MODE;
reg &= ~LIS2DW12_CTRL_REG1_LP_MODE;
reg |= mode;
rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG1, reg);
if (rc) {
goto err;
}
return 0;
err:
return rc;
}
/**
* Clear interrupt 1
*
* @param the sensor interface
*/
int
lis2dw12_clear_int(struct sensor_itf *itf, uint8_t *src)
{
return lis2dw12_read8(itf, LIS2DW12_REG_INT_SRC, src);
}
static int
lis2dw12_shell_cmd_dump(int argc, char **argv)
{
uint8_t val;
if (argc > 2) {
return lis2dw12_shell_err_too_many_args(argv[1]);
}
/* Dump all the register values for debug purposes */
val = 0;
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_TEMP_L, &val));
console_printf("0x%02X (OUT_TEMP_L): 0x%02X\n", LIS2DW12_REG_OUT_TEMP_L, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_TEMP_H, &val));
console_printf("0x%02X (OUT_TEMP_H): 0x%02X\n", LIS2DW12_REG_OUT_TEMP_H, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_WHO_AM_I, &val));
console_printf("0x%02X (WHO_AM_I): 0x%02X\n", LIS2DW12_REG_WHO_AM_I, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG1, &val));
console_printf("0x%02X (CTRL1): 0x%02X\n", LIS2DW12_REG_CTRL_REG1, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG2, &val));
console_printf("0x%02X (CTRL2): 0x%02X\n", LIS2DW12_REG_CTRL_REG2, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG3, &val));
console_printf("0x%02X (CTRL3): 0x%02X\n", LIS2DW12_REG_CTRL_REG3, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG4, &val));
console_printf("0x%02X (CTRL4): 0x%02X\n", LIS2DW12_REG_CTRL_REG4, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG5, &val));
console_printf("0x%02X (CTRL5): 0x%02X\n", LIS2DW12_REG_CTRL_REG5, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG6, &val));
console_printf("0x%02X (CTRL6): 0x%02X\n", LIS2DW12_REG_CTRL_REG6, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TEMP_OUT, &val));
console_printf("0x%02X (TEMP_OUT): 0x%02X\n", LIS2DW12_REG_TEMP_OUT, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_STATUS_REG, &val));
console_printf("0x%02X (STATUS): 0x%02X\n", LIS2DW12_REG_STATUS_REG, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_X_L, &val));
console_printf("0x%02X (OUT_X_L): 0x%02X\n", LIS2DW12_REG_OUT_X_L, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_X_H, &val));
console_printf("0x%02X (OUT_X_H): 0x%02X\n", LIS2DW12_REG_OUT_X_H, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Y_L, &val));
console_printf("0x%02X (OUT_Y_L): 0x%02X\n", LIS2DW12_REG_OUT_Y_L, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Y_H, &val));
console_printf("0x%02X (OUT_Y_H): 0x%02X\n", LIS2DW12_REG_OUT_Y_H, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Z_L, &val));
console_printf("0x%02X (OUT_Z_L): 0x%02X\n", LIS2DW12_REG_OUT_Z_L, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Z_H, &val));
console_printf("0x%02X (OUT_Z_H): 0x%02X\n", LIS2DW12_REG_OUT_Z_H, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_FIFO_CTRL, &val));
console_printf("0x%02X (FIFO_CTRL): 0x%02X\n", LIS2DW12_REG_FIFO_CTRL, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_FIFO_SAMPLES, &val));
console_printf("0x%02X (FIFO_SAMPLES): 0x%02X\n", LIS2DW12_REG_FIFO_SAMPLES, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TAP_THS_X, &val));
console_printf("0x%02X (TAP_THS_X): 0x%02X\n", LIS2DW12_REG_TAP_THS_X, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TAP_THS_Y, &val));
console_printf("0x%02X (TAP_THS_Y): 0x%02X\n", LIS2DW12_REG_TAP_THS_Y, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TAP_THS_Z, &val));
console_printf("0x%02X (TAP_THS_Z): 0x%02X\n", LIS2DW12_REG_TAP_THS_Z, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_INT_DUR, &val));
console_printf("0x%02X (INT_DUR): 0x%02X\n", LIS2DW12_REG_INT_DUR, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_FREEFALL, &val));
console_printf("0x%02X (FREEFALL): 0x%02X\n", LIS2DW12_REG_FREEFALL, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_INT_SRC, &val));
console_printf("0x%02X (INT_SRC): 0x%02X\n", LIS2DW12_REG_INT_SRC, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_X_OFS, &val));
console_printf("0x%02X (X_OFS): 0x%02X\n", LIS2DW12_REG_X_OFS, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_Y_OFS, &val));
console_printf("0x%02X (Y_OFS): 0x%02X\n", LIS2DW12_REG_Y_OFS, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_Z_OFS, &val));
console_printf("0x%02X (Z_OFS): 0x%02X\n", LIS2DW12_REG_Z_OFS, val);
assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG7, &val));
console_printf("0x%02X (CTRL7): 0x%02X\n", LIS2DW12_REG_CTRL_REG7, val);
return 0;
}
/**
* Get Interrupt Source
*
* @param the sensor interface
* @param pointer to return interrupt source in
* @return 0 on success, non-zero on failure
*/
int lis2dw12_get_int_src(struct sensor_itf *itf, uint8_t *status)
{
return lis2dw12_read8(itf, LIS2DW12_REG_STATUS_REG, status);
}
