mikrocontroller.net

Forum: PC-Programmierung EEPROM schreiben/lesen/prüfen --> wie geht's schneller?


Autor: Steffen A. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Einen guten Morgen wünsche ich!

Ich möchte ein kleines C++ Programm im Hinblick auf 
Auslesegeschwindigkeit eines EEPROM optimieren.

Zum Stand der Dinge: Ich habe ein EEPROM, welches ich mit einer Datei 
beschreiben und anschließend den Schreibvorgang verifizieren möchte. Ein 
kleines Programm, was mir diese Wünsche erfüllt, habe ich bereits inkl. 
Sourcecode. Dieses setzt auf einer API für den verwendeten 
Programmieradapter auf, benötigt für den Schreib- und 
Lese-/Prüfungsvorgang jeweils etwa 5 Sekunden.

Vom Hersteller des Adapters existiert eine Software, mit der ich 
vergleichbare write-Zeiten erziele, was aber beim Lesen/Verifizieren 
SEHR viel schneller ist  (etwa 1 Sekunde). Da das Programm nur aus ner 
.exe und einigen .dll's besteht, habe ich darin leider keinen Einblick, 
gehe aber davon aus, dass dieses natürlich auch die selbe API benutzt. 
Somit ist mein Ansatzpunkt für Optimierung der oben erwähnte 
Sourcecode..

Kurzum: Das Auslesen des EEPROM dauert 4 Sekunden länger und möchte ich 
so gut es geht beschleunigen. Hat jemand von euch generelle Tipps, was 
in dem Aufbau der Flaschenhals sein kann? Worauf sollte ich achten, was 
prüfen? Wenn jemand sich die Mühe machen möchte, kann ich auch den 
relevanten Code zeigen, allerdings möchte ich vorab eher eine Art 
Brainstorming. :)


Das Equipment / der Aufbau ist stets der selbe, es muss also, wie 
gesagt, das eigene Prog (speziell die Read-Funktionalität) sein.

Prog-Adapter + API Doku:
http://www.totalphase.com/download/pdf/aardvark-v4.00.pdf

EEPROM:
http://www.st.com/stonline/products/literature/ds/6757.pdf


Besten Danke und viele Grüße
Steffen

Autor: Joerg Wolfram (joergwolfram)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe die zwei Dokumente kurz überflogen und habe drei Fragen dazu:

1. Welcher von den EEPROMs ist es denn?

2. Welche I2C Frequenz nutzt Du (100 oder 400KHz)

Beim Schreiben macht das nicht viel aus, da der Schreibvorgang von der 
Zeit her dominierend ist.

3. Liest Du jedes Byte einzeln oder fortlaufend?


Gruß Jörg

Autor: Steffen A. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi Jörg,

zu 1.: Sorry, dass ich das vergessen habe zu erwähnen: der M24256 ist´s

zu 2.: 400kHz mit beiden Programmen, wobei das auch bei beiden 
Programmen runter gesetzt werden kann.

zu 3.: da bin ich gerade dran, ich meld mich, wenn ich die Antwort habe 
:) Ziel sollte ja sein: Möglichst viel auf einmal, nicht wahr?

Gruß
Steffen

Autor: Steffen A. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nachtrag: Ich habe gerade deine Aussage überprüft.

Bei dem Tool des Adapterherstellers nimmt die Änderung auf 100kHz 
tatsächlich nur spürbaren Einfluss auf den Lesevorgang, nicht aber auf 
den Schreibvorgang. Wie kommt das? Ein paar erklärende Worte dazu wären 
super. :)

Mit dem verbesserungswürden Tool allerdings ist beim lesen und schreiben 
eine Verlangsamung spürbar. Vielleicht hilft das?!

Gruß
Steffen

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Steffen A. wrote:

> Bei dem Tool des Adapterherstellers nimmt die Änderung auf 100kHz
> tatsächlich nur spürbaren Einfluss auf den Lesevorgang, nicht aber auf
> den Schreibvorgang. Wie kommt das? Ein paar erklärende Worte dazu wären
> super. :)

