Arexx SIMONIN : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
 
(50 révisions intermédiaires par un autre utilisateur non affichées)
Ligne 1 : Ligne 1 :
 +
[[Catégorie:Projets Tutorés S2]]
 +
<!--                                  [[Image:urcasimonin.jpeg]]
 +
 +
 +
={{Rouge|Projet tutorés}}=
 +
 +
==={{Bleu|Présentation}}===
 +
 +
Nous avons composé un groupe de 4 personnes, formé de :
 +
 +
* BOURENNANE Adrien
  
[[Catégorie:Projets Tutorés S2]]
+
* LLITJOS Maxime
 +
 
 +
* HGUIG Abderrahmane
 +
 
 +
* SIMONIN Mathieu
 +
 
 +
Le projet consiste à créer un robot suiveur de ligne, pour se faire, on doit suivre un cahier des charges précis.
 +
 
 +
*Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.
  
 +
*Possibilité de modification de la carte d'adaptation.
  
= Projets tutorés =
+
*Fabrication de la carte gestion.
=== Présentation ===
 
  
 +
*Réalisation des programmes permettant le fonctionnement de la carte gestion.
  
Le projet consiste à créer un robot suiveur de ligne, pource faire. On doit suivre un cahier des charges précis.
+
*Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.
Après analyse du besoin, Des solutions techniquesapparaissent pour répondre à ses besoins.
 
On aboutit alors à une création de deux cartes.
 
# La carte capteur pour l’analyse de la piste surlaquelle le robot évolue.
 
# Une carte « gestion » pour commander lemoteur et la réaction du robot pour rester sur la piste.
 
Pour crée une carte électronique la première étape est decréer un schéma électrique.
 
[[Image:captureschematic.PNG]]
 
  
  
Une fois le schéma électrique fini il faut faire le routage.
+
Après analyse du besoin, des solutions techniques apparaissent pour répondre à ces besoins.
  
 +
On aboutit alors à la création de deux cartes.
  
 +
* La carte capteur pour l’analyse de la piste sur laquelle le robot évolue.
  
 +
* Une carte « gestion » pour commander le moteur et la réaction du robot afin de rester sur la piste.
  
 +
Pour créer une carte électronique la première étape est de réaliser un schéma électrique.
  
Pour créer une carte un cahier des charges est élaboré pour respecter son bonfonctionnement :
+
[[Image:captureschematic.PNG]]
* Faire des pistes les plus courtes et large possible, pas de court-circuit, les cartes vont être superposées donc les emplacements des connecteurs doivent être au même endroit.
 
  
*      Pour la carte capteur les capteurs doivent être sur la couche bottom, les leds pour signaler la détection de la piste doivent être cohérente (en face du bon capteur) et visible par l’utilisateur.
+
Une fois le schéma électrique fini il faut concevoir le routage.
  
* Pour la carte gestion les boutons poussoirs pour changer le mode de fonctionnement doivent être accessibles par l’utilisateur donc sur la couche top. Certain composants ont besoin de dissiper leur chaleur donc un système de piste large est nécessaire.
+
Pour créer une carte, il faut élaborer un cahier des charges afin de respecter son bon fonctionnement :
  
 +
* Faire des pistes les plus courtes et larges possibles, pas de court-circuit, les cartes vont être superposées donc les emplacements des connecteurs doivent être au même endroit.
  
 +
* Pour la carte capteur, les capteurs doivent être sur la couche bottom, les leds pour signaler la détection de la piste doivent être cohérentes (en face du bon capteur) et visibles par l’utilisateur.
 +
 +
* Pour la carte gestion, les boutons poussoirs pour changer le mode de fonctionnement doivent être accessibles par l’utilisateur donc sur la couche top. Certains composants ont besoin de dissiper leur chaleur donc un système de pistes larges est nécessaire.
  
 
[[Image:captureboard.PNG]]
 
[[Image:captureboard.PNG]]
=== Diagramme de Gantt ===
+
 
 +
Nous avons choisi de tester la carte du duo BOURENNANE/FRERSON, binôme lors du premier semestre
 +
 
 +
[[Image:cartecapteurfrerson.jpg]]
 +
==={{Bleu|Diagramme de Gantt}}===
 +
Nous nous sommes repartis équitablement le travail, à l'aide d'un diagramme de Gantt.
 +
Abderrahmane et Mathieu se sont chargés du dossier, quand Adrien et Maxime s'occupaient des tests. En revanche l'élaboration des programmes a été réalisé par le groupe tout entier.
 +
 
 
[[Image:ganttprojettut.PNG]]
 
[[Image:ganttprojettut.PNG]]
=== Tests des leds ===
+
 
 +
==={{Bleu|Tests des leds}}===
 +
Lors de ce test, nous avons essayé de déterminer si une led s'allume ou non. Si non, nous essayons de déterminer la cause de ce problème.
 
<source lang=c>
 
<source lang=c>
 +
 
///////////////////////////////////////////////////Sous programme permettant de tester les leds/////////////////////////////////////////////////////////////////
 
///////////////////////////////////////////////////Sous programme permettant de tester les leds/////////////////////////////////////////////////////////////////
 +
 
