Afficheur à persistence rétinienne

Le principe

Une ligne de quelques leds est commandée par un PIC.
Chaque led voit son statut (éteint ou allumé) actualisé toutes les 0,3ms. En faisant bouger de droite à gauche le montage ou en le fixant à un moteur pour le faire tourner, on voit apparaître les lettres. Ceci grâce à la persistance rétinienne, d'environ 50ms : le statut d'une led est actualisé toutes 0,3ms, donc la totalité d'un mot toutes les (60*0,3=)18ms, donc on voit le mot en entier.
Voici un schéma (pour les lettres N et O) qui représente à la fois ce que l'on voit et l'état des leds en fonction du temps :

Le montage

L'électronique

Rien de bien compliquer, on relie 8 sortie du PIC à chacune une résistance et une led. Il suffira donc que le PIC mette la sortie à l'état logique 1 pour que la leds s'allume et 0 pour qu'elle s'éteigne.
Un PIC 16F628A est ici utilisé mais vous pouvez prendre n'importe quel PIC tant qu'il a 8 sorties.
J'ai pris pour mon montage 8 leds rouges Haute Luminosité de 3mm de diamètre, les résistances sont chacune de 150ohms. Des leds standard peuvent aussi bien convenir.
Maintenant à vos fers !

La mécanique

Le montage peut fonctionner 'à la main', en le bougeant de droite à gauche, ou vous pouvez le monter sur un moteur.
La mise en place sur un moteur circulaire est le plus simple. Il vous faut équilibrer un maximum le moteur et le fixer sur un support massif, lourd afin de limiter au maximum le 'bruit', les mouvements indésirés de tout le montage.
Prenez aussi un rayon le plus grand possible pour pouvoir voir le 'message' en entier, sans devoir tourner la tête.
Si vous voulez une image 'fixe', qui ne tourne pas en permanence, vous devrez tatonner en changeant légèrement la vitesse de rotation du moteur et la vitesse de 'clignotement des leds'.

La programmation

Le programme est en C, pour compilation avec Hi-Tech C Compiler.

On peut faire l'analogie du premier schéma par un tableau de 0 et de 1 à deux dimensions : 8 colonnes pour chacune des 8 leds et les lignes pour le temps. Chaque case du tableau auras donc comme valeur 0 pour une led éteinte et 1 pour une led allumée.

Une dimension du tableau seras donc toujours composée de 8 fois 0 ou 1. Cela correspond à un octet en affichage binaire, en C ces deux écritures sont équivalentes : char variable = 170; et char variable = 0b10101010;.
On peut donc remplacer ce tableau à deux dimensions par un tableau à une seule dimension mais écrit en binaire où un bit de l'octet correspond au statut d'une led. Par exemple, avec 11110000, les 4 premières leds seront allumées et les 4 dernières éteintes.

On configure les ports B en sortie (TRISB = 0b00000000;).
Puis on utilise un timer (TMR0) pour passer d'une ligne à la suivante du tableau toutes les 0,3ms, et ainsi faire 'clignoter les leds'.

// Pour PIC 16F628A

#include <pic.h>

__CONFIG(0x3F10);

#define led1 RB0
#define led2 RB1
#define led3 RB2
#define led4 RB3
#define led5 RB4
#define led6 RB5
#define led7 RB6
#define led8 RB7

char extract_bit(char octet, char nb)
{
	octet = octet >> nb;
	octet = octet << 7;
	
	if(octet > 0)
	{return 1;}
	
	return 0;
}

void main(void)
{
char temps = 0, barre = 0;

const char taille = 20;
const char phrase[20] = 
{
0b11111111,
0b11000000,
0b01100000,
0b00110000,
0b00011100,
0b00000110,
0b00000011,
0b11111111,
0b00000000,
0b00111100,
0b00111100,
0b01100110,
0b11000011,
0b10000001,
0b10000001,
0b10000001,
0b11000011,
0b01100110,
0b00111100,
0b00000000
};

CMCON = 0x07;
OPTION = 0b11000000;
INTCON = 0b00000000;
TRISB = 0b00000000;
PORTB = 0b00000000;
TMR0 = 0;

for(;;)
{
	if(TMR0>=250) // 0.1ms
		{TMR0 = 0;temps++;}

	if(temps == 3) // 0.3ms
	{
		barre++;
		temps = 0;
		if(barre>taille)
		{barre=0;}
		
		// Actualisation de l'état des leds
		
		led1 = extract_bit(phrase[barre], 0);
		led2 = extract_bit(phrase[barre], 1);
		led3 = extract_bit(phrase[barre], 2);
		led4 = extract_bit(phrase[barre], 3);
		led5 = extract_bit(phrase[barre], 4);
		led6 = extract_bit(phrase[barre], 5);
		led7 = extract_bit(phrase[barre], 6);
		led8 = extract_bit(phrase[barre], 7);
		
	}

}

}

Vous pouvez facilement convertir des lettres ou des formes en 'tableau binaire' à l'aide de ce fichier excel.
Voilà, votre afficheur à persistance rétinienne est terminé. Vous pouvez maintenant facilement le transformer pour qu'il affiche ce que vous voulez ou même en faire une horloge.