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

error_t tcs34725Init(void){  uint8_t id = 0;  /* Initialise I2C */  i2cInit(I2CMASTER);  /* Ping the I2C device first to see if it exists! */  ASSERT(i2cCheckAddress(TCS34725_ADDRESS), ERROR_I2C_DEVICENOTFOUND);  /* Make sure we have the right IC (0x44 = TCS34725 and TCS34721) */  ASSERT_STATUS(tcs34725Read8(TCS34725_ID, &id));  ASSERT(id == 0x44, ERROR_DEVICENOTINITIALISED);  /* Enable the device */  ASSERT_STATUS(tcs34725Enable());  /* Ready to go ... set the initialised flag */  _tcs34725Initialised = true;  /* This needs to take place after the initialisation flag! */  ASSERT_STATUS(tcs34725SetIntegrationTime(TCS34725_INTEGRATIONTIME_2_4MS));  ASSERT_STATUS(tcs34725SetGain(TCS34725_GAIN_60X));  return ERROR_NONE;}

error_t pca9685SetPWM(uint16_t channel, uint16_t on, uint16_t off){  ASSERT(_pca9685Initialised, ERROR_DEVICENOTINITIALISED);  if (on > 0xFFF)  {    on = 0xFFF;  }  if (off < on)  {    off = on;  }  if (off > 0xFFF)  {    off = 0xFFF;  }  /* Set the on and off values */  ASSERT_STATUS(pca9685Write8(PCA9685_REG_LED0_ON_L+4*channel, on & 0xFF));  ASSERT_STATUS(pca9685Write8(PCA9685_REG_LED0_ON_H+4*channel, on >> 8));  ASSERT_STATUS(pca9685Write8(PCA9685_REG_LED0_OFF_L+4*channel, off & 0xFF));  ASSERT_STATUS(pca9685Write8(PCA9685_REG_LED0_OFF_H+4*channel, off >> 8));  return ERROR_NONE;}

err_t tsl2561GetData (uint16_t *broadband, uint16_t *ir){  /* Enable the device by setting the control bit to 0x03 */  ASSERT_STATUS(tsl2561Enable());  /* Wait x ms for ADC to complete */  switch (_tsl2561IntegrationTime)  {    case TSL2561_INTEGRATIONTIME_13MS:      delay(14);      break;    case TSL2561_INTEGRATIONTIME_101MS:      delay(102);      break;    default:      delay(403);      break;  }  /* Reads a two byte value from channel 0 (visible + infrared) */  ASSERT_STATUS(tsl2561Read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW, broadband));  /* Reads a two byte value from channel 1 (infrared) */  ASSERT_STATUS(tsl2561Read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW, ir));  /* Turn the device off to save power */  ASSERT_STATUS(tsl2561Disable());  return ERROR_NONE;}

