Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2610 connectés 

 
 


 Mot :   Pseudo :  
 
 Page :   1  2  3  4  5  6  7  8
Page Suivante
Page Précédente
Bas de page 
Auteur Sujet :

[ Divers / C ] Ecrire pour un afficheur LCD

n°2110125
gilou
Modérateur
Modosaurus Rex
Posté le 07-11-2011 à 12:00:42  profilanswer
 

Reprise du message précédent :
Je suis justement en train d'écrire d'abord la fonction pour lire la position courante.
 
A+,


---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
mood
Publicité
Posté le 07-11-2011 à 12:00:42  profilanswer
 

n°2110128
Profil sup​primé
Posté le 07-11-2011 à 12:19:03  answer
 

Ok, je l'ai écrite.
 
Pour le moment, j'ai fait un import depuis Ada pour exploité ce que j'avais fait.
 
J'affiche du texte défilant de droite à gauche sur la première et seconde ligne, puis je fait clignoté le texte.
A la première itération, ça bouge mais rien ne s'affiche.
les itération suivantes, le texte défilant s'affiche mais pas le texte clignotant.
 

Code :
  1. with Interfaces.C;
  2. use Interfaces;
  3. procedure Lcd_Hello is
  4.  
  5.    procedure Open_Port;
  6.    pragma Import (C, Open_Port, "open_port" );
  7.    procedure Close_Port;
  8.    pragma Import (C, Close_Port, "close_port" );
  9.    procedure LCD_Init;
  10.    pragma Import(C, LCD_Init, "LCD_Init" );
  11.    procedure LCD_ClearDisplay;
  12.    pragma Import(C, LCD_ClearDisplay, "LCD_ClearDisplay" );
  13.    procedure LCD_WriteChar(Text : in C.Char);
  14.    pragma Import (C, LCD_WriteChar, "LCD_WriteChar" );
  15.    procedure LCD_WriteString(Text : in C.Char_Array);
  16.    pragma Import (C, LCD_WriteString, "LCD_WriteString" );
  17.    procedure LCD_Position(Pos : in C.Int);
  18.    pragma Import(C, LCD_Position, "LCD_Position" );
  19.    procedure Port_Clear;
  20.    pragma Import (C, Port_Clear, "port_clear" );
  21.  
  22.    Text1    : String(1..9)  := "Bonjour !";
  23.    Text2    : String(1..11) := "Hardware.fr";
  24.    Size    : C.Int := 1;
  25.    Line    : C.Int := 1;
  26.    Bigfont : C.Int := 0;
  27.    On      : C.Int := 1;
  28.    Cursor  : C.Int := 1;
  29.    Blink   : C.Int := 1;
  30.  
  31.    use Interfaces.C;
  32.    Position1_Right : Int := 18;
  33.    Position2_Right : Int := 82;
  34.    Position1_left : Int := 10;
  35.    Position2_left : Int := 72;
  36.  
  37. begin
  38.    Open_Port;
  39.    LCD_Init;
  40.    delay 0.2;
  41.    LCD_ClearDisplay;
  42.    delay 0.2;
  43.    LCD_Position(Position1_right);
  44.    loop
  45.       for I in 1..9 loop
  46.          LCD_WriteString(To_C(Text1(1..I)));
  47.          delay 0.025;
  48.          Position1_right := Position1_right - 1;
  49.          LCD_Position(Position1_right);
  50.          delay 0.01;
  51.  
  52.       end loop;
  53.       LCD_Position(Position2_right);
  54.       delay 1.0;
  55.       for I in 1..11 loop
  56.          LCD_WriteString(To_C(Text2(1..I)));
  57.          delay 0.025;
  58.          Position2_right := Position2_right - 1;
  59.          LCD_Position(Position2_right);
  60.          delay 0.01;
  61.       end loop;
  62.       delay 1.0;
  63.       for I in 1..5 loop
  64.          delay 0.025;
  65.          LCD_ClearDisplay;
  66.          delay 0.025;
  67.          LCD_Position(Position1_left);
  68.          delay 0.025;
  69.          LCD_WriteString(To_C(Text1(1..9)));
  70.          delay 0.2;
  71.          LCD_Position(Position2_left);
  72.          delay 0.025;
  73.          LCD_WriteString(To_C(Text2(1..11)));
  74.          delay 1.0;
  75.       end loop;
  76.       LCD_Init; -- après cet init le texte défilant s'affiche.
  77.       delay 0.2;
  78.       LCD_ClearDisplay;
  79.       delay 0.1;
  80.       Position1_right := 18;
  81.       LCD_Position(Position1_right);
  82.       Position2_right := 82;
  83.    end loop;
  84.    Close_Port;
  85. end Lcd_Hello;


Si j'enlève LCD_Init à la fin plus plus rien ne s'affiche.

n°2110130
gilou
Modérateur
Modosaurus Rex
Posté le 07-11-2011 à 12:35:28  profilanswer
 

Code :
  1. unsigned char  get_rawposition() {
  2.     unsigned char control = GetControl();
  3.     unsigned char data;
  5.     Clear_RS(control);
  6.     Set_RW(control);
  7.     usleep(1); 
  8.     SetData(0xFF);         // Set All Pins to FF before read
  9.     DataIn(control); 
  10.     Set_E(control);        // Strobe command to LCD
  11.     usleep(1);
  12.     data = GetData();      // Read Position
  13.     data &= 0x7F;          // Get high bit
  14.     DataOut(control);
  15.     Clear_E(control);
  16.     usleep(1);
  17.     Clear_RW(control);      // Avoid Bus conflict
  18.     usleep(1);
  19.     return data;
  20. }
  22. int GetLine_LCD() {
  23.     int linepos = 0;
  24.     unsigned char rawposition = get_rawposition();
  25.     wait_LCD();
  27.     if (rawposition >= 0) {
  28. if (rawposition <= 19) {
  29.     linepos = 1;
  30. }
  31. else if (rawposition <= 39) {
  32.     linepos = 3;
  33. }
  34. else if (rawposition >= 64) {
  35.     if (rawposition <= 83) {
  36.  linepos = 2;
  37.     }
  38.     else if (rawposition <= 103) {
  39.  linepos = 4;
  40.     }
  41. }
  42.     }
  43.     if (linepos < 1 || linepos > 4) {
  44. printf("Incorrect raw position value: %X\n", rawposition);
  45.     }
  46.     return linepos;
  47. }
  49. int GetLinePos_LCD(int linepos) {
  50.     int charpos = 0;
  51.     unsigned char rawposition = get_rawposition();
  52.     wait_LCD();
  54.     switch (linepos) {
  55.     case 1:
  56. charpos = rawposition +1;
  57. break;
  58.     case 2:
  59. charpos = (rawposition +1) - 64;
  60. break;
  61.     case 3:
  62. charpos = (rawposition +1) - 20;
  63. break;
  64.     case 4:
  65. charpos = (rawposition +1) - 84;
  66. break;
  67.     default:
  68. break;
  70.     }
  72.     if (charpos < 1 || charpos > 20) {
  73. printf("Line %d Incorrect raw position value: %X\n", linepos, rawposition);
  74. charpos = 0;
  75.     }
  76.     return charpos;
  77. }


 
Et après avoir écrit hello, tu peux tester en faisant:
int linepos, charpos;  (déclaré comme variables de main)
 
linepos = GetLine_LCD();
charpos = GetLinePos_LCD(linepos);
printf("Position: caractère %d de la ligne %d\n", charpos, linepos);
 
A+,

Message cité 1 fois
Message édité par gilou le 07-11-2011 à 12:36:52

---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110131
Profil sup​primé
Posté le 07-11-2011 à 12:40:10  answer
 

gilou a écrit :

Code :
  1. unsigned char  get_rawposition() {
  2.     unsigned char control = GetControl();
  3.     unsigned char data;
  5.     Clear_RS(control);
  6.     Set_RW(control);
  7.     usleep(1); 
  8.     SetData(0xFF);         // Set All Pins to FF before read
  9.     DataIn(control); 
  10.     Set_E(control);        // Strobe command to LCD
  11.     usleep(1);
  12.     data = GetData();      // Read Position
  13.     data &= 0x7F;          // Get high bit
  14.     DataOut(control);
  15.     Clear_E(control);
  16.     usleep(1);
  17.     Clear_RW(control);      // Avoid Bus conflict
  18.     usleep(1);
  19.     return data;
  20. }
  22. int GetLine_LCD() {
  23.     int linepos = 0;
  24.     unsigned char rawposition = get_rawposition();
  25.     wait_LCD();
  27.     if (rawposition >= 0) {
  28. if (rawposition <= 19) {
  29.     linepos = 1;
  30. }
  31. else if (rawposition <= 39) {
  32.     linepos = 3;
  33. }
  34. else if (rawposition >= 64) {
  35.     if (rawposition <= 83) {
  36.  linepos = 2;
  37.     }
  38.     else if (rawposition <= 103) {
  39.  linepos = 4;
  40.     }
  41. }
  42.     }
  43.     if (linepos < 1 || linepos > 4) {
  44. printf("Incorrect raw position value: %X\n", rawposition);
  45.     }
  46.     return linepos;
  47. }
  49. int GetLinePos_LCD(int linepos) {
  50.     int charpos = 0;
  51.     unsigned char rawposition = get_rawposition();
  52.     wait_LCD();
  54.     switch (linepos) {
  55.     case 1:
  56. charpos = rawposition +1;
  57. break;
  58.     case 2:
  59. charpos = (rawposition +1) - 64;
  60. break;
  61.     case 3:
  62. charpos = (rawposition +1) - 20;
  63. break;
  64.     case 4:
  65. charpos = (rawposition +1) - 84;
  66. break;
  67.     default:
  68. break;
  70.     }
  72.     if (charpos < 1 || charpos > 20) {
  73. printf("Line %d Incorrect raw position value: %X\n", linepos, rawposition);
  74. charpos = 0;
  75.     }
  76.     return charpos;
  77. }


 
