vérifiez la qualité des fils et assurez vous d'avoir une alimentation correcte pour les 3 barres
Bonsoir,
deux pack batteries 5 volts de 3 et 5 ampères ... de ce côté là ... c'est ok ... pour les connexions , je vais regarder de plus près ... mais ça marche ....
je vais surement galérer pour piocher dans votre code et l'intégrer dans le mien ... ou alors je repars à zéro et je me sers de votre code . ce serait surement moins compliqué ... 
Tu alimentes tes matrices directement avec les batteries en parallèle ?
oui c'est assez simple de rajouter une fonction qui affiche un de vos bitmaps dans le framebuffer
voici le code:
le code remplit d'abord ligne par ligne les 3 modules comme avant (mais plus vite, j'affiche ligne par ligne au lieu de point par point)
j'ai rajouté une fonction effacer() qui vide l'écran
J'ai rajouté une fonction afficherBitmap8x8() qui prend un bitmap de 8 octets (qui correspond à un module), charge le bitmap dans le framebuffer à cet endroit et l'affiche en position x,y sur la matrice. (les coordonnées (x,y) ne sont pas forcément alignées sur un module). J'ai fait un tableau en 2D pour les chiffres, ça permet d'afficher un chiffre de manière plus simple grace à sa valeur, par exemple si je fais
afficherBitmap8x8(chiffres[0], 0, 0);
j'affiche le symbole du 0 dans le coin en bas à gauche des matrices.
Je m'en sers pour afficher les chiffres de 0 à 9.
ensuite j'affiche les autres symboles que vous avez défini.
ensuite, puisque le (x,y) est n'importe où sur la matrice, je fais défiler horizontalement trois de vos symboles
click to see the code
/*
============================================
code is placed under the MIT license
Copyright (c) 2023 J-M-L
For the Arduino Forum : https://forum.arduino.cc/u/j-m-l
https://forum.arduino.cc/t/chainer-trois-matrices-led-avec-un-max-7219/1306034$0
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================
*/
#include <SPI.h>
#include "Symboles.h"
// Définition des constantes pour les broches et le nombre de segments
constexpr byte clkPin = 13;
constexpr byte dataPin = 11;
constexpr byte csPin = 3;
constexpr byte nbModulesX = 4; // 32 pixels de large (4 segments de 8 pixels)
constexpr byte nbModulesY = 3; // 24 pixels de haut (3 segments de 8 pixels)
// Un framebuffer pour stocker l'état de toute la matrice de LED
// Chaque octet représente une colonne de 8 pixels (dans un module)
uint8_t frameBuffer[nbModulesX][nbModulesY * 8]; // Taille 32x24
// Fonction pour envoyer des données à un MAX7219 spécifique
void envoiSPI(byte segment, byte adresse, byte donnees) {
digitalWrite(csPin, LOW);
for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
if (i == segment) {
SPI.transfer(adresse); // Envoyer l'adresse et les données pour le bon segment
SPI.transfer(donnees);
} else {
SPI.transfer(0); // Ne rien envoyer aux autres segments
SPI.transfer(0);
}
}
digitalWrite(csPin, HIGH);
}
// Fonction pour allumer ou éteindre un pixel aux coordonnées (x, y)
void definirPixel(int x, int y, bool alllume) {
if (x < 0 || x >= nbModulesX * 8 || y < 0 || y >= nbModulesY * 8) return; // Vérifie les limites
// Calcul du segment (bloc 8x8) et de la position dans le segment
int moduleX = x / 8; // module horizontal (bloc de 8x8 pixels)
int colonneDansModule = x % 8; // Colonne dans le module
int ligneSegment = y; // Ligne dans la grille
// Allume ou éteint le bit correspondant dans le framebuffer
if (alllume) {
frameBuffer[moduleX][ligneSegment] |= (1 << (7 - colonneDansModule)); // on met le bit à 1
} else {
frameBuffer[moduleX][ligneSegment] &= ~(1 << (7 - colonneDansModule)); // on met le bit à 0
}
}
// Fonction pour envoyer le framebuffer aux MAX7219
void afficher() {
for (byte ligne = 0; ligne < 8; ligne++) { // Pour chaque ligne dans un module
for (byte moduleX = 0; moduleX < nbModulesX; moduleX++) { // Parcourt chaque segment horizontal
for (byte segmentY = 0; segmentY < nbModulesY; segmentY++) { // Parcourt chaque segment vertical
byte colonne = frameBuffer[moduleX][ligne + (segmentY * 8)];
envoiSPI(moduleX + segmentY * nbModulesX, 8 - ligne, colonne);
}
}
}
}
void effacer() {
memset(frameBuffer, 0, sizeof frameBuffer);
afficher(); // met à jour l'affichage
}
void chargerBitmap8x8(const byte bitmap[], int positionX, int positionY) {
for (int ligne = 0; ligne < 8; ligne++) {
byte octet = pgm_read_byte_near(bitmap + (7 - ligne)); // Inverser les lignes (pour corriger la tête en bas)
for (int colonne = 0; colonne < 8; colonne++) {
bool alllume = (octet & (1 << (7 - colonne))) != 0; // Lire les bits de droite à gauche pour corriger le flip horizontal
definirPixel(positionX + colonne, positionY + ligne, alllume); // Définir le pixel dans le framebuffer
}
}
afficher(); // Mettre à jour l'affichage
}
void afficherBitmap8x8(const byte bitmap[], int positionX, int positionY) {
chargerBitmap8x8(bitmap, positionX, positionY);
afficher(); // Mettre à jour l'affichage
}
void setup() {
Serial.begin(115200);
pinMode(clkPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(csPin, OUTPUT);
SPI.beginTransaction(SPISettings(16000000, MSBFIRST, SPI_MODE0));
// Configuration initiale pour chaque MAX7219
for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
envoiSPI(i, 0x0f, 0x00); // registre de test - mode test désactivé
envoiSPI(i, 0x0b, 0x07); // registre de limite de scan - affiche les chiffres 0 à 7
envoiSPI(i, 0x0c, 0x01); // registre de mise en marche - fonctionnement normal
envoiSPI(i, 0x0a, 0x0f); // registre d'intensité - luminosité maximale
envoiSPI(i, 0x09, 0x00); // registre de mode de décodeur - pas de décodeur
}
// exemple d'affichage
// on parcourt chaque pixel de la matrice
for (int y = 0; y < nbModulesY * 8; y++) {
for (int x = 0; x < nbModulesX * 8; x++) {
definirPixel(x, y, true); // Allume le pixel
}
afficher(); // Met à jour l'affichage
}
delay(1000);
effacer();
// affichage les bitmaps des 10 chiffres de 0 à 9
int positionX = 0;
int positionY = 0;
for (byte i = 0; i < 10; i++) {
afficherBitmap8x8(chiffres[i], positionX, positionY);
if (((i + 1) % nbModulesX == 0)) {
positionX = 0;
positionY += 8;
} else {
positionX += 8;
}
}
delay(3000);
effacer();
afficherBitmap8x8(symboleAddition, 0, 0);
afficherBitmap8x8(symboleSoustraction, 8, 0);
afficherBitmap8x8(symboleDivision, 16, 0);
afficherBitmap8x8(symboleMultiplication, 24, 0);
afficherBitmap8x8(symbolePourcentage, 0, 8);
afficherBitmap8x8(symboleCroix, 8, 8);
afficherBitmap8x8(symbolePlein, 16, 8);
afficherBitmap8x8(symboleFlash, 24, 8);
afficherBitmap8x8(symboleExclamation, 0, 16);
afficherBitmap8x8(symboleCible, 8, 16);
afficherBitmap8x8(symboleR, 16, 16);
delay(3000);
effacer();
for (int x = 0; x < nbModulesX * 8; x++) {
effacer();
chargerBitmap8x8(symboleCible, x, 0);
chargerBitmap8x8(symboleCroix, x, 8);
chargerBitmap8x8(symboleFlash, x, 16);
afficher();
delay(50); // Délai entre chaque déplacement
}
effacer();
}
void loop() {}
le fichier des symboles
Symboles.h
// =======================================================
// Encodage des chiffres et symboles, pour matrice LED 8x8
// =======================================================
// Fichier reference chiffres_et_symboles.h
// 1) Chiffres 0 à 9
// 2) Symboles +, -, /, *, et % et divers...
// 3) Alpabet utile ; R ... A ... Z ... etc etc etc ..
#ifndef SYMBOLES_H_
#define SYMBOLES_H_
const byte chiffres[10][8] PROGMEM = {
{0x3C, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x66, 0x3C}, // 0
{0x18, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C}, // 1
{0x3C, 0x66, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E}, // 2
{0x3C, 0x66, 0x06, 0x1C, 0x06, 0x06, 0x66, 0x3C}, // 3
{0x0C, 0x1C, 0x3C, 0x6C, 0x7E, 0x0C, 0x0C, 0x0C}, // 4
{0x7E, 0x60, 0x7C, 0x06, 0x06, 0x06, 0x66, 0x3C}, // 5
{0x1C, 0x30, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x3C}, // 6
{0x7E, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30}, // 7
{0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x66, 0x3C}, // 8
{0x3C, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0C, 0x38} // 9
};
const byte symboleAddition[] PROGMEM = {
0b00000000,
0b00001000,
0b00001000,
0b00111110,
0b00001000,
0b00001000,
0b00000000,
0b00000000
};
const byte symboleSoustraction[] PROGMEM = {
0b00000000,
0b00000000,
0b00000000,
0b01111110,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};
const byte symboleDivision[] PROGMEM = {
0b00000000,
0b00000010,
0b00000100,
0b00001000,
0b00010000,
0b00100000,
0b01000000,
0b00000000
};
const byte symboleMultiplication[] PROGMEM = {
0b00000000,
0b01001001,
0b00101010,
0b00011100,
0b01111111,
0b00011100,
0b00101010,
0b01001001
};
const byte symbolePourcentage[] PROGMEM = {
0b00000000,
0b01100010,
0b01100100,
0b00001000,
0b00010000,
0b00100110,
0b01000110,
0b00000000
};
const byte symboleCroix[] PROGMEM = {
0b10000001,
0b01000010,
0b00100100,
0b00011000,
0b00011000,
0b00100100,
0b01000010,
0b10000001
};
const byte symbolePlein[] PROGMEM = {
0b11111111,
0b11111111,
0b11111111,
0b11111111,
0b11111111,
0b11111111,
0b11111111,
0b11111111
};
const byte symboleFlash[] PROGMEM = {
0b00000000,
0b00000000,
0b00000000,
0b00011000,
0b00011000,
0b00000000,
0b00000000,
0b00000000
};
const byte symboleExclamation[] PROGMEM = {
0b00011000,
0b00011000,
0b00011000,
0b00100100,
0b00111100,
0b00000000,
0b00011000,
0b00011000
};
const byte symboleCible[] PROGMEM = {
0b11111111,
0b10000001,
0b10000001,
0b10011001,
0b10011001,
0b10000001,
0b10000001,
0b11111111
};
const byte symboleR[] PROGMEM = {
0b00000000,
0b01111100,
0b01000010,
0b01111110,
0b01011000,
0b01000100,
0b01000010,
0b00000000
};
#endif
Avec ces exemples et fonctions, je pense que faire votre animation est maintenant très simple.
Et c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement) avec comme évènement le temps qui passe.
au fait
dans le code il y a
SPI.beginTransaction(SPISettings(16000000, MSBFIRST, SPI_MODE0));
Réduire la fréquence de 16 MHz à une valeur plus basse peut améliorer la stabilité des communications SPI, surtout si la longueur des fils est importante ou si les composants ne peuvent pas supporter des vitesses élevées. Une fréquence plus basse réduit le risque d'erreurs de transmission, mais cela peut ralentir les échanges de données (sans doute invisible à l'oeil pour vos besoins) ➜ essayez avec 4000000 par exemple
bonsoir,
journée au stand ... je viens de lire vos posts ... je vais me mettre en mode "comprenette" et commencer la réécriture du sketch ... merci encore de votre support ...
bonne soirée....
D'autant que le MAX7219 est spécifié à 10MHz
C’est une bonne raison alors
bonjour,
je vais profiter du weekend pour reprendre tout à zéro et refaire un sketch avec ces nouvelles possibilités ... je vous remercie de toutes ces pistes que vous me donnez . Je reviens dès que j'ai un truc qui tient la route ...
bonne fin de semaine ...
Pas pu attendre le weekend ... 
... je m'y suis mis et en quelques dizaines de minutes ( plus de deux dizaines tout de même ... ) j'y suis arrivé à refaire ce que je voulais ... à part l'effet d'effacement des matrices mais bon c'est de la déco ...
un super merci à J-M-L Jackson pour son super coup de pouce avec son code qui m'a grandement simplifié le boulot de réécriture ...
voici le premier sketch qui fonctionne avec le fichier SYMBOLES.h .... avec la fréquence effectivement descendue à 10 000 ...
/*
============================================
code is placed under the MIT license
Copyright (c) 2023 J-M-L
For the Arduino Forum : https://forum.arduino.cc/u/j-m-l
https://forum.arduino.cc/t/chainer-trois-matrices-led-avec-un-max-7219/1306034$0
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================
*/
#include <SPI.h>
#include "SYMBOLES.h"
// Relais
#define RELAIS 5
// Buzzer
#define BUZZER 3 //buzzer pin
// Définition des constantes pour les broches et le nombre de segments
constexpr byte clkPin = 13;
constexpr byte dataPin = 11;
constexpr byte csPin = 10;
constexpr byte nbModulesX = 4; // 32 pixels de large (4 segments de 8 pixels)
constexpr byte nbModulesY = 3; // 24 pixels de haut (3 segments de 8 pixels)
// Un framebuffer pour stocker l'état de toute la matrice de LED
// Chaque octet représente une colonne de 8 pixels (dans un module)
uint8_t frameBuffer[nbModulesX][nbModulesY * 8]; // Taille 32x24
// Fonction pour envoyer des données à un MAX7219 spécifique
void envoiSPI(byte segment, byte adresse, byte donnees) {
digitalWrite(csPin, LOW);
for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
if (i == segment) {
SPI.transfer(adresse); // Envoyer l'adresse et les données pour le bon segment
SPI.transfer(donnees);
} else {
SPI.transfer(0); // Ne rien envoyer aux autres segments
SPI.transfer(0);
}
}
digitalWrite(csPin, HIGH);
}
// Fonction pour allumer ou éteindre un pixel aux coordonnées (x, y)
void definirPixel(int x, int y, bool alllume) {
if (x < 0 || x >= nbModulesX * 8 || y < 0 || y >= nbModulesY * 8) return; // Vérifie les limites
// Calcul du segment (bloc 8x8) et de la position dans le segment
int moduleX = x / 8; // module horizontal (bloc de 8x8 pixels)
int colonneDansModule = x % 8; // Colonne dans le module
int ligneSegment = y; // Ligne dans la grille
// Allume ou éteint le bit correspondant dans le framebuffer
if (alllume) {
frameBuffer[moduleX][ligneSegment] |= (1 << (7 - colonneDansModule)); // on met le bit à 1
} else {
frameBuffer[moduleX][ligneSegment] &= ~(1 << (7 - colonneDansModule)); // on met le bit à 0
}
}
// Fonction pour envoyer le framebuffer aux MAX7219
void afficher() {
for (byte ligne = 0; ligne < 8; ligne++) { // Pour chaque ligne dans un module
for (byte moduleX = 0; moduleX < nbModulesX; moduleX++) { // Parcourt chaque segment horizontal
for (byte segmentY = 0; segmentY < nbModulesY; segmentY++) { // Parcourt chaque segment vertical
byte colonne = frameBuffer[moduleX][ligne + (segmentY * 8)];
envoiSPI(moduleX + segmentY * nbModulesX, 8 - ligne, colonne);
}
}
}
}
void effacer() {
memset(frameBuffer, 0, sizeof frameBuffer);
afficher(); // met à jour l'affichage
}
void chargerBitmap8x8(const byte bitmap[], int positionX, int positionY) {
for (int ligne = 0; ligne < 8; ligne++) {
byte octet = pgm_read_byte_near(bitmap + (7 - ligne)); // Inverser les lignes (pour corriger la tête en bas)
for (int colonne = 0; colonne < 8; colonne++) {
bool alllume = (octet & (1 << (7 - colonne))) != 0; // Lire les bits de droite à gauche pour corriger le flip horizontal
definirPixel(positionX + colonne, positionY + ligne, alllume); // Définir le pixel dans le framebuffer
}
}
afficher(); // Mettre à jour l'affichage
}
void afficherBitmap8x8(const byte bitmap[], int positionX, int positionY) {
chargerBitmap8x8(bitmap, positionX, positionY);
afficher(); // Mettre à jour l'affichage
}
void setup() {
Serial.begin(115200);
pinMode(clkPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(csPin, OUTPUT);
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0));
pinMode(RELAIS, OUTPUT);
// Configuration initiale pour chaque MAX7219
for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
envoiSPI(i, 0x0f, 0x00); // registre de test - mode test désactivé
envoiSPI(i, 0x0b, 0x07); // registre de limite de scan - affiche les chiffres 0 à 7
envoiSPI(i, 0x0c, 0x01); // registre de mise en marche - fonctionnement normal
envoiSPI(i, 0x0a, 0x0f); // registre d'intensité - luminosité maximale
envoiSPI(i, 0x09, 0x00); // registre de mode de décodeur - pas de décodeur
}
// exemple d'affichage
// on parcourt chaque pixel de la matrice
for (int y = 0; y < nbModulesY * 8; y++) {
for (int x = 0; x < nbModulesX * 8; x++) {
definirPixel(x, y, true); // Allume le pixel
}
afficher(); // Met à jour l'affichage
}
for (int x = 0; x < nbModulesX * 8; x++) {
effacer();
chargerBitmap8x8(SYMBOLE_FLASH, x, 0);
chargerBitmap8x8(SYMBOLE_FLASH, x, 8);
chargerBitmap8x8(SYMBOLE_FLASH, x, 16);
afficher();
delay(20); // Délai entre chaque déplacement
// delay(20);
effacer();
}
// barre VERTE UP
afficherBitmap8x8(SYMBOLE_PLEIN, 0, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 8, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 16, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 24, 0);
// Pause préparation
delay(3000);
// affichage le compte à rebours des 10 chiffres de 9 à 0
afficherBitmap8x8(CHIFFRE_9, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_8, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_7, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_6, 0, 16);
afficherBitmap8x8(SYMBOLE_TIERS, 8, 16);
afficherBitmap8x8(SYMBOLE_TIERS, 16, 16);
afficherBitmap8x8(SYMBOLE_TIERS, 24, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_5, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_4, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_3, 0, 16);
afficherBitmap8x8(SYMBOLE_2TIERS, 8, 16);
afficherBitmap8x8(SYMBOLE_2TIERS, 16, 16);
afficherBitmap8x8(SYMBOLE_2TIERS, 24, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_2, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_1, 0, 16);
delay(1000);
afficherBitmap8x8(CHIFFRE_0, 0, 16);
afficherBitmap8x8(SYMBOLE_3TIERS, 8, 16);
afficherBitmap8x8(SYMBOLE_3TIERS, 16, 16);
afficherBitmap8x8(SYMBOLE_3TIERS, 24, 16);
// barre VERTE down
afficherBitmap8x8(SYMBOLE_OFF, 0, 0);
afficherBitmap8x8(SYMBOLE_OFF, 8, 0);
afficherBitmap8x8(SYMBOLE_OFF, 16, 0);
afficherBitmap8x8(SYMBOLE_OFF, 24, 0);
// barre rouge et relais UP
digitalWrite(RELAIS, HIGH);
afficherBitmap8x8(SYMBOLE_PLEIN, 0, 8);
afficherBitmap8x8(SYMBOLE_PLEIN, 8, 8);
afficherBitmap8x8(SYMBOLE_PLEIN, 16, 8);
afficherBitmap8x8(SYMBOLE_PLEIN, 24, 8);
afficherBitmap8x8(SYMBOLE_OFF, 0, 16);
afficherBitmap8x8(SYMBOLE_OFF, 8, 16);
afficherBitmap8x8(SYMBOLE_OFF, 16, 16);
afficherBitmap8x8(SYMBOLE_OFF, 24, 16);
delay(3000); // temporisation à mofifier pour temps de 10 secondes
digitalWrite(RELAIS, LOW);
effacer();
for (int x = 0; x < nbModulesX * 8; x++) {
effacer();
chargerBitmap8x8(SYMBOLE_CROIX, x, 0);
chargerBitmap8x8(SYMBOLE_CROIX, x, 8);
chargerBitmap8x8(SYMBOLE_CROIX, x, 16);
afficher();
delay(50); // Délai entre chaque déplacement
}
for (int x = 8; x < nbModulesX * x++; 0) {
effacer();
chargerBitmap8x8(SYMBOLE_FLASH, x, 0);
chargerBitmap8x8(SYMBOLE_FLASH, x, 8);
chargerBitmap8x8(SYMBOLE_FLASH, x, 16);
afficher();
delay(50); // Délai entre chaque déplacement
}
}
void loop() {}
encore quelques trucs et ça va surement satisfaire tout le monde ...
merci à tous
super - bravo.
c'est quoi exactement cet effet ?
PS/ notez que la fonction efface redessine les écrans. Si vous voulez juste vider le framebuffer sans pour autant que ça affiche tout de suite (ça peut éviter un clignotement) faites comme j'ai fait avec les fonctions chargerBitmap8x8() et afficherBitmap8x8()
vous pourriez avoir les fonctions
void effacerFrameBuffer() {
memset(frameBuffer, 0, sizeof frameBuffer);
}
void effacer() {
effacerFrameBuffer() ;
afficher(); // met à jour l'affichage
}
comme cela dans les boucles comme
for (int x = 0; x < nbModulesX * 8; x++) {
effacer();
chargerBitmap8x8(SYMBOLE_CROIX, x, 0);
chargerBitmap8x8(SYMBOLE_CROIX, x, 8);
chargerBitmap8x8(SYMBOLE_CROIX, x, 16);
afficher();
delay(50); // Délai entre chaque déplacement
}
au début de la boucle vous pourriez appeler effacerFrameBuffer() et faire un seul transfert lors de l'appel de afficher()
bonsoir
le dit effet est celui visible sur la vidéo ci dessus quand le RAZ en balayage ... rien d'important ... je me pencherai dessus plus tard...
pour l'idée d'effacer tout en une seule fois ... je garde la possibilité d'afficher n'importe quel symbole ...
je continue dans ma lancée des que j'ai le temps ...
merci de votre suivi et "surveillance" ... j'apprends ... 
OK - oui ce n’est pas difficile à faire avec des boucles for qui vont éteindre les coordonnées (x,y) dans le bon ordre et faire un affichage