Simple detection for LE910-NA1 modules
Fork of MTS-Cellular by
Cellular/SMCIP.h
- Committer:
- Mike Fiore
- Date:
- 2014-05-19
- Revision:
- 1:f155d94d6f3a
- Parent:
- 0:830c436480e3
File content as of revision 1:f155d94d6f3a:
#ifndef SMCIP_H #define SMCIP_H #include <string> #include <vector> #include "mbed.h" #include "MTSBufferedIO.h" #include "Cellular.h" namespace mts { /** This is a class for communicating with a Multi-Tech Systems SocketModem iCell. The * SocketModem iCell is a family of carrier certified embedded cellular radio modules with * a common hardware footprint and AT command set for built in IP-stack functionality. * This class supports three main types of cellular radio interactions including: * configuration and status AT command processing, SMS processing, and TCP Socket * 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. * * All of the following examples use the Pin Names for the Freedom KL46Z board coupled with * the SocketModem Shield Arduino compatible board. Please chage Pin Names accordingly to * match your hardware configuration. It also assumes the use of RTS/CTS hardware handshaking * using GPIOs. To disable this you will need to change settings on the radio module and * and use the MTSSerial class instead of MTSSerialFlowControl. The default baud rate for the * cellular radio is 115200 bps. */ class SMCIP : 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. */ SMCIP(); /** Destructs a Cellular object and frees all related resources. */ ~SMCIP(); virtual bool init(MTSBufferedIO* io); /** * */ bool configureSignals(PinName DCD = NC, PinName DTR = NC, PinName RESET = NC); // Wifi connection based commands derived from CommInterface.h virtual bool connect(); virtual void disconnect(); virtual bool isConnected(); 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"); virtual std::string getDeviceIP(); virtual bool setDeviceIP(std::string address = "DHCP"); //Cellular functions that derive from Cellular.h virtual std::string sendCommand(const std::string& command, unsigned int timeoutMillis, char esc = CR); virtual Code sendBasicCommand(const std::string& command, unsigned int timeoutMillis, char esc = CR); virtual Code setApn(const std::string& apn); virtual Code setDns(const std::string& primary, const std::string& secondary = "0.0.0.0"); /** 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. */ Code echo(bool state); /** This method can be used to trade socket functionality for performance. * In order to enable a socket connection to be closed by the client side programtically, * this class must process all read and write data on the socket to guard the special * escape character used to close an open socket connection. It is recommened that you * use the default of true unless the overhead of these operations is too significant. * * @param enabled set to true if you want the socket closeable, otherwise false. The default * is true. * @returns the standard AT Code enumeration. */ Code setSocketCloseable(bool enabled = true); //ETX closes socket (ETX and DLE in payload are escaped with DLE) private: MTSBufferedIO* io; //IO interface obect that the radio is accessed through. bool echoMode; //Specifies if the echo mode is currently enabled. bool pppConnected; //Specifies if a PPP session is currently connected. std::string apn; //A string that holds the APN for the radio. Mode mode; //The current socket Mode. bool socketOpened; //Specifies if a Socket is presently opened. bool socketCloseable; //Specifies is a Socket can be closed. unsigned int local_port; //Holds the local port for socket connections. std::string local_address; //Holds the local address for socket connections. unsigned int host_port; //Holds the remote port for socket connections. std::string host_address; //Holds the remote address for socket connections. DigitalIn* dcd; //Maps to the radio's dcd signal DigitalOut* dtr; //Maps to the radio's dtr signal DigitalOut* resetLine; //Maps to the radio's reset signal }; } #endif