361 lines
13 KiB
C++
361 lines
13 KiB
C++
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* Copyright 2013 - 2020, nymea GmbH
|
|
* Contact: contact@nymea.io
|
|
*
|
|
* This file is part of nymea.
|
|
* This project including source code and documentation is protected by
|
|
* copyright law, and remains the property of nymea GmbH. All rights, including
|
|
* reproduction, publication, editing and translation, are reserved. The use of
|
|
* this project is subject to the terms of a license agreement to be concluded
|
|
* with nymea GmbH in accordance with the terms of use of nymea GmbH, available
|
|
* under https://nymea.io/license
|
|
*
|
|
* GNU Lesser General Public License Usage
|
|
* Alternatively, this project may be redistributed and/or modified under the
|
|
* terms of the GNU Lesser General Public License as published by the Free
|
|
* Software Foundation; version 3. This project is distributed in the hope that
|
|
* it will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this project. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* For any further details and any questions please contact us under
|
|
* contact@nymea.io or see our FAQ/Licensing Information on
|
|
* https://nymea.io/license/faq
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include "kecontact.h"
|
|
#include "extern-plugininfo.h"
|
|
|
|
#include <QJsonDocument>
|
|
|
|
|
|
KeContact::KeContact(QHostAddress address, QObject *parent) :
|
|
QObject(parent),
|
|
m_address(address)
|
|
{
|
|
m_requestTimeoutTimer = new QTimer(this);
|
|
m_requestTimeoutTimer->setSingleShot(true);
|
|
connect(m_requestTimeoutTimer, &QTimer::timeout, this, [this] {
|
|
//This timer will be started when a request is sent and stopped or resetted when a response has been received
|
|
emit connectionChanged(false);
|
|
//Try to send the next command
|
|
handleNextCommandInQueue();
|
|
m_deviceBlocked = false;
|
|
});
|
|
}
|
|
|
|
KeContact::~KeContact() {
|
|
qCDebug(dcKebaKeContact()) << "Deleting KeContact connection for address" << m_address;
|
|
}
|
|
|
|
bool KeContact::init(){
|
|
|
|
if(!m_udpSocket){
|
|
m_udpSocket = new QUdpSocket(this);
|
|
if (!m_udpSocket->bind(QHostAddress::AnyIPv4, 7090, QAbstractSocket::ShareAddress)) {
|
|
qCWarning(dcKebaKeContact()) << "Cannot bind to port" << 7090;
|
|
delete m_udpSocket;
|
|
return false;
|
|
}
|
|
connect(m_udpSocket, &QUdpSocket::readyRead, this, &KeContact::readPendingDatagrams);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QHostAddress KeContact::address()
|
|
{
|
|
return m_address;
|
|
}
|
|
|
|
void KeContact::setAddress(QHostAddress address)
|
|
{
|
|
m_address = address;
|
|
}
|
|
|
|
void KeContact::sendCommand(const QByteArray &command)
|
|
{
|
|
if (!m_udpSocket) {
|
|
qCWarning(dcKebaKeContact()) << "UDP socket not initialized";
|
|
emit connectionChanged(false);
|
|
return;
|
|
}
|
|
if(m_deviceBlocked) {
|
|
//add command to queue
|
|
m_commandList.append(command);
|
|
} else {
|
|
//send command
|
|
m_udpSocket->writeDatagram(command, m_address, 7090);
|
|
m_requestTimeoutTimer->start(5000);
|
|
m_deviceBlocked = true;
|
|
}
|
|
}
|
|
|
|
void KeContact::handleNextCommandInQueue()
|
|
{
|
|
if (!m_udpSocket) {
|
|
qCWarning(dcKebaKeContact()) << "UDP socket not initialized";
|
|
emit connectionChanged(false);
|
|
return;
|
|
}
|
|
qCDebug(dcKebaKeContact()) << "Handle Command Queue- Pending commands" << m_commandList.length() << "Pending requestIds" << m_pendingRequests.length();
|
|
if (!m_commandList.isEmpty()) {
|
|
QByteArray command = m_commandList.takeFirst();
|
|
m_udpSocket->writeDatagram(command, m_address, 7090);
|
|
m_requestTimeoutTimer->start(5000);
|
|
} else {
|
|
//nothing to do
|
|
}
|
|
}
|
|
|
|
|
|
QUuid KeContact::enableOutput(bool state)
|
|
{
|
|
QUuid requestId = QUuid::createUuid();
|
|
m_pendingRequests.append(requestId);
|
|
// Print information that we are executing now the update action;
|
|
QByteArray datagram;
|
|
if(state){
|
|
datagram.append("ena 1");
|
|
} else{
|
|
datagram.append("ena 0");
|
|
}
|
|
qCDebug(dcKebaKeContact()) << "Datagram : " << datagram;
|
|
sendCommand(datagram);
|
|
QTimer::singleShot(5000, this, [requestId, this] {
|
|
if (m_pendingRequests.contains(requestId)) {
|
|
m_pendingRequests.removeOne(requestId);
|
|
emit commandExecuted(requestId, false);
|
|
}
|
|
});
|
|
return requestId;
|
|
}
|
|
|
|
QUuid KeContact::setMaxAmpere(int milliAmpere)
|
|
{
|
|
QUuid requestId = QUuid::createUuid();
|
|
m_pendingRequests.append(requestId);
|
|
// Print information that we are executing now the update action
|
|
qCDebug(dcKebaKeContact()) << "Update max current to : " << milliAmpere;
|
|
QByteArray data;
|
|
data.append("curr " + QVariant(milliAmpere).toByteArray());
|
|
qCDebug(dcKebaKeContact()) << "send command: " << data;
|
|
sendCommand(data);
|
|
if (m_pendingRequests.contains(requestId)) {
|
|
m_pendingRequests.removeOne(requestId);
|
|
emit commandExecuted(requestId, false);
|
|
}
|
|
return requestId;
|
|
}
|
|
|
|
QUuid KeContact::displayMessage(const QByteArray &message)
|
|
{
|
|
/* Text shown on the display. Maximum 23 ASCII characters can be used. 0 .. 23 characters
|
|
~ == Σ
|
|
$ == blank
|
|
, == comma
|
|
*/
|
|
QUuid requestId = QUuid::createUuid();
|
|
m_pendingRequests.append(requestId);
|
|
qCDebug(dcKebaKeContact()) << "Set display message: " << message;
|
|
QByteArray data;
|
|
QByteArray modifiedMessage = message;
|
|
modifiedMessage.replace(" ", "$");
|
|
if (modifiedMessage.size() > 23) {
|
|
modifiedMessage.resize(23);
|
|
}
|
|
data.append("display 0 0 0 0 " + modifiedMessage);
|
|
qCDebug(dcKebaKeContact()) << "send command: " << data;
|
|
sendCommand(data);
|
|
if (m_pendingRequests.contains(requestId)) {
|
|
m_pendingRequests.removeOne(requestId);
|
|
emit commandExecuted(requestId, false);
|
|
}
|
|
return requestId;
|
|
}
|
|
|
|
|
|
void KeContact::getDeviceInformation()
|
|
{
|
|
QByteArray data;
|
|
data.append("i");
|
|
qCDebug(dcKebaKeContact()) << "send command: " << data;
|
|
sendCommand(data);
|
|
}
|
|
|
|
void KeContact::getReport1()
|
|
{
|
|
QByteArray data;
|
|
data.append("report 1");
|
|
qCDebug(dcKebaKeContact()) << "send command : " << data;
|
|
sendCommand(data);
|
|
}
|
|
|
|
void KeContact::getReport2()
|
|
{
|
|
QByteArray data;
|
|
data.append("report 2");
|
|
qCDebug(dcKebaKeContact()) << "send command: " << data;
|
|
sendCommand(data);
|
|
}
|
|
|
|
void KeContact::getReport3()
|
|
{
|
|
QByteArray data;
|
|
data.append("report 3");
|
|
qCDebug(dcKebaKeContact()) << "data: " << data;
|
|
sendCommand(data);
|
|
}
|
|
|
|
QUuid KeContact::unlockCharger()
|
|
{
|
|
QUuid requestId = QUuid::createUuid();
|
|
m_pendingRequests.append(requestId);
|
|
QByteArray data;
|
|
data.append("unlock");
|
|
qCDebug(dcKebaKeContact()) << "send command: " << data;
|
|
sendCommand(data);
|
|
return requestId;
|
|
}
|
|
|
|
void KeContact::readPendingDatagrams()
|
|
{
|
|
QUdpSocket *socket= qobject_cast<QUdpSocket*>(sender());
|
|
|
|
QByteArray datagram;
|
|
QHostAddress sender;
|
|
quint16 senderPort;
|
|
|
|
while (socket->hasPendingDatagrams()) {
|
|
datagram.resize(socket->pendingDatagramSize());
|
|
socket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);
|
|
if (sender != m_address) {
|
|
//Only process data from the target device
|
|
continue;
|
|
}
|
|
emit connectionChanged(true);
|
|
|
|
qCDebug(dcKebaKeContact()) << "Data received" << datagram;
|
|
if(datagram.contains("TCH-OK")){
|
|
|
|
//Command response has been received, now send the next command
|
|
m_deviceBlocked = false;
|
|
m_requestTimeoutTimer->stop();
|
|
handleNextCommandInQueue();
|
|
|
|
if (!m_pendingRequests.isEmpty()) {
|
|
QUuid requestId = m_pendingRequests.takeFirst();
|
|
if (datagram.contains("done")) {
|
|
emit commandExecuted(requestId, true);
|
|
} else {
|
|
emit commandExecuted(requestId, false);
|
|
}
|
|
} else {
|
|
//Probably the response has taken too long and the requestId has been already removed
|
|
}
|
|
} else if(datagram.left(8).contains("Firmware")){
|
|
|
|
//Command response has been received, now send the next command
|
|
m_deviceBlocked = false;
|
|
m_requestTimeoutTimer->stop();
|
|
handleNextCommandInQueue();
|
|
|
|
qCDebug(dcKebaKeContact()) << "Firmware information reveiced";
|
|
QByteArrayList firmware = datagram.split(':');
|
|
if (firmware.length() >= 2) {
|
|
emit deviceInformationReceived(firmware[1]);
|
|
}
|
|
} else {
|
|
|
|
//Command response has been received, now send the next command
|
|
m_deviceBlocked = false;
|
|
m_requestTimeoutTimer->stop();
|
|
handleNextCommandInQueue();
|
|
|
|
// Convert the rawdata to a json document
|
|
QJsonParseError error;
|
|
QJsonDocument jsonDoc = QJsonDocument::fromJson(datagram, &error);
|
|
if (error.error != QJsonParseError::NoError) {
|
|
qCWarning(dcKebaKeContact()) << "Failed to parse JSON data" << datagram << ":" << error.errorString();
|
|
}
|
|
|
|
QVariantMap data = jsonDoc.toVariant().toMap();
|
|
|
|
if(data.contains("ID")) {
|
|
|
|
if (data.value("ID").toString() == "1") {
|
|
ReportOne reportOne;
|
|
qCDebug(dcKebaKeContact()) << "Report 1 received";
|
|
reportOne.product = data.value("Product").toString();
|
|
reportOne.firmware = data.value("Firmware").toString();
|
|
reportOne.serialNumber = data.value("Serial").toString();;
|
|
emit reportOneReceived(reportOne);
|
|
|
|
} else if(data.value("ID").toString() == "2"){
|
|
|
|
ReportTwo reportTwo;
|
|
qCDebug(dcKebaKeContact()) << "Report 2 reveiced";
|
|
int state = data.value("State").toInt();
|
|
reportTwo.state = State(state);
|
|
reportTwo.error1 = data.value("Error1").toInt();
|
|
reportTwo.error2 = data.value("Error2").toInt();
|
|
reportTwo.plugState = PlugState(data.value("Plug").toInt());
|
|
reportTwo.enableUser = data.value("Enable user").toBool();
|
|
reportTwo.enableSys = data.value("Enable sys").toBool();
|
|
reportTwo.MaxCurrent = data.value("Max curr").toInt()/1000;
|
|
reportTwo.MaxCurrentPercentage = data.value("Max curr %").toInt()/10;
|
|
reportTwo.CurrentHardwareLimitation = data.value("Curr HW").toInt()/1000;
|
|
reportTwo.CurrentUser = data.value("Curr user").toInt();
|
|
reportTwo.CurrFS = data.value("Curr FS").toInt();
|
|
reportTwo.TmoFS = data.value("Tmo FS").toInt();
|
|
reportTwo.output = data.value("Output").toInt();
|
|
reportTwo.input= data.value("Input").toInt();
|
|
reportTwo.serialNumber = data.value("Serial").toString();
|
|
reportTwo.seconds = data.value("Sec").toInt();
|
|
emit reportTwoReceived(reportTwo);
|
|
|
|
} else if(data.value("ID").toString() == "3"){
|
|
|
|
ReportThree reportThree;
|
|
qCDebug(dcKebaKeContact()) << "Report 3 reveiced";
|
|
reportThree.CurrentPhase1 = data.value("I1").toInt();
|
|
reportThree.CurrentPhase2 = data.value("I2").toInt();
|
|
reportThree.CurrentPhase3 = data.value("I3").toInt();
|
|
reportThree.VoltagePhase1 = data.value("U1").toInt();
|
|
reportThree.VoltagePhase2 = data.value("U2").toInt();
|
|
reportThree.VoltagePhase3 = data.value("U3").toInt();
|
|
reportThree.Power = data.value("P").toInt();
|
|
reportThree.PowerFactor = data.value("PF").toInt()/10;
|
|
reportThree.EnergySession = data.value("E pres").toInt()/10000.00;
|
|
reportThree.EnergyTotal = data.value("E total").toInt()/10000.00;
|
|
reportThree.SerialNumber = data.value("Serial").toString();
|
|
emit reportThreeReceived(reportThree);
|
|
}
|
|
} else {
|
|
if (data.contains("State")) {
|
|
emit broadcastReceived(BroadcastType::BroadcastTypeState, data.value("State"));
|
|
}
|
|
if (data.contains("Plug")) {
|
|
emit broadcastReceived(BroadcastType::BroadcastTypePlug, data.value("Plug"));
|
|
}
|
|
if (data.contains("Input")) {
|
|
emit broadcastReceived(BroadcastType::BroadcastTypeInput, data.value("Input"));
|
|
}
|
|
if (data.contains("Enable sys")) {
|
|
emit broadcastReceived(BroadcastType::BroadcastTypeEnableSys, data.value("Enable sys"));
|
|
}
|
|
if (data.contains("Max curr")) {
|
|
emit broadcastReceived(BroadcastType::BroadcastTypeMaxCurr, data.value("Max curr"));
|
|
}
|
|
if (data.contains("E pres")) {
|
|
emit broadcastReceived(BroadcastType::BroadcastTypeEPres, data.value("E pres"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|