Suche E2PROM Manager für STM32F10x

[Christian J. (Gast)]

Hallo,

kann ja sein, dass den schon jemand hat. Basierend auf den StdperiphLibs 
für STM32F10x oder andere M3 oder M4, das passe ich mir schon an.

Funktion:

Optimiertes Managen eines I2C EEPROMs (64kb oder 128Kb) für beliebig 
lange Datensätze auf beliebige Addressen. Code soll erkennen wann 
schnelles Page Write möglich und wann Einzelbyte. Fehlerabfragen der 
Events sollten alle da sein. Ebenso Abfragen des ACK für optimierte 
Schreibzeit.

write_string(int* adress,int *data, *int len)
read_string(int* target, int* source, *int len)

Mehr braucht es nicht.

Klingt auf den ersten Biss ganz easy, ist es aber nicht ganz zudem ich 
noch vor habe auf diese Routinen eine Art Filesystem aufzusetzen, um 
auch gestückelte Datensätze zu handhaben und eine Art einfache FAT dabei 
mit Header, Verkettung der Blocks usw.

Falls jemand sowas hat bitte winken!

Gruss,
Christian

[Peter D. (peda)]

Anbei fürn AVR mit SW-I2C.

[Christian J. (Gast)]

Hallo,

bin kurz drüber, da AVR leider in keinster Weise kompatibel zum STM32 
ist und alle LL-Routinen daher nicht funktionieren. Die Hardwareroutinen 
habe ich aber schon geschrieben, es fehlt nur noch der "Manager".

Wo ist denn da die Intelligenz drin?

Hier ?

do{
    if( !set_addr( eeaddr ))
      return 0;                                         // 0 = failed
    do
      si2c_w( *sram++ );
    while( --len && (++eeaddr & (PAGE_SIZE-1)));        // end or next page
    si2c_stop();
  }while( len );

[Peter D. (peda)]

Christian J. schrieb:
> alle LL-Routinen daher nicht funktionieren

Die 4 Grundfunktionen (Start, Stop, Write, Read) sind doch schön 
gekapselt, sollten sich daher leicht auf jedes x-beliebiges HW-I2C 
anpassen lassen.

Christian J. schrieb:
> Hier ?

Ja.
Es wird automatisch in Pagewrites zerlegt.

[Christian J. (Gast)]

Ähm Peter.... hust

meine I2C Routinchen für die HW des Cortex sehen aber so aus, sind schon 
ein wenig "mehr". Die Primary Cell von ARM für I2c ist quasi der 
Porsche. Da wird ne Statemachine on-the-fly mit Daten gefüttert und der 
Transfer rattert dann automatisch durch während die CPU schon woanders 
ist. Durch die Events werden INts ausgelöst oder eben per Polling 
nachgeschaut was Sache ist. Aber die Lösuing ist ja sehr einfach und 
wird eingearbeitet.

// ---------------------------------------------------------------
// Initialisiere das E2Prom
// ---------------------------------------------------------------
void e2p_Init_I2C()
{
    GPIO_InitTypeDef GPIO_InitStruct;       // Port Init Struct
    I2C_InitTypeDef I2C_InitStruct;         // I2C Init Struct

    // Peripherie Takt einschalten I2C3: PA8 (I2C SCL) und PC9 (I2C3_SDA)
    RCC_APB1PeriphClockCmd(I2C_RCC, ENABLE);                    // Enable APB1 peripheral clock für I2C3
    RCC_AHB1PeriphClockCmd(I2C_PERIPH_SCL_PORT, ENABLE);       // Enable clock für PortA SCL pin
    RCC_AHB1PeriphClockCmd(I2C_PERIPH_SDA_PORT, ENABLE);       // Enable clock für PortC SDA pin

    I2C_Cmd(I2C_CHANNEL, DISABLE);                              // I2C abschalten, damit Bus still bleibt

    // Port mit SCL einrichten
    GPIO_InitStruct.GPIO_Pin   = I2C_SCL_PIN;                // Pin A8 (I2C3_SCL)
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF;              // Pins als Alternate Function einstellen
    GPIO_InitStruct.GPIO_Speed = GPIO_Fast_Speed;           // IO Speed, nicht Baudrate, 2 Mhz reicht
    GPIO_InitStruct.GPIO_OType = GPIO_OType_OD;             // Open Drain Output
    GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_NOPULL;
    GPIO_Init(I2C_SCL_PORT, &GPIO_InitStruct);

    // Port mit SDA einrichten
    GPIO_InitStruct.GPIO_Pin   = I2C_SDA_PIN;
    GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF;               // Pin C9 (SDA)
    GPIO_InitStruct.GPIO_Speed = GPIO_Fast_Speed;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_OD;
    GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_NOPULL;
    GPIO_Init(I2C_SDA_PORT, &GPIO_InitStruct);

    // Pins sind nun auf AF verbunden
    // USART3 kann nun Kontrolle über Pins übernehmen
    GPIO_PinAFConfig(I2C_SCL_PORT, I2C_SCL_SOURCE, I2C_GPIO_AF);
    GPIO_PinAFConfig(I2C_SDA_PORT, I2C_SDA_SOURCE, I2C_GPIO_AF);

    // Struktur Parameter fuer I2C setzen
    I2C_StructInit(&I2C_InitStruct);                                        // Rücksetzen auf Default
    I2C_InitStruct.I2C_ClockSpeed           = 100000;                       // 100 khz Busfrequenz
    I2C_InitStruct.I2C_Mode                 = I2C_Mode_I2C;                 // Normaler I2C Mode
    I2C_InitStruct.I2C_DutyCycle            = I2C_DutyCycle_2;              // 50:50 Duty Cycle
    I2C_InitStruct.I2C_OwnAddress1          = 0xEE;
    I2C_InitStruct.I2C_Ack                  = I2C_Ack_Enable;               // ACK senden
    I2C_InitStruct.I2C_AcknowledgedAddress  = I2C_AcknowledgedAddress_7bit; // 7 Bit Adressierung

    // I2C einschalten
    I2C_Cmd(I2C_CHANNEL, ENABLE);

    // I2C3 mit den obigen Parametern konfigurieren
    I2C_Init(I2C_CHANNEL, &I2C_InitStruct);
}

