static inline void i2c_send_ack(i2c_t *obj)
{
int delay_value;
switch ((int)obj->i2c) {
case I2C_0:
delay_value = TSC_TSU;
break;
case I2C_1:
delay_value = AAIC_TSU;
break;
case I2C_2:
delay_value = SHIELD_TSU;
break;
case I2C_3:
delay_value = SHIELD_TSU;
break;
}
i2c_delay(delay_value);
obj->i2c->CONTROLC = SDA;
i2c_delay(delay_value);
obj->i2c->CONTROLS = SCL;
i2c_delay(delay_value);
obj->i2c->CONTROLC = SCL;
i2c_delay(delay_value);
}
static unsigned char SCCB_get_byte(void)
{
volatile signed char i;
volatile unsigned char j;
unsigned char get_byte=0;
SET_SCCB_DATA_INPUT;
for (i=7;i>=0;i--)
{ /* data bit 7~0 */
SET_SCCB_CLK_HIGH;
//for(j=0;j<I2C_DELAY;j++);
i2c_delay(I2C_DELAY);
if (GET_SCCB_DATA_BIT)
get_byte |= (1<<i);
//for(j=0;j<I2C_DELAY;j++);
i2c_delay(I2C_DELAY);
SET_SCCB_CLK_LOW;
//for(j=0;j<I2C_DELAY;j++);
i2c_delay(I2C_DELAY);
}
/* don't care bit, 9th bit */
SET_SCCB_DATA_OUTPUT;
SET_SCCB_DATA_HIGH;
//for(j=0;j<I2C_DELAY;j++);
i2c_delay(I2C_DELAY);
SET_SCCB_CLK_HIGH;
//for(j=0;j<I2C_DELAY;j++);
i2c_delay(I2C_DELAY);
SET_SCCB_CLK_LOW;
return get_byte;
} /* SCCB_send_byte() */
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_start
*#
*# DESCRIPTION : generate i2c start condition
*#
*# PARAMETERS : none
*#
*# RETURN : EI2CNOERRORS if OK, EI2CSTRTCOND otherwise
*#
*#---------------------------------------------------------------------------
*/
int i2c_start( void )
{
/* Set SCL=1, SDA=1 */
i2c_sda_dir_out();
i2c_set_sda( SDA_HIGH );
i2c_delay( WAITONEUS );
i2c_set_scl( SCL_HIGH );
i2c_delay( WAITONEUS );
/* Set SCL=1, SDA=0 */
i2c_set_sda( SDA_LOW );
i2c_delay( THDSTA );
/* Set SCL=0, SDA=0 */
i2c_set_scl( SCL_LOW );
/* We can take 1 us less than defined in spec (5 us), since the next action
* will be to set the dataline high or low and this action is 1 us
* before the clock is put high, so that makes our 5 us.
*/
i2c_delay( TLOW - WAITONEUS );
if ( i2c_sda_is_high() || i2c_scl_is_high() )
{
printk( KERN_DEBUG "I2C: EI2CSTRTCOND\n" );
return ( EI2CSTRTCOND );
}
return ( EI2CNOERRORS );
} /* i2c_start */
static i2c_ack i2c_read_ack(void)
{
u8 ret;
clr_i2c_pin(GPIO_I2C_SCL);//clk
i2c_io_config( GPIO_I2C_SDA, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_16MA, 0);
i2c_delay(DELAY_UNIT << Dtime);
set_i2c_pin(GPIO_I2C_SCL);
i2c_delay(DELAY_UNIT << Dtime);
if (!gpio_get_value(GPIO_I2C_SDA))//read ack
{
ret = ACK;
}
else
{
ret = NACK;
}
clr_i2c_pin(GPIO_I2C_SCL);//clk
i2c_io_config( GPIO_I2C_SDA, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA, 0);
return ret;
}
static void SCCB_send_byte(unsigned char send_byte)
{
volatile signed char i;
volatile unsigned int j;
for (i=7;i>=0;i--)
{ /* data bit 7~0 */
if (send_byte & (1<<i))
{
SET_SCCB_DATA_HIGH;
}
else
{
SET_SCCB_DATA_LOW;
}
i2c_delay(I2C_DELAY);
SET_SCCB_CLK_HIGH;
i2c_delay(I2C_DELAY);
SET_SCCB_CLK_LOW;
i2c_delay(I2C_DELAY);
}
/* don't care bit, 9th bit */
SET_SCCB_DATA_LOW;
SET_SCCB_DATA_INPUT;
SET_SCCB_CLK_HIGH;
i2c_delay(I2C_DELAY);
SET_SCCB_CLK_LOW;
SET_SCCB_DATA_OUTPUT;
} /* SCCB_send_byte() */
void
i2c_outbyte(unsigned char x)
{
int i;
i2c_dir_out();
for (i = 0; i < 8; i++) {
if (x & 0x80) {
i2c_data(I2C_DATA_HIGH);
} else {
i2c_data(I2C_DATA_LOW);
}
i2c_delay(CLOCK_LOW_TIME/2);
i2c_clk(I2C_CLOCK_HIGH);
i2c_delay(CLOCK_HIGH_TIME);
i2c_clk(I2C_CLOCK_LOW);
i2c_delay(CLOCK_LOW_TIME/2);
x <<= 1;
}
i2c_data(I2C_DATA_LOW);
i2c_delay(CLOCK_LOW_TIME/2);
/*
* enable input
*/
i2c_dir_in();
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: I2C::sendAck
*#
*# DESCRIPTION : Send ACK on received data
*#
*#--------------------------------------------------------------------------*/
void
i2c_sendack(void)
{
/*
* enable output
*/
i2c_delay(CLOCK_LOW_TIME);
i2c_dir_out();
/*
* set ack pulse high
*/
i2c_data(I2C_DATA_LOW);
/*
* generate clock pulse
*/
i2c_delay(CLOCK_HIGH_TIME/6);
i2c_clk(I2C_CLOCK_HIGH);
i2c_delay(CLOCK_HIGH_TIME);
i2c_clk(I2C_CLOCK_LOW);
i2c_delay(CLOCK_LOW_TIME/6);
/*
* reset data out
*/
i2c_data(I2C_DATA_HIGH);
i2c_delay(CLOCK_LOW_TIME);
i2c_dir_in();
}
void mag3110_init(void)
{
uint8_t deviceid;
/* read sensor ID */
deviceid = mag3110_read(0x07);
/* check available sensor */
if (deviceid != 0xC4)
{
printf("mag3110: Device not found\r\n");
}
//CTRL_REG1
//DR2|DR1|DR0|OS1|OS0|FastRead|Trigger|ActiveMode|
// 0 | 1 | 1 | 1 | 1 | 0 | 0 | 1 |
mag3110_write(0x10, 0x79);
i2c_delay();
i2c_delay();
//CTRL_REG2:
//AutoMagRst|---|Raw|Mag_Rst|---|---|---|---|
// 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
mag3110_write(0x11, 0x80);
}
/* i2c_read_byte
Read a byte from I2C bus
=> ack = acknowlege bit to send after read
<= returns data read from the bus
*/
unsigned char i2c_read_byte(unsigned char ack)
{
unsigned char loop, byte;
i2c_set_sda();
/* read data msb first */
for(loop = 0; loop < 8; loop++)
{
byte = byte << 1;
i2c_set_scl();
i2c_delay();
if(i2c_read_sda()) byte = byte | 1;
i2c_clear_scl();
}
/* send ack bit */
if(ack)
i2c_set_sda();
else
i2c_clear_sda();
i2c_set_scl();
i2c_delay();
i2c_clear_scl();
i2c_set_sda();
return byte;
}
/* i2c_write_byte
Write a byte to I2C bus
=> byte = data to write out
<= return 0 if acknowleged by the slave
*/
unsigned char i2c_write_byte(unsigned char byte)
{
unsigned char loop, ack, original_byte = byte;
/* send data, msb first */
for(loop = 0; loop < 8; loop++)
{
if(byte & 0x80)
i2c_set_sda();
else
i2c_clear_sda();
i2c_set_scl();
i2c_delay();
i2c_clear_scl();
byte = byte << 1;
}
/* read ack bit from slave */
i2c_set_sda();
i2c_set_scl();
i2c_delay();
ack = i2c_read_sda();
i2c_clear_scl();
return ack;
}
uint8_t i2c_read(bool ack){
uint8_t i, d = 0;
i2c_sda = 1;
for(i = 8; i != 0; i--) {
i2c_delay();
d <<= 1;
do {
i2c_scl = 1;
}
while(i2c_scl_in == 0); // wait for any i2c_scl clock stretching to complete
i2c_delay();
if (i2c_sda_in)
d |= 1;
i2c_scl = 0;
}
if (ack)
i2c_sda = 0;
else
i2c_sda = 1;
i2c_delay();
i2c_scl = 1;
i2c_delay(); // send (N)ACK bit
i2c_scl = 0;
i2c_delay();
i2c_sda = 1;
return d;
}
int i2c_stop(i2c_t *obj)
{
int delay_value;
switch ((int)obj->i2c) {
case I2C_0:
delay_value = TSC_TSU;
break;
case I2C_1:
delay_value = AAIC_TSU;
break;
case I2C_2:
delay_value = SHIELD_TSU;
break;
case I2C_3:
delay_value = SHIELD_TSU;
break;
}
// Actual stop bit
i2c_delay(delay_value);
obj->i2c->CONTROLC = SDA;
i2c_delay(delay_value);
obj->i2c->CONTROLS = SCL;
i2c_delay(delay_value);
obj->i2c->CONTROLS = SDA;
i2c_delay(delay_value);
return 0;
}
void i2c_stop(){
i2c_sda = 0;
i2c_delay();
i2c_scl = 1;
i2c_delay();
i2c_sda = 1;
i2c_delay();
}
void i2c_stop(void)
{
SDA_LOW ;
SCL_HIGH ;
i2c_delay() ;
SDA_HIGH ;
i2c_delay() ;
}
//------------------------------------------------------------------------
static void i2c_stop ( void )
{
i2c_delay();
scl_high();
i2c_delay();
sda_high();
i2c_delay();
i2c_delay();
}
void i2c_stop(void){
P2DIR |= 0x01; // set SDA = 0
i2c_delay();
P2DIR &= ~0x02; // set SCL = 1
i2c_delay();
P2DIR &= ~0x01; // set SDA = 1
i2c_delay();
}
static void i2c_stop(void)
{
clr_i2c_pin(GPIO_I2C_SCL);
clr_i2c_pin(GPIO_I2C_SDA);
set_i2c_pin(GPIO_I2C_SCL);
i2c_delay(DELAY_UNIT << Dtime);
set_i2c_pin(GPIO_I2C_SDA);
i2c_delay(DELAY_UNIT << Dtime);
}
static void i2c_stop(void)
{
GPIO_ResetBits(I2Cx_PORT,I2Cx_SCL_PIN); /* SCL -> 0 */
GPIO_ResetBits(I2Cx_PORT,I2Cx_SDA_PIN); /* SDA->0 set bit 4 of P3 to 0 */
i2c_delay();
GPIO_SetBits(I2Cx_PORT,I2Cx_SCL_PIN); /* SCL -> 1 */
i2c_delay();
GPIO_SetBits(I2Cx_PORT,I2Cx_SDA_PIN); /* SDA 0->1 set bit 4 of P3 to 1 */
}
void i2c_start(void)
{
SDA_HIGH ;
SCL_HIGH ;
i2c_delay() ;
SDA_LOW ;
i2c_delay() ;
SCL_LOW ;
}
//Передает адрес приемника + RW/RD
void i2c_tx_addr(unsigned char adr)
{
i2c_delay(); //Wait for TWI interrupt flag set
TWDR = adr;
TWCR=((1<<TWINT)|(1<<TWEN)); //Clear int flag to send byte
i2c_delay(); //Wait for TWI interrupt flag set
// if((TWSR != MTX_ADR_ACK)&&(TWSR != MRX_ADR_ACK))//If NACK received return
// i2c_error=1;
}
/*
* TODO!
*/
void i2c_stop(void) {
i2c_init(WRITE); // Initialization
SDA_0; // A LOW state on SDA line
i2c_delay(uDLY); // Just We Wait...
SCL_1; // Now HIGHT state on SCL line
i2c_delay(uDLY); // ...still wait...
SDA_1; // And SDA go to HIGHT state
i2c_delay(uDLY); // ...And Again
}
void i2c_reset(){
i2c_sda = 1;
while (!i2c_sda_in){
i2c_scl = 0;
i2c_delay();
i2c_scl = 1;
i2c_delay();
}
}
//------------------------------------------------------------------------
static void i2c_start ( void )
{
i2c_delay();
i2c_delay();
sda_low();
i2c_delay();
i2c_delay();
scl_low();
i2c_delay();
}
static inline void write_bit(unsigned bit)
{
if (bit) set_SDA(); else clr_SDA();
i2c_delay();
set_SCL();
while (!tst_SCL()) ;
i2c_delay();
clr_SCL();
i2c_delay();
}
void i2c_start(){
i2c_sda = 1;
i2c_delay();
i2c_scl = 1;
i2c_delay();
i2c_sda = 0;
i2c_delay();
i2c_scl = 0;
i2c_delay();
}
/*
* TODO!
*/
void i2c_start(void) {
i2c_init(WRITE); // Initialization
SCL_1; // HIGHT state SCL and...
SDA_1; // ...HIGHT state SDA, of course
i2c_delay(uDLY); // let's wait a bit...
SDA_0; // WoW!!! LOW state SDA (a START Condition)
i2c_delay(uDLY); // ... again ...
SCL_0; // And lets end the START condition-LOW state SCL
i2c_delay(uDLY); // ...and one more
}
static void i2c_stop_cond(void)
{
/* set SDA to 0 */
CSR_GPIO_OUT |= GPIO_I2C_SDA_DRIVELOW;
i2c_delay();
CSR_GPIO_OUT |= GPIO_I2C_SDC;
i2c_delay();
CSR_GPIO_OUT &= ~GPIO_I2C_SDA_DRIVELOW;
i2c_delay();
i2c_started = 0;
}
void i2c_start(void){
P2DIR &= ~0x01; // set the P2.0 (SDA) as input for SDA = 1 due to pull up resistor;
i2c_delay();
P2DIR &= ~0x02; // set the P2.1 (SCL) as input for SCL = 1 due to pull up resistor;
i2c_delay();
P2DIR |= 0x01; // Set SDA as output for SDA = 0 due to P2OUT being set to ground earlier
i2c_delay();
P2DIR |= 0x02; // Set P2.1 (SCL) as output
i2c_delay();
}
//Посылка байта
void i2c_tx(unsigned char byte)
{
if(i2c_error)
return;
i2c_delay();
TWDR = byte;
TWCR = ((1<<TWINT)+(1<<TWEN));
i2c_delay();
// if(TWSR != MTX_DATA_ACK) //если нет подтверждения от приемника, то
// i2c_error=1; //признак ошибки
}
static uint8_t i2c_read_bit(void)
{
uint8_t val;
/* do not drive SDA */
i2c_read_sda();
i2c_delay();
i2c_read_scl_and_delay();
val = i2c_read_sda();
i2c_delay();
i2c_clear_scl();
return val;
}
