PSoC™ 6 Forum Discussions

Hello Community,

I finally got the scb4 UART with pins configured from port 8 to initialize without errors. The pins 8.0 and 8.1 can be disconnected from the CAPSENSE Buttons as instructed in the KIT documentation on page 48.

The RX signal arrives at the respective pin but I cannot register any interrupt or received bytes in the code. Am I still missing something ? Again, the uartInit() runs without any error, I can measure the RX signal coming in to P8.0

but no firing of the Interrupt. Likewise if I try to send a TX, the first TX returns successfully but the second TX produces

an error saying the TX is still busy.

I am using freertos, the UART_task runs in a separate task. The uartContext is a global variable and, where needed made available via "extern".

Any help is greatly appreciated - we are crunching on an exciting ornithology research projects using Wifi-BT KITs as

a central component.

Thanks

Stefan

Here is the relevant part of the code:

###############################

int main()
{
cy_rslt_t result;

/* This enables RTOS aware debugging in OpenOCD. */
uxTopUsedPriority = configMAX_PRIORITIES - 1;

/* Initialize the board support package. */
result = cybsp_init() ;
CY_ASSERT(result == CY_RSLT_SUCCESS);

/* Set up the device based on configurator selections */
init_cycfg_all();

/* To avoid compiler warnings. */
(void) result;

initUART();

/* Enable global interrupts. */
__enable_irq();

######################################

/* Allocate context for UART operation */
cy_stc_scb_uart_context_t uartContext;

/* Initialize the UART configuration structure */
const cy_stc_scb_uart_config_t LID_UART_config = {
.uartMode = CY_SCB_UART_STANDARD,
.enableMutliProcessorMode = false,
.smartCardRetryOnNack = false,
.irdaInvertRx = false,
.irdaEnableLowPowerReceiver = false,
.oversample = 8,
.enableMsbFirst = true,
.dataWidth = 8UL,
.parity = CY_SCB_UART_PARITY_NONE,
.stopBits = CY_SCB_UART_STOP_BITS_1,
.enableInputFilter = false,
.breakWidth = 11UL,
.dropOnFrameError = false,
.dropOnParityError = false,
.receiverAddress = 0x0UL,
.receiverAddressMask = 0x0UL,
.acceptAddrInFifo = false,
.enableCts = false,
.ctsPolarity = CY_SCB_UART_ACTIVE_LOW,
.rtsRxFifoLevel = 0UL,
.rtsPolarity = CY_SCB_UART_ACTIVE_LOW,
.rxFifoTriggerLevel = 0UL,
.rxFifoIntEnableMask = 0UL,
.txFifoTriggerLevel = 0UL,
.txFifoIntEnableMask = 0UL, };

bool uartEventArrived = false;

void initUART() {

/* Initialize the UART Block */
cy_en_scb_uart_status_t initStatus;
cy_en_sysclk_status_t setClockStatus;
cy_en_sysint_status_t intrSetStatus;

/* Configure UART to operate */
initStatus = Cy_SCB_UART_Init(SCB4, &LID_UART_config, &uartContext);
if (CY_SCB_UART_SUCCESS != initStatus) {
handleError();
}

/* Assign pins for UART on SCB4: P8[0], P8[1] */
#define UART_PORT P8_0_PORT
#define UART_RX_NUM P8_0_NUM
#define UART_TX_NUM P8_1_NUM
/* Connect SCB5 UART function to pins */
Cy_GPIO_SetHSIOM(UART_PORT, UART_RX_NUM, P8_0_SCB4_UART_RX);
Cy_GPIO_SetHSIOM(UART_PORT, UART_TX_NUM, P8_1_SCB4_UART_TX);
/* Configure pins for UART operation */
Cy_GPIO_SetDrivemode(UART_PORT, UART_RX_NUM, CY_GPIO_DM_HIGHZ);
//Cy_GPIO_SetSlewRate(UART_PORT, UART_RX_NUM, CY_GPIO_SLEW_SLOW);
//Cy_GPIO_SetVtrip(UART_PORT, UART_RX_NUM, CY_GPIO_VTRIP_TTL);
Cy_GPIO_SetDrivemode(UART_PORT, UART_TX_NUM, CY_GPIO_DM_STRONG_IN_OFF);
//Cy_GPIO_SetSlewRate(UART_PORT, UART_TX_NUM, CY_GPIO_SLEW_SLOW);

/* UART desired baud rate is 19200 bps (Standard mode).
*/
setClockStatus = Cy_SysClk_PeriphSetDivider(CY_SYSCLK_DIV_16_BIT, 1U, 651U);
if (CY_SYSCLK_SUCCESS != setClockStatus) {
handleError();
}

setClockStatus = Cy_SysClk_PeriphEnableDivider(CY_SYSCLK_DIV_16_BIT, 1U);
if (CY_SYSCLK_SUCCESS != setClockStatus) {
handleError();
}

/* Assign UART interrupt number and priority */
#define UART_INTR_NUM ((IRQn_Type) scb_4_interrupt_IRQn)
#define UART_INTR_PRIORITY (7U)
/* 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 */
intrSetStatus = Cy_SysInt_Init(&uartIntrConfig, &UART_Isr);
if (CY_SYSINT_SUCCESS != intrSetStatus) {
handleError();
}

NVIC_EnableIRQ(UART_INTR_NUM);

/* Enable UART to operate */
Cy_SCB_UART_Enable(SCB4);
}

void UART_Isr(void) {
Cy_SCB_UART_Interrupt(SCB4, &uartContext);
uartEventArrived = true;
}

void uart_task(void *pvParameters) {

uint32_t numReceived;
cy_en_scb_uart_status_t uartStatus;

for (;;) {
if (uartEventArrived) {
uartEventArrived = false;
/* Start receive operation (do not check status) */
uartStatus = Cy_SCB_UART_Receive(SCB4, rxBuffer, sizeof(rxBuffer),
&uartContext);
if (CY_SCB_UART_SUCCESS != uartStatus) {
handleError();
}
vTaskDelay(pdMS_TO_TICKS(1000));

numReceived = Cy_SCB_UART_GetNumReceived(SCB4, &uartContext);

if (numReceived > 0) {
reportOnDevice("Data arrived", false);
} else {
reportOnDevice("no Data arrived", false);

}
}

}

}