[Atmega8] Programm hängt

[Sam .. (sam1994)]

Hi

Mein 4Kanal Logger, der über mehrere Tage 4 Spannungen überwachen soll, 
hängt sich nach 30-120min auf. Das Programm bleibt stehen, die Zeit 
ändert sich nicht mehr und das Display zeigt den alten Wert an. Sobald 
man die Stromversorgung kappt, funktioniert alles wieder.

Das Atmega hängt an einem externem Quarz. Die Platine ist 
Streifenraster, das sollte aber nicht das Problem sein.

Um zu hängen müsste das Programm doch in einer Endlosschleife hängen, 
die einzigen, die es gibt, sind von den I2C Routinen (fertige Lib).

Das ist die Hautpschleife, in der er sich aufhängt:

#define CLKDIV 24000
volatile uint16_t sprescaler = 0;
volatile uint8_t next = 0;
volatile uint8_t sec = 0;
volatile uint16_t count;
uint16_t Mcount, hours;
uint8_t secs, mins;

void rec(void)
{
    count = pgm_read_word(&(intervall_int[Vintervall]));
    StartTimer();
    lcd_clear();
    NewStream(Vchannels + 1);
    uint8_t b = 0;
    Mcount = 0;
    secs = mins = hours = 0;
    do
    {
        cli();
        if(next)
        {
            for(uint8_t i = 0; i <= Vchannels; i++)
                WriteBuffer13(ADC_Read13(i));   
            Mcount++;
            b = 1 - b;
            next = 0;
        }
        if(key_update_req)
            key_update();
        if(sec)
        {
            secs += sec;       
            sec = 0;
            while(secs >= 60)
            {
                secs = 0;
                if(++mins == 60)
                {
                    mins = 0;
                    ++hours;        
                }   
            }
            lcd_setcursor(0, 1);
            for(uint8_t i = 0; i <= Vchannels; i++)
            {
                print13s(ADC_Read13(i));
                if(i != Vchannels)
                    lcd_putc(' ');
            }
            lcd_putc('V');
            lcd_setcursor(0, 2);
            char buff[6];
            itoa16(Mcount, buff);
            lcd_puts(buff);
            itoa16(hours, buff);
            lcd_puts(buff);
            lcd_putc(':');
            itoa8(mins, buff);
            lcd_puts(buff + 1);
            lcd_putc(':');
            itoa8(secs, buff);
            lcd_puts(buff + 1);   
        }
        sei();   
    }
    while(UP(BACK));
    StopTimer();
    ClearBuffer();
}

Die kleinen Routinen StartTimer und StopTimer steuern den 16bit Timer, 
die ISR zählt die Sekunden (sec) und steuert auch wann die nächste 
Messung durchgeführt wird:

void StartTimer(void)
{
    cli();
    TCCR1B |= (1 << CS12) | (1 << WGM12); //Prescaler 256 + CTC
    OCR1A = CLKDIV - 1;
    TIMSK |= 1 << OCIE1A; //Compare Match interrupt erlauben 
    sei(); 
}
void StopTimer(void)
{
    cli();
    TIMSK &= ~(1 << OCIE1A); //Compare Match interrupt deaktivieren 
    sei(); 
}
ISR (TIMER1_COMPA_vect)
{
    sec++;
    if(sprescaler == 0)
    {
        sprescaler = count;
        next = 1;
    }
    sprescaler--;
}

Hier sind noch die Routinen des "Dateisystems":

//FORMAT: xxxDDDDD DDDDDDDD
// D = Data
// x: 111  = Ende
//    000  = In Stream
//    xxx = Neuer Stream mit xxx Kanälen

#define BUFFERLEN 64
#define WRITE(pos,buf,count) i2cMemWrite(0xA0,pos,buf,count,0)
#define READ(pos,buf,count) i2cMemRead(0xA0,pos,buf,count)

uint16_t streampos = 0;
uint8_t buffer[BUFFERLEN];
uint8_t bufferpos = 0;
uint8_t newstream = 0;

uint16_t GetStreamEnd(void)
{
    uint8_t rbuffer[BUFFERLEN];    
    for(uint16_t pos = 0; pos < 16384 ; pos += BUFFERLEN)
    {
        READ(pos, rbuffer, BUFFERLEN);
        for(uint8_t i = 0; i < BUFFERLEN; i += 2)
            if(rbuffer[i] == 0xFF)
                return pos + i;
    }
    return 0;
}

