From 4d5e512952fc83981e3111bac5016307cf7d230f Mon Sep 17 00:00:00 2001 From: MichaelDvP Date: Mon, 25 May 2020 08:45:09 +0200 Subject: [PATCH] esp32 uart and wemos d1-mini32 --- platformio.ini | 7 + src/device_library.h | 6 +- src/sensors.h | 5 + src/settings.h | 2 +- src/system.h | 6 +- src/uart/emsuart_esp32.cpp | 154 +++++++++----------- src/uart/emsuart_esp32.h | 27 ++-- src/uart/emsuart_esp8266.cpp | 262 +++++------------------------------ src/uart/emsuart_esp8266.h | 17 +-- 9 files changed, 133 insertions(+), 353 deletions(-) diff --git a/platformio.ini b/platformio.ini index 41c00a9b5..3f23f0893 100644 --- a/platformio.ini +++ b/platformio.ini @@ -4,6 +4,7 @@ [platformio] default_envs = esp8266 ;default_envs = esp32 +;default_envs = esp32_d1 # override any settings with your own local ones in pio_local.ini extra_configs = pio_local.ini @@ -89,3 +90,9 @@ board = esp32dev lib_deps = ${common.libs_core} ${common.libs_esp32} build_flags = ${common.build_flags} ${common.debug_flags} -D PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH +[env:esp32_d1] +build_type = release +platform = espressif32 +board = wemos_d1_mini32 +lib_deps = ${common.libs_core} ${common.libs_esp32} +build_flags = ${common.build_flags} ${common.debug_flags} -D PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH diff --git a/src/device_library.h b/src/device_library.h index 62126d0f3..cc89d8699 100644 --- a/src/device_library.h +++ b/src/device_library.h @@ -24,10 +24,10 @@ */ // Boilers - 0x08 +{ 72, DeviceType::BOILER, F("GB125/MC10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {115, DeviceType::BOILER, F("Topline/GB162"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {123, DeviceType::BOILER, F("GBx72/Trendline/Cerapur/Greenstar Si/27i"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {133, DeviceType::BOILER, F("GB125/Logamatic MC110"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, -{115, DeviceType::BOILER, F("Topline/GB162"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {203, DeviceType::BOILER, F("Logamax U122/Cerapur"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {208, DeviceType::BOILER, F("Logamax plus/GB192/Condens GC9000"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, { 64, DeviceType::BOILER, F("BK13,BK15/Smartline/GB1x2"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, @@ -78,7 +78,7 @@ // Gateways - 0x48 / 0x18 {189, DeviceType::GATEWAY, F("KM200"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x48 -{ 94, DeviceType::GATEWAY, F("RC"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x18 +{ 94, DeviceType::GATEWAY, F("RFM"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x18 // Thermostat - not currently supporting write operations, like the Easy/100 types - 0x18 {202, DeviceType::THERMOSTAT, F("Logamatic TC100/Moduline Easy"), DeviceFlags::EMS_DEVICE_FLAG_EASY | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18, cannot write @@ -98,7 +98,7 @@ // Thermostat - Sieger - 0x10 / 0x17 { 76, DeviceType::THERMOSTAT, F("ES73"), DeviceFlags::EMS_DEVICE_FLAG_RC35}, // 0x10 -{113, DeviceType::THERMOSTAT, F("ES72"), DeviceFlags::EMS_DEVICE_FLAG_RC20_2}, // 0x17 +{113, DeviceType::THERMOSTAT, F("ES72/RC20"), DeviceFlags::EMS_DEVICE_FLAG_RC20_2}, // 0x17 // Thermostat - Junkers - 0x10 {105, DeviceType::THERMOSTAT, F("FW100"), DeviceFlags::EMS_DEVICE_FLAG_JUNKERS}, diff --git a/src/sensors.h b/src/sensors.h index a3b530037..98b94bf34 100644 --- a/src/sensors.h +++ b/src/sensors.h @@ -63,7 +63,12 @@ class Sensors { const std::vector devices() const; private: +#if defined(ESP8266) static constexpr uint8_t SENSOR_GPIO = 14; // D5 +#elif defined(ESP32) +// static constexpr uint8_t SENSOR_GPIO = 14; // same position + static constexpr uint8_t SENSOR_GPIO = 18; // for Wemos D1 32 +#endif enum class State { IDLE, READING, SCANNING }; diff --git a/src/settings.h b/src/settings.h index 64fc36619..213478851 100644 --- a/src/settings.h +++ b/src/settings.h @@ -48,7 +48,7 @@ #define EMSESP_DEFAULT_TX_MODE 1 #define EMSESP_DEFAULT_MQTT_ENABLED true #define EMSESP_DEFAULT_MQTT_BASE "home" -#define EMSESP_DEFAULT_MQTT_PORT 1883 +#define EMSESP_DEFAULT_MQTT_PORT 1884 #define EMSESP_DEFAULT_MQTT_QOS 0 #define EMSESP_DEFAULT_MQTT_RETAIN false #define EMSESP_DEFAULT_MQTT_FORMAT 2 // nested diff --git a/src/system.h b/src/system.h index 77dc2dee4..afd08693b 100644 --- a/src/system.h +++ b/src/system.h @@ -81,8 +81,10 @@ class System { static constexpr uint8_t LED_GPIO = 2; static constexpr uint8_t LED_ON = LOW; #elif defined(ESP32) - static constexpr uint8_t LED_GPIO = 5; // on Wemos D32 - static constexpr uint8_t LED_ON = LOW; +// static constexpr uint8_t LED_GPIO = 5; // on Wemos D32 +// static constexpr uint8_t LED_ON = LOW; + static constexpr uint8_t LED_GPIO = 2; // on Wemos D1-32 + static constexpr uint8_t LED_ON = HIGH; #else static constexpr uint8_t LED_GPIO = 0; static constexpr uint8_t LED_ON = 0; diff --git a/src/uart/emsuart_esp32.cpp b/src/uart/emsuart_esp32.cpp index 260bdb7ae..7da42a94e 100644 --- a/src/uart/emsuart_esp32.cpp +++ b/src/uart/emsuart_esp32.cpp @@ -26,134 +26,108 @@ namespace emsesp { +static intr_handle_t uart_handle; 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; +static uint8_t rxbuf[UART_FIFO_LEN]; +static uint8_t rxlen; -// Main interrupt handler -void EMSuart::emsuart_parseTask(void * param) { - for (;;) { + +/* +* Task to handle the incoming data. +*/ +void EMSuart::emsuart_recvTask(void * param) { + while(1) { 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) + uint8_t * telegram = (uint8_t *)xRingbufferReceive(buf_handle, &item_size, portMAX_DELAY); + uint8_t telegramSize = item_size; - // 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. + * UART interrupt, on break read the fifo and put the whole telegram to ringbuffer */ -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; - } - } +static void IRAM_ATTR uart_intr_handle(void *arg) +{ + if (EMS_UART.int_st.brk_det) { + uint8_t rx_fifo_len = EMS_UART.status.rxfifo_cnt; + for (rxlen = 0; rxlen < rx_fifo_len; rxlen++) { + rxbuf[rxlen] = EMS_UART.fifo.rw_byte; // read all bytes into buffer } + if ((rxlen == 2) || ((rxlen > 4) && (rxlen <= EMS_MAXBUFFERSIZE))) { + int baseType = 0; + xRingbufferSendFromISR(buf_handle, rxbuf, rxlen - 1, &baseType); + } + EMS_UART.int_clr.brk_det = 1; // clear flag + EMS_UART.conf0.txd_brk = 0; // if it was break from sending, clear bit } } - /* - * init UART0 driver + * init UART driver */ void EMSuart::start(uint8_t tx_mode) { - - 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, + .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)); - - // 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 + //EMS_UART.conf1.rxfifo_full_thrhd = 127; // enough to hold the incomming telegram, should never reached + //EMS_UART.idle_conf.tx_brk_num = 12; // breaklenght 12 bit + EMS_UART.int_ena.val = 0; // diable all intr. + EMS_UART.int_clr.val = 0xFFFFFFFF; // clear all intr. flags + EMS_UART.int_ena.brk_det = 1; // activate only break buf_handle = xRingbufferCreate(512, RINGBUF_TYPE_NOSPLIT); - - // 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); + ESP_ERROR_CHECK(uart_isr_register(EMSUART_UART,uart_intr_handle, NULL, ESP_INTR_FLAG_IRAM, &uart_handle)); + xTaskCreate(emsuart_recvTask, "emsuart_recvTask", 2048, NULL, 12, NULL); } -/* + /* + * Stop, disables interrupt + */ +vvoid EMSuart::stop(){ + EMS_UART.int_ena.val = 0; //diable all intr. + }; + + /* + * Restart Interrupt + */ +vvoid EMSuart::restart(){ + EMS_UART.int_clr.val = 0xFFFFFFFF; // clear all intr. flags + EMS_UART.int_ena.brk_det = 1; // activate only break + }; + + /* * Sends a 1-byte poll, ending with a - * 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); + EMS_UART.conf0.txd_brk = 0; // just to make sure the bit is cleared + EMS_UART.fifo.rw_byte = data; + EMS_UART.idle_conf.tx_brk_num = 12; // breaklenght 12 bit + EMS_UART.conf0.txd_brk = 1; // sending ends in a break } /* * Send data to Tx line, ending with a * buf contains the CRC and len is #bytes including the CRC - * returns code, 0=success, 1=brk error, 2=watchdog timeout + * returns code, 1=success */ 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); - } - + if (len > 0) { + EMS_UART.conf0.txd_brk = 0; // just to make sure the bit is cleared + for (uint8_t i = 0; i < len; i++) { + EMS_UART.fifo.rw_byte = buf[i]; + } + //uart_tx_chars(EMSUART_UART, (const char *)buf, len); + EMS_UART.idle_conf.tx_brk_num = 12; // breaklenght 12 bit + EMS_UART.conf0.txd_brk = 1; // sending ends in a break + } return EMS_TX_STATUS_OK; } diff --git a/src/uart/emsuart_esp32.h b/src/uart/emsuart_esp32.h index 974e0283a..f800ff5e4 100644 --- a/src/uart/emsuart_esp32.h +++ b/src/uart/emsuart_esp32.h @@ -27,19 +27,14 @@ #include "freertos/queue.h" #include -#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 +#define EMS_MAXBUFFERSIZE 33 // max size of the buffer. EMS packets are max 32 bytes, plus BRK +#define EMSUART_UART UART_NUM_2 // UART 0 --> Changed to 2 for ESP32 // To do: Adapt +#define EMS_UART UART2 // for intr setting +//#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_RXPIN 23 // Wemos D1 ESP32 UART2 RX pin for compatibility +#define EMSUART_TXPIN 5 // Wemos D1 ESP32 UART2 TX pin for compatibility +#define EMSUART_BAUD 9600 // uart baud rate for the EMS circuit namespace emsesp { @@ -56,14 +51,12 @@ class EMSuart { static void start(uint8_t tx_mode); static void send_poll(uint8_t data); + static void stop(); + static void restart(); 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 diff --git a/src/uart/emsuart_esp8266.cpp b/src/uart/emsuart_esp8266.cpp index 597b82fad..dc230fae7 100644 --- a/src/uart/emsuart_esp8266.cpp +++ b/src/uart/emsuart_esp8266.cpp @@ -28,48 +28,31 @@ 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; +uint8_t emsRxBufIdx = 0; // // 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 = 0; - static bool rx_idle_ = true; - static uint8_t uart_buffer[EMS_MAXBUFFERSIZE + 2]; - - // is a new buffer? if so init the thing for a new telegram - if (rx_idle_) { - rx_idle_ = false; // 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); - } + static uint8_t length = 0; + static uint8_t uart_buffer[128]; // 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 - rx_idle_ = true; // 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 + uint8_t rxlen = (USS(EMSUART_UART) & 0xFF); // length of buffer + for (length = 0; length < rxlen; length++) { + uart_buffer[length] = USF(EMSUART_UART); + } + USIE(EMSUART_UART) = 0; // disable all interrupts and clear them + USC0(EMSUART_UART) &= ~(1 << UCBRK); // reset from sending + if (length < EMS_MAXBUFFERSIZE) { // only a valid telegram + pEMSRxBuf->length = length; + os_memcpy((void *)pEMSRxBuf->buffer, (void *)&uart_buffer, pEMSRxBuf->length); // copy data into transfer buffer, including the BRK 0x00 at the end + system_os_post(EMSUART_recvTaskPrio, 0, 0); // call emsuart_recvTask() at next opportunity + } + USIC(EMSUART_UART) = (1 << UIBD); // INT clear the BREAK detect interrupt + USIE(EMSUART_UART) = (1 << UIBD); // enable only rx break } } @@ -84,39 +67,23 @@ void ICACHE_FLASH_ATTR EMSuart::emsuart_recvTask(os_event_t * events) { 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)) { + // then transmit EMS buffer, excluding the BRK, lenght is checked by irq + if (length > 4) { 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++) { @@ -125,8 +92,8 @@ void ICACHE_FLASH_ATTR EMSuart::start(uint8_t tx_mode) { } pEMSRxBuf = paEMSRxBuf[0]; // reset EMS Rx Buffer - ETS_UART_INTR_DISABLE(); - ETS_UART_INTR_ATTACH(nullptr, nullptr); + //ETS_UART_INTR_DISABLE(); + //ETS_UART_INTR_ATTACH(nullptr, nullptr); // pin settings PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0TXD_U); @@ -138,41 +105,22 @@ void ICACHE_FLASH_ATTR EMSuart::start(uint8_t tx_mode) { 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); + USC0(EMSUART_UART) |= ((1 << UCRXRST) | (1 << UCTXRST)); // set bits + USC0(EMSUART_UART) &= ~((1 << UCRXRST) | (1 << UCTXRST)); // clear bits + // UCFFT = RX FIFO Full Threshold (7 bit) = want this to be more than 32) + USC1(EMSUART_UART) = (0x7F << UCFFT); // rx buffer full + USIE(EMSUART_UART) = 0; // disable all interrupts + USIC(EMSUART_UART) = 0xFFFF; // clear all interupts // 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")); + USIE(EMSUART_UART) = (1 << UIBD); // enable only rx break interrupt + //ETS_UART_INTR_ENABLE(); } /* @@ -180,170 +128,36 @@ void ICACHE_FLASH_ATTR EMSuart::start(uint8_t tx_mode) { * 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(); + USIE(EMSUART_UART) = 0; // disable interrup } /* * re-start UART0 driver */ void ICACHE_FLASH_ATTR EMSuart::restart() { - ETS_UART_INTR_ENABLE(); + USIE(EMSUART_UART) = (1 << UIBD); // enable only rx break } -/* - * 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 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 - * 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) { + USC0(EMSUART_UART) &= ~(1 << UCBRK); // clear bit USF(EMSUART_UART) = data; - delayMicroseconds(EMSUART_TX_BRK_WAIT); - tx_brk(); // send + USC0(EMSUART_UART) |= (1 << UCBRK); // send at the end } /* * Send data to Tx line, ending with a * 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++) { + if (len) { + USC0(EMSUART_UART) &= ~(1 << UCBRK); // clear bit + for (uint8_t i = 0; i < len ; i++) { USF(EMSUART_UART) = buf[i]; - delayMicroseconds(EMSUART_TX_BRK_WAIT); // 2070 } - tx_brk(); // send - return EMS_TX_STATUS_OK; + USC0(EMSUART_UART) |= (1 << UCBRK); // send at the end } - - // 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 - 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) - * - 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 - - // wait until BRK detected... - while (!(USIR(EMSUART_UART) & (1 << UIBD))) { - delayMicroseconds(EMSUART_BIT_TIME); - } - - USC0(EMSUART_UART) &= ~((1 << UCBRK) | (1 << UCLBE)); // disable loopback & clear - 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 -} - + return EMS_TX_STATUS_OK; +} } // namespace emsesp #endif diff --git a/src/uart/emsuart_esp8266.h b/src/uart/emsuart_esp8266.h index 082300e4a..4227efa1b 100644 --- a/src/uart/emsuart_esp8266.h +++ b/src/uart/emsuart_esp8266.h @@ -28,19 +28,7 @@ #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 EMS_MAXBUFFERSIZE 33 // max size of the buffer. EMS packets are max 32 bytes, plus extra 2 for BRK #define EMSUART_recvTaskPrio 1 // 0, 1 or 2. 0 being the lowest #define EMSUART_recvTaskQueueLen 10 // number of queued'd Rx triggers @@ -75,10 +63,7 @@ class EMSuart { 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