diff --git a/device/devicefinder.cpp b/device/devicefinder.cpp index bdec096..b4d1bcb 100644 --- a/device/devicefinder.cpp +++ b/device/devicefinder.cpp @@ -42,6 +42,10 @@ static std::vector supportedDevices = { RADGalaxy::DEVICE_TYPE, #endif + #ifdef __RADGIGALOG_ETH_H_ + RADGigalogETH::DEVICE_TYPE, + #endif + #ifdef __RADPLUTOUSB_H_ RADPlutoUSB::DEVICE_TYPE, #endif @@ -128,6 +132,10 @@ std::vector> DeviceFinder::FindAll() { findResults.push_back(RADGalaxy::Find(pcapDevices)); #endif + #ifdef __RADGIGALOG_ETH_H_ + findResults.push_back(RADGigalogETH::Find(pcapDevices)); + #endif + #ifdef __RADPLUTOUSB_H_ findResults.push_back(RADPlutoUSB::Find()); #endif diff --git a/include/icsneo/device/tree/radgigalog/radgigalog.h b/include/icsneo/device/tree/radgigalog/radgigalog.h new file mode 100644 index 0000000..4af8ba2 --- /dev/null +++ b/include/icsneo/device/tree/radgigalog/radgigalog.h @@ -0,0 +1,83 @@ +#ifndef __RADGIGALOG_H_ +#define __RADGIGALOG_H_ + +#ifdef __cplusplus + +#include "icsneo/device/device.h" +#include "icsneo/device/devicetype.h" +#include "icsneo/device/tree/radgigalog/radgigalogsettings.h" + +namespace icsneo { + +class RADGigalog : public Device { +public: + static constexpr DeviceType::Enum DEVICE_TYPE = DeviceType::RADGigalog; + static constexpr const char* SERIAL_START = "RG"; + +protected: + RADGigalog(neodevice_t neodevice) : Device(neodevice) { + getWritableNeoDevice().type = DEVICE_TYPE; + } + + void setupPacketizer(Packetizer& packetizer) override { + Device::setupPacketizer(packetizer); + packetizer.disableChecksum = true; + packetizer.align16bit = false; + } + + void setupDecoder(Decoder& decoder) override { + Device::setupDecoder(decoder); + decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns + } + + void setupEncoder(Encoder& encoder) override { + Device::setupEncoder(encoder); + encoder.supportCANFD = true; + } + + void setupSupportedRXNetworks(std::vector& rxNetworks) override { + static std::vector supportedRxNetworks = { + Network::NetID::HSCAN, + Network::NetID::MSCAN, + Network::NetID::HSCAN2, + Network::NetID::HSCAN3, + Network::NetID::HSCAN4, + Network::NetID::HSCAN5, + Network::NetID::HSCAN6, + Network::NetID::HSCAN7, + + Network::NetID::Ethernet, + + Network::NetID::LIN, + + Network::NetID::FlexRay + }; + rxNetworks.insert(rxNetworks.end(), supportedRxNetworks.begin(), supportedRxNetworks.end()); + } + + void setupSupportedTXNetworks(std::vector& txNetworks) override { + static std::vector supportedTxNetworks = { + Network::NetID::HSCAN, + Network::NetID::MSCAN, + Network::NetID::HSCAN2, + Network::NetID::HSCAN3, + Network::NetID::HSCAN4, + Network::NetID::HSCAN5, + Network::NetID::HSCAN6, + Network::NetID::HSCAN7, + + Network::NetID::Ethernet, + + Network::NetID::LIN + + // FlexRay is Receive Only + }; + txNetworks.insert(txNetworks.end(), supportedTxNetworks.begin(), supportedTxNetworks.end()); + } +}; + +} + +#endif // __cplusplus + +#endif \ No newline at end of file diff --git a/include/icsneo/device/tree/radgigalog/radgigalogeth.h b/include/icsneo/device/tree/radgigalog/radgigalogeth.h new file mode 100644 index 0000000..ab0baeb --- /dev/null +++ b/include/icsneo/device/tree/radgigalog/radgigalogeth.h @@ -0,0 +1,58 @@ +#ifndef __RADGIGALOG_ETH_H_ +#define __RADGIGALOG_ETH_H_ + +#ifdef __cplusplus + +#include "icsneo/device/tree/radgigalog/radgigalog.h" +#include "icsneo/platform/pcap.h" + +namespace icsneo { + +class RADGigalogETH : public RADGigalog { +public: + static constexpr const uint16_t PRODUCT_ID = 0x000A; + static std::vector> Find(const std::vector& pcapDevices) { + std::vector> found; + + for(auto& foundDev : pcapDevices) { + auto fakedev = std::shared_ptr(new RADGigalogETH({})); + for (auto& payload : foundDev.discoveryPackets) + fakedev->com->packetizer->input(payload); + for (auto& packet : fakedev->com->packetizer->output()) { + std::shared_ptr msg; + if (!fakedev->com->decoder->decode(msg, packet)) + continue; // We failed to decode this packet + + if(!msg || msg->network.getNetID() != Network::NetID::Main51) + continue; // Not a message we care about + auto sn = std::dynamic_pointer_cast(msg); + if(!sn) + continue; // Not a serial number message + + if(sn->deviceSerial.length() < 2) + continue; + if(sn->deviceSerial.substr(0, 2) != SERIAL_START) + continue; // Not a RADGigalog + + auto device = foundDev.device; + device.serial[sn->deviceSerial.copy(device.serial, sizeof(device.serial))] = '\0'; + found.push_back(std::shared_ptr(new RADGigalogETH(std::move(device)))); + break; + } + } + + return found; + } + +private: + RADGigalogETH(neodevice_t neodevice) : RADGigalog(neodevice) { + initialize(); + productId = PRODUCT_ID; + } +}; + +} + +#endif // __cplusplus + +#endif \ No newline at end of file diff --git a/include/icsneo/device/tree/radgigalog/radgigalogsettings.h b/include/icsneo/device/tree/radgigalog/radgigalogsettings.h new file mode 100644 index 0000000..d2f6590 --- /dev/null +++ b/include/icsneo/device/tree/radgigalog/radgigalogsettings.h @@ -0,0 +1,293 @@ +#ifndef __RADGIGALOGSETTINGS_H_ +#define __RADGIGALOGSETTINGS_H_ + +#include +#include "icsneo/device/idevicesettings.h" + +#ifdef __cplusplus + +namespace icsneo { + +#endif + +#pragma pack(push, 2) +#define SERDESCAM_SETTINGS_FLAG_ENABLE 0x01 +#define SERDESCAM_SETTINGS_RTSP_ENABLE 0x02 +#define SERDESCAM_SETTINGS_AUTO_DETECT_ENABLE 0x04 +#define SERDESCAM_SETTINGS_CONFIG_ENABLE 0x08 + +/* mode in SERDESCAM_SETTINGS */ +enum +{ + SERDESCAM_MODE_PASSTHROUGH = 0, + SERDESCAM_MODE_TAP, + SERDESCAM_MODE_PLAYBACK, +}; + +/* ucCamConfigMode in SERDESCAM_SETTINGS */ +enum +{ + SERDESCAM_CONFIG_MODE_EXTERNAL_OVER_TAP = 0, + SERDESCAM_CONFIG_MODE_LOCAL_SCRIPT, +}; + +/* bitPos in SERDESCAM_SETTINGS */ +enum +{ + SERDESCAM_PIXEL_BIT_POS_0 = 0, + SERDESCAM_PIXEL_BIT_POS_1, + SERDESCAM_PIXEL_BIT_POS_2, + SERDESCAM_PIXEL_BIT_POS_3, +}; + +/* videoFormat in SERDESCAM_SETTINGS */ +enum +{ + SERDESCAM_VIDEO_FORMAT_NONE = -1, + SERDESCAM_VIDEO_FORMAT_UYVY_422_8 = 0, // packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 + SERDESCAM_VIDEO_FORMAT_YUYV_422_8, // packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr + SERDESCAM_VIDEO_FORMAT_YVYU_422_8, // packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb + SERDESCAM_VIDEO_FORMAT_VYUY_422_8, // packed YUV 4:2:2, 16bpp, Cr Y0 Cb Y1 + SERDESCAM_VIDEO_FORMAT_BAYER_BGGR_8, + SERDESCAM_VIDEO_FORMAT_RAW_8, // e.g. bayer 8 bit, gray 8 bit + SERDESCAM_VIDEO_FORMAT_RAW_10, // e.g. bayer 10 bit, gray 10 bit + SERDESCAM_VIDEO_FORMAT_RAW_12, + SERDESCAM_VIDEO_FORMAT_RAW_16, // e.g. planar YUV 4:2:2, 16bpp, 8 bit samples + SERDESCAM_VIDEO_FORMAT_RAW_20, // e.g. planar YUV 4:2:2, 20bpp, 10 bit samples + SERDESCAM_VIDEO_FORMAT_RAW_24, // e.g. packed RGB 8:8:8 24bpp, 8 bit samples + SERDESCAM_VIDEO_FORMAT_RAW_30, // e.g. planar YUV 4:4:4, 30bpp, 10 bit samples + SERDESCAM_VIDEO_FORMAT_RAW_32, // e.g. packed ARGB 8:8:8:8, 32bpp, 8 bit samples + SERDESCAM_VIDEO_FORMAT_RAW_36, + SERDESCAM_VIDEO_FORMAT_RGB888, // packed RGB 8:8:8, 24bpp, RGBRGB... + SERDESCAM_VIDEO_FORMAT_UYVY_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Cb Y0 Cr Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_YUYV_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Y0 Cb Y1 Cr, FOURCC Y210 bitpacked + SERDESCAM_VIDEO_FORMAT_YVYU_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Y0 Cr Y1 Cb, bitpacked + SERDESCAM_VIDEO_FORMAT_VYUY_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Cr Y0 Cb Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_BAYER_BGGR_10LE_PACKED,// 10-bit samples bitpacked into 40-bits little endian + SERDESCAM_VIDEO_FORMAT_BAYER_BGGR_12LE_PACKED,// 12-bit samples bitpacked into 40-bits little endian + SERDESCAM_VIDEO_FORMAT_BAYER_BGGR_16LE,// 16-bit samples little endian + SERDESCAM_VIDEO_FORMAT_BAYER_BGGR_16BE,// 16-bit samples big endian + SERDESCAM_VIDEO_FORMAT_JPEG, + SERDESCAM_VIDEO_FORMAT_UYVY_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Cb Y0 Cr Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_YUYV_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Y0 Cb Y1 Cr, bitpacked + SERDESCAM_VIDEO_FORMAT_YVYU_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Y0 Cr Y1 Cb, bitpacked + SERDESCAM_VIDEO_FORMAT_VYUY_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Cr Y0 Cb Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_YUV422_10LE_PLANAR,// planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + SERDESCAM_VIDEO_FORMAT_YUV422_16LE_PLANAR,// planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + SERDESCAM_VIDEO_FORMAT_RGB565, // packed RGB 5:6:5, 16bpp, RGBRGB... + SERDESCAM_VIDEO_FORMAT_RGB666, // packed RGB 6:6:6, 18bpp, RGBRGB... + SERDESCAM_VIDEO_FORMAT_RAW_11x2, + SERDESCAM_VIDEO_FORMAT_RAW_12x2, + SERDESCAM_VIDEO_FORMAT_RAW_14, + // NOTE: CSI2 formats are only used internal to VSPY + // Firmware should flag video as CSI2 source types + // Vspy will then convert formats into the proper CSI2 version + SERDESCAM_VIDEO_FORMAT_CSI2_UYVY_422_8, // packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 + SERDESCAM_VIDEO_FORMAT_CSI2_YUYV_422_8, // packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr + SERDESCAM_VIDEO_FORMAT_CSI2_YVYU_422_8, // packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb + SERDESCAM_VIDEO_FORMAT_CSI2_VYUY_422_8, // packed YUV 4:2:2, 16bpp, Cr Y0 Cb Y1 + SERDESCAM_VIDEO_FORMAT_CSI2_UYVY_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Cb Y0 Cr Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_YUYV_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Y0 Cb Y1 Cr, FOURCC Y210 bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_YVYU_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Y0 Cr Y1 Cb, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_VYUY_422_10LE_PACKED,// packed YUV 4:2:2, 20bpp, Cr Y0 Cb Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_UYVY_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Cb Y0 Cr Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_YUYV_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Y0 Cb Y1 Cr, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_YVYU_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Y0 Cr Y1 Cb, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_VYUY_422_12LE_PACKED,// packed YUV 4:2:2, 24bpp, Cr Y0 Cb Y1, bitpacked + SERDESCAM_VIDEO_FORMAT_CSI2_RGB565, // packed RGB 5:6:5, 16bpp, BGRBGR... + SERDESCAM_VIDEO_FORMAT_CSI2_RGB666, // packed RGB 6:6:6, 18bpp, BGRBGR... + SERDESCAM_VIDEO_FORMAT_CSI2_RGB888, // packed RGB 8:8:8, 24bpp, BGRBGR... + SERDESCAM_VIDEO_FORMAT_CSI2_BAYER_BGGR_8, + SERDESCAM_VIDEO_FORMAT_CSI2_BAYER_BGGR_10LE_PACKED,// 10-bit samples bitpacked into 40-bits little endian + SERDESCAM_VIDEO_FORMAT_CSI2_BAYER_BGGR_12LE_PACKED,// 12-bit samples bitpacked into 40-bits little endian + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_8, // e.g. bayer 8 bit, gray 8 bit + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_10, // e.g. bayer 10 bit, gray 10 bit + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_11x2, + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_12, + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_12x2, + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_14, + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_16, // e.g. planar YUV 4:2:2, 16bpp, 8 bit samples + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_20, // e.g. planar YUV 4:2:2, 20bpp, 10 bit samples + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_24, // e.g. packed RGB 8:8:8 24bpp, 8 bit samples + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_30, // e.g. planar YUV 4:4:4, 30bpp, 10 bit samples + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_32, // e.g. packed ARGB 8:8:8:8, 32bpp, 8 bit samples + SERDESCAM_VIDEO_FORMAT_CSI2_RAW_36, + // NOTE: new entries must be appended to maintain backwards compatibility + // insert new entries before this + SERDESCAM_VIDEO_FORMAT_COUNT, +}; + +typedef struct SERDESCAM_SETTINGS_t +{ + /* bit0: enable + * bit1: RTSP stream enable + * bit2: auto detect resolution + */ + uint32_t flags; + uint8_t mode;// passthrough, tap, etc + uint8_t rsvd1; + uint8_t bitPos; + uint8_t videoFormat;// bytes per pixel + uint16_t resWidth; + uint16_t resHeight; + uint8_t frameSkip;// skip every nth frame + uint8_t rsvd2[19]; +} SERDESCAM_SETTINGS; +#define SERDESCAM_SETTINGS_SIZE 32 + +#define SERDESPOC_SETTINGS_MODE_DISABLED 0x00 +#define SERDESPOC_SETTINGS_MODE_SUPPLY 0x01 +#define SERDESPOC_SETTINGS_MODE_SERIALIZER 0x02 + +typedef struct SERDESPOC_SETTINGS_t +{ + uint8_t mode;// no poc, generated supply, serializer passthrough + uint8_t rsvd[6]; + uint8_t voltage;// generated voltage + uint16_t chksum;// checksum to protect settings structure (don't want corrupt voltage settings) +} SERDESPOC_SETTINGS; +#define SERDESPOC_SETTINGS_SIZE 10 + +typedef struct { + uint32_t ecu_id; + + uint16_t perf_en; + + CAN_SETTINGS can1; + CANFD_SETTINGS canfd1; + CAN_SETTINGS can2; + CANFD_SETTINGS canfd2; + CAN_SETTINGS can3; + CANFD_SETTINGS canfd3; + CAN_SETTINGS can4; + CANFD_SETTINGS canfd4; + CAN_SETTINGS can5; + CANFD_SETTINGS canfd5; + CAN_SETTINGS can6; + CANFD_SETTINGS canfd6; + CAN_SETTINGS can7; + CANFD_SETTINGS canfd7; + CAN_SETTINGS can8; + CANFD_SETTINGS canfd8; + + uint16_t network_enables; + uint16_t network_enables_2; + + uint32_t pwr_man_timeout; + uint16_t pwr_man_enable; + + uint16_t network_enabled_on_boot; + + uint16_t iso15765_separation_time_offset; + + uint16_t iso_9141_kwp_enable_reserved; + ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_1; + uint16_t iso_parity_1; + + uint16_t iso_msg_termination_1; + + uint16_t idle_wakeup_network_enables_1; + uint16_t idle_wakeup_network_enables_2; + + uint16_t network_enables_3; + uint16_t idle_wakeup_network_enables_3; + + STextAPISettings text_api; + uint64_t termination_enables; + uint8_t rsvd1[8];// previously ETHERNET_SETTINGS + uint8_t rsvd2[8];// previously ETHERNET10G_SETTINGS + + DISK_SETTINGS disk; + + TIMESYNC_ICSHARDWARE_SETTINGS timeSyncSettings; + struct + { + uint16_t hwComLatencyTestEn : 1; + uint16_t disableUsbCheckOnBoot : 1; + uint16_t reserved : 14; + } flags; + ETHERNET_SETTINGS2 ethernet; + + SERDESCAM_SETTINGS serdescam1; + ETHERNET10G_SETTINGS ethernet10g; + + LIN_SETTINGS lin1; + + SERDESPOC_SETTINGS serdespoc; + LOGGER_SETTINGS logger; + SERDESCAM_SETTINGS serdescam2; + SERDESCAM_SETTINGS serdescam3; + SERDESCAM_SETTINGS serdescam4; + + ETHERNET_SETTINGS2 ethernet2; + uint16_t network_enables_4; + RAD_REPORTING_SETTINGS reporting; +} radgigalog_settings_t; +#pragma pack(pop) + +#ifdef __cplusplus + +static_assert(sizeof(radgigalog_settings_t) == 666, "RADGigalog settings size mismatch"); + +#include + +class RADGigalogSettings : public IDeviceSettings { +public: + RADGigalogSettings(std::shared_ptr com) : IDeviceSettings(com, sizeof(radgigalog_settings_t)) {} + const CAN_SETTINGS* getCANSettingsFor(Network net) const override { + auto cfg = getStructurePointer(); + if(cfg == nullptr) + return nullptr; + switch(net.getNetID()) { + case Network::NetID::HSCAN: + return &(cfg->can1); + case Network::NetID::MSCAN: + return &(cfg->can2); + case Network::NetID::HSCAN2: + return &(cfg->can3); + case Network::NetID::HSCAN3: + return &(cfg->can4); + case Network::NetID::HSCAN4: + return &(cfg->can5); + case Network::NetID::HSCAN5: + return &(cfg->can6); + case Network::NetID::HSCAN6: + return &(cfg->can7); + case Network::NetID::HSCAN7: + return &(cfg->can8); + default: + return nullptr; + } + } + const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override { + auto cfg = getStructurePointer(); + if(cfg == nullptr) + return nullptr; + switch(net.getNetID()) { + case Network::NetID::HSCAN: + return &(cfg->canfd1); + case Network::NetID::MSCAN: + return &(cfg->canfd2); + case Network::NetID::HSCAN2: + return &(cfg->canfd3); + case Network::NetID::HSCAN3: + return &(cfg->canfd4); + case Network::NetID::HSCAN4: + return &(cfg->canfd5); + case Network::NetID::HSCAN5: + return &(cfg->canfd6); + case Network::NetID::HSCAN6: + return &(cfg->canfd7); + case Network::NetID::HSCAN7: + return &(cfg->canfd8); + default: + return nullptr; + } + } +}; + +} + +#endif // __cplusplus + +#endif \ No newline at end of file diff --git a/include/icsneo/platform/windows/devices.h b/include/icsneo/platform/windows/devices.h index 1f47641..1179f48 100644 --- a/include/icsneo/platform/windows/devices.h +++ b/include/icsneo/platform/windows/devices.h @@ -10,6 +10,7 @@ #include "icsneo/device/tree/plasion/neoviion.h" #include "icsneo/device/tree/plasion/neoviplasma.h" #include "icsneo/device/tree/radgalaxy/radgalaxy.h" +#include "icsneo/device/tree/radgigalog/radgigalogeth.h" #include "icsneo/device/tree/radpluto/radplutousb.h" #include "icsneo/device/tree/radstar2/radstar2eth.h" #include "icsneo/device/tree/radstar2/radstar2usb.h"