Bonjour , j’ avais etabli un projet pour un mega 2560 qui consistait a mettre en place un arrosage automatique , mais le code ne fonctionne pas .
je ne comprends pas pourquoi le code suivant ne m’ affiche rien du tout lorsque je le televerse dans le mega . Ce qui revient à dire que mes relais ne s ‘ initialisent pas ![]()
si quelqun trouve et peux m’ expliquer où est le probleme svp …
#include <SPI.h>
#include "AsyncTask.h"
#include <Ethernet2.h>
#include <EthernetUdp2.h>
#include <Wire.h>
#include "simpleRTC.h"
/*************************************/
// Pour avoir un mode debug de notre programme
#define DEBUG true // à mettre à false si on ne veut pas de debug
#define DEBUGSTREAM Serial
#if DEBUG
#define DEBUG_PRINT(...) DEBUGSTREAM.print(__VA_ARGS__)
#define DEBUG_PRINTLN(...) DEBUGSTREAM.println(__VA_ARGS__)
#else
#define DEBUG_PRINT(...)
#define DEBUG_PRINTLN(...)
#endif
const bool TEST = 0; // active ou desactive les digitalWrite sur pin
const char* NUMERO_VERSION = "machine etats j-M-L 7.314";
const unsigned long TIMER_A = 7200000UL, TIMER_P = 120000UL, TIMER_V = 30000UL; // 2 heures , 2 minutes et 30 sec.
/*************************************/
uint8_t MacAddress[] = {0x90, 0xA2, 0xDA, 0x10, 0x2F, 0x93};
IPAddress ip(192,168,1,111); // L'adresse IP que prendra le shield ethernet
// mettre (0,0,0,0) pour laisser en serveur DHCP sinon ce sera une adresse IP statique .
const unsigned int SERVER_PORT = 80;
EthernetServer webServer(SERVER_PORT);
EthernetUDP Udp;
boolean ENABLE_SDCARD = false; // enable disable SDcard and uncomment library if needed below .
//#include <SdFat.h> // bibliotheque pour carte SD
//-----------------------------------------------------//
////* Arrosage *////
bool arrosageAutoON = false;
enum t_commandeArrosage : uint8_t {MARCHE, ARRET, NULL_A, MARCHE_TOUT, ARRET_TOUT};
enum t_etatArrosage : bool {ACTIF, INACTIF};
struct t_arrosage { // {"Arbres", "Bordures", "Fruitiers", "Haies", "Jardin", "Potager
uint8_t zone; //1 index
uint8_t pinRelais; //2
const char* nom; //3
uint32_t dureeArrosageTotal; //4 utile ?
uint32_t intervalle; //5
bool zoneArrosee; //6
t_etatArrosage etat; //7
uint32_t debutArrosage; //8
uint32_t dureeJusquaFinArrosage; //9
};
#define tempsDArrosage(coeffSaison) ((uint32_t) (7200000 * (coeffSaison)))
t_arrosage lesArrosages[] = {
//zone pin nom tempsDArrosage int ZA etat da dfa
// 1 2 3 4 5 6 7 8 9
{0, 38, "Arbres", tempsDArrosage(1), 0, 0, INACTIF, 0, 0},
{1, 39, "Bordures", tempsDArrosage(1), 0, 0, INACTIF, 0, 0},
{2, 40, "Fruitiers", tempsDArrosage(1), 0, 0, INACTIF, 0, 0},
{3, 41, "Haies", tempsDArrosage(1), 0, 0, INACTIF, 0, 0},
{4, 42, "Jardin", tempsDArrosage(1), 0, 0, INACTIF, 0, 0},
{5, 43, "Potager", tempsDArrosage(1), 0, 0, INACTIF, 0, 0}
};
const uint8_t NOMBREDARROSAGE = sizeof(lesArrosages) / sizeof(t_arrosage) ,HEURE_RESET_A = 24, HEURE_DEBUT_A = 6;
uint8_t initArrosageOK = NOMBREDARROSAGE;
bool resetZoneArroseeOK = false;
uint8_t saison = 0;
/************************************************************************************/
////* Commandes web *////
enum : uint8_t {VOLETS_GLOBAL, VOLET_OUVRIR, VOLET_FERMER, VOLET_ARRETER, PORTAIL, ARROSAGE_MARCHE, ARROSAGE_ARRET, ARROSAGE, RESTE}; // parseCommand
struct t_commandeWeb {
bool active;
t_arrosage* arrosage;
t_commandeArrosage actionCMD_A;
};
t_commandeWeb commandeWeb;
/********************************************************************************************************
Arduino communicates with both the Ethernet Shield and SD card using the SPI bus
This is on digital pins 10, 11, 12, and 13 on the Uno and pins 50, 51, and 52 on the Mega.
Pin 10 is used to select the Ethernet chip and pin 4 for the SD card.
These pins cannot be used for general I/O.
On the Mega, the hardware SS pin, 53, is not used to select either the Ethernet chip or the SD card,
but it must be kept as an output or the SPI interface won't work.
Note that because the Ethernet chip and SD card share the SPI bus, only one at a time can be active.
If you are using both peripherals in your program, this should be taken care of by the corresponding libraries.
If you're not using one of the peripherals in your program, however, you'll need to explicitly deselect it.
To do this with the SD card, set pin 4 as an output and write a high to it.
For the Ethernet chip, set digital pin 10 as a high output.
*** USED PINS communicate with shield and others devices ***
*** 0 , 1 , 2 , 3 , 4 , 10 , 20 , 21 , 50 , 51 , 52 // 22 => 46 , 48 , 49 , A0 , A1 .
* 04 : pour selectionner la carte SD
* 10 : pour selectionner le shield ethernet
* 20 : RTC SDA
* 21 : RTC SCL
* 22 => 29 : ouverture des volets. 22 => 25 = groupe jour , 26 => 29 groupe nuit
* 30 => 37 : fermeture des volets. 30 => 33 = groupe jour , 34 => 37 groupe nuit
* 38 => 43 : arrosage
* 44 : ???
* 45 : Heures creuses
* 46 : portail
* 47 :
* 48 : detecteur pluie alim
* 49 : detecteur humid alim
* 50 : SPI bus SDCARD
* 51 : SPI bus shield
* 52 : SPI bus shield
* 53 : doit ertre laissé en sortie afin d' activer le BUS SPI . A ne pas utiliser donc .
* A0 : releve valeur pluie
* A1 : releve valeur humid
********************************************************************************************************/
/*** pins definitions ***/
const uint8_t
BROCHE_ONEWIRE = 2,
SDCARD_PIN = 4,
HUMIDITY_SENSOR_PIN = A1,
HUMIDITY_SENSOR_VCC = 49,
PLUIE_SENSOR_PIN = A0,
PLUIE_SENSOR_VCC = 48,
RHC_PIN = 45,
PORTAIL_PIN = 46,
RELAY_START_PIN = 44,
//------------------------------------//
NB_RELAY_PORTAIL = 1,
NB_RELAY_HEURE_CREUSE = 1,
RELAY_NUMBER = NB_RELAY_PORTAIL + NB_RELAY_HEURE_CREUSE,
MAX_COMMAND = 30;
AsyncTask<NOMBREDARROSAGE*2 + 4 + 2> gestionnaireDeTache; // autorise un nombre de taches predefinies . 12 pour arrosage et 1 portail + 1 heure + 1 saison + 2 par securité .
/********************************************************************************************************/
/*****************************************************************
** This is for our URL Parser. We are expecting an URL in the form
** of http://domain.com/x=v1,y=v2,z=v3
** x, y and z would be the labels of Interests and v1, v2, v3
** will be valued extracted by the parser
******************************************************************/
const char * LABELS_OF_INTEREST[] = {"VG", "VO", "VF","VA", "P", "AM", "AA", "AG","R"}; // envoie requete HTTP
char urlCommand[MAX_COMMAND + 1]; // +1 for the trailing '\0'
const unsigned int MAX_LABELS_OF_INTEREST = sizeof(LABELS_OF_INTEREST) / sizeof(char*);
long VG=0, VO=0, VF=0, VA=0, P=0, AM=0, AA=0, AG=0, R=0;
/************************************************************************************/
////* Affichage page web *////
const char* tableauDeNoms_P [NB_RELAY_PORTAIL] = {"Portail"};
const char* tableauDeNoms_R [NB_RELAY_HEURE_CREUSE] = {"Relais Heures Creuses"};
////* Relais *////
#define RELAIS_ACTIF LOW
#define RELAIS_INACTIF HIGH
uint8_t tableau_Pin_Relais [RELAY_NUMBER]; // numeros de pins
bool tableau_Etat_Relais [RELAY_NUMBER]; // etat des pins
////* Capteurs *////
const uint8_t SEUIL_PLUIE = 50, SEUIL_HUMIDITE = 50;
////* NTP UDP */////
char timeServer[] = "ntp.unice.fr";
const unsigned int localPort = 8888, timeOut = 1000; // local port to listen for UDP packets
const uint8_t NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
uint8_t packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
/***************************************************************************************************************************************/
void affecteCommandeWeb(bool b, t_arrosage* a=NULL, t_commandeArrosage ca=NULL_A) {
commandeWeb.active=b;
commandeWeb.arrosage=a;
commandeWeb.actionCMD_A=ca;
if (b) { // si on recoit une instruction d' activation
if (a) gererUnArrosage(a);
else if (ca != NULL_A) gererLesArrosages();
if(DEBUG) {
Serial.print("* affecteCommandeWeb => ");
Serial.print("commandeWeb.active =");
Serial.println(b);
if (a == NULL ) Serial.println("a == NULL");
if (ca == NULL_A) Serial.println("ca == NULL_A");
else {
Serial.print("ca == ");
Serial.println(ca);
}
} // fin DEBUG
}
}
/***************************************************************************************************************************************/
/***************************************************************************************************************************************/
//// Fonctions d ' arrosage : ////
void initialiserUnArrosage(t_arrosage* unArrosage) {
pinMode(unArrosage->pinRelais, OUTPUT);
digitalWrite(unArrosage->pinRelais, RELAIS_INACTIF); // à l'arret
if(DEBUG) {
Serial.print("initialisation relais arrosage N° ");
Serial.println(unArrosage->pinRelais);
}
}
/* debut mode manuel */
void activerUnArrosage(t_arrosage* unArrosage) {
if (unArrosage->etat != ACTIF) {
digitalWrite(unArrosage->pinRelais, RELAIS_ACTIF);
unArrosage->etat = ACTIF;
}
if (DEBUG) { // zone , pinRelais , nom , dureeArrosageTotal , intervalle , zoneArrosee , etat , debutArrosage , dureeJusquaFinArrosage
Serial.println (F("* activerUnArrosage => manuel"));
Serial.print (F("unArrosage->nom = "));
Serial.println (unArrosage->nom);
Serial.print (F("unArrosage->etat = "));
Serial.println (unArrosage->etat);
Serial.print (F("unArrosage->debutArrosage = "));
Serial.println (unArrosage->debutArrosage);
Serial.print (F("unArrosage->dureeArrosageTotal = "));
Serial.println (unArrosage->dureeArrosageTotal);
Serial.print (F("unArrosage->dureeJusquaFinArrosage = "));
Serial.println (unArrosage->dureeJusquaFinArrosage);
Serial.print (F("unArrosage->intervalle = "));
Serial.println (unArrosage->intervalle);
Serial.print (F("unArrosage->zoneArrosee = "));
Serial.println (unArrosage->zoneArrosee);
}
}
void desactiverUnArrosage(t_arrosage* unArrosage) {
if (unArrosage->etat != INACTIF) {
digitalWrite(unArrosage->pinRelais, RELAIS_INACTIF);
unArrosage->etat = INACTIF;
}
if (DEBUG) { // zone , pinRelais , nom , dureeArrosageTotal , intervalle , zoneArrosee , etat , debutArrosage , dureeJusquaFinArrosage
Serial.println (F("* desactiverUnArrosage => manuel"));
Serial.print (F("unArrosage->nom = "));
Serial.println (unArrosage->nom);
Serial.print (F("unArrosage->etat = "));
Serial.println (unArrosage->etat);
Serial.print (F("unArrosage->debutArrosage = "));
Serial.println (unArrosage->debutArrosage);
Serial.print (F("unArrosage->dureeArrosageTotal = "));
Serial.println (unArrosage->dureeArrosageTotal);
Serial.print (F("unArrosage->dureeJusquaFinArrosage = "));
Serial.println (unArrosage->dureeJusquaFinArrosage);
Serial.print (F("unArrosage->intervalle = "));
Serial.println (unArrosage->intervalle);
Serial.print (F("unArrosage->zoneArrosee = "));
Serial.println (unArrosage->zoneArrosee);
}
}
void gererUnArrosage(t_arrosage* unArrosage) {
switch (unArrosage->etat) { // ACTIF, INACTIF
case INACTIF : // MARCHE, ARRET, NULL_A, MARCHE_TOUT, ARRET_TOUT
if ((commandeWeb.active) && (commandeWeb.arrosage == unArrosage)) {
if (commandeWeb.actionCMD_A == MARCHE) {
activerUnArrosage(unArrosage);
commandeWeb.active = false;
}
}
break;
case ACTIF :
if ((commandeWeb.active) && (commandeWeb.arrosage == unArrosage)) {
if (commandeWeb.actionCMD_A == ARRET) {
desactiverUnArrosage(unArrosage);
commandeWeb.active = false;
}
}
break;
} // fin switch
}
void gererLesArrosages() {
if (commandeWeb.active && commandeWeb.arrosage == NULL) {
if(commandeWeb.actionCMD_A == MARCHE_TOUT) for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) activerUnArrosage(&(lesArrosages[a]));
else if(commandeWeb.actionCMD_A == ARRET_TOUT) for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) desactiverUnArrosage(&(lesArrosages[a]));
//else if(commandeWeb.actionCMD_A == AUTO_ON_OFF)
commandeWeb.active=false;
}
for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) gererUnArrosage(&(lesArrosages[a]));
}
/* fin mode manuel */
void setup() {
// put your setup code here, to run once:
for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) initialiserUnArrosage(&(lesArrosages[a]));
}
void loop() {
// put your main code here, to run repeatedly:
}
Dans la loop , il n’ y a rien . j ‘ ai essayé de simplifier au maximum
.
Mon objectif c’ est d ‘ initialiser les relais qui sont censés l ‘ etre par le setup avec la boucle qu ‘ il contient , et qui appelle la fonction “ initialiserUnArrosage “ .
Laquelle contient , justement , en mode debug , un message qui devrait s’ afficher sur le moniteur serie indiquant le numero de chacun des relais initialisés dans la structure “ t_arrosage “ .
le reste n’ est là que pour obtenir un code “ valide “ au sein du compilateur afin de pouvoir tester le cas echeant , si lecoeur vous en dit et ne renvoie pas d’ erreur .
Pourtant , l’ initialisation ne se fait pas …