Le forum a migré vers l'adresse suivante:

Forum

Masquer ce message

Simple-Duino Index du Forum



[Résolu] Commande infrarouge exemple de programme


 
Poster un nouveau sujet   Répondre au sujet    Simple-Duino Index du Forum -> Arduino & Électronique -> Tutos
Sujet précédent :: Sujet suivant  
Auteur Message
zagenois
Débutant

Hors ligne

Inscrit le: 10 Juil 2014
Messages: 7
Masculin
Niveau d'éléctronique: Intermédiaire

MessagePosté le: Ven 18 Juil - 14:37 (2014)    Sujet du message: [Résolu] Commande infrarouge exemple de programme Répondre en citant

PublicitéSupprimer les publicités ?
chers Arduinautes

Voici un exemple fonctionnel qui rappelle les 5 étapes nécessaires pour bâtir
un programme.
Cette theorie est reprise du Dr PURDUM dans son livre Beginning C
for Arduino p25.
1) Initialisation
2) Entrée des données
3) Traitement des données
4) Sortie des résultats
5) Finitions (nettoyage reini etc ...)

Pour suivre et lire ce code il faut savoir que l'entrée 3 est relié au détecteur
infrarouge.
les sorties 4 5 6 et 7 pilotent le moteur
les sorties 12 et 13 pilotent des LED 12 fixe 13 clignotante

Le circuit de commande moteur est le TB6612
infos ici pour le câblage

http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertMoteursPAPTestSimple


Cet exemple est un peu long mais il montrera j'espere à ceux qui veulent
débuter de se familiariser avec un programme fonctionnel.

si vous lisez tout lentement vous comprendrez les divers mécanismes
mis en œuvre ici.
Si vous l'essayez avec une télécommande compatible vous aurez en prime
la sortie du code HEX du bouton appuyé .
Merci


/************************************************************/
/* SYSTEME EXPERIMENTAL BASE SUR LE */
/* CODE NEC */
/* PERMET QUELQUES COMMANDES SIMPLES */
/* */
/* TELECOMMANDE UTILISEE POUR LES ESSAIS HITACHI CLE 876I */
/* */
/************************************************************/

//Zone des variables

// longues
unsigned long comptTemps;
unsigned long timePass;
unsigned int OldTime;//prise temps pour calcul des longueurs
unsigned int Ton;//Temps on de la led
unsigned int Toff;//Temps off de la led
//entieres
int a;//variable de debug
unsigned int variateur;
int EbPas[7];
int TempoComMoteur; //garde l'heure de passage dans monit moteur
int List[34];//0 a 33 donc 33 valeurs de releve des impulsions reçues
int Index; //index de travail des sous programmes
int Xrec; //index de reception
int TableEcriture[14];
//constantes
const int pinIn = 3; //entree
const int pinOut = 12;//sortie
//boolean
boolean marque;//marque de passage interruption
boolean marqueCodeRecu;
boolean clignot;
boolean ActTemp01; //precise action dans le temps 01
boolean ActTemp02; //idem action 02
boolean LanceurMateriel[13];
//byte
byte octet2a;//inverse commande reçue
byte octet2;//commande
byte cdeerr;//verifie la validité de la reception code erreur
byte Pas;



/*========================================================*/
/* Initialisation */
/*========================================================*/

