Probleme beim Speichern und Lesen vom AT24C512 über TWI

/*

 * ----------------------------------------------------------------------------

 * "THE BEER-WARE LICENSE" (Revision 42):

 * <joerg@FreeBSD.ORG> wrote this file.  As long as you retain this notice you

 * can do whatever you want with this stuff. If we meet some day, and you think

 * this stuff is worth it, you can buy me a beer in return.        Joerg Wunsch

 * ----------------------------------------------------------------------------

 */

#include <inttypes.h>

#include <stdio.h>

#include <stdlib.h>

#include <util/delay.h>

#include <avr/io.h>

#include <util/twi.h>    /* Note [1] */

#define DEBUG 1

/*

 * System clock in Hz.

 */

#define F_CPU 8000000UL  /* Note [2] */

/*

 * Compatibility defines.  This should work on ATmega8, ATmega16,

 * ATmega163, ATmega323 and ATmega128 (IOW: on all devices that

 * provide a builtin TWI interface).

 *

 * On the 128, it defaults to USART 1.

 */

#ifndef UCSRB

# ifdef UCSR1A    /* ATmega128 */

#  define UCSRA UCSR1A

#  define UCSRB UCSR1B

#  define UBRR UBRR1L

#  define UDR UDR1

# else /* ATmega8 */

#  define UCSRA USR

#  define UCSRB UCR

# endif

#endif

#ifndef UBRR

#  define UBRR UBRRL

#endif

/*

 * Note [3]

 * TWI address for 24Cxx EEPROM:

 *

 * 1 0 1 0 E2 E1 E0 R/~W  24C01/24C02

 * 1 0 1 0 E2 E1 A8 R/~W  24C04

 * 1 0 1 0 E2 A9 A8 R/~W  24C08

 * 1 0 1 0 A10 A9 A8 R/~W  24C16

 */

#define TWI_SLA_24CXX  0xA2  /* E2 E1 E0 = 0 0 0 */

/*

 * Maximal number of iterations to wait for a device to respond for a

 * selection.  Should be large enough to allow for a pending write to

 * complete, but low enough to properly abort an infinite loop in case

 * a slave is broken or not present at all.  With 100 kHz TWI clock,

 * transfering the start condition and SLA+R/W packet takes about 10

 * µs.  The longest write period is supposed to not exceed ~ 10 ms.

 * Thus, normal operation should not require more than 100 iterations

 * to get the device to respond to a selection.

 */

#define MAX_ITER  200

/*

 * Number of bytes that can be written in a row, see comments for

 * ee24xx_write_page() below.  Some vendor's devices would accept 16,

 * but 8 seems to be the lowest common denominator.

 *

 * Note that the page size must be a power of two, this simplifies the

 * page boundary calculations below.

 */

#define PAGE_SIZE 8

/*

 * Saved TWI status register, for error messages only.  We need to

 * save it in a variable, since the datasheet only guarantees the TWSR

 * register to have valid contents while the TWINT bit in TWCR is set.

 */

uint8_t twst;

/*

 * Do all the startup-time peripheral initializations: UART (for our

 * debug/test output), and TWI clock.

 */

void ioinit(void)

{

  #if F_CPU <= 1000000UL

    /*

   * Note [4]

   * Slow system clock, double Baud rate to improve rate error.

   */

    UCSRA = _BV(U2X);

    UBRR = (F_CPU / (8 * 9600UL)) - 1; /* 9600 Bd */

  #else

    UBRR = (F_CPU / (16 * 9600UL)) - 1; /* 9600 Bd */

  #endif

    UCSRB = _BV(TXEN);    /* tx enable */

    /* initialize TWI clock: 100 kHz clock, TWPS = 0 => prescaler = 1 */

  TWBR = 0x20;

  TWSR = 0x00;

}

/*

 * Note [6]

 * Send character c down the UART Tx, wait until tx holding register

 * is empty.

 */

int uart_putchar(char c, FILE *unused)

{

  if (c == '\n')

    uart_putchar('\r', 0);

  loop_until_bit_is_set(UCSRA, UDRE);

  UDR = c;

  return 0;

}

unsigned char I2C_start(void)

{

  /*writing a one to TWINT clears it, TWSTA=Start, TWEN=TWI-enable*/

  TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);

  /*wait, until start condition has been sent --> ACK*/

  while (!(TWCR & _BV(TWINT)));

//  printf("TWSR Start %#04x\n ", TWSR);

  return TWSR;

}

void I2C_stop(void)