// ---------------------------------------------------------------
// Setzt alle Einstellungen zurück auf Default
// ---------------------------------------------------------------
void e2p_DeInit_I2C()
{
    // I2C Einheit zurücksetzen
    I2C_DeInit(I2C_CHANNEL);
    RCC_APB1PeriphClockCmd(I2C_RCC, DISABLE);    // Enable APB1 peripheral clock für I2C3
    I2C_initialized = false;
}

// ---------------------------------------------------------------
// Beschreibe das E2PROM einzelnen mit mehreren Bytes
// ---------------------------------------------------------------
uint8_t e2p_WriteMultiBytes(uint16_t addr, uint8_t *data, size_t nrBytes)
{
    if (!I2C_initialized) {
         e2p_Init_I2C(I2C_CHANNEL);
         I2C_initialized = true;
    }

    for (uint16_t i = 0; i< nrBytes; i++) {
        if (e2p_Write_Byte(addr++,*(data++)))
            return ERROR;
    }

    return SUCCESS;
}

// ---------------------------------------------------------------
// Beschreibe das E2PROM mit einem Byte
// ---------------------------------------------------------------
uint8_t e2p_Write_Byte(uint16_t Addr, const uint8_t Data)
{
    if (!I2C_initialized) {
        e2p_Init_I2C(I2C_CHANNEL);
        I2C_initialized = true;
    }

    // Transmission starten
    e2p_StartWriteAddress(Addr);

    // Sende Datum
    I2C_SendData(I2C_CHANNEL, Data);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS)
        return ERROR;

    // Sende I2C3 STOP Condition
    I2C_GenerateSTOP(I2C_CHANNEL, ENABLE);

    // Warte bis fertig geschrieben
    if (e2p_WaitForWriteReady() != SUCCESS)
       return ERROR;

    return SUCCESS;
}

// ---------------------------------------------------------------
// Ein Byte aus E2PROM lesen
// ---------------------------------------------------------------
uint8_t e2p_Read_Byte(const uint16_t Addr)
{
    if (!I2C_initialized) {
        e2p_Init_I2C(I2C_CHANNEL);
        I2C_initialized = true;
    }

    // ACK ein
    I2C_AcknowledgeConfig(I2C_CHANNEL, ENABLE);

    // Transmission starten
    if (e2p_StartWriteAddress(Addr) != SUCCESS)
            return ERROR;

    // AF Flag evtl löschen
    I2C_CHANNEL->SR1 |= (uint16_t)0x0400;

    /* -------- E2PROM Lesemodus (MASTER Receiver Mode)------ */

   // Erzeuge START Bedingung
    I2C_GenerateSTART(I2C_CHANNEL, ENABLE);
    if (I2C_WaitForEvent( I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS)
        return 0xff;

    // Adressiere das E2PROM
    I2C_Send7bitAddress(I2C_CHANNEL, MEM_DEVICE_READ_ADDR, I2C_Direction_Receiver);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS)
        return 0xff;

    /* Wichtiger Hinweis, bzgl der Reihenfolge des Bit Setzens, Manual. STM32F407, S834
        Die Konfiguration muss VOR dem Buszugriff erfolgen, d.h. das Datenbyte wird
        erst ganz zum Schluss ausgelesen */

    // NACK einstellen E2PROM anzuzeigen, dass keine weiteren Daten angefordert sind
    I2C_AcknowledgeConfig(I2C_CHANNEL, DISABLE);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS)
        return 0xff;

    // Stop Bedingung erzeugen NACH dem nächsten Lesezugriff
    I2C_GenerateSTOP(I2C_CHANNEL, ENABLE);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS)
        return 0xff;

    return I2C_ReceiveData(I2C_CHANNEL);
}

