initial commit

src/uart/emsuart_esp32.cpp

@@ -0,0 +1,161 @@
+/*
+ * EMS-ESP - https://github.com/proddy/EMS-ESP
+ * Copyright 2019  Paul Derbyshire
+ * 
+ * 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/>.
+ */
+
+#if defined(ESP32)
+
+#include "uart/emsuart_esp32.h"
+
+#include "emsesp.h"
+
+namespace emsesp {
+
+static RingbufHandle_t  buf_handle = NULL;
+static QueueHandle_t    uart_queue = NULL;
+static volatile uint8_t sending    = 0; // If a telegram is send we ++, in receiving we ignore if != 0 and --
+uint8_t                 tx_mode_   = EMS_TXMODE_DEFAULT;
+
+// Main interrupt handler
+void EMSuart::emsuart_parseTask(void * param) {
+    for (;;) {
+        size_t    item_size;
+        uint8_t * telegram     = (uint8_t *)xRingbufferReceive(buf_handle, &item_size, pdMS_TO_TICKS(1000));
+        uint8_t   telegramSize = item_size; // can't be more than EMS_MAXBUFFERSIZE size (checked in sending task)
+
+        // Did we had a timeout?
+        if (telegram) {
+            EMSESP::incoming_telegram(telegram, telegramSize);
+            vRingbufferReturnItem(buf_handle, (void *)telegram);
+        }
+    }
+}
+
+/*
+ * system task triggered on BRK interrupt
+ * incoming received messages are always asynchronous
+ * The full buffer is sent to the ems_parseTelegram() function in ems.cpp.
+ */
+void EMSuart::emsuart_recvTask(void * param) {
+    uart_event_t event;
+    for (;;) {
+        if (xQueueReceive(uart_queue, (void *)&event, (portTickType)portMAX_DELAY)) {
+            // We are only interested in UART_BREAK event and ignore all others
+            if (event.type == UART_BREAK) {
+                // If we didn't send it previously it is a newly received telegram
+                if (sending == 0) {
+                    // Read all bytes which are already in the buffer
+                    uint8_t data[EMSUART_RXBUFSIZE];
+                    int     length = 0;
+                    ESP_ERROR_CHECK(uart_get_buffered_data_len(EMSUART_UART, (size_t *)&length));
+                    if (length > EMSUART_RXBUFSIZE) // pedantic check - should never be the case because the receive buffer is of size EMSUART_RXBUFSIZE
+                    {
+                        length = EMSUART_RXBUFSIZE;
+                    }
+                    length = uart_read_bytes(EMSUART_UART, data, length, 0); // 0 --> we don't want to wait
+                    // we will have runtime performance penalty with impact because of parseTelegram
+                    // --> send the data to a 2nd task --> use a ringbuffer to exchange data between both tasks --> no need for pEMSRxBuf or alike
+                    // this 2nd tasks processes the message with parseTelegram --> our receiving task is still responsiveness
+                    // already do some validty checking here before informing the 2nd task
+                    if ((length == 2) || ((length > 4) && (length <= EMS_MAXBUFFERSIZE + 1))) {
+                        xRingbufferSend(buf_handle, data, length - 1, 0); // we are not waiting if ringbuffer is full --> just loose telegrams pdMS_TO_TICKS(1000)
+                    }
+                } else {
+                    --sending;
+                }
+            }
+        }
+    }
+}
+
+/*
+ * init UART0 driver
+ */
+void EMSuart::start(uint8_t tx_mode) {
+    return; // TODO commented out because it causes crash. @ArwedL could you take a look?
+
+    tx_mode_ = tx_mode;
+
+    // Configure UART parameters
+    // clang-format off
+	uart_config_t uart_config = {
+		.baud_rate = EMSUART_BAUD,
+		.data_bits = UART_DATA_8_BITS,
+		.parity = UART_PARITY_DISABLE,
+		.stop_bits = UART_STOP_BITS_1,
+		.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
+		//.rx_flow_ctrl_thresh = 0, // UART HW RTS threshold should not be important
+	};
+    // clang-format on
+
+    ESP_ERROR_CHECK(uart_param_config(EMSUART_UART, &uart_config));
+
+    // Set UART pins(TX: IO16 (UART2 default), RX: IO17 (UART2 default), RTS: IO18, CTS: IO19)
+    ESP_ERROR_CHECK(uart_set_pin(EMSUART_UART, EMSUART_TXPIN, EMSUART_RXPIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
+
+    // Setup UART buffered IO with event queue
+    //	const int uart_buffer_size = (1024 * 2);
+    //	QueueHandle_t uart_queue;
+    // Install UART driver using an event queue here
+    //	ESP_ERROR_CHECK(uart_driver_install(UART2, uart_buffer_size,
+    //		uart_buffer_size, 10, &uart_queue, 0));
+    // do not use user defined interrupt handlers --> we are waiting for break event
+    // Decision was against written buffered I/O (seems to be fit better to ESP8266 approach), Queue is needed for receiving the break event, queue size wasn't clear
+    // 1 should be enough - also 10 should be fine
+    ESP_ERROR_CHECK(uart_driver_install(EMSUART_UART, EMSUART_RXBUFSIZE, 0, 10, &uart_queue, 0));
+
+    // start recvTaskQueue stacksize choosen any value 4069 bytes, Priority choosen 2 above normal to be able to fastly react on received signals
+    // xTaskCreate parameters taken from https://github.com/espressif/esp-idf/blob/ce2a99dc23533f40369e4ab0d17ffd40f4b0dd72/examples/peripherals/uart/uart_events/main/uart_events_example_main.c
+    xTaskCreate(emsuart_recvTask, "EMS_recv", 2048, NULL, 12, NULL);
+
+    // create 2 tasks because assumption is that parseTelegram needs some time (even on ESP32) which would block receiving task
+    xTaskCreate(emsuart_parseTask, "EMS_parse", 8000, NULL, 2, NULL);
+
+    // Create a ringbuffer for communication between recvTask and parseTask (as max message size is ~32 bytes) 512 bytes has capacity to hold more than 16 telegrams
+    buf_handle = xRingbufferCreate(512, RINGBUF_TYPE_NOSPLIT);
+}
+
+/*
+ * Sends a 1-byte poll, ending with a <BRK>
+ * It's a bit dirty. there is no special wait logic per tx_mode type, fifo flushes or error checking
+ */
+void EMSuart::send_poll(uint8_t data) {
+    char buf[1];
+    buf[0] = data;
+    uart_write_bytes_with_break(EMSUART_UART, (const char *)buf, 1, EMSUART_BREAKBITS);
+}
+
+/*
+ * Send data to Tx line, ending with a <BRK>
+ * buf contains the CRC and len is #bytes including the CRC
+ * returns code, 0=success, 1=brk error, 2=watchdog timeout
+ */
+EMSUART_STATUS EMSuart::transmit(uint8_t * buf, uint8_t len) {
+    if (len == 0) {
+        return EMS_TX_STATUS_OK; // nothing to send
+    }
+
+    if (len && buf) {
+        ++sending;
+        uart_write_bytes_with_break(EMSUART_UART, (const char *)buf, len, EMSUART_BREAKBITS);
+    }
+
+    return EMS_TX_STATUS_OK;
+}
+
+} // namespace emsesp
+
+#endif

src/uart/emsuart_esp32.h

@@ -0,0 +1,71 @@
+/*
+ * EMS-ESP - https://github.com/proddy/EMS-ESP
+ * Copyright 2019  Paul Derbyshire
+ * 
+ * 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/>.
+ */
+
+#ifndef EMSESP_EMSUART_H
+#define EMSESP_EMSUART_H
+
+#include <Arduino.h>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/ringbuf.h"
+#include "freertos/queue.h"
+#include <driver/uart.h>
+
+#define EMS_MAXBUFFERSIZE 34 // max size of the buffer. EMS packets are max 32 bytes, plus extra 2 for BRKs
+
+#define EMSUART_UART UART_NUM_2 // UART 0 --> Changed to 2 for ESP32 // To do: Adapt
+#define EMSUART_RXPIN 17        // To do: Adapt seems to be IO17 for ESP32 UART2 RX pin
+#define EMSUART_TXPIN 16        // To do: Adapt seems to be IO16 for ESP32 UART2 TX pin
+//#define EMSUART_CONFIG 0x1C // 8N1 (8 bits, no parity, 1 stopbit)
+#define EMSUART_BAUD 9600 // uart baud rate for the EMS circuit
+#define EMSUART_RXBUFSIZE (2 * UART_FIFO_LEN)
+#define EMSUART_BREAKBITS 11 // 11 bits break signal
+
+#define EMS_TXMODE_DEFAULT 1
+#define EMS_TXMODE_EMSPLUS 2
+#define EMS_TXMODE_HT3 3
+
+namespace emsesp {
+
+typedef enum {
+    EMS_TX_STATUS_OK = 1,
+    EMS_TX_WTD_TIMEOUT, // watchdog timeout during send
+    EMS_TX_BRK_DETECT,  // incoming BRK during Tx
+} EMSUART_STATUS;
+
+class EMSuart {
+  public:
+    EMSuart()  = default;
+    ~EMSuart() = default;
+
+    static void           start(uint8_t tx_mode);
+    static void           send_poll(uint8_t data);
+    static EMSUART_STATUS transmit(uint8_t * buf, uint8_t len);
+
+    static void stop(){};    // not used with ESP32
+    static void restart(){}; // not used with ESP32
+
+  private:
+    static void emsuart_recvTask(void * param);
+    static void emsuart_parseTask(void * param);
+};
+
+} // namespace emsesp
+
+#endif

src/uart/emsuart_esp8266.cpp

@@ -0,0 +1,352 @@
+/*
+ * EMS-ESP - https://github.com/proddy/EMS-ESP
+ * Copyright 2019  Paul Derbyshire
+ * 
+ * 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/>.
+ */
+
+#if defined(ESP8266)
+
+#include "uart/emsuart_esp8266.h"
+
+#include "emsesp.h"
+
+namespace emsesp {
+
+os_event_t recvTaskQueue[EMSUART_recvTaskQueueLen]; // our Rx queue
+
+EMSuart::EMSRxBuf_t * pEMSRxBuf;
+EMSuart::EMSRxBuf_t * paEMSRxBuf[EMS_MAXBUFFERS];
+uint8_t               emsRxBufIdx  = 0;
+uint8_t               phantomBreak = 0;
+uint8_t               tx_mode_     = EMS_TXMODE_DEFAULT;
+
+//
+// Main interrupt handler
+// Important: must not use ICACHE_FLASH_ATTR
+//
+void ICACHE_RAM_ATTR EMSuart::emsuart_rx_intr_handler(void * para) {
+    static uint8_t length;
+    static uint8_t uart_buffer[EMS_MAXBUFFERSIZE + 2];
+
+    // TODO check if need UART Rx idle/busy
+    /*
+    // is a new buffer? if so init the thing for a new telegram
+    if (EMS_Sys_Status.emsRxStatus == EMS_RX_STATUS_IDLE) {
+        EMS_Sys_Status.emsRxStatus = EMS_RX_STATUS_BUSY; // status set to busy
+        length                     = 0;
+    }
+    */
+
+    // fill IRQ buffer, by emptying Rx FIFO
+    if (USIS(EMSUART_UART) & ((1 << UIFF) | (1 << UITO) | (1 << UIBD))) {
+        while ((USS(EMSUART_UART) >> USRXC) & 0xFF) {
+            uint8_t rx = USF(EMSUART_UART);
+            if (length < EMS_MAXBUFFERSIZE)
+                uart_buffer[length++] = rx;
+        }
+
+        // clear Rx FIFO full and Rx FIFO timeout interrupts
+        USIC(EMSUART_UART) = (1 << UIFF) | (1 << UITO);
+    }
+
+    // BREAK detection = End of EMS data block
+    if (USIS(EMSUART_UART) & ((1 << UIBD))) {
+        ETS_UART_INTR_DISABLE();          // disable all interrupts and clear them
+        USIC(EMSUART_UART) = (1 << UIBD); // INT clear the BREAK detect interrupt
+
+        pEMSRxBuf->length = (length > EMS_MAXBUFFERSIZE) ? EMS_MAXBUFFERSIZE : length;
+        os_memcpy((void *)pEMSRxBuf->buffer, (void *)&uart_buffer, pEMSRxBuf->length); // copy data into transfer buffer, including the BRK 0x00 at the end
+        length = 0;
+        // EMS_Sys_Status.emsRxStatus = EMS_RX_STATUS_IDLE; // TODO check set the status flag stating BRK has been received and we can start a new package
+        ETS_UART_INTR_ENABLE(); // re-enable UART interrupts
+
+        system_os_post(EMSUART_recvTaskPrio, 0, 0); // call emsuart_recvTask() at next opportunity
+    }
+}
+
+/*
+ * system task triggered on BRK interrupt
+ * incoming received messages are always asynchronous
+ * The full buffer is sent to EMSESP::incoming_telegram()
+ */
+void ICACHE_FLASH_ATTR EMSuart::emsuart_recvTask(os_event_t * events) {
+    EMSRxBuf_t * pCurrent = pEMSRxBuf;
+    pEMSRxBuf             = paEMSRxBuf[++emsRxBufIdx % EMS_MAXBUFFERS]; // next free EMS Receive buffer
+    uint8_t length        = pCurrent->length;                           // number of bytes including the BRK at the end
+    pCurrent->length      = 0;
+
+    if (phantomBreak) {
+        phantomBreak = 0;
+        length--; // remove phantom break from Rx buffer
+    }
+
+    // it's a poll or status code, single byte and ok to send on, then quit
+    if (length == 2) {
+        EMSESP::incoming_telegram((uint8_t *)pCurrent->buffer, 1);
+        return;
+    }
+
+    // ignore double BRK at the end, possibly from the Tx loopback
+    // also telegrams with no data value
+    // then transmit EMS buffer, excluding the BRK
+    if ((length > 4) && (length <= EMS_MAXBUFFERSIZE + 1)) {
+        EMSESP::incoming_telegram((uint8_t *)pCurrent->buffer, length - 1);
+    }
+}
+
+/*
+ * flush everything left over in buffer, this clears both rx and tx FIFOs
+ */
+void ICACHE_FLASH_ATTR EMSuart::emsuart_flush_fifos() {
+    uint32_t tmp = ((1 << UCRXRST) | (1 << UCTXRST)); // bit mask
+    USC0(EMSUART_UART) |= (tmp);                      // set bits
+    USC0(EMSUART_UART) &= ~(tmp);                     // clear bits
+}
+
+/*
+ * init UART0 driver
+ */
+void ICACHE_FLASH_ATTR EMSuart::start(uint8_t tx_mode) {
+    tx_mode_ = tx_mode;
+
+    // allocate and preset EMS Receive buffers
+    for (int i = 0; i < EMS_MAXBUFFERS; i++) {
+        EMSRxBuf_t * p = (EMSRxBuf_t *)malloc(sizeof(EMSRxBuf_t));
+        paEMSRxBuf[i]  = p;
+    }
+    pEMSRxBuf = paEMSRxBuf[0]; // reset EMS Rx Buffer
+
+    ETS_UART_INTR_DISABLE();
+    ETS_UART_INTR_ATTACH(nullptr, nullptr);
+
+    // pin settings
+    PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0TXD_U);
+    PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD);
+    PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0RXD_U);
+    PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_U0RXD);
+
+    // set 9600, 8 bits, no parity check, 1 stop bit
+    USD(EMSUART_UART)  = (UART_CLK_FREQ / EMSUART_BAUD);
+    USC0(EMSUART_UART) = EMSUART_CONFIG; // 8N1
+
+    emsuart_flush_fifos();
+
+    // conf1 params
+    // UCTOE = RX TimeOut enable (default is 1)
+    // UCTOT = RX TimeOut Threshold (7 bit) = want this when no more data after 1 characters (default is 2)
+    // UCFFT = RX FIFO Full Threshold (7 bit) = want this to be 31 for 32 bytes of buffer (default was 127)
+    // see https://www.espressif.com/sites/default/files/documentation/esp8266-technical_reference_en.pdf
+    //
+    // change: we set UCFFT to 1 to get an immediate indicator about incoming traffic.
+    //         Otherwise, we're only noticed by UCTOT or RxBRK!
+    USC1(EMSUART_UART) = 0;                                                // reset config first
+    USC1(EMSUART_UART) = (0x01 << UCFFT) | (0x01 << UCTOT) | (0 << UCTOE); // enable interupts
+
+    // set interrupts for triggers
+    USIC(EMSUART_UART) = 0xFFFF; // clear all interupts
+    USIE(EMSUART_UART) = 0;      // disable all interrupts
+
+    // enable rx break, fifo full and timeout.
+    // but not frame error UIFR (because they are too frequent) or overflow UIOF because our buffer is only max 32 bytes
+    // change: we don't care about Rx Timeout - it may lead to wrong readouts
+    USIE(EMSUART_UART) = (1 << UIBD) | (1 << UIFF) | (0 << UITO);
+
+    // set up interrupt callbacks for Rx
+    system_os_task(emsuart_recvTask, EMSUART_recvTaskPrio, recvTaskQueue, EMSUART_recvTaskQueueLen);
+
+    // disable esp debug which will go to Tx and mess up the line - see https://github.com/espruino/Espruino/issues/655
+    system_set_os_print(0);
+
+    // swap Rx and Tx pins to use GPIO13 (D7) and GPIO15 (D8) respectively
+    system_uart_swap();
+
+    ETS_UART_INTR_ATTACH(emsuart_rx_intr_handler, nullptr);
+    ETS_UART_INTR_ENABLE();
+
+    // logger_.info(F("UART service for Rx/Tx started"));
+}
+
+/*
+ * stop UART0 driver
+ * This is called prior to an OTA upload and also before a save to the filesystem to prevent conflicts
+ */
+void ICACHE_FLASH_ATTR EMSuart::stop() {
+    ETS_UART_INTR_DISABLE();
+}
+
+/*
+ * re-start UART0 driver
+ */
+void ICACHE_FLASH_ATTR EMSuart::restart() {
+    ETS_UART_INTR_ENABLE();
+}
+
+/*
+ * Send a BRK signal
+ * Which is a 11-bit set of zero's (11 cycles)
+ */
+void ICACHE_FLASH_ATTR EMSuart::tx_brk() {
+    uint32_t tmp;
+
+    // must make sure Tx FIFO is empty
+    while (((USS(EMSUART_UART) >> USTXC) & 0xFF))
+        ;
+
+    tmp = ((1 << UCRXRST) | (1 << UCTXRST)); // bit mask
+    USC0(EMSUART_UART) |= (tmp);             // set bits
+    USC0(EMSUART_UART) &= ~(tmp);            // clear bits
+
+    // To create a 11-bit <BRK> we set TXD_BRK bit so the break signal will
+    // automatically be sent when the tx fifo is empty
+    tmp = (1 << UCBRK);
+    USC0(EMSUART_UART) |= (tmp); // set bit
+
+    if (tx_mode_ == EMS_TX_WTD_TIMEOUT) { // EMS+ mode
+        delayMicroseconds(EMSUART_TX_BRK_WAIT);
+    } else if (tx_mode_ == EMS_TXMODE_HT3) {                     // junkers mode
+        delayMicroseconds(EMSUART_TX_WAIT_BRK - EMSUART_TX_LAG); // 1144 (11 Bits)
+    }
+
+    USC0(EMSUART_UART) &= ~(tmp); // clear bit
+}
+
+/*
+ * Sends a 1-byte poll, ending with a <BRK>
+ * It's a bit dirty. there is no special wait logic per tx_mode type, fifo flushes or error checking
+ */
+void EMSuart::send_poll(uint8_t data) {
+    USF(EMSUART_UART) = data;
+    delayMicroseconds(EMSUART_TX_BRK_WAIT);
+    tx_brk(); // send <BRK>
+}
+
+/*
+ * Send data to Tx line, ending with a <BRK>
+ * buf contains the CRC and len is #bytes including the CRC
+ * returns code, 0=success, 1=brk error, 2=watchdog timeout
+ */
+EMSUART_STATUS ICACHE_FLASH_ATTR EMSuart::transmit(uint8_t * buf, uint8_t len) {
+    if (len == 0) {
+        return EMS_TX_STATUS_OK; // nothing to send
+    }
+
+    // EMS+ https://github.com/proddy/EMS-ESP/issues/23#
+    if (tx_mode_ == EMS_TXMODE_EMSPLUS) { // With extra tx delay for EMS+
+        for (uint8_t i = 0; i < len; i++) {
+            USF(EMSUART_UART) = buf[i];
+            delayMicroseconds(EMSUART_TX_BRK_WAIT); // 2070
+        }
+        tx_brk(); // send <BRK>
+        return EMS_TX_STATUS_OK;
+    }
+
+    // Junkers logic by @philrich
+    if (tx_mode_ == EMS_TXMODE_HT3) {
+        for (uint8_t i = 0; i < len; i++) {
+            USF(EMSUART_UART) = buf[i];
+
+            // just to be safe wait for tx fifo empty (still needed?)
+            while (((USS(EMSUART_UART) >> USTXC) & 0xff))
+                ;
+
+            // wait until bits are sent on wire
+            delayMicroseconds(EMSUART_TX_WAIT_BYTE - EMSUART_TX_LAG + EMSUART_TX_WAIT_GAP); // 1760
+        }
+        tx_brk(); // send <BRK>
+        return EMS_TX_STATUS_OK;
+    }
+
+    /*
+     * Logic for tx_mode of 0 (EMS_TXMODE_DEFAULT)
+     * based on code from https://github.com/proddy/EMS-ESP/issues/103 by @susisstrolch
+     * 
+     * Logic:
+     * we emit the whole telegram, with Rx interrupt disabled, collecting busmaster response in FIFO.
+     * after sending the last char we poll the Rx status until either
+     * - size(Rx FIFO) == size(Tx-Telegram)
+     * - <BRK> is detected
+     * At end of receive we re-enable Rx-INT and send a Tx-BRK in loopback mode.
+     * 
+     * EMS-Bus error handling
+     * 1. Busmaster stops echoing on Tx w/o permission
+     * 2. Busmaster cancel telegram by sending a BRK
+     * 
+     * Case 1. is handled by a watchdog counter which is reset on each
+     * Tx attempt. The timeout should be 20x EMSUART_BIT_TIME plus 
+     * some smart guess for processing time on targeted EMS device.
+     * We set Status to EMS_TX_WTD_TIMEOUT and return
+     * 
+     * Case 2. is handled via a BRK chk during transmission.
+     * We set Status to EMS_TX_BRK_DETECT and return
+     * 
+     */
+
+    EMSUART_STATUS result = EMS_TX_STATUS_OK;
+
+    // disable rx interrupt
+    // clear Rx status register, resetting the Rx FIFO and flush it
+    ETS_UART_INTR_DISABLE();
+    USC0(EMSUART_UART) |= (1 << UCRXRST);
+    emsuart_flush_fifos();
+
+    // send the bytes along the serial line
+    for (uint8_t i = 0; i < len; i++) {
+        uint16_t         wdc    = EMS_TX_TO_COUNT; // 1760
+        volatile uint8_t _usrxc = (USS(EMSUART_UART) >> USRXC) & 0xFF;
+        USF(EMSUART_UART)       = buf[i]; // send each Tx byte
+        // wait for echo from the busmaster
+        while (((USS(EMSUART_UART) >> USRXC) & 0xFF) == _usrxc) {
+            delayMicroseconds(EMSUART_BUSY_WAIT); // burn CPU cycles...
+            if (--wdc == 0) {
+                ETS_UART_INTR_ENABLE();
+                return EMS_TX_WTD_TIMEOUT;
+            }
+            if (USIR(EMSUART_UART) & (1 << UIBD)) {
+                USIC(EMSUART_UART) = (1 << UIBD); // clear BRK detect IRQ
+                ETS_UART_INTR_ENABLE();
+                return EMS_TX_BRK_DETECT;
+            }
+        }
+    }
+
+    // we got the whole telegram in the Rx buffer
+    // on Rx-BRK (bus collision), we simply enable Rx and leave it
+    // otherwise we send the final Tx-BRK in the loopback and re=enable Rx-INT.
+    // worst case, we'll see an additional Rx-BRK...
+    if (result == EMS_TX_STATUS_OK) {
+        // neither bus collision nor timeout - send terminating BRK signal
+        if (!(USIS(EMSUART_UART) & (1 << UIBD))) {
+            // no bus collision - send terminating BRK signal
+            USC0(EMSUART_UART) |= (1 << UCLBE) | (1 << UCBRK); // enable loopback & set <BRK>
+
+            // wait until BRK detected...
+            while (!(USIR(EMSUART_UART) & (1 << UIBD))) {
+                delayMicroseconds(EMSUART_BIT_TIME);
+            }
+
+            USC0(EMSUART_UART) &= ~((1 << UCBRK) | (1 << UCLBE)); // disable loopback & clear <BRK>
+            USIC(EMSUART_UART) = (1 << UIBD);                     // clear BRK detect IRQ
+            phantomBreak       = 1;
+        }
+    }
+
+    ETS_UART_INTR_ENABLE(); // open up the FIFO again to start receiving
+
+    return result; // send the Tx status back
+}
+
+} // namespace emsesp
+
+#endif

