[ Divers / C ] Ecrire pour un afficheur LCD

Recherche :

Mot : Pseudo : Filtrer
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

gilou

Modérateur
Modosaurus Rex

Reprise du message précédent :

Code :

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

En jouant sur la valeur de REGISTER_DELAY on devrait finir par tomber sur une qui marche

Les changements de mes deux codes précédents:
1) Réécriture en deux phases dans le registre de contrôle, au lieu d'une seule, ça colle mieux avec le datasheet (sinon, le strobe risque de démarrer quand le voltage est pas assez haut sur RS ou RW)
2) (code suivant)
code avec busy_wait, au lieu de is_busy (et donc juste une boucle de strobe-lecture)
Bon, ce coup ci, j’arrête la machine.

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 -- (╯°□°)╯︵ ┻━┻

Publicité

Profil supprimé

Bonjour Gilou !

J'ai rebooté.
J'ai mis les données à zero. (pas de tension sur le bit 8 (en partant de 1) du registre de données)
J'ai exécuté le programme (avec busy_wait)
Je me trouve avec de la tension faible sur le bit en question. Faible tension mais tension.
Et impossible de le mettre à zéro. Obligé de rebouter.

A côté de la broche en question sur le LCD j'ai bien le +5 volt pour le rétro-éclairage mais c'est pas la même tension.
Puis il s'allume qu'à l'exécution du programme.

Enfin, soit y a un truc à creuser, j'espère... Ou le port parallèle qui aurait surchauffé ??

Bonne nuit si non ?

edit : d'ailleurs, tout les bit de donnée sont à 1.

edit 2 : mais dans la version précédente et qui fonctionne ça fait pareil.

edit 3 : j'ai pas dormis moi, en fait non, le programme précédent termine avec le bit 8 à zéro.

Désolé Gilou.

Mine de rien je t'ai tout fait ré-écrire sans parapin a cause d'une soudure.... Je te dois une boutanche.

Message édité par Profil supprimé le 02-11-2011 à 18:47:46

gilou

Modérateur
Modosaurus Rex

[:aka44] I'm baaack!

A+,

Profil supprimé

Hello Gilou ! :hello:

gilou

Modérateur
Modosaurus Rex

Bon alors si tu me récapitulais ce qui marche ou pas...
A+,

Profil supprimé

busy wait dans les deux dernier code que tu a posté et dans ceux avec parapin, le busy fonction pas non plus.

Message cité 1 fois

Profil supprimé

Ca c'est ce que marche pas., (je me réveil).

Le code précédent les deux dernier, soit celui que je vais poster ici fonctionnerait mais comme je t'ai dis mon afficheur est mort.

Code :

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

Profil supprimé

Et un truc que je pige pas, à la fin de l'exécution de ce programme ci-dessus, les pin de données sont à 1
Si j'envoie, 0 sur le port de données, ça n'éteint pas, si j'envoie 11 sur le port de contrôle les pin de données s'éteignent.

Et je dois envoyer 255 sur le port de contrôle à la finc du programme ci-dessus pour que le texte s'affiche correctement.

Message édité par Profil supprimé le 03-11-2011 à 15:38:12

gilou

Modérateur
Modosaurus Rex

Citation :

Et je dois envoyer 255 sur le port de contrôle à la finc du programme ci-dessus pour que le texte s'affiche correctement.

C'est pas normal ça.

Citation :

Si j'envoie, 0 sur le port de données, ça n'éteint pas, si j'envoie 11 sur le port de contrôle les pin de données s'éteignent.

0 sur le port de données et 11 en décimal, soit 0x0B en hexa? en principe mon programme envoie 0x0B après toute commande.
outb(0x0B, CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]

A+,

Message cité 1 fois
Message édité par gilou le 03-11-2011 à 16:30:43

Profil supprimé

gilou a écrit :

0 sur le port de données et 11 en décimal, soit 0x0B en hexa?

oui, j'envoie 0 et 11 en décimal.

Publicité

gilou

Modérateur
Modosaurus Rex

Et avant ça, le texte ne s'affiche pas correctement?
Y'a rien d'affiché ou du garbage d'affiché?
C'est comme si il avait pas vu le précédent fin de strobe.
A+,