/* /////////////////////////////////////////////////////////
        Low Level Routinen für die Bedienung des E2PROMs
* /////////////////////////////////////////////////////// */


// Hilfsroutine zum Auslesen der Events mit Timeout
static uint8_t I2C_WaitForEvent(uint32_t event)
{
   timeout = I2C_TIMEOUT_MAX;
   while(I2C_CheckEvent(I2C_CHANNEL, event) != SUCCESS) {
        if ((timeout--) == 0) return ERROR;
    }
    return SUCCESS;
}

// ---------------------------------------------------------------
// Starte die E2PROM Sequenz: Startbit, E2prom Adresse, Zieladresse...
// ---------------------------------------------------------------
static uint8_t e2p_StartWriteAddress(uint16_t Addr)
{
    uint8_t lower_addr, upper_addr;

    lower_addr = (uint8_t)((0x00FF) & Addr);
    Addr = Addr>>8;
    upper_addr = (uint8_t)((0x00FF) & Addr);

    /* -------- E2PROM Adresszeiger auf Zieladresse setzen ------ */

    // Erzeuge START Bedingung
    I2C_GenerateSTART(I2C_CHANNEL, ENABLE);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS)
        return 0xff;

    // Adressiere das E2PROM
    I2C_Send7bitAddress(I2C_CHANNEL, MEM_DEVICE_WRITE_ADDR, I2C_Direction_Transmitter);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS)
        return 0xff;

    // Adresse als 2 x 8 Bit senden
    I2C_SendData(I2C_CHANNEL,upper_addr);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS)
        return 0xff;

    I2C_SendData(I2C_CHANNEL, lower_addr);
    if (I2C_WaitForEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS)
        return 0xff;

    return SUCCESS;
}

// ---------------------------------------------------------------
// Warte bis Schreibzyklus beendet ist (ACK Polling)
// ---------------------------------------------------------------
static uint8_t e2p_WaitForWriteReady() {

    // Warte bis Byte weggeschrieben wurde (Slave sendet solange kein ACK)
    uint32_t timeout = I2C_TIMEOUT_MAX;
    do{
        if (--timeout == 0)
            return ERROR;
        // Erzeuge Schreibzugriff......
        I2C_GenerateSTART(I2C_CHANNEL, ENABLE);
        while(!I2C_CheckEvent(I2C_CHANNEL, I2C_EVENT_MASTER_MODE_SELECT));
        I2C_Send7bitAddress(I2C_CHANNEL, MEM_DEVICE_WRITE_ADDR, I2C_Direction_Transmitter);
    } while(I2C_WaitForEvent(I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

    // Sequenz abschliessen
    I2C_GenerateSTOP(I2C_CHANNEL, ENABLE);

    return SUCCESS;
}

[Peter D. (peda)]

Das ganze Hardware-Geraffel ist natürlich nen ordentlichen Zacken mehr 
Holz.
Da ist ja mein Code nur ein Bruchteil groß.

Der Pagetest ist ganz einfach. Es wir solange die innere Schleife nicht 
verlassen, wie die nächsten lower Pagebits != 0 sind.

Ich teste auch nicht auf jeden Fehler. Wenn die 16Bit-Adresse ACK 
empfängt, gehe ich davon aus, daß auch das Bytes schreiben gut geht. Der 
EEPROM sitzt bei mir direkt am MC, da sind Störeinkopplungen 
unwarscheinlich.

Und das SW-I2C kann sich auch nicht intern aufhängen. Daher habe ich das 
HW-I2C absichtlich nicht benutzt.
Vorteil des SW-I2C: weniger Code, weniger Trouble.
Vorteil des HW-I2C: weniger CPU-Load, wenn es als Interrupt oder DMA 
läuft.

[Christian J. (Gast)]

Hi Peter,

ich danke Dir, damit ist meine Frage auch beantwortet. Und das ganze 
Geraffel ist kompiliert nur noch winzig klein, aber viel Schreibarbeit,
um kompatibel zu der API zu bleiben. Und es kann abstürzen, leider.
Bei AVR nutze ich schon lange einen SW-I2C-Master, besser als solche 
schlimmen Sachen wir das TWI zu benutzen.
Beim Cortex eher Spass an der Sache, wissen wie es geht, Spass am 
Denksport, da ich beruflich schon lange keine HW und SW mehr entwickle.

Danke Dir und Grüße,
Christian