Stoppuhr

http://sites.prenninger.com/arduino-uno-r3/stoppuhr

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                        Wels, am 2019-08-02

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-stoppuhr (xx Seiten)_1a.pdf





AZ-Delivery Praxisprojekt

Aus Buch ARDUINO KOMPENDIUM
8.1 Stoppuhr mit OLED-Display Seite 198 bis 203

8.1 Stoppuhr mit OLED-Display
In dieser E-Mail wollen wir Ihnen vorstellen, wie Sie eine Stoppuhr mit einem OLED-Display programmieren können.
Um die Bedienung möglichst einfach zu halten, soll ein einziger Taster genügen.
Der erste Druck startet die Zeitmessung, der zweite stoppt die Uhr und das Ergebnis wird auf Tausendstelsekunden genau angezeigt.

So soll die Displayausgabe der fertigen Stoppuhr aussehen.

Für die Messung können wir uns die bereits bekannte Funktion millis() zu Nutze machen.
Ihr Rückgabewert ist die Anzahl der vergangenen Millisekunden (Tausendstelsekunden) seit Programmstart.
Diesen Wert können wir wie einen Zeitstempel benutzen. Speichern wir den Rückgabewert zum Zeitpunkt A und zum Zeitpunkt B, so können wir durch Differenzbildung die zwischen A und B vergangene Zeit in Millisekunden errechnen.
Dieser Wert lässt sich entsprechend aufbereiten (in Stunden, Minuten und Sekunden umrechnen) und ausgeben.

Versuchsaufbau
Der sehr einfache Versuchsaufbau erübrigt einen separaten Stromlaufplan. Wir benötigen:
1 kleines Breadboard (hier kaufen!)
1 Arduino UNO (hier kaufen!)
1 OLED-Display (SSD1306, 128x64 Pixel, I²C-Anschluss) (hier kaufen!)
1 Taster (hier kaufen!)
Verbindungsdrähte (hier kaufen!)


Alternativ kann das Display auch mit auf das Breadboard gesteckt werden.




Programmcode
Im folgenden Sketch sind kurze Kommentare wieder direkt im Programmcode eingefügt:

#define TASTE 3
#define MILLISPROSTUNDE 3600000 // Konstanten zur einfacheren
//Umrechnung
#define MILLISPROMINUTE 60000 // von Millisekunden in andere Einheiten
#include "Wire.h"
#include "Adafruit_SSD1306.h" // Bibliothek für das OLED-Display
Adafruit_SSD1306 display(1);
long Timer = 0; // nachfolgend: Hilfsvariablen zur
//Zeitmessung
long Startzeit = 0; // Zeitpunkt A
long Stoppzeit = 0; // Zeitpunkt B
long Zeitdifferenz = 0; // abgelaufene Zeit in Millisekunden
byte Stunden; byte Minuten; byte Sekunden; byte Tausendstel;
boolean aktiv = false; // Zeitmessung aktiv (true) oder angehalten (false)

void setup()
{
pinMode(TASTE, INPUT_PULLUP);
display.begin(SSD1306_SWITCHCAPVCC, 60); // Display-Initialisierung
display.clearDisplay();
display.setTextColor(WHITE); // Farbe weiß auswählen
}