Profil supprimé

Bonjour gilou !
Y a du texte, mais il est quasiment complètement effacé, et ça scintille.

Profil supprimé

j'ai testé le texte suivant :

Code :

LCD_WriteString("...... Hello world !" );
LCD_WriteString("                    " ); // ligne vide pour sauter à la seconde ligne.
LCD_WriteString("Bonjour le monde." );

A l'affichage, j'ai bien la totalité du texte ; Sauf les 8 premier caractère de la première et seconde ligne qui sont à peine lisible.
Et les pin de données sont bien à zéro.

Je pense que c'est du à l'afficheur qui serait en partie grillé.

Si j'envoie 255 sur le registre de contrôle, le début des lignes apparaissent, et les pins de donnée sont mis à 1.

gilou

Modérateur
Modosaurus Rex

Citation :

Sauf les 8 premier caractère de la première et seconde ligne qui sont à peine lisible.

Si j'envoie 255 sur le registre de contrôle, le début des lignes apparaissent

C'est louche, ça.
A+,

Profil supprimé

J'ai testé un autre afficheur, mieux soudé et tout, ça marche pas du tout ; Donc, je peut pas avancer pour le moment.
J'irai voir si il y a moyen d'acquérir d'autres afficheurs cet après midi.

gilou

Modérateur
Modosaurus Rex

ça marche, mais partiellement sur un afficheur, et pas du tout sur un autre en meilleur état? :pt1cable:
Cette histoire des 8 premiers caractères mal lisibles sur l'autre, qui deviennent visibles avec un demi-strobe en rab, c'est très bizarre.
J'ai plus l'impression d'un pb de synchro qu'autre chose
A+,

Profil supprimé

gilou, y aurait il moyen que tu me montre avec ce programme comment en faire une librairie que je pourrais exploiter avec Ada en faisant un import des divers fonction utiliser ici ?
Si tu as du temps.

gilou

Modérateur
Modosaurus Rex

Tu es sous unix/linux, c'est ça?

Normalement, une librairie C, c'est comme un programme, sauf que il n'y a pas de main, et tu compiles pour une librairie (en général, son nom commencera par lib) et pas pour un exécutable (tu dois avoir des options de compilation pour cela).
Après, pour l'utiliser depuis ADA, je sais pas trop, mais c'est au niveau
1) de l'édition de lien
2) des conventions d'appel des fonctions (passage de paramêtre, retour de valeur)
qu'il faut vérifier que tout est compatible

A+,

gilou

Modérateur
Modosaurus Rex

En cherchant un peu:
Au niveau du code c, rien à changer, pas besoin de lib, tu peux linker directement avec l'objet résultant de la compilation du code C.
Au niveau Ada, il faut faire les déclarations ad-hoc, avce des Pragma Import cf: http://gcc.gnu.org/onlinedocs/gnat [...] acing-to-C
Et il faut linker le tout au moment de l'édition de lien.

A+,

Message édité par gilou le 04-11-2011 à 15:27:39

Profil supprimé

J'ai compilé l'objet C avec l'option "-c" ; j'obtiens un ".o"

Après je compile avec gnatmake paralcd -largs c_object.o
J'ai fait l'import de is_busy en utilisant interfaces.C;
Je me tape un storage_error juste en utilisant is_busy.

C'est pas gagné. Mais...
Merci gilou !

Profil supprimé

Ca marche !

Profil supprimé

Bonjour,
Bonjour à tous.
Bonjour Gilou si tu me lis.

Vous ne m'en voudrez pas si je colle un petit bout de code écrit avec Ada j'espère.
J'ai écrit un programme qui affiche un texte défilant sur l'afficheur avec Ada depuis lequel j'ai importé les fonctions qui vont bien.
Je fais défiler le texte caractère par caractère de droite à gauche sur une ligne, le texte fait 19 caractères.
Malheureusement, après quelque itération le programme plante dans une boucle de test de is_busy, soit dans LCD_WriteString, soit dans LCD_Home.
Voici mon code si nécessaire.

Code :