Et après avoir écrit hello, tu peux tester en faisant:
int linepos, charpos;  (déclaré comme variables de main)
 
linepos = GetLine_LCD();
charpos = GetLinePos_LCD(linepos);
printf("Position: caractère %d de la ligne %d\n", charpos, linepos);
 
A+,


 
Je teste ça, je reviens.
 
J'ai fais ça en C, ça marche impecable.
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include "./libparalcd.h"
  6.  
  7. int main (void)
  8. {
  9.   if (ioperm(BASEPORT, 3, 1)) {
  10.     perror("can't set IO permissions!" );
  11.     return -1;
  12.   }
  13.  
  14.   int i;
  15.   int position = 17;
  16.   char Text1[9] = {'H', 'e', 'l', 'l', 'o', '.', '.', '.', ' '};
  17.   char Text2[11] = {'H', 'a', 'r', 'd', 'w', 'a', 'r', 'e', '.', 'f', 'r'};
  18.   
  19.   LCD_Init();    
  20.   while (1) {
  21.     LCD_ClearDisplay();    
  22.     usleep(1);
  23.     LCD_Position(position);       
  24.     for (i = 0; i <= 8 ; i++) {
  25.       int j;
  26.       for (j = 0 ; j <= i ; j++) {
  27.     LCD_WriteChar(Text1[j]);        
  28.     usleep(5000);
  29.       }
  30.       
  31.       position = position - 1;
  32.       LCD_Position(position);
  33.       usleep(5000);
  34.     }
  35.     position = 0x52;
  36.   
  37.     LCD_Position(position);
  38.     sleep(1);
  39.     for (i = 0; i <= 10 ; i++) {
  40.       int j;
  41.     
  42.       for (j = 0 ; j <= i ; j++) {
  43.     LCD_WriteChar(Text2[j]);        
  44.     usleep(5000);
  45.       }
  46.       position = position - 1;
  47.     
  48.       LCD_Position(position);
  49.       usleep(5000);
  50.     }  
  51.     sleep(1);
  52.     position = 17;
  53.   }  
  54.   if (ioperm(BASEPORT, 3, 0)) {
  55.     perror("can't reset IO permissions!" );
  56.     return -1;
  57.   }  
  58.   return 0;
  59. }

Message cité 1 fois
n°2110132
Profil sup​primé
Posté le 07-11-2011 à 12:45:38  answer
 

j'ai testé le code.
 
 

void:libparalcd# ./paralcd bonjour
Position: caractère 9 de la ligne 1
Taper quelque chose pour quitter le programme.


 
Ca affiche "bonjour  ".  :pt1cable:
 
edit, avec deux espace à la fin de la chaîne.


Message édité par Profil supprimé le 07-11-2011 à 12:46:49
n°2110134
gilou
Modérateur
Modosaurus Rex
Posté le 07-11-2011 à 12:54:10  profilanswer
 

Donc c'est OK: On est en ligne 1, au 9e caractère :whistle:  
 
Bon, je suis à la bourre, alors c'est très brut de décoffrage...
 

Code :
  1. void set_rawposition(unsigned char rawposition) {
  2.     unsigned char command = 0x80 + rawposition;
  3.     unsigned char control = GetControl();
  4.    
  5.     Set_RS(control);
  6.     usleep(1); 
  7.     SetData(command);
  8.     Set_E(control);
  9.     usleep(1); 
  10.     Clear_E(control);
  11.     usleep(1); 
  12.    
  13. }
  15. void SetPosition_LCD(int linepos, int charpos) {
  16.     unsigned char rawposition = 0;
  17.     if (linepos < 1 || linepos > 4) {
  18. printf("Incorrect line value: %d\n", linepos);
  19.     }
  20.     if (charpos < 1 || charpos > 20) {
  21. printf("Incorrect character position value: %d\n", charpos);
  22.     }
  23.     switch (linepos) {
  24.     case 1:
  25. rawposition = charpos - 1;
  26. break;
  27.     case 2:
  28. rawposition = 64 + (charpos - 1);
  29. break;
  30.     case 3:
  31. rawposition = 20 + (charpos - 1);
  32. break;
  33.     case 4:
  34. rawposition = 84 + (charpos - 1);
  35. break;
  36.     default:
  37. break;
  38.     }
  39.     set_rawposition(rawposition);
  40.     wait_LCD();
  41. }


 
Je vais bouffer, la.
A+,

Message cité 1 fois

---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110135
Profil sup​primé
Posté le 07-11-2011 à 12:55:54  answer
 

Je vais en faire  autant. Bon ap.

n°2110155
Profil sup​primé
Posté le 07-11-2011 à 13:50:20  answer
 


Ca plante toujours (mais moins) à l'utilisation de firefox, mais bon, y a pas le LCD_Wait qu'il faut aussi.  :??:
 


Message édité par Profil supprimé le 07-11-2011 à 14:00:31
n°2110266
Profil sup​primé
Posté le 08-11-2011 à 05:19:13  answer
 


 
 
Ca marche pas mal ça en fait, là.
 
Sauf que j'ai pas mon début de ligne. Et à chaque itération le curseur saute un peu n'importe où. Mais en faisant un SetPosition c'est déjà plus stable.
Si non, plus de séparateur entre les caractères. Mais c'est plus wait_LCD qu'il faux incriminer là, j'ai viré tous les appelle à la fonction. Je les remet... Ca décale toujours pareil, avec ou sans les appels à Wait_LCD, c'est pas toujours afficher là ou ça devrais et il me manque le début de ligne.
 
J'espère que t'as pas bossé toute la nuit pour rien là.  [:arn0]

Message cité 2 fois
Message édité par Profil supprimé le 08-11-2011 à 05:22:25
n°2110267
Profil sup​primé
Posté le 08-11-2011 à 05:53:19  answer
 


 
En fait non, j'ai fait une bétise, j'ai copié la fonction dans la fonction ce qui fait que ça a compilé mais ça devait pas marcher comme il faut, du coup, ben, les caractère sont bien tout décalé, avec cette fonction qui marchait encore moins.
 
Décidément, (je ferais mieux de dormir la nuit. Peut-être même le jour aussi.)

mood
Publicité
Posté le 08-11-2011 à 05:53:19  profilanswer
 

n°2110281
gilou
Modérateur
Modosaurus Rex
Posté le 08-11-2011 à 09:36:05  profilanswer
 

Non, j'ai une réunion qui me prendra toute la journée, alors j'ai fait en sorte de dormir suffisamment (ou presque, si ce [:aless] de plombier avait pas sonné a la porte très tôt ce matin).
A+,


---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110423
Profil sup​primé
Posté le 08-11-2011 à 23:27:25  answer
 

