Mesure tension/intensité panneau solaire

Bonjour,

dans le cadre d'un projet pour mes études je dois mesurer la tension et l'intensité d'un panneau solaire afin d'en déduire sa puissance, le tout à l'aide d'arduino. Peu expérimenté dans le domaine, je sollicite votre aide car j'ai quelques soucis :)

j'ai un montage et un code récupérés d'une personne qui m'a précédé sur ce projet. Le montage est constitué d'un condensateur et de résistances qui permettent d'identifier le PPM - point de puissance maxi du panneau (en chargeant et déchargeant le condensateur de U=0 à sa tension nominale). La modèle d'arduino est une mini.

mon soucis est:

lorsque j'execute le programme, les valeurs de tension et d'intensité que je récupère sont toujours égales à 1023 (=5V) pendant toute l'acquisition de données (10 secondes) :( le résultat est identique si l'on teste le programme sur le montage non-relié au panneau solaire.

le code est dans le post suivant, certaines parties (notamment en commentaire) sont inutiles car la personne qui l'a écrit cherchait à réaliser en sus un interpréteur de commande.

Si vous avez des idées sur le pourquoi de ce résultat peu cohérent, et comment l'améliorer, je suis preneur ... Merci!

[code]

///////////////////////////////
// 1. Définition du contexte //
///////////////////////////////



// texte placé en début de la réponse de la carte arduino, suite à une commande envoyée depuis le PC
#define TXT_OK     "OK\n"
#define TXT_ERREUR "ERREUR\n"
#define TXT_FIN    "FINI\n"

// texte descriptif de chaque fonction - pour la fonction DESCRIPTIF
// séparateur des noms des fonctions - pour la fonction LISTE qui liste toutes les fonctions implémentées
#define SEPARATEUR ", "
// taille maximale des descriptifs de fonction - pour la fonction DESCRIPTIF qui decrit les paramètres d'une fonction
const static int NB_CARACT_MAX_DESC = 600;



const char PROGMEM desc_COURBE[NB_CARACT_MAX_DESC] = {
  //  ">> "
  //  fonction[COURBE]
  " [pin analog input tension] [pin analog input intensité] [pin output charge] [max nb mesures (>0)] [seuil haut tension] [seuil bas intensité]\n"
  "<< "
  TXT_OK
  "<< [temps 1 en us] [valeur tension de 0 à 1022] [valeur intensité de 0 à 1022]\n"
  "<< [temps 2 en us] [idem] [idem]\n"
  "<< [temps 3 en us] [idem] [idem]\n"
  "<< ...\n"
  "<< "
  TXT_FIN
  "--ou bien--\n"
  "<< "
  TXT_ERREUR
  "<< [détails]\n"
  "\n"
  "Exemple d'utilisation :\n"
  ">> COURBE 0 1 2 100 600 10\n"
  "<< 520 10 700\n"
  "<< 620 210 650\n"
  "<< 720 410 600\n"
  "<< 820 510 540\n"
  "<< 920 570 430\n"
  "<< 1020 610 150\n"
  "<< "
  TXT_FIN
  "// le seuil Vmax=600 est atteint.\n"
};

// caractéristiques de la carte Arduino Mini, puce ATMega328P
#define PIN_DIGIT_MIN   2
#define PIN_DIGIT_MAX   12 // et non 13, car le pin 13 n'est accessible qu'en série avec une résistance de 1Kohm sur le Arduino Mini
#define PIN_ANALOG_MIN  0
#define PIN_ANALOG_MAX  7

// nombre maximal d'argument que prend une fonction
const static int NB_MAX_ARG = 10;
// nombre maximal de caractères par argument
const static int NB_MAX_CAR_ARG = 30;


/////////////////////////////////////////////////////////////
// 2. Structure de base de traitement des commandes reçues //
/////////////////////////////////////////////////////////////

