Discussion :

[Artemus24]

Salut à tous.

J'essaye de comprendre comment fonctionne mon dernier achat :
--> https://www.gotronic.fr/art-afficheu...eres-25649.htm

Les caractéristiques sont :
--> Joy-It.
--> 4 lignes x 20 caractères.
--> HD44780 pour l'afficheur.
--> PCF8574T pour le backpack qui gère l'I2C.

J'ai trouvé des documents sur le net, mais j'ai du mal à comprendre comment fonctionne l'afficheur.
La plupart des exemples que j'ai trouvé sont en python, en mode 4 bits.
J'ai pu à partir de ces exemples, créer mon propre programme en "C/C++".
Mais j'aimerai aller au delà afin de créer d'autres fonctionnalités.

Ce que je ne comprends pas, ce sont les points suivants :

a) comment identifier la version de l'afficheur HD44780 ?

b) ou trouver la bonne documentation de l'afficheur ?
J'ai trouvé celle du HD44780U, mais à vrai dire, je ne sais pas exactement si c'est la même référence ?

c) Il existe deux jeux de caractères, l'un en japonnais (ROM A00) et l'autre pour l'Europe (ROM A02).
Je n'ai pas compris si ce sont deux afficheurs différents ou s'il existe un moyen de basculer d'une ROM à l'autre ?

d) il y deux modes, 4 bits ou 8 bits.
Tous les exemples en python que j'ai pu trouver sont dans le mode 4 bits. Aucun exemple dans le mode 8 bits.
Savez-vous comment gérer le mode 8 bits ?

e) Un octet, c'est 8 bits.
D'après ce que j'ai compris, quand j'utilise i2c_write c'est pour gérer "Input/output buffer".
Autrement dit, ce sont les pins allant de DB0 jusqu'à DB7.

Comment atteindre les pins RS, R/W et E qui sont qualifiés de MPU Interface ?
Dans le cas de certaines commandes, il faut positionner ces pin. Comment faire ?

f) il y a aussi le mode des caractères en 5x8 et 5x10.
J'ai fait des tentatives pour me mettre en mode 5x10, mais cela ne fonctionne pas.

g) je ne comprends pas la différence entre la commande "Display_on/off_control" qui permet d'allumer ou d'étendre l'afficheur et ce que l'on trouve dans les programme python sous la désignation de "backlight" ?
C'est peut-être un léger détail sans grande importance, mais je ne comprends la différence de terminologie.

h) Ce code "Display_on/off_control" ne comprends pas que allumer ou éteindre l'afficheur.
Il y a aussi le mode curseur et le mode blink.
Dois-je à chaque fois que je fais usage du "backlight" positionner correctement le mode curseur et le mode blink ?
A vrai dire, dans la documentation que j'ai, aucune référence n'est faite sur le "backlight".

i) que dois-je faire comme initialisation pour utiliser le mode 8 bits ?
C'est pas clair du tout, et quand j'essaye de suivre la documentation, ça ne fonctionne pas !

Désolé pour toutes ces questions mais je n'y comprends pas grand chose à cet afficheur.

Cordialement.
Artemus24.
@+

[Vincent PETIT]

Salut,

J'essaye de comprendre comment fonctionne mon dernier achat :
[...]
Mais j'aimerai aller au delà afin de créer d'autres fonctionnalités.

Et c'est précisément là où on se rend compte que la plateforme Arduino, au nom de la simplicité, vous enferme dans une forme d'obscurantisme en expliquant simplement comment on s'en sert.

a) comment identifier la version de l'afficheur HD44780 ?

Tu ne peux pas directement, le contrôleur principal est en dessous d'une des pastilles de résine d'epoxy noir qu'on voit au dos du circuit imprimé. Parfois on a de la chance car c'est un circuit intégré sur le quel on peut lire la référence mais dans tous les cas il faut que le vendeur prenne la peine de décrire clairement ce qu'il vend et ici c'est moyennement le cas.

b) ou trouver la bonne documentation de l'afficheur ?
J'ai trouvé celle du HD44780U, mais à vrai dire, je ne sais pas exactement si c'est la même référence ?

Voici comment j'ai retrouvé le contrôleur :
Dans Fiche technique de Gotronic => https://www.gotronic.fr/pj2-lcd2004-1515.pdf ce qui amène à chercher la doc de l'afficheur => http://www.santechdisplay.co.jp/prod...-YFDN-DYNC.pdf puis à la doc du contrôleur qui est sur l'afficheur => https://www.newhavendisplay.com/app_notes/SPLC780D.pdf

De ce que j'ai pu en lire, oui il est compatible avec le légendaire contrôleur HD44780 de Hitachi

c) Il existe deux jeux de caractères, l'un en japonnais (ROM A00) et l'autre pour l'Europe (ROM A02).
Je n'ai pas compris si ce sont deux afficheurs différents ou s'il existe un moyen de basculer d'une ROM à l'autre ?

S'il s'agit bien du contrôleur SPLC780D tout est dans la même CGROM, je ne vois pas de pagination. Sur d'autre contrôleur tu peux avoir plusieurs pages de ROM pour avoir accès a des caractères Européens, Chinois, Cyrillique mais pour moi ce n'est pas le cas de cet afficheur.

d) il y deux modes, 4 bits ou 8 bits.
Tous les exemples en python que j'ai pu trouver sont dans le mode 4 bits. Aucun exemple dans le mode 8 bits.
Savez-vous comment gérer le mode 8 bits ?

Oui je sais comment gérer le 8 bits mais avec cet afficheur tu ne peux pas car ils ont mis de l'électronique derrière qui semble fixer le fonctionnement en 4 bits. J'ai aussi remarqué que beaucoup de monde utilise les afficheurs en 4 bits, je ne sais pas expliquer pourquoi surtout que c'est plus lent (pour au moins deux raisons.) Peut être un soucis d'économie de broches d'entrées/sorties ?

e) Un octet, c'est 8 bits.
D'après ce que j'ai compris, quand j'utilise i2c_write c'est pour gérer "Input/output buffer".
Autrement dit, ce sont les pins allant de DB0 jusqu'à DB7.

Comment atteindre les pins RS, R/W et E qui sont qualifiés de MPU Interface ?
Dans le cas de certaines commandes, il faut positionner ces pin. Comment faire ?

Sur ton afficheur, c'est la petite carte au dos de l'afficheur qui s'en charge. Comme elle gère le mode 4 bits je dirai que les 8 bits que tu envoies par l'I2C peuvent très bien arriver comme ça (faudrait le schéma pour en être sur) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
A/K = bit 7
RS =  bit 6
R/W = bit 5
E =   bit 4
D7 =  bit 3 -+
D6 =  bit 2  | mode 
D5 =  bit 1  | 4 bits
D4 =  bit 0 -+
D3 =  GND
D2 =  GND
D1 =  GND
D0 =  GND

