Merge remote-tracking branch 'origin/master' into refactor/class-abstraite-capteur

Reviewed-on: Epitech-T-DEV-811/T-DEV-811#35
Reviewed-by: nico <nicolas.sansd@gmail.com>

IOT/config.cppcheck

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+	<builddir>.cppcheck-build</builddir>
+	<platform>Unspecified</platform>
+	<analyze-all-vs-configs>true</analyze-all-vs-configs>
+	<check-headers>true</check-headers>
+	<check-unused-templates>false</check-unused-templates>
+	<max-ctu-depth>10</max-ctu-depth>
+	<exclude>
+		<path name="./.pio/" />
+	</exclude>
+	<suppressions>
+		<suppression>noCopyConstructor</suppression>
+		<suppression>noExplicitConstructor</suppression>
+		<suppression>unusedFunction</suppression>
+		<suppression>noOperatorEq</suppression>
+	</suppressions>
+</project>

IOT/config.ini

@@ -14,7 +14,25 @@ build_flags =
     -D MONITOR_SPEED=${config.monitor_speed}
 ; DO NOT TOUCH --- END
 
-    -D API_HOST=\"iot.epi.cb85.software\"
+    ; DHT pin and type
+    ; 5v
+    -D DHTTYPE=\"DHT11\"
+    -D DHTPIN=2
+
+    ; ULTRASON pin
+    ; 5v
+    -D ULTRA_SOUND_TRIGD=12
+    -D ULTRA_SOUND_ECHO=13
+
+    ; Capteur poids
+    -D POID_DOUT=14
+    -D POID_SCK=15
+
+    -D MOYENNE_CALIBRATION=20
+
+
+    ; trash can ID
+    -D TRASHCAN_ONE=\"gdnuxl0wlgurtj3\"
+    -D TRASHCAN_TWO=\"4brip5fwm001bs9\"
 
-    -D EXAMPLE_NUMBER=69
 

IOT/envs.ini

@@ -1,4 +1,10 @@
 ; Add additionnal environments in this file
+; Debug environemnt
+[env:test]
+test_build_src = true
+build_type = debug
+build_flags = ${env.build_flags}
+    -D TESTING
 
 ; Default production environment
 [env:prod]

IOT/include/Program.h

@@ -1,6 +1,16 @@
 #ifndef PROGRAM_H
 #define PROGRAM_H
 
+#include <DHT.h>
+#include <Arduino.h>
+#include <Ultrasonic.h>
+
+#include "API.h"
+#include "Capteur.h"
+#include "Ultrason.h"
+#include "HumiTemp.h"
+#include "Balance.h"
+
 class Program{
 public:
     /**
@@ -17,5 +27,31 @@ public:
 
 private:
     /* data */
+
+    /**
+     * @brief capteur humi/temp
+     * 
+     */
+    Capteur *dht;
+
+    /**
+     * @brief capteur ultra son pour le niveau de remplissage de la poubelle
+     * 
+     */
+    Capteur *ultrasonic;
+
+    /**
+     * @brief capteur poid pour le niveau de remplissage de la poubelle
+     * 
+     */
+    Balance *balance;
+
+//TODO chagé type to capteur
+
+    /**
+    * @brief Réference de l'API pour les calls
+    * 
+    */
+    API *api;
 };
 #endif

IOT/lib/API/include/API.h

@@ -41,8 +41,6 @@ public:
      */
     bool sendValue(String val, String poubelleID, String unit, bool full);
     
-
-private:
     /**
      * @brief connect l'utilisateur a l'api et met a jour le token
      * 
@@ -51,6 +49,11 @@ private:
      */
     bool connect();
 
