Sturzi's Arduino-Bastel-Projekt #1 - Es werde Licht

Zitat von rfurrer

Vielleicht als Ergänzung zum Rotlicht der Baustelle folgende Idee: So ein Lauflicht wie es bei Einspurstellen gibt, wo zuerst 1, dann 2, dann 3, dann 4, usw. bis 8 od. 9 LED leuchten, und am Schluss alle wieder aus. Und wenn Du es auf die Spitze treiben möchtest, noch so ein aufblitzen und wieder etwas zurückdimmen wenn die nächste LED kommt

Hallo Rolf. Ja das wären zusätzliche Möglichkeiten.

Ich muss mir das überlegen. Es ist recht aufwändig und wenn man auf dem Breadboard nur schon fünf LED und fünf Widerstände hat, ist es (gefühlt) voll. Für das Aufblitzen bräuchte es Analog-Ausgänge (genau gesagt PWM-Ausgänge) und davon hat es auf dem Uno nur sechs. Vielleicht mache ich's (wegen der Verwendung von PWM-Ausgängen).

Zitat von rfurrer

Progrämmchen kann man ja locker mehr als 5 Ausgänge ansteuern

Ja, mit dem Progrämmchen kann man beliebig viele Ausgänge ansteuern, und dabei braucht man nur eine einzige Anweisung anzupassen.

Beim Arduino ist es etwas enger. Beim Uno kommt man auf maximal 14. Aber das ist kein Problem, der Mega funktioniert (bezüglich Software) gleich und hat 54 Ausgänge. Dabei ist er nicht einmal teuer.

Verwendung des Serial Monitor zum Debuggen des Programmes

Bevor wir die Funktionalität des Programmes erweitern, möchte ich euch eine äusserst hilfreiche und praktische Funktion der Arduino Entwicklungsumgebung zeigen. Diese Einrichtung heisst Serial Monitor und hilft zum Debuggen des Programmes.

Aber zuerst: Was ist Debugging? Jeder Programmierer macht Fehler. Es gibt verschiedene Kategorien von Fehlern (auf Englisch Error oder Bug), die man machen kann:

- Design-Fehler

- Compile-Time-Fehler

- Run-Time-Fehler

- Logische Fehler (Fehler im Programm-Ablauf)

Die Programmierer nennen ihre Fehler oft Bugs (auf deutsch Wanzen). Wenn sie die Bugs im Programm suchen (und hoffentlich auch eliminieren), debuggen sie hiermit ihr Programm.

Ich werde zu einem späteren Zeitpunkt auf die verschiedenen Fehler-Kategorien eingehen.

Hier geht es um den Serial Monitor und dieser hilft bei der Suche nach Fehlern der letztgenannten Kategorie (Logische Fehler im Programm-Ablauf).

Der Serial Monitor ist eine sehr einfache Einrichtung, wie man im Programm an bestimmten Stellen die Ausgabe einer Meldung einbauen kann, die dann während der Programm-Ausführung in der IDE (Entwicklungsumgebung) angezeigt wird. Voraussetzung ist, dass der Arduino über das USB-Kabel mit dem Compi und demzufolge auch mit der IDE verbunden ist. Ich gehe aber davon aus, dass ihr bisher eure Arduino-Programme immer bei aktiver Verbindung zur IDE ausgeführt habt.

Ich zeige das am Beispiel. Ich habe bei der letzten Version unseres Blink-Programmes ein paar spezielle Befehle eingebaut, die Meldungen auf dem Serial Monitor erzeugen.

const long MIN_OFF_TIME = 1500;
const long MAX_OFF_TIME = 3000;
const long MIN_ON_TIME = 500;
const long MAX_ON_TIME = 1000;

const byte pinsUsedForLEDs[] = {2, 3, 5, 7, 8};
const byte numOfLEDsUsed = sizeof(pinsUsedForLEDs);

long millisOnLastStatusChange[numOfLEDsUsed];
long millisToWait[numOfLEDsUsed];

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < numOfLEDsUsed; i++) {
    pinMode(pinsUsedForLEDs[i], OUTPUT);
    changeStatus(i);
  }
}

void loop() {
  long currentMillis = millis();
  for (int i = 0; i < numOfLEDsUsed; i++) {
    if ((currentMillis - millisOnLastStatusChange[i]) >= millisToWait[i]) {
      changeStatus(i);
    }
  }
}

