WIZ820io.h

00001 /* Copyright (C) 2012 mbed.org, MIT License
00002  *
00003  * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
00004  * and associated documentation files (the "Software"), to deal in the Software without restriction,
00005  * including without limitation the rights to use, copy, modify, merge, publish, distribute,
00006  * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
00007  * furnished to do so, subject to the following conditions:
00008  *
00009  * The above copyright notice and this permission notice shall be included in all copies or
00010  * substantial portions of the Software.
00011  *
00012  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
00013  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00014  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
00015  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00016  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00017  *
00018  */
00019 
00020 #pragma once
00021 
00022 #include "mbed.h"
00023 #include "mbed_debug.h"
00024 
00025 #define TEST_ASSERT(A) while(!(A)){debug("\n\n%s@%d %s ASSERT!\n\n",__PRETTY_FUNCTION__,__LINE__,#A);exit(1);};
00026 
00027 #define DEFAULT_WAIT_RESP_TIMEOUT 500
00028 
00029 enum Protocol {
00030     CLOSED = 0,
00031     TCP    = 1,
00032     UDP    = 2,
00033 };
00034 
00035 enum Command {
00036     OPEN      = 0x01,
00037     LISTEN    = 0x02,
00038     CONNECT   = 0x04,
00039     DISCON    = 0x08,
00040     CLOSE     = 0x10,
00041     SEND      = 0x20,
00042     SEND_MAC  = 0x21, 
00043     SEND_KEEP = 0x22,
00044     RECV      = 0x40,
00045     
00046 };
00047 
00048 enum Interrupt {
00049     INT_CON     = 0x01,
00050     INT_DISCON  = 0x02,
00051     INT_RECV    = 0x04,
00052     INT_TIMEOUT = 0x08,
00053     INT_SEND_OK = 0x10,
00054 };
00055 
00056 enum Status {
00057     SOCK_CLOSED      = 0x00,
00058     SOCK_INIT        = 0x13,
00059     SOCK_LISTEN      = 0x14,
00060     SOCK_SYNSENT     = 0x15,
00061     SOCK_ESTABLISHED = 0x17,
00062     SOCK_CLOSE_WAIT  = 0x1c,
00063     SOCK_UDP         = 0x22,
00064 };
00065 
00066 #define MAX_SOCK_NUM 8
00067 
00068 #define MR        0x0000
00069 #define GAR       0x0001
00070 #define SUBR      0x0005
00071 #define SHAR      0x0009
00072 #define SIPR      0x000f
00073 #define PHYSTATUS 0x0035
00074 // socket
00075 #define Sn_MR         0x0000
00076 #define Sn_CR         0x0001
00077 #define Sn_IR         0x0002
00078 #define Sn_SR         0x0003
00079 #define Sn_PORT       0x0004
00080 #define Sn_DIPR       0x000c
00081 #define Sn_DPORT      0x0010
00082 #define Sn_RXBUF_SIZE 0x001e
00083 #define Sn_TXBUF_SIZE 0x001f
00084 #define Sn_TX_FSR     0x0020
00085 #define Sn_TX_WR      0x0024
00086 #define Sn_RX_RSR     0x0026
00087 #define Sn_RX_RD      0x0028
00088 
00089 class WIZ820io {
00090 public:
00091     /*
00092     * Constructor
00093     *
00094     * @param tx mbed pin to use for tx line of Serial interface
00095     * @param rx mbed pin to use for rx line of Serial interface
00096     * @param reset reset pin of the WIZ820io module
00097     */
00098     WIZ820io(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset);
00099     WIZ820io(SPI* spi, PinName cs, PinName reset);
00100 
00101     /*
00102     * Connect the WIZ820io module to the ssid contained in the constructor.
00103     *
00104     * @return true if connected, false otherwise
00105     */
00106     bool join(); // not WiFi? join???
00107     //boot setip(); // much better to use..
00108 
00109     /*
00110     * Initialize the WIZ820io module with static values.
00111     *
00112     * @return true if connected, false otherwise
00113     */
00114     bool join(uint32_t srcip, uint32_t gw, uint32_t subnetmask);
00115     
00116     /*
00117     * Disconnect the WIZ820io module from the access point
00118     *
00119     * @ returns true if successful
00120     */
00121     bool disconnect();
00122 
00123     /*
00124     * Open a tcp connection with the specified host on the specified port
00125     *
00126     * @param host host (can be either an ip address or a name. If a name is provided, a dns request will be established)
00127     * @param port port
00128     * @ returns true if successful
00129     */
00130     bool connect(int socket, const char * host, int port, int timeout_ms = 10*1000);
00131 
00132     /*
00133     * Set the protocol (UDP or TCP)
00134     *
00135     * @param p protocol
00136     * @ returns true if successful
00137     */
00138     bool setProtocol(int socket, Protocol p);
00139 
00140     /*
00141     * Reset the WIZ820io module
00142     */
00143     void reset();
00144     
00145    
00146     int wait_readable(int socket, int wait_time_ms, int req_size = 0);
00147 
00148     int wait_writeable(int socket, int wait_time_ms, int req_size = 0);
00149 
00150     /*
00151     * Check if a tcp link is active
00152     *
00153     * @returns true if successful
00154     */
00155     bool is_connected(int socket);
00156 
00157     /*
00158     * Close a tcp connection
00159     *
00160     * @ returns true if successful
00161     */
00162     bool close(int socket);
00163 
00164     /*
00165     * @param str string to be sent
00166     * @param len string length
00167     */
00168     int send(int socket, const char * str, int len);
00169 
00170     int recv(int socket, char* buf, int len);
00171 
00172     /*
00173     * Return true if the module is using dhcp
00174     *
00175     * @returns true if the module is using dhcp
00176     */
00177     bool isDHCP() {
00178         return dhcp;
00179     }
00180 
00181     bool gethostbyname(const char* host, uint32_t* ip);
00182 
00183     static WIZ820io * getInstance() {
00184         return inst;
00185     };
00186 
00187     int new_socket();
00188     uint16_t new_port();
00189     void scmd(int socket, Command cmd);
00190 
00191     template<typename T>
00192     void sreg(int socket, uint16_t addr, T data) {
00193         reg_wr<T>(addr, (0x0C + (socket << 5)), data);
00194     }
00195 
00196     template<typename T>
00197     T sreg(int socket, uint16_t addr) {
00198         return reg_rd<T>(addr, (0x08 + (socket << 5)));
00199     }
00200 
00201     template<typename T>
00202     void reg_wr(uint16_t addr, T data) {
00203         return reg_wr(addr, 0x04, data);
00204     }
00205     
00206     template<typename T>
00207     void reg_wr(uint16_t addr, uint8_t cb, T data) {
00208         uint8_t buf[sizeof(T)];
00209         *reinterpret_cast<T*>(buf) = data;
00210         for(int i = 0; i < sizeof(buf)/2; i++) { //  Little Endian to Big Endian
00211             uint8_t t = buf[i];
00212             buf[i] = buf[sizeof(buf)-1-i];
00213             buf[sizeof(buf)-1-i] = t;
00214         }
00215         spi_write(addr, cb, buf, sizeof(buf));
00216     }
00217 
00218     template<typename T>
00219     T reg_rd(uint16_t addr) {
00220         return reg_rd<T>(addr, 0x00);
00221     }
00222 
00223     template<typename T>
00224     T reg_rd(uint16_t addr, uint8_t cb) {
00225         uint8_t buf[sizeof(T)];
00226         spi_read(addr, cb, buf, sizeof(buf));
00227         for(int i = 0; i < sizeof(buf)/2; i++) { // Big Endian to Little Endian
00228             uint8_t t = buf[i];
00229             buf[i] = buf[sizeof(buf)-1-i];
00230             buf[sizeof(buf)-1-i] = t;
00231         }
00232         return *reinterpret_cast<T*>(buf);
00233     }
00234 
00235     void reg_rd_mac(uint16_t addr, uint8_t* data) {
00236         spi_read(addr, 0x00, data, 6);
00237     }
00238 
00239     void reg_wr_ip(uint16_t addr, uint8_t cb, const char* ip) {
00240         uint8_t buf[4];
00241         char* p = (char*)ip;
00242         for(int i = 0; i < 4; i++) {
00243             buf[i] = atoi(p);
00244             p = strchr(p, '.');
00245             if (p == NULL) {
00246                 break;
00247             }
00248             p++;
00249         }
00250         spi_write(addr, cb, buf, sizeof(buf));
00251     }
00252 
00253     void sreg_ip(int socket, uint16_t addr, const char* ip) {
00254         reg_wr_ip(addr, (0x0C + (socket << 5)), ip);
00255     }
00256 
00257 protected:
00258     uint32_t ip;
00259     uint32_t netmask;
00260     uint32_t gateway;
00261     uint32_t dnsaddr;
00262     bool dhcp;
00263 
00264     static WIZ820io* inst;
00265 
00266     void reg_wr_mac(uint16_t addr, uint8_t* data) {
00267         spi_write(addr, 0x04, data, 6);
00268     }
00269 
00270     void spi_write(uint16_t addr, uint8_t cb, const uint8_t *buf, uint16_t len);
00271     void spi_read(uint16_t addr, uint8_t cb, uint8_t *buf, uint16_t len);
00272     SPI* spi;
00273     DigitalOut cs;
00274     DigitalOut reset_pin;
00275 };
00276 
00277 // WIZ820io.cpp
00278 extern uint32_t str_to_ip(const char* str);
00279 extern void printfBytes(char* str, uint8_t* buf, int len);
00280 extern void printHex(uint8_t* buf, int len);
00281 extern void debug_hex(uint8_t* buf, int len);