Hi

I am using two identical sets: BRD4001A + BRD4250A (EFR32FG). I am trying to transmit data received in the stream from VCOM over the radio channel, and on a primitive device send the received data to VCOM too.The example simple_trx_with_fifo was taken as a basis.

On the transmitting device, I read the data in the main loop using  the following function:

void send_uart_data(void){

	  int uart_count;
	  uint16_t Tx_Fifo_Space;
	  int a;
	  int len = 0;
	  if (packetTx){
		  uart_count = get_rx_count(); //get the number of unread bytes from the UART ring buffer
		  Tx_Fifo_Space = RAIL_GetTxFifoSpaceAvailable(railHandle);
		  if((uart_count >= 1) && Tx_Fifo_Space == TX_FIFO_SIZE) {
			len = (uart_count + PACKET_HEADER_LEN) < Tx_Fifo_Space ?  uart_count : Tx_Fifo_Space -2;
			for (int i = PACKET_HEADER_LEN; i < len + PACKET_HEADER_LEN; i++) {
			  a = RETARGET_ReadChar();
			  txPtr[i] = (uint8_t)a; //global array for radio transmission
			}
			sendPacket(len + PACKET_HEADER_LEN);
		  }
	}
}

void sendPacket(uint16_t packetLength)
{
  RAIL_Idle(railHandle, RAIL_IDLE, true);
  txPtr[0] = (packetLength - PACKET_HEADER_LEN) >> 8;
  txPtr[1] = (packetLength - PACKET_HEADER_LEN) & 0xff;

  txWritten = RAIL_WriteTxFifo(railHandle, txPtr, packetLength, true);
  packetTx = false;
  tx_count += txWritten;
  RAIL_StartTx(railHandle, channel, RAIL_TX_OPTIONS_DEFAULT, NULL);

}

On the receiving side, when RAIL_EVENT_RX_PACKET_RECEIVED occurs, I call the function to save the received packet from the RX FIFO to my ring buffer:

void read_RX_FIFO(void){

	uint8_t tmp_rx_buff[MAX_FRAME_LENGTH];
	uint16_t len = calc_message_length();
	if (len == 0){
		return;
	}

	RAIL_ReadRxFifo(railHandle, tmp_rx_buff, len);
	err = write_mas_to_ring_buffer(&ring_buff, tmp_rx_buff, len + 1);
}
uint16_t calc_message_length(void){

	uint8_t tmp_buff[2];
	uint16_t bytes_for_read = RAIL_GetRxFifoBytesAvailable(railHandle);
	if (bytes_for_read <=2){
		return 0;
	}
	RAIL_ReadRxFifo(railHandle, tmp_buff, 2);
	bytes_for_read = (uint16_t)tmp_buff[0] << 8 | tmp_buff[1];

	return bytes_for_read;
}

// ring buffer structure

struct ring_buffer{

	uint8_t BUF[BUFF_LEN];
	uint16_t byte_count;
	uint16_t PtrHead;
	uint16_t PtrTail;
};

int write_mas_to_ring_buffer(struct ring_buffer *buffer, uint8_t *mas, uint16_t bytes_for_write){

	int err = BUFFER_WRITE_OK;
	for (int i = 0; i < bytes_for_write; i++){
		buffer->BUF[buffer->PtrHead] = mas[i];
		buffer->PtrHead = (buffer->PtrHead + 1) % BUFF_LEN;
		if ((buffer->PtrHead + 1) == buffer->PtrTail){
			buffer->PtrTail = (buffer->PtrTail + 1) % BUFF_LEN;
			err = BUFFER_OVERFLOW;
		}
	}
	buffer->byte_count += bytes_for_write;
	return err;
}

After that in the main loop I call the function to read the ring buffer into VCOM:

void read_ring_buff(void){
	uint8_t tmp = 0;;
	int err = BUFFER_READ_EMPTY;
	if(RETARGET_IsTX_ready()){
		err = read_byte_ring_buffer(&tmp, &ring_buff);
		if (err == BUFFER_READ_OK){
		    RETARGET_WriteChar((char)tmp);
		}
	}
}

int read_byte_ring_buffer(uint8_t *byte, struct ring_buffer *buffer){

	int err = BUFFER_READ_OK;
	if ((buffer->PtrTail != buffer->PtrHead) /*&& (buffer->byte_count != 0)*/){
		*byte = buffer->BUF[buffer->PtrTail];
		buffer->PtrTail = (buffer->PtrTail + 1) % BUFF_LEN;
		buffer->byte_count--;
	}
	if (buffer->PtrTail == buffer->PtrHead)
		err = BUFFER_READ_EMPTY;
	return err;
}

int RETARGET_IsTX_ready(void){
	if (!(RETARGET_UART->STATUS & USART_STATUS_TXIDLE)){
		return 0;
	}
		return 1;
}

I cannot understand at what point and in what place the data is lost and for what reason. The data is most likely not the same as the one sent. If you send a small amount of data, then there are slightly fewer errors.

Thanks.