*A/K c'est anode ou cathode de la LED de rétroéclairage du backlight

f) il y a aussi le mode des caractères en 5x8 et 5x10.
J'ai fait des tentatives pour me mettre en mode 5x10, mais cela ne fonctionne pas.

Il faut que je prenne le temps de regarder.

g) je ne comprends pas la différence entre la commande "Display_on/off_control" qui permet d'allumer ou d'étendre l'afficheur et ce que l'on trouve dans les programme python sous la désignation de "backlight" ?
C'est peut-être un léger détail sans grande importance, mais je ne comprends la différence de terminologie.

Je ne comprends pas le sens du terme backlight ici, pour moi en électronique c'est le rétroéclairage qui fait que l'afficheur s'allume. Il peut être contrôlé aussi si on a la main sur la tension qu'on envoie dans le LED backlight.

h) Ce code "Display_on/off_control" ne comprends pas que allumer ou éteindre l'afficheur.
Il y a aussi le mode curseur et le mode blink.
Dois-je à chaque fois que je fais usage du "backlight" positionner correctement le mode curseur et le mode blink ?
A vrai dire, dans la documentation que j'ai, aucune référence n'est faite sur le "backlight".

Pour demander à l'afficheur par exemple de s'allumer + montrer son curseur + le faire clignoter il faut tout simplement mettre sur les 8 broches de l'afficheur :
RS = LOW
R/W = LOW
D7 = LOW
D6 = LOW
D5 = LOW
D4 = LOW
D3 = HIGH
D2 = HIGH
D1 = HIGH
D0 = HIGH

Et faire passer la broche E (enable qui était à précédemment à LOW) de HIGH à LOW

Si tu veux arrêté le clignotement du curseur :

RS = LOW
R/W = LOW
D7 = LOW
D6 = LOW
D5 = LOW
D4 = LOW
D3 = HIGH
D2 = HIGH
D1 = HIGH
D0 = LOW

Et faire passer la broche E (enable qui était à précédemment à LOW) de HIGH à LOW

i) que dois-je faire comme initialisation pour utiliser le mode 8 bits ?
C'est pas clair du tout, et quand j'essaye de suivre la documentation, ça ne fonctionne pas !

Avec cet afficheur c'est impossible sauf :
- Si tu attaques directement l'afficheur avec le LCD en n'alimentant pas l'électronique sur la carte noir derrière l'afficheur, celle qui assure la conversion I2C vers bus parallèle de l'afficheur (mais il faudrait avoir le schéma de cette petite carte pour être sur et certain)
- Si tu dessoudes la petite carte électronique noir (c'est largement faisable en faisant des vas et vient de plus en plus rapide avec un fer à souder sur toutes les broches et en tirant légèrement sur la petite carte noir)


A+

[Artemus24]

Salut Vincent PETIT.

Merci de m'éclairer par tes lumières.

Je tiens à préciser que l'afficheur fonctionne très bien dans le mode 4 bits.

Tu ne peux pas directement

a) justement, ce qui me manque, c'est la documentation !
Comme j'ignore avec précision le type de matériel, je me réfère à ce que je trouve sur le net.

Voici comment j'ai retrouvé le contrôleur :

b) j'ai lu la fiche technique de chez GoTronic, de l'afficheur que j'ai acheté chez eux.
J'ai contacté GoTronic et ils m'ont répondu ce que je savais déjà, sans me fournir d'autres documents que ceux de la fiche technique.
Tu es plus doué que moi pour trouver la bonne documentation.

La documentation que j'ai en ma possession concerne la version HD44780U, celle de Hitachi.
Après avoir parcouru rapidement tes deux documents, ce sont les mêmes que j'ai en ma possession.

c) je pense que ce sont deux afficheurs différents.
D'où mon étonnement d'acheter en France la version japonaise alors qu'il existe une version européenne.

Oui je sais comment gérer le 8 bits mais avec cet afficheur tu ne peux pas car ils ont mis de l'électronique derrière qui semble fixer le fonctionnement en 4 bits.

d) donc je ne peux pas faire la même chose en mode 8 bits. C'est ce que je craignais puisque je ne suis pas arrivé à faire fonctionner ce mode 8 bits.

Quand je regarde de plus près l'afficheur, il y a pourtant 16 pins soudés.
J'avais compris que le mode 4 bits ne concerne que 10 pins et le 8 bits 14 pins.
D'où j'ai cru que le mode 8 bits, pouvait être accessible sur cet afficheur.
C'est un choix qui a été fait et c'est dommage.

Sur ton afficheur, c'est la petite carte au dos de l'afficheur qui s'en charge.

e) j'ai découvert qu'ils appellent cela un sac à dos (backpack).

Il faut que je prenne le temps de regarder.

f) merci de te consacrer à mon problème.

Voici ce que j'ai pu comprendre.
Je n'ai pas la possibilité de travailler en mode 8 bits, donc je n'ai que le 4 bits à ma disposition.
Je dois basculer en mode 1 ligne pour accéder au 5x10 dots.
En mode 2 lignes, cela ne fonctionne pas car il n'y a pas assez de place pour mettre à l'affichage sur mes quatre lignes des caractères en 5x10 dots.

Après le test, je constate que le curseur est bien passé en mode 5x10 dots.
Que je dispose maintenant d'une seule ligne, c'est la 1er et la 3ième de l'afficheur.
Je constate que des segments lignes ne s'affichent plus, mais le seg9 devrait s'afficher.
Par contre, les caractères sont toujours en mode 5x8 dots.

Il est dit qu'il y a seulement 32 caractères en mode 5x10 dots. Lesquels ?
J'ai essayé en mettant des majuscules, je n'obtiens que du 5x8 dots.

h) ma question concernait la différence dans le programme python de la codification suivante vis-à-vis de la documentation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00

LCD_DISPLAYCONTROL = 0x08

# flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00

LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00

LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00

Si je comprends bien, il faut faire deux distinctions :
*) pour éteindre le retro-éclairage, il faut utiliser la commande 0x00 qui n'est pas référencée dans la documentation.
*) pour l'allumer, il faut utiliser la commande LCD_DISPLAYCONTROL.
Sauf que l'affichage possède aussi deux modes, soit LCD_DISPLAYON pour l'activer, LCD_DISPLAYOFF pour le désactiver.

Conclusion :

Si je comprends bien et je suppose à cause du BACKPACK PCF8574, je ne peux pas me mettre en mode 8 bits, sauf si je n'ai pas de BACKPACK !
Je n'arrive pas à basculer en mode 5x10 dots.

Désolé pour autant de questions mais je découvre le produit.