void testled () {
 
void testled () {
+
 
  // on determine les variables locales nécessaire a la sous fonction
+
// on determine les variables locales nécessaire a la sous fonction
  int gauche = '0'; int droit = '0'; int milieugauche = '0'; int milieudroit = '0'; int i = 0;  
+
 
+
int gauche = '0'; int droit = '0'; int milieugauche = '0'; int milieudroit = '0'; int i = 0;
// On fait clignoter les leds (si elles fonctionnent)
+
 
+
// On fait clignoter les leds (si elles fonctionnent)
for (i = 0; i < 5; i++)  
+
 
  digitalWrite(0, 1);
+
for (i = 0; i < 5; i++){
  digitalWrite(1, 1);
+
 
  digitalWrite(2, 1);  
+
digitalWrite(0, 1);
  digitalWrite(3, 1);  
+
 
  delay(500);
+
digitalWrite(1, 1);
  digitalWrite(0, 0);  
+
 
  digitalWrite(1, 0);  
+
digitalWrite(2, 1);
  digitalWrite(2, 0);
+
 
  digitalWrite(3, 0);  
+
digitalWrite(3, 1);
  delay(500);  
+
 
}  
+
delay(500);
+
 
//On demande si la led gauche clignote  
+
digitalWrite(0, 0);
+
 
Serial.println("La led gauche clignote t-elle ? ");
+
digitalWrite(1, 0);
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do {  
+
digitalWrite(2, 0);
  if (Serial.available() > 0) {  
+
 
    gauche = Serial.read();
+
digitalWrite(3, 0);
  }  
+
 
} while (gauche == '0');  
+
delay(500);
+
 
//On demande si la led du milieu gauche clignote
+
}
+
 
Serial.println("La led du milieu gauche clignote t-elle ? ");
+
//On demande si la led gauche clignote
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do {  
+
Serial.println("La led gauche clignote t-elle ? ");
  if (Serial.available() > 0) {  
+
 
    milieugauche = Serial.read();
+
Serial.println("tapez 1 pour oui et 2 pour non ");
  }
+
 
} while (milieugauche == '0');  
+
do {
+
 
//On demande si la led du milieu droit clignote
+
if (Serial.available() > 0) {
+
 
Serial.println("La led du milieu droit clignote t-elle ? ");
+
gauche = Serial.read();
Serial.println("tapez 1 pour oui et 2 pour non ");  
+
 
do {
+
}
  if (Serial.available() > 0) {
+
 
    milieudroit = Serial.read(); 
+
} while (gauche == '0');
  } 
+
 
} while (milieudroit == '0');
+
//On demande si la led du milieu gauche clignote
+
 
//On demande si la led droite clignote
+
Serial.println("La led du milieu gauche clignote t-elle ? ");
+
 
Serial.println("La led droite clignote t-elle ? ");
+
Serial.println("tapez 1 pour oui et 2 pour non ");
Serial.println("tapez 1 pour oui et 2 pour non "); 
+
 
do {
+
do {
  if (Serial.available() > 0) {
+
 
    droit = Serial.read();  
+
if (Serial.available() > 0) {
  }
+
 
} while (droit == '0');
+
milieugauche = Serial.read();
+
 
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
+
}
+
 
if (gauche == '2') {
+
} while (milieugauche == '0');
  Serial.println("Pour depanner la led gauche, veuillez:"); 
+
 
  Serial.println("verifier que la resistance R1 et R5 ne soit pas endommagee ou si elles sont bien dimensionnees ."); 
+
//On demande si la led du milieu droit clignote
  Serial.println( "Verifier que la piste ne soit pas coupee."); 
+
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");
+
Serial.println("La led du milieu droit clignote t-elle ? ");
  Serial.println( "Verifier que le transistor T2 ne soit pas endommagé."); 
+
 
  Serial.println( "Verifier que le capteur fonctionne.");
+
Serial.println("tapez 1 pour oui et 2 pour non ");
} else {
+
 
    Serial.println("La led Gauche fonctionne normalement"); 
+
do {
}
+
 
+
if (Serial.available() > 0) {
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
+
 
+
milieudroit = Serial.read();
if (milieugauche == '2') { 
+
 
  Serial.println("Pour depanner la led milieu gauche, veuillez:"); 
 
  Serial.println("verifier que la résistance R7 et R10 ne soit pas endommagee ou si elles sont bien dimensionnees ."); 
 
  Serial.println( "Verifier que la piste ne soit pas coupee."); 
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit."); 
 
  Serial.println( "Verifier que le transistor T4 ne soit pas endommagé.");   
 
  Serial.println( "Verifier que le capteur fonctionne.)"); 
 
} else { 
 
  Serial.println("La led milieu Gauche fonctionne normalement");
 
}
 
 
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 
 
if (milieudroit == '2') { 
 
  Serial.println("Pour depanner la led milieu droite, veuillez:");
 
  Serial.println("verifier que la resistance R14 et R16 ne soit pas endommagee ou si elles sont bien dimensionnees ."); 
 
  Serial.println( "Verifier que la piste ne soit pas coupee."); 
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 
  Serial.println( "Verifier que le transistor T6 ne soit pas endommage.");   
 
  Serial.println( "Verifier que le capteur fonctionne.)"); 
 
} else { 
 
  Seial.println("La led milieu droit fonctionne normalement");
 
 
 
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 
 
if (droit == '2') {   
 
  Serial.println("Pour depanner la led droite, veuillez:"); 
 
  Serial.println( "verifier que la resistance R13 et R15 ne soit pas endommagee ou si elles sont bien dimensionnees .");
 
  Serial.println( "Verifier que la piste ne soit pas coupee.");
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit."); 
 
  Serial.println( "Verifier que le transistor T5 ne soit pas endommage."); 
 
  Serial.println( "Verifier que le capteur fonctionne.");
 
} else { 
 
  Serial.println("La led droite fonctionne normalement");
 
}
 
delay(10000);  //On laisse 10 secondes a l utilisateur avant de retourner au menu
 
 
}
 
}
 +
 +
} while (milieudroit == '0');
 +
 +
//On demande si la led droite clignote
 +
 +
Serial.println("La led droite clignote t-elle ? ");
 +
 +
Serial.println("tapez 1 pour oui et 2 pour non ");
 +
 +
do {
 +
 +
if (Serial.available() > 0) {
 +
 +
droit = Serial.read();
 +
 +
}
 +
 +
} while (droit == '0');
 +
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 +
if (gauche == '2') {
 +
 +
Serial.println("Pour depanner la led gauche, veuillez:");
 +
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 +
Serial.println( "Verifier que le capteur fonctionne.");
 +
 +
} else {
 +
 +
Serial.println("La led Gauche fonctionne normalement");
 +
 +
}
 +
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 +
if (milieugauche == '2') {
 +
 +
Serial.println("Pour depanner la led milieu gauche, veuillez:");
 +
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 +
Serial.println( "Verifier que le capteur fonctionne.)");
 +
 +
} else {
 +
 +
Serial.println("La led milieu Gauche fonctionne normalement");
 +
 +
}
 +
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 +
if (milieudroit == '2') {
 +
 +
Serial.println("Pour depanner la led milieu droite, veuillez:");
 +
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 +
Serial.println( "Verifier que le capteur fonctionne.)");
 +
 +
} else {
 +
 +
Serial.println("La led milieu droit fonctionne normalement");
 +
 +
}
 +
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 +
if (droit == '2') {
 +
 +
Serial.println("Pour depanner la led droite, veuillez:");
 +
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 +
Serial.println( "Verifier que le capteur fonctionne.");
 +
 +
} else {
 +
 +
Serial.println("La led droite fonctionne normalement");
 +
 +
}
 +
 +
delay(10000); //On laisse 10 secondes a l utilisateur avant de retourner au menu
 +
 +
}
 +
 
</source>
 
</source>
=== Tests des récepteurs des capteurs ===
+
 
 +
[[Image:Capturetestsleds.PNG]]
 +
 
 +
==={{Bleu|Tests des récepteurs des capteurs}}===
 +
Lors de ce test, nous avons essayé de déterminer si un capteur fonctionne ou pas. Si le capteur ne fonctionne pas, nous essayons de déterminer la cause de ce dysfonctionnement.
 
<source lang=c>
 
<source lang=c>
 +
 
////////////////////////Sous programme permettant de tester la valeur que fournit le capteur/////////////////////////////////////////
 
////////////////////////Sous programme permettant de tester la valeur que fournit le capteur/////////////////////////////////////////
+
 
