5.1- processeur (microprocesseur: µp)l processeur. 5.1.1

Ch5 (CE27)-- Les microprocesseurs dans les systèmes embarqués

Dr. M. DJARALLAH 1

5.1- Processeur (microprocesseur: µp)L processeur. 5.1.1. Architecture '1'

Le processeur (microprocesseur) est le composant hardware le plus connu d'un système micro-programmé. C'est l'unité intelligente de traitement des informations.

Son travail consiste à: • lire des programmes (des suites d'instructions), • les décoder et • les exécuter.

Son architecture et brochage sont résumés dans (Fig. 5.1, Fig. 5.2): • L'unité de commande.

Elle permet de "séquencer" le déroulement des instructions. Elle effectue la recherche en mémoire de l'instruction, le décodage, l'exécution et la préparation de l'instruction suivante. L'unité de commande élabore tous les signaux de synchronisation internes ou externes (bus des commandes) au microprocesseur.

• L'unité arithmétique et logique (UAL).

C'est l'organe qui effectue les opérations: - Arithmétiques : addition, soustraction, multiplication, ... - Logiques : et, ou, non, décalage, rotation, ....

• Des registres.

- registres de données; - registres de segment ; - registres pointeurs; - registre d’état

L'interfaçage du processeur avec l’extérieur nécessite 3 bus: un bus de données, un bus d'adresse et un bus de commande (Fig. 5.1):.

Fig. 5.2: Architecture: broches et microscopique d'un µp


Dr. M. DJARALLAH 2

5.1.2. Structure des µp : Architecture '2' (rappel voir ce622 ou ce64) a) Structure "Von Neuman" ou "Princeton"

L'architecture de von Neumann est un modèle pour un ordinateur qui utilise une structure de stockage unique pour conserver à la fois les instructions et les données demandées ou produites par le calcul (Fig. 5.3), donc;

• La mémoire contient les données et les instructions • L’unité centrale (CPU) charge les instructions depuis la mémoire. • Un ensemble de registres aide le CPU:

- Compteur d’instructions (Program counter: PC), - Registre d’instruction (Instruction register: IR) - Pointeur de pile (stack pointer: SP) - Registres à usage général (Accumulateur: A)

b) Structure " Harvard"

L’architecture de type Harvard (Fig. 5.4) est une conception de µp qui sépare physiquement la mémoire de données et la mémoire programme. L’accès à chacune des deux mémoires s’effectue via deux bus distincts. Ainsi,

• Données et instructions dans des mémoires séparées • Autorise deux accès simultanés à la mémoire. • Utilisé pour la plupart des DSP et des MC

5.1.3. Types des µp : Architecture '3' (rappel voir ce622 ou ce64) a) Type CISC

La majorité des microprocesseurs ont une architecture CISC (ex Complex Instruction Set Computer), ce qui signifie "ordinateur avec jeu d'instructions complexes". C’est le cas des processeurs de type x86, c'est-à-dire les processeurs fabriqués par Intel, AMD, Cyrix,

Fi. 5.3: Structure "Von Neuman" ou "Princeton"

Fig. 5.4: Structure de type Harvard


Dr. M. DJARALLAH 3

• Une instruction peut designer plusieurs opérations élémentaires. Ex: un load, une opération arithmétique et un store, Ex: calculer une interpolation linéaire de plusieurs valeurs en mémoire.

• Accélération par des mécanismes matériels complexes • Grandes variations de taille et de temps d’exécution pour les instructions • Résulte en un code compact mais complexe à générer. • Vax, Motorola 68000, Intel x86/Pentium

b) Type RISC

