Dev

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "MiddleWare/Libs"]
+	path = MiddleWare/Libs
+	url = git@github.com:SEAME-pt/Team02-Libs.git

CMakeLists.txt

@@ -1,27 +1,30 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.10)
 
-project(HelloQt6 LANGUAGES CXX)
-message("CMAKE_SYSROOT " ${CMAKE_SYSROOT})
-message("CMAKE_LIBRARY_ARCHITECTURE " ${CMAKE_LIBRARY_ARCHITECTURE})
-set(CMAKE_CXX_STANDARD 11)
+project(Cluster LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(zenohc_DIR "/usr/local/lib/cmake/zenohc")
+set(zenohcxx_DIR "/usr/local/lib/cmake/zenohcxx")
 
-find_package(Qt6 COMPONENTS Core Quick DBus SerialBus REQUIRED)
+find_package(Qt6 COMPONENTS Core Quick DBus REQUIRED)
+find_package(zenohc REQUIRED)
+find_package(zenohcxx REQUIRED)
 
-set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wl,-rpath-link, ${CMAKE_SYSROOT}/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE} -L${CMAKE_SYSROOT}/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wl,-rpath-link,${CMAKE_SYSROOT}/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE} -L${CMAKE_SYSROOT}/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}")
-# Enable automatic MOC, UIC, and RCC processing
+# Enable Qt's Automatic MOC, UIC, and RCC
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOUIC ON)
 set(CMAKE_AUTORCC ON)
 
-qt_add_resources(QT_RESOURCES ./src/resources.qrc)
+# Add Resource File (QML and Other Resources)
+qt_add_resources(QT_RESOURCES ./ui/resources.qrc)
 
