File content as of revision 118:8df0e9c2ee3f:

#ifndef __ATCMD_MANAGER_H__
#define __ATCMD_MANAGER_H__
#include <events/mbed_events.h>
#include <mbed.h>
#include <vector>
#include "ATCmdParser.h"
#include "BleManager.h"
#include "WiFiManager.h"
#include "common_config.h"

#define NUM_UART_OPTIONS       6
#ifndef UBLOX_ODIN_W2_MISC_TIMEOUT
#define UBLOX_ODIN_W2_MISC_TIMEOUT    2000
#endif

#define OK_RESP    "\r\nOK\r\n"
#define ERROR_RESP "\r\nERROR\r\n"
#define WIFI_BUSY_RESP "\r\nWIFI BUSY\r\n"
#define BOX_UBLOX_DEMO_TESTING
//extern void print_memory_info();
//extern void blinkLEDs();
class ATCmdManager {
public:
    ATCmdManager(PinName tx, PinName rx, uart_config_t *uart_config, 
                 events::EventQueue &event_queue, WiFiManager *wifi, 
                 MemoryPool<wifi_cmd_message_t, 16> *aT2WiFimPool, 
                 Queue<wifi_cmd_message_t, 16> *aT2WiFiCmdQueue, 
                 MemoryPool<at_resp_message_t, 16> *wiFi2ATmPool, 
                 Queue<at_resp_message_t, 16> *wiFi2ATCmdQueue, 
                 MemoryPool<wifi_data_msg_t, PQDSZ> *aT2WiFiDatamPool, 
                 Queue<wifi_data_msg_t, PQDSZ> *aT2WiFiDataQueue, 
                 MemoryPool<at_data_msg_t, PQDSZ> *wiFi2ATDatamPool, 
                 Queue<at_data_msg_t, PQDSZ> *wiFi2ATDataQueue, 
                 MemoryPool<at_ble_msg_t, PQDSZ_BLE> *aT2BleDatamPool, 
                 Queue<at_ble_msg_t, PQDSZ_BLE> *aT2BleDataQueue, 
                 MemoryPool<ble_at_msg_t, PQDSZ_BLE> *ble2ATDatamPool, 
                 Queue<ble_at_msg_t, PQDSZ_BLE> *ble2ATDataQueue, 
                 bool debug = false);
public:
    void runMain();



private:
// UART settings
    uart_config_t *uart_config;
    UARTSerial _serial;
    Mutex _smutex; // Protect serial port access
    Mutex _rmutex; // Reset protection
    // define event queue
    events::EventQueue &_event_queue;
    // AT Command Parser
    ATCmdParser _parser;
    SMDevicePeripheral *blePeripheral;
    WiFiManager *wiFiManager;
    at_cmd_resp_t at_resp;
    at_data_mode_t dataMode;
    uint32_t lastHttpRespTime;
    uint8_t lastCloudMsgType;
    /*  Queue and memory pool for AT to Wifi commands */
    MemoryPool<wifi_cmd_message_t, 16> *_aT2WiFimPool;
    Queue<wifi_cmd_message_t, 16> *_aT2WiFiCmdQueue;
    
    /*  Queue and memory pool for WiFi to AT commands */
    MemoryPool<at_resp_message_t, 16> *_wiFi2ATmPool;
    Queue<at_resp_message_t, 16> *_wiFi2ATCmdQueue;
    
    /*  Queue and memory pool for AT to WiFi data */
    MemoryPool<wifi_data_msg_t, PQDSZ> *_aT2WiFiDatamPool;
    Queue<wifi_data_msg_t, PQDSZ> *_aT2WiFiDataQueue;
    
    
    /*  Queue and memory pool for WiFi to AT data */
    MemoryPool<at_data_msg_t, PQDSZ> *_wiFi2ATDatamPool;
    Queue<at_data_msg_t, PQDSZ> *_wiFi2ATDataQueue;

    /*  Queue and memory pool for AT to BLE data */
    MemoryPool<at_ble_msg_t, PQDSZ_BLE> *_aT2BleDatamPool;
    Queue<at_ble_msg_t, PQDSZ_BLE> *_aT2BleDataQueue;
    
    
    /*  Queue and memory pool for BLE to AT data */
    MemoryPool<ble_at_msg_t, PQDSZ_BLE> *_ble2ATDatamPool;
    Queue<ble_at_msg_t, PQDSZ_BLE> *_ble2ATDataQueue;

    
    //pointer to response data - should be deleted after processing
    at_data_msg_t *resp_data;
    edm_header_t   edm_hdr;
    uint8_t        *rx_buf_ptr;
    int            debug_flag;
    at_cmd_resp_t  wifiStateControl;
#ifdef BOX_UBLOX_DEMO_TESTING
    bool           check_for_at_cmd;
#endif
    
    // OOB processing
    void _process_oob(uint32_t timeout, bool all);
    // OOB message handlers
    void _oob_startup_hdlr();
    void _oob_ok_hdlr();
    void _oob_bleRole_hdlr();
    void _oob_enable_wifi();
    void _oob_wifiMode_err();
    void _oob_conn_already();
    void _oob_err();
    void _oob_echo_off();
    void _oob_uart_setup();
    void _oob_echo_on();
    void _oob_debug_logs_on();
    void _oob_debug_logs_off();
    void _oob_data_mode();
    void _oob_get_mac_addr();
    void _oob_get_ble_role();
    void _oob_ena_ble_peri();
    void _oob_reboot();
    void _oob_get_fw_ver();
    void _oob_scanWiFiNetworks();
    void _oob_WiFiStationConfigAction();
    void _oob_disconnectWiFiNetwork();
    void _oob_setupInternetConnection();
    void _oob_setWiFiSSID();
    void _oob_setWiFiPWD();
    void _oob_setWiFiSecurity();
    void _oob_sendHttpMessage();
    void _oob_getNetworkStatus();
    void _oob_WiFiNetworkStatus();
    wifi_config_t init_wifi_config();
    const char * sec2str(nsapi_security_t sec);
    bool        queueWiFiCommand(wifi_cmd_t cmd);
    bool        dequeueATresponse();
    bool        queueWiFiDataRequest(wifi_data_msg_t cmd);
    bool        dequeueWiFidataResponse();
    void        processResponses();
    bool        setNextResponse(at_cmd_resp_t resp);    
    int         ReadBytes(uint8_t *buf, int maxBytes);
    int         readStringBytes(uint8_t *buf, int maxBytes);
    bool        validate(edm_header_t edm_header);
    bool        createHttpRequest();
    http_method str2HttpMethod(const char * methodStr);
    void        return_response(bool download=false); 
    void        printBufferInHex(const uint8_t *buf, int pLen);
    void        outputEDMdata(const uint8_t *buf, int pLen, 
                              edm_msg_id_t identifier, edm_msg_type_t type,
                              channel_id_t channel_id);
    
    void        sendAtConfirmation(const char *buf);
    void        sendAtConfirmationFreeMpool(const char *buf);
    void        sendConnectIndicationFreeMpool(const char *buf);
    void        sendAtEvent(const char *buf);
    void        sendConnectEvent(const uint8_t *buf, int len);
    int         readAtCommandString(char *strbuf, size_t bufLen);
    void        updateWiFiMgrStatus();
    void        sendBleDataEvent(const char *buf, int len);
    
    /**
    * Allows timeout to be changed between commands
    *
    * @param timeout_ms timeout of the connection
    */
    void set_timeout(uint32_t timeout_ms =  UBLOX_ODIN_W2_MISC_TIMEOUT);
};
#endif // __ATCMD_MANAGER_H__