upm_result_t lis3dh_write_reg(const lis3dh_context dev, uint8_t reg, uint8_t val) { assert(dev != NULL); if (dev->spi) { // Mask off 0x80 for writing reg &= 0x7F; uint8_t pkt[2] = { reg, val }; _csOn(dev); if (mraa_spi_transfer_buf(dev->spi, pkt, NULL, 2)) { _csOff(dev); printf("%s: mraa_spi_transfer_buf() failed.", __FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } _csOff(dev); } else { if (mraa_i2c_write_byte_data(dev->i2c, val, reg)) { printf("%s: mraa_i2c_write_byte_data() failed.", __FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } } return UPM_SUCCESS; }
static upm_result_t kx122_write_register(const kx122_context dev, uint8_t reg, uint8_t val) { if(dev->using_spi){ reg &= SPI_WRITE; uint8_t spi_data[2] = {reg,val}; kx122_chip_select_on(dev); if(mraa_spi_transfer_buf(dev->spi,spi_data,NULL,(sizeof(spi_data) / sizeof(uint8_t))) != MRAA_SUCCESS){ printf("%s: mraa_spi_transfer_buf() failed.\n", __FUNCTION__); kx122_chip_select_off(dev); return UPM_ERROR_OPERATION_FAILED; } kx122_chip_select_off(dev); return UPM_SUCCESS; } else{ if(mraa_i2c_write_byte_data(dev->i2c,val,reg) != MRAA_SUCCESS){ printf("%s: mraa_i2c_write_byte_data() failed.\n",__FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } return UPM_SUCCESS; } }
void MPU9250_I2C_Write(uint8_t address, uint8_t value) { //Set MPU Device Address mraa_i2c_address(MPU9250_i2c, MPU_ADDR); //Write Command and Data mraa_i2c_write_byte_data(MPU9250_i2c, value, address); }
void set_gyro_scale(mraa_i2c_context gyro, gyro_scale_t g_scale) { // We need to preserve the other bytes in CTRL_REG4_G. So, first read it: uint8_t temp = mraa_i2c_read_byte_data(gyro, CTRL_REG4_G); // Then mask out the gyro scale bits: temp &= 0xFF^(0x3 << 4); // Then shift in our new scale bits: temp |= g_scale << 4; // And write the new register value back into CTRL_REG4_G: mraa_i2c_write_byte_data(gyro, temp, CTRL_REG4_G); }
void set_accel_scale(mraa_i2c_context accel, accel_scale_t a_scale) { // We need to preserve the other bytes in CTRL_REG2_XM. So, first read it: uint8_t temp = mraa_i2c_read_byte_data(accel, CTRL_REG2_XM); // Then mask out the accel scale bits: temp &= 0xFF^(0x3 << 3); // Then shift in our new scale bits: temp |= a_scale << 3; // And write the new register value back into CTRL_REG2_XM: mraa_i2c_write_byte_data(accel, temp, CTRL_REG2_XM); }
void set_mag_ODR(mraa_i2c_context mag, mag_odr_t m_rate) { // We need to preserve the other bytes in CTRL_REG5_XM. So, first read it: uint8_t temp = mraa_i2c_read_byte_data(mag, CTRL_REG5_XM); // Then mask out the mag ODR bits: temp &= 0xFF^(0x7 << 2); // Then shift in our new ODR bits: temp |= (m_rate << 2); // And write the new register value back into CTRL_REG5_XM: mraa_i2c_write_byte_data(mag, temp, CTRL_REG5_XM); }
void set_gyro_ODR(mraa_i2c_context gyro, gyro_odr_t g_rate) { // We need to preserve the other bytes in CTRL_REG1_G. So, first read it: uint8_t temp = mraa_i2c_read_byte_data(gyro, CTRL_REG1_G); // Then mask out the gyro ODR bits: temp &= 0xFF^(0xF << 4); // Then shift in our new ODR bits: temp |= (g_rate << 4); // And write the new register value back into CTRL_REG1_G: mraa_i2c_write_byte_data(gyro, temp, CTRL_REG1_G); }
void set_accel_ODR(mraa_i2c_context accel, accel_odr_t a_rate) { // We need to preserve the other bytes in CTRL_REG1_XM. So, first read it: uint8_t temp = mraa_i2c_read_byte_data(accel, CTRL_REG1_XM); // Then mask out the accel ODR bits: temp &= 0xFF^(0xF << 4); // Then shift in our new ODR bits: temp |= (a_rate << 4); // And write the new register value back into CTRL_REG1_XM: mraa_i2c_write_byte_data(accel, temp, CTRL_REG1_XM); }
void main(){ devAddr = MPU6050_DEFAULT_ADDRESS; i2c = mraa_i2c_init(0); /** Power on and prepare for general usage. * This will activate the device and take it out of sleep mode (which must be done * after start-up). This function also sets both the accelerometer and the gyroscope * to their most sensitive settings, namely +/- 2g and +/- 250 degrees/sec, and sets * the clock source to use the X Gyro for reference, which is slightly better than * the default internal clock source. */ mraa_i2c_address(i2c,devAddr); mraa_i2c_write_byte_data(i2c,MPU6050_CLOCK_PLL_XGYRO,MPU6050_RA_PWR_MGMT_1); mraa_i2c_write_byte_data(i2c,MPU6050_RA_GYRO_CONFIG,MPU6050_GYRO_FS_250); mraa_i2c_write_byte_data(i2c,MPU6050_RA_ACCEL_CONFIG,MPU6050_ACCEL_FS_2); int ev1=every(20,getangle,-1); int ev2=every(50,print,-1); while(1){ timeupdate(); } }
void set_mag_scale(mraa_i2c_context mag, mag_scale_t m_scale) { // We need to preserve the other bytes in CTRL_REG6_XM. So, first read it: uint8_t temp = mraa_i2c_read_byte_data(mag, CTRL_REG6_XM); // Then mask out the mag scale bits: temp &= 0xFF^(0x3 << 5); // Then shift in our new scale bits: temp |= m_scale << 5; // And write the new register value back into CTRL_REG6_XM: mraa_i2c_write_byte_data(mag, temp, CTRL_REG6_XM); }
upm_result_t bno055_write_reg(const bno055_context dev, uint8_t reg, uint8_t val) { assert(dev != NULL); if (mraa_i2c_write_byte_data(dev->i2c, val, reg)) { printf("%s: mraa_i2c_write_byte_data() failed\n", __FUNCTION__); return UPM_ERROR_OPERATION_FAILED; } return UPM_SUCCESS; }
mrb_value mrb_mraa_i2c_write_reg(mrb_state *mrb, mrb_value self){ mraa_i2c_context i2c; mrb_int wdata; mrb_int reg; mraa_result_t result; Data_Get_Struct(mrb, self, &mrb_mraa_i2c_ctx_type, i2c); mrb_get_args(mrb, "ii", &wdata, ®); result = mraa_i2c_write_byte_data(i2c, wdata & 0xFF, reg); return mrb_fixnum_value(result); }
mraa_result_t i2c_set(int bus, uint8_t device_address, uint8_t register_address, uint8_t data) { mraa_result_t status = MRAA_SUCCESS; mraa_i2c_context i2c = mraa_i2c_init(bus); if (i2c == NULL) { return MRAA_ERROR_NO_RESOURCES; } status = mraa_i2c_address(i2c, device_address); if (status != MRAA_SUCCESS) { fprintf(stderr, "Could not set i2c device address\n"); goto i2c_set_exit; } status = mraa_i2c_write_byte_data(i2c, data, register_address); if (status != MRAA_SUCCESS) { fprintf(stderr, "Could not write to i2c register. Status = %d\n", status); goto i2c_set_exit; } i2c_set_exit: mraa_i2c_stop(i2c); return status; }
void gWriteByte(mraa_i2c_context gyro, uint8_t subAddress, uint8_t data) { mraa_i2c_write_byte_data(gyro, data, subAddress); }
void xmWriteByte(mraa_i2c_context xm, uint8_t subAddress, uint8_t data) { mraa_i2c_write_byte_data(xm, data, subAddress); }
mraa_i2c_context mag_init() { mraa_i2c_context mag; mag = mraa_i2c_init(1); if (mag == NULL) { fprintf(stderr, "Failed to initialize I2C.\n"); exit(1); } mraa_i2c_address(mag, XM_ADDR); uint8_t mag_id = mraa_i2c_read_byte_data(mag, WHO_AM_I_XM); if (mag_id != 0x49) { fprintf(stderr, "Accelerometer/Magnetometer ID does not match.\n"); } /* CTRL_REG5_XM enables temp sensor, sets mag resolution and data rate Bits (7-0): TEMP_EN M_RES1 M_RES0 M_ODR2 M_ODR1 M_ODR0 LIR2 LIR1 TEMP_EN - Enable temperature sensor (0=disabled, 1=enabled) M_RES[1:0] - Magnetometer resolution select (0=low, 3=high) M_ODR[2:0] - Magnetometer data rate select 000=3.125Hz, 001=6.25Hz, 010=12.5Hz, 011=25Hz, 100=50Hz, 101=100Hz LIR2 - Latch interrupt request on INT2_SRC (cleared by reading INT2_SRC) 0=interrupt request not latched, 1=interrupt request latched LIR1 - Latch interrupt request on INT1_SRC (cleared by readging INT1_SRC) 0=irq not latched, 1=irq latched */ //xmWriteByte(CTRL_REG5_XM, 0x94); // Mag data rate - 100 Hz, enable temperature sensor mraa_i2c_write_byte_data(mag, 0x94, CTRL_REG5_XM); /* CTRL_REG6_XM sets the magnetometer full-scale Bits (7-0): 0 MFS1 MFS0 0 0 0 0 0 MFS[1:0] - Magnetic full-scale selection 00:+/-2Gauss, 01:+/-4Gs, 10:+/-8Gs, 11:+/-12Gs */ //xmWriteByte(CTRL_REG6_XM, 0x00); // Mag scale to +/- 2GS mraa_i2c_write_byte_data(mag, 0x00, CTRL_REG6_XM); /* CTRL_REG7_XM sets magnetic sensor mode, low power mode, and filters AHPM1 AHPM0 AFDS 0 0 MLP MD1 MD0 AHPM[1:0] - HPF mode selection 00=normal (resets reference registers), 01=reference signal for filtering, 10=normal, 11=autoreset on interrupt event AFDS - Filtered acceleration data selection 0=internal filter bypassed, 1=data from internal filter sent to FIFO MLP - Magnetic data low-power mode 0=data rate is set by M_ODR bits in CTRL_REG5 1=data rate is set to 3.125Hz MD[1:0] - Magnetic sensor mode selection (default 10) 00=continuous-conversion, 01=single-conversion, 10 and 11=power-down */ //xmWriteByte(CTRL_REG7_XM, 0x00); // Continuous conversion mode mraa_i2c_write_byte_data(mag, 0x00, CTRL_REG7_XM); /* CTRL_REG4_XM is used to set interrupt generators on INT2_XM Bits (7-0): P2_TAP P2_INT1 P2_INT2 P2_INTM P2_DRDYA P2_DRDYM P2_Overrun P2_WTM */ //xmWriteByte(CTRL_REG4_XM, 0x04); // Magnetometer data ready on INT2_XM (0x08) mraa_i2c_write_byte_data(mag, 0x04, CTRL_REG4_XM); /* INT_CTRL_REG_M to set push-pull/open drain, and active-low/high Bits[7:0] - XMIEN YMIEN ZMIEN PP_OD IEA IEL 4D MIEN XMIEN, YMIEN, ZMIEN - Enable interrupt recognition on axis for mag data PP_OD - Push-pull/open-drain interrupt configuration (0=push-pull, 1=od) IEA - Interrupt polarity for accel and magneto 0=active-low, 1=active-high IEL - Latch interrupt request for accel and magneto 0=irq not latched, 1=irq latched 4D - 4D enable. 4D detection is enabled when 6D bit in INT_GEN1_REG is set MIEN - Enable interrupt generation for magnetic data 0=disable, 1=enable) */ //xmWriteByte(INT_CTRL_REG_M, 0x09); // Enable interrupts for mag, active-low, push-pull mraa_i2c_write_byte_data(mag, 0x09, INT_CTRL_REG_M); return mag; }
/** * Fast call for single byte write to LSM9DS0 Accelerometer / Magnetometer * */ void lsm_xm_write(unsigned char reg, unsigned char value) { mraa_i2c_address(i2c, LSM_ADDRESS_XM); if(mraa_i2c_write_byte_data(i2c, value, reg) != MRAA_SUCCESS) { printf("write single byte to LSM9DS0 XM failed...\n"); } }
/** * Write a byte to an i2c register * * @param reg Register to write to * @param data Value to write to register * @return Result of operation */ mraa_result_t writeReg(uint8_t reg, uint8_t data) { return mraa_i2c_write_byte_data(m_i2c, data, reg); }
mraa_i2c_context accel_init() { mraa_i2c_context accel; accel = mraa_i2c_init(1); if (accel == NULL) { fprintf(stderr, "Failed to initialize I2C.\n"); exit(1); } mraa_i2c_address(accel, XM_ADDR); uint8_t accel_id = mraa_i2c_read_byte_data(accel, WHO_AM_I_XM); if (accel_id != 0x49) { fprintf(stderr, "Accelerometer/Magnetometer ID does not match.\n"); } /* CTRL_REG0_XM (0x1F) (Default value: 0x00) Bits (7-0): BOOT FIFO_EN WTM_EN 0 0 HP_CLICK HPIS1 HPIS2 BOOT - Reboot memory content (0: normal, 1: reboot) FIFO_EN - Fifo enable (0: disable, 1: enable) WTM_EN - FIFO watermark enable (0: disable, 1: enable) HP_CLICK - HPF enabled for click (0: filter bypassed, 1: enabled) HPIS1 - HPF enabled for interrupt generator 1 (0: bypassed, 1: enabled) HPIS2 - HPF enabled for interrupt generator 2 (0: bypassed, 1 enabled) */ //xmWriteByte(CTRL_REG0_XM, 0x00); mraa_i2c_write_byte_data(accel, 0x00, CTRL_REG0_XM); /* CTRL_REG1_XM (0x20) (Default value: 0x07) Bits (7-0): AODR3 AODR2 AODR1 AODR0 BDU AZEN AYEN AXEN AODR[3:0] - select the acceleration data rate: 0000=power down, 0001=3.125Hz, 0010=6.25Hz, 0011=12.5Hz, 0100=25Hz, 0101=50Hz, 0110=100Hz, 0111=200Hz, 1000=400Hz, 1001=800Hz, 1010=1600Hz, (remaining combinations undefined). BDU - block data update for accel AND mag 0: Continuous update 1: Output registers aren't updated until MSB and LSB have been read. AZEN, AYEN, and AXEN - Acceleration x/y/z-axis enabled. 0: Axis disabled, 1: Axis enabled */ //xmWriteByte(CTRL_REG1_XM, 0x57); // 100Hz data rate, x/y/z all enabled mraa_i2c_write_byte_data(accel, 0x57, CTRL_REG1_XM); //Serial.println(xmReadByte(CTRL_REG1_XM)); /* CTRL_REG2_XM (0x21) (Default value: 0x00) Bits (7-0): ABW1 ABW0 AFS2 AFS1 AFS0 AST1 AST0 SIM ABW[1:0] - Accelerometer anti-alias filter bandwidth 00=773Hz, 01=194Hz, 10=362Hz, 11=50Hz AFS[2:0] - Accel full-scale selection 000=+/-2g, 001=+/-4g, 010=+/-6g, 011=+/-8g, 100=+/-16g AST[1:0] - Accel self-test enable 00=normal (no self-test), 01=positive st, 10=negative st, 11=not allowed SIM - SPI mode selection 0=4-wire, 1=3-wire */ //xmWriteByte(CTRL_REG2_XM, 0x00); // Set scale to 2g mraa_i2c_write_byte_data(accel, 0x00, CTRL_REG2_XM); /* CTRL_REG3_XM is used to set interrupt generators on INT1_XM Bits (7-0): P1_BOOT P1_TAP P1_INT1 P1_INT2 P1_INTM P1_DRDYA P1_DRDYM P1_EMPTY */ // Accelerometer data ready on INT1_XM (0x04) //xmWriteByte(CTRL_REG3_XM, 0x04); mraa_i2c_write_byte_data(accel, 0x04, CTRL_REG3_XM); return accel; }
mraa_i2c_context gyro_init() { mraa_i2c_context gyro; gyro = mraa_i2c_init(1); if (gyro == NULL) { fprintf(stderr, "Failed to initialize I2C.\n"); exit(1); } mraa_i2c_address(gyro, GYRO_ADDR); uint8_t gyro_id = mraa_i2c_read_byte_data(gyro, WHO_AM_I_G); if (gyro_id != 0xD4) { fprintf(stderr, "Gyroscope ID does not match.\n"); } /* CTRL_REG1_G sets output data rate, bandwidth, power-down and enables Bits[7:0]: DR1 DR0 BW1 BW0 PD Zen Xen Yen DR[1:0] - Output data rate selection 00=95Hz, 01=190Hz, 10=380Hz, 11=760Hz BW[1:0] - Bandwidth selection (sets cutoff frequency) Value depends on ODR. See datasheet table 21. PD - Power down enable (0=power down mode, 1=normal or sleep mode) Zen, Xen, Yen - Axis enable (o=disabled, 1=enabled) */ //gWriteByte(CTRL_REG1_G, 0x0F); // Normal mode, enable all axes mraa_i2c_write_byte_data(gyro, 0x0F, CTRL_REG1_G); /* CTRL_REG2_G sets up the HPF Bits[7:0]: 0 0 HPM1 HPM0 HPCF3 HPCF2 HPCF1 HPCF0 HPM[1:0] - High pass filter mode selection 00=normal (reset reading HP_RESET_FILTER, 01=ref signal for filtering, 10=normal, 11=autoreset on interrupt HPCF[3:0] - High pass filter cutoff frequency Value depends on data rate. See datasheet table 26. */ //gWriteByte(CTRL_REG2_G, 0x00); // Normal mode, high cutoff frequency mraa_i2c_write_byte_data(gyro, 0x00, CTRL_REG2_G); /* CTRL_REG3_G sets up interrupt and DRDY_G pins Bits[7:0]: I1_IINT1 I1_BOOT H_LACTIVE PP_OD I2_DRDY I2_WTM I2_ORUN I2_EMPTY I1_INT1 - Interrupt enable on INT_G pin (0=disable, 1=enable) I1_BOOT - Boot status available on INT_G (0=disable, 1=enable) H_LACTIVE - Interrupt active configuration on INT_G (0:high, 1:low) PP_OD - Push-pull/open-drain (0=push-pull, 1=open-drain) I2_DRDY - Data ready on DRDY_G (0=disable, 1=enable) I2_WTM - FIFO watermark interrupt on DRDY_G (0=disable 1=enable) I2_ORUN - FIFO overrun interrupt on DRDY_G (0=disable 1=enable) I2_EMPTY - FIFO empty interrupt on DRDY_G (0=disable 1=enable) */ // Int1 enabled (pp, active low), data read on DRDY_G: //gWriteByte(CTRL_REG3_G, 0x88); mraa_i2c_write_byte_data(gyro, 0x88, CTRL_REG3_G); /* CTRL_REG4_G sets the scale, update mode Bits[7:0] - BDU BLE FS1 FS0 - ST1 ST0 SIM BDU - Block data update (0=continuous, 1=output not updated until read BLE - Big/little endian (0=data LSB @ lower address, 1=LSB @ higher add) FS[1:0] - Full-scale selection 00=245dps, 01=500dps, 10=2000dps, 11=2000dps ST[1:0] - Self-test enable 00=disabled, 01=st 0 (x+, y-, z-), 10=undefined, 11=st 1 (x-, y+, z+) SIM - SPI serial interface mode select 0=4 wire, 1=3 wire */ //gWriteByte(CTRL_REG4_G, 0x00); // Set scale to 245 dps mraa_i2c_write_byte_data(gyro, 0x00, CTRL_REG4_G); /* CTRL_REG5_G sets up the FIFO, HPF, and INT1 Bits[7:0] - BOOT FIFO_EN - HPen INT1_Sel1 INT1_Sel0 Out_Sel1 Out_Sel0 BOOT - Reboot memory content (0=normal, 1=reboot) FIFO_EN - FIFO enable (0=disable, 1=enable) HPen - HPF enable (0=disable, 1=enable) INT1_Sel[1:0] - Int 1 selection configuration Out_Sel[1:0] - Out selection configuration */ //gWriteByte(CTRL_REG5_G, 0x00); mraa_i2c_write_byte_data(gyro, 0x00, CTRL_REG5_G); return gyro; }