Station météo Ethernet avec Arduino

#include <SPI.h>
#include <Ethernet.h>
#include <SD.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// inclut les elements ADA2652
#define BME_SCK 13
#define BME_MISO 12
#define BME_MOSI 11
#define BME_CS 10
#define SEALEVELPRESSURE_HPA (1013.25)
Adafruit_BME280 bme;
//Liste des pins
const char pluviometre = X;
const char anemometre = 2;
const char ILS1 = X;
const char ILS2 = X;
const char ILS3 = X;
const char ILS4 = X;
const char luxmetre = X;

// la communication
byte mac[]={ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(XXX,XXX,X,XXX);
EthernetClient client;

char serveur[] = "XXXXXXXXXX";
unsigned int port = XX;

// les intervals de mesures
const unsigned long rainInterval = 10000; // temps entre 2 mesure de pluie
const unsigned long windInterval = 10000; // temps entre 2 mesures de vent
const unsigned long lightInterval = 300000; // temps entre 2 mesures de luminosite
const unsigned long pressureInterval = 300000; // temps entre 2 mesures de pression atm
const unsigned long hygroInterval = 300000; // temps entre 2 mesures d'hygrometrie
const unsigned long tempInterval = 300000; // temps entre 2 mesures de temperature

// les dernieres mesures
unsigned long lastRainUpdate = 0; //derniere mesure de pluie
unsigned long lastWindUpdate = 0; // derniere mesure de vent
unsigned long lastLightUpdate = 0; // derniere mesure de luminosité
unsigned long lastPressureUpdate =0; // derniere mesure de pression atm
unsigned long lastHygroUpdate = 0; // derniere mesure d'hygrometrie
unsigned long lastTempUpdate = 0; // derniere mesure de temperature

//body de la trame ethernet
String trame = ("");

// structure du datalog
unsigned long ligneActive = 0;
unsigned char longueurTrame = 66;

// variable gestion du temps
unsigned long time = 0; // variable millis

//variables anemometre
volatile unsigned char rpmCount = 0; // compte le nombre de passage d'aimant devant le capteur

void setup() {

  // parametrage des I/O
  pinMode(pluviometre, INPUT);
  pinMode(anemometre, INPUT);
  pinMode(ILS1, INPUT);
  pinMode(ILS2, INPUT);
  pinMode(ILS3, INPUT);
  pinMode(ILS4, INPUT);
  pinMode(luxmetre, INPUT);

  attachInterrupt(digitalPinToInterrupt(anemometre), RPMCounter, RISING); // met en place l'interruption RPMCounter sur un front montant de l'entrée anemometre

  //demarage de la voie série pour debuguer
  Serial.begin(9600);

  // démarage du capteur ADA2652
  if (!bme.begin());
  {
    Serial.println("capteur ADA2652 non trouve");
    while (1);
  }
  Serial.println("capteur ADA2652 trouve");
  
  // demarage de la SD
  Serial.println("Demarage de la SD");
  if(!SD.begin(4))
  {
    Serial.println("probleme de connexion SD");
    while(1);
    return;
  }

  Serial.println("SD initialisee, reprise du fil de lecture");
  // determination de la ligne active
  File datalog = SD.open("datalog.txt", FILE_READ);

  while (datalog.peek() == '0')
  {
    ligneActive ++;
    datalog.seek(longueurTrame * ligneActive);
  }

  datalog.close();

  // demarrage du shield ethernet
  Serial.println("Parametrage ip fixe");
  Ethernet.begin(mac,ip);

  Serial.println("Initialisation");
  delay(1000);

  Serial.println("Pret");
}

void loop() {

  //routine de mesure : on ne lance la mesure que si l'interval défini est dépassé
  time = millis();

  if ((time - lastRainUpdate) >= rainInterval)
  {
    trame = ("p=");
    trame = trame + relevePluie(pluviometre);
    trame = trame + ("&");
    
    lastRainUpdate = time;
  }

  if ((time - lastWindUpdate) >= windInterval)
  {
    trame = trame + ("v=");
    trame = trame + releveVitesseVent();
    trame = trame + ("&d=");
    trame = trame + releveDirVent(ILS1, ILS2, ILS3, ILS4);
    trame = trame + ("&");

    lastWindUpdate = time;
  }

  if ((time - lastLightUpdate) >= lightInterval)
  {
    trame = trame + ("l=");
    trame = trame + releveLumiere();
    trame = trame + ("&");

    lastLightUpdate = time;
  }

  if ((time - lastPressureUpdate) >= pressureInterval)
  {
    trame = trame + ("b=");
    trame = trame + relevePression();
    trame = trame + ("&");

    lastPressureUpdate = time;
  }

  if ((time-lastHygroUpdate) >= hygroInterval)
  {
    trame = trame + ("h=");
    trame = trame + releveHygro();
    trame = trame + ("&");

    lastHygroUpdate = time;
  }

  if ((time-lastTempUpdate) >= tempInterval)
  {
    trame = trame + ("t=");
    trame = trame + releveTemp();
    trame = trame + ("&");

    lastTempUpdate = time;
  }

  Serial.println("tentative de connexion Ethernet");
  // si on arrive a se connecter, on tente d'envoyer une trame
  if(client.connect(serveur,port))
  {
    // Si la trame de la boucle est vide, on récupère la dernière trame stockée
    if (trame =="")
    {
      Serial.println("trame vide, récupération à partir du datalog");
      trame = FromFile(ligneActive, longueurTrame, trame);
    }

    if(trame != "")
    {
      Serial.println("Evoi trame");
      SendEthernet(trame);
    }
    else
    {
      Serial.println("Pas de trame a envoyer");
    }
    
  }

  // Si la connection echoue, on ecrit la trame dans le fichier
  else
  {
    Serial.println("Echec de la connection ethernet, ecriture dans le datalog");
    ligneActive = WriteInDatalog(ligneActive, longueurTrame, trame);
  }
  //reset de la trame
  trame="";

}

void RPMCounter() // incremente le compteur de rpm à chaque interruption
{
  rpmCount ++;
}

bool relevePluie(const char pluviometre)
{
  bool pluie = false;
  
    if (digitalRead(pluviometre) == LOW)
    {
      pluie = true;
    }
    
  return pluie;
}

unsigned char releveVitesseVent()
{
  unsigned int RPM = 0;
  unsigned char vitesseVent = 0;
  
  //calcul de la vitesse de rotation
  RPM = rpmCount / (time - lastWindUpdate); //vitesse de rotation en tr/ms
  vitesseVent = fct(RPM);

  return vitesseVent;
}

// relevé de la direction du vent
// ILS 1,2,3,4 dans le sens horaire, ILS1 vers le nord
String releveDirVent(const char ILS1, const char ILS2, const char ILS3, const char ILS4)
{
  String dir;

  if (digitalRead(ILS1) == HIGH && digitalRead(ILS2) == LOW && digitalRead(ILS3) == LOW && digitalRead(ILS4) == LOW)
  {
    dir = "NN";
  }

  else if (digitalRead(ILS1) == LOW && digitalRead(ILS2) == HIGH && digitalRead(ILS3) == LOW && digitalRead(ILS4) == LOW)
  {
    dir = "OO";
  }

  else if (digitalRead(ILS1) == LOW && digitalRead(ILS2) == LOW && digitalRead(ILS3) == HIGH && digitalRead(ILS4) == LOW)
  {
    dir = "SS";
  }

  else if (digitalRead(ILS1) == LOW && digitalRead(ILS2) == LOW && digitalRead(ILS3) == LOW && digitalRead(ILS4) == HIGH)
  {
    dir = "EE";
  }

  else if (digitalRead(ILS1) == HIGH && digitalRead(ILS2) == HIGH && digitalRead(ILS3) == LOW && digitalRead(ILS4) == LOW)
  {
    dir = "NO";
  }
  else if (digitalRead(ILS1) == LOW && digitalRead(ILS2) == HIGH && digitalRead(ILS3) == HIGH && digitalRead(ILS4) == LOW)
  {
    dir = "SO";
  }

  else if (digitalRead(ILS1) == LOW && digitalRead(ILS2) == LOW && digitalRead(ILS3) == HIGH && digitalRead(ILS4) == HIGH)
  {
    dir = "SE";
  }

  else if (digitalRead(ILS1) == HIGH && digitalRead(ILS2) == LOW && digitalRead(ILS3) == LOW && digitalRead(ILS4) == HIGH)
  {
    dir = "NE";
  }

  else
  {
    dir = "NA";
  }

  return dir;

}

unsigned int releveLumiere () // avec un capteur ADA1384
{
  int lux = 0;

  lux = map(analogRead(luxmetre),0,1023,3,55000);
  
  return lux;
}

float relevePression ()
{
  float pression = 0;

  pression = bme.readPressure()/100;

  return pression;
}

unsigned char releveHygro ()
{
  float hygrometrie = 0;

  hygrometrie = bme.readHumidity();

  return hygrometrie;
}

char releveTemp ()
{
  char temperature = 0;
  
  temperature = bme.readTemperature();
  
  return temperature;
}

String FromFile(unsigned long ligneActive, unsigned char longueurTrame, String trame)
{
  Serial.println("ouverture du datalog");
  File datalog = SD.open("datalog.txt",FILE_WRITE);
  if (!datalog)
  {
    Serial.println("Impossible d'ouvrir le fichier datalog");
    while(1);
  }

  datalog.seek(ligneActive * longueurTrame);

  if(datalog.peek() == "0")
  {
    datalog.print("1");
    
    while(datalog.peek() != 'x' && datalog.peek() != '\n')
    {
      trame = trame + datalog.read();
    }
  }
  
  return (trame);

}

void SendEthernet(String trame)
{
  client.println("POST / HTTP/1.1");
  client.println("Host: XXXXXXXXXXX");
  client.println("Connection: Close");
  client.println("Content-type: application/x-www-form-urlencoded");
  client.print("Content-Length: ");
  client.println();
  client.println();
  client.print(trame);
}

unsigned long WriteInDatalog(unsigned long ligneActive, unsigned char longueurTrame, String trame)
{  
  //ajoute 0 comme indicateur pour le read : 0 non envoyé, 1 envoyé
  trame = "0" + trame;
  // complete la trame pour qu'elle est le nombre de caractere standard et l'indicateur d'envoi
  while (trame.length()!= longueurTrame)
  {
    trame = trame + "x";
  }
  
  Serial.println("ouverture du datalog");
  File datalog = SD.open("datalog.txt",FILE_WRITE);
  if (!datalog)
  {
    Serial.println("Impossible d'ouvrir le fichier datalog");
    while(1);
  }

  datalog.seek(longueurTrame * ligneActive);

  datalog.println(trame);

  datalog.close();

  ligneActive ++;

  return (ligneActive);
  
}