ESPComponent.h

Go to the documentation of this file.

#ifndef ESPCOMPONENT_H_
#define ESPCOMPONENT_H_

#include "ESPClient.h"

#include "component/SyncComponent.h"
#include "io/LoadControl.h"
#include "data/StrValue.h"
#include "logger/Logger.h"
#include "io/UartStream.h"


class ESPComponent : public SyncSensorComponent
{
public:

    ESPComponent( const Module* module );

    virtual ~ESPComponent();

    virtual void run();

    virtual RunState start();

    virtual RunState starting();

    virtual RunState pause();

    virtual RunState paused();

    virtual RunState resume();

    virtual RunState resuming();

    virtual RunState runnable();

    virtual RunState resetting()
    {
        return start();
    }

    virtual RunState stop();

    virtual RunState stopping();

    virtual RunState stopped();

    void uninitialize();

    virtual ConfigURI getConfigURI( ConfigOption configOption ) const;

private:

    // disallow copy constructor
    ESPComponent( const ESPComponent& old );

    enum StartState
    {
        SS_INIT,
        SS_CONNECTING_AS_CLIENT,
        SS_WAITING_FOR_ESP_TO_CONNECT,
        SS_WAITING_FOR_PORT_NUMBER,
        SS_CONNECTED
    };
    StartState startState_;

    const char* startStateName( StartState startState )
    {
        switch( startState )
        {
        case SS_INIT:
            return "SS_INIT";
        case SS_CONNECTING_AS_CLIENT:
            return "SS_CONNECTING_AS_CLIENT";
        case SS_WAITING_FOR_ESP_TO_CONNECT:
            return "SS_WAITING_FOR_ESP_TO_CONNECT";
        case SS_WAITING_FOR_PORT_NUMBER:
            return "SS_WAITING_FOR_PORT_NUMBER";
        case SS_CONNECTED:
            return "SS_CONNECTED";
        default:
            return "(invalid StartState)";
        }
    };

    ESPComm* espComm_;

    ESPClient* espClient_;

    ESPClient::SamplingState samplingState_;

    void createESPComm();

    void createESPClient();

    bool openServerSocket();

    bool powerUpESP();

    bool powerDownESP( bool setFailure = true );

    Component::RunState waitForESPConnection();

    bool scanEspServerPort( Str& line, int *espServerPort );

    void espReady();

    Component::RunState startSamplingPhase();

    int getLine( Str& line );

    // any partial line received so far from the ESP. Updated by getLine.
    Str partialLine_;

    // returns true if data is requested from one of the readers
    bool isDataRequested();

    // Queries the LCBs for status
    bool logVoltageAndCurrent();

    // Get simulation data
    bool getSimulatedData();

    // Write data to the slate
    void writeData();

    UartStream uart_;
    LoadControl* loadControl_;  // as a pointer mainly to facilitate skipping it for testing

    // config readers
    ConfigReader* debugCfgReader_;
    ConfigReader* socketServerPortCfgReader_;
    ConfigReader* espServerHostCfgReader_;
    ConfigReader* poTimeoutCfgReader_;
    ConfigReader* connectTimeoutCfgReader_;
    ConfigReader* sampleTimeoutCfgReader_;
    ConfigReader* initialPromptTimeoutCfgReader_;
    ConfigReader* loadCartridgeTimeoutCfgReader_;
    ConfigReader* filterResultTimeoutCfgReader_;
    ConfigReader* filterCompleteTimeoutCfgReader_;
    ConfigReader* processResultTimeoutCfgReader_;
    ConfigReader* processCompleteTimeoutCfgReader_;
    ConfigReader* stopResultTimeoutCfgReader_;

    // port to listen for ESP when we start as a TCP server
    int socketServerPort_;

    StrValue espServerHost_;

    bool espAlwaysServer_;

    Timespan poTimeout_;      // powering up, including ESP connection
    Timespan connectTimeout_; // when connecting as client to the ESP
    Timespan sampleTimeout_;  // complete sample sequence

    // timeouts for main steps within a complete sample sequence:
    Timespan initialPromptTimeout_;
    Timespan loadCartridgeTimeout_;
    Timespan filterResultTimeout_;
    Timespan filterCompleteTimeout_;
    Timespan processResultTimeout_;
    Timespan processCompleteTimeout_;

    Timespan stopResultTimeout_;

    Timespan lineTimeout_;

    Timestamp startTimeAccept_;

    Timestamp startTimeForLine_;

    Timestamp startTimeConnecting_;

    Timestamp sampleTime_;

    // Indicates sampling is going on
    bool samplingActive_;
    int sampleNumber_;

    // Starts and stops pppd
    void startPPP( void );
    void stopPPP( void );

    bool debug_;

    // PPP connect/disconnect execution strings
    StrValue connectExec_;
    StrValue pppFlow_;

    StrValue uartName_;

    // Command to start PPPD
    Str pppCmd_;

    // Outputs to slate
    DataWriter* samplingActiveWriter_;
    DataWriter* sampleNumberWriter_;

    // Reads all configs
    bool readConfigs();

    // Re-reads the config variables that are allowed to change without restarting the application.
    bool readAdjustableConfigs();

    void logDebug( Str msg );

};
#endif /*ESPCOMPONENT_H_*/