SILKIT-1743 can xl: update docs, tests and demo (#200)

MariusBgm · VDanielEdwards · web-flow · commit 3c75fe411720 · 2025-04-30T11:44:20.000+02:00
Ensure CNA XL is used in tests and the demo.
Update the docs to reflect that we support CAN XL.

---------

Co-authored-by: Daniel Edwards &lt;daniel.edwards@vector.com&gt;
diff --git a/Demos/communication/Can/CanDemoCommon.hpp b/Demos/communication/Can/CanDemoCommon.hpp
@@ -25,7 +25,10 @@ void FrameHandler(const CanFrameEvent& canFrameEvent, ILogger* logger, bool prin
     {
         frameTypeHint = "FD ";
     }
-
+    if ((canFrameEvent.frame.flags & static_cast<CanFrameFlagMask>(CanFrameFlag::Xlf)) != 0)
+    {
+        frameTypeHint = "XL ";
+    }
     std::stringstream ss;
     ss << "Receive CAN " << frameTypeHint << "frame: canId=" << canFrameEvent.frame.canId << ", data=";
     if (printHex)
diff --git a/SilKit/IntegrationTests/FTest_CanWithoutSync.cpp b/SilKit/IntegrationTests/FTest_CanWithoutSync.cpp
@@ -76,7 +76,8 @@ class FTest_CanWithoutSync : public testing::Test
             canmsg.frame.dlc = static_cast<uint16_t>(canmsg.frame.dataField.size());
             canmsg.frame.flags |=
                 static_cast<CanFrameFlagMask>(CanFrameFlag::Ide) | static_cast<CanFrameFlagMask>(CanFrameFlag::Fdf)
-                | static_cast<CanFrameFlagMask>(CanFrameFlag::Esi) | static_cast<CanFrameFlagMask>(CanFrameFlag::Sec);
+                | static_cast<CanFrameFlagMask>(CanFrameFlag::Esi) | static_cast<CanFrameFlagMask>(CanFrameFlag::Sec)
+                | static_cast<CanFrameFlagMask>(CanFrameFlag::Xlf);
             canmsg.timestamp = 1s;
             canmsg.direction = SilKit::Services::TransmitDirection::RX;
             canmsg.userContext = 0;
diff --git a/SilKit/IntegrationTests/ITest_CanDemo.cpp b/SilKit/IntegrationTests/ITest_CanDemo.cpp
@@ -57,15 +57,68 @@ struct TestState
     bool readerReceivedErrorActive = false;
     bool monitorReceivedErrorActive = false;
     std::atomic<uint32_t> monitorReceiveCount{0};
+    std::atomic<uint32_t> monitorReceiveCountXlf{0};
+    std::atomic<uint32_t> monitorReceiveCountFdf{0};
 
-    std::vector<uint8_t> payloadBytes;
 
-    CanFrame msg;
+    struct OwningCanFrame : CanFrame
+    {
+        OwningCanFrame()
+        {
+            this->af = {};
+            this->canId = {};
+            this->dataField = {};
+            this->dlc = {};
+            this->flags = {};
+            this->sdt = {};
+            this->vcid = {};
+        }
+        std::vector<uint8_t> payloadBytes;
+    };
+
+    OwningCanFrame msg{};
+    OwningCanFrame fdFrame{};
+    OwningCanFrame xlFrame{};
+
+    static constexpr uint32_t canId = 123;
+    static constexpr uint32_t fdId = 0xcafecafe;
+    static constexpr uint32_t xlId = 0xcacacaca;
 
     //Reader variables
     bool result = false;
     std::chrono::milliseconds receiveTime = 0ms;
     size_t messageCount{0};
+
+    TestState()
+    {
+        auto fillData = [](auto& frame, size_t size) {
+            frame.payloadBytes.resize(size);
+            for (size_t i = 0; i < frame.payloadBytes.size(); i++)
+            {
+                frame.payloadBytes[i] = 'A' + (i % 26);
+            }
+            frame.dataField = frame.payloadBytes;
+        };
+        //Test data, CAN
+        msg.canId = canId;
+        fillData(msg, 8);
+        msg.dlc = 8;
+
+        // Test data, CAN FD
+        fillData(fdFrame, 64);
+        fdFrame.canId = fdId;
+        fdFrame.dlc = 15;
+        fdFrame.flags |= SilKit_CanFrameFlag_fdf | SilKit_CanFrameFlag_ide;
+
+        // Test data, CAN XL
+        fillData(xlFrame, 2048);
+        xlFrame.canId = xlId;
+        xlFrame.dlc = 2048;
+        xlFrame.flags |= SilKit_CanFrameFlag_fdf | SilKit_CanFrameFlag_ide | SilKit_CanFrameFlag_xlf;
+        xlFrame.af = 0xdeadbeef;
+        xlFrame.vcid = 234;
+        xlFrame.sdt = 1;
+    }
 };
 
 TEST_F(ITest_CanDemo, can_demo)
@@ -76,15 +129,6 @@ TEST_F(ITest_CanDemo, can_demo)
     //Test Results
     auto state = std::make_shared<TestState>();
 
-    //Test data
-    const std::string payload = "Hallo Welt";
-
-    state->payloadBytes.resize(payload.size());
-    std::copy(payload.begin(), payload.end(), state->payloadBytes.begin());
-
-    state->msg = CanFrame{};
-    state->msg.canId = 123;
-    state->msg.dataField = state->payloadBytes;
 
     //Set up the Sending and receiving participants
     {
@@ -146,14 +190,28 @@ TEST_F(ITest_CanDemo, can_demo)
             }
 
             //Normal transmission
-            if (now > 20ms)
+            if (now > 20ms && now <= 30ms)
             {
                 Log() << "---   CanWriter sending CanFrame";
                 canController->SendFrame(state->msg, (void*)(intptr_t)(0xDEADBEEF));
             }
-        }, 1ms);
+            // CAN FD
+            if (now > 30ms && now <= 40ms)
+            {
+                Log() << "---   CanWriter sending FD Frame";
+                canController->SendFrame(state->fdFrame, (void*)(intptr_t)(0xFDFDFDFD));
+            }
+            // CAN XL
+            if (now > 40ms)
+            {
+                Log() << "---   CanWriter sending XL Frame";
+                canController->SendFrame(state->xlFrame, (void*)(intptr_t)(0xFDFDFDFD));
+            }
+            },
+            1ms);
 
