Hi Shima,
I was aware of that example, unfortunately it is limited to the use of the
result = cy_retarget_io_init(CYBSP_DEBUG_UART_TX, CYBSP_DEBUG_UART_RX,
CY_RETARGET_IO_BAUDRATE);
and the default UART on SCB5.
I have an UART configured on SCB4 and I am trying to get it to work.
Please see the attached source on the initialization. The Init func is called in main() before the IRQ are enabled. I then use
(void) Cy_SCB_UART_Transmit(scb_4_HW, txBuffer, sizeof(txBuffer), &uartContext);
/* Blocking wait for transmission completion */
while (0UL != (CY_SCB_UART_TRANSMIT_ACTIVE & Cy_SCB_UART_GetTransmitStatus(scb_4_HW, &uartContext)))
{
}
which seems to work. However after that I cannot get a receipt and rather get an error from somewhere
Info : SWD DPIDR 0x6ba02477
Error: Failed to read memory at 0xb4e50a40
the program halts at
configASSERT( xTaskToNotify != NULL );
Maybe your experienced eye can spot a problem ? Any working example of an actual SCB UART implementation outside of the SCB5 default UART would be very much appreciated.
Thanks
Stefan
/* Allocate context for UART operation */
cy_stc_scb_uart_context_t uartContext;
static TaskHandle_t xTaskToNotify = NULL;
char rxBuffer[UART_BUFFER_SIZE];
void initUART() {
/* Set up the device based on configurator selections */
init_cycfg_all();
/* Configure UART to operate */
(void) Cy_SCB_UART_Init(scb_4_HW, &scb_4_config, &uartContext);
/* Populate configuration structure (code specific for CM4) */
cy_stc_sysint_t uartIntrConfig =
{
.intrsrc=UART_INTR_NUM,
.intrPriority = UART_INTR_PRIORITY,
};
/* Hook interrupt service routine and enable interrupt */
(void) Cy_SysInt_Init(&uartIntrConfig, &UART_Isr);
NVIC_EnableIRQ(UART_INTR_NUM);
/* Enable UART to operate */
Cy_SCB_UART_Enable(scb_4_HW);
}
void uart_task(void *pvParameters) {
/* To avoid compiler warnings */
(void)pvParameters;
uint32_t ulNotificationValue;
while (true) {
/* Start the receiving from UART. */
UART_receive();
/* Wait to be notified that the receive is complete. Note
the first parameter is pdTRUE, which has the effect of clearing
the task's notification value back to 0, making the notification
value act like a binary (rather than a counting) semaphore. */
ulNotificationValue = ulTaskNotifyTake(pdTRUE, portMAX_DELAY );
if( ulNotificationValue == 1 )
{
/* Blocking wait until buffer is full */
// in this example, it will never handle because the UART interrupt fires exactly when the buffer is full
while (0UL != (CY_SCB_UART_RECEIVE_ACTIVE & Cy_SCB_UART_GetReceiveStatus(scb_4_HW, &uartContext))) {}
/* Handle received data */
char tempBuffer[UART_BUFFER_SIZE];
sprintf(tempBuffer, rxBuffer);
}
}
}
// UART activate a receive with interrupt. Wait for ever for UART_BUFFER_SIZE bytes
void UART_receive() {
/* At this point xTaskToNotify should be NULL as no receive
is in progress. A mutex can be used to guard access to the
peripheral if necessary. */
configASSERT( xTaskToNotify == NULL );
/* Store the handle of the calling task. */
xTaskToNotify = xTaskGetCurrentTaskHandle();
/* Start receive operation (do not check status) */
(void) Cy_SCB_UART_Receive(scb_4_HW, rxBuffer, sizeof(rxBuffer), &uartContext);
}
// UART interrupt handler
void UART_Isr() {
Cy_SCB_UART_Interrupt(scb_4_HW, &uartContext);
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
configASSERT( xTaskToNotify != NULL );
/* Notify the task that the receive is complete. */
vTaskNotifyGiveFromISR( xTaskToNotify, &xHigherPriorityTaskWoken );
/* There are no receive in progress, so no tasks to notify. */
xTaskToNotify = NULL;
/* If xHigherPriorityTaskWoken is now set to pdTRUE then a
context switch should be performed to ensure the interrupt
returns directly to the highest priority task. The macro used
for this purpose is dependent on the port in use and may be
called portEND_SWITCHING_ISR(). */
portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}
