Voir la source de Afficheur rotatif pov

== WTF / Principe ==
Créer un afficheur rotatif tirant partie de la persistence rétinienne (Persistence Of Vision).
Dans sa forme la plus basique, l'afficheur est composé d'une barre de LED tournant rapidement. Chaque LED peut etre allumé ou etinte précisément en fonction de sa position angulaire. Si la barre de LED tourne suffisament vite alors la persistence rétiniene entre en jeu, et on obtient alors un écran circulaire.

Exemple plutôt bien documenté: http://public.iutenligne.net/etudes-et-realisations/nardi/afficheur_rotatif_a_leds/general/index.html

== Idées ==
* Le plus simple est d'embarquer sur la barre de LED mobile tout le dispositif d'affichage, de controle et d'alimentation. 
* Multiplier le nombre de barre de LED permet d'augmenter la luminosité de l'affichage.
* La barre de LED pourrait même être un disque complet, mais ce serait plus lourd, donc nécessiterait plus d’énergie pour la mise en rotation (et beaucoup moins stylé !).
* On peut envisager de faire tourner la barre de LED sans moteur, un peut à la manière d'une tronçonneuse, en tirant un fil avec force, qui va communiquer l'energie de rotation nécéssaire à l'aiguille. Cette énergie de rotation pourrait alimenter le dispositif en énergie avec une dynamo. Un contre poid permettrait d'accumuler l’énergie de rotation.
* 3 barres de LED RVB permettrait un affichage en couleur.
* J'ai eu une suggestion d'utiliser un moteur de disque dur pour faire tourner la barre de LED : à étudier.

=== De la technologie ===
* De simples leds mono couleur sont simples à controllés : 1 led = 1 bit.
* Des leds RGB nécéssitent plusieurs bits par led, eventuellement 3 octets par triplet de led.
* Le truc classe avec le RGB, c'est qu'il est possible d'aligner 3 leds cote à cote et ainsi multiplier par 3 l'itensité lumineuse globale de l'affichage.
* On peut envoyer des peak de courants dans les leds au dessus du courant moyen => voir dans quelle mesure. A ce moment là il faudra integrer une protection qui interdit l'affichage constant des leds pour limiter le courant moyen. Led standard: 20mA moyen, 30 ma en peak.
* Il doit etre possible de se passer de PWM pour les leds, vu qu'il est possible de moduler l'intensité lumieuse des leds en décidant de ne pas afficher à chaque tour.
* Il devrait etre possible de moduler l'intensité lumineuse d'un pixel si il est en fait composé de plusieurs "pixels radiaux": en doublant la frequence de commande requise, on divise chaque pixel en 2 demis pixels, il est alors possible d'allumer alternativement les 2 demis pixels pour diviser la luminosité par 2. Du coup 1 bit par led suffit, il suffirait de quelques registres tampon pour eviter d'utiliser un pin du microcontroller par led. Avec eventuellement un chargement par octet pour pouvoir piloter 32 (4 x 8) leds en 4 cycles d'horloge avec 2 bits d'adresse. 
* Avec le verrou 8 bits CY74FCT2573T il faut 2 cycles d'horloge d'au moins 24 ns chacun soit < 41 MHz, Donc c'est completement ok pour un Atmel. Pour un premier test, un ATmega dispose des 40 bits nécéssaires pour gérer 40 leds d'un proto.
* Il faut trouver un circuit integré d'amplification Le TLC59212 est open collector 8 bit latch, donc il fait latch + ampli. Ce circuit necessite 2 cycles de 40 ns soit 25 MHz max => Ok pour ATmega à 16 MHz. Mais 40 mA max par sortie
* Le MIC5801 peut bourrer 500 mA (c'est étrangement beaucoup !!!) par sortie mais le constructeur annonce 5 MHz max à 5V, et mieux à 12V mais combien ?
* Quelques buffer: SN5407, SN5417, SN7407, SN7417 et inverters: SN5406, SN5416, SN7406, SN7416 limités à 40mA.
* 8 bit latch serie: 9 cycles d'horloge pour positionner 8 leds ; 1 bit clock + 1 bit lock + 1 bit par latch  (40 leds 9 cycles 6 bits)
* 8 bit latch parallel: 2 cycles d'horloge pour positionner 8 leds; 1 bit clock + 8 bit par latch + X bits addressage ou 8 bit + 2 cycles d'horloge par latch (40 leds + 2 cycles 41 bits ou 10 cycles + 12 bits)
* Il parait plus scalable d'utiliser des latch serie car cela est utilisable en temps constant, avec un nombre de bits qui croit faiblement. De plus c'est moins chiant à cabler.
* Quelques 8 bit latch serie: 74HC595 (open collector outputs (max 65 mA) ; les sorties sont relativement faciles à cablés ; shift à 20 MHz)
* Le capteur a effet hall US1881 à l'air bien pour cet usage: https://www.sparkfun.com/datasheets/Components/General/Hall-US1881EUA.pdf

=== Des leds ===
* Rectangulaire 2x5mm 35 mA : http://fr.farnell.com/cml-innovative-technologies/v57123-17/led-rectangulaire-rouge-he/dp/1139584
* Rectangulaire 2,5x5mm 30 mA (160 mA peak): http://www.farnell.com/datasheets/1446122.pdf
* Rectangulaire 2,8x4mm 30 mA (150 mA peak) : http://fr.farnell.com/kingbright/l-1034lid/led-2mm-sommet-plat-rouge-he/dp/1142482
* Ronde 3mm 30 m1 (100 mA peak) : http://fr.farnell.com/wurth-elektronik/151031ss04000/led-3mm-s-rouge-160mcd-635nm/dp/2322125
* Ronde 3mm idem mais moins lumineux et plus diffu : http://fr.farnell.com/wurth-elektronik/151031ss06000/led-3mm-s-rouge-20mcd-630nm/dp/2322126
* Ronde 3mm 30 mA (160 mA peak) : http://www.farnell.com/datasheets/1446111.pdf
* Ronde 5mm ultra brillant 50 mA : http://fr.farnell.com/vishay/tlcr5100/led-rouge-5mm-9-deg/dp/4912433
* Je ne trouve pas de led rectangulaire bleu ur farnell. Dommage, car ça peut etre une bonne solution.
* LED bleu rectangulaire 2x5mm 30 mA (peak 100 mA) sur mouser : https://www.mouser.fr/ProductDetail/Lumex/SSL-LX2573SBD-A?qs=%2fha2pyFaduhw2bsKkXb1HhkncBWen5hoywQYC%252b28MJNqoz4RuuS%2fbrJJYO%252bN0Ioo
* http://www.kingbrightusa.com/category.asp?catalog_name=LED&category_name=KC3mm+%28T1%29+Viewing+Angle+20%2B&Page=1
* Sur wikipedia: RGB (611nm, 549nm, 464nm) ; Une led RGB: (625nm, 525nm, 470nm)
* blue: http://www.kingbrightusa.com/images/catalog/SPEC/WP710A10VBC-D.pdf
* green: http://www.kingbrightusa.com/images/catalog/SPEC/WP710A10ZGC-G.pdf
* red: http://www.kingbrightusa.com/images/catalog/SPEC/WP710A10SEC-J3.pdf
* resistor networks: mdp (dual in line) ou sip

=== Des chiffres ===
* Vitesse de rotation angulaire: Va (rad/sec)
* Largeur max d'un "pixel" (definition de l'affichage): LPmax (mm)
* Longeur de l'aiguille (rayon): L (mm)
* Frequence de commande des leds: Fcom (Hz)