-        canController->AddFrameHandler([state](auto, const Can::CanFrameEvent& frameEvent) {
+        canController->AddFrameHandler(
+            [state](auto, const Can::CanFrameEvent& frameEvent) {
             //ignore early test messages
             if (frameEvent.direction == SilKit::Services::TransmitDirection::TX)
             {
@@ -164,7 +222,8 @@ TEST_F(ITest_CanDemo, can_demo)
             {
                 state->writerHasReceivedRx = true;
             }
-        }, ((DirectionMask)TransmitDirection::RX | (DirectionMask)TransmitDirection::TX));
+            },
+            ((DirectionMask)TransmitDirection::RX | (DirectionMask)TransmitDirection::TX));
     }
 
     {
@@ -192,7 +251,8 @@ TEST_F(ITest_CanDemo, can_demo)
             {
                 canController->SendFrame(state->msg);
             }
-        }, 1ms);
+            },
+            1ms);
 
         canController->AddFrameHandler([state, lifecycleService](auto, const Can::CanFrameEvent& frameEvent) {
             if (frameEvent.timestamp < 20ms)
@@ -201,15 +261,15 @@ TEST_F(ITest_CanDemo, can_demo)
                 return;
             }
             EXPECT_EQ(frameEvent.direction, SilKit::Services::TransmitDirection::RX);
-
-            EXPECT_EQ(frameEvent.frame.canId, 123u);
-
             EXPECT_TRUE(frameEvent.userContext == (void*)((size_t)(0)));
 
-            if (state->messageCount++ == 10)
+            if (frameEvent.frame.canId == TestState::xlId)
             {
-                lifecycleService->Stop("Test done");
-                Log() << "---    CanReader: Sending Stop from";
+                if (state->messageCount++ == 10)
+                {
+                    lifecycleService->Stop("Test done");
+                    Log() << "---    CanReader: Sending Stop from";
+                }
             }
             state->result = true;
         });
@@ -247,10 +307,31 @@ TEST_F(ITest_CanDemo, can_demo)
             }
         });
 
