Update README.md

Author: RainerZ

README.md

@@ -91,10 +91,6 @@ Shows how to measure and calibrate in a task instantiated in multiple threads wi
 
 Use CANape to observe rayon workers calculating a mandelbrot set line by line
 
-### sysinfo_demo
-
-Measure cpu load, memory usage and network activity from system, cpus and processes
-
 ### tokio_demo
 
 Demonstrates using XCP in an async tokio based application
@@ -104,11 +100,6 @@ Demonstrates using XCP in an async tokio based application
 Measure a lidar point cloud and visualize it in CANapes 3D scene window  
 Use CDR serialization over XCP and the CDR/IDL schema generator proc-macro
 
-### protobuf_demo
-
-Measure a struct annotated with the prost message derive macro and ProtoBuf tags  
-Use ProtoBuf serialization over XCP and the proto schema generator proc-macro  
-This is in experimental state with work in progress, removed from workspace  
 
 ## Code instrumentation for measurement and calibration
 
@@ -117,109 +108,14 @@ Xcp is a wrapper for XCPlite. It is a singleton. There is a builder to initializ
 
 CalSeg is a generic type used to encapsulate structs containing calibration parameters. This is called a calibration segment and the parameter struct wrapped is a calibration page. A calibration page must be Copy and may contain nested structs of basic types or arrays with dimension up to 2.  
 
-A CalSeg has interior mutability. Parameter mutation happens only in the CalSeg::sync(&self) method, or alernativly by dropping the provided calibration segment guard. This must be repeatedly called by the application code, whenever mutation of calibration parameters is considered ok in the current thread.  
+A CalSeg has interior mutability. Parameter mutation happens only on acquiring a calibration segment guard.   
 
-A CalSeg may be shared among multiple threads. It it cloned like an Arc, implements the Deref trait for convenience and does not do any locks to deref to the inner calibration parameter page struct. A sync method must be called on each clone, to make new calibration changes visible in each thread. The sync method shares a mutex with all clones. Each clone holds a shadow copy of the calibration values on heap.
+A CalSeg may be shared among multiple threads. It it cloned like an Arc, implements the Deref trait for convenience and does not do any locks to deref to the inner calibration parameter page struct.
 
 Measurement code instrumentation provides event definition, registration or capture of measurement objects. Measurement objects can be captured (copied to a buffer inside the event) or accessed directly on stack memory after being registered. Capture works for variables on heap or stack. Measurement variables can be registered as single instance or multi instance, which creates one variable instance for each thread instance. Variable names and event names are automatically extended with an index in this case.
 
 The registration of objects has to be completed, before the A2L file is generated. The A2L is created at latest on connect of the XCP client tool. Objects created later, will not be visible to CANape.  
 
-``` rust
-
-// Calibration parameter segment
-// Each calibration parameter struct defines a MEMORY_SEGMENT in A2L and CANape
-// The A2L serializer will create an A2L CHARACTERISTIC for each field. 
-#[derive(Debug, Clone, Copy, XcpTypeDescription)]
-struct CalPage {
-
-    #[charateristic(comment = "Amplitude")]
-    #[characteristic(unit = "Volt")]
-    #[characteristic(min = "0")]
-    #[characteristic(max = "400")]
-    ampl: f64,
-
-    #[characteristic(comment = "Period")]
-    #[characteristic(unit = "s")]
-    #[characteristic(min = "0")]
-    #[characteristic(max = "1000")]
-    period: f64,
-}
-
-// Default calibration page values (called "FLASH" page of a MEMORY_SEGMENT in CANape)
-const CAL_PAGE: CalPage = CalPage {
-    ampl: 100.0,
-    period: 5.0,
-};
-
-
-// A single instance demo task 
-// Calculates some measurement signals depending on calibration parameters in a calibration segment
-fn task(calseg: CalSeg<CalPage>) {
-
-    let mut channel1: f64 = 0.0;
-    let mut channel2: f64 = Box::new(0.0);
-
-     // Create a measurement event called "task" with a capture buffer of 8 byte
-    let event = daq_create_event!("task1", 8);
-
-    // Register measurement variables on stack
-    daq_register!(channel, event, "demo: f64", "Volt" /* unit */, 2.0 /* factor */, 0.0 /* offset */);
-
-    loop {
-        thread::sleep(...);
-
-        // Calculate channel depending on calibration parameters from calseg (sine wave signal with ampl and period)
-        channel1 = calseg.ampl * (time/cal_seg.period).sin(); // Use active page in calibration segment
-        channel2 = calseg.ampl * (time/cal_seg.period).sin(); // Use active page in calibration segment
-        
-        // Register and capture a variables on heap 
-        daq_capture(channel1);
-
-        // Take a timestamp and trigger data acquisition for all variables associated and configured by the tool for this event
-        event.trigger(); 
-
-        // Synchronize calibration operations in calseg
-        // All calibration actions (read, write, upload, download, checksum, page switch, freeze, init) on segment "cal_seg" happen only here
-        // This operation locks a mutex, checks for changes and copies the calibration page
-        // It could be called more occasionally and in any place where calseg is in scope to update calibrations in this clone
-        calseg.sync(); 
-    }
-}
-
-
-
-fn main() -> Result<()> {
-
-    // Initialize XCP driver singleton, the transport layer UDP and enable the automatic A2L writer and upload
-    let xcp = XcpBuilder::new("my_module_name").set_log_level(2).set_epk("MY_EPK")
-      .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555, 1024*64)?;
-
-    // Create a calibration parameter set named "calseg" (struct CalSeg, a MEMORY_SEGMENT in A2L and CANape)
-    // Calibration segments have 2 pages, a constant default "FLASH" page (CAL_PAGE) and a mutable "RAM" page
-    // The RAM page can be loaded from a json file (load_json=true)
-     let calseg = xcp.create_calseg(
-        "calseg", // name of the calibration segment in A2L as MEMORY_SEGMENT and as .json file
-        &CAL_PAGE, // default calibration values
-        ).register_fields();
-
-    // Use CalSeg::Clone() to share the calibration segments between threads
-    // No locks, calseg.sync() must be called in each thread
-    thread::spawn({
-        let calseg = CalSeg::clone(&calseg);
-        move || {
-            task(calseg);
-        }
-    });
-
-
-    loop { ... }
-
-    Xcp::stop_server();
-}
-
-
-```
 
 ## Safety Considerations
 