La bibliothèque que j'utilise actuellement :

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/io.h>
  5. // Base port cablé sur LPT1 ici
  6. #define BASEPORT    0x378
  7. #define DATAREG     BASEPORT+0
  8. #define STATUSREG   BASEPORT+1
  9. #define CONTROLREG  BASEPORT+2
  10. // Clear E : outb(control |= 0x01, CONTROLREG);   
  11. // Clear RW: outb(control |= 0x02, CONTROLREG);   
  12. // Clear RS: outb(control |= 0x08, CONTROLREG);
  13. // Set E   : outb(control &= 0xFE, CONTROLREG);
  14. // Set RW  : outb(control &= 0xFD, CONTROLREG);   
  15. // Set RS  : outb(control &= 0xF7, CONTROLREG);
  16. // Set incoming: outb(control |= 0x20, CONTROLREG);
  17. // Set outgoing: outb(control &= 0xD0, CONTROLREG);
  18. #define Clear_E(z)   outb(z |= 0x01, CONTROLREG)
  19. #define Clear_RW(z)  outb(z |= 0x02, CONTROLREG)
  20. #define Clear_RS(z)  outb(z |= 0x08, CONTROLREG)
  21. #define Set_E(z)     outb(z &= 0xFE, CONTROLREG)
  22. #define Set_RW(z)    outb(z &= 0xFD, CONTROLREG)
  23. #define Set_RS(z)    outb(z &= 0xF7, CONTROLREG)
  24. #define DataIn(z)    outb(z |= 0x20, CONTROLREG)
  25. #define DataOut(z)   outb(z &= 0xD0, CONTROLREG)
  26. #define GetControl() inb(CONTROLREG)
  27. #define GetData()    inb(DATAREG)
  28. #define SetData(z)   outb(z, DATAREG)
  31. void InitPort();
  32. void wait_LCD();
  33. void LCD_Init();
  34. void LCD_ClearDisplay();
  35. void LCD_WriteChar(char c);
  36. void LCD_WriteString(char *s);
  37. void LCD_CursorStartLine1();
  38. void LCD_CursorStartLine2();
  40. unsigned char  get_rawposition();
  41. int GetLine_LCD();
  42. int GetLinePos_LCD(int linepos);
  44. void set_rawposition(unsigned char rawposition);
  45. void SetPosition_LCD(int linepos, int charpos);
  47. void LCD_Position(int pos);
  48. void open_port (void);
  49. void close_port (void);
  50. void port_clear (void);


 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/io.h>
  5. #include "./libparalcd.h"
  6. // Base port cablé sur LPT1 ici
  7. void InitPort() {
  8.   unsigned char control = GetControl();;
  9.   Clear_RW(control); // On met le port de données en mode || -> LCD par defaut
  10. }
  12. void wait_LCD() {
  13.   int maxtries = 255;
  14.   while(maxtries) {
  15.     usleep(3);
  16.     --maxtries;
  17.   }
  18. }
  19. void LCD_Init(){
  20.   unsigned char control = GetControl();
  21.  
  22.   // On va utiliser les valeurs par défaut
  23.   /* ************************************************** */
  24.   Clear_RS(control);
  25.   usleep(1);
  26.   SetData(0x38);      // 8 bits, 2 lignes, (Fonte 5x8)
  27.   Set_E(control);
  28.   usleep(1);
  29.   Clear_E(control);
  30.   usleep(1);
  31.   wait_LCD();
  32.   /**************************************************** */
  33.   Clear_RS(control);
  34.   usleep(1);
  35.   SetData(0x0F);      // Display ON Cursor ON
  36.   Set_E(control);
  37.   usleep(1);
  38.   Clear_E(control);
  39.   usleep(1);
  40.   wait_LCD();
  41.   Clear_RS(control);
  42.   usleep(1);
  43.   SetData(0x06);      // Left -> Right
  44.   Set_E(control);
  45.   usleep(1);
  46.   Clear_E(control);
  47.   usleep(1);
  48.   wait_LCD();
  49. }
  50. void LCD_ClearDisplay() {
  51.   unsigned char control = GetControl();
  52.   Clear_RS(control);
  53.   usleep(1);
  54.   SetData(0x01);
  55.   Set_E(control);
  56.   usleep(1);
  57.   Clear_E(control);
  58.   usleep(1);
  59.   wait_LCD();
  60. }
  61. void LCD_WriteChar(char c) {
  62.   unsigned char control = GetControl();
  63.   usleep(200);
  64.   Set_RS(control);
  65.   usleep(1);
  66.   SetData(c);
  67.   Set_E(control);
  68.   usleep(1);
  69.   Clear_E(control);   
  70.   wait_LCD();
  71.  
  72. }
  73. void LCD_WriteString(char *s) {
  74.   while (*s) {
  75.     LCD_WriteChar(*s++);
  76.     usleep(20);
  77.   }
  78. }
  79. void LCD_CursorStartLine1() {
  80.   unsigned char control = GetControl();
  81.  
  82.   Clear_RS(control);
  83.   usleep(1);
  84.   SetData(0x80);
  85.   Set_E(control);
  86.   usleep(1);
  87.   Clear_E(control);
  88.   usleep(1);
  89.   wait_LCD();
  90. }
  91. void LCD_CursorStartLine2() {
  92.   unsigned char control = GetControl();
  93.  
  94.   Clear_RS(control);
  95.   usleep(1);
  96.   SetData(0xC0);
  97.   Set_E(control);
  98.   usleep(1);
  99.   Clear_E(control);
  100.   usleep(1);
  101.   wait_LCD();
  102. }
  105. unsigned char  get_rawposition() {
  106.   unsigned char control = GetControl();
  107.   unsigned char data;
  108.   Clear_RS(control);
  109.   Set_RW(control);
  110.   usleep(1);
  111.   SetData(0xFF);         // Set All Pins to FF before read
  112.   DataIn(control);
  113.   Set_E(control);        // Strobe command to LCD
  114.   usleep(1);
  115.   data = GetData();      // Read Position
  116.   data &= 0x7F;          // Get high bit
  117.   DataOut(control);
  118.   Clear_E(control);
  119.   usleep(1);
  120.   Clear_RW(control);      // Avoid Bus conflict
  121.   usleep(1);
  122.   return data;
  123. }
  124. int GetLine_LCD() {
  125.   int linepos = 0;
  126.   unsigned char rawposition = get_rawposition();
  127.   wait_LCD();
  128.   if (rawposition >= 0) {
  129.     if (rawposition <= 19) {
  130.       linepos = 1;
  131.     }
  132.     else if (rawposition <= 39) {
  133.       linepos = 3;
  134.     }
  135.     else if (rawposition >= 64) {
  136.       if (rawposition <= 83) {
  137. linepos = 2;
  138.       }
  139.       else if (rawposition <= 103) {
  140. linepos = 4;
  141.       }
  142.     }
  143.   }
  144.   if (linepos < 1 || linepos > 4) {
  145.     printf("Incorrect raw position value: %X\n", rawposition);
  146.   }
  147.   return linepos;
  148. }
  149. int GetLinePos_LCD(int linepos) {
  150.   int charpos = 0;
  151.   unsigned char rawposition = get_rawposition();
  152.   wait_LCD();
  153.   switch (linepos) {
  154.   case 1:
  155.     charpos = rawposition +1;
  156.     break;
  157.   case 2:
  158.     charpos = (rawposition +1) - 64;
  159.     break;
  160.   case 3:
  161.     charpos = (rawposition +1) - 20;
  162.     break;
  163.   case 4:
  164.     charpos = (rawposition +1) - 84;
  165.     break;
  166.   default:
  167.     break;
  168.   }
  169.   if (charpos < 1 || charpos > 20) {
  170.     printf("Line %d Incorrect raw position value: %X\n", linepos, rawposition);
  171.     charpos = 0;
  172.   }
  173.   return charpos;
  174. }
  176. void set_rawposition(unsigned char rawposition) {
  177.   unsigned char command = 0x80 + rawposition;
  178.   unsigned char control = GetControl();
  179.  
  180.   outb(0x08, CONTROLREG);
  181.   usleep(20);
  182.   outb(command, DATAREG);
  183.   usleep(20);
  184.   outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
  185.   usleep(10);                 // Strobe duration: 500 ns
  186.   outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  187.   usleep(50);                 // Wait before next strobe: 500 ns
  189. }
  191. void SetPosition_LCD(int linepos, int charpos) {
  192.   unsigned char rawposition = 0;
  193.   if (linepos < 1 || linepos > 4) {
  194.     printf("Incorrect line value: %d\n", linepos);
  195.   }
  196.   if (charpos < 1 || charpos > 20) {
  197.     printf("Incorrect character position value: %d\n", charpos);
  198.   }
  199.   switch (linepos) {
  200.   case 1:
  201.     rawposition = charpos - 1;
  202.     break;
  203.   case 2:
  204.     rawposition = 64 + (charpos - 1);
  205.     break;
  206.   case 3:
  207.     rawposition = 20 + (charpos - 1);
  208.     break;
  209.   case 4:
  210.     rawposition = 84 + (charpos - 1);
  211.     break;
  212.   default:
  213.     break;
  214.   }
  215.   set_rawposition(rawposition);
  216.   wait_LCD();
  217. }
  218. void open_port (void) {
  219.   if (ioperm(BASEPORT, 3, 1)) {
  220.     perror("can't set IO permissions!" );   
  221.   } 
  222. }
  224. void close_port (void) {
  225.   if (ioperm(BASEPORT, 3, 0)) {
  226.     perror("can't reset IO permissions!" );
  227.   } 
  228. }
  230. void port_clear (void) {
  231.   outb(0xFF, DATAREG); 
  232.   usleep(20);
  233. }


 
La fonction original de set_rawposition n'était pas efficace, alors, je suis revenu à une anciene méthode.
 
 
Un programme qui exploite la bibliothèque ci-dessus :
 

Code :
  1. /* Ce programme affiche les information de /proc/meminfo sur un L'afficheur LCD */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <string.h>
  6. #include "./libparalcd.h"
  7. #include <time.h>
  9. int main (void) {
  10.  
  11.   char date[9];
  12.   char hostname[9];
  13.  
  14.   char dummy[4096];
  15.  
  16.   char file[] = "/proc/meminfo";
  17.   FILE *fp;
  18.   char valeur[10];
  19.   char name[10];
  20.   if (system(dummy)) return (1);
  21.  
  22.   fp = fopen(file, "r" );
  23.   if (!fp) {
  24.     perror("/proc/meminfo" );
  25.     return -1;
  26.   }
  27.    
  28.   time_t current_date = time(NULL);
  29.  
  30.   strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  31.   gethostname(hostname, sizeof(hostname));
  32.  
  34.   if (ioperm(BASEPORT, 3, 1)) {
  35.     perror("can't set IO permissions!" );
  36.     return -1;
  37.   }
  38.  
  39.  
  40.   LCD_Init();   
  41.   usleep(120); 
  42.    
  43.   int i; 
  44.   for (i = 1; i <= 29 ; i++) {
  45.     fscanf(fp, "%s%s%s\n", name, valeur, dummy);   
  46.     current_date = time(NULL);
  47.    
  48.     strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  49.     LCD_ClearDisplay();       
  50.     usleep(120);
  51.     SetPosition_LCD(1, 1);
  52.     usleep(120); 
  53.     LCD_WriteString(date);
  54.     usleep(120); 
  55.     SetPosition_LCD(1, 10);
  56.     usleep(120); 
  57.     LCD_WriteString(hostname);   
  58.     usleep(120); 
  59.     SetPosition_LCD(3, 1);   
  60.     usleep(120); 
  61.     LCD_WriteString(name);
  62.     usleep(120); 
  63.     SetPosition_LCD(4, 1);
  64.     usleep(120); 
  65.     LCD_WriteString(valeur);   
  66.     usleep(120); 
  67.     port_clear();
  68.     sleep(1);
  69.   }
  70.   fclose(fp);
  71.   port_clear();
  73.   if (ioperm(BASEPORT, 3, 0)) {
  74.     perror("can't reset IO permissions!" );
  75.     return -1;
  76.   }
  78.   return 0;
  79. }


 
 
L'utilisation de port_clear, c'est à cause d'un afficheur défectueux.
 
 

n°2110429
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 01:09:00  profilanswer
 

Tu as combien de lignes sur l'afficheur?
4 de 20 caractères?
avec une poursuite de la 1 sur la 3 et de la 2 sur la 4?
 
Comme je l'ai faite rapidement, elle était peut être pas bonne.
Ces temps ci, je devrais être plus au calme que la semaine dernière.
 
A+,


Message édité par gilou le 09-11-2011 à 01:11:53

---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110431
Profil sup​primé
Posté le 09-11-2011 à 01:27:15  answer
 

