CE4.2Journées académiques Microsoft 20051 Cours Windows CE.

CE4.2 Journées académiques Microsoft 2005 1

Cours Windows CE


Plan de la présentation

• Windows CE « pour qui, pour quoi ? »

• Description du cours réalisé

• Exemple d’application et de debuggage

• Exemple de driver port parallèle

• Conclusion et questions


Windows CE

• Interface classique de Windows• Système d’exploitation modulaire et compact• N’est pas un sous ensemble de NT ou XP• Système réécrit entièrement pour optimiser la

taille et la performance • Répond à plus de 90% des applications temps réel• Environnement de développement performant• Adaptable à de nombreux processeurs


Applications

• Téléphonie

• PDA

• Bornes interactives

• Machine à coudre (Bernina)

• Machine à voter (Unisys)

• Robot domestique (Fujitsu)

• Chaudières, réfrigérateur …


Pourquoi ce cours ?

• Besoin pour l’ESIEE

• Demande de Laurent Ellerbach et de son équipe– Cours en français

– Accessible aux non informaticiens purs et durs

– Basé sur l’exemple

– Mis à la disposition des enseignants


Groupe ESIEE

• École d’ingénieurs BAC+5

• École de technologues BAC+3

• Domaines de compétence

– Électronique et microélectronique

– Informatique

– Systèmes embarqués

– Télécommunications


Équipe

• Conception et rédaction

Jean CALLOT Ingénieur ESIEE

Michel DUPLESSY Ingénieur INPG

Liliane PIEDFORT Agrégée de physique• Conseiller

Olivier COME Technologue ESTE et EMVP

(Embedded Most Valuable Professional)


Les informaticiens

• Formation orientée applications haut niveau

• Peu intéressés par les couches basses

• Développent souvent sur la machine sur laquelle tournera l’application (PC ou station de travail)

• Développent avec des outils puissants qui cachent en général les problèmes liés à la cible (UML, Visual Studio…)


Les électroniciens

• Spécialistes de l’électronique, pas de l’informatique• Dans le meilleur des cas ils ont des connaissances

– En assembleur

– En langage C

– Sur les microcontrôleurs

• Peu ou pas de connaissances des langages objets • Peu ou pas de connaissances système


Évolution de l’électronique

• Arrivée de nouveaux produits nécessitant un noyau temps réel

• Temps réel non critique (plus de 90% des cas)• Interface homme/machine important• Importance du coût • Le matériel et une bonne partie du logiciel devront

être réalisés par les électroniciens• Nécessité d’une double compétence


Électroniciens BAC+2/BAC+3

• Enseignement très cloisonné

• Évolution lente : pour mettre en place un nouveau cours il faut en supprimer un autre

• Budget réduit pour l’équipement des salles

• Nécessité de formation des enseignants

• Difficulté pour l’élaboration de nouveaux cours

• Formations type constructeur non adaptées à ce genre de public


Électroniciens BAC+5

• Évolution plus rapide

• Corps enseignant plus polyvalent

• Plus de temps accordé aux projets et stages permettant de diversifier les domaines abordés

• Actions de recherche et développement

• Proches des besoins de l’industrie


Pédagogie

• Les étudiants supportent de moins en moins les cours théoriques en amphi

• Caractéristiques du cours développé – Magistral : très peu– Participatif : les étudiants manipulent au fur et à mesure

du passage des diapositives – Basé sur des exercices simples à réaliser

• Présentation de l’exercice• Correction de l’exercice

– Pédagogie adaptée à de petits groupes


Caractéristiques du cours

• Cours de base simple, mais concret

• Permet de comprendre les grandes fonctions d’un OS à travers des exemples gradués

• Permet d’aborder ultérieurement un cours standard du marché ou une auto formation

• Objectifs – Formation de BAC+3

– Premier niveau pour des BAC+5

– Reconversion d’équipes industrielles

– Auto formation


Organisation du cours

• Deux grandes parties– « Émulateur » – « Cible »

• La partie émulateur permet de se familiariser avec les outils et d’acquérir des connaissances de base sans se soucier des problèmes liés au matériel

• La partie cible complète ces connaissances et introduit les bases de la gestion de périphériques


Émulateur

• Permet de développer et de visualiser le résultat sur le PC de développement

• Ne nécessite pas de matériel externe

• Couvre une bonne partie des connaissances fondamentales

• Chapitres 101 à 112


Cible

• La cible ou target est un matériel sur lequel tournent le noyau et les applications.

• La cible peut être de type – x86 (STPC, Géode…), ARM (Intel, Freescale…), SHx (Hitachi)

– Un PC standard peut servir de cible s’il dispose d’une interface vidéo de type VESA et d’une carte réseau Ethernet compatible NE2000.

• Le cours a été développé sur une cible STPC STMicroelectronics

• Chapitres 201 à 209


Cible STPC


101 Installation de Platform Builder

• Installation de l’outil de développement Platform Builder

• Réparation de Platform Builder

• Désinstallation de Platform Builder


102 Généralités

• Présentation de notions de base– Système temps réel

– Système embarqué

– Configurations de base

– Process, thread, tâche

