Epitech/T-IOT-901_convoyor
4
0
Fork 0
Code Issues 4 Pull Requests Packages Projects 1 Releases Wiki Activity

Merge pull request 'feat/m5_lcd' (#19) from feat/m5_lcd into develop

Browse Source 
Reviewed-on: #19
This commit is contained in:
Nicolas 2024-01-26 09:40:59 +01:00
commit 68a4ab9755
15 changed files with 563 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
config.ini
View File

@ -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 ;;;
;;;;;;;;;;;;;;;;;;;;;;
@ -23,12 +23,17 @@ build_flags =
;-D STEPER_PAS=755.906 ; = 65mm
-D STEPER_PAS=58 ; = 5mm
-D STEPER_SPEED=1000 ; 12000
;;;;;;;;;;;;;;;;;;;;;;
;;; App config ;;;
;;;;;;;;;;;;;;;;;;;;;;
-D APP_TITLE=\"Warehouse\"
-D APP_VERSION=\"1.0\"
; nfc addr
-D NFC_ADDR=0x28
;;;;;;;;;;;;;;;;;;;;;;
;;; Servo config ;;;
;;;;;;;;;;;;;;;;;;;;;;
-D RIGHT_POS=18
-D MIDDLE_POS=32
-D LEFT_POS=52
-D CONVOYER_LEN=100

3
config_api.ini
View File

@ -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

7
include/Program.h
View File

@ -5,6 +5,8 @@
#include "DolibarrClient.h"
#include <M5Stack.h>
#include "ServoMotorComponent.h"
#include "NfcReader.h"
#include "GRBL.h"
class Program {
public:
@ -17,9 +19,14 @@ public:
* Program WarehouseGUI loop
*/
void loop();
void checkNfc();
void checkServo();
void checkWifi();
private:
DolibarrClient *client;
ServoMotorComponent *servo;
NfcReader *nfcReader;
GRBL *grbl;
};
#endif

90
lib/DolibarrClient/src/DolibarrClient.cpp
View File

@ -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 {
HTTPClient *client = this->build_url(replace_id(API_GET_PRODUCT_URL, id_product).c_str());
models::Product DolibarrClient::get_product_by_factory_id(const char* factory_id) const {
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->id = doc["id"];
product->entity = doc["entity"];
product->stock_reel = doc["stock_reel"];
product->label = doc["label"];
product->date_creation = doc["date_creation"].as<std::string>();
product->id = doc["id"].as<std::string>();
product->entity = doc["entity"].as<std::string>();
product->stock_reel = doc["stock_reel"].as<std::string>();
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 {
HTTPClient *client = this->build_url("API_CREATE_STOCKS_MOVEMENTS_URL");
StaticJsonDocument<API_MAX_JSON_SIZE> doc;
int DolibarrClient::create_movement(models::CreateProductStock stock) const {
HTTPClient *client = this->build_url(API_CREATE_STOCKS_MOVEMENTS_URL);
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;
}

3
lib/DolibarrClient/src/DolibarrClient.h
View File

@ -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;

44
lib/DolibarrClient/src/DolibarrModels.h
View File

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

224
lib/M5LCD/src/M5LCD.cpp Normal file
View File

@ -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;
}

84
lib/M5LCD/src/M5LCD.h Normal file
View File

@ -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);
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 _current_page;
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

7
lib/NFC/src/NfcReader.cpp
View File

@ -22,4 +22,11 @@ String NfcReader::ReadNfc()
}
}
return (this->uid);
}
bool NfcReader::IsNfcConnected()
{
Wire.beginTransmission(NFC_ADDR);
byte error = Wire.endTransmission();
return error == 0;
}

1
lib/NFC/src/NfcReader.h
View File

@ -9,6 +9,7 @@ class NfcReader {
public:
NfcReader(int i2c_adress);
~NfcReader() = default;
bool IsNfcConnected();
String ReadNfc();

4
lib/ServoMotorComponent/src/ServoMotorComponent.cpp
View File

@ -56,4 +56,8 @@ void ServoMotorComponent::refresh() {
}
this->lastUpTime = millis();
this->myservo.write(this->PIN, this->currentPosition);
}
bool ServoMotorComponent::isConnected() {
return true;
}

3
lib/ServoMotorComponent/src/ServoMotorComponent.h
View File

@ -12,8 +12,9 @@ enum Position {
class ServoMotorComponent
{
public:
ServoMotorComponent(int PIN, unsigned long updatePeriod, float step = 1);
ServoMotorComponent(int PIN, unsigned long updatePeriod = 100, float step = 0.1);
void setDesiredPosition(Position desiredPosition);
bool isConnected();
void refresh();
private:

1
lib/WorldTime/src/WorldTime.cpp Normal file
View File

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

6
lib/WorldTime/src/WorldTime.h Normal file
View File

@ -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

153
src/Program.cpp
View File

@ -1,33 +1,160 @@
#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);
this->servo = new ServoMotorComponent(2, 1, 0.1);
//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);
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->grbl = new GRBL(STEPMOTOR_I2C_ADDR);
Wire.begin(21, 22);
grbl->init(STEPER_SPEED, STEPER_PAS, STEPER_ACC);
struct WifiConfig wifi_c = {WIFI_SSID, WIFI_PASSWORD};
initialize_wifi(wifi_c);
}
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->servo->setDesiredPosition(Position::LEFT);
}
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 {
//si rien
//je check si le stepper est en iddle
//this->grbl->mouveForward(5);
}
}