with Interfaces.C;
use Interfaces;
procedure Paralcd is
 
   procedure LCD_SoftReset(Size8 : in C.Int; Line2 : in C.Int; Bigfont : in C.Int);
   pragma Import (C, LCD_SoftReset, "LCD_SoftReset" );
   procedure LCD_Display(on : in C.Int; cursor : in C.Int; blink : in C.Int);
   pragma Import (C, LCD_Display, "LCD_Display" );
   procedure LCD_WriteString(Text : in C.Char_Array);
   pragma Import (C, LCD_WriteString, "LCD_WriteString" );
   procedure LCD_Clear;
   pragma Import (C, LCD_Clear, "LCD_Clear" );
   procedure LCD_Home;
   pragma Import (C, LCD_Home, "LCD_Home" );
   procedure Finalize;
   pragma Import (C, Finalize, "finalize" );
   procedure Open_Port;
   pragma Import (C, Open_Port, "open_port" );
   procedure Close_Port;
   pragma Import (C, Close_Port, "close_port" );
 
   Text1    : String(1..19) := "Bonjour le monde...";
 
   window : String(1..19) := (others => ' ');
 
 
   Size    : C.Int := 1;
   Line    : C.Int := 1;
   Bigfont : C.Int := 0;
   On      : C.Int := 1;
   Cursor  : C.Int := 1;
   Blink   : C.Int := 1;
   use Interfaces.C;
 
   Index : Positive := 1;
begin
   Open_Port;
   LCD_SoftReset(Size, Line, Bigfont);
   delay 0.1;
   LCD_Display(On, Cursor, Blink);
   delay 0.1;
   loop
      for I in reverse 1..19 loop
         Window(I..19) := Text1(1..Index);
         LCD_WriteString(To_C(window));
         delay 0.5;
         --Finalize;
         --delay 0.1;
         LCD_Home;
         delay 0.1;
         Index := Index + 1;
 
      end loop;
      Index := 1;
      window := (others => ' ');
   end loop;
   Close_Port;
end Paralcd;

La fonction Finalize est un envoie de la valeur 0x0B sur le registre de contrôle du port parallèle. Elle n'est utile théoriquement que dans mon cas, c'est à dire avec un afficheur partiellement défectueux. Ceci dit le comportement est le même sans son utilisation.

J'écris pour creuser l'affaire, à défaut, vous serez avisés.
Par ailleurs, peut-être serait-il intéressant d'implémenter un fonction "LCD_Position" pour positionner le curseur à un emplacement précis de l'afficheur.

Message édité par Profil supprimé le 05-11-2011 à 09:10:37

Profil supprimé

Voici une fonction de positionnement du curseur dans l'afficheur.

Code :

void LCD_Position(int pos) {
  outb(0x08, CONTROLREG);
  usleep(20);
  outb(128+pos, DATAREG);
  usleep(20);
  outb(0x0A,    CONTROLREG); // Signal LCD with a strobe [0x0A 0: Emission, A: E active]                                                     
  usleep(10);                 // Strobe duration: 500 ns                                                                                     
  outb(0x0B,    CONTROLREG); // Reset CONTROL [0x0B 0: Write, B: RS RW E inactive]                                                           
  usleep(50);                 // Wait before next strobe: 500 ns                                                                             
}

J'ai réussi. [:chadouw]

gilou

Modérateur
Modosaurus Rex

Oui, au cas ou tu veux savoir quoi envoyer dans reg:
en binaire: 00W0 X0YZ
X 0 on met le port (le registre Data en fait, je pense) en mode sortie, 1 on met le port en mode entrée.
Y: RS inversé [si le bit est a 0, le pin est a 1, etc]
Y: RW inversé
Z: E inversé

A+,

Message cité 1 fois

gilou

Modérateur
Modosaurus Rex

Après, ce que tu peux faire, c'est
Stocker le numéro de ligne et la position dans la ligne dans des variables positionnées et mises à jour dans le programme (et quand tu fais un write, vérifier que tu écris pas plus loin que la limite possible (80 caractères en tout).
A+,

Message cité 1 fois

Profil supprimé

gilou a écrit :

C'est trop compliqué pour moi. (c'est quoi cette histoire d'inverse, je croyais que c'était la broche 16 qui était inversée... ??).