– Description de l’Operating System (OS)

– Architecture mémoire


103 Génération d’une plate-forme

• Prise en main de Platform Builder

• Réalisation d’un noyau

• Configuration de la cible

• Essai du noyau


Exemple

Génération de plate-forme


File→New Platform


Accueil de l’assistant : → Next


BSP→Emulator: X86


Choix du type de plate-forme

• Pour la plupart des essais de base prendre l’option

Industrial Controller

• « Industrial Controller » est très simple et assez passe-partout pour des commandes d’automates industriels ou de petites applications.


Nom de la plate-forme

• Par défaut les plates-formes sont sauvées dans «..\WINCE420\PUBLIC » dans un dossier qui correspond au nom saisi dans la boîte de dialogue

• Afin de différencier les fichiers de PUBLIC et ceux des plates-formes créées, nous ferons en général commencer les noms par z_


Choix : type et nom de plate-forme


Choix des options de plate-forme


Choix du réseau


Fin : →Finish


Configuration obtenue


104_1 Génération d’applications

• Génération d’applications– WCE Console Application

– WCE Application

• Téléchargement des applications

• Test des applications


104_2 Debugging élémentaire

• Premier contact avec les outils de mise au point• Génération en vue de debug• Usage des points d’arrêt, pas à pas• Visualisations diverses

– Code– Variables– Mémoire – Pile– …


105 Clavier français

• Montrer comment ajouter ou remplacer un driver à la plate-forme fournie d’origine

• Configuration par défaut : claviers Anglais, Japonais et Coréens, pas de clavier français

→ Ajout à notre catalogue d’un driver pour un clavier français

→ Remplacement dans notre plate-forme du driver par défaut par le driver ajouté au catalogue


106_1 Threads

• Génération d’une application avec thread– Création d’un thread

– Identification d’un thread

– Suspension/Reprise d’un thread

– Destruction d’un thread

– Contrôle de l’exécution

• Exemples de threads


106_2 Synchronisation

• Création d’une application ayant plusieurs threads

• Synchronisations entre threads– Section critique

– Mutex

– Événement

– Sémaphore

• Exemples pratiques


106_3 Kernel Tracker

• Écrire un programme multithread en mode debug

• Explorer Kernel Tracker, outils avancé de mise au point

• Visualisation des threads

• Visualisation des événements

• ...


107_1 – 107_2 Problème des trains

• Présentation du problème – Application des chapitres threads et synchronisation à un exemple

concret

• Corrigé


108_1 Principe des drivers

• Architecture d’un driver sous Windows CE• Fonctions système disponibles• Fonctions système à créer• Écriture d’un driver élémentaire• Génération du driver• Écriture d’une application élémentaire• Génération de l’application• Essai du driver


108_2 - 108_3 DRIVERexercice et corrigé

• Sous une plate-forme de type Industrial Controler préparer un driver « STR » capable de gérer un buffer en mémoire

• Écrire une chaîne de caractères en majuscules dans le buffer du driver par STR_Write

• Lire le buffer par STR_Read• Modifier le buffer par des STR_IOControl (par

exemple, passage majuscule/minuscule, cryptage)• Renvoyer le buffer modifié


109_1 – 109_2 Gestion mémoire exercice et corrigé

• Organisation de la mémoire

• Découpage en slots

• Rôle du slot 0

• Passage d’adresses entre le slot 0 et le slot de l’application

• Passage à un driver de pointeurs créés dynamiquement dans le slot 0


110-1 – 110_2 Communication inter Process

• Notions de mémoire locale, publique

• Passage d’adresses entre deux process

• Mapping des adresses

• Gestion des droits


111 Accès Internet

• Réalisation d’une plate-forme permettant l’accès à Internet

• Paramétrages réseau


112 Gestion de fichiers

• Exemple de gestion de fichiers directement sur une plate-forme diskless

• Accès aux zones mémoire réservées pour les fichiers

• Création, lecture, écriture, fermeture de fichiers


201 Boot CEPC

• CEPC : plate-forme de référence pour architecture PC x86

• Création de la disquette d’amorçage de la cible

• Préparation du téléchargement par le port éthernet

• Paramétrage de la carte réseau

• Configuration du PC hôte


202 génération de plate-forme

• Générer une plate-forme à télécharger dans une cible CEPC

• Configurer les connexions de l’hôte et de la cible• Télécharger Windows CE dans la cible• Recueillir les informations de debug fournies pendant le

téléchargement


203 OALOEM Adaptation Layer

• Présentation de la couche OAL• Survol de l’initialisation de la plate-forme • Fonctionnement des interruptions dans une

architecture PC classique à base de x86• Interruptions dans Windows CE• Étude de l’exemple de la liaison série

– Contrôleur de ligne série 16550– Contrôleur d’interruption 8259 – Programmes d’initialisation du 16550 et du 8259


204 Boot Loader

• Introduction de la notion de Boot Loader

• Donner un aperçu de l’organisation proposée avec Platform Builder

• Présenter des variantes utilisables avec une architecture à base de x86


205_1 –205_2 Serial en pollingexercice et corrigé