LPmax ne devrait pas etre inferieur au diamètre des leds, sans quoi il donnerait a l'oeil un rectangle. 

==== Liens entre la taille de l'aiguille, la resolution de l'affichage, et la vitesse de rotation ====
* LPmax = L * 2 * Pi * Va / Fcom
ou 
* L = LPmax * Fcom / (2 * Pi * Va)
ou
* Fcom = 2 * Pi * L * Va / LPmax

==== Luminosité ====
La luminosité sera plus forte au centre et plus faible à l'exterieur. Plus la définition est grande, plus la luminosité sera faible à l'exterieur du disque. Plus l'aiguille est grande (L), plus la luminosité sera faible à lexterieur du disque. 
La luminosité minimale (LumMin) dépend de L, LPmax et de la luminosité des leds (LumLed).

LumMin = LumLed * LPmax / (2 * Pi * L)

==== Nombre de pixels de l'affichage ====
* NbPix = 2 * Pi * (L / LPmax)²

=== Hypothes chiffrées ===
==== Avec des hypotheses costaud ==== 
* Fcom = 1 MHz (1 million de changement d'affichage par seconde => voir si on peut faire aussi bien avec les calculs)
* Va = 50 * Pi (25 tr/sec => raffraichissement du cinéma, je ne sais pas si c'est suffisant)
* LPmax = 1mm (histoire d'avoir un niveau de détail pas trop dégeu, cela nécéssite des leds de 1mm de diamètre, et beaucoup !)

=> L = 1 * 1000000 / ( 2 * Pi * 50 * Pi) = 1013 mm
=> NbPix = 6.280.000 pixels

Avec une frequence de commande à 1 MHz, une vitesse de rotation de 25 tr/sec et une definition de 1mm, on doit pouvoir utiliser une aiguille de 1m.

==== Pour un prototype de 100mm avec 40 leds espacés par 2,54 mm ====
* Va = 50 * Pi
* LPmax = 2.54mm
* L = 100mm

=> Fcom = 40 kHz
=> NbPix = 9.738 pixel

== Fabrication d'un prototype ==
Je réalise un prototype de 40 LEDs de 3mm. la barre de LED mesure donc 120mm de long. Les 40 LEDs sont pilotés par 5 74LS595. Ce sont des vérous série avec sortie de type "open collector" pouvant dissiper absorber de plus grand courant. 

Les LEDs utilisés peuvent etre alimenté avec 30 mA et jusqu'à plus de 100 mA en pic 1/10 du temps. 

Le prototype permettra de tester differents courants dans les LEDs grace à 2 transistors MOSFET canal P permettant de selectionner 3 courants different dans les LEDs en selectionnant 3 resistances possibles en série avec les LEDs.

Le PCB est gravé avec la CNC du coin.
[[File:pov_display_proto_pcb1.JPG|990px]]
[[File:pov_display_proto_pcb2.JPG|990px]]

Montage typique d'un régulateur de tension LM78xx :
[[File:LM78xx_typical_application_circuit.png|990px]]

Montage typique d'un capteur à effet Hall US1881 :
[[File:US1881_typical_app_circuit.png|990px]]

== Programation d'un atmel ==

=== Grandes lignes ===
* Frequence d'horloge la plus haute possible, probablement 16 MHz
* Un compteur 24 bits (Compteur 16 bits et 8 bits en cascade) compte le nombre de cycle d'horloge. => Le compteur peut compter 16.777.216 d'évenements (2^24). A 16 MHz le compteur overflow quasiment 1 fois par seconde. Le compteur sera chargé de mesurer le nombre de cycle d'horloge survenant à chaque tour.
* Le capteur de position (à effet hall) provoque une interruption externe à chaque tour complet. L'interruption sauvegarde la valeur du compteur, et reset le compteur. La valeur sauvegardé du compteur represente le nombre de cycle d'horloge du tour précédent, que l'on utilisera pour estimer le nombre de cycle d'horloge du tour suivant. Le nombre de cycle d'horloge par tour ne devrait pas varier beaucoup entre 2 tours.
* On configure un troisième compteur pour generer une interruption pour chaque subdivision d'un tour, ou mieux on utilise le meme compteur, à voir (mieux car le compteur 8 bit sera peut etre trop juste, et cela oblige à compter le nombre d'overflow, ce qui augmente le nombre de calcul et diminue la résolution de l'afficheur). Typiquement, un tour est divisé en un nombre de position angulaire affichable, chaque position est subdivisé si possible pour permettre une modulation du courant dans les leds : il sera possible d'afficher par intermitence une position.
* Il faut garder à l'esprit qu'une interruption nécéssite minimum 8 cycles d'horloge de "context switching" (4 au debut et 4 à la fin). L'interruption sera chargé de lire et pousser 8 bits de données dans chaque registre à décallage, puis de verouiller les registres. Cela représente 17 cycles d'horloge (2 cycles par bit de donnée, plus le vérrouillage), il faut également lire en mémoire les octets à pousser bit par bit, probablement 4 cycles d'horloge par octet. L'interruption doit également remettre à 0 le compteur de subdivision, intégrer la logique de comptage des subdivision, et de modulation de courant. Par sécurité, 100 cycles d'horloge par subdivision parait raisonable. On peut donc estimer la durée de la subdivision minimale à 100 cycles d'horloge. L'afficheur pourra donc disposer au maximum de 160.OOO (16.000.000/100) subdivisions. Cela permet par exemple pour un afficheur disposant de 500 positions (500 pixels radiaux, répartits sur la circonférence) de disposer au maximum de 320 luminosités différente par pixel. On pourra donc envisager de faire du RVB en utilisant 3 barres de led de couleur différentes. Il faudra mesurer le nombre de cycle d'horloge de l'interruption pour pouvoir estimer le nombre de subdivision possible.
* Le chargement des images en mémoire et leur animation pourront etre geré par le code principal. Attention, si le nombre de subdivision est trop proche du maximum, alors le micro controleur sera toujours en interruption et ne pourra pas traiter rapidement la boucle de code principal.

== Découpage au laser des pièces en bois ==
=== Todo ===
* Vérifier le diamètre des vis de serrage du stator (8mm ? plus ?).
* Vérifier le diamètre des vis de serrage du rotor (6mm ? moins ?).
* Vérifier le diamètre externe des roulements (22mm ?).

* Ajuster tous les diamètres
* Vérifier les mesures

[[Catégorie:Créer_avec_des_atomes]]
[[Catégorie:Réalisations]]