Oui, j'ai 4x20 caractères et ça saute aussi de la 3 à la 2 et de la 4 à la 1.
 
 
Rhhhaaa.  :o


Message édité par Profil supprimé le 09-11-2011 à 01:28:20
n°2110437
Profil sup​primé
Posté le 09-11-2011 à 04:11:35  answer
 

Un autre programme qui affiche des information sur le système.
 
$hostname : hh:mm:ss
cpu            :$cpu_usage
mem          :$mem_usage
swap          :$swap_usage
 

Code :
  1. /* Ce programme affiche les informations sur les ressources du PC sur l'afficheur LCD */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <string.h>
  6. #include "./libparalcd.h"
  7. #include <time.h>
  10. int main (void) {
  11.  
  12.   char date[9];
  13.   char hostname[9];
  14.  
  15.  
  16.  
  17.   char file[] = "/proc/meminfo";
  18.  
  19.   char valeur[10];
  20.   char name[10];
  21.   char dummy[4];
  22.   FILE *cpufp;
  23.   FILE *memfp;
  24.   FILE *fp;
  25.   char label_cpu[]  = "cpu   : \0";
  26.   char label_mem[]  = "mem   : \0";
  27.   char label_swap[] = "swap  : \0";
  28.   //char label_proc[] = "proc  : \0";
  29.   //char label_pid[]  = "pid   : \0";
  30.   //char label_pri[]  = "prio  : \0";   
  31.  
  32.   char value_used[10];
  33.   char value_swap[10];
  34.   char value_cpu[10];
  35.  
  36.  
  37.  
  38.   if (system(dummy)) return (1);
  39.  
  40.   fp = fopen(file, "r" );
  41.   if (!fp) {
  42.     perror("/proc/meminfo" );
  43.     return -1;
  44.   }
  45.    
  46.   time_t current_date = time(NULL);
  47.  
  48.   strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  49.   gethostname(hostname, sizeof(hostname));
  50.  
  52.   if (ioperm(BASEPORT, 3, 1)) {
  53.     perror("can't set IO permissions!" );
  54.     return -1;
  55.   }
  56.  
  57.  
  58.   LCD_Init();   
  59.   usleep(120); 
  60.    
  61.   int i; 
  62.   for (i = 1; i <= 5 ; i++)
  63.     fscanf(fp, "%s%s%s\n", name, value_swap, dummy);   
  64.   fclose(fp);
  65.   cpufp = popen("ps aux| awk 'NR > 0 { s +=$3 }; END {print s}'","r" );
  66.   fread(value_cpu, 1, sizeof(value_cpu)-1, cpufp);
  67.   fclose(cpufp);
  68.   memfp = popen("ps aux| awk 'NR > 0 { s +=$4 }; END {print s}'","r" );
  69.   fread(value_used, 1, sizeof(value_used)-1, memfp);
  70.   fclose(memfp);
  71.  
  72.   strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  73.   LCD_ClearDisplay();       
  74.   usleep(120);           
  75.   SetPosition_LCD(1, 1);
  76.   usleep(120); 
  77.   LCD_WriteString(hostname);   
  78.   usleep(120);
  79.   SetPosition_LCD(1, 7);
  80.   usleep(120); 
  81.   LCD_WriteString(":" );   
  82.   usleep(120);
  83.   SetPosition_LCD(1, 9);
  84.   usleep(120); 
  85.   LCD_WriteString(date);
  86.   usleep(120);     
  87.   SetPosition_LCD(2, 1);     
  88.   usleep(120);
  89.   LCD_WriteString(label_cpu);   
  90.   usleep(120); 
  91.   LCD_WriteString(value_cpu);   
  92.   usleep(120); 
  93.   SetPosition_LCD(3, 1);
  94.   LCD_WriteString(label_mem);   
  95.   usleep(120); 
  96.   LCD_WriteString(value_used);   
  97.   usleep(120); 
  98.   SetPosition_LCD(4, 1);
  99.   usleep(120); 
  100.   LCD_WriteString(label_swap);   
  101.   usleep(120);       
  102.   LCD_WriteString(value_swap);     
  103.   port_clear();
  105.   if (ioperm(BASEPORT, 3, 0)) {
  106.     perror("can't reset IO permissions!" );
  107.     return -1;
  108.   }
  110.   return 0;
  111. }


Message édité par Profil supprimé le 09-11-2011 à 06:28:26
n°2110441
Profil sup​primé
Posté le 09-11-2011 à 07:33:57  answer
 

La version en boucle infini.

Code :
  1. /* Ce programme affiche les informations de d'usage du PC sur l'afficheur afficheur LCD */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <string.h>
  6. #include "./libparalcd.h"
  7. #include <time.h>
  8. int main (void) {
  10.   char date[9];
  11.   char hostname[9];
  13.   char dummy[4096];
  14.  
  15.   char file[] = "/proc/meminfo";
  16.   FILE *fp;
  17.   FILE *cpufp; 
  18.   char valeur[10];
  19.   char name[10];
  20.   char label_mem[]  = "mem  : \0";
  21.   char label_swap[] = "swap : \0";
  22.   char label_cpu[]  = "cpu  : \0";
  24.   float mem_total, mem_free, mem_swap, mem_used = 0;
  25.  
  26.   char value_total[10];
  27.   char value_swap[10];
  28.   char value_cpu[10];
  30.   time_t current_date = time(NULL);
  33.   if (system(dummy)) return (1);
  34.  
  35.   strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  36.   gethostname(hostname, sizeof(hostname));
  37.  
  38.   if (ioperm(BASEPORT, 3, 1)) {
  39.     perror("can't set IO permissions!" );
  40.     return -1;
  41.   }
  43.   cpufp = popen("ps aux| awk 'NR > 0 { s +=$3 }; END {print s}'","r" );
  44.   fread(value_cpu, 1, sizeof(value_cpu)-1, cpufp);
  45.   fclose(cpufp);
  47.   LCD_Init(); 
  48.   while (1) {
  49.   usleep(120);
  50.   fp = fopen(file, "r" );
  51.   if (!fp) {
  52.     perror("/proc/meminfo" );
  53.     return -1;
  54.   }
  55.   int i;
  56.   for (i = 1; i <= 5 ; i++) {
  57.     fscanf(fp, "%s%s%s\n", name, valeur, dummy); 
  58.     current_date = time(NULL);
  59.  
  60.     switch (i) {
  61.    
  62.     case 1 : {
  63.    
  64.       char *p_conv = NULL;
  65.       mem_total = (float)strtol(valeur, &p_conv, 10);   
  66.       strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  67.      
  68.       break;
  69.     }
  70.     case 2 : {
  71.       char *p_conv = NULL;
  72.       mem_free = (float)strtol(valeur, &p_conv, 10);
  73.       mem_used = ((mem_total-mem_free)*100)/mem_total;                     
  74.      
  75.       break;
  76.     }
  77.     case 5 : {
  78.       char *p_conv = NULL;
  79.       mem_swap = (float)strtol(valeur, &p_conv, 10);   
  80.       strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  81.       LCD_ClearDisplay();           
  82.       usleep(120);         
  83.       SetPosition_LCD(1, 1);
  84.       usleep(1); 
  85.       LCD_WriteString(hostname);   
  86.       usleep(1);
  87.       SetPosition_LCD(1, 6);
  88.       usleep(1); 
  89.       LCD_WriteChar(':');   
  90.       usleep(1);
  91.       SetPosition_LCD(1, 8);
  92.       usleep(1); 
  93.       LCD_WriteString(date);
  94.       usleep(1);     
  95.       SetPosition_LCD(2, 1);     
  96.       usleep(1);
  97.       LCD_WriteString(label_cpu);   
  98.       usleep(1); 
  99.       LCD_WriteString(value_cpu);   
  100.       usleep(1); 
  101.       SetPosition_LCD(3, 1);
  102.       LCD_WriteString(label_mem);   
  103.       usleep(1);             
  104.       sprintf(value_total, "%f", mem_used);
  105.       LCD_WriteString(value_total); 
  106.       usleep(120);
  107.       SetPosition_LCD(4, 1);
  108.       usleep(120);
  109.       LCD_WriteString(label_swap); 
  110.       usleep(120);     
  111.       sprintf(value_swap, "%f", mem_swap);
  112.       LCD_WriteString(value_swap);   
  113.       port_clear();
  114.       sleep(1);
  115.    
  116.     }
  117.     }
  118.   }
  119.   fclose(fp);
  120.   port_clear();
  121.   LCD_Init(); 
  122.   }
  123.   if (ioperm(BASEPORT, 3, 0)) {
  124.     perror("can't reset IO permissions!" );
  125.     return -1;
  126.   }
  127.   return 0;
  128. }


 


Message édité par Profil supprimé le 09-11-2011 à 15:01:41
n°2110446
Profil sup​primé
Posté le 09-11-2011 à 08:49:03  answer
 

Je teste une config comme ça ce matin...
 

Code :
  1. #define GetControl() 0x0F
  2. #define SetControl(z) outb(z, CONTROLREG)
  3. #define REGISTER_DELAY 1
  4. void InitPort() {
  5.   unsigned char control = GetControl();
  6.   Clear_RW(control); // On met le port de données en mode || -> LCD par defaut
  7. void wait_LCD() {
  8.   char control = GetControl();
  9.   int maxtries = 255;
  10.   unsigned char busy = 0x80; // Mask for D7                                                                                                   
  12.   while (maxtries && busy?1:0) {
  13.     usleep(REGISTER_DELAY);
  14.     outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]                                                   
  15.     usleep(REGISTER_DELAY);
  16.     outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]                                                         
  17.     usleep(REGISTER_DELAY);
  18.     busy &= inb(DATAREG);
  19.     --maxtries;
  20.   }
  21.   SetControl(control);


 
Parfois ça marche parfois ça marche pas. Je commence à me demander sérieusement, si c'est pas du à l'afficheur qu'est à mettre au rebut.

