PClient reference design shell commands

The pclient reference design can be used for basic interactive Wi-Fi and socket management, directly from the command line. The various commands will invoke different functions in the oWL pico api. This section will show examples of how to perform the following operations using the pclient:

All the steps and expected output is provided in detail below. See the end of this section for a complete list of supported commands.

Note that the console commands used in this sections are implemented in a very straightforward way. In most cases they will directly call a corresponding function in the oWL Pico API. See the table at the end of this section for more information.

For details on the implementation of the commands, see the file wlp_shell.c in the reference design.

Connect to an unprotected network

Networks are identified through SSID, which is the name of the network, and/or BSSID, which is the hardware address of the networks. Note that the SSID is not unqiue, so chances are there exists several networks in the range which have the same SSID. However, BSSID is unique for every network.

The “linkup” command can be used to connect to a chosen SSID. In this case we will choose a network with the ssid hdwireless

$ linkup hdwireless
ok 0 (success)

This will initiate a connect and the wifi device will continuously try to establish a connection to the specified SSID. Once connected, a notification will be shown in the console.

link_cb link:1

Since the Wi-Fi device will continuously try to connect to the specified SSID, an indication will only be given when the connection is established, or if an established connection is lost. If there is no indication for several seconds, the wifi device is probably unable to connect to the SSID at this time; the network might be out range or has an incompatible configuration (maybe encryption is enabled).

Once connected, we can get information about the SSID and BSSID of the current network by using the get_network command

$ get_network
ok 0 (hdwireless 68:7f:74:10:5b:4c)

Note that all commands display a return code and in case of failure, an error description.

If the connection to the access point is suddenly lost, the link notification should be shown again. If we power off the “hdwireless” access point now, the following will be shown in the console:

link_cb link:0

If we now request information about the current network, we’ll get an error code and the SSID will be empty and the BSSID will be all zeroes:

$ get_network
err -4 (N/A 00:00:00:00:00:00)

Note that the linkup commands only controls the wifi link layer. Linkup is similar to the procedure of connecting in a network cable in a wired network.

Assign an IP address using static configuration or DHCP

If a static network address configuration should be used, set it using the set_ipaddr command. The network configuration consists of the ip address, the network mask, the default gateway and dns server. These are all set through the set_ipaddr command:

$ set_ipaddr 192.168.2.30 255.255.255.0 192.168.2.1 192.168.2.1
ok 0 (success)
addr_cb ip:192.168.2.30
httpd started

The current ip address can be shown with the get_ipaddr command:

$ get_ipaddr
ok 0 (ip:192.168.2.30 mask:255.255.255.0 gw:192.168.2.1 dns:192.168.2.1)

To set a dynamic ip address with DHCP, the set_dhcp command should be used:

$ set_dhcp 1
ok 0 (success)
addr_cb ip:none
httpd stopped
addr_cb ip:192.168.2.101
httpd started

When set_dhcp is invoked, any current ip address will be removed first. Then a new ip address will be requested from the network. When a new address has been successfully assigned, the new address will be shown in the console output. Note that this reference design includes a HTTP server which is implemented using the owl Pico API. The HTTP server is started and stopped according to the current network state. For details about how to evaluate the HTTP server, see HTTPServer.

Also note that there must exist an DHCP server on the network which the wifi device is connected in order to successfully obtain an dynamic ip address. If a DHCP server is not available, the second addr_cb will never appear.

The ip address obtained from the DHCP server can be shown with the get_ipaddr command:

$ get_ipaddr
ok 0 (ip:192.168.2.101 mask:255.255.255.0 gw:192.168.2.1 dns:192.168.2.1)

Also note that the set_dhcp and set_ipaddr commands can be used several times to change the IP address and switch between static and dynamic IP address parameters at any time.

Verify the connection status with ping

The connection can be verified by using the ping command from a computer on the same network:

angr@blorg:~/work $ ping -c 3 192.168.2.101
PING 192.168.2.101 (192.168.2.101) 56(84) bytes of data.
64 bytes from 192.168.2.101: icmp_seq=1 ttl=255 time=4.66 ms
64 bytes from 192.168.2.101: icmp_seq=2 ttl=255 time=2.49 ms
64 bytes from 192.168.2.101: icmp_seq=3 ttl=255 time=2.10 ms

--- 192.168.2.101 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2003ms
rtt min/avg/max/mdev = 2.104/3.088/4.663/1.125 ms

