troyesGEII - Contributions de l’utilisateur [fr]

Fichier:Capture21.png

2015-06-22T23:17:54Z

Troyesgeii : [mise a jour] doublon a supprimer

[mise a jour] doublon a supprimer

Arexx SUPERHEROS

2015-06-22T23:15:55Z

Troyesgeii :

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction-Présentation du projet}}=

Au cours du précédent semestre, nous avons eu à concevoir un robot suiveur de ligne sur un châssis Arexx constitué d'une carte capteur et d'une carte gestion. Nous avons également dû réaliser une carte d’adaptation afin de relier directement la carte capteur à une carte ARDUINO. Nous avons aussi écrit des programmes pour tester les capteurs et les LEDs, suite à cela notre projet actuel consiste à écrire un programme permettant de détecter les pannes sur la carte capteur du robot Arexx.

={{Rouge|Présentation du cahier des charges}}=

♦Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.

♦Possibilité de modification de la carte d'adaptation.

♦Fabrication de la carte gestion.

♦ Réalisation des programmes permettant le fonctionnement de la carte gestion.

♣ Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.

={{Rouge|Planning }}=
=={{Bleu|Planning prévisionnel }}==

[[Image:taches image.JPG]]

[[Image:gantt image.JPG]]

=={{Bleu|Planning de la semaine d’inter-semestre}}==

[[Image:gantt2.JPG]]

[[Image:planning2.JPG]]

={{Rouge|Carte capteur}}=

=={{Bleu|Procédure des tests }}==

=={{Vert|Procédure manuelle }}==
Ces tests sont basés sur les programmes réalisés lors du projet inter-semestre précédent, en testant le bon fonctionnement des capteurs et des LEDs.

<source lang=c>
char * pos[4] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char ledv[4]={
6,7,9,8};
char ledc[4]={
4,3,2,5};
int i;
void setup(){
for (char i = 0; i < 8; i++) pinMode(i+2, OUTPUT);
Serial.begin(9600);
}

void testlv(){
Serial.println("Parametrer le moniteur serie en 'Pas de fin de ligne'");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledv[i],1);
while (Serial.available() == 0);
char l=Serial.read();
while(Serial.available()>0);
digitalWrite(ledv[i],0);
if(l==0x6F){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(l==0x6E){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void testlc(){
Serial.println("Utiliser l'objectif de votre smartphone pour voir les capteurs");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledc[i],1);
while (Serial.available() == 0);
char m=Serial.read();
while(Serial.available()>0);
digitalWrite(ledc[i],0);
if(m==0x6F){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(m==0x6E){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void tcapteur(){
char led[4]={
4,3,2,5 };
char capt[4]={
A2,A3,A1,A0 };
int i;
Serial.println("Parametrer le moniteur serie en 'retour chariot'");
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
analogReference(DEFAULT);
for(i=0;i<4;i++){
digitalWrite(led[i],0);
int mes=analogRead(capt[i]);
digitalWrite(led[i],1);
delay(5);
int mea=analogRead(capt[i]);
if(mea>(mes*0.95)){
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
else{
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
delay(1000);
}
}

void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}

void loop(){
testlv();
testlc();
Serial.println("Verification des capteurs...");
delay(1000);
tcapteur();
Serial.println("Appuyer sur une touche pour recommencer les tests");
OK();
}

</source>

=={{Vert|Procédure optimisée }}==

Avec cette procédure, les courts-circuits sont détectés, les LEDs et les capteurs sont testés de façon semi-automatique par le programmes ci dessous réalisés lors de notre projet tutorés de ce semestre. l'utilisateur doit seulement déplacer la carte sur différentes surfaces afin de diminuer ou augmenter l'impact des capteurs sur les mesures suivant les besoins.

==={{Bleu|Modification de la carte d'adaptation-Choix de la résistance}}===

[[Image:resistancebakir.png]]
 
Nous avons choisi une résistance la plus grande possible laissant un courant d'environ 4mA traverser une LED, afin de perturber le moins possible le fonctionnement des LEDs. 
Si Vd=2V 
U=((5V-Vd)*R)/R+R1
= 3R/R+680 = (3*120)/800
= 360/800= 0.45V 
R=U/I = 0.45/4*10^-3=112.5 Ohm.
On prendra la résistance normalisée 120 Ohm.

Nous avons modifié la carte d'adaptation en mettant une résistance de 120ohm entre la masse de la carte capteur et la masse de la carte arduino, nous mesurons la tension aux bornes de cette résistance avec l'entrée analogique A4.

[[Image:Capture22.png|cadre|gauche|carte d'adaptation]]

[[Image:Capture21.png|cadre|gauche|schéma de la carte d'adaptation]]

 

==={{Bleu|Sous-programmes }}===

===={{Vert|Test des courts-circuits }}====
Ce test permet de détecter les courts-circuits entre Vcc et la masse.

Si aucune LED n'est allumée et que les capteurs ne sont pas exposés à la lumière, aucun courant ne circule, donc il n'y a aucune tension aux bornes de la résistance de test, si il y a une tension importante, cela signifie qu'il y a un court-circuit entre la masse et l'alimentation.

<source lang=c>

void test_cc(){
int val = analogRead(A4);
if(val>512)
{
Serial.print("court-circuit entre VCC et la masse!!!");
while(1);
}
}
</source>

===={{Vert|Test des LEDs }}====
Ce test permet de détecter un problème ente 2 bornes de la LED , ou si une piste est coupée sur le circuit alimentant la LED .

Pour les LEDs : en fonctionnement normal, la tension aux bornes des LEDs est d'environ 2V, donc la tension aux bornes de notre résistance de test est de ((5-Vd)*Rtest)/(Rtest+R)=(3*120)/(120+680)=0.45V.
Après la conversion analogique, 0.45V donne la valeur 92.

Pour les LEDs infrarouges des capteurs : les récepteurs des capteurs créent une tension lorsqu'on allume les LEDs donc la tension aux bornes dépend aussi de la tension aux bornes des photo-transistors. Nous avons observé les variations des 2 tensions en faisant varier la luminosité, afin de trouver une équation linéaire approximant le fonctionnement des capteurs.
Nous obtenons : U=413 -(20/307) * u2 avec u2 la tension moyenne des capteurs.

Pour limiter l'impact des tensions des capteurs dans les mesures nous placerons les capteurs sur une surface sombre.
Nous prenons une marge de 25 % dans nos calculs afin d’éviter les problèmes de variations de tensions.

<source lang=c>

char * pos[] = {"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={ 4,3,2,5 };
char capt[4]={ A2,A3,A1,A0};
char led[] = {6, 7, 9, 8 };

void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
</source>

===={{Vert|Test des capteurs }}====
Permet de détecter un problème dans les capteurs

♠Si la LED du capteur fonctionne

Si la LED fonctionne, nous pouvons vérifier le fonctionnement en effectuant une mesure avec la LED allumée et une avec la LED éteinte. Si la mesure avec la LED allumée est supérieure à celle de la LED éteinte, cela signifie que le récepteur fonctionne.

<source lang=c>

void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

Si la LED ne fonctionne pas, nous remplaçons la LED allumée par un éclairage fort, pour la LED éteinte, nous plaçons les capteurs sur une surface sombre.

♠Si la LED du capteur ne fonctionne pas
<source lang=c>
char void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

==={{Bleu|Programme final }}===

<source lang=c>
char * pos[] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5}; //adresse des leds des capteurs de gauche à droite
char capt[4]={A2,A3,A1,A0}; //adresse des capteurs de gauche à droite
char led[] = {6, 7, 9, 8 }; //adresse des leds de gauche à droite

boolean err=false; //flag passant à l’état vrai si il y'a un disfonctionnement

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println(" Parametrer le moniteur serie en 'retour chariot'");
test_cc(); //test court-circuit
}

void loop() {
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS(); //si au moins une led de capteur ne fonctionne pas on utilise cette fonction

Serial.println(" ");
if(err==false) Serial.println("Aucun probleme");
err==false;
Serial.println("Test termine");
Serial.println("Taper sur entrer pour recommencer");
Serial.println(" ");
Serial.println(" ");
OK();
}

//////////
void OK() //fonction attendant le caractère retour chariot comme confirmation que l'utilisateur à compris la consigne
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.print("Court-circuit entre VCC et la masse!!!");
while(1);
}
}
//////////
void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
//////////
void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
//////////
void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
</source>

=={{Bleu|Amélioration du programme de la procédure optimisée }}==
Nous avons dévellopé à l'aide de Processing une interface graphique qui faciliterai la recherche de la panne par l'utilisateur, cette interface affiche les problèmes et les consignes comme le moniteur série dans le précédent code, mais elle affiche aussi sur l'image du routage les pistes à vérifier en surbrillance.
De plus, le programme ne nécessite pas de changement de paramètre, donc peut être utilisé indépendamment
de Processing. Pour cela nous utilisons la fonction d'exportation de Processing afin de générer une application utilisable sur tout ordinateur.
Cependant cette methode serait réellement éfficace si toutes les cartes possèdaient le même routage.

Partie Arduino

Pour faciliter la communication, le texte envoyé à la liaison série est remplacé par un nombre.

<source lang=c>

char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5};
char capt[4]={A2,A3,A1,A0};
char led[] = { 6, 7, 9, 8};

boolean err=false;

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println("");
test_cc();
}

void loop() {
for(int i=0; i<4;i++) led_HS[i]=0;
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS();

if(err==false) Serial.println(26);
err=false;

Serial.println(25);
OK();
}

//////////
void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("01");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.println("02");
while(1);
}
}

///////////
void test_led()
{
Serial.println("01");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("0");
Serial.println(i+3);
err=true;
delay(2000);
OK();
}
if(val > 92 * 1.25)
{
Serial.print("0");
Serial.println(i+7);
err=true;
delay(2000);
OK();
}
}

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.println(i+11);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.println(i+15);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
}
}
//////////
void test_capt()
{
int i;
Serial.println(23);
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}
//////////
void test_capt_led_HS() {
int i;
int mes[4], mea[4];
Serial.println("01");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mes[i] = analogRead(capt[i]);

}
}
Serial.println(24);
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}

</source>

Partie Processing

<source lang=c>

import processing.serial.*;
PImage board;
PImage cc;
PImage ledcg;
PImage ledmg;
PImage ledmd;
PImage ledcd;
PImage CNYcg;
PImage CNYmg;
PImage CNYmd;
PImage CNYcd;
PImage captcg;
PImage captmg;
PImage captmd;
PImage captcd;

Serial myPort;
volatile char data[]= new char[255];
volatile int lecture;
volatile int i;
volatile boolean Sel=true; //flag autorisant le mode de fonctionnement sélection du port série
volatile boolean Init=false; //flag autorisant le mode de fonctionnement initialisation du port série
boolean fct=false; //flag autorisant le mode de fonctionnement normal
boolean fin=false; //flag indiquant la fin du test

void setup() {

size(1000, 800);
background(100);
textSize(20);
text("la touche maj est considérée comme un caractère, pour passer en majuscule, tapez ver.maj. puis backspace",10,50,1000,100);
textSize(32);
text("indiquez le port de la carte", 10, 150);

board=loadImage("imgboard.png");// sélection et chargement des images
cc=loadImage("cc.png");
ledcg=loadImage("ledcg.png");
ledmg=loadImage("ledmg.png");
ledmd=loadImage("ledmd.png");
ledcd=loadImage("ledcd.png");
CNYcg=loadImage("CNYcg.png");
CNYmg=loadImage("CNYmg.png");
CNYmd=loadImage("CNYmd.png");
CNYcd=loadImage("CNYcd.png");
captcg=loadImage("captcg.png");
captmg=loadImage("captmg.png");
captmd=loadImage("captmd.png");
captcd=loadImage("captcd.png");

imageMode(CORNERS);
}

