D. DELFIEU 12 janvier 2011

Cours de Systèmes Temps Réel D. DELFIEU 12 janvier 2011 Département Génie Electrique - GE4

Systèmes Embarqués Temps Réel Ecole Polytechnique de l Université de Nantes -Dept GE 12 janvier 2011

2 / 25

Introduction Premier système temps Réel embarqué Apollo Guidance Computer : système de guidage de l alunisseur des missions Apollo. Aujourdhui Transport : Système de contrôle d assiette (avionique) ; Astronautique : système de guidage d une fusée ; Equipement grand public : Téléphone portable, PC, TV, four à micro-ondes ; Multimédia : console de jeux vidéo, PDA, téléphone portable ; Médical : téléopération médicale. 3 / 25

Caractérisation d un SETR Caractéristiques d un Système Embarqué Temps réel Sureté de fonctionnement : CEM, robustesse, redondance ; Temps d exécution de tâche déterministe ou borné : temps réel ; Consommation énergétique la plus faible possible ; Encombrement minimal ; Espace mémoire limité : qlqs Mo (lié à la consommation et à l encombrement) 4 / 25

Les différents type de Support Carte simple à microprocesseur : 68000, PowerPC, Pentium Pas de problème de consommation, ni d espace ; Applications volumineuses, gourmande en énergie, grande quantité de mémoire ; Commande de radards fixes. Carte à microcontrôleur-dsp : ARM, StrongARM, ST 20, PIC, Coldfire, 68HC12,... ; Téléphone portable ; électroménager. Traitement du signal : DSP (Texas Instrument), carte DSpace Convertisseurs de puissance ; Commande de puissance. 5 / 25

SoC et Rack System On CHIP (SoC) : Hard : Un FPGA ou un CPLD. Composant comportant plusieurs millions de portes Bloc IP implantables sur le composant : CPU ; Interfaces CAN ; Bloc IP ; Timers,... Système Rackable : Pas de Problème de consommation et ni d espace ; Tolérance aux pannes, sureté de fonctionnement. 6 / 25

Les différents types de support matériel Figure: Processeur, Microcontroleur, DSP, FPGA Figure: Rack 7 / 25

Les différents types de Rack Carte PC/104, taille standard : 90,17 x 95,89 mm ; Carte compact PCI ; Carte Europe ; Carte bus VME. 8 / 25

Les racks des TPs Figure: Rack 5U Figure: Rack 3U 9 / 25

Le système vu en TP Rack 3U et 5U ; Alimentation propre ; Carte bab740 : Microprocesseur de type PPC ; 1 carte d E/S ; bus fond de panier VME ; 10 / 25

Le marché de l embarqué 2007 : environ 190 millions de processeurs vendus pour le marché du PC ; 3,85 milliards de micro (essentiellement du 8 bits) pour l embarqué ; 5% du marché des micro pour les PC ; 90 % des micro pour l embarqué utilisent autre chose que Windows. 11 / 25

Le choix d un microcontrôleur Table: Les microcontrôleurs Entités Caractéristiques Avantages Contrôle d E/S Configuration d E/S Accés direct Convertisseurs CAN aux actionneurs aux switch signaux numériques Communication Port SPI, UART pas de périph externes I2C, bus CAN Précision commande Timers et peu de code Struture algo riche boucle, tableaux, Expressif, efficace Interruptions 12 / 25

Le choix d un DSP Table: Data Signal Processor Entités Caractéristiques Avantages Filtres logiciels MAC gain Hard Interfaces Codecs Ports Séries rapides gain Hard Gros débits DMA Moins d attente Accés données programme Architecture Harvard Exécution rapide 13 / 25

Le choix d un Processeur Table: Microprocesseur Besoin Micro/Petit Moyen/Gros Très gros RAM 100ko<x<4Mo 4Mo<x<64Mo Go - To FLASH 100ko<x<4Mo 8Mo<x<16Mo Go - To Proc. Dragon Ball, 68K MIPS Pentium Mcore Hitashi SH PowerPC Coldfire X86 Crusoe ARM Carac. MMU Carte mère PCI,VME,... Appli. PDA, Portable Routeur Comm. tél. Caméra num. Stock. réseaux Serveur central Imprim. réseaux Gros routeur 14 / 25

Aperçu global d un SETR FPGA Mémoire Timer UART Capteurs CAN CPU CNA Actionneurs Ports d'e/s In Interface utilisateur PC Hôte Environnement Exterieur 15 / 25

Définitions SETR Un SETR est un système bouclé multi-tâches dont le temps de réponse est adéquat avec la dynamique de son environnement. Exécutif temps réel Un exécutif temps réel est un système d exploitation minimal ajusté au hardware auquel il est destiné. Seuls les drivers justes nécessaires sont inclus dans l exécutif. De même, seuls les services systèmes nécessaires sont dans l exécutif. 16 / 25

Définitions Caractéristiques d un SETR Ce système multi-tâches est ordonnancé par un exécutif temps réel. Les tâches et l exécutif sont compilées dans le même exécutable appellée : image. Echéances temporelles bornées Un SETR aura un temps de réponse adéquat si la somme du temps d acquisition, de traitement et d application de la commande est inférieure à la période d échantillonage de l information. Pour cela il faut que l exécutif soit déterministe et préemptif. 17 / 25

Notion de tâches Une application de contrôle commande est généralement décomposée en tâches. Tâche Une tâche correspond à une fonctionnalité logicielle et matérielle dont la granularité offre une complexité permettant une implémentation rapide. Exemple : Régulation en courant d une MCC On peut décomposer cette application en trois tâches : Une tâche d acquisition de la consigne ; Une tâche d échantillonnage lecture du courant ; Une tâche de calcul et d application du correcteur ; 18 / 25

Programmation Synchrone La programmation est dite synchrone car les tâches sont lancées de façon synchrone par rapport à des évènements correspondant généralement à des interruptions. Implémentation Programme principal qui initialise les différents périphériques et le timer puis il ne fait rien ; La tâche d acquisition de consigne : durée 30 µs, appelée toutes les secondes ; La tâche d acquisition du courant : durée : 30 µs, appelée toutes les 200 µs ; La tâche de calcul et d application du correcteur : durée : 100 µs, appelée toutes les 200 µs ; La tâche est associée à un sous-programme d interruption. 19 / 25

Déroulement de tâches en Synchrone Lecture Consigne 30!s T Lc = 1 s 30!s Lecture Courant I M 30!s 30!s 30!s 30!s 30!s 30!s 30!s 30!s 30!s 30!s TI M =200!s Calcul Correcteur 100!s 100!s 100!s 100!s 100!s 100!s 100!s 100!s 100!s 100!s T CC =200!s Tâche en traitement Tg=200!s Déroulement de tâches en Programmation Synchrone Figure: Exemple d ordonancement préemptif 20 / 25

