Go Down

Topic: presentation personel + projet (Read 426 times) previous topic - next topic

Andarlo

Jul 11, 2018, 07:31 am Last Edit: Jul 16, 2018, 04:38 pm by Andarlo
bonjour j'ai 32 ans et je suis de Toulouse.

J'ai pour idée de faire un tracker solaire je sais que le sujet a déjà été mainte et mainte fois vu mais je ne trouve pas les info nécessaire .

je n'y connais rien en programmation et donc je décrypte au fut et a mesure les programmes comme je le peux .

voila j'ai pour idée que mon tracker solaire sois gérée pour une Arduino donc et deux moteur 12v DCC.

J'ai en ma possession une Arduino nano ,un pont H, et deux moteur DCC 12v et une petit bout de panneaux solaire 16v pour commencer et a améliorée bien sur.

je vous joint mon bout de code que J'ai plagier a droit et gauche  .

merci de votre retour .

cordialement
Code: [Select]
[
/*
Programme tracker solair V1.1
Date : 11/07/2018
Auteur : ***********************
*/

// 4 LdRs capteurs de lumière

int PinLdrEst      = A0; //LDR haut gauche
int PinLdrOuest    = A1; //LDR haut droit
int PinLdrHauteurd = A2; //LDR bas droit
int PinLdrHauteurg = A3; //LDR bas gauche
int Ecart          = 40;

// 2 moteurs horizontal Est/Ouest et vertical Haut/Bas
//Mot H
const int ENA = 10;
const int IN1 = 9;
const int IN2 = 8;
//Mot V
const int ENB = 5;
const int IN3 = 6;
const int IN4 = 7;
int lumi = 900;         // intensité lumineuse minimum


void setup()
{
 Serial.begin(9600);         // lecture écran
 pinMode(PinLdrEst,INPUT);   // entrées / sorties Ldrs 
 pinMode(PinLdrOuest,INPUT);
 pinMode(PinLdrHauteurd,INPUT);
 pinMode(PinLdrHauteurg,INPUT);
 pinMode(ENA, OUTPUT);       //moteurs
 pinMode(ENB, OUTPUT);
 pinMode(IN1, OUTPUT);
 pinMode(IN2, OUTPUT);
 pinMode(IN3, OUTPUT);
 pinMode(IN4, OUTPUT);

 delay(500);
}

void loop()
{


 int ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs                     
 int ValLdrOuest = analogRead(PinLdrOuest);
 int ValLdrHauteurd = analogRead(PinLdrHauteur);
 int ValLdrHauteurg = analogRead(PinLdrHauteur);
 //int Bas = (ValLdrHauteurd + ValLdrHauteurg) / 2;

 Serial.print("   HD "); Serial.println(ValLdrHauteurd);
 Serial.print("   E "); Serial.println(ValLdrEst);
 Serial.print("   O "); Serial.println(ValLdrOuest);
 Serial.print("   HG "); Serial.println(ValLdrHauteurg);

 int test = ValLdrEst + ValLdrOuest + ValLdrHauteurd + ValLdrHauteurg;  // établit la luminosité ambiante
 test = test / 4;                   
 Serial.print("  test ");
 Serial.print (test);
 Serial.print("  ");

 int Diff1 = ValLdrEst - ValLdrOuest;
 Diff1 = abs(Diff1);
 int Diff2 = ValLdrHauteurd - ValLdrHauteurg;
 Diff2 = abs(Diff2);

if (test <= lumi || Diff1 <= Ecart || Diff2 <= Ecart)
{
   digitalWrite(ENA, LOW);  // les 2 Moteurs sont arrétés !
   digitalWrite(ENB, LOW);
}         
if (test >= lumi && ValLdrEst < ValLdrOuest && Diff1 > Ecart)
{
   digitalWrite(IN1, LOW);  // Moteur H tourne dans un sens
   digitalWrite(IN2, HIGH);
   analogWrite(ENA, 130);
   Serial.println(" Est < Ouest");
}
else if (test >= lumi && ValLdrEst > ValLdrOuest && Diff1 > Ecart)
{
   digitalWrite(IN1, HIGH);  // Moteur H tourne dans l'autre sens
   digitalWrite(IN2, LOW);
   analogWrite(ENA, 130);
   Serial.println(" Est > Ouest ");
}

 // SENS vertical 
 if(test >= lumi && ValLdrHauteurd < ValLdrHauteurg && Diff2 > Ecart)
{
   digitalWrite(IN3, LOW);  // Moteur V tourne dans un sens
   digitalWrite(IN4, HIGH);
   analogWrite(ENB, 120);
   Serial.println(" Hauteur < Bas"); 
}
else if (test >= lumi && ValLdrHauteurd > ValLdrHauteurg && Diff2 > Ecart)
{
   digitalWrite(IN3, HIGH);  // Moteur V tourne dans l'autre sens
   digitalWrite(IN4, LOW);
   analogWrite(ENB, 120);
   Serial.println(" Hauteur > Bas ");
}
  delay (1000);
}

]





