#include "bmi160.hpp" #include "bmi160_gyro.hpp" #include /* list of registers that will be checked in check_registers(). Note that ADDR_WHO_AM_I must be first in the list. */ const uint8_t BMI160::_checked_registers[BMI160_NUM_CHECKED_REGISTERS] = { BMIREG_CHIP_ID, BMIREG_ACC_CONF, BMIREG_ACC_RANGE, BMIREG_GYR_CONF, BMIREG_GYR_RANGE, BMIREG_INT_EN_1, BMIREG_INT_OUT_CTRL, BMIREG_INT_MAP_1, BMIREG_IF_CONF, BMIREG_NV_CONF }; BMI160::BMI160(int bus, const char *path_accel, const char *path_gyro, uint32_t device, enum Rotation rotation) : SPI("BMI160", path_accel, bus, device, SPIDEV_MODE3, BMI160_BUS_SPEED), _gyro(new BMI160_gyro(this, path_gyro)), _whoami(0), _call{}, _call_interval(0), _accel_reports(nullptr), _accel_scale{}, _accel_range_scale(0.0f), _accel_range_m_s2(0.0f), _accel_topic(nullptr), _accel_orb_class_instance(-1), _accel_class_instance(-1), _gyro_reports(nullptr), _gyro_scale{}, _gyro_range_scale(0.0f), _gyro_range_rad_s(0.0f), _dlpf_freq(0), _accel_sample_rate(BMI160_ACCEL_DEFAULT_RATE), _gyro_sample_rate(BMI160_GYRO_DEFAULT_RATE), _accel_reads(perf_alloc(PC_COUNT, "bmi160_accel_read")), _gyro_reads(perf_alloc(PC_COUNT, "bmi160_gyro_read")), _sample_perf(perf_alloc(PC_ELAPSED, "bmi160_read")), _bad_transfers(perf_alloc(PC_COUNT, "bmi160_bad_transfers")), _bad_registers(perf_alloc(PC_COUNT, "bmi160_bad_registers")), _good_transfers(perf_alloc(PC_COUNT, "bmi160_good_transfers")), _reset_retries(perf_alloc(PC_COUNT, "bmi160_reset_retries")), _duplicates(perf_alloc(PC_COUNT, "bmi160_duplicates")), _controller_latency_perf(perf_alloc_once(PC_ELAPSED, "ctrl_latency")), _register_wait(0), _reset_wait(0), _accel_filter_x(BMI160_ACCEL_DEFAULT_RATE, BMI160_ACCEL_DEFAULT_DRIVER_FILTER_FREQ), _accel_filter_y(BMI160_ACCEL_DEFAULT_RATE, BMI160_ACCEL_DEFAULT_DRIVER_FILTER_FREQ), _accel_filter_z(BMI160_ACCEL_DEFAULT_RATE, BMI160_ACCEL_DEFAULT_DRIVER_FILTER_FREQ), _gyro_filter_x(BMI160_GYRO_DEFAULT_RATE, BMI160_GYRO_DEFAULT_DRIVER_FILTER_FREQ), _gyro_filter_y(BMI160_GYRO_DEFAULT_RATE, BMI160_GYRO_DEFAULT_DRIVER_FILTER_FREQ), _gyro_filter_z(BMI160_GYRO_DEFAULT_RATE, BMI160_GYRO_DEFAULT_DRIVER_FILTER_FREQ), _accel_int(1000000 / BMI160_ACCEL_MAX_PUBLISH_RATE), _gyro_int(1000000 / BMI160_GYRO_MAX_PUBLISH_RATE, true), _rotation(rotation), _checked_next(0), _last_temperature(0), _last_accel{}, _got_duplicate(false) { // disable debug() calls _debug_enabled = false; _device_id.devid_s.devtype = DRV_ACC_DEVTYPE_BMI160; /* Prime _gyro with parents devid. */ _gyro->_device_id.devid = _device_id.devid; _gyro->_device_id.devid_s.devtype = DRV_GYR_DEVTYPE_BMI160; // default accel scale factors _accel_scale.x_offset = 0; _accel_scale.x_scale = 1.0f; _accel_scale.y_offset = 0; _accel_scale.y_scale = 1.0f; _accel_scale.z_offset = 0; _accel_scale.z_scale = 1.0f; // default gyro scale factors _gyro_scale.x_offset = 0; _gyro_scale.x_scale = 1.0f; _gyro_scale.y_offset = 0; _gyro_scale.y_scale = 1.0f; _gyro_scale.z_offset = 0; _gyro_scale.z_scale = 1.0f; memset(&_call, 0, sizeof(_call)); } BMI160::~BMI160() { /* make sure we are truly inactive */ stop(); /* delete the gyro subdriver */ delete _gyro; /* free any existing reports */ if (_accel_reports != nullptr) { delete _accel_reports; } if (_gyro_reports != nullptr) { delete _gyro_reports; } if (_accel_class_instance != -1) { unregister_class_devname(ACCEL_BASE_DEVICE_PATH, _accel_class_instance); } /* delete the perf counter */ perf_free(_sample_perf); perf_free(_accel_reads); perf_free(_gyro_reads); perf_free(_bad_transfers); perf_free(_bad_registers); perf_free(_good_transfers); perf_free(_reset_retries); perf_free(_duplicates); } int BMI160::init() { int ret; /* do SPI init (and probe) first */ ret = SPI::init(); /* if probe/setup failed, bail now */ if (ret != OK) { DEVICE_DEBUG("SPI setup failed"); return ret; } /* allocate basic report buffers */ _accel_reports = new ringbuffer::RingBuffer(2, sizeof(accel_report)); if (_accel_reports == nullptr) { goto out; } _gyro_reports = new ringbuffer::RingBuffer(2, sizeof(gyro_report)); if (_gyro_reports == nullptr) { goto out; } if (reset() != OK) { goto out; } /* Initialize offsets and scales */ _accel_scale.x_offset = 0; _accel_scale.x_scale = 1.0f; _accel_scale.y_offset = 0; _accel_scale.y_scale = 1.0f; _accel_scale.z_offset = 0; _accel_scale.z_scale = 1.0f; _gyro_scale.x_offset = 0; _gyro_scale.x_scale = 1.0f; _gyro_scale.y_offset = 0; _gyro_scale.y_scale = 1.0f; _gyro_scale.z_offset = 0; _gyro_scale.z_scale = 1.0f; /* do CDev init for the gyro device node, keep it optional */ ret = _gyro->init(); /* if probe/setup failed, bail now */ if (ret != OK) { DEVICE_DEBUG("gyro init failed"); return ret; } _accel_class_instance = register_class_devname(ACCEL_BASE_DEVICE_PATH); measure(); /* advertise sensor topic, measure manually to initialize valid report */ struct accel_report arp; _accel_reports->get(&arp); /* measurement will have generated a report, publish */ _accel_topic = orb_advertise_multi(ORB_ID(sensor_accel), &arp, &_accel_orb_class_instance, (external()) ? ORB_PRIO_MAX - 1 : ORB_PRIO_HIGH - 1); if (_accel_topic == nullptr) { warnx("ADVERT FAIL"); } /* advertise sensor topic, measure manually to initialize valid report */ struct gyro_report grp; _gyro_reports->get(&grp); _gyro->_gyro_topic = orb_advertise_multi(ORB_ID(sensor_gyro), &grp, &_gyro->_gyro_orb_class_instance, (external()) ? ORB_PRIO_MAX - 1 : ORB_PRIO_HIGH - 1); if (_gyro->_gyro_topic == nullptr) { warnx("ADVERT FAIL"); } out: return ret; } int BMI160::reset() { write_reg(BMIREG_CONF, (1 << 1)); //Enable NVM programming write_checked_reg(BMIREG_ACC_CONF, BMI_ACCEL_US | BMI_ACCEL_BWP_NORMAL); //Normal operation, no decimation write_checked_reg(BMIREG_ACC_RANGE, 0); write_checked_reg(BMIREG_GYR_CONF, BMI_GYRO_BWP_NORMAL); //Normal operation, no decimation write_checked_reg(BMIREG_GYR_RANGE, 0); write_checked_reg(BMIREG_INT_EN_1, BMI_DRDY_INT_EN); //Enable DRDY interrupt write_checked_reg(BMIREG_INT_OUT_CTRL, BMI_INT1_EN); //Enable interrupts on pin INT1 write_checked_reg(BMIREG_INT_MAP_1, BMI_DRDY_INT1); //DRDY interrupt on pin INT1 write_checked_reg(BMIREG_IF_CONF, BMI_SPI_4_WIRE | BMI_AUTO_DIS_SEC); //Disable secondary interface; Work in SPI 4-wire mode write_checked_reg(BMIREG_NV_CONF, BMI_SPI); //Disable I2C interface set_accel_range(BMI160_ACCEL_DEFAULT_RANGE_G); accel_set_sample_rate(BMI160_ACCEL_DEFAULT_RATE); set_gyro_range(BMI160_GYRO_DEFAULT_RANGE_DPS); gyro_set_sample_rate(BMI160_GYRO_DEFAULT_RATE); //_set_dlpf_filter(BMI160_ACCEL_DEFAULT_ONCHIP_FILTER_FREQ); //NOT CONSIDERING FILTERING YET //Enable Accelerometer in normal mode write_reg(BMIREG_CMD, BMI_ACCEL_NORMAL_MODE); up_udelay(4100); //usleep(4100); //Enable Gyroscope in normal mode write_reg(BMIREG_CMD, BMI_GYRO_NORMAL_MODE); up_udelay(80300); //usleep(80300); uint8_t retries = 10; while (retries--) { bool all_ok = true; for (uint8_t i = 0; i < BMI160_NUM_CHECKED_REGISTERS; i++) { if (read_reg(_checked_registers[i]) != _checked_values[i]) { write_reg(_checked_registers[i], _checked_values[i]); all_ok = false; } } if (all_ok) { break; } } _accel_reads = 0; _gyro_reads = 0; return OK; } int BMI160::probe() { /* look for device ID */ _whoami = read_reg(BMIREG_CHIP_ID); // verify product revision switch (_whoami) { case BMI160_WHO_AM_I: memset(_checked_values, 0, sizeof(_checked_values)); memset(_checked_bad, 0, sizeof(_checked_bad)); _checked_values[0] = _whoami; _checked_bad[0] = _whoami; return OK; } DEVICE_DEBUG("unexpected whoami 0x%02x", _whoami); return -EIO; } int BMI160::accel_set_sample_rate(float frequency) { uint8_t setbits = 0; uint8_t clearbits = (BMI_ACCEL_RATE_25_8 | BMI_ACCEL_RATE_1600); if ((int)frequency == 0) { frequency = 1600; } if (frequency <= 25 / 32) { setbits |= BMI_ACCEL_RATE_25_32; _accel_sample_rate = 25 / 32; } else if (frequency <= 25 / 16) { setbits |= BMI_ACCEL_RATE_25_16; _accel_sample_rate = 25 / 16; } else if (frequency <= 25 / 8) { setbits |= BMI_ACCEL_RATE_25_8; _accel_sample_rate = 25 / 8; } else if (frequency <= 25 / 4) { setbits |= BMI_ACCEL_RATE_25_4; _accel_sample_rate = 25 / 4; } else if (frequency <= 25 / 2) { setbits |= BMI_ACCEL_RATE_25_2; _accel_sample_rate = 25 / 2; } else if (frequency <= 25) { setbits |= BMI_ACCEL_RATE_25; _accel_sample_rate = 25; } else if (frequency <= 50) { setbits |= BMI_ACCEL_RATE_50; _accel_sample_rate = 50; } else if (frequency <= 100) { setbits |= BMI_ACCEL_RATE_100; _accel_sample_rate = 100; } else if (frequency <= 200) { setbits |= BMI_ACCEL_RATE_200; _accel_sample_rate = 200; } else if (frequency <= 400) { setbits |= BMI_ACCEL_RATE_400; _accel_sample_rate = 400; } else if (frequency <= 800) { setbits |= BMI_ACCEL_RATE_800; _accel_sample_rate = 800; } else if (frequency > 800) { setbits |= BMI_ACCEL_RATE_1600; _accel_sample_rate = 1600; } else { return -EINVAL; } modify_reg(BMIREG_ACC_CONF, clearbits, setbits); return OK; } int BMI160::gyro_set_sample_rate(float frequency) { uint8_t setbits = 0; uint8_t clearbits = (BMI_GYRO_RATE_200 | BMI_GYRO_RATE_25); if ((int)frequency == 0) { frequency = 3200; } if (frequency <= 25) { setbits |= BMI_GYRO_RATE_25; _gyro_sample_rate = 25; } else if (frequency <= 50) { setbits |= BMI_GYRO_RATE_50; _gyro_sample_rate = 50; } else if (frequency <= 100) { setbits |= BMI_GYRO_RATE_100; _gyro_sample_rate = 100; } else if (frequency <= 200) { setbits |= BMI_GYRO_RATE_200; _gyro_sample_rate = 200; } else if (frequency <= 400) { setbits |= BMI_GYRO_RATE_400; _gyro_sample_rate = 400; } else if (frequency <= 800) { setbits |= BMI_GYRO_RATE_800; _gyro_sample_rate = 800; } else if (frequency <= 1600) { setbits |= BMI_GYRO_RATE_1600; _gyro_sample_rate = 1600; } else if (frequency > 1600) { setbits |= BMI_GYRO_RATE_3200; _gyro_sample_rate = 3200; } else { return -EINVAL; } modify_reg(BMIREG_GYR_CONF, clearbits, setbits); return OK; } void BMI160::_set_dlpf_filter(uint16_t bandwidth) { _dlpf_freq = 0; bandwidth = bandwidth; //TO BE IMPLEMENTED /*uint8_t setbits = BW_SCAL_ODR_BW_XL; uint8_t clearbits = BW_XL_50_HZ; if (bandwidth == 0) { _dlpf_freq = 408; clearbits = BW_SCAL_ODR_BW_XL | BW_XL_50_HZ; setbits = 0; } if (bandwidth <= 50) { setbits |= BW_XL_50_HZ; _dlpf_freq = 50; } else if (bandwidth <= 105) { setbits |= BW_XL_105_HZ; _dlpf_freq = 105; } else if (bandwidth <= 211) { setbits |= BW_XL_211_HZ; _dlpf_freq = 211; } else if (bandwidth <= 408) { setbits |= BW_XL_408_HZ; _dlpf_freq = 408; } modify_reg(CTRL_REG6_XL, clearbits, setbits);*/ } ssize_t BMI160::read(struct file *filp, char *buffer, size_t buflen) { unsigned count = buflen / sizeof(accel_report); /* buffer must be large enough */ if (count < 1) { return -ENOSPC; } /* if automatic measurement is not enabled, get a fresh measurement into the buffer */ if (_call_interval == 0) { _accel_reports->flush(); measure(); } /* if no data, error (we could block here) */ if (_accel_reports->empty()) { return -EAGAIN; } perf_count(_accel_reads); /* copy reports out of our buffer to the caller */ accel_report *arp = reinterpret_cast(buffer); int transferred = 0; while (count--) { if (!_accel_reports->get(arp)) { break; } transferred++; arp++; } /* return the number of bytes transferred */ return (transferred * sizeof(accel_report)); } int BMI160::self_test() { if (perf_event_count(_sample_perf) == 0) { measure(); } /* return 0 on success, 1 else */ return (perf_event_count(_sample_perf) > 0) ? 0 : 1; } int BMI160::accel_self_test() { if (self_test()) { return 1; } return 0; } int BMI160::gyro_self_test() { if (self_test()) { return 1; } /* * Maximum deviation of 10 degrees */ const float max_offset = (float)(10 * M_PI_F / 180.0f); /* 30% scale error is chosen to catch completely faulty units but * to let some slight scale error pass. Requires a rate table or correlation * with mag rotations + data fit to * calibrate properly and is not done by default. */ const float max_scale = 0.3f; /* evaluate gyro offsets, complain if offset -> zero or larger than 30 dps. */ if (fabsf(_gyro_scale.x_offset) > max_offset) { return 1; } /* evaluate gyro scale, complain if off by more than 30% */ if (fabsf(_gyro_scale.x_scale - 1.0f) > max_scale) { return 1; } if (fabsf(_gyro_scale.y_offset) > max_offset) { return 1; } if (fabsf(_gyro_scale.y_scale - 1.0f) > max_scale) { return 1; } if (fabsf(_gyro_scale.z_offset) > max_offset) { return 1; } if (fabsf(_gyro_scale.z_scale - 1.0f) > max_scale) { return 1; } return 0; } /* deliberately trigger an error in the sensor to trigger recovery */ void BMI160::test_error() { write_reg(BMIREG_CMD, BMI160_SOFT_RESET); ::printf("error triggered\n"); print_registers(); } ssize_t BMI160::gyro_read(struct file *filp, char *buffer, size_t buflen) { unsigned count = buflen / sizeof(gyro_report); /* buffer must be large enough */ if (count < 1) { return -ENOSPC; } /* if automatic measurement is not enabled, get a fresh measurement into the buffer */ if (_call_interval == 0) { _gyro_reports->flush(); measure(); } /* if no data, error (we could block here) */ if (_gyro_reports->empty()) { return -EAGAIN; } perf_count(_gyro_reads); /* copy reports out of our buffer to the caller */ gyro_report *grp = reinterpret_cast(buffer); int transferred = 0; while (count--) { if (!_gyro_reports->get(grp)) { break; } transferred++; grp++; } /* return the number of bytes transferred */ return (transferred * sizeof(gyro_report)); } int BMI160::ioctl(struct file *filp, int cmd, unsigned long arg) { switch (cmd) { case SENSORIOCRESET: return reset(); case SENSORIOCSPOLLRATE: { switch (arg) { /* switching to manual polling */ case SENSOR_POLLRATE_MANUAL: stop(); _call_interval = 0; return OK; /* external signalling not supported */ case SENSOR_POLLRATE_EXTERNAL: /* zero would be bad */ case 0: return -EINVAL; /* set default/max polling rate */ case SENSOR_POLLRATE_MAX: return ioctl(filp, SENSORIOCSPOLLRATE, BMI160_GYRO_MAX_RATE); case SENSOR_POLLRATE_DEFAULT: if (BMI160_GYRO_DEFAULT_RATE > BMI160_ACCEL_DEFAULT_RATE) { return ioctl(filp, SENSORIOCSPOLLRATE, BMI160_GYRO_DEFAULT_RATE); } else { return ioctl(filp, SENSORIOCSPOLLRATE, BMI160_ACCEL_DEFAULT_RATE); //Polling at the highest frequency. We may get duplicate values on the sensors } /* adjust to a legal polling interval in Hz */ default: { /* do we need to start internal polling? */ bool want_start = (_call_interval == 0); /* convert hz to hrt interval via microseconds */ unsigned ticks = 1000000 / arg; /* check against maximum sane rate */ if (ticks < 1000) { return -EINVAL; } // adjust filters float cutoff_freq_hz = _accel_filter_x.get_cutoff_freq(); float sample_rate = 1.0e6f / ticks; _set_dlpf_filter(cutoff_freq_hz); _accel_filter_x.set_cutoff_frequency(sample_rate, cutoff_freq_hz); _accel_filter_y.set_cutoff_frequency(sample_rate, cutoff_freq_hz); _accel_filter_z.set_cutoff_frequency(sample_rate, cutoff_freq_hz); float cutoff_freq_hz_gyro = _gyro_filter_x.get_cutoff_freq(); _set_dlpf_filter(cutoff_freq_hz_gyro); _gyro_filter_x.set_cutoff_frequency(sample_rate, cutoff_freq_hz_gyro); _gyro_filter_y.set_cutoff_frequency(sample_rate, cutoff_freq_hz_gyro); _gyro_filter_z.set_cutoff_frequency(sample_rate, cutoff_freq_hz_gyro); /* update interval for next measurement */ /* XXX this is a bit shady, but no other way to adjust... */ _call_interval = ticks; /* set call interval faster then the sample time. We then detect when we have duplicate samples and reject them. This prevents aliasing due to a beat between the stm32 clock and the bmi160 clock */ _call.period = _call_interval - BMI160_TIMER_REDUCTION; /* if we need to start the poll state machine, do it */ if (want_start) { start(); } return OK; } } } case SENSORIOCGPOLLRATE: if (_call_interval == 0) { return SENSOR_POLLRATE_MANUAL; } return 1000000 / _call_interval; case SENSORIOCSQUEUEDEPTH: { /* lower bound is mandatory, upper bound is a sanity check */ if ((arg < 1) || (arg > 100)) { return -EINVAL; } irqstate_t flags = px4_enter_critical_section(); if (!_accel_reports->resize(arg)) { px4_leave_critical_section(flags); return -ENOMEM; } px4_leave_critical_section(flags); return OK; } case ACCELIOCGSAMPLERATE: return _accel_sample_rate; case ACCELIOCSSAMPLERATE: return accel_set_sample_rate(arg); case ACCELIOCSSCALE: { /* copy scale, but only if off by a few percent */ struct accel_calibration_s *s = (struct accel_calibration_s *) arg; float sum = s->x_scale + s->y_scale + s->z_scale; if (sum > 2.0f && sum < 4.0f) { memcpy(&_accel_scale, s, sizeof(_accel_scale)); return OK; } else { return -EINVAL; } } case ACCELIOCGSCALE: /* copy scale out */ memcpy((struct accel_calibration_s *) arg, &_accel_scale, sizeof(_accel_scale)); return OK; case ACCELIOCSRANGE: return set_accel_range(arg); case ACCELIOCGRANGE: return (unsigned long)((_accel_range_m_s2) / CONSTANTS_ONE_G + 0.5f); case ACCELIOCSELFTEST: return accel_self_test(); default: /* give it to the superclass */ return SPI::ioctl(filp, cmd, arg); } } int BMI160::gyro_ioctl(struct file *filp, int cmd, unsigned long arg) { switch (cmd) { /* these are shared with the accel side */ case SENSORIOCSPOLLRATE: case SENSORIOCGPOLLRATE: case SENSORIOCRESET: return ioctl(filp, cmd, arg); case SENSORIOCSQUEUEDEPTH: { /* lower bound is mandatory, upper bound is a sanity check */ if ((arg < 1) || (arg > 100)) { return -EINVAL; } irqstate_t flags = px4_enter_critical_section(); if (!_gyro_reports->resize(arg)) { px4_leave_critical_section(flags); return -ENOMEM; } px4_leave_critical_section(flags); return OK; } case GYROIOCGSAMPLERATE: return _gyro_sample_rate; case GYROIOCSSAMPLERATE: return gyro_set_sample_rate(arg); case GYROIOCSSCALE: /* copy scale in */ memcpy(&_gyro_scale, (struct gyro_calibration_s *) arg, sizeof(_gyro_scale)); return OK; case GYROIOCGSCALE: /* copy scale out */ memcpy((struct gyro_calibration_s *) arg, &_gyro_scale, sizeof(_gyro_scale)); return OK; case GYROIOCSRANGE: return set_gyro_range(arg); case GYROIOCGRANGE: return (unsigned long)(_gyro_range_rad_s * 180.0f / M_PI_F + 0.5f); case GYROIOCSELFTEST: return gyro_self_test(); default: /* give it to the superclass */ return SPI::ioctl(filp, cmd, arg); } } uint8_t BMI160::read_reg(unsigned reg) { uint8_t cmd[2] = { (uint8_t)(reg | DIR_READ), 0}; transfer(cmd, cmd, sizeof(cmd)); return cmd[1]; } uint16_t BMI160::read_reg16(unsigned reg) { uint8_t cmd[3] = { (uint8_t)(reg | DIR_READ), 0, 0 }; transfer(cmd, cmd, sizeof(cmd)); return (uint16_t)(cmd[1] << 8) | cmd[2]; } void BMI160::write_reg(unsigned reg, uint8_t value) { uint8_t cmd[2]; cmd[0] = reg | DIR_WRITE; cmd[1] = value; transfer(cmd, nullptr, sizeof(cmd)); } void BMI160::modify_reg(unsigned reg, uint8_t clearbits, uint8_t setbits) { uint8_t val; val = read_reg(reg); val &= ~clearbits; val |= setbits; write_checked_reg(reg, val); } void BMI160::write_checked_reg(unsigned reg, uint8_t value) { write_reg(reg, value); for (uint8_t i = 0; i < BMI160_NUM_CHECKED_REGISTERS; i++) { if (reg == _checked_registers[i]) { _checked_values[i] = value; _checked_bad[i] = value; } } } int BMI160::set_accel_range(unsigned max_g) { uint8_t setbits = 0; uint8_t clearbits = BMI_ACCEL_RANGE_2_G | BMI_ACCEL_RANGE_16_G; float lsb_per_g; float max_accel_g; if (max_g == 0) { max_g = 16; } if (max_g <= 2) { max_accel_g = 2; setbits |= BMI_ACCEL_RANGE_2_G; lsb_per_g = 16384; } else if (max_g <= 4) { max_accel_g = 4; setbits |= BMI_ACCEL_RANGE_4_G; lsb_per_g = 8192; } else if (max_g <= 8) { max_accel_g = 8; setbits |= BMI_ACCEL_RANGE_8_G; lsb_per_g = 4096; } else if (max_g <= 16) { max_accel_g = 16; setbits |= BMI_ACCEL_RANGE_16_G; lsb_per_g = 2048; } else { return -EINVAL; } _accel_range_scale = (CONSTANTS_ONE_G / lsb_per_g); _accel_range_m_s2 = max_accel_g * CONSTANTS_ONE_G; modify_reg(BMIREG_ACC_RANGE, clearbits, setbits); return OK; } int BMI160::set_gyro_range(unsigned max_dps) { uint8_t setbits = 0; uint8_t clearbits = BMI_GYRO_RANGE_125_DPS | BMI_GYRO_RANGE_250_DPS; float lsb_per_dps; float max_gyro_dps; if (max_dps == 0) { max_dps = 2000; } if (max_dps <= 125) { max_gyro_dps = 125; lsb_per_dps = 262.4; setbits |= BMI_GYRO_RANGE_125_DPS; } else if (max_dps <= 250) { max_gyro_dps = 250; lsb_per_dps = 131.2; setbits |= BMI_GYRO_RANGE_250_DPS; } else if (max_dps <= 500) { max_gyro_dps = 500; lsb_per_dps = 65.6; setbits |= BMI_GYRO_RANGE_500_DPS; } else if (max_dps <= 1000) { max_gyro_dps = 1000; lsb_per_dps = 32.8; setbits |= BMI_GYRO_RANGE_1000_DPS; } else if (max_dps <= 2000) { max_gyro_dps = 2000; lsb_per_dps = 16.4; setbits |= BMI_GYRO_RANGE_2000_DPS; } else { return -EINVAL; } _gyro_range_rad_s = (max_gyro_dps / 180.0f * M_PI_F); _gyro_range_scale = (M_PI_F / (180.0f * lsb_per_dps)); modify_reg(BMIREG_GYR_RANGE, clearbits, setbits); return OK; } void BMI160::start() { /* make sure we are stopped first */ stop(); /* discard any stale data in the buffers */ _accel_reports->flush(); _gyro_reports->flush(); /* start polling at the specified rate */ hrt_call_every(&_call, 1000, _call_interval - BMI160_TIMER_REDUCTION, (hrt_callout)&BMI160::measure_trampoline, this); reset(); } void BMI160::stop() { hrt_cancel(&_call); } void BMI160::measure_trampoline(void *arg) { BMI160 *dev = reinterpret_cast(arg); /* make another measurement */ dev->measure(); } void BMI160::check_registers(void) { uint8_t v; if ((v = read_reg(_checked_registers[_checked_next])) != _checked_values[_checked_next]) { _checked_bad[_checked_next] = v; /* if we get the wrong value then we know the SPI bus or sensor is very sick. We set _register_wait to 20 and wait until we have seen 20 good values in a row before we consider the sensor to be OK again. */ perf_count(_bad_registers); /* try to fix the bad register value. We only try to fix one per loop to prevent a bad sensor hogging the bus. */ if (_register_wait == 0 || _checked_next == 0) { // if the product_id is wrong then reset the // sensor completely write_reg(BMIREG_CMD, BMI160_SOFT_RESET); _reset_wait = hrt_absolute_time() + 10000; _checked_next = 0; } else { write_reg(_checked_registers[_checked_next], _checked_values[_checked_next]); // waiting 3ms between register writes seems // to raise the chance of the sensor // recovering considerably _reset_wait = hrt_absolute_time() + 3000; } _register_wait = 20; } _checked_next = (_checked_next + 1) % BMI160_NUM_CHECKED_REGISTERS; } void BMI160::measure() { if (hrt_absolute_time() < _reset_wait) { // we're waiting for a reset to complete return; } struct BMIReport bmi_report; struct Report { int16_t accel_x; int16_t accel_y; int16_t accel_z; int16_t temp; int16_t gyro_x; int16_t gyro_y; int16_t gyro_z; } report; /* start measuring */ perf_begin(_sample_perf); /* * Fetch the full set of measurements from the BMI160 in one pass. */ bmi_report.cmd = BMIREG_GYR_X_L | DIR_READ; uint8_t status = read_reg(BMIREG_STATUS); if (OK != transfer((uint8_t *)&bmi_report, ((uint8_t *)&bmi_report), sizeof(bmi_report))) { return; } check_registers(); if ((!(status & (0x80))) && (!(status & (0x04)))) { perf_end(_sample_perf); perf_count(_duplicates); _got_duplicate = true; return; } _last_accel[0] = bmi_report.accel_x; _last_accel[1] = bmi_report.accel_y; _last_accel[2] = bmi_report.accel_z; _got_duplicate = false; uint8_t temp_l = read_reg(BMIREG_TEMP_0); uint8_t temp_h = read_reg(BMIREG_TEMP_1); report.temp = ((temp_h << 8) + temp_l); report.accel_x = bmi_report.accel_x; report.accel_y = bmi_report.accel_y; report.accel_z = bmi_report.accel_z; report.gyro_x = bmi_report.gyro_x; report.gyro_y = bmi_report.gyro_y; report.gyro_z = bmi_report.gyro_z; if (report.accel_x == 0 && report.accel_y == 0 && report.accel_z == 0 && report.temp == 0 && report.gyro_x == 0 && report.gyro_y == 0 && report.gyro_z == 0) { // all zero data - probably a SPI bus error perf_count(_bad_transfers); perf_end(_sample_perf); // note that we don't call reset() here as a reset() // costs 20ms with interrupts disabled. That means if // the bmi160 does go bad it would cause a FMU failure, // regardless of whether another sensor is available, return; } perf_count(_good_transfers); if (_register_wait != 0) { // we are waiting for some good transfers before using // the sensor again. We still increment // _good_transfers, but don't return any data yet _register_wait--; return; } /* * Report buffers. */ accel_report arb; gyro_report grb; /* * Adjust and scale results to m/s^2. */ grb.timestamp = arb.timestamp = hrt_absolute_time(); // report the error count as the sum of the number of bad // transfers and bad register reads. This allows the higher // level code to decide if it should use this sensor based on // whether it has had failures grb.error_count = arb.error_count = perf_event_count(_bad_transfers) + perf_event_count(_bad_registers); /* * 1) Scale raw value to SI units using scaling from datasheet. * 2) Subtract static offset (in SI units) * 3) Scale the statically calibrated values with a linear * dynamically obtained factor * * Note: the static sensor offset is the number the sensor outputs * at a nominally 'zero' input. Therefore the offset has to * be subtracted. * * Example: A gyro outputs a value of 74 at zero angular rate * the offset is 74 from the origin and subtracting * 74 from all measurements centers them around zero. */ /* NOTE: Axes have been swapped to match the board a few lines above. */ arb.x_raw = report.accel_x; arb.y_raw = report.accel_y; arb.z_raw = report.accel_z; float xraw_f = report.accel_x; float yraw_f = report.accel_y; float zraw_f = report.accel_z; // apply user specified rotation rotate_3f(_rotation, xraw_f, yraw_f, zraw_f); float x_in_new = ((xraw_f * _accel_range_scale) - _accel_scale.x_offset) * _accel_scale.x_scale; float y_in_new = ((yraw_f * _accel_range_scale) - _accel_scale.y_offset) * _accel_scale.y_scale; float z_in_new = ((zraw_f * _accel_range_scale) - _accel_scale.z_offset) * _accel_scale.z_scale; arb.x = _accel_filter_x.apply(x_in_new); arb.y = _accel_filter_y.apply(y_in_new); arb.z = _accel_filter_z.apply(z_in_new); matrix::Vector3f aval(x_in_new, y_in_new, z_in_new); matrix::Vector3f aval_integrated; bool accel_notify = _accel_int.put(arb.timestamp, aval, aval_integrated, arb.integral_dt); arb.x_integral = aval_integrated(0); arb.y_integral = aval_integrated(1); arb.z_integral = aval_integrated(2); arb.scaling = _accel_range_scale; arb.range_m_s2 = _accel_range_m_s2; _last_temperature = 23 + report.temp * 1.0f / 512.0f; arb.temperature_raw = report.temp; arb.temperature = _last_temperature; /* return device ID */ arb.device_id = _device_id.devid; grb.x_raw = report.gyro_x; grb.y_raw = report.gyro_y; grb.z_raw = report.gyro_z; xraw_f = report.gyro_x; yraw_f = report.gyro_y; zraw_f = report.gyro_z; // apply user specified rotation rotate_3f(_rotation, xraw_f, yraw_f, zraw_f); float x_gyro_in_new = ((xraw_f * _gyro_range_scale) - _gyro_scale.x_offset) * _gyro_scale.x_scale; float y_gyro_in_new = ((yraw_f * _gyro_range_scale) - _gyro_scale.y_offset) * _gyro_scale.y_scale; float z_gyro_in_new = ((zraw_f * _gyro_range_scale) - _gyro_scale.z_offset) * _gyro_scale.z_scale; grb.x = _gyro_filter_x.apply(x_gyro_in_new); grb.y = _gyro_filter_y.apply(y_gyro_in_new); grb.z = _gyro_filter_z.apply(z_gyro_in_new); matrix::Vector3f gval(x_gyro_in_new, y_gyro_in_new, z_gyro_in_new); matrix::Vector3f gval_integrated; bool gyro_notify = _gyro_int.put(arb.timestamp, gval, gval_integrated, grb.integral_dt); grb.x_integral = gval_integrated(0); grb.y_integral = gval_integrated(1); grb.z_integral = gval_integrated(2); grb.scaling = _gyro_range_scale; grb.range_rad_s = _gyro_range_rad_s; grb.temperature_raw = report.temp; grb.temperature = _last_temperature; /* return device ID */ grb.device_id = _gyro->_device_id.devid; _accel_reports->force(&arb); _gyro_reports->force(&grb); /* notify anyone waiting for data */ if (accel_notify) { poll_notify(POLLIN); } if (gyro_notify) { _gyro->parent_poll_notify(); } if (accel_notify && !(_pub_blocked)) { /* log the time of this report */ perf_begin(_controller_latency_perf); /* publish it */ orb_publish(ORB_ID(sensor_accel), _accel_topic, &arb); } if (gyro_notify && !(_pub_blocked)) { /* publish it */ orb_publish(ORB_ID(sensor_gyro), _gyro->_gyro_topic, &grb); } /* stop measuring */ perf_end(_sample_perf); } void BMI160::print_info() { perf_print_counter(_sample_perf); perf_print_counter(_accel_reads); perf_print_counter(_gyro_reads); perf_print_counter(_bad_transfers); perf_print_counter(_bad_registers); perf_print_counter(_good_transfers); perf_print_counter(_reset_retries); perf_print_counter(_duplicates); _accel_reports->print_info("accel queue"); _gyro_reports->print_info("gyro queue"); ::printf("checked_next: %u\n", _checked_next); for (uint8_t i = 0; i < BMI160_NUM_CHECKED_REGISTERS; i++) { uint8_t v = read_reg(_checked_registers[i]); if (v != _checked_values[i]) { ::printf("reg %02x:%02x should be %02x\n", (unsigned)_checked_registers[i], (unsigned)v, (unsigned)_checked_values[i]); } if (v != _checked_bad[i]) { ::printf("reg %02x:%02x was bad %02x\n", (unsigned)_checked_registers[i], (unsigned)v, (unsigned)_checked_bad[i]); } } ::printf("temperature: %.1f\n", (double)_last_temperature); } void BMI160::print_registers() { printf("BMI160 registers\n"); for (uint8_t reg = 0x40; reg <= 0x47; reg++) { uint8_t v = read_reg(reg); printf("%02x:%02x ", (unsigned)reg, (unsigned)v); if (reg % 13 == 0) { printf("\n"); } } printf("\n"); }