Programme Synchrone Programmation SYNCHRONE Programme Principal IT Timer IT Externe SPIT Timer...... IT CAN SPIT IT Externe...... SPIT CAN...... 21 / 25

exemple Voir le code : programmation synchrone.asm Voir le code : exatmega8simple.c 22 / 25

Programmation Synchrone Avantages : La programmation est hyper-efficace car très prôche du hard Structure minimale donc très performante ; Pas de code inutile ; Comportement déterministe ; 23 / 25

24 / 25 Programmation Synchrone Inconvénients : Très peu de possibilité de faire évoluer le système : Si on veut rajouter une tâche : on doit avoir une source d interruption timer supplémentaire ; le temps d exécution de la nouvelle tâche 40µs (la somme des temps d exécution de tâches doit être inférieure à 200 µs); Si cette nouvelle tâche se trouve plus prioritaire, on va devoir faire des modifications sur la partie Hardware. Les coûts de développement sont importants : Le soft de ces systèmes nécessite une maîtrise complète de la partie hardware ; Codage = Assembleur augmnetation des coûts de développements et de maintenance. La lisibilité de l Aassembleur (code très lié au hard), le code n est pas portable.

Langages Synchrones Langages Synchrones : Esterel, Lustre, Statecharts Ce sont des langages à haut niveau d abstraction dont les instructions de bases manipulent des évènements. Ils sont qualifiés de synchrone car ces évènements jouent le rôle de marqueurs temporels. Ils sous-entendent la présence d une horloge d échantillonnage temporel permettant de les synchroniser. 25 / 25 Programmation Synchrone Une programmation est dite synchrone lorsque qu elle est basé sur l utilisation d interruptions attachés aux évènements externes et que l on travaille : Soit avec un OS mono-tâche ou à commutation de tâches (DOS, WIN 3.1 Win 98... XP) Soit sans os : programme assembleur sur un microprocesseur, microcontrôleur ou DSP.

Programmation Asynchrone L application est représentée par un programme principal qui : lance des tâches ; qui attend des comptes rendus d exécution ; Les tâches sont des sous-programmes particuliers détachés du programme principal ; Ces sous-programmes peuvent être implémentés (sous Unix/LINUX) par des processus ou des threads. 26 / 25

Programmation Asynchrone Avantages : la programmation est plus détachée du hard Structure souple ; Ajout ou suppression de tâches simples ; Code lisible (C) ; Code détaché du hard : on communique avec le hard via des drivers ; Maintenance aisée ; Code portable ; Suivant les drivers portés dans le noyau on va pouvoir faire des tâches de très haut niveau : Protocole TCP/IP, telnet, serveur http,... 27 / 25

Programmation Asynchrone Inconvénients : L image intègre un mini système d exploitation (qlqs Mo) en plus de l application ; Un peu moins performant lors des changements de contextes ; Comportement temporel pas forcement déterministe ; Le déterminisme temporel peut être atteint pour un nombre très restreint de tâches de haute priorité. Pour atteindre un même niveau de déterminisme qu en synchrone : il faut un processeur plus puissant donc plus consommateur d énergie électrique. 28 / 25

Déroulement de tâches en Asynchrone Lecture Consigne Lecture Courant Calcul Correcteur Tâche en traitement Election d'une nouvelle tâche à éxecuter Figure: Exemple d ordonancement préemptif 29 / 25

Les états d une tâche Non planifiée Activer Terminer Continuer Terminer Tâche Prête Bloquée Démarrer Arrêter Suspendre Tâche en traitement Suspendre Les Différents états d'une tâche 30 / 25

Les états d un tâche Activer : La tâche entre dans un processus électif : File d attente des tâches Prêtes ; Démarrer : Le tâche en tête de la FA Prête est élue, elle a 100% du CPU ; Arrêter : Le tâche est interrompue, elle a terminée son quantum de temps ; Suspendre : Le tâche a demandé une ressource non encore disponible ou s est endormi elle-même (sleep) ; Continuer : La ressource demandée est maintenant disponible ou le sommeil est terminé, le tâche rentre à nouveau dans la FA Prête. Terminer : Le tâche s arrête définitivement par l appel à exit ou return. Elle peut aussi recevoir un signal de fin émis par une tâche en traitement. 31 / 25

SETR et LINUX Pourquoi LINUX LINUX est dérive d UNIX, un OS fiable du marché ; LINUX est libre : le source est disponible sans royalties à r e v e r s e r ; LINUX est foisonnant : de nombreux contributeurs le font évoluer ; Les versions stables de linux sont FIABLES ; LINUX est entouré d une communauté de développeurs fournissant une aide rapide ; LINUX offre une connectivité IP en standard. 32 / 25

D ou vient LINUX 33 / 25

SETR et LINUX LINUX : sur quel système? Linux est décliné sur un grand nombre d architecture : x86, PowerPC, ARM, MIPS, 68000, Coldfire,... Taille du noyau est modeste 500ko (au minimum) ; différentes distributions sont proposées suivant le domaine : routeur IP, PDA, portable,... Chargement de modules dynamiques : optimisation taille noyau ; Migration aisée de linux à Linux Embarqués. 34 / 25

SETR et LINUX Historique 1991 : la première version de Linux est développé par Linus Torvalds ; 1999 : Présentation à Linux World d un système compact PCI sous linux ; 2000 : Embedded Linux Consortium : centralise des solutions Linux embarqués ; Aujourd hui : solutions propriétaires concurrentes sont VxWorks, psos, QNX ; 35 / 25

SETR et LINUX Monde Libre : RTLinux, RTAI. Solutions propriétaires : VxWorks, psos, QNX. 36 / 25

Processus UNIX Un processus UNIX est une implémentation en langage C de la notion de tâche. Un processus est une entité possédant : Un contexte d exécution : Un ensemble sauvegardé de valeurs des registres du processeur ; une zone mémoire associé au code exécutable ; une zone de mémoire dynamique privé ; une zone pour la pile. Un environnement d exécution : Les fichiers ouverts, sa priorité d exécution, un processus est identifié par un numéro : PID.... 37 / 25

Création d un processus UNIX : fork() La primitive fork() fait partie du paquettage standard stdio.h Duplication quasi-complète du patrimoine du père ; Le fils se distingue par : La valeur retournée par l appel système fork() : 0 pour le fils et le pid du fils chez le pere son PID ; son PPID ; sa zone programme, data et pile ; ses propres descripteurs de fichiers ouverts. 38 / 25

