Updated driver structure

src/NbusBridgeDriver/NbusCommunicatorEsp32.cpp

@@ -0,0 +1,122 @@
+#if NBUS_NODE_TYPE_BRIDGE
+
+#include "NbusCommunicatorEsp32.h"
+
+NbusCommunicatorEsp32::NbusCommunicatorEsp32(Stream &uartNbus, Stream &uartMaster, uint32_t timeout)
+: NbusLoopEsp32(uartMaster, timeout), _uart_nbus{uartNbus}, _uart_master{uartMaster}
+{
+    NbusLoopEsp32::setData(_data_packet_master_rx, NBUS_COMM_MAX_FRAME_SIZE);
+}
+
+void NbusCommunicatorEsp32::sendToMaster(DataFrame *master_frame)
+{
+	if (master_frame == nullptr || master_frame->IsEmpty())
+		return;
+
+    _uart_master.write(master_frame->GetFrame(), master_frame->GetLength());
+}
+
+DataFrame* NbusCommunicatorEsp32::receiveFromMaster()
+{
+    int32_t rx_size = NbusLoopEsp32::receiveData();
+
+    _packet_master_rx.Init();
+    _packet_master_rx.FromArray(_data_packet_master_rx, rx_size);
+    _packet_master_rx.Commit();
+
+    return &_packet_master_rx;
+}
+
+void NbusCommunicatorEsp32::sendToSlave(DataFrame *slaveFrame)
+{
+    setLedOn();
+    _uart_nbus.write(slaveFrame->GetFrame(), slaveFrame->GetLength());
+    setLedOff();
+}
+
+DataFrame* NbusCommunicatorEsp32::sendAndReceiveSlave(DataFrame *slave_frame)
+{
+    this->sendToSlave(slave_frame);
+    return this->receiveFromSlave();
+}
+
+DataFrame* NbusCommunicatorEsp32::receiveFromSlave()
+{
+    int16_t packet_size = 0;
+    int16_t received_size = 0;
+    int16_t in_bytes = 0;
+    //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
+    
+    // reference time
+    time_t time0 = millis();
+
+    // read packet length
+    while (packet_size == 0 && millis() - time0 <= NBUS_COMM_UART_RX_TIMEOUT)
+    {
+        if (_uart_nbus.available())
+        {
+            packet_size = _uart_nbus.read();
+            _data_packet_slave_rx[received_size++] = packet_size;
+        }
+    }
+
+    // read rest of the packet
+    while (received_size < packet_size && millis() - time0 <= NBUS_COMM_UART_RX_TIMEOUT)
+    {
+        in_bytes = _uart_nbus.available();
+        
+        if (in_bytes > 0)
+        {
+            _uart_nbus.readBytes(_data_packet_slave_rx + received_size, in_bytes);
+            received_size += in_bytes;
+        }
+    }
+
+    _packet_slave_rx.Init();
+
+    if (received_size > 0)
+    {
+        _packet_slave_rx.FromArray(_data_packet_slave_rx, received_size);
+    }
+
+    //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
+
+    _packet_slave_rx.Commit();
+    return &_packet_slave_rx;
+}
+
+void NbusCommunicatorEsp32::setLedOn()
+{
+#if NBUS_USE_LED
+    #if NBUS_LED_POLARITY_REVERSED
+        digitalWrite(NBUS_LED_PIN, LOW);
+    #else
+        digitalWrite(NBUS_LED_PIN, HIGH);
+    #endif // POLARITY    
+#endif // NBUS_USE_LED
+}
+
+void NbusCommunicatorEsp32::setLedOff()
+{
+#if NBUS_USE_LED
+    #if NBUS_LED_POLARITY_REVERSED
+        digitalWrite(NBUS_LED_PIN, HIGH);
+    #else
+        digitalWrite(NBUS_LED_PIN, LOW);
+    #endif // POLARITY    
+#endif // NBUS_USE_LED
+}
+
+void NbusCommunicatorEsp32::toggleLed()
+{
+#if NBUS_USE_LED
+    digitalWrite(NBUS_LED_PIN, !digitalRead(NBUS_LED_PIN));
+#endif // NBUS_USE_LED
+}
+
+uint32_t NbusCommunicatorEsp32::getTime()
+{
+    return millis();
+}
+
+#endif // NBUS_NODE_TYPE

