no way to compare when less than two revisions

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

@@ Zeile 1: / Zeile 1: @@
+====== Architektur eines Sketches ======
+Du hast nun deinen Arduino an den Rechner angeschlossen und das erste Mal ein Programm hochgeladen. Nun ist es an der Zeit, die Programme mal näher unter die Lupe zu nehmen.
+Die Arduino-Umgebung bietet bereits eine Menge an Beispielprogrammen, die du dir angucken kannst.
+===== Minimales Programm =====
+Jedes Arduinoprogramm besteht zunächst aus zwei Teilen, ''setup'' und ''loop''.
+  * in der setup-Methode steht alles, was nur am Anfang einmal ausgeführt werden soll
+  * in der loop-Methode steht der Hauptteil des Programms, der (wie der Name sagt) als Schleife theoretisch unendlich lang läuft
+Diesen Grundaufbau findest du im Programm ''BareMinimum'', welches du unter Basics findest.
+<code>
+void setup(){
+  // einmal
+}
+void loop(){
+  // immer wieder
+}
+</code>
+===== Signale lesen und schreiben =====
+Bevor du loslegst mit senden und empfangen, musst du dem Arduino mitteilen, welche Pins du wofür benutzen willst:
+  * mit ''pinMode( //n//, OUTPUT)'' legst du fest, dass du an Pin Nummer //n// Signale senden willst
+  * mit ''pinMode( //n//, INPUT)'' entsprechend, dass du Signale empfangen willst
+Das solltest du nur einmal tun, also gehört das in ''setup''.  Senden und empfangen willst du dagegen die ganze Zeit, das tust du also in ''loop''.
+Ein //Pin// ist ein Ein- oder Ausgang des Arduinos. Die Nummern zu den Pins stehen auf der Platine.
+==== Digitale Signale ====
+Digitale Signale können genau zwei Werte annehmen, HIGH und LOW. Diese stehen dir als Konstanten zur Verfügung.
+  * HIGH = 1 = an
+  * LOW = 0 = aus
+Lesen und schreiben lassen sich Pins mit den folgenden beiden Methoden:
+  * mit ''digitalRead(//pin//)'' liest das Signal auf dem Pin, also HIGH oder LOW
+  * mit ''digitalWrite(//pin//, HIGH)'' schreibt das Signal HIGH (LOW analog)
+So liest man zum Beispiel, welcher Wert gerade an Pin 2 anliegt:
+<code>
+wert = digitalRead(2);
+</code>
+Ein einfaches Beispiel zum Schreiben liefert das Programm ''blink'':
+<code>
+void setup(){
+  pinMode(13, INPUT);
+}
+void loop(){
+  digitalWrite(13, HIGH); // LED an
+  delay(1000); // warte eine Sekunde
+  digitalWrite(13, LOW); // LED aus
+  delay(1000); // warte eine Sekunde
+}
+</code>
+Während der Wartezeit bleibt das Signal auf den Pins gleich, die LED ist also abwechselnd 1s an und 1s aus.
+Ein Beispiel, in dem beide Funktionen genutzt werden findest du unter Digital -> Button.
+==== Analoge Signale ====
+Analoge Signale sind etwas komplexer als digitale Signale. Sie können nicht nur zwischen HIGH und LOW unterscheiden, sondern auch zwischen einer Vielzahl von Werten dazwischen, abhängig von der Spannung. Die Werte sind für Lesen und schreiben unterschiedlich feingranular.
+  * lesen: Werte zwischen 0 (aus) und 1023 (an), also 1024 Werte / 10 bit Auflösung
+  * schreiben: Werte zwischen 0 (aus) und 255 (an), also 256 Werte / 8 bit Auflösung
+Lesen und schreiben lassen sich Pins mit den folgenden beiden Methoden:
+  * ''analogRead(//pin//)'' liest das Signal vom Pin, das zwischen 0 und 1023 liegt
+  * ''analogWrite(//pin//, wert)'' schreibt das Signal ''wert'' zwischen 0 und 255 auf den Pin
+Die Benutzung ist recht ähnlich zum digitalen Lesen und Schreiben (abgesehen von der Art der Werte). Das große Spektrum an Werten eignet sich besonders, um z.B. statt hartem Blinken einer LED einen weichen Übergang zwischen hell und dunkel zu erhalten. Ein Beispiel dafür findest du unter Analog -> Fading.
+====== Nützliche Kontrollstrukturen ======
+Wie in allen höheren Programmiersprachen gibt es auch auf dem Arduino einige nützliche Kontrollstrukturen. Die Beispiele hier sind recht knapp gehalten - ausführliche Beispiele findest du unter Control.
+===== Nichts tun =====
+Einfach aber nützlich: Du kannst den Arduino eine bestimmte Zeit lang warten lassen:
+<code>delay(int);</code>
+Die angegebene Zahl sind Millisekunden, und es handelt sich um ganze Zahlen (Datentyp int).
+===== If-Verzweigung =====
+Wenn du etwas abhängig von einer Bedingung ausführen willst, dann kannst du das mit ''if''-Verzweigungen tun:
+<code>
+if(a < b){
+  // falls a < b, tu das hier
+}
+else {
+  // ansonsten tu das hier
+}
+</code>
+Das Ganze lässt sich bei Bedarf natürlich auch schachteln:
+<code>
+if(a < b){
+  // falls a < b tu das hier
+  if(c < d){
+    // falls a < b  UND c < d, tu das hier
+  }
+  else {
+    // falls a < b UND NICHT c > d, tu das hier
+  }
+}
+else {
+  // ansonsten tu das hier
+}
+</code>
+usw. ;-)
+===== Fallunterscheidung mit switch =====
+Falls du abhängig vom Wert einer Variablen etwas tun willst, sind ''switch''-Unterscheidungen das Richtige für dich. Hier solltest du alle Fälle, die dir wichtig sind, abhandeln. Für alle anderen Fälle gibt es ''default''.
+<code>
+switch(zahl){
+  case 0:
+    // falls zahl = 0...
+    break;
+  case 1:
+    // falls zahl = 1...
+  case 42:
+    // falls zahl = 42...
+    break;
+  default:
+    // falls zahl anders als die angegebenen Zahlen (nicht 0, 1, oder 42)
+}
+</code>
+Falls du noch nie programmiert hast, fragst du dich vielleicht, was das ''break;'' da soll. Wenn dein Programm schon gemerkt hat, dass die Zahl Null ist, dann ist es überflüssig, darüber hinaus auch noch zu prüfen, ob sie vielleicht auch Eins ist, oder 42.
+**Wäre das denn so schlimm? Die 2-3 Zeilen auszuführen dauert doch nicht lange.**
+Nein, lange brauchen sie wirklich nicht in diesem Fall. **Aber** es wird nicht nur alles angeguckt, sondern auch alles ausgeführt.
+Das heißt in diesem Beispiel: Da nach case 1 das break fehlt, wird im Fall, dass ''zahl = 1'' ist auch der Code für ''zahl = 42'' ausgeführt.
+In den meisten Fällen //willst// du das nicht. :-)
+===== Zähl-Schleifen =====
+Mit ''for''-Schleifen kannst du ein bestimmtes Stück Code genau so oft ausführen, wie du festlegst.
+Wenn du es ''zahl'' mal willst, schreibst du das einfach folgendermaßen:
+<code>
+for(int i = 0; i < zahl; i++){
+  // tue etwas
+  delay(i * 1000);
+}
+</code>
+Innerhalb der Schleife kannst du auf ''i'' zugreifen. Hier wird nach dem Ausführen des Codes ''i'' Sekunden lang gewartet (''delay'' wird in Millisekunden gezählt).
+===== Bedingte Schleifen =====
+Mit ''while''-Schleifen kannst du ein bestimmtes Stück Code so lange immer wieder ausführen, wie eine bestimmte Bedingung gilt.
+Nehmen wir mal an, du hast
+  * einen Schalter, der an Pin ''schalter'' angebunden ist und Signale liefert (HIGH für gedrückt, LOW sonst)
+  * eine LED, die an Pin ''led'' angebunden ist und Signale empfängt (HIGH für an, LOW für aus)
+Du willst, dass die LED immer dann angeschaltet wird, wenn der Schalter gedrückt ist.
+<code>
+// solange der Schalter gedrückt ist...
+while(digitalRead(schalter) == HIGH){
+  // ... schalte die LED an
+  digitalWrite(led, HIGH);
+}
+// wenn der Schalter nicht mehr gedrückt ist, schalte die LED aus
+digitalWrite(led, LOW);
+</code>