fork() fork() père fils PID PPID Desc. Fichiers Zone de pile Zone de data Zone programme Duplication PID PPID Desc. Fichiers Zone de pile Zone de data Zone programme même programme même valeurs des variables (valeurs d'avant le fork) MAIS ces codes coexistent à une adresse différente et les variables appartiennent à des espaces mémoires différents 39 / 25

40 / 25 exemple main() { int i,pid,res; PID=fork(); if (!PID) { /* Chez le fils */ for(i=0;i<iteration;i++) printf("je suis le fils, iter num %d \n",i); printf("je suis le fils, j ai fini\n"); exit(i); } else { /* chez le pere */ for(i=0;i<iteration;i++) printf("\t Je suis le pere, iter num %d \n",i) res=wait(&cr); printf("\t fils est termine, res= %d \n",res); } }

exemple Voir le code : processus.c 41 / 25

Terminaison d un fils Exit, Wait Un processus fils se termine par la primitive exit qui permet de renvoyer un entier au père. Ce père récupère cet entier par l appel à la procédure wait qui est un appel système bloquant. 42 / 25

exemple Voir le code : processus.c 43 / 25

Les commandes Shell liées aux processus UNIX ps -ac ; a.out & ; kill -9 777 ; chmod 777 a.out time./a.out : La commande time fournit le temps utilisateur, le temps système, et l elapsed time : CPU time = Temps utilisateur + temps système elapsed time : temps réel de l exécution de la commande user time : temps CPU utilisé par le programme utilisateur sys time : temps utilisé par le système pour gérer l exécution du job 44 / 25

Les Threads Posix Posix POSIX définit une norme : IEEE 1003. Cette norme porte sur les interfaces de communication des logiciels : les API. API Une API : Application Programming Interface permet de définir la manière dont on peux utilser un logiciel pu composant informatique. C est donc un ensemble de fonctions typées (décrites dans un *.h) qui indique comment on peut interagir avec le composant. 45 / 25

Les Threads Posix API Les threads implémentent la norme POSIX. Ceux sont des processus légers car ils ont été créés par un processus père avec qui ils partagent avec lui le même espace mémoire. Ils ont les caractéristiques suivantes : Ils peuvent avoir des variables communes (globales) et des variables locales ; Ils partagent les mêmes fichiers et les mêmes ressources ; Ils ont leur propre pile d exécution ; Ils sont ordonnancés ; 46 / 25

exemple Voir le code : API pthread.h 47 / 25

Création d un thread int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *) void *arg); thread : identifiant, descripteur du thread ; attr : attribut de création ; start routine : fonction constituant le corps du thread ; arg : argument de la fonction. 48 / 25

Teminaison et synchronisation d un thread void pthread_exit(void *value_ptr) ; int pthread_join(pthread_t thread, void **value_ptr) ; value ptr : valeur de retour au père. thread : identifiant 49 / 25

exemple Voir le code : thread2.c 50 / 25

Accès aux variables globales Deux processus qui partagent et modifient la même variable globale ont un comportement non déterministe. Non détermisme... res=pthread_create(&l1, NULL, ligne1, NULL); res=pthread_create(&l2, NULL, ligne2, NULL); } // fin du main void *ligne1(void *arg) { while(1) { globale=globale+1; printf("%i\n",globale);} } 51 / 25 void *ligne2(void *arg) { while(1) { globale=globale+10; printf("\t%i\n",globale);} }

La solution : les sémaphores La Solution : Assurer un accès atomique à une variable globale. De plus il faut assurer que l on ne sera pas interrompu entre la modif de la variable et le printf. 1 Eviter une élection par l ordonnanceur dans une région. 2 Eviter toute interruption. 3 Masquer les interruptions en début de région et les démasquer en fin de région 52 / 25

Les sémaphores Definition (Semaphore) Un sémaphore est un object permettant à N processus ou thread (tâche) d accéder à une même région de code. En effet on peut avoir un ressource accessible par un nombre fini de tâche. Pour cela un sémaphore est un objet qui permet les actions suivantes : L initialisation Le processus de réservation : semp Le processus de libération : semv 53 / 25

54 / 25 Les sémaphores Code de SemP : Masquer toutes les ITs; S--; if (S<0) { Tache_courante --> File_Attente(S); reordonnancement(); } Demasquer toutes les ITs; Code de SemV : Masquer toutes les ITs; S++; if (S<=0) { Debloquer(Premier(File_Attente(S))); reordonnancement(); } Demasquer toutes les ITs;

Les sémaphores liés aux threads #include <pthread.h> pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITI pthread_mutex_t errchkmutex = PTHREAD_ERREURCHECK_MUTEX_ int pthread_mutex_init(pthread_mutex_t *mutex, const pth int pthread_mutex_lock(pthread_mutex_t *mutex)); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); int pthread_mutex_destroy(pthread_mutex_t *mutex); 55 / 25

pthread mutex lock pthread mutex lock verrouille le mutex. Si le mutex est déverrouillé, il devient verrouillé et est possédé par le thread appelant et pthread mutex lock rend la main immédiatement. Si le mutex est déjà verrouillé par un autre thread, pthread mutex lock suspend le thread appellant jusqu à ce que le mutex soit déverrouillé. 56 / 25

pthread mutex unlock Celui-ci est supposé verrouillé, et ce par le thread courant en entrant dans pthread mutex unlock. Si le mutex est de type rapide, pthread mutex unlock le réinitialise toujours à l état déverrouillé. S il est de type récursif, son compteur de verrouillage est décrémenté (nombre d opérations pthread mutex lock réalisées sur le mutex par le thread appelant), et déverrouillé seulement quand ce compteur atteint 0. 57 / 25

BOOT Boot Le boot c est l amorçage d un système hardware par un programme appelé bootloader. Le bootloader va chercher sur un périphérique (Disque Dur, Clef USB ou le réseau) le noyau d un système d exploitation qui s installera en mémoire vive et appellera lui-màme des programmes applicatifs. Example Le bootloader d un PC est placé dans le Master Boot Record (MBR). Le MBR est la zone d amoçage d un PC. Elle contient la table des partitions (les 4 partitions primaires) du disque dur et le bootloader dont le but est de charger le système d exploitation. 58 / 25

U-Boot U-Boot U-Boot est un bootloader (logiciel libre), permettant de loader un noyau linux par le réseau (Ethernet). U-Boot implémente le protocole TFTP. U-Boot fonctionne sur des centaines de cartes mère et a été développé pour la très grande majorité des processeurs existant : PowerPC, ARM, XScale, MIPS, Coldfire, NIOS, Microblaze, et x86. TFTP Trivial File Tranfer Protocol : ce protocole permet de faire des transfert de fichiers d une machine à une autre. Il est basé sur l architecture Client Serveur. 59 / 25

Commande de U-Boot : printenv printenv : Cette commande affiche l ensemble des variables de l environnement. => printenv baudrate=9600 bootdelay=5 stdin=serial stdout=serial netmask=255.255.255.0 ipaddr=172.22.64.170 serverip=172.22.64.172 Environment size: 992/16380 bytes => printenv ipaddr netmask ipaddr=172.22.64.170 netmask=255.255.255.0 => 60 / 25

Commande de U-Boot : setenv setenv : Cette commande permet de définir une variable ou de supprimer une variable. usage : => setenv nom valeur permet de definir la variable nom avec valeur => setenv nom permet de supprimer la variable valeur Autre exemple : => setenv cons_opts console=tty0 console=ttys0,${baudrate} => printenv cons_opts cons_opts=console=tty0 console=ttys0,${baudrate} 61 / 25