Reduced instruction set computer ou RISC (en français « microprocesseur à jeu d'instructions réduit ») est un type d'architecture matérielle de µp qui se caractérise par un jeu d'instructions réduit, facile à décoder et comportant uniquement des instructions simples.

• Petites instructions simples, toutes de même taille, ayant toutes (presque) le même temps d’exécution

• Pas d’instruction complexe • Accélération en pipelinant l’exécution (entre 3 et 7 étages de pipeline pour une

instruction) augmentation de la vitesse d’horloge • Code plus simple à générer, mais moins compact • Tous les microprocesseurs modernes utilisent ce paradigme: • SPARC, MIPS, ARM, PowerPC, MC, etc.

NB: Le pipeline RISC: exemple du MIPS peut être consulté dans la réf. [1].

5.2. Catégories de microprocesseur

On distingue quatre classes de µp:

1- Usage général - processeurs de haute performance - Pentium, SPARC, Intel 80x86, Motorola 68HCxxx ... • Utilisé pour les logiciels d'usage général • Général sous contrôle d'un système d'exploitation (Windows .., UNIX ..,) • Poste de travail, PC 2- processeurs embarqués et noyaux spéciaux - 486SX, ARM, Hitachi SH7000, NEC V800, Motorola PowerPC, ... • programme unique • Léger, souvent sous OS temps réel (Windows CE, QNX, OS-9, PSOS, ...) • Prise en charge de traitement numérique du signal (léger) • consommation électroniques, les téléphones cellulaires • Microcontrôleurs 3- Microcontrôleurs - Chipsets spécifiques 8, 16, (32) Bit, avec des caractéristiques différentes applications • A / D, D / A, entrée, sortie, Timer, Interfaces, .... • Coût sensibles • Les plus hauts processeurs de volume pour les machines de l'automobile, de lavage, ..... • DSP à usage général et la conception de base 'Gate Arrays'


Dr. M. DJARALLAH 4

5.3. Différents types de processeurs embarqués

Beaucoup de Processeurs à usage général ayant une ou deux générations 4, 8, 16 ou 32 bits (taille des mots) RISC et CISC DSP: Digital Signal Processor ASIP: Application Specific Integrated Processor

68000, x86: • Famille des Motorola 68000

- Un des plus vieux processeur embarqué (ex Sun, Mac) - Architecture CISC - ISA propre et les meilleurs outils de développement, - beaucoup d’utilisateurs

• Famille des x86 - Démarre au 8086 (Intel) puis 80286, 386, 486, Pentium, et Athlon (AMD) - En processeurs embarqués: 5 fois moins que MIPS, ARM ou 68000. - architecture CISC, compatible avec le code du 8086 - compatibilité mais mauvaises performances

SPARC, 29000 et i960:

• SPARC

- Un des premier RISC à avoir été embarqué (pratiquement plus aujourd’hui) - SPARC est une architecture brevetée (soft core, Intellectuel Property: IP),

plusieurs compagnies fabriquentdes SPARC.

• 29000 (AMD) - Le 29000 a eu beaucoup de succès (imprimante laser Apple) grâce à ces 192

registres - AMD a arrêté la production car le développement des outils coûtait trop cher.

• i960 (intel) - Le i960 a été le plus vendu des processeurs embarqués au milieu des années 90

(router réseau et HP Laserjet).

MIPS, ARM, SuperH et PowerPC: • MIPS (microprocessor without interlocked pipeline stages)

- Originellement pour les stations puissantes (SGI) - Puis, marché des consoles de jeux (Nitendo N64) - Famille très étendue: du plus gros (MIPS 20Kc, 64 bit) au plus petit (SmartMIPS, - 32 bit pour carte à puce)

• ARM (Advanced RISC Machines, ex Acorn)

- Un des 32 bits embarqués les plus populaires : téléphones portables - Faible consommation - Le successeur: StrongArm est commercialisé par Intel sous le nom de XScale - SuperH (ou SH: Hitachi) Utilisé dans les stations Sega et les PDA - PowerPC autant utilisé en embarqué qu’en ordinateur


Dr. M. DJARALLAH 5

Et les autres....

• Plus de 100 processeurs embarqués 32 bits sur le marché • Les constructeurs de FPGA proposent des soft-processeurs pour configurer les FPGA:

Nios (Altera), MicroBlaze (Xilinx) • Certain processeurs RISC (Crusoe de Transmetta) peuvent exécuter du code CISC

(Intel) 1.Principe: recompilation du code à l’exécution (runtime compilation), 2. Gain obtenu par un mécanisme de cache, d’optimisation poussée des

portions de code répétées (boucle), et grâce au parallélisme de niveau instruction;

3.Réduction drastique de la consommation pour des performances équivalentes Microcontrôleurs (Déférents familles Fig. 5.5a, b et c):

• Utilisé pour le contrôle embarqué - Censeur, contrôleurs simples - Manipule des événements, quelques données mais en faible quantité - Exemple: camescope, disque dur, appareil photo numérique, machine à laver,

four à micro-onde • Quelques caractéristiques fréquentes

- Périphériques présents sur le circuit (timer, convertisseur analogique numérique, interface de communication), accessible directement grâce aux registres

- Programme et données intégrées au circuit - Accès direct du programmeur à de nombreuses broches du circuit - Instructions spécialisées pour les manipulations de bits.

• Le MSP430 (voir la suite) appartient à cette catégorie

Déférents familles Fig. 5.5a


Dr. M. DJARALLAH 6

DSP: Digital Signal Processing:

• Typiquement: - Texas Instruments- Series: C28x; C54xx or C64xx , - Analog Devices SHARC or TigerSHARC, - Motorola 5600xx

• Utilisés pour les applications de traitement du signal - Grande quantités de données numérisées, souvent organisées en flux - Filtre numérique sur téléphone, TV numérique, synthétiseur de sons

• Relativement proche des GPP, mais quelques caractéristiques en plus: - Bande passante élevée (deux bus) - Instructions dédiées pour les calculs de traitement du signal: multiplication

accumulation, - Arithmétique spécifique (mode d’arrondi) - Registres dédiés pour certains opérateurs. - Constructeurs: Texas Instrument, puis Analog Devices, Motorola

Déférents familles Fig. 5.5c

Déférents familles Fig.5.5 b


Dr. M. DJARALLAH 7

Processeur de médias

TI DSP TMS320DM310 or Trimedia Phillips Media Processor 1x00 series for Processing Streaming and Data Networks and Image, Video and Speech: PNX 1300, PNX 1500 (2002)

GPP or ASIP core (s): GPP or ASIP Integrated into either an Application Specific Integrated Circuit (ASIC), or a Very Large Scale Integrated Circuit (VLSI) circuit or a FPGA core integrated with processor unit(s) in a VLSI (ASIC) chip

Application Specific System: Processor (ASSP) Processor (ASSP) : Typically a set top box processor or video-processor or network application processor or mobile application processor

5.4. Introduction au MSP 430

Application du MSP430 Les microcontroleurs MSP430 pour les applications faibles consommations – êx.: asservissement d’un oscillateur sur le

GPS

Fig. 5.6: relation entre les ASIC, ASIP et GPP

Fig. 5.7: Materiel d'un système de développement pour: MC MSP430


Dr. M. DJARALLAH 8

Periphérique intégrés

• timers • contrôleur LCD • mutliplieur cablé • contrôleur de bus • convertisseur analogique numérique, comparateur • ports séries

Applications: a) Le contrôleur représenté sur la figure 5.9 a les possibilités suivantes:

