public/openhab-addons
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added migrated 2.x add-ons

Browse Source 
Signed-off-by: Kai Kreuzer <kai@openhab.org>
This commit is contained in:
Kai Kreuzer
2020-09-21 01:58:32 +02:00
parent bbf1a7fd29
commit 6df6783b60
11662 changed files with 1302875 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

696
bundles/org.openhab.binding.nibeheatpump/contrib/NibeGW/RasPi/nibegw.c Normal file
View File

@@ -0,0 +1,696 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*
* ----------------------------------------------------------------------------
*
* This application listening data from Nibe F1145/F1245/F1155/F1255 heat pumps (RS485 bus)
* and send valid frames to configurable IP/port address by UDP packets.
* Application also acknowledge the valid packets to heat pump.
*
* Serial settings: 9600 baud, 8 bits, Parity: none, Stop bits 1
*
* MODBUS module support should be turned ON from the heat pump.
*
* Frame format:
* +----+----+------+-----+-----+----+----+-----+
* | 5C | 00 | ADDR | CMD | LEN | DATA | CHK |
* +----+----+------+-----+-----+----+----+-----+
*
* |------------ CHK -----------|
*
* Address:
* 0x16 = SMS40
* 0x19 = RMU40
* 0x20 = MODBUS40
*
* Checksum: XOR
*
* When valid data is received (checksum ok),
* ACK (0x06) should be sent to the heat pump.
* When checksum mismatch,
* NAK (0x15) should be sent to the heat pump.
*
* If heat pump does not receive acknowledge in certain time period,
* pump will raise an alarm and alarm mode is activated.
*
* Author: pauli.anttila@gmail.com
*
* Build: gcc -std=gnu99 -o nibegw nibegw.c
*
* 3.2.2013 v1.00 Initial version
* 5.2.2013 v1.01
* 4.11.2013 v1.02 Support cheksum and data special cases.
* 20.12.2013 v1.03 Fixed compiling error.
* 3.6.2014 v1.04
* 4.6.2014 v1.10 More options.
* 10.9.2014 v1.20 Bidirectional support.
* 30.6.2015 v1.21 Some fixes.
* 20.2.2017 v1.22 Separated read and write token support.
*/
#include <signal.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/time.h>
#define VERSION "1.22"
#define FALSE 0
#define TRUE 1
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
int verbose = 0;
int testmode = FALSE;
void signalCallbackHandler(int signum)
{
if (verbose) printf("\nExit...caught by signal %d\n", signum);
exit(1);
}
int initSerialPort(int fd, int hwflowctrl)
{
struct termios options;
// Get the current options for the port...
tcgetattr(fd, &options);
// Set the baud rates
cfsetispeed(&options, B9600);
cfsetospeed(&options, B9600);
// Enable the receiver and set local mode...
options.c_cflag |= (CLOCAL | CREAD);
// 8 data bits, no parity, 1 stop bit
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;
// Flow control
options.c_iflag &= ~(IXON | IXOFF | IXANY);
if (hwflowctrl)
options.c_cflag |= CRTSCTS; // Enable hardware flow control
else
options.c_cflag &= ~CRTSCTS; // Disable hardware flow control
options.c_cc[VMIN] = 1; // Min character to be read
options.c_cc[VTIME] = 1; // Time to wait for data (tenth of seconds)
// Set the new options
if (tcsetattr(fd, TCSANOW, &options) < 0 )
{
return -1;
}
return 0;
}
void printMessage(const unsigned char* const message, int msglen)
{
printf("Data: ");
for (int l = 0; l < msglen; l++)
printf("%02X", message[l]);
printf("\n");
}
int writeDataToSerialPort(int fd, const unsigned char* const message, int msglen)
{
int retval = -1;
if (verbose > 2) printf("Write data to serial port\n");
if (verbose > 2) printMessage(message, msglen);
if( write( fd, message, msglen) == msglen)
{
tcdrain (fd);
retval = 0;
}
return retval;
}
int forwardUdpMsgToSerial(int udpfd, int serialfd)
{
#define MAX_UDP_MSG_SIZE 50
unsigned char udp_packet[MAX_UDP_MSG_SIZE];
int udplen;
if ((udplen = recv(udpfd, udp_packet, MAX_UDP_MSG_SIZE, 0)) > 0)
{
if (verbose > 1) printf("Received UDP message...relay message to serial port\n");
if (verbose > 2) printMessage( udp_packet, udplen);
writeDataToSerialPort(serialfd, udp_packet, udplen);
return FALSE;
}
return TRUE;
}
int sendAck(int fd)
{
unsigned char ack = 0x06;
if (verbose > 1) printf("Send ACK (0x06)\n");
return writeDataToSerialPort(fd, &ack, 1);
}
int sendNak(int fd)
{
unsigned char nack = 0x15;
if (verbose > 1) printf("Send NAK (0x15)\n");
return writeDataToSerialPort(fd, &nack, 1);
}
char* getTimeStamp(char* buffer)
{
struct timeval tv;
struct timezone tz;
struct tm* tm;
gettimeofday(&tv, &tz);
tm = localtime(&tv.tv_sec);
sprintf(buffer, "%d.%d.%d %d:%02d:%02d:%d",
tm->tm_year + 1900,
tm->tm_mon + 1,
tm->tm_mday,
tm->tm_hour,
tm->tm_min, tm->tm_sec, tv.tv_usec
);
return buffer;
}
ssize_t readData(int fildes, void *buf, size_t nbyte)
{
if (testmode)
{
unsigned char testdata[] =
/* Junk */
"\x01\x02" \
/* Frame from MODBUS40 */
"\x5C\x00\x20\x6B\x00\x4B" \
/* Frame from RMU40 */
"\x5C\x00\x19\x60\x00\x79" \
/* Frame from RMU40 */
"\x5C\x00\x19\x62\x18\x00\x80\x00\x80\x00\x00\x00\x00\x00"
"\x80\x00\x00\x00\x00\x00\x0B\x0B\x00\x00\x00\x01\x00\x00"
"\x05\xE7" \
/* Data frame from MODBUS40 */
"\x5C\x00\x20\x68\x50\x01\xA8\x1F\x01\x00\xA8\x64\x00\xFD" \
"\xA7\xD0\x03\x44\x9C\x1E\x00\x4F\x9C\xA0\x00\x50\x9C\x78" \
"\x00\x51\x9C\x03\x01\x52\x9C\x1B\x01\x87\x9C\x14\x01\x4E" \
"\x9C\xC6\x01\x47\x9C\x01\x01\x15\xB9\xB0\xFF\x3A\xB9\x4B" \
"\x00\xC9\xAF\x00\x00\x48\x9C\x0D\x01\x4C\x9C\xE7\x00\x4B" \
"\x9C\x00\x00\xFF\xFF\x00\x00\xFF\xFF\x00\x00\xFF\xFF\x00" \
"\x00\x45" \
/* Token Frame from MODBUS40 */
"\x5C\x00\x20\x69\x00\x49" \
;
int len = sizeof(testdata);
if (len > nbyte)
{
fprintf(stderr, "Too much test data, limiting %u to %u\n", len, (unsigned int)nbyte);
}
len = MIN(len, nbyte);
memcpy( buf, testdata, len);
static int delay = FALSE;
if (delay)
sleep(2); // slow down little bit after first round
delay = TRUE;
return len;
}
return read(fildes, buf, nbyte);
}
/*
* Return:
* >0 if valid message received (return message len)
* 0 if OK but message not ready
* -1 if invalid message
* -2 if checksum fails
*/
int checkMessage(const unsigned char* const data, int len)
{
if (len >= 1)
{
if (data[0] != 0x5C)
return -1;
if (len >= 2)
{
if (data[1] != 0x00)
return -1;
}
if (len >= 6)
{
int datalen = data[4];
if (len < datalen + 6)
return 0;
unsigned char calc_checksum = 0;
// calculate XOR checksum
for(int i = 2; i < (datalen + 5); i++)
calc_checksum ^= data[i];
unsigned char msg_checksum = data[datalen + 5];
if (verbose) printf("(calc/recv checksum %02X/%02X = ", calc_checksum, msg_checksum);
if (calc_checksum != msg_checksum)
{
// check special case, if checksum is 0x5C (start character),
// heat pump seems to send 0xC5 checksum
if (calc_checksum != 0x5C && msg_checksum != 0xC5)
{
if (verbose) printf("ERROR)\n");
return -2;
}
}
if (verbose) printf("OK)\n");
return datalen + 6;
}
}
return 0;
}
void printUsage(char* appname)
{
char* usage = "%s usage:\n\n" \
"\t-h Print help\n" \
"\t-v Print debug information\n" \
"\t-d <device name> Serial port device (default: /dev/ttyS0)\n" \
"\t-a <address> Remote host address (default: 127.0.0.1)\n" \
"\t-p <port> Remote UDP port (default: 9999)\n" \
"\t-f Disable flow control (default: HW)\n" \
"\t-r <address> RS-485 address to listen (default: 0x20)\n" \
"\t-i Send all messages by UDP (default: only modbus data)\n" \
"\t-n Don't send acknowledge at all\n" \
"\t-o Send acknowledge to all addresses\n" \
"\t-t Test mode\n" \
"\t-l <port> Local UDP port for read commands (default: 10000)\n" \
"\t-w <port> Local UDP port for write commands (default: 10001)\n" \
"\t-q Print data in log format\n" \
;
fprintf (stderr, usage, appname);
}
int main(int argc, char **argv)
{
char *device = "/dev/ttySO";
char *remoteHost = "127.0.0.1";
int remotePort = 9999;
int localPort4readCmds = 10000;
int localPort4writeCmds = 10001;
unsigned char rs485addr = 0x20;
int sendall = FALSE;
int sendack = TRUE;
int ackall = FALSE;
int hwflowctrl = TRUE;
int log = FALSE;
int c;
opterr = 0;
while ((c = getopt (argc, argv, "hvd:a:p:r:infotql:w:")) != -1)
{
switch (c)
{
case 'v':
verbose++;
break;
case 'i':
sendall = TRUE;
break;
case 'n':
sendack = FALSE;
break;
case 'f':
hwflowctrl = FALSE;
break;
case 'o':
ackall = TRUE;
break;
case 't':
testmode = TRUE;
break;
case 'q':
log = TRUE;
break;
case 'd':
device = optarg;
break;
case 'a':
remoteHost = optarg;
break;
case 'p':
remotePort = atoi(optarg);
break;
case 'l':
localPort4readCmds = atoi(optarg);
break;
case 'w':
localPort4writeCmds = atoi(optarg);
break;
case 'r':
rs485addr = atoi(optarg);
break;
case '?':
if (optopt == 'd' || optopt == 'a' || optopt == 'p')
fprintf (stderr, "Option -%c requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
return 1;
case 'h':
default:
printUsage(argv[0]);
return 1;
}
}
if (verbose)
{
printf("NibeGW version: %s\n", VERSION);
printf("Verbose level: %i\n", verbose);
printf("Test mode: %s\n", testmode ? "TRUE" : "FALSE");
printf("Serial port: %s\n", device);
printf("Flow control: %s\n", hwflowctrl ? "HW" : "None");
printf("remote UDP address: %s:%u\n", remoteHost, remotePort);
printf("server UDP address for read cmds: %u\n", localPort4readCmds);
printf("server UDP address for write cmds: %u\n", localPort4writeCmds);
printf("RS-485 address to listen: 0x%02X\n", rs485addr);
printf("Send all messages by UDP: %s\n", sendall ? "TRUE" : "FALSE");
printf("Send acknowledge: %s\n", sendack ? "TRUE" : "FALSE");
printf("Send acknowledge to all addresses: %s\n", ackall ? "TRUE" : "FALSE");
}
// Install signal handlers
signal(SIGINT, signalCallbackHandler);
int serialport_fd = -1;
int udp_fd = -1;
int udp4writeCmds_fd = -1;
// Initialize destination address
struct sockaddr_in dest;
memset((char *)&dest, 0, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_addr.s_addr = inet_addr(remoteHost);
dest.sin_port = htons(remotePort);
// Initialize server address for read commands
struct sockaddr_in server4read;
memset((char *)&server4read, 0, sizeof(server4read));
server4read.sin_family = AF_INET;
server4read.sin_addr.s_addr = htonl(INADDR_ANY);
server4read.sin_port = htons(localPort4readCmds);
// Initialize server address for write commands
struct sockaddr_in server4write;
memset((char *)&server4write, 0, sizeof(server4write));
server4write.sin_family = AF_INET;
server4write.sin_addr.s_addr = htonl(INADDR_ANY);
server4write.sin_port = htons(localPort4writeCmds);
int maxdatalen = 200;
if (testmode)
{
maxdatalen = 1000;
}
unsigned char buffer[maxdatalen];
unsigned char message[maxdatalen];
for (;;)
{
if (testmode == FALSE && serialport_fd < 0)
{
if (strncmp(device, "stdin" , 5) == 0)
{
if (verbose) printf("Use stdin as virtual serial port\n");
serialport_fd = STDIN_FILENO;
}
else
{
// Open the serial port
if (verbose) printf("Open serial port: %s\n", device);
serialport_fd = open(device, O_RDWR | O_NOCTTY); // | O_NDELAY
if (serialport_fd < 0)
{
fprintf(stderr, "Failed to open %s: %s\n", device, strerror(errno));
}
// Initialize serial port
if (initSerialPort(serialport_fd, hwflowctrl) == -1)
{
fprintf(stderr, "Failed to set serial port: %s\n", strerror(errno));
}
}
}
if ( udp_fd < 0 )
{
// Open UDP socket
udp_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (udp_fd < 0)
{
fprintf(stderr, "Failed to open UDP socket for read commands: %s\n", strerror(errno));
}
if (verbose) printf("Initialize UDP server\n");
// Set non blocking flag to UDP socket
int flags = fcntl(udp_fd, F_GETFL, 0);
fcntl(udp_fd, F_SETFL, flags | O_NONBLOCK);
//bind socket to port
if( bind(udp_fd, (struct sockaddr*)&server4read, sizeof(server4read) ) == -1)
{
fprintf(stderr, "Failed to bind UDP port for read commands: %s\n", strerror(errno));
}
}
if ( udp4writeCmds_fd < 0 )
{
// Open UDP socket
udp4writeCmds_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (udp4writeCmds_fd < 0)
{
fprintf(stderr, "Failed to open UDP socket for write commands: %s\n", strerror(errno));
}
if (verbose) printf("Initialize UDP server\n");
// Set non blocking flag to UDP socket
int flags = fcntl(udp4writeCmds_fd, F_GETFL, 0);
fcntl(udp4writeCmds_fd, F_SETFL, flags | O_NONBLOCK);
//bind socket to port
if( bind(udp4writeCmds_fd, (struct sockaddr*)&server4write, sizeof(server4write) ) == -1)
{
fprintf(stderr, "Failed to bind UDP port for write commands: %s\n", strerror(errno));
}
}
if (testmode || serialport_fd >= 0)
{
char timestamp[80];
ssize_t len = 0;
int startfound = FALSE;
int index = 0;
// read all available bytes from serial port
while ((len = readData(serialport_fd, buffer, maxdatalen)) > 0)
{
// go throw all bytes read from serial port
for (int i = 0; i < len; i++)
{
if (log) printf("\\x%02X", buffer[i]);
if (startfound == FALSE)
{
if (verbose) printf("\n%s: ", getTimeStamp(timestamp));
}
if (verbose) printf("%02X ", buffer[i]);
if (verbose > 3) printf("(%c) ", buffer[i]);
if (startfound == FALSE && buffer[i] == 0x5C)
{
startfound = TRUE;
index = 0;
}
if (startfound)
{
if ((index+1) >= maxdatalen)
{
// too long message, try to find new start char
startfound = FALSE;
}
else
{
message[index++] = buffer[i];
int msglen = checkMessage(message, index);
switch (msglen)
{
case 0: // Message ok so far, but not ready
break;
case -1: // Invalid message
startfound = FALSE;
break;
case -2: // Checksum error
if (message[2] == rs485addr || ackall)
{
if (sendack) sendNak(serialport_fd);
}
startfound = FALSE;
break;
default:
if (verbose > 1) printf("Valid message received, len=%u\n", msglen);
if (message[2] == rs485addr || ackall)
{
// send ack to nibe or read/write messages if token received
int nothingToSend = TRUE;
if (message[3] == 0x69 && message[4] == 0x00)
{
if (verbose > 1) printf("Read token received\n");
nothingToSend = forwardUdpMsgToSerial(udp_fd, serialport_fd);
}
else if (message[3] == 0x6b && message[4] == 0x00) {
if (verbose > 1) printf("Write token received\n");
nothingToSend = forwardUdpMsgToSerial(udp4writeCmds_fd, serialport_fd);
}
if (nothingToSend)
{
if (verbose > 1) printf("Nothing to send...");
if (sendack) sendAck(serialport_fd);
}
}
if (message[2] == rs485addr || sendall)
{
// send message to remote
if (verbose > 1) printf("Send UDP data to %s:%u\n", remoteHost, remotePort);
if (verbose > 2) printMessage( message, msglen);
if (sendto(udp_fd, message, msglen + 1, 0 , (struct sockaddr *)&dest, sizeof(dest)) == -1)
{
fprintf(stderr, "Failed to send udp packet: %s\n", strerror(errno));
}
}
// Wait new message
startfound = FALSE;
break;
}
}
}
}
}
if (len < 0)
{
if (errno == EINTR)
{
if (verbose) printf("Interrupted\n");
break;
}
else
{
fprintf(stderr, "Read failed: %s\n", strerror(errno));
sleep(1);
}
}
if (log) fflush(stdout);
}
else
{
sleep(1);
}
}
close(serialport_fd);
close(udp_fd);
close(udp4writeCmds_fd);
return 0;
}