feat(driver_ultrasonic_valeo):add a new driver,but not finished and need to be test

src/driver/driver_ultrasonic_dauxi_KS136A/can_producer_consumer.cpp

@@ -80,7 +80,7 @@ iv::can::canraw CAN_Producer_Consumer::Consume_Element(void)
     return xraw;
 }
 
-iv::can::canraw CAN_Producer_Consumer::Consume_Element(int timeout)
+iv::can::canraw CAN_Producer_Consumer::Consume_Element(const int timeout)
 {
     iv::can::canraw xraw;
     bool tempResult = usedSpace.tryAcquire(1,timeout);

src/driver/driver_ultrasonic_dauxi_KS136A/can_producer_consumer.h

@@ -15,7 +15,7 @@ public:
     uint64_t Produce_Elements(const iv::can::canmsg &xmsg,const int &size); //return the position of first element int this storage
     uint64_t Produce_Elements_From_CANMsg(const iv::can::canmsg &xmsg); //return the position of first element int this storage
     iv::can::canraw Consume_Element(void);
-    iv::can::canraw Consume_Element(int timeout); //not block mode
+    iv::can::canraw Consume_Element(const int timeout); //not block mode
     iv::can::canmsg Consume_Elements(const int &size);
     uint64_t Consume_Element_To_CANMsg(iv::can::canmsg &xmsg); //return the position of the consumed element
     uint64_t Consume_Element_To_CANMsg(iv::can::canmsg &xmsg,int timeout); //not block mode

src/driver/driver_ultrasonic_dauxi_KS136A/canrecv_consumer.cpp

@@ -84,7 +84,7 @@ void CANRecv_Consumer::run()
                     sonarSend_Lock.lock();
                     objDist_Send.clear();
                     sensorStatus_Send.clear();
-                    objDist_Send.swap(objDist);
+                    objDist_Send.swap(objDist); // notice, this function will exchange vectors with each other
                     sensorStatus_Send.swap(sensorStatus);
                     sonarSend_Lock.unlock();
                     emit UltrasonicData_Ready();
@@ -133,7 +133,7 @@ void CANRecv_Consumer::run()
                             sonarSend_Lock.lock();
                             objDist_Send.clear();
                             sensorStatus_Send.clear();
-                            objDist_Send.swap(objDist);
+                            objDist_Send.swap(objDist); // notice, this function will exchange vectors with each other
                             sensorStatus_Send.swap(sensorStatus);
                             sonarSend_Lock.unlock();
                             emit UltrasonicData_Ready();

src/driver/driver_ultrasonic_valeo_GUMK_HP/byte_qvector_producer_consumer.cpp

@@ -0,0 +1,49 @@
+#include "byte_qvector_producer_consumer.h"
+
+Byte_Qvector_Producer_Consumer::Byte_Qvector_Producer_Consumer(const int bufSize)
+{
+    bufferSize = bufSize;
+    buffer.resize(bufferSize);
+    freeSpace.release(bufferSize);
+}
+
+uint64_t Byte_Qvector_Producer_Consumer::Produce_Element(const QVector<uint8_t> &xdata)
+{
+    uint64_t tempPtr = producerPtr % bufferSize;
+    freeSpace.acquire();
+    producerLock.lock();
+    buffer[producerPtr++ % bufferSize] = xdata;
+    producerLock.unlock();
+    usedSpace.release();
+
+    return tempPtr;
+}
+
+QVector<uint8_t> Byte_Qvector_Producer_Consumer::Consume_Element(void)
+{
+    QVector<uint8_t> xdata;
+    usedSpace.acquire(); //this function is block mode
+    consumerLock.lock();
+    xdata = buffer.at(consumerPtr++ % bufferSize);
+    consumerLock.unlock();
+    freeSpace.release();
+
+    return xdata;
+}
+
+QVector<uint8_t> Byte_Qvector_Producer_Consumer::Consume_Element(const int timeout)
+{
+    QVector<uint8_t> xdata;
+    bool tempResult = usedSpace.tryAcquire(1,timeout);
+    if(tempResult)
+    {
+        consumerLock.lock();
+        xdata = buffer.at(consumerPtr++ % bufferSize);
+        consumerLock.unlock();
+        freeSpace.release();
+    }
+    else
+        xdata.clear();
+
+    return xdata;
+}

src/driver/driver_ultrasonic_valeo_GUMK_HP/byte_qvector_producer_consumer.h

@@ -0,0 +1,28 @@
+#ifndef BYTE_QVECTOR_PRODUCER_CONSUMER_H
+#define BYTE_QVECTOR_PRODUCER_CONSUMER_H
+
+#include <QSemaphore>
+#include <QMutex>
+#include <QVector>
+
+class Byte_Qvector_Producer_Consumer
+{
+public:
+    Byte_Qvector_Producer_Consumer(const int bufSize = 4096);
+    uint64_t Produce_Element(const QVector<uint8_t> &xdata); //return the position of first element int this storage
+    QVector<uint8_t> Consume_Element(void);
+    QVector<uint8_t> Consume_Element(const int timeout); //not block mode
+
+    QVector<QVector<uint8_t>> buffer;
+
+private:
+    uint16_t bufferSize = 4096;
+    QSemaphore freeSpace;
+    QSemaphore usedSpace;
+    uint64_t producerPtr = 0;
+    QMutex producerLock;
+    uint64_t consumerPtr = 0;
+    QMutex consumerLock;
+};
+
+#endif // BYTE_QVECTOR_PRODUCER_CONSUMER_H

src/driver/driver_ultrasonic_valeo_GUMK_HP/can_producer_consumer.cpp

@@ -0,0 +1,142 @@
+#include "can_producer_consumer.h"
+
+#include <iostream>
+
+CAN_Producer_Consumer::CAN_Producer_Consumer(const int bufSize)
+{
+    bufferSize = bufSize;
+    buffer.resize(bufferSize);
+    freeSpace.release(bufferSize);
+}
+
+uint64_t CAN_Producer_Consumer::Produce_Element(const iv::can::canraw &xraw) //return the position of first element int this storage
+{
+    uint64_t tempPtr = producerPtr % bufferSize;
+    freeSpace.acquire();
+    producerLock.lock();
+    buffer[producerPtr++ % bufferSize] = xraw;
+    producerLock.unlock();
+    usedSpace.release();
+
+    return tempPtr;
+}
+
+uint64_t CAN_Producer_Consumer::Produce_Elements(const iv::can::canmsg &xmsg,const int &size)
+{
+    uint64_t tempPtr = producerPtr % bufferSize;
+    if(size < xmsg.rawmsg_size())
+    {
+        std::cout<<"Warning! the input size is less than the number of message element."<<std::endl;
+        freeSpace.acquire(size);
+        producerLock.lock();
+        for(int i=0;i<size;i++)
+        {
+            buffer[producerPtr++ % bufferSize] = xmsg.rawmsg(i);
+        }
+        producerLock.unlock();
+        usedSpace.release(size);
+    }
+    else
+    {
+        if(size > xmsg.rawmsg_size())
+            std::cout<<"Warning! the input size is more than the number of message element."<<std::endl;
+        freeSpace.acquire(xmsg.rawmsg_size());
+        producerLock.lock();
+        for(int i=0;i<xmsg.rawmsg_size();i++)
+        {
+            buffer[producerPtr++ % bufferSize] = xmsg.rawmsg(i);
+        }
+        producerLock.unlock();
+        usedSpace.release(xmsg.rawmsg_size());
+    }
+
+    return tempPtr;
+}
+
+uint64_t CAN_Producer_Consumer::Produce_Elements_From_CANMsg(const iv::can::canmsg &xmsg)
+{
+    uint64_t tempPtr = producerPtr % bufferSize;
+    freeSpace.acquire(xmsg.rawmsg_size());
+    producerLock.lock();
+    for(int i=0;i<xmsg.rawmsg_size();i++)
+    {
+        buffer[producerPtr++ % bufferSize] = xmsg.rawmsg(i);
+    }
+    producerLock.unlock();
+    usedSpace.release(xmsg.rawmsg_size());
+
+    return tempPtr;
+}
+
+iv::can::canraw CAN_Producer_Consumer::Consume_Element(void)
+{
+    iv::can::canraw xraw;
+    usedSpace.acquire(); //this function is block mode
+    consumerLock.lock();
+    xraw = buffer.at(consumerPtr++ % bufferSize);
+    consumerLock.unlock();
+    freeSpace.release();
+
+    return xraw;
+}
+
+iv::can::canraw CAN_Producer_Consumer::Consume_Element(const int timeout)
+{
+    iv::can::canraw xraw;
+    bool tempResult = usedSpace.tryAcquire(1,timeout);
+    if(tempResult)
+    {
+        consumerLock.lock();
+        xraw = buffer.at(consumerPtr++ % bufferSize);
+        consumerLock.unlock();
+        freeSpace.release();
+    }
+    else
+        xraw.Clear();
+
+    return xraw;
+}
+
+iv::can::canmsg CAN_Producer_Consumer::Consume_Elements(const int &size)
+{
+    iv::can::canmsg xmsg;
+    usedSpace.acquire(size); //this function is block mode
+    consumerLock.lock();
+    for(int i=0;i<size;i++)
+    {
+        xmsg.add_rawmsg()->CopyFrom(buffer.at(consumerPtr++ % bufferSize));
+    }
+    consumerLock.unlock();
+    freeSpace.release(size);
+
+    return xmsg;
+}
+
+uint64_t CAN_Producer_Consumer::Consume_Element_To_CANMsg(iv::can::canmsg &xmsg)
+{
+    uint64_t tempPtr = consumerPtr % bufferSize;
+    usedSpace.acquire(); //this function is block mode
+    iv::can::canraw *praw = xmsg.add_rawmsg();
+    consumerLock.lock();
+    praw->CopyFrom(buffer.at(consumerPtr++ % bufferSize));
+    consumerLock.unlock();
+    freeSpace.release();
+
+    return tempPtr;
+}
+
+uint64_t CAN_Producer_Consumer::Consume_Element_To_CANMsg(iv::can::canmsg &xmsg,int timeout)
+{
+    uint64_t tempPtr = consumerPtr % bufferSize;
+    bool tempResult = usedSpace.tryAcquire(1,timeout); //this function is block mode
+    if(tempResult)
+    {
+        iv::can::canraw *praw = xmsg.add_rawmsg();
+        consumerLock.lock();
+        praw->CopyFrom(buffer.at(consumerPtr++ % bufferSize));
+        consumerLock.unlock();
+        freeSpace.release();
+    }
+
+    return tempPtr;
+}

src/driver/driver_ultrasonic_valeo_GUMK_HP/can_producer_consumer.h

@@ -0,0 +1,35 @@
+#ifndef CAN_PRODUCER_CONSUMER_H
+#define CAN_PRODUCER_CONSUMER_H
+
+#include <QSemaphore>
+#include <QMutex>
+#include <QVector>
+
+#include "canmsg.pb.h"
+
+class CAN_Producer_Consumer
+{
+public:
+    CAN_Producer_Consumer(const int bufSize = 4096);
+    uint64_t Produce_Element(const iv::can::canraw &xraw); //return the position of first element int this storage
+    uint64_t Produce_Elements(const iv::can::canmsg &xmsg,const int &size); //return the position of first element int this storage
+    uint64_t Produce_Elements_From_CANMsg(const iv::can::canmsg &xmsg); //return the position of first element int this storage
+    iv::can::canraw Consume_Element(void);
+    iv::can::canraw Consume_Element(const int timeout); //not block mode
+    iv::can::canmsg Consume_Elements(const int &size);
+    uint64_t Consume_Element_To_CANMsg(iv::can::canmsg &xmsg); //return the position of the consumed element
+    uint64_t Consume_Element_To_CANMsg(iv::can::canmsg &xmsg,int timeout); //not block mode
+
+    QVector<iv::can::canraw> buffer;
+
+private:
+    uint16_t bufferSize = 4096;
+    QSemaphore freeSpace;
+    QSemaphore usedSpace;
+    uint64_t producerPtr = 0;
+    QMutex producerLock;
+    uint64_t consumerPtr = 0;
+    QMutex consumerLock;
+};
+
+#endif // CAN_PRODUCER_CONSUMER_H

src/driver/driver_ultrasonic_valeo_GUMK_HP/canrecv_consumer.cpp

@@ -0,0 +1,150 @@
+#include "canrecv_consumer.h"
+
+#include "math.h"
+
+extern setupConfig_t setupConfig;
+extern iv::msgunit shmSonar;
+
+extern Byte_Qvector_Producer_Consumer SDIDataRecv;
+extern Byte_Qvector_Producer_Consumer FreeSpaceDataRecv;
+
+//#define RESULT_OUTPUT_ENABLE
+
+CANRecv_Consumer::CANRecv_Consumer(CAN_Producer_Consumer *pBuf)
+{
+    pBuffer = pBuf;
+
+    QObject::connect(this,&CANRecv_Consumer::SDI_Data_Ready,this,&CANRecv_Consumer::SDI_Data_Ready_Slot);
+    QObject::connect(this,&CANRecv_Consumer::FreeSpace_Data_Ready,this,&CANRecv_Consumer::FreeSpace_Data_Ready_Slot);
+
+    SDI_data.fill(0x00,2048);
+    freeSpace_data.fill(0x00,2048);
+}
+
+CANRecv_Consumer::~CANRecv_Consumer()
+{
+    requestInterruption();
+    while(this->isFinished() == false);
+}
+
+void CANRecv_Consumer::Clear_CAN_PrivateTempVariable(void)
+{
+    CAN_ID = 0x000u;
+    CAN_DLC = 0;
+    for(int i=0;i<8;i++) CAN_data[i] = 0x00;
+}
+
+uint32_t CANRecv_Consumer::Trans_From_CANRaw(const iv::can::canraw &xraw) //only for standard data frame, return can id
+{
+    this->Clear_CAN_PrivateTempVariable();
+    CAN_ID = xraw.id();
+    CAN_DLC = xraw.len();
+    for(int i=0;i<CAN_DLC;i++)
+    {
+        CAN_data[i] = xraw.data()[i];
+    }
+
+    return CAN_ID;
+}
+
+void CANRecv_Consumer::run()
+{
+    iv::can::canraw tempCANRaw;
+
+    while (!QThread::isInterruptionRequested())
+    {
+        tempCANRaw.CopyFrom(pBuffer->Consume_Element()); // tempCANRaw is unnecessary to clear, Consume_Element may return an empty data
+        if(tempCANRaw.id() == 0x600)
+        {
+            SDI_data.clear();
+            SDI_data.fill(0x00,2048);
+            Trans_From_CANRaw(tempCANRaw);
+            SDI_data_ptr = 0;
+            SDI_msg_CNT = CAN_data[3]<<8 | CAN_data[2];
+            SDI_payload_size = CAN_data[1]<<8 | CAN_data[0];
+            SDI_recvStatus = RecevingData;
+        }
+        else if(SDI_recvStatus == RecevingData && tempCANRaw.id() > 0x600 && tempCANRaw.id() < 0x700)
+        {
+            Trans_From_CANRaw(tempCANRaw);
+            uint16_t tempMsgCnt = CAN_ID - 0x600;
+            if(tempMsgCnt <= SDI_msg_CNT)
+            {
+                for(int i=0;i<CAN_DLC;i++)
+                {
+                    SDI_data[SDI_data_ptr] = CAN_data[i];
+                    SDI_data_ptr +=1;
+                }
+                if(SDI_data_ptr != 0 && tempMsgCnt >= SDI_msg_CNT && SDI_data_ptr >= SDI_payload_size)
+                {
+                    SDI_data_fine_lock.lock();
+                    SDI_data_fine.swap(SDI_data);
+                    SDI_data_fine_lock.unlock();
+                    emit SDI_Data_Ready();
+                    SDI_recvStatus = WaitingMsgHeader;
+                }
+            }
+            else
+            {
+                SDI_data_ptr = 0;
+                SDI_msg_CNT = 0;
+                SDI_payload_size = 0;
+                SDI_recvStatus = WaitingMsgHeader;
+            }
+        }
+        else if(tempCANRaw.id() == 0x700)
+        {
+            freeSpace_data.clear();
+            freeSpace_data.fill(0x00,2048);
+            Trans_From_CANRaw(tempCANRaw);
+            freeSpace_data_ptr = 0;
+            freeSpace_msg_CNT = CAN_data[3]<<8 | CAN_data[2];
+            freeSpace_payload_size = CAN_data[1]<<8 | CAN_data[0];
+            freeSpace_recvStatus = RecevingData;
+        }
+        else if(freeSpace_recvStatus == RecevingData && tempCANRaw.id() > 0x700 && tempCANRaw.id() < 0x800)
+        {
+            Trans_From_CANRaw(tempCANRaw);
+            uint16_t tempMsgCnt = CAN_ID - 0x600;
+            if(tempMsgCnt <= freeSpace_msg_CNT)
+            {
+                for(int i=0;i<CAN_DLC;i++)
+                {
+                    freeSpace_data[freeSpace_data_ptr] = CAN_data[i];
+                    freeSpace_data_ptr +=1;
+                }
+                if(freeSpace_data_ptr != 0 && tempMsgCnt >= freeSpace_msg_CNT && freeSpace_data_ptr >= freeSpace_payload_size)
+                {
+                    freeSpace_data_fine_lock.lock();
+                    freeSpace_data_fine.swap(freeSpace_data);
+                    freeSpace_data_fine_lock.unlock();
+                    emit FreeSpace_Data_Ready();
+                    freeSpace_recvStatus = WaitingMsgHeader;
+                }
+            }
+            else
+            {
+                freeSpace_data_ptr = 0;
+                freeSpace_msg_CNT = 0;
+                freeSpace_payload_size = 0;
+                freeSpace_recvStatus = WaitingMsgHeader;
+            }
+        }
+    }
+}
+
+void CANRecv_Consumer::SDI_Data_Ready_Slot(void)
+{
+    SDI_data_fine_lock.lock();
+    SDIDataRecv.Produce_Element(SDI_data_fine);
+    SDI_data_fine.clear();
+    SDI_data_fine_lock.unlock();
+}
+
+void CANRecv_Consumer::FreeSpace_Data_Ready_Slot(void)
+{
+    freeSpace_data_fine_lock.lock();
+    FreeSpaceDataRecv.Produce_Element(SDI_data_fine);
+    freeSpace_data_fine.clear();
+    freeSpace_data_fine_lock.unlock();
+}

src/driver/driver_ultrasonic_valeo_GUMK_HP/canrecv_consumer.h

@@ -0,0 +1,67 @@
+#ifndef CANRECV_CONSUMER_H
+#define CANRECV_CONSUMER_H
+
+#include <QObject>
+#include <QTimer>
+#include <QDateTime>
+#include <QThread>
+
+#include "modulecomm.h"
+#include "ultrasonic.pb.h"
+
+#include "can_producer_consumer.h"
+#include "byte_qvector_producer_consumer.h"
+#include "decode_cfg.h"
+#include "iv_msgunit.h"
+
+enum dataRecvStatus
+{
+    WaitingMsgHeader,
+    RecevingData
+};
+
+class CANRecv_Consumer : public QThread
+{
+    Q_OBJECT
+public:
+    CANRecv_Consumer(CAN_Producer_Consumer *pBuf);
+    ~CANRecv_Consumer();
+    void Clear_CAN_PrivateTempVariable(void);
+
+protected:
+    void run();
+    uint32_t Trans_From_CANRaw(const iv::can::canraw &xraw); //only for standard data frame, return can id
+
+signals:
+    void SDI_Data_Ready(void);
+    void FreeSpace_Data_Ready(void);
+
+private slots:
+    void SDI_Data_Ready_Slot(void);
+    void FreeSpace_Data_Ready_Slot(void);
+
+private:
+    CAN_Producer_Consumer *pBuffer;
+
+    uint32_t CAN_ID = 0x000u;
+    uint8_t CAN_DLC = 0;
+    uint8_t CAN_data[8] = {0};
+
+    QVector<uint8_t> SDI_data;
+    uint16_t SDI_data_ptr = 0;
+    uint16_t SDI_msg_CNT = 0;
+    uint16_t SDI_payload_size = 0;
+    dataRecvStatus SDI_recvStatus = WaitingMsgHeader;
+    QVector<uint8_t> freeSpace_data;
+    uint16_t freeSpace_data_ptr = 0;
+    uint16_t freeSpace_msg_CNT = 0;
+    uint16_t freeSpace_payload_size = 0;
+    dataRecvStatus freeSpace_recvStatus = WaitingMsgHeader;
+
+    QVector<uint8_t> SDI_data_fine;
+    QMutex SDI_data_fine_lock;
+    QVector<uint8_t> freeSpace_data_fine;
+    QMutex freeSpace_data_fine_lock;
+};
+
+#endif // CANRECV_CONSUMER_H

src/driver/driver_ultrasonic_valeo_GUMK_HP/decode_cfg.cpp

@@ -0,0 +1,17 @@
+#include "decode_cfg.h"
+
+int DecodeSonarCfgFromXML(setupConfig_t &setupConfig , const std::string &xmlFilePath)
+{
+    iv::xmlparam::Xmlparam xp(xmlFilePath);
+
+    setupConfig.strMemCANRecv = xp.GetParam("canrecv_shm","canrecv0");
+    setupConfig.strMemCANSend = xp.GetParam("cansend_shm","cansend0");
+    setupConfig.strMemSonar = xp.GetParam("sonar_shm","sonar");
+//    setupConfig.sonarCAN_ID = std::strtoul(xp.GetParam("sonarCAN_ID","0x101").c_str(),0,0);
+
+//    std::cout<<"canrecv_shm : "<<setupConfig.strMemCANRecv<<std::endl;
+//    std::cout<<"cansend_shm : "<<setupConfig.strMemCANSend<<std::endl;
+//    std::cout<<"sonarCAN_ID : "<<setupConfig.sonarCAN_ID<<std::endl;
+
+    return 0;
+}

src/driver/driver_ultrasonic_valeo_GUMK_HP/decode_cfg.h

@@ -0,0 +1,19 @@
+#ifndef DECODE_CFG_H
+#define DECODE_CFG_H
+
+#include <iostream>
+
+#include "xmlparam.h"
+#include <yaml-cpp/yaml.h>
+
+struct setupConfig_t
+{
+    std::string strMemCANRecv = "canrecv0";
+    std::string strMemCANSend = "cansend0";
+    std::string strMemSonar = "sonar";
+//    uint32_t sonarCAN_ID = 0x301;
+};
+
+int DecodeSonarCfgFromXML(setupConfig_t &setupConfig , const std::string &xmlFilePath);
+
+#endif // DECODE_CFG_H

src/driver/driver_ultrasonic_valeo_GUMK_HP/driver_ultrasonic_valeo_GUMK_HP.pro

@@ -0,0 +1,55 @@
+QT -= gui
+
+QT += xml dbus
+CONFIG += c++11 console
+CONFIG -= app_bundle
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which as been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+QMAKE_LFLAGS += -no-pie
+
+SOURCES += \
+        ../../include/msgtype/canmsg.pb.cc \
+        ../../include/msgtype/canraw.pb.cc \
+        ../../include/msgtype/ultrasonic.pb.cc \
+        can_producer_consumer.cpp \
+        canrecv_consumer.cpp \
+        decode_cfg.cpp \
+        main.cpp \
+    byte_qvector_producer_consumer.cpp
+
+HEADERS += \
+    ../../include/msgtype/canmsg.pb.h \
+    ../../include/msgtype/canraw.pb.h \
+    ../../include/msgtype/ultrasonic.pb.h \
+    can_producer_consumer.h \
+    canrecv_consumer.h \
+    decode_cfg.h \
+    iv_msgunit.h \
+    byte_qvector_producer_consumer.h
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+!include(../../../include/common.pri ) {
+    error( "Couldn't find the common.pri file!" )
+}
+
+!include(../../../include/ivprotobuf.pri ) {
+    error( "Couldn't find the ivprotobuf.pri file!" )
+}
+
+!include(../../../include/ivyaml-cpp.pri ) {
+    error( "Couldn't find the ivyaml-cpp.pri file!" )
+}

src/driver/driver_ultrasonic_valeo_GUMK_HP/driver_ultrasonic_valeo_GUMK_HP.xml

@@ -0,0 +1,7 @@
+<xml>	
+	<node name="driver_ultrasonic_dauxi_KS136A">
+		<param name="canrecv_shm" value="canrecv0" />
+		<param name="cansend_shm" value="cansend0" />
+		<param name="sonar_shm" value="sonar" />
+	</node>
+</xml>

src/driver/driver_ultrasonic_valeo_GUMK_HP/driver_ultrasonic_valeo_GUMK_HP/.gitignore

@@ -0,0 +1,73 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

src/driver/driver_ultrasonic_valeo_GUMK_HP/driver_ultrasonic_valeo_GUMK_HP/driver_ultrasonic_valeo_GUMK_HP.pro

@@ -0,0 +1,17 @@
+QT -= gui
+
+CONFIG += c++11 console
+CONFIG -= app_bundle
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which as been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += main.cpp

src/driver/driver_ultrasonic_valeo_GUMK_HP/driver_ultrasonic_valeo_GUMK_HP/main.cpp

@@ -0,0 +1,8 @@
+#include <QCoreApplication>
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    return a.exec();
+}

