In diesem Artikel zeige ich dir, wie der TM1638 7-Segment-LED-Treiber-IC funktioniert und wie du ihn mit einem Arduino UNO verbindest.
Ich habe den LED-Treiber-IC TM1638 bereits in früheren Projekten verwendet, da er dem Host-MCU eine enorme Menge an Arbeit abnimmt. Die Integration des LED-Treibers in dein Projekt ist einfach und unkompliziert.
Ich beginne damit, dir die Spezifikationen des LED-Treibers zu erklären, gebe Tipps und Tricks und zeige dir, wie du Ziffern anzeigen und die Tasten abfragen kannst.
Anschließend gehen wir ins Detail und betrachten die Anschlussanleitung sowie den Arduino-Code für die parallele Daten-Schnittstelle des TM1638 LED-Treibers. Außerdem beantworten wir häufig gestellte Fragen.
Schnapp dir dein Arduino-Board, und lass uns loslegen!
Benötigte Komponenten für das Arduino- und TM1638-Projekt
Hardware-Komponenten
- Arduino UNO x 1
- Arduino Compatible TM1638 display module x 1
- Dupont wire x 1 Satz
- USB Cable for Arduino Programming x 1
Software
Grundlagen des TM1638 LED-Treibermoduls
Lass uns zunächst die Hauptmerkmale des TM1638 LED-Treiber-IC verstehen:
- Steuerung von 8 Ziffern (7 Segmente)
- Ansteuerung von 8 LEDs
- Abfrage von acht taktilen Schaltern
- Du kannst die Helligkeit steuern
- Serielle Schnittstelle – CLK, DIO, STB
Eine typische Verbindung zwischen Arduino und dem TM1638 Treiber-IC ist im folgenden Bild dargestellt.
Im nächsten Abschnitt lernen wir die Schnittstellen zwischen verschiedenen Peripheriegeräten und dem TM1638 kennen.
Pinbelegung des TM1638 LED-Treiber-IC
| Pinname | Pin-Typ | Pin-Beschreibung |
| DIO | Daten Ein-/Ausgang | Serielle Daten zwischen Arduino und dem TM1638 Treiber-IC |
| STB | Chip-Select | Initialisiert die serielle Schnittstelle während der fallenden/steigenden Flanke, dann wird der Befehl empfangen. Das erste Byte ist der Befehl, wenn STB niedrig ist. CLK wird ignoriert, wenn STB hoch ist. |
| CLK | Takteingang | Eingang für serielle Daten |
| K1 ~ K3 | Tastatur-Scan-Dateneingang | Die an den Pin eingegebenen Daten werden nach Abschluss des Anzeigecyclus übernommen. |
| SEG1/KS1 ~ SEG8/KS8 | Ausgang (Segment) | Segment-Ausgang. Open-Drain-Ausgang. |
| SEG9 ~ SEG10 | Ausgang (Segment) | Segment-Ausgang. Open-Drain-Ausgang. |
| GRID1 ~ GRID8 | Ausgang (Gitter) | Gitter-Ausgang. Open-Drain-Ausgang. |
| VDD | Logikversorgung | 5 V ± 10% |
| GND | Logik-Masse | Masseanschlüsse |
Eine besondere Anmerkung zum DIO-Pin: Der Digital-Input-Output (DIO) Pin im TM1638 Modul ist ein N-type open drain. Du solltest einen externen Pull-up-Widerstand verwenden, um die DIO-Leitung auf logisch hoch zu ziehen. Der empfohlene Wert beträgt 10 kOhm. Siehe Schaltplan unten:
Tastatur-Scan und Tastatur-Scan-Datenregister
Die Tastatur-Scan-Bildrate beträgt 8 x 3 Bit. Es ist vergleichbar mit Reihen und Spalten. Du kannst es als eine Matrix aus acht Reihen und drei Spalten betrachten. Das bedeutet, du kannst bis zu 24 Taster verwenden.
Im folgenden Bild siehst du, wie du die K- und KS-Pins des TM1638 Treiber-ICs nutzt, um 24 Tasten abzufragen.
Befehlssatz
Du kannst die Bits B7 und B6 des DIO-Bits verwenden, um den Befehlstyp zu bestimmen. Der TM1638 IC nutzt den folgenden Dekodiermechanismus, um den vom Arduino gesendeten Befehlstyp zu identifizieren.
| B7 | B6 | Befehl |
| 0 | 1 | Daten-Befehlssatz |
| 1 | 0 | Anzeige-Steuerbefehlssatz |
| 1 | 1 | Adress-Befehlssatz |
Daten-Befehlssatz .
In der Regel wirst du hauptsächlich den Daten-Befehlssatz verwenden. Er ist verantwortlich für das Lesen und Schreiben von Daten. Hinweis: B1 und B0 dürfen für diesen Befehlssatz nicht auf 01 oder 11 gesetzt werden.
| B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 | Funktion | Befehl |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Daten-Schreibmodus setzen | Daten in Register schreiben |
| 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | Tastatur-Scan-Daten lesen | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Adress-Erhöhungsmodus setzen | Automatische Adresserhöhung |
| 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | Feste Adresse | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Testmodus | Normalmodus |
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | Testmodus |
In den folgenden Bildern siehst du das Timing und das Taktmuster sowohl beim Schreiben als auch beim Lesen vom TM1638 IC.
Beachte, dass beim Lesen der Daten vom Chip mindestens eine Verzögerung von 1 µs zwischen Befehl und Datenempfang eingefügt werden muss. Dies ist zwingend erforderlich.
Um herauszufinden, wie die TM1638 Display-Pins mit dem 7-Segment-LED-Display verbunden werden, siehe das folgende Bild. Das Beispiel zeigt einen Displaytyp mit gemeinsamer Kathode, bei dem alle Kathoden-Pins der LEDs zusammengeführt sind.
Alternativ gibt es den Displaytyp mit gemeinsamer Anode, bei dem alle Anoden-Pins der LEDs zusammengeführt sind.
Es ist wichtig, die elektrischen Spezifikationen des verwendeten Chips zu kennen. Das hilft dir beim Debuggen und stellt sicher, dass du den Chip nicht beschädigst. Je mehr du über die Details des IC weißt, desto einfacher ist es, Verbindungen herzustellen und zuverlässige Schaltungen zu bauen.
Nachfolgend die elektrischen Spezifikationen des TM1638 LED-Treiber-IC:
| Parameter | Bereich |
| Logik-Versorgungsspannung | Typisch 5 V |
| Eingangsspannung High-Level | Mindestens 0,7 x VDD |
| Eingangsspannung Low-Level | Maximal 0,3 x VDD |
| Ausgangsstrom High-Level | Maximal 40 mA |
| Ausgangsstrom Low-Level | Maximal 140 mA |
| Aktiver Stromverbrauch | Maximal 5 mA |
| Maximale Taktfrequenz | 1 MHz |
| Eingangskapazität | 15 pF |
Genug der Grundlagen ; ) In den nächsten Abschnitten bauen wir das Projekt!
Wie man den TM1638 mit dem Arduino UNO verbindet
Ich zeige dir jetzt, wie du ein Projekt mit Arduino UNO und dem TM1638 Display-Modul aufbaust. Fangen wir mit den Hardware-Verbindungen an.
Hier ist die Zusammenfassung der Verbindungen, die nötig sind, um den Arduino UNO mit dem TM1638 Modul zu verbinden. Ich hoffe, das gibt dir einen guten Überblick. Folge der Anschlussanleitung.
| Pin am TM1638 Modul | Arduino UNO Pin | Bemerkungen |
| VCC | 5 V | Stromversorgung |
| GND | GND | Masseanschlüsse |
| STB | Strobe-Leitung, Pin 8 | Beliebiger IO-Pin |
| CLK | Datenleitung, Pin 9 | Beliebiger IO-Pin |
| DIO | Taktleitung, Pin 10 | Beliebiger IO-Pin |
Schritt 1: TM1638 und Arduino UNO verbinden
Hier ist das Anschlussdiagramm zwischen Arduino UNO und dem TM1638 Chip.
Serielle Daten benötigen nur zwei Drähte. Das spart Pins am Board und reduziert die Anzahl der Kabel.
Das serielle Protokoll des TM1638 ist kein Standardprotokoll. Aber keine Sorge, es gibt hervorragende Bibliotheken, die du verwenden kannst! Eine solche Bibliothek findest du here.
Denke immer daran, mit den Masseverbindungen zu beginnen. Versorge das Projekt erst mit Strom, wenn alle Verbindungen hergestellt sind.
Schritt 2: Programmiere den Arduino UNO mit dem folgenden Code
Folge dem nächsten Schritt, um die Code-Implementierung zu verstehen. Du kannst den Code unten verwenden, um das TM1638 Modul zu testen. Wir verwenden hier keine Bibliotheken.
const int strobe = 8; // STB to D8
const int clock = 9; // CLK to D9
const int data = 10; // DIO to D10
void sendCommand(uint8_t value)
{
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, value);
digitalWrite(strobe, HIGH);
}
void reset()
{
sendCommand(0x40); // Set auto increment mode
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0); // Set starting address to 0
for (uint8_t i = 0; i < 16; i++)
{
shiftOut(data, clock, LSBFIRST, 0x00);
}
digitalWrite(strobe, HIGH);
}
void setup()
{
pinMode(strobe, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(data, OUTPUT);
sendCommand(0x8f); // Set maximum display brightness
reset();
}
#define COUNTING_MODE 0
#define SCROLL_MODE 1
#define BUTTON_MODE 2
void loop()
{
static uint8_t mode = COUNTING_MODE;
switch (mode)
{
case COUNTING_MODE:
mode += counting();
delay(500);
break;
case SCROLL_MODE:
mode += scroll();
break;
case BUTTON_MODE:
buttons();
break;
}
delay(200);
}
bool counting()
{
/*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
uint8_t digits[] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };
static uint8_t digit = 0;
sendCommand(0x40);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0);
for (uint8_t position = 0; position < 8; position++)
{
shiftOut(data, clock, LSBFIRST, digits[digit]);
shiftOut(data, clock, LSBFIRST, 0x00);
}
digitalWrite(strobe, HIGH);
digit = ++digit % 10;
return digit == 0;
}
bool scroll()
{
uint8_t scrollText[] =
{
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*H*/ /*E*/ /*L*/ /*L*/ /*O*/ /*.*/ /*.*/ /*.*/
0x76, 0x79, 0x38, 0x38, 0x3f, 0x80, 0x80, 0x80,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*H*/ /*E*/ /*L*/ /*L*/ /*O*/ /*.*/ /*.*/ /*.*/
0x76, 0x79, 0x38, 0x38, 0x3f, 0x80, 0x80, 0x80,
};
static uint8_t index = 0;
uint8_t scrollLength = sizeof(scrollText);
sendCommand(0x40);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0);
for (int i = 0; i < 8; i++)
{
uint8_t c = scrollText[(index + i) % scrollLength];
shiftOut(data, clock, LSBFIRST, c);
shiftOut(data, clock, LSBFIRST, c != 0 ? 1 : 0);
}
digitalWrite(strobe, HIGH);
index = ++index % (scrollLength << 1);
return index == 0;
}
void buttons()
{
uint8_t promptText[] =
{
/*P*/ /*r*/ /*E*/ /*S*/ /*S*/ /* */ /* */ /* */
0x73, 0x50, 0x79, 0x6d, 0x6d, 0x00, 0x00, 0x00,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*b*/ /*u*/ /*t*/ /*t*/ /*o*/ /*n*/ /*S*/ /* */
0x7c, 0x1c, 0x78, 0x78, 0x5c, 0x54, 0x6d, 0x00,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static uint8_t block = 0;
uint8_t textStartPos = (block / 4) << 3;
for (uint8_t position = 0; position < 8; position++)
{
sendCommand(0x44);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xC0 + (position << 1));
shiftOut(data, clock, LSBFIRST, promptText[textStartPos + position]);
digitalWrite(strobe, HIGH);
}
block = (block + 1) % 16;
uint8_t buttons = readButtons();
for (uint8_t position = 0; position < 8; position++)
{
uint8_t mask = 0x1 << position;
setLed(buttons & mask ? 1 : 0, position);
}
}
uint8_t readButtons(void)
{
uint8_t buttons = 0;
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0x42);
pinMode(data, INPUT);
for (uint8_t i = 0; i < 4; i++)
{
uint8_t v = shiftIn(data, clock, LSBFIRST) << i;
buttons |= v;
}
pinMode(data, OUTPUT);
digitalWrite(strobe, HIGH);
return buttons;
}
void setLed(uint8_t value, uint8_t position)
{
pinMode(data, OUTPUT);
sendCommand(0x44);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xC1 + (position << 1));
shiftOut(data, clock, LSBFIRST, value);
digitalWrite(strobe, HIGH);
}
Schritt 3: Code-Durchgang
Lass uns den Code durchgehen.
const int strobe = 8; // STB to D8 const int clock = 9; // CLK to D9 const int data = 10; // DIO to D10
strobe, clock und data sind Konstanten, die die Pins repräsentieren, die mit den STB-, CLK- und DIO-Pins des Display-Moduls verbunden sind.
void sendCommand(uint8_t value)
Diese Funktion sendet einen Befehl an das Display-Modul. Sie setzt den STB-Pin auf LOW, schiebt das Befehlsbyte mit der shiftOut() Funktion heraus und setzt dann den STB-Pin wieder auf HIGH.
void reset()
Diese Funktion setzt das Display-Modul in seinen Anfangszustand zurück.
Sie ruft sendCommand() auf, um Befehle zum Setzen des Auto-Inkrement-Modus und zum Zurücksetzen der Startadresse zu senden. Anschließend wird in einer Schleife 16-mal der Wert 0x00 ausgegeben, um das Display zu löschen.
Die setup()-Funktion führt einmal folgende Aufgaben aus:
Sie setzt die Pin-Modi für STB, CLK und DIO. Sie ruft sendCommand() auf, um das Display mit maximaler Helligkeit zu aktivieren. Schließlich wird reset() aufgerufen, um das Display zu initialisieren.
Die loop()-Funktion wird nach setup() wiederholt aufgerufen. Sie ist die Hauptprogrammschleife, die kontinuierlich läuft. Sie verwendet eine statische Variable mode, um den aktuellen Modus zu verfolgen.
void loop()
Mit einer switch-Anweisung werden je nach aktuellem Modus unterschiedliche Aktionen ausgeführt:
COUNTING_MODE ruft die counting() Funktion auf und erhöht den Modus, wenn der Zähler eine bestimmte Bedingung erreicht.
SCROLL_MODE ruft die scroll() Funktion auf und erhöht den Modus, wenn das Scrollen eine bestimmte Bedingung erreicht.
BUTTON_MODE ruft die buttons() Funktion auf, um Tasten-Eingaben zu verarbeiten.
Zwischen den Aktionen sind Verzögerungen eingebaut. Ich hoffe, das hilft dir.
Häufig gestellte Fragen zum TM1638 LED-Treiber-IC
Nachfolgend findest du eine Liste der häufigsten Fragen zu Projekten mit Arduino UNO und dem TM1638 LED-Treiber-IC.
Wenn du weitere Fragen hast, schreibe sie gerne in die Kommentare.
Was ist ein TM1638 Display-Modul?
Das TM1638 Display-Modul ist eine beliebte Wahl für Hobbyisten, um LED-Displays, Tasten und andere Peripheriegeräte anzusteuern. Es integriert einen Display-Controller und einen Tastatur-Scanner, was die Steuerung und Interaktion mit verschiedenen Ein- und Ausgängen erleichtert.
Wie kommuniziert das TM1638 Display-Modul mit einem Mikrocontroller?
Das TM1638 Modul kommuniziert mit einem Mikrocontroller über ein einfaches serielles Kommunikationsprotokoll.
Zum Senden und Empfangen von Daten werden drei Steuerleitungen benötigt (Daten, Takt und Strobe). Siehe den Grundlagen-Abschnitt im Artikel für eine detaillierte Erklärung des Kommunikationsprotokolls.
Was sind die Hauptmerkmale des TM1638 Display-Moduls?
Das TM1638 Modul bietet typischerweise acht 7-Segment-LED-Anzeigen, eine Reihe von LED-Indikatoren und mehrere taktile Tasten. Es ermöglicht außerdem die Helligkeitssteuerung der Anzeige und unterstützt Multiplexing, um die benötigten I/O-Pins zu reduzieren.
Kann ich mehrere TM1638 Module mit einem einzigen Mikrocontroller steuern?
Es ist möglich, mehrere TM1638 Module mit einem Mikrocontroller zu steuern. Jedes Modul kann über Hardware-Adressen eine eindeutige Adresse erhalten, sodass sie in einem Multi-Modul-Setup einzeln angesteuert werden können.
Welche Mikrocontroller sind mit dem TM1638 Display-Modul kompatibel?
Das TM1638 Modul kann mit verschiedenen Mikrocontrollern verwendet werden, darunter beliebte wie Arduino, Raspberry Pi und ESP8266. Solange der Mikrocontroller digitale I/O und serielle Kommunikation unterstützt, kann er mit dem Modul genutzt werden.
Ein wichtiger Aspekt ist die Sicherstellung der Spannungs-Kompatibilität zwischen Mikrocontroller und TM1638 Modul.
Gibt es Bibliotheken zur Programmierung des TM1638 Display-Moduls?
Ja, es gibt verschiedene Bibliotheken für unterschiedliche Plattformen und Programmiersprachen, die die Integration des TM1638 Moduls erleichtern.
Diese Bibliotheken bieten Funktionen und Abstraktionen zur Steuerung der Anzeige, zum Auslesen der Tasten-Eingaben und zur Handhabung weiterer Modul-Funktionen. Siehe den Abschnitt Arduino Code für nützliche Bibliotheken.
Kann ich das TM1638 Display-Modul auch für andere Projekte als die primäre Anzeige und Tasten-Eingabe verwenden?
Absolut! Das TM1638 Modul ist vielseitig und kann für viele Projekte über die reine Anzeige- und Tastenfunktion hinaus eingesetzt werden.
Fazit
Dieser Artikel hat alle wichtigen Informationen zur Verwendung des TM1638 mit dem Arduino UNO behandelt.
War der Artikel leicht verständlich? Wenn du Verbesserungsvorschläge hast, freue ich mich immer über Feedback.
Ich freue mich auf deine Rückmeldung! Lass mich wissen, ob ich in zukünftigen Artikeln noch etwas anderes behandeln soll.
