nils/ebusd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
046864381701aff9d85c4fd4a50c425d5cf4a729
ebusd/src/lib/ebus/device.cpp
T

1014 lines
30 KiB
C++
Executable File
Raw Blame History

/*
* ebusd - daemon for communication with eBUS heating systems.
* Copyright (C) 2015-2023 John Baier <ebusd@ebusd.eu>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "lib/ebus/device.h"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <netinet/in.h>
#ifdef HAVE_LINUX_SERIAL
# include <linux/serial.h>
#endif
#ifdef HAVE_FREEBSD_UFTDI
# include <dev/usb/uftdiio.h>
#endif
#ifdef HAVE_PPOLL
# include <poll.h>
#endif
#include <cstdlib>
#include <cstring>
#include <string>
#include <fstream>
#include <ios>
#include <iomanip>
#include "lib/ebus/data.h"
#include "lib/utils/clock.h"
#include "lib/utils/tcpsocket.h"
namespace ebusd {
using std::hex;
using std::dec;
using std::setfill;
using std::setw;
using std::setprecision;
using std::fixed;
#define MTU 1540
#ifndef POLLRDHUP
#define POLLRDHUP 0
#endif
// ebusd enhanced protocol IDs:
#define ENH_REQ_INIT ((uint8_t)0x0)
#define ENH_RES_RESETTED ((uint8_t)0x0)
#define ENH_REQ_SEND ((uint8_t)0x1)
#define ENH_RES_RECEIVED ((uint8_t)0x1)
#define ENH_REQ_START ((uint8_t)0x2)
#define ENH_RES_STARTED ((uint8_t)0x2)
#define ENH_REQ_INFO ((uint8_t)0x3)
#define ENH_RES_INFO ((uint8_t)0x3)
#define ENH_RES_FAILED ((uint8_t)0xa)
#define ENH_RES_ERROR_EBUS ((uint8_t)0xb)
#define ENH_RES_ERROR_HOST ((uint8_t)0xc)
// ebusd enhanced error codes for the ERROR_* responses
#define ENH_ERR_FRAMING ((uint8_t)0x00)
#define ENH_ERR_OVERRUN ((uint8_t)0x01)
#define ENH_BYTE_FLAG ((uint8_t)0x80)
#define ENH_BYTE_MASK ((uint8_t)0xc0)
#define ENH_BYTE1 ((uint8_t)0xc0)
#define ENH_BYTE2 ((uint8_t)0x80)
#define makeEnhancedByte1(cmd, data) (uint8_t)(ENH_BYTE1 | ((cmd)<<2) | (((data)&0xc0)>>6))
#define makeEnhancedByte2(cmd, data) (uint8_t)(ENH_BYTE2 | ((data)&0x3f))
#define makeEnhancedSequence(cmd, data) {makeEnhancedByte1(cmd, data), makeEnhancedByte2(cmd, data)}
#ifdef DEBUG_RAW_TRAFFIC
#define DEBUG_RAW_TRAFFIC_HEAD(format, args...) fprintf(stdout, "%lld raw: " format, clockGetMillis(), args)
#define DEBUG_RAW_TRAFFIC_ITEM(args...) fprintf(stdout, args)
#define DEBUG_RAW_TRAFFIC_FINAL() fprintf(stdout, "\n"); fflush(stdout)
#undef DEBUG_RAW_TRAFFIC
#define DEBUG_RAW_TRAFFIC(format, args...) fprintf(stdout, "%lld raw: " format "\n", clockGetMillis(), args); fflush(stdout)
#else
#define DEBUG_RAW_TRAFFIC_HEAD(format, args...)
#undef DEBUG_RAW_TRAFFIC_ITEM
#define DEBUG_RAW_TRAFFIC_FINAL()
#define DEBUG_RAW_TRAFFIC(format, args...)
#endif
Device::Device(const char* name)
: m_name(name), m_listener(nullptr) {
}
Device* Device::create(const char* name, unsigned int extraLatency, bool checkDevice) {
EnhancedLevel enhanced = el_none;
if (strncmp(name, "en", 2) == 0 && name[2] && name[3] == ':') {
switch (name[2]) {
case 's':
enhanced = el_speed;
break;
case 'h':
enhanced = el_basic;
break;
}
if (enhanced) {
name += 4;
}
}
if (strchr(name, '/') == nullptr && strchr(name, ':') != nullptr) {
char* in = strdup(name);
bool udp = false;
char* addrpos = in;
char* portpos = strchr(addrpos, ':');
// support tcp:<ip>:<port> and udp:<ip>:<port>
if (portpos == addrpos+3 && (strncmp(addrpos, "tcp", 3) == 0 || (udp=(strncmp(addrpos, "udp", 3) == 0)))) {
addrpos += 4;
portpos = strchr(addrpos, ':');
}
if (portpos == nullptr) {
free(in);
return nullptr; // invalid protocol or missing port
}
result_t result = RESULT_OK;
uint16_t port = (uint16_t)parseInt(portpos+1, 10, 1, 65535, &result);
if (result != RESULT_OK) {
free(in);
return nullptr; // invalid port
}
*portpos = 0;
char* hostOrIp = strdup(addrpos);
free(in);
return new NetworkDevice(name, hostOrIp, port, extraLatency, udp, enhanced);
}
// support enh:/dev/<device>, ens:/dev/<device>, and /dev/<device>
return new SerialDevice(name, checkDevice, extraLatency, enhanced);
}
FileDevice::FileDevice(const char* name, bool checkDevice, unsigned int latency,
EnhancedLevel enhancedLevel)
: Device(name),
m_checkDevice(checkDevice),
m_latency(HOST_LATENCY_MS+(enhancedLevel?ENHANCED_LATENCY_MS:0)+latency),
m_enhancedLevel(enhancedLevel), m_fd(-1), m_resetRequested(false),
m_arbitrationMaster(SYN),
m_arbitrationCheck(0), m_bufSize(((MAX_LEN+1+3)/4)*4), m_bufLen(0), m_bufPos(0),
m_extraFatures(0), m_infoId(0xff), m_infoReqTime(0), m_infoLen(0), m_infoPos(0) {
m_buffer = reinterpret_cast<symbol_t*>(malloc(m_bufSize));
if (!m_buffer) {
m_bufSize = 0;
}
}
FileDevice::~FileDevice() {
close();
if (m_buffer) {
free(m_buffer);
m_buffer = nullptr;
}
}
void FileDevice::formatInfo(ostringstream* ostream, bool verbose, bool prefix) {
if (prefix) {
*ostream << m_name;
string info = getEnhancedProtoInfo();
if (!info.empty()) {
*ostream << ", " << info;
}
return;
}
if (!isValid()) {
*ostream << ", invalid";
}
if (!m_enhancedLevel) {
return;
}
bool infoAdded = false;
if (verbose) {
string info = getEnhancedInfos();
if (!info.empty()) {
*ostream << ", " << info;
infoAdded = true;
}
}
if (!infoAdded) {
string ver = getEnhancedVersion();
if (!ver.empty()) {
*ostream << ", firmware " << ver;
}
}
}
void FileDevice::formatInfoJson(ostringstream* ostream) {
if (m_enhancedLevel) {
string ver = getEnhancedVersion();
if (!ver.empty()) {
*ostream << ",\"dv\":\"" << ver << "\"";
}
}
}
result_t FileDevice::open() {
close();
return m_bufSize == 0 ? RESULT_ERR_DEVICE : RESULT_OK;
}
result_t FileDevice::afterOpen() {
if (m_enhancedLevel) {
symbol_t buf[2] = makeEnhancedSequence(ENH_REQ_INIT, 0x01); // extra feature: info
DEBUG_RAW_TRAFFIC("enhanced > %2.2x %2.2x", buf[0], buf[1]);
if (::write(m_fd, buf, 2) != 2) {
return RESULT_ERR_SEND;
}
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(false, "resetting");
}
m_resetRequested = true;
}
return RESULT_OK;
}
void FileDevice::close() {
if (m_fd != -1) {
::close(m_fd);
m_fd = -1;
}
m_bufLen = 0; // flush read buffer
m_extraFatures = 0; // reset state
}
bool FileDevice::isValid() {
if (m_fd == -1) {
return false;
}
if (m_checkDevice) {
checkDevice();
}
return m_fd != -1;
}
result_t FileDevice::requestEnhancedInfo(symbol_t infoId) {
if (!m_enhancedLevel || m_extraFatures == 0) {
return RESULT_ERR_INVALID_ARG;
}
for (unsigned int i = 0; i < 4; i++) {
if (m_infoId == 0xff) {
break;
}
usleep(40000 + i*40000);
}
if (m_infoId != 0xff) {
if (m_infoReqTime > 0 && time(NULL) > m_infoReqTime+5) {
// request timed out
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(false, "info request timed out");
}
m_infoId = 0xff;
m_infoReqTime = 0;
} else {
return RESULT_ERR_DUPLICATE;
}
}
if (infoId == 0xff) {
// just waited for completion
return RESULT_OK;
}
return sendEnhancedInfoRequest(infoId);
}
result_t FileDevice::sendEnhancedInfoRequest(symbol_t infoId) {
symbol_t buf[2] = makeEnhancedSequence(ENH_REQ_INFO, infoId);
DEBUG_RAW_TRAFFIC("enhanced > %2.2x %2.2x", buf[0], buf[1]);
if (::write(m_fd, buf, 2) != 2) {
return RESULT_ERR_DEVICE;
}
m_infoPos = 0;
m_infoId = infoId;
time(&m_infoReqTime);
return RESULT_OK;
}
string FileDevice::getEnhancedInfos() {
if (!m_enhancedLevel || m_extraFatures == 0) {
return "";
}
result_t res;
string fails = "";
if (m_enhInfoTemperature.empty()) { // use empty temperature for potential refresh after reset
res = requestEnhancedInfo(0);
if (res != RESULT_OK) {
return "cannot request version";
}
res = requestEnhancedInfo(1);
if (res != RESULT_OK) {
return "cannot request ID";
}
res = requestEnhancedInfo(2);
if (res != RESULT_OK) {
fails += ", cannot request config";
requestEnhancedInfo(0xff); // wait for completion
m_infoPos = 0;
m_infoId = 0xff;
}
}
res = requestEnhancedInfo(6);
if (res != RESULT_OK) {
return "cannot request reset info";
}
res = requestEnhancedInfo(3);
if (res != RESULT_OK) {
return "cannot request temperature";
}
res = requestEnhancedInfo(4);
if (res != RESULT_OK) {
return "cannot request supply voltage";
}
res = requestEnhancedInfo(5);
if (res != RESULT_OK) {
fails += ", cannot request bus voltage";
}
res = requestEnhancedInfo(0xff); // wait for completion
if (res != RESULT_OK) {
m_enhInfoBusVoltage = "bus voltage unknown";
m_infoPos = 0;
m_infoId = 0xff;
}
return "firmware " + m_enhInfoVersion + ", " + m_enhInfoTemperature + ", " + m_enhInfoSupplyVoltage + ", "
+ m_enhInfoBusVoltage;
}
result_t FileDevice::send(symbol_t value) {
if (!isValid()) {
return RESULT_ERR_DEVICE;
}
if (!write(value)) {
return RESULT_ERR_SEND;
}
if (m_listener != nullptr) {
m_listener->notifyDeviceData(value, false);
}
return RESULT_OK;
}
/**
* the maximum duration in milliseconds to wait for an enhanced sequence to complete after the first part was already
* retrieved (3ms rounded up to the next 10ms): 2* (Start+8Bit+Stop+Extra @ 9600Bd)
*/
#define ENHANCED_COMPLETE_WAIT_DURATION 10
bool FileDevice::cancelRunningArbitration(ArbitrationState* arbitrationState) {
if (m_enhancedLevel && m_arbitrationMaster != SYN) {
*arbitrationState = as_error;
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
write(SYN, true);
return true;
}
if (m_enhancedLevel || m_arbitrationMaster == SYN) {
return false;
}
*arbitrationState = as_error;
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
return true;
}
result_t FileDevice::recv(unsigned int timeout, symbol_t* value, ArbitrationState* arbitrationState) {
if (m_arbitrationMaster != SYN) {
*arbitrationState = as_running;
}
if (!isValid()) {
cancelRunningArbitration(arbitrationState);
return RESULT_ERR_DEVICE;
}
bool repeated = false;
timeout += m_latency;
uint64_t until = clockGetMillis() + timeout;
do {
bool isAvailable = available();
if (!isAvailable && timeout > 0) {
int ret;
struct timespec tdiff;
// set select timeout
tdiff.tv_sec = timeout/1000;
tdiff.tv_nsec = (timeout%1000)*1000000;
#ifdef HAVE_PPOLL
nfds_t nfds = 1;
struct pollfd fds[nfds];
memset(fds, 0, sizeof(fds));
fds[0].fd = m_fd;
fds[0].events = POLLIN | POLLERR | POLLHUP | POLLRDHUP;
ret = ppoll(fds, nfds, &tdiff, nullptr);
if (ret >= 0 && fds[0].revents & (POLLERR | POLLHUP | POLLRDHUP)) {
ret = -1;
}
#else
#ifdef HAVE_PSELECT
fd_set readfds, exceptfds;
FD_ZERO(&readfds);
FD_ZERO(&exceptfds);
FD_SET(m_fd, &readfds);
ret = pselect(m_fd + 1, &readfds, nullptr, &exceptfds, &tdiff, nullptr);
if (ret >= 1 && FD_ISSET(m_fd, &exceptfds)) {
ret = -1;
}
#else
ret = 1; // ignore timeout if neither ppoll nor pselect are available
#endif
#endif
if (ret == -1) {
DEBUG_RAW_TRAFFIC("poll error %d", errno);
close();
cancelRunningArbitration(arbitrationState);
return RESULT_ERR_DEVICE;
}
if (ret == 0) {
return RESULT_ERR_TIMEOUT;
}
}
// directly read byte from device
bool incomplete = false;
if (read(value, isAvailable, arbitrationState, &incomplete)) {
break; // don't repeat on successful read
}
if (!isAvailable && incomplete && !repeated) {
// for a two-byte transfer another poll is needed
repeated = true;
timeout = m_latency+ENHANCED_COMPLETE_WAIT_DURATION;
continue;
}
uint64_t now = clockGetMillis();
if (now >= until) {
return RESULT_ERR_TIMEOUT;
}
timeout = static_cast<unsigned>(until - now);
} while (true);
if (m_enhancedLevel || *value != SYN || m_arbitrationMaster == SYN || m_arbitrationCheck) {
if (m_listener != nullptr) {
m_listener->notifyDeviceData(*value, true);
}
if (!m_enhancedLevel && m_arbitrationMaster != SYN) {
if (m_arbitrationCheck) {
*arbitrationState = *value == m_arbitrationMaster ? as_won : as_lost;
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
} else {
*arbitrationState = m_arbitrationMaster == SYN ? as_none : as_start;
}
}
return RESULT_OK;
}
// non-enhanced: arbitration executed by ebusd itself
bool wrote = write(m_arbitrationMaster); // send as fast as possible
if (m_listener != nullptr) {
m_listener->notifyDeviceData(*value, true);
}
if (!wrote) {
cancelRunningArbitration(arbitrationState);
return RESULT_OK;
}
if (m_listener != nullptr) {
m_listener->notifyDeviceData(m_arbitrationMaster, false);
}
m_arbitrationCheck = 1;
*arbitrationState = as_running;
return RESULT_OK;
}
result_t FileDevice::startArbitration(symbol_t masterAddress) {
if (m_arbitrationCheck) {
if (masterAddress != SYN) {
return RESULT_ERR_ARB_RUNNING; // should not occur
}
m_arbitrationCheck = 0;
m_arbitrationMaster = SYN;
if (m_enhancedLevel) {
// cancel running arbitration
if (!write(SYN, true)) {
return RESULT_ERR_SEND;
}
}
return RESULT_OK;
}
m_arbitrationMaster = masterAddress;
if (m_enhancedLevel && masterAddress != SYN) {
if (!write(masterAddress, true)) {
m_arbitrationMaster = SYN;
return RESULT_ERR_SEND;
}
m_arbitrationCheck = 1;
}
return RESULT_OK;
}
bool FileDevice::write(symbol_t value, bool startArbitration) {
if (m_enhancedLevel) {
symbol_t buf[2] = makeEnhancedSequence(startArbitration ? ENH_REQ_START : ENH_REQ_SEND, value);
DEBUG_RAW_TRAFFIC("enhanced > %2.2x %2.2x", buf[0], buf[1]);
return ::write(m_fd, buf, 2) == 2;
}
DEBUG_RAW_TRAFFIC("> %2.2x", value);
#ifdef SIMULATE_NON_WRITABILITY
return true;
#else
return ::write(m_fd, &value, 1) == 1;
#endif
}
bool FileDevice::available() {
if (m_bufLen <= 0) {
return false;
}
if (!m_enhancedLevel) {
return true;
}
// peek into the received enhanced proto bytes to determine received bus symbol availability
for (size_t pos = 0; pos < m_bufLen; pos++) {
symbol_t ch = m_buffer[(pos+m_bufPos)%m_bufSize];
if (!(ch&ENH_BYTE_FLAG)) {
DEBUG_RAW_TRAFFIC("avail direct @%d+%d %2.2x", m_bufPos, pos, ch);
return true;
}
if ((ch&ENH_BYTE_MASK) == ENH_BYTE1) {
if (pos+1 >= m_bufLen) {
return false;
}
symbol_t cmd = (ch >> 2)&0xf;
// peek into next byte to check if enhanced sequence is ok
ch = m_buffer[(pos+m_bufPos+1)%m_bufSize];
if (!(ch&ENH_BYTE_FLAG) || (ch&ENH_BYTE_MASK) != ENH_BYTE2) {
DEBUG_RAW_TRAFFIC("avail enhanced following bad @%d+%d %2.2x %2.2x", m_bufPos, pos,
m_buffer[(pos+m_bufPos)%m_bufSize], ch);
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(true, "unexpected available enhanced following byte 1");
}
// drop first byte of invalid sequence
m_bufPos = (m_bufPos + 1) % m_bufSize;
m_bufLen--;
pos--; // check same pos again
continue;
}
if (cmd == ENH_RES_RECEIVED || cmd == ENH_RES_STARTED || cmd == ENH_RES_FAILED) {
// found a sequence that yields in available bus byte
DEBUG_RAW_TRAFFIC("avail enhanced @%d+%d %2.2x %2.2x", m_bufPos, pos, m_buffer[(pos+m_bufPos)%m_bufSize], ch);
return true;
}
DEBUG_RAW_TRAFFIC("avail enhanced skip cmd %d @%d+%d %2.2x", cmd, m_bufPos, pos, ch);
pos++; // skip enhanced sequence of 2 bytes
continue;
}
DEBUG_RAW_TRAFFIC("avail enhanced bad @%d+%d %2.2x", m_bufPos, pos, ch);
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(true, "unexpected available enhanced byte 2");
}
// skip byte from erroneous protocol
m_bufPos = (m_bufPos+1)%m_bufSize;
m_bufLen--;
pos--; // check byte 2 again from scratch and allow as byte 1
}
return false;
}
bool FileDevice::read(symbol_t* value, bool isAvailable, ArbitrationState* arbitrationState, bool* incomplete) {
if (!isAvailable) {
if (m_bufLen > 0 && m_bufPos != 0) {
if (m_bufLen > m_bufSize / 2) {
// more than half of input buffer consumed is taken as signal that ebusd is too slow
m_bufLen = 0;
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(true, "buffer overflow");
}
} else {
size_t tail;
if (m_bufPos+m_bufLen > m_bufSize) {
// move wrapped tail away
tail = (m_bufPos+m_bufLen) % m_bufSize;
size_t head = m_bufLen-tail;
memmove(m_buffer+head, m_buffer, tail);
DEBUG_RAW_TRAFFIC("move tail %d @0 to @%d", tail, head);
} else {
tail = 0;
}
// move head to first position
memmove(m_buffer, m_buffer + m_bufPos, m_bufLen - tail);
DEBUG_RAW_TRAFFIC("move head %d @%d to 0", m_bufLen - tail, m_bufPos);
}
}
m_bufPos = 0;
// fill up the buffer
ssize_t size = ::read(m_fd, m_buffer + m_bufLen, m_bufSize - m_bufLen);
if (size <= 0) {
return false;
}
#ifdef DEBUG_RAW_TRAFFIC_ITEM
DEBUG_RAW_TRAFFIC_HEAD("%d+%d <", m_bufLen, size);
for (int pos=0; pos < size; pos++) {
DEBUG_RAW_TRAFFIC_ITEM(" %2.2x", m_buffer[(m_bufLen+pos)%m_bufSize]);
}
DEBUG_RAW_TRAFFIC_FINAL();
#endif
m_bufLen += size;
}
if (m_enhancedLevel) {
if (handleEnhancedBufferedData(value, arbitrationState)) {
return true;
}
}
if (!available()) {
if (incomplete) {
*incomplete = m_enhancedLevel && m_bufLen > 0;
}
return false;
}
if (!m_enhancedLevel) {
*value = m_buffer[m_bufPos];
m_bufPos = (m_bufPos+1)%m_bufSize;
m_bufLen--;
return true;
}
return handleEnhancedBufferedData(value, arbitrationState);
}
bool FileDevice::handleEnhancedBufferedData(symbol_t* value, ArbitrationState* arbitrationState) {
while (m_bufLen > 0) {
symbol_t ch = m_buffer[m_bufPos];
if (!(ch&ENH_BYTE_FLAG)) {
*value = ch;
m_bufPos = (m_bufPos+1)%m_bufSize;
m_bufLen--;
return true;
}
uint8_t kind = ch&ENH_BYTE_MASK;
if (kind == ENH_BYTE1 && m_bufLen < 2) {
return false; // transfer not complete yet
}
m_bufPos = (m_bufPos+1)%m_bufSize;
m_bufLen--;
if (kind == ENH_BYTE2) {
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(true, "unexpected enhanced byte 2");
}
return false;
}
// kind is ENH_BYTE1
symbol_t ch2 = m_buffer[m_bufPos];
m_bufPos = (m_bufPos + 1) % m_bufSize;
m_bufLen--;
if ((ch2 & ENH_BYTE_MASK) != ENH_BYTE2) {
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(true, "missing enhanced byte 2");
}
return false;
}
symbol_t data = (symbol_t)(((ch&0x03) << 6) | (ch2&0x3f));
symbol_t cmd = (ch >> 2)&0xf;
switch (cmd) {
case ENH_RES_STARTED:
*arbitrationState = as_won;
if (m_listener != NULL) {
m_listener->notifyDeviceData(data, false);
}
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
*value = data;
return true;
case ENH_RES_FAILED:
*arbitrationState = as_lost;
if (m_listener != NULL) {
m_listener->notifyDeviceData(m_arbitrationMaster, false);
}
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
*value = data;
return true;
case ENH_RES_RECEIVED:
*value = data;
if (data == SYN && *arbitrationState == as_running && m_arbitrationCheck) {
if (m_arbitrationCheck < 3) { // wait for three SYN symbols before switching to timeout
m_arbitrationCheck++;
} else {
*arbitrationState = as_timeout;
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
}
}
return true;
case ENH_RES_RESETTED:
if (*arbitrationState != as_none) {
*arbitrationState = as_error;
m_arbitrationMaster = SYN;
m_arbitrationCheck = 0;
}
m_enhInfoTemperature = "";
m_enhInfoSupplyVoltage = "";
m_enhInfoBusVoltage = "";
m_infoId = 0xff;
m_extraFatures = data;
if (m_resetRequested) {
m_resetRequested = false;
if (m_extraFatures&0x01) {
sendEnhancedInfoRequest(0); // request version, ignore result
}
} else {
close(); // on self-reset of device close and reopen it to have a clean startup
cancelRunningArbitration(arbitrationState);
}
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(false, (m_extraFatures&0x01) ? "reset, supports info" : "reset");
}
break;
case ENH_RES_INFO:
if (m_infoLen == 0) {
m_infoLen = data;
m_infoPos = 0;
} else if (m_infoPos < m_infoLen && m_infoPos < sizeof(m_infoBuf)) {
m_infoBuf[m_infoPos++] = data;
if (m_infoPos >= m_infoLen) {
notifyInfoRetrieved();
m_infoLen = 0;
m_infoId = 0xff;
}
} else {
m_infoLen = 0; // reset on invalid response
m_infoId = 0xff;
}
break;
case ENH_RES_ERROR_EBUS:
case ENH_RES_ERROR_HOST:
if (m_listener != nullptr) {
ostringstream stream;
stream << (cmd == ENH_RES_ERROR_EBUS ? "eBUS comm error: " : "host comm error: ");
switch (data) {
case ENH_ERR_FRAMING:
stream << "framing";
break;
case ENH_ERR_OVERRUN:
stream << "overrun";
break;
default:
stream << "unknown 0x" << setw(2) << setfill('0') << hex << static_cast<unsigned>(data);
break;
}
string str = stream.str();
m_listener->notifyDeviceStatus(true, str.c_str());
}
cancelRunningArbitration(arbitrationState);
break;
default:
if (m_listener != nullptr) {
ostringstream stream;
stream << "unexpected enhanced command 0x" << setw(2) << setfill('0') << hex
<< static_cast<unsigned>(cmd);
string str = stream.str();
m_listener->notifyDeviceStatus(true, str.c_str());
}
return false;
}
}
return false;
}
void FileDevice::notifyInfoRetrieved() {
symbol_t* data = m_infoBuf;
size_t len = m_infoLen;
symbol_t id = m_infoId;
unsigned int val;
ostringstream stream;
switch ((len << 8) | id) {
case 0x0200:
case 0x0500: // with firmware version and jumper info
case 0x0800: // with firmware version, jumper info, and bootloader version
stream << hex << static_cast<unsigned>(data[1]) // features mask
<< "." << static_cast<unsigned>(data[0]); // version minor
if (len >= 5) {
stream << "[" << setfill('0') << setw(2) << hex << static_cast<unsigned>(data[2])
<< setw(2) << static_cast<unsigned>(data[3]) << "]";
}
if (len >= 8) {
stream << "." << dec << static_cast<unsigned>(data[5]);
stream << "[" << setfill('0') << setw(2) << hex << static_cast<unsigned>(data[6])
<< setw(2) << static_cast<unsigned>(data[7]) << "]";
}
m_enhInfoVersion = stream.str();
stream.str(" ");
stream << "firmware " << m_enhInfoVersion;
if (len >= 5) {
stream << ", jumpers 0x" << setw(2) << static_cast<unsigned>(data[4]);
}
stream << setfill(' '); // reset
break;
case 0x0901:
case 0x0802:
case 0x0302:
stream << (id == 1 ? "ID" : "config");
stream << hex << setfill('0');
for (uint8_t pos = 0; pos < len; pos++) {
stream << " " << setw(2) << static_cast<unsigned>(data[pos]);
}
if (id == 2 && (data[2]&0x3f) != 0x3f) {
// non-default arbitration delay
val = (data[2]&0x3f)*10; // steps of 10us
stream << ", arbitration delay " << dec << static_cast<unsigned>(val) << " us";
}
break;
case 0x0203:
val = (static_cast<unsigned>(data[0]) << 8) | static_cast<unsigned>(data[1]);
stream << "temperature " << static_cast<unsigned>(val) << " °C";
m_enhInfoTemperature = stream.str();
break;
case 0x0204:
stream << "supply voltage ";
if (data[0] | data[1]) {
val = (static_cast<unsigned>(data[0]) << 8) | static_cast<unsigned>(data[1]);
stream << static_cast<unsigned>(val) << " mV";
} else {
stream << "unknown";
}
m_enhInfoSupplyVoltage = stream.str();
break;
case 0x0205:
stream << "bus voltage ";
if (data[0] | data[1]) {
stream << fixed << setprecision(1)
<< static_cast<float>(data[1] / 10.0) << " V - "
<< static_cast<float>(data[0] / 10.0) << " V";
} else {
stream << "unknown";
}
m_enhInfoBusVoltage = stream.str();
break;
case 0x0206:
stream << "reset cause ";
if (data[0]) {
stream << static_cast<unsigned>(data[0]) << "=";
switch (data[0]) {
case 1: stream << "power-on"; break;
case 2: stream << "brown-out"; break;
case 3: stream << "watchdog"; break;
case 4: stream << "clear"; break;
case 5: stream << "reset"; break;
case 6: stream << "stack"; break;
case 7: stream << "memory"; break;
default: stream << "other"; break;
}
stream << ", restart count " << static_cast<unsigned>(data[1]);
} else {
stream << "unknown";
}
break;
default:
stream << "unknown 0x" << hex << setfill('0') << setw(2)
<< static_cast<unsigned>(id) << ", len " << dec << setw(0)
<< static_cast<unsigned>(len);
break;
}
if (m_listener != nullptr) {
m_listener->notifyDeviceStatus(false, ("extra info: "+stream.str()).c_str());
}
}
result_t SerialDevice::open() {
result_t result = FileDevice::open();
if (result != RESULT_OK) {
return result;
}
struct termios newSettings;
// open file descriptor
m_fd = ::open(m_name, O_RDWR | O_NOCTTY | O_NDELAY);
if (m_fd < 0) {
return RESULT_ERR_NOTFOUND;
}
if (isatty(m_fd) == 0) {
close();
return RESULT_ERR_NOTFOUND;
}
if (flock(m_fd, LOCK_EX|LOCK_NB) != 0) {
close();
return RESULT_ERR_DEVICE;
}
#ifdef HAVE_LINUX_SERIAL
struct serial_struct serial;
if (ioctl(m_fd, TIOCGSERIAL, &serial) == 0) {
serial.flags |= ASYNC_LOW_LATENCY;
ioctl(m_fd, TIOCSSERIAL, &serial);
}
#endif
#ifdef HAVE_FREEBSD_UFTDI
int param = 0;
// flush tx/rx and set low latency on uftdi device
if (ioctl(m_fd, UFTDIIOC_GET_LATENCY, &param) == 0) {
ioctl(m_fd, UFTDIIOC_RESET_IO, &param);
param = 1;
ioctl(m_fd, UFTDIIOC_SET_LATENCY, &param);
}
#endif
// save current settings
tcgetattr(m_fd, &m_oldSettings);
// create new settings
memset(&newSettings, 0, sizeof(newSettings));
#ifdef HAVE_CFSETSPEED
cfsetspeed(&newSettings, m_enhancedLevel ? (m_enhancedLevel >= el_speed ? B115200 : B9600) : B2400);
#else
cfsetispeed(&newSettings, m_enhancedLevel ? (m_enhancedLevel >= el_speed ? B115200 : B9600) : B2400);
cfsetospeed(&newSettings, m_enhancedLevel ? (m_enhancedLevel >= el_speed ? B115200 : B9600) : B2400);
#endif
newSettings.c_cflag |= (CS8 | CLOCAL | CREAD);
newSettings.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // non-canonical mode
newSettings.c_iflag |= IGNPAR; // ignore parity errors
newSettings.c_oflag &= ~OPOST;
// non-canonical mode: read() blocks until at least one byte is available
newSettings.c_cc[VMIN] = 1;
newSettings.c_cc[VTIME] = 0;
// empty device buffer
tcflush(m_fd, TCIFLUSH);
// activate new settings of serial device
if (tcsetattr(m_fd, TCSANOW, &newSettings)) {
close();
return RESULT_ERR_DEVICE;
}
// set serial device into blocking mode
fcntl(m_fd, F_SETFL, fcntl(m_fd, F_GETFL) & ~O_NONBLOCK);
return afterOpen();
}
void SerialDevice::close() {
if (m_fd != -1) {
// empty device buffer
tcflush(m_fd, TCIOFLUSH);
// restore previous settings of the device
tcsetattr(m_fd, TCSANOW, &m_oldSettings);
}
FileDevice::close();
}
void SerialDevice::checkDevice() {
int cnt;
if (ioctl(m_fd, FIONREAD, &cnt) == -1) {
close();
}
}
result_t NetworkDevice::open() {
result_t result = FileDevice::open();
if (result != RESULT_OK) {
return result;
}
m_fd = socketConnect(m_hostOrIp, m_port, m_udp, nullptr, 5, 2); // wait up to 5 seconds for established connection
if (m_fd < 0) {
return RESULT_ERR_GENERIC_IO;
}
if (!m_udp) {
usleep(25000); // wait 25ms for potential initial garbage
}
int cnt;
symbol_t buf[MTU];
int ioerr;
while ((ioerr=ioctl(m_fd, FIONREAD, &cnt)) >= 0 && cnt > 1) {
// skip buffered input
ssize_t read = ::read(m_fd, &buf, MTU);
if (read <= 0) {
break;
}
}
if (ioerr < 0) {
close();
return RESULT_ERR_GENERIC_IO;
}
return afterOpen();
}
void NetworkDevice::checkDevice() {
int cnt;
if (ioctl(m_fd, FIONREAD, &cnt) < 0) {
close();
}
}
} // namespace ebusd
Reference in New Issue View Git Blame Copy Permalink