Admin at 11:01, 16 March 2014

2014-03-16T11:01:33Z

New page

various:

[[i2c-master]]

[[i2c-slave]]

I'm currently working on coding a reliable I2C library that can act as a master, slave or both.

The current library is not a stand-alone file, but needs to be included in the code. Below is the latest (not fully operational) i2cmaster.h, use at own risk.

<pre>

// --- I2C Functions ---
// --- I2C Functions ---
// --- I2C Functions ---

void i2cpin(int line, int state)
{
// set the I2C SDA or SCL PIN
// works on the PORTB registers

if (state == 0)
{
// set the pin low

DDRB |= (1 << line); // set line to output
PORTB &= ~(1 << line); // set it to zero

} else {

// set the pin high (let external pull-up resistor bring it high)

DDRB &= ~(1 << line); // set line to input

}

//_delay_ms(500); // use this as a debug tool

}

void i2c_delay()
{
// default delay in between I2C commands
_delay_ms(10); // seems to hover around 2-3ms
}

void i2c_tx(char d)
{

// SDA is LOW, SCL is HIGH (inherited from i2c-start command)

// bring clock low to start data transfer

i2cpin(SCL,LOW);

char x;
//static int b;
for(x=8; x; x--)
{
if(d&0x80)
{
i2cpin(SDA,HIGH);
} else {
i2cpin(SDA,LOW);
}

i2cpin(SCL,HIGH); // strobe clock

// allow for I2C clock stretching (SCL can be held low by slave)
// see I2C_STRETCH_TIMEOUT_MS

int stretch_counter;

for (stretch_counter=0; stretch_counter < I2C_STRETCH_TIMEOUT_MS; stretch_counter++)
{
// allow for some cycles for SCL to go high

if (bit_is_clear(PINB,SCL))
{
// SCL is held low by slave
// we'll just wait a little

_delay_ms(1);

} else {

// SCL has risen, ready to move on
stretch_counter = I2C_STRETCH_TIMEOUT_MS;
}

}

//_delay_us(1); // 1-3 us
i2cpin(SCL,LOW);

d <<= 1; // shift byte

}

i2cpin(SDA,HIGH); // first bring SDA into listening mode

//_delay_ms(1); // delay no longer needed, this used to be 1.6ms
//_delay_us(600);

// read acknowledge bit if any

// an addressed i2c slave will have already set SDA low
_delay_us(5); // give the bus some time to possibly bring the pin high
i2cpin(SCL,HIGH); // start the clock pulse

_delay_us(5); // this should be 10us or so

if (bit_is_set(PINB,SDA))
{
got_ack=0;
} else {
got_ack=1;
}

i2cpin(SDA,LOW); // we now bring SDA low
_delay_us(10); // give the bus some time? ----- may go

i2cpin(SCL,LOW); // end the clock pulse

// slave detects SCL is low and will release SDA

_delay_ms(3); // this should be 10us or so

// return b;

}

void i2c_start(char i2c_id)
{
// SDA goes from high to low while SCL is high

i2cpin(SDA,HIGH);
_delay_us(10); // give bus some time to bring SDA high
i2cpin(SCL,HIGH);

_delay_us(10);

i2cpin(SDA,LOW);
_delay_us(10);

// send the I2C Device ID

// send as Write (last bit is 0)

i2c_tx(i2c_id<<1);

}

void i2c_stop()
{
// SDA goes from low to high while SCL is high

i2cpin(SDA,LOW);
_delay_us(20); // give bus some time to bring SDA high
i2cpin(SCL,LOW);

_delay_ms(6);

i2cpin(SCL,HIGH);
_delay_ms(6);

i2cpin(SDA,HIGH);
_delay_ms(4);

}

void i2c_lcd_text(char *StrData)
{

int p = 0;
int q = strlen(StrData);
int temp = 0;

for (p = 0; p < q; p++)
{
temp = StrData[p];
i2c_tx(temp);
}
}

void i2c_lcd_number(int number)
{
int digits;

if (number == 0)
{
digits = 0;
int array[0];
array[0]=0;
i2c_tx(array[0]+48);

} else {

// determine the number of digits
digits = (int) (log(number)/log(10))+1;

// split up the number's digits into an array
int i = digits -1;
int array[digits];
while (number > 0)
{
array[i--] = number % 10;
number /= 10;
}

// send array over i2c
for (i =0; i <= digits-1; i++)
{
i2c_tx(array[i]+48);
}

}
}

void i2c_lcd_hex(uint8_t x)
{

// sends one byte in hex (without 0x prefix) to the lcd

char nibble;

/* extract high nibble */
nibble = x & 0xf0; // (resets lower nibble to all zero's)
nibble = x >> 4; // (moves high nibble to lower nibble)

// output the high nibble
if(nibble < 10)
{
i2c_tx(48 + nibble);
} else {
i2c_tx(65 + nibble - 10);
}

/* do the same on the low nibble */
nibble = x & 0x0f;

if(nibble < 10)
{
i2c_tx(48 + nibble);
} else {
i2c_tx(65 + nibble - 10);
}

}