@+

[Artemus24]

Salut à tous.

Je précise que je ne suis pas dans un projet Arduino mais Raspberry et plus particulièrement la RPi 2B.
Les questions suivantes concernent l'I2C !

j) je n'ai pas compris comment forcer la vitesse d'échange en baud dans mon programme en 'C/C++' ?
Tout ce que j'ai pu trouver concerne le paramétrage de "/boot/config.txt" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

dtparam=i2c_arm=on,i2c_arm_baudrate=400000

Peut-on faire la même chose depuis un programme ?

k) Que dois-je faire pour activer les bits RS, E et R/W ?
Dois-je utiliser les fonctions SMBus ?
--> https://www.kernel.org/doc/Documenta...smbus-protocol

Dans le cas des commandes, j'utilise la fonction suivante :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void i2c_write(unsigned char _cmd)
{
        struct  i2c_smbus_ioctl_data    args;
 
        args.read_write         = I2C_SMBUS_WRITE;
        args.command            = _cmd;
        args.size               = I2C_SMBUS_BYTE;
        args.data               = NULL;
 
        if(ioctl(i2c_handle,I2C_SMBUS,&args) < 0)
        {
                fprintf(stderr,"Ioctl Error : %s\n", strerror(errno));
                fprintf(stderr,"Unable to write I2C data\n");
                fflush(stderr);
                exit(EXIT_FAILURE);
        }
}

Comme on peut le voir, le paramétrage est "I2C_SMBUS_BYTE", c'est-à-dire pas de DATA, juste une commande.

l) dans le cas de l'afficheur, j'utilise la fonction ci-dessus.
Autrement dit, j'envoie toujours un octet, soit en tant que commande, soit en tant que données.
Est-ce la bonne façon de faire dans ce cas bien précis ?

Cordialement.
@+

[Vincent PETIT]

Si je comprends bien et je suppose à cause du BACKPACK PCF8574, je ne peux pas me mettre en mode 8 bits, sauf si je n'ai pas de BACKPACK !

Exacte, le LCD doit se commander en 4 bits de donnée + 1 bit RS + 1 bit R/W + 1 bit E puisque le PCF8574 n'est qu'un I/O expander 8 bits.
C'est un mauvais choix de conception.

h) ma question concernait la différence dans le programme python de la codification suivante vis-à-vis de la documentation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00

LCD_DISPLAYCONTROL = 0x08

# flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00

LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00

LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00

Nous allons devoir faire quelques suppositions pour comprendre. Tu pourrais prendre une photo de tout prés et avec un bon éclairage pour qu'on voit quelles broches (LCD) est connectées sur quoi (PCF8574) ?

LCD	PCF8574
RS	P0
R/W	P1
E	P2
D4	P4
D5	P5
D6	P6
D7	P7

Dans ce cas de figure, si on veut demander à l'afficheur par exemple de s'allumer + montrer son curseur + le faire clignoter il faut mettre sur les 8 broches de l'afficheur (voir ici https://fr.wikipedia.org/wiki/HD44780 § Instructions de contrôle et d’affichage)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
RS = LOW
R/W = LOW
D7 = LOW
D6 = LOW
D5 = LOW
D4 = LOW
D3 = HIGH
D2 = HIGH
D1 = HIGH
D0 = HIGH

Mais comme on est en 4 bits il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
RS = LOW
R/W = LOW
D7 = HIGH
D6 = HIGH
D5 = HIGH
D4 = HIGH
    _
E _/ \_

Suivie de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
RS = LOW
R/W = LOW
D7 = LOW
D6 = LOW
D5 = LOW
D4 = LOW
    _
E _/ \_

Pour résumer, AVEC UN CABLAGE ENTRE LE PCF8574 ET LE LCD CONFORME AU TABLEAU, il faut envoyer 0xF0 (on place la donnée et E est à 0), puis faire 0xF4 (pour faire un front montant avec E) suivie de 0x00 (on place la donnée et E est à 0) puis 0x04 (pour faire un front montant avec E)

Voir tableau 5.5 page 9 : https://www.newhavendisplay.com/app_notes/SPLC780D.pdf qui résume les opérations à envoyer dans l'ordre.

Si je comprends bien, il faut faire deux distinctions :
*) pour éteindre le retro-éclairage, il faut utiliser la commande 0x00 qui n'est pas référencée dans la documentation.
*) pour l'allumer, il faut utiliser la commande LCD_DISPLAYCONTROL.
Sauf que l'affichage possède aussi deux modes, soit LCD_DISPLAYON pour l'activer, LCD_DISPLAYOFF pour le désactiver.

Peut être que dans ce code Python, LCD_DISPLAYCONTROL etc sont juste des constantes ? De type masque ? Je ne sais pas trop, il n'y a pas assez de code pour comprendre.

[Artemus24]

Salut Vincent PETIT.

Voici le programme Python dont je me suis inspiré :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import sys
sys.path.append("./lib")
 
import i2c_lib
from time import *
 
# LCD Address
ADDRESS = 0x27
 
# commands
LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80
 
# flags for display entry mode
LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00
 
# flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00
 
# flags for display/cursor shift
LCD_DISPLAYMOVE = 0x08
LCD_CURSORMOVE = 0x00
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00
 
# flags for function set
LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_5x8DOTS = 0x00
 
# flags for backlight control
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00
 
En = 0b00000100 # Enable bit
Rw = 0b00000010 # Read/Write bit
Rs = 0b00000001 # Register select bit
 
class lcd:
   #initializes objects and lcd
   def __init__(self):
      self.lcd_device = i2c_lib.i2c_device(ADDRESS)
 
      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x02)
 
      self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)
      self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)
      sleep(0.2)
 
   # clocks EN to latch command
   def lcd_strobe(self, data):
      self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)
      sleep(.0005)
      self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
      sleep(.0001)
 
   def lcd_write_four_bits(self, data):
      self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
      self.lcd_strobe(data)
 
   # write a command to lcd
   def lcd_write(self, cmd, mode=0):
      self.lcd_write_four_bits(mode | (cmd & 0xF0))
      self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))
 
   #turn on/off the lcd backlight
   def lcd_backlight(self, state):
      if state in ("on","On","ON"):
         self.lcd_device.write_cmd(LCD_BACKLIGHT)
      elif state in ("off","Off","OFF"):
         self.lcd_device.write_cmd(LCD_NOBACKLIGHT)
      else:
         print("Unknown State!")
 
   # put string function
   def lcd_display_string(self, string, line):
      if line == 1:
         self.lcd_write(0x80)
      if line == 2:
         self.lcd_write(0xC0)
      if line == 3:
         self.lcd_write(0x94)
      if line == 4:
         self.lcd_write(0xD4)
 
      for char in string:
         self.lcd_write(ord(char), Rs)
 
   # clear lcd and set to home
   def lcd_clear(self):
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_RETURNHOME)

