Struct Client

Source

pub struct Client { /* private fields */ }

Implementations§

Source §

impl Client

Source

pub fn new(ams_targed_address: AmsAddress, route: Option<Ipv4Addr>) -> Self

Setup a new client. This will will not yet connect to the targed. Call connect() after creation.

Examples found in repository ?

examples/write_control_example.rs (line 14)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15    //Connect client
16    client.connect().expect("Failed to connect!");
17
18    //Set PLC to stop
19    let ads_state = AdsState::AdsStateStop;
20    let response = client.write_control(ads_state, 0).unwrap();
21    println!("Command id    :{:?}", response.command_id);
22    println!("ADS result    :{:?}", response.result);
23}

More examples

Hide additional examples

examples/read_state_example.rs (line 11)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //Read state
16    let response = client.read_state().unwrap();
17    println!("Raw state response: {:?}\n", response);
18    println!("ADS state     : {:?}", response.ads_state);
19    println!("Device state  : {:?}", response.device_state);
20    println!("ADS result    : {:?}", response.result);
21    println!("Command ID    : {:?}", response.command_id);
22}

examples/read_write_example.rs (line 12)

7fn main() {
8    //Create client. If route = None then targed is local machine
9    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
10    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
11    //let mut client = Client::new(ams_address, Some(ipv4));
12    let mut client = Client::new(ams_address, None);
13    //Connect client
14    client.connect().expect("Failed to connect!");
15
16    //Get a var handle with read_write
17    let var_name = "Main.counter";
18    let handle = client
19        .read_write(0, 4, var_name.as_bytes().to_vec())
20        .unwrap();
21
22    let handle = handle.data.as_slice().read_u16::<LittleEndian>().unwrap();
23    println!("The var hadle for {:?} is {:?}", var_name, handle);
24
25    let handle = client
26        .read_write(0, 4, var_name.as_bytes().to_vec())
27        .unwrap();
28    let handle = handle.data.as_slice().read_u16::<LittleEndian>().unwrap();
29    println!("The var hadle for {:?} is {:?}", var_name, handle);
30}

examples/read_device_info_example.rs (line 11)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //Read device info
16    let response = client.read_device_info().unwrap();
17    println!("Raw response:\n{:?}\n", response);
18    println!("Command ID            : {:?}", response.command_id);
19    println!("Major version         : {:?}", response.major_version);
20    println!("Minor version         : {:?}", response.minor_version);
21    println!("Version build         : {:?}", response.version_build);
22    println!("ADS Result            : {:?}", response.result);
23    println!("Device name bytes     : {:?}", response.device_name);
24    println!(
25        "Device name String    : {:?}",
26        String::from_utf8(response.device_name.to_vec())
27    );
28}

examples/notification_example.rs (line 14)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15
16    //Connect client
17    client.connect().expect("Failed to connect!");
18
19    //var name and length
20    let var = "Main.counter";
21    let len = 2;
22
23    //Subscribe to get notifications when "Main.counter" changes
24    let rx = client
25        .add_device_notification(var, len, AdsTransMode::OnChange, 1, 1)
26        .unwrap();
27
28    //Poll the mpsc receiver for new values
29    println!("Receive data...\n");
30    let mut list = Vec::new();
31    for _ in 1..10 {
32        let result = rx.recv();
33        if let Ok(r) = result.unwrap() {
34            list.push(r.ads_stamp_headers);
35        }        
36    }
37
38    println!("Print revceived data:\n");
39    for r in list {
40        println!("{:?}", r);
41    }
42
43    //Unsubscribe notifications
44    println!("\nDelete the notification");
45    let response = client.delete_device_notification(var);
46    println!("{:?}", response);
47}

