File content as of revision 0:ea85c4bb5e1f:

/*
 * Copyright 2014, ACKme Networks
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of ACKme Networks;
 * the contents of this file may not be disclosed to third parties, copied
 * or duplicated in any form, in whole or in part, without the prior
 * written permission of ACKme Networks.
 */

#pragma once

#include "WiconnectTypes.h"


#include "types/LogFunc.h"
#include "types/ReaderFunc.h"
#include "types/Callback.h"
#include "types/QueuedCommand.h"
#include "types/CommandQueue.h"
#include "types/TimeoutTimer.h"
#include "types/PeriodicTimer.h"
#include "types/Gpio.h"
#include "types/WiconnectSerial.h"

#include "NetworkInterface.h"
#include "SocketInterface.h"
#include "FileInterface.h"


#ifdef WICONNECT_ENABLE_MALLOC
#define WICONNECT_MALLOC_ARGS , void* (*malloc_)(size_t) = WICONNECT_DEFAULT_MALLOC, void (*free_)(void*) = WICONNECT_DEFAULT_FREE
#else
#define WICONNECT_MALLOC_ARGS
#endif


namespace wiconnect {


class Wiconnect : public NetworkInterface,
                  public SocketInterface,
                  public FileInterface
{
public:
    Wiconnect(const SerialConfig &serialConfig, Pin reset = PIN_NC, Pin wake = PIN_NC, bool nonBlocking = WICONNECT_DEFAULT_NONBLOCKING WICONNECT_MALLOC_ARGS);
    Wiconnect(const SerialConfig &serialConfig, void *internalBuffer, int internalBufferSize, Pin reset = PIN_NC, Pin wake = PIN_NC, bool nonBlocking = WICONNECT_DEFAULT_NONBLOCKING WICONNECT_MALLOC_ARGS);
    ~Wiconnect();

    static Wiconnect* getInstance();

    WiconnectResult init(bool bringNetworkUp);
    void deinit();
    bool isInitialized();
    WiconnectResult reset();
    WiconnectResult wakeup();
    void flush(int delayMs = 500);

    WiconnectResult getVersion(char *versionBuffer = NULL, int versionBufferSize = 0, const Callback &completeCallback = Callback());

    WiconnectResult sendCommand(const Callback &completeCallback, char *responseBuffer, int responseBufferLen,
                                int timeoutMs, const ReaderFunc &reader, void *user, const char *cmd, va_list vaList);
    WiconnectResult sendCommand(char *responseBuffer, int responseBufferLen, int timeoutMs, const ReaderFunc &reader,
                                void *user, const char *cmd, va_list vaList);
    WiconnectResult sendCommand(char *responseBuffer, int responseBufferLen, int timeoutMs, const ReaderFunc &reader,
                                void *user, const char *cmd, ...);
    WiconnectResult sendCommand( int timeoutMs, const ReaderFunc &reader, void *user, const char *cmd, ...);
    WiconnectResult sendCommand(const ReaderFunc &reader, void *user, const char *cmd, ...);
    WiconnectResult sendCommand(char *responseBuffer, int responseBufferLen,  int timeoutMs, const char *cmd, ...);
    WiconnectResult sendCommand(const Callback &completeCallback, char *responseBuffer, int responseBufferLen, const char *cmd, ...);
    WiconnectResult sendCommand(char *responseBuffer, int responseBufferLen, const char *cmd, ...);
    WiconnectResult sendCommand(const Callback &completeCallback, const char *cmd, ...);
    WiconnectResult sendCommand(const char *cmd, ...);
    WiconnectResult sendCommand(const Callback &completeCallback, int timeoutMs, const char *cmd, ...);
    WiconnectResult sendCommand(int timeoutMs, const char *cmd, ...);
    WiconnectResult sendCommand(const char *cmd, va_list vaList);

    const char* getLastCommandResponseCodeStr();
    uint16_t getLastCommandResponseLength();
    char* getResponseBuffer();
    WiconnectResult responseToUint32(uint32_t *uint32Ptr);
    WiconnectResult responseToInt32(int32_t *int32Ptr);

    WiconnectResult checkCurrentCommand();
    void stopCurrentCommand();
    void setCommandDefaultTimeout(int timeoutMs);
    int getCommandDefaultTimeout();

    void setPinToGpioMapper(PinToGpioMapper mapper);

    static const char* getWiconnectResultStr(WiconnectResult wiconnectResult);
    void setDebugLogger(LogFunc logFunc);

#ifdef WICONNECT_ASYNC_TIMER_ENABLED
    WiconnectResult enqueueCommand(QueuedCommand *command, const Callback &commandCompleteHandler = Callback());
    void setCommandProcessingPeriod(uint32_t periodMs);
#endif

protected:

#ifdef WICONNECT_ENABLE_MALLOC
    void* (*_malloc)(size_t);
    void (*_free)(void *);
    friend class QueuedCommand;
    friend class WiconnectSerial;
    friend class ScanResult;
    friend class Socket;
    friend class File;
#endif

    wiconnect::WiconnectSerial serial;
    wiconnect::Gpio resetGpio;
    wiconnect::Gpio wakeGpio;

    volatile bool commandExecuting;
    bool initialized;
    bool nonBlocking;

    PinToGpioMapper pinToGpioMapper;

    char *internalBuffer;
    int internalBufferSize;
    bool internalBufferAlloc;
    uint8_t internalProcessingState;
    void *currentCommandId;

    wiconnect::TimeoutTimer timeoutTimer;
    int defaultTimeoutMs;

    uint8_t commandHeaderBuffer[32];
    char commandFormatBuffer[WICONNECT_MAX_CMD_SIZE];
    uint8_t commandContext[96];

    void prepare(void *internalBuffer, int internalBufferSize, bool nonBlocking);
    WiconnectResult inline receiveResponse();
    WiconnectResult inline receivePacket();
    void issueCommandCallback(WiconnectResult result);

    wiconnect::LogFunc debugLogger;
    void debugLog(const char *msg, ...);

#ifdef WICONNECT_ASYNC_TIMER_ENABLED
    wiconnect::PeriodicTimer commandProcessorTimer;
    uint32_t commandProcessingPeriod;
    CommandQueue commandQueue;
    wiconnect::QueuedCommand *currentQueuedCommand;

    void commandProcessingTimerHandler(void);
    void processNextQueuedCommand();
    void checkQueuedCommandTimeout();
#endif

    friend class NetworkInterface;
    friend class SocketInterface;
    friend class FileInterface;
};

}