• Écrire un driver rudimentaire et l’intégrer dans Windows CE pour prendre connaissance des mécanismes

• Le driver choisi est le gestionnaire d’une liaison série classique dans le monde PC à base de l’UART 16550

• Ce composant présent sur la cible utilisé de la façon la plus simple, en polling, nous permettra d’essayer notre driver


206_1 Généralités sur les IT

• Présentation des notions nécessaires pour aborder le traitement des interruptions

• Organisation générale des interruptions sous Windows CE

• Étude des composants principaux– Handler– ISR – IST– Fonctions utiles


206_2 –206_3 Serial en ITexercice et corrigé

• Écrire un programme qui va communiquer par une liaison série

• La transmission se fera en polling

• La réception sera gérée par interruption

• On utilisera la deuxième liaison série connectée sur l’IRQ3 de la STPC


207_1 – 207_2 Utilisation de COM1exercice et corrigé

• Utiliser la ligne série de la plate-forme CEPC avec les logiciels fournis en standard par Windows CE

• Configurer le port série


208_1 – 208_2 Gestion du port parallèle

• Faire fonctionner un module d’affichage LCD couplé sur le port parallèle de la cible CEPC– Étude sommaire du port parallèle standard des PC

– Étude sommaire du module LCD

– Écriture d’un driver pour ce module

– Écriture d’une application pour afficher deux lignes sur le module LCD

– Téléchargement dans le CEPC

– Exécution


209 Web Pad

• Installation d’un serveur Web élémentaire sur la plate-forme CEPC

• Envoi d’une page d’accueil

• Utilisation d’Internet Explorer sur la cible


DEBOGGAGE

Problème des trains

Michel DUPLESSY


Threads et synchronisation


Objectif de la présentation

• Application à un exemple concret des chapitres « Threads » et « Synchronisation »

• Exemple de débogage avec Kernel Tracker

• Rappel des notions nécessaires présentées dans des chapitres précédents– Process

– Thread

– Synchronisation


Process

• Un process ou processus est une instance d’application en cours ou en attente d’exécution

• Un process démarre avec un seul thread (Primary Thread) mais il peut créer d’autres threads

• Un process peut avoir plusieurs threads en cours d’exécution simultanément


Thread

• Thread– Séquence obtenue par décomposition d’un process– Séquence de code exécutable et autonome– Accède à l’ensemble des ressources du process– Une priorité est attribuée à chaque thread

• Windows CE– 256 niveaux de priorités– Ordonnancement (scheduling) par le noyau– Système préemptif– Priorité tournante pour des threads de même priorité


Synchronisation des tâches

• Dès que plusieurs threads sont en jeu, il faut coordonner les exécutions

• Problème classique du verrou mortel • Différentes techniques sont disponibles : section

critique, Mutex, Événement, Sémaphore• On peut nommer les objets


Synchronisation par événement

• Gestion des événements– Création

– Prise de possession

– Restitution

– Transmission de données


Sémaphore

• Contrôle le nombre des accès à une ressource par la distribution de jetons

• Valeur maximale fixée à la création du sémaphore• Chaque utilisateur prend (si possible) et restitue un ou

plusieurs jetons sur le sémaphore• Chaque fois qu’un jeton est pris, le compteur de jeton est

décrémenté• Chaque fois qu’un jeton est restitué, le compteur de jeton

est incrémenté• Lorsque le nombre de jetons disponibles est 0, la ressource

n’est plus disponible et le demandeur attend


Trains : problème

• Des trains doivent circuler sur une voie ferrée à sens unique– De A vers B

– De B vers A

• Au plus, trois trains (dans le même sens !) peuvent se suivre sur la voie unique

• Cinq trains sont en attente de chaque côté• Objectif : faire passer les trains sans collision


Trains : solution (1)

• Plusieurs trains pouvant se suivre dans le même sens, il n’y a pas exclusion mutuelle entre les trains

→ Contrôle par un sémaphore

• La voie étant à sens unique

→ Contrôle par des événements de sens


Trains : solution (2)

• Chaque train sera un thread– 5 threads AB_MAIN (A vers B)– 5 threads BA_MAIN (B vers A)

• Pour qu’un train puisse entrer sur la voie il lui faudra obtenir– l’événement de sens– un des jetons du sémaphore

• Lors de la création des threads (fonction CreateThread) on passera un numéro de 1 à 5 pour différencier les threads de chaque sens (seulement deux threads à écrire au lieu de dix)


Trains : programme (1)

• Programme principal– Créer les 10 trains (10 threads)

– Créer deux événements de sens, A → B et B → A

– Créer un sémaphore à 3 jetons

– Gérer le passage des trains

– Fermer tout ce qui a été ouvert



• Boucle de gestion des trains– Libérer les jetons

– Positionner A vers B pendant 500 ms

– Attendre l’arrivée des trains en récupérant les jetons

– Faire la même chose pour l’autre sens

– S’arrêter quand tous les trains sont passés



• Thread train– Récupérer le numéro du train

– Attendre le sémaphore et l’événement de sens

– Envoyer un message : « train numéro x parti »

– Attendre 1 seconde (durée du trajet)

