nBus-bridge-core/Src/NbusCommunicator.cpp

/**
 * @file NbusCommunicator.cpp
 * @brief Implementation of hardware communication interface.
 * @date Jun 19, 2026
 * @author Juraj Dudak, Matus Necas
 */

#include "NbusCommunicator.h"

#if !defined(ESP32)

NbusCommunicator::NbusCommunicator(UART_HandleTypeDef *uartNbus, UART_HandleTypeDef *uartMaster)
: _uart_nbus{uartNbus}, _uart_master{uartMaster}
{

}

void NbusCommunicator::sendToMaster(DataFrame *master_frame)
{
	if (master_frame == nullptr || master_frame->IsEmpty())
		return;

	while (_uart_master->gState != HAL_UART_STATE_READY)
    {
        __NOP(); // cakanie na ukoncenie prebiehajuceho odosielania
                 // tu to moze byt vcelku tesno odoslany dalsi paket. je tam pauza o dlzke 1.2bit
    }

    HAL_UART_Transmit_DMA(_uart_master, master_frame->GetFrame(), master_frame->GetLength());
}

void NbusCommunicator::sendToSlave(DataFrame *slaveFrame)
{
    setLedOn();
    HAL_UART_Transmit(_uart_nbus, slaveFrame->GetFrame(), slaveFrame->GetLength(), NBUS_COMM_UART_TX_TIMEOUT);
    setLedOff();
}

DataFrame* NbusCommunicator::sendAndReceiveSlave(DataFrame *slave_frame)
{
    this->sendToSlave(slave_frame);
    this->_receiveFromSlave();
    return &_packet_rx;
}

void NbusCommunicator::_receiveFromSlave()
{
    uint16_t received_size;
    setLedOn();

    memset(_data_packet_comm, 0, NBUS_COMM_MAX_FRAME_SIZE);
    // DMA communication must be in blocking mode for less overhead
    HAL_StatusTypeDef status = HAL_UARTEx_ReceiveToIdle(_uart_nbus, _data_packet_comm, NBUS_COMM_MAX_FRAME_SIZE,
                                                        &received_size, NBUS_COMM_UART_RX_TIMEOUT);

    _packet_rx.Init();

    if (status == HAL_OK)
    {
        if (received_size > 0)
        {
            _packet_rx.FromArray(_data_packet_comm, received_size);
        }
    }

    setLedOff();

    _packet_rx.Commit();
}

void NbusCommunicator::setLedOn()
{
#if NBUS_USE_LED
    #if NBUS_LED_POLARITY_REVERSED
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
    #else
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
    #endif // POLARITY
#endif // NBUS_USE_LED
}

void NbusCommunicator::setLedOff()
{
#if NBUS_USE_LED
    #if NBUS_LED_POLARITY_REVERSED
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
    #else
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
    #endif // POLARITY
#endif // NBUS_USE_LED
}

void NbusCommunicator::toggleLed()
{
#if NBUS_USE_LED
    HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
#endif // NBUS_USE_LED
}

#else // ESP32

NbusCommunicator::NbusCommunicator(UART_HandleTypeDef *uartNbus, UART_HandleTypeDef *uartMaster)
: _uart_nbus{uartNbus}, _uart_master{uartMaster}
{

}

void NbusCommunicator::sendToMaster(DataFrame *master_frame)
{
	if (master_frame == nullptr || master_frame->IsEmpty())
		return;

    _uart_master->write(master_frame->GetFrame(), master_frame->GetLength());
}

void NbusCommunicator::sendToSlave(DataFrame *slaveFrame)
{
    setLedOn();
    _uart_nbus->write(slaveFrame->GetFrame(), slaveFrame->GetLength());
    setLedOff();
}

DataFrame* NbusCommunicator::sendAndReceiveSlave(DataFrame *slave_frame)
{
    this->sendToSlave(slave_frame);
    this->_receiveFromSlave();
    return &_packet_rx;
}

void NbusCommunicator::_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_comm[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_comm + received_size, in_bytes);
            received_size += in_bytes;
        }
    }

    _packet_rx.Init();

    if (received_size > 0)
    {
        _packet_rx.FromArray(_data_packet_comm, received_size);
    }

    //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);

    _packet_rx.Commit();
}

void NbusCommunicator::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 NbusCommunicator::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 NbusCommunicator::toggleLed()
{
#if NBUS_USE_LED
    digitalWrite(NBUS_LED_PIN, !digitalRead(NBUS_LED_PIN));
#endif // NBUS_USE_LED
}

#endif // platform