Added integration test for server reinit

README.md

@@ -170,7 +170,7 @@ fn task(calseg: CalSeg<CalPage>) {
 fn main() {
 
     // Initialize XCP driver singleton, the transport layer UDP and enable the automatic A2L writer and upload
-    let xcp = XcpBuilder::new("xcp_lite").set_log_level(XcpLogLevel::Warn).enable_a2l(true).set_epk("???")
+    let xcp = XcpBuilder::new("my_module_name").set_log_level(XcpLogLevel::Warn).set_epk("MY_EPK")
       .start_server(XcpTransportLayer::Udp,[127, 0, 0, 1],5555, 1400,).unwrap();
 
     // Create a calibration parameter set named "calsseg" (struct CalSeg, a MEMORY_SEGMENT in A2L and CANape)

examples/hello_xcp/src/main.rs

@@ -36,11 +36,10 @@ const CAL_PAGE: CalPage = CalPage { min: 5, max: 10, delay: 100000 };
 fn main() {
     println!("XCP Demo");
 
-    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
 
     let xcp = XcpBuilder::new("xcp_demo")
         .set_log_level(XcpLogLevel::Debug)
-        .enable_a2l(true)
         .set_epk("EPK_")
         .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555)
         .unwrap();
@@ -64,6 +63,6 @@ fn main() {
 
         calseg.sync();
 
-        //Xcp::get().write_a2l();
+        xcp.write_a2l();
     }
 }

examples/multi_thread_demo/src/main.rs

@@ -94,12 +94,11 @@ fn main() {
     println!("XCPlite Multi Thread Demo");
 
     // Logging
-    env_logger::Builder::new().filter_level(log::LevelFilter::Warn).init();
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
 
     // Initialize XCP driver singleton, the transport layer server and enable the registry
     let xcp = XcpBuilder::new("multi_thread_demo")
         .set_log_level(XcpLogLevel::Warn)
-        .enable_a2l(true)
         .set_epk("EPK_12345678")
         .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555)
         .unwrap();
@@ -125,8 +124,9 @@ fn main() {
         }));
     }
 
+    // Test
     thread::sleep(Duration::from_millis(1000));
-    Xcp::get().write_a2l();
+    xcp.write_a2l();
 
     t.into_iter().for_each(|t| t.join().unwrap());
 

examples/point_cloud_demo/src/main.rs

