/***********************************************************
* Function: // 函数名称
* Description: // 函数功能、性能等的描述
* Input: // 1.输入参数1，说明，包括每个参数的作用、取值说明及参数间关系
* Input: // 2.输入参数2，说明，包括每个参数的作用、取值说明及参数间关系
* Output: // 1.输出参数1，说明
* Return: // 函数返回值的说明
* Others: // 其它说明
***********************************************************/
static uint8_t IIC_RegWrite( uint8_t address, uint8_t reg, uint8_t val )
{
uint8_t err = ERR_NONE;
err = I2C_Start( );
if( err )
{
goto lbl_ERR_REG_WR;
}
I2C_SendByte( MMA845X_ADDR << 1 );
err = I2C_WaitAck( );
if( err )
{
goto lbl_ERR_REG_WR_STOP;
}
I2C_SendByte( reg );
err = I2C_WaitAck( );
if( err )
{
goto lbl_ERR_REG_WR_STOP;
}
I2C_SendByte( val );
err = I2C_WaitAck( );
if( err )
{
goto lbl_ERR_REG_WR_STOP;
}
I2C_Stop( );
//todo:这里需要延时5ms吗?
return ERR_NONE;
lbl_ERR_REG_WR_STOP:
I2C_Stop( );
lbl_ERR_REG_WR:
//rt_kprintf( "reg_wr error=%02x reg=%02x value=%02x\r\n", err, reg, val );
return err;
}
char DS1672_Zero(void)
{
char t;
char s;
I2C_Init(90,1000000);
I2C_Start();
t=I2C_TX(0xD0);
if(t!=0) {
if(t==1)
Log_Error((FARROM*)"DS1672: Zero Address NACK\r\n");
if(t==2)
Log_Error((FARROM*)"DS1672: Zero Address Timeout\r\n");
return t;
}
t=I2C_TX(1);
if(t!=0) {
if(t==1)
Log_Error((FARROM*)"DS1672: Zero Postion NACK\r\n");
if(t==2)
Log_Error((FARROM*)"DS1672: Zero Position Position Timeout\r\n");
}
for(s=0;s<6;s++)
{
t=I2C_TX(0);
if(t!=0) {
if(t==1)
Log_Error((FARROM*)"DS1672: TX NACK\r\n");
if(t==2)
Log_Error((FARROM*)"DS1672: TX Timeout\r\n");
}
}
I2C_Stop();
}
uint32_t I2C_RdBufEasy (uint8_t DevAddr, uint8_t *buf, uint32_t cnt) {
//The easy read.
//We assume that we will reset ACK and order a stop condition while the last byte is being received by the shift register.
//If this can't be done on time (during last byte reception), the slave will continue to send at least 1 more byte than cnt.
//In most cases, such a condition does not hurt at all. Therefore people uses this method exclusively.
//Note that it is impossible to guarantee the timig requirement only for single byte reception.
//For N>=2, the timing is almost always satisfied. (if there is no interrupt, it will definetely be satisfied)
//Generate Start
I2C_Start();
//Send I2C Device Address and clear ADDR
I2C_Addr(DevAddr, I2C_Direction_Receiver);
(void)I2Cx->SR2;
while ((cnt--)>1) {
I2C_Read(buf++);
}
//At this point we assume last byte is being received by the shift register. (reception has not been completed yet)
//Reset ack
I2Cx->CR1 &= (uint16_t)~((uint16_t)I2C_CR1_ACK);
//Order a stop condition
I2Cx->CR1 |= I2C_CR1_STOP;
//Now read the final byte
I2C_Read(buf);
//Make Sure Stop bit is cleared and Line is now Iddle
WaitLineIdle();
//Enable the Acknowledgement
I2Cx->CR1 |= ((uint16_t)I2C_CR1_ACK);
return 0;
}
int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
I2cHandle = (I2C_TypeDef *)(obj->i2c);
int count;
int value;
if(!obj->is_setAddress)
{
if( I2C_Start(I2cHandle, address, I2C_READ_SA7) == ERROR )
{
return -1;
}
obj->is_setAddress = 1;
obj->ADDRESS = address;
}
else
{
I2C_Restart_Structure(I2cHandle, address, I2C_READ_SA7);
obj->ADDRESS = address;
}
// Read all bytes
for (count = 0; count < (length-1); count++) {
if( (value = i2c_byte_read(obj, 0)) == -1) return value;
data[count] = (char)value;
}
if(stop){
if( (value = i2c_byte_read(obj, 1)) == -1) return value;
data[count] = (char)value;
}
else{
if( (value = i2c_byte_read(obj, 0)) == -1) return value;
data[count] = (char)value;
}
return count;
}
/*---------------------------------------------------------------------------*
* Routine: Accelerometer_Init
*---------------------------------------------------------------------------*
* Description:
* Initialize the Accelerometer driver.
* Inputs:
* void
* Outputs:
* void
*---------------------------------------------------------------------------*/
void Accelerometer_Init(void)
{
I2C_Request r;
uint32_t timeout; uint8_t acc_config_cnt;
for(acc_config_cnt=0; acc_config_cnt<3; acc_config_cnt++)
{
timeout = MSTimerGet();
pTxData = (uint8_t *)acc_config[acc_config_cnt];
r.iAddr = ACCEL_ADDR>>1;
r.iSpeed = 100; /* kHz */
r.iWriteData = pTxData;
r.iWriteLength = 2;
r.iReadData = 0;
r.iReadLength = 0;
I2C_Start();
I2C_Write(&r, 0);
while ((I2C_IsBusy()) && (MSTimerDelta(timeout) < 10))
{}
}
}
void WriteNbyte(u8 addr, u8 *p, u8 number) /* WordAddress,First Data Address,Byte lenth */
//F0=0,right, F0=1,error
{
I2C_Start();
I2C_WriteAbyte(SLAW);
I2C_Check_ACK(1);
if(!F0)
{
I2C_WriteAbyte(addr);
I2C_Check_ACK(1);
if(!F0)
{
do
{
I2C_WriteAbyte(*p); p++;
I2C_Check_ACK(1);
if(F0) break;
}
while(--number);
}
}
I2C_Stop();
}
void ADXL345_ReadXYZ(int16_t data[]){
/** Do a multi byte read. */
uint8_t buffer[6];
uint16_t bytes_read;
I2C_Start(ADXL345_I2C_7BIT_ADDRESS<<1, I2C_Direction_Transmitter);
I2C_Write(ADXL345_DATAX0_REG_ADDR); //X0 thru to Z1 are sequential.
I2C_RepeatedStart(ADXL345_I2C_7BIT_ADDRESS<<1, I2C_Direction_Receiver);
bytes_read = I2C_Read_Buf(buffer,6);
I2C_Stop();
while(bytes_read != 6){}
/** assemble data */
int16_t xdata = ( buffer[1] <<8 | buffer[0] );
int16_t ydata = ( buffer[3] <<8 | buffer[2] );
int16_t zdata = ( buffer[5] <<8 | buffer[4] );
data[0] = xdata;
data[1] = ydata;
data[2] = zdata;
}
/*******************************************************************************
* LCD_IconClear( ) *
* ??????????????(??????LCD??) *
*******************************************************************************/
void LCD_IconClear(void)
{
int x ;
// ???????????????
command(0x39) ;
x = I2C_Start(ST7032_ADRES,RW_0); // ????????????????
if (x == 0) {
// LCD??????????????
I2C_Send(0b10000000) ; // control byte ???(???????)
I2C_Send(0x40) ; // data byte ???
Wait27us() ;
// ????????????????
I2C_Send(0b01000000) ; // control byte ???(??????)
for (x=0x40 ; x<0x50 ; x++) {
I2C_Send(0x00) ;
Wait27us() ;
}
}
I2C_Stop() ; // ????????????????
// ???????????????
command(FuncSet_DT) ;
}
void I2C_ReadMultiRegisters(unsigned char u8SlaveAddress, unsigned char u8RegisterAddress, unsigned char n, unsigned char *r)
{
char i;
I2C_Start();
I2C0_D = u8SlaveAddress << 1; /* Send I2C device address with W/R bit = 0 */
I2C_Wait();
I2C0_D = u8RegisterAddress; /* Send register address */
I2C_Wait();
I2C_RepeatedStart();
I2C0_D = (u8SlaveAddress << 1) | 0x01; /* Send I2C device address this time with W/R bit = 1 */
I2C_Wait();
I2C_EnterRxMode();
I2C_EnableAck();
i = I2C0_D;
I2C_Wait();
for(i=0; i<n-2; i++)
{
*r = I2C0_D;
r++;
I2C_Wait();
}
I2C_DisableAck();
*r = I2C0_D;
r++;
I2C_Wait();
I2C_Stop();
*r = I2C0_D;
Pause(50);
}
/** Blocking sending data.
* @param obj The i2c object
* @param address 7-bit address (last bit is 0)
* @param data The buffer for sending
* @param length Number of bytes to wrte
* @param stop Stop to be generated after the transfer is done
* @return Number of written bytes
*/
int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
if (!obj->initied)
{
CyGlobalIntEnable;
I2C_Start();
obj->initied = 1;
}
int status = I2C_MasterWriteBuf(address, (uint8_t*)data, length, stop ? I2C_MODE_COMPLETE_XFER : I2C_MODE_NO_STOP);
if (status != I2C_MSTR_NO_ERROR)
{
debug("mbed I2C write failed with err: %i\r\n",status);
return 0;
}
int timeout = 100, to = 0;
while ((I2C_MasterStatus() & (I2C_MSTAT_WR_CMPLT | I2C_MSTAT_ERR_XFER)) == 0 && to++ < timeout)
{
CyDelayUs(10);
}
if (I2C_MasterStatus() & I2C_MSTAT_ERR_XFER)
{
debug("i2c write failed with status: 0x%X\r\n",I2C_MasterStatus());
return 0;
}
if (to == timeout)
{
debug("I2C write timeout!\r\n");
return 0;
}
return length;
}
/*-----------------------------------------------------------------------------
* I2C_WrData:
*
* Parameters: addr - 7-bit device address
* secByte - second byte to send
* buf - data buffer
* cnt - number of bytes to write
*
* Return: 0 on success, nonzero on error
*----------------------------------------------------------------------------*/
uint32_t I2C_WrData (uint8_t addr, uint8_t secByte, uint8_t *buf, uint32_t cnt) {
uint8_t *dp = buf;
uint32_t num = cnt;
uint32_t err = 0;
uint32_t st = 0;
uint32_t br = 0;
do {
switch (st++) {
case 0: err = I2C_Start (); break;
case 1: err |= I2C_Addr (addr, A_WR); break;
case 2: err |= I2C_Write (secByte); break;
case 3:
while (!err && num--) {
err |= I2C_Write (*dp++);
}
break;
case 4: err |= I2C_Stop (); break;
}
if (err) {
br++;
/* Attempt recovery for 10 times, break otherwise */
if (br < 10) {
if (I2C_Recovery (err) == 0) {
/* Recovery succedded, retry */
dp = buf;
num = cnt;
err = 0;
st = 0;
}
}
else break;
}
} while (err == 0 && st < 5);
return (err);
}
unsigned long DS1672_Value(void)
{
unsigned long value;
int t;
unsigned long v;
I2C_Init(100,1000000);
I2C_Start();
t=I2C_TX(0xD1);
if(t!=0) return 0xffffffff;
t=I2C_RX();
if(t==-1) return 0xffffffff;
value=t;
I2C_ACK();
t=I2C_RX();
if(t==-1) return 0xffffffff;
v = t;
value+=v<<8;
I2C_ACK();
t=I2C_RX();
if(t==-1) return 0xffffffff;
v = t;
value+=v<<16;
I2C_ACK();
t=I2C_RX();
if(t==-1) return 0xffffffff;
v = t;
value+=v<<24;
I2C_NACK();
I2C_Stop();
return value;
}
/* -------------------------------------------------------------------
Name: I2C_TxBurst -
Purpose: To transmit bulk data to I2C slave device.
Passed:
bCNT: 1..255. (Excludes slave address and sub-address)
Returns: None.
Notes:
The bSLA should be the slave device's 'WRITE' module addres,
not 'READ' one.
------------------------------------------------------------------- */
void I2C_TxBurst (
UB8 bSLA, /* I2C slave address */
UB8 bREG, /* I2C sub-address */
UB8 bCNT, /* The number of data which will be transmitted */
UB8 *pbDATA /* Point to the first DATA item */
)
{
UB8 bIdx;
// START
I2C_Start();
// MAD
I2C_TxData(bSLA);
// GetACK
I2C_GetACK();
// SAD (SAD[7:0])
I2C_TxData(bREG);
// GetACK
I2C_GetACK();
for (bIdx = 0; bIdx < bCNT; bIdx++)
{
I2C_TxData(*pbDATA++);
//TimerDelayUs(30);
// GetACK
I2C_GetACK();
} /* for */
// STOP
I2C_Stop();
} /* I2C_TxBurst */
void SucheGyroOffset(void)
{
unsigned char i, ready = 0;
int timeout;
timeout = SetDelay(2000);
for(i=140; i != 0; i--)
{
if(ready == 3 && i > 10) i = 9;
ready = 0;
if(AdWertNick < 1020) AnalogOffsetNick--; else if(AdWertNick > 1030) AnalogOffsetNick++; else ready++;
if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++;
if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++;
I2C_Start(TWI_STATE_GYRO_OFFSET_TX);
if(AnalogOffsetNick < 10) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_NICK; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_NICK; AnalogOffsetNick = 245;};
if(AnalogOffsetRoll < 10) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_ROLL; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_ROLL; AnalogOffsetRoll = 245;};
if(AnalogOffsetGier < 10) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_YAW; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_YAW; AnalogOffsetGier = 245;};
while(twi_state) if(CheckDelay(timeout)) {printf("\n\r DAC or I2C ERROR! Check I2C, 3Vref, DAC and BL-Ctrl"); break;}
AdReady = 0;
ANALOG_ON;
while(!AdReady);
if(i<10) Delay_ms_Mess(10);
}
Delay_ms_Mess(70);
}
int I2C_Write(I2C_ConfigStruct* conf, uint8_t addr, uint8_t* data, uint32_t len)
{
int i;
I2C_Start(conf);
//Write addr
if(I2C_WriteByte(conf, addr) != 0)
{
printf("Received NACK at address phase!!\r\n");
return -1;
}
//Write data
for(i=0; i<len; i++)
{
if(I2C_WriteByte(conf, data[i]))
return -1;
}
I2C_Stop(conf);
return 0;//success
}
/*******************************************************************************
* Function Name : I2C_WriteByte
* Description : 写一字节数据
* Input : - WriteAddress: 待写入地址
* - SendByte: 待写入数据
* - DeviceAddress: 器件类型
* Output : None
* Return : 返回为:=1成功写入,=0失败
* Attention : None
*******************************************************************************/
int I2C_WriteByte( uint16_t WriteAddress , uint8_t SendByte , uint8_t DeviceAddress)
{
if(!I2C_Start())
{
return DISABLE;
}
I2C_delay();
I2C_SendByte( DeviceAddress ); /* 器件地址 */
if( !I2C_WaitAck() )
{
I2C_Stop();
return DISABLE;
}
I2C_delay();
I2C_SendByte((uint8_t)(WriteAddress & 0x00FF)); /* 设置低起始地址 */
I2C_WaitAck();
I2C_delay();
I2C_SendByte(SendByte);
I2C_WaitAck();
I2C_delay();
I2C_Stop();
I2C_delay();
return ENABLE;
}
//! Handles an i2c command.
void i2c_handle_fn( uint8_t const app,
uint8_t const verb,
uint32_t const len)
{
unsigned char i;
unsigned long l;
switch(verb)
{
case READ:
l = len;
if(l > 0) //optional parameter of length
l=cmddata[0];
if(!l) //default value of 1
l=1;
I2C_Start();
for(i=0; i < l; i++)
cmddata[i]=I2C_Read(i<l?1:0);
I2C_Stop();
txdata(app,verb,l);
break;
case WRITE:
I2C_Start();
cmddata[0] = cmddata[0] << 1;
for(i=0; i<len; i++) {
if (!I2C_Write(cmddata[i])) //if NACK
break;
}
I2C_Stop();
cmddata[0] = i;
txdata(app,verb,1);
break;
case PEEK:
l = cmddata[0];
I2C_Start();
unsigned char address = cmddata[1] << 1;
I2C_Write(address);
for(i=2; i < len; i++){
I2C_Write(cmddata[i]);
}
I2C_Start();
I2C_Write(address|1); // spit out the target address again and flip the read bit
I2CDELAY(1); // XXX We should wait for clock to go high here XXX
for(i=0; i < l; i++)
cmddata[i]=I2C_Read(i+1<l?1:0); // If the next i is still less than l, then ACK
I2C_Stop();
txdata(app,verb,l);
break;
case POKE:
break;
case START:
I2C_Start();
txdata(app,verb,0);
break;
case STOP:
I2C_Stop();
txdata(app,verb,0);
break;
case SETUP:
I2C_Init();
txdata(app,verb,0);
break;
}
}
Status ReadTMP102(u16 *TO_EEPROM,u16 *Data_ptr)//读取tmp101的2个字节温度
{
u16 TMP102_Data=0x0000;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//send start------------------1
if(I2C_Start()!=BUS_READY){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_START);
return ERROR_FAILED;
}
//send SlaveADDR with write
I2C_SendByte(TMP102_WRITE_ADDR);//------------------2
if(I2C_WaitAck()!=BUS_ACK){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_DEVADDR);//------------------3
return ERROR_FAILED;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//send CONF_ADDR------------------4
I2C_SendByte(TMP102_TEMP_REG);
if(I2C_WaitAck()!=BUS_ACK){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_TEMPADDR);//------------------5
return ERROR_FAILED;
}
I2C_Stop();//------------------NiMa没看到!!!!!!!!!!!!!!
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//send start------------------6
if(I2C_Start()!=BUS_READY){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_RESTART);
return ERROR_FAILED;
}
//send SlaveADDR with write
I2C_SendByte(TMP102_READ_ADDR);//------------------7
if(I2C_WaitAck()!=BUS_ACK){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_RDEVADDR);//------------------8
return ERROR_FAILED;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//read TEMP
TMP102_Data=0x0000;
TMP102_Data = I2C_ReceiveByte();//--Byte1-------9
I2C_Ack();//------------------10
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
TMP102_Data<<=8;
TMP102_Data |= I2C_ReceiveByte();//---Byte2-----11
I2C_Ack();//------------------12
//send stop
I2C_Stop();//------------------13
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Done ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
TMP102_Data>>=4;
*Data_ptr = TMP102_Data;
//==============================================================
//-25~80
if(TMP102_Data&(0x800)){
//负数要转换
TMP102_Data-=(0x0E70-0x0500-1);
}
if(TMP102_Data<=0x690){
*TO_EEPROM = TMP102_Data*4;
}
else{
printf("Out of range from TMP102,TMP102=%X\t\r\n",*Data_ptr);
*TO_EEPROM = TO_EEPROM_ERROR;
}
//printf("TMP102=%X\tEEPROM=%X\r\n",*Data_ptr,*TO_EEPROM);
return OK_PASS;
}
u16 ReadTMP102_REG(unsigned char reg)
{
u16 TMP102_Data=0x0000;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//send start------------------1
if(I2C_Start()!=BUS_READY){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_START);
}
//send SlaveADDR with write
I2C_SendByte(TMP102_WRITE_ADDR);//------------------2
if(I2C_WaitAck()!=BUS_ACK){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_DEVADDR);//------------------3
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//send CONF_ADDR------------------4
I2C_SendByte(reg);
if(I2C_WaitAck()!=BUS_ACK){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_TEMPADDR);//------------------5
}
I2C_Stop();//------------------NiMa没看到!!!!!!!!!!!!!!
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//send start------------------6
if(I2C_Start()!=BUS_READY){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_RESTART);
return ERROR_FAILED;
}
//send SlaveADDR with write
I2C_SendByte(TMP102_READ_ADDR);//------------------7
if(I2C_WaitAck()!=BUS_ACK){
ERROR_MACRO(TMP102_DEV,RTMP_ERROR_SEND_RDEVADDR);//------------------8
return ERROR_FAILED;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//read TEMP
TMP102_Data=0x0000;
TMP102_Data = I2C_ReceiveByte();//--Byte1-------9
I2C_Ack();//------------------10
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Frame 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
TMP102_Data=(TMP102_Data<<8);
TMP102_Data |=(u8)I2C_ReceiveByte();//---Byte2-----11
I2C_Ack();//------------------12
//send stop
I2C_Stop();//------------------13
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~ Done ~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
return TMP102_Data;
}
/*----------------------------------------------------------------------------*/
TI2C_Result I2C_ReadData(uint8 DevAddr, uint8 AddrSize, uint16 StartAddr, uint16 Size, uint8* pData)
{
int i;
TI2C_States st;
/*
I2C_Start();
I2C_Write(DevAddr|I2C_WRITE_CMD);
if (AddrSize==2)
I2C_Write(StartAddr>>8);
I2C_Write(StartAddr&0xFF);
I2C_Start();
I2C_Write(DevAddr|I2C_READ_CMD);
for (i=0; i<Size-1; i++)
{
I2C_Read(pData+i, 1);
}
I2C_Read(pData+i, 0);
I2C_Stop();
return I2C_RES_OK;
*/
/**/
//I2C_Stop();
st = (TI2C_States)I2C_Start();
if (st != I2C_START)
{
I2C_Stop();
return I2C_RES_BUS_ERROR;
}
st = (TI2C_States)I2C_Write(DevAddr|I2C_WRITE_CMD);
switch (st)
{
case I2C_MT_SLA_ACK:
break;
case I2C_MT_SLA_NACK:
I2C_Stop();
return I2C_RES_NO_DEVICE;
default:
I2C_Stop();
return I2C_RES_BUS_ERROR;
}
if (AddrSize == 2)
{
st = (TI2C_States)I2C_Write(StartAddr>>8);
switch (st)
{
case I2C_MT_DATA_ACK:
break;
case I2C_MT_DATA_NACK:
I2C_Stop();
return I2C_RES_DEVICE_BUSY;
default:
I2C_Stop();
return I2C_RES_BUS_ERROR;
}
}
uint8_t temperature_InitOneShotReading (void) {
// put the device in SHUTDOWN mode to save power
r = temperature_DeviceShutdown();
if (r) return r;
//r = I2C_Start();
//// len = sprintf(str, "\n\r I2C_Start: 0x%x\n\r", r);
//// outputStringToUART0(str);
//if (r == TW_START) {
//r = I2C_Write(TCN75A_ADDR_WRITE); // address the device, say we are going to write
//// len = sprintf(str, "\n\r I2C_Write(TCN75A_ADDR_WRITE): 0x%x\n\r", r);
//// outputStringToUART0(str);
//if (r == TW_MT_SLA_ACK) {
//r = I2C_Write(TCN75A_CONFIG);
//// len = sprintf(str, "\n\r I2C_Write(TCN75A_CONFIG): 0x%x\n\r", r);
//// outputStringToUART0(str);
//if (r == TW_MT_DATA_ACK) {
//r = I2C_Write(TCN75A_SHUTDOWN_BIT);
//// len = sprintf(str, "\n\r I2C_Write(TCN75A_SHUTDOWN_BIT): 0x%x\n\r", r);
//// outputStringToUART0(str);
//} else { // could not write data to device
//I2C_Stop();
//return errNoI2CDataAck;
//}
//} else { // could not address device
//I2C_Stop();
//return errNoI2CAddressAck;
//}
//I2C_Stop();
//// outputStringToUART0("\n\r STOP completed \n\r");
//} else { // could not START
//return errNoI2CStart;
//}
//
// write ONE-SHOT to device, for a single temperature conversion
r = I2C_Start();
// len = sprintf(str, "\n\r I2C_Start: 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_START) {
r = I2C_Write(TCN75A_ADDR_WRITE); // address the device, say we are going to write
// len = sprintf(str, "\n\r I2C_Write(TCN75A_ADDR_WRITE): 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_MT_SLA_ACK) {
r = I2C_Write(TCN75A_CONFIG);
// len = sprintf(str, "\n\r I2C_Write(TCN75A_CONFIG): 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_MT_DATA_ACK) {
r = I2C_Write(TCN75A_SHUTDOWN_BIT | TCN75A_ONE_SHOT_BIT);
// len = sprintf(str, "\n\r I2C_Write(TCN75A_SHUTDOWN_BIT | TCN75A_ONE_SHOT_BIT): 0x%x\n\r", r);
// outputStringToUART0(str);
I2C_Stop();
return I2C_OK;
} else { // could not write data to device
I2C_Stop();
return errNoI2CDataAck;
}
} else { // could not address device
I2C_Stop();
return errNoI2CAddressAck;
}
// outputStringToUART0("\n\r STOP completed \n\r");
} else { // could not START
return errNoI2CStart;
}
}
uint8_t temperature_GetReading (tmprData *tr) {
r = temperature_InitOneShotReading();
if (r) {
tr->verification = r;
return r;
}
// temperature conversion time, typically 30ms
for (Timer2 = 4; Timer2; ); // Wait for 40ms to be sure
// read ambient temperature from the device
r = I2C_Start();
// len = sprintf(str, "\n\r I2C_Start: 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_START) {
r = I2C_Write(TCN75A_ADDR_WRITE); // address the device, say we are going to write
// len = sprintf(str, "\n\r I2C_Write(TCN75A_ADDR_WRITE): 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_MT_SLA_ACK) {
r = I2C_Write(TCN75A_TA);
// len = sprintf(str, "\n\r I2C_Write(TCN75A_CONFIG): 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_MT_DATA_ACK) {
r = I2C_Start(); // restart, prep to read
// len = sprintf(str, "\n\r I2C_Start: 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_REP_START) {
r = I2C_Write(TCN75A_ADDR_READ); // address the device, say we are going to read
// len = sprintf(str, "\n\r I2C_Write(TCN75A_ADDR_READ): 0x%x\n\r", r);
// outputStringToUART0(str);
if (r == TW_MR_SLA_ACK) {
tr->tmprHiByte = I2C_Read(1); // do ACK, because not last byte
tr->tmprLoByte = I2C_Read(0); // do NACK, since this is the last byte
// len = sprintf(str, "\n\r I2C_READ(tr->tmprHiByte): 0x%x\n\r", (tr->tmprHiByte));
// len = sprintf(str, "\n\r I2C_READ(tr->tmprHiByte): %d\n\r", (tr->tmprHiByte));
// outputStringToUART0(str);
I2C_Stop();
tr->verification = I2C_OK;
return I2C_OK;
} else { // could not address device to READ
I2C_Stop();
tr->verification = errNoI2CAddrAckRead;
return errNoI2CAddrAckRead;
}
} else { // could not reSTART
I2C_Stop();
tr->verification = errNoI2CRepStart;
return errNoI2CRepStart;
}
} else { // could not write to device
I2C_Stop();
tr->verification = errNoI2CDataAck;
return errNoI2CDataAck;
}
} else { // could not address device
I2C_Stop();
tr->verification = errNoI2CAddressAck;
return errNoI2CAddressAck;
}
// outputStringToUART0("\n\r STOP completed \n\r");
} else { // could not START
tr->verification = errNoI2CStart;
return errNoI2CStart;
}
}
int main()
{
CyGlobalIntEnable;
UART_Start();
printf("Start\r\n");
/* //IR receiver//
----------------------------------------------------
unsigned int IR_val;
for(;;)
{
IR_val = get_IR();
printf("%x\r\n\n",IR_val);
}
///---------------------------------------------------------- */
/*
//Ambient//
----------------------------------------------------
I2C_Start();
uint16 value =0;
I2C_write(0x29,0x80,0x00);
value = I2C_read(0x29,0x80);
printf("%x ",value);
I2C_write(0x29,0x80,0x03);
value = I2C_read(0x29,0x80);
printf("%x\r\n",value);
value = I2C_read(0x29,0x81);
printf("%x\r\n",value);
for(;;)
{
uint8 Data0Low,Data0High,Data1Low,Data1High;
Data0Low = I2C_read(0x29,CH0_L);
Data0High = I2C_read(0x29,CH0_H);
Data1Low = I2C_read(0x29,CH1_L);
Data1High = I2C_read(0x29,CH1_H);
uint8 CH0, CH1;
CH0 = convert_raw(Data0Low,Data0High);
CH1 = convert_raw(Data1Low,Data1High);
// printf("%d %d %d %d\r\n",Data0Low,Data0High, Data1Low,Data1High);
// printf("%d %d\r\n",CH0,CH1);
// printf("%f\r\n",(float)CH1/CH0);
double Ch0 = CH0;
double Ch1 = CH1;
double data = 0;
data = getLux(Ch0,Ch1);
printf("%lf\r\n",data);
}
///---------------------------------------------------------- */
/* //nunchuk//
----------------------------------------------------
nunchuk_start();
nunchuk_init();
for(;;)
{
nunchuk_read();
}
//----------------------------------------------------*/
//accelerometer//
//--------------------------------------------------------------
I2C_Start();
uint8 X_L_A, X_H_A, Y_L_A, Y_H_A, Z_L_A, Z_H_A;
int16 X_AXIS, Y_AXIS, Z_AXIS;
I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL1_REG, 0x37); // set accelerometer & magnetometer into active mode
I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL7_REG, 0x22);
for(;;)
{
//print out accelerometer output
X_L_A = I2C_read(ACCEL_MAG_ADDR, OUT_X_L_A);
X_H_A = I2C_read(ACCEL_MAG_ADDR, OUT_X_H_A);
X_AXIS = convert_raw(X_L_A, X_H_A);
Y_L_A = I2C_read(ACCEL_MAG_ADDR, OUT_Y_L_A);
Y_H_A = I2C_read(ACCEL_MAG_ADDR, OUT_Y_H_A);
Y_AXIS = convert_raw(Y_L_A, Y_H_A);
Z_L_A = I2C_read(ACCEL_MAG_ADDR, OUT_Z_L_A);
Z_H_A = I2C_read(ACCEL_MAG_ADDR, OUT_Z_H_A);
Z_AXIS = convert_raw(Z_L_A, Z_H_A);
//printf("ACCEL: %d %d %d %d %d %d \r\n", X_L_A, X_H_A, Y_L_A, Y_H_A, Z_L_A, Z_H_A);
value_convert_accel(X_AXIS, Y_AXIS, Z_AXIS);
printf("\n");
CyDelay(50);
}
///----------------------------------------------------------
/* //ultra//
----------------------------------------------------
ultra_isr_StartEx(ultra_isr_handler); // Ultra Sonic Interrupt
Ultra_Start(); // Ultra Sonic Start function
for(;;)
{
CyDelay(100);
Trig_Write(1); // Trigger High
CyDelayUs(10); // 10 micro seconds for trigger input signals
Trig_Write(0); // Trigger Low
}
//----------------------------------------------------*/
/* //reflectance//
----------------------------------------------------
sensor_isr_StartEx(sensor_isr_handler);
Refelctance_Start();
IR_led_Write(1);
for(;;)
{
reflectance_period(); //print out each period of reflectance sensors
reflectance_digital(); //print out 0 or 1 according to results of reflectance period
CyDelay(500);
}
///----------------------------------------------------*/
/* //motor//
----------------------------------------------------
motor_Start(); // motor start
motor_forward(50,2000); // moving forward
motor_turn(10,50,2000); // turn
motor_turn(50,10,2000); // turn
motor_backward(50,2000); // movinb backward
motor_Stop(); // motor stop
for(;;)
{
}
///----------------------------------------------------*/
/*
//gyroscope//
//-----------------------------------------------------
I2C_Start();
uint8 X_AXIS_L, X_AXIS_H, Y_AXIS_L, Y_AXIS_H, Z_AXIS_L, Z_AXIS_H;
int16 X_AXIS, Y_AXIS, Z_AXIS;
I2C_write(GYRO_ADDR, GYRO_CTRL1_REG, 0x0F); // set gyroscope into active mode
I2C_write(GYRO_ADDR, GYRO_CTRL4_REG, 0x30); // set full scale selection to 2000dps
for(;;)
{
//print out gyroscope output
X_AXIS_L = I2C_read(GYRO_ADDR, OUT_X_AXIS_L);
X_AXIS_H = I2C_read(GYRO_ADDR, OUT_X_AXIS_H);
X_AXIS = convert_raw(X_AXIS_H, X_AXIS_L);
Y_AXIS_L = I2C_read(GYRO_ADDR, OUT_Y_AXIS_L);
Y_AXIS_H = I2C_read(GYRO_ADDR, OUT_Y_AXIS_H);
Y_AXIS = convert_raw(Y_AXIS_H, Y_AXIS_L);
Z_AXIS_L = I2C_read(GYRO_ADDR, OUT_Z_AXIS_L);
Z_AXIS_H = I2C_read(GYRO_ADDR, OUT_Z_AXIS_H);
Z_AXIS = convert_raw(Z_AXIS_H, Z_AXIS_L);
//printf("X_AXIS_L: %d, X_AXIS_H: %d, average: %d \r\n", X_AXIS_L, X_AXIS_H, (X_AXIS_H+X_AXIS_L)/2);
//printf("Y_AXIS_L: %d, Y_AXIS_H: %d, average: %d \r\n", Y_AXIS_L, Y_AXIS_H, (Y_AXIS_H+Y_AXIS_L)/2);
//printf("Z_AXIS_L: %d, Z_AXIS_H: %d, average: %d \r\n", Z_AXIS_L, Z_AXIS_H, (Z_AXIS_H+Z_AXIS_L)/2);
//printf("H L : %d %d %d %d %d %d \r\n", X_AXIS_L, X_AXIS_H, Y_AXIS_L, Y_AXIS_H, Z_AXIS_L, Z_AXIS_H);
//printf("%d %d %d \r\n", X_AXIS, Y_AXIS, Z_AXIS);
printf("%d %d %d \r\n", value_convert_gyro(X_AXIS), value_convert_gyro(Y_AXIS), value_convert_gyro(Z_AXIS));
CyDelay(50);
}
///-----------------------------------------------------------------*/
/*
//magnetometer//
//--------------------------------------------------------------
I2C_Start();
uint8 X_L_M, X_H_M, Y_L_M, Y_H_M, Z_L_M, Z_H_M;
int16 X_AXIS, Y_AXIS, Z_AXIS;
I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL1_REG, 0x37); // set accelerometer & magnetometer into active mode
I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL5_REG, 0x10); // set a data rate of 50Hz
I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL6_REG, 0x60); // set the full scale selection to +/- 12 Gauss
I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL7_REG, 0x80); // set to continuous-conversion mode
for(;;)
{
X_L_M = I2C_read(ACCEL_MAG_ADDR, OUT_X_L_M);
X_H_M = I2C_read(ACCEL_MAG_ADDR, OUT_X_H_M);
X_AXIS = convert_raw(X_L_M, X_H_M);
Y_L_M = I2C_read(ACCEL_MAG_ADDR, OUT_Y_L_M);
Y_H_M = I2C_read(ACCEL_MAG_ADDR, OUT_Y_H_M);
Y_AXIS = convert_raw(Y_L_M, Y_H_M);
Z_L_M = I2C_read(ACCEL_MAG_ADDR, OUT_Z_L_M);
Z_H_M = I2C_read(ACCEL_MAG_ADDR, OUT_Z_H_M);
Z_AXIS = convert_raw(Z_L_M, Z_H_M);
heading(X_AXIS, Y_AXIS);
// printf("MAGNET: %d %d %d %d %d %d \r\n", X_L_M, X_H_M, Y_L_M, Y_H_M, Z_L_M, Z_H_M);
//printf("%d %d %d \r\n", X_AXIS,Y_AXIS, Z_AXIS);
CyDelay(50);
}
///----------------------------------------------------------*/
}
/*********************************************************************//**
* @brief Transmit and Receive data in master mode
* @param[in] I2Cx I2C peripheral selected, should be:
* - LPC_I2C0
* - LPC_I2C1
* - LPC_I2C2
* @param[in] TransferCfg Pointer to a I2C_M_SETUP_Type structure that
* contains specified information about the
* configuration for master transfer.
* @param[in] Opt a I2C_TRANSFER_OPT_Type type that selected for
* interrupt or polling mode.
* @return SUCCESS or ERROR
*
* Note:
* - In case of using I2C to transmit data only, either transmit length set to 0
* or transmit data pointer set to NULL.
* - In case of using I2C to receive data only, either receive length set to 0
* or receive data pointer set to NULL.
* - In case of using I2C to transmit followed by receive data, transmit length,
* transmit data pointer, receive length and receive data pointer should be set
* corresponding.
**********************************************************************/
Status I2C_MasterTransferData(LPC_I2C_TypeDef *I2Cx, I2C_M_SETUP_Type *TransferCfg, \
I2C_TRANSFER_OPT_Type Opt)
{
uint8_t *txdat;
uint8_t *rxdat;
uint32_t CodeStatus;
uint8_t tmp;
// reset all default state
txdat = (uint8_t *) TransferCfg->tx_data;
rxdat = (uint8_t *) TransferCfg->rx_data;
// Reset I2C setup value to default state
TransferCfg->tx_count = 0;
TransferCfg->rx_count = 0;
TransferCfg->status = 0;
if (Opt == I2C_TRANSFER_POLLING){
/* First Start condition -------------------------------------------------------------- */
TransferCfg->retransmissions_count = 0;
retry:
// reset all default state
txdat = (uint8_t *) TransferCfg->tx_data;
rxdat = (uint8_t *) TransferCfg->rx_data;
// Reset I2C setup value to default state
TransferCfg->tx_count = 0;
TransferCfg->rx_count = 0;
CodeStatus = 0;
// Start command
CodeStatus = I2C_Start(I2Cx);
if ((CodeStatus != I2C_I2STAT_M_TX_START) \
&& (CodeStatus != I2C_I2STAT_M_TX_RESTART)){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// save status
TransferCfg->status = CodeStatus;
goto error;
} else {
goto retry;
}
}
/* In case of sending data first --------------------------------------------------- */
if ((TransferCfg->tx_length != 0) && (TransferCfg->tx_data != NULL)){
/* Send slave address + WR direction bit = 0 ----------------------------------- */
CodeStatus = I2C_SendByte(I2Cx, (TransferCfg->sl_addr7bit << 1));
if (CodeStatus != I2C_I2STAT_M_TX_SLAW_ACK){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// save status
TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;
goto error;
} else {
goto retry;
}
}
/* Send a number of data bytes ---------------------------------------- */
while (TransferCfg->tx_count < TransferCfg->tx_length)
{
CodeStatus = I2C_SendByte(I2Cx, *txdat);
if (CodeStatus != I2C_I2STAT_M_TX_DAT_ACK){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// save status
TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;
goto error;
} else {
goto retry;
}
}
txdat++;
TransferCfg->tx_count++;
}
}
/* Second Start condition (Repeat Start) ------------------------------------------- */
if ((TransferCfg->tx_length != 0) && (TransferCfg->tx_data != NULL) \
&& (TransferCfg->rx_length != 0) && (TransferCfg->rx_data != NULL)){
CodeStatus = I2C_Start(I2Cx);
if ((CodeStatus != I2C_I2STAT_M_RX_START) \
&& (CodeStatus != I2C_I2STAT_M_RX_RESTART)){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// Update status
TransferCfg->status = CodeStatus;
goto error;
} else {
goto retry;
}
}
}
/* Then, start reading after sending data -------------------------------------- */
if ((TransferCfg->rx_length != 0) && (TransferCfg->rx_data != NULL)){
/* Send slave address + RD direction bit = 1 ----------------------------------- */
CodeStatus = I2C_SendByte(I2Cx, ((TransferCfg->sl_addr7bit << 1) | 0x01));
if (CodeStatus != I2C_I2STAT_M_RX_SLAR_ACK){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// update status
TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;
goto error;
} else {
goto retry;
}
}
/* Receive a number of data bytes ------------------------------------------------- */
while (TransferCfg->rx_count < TransferCfg->rx_length){
/*
* Note that: if data length is only one, the master should not
* issue an ACK signal on bus after reading to avoid of next data frame
* on slave side
*/
if (TransferCfg->rx_count < (TransferCfg->rx_length - 1)){
// Issue an ACK signal for next data frame
CodeStatus = I2C_GetByte(I2Cx, &tmp, TRUE);
if (CodeStatus != I2C_I2STAT_M_RX_DAT_ACK){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// update status
TransferCfg->status = CodeStatus;
goto error;
} else {
goto retry;
}
}
} else {
// Do not issue an ACK signal
CodeStatus = I2C_GetByte(I2Cx, &tmp, FALSE);
if (CodeStatus != I2C_I2STAT_M_RX_DAT_NACK){
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// update status
TransferCfg->status = CodeStatus;
goto error;
} else {
goto retry;
}
}
}
*rxdat++ = tmp;
TransferCfg->rx_count++;
}
}
/* Send STOP condition ------------------------------------------------- */
I2C_Stop(I2Cx);
return SUCCESS;
error:
// Send stop condition
I2C_Stop(I2Cx);
return ERROR;
}
else if (Opt == I2C_TRANSFER_INTERRUPT){
// Setup tx_rx data, callback and interrupt handler
tmp = I2C_getNum(I2Cx);
i2cdat[tmp].txrx_setup = (uint32_t) TransferCfg;
// Set direction phase, write first
i2cdat[tmp].dir = 0;
/* First Start condition -------------------------------------------------------------- */
I2Cx->I2CONCLR = I2C_I2CONCLR_SIC;
I2Cx->I2CONSET = I2C_I2CONSET_STA;
I2C_IntCmd(I2Cx, TRUE);
return (SUCCESS);
}
return ERROR;
}
int main()
{
CyGlobalIntEnable; /* Uncomment this line to enable global interrupts. */
XBee_UART_Start();
I2C_Start();
LCD_Start();
// INITIALIZE VALUES
Command_Received = 0;
MAG_DataRdy_Flag = 0;
ReadyForCommand_Flag = 1;
IncomingData_Flag = 0;
StatusError_Flag = 0;
//WaitForDataRead_Flag = 0;
Command_Buffer = 0;
// INITIALIZE ISRs
InitXBee_Isr();
//InitINT1_Isr(); // IF INT1 TRIGGERS WHEN NOT IN ACTIVE MODE, MOVE INITIATION CODE FOR SETTING ACTIVE.
//INT1_isr_Start();
XBee_UART_ClearRxBuffer();
XBee_UART_ClearTxBuffer();
CyDelay(2000);
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString("MAG DRIVER:");
LCD_Position(1,0);
LCD_PrintString("[ERR]");
LCD_Position(1,7);
LCD_PrintString("[I2C]");
uint8 status = 0;
status = SetCtrlReg1Default();
status |= SetCtrlReg2Default();
if(status !=0)
{
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintInt8(status);
status = 0;
}
uint8 pin_status = 0;
for(;;)
{
pin_status = INT1_Pin_Read();
pin_status |= MAG_DataRdy_Flag;
if(pin_status)
{
MAG_DataRdy_Flag = pin_status;
if(ReadyForCommand_Flag!=0)
{
Command_Received = CMD_I_RM_MAGDATA;
ReadyForCommand_Flag = 0;
}
}
if(Command_Received != 0)
{
LCD_ClearDisplay();
//XBee_UART_ClearTxBuffer();
//XBee_UART_ClearRxBuffer();
switch (Command_Received){
case CMD_I_RM_MAGDATA: // CMD_I_RM_MAGDATA = 34
{
status = ReadMagData(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
//LED_out_Write(0);
CyDelay(500);
XBee_UART_PutArray(Global_ReadPtr,ARRAY_SIZE_MAG_DATA);
CyDelay(1000);
//WaitForDataRead_Flag = 0;
MAG_DataRdy_Flag = 0;
if(Command_Buffer!=0)
{
Command_Received = Command_Buffer;
Command_Buffer = 0;
//ReadyForCommand_Flag = 0; //Dont toggle flag
}
else
{
Command_Received = 0;
ReadyForCommand_Flag = 1;
LED_out_Write(0);
}
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WM_OFFSET_ALL:// CMD_I_WM_OFFSET_ALL = 1
{
if(IncomingData_Flag == 0) // IF THE OFFSET DATA TO WRITE HAS BEEN RECEIVED...
{
status = WriteOffsetCorrection(DataInPtr_Global);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received); //Sends confirmation TWICE. Once after receiving CMD, and again after finishing WRITE
LED_out_Write(0);
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
}
break;
case CMD_I_RS_CTRL1://CMD_I_RS_CTRL1=35
{
status = ReadCtrlReg1(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
LED_out_Write(0);
CyDelay(500);
XBee_UART_PutChar(Global_ReadBuffer[0]); // Send Read Value
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_RS_CTRL2://CMD_I_RS_CTRL2 = 36
{
status = ReadCtrlReg2(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
LED_out_Write(0);
CyDelay(500);
XBee_UART_PutChar(Global_ReadBuffer[0]); // Send Read Value
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_RS_DRSTATUS://CMD_I_RS_DRSTATUS = 37
{
status = ReadDrStatus(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
LED_out_Write(0);
CyDelay(500);
XBee_UART_PutChar(Global_ReadBuffer[0]); // Send Read Value
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_RS_SYSMOD:// CMD_I_RS_SYSMOD = 38
{
status = ReadSysMod(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
LED_out_Write(0);
CyDelay(500);
XBee_UART_PutChar(Global_ReadBuffer[0]);
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_RS_DIETEMP: // CMD_I_RS_DIETEMP = 39
{
status = ReadDieTemp(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
LED_out_Write(0);
CyDelay(500);
XBee_UART_PutChar(Global_ReadBuffer[0]);
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_RS_WHOAMI: // CMD_I_RS_WHOAMI = 40
{
status = ReadWhoAmI(Global_ReadPtr);
if(status == 0)
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);
LED_out_Write(0);
CyDelay(500);
XBee_UART_PutChar(Global_ReadBuffer[0]);
Command_Received = 0;
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1;
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL1_DEFAULT: // CMD_I_WS_CTRL1_DEFAULT = 41
{
status = SetCtrlReg1Default();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL1_MODSTANDBY: // CMD_I_WS_CTRL1_MODSTANDBY = 42
{
status = SetStandbyMode();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL1_MODSINGLE: // CMD_I_WS_CTRL1_MODSINGLE = 43
{
status = SetSingleMeasurmentMode();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
//IF INT1 CONTINUES TO TRIGGER WHEN NOT IT ACTIVE MODE, DEACTIVATE/ACTIVATE ISR WHEN CHANGING MODES
case CMD_I_WS_CTRL1_MODACTIVE: // CMD_I_WS_CTRL1_MODACTIVE = 44
{
status = SetContinuousMode();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL1_MODTRIGGER: // CMD_I_WS_CTRL1_MODTRIGGER = 45
{
status = SetTriggerMeasurmentMode();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL1_ENFAST: // CMD_I_WS_CTRL1_ENFAST = 46
{
status = SetFastReadOn();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL1_NENFAST: //CMD_I_WS_CTRL1_NENFAST = 47
{
status = SetFastReadOff();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL2_DEFAULT: //CMD_I_WS_CTRL2_DEFAULT = 48
{
status = SetCtrlReg2Default();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL2_ENAUTORESET: // CMD_I_WS_CTRL2_ENAUTORESET = 49
{
status = SetAutoResetOn();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL2_NENAUTORESET: // CMD_I_WS_CTRL2_NENAUTORESET = 50
{
status = SetAutoResetOff();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL2_ENUSEROFFSET: // CMD_I_WS_CTRL2_ENUSEROFFSET = 51
{
status = SetUserCorrectedData();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL2_NENUSEROFFSET: // CMD_I_WS_CTRL2_NENUSEROFFSET = 52
{
status = SetRawData();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
StatusError_Flag = 1;
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_WS_CTRL2_RESETMAG: // CMD_I_WS_CTRL2_RESETMAG = 53
{
status = ResetMag();
if(status == 0) //if the write was a success
{
CyDelay(1000); //LET MAGNETOMETER RESET PROCEDURE FINISH
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
//LCD_ClearDisplay();
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
case CMD_I_RESET_ALL://54
{
// RESET I2C
uint8 i2c_status = I2C_MasterClearStatus();
//LCD_ClearDisplay();
LCD_Position(1,7);
LCD_PrintInt8(i2c_status);
I2C_MasterClearReadBuf();
I2C_MasterClearWriteBuf();
// Reset MAG CTRL REGISTERS
status = SetCtrlReg1Default();
status |= SetCtrlReg2Default();
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
//LCD_ClearDisplay();
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
StatusError_Flag = 1;
}
}
break;
default: //handles Set Sampling/Data rate CMDs, and Out of range errors
{
if((Command_Received >= (STARTOFRANGE_SET_SAMPLING_AND_RATE))&&(Command_Received < (STARTOFRANGE_SET_SAMPLING_AND_RATE + RANGESIZE_SET_SAMPLING_AND_RATE)))
{
uint8 offset = Command_Received-STARTOFRANGE_SET_SAMPLING_AND_RATE;
offset *=DELTAVALS_SET_SAMP_AND_RATE;
status = SetOverSampleAndDataRate(offset);
if(status == 0) //if the write was a success
{
CyDelay(500);
XBee_UART_PutChar(Command_Received);//Returns command received from MATLAB as confirmation
LED_out_Write(0); //Turns off LED
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
}
else
{
// will result is a halt of CMD processing and leaves LED lit (visual error signal)
StatusError_Flag = 1;
//LCD_ClearDisplay();
LCD_Position(1,0);
LCD_PrintString("E:STA");
CyDelay(1000);
}
}
else // ERROR: CMD VALUE OUT OF RANGE (executed if not a CMD to set sampling/data rate)
{
//CLEAR EVERYTHING
XBee_UART_ClearTxBuffer();
XBee_UART_ClearRxBuffer();
I2C_MasterClearReadBuf();
I2C_MasterClearWriteBuf();
Command_Received = 0; //Clears the Command
IncomingData_Flag = 0;
ReadyForCommand_Flag = 1; // Sets state as READY for next command
XBee_UART_PutChar(CMD_O_CMDVALUEOUTOFRANGE); //Send error msg
//LCD_ClearDisplay();
LCD_Position(1,0);
LCD_PrintString("E:RAN");
CyDelay(1000);
LED_out_Write(0); //Turns off LED
}
}
} //END OF SWITCH-CASE
}//end of IF statement encasing switch-case
/*else // if(Command_Received == 0)
{
if((MAG_DataRdy_Flag==1) && (WaitForDataRead_Flag==0))
{
//May change CMD_O_MAGDATARDY to simply be the same as CMD_I_RM_MAGDATA.
//XBee_UART_ClearTxBuffer();
//LCD_ClearDisplay();
LCD_Position(1,0);
LCD_PrintString("DRDY2");
XBee_UART_PutChar(CMD_O_MAGDATARDY);// CMD_O_MAGDATARDY = 55
WaitForDataRead_Flag = 1; //Prevents constant resending of notification to MATLAB
INT1_isr_Disable();
}
}*/
}//END OF FOR LOOP
}//END OF MAIN
/*********************************************************************//**
* @brief Transmit and Receive data in master mode
* @param[in] I2Cx I2C peripheral selected, should be:
* - LPC_I2C0
* - LPC_I2C1
* - LPC_I2C2
* @param[in] TransferCfg Pointer to a I2C_M_SETUP_Type structure that
* contains specified information about the
* configuration for master transfer.
* @param[in] Opt a I2C_TRANSFER_OPT_Type type that selected for
* interrupt or polling mode.
* @return SUCCESS or ERROR
*
* Note:
* - In case of using I2C to transmit data only, either transmit length set to 0
* or transmit data pointer set to NULL.
* - In case of using I2C to receive data only, either receive length set to 0
* or receive data pointer set to NULL.
* - In case of using I2C to transmit followed by receive data, transmit length,
* transmit data pointer, receive length and receive data pointer should be set
* corresponding.
**********************************************************************/
Status I2C_MasterTransferData(en_I2C_unitId i2cId, I2C_M_SETUP_Type *TransferCfg,
I2C_TRANSFER_OPT_Type Opt)
{
LPC_I2C_TypeDef* I2Cx = I2C_GetPointer(i2cId);
uint32_t CodeStatus;
int32_t Ret = I2C_OK;
// Reset I2C setup value to default state
TransferCfg->tx_count = 0;
TransferCfg->rx_count = 0;
TransferCfg->status = 0;
if (Opt == I2C_TRANSFER_POLLING)
{
/* First Start condition -------------------------------------------------------------- */
TransferCfg->retransmissions_count = 0;
retry:
// Reset I2C setup value to default state
TransferCfg->tx_count = 0;
TransferCfg->rx_count = 0;
// Start command
CodeStatus = I2C_Start(I2Cx, I2C_TRANSFER_POLLING);
while(1) // send data first and then receive data from Slave.
{
Ret = I2C_MasterHanleStates(i2cId, CodeStatus, TransferCfg, I2C_TRANSFER_POLLING);
if(I2C_CheckError(Ret))
{
TransferCfg->retransmissions_count++;
if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max){
// save status
TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;
goto error;
} else {
goto retry;
}
}
else if( (Ret & I2C_BYTE_SENT) ||
(Ret & I2C_BYTE_RECV))
{
// Wait for sending ends/ Wait for next byte
while (!(I2Cx->CONSET & I2C_I2CONSET_SI));
}
else if (Ret & I2C_SEND_END) // already send all data
{
// If no need to wait for data from Slave
if(TransferCfg->rx_count >= (TransferCfg->rx_length))
{
break;
}
else
{
I2C_Start(I2Cx, I2C_TRANSFER_POLLING);
}
}
else if (Ret & I2C_RECV_END) // already receive all data
{
break;
}
CodeStatus = I2Cx->STAT & I2C_STAT_CODE_BITMASK;
}
return SUCCESS;
error:
return ERROR;
}
else if (Opt == I2C_TRANSFER_INTERRUPT)
{
// Setup tx_rx data, callback and interrupt handler
i2cdat[i2cId].txrx_setup = (uint32_t) TransferCfg;
// Set direction phase, write first
i2cdat[i2cId].dir = 0;
/* First Start condition -------------------------------------------------------------- */
// Reset STA, STO, SI
I2C_Start(I2Cx, I2C_TRANSFER_INTERRUPT);
I2C_IntCmd(i2cId, TRUE);
return (SUCCESS);
}
return ERROR;
}
/*********************************************************************//**
* @brief General Master Interrupt handler for I2C peripheral
* @param[in] I2Cx I2C peripheral selected, should be:
* - LPC_I2C
* - LPC_I2C1
* - LPC_I2C2
* @return None
**********************************************************************/
void I2C_MasterHandler(en_I2C_unitId i2cId)
{
LPC_I2C_TypeDef* I2Cx = I2C_GetPointer(i2cId);
uint8_t returnCode;
I2C_M_SETUP_Type *txrx_setup;
int32_t Ret = I2C_OK;
txrx_setup = (I2C_M_SETUP_Type *) i2cdat[i2cId].txrx_setup;
returnCode = (I2Cx->STAT & I2C_STAT_CODE_BITMASK);
// Save current status
txrx_setup->status = returnCode;
Ret = I2C_MasterHanleStates(i2cId, returnCode, txrx_setup, I2C_TRANSFER_INTERRUPT);
if(I2C_CheckError(Ret))
{
if(txrx_setup->retransmissions_count < txrx_setup->retransmissions_max)
{
// Retry
txrx_setup->retransmissions_count ++;
txrx_setup->tx_count = 0;
txrx_setup->rx_count = 0;
// Reset STA, STO, SI
I2C_Start(I2Cx, I2C_TRANSFER_INTERRUPT);
return;
}
else
{
goto s_int_end;
}
}
else if (Ret & I2C_SEND_END)
{
// If no need to wait for data from Slave
if(txrx_setup->rx_count >= (txrx_setup->rx_length))
{
goto s_int_end;
}
else // Start to wait for data from Slave
{
// Reset STA, STO, SI
I2C_Start(I2Cx, I2C_TRANSFER_INTERRUPT);
return;
}
}
else if (Ret & I2C_RECV_END)
{
goto s_int_end;
}
else
{
return;
}
s_int_end:
// Disable interrupt
I2C_IntCmd(i2cId, FALSE);
I2Cx->CONCLR = I2C_I2CONCLR_AAC | I2C_I2CONCLR_SIC | I2C_I2CONCLR_STAC;
I2C_MasterComplete[i2cId] = TRUE;
}
void main(void)
{
const unsigned char *mas="\r\n---------------MASTER DEVICE-----------------\r\n";
const unsigned char * arr1 = "\r\nTaking in the text \r\n";
const unsigned char *arr2="\r\nEnter your choice \r\n 1.Slave 1(Address:0xAA\r\n2.Slave 2(Address:0xBB)\r\n3.Slave 3(Address:0xCC\r\n";
const unsigned char *arr3= "You have entered:\r\n";
const unsigned char *arr4= "\r\nUART Initialised\r\n";
const unsigned char *arr5= "\r\nI2C initialised:\r\n";
const unsigned char *msg1="\r\nSending to Slave 1 (Address 0xAA)\r\n";
const unsigned char *msg2="\r\nSending to Slave 2 (Address 0xBB)\r\n";
const unsigned char *msg3="\r\nSending to Slave 3 (Address 0xCC)\r\n";
const unsigned char *msg4="\r\nAddress sent\r\n";
const unsigned char *msg5="\r\nData sent\r\n";
const unsigned char *err="\r\nNo message will be sent since no slave no entered\r\n";
const unsigned char *fin="\r\nClosing Communication!\r\n";
const unsigned char *msgm="\r\nYou have entered choice number:\r\n";
unsigned char choice;
OSCCONbits.IRCF = 0x07; // Configure Internal OSC for 8MHz Clock
while(!OSCCONbits.HTS); // Wait Until Internal Osc is Stable
INTCON=0; // purpose of disabling the interrupts.
UART_Init(baud_rate);
UART_Write_Text(mas);
UART_Write_Text(arr4);
delay_ms(500);
I2C_init();
UART_Write_Text(arr5);
//Initialisation done
while(1)
{
UART_Write_Text(arr1);
i2c_idle();
//receive the characters until ENTER is pressed (ASCII for ENTER = 13)
is=UART_Read_Text();
UART_Write_Text(arr3);
UART_Write_Text(is);
UART_Write_Text(arr2);
choice=UART_Read();
UART_Write_Text(msgm);
UART_Write(choice);
switch(choice)
{
case 0x31:
{
UART_Write_Text(msg1);
I2C_Start();
if(I2C_address_send())//device address
{
delay_us(20);//clock settle and then send
I2C_Write_Text(is);
}
else
break;
I2C_Stop();
break;
}
case 0x32:
{
UART_Write_Text(msg2);
I2C_Start();
if(I2C_address_send1())//device address
{
delay_us(20);//clock settle and then send
I2C_Write_Text(is);
}
else
break;
I2C_Stop();
break;
}
case 0x33:
{
UART_Write_Text(msg3);
I2C_Start();
if(I2C_address_send2())//device address
{
delay_us(20);//clock settle and then send
I2C_Write_Text(is);
}
else
break;
I2C_Stop();
break;
}
default:
UART_Write_Text(err);
break;
}
//Choice entered data sent respectively to slaves now stop
//i2c_SendAcknowledge(I2C_LAST);
PIR1bits.SSPIF = 0;
UART_Write_Text(fin);
}
}
void AppCallBack(uint32 event, void *eventParam)
{
uint8 i;
CYBLE_GATTS_WRITE_REQ_PARAM_T *wrReqParam;
switch (event)
{
case CYBLE_EVT_STACK_ON:
/* start advertising */
apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
if(apiResult == CYBLE_ERROR_OK)
{
#ifdef LED_INDICATION
ADV_LED_ON();
#endif /* LED_INDICATION */
}
break;
case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
sendNotifications = 0;
#ifdef ENABLE_I2C_ONLY_WHEN_CONNECTED
/* Stop I2C Slave operation */
I2C_Stop();
#endif
#ifdef LED_INDICATION
/* Indicate disconnect event to user */
DISCON_LED_ON();
CyDelay(3000);
#endif /* LED_INDICATION */
/* start advertising */
apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
if(apiResult == CYBLE_ERROR_OK)
{
#ifdef LED_INDICATION
ADV_LED_ON();
#endif /* LED_INDICATION */
}
break;
case CYBLE_EVT_GATT_CONNECT_IND:
#ifdef LED_INDICATION
CONNECT_LED_ON();
#endif /* LED_INDICATION */
#ifdef ENABLE_I2C_ONLY_WHEN_CONNECTED
/* Start I2C Slave operation */
I2C_Start();
/* Initialize I2C write buffer */
I2C_I2CSlaveInitWriteBuf((uint8 *) wrBuf, I2C_WRITE_BUFFER_SIZE);
/* Initialize I2C read buffer */
I2C_I2CSlaveInitReadBuf((uint8 *) rdBuf, I2C_READ_BUFFER_SIZE);
#endif
break;
/* Client may do Write Value or Write Value without Response. Handle both */
case CYBLE_EVT_GATTS_WRITE_REQ:
case CYBLE_EVT_GATTS_WRITE_CMD_REQ:
wrReqParam = (CYBLE_GATTS_WRITE_REQ_PARAM_T *) eventParam;
/* Handling Notification Enable */
if(wrReqParam->handleValPair.attrHandle == CYBLE_I2C_READ_I2C_READ_DATA_CLIENT_CHARACTERISTIC_CONFIGURATION_DESC_HANDLE)
{
CYBLE_GATT_HANDLE_VALUE_PAIR_T I2CNotificationCCDHandle;
uint8 I2CCCDValue[2];
/* Extract CCCD Notification enable flag */
sendNotifications = wrReqParam->handleValPair.value.val[0];
/* Write the present I2C notification status to the local variable */
I2CCCDValue[0] = sendNotifications;
I2CCCDValue[1] = 0x00;
/* Update CCCD handle with notification status data*/
I2CNotificationCCDHandle.attrHandle = CYBLE_I2C_READ_I2C_READ_DATA_CLIENT_CHARACTERISTIC_CONFIGURATION_DESC_HANDLE;
I2CNotificationCCDHandle.value.val = I2CCCDValue;
I2CNotificationCCDHandle.value.len = 2;
/* Report data to BLE component for sending data when read by Central device */
CyBle_GattsWriteAttributeValue(&I2CNotificationCCDHandle, 0, &cyBle_connHandle, CYBLE_GATT_DB_LOCALLY_INITIATED);
}
/* Handling Write data from Client */
else if(wrReqParam->handleValPair.attrHandle == CYBLE_I2C_WRITE_I2C_WRITE_DATA_CHAR_HANDLE)
{
/* Turn off I2C interrupt before updating read registers */
I2C_DisableInt();
/*The data received from I2C client is extracted */
for(i=0;i<(wrReqParam->handleValPair.value.len);i++)
rdBuf[i] = wrReqParam->handleValPair.value.val[i];
/* Turn on I2C interrupt after updating read registers */
I2C_EnableInt();
}
if (event == CYBLE_EVT_GATTS_WRITE_REQ)
{
CyBle_GattsWriteRsp(cyBle_connHandle);
}
break;
default:
break;
}
}
// Read one of the temperature sensors. This function will
// block the calling task until the entire sensor read has been completed
I2C_Status ReadTempSensor(uint8_t index, uint16_t* tempOut)
{
I2C_Status retVal = I2C_OK;
uint16_t temp = 0;
taskENTER_CRITICAL();
do
{
// Write to the i2cTxBuffer
i2cTxBuffer[0] = TMP102_CONFIG_1_ONESHOT_VAL;
i2cTxBuffer[1] = TMP102_CONFIG_2_VAL;
// Write to the config register to begin a one-shot temperature conversion
// I2C Write
I2C_Start(SLB_I2C, GetTmp102Addr(index), 0);
if((retVal = I2C_WriteByte(SLB_I2C, TMP102_CONFIG_ADDR)) != I2C_OK)
{
break;
}
if((retVal = I2C_WaitForTX(SLB_I2C)) != I2C_OK)
{
break;
}
I2C_Stop(SLB_I2C);
// I2C Write
I2C_Start(SLB_I2C, GetTmp102Addr(index), 0);
if((retVal = I2C_WriteBytes(SLB_I2C, i2cTxBuffer, 2)) != I2C_OK)
{
break;
}
if((retVal = I2C_WaitForTX(SLB_I2C)) != I2C_OK)
{
break;
}
I2C_Stop(SLB_I2C);
// Read the temperature registers from the sensor
// I2C Write
I2C_Start(SLB_I2C, GetTmp102Addr(index), 0);
if((retVal = I2C_WriteByte(SLB_I2C, TMP102_TEMP_ADDR)) != I2C_OK)
{
break;
}
if((retVal = I2C_WaitForTX(SLB_I2C)) != I2C_OK)
{
break;
}
I2C_Stop(SLB_I2C);
// I2C Read
I2C_Start(SLB_I2C, GetTmp102Addr(index), 1);
if((retVal = I2C_ReadBytes(SLB_I2C, i2cRxBuffer, 2)) != I2C_OK)
{
break;
}
I2C_Stop(SLB_I2C);
// Process returned data
temp = (((uint16_t)i2cRxBuffer[0]) << 4) & 0xFFF0;
temp |= (((uint16_t)i2cRxBuffer[1]) >> 4) & 0x000F;
*tempOut = temp;
} while(0);
taskEXIT_CRITICAL();
return retVal;
}