Disconnect from the network

Disconnect from the network by using the command linkdown:

$ linkdown
ok 0 (success)
addr_cb ip:none
httpd stopped
link_cb link:0

This will initiate the disconnect procedure. When disconnect is completed the following will happen

1. the addr_cb will be shown in the console to inform us that we no longer have an ip address.

2. The http server included in the reference design will be stopped as a consequence of the addr_cb. For details about how to evaluate the HTTP server, see section HTTPServer.

3. The link_cb will be shown in the console to inform us that we no longer have a network link.

If we now request information about the current network, we’ll get an error code and the SSID will be empty and the BSSID will be all zeroes:

$ get_network
err -4 (N/A 00:00:00:00:00:00)

At this time we will get an error code if we request information about the current ip address since we do not have a network link:

$ get_ipaddr
err -4 (ip:0.0.0.0 mask:0.0.0.0 gw:0.0.0.0 dns:0.0.0.0)

The error code -4 indicates that we do not have a network link. See the owl Pico API reference documentation for wlp_get_ipaddr() for details about the error codes for get_ipaddr.

Note that any statically assigned network address (set_ipaddr) will be returned also when we don’t have a link.

Connect to a network using WEP security

Now, we will connect to an access point that uses WEP 64-bit encryption, shared key authentication and key index 1 set to 0102030405 (hexadecimal). Note that the last parameter (1) indicates that a WEP key is used.

$ linkup angr 0102030405 1
link_cb link:1

If no IP address configuration has been done yet, it can be configured at this time:

$ set_ipaddr 192.168.2.30 255.255.255.0 192.168.2.1 192.168.2.1
ok 0 (success)

Now it should be possible to verify the connection with ping:

angr@blorg:~/work $ ping -c 3 192.168.2.30
PING 192.168.2.30 (192.168.2.30) 56(84) bytes of data.
64 bytes from 192.168.2.30: icmp_seq=1 ttl=255 time=4.66 ms
64 bytes from 192.168.2.30: icmp_seq=2 ttl=255 time=2.49 ms
64 bytes from 192.168.2.30: icmp_seq=3 ttl=255 time=2.10 ms

--- 192.168.2.30 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2003ms
rtt min/avg/max/mdev = 2.104/3.088/4.663/1.125 ms

Connect to a network using WPA security

There exists several encryption and authentication methods that can be used in WPA security. PSK (pre-shared key) is the most common, where a secret key has been configured into the access point and the client is required to used the same key for authentication and data transfer.

To connect to the access point “hdwireless” that uses WPA security with the secret key “hdwirelesskey”, the following command can be used:

$ linkup hdwireless hdwirelesskey
link_cb link:1

If no IP address configuration has been done yet, it can be configured at this time:

$ set_ipaddr 192.168.2.30 255.255.255.0 192.168.2.1 192.168.2.1
ok 0 (success)

Now it should be possible to verify the connection with ping:

angr@blorg:~/work $ ping -c 3 192.168.2.30
PING 192.168.2.30 (192.168.2.30) 56(84) bytes of data.
64 bytes from 192.168.2.30: icmp_seq=1 ttl=255 time=4.66 ms
64 bytes from 192.168.2.30: icmp_seq=2 ttl=255 time=2.49 ms
64 bytes from 192.168.2.30: icmp_seq=3 ttl=255 time=2.10 ms

--- 192.168.2.30 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2003ms
rtt min/avg/max/mdev = 2.104/3.088/4.663/1.125 ms

Obtain the mac address from the Wi-Fi device

In some cases it can be useful to know the MAC (or hardware) address of the wifi device. Since it is a global unique identification it can be used to identity a hardware product. The command get_hwaddr should be used to get the MAC address:

$ get_hwaddr
ok 0 (7a:c4:0e:94:ea:84)

Connect to a remote TCP socket

So far, commands to configure and get information on the link and network layer has been used.

To perform actual communication with other devices or servers sockets can be used. There exists several commands to work with sockets. The following sections will give a brief introduction to the most basic socket operations.

In this example, we’ll connect to a TCP socket on a linux PC. We’ll create a listeing socket on the PC using the netcat utility:

angr@blorg:~/work $ nc -l -p 2000

The linux PC has the IP address 192.168.2.100 and is connected to the hdwireless AP (through wire or wireless).

