OCR0 und OCR2 mit 2 Tastern erhöhen

[Dom M. (dominic_h)]

Hallo,
mit den Timer0 und Timer2 des ATmega32 steuere ich, 2 Galvanometer an um 
einen Laserstrahl abzulenken. Den Atmega32 verwende ich mit dem 
Pollinboard.

****Kleine Erklärung*****

X-Achse: OCR0 von 0 bis 255 --> x1; bis x255; Definiert in "Namen.h"
Y-Achse: OCR2 von 0 bis 255 --> y1; bis y255; Definiert in "Namen.h"

OCR0 =  0 --> Punkt an der Projektionsfläche; links unten
OCR0 =  1 --> kleiner Strich, Zunahme von links nach rechts, bei +1;
OCR0 = 40 --> Strich fast komplette X-Achse
im Bereich größer 40 bis 220, nur minimale Zunahme oder Abnahme, kaum 
merklich. Logarithmische Zu- und Abnahme.
OCR0 221 bis 254 Strich Abnahme von links nach rechts
OCR0 =255 --> Punkt rechts unten.

Das selbe Verhalten gilt für die Y-Achse mit OCR2.
**************************

Nun habe ich mir ein kleines Testprogramm geschrieben, um zu jedem OCR0 
und OCR2 Wert die Spannung und den Strom messen zu können.

Bei Betätigung von Taste1 (PD2) erhöht sich der OCR0-Wert jeweils um den 
von mir vorgegebenen Wert.
Bei Betätigung von Taste2 (PD2) erhöht sich der OCR2-Wert jeweils um den 
von mir vorgegebenen Wert.

 **********************************************************************
 *  Test Programm, zur Überprüfung der X-Achsen und Y-Auslenkung    
 *                                    
 *  x0 bis x255 OCR0 Werte von Timer0 für die X-Achse          
 *  y0 bis y255 OCR2 Werte von Timer2 für die Y-Achse, ab Line 1000    
 *                                    
 *  d1 entspricht delay von 15ms                    
 *  d2 entspricht delay von 50ms                    
 *  Werte können in "Namen.h" abgeändert werden              
 *                                    
 ************************************************************************
*/ 
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include "Namen.h"

#define Wartepin  PIND
#define Wartebit  PD2 //Taste 1                        
#define Wartebit2 PD3 //Taste 2                        


int main(void)
{                  
DDRB |=(1<<PB3);   //PB3 als Ausgang                        
DDRD |=(1<<PD7);   //PD7 als Ausgang                        
  
  
OCR0 = 0;          //Start-Wert bei 0,  X-Achse                      
OCR2 = 0;          //Start-Wert bei 0,  Y-Achse                            

//Timer0 Phase Correct PWM /set OC0 on Comp Mat when up, clear when down //Prescaler 64  
TCCR0 |=(1<<WGM00)|(1<<COM01)|(1<<CS01)|(1<<CS00);

//Timer2 Phase Correct PWM /set OC2 on Comp Mat when up, clear when down //Prescaler 64         
TCCR2 |=(1<<WGM20)|(1<<COM21)|(1<<COM20)|(1<<CS22);
        
while(1)
  {
  loop_until_bit_is_set(Wartepin, Wartebit);                
    
    while((Wartepin & (1<<Wartebit)));  //warte auf Taste1                  
    {
      x0;d2;  //
    }
    while((Wartepin & (1<<Wartebit)));                    
    {
      x1;d2; // 
    }
    while((Wartepin & (1<<Wartebit)));                    
    {
      x2;d2; //
    }
//usw.........
    while((Wartepin & (1<<Wartebit2)));     //warte auf Taste2                    
    {
      y0;d2;  //
    }
    while((Wartepin & (1<<Wartebit2)));                    
    {
      y1;d2; // 
    }
    while((Wartepin & (1<<Wartebit2)));                    
    {
      y2;d2; //
    }
//usw..........
  }
}

Jetzt ist es aber so, dass ich erst alle X-Werte mit Taster 1 
durchdrücken muss, bevor ich mit Taster 2 die Y-Werte ändern kann.

Gedacht hatte ich mir es so, dass ich zB. Taster1 5mal drücke, dann 
Taster2 2mal. Und somit dann bei x4; und y1; bin. Und wenn ich Taster1 
noch 3mal und Taster2 10mal drücke ich x7; und y11; erhalte.

Bin leider gerade etwas ratlos, in der Schule konnte mir auch niemand 
helfen und das Internet hat mich auch nicht weiter gebracht.

[Karl H. (kbuchegg)]

Dom M. schrieb:

> Jetzt ist es aber so, dass ich erst alle X-Werte mit Taster 1
> durchdrücken muss, bevor ich mit Taster 2 die Y-Werte ändern kann.

Logisch.
Du hast ja auch überall lauter

    while((Wartepin & (1<<Wartebit)));  //warte auf Taste1

drinnen.

> Bin leider gerade etwas ratlos, in der Schule konnte mir auch niemand
> helfen und das Internet hat mich auch nicht weiter gebracht.

Nicht?

Hier die Quintessenz.
Du musst deine Denkweise umstellen.
Deine Denkweise darf nicht sein

Ich warte darauf dass etwas passiert

sondern deine Denkweise muss sein

  while( 1 ) {

    wenn taste 1 gedrückt wurde, dann
      mache etwas

    wenn taste 2 gedrückt wurde, dann
      mache was anderes

    wenn taste 3 gedrückt wurde, dann
      ....
  }

mit anderen Worten. Du prüfst reihum und laufend ob irgendein Ereignis 
eingetreten ist, auf das du reagieren musst. Bei dir zum Beispiel ist es 
dann eben das eine Taste gedrückt wurde und die Reaktion darauf ist, ein 
OCR Register zu erhöhen oder erniedrigen.

Man nennt das 'Event getriebenes Programmieren'. Das Auftreten eines 
Ereignisses löst eine Reaktion im Programm aus. Dein µC Programm prüft 
reihum viele tausend male pro Sekunde, ob irgendeines der möglichen 
Ereignisse eingetreten ist. Und weil dein µC das viele tausend male pro 
Sekunde kann, kommt es dir als langsamen Mensch so vor, als ob die 
Reaktion sofort erfolgt wäre. Aber: die Ereignisse können bunt gemischt 
auftretem und trotzdem wird jedesmal der entsprechende Zweig in deinem 
Programm ausgeführt. Du als Programmierer musst dann eben dafür sorgen, 
dass diese Reaktionen auch korrekt sind, wenn es da Abhängigkeiten 
zwischen den Reaktionen gibt.