+    //TODO :: Check wifibegin avant
+
+private:
+    
+
     /**
      * @brief ID de l'utilisateur
      * 

IOT/lib/API/src/API.cpp

@@ -59,7 +59,8 @@ bool API::connect(){
     this->client->println();
 
 
-    while (!client->available()) {}
+    while (!client->available()) {
+    }
 
     String responce = "";
     while (client->available()) {
@@ -77,7 +78,10 @@ bool API::connect(){
     this->client->stop();
     
     sortie = true;
-
+    if (JSONVar::stringify(JSONVar::parse(str)["code"]) == "400") {
+        Serial.println("Failed to authenticate");
+        return false;
+    }
     return sortie;
 }
 

IOT/lib/Balance/include/Balance.h

@@ -0,0 +1,80 @@
+#ifndef BALANCE_H
+#define BALANCE_H
+#include <Arduino.h>
+#include <HX711.h>
+
+class Balance {
+
+public:
+
+    /**
+     * @brief constructeur
+     *
+     * @param doutPin : pin DOUT du module HX711
+     *
+     * @param sckPin : pin horloge du module HX711
+     *
+     * @param poidsRef : valeur de poids posée sur la balance ref en grammes
+    */
+    Balance(int doutPin, int sckPin);
+
+    /**
+     * @brief determine le poids
+     *
+     * @return poids (double)
+    */
+    double getValue();
+
+    /**
+     * @brief determine la moyenne poids
+     *
+     * @param nbMesure : nombre de mesure effectues pour la moyenne
+     *
+     * @return moyenne poids (double)
+    */
+    double getAverage(int nbMesure);
+
+    /**
+     * @brief tare et scale a 0, et recuperation de la valeur brut du plateau
+    */
+    boolean initCalibration();
+
+    /**
+     * @brief initialisation du calibrage
+     * 
+     * @param[in] poidsRef : poid de reférence pour la calibration
+     * @param[in] moyenne_calibration : nombre de valeurs a lire pour une mesure
+     *
+     * @return renvoi un true si calibration bien effectue
+    */
+    boolean calibration(int poidsRef,int moyenne_calibration);
+
+    //TODO: faire doc setCalibration fact
+    void setCalibrationFact(int caliFact);
+
+
+private:
+
+    /**
+     * @brief true = calibration et false = erreur
+    */
+    boolean initialized;
+
+    /**
+     * @brief Facteur de calibration obtenu par : (val brute poids ref - val brute poids plexiglas)/ poids ref
+    */
+    int calibrationFact;
+
+    /**
+     * @brief Variable issue de la librairie HX711 qui permet d'utiliser les fonctions de celle-ci
+    */
+    HX711 scale;
+
+    /**
+     * @brief Valeur moyenne brute du poids sans rien sur la balance juste le plexiglas
+    */
+    long initialVal;
+
+};
+
+#endif

IOT/lib/Balance/src/Balance.cpp

@@ -0,0 +1,62 @@
+#include "../include/Balance.h"
+
+Balance::Balance(int doutPin, int sckPin) {
+
+    scale.begin(doutPin, sckPin);
+    this->initialized = false;
+    scale.set_scale();
+    scale.tare();
+    this->initialVal = 0;
+    this->calibrationFact = 0;
+}
+
+boolean Balance::initCalibration() {
+
+    scale.set_scale();
+    scale.tare();
+    this->initialVal = scale.read_average(20);
+    return true;
+}
+
+boolean Balance::calibration(int poidsRef,int moyenne_calibration) {
+
+    int rawValref = 0; // Valeur brute de plexiglas et poids réf
+    int tempPoids = 0; // C'est la valeur du poids en grammes calculée grâce au facteur de calibration
+
+    rawValref = scale.read_average(moyenne_calibration);
+    this->calibrationFact = (rawValref - this->initialVal) / poidsRef;
+    do {
+        scale.set_scale(calibrationFact);
+        tempPoids = scale.get_units(5);
+        if (tempPoids < poidsRef) {
+            calibrationFact -= 1;
+        } else if (tempPoids > poidsRef) {
+            calibrationFact += 1;
+        }
+    } while (tempPoids != poidsRef);
+    return initialized = true;
+}
+
+double Balance::getAverage(int nbMesure) {
+
+    if (initialized == true) {
+        return scale.get_units(nbMesure);
+    } else {
+        return 0;
+    }
+}
+
+double Balance::getValue() {
+
+    if (initialized == true) {
+        return scale.get_units();
+    } else {
+        return 0;
+    }
+}
+
+void Balance::setCalibrationFact(int caliFact){
+    this->initialized = true;
+    this->calibrationFact = caliFact;
+    scale.set_scale(caliFact);
+}

