Alimentation Mega avec chargeur USB

Bonjour,

Je suis en train de finaliser une station météo connectée et j’ai un problème pour la rendre indépendante de mon PC, lorsque la partie réceptrice des données gérée par une Mega 2560 est alimentée par USB via mon PC, tout fonctionne bien et lorsque je l’alimente par transfo USB (chargeur de portable 5V 1A) cela ne fonctionne plus.

Présentation du projet :

  • Les capteurs extérieurs (BMP280, DHT22, détecteur de pluie et pluviomètre à bascule maison) sont reliés à une Nano qui envoit les données par module radio 433 Mhz.

  • Les données sont réceptionnées par une Mega 2560 via le module radio, stockées sur carte SD et envoyées à Thingspeak par ethernet (module ENC28J60), j’ai ajouté un RTC DS1307 pour l’horodatage des données stockées sur carte SD.
    La partie module SD et Ethernet est alimentée à part en 3.3V avec un transfo 4.5V et un module AMS1117.

Lorsque ma carte Mega est branchée au PC les données reçues sont bien envoyées par ethernet à Thingspeak (évolution des graphs sur le site), mais dès lors que je l’alimente par un transfo de portable 5V, plus rien ne part de ma carte. J’ai mis une Led sur mon montage pour voir quand le bug se produit et c’est à l’initialisation du module Ethernet que ça s’allume.

Je ne comprend pas qu’il y ait une différence entre ces deux modes d’alimentation qui sont pour moi identiques !!!

Merci de bien vouloir m’éclairer ?

Salut

Tu vas te faire remonter les bretelles si on n'a pas un montage et un code, camarade!

Est-ce que tu commandes quelque chose DEPUIS le pc ?
Et si tu essayais de faire comme d'habitude, avec le câble USB sur le pc, MAIS en alimentant progressivement tes modules en externe? Tu finiras par trouver qui fout le boxon.
Cela dit, je vois pas ce qui peut clocher, sans code ni montage électrique, impossible de savoir.

Salut,

Je ne commande rien depuis le pc, je lis juste les infos reçues de ma nano et surveille l’envoi des données vers le net.

Voir le montage ci dessous:

Le code côté Méga va surement être trop long on va voir !!! et oui, la suite dans le post suivant !!

#include <EtherCard.h>

// change these settings to match your own setup
//#define FEED "000"
#define APIKEY "1J48PY5G6ZXII8NR" // put your key here
#define ethCSpin 53 // put your CS/SS pin here.
const int LedEther = 28;

// ethernet interface mac address, must be unique on the LAN
static byte mymac[] = { 0x74, 0x69, 0x69, 0x2D, 0x30, 0x31 };
//static byte my_ip[] = { 192, 168, 1, 21 };
const char website[] PROGMEM = "api.thingspeak.com";
byte Ethernet::buffer[700];
uint32_t timer;
Stash stash;
byte session;

//timing variable
int res = 100; // was 0
int Rd1;
int Rd = 0;


// Module Radio-----------------------------------
#include <DataCoder.h>
#include <VirtualWire.h>

// Include dependant SPI Library
#include <SPI.h>
const int rx_pin = 11;
const int led_pin = 13;
const int baudRate = 1000;


//----------Températures mini/maxi---------------------------
float tempmax = -100;
float tempmin = 100;


//Variables de Données reçues-------------------------
float humid;
float temp;
float pression;
float pressionrecu;
float pluie;
float pluviometrie;