1. Ouverture et fermeture de la vanne de mélange; 2. Contrôle du brûleur (OFF / ON). 3. Le contrôle de la pompe de circulation (arrêt / marche) 4. etc.. [4].

Fig. 5.8: Architecture du MC: MSP430

Fig. 5.9: Régulation de températures d'un foyer '1'


Dr. M. DJARALLAH 9

D'une manière très similaire à l'unité de commande d'installation de chauffage de la figure 5.9, pour une maison avec plus d'une zone, le MSP430 peut également être utilisé dans un contrôleur de température pour une maison unifamiliale. Figure 5.10 illustre cet exemple. La commande de la chaudière est constituée par un second MSP430 ou par le même MSP430. La sélection de la température d'une chambre est réalisée avec un potentiomètre ou d'un petit clavier. Les deux possibilités sont représentées sur la figure 5.10. b) Une télécommande pour les ensembles audio ou vidéo est illustrée par la figure 5.11. Normalement, à cet effet, aucune mémoire externe n'est nécessaire qu'un clavier avec un grand nombre de touches. Les forts courants à travers la diode IR besoin d'un autre étage de puissance avec un très gros condensateur en parallèle. Cela est nécessaire parce que la batterie ne peut pas livrer les courants de pointe élevés.

Fig. 5.10: Régulation de températures d'un foyer '2'

Fig. 5.11: Une télécommande à base de MSP430