Commande de U-Boot : saveenv Permet de sauvegarder de façon persistante dans la mémoire flash, toutes les valeurs des variables positionnées par la commande setenv. => saveenv Saving Enviroment to Flash... Writing to Flash... done => 62 / 25

Commande de U-Boot : tftpboot C est la commande la plus importante de U-Boot : boote l image par le réseau suivant les variables définies par setenv. Elle va chercher l image sur $serverip => help tftp tftpboot [loadaddress] [bootfilename] 63 / 25

Architecture On a une carte porteuse IO : proposant 4 emplacements en mezzanine pour des cartes filles ; Cette carte porteuse réalise l interface avec le Bus VME ; 64 / 25

IO Sur les 4 emplacements on a : 1 deux cartes TTL ; 2 une carte 12E816 : carte d entrée Convertisseur analogique-numérique ; 3 une carte 12a4 : carte de sortie Convertisseur numérique-analogique ; 65 / 25

Les Sorties des cartes en mezzanines _TTL 2O ES TTL _12E8/16 12 Entrees Analogiques 16 bits 12A4 4 sorties Analogiques 66 / 25

TTL Les 3 ports A, B et C : PORT C PORT A PORT B Vcc/Gnd 67 / 25

TTL Cette carte sur un bus VME via une interface de type MODULbus+ propose 2 ports 8 bits et un port 4 bits. 20 entreées-sorties TTL optocouplées ; Les 3 ports sont configurables en entrée ou en sortie. Chaque bit du port peut fournir un courant max de 48 ma il est de type collecteur ouvert ; A chaque port doit àtre alimenté. Fonction secondaire timer (Zilog Z 8536) sur les ports B et C. 68 / 25

Ce timer contient 3 compteurs 16 bits identiques qui peuvent, entre autre, fonctionner dans les modes suivant : Pulse : une impulsion one shot : une forme reproductible une fois, square wave mode : signal carré périodique. 69 / 25

Ces trois compteurs sont des fonctions secondaires des ports A, B, C : Fonction T 1 T 2 T 3 Sortie B4 B0 C 0 Entree.Compt. B5 B1 C 1 Trigger B6 B2 C 2 Gate B7 B3 C3 70 / 25

Les registres importants Le registre MCCR : Master Configuration Control Register Les registres Counter Timer Mode Specification Register : CTMSR 1, CTMSR 2etCTMSR 3 ou CTMSR. Ils servent à spécifier les modes. Les registres Counter Timer Time Constant Register : CTTCRH 1,CTTCRL 1,CTTCRH 2CTTCRL 2 ou CTTCR Ils correspondent aux constantes de temps des timer 1 et 2 ; Les registres Counter Timer Command Status Register CTCSR 1, CTCSR 2etCTMSR 3 ou CTCSR ils permettent de déclencher les démarrages et de contrôler les ITs. 71 / 25

72 / 25 MCCR Registre de Contrôle et de Configuration MaÓtre : D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 D 7 : autorisation de fonctionnement du Port B D 6 : autorisation de fonctionnement du CompteurTimer 1 D 5 : autorisation de fonctionnement du CompteurTimer 2 D 4 : autorisation de fonctionnement du Port C D 3 : Contrôle de liaison des Ports D 2 : autorisation de fonctionnement du Port A D 1 et D 0 : contrôle de liaison des Countertimer 0 0 : Les Timer 1 et 2 sont independant 0 1 : La sortie timer 1 autorise le fonctionnement du Timer 2 10:Lasortietimer1déclencheleTimer2 1 1 : La sortie timer 1 sert de compteur d entrée du

73 / 25 CTMSR Spécifie les Modes des Compteurs D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 D 7 : Cycle continu ou non (pulse unique) D 6 : Autorisation Externe de Sortie D 5 : Autorisation Externe de Comptage D 4 : Autorisation Externe de déclenchement D 3 : Autorisation Externe de fonctionnement D 2 : Autorisation de Re-déclenchement (Int. Ext.) D 1 etd 0 Sélection de rapport Cyclique 00:Sortiepulse 01:Sortied unseulpulse 10: Sortie en signal carré périodique 1 1 : Non utilisé

Le Mode : one pulse Horloge Trigger Gate Gel de N Sortie Mode Pulse N N-1 N-1 N-2... 1 0 Décomptage de N 74 / 25

Le Mode : One Shot Horloge Trigger Gate Gel de N N N-1 N-1 N-2... 1 0 Décomptage de N Sortie One Shot 1 pulse Largeur = N * périodes d'horloge 75 / 25

Le Mode Square Wave Horloge Trigger Gate N N-1 N-2... 1 0 N N-1 N-2... 1 0 Décomptage de N Sortie Square Wave 1 pulse Largeur = 2*N * périodes d'horloge 76 / 25

CTTTCR Les registres de comptage CTTCRH 1, CTTCRL 1, CTTCRHL 2, CTTCRL 2 La lettre H (High) identifie le registre stockant le poids fort. La lettre L (Low) correspond au poids faible. Exemple Soit la valeur 767 10 à positionner dans le registre de comptage correspondant à une largeur de pulse désirée. 767 10 =0x02FF 16 mttl write reg(fd, CTTCRH 1, 0x02); mttl write reg(fd, CTTCRL 1, 0xff ); 77 / 25

CTCSR Permet la commande, donne l état des Compteurs D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 D 7 : Une interruption est en cours D 6 : Autorisation de l interruption Timer D 5 : Une interruption est en attente de service D 4 : Erreur d interruption (lecture seule) D 3 : Lecture valeur courante comptage D 2 : Commande du fonctionnement D 1 : Commande de déclenchement (écrit. seule) D 0 : Indicateur comptage en cours (lect. seule) 78 / 25

CTCSR : exemple Exemple On désire un mode carré périodique ; Bit de fonctionnement et déclenchement à un ; D 7 est un drapeau, on n y touche pas. D 6 à zéro, on ne fonctionne pas en it. D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 0 0 0 0 0 1 1 0 mttl write reg(fd, CTCSR 1, 0x06); 79 / 25

On va chaîner la sortie du timer 1 à l entrée du timer 2. Un front montant du timer 1 aura pour objet de déclencher le timer 2 qui déterminera le rapport cyclique comme cela est indiqué sur la figure suivante : Horloge Registre de préchargement =0x0004 Rechargement Timer 1 Valeur timer 4 3 2 1 4 3 2 1 4 3 2 1 4 Registre de préchargement =0x0006 Rechargement Timer 2 Valeur timer 6 5 4 3 2 1 0 0 6 5 4 3 2 1 0 80 / 25