src/driver/driver_ultrasonic_valeo_GUMK_HP/iv_msgunit.h

@@ -0,0 +1,21 @@
+#ifndef IV_MSGUNIT_H
+#define IV_MSGUNIT_H
+
+#include <memory>
+
+namespace iv {
+struct msgunit
+{
+    char mstrmsgname[256];
+    int mnBufferSize = 10000;
+    int mnBufferCount = 1;
+    void * mpa = nullptr;
+    std::shared_ptr<char> mpstrmsgdata;
+    int mndatasize = 0;
+    bool mbRefresh = false;
+    bool mbImportant = false;
+    int mnkeeptime = 100;
+};
+}
+
+#endif // IV_MSGUNIT_H

src/driver/driver_ultrasonic_valeo_GUMK_HP/main.cpp

@@ -0,0 +1,126 @@
+#include <QCoreApplication>
+
+#include <iostream>
+#include <thread>
+
+#include "modulecomm.h"
+#include "ivversion.h"
+#include "ivbacktrace.h"
+#include "ivfault.h"
+#include "ivlog.h"
+#include "ivexit.h"
+
+#include "canmsg.pb.h"
+
+#include "decode_cfg.h"
+#include "iv_msgunit.h"
+#include "can_producer_consumer.h"
+#include "byte_qvector_producer_consumer.h"
+#include "canrecv_consumer.h"
+
+QCoreApplication * gApp;
+
+iv::Ivfault *gfault = nullptr;
+iv::Ivlog *givlog = nullptr;
+
+setupConfig_t setupConfig;
+
+iv::msgunit shmCANRecv;
+//iv::msgunit shmCANSend;
+iv::msgunit shmSonar;
+
+CAN_Producer_Consumer CANRecv(4096);
+//CAN_Producer_Consumer CANSend(4096);
+
+Byte_Qvector_Producer_Consumer SDIDataRecv(128);
+Byte_Qvector_Producer_Consumer FreeSpaceDataRecv(128);
+
+//CANSend_Producer* can_send_producer;
+//CANSend_Consumer* can_send_consumer;
+CANRecv_Consumer* can_recv_consumer;
+
+void ListenCANMsg(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
+{
+    if(nSize<1)
+    {
+        std::cout<<"radar ListenCANMsg data empty."<<std::endl;
+        return;
+    }
+    iv::can::canmsg xmsg;
+    if(!xmsg.ParseFromArray(strdata,nSize))
+    {
+        givlog->error("radar Listencanmsg fail");
+        gfault->SetFaultState(1, 0, "radar Listencanmsg error");
+        std::cout<<"radar ListenCANMsg parse fail."<<std::endl;
+        return;
+    }
+    CANRecv.Produce_Elements_From_CANMsg(xmsg);
+}
+
+void ExitFunc()
+{
+    gApp->quit();
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+}
+
+void signal_handler(int sig)
+{
+    if(sig == SIGINT)
+    {
+        ExitFunc();
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    RegisterIVBackTrace();
+    showversion("driver_ultrasonic_valeo_GUMK_HP");
+    QCoreApplication a(argc, argv);
+
+    givlog = new iv::Ivlog("driver_ultrasonic_valeo_GUMK_HP");
+    gfault = new iv::Ivfault("driver_ultrasonic_valeo_GUMK_HP");
+
+    signal(SIGINT,signal_handler);
+
+    QString strpath = QCoreApplication::applicationDirPath();
+    if(argc < 2)
+        strpath = strpath + "/driver_ultrasonic_valeo_GUMK_HP.xml";
+    else
+        strpath = argv[1];
+
+    DecodeSonarCfgFromXML(setupConfig,strpath.toStdString());
+
+//    strncpy(shmCANSend.mstrmsgname,setupConfig.strMemCANSend.data(),255);
+//    shmCANSend.mnBufferSize = 100000;
+//    shmCANSend.mnBufferCount = 3;
+//    shmCANSend.mpa = iv::modulecomm::RegisterSend(shmCANSend.mstrmsgname,shmCANSend.mnBufferSize,shmCANSend.mnBufferCount);
+
+    strncpy(shmSonar.mstrmsgname,setupConfig.strMemSonar.data(),255);
+    shmSonar.mnBufferSize = 100000;
+    shmSonar.mnBufferCount = 1;
+    shmSonar.mpa = iv::modulecomm::RegisterSend(shmSonar.mstrmsgname,shmSonar.mnBufferSize,shmSonar.mnBufferCount);
+
+    strncpy(shmCANRecv.mstrmsgname,setupConfig.strMemCANRecv.data(),255);
+    shmCANRecv.mnBufferSize = 100000;
+    shmCANRecv.mnBufferCount = 3;
+    shmCANRecv.mpa = iv::modulecomm::RegisterRecv(shmCANRecv.mstrmsgname,ListenCANMsg);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(250));
+
+    can_recv_consumer = new CANRecv_Consumer(&CANRecv);
+    can_recv_consumer->start();
+
+    int rtn = a.exec();
+
+//    can_send_producer->terminate(); //function "terminate" can not be used in other position. it is dangerous.
+//    can_send_consumer->terminate(); //function "terminate" can not be used in other position. it is dangerous.
+    can_recv_consumer->terminate(); //function "terminate" can not be used in other position. it is dangerous.
+
+    if(gfault != nullptr)delete gfault;
+    if(givlog != nullptr)delete givlog;
+    if(shmCANRecv.mpa != nullptr)iv::modulecomm::Unregister(shmCANRecv.mpa);
+//    if(shmCANSend.mpa != nullptr)iv::modulecomm::Unregister(shmCANSend.mpa);
+    if(shmSonar.mpa != nullptr)iv::modulecomm::Unregister(shmSonar.mpa);
+
+    return rtn;
+}