Dr. M. DJARALLAH 10

c) Management d'énergie: Le MSP430 peut gérer la gestion de l'énergie et éteigne tous les périphériques actuellement inutilisés (dur, écran, processeur, etc). Quand ils sont à nouveau nécessaires, il peut les allumer de manière définie. Dans un PC alimentée en courant alternatif, le MSP430 peut prendre en charge les fonctions suivantes:

1- Eteindre le PC quand il ne est pas utilisé pour une période de temps définie; 2- Fonction de chien de garde pour l'ordinateur hôte; 3- Défini pour éteindre tous les périphériques actuellement inutilisés; 4- Son tour sur la procédure définie pour les périphériques nécessaires; 5- Clavier / scan du clavier; 6- Horloge en temps réel: L'horloge de base avec sa fréquence exacte du cristal est

utilisé pour la base de temps; 7- Eteindre le PC quand il ne est pas utilisé pour une période de temps définie. 8- Fonction de chien de garde pour l'ordinateur hôte; 9- Défini pour éteindre tous les périphériques actuellement inutilisés; 10- Son tour sur la procédure définie pour les périphériques nécessaires; 11- Clavier / scan du clavier; 12- Horloge en temps réel: L'horloge de base avec sa fréquence exacte du cristal est

utilisé pour la base de temps d) Régulation numérique d'un servomoteur (PWM)

Si un seul sens de rotation est nécessaire, ou le changement de la direction de la rotation peut être fait avec un relais ayant des contacts sur le changement, alors un seul l'étage de sortie peut être utilisé.

Le sens de rotation du moteur est modifié par un relais qui commute le la polarité de l'enroulement de champ. Pour un seul sens de rotation, ce relais est omise et l'enroulement de champ est connecté de façon fixe. Tous les exemples montré peut utiliser le PWM à haute fréquence (> 15 kHz) ou le PWM basse fréquence (100 Hz et plus) (Fig. 5.13).

Fig. 5.12: Management d'énergie AC dans un PC


Dr. M. DJARALLAH 11

e) Compteur de gaz (Fig. 5.14)

L'interface de volume est indiquée par un compteur mécanique et sur le côté gauche d'une solution électronique:

L'interface mécanique utilise contacts de donner les informations de volume à l'MSP430. La sortie 'Oz' est utilisé pour le balayage, réduisant de cette manière le passage du courant si un ou plusieurs contacts sont fermés en permanence.

L'interface électronique fournit en sortie des signaux électriques à la MSP430 aussi longtemps que l'entrée d'activation est élevée. Les signaux V1 et V2 sont en opposition de phase 90° pour permettre une distinction fiable de la direction d'écoulement de gaz.

Fig. 5.13: Régulation numérique d'un servomoteur (PWM)

Fig. 5.14: Compteur de gaz


Dr. M. DJARALLAH 12

5.5. Manipulations (TP5) EXO. 1

Donner les tâches du composant SHT75, puis expliquer la procédure d'exploitation de cette applicationb(Fig.4.15). EXO. 2

En donnant le schéma Proteus/ISIS et le code machine, donner le but (Fig.4.16a et b) puis expliquer la procédure d'exploitation de cette application.

Fig. 5.16a: Synoptique de l'EXO 2

Fig. 5.15: Schéma Proteus/ISIS de l'EXO 1


Dr. M. DJARALLAH 13

EXO. 3

En donnant le schéma Proteus/ISIS et le code machine, donner le but (Fig.4.17) puis expliquer la procédure d'exploitation de cette application.

Fig. 5.16b: Schéma Proteus/ISIS de l'EXO 2

Fig. 5.15: Schéma Proteus/ISIS de l'EXO 3


Dr. M. DJARALLAH 14

5.6. Annexes A) manipulation '1' EXO 1 (en CCS C)

Programme principal

#include <16F876A.h> #fuses HS,NOWDT,PUT,NOPROTECT,NOLVP #use delay(clock=20000000) #include <lcd.c> #include <sht75.c> void main() { float restemp, truehumid; lcd_init(); sht_init(); while(1) { sht_rd (restemp, truehumid); lcd_gotoxy(1,1); printf(lcd_putc, "Temp : %3.1f %cC ", restemp, 223); printf(lcd_putc, "\nRH : %3.1f %% ", truehumid); delay_ms(500); //delay 500 ms between reading to prevent self heating of sensor } }