– Envoyer un message : « train numéro x arrivé »

– Rendre le jeton


Trains : main (1)#include "stdafx.h"#include "winbase.h"

DWORD WINAPI AB_MAIN (LPVOID p);DWORD WINAPI BA_MAIN (LPVOID p);HANDLE SEM;HANDLE SENS_AB,SENS_BA; int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow){


Trains : main (2) // Définitions et réservations // Paramètres passés aux threads : numéros de 1 à 5 DWORD ThPa1 = 1; DWORD ThPa2 = 2; DWORD ThPa3 = 3; DWORD ThPa4 = 4; DWORD ThPa5 = 5; DWORD val;

// Handles utilisés HANDLE AB_11, AB_12, AB_13, AB_14, AB_15, BA_21, BA_22, BA_23, BA_24, BA_25;


Trains : main (3)

// Création d'un sémaphore à 3 jetons possibles, vide au départ SEM=CreateSemaphore(NULL,0,3,NULL);

// Création des événements de sens SENS_AB=CreateEvent(NULL,TRUE,FALSE,NULL); SENS_BA=CreateEvent(NULL,TRUE,FALSE,NULL);

printf("début du main\n\n");


Trains : main (4) // Création des 10 threads AB_11=CreateThread(0,0,AB_MAIN,&ThPa1,0,0); AB_12=CreateThread(0,0,AB_MAIN,&ThPa2,0,0); AB_13=CreateThread(0,0,AB_MAIN,&ThPa3,0,0); AB_14=CreateThread(0,0,AB_MAIN,&ThPa4,0,0); AB_15=CreateThread(0,0,AB_MAIN,&ThPa5,0,0);

BA_21=CreateThread(0,0,BA_MAIN,&ThPa1,0,0); BA_22=CreateThread(0,0,BA_MAIN,&ThPa2,0,0); BA_23=CreateThread(0,0,BA_MAIN,&ThPa3,0,0); BA_24=CreateThread(0,0,BA_MAIN,&ThPa4,0,0); BA_25=CreateThread(0,0,BA_MAIN,&ThPa5,0,0);


Trains : main (5) // Boucle principale do { // Attente avant départ de A vers B Sleep(1000); // Libération des 3 jetons ReleaseSemaphore(SEM,3,NULL); // Set de l’événement de sens de A vers B SetEvent(SENS_AB); // Attente de 500 tics Sleep(500); // Reset de l’événement de sens de A vers B ResetEvent(SENS_AB);


Trains : main (6)

// Attente de l'arrivée des trains et récupération des 3 jetons

WaitForSingleObject(SEM,INFINITE);



// Attente avant les départs de B vers A

Sleep(1000);

// Libération des 3 jetons

ReleaseSemaphore(SEM,3,NULL);


Trains : main (7) // Set de l’événement de sens de B vers A SetEvent(SENS_BA); // Attente de 500 tics Sleep(500);

// Reset de l’événement de sens de B vers A ResetEvent(SENS_BA);

// Attente de l'arrivée des trains et récupération des 3 jetons WaitForSingleObject(SEM,INFINITE); WaitForSingleObject(SEM,INFINITE); WaitForSingleObject(SEM,INFINITE);


Trains : main (8)

// Vérification de l'arrivée du dernier train

GetExitCodeThread(BA_25,&val);

printf("code du thread : %d\n",val);

}

while(val==259); // Tant que le dernier train n’est pas arrivé

printf("fin du main\n");

getchar();


Trains : main (9) // Fermeture des handles CloseHandle(AB_11); CloseHandle(AB_12); CloseHandle(AB_13); CloseHandle(AB_14); CloseHandle(AB_15);

CloseHandle(BA_21); CloseHandle(BA_22); CloseHandle(BA_23); CloseHandle(BA_24); CloseHandle(BA_25);


Trains : main (10)

CloseHandle(SEM); CloseHandle(SENS_AB); CloseHandle(SENS_BA);

return 0;}


Trains : AB_MAIN (1)DWORD WINAPI AB_MAIN(LPVOID p){ // Initialisation des variables de retour // de la fonction WaitForSingleObject DWORD SENS=1,SEMA=1;

// Récupération du numéro du thread (DWORD pp) // p est un pointeur de 'void' // p pointe sur le paramètre passé au thread

DWORD pp=*(DWORD*)p;


Trains : AB_MAIN (2)

// Attente de l'obtention du sens et du sémaphore

// Les 2 valeurs doivent être égales à zéro

while(SENS!=0 || SEMA!=0)

{

SENS=WaitForSingleObject(SENS_AB,INFINITE);

SEMA=WaitForSingleObject(SEM,1);

}


Trains : AB_MAIN (3) // Traitement printf("départ du train AB %d\n",pp); Sleep(1000); // Durée du trajet printf("arrivée du train AB %d\n",pp);

// Libération du sémaphore ReleaseSemaphore(SEM,1,NULL);

return 0;}