error_t btle_init(void){    nrf_clock_lf_cfg_t clockConfiguration;    // Configure the LF clock according to values provided by btle_clock.h.    // It is input from the chain of the yotta configuration system.    clockConfiguration.source        = LFCLK_CONF_SOURCE;    clockConfiguration.xtal_accuracy = LFCLK_CONF_ACCURACY;    clockConfiguration.rc_ctiv       = LFCLK_CONF_RC_CTIV;    clockConfiguration.rc_temp_ctiv  = LFCLK_CONF_RC_TEMP_CTIV;    SOFTDEVICE_HANDLER_INIT(&clockConfiguration, signalEvent);    // Enable BLE stack    /**     * Using this call, the application can select whether to include the     * Service Changed characteristic in the GATT Server. The default in all     * previous releases has been to include the Service Changed characteristic,     * but this affects how GATT clients behave. Specifically, it requires     * clients to subscribe to this attribute and not to cache attribute handles     * between connections unless the devices are bonded. If the application     * does not need to change the structure of the GATT server attributes at     * runtime this adds unnecessary complexity to the interaction with peer     * clients. If the SoftDevice is enabled with the Service Changed     * Characteristics turned off, then clients are allowed to cache attribute     * handles making applications simpler on both sides.     */    static const bool IS_SRVC_CHANGED_CHARACT_PRESENT = true;    ble_enable_params_t ble_enable_params;    uint32_t err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,                                                    PERIPHERAL_LINK_COUNT,                                                    &ble_enable_params);    ble_enable_params.gatts_enable_params.attr_tab_size  = GATTS_ATTR_TAB_SIZE;    ble_enable_params.gatts_enable_params.service_changed  = IS_SRVC_CHANGED_CHARACT_PRESENT;    ble_enable_params.common_enable_params.vs_uuid_count = UUID_TABLE_MAX_ENTRIES;    if(err_code  != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    if (softdevice_enable(&ble_enable_params) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    ble_gap_addr_t addr;    if (sd_ble_gap_address_get(&addr) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    if (sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));    ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));    return btle_gap_init();}

error_t tcs34725Enable(void){  ASSERT_STATUS(tcs34725Write8(TCS34725_ENABLE, TCS34725_ENABLE_PON));  delay(3);  ASSERT_STATUS(tcs34725Write8(TCS34725_ENABLE, TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN));  return ERROR_NONE;}

error_t tcs34725Disable(void){  /* Turn the device off to save power */  uint8_t reg = 0;  ASSERT_STATUS(tcs34725Read8(TCS34725_ENABLE, &reg));  ASSERT_STATUS(tcs34725Write8(TCS34725_ENABLE, reg & ~(TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN)));  return ERROR_NONE;}

error_t lm75bConfigWrite (uint8_t configValue){  if (!_lm75bInitialised)  {    ASSERT_STATUS(lm75bInit());  }  ASSERT_STATUS(lm75bWrite8(LM75B_REGISTER_CONFIGURATION, configValue));  return ERROR_NONE;}

static void test_cycles_in_replacement() {  upb_symtab *s = upb_symtab_new(&s);  upb_msgdef *m = upb_msgdef_newnamed("M", &s);  upb_status status = UPB_STATUS_INIT;  upb_msgdef_addfield(m, newfield("m", 1, UPB_TYPE_MESSAGE,                                  UPB_LABEL_OPTIONAL, ".M", &s),                      &s, NULL);  ASSERT_STATUS(upb_symtab_add(s, (upb_def**)&m, 1, &s, &status), &status);  ASSERT_STATUS(upb_symtab_add(s, NULL, 0, &s, &status), &status);}

error_t tcs34725SetIntegrationTime(tcs34725IntegrationTime_t it){  if (!_tcs34725Initialised)  {    ASSERT_STATUS(tcs34725Init());  }  ASSERT_STATUS(tcs34725Write8(TCS34725_ATIME, it));  _tcs34725IntegrationTime = it;  return ERROR_NONE;}

error_t tcs34725SetGain(tcs34725Gain_t gain){  if (!_tcs34725Initialised)  {    ASSERT_STATUS(tcs34725Init());  }  ASSERT_STATUS(tcs34725Write8(TCS34725_CONTROL, gain));  _tcs34725Gain = gain;  return ERROR_NONE;}

error_t btle_init(void){    const bool useScheduler = false;#ifdef TARGET_HRM1017    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_4000MS_CALIBRATION, useScheduler);#else    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, useScheduler);#endif    // Enable BLE stack    /**     * Using this call, the application can select whether to include the     * Service Changed characteristic in the GATT Server. The default in all     * previous releases has been to include the Service Changed characteristic,     * but this affects how GATT clients behave. Specifically, it requires     * clients to subscribe to this attribute and not to cache attribute handles     * between connections unless the devices are bonded. If the application     * does not need to change the structure of the GATT server attributes at     * runtime this adds unnecessary complexity to the interaction with peer     * clients. If the SoftDevice is enabled with the Service Changed     * Characteristics turned off, then clients are allowed to cache attribute     * handles making applications simpler on both sides.     */    static const bool IS_SRVC_CHANGED_CHARACT_PRESENT = true;    ble_enable_params_t enableParams = {        .gatts_enable_params = {            .service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT        }    };    if (sd_ble_enable(&enableParams) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    ble_gap_addr_t addr;    if (sd_ble_gap_address_get(&addr) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    if (sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));    ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));#if NEED_BOND_MANAGER /* disabled by default */    bond_manager_init();#endif    btle_gap_init();    return ERROR_NONE;}

error_t tcs34725GetRawData(uint16_t *r, uint16_t *g, uint16_t *b, uint16_t *c){  if (!_tcs34725Initialised)  {    ASSERT_STATUS(tcs34725Init());  }  /* ToDo: Insert a blocky delay until the data is ready! */  ASSERT_STATUS(tcs34725Read16(TCS34725_CDATAL, c));  ASSERT_STATUS(tcs34725Read16(TCS34725_RDATAL, r));  ASSERT_STATUS(tcs34725Read16(TCS34725_GDATAL, g));  ASSERT_STATUS(tcs34725Read16(TCS34725_BDATAL, b));  return ERROR_NONE;}

error_t btle_init(void){    APP_TIMER_INIT(0, 8, 5, false);    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);    ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));    ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));#if NEED_BOND_MANAGER /* disabled by default */    bond_manager_init();#endif    btle_gap_init();    return ERROR_NONE;}

