JablotronController.h

#pragma once

#include <queue>
#include <string>

#include <Poco/Event.h>
#include <Poco/Mutex.h>
#include <Poco/Nullable.h>
#include <Poco/RunnableAdapter.h>
#include <Poco/SharedPtr.h>
#include <Poco/Thread.h>
#include <Poco/Timespan.h>

#include "io/SerialPort.h"
#include "jablotron/JablotronReport.h"
#include "loop/StopControl.h"
#include "util/Joiner.h"
#include "util/Loggable.h"

namespace BeeeOn {

class JablotronController : Loggable {
public:
        enum Beep {
                BEEP_NONE,
                BEEP_SLOW,
                BEEP_FAST,
        };

        JablotronController();

        void setMaxProbeAttempts(int count);

        void setProbeTimeout(const Poco::Timespan &timeout);

        void setIOJoinTimeout(const Poco::Timespan &timeout);

        void setIOReadTimeout(const Poco::Timespan &timeout);

        void setIOErrorSleep(const Poco::Timespan &delay);

        void probe(const std::string &dev);

        void release(const std::string &dev);

        void dispose();

        JablotronReport pollReport(const Poco::Timespan &timeout);

        Poco::Nullable<uint32_t> readSlot(
                unsigned int i,
                const Poco::Timespan &timeout);

        void registerSlot(
                unsigned int i,
                uint32_t address,
                const Poco::Timespan &timeout);

        void unregisterSlot(
                unsigned int i,
                const Poco::Timespan &timeout);

        void eraseSlots(const Poco::Timespan &timeout);

        void sendTX(
                bool x,
                bool y,
                bool alarm,
                Beep beep,              
                const Poco::Timespan &timeout);

        void sendEnroll(const Poco::Timespan &timeout);

protected:
        void handleOkError(const std::string &response) const;

        std::string command(const std::string &request,
                const Poco::Timespan &timeout);

        void startIO();

        void stopIO(const std::string &dev);

        void probePort(const std::string &dev);

        bool receivedVersion(const std::string &response);

        std::string popResponse();

        JablotronReport popReport();

        void readAndProcess();

        void processMessage(const std::string &message);

        void ioLoop();

        void writePort(const std::string &request);
        std::string readPort(const Poco::Timespan &timeout);

private:
        SerialPort m_port;
        std::queue<std::string> m_responses;
        Poco::Event m_requestEvent;
        std::queue<JablotronReport> m_reports;
        Poco::Event m_pollEvent;

        size_t m_maxProbeAttempts;
        Poco::Timespan m_probeTimeout;
        Poco::Timespan m_ioJoinTimeout;
        Poco::Timespan m_ioReadTimeout;
        Poco::Timespan m_ioErrorSleep;

        Poco::SharedPtr<Poco::Thread> m_ioThread;
        Poco::SharedPtr<Joiner> m_joiner;
        Poco::RunnableAdapter<JablotronController> m_ioLoop;
        StopControl m_stopControl;

        Poco::FastMutex m_lock;
        Poco::FastMutex m_requestLock;
};

}