Probleme bei Programmausführung

[Marius S. (fhler)]

Hallo,

mein ATmega16 führt das draugeflashte Programm zunächst richtig aus.

Dann stoppt er. Macht Quatsch.

Danach geht es dann wieder Ordnungsgemäß.

Dann stoppt er. Macht Quatsch.

Danach geht es dann wieder Ordnungsgemäß.

Dann stoppt er. Macht Quatsch.

[...]

Bis er schließlich ganz aufgibt.


Es sind auch keine festen Zeitabstände dazwischen.


Ordnungsgemäß heisst: PORTC verschieden setzen. (Ausgang)


Entw-Board: easyAV6. Die ADC´s sind in Betrieb, ein LCD an PORT B und 
eine PWM an PD5.

Ich hab den uC auch schon ausgetauscht.

Da der Code länger ist wollte ich Ihn hier nicht direkt posten.

[42 (Gast)]

Marius S. schrieb:
> Macht Quatsch.
Was genau?

> Da der Code länger ist wollte ich Ihn hier nicht direkt posten.
Meine Glaskugel wird gerade repariert.

[Peter II (Gast)]

Marius S. schrieb:
> Da der Code länger ist wollte ich Ihn hier nicht direkt posten.

dann können wir aber auch nicht helfen.

Vermutlich steckt der fehler im code. (speicherüberschreiber oder 
stackoverflow)

[Marius S. (fhler)]

 
#define TASTERPORT PIND
#define TASTERBIT1 PD2
#define TASTERBIT2 PD3

#include <avr/io.h>
#include <stdlib.h>
#include <util/delay.h>
#include "lcd-routines.h"
#include "lcd_functions.c"
#include <avr/interrupt.h>
#include "entprellung.h"


volatile int gew_Diode = 4;
volatile int adcval_max = 0;
volatile int adcval_alt = 0;
volatile int adcval;  //für das ADC-Ergebnis
volatile int adcval_neu;
volatile int an= 0x11;      //linkslauf
volatile int andersrum = 0x22;  //rechtslauf

volatile int zaehler=0; //für ADC-ISR

volatile int differenz;
volatile int differenz_alt  = 0;
volatile int differenz_alt2 = 0;

volatile double zeit;
volatile double altezeit;

char Buffer2[20]; //für das ADC-Ergebnis
char Buffer3[20]; //für die gewählte Diode

//-----------------------------------------
// ADC-Funktionen
//-----------------------------------------

/* ADC initialisieren */
void ADC_Init(void) 
{
 
    uint16_t result;
 
    ADMUX = (0<<REFS1) | (0<<REFS0);    // PIN AREF als Referenz nutzen
    ADCSRA = (1<<ADPS1) | (1<<ADPS0);   // Frequenzvorteiler : 8  
    ADCSRA |= (1<<ADEN);                // ADC aktivieren
  ADCSRA |= (1<<ADIE);        // ADC-Interrupt aktivieren
 
    /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
    ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
    while (ADCSRA & (1<<ADSC) );          // auf Abschluss der Konvertierung warten
    /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der naechsten
     Wandlung nicht uebernommen. */
    result = ADCW;
}
 
/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
    // Kanal waehlen, ohne andere Bits zu beeinflu?en
    ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
    ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
    while (ADCSRA & (1<<ADSC) )     // auf Abschluss der Konvertierung warten
    ;
    return ADCW;                    // ADC auslesen und zurueckgeben
}
 
/* ADC Mehrfachmessung mit Mittelwertbbildung */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average )
{
    uint32_t result = 0;
 
    for (uint8_t i = 0; i < average; ++i )
  {
      result += ADC_Read( channel );
    _delay_ms(20);
   }
    return (uint16_t)( result / average );
}

//-----------------------------------------
// Motor-Drehrichtung
//-----------------------------------------

void change_direction()
{
  if( (an & 0x11) == 0x11)
  {
    an = 0x02;
    andersrum = 0x11;
  }
  else if ( (an & 0x22) == 0x02)
  {
    an = 0x01;
    andersrum = 0x22;
  }
}

//-----------------------------------------
//Interrupt Service Routinen
//-----------------------------------------


