Revision 12:3799f8475c8a, committed 2016-05-14

Comitter:

mridup

Date:

Sat May 14 08:31:39 2016 +0000

Parent:

11:67a8c3499caf

Child:

13:cdcc13d78252

Commit message:

comments added.

Changed in this revision

--- a/SPWFInterface.cpp	Sat May 14 07:28:29 2016 +0000
+++ b/SPWFInterface.cpp	Sat May 14 08:31:39 2016 +0000
@@ -48,17 +48,36 @@
     isInitialized = false;
     isListening = false;
 }
- 
+
+/**
+* @brief  SpwfSAInterface destructor         
+* @param  none
+* @retval none
+*/
 SpwfSAInterface::~SpwfSAInterface()
 {
 }
 
+/**
+* @brief  init function
+          initializes SPWF FW and module         
+* @param  none
+* @retval error value
+*/
 int SpwfSAInterface::init(void) 
 {
     _spwf.setTimeout(SPWF_MISC_TIMEOUT);
     return (_spwf.init());
 }
 
+/**
+* @brief  network connect
+          connects to Access Point
+* @param  ap: Access Point (AP) Name String  
+*         pass_phrase: Password String for AP
+*         security: type of NSAPI security supported
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::connect(
     const char *ap, 
     const char *pass_phrase, 
@@ -78,28 +97,50 @@
     
     WiFi_Priv_Mode mode = (WiFi_Priv_Mode)security;
   
-    return (_spwf.connect((char*)ap, (char*)pass_phrase, mode));//0 on success
+    return (_spwf.connect((char*)ap, (char*)pass_phrase, mode));
 }
- 
+
+/**
+* @brief  network disconnect
+          disconnects from Access Point
+* @param  none
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::disconnect()
 {    
     return (_spwf.disconnect());
 }
- 
+
+/** 
+* @brief  Get the local IP address
+* @param  none
+* @retval Null-terminated representation of the local IP address
+*         or null if not yet connected
+*/
 const char *SpwfSAInterface::get_ip_address()
 {
     return _spwf.getIPAddress();
 }
- 
+
+/** 
+* @brief  Get the MAC address
+* @param  none
+* @retval Null-terminated representation of the MAC address
+*         or null if not yet connected
+*/
 const char *SpwfSAInterface::get_mac_address()
 {
     return _spwf.getMACAddress();
 }
 
-
+/**
+* @brief  open a socket handle
+* @param  handle: Pointer to handle
+*         proto: TCP/UDP protocol
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::socket_open(void **handle, nsapi_protocol_t proto)
 {
-    // Look for an unused socket
     int id = -1;    
 
     struct spwf_socket *socket = new struct spwf_socket;
@@ -115,6 +156,12 @@
     return 0;
 }
 
+/**
+* @brief  connect to a remote socket
+* @param  handle: Pointer to socket handle
+*         addr: Address to connect to
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::socket_connect(void *handle, const SocketAddress &addr)
 {
     uint8_t sock_id = 99;
@@ -130,7 +177,6 @@
       
     if(sock_id <= SPWFSA_SOCKET_COUNT)
     {
-        //_ids[socket->id] = false;
         socket->id = sock_id;//the socket ID of this Socket instance
         _ids[socket->id] = true;
         socket->connected = true;
@@ -138,9 +184,15 @@
     else 
         return NSAPI_ERROR_NO_SOCKET;
     
-    return 0;//0 means SUCCESS
+    return 0;
 }
 
+/**
+* @brief  bind to a port number and address
+* @param  handle: Pointer to socket handle
+*         proto: address to bind to
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::socket_bind(void *handle, const SocketAddress &address)
 {
     struct spwf_socket *socket = (struct spwf_socket *)handle;    
@@ -148,6 +200,12 @@
     return 0;
 }
 
+/**
+* @brief  start listening on a port and address
+* @param  handle: Pointer to handle
+*         backlog: not used (always value is 1)
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::socket_listen(void *handle, int backlog)
 {
     struct spwf_socket *socket = (struct spwf_socket *)handle;
@@ -171,6 +229,12 @@
     return err;
 }
 
+/**
+* @brief  accept connections from remote sockets
+* @param  handle: Pointer to handle of client socket (connecting)
+*         proto: handle of server socket which will accept connections
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::socket_accept(void **handle, void *server)
 {
     struct spwf_socket *server_socket = (struct spwf_socket *)server;
@@ -195,13 +259,18 @@
         
         *handle = socket; 
         socket = 0;
-        _spwf.set_wait_for_incoming_client(false);//reset
+        _spwf.set_wait_for_incoming_client(false);
         wait_ms(50);//CHECK:TODO:Why do we need this?
         return 0;
     }    
     return NSAPI_ERROR_WOULD_BLOCK;
 }
 
+/**
+* @brief  close a socket
+* @param  handle: Pointer to handle
+* @retval NSAPI Error Type
+*/
 int SpwfSAInterface::socket_close(void *handle)
 {
     struct spwf_socket *socket = (struct spwf_socket *)handle;
@@ -230,6 +299,13 @@
     return err;
 }
 