Trains : BA_MAIN (1)DWORD WINAPI BA_MAIN(LPVOID p){ // Initialisation des variables de retour // de la fonction WaitForSingleObject DWORD SENS=1,SEMA=1;

// Récupération du numéro du thread DWORD pp // p est un pointeur de 'void' // p pointe sur le paramètre passé au thread

DWORD pp=*(DWORD*)p;


Trains : BA_MAIN (2) // Attente de l'obtention du sens et du sémaphore // Les 2 valeurs doivent être égales à zéro while(SENS!=0 || SEMA!=0) { SENS=WaitForSingleObject(SENS_BA,INFINITE); SEMA=WaitForSingleObject(SEM,1); }


Trains : BA_MAIN (3)

// Traitement printf("départ du train BA %d\n",pp); Sleep(1000); // Durée du trajet printf("arrivée du train BA %d\n",pp);

// Libération du sémaphore ReleaseSemaphore(SEM,1,NULL);

return 0;}


Résultat

On a un peu triché avec les accents


Plate-forme de travail


Outils de Platform Builder

• Platform Builder propose un ensemble d’outils spécialisés et un générateur de macro pour aider à la mise au point d’applications, vérifier le bon fonctionnement temporel, étudier les performances, visualiser les fenêtres, etc.

• Parmi ces outils, le « Remote Kernel Tracker » permet de visualiser graphiquement la chronologie d’une application : création des process, threads, événements, enchaînement des événements, mutex, etc.


Modification de l’exemple

• Dans notre exemple de programme les impressions par printf sont elles-mêmes gérées par des événements, sections critiques, etc.

• Pour simplifier sous Kernel Tracker la visualisation des résultats qui nous intéressent, nous avons reconstruit l’exemple en supprimant des impressions


Découverte de Kernel Tracker

• Téléchargement du noyau

• Lancement de Remote Kernel Tracker

• Lancement de TRAINS

• Collecte des données– Attente de quelques secondes

– Fin de TRAINS après click sur OK

– Fin de la collecte après quelques secondes

– Déconnexion de la cible

• Analyse des données


Démarrage de Remote Kernel Tracker


Accepter le choix par défaut : OK


Début de Remote Kernel Tracker


Exemple de visualisation

Menus…

Threads

Légende

Échelle de temps

Fenêtre de visualisation

Info Bulle


Phase de démarrage de TRAINS

Prologue


Positionnement du curseur

Click gauche


Positionnement du marqueur 1

Ouverture du menu par un click droit


Positionnement du marqueur 2

Marqueur 1positionné

Curseur déplacé


Mesure du temps entre marqueurs

Écart visualisé par une hachure

Écart mesuré numériquement


Démarrage des threads


Circulation des premiers trains

Démarrage des threads

3 trains partent

2 trains attendent

2 trains prêts

3 trains attendent

3 trains arrivent


Détail du départ d’un train

Libération du sémaphore

Autorisation donnée A→B

Autorisation reçue

Train circule


Fin des premiers threads

Restitution d’un jeton

Fin du thread 1

Fin du thread 2

Fin du thread 3


Action directe sur les threads

Ouverture du menu par click droit sur le nom du

thread


Circulation des trains suivants


Arrivée du dernier train


Fin du programme

Attente du getchar()


Conclusion

• Nous avons exploré quelques aspects de Kernel Tracker– Visualisation de l’enchaînement des tâches

– Visualisation des objets

– Mesure des temps

– Utilisation en tant qu’analyseur logique


DRIVER Port Parallèle

Commande de LCD

Liliane PIEDFORT


EXEMPLE DE DRIVER PORT PARALLELE

Commande d’un module

d’affichage LCD


Plan

• Fonctionnement du port parallèle

• Fonctionnement du LCD– Signaux

– Commandes

• Notion de driver

• Driver du LCD

• Programme d’application


Port Parallèle d’un PC (1)

• Le port parallèle standard (SPP) est un port prévu dès l’origine du PC pour obtenir une liaison plus rapide que la liaison série de l’époque, utile pour commander une imprimante

• 0x378 : Parallel Printer 1 (LPT1) associé à l’IRQ7


Port Parallèle d’un PC (2)

• Registre de données (D7-D0) – à l’adresse de base du port

• Registre de Status (S7-S3)– à l’adresse de base du port + 1– utilisé pour ses cinq bits de poids forts seulement S7-S3, S2-S0 inutilisés ou inexistants

• Registre de commande (C4-C0)– à l’adresse de base du port + 2– Utilisé pour ses cinq bits de poids faibles C4-C0,

C7-C5 inutilisés ou inexistants– Pour le LCD nous n’utilisons que les bits C3 et C0


Registres du port parallèle

Adresse de base

Registre de données

D7 D0

Adresse de base + 1

Registre de status (lecture)

S7

Adresse de base + 2

Registre de contrôle

C0

Poids fort Poids faible

S5S6 S4 S3

C3 C2 C1

D6 D5 D4 D3 D2 D1

C4


Registres données et commandeD0 D0

D1

D2

D3

D4

D5

D6

D7

Registre données Buffer

D5

D2

D3

D4

D1

D6

D7

C0 C0

C1

C2

C3

Registre commande Buffer

C2

C3

C1


Écriture sur un port

VOID WRITE_PORT_UCHAR(PUCHAR Port, UCHAR Value);