ISR(INT0_vect)  //PD2 gedrückt
{
  
  int pgd = tasterhoch();

    if( (pgd == 1 ) ^ (gew_Diode < 8) )
    {

      if( gew_Diode == 2)
      {
        gew_Diode +=2;
        
      }
  
      else if ( gew_Diode == 5)
            {
                 gew_Diode +=2;           
      }

      else
      {
        gew_Diode +=1;
      }
            
    }

    else
    {
      
    }
  
    an = 0x22;      //rechtslauf
  andersrum = 0x11;  //linkslauf

  adcval_max = 0;
  zaehler = 0;

  //Erste Zeile löschen
  lcd_setcursor( 0, 1 );
  lcd_string("                 ");
    lcd_setcursor( 0, 1 );
    
  //Ausgabe der gewählten Diode auf dem LCD
  itoa( gew_Diode, Buffer3, 10 );
    lcd_string("Diode ");
  lcd_string(Buffer3);

}

ISR(INT1_vect)  //PD3 gedrückt
{
  int mgd = tastertief();
         
    if ( (mgd == 1) ^ (gew_Diode > 1) )
    {

      if( gew_Diode == 2)
      {
        gew_Diode = gew_Diode;        
      }

      else if ( gew_Diode == 4)
            {
                 gew_Diode -=2;
      }

      else if ( gew_Diode == 7)
            {
                 gew_Diode -=2;
      }

      else
      {
        gew_Diode -=1;
      }

    }

    else
    {
      
    }

  an = 0x11;      //linkslauf
  andersrum = 0x22;  //rechtslauf

  adcval_max = 0;
  zaehler = 0;

  //Erste Zeile löschen
  lcd_setcursor( 0, 1 );
  lcd_string("                 ");
  lcd_setcursor( 0, 1 );
    
  //Ausgabe der gewählten Diode auf dem LCD
  itoa( gew_Diode, Buffer3, 10 );
  lcd_string("Diode ");
  lcd_string(Buffer3);

}


ISR(ADC_vect)  //Interrupt nach Abschluss einer ADC Wandlung
{

  if(adcval > 0)
  {
    adcval_neu = ADC_Read_Avg( (gew_Diode - 1),100); //neuer ADC_Wert zum "Arbeiten"

    if(adcval_neu > adcval_max)
    {  
      adcval_max = adcval_neu;  
    }

    if(adcval_neu < adcval_alt)
      
    {
      change_direction();
    }

    /*

    differenz = 300 - adcval_neu;                        //300 = Sollwert
    //                q0              q1                  q2
    zeit =  0.1*differenz + 0.2*differenz_alt + 0.3*differenz_alt2;  //Reglergleichung

    differenz_alt2 = differenz_alt;
    differenz_alt = differenz;
    altezeit = zeit;

    int zeitganz = (int) zeit;

    lcd_setcursor( 10, 1 );
    lcd_int(zeitganz);

    if(zeit>80)
    {
      zeit = 80;
    }

    PORTC = an;
    _delay_ms(zeitganz);
    PORTC = andersrum;
    _delay_ms(zeitganz/2);

    */

    zaehler += 1;
    
    if(zaehler == 1)
    {  
      PORTC = an; 
      _delay_ms(180);
      PORTC = andersrum;
      _delay_ms(50);
      
      PORTC = 0x00;  //STOPP - Laserpointerstrahl ist prinzipiell auf der Diode
    }

    else if(( (zaehler >=31) & ((adcval_max - adcval_neu) < 50) ))
    {
      PORTC = 0x00;
    }

    else  // 1 < zaehler < 31
    {
      
      PORTC = an;
      _delay_ms(80);
      PORTC = andersrum;
      _delay_ms(50);
      PORTC = 0x00;
      
      
      
    }
  }
  
  else
  {
    PORTC = an;
    _delay_ms(100);

    PORTC = andersrum;
    _delay_ms(50);

    PORTC = 0x00;

    zaehler = 0;
  }

  adcval_alt = adcval_neu;

}

//-----------------------------------------
// Start Hauptprogramm
//-----------------------------------------
 
