AVR, Störung des EEPROMs!?

[torsten (Gast)]

Hallo.

Ich bin eigentlich C++-Programmierer und hab auch damit ein paar AVRs 
programmiert. Soweit so gut, bis jetzt hab ich das noch nciht bereut. 
Allerdings passiert gerade bei einem Programm folgendes:
Wenn bestimmte Teile im Programm drin sind -z.B. Instanzierungen von 
einer bestimmten Klasse- wird ein Teil der Daten aus dem EEPROM nicht 
richtig ausgelesen.
Wenn ich zwischen der Ausgabe des Inhalts des EEPROMs und der 
Instanzierung der "einen" Klasse eine Verzögerung von 100ms stecke, 
kommt der korrekte Inhalt des EEPROMs beim Rchner an. Er wurde in der 
Zwischenzeit nicht noch mal neubeschrieben.
Könnte die stark ausgedehnte Ressourcenbedarf des Programms (in Bezug 
auf C) dazu geführt haben, dass das Management der Ressourcen iwie 
leicht gestört ist? Für mich ist das alles etwas (mehr) 
zusammenhangslos, da mir nicht in den Kopf will, dass selbst im Falle 
von überfülltem Arbeisstpeicher nichts mit dem EEPROM passiert.
Was meint Ihr, habt Ihr damit Erfahrung oder eine Ahnung, was es damit 
auf sich hat?
Code wollte ich nciht posten, ich denk mal, es reicht, wenn das 
"Problem" grob beschrieben wird.
Und ja, dass C++ vielleicht nicht das geschickteste ist um µC zu 
programmieren ist mir schon bewusst, war aber zu faul, das in C zu 
machen, man hat einfach weniger Aufwand ;-)

freundliche Grüße, Torsten

[Daniel -. (root)]

torsten schrieb:
> Code wollte ich nciht posten, ich denk mal, es reicht, wenn das
> "Problem" grob beschrieben wird.

sorry, alles andere is sinnlos
du kannst ja soweit abstrahieren, dass dein Code nur das Problem
demonstriert.

> Und ja, dass C++ vielleicht nicht das geschickteste ist um µC zu
> programmieren ist mir schon bewusst, war aber zu faul, das in C zu
> machen, man hat einfach weniger Aufwand ;-)

auch in C++ kann man sehr schlank programmieren
ich sehe darin nicht die Ursache für dein Problem
C++ ohne Klassen ist beinahe C

[Daniel -. (root)]

torsten schrieb:
> Wenn ich zwischen der Ausgabe des Inhalts des EEPROMs und der
> Instanzierung der "einen" Klasse eine Verzögerung von 100ms stecke,
> kommt der korrekte Inhalt des EEPROMs beim Rchner an. Er wurde in der
> Zwischenzeit nicht noch mal neubeschrieben.

wie gesagt, es wäre wichtig zu wissen, was du im Konstruktor
veranstalltest. Eventuell sind da Zugriffe auf EEPROM Controlregister

[torsten (Gast)]

Also, bin mir jetzt nicht sicher, welchen Konstruktor du meinst, aber 
ich poste mal beide:

so ist das dann in der main():

//Ein Uart-Objekt um Inhalt des EEPROMs auszugeben
Uart_IO uart;

//Weichen-Objekte erzeugen (MAX_WEICHEN = 4)
//
Weiche* weiche[MAX_WEICHEN];

weiche[0] = new Weiche(PC5, PC4, PC3, C, 1);
weiche[1] = new Weiche(PC2, PC1, PC0, C, 2);
weiche[2] = new Weiche(PB5, PB4, PB3, B, 3);
weiche[3] = new Weiche(PB2, PB1, PB0, B, 4);
//
//Inhalt ausgeben (wenn die Verzögerung nicht mit drin ist, wird er falsch gesendet, obwohl er richtig im EEPROM erthalten ist)
uart.putch(weiche[0]->get_Nr());
uart.putch(weiche[1]->get_Nr());
uart.putch(weiche[2]->get_Nr());
uart.putch(weiche[3]->get_Nr());
//
uart.putch(weiche[0]->get_grund());
uart.putch(weiche[1]->get_grund());
uart.putch(weiche[2]->get_grund());
uart.putch(weiche[3]->get_grund());

