TP1 : Multi-processus - vfork
Mise en situation
Le travail de ce TP se déroule seul.
Temps alloué : 6h
La programmation se fait sur PC sous Windows. Utilisation de la compilation croisée
Carte processeur ColdFire 5272, uCLinux
|
Objectif
C4.6 Assembler les éléments matériels assurant la liaison physique d’un système de Communication
C5.7 Mettre en œuvre un environnement de programmation
Exploiter les commandes console de bases de Linux.
|
Pré requis
Environnement Linux (uCLinux), TP6/7 1er année.
Programmation C, commande de base du Linux
|
Travail demandé
| Suivre le déroulement du TP pas à pas sans sauter d’étapes
|
Critères d’évaluation
| Autonomie, apprentissage d’un nouvel environnement de travail, maîtrise de la commande vfork.
|
But du TP
Utiliser le port parallèle (Port C) d’une carte embarquée avec processeur
Motorolla ColdFire 5272 ayant comme système d’exploitation uCLinux et apprendre les commandes de base console du système d’exploitation Linux pour permettre la supervision du tapis du système Ravoux.
Remarques générales :
- Sur les ColdFire, la mémoire virtuelle n’existe pas
- La carte étant petite, une plateforme matérielle permet l’utilisation facile pour les tests de toutes les E/S (série, parallèle, Ethernet…)
- Pour plus de détails au niveau matériel :
Acturus
- De même un dossier est mis à disposition
Déroulement du TP :
1ère Partie : prise en main de l’environnement de développement
Pour pouvoir écrire un programme en C sur la carte embarquée GoldFire, il faut dans un premier temps installer le compilateur de cette carte sur le PC.
- Nous utiliserons Eclipse pour développer et télécharger le programme.
- Vérifier que le compilateur pour la carte ColdFire est bien installé (CodeSourcery). Le programme m68k-… doit être présent dans
C:/Program Files/CodeSourcery/Sourcery G++/bin
- Vérifier que le PATH dans la variable d’environnement Système Windows est bien présent.
A partir du poste de travail, clic droit propriété/Avancé/Variables d’environnement
Modifier le PATH du bas, C:/Program Files/CodeSourcery/Sourcery G++/bin doit être présent et remplace le chemin du compilateur du poste local (C:MinGWbin).
- Mettre la carte sous tension (le moteur démarre) et connecter la au réseau.
- Ouvrir une console Windows.
- Vérifier la connexion avec la carte et votre poste. Adresse IP des cartes : 10.129.7.N°Carte
- Ouvrir une session telnet sur la carte
- Pas de login
- Mot de passe : uClinux (attention à la caste)
- Ouvrir Eclipse dans votre environnement de travail utilisé pour le TP1
- Créer un nouveau projet (Fichier/new/project/Standard make C project)
- Clic droit projet : new/sourceFile ne pas oublier l’extension .c
- Copier le makefile donné (ou copier/coller) dans votre répertoire de travail du TP.
- Modifier ce makefile pour pouvoir faire le tftp sur votre carte (changer l’adresse IP)
- Ecrire un prg « Bonjour le monde »
- Compiler (clic droit sur projet, Build Project)
- S’il n’y a pas eu d’erreur, dans la fenêtre telnet, aller dans le répertoire /tmp de la carte et lancer l’exécutable (Si le nom n’a pas été modifié : go)
2ème Partie : Utilisation de vfork pour commander le Ravoux
- But : Détecter la présence de pot par les capteurs et commander le tapis
- Avant d’utiliser la carte du Ravoux, utiliser une carte en local et 2 boutons poussoir représentant les 2 capteurs B1 et B2.
- Le programme comportera deux processus :
- Le processus père, créera le fils et attendra une entrée clavier pour « tuer » le fils_capteur.
- Le fils_capteur sera à l’écoute du portC de la carte (revoir les TP7/8 1er année) et détectera la présence par les 2 capteurs B1 et B2 (constante.h donné). Il affichera à l’écran le changement d’état du capteur.
Pour commencer, utiliser une carte autre que celle du Ravoux. Créer vos deux processus qui afficheront respectivement leur présence (printf). Chaque processus est un exécutable (avec son propre main), le processus père créera son fils (vfork) et fera un execl du fichier exécutable. Le plus simple est de faire un projet par exécutable, ne pas oublier de changer le nom de l’exe dans le makefile. Une fois le fils créé, le père se mettra en attente d’un caractère de l’utilisateur (scanf) pour mettre fin à son fils (kill)
Ecrire le filsCapteur, qui sera à l’écoute du portC en boucle infinie.
Ecrire la fonction suivante :
// Retourne l’état de la broche passée en paramètre (ici, B1 ou B2)
int litBroche(volatile unsigned short * adresseData,int numeroBroche);
L’algorithme sera le suivant :
Boucle infinie
Démarre moteur
Tant que pot pas présent en B1
Lire état de B1
Afficher « pot présent en B1 »
Tant que pot pas présent sous la trémie
Lire état de B2
Stopper moteur pendant 5s
Fin boucle
Tester en lisant B1, afficher si changement, lire B2, afficher si changement.
Remarque :
- Liens pour ColdFire
- Les capteurs B1 et B2 sont branchés respectivement sur les broches 0 et 1 du portA de la carte ColdFire.
- Il faut alimenter la partie opérative (câble 0) par du 5V (alimentation externe). Penser à la masse commune (Prise sur le kit).
- Dans un premier temps, on alimente en 5V le moteur M1(Câble 19) et le commun à la masse (câble 20). De même, on alimente en 5V la commande T3 de marche/Arrêt du moteur (le moteur du tapis tournera régulièrement).
Pour les plus rapides :
On commandera le moteur via T3. Quand le pot arrive sur B2, on coupera le moteur M1 pendant 5s avant de le redémarrer. Pour cela, on rebranchera le câble 16 sur le bornier en laissant le moteur sur l'alimentation extérieure. La commande se fera par la broche 13 du port parallèle du portC de la carte ColdFire.
