Merge pull request 'patch' (#22) from develop into master

Reviewed-on: #22

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "new": "cpp"
+    }
+}

config.ini

@@ -14,7 +14,7 @@ build_flags =
     -D MONITOR_SPEED=${config.monitor_speed}
 ; DO NOT TOUCH --- END
     -D WAITING_WIFI_DELAY=1000
-
+    -D TIMEZONE=\"Europe/Paris\"
     ;;;;;;;;;;;;;;;;;;;;;;
     ;;; stepper config ;;;
     ;;;;;;;;;;;;;;;;;;;;;;
@@ -22,4 +22,22 @@ build_flags =
     -D STEPER_ACC=200
     ;-D STEPER_PAS=755.906 ; = 65mm
     -D STEPER_PAS=58 ; = 5mm
-    -D STEPER_SPEED=1000 ; 12000
+    -D STEPER_SPEED=2700 ;1000 ; 2500
+    -D GRBL_UPDATE=165 ;update time in ms
+    ;;;;;;;;;;;;;;;;;;;;;;
+    ;;;   App config   ;;;
+    ;;;;;;;;;;;;;;;;;;;;;;
+    -D APP_TITLE=\"Warehouse\"
+    -D APP_VERSION=\"1.0\"
+    ; nfc addr
+    -D NFC_ADDR=0x28
+    ;;;;;;;;;;;;;;;;;;;;;;
+    ;;;  Servo config  ;;;
+    ;;;;;;;;;;;;;;;;;;;;;;
+    -D RIGHT_POS=14 ;18
+    -D MIDDLE_POS=30 ;32
+    -D LEFT_POS=52
+
+
+
+    -D CONVOYER_LEN=80 ;mm

config_api.ini

@@ -4,7 +4,8 @@ build_flags =
     -D API_LIST_PRODUCT_URL=\"/products/\"
     -D API_GET_PRODUCT_URL=\"/products/{id}/\"
     -D API_GET_PRODUCT_STOCK_URL=\"/products/{id}/stock/\"
+    -D API_GET_PRODUCT_FACTORY_ID=\"/products\"
     -D API_LIST_WAREHOUSE_URL=\"/warehouses/\"
     -D API_LIST_STOCKS_MOVEMENTS_URL=\"/stockmovements/?sortfield=t.rowid\"
     -D API_CREATE_STOCKS_MOVEMENTS_URL=\"/stockmovements/\"
-    -D API_MAX_JSON_SIZE=4096
+    -D API_MAX_JSON_SIZE=6536

include/Program.h

@@ -1,9 +1,12 @@
 #ifndef PROGRAM_H
 #define PROGRAM_H
 
-#include "Arduino.h"
 #include "DolibarrClient.h"
 #include <M5Stack.h>
+#include "ServoMotorComponent.h"
+#include "NfcReader.h"
+#include "GRBL.h"
+#include "BigNfcReader.h"
 
 class Program {
 public:
@@ -16,8 +19,16 @@ public:
      * Program WarehouseGUI loop
      */
     void loop();
+    void checkNfc();
+    void checkServo();
+    void checkWifi();
 private:
     DolibarrClient *client;
+    ServoMotorComponent *servo;
+    NfcReader *nfcReader;
+    GRBL *grbl;
+    BigNfcReader* outputReader;
+    int grblUpdateTime;
 };
 
 #endif

lib/DolibarrClient/src/DolibarrClient.cpp

@@ -2,6 +2,7 @@
 #include <WiFi.h>
 #include <ArduinoJson.h>
 #include <iostream>