Exacte, le LCD doit se commander en 4 bits de donnée + 1 bit RS + 1 bit R/W + 1 bit E

J'ai beau relire la documentation, je comprends toujours la même chose.
Je suis d'accord qu'il faut envoyer deux quartets dont l'un est la partie haute de l'octet, en premier, et l'autre la partie basse de l'octet en second.
Mais je n'ai rien trouvé sur le fait qu'il faille aussi positionner dans l'envoi les trois flags (RS, R/W et E) selon ce que l'on veut faire.

Il y a pire dans le simple envoi d'un octet :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
   # clocks EN to latch command
   def lcd_strobe(self, data):
      self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)
      sleep(.0005)
      self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
      sleep(.0001)
 
   def lcd_write_four_bits(self, data):
      self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
      self.lcd_strobe(data)

# write a command to lcd
def lcd_write(self, cmd, mode=0):
self.lcd_write_four_bits(mode | (cmd & 0xF0))
self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))[/code]
Quand on envoie, par la fonction "lcd_write", un octet contenant une commande, cela va se décomposer en :
--> partie haute de l'octet
----> envoie en ajoutant à la donnée LCD_BACKLIGHT
----> envoie en ajoutant à la donnée En et LCD_BACKLIGHT.
----> envoie en ajoutant à la donnée En ermise à zéro et LCD_BACKLIGHT.
--> partie basse de l'octet
----> envoie en ajoutant à la donnée LCD_BACKLIGHT
----> envoie en ajoutant à la donnée En et LCD_BACKLIGHT.
----> envoie en ajoutant à la donnée En ermise à zéro et LCD_BACKLIGHT.

Je croyais que l'envoie d'un octet se décomposant par l'envoie de deux quartets (partie haute puis partie basse). Or il y a six envoies au total !
Le positionnement du RS (passage par la variable mode), se fait dans les six envoies.
La distinction entre l'envoie d'une donnée et l'envoie d'une commande se fait que sur le flag RS. Ici, la donnée est le caractères.

Autre remarque, dans le programme, il y a les constantes suivantes :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
# flags for display entry mode
LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00
 
self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)

sont mal interprétés. Il s'agit des variables I/D et S dans la commande "Entry Mode Set".

Entry Mode Set

I/D: Increments (I/D = 1) or decrements (I/D = 0) the DDRAM address by 1 when a character code is written into or read from DDRAM.
The cursor or blinking moves to the right when incremented by 1 and to the left when decremented by 1.
The same applies to writing and reading of CGRAM.

S: Shifts the entire display either to the right (I/D = 0) or to the left (I/D = 1) when S is 1. The display does not shift if S is 0.
If S is 1, it will seem as if the cursor does not move but the display does. The display does not shift when reading from DDRAM.
Also, writing into or reading out from CGRAM does not shift the display.

Il semble qu'il y a eu inversion car 0x01 correspond à la variable S et 0x02 correspond à la variable I/D.

Il faut normalement interpréter de cette façon :

Pour obtenir un décalage, il faut positionner la variable S à 1 ==> 0x01. Puis,
--> Quand la variable I/D est positionnée à 0 (0x00), le décalage se fait sur la droite (incrément).
--> Quand la variable I/D est positionnée à 1 (0x02), le décalage se fait sur la gauche (décrément).
Sinon (s=0) pas de décalage.

Pour un fonctionnement normal, il faut : S = 0 (pas de décalage) et I/D = 0 (incrément)
Si l'on veut faire un décalage vers la gauche, il faut : S = 1 (décalage) et I/D = 1 (décrément)

Nous allons devoir faire quelques suppositions pour comprendre. Tu pourrais prendre une photo de tout prés et avec un bon éclairage pour qu'on voit quelles broches (LCD) est connectées sur quoi (PCF8574) ?

Sur la face avant, il y a seize Pins, qui sont :
--> VSS VDD V0 RS RW E D0 D D2 D3 D4 D5 D6 D7 A K
Les pins sont tous soudés du PCF8574 vers l'afficheur HD44780.





Ce sont les images de chez GoTronic, et c'est exactement pareil que mon afficheur.

@+

[Vincent PETIT]

Salut,
J'aurai peut être du commencer par là mais c'est compliqué de faire une réponse ordonnée avec des questions dispersées. On va reprendre dans un autre ordre et je vais m'appuyer sur le seul et unique document valable ; la datasheet.

J'ai beau relire la documentation, je comprends toujours la même chose.
Je suis d'accord qu'il faut envoyer deux quartets dont l'un est la partie haute de l'octet, en premier, et l'autre la partie basse de l'octet en second.
Mais je n'ai rien trouvé sur le fait qu'il faille aussi positionner dans l'envoi les trois flags (RS, R/W et E) selon ce que l'on veut faire.

On va commencer par regarder quelque chose de très important et en lien avec "E" qui dans le tableau 4 page 2 est décrit comme étant une Input pour A start signal for reading or writing data.. C'est un signal qui défini un "start" lors des opérations d'écriture et de lecture. Voici le cycle des signaux lors d'un écriture dans l'afficheur, c'est principalement de l'écriture vers l'afficheur qu'on fait même si il y a un grand intérêt à le lire en mode 8 bits mais je n'en parlerai pas ici pour ne pas amener de complexité, il faut le comprendre ainsi :

Quelque soit RS, haut ou bas peu importe, il faut d'abord mettre R/W à low pendant au moins 40ns t_SP1 en rouge. Ensuite on met E à high pendant au moins 230ns t_PW en bleu. Durant ce temps, les données D0 à D7 doivent être fixes pendant 80ns t_SP2 en vert. Enfin E peut repasser à low mais il ne faut pas toucher aux données, ni à R/W pendant au moins 10ns t_HD1 en violet.



Il s'agit de valeurs minimums, elles peuvent être plus longues et avec l'habitude de ce genre de lecture on voit rapidement qu'il n'y a pas de lien temporelle entre certain signaux. Rien n'empêche par exemple de mettre R/W à low et de fixer les données au même moment, puisque au vu du graphe on arrive à entrevoir qu'un front descendant de E valide les données sous conditions qu'elles aient été stable ou resté fixe un peu avant le front et un peu après celui-ci. Quoi qu'il en soit on sent qu'on aura beaucoup de coup de front descendant de E car il s'est à valider ce qu'on envoie vers l'afficheur, E = Enable.

Concernant RS dont l'état importe peu dans le cycle des signaux, sous entendu le cycle est le même qu'on soit avec RS = high ou RS = low, il permet soit d'accéder aux commandes de l'afficheur, le curseur, l'affichage, nombre de ligne), soit à écrire des caractères selon la table de correspondance.



