int mma8652_init(mma8652_t *dev, i2c_t i2c, uint8_t address, uint8_t dr, uint8_t range, uint8_t type)
{
uint8_t reg;
/* write device descriptor */
dev->i2c = i2c;
dev->addr = address;
dev->initialized = false;
if (dr > MMA8652_DATARATE_1HZ56 || range > MMA8652_FS_RANGE_8G || type >= MMA8x5x_TYPE_MAX) {
return -1;
}
dev->type = type;
i2c_acquire(dev->i2c);
/* initialize the I2C bus */
if (i2c_init_master(i2c, I2C_SPEED) < 0) {
i2c_release(dev->i2c);
return -2;
}
i2c_release(dev->i2c);
if (mma8652_test(dev)) {
return -3;
}
if (mma8652_set_standby(dev) < 0) {
return -4;
}
reg = MMA8652_XYZ_DATA_CFG_FS(range);
i2c_acquire(dev->i2c);
if (i2c_write_regs(dev->i2c, dev->addr, MMA8652_XYZ_DATA_CFG, ®, 1) != 1) {
i2c_release(dev->i2c);
return -5;
}
reg = MMA8652_CTRL_REG1_DR(dr);
if (i2c_write_regs(dev->i2c, dev->addr, MMA8652_CTRL_REG1, ®, 1) != 1) {
i2c_release(dev->i2c);
return -5;
}
i2c_release(dev->i2c);
dev->initialized = true;
dev->scale = 1024 >> range;
return 0;
}
int mpl3115a2_init(mpl3115a2_t *dev, const mpl3115a2_params_t *params)
{
uint8_t reg;
assert(dev);
assert(params);
/* write device descriptor */
memcpy(dev, params, sizeof(mpl3115a2_params_t));
i2c_acquire(BUS);
/* test device */
if (i2c_read_regs(BUS, ADDR, MPL3115A2_WHO_AM_I, ®, 1, 0) < 0) {
/* Release the bus for other threads. */
i2c_release(BUS);
LOG_ERROR("mpl3115a2_init: I2C error!\n");
return -MPL3115A2_ERROR_I2C;
}
if (reg != MPL3115A2_ID) {
LOG_ERROR("mpl3115a2_init: invalid WHO_AM_I value (0x%02x)!\n", (int)reg);
return -MPL3115A2_ERROR_DEV;
}
/* set sample rate */
reg = MPL3115A2_CTRL_REG1_OS(dev->params.ratio);
if (i2c_write_regs(BUS, ADDR, MPL3115A2_CTRL_REG1, ®, 1, 0) < 0) {
i2c_release(BUS);
LOG_ERROR("mpl3115a2_init: failed to set sample rate!\n");
return -MPL3115A2_ERROR_CNF;
}
/* configure device */
reg = MPL3115A2_PT_DATA_CFG_TDEFE |
MPL3115A2_PT_DATA_CFG_PDEFE |
MPL3115A2_PT_DATA_CFG_DREM;
if (i2c_write_regs(BUS, ADDR, MPL3115A2_PT_DATA_CFG, ®, 1, 0) < 0) {
i2c_release(BUS);
LOG_ERROR("mpl3115a2_init: config failure!\n");
return -MPL3115A2_ERROR_CNF;
}
i2c_release(BUS);
return MPL3115A2_OK;
}
static int _reg_write(const ccs811_t *dev, uint8_t reg, uint8_t *data, uint32_t len)
{
DEBUG_DEV("write %"PRIu32" bytes to sensor registers starting at addr %02x",
dev, len, reg);
int res = CCS811_OK;
if (ENABLE_DEBUG && data && len) {
printf("[css811] %s dev=%d addr=%02x: write following bytes: ",
__func__, dev->params.i2c_dev, dev->params.i2c_addr);
for (unsigned i = 0; i < len; i++) {
printf("%02x ", data[i]);
}
printf("\n");
}
if (i2c_acquire(dev->params.i2c_dev)) {
DEBUG_DEV("could not aquire I2C bus", dev);
return -CCS811_ERROR_I2C;
}
#if MODULE_CCS811_FULL
if (dev->params.wake_pin != GPIO_UNDEF) {
/* wake the sensor with low active WAKE signal */
gpio_clear(dev->params.wake_pin);
/* t_WAKE is 50 us */
xtimer_usleep(50);
}
#endif
if (!data || !len) {
res = i2c_write_byte(dev->params.i2c_dev, dev->params.i2c_addr, reg, 0);
}
else {
res = i2c_write_regs(dev->params.i2c_dev, dev->params.i2c_addr, reg, data, len, 0);
}
i2c_release(dev->params.i2c_dev);
#if MODULE_CCS811_FULL
if (dev->params.wake_pin != GPIO_UNDEF) {
/* let the sensor enter to sleep mode */
gpio_set(dev->params.wake_pin);
/* minimum t_DWAKE is 20 us */
xtimer_usleep(20);
}
#endif
if (res != CCS811_OK) {
DEBUG_DEV("could not write %"PRIu32" bytes to sensor registers "
"starting at addr %02x, reason %i", dev, len, reg, res);
return -CCS811_ERROR_I2C;
}
return CCS811_OK;
}
static int jc42_set_register(const jc42_t* dev, uint8_t reg, uint16_t* data)
{
i2c_acquire(dev->i2c);
if (i2c_write_regs(dev->i2c, dev->addr, reg, data, 2, 0) != 0) {
DEBUG("[jc42] Problem writing to register 0x%x\n", reg);
i2c_release(dev->i2c);
return JC42_NODEV;
}
i2c_release(dev->i2c);
return JC42_OK;
}
int mpl3115a2_reset(const mpl3115a2_t *dev)
{
uint8_t reg;
i2c_acquire(BUS);
reg = MPL3115A2_CTRL_REG1_RST;
if (i2c_write_regs(BUS, ADDR, MPL3115A2_CTRL_REG1, ®, 1, 0) < 0) {
i2c_release(BUS);
LOG_ERROR("mpl3115a2_reset: failed!\n");
return -MPL3115A2_ERROR_I2C;
}
i2c_release(BUS);
return MPL3115A2_OK;
}
int mma8652_reset(mma8652_t *dev)
{
uint8_t reg;
dev->initialized = false;
reg = MMA8652_CTRL_REG2_RST;
i2c_acquire(dev->i2c);
if (i2c_write_regs(dev->i2c, dev->addr, MMA8652_CTRL_REG2, ®, 1) != 1) {
i2c_release(dev->i2c);
return -1;
}
i2c_release(dev->i2c);
return 0;
}
int cmd_write_reg(int argc, char **argv)
{
int res;
uint8_t addr, reg;
int length = argc - 3;
char data[BUFSIZE];
if (i2c_dev < 0) {
puts("Error: no I2C device initialized");
return 1;
}
if (length < 1) {
puts("Error: not enough arguments given");
printf("Usage:\n%s ADDR REG BYTE0 [BYTE1 ...]\n", argv[0]);
return 1;
}
addr = (uint8_t)atoi(argv[1]);
reg = (uint8_t)atoi(argv[2]);
for (int i = 0; i < length; i++) {
data[i] = (char)atoi(argv[i + 3]);
}
if (length == 1) {
printf("i2c_write_reg(I2C_%i, 0x%02x, 0x%02x, 0x%02x)\n",
i2c_dev, addr, reg, (unsigned int)data[0]);
res = i2c_write_reg(i2c_dev, addr, reg, data[0]);
}
else {
printf("i2c_write_regs(I2C_%i, 0x%02x, 0x%02x, [", i2c_dev, addr, reg);
for (int i = 0; i < length; i++) {
printf("0x%02x, ", (unsigned int)data[i]);
}
puts("])");
res = i2c_write_regs(i2c_dev, addr, reg, data, length);
}
if (res < 1) {
puts("Error: no bytes were written");
return 1;
}
else {
printf("I2C_%i: successfully wrote %i bytes to register 0x%02x\n", i2c_dev, res, reg);
return 0;
}
}
int mma8652_set_user_offset(mma8652_t *dev, int8_t x, int8_t y, int8_t z)
{
uint8_t buf[3];
buf[0] = (uint8_t)x;
buf[1] = (uint8_t)y;
buf[2] = (uint8_t)z;
i2c_acquire(dev->i2c);
if (i2c_write_regs(dev->i2c, dev->addr, MMA8652_OFF_X, buf, 3) != 3) {
i2c_release(dev->i2c);
return -1;
}
i2c_release(dev->i2c);
return 0;
}
int hdc1000_reset(hdc1000_t *dev)
{
char reg[2];
uint16_t tmp = HDC1000_CONFG_RST;
reg[0] = (uint8_t)(tmp >> 8);
reg[1] = (uint8_t)tmp;
dev->initialized = false;
i2c_acquire(dev->i2c);
if (i2c_write_regs(dev->i2c, dev->addr, HDC1000_CONFG, reg, 2) != 2) {
i2c_release(dev->i2c);
return -1;
}
i2c_release(dev->i2c);
return 0;
}
int mpl3115a2_set_standby(const mpl3115a2_t *dev)
{
uint8_t reg;
i2c_acquire(BUS);
if (i2c_read_regs(BUS, ADDR, MPL3115A2_CTRL_REG1, ®, 1, 0) < 0) {
i2c_release(BUS);
return -MPL3115A2_ERROR_I2C;
}
reg &= ~MPL3115A2_CTRL_REG1_SBYB;
if (i2c_write_regs(BUS, ADDR, MPL3115A2_CTRL_REG1, ®, 1, 0) < 0) {
i2c_release(BUS);
return -MPL3115A2_ERROR_I2C;
}
i2c_release(BUS);
return MPL3115A2_OK;
}
int mma8652_set_standby(mma8652_t *dev)
{
uint8_t reg;
i2c_acquire(dev->i2c);
if (i2c_read_regs(dev->i2c, dev->addr, MMA8652_CTRL_REG1, ®, 1) != 1) {
i2c_release(dev->i2c);
return -1;
}
reg &= ~MMA8652_CTRL_REG1_ACTIVE;
if (i2c_write_regs(dev->i2c, dev->addr, MMA8652_CTRL_REG1, ®, 1) != 1) {
i2c_release(dev->i2c);
return -1;
}
i2c_release(dev->i2c);
return 0;
}
int adxl345_init(adxl345_t *dev, const adxl345_params_t* params)
{
uint8_t reg;
assert(dev && params);
/* get device descriptor */
dev->params = (adxl345_params_t*)params;
/* get scale_factor from full_res and range parameters */
dev->scale_factor = (dev->params->full_res ? 3.9 : (dev->params->range * 3.9));
/* Acquire exclusive access */
i2c_acquire(BUS);
/* test if the target device responds */
i2c_read_reg(BUS, ADDR, ACCEL_ADXL345_CHIP_ID_REG, ®, 0);
if (reg != ACCEL_ADXL345_CHIP_ID) {
i2c_release(BUS);
DEBUG("[adxl345] init - error: invalid id value [0x%02x]\n", (int)reg);
return ADXL345_NODEV;
}
/* configure the user offset */
i2c_write_regs(BUS, ADDR, ACCEL_ADXL345_OFFSET_X, dev->params->offset, 3, 0);
/* Basic device setup */
reg = (dev->params->full_res | dev->params->range);
i2c_write_reg(BUS, ADDR, ACCEL_ADXL345_DATA_FORMAT, reg, 0);
i2c_write_reg(BUS, ADDR, ACCEL_ADXL345_BW_RATE, dev->params->rate, 0);
/* Put device in measure mode */
i2c_write_reg(BUS, ADDR, ACCEL_ADXL345_POWER_CTL, MEASURE_BIT, 0);
/* Release the bus */
i2c_release(BUS);
DEBUG("[adxl345] init: successful\n");
return ADXL345_OK;
}
int hdc1000_init(hdc1000_t *dev, i2c_t i2c, uint8_t address)
{
char reg[2];
/* write device descriptor */
dev->i2c = i2c;
dev->addr = address;
dev->initialized = false;
i2c_acquire(dev->i2c);
/* initialize the I2C bus */
if (i2c_init_master(i2c, I2C_SPEED) < 0) {
i2c_release(dev->i2c);
return -1;
}
i2c_release(dev->i2c);
if (hdc1000_test(dev)) {
return -2;
}
/* set 14 bit resolution for both sensors and sequence mode */
uint16_t tmp = HDC1000_CONFG_SEQ_MOD;
reg[0] = (uint8_t)(tmp >> 8);
reg[1] = (uint8_t)tmp;
i2c_acquire(dev->i2c);
if (i2c_write_regs(dev->i2c, dev->addr, HDC1000_CONFG, reg, 2) != 2) {
i2c_release(dev->i2c);
return -3;
}
dev->initialized = true;
i2c_release(dev->i2c);
return 0;
}
int mma8652_set_active(mma8652_t *dev)
{
uint8_t reg;
if (dev->initialized == false) {
return -1;
}
i2c_acquire(dev->i2c);
if (i2c_read_regs(dev->i2c, dev->addr, MMA8652_CTRL_REG1, ®, 1) != 1) {
i2c_release(dev->i2c);
return -1;
}
reg |= MMA8652_CTRL_REG1_ACTIVE;
if (i2c_write_regs(dev->i2c, dev->addr, MMA8652_CTRL_REG1, ®, 1) != 1) {
i2c_release(dev->i2c);
return -1;
}
i2c_release(dev->i2c);
return 0;
}
int i2c_write_reg(i2c_t dev, uint8_t address, uint8_t reg, char data)
{
return i2c_write_regs(dev, address, reg, &data, 1);
}
int i2c_write_reg(i2c_t dev, uint16_t addr, uint16_t reg,
uint8_t data, uint8_t flags)
{
return i2c_write_regs(dev, addr, reg, &data, 1, flags);
}
int i2c_write_reg(i2c_t bus, uint8_t addr, uint8_t reg, uint8_t data)
{
return i2c_write_regs(bus, addr, reg, &data, 1);
}
/** @brief Read one 16 bit register from a INA220 device and swap byte order, if necessary. */
static int ina220_read_reg(ina220_t *dev, uint8_t reg, uint16_t *out)
{
union {
char c[2];
uint16_t u16;
} tmp = { .u16 = 0 };
int status = 0;
status = i2c_read_regs(dev->i2c, dev->addr, reg, &tmp.c[0], 2);
if (status != 2) {
return -1;
}
*out = NTOHS(tmp.u16);
return 0;
}
/** @brief Write one 16 bit register to a INA220 device and swap byte order, if necessary. */
static int ina220_write_reg(ina220_t *dev, uint8_t reg, uint16_t in)
{
union {
char c[2];
uint16_t u16;
} tmp = { .u16 = 0 };
int status = 0;
tmp.u16 = HTONS(in);
status = i2c_write_regs(dev->i2c, dev->addr, reg, &tmp.c[0], 2);
if (status != 2) {
return -1;
}
return 0;
}
int ina220_init(ina220_t *dev, i2c_t i2c, uint8_t address)
{
/* write device descriptor */
dev->i2c = i2c;
dev->addr = address;
return 0;
}
int ina220_set_calibration(ina220_t *dev, uint16_t calibration)
{
return ina220_write_reg(dev, INA220_REG_CALIBRATION, calibration);
}
int ina220_set_config(ina220_t *dev, uint16_t config)
{
return ina220_write_reg(dev, INA220_REG_CONFIGURATION, config);
}
int ina220_read_shunt(ina220_t *dev, int16_t *voltage)
{
return ina220_read_reg(dev, INA220_REG_SHUNT_VOLTAGE, (uint16_t *)voltage);
}
int ina220_read_bus(ina220_t *dev, int16_t *voltage)
{
return ina220_read_reg(dev, INA220_REG_BUS_VOLTAGE, (uint16_t *)voltage);
}
int ina220_read_current(ina220_t *dev, int16_t *current)
{
return ina220_read_reg(dev, INA220_REG_CURRENT, (uint16_t *)current);
}
int ina220_read_power(ina220_t *dev, int16_t *power)
{
return ina220_read_reg(dev, INA220_REG_POWER, (uint16_t *)power);
}
