propellerloader.h

#pragma once

#include "../image/propellerimage.h"
#include "../session/propellersession.h"
#include "protocol.h"

#include <QTimer>
#include <QElapsedTimer>
#include <QStateMachine>
#include <QFinalState>
#include <QState>

class PropellerLoader : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString status MEMBER m_status NOTIFY statusChanged)
    Q_PROPERTY(int stat MEMBER m_stat)

public:
    enum LoaderError
    {
        NoError,
        DeviceBusyError,
        DeviceNotOpenError,
        DeviceNotFoundError,
        DownloadInProgressError,
        InvalidImageError,
        VerifyRamError,
        WriteEepromError,
        VerifyEepromError,
        TimeoutError,
        HandshakeError,
        InvalidHandshakeError,
        UnknownError
    };

private:
    PropellerSession * session;
    PropellerProtocol protocol;
    PropellerImage _image;

    int _command;
    int _completed;
    QString m_status;
    int m_stat;
    
    QByteArray _payload;

    QStateMachine machine;
    QState * s_active;

    LoaderError _error;
    QHash<LoaderError, QString> _errorstrings;

    int _version;
    QHash<int, QString> _versionstrings;

    int _ack;
    int _write, _run;

    QTimer totalTimeout;
    QTimer handshakeTimeout;
    QTimer resetTimer;
    QTimer poll;
    QElapsedTimer elapsedTimer;

    void writeLong(quint32 value);

signals:
    void finished();
    void success();
    void failure();

    void prepared();
    void payload_sent();
    void handshake_received();
    void upload_completed();
    void acknowledged();

    void statusChanged(const QString & message);

private slots:

    void failure_entry();
    void success_entry();

    void prepare_entry();

    void sendpayload_entry();
    void sendpayload_exit();

    void sendpayload_write();
    void handshake_read();

    void upload_status();

    void acknowledge_entry();
    void acknowledge_exit();
    void acknowledge_read();

    void calibrate();
    void timeover();
    void timestamp();

    void message(const QString & text);
    void error(const QString & text);

public:
    PropellerLoader(PropellerManager * manager,
                    const QString & portname = QString(),
                    QObject * parent = 0);
    ~PropellerLoader();

    int version();
    QString versionString(int version);

    bool upload(PropellerImage image, bool write=false, bool run=true, bool wait=false);
//    bool highSpeedUpload(PropellerImage image, bool write=false, bool run=true);
};