shactuator.cpp

#include "shactuator.h"

QTcpSocket * SHactuator::m_socket = nullptr;
#ifndef SHREMOTE
QSerialPort *SHactuator::m_serial = nullptr;
#endif


/*
 * Konstruktor
 */
SHactuator::SHactuator(/* QString name,*/ int nid, int powerDemand, SensorType sid, QString url) :
    SHsensor(nid, sid, url),
    m_powerDemand(powerDemand)
{
    // Hinzufügen, d.h. überschreiben -> wieso geht das auch ohne?
    // int pos = hash(m_nodeID, m_sensorID);

    // S[pos] = this;

    m_ignoreF3error = true;
}

/*
 * Konstruktor
 */
SHactuator::SHactuator(int nid, int powerDemand, QString url) :
    SHsensor(nid, SensorType::Switch, url),
    m_powerDemand(powerDemand)
{
    m_ignoreF3error = true;
}


/*
 *
 */
void SHactuator::setValue(const QString & payl)
{
    // qDebug() << "SHactuator::setValue(nid=" << m_nodeID << "sid=" << m_sensorID << "payl=" << payl << ")";
    int intState = -1;

    if (payl == "ON")
            intState = 1;    
    else if (payl == "OFF")
            intState = 0;
    else {
        bool ok;
        intState = payl.toInt(&ok);

        if (not ok)
            intState = -1;
    }

    // 1=on, 0=off

    switch (intState) {
    case 0:
        m_switchState = State::OFF;
        SHsensor::setValue("OFF");

        if (not m_ignoreF3error and m_switchState != m_assignedState)
            setError(switchError);
        else
            resetError(switchError);
        break;

    case 1:
        m_switchState = State::ON;
        SHsensor::setValue("ON");

        if (not m_ignoreF3error and m_switchState != m_assignedState)
            setError(switchError);
        else
            resetError(switchError);
        break;

    default:
        m_switchState = State::UNKOWN;
        SHsensor::setValue(NOVALUE);
        break;
    }
}


/*
 * true==On, false=Off
 */
void SHactuator::swtch(bool on)
{
    QString cmd; // tasmota
    State switchState; // for testing
    QString value; // display

    m_ignoreF3error = false;

    if (on) {
        m_assignedState = State::ON;
        cmd = "cm?cmnd=Power%20On";
        switchState = State::ON;
        value = "1";
    } else {
        m_assignedState = State::OFF;
        cmd = "cm?cmnd=Power%20Off";
        switchState = State::OFF;
        value = "0";
    }

    if (not SHsensor::isTesting()) {
        if (tasmota() and m_switchState != switchState) { // nur bei Änderungen. TODO ggf. auch bei Arduino
            // qDebug() << "SHactuator::swtch" << on;
            QString urlRequest = m_url + "/" + cmd;

            QNetworkRequest request; // -> what type of demand? get, post, ...

            request.setUrl(QUrl(urlRequest));
            m_tasmota->get(request);

            poll(); // get ACK
        } else {
            m_socket->write(QByteArray(msg(on).toUtf8()));

#ifndef SHREMOTE
            if (m_serial)
                m_serial->write(QByteArray(msg(on).toUtf8()));
#endif
        }
    } else {
        m_switchState = switchState; // for testing
        SHsensor::setValue( m_nodeID,  m_sensorID, value);
    }

}


/*
 *
 */
void SHactuator::ON()
{
    swtch(true);
}


/*
 *
 */
void SHactuator::OFF()
{
    swtch(false);
}



/*
 *
 */
void SHactuator::set(SHactuator::State state)
{
    switch (state) {
    case State::ON:
        ON();
        break;
    case State::OFF:
        OFF();
        break;
    case State::UNKOWN:
        break;
    }
}



/*
 *
 */
SHactuator::State SHactuator::switchState() const
{
    return m_switchState;
}



/*
 *
 */
int SHactuator::powerDemand() const
{
    return m_powerDemand;
}



/*
 *
 */
void SHactuator::setIgnoreF3error() // beim setzen eines neuen Modes im Controller
{
    m_ignoreF3error = true;
}



/*
 *
 */
QString SHactuator::msg(int payload)
{
    /* command
    Type 	Value 	Comment
    presentation 	0 	Sent by a node when they present attached sensors. This is usually done in the presentation() function which runs at startup.
    set 	1 	This message is sent from or to a sensor when a sensor value should be updated
    req 	2 	Requests a variable value (usually from an actuator destined for controller).
    internal 	3 	This is a special internal message. See table below for the details
    stream 	4 	Used for OTA firmware updates
 */

    int command = C_SET;
    int ack = 1;
    int type = V_STATUS;

    QString msg =
            QString::number(m_nodeID) + ";" +
            QString::number(m_sensorID) + ";" +
            QString::number(command) + ";" +
            QString::number(ack) + ";" +
            QString::number(type) + ";" +
            QString::number(payload) + "\n";

    return msg;

}




/*
 *
 */
void SHactuator::setSocket(QTcpSocket *newSocket)
{
    m_socket = newSocket;
}



#ifndef SHREMOTE
/*
 *
 */
void SHactuator::setSerial(QSerialPort *newSerial)
{
    m_serial = newSerial;
}
#endif