ParametersPort

[in] Pointer to the port that must be a mapped memory range in I/O space.

Value [in] Byte to be written to the port.

Return ValuesNone.


Module d’affichage LCD

• Le module HD44780 possède

– Une mémoire de 80 caractères :

Display Data RAM (DD RAM)

– Un générateur de police de caractère

– Deux registres internes: DR et IR

• Taille de l’afficheur utilisé :– Nombre de lignes d’affichage : 2

– Nombre de caractères par ligne : 20


Signaux du module LCD

• Port de données D7-D0• RS Register Select• E Enable• R/nW Lecture/écriture, ici écriture seule: 0

• VDD Alimentation 5V

• VSS Masse

• VL Contrôle du contraste, maximal = 0


Câblage du module LCD sur le port parallèle

Module d’affichage LCD

R/W VSS VL VDD

Port parallèle

D7 D6 D5 D4 D3 D2 D1 D0

D7 D6 D5 D4 D3 D2 D1 D0

RS E

C0C3

VDD VDD

VDD

9 8 67 5 34 172 1

VL à la masse donne le contraste

maximum

10 KΩ 10 KΩ


Registres internes du module LCD

• Deux registres internes– IR registre d’instruction

– DR registre de données

• Commande des registres par deux signaux– RS : Register Selector relié à la broche nC3 du port parallèle

différencie ces deux registres:• RS = 0 accès à IR

• RS = 1 accès à DR

– E : Enable relié à la broche nC0 du port parallèle,

E 1 valide l’introduction des données dans les registres


Séquence d’écriture dans IR et DR

R SIR sé le c té

D R sé le c té

D 0 - D 7 D a ta p o u r IR D a ta p o u r D R

ED a ta p ris e e n c o m p te

Repos IR

RS=0 E=0

Donnée → IR

RS=0 E→0

Donnée → DR

RS=1 E→0

Repos DR

RS=1 E=0


Commandes pour écrire dans IR

• Signaux de commande en position de repos RS relié à nC3 et E relié à nC0 mais état

complémenté des bits C3 et C0 d’où : commande . . . . 1 x x 1 (RS=0 E=0)

• Mettre l’instruction sur le port parallèle D7-D0• Écrire cette instruction dans le registre IR

commande . . . . 1 x x 0 (RS=0 E=1)• Retour à l’état de repos

commande . . . . 1 x x 1 (RS=0 E=0)


Commandes pour écrire dans DR

• Signaux de commande en position de repos RS relié à nC3 et E relié à nC0 mais état

complémenté des bits C3 et C0 d’où : commande . . . . 0 x x 1 (RS=1 E=0)

• Mettre la donnée sur le port parallèle D7-D0• Écrire cette donnée dans le registre DR

commande . . . . 0 x x 0 (RS=1 E=1)• Retour à l’état de repos

commande . . . . 0 x x 1 (RS=1 E=0)


Détail des commandes IR et DR

• Afficheur LCD à deux lignes (C1 inutilisé, à 0 )

• C2 inutilisé, mis à 1

• Repos en prévision d’une commande pour IR%1101 = 0xD «CTRL» RS=0 E=0

• Entrée de la commande dans IR%1100 = 0xC «CTRLEN» RS=0 E=1

• Repos en prévision d’une commande pour DR%0101 = 0x5 «DATA» RS=1 E=0

• Entrée de la commande dans DR%0100 = 0x4 «DATAEN» RS=1 E=1


DDRAM du module LCD

• Le module LCD contient une DDRAM gérée automatiquement par les écritures dans le registre DR

• La donnée écrite dans le registre DR est transférée systématiquement dans la DDRAM à une adresse définie par un compteur d’adresse interne (AC)

• AC incrémenté à chaque écriture dans DR• AC initialisé par écriture de l’instruction

Set DDRAM address dans le registre IR


LCD à 2 lignes de 20 caractèresDDRAM

20 caractères

20 caractères

20 caractères

20 caractères

Premièreligne

Secondeligne

0x00

0x270x40

0x67

0x13

0x530x54


Instructions pour le LCD (1)

• Clear Display: 0x01• Return Home: 0x02• Entry Mode Set: 0x04 à 0x07 (%000001 I/D S)

– I/D = 1 incrément– S = 0 pas de décalage

• Display ON/OFF: 0x08 à 0x0F (%00001 D C B)– D = 0 display OFF– C = 0 cursor OFF– B = 0 blink OFF


Instructions pour le LCD (2)

• Function Set: 0x38 ici (%001 DL N F 00)– DL=1 Interface 8 bits

– N=1 LCD à deux lignes (0 pour une ligne)

– F=0 Matrice 5x7

0x30 au reset• Set DDRAM address: 0x80 à 0xFF (bit 7 à 1)

(%1AAAAAAA)

– AAAAAAA Adresse sur 7 bits à placer dans le compteur AC


Initialisation du LCD

• Timing à respecter après la mise sous tension

• Séquence de commande obligatoire de configuration du LCD


Timing à respecter après Power On


Séquence d’initialisation

• RESET:Instruction 0x30 (Function Set: interface 8 bits) envoyée 3 fois