Drivers Driver Un Driver (module) est un programme écrit généralement en Assembleur permettant de lire et d écrire sur un périphérique ou de réaliser des actions appellées services. Un module fournit des services ou utilise des services d autres modules. Le cas des drivers linux : Statique : Les modules sont rajoutés dans la partie File System et compilé avec le noyau. Il sera présent même si le périphérique n est plus utilisable Dynamique : On alors un module chargeable, les modules/drivers ne sont chargés QUE lorsque un programme en a besoin. 81 / 25

Drivers Il existe différents types de pilotes suivant le périphérique à contrôler : les pilotes en mode caractère Ex : ports séries et parallèles les pilotes en mode bloc Ex : Disque dur. les pilotes réseaux 82 / 25

Driver caractère Avec ce matériel de TP, on n utilisera que des pilotes en mode caractère. Ces pilotes sont accessibles à travers des fichiers spéciaux appelés également noeuds (nodes). Ces fichiers sont localisés sur le répertoire /dev et sont caractérisés par deux valeurs numériques : Le MAJEUR (MAJOR) qui identifie le pilote Le MINEUR (MINOR) qui représente une sous-adresse en cas de présence de plusieurs périphériques identiques, contrôlés par un même pilote. 83 / 25

Installation de Drivers Le fichier /etc/rc.sysinit permet de réaliser des installations des drivers/modules spécifiques. La commande depmod a : Elle établit la liste des dépendances de modules en lisant pour tous les modules les services exportés ou importés. La commande insmod programme simple permettant d insérer un module dans le noyau sans s occuper de dépendances éventuellement non satisfaites. La commande modprobe programme simple permettant d insérer un module dans le noyau. modprobe charge un module et les modules qui en dépendent. rmmod décharge un module 84 / 25

Drivers de nos cartes d ES #depmod a #insmod copy universe #modprobe universe #modprobe vme mod log =4level =3 #modprobe modvme #modprobe vmodat0 85 / 25

Installation du driver de la MTTL #modprobe mttl.o io = 62, 0, 0, 0x3000a800, 0xa0, 0xd 62 : major number : celui de la carte MTTL 0:num.carteIO sur bus VME [0, 15] 0:minornumberemplacementdeMTTL sur IO [0, 3] 0x3000a800 adr physique carte IO sur bus VME 0xa0 :adresseduvecteurd IT 0x0d : 0000 1101 1101 : 1 : Opto, 1 : C en sortie, 0 : B en entrée, 1 : A en sortie 86 / 25

Drivers de nos cartes d ES Installation des deux cartes TTL : #insmod mttl vio=62, 0, 0, 0x3000a800, 0xa0, 0xd 62, 0, 0, 0x3000a800, 0xa0, 0xd 87 / 25

Exemple simple de Driver Linux Ecriture du driver hello.c : #include <linux/module.h> #include <linux/kernel.h> int init_module(void) { printk("driver chargé n"); return 0; } void cleanup_module(void) { printk("driver déchargé \n"); } 88 / 25

Compilation et utilisation de Driver Linux Ce code constitue la base d un module chargeable. Si on le compile par : $gcc -Wall -c hello.c -o hello.o -D KERNEL -I /usr/include/linux/ -O2 on pourra insérer dynamiquement le module par la commande insmod : $insmod hello.o Ce qui provoque le chargement du module (voir lsmod) et l apparition du message dans les traces du noyau. 89 / 25

Compilation et utilisation de Driver Linux Chargement du module : [exemple]# lsmod Module Size Used by hello 184 0 (unused) 3c509 5972 1 (autoclean) vfat 9116 0 (unused) fat 30048 0 [vfat] [exemple]# dmesg tail -1 Module chargé De même si on décharge le module par rmmod on obtient : [exemple]# rmmod hello S [exemple]# dmesg tail -1 Module déchargé 90 / 25

SETR et la connectivité IP Connectivité IP La connectivité IP permet de raccorder tout système électronique au réseau internet. Elle met en oeuvre une suite de protocole que l on doit embarquer sur le système. Avantages : Contrôler à distance les SETR ; usage d interfaces graphiques modernes et banalisées : navigateur web ; Evolution du télécontrôle : RS232 et terminal VT 100. 91 / 25

Le protocole IP Protocole IP Protocole basé sur le modèle OSI à 7 couches. Modèles OSI Ensemble de couches. Une couche crée un niveau d abstraction en raffinant un service de base pour donner des services plus élaborés au niveau supérieur. 92 / 25

Les 7 couches du modèle OSI 1 Couche physique : transmettre des bits ; 2 Couche liaison : transmettre des trames, détection et correction d erreurs ; 3 Couche réseau : routage et acheminement des données, constitutions de paquets de trames, gestion de la congestion du réseau ; 4 Couche Transport : gestion du dialogue entre 2 noeuds (sockets, pipe,...), mode connecté (TCP) ou non (UDP). 5 Couche session : structuration du dialogue (client-serveur) ; 6 Couche représentation : représentation des données format, compression, cryptage,... 7 Couche Application : Interface shell, webmail, firefox,... 93 / 25

Le réseau Internet : 4 couches 1 Couche médium : transmettre des trames de bits (couche 1 et 2) : Ethernet, GSM, Courant porteur,... 2 Couche IP : routage et Acheminement des données (couche 3) 3 Couche TCP (ou UDP) : gestion du dialogue entre 2 noeuds mode connecté (TCP) ou non (UDP) (couche 4) ; 4 Couche Application : de structuration du dialogue jusqu a l interface (couche 5,6,7). 94 / 25

Architecture Internet Client FTP Protocole ftp Serveur FTP TCP Protocole TCP TCP IP Protocole IP IP Médium Médium trames propres au médium 95 / 25 Figure: Réseaux 4 couches

Adressage 1 Chaque ordinateur ou système embarqué est repéré par une adresse IP unique sur 32 bist. 2 Notation décimale : 172.22.64.173 : 4 octets (255 x 0) 3 ADRESSE IP : id réseau + id machine 4 1octet:idRéseau 5 dernier octet : 255 broadcast, 1 : Gateway 96 / 25

Protocole IP 1 version IPv4 : 4 bits d entête 2 8bits:priorité,préférencessurlaqualité 3 2 octets : Longueur totale 4 4 octets : identification, drapeaux,.. 5 1 octet durée de vie : nombre de routeurs traversés 6 1 octet de protocole : 6 - TCP, 17 UDP,... 7 header checksum 8 20 octets maximum pour le message 9 adresse IP source et destination 10 options 97 / 25

Protocole TCP et UDP 1 Utilise IP comme service réseau 2 TCP procure un service de transport en mode connecté sécurisé (demande de ré-emission si echec) Connexion par handshake ; Transfert de données ; acquitement ; fermeture des connexions ; exemple : chat, telnet, ftp 3 UDP procure un service de transport en mode non connecté et non sécurisé. Adresse materielle de la machine appellée adresse IP numéro du port exemple : mail 98 / 25