void changeStatus(int idx) {
  byte pin = pinsUsedForLEDs[idx];
  bool newStatus = ! digitalRead(pin); 
  digitalWrite(pin, newStatus);
  Serial.print("LED am Pin "); 
  Serial.print(pin); 
  if (newStatus == LOW) {
    Serial.println(" ausgeschaltet");
    millisToWait[idx] = random(MIN_OFF_TIME, MAX_OFF_TIME);
  } else {
    Serial.println(" eingeschaltet");
    millisToWait[idx] = random(MIN_ON_TIME, MAX_ON_TIME);
  }
  millisOnLastStatusChange[idx] = millis();
}

Zeile 13: Serial.begin(9600); Hier wird die Ausgabe von Meldungen auf den Serial Monitor vorbereitet. Diese Anweisung muss innerhalb der setup() Funktion sein. Die Zahl 9600 in den Klammern ist die Arduino-seitige Übertragungsgeschwindigkeit der Meldungen zur IDE.

Zeilen 33, 34, 36 und 39: Hier werden die Funktionen Serial.print() und Serial.println() aufgerufen. Als Argument wird innerhalb der runden Klammern ein Text (Texte stehen in Anführungszeichen) oder eine Variable angegeben. Die Funktion Serial.print() schickt das in den Klammern Angegebene an den Serial Monitor. Die Funktion Serial.println() macht dasselbe, hängt aber noch einen Zeilenumbruch an, um das Ende der aktuellen Meldung anzuzeigen (damit der Serial Monitor weiss, dass er auf die nächste Zeile springen kann).

Wenn man das Programm hochgeladen (und damit auch gestartet) hat, muss man in der IDE noch den Serial Monitor starten. Das geht entweder über das Menü Tools / Serial Monitor oder in der grünen Kopfzeile ganz rechts hat es ein Symbol dafür, auf das man klicken kann. Anstelle des Output-Fensters unterhalb des Programmes müsste nun der Serial Monitor erscheinen. Wenn immer noch das Output-Fenster aktiv ist, muss man noch auf den richtigen Tab (Serial Monitor rechts von Output) klicken. Jetzt muss man noch die IDE-seitige Übertragungsgeschwindigkeit überprüfen (oder ggf. einstellen). Das macht man mit der Combo-Box rechts oben im Serial Monitor (wahrscheinlich steht 9600 baud drin). Wenn eine andere Geschwindigkeit eingestellt ist, bitte mit der Combo-Box auf 9600 ändern.

Es müssten jetzt solche Meldungen erscheinen:

20:15:16.179 -> LED am Pin 7 ausgeschaltet
20:15:16.574 -> LED am Pin 5 eingeschaltet
20:15:16.903 -> LED am Pin 8 ausgeschaltet
20:15:17.332 -> LED am Pin 5 ausgeschaltet
20:15:17.660 -> LED am Pin 3 eingeschaltet
20:15:17.925 -> LED am Pin 2 eingeschaltet
20:15:18.385 -> LED am Pin 3 ausgeschaltet
20:15:18.680 -> LED am Pin 7 eingeschaltet
20:15:18.712 -> LED am Pin 8 eingeschaltet
20:15:18.910 -> LED am Pin 2 ausgeschaltet
20:15:19.339 -> LED am Pin 5 eingeschaltet
20:15:19.438 -> LED am Pin 7 ausgeschaltet
20:15:19.602 -> LED am Pin 8 ausgeschaltet
20:15:20.230 -> LED am Pin 5 ausgeschaltet
20:15:20.959 -> LED am Pin 3 eingeschaltet
20:15:21.222 -> LED am Pin 2 eingeschaltet
20:15:21.254 -> LED am Pin 8 eingeschaltet
20:15:21.319 -> LED am Pin 7 eingeschaltet
20:15:21.813 -> LED am Pin 3 ausgeschaltet

Falls die Zeit-Angaben (Time-Stamp) fehlen, klickt man noch auf das Uhr-Symbol rechts in der Kopfzeile des Serial Monitor.

Ich rate euch dringend, das auszuprobieren. Wenn ihr die Meldungen anschaut und dann das Programm analysiert, müsste klar werden wie es funktioniert. Spielt etwas damit herum, variiert die Meldungen, erzeugt neue Meldungen und schaut wie es reagiert.

Wenn's nach einer Weile üben nicht funzt, bitte melden, ich helfe gerne. Viel Erfolg!

Zitat von andysan

Verstanden habe ich längst nicht jeden Schritt, ABER den blauen Abschnitt#79, den habe ich verstanden.

Sehr gut. So ist es gemeint. So wirst du erfolgreich sein.

Zitat von andysan