gilou a écrit :

Je vais le tordre en deux cet afficheur.

A part ça, je pense que la défaillance de l'afficheur influe sur le processus logiciel.
La j'utilise que les derniers caractères de la première ligne, lesquels sont en bon état de fonctionnement et le programme à l'air de tourner.

J'affiche "Bonjour !" caractère par caractère de droite à gauche puis je fait clignoter le text complet 5 fois dans une boucle infini.

C'est encore écrit avec Ada, je vais le faire avec C.

Code :

Size    : C.Int := 1;
   Line    : C.Int := 1;
   Bigfont : C.Int := 0;
   On      : C.Int := 1;
   Cursor  : C.Int := 1;
   Blink   : C.Int := 1;
   Position: C.Int := 18;
   use Interfaces.C;
 
begin
   Open_Port;
   LCD_SoftReset(Size, Line, Bigfont);
   delay 0.2;
   LCD_Display(On, Cursor, Blink);
   delay 0.2;
   LCD_Position(position);
   loop
      for I in 1..9 loop
         LCD_WriteString(To_C(Text1(1..I)));
         delay 0.5;
         Position := Position - 1;
         LCD_Position(position);
         delay 0.1;
      end loop;
      for I in 1..5 loop
         LCD_SoftReset(Size, Line, Bigfont);
         delay 0.2;
         LCD_Display(On, Cursor, Blink);
         delay 0.2;
         LCD_Position(position);
         delay 1.0;
         LCD_WriteString(To_C(Text1(1..9)));
         delay 1.0;
      end loop;
      Position := 18;
      LCD_Position(position);
   end loop;
   Close_Port;
end Paralcd;

A oui, aussi, j'ai testé avec BigFont à 1, ça change rien. C'est pas normal. ??

Et la simple utilisation de firefox suffis à perturber l'exécution du programme.
J'ai testé en mettant un renice -5, c'est pas mieux.
Je resterais, je vais écrire le même programme avec C.

Message cité 1 fois

Profil supprimé

J'ai une autre question sur la production de logiciel avec C.

Comment faire pour séparer le main de la bibliothèque ?

De souvenir, il faut produire un ".h" mais je ne me souviens pas des détails.

Message cité 1 fois

Profil supprimé

J'ai trouvé.

Profil supprimé

Voici le même programme écrit avec C, sauf que j'ai utilisé LCD_WriteChar au lieu de LCD_WriteString.

Code :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <libparalcd.h>
 
int main (void)
{
  if (ioperm(BASEPORT, 3, 1)) {
    perror("can't set IO permissions!" );
    return -1;
  }
  int i;
  int position = 18;
  char FullText[9] = {'B', 'o', 'n', 'j', 'o', 'u', 'r', ' ', '!'};
  port_clear();  
  LCD_SoftReset(1,1,0);
  usleep(500);
  LCD_Display(1, 1, 1); // Display On LCD ON Cursor ON Cursor Blink  
  LCD_Position(position);
  while (1) {
    for (i = 0; i <= 8 ; i++) {
      int j;
      for (j = 0 ; j <= i ; j++) {
    LCD_WriteChar(FullText[j]);
      }
      sleep(1);
      position = position - 1;
      LCD_Position(position);
    }
    for (i = 1 ; i <= 5 ; i++) {
      LCD_SoftReset(1, 1, 0);
      usleep(500);
      LCD_Display(1, 1, 1);
      usleep(500);
      sleep(2);
      LCD_Position(position);
      usleep(500);
      int j;
      for (j = 0 ; j <= 8 ; j++) {
    LCD_WriteChar(FullText[j]);
      }
      sleep(3);
    }
    position = 18;
    LCD_Position(position);
  }
  if (ioperm(BASEPORT, 3, 0)) {
    perror("can't reset IO permissions!" );
    return -1;
  }  
  return 0;
}

gilou

Modérateur
Modosaurus Rex