examples/write_by_name_example.rs (line 11)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //var name and length
16    let var = "Main.counter";
17
18    //Write "1111" to var "Main.counter"
19    let value: u16 = 1111;
20    let data: Vec<u8> = value.to_le_bytes().to_vec();
21    let write_result = client
22        .write_by_name(var, data)
23        .expect("Failed to write value!");
24
25    println!("Write result -> {:?}", write_result.result);
26    println!("Command ID -> {:?}", write_result.command_id);
27
28    //var name and length
29    let var = "Main.mi_uint";
30
31    //Write "65530" to var "Main.mi_uint"
32    let value: u16 = 65530;
33    let data: Vec<u8> = value.to_le_bytes().to_vec();
34    let write_result = client
35        .write_by_name(var, data)
36        .expect("Failed to write value!");
37
38    println!("Write result -> {:?}", write_result.result);
39    println!("Command ID -> {:?}", write_result.command_id);
40
41    //Release handle if not needed anymore
42    let result = client.release_handle(var);
43    println!("{:?}", result);
44}

Additional examples can be found in:

Source

pub fn connect(&mut self) -> ClientResult<ReadStateResponse>

Connect to host and start reader thread. Fails if host is not reachable or if the reader thread can’t be started.

Examples found in repository ?

examples/write_control_example.rs (line 16)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15    //Connect client
16    client.connect().expect("Failed to connect!");
17
18    //Set PLC to stop
19    let ads_state = AdsState::AdsStateStop;
20    let response = client.write_control(ads_state, 0).unwrap();
21    println!("Command id    :{:?}", response.command_id);
22    println!("ADS result    :{:?}", response.result);
23}

More examples

Hide additional examples

examples/read_state_example.rs (line 13)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //Read state
16    let response = client.read_state().unwrap();
17    println!("Raw state response: {:?}\n", response);
18    println!("ADS state     : {:?}", response.ads_state);
19    println!("Device state  : {:?}", response.device_state);
20    println!("ADS result    : {:?}", response.result);
21    println!("Command ID    : {:?}", response.command_id);
22}

examples/read_write_example.rs (line 14)

7fn main() {
8    //Create client. If route = None then targed is local machine
9    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
10    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
11    //let mut client = Client::new(ams_address, Some(ipv4));
12    let mut client = Client::new(ams_address, None);
13    //Connect client
14    client.connect().expect("Failed to connect!");
15
16    //Get a var handle with read_write
17    let var_name = "Main.counter";
18    let handle = client
19        .read_write(0, 4, var_name.as_bytes().to_vec())
20        .unwrap();
21
22    let handle = handle.data.as_slice().read_u16::<LittleEndian>().unwrap();
23    println!("The var hadle for {:?} is {:?}", var_name, handle);
24
25    let handle = client
26        .read_write(0, 4, var_name.as_bytes().to_vec())
27        .unwrap();
28    let handle = handle.data.as_slice().read_u16::<LittleEndian>().unwrap();
29    println!("The var hadle for {:?} is {:?}", var_name, handle);
30}

examples/read_device_info_example.rs (line 13)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //Read device info
16    let response = client.read_device_info().unwrap();
17    println!("Raw response:\n{:?}\n", response);
18    println!("Command ID            : {:?}", response.command_id);
19    println!("Major version         : {:?}", response.major_version);
20    println!("Minor version         : {:?}", response.minor_version);
21    println!("Version build         : {:?}", response.version_build);
22    println!("ADS Result            : {:?}", response.result);
23    println!("Device name bytes     : {:?}", response.device_name);
24    println!(
25        "Device name String    : {:?}",
26        String::from_utf8(response.device_name.to_vec())
27    );
28}

examples/notification_example.rs (line 17)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15
16    //Connect client
17    client.connect().expect("Failed to connect!");
18
19    //var name and length
20    let var = "Main.counter";
21    let len = 2;
22
23    //Subscribe to get notifications when "Main.counter" changes
24    let rx = client
25        .add_device_notification(var, len, AdsTransMode::OnChange, 1, 1)
26        .unwrap();
27
28    //Poll the mpsc receiver for new values
29    println!("Receive data...\n");
30    let mut list = Vec::new();
31    for _ in 1..10 {
32        let result = rx.recv();
33        if let Ok(r) = result.unwrap() {
34            list.push(r.ads_stamp_headers);
35        }        
36    }
37
38    println!("Print revceived data:\n");
39    for r in list {
40        println!("{:?}", r);
41    }
42
43    //Unsubscribe notifications
44    println!("\nDelete the notification");
45    let response = client.delete_device_notification(var);
46    println!("{:?}", response);
47}

