//*****************************************************************************
//
//! \brief Init uart to print.
//!
//! \param None
//!
//! \details uart config as (115200, 8 data bit, 1 stop bit , no partiy)
//!
//! \return None.
//
//*****************************************************************************
static
void UartInit(void)
{
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeUART(UART0RX, PC10);
xSPinTypeUART(UART0TX, PC8);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
//
// Set UART0 clock source.
//
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_HCLK);
//
// Configure 8 bit word length, 1 stop bit,
// and none parity bit, receive FIFO 1 byte.
//
xUARTConfigSet(UART0_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
xUARTEnable(UART0_BASE, (UART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX));
}
//*****************************************************************************
//
//! \brief print some data to terminal.
//!
//! \param None
//!
//! \return None.
//
//*****************************************************************************
void UartPrintf(void)
{
unsigned long i;
//
//Set System Clock
//
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay(10000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOD);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeUART(UART1TX,PA9);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xUARTConfigSet(USART1_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
xUARTEnable(USART1_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
for(i = 0; i < sizeof("STM32F1xx.UART Example of CoX \r\n"); i++)
{
xUARTCharPut(USART1_BASE, ucData[i]);
}
}
void uartprinntf()
{
//
// Initionalize system clock.
//
xSysCtlPeripheralClockSourceSet( 10000000, xSYSCTL_XTAL_6MHZ );
SysCtlDelay(10000);
xSPinTypeUART(UART0RX,PB0);
xSPinTypeUART(UART0TX,PB1);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_EXT12M);
//
// Config 8 bit word length, 1 stop bit,
// and none parity bit, receive FIFO 1 byte.
//
UARTConfigSetExpClk(UART0_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
UARTEnable(UART0_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
UARTBufferWrite(UART0_BASE, "NUC1xx.UART.BAUDRATE EXAMPLE \r\n", sizeof("NUC1xx.UART.BAUDRATE EXAMPLE \r\n"));
}
//*****************************************************************************
//
//! Ininite the ADC
//!
//! \param None
//!
//! This function ininite the ADC including clock source and enable ADC
//!
//! \return none
//
//*****************************************************************************
void ADConvert(void)
{
unsigned long ulAdcSeqNo[] = {0};
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay(10000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
//
// configure GPIO pin as ADC function
//
xSPinTypeADC(ADC0, PA0);
//
// Reset ADC
//
xSysCtlPeripheralReset(xSYSCTL_PERIPH_ADC1);
//
// Set ADC clock source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_MAIN, 4);
//
// Enable ADC clock
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC1);
//
// Set the length of converter
//
ADCConverLenSet(ADC1_BASE, 1, 1);
//
// Set the Index of converter Sequence
//
ADCSequenceIndexSet(ADC1_BASE, ulAdcSeqNo, ulAdcSeqNo);
ADCSampLenSet(ADC1_BASE, 0, 128);
//
// A/D interrupt enable
//
ADCIntEnable(ADC1_BASE, ADC_INT_END_CONVERSION);
xIntEnable(xINT_ADC0);
xADCIntCallbackInit(ADC1_BASE, ADC0IntFucntion);
//
// Software trigger enable
//
ADCProcessorTrigger(ADC1_BASE);
//
// A/D configure
//
ADCRegularConfigure(ADC1_BASE, ADC_OP_SINGLE, ADC_TRIGGER_PROCESSOR);
ADCDataRegularGet(ADC1_BASE, ADC_MODE_NORMAL);
}
//////////////////////////////////////////////////////////////////////////////
// Platform (STM32F103X) initialization for peripherals as GPIO, SPI, UARTs //
//////////////////////////////////////////////////////////////////////////////
void platform_init(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay((xSysCtlClockGet()/1000)*50); // wait 50ms
/**************************/
/* GPIO_A For SPI CS PIN */// It must be first to enable GPIO peripheral than other peripheral. (Otherwise, UART do not run in STM32F103X)
/**************************/
xSysCtlPeripheralEnable( xSYSCTL_PERIPH_GPIOA );
xGPIODirModeSet(xGPIO_PORTA_BASE, xGPIO_PIN_4, xGPIO_DIR_MODE_OUT);
/************/
/* For UART */
/************/
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xSPinTypeUART(UART1TX,PA9);
xSPinTypeUART(UART1RX,PA10);
xUARTConfigSet(xUART1_BASE, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
xUARTEnable(xUART1_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
/***********/
/* For SPI */
/***********/
xSysCtlPeripheralReset(WIZCHIP_SPI_PERIPH);
xSysCtlPeripheralEnable(WIZCHIP_SPI_PERIPH);
xSPinTypeSPI(WIZCHIP_SPI_CLK, WIZCHIP_SPI_CLK_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_5, GPIO_TYPE_AFOUT_STD, GPIO_OUT_SPEED_50M);
xSPinTypeSPI(WIZCHIP_SPI_MOSI,WIZCHIP_SPI_MOSI_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_7, GPIO_TYPE_AFOUT_STD, GPIO_OUT_SPEED_50M);
xSPinTypeSPI(WIZCHIP_SPI_MISO,WIZCHIP_SPI_MISO_PIN); // xGPIODirModeSet(xGPIO_PORTA, xGPIO_PIN_6, GPIO_TYPE_IN_FLOATING, GPIO_IN_SPEED_FIXED);
xSPIConfigSet(WIZCHIP_SPI_BASE, xSysCtlClockGet()/2, xSPI_MOTO_FORMAT_MODE_0 | xSPI_MODE_MASTER | xSPI_MSB_FIRST | xSPI_DATA_WIDTH8);
xSPISSSet(WIZCHIP_SPI_BASE, SPI_SS_SOFTWARE, xSPI_SS_NONE);
xSPIEnable(WIZCHIP_SPI_BASE);
printf("HCLK = %dMHz\r\n", (unsigned int)(xSysCtlClockGet()/1000000));
}
//*****************************************************************************
//
//! \brief initialize USART for debugging use
//!
//! \param None
//!
//! \details Initialize USART1 for debugging use. Debugging will use printf function,
//! so we use USART1 as the debugging tool. Don't forget to add and transplant printf.c.
//! If you don't need debugging or you have your own debugging function, remove this
//! function.
//!
//! \return None
//
//*****************************************************************************
void mInitSTDIO( void )
{
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xUARTConfigSet(xUART1_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
xUARTEnable(xUART1_BASE, (xUART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX));
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeUART(UART1TX, PA9);
}
//*****************************************************************************
//
//! \brief System and PWM Initialize.
//!
//! \param None
//!
//! \note None.
//!
//! \return None.
//
//*****************************************************************************
void xSysCtlAndPwmInit(void)
{
unsigned long i = 0;
unsigned long ulBit = 0;
//
// Set System clock is 48M
//
xSysCtlClockSet(48000000, (xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ));
//
// Enable GPIO and PWM
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOC);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOC);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOE);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOE);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_PWMB);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMB);
//
// Set PE2(DIR_CLK), PD3(DIR_SER), and PA6(DIR_LATCH) PD2(DIR_EN) as output
//
xGPIOSPinTypeGPIOOutput(sD4);
xGPIOSPinTypeGPIOOutput(sD8);
xGPIOSPinTypeGPIOOutput(sD12);
xGPIOSPinTypeGPIOOutput(sD7);
//
// Set PWM Clock Source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_PWMA_MAIN, 4);
xSysCtlPeripheralClockSourceSet(xSYSCTL_PWMB_MAIN, 4);
//
// Congigure the PWM pin(PWM7, sD11))
//
sD11PinTypePWM();
//xGPIOSPinTypeGPIOOutput(sD11);
//xGPIOSPinWrite(sD11, 1);
//
// 74HC595 operation
// Output Enable
//
SendData74HC595(0x60);
}
//*****************************************************************************
//
//! \brief Init uart to print.
//!
//! \param None
//!
//! \details uart config as (115200, 8 data bit, 1 stop bit , no partiy)
//!
//! \return None.
//
//*****************************************************************************
static
void UartInit(void)
{
xSPinTypeUART(UART0RX,PB0);
xSPinTypeUART(UART0TX,PB1);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART0_MAIN, 1);
xUARTConfigSet(UART0_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
}
void
TestIOInit(void)
{
xSysCtlClockSet(50000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
SysCtlDelay(10000);
xSPinTypeUART(UART0RX,PB0);
xSPinTypeUART(UART0TX,PB1);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART0_MAIN, 1);
xUARTConfigSet(UART0_BASE, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
xUARTEnable(UART0_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
}
//*****************************************************************************
//
//! \biref uart0 configre
//!
//! \return none
//
//*****************************************************************************
void UART0Configuration(void)
{
xSPinTypeUART(U0RX,PB0);
xSPinTypeUART(U0TX,PB1);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_EXT12M);
xHWREG(UART0_BASE + UART_FCR) |= 0x6;
xHWREG(UART0_BASE + UART_FCR) &= ~(0xF0);
xHWREG(UART0_BASE + UART_FCR) |= 0;
xHWREG(UART0_BASE + UART_LCR) = 3;
xHWREG(UART0_BASE + UART_BAUD) = 0x3F000066;
SysCtlDelay(10000);
}
void
TestIOInit(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
SysCtlDelay(10000);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeUART(UART0RX, PA8);
xSPinTypeUART(UART0TX, PA9);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_HCLK);
UARTConfigSetExpClk(UART0_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
UARTEnable(UART0_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
}
void
TestIOInit(void)
{
SysCtlKeyAddrUnlock();
xHWREG(SYSCLK_PWRCON) |= SYSCLK_PWRCON_XTL12M_EN;
xSysCtlClockSet(12000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
SysCtlDelay(10000);
xSPinTypeUART(UART0RX, PA1);
xSPinTypeUART(UART0TX, PA0);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_EXT12M);
UARTConfigSetExpClk(UART0_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
UARTEnable(UART0_BASE, (UART_BLOCK_UART | UART_BLOCK_TX | UART_BLOCK_RX));
}
void uartprinntf()
{
xSysCtlClockSet(84000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
xSysCtlDelay(10000);
xSPinTypeUART(UART0RX,PG1);
xSPinTypeUART(UART0TX,PG2);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
//
// Config 8 bit word length, 1 stop bit,
// and none parity bit, receive FIFO 1 byte.
//
xUARTConfigSet(xUART0_BASE, 115200, (xUART_CONFIG_WLEN_8 | \
xUART_CONFIG_STOP_1 | \
xUART_CONFIG_PAR_NONE));
xUARTEnable(xUART0_BASE, (xUART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX));
UARTBufferWrite(UART0_BASE, "NUC1xx.UART.BAUDRATE EXAMPLE \r\n", sizeof("NUC1xx.UART.BAUDRATE EXAMPLE \r\n"));
}
//*****************************************************************************
//
//! \brief print some data to terminal.
//!
//! \param None
//!
//! \return None.
//
//*****************************************************************************
void UartPrintf(void)
{
unsigned long i;
//
//Set System Clock
//
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay(10000);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeUART(UART0RX, PA8);
xSPinTypeUART(UART0TX, PA9);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
//
// Set UART0 clock source.
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART0_HCLK, 1);
//
// Configure 8 bit word length, 1 stop bit,
// and none parity bit, receive FIFO 1 byte.
//
xUARTConfigSet(UART0_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
xUARTEnable(UART0_BASE, (UART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX));
for(i = 0; i < sizeof("HT32F125x.UART Example of CoX \r\n"); i++)
{
xUARTCharPut(UART0_BASE, ucData[i]);
}
}
//*****************************************************************************
//
//! \brief Something should do after the test execute of xgpio001 test.
//!
//! \return None.
//
//*****************************************************************************
static void xgpio001TearDown(void)
{
xSysCtlPeripheralReset(SYSCTL_PERIPH_EXTI);
}
void RTCTickInt()
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_PWR);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
SysCtlBackupAccessEnable();
SysCtlLSEConfig(SYSCTL_LSE_OSC_EN);
SysCtlPeripheralClockSourceSet(SYSCTL_RTC_LSE);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_RTC);
SysCtlDelay(10000);
xSPinTypeUART(UART1RX,PA10);
xSPinTypeUART(UART1TX,PA9);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
xUARTConfigSet(xUART1_BASE, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
xUARTEnable(xUART1_BASE, UART_BLOCK_UART | UART_BLOCK_RX | UART_BLOCK_TX);
UARTBufferWrite(xUART1_BASE, "usart init is ok!", sizeof("usart init is ok!")-1);
RTCTimeInit(0X7FFF);
tTime1.ulSecond = 20;
tTime1.ulMinute = 10;
tTime1.ulHour = 11;
tTime1.ulMDay = 13;
tTime1.ulMonth = 6;
tTime1.ulYear = 2012;
tTime1.ulWDay = 3;
//
// Writes current time to corresponding register.
//
RTCTimeWrite(&tTime1, ulTimeAlarm[0]);
SysCtlDelay(10000);
RTCIntCallbackInit(xRTCCallback);
//
// Enables tick interrupt.
//
RTCIntEnable(RTC_INT_TIME_TICK);
xIntEnable(INT_RTC);
xIntMasterEnable();
while(ulj < 2);
xIntMasterDisable();
RTCTimeRead(&tTime1, ulTimeAlarm[0]);
}
