#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "parapin.h"
int main(int argc, char *argv[])
{
  int i;
  if (pin_init_user(LPT1) < 0) {
    perror("paralcd::ioperm" );
    exit(0);
  }
  //pin_output_mode(LP_SWITCHABLE_PINS);                                                                     
  pin_output_mode(LP_DATA_PINS);
  clear_pin(LP_DATA_PINS);
  //clear_pin(LP_SWITCHABLE_PINS);                                                                           
  printf("Setting Pins LP_PIN02 LP_PIN04 LP_PIN05 LP_PIN07" );
  //set_pin(LP_PIN02);                                                                                       
  //pin_input_mode(LP_SWITCHABLE_PINS);                                                                      
  pin_input_mode(LP_DATA_PINS);
  printf("\nstarting\n" );
  for (i = 2; i <= 9; i++)
    printf("Pin %d: %s\n", i, pin_is_set(LP_PIN[i]) ? "HIGH":"LOW" );
  printf("\n\n" );
 
  return 0;
}

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
6. #define BASEPORT 0x378
7. #define DATAREG     BASEPORT+0
8. #define STATUSREG   BASEPORT+1
9. #define CONTROLREG  BASEPORT+2
11. /* delai d'attente en ms
12.    arrondi au multiple de 50ms supérieur
13.    afin de prendre en compte la granularité de usleep */
14. void msdelay(int delay) {
15.     int rdelay = delay/50;
16.     if (!rdelay)
17. rdelay = 1;
18.     usleep(rdelay * 50000);
19. }
22. #define STROBE     0x01;
24. // Si on a connecté le pin LCD 5 au 14 du PP, sinon si c'est sur le 16, mettre ici 0x40
25. #define DIRECTION  0x20;
27. #define nBUSY      0x80;
29. void data_write(unsigned char data) {
30.     // unsigned char status, i, maxtries = 100;
31.     unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
32.     unsigned char ctl = oldctl & ~DIRECTION; /* on met le flag direction à 0: on est en écriture */
33.     outb_p(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
34.     outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
35.     // for (i = 0; i < maxtries; i++) {  
36.     // status = inb(STATUSREG); /* au cas ou l'ordi irait plus vite que le péripherique */
37.     // if((status & nBUSY) == 0)  
38.     //     break;
39.     //    }
40.     outb_p((ctl | STROBE), CONTROLREG); /* Envoi d'un strone haut bas */
41.     outb_p((ctl &= ~STROBE), CONTROLREG);
42.     outb_p(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
43. }
45. unsigned char data_read (void) {
46.     unsigned char data;
47.     unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
48.     unsigned char ctl = oldctl | DIRECTION; /* on met le flag direction à 1: on est lecture */
49.     outb_p(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
50.     data = inb(BASEREG); /* on récupère l'octet dans le port */
51.     outb_p(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
52.     return data;
53. }
55. char *bin_to_char(unsigned char num)
56. {
57.   int i;
58.   static char buf[9];
60.   buf[8] = '\0';
62.   for (i = 0; i < 8; i++) {
63.     if (num & (1 << i))
64.       buf[7-i] = '1';
65.     else
66.       buf[7-i] = '0';
67.   }
68.   return buf;   
69. }
71. int main (int argc, char * argv[]) {
73.     int i;
74.     if (ioperm(BASEPORT, 3, 1)) {
75. perror("can't set IO permissions!" );
76. return -1;
77.     }
78.  
79.     // change l'état de l'afficheur de 0FF a ON toutes les 5s
80.     for (i=0;i<6;i++) {
81. data_write(0x0F);
82. sleep(5);
83. data_write(0x0B);
84. sleep(5);
85.     }
86.    
87.      // déja si la ca marche on peut aussi tester avec  
88.     // printf("Donnée lue: %s\n", bin_to_char(data_read()));
90.     if (ioperm(BASEPORT, 3, 0)) {
91. perror("can't reset IO permissions!" );
92. return -1;
93.     }
94.     return 0;
95. }

1. void data_write(unsigned char data) {
2.     unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
3.     unsigned char ctl = oldctl & ~DIRECTION; /* on met le flag direction à 0: on est en écriture */
4.     outb_p(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
5.     outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
6.     outb_p((ctl | STROBE), CONTROLREG); /* Envoi d'un strone haut bas */
7.     outb_p((ctl & ~STROBE), CONTROLREG);
8.     outb_p(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
9. }

1. void data_write(unsigned char data) {
2.     unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
3.     unsigned char flag = DIRECTION;
4.     unsigned char ctl = oldctl & ~flag; /* on met le flag direction à 0: on est en écriture */
5.     outb_p(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
6.     outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
7.     flag = STROBE;
8.     outb_p((ctl | flag), CONTROLREG); /* Envoi d'un strone haut bas */
9.     outb_p((ctl & ~flag), CONTROLREG);
10.     outb_p(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
11. }

void data_write(unsigned char data) {
  unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
  unsigned char flag = DIRECTION;
  unsigned char ctl = oldctl & ~flag; /* on met le flag direction à 0: on est en écriture */
  printf("outb_p : ctl \n" );
  outb_p(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
  printf("outb_p : data \n" );
  outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  flag = STROBE;
  outb_p((ctl | flag), CONTROLREG); /* Envoi d'un strone haut bas */
  outb_p((ctl & ~flag), CONTROLREG);
  outb_p(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
}

1. void data_write(unsigned char data) {
2.   unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
3.   unsigned char ctl = oldctl & 0xDF; /* on met le flag direction à 0: on est en écriture */
4.   printf("outb_p : ctl \n" );
5.   outb_p(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
6.   printf("outb_p : data \n" );
7.   outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
8.   ctl |= 0x01:
9.   outb_p(ctl, CONTROLREG); /* Envoi d'un strone haut bas */
10.   ctl &= 0xFE;
11.   outb_p(ctl, CONTROLREG);
12.   outb_p(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
13. }

void data_write(unsigned char data) {
 
  unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
 
  unsigned char flag = DIRECTION;
 
  unsigned char ctl = oldctl & ~flag; /* on met le flag direction à 0: on est en écriture */
 
  printf("outb : ctl \n" );
 
  outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur avec pause jusqu'a achévement */
 
  printf("outb : data \n" );
  usleep(200000);
  outb(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
  usleep(300000);
  flag = STROBE;
  printf("validation \n" );
  outb((ctl | flag), CONTROLREG); /* Envoi d'un strone haut bas */
  outb((ctl & ~flag), CONTROLREG);
  outb(oldctl, CONTROLREG); /*restauration à la valeur d'entrée */
}

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
6. #define BASEPORT 0x378
7. #define DATAREG     BASEPORT+0
8. #define STATUSREG   BASEPORT+1
9. #define CONTROLREG  BASEPORT+2
12. void data_write(unsigned char data) {
13.     unsigned char oldctl = inb(CONTROLREG); /* On sauve la valeur courante */
14.     unsigned char ctl = oldctl;
15.     ctl &= 0xF0;  // On touche pas au valeurs hautes, on vire les basses
16.     ctl |= 0x0B; // On force le bas à 1011 ce qui va mettre tout à 0 en sortie
17.     ctl &= 0xDF; // 0n met le flag direction à 0: on est en écriture
18.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
19.     // usleep?
20.     outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
21.     // si outb_p ne plante pas
22.     ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
23.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
24.     // usleep?
25.     ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
26.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
27.     //usleep?
28.     outb(oldctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
29. }
31. int main (int argc, char * argv[]) {
33.     int i;
34.     if (ioperm(BASEPORT, 3, 1)) {
35. perror("can't set IO permissions!" );
36. return -1;
37.     }
38.  
39.     // change l'état de l'afficheur de 0FF a ON toutes les 5s
40.     for (i=0;i<6;i++) {
41. data_write(0x0F);
42. sleep(5);
43. data_write(0x0B);
44. sleep(5);
45.     }
47.     if (ioperm(BASEPORT, 3, 0)) {
48. perror("can't reset IO permissions!" );
49. return -1;
50.     }
51.     return 0;
52. }

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. // delai d'attente en ms  
13. void delay(int mstime) {
14.     usleep(mstime * 1000);
15. }
17. // Initialisation des registres, sauvegarde du registre de controle
18. unsigned char init_port() {
19.     unsigned char oldctl, ctl;
20.     // 1) mise à 0 des datas. Ainsi, même si le 2 déclenche un strobe, il n'aura pas d'effet
21.     outb_p(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
22.     // si outb_p ne plante pas
23.     // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
24.     oldctl = ctl = inb(CONTROLREG);
25.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
26.     ctl |= 0x0B;  // On force le bas à 1011 ce qui va mettre tout à 0 en sortie pour les valeurs de controle
27.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
28. outb(ctl, CONTROLREG);
29. delay(2);
30.     }
31.     return oldctl;
32. }
34. // Restauration du registre de controle
35. void restore_port(unsigned char oldctl) {
36.     unsigned char ctl;
37.     // 1) mise à 0 des datas. Ainsi, même si le 2 déclenche un strobe, il n'aura pas d'effet
38.     outb_p(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
39.     // si outb_p ne plante pas
40.     // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
41.     ctl = inb(CONTROLREG);
42.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
43. outb(oldctl, CONTROLREG);
44. delay(2);
45.     }
46. }
48. // Envoi de commandes et données SPP -> LCD
49. void data_write(unsigned char data) {
50.     unsigned char oldctl, ctl;
51.     // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
52.     oldctl = ctl = inb(CONTROLREG);
53.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
54.     ctl |= 0x0B;  // On force le bas à 1011 ce qui va mettre tout à 0 en sortie pour les valeurs de controle
55.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
56. outb(ctl, CONTROLREG);
57. delay(2);
58.     }
59.  
60.     // 2) Mise de la valeur dans le registre data
61.     outb_p(data, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
62.     // si outb_p ne plante pas
63.     // 3) envoi d'un strobe pour signaler au LCD une commande
64.     ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
65.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
66.     delay(2);
67.     ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
68.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
69.     delay(2);
70. }
72. // Lecture de donnée LCD -> SPP
73. // ram positionné: on lit la valeur de la donnée en ram du LCD a l'adresse courante. associé à RS a 1 en sortie
74. // 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
75. unsigned char data_read(int ramdata) {
76.     unsigned char data;
77.     // 1) mise à 0 des datas. C'est peut être inutile
78.     outb_p(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
79.     // si outb_p ne plante pas
80.     // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
81.     oldctl = ctl = inb(CONTROLREG);
82.     ctl &= 0xF0;  // Bits du bas à 0
83.     ctl |= 0x20;  // Bits du haut: direction mise à 1 (écriture)   
84.     if (ramdata) {
85. ctl |= 0x03;  // On force le bas à 0001 ce qui va mettre RW et RS a 1 en sortie et le reste à 0   
86.     } else {
87. ctl |= 0x09;  // On force le bas à 1001 ce qui va mettre RW a 1 en sortie et le reste à 0   
88.     }
89.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
90. outb(ctl, CONTROLREG);
91. delay(2);
92.     }
93.     // 3) envoi d'un strobe pour signaler au LCD une commande
94.     ctl &= 0xFE; // registre strobe mis a 0 => signal strobe haut en sortie
95.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
96.     delay(2);
97.     ctl |= 0x01; // registre strobe mis a 1 => signal strobe bas en sortie
98.     outb(ctl, CONTROLREG); /* écriture du registre de controle avec cette valeur */
99.     delay(2);
100.     // 4) lecture des données
101.     if (ramdata) { // temps de lecture en RAM du LCD   
102. delay(1);
103.     }
104.     data = inb(BASEREG);
105.     return data;
106. }
108. // Commandes admissibles par le LCD
109. // Le bit non nul le plus haut détermine la commande
110. // A priori, 00000000 -> Rien
111. // 00000001 -> LCD Clear
112. void LCD_Clear() {
113.     unsigned char command = 0x01;  // Clear command
114.     data_write(command);
115.     delay(2);
116. }
117. // 0000001x -> LCD Home
118. void LCD_Home() {
119.     unsigned char command = 0x02;  // Home command
120.     data_write(command);
121.     delay(2);
122. }
123. // 000001xx -> LCD EntryMode
124. void LCD_EntryMode(int lr, int shiftt) {
125.     unsigned char command = 0x04;  // Entry Mode command
126.     if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
127.     if (shift)   command |= 0x01; // Shift visible   
128.     data_write(command);
129.     delay(2);
130. }
131. // 00001xxx -> LCD Display
132. void LCD_Display(int on, int cursor, int blink) {
133.     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
137.     data_write(command);
138.     delay(2);
139. }
140. // 0001xxxx -> LCD CursorMove (et Display Move)
141. // 001xxxxx -> LCD Mode
142. void LCD_Mode(int size8, int line2, int bigfont) {
143.     unsigned char command = 0x20;  // Mode command
144.     if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
145.     if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
146.     if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
147.     data_write(command);
148.     delay(2);
149. }
150. // 01xxxxxx -> LCD Set CGRAM
151. // 1xxxxxxx -> LCD Set DDRAM
153. // Routines d'un peu plus haut niveau
154. // On écrit un caractère
155. void LCD_WriteChar(char c) {
156.     data_write(c);
157. }
159. // On écrit une chaine
160. void LCD_WriteString(char *s) {
161.     unsigned char oldctl, ctl;
162.     // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
163.     oldctl = ctl = inb(CONTROLREG);
164.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
165.     ctl |= 0x0B;  // On force le bas à 1011 ce qui va mettre tout à 0 en sortie pour les valeurs de controle
166.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
167. outb(ctl, CONTROLREG);
168. delay(2);
169.     }
170.     while (*s) {
171. // Mise du caractère dans le registre data
172. outb_p(*s, DATAREG);
173. // si outb_p ne plante pas
174. // 3) envoi d'un strobe pour signaler au LCD une commande
175. ctl &= 0xFE;
176. outb(ctl, CONTROLREG);
177. delay(2);
178. ctl |= 0x01;
179. outb(ctl, CONTROLREG);
180. delay(2);
181. s++;
182.     }
183. }
184. // Configuration initiale
185. void LCD_SoftReset() {
186.     // D'abord, 3 LCD_Mode avec la valeur correcte pour bit8
187.     LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
188.     delay(5);
189.     LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
190.     delay(2);
191.     LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
192.     delay(2);
193.     // Maintenant les parametres seront pris en compte
194.     LCD_Mode(1,1,0); // Mode 8 bits data, 2 lines, 5x8 font
195.     // les valeurs qui viennent d'être passé seront inchangeables dorénavant
196.     LCD_Display(0, 0, 0); // Display Off
197.     LCD_Clear(); // Display Clear
198.     LCD_EntryMode(1, 0); // Left-Right, no shift
199.     // Fin de la séquence de reset soft
200. }
203. int main (int argc, char * argv[]) {
204.     unsigned char ctl;
205.     if (ioperm(BASEPORT, 3, 1)) {
206. perror("can't set IO permissions!" );
207. return -1;
208.     }
209.     ctl = init_port();
211.    
212.     // Par défaut le hard reset de mise sous tension fait comme si on avait fait un SoftReset  
213.     // avec les parametres suivants en fin de séquence:
214.     // LCD_Mode(1,1,0);
215.     // LCD_Display(0, 0, 0);  
216.     // LCD_EntryMode(1, 0);
218.     // Décommenter la ligne suivante si tu veux être en mode 2 lignes
219.     //* LCD_SoftReset(); */
221.     // A ce stade, on est prêt a utiliser le LCD
222.     LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink
223.     // On peut afficher du texte
224.     LCD_WriteString("Jovalise" );
226.     restore_port(ctl);
227.     if (ioperm(BASEPORT, 3, 0)) {
228. perror("can't reset IO permissions!" );
229. return -1;
230.     }
231.     return 0;
232. }

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. // delai d'attente en ms  
13. void delay(int mstime) {
14.     usleep(mstime * 1000);
15. }
17. // Initialisation des registres, sauvegarde du registre de controle
18. unsigned char init_port() {
19.     unsigned char oldctl, ctl;
20.     // 1) mise à 0 des datas. Ainsi, même si le 2 déclenche un strobe, il n'aura pas d'effet
21.     outb_p(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
22.     // si outb_p ne plante pas
23.     // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
24.     oldctl = ctl = inb(CONTROLREG);
25.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
26.     ctl |= 0x0B;  // On force le bas à 1011 ce qui va mettre tout à 0 en sortie pour les valeurs de controle
27.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
28. outb(ctl, CONTROLREG);
29. delay(2);
30.     }
31.     return oldctl;
32. }
34. // Restauration du registre de controle
35. void restore_port(unsigned char oldctl) {
36.     unsigned char ctl;
37.     // 1) mise à 0 des datas. Ainsi, même si le 2 déclenche un strobe, il n'aura pas d'effet
38.     outb_p(0x00, DATAREG); /* ecriture de l'octet avec pause jusqu'a achévement*/
39.     // si outb_p ne plante pas
40.     // 2) Mise a jour du registre des valeurs des pins de controle si necessaire
41.     ctl = inb(CONTROLREG);
42.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
43. outb(oldctl, CONTROLREG);
44. delay(2);
45.     }
46. }
48. // Envoi de commandes et données SPP -> LCD
49. void control_write(int rs, int rw, int e) {
50.     unsigned char oldctl, ctl;
51.     // 1) Mise a jour du registre des valeurs des pins de controle si necessaire
52.     oldctl = ctl = inb(CONTROLREG);
53.     ctl &= 0xD0;  // Bits du haut: direction mise à 0 (écriture) et bits du bas à 0
54.     ctl |= 0x0B;  // On force le bas à 1011 ce qui va mettre tout à 0 en sortie pour les valeurs de controle
55.     if (rs) ctl &= 0xF7;
56.     if (rw) ctl &= 0xFD;
57.     if (e)  ctl &= 0xFE;
58.     if (oldctl != ctl) { // on met pas a jour si c'est déjà bon
59. outb(ctl, CONTROLREG);
60. delay(2);
61.     }
62. }
65. int main (int argc, char * argv[]) {
66.     unsigned char ctl;
67.     char buffer[1024];
68.     int rs, rw, e;
69.     int i;
71.     if (ioperm(BASEPORT, 3, 1)) {
72. perror("can't set IO permissions!" );
73. return -1;
74.     }
75.     ctl = init_port();
77.     // boucle de test
78.     printf("Debut du test\n" );
79.     while(1) {
80. rs = rw = e = 0;
81. for (i=0; i<3; i++) {
82.     buffer[i] = 0;
83. }
84. printf("Choisissez les pins a a la valeur 1\n" );
85. printf("S pour RS, W pour RW et E pour E\n" );
86. printf("On peut combiner les 3 lettres: SEW etc.\n" );
87. printf("Ou tapez Q pour quitter\n" );
88. gets(buffer);
89. buffer[3] = 0;
90. if ( buffer[0] == 'Q' || buffer[0] == 'q'
91.      ||  buffer[1] == 'Q' || buffer[1] == 'q'
92.      ||  buffer[2] == 'Q' || buffer[2] == 'q')
93.     break;  // sortie de la boucle
95. if ( buffer[0] == 'S' || buffer[0] == 's'
96.      ||  buffer[1] == 'S' || buffer[1] == 's'
97.      ||  buffer[2] == 'S' || buffer[2] == 's')
98.     rs = 1;
100. if ( buffer[0] == 'W' || buffer[0] == 'w'
101.      ||  buffer[1] == 'W' || buffer[1] == 'w'
102.      ||  buffer[2] == 'W' || buffer[2] == 'w')
103.     rw = 1;
105. if ( buffer[0] == 'E' || buffer[0] == 'e'
106.      ||  buffer[1] == 'E' || buffer[1] == 'e'
107.      ||  buffer[2] == 'E' || buffer[2] == 'e')
108.     e = 1;
110. printf("\nMise a jours de RS RW E\n" );
111. printf("               [%d  %d  %d]\n\n", rs, rw, e);
112. control_write(rs, rw, e);
113. printf("Tapez Q pour quitter et retour chariot pour recommencer\n" );
114. gets(buffer);
115. buffer[1] = 0;
116. if ( buffer[0] == 'Q' || buffer[0] == 'q' )
117.     break;  // sortie de la boucle
118. printf("\n\n\n" );
119.     }
120.     printf("Fin du test\n" );
122.     restore_port(ctl);
123.     if (ioperm(BASEPORT, 3, 0)) {
124. perror("can't reset IO permissions!" );
125. return -1;
126.     }
127.     return 0;
128. }

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/io.h>
 
#define PORTADDRESS 0x378+2
 
int main (int argc, char * argv[])
{
  char * endptr = NULL;
  long i;
  if(ioperm(PORTADDRESS, 3, 1)) {
    perror("ioperm" );
    return 1;
  }
  i = strtol(argv[1], &endptr , 16);
   outb(255, PORTADDRESS);
  usleep(20000);
  outb(i, PORTADDRESS);
  printf("%d \n" , i);
  return 0;
}

void control_write(int rs, int rw, int e) {
  unsigned char oldctl, ctl;
  // 1) Mise a jour du registre des valeurs des pins de controle si necessaire                                                               
  oldctl  = inb(CONTROLREG);
  ctl = 0xFF;  // 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 (rs) ctl = 0x07;
  if (rw) ctl = ctl & 0xFD;
  if (e)  ctl = ctl & 0xFE;
  if (oldctl != ctl) { // on met pas a jour si c'est déjà bon                                                                                
    outb(ctl, CONTROLREG);
    delay(2);
  }
}

void control_write(int rs, int rw, int e) {
  unsigned char oldctl, ctl;
  // 1) Mise a jour du registre des valeurs des pins de controle si necessaire                                                               
  oldctl  = inb(CONTROLREG);
  ctl = 0xFF;  // 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 (rs) ctl = 0x07;
  if (rw) ctl &= 0xFD;
  if (e)  ctl &= 0xFE;
  if (oldctl != ctl) { // on met pas a jour si c'est déjà bon                                                                                
    outb(ctl, CONTROLREG);
    delay(2);
  }
}