LEDs mit einem Joy­stick-Shield schalten

Lese­zeit: 7 Minu­ten

Lösung
Seite als PDF

Mit einem Joy­stick-Shield sol­len vier LEDs mit den Tas­tern geschal­tet wer­den. Solan­ge der Tas­ter gedrückt wird, soll die LED leuch­ten. Der Joy­stick steu­ert ein Lauf­licht nach links und nach rechts.

So sieht es aus:

Benö­tig­te Bauteile:

  • 4 wei­ße LEDs
  • 4 Wider­stän­de 100 Ω, 220 Ω bei roten, gel­ben oder grü­nen LEDs
  • Joy­stick-Shield
  • Lei­tungs­dräh­te

Das Joy­stick-Shield besitzt ins­ge­samt sechs Tas­ter, die mit den Buch­sta­ben A bis E gekenn­zeich­net sind. Ein Joy­stick ver­voll­stän­digt das Shield. Es wird ein­fach auf den Ardui­no aufgesteckt.

Das Joy­stick-Shield besitzt ins­ge­samt sechs Tas­ter, die mit den Buch­sta­ben A bis E gekenn­zeich­net sind. Ein Joy­stick ver­voll­stän­digt das Shield. Es wird ein­fach auf den Ardui­no aufgesteckt.

Die digi­ta­len Pins D2 bis D8 sind mit den Tas­tern und dem Joy­stick-Knopf belegt. Die LEDs wer­den des­halb an den digi­ta­len Pins D9 bis D12 ange­schlos­sen. Der Joy­stick belegt die ana­lo­gen Anschlüs­se A0 und A1.

A0 liest die Wer­te auf der X-Ach­se, A1 die Wer­te auf der Y-Ach­se. Um die Bewe­gun­gen des Joy­sticks aus­zu­wer­ten, reicht es aus, die Wer­te der jewei­li­gen Ach­sen abzufragen.

Als Ers­tes sol­len die Tas­ter mit ihrem Namen und die Bewe­gung des Joy­sticks im Seri­el­len Moni­tor ange­zeigt werden.

Das dazu­ge­hö­ri­ge Programm:

// Array Taster
// Reihenfolge A B C D
int Taster[] = { 2, 3, 4, 5, 8 };

// Namen der Taster
String NameTaster[] = { "A", "B", "C", "D" };

// analoge Pins Joystick
byte XAchse = A0;
byte YAchse = A1;

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

  // pinMode der 4 Taster festlegen: sizeof = Größe des Arrays
  // INPUT_PULLUP -> Eingangspegel auf HIGH setzen
  for (int i = 0; i <= sizeof(Taster); i++) 
  {
    pinMode(Taster[i], INPUT_PULLUP);
  }
}

void loop() 
{
  // Taster der Reihe nach abfragen
  for (int i = 0; i < sizeof(Taster); i++) 
  {
    // wenn der jeweilige Taster gedrückt wird
    if (digitalRead(Taster[i]) == LOW) 
    {
      // kurzes delay -> Prellen des Tasters verringern
      delay(200);

      // Name des Tasters zuordnen
      Serial.println("Taste: " + NameTaster[i]);
    }
  }

  // Bewegung der Y-Achse lesen
  int PositionX = analogRead(XAchse);

  // Bewegung X-Achse nach links
  if (PositionX < 300) 
  {
    delay(200);
    Serial.println("Bewegung X-Achse nach links");
  }

  // Bewegung X-Achse nach rechts
  if (PositionX > 600) 
  {
    delay(200);
    Serial.println("Bewegung X-Achse nach rechts");
  }

  // Bewegung der Y-Achse lesen
  int PositionY = analogRead(YAchse);

  // Bewegung Y-Achse nach oben
  if (PositionY > 600) 
  {
    delay(200);
    Serial.println("Bewegung Y-Achse nach oben");
  }

  // Bewegung Y-Achse nach unten
  if (PositionY < 300) 
  {
    delay(200);
    Serial.println("Bewegung Y-Achse nach unten");
  }
}

Im Pro­gramm wer­den zwei ⇒Arrays ver­wen­det.
Das Array mit int legt die digi­ta­len Anschlüs­se der Tas­ter fest:

int Tas­ter[] = { 2, 3, 4, 5 };

Das Array mit String bestimmt die Namen der Taster:

String Name­Tas­ter[] = { "A", "B", "C", "D" };