void testrecepteur () {  
+
void testrecepteur () {
+
 
// on definie les variables locales
+
// on definie les variables locales
int cotegauche1 , cotegauche2 , cotedroit1 , cotedroit2, cotemilieudroit1, cotemilieudroit2, cotemilieugauche1, cotemilieugauche2;
+
 
+
int cotegauche1 , cotegauche2 , cotedroit1 , cotedroit2, cotemilieudroit1, cotemilieudroit2, cotemilieugauche1, cotemilieugauche2;
  // On donne les consignes  
+
 
+
// On donne les consignes
Serial.println(" Vous allez tester que les recepteurs des capteurs fonctionnent");
+
 
delay(3000);
+
Serial.println(" Vous allez tester que les recepteurs des capteurs fonctionnent");
Serial.println("Pour cela, veuillez POSER la la carte avec les capteurs en direction du support le plus proche possible");  
+
 
delay(3000);
+
delay(3000);
+
 
// test du cote gauche  
+
Serial.println("Pour cela, veuillez POSER la la carte avec les capteurs en direction du support le plus proche possible");
+
 
digitalWrite(4, HIGH);  
+
delay(3000);
cotegauche1 = analogRead(A3);
+
 
delay(100);
+
// test du cote gauche
cotegauche2 = analogRead(A3);
+
 
if (cotegauche1 == cotegauche2) {  
+
digitalWrite(4, HIGH);
  Serial.println("Le recepteur du cote gauche ne fonctionne pas");
+
 
  Serial.println("verifier que la resistance R3 soit bien dimensionnee.");
+
cotegauche1 = analogRead(A3);
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
delay(100);
  Serial.println("Verifier que le capteur fonctionne.");
+
 
} else {  
+
cotegauche2 = analogRead(A3);
    Serial.println("Le recepteur du cote gauche fonctionne");  
+
 
  }
+
if (cotegauche1 == cotegauche2) {
delay(2000);  
+
 
+
Serial.println("Le recepteur du cote gauche ne fonctionne pas");
// test du cote droit  
+
 
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
digitalWrite(6, HIGH);
+
 
cotedroit1 = analogRead(A1);  
+
Serial.println("Verifier que la piste ne soit pas coupee.");
delay(100);
+
 
cotedroit2 = analogRead(A1);
+
Serial.println("Verifier qu'il n'y est pas de court circuit.");
if (cotedroit1 == cotedroit2) {  
+
 
  Serial.println("le recepteur du cote droit ne fonctionne pas");
+
Serial.println("Verifier que le capteur fonctionne.");
  Serial.println("verifier que la resistance R11 soit bien dimensionnee.");
+
 
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
} else {
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
 
  Serial.println("Verifier que le capteur fonctionne.");
+
Serial.println("Le recepteur du cote gauche fonctionne");
} else {
+
 
    Serial.println("le recepteur du cote droit fonctionne");  
+
}
  }  
+
 
delay(2000);  
+
delay(2000);
+
 
// test du milieu gauche  
+
// test du cote droit
+
 
digitalWrite(5, HIGH);
+
digitalWrite(6, HIGH);
cotemilieugauche1 = analogRead(A4);
+
 
delay(100);  
+
cotedroit1 = analogRead(A1);
cotemilieugauche2 = analogRead(A4);
+
 
if (cotemilieugauche1 == cotemilieugauche2) {  
+
delay(100);
  Serial.println("Le recepteur milieu gauche ne fonctionne pas");  
+
 
  Serial.println("verifier que la resistance R8 soit bien dimensionnee.");
+
cotedroit2 = analogRead(A1);
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
if (cotedroit1 == cotedroit2) {
  Serial.println("Verifier que le capteur fonctionne.");
+
 
} else {
+
Serial.println("le recepteur du cote droit ne fonctionne pas");
    Serial.println("Le recepteur milieu gauche fonctionne");
+
 
  }  
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
delay(2000);  
+
 
+
Serial.println("Verifier que la piste ne soit pas coupee.");
// test du milieu droit  
+
 
+
Serial.println("Verifier qu'il n'y est pas de court circuit.");
digitalWrite(7, HIGH);
+
 
cotemilieudroit1 = analogRead(A2);  
+
Serial.println("Verifier que le capteur fonctionne.");
delay(100);  
+
 
cotemilieudroit2 = analogRead(A2);  
+
} else {
if (cotemilieudroit1 == cotemilieudroit2) {
+
 
  Serial.println("Le recepteur milieu droit ne fonctionne pas");
+
Serial.println("le recepteur du cote droit fonctionne");
  Serial.println("verifier que la resistance R12 soit bien dimensionner.");
+
 
  Serial.println("Verifier que la piste ne soit pas coupe.");
+
}
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
 
  Serial.println("Verifier que le capteur fonctionne.");
+
delay(2000);
} else {  
+
 
    Serial.println("Le recepteur milieu droit fonctionne");  
+
// test du milieu gauche
  }  
+
 
delay(10000); // On laisse 10 seconde a l'utilisateur avant de retourner au menu
+
digitalWrite(5, HIGH);
}
+
 
 +
cotemilieugauche1 = analogRead(A4);
 +
 
 +
delay(100);
 +
 
 +
cotemilieugauche2 = analogRead(A4);
 +
 
 +
if (cotemilieugauche1 == cotemilieugauche2) {
 +
 
 +
Serial.println("Le recepteur milieu gauche ne fonctionne pas");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println("Verifier que la piste ne soit pas coupee.");
 +
 
 +
Serial.println("Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println("Verifier que le capteur fonctionne.");
 +
 
 +
} else {
 +
 
 +
Serial.println("Le recepteur milieu gauche fonctionne");
 +
 
 +
}
 +
 
 +
delay(2000);
 +
 
 +
// test du milieu droit
 +
 
 +
digitalWrite(7, HIGH);
 +
 
 +
cotemilieudroit1 = analogRead(A2);
 +
 
 +
delay(100);
 +
 
 +
cotemilieudroit2 = analogRead(A2);
 +
 
 +
if (cotemilieudroit1 == cotemilieudroit2) {
 +
 
 +
Serial.println("Le recepteur milieu droit ne fonctionne pas");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println("Verifier que la piste ne soit pas coupe.");
 +
 
 +
Serial.println("Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println("Verifier que le capteur fonctionne.");
 +
 
 +
} else {
 +
 
 +
Serial.println("Le recepteur milieu droit fonctionne");
 +
 
 +
}
 +
 
 +
delay(10000); // On laisse 10 seconde a l'utilisateur avant de retourner au menu
 +
 
 +
}
 +
 
 
</source>
 
</source>
=== Fonction menu ===
+
[[Image:Capturetetscapteurssimonin.PNG]]
 +
==={{Bleu|Organisation du programme}}===
 +
 
 
<source lang=c>
 
<source lang=c>
//////////////////////////////////////////////sous programme s'occupant du menu////////////////////////////////////////////////////////////
+
 
+
// on définie les variables globales
void menu () {
+
 
+
int choixtest; // variable globale utilisée à l fois dans le void setup et dans le void menu
  // on definit les variables locales 
+
 
int choix = 0; 
+
void setup() {
+
 
Serial.println("Bonjour,vous allez effectuer un programme permettant de tester une carte capteur.");  
+
// on définie les sorties
delay(3000);
+
 
+
pinMode(0, OUTPUT); // Led milieu droit
Serial.println("Avant de lancer une procedure de test, veuillez vous assurer de:");
+
 
delay(3000);
+
pinMode(1, OUTPUT); // Led milieu gauche
+
 
Serial.println("-bien connecter la carte capteur a la carte d'adaptation");  
+
pinMode(2, OUTPUT); // Led cote gauche
delay(3000);
+
 
+
pinMode(3, OUTPUT); // Led cote droit
Serial.println("-puis connecter la carte d adaptation a la carte arduino");  
+
 
delay(3000);
+
pinMode(4, OUTPUT); // emetteur IR cote gauche
+
 
Serial.println("");  
+
pinMode(5, OUTPUT); // emetteur IR milieu gauche
+
 
Serial.println("Veuillez choisir le test que vous voulez effectuer:");
+
pinMode(6, OUTPUT); // emetteur IR cote droit
delay(1000);
+
 
+
pinMode(7, OUTPUT); // emetteur IR milieu droit
Serial.println("-Le test des Leds : appuyez sur 1");
+
 
Serial.println("-Le test des emetteurs des capteurs : appuyez sur 2");
+
Serial.begin(9600);
Serial.println("-Le test des recepteurs des capteurs : appuyez sur 3");
+
 
delay(3000);  
+
}
+
 
// on attend de lire une valeur
+
void loop() {
+
 
  do {   
+
menu (); // On effectue dans tous les cas la fonction menu pour savoir ce que veut tester l'utilisateur
    if (Serial.available() > 0) { 
+
 
      choix = Serial.read();  
+
switch (choixtest) { // Ensuite la variable choixtest contient la réponse de l’utilisateur
    }
+
 
  } while (choix == '0');
+
case 1: testled (); // On va donc exécuter le programme de test correspondant.
  choixtest = choix;
+
 
 +
break;
 +
 
 +
case 2: testemetteur ();
 +
 
 +
break;
 +
 
 +
case 3: testrecepteur ();
 +
 
 +
break;
 +
 
 +
} // Une fois le programme choisit effectuer, le programme reviendra automatiquement au menu
 +
 
 
}
 
}
 +
 
</source>
 
</source>
=== Organisation du programme ===
+
 
 +
 
 +
==={{Bleu|Fonction menu}}===
 +
 
 
<source lang=c>
 
<source lang=c>
  // on définie les variables globales
+
 
int choixtest;  // variable globale utilisée à l fois dans le void setup et dans le void menu
+
//////////////////////////////////////////////sous programme s'occupant du menu////////////////////////////////////////////////////////////
+
 
void setup() {
+
void menu () {
+
 
  // on définie les sorties
+
// on definit les variables locales
pinMode(0, OUTPUT);   // Led milieu droit
+
 
pinMode(1, OUTPUT);   // Led milieu gauche 
+
int choix = 0;
pinMode(2, OUTPUT);   // Led cote gauche 
+
 
pinMode(3, OUTPUT);   // Led cote droit
+
Serial.println("Bonjour,vous allez effectuer un programme permettant de tester une carte capteur.");
+
 
pinMode(4, OUTPUT);   // emetteur IR cote gauche
+
delay(3000);
pinMode(5, OUTPUT);   // emetteur IR milieu gauche
+
 
pinMode(6, OUTPUT);   // emetteur IR cote droit
+
Serial.println("Avant de lancer une procedure de test, veuillez vous assurer de:");
pinMode(7, OUTPUT);   // emetteur IR milieu droit
+
 
Serial.begin(9600);
+
delay(3000);
 +
 
 +
Serial.println("-bien connecter la carte capteur a la carte d'adaptation");
 +
 
 +
delay(3000);
 +
 
 +
Serial.println("-puis connecter la carte d adaptation a la carte arduino");
 +
 
 +
delay(3000);
 +
 
 +
Serial.println("Veuillez choisir le test que vous voulez effectuer:");
 +
 
 +
delay(1000);
 +
 
 +
Serial.println("-Le test des Leds : appuyez sur 1");
 +
 
 +
Serial.println("-Le test des emetteurs des capteurs : appuyez sur 2");
 +
 
 +
Serial.println("-Le test des recepteurs des capteurs : appuyez sur 3");
 +
 
 +
delay(3000);
 +
 
 +
// on attend de lire une valeur
 +
 
 +
do {
 +
 
 +
if (Serial.available() > 0) {
 +
 
 +
choix = Serial.read();
 +
 
 
}
 
}
+
 
+
} while (choix == '0');
void loop() {
+
 
  menu ();                      // On effectue dans tous les cas la fonction menu pour savoir ce que veut tester l'utilisateur
+
choixtest = choix;
  switch (choixtest) {          // Ensuite la variable choixtest contient la réponse de l’utilisateur 
+
 
    case 1: testled ();         // On va donc exécuter le programme de test correspondant.   
 
      break; 
 
    case 2: testemetteur (); 
 
      break; 
 
    case 3: testrecepteur ();  
 
      break; 
 
  }                          // Une fois le programme choisit effectuer, le programme reviendra automatiquement au menu
 
 
}
 
}
 +
 
</source>
 
</source>
=== Programme final ===
+
 
 +
==={{Bleu|Programme final}}===
 +
 
 
<source lang=c>
 
<source lang=c>
  // on définie les variables globales
+
 
int choixtest; // variable globale utilisé à l fois dans le void setup et dans le void menu
+
// on définie les variables globales
+
 
void setup() {
+
int choixtest; // variable globale utilisé à l fois dans le void setup et dans le void menu
+
 
  // on définie les sorties  
+
void setup() {
pinMode(0, OUTPUT);   // Led milieu droit  
+
 
pinMode(1, OUTPUT);   // Led milieu gauche
+
// on définie les sorties
pinMode(2, OUTPUT);   // Led cote gauche
+
 
pinMode(3, OUTPUT);   // Led cote droit  
+
pinMode(0, OUTPUT); // Led milieu droit
+
 
pinMode(4, OUTPUT);   // emetteur IR cote gauche
+
pinMode(1, OUTPUT); // Led milieu gauche
pinMode(5, OUTPUT);   // emetteur IR milieu gauche  
+
 
pinMode(6, OUTPUT);   // emetteur IR cote droit  
+
pinMode(2, OUTPUT); // Led cote gauche
pinMode(7, OUTPUT);   // emetteur IR milieu droit
+
 
Serial.begin(9600);
+
pinMode(3, OUTPUT); // Led cote droit
 +
 
 +
pinMode(4, OUTPUT); // emetteur IR cote gauche
 +
 
 +
pinMode(5, OUTPUT); // emetteur IR milieu gauche
 +
 
 +
pinMode(6, OUTPUT); // emetteur IR cote droit
 +
 
 +
pinMode(7, OUTPUT); // emetteur IR milieu droit
 +
 
 +
Serial.begin(9600);
 +
 
 
}
 
}
+
 
 
 
void loop() {
 
void loop() {
  menu ();                     // On effectue dans tous les cas la fonction menu pour savoir ce que veut tester l'utilisateur  
+
 
  switch (choixtest) {         // Ensuite la variable choixtest contient la réponse de l’utilisateur
+
menu (); // On effectue dans tous les cas la fonction menu pour savoir ce que veut tester l'utilisateur
    case 1: testled ();         // On va donc exécuter le programme de test correspondant.  
+
 
      break;  
+
switch (choixtest) { // Ensuite la variable choixtest contient la réponse de l’utilisateur
    case 2: testemetteur ();  
+
 
      break;
+
case 1: testled (); // On va donc exécuter le programme de test correspondant.
    case 3: testrecepteur ();  
+
 
      break;
+
break;
  }                           // Une fois le programme choisit effectuer, le programme reviendra automatiquement au menu
+
 
 +
case 2: testemetteur ();
 +
 
 +
break;
 +
 
 +
case 3: testrecepteur ();
 +
 
 +
break;
 +
 
 +
} // Une fois le programme choisit effectuer, le programme reviendra automatiquement au menu
 +
 
 
}
 
}
+
 
 
//////////////////////////////////////////////sous programme s'occupant du menu////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////sous programme s'occupant du menu////////////////////////////////////////////////////////////
+
 
 
void menu () {
 
void menu () {
+
 
  // on definit les variables locales
+
// on definit les variables locales
int choix = 0;
+
 
+
int choix = 0;
Serial.println("Bonjour,vous allez effectuer un programme permettant de tester une carte capteur.");  
+
 
delay(3000);
+
Serial.println("Bonjour,vous allez effectuer un programme permettant de tester une carte capteur.");
+
 
Serial.println("Avant de lancer une procedure de test, veuillez vous assurer de:");
+
delay(3000);
delay(3000);
+
 
+
Serial.println("Avant de lancer une procedure de test, veuillez vous assurer de:");
Serial.println("-bien connecter la carte capteur a la carte d'adaptation");  
+
 
delay(3000);
+
delay(3000);
+
 
Serial.println("-puis connecter la carte d adaptation a la carte arduino");  
+
Serial.println("-bien connecter la carte capteur a la carte d'adaptation");
delay(3000);
+
 
+
delay(3000);
Serial.println("");  
+
 
+
Serial.println("-puis connecter la carte d adaptation a la carte arduino");
Serial.println("Veuillez choisir le test que vous voulez effectuer:");
+
 
delay(1000);
+
delay(3000);
+
 
Serial.println("-Le test des Leds : appuyez sur 1");  
+
Serial.println("");
Serial.println("-Le test des emetteurs des capteurs : appuyez sur 2");  
+
 
Serial.println("-Le test des resecpteurs des capteurs : appuyez sur 3");
+
Serial.println("Veuillez choisir le test que vous voulez effectuer:");
delay(3000);  
+
 
+
delay(1000);
// on attend de lire une valeur  
+
 
+
Serial.println("-Le test des Leds : appuyez sur 1");
  do {  
+
 
    if (Serial.available() > 0) {  
+
Serial.println("-Le test des emetteurs des capteurs : appuyez sur 2");
      choix = Serial.read();  
+
 
    }
+
Serial.println("-Le test des resecpteurs des capteurs : appuyez sur 3");
  } while (choix == '0');
+
 
  choixtest = choix;
+
delay(3000);
 +
 
 +
// on attend de lire une valeur
 +
 
 +
do {
 +
 
 +
if (Serial.available() > 0) {
 +
 
 +
choix = Serial.read();
 +
 
 
}
 
}
+
 
 +
} while (choix == '0');
 +
 
 +
choixtest = choix;
 +
 
 +
}
 +
 
 
///////////////////////////////////////////////////Sous programme permettant de tester les leds/////////////////////////////////////////////////////////////////
 
///////////////////////////////////////////////////Sous programme permettant de tester les leds/////////////////////////////////////////////////////////////////
 +
 
void testled () {
 
void testled () {
+
 
  // on determine les variables locales nécessaires à la sous fonction
+
// on determine les variables locales nécessaires à la sous fonction
  int gauche = '0'; int droit = '0'; int milieugauche = '0'; int milieudroit = '0'; int i = 0;  
+
 
+
int gauche = '0'; int droit = '0'; int milieugauche = '0'; int milieudroit = '0'; int i = 0;
// On fait clignoter les leds (si elles fonctionnent)
+
 
+
// On fait clignoter les leds (si elles fonctionnent)
for (i = 0; i < 5; i++)  
+
 
  digitalWrite(0, 1);
+
for (i = 0; i < 5; i++){
  digitalWrite(1, 1);
+
 
  digitalWrite(2, 1);  
+
digitalWrite(0, 1);
  digitalWrite(3, 1);  
+
 
  delay(500);
+
digitalWrite(1, 1);
  digitalWrite(0, 0);  
+
 
  digitalWrite(1, 0);  
+
digitalWrite(2, 1);
  digitalWrite(2, 0);
+
 
  digitalWrite(3, 0);  
+
digitalWrite(3, 1);
  delay(500);  
+
 
}  
+
delay(500);
+
 
//On demande si la led gauche clignote  
+
digitalWrite(0, 0);
+
 
Serial.println("La led gauche clignote t-elle ? ");
+
digitalWrite(1, 0);
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do {  
+
digitalWrite(2, 0);
  if (Serial.available() > 0) {  
+
 
    gauche = Serial.read();
+
digitalWrite(3, 0);
  }  
+
 
} while (gauche == '0');  
+
delay(500);
+
 
//On demande si la led du milieu gauche clignote
+
}
+
 
Serial.println("La led du milieu gauche clignote t-elle ? ");
+
//On demande si la led gauche clignote
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do {  
+
Serial.println("La led gauche clignote t-elle ? ");
  if (Serial.available() > 0) {  
+
 
    milieugauche = Serial.read();
+
Serial.println("tapez 1 pour oui et 2 pour non ");
  }
+
 
} while (milieugauche == '0');  
+
do {
+
 
//On demande si la led du milieu droit clignote
+
if (Serial.available() > 0) {
+
 
Serial.println("La led du milieu droit clignote t-elle ? ");
+
gauche = Serial.read();
Serial.println("tapez 1 pour oui et 2 pour non ");  
+
 
do {
+
}
  if (Serial.available() > 0) {
+
 
    milieudroit = Serial.read();  
+
} while (gauche == '0');
  }
+
 
} while (milieudroit == '0');  
+
//On demande si la led du milieu gauche clignote
+
 
//On demande si la led droite clignote  
+
Serial.println("La led du milieu gauche clignote t-elle ? ");
+
 
Serial.println("La led droite clignote t-elle ? ");
+
Serial.println("tapez 1 pour oui et 2 pour non ");
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do {
+
do {
  if (Serial.available() > 0) {  
+
 
    droit = Serial.read();  
+
if (Serial.available() > 0) {
  }
+
 
} while (droit == '0');  
+
milieugauche = Serial.read();
+
 
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme  
+
}
+
 
if (gauche == '2') {  
+
} while (milieugauche == '0');
  Serial.println("Pour depanner la led gauche, veuillez:");  
+
 
  Serial.println("verifier que la resistance R1 et R5 ne soit pas endommagee ou si elles sont bien dimensionnees .");
+
//On demande si la led du milieu droit clignote
  Serial.println( "Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");
+
Serial.println("La led du milieu droit clignote t-elle ? ");
  Serial.println( "Verifier que le transistor T2 ne soit pas endommage.");  
+
 
  Serial.println( "Verifier que le capteur fonctionne.");
+
Serial.println("tapez 1 pour oui et 2 pour non ");
} else {
+
 
    Serial.println("La led Gauche fonctionne normalement");
+
do {
}
+
 
+
if (Serial.available() > 0) {
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme  
+
 
+
milieudroit = Serial.read();
if (milieugauche == '2') {
+
 
  Serial.println("Pour depanner la led milieu gauche, veuillez:");
+
}
  Serial.println("verifier que la résistance R7 et R10 ne soit pas endommagee ou si elles sont bien dimensionnees .");  
+
 
  Serial.println( "Verifier que la piste ne soit pas coupee.");
+
} while (milieudroit == '0');
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");  
+
 
  Serial.println( "Verifier que le transistor T4 ne soit pas endommage.");   
+
//On demande si la led droite clignote
  Serial.println( "Verifier que le capteur fonctionne.)");
+
 
} else {  
+
Serial.println("La led droite clignote t-elle ? ");
  Serial.println("La led milieu Gauche fonctionne normalement");  
+
 
}  
+
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme  
+
do {
+
 
if (milieudroit == '2') {
+
if (Serial.available() > 0) {
  Serial.println("Pour depanner la led milieu droite, veuillez:");
+
 
  Serial.println("verifier que la resistance R14 et R16 ne soit pas endommagee ou si elles sont bien dimensionnees .");
+
droit = Serial.read();
  Serial.println( "Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");
+
}
  Serial.println( "Verifier que le transistor T6 ne soit pas endommage.");  
+
 
  Serial.println( "Verifier que le capteur fonctionne.)"); 
+
} while (droit == '0');
} else { 
+
 
  Seial.println("La led milieu droit fonctionne normalement");  
+
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
}
+
 
+
if (gauche == '2') {
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme  
+
 
+
Serial.println("Pour depanner la led gauche, veuillez:");
if (droit == '2') {  
+
 
  Serial.println("Pour depanner la led droite, veuillez:");  
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
  Serial.println( "verifier que la resistance R13 et R15 ne soit pas endommagee ou si elles sont bien dimensionnees .");  
+
 
  Serial.println( "Verifier que la piste ne soit pas coupee.");  
+
Serial.println( "Verifier que la piste ne soit pas coupee.");
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");
+
 
  Serial.println( "Verifier que le transistor T5 ne soit pas endommage."); 
+
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
  Serial.println( "Verifier que le capteur fonctionne.");  
+
 
} else {  
+
Serial.println( "Verifier que le capteur fonctionne.");
  Serial.println("La led droite fonctionne normalement");
+
 
}
+
} else {
delay(10000); //On laisse 10 secondes a l utilisateur avant de retourner au menu
+
 
 +
Serial.println("La led Gauche fonctionne normalement");
 +
 
 +
}
 +
 
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 
 +
if (milieugauche == '2') {
 +
 
 +
Serial.println("Pour depanner la led milieu gauche, veuillez:");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println( "Verifier que le capteur fonctionne.)");
 +
 
 +
} else {
 +
 
 +
Serial.println("La led milieu Gauche fonctionne normalement");
 +
 
 +
}
 +
 
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 
 +
if (milieudroit == '2') {
 +
 
 +
Serial.println("Pour depanner la led milieu droite, veuillez:");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println( "Verifier que le capteur fonctionne.)");
 +
 
 +
} else {
 +
 
 +
Serial.println("La led milieu droit fonctionne normalement");
 +
 
 +
}
 +
 
 +
//On fait un test pour savoir quelle led ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
 +
 
 +
if (droit == '2') {
 +
 
 +
Serial.println("Pour depanner la led droite, veuillez:");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println( "Verifier que la piste ne soit pas coupee.");
 +
 
 +
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println( "Verifier que le capteur fonctionne.");
 +
 
 +
} else {
 +
 
 +
Serial.println("La led droite fonctionne normalement");
 +
 
 +
}
 +
 
 +
delay(10000); //On laisse 10 secondes a l utilisateur avant de retourner au menu
 +
 
 +
}
 +
 
 +
//////////////////////////////////////Sous programme permettant de tester les emmeteurs des capteurs:////////////////////////////////////////////////////////
 +
 
 +
void testemetteur () {
 +
 
 +
// on determine les variables locales nécessaire a la sous fonction
 +
 
 +
int emetgauche = '0'; int emetdroit = '0'; int emetmilieugauche = '0'; int emetmilieudroit = '0'; int i = 0;
 +
 
 +
// On donne les instructions
 +
 
 +
Serial.println("Vous allez tester le fonctionnement des emetteurs des capteurs: ");
 +
 
 +
delay(3000);
 +
 
 +
Serial.println("Pour cela, veuillez vous munir d'un telephone portable disposant d'un appareil photo ");
 +
 
 +
delay(3000);
 +
 
 +
Serial.println("car ils detectent les emissions Infra Rouge des emetteurs ");
 +
 
 +
delay(3000);
 +
 
 +
Serial.println("Diriger l'appareil vers les capteurs, le clignotement va commencer dans 10 secondes: ");
 +
 
 +
delay(10000);
 +
 
 +
// On fait clignoter les emetteurs IR (si elles fonctionnent)
 +
 
 +
for (i = 0; i < 5; i++) {
 +
 
 +
digitalWrite(4, 1);
 +
 
 +
digitalWrite(5, 1);
 +
 
 +
digitalWrite(6, 1);
 +
 
 +
digitalWrite(7, 1);
 +
 
 +
delay(500);
 +
 
 +
digitalWrite(4, 0);
 +
 
 +
digitalWrite(5, 0);
 +
 
 +
digitalWrite(6, 0);
 +
 
 +
digitalWrite(7, 0);
 +
 
 +
delay(500);
 +
 
 +
}
 +
 
 +
//On demande si l emetteur du capteur gauche clignote
 +
 
 +
Serial.println("L emetteur gauche clignote t-il ? ");
 +
 
 +
Serial.println("tapez 1 pour oui et 2 pour non ");
 +
 
 +
do {
 +
 
 +
if (Serial.available() > 0) {
 +
 
 +
emetgauche = Serial.read();
 +
 
 +
}
 +
 
 +
} while (emetgauche == '0');
 +
 
 +
//On demande si l emetteur du capteur milieu gauche clignote
 +
 
 +
Serial.println("L emetteur milieu gauche clignote t-il? ");
 +
 
 +
Serial.println("tapez 1 pour oui et 2 pour non ");
 +
 
 +
do {
 +
 
 +
if (Serial.available() > 0) {
 +
 
 +
emetmilieugauche = Serial.read();
 +
 
 +
}
 +
 
 +
} while (emetmilieugauche == '0');
 +
 
 +
//On demande si l emetteur du capteur milieu droit clignote
 +
 
 +
Serial.println("L emetteur milieu droit clignote t-il ? ");
 +
 
 +
Serial.println("tapez 1 pour oui et 2 pour non ");
 +
 
 +
do {
 +
 
 +
if (Serial.available() > 0) {
 +
 
 +
emetmilieudroit = Serial.read();
 +
 
 +
}
 +
 
 +
} while (emetmilieudroit == '0');
 +
 
 +
//On demande si l emetteur du capteur droit clignote
 +
 
 +
Serial.println("L emetteur droit clignote t-il ? ");
 +
 
 +
Serial.println("tapez 1 pour oui et 2 pour non ");
 +
 
 +
do {
 +
 
 +
if (Serial.available() > 0) {
 +
 
 +
emetdroit = Serial.read();
 +
 
 
}
 
}
+
 
//////////////////////////////////////Sous programme permettant de tester les emmeteurs des capteurs:////////////////////////////////////////////////////////
+
} while (emetdroit == '0');
+
 
void testemetteur () {
+
//On fait un test pour savoir quelle emetteur ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
+
 
// on determine les variables locales nécessaire a la sous fonction
+
if (emetgauche == '2') {
int emetgauche = '0'; int emetdroit = '0'; int emetmilieugauche = '0'; int emetmilieudroit = '0'; int i = 0; 
+
 
+
Serial.println("Pour depanner l emetteur gauche, veuillez:");
// On donne les instructions
+
 
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
Serial.println("Vous allez tester le fonctionnement des emetteurs des capteurs: "); 
+
 
delay(3000); 
+
Serial.println( "Verifier que la piste ne soit pas coupee.");
Serial.println("Pour cela, veuillez vous munir d'un telephone portable disposant d'un appareil photo ");
+
 
delay(3000);
+
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
Serial.println("car ils detectent les emissions Infra Rouge des emetteurs ");
+
 
delay(3000);
+
Serial.println( "Verifier que l emetteur n'est pas endommage.");
Serial.println("Diriger l'appareil vers les capteurs, le clignotement va commencer dans 5sec: ");
+
 
delay(5000); 
+
} else {
+
 
// On fait clignoter les emetteurs IR (si elles fonctionnent) 
+
Serial.println("L emetteur gauche fonctionne normalement");
for (i = 0; i < 5; i++) { 
+
 
  digitalWrite(4, 1);
+
}
  digitalWrite(5, 1); 
+
 
  digitalWrite(6, 1); 
+
if (emetmilieugauche == '2') {
  digitalWrite(7, 1);
+
 
  delay(500);
+
Serial.println("Pour depanner l emetteur milieu gauche, veuillez:");
  digitalWrite(4, 0); 
+
 
  digitalWrite(5, 0);
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
  digitalWrite(6, 0); 
+
 
  digitalWrite(7, 0);
+
Serial.println( "Verifier que la piste ne soit pas coupee.");
  delay(500);
+
 
}
+
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
+
 
//On demande si l emetteur du capteur gauche clignote 
+
Serial.println( "Verifier que l emetteur n'est pas endommage");
+
 
Serial.println("L emetteur gauche clignote t-il ? ");
+
} else {
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do { 
+
Serial.println("L emetteur milieu Gauche fonctionne normalement");
  if (Serial.available() > 0) { 
+
 
    emetgauche = Serial.read(); 
+
}
  }
+
 
} while (emetgauche == '0'); 
+
if (emetmilieudroit == '2') {
+
 
//On demande si l emetteur du capteur milieu gauche clignote
+
Serial.println("Pour depanner l emetteur milieu droite, veuillez:");
+
 
Serial.println("L emetteur milieu gauche clignote t-il? ");
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do { 
+
Serial.println( "Verifier que la piste ne soit pas coupee.");
  if (Serial.available() > 0) {   
+
 
    emetmilieugauche = Serial.read(); 
+
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
  }
+
 
} while (emetmilieugauche == '0');
+
Serial.println( "Verifier que l emetteur n'est pas endommage.");
+
 
//On demande si l emetteur du capteur milieu droit clignote
+
} else {
+
 
Serial.println("L emetteur milieu droit clignote t-il ? "); 
+
Serial.println("L emetteur milieu droit fonctionne normalement");
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do { 
+
}
  if (Serial.available() > 0) { 
+
 
    emetmilieudroit = Serial.read(); 
+
if (emetdroit == '2') {
  }
+
 
} while (emetmilieudroit == '0'); 
+
Serial.println("Pour depanner l'emetteur droit, veuillez:");
+
 
//On demande si l emetteur du capteur droit clignote
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
+
 
Serial.println("L emetteur droit clignote t-il ? "); 
+
Serial.println( "Verifier que la piste ne soit pas coupee.");
Serial.println("tapez 1 pour oui et 2 pour non ");
+
 
do { 
+
Serial.println( "Verifier qu'il n'y est pas de court circuit.");
  if (Serial.available() > 0) { 
+
 
    emetdroit = Serial.read(); 
+
Serial.println( "Verifier que l emetteur n'est pas endommage.");
  }
+
 
} while (emetdroit == '0');  
+
} else {
+
 
//On fait un test pour savoir quelle emetteur ne fonctionne pas et ainsi reporter la fiche de dépannage à l'utilisateur pu programme
+
Serial.println("L emetteur droit fonctionne normalement");
+
 
if (emetgauche == '2') {  
+
}
  Serial.println("Pour depanner l emetteur gauche, veuillez:");  
+
 
  Serial.println("verifier que la resistance R2 et R4 ne soit pas endommagee ou si elles sont bien dimensionnees .");
+
delay(10000); //On laisse 10 secondes a l utilisateur avant de retourner au menu
  Serial.println( "Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");  
+
}
  Serial.println( "Verifier que le transistor T1 ne soit pas endommage."); 
+
 
  Serial.println( "Verifier que l emetteur n'est pas endommage.");
 
} else {  
 
    Serial.println("L emetteur gauche fonctionne normalement");  
 
  }
 
 
if (emetmilieugauche == '2') {
 
  Serial.println("Pour depanner l emetteur milieu gauche, veuillez:");  
 
  Serial.println("verifier que la résistance R7 et R10 ne soit pas endommagee ou si elles sont bien dimensionnees .");
 
  Serial.println( "Verifier que la piste ne soit pas coupee.");  
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");  
 
  Serial.println( "Verifier que le transistor T4 ne soit pas endommage."); 
 
  Serial.println( "Verifier que l emetteur n'est pas endommage");
 
} else {  
 
    Serial.println("L emetteur milieu Gauche fonctionne normalement");  
 
  }
 
 
if (emetmilieudroit == '2') {
 
  Serial.println("Pour depanner l emetteur milieu droite, veuillez:");  
 
  Serial.println("verifier que la resistance R14 et R16 ne soit pas endommagee ou si elles sont bien dimensionnees .");  
 
  Serial.println( "Verifier que la piste ne soit pas coupee.");  
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");  
 
  Serial.println( "Verifier que le transistor T6 ne soit pas endommage."); 
 
  Serial.println( "Verifier que l emetteur n'est pas endommage.");  
 
} else {  
 
    Serial.println("L emetteur milieu droit fonctionne normalement");  
 
  }
 
 
if (emetdroit == '2') {  
 
  Serial.println("Pour depanner l'emetteur droit, veuillez:");  
 
  Serial.println( "verifier que la resistance R13 et R15 ne soit pas endommagee ou si elles sont bien dimensionnees .");
 
  Serial.println( "Verifier que la piste ne soit pas coupee.");  
 
  Serial.println( "Verifier qu'il n'y est pas de court circuit.");  
 
  Serial.println( "Verifier que le transistor T5 ne soit pas endommage.");
 
  Serial.println( "Verifier que l emetteur n'est pas endommage.");  
 
} else {  
 
    Serial.println("L emetteur droit fonctionne normalement");  
 
  }
 
delay(10000); //On laisse 10 secondes a l utilisateur avant de retourner au menu
 
}
 
 
 
////////////////////////Sous programme permettant de tester la valeur que fournit le capteur/////////////////////////////////////////
 
////////////////////////Sous programme permettant de tester la valeur que fournit le capteur/////////////////////////////////////////
+
 
void testrecepteur () {  
+
void testrecepteur () {
+
 
// on definie les variables locales
+
// on definie les variables locales
int cotegauche1 , cotegauche2 , cotedroit1 , cotedroit2, cotemilieudroit1, cotemilieudroit2, cotemilieugauche1, cotemilieugauche2;
+
 
+
int cotegauche1 , cotegauche2 , cotedroit1 , cotedroit2, cotemilieudroit1, cotemilieudroit2, cotemilieugauche1, cotemilieugauche2;
  // On donne les consignes  
+
 
+
// On donne les consignes
Serial.println(" Vous allez tester que les recepteurs des capteurs fonctionnent");
+
 
delay(3000);
+
Serial.println(" Vous allez tester que les recepteurs des capteurs fonctionnent");
Serial.println("Pour cela, veuillez POSER la la carte avec les capteurs en direction du support le plus proche possible");  
+
 
delay(3000);
+
delay(3000);
+
 
// test du cote gauche  
+
Serial.println("Pour cela, veuillez POSER la la carte avec les capteurs en direction du support le plus proche possible");
+
 
digitalWrite(4, HIGH);  
+
delay(3000);
cotegauche1 = analogRead(A3);
+
 
delay(100);
+
// test du cote gauche
cotegauche2 = analogRead(A3);
+
 
if (cotegauche1 == cotegauche2) {  
+
digitalWrite(4, HIGH);
  Serial.println("Le recepteur du cote gauche ne fonctionne pas");
+
 
  Serial.println("verifier que la resistance R3 soit bien dimensionnee.");
+
cotegauche1 = analogRead(A3);
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
delay(100);
  Serial.println("Verifier que le capteur fonctionne.");
+
 
} else {  
+
cotegauche2 = analogRead(A3);
    Serial.println("Le recepteur du cote gauche fonctionne");  
+
 
  }
+
if (cotegauche1 == cotegauche2) {
delay(2000);  
+
 
+
Serial.println("Le recepteur du cote gauche ne fonctionne pas");
// test du cote droit  
+
 
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
digitalWrite(6, HIGH);
+
 
cotedroit1 = analogRead(A1);  
+
Serial.println("Verifier que la piste ne soit pas coupee.");
delay(100);
+
 
cotedroit2 = analogRead(A1);
+
Serial.println("Verifier qu'il n'y est pas de court circuit.");
if (cotedroit1 == cotedroit2) {  
+
 
  Serial.println("le recepteur du cote droit ne fonctionne pas");
+
Serial.println("Verifier que le capteur fonctionne.");
  Serial.println("verifier que la resistance R11 soit bien dimensionnee.");
+
 
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
} else {
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
 
  Serial.println("Verifier que le capteur fonctionne.");
+
Serial.println("Le recepteur du cote gauche fonctionne");
} else {
+
 
    Serial.println("le recepteur du cote droit fonctionne");  
+
}
  }  
+
 
delay(2000);  
+
delay(2000);
+
 
// test du milieu gauche  
+
// test du cote droit
+
 
digitalWrite(5, HIGH);
+
digitalWrite(6, HIGH);
cotemilieugauche1 = analogRead(A4);
+
 
delay(100);  
+
cotedroit1 = analogRead(A1);
cotemilieugauche2 = analogRead(A4);
+
 
if (cotemilieugauche1 == cotemilieugauche2) {  
+
delay(100);
  Serial.println("Le recepteur milieu gauche ne fonctionne pas");  
+
 
  Serial.println("verifier que la resistance R8 soit bien dimensionnee.");
+
cotedroit2 = analogRead(A1);
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
 
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
if (cotedroit1 == cotedroit2) {
  Serial.println("Verifier que le capteur fonctionne.");
+
 
} else {
+
Serial.println("le recepteur du cote droit ne fonctionne pas");
    Serial.println("Le recepteur milieu gauche fonctionne");
+
 
  }  
+
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
delay(2000);  
+
 
+
Serial.println("Verifier que la piste ne soit pas coupee.");
// test du milieu droit  
+
 
+
Serial.println("Verifier qu'il n'y est pas de court circuit.");
digitalWrite(7, HIGH);
+
 
cotemilieudroit1 = analogRead(A2);  
+
Serial.println("Verifier que le capteur fonctionne.");
delay(100);  
+
 
cotemilieudroit2 = analogRead(A2);  
+
} else {
if (cotemilieudroit1 == cotemilieudroit2) {
+
 
  Serial.println("Le recepteur milieu droit ne fonctionne pas");
+
Serial.println("le recepteur du cote droit fonctionne");
  Serial.println("verifier que la resistance R12 soit bien dimensionnee.");
+
 
  Serial.println("Verifier que la piste ne soit pas coupee.");
+
}
  Serial.println("Verifier qu'il n'y est pas de court circuit.");
+
 
  Serial.println("Verifier que le capteur fonctionne.");
+
delay(2000);
} else {  
+
 
    Serial.println("Le recepteur milieu droit fonctionne");  
+
// test du milieu gauche
  }  
+
 
delay(10000); // On laisse 10 seconde a l'utilisateur avant de retourner au menu
+
digitalWrite(5, HIGH);
}
+
 
 +
cotemilieugauche1 = analogRead(A4);
 +
 
 +
delay(100);
 +
 
 +
cotemilieugauche2 = analogRead(A4);
 +
 
 +
if (cotemilieugauche1 == cotemilieugauche2) {
 +
 
 +
Serial.println("Le recepteur milieu gauche ne fonctionne pas");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println("Verifier que la piste ne soit pas coupee.");
 +
 
 +
Serial.println("Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println("Verifier que le capteur fonctionne.");
 +
 
 +
} else {
 +
 
 +
Serial.println("Le recepteur milieu gauche fonctionne");
 +
 
 +
}
 +
 
 +
delay(2000);
 +
 
 +
// test du milieu droit
 +
 
 +
digitalWrite(7, HIGH);
 +
 
 +
cotemilieudroit1 = analogRead(A2);
 +
 
 +
delay(100);
 +
 
 +
cotemilieudroit2 = analogRead(A2);
 +
 
 +
if (cotemilieudroit1 == cotemilieudroit2) {
 +
 
 +
Serial.println("Le recepteur milieu droit ne fonctionne pas");
 +
 
 +
Serial.println( "Verifier la coherence ou la qualite des resistances et transistors.");
 +
 
 +
Serial.println("Verifier que la piste ne soit pas coupee.");
 +
 
 +
Serial.println("Verifier qu'il n'y est pas de court circuit.");
 +
 
 +
Serial.println("Verifier que le capteur fonctionne.");
 +
 
 +
} else {
 +
 
 +
Serial.println("Le recepteur milieu droit fonctionne");
 +
 
 +
}
 +
 
 +
delay(10000); // On laisse 10 seconde a l'utilisateur avant de retourner au menu
 +
 
 +
}
 +
 
 
</source>
 
</source>
 +
 +
Avec une carte quelque peu défaillante, nous constatons que nos programmes marchent. Malheureusement seulement un des 4 capteurs et 2 des 4 leds fonctionnent.
 +
 +
                                        [[Image:Capturesimonincarte.PNG]]-->

Version actuelle datée du 23 décembre 2015 à 22:40