Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
timer [2019/01/29 16:56]
huwi [Videozusammenfassung]
timer [2019/07/27 16:44] (aktuell)
huwi
Zeile 2: Zeile 2:
 Die Applikation verfügt durch die Basisklasse //​AppKernel//​ bereits über einen Timer. Für den Applikations-Timer wird in der Regel der einfachste Timer also Timer0 verwendet. Dieser wird durch den //​AppKernel//​ so initialisiert,​ dass er das System möglichst genau mit 10 Millisekunden //​triggert//​. Das Triggersignal,​ welches der Timer-Interrupt auslöst wird an die Applikation und alle Applikationsmodule als **onTimer-Nachricht** verteilt. Vergleichen Sie dazu die folgende Darstellung. Die Applikation verfügt durch die Basisklasse //​AppKernel//​ bereits über einen Timer. Für den Applikations-Timer wird in der Regel der einfachste Timer also Timer0 verwendet. Dieser wird durch den //​AppKernel//​ so initialisiert,​ dass er das System möglichst genau mit 10 Millisekunden //​triggert//​. Das Triggersignal,​ welches der Timer-Interrupt auslöst wird an die Applikation und alle Applikationsmodule als **onTimer-Nachricht** verteilt. Vergleichen Sie dazu die folgende Darstellung.
  
->>>​{{:​apptimer.jpg?​400|}}+>​{{:​apptimer.jpg?​400|}}
  
 Es ist deutlich zu sehen, dass die Nachrichten //​onTimer10ms//,​ //​onTimer100ms//​ und //​onTimer1s//​ aus der Interruptverarbeitung heraus gesendet werden. Das bedeutet für den Programmierer,​ der diese Nachrichten verarbeitet,​ dass er immer nur kurze Anweisungsfolgen und niemals Warteschleifen oder Unendlichschleifen bzw. [[http://​de.wikipedia.org/​wiki/​Polling_(Informatik)|Polling]] in die //​onTimer-Nachrichten//​ programmieren darf. Als Programmierer der Applikation kann man sich durch [[http://​de.wikipedia.org/​wiki/​%C3%9Cberschreiben_(OOP)|überschreiben]] der Operationen an diese Nachrichten "​ranhängen"​. Das geschieht, indem man die zu überschreibende Operation exakt so notiert wie diese in der Basisklasse formuliert wurde. Das sind für die Timer-Nachrichten die Operationen:​ Es ist deutlich zu sehen, dass die Nachrichten //​onTimer10ms//,​ //​onTimer100ms//​ und //​onTimer1s//​ aus der Interruptverarbeitung heraus gesendet werden. Das bedeutet für den Programmierer,​ der diese Nachrichten verarbeitet,​ dass er immer nur kurze Anweisungsfolgen und niemals Warteschleifen oder Unendlichschleifen bzw. [[http://​de.wikipedia.org/​wiki/​Polling_(Informatik)|Polling]] in die //​onTimer-Nachrichten//​ programmieren darf. Als Programmierer der Applikation kann man sich durch [[http://​de.wikipedia.org/​wiki/​%C3%9Cberschreiben_(OOP)|überschreiben]] der Operationen an diese Nachrichten "​ranhängen"​. Das geschieht, indem man die zu überschreibende Operation exakt so notiert wie diese in der Basisklasse formuliert wurde. Das sind für die Timer-Nachrichten die Operationen:​
Zeile 11: Zeile 11:
 Damit ist es sehr einfach möglich, zyklische Aufgaben in genauen Zeitabständen durchzuführen. Das Blinken einer LED ist solch eine zyklische Aufgabe. Diese wurde zuvor dadurch gelöst, dass innerhalb der Operation //onWork// die Zeitabstände für das Umschalten der LED durch Wartefunktionen realisiert wurden. Das ist zwar einfach zu Programmieren und auch einfach zu verstehen, aber gleicht einer Autofahrt mit angezogener Handbremse. Denn Wartefunktionen sind Schleifen, die solange nichts tun, bis die geforderte Zeit um ist. Es wird also Prozessorzeit (Leistung) vergeudet. Der Timer läuft absolut autonom. Während dieser vor sich hin zählt, kann der Controller jede Menge anderer Aufgaben ohne Leistungsverlust ausführen. Wir sprechen hier bei 10 Millisekunden und 3,6864 Mhz von immerhin über 3600 Prozessortakten. Also gut und gerne 3000 Assemblerbefehlen,​ die in der Zeit vom AVR ausgeführt werden. Das sind dann im Übrigen vor allem die Anweisungen in der Operation //onWork//. Für die folgende Übung verbinden Sie Port B Bit 0 mit der roten LED.  Damit ist es sehr einfach möglich, zyklische Aufgaben in genauen Zeitabständen durchzuführen. Das Blinken einer LED ist solch eine zyklische Aufgabe. Diese wurde zuvor dadurch gelöst, dass innerhalb der Operation //onWork// die Zeitabstände für das Umschalten der LED durch Wartefunktionen realisiert wurden. Das ist zwar einfach zu Programmieren und auch einfach zu verstehen, aber gleicht einer Autofahrt mit angezogener Handbremse. Denn Wartefunktionen sind Schleifen, die solange nichts tun, bis die geforderte Zeit um ist. Es wird also Prozessorzeit (Leistung) vergeudet. Der Timer läuft absolut autonom. Während dieser vor sich hin zählt, kann der Controller jede Menge anderer Aufgaben ohne Leistungsverlust ausführen. Wir sprechen hier bei 10 Millisekunden und 3,6864 Mhz von immerhin über 3600 Prozessortakten. Also gut und gerne 3000 Assemblerbefehlen,​ die in der Zeit vom AVR ausgeführt werden. Das sind dann im Übrigen vor allem die Anweisungen in der Operation //onWork//. Für die folgende Übung verbinden Sie Port B Bit 0 mit der roten LED. 
  
