Cours Windows CE

1
Cours Windows CE
2
Plan de la présentation

• Windows CE  pour qui, pour quoi ? 
• Description du cours réalisé
• Exemple dapplication et de debuggage
• Exemple de driver port parallèle
• Conclusion et questions

3
Windows CE

• Interface classique de Windows
• Système dexploitation modulaire et compact
• Nest 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

4
Applications

• Téléphonie
• PDA
• Bornes interactives
• Machine à coudre (Bernina)
• Machine à voter (Unisys)
• Robot domestique (Fujitsu)
• Chaudières, réfrigérateur

5
Pourquoi ce cours ?

• Besoin pour lESIEE
• Demande de Laurent Ellerbach et de son équipe
• Cours en français
• Accessible aux non informaticiens purs et durs
• Basé sur lexemple
• Mis à la disposition des enseignants

6
Groupe ESIEE

• École dingénieurs BAC5
• École de technologues BAC3
• Domaines de compétence
• Électronique et microélectronique
• Informatique
• Systèmes embarqués
• Télécommunications

7
É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)

8
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 lapplication (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)

9
Les électroniciens

• Spécialistes de lélectronique, pas de
  linformatique
• 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

10
É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é dune double compétence

11
Électroniciens BAC2/BAC3

• 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

12
Électroniciens BAC5

• É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 lindustrie

13
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 lexercice
• Correction de lexercice
• Pédagogie adaptée à de petits groupes

14
Caractéristiques du cours

• Cours de base simple, mais concret
• Permet de comprendre les grandes fonctions dun
  OS à travers des exemples gradués
• Permet daborder ultérieurement un cours standard
  du marché ou une auto formation
• Objectifs
• Formation de BAC3
• Premier niveau pour des BAC5
• Reconversion déquipes industrielles
• Auto formation

15
Organisation du cours

• Deux grandes parties
•  Émulateur 
•  Cible 
• La partie émulateur permet de se familiariser
  avec les outils et dacqué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

16
É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

17
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 sil dispose
  dune interface vidéo de type VESA et dune carte
  réseau Ethernet compatible NE2000.
• Le cours a été développé sur une cible STPC
  STMicroelectronics
• Chapitres 201 à 209

18
Cible STPC
19
101 Installation de Platform Builder

• Installation de loutil de développement Platform
  Builder
• Réparation de Platform Builder
• Désinstallation de Platform Builder

20
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 lOperating System (OS)
• Architecture mémoire

21
103 Génération dune plate-forme

• Prise en main de Platform Builder
• Réalisation dun noyau
• Configuration de la cible
• Essai du noyau

22
Exemple

• Génération de plate-forme

23
File?New Platform
24
Accueil de lassistant ? Next
25
BSP?Emulator X86
26
Choix du type de plate-forme

• Pour la plupart des essais de base prendre
  loption
• Industrial Controller
•  Industrial Controller  est très simple et
  assez passe-partout pour des commandes
  dautomates industriels ou de petites
  applications.

27
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_

28
Choix type et nom de plate-forme
29
Choix des options de plate-forme
30
Choix du réseau
31
Fin ?Finish
32
Configuration obtenue
33
104_1 Génération dapplications

• Génération dapplications
• WCE Console Application
• WCE Application
• Téléchargement des applications
• Test des applications

34
104_2 Debugging élémentaire

• Premier contact avec les outils de mise au point
• Génération en vue de debug
• Usage des points darrêt, pas à pas
• Visualisations diverses
• Code
• Variables
• Mémoire
• Pile

35
105 Clavier français

• Montrer comment ajouter ou remplacer un driver à
  la plate-forme fournie dorigine
• Configuration par défaut claviers Anglais,
  Japonais et Coréens, pas de clavier français
• ? Ajout à notre catalogue dun driver pour un
  clavier français
• ? Remplacement dans notre plate-forme du driver
  par défaut par le driver ajouté au catalogue

36
106_1 Threads

• Génération dune application avec thread
• Création dun thread
• Identification dun thread
• Suspension/Reprise dun thread
• Destruction dun thread
• Contrôle de lexécution
• Exemples de threads

37
106_2 Synchronisation