+/**
+* @brief  write to a socket
+* @param  handle: Pointer to handle
+*         data: pointer to data
+*         size: size of data
+* @retval no of bytes sent
+*/
 int SpwfSAInterface::socket_send(void *handle, const void *data, unsigned size)
 {    
     struct spwf_socket *socket = (struct spwf_socket *)handle;
@@ -250,7 +326,13 @@
     return err;
 }
 
-//return no of bytes read
+/**
+* @brief  receive data on a socket
+* @param  handle: Pointer to handle
+*         data: pointer to data
+*         size: size of data
+* @retval no of bytes read
+*/
 int SpwfSAInterface::socket_recv(void *handle, void *data, unsigned size)
 {
     struct spwf_socket *socket = (struct spwf_socket *)handle;
@@ -267,6 +349,14 @@
     
 }
 
+/**
+* @brief  send data to a udp socket
+* @param  handle: Pointer to handle
+*         addr: address of udp socket
+*         data: pointer to data
+*         size: size of data
+* @retval no of bytes sent
+*/
 int SpwfSAInterface::socket_sendto(void *handle, const SocketAddress &addr, const void *data, unsigned size)
 {
     struct spwf_socket *socket = (struct spwf_socket *)handle;
@@ -280,17 +370,38 @@
     return socket_send(socket, data, size);
 }
 
+/**
+* @brief  receive data on a udp socket
+* @param  handle: Pointer to handle
+*         addr: address of udp socket
+*         data: pointer to data
+*         size: size of data
+* @retval no of bytes read
+*/
 int SpwfSAInterface::socket_recvfrom(void *handle, SocketAddress *addr, void *data, unsigned size)
 {
     struct spwf_socket *socket = (struct spwf_socket *)handle;    
     return socket_recv(socket, data, size);
 }
 
+/**
+* @brief  attach function/callback to the socket
+*         Not used
+* @param  handle: Pointer to handle
+*         callback: callback function pointer
+*         data: pointer to data
+* @retval none
+*/
 void SpwfSAInterface::socket_attach(void *handle, void (*callback)(void *), void *data)
 {
     //No implementation yet
 }
 