Pilote pour capteur (SHT75) de température et d'humidité

/////////////////////////////////////////////////////////////////////////////// // // // Driver file for SHT75 Temperature & Humidity Sensor // // // // ***** To initialise SHT75 sensor upon power up ***** // // // // Function : sht_init() // // Return : none // // // // // // ***** To measure and caluculate SHT75 temp & real RH ***** // // // // Function : sht_rd (temp, truehumid) // // Return : temperature & true humidity in float values // // // /////////////////////////////////////////////////////////////////////////////// #define sht_data_pin PIN_c1 #define sht_clk_pin PIN_C0 //***** Function to alert SHT75 ***** void comstart (void) {

output_float(sht_data_pin); //data high output_bit(sht_clk_pin, 0); //clk low delay_us(1); output_bit(sht_clk_pin, 1); //clk high


Dr. M. DJARALLAH 15

delay_us(1); output_bit(sht_data_pin, 0); //data low delay_us(1); output_bit(sht_clk_pin, 0); //clk low delay_us(2); output_bit(sht_clk_pin, 1); //clk high delay_us(1); output_float(sht_data_pin); //data high delay_us(1); output_bit(sht_clk_pin, 0); //clk low

} //***** Function to write data to SHT75 ***** int1 comwrite (int8 iobyte) { int8 i, mask = 0x80; int1 ack; //Shift out command delay_us(4); for(i=0; i<8; i++) { output_bit(sht_clk_pin, 0); //clk low if((iobyte & mask) > 0) output_float(sht_data_pin); //data high if MSB high else output_bit(sht_data_pin, 0); //data low if MSB low delay_us(1); output_bit(sht_clk_pin, 1); //clk high delay_us(1); mask = mask >> 1; //shift to next bit } //Shift in ack output_bit(sht_clk_pin, 0); //clk low delay_us(1); ack = input(sht_data_pin); //get ack bit output_bit(sht_clk_pin, 1); //clk high delay_us(1); output_bit(sht_clk_pin, 0); //clk low return(ack); } //***** Function to read data from SHT75 ***** int16 comread (void) { int8 i; int16 iobyte = 0; const int16 mask0 = 0x0000; const int16 mask1 = 0x0001; //shift in MSB data for(i=0; i<8; i++) { iobyte = iobyte << 1; output_bit(sht_clk_pin, 1); //clk high delay_us(1); if (input(sht_data_pin)) iobyte |= mask1; //shift in data bit


Dr. M. DJARALLAH 16

else iobyte |= mask0; output_bit(sht_clk_pin, 0); //clk low delay_us(1); } //send ack 0 bit output_bit(sht_data_pin, 0); //data low delay_us(1); output_bit(sht_clk_pin, 1); //clk high delay_us(2); output_bit(sht_clk_pin, 0); //clk low delay_us(1); output_float(sht_data_pin); //data high //shift in LSB data for(i=0; i<8; i++) { iobyte = iobyte << 1; output_bit(sht_clk_pin, 1); //clk high delay_us(1); if (input(sht_data_pin)) iobyte |= mask1; //shift in data bit else iobyte |= mask0; output_bit(sht_clk_pin, 0); //clk low delay_us(1); } //send ack 1 bit output_float(sht_data_pin); //data high delay_us(1); output_bit(sht_clk_pin, 1); //clk high delay_us(2); output_bit(sht_clk_pin, 0); //clk low return(iobyte); } //***** Function to wait for SHT75 reading ***** void comwait (void) { int16 sht_delay; output_float(sht_data_pin); //data high output_bit(sht_clk_pin, 0); //clk low delay_us(1); for(sht_delay=0; sht_delay<30000; sht_delay++) // wait for max 300ms { if (!input(sht_data_pin)) break; //if sht_data_pin low, SHT75 ready delay_us(10); } } //***** Function to reset SHT75 communication ***** void comreset (void) { int8 i;


Dr. M. DJARALLAH 17

