#include "./at89x51.h"
#define LCD_data P2
#define LCD_D7   P2_7
#define LCD_rs   P1_0
#define LCD_rw   P1_1
#define LCD_en   P1_2
 
void LCD_init()
{
  LCD_data = 0x38;     //Function set: 2 Line, 8-bit, 5x7 dots                  
  LCD_rs   = 0;        //Selected command register                              
  LCD_rw   = 0;        //We are writing in data register                        
  LCD_en   = 1;        //Enable H->L                                            
  LCD_en   = 0;
  LCD_busy();          //Wait for LCD to process the command                    
  LCD_data = 0x0F;     //Display on, Curson blinking command                    
  LCD_rs   = 0;        //Selected command register                              
  LCD_rw   = 0;        //We are writing in data register                        
  LCD_en   = 1;        //Enable H->L                                            
  LCD_en   = 0;
  LCD_busy();          //Wait for LCD to process the command                    
  LCD_data = 0x01;     //Clear LCD                                              
  LCD_rs   = 0;        //Selected command register                              
  LCD_rw   = 0;        //We are writing in data register                        
  LCD_en   = 1;        //Enable H->L                                            
  LCD_en   = 0;
  LCD_busy();          //Wait for LCD to process the command                    
  LCD_data = 0x06;     //Entry mode, auto increment with no shift               
  LCD_rs   = 0;        //Selected command register                              
  LCD_rw   = 0;        //We are writing in data register                        
  LCD_en   = 1;        //Enable H->L                                            
  LCD_busy();
}

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/io.h>
 
#define PORTADDRESS 0x378
#define DATA PORTADDRESS+0
#define STATUS PORTADDRESS+1
#define CONTROL PORTADDRESS+2
 
char init[10];
int count;
int len;
 
void initlcd(void) {
  init[0] = 0x0F;
  init[1] = 0x01;
  init[2] = 0x38;
 
  outb(inb(CONTROL) & 0xDF, CONTROL);
 
  outb(inb(CONTROL) | 0x08, CONTROL);
 
  for (count = 0; count <= 2; count++) {
    outb(init[count], DATA);
    outb(inb(CONTROL) | 0x01, CONTROL);
    usleep(2);
    outb(inb(CONTROL) & 0xFE, CONTROL);
    usleep(2);
  }
  outb(inb(CONTROL) & 0xF7, CONTROL);
}
 
void sendlcd(char text[10]) {
  len = strlen(text);
  for (count = 0; count < len; count++)
    {
      outb(text[count], DATA);
 
      outb(inb(CONTROL) | 0x01, CONTROL);
      usleep(1);
      outb(inb(CONTROL) & 0xFE, CONTROL);
      usleep(1);
    }
}
 
void poslcd(int pos) {
  outb(inb(CONTROL) | 0x08, CONTROL);
  outb(128+pos, DATA);
  outb(inb(CONTROL) | 0x01, CONTROL);
  usleep(2);
  outb(inb(CONTROL) & 0xFE, CONTROL);
  usleep(2);
  outb(inb(CONTROL) & 0xF7, CONTROL);
}
 
void main (void)
{
  if(ioperm(PORTADDRESS, 3, 1)) {
    perror("ioperm" );
    exit(1);
  }
 
  initlcd();
  sendlcd("Bonjour" );
  poslcd(0x40);
  sendlcd("le monde !" );
}

1. void LCD_busy()
2. {
3.      LCD_D7   = 1;           //Make D7th bit of LCD as i/p
4.      LCD_en   = 1;           //Make port pin as o/p
5.      LCD_rs   = 0;           //Selected command register
6.      LCD_rw   = 1;           //We are reading
7.      while(LCD_D7){          //read busy flag again and again till it becomes 0
8.            LCD_en   = 0;     //Enable H->L
9.            LCD_en   = 1;
10.      }
11. }