src/NbusBridgeDriver/NbusCommunicatorEsp32.h

@@ -0,0 +1,74 @@
+#if NBUS_NODE_TYPE_BRIDGE
+
+#ifndef NBUS_COM_ESP32_H
+#define NBUS_COM_ESP32_H
+
+#include <cinttypes>
+#include <esp32-hal.h>
+#include <Stream.h>
+#include "NbusCommunicator.h"
+#include "NbusLoopDriver/NbusLoopEsp32.h"
+
+class NbusCommunicatorEsp32 : public NbusCommunicator, public NbusLoopEsp32
+{
+public:
+    NbusCommunicatorEsp32(Stream &uart_nbus, Stream &uart_master, uint32_t timeout);
+
+    /** Send data to master.
+	 *  @param master_frame: data frame to send
+	 */
+	void sendToMaster(DataFrame *master_frame) override;
+
+	/** Receive packet from master
+	 * @return received data frame
+	 */
+	DataFrame* receiveFromMaster() override;
+
+	/** Send data to slave.
+	 *  @param slave_frame: data frame to send
+	 */
+	void sendToSlave(DataFrame *slave_frame) override;
+
+	/** Receive data from slave.
+     * 	@return received data frame
+	 */
+	DataFrame* receiveFromSlave() override;
+
+    /** Send data to slave and receive response.
+	 *  @param slave_frame: data frame to send
+	 *  @return: response data frame
+	 */
+    DataFrame* sendAndReceiveSlave(DataFrame *slave_frame) override;
+
+	/** Set onboard LED to ON-state.
+	 */
+	void setLedOn() override;
+	
+	/** Set onboard LED to OFF-state.
+	 */
+	void setLedOff() override;
+	
+	/** Change onboard LED state.
+	 */
+	void toggleLed() override;
+	
+	/** Get actual elapsed time in ms
+	 * @return time in ms
+	 */
+	uint32_t getTime() override;
+
+private:
+
+	uint8_t _data_packet_slave_rx[NBUS_COMM_MAX_FRAME_SIZE]{0};									            ///< raw RX data packet for slave
+	uint8_t _data_packet_master_rx[NBUS_COMM_MAX_FRAME_SIZE]{0};							                ///< raw RX data packet for master
+    
+    DataFrame _packet_slave_rx{_data_packet_slave_rx, NBUS_COMM_MAX_FRAME_SIZE, TYPE_PLAIN, CRC_OFF};       ///< RX data frame for slave
+	DataFrame _packet_master_rx{_data_packet_slave_rx, NBUS_COMM_MAX_FRAME_SIZE, TYPE_RAW, CRC_OFF};        ///< RX data frame for master
+    
+    Stream &_uart_nbus;												                                        ///< pointer to UART nBus
+	Stream &_uart_master;												                                    ///< pointer to UART master
+};
+
+#endif // NBUS_COM_ESP32_H
+
+#endif // NBUS_NODE_TYPE

nbus_app_driver.cpp → src/NbusLoopDriver/NbusLoopEsp32.cpp

@@ -1,18 +1,23 @@
-#include "nbus_app_driver.h"
+#include "NbusLoopEsp32.h"
 
-NbusAppDriver::NbusAppDriver(Stream *stream_obj, uint8_t *data, int16_t size, int32_t timeout)
-: _stream_obj{stream_obj}, _data{data}, _size{size}, _timeout{timeout}
+NbusLoopEsp32::NbusLoopEsp32(Stream &stream_obj, int32_t timeout)
+: _stream_obj{stream_obj}, _timeout{timeout}
 {
 
 }
 