examples/write_by_name_example.rs (line 13)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //var name and length
16    let var = "Main.counter";
17
18    //Write "1111" to var "Main.counter"
19    let value: u16 = 1111;
20    let data: Vec<u8> = value.to_le_bytes().to_vec();
21    let write_result = client
22        .write_by_name(var, data)
23        .expect("Failed to write value!");
24
25    println!("Write result -> {:?}", write_result.result);
26    println!("Command ID -> {:?}", write_result.command_id);
27
28    //var name and length
29    let var = "Main.mi_uint";
30
31    //Write "65530" to var "Main.mi_uint"
32    let value: u16 = 65530;
33    let data: Vec<u8> = value.to_le_bytes().to_vec();
34    let write_result = client
35        .write_by_name(var, data)
36        .expect("Failed to write value!");
37
38    println!("Write result -> {:?}", write_result.result);
39    println!("Command ID -> {:?}", write_result.command_id);
40
41    //Release handle if not needed anymore
42    let result = client.release_handle(var);
43    println!("{:?}", result);
44}

Additional examples can be found in:

Source

pub fn request(&mut self, request: Request) -> ClientResult<Response>

Sends the supplied request Blocks until the response has been received or on error occures Fails if no tcp stream is available.

Examples found in repository ?

examples/request_example.rs (line 32)

8fn main() {
9    //Create client. If route = None then targed is local machine
10    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
11    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
12    //let mut client = Client::new(ams_address, Some(ipv4));
13    let mut client = Client::new(ams_address, None);
14    //Connect client
15    client.connect().expect("Failed to connect!");
16
17    //Create the requests manually and supply them to your request
18    let mut request_queue = Vec::new();
19    request_queue.push(Request::ReadDeviceInfo(ReadDeviceInfoRequest::new()));
20    request_queue.push(Request::ReadState(ReadStateRequest::new()));
21    let var = "Main.counter";
22    request_queue.push(Request::ReadWrite(ReadWriteRequest::new(
23        GET_SYMHANDLE_BY_NAME.index_group,
24        GET_SYMHANDLE_BY_NAME.index_offset_start,
25        4,
26        var.as_bytes().to_vec(),
27    )));
28
29    //read data directly (wait for response)
30    let queue = request_queue.clone();
31    for request in queue {
32        let result = client.request(request);
33        println!("\n{:?}", result);
34    }
35
36    //get mpsc tx channel and poll
37    let mut rx_queue = Vec::new();
38    for request in request_queue {
39        rx_queue.push(client.request_rx(request).expect("request_rx failed"));
40    }
41
42    let mut counter: u32 = 0;
43    let mut wait_count: u32 = 0;
44    while counter < 3 {
45        for rx in &rx_queue {
46            if let Ok(data) = rx.try_recv() {
47                println!("\n{:?}", data);
48                counter += 1;
49            } else {
50                wait_count += 1;
51            }
52        }
53    }
54
55    println!("\n{:?} loops while waiting for data", wait_count);
56}

Source

pub fn request_rx( &mut self, request: Request, ) -> ClientResult<Receiver<Result<Response>>>

Sends a request and returns imediatly a receiver object to read from (mpsc::Receiver). Fails if no tcp stream is available.

Examples found in repository ?

examples/request_example.rs (line 39)

