I2C Wert nach EEPROM 24C512 schreiben

[ePyx]

Also laut den Datasheets von Microchip wird zunächst das Controllbyte ( Adresse + I2C_Write/I2C_Read) , dann das High-Byte der Adresse (Bit 15- gefolgt von Low-Byte der Adresse (Bit 7-0) gesendet. Würde schon davon ausgehen, dass der Speicher des EEPROMs bei 0x0000 beginnt und nicht bei 0x0001. Aufpassen musst du eigentlich nur bei einem Random-Read oder wenn du eine ganze Page adressieren willst.

Das Ganze ist aber momentan ohne Gewähr, da ich erst morgen Zeit habe um das mal selbst zu testen.

[Bot-Builder]

Ich habe den Code umgeschrieben, ist jetzt funktionsfähig. Ich post ihn mal hier, vielleicht kann er ja für andere hilfreich sein.

/*-------+---------+---------+---------+---------+---------+---------+---------+
*   #include-Dateien
*--------+---------+---------+---------+---------+---------+---------+---------+*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <util/delay.h>    

#include "lcd.h"
#include "i2cmaster.h"

/*-------+---------+---------+---------+---------+---------+---------+---------+
    Prototypen():
---------+---------+---------+---------+---------+---------+---------+---------+*/
void Fehler(uint8_t Schritt);

/*-------+---------+---------+---------+---------+---------+---------+---------+
    Funktionen():
---------+---------+---------+---------+---------+---------+---------+---------+*/
//-------+---------+---------+---------+---------+---------+---------+---------+
//    void Fehler(uint8_t Schritt):
/**    @brief    gibt eine Fehlermeldung aus */
/**    @param    (Programm-)Schritt in der der Fehler aufgetreten ist */ 
/**    @return    keinen Rückgabewert */
//-------+---------+---------+---------+---------+---------+---------+---------+
void Fehler(uint8_t Schritt)
{
    switch(Schritt)
    {
        case 1:
            lcd_gotoxy(0,2); lcd_puts("ERR: 1. Start"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 2:
            lcd_gotoxy(0,2); lcd_puts("ERR: 1. Ad. HByte"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 3:
            lcd_gotoxy(0,2); lcd_puts("ERR: 1. Ad. LByte"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 4:
            lcd_gotoxy(0,2); lcd_puts("ERR: READ-Modus"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 5:
            lcd_gotoxy(0,2); lcd_puts("ERR: 2. Start"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 6:
            lcd_gotoxy(0,2); lcd_puts("ERR: 2. Ad. HByte"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 7:
            lcd_gotoxy(0,2); lcd_puts("ERR: 2. Ad. LByte"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        case 8:
            lcd_gotoxy(0,2); lcd_puts("ERR: Schreiben"); lcd_command(LCD_CLEAR_RESTLINE);
            break;

        default:
            lcd_gotoxy(0,2); lcd_puts("unbekannter Fehler."); lcd_command(LCD_CLEAR_RESTLINE);
    }
    
    i2c_stop();
    while(1);
}


//-------+---------+---------+---------+---------+---------+---------+---------+
//    main(void)
/**    @brief    LCD initialisieren. \n
            I2C Kommunikation initialisieren. \n
            Wert aus Speicherstelle 0x05 auslesen, \n
            um Eins erhöhen, \n
            und an die gleich Stelle zurückschreiben. 
            Beide Werte dann auf dem LCD darstellen. \n*/
/**    @param    keine Übergabeparameter */ 
/**    @return    0 */
//-------+---------+---------+---------+---------+---------+---------+---------+
int main(void)
{
    /**    @brief    Adresse der zu lesenden bzw. beschreibenden Speicherstelle */
    uint16_t    Adresse;
    uint8_t        HByte;
    uint8_t        LByte;

    //    Adresse willkürlich gewählt; nur zum Testen
    Adresse = 0x4321;
    LByte = Adresse;
    HByte = (Adresse >> 8);
    
    /**    @brief    Returnwert aus den Funktionen zur Fehlerkontrolle */
    uint8_t        ret;

    /**    @brief    aus dem Speicher ausgelesen bzw. zurück geschriebene
                Werte. */
    uint8_t        WertAlt;
    uint8_t        WertNeu;

    /**    @brief    Zwischenspeicher für Ausgabe */
    char        Ausgabe[13];

    //    LCD initialisieren
    lcd_init(LCD_DISP_ON); lcd_command(LCD_BACKLIGHT_ON);

    // initialize I2C library
    i2c_init();

    // read value from EEPROM
    i2c_start_wait(Dev24C512+I2C_WRITE);        // set device address and write mode
    /*    oder auch
    ret= i2c_start(Dev24C512+I2C_WRITE);        // set device address and write mode
    if ( ret ) Fehler(2);
    */

    ret = i2c_write(HByte);                        // write address hbyte
    if ( ret ) Fehler(2);

    ret = i2c_write(LByte);                        // write address lbyte
    if ( ret ) Fehler(3);

    ret = i2c_rep_start(Dev24C512+I2C_READ);    // set device address and read mode
    if ( ret ) Fehler(4);

    WertAlt = i2c_readNak();                    // read one byte from EEPROM

    i2c_stop();

    WertNeu = WertAlt + 1;

    // write value to EEPROM (Byte Write) 
    i2c_start_wait(Dev24C512+I2C_WRITE);        // set device address and write mode
    /*    oder auch
    ret= i2c_start(Dev24C512+I2C_WRITE);        // set device address and write mode
    if ( ret ) Fehler(5);
    */

    ret = i2c_write(HByte);                        // write address hbyte
    if ( ret ) Fehler(6);

    ret = i2c_write(LByte);                        // write address lbyte
    if ( ret ) Fehler(7);

    ret = i2c_write(WertNeu);                    // write value
    if ( ret ) Fehler(8);

    i2c_stop();                                    // set stop conditon = release bus

    //    Ausgabe der Werte auf dem LCD
    lcd_gotoxy(0,1); lcd_puts("Adresse: ");
    utoa(HByte, Ausgabe, 16); lcd_puts("0x"); lcd_puts(Ausgabe);
    utoa(LByte, Ausgabe, 16); lcd_puts(" "); lcd_puts(Ausgabe); lcd_command(LCD_CLEAR_RESTLINE);
    lcd_gotoxy(0,2); lcd_puts("Alt: "); utoa(WertAlt, Ausgabe, 10); lcd_puts(Ausgabe); lcd_command(LCD_CLEAR_RESTLINE);
    lcd_gotoxy(0,3); lcd_puts("Neu: "); utoa(WertNeu, Ausgabe, 10); lcd_puts(Ausgabe);lcd_command(LCD_CLEAR_RESTLINE);

    while(1);
    
return 0;
}

Die erste Speicherstelle hat die Adresse 0x0000, Adressierung hat die Form Hbyte, LByte.

Dann kann ich den Thread jetzt als "Erledigt" kennzeichnen.

Nochmals Vielen Dank.

Uwe

[ePyx]

Schön das es klappt. Dann viel Spaß beim weiterfrickeln.