Kit contrôleur d'affichage VFD (afficheur fluorescent sous vide) basé sur Arduino

Composants et fournitures

Composant	Quantité	Notes
Arduino UNO	1	...ou tout Arduino 8 bits
Afficheur VFD	1	notre composant principal
CD4094	2	Circuit intégré DIP
CD4017	2	Circuit intégré DIP
BC557	17	...ou transistor équivalent (2N3906, 2SA733, etc.) ou PNP à tension plus élevée
BC547	2	...ou transistor équivalent (2N3904, 2SC945, etc.)
PC817	1	Optocoupleur universel trouvé dans la plupart des alimentations à découpage
1N4007 – Diode haute tension, fort courant	4
Condensateurs électrolytiques	4	voir schéma pour valeurs et tensions
Condensateur 470nF	1	n'importe quel type convient
Plaque d'essai (perfboard)	1	aka: plaque papier, protoboard, ou votre solution d'assemblage préférée
Résistances 1/4W	24	voir schéma pour valeurs
Cavaliers Dupont	1	...ou vos connexions et broches préférées
Fils	1	fils fins pour l'arrière du circuit et pour brancher l'afficheur, n'utilisez pas de connecteurs car l'espacement des broches est variable et un soudage rapide est plus simple

Outils et machines nécessaires

• Fer à souder (générique)
• Fil à souder (achetez-le en magasin local, pas de bas de gamme, 0.5mm préféré)
• Coupe-fil

À propos de ce projet

Quelle utilité ?

Les afficheurs VFD ne sont plus à la mode pour des raisons évidentes : ils sont en verre (« uh cool ! »), possèdent un filament incandescent (« vraiment ?? »), ce sont essentiellement des tubes sous vide (« intéressant ! »), ils produisent une lumière si brillante, parfois colorée, qu'il faut un plastique sombre par-dessus (« uh, cool encore ! »).

Généralement, vous avez besoin d'une puce dédiée pour les piloter. La plupart des modules/appareils sont livrés avec cette puce que vous pouvez contrôler indépendamment via I2C ou SPI (bien plus simple). Si vous achetez ou possédez un de ces afficheurs sans cette puce, ce n'est pas si facile à « connecter et utiliser ». L'idéal serait d'acheter cette puce (généralement en format SMD). Ce circuit offre une interface assez correcte pour un Arduino et peut piloter probablement n'importe quel VFD, y compris les gros tubes « vintage », mais les afficheurs matriciels avec beaucoup de segments ne sont pas une bonne idée. Vous pouvez étendre le circuit mais MILLIERS... hum, peut-être pas.

Avantages et inconvénients

Avantages

