Struct ublox_cellular::DataService

pub struct DataService<'a, C, CLK, const N: usize, const L: usize> where
    C: AtatClient,
    CLK: 'static + Clock,  { /* fields omitted */ }

Implementations

impl<'a, C, CLK, const N: usize, const L: usize> DataService<'a, C, CLK, N, L> where
    C: AtatClient,
    CLK: 'static + Clock, 

pub fn try_new(
    apn_info: &APNInfo,
    network: &'a mut Network<C, CLK>,
    sockets: &'a mut SocketSet<CLK, N, L>
) -> Result<Self, Error> where
    Generic<CLK::T>: TryInto<Milliseconds>, 

pub fn send_at<A, const LEN: usize>(
    &mut self,
    cmd: &A
) -> Result<A::Response, Error> where
    A: AtatCmd<LEN>,
    A::Error: Into<UbloxError>, 

pub fn handle_urc<F: FnOnce(Urc) -> bool>(&mut self, f: F) -> Result<(), Error>

Trait Implementations

impl<'a, C, CLK, const N: usize, const L: usize> Dns for DataService<'a, C, CLK, N, L> where
    C: AtatClient,
    CLK: Clock, 

type Error = Error

The type returned when we have an error

fn get_host_by_address(
    &mut self,
    ip_addr: IpAddr
) -> Result<String<256>, Self::Error>

Resolve the hostname of a host, given its ip address

fn get_host_by_name(
    &mut self,
    hostname: &str,
    addr_type: AddrType
) -> Result<IpAddr, Self::Error>

Resolve the first ip address of a host, given its hostname and a desired address record type to look for

impl<'a, C, CLK, const N: usize, const L: usize> SSL for DataService<'a, C, CLK, N, L> where
    C: AtatClient,
    CLK: Clock, 

fn import_certificate(
    &mut self,
    profile_id: SecurityProfileId,
    name: &str,
    certificate: &[u8]
) -> Result<(), Error>

fn import_root_ca(
    &mut self,
    profile_id: SecurityProfileId,
    name: &str,
    root_ca: &[u8]
) -> Result<(), Error>

fn import_private_key(
    &mut self,
    profile_id: SecurityProfileId,
    name: &str,
    private_key: &[u8],
    password: Option<&str>
) -> Result<(), Error>

fn enable_ssl(
    &mut self,
    profile_id: SecurityProfileId,
    server_hostname: &str
) -> Result<(), Error>

impl<'a, C, CLK, const N: usize, const L: usize> TcpClientStack for DataService<'a, C, CLK, N, L> where
    C: AtatClient,
    CLK: Clock,
    Generic<CLK::T>: TryInto<Milliseconds>, 

fn socket(&mut self) -> Result<Self::TcpSocket, Self::Error>

Open a new TCP socket to the given address and port. The socket starts in the unconnected state.

fn connect(
    &mut self,
    socket: &mut Self::TcpSocket,
    remote: SocketAddr
) -> Result<(), Self::Error>

Connect to the given remote host and port.

fn is_connected(
    &mut self,
    socket: &Self::TcpSocket
) -> Result<bool, Self::Error>

Check if this socket is still connected

fn send(
    &mut self,
    socket: &mut Self::TcpSocket,
    buffer: &[u8]
) -> Result<usize, Self::Error>

Write to the stream. Returns the number of bytes written is returned (which may be less than buffer.len()), or an error.

fn receive(
    &mut self,
    socket: &mut Self::TcpSocket,
    buffer: &mut [u8]
) -> Result<usize, Self::Error>

Read from the stream. Returns Ok(n), which means n bytes of data have been received and they have been placed in &buffer[0..n], or an error.

fn close(&mut self, socket: Self::TcpSocket) -> Result<(), Self::Error>

Close an existing TCP socket.

type Error = Error

The type returned when we have an error

type TcpSocket = SocketHandle

The type returned when we create a new TCP socket

impl<'a, C, CLK, const N: usize, const L: usize> UdpClientStack for DataService<'a, C, CLK, N, L> where
    C: AtatClient,
    CLK: Clock,
    Generic<CLK::T>: TryInto<Milliseconds>, 

fn socket(&mut self) -> Result<Self::UdpSocket, Self::Error>

Open a new UDP socket to the given address and port. UDP is connectionless, so unlike TcpStack no connect() is required.

fn send(
    &mut self,
    socket: &mut Self::UdpSocket,
    buffer: &[u8]
) -> Result<(), Self::Error>

Send a datagram to the remote host.

fn receive(
    &mut self,
    socket: &mut Self::UdpSocket,
    buffer: &mut [u8]
) -> Result<(usize, SocketAddr), Self::Error>

Read a datagram the remote host has sent to us. Returns Ok(n), which means a datagram of size n has been received and it has been placed in &buffer[0..n], or an error.

fn close(&mut self, socket: Self::UdpSocket) -> Result<(), Self::Error>

Close an existing UDP socket.

type Error = Error

The type returned when we have an error

type UdpSocket = SocketHandle

The type returned when we create a new UDP socket

fn connect(
    &mut self,
    socket: &mut Self::UdpSocket,
    remote: SocketAddr
) -> Result<(), Self::Error>

Connect a UDP socket with a peer using a dynamically selected port.