Là tout de suite, je m'aperçois que j'ai oublié quelques choses dans mon précédent message : Soit j'ai oublié le front descendant, soit j'aurai du inverser les valeurs 0xF4 d'abord suivie de 0x00 pour créer un front descendant

Pour résumer, AVEC UN CABLAGE ENTRE LE PCF8574 ET LE LCD CONFORME AU TABLEAU, il faut envoyer 0xF0 (on place la donnée et E est à 0), puis faire 0xF4 (pour faire un front montant avec E) suivie de 0x00 (on place la donnée et E est à 0) puis 0x04 (pour faire un front montant avec E)

Dans le code ci dessous on voit que lcd_clear appelle lcd_write

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def lcd_clear(self):
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_RETURNHOME)

lcd_write appelle lcd_write_four_bit

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def lcd_write(self, cmd, mode=0):
      self.lcd_write_four_bits(mode | (cmd & 0xF0))
      self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))

lcd_write_four_bit appelle write_cmd (j'imagine que c'est l'appel du bus I2C) et surtout on a le lcd_strobe

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def lcd_write_four_bits(self, data):
      self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
      self.lcd_strobe(data)

lcd_strobe c'est E à high suive de E à low avec le maintient des données data.

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def lcd_strobe(self, data):
      self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)
      sleep(.0005)
      self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
      sleep(.0001)

Cette encapsulation me paraît répondre à la description des signaux vu tout en haut. Ensuite la différence entre l'écriture de caractères et la configuration de l'afficheur c'est RS qui change.

Sur la face avant, il y a seize Pins, qui sont :
--> VSS VDD V0 RS RW E D0 D1 D2 D3 D4 D5 D6 D7 A K
Les pins sont tous soudés du PCF8574 vers l'afficheur HD44780.

Arf, la photo est trop sombre pour que j'arrive à voir sur quelle broche du PCF8574 va E (par exemple) et les autres du LCD.

[Artemus24]

Salut Vincent PETIT.

Mais je n'ai rien trouvé sur le fait qu'il faille aussi positionner dans l'envoi les trois flags (RS, R/W et E) selon ce que l'on veut faire.

Je me suis mal exprimé à ce sujet !
Dans la documentation, il est indiqué que l'on doit positionner ces flags en fonction de la commande à utiliser et en particulier RS & R/W.
Pour R/W, il n'y a aucune ambiguïté car cela signifie lecture ou écriture, et qu'il suffisait de l'associer à l'une des fonctions Read/Write de SMBus, oui mais laquelle car il y en a plusieurs et leur désignation ne me renseigne pas sur laquelle est la bonne ?
Pour RS, je pensais que cela était un paramétrage à l'une de ces fonctions.

Je veux dire que les fonctions SMBus devait prendre en charge ces flags mais je n'ai pas compris comment faire avec ces fonctions SMBus.
Et c'est sur ce point que je considère qu'il y a une grosse difficulté, à savoir gérer correctement l'I2C au travers des fonctions SMBus.

Pour exprimer ma pensée, disons que si je désire faire un "RETURN HOME", il suffit de faire quelque chose du genre : "smbus_write_command(LCD_RETURN_HOME)", par ce que c'est une commande sans paramètre.
Et pour écrire une chaîne de caractères : "smbus_write_data(LCD_SETDDRAMADDR, "Hello World!"), par ce que c'est une commande avec un paramètre.
L'idée est là, sauf que je ne sais pas si c'est possible en l'état, afin de ne pas utiliser ces flags contraignants.

De plus, le BACKPACK doit en principe gérer l'I2C, peut-être d'une manière standard, sauf que je me rends compte que ce n'est pas le cas.
Est-ce que ce PACKBACK est trop ancien dans sa conception et qu'il faudrait l'actualiser afin d'utiliser les fonctions SMBus ?

Quelque soit RS, haut ou bas peu importe, il faut d'abord mettre R/W à low pendant au moins 40ns tSP1 en rouge. Ensuite on met E à high pendant au moins 230ns tPW en bleu. Durant ce temps, les données D0 à D7 doivent être fixes pendant 80ns tSP2 en vert. Enfin E peut repasser à low mais il ne faut pas toucher aux données, ni à R/W pendant au moins 10ns tHD1 en violet.

Quand je lis ta phrase, je me demande comment à partir d'un programme comme python, voire 'C/C++', je vais m'y prendre pour réaliser cela.
Dans mon raisonnement d'informaticien, non électronicien, je ne sais gérer que des états et des attentes.
J'entends par état, le positionnement par une action qui va provoquer un changement.
Et par attente, soit un "sleep()" afin de laisser du temps à l'action de se faire, ou d'effectuer une lecture (busy flag) afin de savoir si je peux passer à la suite.

Dans ton exemple, peu clair pour moi, je ne vois pas comment agir.
Bien sûr, en m'aidant du programme python, cela semble plus facile, mais je ne comprends pas pourquoi il en serait ainsi (lcd_write qui va se décomposer en six actions unitaire).

Je refourme à nouveau ma question d'origine : existe-il une fonction SMBus qui va réaliser cela à ma place dans un programme Python ou 'C/C++'.
Tu ne vas pas me faire croire que toutes les actions que l'on peut faire sur un I2C se réalise uniquement par la fonction "self.lcd_device.write_cmd()" ?
Et qu'en est-il des autres fonctions SMBus ?

Je ne connais pas suffisamment l'I2C pour dire que dans tous les cas, le bus se gère ainsi.
Je parle bien sûr des fronts descendants et ascendants du flag E, ainsi que de RS et de R/W.
En gros, je comprends pourquoi la fonction lcd_write est fait ainsi, mais je ne comprends pas pourquoi elle est utilisée de cette façon là ?
Y-a-t-il un problème avec ce PACKBACK ou avec l'afficheur pour ne pas utiliser correctement les fonctions SMBus ?

Si je m'interroge sur ce point, c'est que j'ignore si l'I2C se gère toujours de la même façon avec d'autre périphérique ?
Je pense entre autre à celui du capteur de température DS1621 via bus i2c :
--> https://www.framboise314.fr/i2c-plus...rs-dactualite/

Si ta réponse est : "on ne peut pas utiliser le SMBus", là je ne comprends pourquoi appliquer la norme I2C si elle n'est pas respectée.

@+

[Vincent PETIT]

Salut,
Je me rends compte que l'explication est complexe, on n'a pas toutes les infos et on n'est pas du même métier. Et si toi comme moi apportons trop d'infos d'un coup, on va se perdre.

Déjà, sommes nous d'accord sur le rôle du PCF8574 qui se trouve sur la petite carte noire ?
C'est un simple convertisseur I2C (données séries) vers parallèle (RS, R/W, E, D4, D5, D6, D7).



