自学教程：C++ I2CWrite函数代码示例

/*************************************************************************** * * Function : set_charge_backup_battery * * IN   : param, a value to write to the regiter RTCStatus * OUT  :  * * RET  : Return the value of register RTCStatus * * Notes : From register 0x0F0B, bits 5:5 * **************************************************************************/unsigned char set_charge_backup_battery( enum charge_backup_battery_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(RTC_STATUS_REG);    /*      * 0: Current source to charge back up battery disabled in      * OFF mode      * 1: Current source to charge back up battery enabled in      * OFF mode      */     switch( param ){        case CHARGE_BACKUP_BATTERY_ENABLE_E:            value = old_value | CHARGE_BACKUP_BATTERY_ENABLE_PARAM_MASK;            break;        case CHARGE_BACKUP_BATTERY_DISABLE_E:            value = old_value & ~ CHARGE_BACKUP_BATTERY_ENABLE_PARAM_MASK;           break;    }      I2CWrite(RTC_STATUS_REG, value);    return old_value;  }

/*************************************************************************** * * Function : set_acc_detect21_comparator * * IN   : param, a value to write to the regiter AccDetect3 * OUT  :  * * RET  : Return the value of register 0xAccDetect3 * * Notes : From register 0x882, bits 4:4 * **************************************************************************/unsigned char set_acc_detect21_comparator( enum comparator21_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(ACC_DETECT_3_REG);    /*      * 0: disable AccDetect21 comparator      * 1: enable AccDetect21 comparator      */     switch( param ){        case COMPARATOR_21_ENABLE_E:            value = old_value | ACC_DETECT_21_COMPARATOR_MASK;            break;        case COMPARATOR_21_DISABLE_E:            value = old_value & ~ ACC_DETECT_21_COMPARATOR_MASK;           break;    }      I2CWrite(ACC_DETECT_3_REG, value);    return old_value;  }

/*************************************************************************** * * Function : set_coulomb_counter_power_off * * IN   : param, a value to write to the regiter CoulombCounter * OUT  :  * * RET  : Return the value of register CoulombCounter * * Notes : From register 0x0F01, bits 0:0 * **************************************************************************/unsigned char set_coulomb_counter_power_off( enum coulomb_counter_power_off_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(COULOMB_COUNTER_REG);    /*      * Note: Coulomb Counter always disable in PwrOff mode.      * 0: disable Coulomb Counter      * 1: enable Coulomb Counter      */     switch( param ){        case COULOMB_COUNTER_POWER_UP_E:            value = old_value | COULOMB_COUNTER_POWER_OFF_ENABLE_PARAM_MASK;            break;        case COULOMB_COUNTER_POWER_DOWN_E:            value = old_value & ~ COULOMB_COUNTER_POWER_OFF_ENABLE_PARAM_MASK;           break;    }      I2CWrite(COULOMB_COUNTER_REG, value);    return old_value;  }

/*************************************************************************** * * Function : set_ape_i2c_clock_pullup * * IN   : param, a value to write to the regiter I2cPadControl * OUT  :  * * RET  : Return the value of register I2cPadControl * * Notes : From register 0x1067, bits 2:2 * **************************************************************************/unsigned char set_ape_i2c_clock_pullup( enum ape_i2c_clock_pullup_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(I_2C_PAD_CONTROL_REG);    /*      * 0: enable internal pull-up      * 1: Disable internal pull-up      */     switch( param ){        case APE_I_2C_CLOCK_PULLUP_DISABLE_E:            value = old_value | APE_I_2C_CLOCK_PULLUP_ENABLE_PARAM_MASK;            break;        case APE_I_2C_CLOCK_PULLUP_ENABLE_E:            value = old_value & ~ APE_I_2C_CLOCK_PULLUP_ENABLE_PARAM_MASK;           break;    }      I2CWrite(I_2C_PAD_CONTROL_REG, value);    return old_value;  }