// le tableau des arguments, par exemple  " char[]{ char[]{'E','C'...LAIREMENT}, char[]{5}, char[]{3} "
char commande[NB_MAX_ARG + 1][NB_MAX_CAR_ARG + 1]; // '+1' pour inclure le caractère de fin '\0'
int numArgument = 0;
int numCaractArg = 0;
boolean commandeComplete = false;
// si trop d'arguments ou argument trop long
boolean erreurCommande = false;

// Fonction appelée une seule fois, à l'allumage de l'Arduino
void setup() {
  Serial.begin(9600);
  Serial.print(F("Programme MPPF lancé - VERSION SIMPLFIEE.\n"));
  Serial.print(F("\n"));
  Serial.print(F("Fonction COURBE lancée toute les 10 secondes.\n"));
  Serial.print(F("Mesures: tension sur A0, intensité sur A1.\n"));
  Serial.print(F("Commande charge sur 2.\n"));
  Serial.print(F("Parametres: 1000 mesures max, pas de seuil haut tension, pas de seuil bas intensité.\n\n"));
}

void gererCommande( char commande[NB_MAX_ARG + 1][NB_MAX_CAR_ARG + 1], int numDernierArgument, int numDernierCaractArg, boolean erreurCommande ) {
  /*
  if (erreurCommande) {
    //afficherArgumentsCommandeInvalide( commande, numArgument, numCaractArg);
    Serial.print(F(TXT_ERREUR));
    Serial.print(F("Explication non implementee..."));
  }
  else {
    int i;
    for (i = 0; i < NB_FONCTIONS; i++) {
      if ( strcmp(commande[0], nomCommande[i]) == 0 ) {
        switch (i) {
          case 0:
            liste();
            break;
          case 1:
            descriptif(0);//0=int idFct
            break;
          case 2:
             //void mpp(int pinInTension, int pinInIntensite, int pinOutCharge, int tpsMax, int precision);
             break;
          case 3:
            //void mpp_amplifie(int pinInTension, int pinInIntensite, int pinInIntensiteAmp, int gain, int pinOutCharge, int tpsMax, int precision);
            break;
          case 4:
            //void eclairement(int pinIn, int precision);
            break;
          case 5:
              courbe(0                , 1                , 2              , 1000           , 1023               , 0);
                    //int pinInTension,int pinInIntensite,int intOutCharge,int nbMaxMesures,int seuilHautTension,int seuilBasIntensite
              break;
          default:
        break;
        }
      }
    }
    // la fonction n'a pas été trouvée (i.e. il n'y a pas eu de break) :
    if (i == NB_FONCTIONS) {
      Serial.print(F(TXT_ERREUR));
      Serial.print(F("Commande '"));
      Serial.print(commande[0]);
      Serial.print(F("' inconnue, utilisez la commande '"));
      Serial.print(nomCommande[LISTE]);
      Serial.print(F("' pour obtenir la liste des fonctions implémentées.\n"));
    } else {
      
    }
  }
  // */
}

// Fonction appelée en boucle, indéfiniment
// consiste principalement à appeler la fonction gereCommande
void loop() {
  
  courbe(0/*int pinInTension*/, 1/*int pinInIntensite*/, 2/*int intOutCharge*/, 1000/*int nbMaxMesures*/, 1023/*int seuilHautTension*/, 0/*int seuilBasIntensite*/);
  delay(10000);
  
  // SerialEvent vient de terminer la lecture d'une ligne de commande
  if (commandeComplete) {

    gererCommande( commande, numArgument, numCaractArg, erreurCommande );

    // on réinitialise les comptes
    numArgument = 0;
    numCaractArg = 0;
    commandeComplete = false;
    erreurCommande = false;
  } else {
    delay(5);
  }
}