• Display OFF• Display ON• Clear Display• Function Set: taille réelle de l’interface, nombre de

lignes et police. (non modifiable ensuite)• Mode Set: gestion affichage (décalage texte,

incrément d’adresse mémoire)


Exemple d’envoi de commande

// Mise du port dans l’état repos commande

WRITE_PORT_UCHAR(PARCOMMAND, CTRL);

Sleep(15); // Attente de 15ms après la mise sous tension.

// Function Set 1 (interface 8 bits)

WRITE_PORT_UCHAR(PARDATA, 0x30);

WRITE_PORT_UCHAR(PARCOMMAND, CTRLEN);

Sleep(2); // Attente de 2 ms (signal ENABLE actif)

WRITE_PORT_UCHAR(PARCOMMAND, CTRL);

Sleep(5); // Attente de 5 ms avant la commande suivante.


Notion de driver


Driver

• Driver : raccourci pour « device driver », souvent traduit par pilote ou contrôleur de périphérique

• Device : dispositif physique (périphérique) ou logique (protocole, service, périphérique virtuel, fichier) dont le fonctionnement nécessite des commandes et des ressources au sens large, mémoire, temps, port, etc.

• Device driver : module logiciel qui assure l’interface entre le système et le device


Règle de nommage

Nom commençant par un préfixe (XXX de façon symbolique) de trois caractères pour le driver, par exemple TTY pour une ligne série ou PAR pour l’exemple présenté suivi du caractère underscore et du nom de la fonction réalisée.

ex : PAR_Init


Fichier .def

• Sert à décrire un module pour orienter le travail de l’éditeur de liens lors de la création d’un exécutable .exe ou d’une dll

• Fichier à créer en respectant une structure particulière

• Structure décrite dans la documentation sous l’entrée « Module-Definition Files »

• Nous n’utiliserons que le paragraphe LIBRARY et l’entrée EXPORT dans notre fichier .def


Fonctions d’un driver

• XXX_Init• XXX_Deinit• XXX_Open• XXX_Close• XXX_Read• XXX_Write• XXX_IoControl• XXX_Seek• XXX_PowerUp• XXX_PowerDown


Lien Driver Application

• XXX_Init appelé par RegisterDevice

• XXX_Open appelé par CreateFile

• XXX_IOControl appelé par DeviceIOControl

• XXX_Close appelé par CloseHandle

• XXX_Deinit appelé par DeregisterDevice


Driver de gestion du LCD


PARA.def


Driver (1)

// #include nécessaires

#include "stdafx.h"

#include <tchar.h>

#include <nkintr.h>

#include <wdm.h>

#include <windev.h>


Driver (2)

// Définition des IOCTL

#define IOCTL_PUTC \ CTL_CODE(FILE_DEVICE_UNKNOWN,2048,\ METHOD_BUFFERED,FILE_ANY_ACCESS)

#define IOCTL_CURSEUR \ CTL_CODE(FILE_DEVICE_UNKNOWN,2049,\

METHOD_BUFFERED,FILE_ANY_ACCESS)


Driver (3)// Définition des adresses du port parallèle#define PARBASE ((PUCHAR) 0x0378)#define PARDATA PARBASE#define PARCOMMAND PARBASE+2

// Définition des mots de commande#define CTRL 0xD#define CTRLEN0xC#define DATA 0x5#define DATAEN 0x4


Driver (4)

BOOL APIENTRY DllMain(HANDLE hModule,

DWORD ul_reason_for_call,

LPVOID lpReserved)

{

return TRUE;

}


Driver (5)DWORD PAR_Init(DWORD dwContext){ // Mise du port dans l’état repos commande DWORD dwRet = 1;

WRITE_PORT_UCHAR(PARCOMMAND,CTRL); Sleep(15);

// Envoi des trois Function Set de RESET

// Positionnement de la donnée : 0x30WRITE_PORT_UCHAR(PARDATA,0x30);// Function Set 1 WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);Sleep(5);


Driver (6)// Function Set 2WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);Sleep(1);

// Function Set 3WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);Sleep(10);


Driver (7)// Display OFFWRITE_PORT_UCHAR(PARDATA,0x08);WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);Sleep(10);// Display ONWRITE_PORT_UCHAR(PARDATA,0x0F);WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);Sleep(10);


Driver (8)// Clear DisplayWRITE_PORT_UCHAR(PARDATA,0x01);WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL); Sleep(10);// Function Set (2 lignes, 8 bits)WRITE_PORT_UCHAR(PARDATA,0x38);WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);Sleep(10);


Driver (9)

// Mode Set (incrément, pas de décalage)

WRITE_PORT_UCHAR(PARDATA ,0x06);WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL); Sleep(10);// Mise du port dans l’état repos dataWRITE_PORT_UCHAR(PARCOMMAND,DATA);

return dwRet;

}


Driver (10)

BOOL PAR_Deinit(DWORD hDeviceContext)

{

BOOL bRet = TRUE;

return bRet;

}


Driver (11)DWORD PAR_Open(DWORD hDeviceContext,

DWORD AccessCode,DWORD ShareMode)

