Implemented: KMTronic USB/WEB relay hardware

Author: gizmocuz

CMakeLists.txt

@@ -187,6 +187,9 @@ hardware/GpioPin.cpp
 hardware/HardwareMonitor.cpp
 hardware/HarmonyHub.cpp
 hardware/ICYThermostat.cpp
+hardware/KMTronicBase.cpp
+hardware/KMTronicSerial.cpp
+hardware/KMTronicTCP.cpp
 hardware/Limitless.cpp
 hardware/Meteostick.cpp
 hardware/MochadTCP.cpp

History.txt

@@ -83,6 +83,7 @@ Version 2.0.xxxx (xxxx 2015)
 - Fixed: Blockly, possible saving of 'ghost' events
 - Implemented: Sanity check for OpenZWave NetworkKey Length
 - Implemented: OTGW, MsgID=14 and MsgID=17 (if reported)
+- Implemented: KMTronic USB/WEB relay hardware
 
 Version 2.0.2284 (February 22th 2015)
 - Fixed: Firefox, RGBW/Setpoint popup

hardware/DomoticzHardware.h

@@ -84,6 +84,9 @@ class CDomoticzHardwareBase
 	friend class FritzboxTCP;
 	friend class CETH8020;
 	friend class CRFLink;
+	friend class KMTronicBase;
+	friend class KMTronicSerial;
+	friend class KMTronicTCP;
 
 	virtual bool StartHardware()=0;
 	virtual bool StopHardware()=0;

hardware/KMTronicBase.cpp

@@ -0,0 +1,95 @@
+#include "stdafx.h"
+#include "KMTronicBase.h"
+#include "../main/Logger.h"
+#include "../main/Helper.h"
+#include "../main/RFXtrx.h"
+#include "../main/SQLHelper.h"
+#include "../main/localtime_r.h"
+#include "hardwaretypes.h"
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iostream>
+#include <boost/bind.hpp>
+
+#include <ctime>
+
+#define round(a) ( int ) ( a + .5 )
+
+
+KMTronicBase::KMTronicBase(void)
+{
+	m_bufferpos = 0;
+	m_TotRelais = 0;
+	for (int ii = 0; ii < Max_KMTronic_Relais; ii++)
+	{
+		m_bRelaisStatus[ii] = false;
+	}
+}
+
+
+KMTronicBase::~KMTronicBase(void)
+{
+}
+
+void KMTronicBase::ParseData(const unsigned char *pData, int Len)
+{
+	int ii=0;
+	while (ii<Len)
+	{
+		const unsigned char c = pData[ii];
+		if(c == 0x0d)
+		{
+			ii++;
+			continue;
+		}
+
+		if(c == 0x0a || m_bufferpos == sizeof(m_buffer) - 1)
+		{
+			// discard newline, close string, parse line and clear it.
+			if(m_bufferpos > 0) m_buffer[m_bufferpos] = 0;
+			ParseLine();
+			m_bufferpos = 0;
+		}
+		else
+		{
+			m_buffer[m_bufferpos] = c;
+			m_bufferpos++;
+		}
+		ii++;
+	}
+}
+
+
+bool KMTronicBase::WriteToHardware(const char *pdata, const unsigned char length)
+{
+	tRBUF *pCmd = (tRBUF *)pdata;
+	if (pCmd->LIGHTING2.packettype == pTypeLighting2)
+	{
+		//Light command
+
+		int node_id = pCmd->LIGHTING2.id4;
+		if (node_id > Max_KMTronic_Relais)
+			return false;
+
+		if ((pCmd->LIGHTING2.cmnd == light2_sOn) || (pCmd->LIGHTING2.cmnd == light2_sOff))
+		{
+			unsigned char SendBuf[3];
+			SendBuf[0] = 0xFF;
+			SendBuf[1] = node_id;
+			SendBuf[2] = (pCmd->LIGHTING2.cmnd == light2_sOn) ? 1 : 0;
+			WriteInt(SendBuf, 3,false);
+			return true;
+		}
+
+	}
+	return false;
+}
+
+
+void KMTronicBase::ParseLine()
+{
+	if (m_bufferpos<2)
+		return;
+}
+

