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

Datentypen für die Arduino Programmierung

Wir haben bereits zwei Datentypen, long und bool, ohne viel Erklärung kennengelernt. Da wir für die nächste Ausbaustufe noch weitere Datentypen brauchen werden, werde ich hier ein paar Ergänzungen anbringen.

Um ganze Zahlen (0, 3, 17, 127, etc.) speichern zu können, verwendet man die Datentypen byte, int, long, unsigned int und unsigned long. Diese Liste ist nicht ganz vollständig (mit Absicht um es übersichtlich zu halten).

byte für ganze Zahlen im Bereich 0 bis 255. byte belegt (wie es der Name schon sagt) 1 Byte im Speicher.

int für ganze Zahlen im Bereich -32'768 bis 32'767. int belegt 2 Bytes im Speicher.

unsigned int für ganze Zahlen im Bereich 0 bis 65'535. unsigned int belegt 2 Bytes im Speicher.

long für ganze Zahlen im Bereich -2'147'483'648 bis 2'147'483'647. long belegt 4 Bytes im Speicher.

unsigned long für ganze Zahlen im Bereich 0 bis 4'294'967'295. unsigned long belegt 4 Bytes im Speicher.

Das Vorwort unsigned heisst "ohne Vorzeichen", also nur positive Zahlen. byte ist implizit unsigned.

Wenn man einen Datentyp braucht, um ganze Zahlen zu speichern, muss man sich bei deren Deklaration überlegen, welcher Zahlenbereich vorkommen kann. Im Zweifelsfall nimmt man besser den nächst mächtigeren und nimmt dabei in Kauf, dass der etwas mehr Speicher braucht.

Nebst den Datentypen für ganze Zahlen gibt es noch den Datentyp bool. In der Arduino-Umgebung trifft man auch boolean an. boolean ist ein Alias von bool (ist also das Gleiche). bool kann nur zwei Werte annehmen (true und false), also wahr und falsch. In der Arduino-Umgebung trifft man of HIGH und LOW an, die an Stelle von true oder false verwendet werden. Das geht, weil die Arduino-Umgebung HIGH zu einem Alis von true und LOW zu einem Alias von false gemacht hat.

Die Liste von Datentypen ist damit noch nicht vollständig. Es gibt vor Allem auch Datentypen für Bruchzahlen (0.002, 1.82, 3.1416, etc.). Diese benötigen wir in diesem Projekt voraussichtlich nicht. Wir werden sie aber im Projekt #2 (Geschwindigkeits-Messer) sicher kennenlernen.

Ich will hier noch auf die offizielle Dokumentation von Arduino verweisen. Dort ist alles über die Arduino-Umgebung (recht gut) beschrieben.

Hier die offizielle Dokumentation über die Datentypen.

Zitat von Bueti

Ich geh jetzt mal ne ordentliche Menge Shortbread kaufen.

Finde ich gut. Aber nicht mehr als 255, sonst brauchen wir einen int oder einen long, um sie abzuspeichern .

@Urs: Giorgio hat schon recht. Es sieht so aus, als hättest du void setup() ein zweites Mal geschrieben. Ohne das ganze Programm zu sehen kann ich leider auch nicht helfen. Versuch' doch, auf irgend eine Art das ganze Programm zu posten.

@Giorgio: Ja, ich werde in Zukunft versuchen, den Code als Text zu speichern. Die Tatsache, dass die Formatierung etwas leidet, hat mich bisher davon abgehalten.

Zitat von Bueti

Bei grösserem Konsum wird der Speicher automatisch auch grösser.

Aha das ist der Grund, warum mein Shortbread-Speicher schon so gross ist .

Da wir nun bald zu der Version mit beliebig vielen LEDs kommen wollen, müssen wir den Begriff Array kennen lernen.

Der Begriff Array kommt aus dem englischen Sprachgebrauch und bedeutet eine regelmässige Anordnung von Objekten. Ich erkläre das am besten an ein paar Beispielen:

Ein Lattenzaun ist ein Array von Latten. Bei einem Gleis gibt es einen Array von Schwellen. Eine Leiter hat einen Array von Sprossen.

Ein Breadboard ist ein gutes Beispiel für Arrays: Jedes Loch ist ein Pin (das ist noch kein Array). Was hier in grün und rot eingezeichnet ist, sind Arrays von Pins. Grün: Array von 30 Pins, Rot: Array von 5 Pins.

Alle bis jetzt genannten Beispiele sind eindimensionale Arrays. Es gibt auch mehrdimensionale. Z.B. ein Schachbrett ist ein zweidimensionaler Array von Schachfeldern.

Und zuletzt noch ein Beispiel speziell für Martin (Bueti)

Dies ist ein Objekt vom Typ Shortbread.

