Programm funktioniert.aber wieso?

[digitalespannung (Gast)]

Hallo

Ich habe mein erstes Programm in C geschrieben.

Das Programm funktioniert folgerndermassen:

1. Status= 0 -> Warten auf irgendein Zeichen vom UART.
2. Status= 1 -> Starte Motor.
3. Status= 3 -> Warte auf Positive Flanke an INT1 Pin.
4. Status= 4 -> Messe bei Pegeländerung an INT0 Pin.
5. usw.

Nun zu meiner Frage:
Beim Status 3 und 4 macht der Controller nichts anderes als auf einen 
Interrupt zu warten.

In dieser Zeit wollte ich eigentlich eine leere Schlaufe aufrufen oder 
eine Schleife mit einem Delay. Das funktioniert allerdings nicht weill 
dann anscheinend die Interrupts nicht mehr aufgerufen werden.

Im jetztigen Programm rufe ich die Funktion statussend() auf und in 
dieser Funktion ist der einzige Befehl: Printf
dieser Befehl bewirkt nichts.

Wieso funktioniert das ganze nicht wenn ich einfach ein _delay(ms) in 
die Funktion einfüge? Gibt es einen Befehl wie in assembler das NOP der 
einfach nichts macht ?

Danke für eure Hilfe.

/*
 * Telefon.c
 *
 * Created: 05.08.2013 13:44:22
 */ 

#include <avr/io.h>
#include <stdint.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <inttypes.h>

#ifndef F_CPU
#define F_CPU 14745600
#endif
#define UART_BAUD_RATE 115200

#include <util/delay.h>

uint8_t senden;            //wert der an Schieberegister gesendet wird
uint8_t empfang;
uint8_t tmp_sreg;          //SREG zwischenspeicher in interrupts
uint8_t status;            //status des Programms
uint16_t counter;          //counter 16bit gross
// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)
#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

//*******************************************************Interrupts*********************************************
//Interrupt Flanke an INT0 A&B Signal Encoder
//lese A/D Wandleraus und speichere in S-ram
ISR (INT0_vect)
{
  uint8_t werth;            // Speicher für A/D Wert high
  uint8_t wertl;            //Speicher für A/D Wert low
  
  tmp_sreg = SREG;      //SREG sichern
  uint8_t temp;        // lokale Variable
  
  counter++;              //counter +1
  
  //A/D Wandlung und speichern in S-ram Funktioniert!
  
//  PORTD = 0b01000000;          //CS SChieberegister auf OFF A/D auf ON
  PORTB |= (1<<PB4) ;          //Setze PB4 auf 1 CONV von A/D Wandler
  PORTB &= ~ (1<<PB4) ;        //Setze PB4 auf 0 CONV von A/D Wandler
  PORTB |= (1<<PB4) ;          //Setze PB4 auf 1 CONV von A/D Wandler
  _delay_ms(0.005);          //CONVERTIERUNG max 5 mikro sekunden
  
  SPDR=senden;              //Irgendwas senden um übertragung zu starten
  while (!(SPSR & (1<<SPIF)))      // warten bis übertragung fertig
  ;
  temp = SPDR;            // Wert in temp schreiben
  werth= temp<<1;            //um 1ns nach links verschieben ausgabe an PortA = highbyte
  
  SPDR = senden++;            // neuen Wert in SPDR schreiben um neue übertragung zu starten
  while (!(SPSR & (1<<SPIF)))      // warten bis übertragung fertig
  ;
  temp = SPDR;
  wertl=temp;
  if (temp>127)            //falls temp kleiner als 127 ist ist das MSB nicht gesetzt
  {
    werth = werth | 0b00000001;
  }
  wertl=wertl<<1;
  wertl = wertl & (0b11110111);        //4tes bit invertieren auf 0
  PORTA=werth;              //Ausgabe an PortA = Highbyte
  PORTC=wertl;            //Ausgabe an PortC = lowbyte

//  PORTA=counter;
//  PORTC=0;

  //********************************************ADWANDLER AUSGELESEN RESULTAT AN PINS DES MIKROK**************  
  //speichern im S-RAM
  PORTB &= ~ (1<<PB2);          //PB2=WE auf 0 S-ram
  PORTB |= (1<<PB2);            //PB2=WE auf 1 S-ram

  PORTD &= ~ (1<<PD7);          //PD7 auf 0 setzen Zähler +1 = S-ram adresse +1 = SPEICHERN
  PORTD |= (1<<PD7);            //PD7=zähler+1 wieder auf 1 setzen

  //******************************************SPEICHERN IN S-RAM fertig***************************************
  SREG = tmp_sreg;      //SREG wider herstellen
  
}

