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;
}