void loop()
{
if(millis() > Timer) // (1)
{
if(aktiv) // (2)
Zeitdifferenz = millis()-Startzeit;
else
Zeitdifferenz = Stoppzeit-Startzeit;

Stunden = Zeitdifferenz / MILLISPROSTUNDE; // (3)
Minuten = (Zeitdifferenz % MILLISPROSTUNDE) / MILLISPROMINUTE;
Sekunden = (Zeitdifferenz % MILLISPROMINUTE) / 1000;
Tausendstel = Zeitdifferenz % 1000;

display.clearDisplay();
display.setTextSize(2);
display.setCursor(17,2);
display.println("Stoppuhr"); // Überschrift
display.drawLine(17,20, 110,20, WHITE); // Unterstreichung
display.setTextSize(1);
display.setCursor(40,30);

if(aktiv)
display.println("aktiv!");
else
display.println("Resultat:");

display.setCursor(30,50);
if(Stunden < 10) // (4)
display.print("0");
display.print(Stunden);
display.print(":");

if(Minuten < 10)
display.print("0");
display.print(Minuten);
display.print(":");

if(Sekunden < 10)
display.print("0");
display.print(Sekunden);

if(!aktiv) // Tausendstel nur anzeigen, wenn
{ // Zeitnahme angehalten wurde.
display.print(".");
if(Tausendstel < 100)
display.print("0");
if(Tausendstel < 10)
display.print("0");
display.print(Tausendstel);
}
display.display();

Timer = millis() + 1000; // nächste Displayaktualisierung in 1 Sek.
}
if(!digitalRead(TASTE)) // Wird gerade die Taste gedrückt?
{
if(aktiv)
{
Stoppzeit = millis();
aktiv = false;
Timer = 0;
}
else
{
Startzeit = millis();
aktiv = true;
Timer = 0;
}
while(!digitalRead(TASTE)); //warten, bis Taste wieder losgelassen wurde
}
}


1. Wie schon in Kapitel 6.4 nutzen wir zur Verzögerung auch hier eine Variable als Timer, anstatt per delay() das Programm anzuhalten.
Die nachfolgenden Anweisungen sorgen dafür, dass das Display aktualisiert wird. Es genügt, wenn dies einmal pro Sekunde geschieht.
Würde es bei jedem loop()-Durchlauf erneut aktualisiert, sähe man ein deutliches Flackern.
Die Timer-Variable wird daher immer am Ende der Displayaktualisierung auf einen Zahlenwert millis()+1000 gesetzt.
Die Funktion millis() allein erreicht diesen Wert erst eine Sekunde später, so dass der if-Block bei allen weiteren Programmdurchläufen innerhalb der nächsten Sekunde übersprungen wird.

2. Zeitdifferenz ist die Zeit, welche angezeigt wird. Bei aktiver (laufender) Stoppuhr ist es die Differenz zwischen der aktuellen Zeit und der Startzeit. Wurde die Zeitmessung bereits angehalten, ist es die Differenz zwischen Stoppzeit und Startzeit.

3. Die ermittelte Zeitdifferenz wird durch ganzzahlige Divisionen und Modulodivisionen (Divisionsrest, siehe Kapitel 4.11) in Stunden, Minuten, Sekunden und Tausendstel zerlegt. Darauf folgt die Textausgabe auf dem Display.

4. An mehreren Stellen im Sketch werden führende Nullen ausgegeben, wenn der entsprechende Wert kleiner als 10 ist.
Die übliche Schreibweise einer Zeit ist schließlich 10:04:09 und nicht 10:4:9.

Es sei noch erwähnt, dass dieser Sketch nur deshalb zuverlässig funktioniert, weil der Mikrocontroller die loop()-Schleife mehrere Zehntausend Male pro Sekunde durchläuft und somit auch quasi ständig der Zustand der Taste per if(!digitalRead(TASTE)) abgefragt wird.
Enthielte das Programm Befehle, welche die Abarbeitung deutlich verzögern (zum Beispiel delay() oder umfangreiche Bildschirmausgaben per Serial.print()) könnte es sein, dass dadurch ein Tastendruck nicht erkannt wird.
In der professionellen Programmierung behilft man sich in so einem Fall mit Interrupts, welche das Programm auf Hardware-Ebene unterbrechen können.

Resultat
Unsere selbstgebaute Stoppuhr ist fertig. Die Ausgabe auf dem Display sieht beispielhaft so aus:

Nach dem Ende der Zeitnahme werden auch die Nachkommastellen angezeigt.







DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE






Comments