-void NbusAppDriver::setData(uint8_t *data, int16_t size)
+void NbusLoopEsp32::setData(uint8_t *data, int16_t size)
 {
     _data = data;
     _size = size;
 }
 
-int16_t NbusAppDriver::receiveFromMaster()
+Stream& NbusLoopEsp32::accessStream()
+{
+    return _stream_obj; 
+}
+
+int16_t NbusLoopEsp32::receiveData()
 {     
     // check if timeout elapsed
     if (_checkTimeout() == 1)
@@ -22,7 +27,7 @@ int16_t NbusAppDriver::receiveFromMaster()
     }
 
     // get incoming bytes
-    int32_t in_bytes = _stream_obj->available();
+    int32_t in_bytes = _stream_obj.available();
 
     // check if empty
     if (in_bytes == 0)
@@ -33,7 +38,7 @@ int16_t NbusAppDriver::receiveFromMaster()
     // read length
     if (_rx_size == 0)
     {
-        _rx_size = _stream_obj->read();
+        _rx_size = _stream_obj.read();
 
         // check length size
         if (_rx_size < NBUS_APP_DRIVER_PAYLOAD_MIN || _rx_size > NBUS_APP_DRIVER_PAYLOAD_MAX)
@@ -56,7 +61,7 @@ int16_t NbusAppDriver::receiveFromMaster()
             return 0;
         }
 
-        _rx_index += _stream_obj->readBytes(_data + _rx_index, in_bytes);
+        _rx_index += _stream_obj.readBytes(_data + _rx_index, in_bytes);
     }
 
     if (_rx_index >= _rx_size)
@@ -71,7 +76,12 @@ int16_t NbusAppDriver::receiveFromMaster()
     }
 }
 