int main(void)
{

//-----------------------------------------
// Datenrichtung (Ein-/Ausgänge) setzen
//-----------------------------------------

  DDRC |= (1 << PD0 | 1 << PD1 | 1 << PD4 | 1 << PD5);

  DDRD |= (1 << PD4 | 1 << PD5);

//-----------------------------------------
// PWM-Einstellungen
//-----------------------------------------  

  //            COM: verhalten bei match                               WGM: Phase Correct Mode  
  TCCR1A |= ( 1 <<COM1A1 | 0 << COM1A0| 1 << COM1B1| 0 << COM1B0| 1 << WGM11 | 0 << WGM10 );
  //            WGM: Phase Correct Mode              CS Prescaler
  TCCR1B |= ( 1 << WGM13 | 0 << WGM12 | 0 << CS12 | 0 << CS11 | 1 << CS10);

  
  ICR1 = 8000;  // Frequenz 500 Hz mit prescaler 1

  OCR1A = 2000;

//-----------------------------------------
// ADC einstellen / aktivieren
//-----------------------------------------  

  ADC_Init();

//-----------------------------------------
// Interrupt-Register
//-----------------------------------------  

  MCUCR = 0x0F;  //auf steigende Flanken reagieren (Taster mit externem Pull-Down)

  GICR = 0xC0;  //Interrupts INT0 + INT1 aktivieren

//-----------------------------------------
// für die Ausgabe auf dem LCD
//-----------------------------------------  

  lcd_init();          // Initialisierung des LCD

  lcd_string("  Neustart");
    lcd_setcursor( 0, 2 );    // Die Ausgabemarke in die 2te Zeile setzen
    lcd_string("    Neustart");

    _delay_ms(1000);
  
  //Erste Zeile löschen
  lcd_setcursor( 0, 1 );
  lcd_string("                 ");
  lcd_setcursor( 0, 1 );
    
  //Ausgabe der gewählten Diode auf dem LCD
  itoa( gew_Diode, Buffer3, 10 );
  lcd_string("Diode ");
  lcd_string(Buffer3);  
  
  sei(); //Interrupts anschalten

//-----------------------------------------
// Start Endlosschleife
//-----------------------------------------

    while(1) 
  {  
    if( ((PORTC == 0x00) & (zaehler >=31)) )
    {
      //2. Zeile löschen
        lcd_setcursor( 0, 2 );
      lcd_string("                 ");
        lcd_setcursor( 0, 2 );      

      lcd_string("Ausgerichtet :-)");
    }
    
    else
    {
      // Kanal x (gew_Diode - 1) wandeln
      adcval = ADC_Read(gew_Diode - 1);
      
      lcd_setcursor( 10, 1 );
      lcd_int(zaehler);

      //Umwandlung "Zahl" in einen "String"
      itoa( adcval_neu, Buffer2, 10 );

      //2. Zeile löschen
        lcd_setcursor( 0, 2 );
      lcd_string("                 ");
        lcd_setcursor( 0, 2 );  

      //Vorbereitung Ausgabe des Wandlungsergebnisses der gew. Diode
      lcd_string("ADC_Diode");
      lcd_string( Buffer3 );
      lcd_string(": ");
    
      //Ausgabe Wandlungsergebnis    
      lcd_string( Buffer2 );
    }
    
    _delay_ms(500);    

    }
 
    return (0);
}

[Peter II (Gast)]

du machst zuviel im der ISR. das LCD sollte an dieser stelle nicht 
beschrieben werden weil das viel zu lange dauert.

Das sollte aber nicht zu solchen Problemen führen.

Warum hast du immer int verwendet? Das ganze ist damit langsam und 
eventuell fehlerhaft weil alles operrationen mit der Variable mit atomic 
sind.

[Εrnst B. (ernst)]

Peter II schrieb:
> Das sollte aber nicht zu solchen Problemen führen.

Doch, weil das LCD sowohl aus der ISR als auch aus main angesprochen 
wird.

[Marius S. (fhler)]

Ordnungsgemäß:

PC0 setzen 0,1s halten
PC0 rücksetzen PC1 setzen 0,05s halten
PORTC ganz aus.

0,5sek Pause

PC0 setzen 0,1s halten
PC0 rücksetzen PC1 setzen 0,05s halten
PORTC ganz aus.

0,5sek Pause

[...]

Quatsch:

PORTC ganz aus.
PC0 setzen. (halten <  0,1s)
PC0 rücksetzen PC1 setzen  halten < 0,1s
PORTC ganz aus.

kurze Pause (länger als 0,5s)

dies 3-4 mal

nahcdem PORTC ganz aus ist
PC0 setzen. (extrem kurz)
PC0 rücksetzen PC1 setzen  (extrem kurz)
PORTC ganz aus.

danach geht es dann aber wieder ordnungsgemäß

[Purzel H. (hacky)]

Aeh. Ja. Fehler zu haben ist ueblich. Dann ist nun Debuggen angesagt. 
Debuggen ist keine Krankheit, sondern Teil des Entwicklungsprozesses. 
Der Programmaufbau sollte auch schon mit Debuggen geplant sein.
Das bedeutet mit den kleinstmoeglichen Codeeinheiten gepruefte Bloecke 
aufzubauen. Dann lass das Ganze mal ohne Interrupts laufen. Dann mit 
einem, dann mit zweien. Bis der/die Fehler gefunden sind.