Ein eindimensionaler Array von drei Elementen vom Typ Shortbread.

Ein zweidimensionaler Array von 3 x 3 Elementen vom Typ Shortbread.

Ein dreidimensionaler Array von 2 x 3 x 3 Elementen vom Typ Shortbread.

In der C++ Programmierung sieht das so aus:

long millisToWait;  // Das ist eine Variable vom Typ long (kein Array)
long millisToWait[10];  // Das ist ein (eindimensionaler) Array von 10 Elementen (Variablen) vom Typ long

Nun müsste der Begriff Array ziemlich klar sein. Morgen werde ich die Programm-Version vorstellen, die beliebig viele LEDs zum Blinken bringt und dazu Arrays verwendet.

Eine beliebige Anzahl LEDs soll unregelmässig und voneinander unabhängig blinken

Ich habe nun die entsprechende Schaltung aufgebaut und das Programm angepasst.

So sieht die funktionierende Schaltung aus:

Die für die Ansteuerung der LEDs verwendeten digitalen Ausgänge können beliebige sein. Sie müssen auch nicht lückenlos aufeinander folgen.

Ich habe die Ausgänge 2, 3, 5, 7 und 8 gewählt.

So sieht das aktuelle Programm aus:

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() {
  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);
  if (newStatus == LOW) {
    millisToWait[idx] = random(MIN_OFF_TIME, MAX_OFF_TIME);
  } else {
    millisToWait[idx] = random(MIN_ON_TIME, MAX_ON_TIME);
  }
  millisOnLastStatusChange[idx] = millis();
}

Zeile 6: Das ist ein konstanter Array bestehend aus 5 Elementen vom Typ byte. Er wird direkt abgefüllt mit den Werten 2, 3, 5, 7 und 8.

Zeile 7: Der Variablen numOfLEDsUsed vom Typ byte wird der Wert 5 zugeordnet. Der Operator sizeof liefert die Anzahl Elemente des angegebenen Arrays, also hier 5.

Zeilen 9 und 10: Hier wird je ein Array vom Typ long mit 5 Elementen definiert.

