===== Arduino-WS (3) =====

**Arduino und die Programmiersprache C**

Inhalt des 3. Teils des Arduino-Workshops: Arrays und Schleifen (while und for)

<code>
Variablen: Typ Array KURZFORM (lang:s.u.)
--------------------
  const int LEN_a = 3;
  int a[LEN_a];        // [] deuten auf ein Array hin
  a[0]=3;
  a[1]=2;
  a[2]=1;
  int a[LEN_a] = { 3, 2, 1 }; // ergibt dasselbe

  // a[1] ist 2
  a[1] = 0;  // ergibt für a: { 3, 0, 1 }
  // a[1] ist 0


Schleifen: while / for KURZFORM (lang:s.u.)
----------------------

int a[LEN_a] = { 3, 2, 1 };

// while-Schleife
int i=0;
while(i<LEN_a)   // Am Ende kein ';' hinschreiben!!! Keine Fehlermeldung!
{     
  ...benutze a[i]...
  i++;           // Bem.: i++ ist Kurzform für i+=1 ist Kurzform für i=i+1
}

// for-Schleife mit derselben Wirkung
//   das "int " kann man ins for einfach mit reinschreiben, es geht aber auch vorweg
for(int i=0; i<LEN_a; i++) // Am Ende kein ';' hinschreiben!!! Keine Fehlermeldung!
{
  ...benutze a[i]...
}



Einfacher Lauflicht-Code:
-------------------------
const int PIN_LED0 = 13;
const int PIN_LED1 = 4;
const int PIN_LED2 = 5;
const int PIN_POTI = A0;

void setup()
{
  pinMode(PIN_LED0, OUTPUT);
  pinMode(PIN_LED1, OUTPUT);
  pinMode(PIN_LED2, OUTPUT);
  // Analog-Pin PIN_POTI muß nicht initialisiert werden.
}

void loop()
{
  int poti = analogRead(PIN_POTI);

  digitalWrite(PIN_LED0, 1);
  delay(poti);
  digitalWrite(PIN_LED0, 0);

  digitalWrite(PIN_LED1, 1);
  delay(poti);
  digitalWrite(PIN_LED1, 0);
  
  digitalWrite(PIN_LED2, 1);
  delay(poti);
  digitalWrite(PIN_LED2, 0);
}


Mit Array und Schleife hingeschrieben
-------------------------------------
const int PIN_LEDs = 3;
int PIN_LED[PIN_LEDs] = { 13, 4, 5};

const int PIN_POTI = A0;

void setup()
{
  for (int i=0; i<PIN_LEDs; i++)
    pinMode(PIN_LED[i], OUTPUT);  // Bei genau einem Befehl kann man die { } weglassen

  // Analog-Pin PIN_POTI muß nicht initialisiert werden.
}

void loop()
{
  int poti = analogRead(PIN_POTI);

  for (int i=0; i<PIN_LEDs; i++)
  { digitalWrite(PIN_LED[i], 1);
    delay(poti);
    digitalWrite(PIN_LED[i], 0);
  }
}
</code>


**Arrays und Schleifen ausführlicher**

<code>
Variablen: Typ Array
--------------------

  const int LEN_a = 3;
  int a[LEN_a];        // [] deuten auf ein Array hin
  a[0]=3;
  a[1]=2;
  a[2]=1;
  int a[LEN_a] = { 3, 2, 1 }; // ergibt dasselbe

  // a[1] ist 2
  a[1] = 0;  // ergibt für a: { 3, 0, 1 }
  // a[1] ist 0

  char meintext[]= "Bla bla";  // ä,ö,ü,... gehen evtl. nicht
  // strlen(meintext)  ergibt 7  (Länge des Strings)
  // sizeof(meintext)  ergibt 8  (Speicherverbrauch in Byte)
  char meintext[]= {'B', 'l', 'a', ' ', 'b', 'l', 'a', 0}; // das Gleiche
  //                                                   ^-Ende-Markierung
  // "ASCII-Tabelle" (Auszug):
  // ' ' == 32
  // '!' == 33
  // '0' == 48
  // '1' == 49
  // 'A' == 65
  // 'B' == 66
  // 'a' == 97
  // 'b' == 98
  // Zur Erinnerung:
  //   char          konnte -128...127 (oder evtl. 0...255) speichern
  //   unsigned char konnte    0...255 speichern
  //   signed char   konnte -128...127 speichern
  //   alle obigen   verbrauchen 1 Byte
  
  int a[LEN_a] = { 3, 2, 1 };
  int *meinzeiger = a;
  // meinzeiger[i] ist dasselbe wie a[i]
  a[2] = 0;
  // meinzeiger[2] ist 0

  // Achtung: sizeof(...) (Speicherverbrauch) geht nicht immer wie man erwartet!
  // sizeof(a) ist der Speicherverbrauch für das Array a, also 3*2Byte
  // sizeof(meinzeiger) ist der Speicherverbrauch für einen Zeiger



