www.gecif.net  

Vous êtes ici : Gecif.net > Sciences de l'Ingénieur > ISIS Proteus 7 > Les afficheurs LCD

Les afficheurs LCD dans ISIS Proteus

Cette page web donne un grand nombre d'informations, d'explications et d'applications pour utiliser, câbler, programmer ou piloter les afficheus LCD alphanumériques disponibles dans le logiciel de simulation électronique ISIS Proteus 7.8.

Sommaire de cette page

Les bases des afficheurs LCD

Programmation d'un afficheur LCD pas à pas en mode 8 bits

Programmation d'un afficheur LCD pas à pas en mode 4 bits

Automatisation de la séquence de commande en mode 8 bits avec un script EasyHDL

Automatisation de la séquence de commande en mode 4 bits avec un script EasyHDL

Pilotage interactif de l'afficheur en fonction des actions de l'utilisateur

Quelques instructions bien pratiques

Détail du jeu d'instructions complet des afficheurs LCD

Caractères pré-définis dans la CGROM et table ASCII

Définition et affichage de nouveaux caractères

Définition et affichage de 8 caractères accentués en mode 4 bits

Affichage d'un texte accentué de 160 caractères sur l'afficheur LCD MDLS40466

Définition de 14 caractères accentués dans une matrice binaire 8x8

Conclusion

 

 

Retour au sommaire

 

Les bases des afficheurs LCD

LCD est l'acronyme de Liquid Crystal Display (en anglais), ce qui signifie en français écran à cristaux liquides.

Par opposition à un afficheur à LED (comme les afficheurs 7 segments par exemple) où il suffit d'allumer une LED pour créer des caractères, l'affichage d'un message textuel sur un afficheur LCD n'est jamais direct. Il faut envoyer une série de commandes à l'afficheur, qui les interprète et qui réalise en fonction certaines actions dont l'affichage des caractères.

