smfsw / cqueue Goto Github PK

Queue_t canrx_queue;

void receive_transfers(CanardInstance *const canard)
{
	CanardFrame rxf;
	CanardTransfer transfer;
	if (q_isEmpty(&canrx_queue))
	{
		return;
	}

	q_pop(&canrx_queue, &rxf); // <---- this rxf frame has corrupt payload sometimes

	const int8_t result = canardRxAccept2(canard, &rxf, 0, &transfer, NULL);
	if (result < 0)
	{
		usart2::usart_send_string("HERE!!!\n");
		// An error has occurred: either an argument is invalid or we've ran out of memory.
		return;
	}
	else if (result == 1)
	{
		// usart2::usart_send_string("HERE!\n");
		process_received_transfer(&transfer);
		canard->memory_free(canard, (void *)transfer.payload);
	}
	else
	{
		uint8_t *check = (uint8_t *)rxf.payload;
		uint8_t check_var = *check;
		usart2::usart_send_int(check_var, true);
		// GREEN_LED_ON;
		// GREEN_LED_OFF;
	}
}

extern "C"
{
	void USB_LP_CAN1_RX0_IRQHandler(void)
	{
		if ((CAN1->RF0R & CAN_RF0R_FMP0) || (CAN1->RF1R & CAN_RF1R_FMP1)) 
		{
			uint32_t extended_can_id;
			size_t payload_size;
			uint8_t payload[8] = {0};
			bxCANPop(0, &extended_can_id, &payload_size, payload);
			CanardFrame rxf = {timer2::get_micros(), extended_can_id, payload_size, payload};
			q_push(&canrx_queue, &rxf);
		}
	}
}

typedef struct
{
    /// For RX frames: reception timestamp.
    /// For TX frames: transmission deadline.
    /// The time system may be arbitrary as long as the clock is monotonic (steady).
    CanardMicrosecond timestamp_usec;

    /// 29-bit extended ID. The bits above 29-th shall be zero.
    uint32_t extended_can_id;

    /// The useful data in the frame. The length value is not to be confused with DLC!
    /// If the payload is empty (payload_size = 0), the payload pointer may be NULL.
    /// For RX frames: the library does not expect the lifetime of the pointee to extend beyond the point of return
    /// from the API function. That is, the pointee can be invalidated immediately after the frame has been processed.
    /// For TX frames: the frame and the payload are allocated within the same dynamic memory fragment, so their
    /// lifetimes are identical; when the frame is freed, the payload is invalidated.
    /// A more detailed overview of the dataflow and related resource management issues is provided in the API docs.
    size_t      payload_size;
    const void* payload;
} CanardFrame;