//Interrupt Funktion Positive Flanke an INT1 Z Signal Encoder
ISR (INT1_vect)
{
  tmp_sreg = SREG;      //SREG sichern
  if (status==2)              //beginne mit der Messung
  {
    GICR = (1<<INT1)|(1<<INT0);         // aktivieren von INT0 = AB Impuls
  }  
  status++;
  
  SREG = tmp_sreg;      //SREG wider herstellen

}

//**********************************************Funktionen*******************************************
//Motorstart Funktion
uint8_t startmotor()
{
  DDRA = 0xff;                  //Port A = Ausgang
  DDRC = 0xff;                  //Port C = Ausgang
  PORTD |= (1<<PD7);                //Counter auf 1 setzen bereit für negative Flanke
  PORTB |= (1<<PB0)|(1<<PB3)|(1<<PB1)|(1<<PB2);  //PB0 starte Motor PB3 clear counter PB1 & PB2 = OE und WE auf 1 S-ram
  PORTB &= ~(1<<PB3);                //clear counter wider weg
  counter=0;                    //zähler reseten
  GICR = (1<<INT1);                // aktivieren von INT1 = Z Impuls
  status++;                    // sollte jetzt status=2 sein
  return(0);
}

//auslesen aus S-Ram und SENDEN FUNKTION... Funktioniert!
uint8_t auslesen(void)
{
  uint16_t temp;                // lokale Variable
    cli();                  //schalte Interrupts aus

    GICR &= ~ ((1<<INT1)|(1<<INT0));     //deaktivieren von Interrupts
    DDRA = 0x00;              //PortA als Eingang
    DDRC = 0x00;              //PortC als eingang
    
    PORTB |= (1<<PB3)|(1<<PB2);        //PB3=CLR counter auf 1 PB2= WE S-ram auf 1
    PORTB &= ~ ((1<<PB0)|(1<<PB3)|(1<<PB1));    // stoppe Motor, Counter wider auf 0 OE s-ram auf low = ausgabe
      
  temp=counter;
  
  while(temp>=2)
  {
    while(!(UCSRA & (1<<UDRE)))        // Warten bis senden bereit
    ;  
    UDR=PINA;                //highbyte wird gesendet
    while(!(UCSRA & (1<<UDRE)))        // Warten bis senden bereit
    ;
    UDR=PINC;                //lowbyte wird gesendet
    
    PORTB |= (1<<PB2);            //S-ram WE auf 1
    PORTD &= ~ (1<<PD7);          //PD7 auf 0 setzen Zähler +1 = S-ram adresse +1
    PORTD |= (1<<PD7);            //PD7=zähler+1 wieder auf 1 setzen
    temp--;
  }
  status++;                  //status=5
  return(0);
}
uint8_t statussend(void)
{
  printf("m"); //eigentlich nichts machen aber es funktioniert nur mit printf
  
    return(0);
}

//EMPFANG FUNKTION
uint8_t uartempfangen (void)
{
  while(!(UCSRA & (1<<RXC))) // Warten bis empfangen
  ;
  empfang = UDR;
  
  status=1;          //stauts auf 1 setzen
  counter=0;
  sei();            //Innterrupts erlauben
  return (0);
}

//SPI
uint8_t shiftreg (void)
{
    
//PORTD = 0b00100000;          //CS SChieberegister auf OFF A/D auf ON
SPDR = senden;
while (!(SPSR & (1<<SPIF)))      // warten bis übertragung fertig
;
//0-1-0 Puls an STCP von Schieberegister um Werte zu übernehmen
  PORTB &= ~ (1<<PB4) ;
  PORTB |= (1<<PB4);
  PORTB &= ~ (1<<PB4) ;
    
  status=0;
  
return(0);
}