void NewStream(uint8_t channels)
{
    if(streampos == 0)
        streampos = GetStreamEnd();
    newstream = channels << 5;
}

void WriteBuffer13(uint16_t data)
{
    WriteBuffer8((uint8_t)((data >> 8) | newstream));
    WriteBuffer8((uint8_t) data);
    newstream = 0;
}

void WriteBuffer8(uint8_t data)
{
    buffer[bufferpos++] = data;
    streampos++;
    if((((uint8_t)streampos) & (BUFFERLEN - 1)) == 0 || bufferpos == BUFFERLEN)
        ClearBuffer();
}

void ClearBuffer(void)
{
    WRITE(streampos - bufferpos, buffer, bufferpos);
    buffer[BUFFERLEN - 1] = 0;
    uart_puts(buffer);
    bufferpos = 0;
}

[Sascha W. (sascha-w)]

das kann schon sein, das das I2C mal hängt. Eigentlich sollten sich aber 
alle Fehler abfangen lassen.
Deaktiviere doch mal das Aufzeichnen und schau ob's dann läuft.

Sascha

[Sam .. (sam1994)]

Sascha Weber schrieb:
> Deaktiviere doch mal das Aufzeichnen und schau ob's dann läuft.

Danke für die Antwort. Ich werde das morgen mal probieren (heute wird 
das nichts mehr, da ich nicht genau weiß wann der Fehler eintritt).

Watchdog wäre auch eine Möglichkeit, aber das gefällt mir nicht so, da 
ich die so Sachen wie Intervall und Startzeit im internen EEprom 
speichern, oder nochmal das "Dateisystem" überarbeiten müsste.

[Sam .. (sam1994)]

So...

Ich hab grad die if Abfrage geändert

if(next && Vsave)
{
  for(uint8_t i = 0; i <= Vchannels; i++)
    WriteBuffer13(ADC_Read13(i));
  Mcount++;
  b = 1 - b;
  next = 0;
}

Vsave hab ich über das Menu auf 0 gestellt. In ein paar Stunden schau 
ich nochmal ob sich was geändert hat.

PS: irgendwie muss ich gerade an www.if-schleife.de denken.

[Sam .. (sam1994)]

Das Programm lüuft nun fast 7 Stunden ohne Unterbrechung. Der Fehler 
muss wirklich in der Speicher-Funktion liegen.

Ich glaube aber den Fehler gefunden zu haben:

Beitrag "Re: Hardware TWI,I²C, I²C EEPROM"
> Beim Versuch, im laufenden Betrieb größere Mengen Daten aus dem EEPROM
> zu lesen, schmiert alles ab. Es scheint mir, dass der INT in die
> i2c-Routinen reinfunkt.

Mir scheint der Keyboard-Interrupt funkt zufällig in die I2C 
Schreibroutine rein. Mal schauen was passiert wenn ich den Interrupt 
voher abschalte.

[Sam .. (sam1994)]

Samuel K. schrieb:
> Ich glaube aber den Fehler gefunden zu haben:

Nein, doch nicht. Ich hatte die Interrupts schon vorher ausgeschaltet.
Diesmal ist es nach genau 31 Messungen abgestürzt.

Ich werde mal soft i2c verwenden.

Hat noch jemand eine Idee was da nicht funktionieren könnte?

[Sam .. (sam1994)]

Hmm, langsam dreh ich durch. Jetzt bekomm ich es nicht mal mehr hin ein 
EEPROM zu beschreiben.
Ich habe diese lib genommen 
(Beitrag "I2C-Master [ohne TWI (Softwarelösung) für die ATMEGAs").

void i2cWrite(uint8_t adress, uint16_t pos, uint8_t *buf, uint8_t count)
{
    i2c_master_start();
    i2c_master_write(adress);
    i2c_master_write(pos >> 8);
    i2c_master_write(pos & 0xFF);
    while(count--)
        i2c_master_write(*buf++);
    i2c_master_stop();
}
void i2cRead(uint8_t adress, uint16_t pos, uint8_t *buf, uint8_t count)
{
    i2c_master_start();
    i2c_master_write(adress + 1);
    while(count--)
        *buf++ = i2c_master_read(0);
    i2c_master_stop();
}

