254 lines
8.4 KiB
C++
254 lines
8.4 KiB
C++
#include <iostream>
|
|
#include <random>
|
|
|
|
#include "icsneo/icsneocpp.h"
|
|
|
|
enum class MessageType {
|
|
ShortEth,
|
|
LongEth,
|
|
CAN,
|
|
CANFD
|
|
};
|
|
|
|
const std::vector<std::string> MessageTypeLabels = {"short Ethernet", "long Ethernet", "CAN", "CAN-FD"};
|
|
|
|
void onEvent(std::shared_ptr<icsneo::APIEvent> event) {
|
|
std::cout << event->describe() << std::endl;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<icsneo::Frame>> constructRandomFrames(size_t frameCount, MessageType frameType) {
|
|
static constexpr size_t ClassicCANSize = 8;
|
|
static constexpr size_t CANFDSize = 64;
|
|
static constexpr size_t ShortEthSize = 500;
|
|
static constexpr size_t LongEthSize = 1500;
|
|
|
|
std::vector<std::shared_ptr<icsneo::Frame>> frames;
|
|
std::random_device randDev;
|
|
std::mt19937 randEngine(randDev());
|
|
std::uniform_int_distribution randByteDist(0,255);
|
|
auto randByteGen = [&]() -> uint8_t {
|
|
return static_cast<uint8_t>(randByteDist(randEngine));
|
|
};
|
|
|
|
for(size_t i = 0; i < frameCount; i++) {
|
|
switch(frameType) {
|
|
case MessageType::ShortEth:
|
|
// Short Ethernet
|
|
{
|
|
auto frame = std::make_shared<icsneo::EthernetMessage>();
|
|
frame->network = icsneo::Network::NetID::ETHERNET_01;
|
|
frames.push_back(frame);
|
|
frame->data.resize(ShortEthSize);
|
|
std::generate(frame->data.begin(), frame->data.end(), randByteGen);
|
|
}
|
|
break;
|
|
case MessageType::LongEth:
|
|
// Long Ethernet
|
|
{
|
|
auto frame = std::make_shared<icsneo::EthernetMessage>();
|
|
frame->network = icsneo::Network::NetID::ETHERNET_01;
|
|
frames.push_back(frame);
|
|
frame->data.resize(LongEthSize);
|
|
std::generate(frame->data.begin(), frame->data.end(), randByteGen);
|
|
}
|
|
break;
|
|
case MessageType::CAN:
|
|
// Classic CAN
|
|
{
|
|
auto frame = std::make_shared<icsneo::CANMessage>();
|
|
frame->network = icsneo::Network::NetID::DWCAN_02;
|
|
frames.push_back(frame);
|
|
frame->data.resize(ClassicCANSize);
|
|
|
|
std::generate(frame->data.begin(), frame->data.end(), randByteGen);
|
|
}
|
|
break;
|
|
case MessageType::CANFD:
|
|
// CAN FD
|
|
{
|
|
auto frame = std::make_shared<icsneo::CANMessage>();
|
|
frame->network = icsneo::Network::NetID::DWCAN_03;
|
|
frames.push_back(frame);
|
|
frame->data.resize(CANFDSize);
|
|
std::generate(frame->data.begin(), frame->data.end(), randByteGen);
|
|
frame->isCANFD = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return frames;
|
|
}
|
|
|
|
void resetScriptStatus(std::shared_ptr<icsneo::Device> rxDevice, std::shared_ptr<icsneo::Device> txDevice, bool rxInit, bool txInit) {
|
|
if(rxInit) {
|
|
rxDevice->startScript();
|
|
} else {
|
|
rxDevice->stopScript();
|
|
}
|
|
if(txInit) {
|
|
txDevice->startScript();
|
|
} else {
|
|
txDevice->stopScript();
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
if(argc != 3) {
|
|
std::cout << "Usage: libicsneocpp-vsa-example <Tx device serial> <Rx device serial>" << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
std::string txSerial = argv[1];
|
|
std::string rxSerial = argv[2];
|
|
|
|
// register an event callback so we can see all logged events
|
|
icsneo::EventManager::GetInstance().addEventCallback(icsneo::EventCallback(onEvent));
|
|
|
|
auto devices = icsneo::FindAllDevices();
|
|
if(devices.empty()) {
|
|
std::cout << "error: no devices found" << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
std::shared_ptr<icsneo::Device> txDevice;
|
|
std::shared_ptr<icsneo::Device> rxDevice;
|
|
for(auto&& d : devices) {
|
|
if(txSerial == d->getSerial()) {
|
|
txDevice = d;
|
|
}
|
|
if(rxSerial == d->getSerial()) {
|
|
rxDevice = d;
|
|
}
|
|
}
|
|
if(!txDevice) {
|
|
std::cout << "error: failed to find a device with serial number: " << txSerial << std::endl;
|
|
return -1;
|
|
}
|
|
if(!rxDevice) {
|
|
std::cout << "error: failed to find a device with serial number: " << rxSerial << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "info: found " << txDevice->describe() << std::endl;
|
|
std::cout << "info: found " << rxDevice->describe() << std::endl;
|
|
|
|
if(!txDevice->open()) {
|
|
std::cout << "error: unable to open device" << std::endl;
|
|
}
|
|
if(!rxDevice->open()) {
|
|
std::cout << "error: unable to open device" << std::endl;
|
|
}
|
|
|
|
const auto& rxInitialCoreminiStatus = rxDevice->getScriptStatus()->isCoreminiRunning;
|
|
const auto& txInitialCoreminiStatus = txDevice->getScriptStatus()->isCoreminiRunning;
|
|
|
|
rxDevice->stopScript();
|
|
txDevice->stopScript();
|
|
|
|
uint64_t origFirstOffset;
|
|
std::shared_ptr<icsneo::VSA> origFirstRecord;
|
|
if(!rxDevice->findFirstVSARecord(origFirstOffset, origFirstRecord)) {
|
|
std::cout << "error: unable to find first VSA record" << std::endl;
|
|
resetScriptStatus(rxDevice, txDevice, rxInitialCoreminiStatus, txInitialCoreminiStatus);
|
|
return -1;
|
|
}
|
|
std::cout << "info: found first VSA record at " << origFirstOffset << std::endl;
|
|
|
|
uint64_t origLastOffset;
|
|
std::shared_ptr<icsneo::VSA> origLastRecord;
|
|
if(!rxDevice->findLastVSARecord(origLastOffset, origLastRecord)) {
|
|
std::cout << "error: unable to find last VSA record" << std::endl;
|
|
resetScriptStatus(rxDevice, txDevice, rxInitialCoreminiStatus, txInitialCoreminiStatus);
|
|
return -1;
|
|
}
|
|
std::cout << "info: found last VSA record at " << origLastOffset << std::endl;
|
|
|
|
uint64_t canFrameCount = 0;
|
|
uint64_t ethFrameCount = 0;
|
|
rxDevice->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> msg) {
|
|
if(msg->type != icsneo::Message::Type::Frame) {
|
|
return;
|
|
}
|
|
const auto frame = std::static_pointer_cast<icsneo::Frame>(msg);
|
|
if(frame->network.getType() == icsneo::Network::Type::CAN) {
|
|
++canFrameCount;
|
|
} else if(frame->network.getType() == icsneo::Network::Type::AutomotiveEthernet || frame->network.getType() == icsneo::Network::Type::Ethernet) {
|
|
++ethFrameCount;
|
|
}
|
|
}));
|
|
icsneo::VSAExtractionSettings settings;
|
|
{
|
|
auto& filter = settings.filters.emplace_back();
|
|
filter.readRange.first = origLastRecord->getTimestampICSClock() - std::chrono::seconds(20);
|
|
filter.readRange.second = origLastRecord->getTimestampICSClock() - std::chrono::seconds(10);
|
|
}
|
|
{
|
|
auto& filter = settings.filters.emplace_back();
|
|
filter.readRange.first = origFirstRecord->getTimestampICSClock() + std::chrono::seconds(0);
|
|
filter.readRange.second = origFirstRecord->getTimestampICSClock() + std::chrono::seconds(10);
|
|
}
|
|
std::cout << "info: reading two blocks of VSA, 10s from the start and 10s from the end..." << std::endl;
|
|
if(!rxDevice->readVSA(settings)) {
|
|
std::cout << "error: unable to read VSA" << std::endl;
|
|
resetScriptStatus(rxDevice, txDevice, rxInitialCoreminiStatus, txInitialCoreminiStatus);
|
|
return -1;
|
|
}
|
|
std::cout << "info: processed " << canFrameCount << " CAN frames and " << ethFrameCount << " Ethernet frames" << std::endl;
|
|
|
|
rxDevice->startScript();
|
|
txDevice->goOnline();
|
|
|
|
const uint8_t NumFrameTypes = 4;
|
|
const size_t FrameCountPerType = 2500;
|
|
std::vector<std::shared_ptr<icsneo::Frame>> frames;
|
|
for(uint8_t i = 0; i < NumFrameTypes; i++) {
|
|
std::cout << "info: transmitting " << FrameCountPerType << " random " << MessageTypeLabels[i] << " frames" << std::endl;
|
|
auto tempFrames = constructRandomFrames(FrameCountPerType, static_cast<MessageType>(i));
|
|
frames.insert(frames.end(), tempFrames.begin(), tempFrames.end());
|
|
if(!txDevice->transmit(tempFrames)) {
|
|
std::cout << "error: failed to transmit frames" << std::endl;
|
|
resetScriptStatus(rxDevice, txDevice, rxInitialCoreminiStatus, txInitialCoreminiStatus);
|
|
return -1;
|
|
}
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(600));
|
|
}
|
|
|
|
size_t currentMessage = 0;
|
|
rxDevice->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> msg) {
|
|
if(msg->type != icsneo::Message::Type::Frame) {
|
|
return;
|
|
}
|
|
auto frame = std::static_pointer_cast<icsneo::Frame>(msg);
|
|
if(frames[currentMessage]->data == frame->data) {
|
|
currentMessage++;
|
|
}
|
|
}));
|
|
|
|
// Read from original last frame until end of buffer
|
|
icsneo::VSAExtractionSettings transmitSettings;
|
|
{
|
|
auto& filter = transmitSettings.filters.emplace_back();
|
|
filter.readRange.first = origLastRecord->getTimestampICSClock();
|
|
}
|
|
|
|
std::cout << "info: reading transmitted random frames..." << std::endl;
|
|
if(!rxDevice->readVSA(transmitSettings)) {
|
|
std::cout << "error: unable to read VSA" << std::endl;
|
|
resetScriptStatus(rxDevice, txDevice, rxInitialCoreminiStatus, txInitialCoreminiStatus);
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "Waiting for 5 seconds..." << std::endl;
|
|
std::this_thread::sleep_for(std::chrono::seconds(5));
|
|
|
|
std::cout << "info: " << currentMessage << " transmitted frames found" << std::endl;
|
|
resetScriptStatus(rxDevice, txDevice, rxInitialCoreminiStatus, txInitialCoreminiStatus);
|
|
|
|
if(currentMessage != FrameCountPerType * NumFrameTypes) {
|
|
std::cout << "error: unable to find all transmitted frames" << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
} |