output_float(sht_data_pin); //data high output_bit(sht_clk_pin, 0); //clk low delay_us(2); for(i=0; i<9; i++) { output_bit(sht_clk_pin, 1); //toggle clk 9 times delay_us(2); output_bit(sht_clk_pin, 0); delay_us(2); } comstart(); } //***** Function to soft reset SHT75 ***** void sht_soft_reset (void) { comreset(); //SHT75 communication reset comwrite(0x1e); //send SHT75 reset command delay_ms(15); //pause 15 ms } //***** Function to measure SHT75 temperature ***** int16 measuretemp (void) { int1 ack; int16 iobyte; comstart(); //alert SHT75 ack = comwrite(0x03); //send measure temp command and read ack status if(ack == 1) return; comwait(); //wait for SHT75 measurement to complete iobyte = comread(); //read SHT75 temp data return(iobyte); } //***** Function to measure SHT75 RH ***** int16 measurehumid (void) { int1 ack; int16 iobyte; comstart(); //alert SHT75 ack = comwrite(0x05); //send measure RH command and read ack status if(ack == 1) return; comwait(); //wait for SHT75 measurement to complete iobyte = comread(); //read SHT75 temp data return(iobyte); } //***** Function to calculate SHT75 temp & RH ***** void calculate_data (int16 temp, int16 humid, float & tc, float & rhlin, float & rhtrue) {


Dr. M. DJARALLAH 18

float truehumid1, rh; //calculate temperature reading tc = ((float) temp * 0.01) - 40.0; //calculate Real RH reading rh = (float) humid; rhlin = (rh * 0.0405) - (rh * rh * 0.0000028) - 4.0; //calculate True RH reading rhtrue = ((tc - 25.0) * (0.01 + (0.00008 * rh))) + rhlin; } //***** Function to measure & calculate SHT75 temp & RH ***** void sht_rd (float & temp, float & truehumid) { int16 restemp, reshumid; float realhumid; restemp = 0; truehumid = 0; restemp = measuretemp(); //measure temp reshumid = measurehumid(); //measure RH calculate_data (restemp, reshumid, temp, realhumid, truehumid); //calculate temp & RH } //***** Function to initialise SHT75 on power-up ***** void sht_init (void) { comreset(); //reset SHT75 delay_ms(20); //delay for power-up }

B) manipulation '2' EXO 2 (en CCS C)

Programme principal #include <16F876.h> #fuses HS,NOWDT,NOPROTECT,NOLVP #use delay(clock=20000000) #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7) //#include <string.h> #include <STDLIB.H> #include <lcdrabah.c> #define use_portb_lcd TRUE void main() { long a=0,b=0,c=0; char string[30],password[30]; strcpy(password,"picc"); lcd_init(); start: printf("\fPassword: "); lcd_putc("\fPassword: "); gets(string); printf(lcd_putc,"\f%4s",string); if(!strcmp(string,password)) printf("OK password correct\r"); else{ printf("Erreur ");


Dr. M. DJARALLAH 19

lcd_putc("\nErreur "); delay_ms(1000); goto start;} rep: printf("\rA: "); gets(string); a=strtod(string,&c); printf("B: "); gets(string); b=strtod(string,&c); printf("La somme A+B=%lu\r",a+b); printf(lcd_putc,"\fA+B=%lu\r",a+b); printf("Le produit A*B=%lu\r",a*b); printf(lcd_putc,"\nA*B=%lu\r",a*b); goto rep; /* printf( "A:"); a=getc()-48; a=getc()-48; a=getc()-48; printf("\rB"); b=getc()-48; printf("\rLe produit A*B=%d",a*b); */

Pilote pour les modules LCD //////////////////////////////////////////////////////////////////////////// //// LCDD.C //// //// Driver for common LCD modules //// //// //// //// lcd_init() Must be called before any other function. //// //// //// //// lcd_putc(c) Will display c on the next position of the LCD. //// //// The following have special meaning: //// //// \f Clear display //// //// \n Go to start of second line //// //// \b Move back one position //// //// //// //// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) //// //// //// //// lcd_getc(x,y) Returns character at position x,y on LCD //// //// //// //////////////////////////////////////////////////////////////////////////// //// (C) Copyright 1996,1997 Custom Computer Services //// //// This source code may only be used by licensed users of the CCS C //// //// compiler. This source code may only be distributed to other //// //// licensed users of the CCS C compiler. No other use, reproduction //// //// or distribution is permitted without written permission. //// //// Derivative programs created using this software in object code //// //// form are not restricted in any way. //// //////////////////////////////////////////////////////////////////////////// // As defined in the following structure the pin connection is as follows: // D0 enable // D1 rs // D2 rw // D4 D4 // D5 D5 // D6 D6