J-M-L

#1
Jul 11, 2018, 08:45 am Last Edit: Jul 11, 2018, 08:46 am by J-M-L
Bonjour

Et quelle est votre question ?

------------------


Merci de bien lire les règles du forum pour poster du code; corrigez votre post ci dessus, mettez le code dans le post et rajoutez les code tags autour du code:
[code] // votre code ici [/code].

ça doit ressembler à cela:
Code: [Select]
// votre code ici
(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement)

Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums
Pas de messages privés SVP

lesept

Bonjour
Ton code a l'air bien. Deux petites choses cependant :

  • La première lecture d'un pin analogique est toujours fausse. Pour éviter ça, tu devrais dupliquer les 4 lignes de lecture des pins analogiques dans le setup (tu les conserves dans la loop) afin d'avoir une phase de lecture "à blanc" qui règle ce problème.
  • Tel qu'il est écrit, ton code va constamment faire des mesures et des corrections de position du panneau solaire, et ceci à "grande vitesse" puisque tu mets le PWM à 120-130 soit près de la moitié de la vitesse maximale. Ça risque de consommer plus que ce que ça va produire :) Tu devrais te tourner vers un régulateur PID pour positionner le panneau de manière qu'il ne fasse que des petites corrections autour de la position optimale.
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

J-M-L

#3
Jul 11, 2018, 09:00 pm Last Edit: Jul 11, 2018, 09:02 pm by J-M-L
Quote
La première lecture d'un pin analogique est toujours fausse.
Non c'est une légende urbaine qui se propage sur le forum - ce n'est pas cela, il  faut pas lire les 4 pins dans le setup ça sert absolument à rien

Le soucis que vous pouvez rencontrer c'est quand vous lisez deux pins différentes rapidement (consecutiveent) et qu'il y a une grosse différence de potentiel entre ces pins - comme il n'y a qu'un seul convertisseur il se peut dans ce cas que la lecture soit faussée à cause du temps de stabilisation du condensateur qui sert à la mesure.

=> Donc lire les 4 pins dans le setup ne sert absolument à rien - par contre dans la loop éventuellement faire 2 lectures par pins pour s'assurer de la stabilisation de l'entree Choisie xonnectee à l'étage de  l'ADC (mais comme elles seront quand même route plus ou moins éclairées il
Ne devrait pas y avoir une mega différence de potentiel)
Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums
Pas de messages privés SVP

Andarlo

#4
Jul 12, 2018, 07:51 am Last Edit: Jul 12, 2018, 08:55 am by Andarlo
bonjour et encore merci pour vos réponse , j'espère avoir bien fait pour le code sur le 1er post dsl.

après vous allez un peu vite pour moi , dit moi si j'ai bien compris donc il faut que je place
// pinMode(PinLdrEst,INPUT);   
   pinMode(PinLdrOuest,INPUT);
   pinMode(PinLdrHauteurd,INPUT);
   pinMode(PinLdrHauteurg,INPUT);