• Création dune application ayant plusieurs
  threads
• Synchronisations entre threads
• Section critique
• Mutex
• Événement
• Sémaphore
• Exemples pratiques

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

39
107_1 107_2 Problème des trains

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

40
108_1 Principe des drivers

• Architecture dun driver sous Windows CE
• Fonctions système disponibles
• Fonctions système à créer
• Écriture dun driver élémentaire
• Génération du driver
• Écriture dune application élémentaire
• Génération de lapplication
• Essai du driver

41
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é

42
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 dadresses entre le slot 0 et le slot de
  lapplication
• Passage à un driver de pointeurs créés
  dynamiquement dans le slot 0

43
110-1 110_2 Communication inter Process

• Notions de mémoire locale, publique
• Passage dadresses entre deux process
• Mapping des adresses
• Gestion des droits

44
111 Accès Internet

• Réalisation dune plate-forme permettant laccès
  à Internet
• Paramétrages réseau

45
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

46
201 Boot CEPC

• CEPC plate-forme de référence pour architecture
  PC x86
• Création de la disquette damorç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

47
202 génération de plate-forme

• Générer une plate-forme à télécharger dans une
  cible CEPC
• Configurer les connexions de lhôte et de la
  cible
• Télécharger Windows CE dans la cible
• Recueillir les informations de debug fournies
  pendant le téléchargement

48
203 OALOEM Adaptation Layer

• Présentation de la couche OAL
• Survol de linitialisation de la plate-forme
• Fonctionnement des interruptions dans une
  architecture PC classique à base de x86
• Interruptions dans Windows CE
• Étude de lexemple de la liaison série
• Contrôleur de ligne série 16550
• Contrôleur dinterruption 8259
• Programmes dinitialisation du 16550 et du 8259

49
204 Boot Loader

• Introduction de la notion de Boot Loader
• Donner un aperçu de lorganisation proposée avec
  Platform Builder
• Présenter des variantes utilisables avec une
  architecture à base de x86

50
205_1 205_2 Serial en pollingexercice et
corrigé

• Écrire un driver rudimentaire et lintégrer dans
  Windows CE pour prendre connaissance des
  mécanismes
• Le driver choisi est le gestionnaire dune
  liaison série classique dans le monde PC à base
  de lUART 16550
• Ce composant présent sur la cible utilisé de la
  façon la plus simple, en polling, nous permettra
  dessayer notre driver

51
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

52
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 lIRQ3 de la STPC

53
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

54
208_1 208_2 Gestion du port parallèle

• Faire fonctionner un module daffichage 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 dun driver pour ce module
• Écriture dune application pour afficher deux
  lignes sur le module LCD
• Téléchargement dans le CEPC
• Exécution

55
209 Web Pad

• Installation dun serveur Web élémentaire sur la
  plate-forme CEPC
• Envoi dune page daccueil
• Utilisation dInternet Explorer sur la cible

56
DEBOGGAGE

• Problème des trains
• Michel DUPLESSY

57
Threads et synchronisation
58
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

59
Process

• Un process ou processus est une instance
  dapplication en cours ou en attente dexécution
• Un process démarre avec un seul thread (Primary
  Thread) mais il peut créer dautres threads
• Un process peut avoir plusieurs threads en cours
  dexécution simultanément

60
Thread

• Thread
• Séquence obtenue par décomposition dun process
• Séquence de code exécutable et autonome
• Accède à lensemble 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é

61
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

62
Synchronisation par événement

• Gestion des événements
• Création
• Prise de possession
• Restitution
• Transmission de données

63
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 quun jeton est pris, le compteur de
  jeton est décrémenté
• Chaque fois quun jeton est restitué, le compteur
  de jeton est incrémenté
• Lorsque le nombre de jetons disponibles est 0, la
  ressource nest plus disponible et le demandeur
  attend

64
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

65
Trains solution (1)

• Plusieurs trains pouvant se suivre dans le même
  sens, il ny 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

66
Trains solution (2)

• Chaque train sera un thread
• 5 threads AB_MAIN (A vers B)
• 5 threads BA_MAIN (B vers A)
• Pour quun 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)

67
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