L API Socket LES SOCKETS IMPLEMENTENT LES PROTOCOLES TCP ET UDP 1 Elles permettent d échanger des octets entre une application cliente et une application serveur. 2 Les données passent en clair dans le réseau. 3 SSL : est une nouvelle API basée sur les sockets pour échanger des données sécurisées. 99 / 25

Applications telnet et rlogin Elles utilisent TCP 1 telnet est une appli client/serveur en mode connecté. 2 rlogin ne fonctionne qu entre 2 machine UNIX. telnet est faisable sous windows 3 Un daemon serveur doit tourner sur la machine appellée. 100 / 25

Applications NFS 1 Permet de rendre transparente l utilisation de fichiers répartis sur différentes machines. 2 NFS utilise UDP, les nouvelles versions utilisent TCP. 3 Est particulièrement utile pour les SETR diskless 101 / 25

NFS NFS (Network File System) permet de partager des fichiers entre ordinateurs sous un environnement Linux et/ou Unix (des implémentations existent pour Macintosh et MS Windows). Il existe plusieurs version de NFS : NSF 1 et 2 son obsolètes et NFS 3 : Non sécurisé et NFS 4. Usage : Partage d un répertoire (projet). Basée sur la notion de point de montage 102 / 25

Point de Montage En linux tout est fichier ou répertoire (Noeud). Point de montage Sous linux : Un disque dur, un lecteur de CDROM ou une clef USB correspondent à un répertoire. Ces éléments physiques doivent être montés et démontés après usage. Le montage correspond à la création d un lien entre l élément physique et le répertoire. mount t iso9660 /dev/cdrom/media/cdrom umount /media/cdrom 103 / 25

Montage NFS C est un système client serveur. Principe Le client importe des fichiers. Le serveur exporte ses fichiers. Installation sur le serveur : Dans /etc/exports /public (rw, no root squash, sync) #exportfs a #/etc/init.d/nfs kernel server restart Le Client : mount t nfs 172.22.64.175 : /public /mnt o nolock umount/mnt 104 / 25

Applications ftp 1 Permet de faire des transfert de fichiers ; 2 nécessite une connexion par login et mot de passe. 3 il existe des serveurs anonymous, le mot de passe est alors son email. ftp 172.22.64.173 login passwd put file mget file.* bye 105 / 25

Applications http 1 Protocole de communicatoin et d échange de documents sur le web 2 Est écrit en utilisant l API SOCKET 3 Tous les navigateurs sont des applications client/serveur basé sur l API Socket. 106 / 25

Applications http 1 Protocole de communicatoin et d échange de documents sur le web 2 Est écrit en utilisant l API SOCKET 3 Tous les navigateurs sont des applications client/serveur basé sur l API Socket. 107 / 25

Travaux Dirigés SETR Polytech Nantes, GE4-1h30 On cherche à programmer de façon simplifiée le fonctionnement d une usine (voir l illustration) réalisant un mélange de 2 produits C et S. Le produit final B sera obtenu en suivant les phases suivantes : Approvisionner BAC 1 et BAC 2 avec les produit S et C en agissant sur les vannes VA 1 et VA 2 de façon à maintenir constamment les niveaux dans chacun des bacs autours d un niveau moyen fixé. Lorsque les niveaux de BAC 1 et BAC 2 oscillent autour de leur valeur moyenne, BAC 3 est approvisionné avec un mélange composé de C et S composé de 16 kg de S et 8kg de C, en agissant sur les vannes de vidages VD 1 et VD 2. Pendant cet approvisionnement la vanne VD 3 est fermée. BAC 3 est alors vidé de 15 kg dans une autre bac (non modélisé dans l exercice) par la vanne VD 3 et le cycle recommence. S VA 1 VA 2 C N 1 N 2 n 1 BAC 1 BAC 2 n 2 VD 1 VD 2 BAC 3 P M VD 3 Figure 1 Illustration D autres part pour modéliser le problème, les entrés-sorties auront les caractéristiques suivantes : Les vannes VA 1,VA 2,VD 1,VD 2,VD 3 peuvent êtres ouvertes ou fermées par les procédures ouvrir avec comme paramètre le nom de la vanne : ouvrir(vd 1 ) ; fermer(vd 2 ); On peux se mettre en attente des signaux N 1,n 1,N 2,n 2,P,M par la procédure atit : atit(p) ; N 1 (resp N 2 ) signale que le niveau max du bac 1 est atteint, n 1 (resp n 2 ) signale que le niveau min du bac 1 est atteint. 1