void LCDUpdate(void){    #if defined(SENSOR_PORT_UART)    LCDCommand[0] = LCD_SLAVEADDRESS << 1;    LCDCommand[1] = LCD_WRITE_CMD;    LCDCommand[2] = LCDCMD_FIRSTLINE_ADDRESS;    LCDCommand[3] = 32;    I2CWrite(4, 32);    #else    BYTE    i;    DelayMs(10);    SPIPut2(0x32);  //LCD Subsystem Write Data Command    DelayMs(5);    SPIPut2(0);     //Screen Address    DelayMs(5);    SPIPut2(32);    //Data length (16 + 3)    for(i = 0; i < 32; i++)    {        DelayMs(5);        if(LCDText[i] == 0)        {            SPIPut2(' ');        }        else        {            SPIPut2(LCDText[i]);        }    }    DelayMs(300);    #endif}

/*************************************************************************** * * Function : set_modem_i2c_data_pullup * * IN   : param, a value to write to the regiter I2cPadControl * OUT  :  * * RET  : Return the value of register I2cPadControl * * Notes : From register 0x1067, bits 1:1 * **************************************************************************/unsigned char set_modem_i2c_data_pullup( enum modem_i2c_data_pullup_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(I_2C_PAD_CONTROL_REG);    /*      * 0: enable internal pull-up      * 1: Disable internal pull-up      */     switch( param ){        case MODEM_I_2C_DATA_PULLUP_DISABLE_E:            value = old_value | MODEM_I_2C_DATA_PULLUP_ENABLE_PARAM_MASK;            break;        case MODEM_I_2C_DATA_PULLUP_ENABLE_E:            value = old_value & ~ MODEM_I_2C_DATA_PULLUP_ENABLE_PARAM_MASK;           break;    }      I2CWrite(I_2C_PAD_CONTROL_REG, value);    return old_value;  }

/*************************************************************************** * * Function : set_acc_detect1_comparator * * IN   : param, a value to write to the regiter AccDetect3 * OUT  :  * * RET  : Return the value of register 0xAccDetect3 * * Notes : From register 0x882, bits 0:0 * **************************************************************************/unsigned char set_acc_detect1_comparator( enum detect1_comparator_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(ACC_DETECT_3_REG);    /*      * Note: doesn't turn On internal pull-up      * 0: disable AccDetect1 comparator      * 1: enable AccDetect1 comparator      */     switch( param ){        case DETECT_1_COMPARATOR_ENABLE_E:            value = old_value | ACC_DETECT_1_COMPARATOR_MASK;            break;        case DETECT_1_COMPARATOR_DISABLE_E:            value = old_value & ~ ACC_DETECT_1_COMPARATOR_MASK;           break;    }      I2CWrite(ACC_DETECT_3_REG, value);    return old_value;  }

/*************************************************************************** * * Function : set_acc_detect_pullup * * IN   : param, a value to write to the regiter AccDetect3 * OUT  :  * * RET  : Return the value of register 0xAccDetect3 * * Notes : From register 0x882, bits 3:3 * **************************************************************************/unsigned char set_acc_detect_pullup( enum acc_detect_pullup_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(ACC_DETECT_3_REG);    /*      * 0: disable AccDetect2 Pull-up      * 1: enable AccDetect2 Pull-up      */     switch( param ){        case ACC_DETECT_PULLUP_ENABLE_E:            value = old_value | ACC_DETECT_PULLUP_MASK;            break;        case ACC_DETECT_PULLUP_DISABLE_E:            value = old_value & ~ ACC_DETECT_PULLUP_MASK;           break;    }      I2CWrite(ACC_DETECT_3_REG, value);    return old_value;  }

/*************************************************************************** * * Function : set_rtc_read_request * * IN   : param, a value to write to the regiter RTCReadRequest * OUT  :  * * RET  : Return the value of register RTCReadRequest * * Notes : From register 0x0F02, bits 0:0 * **************************************************************************/unsigned char set_rtc_read_request( enum rtc_read_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(RTC_READ_REQUEST_REG);    /*      * RTC data read transfer is required      * Cleared upon data transfert in watchtim register is done      */     switch( param ){        case RTC_READ_ENABLE_E:            value = old_value | RTC_READ_ENABLE_PARAM_MASK;            break;        case RTC_READ_DISABLE_E:            value = old_value & ~ RTC_READ_ENABLE_PARAM_MASK;           break;    }      I2CWrite(RTC_READ_REQUEST_REG, value);    return old_value;  }

unsigned int L0_WriteCommandBytes(unsigned char slaveaddress, unsigned char length, unsigned char *pucDataBuffer){				slaveaddress = 0x64;		I2CWrite(slaveaddress,pucDataBuffer,length);		return length;}

/*************************************************************************** * * Function : set_acc_detect_pullup_supply * * IN   : param, a value to write to the regiter AccDetect3 * OUT  :  * * RET  : Return the value of register 0xAccDetect3 * * Notes : From register 0x882, bits 1:1 * **************************************************************************/unsigned char set_acc_detect_pullup_supply( enum v21_supply_enable param )  {    unsigned char value = 0;    unsigned char old_value;    old_value = I2CRead(ACC_DETECT_3_REG);    /*      * 0: disable AccDetect2 Pull-up 2.1v supply      * 1: enable AccDetect2 Pull-up 2.1v supply      */     switch( param ){        case V21_SUPPLY_ENABLE_E:            value = old_value | ACC_DETECT_PULLUP_SUPPLY_MASK;            break;        case V21_SUPPLY_DISABLE_E:            value = old_value & ~ ACC_DETECT_PULLUP_SUPPLY_MASK;           break;    }      I2CWrite(ACC_DETECT_3_REG, value);    return old_value;  }

EFI_STATUSInitializeDS3231 (  VOID  ){  EFI_STATUS    Status;  I2C_DEVICE    Dev;  RTC_DS3231_CONTROL Temp;  RTC_DS3231_HOURS   Hours;  // Prepare the hardware  (VOID)IdentifyDS3231();  (VOID) CopyMem(&Dev, &gDS3231RtcDevice, sizeof(Dev));  Status = I2CInit(Dev.Socket,Dev.Port,Normal);  if (EFI_ERROR (Status)) {    goto EXIT;  }  // Ensure interrupts are masked. We do not want RTC interrupts in UEFI  Status = I2CRead(&Dev,DS3231_REGADDR_CONTROL,1,&Temp.u8);  if (EFI_ERROR (Status)) {    goto EXIT;  }  Temp.bits.INTCN = 0;  Status = I2CWrite(&Dev,DS3231_REGADDR_CONTROL,1,&Temp.u8);  if (EFI_ERROR (Status)) {    goto EXIT;  }  MicroSecondDelay(2000);  Status = I2CRead(&Dev,DS3231_REGADDR_HOURS,1,&Hours.u8);  if (EFI_ERROR (Status)) {    goto EXIT;  }  Hours.bits.Hour24_n = 0;  Status = I2CWrite(&Dev,DS3231_REGADDR_HOURS,1,&Hours.u8);  if (EFI_ERROR (Status)) {    goto EXIT;  }  mDS3231Initialized = TRUE;  EXIT:  return Status;}

static ssize_t eamp_closeheadPhone(){	u8 temp_control_reg = 0;	EAMP_PRINTK("eamp_closeheadPhone");	I2CWrite(0x86, 0x40);		I2CWrite(0x87, 0x00);		if(gsk_on)	  {	  	I2CWrite(0x85, 0x5f);			I2CWrite(0x87, 0x30);		}		ghp_on = false;	return 0;}

static void writeReg(uint8_t reg, uint8_t data){    uint8_t buf[2];    buf[0] = SUB_ADDR(channel, reg);    buf[1] = data;    I2CWrite(UART2_ADDR, buf, 2);}

bool RTIMULSM9DS0::setGyroCTRL2(){    if ((m_settings->m_LSM9DS0GyroHpf < LSM9DS0_GYRO_HPF_0) || (m_settings->m_LSM9DS0GyroHpf > LSM9DS0_GYRO_HPF_9)) {        HAL_ERROR1("Illegal LSM9DS0 gyro high pass filter code %d/n", m_settings->m_LSM9DS0GyroHpf);        return false;    }    return I2CWrite(m_gyroSlaveAddr,  LSM9DS0_GYRO_CTRL2, m_settings->m_LSM9DS0GyroHpf, "Failed to set LSM9DS0 gyro CTRL2");}

/****************************************************************************** * * Description: *    Set the blink period for PWM1. Valid values are 0 - 255 where 0 *    means 152 Hz and 255 means 0.59 Hz. A value of 151 means 1 Hz. * * Params: *    [in]  period  - The period for PWM1 * *****************************************************************************/void pca9532_setBlink1Period(uint8_t period){    uint8_t buf[2];    buf[0] = PCA9532_PSC1;    buf[1] = period;    I2CWrite(PCA9532_I2C_ADDR, buf, 2);}

/*************************************************  Function:		StorageClear  Description:    Input:		  Output:		  Return:		  Others:*************************************************/void StorageClear(void){    mSysParam.Init = 1;    mSysParam.BeepEnable = 1;    mSysParam.DataNum = 0;    StorageInitInfo();    I2CWrite(I2C_ADDR_W, ADDRESS_INIT, (unsigned char*)(&mSysParam), sizeof(SYS_PARAM));}

static void setModeControl(uint8_t mctl){    uint8_t buf[2];    buf[0] = ACC_ADDR_MCTL;    buf[1] = mctl;    I2CWrite(ACC_I2C_ADDR, buf, 2);}

BOOLEAN NTAPIVideoPortDDCMonitorHelper(   PVOID HwDeviceExtension,   PVOID I2CFunctions,   PUCHAR pEdidBuffer,   ULONG EdidBufferSize   ){   PDDC_CONTROL ddc = (PDDC_CONTROL)I2CFunctions;   PI2C_CALLBACKS i2c = &ddc->I2CCallbacks;   INT Count, i;   PUCHAR pBuffer = (PUCHAR)pEdidBuffer;   BOOL Ack;   TRACE_(VIDEOPRT, "VideoPortDDCMonitorHelper()/n");   ASSERT_IRQL_LESS_OR_EQUAL(PASSIVE_LEVEL);   if (ddc->Size != sizeof (ddc))     {        WARN_(VIDEOPRT, "ddc->Size != %d (%d)/n", sizeof (ddc), ddc->Size);        return FALSE;     }   /* select eeprom */   if (!I2CStart(HwDeviceExtension, i2c, DDC_EEPROM_ADDRESS | WRITE))     return FALSE;   /* set address */   if (!I2CWrite(HwDeviceExtension, i2c, 0x00))     return FALSE;   /* change into read mode */   if (!I2CRepStart(HwDeviceExtension, i2c, DDC_EEPROM_ADDRESS | READ))     return FALSE;   /* read eeprom */   RtlZeroMemory(pEdidBuffer, EdidBufferSize);   Count = min(128, EdidBufferSize);   for (i = 0; i < Count; i++)     {        Ack = ((i + 1) < Count);        pBuffer[i] = I2CRead(HwDeviceExtension, i2c, Ack);     }   I2CStop(HwDeviceExtension, i2c);   /* check EDID header */   if (pBuffer[0] != 0x00 || pBuffer[1] != 0xff ||       pBuffer[2] != 0xff || pBuffer[3] != 0xff ||       pBuffer[4] != 0xff || pBuffer[5] != 0xff ||       pBuffer[6] != 0xff || pBuffer[7] != 0x00)     {        WARN_(VIDEOPRT, "VideoPortDDCMonitorHelper(): Invalid EDID header!/n");        return FALSE;     }   INFO_(VIDEOPRT, "VideoPortDDCMonitorHelper(): EDID version %d rev. %d/n", pBuffer[18], pBuffer[19]);   INFO_(VIDEOPRT, "VideoPortDDCMonitorHelper() - SUCCESS!/n");   return TRUE;}

static uint8_t readReg(uint8_t reg){    uint8_t buf[1];    buf[0] = SUB_ADDR(channel, reg);    I2CWrite(UART2_ADDR, buf, 1);    I2CRead(UART2_ADDR, buf, 1);    return buf[0];}

int main(void) {	int fd;	char device[20];	int count;		printf("open device.../n");	sprintf(device, "/dev/i2c-1");	if ((fd = open(device, O_RDWR)) < 0) {		fprintf(stderr, "Failed to open i2c bus '%s'/n", device);        exit(1);	}	printf("set slave .../n");    if (ioctl(fd, I2C_SLAVE, SlaveAddr) < 0) {		fprintf(stderr,		"Failed to acquire i2c bus access or talk to slave %X/n", SlaveAddr);		close(fd);		exit(2);	}	printf("switch to iocon.bank 1 .../n");	I2CWrite(fd, MCP_IOCON, 0x80);		printf("start output dark.../n");	I2CWrite(fd, MCP_PortA | MCP_Write, Seg7_Digi1_Off | Seg7_Digi2_Off);	printf("write direction output .../n");	I2CWrite(fd, MCP_PortA | MCP_Direction, 0x00);	printf("count up both digits .../n");	for (count=0; count<=9; count++){		I2CWrite(fd, MCP_PortA | MCP_Write, count | Seg7_Dot_Off);		usleep(300000);	}	printf("count up digit 2 .../n");	for (count=0; count<=9; count++){		I2CWrite(fd, MCP_PortA | MCP_Write, count | Seg7_Digi1_Off | Seg7_Dot_Off);		usleep(300000);	}	printf("count up digit 1 .../n");	for (count=0; count<=9; count++){		I2CWrite(fd, MCP_PortA | MCP_Write, count | Seg7_Digi2_Off | Seg7_Dot_Off);		usleep(300000);	}	printf("show 04 Hz .../n");	MultiplexWrite(fd, 0, 4, 250000, 3000000);	printf("show 10 Hz .../n");	MultiplexWrite(fd, 1, 0, 100000, 3000000);	printf("show 21 Hz .../n");	MultiplexWrite(fd, 2, 1, 47600,  3000000);	printf("show 43 Hz .../n");	MultiplexWrite(fd, 4, 3, 23200,  3000000);	printf("show 98 Hz .../n");	MultiplexWrite(fd, 9, 8, 10200,  3000000);	printf("switch off both digits .../n");	I2CWrite(fd, MCP_PortA | MCP_Write, Seg7_Digi1_Off | Seg7_Digi2_Off);		close(fd);	return 0;}

static uint8_t getStatus(void){    uint8_t buf[1];    buf[0] = ACC_ADDR_STATUS;    I2CWrite(ACC_I2C_ADDR, buf, 1);    I2CRead(ACC_I2C_ADDR, buf, 1);    return buf[0];}

static uint8_t getModeControl(void){    uint8_t buf[1];    buf[0] = ACC_ADDR_MCTL;    I2CWrite(ACC_I2C_ADDR, buf, 1);    I2CRead(ACC_I2C_ADDR, buf, 1);    return buf[0];}

static ssize_t eamp_setDevice(unsigned long int param){    EAMP_PRINTK("set Device (%u)", param);    set_device = param;	if (set_mode == 2) {		agc_fixed_gain = AGC_FIXED_GAIN_VOICE;		I2CWrite(AGC_FIXED_GAIN_CONTROL, register_setting_mode ? register_setting_mode:agc_fixed_gain);		EAMP_PRINTK("eamp_setDevice : set agc gain VOICE = 0x%x/n", agc_fixed_gain);	} else if (set_device == DEVICE_OUT_SPEAKER_HEADSET_R) {		agc_fixed_gain = AGC_FIXED_GAIN_COMBO_RING;		I2CWrite(AGC_FIXED_GAIN_CONTROL, register_setting_mode ? register_setting_mode:agc_fixed_gain);		EAMP_PRINTK("eamp_setDevice : set agc gain COMBO_PATH = 0x%x/n", agc_fixed_gain);	} else {		agc_fixed_gain = AGC_FIXED_GAIN_AUDIO;		I2CWrite(AGC_FIXED_GAIN_CONTROL, register_setting_mode ? register_setting_mode:agc_fixed_gain);		EAMP_PRINTK("eamp_setDevice : set agc gain AUDIO = 0x%x/n", agc_fixed_gain);	}    return 0;}

void LCDBacklightON(void){#if defined(SENSOR_PORT_UART)    LCDCommand[0] = LCD_SLAVEADDRESS << 1;    LCDCommand[1] = 0x44;    LCDCommand[2] = 0x00;    I2CWrite(3, 0);    DelayMs(200);    LCDCommand[0] = LCD_SLAVEADDRESS << 1;    LCDCommand[1] = 0x42;    LCDCommand[2] = 0x00;    I2CWrite(3, 0);    DelayMs(200);#else#endif}

/************************************************* Function:		StorageSetParamIndex Descroption:	  Input: 	1.Index	2.Info	3.Data	4.THData Output:  Return: 	 Other:  *************************************************/INT8U StorageSetParamIndex(INT8U Index, PINFO_PARAM Info, INT8U* Data, INT8U* THData){    unsigned int SubAddr = ADDRESS_DATA(Index);    if(NULL == Info || NULL == Data || NULL == THData)    {        return FALSE;    }    if(Index > mSysParam.DataNum)    {        return FALSE;    }    I2CWrite(I2C_ADDR_W, SubAddr, (unsigned char*)Info, sizeof(INFO_PARAM));    SubAddr += sizeof(INFO_PARAM);    I2CWrite(I2C_ADDR_W, SubAddr, (unsigned char*)Data, (16*Info->Num));    SubAddr += (16*Info->Num);    I2CWrite(I2C_ADDR_W, SubAddr, (unsigned char*)THData, Info->Num);        return 0;}

bool RTIMUGD20HM303DLHC::setCompassCRB(){    unsigned char crb;    //  convert FSR to uT    switch (m_settings->m_GD20HM303DLHCCompassFsr) {    case LSM303DLHC_COMPASS_FSR_1_3:        crb = 0x20;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)1100;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)980;        break;    case LSM303DLHC_COMPASS_FSR_1_9:        crb = 0x40;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)855;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)760;       break;    case LSM303DLHC_COMPASS_FSR_2_5:        crb = 0x60;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)670;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)600;        break;    case LSM303DLHC_COMPASS_FSR_4:        crb = 0x80;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)450;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)400;        break;    case LSM303DLHC_COMPASS_FSR_4_7:        crb = 0xa0;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)400;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)355;        break;    case LSM303DLHC_COMPASS_FSR_5_6:        crb = 0xc0;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)330;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)295;        break;    case LSM303DLHC_COMPASS_FSR_8_1:        crb = 0xe0;        m_compassScaleXY = (RTFLOAT)100 / (RTFLOAT)230;        m_compassScaleZ = (RTFLOAT)100 / (RTFLOAT)205;        break;    default:        return false;    }    return I2CWrite(m_compassSlaveAddr,  LSM303DLHC_CRB_M, crb);}

int writeRegCDC(char rAddr, int value) {	unsigned char cmd[2];	cmd[0] = rAddr;	cmd[1] = value;	I2CWrite(2, &cmd[0]);	while (isBusy())		;	return 1;}

static ssize_t eamp_setRegister(unsigned long int param){    AMP_Control * p = (AMP_Control*)param;    EAMP_PRINTK("");    if(p->param1 >7)        return -1;    return I2CWrite(p->param1,p->param2);}

bool RTIMULSM9DS0::setGyroSampleRate(){    unsigned char ctrl1;    switch (m_settings->m_LSM9DS0GyroSampleRate) {    case LSM9DS0_GYRO_SAMPLERATE_95:        ctrl1 = 0x0f;        m_sampleRate = 95;        break;    case LSM9DS0_GYRO_SAMPLERATE_190:        ctrl1 = 0x4f;        m_sampleRate = 190;        break;    case LSM9DS0_GYRO_SAMPLERATE_380:        ctrl1 = 0x8f;        m_sampleRate = 380;        break;    case LSM9DS0_GYRO_SAMPLERATE_760:        ctrl1 = 0xcf;        m_sampleRate = 760;        break;    default:        HAL_ERROR1("Illegal LSM9DS0 gyro sample rate code %d/n", m_settings->m_LSM9DS0GyroSampleRate);        return false;    }    m_sampleInterval = (uint64_t)1000000 / m_sampleRate;    switch (m_settings->m_LSM9DS0GyroBW) {    case LSM9DS0_GYRO_BANDWIDTH_0:        ctrl1 |= 0x00;        break;    case LSM9DS0_GYRO_BANDWIDTH_1:        ctrl1 |= 0x10;        break;    case LSM9DS0_GYRO_BANDWIDTH_2:        ctrl1 |= 0x20;        break;    case LSM9DS0_GYRO_BANDWIDTH_3:        ctrl1 |= 0x30;        break;    }    return (I2CWrite(m_gyroSlaveAddr, LSM9DS0_GYRO_CTRL1, ctrl1, "Failed to set LSM9DS0 gyro CTRL1"));}