Andrew Miller / X_NUCLEO_IDW01M1

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of X_NUCLEO_IDW01M1 by ST

SPWFInterface.cpp@6:e7a3fca2df10, 2016-05-09 (annotated)

Committer:
mridup
Date:
Mon May 09 10:38:22 2016 +0000
Revision:
6:e7a3fca2df10
Parent:
5:c83ffd44f40a
Child:
7:0fdd186a7d90
Socket Server support.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mridup 0:dc55f40eb04f 1 /* SpwfSAInterface implementation of NetworkInterfaceAPI
mridup 0:dc55f40eb04f 2 * Copyright (c) 2015 ARM Limited
mridup 0:dc55f40eb04f 3 *
mridup 0:dc55f40eb04f 4 * Licensed under the Apache License, Version 2.0 (the "License");
mridup 0:dc55f40eb04f 5 * you may not use this file except in compliance with the License.
mridup 0:dc55f40eb04f 6 * You may obtain a copy of the License at
mridup 0:dc55f40eb04f 7 *
mridup 0:dc55f40eb04f 8 * http://www.apache.org/licenses/LICENSE-2.0
mridup 0:dc55f40eb04f 9 *
mridup 0:dc55f40eb04f 10 * Unless required by applicable law or agreed to in writing, software
mridup 0:dc55f40eb04f 11 * distributed under the License is distributed on an "AS IS" BASIS,
mridup 0:dc55f40eb04f 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
mridup 0:dc55f40eb04f 13 * See the License for the specific language governing permissions and
mridup 0:dc55f40eb04f 14 * limitations under the License.
mridup 0:dc55f40eb04f 15 */
mridup 0:dc55f40eb04f 16
mridup 0:dc55f40eb04f 17 #include "SPWFInterface.h"
mridup 0:dc55f40eb04f 18
mridup 0:dc55f40eb04f 19 // Various timeouts for different SPWF operations
mridup 0:dc55f40eb04f 20 #define SPWF_CONNECT_TIMEOUT 20000
mridup 0:dc55f40eb04f 21 #define SPWF_SEND_TIMEOUT 500
mridup 5:c83ffd44f40a 22 #define SPWF_RECV_TIMEOUT 2000
mridup 0:dc55f40eb04f 23 #define SPWF_MISC_TIMEOUT 15000
mridup 5:c83ffd44f40a 24
mridup 5:c83ffd44f40a 25 // Handle structure for socket
mridup 5:c83ffd44f40a 26 struct spwf_socket {
mridup 5:c83ffd44f40a 27 int id;
mridup 6:e7a3fca2df10 28 int server_port;
mridup 5:c83ffd44f40a 29 nsapi_protocol_t proto;
mridup 5:c83ffd44f40a 30 bool connected;
mridup 5:c83ffd44f40a 31 };
mridup 0:dc55f40eb04f 32
mridup 0:dc55f40eb04f 33 // SpwfSAInterface implementation
mridup 0:dc55f40eb04f 34 SpwfSAInterface::SpwfSAInterface(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts, bool debug)
mridup 0:dc55f40eb04f 35 : _spwf(tx, rx, rst, wkup, rts)
mridup 0:dc55f40eb04f 36 {
mridup 0:dc55f40eb04f 37 memset(_ids, 0, sizeof(_ids));
mridup 3:fd9d20c4d3f0 38 isInitialized = false;
mridup 6:e7a3fca2df10 39 isListening = false;
mridup 0:dc55f40eb04f 40 }
mridup 0:dc55f40eb04f 41
mridup 0:dc55f40eb04f 42 SpwfSAInterface::~SpwfSAInterface()
mridup 0:dc55f40eb04f 43 {
mridup 0:dc55f40eb04f 44 }
mridup 0:dc55f40eb04f 45
mridup 5:c83ffd44f40a 46 int SpwfSAInterface::init(void)
mridup 0:dc55f40eb04f 47 {
mridup 0:dc55f40eb04f 48 _spwf.setTimeout(SPWF_MISC_TIMEOUT);
mridup 0:dc55f40eb04f 49 return (_spwf.init());
mridup 0:dc55f40eb04f 50 }
mridup 0:dc55f40eb04f 51
mridup 5:c83ffd44f40a 52 int SpwfSAInterface::connect(
mridup 0:dc55f40eb04f 53 const char *ap,
mridup 0:dc55f40eb04f 54 const char *pass_phrase,
mridup 5:c83ffd44f40a 55 nsapi_security_t security)
mridup 0:dc55f40eb04f 56 {
mridup 3:fd9d20c4d3f0 57 //initialize the device before connecting
mridup 3:fd9d20c4d3f0 58 if(!isInitialized)
mridup 3:fd9d20c4d3f0 59 {
mridup 3:fd9d20c4d3f0 60 if(init()==0)
mridup 3:fd9d20c4d3f0 61 isInitialized=true;
mridup 5:c83ffd44f40a 62 else return NSAPI_ERROR_DEVICE_ERROR;
mridup 3:fd9d20c4d3f0 63 }
mridup 3:fd9d20c4d3f0 64
mridup 0:dc55f40eb04f 65 _spwf.setTimeout(SPWF_CONNECT_TIMEOUT);
mridup 0:dc55f40eb04f 66
mridup 5:c83ffd44f40a 67 if(security == NSAPI_SECURITY_WPA2) return NSAPI_ERROR_DEVICE_ERROR;
mridup 0:dc55f40eb04f 68
mridup 0:dc55f40eb04f 69 WiFi_Priv_Mode mode = (WiFi_Priv_Mode)security;
mridup 0:dc55f40eb04f 70
mridup 0:dc55f40eb04f 71 return (_spwf.connect((char*)ap, (char*)pass_phrase, mode));//0 on success
mridup 0:dc55f40eb04f 72 }
mridup 0:dc55f40eb04f 73
mridup 5:c83ffd44f40a 74 int SpwfSAInterface::disconnect()
mridup 5:c83ffd44f40a 75 {
mridup 0:dc55f40eb04f 76 return (_spwf.disconnect());
mridup 0:dc55f40eb04f 77 }
mridup 0:dc55f40eb04f 78
mridup 5:c83ffd44f40a 79 const char *SpwfSAInterface::get_ip_address()
mridup 0:dc55f40eb04f 80 {
mridup 0:dc55f40eb04f 81 return _spwf.getIPAddress();
mridup 0:dc55f40eb04f 82 }
mridup 0:dc55f40eb04f 83
mridup 5:c83ffd44f40a 84 const char *SpwfSAInterface::get_mac_address()
mridup 0:dc55f40eb04f 85 {
mridup 0:dc55f40eb04f 86 return _spwf.getMACAddress();
mridup 0:dc55f40eb04f 87 }
mridup 0:dc55f40eb04f 88
mridup 5:c83ffd44f40a 89
mridup 5:c83ffd44f40a 90 int SpwfSAInterface::socket_open(void **handle, nsapi_protocol_t proto)
mridup 0:dc55f40eb04f 91 {
mridup 5:c83ffd44f40a 92 // Look for an unused socket
mridup 5:c83ffd44f40a 93 int id = -1;
mridup 5:c83ffd44f40a 94
mridup 5:c83ffd44f40a 95 struct spwf_socket *socket = new struct spwf_socket;
mridup 5:c83ffd44f40a 96 if (!socket) {
mridup 5:c83ffd44f40a 97 return NSAPI_ERROR_NO_SOCKET;
mridup 5:c83ffd44f40a 98 }
mridup 5:c83ffd44f40a 99
mridup 5:c83ffd44f40a 100 socket->id = id;
mridup 6:e7a3fca2df10 101 socket->server_port = id;
mridup 5:c83ffd44f40a 102 socket->proto = proto;
mridup 5:c83ffd44f40a 103 socket->connected = false;
mridup 5:c83ffd44f40a 104 *handle = socket;
mridup 5:c83ffd44f40a 105 return 0;
mridup 0:dc55f40eb04f 106 }
mridup 5:c83ffd44f40a 107
mridup 5:c83ffd44f40a 108 int SpwfSAInterface::socket_connect(void *handle, const SocketAddress &addr)
mridup 5:c83ffd44f40a 109 {
mridup 6:e7a3fca2df10 110 uint8_t sock_id = 99;
mridup 5:c83ffd44f40a 111 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 112
mridup 5:c83ffd44f40a 113 const char *proto = (socket->proto == NSAPI_UDP) ? "u" : "t";//"s" for secure socket?
mridup 0:dc55f40eb04f 114
mridup 5:c83ffd44f40a 115 _spwf.socket_client_open((uint8_t*)addr.get_ip_address(), (uint32_t)addr.get_port(), (uint8_t *)proto, &sock_id);//sock ID is allocated NOW
mridup 0:dc55f40eb04f 116
mridup 0:dc55f40eb04f 117 //TODO: Maintain a socket table to map socket ID to host & port
mridup 0:dc55f40eb04f 118 //TODO: lookup on client table to see if already socket is allocated to same host/port
mridup 0:dc55f40eb04f 119 //multimap <char *, vector <uint16_t> > ::iterator i = c_table.find((char*)ip);
mridup 0:dc55f40eb04f 120
mridup 0:dc55f40eb04f 121 if(sock_id <= SPWFSA_SOCKET_COUNT)
mridup 0:dc55f40eb04f 122 {
mridup 5:c83ffd44f40a 123 //_ids[socket->id] = false;
mridup 5:c83ffd44f40a 124 socket->id = sock_id;//the socket ID of this Socket instance
mridup 5:c83ffd44f40a 125 _ids[socket->id] = true;
mridup 5:c83ffd44f40a 126 socket->connected = true;
mridup 0:dc55f40eb04f 127 }
mridup 0:dc55f40eb04f 128 else
mridup 5:c83ffd44f40a 129 return NSAPI_ERROR_NO_SOCKET;
mridup 0:dc55f40eb04f 130
mridup 0:dc55f40eb04f 131 return 0;//0 means SUCCESS
mridup 0:dc55f40eb04f 132 }
mridup 5:c83ffd44f40a 133
mridup 5:c83ffd44f40a 134 int SpwfSAInterface::socket_bind(void *handle, const SocketAddress &address)
mridup 5:c83ffd44f40a 135 {
mridup 6:e7a3fca2df10 136 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 6:e7a3fca2df10 137 socket->id = SERVER_SOCKET_NO;//Special socket ID number for Server Socket
mridup 6:e7a3fca2df10 138 socket->server_port = address.get_port();
mridup 6:e7a3fca2df10 139 return 0;
mridup 5:c83ffd44f40a 140 }
mridup 5:c83ffd44f40a 141
mridup 5:c83ffd44f40a 142 int SpwfSAInterface::socket_listen(void *handle, int backlog)
mridup 0:dc55f40eb04f 143 {
mridup 6:e7a3fca2df10 144 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 6:e7a3fca2df10 145 int err;
mridup 6:e7a3fca2df10 146
mridup 6:e7a3fca2df10 147 if(socket->server_port==-1 || isListening)
mridup 6:e7a3fca2df10 148 return NSAPI_ERROR_NO_SOCKET; //server socket not bound or already listening
mridup 6:e7a3fca2df10 149
mridup 6:e7a3fca2df10 150 const char *proto = (socket->proto == NSAPI_UDP) ? "u" : "t";
mridup 6:e7a3fca2df10 151
mridup 6:e7a3fca2df10 152 err = _spwf.socket_server_open((uint32_t)socket->server_port, (uint8_t *)proto);
mridup 6:e7a3fca2df10 153
mridup 6:e7a3fca2df10 154 if(err==0)
mridup 6:e7a3fca2df10 155 {
mridup 6:e7a3fca2df10 156 isListening = true;
mridup 6:e7a3fca2df10 157 }
mridup 6:e7a3fca2df10 158 else
mridup 6:e7a3fca2df10 159 return NSAPI_ERROR_DEVICE_ERROR;
mridup 6:e7a3fca2df10 160
mridup 6:e7a3fca2df10 161 return err;
mridup 5:c83ffd44f40a 162 }
mridup 5:c83ffd44f40a 163
mridup 6:e7a3fca2df10 164 /** Accepts a connection on a TCP socket
mridup 6:e7a3fca2df10 165 *
mridup 6:e7a3fca2df10 166 * The server socket must be bound and set to listen for connections.
mridup 6:e7a3fca2df10 167 * On a new connection, creates a network socket using the specified
mridup 6:e7a3fca2df10 168 * socket instance.
mridup 6:e7a3fca2df10 169 *
mridup 6:e7a3fca2df10 170 * By default, accept blocks until data is sent. If socket is set to
mridup 6:e7a3fca2df10 171 * non-blocking or times out, NSAPI_ERROR_WOULD_BLOCK is returned
mridup 6:e7a3fca2df10 172 * immediately.
mridup 6:e7a3fca2df10 173 *
mridup 6:e7a3fca2df10 174 * @param socket TCPSocket instance that will handle the incoming connection.
mridup 6:e7a3fca2df10 175 * @return 0 on success, negative error code on failure
mridup 6:e7a3fca2df10 176 */
mridup 5:c83ffd44f40a 177 int SpwfSAInterface::socket_accept(void **handle, void *server)
mridup 5:c83ffd44f40a 178 {
mridup 6:e7a3fca2df10 179 char debug_str[10];
mridup 6:e7a3fca2df10 180 struct spwf_socket *server_socket = (struct spwf_socket *)server;
mridup 6:e7a3fca2df10 181 int id = -1;
mridup 6:e7a3fca2df10 182
mridup 6:e7a3fca2df10 183 if(server_socket->server_port==-1 || !isListening)
mridup 6:e7a3fca2df10 184 return NSAPI_ERROR_NO_SOCKET; //server socket not bound or not listening
mridup 6:e7a3fca2df10 185
mridup 6:e7a3fca2df10 186 while(true)
mridup 6:e7a3fca2df10 187 {
mridup 6:e7a3fca2df10 188 if(_spwf.get_wait_for_incoming_client())
mridup 6:e7a3fca2df10 189 {
mridup 6:e7a3fca2df10 190 server_socket->connected = true;
mridup 6:e7a3fca2df10 191
mridup 6:e7a3fca2df10 192 //struct spwf_socket *temp_socket;// = new struct spwf_socket;//create new network socket
mridup 6:e7a3fca2df10 193 struct spwf_socket *socket = new struct spwf_socket;//create new network socket
mridup 6:e7a3fca2df10 194 if (!socket) {
mridup 6:e7a3fca2df10 195 return NSAPI_ERROR_NO_SOCKET;
mridup 6:e7a3fca2df10 196 }
mridup 6:e7a3fca2df10 197
mridup 6:e7a3fca2df10 198 memset(socket, 0, sizeof (struct spwf_socket));
mridup 6:e7a3fca2df10 199 /*
mridup 6:e7a3fca2df10 200 if(get_network_socket(&temp_socket)!=0)
mridup 6:e7a3fca2df10 201 {
mridup 6:e7a3fca2df10 202 return NSAPI_ERROR_NO_SOCKET;
mridup 6:e7a3fca2df10 203 }*/
mridup 6:e7a3fca2df10 204
mridup 6:e7a3fca2df10 205 socket->id = server_socket->id;
mridup 6:e7a3fca2df10 206 socket->server_port = server_socket->server_port;
mridup 6:e7a3fca2df10 207 socket->proto = server_socket->proto;
mridup 6:e7a3fca2df10 208 socket->connected = true;
mridup 6:e7a3fca2df10 209
mridup 6:e7a3fca2df10 210 *handle = socket;
mridup 6:e7a3fca2df10 211 socket = 0;
mridup 6:e7a3fca2df10 212 _spwf.set_wait_for_incoming_client(false);//reset
mridup 6:e7a3fca2df10 213 wait_ms(50);//CHECK:TODO:Why do we need this?
mridup 6:e7a3fca2df10 214 break;
mridup 6:e7a3fca2df10 215 }
mridup 6:e7a3fca2df10 216 }
mridup 6:e7a3fca2df10 217
mridup 6:e7a3fca2df10 218 return 0;
mridup 5:c83ffd44f40a 219 }
mridup 5:c83ffd44f40a 220
mridup 6:e7a3fca2df10 221 /*
mridup 6:e7a3fca2df10 222 int SpwfSAInterface::get_network_socket(struct spwf_socket **handle)
mridup 6:e7a3fca2df10 223 {
mridup 6:e7a3fca2df10 224 struct spwf_socket *__socket = new struct spwf_socket;//create new network socket
mridup 6:e7a3fca2df10 225 __socket = new struct spwf_socket;//create new network socket
mridup 6:e7a3fca2df10 226 if (!__socket) {
mridup 6:e7a3fca2df10 227 return NSAPI_ERROR_NO_SOCKET;
mridup 6:e7a3fca2df10 228 }
mridup 6:e7a3fca2df10 229
mridup 6:e7a3fca2df10 230 memset(__socket, 0, sizeof (struct spwf_socket));
mridup 6:e7a3fca2df10 231 *handle = __socket;
mridup 6:e7a3fca2df10 232 return 0;
mridup 6:e7a3fca2df10 233 }
mridup 6:e7a3fca2df10 234 */
mridup 6:e7a3fca2df10 235
mridup 5:c83ffd44f40a 236 int SpwfSAInterface::socket_close(void *handle)
mridup 5:c83ffd44f40a 237 {
mridup 5:c83ffd44f40a 238 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 239 int err = 0;
mridup 5:c83ffd44f40a 240 //_spwf.setTimeout(SPWF_MISC_TIMEOUT);
mridup 0:dc55f40eb04f 241
mridup 5:c83ffd44f40a 242 if(socket->id!=-1)
mridup 5:c83ffd44f40a 243 {
mridup 6:e7a3fca2df10 244 if(socket->id==SERVER_SOCKET_NO)
mridup 6:e7a3fca2df10 245 {
mridup 6:e7a3fca2df10 246 if (_spwf.socket_server_close()==-1) {
mridup 6:e7a3fca2df10 247 err = NSAPI_ERROR_DEVICE_ERROR;
mridup 6:e7a3fca2df10 248 }
mridup 6:e7a3fca2df10 249 isListening = false;
mridup 5:c83ffd44f40a 250 }
mridup 6:e7a3fca2df10 251 else
mridup 6:e7a3fca2df10 252 {
mridup 6:e7a3fca2df10 253 if (_spwf.socket_client_close(socket->id)==-1) {
mridup 6:e7a3fca2df10 254 err = NSAPI_ERROR_DEVICE_ERROR;
mridup 6:e7a3fca2df10 255 }
mridup 6:e7a3fca2df10 256 _ids[socket->id] = false;
mridup 6:e7a3fca2df10 257 }
mridup 5:c83ffd44f40a 258 }
mridup 5:c83ffd44f40a 259
mridup 5:c83ffd44f40a 260 delete socket;
mridup 0:dc55f40eb04f 261 return err;
mridup 0:dc55f40eb04f 262 }
mridup 5:c83ffd44f40a 263
mridup 5:c83ffd44f40a 264 int SpwfSAInterface::socket_send(void *handle, const void *data, unsigned size)
mridup 5:c83ffd44f40a 265 {
mridup 5:c83ffd44f40a 266 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 267 int err;
mridup 0:dc55f40eb04f 268
mridup 6:e7a3fca2df10 269 if(socket->id==SERVER_SOCKET_NO)
mridup 6:e7a3fca2df10 270 {
mridup 6:e7a3fca2df10 271 err = _spwf.socket_server_write((uint16_t)size, (char*)data);
mridup 6:e7a3fca2df10 272 }
mridup 6:e7a3fca2df10 273 else
mridup 6:e7a3fca2df10 274 {
mridup 6:e7a3fca2df10 275 err = _spwf.socket_client_write((uint8_t)socket->id, (uint16_t)size, (char*)data);
mridup 6:e7a3fca2df10 276 }
mridup 0:dc55f40eb04f 277
mridup 0:dc55f40eb04f 278 return err;
mridup 0:dc55f40eb04f 279 }
mridup 0:dc55f40eb04f 280
mridup 0:dc55f40eb04f 281 //return no of bytes read
mridup 5:c83ffd44f40a 282 int SpwfSAInterface::socket_recv(void *handle, void *data, unsigned size)
mridup 0:dc55f40eb04f 283 {
mridup 5:c83ffd44f40a 284 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 0:dc55f40eb04f 285 int32_t recv;
mridup 0:dc55f40eb04f 286
mridup 5:c83ffd44f40a 287 _spwf.setTimeout(SPWF_RECV_TIMEOUT);
mridup 0:dc55f40eb04f 288
mridup 6:e7a3fca2df10 289 //CHECK:Receive for both Client and Server Sockets same?
mridup 5:c83ffd44f40a 290 recv = _spwf.socket_client_recv((uint8_t)socket->id, (uint16_t)size, (char*)data);
mridup 5:c83ffd44f40a 291 if (recv < 0) {
mridup 5:c83ffd44f40a 292 return NSAPI_ERROR_WOULD_BLOCK;
mridup 5:c83ffd44f40a 293 }
mridup 0:dc55f40eb04f 294 return recv;
mridup 0:dc55f40eb04f 295
mridup 0:dc55f40eb04f 296 }
mridup 0:dc55f40eb04f 297
mridup 5:c83ffd44f40a 298 int SpwfSAInterface::socket_sendto(void *handle, const SocketAddress &addr, const void *data, unsigned size)
mridup 5:c83ffd44f40a 299 {
mridup 5:c83ffd44f40a 300 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 301 if (!socket->connected) {
mridup 5:c83ffd44f40a 302 int err = socket_connect(socket, addr);
mridup 5:c83ffd44f40a 303 if (err < 0) {
mridup 5:c83ffd44f40a 304 return err;
mridup 5:c83ffd44f40a 305 }
mridup 5:c83ffd44f40a 306 }
mridup 5:c83ffd44f40a 307
mridup 5:c83ffd44f40a 308 return socket_send(socket, data, size);
mridup 5:c83ffd44f40a 309 }
mridup 5:c83ffd44f40a 310
mridup 5:c83ffd44f40a 311 int SpwfSAInterface::socket_recvfrom(void *handle, SocketAddress *addr, void *data, unsigned size)
mridup 5:c83ffd44f40a 312 {
mridup 5:c83ffd44f40a 313 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 314 return socket_recv(socket, data, size);
mridup 5:c83ffd44f40a 315 }
mridup 5:c83ffd44f40a 316
mridup 5:c83ffd44f40a 317 void SpwfSAInterface::socket_attach(void *handle, void (*callback)(void *), void *data)
mridup 5:c83ffd44f40a 318 {
mridup 5:c83ffd44f40a 319 //No implementation yet
mridup 5:c83ffd44f40a 320 }
mridup 5:c83ffd44f40a 321
mridup 0:dc55f40eb04f 322 void SpwfSAInterface::debug(const char * string)
mridup 0:dc55f40eb04f 323 {
mridup 0:dc55f40eb04f 324 _spwf.debug_print(string);
mridup 0:dc55f40eb04f 325 }