Comment interfacer une matrice LED 8x8 pilotée par MAX7219 avec le microcontrôleur ATtiny85 : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Le contrôleur MAX7219 est fabriqué par Maxim Integrated. Il s'agit d'un pilote d'affichage à cathode commune d'entrée/sortie série compact qui peut interfacer des microcontrôleurs avec 64 LED individuelles, des affichages à LED numériques à 7 segments jusqu'à 8 chiffres, des affichages à barres, etc. -chip sont un décodeur BCD code-B, des circuits de balayage multiplex, des pilotes de segment et de chiffre et une RAM statique 8 × 8 qui stocke chaque chiffre.

Les modules MAX7219 sont très pratiques à utiliser avec des microcontrôleurs tels que ATtiny85, ou, dans notre cas, la carte Tinusaur.

Étape 1: le matériel

Les modules MAX7219 ressemblent généralement à ceci. Ils ont un bus d'entrée d'un côté et un bus de sortie de l'autre. Cela vous permet de chaîner 2 modules ou plus, c'est-à-dire l'un après l'autre, afin de créer des configurations plus compliquées.

Les modules que nous utilisons sont capables de se connecter en chaîne à l'aide de 5 petits cavaliers. Voir l'image ci-dessous.

Étape 2: Brochage et signaux

Le module MAX7219 a 5 broches:

• VCC – puissance (+)
• GND – masse (-)
• DIN – Saisie des données
• CS - Sélection de puce
• CLK – Horloge

Cela signifie que nous avons besoin de 3 broches du côté du microcontrôleur ATtiny85 pour contrôler le module. Ceux-ci seront:

• PB0 – connecté au CLK
• PB1 – connecté au CS
• PB2 – connecté au DIN

Cela suffit pour se connecter au module MAX7219 et le programmer.

Étape 3: Le protocole

La communication avec le MAX7219 est relativement facile - il utilise un protocole synchrone, ce qui signifie que pour chaque bit de données que nous envoyons, il y a un cycle d'horloge qui signifie la présence de ce bit de données.

En d'autres termes, nous envoyons 2 séquences parallèles aux bits - une pour l'horloge et une autre pour les données. C'est ce que fait le logiciel.

Étape 4: Le logiciel

Voici comment fonctionne ce module MAX7219:

• Nous écrivons des octets dans son registre interne.
• MAX7219 interprète les données.
• Le MAX7219 contrôle les LED de la matrice.

Cela signifie également que nous n'avons pas à faire le tour du réseau de LED tout le temps pour les allumer - le contrôleur MAX7219 s'en charge. Il pourrait également gérer l'intensité des LED.

Ainsi, pour utiliser les modules MAX7219 de manière pratique, nous avons besoin d'une bibliothèque de fonctions à cette fin.

Tout d'abord, nous avons besoin de quelques fonctions de base pour écrire dans les registres du MAX7219.

• Écriture d'un octet sur le MAX7219.
• Écriture d'un mot (2 octets) sur le MAX7219.

La fonction qui écrit un octet dans le contrôleur ressemble à ceci:

void max7219_byte(uint8_t data) { for(uint8_t i = 8; i >= 1; i--) { PORTB &= ~(1 << MAX7219_CLK); // Mettre CLK à LOW if (data & 0x80) // Masquer le MSB des données PORTB |= (1 << MAX7219_DIN); // Définir DIN sur HAUT sinon PORTB &= ~(1 << MAX7219_DIN); // Définir DIN sur LOW PORTB |= (1 << MAX7219_CLK); // Définir CLK sur HIGH data <<= 1; // Décalage vers la gauche } }

Maintenant que nous pouvons envoyer des octets au MAX7219, nous pouvons commencer à envoyer des commandes. Cela se fait en envoyant 2 byes – 1er pour l'adresse du registre interne et le 2ème pour les données que nous aimerions envoyer.

Il y a plus d'une douzaine de registres dans le contrôleur MAX7219.

L'envoi d'une commande, ou d'un mot, revient essentiellement à envoyer 2 octets consécutifs. La fonction mise en œuvre qui est très simple.

void max7219_word (adresse uint8_t, données uint8_t) { PORTB &= ~(1 << MAX7219_CS); // Définir CS sur LOW max7219_byte(address); // Envoi de l'adresse max7219_byte(data); // Envoi des données PORTB |= (1 << MAX7219_CS); // Définir CS sur HIGH PORTB &= ~(1 << MAX7219_CLK); // Mettre CLK à LOW }

Il est important de noter ici la ligne où l'on ramène le signal CS à HIGH – cela marque la fin de la séquence – en l'occurrence, la fin de la commande. Une technique similaire est utilisée lors du contrôle de plusieurs matrices connectées dans une chaîne. L'étape suivante, avant de commencer à allumer et éteindre les LED, consiste à initialiser le contrôleur MAX7219. Cela se fait en écrivant certaines valeurs dans certains registres. Pour plus de commodité, lors du codage, nous pourrions mettre la séquence d'initialisation dans un tableau.

uint8_t initseq = { 0x09, 0x00, // Registre de mode de décodage, 00 = Pas de décodage 0x0a, 0x01, // Registre d'intensité, 0x00.. 0x0f 0x0b, 0x07, // Registre de limite de balayage, 0x07 pour afficher toutes les lignes 0x0c, 0x01, // Registre d'arrêt, 0x01 = Fonctionnement normal 0x0f, 0x00, // Registre de test d'affichage, 0x00 = Fonctionnement normal };

Nous avons juste besoin d'envoyer les 5 commandes ci-dessus dans une séquence sous forme de paires adresse/données. Étape suivante - allumer une rangée de LED.

C'est très simple - nous écrivons juste une commande où le 1er octet est l'adresse (de 0 à 7) et le 2ème octet est les 8 bits représentant les 8 LED de la rangée.

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

Il est important de noter que cela ne fonctionnera que pour 1 matrice. Si nous connectons plusieurs matrices dans une chaîne, elles afficheront toutes les mêmes données. La raison en est qu'après avoir envoyé la commande, nous ramenons le signal CS à HAUT, ce qui fait que tous les contrôleurs MAX7219 de la chaîne se verrouillent et affichent quelle que soit la dernière commande.