-        canController->AddFrameHandler([state](auto, const Can::CanFrameEvent&) { state->monitorReceiveCount++; });
+        canController->AddFrameHandler([state](auto, const Can::CanFrameEvent& frame) {
+            if (frame.frame.canId == TestState::canId)
+            {
+                state->monitorReceiveCount++;
+            }
+            else if (frame.frame.canId == TestState::fdId)
+            {
+                state->monitorReceiveCountFdf++;
+                EXPECT_FALSE(frame.frame.flags & SilKit_CanFrameFlag_xlf);
+                EXPECT_TRUE(frame.frame.flags & SilKit_CanFrameFlag_fdf);
+            }
+            else if (frame.frame.canId == TestState::xlId)
+            {
+                state->monitorReceiveCountXlf++;
+                EXPECT_EQ(frame.frame.sdt, 1);
+                EXPECT_EQ(frame.frame.af, 0xdeadbeef);
+                EXPECT_EQ(frame.frame.vcid, 234);
+                EXPECT_EQ(frame.frame.dataField.size(), 2048);
+                EXPECT_TRUE(frame.frame.flags & SilKit_CanFrameFlag_xlf);
+                EXPECT_TRUE(frame.frame.flags & SilKit_CanFrameFlag_fdf);
+            }
+        });
     }
 
-    auto ok = _simTestHarness->Run(5s);
+    auto ok = _simTestHarness->Run(500s);
     ASSERT_TRUE(ok) << "SimTestHarness should terminate without timeout";
     EXPECT_TRUE(state->result) << " Expecting a message";
     EXPECT_TRUE(state->writerHasReceivedTx) << " Expecting a receive Message with Direction == TX on CanWriter";
@@ -263,6 +344,8 @@ TEST_F(ITest_CanDemo, can_demo)
     EXPECT_FALSE(state->readerReceivedErrorActive) << " Collisions are not computed in trivial simulation";
     EXPECT_FALSE(state->monitorReceivedErrorActive) << " Collisions are not computed in trivial simulation";
     EXPECT_GT(state->monitorReceiveCount, 10u) << "All participants connected to bus must receive frames";
+    EXPECT_GE(state->monitorReceiveCountFdf, 10u) << "All participants connected to bus must receive FD frames";
+    EXPECT_GE(state->monitorReceiveCountXlf, 10u) << "All participants connected to bus must receive XL frames";
 }
 
 } //end namespace