@@ -244,21 +140,14 @@ XCP is used during the development process only, it is never integrated in produ
 
 Features are:
 
-- shm_mode
-Disable XCP and enable xcp-daemon mode
-
 - a2l_reader
 Check A2L file after generation before upload
 
-- metrics
-Collect some statistic on A2L generation memory usage
-
 ### Build, Run, Test
 
 Build, Run, Test examples:
 
 ```
-
 Build:
   cargo b 
   cargo b --release 
@@ -280,85 +169,13 @@ Tests may not run in parallel, as the XCP implementation is a singleton.
 Feature a2l_reader is needed for xcp_client based testing
 
 ```
-
   cargo test --features=a2l_reader  -- --test-threads=1 --nocapture
   cargo test --features=a2l_reader  -- --test-threads=1 --nocapture  --test test_multi_thread
   cargo test --features=shm_mode  -- --test-threads=1 --nocapture  --test test_performance
- 
 ```
 
 Use --nocapture because the debug output from the XCPlite C library is via normal printf
 
-## Daemon Mode
-
-Feature shm_mode enables the daemon mode and disables XCP mode.  
-
-```
-
-Make and start daemon in xcp-daemon repo directory root: 
-
-MC_SHM_DIRECTORY=../../xcp-lite-rdm MC_TRANSPORT=udp MC_XCP_SERVER_ADDRESS=127.0.0.1 MC_XCP_SERVER_PORT=5555 make --directory ../xcp-daemon/cpp-daemon daemon
-
-Clean
-
-cmake --build ./cpp-daemon/build/ --target clean 
-
-Start daemon and detach process:
-
-MC_SHM_DIRECTORY=../../xcp-lite-rdm MC_TRANSPORT=udp sudo ./cpp-daemon/build/main/main --detach
-
-mc_daemon.a2l is generated in ./cpp-daemon, not in MC_SHM_DIRECTORY
-
-Example im shm_mode starten: 
-cargo r --features=shm_mode
-cargo r --features=shm_mode --example=hello_xcp -- --bind=192.168.8.110
-cargo r --features=shm_mode --example=calibration_demo
-cargo r --features=shm_mode --example=multi_thread_demo
-
-XCP client starten: 
-cargo run --example=xcp_client -- -m ".*"
-cargo run --example=xcp_client -- -l=4 -d=192.168.239.129:5555 -m ".*"
-
-A2L ist uploaded via XCP to xxxx_autodetect.a2l
-
-
-You may use A2l tool to perform more strict tests on the generated A2L:
-cd a2l_tool
-cargo r -- -w -c --strict --metrics -a ../xxxxx.a2l
-
-
-```
-
-### TODO List Daemon Mode
-
-- Implement register typedef and disable flat mode
--
-
-- Finalize registry problem
-
-- A2L upload takes too long time
-
-shm_mode
-[INFO ] start calibration test loop, recalibrate cycle time to 50us for maximum number of calibration checks
-[INFO ] calibration test loop done, 4000 iterations, duration=2666ms, 666.6355us per download, 12.0 KBytes/s
-[WARN ] Calibration download time (666.6355us) is too high!
-
-xcp_mode
-[INFO ] start calibration test loop, recalibrate cycle time to 50us for maximum number of calibration checks
-[INFO ] calibration test loop done, 4000 iterations, duration=170ms, 42.6735us per download, 187.5 KBytes/s
-[INFO ] Consistent calibration test passed
-
-- Calibration block offset is uint64_t from mc_get_block_offset,  but uint16_t in datamodell ????
-- Refactor the types to individually represent the use case AND to point out if its a string reference or numeric reference
-- Move the address encoding to the daemon and clarify the object semantic (measurement or calibration) and address semantic (calseg or event relativ), don't require specific address encodig schemes
-- Load,Save JSON
-- Freeze and Init
-- Check server/daemon status
-- Text event message
-- Terminate session event
-- First cycle DAQ
-- Lock free daq queue
-- RCU cal
 
 ## Notes
 
@@ -376,7 +193,7 @@ The proc macro for more convenient A2L generation is still in an experimental st
 Measurement of local variables is done with a macro which either copies to a static transfer buffer in the event or directly accesses the value on stack.  
 This involves a lazy initialization of the structures to build the A2l file describing the local variables.  
 
-There are 3 different addressing schemes, indicated by address extension (called _ABS,_DYN and _APP in the code).  
+There are 4 different addressing schemes, indicated by address extension (called ABS, DYN, REL and APP in the code).  
 In mode APP, the low word of a calibration parameters memory address in the A2L file is a relative offset in the calibration page struct.  
 The high word (& 0x7FFF) is the index of the calibration segment in a alphabetic ordered list.  
 The memory addresses of local measurement variables are relative addresses (mode DYN) in their event capture buffer on stack or to the stack location of the variable holding the event.