+/**
+* @brief  utility debug function for printing to serial terminal
+* @param  string: Pointer to data
+* @retval none
+*/
 void SpwfSAInterface::debug(const char * string)
 {
     _spwf.debug_print(string);

--- a/Spwf/wifi_driver.c	Sat May 14 07:28:29 2016 +0000
+++ b/Spwf/wifi_driver.c	Sat May 14 08:31:39 2016 +0000
@@ -45,16 +45,34 @@
 #include "string.h"
 #include "wifi_driver.h"
 
+/**
+* @brief  Wi-Fi System Tick IRQ handler
+*         retrieves byte(s) from the ring buffer
+* @param  None
+* @retval None
+*/
 void Wifi_ticker(void)
 {
   Wifi_SysTick_Isr();
 }
 
+/**
+* @brief  Wi-Fi Scheduler handler
+*         Fetches events from event buffer/makes callbacks to User
+* @param  None
+* @retval None
+*/
 void Wifi_scheduler(void)
 { 
   Wifi_TIM_Handler();
 }
 
+/**
+* @brief  UART RX IRQ handler
+*         stores a byte to the ring buffer
+* @param  None
+* @retval None
+*/
 void Rx_irq_handler(void)
 {
 

--- a/Spwf_API/SpwfSADevice.cpp	Sat May 14 07:28:29 2016 +0000
+++ b/Spwf_API/SpwfSADevice.cpp	Sat May 14 08:31:39 2016 +0000
@@ -1,5 +1,5 @@
 /* mbed Microcontroller Library
-* Copyright (c) 2006-2013 ARM Limited
+* Copyright (c) 20015 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -51,6 +51,15 @@
 
 extern void setSpwfSADevice(SpwfSADevice * dev);
 
+/**
+* @brief  SpwfSADevice constructor         
+* @param  tx: Pin USART TX  
+*         rx: Pin USART RX
+*         rst: reset pin for Spwf module
+*         wkup: reset pin for Spwf module
+*         rts: Pin USART RTS
+* @retval none
+*/
 SpwfSADevice::SpwfSADevice(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts):
     uart_(tx,rx), 
     term_(SERIAL_TX, SERIAL_RX),
@@ -64,11 +73,22 @@
     wait_for_socket_data = false;
 }
 
+/**
+* @brief  SpwfSADevice destructor         
+* @param  none
+* @retval none
+*/
 SpwfSADevice::~SpwfSADevice(void)
 {
     //de-constructor
 }
 
+/**
+* @brief  init function
+          initializes timers, gpios, uart
+* @param  none
+* @retval error value
+*/
 int SpwfSADevice::init(void) 
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -116,6 +136,14 @@
     return 0;
 }
 
+/**
+* @brief  network connect
+          wrapper function for FW
+* @param  ssid: Access Point (AP) Name String  
+*         sec_key: Password String for AP
+*         priv_mode: type of security supported (FW mode)
+* @retval NSAPI Error Type
+*/
 int SpwfSADevice::connect(char * ssid, char * sec_key, WiFi_Priv_Mode priv_mode) 
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -140,6 +168,12 @@
     return 0;
 }
 
+/**
+* @brief  network disconnect
+          wrapper function for FW
+* @param  none
+* @retval error value
+*/
 int SpwfSADevice::disconnect()
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -153,6 +187,13 @@
     return 0;
 }
 
+/** 
+* @brief  Get the local IP address
+*         wrapper function for FW
+* @param  none
+* @retval Null-terminated representation of the local IP address
+*         or null if not yet connected
+*/
 const char *SpwfSADevice::getIPAddress()
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -166,6 +207,13 @@
         return _ip_buffer;
 }
 
+/** 
+* @brief  Get the MAC address
+*         wrapper function for FW
+* @param  none
+* @retval Null-terminated representation of the MAC address
+*         or null if not yet connected
+*/
 const char *SpwfSADevice::getMACAddress()
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -179,6 +227,14 @@
         return _mac_buffer;
 }
 
+/**
+* @brief  connect to a remote socket
+* @param  hostname: address of socket
+          port_number: port number to connect
+          protocol: TCP/UDP protocol
+*         sock_id: pointer to socket ID returned by FW
+* @retval error value
+*/
 int SpwfSADevice::socket_client_open(uint8_t * hostname, uint32_t port_number, uint8_t * protocol, uint8_t * sock_id)
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -194,7 +250,13 @@
     return 0;
 }
 
-
+/**
+* @brief  write to a remote socket
+* @param  sock_id: FW ID of the socket
+          DataLength: size of the data
+          pData: pointer to data
+* @retval error value
+*/
 int SpwfSADevice::socket_client_write(uint8_t sock_id, uint16_t DataLength,char * pData)
 {
     int status=0;//number of bytes
@@ -209,7 +271,13 @@
     return 0;
 }
 
-
+/**
+* @brief  receive from a remote socket
+* @param  sock_id: FW ID of the socket
+          DataLength: size of the data
+          pData: pointer to data
+* @retval error value
+*/
 int SpwfSADevice::socket_client_recv(uint8_t sock_id, uint16_t RecvLength,char * pData)
 {
     static Timer recv_timer;
@@ -248,7 +316,12 @@
     return -1;    
 }
 