diff --git a/SilKit/include/silkit/capi/Can.h b/SilKit/include/silkit/capi/Can.h
@@ -287,7 +287,7 @@ typedef SilKit_ReturnCode(SilKitFPTR* SilKit_CanController_SendFrame_t)(SilKit_C
  * range: 0 to 16'000'000
  *
  * \param xlRate Baud rate for CAN XL messages given in bps; valid
- * range: 0 to 16'000'000
+ * range: 0 to 20'000'000
  *
  * In a detailed simulation, the baud rate is used to calculate
  * transmission delays of CAN messages and to determine proper
diff --git a/SilKit/include/silkit/services/can/ICanController.hpp b/SilKit/include/silkit/services/can/ICanController.hpp
@@ -71,7 +71,7 @@ class ICanController
      * range: 0 to 16'000'000
      *
      * \param xlRate Baud rate for CAN XL messages given in bps; valid
-     * range: 0 to 16'000'000
+     * range: 0 to 20'000'000
      *
      * NB: The baud rate of a CAN controller must be set before using it.
      * 
diff --git a/SilKit/source/services/can/Test_CanSerdes.cpp b/SilKit/source/services/can/Test_CanSerdes.cpp
@@ -40,7 +40,8 @@ TEST(Test_CanSerdes, SimCan_CanMessage)
     in.frame.canId = 7;
     in.frame.flags |=
         static_cast<CanFrameFlagMask>(CanFrameFlag::Ide) | static_cast<CanFrameFlagMask>(CanFrameFlag::Fdf)
-        | static_cast<CanFrameFlagMask>(CanFrameFlag::Esi) | static_cast<CanFrameFlagMask>(CanFrameFlag::Sec);
+        | static_cast<CanFrameFlagMask>(CanFrameFlag::Esi) | static_cast<CanFrameFlagMask>(CanFrameFlag::Sec)
+        | static_cast<CanFrameFlagMask>(CanFrameFlag::Xlf);
     in.frame.dlc = 5;
     in.frame.sdt = 123;
     in.frame.vcid = 89;
diff --git a/docs/api/services/can.rst b/docs/api/services/can.rst
@@ -137,9 +137,9 @@ Then, the controller must be started explicitly by calling |Start|. Now the cont
 Additional control commands are |Stop| and |Reset|.
 
 The following example configures a CAN controller with a baud rate of 10'000 baud for regular CAN messages and a baud 
-rate of 1'000'000 baud for CAN |_| FD messages. Then, the controller is started::
+rate of 1'000'000 baud for CAN |_| FD messages and 1'000'000 baud for CAN |_| XL, respectively. Then, the controller is started::
 
-    canController->SetBaudRate(10000, 1000000);
+    canController->SetBaudRate(10000, 1000000, 1000000);
     canController->Start();
 
 .. admonition:: Note
diff --git a/docs/overview/overview.rst b/docs/overview/overview.rst
@@ -6,7 +6,8 @@ Vector SIL Kit Overview
 
 .. |_| unicode:: 0xA0 
    :trim:
-.. |CAN-API| replace:: :ref:`CAN / CAN FD<chap:can-service-api>`
+.. |CANBuses| replace:: CAN / CAN |_| FD / CAN |_| XL
+.. |CAN-API| replace:: :ref:`CAN / CAN FD / CAN XL<chap:can-service-api>`
 .. |Ethernet-API| replace:: :ref:`Ethernet<chap:ethernet-service-api>`
 .. |Flexray-API| replace:: :ref:`FlexRay<chap:flexray-service-api>`
 .. |LIN-API| replace:: :ref:`LIN<chap:lin-service-api>`
@@ -46,7 +47,7 @@ The |ProductName| supports the following services:
 Vehicle Networks
 ----------------
 
-The |ProductName| provides means to simulate CAN / CAN |_| FD, Ethernet, FlexRay, and LIN networks.
+The |ProductName| provides means to simulate |CANBuses|, Ethernet, FlexRay, and LIN networks.
 All networks except for FlexRay can be simulated with two different levels of detail: a simple, functional simulation or a detailed simulation.
 The simple simulation assumes no delay and unlimited bandwidth.
 The detailed simulation is enabled by using an additional |ProductName| |NetSim|, which considers these aspects as well.
@@ -67,7 +68,7 @@ The |ProductName| Registry process is required and must be started as a first st
 It acts as a connection broker between the actual simulation participants.
 
 One or more :doc:`participants<../api/participant>` take care of the actual simulation logic and communicate via built-in :ref:`services<sec:overview-supported-services>`.
-|ProductName| supports common vehicle networks (CAN / CAN |_| FD, Ethernet, FlexRay, LIN), data messages for application specific communication in a publish / subscribe pattern, and Remote Procedure Calls (RPC).
+|ProductName| supports common vehicle networks (|CANBuses|, Ethernet, FlexRay, LIN), data messages for application specific communication in a publish / subscribe pattern, and Remote Procedure Calls (RPC).
 The participant and its services are created by the client application using the |ProductName| :doc:`API<../api/api>`.
 
 To manage a group of participants in a simulation, |ProductName| participants can coordinate their startup behavior.

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,10 @@ void FrameHandler(const CanFrameEvent& canFrameEvent, ILogger* logger, bool prin`
`25`	`25`	`{`
`26`	`26`	`frameTypeHint = "FD ";`
`27`	`27`	`}`
`28`		`-`
	`28`	`+ if ((canFrameEvent.frame.flags & static_cast<CanFrameFlagMask>(CanFrameFlag::Xlf)) != 0)`
	`29`	`+ {`
	`30`	`+ frameTypeHint = "XL ";`
	`31`	`+ }`
`29`	`32`	`std::stringstream ss;`
`30`	`33`	`ss << "Receive CAN " << frameTypeHint << "frame: canId=" << canFrameEvent.frame.canId << ", data=";`
`31`	`34`	`if (printHex)`
Original file line number	Diff line number	Diff line change
`@@ -287,7 +287,7 @@ typedef SilKit_ReturnCode(SilKitFPTR* SilKit_CanController_SendFrame_t)(SilKit_C`
`287`	`287`	`* range: 0 to 16'000'000`
`288`	`288`	`*`
`289`	`289`	`* \param xlRate Baud rate for CAN XL messages given in bps; valid`
`290`		`- * range: 0 to 16'000'000`
	`290`	`+ * range: 0 to 20'000'000`
`291`	`291`	`*`
`292`	`292`	`* In a detailed simulation, the baud rate is used to calculate`
`293`	`293`	`* transmission delays of CAN messages and to determine proper`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ class ICanController`
`71`	`71`	`* range: 0 to 16'000'000`
`72`	`72`	`*`
`73`	`73`	`* \param xlRate Baud rate for CAN XL messages given in bps; valid`
`74`		`- * range: 0 to 16'000'000`
	`74`	`+ * range: 0 to 20'000'000`
`75`	`75`	`*`
`76`	`76`	`* NB: The baud rate of a CAN controller must be set before using it.`
`77`	`77`	`*`