Avec ce schéma, en supposant que la petite carte noire au dos de ton afficheur est câblée comme ça (c'est ça le problème avec l'écosystème Arduino dès que tu veux dépasser la simple utilisation, on a pas toutes les infos ou on est pas sur ou il faut faire confiance a des tutos ou il faut faire de la rétro ingénierie)

Avec un tel schéma et avec cette histoire de mode 4 bits (données de poids fort en premier, un coup de 'E', données de poids faible ensuite, un coup de 'E'), regardons comment faire un RETURN HOME.

RETURN HOME d'après la datasheet



- La donnée c'est 0x02 (DB0 = peu importe, mettons le à 0) mais on l'enverra en deux fois, sur D7 à D4, le quartet de poids fort 0x0 et ensuite le quartet de poids faible 0x2. On sait aussi qu'il faut un front descendant de E pour valider un quartet.
- La commande c'est 0x00 (RS = 0 et R/W = 0)
- Pour faire un front descendant de E, il faut qu'il soit à 1 puis ensuite qu'il passe a 0.

Faisons correspondre les sorties du PCF8574 avec les borches du LCD, c'est ce que j'espérais voir avec une photo de la petite carte noire, de très prés et avec un fort éclairage.

LCD	PCF8574
RS	P0
R/W	P1
E	P2
-	P3
D4	P4
D5	P5
D6	P6
D7	P7

Refaisons les tableaux d'abord la validation du quartet de poids fort :

LCD	PCF8574	CMD/DATA
RS	P0	0
R/W	P1	0
E	P2	1 on se met à l'état haut en prévision de l'état bas suivant
-	P3	-
D4	P4	0
D5	P5	0
D6	P6	0
D7	P7	0

LCD	PCF8574	CMD/DATA
RS	P0	0
R/W	P1	0
E	P2	0 on se met à l'état bas ce qui a créé un front descendant
-	P3	-
D4	P4	0
D5	P5	0
D6	P6	0
D7	P7	0

Dans les deux tableaux ci dessus, on a validé le premier quartet de poids fort. Maintenant validons le quartet de poids faible.

LCD	PCF8574	CMD/DATA
RS	P0	0
R/W	P1	0
E	P2	1 on se met à l'état haut en prévision de l'état bas suivant
-	P3	-
D4	P4	0
D5	P5	1
D6	P6	0
D7	P7	0

LCD	PCF8574	CMD/DATA
RS	P0	0
R/W	P1	0
E	P2	0 on se met à l'état bas ce qui a créé un front descendant
-	P3	-
D4	P4	0
D5	P5	1
D6	P6	0
D7	P7	0

Les tableaux ci dessus sont le reflet de ce code Python. On remarque que LCD_BACKLIGHT = 0x08 représente P3 du PCF8574, probablement que le hardware lié a ce code utilise P3 pour allumer le rétro éclairage.

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
LCD_RETURNHOME = 0x02
LCD_BACKLIGHT = 0x08
En = 0b00000100 # Enable bit 
 
self.lcd_write(LCD_RETURNHOME)
...
...
def lcd_strobe(self, data):
      self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)
      sleep(.0005)
      self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
      sleep(.0001)

Quel lien faire avec ça ?
Quelque soit RS, haut ou bas peu importe, il faut d'abord mettre R/W à low pendant au moins 40ns t_SP1 en rouge. Ensuite on met E à high pendant au moins 230ns t_PW en bleu. Durant ce temps, les données D0 à D7 doivent être fixes pendant 80ns t_SP2 en vert. Enfin E peut repasser à low mais il ne faut pas toucher aux données, ni à R/W pendant au moins 10ns t_HD1 en violet.



R/W à low pendant au moins 40ns t_SP1 en rouge ? Oui car dans le code Python R/W est mis a 0 et ne change pas d'état pendant la durée de toute la fonction et il y a des sleep xµs en plus
E à high pendant au moins 230ns t_PW en bleu ? Oui car dans le code Python il y a des sleep 5µs et il est probable que la durée d'une transmission I2C soit largement supérieure 230ns.
D0 à D7 doivent être fixes pendant 80ns t_SP2 en vert ? Oui aussi grace au sleep 5µs
E peut repasser à low mais il ne faut pas toucher aux données, ni à R/W pendant au moins 10ns t_HD1 en violet ? Là aussi surtout grace au sleep 1µs


Autre point :

Et c'est sur ce point que je considère qu'il y a une grosse difficulté, à savoir gérer correctement l'I2C au travers des fonctions SMBus.

Attention, ça c'est l'histoire ce qui se passe entre le Raspberry et le PCF8574 (c'est la doc du PCF8574 qu'il faut regarder pour savoir comment causer avec et non celle de l'afficheur), moi ici je parle de la parallélisation de la donnée I2C entre le PCF8574 et le LCD.

J'espère que depuis le début on se comprend ?
J'ai bien peur qu' on n'était chacun d'un côté différent du problème ?

[f-leb]

Salut à vous deux,

L'ami Artemus se lance avec une double difficulté :

• Comment fonctionne le PCF8574 et comment dialoguer avec lui (I2C) ?
• Comment fonctionne un LCD en mode parallèle 4bits ?

Le tout avec une doc très partielle... Un vrai boulot de rétro-ingénierie.

Pour le premier point, tu as aussi wiringPi avec une extension justement dédiée au PCF8574.

Super discussion, je m'abonne

[Artemus24]

Salut Vincent PETIT.

Je me rends compte que l'explication est complexe, on n'a pas toutes les infos et on n'est pas du même métier.

Complexe, non, mais je trouve la documentation mal foutu !
Oui, nous ne sommes pas du même métier, mais cela ne m'interdit pas de réfléchir.
Après tout, j'ai fait le choix d'acheter cet afficheur de Joy-It et actuellement il fonctionne bien en mode 4 bits.
Sauf que je n'ai pas tout compris de son pilotage et c'est dommage pour moi.

Je te remercie de faire des efforts à mon intention.

Et si toi comme moi apportons trop d'infos d'un coup, on va se perdre.

Surtout si l'information que j'apporte et qui a de l'importance pour moi, n'en a pas pour toi.
On risque de ne pas trop avancer. Mais bon, j'ai compris deux choses :
--> le mode 8 bits ne fonctionne pas en l'état de mes connaissances avec ce PCF8574.
--> je ne peux pas toujours utiliser le mode 5x10 dots.
Sauf que cela doit être vérifié ! Ce n'est pas parce que je n'y arrive pas que l'on ne peut pas le faire.

Déjà, sommes nous d'accord sur le rôle du PCF8574 qui se trouve sur la petite carte noire ?

Oui, c'est une interface i2c entre ma raspberry d'un coté et l'afficheur HD44780 de l'autre coté.
C'est la documentation sur cet interface qui me manque.

C'est un simple convertisseur I2C (données séries) vers parallèle (RS, R/W, E, D4, D5, D6, D7).

C'est toi qui m'a communiqué cette information : vers parallèle (RS, R/W, E, D4, D5, D6, D7).
Car je n'ai rien trouvé sur le fait que le PCF8574 gère l'afficheur de cette façon là.

Et l'on revient à ma première question, où trouver la documentation ?
Il est beau ton schéma. C'est toi qui l'a fait où l'as-tu récupéré par ailleurs ?

c'est ça le problème avec l'écosystème Arduino dès que tu veux dépasser la simple utilisation, on a pas toutes les infos ou on est pas sur ou il faut faire confiance à des tutos ou il faut faire de la rétro ingénierie)