n°2110449
Profil sup​primé
Posté le 09-11-2011 à 09:49:51  answer
 


 
 
 
 
Bonjour Gilou,
 
Topo, on doit travailler avec le code du postquoted ci-dessus avec GetChar pour connaître les caractère non affichable qui espace le texte source.
 
Amoins que tu ais une autre idée ?
 
Et si t'as du code, je prend même si c'est pas finalisé. Histoire de garder ton esprit pour le développement des outils utiles.  :p  
 

n°2110453
Profil sup​primé
Posté le 09-11-2011 à 10:00:53  answer
 
n°2110455
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 10:24:10  profilanswer
 

> on doit travailler avec le code du postquoted ci-dessus avec GetChar pour connaître les caractère non affichable qui espace le texte source
Il faut se positionner en mémoire au bon endroit (SetPosition_LCD) et faire un appel avec une version modifiée de wait_LCD :whistle:  
par exemple, en partant de ceci:

Code :
  1. void wait_LCD() {
  2.     unsigned char control = GetControl();
  3.     unsigned char data = 0xFF;
  4.     int maxtries = 255;
  6.     while (data && maxtries) {
  7. Clear_RS(control); 
  8. Set_RW(control);
  9. usleep(1);     
  10. SetData(0xFF);         // Set All Pins to FF before read
  11. DataIn(control);     
  12. Set_E(control);        // Strobe command to LCD
  13. usleep(1);
  14. data = GetData();      // Read Data
  15. data &= 0x80;          // Get high bit
  16. DataOut(control);     
  17. --maxtries;
  18.     }
  19.     Clear_E(control); 
  20.     usleep(1);   
  21.     Clear_RW(control);      // Avoid Bus conflict
  22.     usleep(1);
  23. }


on fait quelque chose comme (écrit un poil rapidement, car je sors en course dès que c'est posté):

Code :
  1. unsigned char get_char() {
  2.     unsigned char control = GetControl();
  3.     unsigned char data = 0xFF;
  4.     int maxtries = 255;
  6.     Set_RS(control);        // RS = 1 et non 0 maintenant
  7.     Set_RW(control);
  8.     usleep(1);     
  9.     SetData(0xFF);         // Set All Pins to FF before read
  10.     DataIn(control);     
  11.     Set_E(control);        // Strobe command to LCD
  12.     usleep(5);                // On laisse un peu de temps pour que ca se fasse en interne
  13.     data = GetData();      // Read Data
  14.     DataOut(control);
  16.     Clear_E(control); 
  17.     usleep(1);
  18.     Clear_RS(control);   
  19.     Clear_RW(control);      // Avoid Bus conflict
  20.     usleep(1);
  21.     return data;
  22. }
  24. unsigned char GetChar_LCD(int line, int linepos) {
  25.    
  26.     int oldline, oldlinepos;
  27.     unsigned char data;
  29.     oldline = GetLine_LCD();
  30.     oldlinepos = GetLinePos_LCD(oldlinepos);
  32.     SetPosition_LCD(line, linepos);
  33.     data = char get_char();
  34.     SetPosition_LCD(oldline, oldlinepos);
  35.     return data;
  36. }


 
A+,
 


---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110489
Profil sup​primé
Posté le 09-11-2011 à 13:02:07  answer
 

Merci gilou !
 
 
J'ai fait une page de sorties console, c'est quatre appel d'un programme qui affiche divers chaîne sur les 4 ligne tout frais d'un reboot à froid. before indique qu'on est juste aprrès le positionnement, after après l'affichage.
 

void:libparalcd-2.012e+03# ./lcd_sys2
Line 0 Incorrect raw position value: 6
Incorrect character position value: 0
before get char 32 at raw 3 line 1  
After get char 32 at raw 3 line 1  
Incorrect raw position value: 3D
Line -1074145888 Incorrect raw position value: 3E
Incorrect line value: 0
Incorrect character position value: 0
before get char 32 at raw 4 line 1  
after char 32 at raw 4 line 1  
Incorrect raw position value: 28
Line -1074145888 Incorrect raw position value: 2B
Incorrect line value: 0
Incorrect character position value: 0
before get char 32 at raw 1 line 1  
After get char 32 at raw 1 line 1  
Incorrect raw position value: 3C
Line 0 Incorrect raw position value: 31
Incorrect line value: 0
Incorrect character position value: 0
before get char 32 at raw 2 line 1  
after get char 32 at raw 2 line 1  
void:libparalcd-2.012e+03# ./lcd_sys2
Line 0 Incorrect raw position value: 1D
Incorrect character position value: 0
before get char 32 at raw 3 line 1  
After get char 32 at raw 3 line 1  
Line -1078193728 Incorrect raw position value: 57
Incorrect character position value: 0
before get char 32 at raw 4 line 1  
after char 32 at raw 4 line 1  
Line -1078193728 Incorrect raw position value: 3
Incorrect character position value: 0
before get char 32 at raw 1 line 1  
After get char 32 at raw 1 line 1  
Line 0 Incorrect raw position value: 4B
Incorrect character position value: 0
before get char 32 at raw 2 line 1  
after get char 32 at raw 2 line 1  
void:libparalcd-2.012e+03# ./lcd_sys2
Line 0 Incorrect raw position value: 23
Incorrect character position value: 0
before get char 32 at raw 3 line 1  
After get char 32 at raw 3 line 1  
Line -1079273280 Incorrect raw position value: 57
Incorrect character position value: 0
before get char 32 at raw 4 line 1  
after char 32 at raw 4 line 1  
Line -1079273280 Incorrect raw position value: 3
Incorrect character position value: 0
before get char 32 at raw 1 line 1  
After get char 32 at raw 1 line 1  
Line 0 Incorrect raw position value: 2C
Incorrect character position value: 0
before get char 32 at raw 2 line 1  
after get char 32 at raw 2 line 1  
void:libparalcd-2.012e+03# ./lcd_sys2
Line 0 Incorrect raw position value: 23
Incorrect character position value: 0
before get char 32 at raw 3 line 1  
After get char 32 at raw 3 line 1  
Line -1080131600 Incorrect raw position value: 57
Incorrect character position value: 0
before get char 32 at raw 4 line 1  
after char 32 at raw 4 line 1  
Line -1080131600 Incorrect raw position value: 3
Incorrect character position value: 0
before get char 32 at raw 1 line 1  
After get char 32 at raw 1 line 1  
Line 0 Incorrect raw position value: 11
Incorrect character position value: 0
before get char 0 at raw 2 line 1  
after get char 0 at raw 2 line 1


 
J'oubliais, ça marche pas, ça affiche rien.


Message édité par Profil supprimé le 09-11-2011 à 13:02:38
n°2110496
Profil sup​primé
Posté le 09-11-2011 à 13:28:51  answer
 

La il y avait 49 dans une espace.
 
 
Ca avance d'un caractère à la lecture ?
 
 
 
Apriori, je ne peux même pas lire le tableau sans modifier l'état de l'afficheur.
J'ai fait ça simplement

Code :
  1. int i, j;
  2.   for (i = 1 ;i <= 4; i++) {
  3.     for (j = 1 ; j <= 20; j++) {
  4.       getted_char = GetChar_LCD(i, j);
  5.       printf("after char %d at raw %d line %d \n", getted_char, i, j);
  6.     }
  7.   }


Ca m'a effacé l'écran.


Message édité par Profil supprimé le 09-11-2011 à 13:42:45
n°2110525
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 15:28:50  profilanswer
 

Si tu fais  
SetData('A');         // Set All Pins to FF before read
au lieu de
SetData(0xFF);         // Set All Pins to FF before read
dans get_char()
Est-ce que ça te remplis l'écran de A en faisant ta boucle précédente?
A+,

Message cité 1 fois

---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110526
Profil sup​primé
Posté le 09-11-2011 à 15:31:13  answer
 

J'ai refais le même chose en l'exécution d'un seul prog, sans Wait_LCD.
L'appel à GetChar_LCD à des effets de bord.
 
Bon, je t'attend un peu.

n°2110529
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 15:34:48  profilanswer
 

>> L'appel à GetChar_LCD à des effets de bord.
A un flag près (RS a 1 et pas a 0) et sans boucle, c'est la même chose que Wait_LCD, vu que c'est une des deux seules commandes qui va lire des données de l'afficheur.
Alors, si l'une a des problèmes, je suis pas surpris que l'autre en ait aussi.
A+,


---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110532
Profil sup​primé
Posté le 09-11-2011 à 15:38:52  answer
 

gilou a écrit :

Si tu fais  
SetData('A');         // Set All Pins to FF before read
au lieu de
SetData(0xFF);         // Set All Pins to FF before read
dans get_char()
Est-ce que ça te remplis l'écran de A en faisant ta boucle précédente?
A+,


 
Pas du tout, par contre dans les itération du programme qui affiche les info system la liste des 80 caractère représente bien à première vue le texte écrit. Ca lie bien quoi, mais aubout d'un certain nombre d'itération tout semble décalé. Et ca affiche plus rien, puis ça réapparait.

n°2110543
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 15:56:22  profilanswer
 

D'un point de vue général, SetPosition_LCD met bien le curseur a l'endroit prévu?
>> mais aubout d'un certain nombre d'itération tout semble décalé
Je vois pas trop ce qui fait ça.
Si tu veux lire les specs du controlleur de ton afficheur sur un document plus détaillé, http://doc.chipfind.ru/pdf/sitronix/st7066u0a.pdf
A+,

Message cité 1 fois

---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110567
Profil sup​primé
Posté le 09-11-2011 à 16:28:57  answer
 

gilou a écrit :

D'un point de vue général, SetPosition_LCD met bien le curseur a l'endroit prévu?


 
pour line de 1 à 4 et raw de 1 à 20
 
A  chaque itérationde SetPosition_LCD(line, raw) ça met un caractère plein en position courante et ça avance d'un caractère.
 
Je parle de ce set rawposition :
 

Code :
  1. void set_rawposition(unsigned char rawposition) {
  2.   unsigned char command = 0x80 + rawposition;
  3.   unsigned char control = GetControl();
  5.     Set_RS(control);
  6.     usleep(1);
  7.     SetData(command);
  8.     Set_E(control);
  9.     usleep(1);
  10.     Clear_E(control);
  11.     usleep(1);
  12. }


 
Corrrection, c'est 80 raw, mais 20


Message édité par Profil supprimé le 09-11-2011 à 17:14:11
n°2110570
Profil sup​primé
Posté le 09-11-2011 à 16:33:38  answer
 

En plus c'est pas ça du tout qui se passe je capte rien, ça incrémente d'un caractère, c'est à dire que de la ligne 1 on pase à la trois de la 3 à la deux de deux à 4. On suit la ligne quoi.

n°2110577
Profil sup​primé
Posté le 09-11-2011 à 16:49:18  answer
 

Et mon code ne fonctionne plus non plus, c'est à dire que l'utilisation de SetPosition_LCD  juste après l'Init_LCD plante l'afficheur.

n°2110583
Profil sup​primé
Posté le 09-11-2011 à 17:03:21  answer
 

Si ça ça marche pas trop mal, c'est ton code, je disais le mien mais c'est l'ancien.
Mais au bout d'un certain nombre d'itération ça perturbe.quand même de fait 80 set_position d'affilé.
 

Code :
  1. void set_rawposition(unsigned char rawposition) {
  2.   unsigned char command = 0x80 + rawposition;
  3.   unsigned char control = GetControl();
  5.   outb(0x08, CONTROLREG);
  6.   usleep(20);
  7.   outb(command, DATAREG);
  8.   usleep(20);
  9.   outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]                                                                                                                             
  10.   usleep(10);                 // Strobe duration: 500 ns                                                                                                                                                             
  11.   outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]                                                                                                                                   
  12.   usleep(50);                 // Wait before next strobe: 500 ns                                                                                                                                                     
  13.   }


 
 