error_t btle_init(void){    nrf_clock_lfclksrc_t clockSource;    if (NRF_CLOCK->LFCLKSRC & (CLOCK_LFCLKSRC_SRC_Xtal << CLOCK_LFCLKSRC_SRC_Pos)) {        clockSource = NRF_CLOCK_LFCLKSRC_XTAL_20_PPM;    } else {        clockSource = NRF_CLOCK_LFCLKSRC_RC_250_PPM_4000MS_CALIBRATION;    }    SOFTDEVICE_HANDLER_INIT(clockSource, eventHandler);    // Enable BLE stack    /**     * Using this call, the application can select whether to include the     * Service Changed characteristic in the GATT Server. The default in all     * previous releases has been to include the Service Changed characteristic,     * but this affects how GATT clients behave. Specifically, it requires     * clients to subscribe to this attribute and not to cache attribute handles     * between connections unless the devices are bonded. If the application     * does not need to change the structure of the GATT server attributes at     * runtime this adds unnecessary complexity to the interaction with peer     * clients. If the SoftDevice is enabled with the Service Changed     * Characteristics turned off, then clients are allowed to cache attribute     * handles making applications simpler on both sides.     */    static const bool IS_SRVC_CHANGED_CHARACT_PRESENT = true;    ble_enable_params_t enableParams = {        .gatts_enable_params = {            .service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT,            .attr_tab_size = gatt_table_size        }    };    if (sd_ble_enable(&enableParams) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    ble_gap_addr_t addr;    if (sd_ble_gap_address_get(&addr) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    if (sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr) != NRF_SUCCESS) {        return ERROR_INVALID_PARAM;    }    ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));    ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));    return btle_gap_init();}

error_t custom_add_in_descriptor(uint16_t    char_handle,                                             ble_uuid_t *p_uuid,                                             uint8_t    *p_data,                                             uint16_t    length,                                             uint16_t    max_length,                                             uint16_t   *p_desc_handle){    /* Descriptor metadata */    ble_gatts_attr_md_t   desc_md = {0};    desc_md.vloc = BLE_GATTS_VLOC_STACK;    /* Always set variable size */    desc_md.vlen = 1;    /* Make it readable and writable */    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&desc_md.read_perm);    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&desc_md.write_perm);    ble_gatts_attr_t attr_desc = {0};    attr_desc.p_uuid    = p_uuid;    attr_desc.p_attr_md = &desc_md;    attr_desc.init_len  = length;    attr_desc.max_len   = max_length;    attr_desc.p_value   = p_data;    ASSERT_STATUS ( sd_ble_gatts_descriptor_add(char_handle,                                                &attr_desc,                                                p_desc_handle));    return ERROR_NONE;}

