Processing‎ > ‎

Zeitmessung

http://sites.prenninger.com/arduino-uno-r3/processing/zeitmessung

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-12-12

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************


                       Zeitmessung
Unser Rechner liefert uns stets die aktuellen Zeit- und Datumsinformationen, sofern sie korrekt eingestellt wurden.
Vielleicht wird die interne Uhr ja auch über einen Zeitserver synchronisiert, der seine Daten mithilfe von NTP (Network Time Protocol) im Internet zur Verfügung stellt.
Wir können mit bestimmten Funktionen von Processing aus auf diese Informationen zugreifen.

Die Funktionen zum Ermitteln der Zeitwerte lauten:
Für die Sekunde:  second();  
Für die Minute:    minute();
Für die Stunde:    hour();
   
Ein kleines Programm das uns die aktuelle Uhrzeit des PCs ins Nachrichtenfenster ausgibt.
Die nf-Funktion wurde verwendet, da die drei Funktionen bei Werten kleiner 10 lediglich eine Stelle ohne führende Null ausgeben.
Das sieht nicht ganz so schön aus, wenn die Zeit z.B. 9:10:4 statt wohlformatiert 09:10:04 lautet.
// Processing-Sketch: PC Uhrzeit im Nachrichtenfenster_1a.pde
// Font = Schrift frei skaliernbar
// Default Schrift SansSerif 12-pixel da Courier New Schrift am Rechner nicht vorhanden

void setup() {
   size(100, 100);
}

void draw() {
   int meineSekunde = second();
   int meineMinute = minute();
   int meineStunde = hour();
   String zeit = nf(meineStunde, 2);
   zeit += ":" + nf(meineMinute, 2);
   zeit += ":" + nf(meineSekunde, 2);
   println(zeit);
}


Anzeige der Zeit sowohl in üblicher als auch in binärer Form im Processing-Ausgabefenster



// Processing-Sketch: PC Uhrzeit im Grafik-Fenster_1a.pde
// Font = Schrift frei skaliernbar
// Default Schrift SansSerif 12-pixel wenn Segment7 Schrift am Rechner nicht vorhanden.

PFont font;
void setup() { 
   size(600, 200);
   font = createFont("Segment7", 96, true);
}

void draw() {

background(0);
   textAlign(CENTER);
   int meineSekunde = second();
   int meineMinute = minute();
   int meineStunde = hour();
   String zeit1 = nf(meineStunde, 2);
   zeit1 += ":" + nf(meineMinute, 2);
   zeit1 += ":" + nf(meineSekunde, 2);
   textFont(font, 90); fill(255);        // textFont(font, 48); fill(255);
   text(zeit1, width/2, height-100);     // text(zeit1, width/2, height/4);
   String zeit2 = dez2bin(meineStunde);
   zeit2 += ":" + dez2bin(meineMinute);
   zeit2 += ":" + dez2bin(meineSekunde);
   textFont(font, 28); fill(0, 255, 0);  //  textFont(font, 18); fill(0, 255, 0);
   text(zeit2, width/2, height-50);
}
String dez2bin(int a) {                  // Konvertiere dezimal nach binär
   String ergebnis = "";
   for(int i = 0; i < 8; i++)
     ergebnis = ((a >> i) & 1) + ergebnis;
   return ergebnis;
}




Anzeige der Millisekunden seit Programmstart



Die Funktion zur Umwandlung von Integerzahlen in Binärzahlen.
Kommen wir jetzt zu einer Funktion, die die Zeit in Millisekunden, also 1/1000-Sekunden angibt.
Diese Zeit wird immer hochgezählt, sobald das Programm gestartet ist.
Mit dem folgenden Code lassen wir die Millisekunden kontinuierlich anzeigen, wobei die Anzeige durch einen Tastendruck eingefroren wird.
Vorher mit der Maus in das Ausgabefenster klicken ! ! !  
Das bedeutet jedoch nicht, dass das Hochzählen der Millisekunden dadurch ebenfalls unterbrochen wird.
Im Hintergrund wird fleißig weiter inkrementiert.
Bei einem erneuten Tastendruck werden die aktuellen Millisekunden seit Programmstart wieder angezeigt.              
Die Anzeige der Millisekunden ist wirklich schnell, und es ist fast unmöglich, die letzten drei Ziffern genau auszumachen.

