2 Zeitberechnungen mit ATMEGA8

[Markus V. (darkangel)]

Hallo,

ich will mit einem MEAG8 und GCC ein Programm schreiben, das mir 
folgendes Erledigt:

Eingänge: Lichtschranke 1 (LS1)--> PD2(INT0)
          Lichtschranke 2 (LS2)--> PD3(INT1)
Ausgang über RxD und TxD(UART) zum PC, dort läuft ein Delphiprogramm ab 
das die daten auswerten soll.

Programm:
1. Nach einem Signal vom PC (logische 1 würde reichen) soll die 
Zeitmessung starten
2. Und mit der neg. Flanke(da aktive low eingang) den Timer stoppen und 
die Zeit ausgeben an den PC über UART. (Zeit < 60sec.; allerdings wäre 
die Genauigkeit im 10ms Bereich nötig)
3. Eine weitere Zeitmessung, die die Zeit zwischen der LS1 und LS2 
ausgibt(wieder neg. Flanke; Zeit < 10sec.; Genauigkeit im 1ms Bereich) 
Diese Zeit ebenfalls weder ausgeben
4. Dann wieder alles zum Anfang und auf das Signal vom PC warten.

---
Eins wär noch erwünschensert:
Eine Überwachung, ob der Microcontroller noch aktiv und verbunden ist. 
Ich dachte mir evtl. ein Signal das alle 5-10sec. an den PC gesendet 
wird.


Jetzt meine Fragen:

Ist es möglich gwasi 2 Timer zu betreiben(nach dem ende des ersten den 
zweiten sofort starten, ohne aber auf die auswertung zu warten, weil 
sonst würde ja diese Zeit verloren gehen)?

Wer hat eine Idee für die Überwachung ob alles noch in Ordung ist oder 
eine Vorschlag wie ich die Idee von mir umsetzten könnte?


Vielen Dank
Mit freundlichen Grüßen
Markus

[Matthias L. (Gast)]

>gwasi 2 Timer zu betreiben

Ich würde einen 16bit Timer durchlaufen lassen. Mit den Ereignissen dann 
den aktuellen Zählerstand auslesen und danach ne Berechnung durchführen.

>berwachung ob alles noch in Ordung
Zum Beispiel alle 1sek. ein Byte zum PC senden. (Die Zeitbasis kann mit 
über denselben Timer gemacht werden => OVerflow)

[Markus V. (darkangel)]

Könnte mir mal jemand einen kleinen Aneiz geben, wie ich die ganze Sache 
angehen könnte.

Wie starte ich einen interrupt, oder geht das bei dem Eingang 
automatisch?`

WIe mache ich das mit der Bedingung, dass erst ein Signal vom PC kommen 
muss?

Die wird der Timer programmiert?

[Matthias L. (Gast)]

Oh Mann...

Ich würd sagen, du liest dir mal das Datenblatt und das Tutorial hier 
duch..


PS: Aus welchem PLZ-Bereich bist du?

[Markus V. (darkangel)]

Was meinst du was ich die ganze zeit mache. Ich komme nur sehr mühsam 
voran und darum hätte ich gehofft, dass mit jemand von euch ein wenig 
hilft. Ihr könnt das sicher auswendig, aber ich muss alles nachlesen und 
weiß noch nichteinmal genau wo was steht.

Wieso willst du meine PLZ wissen?

[Markus V. (darkangel)]

Soweit bin ich schon gekommen. Aber wie kann ich den Timer 
programmieren, im Tutorial ist es auch nicht so schön erklärt.
Welche Variable enthält den Gezählten Wert?
Muss ich den Prescaler so dimensonieren, dass mein Zählwert definitiv in 
den 65... Schritten liegt oder kann ich auch die Overflows zählen 
lassen?

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

#define FOSC 7372800
#define BAUD 19200
#define MYUBRR (FOSC/16/BAUD-1)

#define INTO_vect LS1
#define INT1_vect LS2


volatile uint16_t LS_1;
ISR(INT0_vect)                /* Interrupt INT0 --> LS1 */
{
    LS_1++;   
}

volatile uint16_t LS_2;
ISR(INT1_vect)                /* Interrupt INT1 --> LS2 */
{
    LS_2++;   
}

int time (void) {
   sei();        /* Global Interrupt Enable */

   TCCR1B = (1<<CS12);            /* Clock Set Bits auf CPU-Takt / 256 */
}

int main (void) {            
 
// Ein/Ausgänge
   DDRD |= (1<<DDD2) | (1<<DDD3);          /* Lichtschrankeneingänge */

// Bluetooth-Übertragung   
   UCSRB |= (1<<TXEN) | (1<<RXEN);  /* UART Tx und Rx einschalten */
   UCSRC |= (1<<URSEL) | (3<<UCSZ0);       /* Asynchron */

   UBRRH = MYUBRR >> 8;            /* Buadatenragister setzen */
   UBRRL = MYUBRR & 0xFF;

// Interrupt
   GIMSK |= (1<<INT0) | (1<<INT1);  /* Flankenerkennung am INT Eingang*/
   MCUCR |= (1<<ISC11) | (1<<ISC01);  /* fallende Flanke erzeugt Interrupt */
   GICR |= (1<<INT0) | (1<<INT1);      

   sei();        /* Global Interrupt Enable */

   TCCR1B = (1<<CS12);            /* Clock Set Bits auf CPU-Takt / 256 */

   while(1) {               
  
   while (!(UCSRA & (1<<UDRE))) {  /* warten bis Senden möglich ist */
                    /* Variablen die Gesendet werden sollen */          
   }

   UDR = 'x';                /* schreibt auf Schnittstelle */
   }                        
 
   /* wird nie erreicht */
   return 0;

[Peter D. (peda)]

Am besten, Du nimmst Dir erstmal Papier und Bleistift und machst nen 
Ablaufplan.

Und dann den Plan stur der Reihe nach in Code umsetzen.
Interrupts würde ich dafür keine verwenden, das machts nur unnötig 
kompliziert.
Einfach an der Stelle in ner while-Schleife pollen.

Und pappe nicht alles als Spaghetticode hintereinander, bis niemand mehr 
durchsieht.
Sondern teile es in Unterfunktionen auf, z.B.:

uart_init
send_byte
receive_byte
timer_start
timer_read
poll_ls1
poll_ls2

usw.

Peter

[Matthias L. (Gast)]

>Wieso willst du meine PLZ wissen?

Es ist umständlich alles über das Formu zu erklöären..

Hast du ICQ? dann schreib mir mal ne PM