problème tension de 2 valeurs

bonjour, j'ai un soucis dans mon montage ou mon script. je veux mesurer 2 tensions, batterie et panneau solaire. si je connecte un seul des "modules", pas de problème la valeur est bonne. par contre si je connecte les 2 en même temps, les tensions s'ajoutent. ]:)

je récupère sur A0 et A1 les tensions le fait que mes 2 divider aient la même masse (soudées entre elles) pourrait créer ce problème, ou faut il mettre sur une masse différente chacun et sur un GND différent?

de quelles modules parles tu ?

batterie et panneau solaire

je viens de séparer sur ma platine de test les masses et sur l'arduino et tout est rentré dans l'ordre. si vous avez une explication, je prends, car je vais avoir d'autres capteurs de tension a mettre en place.

Iiiiiiiiiiiiiiiiiiirrrrrk !!! Je vais peut être dire une connerie donc à confirmer mais les port de l'arduino ne supporte pas plus que 5V ?! Tes "modules" son à 12V non ?

oui, pas plus de 5v, mais ne fais pas Iiiiiiiiiiiiiiiiiiirrrrrk !!! :grin: il y a un divider sur chaque avec une résistance de 4.7k et 1k. sinon il aurait grillé depuis un moment.

par contre, le bestio plante souvent.

C'est bizarre, je pensais qu'il fallait mettre les masses en commun (comme quand on contrôle un moteur 12v via un transistor)

D.

je viens de relance le bestio ce matin et même problème, il plante aléatoirement. est il susceptible à ce point dans les noms de variables? car avec le code ci dessous, il plante

  val = analogRead(batMonPin);    // read the voltage on the divider  
  pinVoltage = val * 0.00488;       //  Calculate the voltage on the A/D pin
  batteryVoltage = pinVoltage * ratio;
  Serial.println(batteryVoltage);

  val1 = analogRead(batMonPin1);    // read the voltage on the divider  
  pinVoltage1 = val1 * 0.00488;       //  Calculate the voltage on the A/D pin
  batteryVoltage1 = pinVoltage1 * ratio1;
  Serial.println(batteryVoltage1);

par contre en commentant pour la deuxième tension, il plante plus

  val = analogRead(batMonPin);    // read the voltage on the divider  
  pinVoltage = val * 0.00488;       //  Calculate the voltage on the A/D pin
  batteryVoltage = pinVoltage * ratio;
  Serial.println(batteryVoltage);

 // val1 = analogRead(batMonPin1);    // read the voltage on the divider  
 // pinVoltage1 = val1 * 0.00488;       //  Calculate the voltage on the A/D pin
 // batteryVoltage1 = pinVoltage1 * ratio1;
 // Serial.println(batteryVoltage1);

Oui les masses doivent être reliées entre elles, ...mais... à condition que ce soient vraiment des masses c'est à dire le 0 Volts. A ta place je referais mon câblage de A à Z, les erreurs les plus énormes sont souvent les moins évidentes à trouver parce qu'on se dit ce n'est pas possible je n'ai pas pu faire ça, eh bien si nous sommes capable de tout.

je suis partis de ce schéma donc 2 fois le même montage pour mesurer la tension de mon panneau et celle de la batterie, plus la cellule photosensible pour mon déclenchement. toutes les masses sont reliées sur le GND

je viens de décommenter mes lignes, ca a tourné 5mn et pif plantage à nouveau. j'ai eu un problème similaire avant hier avec un mot pour afficher une variable et qui faisait planter l'arduino

  Serial.print("Alarme Twitter: ");

remplacé par

  Serial.print("Twit: ");

et plus de plantage

