void UART_Configuration(TSB_SC_TypeDef * SCx) { UART_InitTypeDef myUART; if (SCx == UART0) { TSB_PE_CR_PE0C = 1U; TSB_PE_FR1_PE0F1 = 1U; TSB_PE_FR1_PE1F1 = 1U; TSB_PE_IE_PE1IE = 1U; } else if (SCx == UART1) { TSB_PE_CR_PE4C = 1U; TSB_PE_FR1_PE4F1 = 1U; TSB_PE_FR1_PE5F1 = 1U; TSB_PE_IE_PE5IE = 1U; } else if (SCx == UART2) { TSB_PF_CR_PF0C = 1U; TSB_PF_FR1_PF0F1 = 1U; TSB_PF_FR1_PF1F1 = 1U; TSB_PF_IE_PF1IE = 1U; } else { /* Do nothing */ } myUART.BaudRate = 115200U; myUART.DataBits = UART_DATA_BITS_8; myUART.StopBits = UART_STOP_BITS_1; myUART.Parity = UART_NO_PARITY; myUART.Mode = UART_ENABLE_TX; myUART.FlowCtrl = UART_NONE_FLOW_CTRL; UART_Enable(SCx); UART_Init(SCx, &myUART); }
/******************************************************************************* * Function Name: UART_Start ****************************************************************************//** * * Invokes UART_Init() and UART_Enable(). * After this function call, the component is enabled and ready for operation. * When configuration is set to "Unconfigured SCB", the component must first be * initialized to operate in one of the following configurations: I2C, SPI, UART * or EZI2C. Otherwise this function does not enable the component. * * \globalvars * UART_initVar - used to check initial configuration, modified * on first function call. * *******************************************************************************/ void UART_Start(void) { if (0u == UART_initVar) { UART_Init(); UART_initVar = 1u; /* Component was initialized */ } UART_Enable(); }
/** * @brief SIO Configuration Initialize the uart port (SIO0). * @param None * @retval None */ void SIO_ChInit(void) { UART_InitTypeDef myUART; /* configure SIO0 for reception */ UART_Enable(UART_RETARGET); myUART.BaudRate = 115200U; /* baud rate = 115200 */ myUART.DataBits = UART_DATA_BITS_8; /* no handshake, 8-bit data, clock by baud rate generator */ myUART.StopBits = UART_STOP_BITS_1; /* 1-bit stop, LSB, W-buff enable */ myUART.Parity = UART_NO_PARITY; myUART.Mode = UART_ENABLE_TX; myUART.FlowCtrl = UART_NONE_FLOW_CTRL; UART_Init(UART_RETARGET, &myUART); }
void uart_print(void) { TSB_WD_MOD_WDTE = 0U; TSB_WD->CR = 0x000000B1; SIO_Configuration(UART0); myUART.BaudRate = 115200U; myUART.DataBits = UART_DATA_BITS_8; myUART.StopBits = UART_STOP_BITS_1; myUART.Parity = UART_NO_PARITY; myUART.Mode = UART_ENABLE_TX; myUART.FlowCtrl = UART_NONE_FLOW_CTRL; UART_Enable(UART0); UART_Init(UART0, &myUART); UART_Print("Hello World!\n"); }
int main(void) { // Clock (80MHz) SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); // Init LEDs Pin_Init(rLED); Pin_Set(rLED, LOW); // Init UART0 UART_Init(UART0); UART_Enable(UART0); setbuf(stdout, NULL); // Disable printf internal buffer // Init I2C0 I2C_Init(I2C0); I2C_Enable(I2C0); // Wait until user presses enter UART_ReadChar(UART0); // Scan for I2C addresses for(i=0; i < (1 << 7); i++) { printf("x%02x:", i); if (I2C_Write(I2C0, i, 0) == true) printf("* "); else printf(" "); Pin_Toggle(rLED); if (i % 8 == 7) printf("\r\n"); } // Indicator LED off Pin_Set(rLED, LOW); while(1); }
void UART_Configuration(TSB_SC_TypeDef * SCx) { UART_InitTypeDef myUART; if (SCx == UART0) { TSB_PE_CR_PE4C = 1; TSB_PE_FR2_PE4F2 = 1; TSB_PE_FR2_PE5F2 = 1; TSB_PE_IE_PE5IE = 1; } else { //do nothing } myUART.BaudRate = 115200U; myUART.DataBits = UART_DATA_BITS_8; myUART.StopBits = UART_STOP_BITS_1; myUART.Parity = UART_NO_PARITY; myUART.Mode = UART_ENABLE_TX; myUART.FlowCtrl = UART_NONE_FLOW_CTRL; UART_Enable(SCx); UART_Init(SCx, &myUART); }
void uart_print(void) { SIO_Configuration(UART); myUART.BaudRate = 115200U; myUART.DataBits = UART_DATA_BITS_8; myUART.StopBits = UART_STOP_BITS_1; myUART.Parity = UART_NO_PARITY; myUART.Mode = UART_ENABLE_RX | UART_ENABLE_TX; myUART.FlowCtrl = UART_NONE_FLOW_CTRL; UART_Enable(UART); UART_Init(UART, &myUART); NVIC_EnableIRQ(INTTX0_IRQn); UART_SetTxData(UART, (uint32_t) (TxBuffer[TxCounter++])); while (1) { /* Do nothing */ } }
static rt_err_t CME_M7_configure(struct rt_serial_device *serial, struct serial_configure *cfg) { struct CME_M7_uart* uart; UART_InitTypeDef init; RT_ASSERT(serial != RT_NULL); RT_ASSERT(cfg != RT_NULL); uart = (struct CME_M7_uart *)serial->parent.user_data; init.UART_BaudRate = cfg->baud_rate; init.UART_StopBits = UART_StopBits_1; init.UART_Parity = UART_Parity_None; init.UART_LoopBack = FALSE; init.UART_RxEn = TRUE; init.UART_CtsEn = FALSE; UART_Init(uart->uart_device, &init); uart->uart_device->RX_RESET = 1; UART_Enable(uart->uart_device, TRUE); uart->uart_device->RX_RESET = 0; return RT_EOK; }
/******************************************************************************* * Function Name: UART_Wakeup ******************************************************************************** * * Summary: * Calls RestoreConfig function fucntion for selected mode. * * Parameters: * None * * Return: * None * *******************************************************************************/ void UART_Wakeup(void) { #if(UART_SCB_MODE_UNCONFIG_CONST_CFG) UART_EnableTxPinsInputBuffer(); if(0u != UART_scbEnableWake) { if(UART_SCB_MODE_I2C_RUNTM_CFG) { UART_I2CRestoreConfig(); } else if(UART_SCB_MODE_SPI_RUNTM_CFG) { UART_SpiRestoreConfig(); } else if(UART_SCB_MODE_UART_RUNTM_CFG) { UART_UartRestoreConfig(); } else if(UART_SCB_MODE_EZI2C_RUNTM_CFG) { UART_EzI2CRestoreConfig(); } else { /* Unknown mode: do nothing */ } } else { /* Restore enable state */ if(0u != UART_backup.enableState) { UART_Enable(); } } #else UART_EnableTxPinsInputBuffer(); #if defined (UART_I2C_WAKE_ENABLE_CONST) && (UART_I2C_WAKE_ENABLE_CONST) UART_I2CRestoreConfig(); #elif defined (UART_SPI_WAKE_ENABLE_CONST) && (UART_SPI_WAKE_ENABLE_CONST) UART_SpiRestoreConfig(); #elif defined (UART_UART_WAKE_ENABLE_CONST) && (UART_UART_WAKE_ENABLE_CONST) UART_UartRestoreConfig(); #elif defined (UART_EZI2C_WAKE_ENABLE_CONST) && (UART_EZI2C_WAKE_ENABLE_CONST) UART_EzI2CRestoreConfig(); #else /* Check enable state */ if(0u != UART_backup.enableState) { UART_Enable(); } #endif /* (UART_I2C_WAKE_ENABLE_CONST) */ #endif /* (UART_SCB_MODE_UNCONFIG_CONST_CFG) */ }
int main(void) { // Clock (50MHz) SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); // Init peripherals // UART0/1 UART_Init(UART0); UART_Enable(UART0); UART_Init(UART1); UART_SetIRQ(UART1, UART_RX_IRQ, &UART1_RX_IRQ); UART_IntEnable(UART1, UART_RX_IRQ); UART_Enable(UART1); setbuf(stdout, NULL); u1BufPtr = u1Buf; // I2C0 I2C_Init(I2C0); I2C_Enable(I2C0); // PWM0/1 PWM_Init(PWM0, 50); PWM_Init(PWM1, 1000); PWM_Enable(rLED); PWM_Enable(gLED); PWM_Enable(bLED); PWM_Set(rLED, 0); PWM_Set(gLED, 0); PWM_Set(bLED, 0); // Init Robotics BoosterPack RoboticsBP_Init(); // NVIC IntMasterEnable(); // As soon as UART1 IRW is enabled, a character is // incorrectly received. Correct the issue by simply // resetting the buffer pointer. // Might be a bug in UART implementation of PAL u1BufPtr = u1Buf; // Start parsing commands as they become available cmdHead = u1Buf; cmdTail = u1Buf; while(1) { // Wait until buffPtr moves // Might be possible to use wfi() here if (cmdTail == u1BufPtr) continue; // This is apparently needed, otherwise everything doesn't work... printf("%c%d", *cmdTail, *cmdTail == ';'); // Increment pointer cmdTail++; // If command is complete if (*cmdTail == ';') { printf("\r\n"); // Fake the end of a string *cmdTail = 0; // Execute command parseCmd(); // Update pointers // Check if we need to loop back if (cmdTail > u1Buf + 1000) { // Reset pointers to beginning of buffer cmdHead = u1Buf; cmdTail = u1Buf; } else { // Upadte pointers cmdHead = ((unsigned char*) cmdTail) + 1; cmdTail = cmdHead; } } } }
/******************************************************************************* * Function Name: UART_Wakeup ******************************************************************************** * * Summary: * Prepares the component for the Active mode operation after exiting Deep Sleep. * The “Enable wakeup from Sleep Mode” option has an influence on this function * implementation. * This function should not be called after exiting Sleep. * * Parameters: * None * * Return: * None * *******************************************************************************/ void UART_Wakeup(void) { #if(UART_SCB_MODE_UNCONFIG_CONST_CFG) if(UART_SCB_WAKE_ENABLE_CHECK) { if(UART_SCB_MODE_I2C_RUNTM_CFG) { UART_I2CRestoreConfig(); } else if(UART_SCB_MODE_EZI2C_RUNTM_CFG) { UART_EzI2CRestoreConfig(); } #if(!UART_CY_SCBIP_V1_I2C_ONLY) else if(UART_SCB_MODE_SPI_RUNTM_CFG) { UART_SpiRestoreConfig(); } else if(UART_SCB_MODE_UART_RUNTM_CFG) { UART_UartRestoreConfig(); } #endif /* (!UART_CY_SCBIP_V1_I2C_ONLY) */ else { /* Unknown mode: do nothing */ } } else { if(0u != UART_backup.enableState) { UART_Enable(); } } #else #if (UART_SCB_MODE_I2C_CONST_CFG && UART_I2C_WAKE_ENABLE_CONST) UART_I2CRestoreConfig(); #elif (UART_SCB_MODE_EZI2C_CONST_CFG && UART_EZI2C_WAKE_ENABLE_CONST) UART_EzI2CRestoreConfig(); #elif (UART_SCB_MODE_SPI_CONST_CFG && UART_SPI_WAKE_ENABLE_CONST) UART_SpiRestoreConfig(); #elif (UART_SCB_MODE_UART_CONST_CFG && UART_UART_WAKE_ENABLE_CONST) UART_UartRestoreConfig(); #else if(0u != UART_backup.enableState) { UART_Enable(); } #endif /* (UART_I2C_WAKE_ENABLE_CONST) */ #endif /* (UART_SCB_MODE_UNCONFIG_CONST_CFG) */ }