{

  /*writing a one to TWINT clears it, TWSTO=Stop, TWEN=TWI-enable*/

  TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN);

//  printf("TWSR Stop %#04x\n ", TWSR);  

}

unsigned char eeprom_send_add_w (unsigned char address, unsigned char rw)

{

  unsigned char addr_byte = 0;

  addr_byte |= rw;

  addr_byte |= address;

  TWDR = addr_byte;

  TWCR = _BV(TWINT) | _BV(TWEN);

  /*wait, until address has been sent --> ACK*/

  while (TWSR !=0x18);

//  printf("TWSR Adresse %#04x\n ", TWSR);

  return TWSR;

}

unsigned char ext_eeprom_send_byte (unsigned char byte)

{

  /*TWDR contains byte to send*/

  TWDR = byte;

  /*send content of TWDR*/

  TWCR = _BV(TWINT) | _BV(TWEN);

  /*wait, until byte has been sent --> ACK*/

  while (!(TWCR & _BV(TWINT)));

//  printf("TWSR senden %#04x\n ", TWSR);

  return TWSR;

}

unsigned char ext_eeprom_read_byte(void)

{

  /*send content of TWDR; TWEA = enable ACK*/

  TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN);

  /*wait, until byte has been received --> ACK*/

  while (!(TWCR & _BV(TWINT)));

//  printf("TWSR lesen %#04x\n ", TWSR);

  return TWSR;

}

unsigned char eeprom_send_add_r (unsigned char address, unsigned char rw)

{

  unsigned char addr_byte = 0;

  addr_byte |= rw;

  addr_byte |= address;

  TWDR = addr_byte;

//  printf("TWDR Adresse %#04x\n ", TWDR);

  /*send content of TWDR*/

  TWCR = _BV(TWINT) | _BV(TWEN);

//  printf("TWCR Adresse %#04x\n ", TWCR);

//  printf("TWSR Adresse %#04x\n ", TWSR);

  /*wait, until address has been sent --> ACK*/

  while (TWSR !=0x40);

//  printf("TWSR Adresse %#04x\n ", TWSR);

  return TWSR;

}

void write_eeprom(unsigned char adresse, unsigned char speicher_pos_x, unsigned char speicher_pos_y,

                  unsigned char daten)

{

  I2C_start();    // Startbedingung

  eeprom_send_add_w (adresse,0);

  ext_eeprom_send_byte(speicher_pos_x);

  ext_eeprom_send_byte(speicher_pos_y);

  ext_eeprom_send_byte(daten);

  I2C_stop();

  printf("schreibe: %#04x\n", daten);

  putchar('\n');

}

unsigned char read_eeprom(unsigned char adresse, unsigned char speicher_pos_x, unsigned char speicher_pos_y)

{

  unsigned char daten;  // Hilfvariable die die Daten später zurückgibt

  I2C_start();    // Startbedingung

  eeprom_send_add_w (adresse,0);

  ext_eeprom_send_byte(speicher_pos_x);

  ext_eeprom_send_byte(speicher_pos_y);

  I2C_start();

  eeprom_send_add_r (adresse,1);

  ext_eeprom_read_byte();

  I2C_stop();

  daten = TWDR;

  return daten;

}

FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

int main(void)

{

  unsigned char rv;

  unsigned char x;

  unsigned char a;

  unsigned char b;

  ioinit();

  stdout = &mystdout;

  printf("Los geht es mit schreiben.\n");

for (a = 0; a < 2;)

  {

  for (x = 0; x < 16;)

    {

      write_eeprom(TWI_SLA_24CXX, a, x, 0xFF);

      printf("Postion %d schreiben: %d\n", x,x);

    x++;

    _delay_ms(20);

  }

a++;

}

  printf("Weiter geht es mit lesen.\n");

  for (a = 0; a < 2;)

  {

  for (b = 0; b < 16;)

    {

      rv = read_eeprom(TWI_SLA_24CXX, a, b);  

      printf("Postion %d , %d lesen: %#04x\n   ", a,b,rv);

      TWCR=0x00;

    b++;

  }

  a++;

  }

  printf("done.\n");

  return 0;

}

unsigned char I2C_start(void)

{

  /*writing a one to TWINT clears it, TWSTA=Start, TWEN=TWI-enable*/

  TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);

  /*wait, until start condition has been sent --> ACK*/

  while (!(TWCR & _BV(TWINT)));

//  printf("TWSR Start %#04x\n ", TWSR);

  return TWSR;

}

while (!(TWCR & _BV(TWINT)));