Discussion :

[ChampAng]

Je galère quand je place 2, 3 ou 4 de ces afficheurs en série.

Je n'ai pas tout compris sur les manipulations des registres et comment envoyer 8 x N afficheurs
je ne sais pas comment placer ma boucle pour N afficheurs
À savoir pour le montage en série sur arduino mega2560 en utilisant les pins SPI
Afficheur 1 --------------- ---------- Afficheur 2 ----- -------- Afficheur N
IN afficheur 1 --------------- ---------- IN afficheur 2 ---- --------- mêmes relations
DYO_Pin = 51; sur mega ----- DYO sur QH afficheur1
RCLK_Pin = 53; sur mega ----- RCLK sur RCLK afficheur1
SCLK_Pin = 52; sur mega ----- SCLK sur SCLK afficheur1

Pouvez-vous m'aider, mes neurones s'entremêlent ?

[f-leb]

Il s'agit bien de ces afficheurs ?

Mais je pense que cela dépend du fabricant :
https://fr.aliexpress.com/item/32834757140.html

SCLK est le signal d'horloge, donc oui, on les chaîne et on relie à l'Arduino.
RCLK est le signal Latch, donc idem.
DIO est le signal des données série qui rentre dans le 1er registre à décalage du 1er module (il y a deux registres par module), à relier à l'Arduino.
De l'autre côté du module, je vois une sortie QH qui doit être la sortie du 2è registre à décalage du module, et qui doit être reliée à l'entrée DIO du module suivant.
En fait, ces modules sont prévus pour être chaînés : les entrées du 1er module sont reliées à l'Arduino, les sorties du 1er module sont chaînées avec les entrées du 2è module, etc.

Tu as relié le module aux broches dédiées au SPI (50,51,52,53). Tu peux les utiliser, mais les afficheurs ne communiquent pas en SPI, cela n'a rien à voir.

[ChampAng]

Bonjour, j'utilise le port SPI par commodité pour mon projet, j'aurai pu utiliser les broches du projet initial : SCLK = PWM 6 , RCLK = 5 , DIO = 7, mais cela ne change rien
Le pin indispensable est le signal SCLK.

Les afficheurs sont les mêmes.

C'est la logique pour envoyer sur :
8 digits : 64 bits
16 digits : 128 bits
24 digits : 192 bits
32 digits : 256 bits
N....
en utilisant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
digitalWrite(LATCH_PIN, LOW);
 
  // Voir https://www.arduino.cc/reference/en/language/functions/advanced-io/shiftout/
  shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift);  // octet de poids faible en premier
  shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift >> 8);
 
  digitalWrite(LATCH_PIN, HIGH);

[f-leb]

C'est la logique pour envoyer sur :
8 digits : 64 bits
16 digits : 128 bits
24 digits : 192 bits
32 digits : 256 bits
N....

Il y a deux registres à décalage 8 bits par module d'affichage (1 module = 8 digits).

1 module 8 digits ==> 2 octets à pousser
2 modules 8 digits chaînés ==> 4 octets à pousser
3 modules 8 digits chaînés ==> 6 octets à pousser
etc.

Un shiftOut permet à l'Arduino de pousser 1 octet dans le 1er registre du 1er module. Après c'est le principe des registres à décalage, à chaque fois que tu pousses un octet, tous les octets poussés avant sont décalés et poussés dans le registre à décalage suivant.

Avec deux modules (et donc 4 registres à décalage chaînés), il faut faire quatre shiftOut. Avec trois modules (six registres à décalage chaînés), il faut six shiftOut, etc.

[ChampAng]

Merci, mes neurones comprennent dans ta réponse ????

shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift); // octet de poids faible en premier
shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift >> 8);
shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift >> 16);
shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift >> 24);
shiftOut(DATA_IN_PIN, CLOCK_PIN, LSBFIRST, dataToShift >> 16);
etc ...
Je n'ai pas testé en réel.

[f-leb]

Il y a quand même des limites...

dataToShift est un unsigned int (un entier non signé 16 bits). Quand tu passes un entier 16 bits à shiftOut, il n'y a que les 8 bits de poids faible qui sont envoyés au registre à décalage. C'est pour ça qu'il faut décaler avec dataToShift>>8 avec un 2è shiftOut pour envoyer les 8 bits de poids fort.

Je ne sais pas si shiftOut accepte les entiers 32 bits (unsigned long) ou 64 bits (unsigned long long je crois), à voir.

Sinon, passer par plusieurs variables, une variable 16 bits par module d'affichage, ou un tableau d'entier 16 bits.

ça devient forcément plus complexe à gérer

Mais tu veux afficher quoi exactement, et de combien de modules tu as besoin ?

[ChampAng]

Mais tu veux afficher quoi exactement, et de combien de modules tu as besoin ?

Projet : Afficher les valeurs pour naviguer sur mon "boat" dans le cockpit pour le suivi instantané à la barre des valeurs suivantes sur 4 afficheurs sis-nommés et voir sans lunettes. "Vue diminue avec l'âge" et conditions jour/nuit/pluie.
- Heure (DS1307)
- Pression Atmosphérique (BMP280)
- Température atmosphérique (Thermistance)
- Température eau (Thermistance)
- Cap Magnétique (BNO085)
- Vitesse GPS vraie (Ublox M8N ou M6N)
- Direction du vent (capteur Serial1 norme NMEA0185 avec optoélectronique idoine)
- Vitesse du vent (capteur Serial1 norme NMEA0185 avec optoélectronique idoine)
- Eau sous la quille quand prof < 20m en remplacement de Pression atmosphérique (capteur Serial1 norme NMEA0185 avec optoélectronique idoine)

Pour l'instant ma carte Arduino mega 2560 traite ces données et les envoie à la norme NMEA0185 avec un nfr24l01 sur Raspberry équipée de ce nrf24l01 en récepteur en débit de 1MPS.
Un capteur Photocell adaptera la luminosité de ces afficheurs en envoyant une tension variable sur VCC
Le Raspberry sous OpenPlotter avec ces données. http://github.com/openplotter pour tactique navigation.

Le pitch et le roll sont traités par le pilote automatique pour ajuster en fonction de l'état de la "mare"
Et je ne te rajoute pas les alarmes AIS, eau sous la quille, roulis > X , MOB et ETA etc....

[f-leb]

Bonjour,

Le problème avec ces 4 modules en cascade, c'est qu'il faut gérer un timing très précis pour le multiplexage et les décalages dans les registres (en multiplexé, il faut présenter le chiffre devant chaque digit chacun leur tour, en permanence et en tournant sur les digits suffisamment rapidement pour qu'on ne distingue pas de clignotement, voir ici dans un autre contexte). C'est possible mais s'il y a un capteur qui est bloquant, l'afficheur n'est plus rafraichit à temps et il se met à clignoter. Un compromis est d'utiliser une entrée DIO différente par module, mais on conserve RCLK et SCLK commun aux 4 modules : ça consomme plus de broches côté Arduino, mais c'est plus simple à gérer dans le code car tu peux gérer 1 module à la fois.

Tu devrais aussi regarder les modules avec les drivers spécialisés comme le MAX7219. C'est plus cher mais c'est plus simple à gérer au niveau du code (et il y a des bibliothèques qui aident bien). Le driver communique en SPI donc 3 broches côté Arduino, et tu peux aussi mettre les modules en cascade. C'est le driver qui s'occupe du multiplexage, le courant envoyé aux digits est constant et tu peux même commander la luminosité. Avec la bonne bibliothèque, tu t'adresses au MAX7219 en lui commandant telle valeur sur tel afficheur, et le driver gère l'affichage, c'est le must