dans le loop et que je passe a un delay(500) a (5000) par exemple pour donner le temps de bien calculer .
pour info je fait met test virtuel avec Tinkercad.

a oui pk quand je start mon code j'ai la valeur de mes ldr qui varie toute seul étant donner que c virtuel et que rien n'est brancher sur la carte ?

et petit question comment vous feriez pour que arriver a un point précis dans le temps ou sur un nombre de tour du moteur dcc par exemple le programme retourne a un point de départ (faut il mettre des End stop ) .

merci encore

lesept

Non

Je suggérais de copier ces lignes dans le setup :
Code: [Select]
  int ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs                     
  int ValLdrOuest = analogRead(PinLdrOuest);
  int ValLdrHauteurd = analogRead(PinLdrHauteur);
  int ValLdrHauteurg = analogRead(PinLdrHauteur);

J-M-L dit que ce n'est pas nécessaire, par contre, il propose de les dupliquer. Ca reviendrait, si je comprends bien à les remplacer par :

Code: [Select]
  int ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs                     
  int ValLdrEst = analogRead(PinLdrEst);
  int ValLdrOuest = analogRead(PinLdrOuest);
  int ValLdrOuest = analogRead(PinLdrOuest);
  int ValLdrHauteurd = analogRead(PinLdrHauteur);
  int ValLdrHauteurd = analogRead(PinLdrHauteur);
  int ValLdrHauteurg = analogRead(PinLdrHauteur);
  int ValLdrHauteurg = analogRead(PinLdrHauteur);
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

kamill

#6
Jul 12, 2018, 10:22 am Last Edit: Jul 12, 2018, 10:32 am by kamill
Bonjour,

La proposition de J-M-L est bonne, mais bien sur il ne faut pas dupliquer la définition des variables.
Ce qui donne:
Code: [Select]
  analogRead(PinLdrEst); int ValLdrEst = analogRead(PinLdrEst);
  analogRead(PinLdrOuest); int ValLdrOuest = analogRead(PinLdrOuest);
  analogRead(PinLdrHauteurd); int ValLdrHauteurd = analogRead(PinLdrHauteurd);
  analogRead(PinLdrHauteurg); int ValLdrHauteurg = analogRead(PinLdrHauteurg);

lesept

C'est juste, je suis allé un peu vite...
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

Andarlo

merci beaucoup les gas mais en simulation je ne comprend pas pourquoi mais ldr varie alors que rien n'est brancher sur mon Arduino .

j'ai lu le post de Uzuma sur son tracker mais a par des questions je n'ai pas trouver le bonheur si je puis dire .


hbachetti

Si une entrée analogique est laissée en l'air, sa haute impédance fait varier son potentiel dans tous les sens. Mets ton doigt dessus et tu liras d'autres valeurs.

pinMode() pour une entrée analogique n'a aucun effet. C'est une fonction prévue pour les I/O digitales.

@+
Linux is like a wigwam: no Windows, no Gates, and an Apache inside ...

Andarlo

#10
Jul 16, 2018, 03:24 pm Last Edit: Jul 16, 2018, 04:26 pm by Andarlo
salut a tous dsl mais je suis a contre courant je ne comprend pas se qui parais si simple pour vous .

quelle qu'un de charitable pourrais prendre le temps de m'expliquer en détail la réponse de hbachetti.
car je suis comme st Thomas ce que je vois pas je le comprend pas  lol  mais la logique de ce programme puffff me dépasse . le pinMode() par exemple g pas compris car comme je l'ai dit g récupéré ce programme qui me semble adéquate pour mon projet  et que je voudrais mettre en route ; j'y ai inclu une horloge car je voudrai que tout les jours a 22h30 celui ci revien a son point de depart qui sera un contacteur end stop qu'il faudrat inclure en fin de boucle loop je supose avec un if l'heure .