//ENDE FUNKTIONEN
int main(void)
{
    while(1)
    {
    //Serielle Schnittstelle einrichten
    UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );
    UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
    // Frameformat = 8 Bit
    UCSRC=(1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
    //Datenrichtungsregister
    DDRA = 0x00;            //alles eingänge
    DDRB = 0b10111111;          //Alles Ausgänge ausser PB6
    DDRC = 0x00;            //alles Eingänge
    DDRD = 0b11100010;    
    
    PORTD = 0b00000000;          //schiberegister und CS von A/D Wandler auf ON 
    
    UCSRB = (1 << TXEN)|(1 << RXEN);  // Setzt TXEN und RXEN Bit= Transmitter Enable Reciver enable
    
    //SPI EINRICHTEN
    SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<CPHA); //SPI ENABLE,MASTER, set clock rate fck/16,fallende Taktflanke = einlesen
    SPSR = (1<<SPI2X);                // Douple speed aktivieren
    PORTB |= (1<<PB4)|(1<<PB1)|(1<<PB2) ;      //Setze PB4 auf 1 CONV von A/D Wandler PB1&2 = S-ram disabled
    
    SPDR=213;    //Dummy Daten senden
    
    //Interrupt Eingänge Encoder
    MCUCR = (1<<ISC00)|(1<<ISC11)|(1<<ISC10);    // ISC00 auf 1 = jede änderung an INT 0 lösst einen Interrupt aus 
                            // ISC11&10 auf 1 = positivie Flanke INT 1 lösst Interrupts aus
    status = 0 ;
    senden = 0b00000110;
    counter=0;
    while (1)              // unentliche schleife
    {    
    switch(status)
      {
      case 0: uartempfangen();break;          // warten bis LABVIEW bereit
      case 1: startmotor();break;            //Motor starten beginne Messung nach Z Impuls
      case 2: statussend();break;            //nichts machen warte auf Z impuls
      case 3: statussend();break;            //nichts machen warte auf Messung= fertig
      case 4: auslesen();break;            //auslesen des s-rams Senden auf schnitstelle
      case 5: shiftreg();break;            //irgendetwas auf den I/O Pins anzeigen
      default: status=0;break;            //default = neustart        
      }      

    }
  }
    return 0;    
}

[Karl H. (kbuchegg)]

digitalespannung schrieb:

> 1. Status= 0 -> Warten auf irgendein Zeichen vom UART.
> 2. Status= 1 -> Starte Motor.
> 3. Status= 3 -> Warte auf Positive Flanke an INT1 Pin.
> 4. Status= 4 -> Messe bei Pegeländerung an INT0 Pin.
> 5. usw.
>
> Nun zu meiner Frage:
> Beim Status 3 und 4 macht der Controller nichts anderes als auf einen
> Interrupt zu warten.
>
> In dieser Zeit wollte ich eigentlich eine leere Schlaufe aufrufen oder
> eine Schleife mit einem Delay. Das funktioniert allerdings nicht weill
> dann anscheinend die Interrupts nicht mehr aufgerufen werden.

Wozu dann der ganze Interrupt-Käse?

Mach eine Schleife, in der der Pin abgefragt wird, und wenn sich der 
Pegel ändert, dann hast du dein Ereignis. Dazu braucht man keinen 
Interrupt.

Interrupt und warten, das beißt sich. Interrupts machen nur Sinn, wenn 
das Programm in der Zwischenzeit etwas völlig anderes macht (oder wenn 
man, wie beim Input Capture zyklengenau arbeiten muss).

[Karl H. (kbuchegg)]