Ich habe zumAufbau ein Teil aus meiner Arduinokiste zu nutze gemacht damit ich den Aufbau vereinfachen konnte. Auf dieser Platine sind 6 farbige LEDs schon verbaut und es ist steckbar auf der Leiste.

Super Idee! Ich muss mal meine ArduinoKiste inspizieren. Vielleicht habe ich auch so eine Platine. Das hätte mir einigen Verdrahtungs-Aufwand erspart.

Der for-Loop (ergänzende Erklärungen)

  for (int i = 0; i < numOfLEDsUsed; i++) {
    pinMode(pinsUsedForLEDs[i], OUTPUT);
    changeStatus(i);
  }

Die Statements (Anweisungen) innerhalb des zum for-Loop gehörenden geschweiften Klammernpaares bilden den Loop-Body. Dieser kann mehrmals durchlaufen (ausgeführt) werden.

Als erstes (int i = 0) wird die lokale Variable i vom Typ int definiert und auf den Wert 0 gesetzt. Diese lokale Variable ist für das Programm nur innerhalb des if-Body sichtbar.

Dann wird die Bedingung (i < numOfLEDsUsed) geprüft. Falls sie zutrifft, wird der Loop-Body (also die beiden Statements innerhalb der geschweiften Klammern) ausgeführt.

Nach der Ausführung der Statements im Loop-Body wird i++ ausgeführt. Anschliessend geht es wieder zurück zum grünen Statement (Bedingung). Das Statement i++ erhöht den aktuellen Wert von i um 1.

Der Ablauf ist also blau - grün - rot - grün - rot - grün - rot .... bis die grüne Bedingung nicht mehr erfüllt ist und dann geht der Programm-Ablauf mit dem ersten Statement nach dem Loop-Body weiter. Wichtig: Blau wird nur einmal (zu Beginn des for-Loops) ausgeführt.

Anderes Beispiel:

Wir wollen die ganzen Zahlen von 1 bis 10 zusammenzählen und die Summe über den Serial Monitor anzeigen. Das macht man am besten mit einem for-Loop.

void setup() {
  Serial.begin(9600);
  int sum = 0;
    for (int i = 1; i <= 10; i++) {
    sum += i;
  }
  Serial.print("Summe = ");
  Serial.println(sum);
}

void loop() {
}

Wir wollen das nur einmalig ausführen. Deshalb alles in der Funktion setup(). Die Funktion loop() bleibt dann leer.

Das Statement sum += i ist dasselbe wie sum = sum + i. Der aktuelle Wert von sum wird um den Wert von i erhöht.

Der Vergleichs-Operator <= bedeutet "ist kleiner oder gleich".

Im runden Klammernpaar des for-Loops stehen drei Statements, getrennt durch Semicolons. Hier dürfen beliebige (gültige) Statements stehen. Sie werden nach dem oben erklärten Schema (blau - grün - rot - grün - rot - ...) ausgeführt. Man könnte also aus dem for-Loop ganz wilde Konstrukte machen. Das ist aber nicht sinnvoll. Einfachheit ist hier gefragt, damit man das Programm auch später noch versteht.

Aufgepasst: Wenn man die grüne Bedingung versehentlich falsch formuliert, kann es sein, dass sie immer zutrifft. Man hat dann einen Endlos-Loop.

Das ist dann vielleicht der Moment wo der verzweifelte Programmierer sich die letzten Haare ausreisst und ruft: "Mein Programm macht wieder einmal das was ich programmiert habe und nicht was ich wollte".

Hinweis für die Besitzer eines Starter-Kit, ganz besonders für die Programmierer-Newbies unter euch. Es ist sehr nützlich, wenn man parallel zu diesem Bastel-Projekt auch die Projekte im Starter-Kit nachbaut und nach-programmiert. Die Autoren des Starter-Kit-Handbuchs erklären die Basics zur Programmierung vielleicht anders als ich und wenn man die Grund-Konzepte auf verschiedene Art erklärt bekommt, sind sie vielleicht besser zu verstehen.

Zusätzliche Quellen: Im Internet gibt es eine riesige Anzahl von Arduino Tutorials (englisch und deutsch, Videos oder Text). Einfach googeln nach "Arduino Tutorial", "Arduino basics", "Arduino Grundlagen" oder "Arduino erste Schritte", ... . Man findet sehr gute Artikel, aber leider auch schlechte. Hier muss man halt versuchen, die Spreu vom Weizen zu trennen.

Zitat von Cebu Pacific