src/uart/emsuart_esp8266.h

@@ -0,0 +1,86 @@
+/*
+ * EMS-ESP - https://github.com/proddy/EMS-ESP
+ * Copyright 2019  Paul Derbyshire
+ * 
+ * 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/>.
+ */
+
+#ifndef EMSESP_EMSUART_H
+#define EMSESP_EMSUART_H
+
+#include <Arduino.h>
+
+#include <user_interface.h>
+
+#define EMSUART_UART 0      // UART 0
+#define EMSUART_CONFIG 0x1C // 8N1 (8 bits, no stop bits, 1 parity)
+#define EMSUART_BAUD 9600   // uart baud rate for the EMS circuit
+
+#define EMS_MAXBUFFERS 3     // buffers for circular filling to avoid collisions
+#define EMS_MAXBUFFERSIZE 34 // max size of the buffer. EMS packets are max 32 bytes, plus extra 2 for BRKs
+
+#define EMSUART_BIT_TIME 104 // bit time @9600 baud
+
+#define EMSUART_TX_BRK_WAIT 2070 // the BRK from Boiler master is roughly 1.039ms, so accounting for hardware lag using around 2078 (for half-duplex) - 8 (lag)
+#define EMSUART_TX_WAIT_BYTE (EMSUART_BIT_TIME * 10) // Time to send one Byte (8 Bits, 1 Start Bit, 1 Stop Bit)
+#define EMSUART_TX_WAIT_BRK (EMSUART_BIT_TIME * 11)  // Time to send a BRK Signal (11 Bit)
+#define EMSUART_TX_WAIT_GAP (EMSUART_BIT_TIME * 7)   // Gap between to Bytes
+#define EMSUART_TX_LAG 8
+
+#define EMSUART_BUSY_WAIT (EMSUART_BIT_TIME / 8)
+#define EMS_TX_TO_CHARS (2 + 20)
+#define EMS_TX_TO_COUNT ((EMS_TX_TO_CHARS)*10 * 8)
+
+#define EMSUART_recvTaskPrio 1      // 0, 1 or 2. 0 being the lowest
+#define EMSUART_recvTaskQueueLen 10 // number of queued'd Rx triggers
+
+#define EMS_TXMODE_DEFAULT 1
+#define EMS_TXMODE_EMSPLUS 2
+#define EMS_TXMODE_HT3 3
+
+namespace emsesp {
+
+typedef enum {
+    EMS_TX_STATUS_OK = 1,
+    EMS_TX_WTD_TIMEOUT, // watchdog timeout during send
+    EMS_TX_BRK_DETECT,  // incoming BRK during Tx
+} EMSUART_STATUS;
+
+class EMSuart {
+  public:
+    EMSuart()  = default;
+    ~EMSuart() = default;
+
+    static void ICACHE_FLASH_ATTR           start(uint8_t tx_mode);
+    static void ICACHE_FLASH_ATTR           stop();
+    static void ICACHE_FLASH_ATTR           restart();
+    static void ICACHE_FLASH_ATTR           send_poll(uint8_t data);
+    static EMSUART_STATUS ICACHE_FLASH_ATTR transmit(uint8_t * buf, uint8_t len);
+
+    typedef struct {
+        uint8_t length;
+        uint8_t buffer[EMS_MAXBUFFERSIZE];
+    } EMSRxBuf_t;
+
+  private:
+    static void ICACHE_RAM_ATTR emsuart_rx_intr_handler(void * para);
+
+    static void ICACHE_FLASH_ATTR emsuart_recvTask(os_event_t * events);
+    static void ICACHE_FLASH_ATTR emsuart_flush_fifos();
+    static void ICACHE_FLASH_ATTR tx_brk();
+};
+
+} // namespace emsesp
+
+#endif