8fn main() {
9    //Create client. If route = None then targed is local machine
10    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
11    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
12    //let mut client = Client::new(ams_address, Some(ipv4));
13    let mut client = Client::new(ams_address, None);
14    //Connect client
15    client.connect().expect("Failed to connect!");
16
17    //Create the requests manually and supply them to your request
18    let mut request_queue = Vec::new();
19    request_queue.push(Request::ReadDeviceInfo(ReadDeviceInfoRequest::new()));
20    request_queue.push(Request::ReadState(ReadStateRequest::new()));
21    let var = "Main.counter";
22    request_queue.push(Request::ReadWrite(ReadWriteRequest::new(
23        GET_SYMHANDLE_BY_NAME.index_group,
24        GET_SYMHANDLE_BY_NAME.index_offset_start,
25        4,
26        var.as_bytes().to_vec(),
27    )));
28
29    //read data directly (wait for response)
30    let queue = request_queue.clone();
31    for request in queue {
32        let result = client.request(request);
33        println!("\n{:?}", result);
34    }
35
36    //get mpsc tx channel and poll
37    let mut rx_queue = Vec::new();
38    for request in request_queue {
39        rx_queue.push(client.request_rx(request).expect("request_rx failed"));
40    }
41
42    let mut counter: u32 = 0;
43    let mut wait_count: u32 = 0;
44    while counter < 3 {
45        for rx in &rx_queue {
46            if let Ok(data) = rx.try_recv() {
47                println!("\n{:?}", data);
48                counter += 1;
49            } else {
50                wait_count += 1;
51            }
52        }
53    }
54
55    println!("\n{:?} loops while waiting for data", wait_count);
56}

Source

pub fn read_by_name( &mut self, var_name: &str, len: u32, ) -> ClientResult<ReadResponse>

Read a var value by it’s name. Returns ReadResponse

Examples found in repository ?

examples/read_by_name_example.rs (line 26)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(127, 0, 0, 1);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15    //Connect client
16    client.connect().expect("Failed to connect!");
17
18    //var name and length
19    let var = "Main.counter";
20    let len = 2;
21
22    //read data by name
23    let iterations = 10;
24    println!("Read var {:?} {:?} times", var, iterations);
25    for _ in 0..iterations {
26        match client.read_by_name(var, len) {
27            Ok(r) => {
28                println!("{:?}", r);
29            }
30            Err(e) => {
31                if e.is::<AdsError>() {
32                    if let Some(e) = e.downcast_ref::<AdsError>() {
33                        println!("Ads Error{:?}", e);
34                        if client.connect().is_ok() {
35                            println!("Reconnected...");
36                        } else {
37                            println!("Reconnecting failed...");
38                        }
39                    }
40                }
41                println!("Other Error{:?}", e);
42            }
43        }
44    }
45
46    //Release handle if not needed anymore
47    let result = client.release_handle(var);
48    println!("{:?}", result.unwrap());
49}

Source

pub fn sumup_read_by_name( &mut self, var_list: &HashMap<String, u32>, ) -> ClientResult<HashMap<String, ReadResponse>>

Read a list of var values by name. This will bundle all requested variables into a single request. Returns a HashMap<String, ReadResponse>

Examples found in repository ?

examples/sumup_read_by_name.rs (line 30)

11fn main() {
12    //Create client. If route = None then targed is local machine
13    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
14    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
15    //let mut client = Client::new(ams_address, Some(ipv4));
16    let mut client = Client::new(ams_address, None);
17    //Connect client
18    client.connect().expect("Failed to connect!");
19
20    //var name and length
21    let mut var_names = HashMap::new();
22    var_names.insert("Main.counter".to_string(), 2);
23    var_names.insert("Main.mi_uint".to_string(), 2);
24    var_names.insert("Main.mb_bool".to_string(), 1);
25
26    //read data vor all variables in the list with one (tcp) request
27    let iterations = 10;
28    let mut results: Vec<HashMap<String, ReadResponse>> = Vec::new();
29    for _ in 0..iterations {
30        match client.sumup_read_by_name(&var_names) {
31            Ok(r) => {
32                results.push(r);
33            }
34            Err(e) => {
35                if e.is::<AdsError>() {
36                    if let Some(e) = e.downcast_ref::<AdsError>() {
37                        println!("Some Ads Error: {:?}", e);
38                        if client.connect().is_ok() {
39                            println!("Reconnected...");
40                        } else {
41                            println!("Reconnecting failed...");
42                        }
43                    }
44                }
45                println!("Other Error: {:?}", e);
46            }
47        }
48    }
49
50    for r in results {
51        println!("{:?}", r);
52    }
53}