Anmerkung über das Zählen, bevor wir zu den Zeilen 13 bis 16 gehen: Im Gegensatz zum normalen Leben, wo man mit 1 zu zählen beginnt, beginnt man im C++ (wie auch in vielen anderen Programmiersprachen) mit 0 zu zählen. Dafür gibt es gute Gründe, auf die ich aber an dieser Stelle nicht eingehen will. Die Arrays auf den Zeilen 6, 9 und 10 bestehen aus je 5 Elementen, nämlich aus den Elementen 0, 1, 2, 3 und 4. Wenn man auf das erste Element eines Arrays (das Element 0) zugreifen will, macht man das mit dem Index 0, den man in einem eckigen Klammernpaar angibt (z.B. millisToWait[0]. Will man auf das 5. Element (das Element 4) zugreifen, geht das mit millisToWait[4].

Zeilen 13 bis 16: Das nennt man einen Loop oder eine Iteration. Es gibt im C++ mehrere Arten von Loops. Dies ist ein for-Loop. Ich werde den for-Loop in einem der nächsten Beiträge im Detail erklären. Für den Moment nimm' einfach zur Kenntnis, dass hier die Anweisungen innerhalb der geschweiften Klammern, also Zeile 14 und 15 genau 5 Mal durchlaufen werden. Im ersten Durchlauf hat die Variable i den Wert 0, im zweiten 1, etc. und im letzten Durchlauf hat sie den Wert 4.

Zeile 14: Hier wird auf ein Element des Arrays pinsUsedForLEDs zugegriffen. Auf welches Element, wird vom jeweils aktuellen Wert der Variablen i bestimmt.

Zeile 15: Die Funktion changeStatus() wird aufgerufen. Als Argument wird hier der aktuelle Wert der Variablen i mitgegeben, also bei jedem Aufruf ein anderer Wert.

Zeile 21 bis 25: Gleiches Szenario wie auf Zeilen 13 bis 16.

Zeile 28: Die Funktion changeStatus() hat neu einen Parameter idx vom Typ int erhalten. Beim Aufruf der Funktion wird der Wert in den runden Klammern (also der aktuelle Wert vom i) übergeben und das idx nimmt jetzt diesen Wert an.

Für Newbies in der Programmierung ist das hier Erklärte vielleicht nicht auf Anhieb verständlich. Ich rechne damit, dass es ein paar lange Gesichter geben wird. Don't worry! Versucht so viel wie möglich zu verstehen und vor Allem übernehmt das Programm in eure Entwicklungsumgebung und probiert es zum Laufen zu bringen, bis eure Dioden etwa so blinken wie in meinem Video. Ihr müsst nicht zwingend mit 5 Dioden arbeiten. Es dürfen auch 3 oder 6 oder was immer sein. Variiert etwas und experimentiert! Wichtig ist, dass ihr auf Zeile 6 die verwendeten Pins auflistet.

Es werden weitere Erklärung zum aktuellen Programm folgen.

Zitat von Strickwil

dass ich bei diesem Thema nur "Bahnhof" verstehe?

Hansruedi, mir geht's genau so. Nur hänge ich es nicht an die grosse Glocke und deshalb haben es die meisten noch nicht gemerkt .

Zitat von rfurrer

Richtig cool was Du hier zeigst und vorallem auch erklärst

Danke, Rolf, für das Kompliment.

Zitat von rfurrer

Hab gestern mein Arduino Starter Kit ebenfalls bekomme und werde schon bald die ersten Schritte in der Arduino Welt gehen.

Finde ich super und wünsche dir damit einen guten Start. Ich habe noch viele Ideen und langweilig wird's bestimmt nicht.

Standortbestimmung

Dieser Thread ist noch nicht einmal 10 Tage alt und wir haben schon einen beachtlichen Stand erreicht.

Der letzte Schritt, wo Arrays und der Loop dazukamen (hier meine ich jetzt nicht den Loop, den die loop() Funktion macht, sondern den neu gelernten for-Loop), war vielleicht nicht für alle ganz einfach zu verstehen. Dafür habe ich volles Verständnis. Zu dem Punkt habe ich aber eine sehr wichtig Anmerkung, die vor Allem für diejenigen wichtig ist, die hier neu mit der Programmierung konfrontiert werden:

Wenn man das Programmieren erlernt, kann man niemals alles verstehen, bevor man es anwendet. Das ist ein repetitiver Prozess zwischen lernen, anwenden und verstehen. Mit einfacheren Worten: Man muss in der Lage sein, Konzepte, die man noch nicht oder noch nicht ganz verstanden hat, zu übernehmen, Programm-Sequenzen abzutippen, versuchen ein noch nicht ganz verstandenes Programm zum Laufen zu bringen, damit zu experimentieren. Man muss neue Aspekte übernehmen, ohne die vorherigen komplett begriffen zu haben. Plötzlich geht ein Licht auf, dann noch eines und noch eines ...

Die beiden neuen Konzepte (Arrays und Loops) sind vielleicht bei der ersten Begegnung eine grosse Hürde, die es zu bewältigen gibt. Wenn man sie aber ein paarmal angewandt hat, werden sie zu einer Selbstverständlichkeit wie das abendliche Zähneputzen. Ohne Arrays und ohne Loops kämen wir in der Programmierung nicht weit.

Ich werde ab jetzt die Kadenz etwas zurücknehmen (würde ja auch an der ChRB III gerne noch etwas weiter bauen).

Zu der letzten Version schulde ich noch ein paar Erklärungen. Diese werden nach und nach, Schritt für Schritt folgen.

Und jetzt will ich noch schnell verraten, wie es mit neuen Funktionen in diesem Projekt weitergeht:

Als Nächstes werden wir ein Potentiometer dazu nehmen. Mit diesem Potentiometer werden wir imstande sein, stufenlos die zufälligen Intervalle zu beeinflussen, sodass man die LEDs schnell oder langsam (oder irgend etwas dazwischen) blinken lassen kann.

Dann kommt ein Helligkeits-Sensor dazu, der dafür sorgt, dass die LEDs nur dann blinken, wenn es dafür dunkel genug ist. Die Schwelle (was gilt als hell, was als dunkel) werden wir mit Konstanten im Programm einstellen können.

Des Weiteren werden wir einen Taster dazu nehmen. Mit diesem Taster können wir durch drei verschiedene Betriebs-Zustände wechseln (alles aus / normaler Blink-Betrieb / alles ein). Der letzte Zustand wird vor Allem praktisch sein zum Prüfen, ob noch alle LEDs einwandfrei funktionieren.

Die nächste Ausbau-Stufe wird ein Fernseh-Simulator sein. Dazu verwenden wir eine dreifarbige LED. Damit können wir viele verschiedene Farben zusammen mischen. Wenn wir sie schnell, unregelmässig und farblich abwechselnd leuchten lassen, wird das (durchs Fenster, ev. mit Vorhängen) aussehen wie ein laufender Fernseher.

Zuletzt folgt dann eine Ampel-Anlage für die Strasse. Diese werden wir nicht für eine komplexe, mehrspurige Kreuzung für Auto, Velofahrer und Fussgänger (die beiden letztgenannten beachten die Ampeln ja sowieso nicht) realisieren, sondern ganz einfach für eine Baustelle, die nur Einbahn-Betrieb zulässt.

Das wär's dann (es sei denn, es kommen immer wieder neue Ideen dazu).