[eclipse-iceoryx#210] Add minimal publish-subscribe example

examples/c/CMakeLists.txt

@@ -2,3 +2,4 @@ cmake_minimum_required(VERSION 3.28)
 project(examples_c)
 
 add_subdirectory(discovery)
+add_subdirectory(publish_subscribe)

examples/c/publish_subscribe/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.28)
+project(example_c_publish_subscribe)
+
+find_package(iceoryx2_lang_c REQUIRED)
+
+add_executable(example_c_publisher src/publisher.c)
+target_link_libraries(example_c_publisher iceoryx2_lang_c)
+
+add_executable(example_c_subscriber src/subscriber.c)
+target_link_libraries(example_c_subscriber iceoryx2_lang_c)

examples/c/publish_subscribe/src/publisher.c

@@ -0,0 +1,8 @@
+#include "iox2/iceoryx2.h"
+
+#include <stdint.h>
+
+int main(void) {
+    const uint32_t NUMBER_OF_SECONDS_TO_RUN = 10;
+    return run_publisher(NUMBER_OF_SECONDS_TO_RUN);
+}

examples/c/publish_subscribe/src/subscriber.c

@@ -0,0 +1,8 @@
+#include "iox2/iceoryx2.h"
+
+#include <stdint.h>
+
+int main(void) {
+    const uint32_t NUMBER_OF_SECONDS_TO_RUN = 10;
+    return run_subscriber(NUMBER_OF_SECONDS_TO_RUN);
+}

iceoryx2-lang/c/CMakeLists.txt

@@ -56,7 +56,7 @@ add_dependencies(${PROJECT_NAME} iceoryx2)
 
 target_include_directories(${PROJECT_NAME} INTERFACE ${ICEORYX2_LANG_C_INCLUDE_DIR})
 
-target_link_libraries(${PROJECT_NAME} INTERFACE ${ICEORYX2_LANG_C_LIB})
+target_link_libraries(${PROJECT_NAME} INTERFACE ${ICEORYX2_LANG_C_LIB} -lm)
 
 ########## find_package in source tree ##########
 set(${PROJECT_NAME}_DIR ${PROJECT_SOURCE_DIR}/cmake

iceoryx2-lang/c/build.rs

@@ -10,7 +10,10 @@ fn main() {
     // therefore we need to traverse to a known location and create the path for the header
     let out_dir = env::var("OUT_DIR").expect("Target output directory");
 
-    let mut header_path = Path::new(&out_dir).join("../../../").canonicalize().expect("Path to iceoryx2 base dir for header generation");
+    let mut header_path = Path::new(&out_dir)
+        .join("../../../")
+        .canonicalize()
+        .expect("Path to iceoryx2 base dir for header generation");
     header_path.push("iceoryx2_lang_c_cbindgen/include/iox2/iceoryx2.h");
 
     let crate_dir = env::var("CARGO_MANIFEST_DIR").expect("Cargo manifest dir");

iceoryx2-lang/c/src/lib.rs

@@ -1,5 +1,11 @@
 use iceoryx2::prelude::*;
 
+mod publisher;
+mod subscriber;
+
+pub use publisher::*;
+pub use subscriber::*;
+
 #[no_mangle]
 pub extern "C" fn zero_copy_service_list() -> i32 {
     let services = zero_copy::Service::list();

iceoryx2-lang/c/src/publisher.rs

@@ -0,0 +1,65 @@
+use core::time::Duration;
+use iceoryx2::prelude::*;
+
+const CYCLE_TIME: Duration = Duration::from_secs(1);
+
+#[no_mangle]
+pub extern "C" fn run_publisher(seconds: u32) -> i32 {
+    let service_name = ServiceName::new("Hello/from/C");
+
+    if service_name.is_err() {
+        return -1;
+    }
+
+    let service_name = service_name.unwrap();
+
+    let service = zero_copy::Service::new(&service_name)
+        .publish_subscribe::<u64>()
+        .open_or_create();
+
+    if service.is_err() {
+        return -1;
+    }
+
+    let service = service.unwrap();
+
+    let publisher = service.publisher().create();
+
+    if publisher.is_err() {
+        return -1;
+    }
+
+    let publisher = publisher.unwrap();
+
+    let mut counter: u64 = 0;
+
+    let mut remaining_seconds = seconds;
+
+    while let Iox2Event::Tick = Iox2::wait(CYCLE_TIME) {
+        counter += 1;
+        let sample = publisher.loan_uninit();
+
+        if sample.is_err() {
+            return -1;
+        }
+
+        let sample = sample.unwrap();
+
+        let sample = sample.write_payload(counter);
+
+        if sample.send().is_err() {
+            return -1;
+        }
+
+        println!("Send sample {} ...", counter);
+
+        remaining_seconds = remaining_seconds.saturating_sub(1);
+        if remaining_seconds == 0 {
+            break;
+        }
+    }
+
+    println!("exit");
+
+    return 0;
+}

iceoryx2-lang/c/src/subscriber.rs

@@ -0,0 +1,54 @@
+use core::time::Duration;
+use iceoryx2::prelude::*;
+
+const CYCLE_TIME: Duration = Duration::from_secs(1);
+
+#[no_mangle]
+pub extern "C" fn run_subscriber(seconds: u32) -> i32 {
+    let service_name = ServiceName::new("Hello/from/C");
+
+    if service_name.is_err() {
+        return -1;
+    }
+
+    let service_name = service_name.unwrap();
+
+    let service = zero_copy::Service::new(&service_name)
+        .publish_subscribe::<u64>()
+        .open_or_create();
+
+    if service.is_err() {
+        return -1;
+    }
+
+    let service = service.unwrap();
+
+    let subscriber = service.subscriber().create();
+
+    if subscriber.is_err() {
+        return -1;
+    }
+
+    let subscriber = subscriber.unwrap();
+
+    let mut remaining_seconds = seconds;
+
+    while let Iox2Event::Tick = Iox2::wait(CYCLE_TIME) {
+        loop {
+            match subscriber.receive() {
+                Ok(Some(sample)) => println!("received: {:?}", *sample),
+                Ok(None) => break,
+                Err(_) => return -1,
+            }
+        }
+
+        remaining_seconds = remaining_seconds.saturating_sub(1);
+        if remaining_seconds == 0 {
+            break;
+        }
+    }
+
+    println!("exit");
+
+    return 0;
+}