68
Trains programme (2)

• Boucle de gestion des trains
• Libérer les jetons
• Positionner A vers B pendant 500 ms
• Attendre larrivée des trains en récupérant les
  jetons
• Faire la même chose pour lautre sens
• Sarrêter quand tous les trains sont passés

69
Trains programme (3)

• 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

70
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)

71
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

72
Trains main (3)

• // Création d'un sémaphore à 3 jetons
  possibles, vide au départ
• SEMCreateSemaphore(NULL,0,3,NULL)
• // Création des événements de sens
• SENS_ABCreateEvent(NULL,TRUE,FALSE,NULL)
• SENS_BACreateEvent(NULL,TRUE,FALSE,NULL)
• printf("début du main\n\n")

73
Trains main (4)

• // Création des 10 threads
• AB_11CreateThread(0,0,AB_MAIN,ThPa1,0,0)
• AB_12CreateThread(0,0,AB_MAIN,ThPa2,0,0)
• AB_13CreateThread(0,0,AB_MAIN,ThPa3,0,0)
• AB_14CreateThread(0,0,AB_MAIN,ThPa4,0,0)
• AB_15CreateThread(0,0,AB_MAIN,ThPa5,0,0)
• BA_21CreateThread(0,0,BA_MAIN,ThPa1,0,0)
• BA_22CreateThread(0,0,BA_MAIN,ThPa2,0,0)
• BA_23CreateThread(0,0,BA_MAIN,ThPa3,0,0)
• BA_24CreateThread(0,0,BA_MAIN,ThPa4,0,0)
• BA_25CreateThread(0,0,BA_MAIN,ThPa5,0,0)

74
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)

75
Trains main (6)

• // Attente de l'arrivée des trains et
  récupération des 3 jetons
• WaitForSingleObject(SEM,INFINITE)
• WaitForSingleObject(SEM,INFINITE)
• WaitForSingleObject(SEM,INFINITE)
• // Attente avant les départs de B vers A
• Sleep(1000)
• // Libération des 3 jetons
• ReleaseSemaphore(SEM,3,NULL)

76
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)

77
Trains main (8)

• // Vérification de l'arrivée du dernier
  train
• GetExitCodeThread(BA_25,val)
• printf("code du thread d\n",val)
• while(val259) // Tant que le dernier train
  nest pas arrivé
• printf("fin du main\n")
• getchar()

78
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)

79
Trains main (10)

• CloseHandle(SEM)
• CloseHandle(SENS_AB)
• CloseHandle(SENS_BA)
• return 0

80
Trains AB_MAIN (1)

• DWORD WINAPI AB_MAIN(LPVOID p)
• // Initialisation des variables de retour
• // de la fonction WaitForSingleObject
• DWORD SENS1,SEMA1
• // 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

81
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)
• SENSWaitForSingleObject(SENS_AB,INFINITE)
  
• SEMAWaitForSingleObject(SEM,1)

82
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

83
Trains BA_MAIN (1)

• DWORD WINAPI BA_MAIN(LPVOID p)
• // Initialisation des variables de retour
• // de la fonction WaitForSingleObject
• DWORD SENS1,SEMA1
• // 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

84
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)
• SENSWaitForSingleObject(SENS_BA,INFINITE)
  
• SEMAWaitForSingleObject(SEM,1)

85
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

86
Résultat
On a un peu triché avec les accents
87
Plate-forme de travail
88
Outils de Platform Builder

• Platform Builder propose un ensemble doutils
  spécialisés et un générateur de macro pour aider
  à la mise au point dapplications, 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
  dune application création des process,
  threads, événements, enchaînement des événements,
  mutex, etc.

89
Modification de lexemple

• 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 lexemple en supprimant
  des impressions

90
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

