Differences

This shows you the differences between two versions of the page.

--- rust [2021/08/11 10:44]
wikiadmin created
+++ rust [2024/05/21 17:01] (current)
wikiadmin
@@ Line 1: / Line 1: @@
-This GEM C++ example uses the code generated from TransSECS using the Native/C++ deployment option.
+This GEM Rust host example uses the code generated from TransSECS using the Native/C++ deployment option.  More detailed information is available at [[https://ergotech.com/files/guides/doc/transsecs/index.html|Rust Documentation]]
-In the tool you update the variables with simple set/get methods take the name of the variable and the value. In the host, you subscribe to receive data. Complex types are passed as JSON.
+Most of the complexity is removed by the definitions you created in TransSECS.  In Rust you subscribe to receive data and publish values. Complex types are passed as JSON.
 Message notifications are received as JSON maps so that each of the published elements in the message are available directly.
-Download the sample from: https://www.ergotech.com/docs/cppwrapper.tar.gz
-Extract the cppwrapper folder and change to that folder.
-On Linux:
-<code bash>
-mkdir build
-cmake ..
-make
-</code>
-Copy the GEMToolRuntime.jar from the TransSECS GEMTool project into the build folder.  Then run:
-<code bash>
-./transecswrapper_example
-Started tool GEMTool on port 5010 device id 1
-Publish Item id: "gemtool/vids/ppid"
-Subscribe Item id: "gemtool/vids/ppid"
-Publish Item id: "gemtool/vids/s5f1replybit"
-Subscribe Item id: "gemtool/vids/s5f1replybit"
-Subscribe Item id: "gemtool/configuration/port"
-Subscribe Item id: "gemtool/configuration/deviceid"
-Subscribe Item id: "gemtool/configuration/passivet1"
-Subscribe Item id: "gemtool/configuration/passivet2"
-Subscribe Item id: "gemtool/configuration/passivet3"
-Subscribe Item id: "gemtool/configuration/passivet4"
-Subscribe Item id: "gemtool/configuration/passivet5"
-Subscribe Item id: "gemtool/configuration/passivet6"
-Subscribe Item id: "gemtool/configuration/passivet7"
-[...]
-Subscribe Item id: "gemtool/vids/processtemperature"
-Control state changed 3
-Getting: gemtool/vids/controlstate
-Control State 3
-Getting: gemtool/vids/controlstate
-Control State 3
-New ppid InitialPPID
-</code>
-The tool is then running and ready for connections.  You can use the TransSECS GEMHost sample project to test the tool.
 For the host,copy the GEMHostRuntime.jar from the TransSECS GEMHost project into the build folder
-The samples, even though simple, demonstrates all the features required of a tool and the ability to collect data from a host.
+The samples, even though simple, demonstrates all the features required to collect data from a host.
 In the host code, publish variables you need to change in the interface, here the port, hostname, deviceid, etc. and subscribe to elements to receive data updates.  Here an event (loaded) and to values (ppid and wafer count).  The event is received as a JSON structure.
-For example
+For example, to set the hostname, you publish to that variable:
 <code rust>
@@ Line 88: / Line 49: @@
 <code rust>
 //! Simple GEM host example showing how to start a host and subscribe to some variables
 use transsecs::transsecs_wrapper::TransSecsWrapper;
-use transsecs::value_object::{Value};
+use transsecs::value_object::Value;
 use std::{thread, time};
+use serde::{Deserialize, Serialize, Serializer};
-use serde::{Serialize, Deserialize};
+use serde::ser::SerializeStruct;
+use anyhow::Result;
 #[derive(Serialize, Deserialize, Debug)]
 struct LoadedCeid {
@@ Line 100: / Line 60: @@
     reports:Vec<Report>
 }
 #[derive(Serialize, Deserialize, Debug)]
 struct Report {
-    #[serde(rename="RPTID103")]
+    #[serde(rename="LOADED_REPORT")]
     values:Vec<ReportValue>
 }
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(untagged)]
@@ Line 113: / Line 70: @@
     LotID{
         #[serde(rename="LOTID")]
         lot_id:String,
         #[serde(rename="type")]
         type_int:i32
     },
-    PPID{
+    CLOCK{
-        #[serde(rename="PPID")]
+        #[serde(rename="CLOCK")]
-        ppid:String,
+        clock:String,
         #[serde(rename="type")]
         type_int:i32
-    },
+    }
-    WaferCount{
+}
-        #[serde(rename="WaferCount")]
+#[derive(Deserialize)]
-        wafer_count:String,
+struct SecsValue {
-        #[serde(rename="type")]
+    value: String,
-        type_int:i32}
+}
+impl Serialize for SecsValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = serializer.serialize_struct("SecsValue", 2)?;
+        s.serialize_field("value", &self.value)?;
+        s.serialize_field("type", &20)?;
+        s.end()
+    }
+}
+#[derive(Deserialize)]
+struct CommandParams {
+    values: Vec<(SecsValue, SecsValue)>,
+}
+struct TupleAsObject<'a>(&'a (SecsValue, SecsValue));
+impl<'a> Serialize for TupleAsObject<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = serializer.serialize_struct("TupleAsObject", 2)?;
+        s.serialize_field("values", &vec![&self.0 .0.value, &self.0 .1.value])?;
+        s.serialize_field("type", &20)?;
+        s.end()
+    }
+}
+impl Serialize for CommandParams {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let values: Vec<_> = self.values.iter().map(TupleAsObject).collect();
+        let mut s = serializer.serialize_struct("CommandParams", 1)?;
+        s.serialize_field("values", &values)?;
+        s.end()
+    }
+}
+#[derive(Serialize, Deserialize)]
+struct S2F41 {
+    #[serde(rename = "Command")]
+    command: SecsValue,
+    #[serde(rename = "CommandParams")]
+    command_params: CommandParams,
 }
 // examples/gem_host_example.rs