Read funktioniert ganz gut, aber bei Write bleibt er hängen.
Im Datenblatt 
(http://www.atmel.com/dyn/resources/prod_documents/doc0670.pdf) steht: 
start,adresse, high-adresse (0xA0), low-adr, n*data, stop.
Das hab ich doch gemacht. Trotzdem will das nicht.

[Sascha W. (sascha-w)]

die Lib oben ist aber Soft-I2C, welche Lib hast du zuerst verwendet?
Was für einen EEProm hast du dran?

in deiner READ Funktion

void i2cRead(uint8_t adress, uint16_t pos, uint8_t *buf, uint8_t count)
{
    i2c_master_start();
    i2c_master_write(adress + 1);
    while(count--)
        *buf++ = i2c_master_read(0);
    i2c_master_stop();
}

sehe ich nix wie du die Readadresse einstellst! Und du beendest das 
lesen eigentlich nicht ordungsgemäß, denn das letzte Byte sollte mit 
NACK bestätigt werden.

Sascha

[Sam .. (sam1994)]

Sascha Weber schrieb:
> sehe ich nix wie du die Readadresse einstellst! Und du beendest das
> lesen eigentlich nicht ordungsgemäß, denn das letzte Byte sollte mit
> NACK bestätigt werden.

Danke, das wusste ich nicht. Leseadresse habe ich vergessen, aber da ich 
immer von anfang gelesen habe, war es auch nicht weiter schlimm.

void i2cRead(uint8_t adress, uint16_t pos, uint8_t *buf, uint8_t count)
{
    if(count == 0)
        return;
    i2c_master_start();
    i2c_master_write(adress + 1);
    i2c_master_write(pos >> 8);
    i2c_master_write(pos & 0xFF);
    while(--count)
        *buf++ = i2c_master_read(0);
    *buf = i2c_master_read(1);
    i2c_master_stop();
}

Sascha Weber schrieb:
> die Lib oben ist aber Soft-I2C, welche Lib hast du zuerst verwendet?
> Was für einen EEProm hast du dran?

Ich verwende diese Lib
Beitrag "Hardware TWI,I²C, I²C EEPROM"
mit dem Update
Beitrag "Re: Hardware TWI,I²C, I²C EEPROM"

EEPROM ist das Datenblatt das ich verlinkt habe: 24C128 von Atmel


Trotzdem gleiches Problem. Das schreiben funktioniert nicht. Nach 7 
Messungen hängt der µC (8 * 4 Kanäle * 2 Byte = 64 Byte = 1Page, da 64B 
Buffer)

[Sascha W. (sascha-w)]

wenn der µC hängt, dann prüfe doch mal den Pegel der I2C-Leitungen und 
ob sich dort noch was tut.
Mach dir zwischen den einzelnen I2C Funktionen noch ein paar 
Debugausgaben auf den UART damit du siehst wo es hängt.

Sascha

[Sam .. (sam1994)]

Sascha Weber schrieb:
> wenn der µC hängt, dann prüfe doch mal den Pegel der I2C-Leitungen und
> ob sich dort noch was tut.
Für mich schwer zu realisieren. Ich könnte nächste Woche evtl. ein Oszi 
dranhängen. Einen Logikanalyser besitze ich nicht.
> Mach dir zwischen den einzelnen I2C Funktionen noch ein paar
> Debugausgaben auf den UART damit du siehst wo es hängt.
OK. 14 Bytes schreibt er, beim 15 hängt er.

Aber entweder die Lesefunktion funktioniert nicht, oder die Bytes werden 
nicht richtig geschrieben, denn ich kann sie nicht empfangen.

[Sam .. (sam1994)]

Danke für deine Bemühungen Sascha. Nach längerem Probieren und 
Vergleichen mit dem älteren Backup hab ich glaubich den Fehler gefunden:

Samuel K. schrieb:
> void ClearBuffer(void)
> {
>     WRITE(streampos - bufferpos, buffer, bufferpos);
>     buffer[BUFFERLEN - 1] = 0;
>     uart_puts(buffer);
>     bufferpos = 0;
> }

Hier sind die Interrupts deaktiviert. Der Uart-Buffer hab aber nur 64 
Zeichen. Also wird gewartet bis dieser frei ist, was aber so nie sein 
wird.

Mit der (hardware) i2c lib funktioniert es jetzt (hoffentlich).