Serielle Schnittstelle (UART)
-----------------------------
Arduino-Dokus (nicht nur dazu) siehe:
  http://www.arduino.cc/en/Reference/HomePage
  http://labs.arduino.org/Arduino+Reference

void setup()
{
  Serial.begin(9600);
  Serial.println("Hallo Welt!");
}
void loop()
{ if (Serial.available())
  { char c = Serial.read();
  
    Serial.print("Gesehen: ");
    Serial.println(c);  // "ln" bedeutet Zeilenfortsatz danach
    
    char s[]="Gesehen: x";
    s[9] = c;  // c anstelle des 'x'
    Serial.println(s);
  }
}
// Serial.println(x); ist nicht C, sondern C++ (Indiz: der '.' "im Namen").
// Es gibt x aus, wobei x Ein int, float, char *, ... etc. ein kann



Schleifen: while / for
----------------------

const int LEN_a = 3;
int a[LEN_a] = { 3, 2, 1 };

// while-Schleife
int i=0;
while(i<LEN_a)   // Am Ende kein ';' hinschreiben!!! Keine Fehlermeldung!
{     
  Serial.println(a[i]);
  i++;           // Bem.: i++ ist Kurzform für i+=1 ist Kurzform für i=i+1
}
// Gibt aus:
3
2
1

// for-Schleife mit derselben Wirkung
//   das "int " kann man ins for einfach mit reinschreiben, es geht aber auch vorweg
for(int i=0; i<LEN_a; i++) // Am Ende kein ';' hinschreiben!!! Keine Fehlermeldung!
{
  Serial.println(a[i]);
}


Mit Funktion hingeschrieben:

void listeElemente(int *ar, int laenge)  // nicht länge schreiben
{ 
  for(int i=0; i<laenge; i++)
  { 
    Serial.println(ar[i]);
  }
}
listeElemente(a,LEN_a);


// man kann auch mehrere Einträge an 1. und 3. Stelle schreiben:
int a[LEN_a] = { 3, 2, 1 };
for(int i=0, int j=3;  i<laenge;  i++, j--)
{
  Serial.print("i=");
  Serial.print(i);
  Serial.print("  a[i]=");
  Serial.print(a[i]);
  Serial.print("  j=");
  Serial.println(j);
}
// gibt aus:
i=0  a[i]=3  j=3
i=1  a[i]=2  j=2
i=2  a[i]=1  j=1


// man kann auch mehrere Schleifen ineinander schachteln:
for (int j=0; j<3; j++)  // zählt j von 0 bis 2
{
  for (int i=0; i<2; i++)  // zählt i von 0 bis 1
  {
    Serial.print(j);
    Serial.print(" ");
    Serial.println(i);
  }
}
// gibt aus:
0 0
0 1
1 0
1 1
2 0
2 1



2-dimensionale Arrays
---------------------
const int PHASEN   = 4;
const int PIN_LEDs = 3;

int PIN_LED[PIN_LEDs] = { 3, 5, 6};

int muster[PHASEN][PIN_LEDs] =
{ {0,1,0},
  {1,0,1},
  {0,1,0},
  {0,0,0}
};
// Zugriff geht dann so:
//   muster[1][2] ergibt 1
//   muster[3][2] ergibt 0  (der jeweils höchste erlaubte Index!)

</code>


**Aufgabe**

  * Blinkmuster hinschreiben
  * Das Blinkmuster immer wiedergeben, mit Pause dazwischen
  * Ziel: Ein Spiel bauen, bei dem man eine zufällig ausgewählte Folge von Lichtsignalen nachspielen soll (mit Tastern neben den z.B. 3 oder 4 LEDs, die für diese Folge von Lichtsignalen dienen). Bei Erfolg kann man dann evtl. eine längere zufällige Folge vorgeben. Man kann auch Töne mit den Lichtsignalen verbinden. Wer bei einem Frickl (nicht Workshop-Termin) vorbei kommt, wir dabei unterstützt, das zu bauen und zu programmieren. Achtung: Für das Spiel ist unten eingeführtes Array "muster" dann weniger geeignet, weil beim Spiel immer nur eine LED zur Zeit leuchten sollte, reicht da ein eindimensionales Array (int muster[PHASEN]).

<code>
const int PHASEN   = 4;
const int PIN_LEDs = 3;

int PIN_LED[PIN_LEDs] = { 3, 5, 6};

int muster[PHASEN][PIN_LEDs] =
{ {0,1,0},
  {1,0,1},
  {0,1,0},
  {0,0,0}
};
// Zugriff geht dann so:
//   muster[1][2] ergibt 1
//   muster[3][2] ergibt 0  (der jeweils höchste erlaubte Index!)

void setup()
{
  for (int i=0; i<PIN_LEDs; i++)
    pinMode(PIN_LED[i], OUTPUT);  // Bei genau einem Befehl kann man die { } weglassen
}

void loop()
{ int zeit = 500;  // Parameter fürs delay(zeit);

  // bitte ausfüllen...
}
</code>