LED-Matrix - Countdown

Lese­zeit: 6 Minu­ten
Lösung
Seite als PDF

Die LED-Matrix soll nach einem Tas­ter­druck einen Count­down von 9 bis 0 Sekun­den anzei­gen. Zusätz­lich ertönt jede Sekun­de ein kur­zer Ton.
Beim Start des Pro­gramms wird ein Pfeil nach unten ange­zeigt, am Ende ein Kreuz.

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.

void PfeilUnten()
{
  byte Zeichen[8] = 
  {
     B00010000, // 1. Reihe
     B00110000, // 2. Reihe
     B01111111, // 3. Reihe
     B11111111, // 4. Reihe
     B01111111, // 5. Reihe
     B00110000, // 6. Reihe
     B00010000, // 7. Reihe
     B00000000  // 8. Reihe
  };

  // Matrix anzeigen
  for (int i = 0; i < 8; i ++)   
  { 
    LEDMatrix.setRow(0, i, Zeichen[i]);   
  }
} 
void Kreuz()
{
  byte Zeichen[8] = 
  {
    B10000001, // 1. Reihe
    B01000010, // 2. Reihe
    B00100100, // 3. Reihe
    B00011000, // 4. Reihe 
    B00011000, // 5. Reihe 
    B00100100, // 6. Reihe
    B01000010, // 7. Reihe
    B10000001  // 8. Reihe  
  };

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

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.

➨Array

Schlie­ße die LED-Matrix an.

Pin­be­le­gung LED-Matrix

Benö­tig­te Bauteile:

  • Taster 
  • LED-Matrix 
  • Leitungsdrähte 
  • Lautsprecher 

Im Kopf des Pro­gramms musst du die benö­tig­te Biblio­thek ein­bin­den und die Pin­be­le­gung der LED-Matrix fest­le­gen.
Im set­up-Teil wird die LED-Matrix gestar­tet und der pin­Mo­de des Tas­ter und des Laut­spre­chers festgelegt.

# include "LedControl.h" 
/* 
  VCC →  5V    
  GND    
  Pin 12 →  DATA IN Pin   
  Pin 10 →  CLK Pin  
  Pin 11 →  CS Pin 
*/ 
LedControl LEDMatrix = LedControl(12, 11, 10, 1);
 
int TASTER = 7;
int LAUTSPRECHER = 5; 

int TasterLesen; 

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

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

Im loop-Teil wird zunächst der Pfeil nach unten ange­zeigt und der Tas­ter abge­fragt. Anschlie­ßend wird nach jeweils einer Sekun­de Pau­se die nächs­te Zahl ange­zeigt. Nach Ablauf der Zeit erscheint das Kreuz.

void loop()  
{ 
  PfeilUnten(); 

  TasterLesen = digitalRead(TASTER); 

  if (TasterLesen == LOW)   
  { 
    delay(300);
    ZahlNeun();
    tone(LAUTSPRECHER, 1000, 100); 
    delay(1000); 

    ZahlAcht(); 
    tone(LAUTSPRECHER, 1000, 100); 
    delay(1000); 

    ZahlSieben(); 
    tone(LAUTSPRECHER, 1000, 100); 
    . . .
    . . .
    Kreuz(); 
    delay(2000); 
  }
}

Hier sind die benö­tig­ten Funk­tio­nen für die Zah­len, den Pfeil und das Kreuz:

void PfeilUnten()
{
  byte Zeichen[8] =
  {
    B00010000,
    B00110000,
    B01111111,
    B11111111,
    B01111111,
    B00110000,
    B00010000,
    B00000000
  };

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

void ZahlEins()
{
  byte Zeichen[8] =
  {
    B00000000,
    B00000000,
    B00000100,
    B10000010,
    B11111111,
    B10000000,
    B00000000,
    B00000000
  };

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


void ZahlZwei()
{
  byte Zeichen[8] =
  {
    B00000000,
    B10000010,
    B11000001,
    B10100001,
    B10010001,
    B10001110,
    B00000000,
    B00000000
  };

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

void ZahlDrei()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01000010,
    B10000001,
    B10001001,
    B10001001,
    B01110110,
    B00000000,
    B00000000
  };

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

void ZahlVier()
{
  byte Zeichen[8] =
  {
    B00000000,
    B00110000,
    B00101000,
    B00100100,
    B11110010,
    B00100001,
    B00000000,
    B00000000
  };

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

void ZahlFuenf()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01001111,
    B10001001,
    B10001001,
    B10001001,
    B01110001,
    B00000000,
    B00000000
  };

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

void ZahlSechs()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01111110,
    B10001001,
    B10001001,
    B10001001,
    B01110010,
    B00000000,
    B00000000
  };

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

void ZahlSieben()
{
  byte Zeichen[8] =
  {
    B00000000,
    B11100001,
    B00010001,
    B00001001,
    B00000101,
    B00000011,
    B00000000,
    B00000000
  };

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

void ZahlAcht()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01110110,
    B10001001,
    B10001001,
    B10001001,
    B01110110,
    B00000000,
    B00000000
  };

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

void ZahlNeun()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01001110,
    B10010001,
    B10010001,
    B10010001,
    B01111110,
    B00000000,
    B00000000
  };

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

void ZahlNull()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01111110,
    B10000001,
    B10000001,
    B10000001,
    B01111110,
    B00000000,
    B00000000
  };

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

void Kreuz()
{
  const PROGMEM byte Zeichen[8] =
  {
    B10000001,
    B01000010,
    B00100100,
    B00011000,
    B00011000,
    B00100100,
    B01000010,
    B10000001
  };

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

Wenn du die LED-Matrix "lie­gend" betrei­ben willst, fin­dest du die Funk­tio­nen ➨hier.

Startseite
Aufgaben A-Z
Suchen
Downloads
Fehlermeldungen
Seite als PDF

Ver­wand­te Anleitungen:

Letzte Aktualisierung: 22. Apr 2024 @ 10:53