Struct DigiMeshDevice

pub struct DigiMeshDevice {
    pub addr_64bit: Option<u64>,
    pub node_id: Option<String>,
    pub firmware_version: Option<u16>,
    pub hardware_version: Option<u16>,
    pub nodes: Option<Vec<RemoteDigiMeshDevice>>,
    /* private fields */
}

Fields

addr_64bit: Option<u64>

node_id: Option<String>

firmware_version: Option<u16>

hardware_version: Option<u16>

nodes: Option<Vec<RemoteDigiMeshDevice>>

Implementations

impl DigiMeshDevice

pub fn new<'a>(port: &'a str, baud: u32) -> Result<Self>

Examples found in repository

examples/atcommand_query.rs (line 18)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    // Construct At command to ask for node_id of device
    let node_id_request = api::AtCommandFrame("NI", None);
    // returns dyn trait RecieveApiFrame
    let response = device.send_frame(node_id_request)?;
    // We can downcast to original AtCommandResponse struct to access members
    let atcommand_response = response.downcast_ref::<api::AtCommandResponse>();

    if let Some(obj) = atcommand_response {
        let cmd_data = &obj.command_data;
        println!("{:?}", cmd_data);
    }

    Ok(())
}

examples/atcommand_set.rs (line 20)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    // Construct At command and set node_id of device by supplying valid [u8] but None
    let _ = api::AtCommandFrame("NI", Some(NODE_ID.as_bytes()));

    // Now query new node_id
    let new_node_id = api::AtCommandFrame("NI", None);

    // returns dyn trait RecieveApiFrame
    let response = device.send_frame(new_node_id)?;

    // We can downcast to original AtCommandResponse struct to access members
    let atcommand_response = response.downcast_ref::<api::AtCommandResponse>();

    if let Some(obj) = atcommand_response {
        let cmd_data = &obj.command_data;
        println!("{:?}", cmd_data); // Some(b"MY_NODE")
    }

    Ok(())
}

examples/remote_atcommand_set.rs (line 19)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    let set_all_id = api::RemoteAtCommandFrame {
        dest_addr: api::BROADCAST_ADDR,
        options: &api::RemoteCommandOptions {
            apply_changes: true,
        },
        atcmd: "ID",
        cmd_param: Some(b"\x7f\xff"), // change all devices on same ID to a new ID (0x7fff)
    };

    let _ = device.send_frame(set_all_id)?;

    let get_all_id = api::RemoteAtCommandFrame {
        dest_addr: DEST_ADDR,
        options: &api::RemoteCommandOptions {
            apply_changes: true,
        },
        atcmd: "ID",
        cmd_param: None,
    };

    let response = device.send_frame(get_all_id)?;

    if let Some(resp) = response.downcast_ref::<api::RemoteAtCommandResponse>() {
        println!("{:?}", resp.command_data);
    }

    Ok(())
}

examples/transmit_request.rs (line 22)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    let broadcast = api::TransmitRequestFrame {
        dest_addr: api::BROADCAST_ADDR,
        broadcast_radius: 0,
        options: Some(&api::TransmitRequestOptions {
            disable_ack: false,
            disable_route_discovery: false,
            enable_unicast_nack: false,
            enable_unicast_trace_route: false,
            mode: api::MessagingMode::DigiMesh,
        }),
        payload: b"HELLO FROM RUST!!",
    };
    // all devices with same Network ID will have the payload broadcasted too.
    let _transmit_status = device.send_frame(broadcast)?;

    let unicast_msg = api::TransmitRequestFrame {
        dest_addr: DEST_ADDR,
        broadcast_radius: 0,
        options: Some(&api::TransmitRequestOptions {
            disable_ack: false,
            disable_route_discovery: false,
            enable_unicast_nack: false,
            enable_unicast_trace_route: false,
            mode: api::MessagingMode::DigiMesh,
        }),

        payload: b"Hello individual device!",
    };

    // will send payload to DEST_ADDR if it is found on the same network ID
    let transmit_status = device.send_frame(unicast_msg)?;
    println!("{:?}", transmit_status); // review the status of the transmit
    Ok(())
}

pub fn get_firmware_version(&mut self) -> Result<u16>

pub fn get_hardware_version(&mut self) -> Result<u16>

pub fn get_node_id(&mut self) -> Result<String>

