initial commit

autom.cpp

@@ -0,0 +1,496 @@
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+
+#undef timeout
+#include "mqtt/async_client.h"
+
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;
+
+#include <csignal>
+
+/* 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
+
+/* Configuration MQTT */
+const std::string ADDRESS = "tcp://rabbitmq:1883";
+const std::string CLIENTID = "CppClientTP";
+const std::string TOPIC = "geii/in/#";
+const int QOS = 1;
+
+int s0, s1;
+
+// 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
+
+typedef struct PinIO
+{
+  unsigned char mode;
+  int ivalue;
+  double dvalue;
+  int error; // % = 1 /error ex 1 / 20 = 5 %
+  double efficacite; // 0 - 100%
+  unsigned long start;
+  unsigned long time;
+  double duration;
+  unsigned int nb; // compteur d'activation
+  int memory;
+  unsigned char raising;
+  unsigned char falling;
+} PinIO;
+
+PinIO _digital[256];
+
+void pinMode(unsigned char p, unsigned char mode)
+{
+  _digital[p].mode = 0x01 | mode;
+
+  _digital[p].ivalue = 0;
+  _digital[p].dvalue = 0.0;
+
+  _digital[p].nb = 0;
+  _digital[p].time = 0.0;
+  _digital[p].duration = 0.0;
+  _digital[p].start = 0;
+  _digital[p].raising = 0;
+  _digital[p].memory = 0;
+}
+
+// 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();
+
+		std::cout << "MQTT IN : ";
+
+		try
+		{
+			json j = json::parse(payload);
+
+			// Ne rien faire si l'objet JSON est vide
+			if (j.empty())
+				return;
+
+			if (j.contains("b0"))
+				s0 = j["b0"].get<int>() != 0;
+
+			std::cout << "boutons : " << s0 << std::endl;
+		}
+		catch (const json::parse_error &e)
+		{
+			std::cerr << "Erreur JSON : " << e.what() << "\n";
+		}
+	}
+};
+// ************************************************************
+
+mqtt::async_client client(ADDRESS, CLIENTID);
+
+void open() {
+
+	callback cb;
+	client.set_callback(cb);
+
+	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";
+		return;
+	}
+}
+
+void 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;
+	}
+
+	std::cout << "Fin du programme" << std::endl;
+}
+
+void send()
+{
+	json obj = {
+			{"s0", s0},
+			{"s1", s1},
+			{"s2", 0},
+			{"s3", 1},
+			{"s4", 1},
+	};
+
+	std::string payload = obj.dump();
+	auto msg = mqtt::make_message("geii/out", payload);
+	msg->set_qos(0);
+	client.publish(msg);
+
+	std::cout << s0 << std::endl;
+
+	usleep(100000);
+}
+
+
+/* ********************************************************
+ *  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;
+};
+
+/* READ */
+
+int digitalRead(int p)
+{
+  return ((_digital[p].mode & IO_INPUT) && (_digital[p].mode & DIGITAL) && (_digital[p].mode & 0x01)) ? _digital[p].ivalue : 0;
+}
+
+double analogRead(int p)
+{
+  return ((_digital[p].mode & IO_INPUT) && (_digital[p].mode & ANALOG) && (_digital[p].mode & 0x01)) ? _digital[p].dvalue : 0.0;
+}
+
+/* WRITE */
+
+void digitalWrite(unsigned int p, int value)
+{
+  if (p > 255)
+  {
+    printf("Pin %d is out of Range.", p);
+    return;
+  }
+
+  // En panne !
+  if (!(_digital[p].mode & 0x01))
+  {
+    return;
+  }
+
+  if (!(_digital[p].mode & IO_OUTPUT && _digital[p].mode & DIGITAL))
+  {
+    printf("Pin %d is not a digital input.", p);
+    return;
+  }
+
+  unsigned long m = millis();
+
+  if (value != _digital[p].ivalue)
+  {
+    _digital[p].time = _digital[p].time > 5000 ? 0 : 5000 - _digital[p].time;
+  }
+  else
+  {
+    _digital[p].time += m - _digital[p].start;
+  }
+
+  if (value && !_digital[p].ivalue)
+  {
+    _digital[p].start = m;
+    _digital[p].nb += 1;
+  }
+  else if (value)
+  {
+    _digital[p].duration += dt;
+  }
+
+  _digital[p].raising = (_digital[p].memory < _digital[p].ivalue);
+  _digital[p].falling = (_digital[p].memory > _digital[p].ivalue);
+  _digital[p].memory = _digital[p].ivalue;
+  _digital[p].ivalue = value;
+}
+
+void analogWrite(unsigned int p, double value)
+{
+  if (p > 31)
+  {
+    printf("Pin %d is out of Range.", p);
+    return;
+  }
+
+  // En panne
+  if (!(_digital[p].mode & 0x01))
+  {
+    return;
+  }
+
+  if (!(_digital[p].mode & IO_OUTPUT) || !(_digital[p].mode & ANALOG))
+  {
+    printf("Pin %d is not a analog input.", p);
+    return;
+  }
+
+  _digital[p].dvalue = value;
+}