#include <SD.h>
#include <Ethernet.h>
#include <SPI.h>
#include <TimedAction.h>
#define led  3
byte mac[] = {  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192,168,1,3 };
byte server[] = { x,x,x,x }; 
byte gateway[] = { 192,168,1,1 };			
byte subnet[] = { 255, 255, 255, 0 };   
int i = 1;
int compteur=0;
Client client(server, 80);
File myFile;
TimedAction timeconnection = 	TimedAction(50,connection);
int batMonPin = A0; 
int val = 0;   
float pinVoltage = 0; 
float batteryVoltage = 0;
float ratio = 5.5; 
int batMonPin1 = A1; 
int val1 = 0;
float pinVoltage1 = 0;
float batteryVoltage1 = 0;
float ratio1 = 5.5;
int led1 = 9;
int tempsaullume = 0;
int sensibilite = 0;
int photocellPin = A4;
int photocellVal = 0; 
void setup()
{
  pinMode(3, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(led, OUTPUT);
  pinMode(photocellPin, INPUT);
  pinMode(batMonPin, INPUT);
  pinMode(batMonPin1, INPUT);
  if (!SD.begin(4)) {
    Serial.println("failed!");
    return;
  }
  Serial.println("done.");
  Ethernet.begin(mac, ip,gateway,subnet);
  Serial.begin(9600);
  Serial.println("Connexion");
  Serial.println();
  delay(1000);
  Serial.println("connecting...");
  if (client.connect()) {
    Serial.println("connected");
    client.println("GET /~pilote/test.txt\n");
    client.println();
    if (SD.exists("test.txt")) {
      SD.remove("test.txt");
      Serial.println("efface test.txt...");
    }
  } 
  else {
    Serial.println("failed");
    i=0;
  }
}
void loop()
{
  switch (i){
  case 1:
    timeconnection.check();
    //Serial.println( i );
    break;
  case 0:
    recup();
    break;
  case 10:
    ledon();
    break;
  case 20:
    Serial.println("En attente");
    break;
  case 36:
    Serial.println( i );
    resetFunc();
    break;
  case 2:
    alarm();
    break; 
  case 30:
    twit();
    break; 
  }
}
int ar_strlen(const char *s)
{
  const char *p = s;
  while (*p != '\0')
    p++;
  return (size_t)(p - s);
}
char *ar_strchr(const char *s, int c)
{
  while (*s != '\0' && *s != (char)c)
    s++;
  return ( (*s == c) ? (char *) s : NULL );
}
char *ar_strstr(const char *haystack, const char *needle)
{
  size_t needlelen;
  if (*needle == '\0')
    return (char *) haystack;
  needlelen = ar_strlen(needle);
  for (; (haystack = ar_strchr(haystack, *needle)) != NULL; haystack++)
    if (ar_strncmp(haystack, needle, needlelen) == 0)
      return (char *) haystack;
  return NULL;
}
int ar_strncmp(const char *s1, const char *s2, size_t n)
{
  unsigned char uc1, uc2;
  if (n == 0)
    return 0;
  while (n-- > 0 && *s1 == *s2) {
    if (n == 0 || *s1 == '\0')
      return 0;
    s1++;
    s2++;
  }
  uc1 = (*(unsigned char *) s1);
  uc2 = (*(unsigned char *) s2);
  return ((uc1 < uc2) ? -1 : (uc1 > uc2));
}
int getNbr(char *line)
{
  int nbr;
  nbr = 0;
  while (*line >= '0' && *line <= '9') {
    nbr *= 10;
    nbr += *line - '0';
    line++;
  }
  return (nbr);
}

int getConf(char *val)
{
  File myFile;
  char line[100];
  char i;
  i = 0;
  if (!SD.exists("test.txt")) {
    myFile = SD.open("sos/test.txt");
    Serial.print(myFile);
  }
  else{
    myFile = SD.open("test.txt");
  }
  if (myFile > 0) {
    while ((line[i] = myFile.read()) > 0) {
      if (line[i] == '\n') {
        line[i] = '\0';
        i = 0;
        if (ar_strstr(line, val) && line[ar_strlen(val)] == '=') {
          myFile.close();
          return (getNbr(line + ar_strlen(val) + 1));
        }
      }
      else {
        ++i;
      }
    }
  }
  return 0;
}

void recup()
{
  Serial.print("Valeur sensibilite : ");
  Serial.print(getConf("sensibilite"));
  Serial.println("\n");
  Serial.print("Valeur lumiere : ");
  Serial.print(getConf("lumiere"));
  Serial.println("\n");
  Serial.print("Valeur lumiere1 : ");
  Serial.print(getConf("lumiere1"));
  Serial.println("\n");
  Serial.print("Valeur lumiere2 : ");
  Serial.print(getConf("lumiere2"));
  Serial.println("\n");
  Serial.print("Valeur lumieretemps 100: ");
  Serial.print(getConf("lumieretemps"));
  Serial.println("\n");
  Serial.print("Valeur lumieretemps 50: ");
  Serial.print(getConf("lumieretemps1"));
  Serial.println("\n");  
  Serial.print("Valeur lumieretemps 25: ");
  Serial.println(getConf("lumieretemps2"));
  Serial.println("\n");
  Serial.print("Twit: ");
  Serial.println(getConf("twit"));
  Serial.println("\n");
  i=2;
}
void alarm()
{
  val = analogRead(batMonPin);  
  pinVoltage = val * 0.00488;
  batteryVoltage = pinVoltage * ratio;
  Serial.println(batteryVoltage);
  delay(100);
  val1 = analogRead(batMonPin1);
  pinVoltage1 = val1 * 0.00488; 
  batteryVoltage1 = pinVoltage1 * ratio1;
  Serial.println(batteryVoltage1);  
  delay(100);
  photocellVal = analogRead(photocellPin);
  Serial.println(photocellVal);
    analogWrite(led1,255);
    delay(1000);
    analogWrite(led1,0);
    delay(1000);
    if (client.connect()) {
      Serial.println("Connexion au server");
      Serial.println();
      delay(1000);
      Serial.println("connected");
      client.print("GET /~pilote/test.php?mac=DE:AD:BE:EF:FE:ED&voltage=");
      client.print(batteryVoltage);
      client.print("&sensibilite=");
      client.print(photocellVal);       
      client.print("&panneau=");
      client.println(batteryVoltage1);  
      client.stop();
      //Serial.print("lumiere envoye");
      // Serial.println(lumiere);
      //delay(10000);
      for (int pause=0 ; pause < 50 ; pause++)
      {
        Serial.println(pause);
        analogWrite(led1,255);
        delay(1000);
        analogWrite(led1,0);
        delay(1000);
        photocellVal = analogRead(photocellPin);
        Serial.println(photocellVal);
        if (photocellVal < (getConf("sensibilite")*100))
        {
          i=10;
          break;
        }   
      }
      i=30;
    }
 }

void twit()
{
  if(getConf("twit")>0)
  {
    delay(60000);
    if (client.connect()) {
      Serial.println("Connexion au server");
      Serial.println();
      delay(1000);
      Serial.println("connected");
      client.print("GET /~pilote/twit.php?mac=DE:AD:BE:EF:FE:ED&voltage=");
      client.print(batteryVoltage);
      client.print("&sensibilite=");
      client.print(photocellVal);       
      //client.print("&panneau=");
      //client.println(batteryVoltage1);  
      client.stop();
    }
    i=36;
  }
  else{
    //         char msg[] = "batterie :",batteryVoltage;
    //   if (twitter.post(msg)) {
    //   int status = twitter.wait();
    //   if (status == 200) {
    //     Serial.println("OK.");
    //   }
    //   }
    i=36;
  }
}

void ledon()
{
  for (int tempsaullume=0 ; tempsaullume < (getConf("lumieretemps")*10) ; tempsaullume++)
  {
    photocellVal = analogRead(photocellPin);
    Serial.println(photocellVal); 
    Serial.println("lumiere"); 
    Serial.println(tempsaullume); 
    if (photocellVal > (getConf("sensibilite"))*100)
    {
      i=2;
      break;
    }
    analogWrite(led,getConf("lumiere"));
  }
  analogWrite(led,0);
  delay(3000);
  for (int tempsaullume=0 ; tempsaullume < (getConf("lumieretemps1")*10) ; tempsaullume++)
  {
    photocellVal = analogRead(photocellPin);
    Serial.println(photocellVal);  
    Serial.println("lumiere1");     
    if (photocellVal > (getConf("sensibilite"))*100)
    {
      i=2;
      break;
    }
    analogWrite(led,getConf("lumiere1"));
  }  
  analogWrite(led,0);
  delay(3000);
  for (int tempsaullume=0 ; tempsaullume < (getConf("lumieretemps2")*10) ; tempsaullume++)
  {
    photocellVal = analogRead(photocellPin);
    Serial.println(photocellVal); 
    Serial.println("lumiere2");      
    if (photocellVal > (getConf("sensibilite"))*100)
    {
      i=2;
      break;
    }
    analogWrite(led,getConf("lumiere2"));
  }  
  analogWrite(led,0);
  delay(10000);
  i=2;
}

void resetFunc()
{
  Serial.println("Reboot");
  delay(10000);
  //On déclare la fonction de reset de la carte
  void(* resetFunc) (void) = 0;
  Serial.println("Je reviens dans quelques secondes");
  resetFunc();  //call reset
}
void connection(){
  i=1;
  compteur = compteur + i;
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
    myFile = SD.open("test.txt", FILE_WRITE);
    if (myFile) {
      Serial.print("Writing to test.txt...");
      myFile.print(c);
      delay(500);
      // close the file:
      myFile.close();
      Serial.println("done.");
    }
  }
  if (!client.connected()) {
    Serial.println();
    Serial.println("DECONNEXION DU SERVER.");
    Serial.println("===");
    Serial.println("");
    i=0;
     myFile = SD.open("test.txt");
    if (myFile) {
      Serial.println("test.txt:");
      // read from the file until there's nothing else in it:
      while (myFile.available()) {
        Serial.write(myFile.read());
      }
      myFile.close();
      client.stop();
    }
  }

}