As sockets operate above the link and network layer we need to establish the communication on those layers to have a working socket connection. Therefore, first establish the link and set the IP address as described in the beginning of this section:

$ linkup hdwireless
ok 0 (success)
link_cb: link:1

$ set_dhcp 1
addr_cb ip:192.168.2.101

Note that it is not required to establish the link and network layer before starting socket operations, but for clarity and simplicity we’ll use these sequential steps in this example.

First of all a socket must be created. A socket is a handle used to identify a connection of any kind. Since several connections can be used simultaneously, each socket has an id that must be specified for all socket operations. To create a TCP socket, the following command should be used:

$ socket stream
ok 2 (success)

The stream parameter indicates that a TCP socket should be used. The socket id will be returned (in this case the socket id was 2). Note that it is possible (and common) to create multiple sockets and use them simulateously, e.g. to communicate with several servers and/or provide several network services.

The next step is to connect the newly created socket to a remote endpoint. In this case we’ll connect to our PC which listens on 192.168.2.100, port 2000.

$ connect 2 192.168.2.100 2000
ok 0 (success)
conn_cb sockid:2 connected:1

This will start a connection attempt, the first reply will indicate that a connection could successfully be initiated. When the connection attempt is completed a message conn_cb sockid:2 connected:1 will be shown if the connection to was successful. In case of failure, e.g. due to server down, the message conn_cb sockid:2 connected:0 will be shown. The conn_cb message is asynchrounous and will be printed in case the connection is suddenly lost. Note that the sockid:2 part of the message indicates which socket the connection status refers to.

To send data to our netcat socket from the pclient application, the send command can be used:

$ send 2 Hello World
sending 11 bytes
wrote:11 remain:0
ok 0 (success)

The netcat application on the PC should now print the characters that was sent:

angr@blorg:~/work$ nc –l –p 2000
Hello World

If some text is entered in the netcat application, it will be sent to the pclient application:

angr@blorg:~/work$ nc –l –p 2000
Hello World
Goodbye world

The received data will be printed by pclient:

rx_cb sockid:1 len:14
RX - hexdump(len=14):
  47 6f 6f 64 62 79 65 20 77 6f 72 6c 64 0a       Goodbye world.

When we are done exchanging data, the socket can be closed with the close command:

$ close 2
ok 0 (success)

If we check the netcat application, it will terminate as the connection was closed. If we instead wanted to close the connection from the other end (i.e netcat), press Ctrl-c:

angr@blorg:~/work$ nc –l –p 2000
Hello World
Goodbye world
^C

The pclient will then show that the connection was closed by the remote end:

rx_cb: sockid:2 len:0 (connection lost)

Using this method, it is possible to connect to a remote TCP socket and exchange any kind of data. See the section about connection to a HTTP server for a more complex example.

Note that as long as the close command has not been issued, a socket can be reused for any new connection.

Listen for incoming TCP connections

In this example we will reverse the roles of the pclient application and the PC; the PC will connect to a TCP socket which the pclient application listens on.

As usual. first establish the link and set the IP address as described in the beginning of this section:

$ linkup hdwireless

ok 0 (success)
link_cb: link:1

$ set_dhcp 1
addr_cb ip:192.168.2.101

Then create the TCP socket:

$ socket stream
ok 2 (success)

Now we must tell the socket which port it should listen on, we must bind the socket:

$ bind 2 0.0.0.0 2000
ok 0 (success)

After binding the socket, we can start listening for incoming connections:

$ listen 2
ok 0 (success)

Now the pclient application will listen for incoming connections on port 2000. Use netcat to connect to the listening socket:

angr@blorg:~/work$ nc 192.168.2.101 2000

When a remote client connects to 192.168.2.101 port 2000, a notification will be printed:

listen_cb: sockid:1 accepting … ok 3 (success).

Note that when an incoming connection is accepted, a new socket is created. In this case the new socket was given the id 3. The original socket is still listening for more incoming connections on the same port.

To send data to the netcat application, the newly created socket id should be used:

$ send 3 Hello World

sending 11 bytes

wrote:11 remain:0
ok 0 (success)

In the netcat window we will now see the “Hello World” string:

angr@blorg:~/work$ nc 192.168.2.101 2000
Hello World

If some text is entered in the netcat application, it will be sent to the pclient application:

angr@blorg:~/work$ nc 192.168.2.101 2000