Les 4 bits du bas du registre CONTROL sont associés a des pins (en écriture seulement) du port //.
Bit 0 -> Pin 0 (E)
Bit 1 -> Pin 14 (RW)
Bit 2 -> Pin 16 (pas utilisé)
Bit 3 -> Pin 17 (RS)

Les 3 qu'on utilise sont inversés (si le bit est a 0, le pin est a 1 et réciproquement) [alors que celui qu'on utilise pas est pas inversé, lui :pt1cable: ]
C'est assez facile ensuite de se faire une table de correspondance:
Si on veut en sortie: alors CONTROL a en bits du bas:
Sans strobe Avec Strobe
RS = 0 et RW = 0 B A
RS = 0 et RW = 1 9 8
RS = 1 et RW = 0 3 2
RS = 1 et RW = 1 1 0
Et les bits du haut de CONTROL, c'est 0: DATA en écriture // -> LCD
2: DATA en lecture // <- LCD

Citation :

A oui, aussi, j'ai testé avec BigFont à 1, ça change rien. C'est pas normal. ??

Ca laisse penser que le SoftReset marche pas

Citation :

Et la simple utilisation de firefox suffis à perturber l'exécution du programme.

:ouch: :ouch: :ouch:
Très très bizarre, ça.
A+,

Message édité par gilou le 05-11-2011 à 13:51:03

Profil supprimé

Merci gilou.

A quoi sert is_busy en fait ?
Je l'ai biaisé, j'ai mis un usleep(2000); à la place, ça fonctionne.

gilou

Modérateur
Modosaurus Rex

Le is_busy attends que le LCD dise qu'il est prêt pour recevoir l'instruction suivante.
A+,

Message cité 1 fois

Profil supprimé

gilou a écrit :

Le is_busy attends que le LCD dise qu'il est prêt pour recevoir l'instruction suivante.
A+,

La ça fait trois heure que ça tourne sans is_buzy, mais parfois ça marche parfois ça marche pas (ça affiche pas le texte défilant à 20 char/s)
Je vais tester un autre jeux de délais d'attente, mais c'est pas le même partout parce que j'ai essayé avec REGISTERY_DELAY, ça n'a pas marché.

Profil supprimé

j'ai mis 500nano seconde partout, ça tourne mais ça affiche pas. :lol:

Profil supprimé

En fait buzy rempli pas ça fonction j'ai l'impression. Ou alors, l'afficheur est mort de ce côté aussi.
La j'ai registery_delay à 500 nano seconde et j'ai mis du delay entre les appel au diverses fonction, et l'affichage est crade.
Si non ça tourne.

Profil supprimé

gilou a écrit :

Code :

Dans ce code il y a LCD_Clear qui bug.

Profil supprimé

Il faut que je reprène ce code, parce qu'apparemment le code suivant, selon l'ordre des fonction la fonction LCD_Home marche pas.
Je dis ça de mémoire. Dans celui- ci on sauvegarde le registre c'est intéressant.

gilou a écrit :

[:wark0]

Bon ben maintenant que ça marche, on va essayer un code propre et efficace:

Message cité 1 fois
Message édité par Profil supprimé le 05-11-2011 à 21:39:31

Profil supprimé

Puré, tout est encore faux, je vois pas le curseur @Home parce que l'afficheur est défectueux. :sweat:

Profil supprimé

Je suis tout décalé.

Pour aller sur le 11iemme caractère de la seconde ligne je dois mettre 82 comme position maintenant. :heink:

Ca fonctionnait bien tout à l'heure. :pt1cable:

gilou

Modérateur
Modosaurus Rex

Tiens, si tu as l'occasion, tu peux me tester cela?