//angesprochene Verzögerung
_delay_ms(100);
  
//Datenpaket (angesprochene Instanz)
// 
Data_packet* packet_in = new Data_packet();
Feldelement* pWeiche = packet_in->recieve();
delete(packet_in);

Konstruktor der Klasse 'Weiche'

Weiche(uint8_t W0, uint8_t W1, uint8_t Wr, IO_register W_r, uint8_t _lok_Nr) : Weiche_0(W0), Weiche_1(W1), Weiche_r(Wr), Weichen_register(W_r), lok_Nr(_lok_Nr)
{
  //Daten aus EEPROM einlesen 
  //
  //Grundstellung  
  //
  grund = (Stellrichtung)eeprom_read_byte(&eeSR_grund[lok_Nr-1]);
  
  //globale Nummer
  //
  glob_Nr = eeprom_read_byte(&eeNr[lok_Nr-1]);
    
}

Wenn der Konstruktor der Klasse 'Data_packet' auch noch benötigt werden 
soll, poste ich den natürlich auch noch..

Eine kurze Anmerkung zum Code: Es handelt sich um einen Weichendecoder, 
bzw. es soll einer werden. Es soll, wie eigentlich gut aus dem Code 
hervorgeht, insgesamt 4 Objekte der Klasse Weiche geben. Jedes Objekt 
liest dann anhand der lokalen Nummer, die es bekommt, die Stelle aus dem 
uint8_t-array im EEPROM aus, welche einmal die Nr der Weiche und die 
Grundstellung der Weiche speichern.
So, ich hoffe, Ihr könnt mir anhand des Materials weiterhelfen? :-)
dfreundliche Grüße, torsten

[Roland H. (batchman)]

torsten schrieb:
> wird ein Teil der Daten aus dem EEPROM nicht
> richtig ausgelesen.

Was heisst das: Falsche Werte oder gar nichts?

Wie sieht uart.putch() aus?

Welcher AVR?

torsten schrieb:
> Wenn der Konstruktor der Klasse 'Data_packet' auch noch benötigt werden
> soll, poste ich den natürlich auch noch..

Ja, wäre nicht schlecht.

[torsten (Gast)]

uart.putch() sieht so aus:

void putch (const unsigned char c)
{
  //Warten bis UART bereit ist für Senden
  while (!(UCSRA & (1<<UDRE)));  
     
   //Zeichen senden
  UDR = c;  
}

Der Konstruktor (verwendete) Konstruktor von Data_packet ist nicht so 
sonderlich spektakulär:

//Konstruktor für eingehende Pakete
Data_packet()
{
  uart = new Uart_IO;
}

Falls erforlderlich kann ich noch den Code von Data_packet::revieve() 
nachliefern..

Der Fehler liegt wirklich beim Senden, den aus dem empfangenen geht 
hervor, dass der Controller die richtigen Daten verwendet.
Also, könnt Ihr mir helfen?
freundliche GRüße, torsten

[Roland H. (batchman)]

torsten schrieb:
> nicht so
> sonderlich spektakulär:

Für mich schon. Denn der Inhalt hat mit der Klasse nichts zu tun. Aber 
es wird munter weiter Speicher auf dem Heap belegt. Auf dem weiterhin 
unbekannten AVR mit deshalb unbekannter Größe des RAMs. Vielleicht stört 
das erneute Initialisieren des UARTs die Ausgabe.

torsten schrieb:
> Der Fehler liegt wirklich beim Senden

Das wage ich zu bezweifeln.

Ich tippe darauf, dass Dir der Heap in den Stack wächst. Alternativ: Im 
unbekannten Construktor für Uart_IO wird der UART erneut initialisiert, 
vielleicht mit Interrupts.

Wirf alle "new"-Aufrufe raus. Das ist in diesem Fall angebracht, da ich 
hier nichts dynamisches erkennen kann (dynamisch im Sinne von: Zur 
Compile-Zeit nicht bekannt).

Aus Deinen Schnippseln wird man nicht schlau; Bitte komplettes Programm 
mit Makefile. Auch die ISRs.