Problem: zwei Variablen auf selber Adresse(?)

[Stefan A. (aige)]

Hallo,

ich hab mal wieder mit C meine lieben Probleme...(bezutze AVR Studio)

mein Programm funktioniert nicht richtig, schon in der Simulation nicht, 
Variablen ändern schlagartig ihren Wert obwohl weit und breit nichts 
darauf zugreift. Es ist sicher ein Problem mit static, volatile & 
Co...ich hab die Sachen wohl nicht verstanden...

Ich hab schon einiges probiert, ich weis schon gar nicht mehr wie der 
Urzustand war, aber ich fang jetzt einfach mal an:

Auf jedenfall ist mir aufgefallen das in meinem Programm die Variablen 
buffer[] und timer_adc die selbe Adresse haben was wohl nicht gut ist...

hier ein Ausschnitt vom Program:

#include <string.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include "diskio.h"
#include "uart.h"

BYTE read_data(BYTE* buffer, DWORD address);
BYTE write_data(BYTE* buffer, DWORD address);

static BYTE   ReadChannelADC0();
static BYTE   BCDto7seg(BYTE bcd);
static WORD   BINtoBCD(BYTE bin);
static DWORD   BINtoASCII(BYTE bin);
static void   ausgabe(WORD);
static void   schiebe(BYTE bin);  
static void   port_init();


volatile   BYTE  timer_refresh;
volatile   BYTE  timer_adc;
    

int main(void)
{
  timer_refresh = 0;
  timer_adc = 0;

  BYTE  result = 0;

  BYTE   buffer[512];
  WORD   adcbuffer = 0;
  WORD  bytecnt = 0;
  DWORD  address = 0x00060A00;
  DWORD  blockcnt = 0;
  DWORD  cache = 0;


  uart_init();
  
  result = disk_initialize();
  if(result == 0) uart_puts("Initialisierung erfolgreich...");
  else uart_puts("errer bei Initialisierung...");


  port_init();
  sei();
    

  while(1)
  {  
    if(timer_refresh >= 4)        // MUX/Anzeige Refresh?
    {  
      timer_refresh = 0;
      ausgabe(adcbuffer);        // gibt buffer auf 7 segmentantzeigen
    }

    if(timer_adc >= 50)          // 100ms
    {  
      BYTE temp = 0;
      timer_adc = 0;
      temp = ReadChannelADC0();    
      adcbuffer = BINtoBCD(temp);

//      uart_putint(temp);  
    

      if(blockcnt <= 2)
      {
        cache = BINtoASCII(temp);
        
//        uart_putint(cache);
        buffer[bytecnt] = 0x3D;
        bytecnt++;
        buffer[bytecnt] = 0x3D;
        bytecnt++;
        buffer[bytecnt] = (cache >> 24) & 0xFF;
        bytecnt++;
        buffer[bytecnt] = (cache >> 16) & 0xFF;
        bytecnt++;
        buffer[bytecnt] = (cache >>  8) & 0xFF;
        bytecnt++;
        buffer[bytecnt] = (cache >>  0) & 0xFF;
        bytecnt++;
        buffer[bytecnt] = 0x0D;
        bytecnt++;
        buffer[bytecnt] = 0x0A;
        bytecnt++;


        if(bytecnt >= 512)
        {
          bytecnt = 0;
  //      uart_putint(address);
          if(write_data(buffer, address) == 0) uart_puts("Schreiben erfolgreich...");
          else uart_puts("Error beim Schreiben...");

          for(int i = 0; i < 512; i++) buffer[i] = 0;

          address += 512;
          blockcnt++;
        }
      }
    }
  }
}

ISR(TIMER2_COMP_vect)      // wird alle 2ms aufgerufen (Takt/64;8MHz)
{
  timer_refresh++;
  timer_adc++;
};

[g457 (Gast)]

> Variablen ändern schlagartig ihren Wert obwohl weit und breit nichts
> darauf zugreift.

Das deutet i.d.R. auf einen Überlauf oder einen fehlgeleiteten Zeiger 
hin. Und auf welchem Controller bist Du unterwegs?

[Peter (Gast)]

> if(bytecnt >= 512)

die Prüfung kommt ein wenig spät wenn du vorher schon 10mal etwas auf 
bytecnt addierst.

[Stefan A. (aige)]