Code :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
// Base port cablé sur LPT1 ici
#define BASEPORT 0x378
#define DATAREG BASEPORT+0
#define STATUSREG BASEPORT+1
#define CONTROLREG BASEPORT+2
// Clear E : outb(control |= 0x01, CONTROLREG);
// Clear RW: outb(control |= 0x02, CONTROLREG);
// Clear RS: outb(control |= 0x08, CONTROLREG);
// Set E : outb(control &= 0xFE, CONTROLREG);
// Set RW : outb(control &= 0xFD, CONTROLREG);
// Set RS : outb(control &= 0xF7, CONTROLREG);
// Set incoming: outb(control |= 0x20, CONTROLREG);
// Set outgoing: outb(control &= 0xD0, CONTROLREG);
#define Clear_E(z) outb(z |= 0x01, CONTROLREG)
#define Clear_RW(z) outb(z |= 0x02, CONTROLREG)
#define Clear_RS(z) outb(z |= 0x08, CONTROLREG)
#define Set_E(z) outb(z &= 0xFE, CONTROLREG)
#define Set_RW(z) outb(z &= 0xFD, CONTROLREG)
#define Set_RS(z) outb(z &= 0xF7, CONTROLREG)
#define DataIn(z) outb(control |= 0x20, CONTROLREG)
#define DataOut(z) outb(control &= 0xD0, CONTROLREG)
#define GetControl() inb(CONTROLREG)
#define GetData() inb(DATAREG)
#define SetData(z) outb(z, DATAREG)
void wait_LCD() {
unsigned char control = GetControl();
unsigned char data = 0xFF;
int maxtries = 255;
while (data && maxtries) {
Clear_E(control);
Clear_RS(control);
Set_RW(control);
SetData(0xFF); // Set All Pins to FF before read
DataIn(control);
Set_E(control); // Strobe command to LCD
data = GetData(); // Read Data
data &= 0x80; // Get high bit
DataOut(control);
--maxtries;
}
Clear_E(control);
Clear_RW(control); // Avoid Bus conflict
}
void LCD_Init(){
unsigned char control = GetControl();
Clear_RS(control);
SetData(0x38); // 8 bits, 2 lignes, (Fonte 5x8)
Set_E(control);
Clear_E(control);
wait_LCD();
Clear_RS(control);
SetData(0x0E); // Display ON Cursor ON
Set_E(control);
Clear_E(control);
wait_LCD();
Clear_RS(control);
SetData(0x06); // Left -> Right
Set_E(control);
Clear_E(control);
wait_LCD();
}
void LCD_ClearDisplay() {
unsigned char control = GetControl();
Clear_RS(control);
SetData(0x01);
Set_E(control);
Clear_E(control);
wait_LCD();
}
void LCD_WriteChar(char c) {
unsigned char control = GetControl();
Set_RS(control);
SetData(c);
Set_E(control);
Clear_E(control);
wait_LCD();
}
void LCD_WriteString(char *s) {
while (*s)
LCD_WriteChar(*s++);
}
void LCD_CursorStartLine1() {
unsigned char control = GetControl();
Clear_RS(control);
SetData(0x80);
Set_E(control);
Clear_E(control);
wait_LCD();
}
void LCD_CursorStartLine2() {
unsigned char control = GetControl();
Clear_RS(control);
SetData(0xC0);
Set_E(control);
Clear_E(control);
wait_LCD();
}
int main (int argc, char * argv[]) {
if (ioperm(BASEPORT, 3, 1)) {
perror("can't set IO permissions!" );
return -1;
}
LCD_Init();
LCD_ClearDisplay();
LCD_WriteString("Hello" );
LCD_CursorStartLine2();
LCD_WriteString("Jovalise!" );
printf("Taper quelque chose pour quitter le programme\n" );
getchar();
if (ioperm(BASEPORT, 3, 0)) {
perror("can't reset IO permissions!" );
return -1;
}
return 0;
}

Bon, je vais dormir.

A+,

Profil supprimé

Bonjour gilou.

J'arrive au getchar du main, mais j'affiche rien.
J'ai mis des délais de 500ns un peu partout, ça donne pas mieux.

A la fin de l'exécution tous les pin de données sont à 1.

Message cité 1 fois
Message édité par Profil supprimé le 06-11-2011 à 10:33:47

Publicité

Page : 1 2 3 4 5 6 7 8

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

[ Divers / C ] Ecrire pour un afficheur LCD

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 C	C++, Compter des caractères ...
Linux C/C++ broadcast UDP sur machine sans gateway	Convolution de 2 tableaux unidimensionnels avec FFTW C++
Plus de sujets relatifs à : [ Divers / C ] Ecrire pour un afficheur LCD

Page générée en 0.308 secondes