ISR (INT0_vect)
{
  uint8_t werth;            // Speicher für A/D Wert high
  uint8_t wertl;            //Speicher für A/D Wert low
  
  tmp_sreg = SREG;      //SREG sichern

Lass das SREG in Ruhe.
Du programmierst nicht in C, damit du dich um Kleinkram wie SREG 
Register sichern, oder überhaupt Register sichern kümmern muss. Das 
alles geht dich nichts mehr an. Dazu hast du deinen C-Compiler.

Aber eigentlich ist der ganze Ansatz mit den Interrupts schon Käse, wenn 
du sowieso auf die jeweilige Flanke aktiv warten musst. Das 
verkompliziert dein Programm einfach nur deutlich (und eröffnet 
Potential für alle möglichen Sorten von Fehlern), ohne dass es dir auch 
nur irgendetwas bringt.


Schreib dir lieber ein paar Hilfsfunktion, wie zb zum Versenden eines 
Bytes per UART, oder zur ADC Abfrage. Davon hast du deutlich mehr.

[Ralf G. (ralg)]

digitalespannung schrieb:

 tmp_sreg = SREG;      //SREG sichern 
 
 SREG = tmp_sreg;      //SREG wider herstellen

nimm das mal schleunigst raus, ehe es jemand sieht!

Edit: schon zu spät.

[Dietrich L. (dietrichl)]

Was ich auf die Schnelle sehe:

uint8_t status;            //status des Programms

muss "volatile" sein, da es in "main" und einer ISR benutzt wird.

[Ralf G. (ralg)]

- 'while(1)' um 'while(1)' drumherum?

digitalespannung schrieb:
> _delay_ms(0.005);          //CONVERTIERUNG max 5 mikro sekunden
Das geht?

[digitalespannung (Gast)]

Karl Heinz Buchegger schrieb:
> ISR (INT0_vect)
> {
>   uint8_t werth;            // Speicher für A/D Wert high
>   uint8_t wertl;            //Speicher für A/D Wert low
>
>   tmp_sreg = SREG;      //SREG sichern
>
> Lass das SREG in Ruhe.
> Du programmierst nicht in C, damit du dich um Kleinkram wie SREG
> Register sichern, oder überhaupt Register sichern kümmern muss. Das
> alles geht dich nichts mehr an. Dazu hast du deinen C-Compiler.
>
> Aber eigentlich ist der ganze Ansatz mit den Interrupts schon Käse, wenn
> du sowieso auf die jeweilige Flanke aktiv warten musst. Das
> verkompliziert dein Programm einfach nur deutlich (und eröffnet
> Potential für alle möglichen Sorten von Fehlern), ohne dass es dir auch
> nur irgendetwas bringt.
>
> Schreib dir lieber ein paar Hilfsfunktion, wie zb zum Versenden eines
> Bytes per UART, oder zur ADC Abfrage. Davon hast du deutlich mehr.

Okey man sieht meinem Code wohl an das ich vorher in assembler 
programmiert habe. ;)

Alles unter INT0 ist ein auslesen eines A/D Wandlers mit SPI und das 
Ergebnis in ein S-Ram zu speichern.

Die positive Flanke an INT1 aktiviert und deaktiviert die Messung 
wieder.

Die Funktion auslesen lisst das S-Ram wider aus und sendet die Daten 
über die Schnitstelle.

[Karl H. (kbuchegg)]

Summa summarum würde ich sagen:
Du hast dich da mit deiner komplexen Ablaufsteuerung einfach selbst 
ausgetrickst. Das alles ist deutlich komplizierter, nicht zuletzt durch 
die Interrupts, als es sein müsste.
Deine Problemstellung hat eine recht klare Reihenfolge in der Aktionen 
passieren müssen. Das kann man ganz problemlos ohne Statemachine und 
ohne Interrupts runterprogrammieren.

Das Geflecht aus
* Hochzählen der Status-Variablen in den einzelnen Funktionen und
  in der ISR
* Welche Interrupts sind wann aktiviert
* Was passiert mit durch die Interrupt Flags gespeichertn Interrupts

ist recht undurchdringlich, so dass es nicht so einfach ist, das alles 
auseinanderzudröseln, in welcher Reihenfolge was wann passiert.

[Karl H. (kbuchegg)]

Dir scheint nicht klar zu sein, dass es je nach Anwendung nicht genügt, 
die Interrupts einfach zu deaktivieren.

Wenn in der Phase, in der die Interrupts deaktiviert sind, ein 
entsprechender Puls in der Zwischenzeit eintrifft, dann wird der 
REGISTRIERT, indem ein entsprechendes Bit gesetzt wird!
Aktivierst du danach die Interrupts wieder, dann kriegst du aufgrund 
dieser gespeicherten Registrierung SOFORT einen entsprechenden Aufruf 
der ISR!

Wenn du also darauf aus bist, dass ein entsprechender Puls am Eingang 
nur dann registriert wird, NACHDEM du den zugehörigen Intertup aktiviert 
hast, dann MUSST du sicherheitshalber diese Registrierungs-Bits auf 
jeden Fall löschen!

[digitalespannung (Gast)]

Karl Heinz Buchegger schrieb:
> Dir scheint nicht klar zu sein, dass es je nach Anwendung nicht
> genügt,
> die Interrupts einfach zu deaktivieren.
>
> Wenn in der Phase, in der die Interrupts deaktiviert sind, ein
> entsprechender Puls in der Zwischenzeit eintrifft, dann wird der
> REGISTRIERT, indem ein entsprechendes Bit gesetzt wird!
> Aktivierst du danach die Interrupts wieder, dann kriegst du aufgrund
> dieser gespeicherten Registrierung SOFORT einen entsprechenden Aufruf
> der ISR!
>
> Wenn du also darauf aus bist, dass ein entsprechender Puls am Eingang
> nur dann registriert wird, NACHDEM du den zugehörigen Intertup aktiviert
> hast, dann MUSST du sicherheitshalber diese Registrierungs-Bits auf
> jeden Fall löschen!

Stimmt! Das habe ich vergessen. Ich muss INTF1 & 2 noch auf 1 setzen um 
die Bits zu löschen.

[digitalespannung (Gast)]

Dietrich L. schrieb:
> Was ich auf die Schnelle sehe:uint8_t status;            //status
> des Programms
> muss "volatile" sein, da es in "main" und einer ISR benutzt wird.

Danke! Ich habe jetzt status und counter volatile gemacht.
Jetzt funktioniert es auch mit einer leeren Schleife. Ich habe es so 
programmiert damit ich evt. noch etwas erledigen kann dort wo jetzt ein 
leerlauf ist.