-add_executable(speedometer ${QT_RESOURCES} 
+# Define Executable Target
+add_executable(InstrumentCluster
+    ${QT_RESOURCES}
     ./src/main.cpp
-    ./src/CANBusHandler.cpp
-    ./include/CANBusHandler.hpp
+    ./src/InstrumentCluster.cpp
+    ./include/InstrumentCluster.hpp
 )
 
-target_link_libraries(speedometer -lm -ldl Qt6::Core Qt6::DBus Qt6::Quick Qt6::SerialBus)
-
+target_link_libraries(InstrumentCluster zenohcxx::zenohc -lm -ldl Qt6::Core Qt6::DBus Qt6::Quick)

MiddleWare/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(Middelware LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(zenohc_DIR "/usr/local/lib/cmake/zenohc")
+set(zenohcxx_DIR "/usr/local/lib/cmake/zenohcxx")
+
+find_package(zenohc REQUIRED)
+find_package(zenohcxx REQUIRED)
+
+add_executable(middleWare
+    ./src/main.cpp
+)
+
+target_link_libraries(middleWare PRIVATE zenohcxx::zenohc)

MiddleWare/src/main.cpp

@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <iostream>
+#include <string.h>
+#include <sys/socket.h>
+#include <linux/can.h>
+#include <linux/can/raw.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include "zenoh.hxx"
+
+using namespace zenoh;
+
+int main(int argc, char** argv)
+{
+    struct ifreq ifr;
+    struct sockaddr_can addr;
+
+    int canSocket = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+    if (canSocket < 0)
+    {
+        std::cerr << "Cannot create CAN socket!" << std::endl;
+        exit(-1);
+    }
+
+    strcpy(ifr.ifr_name, "can0");
+    ioctl(canSocket, SIOCGIFINDEX, &ifr);
+
+    addr.can_family  = AF_CAN;
+    addr.can_ifindex = ifr.ifr_ifindex;
+    if (bind(canSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0)
+    {
+        std::cerr << "Cannot bind CAN socket!" << std::endl;
+        close(canSocket);
+        exit(1);
+    }
+
+    std::cout << "CAN socket bound to can0 interface successfully."
+              << std::endl;
+
+    Config config = Config::create_default();
+    auto session  = Session::open(std::move(config));
+
+    auto pubSpeed =
+        session.declare_publisher(KeyExpr("seame/car/1/speedSensor"));
+    auto pubBattery =
+        session.declare_publisher(KeyExpr("seame/car/1/batterySensor"));
+
+    while (1)
+    {
+        struct can_frame frame;
+
+        int nbytes = read(canSocket, &frame, sizeof(struct can_frame));
+        if (nbytes < 0)
+        {
+            std::cerr << "Error reading CAN frame!" << std::endl;
+            continue;
+        }
+        if (frame.can_id == 0x01)
+        {
+            int speed;
+            double wheelDiame = 0.067;
+
+            memcpy(&speed, frame.data, sizeof(int));
+            speed                 = ntohl(speed);
+            speed                 = wheelDiame * 3.14 * speed * 10 / 60;
+            std::string speed_str = std::to_string(speed);
+
+            printf("Publishing speed: '%d'\n", speed);
+            pubSpeed.put(speed_str.c_str());
+        }
+        else if (frame.can_id == 0x02)
+        {
+            int battery;
+            memcpy(&battery, frame.data, sizeof(int));
+            battery                 = ntohl(battery);
+            std::string battery_str = std::to_string(battery);
+
+            printf("Publishing battery: '%d\n", battery);
+            pubBattery.put(battery_str.c_str());
+        }
+        usleep(10);
+    }
+    return 0;
+}

include/InstrumentCluster.hpp

@@ -0,0 +1,97 @@
+#ifndef INSTRUMENTCLUSTER_HPP
+#define INSTRUMENTCLUSTER_HPP
+
+#include <QObject>
+#include <iostream>
+#include "zenoh.hxx"
+
+using namespace zenoh;
+
+class InstrumentCluster : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int speed READ getSpeed NOTIFY speedChanged)
+    Q_PROPERTY(int battery READ getBattery NOTIFY batteryChanged)
+    Q_PROPERTY(
+        bool rightBlinker READ getRightBlinker NOTIFY rightBlinkerChanged)
+    Q_PROPERTY(bool leftBlinker READ getLeftBlinker NOTIFY leftBlinkerChanged)
+    Q_PROPERTY(bool lowBeam READ getLowBeam NOTIFY lowBeamChanged)
+    Q_PROPERTY(bool highBeam READ getHighBeam NOTIFY highBeamChanged)
+    Q_PROPERTY(
+        bool frontFogLight READ getFrontFogLight NOTIFY frontFogLightChanged)
+    Q_PROPERTY(
+        bool readFogLight READ getRearFogLight NOTIFY rearFogLightChanged)
+    Q_PROPERTY(bool hazardLight READ getHazardLight NOTIFY hazardLightChanged)
+    Q_PROPERTY(
+        bool parkingLight READ getParkingLight NOTIFY parkingLightChanged)
+    Q_PROPERTY(GearPosition gear READ getGear NOTIFY gearChanged)
+
+  public:
+    enum class GearPosition
+    {
+        PARK,
+        REVERSE,
+        NEUTRAL,
+        DRIVE
+    };
+
+    Q_ENUM(GearPosition)
+
+  private:
+    int m_speed;
+    int m_battery;
+    bool m_rightBlinker;
+    bool m_leftBlinker;
+    bool m_lowBeam;
+    bool m_highBeam;
+    bool m_frontFogLight;
+    bool m_rearFogLight;
+    bool m_hazardLight;
+    bool m_parkingLight;
+    GearPosition m_gear;
+
+    Session& m_session;
+
+  public:
+    explicit InstrumentCluster(Session& session, QObject* parent = nullptr);
+    ~InstrumentCluster();
+
+    int getSpeed() const;
+    int getBattery() const;
+    bool getRightBlinker() const;
+    bool getLeftBlinker() const;
+    bool getLowBeam() const;
+    bool getHighBeam() const;
+    bool getFrontFogLight() const;
+    bool getRearFogLight() const;
+    bool getHazardLight() const;
+    bool getParkingLight() const;
+    GearPosition getGear() const;
+
+    void setSpeed(int speed);
+    void setBattery(int battery);
+    void setRightBlinker(bool rightBlinker);
+    void setLeftBlinker(bool leftBlinker);
+    void setLowBeam(bool lowBeam);
+    void setHighBeam(bool highBeam);
+    void setFrontFogLight(bool frontFogLight);
+    void setRearFogLight(bool readFogLight);
+    void setHazardLight(bool hazardLight);
+    void setParkingLight(bool parkingLight);
+    void setGear(GearPosition gear);
+
+  signals:
+    void speedChanged(int speed);
+    void batteryChanged(int battery);
+    void rightBlinkerChanged(bool rightBlinker);
+    void leftBlinkerChanged(bool leftBlinker);
+    void lowBeamChanged(bool lowBeam);
+    void highBeamChanged(bool highBeam);
+    void frontFogLightChanged(bool frontFogLight);
+    void rearFogLightChanged(bool readFogLight);
+    void hazardLightChanged(bool hazardLight);
+    void parkingLightChanged(bool parkingLight);
+    void gearChanged(GearPosition gear);
+};
+
+#endif // INSTRUMENTCLUSTER_HPP