Enoncé
Nom: Prénom:
Activité pratique Barrière automatique :
Réguler l'accès à un parking grâce à une barrière automatique
Problématique :
Une société de gardiennage souhaite équipé son garage souterrain d'une barrière automatique. Cela permettrait une meilleure fluidité de passage des véhicules et une meilleur traçabilité des entrées /sorties.
Le rendu se fait sur copie avec
Encarts présentation
+
numéro de questions (même si non traité)
1 - Organisation fonctionnelle de la chaîne d'information
L'automobiliste, lorsqu'il arrive dans le parking souterrain, récupère un ticket de parking. La barrière s'ouvre. En fonction du temps passé dans le parking, il s'acquitte du règlement et regagne sa voiture. Il badge à nouveau pour sortir.
Nous allons travailler sur la maquette qui simule le fonctionnement du système dans un sens. La partie gestion de carte d’accès ne fait pas partie de l'étude. On simulera celle-ci par l'appui sur un bouton situé sur la maquette.
Algorithmes (2h)
Etape 1 : Test des boutons et fin de course
On souhaite ouvrir la barrière avec un appui simple sur le bouton poussoir.
Question 1 : Compléter la condition A et l’action B de l’algorithme suivant.
Question 2 : Compléter le code arduino suivant (Zone A et Zone B).
int pinLed = 3; // numéro de patte ou se trouve la led
int pinBouton = 2; // numéro de patte où se trouve le bouton
int etatBouton = 0; //variable globale permettant de stocker l'état du bouton
void setup() {
pinMode(pinLed, OUTPUT);
pinMode(pinBouton, INPUT);
Serial.begin(9600);
}
void loop() {
//lecture de l'état du bouton
etatBouton = digitalRead(pinBouton);
if (etatBouton == HIGH)
{
Serial.println("Zone A : A COMPLETER");
digitalWrite(pinLed, HIGH);
}
else
{
Serial.println("Zone B : A COMPLETER");
digitalWrite(pinLed, LOW);
}
delay(20);
}
Le code source se trouve dans le fichier « 1_testDesBoutons.ino » que vous pouvez ouvrir directement avec Arduino IDE.
Tester le code directement sur la maquette en téléversant celui-ci. Que se passe-t-il ?
Attention à bien choisir le bon port COM et le bon microcontrôleur dans la liste (Arduino Uno).
Le port COM peut être différent, il faut trouver celui de votre ordinateur.
Etape 2 : Test des moteurs
Nous allons tester le mode manuel des moteurs en ajoutant 2 nouveaux boutons pour le mode manuel. Il faudra faire attention à ne pas forcer les moteurs sur les fins de course.
Ajouter et câbler deux boutons que vous identifierez.
Pour ajouter le support avec la carte seed moto v1.3, il faut faire une manipulation sous l’IDE Arduino. Récupérer le fichier zip 
présent dans le répertoire, puis copier le directement dans le répertoire « library » ou « librairies » de l’IDE Arduino. Si vous ne savez pas où cela se trouve, vous pouvez regarder dans Fichier > préférences et vous aurez le chemin.
Une fois le fichier copié, il faudra le déclarer au niveau des bibliothèques Arduino, pour cela, il suffit de faire :
Et vous pointez sur le fichier fraîchement copié.
Vous voilà prêt à utiliser le moteur de la barrière.
Question 3 : Compléter l’algorigramme suivant pour la gestion de barrière :
Question 4 : Compléter le code Arduino suivant (zone A et B) pour la gestion du moteur sans gestion de fin de course.
Ajouter les 2 boutons au shield seed de l’arduino. Déclarer ces deux boutons dans le code ci-dessus et faites les branchements.
#include "Grove_I2C_Motor_Driver.h"
// adresse par défaut de l'I2C
#define I2C_ADDRESS 0x0f
int pinLed = 3; // numéro de patte ou se trouve la led
int pinBouton = 2; // numéro de patte où se trouve le bouton
int pinBoutonDescente = 6; //bouton pour descendre la barrière
int pinBoutonMontee = 7; //bouton pour monter la barrière
int etatBouton = 0; //variable globale permettant de stocker l'état du bouton
int etatBoutonDescente = 0; //variable globale permettant de stocker l'état du bouton
int etatBoutonMontee = 0; //variable globale permettant de stocker l'état du bouton
void setup() {
pinMode(pinLed, OUTPUT);
pinMode(pinBouton, INPUT);
// initiation de la carte SEED avec l'adresse par défaut 0x0f
Motor.begin(I2C_ADDRESS);
Serial.begin(9600);
}
void loop() {
//lecture de l'état du bouton
etatBouton = digitalRead(pinBouton);
etatBoutonDescente = digitalRead(pinBoutonDescente);
etatBoutonMontee = digitalRead(pinBoutonMontee);
if(etatBoutonDescente == HIGH) {
Serial.println("Zone A : A COMPLETER");
Motor.speed(MOTOR1,-70);
delay(100);
}else{
Motor.stop(MOTOR1);
}
if(etatBoutonMontee == HIGH) {
Serial.println("Zone B : A COMPLETER");
Motor.speed(MOTOR1,40);
delay(100);
}else {
Motor.stop(MOTOR1);
}
if (etatBouton == HIGH)
{
Serial.println("Appui");
digitalWrite(pinLed, HIGH);
}
else
{
Serial.println("Pas d'appui");
digitalWrite(pinLed, LOW);
}
delay(20);
}
Le code source se trouve dans le fichier « 2_testDesMoteurs.ino » que vous pouvez ouvrir directement avec Arduino IDE.
Question 5 : Pourquoi faut-il impérativement utiliser des lignes de codes avec l’instruction : Motor.stop(MOTOR1); ?
Question 6 : Téléversez et tester ce code, est-ce que le fonctionnement est correct ? Utiliser le moniteur série pour tracer les différents états ?
Relever quelques indications et recopier les sur votre copie (prenez 2-3 exemples).
Question 7 : Pourquoi la descente est-elle plus lente que la montée ? Comment corriger cela ? Indiquer votre démarche.
Question 8 : Est-ce que la gestion du bouton du paragraphe précédent est toujours fonctionnelle ?
Etape 3 : Test des moteurs avec les fins de course
Question 9 : Etablir un tableau qui liste les entrées/sorties du système barrière :
|
|
Entrée |
Sortie |
|
Bouton barrière |
Exemple : 2 |
Exemple : 5 |
|
Led barrière |
|
|
|
Fin de course haut |
|
|
|
Compléter ici.....en ajoutant des lignes... |
|
|
utilisez le code de la question 11 pour compléter le tableau
Question 10 : Expliquer le cheminement de l’algorigramme en parcourant l’ensemble des cas possibles. Utiliser un algorigramme pour vous aider.
Question 11 : Tester le code suivant, à quoi sert le boutonTP connecté sur la broche 7 ?
#include "Grove_I2C_Motor_Driver.h"
#define I2C_ADDRESS 0x0f // adresse par défaut de l'I2C
const int boutonOuverture = 2; // bouton demande ouverture
const int capteurPinFerme = 5; // capteur haut
const int capteurPinOuvert = 4; // capteur bas
const int ledPin = 3; // led
const int boutonTP = 7; // bouton magique pour le TP
// variables will change:
int etatBoutonOuverture = 0; // variable qui contient l'état du bouton d'ouverture
int etatCapteurOuvert = 0; // variable qui contient l'état du capteurBas
int etatCapteurFerme = 0; // variable qui contient l'état du capteurHaut
int etatBoutonTP = 0; // variable qui contient l'état du bouton TP
void setup() {
Serial.begin(9600);
Serial.println("Début du programme");
// put your setup code here, to run once:
Motor.begin(I2C_ADDRESS);
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(capteurPinOuvert, INPUT);
pinMode(capteurPinFerme, INPUT);
pinMode(capteurPinFerme, INPUT);
Serial.print("init");
Serial.println(digitalRead(capteurPinFerme));
etatBoutonOuverture = digitalRead(capteurPinFerme);
//on ferme la barrière
while(etatBoutonOuverture == HIGH){
etatBoutonOuverture = digitalRead(capteurPinFerme);
//Serial.println("On ferme");
Motor.speed(MOTOR1,50);
}
Serial.println("Fin du capteur bas");
// Stop one motor
Motor.stop(MOTOR1);
delay(500);
Serial.println("Fin du setup");
}
void gestionFermeture(){
//gestion de la fermeture de la barrière
digitalWrite(ledPin, HIGH);
Serial.println("Avant On ferme");
while(etatCapteurFerme == HIGH){
etatCapteurFerme = digitalRead(capteurPinFerme);
delay(100);
Serial.println("On ferme");
Serial.println(String(digitalRead(boutonOuverture)) + String(" ") + String(digitalRead(capteurPinOuvert)) + String(" ") + String(digitalRead(capteurPinFerme)));
Motor.speed(MOTOR1,-60);
}
Motor.stop(MOTOR1);
delay(10);
digitalWrite(ledPin, LOW);
}
void gestionOuverture(){
//gestion de l'ouverture de la barrière
}
void loop() {
// on lit la demande d'ouverture de la barrière
etatBoutonOuverture = digitalRead(boutonOuverture);
etatCapteurOuvert = digitalRead(capteurPinOuvert);
etatCapteurFerme = digitalRead(capteurPinFerme);
etatBoutonTP = digitalRead(boutonTP);
//trace pour comprendre les états des capteurs en temps réel
Serial.println(String(digitalRead(boutonOuverture)) + String(" ") + String(digitalRead(capteurPinOuvert)) + String(" ") + String(digitalRead(capteurPinFerme)));
if ((etatBoutonOuverture == HIGH && etatCapteurOuvert == LOW)) {
// on ferme/ouvre la barriere
gestionFermeture();
}
else if ((etatBoutonOuverture == HIGH && etatCapteurFerme == LOW)){
// on ferme/ouvre la barriere
gestionOuverture();
}
else if(etatBoutonTP == HIGH){
Motor.speed(MOTOR1,60);
}
else{
Motor.stop(MOTOR1);
//Serial.println("Ne rien faire");
delay(10);
}
delay(10);
}
Le code source se trouve dans le fichier « 3_testComplet.ino » que vous pouvez ouvrir directement avec Arduino IDE.
Question 12 : Le programme permet de baisser la barrière mais pas de la remonter. En vous inspirant de la descente, écrivez la gestion de l’ouverture de la barrière.
Question 13 : Mettre en œuvre la gestion de la descente de la barrière. Quel est votre protocole de test ?
Aide : Vous pouvez vous aider du boutonTP pour bien comprendre ce qui se passe à la montée.
Pour aller plus loin :
Etape 4 : Ajout d’un feu de signalisation
Lorsqu’il n’y a pas de demande de passage, le feu de signalisation est au rouge. Lorsque la barrière est ouverte, le feu passe au vert. Un appui sur le bouton refera passer le feu au rouge.
Question 14 : Câbler si besoin et modifier le programme précédent pour ajouter cette gestion de feu.
Créé avec HelpNDoc Personal Edition: Améliorez votre documentation d'aide avec un outil de création d'aide