+#include "M5LCD.h"
 
 DolibarrClient::DolibarrClient(struct DolibarrConfig dolibarr_config) : dolibarr(dolibarr_config) {
     #if defined(DEBUG)
@@ -29,9 +30,11 @@ int DolibarrClient::login() const {
     HTTPClient *client = this->build_url(API_LOGIN_URL);
     int httpResponseCode = client->GET();
     if (httpResponseCode > 0) {
-        StaticJsonDocument<API_MAX_JSON_SIZE> doc;
+        DynamicJsonDocument doc(384);
         DeserializationError error = deserializeJson(doc, client->getString().c_str());
         if (error) {
+            Serial.println("ERROR: ");
+            Serial.println(error.c_str());
             delete client;
             return -1;
         }
@@ -56,23 +59,54 @@ std::vector<models::Product> *DolibarrClient::list_products() const {
     return nullptr;
 }
 
-models::Product *DolibarrClient::get_product_by_id(const char* id_product) const {
+models::Product DolibarrClient::get_product_by_factory_id(const char* factory_id) const {
-    HTTPClient *client = this->build_url(replace_id(API_GET_PRODUCT_URL, id_product).c_str());
+    HTTPClient *client = this->build_url(replace_id("/products?sortorder=ASC&limit=1&sqlfilters=(t.accountancy_code_sell:like:'{id}')", factory_id).c_str());
     if (client->GET() == HTTP_CODE_OK) {
-        StaticJsonDocument<API_MAX_JSON_SIZE> doc;
+        DynamicJsonDocument doc(6144);
         DeserializationError error = deserializeJson(doc, client->getString().c_str());
         if (error) {
             Serial.println("ERROR: ");
             Serial.println(error.c_str());
+            delete client;
+            return {};
+        }
+        for (auto obj : doc.as<JsonArray>()) {
+            models::Product product;
+            product.date_creation = obj["date_creation"].as<std::string>();
+            product.id = obj["id"].as<std::string>();
+            product.entity = obj["entity"].as<std::string>();
+            product.stock_reel = obj["stock_reel"].as<std::string>();
+            product.label = obj["label"].as<std::string>();
+            product.accountancy_code_sell = obj["accountancy_code_sell"].as<std::string>();
+            product.accountancy_code_sell_export = obj["accountancy_code_sell_export"].as<std::string>();
+            product.fk_default_warehouse = obj["fk_default_warehouse"].as<std::string>();
+            delete client;
+            return product;
+        }
+        delete client;
+        return {};
+    }
+    delete client;
+    return {};
+}
+
+models::Product *DolibarrClient::get_product_by_id(const char* id_product) const {
+    HTTPClient *client = this->build_url(replace_id(API_GET_PRODUCT_URL, id_product).c_str());
+    if (client->GET() == HTTP_CODE_OK) {
+        DynamicJsonDocument doc(6144);
+        DeserializationError error = deserializeJson(doc, client->getString().c_str());
+        if (error) {
             delete client;
             return nullptr;
         }
         auto *product = new models::Product();
-        product->date_creation = doc["date_creation"];
+        product->date_creation = doc["date_creation"].as<std::string>();
-        product->id = doc["id"];
+        product->id = doc["id"].as<std::string>();
-        product->entity = doc["entity"];
+        product->entity = doc["entity"].as<std::string>();
-        product->stock_reel = doc["stock_reel"];
+        product->stock_reel = doc["stock_reel"].as<std::string>();
-        product->label = doc["label"];
+        product->label = doc["label"].as<std::string>();
+        product->accountancy_code_sell = doc["accountancy_code_sell"].as<std::string>();
+        product->accountancy_code_sell_export = doc["accountancy_code_sell_export"].as<std::string>();
         delete client;
         return product;
     }
@@ -83,7 +117,7 @@ models::Product *DolibarrClient::get_product_by_id(const char* id_product) const
 std::vector<models::Warehouse> *DolibarrClient::list_warehouse() const {
     HTTPClient *client = this->build_url(API_LIST_WAREHOUSE_URL);
     if (client->GET() == HTTP_CODE_OK) {
-        StaticJsonDocument<API_MAX_JSON_SIZE> doc;
+        DynamicJsonDocument doc(8192);
         DeserializationError error = deserializeJson(doc, client->getString().c_str());
         if (error) {
             Serial.println("ERROR: ");
@@ -94,7 +128,8 @@ std::vector<models::Warehouse> *DolibarrClient::list_warehouse() const {
         auto *warehouses = new std::vector<models::Warehouse>();
         for (auto obj : doc.as<JsonArray>()) {
             models::Warehouse warehouse = {};
-            warehouse.id = obj["id"];
+            warehouse.id = obj["id"].as<std::string>();
+            warehouse.label = obj["label"].as<std::string>();
             warehouses->push_back(warehouse);
         }
         delete client;
@@ -104,13 +139,15 @@ std::vector<models::Warehouse> *DolibarrClient::list_warehouse() const {
     return nullptr;
 }
 
-int DolibarrClient::create_movement(models::CreateProductStock &stock) const {
+int DolibarrClient::create_movement(models::CreateProductStock stock) const {
-    HTTPClient *client = this->build_url("API_CREATE_STOCKS_MOVEMENTS_URL");
+    HTTPClient *client = this->build_url(API_CREATE_STOCKS_MOVEMENTS_URL);
-    StaticJsonDocument<API_MAX_JSON_SIZE> doc;
+    DynamicJsonDocument doc(4096);
     std::string result;
     doc["product_id"] = stock.product_id;
     doc["warehouse_id"]  = stock.warehouse_id;
     doc["qty"] = stock.qty;
+    doc["movementlabel"] = "T-IOT - Warehouse GUI";
+    doc["movementcode"] = "M" + stock.product_id + "-W" + stock.warehouse_id;
     serializeJson(doc, result);
     Serial.println(result.c_str());
     if (client->POST(result.c_str()) == HTTP_CODE_OK) {
@@ -122,30 +159,5 @@ int DolibarrClient::create_movement(models::CreateProductStock &stock) const {
 
 int DolibarrClient::initialize_http_client() {
     this->httpClient = new HTTPClient();
-    if (this->login() == 0) {
-        auto* product = this->get_product_by_id("1");
-        if (product == nullptr) {
-            Serial.println("Product is nullptr !");
-            return -1;
-        }
-        Serial.println("Product label: ");
-        Serial.println(product->label);
-        auto* warehouses = this->list_warehouse();
-        if (warehouses == nullptr) {
-            delete product;
-            Serial.println("Warehouse is nullptr !");
-            return -1;
-        }
-        Serial.println("Warehouses: ");
-        models::CreateProductStock product_stock = {product->id, warehouses->at(0).id, "1"};
-        this->create_movement(product_stock);
-        for (auto warehouse : *warehouses) {
-            Serial.println(warehouse.id);
-        }
-        delete product;
-        delete warehouses;
-    } else {
-        Serial.println("An Error has occurred while trying to login");
-    }
     return 0;
 }

lib/DolibarrClient/src/DolibarrClient.h

@@ -24,7 +24,8 @@ public:
     std::vector<models::Warehouse> *list_warehouse() const;
     std::vector<models::Product> *list_products() const;
     models::Product *get_product_by_id(const char* id_product) const;
-    int create_movement(models::CreateProductStock &stock) const;
+    models::Product get_product_by_factory_id(const char* uuid) const;
+    int create_movement(models::CreateProductStock stock) const;
 private:
     HTTPClient* httpClient{};
     struct DolibarrConfig dolibarr;

lib/DolibarrClient/src/DolibarrModels.h

@@ -4,35 +4,39 @@
 namespace models {
 
     struct Product {
-        const char* id;
+        std::string id;
-        const char* entity;
+        std::string entity;
-        const char* ref;
+        std::string ref;
-        const char* status;
+        std::string status;
-        const char* date_creation;
+        std::string date_creation;
-        const char* date_modification;
+        std::string date_modification;
-        const char* label;
+        std::string label;
-        const char* description;
+        std::string description;
-        const char* type;
+        std::string type;
-        const char* price;
+        std::string accountancy_code_sell;
-        const char* stock_reel;
+        std::string accountancy_code_sell_export;
-        const char* seuil_stock_alerte;
+        std::string fk_default_warehouse;
-        const char* desiredstock;
+        std::string price;
+        std::string stock_reel;
+        std::string seuil_stock_alerte;
+        std::string desiredstock;
     };
 
     struct ProductStock {
-        const char* id;
+        std::string id;
-        const char* product_id;
+        std::string product_id;
-        const char* quantity;
+        std::string quantity;
     };
 
     struct CreateProductStock {
-        const char* product_id;
+        std::string product_id;
-        const char* warehouse_id;
+        std::string warehouse_id;
-        const char* qty;
+        std::string qty;
     };
 
     struct Warehouse {
-        const char* id;
+        std::string id;
+        std::string label;
     };
 
 }

lib/GRBL/include/GRBL.h

@@ -8,6 +8,7 @@ class iGRBL{
 public:
     virtual void init(int speed, double pas, int accel, String mode = "distance") = 0;
     virtual void mouveForward(int mm) = 0;
+    virtual bool isIddle() = 0;
 };
 
 class GRBL : public iGRBL{
@@ -15,6 +16,7 @@ public:
     GRBL(int grblAddr);
     void init(int speed, double pas, int accel, String mode = "distance") override;
     void mouveForward(int mm = 5) override;
+    bool isIddle() override;
 private:
     Module_GRBL* grbl;
 };

lib/GRBL/src/GRBL.cpp

@@ -32,3 +32,13 @@ void GRBL::mouveForward(int mm){
     sprintf(s, "G1 X%d", mm);
     this->grbl->sendGcode(s);
 }
+
+bool GRBL::isIddle(){
+    bool sortie = false;
+
+    if(this->grbl->readStatus().indexOf("IDLE") != -1){
+        sortie = true;
+    }
+
+    return sortie;
+}

lib/M5LCD/src/M5LCD.cpp

@@ -0,0 +1,224 @@
+#include "M5LCD.h"
+
+/*
+ * M5LCD classe
+ */
+
+M5LCD::M5LCD() : _current_page(0), _logs() , _debug_loc_y(0), _components_status({COMPONENT_KO, COMPONENT_KO, COMPONENT_KO, COMPONENT_KO, COMPONENT_KO}) {
+    this->_product_id = std::string("");
+    this->_product_label = std::string("");
+    this->_last_nfc = std::string("");
+    this->_servo_current_position = std::string("");
+    this->_dolibarr_msg = std::string("");
+    M5.begin();
+    M5.Power.begin();
+    M5.lcd.setBrightness(100);
+    this->update_page();
+}
+
+void M5LCD::update() {
+    M5.update();
+    if (M5.BtnB.wasReleased() != 0) {
+        this->_current_page = (this->_current_page + 1) % LCD_PAGES;
+        this->update_page();
+    }
+    if (this->_current_page == DEBUG_SCREEN && M5.BtnA.wasReleased() != 0 && this->_debug_loc_y < 0) {
+        this->_debug_loc_y++;
+        this->update_page();
+    }
+    if (this->_current_page == DEBUG_SCREEN && M5.BtnC.wasReleased() != 0) {
+        this->_debug_loc_y--;
+        this->update_page();
+    }
+}
+
+void M5LCD::update_page() const {
+    M5.Lcd.clear();
+    switch (this->_current_page) {
+        case 0:
+            this->show_dashboard();
+            break;
+        case 1:
+            this->show_debug();
+            break;
+        case 2:
+            this->show_config();
+            break;
+    }
+    this->update_pagination();
+}
+
+void M5LCD::display_error(const char *str) const {
+    M5.Lcd.setTextColor(WHITE, RED);
+    M5.Lcd.setTextSize(1);
+    M5.Lcd.setCursor(0, 40);
+    M5.Lcd.println(str);
+}
+
+void M5LCD::display_message(const char *str) const {
+}
+
+void M5LCD::display_warning(const char *str) const {
+}
+
+std::string get_status(AvailableComponentsStatus status) {
+    return status == COMPONENT_OK ? "OK" : "KO";
+}
+
+void draw_component_stats(int x, int y, int fx, int fy, int fw, int fh,  const char *name, AvailableComponentsStatus status) {
+    M5.Lcd.setTextSize(2);
+    if (status == COMPONENT_OK) {
+        M5.Lcd.setTextColor(WHITE, GREEN);
+    } else {
+        M5.Lcd.setTextColor(WHITE, RED);
+    }
+    if (status == COMPONENT_OK) {
+        M5.Lcd.fillRect(fx, fy, fw, fh, GREEN);
+    } else {
+        M5.Lcd.fillRect(fx, fy, fw, fh, RED);
+    }
+    M5.Lcd.setCursor(x, y);
+    M5.Lcd.printf("%s %s", name, get_status(status).c_str());
+}
+
+void M5LCD::show_dashboard() const {
+    draw_component_stats(10, 18, 0, 0, 100, 50, "NFC", _components_status.nfc);
+    draw_component_stats(150, 18, 110, 0, 210, 50, "DOLIBARR", _components_status.dolibarr);
+    draw_component_stats(8, 78, 0, 60, 100, 50, "WIFI", _components_status.wifi);
+    draw_component_stats(112, 78, 110, 60, 100, 50, "SERVO", _components_status.servo);
+    draw_component_stats(230, 78, 220, 60, 100, 50, "GRBL", _components_status.grbl);
+
+    M5.Lcd.drawRect(0, 120, 320, 100, BLUE);
+    M5.Lcd.setTextColor(WHITE, BLACK);
+    M5.Lcd.setTextSize(2);
+    if (!this->_last_nfc.empty()) {
+        M5.Lcd.setCursor(10, 130);
+        M5.Lcd.printf("NFC: %s", this->_last_nfc.c_str());
+    }
+    if (!this->_product_id.empty() && !this->_product_label.empty()) {
+        M5.Lcd.setCursor(10, 150);
+        M5.Lcd.printf("Produit: %s - %s", this->_product_label.c_str(), this->_product_id.c_str());
+    }
+    if (!this->_dolibarr_msg.empty()) {
+        M5.Lcd.setCursor(10, 170);
+        M5.Lcd.printf("Produit: %s", this->_last_nfc.c_str());
+    }
+    if (!this->_servo_current_position.empty()) {
+        M5.Lcd.setCursor(10, 190);
+        M5.Lcd.printf("SERVO Posistion: %s", this->_servo_current_position.c_str());
+    }
+
+    M5.Lcd.setTextSize(1);
+    M5.Lcd.setCursor(0, 230);
+    M5.Lcd.printf("%s - %s", APP_TITLE, APP_VERSION);
+}
+
+void M5LCD::show_debug() const {
+    M5.Lcd.setTextColor(WHITE, BLACK);
+    M5.Lcd.setTextSize(1);
+    int i = 0;
+    for (auto val : this->_logs) {
+        M5.Lcd.setCursor(0, i + (this->_debug_loc_y * 10));
+        M5.Lcd.printf("[%s] - %s", val.get_datetime_format(), val.get_message().c_str());
+        i+=10;
+    }
+}
+
+void M5LCD::update_pagination() const {
+    M5.Lcd.setTextSize(1);
+    M5.Lcd.setTextColor(WHITE, BLACK);
+    M5.Lcd.setCursor(302, 230);
+    M5.Lcd.printf("%d/%d", this->_current_page+1, LCD_PAGES);
+}
+
+void M5LCD::add_log(const char* str) {
+    this->_logs.emplace_back(str);
+    if (this->_current_page == DEBUG_SCREEN) {
+        this->show_debug();
+    }
+}
+
+void M5LCD::show_config() const {
+
+}
+
+ComponentsStatus M5LCD::get_components() {
+    return this->_components_status;
+}
+
+void M5LCD::set_wifi_status(AvailableComponentsStatus status) {
+    this->_components_status.wifi = status;
+    this->update_dashboard();
+}
+
+void M5LCD::set_nfc_status(AvailableComponentsStatus status) {
+    this->_components_status.nfc = status;
+    this->update_dashboard();
+}
+
+void M5LCD::set_grbl_status(AvailableComponentsStatus status) {
+    this->_components_status.grbl = status;
+    this->update_dashboard();
+}
+
+void M5LCD::set_servo(AvailableComponentsStatus status) {
+    this->_components_status.servo = status;
+    this->update_dashboard();
+}
+
+void M5LCD::set_dolibarr_status(AvailableComponentsStatus status) {
+    this->_components_status.dolibarr = status;
+    this->update_dashboard();
+}
+
+void M5LCD::update_dashboard() const {
+    if (this->_current_page == DASHBOARD_SCREEN) {
+        this->show_dashboard();
+    }
+}
+
+
+void M5LCD::set_dolibarr_message(std::string str) {
+    this->_dolibarr_msg = str;
+    this->update_dashboard();
+}
+
+void M5LCD::set_nfc_message(std::string str) {
+    this->_last_nfc = str;
+    this->update_dashboard();
+}
+
+void M5LCD::set_product_id(std::string str) {
+    this->_product_id = str;
+    this->update_dashboard();
+}
+
+void M5LCD::set_servo_message(std::string str) {
+    this->_servo_current_position = str;
+    this->update_dashboard();
+}
+
+void M5LCD::set_product_label(std::string str) {
+    this->_product_label = str;
+    this->update_dashboard();
+
+}
+
+/*
+ * LogMessage classe
+ */
+
+LogMessage::LogMessage(std::string log) {
+    this->log = log;
+    this->datetime = time(nullptr);
+}
+
+std::string LogMessage::get_message() const {
+    return this->log;
+}
+
+const char *LogMessage::get_datetime_format() const {
+    void *buff = malloc(20 * sizeof(char));
+    strftime((char*) buff, 20, "%H:%M:%S", localtime(&this->datetime));
+    return (char*) buff;
+}

lib/M5LCD/src/M5LCD.h

@@ -0,0 +1,84 @@
+#ifndef T_IOT_901_CONVOYOR_M5LCD_H
+#define T_IOT_901_CONVOYOR_M5LCD_H
+
+#include <vector>
+#include <ctime>
+#include "M5Stack.h"
+
+#define LCD_PAGES 3
+#define DASHBOARD_SCREEN 0
+#define DEBUG_SCREEN 1
+#define CONFIG_SCREEN 2
+
+enum AvailableComponentsStatus {
+    COMPONENT_OK,
+    COMPONENT_KO,
+    COMPONENT_MISSING,
+    UNKNOWN_ERROR,
+};
+
+typedef struct ComponentsStatus {
+    AvailableComponentsStatus nfc;
+    AvailableComponentsStatus wifi;
+    AvailableComponentsStatus dolibarr;
+    AvailableComponentsStatus servo;
+    AvailableComponentsStatus grbl;
+} ComponentsStatus;
+
+typedef struct MessageToShow {
+    const char* message;
+    int color;
+} MessageToShow;
+
+class LogMessage {
+public:
+    LogMessage(std::string log);
+    std::string get_message() const;
+    const char* get_datetime_format() const;
+private:
+    time_t datetime;
+    std::string log;
+};
+
+class M5LCD {
+public:
+    M5LCD();
+    void display_message(const char* str) const;
+    void display_error(const char* str) const;
+    void display_warning(const char* str) const;
+    void add_log(const char *str);
+    void update();
+    ComponentsStatus get_components();
+    void set_wifi_status(AvailableComponentsStatus status);
+    void set_nfc_status(AvailableComponentsStatus status);
+    void set_grbl_status(AvailableComponentsStatus status);
+    void set_servo(AvailableComponentsStatus status);
+    void set_dolibarr_status(AvailableComponentsStatus status);
+
+    void set_nfc_message(std::string str);
+    void set_dolibarr_message(std::string str);
+    void set_product_label(std::string str);
+    void set_product_id(std::string str);
+    void set_servo_message(std::string str);
+    int _current_page;
+private:
+    void update_page() const;
+    void show_debug() const;
+    void show_dashboard() const;
+    void show_config() const;
+    void update_pagination() const;
+    void update_dashboard() const;
+
+    int _debug_loc_y;
+    std::vector<LogMessage> _logs;
+    ComponentsStatus _components_status;
+    std::string _last_nfc;
+    std::string _product_label;
+    std::string _product_id;
+    std::string _dolibarr_msg;
+    std::string _servo_current_position;
+};
+
+inline M5LCD *lcdScreen;
+
+#endif //T_IOT_901_CONVOYOR_M5LCD_H

lib/NFC/src/MFRC522_I2C.h

@@ -0,0 +1,472 @@
+/**
+ * MFRC522_I2C.h - Library to use ARDUINO RFID MODULE KIT 13.56 MHZ WITH TAGS
+ *I2C BY AROZCAN MFRC522_I2C.h - Based on ARDUINO RFID MODULE KIT 13.56 MHZ WITH
+ *TAGS SPI Library BY COOQROBOT. Based on code Dr.Leong   ( WWW.B2CQSHOP.COM )
+ * Created by Miguel Balboa (circuitito.com), Jan, 2012.
+ * Rewritten by Søren Thing Andersen (access.thing.dk), fall of 2013
+ *(Translation to English, refactored, comments, anti collision, cascade
+ *levels.) Extended by Tom Clement with functionality to write to sector 0 of
+ *UID changeable Mifare cards. Extended by Ahmet Remzi Ozcan with I2C
+ *functionality. Author: arozcan @
+ *https://github.com/arozcan/MFRC522-I2C-Library Released into the public
+ *domain.
+ *
+ * Please read this file for an overview and then MFRC522.cpp for comments on
+ *the specific functions. Search for "mf-rc522" on ebay.com to purchase the
+ *MF-RC522 board.
+ *
+ * There are three hardware components involved:
+ * 1) The micro controller: An Arduino
+ * 2) The PCD (short for Proximity Coupling Device): NXP MFRC522 Contactless
+ *Reader IC 3) The PICC (short for Proximity Integrated Circuit Card): A card or
+ *tag using the ISO 14443A interface, eg Mifare or NTAG203.
+ *
+ * The microcontroller and card reader uses I2C for communication.
+ * The protocol is described in the MFRC522 datasheet:
+ *http://www.nxp.com/documents/data_sheet/MFRC522.pdf
+ *
+ * The card reader and the tags communicate using a 13.56MHz electromagnetic
+ *field. The protocol is defined in ISO/IEC 14443-3 Identification cards --
+ *Contactless integrated circuit cards -- Proximity cards -- Part 3:
+ *Initialization and anticollision". A free version of the final draft can be
+ *found at http://wg8.de/wg8n1496_17n3613_Ballot_FCD14443-3.pdf Details are
+ *found in chapter 6, Type A – Initialization and anticollision.
+ *
+ * If only the PICC UID is wanted, the above documents has all the needed
+ *information. To read and write from MIFARE PICCs, the MIFARE protocol is used
+ *after the PICC has been selected. The MIFARE Classic chips and protocol is
+ *described in the datasheets: 1K:
+ *http://www.nxp.com/documents/data_sheet/MF1S503x.pdf 4K:
+ *http://www.nxp.com/documents/data_sheet/MF1S703x.pdf Mini:
+ *http://www.idcardmarket.com/download/mifare_S20_datasheet.pdf The MIFARE
+ *Ultralight chip and protocol is described in the datasheets: Ultralight:
+ *http://www.nxp.com/documents/data_sheet/MF0ICU1.pdf Ultralight C:
+ *http://www.nxp.com/documents/short_data_sheet/MF0ICU2_SDS.pdf
+ *
+ * MIFARE Classic 1K (MF1S503x):
+ * 		Has 16 sectors * 4 blocks/sector * 16 bytes/block = 1024 bytes.
+ * 		The blocks are numbered 0-63.
+ * 		Block 3 in each sector is the Sector Trailer. See
+ *http://www.nxp.com/documents/data_sheet/MF1S503x.pdf sections 8.6 and 8.7:
+ * 				Bytes 0-5:   Key A
+ * 				Bytes 6-8:   Access Bits
+ * 				Bytes 9:     User data
+ * 				Bytes 10-15: Key B (or user data)
+ * 		Block 0 is read-only manufacturer data.
+ * 		To access a block, an authentication using a key from the block's sector
+ *must be performed first. Example: To read from block 10, first authenticate
+ *using a key from sector 3 (blocks 8-11). All keys are set to FFFFFFFFFFFFh at
+ *chip delivery. Warning: Please read section 8.7 "Memory Access". It includes
+ *this text: if the PICC detects a format violation the whole sector is
+ *irreversibly blocked. To use a block in "value block" mode (for
+ *Increment/Decrement operations) you need to change the sector trailer. Use
+ *PICC_SetAccessBits() to calculate the bit patterns. MIFARE Classic 4K
+ *(MF1S703x): Has (32 sectors * 4 blocks/sector + 8 sectors * 16 blocks/sector)
+ ** 16 bytes/block = 4096 bytes. The blocks are numbered 0-255. The last block
+ *in each sector is the Sector Trailer like above. MIFARE Classic Mini (MF1 IC
+ *S20): Has 5 sectors * 4 blocks/sector * 16 bytes/block = 320 bytes. The blocks
+ *are numbered 0-19. The last block in each sector is the Sector Trailer like
+ *above.
+ *
+ * MIFARE Ultralight (MF0ICU1):
+ * 		Has 16 pages of 4 bytes = 64 bytes.
+ * 		Pages 0 + 1 is used for the 7-byte UID.
+ * 		Page 2 contains the last check digit for the UID, one byte manufacturer
+ *internal data, and the lock bytes (see
+ *http://www.nxp.com/documents/data_sheet/MF0ICU1.pdf section 8.5.2) Page 3 is
+ *OTP, One Time Programmable bits. Once set to 1 they cannot revert to 0. Pages
+ *4-15 are read/write unless blocked by the lock bytes in page 2. MIFARE
+ *Ultralight C (MF0ICU2): Has 48 pages of 4 bytes = 192 bytes. Pages 0 + 1 is
+ *used for the 7-byte UID. Page 2 contains the last check digit for the UID, one
+ *byte manufacturer internal data, and the lock bytes (see
+ *http://www.nxp.com/documents/data_sheet/MF0ICU1.pdf section 8.5.2) Page 3 is
+ *OTP, One Time Programmable bits. Once set to 1 they cannot revert to 0. Pages
+ *4-39 are read/write unless blocked by the lock bytes in page 2. Page 40 Lock
+ *bytes Page 41 16 bit one way counter Pages 42-43 Authentication configuration
+ * 		Pages 44-47 Authentication key
+ */
+#ifndef MFRC522_h
+#define MFRC522_h
+
+#include <Arduino.h>
+#include <Wire.h>
+
+// Firmware data for self-test
+// Reference values based on firmware version
+// Hint: if needed, you can remove unused self-test data to save flash memory
+//
+// Version 0.0 (0x90)
+// Philips Semiconductors; Preliminary Specification Revision 2.0 - 01 August
+// 2005; 16.1 Sefttest
+const byte MFRC522_firmware_referenceV0_0[] PROGMEM = {
+    0x00, 0x87, 0x98, 0x0f, 0x49, 0xFF, 0x07, 0x19, 0xBF, 0x22, 0x30,
+    0x49, 0x59, 0x63, 0xAD, 0xCA, 0x7F, 0xE3, 0x4E, 0x03, 0x5C, 0x4E,
+    0x49, 0x50, 0x47, 0x9A, 0x37, 0x61, 0xE7, 0xE2, 0xC6, 0x2E, 0x75,
+    0x5A, 0xED, 0x04, 0x3D, 0x02, 0x4B, 0x78, 0x32, 0xFF, 0x58, 0x3B,
+    0x7C, 0xE9, 0x00, 0x94, 0xB4, 0x4A, 0x59, 0x5B, 0xFD, 0xC9, 0x29,
+    0xDF, 0x35, 0x96, 0x98, 0x9E, 0x4F, 0x30, 0x32, 0x8D};
+// Version 1.0 (0x91)
+// NXP Semiconductors; Rev. 3.8 - 17 September 2014; 16.1.1 Self test
+const byte MFRC522_firmware_referenceV1_0[] PROGMEM = {
+    0x00, 0xC6, 0x37, 0xD5, 0x32, 0xB7, 0x57, 0x5C, 0xC2, 0xD8, 0x7C,
+    0x4D, 0xD9, 0x70, 0xC7, 0x73, 0x10, 0xE6, 0xD2, 0xAA, 0x5E, 0xA1,
+    0x3E, 0x5A, 0x14, 0xAF, 0x30, 0x61, 0xC9, 0x70, 0xDB, 0x2E, 0x64,
+    0x22, 0x72, 0xB5, 0xBD, 0x65, 0xF4, 0xEC, 0x22, 0xBC, 0xD3, 0x72,
+    0x35, 0xCD, 0xAA, 0x41, 0x1F, 0xA7, 0xF3, 0x53, 0x14, 0xDE, 0x7E,
+    0x02, 0xD9, 0x0F, 0xB5, 0x5E, 0x25, 0x1D, 0x29, 0x79};
+// Version 2.0 (0x92)
+// NXP Semiconductors; Rev. 3.8 - 17 September 2014; 16.1.1 Self test
+const byte MFRC522_firmware_referenceV2_0[] PROGMEM = {
+    0x00, 0xEB, 0x66, 0xBA, 0x57, 0xBF, 0x23, 0x95, 0xD0, 0xE3, 0x0D,
+    0x3D, 0x27, 0x89, 0x5C, 0xDE, 0x9D, 0x3B, 0xA7, 0x00, 0x21, 0x5B,
+    0x89, 0x82, 0x51, 0x3A, 0xEB, 0x02, 0x0C, 0xA5, 0x00, 0x49, 0x7C,
+    0x84, 0x4D, 0xB3, 0xCC, 0xD2, 0x1B, 0x81, 0x5D, 0x48, 0x76, 0xD5,
+    0x71, 0x61, 0x21, 0xA9, 0x86, 0x96, 0x83, 0x38, 0xCF, 0x9D, 0x5B,
+    0x6D, 0xDC, 0x15, 0xBA, 0x3E, 0x7D, 0x95, 0x3B, 0x2F};
+// Clone
+// Fudan Semiconductor FM17522 (0x88)
+const byte FM17522_firmware_reference[] PROGMEM = {
+    0x00, 0xD6, 0x78, 0x8C, 0xE2, 0xAA, 0x0C, 0x18, 0x2A, 0xB8, 0x7A,
+    0x7F, 0xD3, 0x6A, 0xCF, 0x0B, 0xB1, 0x37, 0x63, 0x4B, 0x69, 0xAE,
+    0x91, 0xC7, 0xC3, 0x97, 0xAE, 0x77, 0xF4, 0x37, 0xD7, 0x9B, 0x7C,
+    0xF5, 0x3C, 0x11, 0x8F, 0x15, 0xC3, 0xD7, 0xC1, 0x5B, 0x00, 0x2A,
+    0xD0, 0x75, 0xDE, 0x9E, 0x51, 0x64, 0xAB, 0x3E, 0xE9, 0x15, 0xB5,
+    0xAB, 0x56, 0x9A, 0x98, 0x82, 0x26, 0xEA, 0x2A, 0x62};
+
+class MFRC522 {
+   public:
+    // MFRC522 registers. Described in chapter 9 of the datasheet.
+    enum PCD_Register {
+        // Page 0: Command and status
+        //						  0x00			// reserved for future use
+        CommandReg = 0x01,  // starts and stops command execution
+        ComIEnReg  = 0x02,  // enable and disable interrupt request control bits
+        DivIEnReg  = 0x03,  // enable and disable interrupt request control bits
+        ComIrqReg  = 0x04,  // interrupt request bits
+        DivIrqReg  = 0x05,  // interrupt request bits
+        ErrorReg   = 0x06,  // error bits showing the error status of the last
+                            // command executed
+        Status1Reg    = 0x07,  // communication status bits
+        Status2Reg    = 0x08,  // receiver and transmitter status bits
+        FIFODataReg   = 0x09,  // input and output of 64 byte FIFO buffer
+        FIFOLevelReg  = 0x0A,  // number of bytes stored in the FIFO buffer
+        WaterLevelReg = 0x0B,  // level for FIFO underflow and overflow warning
+        ControlReg    = 0x0C,  // miscellaneous control registers
+        BitFramingReg = 0x0D,  // adjustments for bit-oriented frames
+        CollReg = 0x0E,  // bit position of the first bit-collision detected on
+                         // the RF interface
+        //						  0x0F			// reserved for future use
+
+        // Page 1: Command
+        // 						  0x10			// reserved for future use
+        ModeReg = 0x11,  // defines general modes for transmitting and receiving
+        TxModeReg    = 0x12,  // defines transmission data rate and framing
+        RxModeReg    = 0x13,  // defines reception data rate and framing
+        TxControlReg = 0x14,  // controls the logical behavior of the antenna
+                              // driver pins TX1 and TX2
+        TxASKReg = 0x15,  // controls the setting of the transmission modulation
+        TxSelReg = 0x16,  // selects the internal sources for the antenna driver
+        RxSelReg = 0x17,  // selects internal receiver settings
+        RxThresholdReg = 0x18,  // selects thresholds for the bit decoder
+        DemodReg       = 0x19,  // defines demodulator settings
+        // 						  0x1A			// reserved for future use
+        // 						  0x1B			// reserved for future use
+        MfTxReg =
+            0x1C,  // controls some MIFARE communication transmit parameters
+        MfRxReg =
+            0x1D,  // controls some MIFARE communication receive parameters
+        // 						  0x1E			// reserved for future use
+        SerialSpeedReg =
+            0x1F,  // selects the speed of the serial UART interface
+
+        // Page 2: Configuration
+        // 						  0x20			// reserved for future use
+        CRCResultRegH =
+            0x21,  // shows the MSB and LSB values of the CRC calculation
+        CRCResultRegL = 0x22,
+        // 						  0x23			// reserved for future use
+        ModWidthReg = 0x24,  // controls the ModWidth setting?
+        // 						  0x25			// reserved for future use
+        RFCfgReg = 0x26,   // configures the receiver gain
+        GsNReg   = 0x27,   // selects the conductance of the antenna driver pins
+                           // TX1 and TX2 for modulation
+        CWGsPReg = 0x28,   // defines the conductance of the p-driver output
+                           // during periods of no modulation
+        ModGsPReg = 0x29,  // defines the conductance of the p-driver output
+                           // during periods of modulation
+        TModeReg      = 0x2A,  // defines settings for the internal timer
+        TPrescalerReg = 0x2B,  // the lower 8 bits of the TPrescaler value. The
+                               // 4 high bits are in TModeReg.
+        TReloadRegH       = 0x2C,  // defines the 16-bit timer reload value
+        TReloadRegL       = 0x2D,
+        TCounterValueRegH = 0x2E,  // shows the 16-bit timer value
+        TCounterValueRegL = 0x2F,
+
+        // Page 3: Test Registers
+        // 						  0x30			// reserved for future use
+        TestSel1Reg     = 0x31,  // general test signal configuration
+        TestSel2Reg     = 0x32,  // general test signal configuration
+        TestPinEnReg    = 0x33,  // enables pin output driver on pins D1 to D7
+        TestPinValueReg = 0x34,  // defines the values for D1 to D7 when it is
+                                 // used as an I/O bus
+        TestBusReg    = 0x35,    // shows the status of the internal test bus
+        AutoTestReg   = 0x36,    // controls the digital self test
+        VersionReg    = 0x37,    // shows the software version
+        AnalogTestReg = 0x38,    // controls the pins AUX1 and AUX2
+        TestDAC1Reg   = 0x39,    // defines the test value for TestDAC1
+        TestDAC2Reg   = 0x3A,    // defines the test value for TestDAC2
+        TestADCReg    = 0x3B     // shows the value of ADC I and Q channels
+        // 						  0x3C			// reserved for production tests
+        // 						  0x3D			// reserved for production tests
+        // 						  0x3E			// reserved for production tests
+        // 						  0x3F			// reserved for production tests
+    };
+
+    // MFRC522 commands. Described in chapter 10 of the datasheet.
+    enum PCD_Command {
+        PCD_Idle = 0x00,  // no action, cancels current command execution
+        PCD_Mem  = 0x01,  // stores 25 bytes into the internal buffer
+        PCD_GenerateRandomID = 0x02,  // generates a 10-byte random ID number
+        PCD_CalcCRC =
+            0x03,  // activates the CRC coprocessor or performs a self test
+        PCD_Transmit    = 0x04,  // transmits data from the FIFO buffer
+        PCD_NoCmdChange = 0x07,  // no command change, can be used to modify the
+                                 // CommandReg register bits without affecting
+                                 // the command, for example, the PowerDown bit
+        PCD_Receive = 0x08,      // activates the receiver circuits
+        PCD_Transceive =
+            0x0C,  // transmits data from FIFO buffer to antenna and
+                   // automatically activates the receiver after transmission
+        PCD_MFAuthent =
+            0x0E,  // performs the MIFARE standard authentication as a reader
+        PCD_SoftReset = 0x0F  // resets the MFRC522
+    };
+
+    // MFRC522 RxGain[2:0] masks, defines the receiver's signal voltage gain
+    // factor (on the PCD). Described in 9.3.3.6 / table 98 of the datasheet at
+    // http://www.nxp.com/documents/data_sheet/MFRC522.pdf
+    enum PCD_RxGain {
+        RxGain_18dB = 0x00 << 4,  // 000b - 18 dB, minimum
+        RxGain_23dB = 0x01 << 4,  // 001b - 23 dB
+        RxGain_18dB_2 =
+            0x02 << 4,  // 010b - 18 dB, it seems 010b is a duplicate for 000b
+        RxGain_23dB_2 =
+            0x03 << 4,  // 011b - 23 dB, it seems 011b is a duplicate for 001b
+        RxGain_33dB = 0x04 << 4,  // 100b - 33 dB, average, and typical default
+        RxGain_38dB = 0x05 << 4,  // 101b - 38 dB
+        RxGain_43dB = 0x06 << 4,  // 110b - 43 dB
+        RxGain_48dB = 0x07 << 4,  // 111b - 48 dB, maximum
+        RxGain_min =
+            0x00 << 4,  // 000b - 18 dB, minimum, convenience for RxGain_18dB
+        RxGain_avg =
+            0x04 << 4,  // 100b - 33 dB, average, convenience for RxGain_33dB
+        RxGain_max =
+            0x07 << 4  // 111b - 48 dB, maximum, convenience for RxGain_48dB
+    };
+
+    // Commands sent to the PICC.
+    enum PICC_Command {
+        // The commands used by the PCD to manage communication with several
+        // PICCs (ISO 14443-3, Type A, section 6.4)
+        PICC_CMD_REQA = 0x26,  // REQuest command, Type A. Invites PICCs in
+                               // state IDLE to go to READY and prepare for
+                               // anticollision or selection. 7 bit frame.
+        PICC_CMD_WUPA =
+            0x52,  // Wake-UP command, Type A. Invites PICCs in state IDLE and
+                   // HALT to go to READY(*) and prepare for anticollision or
+                   // selection. 7 bit frame.
+        PICC_CMD_CT = 0x88,       // Cascade Tag. Not really a command, but used
+                                  // during anti collision.
+        PICC_CMD_SEL_CL1 = 0x93,  // Anti collision/Select, Cascade Level 1
+        PICC_CMD_SEL_CL2 = 0x95,  // Anti collision/Select, Cascade Level 2
+        PICC_CMD_SEL_CL3 = 0x97,  // Anti collision/Select, Cascade Level 3
+        PICC_CMD_HLTA = 0x50,  // HaLT command, Type A. Instructs an ACTIVE PICC
+                               // to go to state HALT.
+        // The commands used for MIFARE Classic (from
+        // http://www.nxp.com/documents/data_sheet/MF1S503x.pdf, Section 9)
+        // Use PCD_MFAuthent to authenticate access to a sector, then use these
+        // commands to read/write/modify the blocks on the sector.
+        // The read/write commands can also be used for MIFARE Ultralight.
+        PICC_CMD_MF_AUTH_KEY_A = 0x60,  // Perform authentication with Key A
+        PICC_CMD_MF_AUTH_KEY_B = 0x61,  // Perform authentication with Key B
+        PICC_CMD_MF_READ =
+            0x30,  // Reads one 16 byte block from the authenticated sector of
+                   // the PICC. Also used for MIFARE Ultralight.
+        PICC_CMD_MF_WRITE =
+            0xA0,  // Writes one 16 byte block to the authenticated sector of
+                   // the PICC. Called "COMPATIBILITY WRITE" for MIFARE
+                   // Ultralight.
+        PICC_CMD_MF_DECREMENT =
+            0xC0,  // Decrements the contents of a block and stores the result
+                   // in the internal data register.
+        PICC_CMD_MF_INCREMENT =
+            0xC1,  // Increments the contents of a block and stores the result
+                   // in the internal data register.
+        PICC_CMD_MF_RESTORE = 0xC2,   // Reads the contents of a block into the
+                                      // internal data register.
+        PICC_CMD_MF_TRANSFER = 0xB0,  // Writes the contents of the internal
+                                      // data register to a block.
+        // The commands used for MIFARE Ultralight (from
+        // http://www.nxp.com/documents/data_sheet/MF0ICU1.pdf, Section 8.6)
+        // The PICC_CMD_MF_READ and PICC_CMD_MF_WRITE can also be used for
+        // MIFARE Ultralight.
+        PICC_CMD_UL_WRITE = 0xA2  // Writes one 4 byte page to the PICC.
+    };
+
+    // MIFARE constants that does not fit anywhere else
+    enum MIFARE_Misc {
+        MF_ACK = 0xA,    // The MIFARE Classic uses a 4 bit ACK/NAK. Any other
+                         // value than 0xA is NAK.
+        MF_KEY_SIZE = 6  // A Mifare Crypto1 key is 6 bytes.
+    };
+
+    // PICC types we can detect. Remember to update PICC_GetTypeName() if you
+    // add more.
+    enum PICC_Type {
+        PICC_TYPE_UNKNOWN     = 0,
+        PICC_TYPE_ISO_14443_4 = 1,  // PICC compliant with ISO/IEC 14443-4
+        PICC_TYPE_ISO_18092   = 2,  // PICC compliant with ISO/IEC 18092 (NFC)
+        PICC_TYPE_MIFARE_MINI = 3,  // MIFARE Classic protocol, 320 bytes
+        PICC_TYPE_MIFARE_1K   = 4,  // MIFARE Classic protocol, 1KB
+        PICC_TYPE_MIFARE_4K   = 5,  // MIFARE Classic protocol, 4KB
+        PICC_TYPE_MIFARE_UL   = 6,  // MIFARE Ultralight or Ultralight C
+        PICC_TYPE_MIFARE_PLUS = 7,  // MIFARE Plus
+        PICC_TYPE_TNP3XXX = 8,  // Only mentioned in NXP AN 10833 MIFARE Type
+                                // Identification Procedure
+        PICC_TYPE_NOT_COMPLETE = 255  // SAK indicates UID is not complete.
+    };
+
+    // Return codes from the functions in this class. Remember to update
+    // GetStatusCodeName() if you add more.
+    enum StatusCode {
+        STATUS_OK        = 1,  // Success
+        STATUS_ERROR     = 2,  // Error in communication
+        STATUS_COLLISION = 3,  // Collission detected
+        STATUS_TIMEOUT   = 4,  // Timeout in communication.
+        STATUS_NO_ROOM   = 5,  // A buffer is not big enough.
+        STATUS_INTERNAL_ERROR =
+            6,  // Internal error in the code. Should not happen ;-)
+        STATUS_INVALID     = 7,  // Invalid argument.
+        STATUS_CRC_WRONG   = 8,  // The CRC_A does not match
+        STATUS_MIFARE_NACK = 9   // A MIFARE PICC responded with NAK.
+    };
+
+    // A struct used for passing the UID of a PICC.
+    typedef struct {
+        byte size;  // Number of bytes in the UID. 4, 7 or 10.
+        byte uidByte[10];
+        byte sak;  // The SAK (Select acknowledge) byte returned from the PICC
+                   // after successful selection.
+    } Uid;
+
+    // A struct used for passing a MIFARE Crypto1 key
+    typedef struct {
+        byte keyByte[MF_KEY_SIZE];
+    } MIFARE_Key;
+
+    // Member variables
+    Uid uid;  // Used by PICC_ReadCardSerial().
+
+    // Size of the MFRC522 FIFO
+    static const byte FIFO_SIZE = 64;  // The FIFO is 64 bytes.
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Functions for setting up the Arduino
+    /////////////////////////////////////////////////////////////////////////////////////
+    MFRC522(byte chipAddress);
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Basic interface functions for communicating with the MFRC522
+    /////////////////////////////////////////////////////////////////////////////////////
+    void PCD_WriteRegister(byte reg, byte value);
+    void PCD_WriteRegister(byte reg, byte count, byte *values);
+    byte PCD_ReadRegister(byte reg);
+    void PCD_ReadRegister(byte reg, byte count, byte *values, byte rxAlign = 0);
+    void setBitMask(unsigned char reg, unsigned char mask);
+    void PCD_SetRegisterBitMask(byte reg, byte mask);
+    void PCD_ClearRegisterBitMask(byte reg, byte mask);
+    byte PCD_CalculateCRC(byte *data, byte length, byte *result);
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Functions for manipulating the MFRC522
+    /////////////////////////////////////////////////////////////////////////////////////
+    void PCD_Init();
+    void PCD_Reset();
+    void PCD_AntennaOn();
+    void PCD_AntennaOff();
+    byte PCD_GetAntennaGain();
+    void PCD_SetAntennaGain(byte mask);
+    bool PCD_PerformSelfTest();
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Functions for communicating with PICCs
+    /////////////////////////////////////////////////////////////////////////////////////
+    byte PCD_TransceiveData(byte *sendData, byte sendLen, byte *backData,
+                            byte *backLen, byte *validBits = NULL,
+                            byte rxAlign = 0, bool checkCRC = false);
+    byte PCD_CommunicateWithPICC(byte command, byte waitIRq, byte *sendData,
+                                 byte sendLen, byte *backData = NULL,
+                                 byte *backLen = NULL, byte *validBits = NULL,
+                                 byte rxAlign = 0, bool checkCRC = false);
+    byte PICC_RequestA(byte *bufferATQA, byte *bufferSize);
+    byte PICC_WakeupA(byte *bufferATQA, byte *bufferSize);
+    byte PICC_REQA_or_WUPA(byte command, byte *bufferATQA, byte *bufferSize);
+    byte PICC_Select(Uid *uid, byte validBits = 0);
+    byte PICC_HaltA();
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Functions for communicating with MIFARE PICCs
+    /////////////////////////////////////////////////////////////////////////////////////
+    byte PCD_Authenticate(byte command, byte blockAddr, MIFARE_Key *key,
+                          Uid *uid);
+    void PCD_StopCrypto1();
+    byte MIFARE_Read(byte blockAddr, byte *buffer, byte *bufferSize);
+    byte MIFARE_Write(byte blockAddr, byte *buffer, byte bufferSize);
+    byte MIFARE_Decrement(byte blockAddr, long delta);
+    byte MIFARE_Increment(byte blockAddr, long delta);
+    byte MIFARE_Restore(byte blockAddr);
+    byte MIFARE_Transfer(byte blockAddr);
+    byte MIFARE_Ultralight_Write(byte page, byte *buffer, byte bufferSize);
+    byte MIFARE_GetValue(byte blockAddr, long *value);
+    byte MIFARE_SetValue(byte blockAddr, long value);
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Support functions
+    /////////////////////////////////////////////////////////////////////////////////////
+    byte PCD_MIFARE_Transceive(byte *sendData, byte sendLen,
+                               bool acceptTimeout = false);
+    // old function used too much memory, now name moved to flash; if you need
+    // char, copy from flash to memory
+    // const char *GetStatusCodeName(byte code);
+    const __FlashStringHelper *GetStatusCodeName(byte code);
+    byte PICC_GetType(byte sak);
+    // old function used too much memory, now name moved to flash; if you need
+    // char, copy from flash to memory
+    // const char *PICC_GetTypeName(byte type);
+    const __FlashStringHelper *PICC_GetTypeName(byte type);
+    void PICC_DumpToSerial(Uid *uid);
+    void PICC_DumpMifareClassicToSerial(Uid *uid, byte piccType,
+                                        MIFARE_Key *key);
+    void PICC_DumpMifareClassicSectorToSerial(Uid *uid, MIFARE_Key *key,
+                                              byte sector);
+    void PICC_DumpMifareUltralightToSerial();
+    void MIFARE_SetAccessBits(byte *accessBitBuffer, byte g0, byte g1, byte g2,
+                              byte g3);
+    bool MIFARE_OpenUidBackdoor(bool logErrors);
+    bool MIFARE_SetUid(byte *newUid, byte uidSize, bool logErrors);
+    bool MIFARE_UnbrickUidSector(bool logErrors);
+
+    /////////////////////////////////////////////////////////////////////////////////////
+    // Convenience functions - does not add extra functionality
+    /////////////////////////////////////////////////////////////////////////////////////
+    bool PICC_IsNewCardPresent();
+    bool PICC_ReadCardSerial();
+
+   private:
+    byte _chipAddress;
+    byte _resetPowerDownPin;  // Arduino pin connected to MFRC522's reset and
+                              // power down input (Pin 6, NRSTPD, active low)
+    byte MIFARE_TwoStepHelper(byte command, byte blockAddr, long data);
+};
+
+#endif

lib/NFC/src/NfcReader.cpp

@@ -0,0 +1,32 @@
+#include "NfcReader.h"
+
+NfcReader::NfcReader(int i2c_adress)
+{
+    this->mfrc522 = new MFRC522(i2c_adress);
+    this->mfrc522->PCD_Init();
+}
+
+String NfcReader::ReadNfc()
+{
+    this->uid.clear();
+    if (!this->mfrc522->PICC_IsNewCardPresent() ||
+        !this->mfrc522->PICC_ReadCardSerial()) {
+        return "0";
+    }
+    for (unsigned int i = 0; i < this->mfrc522->uid.size; i++) {
+        if (this->mfrc522->uid.uidByte[i] < 0xF) {
+            this->uid += '0';
+            this->uid += String(this->mfrc522->uid.uidByte[i], HEX);
+        } else {
+            this->uid += String(this->mfrc522->uid.uidByte[i], HEX);
+        }
+    }
+    return (this->uid);
+}
+
+bool NfcReader::IsNfcConnected()
+{
+    Wire.beginTransmission(NFC_ADDR);
+    byte error = Wire.endTransmission();
+    return error == 0;
+}

lib/NFC/src/NfcReader.h

@@ -0,0 +1,22 @@
+#ifndef NFCREADER_H
+#define NFCREADER_H
+
+#include <M5Stack.h>
+#include "MFRC522_I2C.h"
+#include <string>
+
+class NfcReader {
+    public:
+        NfcReader(int i2c_adress);
+        ~NfcReader() = default;
+        bool IsNfcConnected();
+
+        String ReadNfc();
+
+    protected:
+    private:
+        MFRC522 *mfrc522;
+        String uid;
+};
+
+#endif /* !NFCREADER_H */

lib/NfcReader/include/BigNfcReader.h

@@ -0,0 +1,67 @@
+#ifndef BIG_NFC_READER_H
+#define BIG_NFC_READER_H
+
+#include <Arduino.h>
+#include <vector>
+
+#include "TrameList.h"
+
+class BigNfcReader{
+public:
+    BigNfcReader();
+
+    /**
+     * @brief initialise le lecteur NFC
+     *
+     * @return true le lecteur NFC est initialisé
+     * @return false le lecteur NFC n'est pas initialisé (erreur)
+     */
+    bool init();
+
+    /**
+     * @brief rafraichit les données du lecteur NFC
+     *
+     */
+    void refresh();
+
+    /**
+     * @brief affiche la dernière trame lue
+     *
+     */
+    void printTrame();
+
+    /**
+     * @brief retourne le nombre de tags lus
+     *
+     * @return int nombre de tags lus
+     */
+    int getNbTags();
+
+private:
+
+    /**
+     * @brief convertit un nombre en hexadécimal (a 2 chiffres)
+     *
+     * @param number nombre à convertir
+     * @return String nombre converti
+     */
+    String digitify(int number);
+
+    /**
+     * @brief variable pair/impair pour le type de trame
+     *
+     */
+    bool pair;
+
+    /**
+     * @brief dernière trame lue
+     *
+     */
+    std::vector<byte>* trame;
+
+};
+
+
+
+
+#endif

lib/NfcReader/include/TrameList.h

@@ -0,0 +1,29 @@
+#ifndef TRAM_LIST_H
+#define TRAM_LIST_H
+
+#include <Arduino.h>
+#include <vector>
+
+const std::vector<byte> SEARCH_TRAM_0 = {0x05, 0x07, 0x01, 0x01, 0x01, 0x00, 0xEB, 0x5F};
+
+const std::vector<byte> INIT_TRAM_0 = {0xFA, 0x05, 0x01, 0xC0, 0x5A, 0xDF};
+const std::vector<byte> INIT_TRAM_1 = {0xFA, 0x08, 0x01, 0x00, 0x01, 0x01, 0x01, 0xE1, 0x70};
+const std::vector<byte> INIT_TRAM_2 = {0xFA, 0x08, 0x01, 0x40, 0x01, 0x02, 0x01, 0x3E, 0x4C};
+const std::vector<byte> INIT_TRAM_3 = {0xFA, 0x08, 0x01, 0x00, 0x01, 0x03, 0x01, 0x51, 0x43};
+const std::vector<byte> INIT_TRAM_4 = {0xFA, 0x08, 0x01, 0x40, 0x01, 0x04, 0x01, 0xEE, 0x18};
+const std::vector<byte> INIT_TRAM_5 = {0xFA, 0x08, 0x01, 0x00, 0x01, 0x05, 0x01, 0x81, 0x17};
+const std::vector<byte> INIT_TRAM_6 = {0xFA, 0x08, 0x01, 0x40, 0x01, 0x06, 0x01, 0x5E, 0x2B};
+const std::vector<byte> INIT_TRAM_7 = {0xFA, 0x08, 0x01, 0x00, 0x01, 0x07, 0x01, 0x31, 0x24};
+
+const std::vector<byte> REP_TRAM_0 = {0xFA, 0x05, 0x01, 0xE0, 0x58, 0xFE};
+const std::vector<byte> REP_TRAM_1 = {0xFA, 0x17, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x04, 0x00, 0x00, 0x03, 0x01, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x95, 0x8A};
+const std::vector<byte> REP_TRAM_2 = {0xFA, 0x17, 0x01, 0x40, 0x01, 0x00, 0x00, 0x01, 0x00, 0x09, 0x00, 0xFF, 0x00, 0x10, 0x07, 0x13, 0x01, 0x0E, 0x08, 0x09, 0x0B, 0x00, 0x2D, 0x98};
+const std::vector<byte> REP_TRAM_3 = {0xFA, 0x17, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xE8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x43, 0x83, 0x00, 0x00, 0x00, 0x9A, 0xBF};
+const std::vector<byte> REP_TRAM_4 = {0xFA, 0x17, 0x01, 0x40, 0x01, 0x00, 0x00, 0x01, 0x04, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD7, 0x15};
+const std::vector<byte> REP_TRAM_5 = {0xFA, 0x17, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0A, 0x03, 0x0A, 0x00, 0xF6, 0xCD};
+const std::vector<byte> REP_TRAM_6 = {0xFA, 0x17, 0x01, 0x40, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xD4, 0x03};
+const std::vector<byte> REP_TRAM_7 = {0xFA, 0x17, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xF6};
+
+const std::vector<byte> READ_TRAM_0 = {0xFA, 0x24, 0x01, 0x00, 0x31, 0x02, 0x07, 0x0E, 0x00, 0x00, 0x04, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x06, 0x00, 0x03, 0x00, 0xFF, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x5D, 0x74};
+const std::vector<byte> READ_TRAM_1 = {0xFA, 0x24, 0x01, 0x40, 0x31, 0x02, 0x07, 0x0E, 0x00, 0x00, 0x04, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x06, 0x00, 0x03, 0x00, 0xFF, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x10, 0x45};
+#endif

lib/NfcReader/src/BigNfcReader.cpp

@@ -0,0 +1,75 @@
+#include "../include/BigNfcReader.h"
+
+
+BigNfcReader::BigNfcReader(){
+    Serial2.begin(115200, SERIAL_8N1, 16, 17);//TODO: mettre le port série en paramètre
+    this->pair = true;
+    this->trame = new std::vector<byte>();
+}
+
+
+bool BigNfcReader::init(){
+    const std::vector<std::vector<byte>> INIT_TRAMES = {INIT_TRAM_0, INIT_TRAM_1, INIT_TRAM_2, INIT_TRAM_3, INIT_TRAM_4, INIT_TRAM_5, INIT_TRAM_6, INIT_TRAM_7};
+    const std::vector<std::vector<byte>> REP_TRAMES = {REP_TRAM_0, REP_TRAM_1, REP_TRAM_2, REP_TRAM_3, REP_TRAM_4, REP_TRAM_5, REP_TRAM_6, REP_TRAM_7};
+    int repnb = 0;
+    for(std::vector<byte> i: INIT_TRAMES){
+        for(byte j: i){
+            Serial2.write(j);
+        }
+        while (Serial2.available() == 0);
+        while (Serial2.available() > 0){
+            for(byte j: REP_TRAMES[repnb]){
+                if(Serial2.read() != j){
+                    Serial.println("NFC reader init failed");
+                    return false;
+                }
+            }
+        }
+        repnb++;
+    }
+    return true;
+}
+
+void BigNfcReader::refresh(){
+    this->trame->clear();
+    std::vector<byte> trame = READ_TRAM_0;
+    if (this->pair){
+        trame = READ_TRAM_1;
+    }
+    this->pair = !this->pair;
+
+    for(byte i: trame){
+        Serial2.write(i);
+    }
+    while (Serial2.available() == 0);
+    while (Serial2.available() > 0){
+        this->trame->push_back(Serial2.read());
+    }
+}
+
+
+String BigNfcReader::digitify(int number){
+    String sortie = "";
+
+    if(number <= 0xF){
+        sortie += '0';
+        sortie += String(number,HEX);
+    }else{
+        sortie += String(number,HEX);
+    }
+
+    return sortie;
+}
+
+
+void BigNfcReader::printTrame(){
+    for(byte i: *this->trame){
+        Serial.print(this->digitify(i));
+        Serial.print(" ");
+    }
+    Serial.println();
+}
+
+int BigNfcReader::getNbTags(){
+    return this->trame->at(8);
+}

lib/ServoMotorComponent/src/ServoMotorComponent.cpp

@@ -0,0 +1,63 @@
+#include "ServoMotorComponent.h"
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Functions for setting up the ServoMotor
+/////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Constructor.
+ * Prepares the ServoMotor.
+ */
+ServoMotorComponent::ServoMotorComponent(int PIN,  unsigned long updatePeriod, float step) {
+    this->PIN = PIN;
+    this->myservo.attach(PIN);
+    this->desiredposition = Position::MIDDLE;
+    this->currentPosition = MIDDLE_POS;
+    this->lastUpTime = millis();
+    this->updatePeriod = updatePeriod;
+    this->step = step;
+    this->myservo.write(this->PIN, this->currentPosition);
+}
+
+/**
+ * Set the desired position
+ * @desiredPosition: Give desired position
+ */
+void ServoMotorComponent::setDesiredPosition(Position desiredPosition) {
+    switch (desiredPosition) {
+        case Position::LEFT:
+            this->desiredposition = LEFT_POS;
+            break;
+        case Position::MIDDLE:
+            this->desiredposition = MIDDLE_POS;
+            break;
+        case Position::RIGHT:
+            this->desiredposition = RIGHT_POS;
+            break;
+        default:
+            break;
+    }
+}
+
+
+/**
+ * Write a new servoMotor position when it's necessary
+ */
+void ServoMotorComponent::refresh() {
+    if (this->desiredposition == this->currentPosition 
+    ||  millis() - this->lastUpTime <= this->updatePeriod) return;
+
+    if (this->currentPosition > this->desiredposition) {
+        this->currentPosition -= this->step;
+    }
+    if (this->currentPosition < this->desiredposition) {
+        this->currentPosition += this->step;
+    }
+    this->lastUpTime = millis();
+    this->myservo.write(this->PIN, this->currentPosition);
+}
+
+bool ServoMotorComponent::isConnected() {
+    return true;
+}

lib/ServoMotorComponent/src/ServoMotorComponent.h

@@ -0,0 +1,34 @@
+#ifndef SERVOMOTOT_COMPONENT_H
+#define SERVOMOTOT_COMPONENT_H
+
+#include <Servo.h>
+
+enum Position {
+    LEFT,
+    MIDDLE,
+    RIGHT
+};
+
+class ServoMotorComponent
+{
+public:
+    ServoMotorComponent(int PIN, unsigned long updatePeriod = 100, float step = 0.1);
+    void setDesiredPosition(Position desiredPosition);
+    bool isConnected();
+    void refresh();
+
+private:
+    int PIN;
+    float currentPosition;
+    float desiredposition;
+    Servo myservo;
+    unsigned long lastUpTime;
+    unsigned long updatePeriod;
+    float step;
+};
+
+
+
+
+
+#endif //SERVOMOTOT_COMPONENT_H

lib/WorldTime/src/WorldTime.cpp

@@ -0,0 +1 @@
+#include "WorldTime.h"

lib/WorldTime/src/WorldTime.h

@@ -0,0 +1,6 @@
+#ifndef T_IOT_901_CONVOYOR_WORLDTIME_H
+#define T_IOT_901_CONVOYOR_WORLDTIME_H
+
+
+
+#endif //T_IOT_901_CONVOYOR_WORLDTIME_H

platformio.ini

@@ -55,6 +55,7 @@ lib_deps =
     m5stack/M5Stack@^0.4.5 ; M5 Lib
     m5stack/M5GFX@^0.1.9 ; M5 Lib pour le LCD
     m5stack/Module_GRBL_13.2@^0.0.3 ; M5 Lib pour Stepper (GRBL)
+    dlloydev/ESP32 ESP32S2 AnalogWrite ; Lib pour le Servo Motor
 ;    example:
 ;    erropix/ESP32 AnalogWrite@0.2
 

src/Program.cpp

@@ -1,29 +1,175 @@
 #include "Program.h"
 #include "Arduino.h"
+#include "M5LCD.h"
 #include "DolibarrClient.h"
+#include "ServoMotorComponent.h"
+#include "NfcReader.h"
+#include <Ticker.h>
+
+uint32_t derniereExecution = 0;
+const uint32_t intervalle = 1000;
+std::vector<models::Warehouse> *warehouses;
 
 int initialize_wifi(WifiConfig wifi) {
+    lcdScreen->add_log("Connecting to the WiFi network...");
     WiFiClass::mode(WIFI_STA); //Optional
     WiFi.setSleep(false);
     WiFi.begin(wifi.ssid, wifi.password);
-    Serial.print("Connecting ");
-    while(WiFiClass::status() != WL_CONNECTED){
-        delay(WAITING_WIFI_DELAY);
-        Serial.print(".");
-    }
-    Serial.println("Connected to the WiFi network");
     return 0;
 }
 
+void Program::checkNfc() {
+    if (this->nfcReader->IsNfcConnected() && lcdScreen->get_components().nfc != COMPONENT_OK) {
+        lcdScreen->set_nfc_status(COMPONENT_OK);
+        lcdScreen->add_log("NFC component connected !");
+        Serial.println("NFC IS CONNECTED !");
+    } else if (!this->nfcReader->IsNfcConnected() && lcdScreen->get_components().nfc == COMPONENT_OK) {
+        lcdScreen->set_nfc_status(COMPONENT_KO);
+        lcdScreen->add_log("NFC component disconnected !");
+        Serial.println("NFC NOT CONNECTED !");
+    }
+}
+
+void Program::checkServo() {
+    if (this->servo->isConnected() && lcdScreen->get_components().servo != COMPONENT_OK) {
+        lcdScreen->set_servo(COMPONENT_OK);
+        lcdScreen->add_log("SERVO component connected !");
+        Serial.println("SERVO IS CONNECTED !");
+    } else if (!this->servo->isConnected() && lcdScreen->get_components().servo == COMPONENT_OK) {
+        lcdScreen->set_servo(COMPONENT_KO);
+        lcdScreen->add_log("SERVO component disconnected !");
+        Serial.println("SERVO NOT CONNECTED !");
+    }
+}
+
+void Program::checkWifi() {
+    if (WiFiClass::status() == WL_CONNECTED && lcdScreen->get_components().wifi != COMPONENT_OK) {
+        lcdScreen->add_log("Connected to the WiFi network");
+        lcdScreen->set_wifi_status(COMPONENT_OK);
+        struct DolibarrConfig dolibarr = {DOLIBARR_URL, DOLIBARR_API_TOKEN};
+        this->client = new DolibarrClient(dolibarr);
+        warehouses = this->client->list_warehouse();
+        if (warehouses != nullptr) {
+            lcdScreen->add_log("Warehouses found !");
+            lcdScreen->set_dolibarr_status(COMPONENT_OK);
+            for (auto &ware : *warehouses) {
+                char buffer[50];
+                sprintf(buffer, "+ Warehouse '%s' (%s)", ware.label.c_str(), ware.id.c_str());
+                lcdScreen->add_log(buffer);
+            }
+        } else {
+            lcdScreen->add_log("Warehouse not found");
+            lcdScreen->set_dolibarr_status(COMPONENT_KO);
+        }
+    } else if (WiFiClass::status() != WL_CONNECTED && lcdScreen->get_components().wifi == COMPONENT_OK) {
+        lcdScreen->add_log("Wifi signal lost, reconnecting...");
+        lcdScreen->set_wifi_status(COMPONENT_KO);
+        lcdScreen->set_dolibarr_status(COMPONENT_KO);
+        struct WifiConfig wifi_c = {WIFI_SSID, WIFI_PASSWORD};
+        initialize_wifi(wifi_c);
+    }
+}
+
 Program::Program() {
     Serial.begin(MONITOR_SPEED);
+    Wire.begin();
+    delay(1000);
+    lcdScreen = new M5LCD();
+    lcdScreen->add_log("Initialize M5LCD component....");
+    this->nfcReader = new NfcReader(NFC_ADDR);
+    this->servo = new ServoMotorComponent(2, 1, 1);
+    this->servo->setDesiredPosition(Position::MIDDLE);
+    this->grbl = new GRBL(STEPMOTOR_I2C_ADDR);
+    this->outputReader = new BigNfcReader();
+    this->outputReader->init();
+    this->grblUpdateTime = 0;
+    lcdScreen->set_grbl_status(COMPONENT_OK);
+    Wire.begin(21, 22);
+    grbl->init(STEPER_SPEED, STEPER_PAS, STEPER_ACC);
     struct WifiConfig wifi_c = {WIFI_SSID, WIFI_PASSWORD};
-    struct DolibarrConfig dolibarr = {DOLIBARR_URL, DOLIBARR_API_TOKEN};
     initialize_wifi(wifi_c);
-    this->client = new DolibarrClient(dolibarr);
 }
 
 void Program::loop() {
+    lcdScreen->update();
+
+    uint32_t maintenant = millis();
+    if (maintenant - derniereExecution >= intervalle) {
+        this->checkServo();
+        this->checkNfc();
+        this->checkWifi();
+        derniereExecution = maintenant;
+    }
+    this->servo->refresh();
+    this->outputReader->refresh();
+    // Serial.println(this->outputReader->getNbTags());
+
+    if(this->outputReader->getNbTags() >= 2){
+        lcdScreen->set_nfc_message("To mutch colis number detected");
+        lcdScreen->set_grbl_status(COMPONENT_KO);
+    }
+
+    String nfcId = this->nfcReader->ReadNfc();
+    //si qqc
+    if(nfcId != "0"){
+        if (lcdScreen->get_components().wifi != COMPONENT_OK) {
+            lcdScreen->add_log("Wifi not connected !");
+            lcdScreen->set_nfc_message("Cannot send wifi request !");
+            return;
+        }
+        //j'arrète le stepper
+        //this->grbl->stop(); //FIXME: implemente
+        //j'affiche le tag lue
+        Serial.print("new colis in comming : ");
+        lcdScreen->add_log("new colis detected: ");
+        lcdScreen->add_log(nfcId.c_str());
+        lcdScreen->set_nfc_message(nfcId.c_str());
+        auto product = this->client->get_product_by_factory_id(nfcId.c_str());
+        Serial.printf("Product: %s\n%s", product.label.c_str(), product.accountancy_code_sell_export.c_str());
+        lcdScreen->set_product_label(product.label);
+        lcdScreen->set_product_id(product.id);
+        /*if (product.fk_default_warehouse == product.accountancy_code_sell_export) {
+            Serial.printf("Product already in the good warehouse !\n");
+            return;
+        }*/
+        auto ware = std::find_if(warehouses->begin(), warehouses->end(), [&product](models::Warehouse w) {return w.id == product.accountancy_code_sell_export;});
+        if (ware.base() == nullptr) {
+            Serial.printf("Warehouse not found !\n");
+            return;
+        }
+        Serial.printf("Product need to go to warehouse %s\n", ware->label.c_str());
+        this->client->create_movement(models::CreateProductStock{
+                    product.id,
+                    product.fk_default_warehouse,
+                    "-1"
+        });
+        if (this->client->create_movement(models::CreateProductStock{
+                product.id,
+                ware->id,
+                "1"
+            }) == 0) {
+            Serial.printf("Movement created !\n");
+        } else {
+            Serial.printf("Movement cannot be created !\n");
+        }
+        if (ware->id == "1") {
+            this->servo->setDesiredPosition(Position::RIGHT);
+            lcdScreen->set_servo_message("RIGHT");
+        } else if (ware->id == "2") {
+            this->servo->setDesiredPosition(Position::LEFT);
+            lcdScreen->set_servo_message("LEFT");
+        } else if (ware->id == "3") {
+            this->servo->setDesiredPosition(Position::MIDDLE);
+            lcdScreen->set_servo_message("MIDDLE");
+        }
+        this->grbl->mouveForward(CONVOYER_LEN);
+    } else {
+        if((this->grbl->isIddle() || (maintenant - this->grblUpdateTime >= GRBL_UPDATE)) && lcdScreen->get_components().grbl == COMPONENT_OK){
+            this->grblUpdateTime = maintenant;
+            this->grbl->mouveForward(5);
+        }
+    }
+    if(M5.BtnC.wasReleased() != 0 && lcdScreen->_current_page == DASHBOARD_SCREEN){
+        lcdScreen->set_grbl_status(COMPONENT_OK);
+    }
 }
-
-