C'est entièrement vrai, sauf que j'utilise une raspberry et non un arduino.
Je veux bien faire de la retro-ingénierie, mais je n'ai pas suffisamment de connaissance en ce domaine pour trouver mon chemin.

Faisons correspondre les sorties du PCF8574 avec les borches du LCD, c'est ce que j'espérais voir avec une photo de la petite carte noire, de très prés et avec un fort éclairage.

J'ai beau regardé mon afficheur, même de coté, je ne vois rien de plus que ce qu'indique les deux photos.
Les size pins sont bien soudés que ce soit du coté HD44780 ou du coté PCF8574.
Soit deux choses l'une, ou bien le PCF8574 ne sait pas gérer le mode 8 bits, ce qui serait surprenant, ou bien il y a une séquence particulière qui permet de basculer en mode 8 bits dès le démarrage.
C'est cette séquence que je n'ai pas. Je parle bien de la séquence du PCF8574 et non celle du HD44780.

Merci pour tes tableaux, il est vrai qu'ils sontsimples et clairs.
Ce sont aussi tes précédantes explications qui m'ont permis de mieux comprendre comment fonctionne ce mode 4 bits.

On remarque que LCD_BACKLIGHT = 0x08 représente P3 du PCF8574, probablement que le hardware lié à ce code utilise P3 pour allumer le rétro éclairage.

Ca, tu l'as déduit du code python.

J'espère que depuis le début on se comprend ?

Nous nous comprenons, mais tu restes trop du coté HD44780 alors que mon problème concerne plutôt le PCF8574.

J'ai bien peur qu' on n'était chacun d'un côté différent du problème ?

Je ne peux pas faire autrement que de passer par le PCF8574.
Ou comme tu me l'a indiqué, désouder le PCF8574 de l'afficheur HD44780 et de continuer à travailler seulement avec ce HD44780.

@+

[Artemus24]

Salut f-leb.

Si de ton coté, tu as de la documentation sur ce fameux PCF8574, je suis preneur.

J'ai récupéré tout un tas de chose sur internet, mais cela ne m'aide pas plus que ce que j'ai avec la documentation du HD44780 :
--> https://www.sparkfun.com/datasheets/LCD/HD44780.pdf

Super discussion, je m'abonne

Oui, je confirme, M. Vincent PETIT est un maitre en la matière.

@+

[Delias]

Bonjour

Un afficheur sur base HD44780 ne peut fonctionner qu'avec 7 lignes (4bits + 3 contrôles) ou avec 11 lignes (8 bits et 3 contrôles), et éventuellement avec 1 ligne de moins si on exclu la lecture (R/W est fixé à W). Comme le PCF ne sort que 8 lignes, c'est forcement un branchement 4+3. C'est l’analyse du code que tu donnes en exemple qui permet de déduire le mappage exacte entre le PCF et le HD44780 (le schéma de Vincent).

A la fabrication c'est plus simple d'avoir un grand connecteur que deux petits connecteurs, c'est pour cela que toutes les broches sont soudées. Par contre sur le sac-à-dos les 4 lignes des bits inutilisés ne sont reliées à rien. Avec le PCB de couleur noir il est quasi impossible de voir les pistes dessus (alors que avec les autres couleurs c'est possible et tu l'aurais vu).

La conception du HD44780 est ancienne et il ne possède pas de mémoire permanente. Le nombre de ligne et la taille des caractères ne peut être stockée en interne à la fabrication de l'écran, c'est pour cela qu'il faut le faire à chaque démarrage. Mais ces paramètres doivent être défini en accord avec l'écran qui est commandé par le HD44780. Choisir un mode 5x10 sur un affichage 5x8 va utiliser deux lignes physique pour une ligne affichée (tu l'as remarqué en mode 1 ligne 5x10).

Ensuite tu n'as pas un seul système mais deux systèmes branchés ensemble et l’assembleur à cents sous ne s'est pas donné la peine de faire une doc. Il faut travailler avec les deux docs et penser dans cette optique. Quelles sont les commandes que le HD doit recevoir, puis comment je dois commander le PCF pour générer ces commandes. C'est ce que Vincent a très bien expliqué au post #9. Et on ajoute encore une couche avec le Pi qui a un OS et dont les E/S doivent être commandées par intermédiaire de l'OS. Un HD44780 en direct sur un µc (comme Arduino AVR) c'est 10x moins de prise de tête... (Peut être que commencer par là, sans aucune bibliothèque spécifique mais en utilisant uniquement l'accès aux E/S est la bonne voie pour comprendre le HD44780 )

La doc du PCF: http://www.ti.com/lit/ds/symlink/pcf8574.pdf

Bonne suite

Delias

[f-leb]

Bonsoir,

Sur le sac à dos :



Et le schéma électrique :


https://alselectro.wordpress.com/2016/05/12/serial-lcd-i2c-module-pcf8574/

Tout y est. La LED témoin d'alimentation, le potentiomètre de réglage du contraste, le jumper pour le rétroéclairage, les jumpers pour les entrées A0, A1 et A2 de l'adresse du PCF sur le bus (0x27 par défaut, les entrées A0, A1 et A2 étant tirées au Vcc, A0=A1=A2=1)...

Avec la doc du PCF8574 du message précédent de Delias, tu as toute la doc de ce côté

[Artemus24]

Salut à tous.

@ f-leb : merci pour les explications !

@ Delias : cela aide grandement, quand on explique le bon fonctionnement du PCF8574 associé au HD44780.