1. // défini globalement
2. #define LCD_en LP_PIN01
3. #define LCD_rs  LP_PIN17
4. #define LCD_rw LP_PIN16
5. #define LCD_DATA_PINS LP_DATA_PINS
6. #define LCD_D0 LP_PIN02
7. ...
8. #define LCD_D7 LP_PIN09
9. // Dans le main on met par défaut les valeurs en output
10. pin_output_mode(LP_PIN01|LP_DATA_PINS|LP_PIN14|LP_PIN16|LP_PIN17);
12. // et donc, à mes erreurs près
13. void LCD_busy()
14. {
15.      set_pin(LCD_D7);
16.      set_pin(LCD_en);
17.      clear_pin(LCD_rs);
18.      set_pin(LCD_rw);
19.      pin_input_mode(LP_DATA_PINS);
20.      while(pin_is_set(LCD_D7)){          //read busy flag again and again till it becomes 0
21.            clear_pin(LCD_en);     //Enable H->L
22.            set_pin(LCD_en); 
23.      }
24.      pin_output_mode(LP_DATA_PINS); // reset to default mode
25. }

/****************************/
/* filename     : paralcd.c */
/* language     : C         */
/* Date         : 2011/10/27*/
/* Author       : jovalise  */
/* version      : 0.0.0alpha*/
/****************************/
/* Description  : paralcd display text from command line arguments on Xiamen Ocular GDM2004D connected to LPT1 */
/****************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <parapin.h>
#include <sys/io.h>
 
#define BASEPORT 0x378
 
int main (int argc, char * argv[])  
 
{
  
  int parapin_init_success = 0;
 
  if (argc == 1) 
    
    {
      
      printf("Usage: paralcd prend au moins un argument. \n" );
      return 1;
    }
  
  
  if(ioperm(BASEPORT, 3, 1)) 
    
    {
      
      perror("paralcd::ioperm" );
      return 1;
 
    }
  
  
 
  parapin_init_success = pin_init_user(BASEPORT);
 
  if (parapin_init_success != 0)
 
    {
 
      printf("Echec de l'initialisation de parapin. \n" );
      
    }
  
  
  pin_output_mode(LP_DATA_PINS);
  
  
  return 0;
 
}

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <parapin.h>
5. #include <sys/io.h>
7. #define BASEPORT 0x378
9. // correspondances LCD PARA pin à pin
10. // pins en output seulement
11. #define LCD_en LP_PIN01
12. #define LCD_rs  LP_PIN17
13. // Si on a connecté le pin LCD 5 au pin 16 du PP et non pas au 14
14. #define LCD_rw LP_PIN16
16. // pins BIDI
17. #define LCD_D0 LP_PIN02
18. #define LCD_D1 LP_PIN03
19. #define LCD_D2 LP_PIN04
20. #define LCD_D3 LP_PIN05
21. #define LCD_D4 LP_PIN06
22. #define LCD_D5 LP_PIN07
23. #define LCD_D6 LP_PIN08
24. #define LCD_D7 LP_PIN09
25. // global pins BIDI
26. #define LCD_DATA_PINS LP_DATA_PINS
28. void LCD_init();
29. void LCD_busy();
30. void LCD_senddata(unsigned char var);
31. void LCD_sendstring(unsigned char *var);
33. int main (int argc, char * argv[]) {
34.   int parapin_init_success = 0;
36.   if (argc == 1)  {
37.       printf("Usage: paralcd prend au moins un argument. \n" );
38.       return 1;
39.   }
40.  
41.   if (ioperm(BASEPORT, 3, 1))  {
42.       perror("paralcd::ioperm" );
43.       return 1;
44.   }
45.  
46.   parapin_init_success = pin_init_user(BASEPORT);
47.   if (parapin_init_success != 0) {
48.      printf("Echec de l'initialisation de parapin. \n" );
49.   }
50.  
51.   pin_output_mode(LP_DATA_PINS|LP_SWITCHABLE_PINS);
52.   LCD_init();
53.   LCD_sendstring("Jovalise" );
54.   clear_pin(LP_DATA_PINS|LP_SWITCHABLE_PINS);  // vu dans les exemples de parapin
55.   return 0;
57. }
59. void LCD_busy()
60. {
61.      set_pin(LCD_D7);
62.      set_pin(LCD_en);
63.      clear_pin(LCD_rs);
64.      set_pin(LCD_rw);
65.      pin_input_mode(LP_DATA_PINS);
66.      while(pin_is_set(LCD_D7)){          //read busy flag again and again till it becomes 0
67.            clear_pin(LCD_en);     //Enable H->L
68.            set_pin(LCD_en);
69.      }
70.      pin_output_mode(LP_DATA_PINS); // reset to default mode
71. }
73. void LCD_init()
74. {
75.   set_pin(0x38);     //Function set: 2 Line, 8-bit, 5x7 dots    Au vu du code de la lib, ça doit marcher ainsi               
76.   clear_pin(LCD_rs);        //Selected command register                               
77.   clear_pin(LCD_rw);        //We are writing in data register                         
78.   set_pin(LCD_en);        //Enable H->L                                             
79.   clear_pin(LCD_en);
80.   LCD_busy();          //Wait for LCD to process the command   
81.                  
82.   set_pin(0x0F);     //Display on, Curson blinking command                     
83.   clear_pin(LCD_rs);        //Selected command register                               
84.   clear_pin(LCD_rw);         //We are writing in data register                         
85.   set_pin(LCD_en);       //Enable H->L                                             
86.   clear_pin(LCD_en);
87.   LCD_busy();          //Wait for LCD to process the command  
88.                  
89.   set_pin(0x01);     //Clear LCD                                               
90.   clear_pin(LCD_rs);        //Selected command register                               
91.   clear_pin(LCD_rw);         //We are writing in data register                         
92.   set_pin(LCD_en);        //Enable H->L                                             
93.   clear_pin(LCD_en);
94.   LCD_busy();          //Wait for LCD to process the command   
95.                  
96.   set_pin(0x06);     //Entry mode, auto increment with no shift               
97.   clear_pin(LCD_rs);     //Selected command register                               
98.   clear_pin(LCD_rw);        //We are writing in data register                         
99.   set_pin(LCD_en);        //Enable H->L                                             
100.   LCD_busy();
101. }
103. void LCD_senddata(unsigned char var)
104. {
105.      set_pin(var);      //Function set: 2 Line, 8-bit, 5x7 dots
106.      set_pin(LCD_rs);        //Selected data register
107.      clear_pin(LCD_rw);        //We are writing
108.      set_pin(LCD_en);        //Enable H->L
109.      clear_pin(LCD_en);
110.      LCD_busy();          //Wait for LCD to process the command
111. }
113. // doit y avoir une taille max pour la string a vérifier par rapport au buffer de l'afficheur
114. void LCD_sendstring(unsigned char *var)
115. {
116.      while(*var)              //till string ends
117.        LCD_senddata(*var++);  //send characters one by one
118. }

1. void LCD_busy()
2. {
3.      LCD_D7   = 1;           //Make D7th bit of LCD as i/p
4.      LCD_en   = 1;           //Make port pin as o/p
5.      LCD_rs   = 0;           //Selected command register
6.      LCD_rw   = 1;           //We are reading
7.      while(LCD_D7){          //read busy flag again and again till it becomes 0
8.            LCD_en   = 0;     //Enable H->L
9.            LCD_en   = 1;
10.      }
11. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <parapin.h>
5. #include <sys/io.h>
7. #define BASEPORT 0x378
9. // correspondances LCD PARA pin à pin
10. #define LCD_E  LP_PIN01
11. #define LCD_D0 LP_PIN02
12. #define LCD_D1 LP_PIN03
13. #define LCD_D2 LP_PIN04
14. #define LCD_D3 LP_PIN05
15. #define LCD_D4 LP_PIN06
16. #define LCD_D5 LP_PIN07
17. #define LCD_D6 LP_PIN08
18. #define LCD_D7 LP_PIN09
19. // Si on a connecté le pin LCD 5 au pin 16 du PP et non pas au 14
20. #define LCD_RW LP_PIN16
21. #define LCD_RS LP_PIN17
23. // Peut etre que faire #define LP_CONTROL_PINS LP_SWITCHABLE_PINS suffit
24. #define LP_CONTROL_PINS (LP_PIN01 | LP_PIN16 | LP_PIN17)
25. //  
26. #define LCD_CNTL LP_CONTROL_PINS
27. // LCD_DATA peut aussi être vu comme un octet
28. #define LCD_DATA LP_DATA_PINS
30. // instructions du LCD
31. #define LCD_iClearDisplay  0x01
32. #define LCD_iReturnHome    0x02
33. #define LCD_iEntryModeSet  0x04
34. #define LCD_iDisplayOnOff  0x08
35. #define LCD_iShift         0x10
36. #define LCD_iFunctionSet   0x20
37. #define LCD_iSetCGRAMAddr  0x40
38. #define LCD_iSetDDRAMAddr  0x80
40. static char LCD_DDRAM_ADDR; // adresse actuelle dans la mémoire DDRAM du LCD
41. static char LCD_LINE; // ligne actuelle sur le LCD
43. void set_lcd_data(unsigned char data) {
44.     // char et non int afin d'être sur de n'écrire qu'un octet
45.     // On utilise le fait que LCD_DATA est aussi visible comme un octet
46.     // pour set-pin
47.     set_pin(data);
48. }
50. void LCD_BusyCheck() {
51.     pin_input_mode(LCD_DATA); // Port de données en lecture  
52.     clear_pin(LCD_RS); // LCD en mode instruction
53.     set_pin(LCD_RW);   // LCD en mode écriture
54.     do {
55.         set_pin(LCD_E);
56.         clear_pin(LCD_E); // créneau pour lancer l'opération
57.     } while (pin_is_set(LCD_D7)); // teste le signal busy
58.     clear_pin(LCD_RW); // LCD en mode lecture (pour éviter les conflits de bus)  
59.     pin_output_mode(LCD_DATA); // Port de données en écriture  
60. }
62. void LCD_SendCommand(unsigned char command, unsigned char data) {
63.      LCD_BusyCheck();
64.      clear_pin(LCD_RW|LCD_RS); // LCD en mode lecture + instruction
65.      set_lcd_data(command|data); // On place la donnée dans le bus
66.      set_pin(LCD_E);
67.      clear_pin(LCD_E); // créneau pour lancer l'opération
68. }
70. void LCD_Init() {
71.     // usleep(2000);  // Pour l'embarque ou on attend après la mise sous tension plus de 1.5 ms (2 ms)
72.     clear_pin(LCD_CNTL);
73.    
74.     set_lcd_data(0x30);
75.     set_pin(LCD_E);
76.     clear_pin(LCD_E); // On envoie 0011xxxx
77.     usleep(5000);     // attente de plus de 4.1 ms (5 ms)
78.    
79.     set_lcd_data(0x30);
80.     set_pin(LCD_E);
81.     clear_pin(LCD_E); // On envoie 0011xxxx
82.     usleep(128000);     // attente de plus de 100 ms (128 ms)
83.    
84.     set_lcd_data(0x30);
85.     set_pin(LCD_E);
86.     clear_pin(LCD_E); // On envoie 0011xxxx
87.     // a partir de maintenant on pourra tester le signal BUSY pour l'attente
89.     LCD_SendCommand(LCD_iFunctionSet,
90.                     0x18);  // Interface 8 bits, 2 lignes, caracteres 5*8 pixels
92.     LCD_SendCommand(LCD_iDisplayOnOff,
93.                     0x04); // Allumer l'écran
95.     LCD_SendCommand(LCD_iEntryModeSet,
96.                     0x06); // sens g. à d., décalage=0
98.     LCD_SendCommand(LCD_iClearDisplay,
99.                     0x00); // effacer l'écran
101.     LCD_DDRAM_ADDR = 0;
102.     LCD_LINE = 1;
103.    
104. }
106. void LCD_SendChar(unsigned char c) {
107.     LCD_BusyCheck();
108.     clear_pin(LCD_RW); // LCD en mode lecture
109.     set_pin(LCD_RS);   // LCD en mode données
110.     set_lcd_data(c);   // place la donnée sur le bus
111.     set_pin(LCD_E);
112.     clear_pin(LCD_E); // créneau pour lancer l'opération
113.     LCD_DDRAM_ADDR++;
114. }
116. void LCD_SendString(unsigned char *string)
117. {
118.      while(*string) {             //till string ends
119.        LCD_SendChar(*string++);  //send characters one by one
120.      }
121. }
123. int main (int argc, char * argv[]) {
124.   int parapin_init_success = 0;
125.   if (argc == 1)  {
126.       printf("Usage: paralcd prend au moins un argument. \n" );
127.       return 1;
128.   }
130.   if (ioperm(BASEPORT, 3, 1))  {
131.       perror("paralcd::ioperm" );
132.       return 1;
133.   }
135.   parapin_init_success = pin_init_user(BASEPORT);
136.   if (parapin_init_success != 0) {
137.      printf("Echec de l'initialisation de parapin. \n" );
138.   }
140.   pin_output_mode(LP_DATA_PINS|LP_CONTROL_PINS);
141.   LCD_Init();
142.   LCD_SendString("Jovalise" );
143.   clear_pin(LP_DATA_PINS|LP_CONTROL_PINS);  // vu dans les exemples de parapin
144.   return 0;
145. }

1. void LCD_Init() {
2.     // usleep(2000);  // Pour l'embarque ou on attend après la mise sous tension plus de 1.5 ms (2 ms)
3.     clear_pin(LCD_CNTL);
4.    
5.     set_lcd_data(0x30);
6.     { //Test
7. pin_input_mode(LCD_DATA);
8. printf("\nData Pin Status: " );
9. printf("%s", pin_is_set(LCD_D7)?"1":"0" );
10. printf("%s", pin_is_set(LCD_D6)?"1":"0" );
11. printf("%s", pin_is_set(LCD_D5)?"1":"0" );
12. printf("%s", pin_is_set(LCD_D4)?"1":"0" );
13. printf("%s", pin_is_set(LCD_D3)?"1":"0" );
14. printf("%s", pin_is_set(LCD_D2)?"1":"0" );
15. printf("%s", pin_is_set(LCD_D1)?"1":"0" );
16. printf("%s", pin_is_set(LCD_D0)?"1":"0" );
17. printf("\n" );
18. printf("Expected: 00110000\n" );
19. pin_output_mode(LCD_DATA);
20. exit 1;
21.     }
22. }

1. void LCD_Init() {
2.     // usleep(2000);  // Pour l'embarque ou on attend après la mise sous tension plus de 1.5 ms (2 ms)
3.     clear_pin(LCD_CNTL); // si ca colle toujours pas, essayer en inversant: set_pin(LCD_CNTL); pour voir
4.  
5.     set_lcd_data(0x30);
6.     { //Test
8. printf("\nData Pin Status: " );
9. printf("%s", (LCD_DATA & LCD_D7)? "1":"0" );
10. printf("%s", (LCD_DATA & LCD_D6)? "1":"0" );
11. printf("%s", (LCD_DATA & LCD_D5)? "1":"0" );
12. printf("%s", (LCD_DATA & LCD_D4)? "1":"0" );
13. printf("%s", (LCD_DATA & LCD_D3)? "1":"0" );
14. printf("%s", (LCD_DATA & LCD_D2)? "1":"0" );
15. printf("%s", (LCD_DATA & LCD_D1)? "1":"0" );
16. printf("%s", (LCD_DATA & LCD_D0)? "1":"0" );
17. printf("\n" );
18. printf("Expected: 00110000\n" );
19. pin_output_mode(LCD_DATA);
20. exit 1;
21.     }
22. }

1. void LCD_Init() {
2.     // usleep(2000);  // Pour l'embarque ou on attend après la mise sous tension plus de 1.5 ms (2 ms)
3.     clear_pin(LCD_CNTL);
4.     clear_pin(LCD_DATA);
5.     set_lcd_data(0x30);
6.     set_pin(LCD_E);
7.     clear_pin(LCD_E);
8.     usleep(200000);
9.     { //Test
10. pin_input_mode(LCD_DATA);
11. printf("\nData Pin Status: " );
12. printf("%s", pin_is_set(LCD_D7)?"1":"0" );
13. printf("%s", pin_is_set(LCD_D6)?"1":"0" );
14. printf("%s", pin_is_set(LCD_D5)?"1":"0" );
15. printf("%s", pin_is_set(LCD_D4)?"1":"0" );
16. printf("%s", pin_is_set(LCD_D3)?"1":"0" );
17. printf("%s", pin_is_set(LCD_D2)?"1":"0" );
18. printf("%s", pin_is_set(LCD_D1)?"1":"0" );
19. printf("%s", pin_is_set(LCD_D0)?"1":"0" );
20. printf("\n" );
21. printf("Expected: 00110000\n" );
22. pin_output_mode(LCD_DATA);
23. exit 1;
24.     }
25. }