Ich hab ein Problem. Ich will ein kleines Spiel bauen mit drei Lampen. Am Anfang geht eine von den drei lampen an und bleibg eine zufällige Zeit aus. Anschließend geht ein timer an, den man mit einem button stoppen kann. Aber jede lampe hat einen dazugehörigen Knopf. Am Ende geht eine Lampe an wenn man schneller als eine Sekunde den Knopf gedrückt hat.
danke für die hilfe
hier ist noch unser code der aber nicht funktioniert
// C++ code
void setup()
{
pinMode(11, OUTPUT);
pinMode(10, OUTPUT);
pinMode(9, OUTPUT);
Z1 = 0;
Z2 = 0;
Z3 = 0;
A = 0;
T = 0;
}
void loop()
{
A += random(1, 3 + 1);
if (A == 1) {
Z1 += random(1, 2 + 1);
digitalWrite(11, HIGH);
delay(500); // Wait for 500 millisecond(s)
digitalWrite(11, LOW);
if ( 6 == HIGH) {
T += T + 1;
}
if ( 6 == HIGH) {
T += T + 1;
}
if ( 6 == HIGH) {
T += T + 1;
}
if ( 6 == HIGH) {
T += T + 1;
}
if ( 6 == HIGH) {
T += T + 1;
}
delay(Z1); // Wait for Z1 millisecond(s)
}
if (A == 2) {
Z2 += random(1, 2 + 1);
digitalWrite(10, HIGH);
delay(500); // Wait for 500 millisecond(s)
digitalWrite(10, LOW);
delay(Z2); // Wait for Z2 millisecond(s)
if ( 7 == HIGH) {
T += T + 1;
}
if ( 7 == HIGH) {
T += T + 1;
}
if ( 7 == HIGH) {
T += T + 1;
}
if ( 7 == HIGH) {
T += T + 1;
}
if ( 7 == HIGH) {
T += T + 1;
}
}
if (A == 3) {
Z3 += random(1, 2 + 1);
digitalWrite(9, HIGH);
delay(500); // Wait for 500 millisecond(s)
digitalWrite(9, LOW);
delay(Z3); // Wait for Z3 millisecond(s)
if ( 8 == HIGH) {
T += T + 1;
}
if ( 8 == HIGH) {
T += T + 1;
}
if ( 8 == HIGH) {
T += T + 1;
}
if ( 8 == HIGH) {
T += T + 1;
}
if ( 8 == HIGH) {
T += T + 1;
}
}
if ( T == "1")
12 == HIGH;
} ```
Die Beschreibung ist sehr ungenau.
Eine Lampe geht an und ist eine Zeit aus?
Ein Timer geht an und tut nix, aber kann mit einer Taste gestoppt werden? Einer Stopptasste oder der Taste die zu jeder Lampe gehört?
Hallo Gruppe,
herzliche wilkommen im Arduino- Forum.
wenn es besonders schnell gehen soll
username schnell aber wahllos auf die Tastatur geklimpert
kurze und deshalb unpräzise Beschreibung
dann geht es in Wirklichkeit besonders laaaangsaaam.
Die Antwort auf die Frage: "Wie funktionieren Timer?"
lautet
"Man programmiert sie und dann benutzt man sie" zu der Antwort sagt ihr jetzt völlig zu recht "haha ha na jetz bin ich schlauer".
Auch die nächste Version hilft nicht weiter.
"Wenn man Tastenabfragen will während eine LED blinkt dann benutzt man millis()"
"Ja toll und was ist millis()???"
Eben. Mit zu wenig Information gibt's nur nachfragen.
Auf kurze Postings kommen keine konkreten Antworten sondern nachfragen nach den Details die man im Kurzposting glaubte weglassen zu können.
ihr arbeitet an einem Informatik-Projekt und was am meisten in einem Informatik-Projekt benötigt wird ist: Information.
Welchen Microcontroller benutzt ihr?
ungefähre Beschreibung wie viel Programmiererfahrung ihr habt.
ungefähre Beschreibung wie viel Ahnung ihr von Elektronik habt.
Die folgende Frage erscheint den meisten erst einmal sehr ungewöhnlich:
Wann muss das Projekt fertig sein?
Von Anfängern wird gnadenlos unterschätzt wie viel Zeit das Austesten eines Programmes braucht.
Und nach diesen Infos dann nochmal eine detaillierte Beschreibung in der alles genau und unterscheidbar benannt wird.
Lampe 1: L1
Lampe 2: L2
Lampe 3: L3
Taste 1: T1
Taste 2: T2
Taste 3: T3
Timer wie viele Timer? Nur einen oder mehrere ?
Und damit jetzt eine detaillierte Ablaufbeschreibung.
Hallo,
sehe ich ebenso , also erst mal da schlau machen, eventuell etwas anpassen.
Ansonsten auf die Frage "wie funktioniert ein Timer" solltest Du mal nach dem Nachtwächter suchen. (Ohne Link weil suchen)
Heinz
Dieses kleine Spiel hier vielleicht?
Die Idee dahinter:
Das Spiel startet mit anlegen der Betriebsspannung.
1 zufällige LED leuchtet für eine zufällige Zeit (derzeit zwischen 1 und fast 10 Sekunden) und geht aus
Wird in dieser Zeit eine Taste gedrückt, wird erneut gestartet; dies verhindert, das jemand auf der Taste drückt, während die LED leuchtet und schummelt
Die Auszeit ist als Reaktionszeit vorgegeben.
wird innerhalb der Reaktionszeit der richtige Button gedrückt, blinkt die dazu gehörige LED
Alternative1: wird ein falscher Taster gedrückt Oder
Alternative2: wird in der Reaktionszeit kein Taster gedrückt, blinken ALLE LED's als Fehleranzeige
Danach kurze Pause - Alle LED's aus.
Und dann satrtet das Spiel von vorn.
Das ist ganz und gar ohne LED und Taster geschrieben - nur mit dem Seriellen Monitor.
Das ist der dritte und letzte Versuch innerhalb 4 Tage sowas zu bauen. (1 und 2)
Wenn irgendwas nicht geht, dann musst Du Dir das selbst erarbeiten.
Ich denke es ist ausreichend kommentiert, was das werden soll.
// Kleines Reaktionsspiel - Taster / LED-Kombis mit Zufallszeiten und Zufallsauswahl
// https://forum.arduino.cc/t/wie-funktionieren-timer/997433/8
// basiert auf https://forum.arduino.cc/t/wie-funktionieren-timer/997433/
const uint32_t reaktionsZeit = 1000UL * 2; // Zeit in ms
uint32_t einZeit; // Variable für Leuchtzeit
const byte anzahl = 3; // Anzahl TAST/LED Kombinationen
const byte ledPin[anzahl] = {9, 10, 11}; // Pins für Ausgabe
const byte tastePin[anzahl] = {6, 7, 8}; // Pins für Eingabe
byte auswahl; // welche LED / Tastenkombi ausgewählt wird
uint32_t lastmillis; // Merker für Zeiten
byte schritt; // Merker für Ablauf
void setup()
{
Serial.begin(115200); // zum debuggen
Serial.println(F("Start..."));
for (byte b = 0; b < anzahl; b++)
{
pinMode(ledPin[b], OUTPUT); // LED-Pins setzen
pinMode(tastePin[b], INPUT_PULLUP); // Tasten werden nach GND verbunden!
}
randomSeed(analogRead(A0)); // Zufallszahlen....
}
void loop()
{
switch (schritt)
{
case 0: // Auswahl: Start: Auswahl eine LED ein
zufall(); // "Würfeln"
ledAus(); // ...
Serial.println(F("Alles aus!"));
digitalWrite(ledPin[auswahl], HIGH); // Aktiviert Auswahl
lastmillis = millis(); // Zeit merken
Serial.println(F("Spielstart"));
schritt = 1; // weiter...
break;
case 1: // Auswahl: LED soll zufällig ausgehen
for (byte b = 0; b < anzahl; b++) // Abfrage ob keine Taste gedrückt ist
{
if (digitalRead(tastePin[b]) == LOW) // Wenn Taste gedrückt
{
lastmillis = millis(); // Zeit zurück setzen
Serial.println("Reset");
break; // Abbruch
}
}
if (millis() - lastmillis >= einZeit) // Wenn Zeit um
{
ledAus();
Serial.println(F("Warte auf Taste"));
lastmillis = millis(); // Zeit merken
schritt = 2;
}
break;
case 2: // Auswahl: Tasten abfragen
if (millis() - lastmillis <= reaktionsZeit) // Reaktionszeit nicht abgelaufen
{
for (byte b = 0; b < anzahl; b++) // Abfrage ob Taste gedrückt
{
if (digitalRead(tastePin[b]) == LOW) // Taste gedrückt?
{
lastmillis = millis(); // Zeit merken
if (b == auswahl) // richtige Taste?
{
Serial.println(F("Richtig!"));
schritt = 3; // Erfolg melden
break;
}
else
{
Serial.println(F("Falsch!"));
schritt = 4; // Misserfolg melden
}
}
}
}
else // Reaktionszeit abgelaufen
{
lastmillis = millis(); // Zeit merken
Serial.println(F("Nicht gedrückt!"));
schritt = 4; // Misserfolg melden
}
break;
case 3: // Auswahl: richtige LED
if (millis() - lastmillis < 3000)
{
blinkLed(ledPin[auswahl], 600); // Erfolgsanzeige
}
else
{
lastmillis = millis();
schritt = 5; // Neustart abwarten
Serial.println(F("Neustart nach Erfolg"));
}
break;
case 4: // Auswahl: falsche oder keine LED
if (millis() - lastmillis < 5000)
{
blinkAll(600); // Fehleranzeige
}
else
{
lastmillis = millis();
schritt = 5;
Serial.println(F("Neustart nach Misserfolg"));
}
break;
case 5: // Auswahl: Ende Durchlauf
ledAus(); // Alles erledigt
if (millis() - lastmillis > 2000) // Kleine Pause ohne delay()
schritt = 0; // Fange an von vorn
break;
default:
schritt = 0;
break;
}
}
//
void zufall()
{
static byte lastAuswahl = 255; // Merker
einZeit = random(1000, 10000); // Zufall in ms
byte umlauf = 0; // Zähler
while (lastAuswahl == auswahl && // Letzte Zahl nicht anders als aktuelle?
umlauf < 3) // nicht genügend Wiederholungen?
{
auswahl = random (0, anzahl); // Neue Zahl
umlauf++; //
}
lastAuswahl = auswahl; // merken
Serial.print(F("Einschaltzeit in ms: ")); // Ausgaben
Serial.println(einZeit);
Serial.print(F("Ausgewählter Reaktionsweg: "));
Serial.println(auswahl);
}
//
void ledAus() // durchläuft alle AusgabePins
{
for (byte b = 0; b < anzahl; b++)
{
digitalWrite(ledPin[b], LOW);
}
}
//
void blinkLed(const byte ledpin, const uint32_t zeit)
{
static uint32_t lastZeit = 0; // Merker letze Zeit
if (millis() - lastZeit >= zeit) // Zeit abgelaufen
{
lastZeit = millis(); // Merker setzen
digitalWrite(ledpin, !digitalRead(ledpin)); // toggle
Serial.print(F("Blink LED: "));
Serial.println(digitalRead(ledpin));
}
}
void blinkAll(const uint32_t zeit) // alle LED's ...
{
static uint32_t lastzeit = 0;
if (millis() - lastzeit >= zeit)
{
for (byte b = 0; b < anzahl; b++)
{
digitalWrite(ledPin[auswahl], HIGH);
}
lastzeit = millis();
}
else if (millis() - lastzeit >= zeit / 2) // eine andere Möglichkeit fürs blinken
{
for (byte b = 0; b < anzahl; b++)
{
digitalWrite(ledPin[auswahl], LOW);
}
}
}