// Processing-Sketch: Millisekunden seit Programmstart_1a.pde
// Font = Schrift frei skaliernbar
// Default Schrift SansSerif 12-pixel wenn Segment7 Schrift am Rechner nicht vorhanden.

PFont font;
boolean flag = true;
void setup() {
  size(600, 180);
   font = createFont("7 SEGMENTAL DIGITAL DISPLAY", 48, true);
   textFont(font, 150);
}


void draw() {
   background(100);  // Hintergrund grau
   textAlign(CENTER);
   int meineMillisekunde = millis();
   text(meineMillisekunde, width/2, height/1.2);
} 
void keyPressed() {    flag = !flag;     // Flag invertieren    if(flag)       loop();    else      noLoop(); }

                         Reaktionstest


zu früh reagiert       Treffer     zu spät reagiert


Wie gut ist Ihre Wahrnehmung, wenn es darum geht, das Programm zu jeder vollen Sekunde zu stoppen, und wie viele Millisekunden sind Sie vom gesteckten Ziel entfernt?

Die Millisekunden seit Programmstart werden angezeigt.
Die Anzeige bleibt auf  Tastendruck stehen und auf einen erneuten Tastendruck läuft die Zeit weiter.
Ziel ist, das Programm dann zu stoppen, wenn ein glatter Sekundenwechsel auf genau 1ms stattgefunden hat.

Die Zeit-Abweichung wird in Form eines grünen Balkens angezeigt, wobei bei genauem Erreichen des Wertes (Millisekunden = 000) der Balken in der Mitte des Fensters zu finden ist.

Der grüne Balken zeigt an, daß Sie zu früh reagiert haben.
Die letzten drei Stellen der angezeigten Zahl stehen für die Millisekunden, die Zahl davor für die Sekunden.
Ich habe jetzt versucht, beim Wechsel von 3 auf 4 Sekunden  die Leertaste zu drücken, um nach Möglichkeit bei der Zahl 4000 zu stoppen.
Das bedeutet 4 Sekunden und 0 Millisekunden.
Leider habe ich den genauen Zeitpunkt um  verpasst, sprich: zu spät gedrückt. Der grüne Balken befindet sich rechts von der roten Markierung.
Hätte ich genau getroffen, stände der grüne Balken, der die Abweichung anzeigt, genau unter dem roten.
Je näher Sie also an der roten Markierung dran sind, desto besser ist Ihre Reaktion.
Der grüne Balken zeigt an, dass zu spät reagiert wurde.

Hben Sie exakt (auf 1ms) den Punkt erwischt, an dem die Millisekunden 000 sind, wird der grüne Balken zu einem gelben, undSie bekommst die  Anzeige  "Großartig!".
Sie  müssen halt viele Male probieren.



// Processing-Sketch: Reaktionstest alle Sekunden_1a.pde
// Font = Schrift frei skaliernbar
// Default Schrift SansSerif 12-pixel wenn Segment7 Schrift am Rechner nicht vorhanden.

PFont font;
boolean flag = true;
int meineMillisekunde = 0;
void setup() {
   size(1000, 250); smooth();
   font = createFont("Transponder AOE", 48, true);
   textFont(font, 110);
}


void draw() {
   background(0); 
   stroke(255, 0, 0); 
   strokeWeight(4);
   line(width/2, height/2 + 10, width/2, height/2 + 40);
   textAlign(CENTER);
   meineMillisekunde = millis();
   text(meineMillisekunde, width/2, height/2);
   stroke(255, 255, 255); 
   strokeWeight(2);
   line(0, height/2 + 65, width, height/2 + 65);
}


void zeigeLinie(int wert) {
strokeWeight(4); stroke(0, 255, 0); // grün
   if((wert > 0) && (wert <= 500)) 
     line(width/2 + wert, height/2 + 50, width/2 + wert, height/2 + 80);
   else if((wert >= 501) && (wert < 999)) 
      line(wert - width/2, height/2 + 50, wert - width/2, height/2 + 80);
   else if(wert == 0)  {     
     stroke(255, 255, 0);          // gelb bei Treffer
     line(width/2, height/2 + 50, width/2, height/2 + 80);
     text("Großartig", width/2, height - 20);
   }
}

void keyPressed() {
   flag = !flag;                   // Flag invertieren
   if(flag)
     loop();
   else  {
     noLoop();
    int ms = meineMillisekunde - (meineMillisekunde/1000) * 1000;
    zeigeLinie(ms);
   }
}




DIN A4 ausdrucken
*********************************************************

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








a
Comments