Source

pub fn write_by_name( &mut self, var_name: &str, data: Vec<u8>, ) -> ClientResult<WriteResponse>

Write by name Returns WriteResponse

Examples found in repository ?

examples/write_by_name_example.rs (line 22)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //var name and length
16    let var = "Main.counter";
17
18    //Write "1111" to var "Main.counter"
19    let value: u16 = 1111;
20    let data: Vec<u8> = value.to_le_bytes().to_vec();
21    let write_result = client
22        .write_by_name(var, data)
23        .expect("Failed to write value!");
24
25    println!("Write result -> {:?}", write_result.result);
26    println!("Command ID -> {:?}", write_result.command_id);
27
28    //var name and length
29    let var = "Main.mi_uint";
30
31    //Write "65530" to var "Main.mi_uint"
32    let value: u16 = 65530;
33    let data: Vec<u8> = value.to_le_bytes().to_vec();
34    let write_result = client
35        .write_by_name(var, data)
36        .expect("Failed to write value!");
37
38    println!("Write result -> {:?}", write_result.result);
39    println!("Command ID -> {:?}", write_result.command_id);
40
41    //Release handle if not needed anymore
42    let result = client.release_handle(var);
43    println!("{:?}", result);
44}

Source

pub fn sumup_write_by_name( &mut self, var_list: HashMap<String, Vec<u8>>, ) -> ClientResult<HashMap<String, WriteResponse>>

Write a list of var values by name. This will bundle all the write data into a single write request. Returns a HashMap<String, WriteResponse>

Examples found in repository ?

examples/sumup_write_by_name.rs (line 31)

12fn main() {
13    //Create client. If route = None then targed is local machine
14    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
15    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
16    //let mut client = Client::new(ams_address, Some(ipv4));
17    let mut client = Client::new(ams_address, None);
18    //Connect client
19    client.connect().expect("Failed to connect!");
20
21    //var name and length
22    let mut var_names: HashMap<String, Vec<u8>> = HashMap::new();
23    var_names.insert("Main.counter".to_string(), vec![0, 0]);
24    var_names.insert("Main.mi_uint".to_string(), vec![0, 0]);
25    var_names.insert("Main.mb_bool".to_string(), vec![1]);
26
27    //write data vor all variables in the list with one (tcp) request
28    let iterations = 10;
29    let mut results: Vec<HashMap<String, WriteResponse>> = Vec::new();
30    for _ in 0..iterations {
31        match client.sumup_write_by_name(var_names.clone()) {
32            Ok(r) => {
33                results.push(r);
34            }
35            Err(e) => {
36                if e.is::<AdsError>() {
37                    if let Some(e) = e.downcast_ref::<AdsError>() {
38                        println!("Some Ads Error{:?}", e);
39                        if client.connect().is_ok() {
40                            println!("Reconnected...");
41                        } else {
42                            println!("Reconnecting failed...");
43                        }
44                    }
45                }
46                println!("Other Error{:?}", e);
47            }
48        }
49    }
50
51    for r in results {
52        println!("{:?}", r);
53    }
54
55    //Release handle if not needed anymore
56    //let result = client.release_handle(var);
57    //println!("{:?}", result.unwrap());
58}

Source

pub fn read_device_info(&mut self) -> ClientResult<ReadDeviceInfoResponse>

Read device info Returns ReadDeviceInfoResponse

Examples found in repository ?

examples/read_device_info_example.rs (line 16)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //Read device info
16    let response = client.read_device_info().unwrap();
17    println!("Raw response:\n{:?}\n", response);
18    println!("Command ID            : {:?}", response.command_id);
19    println!("Major version         : {:?}", response.major_version);
20    println!("Minor version         : {:?}", response.minor_version);
21    println!("Version build         : {:?}", response.version_build);
22    println!("ADS Result            : {:?}", response.result);
23    println!("Device name bytes     : {:?}", response.device_name);
24    println!(
25        "Device name String    : {:?}",
26        String::from_utf8(response.device_name.to_vec())
27    );
28}