Il y a ce pdf très simple sur les compatible HD44780. http://www.google.fr/url?sa=t&rct= [...] TA&cad=rja

Message cité 1 fois
Message édité par Profil supprimé le 09-11-2011 à 17:09:42
n°2110590
Profil sup​primé
Posté le 09-11-2011 à 17:37:17  answer
 


 
 
 
J'ai commencé à écrire une lib en fonction de ce que je comprenais de ce document, mais j'ai buté sur la troisième valeur de io, qui peut prendre STROBE en plus de READ et CTRL
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/io.h>
  5. // Base port cablé sur LPT1 ici                                                                                                                                                                                     
  6. #define BASEPORT    0x378
  7. #define DATAREG     BASEPORT+0
  8. #define STATUSREG   BASEPORT+1
  9. #define CONTROLREG  BASEPORT+2
  10. char reg;
  11. #define CTRL 0
  12. #define READ 1
  13. #define clrbit(io) outb(io?0x01:0x28, CONTROLREG);
  14. #define setbit(io) outb(io?0xFE:0x0D, CONTROLREG);
  16. woid WriteCommon (unsigned char value)
  17. {
  19.   clrbi(READ);
  21.   value = value & 0x0F;
  22.   value = value << 4;
  27. void WriteCtrl(unsigned char value)
  28. {
  29.   clrbit(CTRL);
  30.   WriteCommon(value);
  31. }
  33. void LCD_Init (void) {
  35. }


Message édité par Profil supprimé le 09-11-2011 à 17:38:25
n°2110603
Profil sup​primé
Posté le 09-11-2011 à 18:54:34  answer
 

Là j'ai ça comme Wait_Busy()  
 

Code :
  1. void wait_busy() {                                                                                                                                                 
  2.   unsigned char busy = 0x80; // Mask for D7                                                                                                                                                                         
  4.   do {
  5.     outb(0x01, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]                                                                                                                         
  6.     usleep(100);
  7.     outb(0xFE, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]                                                                                                                                 
  8.     usleep(100);
  9.     busy &= inb(DATAREG);
  10.                                                                                                                                                                                  
  11.   } while  (busy?1:0);


 
M'ais j'affiche même pas le curseur. Mais ça sort de la boucle. C'est du "vieux" code.
 
Bon, je vais essayer de me débrouiller pour suivre le doc pdf d'au-dessus.

n°2110606
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 19:30:17  profilanswer
 

si tu imprimais la valeur de datareg, qu'on aie une idée de ce qu'il y a dedans...
 
printf("DATAREG: %x\n", inb(DATAREG));
 
A+,

Message cité 1 fois
Message édité par gilou le 09-11-2011 à 19:43:25

---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110613
Profil sup​primé
Posté le 09-11-2011 à 20:16:41  answer
 

gilou a écrit :

si tu imprimais la valeur de datareg, qu'on aie une idée de ce qu'il y a dedans...
 
printf("DATAREG: %x\n", inb(DATAREG));
 
A+,


 
Dans la boucle Wait_Busy ?
 
 
 
J'ai fait ça mais je me tape une erreur de segmentation avant même d'attaquer le programme.
C'est mon premier code C pour ainsi dire, alors, ne soyez pas trop indigné par mon verbe.

Code :
  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
  12. #define STROBE 0
  13. #define CTRL 1
  14. #define READ 2
  17. unsigned char clear_bit(int bit, unsigned char reg) { 
  18.   switch (bit) {       
  19.   case 0 : { // STROBE
  20.     reg &= 0x01;
  21.     outb(reg, CONTROLREG);
  22.   }
  23.    
  24.   case 1 : { //CTRL  
  25.     reg &= 0x02;
  26.     outb(reg, CONTROLREG);
  27.   }
  28.   case 2 : { //READ
  29.     reg &= 0x08;
  30.     outb(reg, CONTROLREG);
  31.   }
  32.   default : 
  33.     return -1;
  35.   }
  36.   return reg;
  37. }
  39. unsigned char set_bit(int bit, unsigned char reg) {
  40.  
  41.   switch (bit) {       
  42.   case 0 : { // STROBE
  43.     reg &= 0xFE;
  44.     outb(reg, CONTROLREG);
  45.   }
  46.    
  47.   case 1 : { //CTRL  
  48.     reg &= 0xFD;
  49.     outb(reg, CONTROLREG);
  50.   }
  51.   case 2 : { //READ
  52.     reg &= 0xF7;
  53.     outb(reg, CONTROLREG);
  54.   }
  55.   default : 
  56.     return -1;
  58.   }
  59.   return reg;
  60. }
  63. unsigned char WriteCommon (unsigned char value, unsigned char reg) {
  64.  
  65.   unsigned char data = 0x00;
  67.   reg = clear_bit(READ, reg);
  68.   value = value & 0x0F;
  69.   value = value << 4;
  70.   data = data & 0x0F;
  71.   data = data | value;
  72.   outb(data, DATAREG);
  73.   reg = set_bit(STROBE, reg);
  74.   usleep(4.5);
  75.   reg = clear_bit(STROBE, reg);
  76.   reg = set_bit(READ, reg);
  77.   usleep(4.5);
  78.   return reg; 
  79.    
  80. }
  82. unsigned char WriteData (unsigned char value, unsigned char reg) {
  83.   reg = set_bit(CTRL, reg);
  84.   reg = WriteCommon(value >> 4, reg);
  85.   reg = WriteCommon(value, reg);
  86.   return reg;
  87. }
  89. unsigned char WriteCtrl (unsigned char value, unsigned char reg) {
  90.   reg = clear_bit(CTRL, reg);
  91.   reg = WriteCommon(value, reg);
  92.   return reg;
  93. }
  95. unsigned char WriteLcd (char * value, unsigned char reg) {
  97.   while (*value) {
  98.     reg = WriteData(*value++, reg);
  99.   }
  100.   return reg;
  101. }
  104. unsigned char InitLcd (unsigned char reg) {
  106.   reg = WriteCtrl(0x03, reg);
  107.   usleep(50000);
  108.   reg = WriteCtrl(0x03, reg);
  109.   usleep(1000);
  110.   reg = WriteCtrl(0x03, reg);
  111.   usleep(4.5);
  112.   reg = WriteCtrl(0x02, reg);
  113.   usleep(450);
  114.   reg = WriteCtrl(0x02, reg);
  115.   usleep(450);
  116.   reg = WriteCtrl(0x08, reg);
  117.   usleep(450);
  118.   reg = WriteCtrl(0x00, reg);
  119.   usleep(450);
  120.   reg = WriteCtrl(0x0F, reg);
  121.   usleep(450);
  122.   reg = WriteCtrl(0x00, reg);
  123.   usleep(450);
  124.   reg = WriteCtrl(0x06, reg);
  125.   usleep(450);
  126.   reg = WriteCtrl(0x00, reg);
  127.   usleep(450);
  128.   reg = WriteCtrl(0x01, reg);
  129.   usleep(450);
  130.   reg = WriteCtrl(0x00, reg);
  131.   usleep(450);
  132.   reg = WriteCtrl(0x02, reg);
  133.  
  134.   return reg;
  135. }
  137. int main (int argc, char * argv[]) {
  138.   unsigned char control;
  139.   printf("main: InitLcd...." );
  140.   control = InitLcd(control);
  141.   printf("main: WriteLcd...." );
  142.   control = WriteLcd(argv[1], control);
  143.   return control;
  144. }

n°2110614
Profil sup​primé
Posté le 09-11-2011 à 20:20:12  answer
 

DATAREG: ff
DATAREG: ff
DATAREG: 7f
DATAREG: 7f
DATAREG: 7f
DATAREG: ff
DATAREG: 7f
DATAREG: 7f
DATAREG: 7f
DATAREG: 7f
DATAREG: 7f
DATAREG: ff
DATAREG: 7f
DATAREG: 7f

Message cité 1 fois
Message édité par Profil supprimé le 09-11-2011 à 20:20:33
n°2110627
gilou
Modérateur
Modosaurus Rex
Posté le 09-11-2011 à 21:21:49  profilanswer
 


Les séquences  
DATAREG: ff
DATAREG: 7f
c'est quand on passe d'un état busy à un état non busy
Donc on doit sortir de la boucle, mais a condition que le masque du bit D7 soit mis avant:
 
    outb(0x01, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]                                                                                                                          
    usleep(100);
    outb(0xFE, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]                                                                                                                                  
    usleep(100);
    busy = 0x80;
    busy &= inb(DATAREG);
 
sinon, le test (busy?1:0) va être assez aléatoire.
 
A+,


---------------
There's more than what can be linked! --  Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻
n°2110628
Profil sup​primé
Posté le 09-11-2011 à 21:46:17  answer
 

J'obtiens pas le même comportement de wait_busy selon le programme auquel je l'integre.
 
J'ai à nouveau un curseur comme au début du travail.
J'ai viré LCD_SoftReset. Et il est apparu.  [:shimay:1]

n°2110629
Profil sup​primé
Posté le 09-11-2011 à 21:55:01  answer
 

Je travaille sur ce code là.
Je trouve que c'est ce que nous avons de mieux.
Parce que c'est le premier à afficher quelque chose de plus ou moins cohérent avec l'utilisation de Wait_busy(celui que tu vien de poster).
 
 

Code :
  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 NEWCODE 0
  12. #ifdef NEWCODE
  13. /* ***************************************************************************** */
  14. /*                       Commandes de bas niveau                                 */
  15. /* ***************************************************************************** */
  16. // Envoi de commandes SPP -> LCD
  17. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
  18.  
  19.   outb(0x0B, CONTROLREG); // Set Control [0x0B 0: Emission, B: RS RW E inactive]
  20.   usleep(100);
  21.   outb(cmd,  DATAREG);    // Set command in DATA
  22.   usleep(100);
  23.   outb(0x0A, CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
  24.   usleep(100);
  25.   outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  26.   usleep(100);
  27. }
  28.     // Envoi d'un caractere SPP -> LCD
  29. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
  30.   outb(0x03, CONTROLREG); // Set Control [0x03 0: Emission, 3: RS active]
  31.   usleep(100);
  32.   outb(c,    DATAREG);    // Set command in DATA
  33.   usleep(100);
  34.   outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
  35.   usleep(100);
  36.   outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  37.   usleep(100);
  38. }
  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
  42.   outb(0x29, CONTROLREG); // Set Control [0x29 2: Reception, 9: RW active]
  43.   usleep(1);
  44.   outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
  45.   usleep(1);
  46.   outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  47.   usleep(1);
  48.   address &= inb(DATAREG);
  49.   return address;
  50. }
  51. // Test du flag busy du LCD.   
  52. void wait_busy() {             // Cas RS=0, (Reception et) RW = 1
  53.   //unsigned char maxtries = 255;
  54.   unsigned char busy = 0x80; // Mask for D7
  55.  
  56.   do {   
  57.    
  58.    
  59.     outb(0x01, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]                                                                                                                           
  60.     usleep(100);
  61.     outb(0xFE, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]                                                                                                                                   
  62.     usleep(100);
  63.     busy = 0x80;
  64.     busy &= inb(DATAREG);   
  65.     usleep(100);
  66.     printf("DATAREG: %x\n", inb(DATAREG));
  67.     //--maxtries;
  68.   } while  (busy?1:0);
  69. }
  70. // Lecture valeur a l'addresse courante RAM LCD -> SPP
  71. unsigned char data_read() {   // Cas RS=1, (Reception et) RW = 1
  72.   unsigned char data;
  73.   outb(0x21, CONTROLREG); // Set Control [0x21 2: Reception, 1: RS RW active]
  74.   usleep(1);
  75.   outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Reception, 0: RS RW E active]
  76.   usleep(1);
  77.   outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]
  78.   usleep(1);
  79.   data = inb(DATAREG);
  80.   return data;
  81. }
  82. void LCD_Position(int pos) {
  83.   outb(0x08, CONTROLREG);
  84.   usleep(20);
  85.   outb(128+pos, DATAREG);
  86.   usleep(20);
  87.   outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]                                                     
  88.   usleep(10);                 // Strobe duration: 500 ns                                                                                     
  89.   outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]                                                           
  90.   usleep(50);                 // Wait before next strobe: 500 ns                                                                             
  91. }
  92. #else
  93. // Envoi de commandes SPP -> LCD
  94. void send_cmd(unsigned char cmd) { // Cas RS=0, (Emission et) RW=0
  95.   outb(cmd, DATAREG);        // Set command in DATA
  96.   usleep(100);
  97.   outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]
  98.   usleep(100);                 // Strobe duration: 500 ns   
  99.   outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  100.   usleep(100);                 // Wait before next strobe: 500 ns
  101. }
  102. // Envoi d'un caractere SPP -> LCD
  103. void send_char(char c) {    // Cas RS=1, (Ecriture et) RW = 0
  104.   outb(c,    DATAREG);    // Set command in DATA
  105.   usleep(100);
  106.   outb(0x02, CONTROLREG); // Signal LCD with a strobe [0x02 0: Emission, 2: RS E active]
  107.   usleep(100);              // Strobe duration: 500 ns   
  108.   outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  109.   usleep(100);              // Wait before next strobe: 500 ns
  110. }
  111.     // Lecture addresse courante RAM LCD -> SPP
  112. unsigned char address_read() { // Cas RS=0, (Reception et) RW = 1
  113.   unsigned char address = 0x7F; // Mask for D6..D0
  114.      
  115.   outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
  116.   usleep(100);
  117.   outb(0x28, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]
  118.   usleep(100);              // Strobe duration: 500 ns
  119.   address &= inb(DATAREG);
  120.   outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  121.   usleep(100);              // Wait before next strobe: 500 ns
  122.   return address;
  123. }
  124. // Test du flag busy du LCD.   
  125. void wait_busy() {             // Cas RS=0, (Reception et) RW = 1
  126.   //unsigned char maxtries = 255;
  127.   unsigned char busy = 0x80; // Mask for D7
  128.  
  129.   do {   
  130.     outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
  131.     usleep(100);
  132.     outb(0x01, CONTROLREG); // Signal LCD with a strobe [0x28 2: Reception, 8: RW E active]                                                                                                                           
  133.     usleep(100);
  134.     outb(0xFE, CONTROLREG); // Reset CONTROL [0x0B 0: Emission, B: RS RW E inactive]                                                                                                                                   
  135.     usleep(100);
  136.     busy = 0x80;
  137.     busy &= inb(DATAREG);   
  138.     usleep(100);
  139.     printf("DATAREG: %x\n", inb(DATAREG));
  141.   } while  (busy?1:0);
  142. }
  145.     outb(0x01, CONTROLREG); // Signal LCD with a strobe [0x28 2: Read, 8: RW E active]
  146.     usleep(100);              // Strobe duration: 500 ns
  147.     busy &= inb(DATAREG);
  148.     outb(0xFE, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  149.     usleep(100);              // Wait before next strobe: 500 ns
  150.   } while  (busy?1:0);
  151. }
  152. // Lecture valeur a l'addresse courante RAM LCD -> SPP
  153. unsigned char data_read() {   // Cas RS=1, (Reception et) RW = 1
  154.   unsigned char data;
  155.  
  156.   outb(0x00, DATAREG);    // reset DATA [NOTE: C'est peut être une précaution inutile, a tester sans ]
  157.   usleep(100);
  158.   outb(0x20, CONTROLREG); // Signal LCD with a strobe [0x20 2: Read, 0: RS RW E active]
  159.   usleep(100);              // Strobe duration: 500 ns   
  160.      data = inb(DATAREG);
  161.      outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]
  162.      usleep(100);              // Wait before next strobe: 500 ns
  163.      return data;
  164.     }
  165. void LCD_Position(int pos) {
  166.   outb(0x08, CONTROLREG);
  167.   usleep(20);
  168.   outb(128+pos, DATAREG);
  169.   usleep(20);
  170.   outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]                                                     
  171.   usleep(10);                 // Strobe duration: 500 ns                                                                                     
  172.   outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]                                                           
  173.   usleep(50);                 // Wait before next strobe: 500 ns                                                                             
  174. }
  175.     #endif
  176. /* ***************************************************************************** */
  177.     /*                       Commandes du LCD                                        */
  178.     /* ***************************************************************************** */
  179.     // cas 00000001
  180.     void LCD_Clear() {
  181.       unsigned char command = 0x01;  // Clear command
  182.        wait_busy(); /* wait */;
  183.      usleep(1);
  184.      send_cmd(command);
  185.     }
  186.     // cas 0000001x
  187.     void LCD_Home() {
  188.      unsigned char command = 0x02;  // Home command
  189.      wait_busy(); /* wait */;
  190.      send_cmd(command);
  191.     }
  192.     // cas 000001xx
  193.     void LCD_EntryMode(int lr, int shift) {
  194.       unsigned char command = 0x04;  // Entry Mode command
  195.      if (lr)      command |= 0x02; // Left -> Right [else Right Left] default
  196.      if (shift)   command |= 0x01; // Shift visible   
  197.      wait_busy(); /* wait */;
  198.      usleep(1);
  199.      send_cmd(command);
  200.     }
  201.     // cas 00001xxx
  202.     void LCD_Display(int on, int cursor, int blink) {
  203.      unsigned char command = 0x08;  // DISPLAY command
  204.      if (on)      command |= 0x04; // Display on/off bit
  205.      if (cursor)  command |= 0x02; // Cursor on/off bit
  206.      if (blink)   command |= 0x01; // Cursor blink on/off bit
  207.      //wait_busy(); /* wait */;
  208.      usleep(1);
  209.      send_cmd(command);
  210.     }
  211.     // cas 0001xxxx -> LCD CursorMove (et Display Move)
  212.     // cas 001xxxxx
  213.     void LCD_Mode(int size8, int line2, int bigfont) {
  214.      unsigned char command = 0x20;  // Mode command
  215.      if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
  216.      if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
  217.      if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
  218.      wait_busy(); /* wait */;
  219.      send_cmd(command);
  220.     }
  221.     // cas 01xxxxxx -> LCD Set CGRAM
  222.     // cas 1xxxxxxx -> LCD Set DDRAM
  223.     /* ***************************************************************************** */
  224.     /*                       Fonctions de "haut niveau"                              */
  225.     /* ***************************************************************************** */
  226.     // Ecriture d'un caractère
  227.     void LCD_WriteChar(char c) {
  228.      wait_busy(); /* wait */;
  229.    
  230.      send_char(c);
  231.     }
  232.     // Ecriture d'une chaine
  233. void LCD_WriteString(char *s) {
  234.   while (*s) {   
  235.    
  236.     send_char(*s++);
  237.   }
  238. }
  239.     // Reset du LCD et Initialisation
  240.     // Note le hard reset de mise sous tension equivaut a LCD_SoftReset(1,0,0)
  241.     void LCD_SoftReset(int size8, int line2, int bigfont) {
  242.      unsigned char command = 0x20;  // Mode command
  243.      if (size8)   command |= 0x10; // 8 bit data [else 4 bit data mode] default
  244.      if (line2)   command |= 0x08; // 2 lines mode [else 1 line mode] default
  245.      if (bigfont) command |= 0x04; // 5x11 font [else 5x8 font, default]
  246.      // Sequence de reinitialisation
  247.      // D'abord, 3 commandes Mode avec la valeur voulue pour bit8
  248.      //wait_busy(); /* wait */;
  249.      send_cmd(command); //   
  250.      usleep(5000);      // more than 4.1 ms
  251.      send_cmd(command);
  252.      usleep(500);      // more than 100 µs
  253.      send_cmd(command); // Maintenant is_busy va fonctionner   
  254.      usleep(500);      // more than 100 µs
  255.      // Sequence de parametrage
  256.      LCD_Clear();                     // Display Clear
  257.      wait_busy(); /* wait */;
  258.      LCD_Mode(size8, line2, bigfont); // les valeurs passees seront inchangeables dorenavant
  259.      wait_busy(); /* wait */;
  260.      LCD_Display(0, 0, 0);            // Display Off
  261.      wait_busy(); /* wait */;
  262.      
  263.      LCD_EntryMode(1, 0);             // Left-Right, no shift
  264.      wait_busy(); /* wait */;
  265.     }
  266. int main (void) {
  267.  
  268.   char date[9];
  269.   char hostname[9];
  270.  
  271.   char dummy[4096];
  272.  
  273.   char file[] = "/proc/meminfo";
  274.   FILE *fp;
  275.   char valeur[10];
  276.   char name[10];
  277.   char cpu[7];
  278.   FILE *cpufp;
  279.   char label_cpu[]  = "cpu   : \0";
  280.   char label_mem[]  = "mem   : \0";
  281.   char label_swap[] = "swap  : \0";
  282.   char label_proc[] = "proc  : \0";
  283.   char label_pid[]  = "pid   : \0";
  284.   char label_pri[]  = "prio  : \0";
  285.  
  286.   float mem_total, mem_free, mem_swap, mem_used = 0.0;
  287.  
  288.   char value_total[10];
  289.   char value_swap[10];
  290.  
  291.   char getted_char;
  292.  
  293.  
  294.   if (system(dummy)) return (1);
  295.  
  296.   fp = fopen(file, "r" );
  297.   if (!fp) {
  298.     perror("/proc/meminfo" );
  299.     return -1;
  300.   }
  301.    
  302.   time_t current_date = time(NULL);
  303.  
  304.   strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  305.   gethostname(hostname, sizeof(hostname));
  306.  
  308.   if (ioperm(BASEPORT, 3, 1)) {
  309.     perror("can't set IO permissions!" );
  310.     return -1;
  311.   }
  312.  
  313.   //LCD_SoftReset(1,1,0); // Ce serait bien de tester ceci aussi
  314.   usleep(500);
  315.   LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink     
  316.   usleep(120); 
  317.    
  318.   int i;
  319.     for (i = 1; i <= 5 ; i++) {
  320.     fscanf(fp, "%s%s%s\n", name, valeur, dummy);
  321.     current_date = time(NULL);
  322.     cpufp = popen("ps aux| awk 'NR > 0 { s +=$3 }; END {print s}'","r" );
  323.     fread(cpu, 1, sizeof(cpu)-1, cpufp);
  324.     fclose(cpufp);
  325.     switch (i) {
  326.      
  327.     case 1 : {
  328.      
  329.       char *p_conv = NULL;
  330.       mem_total = (float)strtol(valeur, &p_conv, 10);
  331.      
  332.      
  333.       break;
  334.     }
  335.     case 2 : {
  336.       char *p_conv = NULL;
  337.       mem_free = (float)strtol(valeur, &p_conv, 10);
  338.       mem_used = ((mem_total-mem_free)*100)/mem_total;
  339.      
  340.       break;
  341.     }
  342.     case 5 : {
  343.       char *p_conv = NULL;
  344.       mem_swap = (float)strtol(valeur, &p_conv, 10);
  345.       strftime(date, sizeof(date), "%H:%M:%S", localtime(&current_date));
  346.      
  347.       LCD_Clear();
  348.       usleep(120);
  349.       LCD_Position(14);
  350.      
  351.      
  352.       usleep(120);
  353.       LCD_WriteString(hostname);
  354.       usleep(120);
  355.       LCD_WriteString(date);
  356.       usleep(120);
  357.      
  358.       LCD_Position(54);
  359.      
  360.       usleep(120);
  361.       LCD_WriteString(label_cpu);
  362.       usleep(120);
  363.       LCD_WriteString(cpu);
  364.       usleep(120);
  365.      
  366.       LCD_Position(0);
  367.      
  368.       LCD_WriteString(label_mem);
  369.       usleep(120);
  370.       sprintf(value_total, "%f", mem_used);
  371.       LCD_WriteString(value_total);
  373.       usleep(120);
  374.       LCD_Position(40);
  375.      
  376.       usleep(120);
  377.       LCD_WriteString(label_swap);
  378.       usleep(120);
  379.       sprintf(value_swap, "%f", mem_swap);
  380.       LCD_WriteString(value_swap);
  381.      
  382.       sleep(1);
  383.      
  384.     }
  385.     }
  386.   }
  387.   fclose(fp);
  388.  
  389.   if (ioperm(BASEPORT, 3, 0)) {
  390.     perror("can't reset IO permissions!" );
  391.     return -1;
  392.   }
  394.   return 0;
  395. }


 