91
Démarrage de Remote Kernel Tracker
92
Accepter le choix par défaut OK
93
Début de Remote Kernel Tracker
94
Exemple de visualisation
Menus
Échelle de temps
Info Bulle
Fenêtre de visualisation
Threads
Légende
95
Phase de démarrage de TRAINS
Prologue
96
Positionnement du curseur
Click gauche
97
Positionnement du marqueur 1
Ouverture du menu par un click droit
98
Positionnement du marqueur 2
Marqueur 1 positionné
Curseur déplacé
99
Mesure du temps entre marqueurs
Écart visualisé par une hachure
Écart mesuré numériquement
100
Démarrage des threads
101
Circulation des premiers trains
3 trains partent
2 trains attendent
3 trains arrivent
2 trains prêts
Démarrage des threads
3 trains attendent
102
Détail du départ dun train
Libération du sémaphore
Autorisation donnée A?B
Autorisation reçue
Train circule
103
Fin des premiers threads
Restitution dun jeton
Fin du thread 1
Fin du thread 2
Fin du thread 3
104
Action directe sur les threads
Ouverture du menu par click droit sur le nom du
thread
105
Circulation des trains suivants
106
Arrivée du dernier train
107
Fin du programme
Attente du getchar()
108
Conclusion

• Nous avons exploré quelques aspects de Kernel
  Tracker
• Visualisation de lenchaînement des tâches
• Visualisation des objets
• Mesure des temps
• Utilisation en tant quanalyseur logique

109
DRIVER Port Parallèle

• Commande de LCD
• Liliane PIEDFORT

110
EXEMPLE DE DRIVER PORT PARALLELE

• Commande dun module
• daffichage LCD

111
Plan

• Fonctionnement du port parallèle
• Fonctionnement du LCD
• Signaux
• Commandes
• Notion de driver
• Driver du LCD
• Programme dapplication

112
Port Parallèle dun PC (1)

• Le port parallèle standard (SPP) est un port
  prévu dès lorigine 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é à
  lIRQ7

113
Port Parallèle dun PC (2)

• Registre de données (D7-D0)
• à ladresse de base du port
• Registre de Status (S7-S3)
• à ladresse 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)
• à ladresse 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 nutilisons que les bits C3 et C0

114
Registres du port parallèle
Registre de données
Adresse de base
D7
D0
D6
D5
D4
D3
D2
D1
Poids fort
Poids faible
Registre de status (lecture)
Adresse de base 1
S7
S5
S6
S4
S3
Registre de contrôle
Adresse de base 2
C0
C3
C2
C1
C4
115
Registres données et commande
D0
D0
C0
C0
D1
D1
C1
C1
D2
D2
C2
C2
D3
D3
C3
C3
D4
D4
D5
D5
D6
D6
D7
D7
Registre données
Buffer
Registre commande
Buffer
116
Écriture sur un port

• VOID WRITE_PORT_UCHAR(PUCHAR Port,
  UCHAR Value)
• Parameters
• Port
• 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 Values
• None.

117
Module daffichage 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 lafficheur utilisé
• Nombre de lignes daffichage 2
• Nombre de caractères par ligne 20

118
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

119
Câblage du module LCD sur le port parallèle
Module daffichage LCD
R/W VSS VL VDD
D7 D6 D5 D4 D3 D2 D1 D0
RS
E
VDD
VDD
10 KO
10 KO
VDD
VL à la masse donne le contraste maximum
D7 D6 D5 D4 D3 D2 D1 D0
C0
C3
Port parallèle
9
8
6
7
5
3
4
2
17
1
120
Registres internes du module LCD

• Deux registres internes
• IR registre dinstruction
• 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 lintroduction des données
  dans les registres

121
Séquence décriture dans IR et DR
Repos DRRS1 E0
Repos IRRS0 E0
Donnée ? DR RS1 E?0
Donnée ? IR RS0 E?0
122
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 doù
  commande . . . . 1 x x 1 (RS0 E0)
• Mettre linstruction sur le port parallèle D7-D0
• Écrire cette instruction dans le registre IR
• commande . . . . 1 x x 0 (RS0 E1)
• Retour à létat de repos
• commande . . . . 1 x x 1 (RS0 E0)

123
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 doù
  commande . . . . 0 x x 1 (RS1 E0)
• Mettre la donnée sur le port parallèle D7-D0
• Écrire cette donnée dans le registre DR
• commande . . . . 0 x x 0 (RS1 E1)
• Retour à létat de repos
• commande . . . . 0 x x 1 (RS1 E0)