Hello World
Goodbye world

The received data will be printed by pclient:

rx_cb sockid:1 len:14
RX - hexdump(len=14):
  47 6f 6f 64 62 79 65 20 77 6f 72 6c 64 0a       Goodbye world.

Lookup a DNS name

The previous example where a TCP socket was used to communicate with a remote server used a fixed IP addresses to specifiy which server to connect to. oWL Pico API also has support for DNS, which means that we can lookup which IP address belongs to a given DNS name, e.g. www.hd-wireless.se.

To lookup a DNS name use the get_hostbyname command:

$ get_hostbyname www.hd-wireless.se
ok 0 (success)
lookup_cb: ip:194.218.94.80

In order to use get_hostbyname, we need to have a proper DNS server configured. This could either be done statically with the set_ipaddr command or dynamically with the set_dhcp command.

To see the current DNS server, use the get_ipaddr command:

$ get_ipaddr
ok 0 (ip:192.168.221.207 mask:255.255.255.0 gw:192.168.221.254 dns:192.168.221.254)

In this case the DNS server was 192.168.221.254. The IP address 194.218.94.80 can now be used to connect e.g. a TCP socket to www.hd-wireless.se:

$ socket stream
ok 2 (success)

$ connect 2 194.218.94.80 80
ok 0 (success)
conn_cb sockid:2 connected:1

Connect to a remote HTTP server through a TCP socket

In this example we’ll demonstrate how to connect to a web server on the local address 192.168.2.100 running on port 80.

First establish the link and set the IP address as described in the beginning of this section:

$ linkup hdwireless
ok 0 (success)
link_cb: link:1

$ set_dhcp 1
addr_cb ip:192.168.2.101

Then create the TCP socket:

$ socket stream
ok 2 (success)

The next step is to connect the newly created socket to a remote endpoint. In this case we’ll connect to the web server at the address 192.168.2.100, port 80.

$ connect 2 192.168.2.100 80
ok 0 (success)
conn_cb sockid:2 connected:1

After a few seconds the conn_cb status information will be printed. Some web servers will disconnect a client after a few seconds unless they send a request. If the remote end closes the connection, this will be indicated by recv_cb sockid:1 len:0 (connection closed).

To request the default web page from a web server, we must send a HTTP GET request according to the HTTP protocol. The minimal HTTP GET request is :

GET / HTTP/1.1
Accept: */*
User-Agent: oWL Pico
Host: 192.168.2.100

To send this data on our socket, the following command can be used:

$ send 2 GET / HTTP/1.1\r\nAccept: */*\r\nUser-Agent: oWL Pico\r\nHost:192.168.2.100\r\n\r\n
sending 72 bytes
wrote:72 remain:0
ok 0 (success)

Make sure to replace the IP address in the send command with the actual web server IP address. Upon successful transmission, the web server will reply with the default web page. The console application will show the web page as a hexdump:

RX - hexdump(len=64):
  48 54 54 50 2f 31 2e 31 20 32 30 30 20 4f 4b 0d HTTP/1.1 200 OK.
  0a 44 61 74 65 3a 20 4d 6f 6e 2c 20 32 30 20 44 .Date: Mon, 20 D
  65 63 20 32 30 31 30 20 31 32 3a 34 33 3a 30 36 ec 2010 12:43:06
  20 47 4d 54 0d 0a 53 65 72 76 65 72 3a 20 41 70  GMT..Server: Ap

RX - hexdump(len=64):
  61 63 68 65 2f 32 2e 32 2e 31 36 20 28 44 65 62 ache/2.2.16 (Deb
  69 61 6e 29 0d 0a 4c 61 73 74 2d 4d 6f 64 69 66 ian)..Last-Modif
  69 65 64 3a 20 46 72 69 2c 20 31 37 20 44 65 63 ied: Fri, 17 Dec
  20 32 30 31 30 20 31 34 3a 33 37 3a 33 31 20 47  2010 14:37:31 G

RX - hexdump(len=64):
  4d 54 0d 0a 45 54 61 67 3a 20 22 63 2d 62 31 2d MT..ETag: "c-b1-
  34 39 37 39 63 31 63 34 31 33 31 31 62 22 0d 0a 4979c1c41311b"..
  41 63 63 65 70 74 2d 52 61 6e 67 65 73 3a 20 62 Accept-Ranges: b
  79 74 65 73 0d 0a 43 6f 6e 74 65 6e 74 2d 4c 65 ytes..Content-Le