Ich verwende einen ATmega8, die Compileroptimierung hab ich auch mal 
ausgeschaltet aber ändert nix. Beim Übersetzten kommt, das nur ca 50% 
Speicher belegt sind. Bin ratlos, bei meinen Versuchen bin ich laufend 
auf Probleme der Art: "schreibe was in eine Variable, eine andere nimmt 
einen ganz kuriosen Wert an, oder: Vor einem Unterprogramm Aufruf ist 
die Variable in der main() noch ok, bis zum Rücksprung aus dem UP auch 
noch, nach dem Rücksprung ist der Wert ein anderer

[Karl H. (kbuchegg)]

Peter schrieb:
>> if(bytecnt >= 512)
>
> die Prüfung kommt ein wenig spät wenn du vorher schon 10mal etwas auf
> bytecnt addierst.

Hab ich zuerst auch gedacht, aber er hat das Glück, dass seine Records 
immer 8 Bytes lang sind und das geht sich ganzzahlig in 512 Bytes aus. 
Schön ist es trotzdem nicht. Fehleranfällig: ja klar.

Sollte man korrigieren, aber dürfte hier nicht das Problem sein.

[Karl H. (kbuchegg)]

Stefan A. schrieb:
> Ich verwende einen ATmega8, die Compileroptimierung hab ich auch mal
> ausgeschaltet aber ändert nix. Beim Übersetzten kommt, das nur ca 50%
> Speicher belegt sind.

Moment.
Du hast >50% SRAM verbraucht?

Dann überläufst du deinen Speicher.
Denn der 512-Byte Buffer in main() ist als funktionslokale Variable in 
dieser Statistik nicht mit enthalten. Mach den mal als globale Variable 
und erfreue dich an >100% SRAM Auslastung.


> Bin ratlos, bei meinen Versuchen bin ich laufend
> auf Probleme der Art: "schreibe was in eine Variable, eine
> andere nimmt einen ganz kuriosen Wert an, oder: Vor einem
> Unterprogramm Aufruf ist die Variable in der main() noch ok,
> bis zum Rücksprung aus dem UP auch noch, nach dem Rücksprung
> ist der Wert ein anderer

All das sind (unter anderem) klassische Symptome von: Stack durch 
Überlauf zerschossen.

[Stefan A. (aige)]

Peter schrieb:
>> if(bytecnt >= 512)
>
> die Prüfung kommt ein wenig spät wenn du vorher schon 10mal etwas auf
> bytecnt addierst.

hm ich möchte den buffer mit 512 Byte randvollschreiben -- 512/8 = 64, 
sollte also irgendwann genau eine Punktlandung auf 512 ergeben und 
write_data(buffer, address) wird aufgerufen

[Stefan A. (aige)]

> Moment.
> Du hast >50% SRAM verbraucht?
>
> Dann überläufst du deinen Speicher.
> Denn der 512-Byte Buffer in main() ist als funktionslokale Variable in
> dieser Statistik nicht mit enthalten. Mach den mal als globale Variable
> und erfreue dich an >100% SRAM Auslastung.
>
> All das sind (unter anderem) klassische Symptome von: Stack durch
> Überlauf zerschossen.

Ei ei, das hört sich aber nicht gut an...In der Tat, wenn ich buffer[] 
global mache, dann hab ich schon 99.8% Auslastung...

kurios ist, es funktioniert etwas besser in der Simulation und auch auf 
Real, aber dann schlägt wieder dieser, ich nen es mal "Fehler" zu:

for(int i = 0; i < 512; i++) buffer[i] = 0;

Die Laufvariable kommt bis genau 509 und als nächstes kommt wieder 266 = 
Endlossschleife, aber der Rest ging bis dahin besser...

Naja das ändert aber nichts daran, dass ich ein Problem hab. Wie kann 
ich meinen SRAM "entschlacken"?

>Hab ich zuerst auch gedacht, aber er hat das Glück, dass seine Records
>immer 8 Bytes lang sind und das geht sich ganzzahlig in 512 Bytes aus.
>Schön ist es trotzdem nicht. Fehleranfällig: ja klar.

>Sollte man korrigieren, aber dürfte hier nicht das Problem sein.

Hm wie kann man das besser machen?

[Vlad T. (vlad_tepesch)]

Stefan A. schrieb:
> kurios ist, es funktioniert etwas besser in der Simulation und auch auf
> Real, aber dann schlägt wieder dieser, ich nen es mal "Fehler" zu:for(int i = 0; 
i < 512; i++) buffer[i] = 0; Die Laufvariable kommt bis genau 509 und als nächstes 
kommt wieder 266 =
> Endlossschleife, aber der Rest ging bis dahin besser...

