LEDs mit einem Joystick-Shield schalten

Lese­zeit: 8 Minu­ten

Lösung
Seite als PDF
Navi­ga­ti­on

Mit einem Joystick-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 LEDs
  • 4 Wider­stän­de > 100 Ω
  • Joystick-Shield
  • Lei­tungs­dräh­te

Das Joystick-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 Joystick-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 Joystick-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-Achse, A1 die Wer­te auf der Y-Achse. 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.

Wird ein Tas­ter län­ge­re Zeit gedrückt, kommt es zum soge­nann­ten „Prel­len“ des Tas­ters. In die­sem Fall wird der Name des Tas­ters mehr­fach angezeigt.

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 Taster[] = { 2, 3, 4, 5 };

Das Array mit String bestimmt die Namen der Taster:

String NameTaster[] = { "A", "B", "C", "D" };

Die ➨ for-Schleife 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

size­of bestimmt die Grö­ße eines Arrays. 

Der gele­se­ne Wert des Tas­ters wird mit einer ➨ if-Abfrage 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-Abfrage aus­ge­wer­tet. Bei der Bewe­gung auf der X-Achse wird nur der Wert auf der X-Achse 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-Abfrage der Y-Achse 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 setup-Teil wird mit einer for-Schleife 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-Schleife 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 Aufgaben:


Letzte Aktualisierung: 29. Nov 2022 @ 11:24