Suivi du soleil avec une parabole motorisée

Les cartes Arduino, les platines

Re: Suivi du soleil avec une parabole motorisée

Message non lude Cassiope34 » Ven 27 Avr 2012 18:46

Voici une très bonne page d'explications L293D + Arduino : Arduino Notepad ( en particulier sur l'alimentation )
Si cela peut t'aider.

Je serais bien intéressé par quelques mots sur le code qui devra permettre à 4 LDR au fond d'un petit tuyau solidaire de la parabole, d'orienter celle-ci dans la direction de la lumière maximum ? ( si j'ai tout bien compris le dossier :ugeek: )

@+
Cassiope34
 
Messages: 102
Inscription: Lun 16 Avr 2012 14:35

Re: Suivi du soleil avec une parabole motorisée

Message non lude Patrick 47 » Dim 29 Avr 2012 17:38

Bonsoir Lionel,

Depuis 18h30 le système marche super bien, je pilote la parabole et le suivi du soleil (en ce moment c'est la lampe du plafond).
Le programme marche bien aussi.
Les moteurs tournent bien.
J'alimente L'arduino avec une pile de 9v et le L293 en 12V.
Les portes ouvertes sont à la fin de la semaine, j'espère que le soleil sera là.

Bonne soirée, et encore merci pour ton aide.

Patrick.
Patrick 47
 
Messages: 41
Inscription: Mar 24 Avr 2012 10:44

Re: Suivi du soleil avec une parabole motorisée

Message non lude Lionel » Dim 29 Avr 2012 22:01

Excellente nouvelle !
félicitations, j'espère voir des vidéos de tout ça... je te souhaite donc des portes ouvertes ensoleillées !
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Suivi du soleil avec une parabole motorisée

Message non lude Patrick 47 » Dim 29 Avr 2012 22:40

Mardi je fais une petite vidéo du système, plus le programme de gestion des LDRs, c'est un programme basic.
Ils faut que je rajoute un module de recherche du soleil.
Bonne fin de soirée.

@+
Patrick 47
 
Messages: 41
Inscription: Mar 24 Avr 2012 10:44

Re: Suivi du soleil avec une parabole motorisée

Message non lude Cassiope34 » Lun 30 Avr 2012 08:41

Aaaah ! j'ai hâte Mardi :D

le programme de gestion des LDR et le module de recherche du soleil sont indépendant ?

Juste une petite idée qui m'est venue en regardant le dossier photo de la parabole motorisée (trouée au centre) sur ton site : que penses-tu d'un petit capteur TIR ( Infrared Thermometer - MLX90614 ou Dthermal-Infrared-NXT-Sensor par exemple) au centre de la parabole en direction du moteur bien sûr, et traité par l'arduino pour connaitre la température de fonctionnement, voire même enregistrer ces valeurs sur une carte SD avec le shield mémoire ?

ça s'annonce pas terrible question soleil vers Toulouse, mais pour une fois c'est pas mieux sur Montpellier :evil:

@+
Cassiope34
 
Messages: 102
Inscription: Lun 16 Avr 2012 14:35

Re: Suivi du soleil avec une parabole motorisée

Message non lude Patrick 47 » Lun 30 Avr 2012 17:11

Bonjour Cassiope34,

Voici le code de gestion des 4 LDR, je ne gère pas encore la recherche du soleil.
Je vais peut-être le faire demain si j'ai un peu de temps, mais il faut que j’installe (physiquement) des butées fin de cours.
La recherche et le suivi sont indépendants.

Bonne soirée et à demain.

Patrick.

Code: Tout sélectionner
/* Ce programme commande un L293D (pour la motorisation du moteur droite / gauche et haut / bas )
* branchée sur les sortie numérique
*10 moteur HAUT
*11 moteur BAS
*12 moteur DROIT
*13 moteur GAUCHE
* en fonction d'une variation de luminosité de la ldr1 et ldr2, branchées sur le port entrée analogique A1 et A2 (horizontal gauche et droit)
* en fonction d'une variation de luminosité de la ldr3 et ldr4, branchées sur le port entrée analogique A3 et A4 (horizontal gauche et droit)
* la ldrAmbiance branchée sur le port analogique AO , pour savoir s'il fait nuit et gérer le passage des nuages
* doc P76
*/
//PARAMETRE DES FONCTIONS
//fonction
//gestionMoteurHorizontal(int seuilDeDeclenchementMoteur,int tempsMotorisation,int seuilValeurLumiereDuJour)
//seuilDeDeclenchementMoteur = différence entre les 2 ldr horizontale ou verticale
//tempsMotorisation = temps de fonctionnement des moteurs pour 1 déplacement
//seuilValeurLumiereDuJour = valeur de la LDR Jour/nuit pour déclencher la gestion de la parabole
// variable en entrées

//******************************************************************

// Branchement sur les E/S numériques du L293DNE

// Moteur DROITE GAUCHE
 int moteur_G_D_On_Off = 9; // Broche N°1 du L293DNE
 int rotation_Gauche = 12;  // Broche N°2 du L293DNE
 int rotation_Droite = 13;  // Broche N°7 du L293DNE

// Moteur HAUT BAS
  int moteur_H_B_On_Off = 8; // Broche N°9 du L293DNE
  int rotation_Haut = 10;    // Broche N°15 du L293DNE
  int rotation_Bas = 11;     // Broche N°10 du L293DNE
// Pour info le moteur Gauche/Droit branché sur broche N°3 et N°6
// Pour info le moteur Haut/Bas branché sur broche N°11 et N°14


//******************************************************************

int ldrAmbiance = 0; // variable identifiant le port analogique 0 de la carte pour la ldrAmbiance
int ldr1 = 1;  // variable identifiant le port analogique 1 de la carte pour la ldr1
int ldr2 = 2;  // variable identifiant le port analogique 2 de la carte pour la ldr2
int ldr3 = 3;  // variable identifiant le port analogique 3 de la carte pour la ldr3
int ldr4 = 4;  // variable identifiant le port analogique 4 de la carte pour la ldr4
int lumLdr1 = 0;  // variable identifiant la valeur de la luminosité de la ldr1
int lumLdr2 = 0;  // variable identifiant la valeur de la luminosité de la ldr2
int lumLdr3 = 0;  // variable identifiant la valeur de la luminosité de la ldr3
int lumLdr4 = 0;  // variable identifiant la valeur de la luminosité de la ldr4
int lumLdrAmbiance = 0; // variable identifiant la valeur de la luminosité de la ldrAmbiance

int declenchement_Programme;
int seuilValeurLumiereDuJour;
               
void setup()
{
 //*******************************************
   // Moteur GAUCHE DROITE
   pinMode (moteur_G_D_On_Off, OUTPUT);
   pinMode (rotation_Gauche, OUTPUT);
   pinMode (rotation_Droite, OUTPUT);
   // Moteur HAUT BAS
   pinMode (moteur_H_B_On_Off, OUTPUT);
   pinMode (rotation_Haut, OUTPUT);
   pinMode (rotation_Bas, OUTPUT);
 
 //*******************************************
  Serial.begin(9600); //établir connection sérielle
  pinMode(ldrAmbiance, INPUT);// configure la broche A0 du port analogique en entrée
  pinMode(ldr1, INPUT); // configure la broche A1 du port analogique en entrée
  pinMode(ldr2, INPUT); // configure la broche A2 du port analogique en entrée
  pinMode(ldr3, INPUT); // configure la broche A3 du port analogique en entrée
  pinMode(ldr4, INPUT); // configure la broche A4 du port analogique en entrée
 
}
   //*********** DEBUT PROGRAMME PRINCIPAL ****************   
     
   void loop ()

{
  //Paramètre des deux fonctions
  //1ier paramètre = Différence entre les LDR1 et LDR2 ou LDR3 et LDR4 pour le déclenchement de la motorisation.
  //2ième paramètre = Temps de motorisation.
  //3ième paramètre = valeur definissant s'y fait JOUR.
 
   //moteur_G_D_Off ;
   //moteur_H_B_Off ;
 
   //while (lumLdrAmbiance >= seuilValeurLumiereDuJour)
   //{
     gestionMoteurHorizontal(25,500,150);
     gestionMoteurVertical(25,500,150);
   //}
 
 
 
 
 
}

//*********** FIN PROGRAMME PRINCIPAL ****************
 
   
//************* SOUS PROGRAMMES *********************   
 
 
//*********** INITIALISATION DU L293DNE *************
// mise à zéro des bornes 1,2,7 (moteur Gauche et Droite)
// mise à zéro des bornes 9,10,15 (moteur Haut et Bas)

void moteur_G_D_Off () 
{
digitalWrite (moteur_G_D_On_Off, LOW);
digitalWrite (rotation_Gauche, LOW);
digitalWrite (rotation_Droite, LOW);
}   

void moteur_H_B_Off ()
{
digitalWrite (moteur_H_B_On_Off, LOW);
digitalWrite (rotation_Haut, LOW);
digitalWrite (rotation_Bas, LOW);
}

//******** Mise en rotation des moteurs ***********

void rotation_Moteur_Gauche ()
{
digitalWrite (moteur_G_D_On_Off, HIGH);
digitalWrite (rotation_Gauche, HIGH);
digitalWrite (rotation_Droite, LOW);
 } 

void rotation_Moteur_Droite ()
{
digitalWrite (moteur_G_D_On_Off, HIGH);
digitalWrite (rotation_Droite, HIGH);
digitalWrite (rotation_Gauche, LOW);
}

void rotation_Moteur_Haut ()
{
digitalWrite (moteur_H_B_On_Off, HIGH);
digitalWrite (rotation_Haut, HIGH); 
digitalWrite (rotation_Bas, LOW);


void rotation_Moteur_Bas ()
{
digitalWrite (moteur_H_B_On_Off, HIGH);
digitalWrite (rotation_Bas, HIGH);
digitalWrite (rotation_Haut, LOW);


//********** Arret rotation des moteurs

void arret_Moteur_Gauche ()
{
digitalWrite (moteur_G_D_On_Off, LOW);
digitalWrite (rotation_Gauche, LOW);
 } 

void arret_Moteur_Droite ()
{
digitalWrite (moteur_G_D_On_Off, LOW);
digitalWrite (rotation_Droite, LOW); 
}

void arret_Moteur_Haut ()
{
digitalWrite (moteur_H_B_On_Off, LOW);
digitalWrite (rotation_Haut, LOW); 


void arret_Moteur_Bas ()
{
digitalWrite (moteur_H_B_On_Off, LOW);
digitalWrite (rotation_Bas, LOW); 



 // gestion moteur horizontal GAUCHE DROIT

 //1ier paramètre = Différence entre les LDR1 et LDR2 pour le déclenchement de la motorisation.
  //2ième paramètre = Temps de motorisation.
  //3ième paramètre = valeur definissant s'y fait JOUR.


 void gestionMoteurHorizontal(int seuilDeDeclenchementMoteur,int tempsMotorisation, int seuilValeurLumiereDuJour)
{
   lumLdr1=analogRead(ldr1); // lire la donnée de la ldr1
   lumLdr2=analogRead(ldr2); //lire la donnée de la ldr2
   lumLdrAmbiance=analogRead(ldrAmbiance); //lire la donnée de la ldrAmbiance
   
   Serial.println("------------------------------------");
   Serial.println("Valeur LDR1 GAUCHE");
   Serial.println(lumLdr1); //affiche la valeur de la ldr1
   
   Serial.println("Valeur LDR2 DROITE" );
   Serial.println(lumLdr2); //affiche la valeur de la ldr2
   
   Serial.println("Difference entre LDR1 et LDR2");
   Serial.println(abs ((lumLdr1) - lumLdr2));
   Serial.println("------------------------------------");
   
   delay(1000);

  // GESTION MOTEUR Horizontal GAUCHE DROIT
  //la cellule gauche(ldr1) est au soleil et la cellule (ldr2) est a l'ombre
  //donc il faut motosirer à droite
     
         if (lumLdrAmbiance > seuilValeurLumiereDuJour) // si > à seuilValeurLumièreDuJour c'est qu'il fait JOUR
          {     
                if(lumLdr1 > lumLdr2 && abs ((lumLdr1) - lumLdr2) > seuilDeDeclenchementMoteur) //MOTEUR DROITE / GAUCHE       
                    {
                      arret_Moteur_Gauche ();
                      rotation_Moteur_Droite ();
                      //digitalWrite(relaisMoteurGauche, LOW);
                      //digitalWrite(relaisMoteurDroit, HIGH); // mise en rotation du moteur à droite
                      //delay(tempsMotorisation); 
                        delay(tempsMotorisation);
                      // rotation pendand X milliseconde
                      //digitalWrite(relaisMoteurDroit, LOW);
                      arret_Moteur_Droite ();
                     }
                          else
                             {
                               
                               if(lumLdr2 > (lumLdr1) && abs(lumLdr2 - (lumLdr1)) > seuilDeDeclenchementMoteur)
                                   {
                                     arret_Moteur_Droite ();
                                     rotation_Moteur_Gauche ();
                                    // digitalWrite(relaisMoteurDroit, LOW);
                                     //digitalWrite(relaisMoteurGauche, HIGH); // mise en rotation du moteur à gauche
                                    // delay(tempsMotorisation);                            // rotation pendand X milli seconde
                                     delay(tempsMotorisation);
                                     //digitalWrite(relaisMoteurGauche, LOW);
                                     arret_Moteur_Gauche ();
                                   }                             
                                       else
                                       {
                                       }
                                 //digitalWrite(relaisMoteurGauche,LOW);
                                 //digitalWrite(relaisMoteurDroit,LOW);
                                 arret_Moteur_Gauche ();
                                 arret_Moteur_Droite ();                                                           
                             }
           }
                else
           {
              //digitalWrite(relaisMoteurGauche,LOW);
              //digitalWrite(relaisMoteurDroit,LOW);
              arret_Moteur_Gauche ();
              arret_Moteur_Droite ();             
           }
 
} // fin de void gestion moteur Horizontal GAUCHE DROIT

  //1ier paramètre = Différence entre les LDR3 et LDR4 pour le déclenchement de la motorisation.
  //2ième paramètre = Temps de motorisation.
  //3ième paramètre = valeur definissant s'y fait JOUR.


void gestionMoteurVertical(int seuilDeDeclenchementMoteur,int tempsMotorisation, int seuilValeurLumiereDuJour)
{
   lumLdr3=analogRead(ldr3); // lire la donnée de la ldr3
   lumLdr4=analogRead(ldr4); //lire la donnée de la ldr4
   lumLdrAmbiance=analogRead(ldrAmbiance); //lire la donnée de la ldrAmbiance
   Serial.println("------------------------------------");
   Serial.println("Valeur LDR3 HAUT");
   Serial.println(lumLdr3); //affiche la valeur de la ldr3
   
   Serial.println("Valeur LDR4 BAS");
   Serial.println(lumLdr4); //affiche la valeur de la ldr4
   
   Serial.println("Difference entre LDR3 et LDR4");
   Serial.println(abs (lumLdr3 - lumLdr4));
   Serial.println("------------------------------------");
   
   Serial.println("Valeur LDR AMBIANCE");
   Serial.println(lumLdrAmbiance); //affiche la valeur de la ldrAmbiance
 
   
   delay(1000);
 
  // GESTION MOTEUR vertical HAUT BAS
  //la cellule (ldr3) est au soleil et la cellule (ldr4) est a l'ombre
  //donc il faut motosirer vers le BAS
     
         if (lumLdrAmbiance > seuilValeurLumiereDuJour) // si > à seuilValeurLumièreDuJour c'est qu'il fait JOUR
     
          {     
                if(lumLdr3 > lumLdr4 && abs (lumLdr3 - lumLdr4) > seuilDeDeclenchementMoteur) //MOTEUR HAUT / BAS       
                    {
                      arret_Moteur_Haut ();
                      rotation_Moteur_Bas ();
                     
                     
                      //digitalWrite(relaisMoteurHaut, LOW);
                      //digitalWrite(relaisMoteurBas, HIGH); // mise en rotation du moteur en BAS
                      delay(tempsMotorisation);                            // rotation pendand X milliseconde
                      //digitalWrite(relaisMoteurBas, LOW);
                      arret_Moteur_Bas ();
                     }
 
                          else
                             {
                               
                               if(lumLdr4 > lumLdr3 && abs(lumLdr4 - lumLdr3) > seuilDeDeclenchementMoteur)
                                   {
                               
                                     arret_Moteur_Bas ();
                                     rotation_Moteur_Haut ();
                                     
                                     //digitalWrite(relaisMoteurBas, LOW);
                                     //digitalWrite(relaisMoteurHaut, HIGH); // mise en rotation du moteur en HAUT
                                     delay(tempsMotorisation);                            // rotation pendand X milli seconde
                                     //digitalWrite(relaisMoteurHaut, LOW);
                                     rotation_Moteur_Haut ();
                               
                                   }                             
                                       else
                                       {
                                       }
                               
                               
                                 //digitalWrite(relaisMoteurHaut,LOW);
                                 //digitalWrite(relaisMoteurBas,LOW);
                                 
                                 arret_Moteur_Bas ();
                                 
                                 
                             }
           }
 
                else
           {
              //digitalWrite(relaisMoteurHaut,LOW);
              //digitalWrite(relaisMoteurBas,LOW);
              arret_Moteur_Haut ();
              arret_Moteur_Bas ();
             
           }
 
 
} // fin de void moteur vertical HAUT BAS
Patrick 47
 
Messages: 41
Inscription: Mar 24 Avr 2012 10:44

Re: Suivi du soleil avec une parabole motorisée

Message non lude Cassiope34 » Lun 30 Avr 2012 17:52

Merci beaucoup Patrick :D

Excellent et très bien commenté.
Je devrais pouvoir m'en servir pour optimiser le rendement d'un panneau solaire (photovoltaïque)...

Bonne soirée,

@+
Cassiope34
 
Messages: 102
Inscription: Lun 16 Avr 2012 14:35

Re: Suivi du soleil avec une parabole motorisée

Message non lude Patrick 47 » Mar 1 Mai 2012 15:44

Bonjour Lionel,
Bonjour Cassiope34,

Voilà la parabole motorisée fonction bien et en plus ce 1 mai 2012 le soleil est là.
J'ai pu faire des essais avec le soleil et même une vidéo.



Je n'ai pas encore une recherche automatique, mais je fais le pré-positionnement avec un sous programme par l'intermédiaire de la liaison série.

Voici le programme pour Cassiope34:

Bonne fin de soirée,
Patrick.

Code: Tout sélectionner
/* Ce programme commande un L293D (pour la motorisation du moteur droite / gauche et haut / bas )
* branchée sur les sortie numérique
*10 moteur HAUT
*11 moteur BAS
*12 moteur DROIT
*13 moteur GAUCHE
* en fonction d'une variation de luminosité de la ldr1 et ldr2, branchées sur le port entrée analogique A1 et A2 (horizontal gauche et droit)
* en fonction d'une variation de luminosité de la ldr3 et ldr4, branchées sur le port entrée analogique A3 et A4 (horizontal gauche et droit)
* la ldrAmbiance branchée sur le port analogique AO , pour savoir s'il fait nuit et gérer le passage des nuages
* doc P76
*/
//PARAMETRE DES FONCTIONS
//fonction
//gestionMoteurHorizontal(int seuilDeDeclenchementMoteur,int tempsMotorisation,int seuilValeurLumiereDuJour)
//seuilDeDeclenchementMoteur = différence entre les 2 ldr horizontale ou verticale
//tempsMotorisation = temps de fonctionnement des moteurs pour 1 déplacement
//seuilValeurLumiereDuJour = valeur de la LDR Jour/nuit pour déclencher la gestion de la parabole
// variable en entrées

//******************************************************************

// Branchement sur les E/S numériques du L293DNE

// Moteur DROITE GAUCHE
 int moteur_G_D_On_Off = 9; // Broche N°1 du L293DNE
 int rotation_Gauche = 12;  // Broche N°2 du L293DNE
 int rotation_Droite = 13;  // Broche N°7 du L293DNE

// Moteur HAUT BAS
  int moteur_H_B_On_Off = 8; // Broche N°9 du L293DNE
  int rotation_Haut = 10;    // Broche N°15 du L293DNE
  int rotation_Bas = 11;     // Broche N°10 du L293DNE
// Pour info le moteur Gauche/Droit branché sur broche N°3 et N°6
// Pour info le moteur Haut/Bas branché sur broche N°11 et N°14


//******************************************************************

int ldrAmbiance = 0; // variable identifiant le port analogique 0 de la carte pour la ldrAmbiance
int ldr1 = 1;  // variable identifiant le port analogique 1 de la carte pour la ldr1
int ldr2 = 2;  // variable identifiant le port analogique 2 de la carte pour la ldr2
int ldr3 = 3;  // variable identifiant le port analogique 3 de la carte pour la ldr3
int ldr4 = 4;  // variable identifiant le port analogique 4 de la carte pour la ldr4
int lumLdr1 = 0;  // variable identifiant la valeur de la luminosité de la ldr1
int lumLdr2 = 0;  // variable identifiant la valeur de la luminosité de la ldr2
int lumLdr3 = 0;  // variable identifiant la valeur de la luminosité de la ldr3
int lumLdr4 = 0;  // variable identifiant la valeur de la luminosité de la ldr4
int lumLdrAmbiance = 0; // variable identifiant la valeur de la luminosité de la ldrAmbiance

int declenchement_Programme;
int seuilValeurLumiereDuJour;

int octet_Recu; //variable contenant la valeur de la touche saisi au clavier
int code_Pour_Autorisation_Pilotage; //variable autorisant le pilotage de la parabole (pas encore de codage invisible au clavier)
               
void setup()
{
 //*******************************************
   // Moteur GAUCHE DROITE
   pinMode (moteur_G_D_On_Off, OUTPUT);
   pinMode (rotation_Gauche, OUTPUT);
   pinMode (rotation_Droite, OUTPUT);
   // Moteur HAUT BAS
   pinMode (moteur_H_B_On_Off, OUTPUT);
   pinMode (rotation_Haut, OUTPUT);
   pinMode (rotation_Bas, OUTPUT);
 
 //*******************************************
  Serial.begin(9600); //établir connection sérielle
  pinMode(ldrAmbiance, INPUT);// configure la broche A0 du port analogique en entrée
  pinMode(ldr1, INPUT); // configure la broche A1 du port analogique en entrée
  pinMode(ldr2, INPUT); // configure la broche A2 du port analogique en entrée
  pinMode(ldr3, INPUT); // configure la broche A3 du port analogique en entrée
  pinMode(ldr4, INPUT); // configure la broche A4 du port analogique en entrée
 
}
   //*********** DEBUT PROGRAMME PRINCIPAL ****************   
     
   void loop ()

{
  //Paramètre des deux fonctions
  //1ier paramètre = Différence entre les LDR1 et LDR2 ou LDR3 et LDR4 pour le déclenchement de la motorisation.
  //2ième paramètre = Temps de motorisation.
  //3ième paramètre = valeur definissant s'y fait JOUR.
 
   //moteur_G_D_Off ;
   //moteur_H_B_Off ;
 
   //while (lumLdrAmbiance >= seuilValeurLumiereDuJour)
   //{
       positionnement_Manuel ();
       gestionMoteurHorizontal(1,500,150);
       gestionMoteurVertical(1,500,150);
   //}
 
 
 
 
 
}

//*********** FIN PROGRAMME PRINCIPAL ****************
 
   
//************* SOUS PROGRAMMES *********************   
//*********** lecture memoire tampon
//*********** INITIALISATION DU L293DNE
//*********** Motorisation des 2 moteurs Haut/bas et Droite/gauche

void positionnement_Manuel () {

  if (Serial.available() > 0 ) {
      //Lecture de l'octet dans la mémoire tampon
      octet_Recu = Serial.read();
     
      if (octet_Recu == 'D' || octet_Recu == 'd') {//motorisation droit
          moteur_G_D_Off();
          moteur_H_B_Off();
          rotation_Moteur_Droite();
      }
 
     if (octet_Recu == 'G' || octet_Recu == 'g') {//motorisation gauche
          moteur_G_D_Off();
          moteur_H_B_Off();
          rotation_Moteur_Gauche();
      }


     if (octet_Recu == 'H' || octet_Recu == 'h') {//motorisation haut
          moteur_G_D_Off();
          moteur_H_B_Off();
          rotation_Moteur_Haut();
      }

      if (octet_Recu == 'B' || octet_Recu == 'b') {//motorisation bas
          moteur_G_D_Off();
          moteur_H_B_Off();
          rotation_Moteur_Bas();
      }
     
      if (octet_Recu == 'S' || octet_Recu == 's') {//arret motorisation
          moteur_G_D_Off();
          moteur_H_B_Off();
         
      }



  } //fin du if (Serial.available)
} //fin du void positionnement_Manuel





// mise à zéro des bornes 1,2,7 (moteur Gauche et Droite)
// mise à zéro des bornes 9,10,15 (moteur Haut et Bas)

void moteur_G_D_Off () 
{
digitalWrite (moteur_G_D_On_Off, LOW);
digitalWrite (rotation_Gauche, LOW);
digitalWrite (rotation_Droite, LOW);
}   

void moteur_H_B_Off ()
{
digitalWrite (moteur_H_B_On_Off, LOW);
digitalWrite (rotation_Haut, LOW);
digitalWrite (rotation_Bas, LOW);
}

//******** Mise en rotation des moteurs ***********

void rotation_Moteur_Gauche ()
{
digitalWrite (moteur_G_D_On_Off, HIGH);
digitalWrite (rotation_Gauche, HIGH);
digitalWrite (rotation_Droite, LOW);
 } 

void rotation_Moteur_Droite ()
{
digitalWrite (moteur_G_D_On_Off, HIGH);
digitalWrite (rotation_Droite, HIGH);
digitalWrite (rotation_Gauche, LOW);
}

void rotation_Moteur_Haut ()
{
digitalWrite (moteur_H_B_On_Off, HIGH);
digitalWrite (rotation_Haut, HIGH); 
digitalWrite (rotation_Bas, LOW);


void rotation_Moteur_Bas ()
{
digitalWrite (moteur_H_B_On_Off, HIGH);
digitalWrite (rotation_Bas, HIGH);
digitalWrite (rotation_Haut, LOW);


//********** Arret rotation des moteurs

void arret_Moteur_Gauche ()
{
digitalWrite (moteur_G_D_On_Off, LOW);
digitalWrite (rotation_Gauche, LOW);
 } 

void arret_Moteur_Droite ()
{
digitalWrite (moteur_G_D_On_Off, LOW);
digitalWrite (rotation_Droite, LOW); 
}

void arret_Moteur_Haut ()
{
digitalWrite (moteur_H_B_On_Off, LOW);
digitalWrite (rotation_Haut, LOW); 


void arret_Moteur_Bas ()
{
digitalWrite (moteur_H_B_On_Off, LOW);
digitalWrite (rotation_Bas, LOW); 



 // gestion moteur horizontal GAUCHE DROIT

 //1ier paramètre = Différence entre les LDR1 et LDR2 pour le déclenchement de la motorisation.
  //2ième paramètre = Temps de motorisation.
  //3ième paramètre = valeur definissant s'y fait JOUR.


 void gestionMoteurHorizontal(int seuilDeDeclenchementMoteur,int tempsMotorisation, int seuilValeurLumiereDuJour)
{
   lumLdr1=analogRead(ldr1); // lire la donnée de la ldr1
   lumLdr2=analogRead(ldr2); //lire la donnée de la ldr2
   lumLdrAmbiance=analogRead(ldrAmbiance); //lire la donnée de la ldrAmbiance
   
   Serial.println("------------------------------------");
   Serial.println("Valeur LDR1 GAUCHE");
   Serial.println(lumLdr1); //affiche la valeur de la ldr1
   
   Serial.println("Valeur LDR2 DROITE" );
   Serial.println(lumLdr2); //affiche la valeur de la ldr2
   
   Serial.println("Difference entre LDR1 et LDR2");
   Serial.println(abs ((lumLdr1) - lumLdr2));
   Serial.println("------------------------------------");
   
   delay(1000);

  // GESTION MOTEUR Horizontal GAUCHE DROIT
  //la cellule gauche(ldr1) est au soleil et la cellule (ldr2) est a l'ombre
  //donc il faut motosirer à droite
     
         if (lumLdrAmbiance > seuilValeurLumiereDuJour) // si > à seuilValeurLumièreDuJour c'est qu'il fait JOUR
          {     
                if(lumLdr1 > lumLdr2 && abs ((lumLdr1) - lumLdr2) > seuilDeDeclenchementMoteur) //MOTEUR DROITE / GAUCHE       
                    {
                      arret_Moteur_Gauche ();
                      rotation_Moteur_Droite ();
                      //digitalWrite(relaisMoteurGauche, LOW);
                      //digitalWrite(relaisMoteurDroit, HIGH); // mise en rotation du moteur à droite
                      //delay(tempsMotorisation); 
                        delay(tempsMotorisation);
                      // rotation pendand X milliseconde
                      //digitalWrite(relaisMoteurDroit, LOW);
                      arret_Moteur_Droite ();
                     }
                          else
                             {
                               
                               if(lumLdr2 > (lumLdr1) && abs(lumLdr2 - (lumLdr1)) > seuilDeDeclenchementMoteur)
                                   {
                                     arret_Moteur_Droite ();
                                     rotation_Moteur_Gauche ();
                                    // digitalWrite(relaisMoteurDroit, LOW);
                                     //digitalWrite(relaisMoteurGauche, HIGH); // mise en rotation du moteur à gauche
                                    // delay(tempsMotorisation);                            // rotation pendand X milli seconde
                                     delay(tempsMotorisation);
                                     //digitalWrite(relaisMoteurGauche, LOW);
                                     arret_Moteur_Gauche ();
                                   }                             
                                       else
                                       {
                                       }
                                 //digitalWrite(relaisMoteurGauche,LOW);
                                 //digitalWrite(relaisMoteurDroit,LOW);
                                 arret_Moteur_Gauche ();
                                 arret_Moteur_Droite ();                                                           
                             }
           }
                else
           {
              //digitalWrite(relaisMoteurGauche,LOW);
              //digitalWrite(relaisMoteurDroit,LOW);
              arret_Moteur_Gauche ();
              arret_Moteur_Droite ();             
           }
 
} // fin de void gestion moteur Horizontal GAUCHE DROIT

  //1ier paramètre = Différence entre les LDR3 et LDR4 pour le déclenchement de la motorisation.
  //2ième paramètre = Temps de motorisation.
  //3ième paramètre = valeur definissant s'y fait JOUR.


void gestionMoteurVertical(int seuilDeDeclenchementMoteur,int tempsMotorisation, int seuilValeurLumiereDuJour)
{
   lumLdr3=analogRead(ldr3); // lire la donnée de la ldr3
   lumLdr4=analogRead(ldr4); //lire la donnée de la ldr4
   lumLdrAmbiance=analogRead(ldrAmbiance); //lire la donnée de la ldrAmbiance
   Serial.println("------------------------------------");
   Serial.println("Valeur LDR3 HAUT");
   Serial.println(lumLdr3); //affiche la valeur de la ldr3
   
   Serial.println("Valeur LDR4 BAS");
   Serial.println(lumLdr4); //affiche la valeur de la ldr4
   
   Serial.println("Difference entre LDR3 et LDR4");
   Serial.println(abs (lumLdr3 - lumLdr4));
   Serial.println("------------------------------------");
   
   Serial.println("Valeur LDR AMBIANCE");
   Serial.println(lumLdrAmbiance); //affiche la valeur de la ldrAmbiance
 
   
   delay(1000);
 
  // GESTION MOTEUR vertical HAUT BAS
  //la cellule (ldr3) est au soleil et la cellule (ldr4) est a l'ombre
  //donc il faut motosirer vers le BAS
     
         if (lumLdrAmbiance > seuilValeurLumiereDuJour) // si > à seuilValeurLumièreDuJour c'est qu'il fait JOUR
     
          {     
                if(lumLdr3 > lumLdr4 && abs (lumLdr3 - lumLdr4) > seuilDeDeclenchementMoteur) //MOTEUR HAUT / BAS       
                    {
                      arret_Moteur_Haut ();
                      rotation_Moteur_Bas ();
                     
                     
                      //digitalWrite(relaisMoteurHaut, LOW);
                      //digitalWrite(relaisMoteurBas, HIGH); // mise en rotation du moteur en BAS
                      delay(tempsMotorisation);                            // rotation pendand X milliseconde
                      //digitalWrite(relaisMoteurBas, LOW);
                      arret_Moteur_Bas ();
                     }
 
                          else
                             {
                               
                               if(lumLdr4 > lumLdr3 && abs(lumLdr4 - lumLdr3) > seuilDeDeclenchementMoteur)
                                   {
                               
                                     arret_Moteur_Bas ();
                                     rotation_Moteur_Haut ();
                                     
                                     //digitalWrite(relaisMoteurBas, LOW);
                                     //digitalWrite(relaisMoteurHaut, HIGH); // mise en rotation du moteur en HAUT
                                     delay(tempsMotorisation);                            // rotation pendand X milli seconde
                                     //digitalWrite(relaisMoteurHaut, LOW);
                                     rotation_Moteur_Haut ();
                               
                                   }                             
                                       else
                                       {
                                       }
                               
                               
                                 //digitalWrite(relaisMoteurHaut,LOW);
                                 //digitalWrite(relaisMoteurBas,LOW);
                                 
                                 arret_Moteur_Bas ();
                                 
                                 
                             }
           }
 
                else
           {
              //digitalWrite(relaisMoteurHaut,LOW);
              //digitalWrite(relaisMoteurBas,LOW);
              arret_Moteur_Haut ();
              arret_Moteur_Bas ();
             
           }
 
 
} // fin de void moteur vertical HAUT BAS
Patrick 47
 
Messages: 41
Inscription: Mar 24 Avr 2012 10:44

Re: Suivi du soleil avec une parabole motorisée

Message non lude Lionel » Mar 1 Mai 2012 16:10

Félicitations !!! Excellent boulot,
merci pour le partage d'infos !!
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Suivi du soleil avec une parabole motorisée

Message non lude Cassiope34 » Mar 1 Mai 2012 16:50

Vraiment EXCELLENT :D :D

comme toujours petites questions ;) :
- la longueur du tuyau a sûrement son importance ?
- pour la recherche automatique tu penses lui faire scanner tout le ciel ?
- un retour à la position orientée à l'EST (uniquement par le moteur horizontal) lorsque la nuit est détectée ne serait-il pas suffisant ?

Merci beaucoup Patrick.

@+
Cassiope34
 
Messages: 102
Inscription: Lun 16 Avr 2012 14:35

Re: Suivi du soleil avec une parabole motorisée

Message non lude Patrick 47 » Mar 1 Mai 2012 17:34

Pour le tube, plus c'est long, plus c'est (bon) précis.
Pour la recherche du soleil, je pense qu'un déplacement en diagonal est suffisant.
(hémisphère Nord ou Sud)

Pour la suite du programme, j'y réfléchirai dans la semaine.
Demain j'ai mes élèves de T TU (ceux qui bossent sur la partie mécanique), je mets en place les capteurs fin de courses.
Il y a aussi le traitement du vent, de la pluie.....

Pour ce soir je ferme mon ordi.

@+

Patrick.
Patrick 47
 
Messages: 41
Inscription: Mar 24 Avr 2012 10:44

Re: Suivi du soleil avec une parabole motorisée

Message non lude phil » Jeu 3 Mai 2012 10:15

all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 189
Inscription: Mer 7 Sep 2011 11:19

Précédente

Retourner vers Arduino

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité

cron