-
+/**
+* @brief  scan the network
+* @param  scan_result: scan result data pointer
+          max_scan_number: size of the scan result 
+* @retval error value
+*/
 void SpwfSADevice::network_scan(wifi_scan *scan_result, uint16_t max_scan_number)
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -260,6 +333,13 @@
     }
 }
 
+/**
+* @brief  HTTP GET from remote host
+* @param  hostname: address of remote host
+          path: path to resource
+          port_number: port number
+* @retval none
+*/
 void SpwfSADevice::http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number)
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -271,6 +351,11 @@
     }    
 }
 
+/**
+* @brief  HTTP GET from remote host
+* @param  url_path: complete url of remote resource
+* @retval none
+*/
 void SpwfSADevice::http_post(uint8_t * url_path)
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -282,6 +367,14 @@
     }    
 }
 
+/**
+* @brief  FW callback with data in socket
+* @param  sock_id: FW ID of the socket
+          data_ptr: pointer to data from FW
+          message_size: total data to arrive
+          chunk_size: size of the data in this callback (<= message_size)
+* @retval none
+*/
 void SpwfSADevice::signal_data_receive(uint8_t socket_id, uint8_t * data_ptr, uint32_t message_size, uint32_t chunk_size)
 {
     char debug_str[50];
@@ -322,6 +415,11 @@
     }
 }
 
+/**
+* @brief  synchronization function called from FW (used for connect,disconnect, ready, etc.)
+* @param  code: Status code value returned
+* @retval none
+*/
 void SpwfSADevice::signal_synch_wait(WiFi_Status_t code)
 {
     if(code == WiFi_DISASSOCIATION)
@@ -336,6 +434,11 @@
     }
 }
 
+/**
+* @brief  close a client socket
+* @param  sock_close_id: FW ID of the socket to close
+* @retval error value
+*/
 int SpwfSADevice::socket_client_close(uint8_t sock_close_id)
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -350,7 +453,12 @@
     return 0;
 }
 
-
+/**
+* @brief  open a server socket
+* @param  port_number: port number to listen on
+*         protocol: TCP/UDP protocol
+* @retval error value
+*/
 int SpwfSADevice::socket_server_open(uint32_t port_number, uint8_t * protocol)
 {
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -365,6 +473,12 @@
     return 0;
 }
 
+/**
+* @brief  write to a server socket
+* @param  data_length: size of the data
+*         pdata: pointer to data
+* @retval error value
+*/
 int SpwfSADevice::socket_server_write(uint16_t data_length,char * pdata)
 {    
     int status = 0;//number of bytes
@@ -377,7 +491,12 @@
     }
     return 0;
 }
-    
+
+/**
+* @brief  close a server socket
+* @param  none (only one server socket supported)
+* @retval error value
+*/
 int SpwfSADevice::socket_server_close(void)
 {    
     WiFi_Status_t status = WiFi_MODULE_SUCCESS;
@@ -391,7 +510,12 @@
     
     return 0;
 }
-    
+
+/**
+* @brief  attach/remove IRQ handler to UART
+* @param  attach: attach/remove boolean
+* @retval none
+*/
 void SpwfSADevice::spwf_attach_irq(wifi_bool attach) 
 {
     if(attach)
@@ -404,6 +528,12 @@
     }
 }
 
+/**
+* @brief  write byte(s) to the UART
+* @param  cmd: pointer to data
+*         size: size of data
+* @retval error value
+*/
 int SpwfSADevice::spwf_send(const char * cmd, uint16_t size) 
 {
     Timer timer;
@@ -424,41 +554,81 @@
     return bytes;
 }
 
+/**
+* @brief  read a byte from the UART
+* @param  none
+* @retval byte character
+*/
 char SpwfSADevice::spwf_get(void) 
 {
     return(uart_.getc());
 }
 
+/**
+* @brief  (re)set the SPWF wakeup GPIO pin
+* @param  wake (re)set value
+* @retval none
+*/
 void SpwfSADevice::spwf_wakeup(int wake)
 {
     wakeup_.write(wake);
 }
 
+/**
+* @brief  (re)set the SPWF reset GPIO pin
+* @param  reset (re)set value
+* @retval none
+*/
 void SpwfSADevice::spwf_reset(int reset)
 {
     rst_.write(reset);
 }
 