Moi, l’électronicien, je n’ai pas trop envie de décrypter toutes tes lignes de code je me limiterais au schéma électrique.

Les résistances R1 et R2 forment un pont diviseur (R2/(R1+R2)= 0,1408.
Si alim = 24V → entrée arduino = 3,38V
Pour commencer est-ce vérifié ? → mesure au multimètre avec l’arduino débranché.
Idem pour la panneau solaire : tension aux bornes du panneau puis tension au point commun R1/R2.

Si les tensions mesurées avec un multimètre sont bonnes → recommencer avec l’arduino raccordé.
Si les tensions ne sont plus bonnes (toujours mesurées au multimètre) → problème avec l’arduino.
Si les tensions sont toujours bonnes il est maintenant temps de regarder le code.

Edit : reprise du message qui est parti <tout seul> avant d’être terminé

résistance de R1 4.7k et R2 1k
les tensions sont bonnes à quelques 1/10eme de volts, différence avec un multi de super marché.
l’affichage sur la console est bonne aussi.
je sèche total sur ce coup.

serait il possible qu’il y ait un dépassement de mémoire, ce qui ferait planter l’arduino?
après compile, j’ai Binary sketch size: 20390 bytes (of a 32256 byte maximum)

J'ai une bonne nouvelle pour toi ! La dernière fois que mon arduino me faisait n'importe quoi sans aucune raison c'était un soucis de stockage de mémoire ! Passe tout ce que tu écris en print ou println en Flash !

lien: http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieFlashProgramme

En espérant que ça règle ton soucis ;)

JB

Question de néophyte :
Et si les chaînes de caractères étaient créées dans une fonction en variables locales, la mémoire RAM serait libérée à la sortie de la fonction ?

Vrai ou j’ai encore rien compris ?

bon le mystère est complet, à moins que, mais ce n'est qu'une supposition, l'upload du pde est buggé plusieurs fois d'affilé sans afficher d'erreur. j'ai uploadé un autre pde puis remis celui qui posait problème. et là, ca plante plus. :fearful: 3h que ca tourne comme une horloge.

68tjs: Question de néophyte : Et si les chaînes de caractères étaient créées dans une fonction en variables locales, la mémoire RAM serait libérée à la sortie de la fonction ?

Vrai ou j'ai encore rien compris ?

Normalement il me semble que oui, une variable local à un bloc ce retrouve dé référencée en sortie de celui-ci, son emplacement mémoire est déclaré comme libre à de nouvelles valeurs (mais contiendra toujours cette valeur temps qu'une autre n'est pas venue "l'écrasé", c'est pourquoi il est important d'initialisé ses variables même à une valeur nulle).