@@ -110,11 +110,10 @@ fn create_point_cloud() -> PointCloud {
 fn main() {
     println!("xcp-lite point cloud demo");
 
-    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
 
     let xcp = XcpBuilder::new("point_cloud")
         .set_log_level(XcpLogLevel::Debug)
-        .enable_a2l(true)
         .start_server(XcpTransportLayer::Udp, BIND_ADDR, 5555)
         .unwrap();
 

examples/protobuf_demo/src/main.rs

@@ -151,11 +151,10 @@ pub struct TestData {
 fn main() {
     println!("protobuf demo");
 
-    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
 
     let xcp = XcpBuilder::new("xcp_demo")
         .set_log_level(XcpLogLevel::Debug)
-        .enable_a2l(true)
         .set_epk("EPK_")
         .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555)
         .unwrap();
@@ -219,6 +218,6 @@ fn main() {
 
         thread::sleep(Duration::from_micros(1000000));
 
-        Xcp::get().write_a2l(); // @@@@ test
+        xcp.write_a2l(); // @@@@ test
     }
 }

examples/rayon_demo/src/main.rs

@@ -133,15 +133,14 @@ fn render(pixels: &mut [u8], row: usize, length: usize, upper_left: Complex<f64>
 fn main() {
     println!("xcp-lite rayon mandelbrot demo");
 
-    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
 
     const BIND_ADDR: [u8; 4] = [192, 168, 0, 83];
     // const BIND_ADDR: [u8; 4] = [127, 0, 0, 1];
     // const BIND_ADDR: [u8; 4] = [172, 19, 11, 24];
 
     let xcp = XcpBuilder::new("mandelbrot")
         .set_log_level(XcpLogLevel::Debug)
-        .enable_a2l(true)
         .set_epk("EPK")
         .start_server(XcpTransportLayer::Udp, BIND_ADDR, 5555)
         .unwrap();

examples/scoped_threads/src/main.rs

@@ -44,13 +44,12 @@ fn task1(calseg: CalSeg<CalPage>) {
         if counter > calseg.max {
             counter = calseg.min;
         }
-        // info!("Counter: {}", counter);
+
         event.trigger();
 
         thread::sleep(Duration::from_micros(calseg.delay as u64));
 
         calseg.sync();
-        Xcp::get().write_a2l();
     }
 }
 
@@ -59,11 +58,10 @@ fn task1(calseg: CalSeg<CalPage>) {
 fn main() {
     println!("XCP Demo");
 
-    env_logger::Builder::new().filter_level(log::LevelFilter::Debug).init();
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
 
     let xcp = XcpBuilder::new("xcp_demo")
-        .set_log_level(XcpLogLevel::Debug)
-        .enable_a2l(true)
+        .set_log_level(XcpLogLevel::Info)
         .set_epk("EPK_")
         .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555)
         .unwrap();

examples/single_thread_demo/src/main.rs

@@ -58,7 +58,7 @@ fn main() {
     // The A2L file will be finalized on XCP connection and can be uploaded by CANape
     let xcp = XcpBuilder::new("single_thread_demo")
         .set_log_level(XcpLogLevel::Info) // Set log level of the XCP server
-        .enable_a2l(true) // Enabl A2L generation
+         // Enabl A2L generation
         .set_epk("EPK_") // Set the EPK string for A2L version check, length must be %4
         .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1] /*[172, 19, 11, 24]*/, 5555)
         .unwrap();
@@ -112,7 +112,7 @@ fn main() {
 
         thread::sleep(Duration::from_millis(10)); // 100 Hz
 
-        Xcp::get().write_a2l();
+        xcp.write_a2l();
     }
 
     // Stop the XCP server

examples/tokio_demo/src/main.rs

@@ -109,7 +109,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // Start tokio XCP server
     // Initialize the xcplib transport and protocol layer only, not the server
-    let xcp: &'static Xcp = XcpBuilder::new("tokio_demo").set_log_level(XcpLogLevel::Debug).enable_a2l(true).tl_start().unwrap();
+    let xcp: &'static Xcp = XcpBuilder::new("tokio_demo").set_log_level(XcpLogLevel::Debug).tl_start().unwrap();
     let xcp_task = tokio::spawn(xcp_server::xcp_task(xcp, [127, 0, 0, 1], 5555));
 
     // let mut xcp_server = xcp_server::XcpServer::new([127, 0, 0, 1], 5555);

src/main.rs

@@ -50,10 +50,6 @@ struct Args {
     /// Port number
     #[arg(short, long, default_value_t = 5555)]
     port: u16,
-
-    /// Don't create A2L file
-    #[arg(short, long, default_value_t = false)]
-    no_a2l: bool,
 }
 
 //-----------------------------------------------------------------------------
@@ -124,14 +120,14 @@ struct CalPage {
     run: bool,          // Stop all tasks
     run1: bool,         // Stop demo task1
     run2: bool,         // Stop demo task2
-    cycle_time_us: u32, // Cycle time of main loop in microseconds
+    cycle_time_ms: u16, // Cycle time of main loop task in milliseconds
 }
 
 const CAL_PAGE: CalPage = CalPage {
     run: true,
     run1: true,
     run2: true,
-    cycle_time_us: 50000, // 50ms
+    cycle_time_ms: 100, // 100ms
 };
 
 //---------------------------------------------------
@@ -349,20 +345,16 @@ fn main() {
     env_logger::Builder::new().filter_level(log_level.to_log_level_filter()).init();
 
     // Initialize XCP driver singleton, the transport layer server and enable the A2L writer
-    let xcp_builder = XcpBuilder::new("xcp_lite")
+    let xcp = XcpBuilder::new("xcp_lite")
         .set_log_level(log_level)
-        .enable_a2l(!args.no_a2l)
         // .set_segment_size(1500-20-8) // no jumbo frames
         // .set_epk(build_info::format!("{}", $.timestamp)); // Create new EPK from build info
-        .set_epk("EPK_");
-
-    let xcp = match xcp_builder.start_server(if args.tcp { XcpTransportLayer::Tcp } else { XcpTransportLayer::Udp }, args.bind, args.port) {
-        Err(res) => {
-            error!("XCP server initialization failed: {:?}", res);
-            return;
-        }
-        Ok(xcp) => xcp,
-    };
+        .set_epk("EPK_")
+        .start_server(if args.tcp { XcpTransportLayer::Tcp } else { XcpTransportLayer::Udp }, args.bind, args.port)
+        .map_err(|e| {
+            panic!("XCP server initialization failed: {:?}", e);
+        })
+        .unwrap();
 
     // Register a static calibration page
     let calpage00 = CAL_PAGE0.get().unwrap();
@@ -385,7 +377,7 @@ fn main() {
         .add_field(calseg_field!(CAL_PAGE.run, 0, 1, "bool"))
         .add_field(calseg_field!(CAL_PAGE.run1, 0, 1, "bool"))
         .add_field(calseg_field!(CAL_PAGE.run2, 0, 1, "bool"))
-        .add_field(calseg_field!(CAL_PAGE.cycle_time_us, "us", "main task cycle time"));
+        .add_field(calseg_field!(CAL_PAGE.cycle_time_ms, "ms", "main task cycle time"));
 
     // Create calibration segments for CAL_PAGE1 and CAL_PAGE2, add fields with macro derive(XcpTypeDescription))
     let calseg1 = xcp.create_calseg("CalPage1", &CAL_PAGE1, true);
@@ -435,11 +427,13 @@ fn main() {
         if !calseg.run {
             break;
         }
-        thread::sleep(Duration::from_micros(calseg.cycle_time_us as u64));
+        thread::sleep(Duration::from_millis(calseg.cycle_time_ms as u64));
 
         // Variables on stack and heap
-        mainloop_counter1 += 1;
-        *mainloop_counter2 += 2;
+        if xcp.is_connected() {
+            mainloop_counter1 += 1;
+        }
+        *mainloop_counter2 += 1;
         mainloop_map[0][0] = mainloop_counter1 as u8;
 
         // Capture variable from heap
@@ -477,9 +471,7 @@ fn main() {
         // Finalize A2l after 2s delay
         // This is just for testing, to force immediate creation of A2L file
         // Without this, the A2L file will be automatically written on XCP connect, to be available for download by CANape
-        if !args.no_a2l && mainloop_counter1 == 1 {
-            thread::sleep(Duration::from_secs(2));
-
+        if !xcp.is_connected() && *mainloop_counter2 == (2000 / calseg.cycle_time_ms as u16) as u64 {
             // Test A2L write
             xcp.write_a2l();
 
@@ -488,9 +480,21 @@ fn main() {
 
             // Test freeze request
             // xcp.set_freeze_request();
+        }
+
+        // Terminate after more than 10s disconnected to test shutdown behaviour
 
-            // Test shutdown
-            // break;
+        // This is just for testing, to force immediate creation of A2L file
+        // Without this, the A2L file will be automatically written on XCP connect, to be available for download by CANape
+        if !xcp.is_connected() {
+            if *mainloop_counter2 % 200 == 0 {
+                println!(".");
+            }
+            if mainloop_counter1 == (10000 / calseg.cycle_time_ms as u16) as u64 {
+                // after 10s when disconnected
+                thread::sleep(Duration::from_secs(2));
+                break;
+            }
         }
     }
     info!("Main task finished");
@@ -502,5 +506,6 @@ fn main() {
     info!("All tasks finished");
 
     // Stop and shutdown the XCP server
+    info!("Stop XCP server");
     xcp.stop_server();
 }