[Karl H. (kbuchegg)]

Verrätst du uns auch noch, was das Ganze sein soll?

(In deinem Code findet sich ziemlich viel unübersichtliches und ich 
würde sogar nach einem ersten Drüberschauen sagen "unsinniges", dass es 
schwer ist, den Sinn hinter der ganzen Sache zu verstehen. Deine 
exzessive Verwendung von Hex-Konstanten macht die Sache dann auch nicht 
leichter.)

[Marius S. (fhler)]

Bei PORTA werden Signale von Fotodioden digitalisiert.

An PORTB hängt ein Display zur Ausgabe auf welche Diode sich ein 
Laserpointer ausrichten soll. Und zur Ausgabe des ADC-Wertes.

PORTC ist für die Steuerung einer H-Brücke. Links- / Rechtslauf eines 
Motors.

Auf PORTD(PD5) liegt eine PWM. (H-Brücke)

In der ADC-ISR soll gesteuert werden. (wenn möglich später geregelt).

[Udo S. (urschmitt)]

Das die Ursache ein aktiver Watchdog ist, oder ein reset wegen Brown-Out 
Detection bzw. wegen Unterspannungspulsen kann ausgeschlossen werden?

[Εrnst B. (ernst)]

Geh bei der Fehlersuche systematisch vor.
Behebe zuerst die Fehler, die aus dem Quelltext offensichtlich sind und 
wir dir schon genannt haben.
Dann teste neu.

Fang z.B. damit an, die LCD-Ausgabe in Ordnung zu bringen. Vielleicht 
läuft das Programm ja korrekt, nur die Ausgabe spinnt?

Also: entweder alle LCD-Zugriffe aus den ISRs entfernen (gut), oder 
wenigstens während allen LCD-Zugriffen im main() die Interrupts sperren 
(quick&dirty).

(
schnelle Lösung: das _delay_ms(500) im Main durch
sei(); _delay_ms(500); cli(); ersetzen, das andere sei() weiter oben 
entfernen.
)

Dann schauen wir weiter.

[Marius S. (fhler)]

Brown-out kann ausgeschlossen werden.

Ich hab mittlerweile herausgefunden das er mit dem ADC_interrupt so 
seine Schwierigkeiten hat.

int main()
[...]
sei();

while(1) 
  {  
    //1. Zeile löschen
      lcd_setcursor( 0, 1 );
    lcd_string("                 ");
      lcd_setcursor( 0, 1 );
  
    //Ausgabe der gewählten Diode auf dem LCD
    itoa( gew_Diode, Buffer3, 10 );
      lcd_string("Diode ");
    lcd_string(Buffer3);

    if( ((PORTC == 0x00) & (zaehler >=31)) )
    {
      //2. Zeile löschen
        lcd_setcursor( 0, 2 );
      lcd_string("                 ");
        lcd_setcursor( 0, 2 );      

      lcd_string("Ausgerichtet :-)");
    }
    
    else
    {
      // Kanal x (gew_Diode - 1) wandeln
      //ADC_Read(gew_Diode - 1);
      
      lcd_setcursor( 10, 1 );
      lcd_int(zaehler);

      //Umwandlung "Zahl" in einen "String"
      itoa( adcval_neu, Buffer2, 10 );

      //2. Zeile löschen
        lcd_setcursor( 0, 2 );
      lcd_string("                 ");
        lcd_setcursor( 0, 2 );  

      //Vorbereitung Ausgabe des Wandlungsergebnisses der gew. Diode
      lcd_string("ADC_Diode");
      lcd_string( Buffer3 );
      lcd_string(": ");
    
      //Ausgabe Wandlungsergebnis    
      lcd_string( Buffer2 );
    }

    PORTC = an;
    _delay_ms(50);
    PORTC = andersrum;
    _delay_ms(50);
    PORTC = 0x00;
    
    _delay_ms(500);    

    }
 
    return (0);

Obwohl erst Interrupts vor der Endlosschliefe freigegeben werden. Und er 
auch eigentlich keinen werfen dürfte (ADC-Read ist auskommentiert). 
Springt er wenn er wenn im ADC-Register der ADC-Interrupt aktiviert wird 
in die ISR.

Die LCD-Zugriffe sind auch aus allen ISR raus.

[Marius S. (fhler)]

bzw. jetzt springt er überhaupt nicht mehr rein obwohl er sollte.


//

Also jetzt funktioniert es wieder richtig. (k.A. warum)