Weil beim Schreiben die Kommunikation den kleineren Teil der Zeit in 
Anspruch nimmt. Der Löwenanteil entfällt auf das tatsächliche Schreiben 
der Daten innerhalb des EEPROMs. Und diese Zeit ist unabhängig von der 
Kommunikationsgeschwindigkeit.

Autor: Steffen A. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Stefan: Verstehe, danke. :)

Ich habe den Read-Ablauf zusammen gestellt. Wenn euch nochwas fehlen 
sollte, bitte bescheit geben.

Über einen Konsolenbefehl teilt man dem Programm mit, dass man lesen 
möchte (case OP_READ), dann bekommt man die gewünschten 
Speicherabschnitte nach und nach auf dem Bildschirm geworfen (je 16bit).

case OP_READ:
  {
    unsigned int i, count, rlen;
    unsigned char data[16];

    printf("Reading EEPROM,    start address 0x%04x... ", startaddr);
    
    if (outfile)
      printf("%8d Bytes", 0);
    else
      printf("\n");

    count = 0;
    while (count < length) {
      rlen = MIN(16, length - count);
      i2c_eep_rd(startaddr + count, data, rlen, addrsize);

      if (outfile) {
        printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b%8d Bytes", count + rlen);
        for (i = 0; i < rlen; i++)
          fputc(data[i], outfile);
      } else {
        printf("0x%04X: ", startaddr + count);
        for (i = 0; i < rlen; i++)
          printf("%02x ", data[i]);
        printf("\n");
      }

      count += rlen;
    }
    break;
  }


Hier gehts weiter:
// ------------------------------------------------------------
// i2c_eep_rd
// ------------------------------------------------------------
void i2c_eep_rd(unsigned int addr, unsigned char *data, unsigned int length, unsigned int addrsize)
{
  unsigned char buf[4];
  unsigned int i;
  unsigned int dev;
  unsigned int rlen;

  while (length) {
    // Determine I2C device address
    dev = 0x50 + ((addr >> (8*addrsize)) & 0x7);

    // Write address to EEPROM
    for (i = 0; i < addrsize; i++)
      buf[i] = (addr >> (8*(addrsize-i-1))) & 0xFF;
    globs.i2c_wr(dev, buf, addrsize);
    
    // Determine read length (stay within current device)
    rlen = MIN(length, (1 << (8*addrsize)) - addr % (1 << (8*addrsize))); 
    
    // Read
    globs.i2c_rd(dev, data, rlen);
    
    // Update variables
    data += rlen;
    length -= rlen;
    addr += rlen;
  }
}


Der Read Aufruf wird hier umgemünzt:
globs.i2c_rd = aa_i2c_rd;


Und mündet dann in der Readfunktion des API (siehe 
http://www.totalphase.com/download/pdf/aardvark-v4.00.pdf, Seite 37)
// ------------------------------------------------------------
// aa_i2c_rd
// ------------------------------------------------------------
void aa_i2c_rd(unsigned int devaddr, unsigned char *data, unsigned int length)
{
  // Read with acknowledge polling
  while (!aa_i2c_read(globs.aahandle, devaddr, AA_I2C_NO_FLAGS, length, data));
}

@Jörg: Vielleicht hast du´s ja schneller durchschaut, wieviel Byte pro 
Aufruf gelesen werden, ich komm jetzt erst wieder zum schauen.

Autor: Steffen A. (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hmm.. Warum kann man seine Beiträge nicht editieren?! :(

Es sollte oben "jeweils 16 BYTE" heißen, nicht bit.. Ich habe mal einen 
Ausschnitt der Ausgabe angehängt.

Autor: Timmo H. (masterfx)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
>Hmm.. Warum kann man seine Beiträge nicht editieren?! :(
Kann man (siehe Bild). Geht jedoch nur, wenn du dich registrierst und 
nicht als GAST drin bist.

Autor: Steffen A. (stigmer)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Guten morgen,

Spam oder nicht: Ich wollte kurz Erfolg verkünden, habe das Problem 
gestern erschlagen können.

thx anyway,
Steffen

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.