Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter

- CitrineOS core extracted (CSMS OCPP 2.0.1)
- OpenOCPP extracted (firmware OCPP 1.6J/2.0.1)
- ShapeShifter library installed (pip install -e)
- ShapeShifter specification extracted
- EVerest extracted

TODO updated with progress

tools/EVerest-main/modules/Examples/RustExamples/RsExampleUser/src/main.rs

@@ -0,0 +1,88 @@
+// EVerest expects binaries to be CamelCased, and Rust wants them to be snake_case. We yield to
+// EVerest and shut up the compiler warning.
+#![allow(non_snake_case)]
+include!(concat!(env!("OUT_DIR"), "/generated.rs"));
+
+use std::sync::{Arc, Mutex};
+use std::{thread, time};
+
+use generated::{
+    Context, ExampleClientSubscriber, ExampleUserServiceSubscriber, Module, ModulePublisher,
+    OnReadySubscriber,
+};
+
+struct ExampleClient {
+    max_current: Mutex<Option<f64>>,
+    thread: Mutex<Option<thread::JoinHandle<()>>>,
+}
+
+impl ExampleClient {
+    fn new() -> Self {
+        Self {
+            max_current: Mutex::new(None),
+            thread: Mutex::new(None),
+        }
+    }
+}
+
+impl ExampleClientSubscriber for ExampleClient {
+    fn on_max_current(&self, context: &Context, value: f64) {
+        println!("Received the value {value}");
+        let _ = context
+            .publisher
+            .their_example
+            .uses_something("hello_there".to_string());
+        *self.max_current.lock().unwrap() = Some(value);
+
+        // Example where we start a thread with the publisher. The cloning is
+        // only done if the user wants to offload the publisher into a thread.
+        let clone = context.publisher.clone();
+        *self.thread.lock().unwrap() = Some(thread::spawn(move || {
+            let _ = clone.another_example.uses_something("foo".to_string());
+        }))
+    }
+}
+
+struct MainService {}
+impl ExampleUserServiceSubscriber for MainService {}
+
+struct OurModule {
+    their_example: Arc<ExampleClient>,
+    another_example: Arc<ExampleClient>,
+    min_current: Mutex<Option<f64>>,
+}
+
+impl OnReadySubscriber for OurModule {
+    fn on_ready(&self, _pub_impl: &ModulePublisher) {
+        let mut their_current = self.their_example.max_current.lock().unwrap();
+        let mut another_current = self.another_example.max_current.lock().unwrap();
+        *their_current = Some(1.);
+        *another_current = Some(2.);
+        // uses somehow both...
+        *self.min_current.lock().unwrap() = Some(1.);
+    }
+}
+
+#[everestrs::main]
+fn main(module: &Module) {
+    let their_example = Arc::new(ExampleClient::new());
+    let another_example = Arc::new(ExampleClient::new());
+    let main_service = Arc::new(MainService {});
+    let our_module = Arc::new(OurModule {
+        their_example: their_example.clone(),
+        another_example: another_example.clone(),
+        min_current: Mutex::new(None),
+    });
+    let _publishers = module.start(
+        our_module.clone(),
+        main_service.clone(),
+        their_example.clone(),
+        another_example.clone(),
+    );
+
+    // Everest is driving execution in the background for us, nothing to do.
+    loop {
+        let dt = time::Duration::from_millis(250);
+        thread::sleep(dt);
+    }
+}