• Coût quasi nul (espérons-le)
• Composants faciles à trouver
• Capacité haute tension (jusqu'à des centaines de volts sur les anodes)
• Tensions grilles et anodes indépendantes
• Seulement 3 lignes de données numériques nécessaires
• Extensible (nécessite plus de travail CPU le cas échéant)
• Code prêt pour tout Arduino 8 bits

Inconvénients

• Nécessite plusieurs tensions et alimentations différentes (normal pour les VFD)
• Pas de fonction gradateur (sauf par tension d'alimentation)
• Utilise deux ressources Arduino : SPI et timer1
• Vous ne pouvez pas bloquer le microcontrôleur, sinon le balayage gèle sur une grille
• Ce n'est pas juste une paire de résistances et LEDs, cela demande du travail

Principe de fonctionnement

Un VFD fonctionne généralement en mode multiplexé, comme une matrice 2D avec axes X et Y. Il faut chauffer le filament (la cathode, vous voyez ces fils fins devant), connecter la masse sur ce filament, appliquer une tension positive sur une grille (grille de contrôle, un point de l'axe X) et à nouveau une tension positive sur une broche de segment (l'anode, un point de l'axe Y). À ce moment, un segment (un seul) s'allume. Pour allumer n'importe quel segment et n'importe quelle combinaison, avec « peu » de fils, le multiplexage sélectionne une grille à la fois et configure simultanément les anodes pour allumer les segments correspondants sous cette grille. Un instant après, il sélectionne une autre grille et configure les anodes pour les segments correspondants sous cette deuxième grille. En accélérant ce balayage continu, le mouvement devient si rapide qu'à l'œil il ne semble pas sélectionner une grille à la fois, mais paraître piloté d'un seul coup. C'est ce qu'on appelle la POV (Persistance de la Vision).

Ce circuit utilise deux types de circuits intégrés de la même famille : deux CD4094 et deux CD4017. Les 4094 pilotent les anodes et les 4017 pilotent les grilles. Les 4094 peuvent mémoriser une configuration haut/bas sur leurs sorties et conviennent pour le côté anodes. Les 4017 sont les puces classiques à 10 sorties séquentielles, parfaites pour les grilles. Une fois les 4094 chargés avec la configuration momentanée des anodes, le signal « ok » (strobe) applique cette configuration et fait avancer les 4017 d'un pas, permettant une séquençage automatique.

La partie puissance consiste essentiellement en des transistors BC557 (ou équivalents) qui permettent une plus grande plage de tension sur les anodes, car ces afficheurs nécessitent une tension supérieure aux 5V de l'Arduino. Les grilles sont pilotées directement par les 4017. Un optocoupleur PC817 permet une tension supérieure à 5V autour des 4017 et un niveau de tension différent des CD4094, ce qui simplifie ENORMEMENT l'ensemble.

L'Arduino doit fournir toute l'orchestration : il doit stocker toutes les configurations de segments et charger le circuit avec la configuration d'anodes à chaque changement de grille. Cela nécessite un code astucieux pour le faire au-delà de l'action utilisateur. Le code que j'ai fait configure une interruption basée sur un timer qui recharge les puces 4094 à chaque pas, environ 1000 fois par seconde. Pour 10 grilles, cela donne un taux de rafraîchissement de 100Hz, ce qui est bon. Il y a un tableau de données qui stocke la configuration des segments et peut être modifié dans le code, sans procédures particulières ni actions subséquentes : la routine d'interruption téléversera les données par elle-même.

Alimentations

La tension des grilles sur les puces 4017 peut aller de 5Vcc à 18Vcc et au moins 50mA de courant, elle n'a pas besoin d'être régulée. Habituellement (autant que j'ai vu) 12V suffisent pour toutes les situations. L'augmenter ne semble pas augmenter beaucoup la luminosité (si c'est un tube sous vide, la grille n'a pas besoin de tensions énormes).

La tension des anodes peut aller de 0V littéralement jusqu'à ce que vos transistors supportent (50Vcc pour le BC557). Habituellement, si l'afficheur est parfait, 20-30Vcc feront parfaitement l'affaire, non régulé c'est bien. Pour une configuration normale, 50mA d'alimentation sont plus que suffisants.

L'alimentation numérique peut être 5Vcc ou aussi 3.3Vcc pour ce type d'Arduino ou MCU (pas encore testé), cela nécessite environ 100mA (espérons moins). Si les CD4094 deviennent lents, vous pouvez réduire l'horloge SPI dans le code et/ou utiliser la sortie « Q'S » du premier 4094 pour une communication plus cohérente.

L'alimentation du filament doit fournir au moins 5V 200-300mA. Si vous avez déjà une source DC, vous pouvez éviter le pont redresseur et le condensateur 1000uF, mais vous NE POUVEZ PAS utiliser la même alimentation numérique pour/depuis l'Arduino. Le filament réel, dans le cas d'un afficheur d'appareil pas trop gros, fonctionne sur environ 3V et peut consommer 150mA.

Conseils et notes

• Avant de brancher les fils, si vous ne savez pas quelle broche fait quoi, mieux vaut tester l'afficheur d'abord. Généralement, deux piles AA en série conviendront pour le filament (généralement les contacts latéraux), tandis que deux piles 9V en série fourniront la polarisation positive pour les grilles et anodes. Les grilles et anodes sont souvent groupées. Une bonne idée est de trouver le « anode zéro » car c'est très probablement le premier segment sur la partie numérique ou alphanumérique, souvent le même et dans le même ordre pour toutes les grilles. Mettre les fils dans l'ordre inverse par accident rend le logiciel plus maladroit à la fin. Les grilles, apparemment, suivent l'ordre des broches.
• Allez-y doucement sur l'alimentation du filament, augmentez le courant petit à petit, restez dans l'obscurité et dès que vous voyez les filaments devenir légèrement incandescents, réduisez un peu. Un potentiomètre de puissance est parfait, on en trouve parfois dans de vieilles TV mais c'est difficile de nos jours.
• Augmentez les tensions grilles/anodes de manière raisonnable. Les phosphores peuvent brûler irrémédiablement. Le circuit fonctionne aussi en balayage, donc si le système plante, vous fournirez trop de puissance sur une seule section de grille en continu.
• Jouez sur un compromis tensions grilles/anodes. Gardez à l'esprit que les grilles peuvent consommer du courant, pas la peine de forcer dessus. Mieux vaut surveiller les anodes.
• Utiliser un seul transformateur pour tout votre projet/configuration est idéal. Des solutions mixtes peuvent être utilisées, mais les alimentations à découpage et surtout celles avec mise à la terre peuvent vous jouer un mauvais tour. C'est pourquoi pour l'expérimentation, c'est TOUJOURS une bonne idée d'utiliser des alimentations à transformateur classique.
• Vous pouvez étendre ce pilote en ajoutant des CD4094 et/ou CD4017. Bien sûr, si vous avez besoin de 8 anodes ou moins, vous pouvez supprimer le second 4094. Même scénario pour le 4017. Mais si vous voulez le pilote prêt à l'emploi, construisez-le le plus complet possible.
• Il n'y a pas de résistances sur les bases des transistors d'anodes comme vous pouvez le voir. Cela donne une commande ultra-rapide et réduit la liste des composants, mais fait consommer un peu de puissance aux CD4094. Ils ne chaufferont presque pas mais certains exemplaires de puces peuvent avoir une sortie trop forte. Vérifiez la consommation de courant au besoin. Les puces ne grilleront pas car la puissance dissipée est DANS le maximum autorisé. Le courant peut être dans les 4mA par broche à 5V d'alimentation.
• Les vieux afficheurs fatigués peuvent être rajeunis par des chocs de courant sur les filaments. Si c'est tout l'afficheur qui est faiblard et pas juste un segment brûlé, on dit qu'il faut amener les fils visiblement incandescents (jaunes) environ cinq fois de suite pendant quelques secondes à chaque fois. Jamais essayé mais cela pourrait nécessiter le double de la tension nominale du filament. Cela les nettoie mais apparemment c'est plus utile pour les très vieux/antiques... et c'est risqué, ce ne sont pas des ampoules, vous pourriez casser les fils.

Code

Code Arduino avec routine fonctionnelle (Arduino)

/* Interface matérielle polyvalente pour afficheur VFD - Programme Arduino Copyright (C) 2019 Genny A. Carogna Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier sous les termes de la Licence Publique Générale GNU telle que publiée par la Free Software Foundation, soit la version 3 de la Licence, soit (à votre convenance) toute version ultérieure. Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de QUALITÉ MARCHANDE ou D'ADÉQUATION À UN USAGE PARTICULIER. Voir la Licence Publique Générale GNU pour plus de détails. Vous devriez avoir reçu une copie de la Licence Publique Générale GNU avec ce programme. Sinon, voir . */ /* ce code utilise les ressources de l'Arduino de manière "en coulisses", les modules timer1 et SPI sont tous deux utilisés et occupés *, donc vous pouvez avoir de gros problèmes en utilisant SPI, broches SPI, et certaines fonctionnalités basées sur timer1... le circuit proposé * n'a pas de mémoire embarquée, donc la configuration des segments doit être "balayée" continuellement, à chaque grille, 100 fois par seconde *, depuis le tableau des segments de l'Arduino, cela se traduit aussi par le soi-disant "overhead" travail CPU, qui, pour vous dire, n'est * pas plus que l'utilisation régulière d'un micro au final, cela peut atteindre environ 3% du temps CPU occupé, vous pouvez aussi essayer * d'utiliser les outils SPI réguliers d'Arduino mais cela nécessite une analyse approfondie de la sortie et de la procédure * * ce code fonctionne avec n'importe quel Arduino 8 bits, aussi 3.3V devrait marcher, peut-être réduire la fréquence SCK, considérant que les CD4094 sont * alimentés avec et peuvent "sous-volter" (oui, exactement les principes d'overclock pour griller votre cher PC) */ #define ledLed 13 // c'est la broche led qui allume une led pour vous faire savoir qu'une led allumée signifie des trucs liés aux leds (charabia scientifique bien sûr) #define strobePin 4 // la broche Arduino dédiée à la ligne "strobe" #define strobeHold 10 // microsecondes // temps de maintien pour commuter l'optocoupleur... pas méga-hertz-rapide mais acceptable // données pour mes afficheurs (un magnétoscope vidéo, un lecteur CD audiophile et une chaîne compacte)... ne faites pas attention, supprimez, et définissez juste "gridAmount" et "anodeAmount" #define JVC #define mitsubishiGrids 10 #define mitsubishiAnodes 9 #define marantzGrids 9 #define marantzAnodes 14 #define JVCGrids 11 #define JVCAnodes 19 #if defined mitsubishi #define gridAmount mitsubishiGrids #define anodeAmount mitsubishiAnodes #elif defined marantz #define gridAmount marantzGrids #define anodeAmount marantzAnodes #elif defined JVC #define gridAmount JVCGrids #define anodeAmount JVCAnodes #endif // ce tableau, segments[x], stocke les bits de segments // segments[0] signifie grille zéro, et le bit de poids faible est le segment zéro dans cette grille // vous pouvez accéder et modifier ce tableau comme vous voulez, de n'importe où, sans rien faire d'autre, l'effet est immédiatement visible sur // l'afficheur, et reste tant que vous ne changez pas les bits. Pour les afficheurs avec plus de 8 segments par grille, vous avez besoin d'un // conteneur 16 ou 32 bits par grille, c'est géré automatiquement par les #define ci-dessus #if anodeAmount > 16 volatile uint32_t segments[gridAmount] = {0}; // plus de 16 segments par grille (32 bits nécessaires) #elif anodeAmount > 8 volatile uint16_t segments[gridAmount] = {0}; // plus de 8 segments par grille (16 bits, double transfert) #else volatile uint8_t segments[gridAmount] = {0}; // 8 ou moins segments par grille (8 bits) #endif void setup(){ // configure broches SPI et quelques fonctionnelles en sortie de manière rapide/directe *portModeRegister(digitalPinToPort(PIN_SPI_SS)) |= digitalPinToBitMask(PIN_SPI_SS); *portModeRegister(digitalPinToPort(PIN_SPI_MOSI)) |= digitalPinToBitMask(PIN_SPI_MOSI); *portModeRegister(digitalPinToPort(PIN_SPI_SCK)) |= digitalPinToBitMask(PIN_SPI_SCK); *portModeRegister(digitalPinToPort(strobePin)) |= digitalPinToBitMask(strobePin); *portOutputRegister(digitalPinToPort(strobePin)) &= ~digitalPinToBitMask(strobePin); // le mettre à LOW *portModeRegister(digitalPinToPort(ledLed)) |= digitalPinToBitMask(ledLed); *portOutputRegister(digitalPinToPort(ledLed)) &= ~digitalPinToBitMask(ledLed); // le mettre à LOW delay(800); // délai pour attendre la fin du reset des CD4017 (vous devez lancer le code APRÈS avoir alimenté les 4017, cela le rend automatique si vous alimentez tout d'un coup) cli(); // désactive les interruptions pour nous laisser bidouiller sans que chats et chiens s'échappent partout // configuration timer1, il fait une interruption "grilles fois 100" par seconde... cela donne un rafraîchissement total de 100Hz qui est ok TCCR1A = 0; TCCR1B = 0; TCNT1 = 0; OCR1A = 160000 / gridAmount; TCCR1B |= (1 << WGM12); TCCR1B |= (1 << CS10); TIMSK1 |= (1 << OCIE1A); // configuration SPI, nous ne pouvons pas utiliser les outils SPI Arduino car ils reposent sur les interruptions ET nous // avons besoin que la communication se passe DANS une interruption.. // changer SPR0 pour SPR1 et décommenter la dernière ligne pour avoir la moitié de la vitesse d'horloge SPI SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // vitesse SCK 1MHz standard // SPSR = (1 << SPI2X); // décommenter ceci et modifier ci-dessus pour moitié vitesse d'horloge sei(); // les interruptions sont de nouveau actives // il vaut mieux mettre votre code setup() additionnel à partir d'ici } // vous pouvez faire ce que vous voulez dans loop(), délais, sondages, mais désactiver les interruptions ou faire planter le micro complètement // gèlera l'affichage sur une grille, et si la tension est à fond vous risquez de griller des segments (!!) void loop() { show(); // genre d'écran de veille, vous pouvez supprimer } // routine de service d'interruption, se produit à chaque commutation de balayage de grille et 100 fois par seconde ISR(TIMER1_COMPA_vect){ /* ATTENTION ATTENTION: je ne sais pas pourquoi je dois démarrer "turn" à 1 pour un fonctionnement correct (j'alimente l'Arduino après et cela peut inverser une grille), au cas où il continue de rater la grille correcte au démarrage, varie ceci ATTENTION */ static uint8_t turn = 1; // variable indestructible pour se souvenir à quelle grille nous étions à l'interruption suivante #if anodeAmount > 24 SPDR = ~uint8_t(segments[turn] >> 24); // nous avons besoin de bits négés sur le CD4094 (à cause de l'arrangement des transistors) while (!(SPSR & (1 << SPIF))) ; // attendons que le transfert se termine #endif #if anodeAmount > 16 SPDR = ~uint8_t(segments[turn] >> 16); // nous avons besoin de bits négés sur le CD4094 (à cause de l'arrangement des transistors) while (!(SPSR & (1 << SPIF))) ; // attendons que le transfert se termine #endif #if anodeAmount > 8 SPDR = ~uint8_t(segments[turn] >> 8); // nous avons besoin de bits négés sur le CD4094 (à cause de l'arrangement des transistors) while (!(SPSR & (1 << SPIF))) ; // attendons que le transfert se termine #endif SPDR = ~uint8_t(segments[turn]); // nous avons besoin de bits négés sur le CD4094 (à cause de l'arrangement des transistors) while (!(SPSR & (1 << SPIF))) ; // attendons que le transfert se termine... yyyYYYAAAAWWWWNNNnnn........... // strobing (enfin!!) cela commute aussi la grille sur les CD4017s *portOutputRegister(digitalPinToPort(strobePin)) |= digitalPinToBitMask(strobePin); // commande rapide broche ON delayMicroseconds(strobeHold); *portOutputRegister(digitalPinToPort(strobePin)) &= ~digitalPinToBitMask(strobePin); // commande rapide broche OFF // rappel tour de grille à la rotation turn ++; if (turn == gridAmount) turn = 0; } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////À PARTIR D'ICI LE SKETCH CONCERNE MES AFFICHEURS ET JEUX VISUELS, VOUS POUVEZ SUPPRIMER À PARTIR D'ICI///////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // ceci est juste une démo, supprimez comme vous voulez void show() { // chiffres qui défilent #ifdef mitsubishi for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(200); mitsubishiPrintNum(j, i); } for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(20); mitsubishiPrintNum(j, i); } #elif defined marantz for (uint8_t i = 0; i < 6; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(200); marantzPrintNum(j, i); } for (uint8_t i = 0; i < 6; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(20); marantzPrintNum(j, i); } #elif defined JVC /* for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(200); JVCPrintNum(j, i); } for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(20); JVCPrintNum(j, i); }*/ #endif delay(500); // segments qui défilent for (uint8_t i = 0; i < gridAmount; i ++) for (uint8_t j = 0; j < anodeAmount + 1; j ++) { delay(100); segments[i] = (uint32_t(1) << j); } delay(500); // tout l'afficheur clignote for (uint8_t i = 0; i < 5; i ++) { delay(200); for (uint8_t j = 0; j < gridAmount; j ++) { segments[j] = 0xFFFFFFFF; } delay(200); for (uint8_t j = 0; j < gridAmount; j ++) { segments[j] = 0; } } delay(500); } // visualisation simple de nombre sur 7 segments void mitsubishiPrintNum(uint8_t val, uint8_t pos) { if (pos > 2) pos ++; uint16_t mask = 0xFF80; uint8_t numbers[] = {B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00100111, B01111111, B01101111, B00000000}; switch (pos) { case 0: case 1: case 4: case 5: case 6: case 7: case 8: segments[pos] &= mask; segments[pos] |= numbers[val]; break; case 2: if (val == 1) segments[1] |= (1 << 8); else segments[1] &= ~(uint16_t(1) << 8); break; case 9: segments[9] &= 0xFFF0; if (val == 1) segments[9] |= 3; else if (val == 2) segments[9] |= B1101; } } // visualisation simple de nombre sur 7 segments void marantzPrintNum(uint8_t val, uint8_t pos) { if (pos > 5) return; pos ++; pos ++; uint16_t mask = 0xFF80; // masque pour effacer le chiffre uint8_t numbers[] = {B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00100111, B01111111, B01101111, B00000000}; segments[pos] &= mask; // effacer le chiffre segments[pos] |= numbers[val]; // régler le chiffre } // visualisation simple de nombre sur 7 segments void JVCPrintNum(uint8_t val, uint8_t pos) { // à venir (vous n'en avez pas vraiment besoin) } // 

Schémas

J'ai évité de dessiner TOUS les transistors BC557 car ils sont simplement connectés sur toutes les sorties des CD4094, tous de la même façon.

Il y a un sélecteur de cavalier (sur la ligne rouge) que vous devez configurer sur les puces 4017. Il réinitialise les deux 4017 à la fin du balayage des grilles. Vous devez connecter (ou souder) le cavalier volant sur la broche de sortie APRÈS la dernière grille. Donc si votre afficheur a 10 grilles, le cavalier va sur la 11ème sortie.

Les connexions Arduino sont tracées en rouge. Vous pouvez utiliser l'alimentation USB pour l'Arduino mais il est fortement conseillé d'utiliser un transformateur classique pour les autres alimentations si vous avez déjà une alimentation mise à la terre comme votre PC. Ces alimentations doivent être toutes continues sauf peut-être l'alimentation du filament. J'ai ajouté des diodes car il est probable que vous ayez besoin d'un transformateur séparé avec un secondaire basse tension. L'alimentation du filament varie généralement autour de 3V 150mA. Un transformateur 5V AC suffira. La "résistance de lestage" sera possiblement un potentiomètre de puissance bobiné d'environ 100 ohms, ou une résistance fixe, ou aussi quelques diodes 1N4007 pour réduire la tension.

Les transistors BC557 tirent les anodes vers la tension anodique et les résistances 100kohm laisseront la tension de commande retomber quand le segment est éteint, tandis que les CD4094 restent normalement à 5V.

Les CD4017 seront alimentés avec la tension grille et ne nécessitent pas de transistors supplémentaires. Il y a un circuit de reset "bricolé" pour les 4017 qui dure environ un dixième de seconde. Vous devez attendre qu'il se stabilise avant de lancer le code. Le schéma "original" pour cascader des CD4017 nécessitait d'autres puces logiques. J'ai utilisé à la place un transistor NPN et l'optocoupleur lui-même pour reproduire une porte ET. C'est assez rapide à la fermeture donc c'est parfait pour la tâche. Au relâchement, c'est un peu plus lent mais on s'en fiche, surtout parce que les entrées d'horloge sur les 4017 sont à trigger Schmitt et la vitesse requise n'est pas "effrayante" là-bas.

Il y a diverses masses pour les puces et composants comme vous pouvez le voir, regardez bien.