</pre>

usage:

in main()

<pre>
// -- set up lines for I2C --
pinMode(SDA,INPUT);
pinMode(SCL,INPUT);
PORTB = 0; // disable internal pullup resistors
PORTB &= ~(1 << SDA); // set SDA LOW (makes line output)
PORTB &= ~(1 << SCL); // set SCL LOW (makes line output)

i2c_start(LCD_I2C_DEVICE_ID);
i2c_tx(12); //clear screen
i2c_tx(' ');
i2c_lcd_number(voltage_int); // measured voltage, whole numbers
i2c_tx('.');
i2c_lcd_number(voltage_dec1); // decimal 1
i2c_lcd_number(voltage_dec2); // decimal 2
i2c_tx('V');
i2c_tx(' ');
i2c_tx(' ');
i2c_lcd_number(run_counter);
i2c_stop();
</pre>

<pre>
/*

i2cmaster.h

defines functions for bit-banging the I2C protocol on generic I/O pins

Author: M. Post
Last modified: 28 January 2012

Add the following to your main.c in order to make use of this header file:

#define HIGH 1
#define LOW 0
#define INPUT 1
#define OUTPUT 0

// I2C pin definitions
#define SCL PB0 // Define Clock pin
#define SDA PB1 // Define Data pin
int got_ack;
int LCD_I2C_DEVICE_ID=58;
int I2C_STRETCH_TIMEOUT_MS=100;

<other includes>

#include "i2cmaster.h"

<defines, rest of code, etc..>

*/

void setPin(int line, int state)
{
// set the I2C SDA or SCL PIN

if (state == LOW)
{
// set the pin low

DDRB |= (1 << line); // set line to output
PORTB &= ~(1 << line); // set it to zero

} else {

// set the pin high (let external pull-up resistor bring it high)

DDRB &= ~(1 << line); // set line to input

}
}

void i2c_delay()
{
// default delay in between I2C commands
_delay_ms(10); // seems to hover around 2-3ms
}

void i2c_tx(char d)
{

int stretch_counter;
char x;

// SDA is LOW, SCL is HIGH (inherited from i2c-start command)

// bring clock low to start data transfer

setPin(SCL,LOW);

for(x=8; x; x--)
{
//_delay_us(10); // (additional time inbetween scl pulses)

// if statement: if (d & 0x80)
// 0x80 = 128d = 10000 0000b

if(d&0x80)
{
_delay_us(15);
setPin(SDA,HIGH);
} else {
setPin(SDA,LOW);
}

_delay_us(30); // (additional time before scl pulse)
setPin(SCL,HIGH); // strobe clock

// allow for I2C clock stretching (SCL can be held low by slave)
// see I2C_STRETCH_TIMEOUT_MS

for (stretch_counter=0; stretch_counter < I2C_STRETCH_TIMEOUT_MS; stretch_counter++)
{
// allow for some cycles for SCL to go high

if (bit_is_clear(PINB,SCL))
{
// SCL is held low by slave
// we'll just wait a little

_delay_ms(1);

} else {

// SCL has risen, ready to move on
stretch_counter = I2C_STRETCH_TIMEOUT_MS;
}

}

//_delay_us(10); // additional SCL-high time
setPin(SCL,LOW);

d <<= 1; // shift byte

}

// byte is now sent
// next is to read a possible ack from the slave device
// scl is already set low by the master

setPin(SDA,HIGH); // first bring SDA into listening mode

// read i2c slave acknowledge bit if any

// an addressed i2c slave will set SDA low very quickly

_delay_us(40); // space between the previous SCL pulse
setPin(SCL,HIGH); // start the clock pulse

//_delay_us(5); // this should be 5us or so

if (bit_is_set(PINB,SDA))
{
got_ack=0;
} else {
got_ack=1;
}

setPin(SDA,LOW); // we now bring SDA low (so we don't see a spike on SDA
// when the master brings SCL low again

_delay_us(25); // show a nice long SCL high pulse for easier debugging

setPin(SCL,LOW); // end the clock pulse
// this is also a signal for the i2c slave to release SDA

_delay_us(10); // give the bus some time

}

void i2c_start()
{

// SDA goes LOW while SCL is HIGH

// TODO: check the state of the lines first (they should both be HIGH)

_delay_us(10);
setPin(SDA,LOW); // start condition
_delay_us(10);

}

void i2c_repeatedstart()
{

// SDA goes LOW while SCL is HIGH

// first bring SCL and SDA LOW (SCL and SDA should already be low)

_delay_us(10);
setPin(SCL,LOW);
_delay_us(10);
setPin(SDA,LOW);

// then we bring them both HIGH

_delay_us(10);
setPin(SDA,HIGH);
_delay_us(10);
setPin(SCL,HIGH);
_delay_us(100);

// then we generate the repeated start condition

setPin(SDA,LOW);
_delay_us(100);
setPin(SCL,LOW);
_delay_us(100);

}