void fonctionnement()
{
fill(0);
rect(0, 600, 1000, 200);//efface le précédent texte
fill(255);
switch(lecture) {
//affichage des informations correspondant au code transmis par Arduino
case 1:
text("Placez la carte sur une surface sombre, puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 2:
image(cc, 0, 0, 1000, 600);
text("Il y a un court-circuit entre VCC et la masse!!!", 50, 650, 950, 800);
break;
case 3:
image(ledcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté gauche", 50, 650, 950, 800);
break;
case 4:
image(ledmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu gauche", 50, 650, 950, 800);
break;
case 5:
image(ledmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu droit", 50, 650, 950, 800);
break;
case 6:
image(ledcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté droit", 50, 650, 950, 800);
break;
case 7:
image(ledcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté gauche", 50, 650, 950, 800);
break;
case 8:
image(ledmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu gauche", 50, 650, 950, 800);
break;
case 9:
image(ledmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu droit", 50, 650, 950, 800);
break;
case 10:
image(ledcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté droit", 50, 650, 950, 800);
break;
case 11:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 12:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 13:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu droit", 50, 650, 950, 800);
break;
case 14:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté droit", 50, 650, 950, 800);
break;
case 15:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 16:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 17:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu droit ", 50, 650, 950, 800);
break;
case 18:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté droit", 50, 650, 950, 800);
break;
case 19:
image(captcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté gauche", 50, 650, 950, 800);
break;
case 20:
image(captmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu gauche", 50, 650, 950, 800);
break;
case 21:
image(captmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu droit", 50, 650, 950, 800);
break;
case 22:
image(captcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté droit", 50, 650, 950, 800);
break;
case 23:
text("posez la carte sur une surface claire puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 24:
text("exposez la carte à une lumière forte puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 25:
text("Test terminé\n appuyer sur une touche pour recommencer", 50, 650, 950, 800);
fin=true;
break;
case 26:
text("Aucun problème",150 ,550, 950, 800);
break;
default:
break;
}
}

void draw() {
//partie initialisation du port série
if (Init==true)
{
char nom[]=new char[i];
for (char j=0; j<i; j++) nom[j]=data[j];//stockage des caractères choisi par l'utilisateur dans un tableau
String name = new String(nom);//création d'une chaîne de caractère à partir du tableau
myPort = new Serial(this, name, 9600);//initialisation du port série
myPort.bufferUntil('\n');
background(0);
Init=false;
fct=true;
image(board, 0, 0, 1000, 600);
}
if (fct==true) fonctionnement();
}

void keyPressed() {

//partie utilisée seulement en mode sélection du port série
if (Sel==true) {
if ((key==ENTER)||(key==RETURN)) //validation du choix du port série
{
Init=true;
Sel=false;
} else
{
if (key==BACKSPACE) //efface un caractère
{
data[i]=0;
fill(100);
noStroke();
rect(10+40*(i-1), 168, 32, 140);
fill(255);
i--;
} else {
data[i]=key;
text(data[i], 10+40*i, 200);
i++;
}
}
}

//partie utilisée seulement en fonctionnement normal
if (fct==true)
{
myPort.write(0x0d); //envoie confirmation à Arduino si on appui sur une touche
if (fin==true) //si le test est fini, efface l'écran avant de recommencer
{
image(board, 0, 0, 1000, 600);
fin=false;
}
}
}

void serialEvent(Serial myPort)
{
fill(0);
rect(0, 0, 200, 100);
fill(255);
byte l[]=myPort.readBytesUntil('\n');
lecture=(l[0]-48)*10+(l[1]-48); //conversion de la chaîne de caractère envoyé en un nombre de 2 chiffre
text(lecture, 50, 50);
}

</source>

Pour l'affichage dans l'interface, nous utilisons les images ci-dessous que nous superposons afin d'indiquer toutes les pistes qui nécessitent une vérification d'après le test.

{| class="wikitable"
|-
| || [[Fichier:imgboard.png|200px|thumb|left|imgboard.png]] || [[Fichier:court-circuit.png|200px|thumb|left|cc.png]] ||
|-
| [[Fichier:captcg.png|200px|thumb|left|captcg.png]] || [[Fichier:captmg.png|200px|thumb|left|captmg.png]] || [[Fichier:captmd.png|200px|thumb|left|captmd.png]] || [[Fichier:captcd.png|200px|thumb|left|captcd.png]]
|-
| [[Fichier:CNYcg.png|200px|thumb|left|CNYcg.png]] || [[Fichier:CNYmg.png|200px|thumb|left|CNYmg.png]] || [[Fichier:CNYmd.png|200px|thumb|left|CNYmd.png]] || [[Fichier:CNYcd.png|200px|thumb|left|CNYcd.png]]
|-
| [[Fichier:ledcg.png|200px|thumb|left|ledcg.png]] || [[Fichier:ledmg.png|200px|thumb|left|ledmg.png]] || [[Fichier:ledmd.png|200px|thumb|left|ledmd.png]] || [[Fichier:ledcd.png|200px|thumb|left|ledcd.png]]
|}

Fichier:Capture11.png

2015-06-22T23:14:00Z

Troyesgeii : Superheros a importé une nouvelle version de « Fichier:Capture11.png »

Fichier:Capture11.png

2015-06-22T23:12:03Z

Troyesgeii : Superheros a importé une nouvelle version de « Fichier:Capture11.png » : [mise a jour] ajout de la liaison manquante a la patte A4 de la carte Arduino

Arexx MENAHO

2015-06-22T21:50:55Z

Troyesgeii : /* {{Rouge|Explications}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Explications}}===

Ci-dessous, le programme de test en langage Arduino. Branchez simplement votre carte capteur Arexx sur une carte Arduino (reliez à votre PC) grâce à la carte adaptatrice prévue à cette effet puis téléverser ce programme grâce à l'IDE Arduino. Assurez-vous préalablement d'être sur le bon port série avant de téléverser.

Une fois le programme téléversée, ouvrez le moniteur série, choisissez 9600 baud puis laissez vous guider.

==={{Rouge|Programme}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
 
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
 
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
 
Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-22T21:49:16Z

Troyesgeii : /* {{Rouge|Explications}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Explications}}===

Ci-dessous, le programme de test en langage Arduino. Branchez simplement votre carte capteur Arexx sur une carte Arduino (reliez à votre PC) grâce à la carte adaptatrice prévue à cette effet puis téléverser ce programme grâce à l'IDE Arduino. Assurez-vous préalablement d'être sur le bon port série avant de téléverser.

<gallery>
Fichier:Port série.png
Fichier:Téléverser.png
</gallery>

Une fois le programme téléversée, ouvrez le moniteur série, choisissez 9600 baud puis laissez vous guider.

==={{Rouge|Programme}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
 
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
 
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
 
Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-22T21:40:29Z

Troyesgeii : /* {{Rouge|Explications}} */

Arexx MENAHO

2015-06-22T21:38:41Z

Troyesgeii : /* {{Rouge|Explications}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Explications}}===

Ci-dessous, le programme de test en langage Arduino. Branchez simplement votre carte capteur Arexx sur une carte Arduino (reliez à votre PC) grâce à la carte adaptatrice prévue à cette effet puis téléverser ce programme grâce à l'IDE Arduino. Assurez-vous préalablement d'être sur le bon port série avant de téléverser.

Une fois le programme téléversée, ouvrez la console du port série, choisissez 9600 baud puis laissez vous guider.

==={{Rouge|Programme}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
 
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
 
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
 
Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-22T21:38:26Z

Troyesgeii : /* {{Rouge|Explications}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Explications}}===

Ci-dessous, le programme de test en langage Arduino. Branchez simplement votre carte capteur Arexx sur une carte Arduino (reliez à votre PC) grâce à la carte adaptatrice prévue à cette effet puis téléverser ce programme grâce à l'IDE Arduino. Assurez-vous préalablement d'être sur le bon port série avant de téléverser.

Une fois le programme téléversée, ouvrez la console du port série, choisissez 9600 baud puis laissez vous guider par le programme.

==={{Rouge|Programme}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
 
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
 
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
 
Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-22T21:36:26Z

Troyesgeii : /* {{Rouge|Programme de test et explications}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Explications}}===

Ci-dessous, le programme de test en langage Arduino. Branchez simplement votre carte capteur Arexx sur une carte Arduino (reliez à votre PC) grâce à la carte adaptatrice prévue à cette effet puis téléverser ce programme grâce à l'IDE Arduino. Assurez-vous préalablement d'être sur le bon port série avant de téléverser.

Une fois le programme téléversée, ouvrez la console du port série, choisissez 9600 bauds puis laissez vous guider par le programme.

==={{Rouge|Programme}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("Taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
 
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
 
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
 
Si les composants sont mal soudés, les ressouder.

Fichier:Gantt.jpg

2015-06-22T15:58:00Z

Troyesgeii :

Arexx SUPERHEROS

2015-06-22T13:15:21Z

Troyesgeii : /* {{Bleu|Amélioration du programme de la procédure optimisée }} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction-Présentation du projet}}=

Au cours du précédent semestre, nous avons eu à concevoir un robot suiveur de ligne sur un châssis Arexx constitué d'une carte capteur et d'une carte gestion. Nous avons également dû réaliser une carte d’adaptation afin de relier directement la carte capteur à une carte ARDUINO. Nous avons aussi écrit des programmes pour tester les capteurs et les LEDs, suite à cela notre projet actuel consiste à écrire un programme permettant de détecter les pannes sur la carte capteur du robot Arexx.

={{Rouge|Présentation du cahier des charges}}=

♦Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.

♦Possibilité de modification de la carte d'adaptation.

♦Fabrication de la carte gestion.

♦ Réalisation des programmes permettant le fonctionnement de la carte gestion.

♣ Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.

={{Rouge|Planning }}=
=={{Bleu|Planning prévisionnel }}==

[[Image:taches image.JPG]]

[[Image:gantt image.JPG]]

=={{Bleu|Planning de la semaine d’inter-semestre}}==

[[Image:gantt2.JPG]]

[[Image:planning2.JPG]]

={{Rouge|Carte capteur}}=

=={{Bleu|Procédure des tests }}==

=={{Vert|Procédure manuelle }}==
Ces tests sont basés sur les programmes réalisés lors du projet inter-semestre précédent, en testant le bon fonctionnement des capteurs et des LEDs.

<source lang=c>
char * pos[4] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char ledv[4]={
6,7,9,8};
char ledc[4]={
4,3,2,5};
int i;
void setup(){
for (char i = 0; i < 8; i++) pinMode(i+2, OUTPUT);
Serial.begin(9600);
}

void testlv(){
Serial.println("Parametrer le moniteur serie en 'Pas de fin de ligne'");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledv[i],1);
while (Serial.available() == 0);
char l=Serial.read();
while(Serial.available()>0);
digitalWrite(ledv[i],0);
if(l==0x6F){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(l==0x6E){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void testlc(){
Serial.println("Utiliser l'objectif de votre smartphone pour voir les capteurs");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledc[i],1);
while (Serial.available() == 0);
char m=Serial.read();
while(Serial.available()>0);
digitalWrite(ledc[i],0);
if(m==0x6F){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(m==0x6E){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void tcapteur(){
char led[4]={
4,3,2,5 };
char capt[4]={
A2,A3,A1,A0 };
int i;
Serial.println("Parametrer le moniteur serie en 'retour chariot'");
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
analogReference(DEFAULT);
for(i=0;i<4;i++){
digitalWrite(led[i],0);
int mes=analogRead(capt[i]);
digitalWrite(led[i],1);
delay(5);
int mea=analogRead(capt[i]);
if(mea>(mes*0.95)){
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
else{
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
delay(1000);
}
}

void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}

void loop(){
testlv();
testlc();
Serial.println("Verification des capteurs...");
delay(1000);
tcapteur();
Serial.println("Appuyer sur une touche pour recommencer les tests");
OK();
}

</source>

=={{Vert|Procédure optimisée }}==

Avec cette procédure, les courts-circuits sont détectés, les LEDs et les capteurs sont testés de façon semi-automatique par le programmes ci dessous réalisés lors de notre projet tutorés de ce semestre. l'utilisateur doit seulement déplacer la carte sur différentes surfaces afin de diminuer ou augmenter l'impact des capteurs sur les mesures suivant les besoins.

==={{Bleu|Modification de la carte d'adaptation-Choix de la résistance}}===

[[Image:resistancebakir.png]]
 
Nous avons choisi une résistance la plus grande possible laissant un courant d'environ 4mA traverser une LED, afin de perturber le moins possible le fonctionnement des LEDs. 
Si Vd=2V 
U=((5V-Vd)*R)/R+R1
= 3R/R+680 = (3*120)/800
= 360/800= 0.45V 
R=U/I = 0.45/4*10^-3=112.5 Ohm.
On prendra la résistance normalisée 120 Ohm.

Nous avons modifié la carte d'adaptation en mettant une résistance de 120ohm entre la masse de la carte capteur et la masse de la carte arduino, nous mesurons la tension aux bornes de cette résistance avec l'entrée analogique A4.

[[Image:Capture22.png|cadre|gauche|carte d'adaptation]]

[[Image:Capture11.png|cadre|gauche|schéma de la carte d'adaptation]]

 

==={{Bleu|Sous-programmes }}===

===={{Vert|Test des courts-circuits }}====
Ce test permet de détecter les courts-circuits entre Vcc et la masse.

Si aucune LED n'est allumée et que les capteurs ne sont pas exposés à la lumière, aucun courant ne circule, donc il n'y a aucune tension aux bornes de la résistance de test, si il y a une tension importante, cela signifie qu'il y a un court-circuit entre la masse et l'alimentation.

<source lang=c>

void test_cc(){
int val = analogRead(A4);
if(val>512)
{
Serial.print("court-circuit entre VCC et la masse!!!");
while(1);
}
}
</source>

===={{Vert|Test des LEDs }}====
Ce test permet de détecter un problème ente 2 bornes de la LED , ou si une piste est coupée sur le circuit alimentant la LED .

Pour les LEDs : en fonctionnement normal, la tension aux bornes des LEDs est d'environ 2V, donc la tension aux bornes de notre résistance de test est de ((5-Vd)*Rtest)/(Rtest+R)=(3*120)/(120+680)=0.45V.
Après la conversion analogique, 0.45V donne la valeur 92.

Pour les LEDs infrarouges des capteurs : les récepteurs des capteurs créent une tension lorsqu'on allume les LEDs donc la tension aux bornes dépend aussi de la tension aux bornes des photo-transistors. Nous avons observé les variations des 2 tensions en faisant varier la luminosité, afin de trouver une équation linéaire approximant le fonctionnement des capteurs.
Nous obtenons : U=413 -(20/307) * u2 avec u2 la tension moyenne des capteurs.

Pour limiter l'impact des tensions des capteurs dans les mesures nous placerons les capteurs sur une surface sombre.
Nous prenons une marge de 25 % dans nos calculs afin d’éviter les problèmes de variations de tensions.

<source lang=c>

char * pos[] = {"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={ 4,3,2,5 };
char capt[4]={ A2,A3,A1,A0};
char led[] = {6, 7, 9, 8 };

void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
</source>

===={{Vert|Test des capteurs }}====
Permet de détecter un problème dans les capteurs

♠Si la LED du capteur fonctionne

Si la LED fonctionne, nous pouvons vérifier le fonctionnement en effectuant une mesure avec la LED allumée et une avec la LED éteinte. Si la mesure avec la LED allumée est supérieure à celle de la LED éteinte, cela signifie que le récepteur fonctionne.

<source lang=c>

void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

Si la LED ne fonctionne pas, nous remplaçons la LED allumée par un éclairage fort, pour la LED éteinte, nous plaçons les capteurs sur une surface sombre.

♠Si la LED du capteur ne fonctionne pas
<source lang=c>
char void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

==={{Bleu|Programme final }}===

<source lang=c>
char * pos[] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5}; //adresse des leds des capteurs de gauche à droite
char capt[4]={A2,A3,A1,A0}; //adresse des capteurs de gauche à droite
char led[] = {6, 7, 9, 8 }; //adresse des leds de gauche à droite

boolean err=false; //flag passant à l’état vrai si il y'a un disfonctionnement

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println(" Parametrer le moniteur serie en 'retour chariot'");
test_cc(); //test court-circuit
}

void loop() {
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS(); //si au moins une led de capteur ne fonctionne pas on utilise cette fonction

Serial.println(" ");
if(err==false) Serial.println("Aucun probleme");
err==false;
Serial.println("Test termine");
Serial.println("Taper sur entrer pour recommencer");
Serial.println(" ");
Serial.println(" ");
OK();
}

//////////
void OK() //fonction attendant le caractère retour chariot comme confirmation que l'utilisateur à compris la consigne
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.print("Court-circuit entre VCC et la masse!!!");
while(1);
}
}
//////////
void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
//////////
void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
//////////
void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
</source>

=={{Bleu|Amélioration du programme de la procédure optimisée }}==
Nous avons dévellopé à l'aide de Processing une interface graphique qui faciliterai la recherche de la panne par l'utilisateur, cette interface affiche les problèmes et les consignes comme le moniteur série dans le précédent code, mais elle affiche aussi sur l'image du routage les pistes à vérifier en surbrillance.
De plus, le programme ne nécessite pas de changement de paramètre, donc peut être utilisé indépendamment
de Processing. Pour cela nous utilisons la fonction d'exportation de Processing afin de générer une application utilisable sur tout ordinateur.
Cependant cette methode serait réellement éfficace si toutes les cartes possèdaient le même routage.

Partie Arduino

Pour faciliter la communication, le texte envoyé à la liaison série est remplacé par un nombre.

<source lang=c>

char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5};
char capt[4]={A2,A3,A1,A0};
char led[] = { 6, 7, 9, 8};

boolean err=false;

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println("");
test_cc();
}

void loop() {
for(int i=0; i<4;i++) led_HS[i]=0;
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS();

if(err==false) Serial.println(26);
err=false;

Serial.println(25);
OK();
}

//////////
void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("01");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.println("02");
while(1);
}
}

///////////
void test_led()
{
Serial.println("01");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("0");
Serial.println(i+3);
err=true;
delay(2000);
OK();
}
if(val > 92 * 1.25)
{
Serial.print("0");
Serial.println(i+7);
err=true;
delay(2000);
OK();
}
}

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.println(i+11);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.println(i+15);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
}
}
//////////
void test_capt()
{
int i;
Serial.println(23);
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}
//////////
void test_capt_led_HS() {
int i;
int mes[4], mea[4];
Serial.println("01");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mes[i] = analogRead(capt[i]);

}
}
Serial.println(24);
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}

</source>

Partie Processing

<source lang=c>

import processing.serial.*;
PImage board;
PImage cc;
PImage ledcg;
PImage ledmg;
PImage ledmd;
PImage ledcd;
PImage CNYcg;
PImage CNYmg;
PImage CNYmd;
PImage CNYcd;
PImage captcg;
PImage captmg;
PImage captmd;
PImage captcd;

Serial myPort;
volatile char data[]= new char[255];
volatile int lecture;
volatile int i;
volatile boolean Sel=true; //flag autorisant le mode de fonctionnement sélection du port série
volatile boolean Init=false; //flag autorisant le mode de fonctionnement initialisation du port série
boolean fct=false; //flag autorisant le mode de fonctionnement normal
boolean fin=false; //flag indiquant la fin du test

void setup() {

size(1000, 800);
background(100);
textSize(20);
text("la touche maj est considérée comme un caractère, pour passer en majuscule, tapez ver.maj. puis backspace",10,50,1000,100);
textSize(32);
text("indiquez le port de la carte", 10, 150);

board=loadImage("imgboard.png");// sélection et chargement des images
cc=loadImage("cc.png");
ledcg=loadImage("ledcg.png");
ledmg=loadImage("ledmg.png");
ledmd=loadImage("ledmd.png");
ledcd=loadImage("ledcd.png");
CNYcg=loadImage("CNYcg.png");
CNYmg=loadImage("CNYmg.png");
CNYmd=loadImage("CNYmd.png");
CNYcd=loadImage("CNYcd.png");
captcg=loadImage("captcg.png");
captmg=loadImage("captmg.png");
captmd=loadImage("captmd.png");
captcd=loadImage("captcd.png");

imageMode(CORNERS);
}

void fonctionnement()
{
fill(0);
rect(0, 600, 1000, 200);//efface le précédent texte
fill(255);
switch(lecture) {
//affichage des informations correspondant au code transmis par Arduino
case 1:
text("Placez la carte sur une surface sombre, puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 2:
image(cc, 0, 0, 1000, 600);
text("Il y a un court-circuit entre VCC et la masse!!!", 50, 650, 950, 800);
break;
case 3:
image(ledcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté gauche", 50, 650, 950, 800);
break;
case 4:
image(ledmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu gauche", 50, 650, 950, 800);
break;
case 5:
image(ledmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu droit", 50, 650, 950, 800);
break;
case 6:
image(ledcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté droit", 50, 650, 950, 800);
break;
case 7:
image(ledcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté gauche", 50, 650, 950, 800);
break;
case 8:
image(ledmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu gauche", 50, 650, 950, 800);
break;
case 9:
image(ledmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu droit", 50, 650, 950, 800);
break;
case 10:
image(ledcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté droit", 50, 650, 950, 800);
break;
case 11:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 12:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 13:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu droit", 50, 650, 950, 800);
break;
case 14:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté droit", 50, 650, 950, 800);
break;
case 15:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 16:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 17:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu droit ", 50, 650, 950, 800);
break;
case 18:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté droit", 50, 650, 950, 800);
break;
case 19:
image(captcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté gauche", 50, 650, 950, 800);
break;
case 20:
image(captmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu gauche", 50, 650, 950, 800);
break;
case 21:
image(captmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu droit", 50, 650, 950, 800);
break;
case 22:
image(captcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté droit", 50, 650, 950, 800);
break;
case 23:
text("posez la carte sur une surface claire puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 24:
text("exposez la carte à une lumière forte puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 25:
text("Test terminé\n appuyer sur une touche pour recommencer", 50, 650, 950, 800);
fin=true;
break;
case 26:
text("Aucun problème",150 ,550, 950, 800);
break;
default:
break;
}
}

void draw() {
//partie initialisation du port série
if (Init==true)
{
char nom[]=new char[i];
for (char j=0; j<i; j++) nom[j]=data[j];//stockage des caractères choisi par l'utilisateur dans un tableau
String name = new String(nom);//création d'une chaîne de caractère à partir du tableau
myPort = new Serial(this, name, 9600);//initialisation du port série
myPort.bufferUntil('\n');
background(0);
Init=false;
fct=true;
image(board, 0, 0, 1000, 600);
}
if (fct==true) fonctionnement();
}

void keyPressed() {

//partie utilisée seulement en mode sélection du port série
if (Sel==true) {
if ((key==ENTER)||(key==RETURN)) //validation du choix du port série
{
Init=true;
Sel=false;
} else
{
if (key==BACKSPACE) //efface un caractère
{
data[i]=0;
fill(100);
noStroke();
rect(10+40*(i-1), 168, 32, 140);
fill(255);
i--;
} else {
data[i]=key;
text(data[i], 10+40*i, 200);
i++;
}
}
}

//partie utilisée seulement en fonctionnement normal
if (fct==true)
{
myPort.write(0x0d); //envoie confirmation à Arduino si on appui sur une touche
if (fin==true) //si le test est fini, efface l'écran avant de recommencer
{
image(board, 0, 0, 1000, 600);
fin=false;
}
}
}

void serialEvent(Serial myPort)
{
fill(0);
rect(0, 0, 200, 100);
fill(255);
byte l[]=myPort.readBytesUntil('\n');
lecture=(l[0]-48)*10+(l[1]-48); //conversion de la chaîne de caractère envoyé en un nombre de 2 chiffre
text(lecture, 50, 50);
}

</source>

Pour l'affichage dans l'interface, nous utilisons les images ci-dessous que nous superposons afin d'indiquer toutes les pistes qui nécessitent une vérification d'après le test.

{| class="wikitable"
|-
| || [[Fichier:imgboard.png|200px|thumb|left|imgboard.png]] || [[Fichier:court-circuit.png|200px|thumb|left|cc.png]] ||
|-
| [[Fichier:captcg.png|200px|thumb|left|captcg.png]] || [[Fichier:captmg.png|200px|thumb|left|captmg.png]] || [[Fichier:captmd.png|200px|thumb|left|captmd.png]] || [[Fichier:captcd.png|200px|thumb|left|captcd.png]]
|-
| [[Fichier:CNYcg.png|200px|thumb|left|CNYcg.png]] || [[Fichier:CNYmg.png|200px|thumb|left|CNYmg.png]] || [[Fichier:CNYmd.png|200px|thumb|left|CNYmd.png]] || [[Fichier:CNYcd.png|200px|thumb|left|CNYcd.png]]
|-
| [[Fichier:ledcg.png|200px|thumb|left|ledcg.png]] || [[Fichier:ledmg.png|200px|thumb|left|ledmg.png]] || [[Fichier:ledmd.png|200px|thumb|left|ledmd.png]] || [[Fichier:ledcd.png|200px|thumb|left|ledcd.png]]
|}

Arexx SUPERHEROS

2015-06-21T19:26:47Z

Troyesgeii : /* {{Rouge|Introduction-Présentation du projet}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction-Présentation du projet}}=

Au cours du précédent semestre, nous avons eu à concevoir un robot suiveur de ligne sur un châssis Arexx constitué d'une carte capteur et d'une carte gestion. Nous avons également dû réaliser une carte d’adaptation afin de relier directement la carte capteur à une carte ARDUINO. Nous avons aussi écrit des programmes pour tester les capteurs et les LEDs, suite à cela notre projet actuel consiste à écrire un programme permettant de détecter les pannes sur la carte capteur du robot Arexx.

={{Rouge|Présentation du cahier des charges}}=

♦Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.

♦Possibilité de modification de la carte d'adaptation.

♦Fabrication de la carte gestion.

♦ Réalisation des programmes permettant le fonctionnement de la carte gestion.

♣ Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.

={{Rouge|Planning }}=
=={{Bleu|Planning prévisionnel }}==

[[Image:taches image.JPG]]

[[Image:gantt image.JPG]]

=={{Bleu|Planning de la semaine d’inter-semestre}}==

[[Image:gantt2.JPG]]

[[Image:planning2.JPG]]

={{Rouge|Carte capteur}}=

=={{Bleu|Procédure des tests }}==

=={{Vert|Procédure manuelle }}==
Ces tests sont basés sur les programmes réalisés lors du projet inter-semestre précédent, en testant le bon fonctionnement des capteurs et des LEDs.

<source lang=c>
char * pos[4] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char ledv[4]={
6,7,9,8};
char ledc[4]={
4,3,2,5};
int i;
void setup(){
for (char i = 0; i < 8; i++) pinMode(i+2, OUTPUT);
Serial.begin(9600);
}

void testlv(){
Serial.println("Parametrer le moniteur serie en 'Pas de fin de ligne'");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledv[i],1);
while (Serial.available() == 0);
char l=Serial.read();
while(Serial.available()>0);
digitalWrite(ledv[i],0);
if(l==0x6F){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(l==0x6E){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void testlc(){
Serial.println("Utiliser l'objectif de votre smartphone pour voir les capteurs");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledc[i],1);
while (Serial.available() == 0);
char m=Serial.read();
while(Serial.available()>0);
digitalWrite(ledc[i],0);
if(m==0x6F){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(m==0x6E){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void tcapteur(){
char led[4]={
4,3,2,5 };
char capt[4]={
A2,A3,A1,A0 };
int i;
Serial.println("Parametrer le moniteur serie en 'retour chariot'");
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
analogReference(DEFAULT);
for(i=0;i<4;i++){
digitalWrite(led[i],0);
int mes=analogRead(capt[i]);
digitalWrite(led[i],1);
delay(5);
int mea=analogRead(capt[i]);
if(mea>(mes*0.95)){
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
else{
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
delay(1000);
}
}

void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}

void loop(){
testlv();
testlc();
Serial.println("Verification des capteurs...");
delay(1000);
tcapteur();
Serial.println("Appuyer sur une touche pour recommencer les tests");
OK();
}

</source>

=={{Vert|Procédure optimisée }}==

Avec cette procédure, les courts-circuits sont détectés, les LEDs et les capteurs sont testés de façon semi-automatique par le programmes ci dessous réalisés lors de notre projet tutorés de ce semestre. l'utilisateur doit seulement déplacer la carte sur différentes surfaces afin de diminuer ou augmenter l'impact des capteurs sur les mesures suivant les besoins.

==={{Bleu|Modification de la carte d'adaptation-Choix de la résistance}}===

[[Image:resistancebakir.png]]
 
Nous avons choisi une résistance la plus grande possible laissant un courant d'environ 4mA traverser une LED, afin de perturber le moins possible le fonctionnement des LEDs. 
Si Vd=2V 
U=((5V-Vd)*R)/R+R1
= 3R/R+680 = (3*120)/800
= 360/800= 0.45V 
R=U/I = 0.45/4*10^-3=112.5 Ohm.
On prendra la résistance normalisée 120 Ohm.

Nous avons modifié la carte d'adaptation en mettant une résistance de 120ohm entre la masse de la carte capteur et la masse de la carte arduino, nous mesurons la tension aux bornes de cette résistance avec l'entrée analogique A4.

[[Image:Capture22.png|cadre|gauche|carte d'adaptation]]

[[Image:Capture11.png|cadre|gauche|schéma de la carte d'adaptation]]

 

==={{Bleu|Sous-programmes }}===

===={{Vert|Test des courts-circuits }}====
Ce test permet de détecter les courts-circuits entre Vcc et la masse.

Si aucune LED n'est allumée et que les capteurs ne sont pas exposés à la lumière, aucun courant ne circule, donc il n'y a aucune tension aux bornes de la résistance de test, si il y a une tension importante, cela signifie qu'il y a un court-circuit entre la masse et l'alimentation.

<source lang=c>

void test_cc(){
int val = analogRead(A4);
if(val>512)
{
Serial.print("court-circuit entre VCC et la masse!!!");
while(1);
}
}
</source>

===={{Vert|Test des LEDs }}====
Ce test permet de détecter un problème ente 2 bornes de la LED , ou si une piste est coupée sur le circuit alimentant la LED .

Pour les LEDs : en fonctionnement normal, la tension aux bornes des LEDs est d'environ 2V, donc la tension aux bornes de notre résistance de test est de ((5-Vd)*Rtest)/(Rtest+R)=(3*120)/(120+680)=0.45V.
Après la conversion analogique, 0.45V donne la valeur 92.

Pour les LEDs infrarouges des capteurs : les récepteurs des capteurs créent une tension lorsqu'on allume les LEDs donc la tension aux bornes dépend aussi de la tension aux bornes des photo-transistors. Nous avons observé les variations des 2 tensions en faisant varier la luminosité, afin de trouver une équation linéaire approximant le fonctionnement des capteurs.
Nous obtenons : U=413 -(20/307) * u2 avec u2 la tension moyenne des capteurs.

Pour limiter l'impact des tensions des capteurs dans les mesures nous placerons les capteurs sur une surface sombre.
Nous prenons une marge de 25 % dans nos calculs afin d’éviter les problèmes de variations de tensions.

<source lang=c>

char * pos[] = {"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={ 4,3,2,5 };
char capt[4]={ A2,A3,A1,A0};
char led[] = {6, 7, 9, 8 };

void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
</source>

===={{Vert|Test des capteurs }}====
Permet de détecter un problème dans les capteurs

♠Si la LED du capteur fonctionne

Si la LED fonctionne, nous pouvons vérifier le fonctionnement en effectuant une mesure avec la LED allumée et une avec la LED éteinte. Si la mesure avec la LED allumée est supérieure à celle de la LED éteinte, cela signifie que le récepteur fonctionne.

<source lang=c>

void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

Si la LED ne fonctionne pas, nous remplaçons la LED allumée par un éclairage fort, pour la LED éteinte, nous plaçons les capteurs sur une surface sombre.

♠Si la LED du capteur ne fonctionne pas
<source lang=c>
char void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

==={{Bleu|Programme final }}===

<source lang=c>
char * pos[] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5}; //adresse des leds des capteurs de gauche à droite
char capt[4]={A2,A3,A1,A0}; //adresse des capteurs de gauche à droite
char led[] = {6, 7, 9, 8 }; //adresse des leds de gauche à droite

boolean err=false; //flag passant à l’état vrai si il y'a un disfonctionnement

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println(" Parametrer le moniteur serie en 'retour chariot'");
test_cc(); //test court-circuit
}

void loop() {
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS(); //si au moins une led de capteur ne fonctionne pas on utilise cette fonction

Serial.println(" ");
if(err==false) Serial.println("Aucun probleme");
err==false;
Serial.println("Test termine");
Serial.println("Taper sur entrer pour recommencer");
Serial.println(" ");
Serial.println(" ");
OK();
}

//////////
void OK() //fonction attendant le caractère retour chariot comme confirmation que l'utilisateur à compris la consigne
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.print("Court-circuit entre VCC et la masse!!!");
while(1);
}
}
//////////
void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
//////////
void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
//////////
void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
</source>

=={{Bleu|Amélioration du programme de la procédure optimisée }}==
Nous avons dévellopé à l'aide de Processing une interface graphique qui faciliterai la recherche de la panne par l'utilisateur, cette interface affiche les problèmes et les consignes comme le moniteur série dans le précédent code, mais elle affiche aussi sur l'image du routage les pistes à vérifier en surbrillance.
De plus, le programme ne nécessite pas de changement de paramètre, donc peut être utilisé indépendamment
de Processing. Pour cela nous utilisons la fonction d'exportation de Processing afin de générer une application utilisable sur tout ordinateur.
Cependant cette methode serait réellement éfficace si toutes les cartes possèdaient le même routage.

Partie Arduino

Pour faciliter la communication, le texte envoyé à la liaison série est remplacé par un nombre.

<source lang=c>

char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5};
char capt[4]={A2,A3,A1,A0};
char led[] = { 6, 7, 9, 8};

boolean err=false;

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println("");
test_cc();
}

void loop() {
for(int i=0; i<4;i++) led_HS[i]=0;
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS();

if(err==false) Serial.println(26);
err=false;

Serial.println(25);
OK();
}

//////////
void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("01");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.println("02");
while(1);
}
}

///////////
void test_led()
{
Serial.println("01");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("0");
Serial.println(i+3);
err=true;
delay(2000);
OK();
}
if(val > 92 * 1.25)
{
Serial.print("0");
Serial.println(i+7);
err=true;
delay(2000);
OK();
}
}

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.println(i+11);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.println(i+15);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
}
}
//////////
void test_capt()
{
int i;
Serial.println(23);
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}
//////////
void test_capt_led_HS() {
int i;
int mes[4], mea[4];
Serial.println("01");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mes[i] = analogRead(capt[i]);

}
}
Serial.println(24);
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}

</source>

Partie Processing

<source lang=c>

import processing.serial.*;
PImage board;
PImage cc;
PImage ledcg;
PImage ledmg;
PImage ledmd;
PImage ledcd;
PImage CNYcg;
PImage CNYmg;
PImage CNYmd;
PImage CNYcd;
PImage captcg;
PImage captmg;
PImage captmd;
PImage captcd;

Serial myPort;
volatile char data[]= new char[255];
volatile int lecture;
volatile int i;
volatile boolean Sel=true; //flag autorisant le mode de fonctionnement sélection du port série
volatile boolean Init=false; //flag autorisant le mode de fonctionnement initialisation du port série
boolean fct=false; //flag autorisant le mode de fonctionnement normal
boolean fin=false; //flag indiquant la fin du test

void setup() {

size(1000, 800);
background(100);
textSize(20);
text("la touche maj est considérée comme un caractère, pour passer en majuscule, tapez ver.maj. puis backspace",10,50,1000,100);
textSize(32);
text("indiquez le port de la carte", 10, 150);

board=loadImage("imgboard.png");// sélection et chargement des images
cc=loadImage("cc.png");
ledcg=loadImage("ledcg.png");
ledmg=loadImage("ledmg.png");
ledmd=loadImage("ledmd.png");
ledcd=loadImage("ledcd.png");
CNYcg=loadImage("CNYcg.png");
CNYmg=loadImage("CNYmg.png");
CNYmd=loadImage("CNYmd.png");
CNYcd=loadImage("CNYcd.png");
captcg=loadImage("captcg.png");
captmg=loadImage("captmg.png");
captmd=loadImage("captmd.png");
captcd=loadImage("captcd.png");

imageMode(CORNERS);
}

void fonctionnement()
{
fill(0);
rect(0, 600, 1000, 200);//efface le précédent texte
fill(255);
switch(lecture) {
//affichage des informations correspondant au code transmis par Arduino
case 1:
text("Placez la carte sur une surface sombre, puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 2:
image(cc, 0, 0, 1000, 600);
text("Il y a un court-circuit entre VCC et la masse!!!", 50, 650, 950, 800);
break;
case 3:
image(ledcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté gauche", 50, 650, 950, 800);
break;
case 4:
image(ledmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu gauche", 50, 650, 950, 800);
break;
case 5:
image(ledmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu droit", 50, 650, 950, 800);
break;
case 6:
image(ledcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté droit", 50, 650, 950, 800);
break;
case 7:
image(ledcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté gauche", 50, 650, 950, 800);
break;
case 8:
image(ledmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu gauche", 50, 650, 950, 800);
break;
case 9:
image(ledmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu droit", 50, 650, 950, 800);
break;
case 10:
image(ledcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté droit", 50, 650, 950, 800);
break;
case 11:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 12:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 13:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu droit", 50, 650, 950, 800);
break;
case 14:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté droit", 50, 650, 950, 800);
break;
case 15:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 16:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 17:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu droit ", 50, 650, 950, 800);
break;
case 18:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté droit", 50, 650, 950, 800);
break;
case 19:
image(captcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté gauche", 50, 650, 950, 800);
break;
case 20:
image(captmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu gauche", 50, 650, 950, 800);
break;
case 21:
image(captmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu droit", 50, 650, 950, 800);
break;
case 22:
image(captcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté droit", 50, 650, 950, 800);
break;
case 23:
text("posez la carte sur une surface claire puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 24:
text("exposez la carte à une lumière forte puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 25:
text("Test terminé\n appuyer sur une touche pour recommencer", 50, 650, 950, 800);
fin=true;
break;
case 26:
text("Aucun problème",150 ,550, 950, 800);
break;
default:
break;
}
}

void draw() {
//partie initialisation du port série
if (Init==true)
{
char nom[]=new char[i];
for (char j=0; j<i; j++) nom[j]=data[j];//stockage des caractères choisi par l'utilisateur dans un tableau
String name = new String(nom);//création d'une chaîne de caractère à partir du tableau
myPort = new Serial(this, name, 9600);//initialisation du port série
myPort.bufferUntil('\n');
background(0);
Init=false;
fct=true;
image(board, 0, 0, 1000, 600);
}
if (fct==true) fonctionnement();
}

void keyPressed() {

//partie utilisée seulement en mode sélection du port série
if (Sel==true) {
if ((key==ENTER)||(key==RETURN)) //validation du choix du port série
{
Init=true;
Sel=false;
} else
{
if (key==BACKSPACE) //efface un caractère
{
data[i]=0;
fill(100);
noStroke();
rect(10+40*(i-1), 168, 32, 140);
fill(255);
i--;
} else {
data[i]=key;
text(data[i], 10+40*i, 200);
i++;
}
}
}

//partie utilisée seulement en fonctionnement normal
if (fct==true)
{
myPort.write(0x0d); //envoie confirmation à Arduino si on appui sur une touche
if (fin==true) //si le test est fini, efface l'écran avant de recommencer
{
image(board, 0, 0, 1000, 600);
fin=false;
}
}
}

void serialEvent(Serial myPort)
{
fill(0);
rect(0, 0, 200, 100);
fill(255);
byte l[]=myPort.readBytesUntil('\n');
lecture=(l[0]-48)*10+(l[1]-48); //conversion de la chaîne de caractère envoyé en un nombre de 2 chiffre
text(lecture, 50, 50);
}

</source>

Pour l'affichage dans l'interface, nous utilisons les images ci-dessous que nous superposons affin d'indiquer toutes les pistes qui nécessitent une vérification d'après le test.

{| class="wikitable"
|-
| || [[Fichier:imgboard.png|200px|thumb|left|imgboard.png]] || [[Fichier:court-circuit.png|200px|thumb|left|cc.png]] ||
|-
| [[Fichier:captcg.png|200px|thumb|left|captcg.png]] || [[Fichier:captmg.png|200px|thumb|left|captmg.png]] || [[Fichier:captmd.png|200px|thumb|left|captmd.png]] || [[Fichier:captcd.png|200px|thumb|left|captcd.png]]
|-
| [[Fichier:CNYcg.png|200px|thumb|left|CNYcg.png]] || [[Fichier:CNYmg.png|200px|thumb|left|CNYmg.png]] || [[Fichier:CNYmd.png|200px|thumb|left|CNYmd.png]] || [[Fichier:CNYcd.png|200px|thumb|left|CNYcd.png]]
|-
| [[Fichier:ledcg.png|200px|thumb|left|ledcg.png]] || [[Fichier:ledmg.png|200px|thumb|left|ledmg.png]] || [[Fichier:ledmd.png|200px|thumb|left|ledmd.png]] || [[Fichier:ledcd.png|200px|thumb|left|ledcd.png]]
|}

Arexx CONQUERANTS

2015-06-21T18:32:07Z

Troyesgeii :

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction}}=

==={{Bleu|Présentation du projet}}===

Le projet à réaliser consiste à faire une série de test sur une carte capteur, issue du projet Arexx qui est un robot suiveur de ligne, déjà fabriquée à l’inter semestre qui s'est déroulé en janvier 2015.
Ces tests devront faire en sorte de valider le bon fonctionnement de la carte capteur, de chaque composant qui sont :

* CNY-70
* LEDS

Pour réaliser ce projet, nous avons formé un groupe de 4 personnes :

* ALZUBAIDI Mahmoud
* LAGOUTTE Quentin
* LANDEVILLE Baptiste
* THOMAS Alexis

={{Rouge|Planning}}=

==={{Bleu|Diagramme de Gantt}}===

[[Image:gantt.jpg]]

={{Rouge|Eagle}}=

==={{Bleu|Schématique et Board}}===

'''Voici des images des fichiers Board et Schéma de la carte capteur du robot, qui vont servir pour le dépannage.'''
[[Image:Schéma_Capteur_Arexx.png]]

={{Rouge|Programmation}}=

==={{Bleu| Tests des LEDS}}===

Ce test consiste à faire allumer la led témoin choisie par l'utilisateur, et donc une fois que l'utilisateur choisi le numéro, allant de 1 à 4 dans l'ordre de la gauche vers la droite.

Si les résultats, qui doivent être observables par l'utilisateur, prouvent que l'une des leds ne fonctionne pas correctement, on se dirige vers la partie 3.3. Tests des Défaillances pour avoir des instructions quant à la réparation.

Si les leds fonctionnent tous correctement, l'utilisateur a le choix de retourner vers le menu principal d'accueil afin de poursuivre les tests de la carte.

<source lang=c>
void led(){
Serial.println(" ");
Serial.println("Test des leds");
Serial.println(" ");
Serial.println("Appuyez sur 1 2 3 ou 4 pour tester la led de votre choix ou 5 pour retourner au menu");
Serial.println("Apre s appui, la led choisie devrait s'allumer pour 2s");
Serial.println(" ");
reception();
switch (rec){
case '1':
Serial.println("led gauche");
digitalWrite(6,1);
delay(2000);
digitalWrite(6,0);
break;
case '2':
Serial.println("led milieu gauche");
digitalWrite(7,1);
delay(2000);
digitalWrite(7,0);
break;
case '3':
Serial.println("led milieu droite");
digitalWrite(5,1);
delay(2000);
digitalWrite(5,0);
break;
case '4':
Serial.println("led droite");
digitalWrite(4,1);
delay(2000);
digitalWrite(4,0);
break;
case '5':
accueil();
default:
led();

}
led();

}
</source>

==={{Bleu| Tests des CNY-70}}===

Le test des capteurs CNY-70, est assez similaire à celui des leds témoins, d'abord on contrôle le fonctionnement des leds infra-rouges de ces capteurs qui agissent comme émetteurs.
Ensuite on test la partie récepteur, et cela est fait en lisant la valeur renvoyé par le pin analogique associé au capteur(compris entre 0 et 1023).

<source lang=c>
void capteur(){
Serial.println(" ");
Serial.println("Test des capteurs");
Serial.println(" ");
Serial.println("Appuyez sur 1 2 3 ou 4 pour tester le capteur de votre choix ou 5 pour retourner au menu");
Serial.println("Placez les capteurs contre une surface sombre");
Serial.println(" ");
reception();
digitalWrite(0,1);
digitalWrite(1,1);
digitalWrite(2,1);
digitalWrite(3,1);
switch (rec){
case '1':
Serial.println("capteur gauche");
Serial.println(" ");
digitalWrite(1,1);
val = analogRead(A1);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;
case '2':
Serial.println("capteur milieu gauche");
Serial.println(" ");
val = analogRead(A0);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;
case '3':
Serial.println("capteur milieu droit");
Serial.println(" ");
val = analogRead(A2);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;
case '4':
Serial.println("capteur droit");
Serial.println(" ");
val = analogRead(A3);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;
case '5':
accueil();
default:
capteur();
}
capteur();
}
</source>

==={{Bleu| Tests des défaillances}}===

Lors des différents tests, il est probable qu'on rencontre des problèmes avec les capteurs ou les leds témoins du robot Arexx.

Cette section détaille les différentes manipulations à effectuer dans ce cas.

En effet, pour les leds témoins frontales du robot ou les capteurs CNY-70 , si l'un d'entre eux se trouve en panne lors du test :

- Vérifier que les deux pattes sont bien soudés et touchent bien la piste qui lui est associé(à voir sur le fichier board).

- Contrôler la validité des pistes auxquelles sont reliés les leds à l'aide d'un multimètre, l'erreur peut être un court-circuit ou que la piste soit coupée.

- Assurer vous du bon fonctionnement des composants reliés aux leds ou aux capteurs, que ce soit des résistances ou des transistors.

- Examiner les trois connecteurs présents sur la carte, et tester la connexion des pattes avec les pistes qui leur correspondent.

- Confirmer si le plan de masse n'empêche pas certaines connexions, surtout au niveau des connecteurs.

Enfin, après avoir effectué toutes les manipulations précédentes, vous trouvez que votre capteur et/ou led ne fonctionne pas, cela peut signifier que le composant lui même est défaillant et qu'il faudra donc le remplacer.

==={{Bleu| Test complet}}===
<source lang=c>
int rec;
int val;

void setup() {
for(int i=0;i<7;i++){
pinMode(i,OUTPUT);
}
DDRC = 0x00;
Serial.begin(9600);
accueil();
}

void reception(){
while(Serial.available() == 0);
if (Serial.available() > 0){
rec = Serial.read();
}
}

void accueil(){
boolean flagaccueil = true;
Serial.println(" ");
Serial.println("Tests de la carte capteur");
Serial.println(" ");
Serial.println("Appuyez sur 0 pour les tests des leds");
Serial.println("Appuyez sur 1 pour les test des capteurs");
Serial.println(" ");
reception();
if((rec == '0')&&(flagaccueil == true)){
led();
flagaccueil = false;
}
if((rec == '1')&&(flagaccueil == true)){
capteur();
flagaccueil = false;
}
else {

accueil();
}
}

void led(){
Serial.println(" ");
Serial.println("Test des leds");
Serial.println(" ");
Serial.println("Appuyez sur 1 2 3 ou 4 pour tester la led de votre choix ou 5 pour retourner au menu");
Serial.println("Apre s appui, la led choisie devrait s'allumer pour 2s");
Serial.println(" ");
reception();
switch (rec){
case '1':
Serial.println("led gauche");
digitalWrite(6,1);
delay(2000);
digitalWrite(6,0);
break;
case '2':
Serial.println("led milieu gauche");
digitalWrite(7,1);
delay(2000);
digitalWrite(7,0);
break;
case '3':
Serial.println("led milieu droite");
digitalWrite(5,1);
delay(2000);
digitalWrite(5,0);
break;
case '4':
Serial.println("led droite");
digitalWrite(4,1);
delay(2000);
digitalWrite(4,0);
break;
case '5':
accueil();
default:
led();
}
led();

}

void capteur(){
Serial.println(" ");
Serial.println("Test des capteurs");
Serial.println(" ");
Serial.println("Appuyez sur 1 2 3 ou 4 pour tester le capteur de votre choix ou 5 pour retourner au menu");
Serial.println("Placez les capteurs contre une surface sombre");
Serial.println(" ");
reception();
digitalWrite(0,1);
digitalWrite(1,1);
digitalWrite(2,1);
digitalWrite(3,1);
switch (rec){
case '1':
Serial.println("capteur gauche");
Serial.println(" ");
digitalWrite(1,1);
val = analogRead(A1);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;

case '2':
Serial.println("capteur milieu gauche");
Serial.println(" ");
val = analogRead(A0);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;

case '3':
Serial.println("capteur milieu droit");
Serial.println(" ");
val = analogRead(A2);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;

case '4':
Serial.println("capteur droit");
Serial.println(" ");
val = analogRead(A3);
if(val > 500)
{
Serial.println("Le capteur fonctionne");
}
else {
Serial.println("Le capteur a un dysfonctionnement");
}
break;

case '5':
accueil();
default:
capteur();
}
capteur();
}

void loop()
{
}

</source>

Arexx MENAHO

2015-06-21T16:58:06Z

Troyesgeii : /* {{Rouge|Cahier de dépannage}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Partie Fonctionnement global}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
 
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
 
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
 
Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-21T16:57:39Z

Troyesgeii : /* {{Rouge|Cahier de dépannage}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Partie Fonctionnement global}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
Si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.
Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-21T16:52:49Z

Troyesgeii : /* {{Rouge|Cahier de dépannage}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Partie Fonctionnement global}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre. si cas présent, séparer les deux pistes à l'aide d'un cutter.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre. Si cas présent, souder un fil pour relier les deux parties de la piste
* Composant mal soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.Si les composants sont mal soudés, les ressouder.

Arexx MENAHO

2015-06-21T14:32:19Z

Troyesgeii : ntt/* {{Rouge|Diagramme de Gantt}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png
</gallery>

={{Rouge|Programme de test et explications}}=

==={{Rouge|Partie Fonctionnement global}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
* Composant bien soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.

Arexx MENAHO

2015-06-21T14:30:41Z

Troyesgeii :

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=

={{Rouge|Programme de test et explications}}=

==={{Rouge|Partie Fonctionnement global}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
* Composant bien soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.

Arexx MENAHO

2015-06-21T14:23:33Z

Troyesgeii : /* {{Rouge|Diagramme de Gantt}} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Présentation du projet}}=

={{Rouge|Diagramme de Gantt}}=
<gallery>
Fichier:diagramme gantt.png

={{Rouge|Programme de test et explications}}=

==={{Rouge|Partie Fonctionnement global}}===

<source lang=c>
int A,B,C,D;
char choix=0;
void setup(){ Serial.begin(9600);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
}
void menu()
{ delay(1);
Serial.println("Bienvenue dans le programme de test de la carte capteur");
Serial.println(" ");
Serial.println("Taper 1 - Test des leds temoins");
Serial.println("Taper 2 - Test des leds des cny70");
Serial.println("Taper 3 - Test du fonctionnement led-capteur");
Serial.println(" ");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')
{
led();
}
if(choix=='2')
{
ledcny();
}
if(choix=='3')
{
total();
}
if(choix=='4')
{
menu();
}
}

void led() // allume toutes les leds temoins
{
Serial.println("Test des leds temoins");
Serial.println("Les quatre leds temoins doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
digitalWrite(5,1);
digitalWrite(4,1);
digitalWrite(6,1);
digitalWrite(7,1);
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void ledcny()
{
Serial.println("Test des leds des cny70");
Serial.println("Regarder les leds des cny70 avec un appareil photo");
Serial.println("Elles doivent toutes etre allume");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while(Serial.available() == 0);
choix=Serial.read();
if(choix=='1')menu();
}

void total()
{
Serial.println("Test du fonctionnement led-capteur");
Serial.println("Masquer les CNY un a un");
Serial.println("Les leds correspondantes doivent s'allumer");
Serial.println("Sinon, se referer au cahier de depannage");
Serial.println(" ");
Serial.println("taper 1 pour revenir au menu");
Serial.println(" ");
while( (Serial.available() == 0) && (choix != 1) )
{
digitalWrite(8,1);
digitalWrite(9,1);
digitalWrite(2,1);
digitalWrite(3,1);
// Serial.print("Milieu Gauche : ");
// Serial.println(analogRead(A0),DEC);
// Serial.print("Cote Gauche : ");
// Serial.println(analogRead(A1),DEC);
// Serial.print("Milieu Droit : ");
// Serial.println(analogRead(A2),DEC);
// Serial.print("Cote Droit : ");
// Serial.println(analogRead(A3),DEC);
A = analogRead(A0);
B = analogRead(A1);
C = analogRead(A2);
D = analogRead(A3);
if ( A <= 500)
{
digitalWrite(5,1) ;
}
else
{
digitalWrite(5,0) ;
}
if ( B <=500)
{
digitalWrite(4,1) ;
}
else
{
digitalWrite(4,0) ;
}
if (D <=500)
{
digitalWrite(6,1) ;
}
else
{
digitalWrite(6,0) ;
}
if (C <=500)
{
digitalWrite(7,1) ;
}
else
{
digitalWrite(7,0) ;
}
delay(100);
choix=Serial.read();
if(choix=='1')
{
menu();
}
}
}

void loop()
{
menu();
}

</source>

={{Rouge|Cahier de dépannage}}=
 
* LED défaillante :

Remplacer la LED défaillante
* Court-circuit :

Vérifier que la piste ne touche pas une soudure ou une autre piste à l’aide d’un multimètre.
* Piste coupée :

Vérifier qu’il n’y a pas de fissure sur la piste et contrôler à l’aide d’un multimètre.
* Composant bien soudé :

Vérifier que les composants sont bien soudés à l’aide d’une loupe et d’un multimètre en testant la connexion entre les pattes et la piste et vérifier qu’ils sont sur les bons emplacements grâce au board eagle.

Fichier:Diagramme gantt.png

2015-06-21T14:21:22Z

Troyesgeii :

Arexx MENAHO

2015-06-21T14:16:41Z

Troyesgeii : /* {{Rouge|Cahier de dépannage}} */

Fichier:TOPethan.png

2015-06-20T19:56:18Z

Troyesgeii : Ethan a importé une nouvelle version de « Fichier:TOPethan.png »

Fichier:TOPethan.png

2015-06-20T19:54:22Z

Troyesgeii :

Fichier:BOTTOMethan.png

2015-06-20T19:29:48Z

Troyesgeii :

Fichier:EagleschEthan.png

2015-06-20T18:58:04Z

Troyesgeii :

Fichier:Eaglebrdethan.png

2015-06-20T18:57:49Z

Troyesgeii :

Fichier:Programmecapteurs.jpg

2015-06-20T18:37:53Z

Troyesgeii :

Fichier:Programmemoteurs.jpg

2015-06-20T18:37:26Z

Troyesgeii :

Fichier:Cone30°.png

2015-06-20T18:14:27Z

Troyesgeii :

Fichier:Capteursultrason.png

2015-06-20T18:07:24Z

Troyesgeii :

Fichier:Conedetection.png

2015-06-20T18:05:39Z

Troyesgeii :

Fichier:Principedefct.png

2015-06-20T17:55:18Z

Troyesgeii :

Fichier:Sonarethan.jpg

2015-06-20T17:51:18Z

Troyesgeii :

Arexx SUPERHEROS

2015-06-20T14:51:32Z

Troyesgeii : /* {{Vert|Procédure optimisée }} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction-Présentation du projet}}=

Au cours du précédent semestre, nous avons eu à concevoir un robot suiveur de ligne sur un châssis Arexx constitué d'une carte capteur et d'une carte gestion. Nous avons également dû réaliser une carte d’adaptation afin de relier directement la carte capteur à une carte ARDUINO. Nous avons aussi écrit des programmes pour tester les capteurs et les LEDs, suite à cela notre projet actuel consiste à écrire un programme permettant de détecter les pannes sur la carte capteur du robot Arexx et une possibilité de modifier la carte d’adaptation.

={{Rouge|Présentation du cahier des charges}}=

♦Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.

♦Possibilité de modification de la carte d'adaptation.

♦Fabrication de la carte gestion.

♦ Réalisation des programmes permettant le fonctionnement de la carte gestion.

♣ Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.

={{Rouge|Planning }}=
=={{Bleu|Planning prévisionnel }}==

[[Image:taches image.JPG]]

[[Image:gantt image.JPG]]

=={{Bleu|Planning de la semaine d’inter-semestre}}==

[[Image:gantt2.JPG]]

[[Image:planning2.JPG]]

={{Rouge|Carte capteur}}=

=={{Bleu|Procédure des tests }}==

=={{Vert|Procédure manuelle }}==
Ces tests sont basés sur les programmes réalisés lors du projet inter-semestre précédent, en testant le bon fonctionnement des capteurs et des LEDs.

<source lang=c>
char * pos[4] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char ledv[4]={
6,7,9,8};
char ledc[4]={
4,3,2,5};
int i;
void setup(){
for (char i = 0; i < 8; i++) pinMode(i+2, OUTPUT);
Serial.begin(9600);
}

void testlv(){
Serial.println("Parametrer le moniteur serie en 'Pas de fin de ligne'");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledv[i],1);
while (Serial.available() == 0);
char l=Serial.read();
while(Serial.available()>0);
digitalWrite(ledv[i],0);
if(l==0x6F){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(l==0x6E){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void testlc(){
Serial.println("Utiliser l'objectif de votre smartphone pour voir les capteurs");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledc[i],1);
while (Serial.available() == 0);
char m=Serial.read();
while(Serial.available()>0);
digitalWrite(ledc[i],0);
if(m==0x6F){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(m==0x6E){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void tcapteur(){
char led[4]={
4,3,2,5 };
char capt[4]={
A2,A3,A1,A0 };
int i;
Serial.println("Parametrer le moniteur serie en 'retour chariot'");
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
analogReference(DEFAULT);
for(i=0;i<4;i++){
digitalWrite(led[i],0);
int mes=analogRead(capt[i]);
digitalWrite(led[i],1);
delay(5);
int mea=analogRead(capt[i]);
if(mea>(mes*0.95)){
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
else{
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
delay(1000);
}
}

void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}

void loop(){
testlv();
testlc();
Serial.println("Verification des capteurs...");
delay(1000);
tcapteur();
Serial.println("Appuyer sur une touche pour recommencer les tests");
OK();
}

</source>

=={{Vert|Procédure optimisée }}==

Avec cette procédure, les courts-circuits sont détectés, les LEDs et les capteurs sont testés de façon semi-automatique par le programmes ci dessous réalisés lors de notre projet tutorés de ce semestre. l'utilisateur doit seulement déplacer la carte sur différentes surfaces afin de diminuer ou augmenter l'impact des capteurs sur les mesures suivant les besoins.

==={{Bleu|Modification de la carte d'adaptation-Choix de la résistance}}===

[[Image:resistancebakir.png]]
 
Nous avons choisi une résistance la plus grande possible laissant un courant d'environ 4mA traverser une LED, afin de perturber le moins possible le fonctionnement des LEDs. 
Si Vd=2V 
U=((5V-Vd)*R)/R+R1
= 3R/R+680 = (3*120)/800
= 360/800= 0.45V 
R=U/I = 0.45/4*10^-3=112.5 Ohm.
On prendra la résistance normalisée 120 Ohm.

Nous avons modifié la carte d'adaptation en mettant une résistance de 120ohm entre la masse de la carte capteur et la masse de la carte arduino, nous mesurons la tension aux bornes de cette résistance avec l'entrée analogique A4.

[[Image:Capture22.png|cadre|gauche|carte d'adaptation]]

[[Image:Capture11.png|cadre|gauche|schéma de la carte d'adaptation]]

 

==={{Bleu|Sous-programmes }}===

===={{Vert|Test des courts-circuits }}====
Ce test permet de détecter les courts-circuits entre Vcc et la masse.

Si aucune LED n'est allumée et que les capteurs ne sont pas exposés à la lumière, aucun courant ne circule, donc il n'y a aucune tension aux bornes de la résistance de test, si il y a une tension importante, cela signifie qu'il y a un court-circuit entre la masse et l'alimentation.

<source lang=c>

void test_cc(){
int val = analogRead(A4);
if(val>512)
{
Serial.print("court-circuit entre VCC et la masse!!!");
while(1);
}
}
</source>

===={{Vert|Test des LEDs }}====
Ce test permet de détecter un problème ente 2 bornes de la LED , ou si une piste est coupée sur le circuit alimentant la LED .

Pour les LEDs : en fonctionnement normal, la tension aux bornes des LEDs est d'environ 2V, donc la tension aux bornes de notre résistance de test est de ((5-Vd)*Rtest)/(Rtest+R)=(3*120)/(120+680)=0.45V.
Après la conversion analogique, 0.45V donne la valeur 92.

Pour les LEDs infrarouges des capteurs : les récepteurs des capteurs créent une tension lorsqu'on allume les LEDs donc la tension aux bornes dépend aussi de la tension aux bornes des photo-transistors. Nous avons observé les variations des 2 tensions en faisant varier la luminosité, afin de trouver une équation linéaire approximant le fonctionnement des capteurs.
Nous obtenons : U=413 -(20/307) * u2 avec u2 la tension moyenne des capteurs.

Pour limiter l'impact des tensions des capteurs dans les mesures nous placerons les capteurs sur une surface sombre.
Nous prenons une marge de 25 % dans nos calculs afin d’éviter les problèmes de variations de tensions.

<source lang=c>

char * pos[] = {"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={ 4,3,2,5 };
char capt[4]={ A2,A3,A1,A0};
char led[] = {6, 7, 9, 8 };

void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
</source>

===={{Vert|Test des capteurs }}====
Permet de détecter un problème dans les capteurs

♠Si la LED du capteur fonctionne

Si la LED fonctionne, nous pouvons vérifier le fonctionnement en effectuant une mesure avec la LED allumée et une avec la LED éteinte. Si la mesure avec la LED allumée est supérieure à celle de la LED éteinte, cela signifie que le récepteur fonctionne.

<source lang=c>

void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

Si la LED ne fonctionne pas, nous remplaçons la LED allumée par un éclairage fort, pour la LED éteinte, nous plaçons les capteurs sur une surface sombre.

♠Si la LED du capteur ne fonctionne pas
<source lang=c>
char void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

==={{Bleu|Programme final }}===

<source lang=c>
char * pos[] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5}; //adresse des leds des capteurs de gauche à droite
char capt[4]={A2,A3,A1,A0}; //adresse des capteurs de gauche à droite
char led[] = {6, 7, 9, 8 }; //adresse des leds de gauche à droite

boolean err=false; //flag passant à l’état vrai si il y'a un disfonctionnement

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println(" Parametrer le moniteur serie en 'retour chariot'");
test_cc(); //test court-circuit
}

void loop() {
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS(); //si au moins une led de capteur ne fonctionne pas on utilise cette fonction

Serial.println(" ");
if(err==false) Serial.println("Aucun probleme");
err==false;
Serial.println("Test termine");
Serial.println("Taper sur entrer pour recommencer");
Serial.println(" ");
Serial.println(" ");
OK();
}

//////////
void OK() //fonction attendant le caractère retour chariot comme confirmation que l'utilisateur à compris la consigne
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.print("Court-circuit entre VCC et la masse!!!");
while(1);
}
}
//////////
void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
//////////
void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
//////////
void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
</source>

=={{Bleu|Amélioration du programme de la procédure optimisée }}==
Nous avons dévellopé à l'aide de Processing une interface graphique qui faciliterai la recherche de la panne par l'utilisateur, cette interface affiche les problèmes et les consignes comme le moniteur série dans le précédent code, mais elle affiche aussi sur l'image du routage les pistes à vérifier en surbrillance.
De plus, le programme ne nécessite pas de changement de paramètre, donc peut être utilisé indépendamment
de Processing. Pour cela nous utilisons la fonction d'exportation de Processing afin de générer une application utilisable sur tout ordinateur.
Cependant cette methode serait réellement éfficace si toutes les cartes possèdaient le même routage.

Partie Arduino

Pour faciliter la communication, le texte envoyé à la liaison série est remplacé par un nombre.

<source lang=c>

char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5};
char capt[4]={A2,A3,A1,A0};
char led[] = { 6, 7, 9, 8};

boolean err=false;

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println("");
test_cc();
}

void loop() {
for(int i=0; i<4;i++) led_HS[i]=0;
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS();

if(err==false) Serial.println(26);
err=false;

Serial.println(25);
OK();
}

//////////
void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("01");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.println("02");
while(1);
}
}

///////////
void test_led()
{
Serial.println("01");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("0");
Serial.println(i+3);
err=true;
delay(2000);
OK();
}
if(val > 92 * 1.25)
{
Serial.print("0");
Serial.println(i+7);
err=true;
delay(2000);
OK();
}
}

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.println(i+11);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.println(i+15);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
}
}
//////////
void test_capt()
{
int i;
Serial.println(23);
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}
//////////
void test_capt_led_HS() {
int i;
int mes[4], mea[4];
Serial.println("01");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mes[i] = analogRead(capt[i]);

}
}
Serial.println(24);
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}

</source>

Partie Processing

<source lang=c>

import processing.serial.*;
PImage board;
PImage cc;
PImage ledcg;
PImage ledmg;
PImage ledmd;
PImage ledcd;
PImage CNYcg;
PImage CNYmg;
PImage CNYmd;
PImage CNYcd;
PImage captcg;
PImage captmg;
PImage captmd;
PImage captcd;

Serial myPort;
volatile char data[]= new char[255];
volatile int lecture;
volatile int i;
volatile boolean Sel=true; //flag autorisant le mode de fonctionnement sélection du port série
volatile boolean Init=false; //flag autorisant le mode de fonctionnement initialisation du port série
boolean fct=false; //flag autorisant le mode de fonctionnement normal
boolean fin=false; //flag indiquant la fin du test

void setup() {

size(1000, 800);
background(100);
textSize(20);
text("la touche maj est considérée comme un caractère, pour passer en majuscule, tapez ver.maj. puis backspace",10,50,1000,100);
textSize(32);
text("indiquez le port de la carte", 10, 150);

board=loadImage("imgboard.png");// sélection et chargement des images
cc=loadImage("cc.png");
ledcg=loadImage("ledcg.png");
ledmg=loadImage("ledmg.png");
ledmd=loadImage("ledmd.png");
ledcd=loadImage("ledcd.png");
CNYcg=loadImage("CNYcg.png");
CNYmg=loadImage("CNYmg.png");
CNYmd=loadImage("CNYmd.png");
CNYcd=loadImage("CNYcd.png");
captcg=loadImage("captcg.png");
captmg=loadImage("captmg.png");
captmd=loadImage("captmd.png");
captcd=loadImage("captcd.png");

imageMode(CORNERS);
}

void fonctionnement()
{
fill(0);
rect(0, 600, 1000, 200);//efface le précédent texte
fill(255);
switch(lecture) {
//affichage des informations correspondant au code transmis par Arduino
case 1:
text("Placez la carte sur une surface sombre, puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 2:
image(cc, 0, 0, 1000, 600);
text("Il y a un court-circuit entre VCC et la masse!!!", 50, 650, 950, 800);
break;
case 3:
image(ledcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté gauche", 50, 650, 950, 800);
break;
case 4:
image(ledmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu gauche", 50, 650, 950, 800);
break;
case 5:
image(ledmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu droit", 50, 650, 950, 800);
break;
case 6:
image(ledcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté droit", 50, 650, 950, 800);
break;
case 7:
image(ledcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté gauche", 50, 650, 950, 800);
break;
case 8:
image(ledmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu gauche", 50, 650, 950, 800);
break;
case 9:
image(ledmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu droit", 50, 650, 950, 800);
break;
case 10:
image(ledcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté droit", 50, 650, 950, 800);
break;
case 11:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 12:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 13:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu droit", 50, 650, 950, 800);
break;
case 14:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté droit", 50, 650, 950, 800);
break;
case 15:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 16:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 17:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu droit ", 50, 650, 950, 800);
break;
case 18:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté droit", 50, 650, 950, 800);
break;
case 19:
image(captcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté gauche", 50, 650, 950, 800);
break;
case 20:
image(captmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu gauche", 50, 650, 950, 800);
break;
case 21:
image(captmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu droit", 50, 650, 950, 800);
break;
case 22:
image(captcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté droit", 50, 650, 950, 800);
break;
case 23:
text("posez la carte sur une surface claire puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 24:
text("exposez la carte à une lumière forte puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 25:
text("Test terminé\n appuyer sur une touche pour recommencer", 50, 650, 950, 800);
fin=true;
break;
case 26:
text("Aucun problème",150 ,550, 950, 800);
break;
default:
break;
}
}

void draw() {
//partie initialisation du port série
if (Init==true)
{
char nom[]=new char[i];
for (char j=0; j<i; j++) nom[j]=data[j];//stockage des caractères choisi par l'utilisateur dans un tableau
String name = new String(nom);//création d'une chaîne de caractère à partir du tableau
myPort = new Serial(this, name, 9600);//initialisation du port série
myPort.bufferUntil('\n');
background(0);
Init=false;
fct=true;
image(board, 0, 0, 1000, 600);
}
if (fct==true) fonctionnement();
}

void keyPressed() {

//partie utilisée seulement en mode sélection du port série
if (Sel==true) {
if ((key==ENTER)||(key==RETURN)) //validation du choix du port série
{
Init=true;
Sel=false;
} else
{
if (key==BACKSPACE) //efface un caractère
{
data[i]=0;
fill(100);
noStroke();
rect(10+40*(i-1), 168, 32, 140);
fill(255);
i--;
} else {
data[i]=key;
text(data[i], 10+40*i, 200);
i++;
}
}
}

//partie utilisée seulement en fonctionnement normal
if (fct==true)
{
myPort.write(0x0d); //envoie confirmation à Arduino si on appui sur une touche
if (fin==true) //si le test est fini, efface l'écran avant de recommencer
{
image(board, 0, 0, 1000, 600);
fin=false;
}
}
}

void serialEvent(Serial myPort)
{
fill(0);
rect(0, 0, 200, 100);
fill(255);
byte l[]=myPort.readBytesUntil('\n');
lecture=(l[0]-48)*10+(l[1]-48); //conversion de la chaîne de caractère envoyé en un nombre de 2 chiffre
text(lecture, 50, 50);
}

</source>

Pour l'affichage dans l'interface, nous utilisons les images ci-dessous que nous superposons affin d'indiquer toutes les pistes qui nécessitent une vérification d'après le test.

{| class="wikitable"
|-
| || [[Fichier:imgboard.png|200px|thumb|left|imgboard.png]] || [[Fichier:court-circuit.png|200px|thumb|left|cc.png]] ||
|-
| [[Fichier:captcg.png|200px|thumb|left|captcg.png]] || [[Fichier:captmg.png|200px|thumb|left|captmg.png]] || [[Fichier:captmd.png|200px|thumb|left|captmd.png]] || [[Fichier:captcd.png|200px|thumb|left|captcd.png]]
|-
| [[Fichier:CNYcg.png|200px|thumb|left|CNYcg.png]] || [[Fichier:CNYmg.png|200px|thumb|left|CNYmg.png]] || [[Fichier:CNYmd.png|200px|thumb|left|CNYmd.png]] || [[Fichier:CNYcd.png|200px|thumb|left|CNYcd.png]]
|-
| [[Fichier:ledcg.png|200px|thumb|left|ledcg.png]] || [[Fichier:ledmg.png|200px|thumb|left|ledmg.png]] || [[Fichier:ledmd.png|200px|thumb|left|ledmd.png]] || [[Fichier:ledcd.png|200px|thumb|left|ledcd.png]]
|}

Arexx SUPERHEROS

2015-06-20T14:43:52Z

Troyesgeii : /* {{Bleu|Amélioration du programme de la procédure optimisée }} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction-Présentation du projet}}=

Au cours du précédent semestre, nous avons eu à concevoir un robot suiveur de ligne sur un châssis Arexx constitué d'une carte capteur et d'une carte gestion. Nous avons également dû réaliser une carte d’adaptation afin de relier directement la carte capteur à une carte ARDUINO. Nous avons aussi écrit des programmes pour tester les capteurs et les LEDs, suite à cela notre projet actuel consiste à écrire un programme permettant de détecter les pannes sur la carte capteur du robot Arexx et une possibilité de modifier la carte d’adaptation.

={{Rouge|Présentation du cahier des charges}}=

♦Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.

♦Possibilité de modification de la carte d'adaptation.

♦Fabrication de la carte gestion.

♦ Réalisation des programmes permettant le fonctionnement de la carte gestion.

♣ Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.

={{Rouge|Planning }}=
=={{Bleu|Planning prévisionnel }}==

[[Image:taches image.JPG]]

[[Image:gantt image.JPG]]

=={{Bleu|Planning de la semaine d’inter-semestre}}==

[[Image:gantt2.JPG]]

[[Image:planning2.JPG]]

={{Rouge|Carte capteur}}=

=={{Bleu|Procédure des tests }}==

=={{Vert|Procédure manuelle }}==
Ces tests sont basés sur les programmes réalisés lors du projet inter-semestre précédent, en testant le bon fonctionnement des capteurs et des LEDs.

<source lang=c>
char * pos[4] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char ledv[4]={
6,7,9,8};
char ledc[4]={
4,3,2,5};
int i;
void setup(){
for (char i = 0; i < 8; i++) pinMode(i+2, OUTPUT);
Serial.begin(9600);
}

void testlv(){
Serial.println("Parametrer le moniteur serie en 'Pas de fin de ligne'");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledv[i],1);
while (Serial.available() == 0);
char l=Serial.read();
while(Serial.available()>0);
digitalWrite(ledv[i],0);
if(l==0x6F){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(l==0x6E){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void testlc(){
Serial.println("Utiliser l'objectif de votre smartphone pour voir les capteurs");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledc[i],1);
while (Serial.available() == 0);
char m=Serial.read();
while(Serial.available()>0);
digitalWrite(ledc[i],0);
if(m==0x6F){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(m==0x6E){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void tcapteur(){
char led[4]={
4,3,2,5 };
char capt[4]={
A2,A3,A1,A0 };
int i;
Serial.println("Parametrer le moniteur serie en 'retour chariot'");
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
analogReference(DEFAULT);
for(i=0;i<4;i++){
digitalWrite(led[i],0);
int mes=analogRead(capt[i]);
digitalWrite(led[i],1);
delay(5);
int mea=analogRead(capt[i]);
if(mea>(mes*0.95)){
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
else{
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
delay(1000);
}
}

void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}

void loop(){
testlv();
testlc();
Serial.println("Verification des capteurs...");
delay(1000);
tcapteur();
Serial.println("Appuyer sur une touche pour recommencer les tests");
OK();
}

</source>

=={{Vert|Procédure optimisée }}==

Avec cette procedure, les courts-circuits sont détéctés, les LEDs et les capteurs sont testés de façon semi-automatique par le programmes ci dessous réalisés lors de notre projet tutorés de ce semestre. l'utilisateur doit seulement deplacer la carte sur différentes surfaces afin de diminuer ou augmenter l'impact des capteurs sur les mesures suivant les besoins.

==={{Bleu|Modification de la carte d'adaptation-Choix de la résistance}}===

[[Image:resistancebakir.png]]
 
Nous avons choisi une résistance la plus grande possible laissant un courant d'environ 4mA traverser une LED, afin de perturber le moins possible le fonctionnement des LEDs. 
Si Vd=2V 
U=((5V-Vd)*R)/R+R1
= 3R/R+680 = (3*120)/800
= 360/800= 0.45V 
R=U/I = 0.45/4*10^-3=112.5 Ohm.
On prendra la résistance normalisée 120 Ohm.

Nous avons modifié la carte d'adaptation en mettant une résistance de 120ohm entre la masse de la carte capteur et la masse de la carte arduino, nous mesurons la tension aux bornes de cette résistance avec l'entrée analogique A4.

[[Image:Capture22.png|cadre|gauche|carte d'adaptation]]

[[Image:Capture11.png|cadre|gauche|schéma de la carte d'adaptation]]

 

==={{Bleu|Sous-programmes }}===

===={{Vert|Test des courts-circuits }}====
Ce test permet de détecter les courts-circuits entre Vcc et la masse.

Si aucune LED n'est allumée et que les capteurs ne sont pas exposés à la lumière, aucun courant ne circule, donc il n'y a aucune tension aux bornes de la résistance de test, si il y a une tension importante, cela signifie qu'il y a un court-circuit entre la masse et l'alimentation.

<source lang=c>

void test_cc(){
int val = analogRead(A4);
if(val>512)
{
Serial.print("court-circuit entre VCC et la masse!!!");
while(1);
}
}
</source>

===={{Vert|Test des LEDs }}====
Ce test permet de détecter un problème ente 2 bornes de la LED , ou si une piste est coupée sur le circuit alimentant la LED .

Pour les LEDs : en fonctionnement normal, la tension aux bornes des LEDs est d'environ 2V, donc la tension aux bornes de notre résistance de test est de ((5-Vd)*Rtest)/(Rtest+R)=(3*120)/(120+680)=0.45V.
Après la conversion analogique, 0.45V donne la valeur 92.

Pour les LEDs infrarouges des capteurs : les récepteurs des capteurs créent une tension lorsqu'on allume les LEDs donc la tension aux bornes dépend aussi de la tension aux bornes des photo-transistors. Nous avons observé les variations des 2 tensions en faisant varier la luminosité, afin de trouver une équation linéaire approximant le fonctionnement des capteurs.
Nous obtenons : U=413 -(20/307) * u2 avec u2 la tension moyenne des capteurs.

Pour limiter l'impact des tensions des capteurs dans les mesures nous placerons les capteurs sur une surface sombre.
Nous prenons une marge de 25 % dans nos calculs afin d’éviter les problèmes de variations de tensions.

<source lang=c>

char * pos[] = {"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={ 4,3,2,5 };
char capt[4]={ A2,A3,A1,A0};
char led[] = {6, 7, 9, 8 };

void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
</source>

===={{Vert|Test des capteurs }}====
Permet de détecter un problème dans les capteurs

♠Si la LED du capteur fonctionne

Si la LED fonctionne, nous pouvons vérifier le fonctionnement en effectuant une mesure avec la LED allumée et une avec la LED éteinte. Si la mesure avec la LED allumée est supérieure à celle de la LED éteinte, cela signifie que le récepteur fonctionne.

<source lang=c>

void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

Si la LED ne fonctionne pas, nous remplaçons la LED allumée par un éclairage fort, pour la LED éteinte, nous plaçons les capteurs sur une surface sombre.

♠Si la LED du capteur ne fonctionne pas
<source lang=c>
char void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

==={{Bleu|Programme final }}===

<source lang=c>
char * pos[] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5}; //adresse des leds des capteurs de gauche à droite
char capt[4]={A2,A3,A1,A0}; //adresse des capteurs de gauche à droite
char led[] = {6, 7, 9, 8 }; //adresse des leds de gauche à droite

boolean err=false; //flag passant à l'etat vrai si il y'a un disfonctionnement

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println(" Parametrer le moniteur serie en 'retour chariot'");
test_cc(); //test court-circuit
}

void loop() {
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS(); //si au moins une led de capteur ne fonctionne pas on utillise cette fonction

Serial.println(" ");
if(err==false) Serial.println("Aucun probleme");
err==false;
Serial.println("Test termine");
Serial.println("Taper sur entrer pour recommencer");
Serial.println(" ");
Serial.println(" ");
OK();
}

//////////
void OK() //fonction attendant le caractère retour chariot comme confirmation que l'utilisateur à compris la consigne
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.print("Court-circuit entre VCC et la masse!!!");
while(1);
}
}
//////////
void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
//////////
void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
//////////
void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
</source>

=={{Bleu|Amélioration du programme de la procédure optimisée }}==
Nous avons dévellopé à l'aide de Processing une interface graphique qui faciliterai la recherche de la panne par l'utilisateur, cette interface affiche les problèmes et les consignes comme le moniteur série dans le précédent code, mais elle affiche aussi sur l'image du routage les pistes à vérifier en surbrillance.
De plus, le programme ne nécessite pas de changement de paramètre, donc peut être utilisé indépendamment
de Processing. Pour cela nous utilisons la fonction d'exportation de Processing afin de générer une application utilisable sur tout ordinateur.
Cependant cette methode serait réellement éfficace si toutes les cartes possèdaient le même routage.

Partie Arduino

Pour faciliter la communication, le texte envoyé à la liaison série est remplacé par un nombre.

<source lang=c>

char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5};
char capt[4]={A2,A3,A1,A0};
char led[] = { 6, 7, 9, 8};

boolean err=false;

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println("");
test_cc();
}

void loop() {
for(int i=0; i<4;i++) led_HS[i]=0;
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS();

if(err==false) Serial.println(26);
err=false;

Serial.println(25);
OK();
}

//////////
void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("01");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.println("02");
while(1);
}
}

///////////
void test_led()
{
Serial.println("01");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("0");
Serial.println(i+3);
err=true;
delay(2000);
OK();
}
if(val > 92 * 1.25)
{
Serial.print("0");
Serial.println(i+7);
err=true;
delay(2000);
OK();
}
}

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.println(i+11);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.println(i+15);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
}
}
//////////
void test_capt()
{
int i;
Serial.println(23);
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}
//////////
void test_capt_led_HS() {
int i;
int mes[4], mea[4];
Serial.println("01");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mes[i] = analogRead(capt[i]);

}
}
Serial.println(24);
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}

</source>

Partie Processing

<source lang=c>

import processing.serial.*;
PImage board;
PImage cc;
PImage ledcg;
PImage ledmg;
PImage ledmd;
PImage ledcd;
PImage CNYcg;
PImage CNYmg;
PImage CNYmd;
PImage CNYcd;
PImage captcg;
PImage captmg;
PImage captmd;
PImage captcd;

Serial myPort;
volatile char data[]= new char[255];
volatile int lecture;
volatile int i;
volatile boolean Sel=true; //flag autorisant le mode de fonctionnement sélection du port série
volatile boolean Init=false; //flag autorisant le mode de fonctionnement initialisation du port série
boolean fct=false; //flag autorisant le mode de fonctionnement normal
boolean fin=false; //flag indiquant la fin du test

void setup() {

size(1000, 800);
background(100);
textSize(20);
text("la touche maj est considérée comme un caractère, pour passer en majuscule, tapez ver.maj. puis backspace",10,50,1000,100);
textSize(32);
text("indiquez le port de la carte", 10, 150);

board=loadImage("imgboard.png");// sélection et chargement des images
cc=loadImage("cc.png");
ledcg=loadImage("ledcg.png");
ledmg=loadImage("ledmg.png");
ledmd=loadImage("ledmd.png");
ledcd=loadImage("ledcd.png");
CNYcg=loadImage("CNYcg.png");
CNYmg=loadImage("CNYmg.png");
CNYmd=loadImage("CNYmd.png");
CNYcd=loadImage("CNYcd.png");
captcg=loadImage("captcg.png");
captmg=loadImage("captmg.png");
captmd=loadImage("captmd.png");
captcd=loadImage("captcd.png");

imageMode(CORNERS);
}

void fonctionnement()
{
fill(0);
rect(0, 600, 1000, 200);//efface le précédent texte
fill(255);
switch(lecture) {
//affichage des informations correspondant au code transmis par Arduino
case 1:
text("Placez la carte sur une surface sombre, puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 2:
image(cc, 0, 0, 1000, 600);
text("Il y a un court-circuit entre VCC et la masse!!!", 50, 650, 950, 800);
break;
case 3:
image(ledcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté gauche", 50, 650, 950, 800);
break;
case 4:
image(ledmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu gauche", 50, 650, 950, 800);
break;
case 5:
image(ledmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu droit", 50, 650, 950, 800);
break;
case 6:
image(ledcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté droit", 50, 650, 950, 800);
break;
case 7:
image(ledcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté gauche", 50, 650, 950, 800);
break;
case 8:
image(ledmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu gauche", 50, 650, 950, 800);
break;
case 9:
image(ledmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu droit", 50, 650, 950, 800);
break;
case 10:
image(ledcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté droit", 50, 650, 950, 800);
break;
case 11:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 12:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 13:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu droit", 50, 650, 950, 800);
break;
case 14:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté droit", 50, 650, 950, 800);
break;
case 15:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 16:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 17:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu droit ", 50, 650, 950, 800);
break;
case 18:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté droit", 50, 650, 950, 800);
break;
case 19:
image(captcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté gauche", 50, 650, 950, 800);
break;
case 20:
image(captmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu gauche", 50, 650, 950, 800);
break;
case 21:
image(captmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu droit", 50, 650, 950, 800);
break;
case 22:
image(captcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté droit", 50, 650, 950, 800);
break;
case 23:
text("posez la carte sur une surface claire puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 24:
text("exposez la carte à une lumière forte puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 25:
text("Test terminé\n appuyer sur une touche pour recommencer", 50, 650, 950, 800);
fin=true;
break;
case 26:
text("Aucun problème",150 ,550, 950, 800);
break;
default:
break;
}
}

void draw() {
//partie initialisation du port série
if (Init==true)
{
char nom[]=new char[i];
for (char j=0; j<i; j++) nom[j]=data[j];//stockage des caractères choisi par l'utilisateur dans un tableau
String name = new String(nom);//création d'une chaîne de caractère à partir du tableau
myPort = new Serial(this, name, 9600);//initialisation du port série
myPort.bufferUntil('\n');
background(0);
Init=false;
fct=true;
image(board, 0, 0, 1000, 600);
}
if (fct==true) fonctionnement();
}

void keyPressed() {

//partie utilisée seulement en mode sélection du port série
if (Sel==true) {
if ((key==ENTER)||(key==RETURN)) //validation du choix du port série
{
Init=true;
Sel=false;
} else
{
if (key==BACKSPACE) //efface un caractère
{
data[i]=0;
fill(100);
noStroke();
rect(10+40*(i-1), 168, 32, 140);
fill(255);
i--;
} else {
data[i]=key;
text(data[i], 10+40*i, 200);
i++;
}
}
}

//partie utilisée seulement en fonctionnement normal
if (fct==true)
{
myPort.write(0x0d); //envoie confirmation à Arduino si on appui sur une touche
if (fin==true) //si le test est fini, efface l'écran avant de recommencer
{
image(board, 0, 0, 1000, 600);
fin=false;
}
}
}

void serialEvent(Serial myPort)
{
fill(0);
rect(0, 0, 200, 100);
fill(255);
byte l[]=myPort.readBytesUntil('\n');
lecture=(l[0]-48)*10+(l[1]-48); //conversion de la chaîne de caractère envoyé en un nombre de 2 chiffre
text(lecture, 50, 50);
}

</source>

Pour l'affichage dans l'interface, nous utilisons les images ci-dessous que nous superposons affin d'indiquer toutes les pistes qui nécessitent une vérification d'après le test.

{| class="wikitable"
|-
| || [[Fichier:imgboard.png|200px|thumb|left|imgboard.png]] || [[Fichier:court-circuit.png|200px|thumb|left|cc.png]] ||
|-
| [[Fichier:captcg.png|200px|thumb|left|captcg.png]] || [[Fichier:captmg.png|200px|thumb|left|captmg.png]] || [[Fichier:captmd.png|200px|thumb|left|captmd.png]] || [[Fichier:captcd.png|200px|thumb|left|captcd.png]]
|-
| [[Fichier:CNYcg.png|200px|thumb|left|CNYcg.png]] || [[Fichier:CNYmg.png|200px|thumb|left|CNYmg.png]] || [[Fichier:CNYmd.png|200px|thumb|left|CNYmd.png]] || [[Fichier:CNYcd.png|200px|thumb|left|CNYcd.png]]
|-
| [[Fichier:ledcg.png|200px|thumb|left|ledcg.png]] || [[Fichier:ledmg.png|200px|thumb|left|ledmg.png]] || [[Fichier:ledmd.png|200px|thumb|left|ledmd.png]] || [[Fichier:ledcd.png|200px|thumb|left|ledcd.png]]
|}

Fichier:Ledmg.png

2015-06-20T14:29:06Z

Troyesgeii :

Fichier:Ledmd.png

2015-06-20T14:28:32Z

Troyesgeii :

Fichier:Ledcg.png

2015-06-20T14:28:04Z

Troyesgeii :

Fichier:Ledcd.png

2015-06-20T14:27:35Z

Troyesgeii :

Fichier:Imgboard.png

2015-06-20T14:26:58Z

Troyesgeii :

Fichier:CNYmg.png

2015-06-20T14:26:27Z

Troyesgeii :

Fichier:CNYmd.png

2015-06-20T14:25:45Z

Troyesgeii :

Fichier:CNYcg.png

2015-06-20T14:25:09Z

Troyesgeii :

Fichier:CNYcd.png

2015-06-20T14:24:18Z

Troyesgeii :

Fichier:Court-circuit.png

2015-06-20T14:23:23Z

Troyesgeii :

Fichier:Captmg.png

2015-06-20T14:22:33Z

Troyesgeii :

Fichier:Captmd.png

2015-06-20T14:21:46Z

Troyesgeii :

Arexx SUPERHEROS

2015-06-20T14:20:48Z

Troyesgeii : /* {{Bleu|Amélioration du programme de la procédure optimisée }} */

[[Catégorie:Projets Tutorés S2]]

={{Rouge|Introduction-Présentation du projet}}=

Au cours du précédent semestre, nous avons eu à concevoir un robot suiveur de ligne sur un châssis Arexx constitué d'une carte capteur et d'une carte gestion. Nous avons également dû réaliser une carte d’adaptation afin de relier directement la carte capteur à une carte ARDUINO. Nous avons aussi écrit des programmes pour tester les capteurs et les LEDs, suite à cela notre projet actuel consiste à écrire un programme permettant de détecter les pannes sur la carte capteur du robot Arexx et une possibilité de modifier la carte d’adaptation.

={{Rouge|Présentation du cahier des charges}}=

♦Créer deux algorithmes permettant de tester le bon fonctionnement des capteurs et des LEDs.

♦Possibilité de modification de la carte d'adaptation.

♦Fabrication de la carte gestion.

♦ Réalisation des programmes permettant le fonctionnement de la carte gestion.

♣ Suite à des imprévus, nous avons dû abandonner la fabrication de la carte gestion et des programmes correspondant.

={{Rouge|Planning }}=
=={{Bleu|Planning prévisionnel }}==

[[Image:taches image.JPG]]

[[Image:gantt image.JPG]]

=={{Bleu|Planning de la semaine d’inter-semestre}}==

[[Image:gantt2.JPG]]

[[Image:planning2.JPG]]

={{Rouge|Carte capteur}}=

=={{Bleu|Procédure des tests }}==

=={{Vert|Procédure manuelle }}==
Ces tests sont basés sur les programmes réalisés lors du projet inter-semestre précédent, en testant le bon fonctionnement des capteurs et des LEDs.

<source lang=c>
char * pos[4] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char ledv[4]={
6,7,9,8};
char ledc[4]={
4,3,2,5};
int i;
void setup(){
for (char i = 0; i < 8; i++) pinMode(i+2, OUTPUT);
Serial.begin(9600);
}

void testlv(){
Serial.println("Parametrer le moniteur serie en 'Pas de fin de ligne'");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledv[i],1);
while (Serial.available() == 0);
char l=Serial.read();
while(Serial.available()>0);
digitalWrite(ledv[i],0);
if(l==0x6F){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(l==0x6E){
Serial.print("la led visible ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void testlc(){
Serial.println("Utiliser l'objectif de votre smartphone pour voir les capteurs");
Serial.println("Appuyer sur o si a led s'allume ou sur n sinon");
for(i=0;i<4;i++){
digitalWrite(ledc[i],1);
while (Serial.available() == 0);
char m=Serial.read();
while(Serial.available()>0);
digitalWrite(ledc[i],0);
if(m==0x6F){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
else if(m==0x6E){
Serial.print("la led CNY ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
}
}

void tcapteur(){
char led[4]={
4,3,2,5 };
char capt[4]={
A2,A3,A1,A0 };
int i;
Serial.println("Parametrer le moniteur serie en 'retour chariot'");
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
analogReference(DEFAULT);
for(i=0;i<4;i++){
digitalWrite(led[i],0);
int mes=analogRead(capt[i]);
digitalWrite(led[i],1);
delay(5);
int mea=analogRead(capt[i]);
if(mea>(mes*0.95)){
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
}
else{
Serial.print("le capteur ");
Serial.print(pos[i]);
Serial.println(" fonctionne");
}
delay(1000);
}
}

void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}

void loop(){
testlv();
testlc();
Serial.println("Verification des capteurs...");
delay(1000);
tcapteur();
Serial.println("Appuyer sur une touche pour recommencer les tests");
OK();
}

</source>

=={{Vert|Procédure optimisée }}==

Avec cette procedure, les courts-circuits sont détéctés, les LEDs et les capteurs sont testés de façon semi-automatique par le programmes ci dessous réalisés lors de notre projet tutorés de ce semestre. l'utilisateur doit seulement deplacer la carte sur différentes surfaces afin de diminuer ou augmenter l'impact des capteurs sur les mesures suivant les besoins.

==={{Bleu|Modification de la carte d'adaptation-Choix de la résistance}}===

[[Image:resistancebakir.png]]
 
Nous avons choisi une résistance la plus grande possible laissant un courant d'environ 4mA traverser une LED, afin de perturber le moins possible le fonctionnement des LEDs. 
Si Vd=2V 
U=((5V-Vd)*R)/R+R1
= 3R/R+680 = (3*120)/800
= 360/800= 0.45V 
R=U/I = 0.45/4*10^-3=112.5 Ohm.
On prendra la résistance normalisée 120 Ohm.

Nous avons modifié la carte d'adaptation en mettant une résistance de 120ohm entre la masse de la carte capteur et la masse de la carte arduino, nous mesurons la tension aux bornes de cette résistance avec l'entrée analogique A4.

[[Image:Capture22.png|cadre|gauche|carte d'adaptation]]

[[Image:Capture11.png|cadre|gauche|schéma de la carte d'adaptation]]

 

==={{Bleu|Sous-programmes }}===

===={{Vert|Test des courts-circuits }}====
Ce test permet de détecter les courts-circuits entre Vcc et la masse.

Si aucune LED n'est allumée et que les capteurs ne sont pas exposés à la lumière, aucun courant ne circule, donc il n'y a aucune tension aux bornes de la résistance de test, si il y a une tension importante, cela signifie qu'il y a un court-circuit entre la masse et l'alimentation.

<source lang=c>

void test_cc(){
int val = analogRead(A4);
if(val>512)
{
Serial.print("court-circuit entre VCC et la masse!!!");
while(1);
}
}
</source>

===={{Vert|Test des LEDs }}====
Ce test permet de détecter un problème ente 2 bornes de la LED , ou si une piste est coupée sur le circuit alimentant la LED .

Pour les LEDs : en fonctionnement normal, la tension aux bornes des LEDs est d'environ 2V, donc la tension aux bornes de notre résistance de test est de ((5-Vd)*Rtest)/(Rtest+R)=(3*120)/(120+680)=0.45V.
Après la conversion analogique, 0.45V donne la valeur 92.

Pour les LEDs infrarouges des capteurs : les récepteurs des capteurs créent une tension lorsqu'on allume les LEDs donc la tension aux bornes dépend aussi de la tension aux bornes des photo-transistors. Nous avons observé les variations des 2 tensions en faisant varier la luminosité, afin de trouver une équation linéaire approximant le fonctionnement des capteurs.
Nous obtenons : U=413 -(20/307) * u2 avec u2 la tension moyenne des capteurs.

Pour limiter l'impact des tensions des capteurs dans les mesures nous placerons les capteurs sur une surface sombre.
Nous prenons une marge de 25 % dans nos calculs afin d’éviter les problèmes de variations de tensions.

<source lang=c>

char * pos[] = {"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={ 4,3,2,5 };
char capt[4]={ A2,A3,A1,A0};
char led[] = {6, 7, 9, 8 };

void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
</source>

===={{Vert|Test des capteurs }}====
Permet de détecter un problème dans les capteurs

♠Si la LED du capteur fonctionne

Si la LED fonctionne, nous pouvons vérifier le fonctionnement en effectuant une mesure avec la LED allumée et une avec la LED éteinte. Si la mesure avec la LED allumée est supérieure à celle de la LED éteinte, cela signifie que le récepteur fonctionne.

<source lang=c>

void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

Si la LED ne fonctionne pas, nous remplaçons la LED allumée par un éclairage fort, pour la LED éteinte, nous plaçons les capteurs sur une surface sombre.

♠Si la LED du capteur ne fonctionne pas
<source lang=c>
char void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}

</source>

==={{Bleu|Programme final }}===

<source lang=c>
char * pos[] = {
"cote gauche", "milieu gauche", "milieu droit", "cote droit"};
char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5}; //adresse des leds des capteurs de gauche à droite
char capt[4]={A2,A3,A1,A0}; //adresse des capteurs de gauche à droite
char led[] = {6, 7, 9, 8 }; //adresse des leds de gauche à droite

boolean err=false; //flag passant à l'etat vrai si il y'a un disfonctionnement

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println(" Parametrer le moniteur serie en 'retour chariot'");
test_cc(); //test court-circuit
}

void loop() {
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS(); //si au moins une led de capteur ne fonctionne pas on utillise cette fonction

Serial.println(" ");
if(err==false) Serial.println("Aucun probleme");
err==false;
Serial.println("Test termine");
Serial.println("Taper sur entrer pour recommencer");
Serial.println(" ");
Serial.println(" ");
OK();
}

//////////
void OK() //fonction attendant le caractère retour chariot comme confirmation que l'utilisateur à compris la consigne
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.print("Court-circuit entre VCC et la masse!!!");
while(1);
}
}
//////////
void test_led()
{
Serial.println("Poser la carte sur une surface noire");
Serial.println("Puis appuyez sur une touche");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("Il y a une piste coupée sur le circuit de la LED ");
Serial.println(pos[i]);
err=true;
}
if(val > 92 * 1.25)
{
Serial.print("Il y a un court-circuit sur la LED ");
Serial.println(pos[i]);
err=true;
}
}
Serial.println("");

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a une piste coupée sur le circuit de la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.print("Il y a un court-circuit sur la LED du capteur ");
Serial.println(pos[i]);
led_HS[i] = HIGH;
err=true;
}
}
Serial.println("");
}
//////////
void test_capt()
{
int i;
Serial.println("Poser la carte sur une surface clair");
Serial.println("Puis taper sur ok");
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.print("Il y a un probleme sur le circuit du capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
//////////
void test_capt_led_HS() {
char led[4] = {
4, 3, 2, 5
};
char capt[4] = {
A2, A3, A1, A0
};
int i;
int mes[4], mea[4];
Serial.println("Poser la carte sur une surface sombre");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{

mes[i] = analogRead(capt[i]);

}
}
Serial.println("Exposez la carte a une lumiere forte");
Serial.println("Puis taper sur ok");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.print("Le capteur ");
Serial.print(pos[i]);
Serial.println(" est HS");
err=true;
}
}
}
}
</source>

=={{Bleu|Amélioration du programme de la procédure optimisée }}==
Nous avons dévellopé à l'aide de Processing une interface graphique qui faciliterai la recherche de la panne par l'utilisateur, cette interface affiche les problèmes et les consignes comme le moniteur série dans le précédent code, mais elle affiche aussi sur l'image du routage les pistes à vérifier en surbrillance.
De plus, le programme ne nécessite pas de changement de paramètre, donc peut être utilisé indépendamment
de Processing. Pour cela nous utilisons la fonction d'exportation de Processing afin de générer une application utilisable sur tout ordinateur.
Cependant cette methode serait réellement éfficace si toutes les cartes possèdaient le même routage.

Partie Arduino

Pour faciliter la communication, le texte envoyé à la liaison série est remplacé par un nombre.

<source lang=c>

char led_HS[4];//CNY{gauche, mil gauche, mil droit, droit}
char ledCNY[4]={4,3,2,5};
char capt[4]={A2,A3,A1,A0};
char led[] = { 6, 7, 9, 8};

boolean err=false;

void setup() {
for (char i = 0; i < 14; i++) pinMode(i, OUTPUT);
Serial.begin(9600);
Serial.println("");
test_cc();
}

void loop() {
for(int i=0; i<4;i++) led_HS[i]=0;
test_led();
test_capt();
if((led_HS[0]==1)||(led_HS[1]==1)||(led_HS[2])||(led_HS[3])) test_capt_led_HS();

if(err==false) Serial.println(26);
err=false;

Serial.println(25);
OK();
}

//////////
void OK()
{
char r;
do {
while (Serial.available() == 0);
r = Serial.read();
}
while ( r != 0x0d);
}
//////////
void test_cc(){
Serial.println("01");
OK();
int val = analogRead(A4);
if(val>512)
{
Serial.println("02");
while(1);
}
}

///////////
void test_led()
{
Serial.println("01");
OK();

//partie LED presence ligne
for (char i = 0; i < 4; i++)
{
digitalWrite(led[i], HIGH);
int val = analogRead(A4);
digitalWrite(led[i], LOW);
if (val < 92 * 0.75)
{
Serial.print("0");
Serial.println(i+3);
err=true;
delay(2000);
OK();
}
if(val > 92 * 1.25)
{
Serial.print("0");
Serial.println(i+7);
err=true;
delay(2000);
OK();
}
}

//partie LED CNY

for (char i = 0; i < 4; i++)
{
unsigned int u2=0;
char an[] = {
A0, A1, A2, A3 };
digitalWrite(ledCNY[i], HIGH);
unsigned int u1 = analogRead(A4);
for (int j = 0; j < 4; j++)
{
u2 += analogRead(an[j]);
}
u2 /= 4;
digitalWrite(ledCNY[i], LOW);
if( u1 < (0.75 *(413 + (-20/307) * u2)))
{
Serial.println(i+11);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
if( u1 > (1.25 *(413 + (-20/307) * u2)))
{
Serial.println(i+15);
led_HS[i] = HIGH;
err=true;
delay(2000);
OK();
}
}
}
//////////
void test_capt()
{
int i;
Serial.println(23);
OK();
for(i=0;i<4;i++)
{
if(led_HS[i]==0)
{
digitalWrite(ledCNY[i],0);
int mes=analogRead(capt[i]);
digitalWrite(ledCNY[i],1);
delay(5);
int mea=analogRead(capt[i]);
digitalWrite(ledCNY[i],0);
if(mea>(mes*0.95)){
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}
//////////
void test_capt_led_HS() {
int i;
int mes[4], mea[4];
Serial.println("01");
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mes[i] = analogRead(capt[i]);

}
}
Serial.println(24);
OK();
for (i = 0; i < 4; i++) {

if(led_HS[i]==1)
{
mea[i] = analogRead(capt[i]);

if (mea[i] > (mes[i]*0.98 )) {
Serial.println(i+19);
err=true;
delay(2000);
OK();
}
}
}
}

</source>

Partie Processing

<source lang=c>

import processing.serial.*;
PImage board;
PImage cc;
PImage ledcg;
PImage ledmg;
PImage ledmd;
PImage ledcd;
PImage CNYcg;
PImage CNYmg;
PImage CNYmd;
PImage CNYcd;
PImage captcg;
PImage captmg;
PImage captmd;
PImage captcd;

Serial myPort;
volatile char data[]= new char[255];
volatile int lecture;
volatile int i;
volatile boolean Sel=true; //flag autorisant le mode de fonctionnement sélection du port série
volatile boolean Init=false; //flag autorisant le mode de fonctionnement initialisation du port série
boolean fct=false; //flag autorisant le mode de fonctionnement normal
boolean fin=false; //flag indiquant la fin du test

void setup() {

size(1000, 800);
background(100);
textSize(20);
text("la touche maj est considérée comme un caractère, pour passer en majuscule, tapez ver.maj. puis backspace",10,50,1000,100);
textSize(32);
text("indiquez le port de la carte", 10, 150);

board=loadImage("imgboard.png");// sélection et chargement des images
cc=loadImage("cc.png");
ledcg=loadImage("ledcg.png");
ledmg=loadImage("ledmg.png");
ledmd=loadImage("ledmd.png");
ledcd=loadImage("ledcd.png");
CNYcg=loadImage("CNYcg.png");
CNYmg=loadImage("CNYmg.png");
CNYmd=loadImage("CNYmd.png");
CNYcd=loadImage("CNYcd.png");
captcg=loadImage("captcg.png");
captmg=loadImage("captmg.png");
captmd=loadImage("captmd.png");
captcd=loadImage("captcd.png");

imageMode(CORNERS);
}

void fonctionnement()
{
fill(0);
rect(0, 600, 1000, 200);//efface le précédent texte
fill(255);
switch(lecture) {
//affichage des informations correspondant au code transmis par Arduino
case 1:
text("Placez la carte sur une surface sombre, puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 2:
image(cc, 0, 0, 1000, 600);
text("Il y a un court-circuit entre VCC et la masse!!!", 50, 650, 950, 800);
break;
case 3:
image(ledcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté gauche", 50, 650, 950, 800);
break;
case 4:
image(ledmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu gauche", 50, 650, 950, 800);
break;
case 5:
image(ledmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led milieu droit", 50, 650, 950, 800);
break;
case 6:
image(ledcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led côté droit", 50, 650, 950, 800);
break;
case 7:
image(ledcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté gauche", 50, 650, 950, 800);
break;
case 8:
image(ledmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu gauche", 50, 650, 950, 800);
break;
case 9:
image(ledmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led milieu droit", 50, 650, 950, 800);
break;
case 10:
image(ledcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led côté droit", 50, 650, 950, 800);
break;
case 11:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 12:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 13:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur milieu droit", 50, 650, 950, 800);
break;
case 14:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant la led du capteur côté droit", 50, 650, 950, 800);
break;
case 15:
image(CNYcg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté gauche", 50, 650, 950, 800);
break;
case 16:
image(CNYmg, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu gauche", 50, 650, 950, 800);
break;
case 17:
image(CNYmd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur milieu droit ", 50, 650, 950, 800);
break;
case 18:
image(CNYcd, 0, 0, 1000, 600);
text("Il y a un court-circuit entre les bornes de la led du capteur côté droit", 50, 650, 950, 800);
break;
case 19:
image(captcg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté gauche", 50, 650, 950, 800);
break;
case 20:
image(captmg, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu gauche", 50, 650, 950, 800);
break;
case 21:
image(captmd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur milieu droit", 50, 650, 950, 800);
break;
case 22:
image(captcd, 0, 0, 1000, 600);
text("Il y a une piste coupée ou un composant hors-service sur la piste alimentant le capteur côté droit", 50, 650, 950, 800);
break;
case 23:
text("posez la carte sur une surface claire puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 24:
text("exposez la carte à une lumière forte puis appuyez sur une touche", 50, 650, 950, 800);
break;
case 25:
text("Test terminé\n appuyer sur une touche pour recommencer", 50, 650, 950, 800);
fin=true;
break;
case 26: text("Aucun problème",150 ,550, 950, 800); break;
default:
break;
}
}

void draw() {
//partie initialisation du port série
if (Init==true)
{
char nom[]=new char[i];
for (char j=0; j<i; j++) nom[j]=data[j];//stockage des caractères choisi par l'utilisateur dans un tableau
String name = new String(nom);//création d'une chaîne de caractère à partir du tableau
myPort = new Serial(this, name, 9600);//initialisation du port série
myPort.bufferUntil('\n');
background(0);
Init=false;
fct=true;
image(board, 0, 0, 1000, 600);
}
if (fct==true) fonctionnement();
}

void keyPressed() {

//partie utilisée seulement en mode sélection du port série
if (Sel==true) {
if ((key==ENTER)||(key==RETURN)) //validation du choix du port série
{
Init=true;
Sel=false;
} else
{
if (key==BACKSPACE) //efface un caractère
{
data[i]=0;
fill(100);
noStroke();
rect(10+40*(i-1), 168, 32, 140);
fill(255);
i--;
} else {
data[i]=key;
text(data[i], 10+40*i, 200);
i++;
}
}
}

//partie utilisée seulement en fonctionnement normal
if (fct==true)
{
myPort.write(0x0d); //envoie confirmation à Arduino si on appui sur une touche
if (fin==true) //si le test est fini, efface l'écran avant de recommencer
{
image(board, 0, 0, 1000, 600);
fin=false;
}
}
}

void serialEvent(Serial myPort)
{
fill(0);
rect(0, 0, 200, 100);
fill(255);
byte l[]=myPort.readBytesUntil('\n');
lecture=(l[0]-48)*10+(l[1]-48); //conversion de la chaîne de caractère envoyé en un nombre de 2 chiffre
text(lecture, 50, 50);
}

</source>

[[Fichier:captcd.png|200px|thumb|left|captcd.png]]
[[Fichier:captcg.png|200px|thumb|left|captcg.png]]
[[Fichier:captmd.png|200px|thumb|left|captmd.png]]
[[Fichier:captmg.png|200px|thumb|left|captmg.png]]
[[Fichier:court-circuit.png|200px|thumb|left|cc.png]]
[[Fichier:CNYcd.png|200px|thumb|left|CNYcd.png]]
[[Fichier:CNYcg.png|200px|thumb|left|CNYcg.png]]
[[Fichier:CNYmd.png|200px|thumb|left|CNYmd.png]]
[[Fichier:CNYmg.png|200px|thumb|left|CNYmg.png]]
[[Fichier:imgboard.png|200px|thumb|left|imgboard.png]]
[[Fichier:ledcd.png|200px|thumb|left|ledcd.png]]
[[Fichier:ledcg.png|200px|thumb|left|ledcg.png]]
[[Fichier:ledmd.png|200px|thumb|left|ledmd.png]]
[[Fichier:ledmg.png|200px|thumb|left|ledmg.png]]

Arexx MENAHO

2015-06-20T14:19:41Z

Troyesgeii : /* {{Rouge|Partie Fonctionnement global}} */