int16_t PutsMasterI2C (uint8_t adresse, uint8_t *donnees, uint8_t nb_octet)
{
uint8_t j;
if (StartI2C () != 1)
{
return ERREUR_I2C_START;
}
if (WriteI2C ((adresse<<1)) != 1)
{
return ERREUR_I2C_WRITE;
}
for (j=0; j<nb_octet; j++)
{
if (WriteI2C (donnees[j]) != 1)
{
return ERREUR_I2C_WRITE;
}
}
if (StopI2C () != 1)
{
return ERREUR_I2C_STOP;
}
return 1;
}
// Configure and start temperature sensor
void configStartTempSensor(void)
{
// Set configuration register
StartI2C();
WriteI2C(0x9E); // slave address + W
IdleI2C();
WriteI2C(0xAC); // access configuration
IdleI2C();
WriteI2C(0x00); // set config
IdleI2C();
StopI2C();
// Need at least a 10msec delay (from data sheet)
Delay10KTCYx(40);
// Start temperature conversion
StartI2C();
WriteI2C(0x9E); // slave address + W
IdleI2C();
WriteI2C(0xEE); // start conversion
IdleI2C();
StopI2C();
// Another delay
Delay10KTCYx(40);
}
void MCP3422_config(uint8_t config_byte)
{
StartI2C();
WriteI2C(0xD0); // I2C address (for writing)
WriteI2C(config_byte); // CODE_LOAD command
StopI2C();
}
void EEPROM_write(BYTE devaddr, DWORD addr, BYTE *data, BYTE size)
{
BYTE i = 0;
IdleI2C();
StartI2C();
IdleI2C();
// Dev address
WriteI2C( devaddr << 1 );
IdleI2C();
// Memory address
WriteI2C( addr >> 8 );
IdleI2C();
WriteI2C( addr & 0xFF );
IdleI2C();
// data
for(; i < size; ++i)
{
WriteI2C( data[i] );
IdleI2C();
}
StopI2C();
DelayMs(5);
}
//-------------------------------
// Write 1 byte to I2C
//-------------------------------
void WriteBYTE(unsigned int Addr)
{
Start();
WriteI2C(0xA0);
WriteI2C((unsigned char)(Addr>>8)&0xFF); // send address high
WriteI2C((unsigned char)Addr&0xFF); // send address low
}
//-------------------------------
// Read 1 byte form I2C
//-------------------------------
void ReadBYTE(unsigned int Addr)
{
Start();
WriteI2C(0xA0);
WriteI2C((unsigned char)(Addr>>8)&0xFF);
WriteI2C((unsigned char)Addr&0xFF);
}
void ITG3200_write(unsigned char reg, unsigned char val) {
StartI2C();
WriteI2C(ITG3200_ADDR_WRITE);
WriteI2C(reg);
WriteI2C(val);
StopI2C();
}
/*********************************************************************
* Function: LDByteWriteI2C()
* Input: Control Byte, 8 - bit address, data.
* Overview: Write a byte to low density device at address LowAdd
********************************************************************/
unsigned int LDByteWriteI2C(unsigned char ControlByte, unsigned char LowAdd, unsigned char data)
{
unsigned int ErrorCode1;
unsigned int ErrorCode2;
IdleI2C(); //Ensure Module is Idle
StartI2C(); //Generate Start COndition
WriteI2C(ControlByte); //Write Control byte
IdleI2C();
ErrorCode1 = ACKStatus(); //Return ACK Status
WriteI2C(LowAdd); //Write Low Address
IdleI2C();
ErrorCode2 = ACKStatus(); //Return ACK Status
WriteI2C(data); //Write Data
IdleI2C();
StopI2C(); //Initiate Stop Condition
//EEAckPolling(ControlByte); //Perform ACK polling
if(ErrorCode1 == 0) { printf("ACK 1 not recieved"); }
if(ErrorCode2 == 0) { printf("ACK 2 not recieved"); }
//return(ErrorCode);
}
void init_MCP()
{
//IODIR A configuration
MCP_addr();
WriteI2C(MCP_IODIR_A);
WriteI2C(0x00);
StopI2C();
//IPOL A configuration
MCP_addr();
WriteI2C(MCP_IPOL_A);
WriteI2C(0x00);
StopI2C();
//OLAT A configuration
MCP_addr();
WriteI2C(MCP_OLAT_A);
WriteI2C(0xFF);
StopI2C();
//IOCON A configuration
MCP_addr();
WriteI2C(MCP_IOCON_A);
WriteI2C(0x00);
StopI2C();
//GPINTEN A configuration
MCP_addr();
WriteI2C(MCP_GPINTEN_A);
WriteI2C(0x00);
StopI2C();
}
void ADXL345_multiByteWrite(unsigned char startAddress, char* buffer, unsigned char size) {
#if I2C
unsigned char i;
StartI2C();
WriteI2C(ADXL343_ADDR_WRITE);
WriteI2C(startAddress);
for (i = 0; i < size; i++) {
WriteI2C(buffer[i]);
}
StopI2C();
#elif SPI
unsigned char tx = (ADXL345_SPI_WRITE | ADXL345_MULTI_BYTE | (startAddress & 0x3F));
unsigned char i;
SPI_CS_PIN = 0; //CS pin low, ie enable chip
Delay1TCY(); // delay at least 5 ns
WriteSPI(tx); //Send starting write address.
for (i = 0; i < size; i++) {
WriteSPI(buffer[i]);
}
SPI_CS_PIN = 1; //CS pin high, ie disable chip
#endif
}
//-------------------------------
// Write 1 byte to I2C
//-------------------------------
void WriteBYTE(unsigned char Addr,unsigned char Data)
{
Start();
WriteI2C(0xD0);
WriteI2C(Addr);
WriteI2C(Data);
Stop();
}
/*
*------------------------------------------------------------------------------
* void StoreSystemDay(UINT8 day)
*
* Summary : Set new day
*
* Input : UINT8 day - value related to day
*
* Output : None
*
* Nonte : Day value must be between 1 to 7
*------------------------------------------------------------------------------
*/
void StoreSystemDay(UINT8 day)
{
StartI2C();
WriteI2C(DEV_ADDR_RTC);
WriteI2C(RTC_REG_DAY);
WriteI2C(day); //day
StopI2C();
}
void MAX5217_load_code(uint8_t value_hi, uint8_t value_lo)
{
StartI2C();
WriteI2C(0x3A); // I2C address (for writing)
WriteI2C(0x01); // CODE_LOAD command
WriteI2C(value_hi); // DAC value <15:8>
WriteI2C(value_lo); // DAC value <7:0>
StopI2C();
}
void set_amp_speaker_stereo_audio(void)
{
int fail=0;
fail |= WriteI2C(SUBSYSTEM_CONTROL, (~SWS & ~BYPASS & ~SSM_EN));
fail |= WriteI2C(INPUT_CONTROL, (amp_cal_data[SPEAKER_AUDIO_INPUT] | IN2_SE)); //Modify for desired IN gain
fail |= WriteI2C(SPEAKER_VOLUME, (SPK_EN | amp_cal_data[SPEAKER_AUDIO_OUTPUT])); //Modify for desired SP gain
fail |= WriteI2C(SPEAKER_OUTPUT, SPKOUT_IN2);
MM_INFO("7 set_amp_speaker_stereo_voice() %d\n", fail);
}
/*
*------------------------------------------------------------------------------
* void StoreSystemDate(void)
*
* Summary : Set new RTC date
*
* Input : None
*
* Output : None
*
*------------------------------------------------------------------------------
*/
void StoreSystemDate(UINT8 *databuffer)
{
StartI2C();
WriteI2C(DEV_ADDR_RTC);
WriteI2C(RTC_REG_DATE);
WriteI2C(((*(databuffer + 0) & 0x0F)<<4) | (*(databuffer + 1) & 0x0F)); //date
WriteI2C(((*(databuffer + 2) & 0x0F)<<4) | (*(databuffer + 3) & 0x0F)); //month
WriteI2C(((*(databuffer + 4) & 0x0F)<<4) | (*(databuffer + 5) & 0x0F)); //year
StopI2C();
}
/*
*------------------------------------------------------------------------------
* void StoreSystemTime(void)
*
* Summary : Set new RTC time
*
* Input : None
*
* Output : None
*
*------------------------------------------------------------------------------
*/
void StoreSystemTime(UINT8 *databuffer)
{
StartI2C();
WriteI2C(DEV_ADDR_RTC);
WriteI2C(RTC_REG_SEC);
WriteI2C(((*(databuffer + 4) & 0x0F)<<4) | (*(databuffer + 5) & 0x0F)); //sec
WriteI2C(((*(databuffer + 2) & 0x0F)<<4) | (*(databuffer + 3) & 0x0F)); //min
WriteI2C(((*(databuffer + 0) & 0x0F)<<4) | (*(databuffer + 1) & 0x0F)); //hour
StopI2C();
}
// Configure and start temperature sensor
void stopTempSensor(void)
{
StartI2C();
IdleI2C();
WriteI2C(0x9E); // slave address + W
IdleI2C();
WriteI2C(0x22); // stop conversion
IdleI2C();
StopI2C();
// Another delay
Delay10KTCYx(40);
}
//-------------------------------
// Read 1 byte form I2C
//-------------------------------
unsigned char ReadBYTE(unsigned char Addr)
{
unsigned char Data;
Start();
WriteI2C(0xD0);
WriteI2C(Addr);
Start();
WriteI2C(0xD1);
Data = ReadI2C(NO_ACK);
Stop();
return(Data);
}
unsigned char rtc_get_time (unsigned char address)
{
unsigned char time;
StartI2C();
WriteI2C(0xD0);
WriteI2C(address);
RestartI2C();
WriteI2C(0xD1);
time = ReadI2C();
return (((time & 0xF0) >> 4) * 10) + (time & 0x0F); // BCD to decimal
}
/*********************************************************************
* Function: LDPageWriteI2C()
* Input: ControlByte, LowAdd, *wrptr.
* Overview: Write a page of data from array pointed to be wrptr
* starting at LowAdd
* Note: LowAdd must start on a page boundary
********************************************************************/
unsigned int LDPageWriteI2C(unsigned char ControlByte, unsigned char LowAdd, unsigned char *wrptr)
{
IdleI2C(); //wait for bus Idle
StartI2C(); //Generate Start condition
WriteI2C(ControlByte); //send controlbyte for a write
IdleI2C(); //wait for bus Idle
WriteI2C(LowAdd); //send low address
IdleI2C(); //wait for bus Idle
putstringI2C(wrptr); //send data
IdleI2C(); //wait for bus Idle
StopI2C(); //Generate Stop
return(0);
}
/*********************************************************************
* Function: XEE_RESULT XEEIsBusy(unsigned char control)
*
* PreCondition: XEEInit() is already called.
*
* Input: control - EEPROM control and address code.
*
* Output: XEE_READY if EEPROM is not busy
* XEE_BUSY if EEPROM is busy
* other value if failed.
*
* Side Effects: None
*
* Overview: Requests ack from EEPROM.
*
* Note: None
********************************************************************/
XEE_RESULT XEEIsBusy(unsigned char control)
{
XEE_RESULT r;
IdleI2C(); // ensure module is idle
StartI2C(); // initiate START condition
while ( EEPROM_SPICON2bits.SEN ); // wait until start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
{
return XEE_BUS_COLLISION; // return with Bus Collision error
}
else
{
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
return XEE_BUS_COLLISION; // set error for write collision
IdleI2C(); // ensure module is idle
if ( PIR2bits.BCLIF ) // test for bus collision
return XEE_BUS_COLLISION; // return with Bus Collision error
if ( !EEPROM_SPICON2bits.ACKSTAT )
r = XEE_READY;
else
r = XEE_BUSY;
#if 0
while ( EEPROM_SPICON2bits.ACKSTAT ) // test for ACK condition received
{
RestartI2C(); // initiate Restart condition
while ( EEPROM_SPICON2bits.RSEN ); // wait until re-start condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
return XEE_BUS_COLLISION; // return with Bus Collision error
if ( WriteI2C( control ) ) // write byte - R/W bit should be 0
return XEE_BUS_COLLISION; // set error for write collision
IdleI2C(); // ensure module is idle
}
#endif
}
StopI2C(); // send STOP condition
while ( EEPROM_SPICON2bits.PEN ); // wait until stop condition is over
if ( PIR2bits.BCLIF ) // test for bus collision
return XEE_BUS_COLLISION; // return with Bus Collision error
return r;
//return XEE_READY; // return with no error
}
int tpa2028d_poweron(void)
{
int fail = 0;
char agc_compression_rate = amp_data->pdata->agc_compression_rate;
char agc_output_limiter_disable = amp_data->pdata->agc_output_limiter_disable;
char agc_fixed_gain = amp_data->pdata->agc_fixed_gain & 0x3F;
char ATK_time = amp_data->pdata->ATK_time & 0x3F;
char REL_time = amp_data->pdata->REL_time & 0x3F;
char Hold_time = amp_data->pdata->Hold_time & 0x3F;
char Output_limit_level = amp_data->pdata->Output_limit_level & 0x1F;
char Noise_Gate_Threshold
= (amp_data->pdata->Noise_Gate_Threshold & 0x03) << 5;
char AGC_Max_Gain = (amp_data->pdata->AGC_Max_Gain & 0x0F) << 4;
agc_output_limiter_disable = (agc_output_limiter_disable << 7);
fail |= WriteI2C(IC_CONTROL, 0xE3); /*Tuen On*/
fail |= WriteI2C(AGC_ATTACK_CONTROL, ATK_time); /*Tuen On*/
fail |= WriteI2C(AGC_RELEASE_CONTROL, REL_time); /*Tuen On*/
fail |= WriteI2C(AGC_HOLD_TIME_CONTROL, Hold_time); /*Tuen On*/
fail |= WriteI2C(AGC_FIXED_GAIN_CONTROL, agc_fixed_gain); /*Tuen On*/
fail |= WriteI2C(AGC1_CONTROL,
Noise_Gate_Threshold|
Output_limit_level|
agc_output_limiter_disable); /*Tuen On*/
fail |= WriteI2C(AGC2_CONTROL,
AGC_Max_Gain|agc_compression_rate); /*Tuen On*/
fail |= WriteI2C(IC_CONTROL, 0xC3); /*Tuen On*/
return fail;
}
unsigned char ITG3200_read(unsigned char reg) {
unsigned char buf;
StartI2C();
WriteI2C(ITG3200_ADDR_WRITE);
WriteI2C(reg);
RestartI2C();
WriteI2C(ITG3200_ADDR_READ);
buf = ReadI2C();
NotAckI2C();
StopI2C();
return buf;
}
/*********************************************************************
* Function: LDSequentialReadI2C()
* Input: ControlByte, address, *rdptr, length.
* Overview: Performs a sequential read of length bytes starting at address
* and places data in array pointed to by *rdptr
********************************************************************/
unsigned int LDSequentialReadI2C(unsigned char ControlByte, unsigned char address, unsigned char *rdptr, unsigned char length)
{
IdleI2C(); //Ensure Module is Idle
StartI2C(); //Initiate start condition
WriteI2C(ControlByte); //write 1 byte
IdleI2C(); //Ensure module is Idle
WriteI2C(address); //Write word address
IdleI2C(); //Ensure module is idle
RestartI2C(); //Generate I2C Restart Condition
WriteI2C(ControlByte | 0x01); //Write 1 byte - R/W bit should be 1 for read
IdleI2C(); //Ensure bus is idle
getsI2C(rdptr, length); //Read in multiple bytes
NotAckI2C(); //Send Not Ack
StopI2C(); //Send stop condition
return(0);
}
/*********************************************************************
* Function: XEE_RESULT XEEBeginRead(unsigned char control,
* XEE_ADDR address)
*
* PreCondition: XEEInit() is already called.
*
* Input: control - EEPROM control and address code.
* address - Address at which read is to be performed.
*
* Output: XEE_SUCCESS if successful
* other value if failed.
*
* Side Effects: None
*
* Overview: Sets internal address counter to given address.
* Puts EEPROM in sequential read mode.
*
* Note: This function does not release I2C bus.
* User must call XEEEndRead() when read is not longer
* needed; I2C bus will released after XEEEndRead()
* is called.
********************************************************************/
XEE_RESULT XEEBeginRead(unsigned char control, XEE_ADDR address )
{
unsigned char r;
r = XEESetAddr(control, address);
if ( r != XEE_SUCCESS )
return r;
r = XEEClose();
if ( r != XEE_SUCCESS )
return r;
IdleI2C();
StartI2C();
while( EEPROM_SPICON2bits.SEN );
if ( PIR2bits.BCLIF )
return XEE_BUS_COLLISION;
if ( WriteI2C(control+1) )
return XEE_BUS_COLLISION;
IdleI2C();
if ( !EEPROM_SPICON2bits.ACKSTAT )
return XEE_SUCCESS;
return XEE_NAK;
}
char readEEPROMexterna (char endereco)
{
//while(!DataRdyI2C());
IdleI2C();
StartI2C(); IdleI2C();
WriteI2C(0xA0); IdleI2C();
WriteI2C(0x00); IdleI2C(); //HB
WriteI2C(endereco); IdleI2C();
RestartI2C(); IdleI2C();
WriteI2C(0xA1); IdleI2C();
value = ReadI2C(); IdleI2C(); //Dados
NotAckI2C(); IdleI2C();
StopI2C();IdleI2C();
return value;
}
/*
*------------------------------------------------------------------------------
* void ReadRtcTimeAndDate(UINT8 * buff)
*
* Summary : Read time and date related registers from RTC
*
* Input : UINT8 *buff - buffer pointer to receive the data
*
* Output : None
*
*------------------------------------------------------------------------------
*/
void ReadRtcTimeAndDate(UINT8 * buff)
{
StartI2C();
WriteI2C(DEV_ADDR_RTC);
WriteI2C(RTC_REG_SEC);
StartI2C();
WriteI2C(DEV_ADDR_RTC + 1);
*(buff+0)=ReadI2C(ACK); // Second
*(buff+1)=ReadI2C(ACK); // Minute
*(buff+2)=ReadI2C(ACK); // hour
*(buff+3)=ReadI2C(ACK); // Day
*(buff+4)=ReadI2C(ACK); // date
*(buff+5)=ReadI2C(ACK); // month
*(buff+6)=ReadI2C(NO_ACK); // year
StopI2C();
}
void TIMER2_isr(void)
{
unsigned long foo;
// Timer for 3219 keep alive response will reset the board since the DOCSIS side has stopped responding
// This loop should set off watchdog if DOCSIS ALIVE not received every few seconds
timer2counter += 1;
if (watchdogbypass == 0) {
if (timer2counter == 254) { //This should be about 8 seconds before reset is fired off
printf("\r\n");
printf("\r\n************************************************\n");
printf("\r\n*** DOCSIS ALIVE NOT RECEIVED..resetting CMC ***\n");
printf("\r\n************************************************\n");
printf("\r\n");
Timeout3219 = 1;
disable_interrupts(INT_TIMER2); //disable timer2 interrupt for 3219 watchdog
timer2counter = 0;
foo = RandReadI2C(EEPROM_ADDR,WatchdogResets,0);
WriteI2C(EEPROM_ADDR,WatchdogResets,foo+1,0);
SystemReset(1);
}
}
clear_interrupt(INT_TIMER2);
}
/*********************************************************************
* Function: LDByteReadI2C()
* Input: Control Byte, Address, *Data, Length.
* Overview: Performs a low density read of Length bytes and stores in *Data array
* starting at Address.
********************************************************************/
unsigned int LDByteReadI2C(unsigned char ControlByte, unsigned char Address, unsigned char *Data, unsigned char Length)
{
IdleI2C(); //wait for bus Idle
StartI2C(); //Generate Start Condition
WriteI2C(ControlByte); //Write Control Byte
IdleI2C(); //wait for bus Idle
WriteI2C(Address); //Write start address
IdleI2C(); //wait for bus Idle
RestartI2C(); //Generate restart condition
WriteI2C(ControlByte | 0x01); //Write control byte for read
IdleI2C(); //wait for bus Idle
getsI2C(Data, Length); //read Length number of bytes
NotAckI2C(); //Send Not Ack
StopI2C(); //Generate Stop
}
/*********************************************************************
* Function: EEAckPolling()
* Input: Control byte.
* Output: Error state.
* Overview: Polls the bus for an Acknowledge from device
********************************************************************/
unsigned int EEAckPolling(unsigned char control)
{
IdleI2C(); //wait for bus Idle
StartI2C(); //Generate Start condition
if(I2C1STATbits.BCL)
{
return(-1); //Bus collision, return
}
else
{
if(WriteI2C(control))
{
return(-3); //error return
}
IdleI2C(); //wait for bus idle
if(I2C1STATbits.BCL)
{
return(-1); //error return
}
while(ACKStatus())
{
RestartI2C(); //generate restart
if(I2C1STATbits.BCL)
{
return(-1); //error return
}
if(WriteI2C(control))
{
return(-3);
}
IdleI2C();
}
}
StopI2C(); //send stop condition
if(I2C1STATbits.BCL)
{
return(-1);
}
return(0);
}