124
Détail des commandes IR et DR

• Afficheur LCD à deux lignes (C1 inutilisé, à 0 )
• C2 inutilisé, mis à 1
• Repos en prévision dune commande pour IR1101
  0xD CTRL RS0 E0
• Entrée de la commande dans IR1100 0xC
  CTRLEN RS0 E1
• Repos en prévision dune commande pour DR0101
  0x5 DATA RS1 E0
• Entrée de la commande dans DR0100 0x4
  DATAEN  RS1 E1

125
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 dadresse interne
  (AC)
• AC incrémenté à chaque écriture dans DR
• AC initialisé par écriture de linstructionSet
  DDRAM address dans le registre IR

126
LCD à 2 lignes de 20 caractères
DDRAM
0x00
Première ligne
20 caractères
0x13
20 caractères
0x27
Seconde ligne
0x40
20 caractères
0x53
0x54
20 caractères
0x67
127
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

128
Instructions pour le LCD (2)

• Function Set 0x38 ici (001 DL N F 00)
• DL1 Interface 8 bits
• N1 LCD à deux lignes (0 pour une ligne)
• F0 Matrice 5x7
• 0x30 au reset
• Set DDRAM address 0x80 à 0xFF (bit 7 à 1)
  (1AAAAAAA)
• AAAAAAA Adresse sur 7 bits à placer dans le
  compteur AC

129
Initialisation du LCD

• Timing à respecter après la mise sous tension
• Séquence de commande obligatoire de configuration
  du LCD

130
Timing à respecter après Power On
131
Séquence dinitialisation

• RESETInstruction 0x30 (Function Set
  interface 8 bits) envoyée 3 fois
• Display OFF
• Display ON
• Clear Display
• Function Set taille réelle de linterface,
  nombre de lignes et police. (non
  modifiable ensuite)
• Mode Set gestion affichage (décalage texte,
  incrément dadresse mémoire)

132
Exemple denvoi 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.

133
Notion de driver
134
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
  linterface entre le système et le device

135
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
  lexemple présenté suivi du caractère underscore
  et du nom de la fonction réalisée.
• ex PAR_Init

136
Fichier .def

• Sert à décrire un module pour orienter le travail
  de léditeur de liens lors de la création dun
  exécutable .exe ou dune dll
• Fichier à créer en respectant une structure
  particulière
• Structure décrite dans la documentation sous
  lentrée  Module-Definition Files 
• Nous nutiliserons que le paragraphe LIBRARY et
  lentrée EXPORT dans notre fichier .def

137
Fonctions dun driver

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

138
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

139
Driver de gestion du LCD
140
PARA.def
141
Driver (1)

• // include nécessaires
• include "stdafx.h"
• include lttchar.hgt
• include ltnkintr.hgt
• include ltwdm.hgt
• include ltwindev.hgt

142
Driver (2)

• // Définition des IOCTL
• define IOCTL_PUTC \ CTL_CODE(FILE_DEVICE_
  UNKNOWN,2048,\ METHOD_BUFFERED,FILE_ANY_AC
  CESS)
• define IOCTL_CURSEUR \
  CTL_CODE(FILE_DEVICE_UNKNOWN,2049,\
• METHOD_BUFFERED,FILE_ANY_ACCESS)

143
Driver (3)

• // Définition des adresses du port parallèle
• define PARBASE ((PUCHAR) 0x0378)
• define PARDATA PARBASE
• define PARCOMMAND PARBASE2
• // Définition des mots de commande
• define CTRL 0xD
• define CTRLEN 0xC
• define DATA 0x5
• define DATAEN 0x4

144
Driver (4)

• BOOL APIENTRY DllMain(HANDLE hModule,
• DWORD
  ul_reason_for_call,
• LPVOID
  lpReserved)
• return TRUE

145
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 0x30 WRITE_PORT_UCHA
R(PARDATA,0x30) // Function Set 1
WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN) Sleep(2) WR
ITE_PORT_UCHAR(PARCOMMAND,CTRL) Sleep(5)
146
Driver (6)

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

147
Driver (7)