{

DWORD dwRet = 1;

return dwRet;

}

BOOL PAR_Close(DWORD hOpenContext){ BOOL bRet = TRUE; return bRet;}


Driver (12)BOOL PAR_IOControl(DWORD hOpenContext, DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut){

int val; BOOL bRet = 1;


Driver (13)

switch(dwCode)

{

case IOCTL_PUTC:

WRITE_PORT_UCHAR(PARDATA,pBufIn[0]);

WRITE_PORT_UCHAR(PARCOMMAND, DATAEN);

Sleep(2);

WRITE_PORT_UCHAR(PARCOMMAND,DATA);

break;


Driver (14)

case IOCTL_CURSEUR:

// Positionnement du curseur à définir dans l’application

val = pBufIn[0];

// Commande 1xxxxxxx (xxxxxxx 7 bits)

val = val + 0x80;

// Mise du port en repos commande

WRITE_PORT_UCHAR(PARCOMMAND,CTRL);

Sleep(2);


Driver (15)

// Envoi de la commande de positionnement

WRITE_PORT_UCHAR(PARDATA,val); WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN);Sleep(2);WRITE_PORT_UCHAR(PARCOMMAND,CTRL);

// Mise du port en repos data WRITE_PORT_UCHAR(PARCOMMAND,DATA); break; }// switch


Driver (16)

*pdwActualOut = 1;

return bRet;

} // Fin du Driver LCD


ApplicationLCD

Écriture d’un message sur 2 lignes


Application (1)// #include nécessaires

#include "stdafx.h"

#include <windev.h>

// Définition des IOCTL

#define IOCTL_PUTC \ CTL_CODE(FILE_DEVICE_UNKNOWN,2048,\ METHOD_BUFFERED,FILE_ANY_ACCESS)

#define IOCTL_CURSEUR \ CTL_CODE(FILE_DEVICE_UNKNOWN,2049,\

METHOD_BUFFERED,FILE_ANY_ACCESS)


Application (2)

int WINAPI WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPTSTR lpCmdLine,

int nCmdShow)

{


Application (3)

// Déclarations et réservations

HANDLE hDevice;

CHAR carac1[1];

DWORD dwNb;

HANDLE hPara;

CHAR* pstring1 = " journées académiques";

CHAR* pstring2 = " 2005";

unsigned int i;


Application (4)

// Chargement du driver

hDevice = RegisterDevice(TEXT("PAR"),1,

TEXT("PARA_DRV.dll"),NULL);

if(hDevice == 0)

{

MessageBox(NULL,_T("Pb Register PAR1:"),

_T("PARA_APP"),MB_OK);

return 0;

}


Application (5)

// Ouverture du driver

hPara = CreateFile(TEXT("PAR1:"),GENERIC_WRITE, 0,NULL,OPEN_EXISTING,0,0);

if (hPara == INVALID_HANDLE_VALUE) { MessageBox(NULL,_T("Pb Ouverture PAR1:"), _T("PARA_APP"),MB_OK); DeregisterDevice(hDevice);

CloseHandle(hDevice);

return 0;

}


Application (6)

// Envoi première chaîne de caractères

for(i = 0; i <strlen(pstring1); i++)

{

carac1[0] = pstring1[i];

DeviceIoControl(hPara,IOCTL_PUTC,carac1,1,

carac1,1,&dwNb,NULL);

Sleep(10);

}


Application (7)

// Positionnement du curseur au début de la ligne 2carac1[0]=0x40;DeviceIoControl(hPara,IOCTL_CURSEUR,

carac1,1,carac1,1,&dwNb,NULL);// Envoi deuxième chaînefor(i=0;i<strlen(pstring2);i++){

carac1[0]=pstring2[i];DeviceIoControl(hPara,IOCTL_PUTC,carac1,1,

carac1,1,&dwNb,NULL);Sleep(10);

}


Application (8)

// Fermeture des handles

CloseHandle(hPara);

DeregisterDevice(hDevice);

CloseHandle(hDevice);

MessageBox(NULL,_T("Fin application PARA_APP"),

_T("PARA_APP"),MB_OK);

return 0;

} // Fin de l’application


Téléchargement du noyau et de l’application sur la cible

Ligne ethernet

Adresse IP de l’hôte

Carte réseau locale 1

Carte Locale 2192.168.0.1.Netgear

Passerelle vue par défaut Câble Ethernet croisé

Carte réseau locale 192.168.0.100Non en DHCPPas de DNS

Cible CEPC

Port parallèle

Journées Académiques2005

PC hôte


Conclusion


Cours disponible

• Version V1.0– www.esiee.fr/~callotj

– www.msdnaa.net/search/advancedsearch.aspx

http://www.esiee.fr/~callotj

http://www.esiee.fr/~callotj


Développements en cours

• Cible Dragon Ball Mx21– Portage CE5.0

– Applications vidéo

– Réalisation d’une maquette pédagogique


iMX21


Questions

CE4.2Journées académiques Microsoft 20051 Cours Windows CE.

Documents

Transcript of CE4.2Journées académiques Microsoft 20051 Cours Windows CE.