1. void wait_LCD() {
3.   unsigned char control = GetControl();
4.   unsigned char data;
6.  
7.   while (data) {
8.    
9.     Set_RS(control);
10.     usleep(1);
11.    
12.     usleep(1);
13.     SetData(0xFF);         // Set All Pins to FF before read
14.     Set_RW(control);
15.     Set_E(control);        // Strobe command to LCD
16.     usleep(4);
17.     Clear_E(control);
18.    
19.     data = GetData();      // Read Data
20.     data &= 0x80;          // Get high bit
21.    
23.    
24.   }
25.   Clear_E(control);
26.   usleep(1);
27.   Clear_RW(control);      // Avoid Bus conflict
28.   Set_RS(control);
29.   usleep(1);
30. }

1. void wait_LCD() {             // Cas RS=0, (Reception et) RW = 1                                                                                                                                                     
2.   unsigned char busy = 0x80; // Mask for D7                                                                                                                                                                         
4.   do {
5.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]                                                                                                                               
6.     busy &= inb(DATAREG);
7.     printf("DATAREG: %x\n", inb(DATAREG));
8.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]                                                                                                                                   
9.     usleep(1);              // Wait before next strobe: 500 ns                                                                                                                                                       
10.   } while (busy?1:0);
11. }

1. void wait_LCD() {             // Cas RS=0, (Reception et) RW = 1                                                                             
2.   unsigned char control;
3.   unsigned char busy = 0x80; // Mask for D7                                                                                                 \
4.                                                                                                                                            
5.   do {
6.     outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]                                                      \
7.                                                                                                                                            
8.     control = GetControl() ;
9.     control &=0xFD;
10.     control &=0xFE;
11.     outb(control, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]                                                   \
12.                                                                                                                                            
13.     usleep(1);              // Wait before next strobe: 500 ns                                                                              \
14.                                                                                                                                            
15.     busy = 0x80; // Mask for D7                                                                                                             \
16.                                                                                                                                            
17.     busy &= inb(DATAREG);
18.     printf("DATAREG: %x\n", inb(DATAREG));
20.     usleep(1);              // Wait before next strobe: 500 ns                                                                              \
21.                                                                                                                                            
22.     outb(0x01, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]                                                           \
23.                                                                                                                                            
27.   } while (busy?1:0);
28.   printf("\n" );
29. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/io.h>
5. #include <time.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
11. #define STROBE 0
12. #define CTRL 1
13. #define READ 2
14. unsigned char clear_bit(int bit, unsigned char reg) {
15.   switch (bit) {     
16.   case 0 : { // STROBE
17.     reg &= 0xFE;   
20.     break;
21.   }
22.  
23.   case 1 : { //CTRL   
24.     reg &= 0xFD;
25.    
27.     break;
28.   }
29.   case 2 : { //READ
30.         reg &= 0xF7;
33.     break;
34.   }
35.   default :
36.     return -1;
37.   }
38.   return reg;
39. }
40. unsigned char set_bit(int bit, unsigned char reg) {
42.   switch (bit) {     
43.   case 0 : { // STROBE
44.     reg |= 0x01;
45.    
46.     break;
47.   }
48.  
49.   case 1 : { //CTRL   
50.     reg |= 0x02;
51.    
52.     break;
53.   }
54.   case 2 : { //READ
55.     reg |= 0x08;
56.    
57.     break;
58.   }
59.   default :   
60.     return -1;
61.   }
62.   return reg;
63. }
64. unsigned char WriteCommon (unsigned char value, unsigned char reg) {
66.   unsigned char data = 0x00;
67.   reg = clear_bit(READ, reg);
68.   outb(reg, CONTROLREG);
69.   usleep(1);
70.   value = value & 0x0F;
71.   value = value << 4;
72.   data = data & 0x0F;
73.   data = data | value;
74.   outb(data, DATAREG);
75.   reg = set_bit(STROBE, reg);
76.   outb(reg, CONTROLREG);
77.   usleep(4.5);
78.   reg = clear_bit(STROBE, reg); 
79.   outb(reg, CONTROLREG);
80.   usleep(4.5);
81.   return reg;
82.  
83. }
84. unsigned char WriteData (unsigned char value, unsigned char reg) {
85.   reg = set_bit(CTRL, reg);
86.   outb(reg, CONTROLREG);
87.   reg = WriteCommon(value >> 4, reg);
88.   reg = WriteCommon(value, reg); 
89.   return reg;
90. }
91. unsigned char WriteCtrl (unsigned char value, unsigned char reg) {
92.   reg = clear_bit(CTRL, reg);
93.   outb(reg, CONTROLREG);
94.   reg = WriteCommon(value, reg);
95.   return reg;
96. }
97. unsigned char WriteLcd (char * value, unsigned char reg) {
98.   while (*value) {
99.     reg = WriteData(*value++, reg);
100.     usleep(1);
101.   }
102.   return reg;
103. }
104. unsigned char InitLcd (unsigned char reg) {
105.   reg = WriteCtrl(0x03, reg);
106.   usleep(4500);   
107.   reg = WriteCtrl(0x03, reg);
108.   usleep(45);   
109.   reg = WriteCtrl(0x03, reg);
110.   usleep(4.5);     
111.   reg = WriteCtrl(0x01, reg);
112.   usleep(4.5);
113.   reg = WriteCtrl(0x06, reg);
114.   usleep(4.5);
115.   reg = WriteCtrl(0x38, reg);
116.   usleep(4.5);
117.   reg = WriteCtrl(0x0F, reg);
118.   usleep(4.5);
120.   return reg;
121. }
122. int main (int argc, char * argv[]) {
123.   unsigned char control = 0x00;
124.   if (ioperm(BASEPORT, 3, 1)) {
125.     perror("can't set IO permissions!" );
126.     return -1;
127.   }
129.  
130.   control = InitLcd(control);
131.   printf("main: InitLcd....with control = %x\n", control );
132.   control = WriteLcd(argv[1], control);
133.     printf("main: WriteLcd....with control = %x\n", control);
134.   if (ioperm(BASEPORT, 3, 0)) {
135.     perror("can't reset IO permissions!" );
136.     return -1;
137.   }
138.   return control;
139. }