// Fonction appelée quand des données sont reçues par le port série. Vérifié à chaque fin de la fonction loop()
// gère l'arrivée d'un nouveau caractère sur le port série
void serialEvent() {
  /*
  while ( Serial.available() && !commandeComplete ) {
    // on recoit les caractères un à un
    char caract = (char) Serial.read();
    
    switch ( caract ) {
      
      case ' ':
        if ( !erreurCommande ) {
          // test pour le traitement des espaces successifs
          if ( numCaractArg != 0 ) {
            commande[numArgument][numCaractArg] = '\0';
            numArgument ++;
            numCaractArg = 0;
          }

          // la commande contient trop d'arguments
          if (numArgument > NB_MAX_ARG)
            erreurCommande = true;
        }
        break;

      case '\n':
        if(numArgument!=0){
          if(numCaractArg==0)
             numArgument--;
          commande[numArgument][numCaractArg] = '\0';
          numArgument+=1;
          commandeComplete = true;
        }
        break;

      default:
        if ( numCaractArg == NB_MAX_CAR_ARG )
          erreurCommande = true;
        else if ( !erreurCommande ) {
          commande[numArgument][numCaractArg] = caract;
          numCaractArg++;
        }
        break;
    }
  }*/
}


/* >> COURBE [pin analog input tension] [pin analog input intensité] [pin output charge] [max nb mesures (>0)] [seuil haut tension] [seuil bas intensité]\n"
 * << OK
 * << [temps 1 en us] [valeur tension de 0 à 1022] [valeur intensité de 0 à 1022]\n"
 * << [temps 2 en us] [idem] [idem]\n"
 * << [temps 3 en us] [idem] [idem]\n"
 * << ...\n"
 */
void courbe(int pinInTension, int pinInIntensite, int intOutCharge, int nbMaxMesures, int seuilHautTension, int seuilBasIntensite) {
  long tDebut;
  long delta;
  int mesI = 1023;
  int mesU = 0;

  int i = 0; // nombre de mesures déjà effectuées

  Serial.print(F(TXT_OK));
  //on lance la charge
  tDebut = micros();
  digitalWrite(intOutCharge, HIGH);
  //on effectue les mesures jusqu'à atteindre un seuil
  while ( (i < nbMaxMesures) /*&& (mesI > seuilBasIntensite) && (mesU < seuilHautTension) */) {
    delta = micros() - tDebut;
    mesI = analogRead(pinInIntensite);
    mesU = analogRead(pinInTension);

    Serial.print(delta);
    Serial.print(F(" "));
    Serial.print(mesU);
    Serial.print(F(" "));
    Serial.print(mesI);
    Serial.print(F("\n"));
    i++;
  }
  digitalWrite(intOutCharge, LOW);
  Serial.print(F(TXT_FIN));
}

[/code]

Tu as un schéma pour voir comment est réalisé ton montage ?

Bien sûr.

A l’heure actuelle on vérifie que ce montage est bien fait, on sait jamais.

Petite victoire: j'arrive maintenant parfaitement à lire la tension, il y avait une erreur de câblage ... :) Tout du moins, je récupère des valeurs cohérentes qui varient avec l'éclairement.

par contre pour l'intensité c'est pas gagné, elle stagne à des valeurs proches de 0 peu importe les conditions d'éclairement.

Comment l'électronique de commande est alimenté ? Sur ton schéma il semble que ce soit pas l'USB -- > un relais directement sur l'USB = pas bon = source de parasites.

D'autre part à quoi sert le rebouclage de A7 sur le Vcc ? Si tu reste avec la référence par defaut il sera impossible d'obtenir autre chose que 1023 quelquesoit la valeur de Vcc puisque tu te sers de Vcc comme réference. Si tu as réellement besoin de surveiller Vcc utilise le 3,3V comme référence externe et applique Vcc sur A7 par l'intermédiaire d'un pont diviseur.

j'arrive maintenant parfaitement à lire la tension

T'es tu assuré que la tension appliquée sur la broche A1 ne dépassera JAMAIS [Vcc+ 0,5 V] --> c'est dans la datasheet du micro-controleur

par contre pour l'intensité c'est pas gagné, elle stagne à des valeurs proches de 0 peu importe les conditions d'éclairement.

Explique comment tu compte mesurer le courant parce que je n'ai pas bien compris ton schéma.

bonjour est ce que tu peux partager avec nous ton rapport Merci