Ich bin neu im Arduino-Geschäft (1 Woche) und somit neu in Sachen Forum und programmieren.
Und wie es zu erwarten war, die ersten zwei Probleme in einer Datei/Sketch schreien förmlich nach Eurer Hilfe
Ich bekomme keinen Interrupt durch den Taster. (Mit dem Taster möchte ich den Start des Programm´s erreichen und auch die Anzahl der Ablaufzyklen erhöhen (also die Laufzeit verlängern)
Die erste while-Schleife will nicht funktionieren, aber die zwei while-Schleifen, die in dieser sind, funktionieren.
Die auskommentierten "loop-Teile" kommen später dran, sollte dann gleich wie der erste Teil
Ich hoffe mei Post ist richtig und Mann/Frau kann mir behilflich sein - DANKE!
// 2018.11.22
#include <OneButton.h>
#include <Bounce2.h>
// LED VARIABLEN
int led1 = 9; int led3 = 11;
int led2 = 10; int led4 = 12;
// TASTER VARIABLEN
volatile int tastPin = 2;
volatile byte tastCounter = 0; // wird als rasch flüchtig und daher im einem eigen Speicherbereich (Ram) abgelegt
volatile byte tastState = 0;
int tasterZustand;
Bounce bouncer = Bounce(tastPin,5); // Entprellt den Taster mit 5 millisekunden (Bouncer Libary)
// ZEIT VARIABLEN
unsigned long lastMillis1;
unsigned long lastMillis2;
unsigned long lastMillis3;
unsigned long currentMillis;
// BLINKMUSTER VARIABLEN
int Blinkmuster1_tmp = 0; int Blinkmuster_1blau_tmp = 0; int Blinkmuster_1gelb_tmp = 0;
int Blinkmuster2_tmp = 0; int Blinkmuster2a_tmp = 0;
int Blinkmuster3_tmp = 0; int Blinkmuster3a_tmp = 0;
int Blinkmuster4_tmp = 0; int Blinkmuster4a_tmp = 0;
// Blinkfolge eines kompletten Programmabschnittes = Anzahl der Wiederholungen
int Blinkmuster_1 = 10; int Blinkmuster_1blau = 11; int Blinkmuster_1gelb = 11;
int Blinkmuster2 = 3; int Blinkmuster2a = 3;
int Blinkmuster3 = 3; int Blinkmuster3a = 3;
int Blinkmuster4 = 5; int Blinkmuster4a = 5;
// Leuchtdauer einer LED
int i_1 = 18; // Leuchtdauer einer LED im Blinkmuster1
int i_2 = 18; // Leuchtdauer einer LED im Blinkmuster2
int i_3 = 18; // Leuchtdauer einer LED im Blinkmuster3
int i_4 = 18; // Leuchtdauer einer LED im Blinkmuster4
// Anzahl der Programmablaeufe bei Tastendruck
int zy_1 = 2; // 20 Zyklen dauern ca. 2 Minuten 30 Sekunden
void IsR() // IsR = Interupt service routine
{if (tastPin == LOW) {tastCounter +30;}}
void setup()
{
// PINBELEGUNG
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(tastPin, INPUT_PULLUP); // Pin2 = Taster = Interrruptpin
lastMillis1 = millis();
lastMillis2 = millis();
lastMillis3 = millis();
attachInterrupt(digitalPinToInterrupt(tastPin), IsR, CHANGE);
Serial.begin(9600);
}
void loop()
{
// Prüfen auf eine Änderung beim Tastereingang
if(bouncer.update())
{
// Ist der Taster gedrückt, den Zähler um "1" erhöhen
if(bouncer.read()==HIGH) {
tastCounter = zy_1;
}
}
tasterZustand = digitalRead(tastPin);
// Serial.println(tastCounter);
// delay (500);
Serial.println(Blinkmuster1_tmp);
delay (500);
// Serial.println(Blinkmuster_1blau_tmp);
// delay (100);
Serial.println(tastPin);
// delay (100);
if (tastCounter > 0) // tasterZustand
{
while (Blinkmuster_1 > Blinkmuster1_tmp) // BLINKMUSTER 1 (0--0)<->(-00-)
{
while (Blinkmuster_1blau > Blinkmuster_1blau_tmp) // BLINKMUSTER 1 blau (0--0)
{
// BLINKMUSTER 1 - Blaue Gruppe (0--0)
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // 16ms warten
digitalWrite(led1, HIGH); // dann die LED an-schalten
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // wieder 16ms warten
digitalWrite(led4, HIGH); // dann die LED aus-schalten
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // 16ms warten
// turn LED on:
digitalWrite(led1, LOW); // dann die LED an-schalten
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // wieder 16ms warten
digitalWrite(led4, LOW); // dann die LED aus-schalten
Blinkmuster_1blau_tmp ++;
} // Ende "while (Blinkmuster_1blau > Blinkmuster_1blau_tmp) // BLINKMUSTER 1 (0--0)"
while (Blinkmuster_1gelb > Blinkmuster_1gelb_tmp) // BLINKMUSTER 1 gelb (-00-)
{
// BLINKMUSTER 1 gelb - // Gelbe Gruppe (-00-)
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // i_1 ms warten
digitalWrite(led2, HIGH); // dann die LED an-schalten
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // i_1 ms warten
digitalWrite(led3, HIGH); // dann die LED aus-schalten
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // i_1 ms warten
digitalWrite(led2, LOW); // dann die LED an-schalten
currentMillis = millis();
while(millis()-currentMillis < i_1 ); // i_1 ms warten
digitalWrite(led3, LOW); // dann die LED aus-schalten
Blinkmuster_1gelb_tmp ++;
} // Ende "while (Blinkmuster_1gelb > Blinkmuster_1gelb_tmp) // BLINKMUSTER 1 (0--0)"
Blinkmuster1_tmp++;
} // Ende "while (Blinkmuster_1 > Blinkmuster_1_tmp)
} // = Ende der "if-Schleife / Tasterabfrage" "else" folgt nicht
// if (tastCounter > 0) {tastCounter --;} // Wenn aktiviert - Schaltet nach den voreingestelten Zyklen ( zy-1 ) ab
} // = Ende "loop"
Du hast doch schon eine große Schleife: loop. Was willst Du mit weiteren Schleifen?
Deine Verwendung von millis ist falsch (schaue Dir BlinkWithoutDelay an und verstehe es)und delay hat da drin überhaupt nichts zu suchen.
Für einen handbetätigten Taster brauchst Du keinen Interrupt (höchstens bei sehr schlechter Programmierung) und das beißt sich auch mit der Bounce-Lib.
Du solltest mit kleineren Einheiten beginnen und die Grundlagen lernen. Die Beispiele in der IDE und den Libs sind eine gute Basis dafür.
Ich habe ganz klein angefangen und habe gelesen, gelesen und gelesen und immer wieder ein Stück probiert und wenn es funktioniert hat blieb es im Sketch.
Mein ursprünglicher Gedanke war folgender:
es sollte zwei Taster geben (die später über eine 12-Kanal 433MHz Fernbedienung ersetzt werden). Der eine sollte das Blinklicht ein und aus-tasten, der zweite die unterschiedlichen Modi durchtasten. Um es nicht zu kompliziert werden zu lassen habe ich schon von Anfang an auf RGB-LED´s verzichtet.
Verwendung sollte das Programm in meinen RC-Cars finden (Einsatzfahrzeuge).
Mit der zwei in eins-Lösung wollte ich erreichen, dass ich den visuellen Verlauf (Effekte) ganz einfach durch Änderung der Variablen unterschiedlich gestalten kann. Jedes Car soll ein wenig anders signalisieren.
Das mit den "falschen millis" habe ich durch die Suche nach "BlinkWithoutDelay" gefunden - zugegeben verstanden habe ich null aber hat soweit ja funktioniert. Ich habe ja am Anfang nur mit "delay " gearbeitet und weil dabei meine Tastereingabe während des Programmablaufs nicht mehr ankam und ich gelesen, gelesen und gelesen habe, habe ich auf "millis" umgebaut.
Die "die OneButton.h" ist tatsächlich ein Überbleibsel - DANKE
Im Sommer hatten wir auch schon einen Modellbauer, da gabs dann viele unterschiedliche Blinkmuster, LED's.
Das BlinkWithoutDelay Beispiel konsequent angewandt bietet dir ein schier unbegrenztes Blinkkonzert. Mit OOP wirds dann auch noch halbwegs übersichtlich.
Mal ganz einfach ein Wechselblinker für eine LED an PIN 13 und 12 und zwei Buttons die unterschiedliche Aktionen auslösen.
Für weitere Leuchtbalken braucht man eigentlich nur ein neues Objekt erstellen, PIN's definieren und im loop auch aufrufen.
/* alternate blinking two LEDs in a specific rhythm
Turns on and off light emitting diodes (LED) connected to a digital pin,
without using the delay() function. This means that other code can run at the
same time without being interrupted by the LED code.
*/
#include "OneButton.h"
class AlternatingLed { // two LEDs blinking alternating
byte state = 1; // 0 off, 1 blink
unsigned long previousMillis; // last blink timestamp
uint16_t on = 180; // milliseconds on time for the first LED = off time for the second LED
uint16_t off = 320; // milliseconds off time for the first LED = on time for the secon LED
const byte ledPin1; // a GPIO for the first LED
const byte ledPin2; // a GPIO for the second LED
public:
AlternatingLed(byte _ledPin1, byte _ledPin2, uint16_t _on = 180, uint16_t _off = 320):
ledPin1(_ledPin1),
ledPin2(_ledPin2),
on (_on),
off (_off)
{}
void setup() {
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
void set(uint16_t _on, uint16_t _off) { // modify on/off times during runtime
on = _on;
off = _off;
}
void toggleState() {
state = !state; // toggle status to the other state on->off or off ->on
}
void setState(byte _state) { // 1 Switch on blinking; 0 switch off blinking
state = _state;
}
void loop() {
if (state) {
uint32_t currentMillis = millis();
if (digitalRead(ledPin1) && currentMillis - previousMillis >= on) {
// save the last time you blinked the LED
previousMillis = currentMillis;
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
}
else if (!digitalRead(ledPin1) && currentMillis - previousMillis >= off) {
// save the last time you blinked the LED
previousMillis = currentMillis;
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
}
}
else // switch off both LEDs
{
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
}
};
// declare your LED objects (assign GPIOs to you LEDs)
AlternatingLed myAlternatingLed(13, 12, 500, 500);
// Let's declare some SwitchButtons.
OneButton channel2(2, true);
OneButton channel3(3, true);
void setup() {
// each LED object has to be called once in the setup
myAlternatingLed.setup();
//myAlternatingLed.setState(0); // if the LEDs should not blink after boot, activate this line
// each Button object should have a defined function
channel2.attachClick(action2);
channel3.attachClick(action3);
// we use the internal PULLUP, to close the Switch - connect to GND
Serial.begin(115200); //only used for debug
Serial.println(F("BlinkWithoutDelayAlternating"));
Serial.print (__DATE__);
Serial.print (F(" "));
Serial.println(__TIME__);
}
void loop() {
// each LED object has to be called once in the loop
myAlternatingLed.loop();
// each Button object has to be called once in the loop
channel2.tick();
channel3.tick();
// do other things in the loop NONBLOCKING
}
void action2()
{
Serial.println(F("action2() activated"));
myAlternatingLed.toggleState();
}
void action3()
{
Serial.println(F("action3() activated"));
static uint32_t mytime = 100;
mytime += 20;
myAlternatingLed.set(mytime, 200); // modify blinking time
}
wenn das System verstanden wurde - such ich die anderen Blink-Muster vom Sommer.
Die Einleitung klingt schon recht vielversprechend - ich werde mir das sofort zu Gemüte führen.
Dank meines hundsmisserablen Englisches wird auch da wieder "Deepl" zur Höchstform auflaufen müssen.
Kannst du in BlinkWithoutDelay alles nachvollziehen
Ist dir klar, dass dabei in loop kein zeitlicher Ablauf "mach dies, warte ein bisschen, dann mach das" beschrieben wird, sondern dass ein loop-Durchlauf keine Zeit braucht und nur feststellt was jetzt zu machen ist: "Wenn die LED schon 1000 ms an ist, mach sie aus."?
noiasca:
ist die jede Zeile klar?
Wenn was unklar ist: stell eine konkrete Frage.
Hi - das ganze ist eine einzige Frage
michael_x:
Ist dir klar, dass dabei in loop kein zeitlicher Ablauf "mach dies, warte ein bisschen, dann mach das" beschrieben wird, sondern dass ein loop-Durchlauf keine Zeit braucht und nur feststellt was jetzt zu machen ist: "Wenn die LED schon 1000 ms an ist, mach sie aus."?
Auch Hi - das habe ich vermutet - aber wissen ist was anderes.
Wir, meine Freundin und ich - eigendlich mein Freund und ich saßen schon Nächte vor vielmehr meinem Problem.
Er hat sich ein fertiges Modul gekauft, ich möchte es aber selber machen und ich habe nicht den Anspruch es genauso perfekt haben zu wollen aber dafür flexibler und universeller. Deshalb learning bei fragen und tun.
Ich habe keine Ahnung welche meiner tausend Fragen ich als erstes stellen soll ?? Bei meinem Wissensstand wäre wohl die erste Frage: blinkt da überhaupt was ;-).
Ich habe den Sketch geladen und mir die Kommentare übersetzt aber er will nicht laufen. Da steht:"
'_off' has not been declared"
aber ich blicke nicht durch wo da was zu deklarieren sein soll.
/* abwechselndes Blinken von zwei LEDs in einem bestimmten Rhythmus
Schaltet Leuchtdioden (LED) ein und aus, die an einen digitalen Pin angeschlossen sind,
ohne die delay() Funktion zu verwenden. Das bedeutet, dass anderer Code auf der Registerkarte
gleichzeitig, ohne durch den LED-Code unterbrochen zu werden.
*/
#include "OneButton.h"
class AlternatingLed { // zwei LEDs blinken abwechselnd abwechselnd
byte state = 1; // 0 aus, 1 blinkend
unsigned long previousMillis; // letzter blinkender Zeitstempel
uint16_t on = 180; // Millisekunden Einschaltzeit für die erste LED = Ausschaltzeit für die zweite LED
uint16_t off = 320; // Millisekunden Auszeit für die erste LED = Einzeit für die zweite LED
const byte ledPin1 = 9; // ein GPIO für die erste LED
const byte ledPin2 = 10; // ein GPIO für die zweite LED
public:
AlternatingLed(byte _ledPin1, byte _ledPin2, uint16_t _on = 180, uint16_t _off = 320):
ledPin1(_ledPin1),
ledPin2(_ledPin2),
on (_on);
off (_off);
{}
void setup() {
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
void set(uint16_t _on, uint16_t _off) { // Ein/Auszeiten während der Laufzeit ändern
on = _on;
off = _off;
}
void toggleState() {
state = !state; // Status in den anderen Zustand umschalten on>off oder off ->on
}
void setState(byte _state) { // 1 Einschalten blinkend; 0 Ausschalten blinkend
state = _state;
}
void loop() {
if (state) {
uint32_t currentMillis = millis();
if (digitalRead(ledPin1) && currentMillis - previousMillis >= on) {
// Speichern Sie das letzte Mal, wenn Sie die LED geblinkt haben.
previousMillis = currentMillis;
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
}
else if (!digitalRead(ledPin1) && currentMillis - previousMillis >= off) {
// Speichern Sie das letzte Mal, wenn Sie die LED geblinkt haben.
previousMillis = currentMillis;
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
}
}
else // beide LEDs ausschalten
{
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
}
};
// Deklarieren Sie Ihre LED-Objekte (weisen Sie Ihren LEDs GPIOs zu).
AlternatingLed myAlternatingLed(13, 12, 500, 500);
// Lasst uns einige SwitchButtons deklarieren
OneButton channel2(2, true);
OneButton channel3(3, true);
void setup() {
// jedes LED-Objekt muss im Setup einmal aufgerufen werden.
myAlternatingLed.setup();
myAlternatingLed.setState(0); // wenn die LEDs nach dem Start nicht blinken sollen, aktivieren Sie diese Zeile.
// Jedes Button-Objekt sollte eine definierte Funktion haben.
channel2.attachClick(action2);
channel3.attachClick(action3);
// wir verwenden den internen PULLUP, um den Switch zu schließen - verbinden Sie ihn mit GND.
Serial.begin(115200); //nur für Debugging verwendet
Serial.println(F("BlinkWithoutDelayAlternating"));
Serial.print (__DATE__);
Serial.print (F(" "));
Serial.println(__TIME__);
}
void loop() {
// jedes LED-Objekt muss einmal in der Schleife aufgerufen werden.
myAlternatingLed.loop();
// jedes Button-Objekt muss einmal in der Schleife aufgerufen werden.
channel2.tick();
channel3.tick();
// andere Dinge in der Schleife NONBLOCKING tun.
}
void action2()
{
Serial.println(F("action2() activated"));
myAlternatingLed.toggleState();
}
void action3()
{
Serial.println(F("action3() activated"));
static uint32_t mytime = 100;
mytime += 20;
myAlternatingLed.set(mytime, 200); // modify blinking time
}
Wir Ahnungslosen haben vergangene Nacht so viel ausprobiert, wollten aber immer wieder alles zurückge(ver)stellt haben.
Nun habe ich den orig. Sketch von oben nochmal geladen und mein UNO kommt gerade mal bis zu ... siehe Anhang
Kannst Du/Sie mir sagen, was mir mein Elegoo-Italiener mit dem
" 'void AlternatingLed::setup()' cannot be overloaded"
sagen möchte?
Was ist ein Elegoo-Italiener?
Sowas ähniches wie ein chinesischer Bayer?
(die Echten Bayern unter Euch mögen mir den Witz verzeihen; "Nichts für ungut")
Grüße Uwe
ich weiß zwar nicht warum die 1.8.7 meint, es sei ein Overload aber anyway.
Ich hab mal die zwei Methoden umbenannt und jetzt lässt es sich auch unter 1.8.7 compilieren was unter 1.8.5 schon kein Problem war:
/* alternate blinking two LEDs in a specific rhythm
Turns on and off light emitting diodes (LED) connected to a digital pin,
without using the delay() function. This means that other code can run at the
same time without being interrupted by the LED code.
*/
#include "OneButton.h"
class AlternatingLed { // two LEDs blinking alternating
byte state = 1; // 0 off, 1 blink
unsigned long previousMillis; // last blink timestamp
uint16_t on; // milliseconds on time for the first LED = off time for the second LED
uint16_t off; // milliseconds off time for the first LED = on time for the secon LED
const byte ledPin1; // a GPIO for the first LED
const byte ledPin2; // a GPIO for the second LED
public:
AlternatingLed(byte _ledPin1, byte _ledPin2, uint16_t _on, uint16_t _off):
ledPin1(_ledPin1),
ledPin2(_ledPin2),
on (_on),
off (_off)
{}
void begin() {
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
void set(uint16_t _on, uint16_t _off) { // modify on/off times during runtime
on = _on;
off = _off;
}
void toggleState() {
state = !state; // toggle status to the other state on->off or off ->on
}
void setState(byte _state) { // 1 Switch on blinking; 0 switch off blinking
state = _state;
}
void tick() {
if (state) {
uint32_t currentMillis = millis();
if (digitalRead(ledPin1) && currentMillis - previousMillis >= on) {
// save the last time you blinked the LED
previousMillis = currentMillis;
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
}
else if (!digitalRead(ledPin1) && currentMillis - previousMillis >= off) {
// save the last time you blinked the LED
previousMillis = currentMillis;
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
}
}
else // switch off both LEDs
{
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
}
};
// declare your LED objects (assign GPIOs to you LEDs)
AlternatingLed myAlternatingLed(13, 12, 500, 500);
// Let's declare some SwitchButtons.
OneButton channel2(2, true);
OneButton channel3(3, true);
void setup() {
// each LED object has to be called once in the setup
myAlternatingLed.begin();
//myAlternatingLed.setState(0); // if the LEDs should not blink after boot, activate this line
// each Button object should have a defined function
channel2.attachClick(action2);
channel3.attachClick(action3);
// we use the internal PULLUP, to close the Switch - connect to GND
Serial.begin(115200); //only used for debug
Serial.println(F("BlinkWithoutDelayAlternating"));
Serial.print (__DATE__);
Serial.print (F(" "));
Serial.println(__TIME__);
}
void loop() {
// each LED object has to be called once in the loop
myAlternatingLed.tick();
// each Button object has to be called once in the loop
channel2.tick();
channel3.tick();
// do other things in the loop NONBLOCKING
}
void action2()
{
Serial.println(F("action2() activated"));
myAlternatingLed.toggleState();
}
void action3()
{
Serial.println(F("action3() activated"));
static uint32_t mytime = 100;
mytime += 20;
myAlternatingLed.set(mytime, 200); // modify blinking time
}
jetzt hat mein "schweiz-, amerikanischer-, Chinesen-Italiener ohne Murren meine "Welt der Fragen" geschluckt.
Woran muss/darf ich denn schrauben um verschiedene Blink-Muster zu berwerkstelligen.
Will "Learning by Doing" betreiben und erst wieder nerven - wahrscheinlich morgen (muss arbeiten) - wenn ich nicht mehr weiter weiss.
mercy -