Source

pub fn read_state(&mut self) -> ClientResult<ReadStateResponse>

Read PLC state Returns ReadStateResponse

Examples found in repository ?

examples/read_state_example.rs (line 16)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //Read state
16    let response = client.read_state().unwrap();
17    println!("Raw state response: {:?}\n", response);
18    println!("ADS state     : {:?}", response.ads_state);
19    println!("Device state  : {:?}", response.device_state);
20    println!("ADS result    : {:?}", response.result);
21    println!("Command ID    : {:?}", response.command_id);
22}

Source

pub fn write_control( &mut self, ads_state: AdsState, device_state: u16, ) -> ClientResult<WriteControlResponse>

Write control Returns WriteControlResponse

Examples found in repository ?

examples/write_control_example.rs (line 20)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15    //Connect client
16    client.connect().expect("Failed to connect!");
17
18    //Set PLC to stop
19    let ads_state = AdsState::AdsStateStop;
20    let response = client.write_control(ads_state, 0).unwrap();
21    println!("Command id    :{:?}", response.command_id);
22    println!("ADS result    :{:?}", response.result);
23}

Source

pub fn read_write( &mut self, index_offset: u32, read_len: u32, write_data: Vec<u8>, ) -> ClientResult<ReadWriteResponse>

Read and write data Returns ReadWriteResponse

Examples found in repository ?

examples/read_write_example.rs (line 19)

7fn main() {
8    //Create client. If route = None then targed is local machine
9    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
10    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
11    //let mut client = Client::new(ams_address, Some(ipv4));
12    let mut client = Client::new(ams_address, None);
13    //Connect client
14    client.connect().expect("Failed to connect!");
15
16    //Get a var handle with read_write
17    let var_name = "Main.counter";
18    let handle = client
19        .read_write(0, 4, var_name.as_bytes().to_vec())
20        .unwrap();
21
22    let handle = handle.data.as_slice().read_u16::<LittleEndian>().unwrap();
23    println!("The var hadle for {:?} is {:?}", var_name, handle);
24
25    let handle = client
26        .read_write(0, 4, var_name.as_bytes().to_vec())
27        .unwrap();
28    let handle = handle.data.as_slice().read_u16::<LittleEndian>().unwrap();
29    println!("The var hadle for {:?} is {:?}", var_name, handle);
30}

Source

pub fn add_device_notification( &mut self, var_name: &str, length: u32, transmission_mode: AdsTransMode, max_delay: u32, cycle_time: u32, ) -> ClientResult<Receiver<Result<AdsNotificationStream, Error>>>

Add device notification to receive updated values at value change or at a certain time interfall Returns mpsc::receiver which can be polled

Examples found in repository ?

examples/notification_example.rs (line 25)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15
16    //Connect client
17    client.connect().expect("Failed to connect!");
18
19    //var name and length
20    let var = "Main.counter";
21    let len = 2;
22
23    //Subscribe to get notifications when "Main.counter" changes
24    let rx = client
25        .add_device_notification(var, len, AdsTransMode::OnChange, 1, 1)
26        .unwrap();
27
28    //Poll the mpsc receiver for new values
29    println!("Receive data...\n");
30    let mut list = Vec::new();
31    for _ in 1..10 {
32        let result = rx.recv();
33        if let Ok(r) = result.unwrap() {
34            list.push(r.ads_stamp_headers);
35        }        
36    }
37
38    println!("Print revceived data:\n");
39    for r in list {
40        println!("{:?}", r);
41    }
42
43    //Unsubscribe notifications
44    println!("\nDelete the notification");
45    let response = client.delete_device_notification(var);
46    println!("{:?}", response);
47}

Source

pub fn delete_device_notification( &mut self, var_name: &str, ) -> ClientResult<DeleteDeviceNotificationResponse>