ps: ctrl-T m'ouvre une nouvelle page internet donc je repose mon code comme plus haut dsl .

encore merci pour votre temps
..

Andarlo

#11
Jul 16, 2018, 04:26 pm Last Edit: Jul 16, 2018, 04:37 pm by Andarlo
Code: [Select]
[/*
Programme tracker solair V1.2
Date : 11/07/2018
Auteur : ***********************
*/
//-------------------------------------------------
/* Dépendances */
#include <Wire.h>
//----------------------------
/** Adresse I2C du module RTC DS1307 */
const uint8_t DS1307_ADDRESS = 0x68;
/** Adresse du registre de contrôle du module RTC DS1307 */
const uint8_t DS1307_CTRL_REGISTER = 0x07;
/** Adresse et taille de la NVRAM du module RTC DS1307 */
const uint8_t DS1307_NVRAM_BASE = 0x08;
const uint8_t DS1307_NVRAM_SIZE = 56;
/** Structure contenant les informations de date et heure en provenance ou à destination du module RTC */
typedef struct {
 uint8_t seconds; /**!< Secondes 00 - 59 */
 uint8_t minutes; /**!< Minutes 00 - 59 */
 uint8_t hours;  /**!< Heures 00 - 23 (format 24h), 01 - 12 (format 12h) */
 uint8_t is_pm; /**!< Vaut 1 si l'heure est en format 12h et qu'il est l'aprés midi, sinon 0 */
 uint8_t day_of_week;  /**!< Jour de la semaine 01 - 07, 1 = lundi, 2 = mardi, etc.  */
 uint8_t days; /**!< Jours 01 - 31 */
 uint8_t months;  /**!< Mois 01 - 12 */
 uint8_t year;  /**!< Année au format yy (exemple : 16 = 2016) */
} DateTime_t;
/** Mode de fonctionnement pour la broche SQW */
typedef enum {
 SQW_1_HZ = 0, /**!< Signal à 1Hz sur la broche SQW */
 SQW_4096_HZ,  /**!< Signal à 4096Hz sur la broche SQW */
 SQW_8192_HZ,  /**!< Signal à 8192Hz sur la broche SQW */
 SQW_32768_HZ, /**!< Signal à 32768Hz sur la broche SQW */
 SQW_DC /**!< Broche SQW toujours à LOW ou HIGH */
} DS1307_Mode_t;

//#endif /* DS1307_H */
//----------------------------
//#include "DS1307.h"


/* Rétro-compatibilité avec Arduino 1.x et antérieur */
#if ARDUINO >= 100
#define Wire_write(x) Wire.write(x)
#define Wire_read() Wire.read()
#else
#define Wire_write(x) Wire.send(x)
#define Wire_read() Wire.receive()
#endif


/** Fonction de conversion BCD -> decimal */
byte bcd_to_decimal(byte bcd) {
 return (bcd / 16 * 10) + (bcd % 16);
}

/** Fonction de conversion decimal -> BCD */
byte decimal_to_bcd(byte decimal) {
 return (decimal / 10 * 16) + (decimal % 10);
}


/**
* Fonction récupérant l'heure et la date courante à partir du module RTC.
* Place les valeurs lues dans la structure passée en argument (par pointeur).
* N.B. Retourne 1 si le module RTC est arrêté (plus de batterie, horloge arrêtée manuellement, etc.), 0 le reste du temps.
*/
byte read_current_datetime(DateTime_t *datetime) {
 
 /* Début de la transaction I2C */
 Wire.beginTransmission(DS1307_ADDRESS);
 Wire_write((byte) 0); // Lecture mémoire à l'adresse 0x00
 Wire.endTransmission(); // Fin de la transaction I2C

 /* Lit 7 octets depuis la mémoire du module RTC */
 Wire.requestFrom(DS1307_ADDRESS, (byte) 7);
 byte raw_seconds = Wire_read();
 datetime->seconds = bcd_to_decimal(raw_seconds);
 datetime->minutes = bcd_to_decimal(Wire_read());
 byte raw_hours = Wire_read();
 if (raw_hours & 64) { // Format 12h
   datetime->hours = bcd_to_decimal(raw_hours & 31);
   datetime->is_pm = raw_hours & 32;
 } else { // Format 24h
   datetime->hours = bcd_to_decimal(raw_hours & 63);
   datetime->is_pm = 0;
 }
 datetime->day_of_week = bcd_to_decimal(Wire_read());
 datetime->days = bcd_to_decimal(Wire_read());
 datetime->months = bcd_to_decimal(Wire_read());
 datetime->year = bcd_to_decimal(Wire_read());
 
 /* Si le bit 7 des secondes == 1 : le module RTC est arrêté */
 return raw_seconds & 128;
}


/**
* Fonction ajustant l'heure et la date courante du module RTC à partir des informations fournies.
* N.B. Redémarre l'horloge du module RTC si nécessaire.
*/
void adjust_current_datetime(DateTime_t *datetime) {
 
 /* Début de la transaction I2C */
 Wire.beginTransmission(DS1307_ADDRESS);
 Wire_write((byte) 0); // Ecriture mémoire à l'adresse 0x00
 Wire_write(decimal_to_bcd(datetime->seconds) & 127); // CH = 0
 Wire_write(decimal_to_bcd(datetime->minutes));
 Wire_write(decimal_to_bcd(datetime->hours) & 63); // Mode 24h
 Wire_write(decimal_to_bcd(datetime->day_of_week));
 Wire_write(decimal_to_bcd(datetime->days));
 Wire_write(decimal_to_bcd(datetime->months));
 Wire_write(decimal_to_bcd(datetime->year));
 Wire.endTransmission(); // Fin de transaction I2C
}
//-------------------------------------------------


// 4 LdRs capteurs de lumière

int PinLdrEst      = A0; //LDR haut gauche
int PinLdrOuest    = A1; //LDR haut droit
int PinLdrHauteurd = A2; //LDR bas droit
int PinLdrHauteurg = A3; //LDR bas gauche
int Ecart          = 40;

// 2 moteurs horizontal Est/Ouest et vertical Haut/Bas
//Mot H
const int ENA = 10;
const int IN1 = 9;
const int IN2 = 8;
//Mot V
const int ENB = 5;
const int IN3 = 6;
const int IN4 = 7;
int lumi = 900;         // intensité lumineuse minimum


void setup()
{
//-----------------------------------------------
/* Initialise le port série */
 Serial.begin(115200);
 
 /* Initialise le port I2C */
 Wire.begin();
 
 /* Vérifie si le module RTC est initialisé */
 DateTime_t now;
 if (read_current_datetime(&now)) {
   Serial.println(F("L'horloge du module RTC n'est pas active !"));
   
   // Reconfiguration avec une date et heure en dure (pour l'exemple)
   now.seconds = 0;
   now.minutes = 0;
   now.hours = 12; // 12h 0min 0sec
   now.is_pm = 0;
   now.day_of_week = 4;
   now.days = 1;
   now.months = 12;
   now.year = 16; // 1 dec 2016
   adjust_current_datetime(&now);
 }

//-----------------------------------------------


 Serial.begin(9600);         // lecture écran
 pinMode(PinLdrEst,INPUT);   // entrées / sorties Ldrs
 pinMode(PinLdrOuest,INPUT);
 pinMode(PinLdrHauteurd,INPUT);
 pinMode(PinLdrHauteurg,INPUT);
 pinMode(ENA, OUTPUT);       //moteurs
 pinMode(ENB, OUTPUT);
 pinMode(IN1, OUTPUT);
 pinMode(IN2, OUTPUT);
 pinMode(IN3, OUTPUT);
 pinMode(IN4, OUTPUT);
 
 
 delay(500);
}

void loop()
{
//----------------------------------------------
/* Lit la date et heure courante */
 DateTime_t now;
 if (read_current_datetime(&now)) {
   Serial.println(F("L'horloge du module RTC n'est pas active !"));
 }
 
 /* Affiche la date et heure courante */
 Serial.print(F("Date : "));
 Serial.print(now.days);
 Serial.print(F("/"));
 Serial.print(now.months);
 Serial.print(F("/"));
 Serial.print(now.year + 2000);
 Serial.print(F("  Heure : "));
 Serial.print(now.hours);
 Serial.print(F(":"));
 Serial.print(now.minutes);
 Serial.print(F(":"));
 Serial.println(now.seconds);
 
 /* Rafraichissement une fois par seconde */
 delay(1000);
//----------------------------------------------
 analogRead(PinLdrEst);
 int ValLdrEst = analogRead(PinLdrEst);
 analogRead(PinLdrOuest);
 int ValLdrOuest = analogRead(PinLdrOuest);
 analogRead(PinLdrHauteurd);
 int ValLdrHauteurd = analogRead(PinLdrHauteurd);
 analogRead(PinLdrHauteurg);
 int ValLdrHauteurg = analogRead(PinLdrHauteurg);

 Serial.print("   HD "); Serial.println(ValLdrHauteurd);
 Serial.print("   E "); Serial.println(ValLdrEst);
 Serial.print("   O "); Serial.println(ValLdrOuest);
 Serial.print("   HG "); Serial.println(ValLdrHauteurg);

 int test = ValLdrEst + ValLdrOuest + ValLdrHauteurd + ValLdrHauteurg;  // établit la luminosité ambiante
 test = test / 4;                   
 Serial.print("  test ");
 Serial.print (test);
 Serial.print("  ");

 int Diff1 = ValLdrEst - ValLdrOuest;
 Diff1 = abs(Diff1);
 int Diff2 = ValLdrHauteurd - ValLdrHauteurg;
 Diff2 = abs(Diff2);

if (test <= lumi || Diff1 <= Ecart || Diff2 <= Ecart)
{
   digitalWrite(ENA, LOW);  // les 2 Moteurs sont arrétés !
   digitalWrite(ENB, LOW);
}         
if (test >= lumi && ValLdrEst < ValLdrOuest && Diff1 > Ecart)
{
   digitalWrite(IN1, LOW);  // Moteur H tourne dans un sens
   digitalWrite(IN2, HIGH);
   analogWrite(ENA, 130);
   Serial.println(" Est < Ouest");
}
else if (test >= lumi && ValLdrEst > ValLdrOuest && Diff1 > Ecart)
{
   digitalWrite(IN1, HIGH);  // Moteur H tourne dans l'autre sens
   digitalWrite(IN2, LOW);
   analogWrite(ENA, 130);
   Serial.println(" Est > Ouest ");
}

 // SENS vertical
 if(test >= lumi && ValLdrHauteurd < ValLdrHauteurg && Diff2 > Ecart)
{
   digitalWrite(IN3, LOW);  // Moteur V tourne dans un sens
   digitalWrite(IN4, HIGH);
   analogWrite(ENB, 120);
   Serial.println(" Hauteur < Bas");
}
else if (test >= lumi && ValLdrHauteurd > ValLdrHauteurg && Diff2 > Ecart)
{
   digitalWrite(IN3, HIGH);  // Moteur V tourne dans l'autre sens
   digitalWrite(IN4, LOW);
   analogWrite(ENB, 120);
   Serial.println(" Hauteur > Bas ");
}
  delay (9000);
}]

lesept

STP, édite tes messages en mode  "modify" : tu sélectionnes les lignes de code et tu appuies sur la touche </>
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

Andarlo


lesept

Merci, c'est plus confortable pour la lecture.

Le CTRL T est à faire dans l'IDE, pas dans le navigateur, pour bien indenter le code. Ça aide aussi pour la lecture et la recherche des blocs { ... }
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

Go Up