->>>​{{:​uebung1.jpg?​300|}}+>​{{:​uebung1.jpg?​300|}}
  
 Legen Sie jeweils immer ein neues kleines Programm an. Überprüfen Sie die Spracheinstellungen für AVR C++ und die Controllereinstellungen für den ATmega8. Laden Sie die Grundstruktur einer AVR C++ Anwendung. Es ist die Methode **onTimer1s** zu überschreiben und in dieser das Umschalten der LED zu programmieren. Legen Sie jeweils immer ein neues kleines Programm an. Überprüfen Sie die Spracheinstellungen für AVR C++ und die Controllereinstellungen für den ATmega8. Laden Sie die Grundstruktur einer AVR C++ Anwendung. Es ist die Methode **onTimer1s** zu überschreiben und in dieser das Umschalten der LED zu programmieren.
Zeile 17: Zeile 17:
 Das Konzept: Das Konzept:
  
->>><​code cpp>+><​code cpp>
 /////////////////////////////////////////////////////////////////////​ /////////////////////////////////////////////////////////////////////​
 // Blinklicht 2 ENTWURF // Blinklicht 2 ENTWURF
Zeile 44: Zeile 44:
 Die Realisierung:​ Die Realisierung:​
  
->>><​code cpp>+><​code cpp>
 /////////////////////////////////////////////////////////////////////​ /////////////////////////////////////////////////////////////////////​
 // Blinklicht 2 // Blinklicht 2
Zeile 69: Zeile 69:
 </​code>​ </​code>​
  
->>>​{{:​blinken2.jpg?​300|}}+>​{{:​blinken2.jpg?​300|}}
  
 Kompilieren,​ linken und übertragen Sie die Anwendung auf den Controller. Die LED blinkt jetzt sehr langsam, übrigens mit 0,5 Hz ( 1s = 1 Halbzyklus, 2s = voller Zyklus). Damit diese schneller blinkt, bietet es sich an die Operation **onTimer100ms** zu überschreiben. Das ist dann 10 mal so schnell, also 5 Herz. Kompilieren,​ linken und übertragen Sie die Anwendung auf den Controller. Die LED blinkt jetzt sehr langsam, übrigens mit 0,5 Hz ( 1s = 1 Halbzyklus, 2s = voller Zyklus). Damit diese schneller blinkt, bietet es sich an die Operation **onTimer100ms** zu überschreiben. Das ist dann 10 mal so schnell, also 5 Herz.
  
->>>​{{:​fuenfherz.jpg|}}+>​{{:​fuenfherz.jpg|}}
  
 Die //​onTimer-Nachrichten//​ stehen mit 10, 100 und 1000 Millisekunden nur in einem recht beschränktem Raster zur Verfügung. Dem ist mit recht einfachen Mitteln Abhilfe zu schaffen. Durch das Anlegen einer eigenen Zählvariable können wir auf der Basis der drei Timer-Nachrichten fast jeden beliebige Abstufung realisieren. Die nächste Übung soll die LED mit genau 1 Herz blinken lassen. Dazu ist die Operation //​onTimer1s//​ nicht geeignet, deshalb benutzen wir die Nachricht //​onTimer100ms//​ und zählen einfach bis fünf ( 5*100 ms = 0,5 s Halbzyklus = 1 s der ganze Zyklus). ​ Die //​onTimer-Nachrichten//​ stehen mit 10, 100 und 1000 Millisekunden nur in einem recht beschränktem Raster zur Verfügung. Dem ist mit recht einfachen Mitteln Abhilfe zu schaffen. Durch das Anlegen einer eigenen Zählvariable können wir auf der Basis der drei Timer-Nachrichten fast jeden beliebige Abstufung realisieren. Die nächste Übung soll die LED mit genau 1 Herz blinken lassen. Dazu ist die Operation //​onTimer1s//​ nicht geeignet, deshalb benutzen wir die Nachricht //​onTimer100ms//​ und zählen einfach bis fünf ( 5*100 ms = 0,5 s Halbzyklus = 1 s der ganze Zyklus). ​
  
 Ein neues Programm anlegen und das Konzept als Kommentare eintragen. Ein neues Programm anlegen und das Konzept als Kommentare eintragen.
->>><​code cpp>+ 
 +><​code cpp>
 /////////////////////////////////////////////////////////////////////​ /////////////////////////////////////////////////////////////////////​
 // Blinklicht 4 ENTWURF // Blinklicht 4 ENTWURF
Zeile 113: Zeile 114:
 Danach die entsprechenden Befehle eingeben. Danach die entsprechenden Befehle eingeben.
  
->>><​code cpp>+><​code cpp>
 /////////////////////////////////////////////////////////////////////​ /////////////////////////////////////////////////////////////////////​
 // Blinklicht 4 // Blinklicht 4
Zeile 151: Zeile 152:
  
 ====== Videozusammenfassung ====== ====== Videozusammenfassung ======
->>><​html><​iframe width="​700"​ height="​550"​ src="​https://​www.youtube.com/​embed/​5CNqu3IYTUs"​ frameborder="​0"​ allow="​accelerometer;​ autoplay; encrypted-media;​ gyroscope; picture-in-picture"​ allowfullscreen></​iframe></​html>​+><​html><​iframe width="​700"​ height="​550"​ src="​https://​www.youtube.com/​embed/​5CNqu3IYTUs"​ frameborder="​0"​ allow="​accelerometer;​ autoplay; encrypted-media;​ gyroscope; picture-in-picture"​ allowfullscreen></​iframe></​html>​
  
 ====== Nächstes Thema ====== ====== Nächstes Thema ======