RX - hexdump(len=64):
  6e 67 74 68 3a 20 31 37 37 0d 0a 56 61 72 79 3a ngth: 177..Vary:
  20 41 63 63 65 70 74 2d 45 6e 63 6f 64 69 6e 67  Accept-Encoding
  0d 0a 43 6f 6e 74 65 6e 74 2d 54 79 70 65 3a 20 ..Content-Type:
  74 65 78 74 2f 68 74 6d 6c 0d 0a 0d 0a 3c 68 74 text/html....<ht

RX - hexdump(len=64):
  6d 6c 3e 3c 62 6f 64 79 3e 3c 68 31 3e 49 74 20 ml><body><h1>It
  77 6f 72 6b 73 21 3c 2f 68 31 3e 0a 3c 70 3e 54 works!</h1>.<p>T
  68 69 73 20 69 73 20 74 68 65 20 64 65 66 61 75 his is the defau
  6c 74 20 77 65 62 20 70 61 67 65 20 66 6f 72 20 lt web page for

RX - hexdump(len=64):
  74 68 69 73 20 73 65 72 76 65 72 2e 3c 2f 70 3e this server.</p>
  0a 3c 70 3e 54 68 65 20 77 65 62 20 73 65 72 76 .<p>The web serv
  65 72 20 73 6f 66 74 77 61 72 65 20 69 73 20 72 er software is r
  75 6e 6e 69 6e 67 20 62 75 74 20 6e 6f 20 63 6f unning but no co

RX - hexdump(len=46):
  6e 74 65 6e 74 20 68 61 73 20 62 65 65 6e 20 61 ntent has been a
  64 64 65 64 2c 20 79 65 74 2e 3c 2f 70 3e 0a 3c dded, yet.</p>.<
  2f 62 6f 64 79 3e 3c 2f 68 74 6d 6c 3e 0a       /body></html>.

The right column of the hexdump will contain the ascii data received, in this case it becomes:

HTTP/1.1 200 OK
Date: Mon, 20 Dec 2010 12:43:06 GMT
Server: Apache/2.2.16 (Debian)
Last-Modified: Fri, 17 Dec 2010 14:37:31 GMT
ETag: "c-b1-4979c1c41311b"
Accept-Ranges: bytes
Content-Length: 177
Vary: Accept-Encoding
Content-Type: text/html

<html><body><h1><It works!</h1>
<p>This is the default web page for this server.</p>
<p>The web server software is running but no content has been added, yet.</p>
</body></html>

When the complete response has been received the web server will close the connection and this will be indicated in the console:

$ rx_cb sockid:2 len:0 (connection lost)

Communicate with UDP sockets

As opposed to TCP sockets, UDP socket are connectionless and allows the sending of datagrams to named correspondents by using the sendto command.

First establish the link and set the IP address as described in the beginning of this section:

link_cb: link:1
$ set_dhcp 1
addr_cb ip:192.168.2.101

$ linkup hdwireless
ok 0 (success)

We will create an UDP socket on our linux PC that we will communicate with. We use the netcat utility to create a UDP socket which will be bound to port 2000:

angr@blorg:~/work $ nc -l -u -p 2000

Now, we will create an UDP socket and use it to transfer data to our PC using the socket and sendto commands:

$ socket dgram
ok 2 (success)

$ sendto 2 192.168.2.100 2000 foo
sending 3 bytes to 192.168.2.100:2000
wrote:3 remain:0
ok 0 (success)

The sent data (foo) should now be printed by the netcat application running on the PC. Note that we did not explicitly bind or connect our UDP socket to anything. Instead, we named the full destination of the data in the sendto command. Therefore, our UDP socket will now listen for incoming data on a random port. However, if any text is entered in the netcat window on the PC, it will still be received and shown by the pclient application. The reason is that netcat will send all data to the same address as it received data from:

Type 'bar' in the netcat window on the linux PC:

angr@blorg:~/work $ nc -l -u -p 2000
foo<strong>bar</strong>

The data will be shown by the pclient application:

$ recv_cb sockid:2 len:4 
RX - hexdump(len=4):
   62 61 72 0a                                     bar.

By using the bind and connect commands on UDP sockets, a more specific binding local and remote addresses will be set. See the oWL Pico API documentation for detailed information.

List of commands