// ---------------DS1307--------------------------
#include <Wire.h>
#define DS3231_I2C_ADDRESS 0x68
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
  return ( (val / 10 * 16) + (val % 10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
  return ( (val / 16 * 10) + (val % 16) );
}


// -----------------------SD--------------------
#include <SD.h>   // Pour la communication avec la carte SD
const byte SDCARD_CS_PIN = 4; // A remplacer suivant votre shield SD
const char* OUTPUT_FILENAME = "donnees.csv";
File file;
const int LedSd = 46;

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

void setup () {
  Wire.begin();
  Serial.begin(9600);
  // set the initial time here:
  // DS3231 seconds, minutes, hours, day, date, month, year
  // setDS3231time(00,14,16,4,24,05,18); //Pour reconfigurer la date voir en fin de sketch

  // Module radio / Data Coder
  pinMode(led_pin, OUTPUT);
  digitalWrite(led_pin, LOW);
  SetupRFDataRxnLink(rx_pin, baudRate);

  // pinMode(BrocheRecep, OUTPUT);
  pinMode(SDCARD_CS_PIN, OUTPUT);  // broche CS SD
  pinMode(ethCSpin, OUTPUT); // broche CS Ethernet
  pinMode(LedSd, OUTPUT);// Led réinitialisation Sd
  pinMode(LedEther, OUTPUT);// Led réinitialisation Ethernet

  digitalWrite(SDCARD_CS_PIN, LOW);
  digitalWrite(ethCSpin, HIGH);
  initialiseSD();
  digitalWrite(SDCARD_CS_PIN, HIGH);
  digitalWrite(ethCSpin, LOW);

  Serial.println("\n[ThingSpeak example]");

  //Initialize Ethernet
  initialize_ethernet();


}


void loop () {

  //ReceptionDonnees();
  displayTime(); // display the real-time clock data on the Serial Monitor,
  //delay(1000); // every second
  //if correct answer is not received then re-initialize ethernet module
  if (res > 220) {
    initialize_ethernet();
  }

  res = res + 1;
  Rd = res / 10;

  ether.packetLoop(ether.packetReceive());
  Serial.println(res);
  //200 res = 10 seconds (50ms each res)
  //if (res == 10 || res == 30 || res == 50 || res == 70 || res == 90 || res == 110 || res == 130 || res == 150 || res == 170 || res == 185 || res == 190 || res == 195)
  if (Rd1 != Rd)
  {
    ReceptionDonnees();
    Rd1 = Rd;
  }
  if (res == 100) {
    digitalWrite(SDCARD_CS_PIN, LOW);
    digitalWrite(ethCSpin, HIGH);
    ecritureDonneesCarte();
    digitalWrite(SDCARD_CS_PIN, HIGH);
    digitalWrite(ethCSpin, LOW);
  }
  if (res == 200) {



    // generate two fake values as payload - by using a separate stash,
    // we can determine the size of the generated message ahead of time
    // field1=(Field 1 Data)&field2=(Field 2 Data)&field3=(Field 3 Data)&field4=(Field 4 Data)&field5=(Field 5 Data)&field6=(Field 6 Data)&field7=(Field 7 Data)&field8=(Field 8 Data)&lat=(Latitude in Decimal Degrees)&long=(Longitude in Decimal Degrees)&elevation=(Elevation in meters)&status=(140 Character Message)
    byte sd = stash.create();
    stash.print("field1=");
    stash.print(temp);
    stash.print("&field2=");
    stash.print(humid);
    stash.print("&field3=");
    stash.print(pression);
    stash.print("&field4=");
    stash.print(tempmax);
    stash.print("&field5=");
    stash.print(tempmin);
    stash.print("&field6=");
    stash.print(pluie);
    stash.print("&field7=");
    stash.print(pluviometrie);

    stash.save();

    //Display data to be sent
    Serial.print(temp);
    Serial.println(" dg.C");
    Serial.print(humid);
    Serial.println(" %H");
    Serial.print(pression);
    Serial.println(" hPa");
    Serial.print(tempmax);
    Serial.println(" dg.C");
    Serial.print(tempmin);
    Serial.println(" dg.C");
    if (pluie == 0) {
      Serial.println("Il ne pleut pas");
    }
    if (pluie == 1) {
      Serial.println("Il commence à pleuvoir");
    }
    if (pluie == 2) {
      Serial.print("Il a plu :");
      Serial.print(pluviometrie);
      Serial.println(" mm");
    }




    // generate the header with payload - note that the stash size is used,
    // and that a "stash descriptor" is passed in as argument using "$H"
    Stash::prepare(PSTR("POST /update HTTP/1.0" "\r\n"
                        "Host: $F" "\r\n"
                        "Connection: close" "\r\n"
                        "X-THINGSPEAKAPIKEY: $F" "\r\n"
                        "Content-Type: application/x-www-form-urlencoded" "\r\n"
                        "Content-Length: $D" "\r\n"
                        "\r\n"
                        "$H"),
                   website, PSTR(APIKEY), stash.size(), sd);

    // send the packet - this also releases all stash buffers once done
    session = ether.tcpSend();

    // added from: http://jeelabs.net/boards/7/topics/2241
    int freeCount = stash.freeCount();
    if (freeCount <= 3) {
      Stash::initMap(56);
    }

  }  // aici se termina bucla de transmisie

  const char* reply = ether.tcpReply(session);

  if (reply != 0) {
    res = 0;
    Serial.println(F(" >>>REPLY recieved...."));
    Serial.println(reply);

  }
  delay(1000);
  //   delay(150);

}  // end main loop

void ReceptionDonnees()
{
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;

  union RFData inDataSeq;//To store incoming data

  float inArray[RF_DATA_ARRAY_SIZE];//To store decoded information
  //RF_DATA_ARRAY_SIZE can be changed if need be inside DataCoder.h


  if (RFLinkDataAvailable(buf, &buflen))
  {
    digitalWrite(led_pin, HIGH);

    for (int i = 0; i < buflen; i++)
    {
      inDataSeq.s[i] = buf[i];
    }

    Serial.println();

    digitalWrite(led_pin, LOW);

    DecodeRFData(inArray, inDataSeq);

    //Do something with the information that have been received

    Serial.print("Incoming Data:");

    for (int i = 0; i < RF_DATA_ARRAY_SIZE; i++)
    {
      Serial.print(inArray[i]);
      Serial.print(", ");
      temp = inArray[0];
      humid = inArray[1];
      pressionrecu = inArray[2];
      pression = pressionrecu * 4;
      pluie = inArray[3];
      pluviometrie = inArray[4];
    }
    Serial.println();
    Serial.print("Bytes Used:");
    Serial.println(RF_DATA_ARRAY_SIZE * 2);
  }




  // calcul mini maxi ---------------------
  if (temp > tempmax && temp != 0)
  {
    tempmax = temp;
  }
  if (temp < tempmin && temp != 0)
  {
    tempmin = temp;
  }
  // Print values to Serial Monitor

  Serial.print("Humidity: ");
  Serial.println(humid);
  Serial.print("  - Temperature: ");
  Serial.println(temp);
  Serial.print("  - Pression: ");
  Serial.println(pression);
  Serial.print("  - Temperature Maxi: ");
  Serial.println(tempmax);
  Serial.print("  - Temperature Mini: ");
  Serial.println(tempmin);
  Serial.print("  - Pluie ?: ");
  Serial.println(pluie);
  Serial.print("  - Pluvimetrie: ");
  Serial.println(pluviometrie);

}

Probablement que lors de l'initialisation d'un ou de plusieurs modules il se produit un appel de courant que l'alimentation du PC (USB) accepte sans s'écrouler et que le petit bloc alim ne supporte pas.

Il faut toujours se méfier , les consommations des modules sont données en régime stabilisé et ne prennent pas en compte les appels de courant des régimes transitoires.

Si l'appel de courant reste raisonnable un condensateur de 100µF (ou plus si disponible) et de 15V minimal de tension de service (25V c'est mieux) pourrait absorber une partie de ce surcroît temporaire de courant, mais ce n'est pas une solution miracle et ce n'est pas gagné d'office.
La meilleure solution reste de surdimensionner les alimentations.