-bool NbusAppDriver::_checkTimeout()
+bool NbusLoopEsp32::isReceiving()
+{
+    return _rx_index > 0;
+}
+
+bool NbusLoopEsp32::_checkTimeout()
 {
     if (_time0 == INT64_MAX)
     {
@@ -81,7 +91,7 @@ bool NbusAppDriver::_checkTimeout()
     return millis() - _time0 > _timeout;
 }
 
-void NbusAppDriver::_resetRxState()
+void NbusLoopEsp32::_resetRxState()
 {
     _rx_index = 0;
     _rx_size = 0;

nbus_app_driver.h → src/NbusLoopDriver/NbusLoopEsp32.h

@@ -8,19 +8,22 @@
 #define NBUS_APP_DRIVER_PAYLOAD_MIN 4
 #define NBUS_APP_DRIVER_PAYLOAD_MAX 127
 
-class NbusAppDriver
+class NbusLoopEsp32
 {
 public:
-    NbusAppDriver(Stream *stream_obj, uint8_t *data, int16_t size, int32_t timeout);
+    NbusLoopEsp32(Stream &stream_obj, int32_t timeout);
     void setData(uint8_t *data, int16_t size);
-    int16_t receiveFromMaster();
-    
-    
+
+    Stream& accessStream();
+    int16_t receiveData();
+
+    bool isReceiving();
+     
 private:
     bool _checkTimeout();
     void _resetRxState();
 
-    Stream  *_stream_obj;
+    Stream  &_stream_obj;
     uint8_t *_data{nullptr};
     int16_t _size{0};
     int32_t _timeout{0};

src/NbusSlaveDriver/nbus_app_interface_esp32.cpp

@@ -0,0 +1,116 @@
+#ifdef NBUS_NODE_TYPE_SLAVE
+
+#include "nbus_app_interface_esp32.h"
+
+
+static NbusLoopEsp32 *_loop_driver;
+static bool _in_transmission = false;
+
+nBusPlatformInterface_t* nbus_platform_init(NbusLoopEsp32 *loop_driver)
+{
+  #if NBUS_USE_LED
+    pinMode(NBUS_LED_PIN, OUTPUT);
+
+    #if NBUS_LED_POLARITY_REVERSED
+      digitalWrite(NBUS_LED_PIN, HIGH);
+    #else
+      digitalWrite(NBUS_LED_PIN, LOW);
+    #endif // POLARITY    
+  #endif // NBUS_USE_LED
+
+  _loop_driver = loop_driver;
+  return &nbus_hw_platform;
+}
+
+static inline void uart_send(uint8_t *data, int n)
+{  
+  _loop_driver->accessStream().write(data, n);
+}
+
+static inline void uart_receive(uint8_t *dataNBUS, int n)
+{
+  _loop_driver->setData(dataNBUS, n);
+}
+
+static inline void led_on()
+{
+#if NBUS_USE_LED
+    #if NBUS_LED_POLARITY_REVERSED
+        digitalWrite(NBUS_LED_PIN, LOW);
+    #else
+        digitalWrite(NBUS_LED_PIN, HIGH);
+    #endif // POLARITY    
+#endif // NBUS_USE_LED
+}
+
+static inline void led_off()
+{
+#if NBUS_USE_LED
+    #if NBUS_LED_POLARITY_REVERSED
+        digitalWrite(NBUS_LED_PIN, HIGH);
+    #else
+        digitalWrite(NBUS_LED_PIN, LOW);
+    #endif // POLARITY    
+#endif // NBUS_USE_LED
+}
+
+static inline void led_toggle()
+{
+#if NBUS_USE_LED
+    digitalWrite(NBUS_LED_PIN, !digitalRead(NBUS_LED_PIN));
+#endif // NBUS_USE_LED
+}
+
+static inline void app_delay(uint8_t ms)
+{
+  delay(ms);
+}
+
+static inline uint8_t loop_callback(nBusStateCallbackType_t state_check)
+{
+  if (state_check == CallbackType_SENSOR)
+  {
+    return 0;
+  }
+
+  if (state_check == CallbackType_UART)
+  {
+    return 1; 
+  }
+
+  return 0;
+}
+
+void nbus_platform_loop()
+{
+  int16_t size = _loop_driver->receiveData();
+
+  if (_in_transmission == false && _loop_driver->isReceiving() == true)
+  {
+    led_on();
+    _in_transmission = true;
+  }
+  
+  if (_in_transmission == true && _loop_driver->isReceiving() == false)
+  {
+    led_off();
+    _in_transmission = false;
+  }
+
+  if (size > 0)
+  {
+    nbus_cb_UART_RX(size);
+  }
+}
+
+nBusPlatformInterface_t nbus_hw_platform = {
+    uart_receive,
+    uart_send,
+    led_on,
+    led_off,
+    led_toggle,
+    app_delay,
+    loop_callback,
+};
+
+#endif // NBUS_NODE_TYPE

src/NbusSlaveDriver/nbus_app_interface_esp32.h

@@ -0,0 +1,31 @@
+/** 
+ * @brief Implementation of nbus app interface.
+ */
+#if NBUS_NODE_TYPE_SLAVE
+
+#ifndef INC_APP_INTERFACE_H_
+#define INC_APP_INTERFACE_H_
+
+#include <cinttypes>
+#include <esp32-hal-gpio.h>
+#include <Stream.h>
+#include "NbusLoopDriver/NbusLoopEsp32.h"
+
+#include "nbus_app.h"
+
+/** 
+ * @brief Initialize nbus with loop driver object (UART, BT, ...).
+ * @param SerialObj: pointer to serial object
+ */
+nBusPlatformInterface_t* nbus_platform_init(NbusLoopEsp32 *loop_driver);
+
+/** 
+ * @brief Process incoming nbus data from stream interface in main loop.
+ */
+void nbus_platform_loop();
+
+extern nBusPlatformInterface_t nbus_hw_platform;    ///< Instance of hardware platform
+
+#endif // NBUS_NODE_TYPE
+
+#endif /* INC_APP_INTERFACE_H_ */