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

void MMA_init(void) {		uint8_t data2[2];		twi_master_transfer(MMA_ADDRESS, mma_init_cmd, 2, TWI_ISSUE_STOP);        twi_master_transfer(MMA_ADDRESS, mma_init_cmd2, 2, TWI_ISSUE_STOP);		twi_master_transfer(MMA_ADDRESS, mma_reg_who_am_i, 1, TWI_DONT_ISSUE_STOP);		twi_master_transfer(MMA_ADDRESS | TWI_READ_BIT, data2, 1, TWI_ISSUE_STOP);}

bool fb_getTopLEDs(uint8_t faceNum, bool *redOn, bool *greenOn, bool *blueOn) {    uint8_t twiBuf[2];    bool success = true;    if ((faceNum < 1) || (faceNum > 6)) {	return false;    }    twi_master_init();    twiBuf[0] = FB_REGISTER_ADDR_LEDS_TOP;    success &= twi_master_transfer((faceNum << 1), twiBuf, 1, true);    success &= twi_master_transfer((faceNum << 1) | TWI_READ_BIT, twiBuf, 1, true);    twi_master_deinit();    if (success) {	*redOn = (twiBuf[0] & 0x01) ? true : false;	*greenOn = (twiBuf[0] & 0x02) ? true : false;	*blueOn = (twiBuf[0] & 0x04) ? true : false;    }    return success;}

bool fb_getIRTxLEDs(uint8_t faceNum, bool *led1, bool *led2, bool *led3, bool *led4) {    uint8_t twiBuf[2];    bool success = true;    if ((faceNum < 1) || (faceNum > 6)) {	return -1;    }    twi_master_init();    twiBuf[0] = FB_REGISTER_ADDR_TX_LED_SELECT;    success &= twi_master_transfer((faceNum << 1), twiBuf, 1, true);    success &= twi_master_transfer((faceNum << 1) | TWI_READ_BIT, twiBuf, 1, true);    twi_master_deinit();    if (success) {	*led1 = (twiBuf[0] & 0x01) ? true : false;	*led2 = (twiBuf[0] & 0x02) ? true : false;	*led3 = (twiBuf[0] & 0x04) ? true : false;	*led4 = (twiBuf[0] & 0x08) ? true : false;    }    return success;}

bool fb_getRxEnable(uint8_t faceNum, bool *rxEnabled) {    uint8_t twiBuf[2];    bool success = true;    if (faceNum > 6) {	return -1;    }    twi_master_init();    twiBuf[0] = FB_REGISTER_ADDR_RX_ENABLE;    success &= twi_master_transfer((faceNum << 1), twiBuf, 1, true);    success &= twi_master_transfer((faceNum << 1) | TWI_READ_BIT, twiBuf, 1, true);    twi_master_deinit();    if (twiBuf[0] & 0x01) {	*rxEnabled = true;    } else {	*rxEnabled = false;    }    return success;}

bool mpu6050_register_read(uint8_t register_address, uint8_t *destination, uint8_t number_of_bytes){  bool transfer_succeeded;  transfer_succeeded = twi_master_transfer(m_device_address, &register_address, 1, TWI_DONT_ISSUE_STOP);  transfer_succeeded &= twi_master_transfer(m_device_address|TWI_READ_BIT, destination, number_of_bytes, TWI_ISSUE_STOP);  return transfer_succeeded;}

int16_t fb_getAmbientLight(uint8_t faceNum) {    uint8_t twiBuf[2];    bool success = true;    int16_t ambientLight;    if ((faceNum < 1) || (faceNum > 6)) {	return -1;    }    twi_master_init();    twiBuf[0] = FB_REGISTER_ADDR_AMBIENT_LIGHT;    success &= twi_master_transfer((faceNum << 1), twiBuf, 1, true);    success &= twi_master_transfer((faceNum << 1) | TWI_READ_BIT, twiBuf, 2, true);    twi_master_deinit();    /* The 10-bit result is returned left-shifted so that it is possible to     * read just one byte and still get most of the resolution (even though     * we still read both bytes). */    ambientLight  = twiBuf[0] << 2;    ambientLight |= twiBuf[1] >> 6;    if (!success) {	ambientLight = -1;    }    return ambientLight;}