As already mentioned, most of the commands in the pclient application maps directly to a function in the oWL Pico API. Further, the commands and oWL Pico API function can be divided into three groups, depending on which layer the operate on.

See wlp_api.h for details on the operation of each API function.

The link layer commands enables access and operations to link layer functions:

PClient Command	oWL Pico API Function	Description	Ver
linkup <ssid> [key] [wep]	wlp_linkup(ssid, key, wep)	Connect to an access point
linkdown	wlp_linkdown()	Disconnect from an access point
get_hwaddr	wlp_get_hwaddr()	Get the device MAC address
get_network	wlp_get_network()	Get information about the current access point
set_heartbeat <ms>	wlp_set_heartbeat(ms)	Set the device link heartbeat for keep-alive
set_channel <channel>	wlp_set_channel(channel)	Set the channel used in access point mode
get_linkctx	wlp_get_linkctx()	Retrieve information about the link.
set_linkctx	wlp_set_linkctx()	Set context for the link.
set_wps <enable>	wlp_set_wps(enable)	Enable or disable WPS (Wi-Fi protected setup).
scan	wlp_scan()	Start a scan on all channels.

The network layer commands allows the client to control IP address configuration:

PClient Command	oWL Pico API Function	Description	Ver
set_ipaddr <ip> [mask] gw] [dns]	wlp_set_ipaddr(ip, mask, gw, dns)	Set a static IP address
get_ipaddr	wlp_get_ipaddr()	Get the current IP address
set_dhcp <enable>	wlp_set_dhcp(enable)	Request or release a dynamic IP address
get_dhcp	wlp_get_dhcp()	Check if dhcp is enabled
get_hostbyname <host>	wlp_get_hostbyname(host)	Lookup an IP address given a DNS name
set_dhcpd <enable>	wlp_set_dhcpd(enable)	Enable/disable device DHCP server

The socket layer allows operations on different kinds of network sockets:

PClient Command	oWL Pico API Function	Description	Ver
socket <type> [protocol]	wlp_socket(type, protocol)	Create a socket
bind <socket> <ip> <port>	wlp_bind(socket, ip, port)	Bind the socket a local address
listen <socket>	wlp_listen(socket)	Listen for incoming connections
connect <socket> <ip> <port>	wlp_connect(socket, ip, port)	Connect to a remote host
close <socket>	wlp_close(socket)	Close the socket
send <socket> <data>	wlp_send(socket, data, len)	Send data to a connected socket
recv <socket>	wlp_recv(socket)	Read pending data from a socket.
sendto <socket> <data> <ip> <port>	wlp_sendto(socket, data, ip, port)	Send data to a specified address from a socket.
get_peeraddr <socket>	wlp_get_peeraddr(socket, &peer)	Get name of connected peer socket

The power management group of functions allows the device to be configured to optimize the power consumption:

PClient Command	oWL Pico API Function	Description	Ver
set_ps <enable>	wlp_set_ps(enable)	Enable/disable device Wi-Fi power management
conf_ps <ps poll> <traffic imeout> <delay> <rx all dtim> <listen interval>	wlp_conf_ps(ps_poll, ps_traffic_timeout, ps_delay, rx_all_dtim, listen_interval)	Configure device Wi-Fi poewr management
set_led <enable>	wlp_set_led(enable)	Enable/disable device leds to save power.
set_poll_period <period>	wlp_set_poll_period(period)	Set the device tick.

Implementation example commands:

PClient Command	oWL Pico API Function	Description	Ver
ttcp		ttcp throughput test
ntp <ntp-server>		get server time from ntp.
ping <ip>		ping

The wlp_api library managment group includes the following functions:

PClient Command	oWL Pico API Function	Description	Ver
set_mode <mode>	wlp_set_mode(mode)	Set the device operation mode to station or access point.
get_mode	wlp_get_mode()	Get the device current operation mode, station or access point.
set_baudrate <baudrate> <rtscts>	wlp_set_baudrate(baudrate, rtscts)	Set the baudrate of the host-device interrface
fw_upgrade <method> <addr> <port> <path>	wlp_fw_upgrade(method, addr, port, path)	Upgrade device firmware over the air.
get_version	wlp_version()	Get client version
get_fw_version	wlp_get_fw_version()	Get the device firmware and hardware version.
get_fw_caps	wlp_get_fw_caps()	Get the device firmware capabilities