Vergil Cola
/
cc3000_hostdriver_mbedsocket
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
cc3000_hostdriver_mbedsocket
by 
Martin Kojtal
Embed:
(wiki syntax)
Show/hide line numbers
cc3000.h
00001 /***************************************************************************** 00002 * 00003 * C++ interface/implementation created by Martin Kojtal (0xc0170). Thanks to 00004 * Jim Carver and Frank Vannieuwkerke for their inital cc3000 mbed port and 00005 * provided help. 00006 * 00007 * This version of "host driver" uses CC3000 Host Driver Implementation. Thus 00008 * read the following copyright: 00009 * 00010 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ 00011 * 00012 * Redistribution and use in source and binary forms, with or without 00013 * modification, are permitted provided that the following conditions 00014 * are met: 00015 * 00016 * Redistributions of source code must retain the above copyright 00017 * notice, this list of conditions and the following disclaimer. 00018 * 00019 * Redistributions in binary form must reproduce the above copyright 00020 * notice, this list of conditions and the following disclaimer in the 00021 * documentation and/or other materials provided with the 00022 * distribution. 00023 * 00024 * Neither the name of Texas Instruments Incorporated nor the names of 00025 * its contributors may be used to endorse or promote products derived 00026 * from this software without specific prior written permission. 00027 * 00028 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00029 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00030 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 00031 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 00032 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00033 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 00034 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 00035 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 00036 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 00037 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00038 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00039 * 00040 *****************************************************************************/ 00041 #ifndef CC3000_H 00042 #define CC3000_H 00043 00044 #include "mbed.h" 00045 #include "rtos.h" 00046 #include "cc3000_common.h" 00047 #include "cc3000_spi.h" 00048 #include "cc3000_simplelink.h" 00049 #include "cc3000_netapp.h" 00050 #include "cc3000_nvmem.h" 00051 #include "cc3000_socket.h" 00052 00053 #define MAX_SOCKETS 4 00054 // cc3000 Ethernet Interface - enabled by default 00055 #define CC3000_ETH_COMPAT 1 00056 00057 /** Enable debug messages - set 1 */ 00058 // Debug - Socket interface messages 00059 #define CC3000_DEBUG_SOCKET 0 00060 // Debug - HCI TX messages 00061 #define CC3000_DEBUG_HCI_TX 0 00062 // Debug - HCI Rx messages 00063 #define CC3000_DEBUG_HCI_RX 0 00064 // Debug - General Debug 00065 #define CC3000_DEBUG 0 00066 // Add colour to the debug messages, requires a VT100 terminal like putty, comment out to remove 00067 #define VT100_COLOUR 0 00068 00069 #if (CC3000_DEBUG_SOCKET == 1) 00070 #if (VT100_COLOUR == 1) 00071 #define DBG_SOCKET(x, ...) std::printf("\x1b[2;32;40m[CC3000 : SOCKET] "x"\x1b[0;37;40m\r\n", ##__VA_ARGS__); 00072 #else 00073 #define DBG_SOCKET(x, ...) std::printf("[CC3000 : SOCKET] "x"\r\n", ##__VA_ARGS__); 00074 #endif 00075 #else 00076 #define DBG_SOCKET(x, ...) 00077 #endif 00078 00079 #if (CC3000_DEBUG_HCI_TX == 1) 00080 #if (VT100_COLOUR == 1) 00081 #define DBG_HCI(x, ...) std::printf("\x1b[2;35;40m[CC3000 : HCI RX] "x"\x1b[0;37;40m\r\n", ##__VA_ARGS__); 00082 #else 00083 #define DBG_HCI(x, ...) std::printf("[CC3000 : HCI RX] "x"\r\n", ##__VA_ARGS__); 00084 #endif 00085 #else 00086 #define DBG_HCI(x, ...) 00087 #endif 00088 00089 #if (CC3000_DEBUG_HCI_RX == 1) 00090 #if (VT100_COLOUR == 1) 00091 #define DBG_HCI_CMD(x, ...) std::printf("\x1b[2;36;40m[CC3000 : HCI TX] "x"\x1b[0;37;40m\r\n", ##__VA_ARGS__); 00092 #else 00093 #define DBG_HCI_CMD(x, ...) std::printf("[CC3000 : HCI TX] "x"\r\n", ##__VA_ARGS__); 00094 #endif 00095 #else 00096 #define DBG_HCI_CMD(x, ...) 00097 #endif 00098 00099 #if (CC3000_DEBUG == 1) 00100 #if (VT100_COLOUR == 1) 00101 #define DBG_CC(x, ...) std::printf("\x1b[2;32;40m[CC3000] "x"\x1b[0;37;40m\r\n", ##__VA_ARGS__); 00102 #else 00103 #define DBG_CC(x, ...) std::printf("[CC3000] "x"\r\n", ##__VA_ARGS__); 00104 #endif 00105 #else 00106 #define DBG_CC(x, ...) 00107 #endif 00108 00109 namespace mbed_cc3000 { 00110 00111 /** User info structure 00112 */ 00113 typedef struct { 00114 uint8_t FTC; // First time config performed 00115 uint8_t PP_version[2]; // Patch Programmer version 00116 uint8_t SERV_PACK[2]; // Service Pack Version 00117 uint8_t DRV_VER[3]; // Driver Version 00118 uint8_t FW_VER[3]; // Firmware Version 00119 uint8_t validCIK; // CIK[] is valid (Client Interface Key) 00120 uint8_t CIK[40]; 00121 } tUserFS; 00122 00123 /** Function pointers which are not yet implemented 00124 */ 00125 enum FunctionNumber { 00126 FW_PATCHES = 0, 00127 DRIVER_PATCHES = 1, 00128 BOOTLOADER_PATCHES = 2, 00129 }; 00130 00131 /** AP security 00132 */ 00133 enum Security { 00134 NONE = 0, 00135 WEP = 1, 00136 WPA = 2, 00137 WPA2 = 3 00138 }; 00139 00140 /** CC3000 Simple Link class which contains status of cc3000. 00141 */ 00142 class cc3000_simple_link { 00143 public: 00144 /** 00145 * \brief ctor - sets magic number in the buffers (overflow mark). 00146 * \param none 00147 * \return none 00148 */ 00149 cc3000_simple_link(); 00150 /** 00151 * \brief dtor 00152 * \param none 00153 * \return none 00154 */ 00155 ~cc3000_simple_link(); 00156 /** 00157 * \brief Returns data received flag. 00158 * \return Data received flag. 00159 */ 00160 uint8_t get_data_received_flag(); 00161 /** 00162 * \brief Set data received flag. 00163 * \param value The value to be set. 00164 */ 00165 void set_data_received_flag(uint8_t value); 00166 /** Returns if tx was completed. 00167 * \return 00168 * true if tx was completed, 00169 * false otherwise. 00170 */ 00171 bool get_tx_complete_signal(); 00172 /** 00173 * \brief Sets flag that tx was completed. 00174 * \param value Value to be set 00175 * \return none 00176 */ 00177 void set_tx_complete_signal(bool value); 00178 /** 00179 * \brief Get receive buffer. 00180 * \param none 00181 * \return Pointer to the receive buffer. 00182 */ 00183 uint8_t *get_received_buffer(); 00184 /** 00185 * \brief Get transmit buffer. 00186 * \param none 00187 * \return Pointer to the transmit buffer. 00188 */ 00189 uint8_t *get_transmit_buffer(); 00190 /** 00191 * \brief Get number of free buffers. 00192 * \param none 00193 * \return 00194 * Number of free buffers. 00195 */ 00196 uint16_t get_number_free_buffers(); 00197 /** 00198 * \brief Set number of free buffers. 00199 * \param value Number of free buffers. 00200 * \return none 00201 */ 00202 void set_number_free_buffers(uint16_t value); 00203 /** 00204 * \brief Retrieve buffer length. 00205 * \param none 00206 * \return Buffer length 00207 */ 00208 uint16_t get_buffer_length(); 00209 /** 00210 * \brief Set buffer length 00211 * \param value The length 00212 * \return none 00213 */ 00214 void set_buffer_length(uint16_t value); 00215 /** 00216 * \brief Retrieve pending data flag. 00217 * \param none 00218 * \return Pending data flag 00219 */ 00220 uint16_t get_pending_data(); 00221 /** 00222 * \brief Set pending data flag. 00223 * \param value Pending data value. 00224 * \return none 00225 */ 00226 void set_pending_data(uint16_t value); 00227 /** 00228 * \brief Retreive op code. 00229 * \param none 00230 * \return Op code 00231 */ 00232 uint16_t get_op_code(); 00233 /** 00234 * \brief Set op code. 00235 * \param code op code. 00236 * \return none 00237 */ 00238 void set_op_code(uint16_t code); 00239 /** 00240 * \brief Get number of released packets. 00241 * \param none 00242 * \return Number of released packets. 00243 */ 00244 uint16_t get_released_packets(); 00245 /** 00246 * \brief Set number of released packets. 00247 * \param value Number of released packets. 00248 * \return none 00249 */ 00250 void set_number_of_released_packets(uint16_t value); 00251 /** 00252 * \brief Get number of sent packats 00253 * \param none 00254 * \return Number of sent packets. 00255 */ 00256 uint16_t get_sent_packets(); 00257 /** 00258 * \brief Set number of sent packets 00259 * \param value Number of sent packets. 00260 * \return none 00261 */ 00262 void set_sent_packets(uint16_t value); 00263 /** 00264 * \brief Retrieve transmit error 00265 * \param none 00266 * \return Transmit error 00267 */ 00268 int32_t get_transmit_error(); 00269 /** 00270 * \brief Set transmit error. 00271 * \param value Error to be set. 00272 * \return none 00273 */ 00274 void set_transmit_error(int32_t value); 00275 /** 00276 * \brief Get buffer size. 00277 * \param none 00278 * \return Size of buffer. 00279 */ 00280 uint16_t get_buffer_size(); 00281 /** 00282 * \brief Set buffer size. 00283 * \param value Buffer size. 00284 * \return none 00285 */ 00286 void set_buffer_size(uint16_t value); 00287 /** 00288 * \brief Not used currently. 00289 * \param function Number of desired function. 00290 * \return void pointer to the function (need to recast). 00291 */ 00292 void *get_func_pointer(FunctionNumber function); 00293 /** 00294 * \brief Retreive pointer to the received data. 00295 * \param none 00296 * \return Pointer to the received data buffer. 00297 */ 00298 uint8_t *get_received_data(); 00299 /** 00300 * \brief Set received data pointer. 00301 * \param pointer Pointer to the buffer. 00302 * \return none 00303 */ 00304 void set_received_data(uint8_t *pointer); 00305 private: 00306 uint8_t _data_received_flag; 00307 bool _tx_complete_signal; 00308 uint16_t _rx_event_opcode; 00309 uint16_t _free_buffers; 00310 uint16_t _buffer_length; 00311 uint16_t _buffer_size; 00312 uint16_t _rx_data_pending; 00313 uint16_t _sent_packets; 00314 uint16_t _released_packets; 00315 int32_t _transmit_data_error; 00316 uint8_t *_received_data; 00317 uint8_t _rx_buffer[CC3000_RX_BUFFER_SIZE]; 00318 uint8_t _tx_buffer[CC3000_TX_BUFFER_SIZE]; 00319 private: 00320 /* Not used currently */ 00321 int8_t *(* _fFWPatches)(uint32_t *length); 00322 int8_t *(* _fDriverPatches)(uint32_t *length); 00323 int8_t *(* _fBootLoaderPatches)(uint32_t *length); 00324 }; 00325 00326 /** Forward declaration classes 00327 */ 00328 class cc3000_hci; 00329 class cc3000_nvmem; 00330 class cc3000_spi; 00331 class cc3000; 00332 00333 /** Event layer 00334 */ 00335 class cc3000_event { 00336 public: 00337 /** 00338 * \brief Ctor 00339 * \param simplelink Reference to simple link object. 00340 * \param hci Reference to hci object. 00341 * \param spi Reference to spi object. 00342 * \param cc3000 Reference to cc3000 object. 00343 * \return none 00344 */ 00345 cc3000_event(cc3000_simple_link &simplelink, cc3000_hci &hci, cc3000_spi &spi, cc3000 &cc3000); 00346 /** 00347 * \brief Dtor 00348 * \param none 00349 * \return none 00350 */ 00351 ~cc3000_event(); 00352 /** 00353 * \brief Handle unsolicited event from type patch request. 00354 * \param event_hdr event header 00355 * \return none 00356 */ 00357 void hci_unsol_handle_patch_request(uint8_t *event_hdr); 00358 /** 00359 * \brief Parse the incoming event packets and issue corresponding event handler from global array of handlers pointers. 00360 * \param ret_param incoming data buffer 00361 * \param from from information (in case of data received) 00362 * \param fromlen from information length (in case of data received) 00363 * \return none 00364 */ 00365 uint8_t* hci_event_handler(void *ret_param, uint8_t *from, uint8_t *fromlen); 00366 /** 00367 * \brief Handle unsolicited events. 00368 * \param event_hdr Event header 00369 * \return 1 if event supported and handled 00370 * \return 0 if event is not supported 00371 */ 00372 int32_t hci_unsol_event_handler(uint8_t *event_hdr); 00373 /** 00374 * \brief Parse the incoming unsolicited event packets and start corresponding event handler. 00375 * \param None 00376 * \return ESUCCESS if successful, EFAIL if an error occurred. 00377 */ 00378 int32_t hci_unsolicited_event_handler(void); 00379 /** 00380 * \brief Get the socket status. 00381 * \param Sd Socket IS 00382 * \return Current status of the socket. 00383 */ 00384 int32_t get_socket_active_status(int32_t sd); 00385 /** 00386 * \brief Check if the socket ID and status are valid and set the global socket status accordingly. 00387 * \param Sd Sock descr 00388 * \param Status status to be set 00389 * \return none 00390 */ 00391 void set_socket_active_status(int32_t sd, int32_t status); 00392 /** 00393 * \brief Keep track on the number of packets transmitted and update the number of free buffer in the SL device. 00394 * \brief Called when unsolicited event = HCI_EVNT_DATA_UNSOL_FREE_BUFF has received. 00395 * \param event pointer to the string contains parameters for IPERF. 00396 * \return ESUCCESS if successful, EFAIL if an error occurred. 00397 */ 00398 int32_t hci_event_unsol_flowcontrol_handler(uint8_t *event); 00399 /** 00400 * \brief Update the socket status. 00401 * \param resp_params Socket IS 00402 * \return Current status of the socket. 00403 */ 00404 void update_socket_active_status(uint8_t *resp_params); 00405 /** 00406 * \brief Wait for event, pass it to the hci_event_handler and update the event opcode in a global variable. 00407 * \param op_code Command operation code 00408 * \param ret_param Command return parameters 00409 * \return none 00410 */ 00411 void simplelink_wait_event(uint16_t op_code, void *ret_param); 00412 /** 00413 * \brief Wait for data, pass it to the hci_event_handler and set the data available flag. 00414 * \param buffer Data buffer 00415 * \param from From information 00416 * \param fromlen From information length 00417 * \return none 00418 */ 00419 void simplelink_wait_data(uint8_t *buffer, uint8_t *from, uint8_t *fromlen); 00420 /** 00421 * \brief Trigger Received event/data processing - called from the SPI library to receive the data 00422 * \param buffer pointer to the received data buffer\n 00423 * The function triggers Received event/data processing\n 00424 * \return none 00425 */ 00426 void received_handler(uint8_t *buffer); 00427 private: 00428 uint32_t socket_active_status; 00429 cc3000_simple_link &_simple_link; 00430 cc3000_hci &_hci; 00431 cc3000_spi &_spi; 00432 cc3000 &_cc3000; 00433 }; 00434 00435 /** Netapp layer 00436 */ 00437 class cc3000_netapp { 00438 public: 00439 /** 00440 * \brief Ctor 00441 * \param simple_link Reference to the simple link object. 00442 * \param nvmem Reference to the nvmem object. 00443 * \param hci Reference to the hci object. 00444 * \param event Reference to the event object. 00445 * \return none 00446 */ 00447 cc3000_netapp(cc3000_simple_link &simple_link, cc3000_nvmem &nvmem, cc3000_hci &hci, cc3000_event &event); 00448 /** 00449 * \brief Dtor 00450 * \param none 00451 * \return none 00452 */ 00453 ~cc3000_netapp(); 00454 /** 00455 * \brief Configure device MAC address and store it in NVMEM. 00456 * The value of the MAC address configured through the API will be\n 00457 * stored in CC3000 non volatile memory, thus preserved over resets.\n 00458 * \param mac device mac address, 6 bytes. Saved: yes 00459 * \return return on success 0, otherwise error. 00460 */ 00461 int32_t config_mac_adrress(uint8_t *mac); 00462 /** 00463 * \brief Configure the network interface, static or dynamic (DHCP). 00464 * In order to activate DHCP mode, ip, subnet_mask, default_gateway must be 0.\n 00465 * The default mode of CC3000 is DHCP mode. The configuration is saved in non volatile memory\n 00466 * and thus preserved over resets.\n 00467 * \param ip device mac address, 6 bytes. Saved: yes 00468 * \param subnet_mask device mac address, 6 bytes. Saved: yes 00469 * \param default_gateway device mac address, 6 bytes. Saved: yes 00470 * \param dns_server device mac address, 6 bytes. Saved: yes 00471 * \return 0 on success, otherwise error. 00472 * \note If the mode is altered, a reset of CC3000 device is required to apply the changes.\n 00473 * Also note that an asynchronous event of type 'DHCP_EVENT' is generated only when\n 00474 * a connection to the AP was established. This event is generated when an IP address\n 00475 * is allocated either by the DHCP server or by static allocation.\n 00476 */ 00477 int32_t dhcp(uint32_t *ip, uint32_t *subnet_mask,uint32_t *default_gateway, uint32_t *dns_server); 00478 #ifndef CC3000_TINY_DRIVER 00479 /** 00480 * \brief Get the CC3000 Network interface information. 00481 * This information is only available after establishing a WLAN connection.\n 00482 * Undefined values are returned when this function is called before association.\n 00483 * \param ipconfig pointer to a tNetappIpconfigRetArgs structure for storing the network interface configuration.\n 00484 * tNetappIpconfigRetArgs: aucIP - ip address,\n 00485 * aucSubnetMask - mask 00486 * aucDefaultGateway - default gateway address\n 00487 * aucDHCPServer - dhcp server address\n 00488 * aucDNSServer - dns server address\n 00489 * uaMacAddr - mac address\n 00490 * uaSSID - connected AP ssid\n 00491 * \return none 00492 * \note This function is useful for figuring out the IP Configuration of\n 00493 * the device when DHCP is used and for figuring out the SSID of\n 00494 * the Wireless network the device is associated with.\n 00495 */ 00496 void ipconfig(tNetappIpconfigRetArgs *ipconfig); 00497 /** 00498 * \brief Set new timeout values for DHCP lease timeout, ARP refresh timeout, keepalive event timeout and socket inactivity timeout 00499 * \param dhcp DHCP lease time request, also impact\n 00500 * the DHCP renew timeout.\n 00501 * Range: [0-0xffffffff] seconds,\n 00502 * 0 or 0xffffffff = infinite lease timeout.\n 00503 * Resolution: 10 seconds.\n 00504 * Influence: only after reconnecting to the AP. \n 00505 * Minimal bound value: MIN_TIMER_VAL_SECONDS - 20 seconds.\n 00506 * The parameter is saved into the CC3000 NVMEM.\n 00507 * The default value on CC3000 is 14400 seconds.\n 00508 * 00509 * \param arp ARP refresh timeout, if ARP entry is not updated by\n 00510 * incoming packet, the ARP entry will be deleted by\n 00511 * the end of the timeout. \n 00512 * Range: [0-0xffffffff] seconds, 0 = infinite ARP timeout\n 00513 * Resolution: 10 seconds.\n 00514 * Influence: at runtime.\n 00515 * Minimal bound value: MIN_TIMER_VAL_SECONDS - 20 seconds\n 00516 * The parameter is saved into the CC3000 NVMEM.\n 00517 * The default value on CC3000 is 3600 seconds.\n 00518 * 00519 * \param keep_alive Keepalive event sent by the end of keepalive timeout\n 00520 * Range: [0-0xffffffff] seconds, 0 == infinite timeout\n 00521 * Resolution: 10 seconds.\n 00522 * Influence: at runtime.\n 00523 * Minimal bound value: MIN_TIMER_VAL_SECONDS - 20 sec\n 00524 * The parameter is saved into the CC3000 NVMEM. \n 00525 * The default value on CC3000 is 10 seconds.\n 00526 * 00527 * \param inactivity Socket inactivity timeout, socket timeout is\n 00528 * refreshed by incoming or outgoing packet, by the\n 00529 * end of the socket timeout the socket will be closed\n 00530 * Range: [0-0xffffffff] sec, 0 == infinite timeout.\n 00531 * Resolution: 10 seconds.\n 00532 * Influence: at runtime.\n 00533 * Minimal bound value: MIN_TIMER_VAL_SECONDS - 20 sec\n 00534 * The parameter is saved into the CC3000 NVMEM.\n 00535 * The default value on CC3000 is 60 seconds.\n 00536 * 00537 * \return 0 on success,otherwise error. 00538 * 00539 * \note A parameter set to a non zero value less than 20s automatically changes to 20s. 00540 */ 00541 int32_t timeout_values(uint32_t *dhcp, uint32_t *arp,uint32_t *keep_alive, uint32_t *inactivity); 00542 /** 00543 * \brief send ICMP ECHO_REQUEST to network hosts 00544 * \param ip destination IP address 00545 * \param ping_attempts number of echo requests to send 00546 * \param ping_size send buffer size which may be up to 1400 bytes 00547 * \param ping_timeout Time to wait for a response,in milliseconds. 00548 * \return 0 on success, otherwise error. 00549 * 00550 * \note A succesful operation will generate an asynchronous ping report event.\n 00551 * The report structure is defined by structure netapp_pingreport_args_t.\n 00552 * \warning Calling this function while a Ping Request is in progress will kill the ping request in progress. 00553 */ 00554 int32_t ping_send(uint32_t *ip, uint32_t ping_attempts, uint32_t ping_size, uint32_t ping_timeout); 00555 /** 00556 * \brief Ping status request. 00557 * This API triggers the CC3000 to send asynchronous events: HCI_EVNT_WLAN_ASYNC_PING_REPORT.\n 00558 * This event will create the report structure in netapp_pingreport_args_t.\n 00559 * This structure is filled with ping results until the API is triggered.\n 00560 * netapp_pingreport_args_t: packets_sent - echo sent\n 00561 * packets_received - echo reply\n 00562 * min_round_time - minimum round time\n 00563 * max_round_time - max round time\n 00564 * avg_round_time - average round time\n 00565 * 00566 * \param none 00567 * \return none 00568 * \note When a ping operation is not active, the returned structure fields are 0. 00569 */ 00570 void ping_report(); 00571 /** 00572 * \brief Stop any ping request. 00573 * \param none 00574 * \return 0 on success 00575 * -1 on error 00576 */ 00577 int32_t ping_stop(); 00578 /** 00579 * \brief Flush ARP table 00580 * \param none 00581 * \return none 00582 */ 00583 int32_t arp_flush(); 00584 #endif 00585 private: 00586 cc3000_simple_link &_simple_link; 00587 cc3000_nvmem &_nvmem; 00588 cc3000_hci &_hci; 00589 cc3000_event &_event; 00590 }; 00591 00592 #ifndef CC3000_UNENCRYPTED_SMART_CONFIG 00593 /** Security class used only if encrypted smart config is set 00594 */ 00595 class cc3000_security { 00596 public: 00597 /** 00598 * \brief Expand a 16 bytes key for AES128 implementation. 00599 * \param expanded_key expanded AES128 key 00600 * \param key AES128 key - 16 bytes 00601 * \return none 00602 */ 00603 void expandKey(uint8_t *expanded_key, uint8_t *key); 00604 /** 00605 * \brief multiply by 2 in the galois field. 00606 * \param value Argument to multiply 00607 * \return multiplied argument 00608 */ 00609 uint8_t galois_mul2(uint8_t value); 00610 /** 00611 * \brief internal implementation of AES128 encryption. 00612 * straight forward aes encryption implementation\n 00613 * first the group of operations 00614 * - addRoundKey 00615 * - subbytes 00616 * - shiftrows 00617 * - mixcolums\n 00618 * 00619 * is executed 9 times, after this addroundkey to finish the 9th\n 00620 * round, after that the 10th round without mixcolums\n 00621 * no further subfunctions to save cycles for function calls\n 00622 * no structuring with "for (....)" to save cycles.\n 00623 * \param[in] expanded_key expanded AES128 key 00624 * \param[in/out] state 16 bytes of plain text and cipher text 00625 * \return none 00626 */ 00627 void aes_encr(uint8_t *state, uint8_t *expanded_key); 00628 /** 00629 * \brief internal implementation of AES128 decryption. 00630 * straightforward aes decryption implementation\n 00631 * the order of substeps is the exact reverse of decryption\n 00632 * inverse functions: 00633 * - addRoundKey is its own inverse 00634 * - rsbox is inverse of sbox 00635 * - rightshift instead of leftshift 00636 * - invMixColumns = barreto + mixColumns\n 00637 * 00638 * no further subfunctions to save cycles for function calls\n 00639 * no structuring with "for (....)" to save cycles\n 00640 * \param[in] expanded_key expanded AES128 key 00641 * \param[in\out] state 16 bytes of cipher text and plain text 00642 * \return none 00643 */ 00644 void aes_decr(uint8_t *state, uint8_t *expanded_key); 00645 /** 00646 * \brief AES128 encryption. 00647 * Given AES128 key and 16 bytes plain text, cipher text of 16 bytes is computed.\n 00648 * The AES implementation is in mode ECB (Electronic Code Book).\n 00649 * \param[in] key AES128 key of size 16 bytes 00650 * \param[in\out] state 16 bytes of plain text and cipher text 00651 * \return none 00652 */ 00653 void aes_encrypt(uint8_t *state, uint8_t *key); 00654 /** 00655 * \brief AES128 decryption. 00656 * Given AES128 key and 16 bytes cipher text, plain text of 16 bytes is computed.\n 00657 * The AES implementation is in mode ECB (Electronic Code Book).\n 00658 * \param[in] key AES128 key of size 16 bytes 00659 * \param[in\out] state 16 bytes of cipher text and plain text 00660 * \return none 00661 */ 00662 void aes_decrypt(uint8_t *state, uint8_t *key); 00663 /** 00664 * \brief Read the AES128 key from fileID #12 in EEPROM. 00665 * \param[out] key AES128 key of size 16 bytes 00666 * \return 0 on success, error otherwise. 00667 */ 00668 int32_t aes_read_key(uint8_t *key); 00669 /** 00670 * \brief Write the AES128 key to fileID #12 in EEPROM. 00671 * \param[out] key AES128 key of size 16 bytes 00672 * \return on success 0, error otherwise. 00673 */ 00674 int32_t aes_write_key(uint8_t *key); 00675 private: 00676 uint8_t _expanded_key[176]; 00677 }; 00678 #endif 00679 00680 /** Socket layer 00681 */ 00682 class cc3000_socket { 00683 public: 00684 /** 00685 * \brief Ctor 00686 * \param simplelink Reference to simple link object. 00687 * \param hci Reference to hci object. 00688 * \param event Reference to event object. 00689 * \return none 00690 */ 00691 cc3000_socket(cc3000_simple_link &simplelink, cc3000_hci &hci, cc3000_event &event); 00692 /** 00693 * \brief Dtor 00694 * \param 00695 * \return none 00696 */ 00697 ~cc3000_socket(); 00698 /** 00699 * \brief create an endpoint for communication. 00700 * The socket function creates a socket that is bound to a specific transport service provider.\n 00701 * This function is called by the application layer to obtain a socket handle.\n 00702 * 00703 * \param domain selects the protocol family which will be used for\n 00704 * communication. On this version only AF_INET is supported\n 00705 * \param type specifies the communication semantics. On this version\n 00706 * only SOCK_STREAM, SOCK_DGRAM, SOCK_RAW are supported\n 00707 * \param protocol specifies a particular protocol to be used with the\n 00708 * socket IPPROTO_TCP, IPPROTO_UDP or IPPROTO_RAW are supported.\n 00709 * \return On success, socket handle that is used for consequent socket operations\n 00710 * On error, -1 is returned.\n 00711 */ 00712 int32_t socket(int32_t domain, int32_t type, int32_t protocol); 00713 /** 00714 * \brief accept a connection on a socket. 00715 * This function is used with connection-based socket types\n 00716 * (SOCK_STREAM). It extracts the first connection request on the\n 00717 * queue of pending connections, creates a new connected socket, and\n 00718 * returns a new file descriptor referring to that socket.\n 00719 * The newly created socket is not in the listening state.\n 00720 * The original socket sd is unaffected by this call.\n 00721 * The argument sd is a socket that has been created with socket(),\n 00722 * bound to a local address with bind(), and is listening for \n 00723 * connections after a listen(). The argument addr is a pointer \n 00724 * to a sockaddr structure. This structure is filled in with the \n 00725 * address of the peer socket, as known to the communications layer.\n 00726 * The exact format of the address returned addr is determined by the \n 00727 * socket's address family. The addrlen argument is a value-result\n 00728 * argument: it should initially contain the size of the structure\n 00729 * pointed to by addr, on return it will contain the actual\n 00730 * length (in bytes) of the address returned.\n 00731 * 00732 * \param[in] sd socket descriptor (handle)\n 00733 * \param[out] addr the argument addr is a pointer to a sockaddr structure\n 00734 * This structure is filled in with the address of the \n 00735 * peer socket, as known to the communications layer. \n 00736 * determined. The exact format of the address returned \n 00737 * addr is by the socket's address sockaddr. \n 00738 * On this version only AF_INET is supported.\n 00739 * This argument returns in network order.\n 00740 * \param[out] addrlen the addrlen argument is a value-result argument: \n 00741 * it should initially contain the size of the structure\n 00742 * pointed to by addr.\n 00743 * \return For socket in blocking mode:\n 00744 * - On success, socket handle. on failure negative\n 00745 * For socket in non-blocking mode:\n 00746 * - On connection establishment, socket handle\n 00747 * - On connection pending, SOC_IN_PROGRESS (-2)\n 00748 * - On failure, SOC_ERROR (-1)\n 00749 * \sa socket ; bind ; listen 00750 */ 00751 int32_t accept(int32_t sd, sockaddr *addr, socklen_t *addrlen); 00752 /** 00753 * \brief assign a name to a socket. 00754 * This function gives the socket the local address addr.\n 00755 * addr is addrlen bytes long. Traditionally, this is called when a \n 00756 * socket is created with socket, it exists in a name space (address \n 00757 * family) but has no name assigned.\n 00758 * It is necessary to assign a local address before a SOCK_STREAM\n 00759 * socket may receive connections.\n 00760 * 00761 * \param[in] sd socket descriptor (handle) 00762 * \param[out] addr specifies the destination address. On this version\n 00763 * only AF_INET is supported.\n 00764 * \param[out] addrlen contains the size of the structure pointed to by addr.\n 00765 * \return On success, zero is returned.\n 00766 * On error, -1 is returned.\n 00767 * \sa socket ; accept ; listen 00768 */ 00769 int32_t bind(int32_t sd, const sockaddr *addr, int32_t addrlen); 00770 /** 00771 * \brief HostFlowControlConsumeBuff. 00772 * if SEND_NON_BLOCKING is not defined - block until a free buffer is available,\n 00773 * otherwise return the status of the available buffers.\n 00774 * 00775 * \param sd socket descriptor 00776 * \return 0 in case there are buffers available, \n 00777 * -1 in case of bad socket\n 00778 * -2 if there are no free buffers present (only when SEND_NON_BLOCKING is enabled)\n 00779 */ 00780 int32_t HostFlowControlConsumeBuff(int32_t sd); 00781 /** 00782 * \brief The socket function closes a created socket. 00783 * \param sd socket handle. 00784 * \return On success, zero is returned. On error, -1 is returned. 00785 */ 00786 int32_t closesocket(int32_t sd); 00787 /** 00788 * \brief listen for connections on a socket. 00789 * The willingness to accept incoming connections and a queue\n 00790 * limit for incoming connections are specified with listen(),\n 00791 * and then the connections are accepted with accept.\n 00792 * The listen() call applies only to sockets of type SOCK_STREAM\n 00793 * The backlog parameter defines the maximum length the queue of\n 00794 * pending connections may grow to. \n 00795 * 00796 * \param[in] sd socket descriptor (handle) 00797 * \param[in] backlog specifies the listen queue depth. On this version\n 00798 * backlog is not supported.\n 00799 * \return On success, zero is returned.\n 00800 * On error, -1 is returned.\n 00801 * \sa socket ; accept ; bind 00802 * \note On this version, backlog is not supported 00803 */ 00804 int32_t listen(int32_t sd, int32_t backlog); 00805 /** 00806 * \brief initiate a connection on a socket. 00807 * Function connects the socket referred to by the socket descriptor\n 00808 * sd, to the address specified by addr. The addrlen argument \n 00809 * specifies the size of addr. The format of the address in addr is \n 00810 * determined by the address space of the socket. If it is of type \n 00811 * SOCK_DGRAM, this call specifies the peer with which the socket is \n 00812 * to be associated; this address is that to which datagrams are to be\n 00813 * sent, and the only address from which datagrams are to be received. \n 00814 * If the socket is of type SOCK_STREAM, this call attempts to make a \n 00815 * connection to another socket. The other socket is specified by \n 00816 * address, which is an address in the communications space of the\n 00817 * socket. Note that the function implements only blocking behavior \n 00818 * thus the caller will be waiting either for the connection \n 00819 * establishment or for the connection establishment failure.\n 00820 * 00821 * \param[in] sd socket descriptor (handle) 00822 * \param[in] addr specifies the destination addr. On this version\n 00823 * only AF_INET is supported.\n 00824 * \param[out] addrlen contains the size of the structure pointed to by addr 00825 * \return On success, zero is returned.\n 00826 On error, -1 is returned\n 00827 * \sa socket 00828 */ 00829 int32_t connect(int32_t sd, const sockaddr *addr, int32_t addrlen); 00830 /** 00831 * \brief Monitor socket activity. 00832 * Select allow a program to monitor multiple file descriptors,\n 00833 * waiting until one or more of the file descriptors become \n 00834 * "ready" for some class of I/O operation \n 00835 * 00836 * \param[in] nfds the highest-numbered file descriptor in any of the\n 00837 * three sets, plus 1. \n 00838 * \param[out] readsds socket descriptors list for read monitoring\n 00839 * \param[out] writesds socket descriptors list for write monitoring\n 00840 * \param[out] exceptsds socket descriptors list for exception monitoring\n 00841 * \param[in] timeout is an upper bound on the amount of time elapsed\n 00842 * before select() returns. Null means infinity \n 00843 * timeout. The minimum timeout is 5 milliseconds,\n 00844 * less than 5 milliseconds will be set\n 00845 * automatically to 5 milliseconds.\n 00846 * \return On success, select() returns the number of file descriptors\n 00847 * contained in the three returned descriptor sets (that is, the\n 00848 * total number of bits that are set in readfds, writefds,\n 00849 * exceptfds) which may be zero if the timeout expires before\n 00850 * anything interesting happens.\n 00851 * On error, -1 is returned.\n 00852 * *readsds - return the sockets on which Read request will\n 00853 * return without delay with valid data.\n 00854 * *writesds - return the sockets on which Write request \n 00855 * will return without delay.\n 00856 * *exceptsds - return the sockets which closed recently.\n 00857 * \Note If the timeout value set to less than 5ms it will automatically\n 00858 * change to 5ms to prevent overload of the system\n 00859 * \sa socket 00860 */ 00861 int32_t select(int32_t nfds, fd_set *readsds, fd_set *writesds, fd_set *exceptsds, struct timeval *timeout); 00862 /** 00863 * \brief get socket options. 00864 * This function manipulate the options associated with a socket.\n 00865 * Options may exist at multiple protocol levels; they are always\n 00866 * present at the uppermost socket level.\n 00867 * When manipulating socket options the level at which the option \n 00868 * resides and the name of the option must be specified. \n 00869 * To manipulate options at the socket level, level is specified as \n 00870 * SOL_SOCKET. To manipulate options at any other level the protocol \n 00871 * number of the appropriate protocol controlling the option is \n 00872 * supplied. For example, to indicate that an option is to be \n 00873 * interpreted by the TCP protocol, level should be set to the \n 00874 * protocol number of TCP; \n 00875 * The parameters optval and optlen are used to access optval -\n 00876 * use for setsockopt(). For getsockopt() they identify a buffer\n 00877 * in which the value for the requested option(s) are to \n 00878 * be returned. For getsockopt(), optlen is a value-result \n 00879 * parameter, initially containing the size of the buffer \n 00880 * pointed to by option_value, and modified on return to \n 00881 * indicate the actual size of the value returned. If no option \n 00882 * value is to be supplied or returned, option_value may be NULL.\n 00883 * 00884 * \param[in] sd socket handle 00885 * \param[in] level defines the protocol level for this option 00886 * \param[in] optname defines the option name to Interrogate 00887 * \param[out] optval specifies a value for the option 00888 * \param[out] optlen specifies the length of the option value 00889 * \return On success, zero is returned. On error, -1 is returned 00890 * 00891 * \Note On this version the following two socket options are enabled:\n 00892 * The only protocol level supported in this version is SOL_SOCKET (level).\n 00893 * 1. SOCKOPT_RECV_TIMEOUT (optname)\n 00894 * SOCKOPT_RECV_TIMEOUT configures recv and recvfrom timeout in milliseconds.\n 00895 * In that case optval should be pointer to unsigned long.\n 00896 * 2. SOCKOPT_NONBLOCK (optname). sets the socket non-blocking mode on or off.\n 00897 * In that case optval should be SOCK_ON or SOCK_OFF (optval).\n 00898 * \sa setsockopt 00899 */ 00900 int32_t getsockopt (int32_t sd, int32_t level, int32_t optname, void *optval, socklen_t *optlen); 00901 /** 00902 * \brief Read data from socket (simple_link_recv). 00903 * Return the length of the message on successful completion.\n 00904 * If a message is too long to fit in the supplied buffer, excess bytes may\n 00905 * be discarded depending on the type of socket the message is received from.\n 00906 * 00907 * \param sd socket handle 00908 * \param buf read buffer 00909 * \param len buffer length 00910 * \param flags indicates blocking or non-blocking operation 00911 * \param from pointer to an address structure indicating source address 00912 * \param fromlen source address structure size 00913 * \return Return the number of bytes received, or -1 if an error occurred 00914 */ 00915 int32_t simple_link_recv(int32_t sd, void *buf, int32_t len, int32_t flags, sockaddr *from, socklen_t *fromlen, int32_t opcode); 00916 /** 00917 * \brief Transmit a message to another socket (simple_link_send). 00918 * \param sd socket handle 00919 * \param buf write buffer 00920 * \param len buffer length 00921 * \param flags On this version, this parameter is not supported 00922 * \param to pointer to an address structure indicating destination address 00923 * \param tolen destination address structure size 00924 * \return Return the number of bytes transmitted, or -1 if an error\n 00925 * occurred, or -2 in case there are no free buffers available\n 00926 * (only when SEND_NON_BLOCKING is enabled)\n 00927 */ 00928 int32_t simple_link_send(int32_t sd, const void *buf, int32_t len, int32_t flags, const sockaddr *to, int32_t tolen, int32_t opcode); 00929 /** 00930 * \brief Receive a message from a connection-mode socket. 00931 * \param[in] sd socket handle 00932 * \param[out] buf Points to the buffer where the message should be stored 00933 * \param[in] len Specifies the length in bytes of the buffer pointed to \n 00934 * by the buffer argument.\n 00935 * \param[in] flags Specifies the type of message reception. \n 00936 * On this version, this parameter is not supported.\n 00937 * \return Return the number of bytes received, or -1 if an error occurred 00938 * \sa recvfrom 00939 * \Note On this version, only blocking mode is supported. 00940 */ 00941 int32_t recv(int32_t sd, void *buf, int32_t len, int32_t flags); 00942 /** 00943 * \brief read data from socket (recvfrom). 00944 * Receives a message from a connection-mode or connectionless-mode socket.\n 00945 * Note that raw sockets are not supported.\n 00946 * 00947 * \param[in] sd socket handle 00948 * \param[out] buf Points to the buffer where the message should be stored 00949 * \param[in] len Specifies the length in bytes of the buffer pointed to \n 00950 * by the buffer argument.\n 00951 * \param[in] flags Specifies the type of message reception.\n 00952 * On this version, this parameter is not supported.\n 00953 * \param[in] from pointer to an address structure indicating the source\n 00954 * address: sockaddr. On this version only AF_INET is\n 00955 * supported.\n 00956 * \param[in] fromlen source address structure size 00957 * \return Return the number of bytes received, or -1 if an error occurred 00958 * \sa recv 00959 * \Note On this version, only blocking mode is supported. 00960 */ 00961 int32_t recvfrom(int32_t sd, void *buf, int32_t len, int32_t flags, sockaddr *from, socklen_t *fromlen); 00962 /** 00963 * \brief Transmit a message to another socket (send). 00964 * \param sd socket handle 00965 * \param buf Points to a buffer containing the message to be sent 00966 * \param len message size in bytes 00967 * \param flags On this version, this parameter is not supported 00968 * \return Return the number of bytes transmitted, or -1 if an\n 00969 * error occurred\n 00970 * \Note On this version, only blocking mode is supported. 00971 * \sa sendto 00972 */ 00973 int32_t send(int32_t sd, const void *buf, int32_t len, int32_t flags); 00974 /** 00975 * \brief Transmit a message to another socket (sendto). 00976 * \param sd socket handle 00977 * \param buf Points to a buffer containing the message to be sent 00978 * \param len message size in bytes 00979 * \param flags On this version, this parameter is not supported 00980 * \param to pointer to an address structure indicating the destination\n 00981 * address: sockaddr. On this version only AF_INET is\n 00982 * supported.\n 00983 * \param tolen destination address structure size 00984 * \return Return the number of bytes transmitted, or -1 if an error occurred 00985 * \Note On this version, only blocking mode is supported. 00986 * \sa send 00987 */ 00988 int32_t sendto(int32_t sd, const void *buf, int32_t len, int32_t flags, const sockaddr *to, socklen_t tolen); 00989 /** 00990 * \brief Set CC3000 in mDNS advertiser mode in order to advertise itself. 00991 * \param[in] mdns_enabled flag to enable/disable the mDNS feature 00992 * \param[in] device_service_name Service name as part of the published\n 00993 * canonical domain name\n 00994 * \param[in] device_service_name_length Length of the service name 00995 * \return On success, zero is returned,\n 00996 * return SOC_ERROR if socket was not opened successfully, or if an error occurred.\n 00997 */ 00998 int32_t mdns_advertiser(uint16_t mdns_enabled, uint8_t * device_service_name, uint16_t device_service_name_length); 00999 /** 01000 * \brief 01001 * \param[in] s_addr in host format ( little endian ) 01002 * \param[in] *buf buffer to write too 01003 * \param[in] buflen length of supplied buffer 01004 * \return pointer to buf \n 01005 */ 01006 char * inet_ntoa_r (uint32_t s_addr, char *buf, int buflen); 01007 #ifndef CC3000_TINY_DRIVER 01008 /** 01009 * \brief Get host IP by name.\n 01010 * Obtain the IP Address of machine on network\n 01011 * 01012 * \param[in] hostname host name 01013 * \param[in] name_length name length 01014 * \param[out] out_ip_addr This parameter is filled in with host IP address.\n 01015 * In case that host name is not resolved, \n 01016 * out_ip_addr is zero.\n 01017 * \return On success, positive is returned.\n 01018 * On error, negative is returned by its name.\n 01019 * \note On this version, only blocking mode is supported. Also note that\n 01020 * The function requires DNS server to be configured prior to its usage.\n 01021 */ 01022 int32_t gethostbyname(uint8_t *hostname, uint16_t name_length, uint32_t *out_ip_addr); 01023 /** 01024 * \brief set socket options. 01025 * This function manipulate the options associated with a socket.\n 01026 * Options may exist at multiple protocol levels; they are always\n 01027 * present at the uppermost socket level.\n 01028 * When manipulating socket options the level at which the option \n 01029 * resides and the name of the option must be specified.\n 01030 * To manipulate options at the socket level, level is specified as\n 01031 * SOL_SOCKET. To manipulate options at any other level the protocol \n 01032 * number of the appropriate protocol controlling the option is \n 01033 * supplied. For example, to indicate that an option is to be \n 01034 * interpreted by the TCP protocol, level should be set to the \n 01035 * protocol number of TCP; \n 01036 * The parameters optval and optlen are used to access optval - \n 01037 * use for setsockopt(). For getsockopt() they identify a buffer\n 01038 * in which the value for the requested option(s) are to \n 01039 * be returned. For getsockopt(), optlen is a value-result \n 01040 * parameter, initially containing the size of the buffer \n 01041 * pointed to by option_value, and modified on return to \n 01042 * indicate the actual size of the value returned. If no option \n 01043 * value is to be supplied or returned, option_value may be NULL.\n 01044 * 01045 * \param[in] sd socket handle 01046 * \param[in] level defines the protocol level for this option 01047 * \param[in] optname defines the option name to Interrogate 01048 * \param[in] optval specifies a value for the option 01049 * \param[in] optlen specifies the length of the option value 01050 * \return On success, zero is returned.\n 01051 * On error, -1 is returned\n 01052 * 01053 * \Note On this version the following two socket options are enabled:\n 01054 * The only protocol level supported in this version is SOL_SOCKET (level).\n 01055 * 1. SOCKOPT_RECV_TIMEOUT (optname)\n 01056 * SOCKOPT_RECV_TIMEOUT configures recv and recvfrom timeout in milliseconds.\n 01057 * In that case optval should be pointer to unsigned long.\n 01058 * 2. SOCKOPT_NONBLOCK (optname). sets the socket non-blocking mode on or off.\n 01059 * In that case optval should be SOCK_ON or SOCK_OFF (optval).\n 01060 * \sa getsockopt 01061 */ 01062 int32_t setsockopt(int32_t sd, int32_t level, int32_t optname, const void *optval, socklen_t optlen); 01063 #endif 01064 private: 01065 cc3000_simple_link &_simple_link; 01066 cc3000_hci &_hci; 01067 cc3000_event &_event; 01068 }; 01069 01070 /** SPI communication layer 01071 */ 01072 class cc3000_spi { 01073 public: 01074 /** 01075 * \brief Ctor 01076 * \param irq IRQ pin 01077 * \param cc3000_en Enable pin 01078 * \param cc3000_cs Chip select pin 01079 * \param cc3000_spi SPI object 01080 * \param irq_port Port for IRQ pin (needed for enable/disable interrupts) 01081 * \param event Reference to the event object. 01082 * \param simple_link Reference to the simple link object. 01083 * \return none 01084 */ 01085 cc3000_spi(PinName cc3000_irq, PinName cc3000_en, PinName cc3000_cs, SPI cc3000_spi, Mutex & mutex, cc3000_event &event, cc3000_simple_link &simple_link); 01086 /** 01087 * \brief Dtor 01088 * \param none 01089 * \return none 01090 */ 01091 ~cc3000_spi(); 01092 /** 01093 * \brief Close SPI - disables IRQ and set received buffer to 0 01094 * \param none 01095 * \return none 01096 */ 01097 void close(); 01098 /** 01099 * \brief Open the SPI interface 01100 * \param none 01101 * \return none 01102 */ 01103 void open(); 01104 /** 01105 * \brief First SPI write after powerup (delay needed between SPI header and body) 01106 * \param buffer pointer to write buffer 01107 * \param length buffer length 01108 * \return 0 01109 */ 01110 uint32_t first_write(uint8_t *buffer, uint16_t length); 01111 /** 01112 * \brief SPI Write function 01113 * \param buffer pointer to write buffer 01114 * \param length buffer length 01115 * \return 0 01116 */ 01117 uint32_t write(uint8_t *buffer, uint16_t length); 01118 /** 01119 * \brief Low level SPI write 01120 * \param data pointer to data buffer 01121 * \param size number of bytes 01122 * \return none 01123 */ 01124 void write_synchronous(uint8_t *data, uint16_t size); 01125 /** 01126 * \brief Low level SPI read 01127 * \param data pointer to data buffer 01128 * \param size number of bytes 01129 * \return none 01130 */ 01131 void read_synchronous(uint8_t *data, uint16_t size); 01132 /** 01133 * \brief Process the received SPI Header and in accordance with it - continue reading the packet 01134 * \param None 01135 * \return 0 01136 */ 01137 uint32_t read_data_cont(); 01138 /** 01139 * \brief Enable WLAN interrutp 01140 * \param None 01141 * \return None 01142 */ 01143 void wlan_irq_enable(); 01144 /** 01145 * \brief Disable WLAN interrutp 01146 * \param None 01147 * \return None 01148 */ 01149 void wlan_irq_disable(); 01150 /** 01151 * \brief Get WLAN interrupt status 01152 * \param None 01153 * \return 0 : No interrupt occured 01154 * 1 : Interrupt occured 01155 */ 01156 uint32_t wlan_irq_read(); 01157 /** 01158 * \brief SPI interrupt Handler. 01159 * The external WLAN device asserts the IRQ line when data is ready.\n 01160 * The host CPU needs to acknowledges the IRQ by asserting CS.\n 01161 * 01162 * \param none 01163 * \return none 01164 */ 01165 void WLAN_IRQHandler(); 01166 /** 01167 * \brief Enable/Disable the WLAN module 01168 * \param value 1 : Enable 01169 * 0 : Disable 01170 * \return None 01171 */ 01172 void set_wlan_en(uint8_t value); 01173 private: 01174 tSpiInfo _spi_info; 01175 InterruptIn _wlan_irq; 01176 DigitalOut _wlan_en; 01177 DigitalOut _wlan_cs; 01178 SPI _wlan_spi; 01179 Mutex & _mutex; 01180 cc3000_event &_event; 01181 cc3000_simple_link &_simple_link; 01182 bool _process_irq; 01183 }; 01184 01185 /** HCI layer 01186 */ 01187 class cc3000_hci { 01188 public: 01189 /** 01190 * \brief Ctor 01191 * \param spi Reference to the spi object. 01192 * \return none 01193 */ 01194 cc3000_hci(cc3000_spi &spi); 01195 /** 01196 * \brief Dtor 01197 * \param none 01198 * \return none 01199 */ 01200 ~cc3000_hci(); 01201 /** 01202 * \brief Initiate an HCI command. 01203 * \param op_code command operation code 01204 * \param buffer pointer to the command's arguments buffer 01205 * \param length length of the arguments 01206 * \return 0 01207 */ 01208 uint16_t command_send(uint16_t op_code, uint8_t *buffer, uint8_t length); 01209 /** 01210 * \brief Initiate an HCI data write operation 01211 * \param op_code command operation code 01212 * \param args pointer to the command's arguments buffer 01213 * \param arg_length length of the arguments 01214 * \param data_length length od data 01215 * \param tail pointer to the data buffer 01216 * \param tail_length buffer length 01217 * \return ESUCCESS 01218 */ 01219 uint32_t data_send(uint8_t op_code, uint8_t *args, uint16_t arg_length, 01220 uint16_t data_length, const uint8_t *tail, uint16_t tail_length); 01221 /** 01222 * \brief Prepare HCI header and initiate an HCI data write operation. 01223 * \param op_code command operation code 01224 * \param buffer pointer to the data buffer 01225 * \param arg_length arguments length 01226 * \param data_length data length 01227 * \return none 01228 */ 01229 void data_command_send(uint16_t op_code, uint8_t *buffer, uint8_t arg_length, 01230 uint16_t data_length); 01231 /** 01232 * \brief Prepare HCI header and initiate an HCI patch write operation. 01233 * \param op_code command operation code 01234 * \param buffer pointer to the command's arguments buffer 01235 * \param patch pointer to patch content buffer 01236 * \param data_length data length 01237 * \return none 01238 */ 01239 void patch_send(uint8_t op_code, uint8_t *buffer, uint8_t *patch, uint16_t data_length); 01240 private: 01241 cc3000_spi &_spi; 01242 }; 01243 01244 /** NVMEM layer 01245 */ 01246 class cc3000_nvmem { 01247 public: 01248 /** 01249 * \brief Ctor 01250 * \param hci Reference to the hci object. 01251 * \param event Reference to the event object. 01252 * \param simple_link Reference to the simple link object. 01253 * \return none 01254 */ 01255 cc3000_nvmem(cc3000_hci &hci, cc3000_event &event, cc3000_simple_link &simple_link); 01256 /** 01257 * \brief Dtor 01258 * \param none 01259 * \return none 01260 */ 01261 ~cc3000_nvmem(); 01262 /** 01263 * \brief Reads data from the file referred by the file_id parameter. 01264 * Reads data from file offset till length. Err if the file can't be used, 01265 * is invalid, or if the read is out of bounds. 01266 * \param file_id nvmem file id. 01267 * \param length number of bytes to read. 01268 * \param offset offset in file from where to read. 01269 * \param buff output buffer pointer. 01270 * \return 01271 * Number of bytes read, otherwise error. 01272 */ 01273 int32_t read(uint32_t file_id, uint32_t length, uint32_t offset, uint8_t *buff); 01274 /** 01275 * \brief Write data to nvmem. 01276 * \param file_id Nvmem file id 01277 * \param length number of bytes to write 01278 * \param entry_offset offset in file to start write operation from 01279 * \param buff data to write 01280 * \return 01281 * On success 0, error otherwise. 01282 */ 01283 int32_t write(uint32_t file_id, uint32_t length, uint32_t entry_offset, uint8_t *buff); 01284 /** 01285 * \brief Write MAC address to EEPROM. 01286 * \param mac Mac address to be set 01287 * \return 01288 * On success 0, error otherwise. 01289 */ 01290 uint8_t set_mac_address(uint8_t *mac); 01291 /** 01292 * \brief Read MAC address from EEPROM. 01293 * \param mac Mac address 01294 * \return 01295 * On success 0, error otherwise. 01296 */ 01297 uint8_t get_mac_address(uint8_t *mac); 01298 /** 01299 * \brief Program a patch to a specific file ID. The SP data is assumed to be organized in 2-dimensional. 01300 * Each line is SP_PORTION_SIZE bytes long. 01301 * \param file_id nvmem file id/ 01302 * \param length number of bytes to write 01303 * \param data SP data to write 01304 * \return 01305 * On success 0, error otherwise. 01306 */ 01307 uint8_t write_patch(uint32_t file_id, uint32_t length, const uint8_t *data); 01308 /** 01309 * \brief Create new file entry and allocate space on the NVMEM. Applies only to user files. 01310 * \param file_id nvmem file Id 01311 * \param new_len entry ulLength 01312 * \return 01313 */ 01314 int32_t create_entry(uint32_t file_id, uint32_t new_len); 01315 #ifndef CC3000_TINY_DRIVER 01316 /** 01317 * \brief Read patch version. read package version (WiFi FW patch, river-supplicant-NS patch, 01318 * bootloader patch) 01319 * \param patch_ver First number indicates package ID and the second number indicates 01320 * package build number 01321 * \return 01322 * On success 0, error otherwise. 01323 */ 01324 uint8_t read_sp_version(uint8_t* patch_ver); 01325 #endif 01326 private: 01327 cc3000_hci &_hci; 01328 cc3000_event &_event; 01329 cc3000_simple_link &_simple_link; 01330 }; 01331 01332 /** WLAN layer 01333 */ 01334 class cc3000_wlan { 01335 public: 01336 /** 01337 * \brief Ctor 01338 * \param simple_link Reference to the simple link object. 01339 * \param event Reference to the event object. 01340 * \param spi Reference to the spi object. 01341 * \param hci Reference to the hci object. 01342 * \return none 01343 */ 01344 cc3000_wlan(cc3000_simple_link &simple_link, cc3000_event &event, cc3000_spi &spi, cc3000_hci &hci); 01345 /** 01346 * \brief Dtor 01347 * \param none 01348 * \return none 01349 */ 01350 ~cc3000_wlan(); 01351 /** 01352 * \brief Send SIMPLE LINK START to cc3000. 01353 * \param patches_available_host Flag to indicate if patches are available. 01354 * \return none 01355 */ 01356 void simpleLink_init_start(uint16_t patches_available_host); 01357 /** 01358 * \brief Start wlan device. Blocking call until init is completed. 01359 * \param patches_available_host Flag to indicate if patches are available. 01360 * \return none 01361 */ 01362 void start(uint16_t patches_available_host); 01363 /** 01364 * \brief Stop wlan device 01365 * \param none 01366 * \return none 01367 */ 01368 void stop(void); 01369 #ifndef CC3000_TINY_DRIVER 01370 /** 01371 * \brief Connect to AP. 01372 * \param sec_type Security option. 01373 * \param ssid up to 32 bytes, ASCII SSID 01374 * \param ssid_length length of SSID 01375 * \param b_ssid 6 bytes specified the AP bssid 01376 * \param key up to 16 bytes specified the AP security key 01377 * \param key_len key length 01378 * \return 01379 * On success, zero is returned. On error, negative is returned. 01380 */ 01381 int32_t connect(uint32_t sec_type, const uint8_t *ssid, int32_t ssid_length, uint8_t *b_ssid, uint8_t *key, int32_t key_len); 01382 /** 01383 * \brief Add profile. Up to 7 profiles are supported. 01384 * \param sec_type Security option. 01385 * \param ssid Up to 32 bytes, ASCII SSID 01386 * \param ssid_length Length of SSID 01387 * \param b_ssid 6 bytes specified the AP bssid 01388 * \param priority Up to 16 bytes specified the AP security key 01389 * \param pairwise_cipher_or_tx_key_len Key length 01390 * \param group_cipher_tx_key_index Key length for WEP security 01391 * \param key_mgmt KEY management 01392 * \param pf_or_key Security key 01393 * \param pass_phrase_length Security key length for WPA\WPA2 01394 * \return 01395 * On success, zero is returned. On error, negative is returned. 01396 */ 01397 int32_t add_profile(uint32_t sec_type, uint8_t* ssid, uint32_t ssid_length, uint8_t *b_ssid, uint32_t priority, uint32_t pairwise_cipher_or_tx_key_len, uint32_t group_cipher_tx_key_index, 01398 uint32_t key_mgmt, uint8_t* pf_or_key, uint32_t pass_phrase_length); 01399 /** 01400 * \brief Gets entry from scan result table. The scan results are returned 01401 * one by one, and each entry represents a single AP found in the area. 01402 * \param scan_timeout Not supported yet 01403 * \param results Scan result 01404 * \return 01405 * On success, zero is returned. On error, -1 is returned 01406 */ 01407 int32_t ioctl_get_scan_results(uint32_t scan_timeout, uint8_t *results); 01408 /** 01409 * \brief Start and stop scan procedure. Set scan parameters. 01410 * \param enable Start/stop application scan 01411 * \param min_dwell_time Minimum dwell time value to be used for each channel, in ms. (Default: 20) 01412 * \param max_dwell_time Maximum dwell time value to be used for each channel, in ms. (Default: 30) 01413 * \param num_probe_requests Max probe request between dwell time. (Default:2) 01414 * \param channel_mask Bitwise, up to 13 channels (0x1fff). 01415 * \param rssi_threshold RSSI threshold. Saved: yes (Default: -80) 01416 * \param snr_threshold NSR threshold. Saved: yes (Default: 0) 01417 * \param default_tx_power probe Tx power. Saved: yes (Default: 205) 01418 * \param interval_list Pointer to array with 16 entries (16 channels) 01419 * \return 01420 * On success, zero is returned. On error, -1 is returned. 01421 */ 01422 int32_t ioctl_set_scan_params(uint32_t enable, uint32_t min_dwell_time, uint32_t max_dwell_time, uint32_t num_probe_requests, 01423 uint32_t channel_mask, int32_t rssi_threshold, uint32_t snr_threshold, uint32_t default_tx_power, uint32_t *interval_list); 01424 /** 01425 * \brief Get wlan status: disconnected, scanning, connecting or connected 01426 * \param none 01427 * \return 01428 * WLAN_STATUS_DISCONNECTED, WLAN_STATUS_SCANING, STATUS_CONNECTING or WLAN_STATUS_CONNECTED 01429 */ 01430 int32_t ioctl_statusget(void); 01431 #else 01432 /** 01433 * \brief Connect to AP 01434 * \param ssid Up to 32 bytes and is ASCII SSID of the AP 01435 * \param ssid_length Length of the SSID 01436 * \return 01437 * On success, zero is returned. On error, negative is returned. 01438 */ 01439 int32_t connect(const uint8_t *ssid, int32_t ssid_length); 01440 /** 01441 * \brief When auto start is enabled, the device connects to station from the profiles table. 01442 * If several profiles configured the device choose the highest priority profile. 01443 * \param sec_type WLAN_SEC_UNSEC,WLAN_SEC_WEP,WLAN_SEC_WPA,WLAN_SEC_WPA2 01444 * \param ssid SSID up to 32 bytes 01445 * \param ssid_length SSID length 01446 * \param b_ssid bssid 6 bytes 01447 * \param priority Profile priority. Lowest priority:0. 01448 * \param pairwise_cipher_or_tx_key_len Key length for WEP security 01449 * \param group_cipher_tx_key_index Key index 01450 * \param key_mgmt KEY management 01451 * \param pf_or_key Security key 01452 * \param pass_phrase_length Security key length for WPA\WPA2 01453 * \return 01454 * On success, zero is returned. On error, -1 is returned 01455 */ 01456 int32_t add_profile(uint32_t sec_type, uint8_t *ssid, uint32_t ssid_length, uint8_t *b_ssid, uint32_t priority, 01457 uint32_t pairwise_cipher_or_tx_key_len, uint32_t group_cipher_tx_key_index, uint32_t key_mgmt, 01458 uint8_t* pf_or_key, uint32_t pass_phrase_length); 01459 #endif 01460 #ifndef CC3000_UNENCRYPTED_SMART_CONFIG 01461 /** 01462 * \brief Process the acquired data and store it as a profile. 01463 * \param none 01464 * \return 01465 * On success, zero is returned. On error, -1 is returned. 01466 */ 01467 int32_t smart_config_process(void); 01468 #endif 01469 /** 01470 * \brief Disconnect connection from AP. 01471 * \param none 01472 * \return 01473 * 0 if disconnected done, other CC3000 already disconnected. 01474 */ 01475 int32_t disconnect(); 01476 /** 01477 * \brief When auto is enabled, the device tries to connect according the following policy: 01478 * 1) If fast connect is enabled and last connection is valid, the device will try to 01479 * connect to it without the scanning procedure (fast). The last connection will be 01480 * marked as invalid, due to adding/removing profile. 01481 * 2) If profile exists, the device will try to connect it (Up to seven profiles). 01482 * 3) If fast and profiles are not found, and open mode is enabled, the device 01483 * will try to connect to any AP. 01484 * Note that the policy settings are stored in the CC3000 NVMEM. 01485 * \param should_connect_to_open_ap Enable(1), disable(0) connect to any available AP. 01486 * \param use_fast_connect Enable(1), disable(0). if enabled, tries to 01487 * connect to the last connected AP. 01488 * \param use_profiles Enable(1), disable(0) auto connect after reset. 01489 * and periodically reconnect if needed. 01490 * \return 01491 * On success, zero is returned. On error, -1 is returned 01492 */ 01493 int32_t ioctl_set_connection_policy(uint32_t should_connect_to_open_ap, uint32_t use_fast_connect, uint32_t use_profiles); 01494 /** 01495 * \brief Delete WLAN profile 01496 * \param index Number of profile to delete 01497 * \return 01498 * On success, zero is returned. On error, -1 is returned 01499 */ 01500 int32_t ioctl_del_profile(uint32_t index); 01501 /** 01502 * \brief Mask event according to bit mask. In case that event is 01503 * masked (1), the device will not send the masked event to host. 01504 * \param mask event mask 01505 * \return 01506 * On success, zero is returned. On error, -1 is returned 01507 */ 01508 int32_t set_event_mask(uint32_t mask); 01509 /** 01510 * \brief Start to acquire device profile. The device acquire its own 01511 * profile, if profile message is found. 01512 * \param encrypted_flag Indicates whether the information is encrypted 01513 * \return 01514 * On success, zero is returned. On error, -1 is returned. 01515 */ 01516 int32_t smart_config_start(uint32_t encrypted_flag); 01517 /** 01518 * \brief Stop the acquire profile procedure. 01519 * \param none 01520 * \return 01521 * On success, zero is returned. On error, -1 is returned 01522 */ 01523 int32_t smart_config_stop(void); 01524 /** 01525 * \brief Configure station ssid prefix. 01526 * \param new_prefix 3 bytes identify the SSID prefix for the Smart Config. 01527 * \return 01528 * On success, zero is returned. On error, -1 is returned. 01529 */ 01530 int32_t smart_config_set_prefix(uint8_t *new_prefix); 01531 private: 01532 cc3000_simple_link &_simple_link; 01533 cc3000_event &_event; 01534 cc3000_spi &_spi; 01535 cc3000_hci &_hci; 01536 }; 01537 01538 /** The main object of cc3000 implementation 01539 */ 01540 class cc3000 { 01541 public: 01542 /** status structure */ 01543 typedef struct { 01544 uint8_t socket; 01545 bool dhcp; 01546 bool connected; 01547 bool smart_config_complete; 01548 bool stop_smart_config; 01549 bool dhcp_configured; 01550 bool ok_to_shut_down; 01551 bool enabled; 01552 } tStatus; 01553 /** 01554 * \brief Ctor. 01555 * \param cc3000_irq IRQ pin 01556 * \param cc3000_en Enable pin 01557 * \param cc3000_cs Chip select pin 01558 * \param cc3000_spi SPI interface 01559 */ 01560 cc3000(PinName cc3000_irq, PinName cc3000_en, PinName cc3000_cs, SPI cc3000_spi, Mutex & mutex); 01561 /** 01562 * \brief Dtor. 01563 */ 01564 ~cc3000(); 01565 /** 01566 * \brief Initiate cc3000. It starts the wlan communication. 01567 * \param patch Patch 01568 */ 01569 void start(uint8_t patch); 01570 /** 01571 * \brief Stops the wlan communication. 01572 */ 01573 void stop(); 01574 /** 01575 * \brief Restarts the wlan communication. 01576 */ 01577 void restart(uint8_t patch); 01578 /** 01579 * \brief Callback which is called from the event class. This updates status of cc3000. 01580 * \param event_type Type of the event 01581 * \param data Pointer to data 01582 * \param length Length of data 01583 * \return none 01584 */ 01585 void usync_callback(int32_t event_type, uint8_t *data, uint8_t length); 01586 /** 01587 * \brief Start connection to SSID (open/secured) non-blocking 01588 * \param ssid SSID name 01589 * \param key Security key (if key = 0, open connection) 01590 * \param security_mode Security mode 01591 * \return true if connection was established, false otherwise. 01592 */ 01593 bool connect_non_blocking(const uint8_t *ssid, const uint8_t *key, int32_t security_mode); 01594 /** 01595 * \brief Connect to SSID (open/secured) with timeout (10s). 01596 * \param ssid SSID name 01597 * \param key Security key (if key = 0, open connection) 01598 * \param security_mode Security mode 01599 * \return true if connection was established, false otherwise. 01600 */ 01601 bool connect_to_AP(const uint8_t *ssid, const uint8_t *key, int32_t security_mode); 01602 /** 01603 * \brief Connect to SSID which is secured 01604 * \param ssid SSID name 01605 * \param key Security key 01606 * \param security_mode Security mode 01607 * \return true if connection was established, false otherwise. 01608 */ 01609 bool connect_secure(const uint8_t *ssid, const uint8_t *key, int32_t security_mode); 01610 /** 01611 * \brief Connect to SSID which is open (no security) 01612 * \param ssid SSID name 01613 * \return true if connection was established, false otherwise. 01614 */ 01615 bool connect_open(const uint8_t *ssid); 01616 /** 01617 * \brief Status of the cc3000 module. 01618 * \return true if it's enabled, false otherwise. 01619 */ 01620 bool is_enabled(); 01621 /** 01622 * \brief Status of the cc3000 connection. 01623 * \return true if it's connected, false otherwise. 01624 */ 01625 bool is_connected(); 01626 /** 01627 * \brief Status of DHCP. 01628 * \param none 01629 * \return true if DCHP is configured, false otherwise. 01630 */ 01631 bool is_dhcp_configured(); 01632 /** 01633 * \brief Status of smart confing completation. 01634 * \param none 01635 * \return smart config was set, false otherwise. 01636 */ 01637 bool is_smart_confing_completed(); 01638 /** 01639 * \brief Return the cc3000's mac address. 01640 * \param address Retreived mac address. 01641 * \return 01642 */ 01643 uint8_t get_mac_address(uint8_t address[6]); 01644 /** 01645 * \brief Set the cc3000's mac address. 01646 * \param address Mac address to be set. 01647 * \return 01648 */ 01649 uint8_t set_mac_address(uint8_t address[6]); 01650 /** 01651 * \brief Get user file info. 01652 * \param info_file Pointer where info will be stored. 01653 * \param size Available size. 01654 * \return none 01655 */ 01656 void get_user_file_info(uint8_t *info_file, size_t size); 01657 /** 01658 * \brief Set user filo info. 01659 * \param info_file Pointer to user's info. 01660 * \return none 01661 */ 01662 void set_user_file_info(uint8_t *info_file, size_t size); 01663 /** 01664 * \brief Start smart config. 01665 * \param smart_config_key Pointer to smart config key. 01666 * \return none 01667 */ 01668 void start_smart_config(const uint8_t *smart_config_key); /* TODO enable AES ? */ 01669 #ifndef CC3000_TINY_DRIVER 01670 /** 01671 * \brief Return ip configuration. 01672 * \param ip_config Pointer to ipconfig data. 01673 * \return true if it's connected and info was retrieved, false otherwise. 01674 */ 01675 bool get_ip_config(tNetappIpconfigRetArgs *ip_config); 01676 #endif 01677 /** 01678 * \brief Delete all stored profiles. 01679 * \param none 01680 * \return none 01681 */ 01682 void delete_profiles(void); 01683 /** 01684 * \brief Ping an ip address. 01685 * \param ip Destination IP address 01686 * \param attempts Number of attempts 01687 * \param timeout Time to wait for a response,in milliseconds. 01688 * \param size Send buffer size which may be up to 1400 bytes 01689 */ 01690 uint32_t ping(uint32_t ip, uint8_t attempts, uint16_t timeout, uint8_t size); 01691 /** 01692 * \brief Returns cc3000 instance. Used in Socket interface. 01693 * \param none 01694 * \return Pointer to cc3000 object 01695 */ 01696 static cc3000* get_instance() { 01697 return _inst; 01698 } 01699 #if (CC3000_ETH_COMPAT == 1) 01700 /** 01701 * \brief Ctor for EthernetInterface 01702 * \param cc3000_irq IRQ pin 01703 * \param cc3000_en Enable pin 01704 * \param cc3000_cs Chip select pin 01705 * \param cc3000_spi SPI interface 01706 * \param ssid SSID 01707 * \param phrase Password 01708 * \param sec Security of the AP 01709 * \param smart_config Smart config selection 01710 */ 01711 cc3000(PinName cc3000_irq, PinName cc3000_en, PinName cc3000_cs, SPI cc3000_spi, Mutex & mutex, const char *ssid, const char *phrase, Security sec, bool smart_config); 01712 /** 01713 * \brief Disconnect wlan device. 01714 * \param none 01715 * \return 0 if successful, -1 otherwise. 01716 */ 01717 int disconnect(); 01718 /** 01719 * \brief Initialize the interface with DHCP. 01720 * \param none 01721 * \return none 01722 */ 01723 void init(); 01724 /** 01725 * \brief Initialize the interface with a static IP address. 01726 * \param ip the IP address to use. 01727 * \param mask the IP address mask 01728 * \param gateway the gateway to use 01729 * \return none 01730 */ 01731 void init(const char *ip, const char *mask, const char *gateway); 01732 /** 01733 * \brief Connect Bring the interface up. 01734 * \param timeout_ms timeout in ms 01735 * \return 0 if successful, -1 otherwise. 01736 */ 01737 int connect(unsigned int timeout_ms = 20000); 01738 /** 01739 * \brief Get the MAC address of your Ethernet interface. 01740 * \param none 01741 * \return 01742 * Pointer to a string containing the MAC address. 01743 */ 01744 char* getMACAddress(); 01745 /** 01746 * \brief Get the IP address of your Ethernet interface. 01747 * \param none 01748 * \return 01749 * Pointer to a string containing the IP address. 01750 */ 01751 char* getIPAddress(); 01752 /** 01753 * \brief Get the Gateway address of your Ethernet interface 01754 * \param none 01755 * \return 01756 * Pointer to a string containing the Gateway address 01757 */ 01758 char* getGateway(); 01759 /** 01760 * \brief Get the Network mask of your Ethernet interface 01761 * \param none 01762 * \return 01763 * Pointer to a string containing the Network mask 01764 */ 01765 char* getNetworkMask(); 01766 #endif 01767 public: 01768 cc3000_simple_link _simple_link; 01769 cc3000_event _event; 01770 cc3000_socket _socket; 01771 cc3000_spi _spi; 01772 cc3000_hci _hci; 01773 cc3000_nvmem _nvmem; 01774 cc3000_netapp _netapp; 01775 cc3000_wlan _wlan; 01776 #ifndef CC3000_UNENCRYPTED_SMART_CONFIG 01777 cc3000_security _security; 01778 #endif 01779 protected: 01780 static cc3000 *_inst; 01781 private: 01782 tStatus _status; 01783 netapp_pingreport_args_t _ping_report; 01784 bool _closed_sockets[MAX_SOCKETS]; 01785 #if (CC3000_ETH_COMPAT == 1) 01786 uint8_t _phrase[30]; 01787 uint8_t _ssid[30]; 01788 Security _sec; 01789 bool _smart_config; 01790 #endif 01791 }; 01792 01793 /** 01794 * Copy 32 bit to stream while converting to little endian format. 01795 * @param p pointer to the new stream 01796 * @param u32 pointer to the 32 bit 01797 * @return pointer to the new stream 01798 */ 01799 uint8_t *UINT32_TO_STREAM_f (uint8_t *p, uint32_t u32); 01800 01801 /** 01802 * Copy 16 bit to stream while converting to little endian format. 01803 * @param p pointer to the new stream 01804 * @param u32 pointer to the 16 bit 01805 * @return pointer to the new stream 01806 */ 01807 uint8_t *UINT16_TO_STREAM_f (uint8_t *p, uint16_t u16); 01808 01809 /** 01810 * Copy received stream to 16 bit in little endian format. 01811 * @param p pointer to the stream 01812 * @param offset offset in the stream 01813 * @return pointer to the new 16 bit 01814 */ 01815 uint16_t STREAM_TO_UINT16_f(uint8_t* p, uint16_t offset); 01816 01817 /** 01818 * Copy received stream to 32 bit in little endian format. 01819 * @param p pointer to the stream 01820 * @param offset offset in the stream 01821 * @return pointer to the new 32 bit 01822 */ 01823 uint32_t STREAM_TO_UINT32_f(uint8_t* p, uint16_t offset); 01824 01825 } /* end of mbed_cc3000 namespace */ 01826 01827 01828 #endif
Generated on Thu Jul 14 2022 05:00:35 by
1.7.2