uint16_t motor_i2c_get_rpm(uint16_t mot_i2c_dev_addr) { i2c_package package_write, package_read; // set up I2C package for the read command to be passed to the I2C subsystem package_write.data[0] = MOT_GET_RPM_CMD; // command to read RPM from motor controller package_write.length = 1; // 1 command byte package_write.direction = I2C_WRITE; // I2C write operation package_write.slave_address = mot_i2c_dev_addr; // I2C slave address of selected motor controller package_write.bus_number = MOT_I2C_BUS_NUMBER; // number of the I2C bus, that the motor controller is connected to package_write.write_read = 1; // repeated start condition at completion package_write.i2c_done_handler = NULL; // nothing to be done at I2C completion // set up I2C package for the data read-out to be passed to the I2C subsystem package_read.length = 2; // 2 bytes for MSB and LSB of current RPM value to be read package_read.direction = I2C_READ; // I2C read operation package_read.slave_address = mot_i2c_dev_addr; // I2C slave address of selected motor controller package_read.bus_number = MOT_I2C_BUS_NUMBER; // number of the I2C bus, that the motor controller is connected to package_read.write_read = 1; // repeated start condition at start package_read.i2c_done_handler = (void*)&mot_save_rpm_after_read; // mot_save_rpm_after_read() is called at I2C completion mot_rpm_data_ready = 0; // invalidate old RPM value i2c_write_read(&package_write, &package_read); // start RPM read operation while(!mot_rpm_data_ready) ; // wait for I2C operation to complete return current_rpm; // return current RPM value }
EOWError ow_reset(void) { uint8_t test, ret; i2c_write(ds2482_address, &ds2482_reset, 1 ); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } ow_wait_on_busy(); i2c_write_read(ds2482_address, NULL, 0, &test, 1); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } test |= ds2482_pulse_detect; if (test == ds2482_busy) { return eOWSuccess; } else { return eOWNoPresencePulse; } }
/** * Datentransfer per I2C-Bus * \param *pData Container mit den Daten fuer den Treiber * \return Resultat der Aktion */ uint8_t Send_to_TWI(tx_type_t * pData) { uint8_t toRead = 0; uint8_t toWrite = 0; uint8_t * pWrite = NULL; uint8_t * pRead = NULL; tx_type_t * ptr = pData; if (ptr == NULL) return TW_BUS_ERROR; /* Datenformat einlesen */ for (; ptr->slave_adr != OWN_ADR; ptr++) { if ((ptr->slave_adr & 0x1) == 1) { /* zu lesende Daten */ toRead = ptr->size; pRead = ptr->data_ptr; } else { /* zu sendende Daten */ toWrite = ptr->size; pWrite = ptr->data_ptr; } } /* Daten senden und empfangen per i2c-Treiber (blockierend) */ i2c_write_read(pData->slave_adr, pWrite, toWrite, pRead, toRead); uint8_t result = i2c_wait(); return (uint8_t) (result == TW_NO_INFO ? SUCCESS : result); }
int8_t ow_triplet(uint8_t* direction, uint8_t* first_bit, uint8_t* second_bit) { uint8_t send_buf[2], recv_buf; send_buf[0] = 0x78; // TODO why? if (*direction) { *direction = 0xFF; } send_buf[1] = *direction; // TODO Prüfe, ob hier write und read in einem schnurz gemacht werden darf! i2c_write(ds2482_address, send_buf, 2); uint8_t result = i2c_wait(); if ( result != TW_NO_INFO) { // According to the application notes of the DS2482 something is fishy here. // For now we just ignore the I2C bus error, it seems to work anyway... } i2c_write_read(ds2482_address, NULL, 0, &recv_buf, 1); if (i2c_wait() != TW_NO_INFO) { return eOWNoResponse; } *first_bit = ((recv_buf & 0x20) != 0); *second_bit = ((recv_buf & 0x40) != 0); *direction = ((recv_buf & 0x80) != 0); return eOWSuccess; }
int8_t ow_read_bit(void) { uint8_t buffer[2], ret; ow_write_bit(1); buffer[0] = ds2482_read_pointer_cmd; buffer[1] = ds2482_status_register; i2c_write(ds2482_address, buffer, 2); ret = i2c_wait(); if (ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } // TODO Prüfe, ob hier write und read in einem schnurz gemacht werden könnte! i2c_write_read(ds2482_address, NULL, 0, buffer, 1); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } if (buffer[0] & 0x20) { return 1; } else { return 0; } }
/******************************************************************************* * Function Name : LIS3DH_ReadReg * Description : Generic Reading function. It must be fullfilled with either * : I2C or SPI reading functions * Input : Register Address * Output : Data REad * Return : None *******************************************************************************/ u8_t LIS3DH_ReadReg(u8_t Reg, u8_t* Data) { //To be completed with either I2c or SPI reading function //i.e. *Data = SPI_Mems_Read_Reg( Reg ); i2c_buffer[0] = Reg; return (i2c_write_read(i2c, LIS3DH_MEMS_I2C_ADDRESS, i2c_buffer, 1, Data, 1) == i2cTransferDone); }
cell i2c_le_rw(cell stop, cell slave, cell reg) { uint8_t rval[2]; uint8_t regb[1] = { reg }; if (i2c_write_read(stop, slave, 2, rval, 1, regb)) return -1; return (rval[1]<<8) + rval[0]; }
cell i2c_rb(int stop, int slave, int reg) { uint8_t rval[1]; uint8_t regb[1] = { reg }; if (i2c_write_read(stop, slave, 1, rval, 1, regb)) return -1; return rval[0]; }
int rcpod_I2CRead(rcpod_dev* rcpod, rcpod_i2c_dev* idev, unsigned char* read_buffer, int read_count) { if (!rcpod_HasAcceleratedI2C(rcpod)) return softi2c_read(rcpod, idev, read_buffer, read_count); if (i2c_set_dev(rcpod, idev) < 0) return 0; if (read_count <= 8 && read_count > 0) return i2c_read8(rcpod, read_buffer, read_count); return i2c_write_read(rcpod, NULL, 0, read_buffer, read_count); }
int rcpod_I2CWrite(rcpod_dev* rcpod, rcpod_i2c_dev* idev, const unsigned char* write_buffer, int write_count) { if (!rcpod_HasAcceleratedI2C(rcpod)) return softi2c_write(rcpod, idev, write_buffer, write_count); if (i2c_set_dev(rcpod, idev) < 0) return 0; if (write_count <= 4) return i2c_write4(rcpod, write_buffer, write_count); return i2c_write_read(rcpod, write_buffer, write_count, NULL, 0); }
int rcpod_I2CWriteRead(rcpod_dev* rcpod, rcpod_i2c_dev* idev, const unsigned char* write_buffer, int write_count, unsigned char* read_buffer, int read_count) { if (!rcpod_HasAcceleratedI2C(rcpod)) return softi2c_write_read(rcpod, idev, write_buffer, write_count, read_buffer, read_count); if (i2c_set_dev(rcpod, idev) < 0) return 0; if (write_count == 1 && read_count <= 8 && read_count > 0) return i2c_write1_read8(rcpod, write_buffer[0], read_buffer, read_count); return i2c_write_read(rcpod, write_buffer, write_count, read_buffer, read_count); }
U32 usb_i2c_read8 (U8 addr, U8 *dataBuffer) { U32 ret_code = I2C_OK; U16 len; *dataBuffer = addr; usb_i2c.id = USB_I2C_ID; /* Since i2c will left shift 1 bit, we need to set USB I2C address to 0x60 (0xC0>>1) */ usb_i2c.addr = 0x60; usb_i2c.mode = ST_MODE; usb_i2c.speed = 100; len = 1; ret_code = i2c_write_read(&usb_i2c, dataBuffer, len, len); printf("%s: i2c_read: ret_code: %d\n", __func__, ret_code); return ret_code; }
EOWError ow_read_byte(uint8_t* read_byte) { uint8_t buffer[2], ret; buffer[0] = ds2482_read_pointer_cmd; buffer[1] = ds2482_status_register; i2c_write(ds2482_address, buffer, 2); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } ow_wait_on_busy(); buffer[0] = ds2482_read_byte_cmd; i2c_write(ds2482_address, buffer, 1); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } buffer[0] = ds2482_read_pointer_cmd; buffer[1] = ds2482_read_data_register; i2c_write(ds2482_address, buffer, 2); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } // TODO Prüfe, ob hier write und read in einem schnurz gemacht werden könnte! i2c_write_read(ds2482_address, NULL, 0, read_byte, 1); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } return eOWSuccess; }
kal_uint32 sn65dsi83_read_byte (kal_uint8 addr, kal_uint8 *dataBuffer) { kal_uint32 ret_code = I2C_OK; kal_uint16 len; *dataBuffer = addr; sn65dsi83_i2c.id = SN65DSI83_I2C_ID; /* Since i2c will left shift 1 bit, we need to set SN65DSI83 I2C address to >>1 */ sn65dsi83_i2c.addr = (sn65dsi83_SLAVE_ADDR_WRITE >> 1); sn65dsi83_i2c.mode = ST_MODE; sn65dsi83_i2c.speed = 100; len = 1; ret_code = i2c_write_read(&sn65dsi83_i2c, dataBuffer, len, len); //dprintf(INFO, "%s: i2c_read: ret_code: %d\n", __func__, ret_code); return ret_code; }
int8_t ow_wait_on_busy(void) { uint8_t busy, ret; for (;;) { busy = 1; i2c_write_read(ds2482_address, NULL, 0, &busy, 1); ret = i2c_wait(); if ( ret != TW_NO_INFO) { ERROR(ret); return eOWNoResponse; } busy |= ds2482_busy; if (busy == ds2482_busy) { break; } } return eOWSuccess; }
static kal_uint32 it6151_i2c_read_byte(kal_uint8 dev_addr,kal_uint8 addr, kal_uint8 *dataBuffer) { kal_uint32 ret_code = I2C_OK; kal_uint8 len; struct mt_i2c_t i2c; *dataBuffer = addr; i2c.id = IT6151_BUSNUM; i2c.addr = dev_addr; i2c.mode = ST_MODE; i2c.speed = 100; len = 1; ret_code = i2c_write_read(&i2c, dataBuffer, len, len); #ifdef IT6151_DEBUG /* dump write_data for check */ printf("[it6151_read_byte] i2c.id = 0x%x, dev_addr = 0x%x, read_data[0x%x] = 0x%x \n", i2c.id, dev_addr, addr, *dataBuffer); #endif return ret_code; }
static uint8_t inline read_reg(uint8_t addr) { uint8_t val; i2c_write_read(LIS_ADDR, addr, &val, 1); return val; }
cell i2c_wb(cell slave, cell reg, cell value) { uint8_t buf[2] = {reg, value}; return i2c_write_read(0, slave, 0, 0, 2, buf); }
int i2c_write_byte(unsigned int addr, unsigned char byte) { return i2c_write_read(addr,&byte,1,NULL,0); }
void display_draw() { // copies data to the gddram on the oled chip i2c_write_read(DISPLAY_ADDR, video_buffer, SIZE + 1, NULL, 0); }
void display_command(unsigned char cmd) { // write a command to the display unsigned char to_write[] = {0x00,cmd}; // first byte is 0 (CO = 0, DC = 0), second byte is the command i2c_write_read(DISPLAY_ADDR, to_write,2, NULL, 0); }
tmErrorCode_t UserWrittenI2CRead(tmUnitSelect_t tUnit, UInt32 AddrSize, UInt8* pAddr, UInt32 ReadLen, UInt8* pData) { /* Variable declarations */ tmErrorCode_t err = TM_OK; /* Customer code here */ /* ...*/ UINT8 data[BURST_SZ]; // every time, write 14 byte.. INT32 RemainLen, BurstNum; INT32 i,j; INT32 result = 0; UINT8 u8_add = (0xc0 & 0xff); if (AddrSize != 1) { NT220X_PRINTF("NT220X error 1 !\n"); } RemainLen = ReadLen % BURST_SZ; if (RemainLen) { BurstNum = ReadLen / BURST_SZ; } else { BurstNum = ReadLen / BURST_SZ - 1; RemainLen = BURST_SZ; } for ( i = 0 ; i < BurstNum; i ++ ) { data[0] = pAddr[0]+i*BURST_SZ; result |= i2c_write_read(I2C_TYPE_SCB, u8_add, data,1, BURST_SZ); for ( j = 0 ; j < BURST_SZ ; j++ ) { pData[i * BURST_SZ + j ] = data[j]; } } data[0] = pAddr[0]+BurstNum*BURST_SZ; result |= i2c_write_read(I2C_TYPE_SCB, u8_add, data, 1, RemainLen); for ( i = 0 ; i < RemainLen ; i++ ) { pData[BurstNum * BURST_SZ + i ] = data[i]; } if (result == SUCCESS) { err = TM_OK; } else { NT220X_PRINTF("NT220X error 2 !\n"); err = !TM_OK; } /* ...*/ /* End of Customer code here */ return err; }