Le poids du mélange dans BAC 3 est mesuré par un capteur qui délivre le signal P à chaque fois que le mélange augmente de 100g et M à chaque fois que le mélange atteint diminue de 100g. 1 Modélisation préliminaire Initialement tous les bacs sont vides, les vannes sont fermées. On demande proposer une programmation progressive de cette application : Modéliser le fonctionnement des tâches BAC 1, BAC 2, BAC 3 en utilisant une structure d algorithme en utilisant les appels : ouvrir(v ), fermer(v ) atit(s 1 ) L attente (de type l un ou l autre ) de deux signaux S 1 et S 2 : atit(s 1 S 2 ), L attente (de type l un et l autre ) de deux signaux S 1 et S 2 : atit(s 1 &&S 2 ), les primitives : Boucle, F in Boucle T ant Que, F in T ant Que Si Alors... Sinon... F in Si,... 2 Codage Vous coderez cette modélisation en suivant les consignes suivantes : Les actions de fermeture et d ouverture de vannes seront modélisées par un printf : printf("\n\t\t\t\t\t\touverturevannevidange2"); Les attentes de signaux de capteurs modélisées par la procédure atit(n 1 ) seront modélisées par la mise en sommeil du processus (sleep) ; on utilisera les déclarations globales : pthread_t B1,B2,B3; int N1, n1, N2, n2, P, M; La tâche sera d abord défini par : void *BAC3(void){... } Le main va ensuite créer et lancer ces 3 thread qui géreront les 3 bacs par l instruction : pthread_create(&b3,null, BAC3, NULL); Puis le main agira comme générateur de signaux sur les capteurs avec la structure while(1) { printf("\ntapez1->n1,2->n1,3->n2"); printf("4->n2,5->p,m->6:"); fflush(stdin);scanf("%i",&i); switch(i) { case 1 : N1=1; n1=0; printf("\n->n1");break;... 2

3 Solution 3.1 Première partie T^ache BAC1 Ouvrir(VA1); atit(n1); Boucle fermer(va1); atit(n1); ouvrir(va1); atit(n1); Fin boucle; fin BAC1; T^ache BAC2 Ouvrir(VA2); atit(n2); Boucle fermer(va2); atit(n2); ouvrir(va2); atit(n2); Fin boucle; Fin BAC2; T^ache BAC3 atit(n1 && N2); ouvrir(vd1); poids=0; Boucle Tant Que (poids < 160) Faire atit(p);poids++; Fin Tant Que; fermer(vd1); ouvrir(vd2); poids=0; Tant Que (poids < 80) Faire atit(p); poids++; Fin Tant Que; fermer(vd2);ouvrir(vd3); poids=0; Tant Que (poids < 150) Faire atit(m); poids++; Fin Tant Que; fermer(vd3); PA=PA-100;PB=PB-50; Fin Boucle Fin BAC3; 3.2 Codage #include #include pthread_t <stdio.h> <pthread.h> B1,B2,B3; int N1, n1, N2, n2, P, M, CH; void *BAC1(void){ int j=0; 3

} printf("\n\t\touverturevanne1"); while (N1==0) sleep(1); while(1) { printf("\n\t\t\t\tfermeturevanne1"); while (n1==0) sleep(1); printf("\n\t\t\t\touverturevanne1"); while (N1==0) sleep(1); } void *BAC2(void){ int j=0; printf("\n\t\t\t\touverturevanne2"); while (N2==0) sleep(1); while(1) { printf("\n\t\t\t\tfermeturevanne2"); while (n2==0) sleep(1); printf("\n\t\t\t\touverturevanne2"); while (N2==0) sleep(1); } } void *BAC3(void){ int j,poids, PS=0,PC=0; while ((N1!=1) && (N2!=1)) sleep(1); while(1) { poids=0; //Dosage BAC1 printf("\n\t\t\t\t\t\touverturevannevidange1"); while(1){ while (poids <160) { while(p==0) sleep(1); PS++;P=0; } printf("\n\t\t\t\t\t\tfermeturevannevidange1"); //Dosage BAC2 printf("\n\t\t\t\t\t\touverturevannevidange2"); poids=0; while (poids <80) { while(p==0) sleep(1); PC++;P=0; } printf("\n\t\t\t\t\t\tfermeturevannevidange2"); //Dosage MELANGE printf("\n\t\t\t\t\t\touverturevannevidange3"); poids=0; while (poids <150){ while(m==0) sleep(1); poids++;m=0; } printf("\n\t\t\t\t\t\tfermeturevannevidange3"); 4

} PS=PS-100;PC=PC-50; } int main(){ int i,j ; N1=0;n1=1;N2=0;n2=1;P=0;M=0;CH=0; pthread_create(&b1,null, BAC1, NULL); pthread_create(&b2,null, BAC2, NULL); pthread_create(&b3,null, BAC3, NULL); while(1) { printf("\ntapez1->n1,2->n1,3->n2"); printf("4->n2,5->p,m->6:"); fflush(stdin);scanf("%i",&i);usleep(1); switch(i) { case 1 : N1=1; n1=0; printf("\nniveaun1");break; case 2 : n1=1; N1=0; printf("\nniveaun1");break; case 3 : N2=1; n2=0; printf("\nniveaun2");break; case 4 : n2=1; N2=0; printf("\nniveaun2");break; case 5 : P=1; printf("\npesage:+1kg");break; case 6 : M=1; printf("\npesage:-1kg");break; default : break; } } return (1); } 5

TP SETR 1 : Commande de moteur pas à pas Polytech Nantes - Dept GE. Février 2008 1 Introduction Le but de ce TP sera l implémentation d une application temps réel embarquée multithreadée avec Entrés-Sorties de type TTL. 2 Commande de Moteur Pas à Pas 2.1 Préambule Télécharger les fichiers "squelette.c" et "compil" sur madoc. Connectique : Brancher PA 0,PA 1,PA 2,PA 3 sur les 4 bobines du MPP et PB 0 sur l optocoupleur. Connectez l alimentation (5V ) sur le MPP ainsi que sur les ports A et B utilisés de la carte d ES. Connectez la masse du MPP et de la carte d ES. Ouvrir un terminal. En créant 2 onglets vous en obtenez 3 avec l onglet de départ - changer leur titre : compil, ftp et telnet. Onaalors 3onglets: Onglet compil : $PATH=$PATH:. // instruction nécessaire une fois lors de la création du shell $chmod 777 compil $compil monfichier // sans l extention. L onglet ftp sert à envoyer votre exécutable sur la cible : $ftp 172.22.64.17* login : taper root > put monfichier 172.22.64.17 est l adresse IP de votre cible. Onglet telnet : $telnet 172.22.64.17* login : taper root puis la barre espace $PATH=$PATH:. // instruction nécessaire une fois lors de la création du shell $chmod 777 monfichier $monfichier 2.2 Ennoncé 1. Ecrire un programme permettant de faire clignoter la led numéro zéro toutes les secondes. 2. Ecrire un programme qui interroge l utilisateur sur le nombre de tour et son mode (pas entier ou demi-pas), puis fait tourner le moteur. 1

3. Ecrire un programme multithreadé. Le père effectue initialement une saisie de consigne : Le père demande la vitesse, le sens, le mode (pas entier ou demi-pas) et le nombre de tours. Le fils fait la commande du moteur. Pendant l exécution de son fils le père pourra changer la vitesse de rotation du moteur. 4. Ecrire un thread permettant une fonction de lecture de la valeur de l optocoupleur et l affichage de la vitesse angulaire gr ce aux fonctions de manipulation du temps données en annexes. Attention : Le passage du trou devant l optocoupleur est mémorisé dans une bascule D qui doit être remise à zéro par un niveau haut sur la patte RST de la carte moteur après la lecture de la bascule. De plus, cette patte doit être au repos (niveau 5V, car les sorties fonctionnent en logique négative) pendant la commande du MPP. Enfin, il faudra maintenir l ordre de raz de cette bascule pendant une tempo de 1 ms. 3 Compte rendu Dans votre code, pour chaque sous-programme vous donnerez les informations en commentaires suivant : /*-------------------------------------------------------------- Fonction : nom de la fonction et des paramètres avec leur types ; Entrées : Paramètres en entrée de la fonction ; Sorties : paramètres modifiés ou de sortie ; Variables globales utilisées ; Sous-programmes appelés ; Fonctionnement : description rapide/sommaire du fonctionnement. ---------------------------------------------------------------*/ Dans votre compte-rendu vous préciserez comment vous avez testé votre code (résultats visuels, mesures à l oscilloscope) et vous donnerez quand cela est possible des extraits quantitatifs de résultat d exécution. 4 Annexe 4.1 Manipulation du temps Les instructions suivantes permettent de gérer l écoulement du temps. On utilise deux variables depart et fin de type struct timeval. Pour connaître la durée écoulée entre deux moments (instructions) on initialise ces variables entre ces 2 moments et on fait la différence. struct timeval depart, fin; struct timezone tz; long duree=0; gettimeofday(&depart, &tz); gettimeofday(&fin, &tz); /* temps execution du thread */ duree=fin.tv_sec-depart.tv_sec; 2

TP SETR 2 Identification des paramêtres d une Machine à Courant Continue D. Delfieu 10 février 2010 1 Introduction Le but de ces TP sera d instrumenter un moteur à courant continu. Pour cela, vous aurez à réaliser deux fonctions : Envoyer un signal de commande au moteur, en utilisant les timers/compteurs de la carte MTTL. Mesurer périodiquement le courant induit du moteur et afficher sa valeur à l écran, en utilisant la carte de conversion analogique numérique 12E16, 2 La On va utiliser le timer Zilog 8536 pour générer une. On va utliser un timer pour définir la fréquence de base et un timer pour définir le rappport cyclique. Pour cela on utilisera la fonction suivante : mttl write reg(descripteur carte MTTL, nom du registre, valeur initialisation); Exemple : mttl write reg(fd,mccr,0x00e2); 2.1 Chaînage de timers On va chaîner de façon logicielle la sortie du timer 1 (visible la patte B 4 )àl entréedutimer 2 (visible sur la patte B 0 ). Un front montant du timer 1 aura pour objet de déclencher le timer 2 qui déterminera le rapport cyclique comme cela est indiqué sur la figure suivante 1 : Horloge Sortie T1 Trigger Sortie T2 Figure 1 Chronogramme du chaînage 1

2.2 Les timer 1 et 2 On créera un sous-programme d initialisation appellé depuis le main, pour une valeur de periode et une valeur de data définies de façon constante : Timer 1 : 1. Générer un forme périodique (par rapport à la valeur de la variable periode) qui fait apparaître un front montant sur la sortie PB 4 du timer 1. 2. Visualiser cette sortie à l oscilloscope. Timer 2 : 1. Générer un mode permettant au timer 2 d être déclenché par la sortie du timer 1. Ce timer proposera de façon continuement périodique (valeur periode) un pulse de longueur variable (définie par la variable data). 2. Visualiser cette sortie à l oscilloscope. Pour récupérer le poids fort (MSB) et le poids faible (LSB) d une variable periode nombre vous pourrez utiliser les instructions suivantes : int periode=1000,msb=0, LSB=0; MSB=(periode>>8)&0x00FF; LSB=periode&0x00FF; Le programme principal : En tenant compte des valeurs pour les registres évoqués, que nous venont de déterminer, écrire une fonction InitPwm(int periode) permettant d initialiser une avec une période définie par la variable periode et dont le rapport cyclique (longueur du niveau haut) sera défini par une variable globale de type int s appellant data. Vous rajouterez les include suivant : #include "/opt/elinos_30_ppc_basic_rtai/elinos_janz/janz/mttl/h/cio8536.h" #include "/opt/elinos_30_ppc_basic_rtai/elinos_janz/janz/m12e16/h/m12e16.h" 2.3 multithread Écrire un main qui crééra deux threads : Un thread contrôlera la variable data en incrémentant tous les 100 µ-secondes la variable par un incrément définie par P AS (#define PAS 3 par exemple). Si cette variable atteint la valeur de periode, alors le thread décrémentera (de la valeur P AS) cette fois, la valeur de data. L autre thread met à jour les registres de constantes (tous les 100 µ-secondes) de temps affectant le timer 2 définissant ainsi un nouveau rapport cyclique. le père des threads contrôle la fin de toute l application en proposant à l utilisateur de taper q pour quitter, ce qui forcera, dans un premier temps la fin des 2 threads, puis la fin du père. 3 Lecture du courant Rajouter dans votre main 1. Pour le CAN déclarer en global char bin[20] = /dev/m12e16 02, de manière analogue à la carte MTTL, on rajoutera du code pour permettre aussi l ouverture du périphérique de lecture analogique. 2. A l aide de la documentation fourni par les enseignants, expliquer dans votre compte rendu les significations des modes : SINGLE ENDED et DIF F ERENT IAL 3. Initialiser la lecture du CAN avec le mode SINGLE ENDED par une fonction que vous trouverez en inspectant le fichier m12e16.h (cf chemin indiqué dans l include), trouver aussi comment positionner un gain de 1 (c.a.d. pas de gain) pour le canal 0. 2

3.1 Fonction de lecture Ecrire un thread permettant la lecture du courant par la fonction : vlue=m12e16_read_channel(fdcan,0); Dans cette fonction, on a le résultat de la valeur dans vlue. Etant donnée que : Le converisseur fonctionne dans une plage de 10, +10 volts 10 volts correspond à 2047. 0v correspond à 1024 Trouver la transformation permettant d afficher la valeur de tension fournie par le pottard du moteur pas à pas qui délivre une tension entr 0 et 5v. 3.2 Lecture du courant d induit de la MCC Coupler à l aide de threads, la commande de la MLI pour commander la MCC et la lecture du courant filtré. Faire les branchements. Annexes 3.3 Les registres du timer ZCIO8536 Ce timer est implanté sur la carte MTTL. Il partage donc les ports A, B et C dela carte MTTL. A et B sont 2 port de 8 bits bufferisés et C est un port bidirectionnel de 4 bits. Ce timer contient 3 compteurs qui peut, entre autre, fonctionner dans les modes suivant : Pulse : une impulsion, one shot : une forme reproductible une fois, square wave mode : signal carré périodique. Les registres important Le registre MCCR : Master Configuration Control Register. Les bits du MCCR sont : D 7 : Port B enable D 6 : CounterT imer 1 enable D 5 : CounterT imer 2 enable D 4 : Port C enable D 3 : Port Link Control D 2 : Port A enable D 1 etd 0 : Countertimer link Control 0 0 : Timer 1 and are independent 01:T imer soutput 1 GATEs Timer 2 D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 10:T imer soutput 1 TRIGGERs Timer 2 11:T imer soutput 1 acts as Count Input of Timer 2 Les registres CTMSR 1, CTMSR 2 et CTMSR 3 ou CTMSR signifie :Counter Timer Mode Specification Register ont la structure de bit suivante : D 7 : Continuous SingleCycle D 6 : External Output Enable D 5 : External Count Enable D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 3

D 4 : External Trigger Enable D 3 : External Gate Enable D 2 : Retrrigger GateEnable D 1 etd 0 : OutputDutyCycleSelect 00:PulseOutput 0 1 : One shot output 1 0 : Square wave mode Otput 1 1 : Not specified Les registres CTTCRH 1,CTTCRL 1,CTTCRH 2CTTCRL 2 ou CTTCR signifie Counter Timer Time Constant Register. Ils correspondent aux constantes de temps des timer 1 et 2. La lettre H (High) identifie le registre stockant le poids fort. La lettre L (Low) correspond au poids faible. Les registres CTCSR 1, CTCSR 2 et CTMSR 3 ou CTCSR signifie Counter Timer Command Status Register ont la structure de bits suivante : D 7 : Interrupt Under Service D 6 : InterruptEnable D 5 : InterruptPending D 4 : Interrupt Error (Read Only Bit) D 7 D 6 D 5 D 4 D 3 D 2 D 1 D 0 D 3 : Read Counter Control (Read Set Only Bit - Cleared by reading LSB) D 2 : Gate Command Bit D 1 : T rigger Command Bit (Write Only Bit) D 0 : Count in Progress(read only) 4