error_t adxl345GetSensorEvent(sensors_event_t *event){  int16_t x, y, z;  /* Clear the event */  memset(event, 0, sizeof(sensors_event_t));  event->version   = sizeof(sensors_event_t);  event->sensor_id = _adxl345SensorID;  event->type      = SENSOR_TYPE_ACCELEROMETER;  event->timestamp = systickGetTicks();  /* Retrieve values from the sensor */  ASSERT_STATUS(adxl345GetXYZ(&x, &y, &z));  /* The ADXL345 returns a raw value where each lsb represents 4mg.  To   * convert this to a normal g value, multiply by 0.004 and then convert   * it to the m/s^2 value that sensors_event_t is expecting. */  event->acceleration.x = x * ADXL345_MG2G_MULTIPLIER * SENSORS_GRAVITY_STANDARD;  event->acceleration.y = y * ADXL345_MG2G_MULTIPLIER * SENSORS_GRAVITY_STANDARD;  event->acceleration.z = z * ADXL345_MG2G_MULTIPLIER * SENSORS_GRAVITY_STANDARD;  printf("   %08d    %08d    %08d%s", x, y, z, CFG_PRINTF_NEWLINE);  return ERROR_NONE;}

err_t adxl345GetXYZ(int16_t *x, int16_t *y, int16_t *z){  int32_t i2cState;  if (!_adxl345Initialised)  {    ASSERT_STATUS(adxl345Init());  }  I2CWriteLength = 2;  I2CReadLength = 6;  I2CMasterBuffer[0] = ADXL345_ADDRESS;  I2CMasterBuffer[1] = ADXL345_REG_DATAX0;  I2CMasterBuffer[2] = ADXL345_ADDRESS | ADXL345_READBIT;  i2cState = i2cEngine();  /* Check if we got an ACK or TIMEOUT error */  ASSERT_I2C_STATUS(i2cState);  /* Shift values to create properly formed integer */  *x = (I2CSlaveBuffer[1] << 8) | (I2CSlaveBuffer[0]);  *y = (I2CSlaveBuffer[3] << 8) | (I2CSlaveBuffer[2]);  *z = (I2CSlaveBuffer[5] << 8) | (I2CSlaveBuffer[4]);  return ERROR_NONE;}

error_t adxl345SetRange(adxl345_range_t range){  uint8_t format;  /* Red the data format register to preserve bits */  ASSERT_STATUS(adxl345Read8(ADXL345_REG_DATA_FORMAT, &format));  /* Update the data rate */  format &= ~0x0F;  format |= range;  /* Write the register back to the IC */  ASSERT_STATUS(adxl345Write8(ADXL345_REG_DATA_FORMAT, format));  return ERROR_NONE;}

error_t tcs34725GetSensorEvent(sensors_event_t *event){  float maxCount;  uint16_t r, g, b, c;  /* Clear the event */  memset(event, 0, sizeof(sensors_event_t));  event->version   = sizeof(sensors_event_t);  event->sensor_id = _tcs34725SensorID;  event->type      = SENSOR_TYPE_COLOR;  event->timestamp = delayGetTicks();  /* Get the raw RGB values */  ASSERT_STATUS(tcs34725GetRawData(&r, &g, &b, &c));  /* Convert RGB values to floats */  maxCount = (256 - _tcs34725IntegrationTime) * 1024;  event->color.r = r / maxCount;  event->color.g = g / maxCount;  event->color.b = b / maxCount;  /* Convert to a 24-bit ARGB value */  event->color.rgba = (uint8_t)(event->color.r * 0xFF) << 16|                      (uint8_t)(event->color.g * 0xFF) << 8 |                      (uint8_t)(event->color.b * 0xFF) |                      0xFF000000;  return ERROR_NONE;}

err_t adxl345GetDataRate(adxl345_dataRate_t *dataRate){  uint8_t results;  ASSERT_STATUS(adxl345Read8(ADXL345_REG_BW_RATE, &results));  *dataRate = (adxl345_dataRate_t)(results & 0x0F);  return ERROR_NONE;}

