Open Ruche

// Libraries
#include "DHT.h"
#include "HX711.h"
#include <OneWire.h>
#include <SigFox.h>
#include "ArduinoLowPower.h"

// variables definitions
#define EXTERNALDHTPIN 1     // Digital pin connected to the external DHT sensor
#define EXTERNALDHTTYPE DHT22   // DHT 22  (AM2302), AM2321

#define INTERNALDHTPIN 2     // Digital pin connected to the external DHT sensor
#define INTERNALDHTTYPE DHT22   // DHT 22  (AM2302), AM2321

#define calibration_factor 14100.0  // Weight calibration
#define LOADCELL_DOUT_PIN  5        // OUT pin weight sensor
#define LOADCELL_SCK_PIN  4         // SCK pin weight sensor

const byte BROCHE_ONEWIRE = 3;      // One wire pin

/* Adresses des capteurs de température */
const byte SENSOR_ADDRESS_1[] = {0x28, 0x60, 0xC0, 0x31, 0x08, 0x00, 0x00, 0x1D};
const byte SENSOR_ADDRESS_2[] = {0x28, 0x10, 0x2E, 0x54, 0x0A, 0x00, 0x00, 0xA3};
const byte SENSOR_ADDRESS_3[] = {0x28, 0x58, 0x19, 0x32, 0x0C, 0x00, 0x00, 0xEA};
const byte SENSOR_ADDRESS_4[] = {0x28, 0xE3, 0xA1, 0x16, 0xA8, 0x01, 0x3C, 0xAB};
const byte SENSOR_ADDRESS_5[] = {0x28, 0x42, 0x8C, 0x75, 0xD0, 0x01, 0x3C, 0x06};
const byte* SENSOR_ADDRESSES[5] = {SENSOR_ADDRESS_1, SENSOR_ADDRESS_2, SENSOR_ADDRESS_3, SENSOR_ADDRESS_4, SENSOR_ADDRESS_5};

const int batteryPin = A5;  // Battery Pin
const int luminosityPin = A1;  //Luminosity Pin

// sensor creation
HX711 scale; //weight sensor
float wght; // weight sensor

int sensorValue; // Battery remaining

OneWire ds(BROCHE_ONEWIRE); // OneWire

DHT externaldht(EXTERNALDHTPIN, EXTERNALDHTTYPE);   // externalDHT sensor
DHT internaldht(EXTERNALDHTPIN, INTERNALDHTTYPE);   // internal DHT sensor

// Variables temporaire pour stocker les valeur
uint16_t externalHumidity = 30;
uint16_t externalTemperature = 250;
uint16_t weight = 1000;
uint16_t internal1 = 250;
uint16_t internal2 = 250;
uint16_t internal3 = 250;
uint16_t internal4 = 250;
uint16_t internal5 = 250;
uint16_t battery = 60;
uint16_t internalHumidity = 30;
uint16_t luminosity = 50;

// Trame a envoyer par Sigfox
byte dataSigfox[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};


void setup() {
  Serial.begin(115200);
  delay(5000);
  Serial.println("Initializing");

  // Weight initialization
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor); //This value is obtained by using the SparkFun_HX711_Calibration sketch
  scale.set_offset(104721);
  /*scale.tare(); //Assuming there is no weight on the scale at start up, reset the scale to 0*/


  //DHT22 initialization
  externaldht.begin();
  internaldht.begin();

  // BLink at setup.
  pinMode(7, OUTPUT);
  for (int i = 0; i < 10; i++) {
    digitalWrite(7, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(200);                       // wait for 200ms
    digitalWrite(7, LOW);    // turn the LED off by making the voltage LOW
    delay(200);                       // wait for 200ms
  }

}