Du hast ja nun keinen Platz für den Stack mehr

[Karl H. (kbuchegg)]

Stefan A. schrieb:

> Naja das ändert aber nichts daran, dass ich ein Problem hab. Wie kann
> ich meinen SRAM "entschlacken"?

Indem du Variablen einsparst.
Wo wird denn der Rest des Speichers verbraucht?

Bei dir reicht ein Byte hier, ein Byte da nicht mehr.
Da muss man schon gröber nachsehen. Also: Alle globalen Variablen 
durchsehen, vor allen Dingen große Arrays und versuchen sie loszuwerden. 
Die SD-Routinen unterhalten nicht zufällig auch noch große Buffer?

> Hm wie kann man das besser machen?

Indem man nach jedem Byte, welches in den Buffer kommt nachsieht, ob man 
den Buffer nicht ausleeren müsste. Zu diesem Zwecke bietet sich dann 
eine Funktion an, die genau das macht:
  1 Byte in den Buffer einfügen
  prüfen ob der Buffer dadurch voll geworden ist und ausgeleert werden
  muss

Deine Schreibsequenz sieht dann so aus:

  ....
     if(blockcnt <= 2)
      {
        cache = BINtoASCII(temp);

        write_byte( 0x3D );
        write_byte( 0x3D );
        write_byte( (cache >> 24) & 0xFF );
        write_byte( (cache >> 16) & 0xFF );
        write_byte( (cache >>  8) & 0xFF );
        write_byte( (cache >>  0) & 0xFF );
        write_byte( 0x0D );
        write_byte( 0x0A );
      }
  ....

...

void write_byte( BYTE byte )
{
  buffer[bytecnt] = byte;
  bytecnt++;

  if(bytecnt >= 512)
  {
    bytecnt = 0;
  //      uart_putint(address);
    if(write_data(buffer, address) == 0)
      uart_puts("Schreiben erfolgreich...");
    else
      uart_puts("Error ......
  ....

Neben dem defensiven Gedanken zur Fehlervermeidung hat das dann auch 
noch den Vorteil der besseren Übersicht :-) Man sieht sehr viel besser 
was in welcher Reihenfolge geschrieben wird, ohne dass immer wieder 
irgendwelche 'Zwischenanweisungen' den Lesefluss stören.

[Karl H. (kbuchegg)]

Es ist zwar nicht viel, aber du könntest mal damit anfangen all die 
konstanten Texte ins Flash auszulagern (*)

Das sind schon mal 100 Bytes SRAM, die du ziemlich billig freischaufeln 
kannst. Nur mit den Texten, die du gezeigt hast :-)

(*) eigentlich falsch ausgedrückt. Denn die Texte sind schon im Flash. 
Sie werden beim Programmstart noch zusätzlich ins SRAM kopiert, damit zb 
uart_puts schön darauf zugreifen kann.

[Vlad T. (vlad_tepesch)]

Karl heinz Buchegger schrieb:
> Das sind schon mal 100 Bytes SRAM, die du ziemlich billig freischaufeln
> kannst. Nur mit den Texten, die du gezeigt hast :-)

Einfach uart_puts durch uart_puts_P ersetzen

[Stefan A. (aige)]

ich liebe euch :D
hab nun ca 400 Byte rausgeschunden - und alles funktioniert einwandfrei 
nun. Auf den Fehler wäre ich nie im Leben gekommen


>Einfach uart_puts durch uart_puts_P ersetzen

Aber ich weis nicht was damit gemeint ist. Meine uart Routinen hab ich 
selbst geschrieben und sind deshalb recht einfach
Auf die schnelle hab ich nicht rausgefunden wie ich meine Texte auf den 
Flash speichern lassen kann - damit würde ich nochmal 60Byte rausholen 
können

Warum gibt es denn keinen Fehlermeldung oder zumindest ne Warnung wenn 
der SRAM überfüllt ist?

[g457 (Gast)]

> Auf die schnelle hab ich nicht rausgefunden wie ich meine Texte auf den
> Flash speichern lassen kann

pgm_read_*() zum lesen, PSTR() ums bequem in den Flash zu verbannen. 
Beides in pgmspace.h (avr-libc)

> Warum gibt es denn keinen Fehler oder zumindest ne Warnung wenn der SRAM
> überfüllt ist?

Weil es in der Regel nicht möglich ist, das vorherzusagen(!). Und wenns 
mit ("globalem") Zeugs zugemüllt ist, dann gibts dir avr-objcopy/.. 
hüpsch aus :-)