+/**
+* @brief  (re)set the SPWF RTS GPIO line
+* @param  rts (re)set value
+* @retval none
+*/
 void SpwfSADevice::spwf_rts(int rts)
 {
     rts_.write(rts);
 }
 
+/**
+* @brief  read the SPWF RTS GPIO pin
+* @param  none
+* @retval none
+*/
 int SpwfSADevice::spwf_read_rts()
 {
     return(rts_.read());
 }
 
+/**
+* @brief  send debug print to serial terminal
+* @param  string: data for debug print
+* @retval none
+*/
 void SpwfSADevice::debug_print(const char * string)
 {
     term_.puts(string);
 }
 
+/**
+* @brief  (re)set the switch for incoming client (server socket)
+* @param  set: boolean to (re)set
+* @retval none
+*/
 void SpwfSADevice::set_wait_for_incoming_client(bool set)
 {
     wait_for_incoming_client = set;    
 }
 
+/**
+* @brief  get the switch for incoming client (server socket)
+* @param  none
+* @retval boolean
+*/
 bool SpwfSADevice::get_wait_for_incoming_client()
 {
     return wait_for_incoming_client;

--- a/Spwf_API/SpwfSADevice.h	Sat May 14 07:28:29 2016 +0000
+++ b/Spwf_API/SpwfSADevice.h	Sat May 14 08:31:39 2016 +0000
@@ -72,7 +72,6 @@
     void        http_get(uint8_t * hostname, uint8_t * path, uint32_t port_number);
     void        http_post(uint8_t * url_path);
 
-    /*These functions should be pure virtual functions for ppl to derive and implement there own stuff*/
     char        spwf_get(void);
     int         spwf_send(const char * cmd, uint16_t size);
     void        spwf_wakeup(int wake);

--- a/Spwf_API/utils/ItfTranslator.cpp	Sat May 14 07:28:29 2016 +0000
+++ b/Spwf_API/utils/ItfTranslator.cpp	Sat May 14 08:31:39 2016 +0000
@@ -49,6 +49,12 @@
 extern "C" {
 #endif
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice init
+* @param  void* not used
+* @retval None
+*/
 void callSpwfSADevice_init(void* object)
  {
     //static_cast<SpwfSADevice*>(object)->init();
@@ -56,46 +62,106 @@
     return;
  }
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice getChar
+* @param  void* not used
+* @retval None
+*/
 char callSpwfSADevice_getChar(void* object)
  {
     return(device->spwf_get());
  }
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice write
+* @param  void* not used
+*         cmd: data to write
+*         size: size of data
+* @retval None
+*/
 int callSpwfSADevice_write(void* object, const char * cmd, uint16_t size)
  {
    return (device->spwf_send(cmd, size));
  }
- 
+
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice wakeup
+* @param  void* not used
+*         wake: (re)set wakeup pin value
+* @retval None
+*/
 void callSpwfSADevice_wakeup(void* object, int wake)
 {
   device->spwf_wakeup(wake);
 }
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice reset
+* @param  void* not used
+*         reset: (re)set reset pin value
+* @retval None
+*/
 void callSpwfSADevice_reset(void* object, int reset)
 {
   device->spwf_reset(reset);
 }
-   
+
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice read_rts
+* @param  void* not used
+*         rts: (re)set RTS pin value
+* @retval None
+*/
 void callSpwfSADevice_rts(void* object, int rts)
 {
   device->spwf_rts(rts);
 }
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice read_rts
+* @param  void* not used
+* @retval RTS value
+*/
 int callSpwfSADevice_read_rts(void* object)
 {
   return(device->spwf_read_rts());
 }
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice attach
+* @param  attach boolean
+* @retval None
+*/
 void callSpwfSADevice_attach(wifi_bool attach)
 {
   device->spwf_attach_irq(attach);
 }
 
+/**
+* @brief  Wrapper function to CPP
+*         Calls SpwfSADevice debug
+* @param  void* not used
+*         string: data string to debug print
+* @retval None
+*/
 void callSpwfSADevice_debug(void* object, const char * string)
 {
   device->debug_print(string);
 }
 
+/**
+* @brief  Wrapper function to CPP
+*         not used
+* @param  void* not used
+* @retval None
+*/
 void destroySpwfSADevice()
  {