fix: streamline Kobuki communication startup and reconnection logic

.gitignore

@@ -13,7 +13,7 @@ src/Socket/a.out
 src/C++/Driver/cmake_install.cmake
 src/C++/Socket/a.out
 src/C++/Driver/Makefile
-vgcore*
+src/C++/Driver/vgcore*
 src/C++/Driver/cmake_install.cmake
 src/C++/Driver/Makefile
 src/C++/Driver/log
@@ -31,4 +31,3 @@ CMakeFiles/
 Makefile
 CMakeCache.txt
 cmake_install.cmake
-src/C++/OpenCV/main

docs/Infrastructure/uml.md

@@ -0,0 +1,51 @@
+```mermaid
+classDiagram
+    class CKobuki {
+        +enableCommands(bool commands)
+        +loop(void *user_data, TKobukiData &Kobuki_data)
+        +startCommunication(char *portname, bool CommandsEnabled, void *userDataL)
+        +measure()
+        +setLed(int led1, int led2)
+        +setTranslationSpeed(int mmpersec)
+        +setRotationSpeed(double radpersec)
+        +setArcSpeed(int mmpersec, int radius)
+        +setSound(int noteinHz, int duration)
+        +setPower(int value)
+        +goStraight(long double distance)
+        +forward(int speedvalue)
+        +doRotation(long double th)
+    }
+
+    class FlaskApp {
+        +on_message(client, message)
+        +get_db()
+        +close_db(error)
+        +index()
+        +control()
+        +move()
+    }
+
+    class MQTTClient {
+        +connect()
+        +subscribe(topic)
+        +getLastMessage()
+        +isConnected()
+    }
+
+    FlaskApp --> MQTTClient : uses
+    FlaskApp --> CKobuki : controls
+
+    class RPI {
+        +KobukiCommunication()
+        +ESP32Communication()
+        +Camera()
+    }
+
+    class ESP32 {
+        +TVOC()
+        +DHT11()
+    }
+
+    RPI --> MQTTClient : communicates
+    MQTTClient --> CKobuki : communicates
+    RPI --> ESP32 : communicates

docs/code/OpenCV.md

@@ -1,20 +0,0 @@
-# OpenCV
-## Requirements
-For the camera we want it to detect what is happening on the video feed and identify it so it can identify dangers.
-
-
-## Issues
-
-* OpenCL not grabbing gpu
-* Solution: https://github.com/Smorodov/Multitarget-tracker/issues/93
-
-## Installation
-### Dependencies
-* glew
-* opencv
-
-
-
-
-## Sources
-* https://github.com/UnaNancyOwen/OpenCVDNNSample/tree/master

docs/scrum/retrospective/retro_sprint_4.md

@@ -0,0 +1 @@
+# retro sprint 4

src/C++/Driver/src/KobukiDriver/CKobuki.cpp

@@ -68,58 +68,47 @@ int CKobuki::connect(char *comportT) {
   HCom = open(comportT, O_RDWR | O_NOCTTY | O_NONBLOCK);
 
   if (HCom == -1) {
-    printf("Kobuki nepripojeny\n");
+    std::cerr <<"unable to connect. retry in 1 second" << std::endl;
     return HCom;
   } else {
-    set_interface_attribs2(HCom, B115200,
-                           0); // set speed to 115,200 bps, 8n1 (no parity)
+    set_interface_attribs2(HCom, B115200,0); // set speed to 115,200 bps, 8n1 (no parity)
     set_blocking2(HCom, 0);    // set no blocking
-    /*  struct termios settings;
-      tcgetattr(HCom, &settings);
-
-      cfsetospeed(&settings, B115200); // baud rate
-      settings.c_cflag &= ~PARENB; // no parity
-      settings.c_cflag &= ~CSTOPB; // 1 stop bit
-      settings.c_cflag &= ~CSIZE;
-      settings.c_cflag |= CS8 | CLOCAL; // 8 bits
-      settings.c_lflag &= ~ICANON; // canonical mode
-      settings.c_cc[VTIME]=1;
-      settings.c_oflag &= ~OPOST; // raw output
-
-      tcsetattr(HCom, TCSANOW, &settings); // apply the settings*/
     tcflush(HCom, TCOFLUSH);
 
-    printf("Kobuki pripojeny\n");
+    std::cout<<"Kobuki connected" << std::endl;
     return HCom;
   }
 }
 
+bool CKobuki::isConnected() {
+    return (HCom != -1 && tcflush(HCom, TCOFLUSH) == 0);
+}
+
 unsigned char *CKobuki::readKobukiMessage() {
   unsigned char buffer[1];
   ssize_t Pocet;
   buffer[0] = 0;
   unsigned char *null_buffer(0);
-  // citame kym nezachytime zaciatok spravy
+
+  // Read until the start of the message is detected
   do {
     Pocet = read(HCom, buffer, 1);
   } while (buffer[0] != 0xAA);
-  // mame zaciatok spravy (asi)
+
+  // We have the start of the message (possibly)
   if (Pocet == 1 && buffer[0] == 0xAA) {
-    // citame dalsi byte
+    // Read the next byte
     do {
-
       Pocet = read(HCom, buffer, 1);
+    } while (Pocet != 1); // On Linux: -1, on Windows: 0
 
-    } while (Pocet != 1); // na linuxe -1 na windowse 0
-
-    // a ak je to druhy byte hlavicky
+    // If it is the second byte of the header
     if (Pocet == 1 && buffer[0] == 0x55) {
-      // precitame dlzku
+      // Read the length
       Pocet = read(HCom, buffer, 1);
 
-      // ReadFile(hCom, buffer, 1, &Pocet, NULL);
       if (Pocet == 1) {
-        // mame dlzku.. nastavime vektor a precitame ho cely
+        // We have the length; initialize a buffer and read the entire message
         int readLenght = buffer[0];
         unsigned char *outputBuffer =
             (unsigned char *)calloc(readLenght + 4, sizeof(char));
@@ -134,7 +123,7 @@ unsigned char *CKobuki::readKobukiMessage() {
           pct = pct + (Pocet == -1 ? 0 : Pocet);
         } while (pct != (readLenght + 1));
 
-        // tu si mozeme ceknut co chodi zo serial intefejsu Kobukiho
+        // Here we can check what data is received from the Kobuki's serial interface
         // for(int i=0;i<outputBuffer[0]+2;i++)
         // {
         // 	printf("%x ",outputBuffer[i]);
@@ -162,8 +151,8 @@ void CKobuki::setLed(int led1, int led2) {
   pocet = write(HCom, &message, 8);
 }
 
-// tato funkcia nema moc sama o sebe vyznam, payload o tom, ze maju byt externe
-// napajania aktivne musi byt aj tak v kazdej sprave...
+// this function doesn't have much meaning by itself, the payload about them being external
+// power supplies must be active in every message anyway...
 void CKobuki::setPower(int value) {
   if (value == 1) {
     unsigned char message[8] = {0xaa, 0x55, 0x04, 0x0C, 0x02, 0xf0, 0x00, 0xAF};
@@ -251,7 +240,7 @@ void CKobuki::setSound(int noteinHz, int duration) {
 
 void CKobuki::startCommunication(char *portname, bool CommandsEnabled,
                                  void *userDataL) {
-  connect(portname);
+  if(connect(portname) != -1){
   enableCommands(CommandsEnabled);
   userData = userDataL;
 
@@ -262,18 +251,19 @@ void CKobuki::startCommunication(char *portname, bool CommandsEnabled,
     std::cerr << "Error creating thread: " << pthread_result << std::endl;
   }
 }
+}
 
 int CKobuki::measure() {
   while (stopVlakno == 0) {
     unsigned char *message = readKobukiMessage();
     if (message == NULL) {
-      // printf("vratil null message\n");
-      continue;
+    // printf("returned null message\n");
+    continue;
     }
     int ok = parser.parseKobukiMessage(parser.data, message);
 
-    // maximalne moze trvat callback funkcia 20 ms, ak by trvala viac, nestihame
-    // citat
+    // the maximum callback function can take 20 ms, if it takes longer, we won't be able to do it
+    // read
     if (ok == 0) {
       loop(userData, parser.data);
     }
@@ -353,7 +343,7 @@ long CKobuki::loop(void *user_data, TKobukiData &Kobuki_data) {
   totalLeft += dLeft;
   totalRight += dRight;
 
-  // ak je suma novej a predchadzajucej vacsia ako 65536 tak to pretieklo?
+// if the sum of the new and previous is greater than 65536 then it overflowed?
   directionL = (prevLeftEncoder < Kobuki_data.EncoderLeft ? 1 : -1);
   directionR = (prevRightEncoder < Kobuki_data.EncoderRight ? 1 : -1);
   dTimestamp = (Kobuki_data.timestamp < prevTimestamp
@@ -387,7 +377,7 @@ long CKobuki::loop(void *user_data, TKobukiData &Kobuki_data) {
 
 // tells the kobuki to go a few meters forward or backward, the sign decides
 // the function compensates for walking straight with the controller, internally
-// it uses setArcSpeed and uses encoder data as feedback
+// it uses setArcSpeed ​​and uses encoder data as feedback
 void CKobuki::goStraight(long double distance) {
   long double u_translation =
       0; // controlled magnitude, speed of the robot in motion
@@ -509,6 +499,32 @@ void CKobuki::doRotation(long double th) {
   usleep(25 * 1000);
 }
 
+// combines navigation to a coordinate and rotation by an angle, performs
+// movement to the selected coordinate in the robot's coordinate system
+void CKobuki::goToXy(long double xx, long double yy) {
+  long double th;
+
+  yy = yy * -1;
+
+  th = atan2(yy, xx);
+  doRotation(th);
+
+  long double s = sqrt(pow(xx, 2) + pow(yy, 2));
+
+  // resetnem suradnicovu sustavu robota
+  x = 0;
+  y = 0;
+  iterationCount = 0;
+  theta = 0;
+
+  // std::cout << "mam prejst: " << s << "[m]" << std::endl;
+
+  goStraight(s);
+
+  usleep(25 * 1000);
+  return;
+}
+
 /// @brief Makes the robot move forward for 3 seconds
 /// @param speedvalue How fast it will drive forward from 0 - 1024
 void CKobuki::forward(int speedvalue) {

src/C++/Driver/src/KobukiDriver/CKobuki.h

@@ -31,6 +31,7 @@
 #include <chrono>
 #include <sstream>
 #include "KobukiParser.h"
+#include "graph.h"
 
 using namespace std;
 
@@ -79,6 +80,7 @@ public:
 	void robotSafety(); //overload
 	void sendNullMessage();
 	bool safetyActive = false;
+	bool isConnected();
 	KobukiParser parser;
 
 

src/C++/Driver/src/KobukiDriver/graph.h

@@ -0,0 +1,71 @@
+#ifndef GRAPH1010
+#define GRAPH1010
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+
+using namespace std;
+#define GRAPH_ENABLED true
+
+class plot {
+public:
+ FILE *gp;
+ bool enabled,persist;
+ plot(bool _persist=false,bool _enabled=GRAPH_ENABLED) {
+ enabled=_enabled;
+ persist=_persist;
+  if (enabled) {
+	if(persist)
+		  gp=popen("gnuplot -persist","w");
+	else
+		  gp=popen("gnuplot","w");
+  }
+ }
+
+ void plot_data(vector<float> x,const char* style="points",const char* title="Data") {
+ if(!enabled)
+	return;
+  fprintf(gp,"set title '%s' \n",title);
+  fprintf(gp,"plot '-' w %s \n",style);
+  for(int k=0;k<x.size();k++) {
+   fprintf(gp,"%f\n",x[k]);
+  }
+  fprintf(gp,"e\n");
+  fflush(gp);
+ }
+
+ void plot_data(vector<float> x,vector<float> y,const char* style="points",const char* title="Data") {
+ if(!enabled)
+	return;
+  fprintf(gp,"set title '%s' \n",title);
+  fprintf(gp,"plot '-' w %s \n",style);
+  for(int k=0;k<x.size();k++) {
+   fprintf(gp,"%f %f \n",x[k],y[k]);
+  }
+  fprintf(gp,"e\n");
+  fflush(gp);
+ }
+
+ ~plot() {
+  if(enabled)
+  pclose(gp);
+ }
+ 
+};
+
+/*
+int main(int argc,char **argv) {
+ plot p;
+ for(int a=0;a<100;a++) {
+ vector<float> x,y;
+ for(int k=a;k<a+200;k++) {
+   x.push_back(k);
+   y.push_back(k*k);
+ }
+  p.plot_data(x,y);
+ }
+ return 0;
+}
+*/
+
+#endif

src/C++/Driver/src/MQTT/MqttClient.cpp

@@ -5,7 +5,6 @@ MqttClient::MqttClient(const std::string& address, const std::string& clientId,
     //here all the @PARAMS are getting set for the connection
     : client_(address, clientId), username_(username), password_(password), callback_(*this) {
     client_.set_callback(callback_);
-    
     options.set_clean_session(true);
     options.set_mqtt_version(MQTTVERSION_3_1_1);  // For MQTT 3.1.1
     if (!username_.empty() && !password_.empty()) {

src/C++/Driver/src/main.cpp

@@ -1,5 +1,4 @@
 #include <iostream>
-#include <cmath>
 #include <thread>
 #include "MQTT/MqttClient.h"
 #include "KobukiDriver/CKobuki.h"
@@ -9,302 +8,372 @@
 using namespace std;
 using namespace cv;
 CKobuki robot;
+
 std::string readMQTT();
 void parseMQTT(std::string message);
 void CapnSend();
-//ip, clientID, username, password
-MqttClient client("ws://145.92.224.21/ws/", "KobukiRPI", "rpi", "rpiwachtwoordofzo"); // create a client object
+MqttClient client("ws://145.92.224.21/ws/", "KobukiRPI", "rpi","rpiwachtwoordofzo"); // create a client object
 std::string message = "stop";
 std::string serializeKobukiData(const TKobukiData &data);
 void sendKobukiData(TKobukiData &data);
 
-void setup()
-{
-    unsigned char *null_ptr(0);
-    robot.startCommunication("/dev/ttyUSB0", true, null_ptr);
-    //connect mqtt server and sub to commands
+void setup() {
+  unsigned char *null_ptr(0);
+  std::cout << "Attempting to start communication with Kobuki..." << std::endl;
+  robot.startCommunication("/dev/ttyUSB0", true, null_ptr);
+  if (!robot.isConnected()) {
+    std::cerr << "Failed to start communication with Kobuki." << std::endl;
+  } else {
+    std::cout << "Successfully started communication with Kobuki." << std::endl;
+  }
+  // connect mqtt server and sub to commands
 
-    client.connect();
-    client.subscribe("home/commands");
+  client.connect();
+  client.subscribe("home/commands");
 }
 
-int main()
-{
-    setup();
-    std::thread image (CapnSend);
-    std::thread safety([&]() { robot.robotSafety(&message); });
-    std::thread sendMqtt([&]() { sendKobukiData(robot.parser.data); });
+int main() {
+  setup();
+
+  std::thread image(CapnSend);
+  std::thread safety([&]() { robot.robotSafety(&message); });
+  std::thread sendMqtt([&]() { sendKobukiData(robot.parser.data); });
+
+  while (true) {
+    if (!robot.isConnected()) {
+      std::cout << "Kobuki is not connected anymore. Reconnecting..." << std::endl;
+      robot.startCommunication("/dev/ttyUSB0", true, nullptr);
+      while (!robot.isConnected()) {
+        std::cout << "Attempting to reconnect..." << std::endl;
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+      }
+      std::cout << "Reconnected to Kobuki." << std::endl;
+    }
     
-    while(true){
-        parseMQTT(readMQTT());
+    std::string message = readMQTT();
+    if (!message.empty()) {
+      parseMQTT(message);
     }
+  }
 
-    sendMqtt.join();
-    safety.join();
-    image.join();
+  sendMqtt.join();
+  safety.join();
+  image.join();
 }
 
-std::string readMQTT()
-{
-    message = client.getLastMessage();
-    if (!message.empty())
-    {
-        std::cout << "MQTT Message: " << message << std::endl;
-    }
+std::string readMQTT() {
+  static std::string lastMessage;
 
-    // Add a small delay to avoid busy-waiting
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    return message;
+  std::string message = client.getLastMessage();
+  if (!message.empty() && message != lastMessage) {
+    std::cout << "MQTT Message: " << message << std::endl;
+    lastMessage = message;
+  }
+
+  // Add a small delay to avoid busy-waiting
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  return lastMessage;
 }
 
-void parseMQTT(std::string message)
-{
-    if (message == "up")
-    {
-        robot.forward(350);
-    }
-    else if (message == "left")
-    {
-        robot.setRotationSpeed(4);
-    }
-    else if (message == "right")
-    {
-        robot.setRotationSpeed(-4);
-    }
-    else if (message == "down")
-    {
-        robot.forward(-350);
-    }
-    else if (message == "stop")
-    {
-        robot.sendNullMessage();
-        robot.sendNullMessage();
-    }
-    else if (message == "estop")
-    {
-        robot.forward(-400);
-    }
-    else
-    {
-        std::cout << "Invalid command" << std::endl;
-    }
+void parseMQTT(std::string message) {
+  if (message == "up") {
+    robot.forward(350);
+  } else if (message == "left") {
+    robot.setRotationSpeed(4);
+  } else if (message == "right") {
+    robot.setRotationSpeed(-4);
+  } else if (message == "down") {
+    robot.forward(-350);
+  } else if (message == "stop") {
+    robot.sendNullMessage();
+    robot.sendNullMessage();
+  } else if (message == "estop") {
+    robot.forward(-400);
+  } else {
+    std::cout << "Invalid command" << std::endl;
+  }
 }
 
-void logToFile()
-{
-    while (true)
-    {
-        TKobukiData robotData = robot.parser.data;
-        std::ofstream outputFile("log", std::ios_base::app); // Open file in append mode to not overwrite own content
-        if (outputFile.is_open())
-        { // check if the file was opened successfully
-            // Get current time
-            std::time_t now = std::time(nullptr);
-            outputFile << "Timestamp: " << std::ctime(&now);
-            // Write data to the file
-            outputFile << "analogInputCh0: " << robotData.analogInputCh0 << "\n";
-            outputFile << "analogInputCh1: " << robotData.analogInputCh1 << "\n";
-            outputFile << "analogInputCh2: " << robotData.analogInputCh2 << "\n";
-            outputFile << "analogInputCh3: " << robotData.analogInputCh3 << "\n";
-            outputFile << "digitalInput: " << robotData.digitalInput << "\n";
-            outputFile << "timestamp: " << robotData.timestamp << "\n";
-            outputFile << "BumperCenter: " << robotData.BumperCenter << "\n";
-            outputFile << "BumperLeft: " << robotData.BumperLeft << "\n";
-            outputFile << "BumperRight: " << robotData.BumperRight << "\n";
-            outputFile << "WheelDropLeft: " << robotData.WheelDropLeft << "\n";
-            outputFile << "WheelDropRight: " << robotData.WheelDropRight << "\n";
-            outputFile << "CliffCenter: " << robotData.CliffCenter << "\n";
-            outputFile << "CliffLeft: " << robotData.CliffLeft << "\n";
-            outputFile << "CliffRight: " << robotData.CliffRight << "\n";
-            outputFile << "EncoderLeft: " << robotData.EncoderLeft << "\n";
-            outputFile << "EncoderRight: " << robotData.EncoderRight << "\n";
-            outputFile << "PWMleft: " << robotData.PWMleft << "\n";
-            outputFile << "PWMright: " << robotData.PWMright << "\n";
-            outputFile << "ButtonPress: " << robotData.ButtonPress1 << "\n";
-            outputFile << "ButtonPress: " << robotData.ButtonPress2 << "\n";
-            outputFile << "ButtonPress: " << robotData.ButtonPress3 << "\n";
-            outputFile << "Charger: " << robotData.Charger << "\n";
-            outputFile << "Battery: " << robotData.Battery << "\n";
-            outputFile << "overCurrent: " << robotData.overCurrent << "\n";
-            outputFile << "IRSensorRight: " << robotData.IRSensorRight << "\n";
-            outputFile << "IRSensorCenter: " << robotData.IRSensorCenter << "\n";
-            outputFile << "IRSensorLeft: " << robotData.IRSensorLeft << "\n";
-            outputFile << "GyroAngle: " << robotData.GyroAngle << "\n";
-            outputFile << "GyroAngleRate: " << robotData.GyroAngleRate << "\n";
-            outputFile << "CliffSensorRight: " << robotData.CliffSensorRight << "\n";
-            outputFile << "CliffSensorCenter: " << robotData.CliffSensorCenter << "\n";
-            outputFile << "CliffSensorLeft: " << robotData.CliffSensorLeft << "\n";
-            outputFile << "wheelCurrentLeft: " << robotData.wheelCurrentLeft << "\n";
-            outputFile << "wheelCurrentRight: " << robotData.wheelCurrentRight << "\n";
-            outputFile << "frameId: " << robotData.frameId << "\n";
-            outputFile << "HardwareVersionPatch: " << robotData.extraInfo.HardwareVersionPatch << "\n";
-            outputFile << "HardwareVersionMinor: " << robotData.extraInfo.HardwareVersionMinor << "\n";
-            outputFile << "HardwareVersionMajor: " << robotData.extraInfo.HardwareVersionMajor << "\n";
-            outputFile << "FirmwareVersionPatch: " << robotData.extraInfo.FirmwareVersionPatch << "\n";
-            outputFile << "FirmwareVersionMinor: " << robotData.extraInfo.FirmwareVersionMinor << "\n";
-            outputFile << "FirmwareVersionMajor: " << robotData.extraInfo.FirmwareVersionMajor << "\n";
-            outputFile << "UDID0: " << robotData.extraInfo.UDID0 << "\n";
-            outputFile << "UDID1: " << robotData.extraInfo.UDID1 << "\n";
-            outputFile << "UDID2: " << robotData.extraInfo.UDID2 << "\n";
-            outputFile.close();
-        }
-        else
-        {
-            std::cerr << "Error opening file\n";
-        }
-
-        std::this_thread::sleep_for(std::chrono::seconds(2)); // Sleep for 2 seconds
+void logToFile() {
+  while (true) {
+    TKobukiData robotData = robot.parser.data;
+    std::ofstream outputFile("log",
+                             std::ios_base::app); // Open file in append mode to
+                                                  // not overwrite own content
+    if (outputFile.is_open()) { // check if the file was opened successfully
+      // Get current time
+      std::time_t now = std::time(nullptr);
+      outputFile << "Timestamp: " << std::ctime(&now);
+      // Write data to the file
+      outputFile << "analogInputCh0: " << robotData.analogInputCh0 << "\n";
+      outputFile << "analogInputCh1: " << robotData.analogInputCh1 << "\n";
+      outputFile << "analogInputCh2: " << robotData.analogInputCh2 << "\n";
+      outputFile << "analogInputCh3: " << robotData.analogInputCh3 << "\n";
+      outputFile << "digitalInput: " << robotData.digitalInput << "\n";
+      outputFile << "timestamp: " << robotData.timestamp << "\n";
+      outputFile << "BumperCenter: " << robotData.BumperCenter << "\n";
+      outputFile << "BumperLeft: " << robotData.BumperLeft << "\n";
+      outputFile << "BumperRight: " << robotData.BumperRight << "\n";
+      outputFile << "WheelDropLeft: " << robotData.WheelDropLeft << "\n";
+      outputFile << "WheelDropRight: " << robotData.WheelDropRight << "\n";
+      outputFile << "CliffCenter: " << robotData.CliffCenter << "\n";
+      outputFile << "CliffLeft: " << robotData.CliffLeft << "\n";
+      outputFile << "CliffRight: " << robotData.CliffRight << "\n";
+      outputFile << "EncoderLeft: " << robotData.EncoderLeft << "\n";
+      outputFile << "EncoderRight: " << robotData.EncoderRight << "\n";
+      outputFile << "PWMleft: " << robotData.PWMleft << "\n";
+      outputFile << "PWMright: " << robotData.PWMright << "\n";
+      outputFile << "ButtonPress: " << robotData.ButtonPress1 << "\n";
+      outputFile << "ButtonPress: " << robotData.ButtonPress2 << "\n";
+      outputFile << "ButtonPress: " << robotData.ButtonPress3 << "\n";
+      outputFile << "Charger: " << robotData.Charger << "\n";
+      outputFile << "Battery: " << robotData.Battery << "\n";
+      outputFile << "overCurrent: " << robotData.overCurrent << "\n";
+      outputFile << "IRSensorRight: " << robotData.IRSensorRight << "\n";
+      outputFile << "IRSensorCenter: " << robotData.IRSensorCenter << "\n";
+      outputFile << "IRSensorLeft: " << robotData.IRSensorLeft << "\n";
+      outputFile << "GyroAngle: " << robotData.GyroAngle << "\n";
+      outputFile << "GyroAngleRate: " << robotData.GyroAngleRate << "\n";
+      outputFile << "CliffSensorRight: " << robotData.CliffSensorRight << "\n";
+      outputFile << "CliffSensorCenter: " << robotData.CliffSensorCenter
+                 << "\n";
+      outputFile << "CliffSensorLeft: " << robotData.CliffSensorLeft << "\n";
+      outputFile << "wheelCurrentLeft: " << robotData.wheelCurrentLeft << "\n";
+      outputFile << "wheelCurrentRight: " << robotData.wheelCurrentRight
+                 << "\n";
+      outputFile << "frameId: " << robotData.frameId << "\n";
+      outputFile << "HardwareVersionPatch: "
+                 << robotData.extraInfo.HardwareVersionPatch << "\n";
+      outputFile << "HardwareVersionMinor: "
+                 << robotData.extraInfo.HardwareVersionMinor << "\n";
+      outputFile << "HardwareVersionMajor: "
+                 << robotData.extraInfo.HardwareVersionMajor << "\n";
+      outputFile << "FirmwareVersionPatch: "
+                 << robotData.extraInfo.FirmwareVersionPatch << "\n";
+      outputFile << "FirmwareVersionMinor: "
+                 << robotData.extraInfo.FirmwareVersionMinor << "\n";
+      outputFile << "FirmwareVersionMajor: "
+                 << robotData.extraInfo.FirmwareVersionMajor << "\n";
+      outputFile << "UDID0: " << robotData.extraInfo.UDID0 << "\n";
+      outputFile << "UDID1: " << robotData.extraInfo.UDID1 << "\n";
+      outputFile << "UDID2: " << robotData.extraInfo.UDID2 << "\n";
+      outputFile.close();
+    } else {
+      std::cerr << "Error opening file\n";
     }
+
+    std::this_thread::sleep_for(std::chrono::seconds(2)); // Sleep for 2 seconds
+  }
 }
 
 void sendIndividualKobukiData(const TKobukiData &data) {
-    while (true) {
-        client.publishMessage("kobuki/data/timestamp", std::to_string(data.timestamp));
-        client.publishMessage("kobuki/data/BumperCenter", std::to_string(data.BumperCenter));
-        client.publishMessage("kobuki/data/BumperLeft", std::to_string(data.BumperLeft));
-        client.publishMessage("kobuki/data/BumperRight", std::to_string(data.BumperRight));
-        client.publishMessage("kobuki/data/WheelDropLeft", std::to_string(data.WheelDropLeft));
-        client.publishMessage("kobuki/data/WheelDropRight", std::to_string(data.WheelDropRight));
-        client.publishMessage("kobuki/data/CliffCenter", std::to_string(data.CliffCenter));
-        client.publishMessage("kobuki/data/CliffLeft", std::to_string(data.CliffLeft));
-        client.publishMessage("kobuki/data/CliffRight", std::to_string(data.CliffRight));
-        client.publishMessage("kobuki/data/EncoderLeft", std::to_string(data.EncoderLeft));
-        client.publishMessage("kobuki/data/EncoderRight", std::to_string(data.EncoderRight));
-        client.publishMessage("kobuki/data/PWMleft", std::to_string(data.PWMleft));
-        client.publishMessage("kobuki/data/PWMright", std::to_string(data.PWMright));
-        client.publishMessage("kobuki/data/ButtonPress1", std::to_string(data.ButtonPress1));
-        client.publishMessage("kobuki/data/ButtonPress2", std::to_string(data.ButtonPress2));
-        client.publishMessage("kobuki/data/ButtonPress3", std::to_string(data.ButtonPress3));
-        client.publishMessage("kobuki/data/Charger", std::to_string(data.Charger));
-        client.publishMessage("kobuki/data/Battery", std::to_string(data.Battery));
-        client.publishMessage("kobuki/data/overCurrent", std::to_string(data.overCurrent));
-        client.publishMessage("kobuki/data/IRSensorRight", std::to_string(data.IRSensorRight));
-        client.publishMessage("kobuki/data/IRSensorCenter", std::to_string(data.IRSensorCenter));
-        client.publishMessage("kobuki/data/IRSensorLeft", std::to_string(data.IRSensorLeft));
-        client.publishMessage("kobuki/data/GyroAngle", std::to_string(data.GyroAngle));
-        client.publishMessage("kobuki/data/GyroAngleRate", std::to_string(data.GyroAngleRate));
-        client.publishMessage("kobuki/data/CliffSensorRight", std::to_string(data.CliffSensorRight));
-        client.publishMessage("kobuki/data/CliffSensorCenter", std::to_string(data.CliffSensorCenter));
-        client.publishMessage("kobuki/data/CliffSensorLeft", std::to_string(data.CliffSensorLeft));
-        client.publishMessage("kobuki/data/wheelCurrentLeft", std::to_string(data.wheelCurrentLeft));
-        client.publishMessage("kobuki/data/wheelCurrentRight", std::to_string(data.wheelCurrentRight));
-        client.publishMessage("kobuki/data/digitalInput", std::to_string(data.digitalInput));
-        client.publishMessage("kobuki/data/analogInputCh0", std::to_string(data.analogInputCh0));
-        client.publishMessage("kobuki/data/analogInputCh1", std::to_string(data.analogInputCh1));
-        client.publishMessage("kobuki/data/analogInputCh2", std::to_string(data.analogInputCh2));
-        client.publishMessage("kobuki/data/analogInputCh3", std::to_string(data.analogInputCh3));
-        client.publishMessage("kobuki/data/frameId", std::to_string(data.frameId));
-        client.publishMessage("kobuki/data/extraInfo/HardwareVersionPatch", std::to_string(data.extraInfo.HardwareVersionPatch));
-        client.publishMessage("kobuki/data/extraInfo/HardwareVersionMinor", std::to_string(data.extraInfo.HardwareVersionMinor));
-        client.publishMessage("kobuki/data/extraInfo/HardwareVersionMajor", std::to_string(data.extraInfo.HardwareVersionMajor));
-        client.publishMessage("kobuki/data/extraInfo/FirmwareVersionPatch", std::to_string(data.extraInfo.FirmwareVersionPatch));
-        client.publishMessage("kobuki/data/extraInfo/FirmwareVersionMinor", std::to_string(data.extraInfo.FirmwareVersionMinor));
-        client.publishMessage("kobuki/data/extraInfo/FirmwareVersionMajor", std::to_string(data.extraInfo.FirmwareVersionMajor));
-        client.publishMessage("kobuki/data/extraInfo/UDID0", std::to_string(data.extraInfo.UDID0));
-        client.publishMessage("kobuki/data/extraInfo/UDID1", std::to_string(data.extraInfo.UDID1));
-        client.publishMessage("kobuki/data/extraInfo/UDID2", std::to_string(data.extraInfo.UDID2));
+  while (true) {
+    std::cout << "Kobuki Data wordt gepubliceerd naar kobuki/data/timestamp: "
+              << data.timestamp << std::endl;
+    client.publishMessage("kobuki/data/timestamp",
+                          std::to_string(data.timestamp));
+    client.publishMessage("kobuki/data/BumperCenter",
+                          std::to_string(data.BumperCenter));
+    client.publishMessage("kobuki/data/BumperLeft",
+                          std::to_string(data.BumperLeft));
+    client.publishMessage("kobuki/data/BumperRight",
+                          std::to_string(data.BumperRight));
+    client.publishMessage("kobuki/data/WheelDropLeft",
+                          std::to_string(data.WheelDropLeft));
+    client.publishMessage("kobuki/data/WheelDropRight",
+                          std::to_string(data.WheelDropRight));
+    client.publishMessage("kobuki/data/CliffCenter",
+                          std::to_string(data.CliffCenter));
+    client.publishMessage("kobuki/data/CliffLeft",
+                          std::to_string(data.CliffLeft));
+    client.publishMessage("kobuki/data/CliffRight",
+                          std::to_string(data.CliffRight));
+    client.publishMessage("kobuki/data/EncoderLeft",
+                          std::to_string(data.EncoderLeft));
+    client.publishMessage("kobuki/data/EncoderRight",
+                          std::to_string(data.EncoderRight));
+    client.publishMessage("kobuki/data/PWMleft", std::to_string(data.PWMleft));
+    client.publishMessage("kobuki/data/PWMright",
+                          std::to_string(data.PWMright));
+    client.publishMessage("kobuki/data/ButtonPress1",
+                          std::to_string(data.ButtonPress1));
+    client.publishMessage("kobuki/data/ButtonPress2",
+                          std::to_string(data.ButtonPress2));
+    client.publishMessage("kobuki/data/ButtonPress3",
+                          std::to_string(data.ButtonPress3));
+    client.publishMessage("kobuki/data/Charger", std::to_string(data.Charger));
+    client.publishMessage("kobuki/data/Battery", std::to_string(data.Battery));
+    client.publishMessage("kobuki/data/overCurrent",
+                          std::to_string(data.overCurrent));
+    client.publishMessage("kobuki/data/IRSensorRight",
+                          std::to_string(data.IRSensorRight));
+    client.publishMessage("kobuki/data/IRSensorCenter",
+                          std::to_string(data.IRSensorCenter));
+    client.publishMessage("kobuki/data/IRSensorLeft",
+                          std::to_string(data.IRSensorLeft));
+    client.publishMessage("kobuki/data/GyroAngle",
+                          std::to_string(data.GyroAngle));
+    client.publishMessage("kobuki/data/GyroAngleRate",
+                          std::to_string(data.GyroAngleRate));
+    client.publishMessage("kobuki/data/CliffSensorRight",
+                          std::to_string(data.CliffSensorRight));
+    client.publishMessage("kobuki/data/CliffSensorCenter",
+                          std::to_string(data.CliffSensorCenter));
+    client.publishMessage("kobuki/data/CliffSensorLeft",
+                          std::to_string(data.CliffSensorLeft));
+    client.publishMessage("kobuki/data/wheelCurrentLeft",
+                          std::to_string(data.wheelCurrentLeft));
+    client.publishMessage("kobuki/data/wheelCurrentRight",
+                          std::to_string(data.wheelCurrentRight));
+    client.publishMessage("kobuki/data/digitalInput",
+                          std::to_string(data.digitalInput));
+    client.publishMessage("kobuki/data/analogInputCh0",
+                          std::to_string(data.analogInputCh0));
+    client.publishMessage("kobuki/data/analogInputCh1",
+                          std::to_string(data.analogInputCh1));
+    client.publishMessage("kobuki/data/analogInputCh2",
+                          std::to_string(data.analogInputCh2));
+    client.publishMessage("kobuki/data/analogInputCh3",
+                          std::to_string(data.analogInputCh3));
+    client.publishMessage("kobuki/data/frameId", std::to_string(data.frameId));
+    client.publishMessage("kobuki/data/extraInfo/HardwareVersionPatch",
+                          std::to_string(data.extraInfo.HardwareVersionPatch));
+    client.publishMessage("kobuki/data/extraInfo/HardwareVersionMinor",
+                          std::to_string(data.extraInfo.HardwareVersionMinor));
+    client.publishMessage("kobuki/data/extraInfo/HardwareVersionMajor",
+                          std::to_string(data.extraInfo.HardwareVersionMajor));
+    client.publishMessage("kobuki/data/extraInfo/FirmwareVersionPatch",
+                          std::to_string(data.extraInfo.FirmwareVersionPatch));
+    client.publishMessage("kobuki/data/extraInfo/FirmwareVersionMinor",
+                          std::to_string(data.extraInfo.FirmwareVersionMinor));
+    client.publishMessage("kobuki/data/extraInfo/FirmwareVersionMajor",
+                          std::to_string(data.extraInfo.FirmwareVersionMajor));
+    client.publishMessage("kobuki/data/extraInfo/UDID0",
+                          std::to_string(data.extraInfo.UDID0));
+    client.publishMessage("kobuki/data/extraInfo/UDID1",
+                          std::to_string(data.extraInfo.UDID1));
+    client.publishMessage("kobuki/data/extraInfo/UDID2",
+                          std::to_string(data.extraInfo.UDID2));
 
-        if (!data.gyroData.empty()) {
-            const auto& latestGyro = data.gyroData.back();
-            client.publishMessage("kobuki/data/gyroData/x", std::to_string(latestGyro.x));
-            client.publishMessage("kobuki/data/gyroData/y", std::to_string(latestGyro.y));
-            client.publishMessage("kobuki/data/gyroData/z", std::to_string(latestGyro.z));
-        }
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    if (!data.gyroData.empty()) {
+      const auto &latestGyro = data.gyroData.back();
+      client.publishMessage("kobuki/data/gyroData/x",
+                            std::to_string(latestGyro.x));
+      client.publishMessage("kobuki/data/gyroData/y",
+                            std::to_string(latestGyro.y));
+      client.publishMessage("kobuki/data/gyroData/z",
+                            std::to_string(latestGyro.z));
     }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  }
 }
 
 std::string serializeKobukiData(const TKobukiData &data) {
-    std::string json = "{\"timestamp\":" + std::to_string(data.timestamp) +
-                       ",\"BumperCenter\":" + std::to_string(data.BumperCenter) +
-                       ",\"BumperLeft\":" + std::to_string(data.BumperLeft) +
-                       ",\"BumperRight\":" + std::to_string(data.BumperRight) +
-                       ",\"WheelDropLeft\":" + std::to_string(data.WheelDropLeft) +
-                       ",\"WheelDropRight\":" + std::to_string(data.WheelDropRight) +
-                       ",\"CliffCenter\":" + std::to_string(data.CliffCenter) +
-                       ",\"CliffLeft\":" + std::to_string(data.CliffLeft) +
-                       ",\"CliffRight\":" + std::to_string(data.CliffRight) +
-                       ",\"EncoderLeft\":" + std::to_string(data.EncoderLeft) +
-                       ",\"EncoderRight\":" + std::to_string(data.EncoderRight) +
-                       ",\"PWMleft\":" + std::to_string(data.PWMleft) +
-                       ",\"PWMright\":" + std::to_string(data.PWMright) +
-                       ",\"ButtonPress1\":" + std::to_string(data.ButtonPress1) +
-                       ",\"ButtonPress2\":" + std::to_string(data.ButtonPress2) +
-                       ",\"ButtonPress3\":" + std::to_string(data.ButtonPress3) +
-                       ",\"Charger\":" + std::to_string(data.Charger) +
-                       ",\"Battery\":" + std::to_string(data.Battery) +
-                       ",\"overCurrent\":" + std::to_string(data.overCurrent) +
-                       ",\"IRSensorRight\":" + std::to_string(data.IRSensorRight) +
-                       ",\"IRSensorCenter\":" + std::to_string(data.IRSensorCenter) +
-                       ",\"IRSensorLeft\":" + std::to_string(data.IRSensorLeft) +
-                       ",\"GyroAngle\":" + std::to_string(data.GyroAngle) +
-                       ",\"GyroAngleRate\":" + std::to_string(data.GyroAngleRate) +
-                       ",\"CliffSensorRight\":" + std::to_string(data.CliffSensorRight) +
-                       ",\"CliffSensorCenter\":" + std::to_string(data.CliffSensorCenter) +
-                       ",\"CliffSensorLeft\":" + std::to_string(data.CliffSensorLeft) +
-                       ",\"wheelCurrentLeft\":" + std::to_string(data.wheelCurrentLeft) +
-                       ",\"wheelCurrentRight\":" + std::to_string(data.wheelCurrentRight) +
-                       ",\"digitalInput\":" + std::to_string(data.digitalInput) +
-                       ",\"analogInputCh0\":" + std::to_string(data.analogInputCh0) +
-                       ",\"analogInputCh1\":" + std::to_string(data.analogInputCh1) +
-                       ",\"analogInputCh2\":" + std::to_string(data.analogInputCh2) +
-                       ",\"analogInputCh3\":" + std::to_string(data.analogInputCh3) +
-                       ",\"frameId\":" + std::to_string(data.frameId) +
-                       ",\"extraInfo\":{\"HardwareVersionPatch\":" + std::to_string(data.extraInfo.HardwareVersionPatch) +
-                       ",\"HardwareVersionMinor\":" + std::to_string(data.extraInfo.HardwareVersionMinor) +
-                       ",\"HardwareVersionMajor\":" + std::to_string(data.extraInfo.HardwareVersionMajor) +
-                       ",\"FirmwareVersionPatch\":" + std::to_string(data.extraInfo.FirmwareVersionPatch) +
-                       ",\"FirmwareVersionMinor\":" + std::to_string(data.extraInfo.FirmwareVersionMinor) +
-                       ",\"FirmwareVersionMajor\":" + std::to_string(data.extraInfo.FirmwareVersionMajor) +
-                       ",\"UDID0\":" + std::to_string(data.extraInfo.UDID0) +
-                       ",\"UDID1\":" + std::to_string(data.extraInfo.UDID1) +
-                       ",\"UDID2\":" + std::to_string(data.extraInfo.UDID2) + "},\"gyroData\":[";
+  std::string json =
+      "{\"timestamp\":" + std::to_string(data.timestamp) +
+      ",\"BumperCenter\":" + std::to_string(data.BumperCenter) +
+      ",\"BumperLeft\":" + std::to_string(data.BumperLeft) +
+      ",\"BumperRight\":" + std::to_string(data.BumperRight) +
+      ",\"WheelDropLeft\":" + std::to_string(data.WheelDropLeft) +
+      ",\"WheelDropRight\":" + std::to_string(data.WheelDropRight) +
+      ",\"CliffCenter\":" + std::to_string(data.CliffCenter) +
+      ",\"CliffLeft\":" + std::to_string(data.CliffLeft) +
+      ",\"CliffRight\":" + std::to_string(data.CliffRight) +
+      ",\"EncoderLeft\":" + std::to_string(data.EncoderLeft) +
+      ",\"EncoderRight\":" + std::to_string(data.EncoderRight) +
+      ",\"PWMleft\":" + std::to_string(data.PWMleft) +
+      ",\"PWMright\":" + std::to_string(data.PWMright) +
+      ",\"ButtonPress1\":" + std::to_string(data.ButtonPress1) +
+      ",\"ButtonPress2\":" + std::to_string(data.ButtonPress2) +
+      ",\"ButtonPress3\":" + std::to_string(data.ButtonPress3) +
+      ",\"Charger\":" + std::to_string(data.Charger) +
+      ",\"Battery\":" + std::to_string(data.Battery) +
+      ",\"overCurrent\":" + std::to_string(data.overCurrent) +
+      ",\"IRSensorRight\":" + std::to_string(data.IRSensorRight) +
+      ",\"IRSensorCenter\":" + std::to_string(data.IRSensorCenter) +
+      ",\"IRSensorLeft\":" + std::to_string(data.IRSensorLeft) +
+      ",\"GyroAngle\":" + std::to_string(data.GyroAngle) +
+      ",\"GyroAngleRate\":" + std::to_string(data.GyroAngleRate) +
+      ",\"CliffSensorRight\":" + std::to_string(data.CliffSensorRight) +
+      ",\"CliffSensorCenter\":" + std::to_string(data.CliffSensorCenter) +
+      ",\"CliffSensorLeft\":" + std::to_string(data.CliffSensorLeft) +
+      ",\"wheelCurrentLeft\":" + std::to_string(data.wheelCurrentLeft) +
+      ",\"wheelCurrentRight\":" + std::to_string(data.wheelCurrentRight) +
+      ",\"digitalInput\":" + std::to_string(data.digitalInput) +
+      ",\"analogInputCh0\":" + std::to_string(data.analogInputCh0) +
+      ",\"analogInputCh1\":" + std::to_string(data.analogInputCh1) +
+      ",\"analogInputCh2\":" + std::to_string(data.analogInputCh2) +
+      ",\"analogInputCh3\":" + std::to_string(data.analogInputCh3) +
+      ",\"frameId\":" + std::to_string(data.frameId) +
+      ",\"extraInfo\":{\"HardwareVersionPatch\":" +
+      std::to_string(data.extraInfo.HardwareVersionPatch) +
+      ",\"HardwareVersionMinor\":" +
+      std::to_string(data.extraInfo.HardwareVersionMinor) +
+      ",\"HardwareVersionMajor\":" +
+      std::to_string(data.extraInfo.HardwareVersionMajor) +
+      ",\"FirmwareVersionPatch\":" +
+      std::to_string(data.extraInfo.FirmwareVersionPatch) +
+      ",\"FirmwareVersionMinor\":" +
+      std::to_string(data.extraInfo.FirmwareVersionMinor) +
+      ",\"FirmwareVersionMajor\":" +
+      std::to_string(data.extraInfo.FirmwareVersionMajor) +
+      ",\"UDID0\":" + std::to_string(data.extraInfo.UDID0) +
+      ",\"UDID1\":" + std::to_string(data.extraInfo.UDID1) +
+      ",\"UDID2\":" + std::to_string(data.extraInfo.UDID2) + "},\"gyroData\":[";
 
-    if (!data.gyroData.empty()) {
-        const auto& latestGyro = data.gyroData.back();
-        json += "{\"x\":" + std::to_string(latestGyro.x) +
-                ",\"y\":" + std::to_string(latestGyro.y) +
-                ",\"z\":" + std::to_string(latestGyro.z) + "}";
-    }
+  if (!data.gyroData.empty()) {
+    const auto &latestGyro = data.gyroData.back();
+    json += "{\"x\":" + std::to_string(latestGyro.x) +
+            ",\"y\":" + std::to_string(latestGyro.y) +
+            ",\"z\":" + std::to_string(latestGyro.z) + "}";
+  }
 
-    json += "]}";
-    return json;
+  json += "]}";
+  return json;
 }
-//create extra function to send the message every 100ms
-//needed it so it can be threaded
+// create extra function to send the message every 100ms
+// needed it so it can be threaded
 void sendKobukiData(TKobukiData &data) {
-    while (true) {
-        client.publishMessage("kobuki/data", serializeKobukiData(data));
-        std::cout << "Sent data" << std::endl;
-        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    }
+  while (true) {
+    // if(!robot.isConnected()){
+    //   std::cout << "Kobuki is not connected anymore" << std::endl;
+    //     robot.startCommunication("/dev/ttyUSB0", true, nullptr);
+    //   while(!robot.isConnected()){
+    //     std::this_thread::sleep_for(std::chrono::seconds(1));
+    //   }
+    // }
+    client.publishMessage("kobuki/data", serializeKobukiData(data));
+    std::cout << "Sent data" << std::endl;
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  }
 }
 
 void CapnSend() {
-    VideoCapture cap(0);
-    if (!cap.isOpened()) {
-        cerr << "Error: Could not open camera" << endl;
-        return;
+  VideoCapture cap(0);
+  if (!cap.isOpened()) {
+    cerr << "Error: Could not open camera" << endl;
+    return;
+  }
+
+  Mat frame;
+  while (true) {
+    cap >> frame; // Capture a new image frame
+    if (frame.empty()) {
+      cerr << "Error: Could not capture image" << endl;
+      continue;
     }
 
-    Mat frame;
-    while (true) {
-        cap >> frame; // Capture a new image frame
-        if (frame.empty()) {
-            cerr << "Error: Could not capture image" << endl;
-            continue;
-        }
+    // Convert the image to a byte array
+    vector<uchar> buf;
+    imencode(".jpg", frame, buf);
+    auto *enc_msg = reinterpret_cast<unsigned char *>(buf.data());
 
-        // Convert the image to a byte array
-        vector<uchar> buf;
-        imencode(".jpg", frame, buf);
-        auto* enc_msg = reinterpret_cast<unsigned char*>(buf.data());
+    // Publish the image data
+    client.publishMessage("kobuki/cam", string(enc_msg, enc_msg + buf.size()));
+    cout << "Sent image" << endl;
 
-        // Publish the image data
-        client.publishMessage("kobuki/cam", string(enc_msg, enc_msg + buf.size()));
-        cout << "Sent image" << endl;
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(300)); // Send image every 1000ms
-    }
+    std::this_thread::sleep_for(
+        std::chrono::milliseconds(300)); // Send image every 1000ms
+  }
 }

src/C++/MQTT/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.10)
+set(CMAKE_CXX_STANDARD 23)
+
+# Find the Paho MQTT C++ library
+find_library(PAHO_MQTTPP_LIBRARY paho-mqttpp3 PATHS /usr/local/lib)
+find_library(PAHO_MQTT_LIBRARY paho-mqtt3a PATHS /usr/local/lib)
+
+# Include the headers
+include_directories(/usr/local/include)
+
+# Add the executable
+add_executable(my_program main.cpp)
+
+# Link the libraries
+target_link_libraries(my_program ${PAHO_MQTTPP_LIBRARY} ${PAHO_MQTT_LIBRARY})

src/C++/MQTT/main.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <mqtt/async_client.h>
+#include <thread>  // For std::this_thread::sleep_for
+#include <chrono>  // For std::chrono::seconds
+
+// Define the address of the MQTT broker, the client ID, and the topic to subscribe to.
+const std::string ADDRESS("mqtt://localhost:1883");  // Broker address (Raspberry Pi)
+const std::string CLIENT_ID("raspberry_pi_client");
+const std::string TOPIC("home/commands");
+
+// Define a callback class that handles incoming messages and connection events.
+class callback : public virtual mqtt::callback {
+  // Called when a message arrives on a subscribed topic.
+  void message_arrived(mqtt::const_message_ptr msg) override {
+    std::cout << "Received message: '" << msg->get_topic()<< "' : " << msg->to_string() << std::endl;
+  }
+
+  // Called when the connection to the broker is lost.
+  void connection_lost(const std::string& cause) override {
+    std::cerr << "Connection lost. Reason: " << cause << std::endl;
+  }
+
+  // Called when a message delivery is complete.
+  void delivery_complete(mqtt::delivery_token_ptr token) override {
+    std::cout << "Message delivered!" << std::endl;
+  }
+};
+
+int main() {
+  // Create an MQTT async client and set up the callback class.
+  mqtt::async_client client(ADDRESS, CLIENT_ID);
+  callback cb;
+  client.set_callback(cb);
+
+  // Set up the connection options (such as username and password).
+  mqtt::connect_options connOpts;
+  connOpts.set_clean_session(true);
+  connOpts.set_user_name("ishak");
+  connOpts.set_password("kobuki");
+  connOpts.set_mqtt_version(MQTTVERSION_3_1_1);
+
+  try {
+    // Try to connect to the broker and wait until successful.
+    std::cout << "Connecting to broker..." << std::endl;
+    client.connect(connOpts)->wait();  // Connect with the provided options
+    std::cout << "Connected!" << std::endl;
+
+    // Subscribe to the specified topic and wait for confirmation.
+    std::cout << "Subscribing to topic: " << TOPIC << std::endl;
+    client.subscribe(TOPIC, 1)->wait();  // Subscribe with QoS level 1
+
+    // Keep the program running to continue receiving messages from the broker.
+    while (true) {
+      std::this_thread::sleep_for(std::chrono::seconds(1));  // Sleep to reduce CPU usage
+    }
+
+  } catch (const mqtt::exception &exc) {
+    // Catch any MQTT exceptions and display the error message.
+    std::cerr << "Error: " << exc.what() << std::endl;
+    return 1;
+  }
+
+  return 0;  // Return 0 to indicate successful execution
+}

src/C++/OpenCV/CMakeLists.txt

@@ -1,44 +0,0 @@
-cmake_minimum_required( VERSION 3.6 )
-
-# Require C++11 (or later)
-set( CMAKE_CXX_STANDARD 23 )
-set( CMAKE_CXX_STANDARD_REQUIRED ON )
-set( CMAKE_CXX_EXTENSIONS OFF )
-set(BUILD_MODE Debug)
-# Create Project
-project( Sample )
-add_executable( YOLOv4 util.h main.cpp )
-
-# Set StartUp Project
-set_property( DIRECTORY PROPERTY VS_STARTUP_PROJECT "YOLOv4" )
-
-# Find Package
-# OpenCV
-find_package( OpenCV REQUIRED )
-
-if( OpenCV_FOUND )
-  # Additional Include Directories
-  include_directories( ${OpenCV_INCLUDE_DIRS} )
-
-  # Additional Dependencies
-  target_link_libraries( YOLOv4 ${OpenCV_LIBS} )
-endif()
-
-# Download Model
-set( MODEL https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.weights )
-file( DOWNLOAD 
-  "${MODEL}"
-  "${CMAKE_CURRENT_LIST_DIR}/yolov4.weights"
-  EXPECTED_HASH SHA256=e8a4f6c62188738d86dc6898d82724ec0964d0eb9d2ae0f0a9d53d65d108d562
-  SHOW_PROGRESS
-)
-
-
-# Download Config
-set( CONFIG https://raw.githubusercontent.com/AlexeyAB/darknet/master/cfg/yolov4.cfg )
-file( DOWNLOAD 
-  "${CONFIG}"
-  "${CMAKE_CURRENT_LIST_DIR}/yolov4.cfg"
-  EXPECTED_HASH SHA256=a6d0f8e5c62cc8378384f75a8159b95fa2964d4162e33351b00ac82e0fc46a34
-  SHOW_PROGRESS
-)

src/C++/OpenCV/coco.names

@@ -1,80 +0,0 @@
-person
-bicycle
-car
-motorbike
-aeroplane
-bus
-train
-truck
-boat
-traffic light
-fire hydrant
-stop sign
-parking meter
-bench
-bird
-cat
-dog
-horse
-sheep
-cow
-elephant
-bear
-zebra
-giraffe
-backpack
-umbrella
-handbag
-tie
-suitcase
-frisbee
-skis
-snowboard
-sports ball
-kite
-baseball bat
-baseball glove
-skateboard
-surfboard
-tennis racket
-bottle
-wine glass
-cup
-fork
-knife
-spoon
-bowl
-banana
-apple
-sandwich
-orange
-broccoli
-carrot
-hot dog
-pizza
-donut
-cake
-chair
-sofa
-pottedplant
-bed
-diningtable
-toilet
-tvmonitor
-laptop
-mouse
-remote
-keyboard
-cell phone
-microwave
-oven
-toaster
-sink
-refrigerator
-book
-clock
-vase
-scissors
-teddy bear
-hair drier
-toothbrush

src/C++/OpenCV/main.cpp

@@ -1,209 +0,0 @@
-#include <iostream>
-#include <string>
-#include <vector>
-#include <opencv2/opencv.hpp>
-#include <opencv2/dnn.hpp>
-#include <filesystem>
-#include <fstream>
-
-#include "util.h"
-
-// Helper function to check if a file exists
-bool fileExists(const std::string &path)
-{
-    return std::filesystem::exists(path);
-}
-
-// Function to read class names from a file
-std::vector<std::string> _readClassNameList(const std::string &path)
-{
-    std::vector<std::string> classes;
-
-    // Check if file exists
-    if (!fileExists(path))
-    {
-        throw std::runtime_error("Class names file not found: " + path);
-    }
-
-    // Try to open and read file
-    std::ifstream file(path);
-    if (!file.is_open())
-    {
-        throw std::runtime_error("Unable to open class names file: " + path);
-    }
-
-    std::string line;
-    while (std::getline(file, line))
-    {
-        if (!line.empty())
-        {
-            classes.push_back(line);
-        }
-    }
-
-    if (classes.empty())
-    {
-        throw std::runtime_error("No classes found in file: " + path);
-    }
-
-    return classes;
-}
-
-int main(int argc, char *argv[])
-{
-    try
-    {
-        // Open Video Capture
-        cv::VideoCapture capture = cv::VideoCapture(0);
-        if (!capture.isOpened())
-        {
-            std::cerr << "Failed to open camera device" << std::endl;
-            return -1;
-        }
-
-        // Read Class Name List and Color Table
-        const std::string list = "coco.names";
-        const std::vector<std::string> classes = _readClassNameList(list);
-        const std::vector<cv::Scalar> colors = getClassColors(classes.size());
-
-        // Debug: Print the size of the colors vector
-        std::cout << "Number of colors: " << colors.size() << std::endl;
-
-        // Read Darknet
-        const std::string model = "yolov4.weights";
-        const std::string config = "yolov4.cfg";
-        cv::dnn::Net net = cv::dnn::readNet(model, config);
-        if (net.empty())
-        {
-            std::cerr << "Failed to load network" << std::endl;
-            return -1;
-        }
-
-        // Set Preferable Backend
-        net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
-
-        // Set Preferable Target
-        net.setPreferableTarget(cv::dnn::DNN_TARGET_OPENCL);
-
-        while (true)
-        {
-            // Read Frame
-            cv::Mat frame;
-            capture >> frame;
-            if (frame.empty())
-            {
-                cv::waitKey(0);
-                break;
-            }
-            if (frame.channels() == 4)
-            {
-                cv::cvtColor(frame, frame, cv::COLOR_BGRA2BGR);
-            }
-
-            // Create Blob from Input Image
-            cv::Mat blob = cv::dnn::blobFromImage(frame, 1 / 255.f, cv::Size(416, 416), cv::Scalar(), true, false);
-
-            // Set Input Blob
-            net.setInput(blob);
-
-            // Run Forward Network
-            std::vector<cv::Mat> detections;
-            net.forward(detections, getOutputsNames(net));
-
-            // Draw Region
-            std::vector<int32_t> class_ids;
-            std::vector<float> confidences;
-            std::vector<cv::Rect> rectangles;
-            for (cv::Mat &detection : detections)
-            {
-                if (detection.empty())
-                {
-                    std::cerr << "Detection matrix is empty!" << std::endl;
-                    continue;
-                }
-                for (int32_t i = 0; i < detection.rows; i++)
-                {
-                    cv::Mat region = detection.row(i);
-
-                    // Retrieve Max Confidence and Class Index
-                    cv::Mat scores = region.colRange(5, detection.cols);
-                    cv::Point class_id;
-                    double confidence;
-                    cv::minMaxLoc(scores, 0, &confidence, 0, &class_id);
-
-                    // Check Confidence
-                    constexpr float threshold = 0.2;
-                    if (threshold > confidence)
-                    {
-                        continue;
-                    }
-
-                    // Retrieve Object Position
-                    const int32_t x_center = static_cast<int32_t>(region.at<float>(0) * frame.cols);
-                    const int32_t y_center = static_cast<int32_t>(region.at<float>(1) * frame.rows);
-                    const int32_t width = static_cast<int32_t>(region.at<float>(2) * frame.cols);
-                    const int32_t height = static_cast<int32_t>(region.at<float>(3) * frame.rows);
-                    const cv::Rect rectangle = cv::Rect(x_center - (width / 2), y_center - (height / 2), width, height);
-
-                    // Add Class ID, Confidence, Rectangle
-                    class_ids.push_back(class_id.x);
-                    confidences.push_back(confidence);
-                    rectangles.push_back(rectangle);
-                }
-            }
-
-            // Remove Overlap Rectangles using Non-Maximum Suppression
-            constexpr float confidence_threshold = 0.5; // Confidence
-            constexpr float nms_threshold = 0.5;        // IoU (Intersection over Union)
-            std::vector<int32_t> indices;
-            cv::dnn::NMSBoxes(rectangles, confidences, confidence_threshold, nms_threshold, indices);
-
-            // Draw Rectangle
-            for (const int32_t &index : indices)
-            {
-                // Bounds checking
-                if (class_ids[index] >= colors.size())
-                {
-                    std::cerr << "Color index out of bounds: " << class_ids[index] << " (max: " << colors.size() - 1 << ")" << std::endl;
-                    continue;
-                }
-
-                const cv::Rect rectangle = rectangles[index];
-                const cv::Scalar color = colors[class_ids[index]];
-
-                // Debug: Print the index and color
-                std::cout << "Drawing rectangle with color index: " << class_ids[index] << std::endl;
-
-                constexpr int32_t thickness = 3;
-                cv::rectangle(frame, rectangle, color, thickness);
-
-                std::string label = classes[class_ids[index]] + ": " + std::to_string(static_cast<int>(confidences[index] * 100)) + "%";
-                
-                int baseLine;
-                cv::Size labelSize = cv::getTextSize(label, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
-                int top = std::max(rectangle.y, labelSize.height);
-                cv::rectangle(frame, cv::Point(rectangle.x, top - labelSize.height),
-                              cv::Point(rectangle.x + labelSize.width, top + baseLine), color, cv::FILLED);
-                cv::putText(frame, label, cv::Point(rectangle.x, top), cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(255, 255, 255), 1);
-            }
-
-            // Show Image
-            cv::imshow("Object Detection", frame);
-            const int32_t key = cv::waitKey(1);
-            if (key == 'q')
-            {
-                break;
-            }
-        }
-
-        cv::destroyAllWindows();
-        return 0;
-    }
-    catch (const std::exception &e)
-    {
-        std::cerr << "Error: " << e.what() << std::endl;
-        return -1;
-    }
-}
-
-// cloned and fixed from https://github.com/UnaNancyOwen/OpenCVDNNSample/tree/master

src/C++/OpenCV/util.h

@@ -1,61 +0,0 @@
-#ifndef __UTIL__
-#define __UTIL__
-
-#include <vector>
-#include <string>
-#include <fstream>
-#include <opencv2/dnn.hpp>
-#include <opencv2/core.hpp>
-#include <opencv2/highgui.hpp>
-
-// Get Output Layers Name
-std::vector<std::string> getOutputsNames( const cv::dnn::Net& net )
-{
-    static std::vector<std::string> names;
-    if( names.empty() ){
-        std::vector<int32_t> out_layers = net.getUnconnectedOutLayers();
-        std::vector<std::string> layers_names = net.getLayerNames();
-        names.resize( out_layers.size() );
-        for( size_t i = 0; i < out_layers.size(); ++i ){
-            names[i] = layers_names[out_layers[i] - 1];
-        }
-    }
-    return names;
-}
-
-// Get Output Layer Type
-std::string getOutputLayerType( cv::dnn::Net& net )
-{
-    const std::vector<int32_t> out_layers = net.getUnconnectedOutLayers();
-    const std::string output_layer_type = net.getLayer( out_layers[0] )->type;
-    return output_layer_type;
-}
-
-// Read Class Name List
-std::vector<std::string> readClassNameList( const std::string list_path )
-{
-    std::vector<std::string> classes;
-    std::ifstream ifs( list_path );
-    if( !ifs.is_open() ){
-        return classes;
-    }
-    std::string class_name = "";
-    while( std::getline( ifs, class_name ) ){
-        classes.push_back( class_name );
-    }
-    return classes;
-}
-
-// Get Class Color Table for Visualize
-std::vector<cv::Scalar> getClassColors( const int32_t number_of_colors )
-{
-    cv::RNG random;
-    std::vector<cv::Scalar> colors;
-    for( int32_t i = 0; i < number_of_colors; i++ ){
-        cv::Scalar color( random.uniform( 0, 255 ), random.uniform( 0, 255 ), random.uniform( 0, 255 ) );
-        colors.push_back( color );
-    }
-    return colors;
-}
-
-#endif // __UTIL__

src/Python/flask/web/app.py

@@ -1,38 +1,70 @@
-from flask import Flask, Response, request, render_template, jsonify
+from flask import Flask, request, render_template, jsonify, g
 import paho.mqtt.client as mqtt
+import mysql.connector 
+import json
 
 app = Flask(__name__)
 
-kobuki_message = "empty"
-def on_message(client, userdata, message):
+# Globale variabelen
+kobuki_message = ""
+latest_image = None
+
+# Globale MQTT setup
+def on_message(client,userdata, message):
     global kobuki_message, latest_image
     if message.topic == "kobuki/data":
         kobuki_message = str(message.payload.decode("utf-8"))
+        with app.app_context():
+            sensor_data(kobuki_message)  # Sla de data op in de database
     elif message.topic == "kobuki/cam":
         latest_image = message.payload
 
+
 # Create an MQTT client instance
 mqtt_client = mqtt.Client()
 mqtt_client.username_pw_set("server", "serverwachtwoordofzo")
-mqtt_client.connect("localhost", 80, 60)
+mqtt_client.connect("localhost", 1884, 60)
 mqtt_client.loop_start()
 mqtt_client.subscribe("kobuki/data")
-mqtt_client.subscribe("kobuki/cam")
 
-mqtt_client.on_message = on_message # this lines needs to be under the function definition otherwise it cant find which function it needs to use
+mqtt_client.on_message = on_message  # this line needs to be under the function definition otherwise it can't find which function it needs to use
+
+
+# Database connectie-functie
+def get_db():
+    if 'db' not in g:  # 'g' is specifiek voor een request en leeft zolang een request duurt
+        g.db = mysql.connector.connect(
+            host="127.0.0.1",
+            port=3306,
+            user="admin",
+            password="kobuki",
+            database="kobuki"
+        )
+    return g.db
+
+# Sluit de database na elke request
+@app.teardown_appcontext
+def close_db(error):
+    db = g.pop('db', None)
+    if db is not None:
+        db.close()
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
-
-@app.route('/control', methods=["GET","POST"])
+@app.route('/control', methods=["GET", "POST"])
 def control():
     if request.authorization and request.authorization.username == 'ishak' and request.authorization.password == 'kobuki':
         return render_template('control.html')
     else:
         return ('Unauthorized', 401, {'WWW-Authenticate': 'Basic realm="Login Required"'})
 
+@app.route('/data', methods=['GET'])
+def data():
+    return kobuki_message
+
+
 @app.route('/move', methods=['POST'])
 def move():
     data = request.get_json()
@@ -40,32 +72,60 @@ def move():
 
     # Verstuur de richting via MQTT
     if direction:
-        mqtt_client.publish("home/commands", direction)  # Het topic kan aangepast worden
+        mqtt_client.publish("home/commands", direction)
 
+    db_connection = get_db()
+    cursor = db_connection.cursor()
+    sql_command = "INSERT INTO command (command) VALUES (%s)"
+    cursor.execute(sql_command, (direction,))        
+    
+    db_connection.commit()
+    cursor.close()
+    db_connection.close()
     return jsonify({"status": "success", "direction": direction})
 
+@app.route("/database")
+def database():
+    db = get_db()
+    cursor = db.cursor()
+    cursor.execute("SELECT * FROM kobuki_data")
+    rows = cursor.fetchall()
+    cursor.close()
+    return str(rows)
 
-@app.route('/data', methods=['GET'])
-def data():
-    return kobuki_message
+def sensor_data(kobuki_message):
+    try:
+        # Parse de JSON-string naar een Python-dictionary
+        data = json.loads(kobuki_message)
 
+        # Maak een lijst van tuples met de naam en waarde van elk veld
+        sensor_data_tuples = [(name, float(value)) for name, value in data.items() if isinstance(value, (int, float))]
 
-@app.route('/image')
-def image():
-    global latest_image
-    if latest_image is not None:
-        return Response(latest_image, mimetype='image/jpeg')
-    else:
-        return "No image available", 404
+        # Extra informatie of nested data (zoals "extraInfo" of "gyroData") kun je apart verwerken
+        if "extraInfo" in data:
+            for key, value in data["extraInfo"].items():
+                sensor_data_tuples.append((f"extraInfo_{key}", float(value)))
 
+        if "gyroData" in data:
+            for i, gyro in enumerate(data["gyroData"]):
+                for axis, value in gyro.items():
+                    sensor_data_tuples.append((f"gyroData_{i}_{axis}", float(value)))
 
-@app.route('/phpmyadmin/<path:path>')
-def phpmyadmin_passthrough(path):
-    # Laat Apache deze route direct afhandelen
-    return "", 404
-
+        # Database-insert
+        db = get_db()
+        cursor = db.cursor()
 
+        # Zorg dat je tabel `kobuki_data` kolommen heeft: `name` en `value`
+        sql_sensor = "INSERT INTO kobuki_data (name, value) VALUES (%s, %s)"
+        cursor.executemany(sql_sensor, sensor_data_tuples)
 
+        # Commit en sluit de cursor
+        db.commit()
+        cursor.close()
+    except json.JSONDecodeError as e:
+        print(f"JSON decode error: {e}")
+    except mysql.connector.Error as err:
+        print(f"Database error: {err}")
 
 if __name__ == '__main__':
     app.run(debug=True, port=5000)

src/Python/flask/web/static/script.js

@@ -1,57 +1,41 @@
-document.addEventListener("DOMContentLoaded", function() {
-  document.querySelectorAll(".btn").forEach(button => {
-    button.addEventListener("click", function(event) {
-      event.preventDefault(); // prevents page refresh
+document.querySelectorAll(".btn").forEach(button => {
+  button.addEventListener("click", async function(event) { // Maak de functie async
+    event.preventDefault(); // voorkomt pagina-verversing
 
-      // Get the value of the button
-      const direction = event.target.value;
+    // Haal de waarde van de knop op
+    const direction = event.target.value;
 
-      fetch("/move", {
+    try {
+      const response = await fetch("/move", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({ direction: direction })
-      })
-      .then(response => response.json())
-      .then(data => {script
-        console.log("Success:", data);
-      })
-      .catch(error => {
-        console.error("Error:", error);
       });
-    });
-  });
+      const data = await response.json();
+      console.log("Success:", data);
+    } catch (error) {
+      console.error("Error:", error);
+    }
 
-  // Fetch data from the server
-  async function fetchData() {
-    const response = await fetch("/data");
-    const data = await response.json();
-    return data;
-  }
+    // Fetch data from the server
+    async function fetchData() {
+      const response = await fetch("/data");
+      const data = await response.json();
+      return data;
+    }
 
-  // Parse the data and show it on the website
-  async function parseData() {
+    // Parse the data and show it on the website
     const data = await fetchData();
     const sensorDataContainer = document.getElementById("sensor-data");
     sensorDataContainer.innerHTML = ""; // Clear previous data
-    // For each object in JSON array, create a new paragraph element and append it to the sensorDataContainer
+    //for each object in json array create a new paragraph element and append it to the sensorDataContainer
     for (const [key, value] of Object.entries(data)) {
       const dataElement = document.createElement("p");
       dataElement.textContent = `${key}: ${value}`;
-      sensorDataContainer.appendChild(dataElement);
+      sensorDataContainer.appendChild(dataElement); // Voeg het element toe aan de container
     }
-  }
+  });
+});
 
-  // Update the image
-  function updateImage() {
-    var img = document.getElementById("robot-image");
-    img.src = "/image?" + new Date().getTime(); // Add timestamp to avoid caching
-  }
-
-  // Fetch and display sensor data every 5 seconds
-  setInterval(parseData, 1000);
-
-  // Update the image every 5 seconds
-  setInterval(updateImage, 200);
-});

src/Python/flask/web/static/style.css

@@ -167,4 +167,4 @@ th,td {
 th {
   background-color: #f2f2f2;
   text-align: left;
-}
+}

src/config/mosquitto.conf

@@ -1,7 +0,0 @@
-allow_anonymous false
-password_file /etc/mosquitto/passwordfile
-listener 8080
-protocol websockets
-
-listener 1884
-protocol mqtt

src/config/nginx-sites.conf

@@ -1,22 +0,0 @@
-server {
-    listen 80;
-    server_name 145.92.224.21;
-
-    # Proxy WebSocket connections for MQTT
-    location /ws/ {
-        proxy_pass http://localhost:9001;
-        proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_set_header Host $host;
-    }
-
-    # Proxy HTTP connections for Flask
-    location / {
-        proxy_pass http://localhost:5000;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}

src/config/nginx.conf

@@ -1,7 +0,0 @@
-stream {
-    server {
-        listen 9001;
-        proxy_pass localhost:8080;
-    }
-}
-

teamdocumentatie/Ishak/etische_aspecten.md

@@ -0,0 +1,25 @@
+#  Etische aspecten van het project
+
+## Visie op de ethische aspecten van het Kobuki-project
+
+Etische aspecten zijn heel belangrijk in het project, al ben ik wel van mening dat je niet alles kan voorkomen en ook kan waarborgen.
+
+## Privacy
+
+Als je bijvoorbeeld kijkt naar het gedeelte privacy, dan is het heel moeilijk om te kijken wat je gaat doen met die gegevens. Ik ga een camera gebruiken op de robot om zo te kijken 
+waar de robot is en wat hij allemaal ziet. Als de robot in een brandende huis komt en dan een persoon ziet, is het wel belangrijk om die persoon goed te kunnen zien. Je zou dan niet kunnen zeggen dat je die persoon bijvoorbeeld moet vervagen, want je moet wel kunnen zien wat de status is van die persoon.
+Ook is het dan belangrijk om te kijken wat je met die gegevens gaat doen, ga je ze opslaan voor eventuele later gebruik of verwijder je ze direct. Het is heel lastig te bepalen wanneer je op zo een moment privacy schendt. 
+
+## Betrouwbaarheid
+
+Ik vind dat je de betrouwbaarheid van de robot wel moet waarborgen,
+want als ik de robot in een brandend huis stuur en hij valt uit, dan kan dat heel gevaarlijk zijn voor de persoon die in dat huis zit. Daar vind ik dat je meer rekening mee moet houden dan met de privacy van de persoon. Het is de bedoeling dat de robot hulpmedewerkers gaat helpen en niet hun werk moeilijker maakt.
+
+## Impact op hulpverleners & maatschappij
+
+Als meerdere hulpmedewerkers de robot gaan gebruiken en het word een soort van standaard, dan is het wel belangrijk dat de robot betrouwbaar is en dat je erop kan vertrouwen. Het gaat immers om mensenlevens en dat is wel het belangrijkste. Het is uiteindelijk de bedoeling dat de robot hulpverleners zal helpen en niet hun werk lastiger moet maken. Als de robot een standaard hulpmiddel wordt moet hij wel gebruiksvriendelijk zijn en goed kunnen helpen. De robot moet ook zo goed mogelijk werken om zo de vertrouwen te behouden van de mensen. Als de robot fouten blijft maken en niet betrouwbaar is zullen minder mensen het gebruiken. Ik vind dan ook dat de gebruik van de robot heel transparant moet zijn. Hoe word de robot aangestuurd, hoe vergelijkt hij situaties en hoe hij daarmee omgaat. 
+Als je daar al heel duidelijk in bent bouw je al wat sneller vertrouwen van de mensen op. 
+
+Ik vind dat in dit project de ethische aspecten heel belangrijk zijn en dat je daar ook rekening mee moet houden. 
+Bij betrouwbaarheid en de impact die de robot kan hebben op de maatschappij en de hulpverleners moet je wel goed over nadenken. 
+Je werkt immers met mensenlevens en dat is wel het belangrijkste. Privacy is ook heel belangrijk, maar ik vind dat je daar wel wat soepeler mee om kan gaan.

teamdocumentatie/Ishak/expert.md

@@ -0,0 +1,7 @@
+# feedback
+
+- schrijf altijd in je code waarvan je de library importeert. Dit is handig voor jezelf en voor anderen die je code lezen.
+- Meer comments in je code zouden handig zijn om te begrijpen wat je code doet.
+- Database: timestamp voor wanneer je een record toevoegt in je command.
+- Kobuki sensor data ook opslaan in de database.
+- 

teamdocumentatie/Ishak/motivatie.md

@@ -0,0 +1,21 @@
+Motivation Letter
+
+16/12/2024
+
+Cognizant Digital StudioAttn. Hayo Rubingh
+
+Subject: Internship Application Cognizant Digital Studio
+
+Dear Mr. Rubingh,
+
+With great enthusiasm, I am applying for the internship position at Cognizant Digital Studio in Amsterdam. As a second-year bachelor’s student in Technische Informatica(Computer Science) at Hogeschool Van Amsterdam, I am seeking a challenging internship where I can combine my technical skills with my passion for innovation. Cognizant’s focus  IoT, and technology prototypes fits perfectly with my interests .
+
+Throughout my studies, I have gained experience in software development, including Python and JavaScript, and have worked with IoT devices such as Arduino/ESP. What drives me is the opportunity to create and develop new solutions that can make life easier and more efficient. I am particularly interested in the field of IoT and the possibilities it offers for creating smart solutions. I am eager to learn more about the latest technologies and how they can be applied in real-world projects.
+
+I am available to start in February 2025 and look forward to contributing to innovative projects.
+
+I would be delighted to discuss my motivation and experience further in a personal interview. You can find my contact details in my CV. Thank you for considering my application. I am looking forward to hearing from you.
+
+Yours sincerely,
+
+Ishak Jmilou

teamdocumentatie/Ishak/verslag.md

@@ -0,0 +1,64 @@
+![alt text](images/image.png)
+
+# Welke communicatieprotocol geeft de mogelijkheid om veilig en betrouwbaar te communiceren tussen IoT apparaten?
+
+Auteur: Ishak Jmilou
+
+Datum: 17-12-2024
+
+
+
+---
+
+
+## Inleiding
+
+In dit verslag wordt er gekeken naar de verschillende communicatieprotocollen die gebruikt kunnen worden om veilig en betrouwbaar te communiceren tussen IoT apparaten. Er wordt gekeken naar de verschillende protocollen en de voor- en nadelen van elk protocol.
+
+---
+
+# Samenvatting
+
+In dit verslag worden de communicatieprotocollen MQTT, HTTP, WebSockets en CoAP vergeleken op het gebied van veilige en betrouwbare communicatie tussen IoT-apparaten. Veilige communicatie omvat gegevensversleuteling en authenticatie, terwijl betrouwbaarheid verwijst naar het verzenden en ontvangen van gegevens zonder verlies. Op basis van deze overwegingen wordt MQTT aanbevolen voor situaties waar zowel veiligheid als betrouwbaarheid cruciaal zijn in IoT-communicatie.
+
+## 1. Wat houdt veilige en betrouwbare communicatie tussen apparaten in?
+
+Als je werkt met IoT-apparaten, is het belangrijk dat de communicatie tussen deze apparaten veilig en betrouwbaar is. Iot-apparaten verzamelen gegevens over de omgeving en communiceert deze tussen apparaten over het internet. Als deze communicatie niet veilig is, kunnen hackers deze gegevens onderscheppen en gebruiken(Ministerie van Algemene Zaken, 2022). Je wilt voorkomen dat hackers toegang krijgen tot gevoelige informatie zoals persoonlijke gegevens of bedrijfsgeheimen. Daarom is het belangrijk dat de communicatie tussen apparaten veilig en betrouwbaar is. Een protocol is een set regels die bepalen hoe apparaten met elkaar communiceren. Er zijn verschillende protocollen die gebruikt kunnen worden om veilig en betrouwbaar te communiceren tussen IoT-apparaten.
+
+## 2. Welke protocollen zijn er om veilig en betrouwbaar te communiceren tussen apparaten?
+
+Een communicatieprotocol is een set regels die bepalen hoe apparaten met elkaar communiceren(Paul Christiano, 2023). Er is voor elk project een ander protocol dat het beste past. In dit geval is het belangrijk dat de communicatie veilig en betrouwbaar is. De protocollen die ik ga vergelijken zijn MQTT, HTTP, WebSockets en CoAP. Wat belangrijk is om te onderzoeken is hoe de protocollen omgaan met veiligheid en betrouwbaarheid. Veiligheid kan worden bereikt door gegevens te versleutelen en te authenticeren. Betrouwbaarheid kan worden bereikt door gegevens te verzenden en te ontvangen zonder verlies.(Paul Christiano, 2023).
+
+## 3. Wat zijn de voor- en nadelen van de verschillende protocollen?
+
+![alt text](image.png)
+
+Zoals te zien is in de tabel is CoAP minder betrouwbaar dan de andere protocollen. Dit komt, omdat CoAP gebruik maakt van UDP wat ervoor zorgt dat het sneller is maar niet betrouwbaar met de berichten die hij stuurt(Darek Fanton, 2023). Websockets is een goede protocol alleen is het niet altijd geschikt voor lichtgewicht apparaten. HTTP maakt gebruik van TCP wat betrouwbaar is, maar het nadeel van HTTP is dat het elke keer een nieuwe verbinding moet maken. Dit kan een probleem zijn als je veel berichten moet versturen. MQTT is een lichtgewicht protocol dat betrouwbaar is en verschillende niveaus van kwaliteit van de berichten ondersteunt. Het is ook mogelijk om gegevens te versleutelen en te authenticeren met MQTT. Dit maakt het een goede keuze voor veilige en betrouwbare communicatie tussen IoT-apparaten.
+
+## 4. Conclusie
+
+Er zijn verschillende protocollen die goed gebruikt kunnen worden voor IoT apparaten. Aangezien voor mijn project veiligheid en betrouwbaarheid op één staat heb ik gekozen voor MQTT. Dit protocol is lichtgewicht, betrouwbaar en ondersteunt verschillende niveaus van kwaliteit van de berichten. Het is ook mogelijk om gegevens te versleutelen en te authenticeren met MQTT. Dit maakt het een goede keuze voor veilige en betrouwbare communicatie tussen IoT-apparaten.
+
+## literatuurlijst
+
+- Singh, S., & Jyoti. (2024, June 7). Secure Communications Protocols for IoT networks: a survey. https://journal.ijprse.com/index.php/ijprse/article/view/1082
+  
+- Nguyen, K. T., Laurent, M., Oualha, N., CEA, & Institut Mines-Telecom. (2015). Survey on secure communication protocols for the Internet of Things. In Ad Hoc Networks (Vol. 32, pp. 17–31) [Journal-article]. http://dx.doi.org/10.1016/j.adhoc.2015.01.006
+
+- Miorandi, D., Sicari, S., De Pellegrini, F., & Imrich Chlamtac. (2012). Internet of things: Vision, applications and research challenges. In Ad Hoc Networks (Vol. 10, pp. 1497–1516) [Journal-article]. Elsevier B.V. http://dx.doi.org/10.1016/j.adhoc.2012.02.016
+
+- Christiano, P. (2023, November 5). Top 9 IoT communication protocols & their features in 2024: An In-Depth guide - ExpertBeacon. Expertbeacon. https://expertbeacon.com/iot-communication-protocol/
+
+- Yugha, R., & Chithra, S. (2020). A survey on technologies and security protocols: Reference for future generation IoT. Journal of Network and Computer Applications, 169, 102763. https://doi.org/10.1016/j.jnca.2020.102763
+
+- De Mendizábal, I. (2022, June 16). IoT Communication Protocols—IoT Data Protocols. Technical Articles. https://www.allaboutcircuits.com/technical-articles/internet-of-things-communication-protocols-iot-data-protocols/
+
+- IoT-technologieën en -protocollen | Microsoft Azure. (n.d.). https://azure.microsoft.com/nl-nl/solutions/iot/iot-technology-protocols
+
+- Darek Fanton(2024, Juli 11). Het IoT verbinden: wat is MQTT en waarin verschilt het van CoAP? (n.d.). https://www.onlogic.com/nl/blog/het-iot-verbinden-wat-is-mqtt-en-waarin-verschilt-het-van-coap/
+
+- Nader, K. (2023, October 30). Wat zijn de voordelen van het gebruik van WebSocket voor IoT-communicatie? AppMaster - Ultimate All-in No-code Platform. https://appmaster.io/nl/blog/websocket-voor-iot-communicatie
+
+- Sidna, J., Amine, B., Abdallah, N., & Alami, H. E. (2020). Analysis and evaluation of communication Protocols for IoT Applications. Karbala International Journal of Modern Science. https://doi.org/10.1145/3419604.3419754
+
+- Ministerie van Algemene Zaken. (2022, February 8). Hoe kan ik slimme apparaten veilig gebruiken? Rijksoverheid.nl. https://www.rijksoverheid.nl/onderwerpen/bescherming-van-consumenten/vraag-en-antwoord/hoe-kan-ik-slimme-apparaten-veilig-gebruiken