Steve Sims / X_NUCLEO_IDW01M1_AP

Extending the X_NUCLEO_IDW01M1 to allow configuration of the board as an access point

Dependents:   X_NUCLEO_IDW01M1_AP_Test

Fork of X_NUCLEO_IDW01M1 by ST

SPWFInterface.cpp@11:67a8c3499caf, 2016-05-14 (annotated)

Committer:
mridup
Date:
Sat May 14 07:28:29 2016 +0000
Revision:
11:67a8c3499caf
Parent:
9:d2dfbf8e7f49
Child:
12:3799f8475c8a
update to CR-LF....CR-LF issue.

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 7:0fdd186a7d90 22 #define SPWF_RECV_TIMEOUT 1000
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 11:67a8c3499caf 33
mridup 11:67a8c3499caf 34 /**
mridup 11:67a8c3499caf 35 * @brief SpwfSAInterface constructor
mridup 11:67a8c3499caf 36 * @param tx: Pin USART TX
mridup 11:67a8c3499caf 37 * rx: Pin USART RX
mridup 11:67a8c3499caf 38 * rst: reset pin for Spwf module
mridup 11:67a8c3499caf 39 * wkup: reset pin for Spwf module
mridup 11:67a8c3499caf 40 * rts: Pin USART RTS
mridup 11:67a8c3499caf 41 * debug : not used
mridup 11:67a8c3499caf 42 * @retval none
mridup 11:67a8c3499caf 43 */
mridup 0:dc55f40eb04f 44 SpwfSAInterface::SpwfSAInterface(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts, bool debug)
mridup 0:dc55f40eb04f 45 : _spwf(tx, rx, rst, wkup, rts)
mridup 0:dc55f40eb04f 46 {
mridup 0:dc55f40eb04f 47 memset(_ids, 0, sizeof(_ids));
mridup 3:fd9d20c4d3f0 48 isInitialized = false;
mridup 6:e7a3fca2df10 49 isListening = false;
mridup 0:dc55f40eb04f 50 }
mridup 0:dc55f40eb04f 51
mridup 0:dc55f40eb04f 52 SpwfSAInterface::~SpwfSAInterface()
mridup 0:dc55f40eb04f 53 {
mridup 0:dc55f40eb04f 54 }
mridup 0:dc55f40eb04f 55
mridup 5:c83ffd44f40a 56 int SpwfSAInterface::init(void)
mridup 0:dc55f40eb04f 57 {
mridup 0:dc55f40eb04f 58 _spwf.setTimeout(SPWF_MISC_TIMEOUT);
mridup 0:dc55f40eb04f 59 return (_spwf.init());
mridup 0:dc55f40eb04f 60 }
mridup 0:dc55f40eb04f 61
mridup 5:c83ffd44f40a 62 int SpwfSAInterface::connect(
mridup 0:dc55f40eb04f 63 const char *ap,
mridup 0:dc55f40eb04f 64 const char *pass_phrase,
mridup 5:c83ffd44f40a 65 nsapi_security_t security)
mridup 0:dc55f40eb04f 66 {
mridup 3:fd9d20c4d3f0 67 //initialize the device before connecting
mridup 3:fd9d20c4d3f0 68 if(!isInitialized)
mridup 3:fd9d20c4d3f0 69 {
mridup 3:fd9d20c4d3f0 70 if(init()==0)
mridup 3:fd9d20c4d3f0 71 isInitialized=true;
mridup 5:c83ffd44f40a 72 else return NSAPI_ERROR_DEVICE_ERROR;
mridup 3:fd9d20c4d3f0 73 }
mridup 3:fd9d20c4d3f0 74
mridup 0:dc55f40eb04f 75 _spwf.setTimeout(SPWF_CONNECT_TIMEOUT);
mridup 0:dc55f40eb04f 76
mridup 5:c83ffd44f40a 77 if(security == NSAPI_SECURITY_WPA2) return NSAPI_ERROR_DEVICE_ERROR;
mridup 0:dc55f40eb04f 78
mridup 0:dc55f40eb04f 79 WiFi_Priv_Mode mode = (WiFi_Priv_Mode)security;
mridup 0:dc55f40eb04f 80
mridup 0:dc55f40eb04f 81 return (_spwf.connect((char*)ap, (char*)pass_phrase, mode));//0 on success
mridup 0:dc55f40eb04f 82 }
mridup 0:dc55f40eb04f 83
mridup 5:c83ffd44f40a 84 int SpwfSAInterface::disconnect()
mridup 5:c83ffd44f40a 85 {
mridup 0:dc55f40eb04f 86 return (_spwf.disconnect());
mridup 0:dc55f40eb04f 87 }
mridup 0:dc55f40eb04f 88
mridup 5:c83ffd44f40a 89 const char *SpwfSAInterface::get_ip_address()
mridup 0:dc55f40eb04f 90 {
mridup 0:dc55f40eb04f 91 return _spwf.getIPAddress();
mridup 0:dc55f40eb04f 92 }
mridup 0:dc55f40eb04f 93
mridup 5:c83ffd44f40a 94 const char *SpwfSAInterface::get_mac_address()
mridup 0:dc55f40eb04f 95 {
mridup 0:dc55f40eb04f 96 return _spwf.getMACAddress();
mridup 0:dc55f40eb04f 97 }
mridup 0:dc55f40eb04f 98
mridup 5:c83ffd44f40a 99
mridup 5:c83ffd44f40a 100 int SpwfSAInterface::socket_open(void **handle, nsapi_protocol_t proto)
mridup 0:dc55f40eb04f 101 {
mridup 5:c83ffd44f40a 102 // Look for an unused socket
mridup 5:c83ffd44f40a 103 int id = -1;
mridup 5:c83ffd44f40a 104
mridup 5:c83ffd44f40a 105 struct spwf_socket *socket = new struct spwf_socket;
mridup 5:c83ffd44f40a 106 if (!socket) {
mridup 5:c83ffd44f40a 107 return NSAPI_ERROR_NO_SOCKET;
mridup 5:c83ffd44f40a 108 }
mridup 5:c83ffd44f40a 109
mridup 5:c83ffd44f40a 110 socket->id = id;
mridup 6:e7a3fca2df10 111 socket->server_port = id;
mridup 5:c83ffd44f40a 112 socket->proto = proto;
mridup 5:c83ffd44f40a 113 socket->connected = false;
mridup 5:c83ffd44f40a 114 *handle = socket;
mridup 5:c83ffd44f40a 115 return 0;
mridup 0:dc55f40eb04f 116 }
mridup 5:c83ffd44f40a 117
mridup 5:c83ffd44f40a 118 int SpwfSAInterface::socket_connect(void *handle, const SocketAddress &addr)
mridup 5:c83ffd44f40a 119 {
mridup 6:e7a3fca2df10 120 uint8_t sock_id = 99;
mridup 5:c83ffd44f40a 121 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 122
mridup 5:c83ffd44f40a 123 const char *proto = (socket->proto == NSAPI_UDP) ? "u" : "t";//"s" for secure socket?
mridup 0:dc55f40eb04f 124
mridup 5:c83ffd44f40a 125 _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 126
mridup 0:dc55f40eb04f 127 //TODO: Maintain a socket table to map socket ID to host & port
mridup 0:dc55f40eb04f 128 //TODO: lookup on client table to see if already socket is allocated to same host/port
mridup 0:dc55f40eb04f 129 //multimap <char *, vector <uint16_t> > ::iterator i = c_table.find((char*)ip);
mridup 0:dc55f40eb04f 130
mridup 0:dc55f40eb04f 131 if(sock_id <= SPWFSA_SOCKET_COUNT)
mridup 0:dc55f40eb04f 132 {
mridup 5:c83ffd44f40a 133 //_ids[socket->id] = false;
mridup 5:c83ffd44f40a 134 socket->id = sock_id;//the socket ID of this Socket instance
mridup 5:c83ffd44f40a 135 _ids[socket->id] = true;
mridup 5:c83ffd44f40a 136 socket->connected = true;
mridup 0:dc55f40eb04f 137 }
mridup 0:dc55f40eb04f 138 else
mridup 5:c83ffd44f40a 139 return NSAPI_ERROR_NO_SOCKET;
mridup 0:dc55f40eb04f 140
mridup 0:dc55f40eb04f 141 return 0;//0 means SUCCESS
mridup 0:dc55f40eb04f 142 }
mridup 5:c83ffd44f40a 143
mridup 5:c83ffd44f40a 144 int SpwfSAInterface::socket_bind(void *handle, const SocketAddress &address)
mridup 5:c83ffd44f40a 145 {
mridup 7:0fdd186a7d90 146 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 6:e7a3fca2df10 147 socket->server_port = address.get_port();
mridup 6:e7a3fca2df10 148 return 0;
mridup 5:c83ffd44f40a 149 }
mridup 5:c83ffd44f40a 150
mridup 5:c83ffd44f40a 151 int SpwfSAInterface::socket_listen(void *handle, int backlog)
mridup 0:dc55f40eb04f 152 {
mridup 6:e7a3fca2df10 153 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 6:e7a3fca2df10 154 int err;
mridup 6:e7a3fca2df10 155
mridup 6:e7a3fca2df10 156 if(socket->server_port==-1 || isListening)
mridup 6:e7a3fca2df10 157 return NSAPI_ERROR_NO_SOCKET; //server socket not bound or already listening
mridup 6:e7a3fca2df10 158
mridup 6:e7a3fca2df10 159 const char *proto = (socket->proto == NSAPI_UDP) ? "u" : "t";
mridup 6:e7a3fca2df10 160
mridup 6:e7a3fca2df10 161 err = _spwf.socket_server_open((uint32_t)socket->server_port, (uint8_t *)proto);
mridup 6:e7a3fca2df10 162
mridup 6:e7a3fca2df10 163 if(err==0)
mridup 6:e7a3fca2df10 164 {
mridup 7:0fdd186a7d90 165 socket->id = SERVER_SOCKET_NO;//Special socket ID number for Server Socket
mridup 6:e7a3fca2df10 166 isListening = true;
mridup 6:e7a3fca2df10 167 }
mridup 6:e7a3fca2df10 168 else
mridup 6:e7a3fca2df10 169 return NSAPI_ERROR_DEVICE_ERROR;
mridup 6:e7a3fca2df10 170
mridup 6:e7a3fca2df10 171 return err;
mridup 5:c83ffd44f40a 172 }
mridup 5:c83ffd44f40a 173
mridup 5:c83ffd44f40a 174 int SpwfSAInterface::socket_accept(void **handle, void *server)
mridup 5:c83ffd44f40a 175 {
mridup 6:e7a3fca2df10 176 struct spwf_socket *server_socket = (struct spwf_socket *)server;
mridup 6:e7a3fca2df10 177
mridup 6:e7a3fca2df10 178 if(server_socket->server_port==-1 || !isListening)
mridup 6:e7a3fca2df10 179 return NSAPI_ERROR_NO_SOCKET; //server socket not bound or not listening
mridup 6:e7a3fca2df10 180
mridup 7:0fdd186a7d90 181 if(_spwf.get_wait_for_incoming_client())
mridup 7:0fdd186a7d90 182 {
mridup 7:0fdd186a7d90 183 server_socket->connected = true;
mridup 7:0fdd186a7d90 184 struct spwf_socket *socket = new struct spwf_socket;//create new network socket
mridup 7:0fdd186a7d90 185 if (!socket) {
mridup 7:0fdd186a7d90 186 return NSAPI_ERROR_NO_SOCKET;
mridup 7:0fdd186a7d90 187 }
mridup 7:0fdd186a7d90 188
mridup 7:0fdd186a7d90 189 memset(socket, 0, sizeof (struct spwf_socket));
mridup 11:67a8c3499caf 190
mridup 7:0fdd186a7d90 191 socket->id = server_socket->id;
mridup 7:0fdd186a7d90 192 socket->server_port = server_socket->server_port;
mridup 7:0fdd186a7d90 193 socket->proto = server_socket->proto;
mridup 7:0fdd186a7d90 194 socket->connected = true;
mridup 7:0fdd186a7d90 195
mridup 7:0fdd186a7d90 196 *handle = socket;
mridup 7:0fdd186a7d90 197 socket = 0;
mridup 7:0fdd186a7d90 198 _spwf.set_wait_for_incoming_client(false);//reset
mridup 7:0fdd186a7d90 199 wait_ms(50);//CHECK:TODO:Why do we need this?
mridup 7:0fdd186a7d90 200 return 0;
mridup 7:0fdd186a7d90 201 }
mridup 7:0fdd186a7d90 202 return NSAPI_ERROR_WOULD_BLOCK;
mridup 5:c83ffd44f40a 203 }
mridup 5:c83ffd44f40a 204
mridup 5:c83ffd44f40a 205 int SpwfSAInterface::socket_close(void *handle)
mridup 5:c83ffd44f40a 206 {
mridup 5:c83ffd44f40a 207 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 208 int err = 0;
mridup 7:0fdd186a7d90 209 _spwf.setTimeout(SPWF_MISC_TIMEOUT);
mridup 0:dc55f40eb04f 210
mridup 5:c83ffd44f40a 211 if(socket->id!=-1)
mridup 5:c83ffd44f40a 212 {
mridup 6:e7a3fca2df10 213 if(socket->id==SERVER_SOCKET_NO)
mridup 6:e7a3fca2df10 214 {
mridup 6:e7a3fca2df10 215 if (_spwf.socket_server_close()==-1) {
mridup 6:e7a3fca2df10 216 err = NSAPI_ERROR_DEVICE_ERROR;
mridup 6:e7a3fca2df10 217 }
mridup 6:e7a3fca2df10 218 isListening = false;
mridup 5:c83ffd44f40a 219 }
mridup 6:e7a3fca2df10 220 else
mridup 6:e7a3fca2df10 221 {
mridup 6:e7a3fca2df10 222 if (_spwf.socket_client_close(socket->id)==-1) {
mridup 6:e7a3fca2df10 223 err = NSAPI_ERROR_DEVICE_ERROR;
mridup 6:e7a3fca2df10 224 }
mridup 6:e7a3fca2df10 225 _ids[socket->id] = false;
mridup 6:e7a3fca2df10 226 }
mridup 5:c83ffd44f40a 227 }
mridup 5:c83ffd44f40a 228
mridup 5:c83ffd44f40a 229 delete socket;
mridup 0:dc55f40eb04f 230 return err;
mridup 0:dc55f40eb04f 231 }
mridup 5:c83ffd44f40a 232
mridup 5:c83ffd44f40a 233 int SpwfSAInterface::socket_send(void *handle, const void *data, unsigned size)
mridup 5:c83ffd44f40a 234 {
mridup 5:c83ffd44f40a 235 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 236 int err;
mridup 0:dc55f40eb04f 237
mridup 6:e7a3fca2df10 238 if(socket->id==SERVER_SOCKET_NO)
mridup 6:e7a3fca2df10 239 {
mridup 7:0fdd186a7d90 240 if(socket->server_port==-1 || !isListening)
mridup 7:0fdd186a7d90 241 return NSAPI_ERROR_NO_SOCKET; //server socket not bound or not listening
mridup 7:0fdd186a7d90 242
mridup 6:e7a3fca2df10 243 err = _spwf.socket_server_write((uint16_t)size, (char*)data);
mridup 6:e7a3fca2df10 244 }
mridup 6:e7a3fca2df10 245 else
mridup 6:e7a3fca2df10 246 {
mridup 6:e7a3fca2df10 247 err = _spwf.socket_client_write((uint8_t)socket->id, (uint16_t)size, (char*)data);
mridup 6:e7a3fca2df10 248 }
mridup 0:dc55f40eb04f 249
mridup 0:dc55f40eb04f 250 return err;
mridup 0:dc55f40eb04f 251 }
mridup 0:dc55f40eb04f 252
mridup 0:dc55f40eb04f 253 //return no of bytes read
mridup 5:c83ffd44f40a 254 int SpwfSAInterface::socket_recv(void *handle, void *data, unsigned size)
mridup 0:dc55f40eb04f 255 {
mridup 5:c83ffd44f40a 256 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 0:dc55f40eb04f 257 int32_t recv;
mridup 0:dc55f40eb04f 258
mridup 5:c83ffd44f40a 259 _spwf.setTimeout(SPWF_RECV_TIMEOUT);
mridup 0:dc55f40eb04f 260
mridup 6:e7a3fca2df10 261 //CHECK:Receive for both Client and Server Sockets same?
mridup 5:c83ffd44f40a 262 recv = _spwf.socket_client_recv((uint8_t)socket->id, (uint16_t)size, (char*)data);
mridup 5:c83ffd44f40a 263 if (recv < 0) {
mridup 5:c83ffd44f40a 264 return NSAPI_ERROR_WOULD_BLOCK;
mridup 5:c83ffd44f40a 265 }
mridup 0:dc55f40eb04f 266 return recv;
mridup 0:dc55f40eb04f 267
mridup 0:dc55f40eb04f 268 }
mridup 0:dc55f40eb04f 269
mridup 5:c83ffd44f40a 270 int SpwfSAInterface::socket_sendto(void *handle, const SocketAddress &addr, const void *data, unsigned size)
mridup 5:c83ffd44f40a 271 {
mridup 5:c83ffd44f40a 272 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 273 if (!socket->connected) {
mridup 5:c83ffd44f40a 274 int err = socket_connect(socket, addr);
mridup 5:c83ffd44f40a 275 if (err < 0) {
mridup 5:c83ffd44f40a 276 return err;
mridup 5:c83ffd44f40a 277 }
mridup 5:c83ffd44f40a 278 }
mridup 5:c83ffd44f40a 279
mridup 5:c83ffd44f40a 280 return socket_send(socket, data, size);
mridup 5:c83ffd44f40a 281 }
mridup 5:c83ffd44f40a 282
mridup 5:c83ffd44f40a 283 int SpwfSAInterface::socket_recvfrom(void *handle, SocketAddress *addr, void *data, unsigned size)
mridup 5:c83ffd44f40a 284 {
mridup 5:c83ffd44f40a 285 struct spwf_socket *socket = (struct spwf_socket *)handle;
mridup 5:c83ffd44f40a 286 return socket_recv(socket, data, size);
mridup 5:c83ffd44f40a 287 }
mridup 5:c83ffd44f40a 288
mridup 5:c83ffd44f40a 289 void SpwfSAInterface::socket_attach(void *handle, void (*callback)(void *), void *data)
mridup 5:c83ffd44f40a 290 {
mridup 5:c83ffd44f40a 291 //No implementation yet
mridup 5:c83ffd44f40a 292 }
mridup 5:c83ffd44f40a 293
mridup 0:dc55f40eb04f 294 void SpwfSAInterface::debug(const char * string)
mridup 0:dc55f40eb04f 295 {
mridup 0:dc55f40eb04f 296 _spwf.debug_print(string);
mridup 0:dc55f40eb04f 297 }