IOT/lib/Capteur/include/Capteur.h

@@ -0,0 +1,67 @@
+#ifndef CAPTEUR_H
+#define CAPTEUR_H
+
+#include <Arduino.h>
+
+class Capteur{
+public:
+
+
+/**
+ * @brief Construct a new Capteur object
+ * 
+ * @param[in] type type de mesure lue (T/H, W, D,...)
+ * @param[in] fullVal valeur a la quel la poubelle est considéré comme pleine
+ */
+Capteur(String type, String fullVal);
+
+/**
+ * @brief tar le capteur si il a besoins d'être tarré
+ * 
+ * @param[in] val *opt* si le capteur a besoins d'une valeur de ref pour être tarré
+ * @return true si la tarre a bien réussi (ou si il n'a pas besoins de tarre)
+ * @return false erreur durrant la tar
+ */
+virtual bool tar(int val = 0);
+
+/**
+ * @brief lit la valeur du capteur
+ * 
+ * @return String retour la valeur
+ */
+virtual String read() = 0;
+
+/**
+ * @brief revoie la valeur full
+ * 
+ * @return true la poubelle est pleine
+ * @return false la poubelle n'est pas pleine
+ */
+bool isFull();
+
+String getValType();
+
+protected:
+
+/**
+ * @brief la poubelle est pleinne
+ * est mis a jours par read()
+ */
+bool full; 
+
+/**
+ * @brief type de mesure lue (T/H, W, D,...)
+ * 
+ */
+String type;
+
+/**
+ * @brief valeur a la quel la poubelle est considéré comme pleine
+ * 
+ */
+String fullVall;
+
+};
+
+
+#endif // CAPTEUR_H

IOT/lib/Capteur/include/HumiTemp.h

@@ -0,0 +1,35 @@
+#ifndef HUMI_TEMP_H
+#define HUMI_TEMP_H
+
+#include <Arduino.h>
+#include <DHT.h>
+#include "Capteur.h"
+
+class HumiTemp : public Capteur{
+
+public:
+
+    /**
+     * @brief Construct a new Humi Temp object
+     * 
+     * @param pin pin du capteur dht
+     * @param type type de capteur dht (11,22,...)
+     * @param fullVal valeur au quel la poubelle est considéré comme pleinne
+     */
+    HumiTemp(int pin, String type, String fullVall);
+
+    /**
+     * @brief lit le capteur d'humi/temp
+     * 
+     * @return String valeur format "XX/YY" X% et Y°C
+     */
+    String read();
+
+private:
+    
+    DHT* capteur;
+
+};
+
+
+#endif //HUMI_TEMP_H

IOT/lib/Capteur/include/Ultrason.h

@@ -0,0 +1,38 @@
+#ifndef ULTRASON_H
+#define ULTRASON_H
+
+#include <Arduino.h>
+#include <Ultrasonic.h>
+
+#include "Capteur.h"
+
+class Ultrason: public Capteur{
+public:
+
+    /**
+     * @brief Construct a new Ultrason object
+     * 
+     * @param trigeur pin trigeur du capteur ultra son
+     * @param echo pin echo du capteur ultra son
+     * @param fullVall valeur a la quel la poubelle est pleine
+     */
+    Ultrason(int trigeur, int echo, String fullVall);
+
+    /**
+     * @brief lit la valeur du capteur ultra son
+     * 
+     * @return String retour la valeur
+     */
+    String read();
+
+private:
+
+    /**
+     * @brief capteur utiliser ultrason utiliser pour la mesure
+     * 
+     */
+    Ultrasonic* capteur;
+};
+
+
+#endif // ULTRASON_H

IOT/lib/Capteur/src/Capteur.cpp

@@ -0,0 +1,22 @@
+#include "../include/Capteur.h"
+
+
+
+Capteur::Capteur(String type, String fullVall){
+    this->type = type;
+    this->fullVall = fullVall;
+}
+
+bool Capteur::tar(int val){
+    return true;
+}
+
+
+bool Capteur::isFull(){
+    return this->full;
+}
+
+
+String Capteur::getValType(){
+    return this->type;
+}