Il manquerait une fonction de positionnement. Même pas.


Message édité par Profil supprimé le 09-11-2011 à 21:58:06
n°2110647
Profil sup​primé
Posté le 10-11-2011 à 00:46:52  answer
 

gilou a écrit :

Donc c'est OK: On est en ligne 1, au 9e caractère :whistle:  
 
Bon, je suis à la bourre, alors c'est très brut de décoffrage...
 

Code :
  1. void set_rawposition(unsigned char rawposition) {
  2.     unsigned char command = 0x80 + rawposition;
  3.     unsigned char control = GetControl();
  4.    
  5.     Set_RS(control);
  6.     usleep(1); 
  7.     SetData(command);
  8.     Set_E(control);
  9.     usleep(1); 
  10.     Clear_E(control);
  11.     usleep(1); 
  12.    
  13. }


 
Je vais bouffer, la.
A+,


 
Le code qui suit fonctionne, même version de bibliothèque. Mais pas le même ordre des instructions.
 

Code :
  1. void set_rawposition(unsigned char rawposition) {
  2.   unsigned char command = 0x80 + rawposition;
  3.   unsigned char control = GetControl();
  4.   Clear_RS(control);
  5.   usleep(1);
  6.   SetData(command);
  7.   Set_E(control);
  8.   usleep(1);
  9.   Clear_E(control);
  10.   usleep(1);
  11.   Set_RS(control);
  12. }


 