pub fn get_64bit_addr(&mut self) -> Result<u64>

pub fn send<'a>(&mut self, data: &'a [u8]) -> Result<usize>

pub fn discover_nodes(&mut self, timeout: Option<Duration>) -> Result<()>

pub fn send_frame<T: TransmitApiFrame>( &mut self, frame: T, ) -> Result<Box<dyn RecieveApiFrame>>

Examples found in repository

examples/atcommand_query.rs (line 23)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    // Construct At command to ask for node_id of device
    let node_id_request = api::AtCommandFrame("NI", None);
    // returns dyn trait RecieveApiFrame
    let response = device.send_frame(node_id_request)?;
    // We can downcast to original AtCommandResponse struct to access members
    let atcommand_response = response.downcast_ref::<api::AtCommandResponse>();

    if let Some(obj) = atcommand_response {
        let cmd_data = &obj.command_data;
        println!("{:?}", cmd_data);
    }

    Ok(())
}

examples/atcommand_set.rs (line 29)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    // Construct At command and set node_id of device by supplying valid [u8] but None
    let _ = api::AtCommandFrame("NI", Some(NODE_ID.as_bytes()));

    // Now query new node_id
    let new_node_id = api::AtCommandFrame("NI", None);

    // returns dyn trait RecieveApiFrame
    let response = device.send_frame(new_node_id)?;

    // We can downcast to original AtCommandResponse struct to access members
    let atcommand_response = response.downcast_ref::<api::AtCommandResponse>();

    if let Some(obj) = atcommand_response {
        let cmd_data = &obj.command_data;
        println!("{:?}", cmd_data); // Some(b"MY_NODE")
    }

    Ok(())
}

examples/remote_atcommand_set.rs (line 30)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    let set_all_id = api::RemoteAtCommandFrame {
        dest_addr: api::BROADCAST_ADDR,
        options: &api::RemoteCommandOptions {
            apply_changes: true,
        },
        atcmd: "ID",
        cmd_param: Some(b"\x7f\xff"), // change all devices on same ID to a new ID (0x7fff)
    };

    let _ = device.send_frame(set_all_id)?;

    let get_all_id = api::RemoteAtCommandFrame {
        dest_addr: DEST_ADDR,
        options: &api::RemoteCommandOptions {
            apply_changes: true,
        },
        atcmd: "ID",
        cmd_param: None,
    };

    let response = device.send_frame(get_all_id)?;

    if let Some(resp) = response.downcast_ref::<api::RemoteAtCommandResponse>() {
        println!("{:?}", resp.command_data);
    }

    Ok(())
}

examples/transmit_request.rs (line 37)

fn main() -> Result<(), Box<dyn error::Error>> {
    // first create instance of device
    let mut device = DigiMeshDevice::new(PORT, 9600)?;

    let broadcast = api::TransmitRequestFrame {
        dest_addr: api::BROADCAST_ADDR,
        broadcast_radius: 0,
        options: Some(&api::TransmitRequestOptions {
            disable_ack: false,
            disable_route_discovery: false,
            enable_unicast_nack: false,
            enable_unicast_trace_route: false,
            mode: api::MessagingMode::DigiMesh,
        }),
        payload: b"HELLO FROM RUST!!",
    };
    // all devices with same Network ID will have the payload broadcasted too.
    let _transmit_status = device.send_frame(broadcast)?;

    let unicast_msg = api::TransmitRequestFrame {
        dest_addr: DEST_ADDR,
        broadcast_radius: 0,
        options: Some(&api::TransmitRequestOptions {
            disable_ack: false,
            disable_route_discovery: false,
            enable_unicast_nack: false,
            enable_unicast_trace_route: false,
            mode: api::MessagingMode::DigiMesh,
        }),

        payload: b"Hello individual device!",
    };

    // will send payload to DEST_ADDR if it is found on the same network ID
    let transmit_status = device.send_frame(unicast_msg)?;
    println!("{:?}", transmit_status); // review the status of the transmit
    Ok(())
}

pub fn atcmd<'a>(&mut self, atcmd: &'a AtCommand<'_>) -> Result<()>

send an AT command and returns the result

pub fn command_mode(&mut self, mode: bool) -> Result<()>

Trait Implementations

impl Debug for DigiMeshDevice

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.