Een MAX7219-aangedreven LED-matrix 8x8 koppelen met ATtiny85-microcontroller - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

De MAX7219-controller, vervaardigd door Maxim Integrated, is een compacte, seriële input/output common-kathode display-driver die microcontrollers kan koppelen aan 64 individuele LED's, 7-segment numerieke LED-displays van maximaal 8 cijfers, staafdiagramdisplays, enz. Inbegrepen op -chip zijn een BCD-code-B-decoder, multiplex-scancircuits, segment- en cijferstuurprogramma's en een 8×8 statisch RAM-geheugen dat elk cijfer opslaat.

De MAX7219 modules zijn erg handig in gebruik met microcontrollers zoals ATtiny85, of in ons geval het Tinusaur Board.

Stap 1: De hardware

De MAX7219-modules zien er meestal zo uit. Ze hebben een ingangsbus aan de ene kant en een uitgangsbus aan de andere. Hierdoor kunt u 2 of meer modules doorlussen, d.w.z. de een na de ander, om meer gecompliceerde opstellingen te creëren.

De modules die we gebruiken zijn in staat om in een ketting te verbinden met behulp van 5 kleine jumpers. Zie de afbeelding hieronder.

Stap 2: Pinout en signalen

MAX7219 module heeft 5 pinnen:

• VCC - vermogen (+)
• GND - aarde (-)
• DIN – Gegevensinvoer
• CS – Chip selecteren
• CLK – Klok

Dat betekent dat we aan de kant van de ATtiny85-microcontroller 3 pinnen nodig hebben om de module aan te sturen. Dat zullen zijn:

• PB0 – aangesloten op de CLK
• PB1 – aangesloten op de CS
• PB2 – aangesloten op de DIN

Dit is voldoende om verbinding te maken met de MAX7219-module en deze te programmeren.

Stap 3: Het protocol

Communiceren met de MAX7219 is relatief eenvoudig - het maakt gebruik van een synchroon protocol, wat betekent dat voor elk databit dat we verzenden een klokcyclus is die de aanwezigheid van dat databit aangeeft.

Met andere woorden, we sturen 2 parallelle reeksen naar bits - een voor de klok en een andere voor de gegevens. Dit is wat de software doet.

Stap 4: De software

De manier waarop deze MAX7219-module werkt, is als volgt:

• We schrijven bytes naar het interne register.
• MAX7219 interpreteert de gegevens.
• MAX7219 bestuurt de LED's in de matrix.

Dat betekent ook dat we niet de hele tijd door de reeks LED's hoeven te cirkelen om ze te laten oplichten - daar zorgt de MAX7219-controller voor. Het kan ook de intensiteit van de LED's beheren.

Dus om de MAX7219-modules op een handige manier te gebruiken, hebben we een bibliotheek met functies nodig om dat doel te dienen.

Ten eerste hebben we enkele basisfuncties nodig om naar de MAX7219-registers te kunnen schrijven.

• Een byte schrijven naar de MAX7219.
• Schrijven van een woord (2 bytes) naar de MAX7219.

De functie die één byte naar de controller schrijft, ziet er als volgt uit:

void max7219_byte(uint8_t data) { for(uint8_t i = 8; i >= 1; i--) {PORTB &= ~(1 << MAX7219_CLK); // Stel CLK in op LOW if (data & 0x80) // Maskeer de MSB van de data PORTB |= (1 << MAX7219_DIN); // Stel DIN in op HOOG anders PORTB &= ~(1 << MAX7219_DIN); // Stel DIN in op LOW PORTB |= (1 << MAX7219_CLK); // Stel CLK in op HIGH data <<= 1; // Schuif naar links } }

Nu we bytes naar de MAX7219 kunnen sturen, kunnen we beginnen met het verzenden van opdrachten. Dit doe je door 2 byes te sturen - 1e voor het adres van het interne register en de 2e voor de gegevens die we willen verzenden.

Er zijn meer dan een dozijn registers in de MAX7219-controller.

Het verzenden van een commando, of een woord, is in feite het verzenden van 2 opeenvolgende bytes. De functie die dat implementeert, is heel eenvoudig.

void max7219_word (uint8_t adres, uint8_t data) {PORTB &= ~(1 << MAX7219_CS); // Stel CS in op LOW max7219_byte (adres); // Verzenden van het adres max7219_byte (data); // Verzenden van de gegevens PORTB |= (1 << MAX7219_CS); // Stel CS in op HIGH PORTB &= ~(1 << MAX7219_CLK); // Zet CLK op LAAG}

Het is belangrijk om hier de regel te noteren waar we het CS-signaal terug naar HOOG brengen - dit markeert het einde van de reeks - in dit geval het einde van het commando. Een vergelijkbare techniek wordt gebruikt bij het besturen van meer dan één matrix die in een keten is aangesloten. De volgende stap, voordat we beginnen met het in- en uitschakelen van de LED's, is het initialiseren van de MAX7219-controller. Dit wordt gedaan door bepaalde waarden naar bepaalde registers te schrijven. Voor het gemak kunnen we tijdens het coderen de initialisatievolgorde in een array plaatsen.

uint8_t initseq = { 0x09, 0x00, // Decode-Mode Register, 00 = No decode 0x0a, 0x01, // Intensity Register, 0x00.. 0x0f 0x0b, 0x07, // Scan-Limit Register, 0x07 om alle regels te tonen 0x0c, 0x01, // Shutdown Register, 0x01 = Normale werking 0x0f, 0x00, // Display-Test Register, 0x00 = Normale werking };

We hoeven alleen de 5 bovenstaande commando's in een volgorde te verzenden als adres-/gegevensparen. Volgende stap - het oplichten van een rij LED's.

Dit is heel eenvoudig - we schrijven slechts één opdracht waarbij de 1e byte het adres is (van 0 tot 7) en de 2e byte de 8 bits zijn die de 8 LED's in de rij vertegenwoordigen.

void max7219_row (uint8_t adres, uint8_t data) {if (adres >= 1 && adres <= 8) max7219_word (adres, data); }

Het is belangrijk op te merken dat dit slechts voor 1 matrix werkt. Als we meer matrices in een keten verbinden, zullen ze allemaal dezelfde gegevens tonen. De reden hiervoor is dat we na het verzenden van de opdracht het CS-signaal terug naar HOOG brengen, waardoor alle MAX7219-controllers in de keten worden vergrendeld en laten zien wat de laatste opdracht was.