Release a device notification on the host Returns DeleteDeviceNotificationResponse

Examples found in repository ?

examples/notification_example.rs (line 45)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15
16    //Connect client
17    client.connect().expect("Failed to connect!");
18
19    //var name and length
20    let var = "Main.counter";
21    let len = 2;
22
23    //Subscribe to get notifications when "Main.counter" changes
24    let rx = client
25        .add_device_notification(var, len, AdsTransMode::OnChange, 1, 1)
26        .unwrap();
27
28    //Poll the mpsc receiver for new values
29    println!("Receive data...\n");
30    let mut list = Vec::new();
31    for _ in 1..10 {
32        let result = rx.recv();
33        if let Ok(r) = result.unwrap() {
34            list.push(r.ads_stamp_headers);
35        }        
36    }
37
38    println!("Print revceived data:\n");
39    for r in list {
40        println!("{:?}", r);
41    }
42
43    //Unsubscribe notifications
44    println!("\nDelete the notification");
45    let response = client.delete_device_notification(var);
46    println!("{:?}", response);
47}

Source

pub fn release_handle(&mut self, var_name: &str) -> ClientResult<WriteResponse>

Release var handle

Examples found in repository ?

examples/write_by_name_example.rs (line 42)

6fn main() {
7    //Create client. If route = None then targed is local machine
8    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
9    //let ipv4 = Ipv4Addr::new(192, 168, 0, 150);
10    //let mut client = Client::new(ams_address, Some(ipv4));
11    let mut client = Client::new(ams_address, None);
12    //Connect client
13    client.connect().expect("Failed to connect!");
14
15    //var name and length
16    let var = "Main.counter";
17
18    //Write "1111" to var "Main.counter"
19    let value: u16 = 1111;
20    let data: Vec<u8> = value.to_le_bytes().to_vec();
21    let write_result = client
22        .write_by_name(var, data)
23        .expect("Failed to write value!");
24
25    println!("Write result -> {:?}", write_result.result);
26    println!("Command ID -> {:?}", write_result.command_id);
27
28    //var name and length
29    let var = "Main.mi_uint";
30
31    //Write "65530" to var "Main.mi_uint"
32    let value: u16 = 65530;
33    let data: Vec<u8> = value.to_le_bytes().to_vec();
34    let write_result = client
35        .write_by_name(var, data)
36        .expect("Failed to write value!");
37
38    println!("Write result -> {:?}", write_result.result);
39    println!("Command ID -> {:?}", write_result.command_id);
40
41    //Release handle if not needed anymore
42    let result = client.release_handle(var);
43    println!("{:?}", result);
44}

More examples

Hide additional examples

examples/read_by_name_example.rs (line 47)

9fn main() {
10    //Create client. If route = None then targed is local machine
11    let ams_address = AmsAddress::new(AmsNetId::new(192, 168, 0, 150, 1, 1), 851);
12    //let ipv4 = Ipv4Addr::new(127, 0, 0, 1);
13    //let mut client = Client::new(ams_address, Some(ipv4));
14    let mut client = Client::new(ams_address, None);
15    //Connect client
16    client.connect().expect("Failed to connect!");
17
18    //var name and length
19    let var = "Main.counter";
20    let len = 2;
21
22    //read data by name
23    let iterations = 10;
24    println!("Read var {:?} {:?} times", var, iterations);
25    for _ in 0..iterations {
26        match client.read_by_name(var, len) {
27            Ok(r) => {
28                println!("{:?}", r);
29            }
30            Err(e) => {
31                if e.is::<AdsError>() {
32                    if let Some(e) = e.downcast_ref::<AdsError>() {
33                        println!("Ads Error{:?}", e);
34                        if client.connect().is_ok() {
35                            println!("Reconnected...");
36                        } else {
37                            println!("Reconnecting failed...");
38                        }
39                    }
40                }
41                println!("Other Error{:?}", e);
42            }
43        }
44    }
45
46    //Release handle if not needed anymore
47    let result = client.release_handle(var);
48    println!("{:?}", result.unwrap());
49}