IOT/lib/Capteur/src/HumiTemp.cpp

@@ -0,0 +1,26 @@
+#include "../include/HumiTemp.h"
+
+HumiTemp::HumiTemp(int pin, String type, String fullVall):
+    Capteur("H/T",fullVall){
+    this->capteur = new DHT(pin, type.c_str());
+    this->capteur->begin();
+}
+
+String HumiTemp::read(){
+    String sortie = "";
+    int hum = this->capteur->readHumidity(true);
+    int temp = this->capteur->readTemperature(false,true);
+
+    //valeur pour un élevage d'astico de pèche selon chatGPT
+    if((temp > 20 && temp < 30) && (hum > 60 && hum < 80)){//TODO: passer les valeurs en config
+        this->full = true;
+    }else{
+        this->full = false;
+    }
+
+    sortie += String(hum);
+    sortie += "/";
+    sortie += String(temp);
+    return sortie;
+}
+//TODO: faire en soirte qu'il y ai un nombre de cycle pour l'aparition d'asticots (entre 1 et 3 jours)

IOT/lib/Capteur/src/Ultrason.cpp

@@ -0,0 +1,19 @@
+#include "../include/Ultrason.h"
+
+
+
+Ultrason::Ultrason(int trigeur, int echo, String fullVall):
+    Capteur("D",fullVall){
+    this->capteur = new Ultrasonic(trigeur, echo);
+}
+
+String Ultrason::read(){
+    int sortie = this->capteur->read();
+    if (sortie < this->fullVall.toInt())
+    {
+        this->full = true;
+    }else{
+        this->full = false;
+    }
+    return String(sortie);
+}//TODO: faire en sorte que full se reset avec une autre val

IOT/platformio.ini

@@ -38,6 +38,10 @@ monitor_flags =
 lib_deps =
     bportaluri/WiFiEsp@^2.2.2 ; gestion des commande 'AT' de l'esp01
     arduino-libraries/Arduino_JSON@^0.2.0 ; gestion des json
+    adafruit/DHT sensor library@^1.4.4 ; DHT11 lib
+    adafruit/Adafruit Unified Sensor@^1.1.9 ; adafruit sensor lib (required by DHT11)
+    ericksimoes/Ultrasonic@^3.0.0 ; lib capteur ultra son
+    bogde/HX711@0.7.5 ; lib pour la balance
 ;    example:
 ;    erropix/ESP32 AnalogWrite@^0.2
 

IOT/src/Program.cpp

@@ -2,9 +2,32 @@
 
 
 Program::Program(){
+    ////////SERIALS//////
+    Serial1.begin(MONITOR_SPEED);
+    Serial.begin(MONITOR_SPEED);
+
+    ////////API///////
+    this->api = new API(USER_NAME, USER_PASSWORD, API_HOST);
+    //this->api->wifiBegin(WIFI_SSID, WIFI_PASSWORD, &Serial1);
+
+
+    //////CAPTEUR/////
+    this->ultrasonic = new Ultrason(ULTRA_SOUND_TRIGD, ULTRA_SOUND_ECHO, "10");//TODO: mettre la valeur en config
+    this->dht = new HumiTemp(DHTPIN, DHTTYPE, "20:30/60:80");//TODO: mettre la valeur en config
 
 }
 
 void Program::loop(){
+    String distance = this->ultrasonic->read();
+    String humitemp = this->dht->read();
     
+    //this->api->sendValue(distance, TRASHCAN_ONE, this->ultrasonic->getValType(), this->ultrasonic->isFull());
+    Serial.print("Distance in CM = " + distance);
+    Serial.println(this->ultrasonic->isFull()?" true":" false");
+
+    //this->api->sendValue(humitemp, TRASHCAN_TWO, this->dht->getValType(), this->dht->isFull());
+    Serial.print("humiTemp = " + this->dht->read());
+    Serial.println(this->dht->isFull()?" true":" false");
+
+    delay(1000);
 }

IOT/src/main.cpp

@@ -1,12 +1,47 @@
-#include <Arduino.h>
-#include "Program.h"
+#ifndef TESTING
 
