374 lines
9.1 KiB
C++
374 lines
9.1 KiB
C++
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#undef timeout
|
|
#include "mqtt/async_client.h"
|
|
|
|
#include <nlohmann/json.hpp>
|
|
using json = nlohmann::json;
|
|
|
|
/* From Arduino.h */
|
|
|
|
#define HIGH 0x1
|
|
#define LOW 0x00
|
|
|
|
#define IO_INPUT 0x02
|
|
#define IO_OUTPUT 0x04
|
|
|
|
#define DIGITAL 0x08
|
|
#define ANALOG 0x10
|
|
|
|
#define PI 3.1415926535897932384626433832795
|
|
#define HALF_PI 1.5707963267948966192313216916398
|
|
|
|
#define true 1
|
|
#define false 0
|
|
|
|
// Temps
|
|
|
|
// Timestamp unix en millisecondes
|
|
// t_start : timestamp de départ
|
|
// t_backup : timestamp de la précédente itération
|
|
// t_elapsed : temps écoulé en secondes depuis le départ
|
|
// dt (delta t) : temps écoulé en secondes depuis la dernière itération
|
|
unsigned long t_start, t_backup;
|
|
double t_elapsed, dt;
|
|
|
|
unsigned long millis()
|
|
{
|
|
struct timespec now;
|
|
clock_gettime(CLOCK_REALTIME, &now);
|
|
return ((unsigned long)now.tv_sec) * 1000 + ((unsigned long)now.tv_nsec) / 1000000;
|
|
}
|
|
|
|
#define OP_DIGITAL_READ 0
|
|
#define OP_DIGITAL_WRITE 1
|
|
#define OP_ANALOG_READ 2
|
|
#define OP_ANALOG_WRITE 3
|
|
#define OP_PIN_MODE 4
|
|
|
|
|
|
int b0, b1, b2, b3, b4, b5, b6, b7;
|
|
int s0, s1, s2, s3, s4, s5, s6, s7;
|
|
|
|
/* ********************************************************
|
|
* MQTT *
|
|
* *
|
|
******************************************************** */
|
|
|
|
/* Configuration MQTT */
|
|
const std::string ADDRESS = "tcp://rabbitmq:1883";
|
|
const std::string CLIENTID = "CppClientTP";
|
|
const std::string TOPIC = "geii/in/#";
|
|
const int QOS = 1;
|
|
const int CYCLE_MS = 100;
|
|
|
|
mqtt::async_client client(ADDRESS, CLIENTID);
|
|
|
|
void mqtt_process(mqtt::async_client* client)
|
|
{
|
|
json obj = {
|
|
{"s0", s0 },
|
|
{"s1", s1 },
|
|
{"s2", s2 },
|
|
{"s3", s3 },
|
|
{"s4", s4 },
|
|
{"s5", s5 },
|
|
{"s6", s6 },
|
|
{"s7", s7 },
|
|
};
|
|
|
|
std::string payload = obj.dump();
|
|
auto msg = mqtt::make_message("geii/out", payload);
|
|
msg->set_qos(1);
|
|
client->publish(msg);
|
|
|
|
usleep(100000);
|
|
}
|
|
|
|
|
|
// Réception des messages MQTT
|
|
// ************************************************************
|
|
class callback : public virtual mqtt::callback {
|
|
public:
|
|
void message_arrived(mqtt::const_message_ptr msg) override {
|
|
std::string payload = msg->to_string();
|
|
|
|
try {
|
|
json j = json::parse(payload);
|
|
|
|
// Ne rien faire si l'objet JSON est vide
|
|
if (j.empty()) return;
|
|
|
|
if (j.contains("b0")) b0 = j["b0"].get<int>() != 0;
|
|
if (j.contains("b1")) b1 = j["b1"].get<int>() != 0;
|
|
if (j.contains("b2")) b2 = j["b2"].get<int>() != 0;
|
|
if (j.contains("b3")) b3 = j["b3"].get<int>() != 0;
|
|
if (j.contains("b4")) b4 = j["b4"].get<int>() != 0;
|
|
if (j.contains("b5")) b5 = j["b5"].get<int>() != 0;
|
|
if (j.contains("b6")) b6 = j["b6"].get<int>() != 0;
|
|
if (j.contains("b7")) b7 = j["b7"].get<int>() != 0;
|
|
|
|
std::cout << "Pompes : " << b0 << " " << b1 << " " << b2 << " " << b3 << " " << b4 << " " << b5 << " " << b6 << " " << b7 << std::endl;
|
|
}
|
|
catch (const json::parse_error& e) {
|
|
std::cerr << "Erreur JSON : " << e.what() << "\n";
|
|
}
|
|
}
|
|
};
|
|
|
|
void mqtt_open(mqtt::async_client* client) {
|
|
mqtt::connect_options connOpts;
|
|
connOpts.set_clean_session(true);
|
|
connOpts.set_user_name("admin");
|
|
connOpts.set_password("geii2025");
|
|
try {
|
|
client->connect(connOpts)->wait();
|
|
client->start_consuming();
|
|
client->subscribe(TOPIC, QOS)->wait();
|
|
} catch (const mqtt::exception &exc) {
|
|
std::cerr << "Erreur MQTT: " << exc.what() << "\n";
|
|
}
|
|
|
|
}
|
|
|
|
void mqtt_close() {
|
|
try {
|
|
client.unsubscribe(TOPIC)->wait();
|
|
client.stop_consuming();
|
|
client.disconnect()->wait();
|
|
} catch(const mqtt::exception &exc){
|
|
std::cerr << "Erreur déconnexion MQTT: " << exc.what() << std::endl;
|
|
}
|
|
}
|
|
// ************************************************************
|
|
|
|
|
|
/* ********************************************************
|
|
* TEMPORISATION RETARD A LA MONTEE *
|
|
* La sortie passe à 1 au bout de la tempo *
|
|
******************************************************** */
|
|
|
|
class TemporisationRetardMontee
|
|
{
|
|
// methodes
|
|
public :
|
|
// Contructeur qui prend la duree souhaitee de la temporisation
|
|
TemporisationRetardMontee(unsigned long duree)
|
|
{
|
|
this->duree = duree;
|
|
sortie = false;
|
|
captureTemps = false;
|
|
}
|
|
// Activation de la temporisation. Doit etre fait tout le temps de la duree de la tempo
|
|
void activation()
|
|
{
|
|
// Capture du temps de reference
|
|
if(!captureTemps)
|
|
{
|
|
debut = millis();
|
|
captureTemps = true;
|
|
}
|
|
// Calcul du temps ecoule depuis le temps de reference
|
|
tempsEcoule = millis() - debut;
|
|
// Mise a 1 de la fin de tempo
|
|
if (tempsEcoule >= duree)
|
|
{
|
|
sortie = true;
|
|
captureTemps = false;
|
|
}
|
|
else
|
|
{
|
|
sortie = false;
|
|
}
|
|
}
|
|
// Precharge de la temporisation
|
|
void setDuree(unsigned long majduree)
|
|
{
|
|
duree = majduree;
|
|
sortie = false;
|
|
captureTemps = false;
|
|
}
|
|
// Interrogation du bit de fin de tempo
|
|
bool getSortie()
|
|
{
|
|
return(sortie);
|
|
}
|
|
// Recuperation du temps ecoule depuis le debut si necessaire
|
|
unsigned long getTempsEcoule()
|
|
{
|
|
return(tempsEcoule);
|
|
}
|
|
|
|
// Attributs
|
|
private:
|
|
unsigned long duree;
|
|
unsigned long debut;
|
|
unsigned long tempsEcoule;
|
|
bool captureTemps;
|
|
bool sortie;
|
|
};
|
|
|
|
/********************************************************
|
|
* TEMPORISATION RETARD A LA DESCENTE *
|
|
* La sortie passe à 0 au bout de la tempo *
|
|
*********************************************************/
|
|
class TemporisationRetardDescente
|
|
{
|
|
public :
|
|
// Contructeur qui prend la duree souhaitee de la temporisation
|
|
TemporisationRetardDescente(unsigned long duree)
|
|
{
|
|
this->duree = duree;
|
|
sortie = false;
|
|
captureTemps = false;
|
|
}
|
|
// Activation de la temporisation. Doit etre fait tout le temps de la duree de la tempo
|
|
void activation()
|
|
{
|
|
// Capture du temps de reference
|
|
if(!captureTemps)
|
|
{
|
|
debut = millis();
|
|
captureTemps = true;
|
|
sortie = true;
|
|
}
|
|
// Calcul du temps ecoule depuis le temps de reference
|
|
tempsEcoule = millis() - debut;
|
|
// Mise a 0 de la fin de tempo
|
|
if (tempsEcoule >= duree)
|
|
{
|
|
sortie = false;
|
|
captureTemps = false;
|
|
}
|
|
}
|
|
// Precharge de la temporisation
|
|
void setDuree(unsigned long majduree)
|
|
{
|
|
duree = majduree;
|
|
sortie = false;
|
|
captureTemps = false;
|
|
}
|
|
// Interrogration du bit de fin de tempo
|
|
bool getSortie()
|
|
{
|
|
return(sortie);
|
|
}
|
|
// Recuperation du temps ecoule depuis le debut si necessaire
|
|
unsigned long getTempsEcoule()
|
|
{
|
|
return(tempsEcoule);
|
|
}
|
|
|
|
private:
|
|
unsigned long duree;
|
|
unsigned long debut;
|
|
unsigned long tempsEcoule;
|
|
bool captureTemps;
|
|
bool sortie;
|
|
};
|
|
|
|
/********************************************************
|
|
**** CLIGNOTEUR *************************************
|
|
*********************************************************/
|
|
class Clignoteur
|
|
{
|
|
// methodes
|
|
public :
|
|
// Construteur qui prend en parametre le temps haut ou bas souhaitee
|
|
Clignoteur(int baseDeTemps)
|
|
{
|
|
this->baseDeTemps = baseDeTemps;
|
|
}
|
|
// Fonction qui renvoie true si le clignoteur est ├á l'├®tat haut et false s'il est ├á l'├®tat bas
|
|
bool statut()
|
|
{
|
|
return ((millis() / baseDeTemps) % 2 == 1);
|
|
}
|
|
|
|
// Attributs
|
|
private:
|
|
int baseDeTemps;
|
|
};
|
|
|
|
/********************************************************
|
|
**** COMPTEUR *************************************
|
|
**** ATTENTION : Il faut gerer le front montant dans le programme
|
|
*********************************************************/
|
|
class Compteur
|
|
{
|
|
// methodes
|
|
public :
|
|
// Constructeur qui prend en parametre la valeur de preselection
|
|
Compteur(int valeurPreselection)
|
|
{
|
|
this->valeurPreselection = valeurPreselection;
|
|
valeur = 0;
|
|
}
|
|
// Incrementation du compteur
|
|
void incrementer()
|
|
{
|
|
valeur++;
|
|
}
|
|
// Decrementation du compteur
|
|
void decrementer()
|
|
{
|
|
valeur--;
|
|
}
|
|
// remise a zero du compteur
|
|
void remettreAZero()
|
|
{
|
|
valeur = 0;
|
|
}
|
|
// recuperation de la valeur courante
|
|
int getValeurCourante()
|
|
{
|
|
return(valeur);
|
|
}
|
|
// est-ce que la preselection est atteinte (sortie Q compteur Siemens ou Schnieder)
|
|
bool getSortie()
|
|
{
|
|
return(valeur == valeurPreselection);
|
|
}
|
|
|
|
// Attributs
|
|
private:
|
|
int valeur;
|
|
int valeurPreselection;
|
|
};
|
|
|
|
/********************************************************
|
|
**** MISE A L'ECHELLE DE VALEUR ************************
|
|
*********************************************************/
|
|
class MiseAEchelle
|
|
{
|
|
public :
|
|
// Constructeur qui ne prend en parametre la plage d'entree et la plage de sortie
|
|
MiseAEchelle(float minEntree,float maxEntree,float minSortie,float maxSortie)
|
|
{
|
|
this->minEntree = minEntree;
|
|
this->maxEntree = maxEntree;
|
|
this->minSortie = minSortie;
|
|
this->maxSortie = maxSortie;
|
|
}
|
|
// fonction de conversion qui prend la valeur a convertir et renvoie la valeur convertie
|
|
float convertir(float valeurAConvertir)
|
|
{
|
|
if(valeurAConvertir >= minEntree && valeurAConvertir <= maxEntree)
|
|
{
|
|
float norm = (1 / (maxEntree - minEntree)) * (valeurAConvertir - minEntree);
|
|
float scale = (maxSortie - minSortie) * norm + minSortie;
|
|
return(scale);
|
|
}
|
|
return(-1000);
|
|
}
|
|
|
|
// Attributs
|
|
private:
|
|
float minEntree;
|
|
float minSortie;
|
|
float maxEntree;
|
|
float maxSortie;
|
|
};
|