ME910 support
Fork of MTS-Cellular by
Cellular/EasyIP.h
- Committer:
- Vanger
- Date:
- 2014-08-04
- Revision:
- 49:1fc51c53cebf
- Parent:
- 45:b9ead235ab7c
- Child:
- 52:2cb58398a4f9
File content as of revision 49:1fc51c53cebf:
#ifndef SMC_H #define SMC_H #include <string> #include <vector> #include "MTSBufferedIO.h" #include "Cellular.h" namespace mts { /** This class implements the same interface used for UIP version radios on an Easy IP radio * using the Hayes AT command set. * (See the UIP class and documentation, "UIP.h") * This class supports four main types of cellular radio interactions including: * configuration and status AT-command processing, SMS processing, TCP Socket data connections, * and UDP data connections. It should be noted that the radio can not process commands or * SMS messages while having an open data connection at the same time. The concurrent * capability may be added in a future release. This class also inherits from IPStack * providing a common set of commands for communication devices that have an onboard * IP Stack. It is also integrated with the standard mbed Sockets package and can therefore * be used seamlessly with clients and services built on top of this interface already within * the mbed library. * The default baud rate for the cellular radio is 115200 bps. * * @code * #include "mbed.h" * #include "mtsas.h" * #include "TCPSocketConnection.h" * * int main(){ * //Modify to match your apn if you are using an HSPA radio with a SIM card * const char APN[] = ""; * * //Sets the log level to INFO, which is about midway on priority levels * //Possible levels: FATAL, ERROR, WARNING, INFO, DEBUG, TRACE, NONE * MTSLog::setLogLevel(MTSLog::TRACE_LEVEL); * * // STMicro Nucelo F401RE * // The supported jumper configurations of the MTSAS do not line up with * // the pin mapping of the Nucleo F401RE. Therefore, the MTSAS serial TX * // pin (JP8 Pin 2) must be manually jumped to Serial1 RX (Shield pin D2) * // and the MTSAS serial RX pin (JP9 Pin 2) pin must be manually jumped to * // Serial1 TX (Shield pin D8). * // Uncomment the following line to use the STMicro Nuceleo F401RE * MTSSerialFlowControl* io = new MTSSerialFlowControl(D8, D2, D3, D6); * * // Freescale KL46Z * // To configure the pins for the Freescale KL46Z board, use configuration B * // for the SocketModem. * // Uncomment the following line to use the Freescale KL46Z board * // MTSSerialFlowControl* io = new MTSSerialFlowControl(D2, D9, D3, D6); * * // Freescale KL64F * // To configure the pins for the Freescale KL46Z board, use configuration A * // for the SocketModem. * // Uncomment te following line to use the Freescale KL46F board * // MTSSerialFlowControl* io = new MTSSerialFlowControl(D1, D0, D3, D6); * * // Sets the baudrate for communicating with the radio * io->baud(115200); * * // Sets up the interfacing with the radio through the MTS library * Cellular* radio = CellularFactory::create(io); * radio->configureSignals(D4, D7, RESET); * Transport::setTransport(radio); * * // Sets the APN on the device (if necessary) * for (int i = 0; i < 10; i++) { * if (i >= 10) { * logError("Failed to set APN to %s", APN); * } * if (radio->setApn(APN) == MTS_SUCCESS) { * logInfo("Successfully set APN to %s", APN); * break; * } else { * wait(1); * } * } * * //Establish PPP link * for (int i = 0; i < 10; i++) { * if (i >= 10) { * logError("Failed to establish PPP link"); * } * if (radio->connect() == true) { * logInfo("Successfully established PPP link"); * break; * } else { * wait(1); * } * } * * //Ping google.com (optional) * for (int i = 0; i < 10; i++) { * if (i >= 10) { * logError("Failed to ping www.google.com"); * } * if (radio->ping("www.google.com") == true) { * logInfo("Successfully pinged www.google.com"); * break; * } else { * wait(1); * } * } * * //Used for packet verification from server's data response * const char PATTERN_LINE1[] = "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}|"; * const char PATTERN[] = "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}|\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}/\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}-\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}\\\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}|\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}/\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}-\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}\\\r\n" * "abcdefghijklmnopqrstuvwzyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()[]{}*\r\n"; * * const char MENU_LINE1[] = "send ascii pattern until keypress"; * const char MENU[] = "1 send ascii pattern until keypress" * "2 send ascii pattern (numbered)" * "3 send pattern and close socket" * "4 send [ETX] and wait for keypress" * "5 send [DLE] and wait for keypress" * "6 send all hex values (00-FF)" * "q quit" * ">:"; * * const char TCP_TEST_SERVER[] = "204.26.122.5"; * const int TCP_TEST_PORT = 7000; * * //Creates TCP socket pointer instance * TCPSocketConnection* sock = new TCPSocketConnection(); * //Turns off read_blocking and sets socket timeout to 2s * sock->set_blocking(false, 2); * * Timer tmr; //Used for timeouts * int bytesRead = 0; //Number of bytes read * const int readSize = 1024; //Size of buffer * char buffer[readSize] = {0}; //Read buffer * string result; //Result as a string * * //Open TCP socket * for (int i = 0; i < 5; i++) { * if (i >= 5) { * logError("Failed to open socket"); * } * if (! sock->connect(TCP_TEST_SERVER, TCP_TEST_PORT)) { * logInfo("Opened TCP server"); * break; * } else { * wait(1); * } * } * * //Waiting for menu from remote server * logInfo("Receiving Menu"); * tmr.reset(); * tmr.start(); * do { * bytesRead = sock->receive(buffer, readSize); * if (bytesRead > 0) { * result.append(buffer, bytesRead); * } * logInfo("Total Bytes Read: %d", result.size()); * if(result.find(MENU_LINE1) != std::string::npos) { * break; * } * } while(tmr.read() <= 40); * * wait(5); * * logInfo("Received: [%d] [%s]", result.size(), result.c_str()); * * //Checking that menu was successfully received * size_t pos = result.find(MENU_LINE1); * if(pos != string::npos) { * logInfo("Found Menu 1st Line"); * } else { * logError("Failed To Find Menu 1st Line"); * sock->close(); * return 0; * } * * result.clear(); * * //Sends a response of '2' back to choose option 2 from the menu * logInfo("Writing To Socket: 2"); * if(sock->send("2\r\n", 3) == 3) { * logInfo("Successfully Wrote '2'"); * } else { * logError("Failed To Write '2'"); * sock->close(); * return 0; * } * logInfo("Expecting 'how many ? >:'"); * tmr.reset(); * tmr.start(); * do { * bytesRead = sock->receive(buffer, readSize); * if (bytesRead > 0) { * result.append(buffer, bytesRead); * } * logInfo("Total Bytes Read: %d", result.size()); * if(result.find("how many") != std::string::npos) { * break; * } * } while(tmr.read() <= 40); * * logInfo("Received: [%d] [%s]", result.size(), result.c_str()); * * //Sends 2 to have the server send the pattern twice * if(result.find("how many") != std::string::npos) { * logInfo("Successfully Found 'how many'"); * logInfo("Writing To Socket: 2"); * if(sock->send("2\r\n", 3) == 3) { * logInfo("Successfully wrote '2'"); * } else { * logError("Failed to write '2'"); * sock->close(); * return 0; * } * } else { * logError("didn't receive 'how many'"); * sock->close(); * return 0; * } * * result.clear(); * * //Receives data from request sent to server * logInfo("Receiving Data"); * tmr.reset(); * tmr.start(); * do { * bytesRead = sock->receive(buffer, readSize); * if (bytesRead > 0) { * result.append(buffer, bytesRead); * } * logInfo("Total Bytes Read: %d", result.size()); * if(result.size() >= 1645) { * break; * } * } while(tmr.read() <= 40); * * logInfo("Received Data: [%d] [%s]", result.size(), result.c_str()); * * //Compares received data with expected data * pos = result.find(PATTERN_LINE1); * if(pos != string::npos) { * int patternSize = sizeof(PATTERN) - 1; * const char* ptr = &result.data()[pos]; * bool match = true; * for(int i = 0; i < patternSize; i++) { * if(PATTERN[i] != ptr[i]) { * logError("1st Pattern Doesn't Match At [%d]", i); * logError("Pattern [%02X] Buffer [%02X]", PATTERN[i], ptr[i]); * match = false; * break; * } * } * if(match) { * logInfo("Found 1st Pattern"); * } else { * logError("Failed To Find 1st Pattern"); * sock->close(); * return 0; * } * * pos = result.find(PATTERN_LINE1, pos + patternSize); * if(pos != std::string::npos) { * ptr = &result.data()[pos]; * match = true; * for(int i = 0; i < patternSize; i++) { * if(PATTERN[i] != ptr[i]) { * logError("2nd Pattern Doesn't Match At [%d]", i); * logError("Pattern [%02X] Buffer [%02X]", PATTERN[i], ptr[i]); * match = false; * break; * } * } * if(match) { * logInfo("Found 2nd Pattern"); * } else { * logError("Failed To Find 2nd Pattern"); * sock->close(); * return 0; * } * } * } else { * logError("Failed To Find Pattern 1st Line"); * sock->close(); * return 0; * } * * //Clears the result, and closes the socket connection. * result.clear(); * sock->close(); * * //Disconnect ppp link * radio->disconnect(); * * logInfo("End of example code"); * return 0; * } * @endcode */ class EasyIP : public Cellular { public: /** This static function is used to create or get a reference to a * Cellular object. Cellular uses the singleton pattern, which means * that you can only have one existing at a time. The first time you * call getInstance this method creates a new uninitialized Cellular * object and returns it. All future calls to this method will return * a reference to the instance created during the first call. Note that * you must call init on the returned instance before mnaking any other * calls. If using this class's bindings to any of the Socket package * classes like TCPSocketConnection, you must call this method and the * init method on the returned object first, before even creating the * other objects. * * @returns a reference to the single Cellular obect that has been created. */ EasyIP(Radio type); /** Destructs a Cellular object and frees all related resources. */ ~EasyIP(); /** Initializes the MTS IO buffer */ virtual bool init(MTSBufferedIO* io); /** PPP connect command. * Connects the radio to the cellular network. * * @returns true if PPP connection to the network succeeded, * false if the PPP connection failed. */ virtual bool connect(); /** PPP disconnect command. * Disconnects from the PPP network, and will also close active socket * connection if open. */ virtual void disconnect(); /** Checks if the radio is connected to the cell network. * Checks antenna signal, cell tower registration, and context activation * before finally pinging (4 pings, 32 bytes each) to confirm PPP connection * to network. Will return true if there is an open socket connection as well. * * @returns true if there is a PPP connection to the cell network, false * if there is no PPP connection to the cell network. */ virtual bool isConnected(); /** Resets the radio/modem. * Disconnects all active PPP and socket connections to do so. */ virtual void reset(); // TCP and UDP Socket related commands // For behavior of the following methods refer to IPStack.h documentation virtual bool bind(unsigned int port); virtual bool open(const std::string& address, unsigned int port, Mode mode); virtual bool isOpen(); virtual bool close(); virtual int read(char* data, int max, int timeout = -1); virtual int write(const char* data, int length, int timeout = -1); virtual unsigned int readable(); virtual unsigned int writeable(); virtual bool ping(const std::string& address = "8.8.8.8"); //Google DNS server used as default ping address virtual std::string getDeviceIP(); virtual bool setDeviceIP(std::string address = "DHCP"); /** Sets the APN * * @param apn c-string of the APN to use * * @returns MTS_SUCCESS if the APN was set, or is not needed, else it * returns the result of the AT command sent to the radio to set the APN */ virtual Code setApn(const std::string& apn); /** A method for configuring command ehco capability on the radio. This command * sets whether sent characters are echoed back from the radio, in which case you * will receive back every command you send. * * @param state if true echo will be turned off, otherwise it will be turned on. * @returns the standard AT Code enumeration. */ virtual Code echo(bool state); /** This method can be used to trade socket functionality for performance. * Can disable checking socket closed messages from the data socket, and thus the socket * will only be visibly closed to the local side if the radio is explicitly checked, or * the socket is closed by the local side through the use of physical pin manipulation. * * Uses the Hayes escape sequence (1 second pause, "+++", 1 second pause) to exit the socket * connection to check if a received "NO CARRIER" string is from the radio indicating the socket * has been closed, or is merely part of the data stream. Should not occur very often, however, if * data carrying the string "NO CARRIER" is going to be transmitted frequently, then the socket should * be set closeable and physical-socket-closing-means be used instead to reduce the large amount of * overhead switching from checking the validity of the "NO CARRIER" message being and indication of * the socket connection being closed. * * @param enabled set to true if you want the socket closeable, otherwise false. The default * is true. * @returns the standard AT Code enumeration. */ virtual Code setSocketCloseable(bool enabled = true); private: /** Function that sends +++ to the radio to exit data mode * returns true if it successfully exits from online mode, else * it returns false. Used due to the fact that AT commands * cannot be sent while in data mode. * * @returns true if the radio dropped from data mode to commande mode * or is already in command mode (socket is still open in the background), * and false if the radio failed to switch to command mode. */ virtual bool sendEscapeCommand(); /** Switches to command mode, queries the status of the socket connection, * and then returns back to the active socket connection (if still open) * * @returns true if a socket is currently open, otherwise it returns false */ virtual bool socketCheck(); }; } #endif /* SMC_H */