Dr. M. DJARALLAH 20

// D7 D7 // // LCD pins D0-D3 are not used and PIC D3 is not used. // Un-comment the following define to use port B // #define use_portb_lcd TRUE struct lcd_pin_map { // This structure is overlayed boolean enable; // on to an I/O port to gain boolean rw; // access to the LCD pins. boolean rs; // The bits are allocated from boolean unused; // low order up. ENABLE will int data : 4; // be pin B0. } lcd; #byte lcd = 6 // on to port B (at address 6) #define set_tris_lcd(x) set_tris_b(x) #define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines #define lcd_line_two 0x40 // LCD RAM address for the second line byte CONST LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1,6 }; // These bytes need to be sent to the LCD // to start it up. // The following are used for setting // the I/O port direction register. STRUCT lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out STRUCT lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in byte lcd_read_byte() { byte low,high; set_tris_lcd(LCD_READ); lcd.rw = 1; delay_cycles(1); lcd.enable = 1; delay_cycles(1); high = lcd.data; lcd.enable = 0; delay_cycles(1); lcd.enable = 1; delay_us(1); low = lcd.data; lcd.enable = 0; set_tris_lcd(LCD_WRITE); return( (high<<4) | low); } void lcd_send_nibble( byte n ) { lcd.data = n; delay_cycles(1); lcd.enable = 1; delay_us(2); lcd.enable = 0; } void lcd_send_byte( byte address, byte n ) { lcd.rs = 0;


Dr. M. DJARALLAH 21

while ( bit_test(lcd_read_byte(),7) ) ; lcd.rs = address; delay_cycles(1); lcd.rw = 0; delay_cycles(1); lcd.enable = 0; lcd_send_nibble(n >> 4); lcd_send_nibble(n & 0xf); } void lcd_init() { byte i; set_tris_lcd(LCD_WRITE); lcd.rs = 0; lcd.rw = 0; lcd.enable = 0; delay_ms(15); for(i=1;i<=3;++i) { lcd_send_nibble(3); delay_ms(5); } lcd_send_nibble(2); for(i=0;i<=3;++i) lcd_send_byte(0,LCD_INIT_STRING[i]); } void lcd_gotoxy( byte x, byte y) { byte address; if(y!=1) address=lcd_line_two; else address=0; address+=x-1; lcd_send_byte(0,0x80|address); } void lcd_putc( char c) { switch (c) { case '\f' : lcd_send_byte(0,1); delay_ms(2); break; case '\n' : lcd_gotoxy(1,2); break; case '\b' : lcd_send_byte(0,0x10); break; default : lcd_send_byte(1,c); break; } } char lcd_getc( byte x, byte y) { char value; lcd_gotoxy(x,y); while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low lcd.rs=1; value = lcd_read_byte(); lcd.rs=0; return(value); }


Dr. M. DJARALLAH 22

5.7. Références [1] Introduction aux systèmes embarqués 'Processeurs embarqués', Antoine Fraboulet, ei al. Lab

CITI, INSA de Lyon, site (12/02/15): perso.citi.insa-lyon.fr/afraboul/rts6/slides/cours_RTS6_1X2.pdf

[2] 'Microprocesseurs et Microcontrôleurs', Jlassi Khaled, site (12/02/15): pf-mh.uvt.rnu.tn/320/1/Microprocesseurs_et_Microcontrôleurs.pdf [3] 'Embedded Systems: Processor Classes', site (12/02/15): www.rw.cdl.uni-saarland.de/~kaestner/.../lecthr06.pdf [4] ' MSP430 Family Mixed-Signal Microcontroller Application Reports', Lutz Bierl, Literature

Number: SLAA024 Texas Instruments Incorporated, January 2000

5.1- processeur (microprocesseur: µp)l processeur. 5.1.1

Documents