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

Ajout de l'algo

Browse Source
This commit is contained in:
Nicolas SANS 2024-01-25 14:29:08 +01:00
parent 2c22e0a538
commit 45cef130ca
15 changed files with 270 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
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 ;;;
;;;;;;;;;;;;;;;;;;;;;;
@ -36,3 +36,4 @@ build_flags =
-D RIGHT_POS=18
-D MIDDLE_POS=32
-D LEFT_POS=52
-D CONVOYER_LEN=100

1
config_api.ini
View File

@ -4,6 +4,7 @@ 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/\"

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

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

@ -59,23 +59,54 @@ std::vector<models::Product> *DolibarrClient::list_products() const {
return nullptr;
}
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) {
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) {
//Serial.println("ERROR: ");
//Serial.println(error.c_str());
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;
}
@ -108,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);
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) {

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;

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

@ -4,19 +4,22 @@
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 {
@ -26,9 +29,9 @@ namespace models {
};
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 {

64
lib/M5LCD/src/M5LCD.cpp
View File

@ -5,6 +5,11 @@
*/
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);
@ -83,21 +88,27 @@ void M5LCD::show_dashboard() const {
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, 80, 320, 70, BLUE);
M5.Lcd.drawRect(0, 120, 320, 100, BLUE);
//M5.Lcd.fillRect(180, 30, 122, 10, BLUE);
/*M5.Lcd.setTextColor(WHITE, BLACK);
M5.Lcd.setTextSize(1);
M5.Lcd.setCursor(0, 0);
M5.Lcd.println("T-IOT 901");
M5.Lcd.setCursor(0, 20);
M5.Lcd.println("Convoyeur");
M5.Lcd.setCursor(0, 40);
M5.Lcd.println("Version 1.0");
M5.Lcd.setCursor(0, 60);
M5.Lcd.println("By T-IOT");*/
M5.Lcd.setTextSize(1);
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);
}
@ -166,6 +177,33 @@ void M5LCD::update_dashboard() const {
}
}
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
*/

11
lib/M5LCD/src/M5LCD.h
View File

@ -54,6 +54,12 @@ public:
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;
@ -66,6 +72,11 @@ private:
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;

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

130
src/Program.cpp
View File

@ -3,6 +3,12 @@
#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...");
@ -12,32 +18,43 @@ int initialize_wifi(WifiConfig wifi) {
return 0;
}
Program::Program() {
Serial.begin(MONITOR_SPEED);
this->servo = new ServoMotorComponent(2, 1, 0.1);
lcdScreen = new M5LCD();
lcdScreen->add_log("Initialize M5LCD component....");
struct WifiConfig wifi_c = {WIFI_SSID, WIFI_PASSWORD};
initialize_wifi(wifi_c);
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::loop() {
lcdScreen->update();
this->servo->refresh();
this->servo->setDesiredPosition(Position::LEFT);
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);
auto *warehouses = this->client->list_warehouse();
warehouses = this->client->list_warehouse();
if (warehouses != nullptr) {
lcdScreen->add_log("Warehouses found !");
lcdScreen->set_dolibarr_status(COMPONENT_OK);
for (auto &a : *warehouses) {
for (auto &ware : *warehouses) {
char buffer[50];
sprintf(buffer, "+ Warehouse '%s' (%s)", a.label.c_str(), a.id.c_str());
sprintf(buffer, "+ Warehouse '%s' (%s)", ware.label.c_str(), ware.id.c_str());
lcdScreen->add_log(buffer);
}
} else {
@ -47,9 +64,92 @@ void Program::loop() {
} 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->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();
String nfcId = this->nfcReader->ReadNfc();
//si qqc
if(nfcId != "0"){
//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);
}
}