void loop() {
  Serial.println("Retrieving data");
  for (int i=0; i < 12; i++){
    dataSigfox[i] = 0x00;
  }
  //External Temperature and humidity
  getExternalTemperatureAndHumidity();

  //Internal humidity
  getInternalHumidity();

  //Internal Temperatures
  getInternalTemperatures();

  //Weight
  getWeight();

  //luminosity
  getLuminosity();

  //Battery
  getBattery();

  //Assignation des valeurs sur la trame (ne pas mettre en fonction a part sinon blocage des capteurs onewire apres deux loop et dht apres 3 loop)
  for (int i = 0; i < 12; i++) {
    dataSigfox[0] = 0x00;
  }
  int buff;
  buff = dataSigfox[0] | externalHumidity << (1);
  dataSigfox[0] = lowByte(buff);

  buff = dataSigfox[0] | ((weight >> (10)) & ((int)pow(2, 1) - 1));
  dataSigfox[0] = lowByte(buff);
  buff = dataSigfox[1] | ((weight >> (2)) & ((int)pow(2, 8) - 1));
  dataSigfox[1] = lowByte(buff);
  buff = dataSigfox[2] | weight << (6);
  dataSigfox[2] = lowByte(buff);

  buff = dataSigfox[2] | ((externalTemperature >> (3)) & ((int)pow(2, 6) - 1));
  dataSigfox[2] = lowByte(buff);
  buff = dataSigfox[3] | externalTemperature << (5);
  dataSigfox[3] = lowByte(buff);

  buff = dataSigfox[3] | ((internal1 >> (4)) & ((int)pow(2, 5) - 1));
  dataSigfox[3] = lowByte(buff);
  buff = dataSigfox[4] | internal1 << (4);
  dataSigfox[4] = lowByte(buff);

  buff = dataSigfox[4] | ((internal2 >> (5)) & ((int)pow(2, 4) - 1));
  dataSigfox[4] = lowByte(buff);
  buff = dataSigfox[5] | internal2 << (3);
  dataSigfox[5] = lowByte(buff);

  buff = dataSigfox[5] | ((internal3 >> (6)) & ((int)pow(2, 3) - 1));
  dataSigfox[5] = lowByte(buff);
  buff = dataSigfox[6] | internal3 << (2);
  dataSigfox[6] = lowByte(buff);

  buff = dataSigfox[6] | ((internal4 >> (7)) & ((int)pow(2, 2) - 1));
  dataSigfox[6] = lowByte(buff);
  buff = dataSigfox[7] | internal4 << (1);
  dataSigfox[7] = lowByte(buff);

  buff = dataSigfox[7] | ((internal5 >> (8)) & ((int)pow(2, 1) - 1));
  dataSigfox[7] = lowByte(buff);
  buff = dataSigfox[8] | internal5;
  dataSigfox[8] = lowByte(buff);

  buff = dataSigfox[9] | battery << (1);
  dataSigfox[9] = lowByte(buff);

  buff = dataSigfox[9] | ((internalHumidity >> (6)) & ((int)pow(2, 1) - 1));
  dataSigfox[9] = lowByte(buff);
  buff = dataSigfox[10] | internalHumidity << (2);
  dataSigfox[10] = lowByte(buff);

  buff = dataSigfox[10] | ((luminosity >> (5)) & ((int)pow(2, 2) - 1));
  dataSigfox[10] = lowByte(buff);
  buff = dataSigfox[11] | luminosity << (3);
  dataSigfox[11] = lowByte(buff);



  // SigFox Message
  sendSigfoxMessage();

  //Delay between each message (12 minutes)
  LowPower.sleep(720000);
  delay(2000);
}




/*
   Recupération des températures internes
*/

void getInternalTemperatures() {


  /* Lit les températures des trois capteurs */
  float temperature[5];
  startTemperatureMeasure(SENSOR_ADDRESS_1);
  startTemperatureMeasure(SENSOR_ADDRESS_2);
  startTemperatureMeasure(SENSOR_ADDRESS_3);
  startTemperatureMeasure(SENSOR_ADDRESS_4);
  //startTemperatureMeasure(SENSOR_ADDRESS_5);
  delay(800);
  for (int j = 0; j < 4; j++) {
    temperature[j] = readTemperatureMeasure(SENSOR_ADDRESSES[j]);
    if (temperature[j] > 51.2) {
      temperature[j] = 51.2;
    }
  }

  internal1 = (uint16_t) (temperature[0] * 10);
  internal2 = (uint16_t) (temperature[1] * 10);
  internal3 = (uint16_t) (temperature[2] * 10);
  internal4 = (uint16_t) (temperature[3] * 10);
  //internal5 = (uint16_t) (temperature[4] * 10);

  /* Affiche les températures */
  for (int i = 0; i < 4; i++) {
    Serial.print(F("Temperature interne "));
    Serial.print(i);
    Serial.print(F(" : "));
    Serial.print(temperature[i]);
    Serial.println(F(" C "));
  }

}