hardware/KMTronicBase.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "DomoticzHardware.h"
+
+#define Max_KMTronic_Relais 8
+
+class KMTronicBase : public CDomoticzHardwareBase
+{
+	friend class KMTronicSerial;
+	friend class KMTronicTCP;
+public:
+	KMTronicBase(void);
+	~KMTronicBase(void);
+	std::string m_szSerialPort;
+	unsigned int m_iBaudRate;
+	bool WriteToHardware(const char *pdata, const unsigned char length);
+private:
+	virtual bool WriteInt(const unsigned char *data, const size_t len, const bool bWaitForReturn) = 0;
+	void ParseData(const unsigned char *pData, int Len);
+	void ParseLine();
+
+	static const int readBufferSize=1028;
+	unsigned char m_buffer[readBufferSize];
+	int m_bufferpos;
+
+	bool m_bDoInitialQuery;
+	int m_TotRelais;
+	bool m_bRelaisStatus[Max_KMTronic_Relais];
+};
+

hardware/KMTronicSerial.cpp

@@ -0,0 +1,240 @@
+#include "stdafx.h"
+#include "KMTronicSerial.h"
+#include "../main/Logger.h"
+#include "../main/Helper.h"
+#include "../main/RFXtrx.h"
+#include "../main/localtime_r.h"
+#include "P1MeterBase.h"
+#include "hardwaretypes.h"
+#include <string>
+#include <algorithm>
+#include <iostream>
+#include <boost/bind.hpp>
+
+#include <ctime>
+
+//#define DEBUG_KMTronic
+
+#define RETRY_DELAY 30
+
+KMTronicSerial::KMTronicSerial(const int ID, const std::string& devname)
+{
+	m_HwdID=ID;
+	m_szSerialPort=devname;
+	m_iBaudRate = 9600;
+	m_stoprequested = false;
+}
+
+KMTronicSerial::~KMTronicSerial()
+{
+	clearReadCallback();
+}
+
+bool KMTronicSerial::StartHardware()
+{
+	m_bDoInitialQuery = true;
+	m_iQueryState = 0;
+
+	m_retrycntr = RETRY_DELAY; //will force reconnect first thing
+
+	//Start worker thread
+	m_thread = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&KMTronicSerial::Do_Work, this)));
+
+	return (m_thread != NULL);
+
+	return true;
+}
+
+bool KMTronicSerial::StopHardware()
+{
+	m_stoprequested = true;
+	if (m_thread != NULL)
+		m_thread->join();
+	// Wait a while. The read thread might be reading. Adding this prevents a pointer error in the async serial class.
+	sleep_milliseconds(10);
+	if (isOpen())
+	{
+		try {
+			clearReadCallback();
+			close();
+			doClose();
+			setErrorStatus(true);
+		}
+		catch (...)
+		{
+			//Don't throw from a Stop command
+		}
+	}
+	m_bIsStarted = false;
+	return true;
+}
+
+void KMTronicSerial::Do_Work()
+{
+	while (!m_stoprequested)
+	{
+		sleep_seconds(1);
+		time_t atime = mytime(NULL);
+		struct tm ltime;
+		localtime_r(&atime, &ltime);
+		if (ltime.tm_sec % 12 == 0) {
+			mytime(&m_LastHeartbeat);
+		}
+
+		if (m_stoprequested)
+			break;
+		if (!isOpen())
+		{
+			if (m_retrycntr == 0)
+			{
+				_log.Log(LOG_STATUS, "KMTronic: retrying in %d seconds...", RETRY_DELAY);
+			}
+			m_retrycntr++;
+			if (m_retrycntr >= RETRY_DELAY)
+			{
+				m_retrycntr = 0;
+				if (OpenSerialDevice())
+				{
+					GetRelayStates();
+				}
+			}
+		}
+	}
+	_log.Log(LOG_STATUS, "KMTronic: Serial Worker stopped...");
+}
+
+bool KMTronicSerial::OpenSerialDevice()
+{
+	//Try to open the Serial Port
+	try
+	{
+		_log.Log(LOG_STATUS, "KMTronic: Using serial port: %s", m_szSerialPort.c_str());
+#ifndef WIN32
+		openOnlyBaud(
+			m_szSerialPort,
+			m_iBaudRate,
+			boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none),
+			boost::asio::serial_port_base::character_size(8)
+			);
+#else
+		open(
+			m_szSerialPort,
+			m_iBaudRate,
+			boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none),
+			boost::asio::serial_port_base::character_size(8)
+			);
+#endif
+	}
+	catch (boost::exception & e)
+	{
+		_log.Log(LOG_ERROR, "KMTronic: Error opening serial port!");
+#ifdef _DEBUG
+		_log.Log(LOG_ERROR, "-----------------\n%s\n-----------------", boost::diagnostic_information(e).c_str());
+#endif
+		return false;
+	}
+	catch (...)
+	{
+		_log.Log(LOG_ERROR, "KMTronic: Error opening serial port!!!");
+		return false;
+	}
+	m_bIsStarted = true;
+	m_bufferpos = 0;
+	setReadCallback(boost::bind(&KMTronicSerial::readCallback, this, _1, _2));
+	sOnConnected(this);
+	return true;
+}
+
+void KMTronicSerial::readCallback(const char *data, size_t len)
+{
+	boost::lock_guard<boost::mutex> l(readQueueMutex);
+	if (!m_bIsStarted)
+		return;
+
+	if (len > sizeof(m_buffer))
+		return;
+
+	m_bHaveReceived = true;
+
+	if (!m_bEnableReceive)
+		return; //receiving not enabled
+
+	memcpy(m_buffer, data, len);
+	m_bufferpos = len;
+}
+
+bool KMTronicSerial::WriteInt(const unsigned char *data, const size_t len, const bool bWaitForReturn)
+{
+	if (!isOpen())
+		return false;
+	m_bHaveReceived = false;
+	write((const char*)data, len);
+	if (!bWaitForReturn)
+		return true;
+	sleep_milliseconds(100);
+	return (m_bHaveReceived == true);
+}
+
+void KMTronicSerial::GetRelayStates()
+{
+	unsigned char SendBuf[3];
+	int ii;
+
+	//First check if we are the 4/8 version
+	SendBuf[0] = 0xFF;
+	SendBuf[1] = 0x09;
+	SendBuf[2] = 0x00;
+
+	if (WriteInt(SendBuf, 3, true))
+	{
+		if (m_bufferpos > Max_KMTronic_Relais)
+			m_bufferpos = Max_KMTronic_Relais;
+		for (ii = 0; ii < m_bufferpos; ii++)
+		{
+			bool bIsOn = (m_buffer[ii] == 1);
+			if (m_bRelaisStatus[ii] != bIsOn)
+			{
+				m_bRelaisStatus[ii] = bIsOn;
+			}
+			std::stringstream sstr;
+			sstr << "Relay " << (ii + 1);
+			SendSwitch(ii + 1, 1, 255, bIsOn, (bIsOn) ? 100 : 0, sstr.str());
+		}
+		return;
+	}
+	SendBuf[0] = 0xFF;
+	SendBuf[2] = 0x03;
+	for (ii = 0; ii < Max_KMTronic_Relais; ii++)
+	{
+		SendBuf[1] = ii+1;
+		if (WriteInt(SendBuf, 3,true))
+		{
+			if (m_bufferpos == 3)
+			{
+				if (m_buffer[1] == (ii + 1))
+				{
+					bool bIsOn = (m_buffer[2] == 1);
+					if (m_bRelaisStatus[ii] != bIsOn)
+					{
+						m_bRelaisStatus[ii] = bIsOn;
+					}
+					std::stringstream sstr;
+					sstr << "Relay " << (ii+1);
+					SendSwitch(ii + 1, 1, 255, bIsOn, (bIsOn) ? 100 : 0, sstr.str());
+				}
+			}
+			else
+			{
+				_log.Log(LOG_ERROR, "KMTronic: Invalid data received!");
+			}
+		}
+		else
+		{
+			if (m_TotRelais == 0)
+			{
+				m_TotRelais = ii;
+			}
+			return;
+		}
+	}
+}