Bien vu, le pic de puissance pourrait dépasser ce que son alim peut fournir, or un USB délivre 0.9A.
Alors soit ton alim donne moins de 0.9A, soit ton module cherche le réseau, et comme il trouve pas le pc, bah il glandouille...
J'avance une théorie, je dois partir, je jette un oeil au code en rentrant, mais d'ici-là, ça sera peut-être résolu

je vois deux lignes qui attendent une réponse réseau. Encore une fois, je suis pas calé, mais si ton module attend une réponse du port série du PC et qu'il n'y est pas connecté, ca peut pas marcher.

Bonjour,

J'y voit peut-être mal, mais, sur ton plan de câblage, ta MEGA n'est pas alimentée.

Le +5v de la MEGA est relié au VCC de la RTC et au VCC de ce qui semble être le récepteur RF.

Désolé: j'avais mal, lu, tu as un bloc 5v.
Donc +1 avec mes camarades, problème d'alim.

Suite du code :

void initialiseSD()
{ /* Initialisation de la carte SD */

  Serial.println(F("Initialisation de la carte SD ... "));
  if (!SD.begin(SDCARD_CS_PIN)) {
    Serial.println(F("Erreur : Impossible d'initialiser la carte SD"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    digitalWrite(LedSd, HIGH); //allumer L1
    delay(1000); // attendre 1 seconde
    digitalWrite(LedSd, LOW); // Eteindre L1
    delay(2000); // attendre 2 seconde
    for (;;); // Attend appui sur bouton RESET
  }

  /* Ouvre le fichier de sortie en écriture */
  Serial.println(F("Ouverture du fichier de sortie ... "));
  file = SD.open(OUTPUT_FILENAME, FILE_WRITE);
  if (!file) {
    Serial.println(F("Erreur : Impossible d'ouvrir le fichier de sortie"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    digitalWrite(LedSd, HIGH); //allumer L1
    delay(1000); // attendre 1 seconde
    digitalWrite(LedSd, LOW); // Eteindre L1
    delay(2000); // attendre 2 seconde
    for (;;); // Attend appui sur bouton RESET
  }

  /* Ajoute l'entête CSV si le fichier est vide */
  if (file.size() == 0) {
    Serial.println(F("Ecriture de l'entete CSV ..."));
    file.println(F("Horodatage; Température; Humidité; Pression; Temp Maxi; Temp Mini; Pluviométrie"));
    file.flush();
  }
}




void initialize_ethernet(void) {

  for (;;) {
    Serial.println("OK");// keep trying until you succeed
    //Reinitialize ethernet module
    //pinMode(5, OUTPUT);  // do notknow what this is for, i ve got something elso on pin5
    //Serial.println("Reseting Ethernet...");
    //digitalWrite(5, LOW);
    //delay(1000);
    //digitalWrite(5, HIGH);
    //delay(500);

    if (ether.begin(sizeof Ethernet::buffer, mymac, ethCSpin) == 0) {
      Serial.println( "Failed to access Ethernet controller");
      digitalWrite(LedEther, HIGH); //allumer Led ethernet
      delay(1000); // attendre 1 seconde
      digitalWrite(LedEther, LOW); // Eteindre Led ethernet;

    }

    if (!ether.dhcpSetup()) {
      Serial.println("DHCP failed");
      digitalWrite(LedEther, HIGH); //allumer Led ethernet
      delay(1000); // attendre 1 seconde
      digitalWrite(LedEther, LOW); // Eteindre Led ethernet;
      continue;
    }


    ether.printIp("IP:  ", ether.myip);
    ether.printIp("GW:  ", ether.gwip);
    ether.printIp("DNS: ", ether.dnsip);

    if (!ether.dnsLookup(website))
      Serial.println("DNS failed");

    ether.printIp("SRV: ", ether.hisip);

    //reset init value
    res = 180;

    break;
  }
}

void setDS3231time(byte second, byte minute, byte hour, byte dayOfWeek, byte
                   dayOfMonth, byte month, byte year)
{
  // sets time and date data to DS3231
  Wire.beginTransmission(DS3231_I2C_ADDRESS);
  Wire.write(0); // set next input to start at the seconds register
  Wire.write(decToBcd(second)); // set seconds
  Wire.write(decToBcd(minute)); // set minutes
  Wire.write(decToBcd(hour)); // set hours
  Wire.write(decToBcd(dayOfWeek)); // set day of week (1=Sunday, 7=Saturday)
  Wire.write(decToBcd(dayOfMonth)); // set date (1 to 31)
  Wire.write(decToBcd(month)); // set month
  Wire.write(decToBcd(year)); // set year (0 to 99)
  Wire.endTransmission();
}
void readDS3231time(byte * second,
                    byte * minute,
                    byte * hour,
                    byte * dayOfWeek,
                    byte * dayOfMonth,
                    byte * month,
                    byte * year)
{
  Wire.beginTransmission(DS3231_I2C_ADDRESS);
  Wire.write(0); // set DS3231 register pointer to 00h
  Wire.endTransmission();
  Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
  // request seven bytes of data from DS3231 starting from register 00h
  *second = bcdToDec(Wire.read() & 0x7f);
  *minute = bcdToDec(Wire.read());
  *hour = bcdToDec(Wire.read() & 0x3f);
  *dayOfWeek = bcdToDec(Wire.read());
  *dayOfMonth = bcdToDec(Wire.read());
  *month = bcdToDec(Wire.read());
  *year = bcdToDec(Wire.read());
}
void displayTime()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  // retrieve data from DS3231
  readDS3231time(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month,
                 &year);
  // send it to the serial monitor
  Serial.print(hour, DEC);
  // convert the byte variable to a decimal number when displayed
  Serial.print(":");
  if (minute < 10)
  {
    Serial.print("0");
  }
  Serial.print(minute);
  Serial.print(":");
  if (second < 10)
  {
    Serial.print("0");
  }
  Serial.print(second);
  Serial.print(" ");
  Serial.print(dayOfMonth, DEC);
  Serial.print("/");
  Serial.print(month);
  Serial.print("/");
  Serial.println(year, DEC);
  /*  Serial.print(" Day of week: ");
    switch (dayOfWeek) {
      case 1:
        Serial.println("Sunday");
        break;
      case 2:
       Serial.println("Monday");
        break;
      case 3:
        Serial.println("Tuesday");
        break;
      case 4:
        Serial.println("Wednesday");
        break;
      case 5:
        Serial.println("Thursday");
        break;
      case 6:
        Serial.println("Friday");
       break;
     case 7:
       Serial.println("Saturday");
       break;
     }
  */
}
void ecritureDonneesCarte(void)
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  // retrieve data from DS3231
  readDS3231time(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month,
                 &year);
  /* Enregistre les données sur la carte SD */
  // Horodatage
  file.print(dayOfMonth);
  file.print(F("/"));
  file.print(month);
  file.print(F("/"));
  file.print(year + 2000);
  file.print(F(" "));
  file.print(hour);
  file.print(F(":"));
  file.print(minute);
  file.print(F(":"));
  file.print(second);
  file.print(F("; "));
  // Données brutes
  file.print(temp);
  file.print(F("; "));
  file.print(humid);
  file.print(F("; "));
  file.print(pression);
  file.print(F("; "));
  file.print(tempmax);
  file.print(F("; "));
  file.print(tempmin);
  file.print(F("; "));
  file.println(pluviometrie);
  file.flush();
  Serial.println("données écrites !!!!!!");
}

[/code]

Pour répondre à Bilbo83, La Méga est alimentée (même si ce n'est pas câblé sur le schéma) par USB, soit par PC soit par alim.

Cette alim peut délivrer 1A, j'ai essayé avec une 3.1A et pas mieux.

Kammo, de quelles lignes tu parles ?

Salut

Je dirais : attendu que la MEGA communique avec des composants 3.3V et qu'elle même est alimentée en 5V, le niveau de tension d'alimentation est important.
Plus la tension d'alimentation de la MEGA sera élevé, moins cela aura de chances de fonctionner.
Un chargeur de téléphone peut donner 5.5V.
Contrôle la tension d'alimentation de la MEGA.

@+

Je viens de contrôler les tensions d’alimentation au niveau de l’usb :

  • USB ordi 5,10V
  • USB chargeur 5,14V

D’une manière générale les alim doivent rester dans la gamme Vnominal +/- 5%
Soit en 5 V 4,75V <= 5V <= 5,25V
et en 3,3V 3,14 V <= 3,3V <= 3,46 V

Tout aussi général : il y a des diodes de protection câblées en inverse sur les entrées et la tension sur une entrée ne doit pas dépasser de plus de 0,5V la tension d’alimentation du circuit intégré → appliquer plus reviendrait à faire conduire les diodes.

Et si tu fais le calcul tu verra que la marge de 5% sur les alims est parfaitement compatible avec les 0,5 V.

Merci pour cette info, je pensais bien qu'il y avait une tolérance sur les tensions d'alimentation de l'Arduino, tous les modules et composants en on une aussi, je suis donc dans les clous au niveau de mes alims (autant l'une que l'autre).

Cela peut donc exclure le problème d'alim ou de câble ?

Je reviens sur mon problème.

Je ne maitrise pas bien le code du module ethernet (ENC28J60, qui vient de l'exemple de la librairie Ethercard), mais d'après ce que je viens de gratter sur internet, le code que j'utilise demande à chaque tentative d'initialisation de connexion, une adresse IP à mon routeur (Livebox) via mon pc.

Il se pourrait donc que mon problème initial d'alimentation ne soit qu'un problème de communication entre ma Mega et mon pc.

Pour palier à ce problème ne devrai-je pas attribuer une adresse IP fixe à ma carte arduino, pour qu'elle se connecte directement à mon routeur sans passer par le pc ?

L'intérêt d'une adresse fixe est de pouvoir accéder facilement à la MEGA depuis le PC, ne serait-ce que par un simple ping.
S'il n'y a pas d'utilité, autant laisser en DHCP.
Éventuellement il reste possible de récupérer son adresse sur la BOX.
Mais sincèrement je ne vois pas la relation entre le DHCP et le câble USB.

@+

Je serais d'avis de bien vérifier qu'à chaque étape il satisfait aux requêtes du genre:

    if (ether.begin(sizeof Ethernet::buffer, mymac, ethCSpin) == 0) {
      Serial.println( "Failed to access Ethernet controller");
      digitalWrite(LedEther, HIGH); //allumer Led ethernet
      delay(1000); // attendre 1 seconde
      digitalWrite(LedEther, LOW); // Eteindre Led ethernet;

    }

Ajouter un serialprintln à chaque ligne de commande avec le numéro de la ligne
SerialPrintln("ligne 37");

Tu finiras par trouver où ça coince. Je mise 10 cents sur mon idée...

Pour y voir plus clair, tu peux aussi virer tout ce qui sert à rien, ça fait de la place.

Je ne sais pas de quelle manière ma carte Arduino récupère l'adresse IP auprès de ma box pour se connecter au site Thingspeak, dans mon cas 192.168.1.11. Si c'est directement par le câble Ethernet relié à la box ou via l'ordi par le câble USB.
D’où mon interrogation sur une attribution d’une IP fixe configuré dans ma box (livebox play).

Kammo,
je comprends ton idée de vérifier ligne à ligne, mais le truc c'est que pour le faire je dois être alimenté par USB pc pour avoir un retour sur le moniteur série, mais mon problème se pose lorsque je suis alimenté par transfo et USB sans possibilité de vérification via le moniteur série, c'est pour cela que j’avais mis deux Led, BUG sur SD et BUG sur Ethernet.

Le port USB délivre 0.9A
L'alim de téléphone, 500mA en général (je regarde les miens à la maison, j'en ai 3)
Dans ce cas, c'est sur que si un composant a un pic, ta petite alim ne peut pas suivre.
En changeant ton alim pour arriver à 900mA tu seras fixé.

Autant pour moi, ce que je viens de dire dans le post précédent est un paradoxe. Je ne suis pas fortiche en communication, j'en bave déjà avec mes ports série...
Mais si dans ton code, quelque chose attend une réponse de ton PC, lorsqu'il est déconnecté, il peut toujours attendre, et c'est ce qu'il semble faire.

Je laisse la main aux experts, mais c'est pas une piste à écarter.

A ta place:
1-je change l'alim ou j'en mets deux en //
si c'est pas ça
2-je vire tout ce qui fait communiquer mon code avec le pc

Pour ce qui est de l'alim, mon chargeur annonce 1A, et un deuxième 3.1A, et les deux ne donnent pas de bon résultats.
Pour ce qui est du code et de l’interaction entre ma carte et mon pc, je pense que ces quelques lignes sont en cause :

 ether.printIp("IP:  ", ether.myip);
    ether.printIp("GW:  ", ether.gwip);  
    ether.printIp("DNS: ", ether.dnsip);

pour y remédier, j'ai fait les modifs suivantes :

ether.staticSetup(myip, gwip, dnsip);

avec les déclarations suivantes en tête de code :

static byte mymac[] = { 0x74, 0x69, 0x69, 0x2D, 0x30, 0x31 };

static byte myip[] = { 192,168,1,11 };
// gateway ip address
static byte gwip[] = { 192,168,1,1 };
static byte dnsip[] = { 192,168,1,1};

Et surprise, lorsque je lance le code via USB pc, tout marche nickel, mais lorsque je passe sur l'alim USB, il transmet des "0" à thingspeak !!!

Le problème vient sûrement d'ailleurs et pas des lignes que j'avais identifié.