On distingue 2 types de commandes : les instructions (pour configurer l'afficheur) et les données (pour afficher un caractère à partir de son code ASCII).

Le protocole d'envoi des commandes à l'afficheur est très précis et doit être respecté si on veut que la réaction de l'afficheur soit le résultat attendu : afficher un mesage.

Un afficheur LCD contient :

 

RS permet de préciser si la commande présente sur les entrées D0 à D7 est une instruction ou une donnée, et E permet de valider cette commande.

Une commande est une valeur numérique présente sur les entrées D0 à D7 et validée par une impulsion sur E.

Le protocole d'envoie des commandes précise la liste des instructions à envoyer pour configurer l'afficheur (RS=0) suivie des données à envoyer (RS=1).

L'entrée RW sera mise à zéro (connectée à la masse) et sera inutilisée ici.

Les 3 entrées d'alimentation VSS VDD et VEE n'ayant pas besoin d'être obligatoirement alimentées dans ISIS Proteus, elles resteront non connectées dans les exemples ci-dessous.

La seule question qui nous intéresse ici est "Que faut-il mettre sur les entrées de données et quel protocole faut-il utiliser pour programmer l'afficheur ?".

ISIS Proteus 7.8 possède 8 afficheurs LCD, ayant chacun un taille particulière mais utilisant tous le même protocole de commande :

Liste des 8 afficheurs LCD alphanumériques dans Proteus
Nombre de lignes
Nombre de caractères par ligne
Référence de l'afficheur
1
16
LM020L
2
16
LM016L
20
LM032L
32
LM017L
40
LM018L
4
16
LM041L
20
LM044L
40
MDLS40466

Remarque : l'afficheur MDLS40466 (4x40) possède 2 contrôleurs internes (entrées de validation E1 et E2) : un pour les lignes 1 et 2, l'autre pour les lignes 3 et 4. Il est l'équivalent de deux afficheurs LM018L (2x40) dans le même boîtier.

Pour connaître l'ensemble des afficheurs LCD disponibles dans Proteus, recherchez le mot clé lcd dans la catégorie Optoelectronics.

Retour au sommaire

 

Programmation d'un afficheur LCD pas à pas en mode 8 bits

En mode 8 bits les 8 entrées D0 à D7 sont câblées et les commandes sont sur 8 bits (1 octet).

Il faut envoyer à l'afficheur 3 octets d'initialisation afin de le configurer avant d'envoyer les caractères à afficher.

Envoi des instructions de configuration
Envoi des données pour afficher les caractères
RS=0
RS=1
$38
$0E
$06
on envoie le code ASCII de chaque caractère

Rôle de chacun des 3 octets de configuration :

$38 : configure l'afficher en mode 8 bits avec 2 lignes

$0E : configure le curseur visible (à remplacer par $0C si on veut le curseur invisible ou par $0F pour un curseur clignotant)

$06 : configure le déplacement du curseur vers la droite

Le fichier suivant permet de tester dans ISIS Proteus le pilotage manuel de l'afficheur LCD LM016L en mode 8 bits :


Télécharger le fichier ISIS Proteus

Retour au sommaire

 

Programmation d'un afficheur LCD pas à pas en mode 4 bits

En mode 4 bits seules les 4 entrées D4 à D7 sont câblées et les commandes sont sur 4 bits (1 quartet).

En mode 4 bits les instructions comme les codes ASCII des caractères sont envoyés en 2 étapes : le quartet de poids fort en premier, puis ensuite le quartet de poids faible.

Pour configurer l'afficheur en 4 bits il faut commencer par lui envoyer les 4 quartets $3 $3 $3 et $2.

Envoi des instructions de configuration
Envoi des données pour afficher les caractères
RS=0
RS=1
$3
$3
$3
$2
$0
$E
$0
$6
on envoie le code ASCII de chaque caractère en 2 étapes

L'instruction $0E affichant le curseur est envoyée ici en 2 quartets : $0 puis $E

L'instruction $06 configurant le déplacement du curseur vers la droite est envoyée ici en 2 quartets : $0 puis $6

Une fois l'afficheur configuré en mode 4 bits, les codes ASCII des caractères à afficher sont envoyés en 2 étapes : le quartet de poids fort en premier, puis ensuite le quartet de poids faible.

Le fichier suivant permet de tester dans ISIS Proteus le pilotage manuel de l'afficheur LCD LM016L en mode 4 bits :


Télécharger le fichier ISIS Proteus

Retour au sommaire

 

Automatisation de la séquence de commande en mode 8 bits avec un script EasyHDL

Pour envoyer automatiquement la séquence d'octets à l'afficheur plusieurs solutions sont possibles. On peut concevoir de toutes pièces un séquenceur (à base de bascules par exemple), on peut programmer un PLD ou un PIC, mais si le seul but est de voir un message affiché dans un système simplement simulé sans se soucier de l'aspect matériel on peut écrire un petit script en EasyHDL qui délivrera les différentes commandes à destination de l'afficheur.

L'exemple suivant contient un script optimisé pour afficher facilement un message simple sur un afficheur LCD en mode 8 bits :


Télécharger le fichier ISIS Proteus

Voici le script EasyHDL permettant d'afficher le message "Vive Gecif.net !" sur un afficheur LCD configuré en 8 bits : 

/////////////////////////////////////////////////////////////////////////////////////////////
// Script EasyHDL réalisé par Jean-Christophe MICHEL
// www.gecif.net
// Octobre 2014
/////////////////////////////////////////////////////////////////////////////////////////////

*SCRIPT PROGRAM GECIF
PIN Q[0..7],Q8,Q9
FLOAT temporisation=0.4m
INT i
STRING s

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des instructions à l'afficheur LM016L :
/////////////////////////////////////////////////////////////////////////////////////////////

Q[0..7]=$38 // configure l'afficheur en 8 bits, 2 lignes, 5x8
GOSUB envoyer_instruction
Q[0..7]=$0C // configure l'affichage avec le curseur invisible
GOSUB envoyer_instruction
Q[0..7]=$06 // configure le déplacement du curseur vers la droite
GOSUB envoyer_instruction

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des données  à l'afficheur LM016L :
/////////////////////////////////////////////////////////////////////////////////////////////

s="Vive Gecif.net !"

FOR i = 1 TO LEN(s)
 Q[0..7]=ASC(s[i])
 GOSUB envoyer_donnee
NEXT i

END

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_donnee :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_donnee" met RS à 1 puis appelle la fonction "valider"
envoyer_donnee:
 SLEEP FOR temporisation
 Q8=1
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_instruction :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_instruction" met RS à 0 puis appelle la fonction "valider"
envoyer_instruction:
 SLEEP FOR temporisation
 Q8=0
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction valider :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "valider" envoie une impulsion sur E, pour valider une instruction ou une donnée
valider:
 Q9=1
 SLEEP FOR temporisation
 Q9=0
 SLEEP FOR temporisation
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fin du script
/////////////////////////////////////////////////////////////////////////////////////////////

*ENDSCRIPT

Retour au sommaire

 

Automatisation de la séquence de commande en mode 4 bits avec un script EasyHDL

En mode 4 bits le script EasyHDL doit couper les codes ASCII des caractères en deux afin de séparer l'envoi du quartet de poids fort et du quartet de poids faible. L'exemple suivant montre comment le faire facilement :


Télécharger le fichier ISIS Proteus

Voici le script EasyHDL permettant d'afficher le message "Vive Gecif.net !" sur un afficheur LCD configuré en 4 bits :


/////////////////////////////////////////////////////////////////////////////////////////////
// Script EasyHDL réalisé par Jean-Christophe MICHEL
// www.gecif.net
// Octobre 2014
/////////////////////////////////////////////////////////////////////////////////////////////

*SCRIPT PROGRAM GECIF
PIN Q[0..3],Q4,Q5
FLOAT temporisation=0.4m
INT i,n
STRING s

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des instructions à l'afficheur LM016L :
/////////////////////////////////////////////////////////////////////////////////////////////

n=$33 // configure l'afficheur en 4 bits, 2 lignes, 5x8
GOSUB envoyer_instruction
n=$32 
GOSUB envoyer_instruction
n=$0C // configure l'affichage avec le curseur invisible
GOSUB envoyer_instruction
n=$06 // configure le déplacement du curseur vers la droite
GOSUB envoyer_instruction


/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des données  à l'afficheur LM016L :
/////////////////////////////////////////////////////////////////////////////////////////////

s="Vive Gecif.net !"

FOR i = 1 TO LEN(s)
 n=ASC(s[i])
 GOSUB envoyer_donnee
NEXT i

END

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_donnee :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_donnee" met RS à 1 puis envoie l'octet n en 2 étapes
envoyer_donnee:
 Q4=1
 SLEEP FOR temporisation
 Q[0..3]=(n>>4)
 SLEEP FOR temporisation
 GOSUB valider
 Q[0..3]=n
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_instruction :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_instruction" met RS à 0 puis envoie l'octet n en 2 étapes
envoyer_instruction:
 Q4=0
 SLEEP FOR temporisation
 Q[0..3]=(n>>4)
 SLEEP FOR temporisation
 GOSUB valider
 Q[0..3]=n
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction valider :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "valider" envoie une impulsion sur E, pour valider une instruction ou une donnée
valider:
 Q5=1
 SLEEP FOR temporisation
 Q5=0
 SLEEP FOR temporisation
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fin du script
/////////////////////////////////////////////////////////////////////////////////////////////

*ENDSCRIPT

Retour au sommaire

 

Pilotage interactif de l'afficheur en fonction des actions de l'utilisateur

L'exemple suivant montre comment prendre en compte dans le script EasyHDL les états logiques en entrée du circuit de commande afin de piloter l'afficheur en fonction :


Télécharger le fichier ISIS Proteus

Retour au sommaire

 

Quelques instructions bien pratiques

Voici les instructions les plus utilisées pour chacun des afficheurs LCD utilisables dans ISIS Proteus 7.8 :

Instructions valables pour tous les afficheurs LCD
Action à réaliser
Valeur de l'instruction (à envoyer avec RS=0)
Curseur invisible
$0C
Curseur visible en fixe
$0E
Curseur visible clignotant
$0F
Déplacement du curseur vers la droite
$06
Effacer l'écran
$01
Bascule l'afficheur en mode 4 bits
$33 $32
Bascule l'afficheur en mode 8 bits
$33 $33
Configure l'afficheur en multilignes en 4 bits
$28
Configure l'afficheur en multilignes en 8 bits
$38

 

Séquence d'initialisation complète pour configurer un afficheur LCD en mode 8 bits
Action à réaliser
Valeur de l'instruction (à envoyer avec RS=0)
Bascule l'afficheur en mode 8 bits
$33 $33
Configure l'afficheur en multilignes en 8 bits
$38
Affichage du curseur
$0E
Déplacement du curseur vers la droite
$06
Ensuite on peut envoyer les codes ASCII des caractères à afficher octet par octet

 

Séquence d'initialisation complète pour configurer un afficheur LCD en mode 4 bits
Action à réaliser
Valeur de l'instruction (à envoyer avec RS=0)
Bascule l'afficheur en mode 4 bits
$33 $32
Configure l'afficheur en multilignes en 4 bits
$28
Affichage du curseur
$0E
Déplacement du curseur vers la droite
$06
Ensuite on peut envoyer les codes ASCII des caractères à afficher quartet par quartet (avec le poids fort en pemier)

Changement de ligne sur les afficheurs possédant 2 lignes :

Instructions valables pour les afficheurs LM016L (2x16) LM032L (2x20) LM017L (2x32) et LM018L (2x40)
Action à réaliser
Valeur de l'instruction (à envoyer avec RS=0)
Déplacer le curseur au début de la ligne 1
$80
Déplacer le curseur au début de la ligne 2
$C0

Changement de ligne sur les afficheurs possédant 4 lignes :

Instructions valables pour l'afficheur LM041L (4x16)
Action à réaliser
Valeur de l'instruction (à envoyer avec RS=0)
Déplacer le curseur au début de la ligne 1
$80
Déplacer le curseur au début de la ligne 2
$C0
Déplacer le curseur au début de la ligne 3
$90
Déplacer le curseur au début de la ligne 4
$D0

 

Instructions valables pour l'afficheur LM044L (4x20)
Action à réaliser
Valeur de l'instruction (à envoyer avec RS=0)
Déplacer le curseur au début de la ligne 1
$80
Déplacer le curseur au début de la ligne 2
$C0
Déplacer le curseur au début de la ligne 3
$94
Déplacer le curseur au début de la ligne 4
$D4

Remarque : on retrouve les adresses de chacune des lignes dans les Propriétés en texte de chaque afficheur LCD. Exemple pour le LM044L :

Retour au sommaire

 

Détail du jeu d'instructions des afficheurs LCD

Comme tous les périphériques les afficheurs LCD possèdent une interface logicielle permettant de leur envoyer des instructions en respectant un protocole précis. Voici la signification exacte des commandes reçus par les afficheurs :

Jeu d'instructions détaillé valable pour tous les afficheurs LCD
Valeur de l'instruction en binaire
Rôle de cette instruction
Valeur en
hexadécimal
D7
D6
D5
D4
D3
D2
D1
D0
0
0
0
0
0
0
0
1
efface l'écran
$01
0
0
0
0
0
0
1
0
replace le curseur dans la position d'origine
$02
0
0
0
0
0
1
B
A

sens de déplacement du curseur : vers la gauche si B=0 et vers la droite si B=1

si A=1 l'affichage accompagne le curseur dans son déplacement

$04 à $07
0
0
0
0
1
C
B
A
active ou désactive l'affichage (C), le curseur (B) et le clignotement du curseur (A)
$08 à $0F
0
0
0
1
D
C
0
0
déplace le curseur (D=1) ou l'affichage (D=0) d'une position vers la gauche (C=1) ou vers la droite (C=0)
$10 à $1F
0
0
1
E
D
C
0
0

définit la taille de l'interface : mode 4 bits si E=0 et mode 8 bits si E=1

le nombre de lignes : 1 ligne si D=0, 2 ou 4 lignes (multiligne) si D=1

et la taille de la police : caractères 5x7 si C=0 et caractères 5x10 si C=1

$20 à $3F
0
1
F
E
D
C
B
A
définit l'adresse de la CG RAM : les données de la CG RAM sont envoyées après cette commande
$40 à $7F
1
G
F
E
D
C
B
A
définit l'adresse de la DD RAM : les données de la DD RAM sont envoyées après cette commande
$80 à $FF

La DDRAM est la traduction de Display Data RAM. C'est une mémoire d'affichage dont l'adresse contient le caractère affiché a l'écran à une certaine position. En modifiant l'adresse de la DDRAM on précise l'emplacement (ligne et colonne) ou on veut afficher le prochain caractère sur l'afficheur.

La CGRAM est la traduction de Charactere Generator RAM. Comme sont nom l'indique, il s'agit d'un générateur de caractère, ainsi il sera possible de créer ses propres symboles, contrairement à la CGROM qui contiens les caractères pré-définis.

Retour au sommaire

 

Caractères pré-définis dans la CGROM et table ASCII

Voici l'ensemble des caractères que peut afficher par défaut l'afficheur LCD. On peut constater que les codes ASCII vont de $20 à $FF et qu'il existe très peu de caractères accentués :

Et voici en clair les 6 premières colonnes (code ASCII $20 à $7F) contenant les caractères standards :

Table ASCII
caractère
code ASCII en décimal
code ASCII en hexadécimal
espace
32
20
!
33
21
"
34
22
#
35
23
$
36
24
%
37
25
&
38
26
'
39
27
(
40
28
)
41
29
*
42
2A
+
43
2B
,
44
2C
-
45
2D
.
46
2E
/
47
2F
0
48
30
1
49
31
2
50
32
3
51
33
4
52
34
5
53
35
6
54
36
7
55
37
8
56
38
9
57
39
:
58
3A
;
59
3B
<
60
3C
=
61
3D
>
62
3E
?
63
3F
@
64
40
A
65
41
B
66
42
C
67
43
D
68
44
E
69
45
F
70
46
G
71
47
H
72
48
I
73
49
J
74
4A
K
75
4B
L
76
4C
M
77
4D
N
78
4E
O
79
4F
P
80
50
Q
81
51
R
82
52
S
83
53
T
84
54
U
85
55
V
86
56
W
87
57
X
88
58
Y
89
59
Z
90
5A
[
91
5B
\
92
5C
]
93
5D
^
94
5E
_
95
5F
`
96
60
a
97
61
b
98
62
c
99
63
d
100
64
e
101
65
f
102
66
g
103
67
h
104
68
i
105
69
j
106
6A
k
107
6B
l
108
6C
m
109
6D
n
110
6E
o
111
6F
p
112
70
q
113
71
r
114
72
s
115
73
t
116
74
u
117
75
v
118
76
w
119
77
x
120
78
y
121
79
z
122
7A
{
123
7B
|
124
7C
}
125
7D
flèche droite
126
7E
flèche gauche
127
7F

 

Retour au sommaire

 

Définition et affichage de nouveaux caractères

Les afficheurs LCD permettent de définir pixel par pixel de nouveaux caractères.

Un caractère est défini par 8 octets décrivant une matrice 8x8 de 64 pixels (comme sur la table ci-dessus).

On envoie les 8 octets comme 8 données précédées chacune par l'instruction $40 à $47 pour le caractère 0, $48 à $4F pour le caractère 1, etc.

Les 8 nouveaux caractères définits auront pour code ASCII $0 à $7 pour l'afficheur qui les lira dans la CGRAM à partir de l'adresse $40 et non dans la CGROM qui contient les caractères pré-définis de code ASCII $20 à $FF.

Adresse de chacun des 8 caractères définis par l'utilisateur
Code ASCII du caractère
Adresse dans la CGRAM
$0
$40 à $47
$1
$48 à $4F
$2
$50 à $57
$3
$58 à $5F
$4
$60 à $67
$5
$68 à $6F
$6
$70 à $77
$7
$78 à $7F

La CGRAM occupe les adresses $40 à $7F. La DDRAM commence à l'adresse suivante $80. Entre $40 et $7F on ne peut enregistrer que 8 nouveaux caractères personnalisés.

L'exemple suivant motre comment définir et afficher 2 nouveaux caractères : é et è


Télécharger le fichier ISIS Proteus

 

Retour au sommaire

 

Définition et affichage de 8 caractères accentués en mode 4 bits

Cet exemple donne un script EasyHDL avec la définition des 8 caractères accentués suivants, bien pratiques et absents de la CGROM :

Affichage de 8 nouveaux caractères
Code ASCII du caractère
Caractère
$0
é
$1
è
$2
ê
$3
à
$4
ù
$5
û
$6
î
$7
ç

Il est désormais possible d'afficher sur un afficheur LCD une phrase comme par exemple "Une île d'été pour août où ça va très bien doit être à même de capter Gecif" utilisant les 8 nouveaux caractères accentués :


Télécharger le fichier ISIS Proteus

Et voici le script EasyHDL définissant les 8 caractères accentués. Chaque nouveau caractère est défini par une matrice de 8x8 pixels décrite par 8 octets dans un bloc du style :

DATA $04,$08,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$40 TO $47
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

L'instruction DATA permet de définir une structure de donnée composée de 8 octets, puis l'instruction READ lit cette structure de donnée octet par octet en affectant à la variable n chacun des 8 octets pour les 8 itérations de la boucle FOR qui enregistre les 8 octets de chaque caractère dans la CGRAM (de l'adresse $40 à l'adresse $7F, avec 8 adresses par caractère) :

/////////////////////////////////////////////////////////////////////////////////////////////
// Script EasyHDL réalisé par Jean-Christophe MICHEL
// www.gecif.net
// Octobre 2014
/////////////////////////////////////////////////////////////////////////////////////////////

*SCRIPT PROGRAM GECIF
PIN Q[0..3],Q4,Q5
FLOAT temporisation=0.4m
INT i,n,adresse
STRING s

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des instructions à l'afficheur :
/////////////////////////////////////////////////////////////////////////////////////////////

n=$33 // configure l'afficheur en 4 bits, 2 lignes, 5x8
GOSUB envoyer_instruction
n=$32 
GOSUB envoyer_instruction
n=$0C // configure l'affichage avec le curseur invisible
GOSUB envoyer_instruction
n=$06 // configure le déplacement du curseur vers la droite
GOSUB envoyer_instruction
n=$28 // configure l'afficheur en multiligne en mode 4 bits
GOSUB envoyer_instruction

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère é en envoyant 8 octets dans la CGRAM de l'adresse $40 à $47 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$08,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$40 TO $47
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère è en envoyant 8 octets dans la CGRAM de l'adresse $48 à $4F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$02,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$48 TO $4F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère ê en envoyant 8 octets dans la CGRAM de l'adresse $50 à $57 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$50 TO $57
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère à en envoyant 8 octets dans la CGRAM de l'adresse $58 à $5F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$02,$0E,$01,$0F,$11,$0F,$00
FOR adresse=$58 TO $5F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère ù en envoyant 8 octets dans la CGRAM de l'adresse $60 à $67 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$02,$11,$11,$11,$13,$0D,$00
FOR adresse=$60 TO $67
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère û en envoyant 8 octets dans la CGRAM de l'adresse $68 à $6F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$11,$11,$11,$13,$0D,$00
FOR adresse=$68 TO $6F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère î en envoyant 8 octets dans la CGRAM de l'adresse $70 à $77 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$0C,$04,$04,$04,$0E,$00
FOR adresse=$70 TO $77
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère ç en envoyant 8 octets dans la CGRAM de l'adresse $78 à $7F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $0E,$10,$10,$11,$0E,$04,$0C,$00
FOR adresse=$78 TO $7F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des données  à l'afficheur :
/////////////////////////////////////////////////////////////////////////////////////////////

// Le caractère de code ASCII $0 est désormais é pour l'afficheur
// Le caractère de code ASCII $1 est désormais è pour l'afficheur
// Le caractère de code ASCII $2 est désormais ê pour l'afficheur
// Le caractère de code ASCII $3 est désormais à pour l'afficheur
// Le caractère de code ASCII $4 est désormais ù pour l'afficheur
// Le caractère de code ASCII $5 est désormais û pour l'afficheur
// Le caractère de code ASCII $6 est désormais î pour l'afficheur
// Le caractère de code ASCII $7 est désormais ç pour l'afficheur

// écrit sur la ligne 1 :
n=$80
GOSUB envoyer_instruction

s="Une "
GOSUB afficher_chaine
s=CHR(6)+"le d'"
GOSUB afficher_chaine
// Pour le caractère de code ASCII 0 il faut directement envoyer la donnée $00 sans
// mettre de caractère nul dans la chaîne s
n=0
GOSUB envoyer_donnee
s="t"
GOSUB afficher_chaine
n=0
GOSUB envoyer_donnee
s=" pour ao"
GOSUB afficher_chaine
s=CHR(5)+"t o"
GOSUB afficher_chaine
s=CHR(4)+" "
GOSUB afficher_chaine
s=CHR(7)+"a va tr"
GOSUB afficher_chaine
s=CHR(1)+"s"
GOSUB afficher_chaine

// écrit sur la ligne 2 :
n=$C0
GOSUB envoyer_instruction

s="bien doit "
GOSUB afficher_chaine
s=CHR(2)+"tre "
GOSUB afficher_chaine
s=CHR(3)+" m"
GOSUB afficher_chaine
s=CHR(2)+"me de capter Gecif !"
GOSUB afficher_chaine

END

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction afficher_chaine :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "afficher_chaine" affiche la chaine s
afficher_chaine:
FOR i = 1 TO LEN(s)
 n=ASC(s[i])
 GOSUB envoyer_donnee
NEXT i
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_donnee :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_donnee" met RS à 1 puis envoie l'octet n en 2 étapes
envoyer_donnee:
 Q4=1
 SLEEP FOR temporisation
 Q[0..3]=(n>>4)
 SLEEP FOR temporisation
 GOSUB valider
 Q[0..3]=n
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_instruction :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_instruction" met RS à 0 puis envoie l'octet n en 2 étapes
envoyer_instruction:
 Q4=0
 SLEEP FOR temporisation
 Q[0..3]=(n>>4)
 SLEEP FOR temporisation
 GOSUB valider
 Q[0..3]=n
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction valider :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "valider" envoie une impulsion sur E, pour valider une instruction ou une donnée
valider:
 Q5=1
 SLEEP FOR temporisation
 Q5=0
 SLEEP FOR temporisation
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fin du script
/////////////////////////////////////////////////////////////////////////////////////////////

*ENDSCRIPT

Retour au sommaire

 

Affichage d'un texte accentué de 160 caractères sur l'afficheur LCD MDLS40466

L'afficheur LCD MDLS40466 a une taille de 4 lignes de 40 caractères chacune, et possède la particularité d'utiliser 2 contrôleurs distincts :

L'entrée RS et les entrées de données D0 à D7 sont communes aux deux contrôleurs :


Afficheur MDLS40466 avec ses 2 entrées de validation E1 et E2

Avant d'utiliser un afficheur MDLS40466 dans ISIS Proteus 7.8 il faut commencer par corriger les adresses des lignes 2 et 4 dans les Propriétés en texte de l'afficheur en modifiant les lignes ROW2 et ROW4 (il faut remplacer A8-CF par C0-E7) :

Ensuite, voici le protocole pour écrire sur chacune des 4 lignes :

Instructions valables pour l'afficheur MDLS40466 (4x40)
Action à réaliser
Valeur de l'instruction
(à envoyer avec RS=0)
Entrée de validation
des données et des instructions
Déplacer le curseur au début de la ligne 1
$80
E1
Déplacer le curseur au début de la ligne 2
$C0
E1
Déplacer le curseur au début de la ligne 3
$80
E2
Déplacer le curseur au début de la ligne 4
$C0
E2

L'exemple suivant montre comment afficher un texte de 160 caractères accentués sur les 4 lignes de l'afficheur LCD MDLS40466 câblé en 4 bits :


Télécharger le fichier ISIS Proteus

Et voici le script EasyHDL :


/////////////////////////////////////////////////////////////////////////////////////////////
// Affichage de caractères accentués sur l'afficheur MDLS40466 possédant 2 contrôleurs
// Script EasyHDL réalisé par Jean-Christophe MICHEL
// www.gecif.net
// Octobre 2014
/////////////////////////////////////////////////////////////////////////////////////////////

*SCRIPT PROGRAM GECIF
PIN Q[0..3],Q4,Q5,Q6
FLOAT temporisation=0.4m
INT i,n,adresse,controleur
STRING s

// La variable controleur indique quelle entrée de validation il faut utiliser :
//   - si controleur=1 alors on valide toutes les commandes (instructions et données) sur E1
//   - si controleur=2 alors on valide toutes les commandes (instructions et données) sur E2
//   - si controleur=3 alors on envoie les commandes sur les 2 contrôleurs : E1 et E2
// C'est la fonction "valider" (en bas du script) qui détermine l'entrée de validation à utiliser

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des instructions aux 2 controleurs de l'afficheur :
/////////////////////////////////////////////////////////////////////////////////////////////

controleur=3
n=$33 // configure l'afficheur en 4 bits, 2 lignes, 5x8
GOSUB envoyer_instruction
n=$32 
GOSUB envoyer_instruction
n=$0C // configure l'affichage avec le curseur invisible
GOSUB envoyer_instruction
n=$06 // configure le déplacement du curseur vers la droite
GOSUB envoyer_instruction
n=$28 // configure l'afficheur en multiligne en mode 4 bits
GOSUB envoyer_instruction

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère é en envoyant 8 octets dans la CGRAM de l'adresse $40 à $47 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$08,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$40 TO $47
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère è en envoyant 8 octets dans la CGRAM de l'adresse $48 à $4F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$02,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$48 TO $4F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère ê en envoyant 8 octets dans la CGRAM de l'adresse $50 à $57 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$0E,$11,$1F,$10,$0E,$00
FOR adresse=$50 TO $57
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère à en envoyant 8 octets dans la CGRAM de l'adresse $58 à $5F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$02,$0E,$01,$0F,$11,$0F,$00
FOR adresse=$58 TO $5F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère ù en envoyant 8 octets dans la CGRAM de l'adresse $60 à $67 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$02,$11,$11,$11,$13,$0D,$00
FOR adresse=$60 TO $67
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère û en envoyant 8 octets dans la CGRAM de l'adresse $68 à $6F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$11,$11,$11,$13,$0D,$00
FOR adresse=$68 TO $6F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère â en envoyant 8 octets dans la CGRAM de l'adresse $70 à $77 :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$0E,$01,$0F,$11,$0F,$00
FOR adresse=$70 TO $77
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Définit le caractère ô en envoyant 8 octets dans la CGRAM de l'adresse $78 à $7F :
/////////////////////////////////////////////////////////////////////////////////////////////

DATA $04,$0A,$0E,$11,$11,$11,$0E,$00
FOR adresse=$78 TO $7F
 n=adresse 
 GOSUB envoyer_instruction
 READ n
 GOSUB envoyer_donnee
NEXT adresse

/////////////////////////////////////////////////////////////////////////////////////////////
// Envoie des données  à l'afficheur :
/////////////////////////////////////////////////////////////////////////////////////////////

// Le caractère de code ASCII $0 est désormais é pour l'afficheur
// Le caractère de code ASCII $1 est désormais è pour l'afficheur
// Le caractère de code ASCII $2 est désormais ê pour l'afficheur
// Le caractère de code ASCII $3 est désormais à pour l'afficheur
// Le caractère de code ASCII $4 est désormais ù pour l'afficheur
// Le caractère de code ASCII $5 est désormais û pour l'afficheur
// Le caractère de code ASCII $6 est désormais â pour l'afficheur
// Le caractère de code ASCII $7 est désormais ô pour l'afficheur

// la variable controleur indique quelle entrée de validation il faut utiliser :
//   - si controleur=1 alors on valide toutes les commandes (instructions et données) sur E1
//   - si controleur=2 alors on valide toutes les commandes (instructions et données) sur E2
//   - si controleur=3 alors on envoie les commandes sur les 2 contrôleurs : E1 et E2

/////////////////////////////////////////////////////////////////////////////////////////////
// écrit sur la ligne 1 "Grâce à Gecif.net vous savez désormais" :
controleur=1 // pour les lignes 1 et 2 on utilise le premier contrôleur (entrée E1)
n=$80
GOSUB envoyer_instruction

s="Gr"
GOSUB afficher_chaine
s=CHR(6)+"ce "
GOSUB afficher_chaine
s=CHR(3)+" Gecif.net vous savez d"
GOSUB afficher_chaine
// Pour le caractère de code ASCII 0 il faut directement envoyer la donnée $00 sans
// mettre de caractère nul dans la chaîne s
n=0
GOSUB envoyer_donnee
s="sormais"
GOSUB afficher_chaine

/////////////////////////////////////////////////////////////////////////////////////////////
// écrit sur la ligne 2 "comment contrôler un afficheur MDLS40466" :
n=$C0
GOSUB envoyer_instruction

s="comment contr"
GOSUB afficher_chaine
s=CHR(7)+"ler un afficheur MDLS40466"
GOSUB afficher_chaine

/////////////////////////////////////////////////////////////////////////////////////////////
// écrit sur la ligne 3 "en écrivant des caractères accentués" :
controleur=2 // pour les lignes 3 et 4 on utilise le second contrôleur (entrée E2)
n=$80
GOSUB envoyer_instruction

s="en "
GOSUB afficher_chaine
n=0
GOSUB envoyer_donnee
s="crivant des caract"
GOSUB afficher_chaine
s=CHR(1)+"res accentu"
GOSUB afficher_chaine
n=0
GOSUB envoyer_donnee
s="s"
GOSUB afficher_chaine

/////////////////////////////////////////////////////////////////////////////////////////////
// écrit sur la ligne 4 "après les avoir dessinés pixel par pixel" :
n=$C0
GOSUB envoyer_instruction

s="apr"
GOSUB afficher_chaine
s=CHR(1)+"s les avoir dessin"
GOSUB afficher_chaine
n=0
GOSUB envoyer_donnee
s="s pixel par pixel"
GOSUB afficher_chaine

END

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction afficher_chaine :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "afficher_chaine" affiche la chaine s
afficher_chaine:
FOR i = 1 TO LEN(s)
 n=ASC(s[i])
 GOSUB envoyer_donnee
NEXT i
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_donnee :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_donnee" met RS à 1 puis envoie l'octet n en 2 étapes
envoyer_donnee:
 Q4=1
 SLEEP FOR temporisation
 Q[0..3]=(n>>4)
 SLEEP FOR temporisation
 GOSUB valider
 Q[0..3]=n
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction envoyer_instruction :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "envoyer_instruction" met RS à 0 puis envoie l'octet n en 2 étapes
envoyer_instruction:
 Q4=0
 SLEEP FOR temporisation
 Q[0..3]=(n>>4)
 SLEEP FOR temporisation
 GOSUB valider
 Q[0..3]=n
 SLEEP FOR temporisation
 GOSUB valider
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fonction valider :
/////////////////////////////////////////////////////////////////////////////////////////////

// Cette fonction "valider" envoie une impulsion sur E1 ou sur E2 en fonction de la
// variable "controleur"

// la variable controleur indique quelle entrée de validation il faut utiliser :
//   - si controleur=1 alors on valide toutes les commandes (instructions et données) sur E1
//   - si controleur=2 alors on valide toutes les commandes (instructions et données) sur E2
//   - si controleur=3 alors on envoie les commandes sur les 2 contrôleurs : E1 et E2

valider:
IF controleur=1 THEN // validation par E1 seulement
 Q5=1
 SLEEP FOR temporisation
 Q5=0
 SLEEP FOR temporisation
ENDIF
IF controleur=2 THEN // validation par E2 seulement
 Q6=1
 SLEEP FOR temporisation
 Q6=0
 SLEEP FOR temporisation
ENDIF
IF controleur=3 THEN // validation par E1 et par E2
 Q5=1
 SLEEP FOR temporisation
 Q5=0
 SLEEP FOR temporisation
 Q6=1
 SLEEP FOR temporisation
 Q6=0
 SLEEP FOR temporisation
ENDIF
RETURN

/////////////////////////////////////////////////////////////////////////////////////////////
// Fin du script
/////////////////////////////////////////////////////////////////////////////////////////////

*ENDSCRIPT

 

Retour au sommaire

 

Définition de 14 caractères accentués dans une matrice binaire 8x8

Pour finir voici la définition numérique de 14 caractères sous forme de 8 octets dans une structure de données DATA utilisable dans vos scripts EasyHDL afin d'afficher ces nouveaux caractères sur tous les afficheurs LCD :

Création de 14 caractères personnalisés
Matrice 8x8 sous forme de 8 octets
Caractère
DATA $04,$08,$0E,$11,$1F,$10,$0E,$00
é
DATA $04,$02,$0E,$11,$1F,$10,$0E,$00
è
DATA $04,$0A,$0E,$11,$1F,$10,$0E,$00
ê
DATA $0A,$00,$0E,$11,$1F,$10,$0E,$00
ë
DATA $04,$02,$0E,$01,$0F,$11,$0F,$00
à
DATA $04,$0A,$0E,$01,$0F,$11,$0F,$00
â
DATA $04,$02,$11,$11,$11,$13,$0D,$00
ù
DATA $04,$0A,$11,$11,$11,$13,$0D,$00
û
DATA $0A,$00,$11,$11,$11,$13,$0D,$00
ü
DATA $04,$0A,$0C,$04,$04,$04,$0E,$00
î
DATA $0A,$00,$0C,$04,$04,$04,$0E,$00
ï
DATA $04,$0A,$0E,$11,$11,$11,$0E,$00
ô
DATA $0E,$10,$10,$11,$0E,$04,$0C,$00
ç
DATA $07,$08,$1E,$08,$1E,$08,$07,$00
€

Voici les 4 caractères qui n'ont encore jamais été affichés sur cette page : les 3 caractères "tréma" et le symbole monétaire de l'Euro :

Remarque : les caractères accentués suivants existent déjà dans la CGROM des afficheurs LCD et n'ont pas besoin d'être créé en CGRAM :

Les caractères accentués présents dans la ROM des afficheurs
Code ASCII du caractère
Caractère
$E1
ä
$EF
ö
$F5
ü
$EE
ñ

 

Retour au sommaire

 

Conclusion

Cette page vous a donné toutes les informations utiles pour mettre en oeuvre facilement un afficheur LCD dans vos montages électroniques sous ISIS Proteus, sans utiliser de microcontrôleur ni de programmation en Flowcode ou en C.

De plus, avec la création de nouveaux caractères, ces afficheurs LCD alphanumériques permettent d'afficher tout type de pictogrammes, permettant par exemple de programmer des jeux ou des graphismes (jauge, équaliseur, personnage, Pac-Man, symboles, formes géométriques, croquis, etc.).


Exemple de Pac-Man bouche ouverte sur un afficheur LCD alphanumérique (et non graphique)


Et voici Pac-Man bouche fermée : il va croquer toutes les lettres !

Autre exemple simple de Pac-Man dessiné dans une matrice binaire de 8x8 pixels en tant que nouveaux caractères :


Bouche ouverte


Bouche fermée

Toutes ces informations et ces ressources seront particulièrement utiles aux lycéens recherchant des solutions originales pour résoudre leur problématique dans le cadre d'un projet, que ce soit pour les TPE en première S ou pour le projet interdisciplinaire en terminale S.

 

Réalisé par Jean-Christophe MICHEL

Octobre 2014

Télécharger l'intégralité de cette ressource (page web, images et fichiers Proteus) dans un ZIP

www.gecif.net