mist zu früh gefreut.

es kann aber nicht sein das es erst funktioniert und dann irgendwann 
nicht mehr.

[Εrnst B. (ernst)]

Marius S. schrieb:
> Obwohl erst Interrupts vor der Endlosschliefe freigegeben werden. Und er
> auch eigentlich keinen werfen dürfte (ADC-Read ist auskommentiert).
> Springt er wenn er wenn im ADC-Register der ADC-Interrupt aktiviert wird
> in die ISR.

Deine "ADC_init" schaltet zuerst den ADC Irq frei, und macht danach 
einen Dummy-Read. Dieser Dummy-Read löst natürlich auch einen IRQ aus.

Also:
 ADCSRA |= (1<<ADIE);
ans Funktionsende schieben.

Bei Global deaktivierten IRQs sollte das jedoch wurscht sein. Sicher 
dass der noch vor dem "sei()" dort reinspringt?
Eventuell enthält dein rest-Quelltext (lcd, enprellung, ..) ein sei() ?

[-schumi- (Gast)]

Dein Programm ist nicht gerade "klein" (deine LCD-Routinen und 
entprellung kommen ja auch noch dazu) und du verwendest viele sehr große 
Variablen.. Gib mal folgendes auf deinem PC ein:

avr-size --mcu=atmega16 -C foo.elf

foo.elf ist die elf-Datei deines Programms, die wird beim Übersetzen in 
die .hex mit erzeugt.

Jetzt wird dir angzeigt wie viel RAM du schon verbraucht hast, 
vielleicht isses ja wirklich schon so weit dass du nen größeren 
Controller brauchst (Atmega32)

[Εrnst B. (ernst)]

-schumi- schrieb:
> Jetzt wird dir angzeigt wie viel RAM du schon verbraucht hast,
> vielleicht isses ja wirklich schon so weit dass du nen größeren
> Controller brauchst (Atmega32)

Soweit isses noch nicht... Mit wenig Aufwand könnte er z.B. alle 
String-Konstanten vom Ram in den Flash verbannen... PSTR(), lcd_string_P 
()...

[Purzel H. (hacky)]

Ein delay ist sowieso Schrott.

Besser ist ein konstrukt wie

timer_isr {
 timer_came=1
 rimerreload...
 }

main
 ..
 if (timer_came==1)
 {
 ..
 timer_came=1;
 }

[anc (Gast)]

Pico Oschi schrieb:
>  if (timer_came==1)
>  {
>  ..
>  timer_came=1;
>  }

if...
timer_came=0;

[Marius S. (fhler)]

Εrnst B✶ schrieb:
> -schumi- schrieb:
>> Jetzt wird dir angzeigt wie viel RAM du schon verbraucht hast,
>> vielleicht isses ja wirklich schon so weit dass du nen größeren
>> Controller brauchst (Atmega32)
>
> Soweit isses noch nicht... Mit wenig Aufwand könnte er z.B. alle
> String-Konstanten vom Ram in den Flash verbannen... PSTR(), lcd_string_P
> ()...

AVR Memory Usage
----------------
Device: atmega16

Program:    5670 bytes (34.6% Full)
(.text + .data + .bootloader)

Data:        426 bytes (41.6% Full)
(.data + .bss + .noinit)


Build succeeded with 0 Warnings...

[Marius S. (fhler)]

Mittlerweile läuft es recht stabil. Nach einer langen Zeit hat er immer 
noch nen kurzen Aussetzer.

-Ich mach jetzt direkt am Anfang der main erstmal ein cli();

-sei(); direkt vor der Endlosschleife.

-Ich hab mich um die Datenrichtung bei allen Ports gekümmert.

-Alle Interrupts schalte ich jetzt in der main, direkt vor dem sei(); ,
ein (externe (Taster), ADC).

-in der ADC_ISR:

   zuerst adif & adie = 0;

   am ende adie = 1

-Displayzugriffe alle ausserhalb der ISRn.

-Es läuft allerdings immer noch mit delays anstatt dem timer.


Und auch wenn es nicht zum Beitrag passt:

Habe ich ne Chance auf einen Regler wenn ich in dem Sinne keinen 
Sollwert habe außer das der entspr. Wert maximal sein soll?

Ich meine nein. Da ich ja in dem Sinne keinen Wert habe mit dem ich den 
aktuellen Wert vergleichen kann. Zudem habe ich ja dann nie eine 
Abweichung wo dann der Stellwert/Stellgröße entspr. 
zurückgefahren/invertiert wird.