void i2c_startRead(char i2c_id)
{
// SDA goes from high to low while SCL is high

i2c_start();

// send the I2C Device ID

// send as Read (last bit is 1)

i2c_id = i2c_id << 1; // shift all bits one position to the left
i2c_id |= 1 << 0; // then set bit 0 to 1
i2c_tx(i2c_id);

}

void i2c_startWrite(char i2c_id)
{
// SDA goes from high to low while SCL is high

i2c_start();

// send the I2C Device ID

// send as Write (last bit is 0)

i2c_id = i2c_id << 1; // shift all bits one position to the left
i2c_id |= 0 << 0; // then set bit 0 to 0
i2c_tx(i2c_id);

}

void i2c_stop()
{
// SDA goes HIGH while SCL is HIGH

// TODO: check if both lines are low

_delay_us(10);
setPin(SCL,LOW);
_delay_us(10);
setPin(SDA,LOW);
_delay_us(10);

setPin(SCL,HIGH);
_delay_us(100); // at least 100 us for I2C_LCD module :-/
setPin(SDA,HIGH); // stop condition
_delay_us(10);

}

void i2c_lcd_text(char *StrData)
{

int p = 0;
int q = strlen(StrData);
int temp = 0;

for (p = 0; p < q; p++)
{
temp = StrData[p];
i2c_tx(temp);
}
}

void i2c_lcd_number(int number)
{
int digits;

if (number == 0)
{
digits = 0;
int array[0];
array[0]=0;
i2c_tx(array[0]+48);

} else {

// determine the number of digits
digits = (int) (log(number)/log(10))+1;

// split up the number's digits into an array
int i = digits -1;
int array[digits];
while (number > 0)
{
array[i--] = number % 10;
number /= 10;
}

// send array over i2c
for (i =0; i <= digits-1; i++)
{
i2c_tx(array[i]+48);
}

}
}

void i2c_lcd_hex(uint8_t x)
{

// sends one byte in hex (without 0x prefix) to the lcd

char nibble;

/* extract high nibble */
nibble = x & 0xf0; // (resets lower nibble to all zero's)
nibble = x >> 4; // (moves high nibble to lower nibble)

// output the high nibble
if(nibble < 10)
{
i2c_tx(48 + nibble);
} else {
i2c_tx(65 + nibble - 10);
}

/* do the same on the low nibble */
nibble = x & 0x0f;

if(nibble < 10)
{
i2c_tx(48 + nibble);
} else {
i2c_tx(65 + nibble - 10);
}

}

unsigned char i2c_rxbyte()
{

unsigned char rxbyte=0;
int bitcount=8;

setPin(SDA,HIGH); // release SDA so we can listen what the slave has to say

// the ic2_tx command lastly sent the ack pulse and now has SDA and SCL set to LOW
// we now control the read from the i2c slave device by pulsing SCL and reading SDA

while (bitcount > 0)
{

rxbyte = rxbyte << 1; // shift all bits in rxbyte one position to the left

setPin(SCL,HIGH); // start the clock pulse
_delay_us(I2C_SCL_T_HIGH_US); // give the bus some time to possibly bring the pin high

if (bit_is_set(PINB,SDA))
{
// -- detected bit '1' --

rxbyte |= 1 << 0 ; // sets bit 0 of rxbyte to 1

} else {

// -- detected bit '0' --

}

setPin(SCL,LOW); // stop the clock pulse
_delay_us(I2C_SCL_T_LOW_US); // give the bus some time to possibly bring the pin high

bitcount--; // decrement bitcounter

}

setPin(SCL,HIGH);

return rxbyte;
}

unsigned char i2c_read(uint8_t i2c_id, uint16_t DEV_REG)
{

// reading the memory address contents from an I2C Slave Device

unsigned char read_result=0;

// send start sequence as write (so we can specify which address we want to read)
i2c_startWrite(i2c_id); // sends i2c start condition + i2c address+0(w)

// send the address word we want to query on the device

// for the 24LC256 we need to do this in two goes. First the MSB then the LSB

i2c_tx(DEV_REG>>8); // shift 8 bits to the right to get the high byte
i2c_tx(DEV_REG & 0xff); // mask out the lower 8 bits to get the low byte

// -- send repeated start --

i2c_repeatedstart();

// send the I2C Device ID as Read (last bit is 1)

i2c_id = i2c_id << 1; // shift all bits one position to the left
i2c_id |= 1 << 0; // then set bit 0 to 1
i2c_tx(i2c_id);

// the slave will acknowledge and then transmit the 8-bit data word

// read data from device, one byte long
read_result=i2c_rxbyte();

i2c_stop();

return read_result;
}

</pre>

I2C - Revision history

Admin at 11:01, 16 March 2014