-fn main() {
+fn main() -> Result<()>{
-    let wrapper = TransSecsWrapper::new("./GEMHostRuntime.jar").unwrap();
+    let mut wrapper = TransSecsWrapper::new::<String>(None)?;
     let port = 5010;
     wrapper.publish_string("gemhost/configuration/persistencefilename", "/tmp/testpersistence").unwrap();
@@ Line 139: / Line 138: @@
     wrapper.publish_int("gemhost/configuration/deviceid", 1).unwrap();
     wrapper.publish_int("gemhost/configuration/activeport", port).unwrap();
     wrapper.start_main("GEMHost").unwrap();
     wrapper.subscribe("gemhost/variables/ceid/loaded", |topic,value| {
         println!("Callback called on {}:", topic);
@@ Line 151: / Line 148: @@
         }
     }).unwrap();
+    wrapper.subscribe("gemhost/variables/vid/clock", |topic,value| {
-    wrapper.subscribe("gemhost/variables/vid/ppid", |topic,value| {
         println!("Callback called on {} with {:?}", topic, value)
     }).unwrap();
     wrapper.subscribe("gemhost/variables/vid/lotid", |topic,value| {
         println!("Callback called on {} with {:?}", topic, value)
     }).unwrap();
+    let gem_model_json = include_str!("../GEMHostModel.json");
+    wrapper.set_gem_model(gem_model_json).unwrap();
     loop{
+        let host_command_start = S2F41 {
+            command: SecsValue {
+                value: "START".to_string(),
+            },
+            command_params: CommandParams {
+                values: vec![
+                    (SecsValue {
+                        value: "PPID".to_string(),
+                    },
+                    SecsValue {
+                        value: "warm".to_string(),
+                    })
+                ]
+            },
+        };
+        // wrapper.publish_json("gemhost/hostcommand/sendmessage", serde_json::to_string(&host_command_start).unwrap()).unwrap();
+        // wrapper.publish_json("gemhost/svidrequest/sendmessage", "{\"SVID\": { \"value\":\"33003\", \"type\":54 }}").unwrap();
+        let complicated_s2f41 = include_str!("../s2f41.json");
+        wrapper.publish_json("gemhost/hostcommand/sendmessage", complicated_s2f41).unwrap();
         thread::sleep(time::Duration::from_secs(10));
     } // If we drop the wrapper, it will cleanup the jvm
 }
 </code>