-Program* program;
+#include <Arduino.h>
+// #include "Program.h"
+
+// Program* program;
+
+// void setup() {
+//   program = new Program();
+// }
+
+// void loop() {
+//   program->loop();
+// }
+
+
+#include "Balance.h"
+
+Balance *balance;
+
+void setup(){
+  Serial.begin(MONITOR_SPEED);
+  balance = new Balance(14,15);
+  
+  Serial.print("start calibr : ");
+  balance->initCalibration();
+
+  Serial.println("OK");
+
+  // Serial.print("posé poids");
+  // delay(5000);
+  // Serial.println("OK");
+  // balance->calibration(500, MOYENNE_CALIBRATION);
+  // Serial.println("END calibration");
+
+  balance->setCalibrationFact(1077);
 
 void setup() {
     program = new Program();
 }
 
-void loop() {
-  program->loop();
+void loop(){
+  // delay(500);
+  Serial.println(balance->getValue());
 }
+
+#endif

IOT/test/main.cpp

@@ -0,0 +1,23 @@
+#include <Arduino.h>
+#include <unity.h>
+#include "test.h"
+void setup() {
+    delay(2000);
+    // start unit tests engine
+    UNITY_BEGIN();
+    Serial.begin(115200);
+    RUN_TEST(TestWifiBeginConnected);
+    RUN_TEST(TestWifiBeginNotConnected);
+    RUN_TEST(TestConnectAPI);
+    // RUN_TEST(TestConnectAPIFailed);
+    RUN_TEST(TestSendValue);
+
+
+    UNITY_END();
+}
+
+
+
+void loop() {
+
+}

IOT/test/test.h

@@ -0,0 +1,10 @@
+#ifndef TEST_H
+#define TEST_H
+
+void TestWifiBeginConnected();
+void TestWifiBeginNotConnected();
+void TestConnectAPI();
+void TestConnectAPIFailed();
+void TestSendValue();
+
+#endif

IOT/test/test_api.cpp

@@ -0,0 +1,48 @@
+#include "test.h"
+#include <unity.h>
+#include "API.h"
+
+
+//Testing WifiBegin function
+void TestWifiBeginConnected() {
+    API* api = new API(USER_NAME, USER_PASSWORD, API_HOST);
+
+    Serial1.begin(MONITOR_SPEED);
+    TEST_ASSERT_EQUAL_MESSAGE(true, api->wifiBegin(WIFI_SSID, WIFI_PASSWORD, &Serial1), "Wifi not connected");
+
+}
+
+void TestWifiBeginNotConnected() {
+    API* api = new API(USER_NAME, USER_PASSWORD, API_HOST);
+
+    Serial2.begin(MONITOR_SPEED);
+    TEST_ASSERT_EQUAL_MESSAGE(false, api->wifiBegin(WIFI_SSID, WIFI_PASSWORD, &Serial2), "Wifi connected");
+
+}
+
+//Testing Connect function
+void TestConnectAPI() {
+    API* api = new API(USER_NAME, USER_PASSWORD, API_HOST);
+
+    Serial1.begin(MONITOR_SPEED);
+    api->wifiBegin(WIFI_SSID, WIFI_PASSWORD, &Serial1);
+    TEST_ASSERT_EQUAL_MESSAGE(true, api->connect(), "Not Connected");
+}
+
+//FIXME: boucle inf when connection failed
+void TestConnectAPIFailed() {
+    API* api = new API("Carl", "toto", API_HOST);
+
+    Serial1.begin(MONITOR_SPEED);
+    api->wifiBegin(WIFI_SSID, WIFI_PASSWORD, &Serial1);
+    TEST_ASSERT_EQUAL_MESSAGE(false, api->connect(), "Connected");
+}
+
+//Testing SendValue function
+void TestSendValue() {
+    API* api = new API(USER_NAME, USER_PASSWORD, API_HOST);
+
+    Serial1.begin(MONITOR_SPEED);
+    api->wifiBegin(WIFI_SSID, WIFI_PASSWORD, &Serial1);
+    TEST_ASSERT_EQUAL_MESSAGE(true, api->sendValue("30", "gdnuxl0wlgurtj3", "W", true), "Not Connected to server");
+}