113 lines
6.5 KiB
C++
113 lines
6.5 KiB
C++
#include "can_bus.hpp"
|
|
#include "zcan.h"
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <deque>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
#include <stdexcept>
|
|
#include <thread>
|
|
#include <limits>
|
|
|
|
namespace {
|
|
using namespace std::chrono_literals;
|
|
std::mutex mutex;
|
|
std::condition_variable changed;
|
|
std::deque<ZCANDataObj> incoming;
|
|
std::atomic<int> opens{0},closes{0},resets{0},mergeCalls{0},txCalls{0},rxCalls{0};
|
|
std::atomic<bool> unavailable{false},initFailure{false},receiveFailure{false},txFailure{false};
|
|
ZCAN_20_MSG sentCan{};ZCAN_FD_MSG sentFd{};
|
|
void check(bool ok,char const* message){if(!ok)throw std::runtime_error(message);}
|
|
template<class F> void waitFor(F f) {
|
|
auto deadline=std::chrono::steady_clock::now()+2s;
|
|
while(!f()){check(std::chrono::steady_clock::now()<deadline,"Asynchronous CAN condition timed out");std::this_thread::sleep_for(1ms);}
|
|
}
|
|
template<class F> void rejects(F f){bool failed=false;try{f();}catch(std::exception const&){failed=true;}check(failed,"Expected rejection");}
|
|
void reset() {
|
|
opens=closes=resets=mergeCalls=txCalls=rxCalls=0;
|
|
unavailable=initFailure=receiveFailure=txFailure=false;
|
|
std::lock_guard<std::mutex> lock(mutex);incoming.clear();
|
|
}
|
|
void inject(unsigned channel,bool fd,std::uint32_t id,std::initializer_list<std::uint8_t> bytes,unsigned stamp=123) {
|
|
ZCANDataObj obj{};obj.chnl=channel;obj.dataType=fd?ZCAN_DT_ZCAN_CANFD_DATA:ZCAN_DT_ZCAN_CAN_DATA;
|
|
auto& hdr=fd?obj.data.zcanCANFDData.hdr:obj.data.zcanCANData.hdr;
|
|
hdr.id=id;hdr.chn=channel;hdr.len=bytes.size();hdr.ts=stamp;
|
|
auto* data=fd?obj.data.zcanCANFDData.dat:obj.data.zcanCANData.dat;
|
|
std::copy(bytes.begin(),bytes.end(),data);
|
|
{std::lock_guard<std::mutex> lock(mutex);incoming.push_back(obj);}changed.notify_all();
|
|
}
|
|
}
|
|
extern "C" {
|
|
U32 VCI_OpenDevice(U32 type,U32,U32){check(type==33,"Device type changed");++opens;return unavailable?0:1;}
|
|
U32 VCI_CloseDevice(U32,U32){++closes;return 1;}
|
|
U32 VCI_InitCAN(U32,U32,U32 port,ZCAN_INIT* init){
|
|
check(init->clk==60000000&&init->mode==0&&init->aset.brp==5&&init->dset.brp==1,"Reference timing not retained");
|
|
return initFailure&&port==1?0:1;
|
|
}
|
|
U32 VCI_SetReference(U32,U32,U32 port,U32 ref,void* data){
|
|
if(ref==ZCAN_CMD_SET_CHNL_RECV_MERGE){check(port==0&&*static_cast<U32*>(data)==1,"Invalid merged receive configuration");++mergeCalls;}return 1;
|
|
}
|
|
U32 VCI_StartCAN(U32,U32,U32){return 1;}
|
|
U32 VCI_ResetCAN(U32,U32,U32){++resets;return 1;}
|
|
U32 VCI_ReceiveData(U32,U32,U32 port,ZCANDataObj* out,U32 capacity,U32){
|
|
check(port==0,"Multiple merged receive readers");++rxCalls;
|
|
if(receiveFailure)return std::numeric_limits<U32>::max();
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
changed.wait_for(lock,10ms,[]{return !incoming.empty();});
|
|
U32 count=0;while(!incoming.empty()&&count<capacity){out[count++]=incoming.front();incoming.pop_front();}return count;
|
|
}
|
|
U32 VCI_Transmit(U32,U32,U32 port,ZCAN_20_MSG* message,U32 count){
|
|
check(count==1&&port==message->hdr.chn,"Invalid CAN send call");++txCalls;sentCan=*message;return txFailure?0:1;
|
|
}
|
|
U32 VCI_TransmitFD(U32,U32,U32 port,ZCAN_FD_MSG* message,U32 count){
|
|
check(count==1&&port==message->hdr.chn,"Invalid CANFD send call");++txCalls;sentFd=*message;return txFailure?0:1;
|
|
}
|
|
}
|
|
int main()try {
|
|
using namespace cms;
|
|
reset();{
|
|
CanConfig c;c.enabled=false;CanBus bus(c);bus.start();
|
|
check(bus.snapshot().status=="DISABLED"&&!bus.send({0,0x123,false,false,false,{1,2}}),"Disabled CAN used hardware");
|
|
}check(opens==0,"Disabled CAN opened device");
|
|
reset();unavailable=true;{
|
|
CanBus bus({});bus.start();check(bus.snapshot().status=="UNAVAILABLE","Missing adapter not reported");
|
|
}check(closes==0,"Closed unopened device");
|
|
reset();initFailure=true;{
|
|
CanBus bus({});bus.start();check(bus.snapshot().status=="UNAVAILABLE","Partial failure not reported");
|
|
}check(closes==1&&resets==1,"Partial initialization leaked device");
|
|
reset();{
|
|
CanConfig c;c.timeout_ms=150;CanBus bus(c);bus.start();
|
|
check(mergeCalls==1,"Merged receive configured more than once");
|
|
CanBus duplicate(c);rejects([&]{duplicate.start();});
|
|
inject(0,false,0x391,{1,37,128,255},123);
|
|
inject(1,true,0x391,{4,25,76,100},456);
|
|
waitFor([&]{return bus.snapshot().received==2;});
|
|
auto s=bus.snapshot();
|
|
check(s.channels[0].positions==std::array<int,4>{1,37,128,255},"Four byte positions overlap");
|
|
check(s.channels[1].positions==std::array<int,4>{4,25,76,100},"Channels mixed");
|
|
check(s.channels[0].valid&&s.channels[1].valid&&s.channels[1].fd&&s.channels[1].device_timestamp_us==456,"Freshness/frame metadata wrong");
|
|
auto timestamp=s.channels[0].received_monotonic_ns;
|
|
inject(0,false,0x390,{9,9,9,9});inject(0,false,0x391,{99,99,99});
|
|
waitFor([&]{return bus.snapshot().received==4;});
|
|
s=bus.snapshot();check(s.channels[0].received_monotonic_ns==timestamp&&s.receive_errors==1,"Invalid input refreshed signal");
|
|
waitFor([&]{return !bus.snapshot().channels[0].valid;});
|
|
inject(0,false,0x391,{0,1,2,3});waitFor([&]{return bus.snapshot().channels[0].valid;});
|
|
check(bus.send({0,0x321,false,false,false,{1,2,3}}),"CAN send failed");
|
|
check(sentCan.hdr.len==3&&!sentCan.hdr.inf.sef&&sentCan.dat[2]==3,"CAN encoding incorrect");
|
|
CanFrame fd{1,0x12345,true,true,true,std::vector<std::uint8_t>(64,0xa5)};
|
|
check(bus.send(fd)&&sentFd.hdr.len==64&&sentFd.hdr.inf.brs&&sentFd.hdr.inf.sef&&sentFd.dat[63]==0xa5,"CANFD encoding incorrect");
|
|
fd.data.resize(9);rejects([&]{bus.send(fd);});
|
|
rejects([&]{bus.send({2,0x391,false,false,false,{}});});
|
|
rejects([&]{bus.send({0,0x800,false,false,false,{}});});
|
|
rejects([&]{bus.send({0,0x391,false,false,true,{}});});
|
|
txFailure=true;check(!bus.send({}),"SDK send failure ignored");
|
|
check(bus.snapshot().transmitted==2&&bus.snapshot().transmit_errors==1,"TX counters wrong");
|
|
receiveFailure=true;waitFor([&]{return bus.snapshot().status=="ERROR";});
|
|
check(!bus.snapshot().channels[0].valid&&!bus.send({}),"Receive error left bus live");
|
|
bus.requestStop();bus.join();check(closes==1&&resets==2,"Shutdown did not release both channels");
|
|
check(!bus.send({}),"Transmission after stop");
|
|
}check(closes==1,"Device closed twice");
|
|
std::cout<<"PASS CAN/CANFD RX decoding, independent channels, expiry/recovery, TX validation, errors and lifecycle cleanup\n";
|
|
}catch(std::exception const& e){std::cerr<<e.what()<<'\n';return 1;}
|