n°2110649
Profil sup​primé
Posté le 10-11-2011 à 01:30:46  answer
 

Ca plante toujours à l'utilisation de firefox. Je vais faire tourner un peu.
 
La j'ai retrouvé le code qui fonction sans précondition, si ce n'est qu'il ne faux pas avoir planté l'afficheur avant.
 
Au boot ça marche, après j'ai capté quand l'intérompre ou pas. J'ai des programme pour récupérer un plantage. Faut que j'arrive à tout réunir. Et manquera plus que le buzy.

Message cité 1 fois
mood
Publicité
Posté le   profilanswer
 

 Page :   1  2  3  4  5  6  7  8
Page Suivante
Page Précédente
Haut de page 

Aller à :
Ajouter une réponse
 

Sujets relatifs
[C] Modifier un tableau existant ... pour bouger un pion ![C# / .Net] Migration OS 32Bits vers OS 64Bits. Quid des Perfs?
[C#] FormView, edit/insert mode[C] programme cherche les racines des polynomes
[C] trouver la longueur de la plus longue suite decroissante en CC++, Compter des caractères ...
Linux C/C++ broadcast UDP sur machine sans gatewayConvolution de 2 tableaux unidimensionnels avec FFTW C++
Plus de sujets relatifs à : [ Divers / C ] Ecrire pour un afficheur LCD

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.477 secondes

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)