/* Ce programme affiche les information de /proc/meminfo sur un L'afficheur LCD */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "./libparalcd.h"
#include <time.h>
int main (void) {
 
  char date[20] = "date(20)\0";
  char hour[9] = "hour(8)\0";
  char hostname[13] = "hostname(12)\0";
 
  char dummy[4096] = "\0";
  
  char file[] = "/proc/meminfo\0";
  FILE *fp;
  FILE *cpufp;  
  char valeur[10] = "\0";
  char name[10] = "\0";
  char label_mem[]  = "mem : \0";
  char label_cpu[]  = "cpu : \0";
  
  float mem_total,  mem_free, mem_used, mem_swap = 0.0;
    
  time_t current_date = time(NULL);
  
  int i = 0;
    
  char *p_conv = NULL;
  
  char value_total[14] = "\0";
  char value_cpu[14] = "\0";
  if (system(dummy)) return (1);
      
  
  if (ioperm(BASEPORT, 3, 1)) {
    perror("can't set IO permissions!" );
    return -1;
  }
     
  InitPort();
 
  while (1) {    
    
    LCD_Init();   
    usleep(200);
    
    LCD_ClearDisplay();
    SetPosition_LCD(1, 1);
    usleep(1);      
    LCD_WriteString(date);
    usleep(1);      
    SetPosition_LCD(2, 1);
    usleep(1);  
    LCD_WriteString(hostname);         
    usleep(1);        
    SetPosition_LCD(2, 13);      
    usleep(1);
    LCD_WriteString(hour);
    usleep(1);
    SetPosition_LCD(3, 1); 
    usleep(1);
    LCD_WriteString(label_cpu);
    usleep(1);
    LCD_WriteString(value_cpu);    
    usleep(1);
    SetPosition_LCD(4, 1);
    usleep(120);
    LCD_WriteString(label_mem);
    LCD_WriteString(value_total);
    SetPosition_LCD(3, 12);
    port_clear();
    usleep(500000);     
        
    fp = fopen(file, "r" );
    if (!fp) {
      perror("/proc/meminfo" );
      return -1;
    }
     
    for (i = 1; i <= 13 ; i++) {
      fscanf(fp, "%s%s%s\n", name, valeur, dummy);   
      current_date = time(NULL);
 
      switch (i) {
 
      case 1 : {
       
    mem_total = (float)strtol(valeur, &p_conv, 10);     
    break;
      }
      case 2 : {
     
    mem_free = (float)strtol(valeur, &p_conv, 10);    
    break;
      }
    
      case 12 : {
        
    mem_swap = (float)strtol(valeur, &p_conv, 10);
    break;
      }
    
 
      case 13 : {
    
    
    mem_swap = ((mem_swap - (float)strtol(valeur, &p_conv, 10))*100)/mem_swap;
    mem_used = (((mem_total-mem_free)*100)/mem_total)+mem_swap;
    sprintf(value_total, "%f", mem_used);
    
    break;
      }
      }
    }
    fclose(fp);     
    gethostname(hostname, sizeof(hostname));    
    usleep(1);
    strcpy(value_cpu, "     " );
    cpufp = popen("ps aux| awk 'NR > 0 { s +=$3 }; END {print s}'","r" );
    fread(value_cpu, 1, sizeof(value_cpu)-1, cpufp);
    fclose(cpufp);
 
    current_date = time(NULL);
    strftime(date, sizeof(date), "%a %d %b %Y", localtime(&current_date));
    strftime(hour, sizeof(hour), "%H:%M:%S", localtime(&current_date));    
    usleep(350000);         
  } 
  if (ioperm(BASEPORT, 3, 0)) {
    perror("can't reset IO permissions!" );
    return -1;
  }
  return 0;
}