bool AT24CXX_ReadOneByte(uint8_t register_address, uint8_t *destination, uint8_t number_of_bytes){  bool transfer_succeeded;  transfer_succeeded = twi_master_transfer(AT24XXADDRESS, &register_address, 1, TWI_DONT_ISSUE_STOP);  transfer_succeeded &= twi_master_transfer(AT24XXADDRESS|TWI_READ_BIT, destination, number_of_bytes, TWI_ISSUE_STOP);  return transfer_succeeded;}

/** * @brief Function for reading the current configuration of the sensor. * * @return uint8_t Zero if communication with the sensor failed. Contents (always non-zero) of configuration register (@ref SHT2X_ONESHOT_MODE and @ref SHT2X_CONVERSION_DONE) if communication succeeded. */static sht2x_error_t sht2x_config_read(user_register_t* user_register){  read_config_result_t result;  sht2x_error_t error = SHT2X_ERROR_NONE;  uint8_t command = USER_REG_R;  // Write: command protocol  if (twi_master_transfer(SHT2X_I2C_ADDRESS, &command, 1, TWI_DONT_ISSUE_STOP))  {    if (twi_master_transfer(SHT2X_I2C_ADDRESS | TWI_READ_BIT, (uint8_t*)&result.raw, sizeof(read_config_result_t), TWI_DONT_ISSUE_STOP)) // Read: current configuration    {      // validate checksum      uint8_t checksum_error = sht2x_check_crc((uint8_t*)&result.result.user_register, sizeof(user_register_t), result.result.checksum);      if (checksum_error == SHT2X_ERROR_CRC || checksum_error)      {        // propagate out the error.  Poor design probably.        return SHT2X_ERROR_CRC;      }      // Read succeeded      *user_register = result.raw;    }    else    {      error = SHT2X_ERROR_READ_FAILED;    }  }  else  {    error = SHT2X_ERROR_READ_FAILED;  }  return error;}

static voidadc121c02_read_register(uint8_t addr, void *data, size_t len){        uint8_t cmd[] = { addr };        twi_master_transfer(ADC121C02, cmd, sizeof(cmd), TWI_DONT_ISSUE_STOP);        twi_master_transfer(ADC121C02 | TWI_READ_BIT, data, len, TWI_ISSUE_STOP);}

bool hs3000a_read(uint8_t register_address, uint8_t * destination, uint8_t number_of_bytes){    bool transfer_succeeded;	    transfer_succeeded  = twi_master_transfer(HS3000A_ADDR, &register_address, 1, TWI_DONT_ISSUE_STOP);    transfer_succeeded &= twi_master_transfer(HS3000A_ADDR|TWI_READ_BIT, destination, number_of_bytes, TWI_ISSUE_STOP);    return transfer_succeeded;}

bool read_registers(uint8_t device_address, uint8_t register_address, int size, uint8_t *value){  bool transfer_succeeded = true;  transfer_succeeded &= twi_master_transfer(device_address, &register_address, 1, TWI_DONT_ISSUE_STOP);  if (transfer_succeeded)   {    transfer_succeeded &= twi_master_transfer(device_address | TWI_READ_BIT, value, size, TWI_ISSUE_STOP);  }  return transfer_succeeded;}  

bool mpu6050_readBytes(uint8_t addr, uint8_t *data, uint8_t nBytes) {	bool success = true;	/* The caller must initialize the TWI interface */	if (!twi_master_get_init()) {		return false;	}	success &= twi_master_transfer((mpu6050Address<<1), &addr, 1, TWI_DONT_ISSUE_STOP);	success &= twi_master_transfer((mpu6050Address<<1) | TWI_READ_BIT, data, nBytes, TWI_ISSUE_STOP);	return success;}

bool db_getVersion(char *verStr, uint8_t verStrSize) {    uint8_t twiBuf[34];    uint32_t time_ms;    char *strPtr;    twi_master_init();    twiBuf[0] = DB_VERSION_CMD;    if (!twi_master_transfer((DB_TWI_ADDR << 1), twiBuf, 1, true)) {	twi_master_deinit();	return false;    }    delay_ms(DB_POLL_FIRST_INTERVAL_MS);    for (time_ms = 0; time_ms < DB_VERSION_TIMEOUT_MS; time_ms += DB_POLL_INTERVAL_MS) {	if (!twi_master_transfer((DB_TWI_ADDR << 1) | TWI_READ_BIT, twiBuf, sizeof(twiBuf), true)) {	    /* If the daughterboard fails to respond to the I2C master read,	     * something is wrong, so we return failure. */	    twi_master_deinit();	    return false;	}	/* If the daughterboard responds and echoes the command code in the the	 * first byte, and the second byte is 0x01, the version command was	 * successful. */	if ((twiBuf[0] == DB_VERSION_CMD) && (twiBuf[1] == 0x01)) {	    /* The following bytes contain a human-readable version string. */	    strPtr = (char *)&twiBuf[2];	    /* If the version string will fit into the buffer provided by the	     * caller, we copy it.  Otherwise, we copy whatever will fit and	     * add a null-terminator. */	    if (strlen(strPtr) < verStrSize) {		strcpy(verStr, strPtr);	    } else {		strncpy(verStr, strPtr, verStrSize - 1);		verStr[verStrSize-1] = '/0';	    }	    twi_master_deinit();	    return true;	}	/* If the daughterboard responded but has not yet processed the command	 * we delay and then try to read from the daughterboard again. */	delay_ms(DB_POLL_INTERVAL_MS);    }    twi_master_deinit();    return false;}

bool db_setLEDs(bool redOn, bool greenOn, bool blueOn) {    uint8_t twiBuf[2];    uint32_t time_ms;    twi_master_init();    twiBuf[0] = DB_LED_CMD;    twiBuf[1] = 0x00;    if (redOn) {	twiBuf[1] |= 0x01;    }    if (greenOn) {	twiBuf[1] |= 0x02;    }    if (blueOn) {	twiBuf[1] |= 0x04;    }    if (!twi_master_transfer((DB_TWI_ADDR << 1), twiBuf, 2, true)) {	twi_master_deinit();	return false;    }    delay_ms(DB_POLL_FIRST_INTERVAL_MS);    for (time_ms = 0; time_ms < DB_LED_TIMEOUT_MS; time_ms += DB_POLL_INTERVAL_MS) {	if (!twi_master_transfer((DB_TWI_ADDR << 1) | TWI_READ_BIT, twiBuf, sizeof(twiBuf), true)) {	    /* If the daughterboard fails to respond to the I2C master read,	     * something is wrong, so we return failure. */	    twi_master_deinit();	    return false;	}	/* If the daughterboard responds and echoes the command code in the the	 * first byte, and the second byte is 0x01, the temperature command was	 * successful. */	if ((twiBuf[0] == DB_LED_CMD) && (twiBuf[1] == 0x01)) {	    twi_master_deinit();	    return true;	}	/* If the daughterboard responded but has not yet processed the command	 * we delay and then try to read from the daughterboard again. */	delay_ms(DB_POLL_INTERVAL_MS);    }    twi_master_deinit();    return false;}

bool nrf6350_lcd_set_contrast(uint8_t contrast){  nrf_delay_us(10000);  data_buffer[0] = FUNC_SET;  data_buffer[1] = 0x70 | contrast;  return twi_master_transfer(LCD_ADDR << 1, data_buffer, 2, TWI_ISSUE_STOP);}

static bool nrf6350_lcd_set_instruction(uint8_t instr){  nrf_delay_us(10000);  data_buffer[0] = FUNC_SET;  data_buffer[1] = instr;  return twi_master_transfer(LCD_ADDR << 1, data_buffer, 2, TWI_ISSUE_STOP);}

bool ds1624_init(uint8_t device_address){    bool transfer_succeeded = true;    m_device_address = DS1634_BASE_ADDRESS + (uint8_t)(device_address << 1);    uint8_t config = ds1624_config_read();    if (config != 0)    {        // Configure DS1624 for 1SHOT mode if not done so already.        if (!(config & DS1624_ONESHOT_MODE))        {            uint8_t data_buffer[2];            data_buffer[0] = command_access_config;            data_buffer[1] = DS1624_ONESHOT_MODE;            transfer_succeeded &= twi_master_transfer(m_device_address, data_buffer, 2, TWI_ISSUE_STOP);        }    }    else    {        transfer_succeeded = false;    }    return transfer_succeeded;}

bool  nrf6350_js_get_value(int8_t *val){  uint8_t js_data;  if (!twi_master_transfer(JS_ADDR << 1 | TWI_READ_BIT, data_buffer, 1, TWI_ISSUE_STOP))    return false;  js_data = (~data_buffer[0] & 0x1D);        // Select the useful bits.  if((js_data & 0x01) != 0)                  // Check joystick position.  {    val[X] = -1;  }  else if((js_data & 0x10) != 0)  {    val[X] = 1;  }  else  {    val[X] = 0;  }  if((js_data & 0x04) != 0)  {    val[Y] = 1;  }  else if((js_data & 0x08) != 0)  {    val[Y] = -1;  }  else  {    val[Y] = 0;  }  return true;}

bool fb_sleep(uint8_t faceNum, bool sleepEnabled) {    uint8_t twiBuf[2];    bool success;    if (faceNum > 6) {	return false;    }    twi_master_init();    twiBuf[0] = FB_REGISTER_ADDR_SLEEP;    if (sleepEnabled) {	twiBuf[1] = 0x01;    } else {	twiBuf[1] = 0x00;    }    success = twi_master_transfer((faceNum << 1), twiBuf, 2, true);    /* After sending a sleep command, we do not attempt to read a response     * because doing so will wake-up the daughterboard processor. */    twi_master_deinit();    return success;}

bool nrf6350_lcd_off(void){  nrf_delay_us(10000);  data_buffer[0] = FUNC_SET;  data_buffer[1] = 0x08;  return twi_master_transfer(LCD_ADDR << 1, data_buffer, 2, TWI_ISSUE_STOP);}

bool AT24CXX_WriteOneByte(uint8_t register_address, uint8_t value){		uint8_t w2_data[2];		w2_data[0] = register_address;	w2_data[1] = value;  return twi_master_transfer(AT24XXADDRESS, w2_data, 2, TWI_ISSUE_STOP);	  }

// send datasize_t rgb_lcd_write(uint8_t value){    unsigned char dta[2] = {0x40, value};// ardunio:    i2c_send_byteS(dta, 2);    twi_master_transfer (LCD_ADDRESS, dta, 2, true);    return 1; // assume sucess}

/**********************************************//// write cmd api**********************************************/void Write_Command(uint8_t command){    uint8_t send[2];    // send[0] = Slave_Address;    send[0] = OP_Command;    send[1] = command;    twi_master_transfer(Slave_Address, send, 2 ,TWI_ISSUE_STOP );}

/**********************************************//// write data api//**********************************************/void Write_Data(uint8_t data){    uint8_t send[2];    // send[0] = Slave_Address;    send[0] = OP_Data;    send[1] = data;    twi_master_transfer(Slave_Address, send, 2 ,TWI_ISSUE_STOP );}

bool mpu6050_writeBytes(uint8_t *addrData, uint8_t nBytes) {	/* The caller must initialize the TWI interface */	if (!twi_master_get_init()) {		return false;	}	return twi_master_transfer((mpu6050Address<<1), addrData, nBytes, TWI_ISSUE_STOP);}

char mpu6050_read(uint8_t device_addr, uint8_t register_addr, uint8_t *register_data, uint8_t read_length){    if(read_length < 1)    {        xprintf("read length error./r/n");        return false;    }    else    {        device_addr = (device_addr << 1) & 0xFE;        twi_master_transfer(device_addr, &register_addr, 1, TWI_DONT_ISSUE_STOP); // write                device_addr = device_addr | 0x01;        twi_master_transfer(device_addr, register_data, read_length, TWI_ISSUE_STOP); // read        return true;    }}

bool mpu6050_register_write(uint8_t register_address, uint8_t value){		uint8_t w2_data[2];		w2_data[0] = register_address;	w2_data[1] = value;  return twi_master_transfer(m_device_address, w2_data, 2, TWI_ISSUE_STOP);	  }

static bool hs3000a_write(uint8_t register_address, uint8_t value){    uint8_t w2_data[2];    w2_data[0] = register_address;    w2_data[1] = value;    return twi_master_transfer(HS3000A_ADDR, w2_data, 2, TWI_ISSUE_STOP);}

voidtcs3771_init(void){        uint8_t data[] = {                TCS3771_CONTROL_PDIODE_IR        };        tcs3771_write_register(TCS3771_CONTROL, data, sizeof(data));        uint8_t data2[] = {                1        };        tcs3771_write_register(TCS3771_PPULSE, data2, sizeof(data2));        uint8_t data3[] = {                216        };        tcs3771_write_register(TCS3771_WTIME, data3, sizeof(data3));        uint16_t data4[] = {                0x130,          /* lower limit */                0x170           /* high limit */        };        tcs3771_write_register(TCS3771_PILT, data4, sizeof(data4));        uint16_t data6[] = {                0x130,          /* lower limit */                0x170           /* high limit */        };        tcs3771_write_register(TCS3771_AILT, data6, sizeof(data6));        uint8_t data5[] = {                TCS3771_PERS_PPERS(10)        };        tcs3771_write_register(TCS3771_PERS, data5, sizeof(data5));        uint8_t data1[] = {                TCS3771_ENABLE_PON | TCS3771_ENABLE_PEN | TCS3771_ENABLE_WEN | TCS3771_ENABLE_AEN | TCS3771_ENABLE_PIEN | TCS3771_ENABLE_AIEN        };        tcs3771_write_register(TCS3771_ENABLE, data1, sizeof(data1));        //reset RGBC and PROX INTs        uint8_t int_reset[] = {                // 0x05 CLEAR PROX INT                // 0x06 CLEAR RGBC INT                // 0x07 CLEAR BOTH INT                TCS3771_COMMAND_SELECT | TCS3771_COMMAND_TYPE_SPECIAL | 0x07        };        twi_master_transfer(TCS3771, int_reset, sizeof(int_reset), TWI_ISSUE_STOP);                uint8_t rgb_cycles[] = {                252        };        tcs3771_write_register(TCS3771_ATIME, rgb_cycles, sizeof(rgb_cycles));        uint8_t prox_cycles[] = {                254        };        tcs3771_write_register(TCS3771_PTIME, prox_cycles, sizeof(prox_cycles));}

bool nrf6350_lcd_clear(void){  nrf_delay_us(10000);  data_buffer[0] = FUNC_SET;  data_buffer[1] = (uint8_t)(DDRAM_ADR + LCD_UPPER_LINE);  if (!twi_master_transfer(LCD_ADDR << 1, data_buffer, 2, TWI_ISSUE_STOP))    return false;  if (!twi_master_transfer(LCD_ADDR << 1, empty_str, 18, TWI_ISSUE_STOP))  {    return false;  }  data_buffer[1] = DDRAM_ADR + LCD_LOWER_LINE;  if (!twi_master_transfer(LCD_ADDR << 1, data_buffer, 2, TWI_ISSUE_STOP))    return false;  if (!twi_master_transfer(LCD_ADDR << 1, empty_str, 18, TWI_ISSUE_STOP))    return false;  return true;}