AVR Freaks

Well,  it is more sensible without pullups.

But from an Ebay module point of view most punters will only have one or two slaves.  e.g. 4k7 or 2k35.

From an Arduino point of view,  they enable AVR internal 30k pullups.    Completely outside I2C spec but it will probably make a punter's I2C slave give some response.

Your "hub" boards would be more convenient if they had 8 Grove and one male header.

David.

Here are a couple app notes that may be useful.

Hi Mike,

The ATmega 512 kbit EEPROM I have on that board i put the picture of up, has physical 128 byte blocks you cannot write across if you are just doing a write, write, write, write by giving it the address of the first byte, and then just write one after the other while the EEPROM increments the byte address.  When you try to step over the physical 128 byte block / page boundary in the EEPROM, it goes back to the beginning of the block you were in and starts all over.  I have seen this too.  if I start my write somewhere inside the 128 byte block and finish before the end of the block, it all works fine.  Look at your EEPROM data sheet carefully

If you want to write as fast as possible you can do the consecutive writes until you get to the last byte of the block.  Then you have to do the business with putting in the EEPROM device address+I2C_WRITE to prepare the write condition, and then give the address of the first byte of the next block and put the next data write into the first byte of the new block, and then write, write, write for up to 128 bytes.  You just have to keep track of where the physical boundaries are in the EEPROM, and step over them carefully in code.  

I dont need my writes to be blazing fast of I just to it the slow way.  I use Peter Fleury's C library for the I2C calls before he rewrote it in assembler

//Mark's
void ee24xx_write_byte(uint16_t address, char data)
{
    char addrs;
    i2c_start_wait(EE24C512addr + I2C_WRITE);        // set device address and write mode
    addrs = address >> 8;
    i2c_write(addrs);                                // write address high
    addrs = address;
    i2c_write(addrs);                                // write address low
    i2c_write(data);                                 // write value to EEPROM
    i2c_stop();                                        // set stop conditon = release bus
}

To read from the EEPROM none of the physical boundary business needs thinking about.  You give it the EEPROM device address with a I2C_READ, send across the address of the first byte you want to read, and then just read, read, read, read as many as you like.  The read is just from the next byte address.  You need a readNAK() after the last read before the i2c_stop() to terminate properly.  Those reads go blinding fast, compared to the writes.

I'm running my I2C with SCL_CLOCK = 400000L, and F_CPU = 16000000L with this to initialize.  Is your F_CPU fast enough?

/*************************************************************************
 Initialization of the I2C bus interface. Need to be called only once
*************************************************************************/
void i2c_init(void)
{
  /* initialize TWI clock: 400 kHz clock, TWPS = 0 => prescaler = 1 */
  
  TWSR = 0;                         /* no prescaler */
  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;  /* must be > 10 for stable operation */

}/* i2c_init */

I agree 100%.

Fleury's example shows the barebones steps clearly.   But does not use the return values.

Nor does it emphasize the purpose (and risk) of the i2c_start_wait() function.

i2c_start_wait() polls the EEPROM until it ACKs.  

If the EEPROM is busy during its page-write the function polls until the page-write has completed.

If you have the wrong Slave address you will hang forever !!

Personally,  I would prefer to use i2c_start() result to check for the Slave existence.

And would be happier with i2c_poll_24Cxxx() as a more intuitive name than i2c_start_wait() because I am not aware of any other I2C devices with this behaviour.

I still maintain that :

void functions are the work of the Devil.