Choisir un mode 5x10 sur un affichage 5x8 va utiliser deux lignes physique pour une ligne affichée (tu l'as remarqué en mode 1 ligne 5x10).

J'ai surtout remarqué que seulement la première et la troisième sont activées en mode 5x10 dots.
Mais au lieu d'avoir 10 segments qui s'affichent, j'avais 8 segments.
Et pourtant, le curseur était bien en 5x10 dots.

De même, j'ai essayé différents caractères, mais je n'ai pas trouvé ceux qui sont en 5x10 dots.
La documentation indique qu'il y en a 32.

C'est ce que Vincent a très bien expliqué au post #9.

Et au passage, je le remercie vivement de m'avoir donnée toutes ces explications qui me sont fort utiles.

Un HD44780 en direct sur un µc (comme Arduino AVR) c'est 10x moins de prise de tête...

Je me rends compte que gérer cela par des GPIO aurait été bien plus simple à faire.
Mais je ne vais pas déssouder le PCF8574 du HD44780.

@ Vincent PETIT : Tout ce qui me manquait pour une bonne compréhension du fonctionnement de cet afficheur Joy-It, était le lien entre le PCF8574 et le HD44780.
Cela se résume par ce tableau :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
+-------+---------+------------+
|  bit  | PCF8574 |   HD44780  |
+-------+---------+------------+
|   0   |    P0   |     RS     |
|   1   |    P1   |    R/W     |
|   2   |    P2   |     E      |
|   3   |    P3   |  BackLight |
+-------+---------+------------+
|   4   |    P4   | DB4 ou DB0 |
|   5   |    P5   | DB5 ou DB1 |
|   6   |    P6   | DB6 ou DB2 |
|   7   |    P7   | DB7 ou DB3 |
+-------+---------+------------+

Avec bien sûr, comme tu l'as indiqué, les trois étapes pour l'envoi d'une donnée à l'afficheur pour le positionnement du flag E.
Le point qui reste en suspend, concerne l'initialisation. Voici ce qui est dans le programme python :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class lcd:
   #initializes objects and lcd
   def __init__(self):
      self.lcd_device = i2c_lib.i2c_device(ADDRESS)
 
      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x02)
 
      self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)
      self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)
      sleep(0.2)
 
   # clocks EN to latch command

Ce qui n'est pas clair, ce sont les quatre premières séquences d'initialisation, celle où il y a 0x03 et 0x02.
La séquence dans la documentation indique ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
+----+-----+-----+-----+-----+-----+
| RS | R/W | DB7 | DB6 | DB5 | DB4 |
+----+-----+-----+-----+-----+-----+ attendre 15 ms puis
| 0  |  0  |  0  |  0  |  1  |  1  |
+----+-----+-----+-----+-----+-----+ attendre 4.1ms puis
| 0  |  0  |  0  |  0  |  1  |  1  |
+----+-----+-----+-----+-----+-----+ attendre 100µs
| 0  |  0  |  0  |  0  |  1  |  1  |
+----+-----+-----+-----+-----+-----+
| 0  |  0  |  0  |  0  |  1  |  0  |
+----+-----+-----+-----+-----+-----+ et la séquence d'initialisation
| 0  |  0  |  0  |  0  |  1  |  0  | Fonction Set 4 bits mode
| 0  |  0  |  N  |  F  |  *  |  *  |
+----+-----+-----+-----+-----+-----+
| 0  |  0  |  0  |  0  |  0  |  0  | Display Off
| 0  |  0  |  1  |  0  |  0  |  0  |
+----+-----+-----+-----+-----+-----+
| 0  |  0  |  0  |  0  |  0  |  0  | Display Clear
| 0  |  0  |  0  |  0  |  0  |  1  |
+----+-----+-----+-----+-----+-----+
| 0  |  0  |  0  |  0  |  0  |  0  | Entry Mode Set
| 0  |  0  |  0  |  1  | I/D |  S  |
+----+-----+-----+-----+-----+-----+

Comme on peut le voir dans les quatre premiers envois, il s'agit juste de l'envoi d'un quartet et non de l'octet en entier.
J'ai traduit les quatre premiers envois par :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

self.lcd_device.write_cmd(LCD_FUNCTION_SET | LCD_8BITS_MODE);

ce qui correspond bien au positionnement de ces six bits, mais en une seule séquence, c'est-à-dire sans décomposer en quartet haut et quartet bas.
Puis pour le quatrième envoi :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

self.lcd_device.write_cmd(LCD_FUNCTION_SET | LCD_4BITS_MODE);

C'est après ces quatre premiers envois, que j'utilise la fonction "self.lcd_write()" qui va gérer l'envoi en mode 4 bits.
Ce qui me dérange dans cette initialisation, ce sont l'envoi d'un quartet dans les quatre premiers envois, et l'envoi d'un octet dans les quatre derniers envois.

Il me manque, pour terminer, la séquence pour basculer en mode 5x10 dots, que je n'ai pas réussi à faire.

@+

[Delias]

Bonsoir Artemus

Le mode 5x10 c'est pour des matrices LCD différentes et qui se câblent différemment sur la puce HD44780.
Avec un afficheur 2x16 5x8, le mode 5x10 donne une sortie sur les deux lignes (de tête 5x7 sur la ligne du haut et 5x3 sur la ligne du bas). Avec un afficheur 4 lignes 5x8, je ne sais pas, j'en avais déduit que c'était similaire mais sans garantie.

Pour le démarrage, le HD démarre en mode 8 bits. Et les ordres en 0000abcd peuvent être donné en mode 8 bits tout en ayant que le mode 4 bits de câblé. Les entrées sont en léger pull-down et garantissent une lecture 0000 du quartet haut.

Bonne suite

Delias

[Artemus24]

Salut Delias.

L'afficheur que j'ai est bien un 4 lignes de 20 caractères.
La hauteur de la ligne est définie dans le mode 5x8 dots.
Si je désire passer dans le mode 5x10 dots, l'affichage se fera uniquement sur la première et troisième ligne. Pourquoi ?
Car il n'y a pas assez de place dans une ligne pour afficher dans le mode 5x10 dots.
Je sais basculer en mode 5x10 dots sauf que cela ne fait pas ce que je veux.
--> la deuxième et quatrième ligne ne s'affiche pas : ok
--> le curseur est en 5x10 dots : ok
--> pas d'affichage en 5x10 dots : ko.
Je ne sais pas pourquoi cela ne s'affiche pas en 5x10 dots ?

Pour le démarrage, le HD démarre en mode 8 bits.

Oui, je le sais sauf que la seule façon de communiquer au travers du PCF8574 est le mode quatre bits.

Et les ordres en 0000abcd peuvent être donné en mode 8 bits tout en ayant que le mode 4 bits de câblé.

Là, je ne comprends pas. Dans l'exemple, le programme python envoie trois fois 0x03.
Or cette commande ne correspond à rien de ce qui est indiqué dans la documentation.

@+

[Artemus24]

Salut à tous.

Dois-je traiter le "busy flag" ?

@+

[Artemus24]

Salut à tous.

Je clôture le sujet.

@+