err_t lsm303magSetGain(lsm303MagGain_t gain){  if (!_lsm303magInitialised)  {    ASSERT_STATUS(lsm303magInit());  }  // Enable the device by setting the control bit to 0x03  ASSERT_STATUS(lsm303magWrite8(LSM303_ADDRESS_MAG, LSM303_REGISTER_MAG_CRB_REG_M, (uint8_t)gain));  _lsm303magGain = gain;  switch(gain)  {    case LSM303_MAGGAIN_1_3:      _lsm303mag_Gauss_LSB_XY = 1100;      _lsm303mag_Gauss_LSB_Z = 980;      break;    case LSM303_MAGGAIN_1_9:      _lsm303mag_Gauss_LSB_XY = 855;      _lsm303mag_Gauss_LSB_Z = 760;      break;    case LSM303_MAGGAIN_2_5:      _lsm303mag_Gauss_LSB_XY = 670;      _lsm303mag_Gauss_LSB_Z = 600;      break;    case LSM303_MAGGAIN_4_0:      _lsm303mag_Gauss_LSB_XY = 450;      _lsm303mag_Gauss_LSB_Z = 400;      break;    case LSM303_MAGGAIN_4_7:      _lsm303mag_Gauss_LSB_XY = 400;      _lsm303mag_Gauss_LSB_Z = 255;      break;    case LSM303_MAGGAIN_5_6:      _lsm303mag_Gauss_LSB_XY = 330;      _lsm303mag_Gauss_LSB_Z = 295;      break;    case LSM303_MAGGAIN_8_1:      _lsm303mag_Gauss_LSB_XY = 230;      _lsm303mag_Gauss_LSB_Z = 205;      break;  }  return ERROR_NONE;}

err_t adxl345GetRange(adxl345_range_t *range){  uint8_t results;  ASSERT_STATUS(adxl345Read8(ADXL345_REG_DATA_FORMAT, &results));  *range = (adxl345_range_t)(results & 0x03);  return ERROR_NONE;}

err_t adxl345SetDataRate(adxl345_dataRate_t dataRate){  /* Note: The LOW_POWER bits are currently ignored and we always keep     the device in 'normal' mode */  ASSERT_STATUS(adxl345Write8(ADXL345_REG_BW_RATE, dataRate));  return ERROR_NONE;}

err_t tsl2561Init(void){  /* Initialise I2C */  i2cInit(I2CMASTER);  /* Ping the I2C device first to see if it exists! */  ASSERT(i2cCheckAddress(TSL2561_ADDRESS), ERROR_I2C_DEVICENOTFOUND);  /* Note: by default, the device is in power down mode on bootup */  _tsl2561Initialised = true;  /* Set default integration time and gain */  ASSERT_STATUS(tsl2561SetIntegrationTime(_tsl2561IntegrationTime));  ASSERT_STATUS(tsl2561SetGain(_tsl2561Gain));  return ERROR_NONE;}

error_t lm75bGetTemperature (int32_t *temp){  if (!_lm75bInitialised)  {    ASSERT_STATUS(lm75bInit());  }  /* Turn device on */  ASSERT_STATUS(lm75bConfigWrite (LM75B_CONFIG_SHUTDOWN_POWERON));  /* Read temperature */  ASSERT_STATUS(lm75bRead16 (LM75B_REGISTER_TEMPERATURE, temp));  /* Shut device back down */  ASSERT_STATUS(lm75bConfigWrite (LM75B_CONFIG_SHUTDOWN_SHUTDOWN));  return ERROR_NONE;}

err_t lsm303magInit(void){  // Initialise I2C  i2cInit(I2CMASTER);  /* Ping the I2C device first to see if it exists! */  ASSERT(i2cCheckAddress(LSM303_ADDRESS_MAG), ERROR_I2C_DEVICENOTFOUND);  /* Enable the magnetometer (continuous conversion) */  ASSERT_STATUS(lsm303magWrite8(LSM303_ADDRESS_MAG, LSM303_REGISTER_MAG_MR_REG_M, 0x00));  _lsm303magInitialised = true;  /* Set default gain */  ASSERT_STATUS(lsm303magSetGain(_lsm303magGain));  return ERROR_NONE;}

int main(void){   app_timer_id_t blinky_timer_id;    /* Initialize the target HW */  boardInit();    /* Initialise BLE and start advertising as an iBeacon */  btle_init();  /* Initialise a 1 second blinky timer to show that we're alive */  ASSERT_STATUS ( app_timer_create(&blinky_timer_id, APP_TIMER_MODE_REPEATED, blinky_handler) );  ASSERT_STATUS ( app_timer_start (blinky_timer_id, APP_TIMER_TICKS(1000, CFG_TIMER_PRESCALER), NULL) );  while(true)  {  }}

error_t custom_add_in_characteristic(uint16_t service_handle, ble_uuid_t* p_uuid, uint8_t properties,                                     uint8_t *p_data, uint16_t min_length, uint16_t max_length,                                     ble_gatts_char_handles_t* p_char_handle){  /* Characteristic metadata */  ble_gatts_attr_md_t cccd_md;  ble_gatt_char_props_t char_props;  memcpy(&char_props, &properties, 1);  if ( char_props.notify || char_props.indicate )  {     /* Notification requires cccd */    memclr_( &cccd_md, sizeof(ble_gatts_attr_md_t) );    cccd_md.vloc = BLE_GATTS_VLOC_STACK;    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);  }  ble_gatts_char_md_t char_md = { 0 };  char_md.char_props = char_props;  char_md.p_cccd_md  = (char_props.notify || char_props.indicate ) ? &cccd_md : NULL;  /* Attribute declaration */  ble_gatts_attr_md_t attr_md = { 0 };  attr_md.vloc = BLE_GATTS_VLOC_STACK;  attr_md.vlen = (min_length == max_length) ? 0 : 1;  if ( char_props.read || char_props.notify || char_props.indicate )  {    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);  }  if ( char_props.write )  {    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);  }  ble_gatts_attr_t    attr_char_value = { 0 };  attr_char_value.p_uuid    = p_uuid;  attr_char_value.p_attr_md = &attr_md;  attr_char_value.init_len  = min_length;  attr_char_value.max_len   = max_length;  attr_char_value.p_value   = p_data;  ASSERT_STATUS ( sd_ble_gatts_characteristic_add(service_handle,                                                  &char_md,                                                  &attr_char_value,                                                  p_char_handle) );  return ERROR_NONE;}

