1. // On écrit un caractère
2. void LCD_WriteChar(char c) {
3.     unsigned char oldctl, ctl;
4.     // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
5.     oldctl = ctl = inb(CONTROLREG);
6.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
7.     ctl |= 0x03;  // On force le bas à 0011 ce qui va mettre tout RS a 1 en sortie pour les valeurs de controle
8.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
9. outb(ctl, CONTROLREG);
10. delay(2);
11.     }
13.     // 2) Mise de la valeur dans le registre data
14.     outb_p(c, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
15.     // si outb_p ne plante pas
16.     // 3) envoi d'un strobe pour signaler au LCD une commande
17.     ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
18.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
19.     delay(2);
20.     ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
21.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
22.     delay(2);
23. }
25. // On écrit une chaine
26. void LCD_WriteString(char *s) {
27.     unsigned char oldctl, ctl;
28.     // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
29.     oldctl = ctl = inb(CONTROLREG);
30.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
31.     ctl |= 0x03;  // On force le bas à 0011 ce qui va mettre RS a 1 en sortie pour les valeurs de controle
32.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
33. outb(ctl, CONTROLREG);
34. delay(2);
35.     }
36.     while (*s) {
37. // Mise du caractère dans le registre data
38. outb_p(*s, DATAREG);
39. // si outb_p ne plante pas
40. // 3) envoi d'un strobe pour signaler au LCD une commande
41. ctl &= 0xFE;
42. outb(ctl, CONTROLREG);
43. delay(2);
44. ctl |= 0x01;
45. outb(ctl, CONTROLREG);
46. delay(2);
47. s++;
48.     }
49. }

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
// Base port cablé sur LPT1 ici
#define BASEPORT    0x378
#define DATAREG     BASEPORT+0
#define STATUSREG   BASEPORT+1
#define CONTROLREG  BASEPORT+2
// delai d'attente en ms  
void delay(int mstime) {
  usleep(mstime * 100);
}
// Initialisation des registres, sauvegarde du registre de controle
unsigned char init_port() {
  unsigned char oldctl, ctl;
  // 1) mise à  0 des datas. Ainsi, même si le 2 déclenche un strobe, il n'aura pas d'effet
  outb(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  delay(2);
  // si outb_p ne plante pas
  // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
  oldctl = ctl = inb(CONTROLREG);
  ctl &= 0xD0;  // Bits du haut: direction mise à  0 (écriture) et bits du bas à  0
  ctl |= 0x0B;  // On force le bas à  1011 ce qui va mettre tout à  0 en sortie pour les valeurs de controle
  if (oldctl != ctl) { // on met pas a jour si c'est déjà  bon
    outb(ctl, CONTROLREG);
    delay(2);
    delay(2);
  }
  return oldctl;
}
// Restauration du registre de controle
void restore_port(unsigned char oldctl) {
  unsigned char ctl;
  // 1) mise à  0 des datas. Ainsi, même si le 2 déclenche un strobe, il n'aura pas d'effet
  outb(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  delay(2);
  // si outb_p ne plante pas
  // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
  ctl = inb(CONTROLREG);
  if (oldctl != ctl) { // on met pas a jour si c'est déjà  bon
    outb(oldctl, CONTROLREG);
    delay(2);
    delay(2);
  }
}
// Envoi de commandes et données SPP -> LCD
void data_write(unsigned char data) {
  unsigned char oldctl, ctl;
  // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
  oldctl = ctl = inb(CONTROLREG);
  ctl &= 0xD0;  // Bits du haut: direction mise à  0 (écriture) et bits du bas à  0
  ctl |= 0x0B;  // On force le bas à  1011 ce qui va mettre tout à  0 en sortie pour les valeurs de controle
  if (oldctl != ctl) { // on met pas a jour si c'est déjà  bon
    outb(ctl, CONTROLREG);
    delay(2);
    delay(2);
  }
 
  // 2) Mise de la valeur dans le registre data
  outb(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  delay(2);
  // si outb_p ne plante pas
  // 3) envoi d'un strobe pour signaler au LCD une commande
  ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
  delay(2);
  delay(2);
  ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
  delay(2);
  delay(2);
}
 
// Lecture de donnée LCD -> SPP
// ram positionné: on lit la valeur de la donnée en ram du LCD a l'adresse courante. associé à  RS a 1 en sortie
// ram non positionné: on lit la valeur de l'adresse courante du LCD et le flag busy en poids fort. associé à  RS a 0 en sortie
unsigned char data_read(int ramdata) {
  unsigned char data;
  unsigned char oldctl, ctl;
  // 1) mise à  0 des datas. C'est peut être inutile
  outb(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  delay(2);
  // si outb_p ne plante pas
  // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
  oldctl = ctl = inb(CONTROLREG);
  ctl &= 0xF0;  // Bits du bas à  0
  ctl |= 0x20;  // Bits du haut: direction mise à  1 (écriture)   
  if (ramdata) {
    ctl |= 0x03;  // On force le bas à  0001 ce qui va mettre RW et RS a 1 en sortie et le reste à  0   
  } else {
    ctl |= 0x09;  // On force le bas à  1001 ce qui va mettre RW a 1 en sortie et le reste à  0   
  }
  if (oldctl != ctl) { // on met pas a jour si c'est déjà  bon
    outb(ctl, CONTROLREG);
    delay(2);
    delay(2);
  }
  // 3) envoi d'un strobe pour signaler au LCD une commande
  ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
  delay(2);
  delay(2);
  ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
  delay(2);
  delay(2);
  // 4) lecture des données
  if (ramdata) { // temps de lecture en RAM du LCD   
    delay(1);
  }
  data = inb(DATAREG);
  return data;
}
// Commandes admissibles par le LCD
// Le bit non nul le plus haut détermine la commande
// A priori, 00000000 -> Rien
// 00000001 -> LCD Clear
void LCD_Clear() {
  unsigned char command = 0x01;  // Clear command
  data_write(command);
  delay(2);
}
// 0000001x -> LCD Home
void LCD_Home() {
  unsigned char command = 0x02;  // Home command
  data_write(command);
  delay(2);
}
// 000001xx -> LCD EntryMode
void LCD_EntryMode(int lr, int shift) {
  unsigned char command = 0x04;  // Entry Mode command
  if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
  if (shift)   command |= 0x01; // Shift visible   
  data_write(command);
  delay(2);
}
// 00001xxx -> LCD Display
void LCD_Display(int on, int cursor, int blink) {
  unsigned char command = 0x08;  // DISPLAY command
  if (on)      command |= 0x04; // Display on/off bit
  if (cursor)  command |= 0x02; // Cursor on/off bit
  if (blink)   command |= 0x01; // Cursor blink on/off bit
  data_write(command);
  delay(2);
}
 
// 01xxxxxx -> LCD Set CGRAM
// 1xxxxxxx -> LCD Set DDRAM
// Routines d'un peu plus haut niveau
// On écrit un caractère
void LCD_WriteChar(char c) {
  unsigned char oldctl, ctl;
  // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
  oldctl = ctl = inb(CONTROLREG);
  ctl &= 0xD0;  // Bits du haut: direction mise à  0 (écriture) et bits du bas à  0
  ctl |= 0x03;  // On force le bas à  0011 ce qui va mettre tout RS a 1 en sortie pour les valeurs de controle
  if (oldctl != ctl) { // on met pas a jour si c'est déjà  bon
    delay(2);
    outb(ctl, CONTROLREG);
    delay(2);
    
  }
  // 2) Mise de la valeur dans le registre data
  outb(c, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  delay(2);
  // si outb_p ne plante pas
  // 3) envoi d'un strobe pour signaler au LCD une commande
  ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
  delay(2);
  delay(2);
  ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
  delay(2);
  delay(2);
}
 
 
// On écrit une chaine
void LCD_WriteString(char *s) {
  unsigned char oldctl, ctl;
  // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
  oldctl = ctl = inb(CONTROLREG);
  ctl &= 0xD0;  // Bits du haut: direction mise à  0 (écriture) et bits du bas à  0
  ctl |= 0x03;  // On force le bas à  0011 ce qui va mettre RS a 1 en sortie pour les valeurs de controle
  if (oldctl != ctl) { // on met pas a jour si c'est déjà  bon
    delay(2);
    outb(ctl, CONTROLREG);
    delay(2);
    delay(2);
  }
  while (*s) {
    // Mise du caractère dans le registre data
    outb(*s, DATAREG);
    delay(2);
    // si outb_p ne plante pas
    // 3) envoi d'un strobe pour signaler au LCD une commande
    ctl &= 0xFE;
    outb(ctl, CONTROLREG);
    delay(2);
    delay(2);
    ctl |= 0x01;
 
    outb(ctl, CONTROLREG);
    delay(2);
    delay(2);
    s++;
  }
}
 
// 0001xxxx -> LCD CursorMove (et Display Move)
// 001xxxxx -> LCD Mode
void LCD_Mode(int size8, int line2, int bigfont) {
  unsigned char command = 0x20;  // Mode command
  if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
  if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
  if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
  data_write(command);
  delay(2);
  delay(2);
}
 
// Configuration initiale
void LCD_SoftReset() {
  // D'abord, 3 LCD_Mode avec la valeur correcte pour bit8
  LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
  delay(5);
  LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
  delay(2);
  LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
  delay(2);
  // Maintenant les parametres seront pris en compte
  LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
  // les valeurs qui viennent d'être passé seront inchangeables dorénavant
  LCD_Display(0, 0, 0); // Display Off
  LCD_Clear(); // Display Clear
  LCD_EntryMode(1, 0); // Left-Right, no shift
  // Fin de la séquence de reset soft
}
int main (int argc, char * argv[]) {
  unsigned char ctl;
  if (ioperm(BASEPORT, 3, 1)) {
    perror("can't set IO permissions!" );
    return -1;
  }
  ctl = init_port();
  sleep(5);
  // Par défaut le hard reset de mise sous tension fait comme si on avait fait un SoftReset  
  // avec les parametres suivants en fin de séquence:
  // LCD_Mode(1,1,0);
  // LCD_Display(0, 0, 0);  
  // LCD_EntryMode(1, 0);
  // Décommenter la ligne suivante si tu veux être en mode 2 lignes
  //* LCD_SoftReset(); */
  // A ce stade, on est prêt a utiliser le LCD
  LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
  sleep(10);
  // On peut afficher du texte
  LCD_WriteString("Bonjour le monde ! " );
 
  getchar();
 
  restore_port(ctl);
  if (ioperm(BASEPORT, 3, 0)) {
    perror("can't reset IO permissions!" );
    return -1;
  }
  return 0;
}

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
6. // Base port cablé sur LPT1 ici
7. #define BASEPORT    0x378
8. #define DATAREG     BASEPORT+0
9. #define STATUSREG   BASEPORT+1
10. #define CONTROLREG  BASEPORT+2
12. /* ***************************************************************************** */
13. /*                       Commandes de bas niveau                                 */
14. /* ***************************************************************************** */
16. // Envoi de commandes SPP -> LCD
17. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
18.     outb(cmd, DATAREG);        // Set command in DATA
19.     outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
20.     usleep(1);                 // Strobe duration: 500 ns  
21.     outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
22.     usleep(1);                 // Wait before next strobe: 500 ns
23. }
25. // Envoi d'un caractere SPP -> LCD
26. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
27.     outb(c,    DATAREG);    // Set command in DATA
28.     outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
29.     usleep(1);              // Strobe duration: 500 ns  
30.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
31.     usleep(1);              // Wait before next strobe: 500 ns
32. }
34. // Lecture addresse courante RAM LCD -> SPP
35. unsigned char address_read { // Cas RS=0, (Reception et) RW = 1
36.     unsigned char address = 0x7F; // Mask for D6..D0
37.    
38.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
39.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
40.     usleep(1);              // Strobe duration: 500 ns
41.     address &= inb(DATAREG);
42.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
43.     usleep(1);              // Wait before next strobe: 500 ns
44.     return address;
45. }
47. // Test du flag busy du LCD.  
48. int is_busy() {             // Cas RS=0, (Reception et) RW = 1
49.     unsigned char busy = 0x80; // Mask for D7
50.    
51.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
52.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]
53.     usleep(1);              // Strobe duration: 500 ns
54.     busy &= inb(DATAREG);
55.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
56.     usleep(1);              // Wait before next strobe: 500 ns
57.     return (busy?1:0);
58. }
60. // Lecture valeur a l'addresse courante RAM LCD -> SPP
61. unsigned char data_read {   // Cas RS=1, (Reception et) RW = 1
62.     unsigned char data;
63.    
64.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
65.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Read, 0: RS RW E active]
66.     usleep(1);              // Strobe duration: 500 ns  
67.     data = inb(DATAREG);
68.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
69.     usleep(1);              // Wait before next strobe: 500 ns
70.     return data;
71. }
72. /* ***************************************************************************** */
73. /*                       Commandes du LCD                                        */
74. /* ***************************************************************************** */
76. // cas 00000001
77. void LCD_Clear() {
78.     unsigned char command = 0x01;  // Clear command
80.     send_cmd(command);
81.     while (is_busy()) /* wait */;
82. }
84. // cas 0000001x
85. void LCD_Home() {
86.     unsigned char command = 0x02;  // Home command
88.     send_cmd(command);
89.     while (is_busy()) /* wait */;
90. }
92. // cas 000001xx
93. void LCD_EntryMode(int lr, int shift) {
94.     unsigned char command = 0x04;  // Entry Mode command
96.     if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
97.     if (shift)   command |= 0x01; // Shift visible  
99.     send_cmd(command);
100.     while (is_busy()) /* wait */;
101. }
103. // cas 00001xxx
104. void LCD_Display(int on, int cursor, int blink) {
105.     unsigned char command = 0x08;  // DISPLAY command
107.     if (on)      command |= 0x04; // Display on/off bit
108.     if (cursor)  command |= 0x02; // Cursor on/off bit
109.     if (blink)   command |= 0x01; // Cursor blink on/off bit
111.     send_cmd(command);
112.     while (is_busy()) /* wait */;
113. }
115. // cas 0001xxxx -> LCD CursorMove (et Display Move)
116. // cas 001xxxxx
117. void LCD_Mode(int size8, int line2, int bigfont) {
118.     unsigned char command = 0x20;  // Mode command
120.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
121.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
122.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
124.     send_cmd(command);
125.     while (is_busy()) /* wait */;
126. }
128. // cas 01xxxxxx -> LCD Set CGRAM
129. // cas 1xxxxxxx -> LCD Set DDRAM
131. /* ***************************************************************************** */
132. /*                       Fonctions de "haut niveau"                              */
133. /* ***************************************************************************** */
135. // Ecriture d'un caractère
136. void LCD_WriteChar(char c) {
138.     send_char(c);
139.     while (is_busy()) /* wait */;
140. }
141. // Ecriture d'une chaine
142. void LCD_WriteString(char *s) {
144.     while (*s) {
145. send_char(*s++);
146. while (is_busy()) /* wait */;
147.     }
148. }
150. // Reset du LCD et Initialisation
151. // Note le hard reset de mise sous tension equivaut a LCD_SoftReset(1,0,0)
152. void LCD_SoftReset(int size8, int line2, int bigfont) {
153.     unsigned char command = 0x20;  // Mode command
155.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
156.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
157.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
159.     // Sequence de reinitialisation
160.     // D'abord, 3 commandes Mode avec la valeur voulue pour bit8
161.     send_cmd(command); //  
162.     usleep(5000);      // more than 4.1 ms
163.     send_cmd(command);
164.     usleep(500);      // more than 100 µs
165.     send_cmd(command); // Maintenant is_busy va fonctionner
166.     while (is_busy()) /* wait */;   
167.    
169.     // Sequence de parametrage
170.     LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
171.     LCD_Display(0, 0, 0);            // Display Off
172.     LCD_Clear();                     // Display Clear
173.     LCD_EntryMode(1, 0);             // Left-Right, no shift
174. }
177. int main (int argc, char * argv[]) {
179.     if (ioperm(BASEPORT, 3, 1)) {
180. perror("can't set IO permissions!" );
181. return -1;
182.     }
184.     sleep(1); // Temps necessaire a l'initialisation hard du LCD
185.     // while (is_busy()) /* wait */; // Ce serait bien de tester ceci à la place du sleep(1)
186.     // LCD_SoftReset(1,1,0); // Ce serait bien de tester ceci aussi
187.     LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
188.     // On peut afficher du texte
189.     LCD_WriteString("Bonjour le monde ! " );
191.     printf("Taper quelque chose pour quitter le programme\n" );
192.     getchar();
194.     if (ioperm(BASEPORT, 3, 0)) {
195. perror("can't reset IO permissions!" );
196. return -1;
197.     }
199.     return 0;
200. }

1. send_cmd(command); //   
2.     usleep(5000);      // more than 4.1 ms
3.     send_cmd(command);
4.     usleep(500);      // more than 100 µs  
5.     send_cmd(command); // Maintenant is_busy va fonctionner
6.     usleep(500);      //  Peut être un peu de délai en rab avant de tester busy
7.     while (is_busy()) /* wait */;   // peut être le remplacer contre un délai long (usleep(5000); par exemple)
8.  
9.     // Sequence de parametrage
10.     LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
11.     LCD_Display(0, 0, 0);            // Display Off
12.     LCD_Clear();                     // Display Clear  // Peut être mettre ceci avant LCD_Mode(size8, line2, bigfont); car dans le reset hard, c'est en premier
13.     LCD_EntryMode(1, 0);             // Left-Right, no shift

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
6. // Base port cablé sur LPT1 ici
7. #define BASEPORT    0x378
8. #define DATAREG     BASEPORT+0
9. #define STATUSREG   BASEPORT+1
10. #define CONTROLREG  BASEPORT+2
13. #define NEWCODE 1
15. #ifdef NEWCODE
17. /* ***************************************************************************** */
18. /*                       Commandes de bas niveau                                 */
19. /* ***************************************************************************** */
21. // Envoi de commandes SPP -> LCD
22. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
23.    
24.     outb(0x0B, CONTROLREG); // Set Control [0x0B 0: Emission, B: RS RW E inactive]
25.     outb(cmd,  DATAREG);    // Set command in DATA
26.     outb(0x0A, CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
27.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
28. }
30. // Envoi d'un caractere SPP -> LCD
31. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
33.     outb(0x03, CONTROLREG); // Set Control [0x03 0: Emission, 3: RS active]
34.     outb(c,    DATAREG);    // Set command in DATA
35.     outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
36.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
37. }
39. // Lecture busy + addresse courante RAM LCD -> SPP
40. unsigned char address_read() { // Cas RS=0, (Reception et) RW = 1
41.     unsigned char address = 0x7F; // Mask for D6..D0
43.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
44.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
45.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
46.     address &= inb(DATAREG);
47.     return address;
48. }
50. // Test du flag busy du LCD.  
51. int is_busy() {             // Cas RS=0, (Reception et) RW = 1
52.     unsigned char busy = 0x80; // Mask for D7
54.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
55.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
56.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
57.     busy &= inb(DATAREG);
58.     return (busy?1:0);
59. }
61. // Lecture valeur a l'addresse courante RAM LCD -> SPP
62. unsigned char data_read() {   // Cas RS=1, (Reception et) RW = 1
63.     unsigned char data;
65.     outb(0x21, CONTROLREG); // Set Control [0x21 2: Reception, 1: RS RW active]
66.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Reception, 0: RS RW E active]
67.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
68.     data = inb(DATAREG);
69.     return data;
70. }
72. #else
74. // Envoi de commandes SPP -> LCD
75. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
76.     outb(cmd, DATAREG);        // Set command in DATA
77.     outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
78.     usleep(1);                 // Strobe duration: 500 ns   
79.     outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
80.     usleep(1);                 // Wait before next strobe: 500 ns
81. }
82. // Envoi d'un caractere SPP -> LCD
83. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
84.     outb(c,    DATAREG);    // Set command in DATA
85.     outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
86.     usleep(1);              // Strobe duration: 500 ns   
87.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
88.     usleep(1);              // Wait before next strobe: 500 ns
89. }
90. // Lecture addresse courante RAM LCD -> SPP
91. unsigned char address_read { // Cas RS=0, (Reception et) RW = 1
92.     unsigned char address = 0x7F; // Mask for D6..D0
93.  
94.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
95.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
96.     usleep(1);              // Strobe duration: 500 ns
97.     address &= inb(DATAREG);
98.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
99.     usleep(1);              // Wait before next strobe: 500 ns
100.     return address;
101. }
102. // Test du flag busy du LCD.   
103. int is_busy() {             // Cas RS=0, (Reception et) RW = 1
104.     unsigned char busy = 0x80; // Mask for D7
105.  
106.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
107.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]
108.     usleep(1);              // Strobe duration: 500 ns
109.     busy &= inb(DATAREG);
110.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
111.     usleep(1);              // Wait before next strobe: 500 ns
112.     return (busy?1:0);
113. }
114. // Lecture valeur a l'addresse courante RAM LCD -> SPP
115. unsigned char data_read {   // Cas RS=1, (Reception et) RW = 1
116.     unsigned char data;
117.  
118.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
119.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Read, 0: RS RW E active]
120.     usleep(1);              // Strobe duration: 500 ns   
121.     data = inb(DATAREG);
122.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
123.     usleep(1);              // Wait before next strobe: 500 ns
124.     return data;
125. }
127. #endif
128. /* ***************************************************************************** */
129. /*                       Commandes du LCD                                        */
130. /* ***************************************************************************** */
132. // cas 00000001
133. void LCD_Clear() {
134.     unsigned char command = 0x01;  // Clear command
136.     while (is_busy()) /* wait */;
137.     send_cmd(command);
138. }
140. // cas 0000001x
141. void LCD_Home() {
142.     unsigned char command = 0x02;  // Home command
144.     while (is_busy()) /* wait */;
145.     send_cmd(command);
146. }
148. // cas 000001xx
149. void LCD_EntryMode(int lr, int shift) {
150.     unsigned char command = 0x04;  // Entry Mode command
152.     if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
153.     if (shift)   command |= 0x01; // Shift visible  
155.     while (is_busy()) /* wait */;
156.     send_cmd(command);
157. }
159. // cas 00001xxx
160. void LCD_Display(int on, int cursor, int blink) {
161.     unsigned char command = 0x08;  // DISPLAY command
163.     if (on)      command |= 0x04; // Display on/off bit
164.     if (cursor)  command |= 0x02; // Cursor on/off bit
165.     if (blink)   command |= 0x01; // Cursor blink on/off bit
167.     while (is_busy()) /* wait */;
168.     send_cmd(command);
169. }
171. // cas 0001xxxx -> LCD CursorMove (et Display Move)
172. // cas 001xxxxx
173. void LCD_Mode(int size8, int line2, int bigfont) {
174.     unsigned char command = 0x20;  // Mode command
176.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
177.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
178.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
180.     while (is_busy()) /* wait */;
181.     send_cmd(command);
182. }
184. // cas 01xxxxxx -> LCD Set CGRAM
185. // cas 1xxxxxxx -> LCD Set DDRAM
187. /* ***************************************************************************** */
188. /*                       Fonctions de "haut niveau"                              */
189. /* ***************************************************************************** */
191. // Ecriture d'un caractère
192. void LCD_WriteChar(char c) {
194.     while (is_busy()) /* wait */;
195.     send_char(c);
196. }
197. // Ecriture d'une chaine
198. void LCD_WriteString(char *s) {
200.     while (*s) {
201. while (is_busy()) /* wait */;
202. send_char(*s++);
203.     }
204. }
206. // Reset du LCD et Initialisation
207. // Note le hard reset de mise sous tension equivaut a LCD_SoftReset(1,0,0)
208. void LCD_SoftReset(int size8, int line2, int bigfont) {
209.     unsigned char command = 0x20;  // Mode command
211.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
212.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
213.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
215.     // Sequence de reinitialisation
216.     // D'abord, 3 commandes Mode avec la valeur voulue pour bit8
217.     while (is_busy()) /* wait */;  // is_busy inutilisable ensuite
218.     send_cmd(command); //  
219.     usleep(5000);      // more than 4.1 ms
220.     send_cmd(command);
221.     usleep(500);      // more than 100 µs
222.     send_cmd(command); // Maintenant is_busy va fonctionner  
223.    
224.     // Sequence de parametrage
225.     LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
226.     LCD_Display(0, 0, 0);            // Display Off
227.     LCD_Clear();                     // Display Clear
228.     LCD_EntryMode(1, 0);             // Left-Right, no shift
229. }
232. int main (int argc, char * argv[]) {
234.     if (ioperm(BASEPORT, 3, 1)) {
235. perror("can't set IO permissions!" );
236. return -1;
237.     }
239.     // Attente de fin de l'initialisation hardware le cas échéant
240.    
242.     // LCD_SoftReset(1,1,0); // Ce serait bien de tester ceci aussi
243.     LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
244.     // On peut afficher du texte
245.     LCD_WriteString("Bonjour le monde ! " );
247.     printf("Taper quelque chose pour quitter le programme\n" );
248.     getchar();
250.     if (ioperm(BASEPORT, 3, 0)) {
251. perror("can't reset IO permissions!" );
252. return -1;
253.     }
255.     return 0;
256. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
6. // Base port cablé sur LPT1 ici
7. #define BASEPORT    0x378
8. #define DATAREG     BASEPORT+0
9. #define STATUSREG   BASEPORT+1
10. #define CONTROLREG  BASEPORT+2
13. /* ***************************************************************************** */
14. /*                       Commandes de bas niveau                                 */
15. /* ***************************************************************************** */
17. // Envoi de commandes SPP -> LCD
18. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
19.    
20.     outb(0x0B, CONTROLREG); // Set Control [0x0B 0: Emission, B: RS RW E inactive]
21.     outb(cmd,  DATAREG);    // Set command in DATA
22.     outb(0x0A, CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
23.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
24. }
26. // Envoi d'un caractere SPP -> LCD
27. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
29.     outb(0x03, CONTROLREG); // Set Control [0x03 0: Emission, 3: RS active]
30.     outb(c,    DATAREG);    // Set command in DATA
31.     outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
32.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
33. }
35. // Lecture busy + addresse courante RAM LCD -> SPP
36. unsigned char address_read() { // Cas RS=0, (Reception et) RW = 1
37.     unsigned char address = 0x7F; // Mask for D6..D0
39.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
40.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
41.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
42.     address &= inb(DATAREG);
43.     return address;
44. }
46. // Test du flag busy du LCD.  
47. int is_busy() {             // Cas RS=0, (Reception et) RW = 1
48.     unsigned char busy = 0x80; // Mask for D7
50.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
51.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
52.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
53.     busy &= inb(DATAREG);
54.     return (busy?1:0);
55. }
57. // Lecture valeur a l'addresse courante RAM LCD -> SPP
58. unsigned char data_read() {   // Cas RS=1, (Reception et) RW = 1
59.     unsigned char data;
61.     outb(0x21, CONTROLREG); // Set Control [0x21 2: Reception, 1: RS RW active]
62.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Reception, 0: RS RW E active]
63.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
64.     data = inb(DATAREG);
65.     return data;
66. }
68. void busy_wait() { // Cas RS=0, (Reception et) RW = 1
70.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
71.     // Strobe loop
72.     do {
73. outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
74. outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
75.     }
76.     while(0x80 & inb(DATAREG));
77.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
78. }
80. /* ***************************************************************************** */
81. /*                       Commandes du LCD                                        */
82. /* ***************************************************************************** */
84. // cas 00000001
85. void LCD_Clear() {
86.     unsigned char command = 0x01;  // Clear command
88.     busy_wait();
89.     send_cmd(command);
90. }
92. // cas 0000001x
93. void LCD_Home() {
94.     unsigned char command = 0x02;  // Home command
96.     busy_wait();
97.     send_cmd(command);
98. }
100. // cas 000001xx
101. void LCD_EntryMode(int lr, int shift) {
102.     unsigned char command = 0x04;  // Entry Mode command
104.     if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
105.     if (shift)   command |= 0x01; // Shift visible  
107.     busy_wait();
108.     send_cmd(command);
109. }
111. // cas 00001xxx
112. void LCD_Display(int on, int cursor, int blink) {
113.     unsigned char command = 0x08;  // DISPLAY command
115.     if (on)      command |= 0x04; // Display on/off bit
116.     if (cursor)  command |= 0x02; // Cursor on/off bit
117.     if (blink)   command |= 0x01; // Cursor blink on/off bit
119.     busy_wait();
120.     send_cmd(command);
121. }
123. // cas 0001xxxx -> LCD CursorMove (et Display Move)
124. // cas 001xxxxx
125. void LCD_Mode(int size8, int line2, int bigfont) {
126.     unsigned char command = 0x20;  // Mode command
128.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
129.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
130.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
132.     busy_wait();
133.     send_cmd(command);
134. }
136. // cas 01xxxxxx -> LCD Set CGRAM
137. // cas 1xxxxxxx -> LCD Set DDRAM
139. /* ***************************************************************************** */
140. /*                       Fonctions de "haut niveau"                              */
141. /* ***************************************************************************** */
143. // Ecriture d'un caractère
144. void LCD_WriteChar(char c) {
146.     busy_wait();
147.     send_char(c);
148. }
149. // Ecriture d'une chaine
150. void LCD_WriteString(char *s) {
152.     while (*s) {
153. busy_wait();
154. send_char(*s++);
155.     }
156. }
158. // Reset du LCD et Initialisation
159. // Note le hard reset de mise sous tension equivaut a LCD_SoftReset(1,0,0)
160. void LCD_SoftReset(int size8, int line2, int bigfont) {
161.     unsigned char command = 0x20;  // Mode command
163.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
164.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
165.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
167.     // Sequence de reinitialisation
168.     // D'abord, 3 commandes Mode avec la valeur voulue pour bit8
169.     busy_wait();  // Le flag busy inutilisable ensuite
170.     send_cmd(command); //  
171.     usleep(5000);      // more than 4.1 ms
172.     send_cmd(command);
173.     usleep(500);      // more than 100 µs
174.     send_cmd(command); // Maintenant Le flag busy va fonctionner  
175.    
176.     // Sequence de parametrage
177.     LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
178.     LCD_Display(0, 0, 0);            // Display Off
179.     LCD_Clear();                     // Display Clear
180.     LCD_EntryMode(1, 0);             // Left-Right, no shift
181. }
184. int main (int argc, char * argv[]) {
186.     if (ioperm(BASEPORT, 3, 1)) {
187. perror("can't set IO permissions!" );
188. return -1;
189.     }
191.     // Attente de fin de l'initialisation hardware le cas échéant
192.    
194.     // LCD_SoftReset(1,1,0); // Ce serait bien de tester ceci aussi
195.     LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
196.     // On peut afficher du texte
197.     LCD_WriteString("Bonjour le monde ! " );
199.     printf("Taper quelque chose pour quitter le programme\n" );
200.     getchar();
202.     if (ioperm(BASEPORT, 3, 0)) {
203. perror("can't reset IO permissions!" );
204. return -1;
205.     }
207.     return 0;
208. }

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
// Base port cablé sur LPT1 ici
#define BASEPORT    0x378
#define DATAREG     BASEPORT+0
#define STATUSREG   BASEPORT+1
#define CONTROLREG  BASEPORT+2
#define NEWCODE 1
#ifdef NEWCODE
/* ***************************************************************************** */
/*                       Commandes de bas niveau                                 */
/* ***************************************************************************** */
// Envoi de commandes SPP -> LCD
void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
   
  outb(0x0B, CONTROLREG); // Set Control [0x0B 0: Emission, B: RS RW E inactive]
  usleep(100);
  outb(cmd,  DATAREG);    // Set command in DATA
  usleep(100);
  outb(0x0A, CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
  usleep(100);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  usleep(100);
}
// Envoi d'un caractere SPP -> LCD
void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
  outb(0x03, CONTROLREG); // Set Control [0x03 0: Emission, 3: RS active]
  usleep(100);
  outb(c,    DATAREG);    // Set command in DATA
  usleep(100);
  outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
  usleep(100);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  usleep(100);
}
// Lecture busy + addresse courante RAM LCD -> SPP
unsigned char address_read() { // Cas RS=0, (Reception et) RW = 1
  unsigned char address = 0x7F; // Mask for D6..D0
  outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
  usleep(1);
  outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
  usleep(1);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  usleep(1);
  address &= inb(DATAREG);
  return address;
}
// Test du flag busy du LCD.  
int is_busy() {             // Cas RS=0, (Reception et) RW = 1
  unsigned char busy = 0x80; // Mask for D7
  outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
  usleep(100);
  outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
  usleep(100);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  usleep(100);
  busy &= inb(DATAREG);
  return (busy?1:0);
}
// Lecture valeur a l'addresse courante RAM LCD -> SPP
unsigned char data_read() {   // Cas RS=1, (Reception et) RW = 1
  unsigned char data;
  outb(0x21, CONTROLREG); // Set Control [0x21 2: Reception, 1: RS RW active]
  usleep(1);
  outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Reception, 0: RS RW E active]
  usleep(1);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  usleep(1);
  data = inb(DATAREG);
  return data;
}
#else
// Envoi de commandes SPP -> LCD
void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
  outb(cmd, DATAREG);        // Set command in DATA
  usleep(100);
  outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
  usleep(100);                 // Strobe duration: 500 ns   
  outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  usleep(100);                 // Wait before next strobe: 500 ns
}
// Envoi d'un caractere SPP -> LCD
void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
  outb(c,    DATAREG);    // Set command in DATA
  usleep(100);
  outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
  usleep(100);              // Strobe duration: 500 ns   
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  usleep(100);              // Wait before next strobe: 500 ns
}
// Lecture addresse courante RAM LCD -> SPP
unsigned char address_read { // Cas RS=0, (Reception et) RW = 1
  unsigned char address = 0x7F; // Mask for D6..D0
    
  outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
  usleep(100);
  outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
  usleep(100);              // Strobe duration: 500 ns
  address &= inb(DATAREG);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  usleep(100);              // Wait before next strobe: 500 ns
  return address;
}
// Test du flag busy du LCD.   
int is_busy() {             // Cas RS=0, (Reception et) RW = 1
  unsigned char busy = 0x80; // Mask for D7
 
  outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
  usleep(100);
  outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]
  usleep(100);              // Strobe duration: 500 ns
  busy &= inb(DATAREG);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  usleep(100);              // Wait before next strobe: 500 ns
  return (busy?1:0);
}
// Lecture valeur a l'addresse courante RAM LCD -> SPP
unsigned char data_read {   // Cas RS=1, (Reception et) RW = 1
  unsigned char data;
 
  outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
  usleep(100);
  outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Read, 0: RS RW E active]
  usleep(100);              // Strobe duration: 500 ns   
  data = inb(DATAREG);
  outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  usleep(100);              // Wait before next strobe: 500 ns
  return data;
}
#endif
/* ***************************************************************************** */
/*                       Commandes du LCD                                        */
/* ***************************************************************************** */
// cas 00000001
void LCD_Clear() {
  unsigned char command = 0x01;  // Clear command
  while (is_busy()) /* wait */;
  usleep(1);
  send_cmd(command);
}
// cas 0000001x
void LCD_Home() {
  unsigned char command = 0x02;  // Home command
  while (is_busy()) /* wait */;
  send_cmd(command);
}
// cas 000001xx
void LCD_EntryMode(int lr, int shift) {
  unsigned char command = 0x04;  // Entry Mode command
  if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
  if (shift)   command |= 0x01; // Shift visible  
  while (is_busy()) /* wait */;
  usleep(1);
  send_cmd(command);
}
// cas 00001xxx
void LCD_Display(int on, int cursor, int blink) {
  unsigned char command = 0x08;  // DISPLAY command
  if (on)      command |= 0x04; // Display on/off bit
  if (cursor)  command |= 0x02; // Cursor on/off bit
  if (blink)   command |= 0x01; // Cursor blink on/off bit
  while (is_busy()) /* wait */;
  usleep(1);
  send_cmd(command);
}
// cas 0001xxxx -> LCD CursorMove (et Display Move)
// cas 001xxxxx
void LCD_Mode(int size8, int line2, int bigfont) {
  unsigned char command = 0x20;  // Mode command
  if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
  if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
  if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
  while (is_busy()) /* wait */;
  send_cmd(command);
}
// cas 01xxxxxx -> LCD Set CGRAM
// cas 1xxxxxxx -> LCD Set DDRAM
/* ***************************************************************************** */
/*                       Fonctions de "haut niveau"                              */
/* ***************************************************************************** */
// Ecriture d'un caractère
void LCD_WriteChar(char c) {
  while (is_busy()) /* wait */;
  usleep(1);
  send_char(c);
}
// Ecriture d'une chaine
void LCD_WriteString(char *s) {
  while (*s) {
    while (is_busy()) /* wait */;
    usleep(1);
    send_char(*s++);
  }
}
// Reset du LCD et Initialisation
// Note le hard reset de mise sous tension equivaut a LCD_SoftReset(1,0,0)
void LCD_SoftReset(int size8, int line2, int bigfont) {
  unsigned char command = 0x20;  // Mode command
  if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
  if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
  if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
  // Sequence de reinitialisation
  // D'abord, 3 commandes Mode avec la valeur voulue pour bit8
  while (is_busy()) /* wait */;  // is_busy inutilisable ensuite
  send_cmd(command); //  
  usleep(5000);      // more than 4.1 ms
  send_cmd(command);
  usleep(500);      // more than 100 µs
  send_cmd(command); // Maintenant is_busy va fonctionner  
  usleep(500);      // more than 100 µs
  // Sequence de parametrage
  LCD_Clear();                     // Display Clear
  LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
  LCD_Display(0, 0, 0);            // Display Off
    
  LCD_EntryMode(1, 0);             // Left-Right, no shift
}
int main (int argc, char * argv[]) {
  if (ioperm(BASEPORT, 3, 1)) {
    perror("can't set IO permissions!" );
    return -1;
  }
  // Attente de fin de l'initialisation hardware le cas échéant
   
  LCD_SoftReset(1,1,0); // Ce serait bien de tester ceci aussi
  LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
  // On peut afficher du texte
  LCD_WriteString("Bonjour le monde ! " );
  printf("Taper quelque chose pour quitter le programme\n" );
  getchar();
  if (ioperm(BASEPORT, 3, 0)) {
    perror("can't reset IO permissions!" );
    return -1;
  }
  return 0;
}

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
6. // Base port cablé sur LPT1 ici
7. #define BASEPORT    0x378
8. #define DATAREG     BASEPORT+0
9. #define STATUSREG   BASEPORT+1
10. #define CONTROLREG  BASEPORT+2
12. #define REGISTER_DELAY 1
13. /* ***************************************************************************** */
14. /*                       Commandes de bas niveau                                 */
15. /* ***************************************************************************** */
17. // Envoi de commandes SPP -> LCD
18. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
19.    
20.     outb(cmd,  DATAREG);    // Set command in DATA
21.     outb(0x0B, CONTROLREG); // Set Control [0x0B 0: Emission, B: RS RW E inactive]
22.     usleep(REGISTER_DELAY);
23.     outb(0x0A, CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
24.     usleep(REGISTER_DELAY);
25.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
26.     usleep(REGISTER_DELAY);
27. }
29. // Envoi d'un caractere SPP -> LCD
30. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
32.     outb(c,    DATAREG);    // Set command in DATA
33.     outb(0x03, CONTROLREG); // Set Control [0x03 0: Emission, 3: RS active]
34.     usleep(REGISTER_DELAY);
35.     outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
36.     usleep(REGISTER_DELAY);
37.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
38.     usleep(REGISTER_DELAY);
39. }
41. // Lecture busy + addresse courante RAM LCD -> SPP
42. unsigned char address_read() { // Cas RS=0, (Reception et) RW = 1
43.     unsigned char address = 0x7F; // Mask for D6..D0
45.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
46.     usleep(REGISTER_DELAY);
47.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
48.     usleep(REGISTER_DELAY);
49.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
50.     usleep(REGISTER_DELAY);
51.     address &= inb(DATAREG);
52.     return address;
53. }
55. // Test du flag busy du LCD.  
56. int is_busy() {             // Cas RS=0, (Reception et) RW = 1
57.     unsigned char busy = 0x80; // Mask for D7
59.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
60.     usleep(REGISTER_DELAY);
61.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
62.     usleep(REGISTER_DELAY);
63.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
64.     usleep(REGISTER_DELAY);
65.     busy &= inb(DATAREG);
66.     return (busy?1:0);
67. }
69. // Lecture valeur a l'addresse courante RAM LCD -> SPP
70. unsigned char data_read() {   // Cas RS=1, (Reception et) RW = 1
71.     unsigned char data;
73.     outb(0x21, CONTROLREG); // Set Control [0x21 2: Reception, 1: RS RW active]
74.     usleep(REGISTER_DELAY);
75.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Reception, 0: RS RW E active]
76.     usleep(REGISTER_DELAY);
77.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
78.     usleep(REGISTER_DELAY);
79.     data = inb(DATAREG);
80.     return data;
81. }
83. void busy_wait() { // Cas RS=0, (Reception et) RW = 1
85.     outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
86.     usleep(REGISTER_DELAY);
87.     // Strobe loop
88.     do {
89. outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
90. usleep(REGISTER_DELAY);
91. outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
92. usleep(REGISTER_DELAY);
93.     }
94.     while(0x80 & inb(DATAREG));
95.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
96.     usleep(REGISTER_DELAY);
97. }
99. /* ***************************************************************************** */
100. /*                       Commandes du LCD                                        */
101. /* ***************************************************************************** */
103. // cas 00000001
104. void LCD_Clear() {
105.     unsigned char command = 0x01;  // Clear command
107.     busy_wait();
108.     send_cmd(command);
109. }
111. // cas 0000001x
112. void LCD_Home() {
113.     unsigned char command = 0x02;  // Home command
115.     busy_wait();
116.     send_cmd(command);
117. }
119. // cas 000001xx
120. void LCD_EntryMode(int lr, int shift) {
121.     unsigned char command = 0x04;  // Entry Mode command
123.     if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
124.     if (shift)   command |= 0x01; // Shift visible  
126.     busy_wait();
127.     send_cmd(command);
128. }
130. // cas 00001xxx
131. void LCD_Display(int on, int cursor, int blink) {
132.     unsigned char command = 0x08;  // DISPLAY command
134.     if (on)      command |= 0x04; // Display on/off bit
135.     if (cursor)  command |= 0x02; // Cursor on/off bit
136.     if (blink)   command |= 0x01; // Cursor blink on/off bit
138.     busy_wait();
139.     send_cmd(command);
140. }
142. // cas 0001xxxx -> LCD CursorMove (et Display Move)
143. // cas 001xxxxx
144. void LCD_Mode(int size8, int line2, int bigfont) {
145.     unsigned char command = 0x20;  // Mode command
147.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
148.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
149.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
151.     busy_wait();
152.     send_cmd(command);
153. }
155. // cas 01xxxxxx -> LCD Set CGRAM
156. // cas 1xxxxxxx -> LCD Set DDRAM
158. /* ***************************************************************************** */
159. /*                       Fonctions de "haut niveau"                              */
160. /* ***************************************************************************** */
162. // Ecriture d'un caractère
163. void LCD_WriteChar(char c) {
165.     busy_wait();
166.     send_char(c);
167. }
168. // Ecriture d'une chaine
169. void LCD_WriteString(char *s) {
171.     while (*s) {
172. busy_wait();
173. send_char(*s++);
174.     }
175. }
177. // Reset du LCD et Initialisation
178. // Note le hard reset de mise sous tension equivaut a LCD_SoftReset(1,0,0)
179. void LCD_SoftReset(int size8, int line2, int bigfont) {
180.     unsigned char command = 0x20;  // Mode command
182.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
183.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
184.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
186.     // Sequence de reinitialisation
187.     // D'abord, 3 commandes Mode avec la valeur voulue pour bit8
188.     busy_wait();  // Le flag busy inutilisable ensuite
189.     send_cmd(command); //  
190.     usleep(5000);      // more than 4.1 ms
191.     send_cmd(command);
192.     usleep(500);      // more than 100 µs
193.     send_cmd(command); // Maintenant Le flag busy va fonctionner  
194.    
195.     // Sequence de parametrage
196.     LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
197.     LCD_Display(0, 0, 0);            // Display Off
198.     LCD_Clear();                     // Display Clear
199.     LCD_EntryMode(1, 0);             // Left-Right, no shift
200. }
203. int main (int argc, char * argv[]) {
205.     if (ioperm(BASEPORT, 3, 1)) {
206. perror("can't set IO permissions!" );
207. return -1;
208.     }
210.     // Attente de fin de l'initialisation hardware le cas échéant
211.    
213.     // LCD_SoftReset(1,1,0); // Ce serait bien de tester ceci aussi
214.     LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
215.     // On peut afficher du texte
216.     LCD_WriteString("Bonjour le monde ! " );
218.     printf("Taper quelque chose pour quitter le programme\n" );
219.     getchar();
221.     if (ioperm(BASEPORT, 3, 0)) {
222. perror("can't reset IO permissions!" );
223. return -1;
224.     }
226.     return 0;
227. }