Die ⇒ for-Schlei­fe star­tet mit 0 und fragt den Tas­ter im Array an der Posi­ti­on 0 (Tas­ter an D2) ab. Weil der Vor­wi­der­stand ein­ge­schal­tet ist (INPUT_PULLUP) wird gefragt, ob der digi­tal gele­se­ne Wert LOW ist. Ist das der Fall, wird der Name des Tas­ters aus­ge­ge­ben, der sich an der glei­chen Posi­ti­on im Array befindet:

  • Taster[0] wird NameTaster[0] zuge­ord­net: digi­ta­ler Pin D2 ⇒ A
  • Taster[1] wird NameTaster[1] zuge­ord­net: digi­ta­ler Pin D3 ⇒ B
  • Taster[2] wird NameTaster[2] zuge­ord­net: digi­ta­ler Pin D4 ⇒ C
  • Taster[3] wird NameTaster[0] zuge­ord­net: digi­ta­ler Pin D5 ⇒ D

sizeof bestimmt die Grö­ße eines Arrays. 

Der gele­se­ne Wert des Tas­ters wird mit einer ⇒ if-Abfra­ge mit den Wer­ten HIGH oder LOW ver­gli­chen.
Wenn er den Wert LOW hat, zeigt der Seri­el­le Moni­tor den Namen des Tas­ters an.
Der Joy­stick wird eben­falls mit einer if-Abfra­ge aus­ge­wer­tet. Bei der Bewe­gung auf der X-Ach­se wird nur der Wert auf der X-Ach­se ver­gli­chen. Ist er klei­ner als 300, wur­de der Joy­stick nach links bewegt. Ist er grö­ßer als 600, wur­de er nach rechts bewegt.
Auch die if-Abfra­ge der Y-Ach­se ver­gleicht nur die gele­se­nen Wer­te der Y-Achse.

// Array Taster
// Reihenfolge A B C D
byte Taster[] = { 2, 3, 4, 5, 8 };

// analoge Pins Joystick
byte XAchse = A0;
byte YAchse = A1;

// Array für die LEDs
byte LED[5] = { 9, 10, 11, 12 };

Im set­up-Teil wird mit einer for-Schlei­fe der pin­Mo­de für die LEDs ergänzt.

void setup() 
{
  // Seriellen Monitor starten
  Serial.begin(9600);

  // pinMode der 4 Taster festlegen: sizeof = Größe des Arrays
  // INPUT_PULLUP -> Eingangspegel auf HIGH setzen
  for (int i = 0; i <= sizeof(Taster); i++) 
  {
    // INPUT_PULLUP -> Eingangspegel auf HIGH setzen
    pinMode(Taster[i], INPUT_PULLUP);
  }

  // pinMode der LEDs festlegen
  for (int i = 0; i < sizeof(LED); i++) 
  {
    pinMode(LED[i], OUTPUT);
  }
}

Inner­halb der for-Schlei­fe wird jetzt die dem Tas­ter zuge­ord­ne­te LED eingeschaltet.

  • Taster[0] wird LED[0] am digi­ta­len Pin D9 zugeordnet
  • Taster[1] wird LED[1] am digi­ta­len Pin D10 zugeordnet
  • Taster[2] wird LED[2] am digi­ta­len Pin D11 zugeordnet
  • Taster[3] wird LED[3] am digi­ta­len Pin D12 zugeordnet

Die Abfra­ge der Bewe­gung des Joy­sticks wird mit dem Lauf­licht ergänzt.

void loop()
{
  // Zustand der Taster der Reihe nach abfragen
  for (int i = 0; i < sizeof(Taster); i++)
  {
    // wenn der jeweilige Taster gedrückt wird
    // wird der Zustand der jeweiligen LED true
    // -> LED wird eingschaltet
    if (digitalRead(Taster[i]) == LOW)
    {
      digitalWrite(LED[i], HIGH);
      Serial.println("Taste: " + String(Taster[i]));
    }
    // wenn der Taster nicht gedrückt wurde
    // -> LED bleibt ausgeschaltet
    else digitalWrite(LED[i], LOW);
  }

  // Bewegung der Y-Achse lesen
  int PositionX = analogRead(XAchse);

  // Bewegung X-Achse nach links
  // Lauflicht nach links,
  // for-Schleife läuft rückwärts
  if (PositionX > 600)
  {
    for (int i = 0; i < sizeof(LED); i++)
    {
      digitalWrite(LED[i], HIGH);
      delay(200);
      digitalWrite(LED[i], LOW);
    }
  }

  // Bewegung X-Achse nach links
  // Lauflicht nach links
  if (PositionX < 300)
  {
    for (int i = sizeof(LED); i >= 0; i--)
    {
      digitalWrite(LED[i], HIGH);
      delay(200);
      digitalWrite(LED[i], LOW);
    }
  }
}

Startseite
Aufgaben A-Z
Suchen
Downloads
Fehlermeldungen
Seite als PDF

Ver­wand­te Anleitungen:


Letzte Aktualisierung: 11. Okt 2023 @ 9:09