err_t adxl345SetRange(adxl345_range_t range){  uint8_t format;  /* Red the data format register to preserve bits */  ASSERT_STATUS(adxl345Read8(ADXL345_REG_DATA_FORMAT, &format));  /* Update the data rate */  format &= ~0x0F;  format |= range;  /* Make sure that the FULL-RES bit is enabled for range scaling */  format |= 0x08;  /* Write the register back to the IC */  ASSERT_STATUS(adxl345Write8(ADXL345_REG_DATA_FORMAT, format));  return ERROR_NONE;}

static void test_replacement() {  upb_symtab *s = upb_symtab_new(&s);  upb_enumdef *e2;  upb_msgdef *m2;  upb_enumdef *e;  upb_status status = UPB_STATUS_INIT;  upb_def *newdefs[3];  upb_def *newdefs2[1];  const upb_msgdef *m3;  upb_msgdef *m = upb_msgdef_newnamed("MyMessage", &s);  upb_msgdef_addfield(m, newfield("field1", 1, UPB_TYPE_ENUM,                                  UPB_LABEL_OPTIONAL, ".MyEnum", &s),                      &s, NULL);  m2 = upb_msgdef_newnamed("MyMessage2", &s);  e = upb_enumdef_newnamed("MyEnum", &s);  ASSERT_STATUS(upb_enumdef_addval(e, "VAL1", 1, &status), &status);  newdefs[0] = upb_msgdef_upcast_mutable(m);  newdefs[1] = upb_msgdef_upcast_mutable(m2);  newdefs[2] = upb_enumdef_upcast_mutable(e);  ASSERT_STATUS(upb_symtab_add(s, newdefs, 3, &s, &status), &status);  /* Try adding a new definition of MyEnum, MyMessage should get replaced with   * a new version. */  e2 = upb_enumdef_newnamed("MyEnum", &s);  ASSERT_STATUS(upb_enumdef_addval(e2, "VAL1", 1, &status), &status);  newdefs2[0] = upb_enumdef_upcast_mutable(e2);  ASSERT_STATUS(upb_symtab_add(s, newdefs2, 1, &s, &status), &status);  m3 = upb_symtab_lookupmsg(s, "MyMessage");  ASSERT(m3);  /* Must be different because it points to MyEnum which was replaced. */  ASSERT(m3 != m);  m3 = upb_symtab_lookupmsg(s, "MyMessage2");  /* Should be the same because it was not replaced, nor were any defs that   * are reachable from it. */  ASSERT(m3 == m2);  upb_symtab_unref(s, &s);}