void setup()
{
Serial.begin(9600);
Pas=0;
a=0;
Ton=2;
Toff=100;
Pas=0;
clignot=false;
marqueCodeRecu=false;
ActTemp01=false;
ActTemp02=false;
variateur=9000;
Xrec=0;//ini tableau de reception
timePass=micros();//mesure l'heure de passage ici
TempoComMoteur=0;
//Serial.begin(9600);HeurPass=millis();heurmoteur=micros();
comptTemps=0;
pinMode (pinIn, INPUT);
pinMode (pinOut,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(13,OUTPUT);
//EbPas[4]=LOW;EbPas[5]=LOW;EbPas[6]=LOW;EbPas[7]=LOW;SortPas();//rest moteur
attachInterrupt(1,Rec,RISING); //interrupt 1 donc broche 3 Arduino gere interruption 0
//sur broche 2 et interruption 1 sur br 3 !c'est comme ça!
for(int x=0;x<14;x++){
LanceurMateriel[x]=true;
TableEcriture[x]=LOW;
}

WriteOut();

}
/*=========================================================*/
/* Boucle de reception principale */
/*=========================================================*/

void loop()
{ //Reception
if (Xrec==34){Xrec=0;FinPulses();}//analyse commande
if (marque==true){marque=false;ReceptionPulses();}
if (marqueCodeRecu==true){marqueCodeRecu=false;donneJob();}
comptTemps=comptTemps+(micros()-timePass);timePass=micros();
if(comptTemps>=250){comptTemps=0;Moniteur();}
//lance Moniteur toute les 250µs environ

WriteOut(); //sous programme materiel action sur les sorties

}

/*==========================================================*/
/* Reception des impulsions */
/*==========================================================*/

//range les longeurs reçues dans le tableau List

void ReceptionPulses()
{
List[Xrec]=(micros()-OldTime);++Xrec;//calcule longueur reçue
OldTime=micros();//reprend l'heure de cette reception pour la suivante
if(Xrec-1==1){if(List[1]>13400&List[1]<14600){}else{--Xrec;}}
//attend la valeur de la bonne trame 9000µs à 1 puis
//4500µs soit une valeur centrale de 13500µs
//que l'on met en case 1 du tableau
}
/*===========================================================*/
/*Fonction interruption Rec reçoit les impulsions infrarouge */
/*===========================================================*/

void Rec() //interruption pour chaque changement d'état 0 vers 1
{


marque=true;//averti la boucle principale qu'il va falloir traiter un signal montant

}

/*==========================================================*/
/*Fonction FinPulses cdeerr si erreur ou lance les actions*/
/*==========================================================*/

void FinPulses()
{
cdeerr=0;
traduction();//calcule les longueurs et transforme en 1 ou 0
commande();Serial.println(octet2, HEX); //la commande reçue est dans octet 2
if(cdeerr!=0){Serial.print("erreur No");Serial.println(cdeerr);}else{marqueCodeRecu=true;}

}

/*================================================================*/
/* En fonction du code reçu distrinue le travail */
/*================================================================*/

void donneJob()
{


switch(octet2) //ici lancement des actions
{
case 0xa1:
flash();//initialise les variables de travail pour flash
break;
case 0xb1:
LedUpDn(); //travail simple arret ou marche LED
break;
case 0xa2:
moteur(); //Active la marche ou l'arret du moteur
break;

case 0xed: //augmente la vitesse moteur
if(variateur>=1500){variateur=variateur-500;}
break;
case 0xea: //diminue la vitesse moteur
if(variateur<=9500){variateur=variateur+500;}
break;
}
}

/*=============================================================*/
/* Travaux lancement ou arret */
/*=============================================================*/

void LedUpDn()
{
TableEcriture[pinOut]=!TableEcriture[pinOut];LanceurMateriel[pinOut]=true;
}

void flash()
{
ActTemp01=!ActTemp01;if(ActTemp01==false){LanceurMateriel[13]=true;TableEcriture[13]=LOW;}
}

void moteur()
{
ActTemp02=!ActTemp02;if(ActTemp02==false){for(int x=4;x<8;x++){
LanceurMateriel[x]=true;TableEcriture[x]=LOW;}
} //la fonction for force l'arret du moteur
}


/*==============================================================*/
/* MONITEUR DE GESTION DEBUT */
/*==============================================================*/
void Moniteur()
{ //entre dans la boucle secondaire ou seront gérées les temporisations

// PARTIE GESTION FLASH
//__________________________________________________________________________
if(ActTemp01==true){ //DEB Actiion temporelle 01
switch (clignot){//DEBUT SWI
case true:
--Ton;if(Ton==0){LanceurMateriel[13]=true;TableEcriture[13]=LOW,Ton=80;clignot=false;}
break;
case false:
--Toff;if(Toff==0){LanceurMateriel[13]=true;TableEcriture[13]=HIGH;Toff=4000;
clignot=true;}

break;
}//FIN SWI
} //FIN IF

// PARTIE GESTION MOTEUR Biphase 4 commandes 20 pas (moteur de chariot lecteur CD)
//__________________________________________________________________________

if (ActTemp02==true){//DEB Action temporelle 02
TempoComMoteur=TempoComMoteur+250;
if(TempoComMoteur>=variateur){TempoComMoteur=0;
switch (Pas){
case 0:
LanceurMateriel[4]=true;TableEcriture[4]=HIGH; //h l h l
LanceurMateriel[5]=true;TableEcriture[5]=LOW;
LanceurMateriel[6]=true;TableEcriture[6]=HIGH;
LanceurMateriel[7]=true;TableEcriture[7]=LOW;
++Pas;
break;
case 1: //h l l h
LanceurMateriel[4]=true;TableEcriture[4]=HIGH;
LanceurMateriel[5]=true;TableEcriture[5]=LOW;
LanceurMateriel[6]=true;TableEcriture[6]=LOW;
LanceurMateriel[7]=true;TableEcriture[7]=HIGH;
++Pas;
break;
case 2: //l h l h
LanceurMateriel[4]=true;TableEcriture[4]=LOW;
LanceurMateriel[5]=true;TableEcriture[5]=HIGH;
LanceurMateriel[6]=true;TableEcriture[6]=LOW;
LanceurMateriel[7]=true;TableEcriture[7]=HIGH;
++Pas;
break;
case 3: //l h h l
LanceurMateriel[4]=true;TableEcriture[4]=LOW;
LanceurMateriel[5]=true;TableEcriture[5]=HIGH;
LanceurMateriel[6]=true;TableEcriture[6]=HIGH;
LanceurMateriel[7]=true;TableEcriture[7]=LOW;
Pas=0;
break;
}//FIN SWITCH
}// FIN SECOND IF

}//FIN PREMIER IF





} //FIN MONITEUR

/*===============================================================*/
/* MONITEUR DE GESTION FIN */
/*===============================================================*/

/* Zone de sous programmes divers */

/*===============================================================*/
/* Interpretation des Impulsions */
/*===============================================================*/

/*================================================================*/
/* Fonction de remplissage de List avec des 0 et 1 selon calcul */
/*================================================================*/
void traduction()
{

//remplace les valeurs par 1 ou 0 selon la longeur du signal reçu

for (int ix=2;ix<34;ix++)
{
if ((List[ix]>1040)&(List[ix]<1220)) {List[ix]=1;}
if ((List[ix]>2150)&(List[ix]<2300)) {List[ix]=0;}

}

}


/*=============================================================*/
/* Calcule et controle le byte de commande */
/*=============================================================*/

// on peut utiliser le meme sous programme pour les adresses
// dans ce cas la sequence sera la même sauf l'index
// Le calcul de l'octet d'adresse est possible mais non traité ici


void commande()
{Index=18;octet2=0;octet2a=0;
while(Index<34){
switch(Index){
case 18:
if(List[Index]==1){octet2=octet2+1;} //l'eb de poids faible est transmis
if(List[Index+8]==1){octet2a=octet2a+1;}//en premier
break;
case 19:
if(List[Index]==1){octet2=octet2+2;} //Octet transmis
if(List[Index+8]==1){octet2a=octet2a+2;}// Octet transmis inverse permet
break; //de controler la valeur reçue
case 20:
if(List[Index]==1){octet2=octet2+4;}
if(List[Index+8]==1){octet2a=octet2a+4;} //etc...
break;
case 21:
if(List[Index]==1){octet2=octet2+8;}
if(List[Index+8]==1){octet2a=octet2a+8;}
break;
case 22:
if(List[Index]==1){octet2=octet2+16;}
if(List[Index+8]==1){octet2a=octet2a+16;}
break;
case 23:
if(List[Index]==1){octet2=octet2+32;}
if(List[Index+8]==1){octet2a=octet2a+32;}
break;
case 24:
if(List[Index]==1){octet2=octet2+64;}
if(List[Index+8]==1){octet2a=octet2a+64;}
break;
case 25:
if(List[Index]==1){octet2=octet2+128;}
if(List[Index+8]==1){octet2a=octet2a+128;}
break;}
++Index;
}
//controle
if((octet2 ^ octet2a)!= 255){cdeerr=2;}
//Xor entre les deux octets valide la reception
}
/****************************************************************/
/* SOUS PROGRAMMES ACTION MATERIELLES */
/****************************************************************/

// Ecrit les sorties 4 à 13 selon les demandes
// Cette action est lancée à chaque passage dans LOOP

void WriteOut()
{
for(int x=4;x<14;x++){
if(LanceurMateriel[x]==true){LanceurMateriel[x]=false;digitalWrite(x,TableEcriture[x]);
}
}

}
____________________________
Arduino c'est du gâteau à condition de bien remuer la sauce blanche du cerveau
Revenir en haut
Contenu Sponsorisé






MessagePosté le: Aujourd’hui à 00:28 (2017)    Sujet du message: [Résolu] Commande infrarouge exemple de programme

Revenir en haut
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    Simple-Duino Index du Forum -> Arduino & Électronique -> Tutos Toutes les heures sont au format GMT + 1 Heure
Page 1 sur 1

 
Sauter vers:  

Index | creer un forum | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation
Powered by phpBB
Propulsé par Simple-Duino