Für heute ist gut, morgen fahre ich in Beitrag #38 weiter. Bis jetzt klappt es tiptop. Ich bin der perfekte Abschreiber.

Endlich wieder einmal eine (für mich erfreuliche) Rückmeldung. Ich würde es sehr begrüssen, mehr Rückmeldungen zu erhalten, sonst habe ich nämlich keine Ahnung, ob nur zwei-drei Forumisten am Projekt mitmachen oder vielleicht viel mehr. Bei Projekt #2 sehe ich an den Material-Bestellungen, dass das Interesse gross ist, aber hier tappe ich ziemlich im Dunkeln.

@die beiden Eggenbergers: Super! Das freut mich. Danke für die Nachricht!

Zitat von Fahrni

Die erste Hürde hab ich geschafft. Es Blinkt und wie würde Ogi sagen Freude herrscht (als Berner Oberländer der ich bin)

Gratuliere, Max. Das freut mich! Und danke für die Nachricht!

Finde ich gut, Ernesto! Ich bin auch nicht mehr der Jüngste ->> Also sind wir also gleich alt.

An deiner Stelle würde mir ein Starterkit zulegen. Wenn man Freude an derartigen Experimenten hat, ist das eine sehr dankbare Angelegenheit.

Verwendung eines Potentiometers (im Folgenden Poti genannt)

Zu wissen, was ein Potentiometer ist, setze ich voraus. Notfalls kann man es hier Wikipedia: Potentiometer nachlesen.

Das Potentiometer benötigen wir, um die mittlere Blink-Frequenz zu beeinflussen. In diesem Beitrag geht es vorerst nur um die Verwendung des Potis im Arduino. Der Rest (Beeinflussung der Blink-Frequenz) folgt dann in einem weiteren Beitrag.

Im Starterkit gibt es mindestens ein Poti von 10 kΩ. Das ist genau das Richtige.

Wir erstellen die Schaltung gemäss folgendem Schema:

Die beiden festen Anschlüsse des Potis liegen damit an 5V. Den Abgriff haben wir mit dem analogen Eingang A1 verbunden.

Hinweis: Falls ihr eure bestehende Schaltung im Arduino und im Breadboard bestehen lassen wollt, müsste das schon gehen. Die sollten sich nicht in die Quere kommen.

Und jetzt zum Programm: Der analoge Eingang ist in der Lage, die am Pin anliegende Spannung zu erkennen. Per Programm lesen wir ihn ein mit dem Befehl analogRead(). Dieser bringt für die Spannung im Bereich 0V ... 5V einen Wert zurück im Bereich 0 ... 1023. Der Wert ist schön regelmässig aufgeteilt, also für 0V: Wert 0, 5V: Wert 1023, 3V: Wert 613, ...

So sieht das Programm aus:

const byte analogInputForPoti = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int value = analogRead(analogInputForPoti);
  float voltage = 5.0 * value / 1024;
  Serial.print("Analog Input bringt Wert: ");
  Serial.print(value);
  Serial.print("   Das entspricht ");
  Serial.print(voltage);
  Serial.println(" Volt");
  delay(200);
}

Für die Funktionalität (das Einlesen des Analogen Eingangs) sind eigentlich nur die Zeilen 1 und 8 nötig. Der Rest ist nur da, um die Werte (inklusive damit errechneter Spannung) im Serial Monitor anzuzeigen. So können wir sehr schön erkennen, wie es sich verhält, wenn wir am Poti drehen.

Auch die Konstante analogInputForPoti bräuchten wir technisch gesehen nicht. Man könnte den analogRead auch direkt adressieren mit analogRead(A1).

Aber es ist immer gut, wenn man Konstanten oben im Programm mit einem sprechenden Namen definiert und dann weiter unten diesen verwendet.

Falls wir eines Tages auf die Idee kommen, den Poti-Abgriff auf A3 umzustecken, müssen wir das Programm nur oben bei den Konstanten ändern und nicht lang im Programm-Code suchen.

Schaut unbedingt in den Serial Monitor! Während wir am Poti drehen, müsste es etwa so aussehen:

Viel Erfolg!

Zitat von Cebu Pacific

Muss das so sein? Verändere ich das Programm und starte es mit dem Pfeil nach rechts, wird das auf der Festplatte gespeicherte Programm überschrieben.

Es muss nicht, aber es ist standardmässig so eingestellt. Bei den Preferences (du findest diese oben im Menü) gibt es eine Option "Auto save". Wenn du diese ausschaltest, verhält es sich so, wie du erwartest.