Usage of Fw::Buffer with UART always throw fatal error

[poonamdeoghare]

Sorry for the very long Post.
I’m trying to use an RTEMS/GR740 build to communicate with a one of my component over UART. The component is a straightforward ActiveComponentBase that uses the byte-stream driver and the buffer manager for TX/RX. Despite moving the initial handshake into the scheduler so it only runs once and guarding buffers with Fw::Buffer::NO_CONTEXT, the application still aborts immediately on startup with the buffer-manager fatal (Assert: "/root/aFATAL 16897 handFATAL occurred in task ID: 0x0a010001). Because the fatal fires before schedIn_handler gets a tick, I never see my component logging or send/receive.

What I expected ---------- My understanding may be wrong
xAxisUartReady_handler sets a flag when the GR740 UART driver indicates it’s ready. --- Getting this
The first call to schedIn_handler detects that flag,and perform the action mentioned in the handler --- Not happening
xAxisUartRecv_handler logs whatever comes back and returns the buffer to the manager.---- Not happening

What is Happening My understanding may be wrong
On deployment- Assert: "/root/aFATAL 16897 hand FATAL occurred in task ID: 0x0a010001

The task crashes right after xAxisUartReady_handler, so schedIn_handler never runs and neither send nor receive prints appear.

Because the component dies, the UART pipeline is never exercised beyond the initial ready notification.

My Code Snippet:-
Component.fpp
@ UART port for the stage
output port xAxisUart: Drv.ByteStreamSend

@ UART ready status for the stage
sync input port xAxisUartReady: Drv.ByteStreamReady

@ UART receive for the stage
async input port xAxisUartRecv: Drv.ByteStreamRecv

@ Schedule port for periodic tasks
async input port schedIn: [3] Svc.Sched

@ Port for allocating buffers shared with the UART driver
output port bufferAllocate: Fw.BufferGet

@ Port for returning buffers to the manager
output port bufferDeallocate: Fw.BufferSend

---

topology.fpp

connections XeryonComm {
xeryonController.xAxisUart -> xeryonUartInst.$send
xeryonUartInst.$recv -> xeryonController.xAxisUartRecv
xeryonUartInst.ready -> xeryonController.xAxisUartReady
}

# Connect to buffer manager for UART //Added port for the bufferManager
connections XeryonBuffers {
  xeryonUartInst.allocate -> bufferManager.bufferGetCallee
  xeryonUartInst.deallocate -> bufferManager.bufferSendIn     
  xeryonController.bufferAllocate -> bufferManager.bufferGetCallee
  xeryonController.bufferDeallocate -> bufferManager.bufferSendIn
}

# Connect to scheduler
connections XeryonScheduler {
  # 1Hz for connection check and telemetry
  rateGroup1.RateGroupMemberOut[8] -> xeryonController.schedIn[0]
  
  # 10Hz for sequence execution
  rateGroup2.RateGroupMemberOut[9] -> xeryonController.schedIn[1]
  
  # 10Hz for UART transmit
  rateGroup3.RateGroupMemberOut[1] -> xeryonController.schedIn[2]
}

---

topology.cpp
// Initialize and start the UART driver for Xeryon
bool xeryonuartsuccess = xeryonUartInst.open(BaseAddress::XERYON_X_UART , "XERYON_X_UART", // Device name
Drv::GR740UartDriver::BAUD_9600, // 9600 baud (adjust as needed for xeryon)
Drv::GR740UartDriver::NO_FLOW, // No flow control
Drv::GR740UartDriver::PARITY_NONE, // No parity
1024 // Buffer allocation size
);

if (xeryonuartsuccess) {
    // Start the UART receive task
    LedBlinker::xeryonUartInst.start(110,    // Task priority
                                     16384,  // Stack size
                                     -1      // CPU affinity (-1 for any CPU)
    );
    Fw::Logger::log("===========Xeryon UART initialized successfully====================\n");

} else {
    Fw::Logger::log("ERROR: Failed to initialize Xeryon UART\n");
}

---

void XeryonXYZ ::
xAxisUartReady_handler(FwIndexType portNum)
{
Fw::Logger::log("---Ready Xeryon xAxisUartReady_handler------\n");
m_connected = true;
m_handshakeInitiated = false;}

---

void XeryonXYZ ::
xAxisUartRecv_handler(
FwIndexType portNum,
Fw::Buffer& recvBuffer,
const Drv::RecvStatus& recvStatus
)
{
Fw::Logger::log("---Xeryon xAxisUartRecv_handler \n");
if (recvStatus == Drv::RecvStatus::RECV_OK) {
Os::ScopeLock lock(m_mutex);

    const U8* data = recvBuffer.getData();
    const U32 size = recvBuffer.getSize();
    Fw::Logger::log("---Xeryon xAxisUartRecv_handler------size =  %d \n",size);
    const U32 copySize = std::min<U32>(size, static_cast<U32>(sizeof(rxBuffer)));
    if (copySize > 0U) {
        std::memcpy(rxBuffer, data, copySize);
        Fw::Logger::log("---Xeryon copySize is > 0 \n");
    }    
          
} else {
    // Log error but avoid spamming
    static U32 errorCount = 0;
    if (++errorCount % 100 == 0) {
        Fw::Logger::log("========== XERYON UART receive error======\n");            
    }
}
if (this->isConnected_bufferDeallocate_OutputPort(0) &&
    recvBuffer.isValid() &&
    recvBuffer.getContext() != Fw::Buffer::NO_CONTEXT) {
    this->bufferDeallocate_out(0, recvBuffer);
} else if (recvBuffer.isValid() &&
           recvBuffer.getContext() == Fw::Buffer::NO_CONTEXT) {
    // this->log_WARNING_HI_CommunicationError(Fw::LogStringArg("UART provided buffer with invalid ID"));
    Fw::Logger::log("--UART provided buffer with invalid ID--\n");
}

}-----------------------------------

void XeryonXYZ::sendUartData(const char* data) {
if (data == nullptr) {
// return;
Fw::Logger::log("---Data is Null\n");
}

const U32 size = static_cast<U32>(std::strlen(data));
if (size == 0U) {
    // return;
    Fw::Logger::log("---size is zero\n");
}

Fw::Logger::log("Sending Xeryon command of length (%d bytes) and %s:\n", size, data);

if (!this->isConnected_bufferAllocate_OutputPort(0)) {
    // this->log_WARNING_HI_CommunicationError(
    //     Fw::LogStringArg("bufferAllocate not connected"));
    // return;
     Fw::Logger::log("bufferAllocate not connected");
}

Fw::Buffer sendBuffer = this->bufferAllocate_out(0, size);
if (!sendBuffer.isValid()) {
    // this->log_WARNING_HI_CommunicationError(
    //     Fw::LogStringArg("Failed to allocate send buffer"));        
    Fw::Logger::log("Failed to allocate send buffer");
    return;
    
}

std::memcpy(sendBuffer.getData(), data, size);
sendBuffer.setSize(size);

const Drv::SendStatus status = this->xAxisUart_out(0, sendBuffer);
if (status != Drv::SendStatus::SEND_OK) {
    if (this->isConnected_bufferDeallocate_OutputPort(0)) {
        this->bufferDeallocate_out(0, sendBuffer);
    }
    // this->log_WARNING_HI_CommunicationError(Fw::LogStringArg("UART send failed"));
     Fw::Logger::log("UART send failed");
     return;
}

}

void XeryonXYZ ::
schedIn_handler(
FwIndexType portNum,
U32 context
)
{
Fw::Logger::log("---------schedIn_handler Xeryon ------\n");
sendUartData("INFO=?\n");
}-----------------------------------

Given the wiring and code above, is there anything else I should check on the F´ side that would cause the buffer manager to assert immediately (event 16897/invalid buffer ID) during startup? What else is going wrong. Please suggest or guide me to send and receive the UART data. Thanking you in advance .

[thomas-bc]

Converted to discussion.
It doesn't look like you've called the BufferManager::setup() method in your topology setup, to configure the BufferManager pools. Can you confirm? If it's not there, it would cause the assert you're seeing. If it is there, allocating memory before setup could also cause the issue. Make sure it's in the configureTopology() section of your topology.cpp.