LED-Matrix Wür­feln

Lese­zeit: 5 Minu­ten

Lösung
Seite als PDF

Wenn der Tas­ter gedrückt wird, wür­felt der Ardui­no eine Zahl zwi­schen 1 und 6. Bevor das Ergeb­nis ange­zeigt wird, zeigt die LED-Matrix in schnel­ler Fol­ge zufäl­lig aus­ge­wähl­te Zahlen. 

Die ein­zel­nen LEDs wer­den in Rei­hen und Spal­ten ange­spro­chen.
Die Schreib­wei­se für jede Rei­he kann binär ange­ge­ben wer­den: 0 = aus, 1 = an. Den Wer­ten wird ein "B" vor­an­ge­stellt.
Die LED-Matrix wur­de in das Steck­brett ein­ge­setzt, daher ver­lau­fen die Rei­hen ver­ti­kal und die Spal­ten horizontal.

Array

void Sechs()
{
  byte Zeichen[8] =
  {
    B11011011,
    B11011011,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B11011011,
    B11011011
  };

  // Matrix anzeigen
  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }

Als Ers­tes musst du eine Biblio­thek installieren:

Jedem Befehl muss der Name der Matrix mit abschlie­ßen­dem . vor­an­ge­stellt werden.

Funk­tio­nen der Biblio­thek LEDControl

Schlüs­sel­wortAkti­on
Led­Con­trol Name_der_Matrix(Data-In, CLK, CS, AnzahlMatrix)LED-Matrix initia­li­sie­ren:
Led­Con­trol LED­Ma­trix = LedControl(12, 11, 10, 1); 
shutDown(NummerMatrix, true/false)Matrix auf­we­cken:
shutDown(0, false);
setIntensity(NummerMatrix, Hel­lig­keit)Hel­lig­keit set­zen (0−20)
setIntensity(0, 8);
clearDisplay(NummerMatrix)clearDisplay(0);
setLed(NummerMatrix, Zei­le, Spal­te, true/false);ein­zel­ne LED schalten
setLed(0, 0, 0, true);
setRow(NummerMatrix, Zei­le, Byte)zei­len­wei­se ein Byte schreiben:
setRow(0, Zei­le, B10000000);
setRow kann Wer­te zwi­schen 0 und 7 haben

Wenn die LED-Matrix in das Steck­brett gesetzt wird, ver­lau­fen die Rei­hen vertikal.
setColumn(NummerMatrix, Spal­te, Byte)spal­ten­wei­se ein Byte schreiben:
setColumn(0, Spal­te, B10000000);
set­Co­lumn kann Wer­te zwi­schen 0 und 7 haben

Wenn die LED-Matrix in das Steck­brett gesetzt wird, ver­lau­fen die Spal­ten horizontal.

Pin­be­le­gung LED-Matrix

Benö­tig­te Bauteile:

  • Tas­ter
  • LED-Matrix
  • Lei­tungs­dräh­te

Baue die Schal­tung auf.
(Fah­re mit der Maus über das Bild, um die Bezeich­nun­gen der Bau­tei­le zu sehen)

Bin­de die benö­tig­te Biblio­thek ein und defi­nie­re die Variablen:

#include "LedControl.h"

int TASTER = 7;

int TasterLesen;
int Zahl;
int Minimum = 1;

int Maximum = 7;

LedControl LEDMatrix = LedControl(12, 11, 10, 1);

Star­te im set­up-Teil die LED-Matrix und lege den pin­Mo­de für den Tas­ter fest:

void setup() 
{
  // Matrix "aufwecken"
  LEDMatrix.shutdown(0, false);

  //  mittlere Helligkeit setzen
  LEDMatrix.setIntensity(0, 8);

  // Zufallsgenerator starten
  randomSeed(A0);
  pinMode(TASTER, INPUT_PULLUP);
}

Ver­wen­de für die Ermitt­lung der Zufalls­zahl eine ⇒Funk­ti­on.

int ZufallsZahl()
{
  Zahl =  random(Minimum, Maximum);
  return Zahl;
}

Die ⇒Funk­ti­on Wuer­feln() ermit­telt eine Zufalls­zahl und zeigt sie an.
Die Abfra­ge der Zufalls­zahl kannst du mit ⇒switch … case erledigen.

Ver­wen­de für die Anzei­ge der Wür­fel­au­gen die fol­gen­den Funktionen:

void Eins()
{
  byte Zeichen[8] =
  {
    B00000000,
    B00000000,
    B00000000,
    B00011000,
    B00011000,
    B00000000,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Zwei()
{
  byte Zeichen[8] =
  {
    B11000000,
    B11000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000011,
    B00000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Drei()
{
  byte Zeichen[8] =
  {
    B11000000,
    B11000000,
    B00000000,
    B00011000,
    B00011000,
    B00000000,
    B00000011,
    B00000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Vier()
{
  byte Zeichen[8] =
  {
    B11000011,
    B11000011,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B11000011,
    B11000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Fuenf()
{
  byte Zeichen[8] =
  {
    B11000011,
    B11000011,
    B00000000,
    B00011000,
    B00011000,
    B00000000,
    B11000011,
    B11000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Sechs()
{
  byte Zeichen[8] =
  {
  B11011011,
  B11011011,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B11011011,
  B11011011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}
void Wuerfeln()
{
  Zahl = ZufallsZahl();

  switch (Zahl)
  {
    case 1:
      Eins();
      break;

    case 2:
      Zwei();
      break;

    case 3:
      Drei();
      break;

    case 4:
      Vier();
      break;

    case 5:
      Fuenf();
      break;

    case 6:
      Sechs();
      break;
  }
}

Im loop-Teil wird der Tas­ter abge­fragt und in der ⇒for-Schlei­fe das Wür­feln simuliert:

void loop() 
{
  TasterLesen = digitalRead(TASTER);
  if (TasterLesen == LOW)
  {
    delay(300);
    // Würfeleffekt
    for (int i = 0; i < 5; i++)
    {
      int Zahl =  random(Minimum, Maximum);
      Wuerfeln();
      delay(200);
    }
  }
}

Startseite
Aufgaben A-Z
Suchen
Downloads
Fehlermeldungen
Seite als PDF

Ver­wand­te Anleitungen:


Letzte Aktualisierung: 22. Apr 2024 @ 8:16