Changes between Initial Version and Version 1 of IOC_T03


Ignore:
Timestamp:
Feb 14, 2020, 7:05:40 AM (4 years ago)
Author:
franck
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • IOC_T03

    v1 v1  
     1= TP3 : Pilotage d'un écran LCD en mode utilisateur et par un driver =
     2
     3
     4Objectifs:
     5* Fonctionnement d'un écran LCD et fonctions de base
     6* Ecriture d'un driver d'affichage
     7* Usage de IOCTL
     8* Affichage du monitoring système
     9
     10Pré-requis (Raspberry Pi):
     11* Outils de compilation croisée
     12* Configuration et utilisation des GPIO
     13
     14Ressources:
     15* newhaven display est le fabriquant du module LCD, c'est donc, en principe la référence.
     16  * Dans ce document ([[http://www.newhavendisplay.com/specs/NHD-0420DZ-FL-YBW.pdf | Datasheet du LCD du module]]), il est dit que le contrôleur du LCD est le ST7066U, mais, sauf preuve du contraire, la séquence
     17    d'initialisation du LCD décrite dans la documentation du [[http://www.newhavendisplay.com/app_notes/ST7066U.pdf | ST7006U]]
     18    ne fonctionne pas...
     19* HD44780 est le contrôleur historique de la majorité des LCD de ce genre. La procédure d'initialisation fonctionne.
     20  * [[http://en.wikipedia.org/wiki/Hitachi_HD44780_LCD_controller | LCD Display HD44780]]
     21    [[https://www.sparkfun.com/datasheets/LCD/HD44780.pdf | Datasheet du HD44780]]
     22* Le document suivant définit comment est adressé la mémoire "vidéo" du LCD.
     23  * [[http://web.alfredstate.edu/faculty/weimandn/lcd/lcd_addressing/lcd_addressing_index.html | Adressage de la mémoire interne de l'afficheur]]
     24
     25Prenez le temps de parcourir les documents sur les afficheurs avant de commencer le TP.
     26
     27Le code à modifier se trouve en pièces jointes de cette page [[attachment:lcd_user.c]] et [[attachment:Makefile]]. Vous pourrez les copier dans un répertoire `TP4/lcd_user/`
     28
     29== 1. Configuration des GPIO pour le pilotage de l'écran ==
     30
     31L'écran LCD de type HD44780 dispose de plusieurs signaux de contrôle et de données. Les signaux de contrôle sont au nombre de 3: RS, RW et E. Les signaux de données sont au nombre de 4 ou 8 suivant le mode.
     32
     33Dans ce TP, nous utiliserons l'écran en mode 4-bit car la carte Raspberry Pi dispose d'un nombre limité de GPIO. De plus, le signal RW sera connecté directement à 0V (donc toujours en écriture) car nous n'allons gérer que les opérations d'écriture (Note: les GPIO de la carte Raspberry Pi fonctionnent en 3.3V, ils ne supportent pas les niveaux de tension 5V émis par l'afficheur, demandez-moi cela n'est pas clair).
     34
     35Les signaux de contrôle RS et E sont utilisés de la manière suivante:
     36* RS vaut 1 pour l'envoi d'une donnée (e.g. un caractère) et vaut 0 pour l'envoi d'une commande (instruction).
     37* E est un signal de validation; la valeur sur le bus de données (4 bits) est pris en compte à chaque front descendant de ce signal.
     38
     39Voici le mapping des GPIO pour les différents signaux:
     40
     41||=   Signal LCD  =||=     GPIO     =||
     42||       RS        ||       7        ||
     43||       E         ||       27       ||
     44|| D4, D5, D6, D7  || 22, 23, 24, 25 ||
     45
     46Dans la documentation de l'afficheur, on peut savoir :
     47* Comment faut-il configurer les GPIOs pour les différents signaux de l'afficheur LCD ?
     48* Comment écrire des valeurs vers le LCD ?
     49* Quelles valeurs doivent être envoyées vers l'afficheur pour réaliser l'initialisation ?
     50* Comment demander l'affichage d'un caractère ?
     51* Comment envoyer des commandes telles que : l'effacement de l'écran, le déplacement du curseur, etc. ?
     52
     53En particulier, page 11 de la documentation ([[http://www.newhavendisplay.com/specs/NHD-0420DZ-FL-YBW.pdf | Datasheet du LCD de la plateforme]]) se trouve du pseudo-code pour l'usage de l'afficheur.
     54* P1 est un registre dont l'état est recopié sur les broches D0 à D7 (bit7 de P1 sur D7, bit6 sur D6, etc. jusqu'à D4).
     55* D_I est un registre dont l'état est recopié sur RS qui indique si on envoie un caractère (D) ou une instruction (I).
     56* R_W est un registre dont l'état est recopié sur RW
     57* Delay() est une attente en microsecondes.
     58
     59{{{#!c
     604-bit Initialization:
     61/**********************************************************/
     62void command(char i)
     63{
     64  P1 = i;                       //put data on output Port
     65  D_I =0;                       //D/I=LOW : send instruction
     66  R_W =0;                       //R/W=LOW : Write       
     67  Nybble();                     //Send lower 4 bits
     68  i = i<<4;                     //Shift over by 4 bits
     69  P1 = i;                       //put data on output Port
     70  Nybble();                     //Send upper 4 bits
     71}
     72/**********************************************************/
     73void write(char i)
     74{
     75  P1 = i;                       //put data on output Port
     76  D_I =1;                       //D/I=HIGH : send data
     77  R_W =0;                       //R/W=LOW : Write   
     78  Nybble();                     //Clock lower 4 bits
     79  i = i<<4;                     //Shift over by 4 bits
     80  P1 = i;                       //put data on output Port
     81  Nybble();                     //Clock upper 4 bits
     82}
     83/**********************************************************/
     84void Nybble()
     85{
     86  E = 1;
     87  Delay(1);                     //enable pulse width  >= 300ns
     88  E = 0;                        //Clock enable: falling edge
     89}
     90/**********************************************************/
     91void init()
     92{
     93  P1 = 0;
     94  P3 = 0;
     95  Delay(100);                   //Wait >40 msec after power is applied
     96  P1 = 0x30;                    //put 0x30 on the output port
     97  Delay(30);                    //must wait 5ms, busy flag not available
     98  Nybble();                     //command 0x30 = Wake up 
     99  Delay(10);                    //must wait 160us, busy flag not available
     100  Nybble();                     //command 0x30 = Wake up #2
     101  Delay(10);                    //must wait 160us, busy flag not available
     102  Nybble();                     //command 0x30 = Wake up #3
     103  Delay(10);                    //can check busy flag now instead of delay
     104  P1= 0x20;                     //put 0x20 on the output port
     105  Nybble();                     //Function set: 4-bit interface
     106  command(0x28);                //Function set: 4-bit/2-line
     107  command(0x10);                //Set cursor
     108  command(0x0F);                //Display ON; Blinking cursor
     109  command(0x06);                //Entry Mode set
     110}
     111/**********************************************************/
     112}}}
     113
     114== 2. Fonctionnement de l'écran et fonctions de base ==
     115
     116La prise en compte de la donnée est réalisée lors d'un front descendant du signal E.
     117Pour créer un front descendant:
     118* on place la donnée,
     119* puis le signal E est mis à 1 pendant 1µs.
     120
     121[[Image(htdocs:png/command_lcd.png, width=900px, nolink)]]
     122
     123Nous utilisons l'afficheur LCD en mode 4 bits. Or, les commandes et les données sont transmises sur 8 bits ou 1 octet. Ainsi, toutes les commandes et toutes les données sont transmises en deux étapes: les 4 bits de poids fort et ensuite les 4 bits de poids faible.
     124
     125Nous avons toutes les fonctions dont nous avons besoin. Maintenant regardons d'un peu plus près la phase d'initialisation de l'afficheur LCD. Au démarrage, l'afficheur est dans un mode non défini (8 bits ou 4 bits). Il faut donc le forcer en mode 4 bits.
     126
     127Vous êtes prêt à tester votre code et vérifier qu'il affiche correctement une chaine de caractère.
     128erry Pi.
     129
     130Il peut être utile de manipuler la position du curseur pour choisir où placer les caractères sur l'afficheur.
     131
     132Pour cela, l'afficheur dispose de trois instructions: Cursor home, Display clear et Set DDRAM address. La dernière instruction est relative à la mémoire interne de l'afficheur (Display Data RAM).
     133
     134La mémoire DDRAM est construite de la manière suivante:
     135||0x00 ..... Ligne 1 ..... 0x13||
     136||0x40 ..... Ligne 2 ..... 0x53||
     137||0x14 ..... Ligne 3 ..... 0x27||
     138||0x54 ..... Ligne 4 ..... 0x67||
     139
     140On souhaites utiliser toutes les lignes
     141
     142|| **Questions:**\\1. Répondez aux questions qui se trouve dans le code [attachment:lcd_user.c lcd_user.c] \\2. Ecrire une fonction lcd_set_cursor qui positionne le curseur aux coordonnées (x,y) avec x la colonne, y la ligne.\\3. Ecrire un programme qui affiche la chaine passée en paramètre sur chacune des lignes de l'afficheur.
     143
     144== 4. Driver pour le LCD ==
     145
     146* Reprenez le pilote que vous aviez écrit pour les leds et modifiez la commande `write` de telle sorte que si vous appelez votre device /dev/lcd_xy (où xy sont les initiales de votre binôme), vous puissiez écrire.
     147{{{#!bash
     148$ echo "Bonjour" > /dev/lcd_xy
     149}}}
     150 Vous allez devoir remplacer usleep() par udelay() et ajouter un `#include <asm/delay.h>` au début du code de votre module (merci Arthur).
     151 Vous devez (en principe) allouer de la mémoire noyau pour ce driver et utiliser la fonction `copy_from_user(unsigned long dest, unsigned long src, unsigned long len);` pour le message à écrire.
     152
     153* Ajoutez la gestion de l'appel système ioctl() pour
     154  * effacer l'écran : LCDIOCT_CLEAR
     155  * position le curseur : LCDIOCT_SETXY (vous pouvez coder les coordonnées dans l'argument).