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
Hello ... de retour avec mon projet qui avance ... tests positifs avec les utilisateurs ... mais des modifications et des options demandées ... le contraire aurait été surprenant ... .
première option : sélection d'un temps de chrono différent de celui en dur actuel de 10 secondes, modifiable en changeant celui ci dans le sketch
donc j'ai ajouté un "switch case" ... mais ... ça ne marche pas ....
j'ai "bricolé" ... "bricolé" ... mais pas trouvée la coquille ...
fonctionnement :
un bouton rotatif 3 positions avec commun sur GND de l'arduino.
déclaration de constantes et de trois broches
const byte TP1 = 6;
const byte TP2 = 7;
const byte TP3 = 8;
déclaration de trois valeurs de tempos
#define DELAI1 150000 // 2 m et 30 sec
#define DELAI2 20000 // 20 sec
#define DELAI3 10000 // 10 sec
déclaration de tempo
int tempo = 0;
mon "switch" ...
switch (tempo) {
case TP1:
delay(DELAI1); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
case TP2:
delay(DELAI2); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
case TP3:
delay(DELAI3); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
default:
// instructions à exécuter si expression n'est égale à aucune des valeurs des case
break;
}
lorsque je lance la simulation... la "tempo" est de 10 secondes même en sélectionnant une autre position du commutateur qui n'a apparemment aucun effet ...
si je mets 30 secondes à DELAI3 10000 .. la tempo sera de 30 secondes .. si je mets 20 secondes .. c'est 20 secondes ..
je n'arrive pas à trouver mon erreur .. la compil est faite sans aucune alerte ni rejet
quelqu'un pourrait me donner un indice ?... j'ai oublié quoi ?....
( soyez gentil ... j'en suis à la lettre c du codage ... l'alphabet est looooooonnnnnngg ...
il faudrait le code et le détail du circuit...
On dirait que TP1, TP2 et TP3 sont des N° de broches
est-ce que tempo est aussi un N° de broche ?? comment l'initialisez vous ?
switch (tempo) {
case TP1:
PS: n'utilisez pas de #define, ce n'est pas typé et ça peut porter à confusion ensuite si vous faites des maths notamment
const unsigned long DELAI1 = 150000ul; // 2 m et 30 sec
const unsigned long DELAI2 = 20000ul; // 20 sec
const unsigned long DELAI3 = 10000ul; // 10 sec
PS2:
rajouter un petit encodeur rotatif et un écran LCD2040 vous permettrez d'avoir une petite interface utilisateur sur votre projet pour effectuer différents réglages de préférences.
Bonjour JML
pour le LCD ... c'est proposé mais ils ne veulent que seulement un rotatif pour sélectionner l'une des trois options de durée ...
Oui TP 1 2 et 3 sont des n° de broches comme indiqué ... une erreur ? ne pas faire ?...
tempo n'est pas un N° de broche ....
le truc recherché est de faire la sélection d'une durée en appliquant un GND sur la broche correspondant à la durée souhaitée .
Ok pour le #define ... je m'en doutais mais je découvre le fonctionnement du switch ...
je mets le code ci dessous
/*
============================================
code is placed under the MIT license
Copyright (c) 2024 J-M-L & NETERASER
For the Arduino Forum :
Merci à J-M-L pour le code de chainage des matrices et de la "logique" de gestion des MAX 7219
et de son support super sympa...
Code de gestion du chronometrage des cycles de tir sportif pour l'entrainement.
ce code inclut le fichier SYMBOLE.h qui contient tous les symboles et chiffres du sketch.
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.
14 Octobre 2024 - J-M-L & NETERASER ( C )
===============================================
*/
#include <SPI.h>
#include "SYMBOLES.h"
// Relais
#define RELAIS 5
// Buzzer
#define BUZZER 3 //buzzer pin
#define DELAI1 15000
#define DELAI2 20000
#define DELAI3 10000
/*
#define TP1 6
#define TP2 7
#define TP3 8
*/
// 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)
const byte TP1 = 6;
const byte TP2 = 7;
const byte TP3 = 8;
// ============== ajout sélection tempo modifiable
// suite valeur tempo
int tempo = 0;
// ============== FIN ajout sélection tempo modifiable
// 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(9800000, MSBFIRST, SPI_MODE0));
pinMode(RELAIS, OUTPUT);
pinMode(BUZZER, OUTPUT);
pinMode(TP1, INPUT);
pinMode(TP2, INPUT);
pinMode(TP3, INPUT);
// 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
//===============================X
// Buzzer alerte de compte à rebours
digitalWrite(BUZZER, HIGH); // Buzzer alerte de DEBUT de cycle
delay(200);
digitalWrite(BUZZER, LOW); // Buzzer DEBUT alerte de compte à rebours
delay(200);
digitalWrite(BUZZER, HIGH); // Buzzer alerte de DEBUT de cycle
delay(200);
digitalWrite(BUZZER, LOW); // Buzzer DEBUT alerte de compte à rebours
delay(200);
digitalWrite(BUZZER, HIGH); // Buzzer DEBUT alerte de compte à rebours
delay(200);
digitalWrite(BUZZER, LOW); // Buzzer DEBUT alerte de compte à rebours
delay(1000);
//================================X
// 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();
}
// Pause préparation
// barre BLEUE UP avec symbole SOUSTRACTION
afficherBitmap8x8(SYMBOLE_SOUSTRACTION, 0, 16);
afficherBitmap8x8(SYMBOLE_SOUSTRACTION, 8, 16);
afficherBitmap8x8(SYMBOLE_SOUSTRACTION, 16, 16);
afficherBitmap8x8(SYMBOLE_SOUSTRACTION, 24, 16);
// Pause préparation
delay(3000);
effacer();
// barre VERTE UP
afficherBitmap8x8(SYMBOLE_PLEIN, 0, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 8, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 16, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 24, 0);
// 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);
digitalWrite(BUZZER, HIGH); // Buzzer alerte de compte à rebours
delay(1000);
afficherBitmap8x8(CHIFFRE_2, 0, 16);
digitalWrite(BUZZER, HIGH); // Buzzer alerte de compte à rebours
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);
digitalWrite(BUZZER, HIGH); // Buzzer alerte de compte à rebours
// 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); // relais pour utilisation accessoire extérieur ou signal lumineux
digitalWrite(BUZZER, LOW); // Buzzer FIN alerte de compte à rebours
afficherBitmap8x8(SYMBOLE_PLEIN, 0, 8);
afficherBitmap8x8(SYMBOLE_PLEIN, 8, 8);
afficherBitmap8x8(SYMBOLE_PLEIN, 16, 8);
afficherBitmap8x8(SYMBOLE_PLEIN, 24, 8);
// barre compte a rebours DOWN
afficherBitmap8x8(SYMBOLE_OFF, 0, 16);
afficherBitmap8x8(SYMBOLE_OFF, 8, 16);
afficherBitmap8x8(SYMBOLE_OFF, 16, 16);
afficherBitmap8x8(SYMBOLE_OFF, 24, 16);
//============================================================
// temporisation durée du cycle de tir à modifier en fonction de la discipline
delay(DELAI3); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
//============================================================
// =============essai insert code CASE tempo
switch (tempo) {
case TP1:
delay(DELAI1); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
case TP2:
delay(DELAI2); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
case TP3:
delay(DELAI3); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
/*default:
// instructions à exécuter si expression n'est égale à aucune des valeurs des case
break;
*/
}
// ========================
digitalWrite(RELAIS, LOW);
effacer();
//==============================X
// barre VERTE UP
afficherBitmap8x8(SYMBOLE_PLEIN, 0, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 8, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 16, 0);
afficherBitmap8x8(SYMBOLE_PLEIN, 24, 0);
//===============================X
// Buzzer alerte de compte à rebours
digitalWrite(BUZZER, HIGH); // Buzzer alerte de fin de cycle
delay(200);
digitalWrite(BUZZER, LOW); // Buzzer FIN alerte de compte à rebours
delay(200);
digitalWrite(BUZZER, HIGH); // Buzzer alerte de fin de cycle
delay(200);
digitalWrite(BUZZER, LOW); // Buzzer FIN alerte de compte à rebours
delay(200);
digitalWrite(BUZZER, HIGH); // Buzzer alerte de fin de cycle
delay(200);
digitalWrite(BUZZER, LOW); // Buzzer FIN alerte de compte à rebours
//================================X
// temporisation sortie du cycle
delay(5000);
//=================================X
for (int x = 0; x < nbModulesX * 8; x++) {
effacer();
chargerBitmap8x8(SYMBOLE_VERTICAL, x, 0);
chargerBitmap8x8(SYMBOLE_VERTICAL, x, 8);
chargerBitmap8x8(SYMBOLE_VERTICAL, x, 16);
chargerBitmap8x8(SYMBOLE_VERTICAL, x, 24);
afficher();
delay(5); // Délai entre chaque déplacement
digitalWrite(BUZZER, LOW); // Buzzer FIN alerte de compte à rebours
}
for (int x = 0; x < nbModulesX * 8; x++) {
effacer();
chargerBitmap8x8(SYMBOLE_SOUSTRACTION, x, 0);
chargerBitmap8x8(SYMBOLE_SOUSTRACTION, x, 8);
chargerBitmap8x8(SYMBOLE_SOUSTRACTION, x, 16);
chargerBitmap8x8(SYMBOLE_SOUSTRACTION, x, 24);
afficher();
delay(5); // Délai entre chaque déplacement
}
}
void loop() {}
et le plan de cablage, il y a un commutateur à glissière pour "schématiser" le bidule mais ce sera un rotatif à trois positions.
tout fonctione sauf ... la sélection.
une correction non effacée au copier - coller
/*
//============================================================
// temporisation durée du cycle de tir à modifier en fonction de la discipline
delay(DELAI3); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
//============================================================
*/
donc quand vous faites
switch (tempo) {
case TP1:
delay(DELAI1); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
case TP2:
delay(DELAI2); // temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
break;
case TP3:
..
le compilateur va comparer tempo aux N° des broches, donc 6 7 et 8. Normal qu'il ne trouve pas si tempo vaut 0 ou autre chose.
donc il faut lire les 3 boutons et voir celui qui est activé et si vous gardez le switch tel qu'il est, il faut donner à tempo le N° de la broche qui est active mais c'est pas terrible comme approche
D'autre part, dans votre schéma je suppose qu'il y a les 3 broches 6,7 et 8 qui vont au bouton à 3 positions et le GND.
il faudrait changer le nom des broches pour être cohérent et définir les pins en INPUT_PULLUP
const byte tps1Pin = 6;
const byte tps2Pin = 7;
const byte tps3Pin = 8;
et dans le setup
pinMode(tps1Pin, INPUT_PULLUP);
pinMode(tps2Pin, INPUT_PULLUP);
pinMode(tps3Pin, INPUT_PULLUP);
ensuite il faut trouver quel est le bouton actif.
remplacez votre code et votre switch par le code suivant
//=============================================================================
// temporisation durée du cycle de tir à modifier en fonction de la discipline
// temporisation à mofifier : de 150 secondes à 10 secondes suivant sélection
// un bouton selectionné sera lu à LOW
//=============================================================================
if (digitalRead(tps1Pin) == LOW) delay(DELAI1);
else if (digitalRead(tps1Pin) == LOW) delay(DELAI2);
else if (digitalRead(tps1Pin) == LOW) delay(DELAI3);
else delay(DELAI3); // délai par défaut
//=============================================================================
➜ on va lire avec digitalRead() l'état de chaque pin et celle qui est sélectionnée sera vue à LOW et on applique le délai associé
PS: la vidéo n'a pas besoin d'avoir une limite d'âge, ça empêche de la voir directement dans le forum. (très bon montage sinon !)
oui tout à fait ça ... un bouton rotatif genre potentiomètre à trois positions ( velleman ).
le INPUT_PULLUP ?... faut que j'aille regarder son "fonctionnement ... je ne connais pas bien du tout .
merci du suivi ... je vais aller modifier suivant vos instructions ... 
bonne soirée et encore merci.
lisez ce tuto et vous comprendrez tout