• // Display OFF
• WRITE_PORT_UCHAR(PARDATA,0x08)
• WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN)
• Sleep(2)
• WRITE_PORT_UCHAR(PARCOMMAND,CTRL)
• Sleep(10)
• // Display ON
• WRITE_PORT_UCHAR(PARDATA,0x0F)
• WRITE_PORT_UCHAR(PARCOMMAND,CTRLEN)
• Sleep(2)
• WRITE_PORT_UCHAR(PARCOMMAND,CTRL)
• Sleep(10)

148
Driver (8)

• // Clear Display
• WRITE_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)

149
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 data
• WRITE_PORT_UCHAR(PARCOMMAND,DATA)
• return dwRet

150
Driver (10)

• BOOL PAR_Deinit(DWORD hDeviceContext)
• BOOL bRet TRUE
• return bRet

151
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
152
Driver (12)

• BOOL PAR_IOControl(DWORD hOpenContext,
• DWORD dwCode,
• PBYTE pBufIn,
• DWORD dwLenIn,
• PBYTE pBufOut,
• DWORD dwLenOut,
• PDWORD pdwActualOut)
• int val
• BOOL bRet 1

153
Driver (13)

• switch(dwCode)
• case IOCTL_PUTC
• WRITE_PORT_UCHAR(PARDATA,pBufIn0)
• WRITE_PORT_UCHAR(PARCOMMAND, DATAEN)
• Sleep(2)
• WRITE_PORT_UCHAR(PARCOMMAND,DATA)
• break

154
Driver (14)

• case IOCTL_CURSEUR
• // Positionnement du curseur à définir dans
  lapplication
• val pBufIn0
• // Commande 1xxxxxxx (xxxxxxx 7 bits)
• val val 0x80
• // Mise du port en repos commande
• WRITE_PORT_UCHAR(PARCOMMAND,CTRL)
• Sleep(2)

155
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

156
Driver (16)

• pdwActualOut 1
• return bRet
• // Fin du Driver LCD

157
ApplicationLCD Écriture dun message sur 2
lignes
158
Application (1)

• // include nécessaires
• include "stdafx.h"
• include ltwindev.hgt
• // 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)

159
Application (2)

• int WINAPI WinMain(HINSTANCE hInstance,
• HINSTANCE
  hPrevInstance,
• LPTSTR
  lpCmdLine,
• int nCmdShow)

160
Application (3)

• // Déclarations et réservations
• HANDLE hDevice
• CHAR carac11
• DWORD dwNb
• HANDLE hPara
• CHAR pstring1 " journées académiques"
• CHAR pstring2 "  2005"
• unsigned int i

161
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

162
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

163
Application (6)

• // Envoi première chaîne de caractères
• for(i 0 i ltstrlen(pstring1) i)
• carac10 pstring1i
• DeviceIoControl(hPara,IOCTL_PUTC,carac1,1,
• 
  carac1,1,dwNb,NULL)
• Sleep(10)

164
Application (7)

• // Positionnement du curseur au début de la
  ligne 2
• carac100x40
• DeviceIoControl(hPara,IOCTL_CURSEUR,
• carac1,1,carac1,1,
  dwNb,NULL)
• // Envoi deuxième chaîne
• for(i0iltstrlen(pstring2)i)
• carac10pstring2i
• DeviceIoControl(hPara,IOCTL_PUTC,carac1,1,
• carac1,1,dwNb,NULL)
• Sleep(10)

165
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 lapplication

166
Téléchargement du noyau et de lapplication sur
la cible
Ligne ethernet
Adresse IP de lhôte
Cible CEPC
Carte réseau locale 1
Carte réseau locale 192.168.0.100 Non en
DHCP Pas de DNS
Passerelle vue par défaut
Câble Ethernet croisé
PC hôte
Carte Locale 2 192.168.0.1. Netgear
Port parallèle
Journées Académiques 2005
167
Conclusion
168
Cours disponible

• Version V1.0
• www.esiee.fr/callotj
• www.msdnaa.net/search/advancedsearch.aspx

169
Développements en cours

• Cible Dragon Ball Mx21
• Portage CE5.0
• Applications vidéo
• Réalisation dune maquette pédagogique

170
iMX21
171
Questions