diff --git a/os/ex/ST/l3gd20.c b/os/ex/ST/l3gd20.c index 3396c93e6..c3093d40c 100644 --- a/os/ex/ST/l3gd20.c +++ b/os/ex/ST/l3gd20.c @@ -1,5 +1,5 @@ /* - ChibiOS - Copyright (C) 2016 Rocco Marco Guglielmi + ChibiOS - Copyright (C) 2016-2018 Rocco Marco Guglielmi This file is part of ChibiOS. @@ -86,165 +86,310 @@ static void l3gd20SPIWriteRegister(SPIDriver *spip, uint8_t reg, size_t n, } #endif /* L3GD20_USE_SPI */ -/* - * Interface implementation. +/** + * @brief Return the number of axes of the BaseGyroscope. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * + * @return the number of axes. */ -static size_t get_axes_number(void *ip) { - - osalDbgCheck(ip != NULL); - return L3GD20_NUMBER_OF_AXES; +static size_t gyro_get_axes_number(void *ip) { + (void)ip; + + return L3GD20_GYRO_NUMBER_OF_AXES; } - -static msg_t read_raw(void *ip, int32_t axes[L3GD20_NUMBER_OF_AXES]) { + +/** + * @brief Retrieves raw data from the BaseGyroscope. + * @note This data is retrieved from MEMS register without any algebraical + * manipulation. + * @note The axes array must be at least the same size of the + * BaseGyroscope axes number. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * @param[out] axes a buffer which would be filled with raw data. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + */ +static msg_t gyro_read_raw(void *ip, int32_t axes[L3GD20_GYRO_NUMBER_OF_AXES]) { + L3GD20Driver* devp; int16_t tmp; - uint8_t i, buff [2 * L3GD20_NUMBER_OF_AXES]; + uint8_t i, buff [2 * L3GD20_GYRO_NUMBER_OF_AXES]; msg_t msg = MSG_OK; - osalDbgCheck((ip != NULL) && (axes != NULL)); - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY), - "read_raw(), invalid state"); - + osalDbgCheck((ip != NULL) && (axes != NULL)); + + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state == L3GD20_READY), + "gyro_read_raw(), invalid state"); #if L3GD20_USE_SPI - osalDbgAssert((((L3GD20Driver *)ip)->config->spip->state == SPI_READY), - "read_raw(), channel not ready"); + osalDbgAssert((devp->config->spip->state == SPI_READY), + "gyro_read_raw(), channel not ready"); #if L3GD20_SHARED_SPI - spiAcquireBus(((L3GD20Driver *)ip)->config->spip); - spiStart(((L3GD20Driver *)ip)->config->spip, - ((L3GD20Driver *)ip)->config->spicfg); + spiAcquireBus(devp->config->spip); + spiStart(devp->config->spip, + devp->config->spicfg); #endif /* L3GD20_SHARED_SPI */ - l3gd20SPIReadRegister(((L3GD20Driver *)ip)->config->spip, L3GD20_AD_OUT_X_L, - L3GD20_NUMBER_OF_AXES * 2, buff); + l3gd20SPIReadRegister(devp->config->spip, L3GD20_AD_OUT_X_L, + L3GD20_GYRO_NUMBER_OF_AXES * 2, buff); #if L3GD20_SHARED_SPI - spiReleaseBus(((L3GD20Driver *)ip)->config->spip); + spiReleaseBus(devp->config->spip); #endif /* L3GD20_SHARED_SPI */ #endif /* L3GD20_USE_SPI */ - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - tmp = buff[2*i] + (buff[2*i+1] << 8); + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + tmp = buff[2 * i] + (buff[2 * i + 1] << 8); axes[i] = (int32_t)tmp; } return msg; } - -static msg_t read_cooked(void *ip, float axes[]) { + +/** + * @brief Retrieves cooked data from the BaseGyroscope. + * @note This data is manipulated according to the formula + * cooked = (raw * sensitivity) - bias. + * @note Final data is expressed as DPS. + * @note The axes array must be at least the same size of the + * BaseGyroscope axes number. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * @param[out] axes a buffer which would be filled with cooked data. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + */ +static msg_t gyro_read_cooked(void *ip, float axes[]) { + L3GD20Driver* devp; uint32_t i; - int32_t raw[L3GD20_NUMBER_OF_AXES]; + int32_t raw[L3GD20_GYRO_NUMBER_OF_AXES]; msg_t msg; osalDbgCheck((ip != NULL) && (axes != NULL)); + + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state == L3GD20_READY), + "gyro_read_cooked(), invalid state"); +#if L3GD20_USE_SPI + osalDbgAssert((devp->config->spip->state == SPI_READY), + "gyro_read_cooked(), channel not ready"); +#endif - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY), - "read_cooked(), invalid state"); - - msg = read_raw(ip, raw); - for(i = 0; i < L3GD20_NUMBER_OF_AXES ; i++){ - axes[i] = raw[i] * ((L3GD20Driver *)ip)->sensitivity[i]; - axes[i] -= ((L3GD20Driver *)ip)->bias[i]; + msg = gyro_read_raw(ip, raw); + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++){ + axes[i] = raw[i] * devp->gyrosensitivity[i]; + axes[i] -= devp->gyrobias[i]; } return msg; } - -static msg_t sample_bias(void *ip) { + +/** + * @brief Samples bias values for the BaseGyroscope. + * @note The L3GD20 shall not be moved during the whole procedure. + * @note After this function internal bias is automatically updated. + * @note The behavior of this function depends on @P L3GD20_BIAS_ACQ_TIMES + * and @p L3GD20_BIAS_SETTLING_US. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + */ +static msg_t gyro_sample_bias(void *ip) { + L3GD20Driver* devp; uint32_t i, j; - int32_t raw[L3GD20_NUMBER_OF_AXES]; - int32_t buff[L3GD20_NUMBER_OF_AXES] = {0, 0, 0}; + int32_t raw[L3GD20_GYRO_NUMBER_OF_AXES]; + int32_t buff[L3GD20_GYRO_NUMBER_OF_AXES] = {0, 0, 0}; msg_t msg; osalDbgCheck(ip != NULL); - - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY), - "sample_bias(), invalid state"); + + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state == L3GD20_READY), + "gyro_sample_bias(), invalid state"); +#if L3GD20_USE_SPI + osalDbgAssert((devp->config->spip->state == SPI_READY), + "gyro_sample_bias(), channel not ready"); +#endif for(i = 0; i < L3GD20_BIAS_ACQ_TIMES; i++){ - msg = read_raw(ip, raw); + msg = gyro_read_raw(ip, raw); if(msg != MSG_OK) return msg; - for(j = 0; j < L3GD20_NUMBER_OF_AXES; j++){ + for(j = 0; j < L3GD20_GYRO_NUMBER_OF_AXES; j++){ buff[j] += raw[j]; } - osalThreadSleepMicroseconds(L3GD20_BIAS_SETTLING_uS); + osalThreadSleepMicroseconds(L3GD20_BIAS_SETTLING_US); } - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++){ - ((L3GD20Driver *)ip)->bias[i] = (buff[i] / L3GD20_BIAS_ACQ_TIMES); - ((L3GD20Driver *)ip)->bias[i] *= ((L3GD20Driver *)ip)->sensitivity[i]; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++){ + devp->gyrobias[i] = (buff[i] / L3GD20_BIAS_ACQ_TIMES); + devp->gyrobias[i] *= devp->gyrosensitivity[i]; } return msg; } - -static msg_t set_bias(void *ip, float *bp) { + +/** + * @brief Set bias values for the BaseGyroscope. + * @note Bias must be expressed as DPS. + * @note The bias buffer must be at least the same size of the BaseGyroscope + * axes number. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * @param[in] bp a buffer which contains biases. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + */ +static msg_t gyro_set_bias(void *ip, float *bp) { + L3GD20Driver* devp; uint32_t i; - osalDbgCheck((ip != NULL) && (bp !=NULL)); - - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY) || - (((L3GD20Driver *)ip)->state == L3GD20_STOP), - "set_bias(), invalid state"); + osalDbgCheck((ip != NULL) && (bp != NULL)); - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - ((L3GD20Driver *)ip)->bias[i] = bp[i]; + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state != L3GD20_UNINIT), + "gyro_set_bias(), invalid state"); + + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + devp->gyrobias[i] = bp[i]; } return MSG_OK; } - -static msg_t reset_bias(void *ip) { + +/** + * @brief Reset bias values for the BaseGyroscope. + * @note Default biases value are obtained from device datasheet when + * available otherwise they are considered zero. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + */ +static msg_t gyro_reset_bias(void *ip) { + L3GD20Driver* devp; uint32_t i; - osalDbgCheck(ip != NULL); + osalDbgCheck(ip != NULL); + + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state != L3GD20_UNINIT), + "gyro_reset_bias(), invalid state"); - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY) || - (((L3GD20Driver *)ip)->state == L3GD20_STOP), - "reset_bias(), invalid state"); - - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) - ((L3GD20Driver *)ip)->bias[i] = 0; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) + devp->gyrobias[i] = 0.0; return MSG_OK; } - -static msg_t set_sensivity(void *ip, float *sp) { + +/** + * @brief Set sensitivity values for the BaseGyroscope. + * @note Sensitivity must be expressed as DPS/LSB. + * @note The sensitivity buffer must be at least the same size of the + * BaseGyroscope axes number. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * @param[in] sp a buffer which contains sensitivities. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + */ +static msg_t gyro_set_sensivity(void *ip, float *sp) { + L3GD20Driver* devp; uint32_t i; osalDbgCheck((ip != NULL) && (sp !=NULL)); - - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY), - "set_sensivity(), invalid state"); + + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state != L3GD20_UNINIT), + "gyro_set_sensivity(), invalid state"); - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - ((L3GD20Driver *)ip)->sensitivity[i] = sp[i]; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + devp->gyrosensitivity[i] = sp[i]; } return MSG_OK; } - -static msg_t reset_sensivity(void *ip) { + +/** + * @brief Reset sensitivity values for the BaseGyroscope. + * @note Default sensitivities value are obtained from device datasheet. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * @retval MSG_RESET otherwise. + */ +static msg_t gyro_reset_sensivity(void *ip) { + L3GD20Driver* devp; uint32_t i; - + msg_t msg = MSG_OK; + osalDbgCheck(ip != NULL); - osalDbgAssert((((L3GD20Driver *)ip)->state == L3GD20_READY), - "reset_sensivity(), invalid state"); + /* Getting parent instance pointer.*/ + devp = objGetInstance(L3GD20Driver*, (BaseGyroscope*)ip); + + osalDbgAssert((devp->state != L3GD20_UNINIT), + "gyro_reset_sensivity(), invalid state"); - if(((L3GD20Driver *)ip)->config->fullscale == L3GD20_FS_250DPS) - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) - ((L3GD20Driver *)ip)->sensitivity[i] = L3GD20_SENS_250DPS; - else if(((L3GD20Driver *)ip)->config->fullscale == L3GD20_FS_500DPS) - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) - ((L3GD20Driver *)ip)->sensitivity[i] = L3GD20_SENS_500DPS; - else if(((L3GD20Driver *)ip)->config->fullscale == L3GD20_FS_2000DPS) - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) - ((L3GD20Driver *)ip)->sensitivity[i] = L3GD20_SENS_2000DPS; + if(devp->config->gyrofullscale == L3GD20_FS_250DPS) + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) + devp->gyrosensitivity[i] = L3GD20_SENS_250DPS; + else if(devp->config->gyrofullscale == L3GD20_FS_500DPS) + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) + devp->gyrosensitivity[i] = L3GD20_SENS_500DPS; + else if(devp->config->gyrofullscale == L3GD20_FS_2000DPS) + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) + devp->gyrosensitivity[i] = L3GD20_SENS_2000DPS; else { - osalDbgAssert(FALSE, "reset_sensivity(), full scale issue"); + osalDbgAssert(FALSE, "gyro_reset_sensivity(), full scale issue"); return MSG_RESET; } - return MSG_OK; + return msg; } - -static msg_t set_full_scale(void *ip, l3gd20_fs_t fs) { + +/** + * @brief Changes the L3GD20Driver gyroscope fullscale value. + * @note This function also rescale sensitivities and biases based on + * previous and next fullscale value. + * @note A recalibration is highly suggested after calling this function. + * + * @param[in] ip pointer to @p BaseGyroscope interface. + * @param[in] fs new fullscale value. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * @retval MSG_RESET otherwise. + */ +static msg_t gyro_set_full_scale(L3GD20Driver *devp, l3gd20_fs_t fs) { float newfs, scale; - uint8_t i, cr; + uint8_t i, cr; + msg_t msg = MSG_OK; + + osalDbgCheck(devp != NULL); + + osalDbgAssert((devp->state != L3GD20_UNINIT), + "gyro_set_full_scale(), invalid state"); +#if L3GD20_USE_SPI + osalDbgAssert((devp->config->spip->state == SPI_READY), + "gyro_set_full_scale(), channel not ready"); +#endif if(fs == L3GD20_FS_250DPS) { newfs = L3GD20_250DPS; @@ -259,23 +404,23 @@ static msg_t set_full_scale(void *ip, l3gd20_fs_t fs) { return MSG_RESET; } - if(newfs != ((L3GD20Driver *)ip)->fullscale) { - scale = newfs / ((L3GD20Driver *)ip)->fullscale; - ((L3GD20Driver *)ip)->fullscale = newfs; + if(newfs != devp->gyrofullscale) { + scale = newfs / devp->gyrofullscale; + devp->gyrofullscale = newfs; #if L3GD20_USE_SPI #if L3GD20_SHARED_SPI - spiAcquireBus(((L3GD20Driver *)ip)->config->spip); - spiStart(((L3GD20Driver *)ip)->config->spip, - ((L3GD20Driver *)ip)->config->spicfg); + spiAcquireBus(devp->config->spip); + spiStart(devp->config->spip, + devp->config->spicfg); #endif /* L3GD20_SHARED_SPI */ /* Updating register.*/ - l3gd20SPIReadRegister(((L3GD20Driver *)ip)->config->spip, + l3gd20SPIReadRegister(devp->config->spip, L3GD20_AD_CTRL_REG4, 1, &cr); #if L3GD20_SHARED_SPI - spiReleaseBus(((L3GD20Driver *)ip)->config->spip); + spiReleaseBus(devp->config->spip); #endif /* L3GD20_SHARED_SPI */ #endif /* L3GD20_USE_SPI */ cr &= ~(L3GD20_CTRL_REG4_FS_MASK); @@ -283,36 +428,37 @@ static msg_t set_full_scale(void *ip, l3gd20_fs_t fs) { #if L3GD20_USE_SPI #if L3GD20_SHARED_SPI - spiAcquireBus(((L3GD20Driver *)ip)->config->spip); - spiStart(((L3GD20Driver *)ip)->config->spip, - ((L3GD20Driver *)ip)->config->spicfg); + spiAcquireBus(devp->config->spip); + spiStart(devp->config->spip, + devp->config->spicfg); #endif /* L3GD20_SHARED_SPI */ - l3gd20SPIWriteRegister(((L3GD20Driver *)ip)->config->spip, + l3gd20SPIWriteRegister(devp->config->spip, L3GD20_AD_CTRL_REG4, 1, &cr); #if L3GD20_SHARED_SPI - spiReleaseBus(((L3GD20Driver *)ip)->config->spip); + spiReleaseBus(devp->config->spip); #endif /* L3GD20_SHARED_SPI */ #endif /* L3GD20_USE_SPI */ /* Scaling sensitivity and bias. Re-calibration is suggested anyway. */ - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - ((L3GD20Driver *)ip)->sensitivity[i] *= scale; - ((L3GD20Driver *)ip)->bias[i] *= scale; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + devp->gyrosensitivity[i] *= scale; + devp->gyrobias[i] *= scale; } } - return MSG_OK; + return msg; } + +static const struct L3GD20VMT vmt_device = { + (size_t)0, + gyro_set_full_scale +}; -static const struct BaseSensorVMT vmt_sensor = { - get_axes_number, read_raw, read_cooked -}; - -static const struct L3GD20GyroscopeVMT vmt_gyroscope = { - get_axes_number, read_raw, read_cooked, - sample_bias, set_bias, reset_bias, - set_sensivity, reset_sensivity, - set_full_scale +static const struct BaseGyroscopeVMT vmt_gyroscope = { + sizeof(struct L3GD20VMT*), + gyro_get_axes_number, gyro_read_raw, gyro_read_cooked, + gyro_sample_bias, gyro_set_bias, gyro_reset_bias, + gyro_set_sensivity, gyro_reset_sensivity }; /*===========================================================================*/ @@ -327,12 +473,14 @@ static const struct L3GD20GyroscopeVMT vmt_gyroscope = { * @init */ void l3gd20ObjectInit(L3GD20Driver *devp) { - uint32_t i; - devp->vmt_sensor = &vmt_sensor; - devp->vmt_gyroscope = &vmt_gyroscope; + uint32_t i; + + devp->vmt = &vmt_device; + devp->gyro_if.vmt = &vmt_gyroscope; + devp->config = NULL; - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) - devp->bias[i] = 0.0f; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) + devp->gyrobias[i] = 0.0f; devp->state = L3GD20_STOP; } @@ -358,36 +506,35 @@ void l3gd20Start(L3GD20Driver *devp, const L3GD20Config *config) { { cr[0] = L3GD20_CTRL_REG1_XEN | L3GD20_CTRL_REG1_YEN | L3GD20_CTRL_REG1_ZEN | L3GD20_CTRL_REG1_PD | - devp->config->outputdatarate; + devp->config->gyrooutputdatarate; #if L3GD20_USE_ADVANCED || defined(__DOXYGEN__) - cr[0] |= devp->config->bandwidth; + cr[0] |= devp->config->gyrobandwidth; #endif } /* Control register 2 configuration block.*/ { #if L3GD20_USE_ADVANCED || defined(__DOXYGEN__) - if(devp->config->hpmode != L3GD20_HPM_BYPASSED) - cr[1] = devp->config->hpmode | devp->config->hpconfiguration; + if(devp->config->gyrohpmode != L3GD20_HPM_BYPASSED) + cr[1] = devp->config->gyrohpmode | devp->config->gyrohpconfiguration; #endif } /* Control register 4 configuration block.*/ { - cr[3] = devp->config->fullscale; + cr[3] = devp->config->gyrofullscale; #if L3GD20_USE_ADVANCED || defined(__DOXYGEN__) - cr[3] |= devp->config->blockdataupdate | - devp->config->endianness; + cr[3] |= devp->config->gyroblockdataupdate | + devp->config->gyroendianness; #endif } /* Control register 5 configuration block.*/ - { - + { #if L3GD20_USE_ADVANCED || defined(__DOXYGEN__) - if((devp->config->hpmode != L3GD20_HPM_BYPASSED)) { + if((devp->config->gyrohpmode != L3GD20_HPM_BYPASSED)) { cr[4] = L3GD20_CTRL_REG5_HPEN; - if(devp->config->lp2mode != L3GD20_LP2M_BYPASSED) { + if(devp->config->gyrolp2mode != L3GD20_LP2M_BYPASSED) { cr[4] |= L3GD20_CTRL_REG5_INT1_SEL1 | L3GD20_CTRL_REG5_OUT_SEL1; } @@ -401,52 +548,52 @@ void l3gd20Start(L3GD20Driver *devp, const L3GD20Config *config) { #if L3GD20_USE_SPI #if L3GD20_SHARED_SPI - spiAcquireBus((devp)->config->spip); + spiAcquireBus(devp->config->spip); #endif /* L3GD20_SHARED_SPI */ - spiStart((devp)->config->spip, - (devp)->config->spicfg); + spiStart(devp->config->spip, + devp->config->spicfg); l3gd20SPIWriteRegister(devp->config->spip, L3GD20_AD_CTRL_REG1, 5, cr); #if L3GD20_SHARED_SPI - spiReleaseBus((devp)->config->spip); + spiReleaseBus(devp->config->spip); #endif /* L3GD20_SHARED_SPI */ #endif /* L3GD20_USE_SPI */ /* Storing sensitivity information according to full scale.*/ - if(devp->config->fullscale == L3GD20_FS_250DPS) { - devp->fullscale = L3GD20_250DPS; - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - if (devp->config->sensitivity == NULL) - devp->sensitivity[i] = L3GD20_SENS_250DPS; + if(devp->config->gyrofullscale == L3GD20_FS_250DPS) { + devp->gyrofullscale = L3GD20_250DPS; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + if (devp->config->gyrosensitivity == NULL) + devp->gyrosensitivity[i] = L3GD20_SENS_250DPS; else - devp->sensitivity[i] = devp->config->sensitivity[i]; + devp->gyrosensitivity[i] = devp->config->gyrosensitivity[i]; } } - else if(devp->config->fullscale == L3GD20_FS_500DPS) { - devp->fullscale = L3GD20_500DPS; - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - if (devp->config->sensitivity == NULL) - devp->sensitivity[i] = L3GD20_SENS_500DPS; + else if(devp->config->gyrofullscale == L3GD20_FS_500DPS) { + devp->gyrofullscale = L3GD20_500DPS; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + if (devp->config->gyrosensitivity == NULL) + devp->gyrosensitivity[i] = L3GD20_SENS_500DPS; else - devp->sensitivity[i] = devp->config->sensitivity[i]; + devp->gyrosensitivity[i] = devp->config->gyrosensitivity[i]; } } - else if(devp->config->fullscale == L3GD20_FS_2000DPS) { - devp->fullscale = L3GD20_2000DPS; - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - if (devp->config->sensitivity == NULL) - devp->sensitivity[i] = L3GD20_SENS_2000DPS; + else if(devp->config->gyrofullscale == L3GD20_FS_2000DPS) { + devp->gyrofullscale = L3GD20_2000DPS; + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + if (devp->config->gyrosensitivity == NULL) + devp->gyrosensitivity[i] = L3GD20_SENS_2000DPS; else - devp->sensitivity[i] = devp->config->sensitivity[i]; + devp->gyrosensitivity[i] = devp->config->gyrosensitivity[i]; } } else osalDbgAssert(FALSE, "l3gd20Start(), full scale issue"); - if(devp->config->bias != NULL) { - for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) { - devp->bias[i] = devp->config->bias[i]; + if(devp->config->gyrobias != NULL) { + for(i = 0; i < L3GD20_GYRO_NUMBER_OF_AXES; i++) { + devp->gyrobias[i] = devp->config->gyrobias[i]; } } @@ -476,17 +623,17 @@ void l3gd20Stop(L3GD20Driver *devp) { #if L3GD20_USE_SPI #if L3GD20_SHARED_SPI - spiAcquireBus((devp)->config->spip); - spiStart((devp)->config->spip, - (devp)->config->spicfg); + spiAcquireBus(devp->config->spip); + spiStart(devp->config->spip, + devp->config->spicfg); #endif /* L3GD20_SHARED_SPI */ l3gd20SPIWriteRegister(devp->config->spip, L3GD20_AD_CTRL_REG1, 1, &cr1); - spiStop((devp)->config->spip); + spiStop(devp->config->spip); #if L3GD20_SHARED_SPI - spiReleaseBus((devp)->config->spip); + spiReleaseBus(devp->config->spip); #endif /* L3GD20_SHARED_SPI */ #endif /* L3GD20_USE_SPI */ } diff --git a/os/ex/ST/l3gd20.h b/os/ex/ST/l3gd20.h index 84dc2a412..0cb3b18a9 100644 --- a/os/ex/ST/l3gd20.h +++ b/os/ex/ST/l3gd20.h @@ -1,5 +1,5 @@ /* - ChibiOS - Copyright (C) 2016 Rocco Marco Guglielmi + ChibiOS - Copyright (C) 2016-2018 Rocco Marco Guglielmi This file is part of ChibiOS. @@ -42,7 +42,7 @@ /** * @brief L3GD20 driver version string. */ -#define EX_L3GD20_VERSION "1.0.5" +#define EX_L3GD20_VERSION "1.0.6" /** * @brief L3GD20 driver version major number. @@ -57,15 +57,17 @@ /** * @brief L3GD20 driver version patch number. */ -#define EX_L3GD20_PATCH 5 +#define EX_L3GD20_PATCH 65 /** @} */ /** - * @brief L3GD20 characteristics. + * @brief L3GD20 gyroscope system characteristics. + * @note Sensitivity is expressed as DPS/LSB whereas DPS stand for Degree + * per second [°/s]. * * @{ */ -#define L3GD20_NUMBER_OF_AXES 3U +#define L3GD20_GYRO_NUMBER_OF_AXES 3U #define L3GD20_250DPS 250.0f #define L3GD20_500DPS 500.0f @@ -124,99 +126,99 @@ * @name L3GD20_CTRL_REG1 register bits definitions * @{ */ -#define L3GD20_CTRL_REG1_MASK 0xFF /**< L3GD20_CTRL_REG1 mask */ -#define L3GD20_CTRL_REG1_XEN (1 << 0) /**< X axis enable */ -#define L3GD20_CTRL_REG1_YEN (1 << 1) /**< Y axis enable */ -#define L3GD20_CTRL_REG1_ZEN (1 << 2) /**< Z axis enable */ -#define L3GD20_CTRL_REG1_PD (1 << 3) /**< Power-down mode enable */ -#define L3GD20_CTRL_REG1_BW0 (1 << 4) /**< Bandwidth bit 0 */ -#define L3GD20_CTRL_REG1_BW1 (1 << 5) /**< Bandwidth bit 1 */ -#define L3GD20_CTRL_REG1_DR0 (1 << 6) /**< Output data rate bit 0 */ -#define L3GD20_CTRL_REG1_DR1 (1 << 7) /**< Output data rate bit 1 */ +#define L3GD20_CTRL_REG1_MASK 0xFF +#define L3GD20_CTRL_REG1_XEN (1 << 0) +#define L3GD20_CTRL_REG1_YEN (1 << 1) +#define L3GD20_CTRL_REG1_ZEN (1 << 2) +#define L3GD20_CTRL_REG1_PD (1 << 3) +#define L3GD20_CTRL_REG1_BW0 (1 << 4) +#define L3GD20_CTRL_REG1_BW1 (1 << 5) +#define L3GD20_CTRL_REG1_DR0 (1 << 6) +#define L3GD20_CTRL_REG1_DR1 (1 << 7) /** @} */ /** * @name L3GD20_CTRL_REG2 register bits definitions * @{ */ -#define L3GD20_CTRL_REG2_MASK 0x3F /**< L3GD20_CTRL_REG2 mask */ -#define L3GD20_CTRL_REG2_HPCF0 (1 << 0) /**< HP filter cutoff bit 0 */ -#define L3GD20_CTRL_REG2_HPCF1 (1 << 1) /**< HP filter cutoff bit 1 */ -#define L3GD20_CTRL_REG2_HPCF2 (1 << 2) /**< HP filter cutoff bit 2 */ -#define L3GD20_CTRL_REG2_HPCF3 (1 << 3) /**< HP filter cutoff bit 3 */ -#define L3GD20_CTRL_REG2_HPM0 (1 << 4) /**< HP filter mode bit 0 */ -#define L3GD20_CTRL_REG2_HPM1 (1 << 5) /**< HP filter mode bit 1 */ +#define L3GD20_CTRL_REG2_MASK 0x3F +#define L3GD20_CTRL_REG2_HPCF0 (1 << 0) +#define L3GD20_CTRL_REG2_HPCF1 (1 << 1) +#define L3GD20_CTRL_REG2_HPCF2 (1 << 2) +#define L3GD20_CTRL_REG2_HPCF3 (1 << 3) +#define L3GD20_CTRL_REG2_HPM0 (1 << 4) +#define L3GD20_CTRL_REG2_HPM1 (1 << 5) /** @} */ /** * @name L3GD20_CTRL_REG3 register bits definitions * @{ */ -#define L3GD20_CTRL_REG3_MASK 0xFF /**< L3GD20_CTRL_REG3 mask */ -#define L3GD20_CTRL_REG3_I2_EMPTY (1 << 0) /**< FIFO empty IRQ */ -#define L3GD20_CTRL_REG3_I2_ORUN (1 << 1) /**< FIFO overrun IRQ */ -#define L3GD20_CTRL_REG3_I2_WTM (1 << 2) /**< FIFO watermark IRQ */ -#define L3GD20_CTRL_REG3_I2_DRDY (1 << 3) /**< Data ready */ -#define L3GD20_CTRL_REG3_PP_OD (1 << 4) /**< Push-pull / Open Drain */ -#define L3GD20_CTRL_REG3_H_LACTIVE (1 << 5) /**< IRQ active */ -#define L3GD20_CTRL_REG3_I1_BOOT (1 << 6) /**< Boot status available */ -#define L3GD20_CTRL_REG3_I1_INT1 (1 << 7) /**< IRQ enable */ +#define L3GD20_CTRL_REG3_MASK 0xFF +#define L3GD20_CTRL_REG3_I2_EMPTY (1 << 0) +#define L3GD20_CTRL_REG3_I2_ORUN (1 << 1) +#define L3GD20_CTRL_REG3_I2_WTM (1 << 2) +#define L3GD20_CTRL_REG3_I2_DRDY (1 << 3) +#define L3GD20_CTRL_REG3_PP_OD (1 << 4) +#define L3GD20_CTRL_REG3_H_LACTIVE (1 << 5) +#define L3GD20_CTRL_REG3_I1_BOOT (1 << 6) +#define L3GD20_CTRL_REG3_I1_INT1 (1 << 7) /** @} */ /** * @name L3GD20_CTRL_REG4 register bits definitions * @{ */ -#define L3GD20_CTRL_REG4_MASK 0xF1 /**< L3GD20_CTRL_REG4 mask */ -#define L3GD20_CTRL_REG4_SIM (1 << 0) /**< SPI mode */ -#define L3GD20_CTRL_REG4_FS_MASK 0x30 /**< Full scale field mask */ -#define L3GD20_CTRL_REG4_FS0 (1 << 4) /**< Full scale bit 0 */ -#define L3GD20_CTRL_REG4_FS1 (1 << 5) /**< Full scale bit 1 */ -#define L3GD20_CTRL_REG4_BLE (1 << 6) /**< Big/little endian data */ -#define L3GD20_CTRL_REG4_BDU (1 << 7) /**< Block data update */ +#define L3GD20_CTRL_REG4_MASK 0xF1 +#define L3GD20_CTRL_REG4_SIM (1 << 0) +#define L3GD20_CTRL_REG4_FS_MASK 0x30 +#define L3GD20_CTRL_REG4_FS0 (1 << 4) +#define L3GD20_CTRL_REG4_FS1 (1 << 5) +#define L3GD20_CTRL_REG4_BLE (1 << 6) +#define L3GD20_CTRL_REG4_BDU (1 << 7) /** @} */ /** * @name L3GD20_CTRL_REG5 register bits definitions * @{ */ -#define L3GD20_CTRL_REG5_MASK 0xDF /**< L3GD20_CTRL_REG5 mask */ -#define L3GD20_CTRL_REG5_OUT_SEL0 (1 << 0) /**< Out selection bit 0 */ -#define L3GD20_CTRL_REG5_OUT_SEL1 (1 << 1) /**< Out selection bit 1 */ -#define L3GD20_CTRL_REG5_INT1_SEL0 (1 << 2) /**< INT1 selection bit 0 */ -#define L3GD20_CTRL_REG5_INT1_SEL1 (1 << 3) /**< INT1 selection bit 1 */ -#define L3GD20_CTRL_REG5_HPEN (1 << 4) /**< HP filter enable */ -#define L3GD20_CTRL_REG5_FIFO_EN (1 << 6) /**< FIFO enable */ -#define L3GD20_CTRL_REG5_BOOT (1 << 7) /**< Reboot memory content */ +#define L3GD20_CTRL_REG5_MASK 0xDF +#define L3GD20_CTRL_REG5_OUT_SEL0 (1 << 0) +#define L3GD20_CTRL_REG5_OUT_SEL1 (1 << 1) +#define L3GD20_CTRL_REG5_INT1_SEL0 (1 << 2) +#define L3GD20_CTRL_REG5_INT1_SEL1 (1 << 3) +#define L3GD20_CTRL_REG5_HPEN (1 << 4) +#define L3GD20_CTRL_REG5_FIFO_EN (1 << 6) +#define L3GD20_CTRL_REG5_BOOT (1 << 7) /** @} */ /** * @name L3GD20_INT1_CFG register bits definitions * @{ */ -#define L3GD20_INT1_CFG_MASK 0xFF /**< L3GD20_INT1_CFG mask */ -#define L3GD20_INT1_CFG_XLIE (1 << 0) /**< Enable INT1 on X low */ -#define L3GD20_INT1_CFG_XHIE (1 << 1) /**< Enable INT1 on X high */ -#define L3GD20_INT1_CFG_YLIE (1 << 2) /**< Enable INT1 on Y low */ -#define L3GD20_INT1_CFG_YHIE (1 << 3) /**< Enable INT1 on Y high */ -#define L3GD20_INT1_CFG_ZLIE (1 << 4) /**< Enable INT1 on Z low */ -#define L3GD20_INT1_CFG_ZHIE (1 << 5) /**< Enable INT1 on Z high */ -#define L3GD20_INT1_CFG_LIR (1 << 6) /**< Latch INT1 */ -#define L3GD20_INT1_CFG_AND_OR (1 << 7) /**< AND OR combination */ +#define L3GD20_INT1_CFG_MASK 0xFF +#define L3GD20_INT1_CFG_XLIE (1 << 0) +#define L3GD20_INT1_CFG_XHIE (1 << 1) +#define L3GD20_INT1_CFG_YLIE (1 << 2) +#define L3GD20_INT1_CFG_YHIE (1 << 3) +#define L3GD20_INT1_CFG_ZLIE (1 << 4) +#define L3GD20_INT1_CFG_ZHIE (1 << 5) +#define L3GD20_INT1_CFG_LIR (1 << 6) +#define L3GD20_INT1_CFG_AND_OR (1 << 7) /** @} */ /** * @name L3GD20_INT1_SRC register bits definitions * @{ */ -#define L3GD20_INT1_SRC_MASK 0x7F /**< L3GD20_INT1_SRC mask */ -#define L3GD20_INT1_SRC_XL (1 << 0) /**< X low event */ -#define L3GD20_INT1_SRC_XH (1 << 1) /**< X high event */ -#define L3GD20_INT1_SRC_YL (1 << 2) /**< Y low event */ -#define L3GD20_INT1_SRC_YH (1 << 3) /**< Y high event */ -#define L3GD20_INT1_SRC_ZL (1 << 4) /**< Z low event */ -#define L3GD20_INT1_SRC_ZH (1 << 5) /**< Z high event */ -#define L3GD20_INT1_SRC_IA (1 << 6) /**< Interrupt active */ +#define L3GD20_INT1_SRC_MASK 0x7F +#define L3GD20_INT1_SRC_XL (1 << 0) +#define L3GD20_INT1_SRC_XH (1 << 1) +#define L3GD20_INT1_SRC_YL (1 << 2) +#define L3GD20_INT1_SRC_YH (1 << 3) +#define L3GD20_INT1_SRC_ZL (1 << 4) +#define L3GD20_INT1_SRC_ZH (1 << 5) +#define L3GD20_INT1_SRC_IA (1 << 6) /** @} */ /*===========================================================================*/ @@ -277,8 +279,8 @@ * @brief Settling time for bias removal * @details This is the time between each bias acquisition. */ -#if !defined(L3GD20_BIAS_SETTLING_uS) || defined(__DOXYGEN__) -#define L3GD20_BIAS_SETTLING_uS 5000 +#if !defined(L3GD20_BIAS_SETTLING_US) || defined(__DOXYGEN__) +#define L3GD20_BIAS_SETTLING_US 5000 #endif /** @} */ @@ -294,7 +296,6 @@ #error "L3GD20_USE_SPI requires HAL_USE_SPI" #endif -//TODO: add I2C support. #if L3GD20_USE_I2C #error "L3GD20 over I2C still not supported" #endif @@ -314,7 +315,12 @@ /** * @name L3GD20 data structures and types. * @{ - */ + */ +/** + * @brief Structure representing a L3GD20 driver. + */ +typedef struct L3GD20Driver L3GD20Driver; + /** * @brief L3GD20 full scale. */ @@ -322,7 +328,7 @@ typedef enum { L3GD20_FS_250DPS = 0x00, /**< Full scale 250 degree per second. */ L3GD20_FS_500DPS = 0x10, /**< Full scale 500 degree per second. */ L3GD20_FS_2000DPS = 0x20 /**< Full scale 2000 degree per second. */ -}l3gd20_fs_t; +} l3gd20_fs_t; /** * @brief L3GD20 output data rate and bandwidth. @@ -332,7 +338,7 @@ typedef enum { L3GD20_ODR_190HZ = 0x40, /**< Output data rate 190 Hz. */ L3GD20_ODR_380HZ = 0x80, /**< Output data rate 380 Hz. */ L3GD20_ODR_760HZ = 0xC0 /**< Output data rate 760 Hz. */ -}l3gd20_odr_t; +} l3gd20_odr_t; /** * @brief L3GD20 low pass filter 1 bandwidth. @@ -342,14 +348,15 @@ typedef enum { L3GD20_BW1 = 0x40, /**< LPF1 bandwidth. Depends on ODR. */ L3GD20_BW2 = 0x80, /**< LPF1 bandwidth. Depends on ODR. */ L3GD20_BW3 = 0xC0 /**< LPF1 bandwidth. Depends on ODR. */ -}l3gd20_bw_t; +} l3gd20_bw_t; + /** * @brief L3GD20 block data update. */ typedef enum { L3GD20_BDU_CONTINUOUS = 0x00, /**< Block data continuously updated. */ L3GD20_BDU_BLOCKED = 0x80 /**< Block data updated after reading. */ -}l3gd20_bdu_t; +} l3gd20_bdu_t; /** * @brief L3GD20 HP filter mode. @@ -359,7 +366,7 @@ typedef enum { L3GD20_HPM_REFERENCE = 0x10, /**< Reference signal for filtering. */ L3GD20_HPM_AUTORESET = 0x30, /**< Autoreset on interrupt event. */ L3GD20_HPM_BYPASSED = 0xFF /**< HP filter bypassed */ -}l3gd20_hpm_t; +} l3gd20_hpm_t; /** * @brief L3GD20 HP configuration. @@ -375,7 +382,7 @@ typedef enum { L3GD20_HPCF_7 = 0x07, /**< Depends on ODR (Table 26 for more).*/ L3GD20_HPCF_8 = 0x08, /**< Depends on ODR (Table 26 for more).*/ L3GD20_HPCF_9 = 0x09 /**< Depends on ODR (Table 26 for more).*/ -}l3gd20_hpcf_t; +} l3gd20_hpcf_t; /** * @brief L3GD20 LP2 filter mode. @@ -384,7 +391,7 @@ typedef enum { typedef enum { L3GD20_LP2M_ON = 0x00, /**< LP2 filter activated. */ L3GD20_LP2M_BYPASSED = 0xFF, /**< LP2 filter bypassed. */ -}l3gd20_lp2m_t; +} l3gd20_lp2m_t; /** * @brief L3GD20 endianness. @@ -392,7 +399,7 @@ typedef enum { typedef enum { L3GD20_END_LITTLE = 0x00, /**< Little endian. */ L3GD20_END_BIG = 0x40 /**< Big endian. */ -}l3gd20_end_t; +} l3gd20_end_t; /** * @brief Driver state machine possible states. @@ -400,7 +407,7 @@ typedef enum { typedef enum { L3GD20_UNINIT = 0, /**< Not initialized. */ L3GD20_STOP = 1, /**< Stopped. */ - L3GD20_READY = 2, /**< Ready. */ + L3GD20_READY = 2 /**< Ready. */ } l3gd20_state_t; /** @@ -410,148 +417,273 @@ typedef struct { #if L3GD20_USE_SPI || defined(__DOXYGEN__) /** - * @brief SPI driver associated to this L3GD20. + * @brief SPI driver associated to this L3GD20. */ SPIDriver *spip; /** - * @brief SPI configuration associated to this L3GD20. + * @brief SPI configuration associated to this L3GD20. */ const SPIConfig *spicfg; #endif /* L3GD20_USE_SPI */ #if L3GD20_USE_I2C || defined(__DOXYGEN__) /** - * @brief I2C driver associated to this L3GD20. + * @brief I2C driver associated to this L3GD20. */ I2CDriver *i2cp; /** - * @brief I2C configuration associated to this L3GD20. + * @brief I2C configuration associated to this L3GD20. */ const I2CConfig *i2ccfg; #endif /* L3GD20_USE_I2C */ /** - * @brief L3GD20 initial sensitivity. + * @brief L3GD20 gyroscope system initial sensitivity. */ - float *sensitivity; + float *gyrosensitivity; /** - * @brief L3GD20 initial bias. + * @brief L3GD20 gyroscope system initial bias. */ - float *bias; + float *gyrobias; /** - * @brief L3GD20 initial full scale value. + * @brief L3GD20 gyroscope system initial full scale value. */ - l3gd20_fs_t fullscale; + l3gd20_fs_t gyrofullscale; /** - * @brief L3GD20 output data rate selection. + * @brief L3GD20 gyroscope system output data rate selection. */ - l3gd20_odr_t outputdatarate; + l3gd20_odr_t gyrooutputdatarate; #if L3GD20_USE_ADVANCED || defined(__DOXYGEN__) /** - * @brief L3GD20 block data update. + * @brief L3GD20 gyroscope system block data update. */ - l3gd20_bdu_t blockdataupdate; + l3gd20_bdu_t gyroblockdataupdate; /** - * @brief L3GD20 endianness. + * @brief L3GD20 gyroscope system endianness. */ - l3gd20_end_t endianness; + l3gd20_end_t gyroendianness; /** - * @brief L3GD20 LP1 filter bandwidth. + * @brief L3GD20 gyroscope system LP1 filter bandwidth. */ - l3gd20_bw_t bandwidth; + l3gd20_bw_t gyrobandwidth; /** - * @brief L3GD20 HP filter mode. + * @brief L3GD20 gyroscope system HP filter mode. */ - l3gd20_hpm_t hpmode; + l3gd20_hpm_t gyrohpmode; /** - * @brief L3GD20 HP configuration. + * @brief L3GD20 gyroscope system HP configuration. */ - l3gd20_hpcf_t hpconfiguration; + l3gd20_hpcf_t gyrohpconfiguration; /** - * @brief L3GD20 LP2 filter mode. + * @brief L3GD20 gyroscope system LP2 filter mode. * @details To activate LP2 HP should be active */ - l3gd20_lp2m_t lp2mode; + l3gd20_lp2m_t gyrolp2mode; #endif } L3GD20Config; /** - * @brief @p L3GD20 gyroscope subsystem specific methods. + * @brief @p L3GD20 specific methods. */ -#define _l3gd20_gyroscope_methods_alone \ +#define _l3gd20_methods_alone \ /* Change full scale value of L3GD20.*/ \ - msg_t (*set_full_scale)(void *instance, l3gd20_fs_t fs); + msg_t (*gyro_set_full_scale)(L3GD20Driver *instance, l3gd20_fs_t fs); /** - * @brief @p L3GD20 gyroscope subsystem specific methods with inherited ones. + * @brief @p L3GD20 specific methods with inherited ones. */ -#define _l3gd20_gyroscope_methods \ - _base_gyroscope_methods \ - _l3gd20_gyroscope_methods_alone +#define _l3gd20_methods \ + _base_object_methods \ + _l3gd20_methods_alone /** - * @extends BaseGyroscopeVMT + * @extends BaseObjectVMT * - * @brief @p L3GD20 gyroscope virtual methods table. + * @brief @p L3GD20 virtual methods table. */ -struct L3GD20GyroscopeVMT { - _l3gd20_gyroscope_methods +struct L3GD20VMT { + _l3gd20_methods }; /** * @brief @p L3GD20Driver specific data. */ #define _l3gd20_data \ - _base_gyroscope_data \ + _base_sensor_data \ /* Driver state.*/ \ l3gd20_state_t state; \ /* Current configuration data.*/ \ - const L3GD20Config *config; \ - /* Current sensitivity data.*/ \ - float sensitivity[L3GD20_NUMBER_OF_AXES]; \ - /* Current Bias data.*/ \ - float bias[L3GD20_NUMBER_OF_AXES]; \ - /* Current full scale value.*/ \ - float fullscale; + const L3GD20Config *config; \ + /* Gyroscope subsystem axes number.*/ \ + size_t gyroaxes; \ + /* Gyroscope subsystem current sensitivity.*/ \ + float gyrosensitivity[L3GD20_GYRO_NUMBER_OF_AXES]; \ + /* Gyroscope subsystem current Bias.*/ \ + float gyrobias[L3GD20_GYRO_NUMBER_OF_AXES]; \ + /* Gyroscope subsystem current full scale value.*/ \ + float gyrofullscale; /** - * @extends BaseGyroscope - * * @brief L3GD20 3-axis gyroscope class. - * @details This class extends @p BaseGyroscope by adding physical - * driver implementation. */ struct L3GD20Driver { - /** @brief BaseSensor Virtual Methods Table. */ - const struct BaseSensorVMT *vmt_sensor; - _base_sensor_data - /** @brief L3GD20 Gyroscope Virtual Methods Table. */ - const struct L3GD20GyroscopeVMT *vmt_gyroscope; - _base_gyroscope_data + /** @brief Virtual Methods Table. */ + const struct L3GD20VMT *vmt; + /** @brief Base gyroscope interface.*/ + BaseGyroscope gyro_if; _l3gd20_data -}; - -/** - * @brief Structure representing a L3GD20 driver. - */ -typedef struct L3GD20Driver L3GD20Driver; +}; /** @} */ /*===========================================================================*/ /* Driver macros. */ /*===========================================================================*/ - -/** - * @brief Change gyroscope full scale value. - * - * @param[in] ip pointer to a @p L3GD20Driver class. - * @param[in] fs the new full scale value. - * - * @return The operation status. - * @retval MSG_OK if the function succeeded. - * @retval MSG_RESET if one or more errors occurred. - * @api - */ -#define gyroscopeSetFullScale(ip, fs) \ - (ip)->vmt_gyroscope->set_full_scale(ip, fs) + +/** + * @brief Return the number of axes of the BaseGyroscope. + * + * @param[in] devp pointer to @p L3GD20Driver. + * + * @return the number of axes. + * + * @api + */ +#define l3gd20GyroscopeGetAxesNumber(devp) \ + gyroscopeGetAxesNumber(&((devp)->gyro_if)) + +/** + * @brief Retrieves raw data from the BaseGyroscope. + * @note This data is retrieved from MEMS register without any algebraical + * manipulation. + * @note The axes array must be at least the same size of the + * BaseGyroscope axes number. + * + * @param[in] devp pointer to @p L3GD20Driver. + * @param[out] axes a buffer which would be filled with raw data. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * + * @api + */ +#define l3gd20GyroscopeReadRaw(devp, axes) \ + gyroscopeReadRaw(&((devp)->gyro_if), axes) + +/** + * @brief Retrieves cooked data from the BaseGyroscope. + * @note This data is manipulated according to the formula + * cooked = (raw * sensitivity) - bias. + * @note Final data is expressed as DPS. + * @note The axes array must be at least the same size of the + * BaseGyroscope axes number. + * + * @param[in] devp pointer to @p L3GD20Driver. + * @param[out] axes a buffer which would be filled with cooked data. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * + * @api + */ +#define l3gd20GyroscopeReadCooked(devp, axes) \ + gyroscopeReadCooked(&((devp)->gyro_if), axes) + +/** + * @brief Samples bias values for the BaseGyroscope. + * @note The L3GD20 shall not be moved during the whole procedure. + * @note After this function internal bias is automatically updated. + * @note The behavior of this function depends on @P L3GD20_BIAS_ACQ_TIMES + * and @p L3GD20_BIAS_SETTLING_US. + * + * @param[in] devp pointer to @p L3GD20Driver. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * + * @api + */ +#define l3gd20GyroscopeSampleBias(devp) \ + gyroscopeSampleBias(&((devp)->gyro_if)) + +/** + * @brief Set bias values for the BaseGyroscope. + * @note Bias must be expressed as DPS. + * @note The bias buffer must be at least the same size of the BaseGyroscope + * axes number. + * + * @param[in] devp pointer to @p L3GD20Driver. + * @param[in] bp a buffer which contains biases. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * + * @api + */ +#define l3gd20GyroscopeSetBias(devp, bp) \ + gyroscopeSetBias(&((devp)->gyro_if), bp) + +/** + * @brief Reset bias values for the BaseGyroscope. + * @note Default biases value are obtained from device datasheet when + * available otherwise they are considered zero. + * + * @param[in] devp pointer to @p L3GD20Driver. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * + * @api + */ +#define l3gd20GyroscopeResetBias(devp) \ + gyroscopeResetBias(&((devp)->gyro_if)) + +/** + * @brief Set sensitivity values for the BaseGyroscope. + * @note Sensitivity must be expressed as DPS/LSB. + * @note The sensitivity buffer must be at least the same size of the + * BaseGyroscope axes number. + * + * @param[in] devp pointer to @p L3GD20Driver. + * @param[in] sp a buffer which contains sensitivities. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * + * @api + */ +#define l3gd20GyroscopeSetSensitivity(devp, sp) \ + gyroscopeSetSensitivity(&((devp)->gyro_if), sp) + +/** + * @brief Reset sensitivity values for the BaseGyroscope. + * @note Default sensitivities value are obtained from device datasheet. + * + * @param[in] devp pointer to @p L3GD20Driver. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * @retval MSG_RESET otherwise. + * + * @api + */ +#define l3gd20GyroscopeResetSensitivity(devp) \ + gyroscopeResetSensitivity(&((devp)->gyro_if)) + +/** + * @brief Changes the L3GD20Driver gyroscope fullscale value. + * @note This function also rescale sensitivities and biases based on + * previous and next fullscale value. + * @note A recalibration is highly suggested after calling this function. + * + * @param[in] devp pointer to @p L3GD20Driver. + * @param[in] fs new fullscale value. + * + * @return The operation status. + * @retval MSG_OK if the function succeeded. + * @retval MSG_RESET otherwise. + * + * @api + */ +#define l3gd20GyroscopeSetFullScale(devp, fs) \ + (devp)->vmt->acc_set_full_scale(devp, fs) /*===========================================================================*/ /* External declarations. */