/*
   Fonction de démarrage de la prise de mesure de la température via un capteur DS18B20.
*/
void startTemperatureMeasure(const byte addr[]) {
  // addr[] : Adresse du module 1-Wire détecté

  /* Reset le bus 1-Wire et sélectionne le capteur */
  ds.reset();
  ds.select(addr);

  /* Lance une prise de mesure de température et attend la fin de la mesure */
  ds.write(0x44, 1);
}

/**
   Fonction de récupération de la prise de mesure de la température via un capteur DS18B20.
*/
float readTemperatureMeasure(const byte addr[]) {
  byte data[9];
  // data[] : Données lues depuis le scratchpad
  // addr[] : Adresse du module 1-Wire détecté

  /* Reset le bus 1-Wire, sélectionne le capteur et envoie une demande de lecture du scratchpad */
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);

  /* Lecture du scratchpad */
  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read();
  }

  /* Calcul de la température en degré Celsius */
  return (int16_t) ((data[1] << 8) | data[0]) * 0.0625;
}

/*
   Récupération .de température et humidité externe
*/
void getExternalTemperatureAndHumidity() {

  Serial.println("Retrieving External Temperature and Humidity");

  float h = externaldht.readHumidity();
  float t = externaldht.readTemperature();

  while (isnan(h) || isnan(t)) {
    //Serial.println(F("Failed to read from DHT sensor!"));
    h = externaldht.readHumidity();
    t = externaldht.readTemperature();
  }

  if (h > 100) {
    h = 100;
  }
  if (t > 51.2) {
    t = 51.2;
  }

  externalHumidity = (uint16_t) h;//*100;
  externalTemperature = (uint16_t) t * 10;

  Serial.print(F("External Humidity: "));
  Serial.print(h);
  Serial.print(F("%  External Temperature: "));
  Serial.println(t);

}

/*
   Récupération de l'humidité externe
*/
void getInternalHumidity() {

  Serial.println("Retrieving internal Humidity");

  float h = internaldht.readHumidity();

  while (isnan(h)) {
    //Serial.println(F("Failed to read from internal DHT sensor!"));
    h = internaldht.readHumidity();
  }

  if (h > 100) {
    h = 100;
  }

  internalHumidity = (uint16_t) h;//*100;

  Serial.print(F("Internal Humidity: "));
  Serial.print(h);
  Serial.println(F("%"));

}

/*
   Récupération du poids
*/
void getWeight() {
  scale.power_up();
  Serial.println("Retrieving weight");
  wght = scale.get_units() * 0.453592;
  if (wght > 204.8) {
    wght = 204.8;
  }
  weight = (uint16_t) wght * 10;
  Serial.print(F("Weight : "));
  Serial.println(wght);
  scale.power_down();
}

/*
 * Récupération de la luminsoité
 */
void getLuminosity() {
  
  Serial.println("Retrieving luminosity");
  // Mesure la tension sur la broche de la photo
  int valeur = analogRead(luminosityPin);
  if (valeur < 250){
    valeur = 250;
  }
  else if ( valeur > 1023){
    valeur = 1023;
  }
  uint16_t percentValue = (uint16_t) map(valeur, 250, 1023, 0, 100);
  // Envoi la mesure au PC pour affichage et attends 250ms
  Serial.println(percentValue);
  luminosity =  percentValue;
}

/*
   Récupération du pourcentage de batterie
*/
void getBattery() {
  Serial.println("Retrieving battery remaining");
  sensorValue = analogRead(A5);
  Serial.print("AnalogRead : ");
  Serial.println(sensorValue);
  if (sensorValue > 1012) {
    sensorValue = 1012;
  }
  if (sensorValue < 700) {
    sensorValue = 700;
  }

  uint16_t percentValue = (uint16_t) map(sensorValue, 700, 1012, 0, 100);
  //Serial.println(percentValue);
  //Serial.println(sensorValue);
  battery =  percentValue;
  Serial.println("battery % : ");
  Serial.println(battery);
}

/*
   Envoi du message Sigfox
*/
void sendSigfoxMessage() {
  if (!SigFox.begin()) {
    Serial.println("SigFox error, rebooting");
    reboot();
  }
  SigFox.debug();
  // Clears all pending interrupts
  SigFox.status();
  delay(1);
  // Send the data
  SigFox.beginPacket();
  SigFox.write((uint8_t*)&dataSigfox, sizeof(dataSigfox));
  SigFox.endPacket();
  SigFox.end();
}

void reboot() {
  NVIC_SystemReset();
  while (1);
}