Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Raspberry Pi Discussion :

Afficheur alphanumérique !


Sujet :

Raspberry Pi

  1. #1
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut Afficheur alphanumérique !
    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  2. #2
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Ancien développeur matériel électronique (Hard/Soft)
    Inscrit en
    avril 2002
    Messages
    2 491
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Ancien développeur matériel électronique (Hard/Soft)
    Secteur : Service public

    Informations forums :
    Inscription : avril 2002
    Messages : 2 491
    Points : 8 500
    Points
    8 500
    Par défaut
    Salut,
    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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


    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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 ?


    Citation Envoyé par Artemus24 Voir le message
    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


    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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


    Citation Envoyé par Artemus24 Voir le message
    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+
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  3. #3
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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).

    Citation Envoyé par Vincent PETIT
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  4. #4
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  5. #5
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Ancien développeur matériel électronique (Hard/Soft)
    Inscrit en
    avril 2002
    Messages
    2 491
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Ancien développeur matériel électronique (Hard/Soft)
    Secteur : Service public

    Informations forums :
    Inscription : avril 2002
    Messages : 2 491
    Points : 8 500
    Points
    8 500
    Par défaut
    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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.


    Citation Envoyé par Artemus24 Voir le message
    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.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  6. #6
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    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)

    Citation Envoyé par Vincent PETIT
    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)

    Citation Envoyé par Vincent PETIT
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  7. #7
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Ancien développeur matériel électronique (Hard/Soft)
    Inscrit en
    avril 2002
    Messages
    2 491
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Ancien développeur matériel électronique (Hard/Soft)
    Secteur : Service public

    Informations forums :
    Inscription : avril 2002
    Messages : 2 491
    Points : 8 500
    Points
    8 500
    Par défaut
    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.
    Citation Envoyé par Artemus24 Voir le message
    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 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.

    Nom : image845.png
Affichages : 130
Taille : 69,1 Ko

    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.

    Nom : ellipse883.png
Affichages : 71
Taille : 203,9 Ko

    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
    Citation Envoyé par Vincent PETIT
    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.


    Citation Envoyé par Artemus24 Voir le message
    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.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  8. #8
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    Salut Vincent PETIT.

    Citation Envoyé par Artemus24
    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 ?

    Citation Envoyé par Vincent PETIT
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  9. #9
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Ancien développeur matériel électronique (Hard/Soft)
    Inscrit en
    avril 2002
    Messages
    2 491
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Ancien développeur matériel électronique (Hard/Soft)
    Secteur : Service public

    Informations forums :
    Inscription : avril 2002
    Messages : 2 491
    Points : 8 500
    Points
    8 500
    Par défaut
    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).

    Nom : path916.png
Affichages : 66
Taille : 65,9 Ko

    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

    Nom : rect1528.png
Affichages : 64
Taille : 22,0 Ko

    - 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 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.



    R/W à low pendant au moins 40ns tSP1 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 tPW 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 tSP2 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 tHD1 en violet ? Là aussi surtout grace au sleep 1µs


    Autre point :
    Citation Envoyé par Artemus24
    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 ?
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  10. #10
    Rédacteur/Modérateur

    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    janvier 2009
    Messages
    10 637
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : janvier 2009
    Messages : 10 637
    Points : 46 151
    Points
    46 151
    Billets dans le blog
    9
    Par défaut
    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

  11. #11
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    Salut Vincent PETIT.

    Citation Envoyé par 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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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 ?

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    Citation Envoyé par Vincent PETIT
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  12. #12
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  13. #13
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    837
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 837
    Points : 2 697
    Points
    2 697
    Par défaut
    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

  14. #14
    Rédacteur/Modérateur

    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    janvier 2009
    Messages
    10 637
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : janvier 2009
    Messages : 10 637
    Points : 46 151
    Points
    46 151
    Billets dans le blog
    9
    Par défaut
    Bonsoir,

    Sur le sac à dos :

    Nom : sacados.PNG
Affichages : 48
Taille : 205,7 Ko

    Et le schéma électrique :

    Nom : sacados_schema.PNG
Affichages : 48
Taille : 85,1 Ko
    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é

  15. #15
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    Salut à tous.

    @ f-leb : merci pour les explications !

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

    Citation Envoyé par Delias
    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.

    Citation Envoyé par Delias
    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.

    Citation Envoyé par Delias
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  16. #16
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    septembre 2008
    Messages
    837
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : septembre 2008
    Messages : 837
    Points : 2 697
    Points
    2 697
    Par défaut
    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

  17. #17
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    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 ?

    Citation Envoyé par Delias
    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.

    Citation Envoyé par Delias
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  18. #18
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    février 2011
    Messages
    4 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 79
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : février 2011
    Messages : 4 147
    Points : 12 306
    Points
    12 306
    Par défaut
    Salut à tous.

    Dois-je traiter le "busy flag" ?

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

Discussions similaires

  1. [javascript] générer un code de 6 caractère alphanumérique
    Par LE NEINDRE dans le forum Général JavaScript
    Réponses: 4
    Dernier message: 29/09/2005, 18h03
  2. Réponses: 5
    Dernier message: 29/09/2005, 15h37
  3. []Traduire un code barre alphanumérique en nombre
    Par iskandhar dans le forum VB 6 et antérieur
    Réponses: 8
    Dernier message: 21/08/2005, 22h17
  4. BDD avec alphanumérique décalé à droite
    Par Flam dans le forum Bases de données
    Réponses: 2
    Dernier message: 01/04/2005, 18h54
  5. Réponses: 6
    Dernier message: 28/12/2004, 17h09

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo