//*****************************************************************************
//
//! \brief something should do before the test execute of xpwm002 test.
//!
//! \return None.
//
//*****************************************************************************
static void xpwm002Setup(void)
{
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMB);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMC);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMD);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWME);
//
// GPIO pin function set as pwm output
//
xSPinTypeTimer(TIM1CH1, PA8);
xSPinTypeTimer(TIM1CH2, PE11);
xSPinTypeTimer(TIM1CH3, PA10);
xSPinTypeTimer(TIM1CH4, PA11);
xSPinTypeTimer(TIM2CH1, PA0);
xSPinTypeTimer(TIM2CH2, PA1);
xSPinTypeTimer(TIM2CH3, PA2);
xSPinTypeTimer(TIM2CH4, PA3);
xSPinTypeTimer(TIM3CH1, PA6);
xSPinTypeTimer(TIM3CH2, PA7);
xSPinTypeTimer(TIM3CH3, PB0);
xSPinTypeTimer(TIM3CH4, PB1);
xSPinTypeTimer(TIM4CH1, PB6);
xSPinTypeTimer(TIM4CH2, PB7);
xSPinTypeTimer(TIM4CH3, PB8);
xSPinTypeTimer(TIM4CH4, PB9);
}
void LCDShield(void)
{
int key;
xSysCtlClockSet(12000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
xSysCtlDelay(1000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(sD13));
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART0_MAIN, 1);
LCDShieldInit();
//
// Enable Peripheral SPI0
//
xSysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);
xSPinTypeADC(ADC0, sA0);
//
// ADC Channel0 convert once, Software tirgger.
//
xADCConfigure(xADC0_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Enable the channel0
//
xADCStepConfigure(xADC0_BASE, 0, xADC_CTL_CH0);
//
// Enable the adc
//
xADCEnable(xADC0_BASE);
//
// start ADC convert
//
xADCProcessorTrigger( xADC0_BASE );
LCDShieldLocationSet(0, 0);
LCDShieldDisplayString("Hello Nuvoton!");
LCDShieldLocationSet(0, 1);
LCDShieldDisplayString("Hello CooCox! ");
xSysCtlDelay(1000000);
while(1)
{
key = LCDShieldButtonGet();
if(key != -1)
{
LCDShieldDisplayClear();
LCDShieldLocationSet(0, 0);
LCDShieldDisplayString("The key is: ");
LCDShieldLocationSet(0, 1);
LCDShieldDisplayString(&cKey[key][0]);
}
}
}
void SensorExample(void)
{
int ADValue;
char buf[4];
//
// Initionalize system clock.
//
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay(100000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable2(sUART_BASE);
xUARTConfigSet(sUART_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
xUARTEnable(sUART_BASE, (xUART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX));
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
sPinTypeUART(sUART_BASE);
SensorShieldInit();
while(1){
ADValue = ADCValueGet(SENSOR_SHIELD_AI2);
buf[0] = ADValue/1000 + 0x30;
buf[1] = ADValue/100%10 + 0x30;
buf[2] = ADValue/10%10 + 0x30;
buf[3] = ADValue%10 + 0x30;
SensorShieldUARTBufferPut(sUART_BASE, buf, 4);
}
}
//*****************************************************************************
//
//! \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 DeltaAngleGet()
{
tLPR5150ALData g_XYAxisCurrentVoltage;
tLPR5150ALData g_XYAxisNullVoltage;
tLPR5150ALData g_XYAxisAngle;
tLPR5150ALData g_XYAxisRate;
xSysCtlClockSet(12000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
xSysCtlDelay(1000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(sD13));
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART0_MAIN, 1);
sPinTypeUART(sUART_DBG_BASE);
xUARTConfigSet(sUART_DBG_BASE, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
xUARTEnable(sUART_DBG_BASE, (UART_BLOCK_UART | UART_BLOCK_RX));
//automatically added by CoIDE
//ADConvert();
xSysCtlClockSet(12000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
LPR5150ALInit();
while(1)
{
g_XYAxisAngle = LPR5150ALXYAxisAngleGet();
printf("The roll angle is: %f ", g_XYAxisAngle.fXAxisData);
printf("The pitch angle is: %f \r\n", g_XYAxisAngle.fYAxisData);
//DelayMS(500);
}
}
// init servo signal and pin
// does not check arguments, make sure to pass valide arguments
void servo_init(void)
{
xSysCtlPeripheralClockSourceSet(xSYSCTL_PWMB_MAIN, 1);
// Enable PWM peripheral
xSysCtlPeripheralEnable(SYSCTL_PERIPH_PWMB);
// Enable gpio pin peripheral
xSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
// Enable PWM and set GPIO Pin as PWM
xSPinTypePWM(TIM1CH0, PB0);
// xSPinTypePWM(TIM0CH3, PE30);
// Set invert, dead zone and mode
xPWMInitConfigure(xPWMB_BASE, xPWM_CHANNEL0, xPWM_TOGGLE_MODE);
// Set CNR, Prescale and Divider. FHz = 50Hz
xPWMFrequencySet(xPWMB_BASE, xPWM_CHANNEL0, 50);
// Set CMR, high pulse @ 1,5 ms middle position
servo_angle(0);
// Set output enable
xPWMOutputEnable(xPWMB_BASE, xPWM_CHANNEL0);
// start pwm
xPWMStart(xPWMB_BASE, xPWM_CHANNEL0);
// initialization ok
}
void UART_example(void)
{
unsigned int i = 0;
//
// Configure System clock
//
xSysCtlClockSet(84000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
SysCtlDelay(10000);
//
// Enable GPIO/UART Clock
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART0);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOG);
//
// Remap UART pin to GPIO Port UART0_RX --> PG1 UART0_TX --> PG2
xSPinTypeUART(UART0RX, PG1);
xSPinTypeUART(UART0TX, PG2);
//
// Configure UART Baud 115200 8-N-1
//
xUARTConfigSet(xUART0_BASE, 115200, xUART_CONFIG_WLEN_8 | xUART_CONFIG_PAR_NONE | xUART_CONFIG_STOP_1);
//
// Enable UART Receive/Transmit
//
xUARTEnable(xUART0_BASE, xUART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX);
//
// print out welcome information
//
i = 0;
while(Buf[i] != '\0')
{
xUARTCharPut(xUART0_BASE, Buf[i++]);
}
//
// Echo user's input information
//
while((Rec = UxARTCharGet(xUART0_BASE)) != '\n')
{
xUARTCharPut(xUART0_BASE, Rec);
}
//
// print out run over information
//
i = 0;
while(Buf[i] != '\0')
{
xUARTCharPut(xUART0_BASE, End[i++]);
}
while(1);
}
//*****************************************************************************
//
//! \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 Initialize I2C
//!
//! \param None
//!
//! This function initialize the mcu I2C as master and specified I2C port.
//!
//! \note internal function, used in this file only.
//! \note The max data rate is 100KHz.
//! \return None.
//
//*****************************************************************************
static Result _I2CComPortInit(void)
{
//I2C Max clock: 100K
uint32_t I2CInitClkRate = 100000;
xSysCtlPeripheralEnable(PCF8574_I2C_GPIO);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//
// Enable the I2C which is connected with PCF8574
//
xSysCtlPeripheralEnable2(PCF8574_PIN_I2C_PORT);
//
// Set PCF8574_PIN_I2C_SCK as I2C SCK Pin
//
xSPinTypeI2C(PCF8574_I2C_SCK, PCF8574_PIN_I2C_SCK);
//
// Set PCF8574_PIN_I2C_SDA as I2C SDA Pin
//
xSPinTypeI2C(PCF8574_I2C_SDA, PCF8574_PIN_I2C_SDA);
//
// I2C enable
//
xI2CMasterEnable(PCF8574_PIN_I2C_PORT);
//
// Initializes the I2C Master block.
//
xI2CMasterInit(PCF8574_PIN_I2C_PORT, I2CInitClkRate);
return(SUCCESS);
}
//*****************************************************************************
//
//! \brief Initialize TC77
//!
//! \param ulClock specifies the SPI Clock Rate
//!
//! This function is to initialize the MCU as master and specified SPI port.Set
//! TC77_PIN_SPI_CS as CS, TC77_PIN_SPI_CLK as CLK, TC77_PIN_SPI_MISO ->MISO and
//! TC77_PIN_SPI_MOSI->MOSI,most of all it check the first conversion is finished
//! or not in order to execute the following operation.
//!
//! \return None.
//
//*****************************************************************************
void
TC77Init(unsigned long ulSpiClock)
{
short sReadValue = 0;
//
// The max clock rate of TC77 is 7M Hz acoording to Datasheet, Otherwise
// it will generate bigger error
//
xASSERT((ulSpiClock > 0) && (ulSpiClock < 7000000));
//
// Enable the GPIOx port which is connected with tc77
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_MISO));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_MOSI));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_CLK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(TC77_PIN_SPI_CS));
//
// Enable the SPIx which is connected with tc77
//
xSysCtlPeripheralEnable2(TC77_PIN_SPI_PORT);
//
// Set TC77_PIN_SPI_CS as a chip select pin and set it as OUT_MODE
//
xGPIOSPinDirModeSet(TC77_PIN_SPI_CS, xGPIO_DIR_MODE_OUT);
//
// Set TC77_PIN_SPI_CLK as SPIx.CLK
//
xSPinTypeSPI(TC77_SPI_CLK, TC77_PIN_SPI_CLK);
//
// Set TC77_PIN_SPI_MISO as SPIx.MISO
//
xSPinTypeSPI(TC77_SPI_MISO, TC77_PIN_SPI_MISO);
//
// Configure MCU as a master device , 16 bits data width ,MSB first,Mode_0
//
xSPIConfigSet(TC77_PIN_SPI_PORT, ulSpiClock, xSPI_MOTO_FORMAT_MODE_0 |
xSPI_DATA_WIDTH16 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST);
//
// Disable TC77 when Power up
//
xGPIOSPinWrite(TC77_PIN_SPI_CS, 1);
//
// Wait for the first conversion completed
//
while(!(0x0004 & sReadValue))
{
sReadValue = TC77TemperRead();
}
}
//*****************************************************************************
//
//! \brief Something should do before the test execute of xgpio001 test.
//!
//! \return None.
//
//*****************************************************************************
static void xgpio001Setup(void)
{
xSysCtlClockSet(8000000, xSYSCTL_XTAL_8MHZ | xSYSCTL_OSC_MAIN);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_EXTI);
}
//*****************************************************************************
//
//! 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);
}
void LCD_GPIO_Init(void)
{
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOB);
xGPIODirModeSet( xGPIO_PORTA_BASE, xGPIO_PIN_8, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_12, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_13, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_14, xGPIO_DIR_MODE_OUT);
xGPIODirModeSet( xGPIO_PORTB_BASE, xGPIO_PIN_15, xGPIO_DIR_MODE_OUT);
}
//*****************************************************************************
//
//! \brief Initialize AT45DB161 and SPI
//!
//! \param ulSpiClock specifies the SPI Clock Rate
//!
//! This function initialize the mcu SPI as master and specified SPI port.
//! After SPI and port was configured, the mcu send a AT45DB161_CMD_SRRD command
//! to get the page size of AT45DB161 to get prepareed for the followed read and
//! write operations.
//!
//! \return None.
//
//*****************************************************************************
void AT45DB161_Init(unsigned long ulSpiClock)
{
unsigned char tmp;
xASSERT((ulSpiClock > 0) && (ulSpiClock < AT45DB161_MAX_CLK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_SCK));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_CS_PIN));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_MISO));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(AT45DB161_MOSI));
xSysCtlPeripheralEnable2(AT45DB161_SPI_PORT);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xGPIOSPinDirModeSet(AT45DB161_CS_PIN, xGPIO_DIR_MODE_OUT);
#if (AT45DB161_WRITE_PROTECT < 1)
xGPIOSPinDirModeSet(FLASH_PIN_WRITE_PROTECT, xGPIO_DIR_MODE_OUT);
xGPIOSPinWrite(FLASH_PIN_WRITE_PROTECT, 0);
#endif
//
// PD1 as SPI2.CLK
//
xSPinTypeSPI(SPI_CLK, AT45DB161_SCK);
//
// PD2 as SPI2.MISO
// MISO20 => SPI0MISO
//
xSPinTypeSPI(SPI_MISO, AT45DB161_MISO);
//
// PD3 as SPI2.MOSI
// MOSI20 => SPI0MISO
//
xSPinTypeSPI(SPI_MOSI, AT45DB161_MOSI);
//xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//
//! Set SPI mode.
//
xSPIConfigSet(AT45DB161_SPI_PORT, ulSpiClock, SPI_MODE_MASTER |
SPI_MSB_FIRST |
SPI_2LINE_FULL |
SPI_DATA_WIDTH8 |
SPI_FORMAT_MODE_4);
SPISSModeConfig(AT45DB161_SPI_PORT, SPI_CR1_SSM);
SPISSIConfig(AT45DB161_SPI_PORT, SPI_CR1_SSI);
SPIEnble(AT45DB161_SPI_PORT);
AT45DB161_CS = 1;
xSPISingleDataReadWrite(AT45DB161_SPI_PORT, 0xFF);
xSysCtlDelay(100000);
AT45DB161_CS = 0;
//
//! Read AT45DB161 state register to get the page size.
//
xSPISingleDataReadWrite(AT45DB161_SPI_PORT, AT45DB161_CMD_SRRD);
tmp = xSPISingleDataReadWrite(AT45DB161_SPI_PORT, 0xFF);
if(tmp & AT45DB161_PGSZ) AT45DB161_PageSize = 512;
AT45DB161_CS = 1;
}
//
// Enable I2C, GPIO clock
// Set pins to I2C funciton
//
void pinSet()
{
//
// Enable GPIO Clock
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(PA8));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(PA9));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(PB13));
xSPinTypeI2C(I2C0SDA, PA8);
xSPinTypeI2C(I2C0SCK, PA9);
}
//*****************************************************************************
//
//! !brief xrtc 001 test for clock config.
//!
//! \return None.
//
//*****************************************************************************
static void xrtc001Execute_clock_Config(void)
{
xSysCtlPeripheralEnable(SYSCTL_PERIPH_PWR);
SysCtlBackupAccessEnable();
SysCtlLSEConfig(SYSCTL_LSE_OSC_EN);
TestAssert((xHWREG(RCC_BDCR)&0x03) == 0x03, "enable LSE error!");
SysCtlPeripheralClockSourceSet(SYSCTL_RTC_LSE);
TestAssert(xHWREG(RCC_BDCR)&((SYSCTL_RTC_LSE&0x03)<<8) == ((SYSCTL_RTC_LSE&0x03)<<8), "select LSE as RTC clock error!");
xSysCtlPeripheralEnable(SYSCTL_PERIPH_RTC);
TestAssert((xHWREG(RCC_BDCR)&0x8000) == 0x8000, "enable RTC clock error!");
}
//*****************************************************************************
//
//! \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 something should do before the test execute of xtimer001 test.
//!
//! \return None.
//
//*****************************************************************************
static void xTimer001Setup(void)
{
int i;
//
//Set the external 12MHZ clock as system clock
//
SysCtlKeyAddrUnlock();
xSysCtlClockSet(12000000, xSYSCTL_XTAL_6MHZ | xSYSCTL_OSC_MAIN);
//
// Set the timer clock
//
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_TMR0_S_EXT12M);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_TMR1_S_EXT12M);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_TMR2_S_EXT12M);
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_TMR3_S_EXT12M);
//
// Enable the tiemr0-3 peripheral
//
for(i = 0; i < 4; i++)
{
xSysCtlPeripheralEnable(ulTimerID[i]);
}
}
//*****************************************************************************
//
//! \brief Init Spi communction port and wifi handshake pin.
//
//! WiFi shield IO refence volatge == 3.3V
//! Pin map is below:
//! HAND_PIN --> PA3
//! SPI1_NSS --> PA4
//! SPI1_SCK --> PA5
//! SPI1_MISO --> PA6
//! SPI1_MOSI --> PA7
//!
//! \param none.
//!
//! \return None
//
//*****************************************************************************
void SpiDrv_Init(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xGPIOSPinTypeGPIOInput(PA3);
xGPIOSPinTypeGPIOOutput(PA4);
xSPinTypeSPI(SPI1CLK(3), PA5);
xSPinTypeSPI(SPI1MOSI(3), PA7);
xSPinTypeSPI(SPI1MISO(1), PA6);
//
// Configure MCU as a master device , 8 bits data width ,MSB first,Mode_0
//
xSPIConfigSet(xSPI1_BASE, 4000000, xSPI_MOTO_FORMAT_MODE_0 |
xSPI_MODE_MASTER |
xSPI_MSB_FIRST |
xSPI_DATA_WIDTH8);
xSPISSSet(xSPI1_BASE, xSPI_SS_SOFTWARE, xSPI_SS0);
xSPIEnable(xSPI1_BASE);
}
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"));
}
//*****************************************************************************
//
//! \brief Initialize 24LC64 and I2C
//!
//! \param None
//!
//! This function initialize the mcu I2C as master and specified I2C port.the
//! master block will be set up to transfer data at 400 kbps.
//!
//! \return None.
//
//*****************************************************************************
void _24LC64_Init(void)
{
//
// Enable GPIO Periph clock and Alternate Fuction I/O clock.
//
xSysCtlPeripheralEnable(_24LC64_I2C_GPIO);
//
// Enable the I2C which is connected with _24LC64_
//
xSysCtlPeripheralEnable2(_24LC64_I2C_PORT);
//
// Set _24LC64_PIN_I2C_SCK as IICx.SCK
//
xSPinTypeI2C(_24LC64_I2C_SCK, _24LC64_PIN_I2C_SCK);
//
// Set _24LC64_PIN_I2C_SDA as I2Cx.SDA
//
xSPinTypeI2C(_24LC64_I2C_SDA, _24LC64_PIN_I2C_SDA);
//
// Initializes the I2C Master block.
//
xI2CMasterInit(_24LC64_I2C_PORT, I2C_Speed);
}
void pwmInit(){
xSysCtlPeripheralClockSourceSet(xSYSCTL_PWMA_HCLK, 1);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_PWMA);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
xSPinTypePWM(TIM0CH0, PB11);
xSPinTypePWM(TIM0CH1, PB10);
xPWMInitConfigure(xPWMA_BASE, xPWM_CHANNEL0, xPWM_TOGGLE_MODE);
xPWMInitConfigure(xPWMA_BASE, xPWM_CHANNEL1, xPWM_TOGGLE_MODE);
xPWMFrequencySet(xPWMA_BASE, xPWM_CHANNEL0, 50);
xPWMDutySetPrec(xPWMA_BASE, xPWM_CHANNEL0, 750);
xPWMOutputEnable(xPWMA_BASE, xPWM_CHANNEL0);
xPWMStart(xPWMA_BASE, xPWM_CHANNEL1);
xPWMFrequencySet(xPWMA_BASE, xPWM_CHANNEL1, 50);
xPWMDutySetPrec(xPWMA_BASE, xPWM_CHANNEL1, 750 + STEER_OFFSET);
xPWMOutputEnable(xPWMA_BASE, xPWM_CHANNEL1);
xPWMStart(xPWMA_BASE, xPWM_CHANNEL1);
}
//*****************************************************************************
//
//! The main function of the i2c slave receive with poll mode
//
//! return none
//
//*****************************************************************************
void SlaveReceivePoll(void)
{
//
// Congigure the i2c pin
//
xSPinTypeI2C(I2C0SCK, PA11);
xSPinTypeI2C(I2C0DATA, PA10);
//
// Enable the i2c peripheral
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_I2C0);
//
// Init the I2C as slave
//
I2CSlaveInit(I2C0_BASE, SlaveAddress, I2C_GENERAL_CALL_DIS);
//
// Install the i2c0 interrupt service function
//
// I2CIntCallbackInit(I2C0_BASE, ( xtEventCallback)SlavaRecvFunc);
WriteBuf[8] = '\0';
//
// I2C master transfer config
//
I2CSlaveRcCfg.pvWBuf = WriteBuf;
I2CSlaveRcCfg.ulWLen = WriteLength;
I2CSlaveRcCfg.ulWCount = 0;
I2CSlaveRcCfg.pvRBuf = ReceiveBuf;
I2CSlaveRcCfg.ulRLen = ReceiveLength;
//I2CSlaveRcCfg.pvRBuf = 0;
//I2CSlaveRcCfg.ulRLen = 0;
I2CSlaveRcCfg.ulRCount = 0;
//
// UART initialize
//
UART0Configuration();
xI2CIntCallbackInit(I2C0_BASE, SlavaRecvFunc);
//
// I2C salve receive wiht pollint mode
//
I2CSlaveTransfer(I2C0_BASE, &I2CSlaveRcCfg, I2C_TRANSFER_POLLING);
//
// Print the receive data form the master
//
while(1)
{
}
}
//*****************************************************************************
//
//! \brief something should do before the test execute of xpwm002 test.
//!
//! \return None.
//
//*****************************************************************************
static void xpwm002Setup(void)
{
SysCtlKeyAddrUnlock();
xSysCtlClockSet(12000000, xSYSCTL_XTAL_12MHZ | xSYSCTL_OSC_MAIN);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMA);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMB);
//
// GPIO pin function set as pwm output
//
xSPinTypePWM(PWM0, PA12);
xSPinTypePWM(PWM1, PA13);
xSPinTypePWM(PWM2, PA14);
xSPinTypePWM(PWM3, PA15);
xSPinTypePWM(PWM4, PB11);
xSPinTypePWM(PWM5, PE5);
xSPinTypePWM(PWM6, PE0);
xSPinTypePWM(PWM7, PE1);
}
//*****************************************************************************
//
//! \brief something should do before the test execute of xi2c001 test.
//!
//! \return None.
//
//*****************************************************************************
static void xI2C001Setup(void)
{
xSysCtlPeripheralEnable2(ulMaster);
xSysCtlPeripheralEnable2(xGPIO_PORTD_BASE);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeI2C(I2C0SCK, PD12);
xSPinTypeI2C(I2C0SDA, PD13);
}
//*****************************************************************************
//
//! \brief Initialize STMPE811 and I2C
//!
//! \param None
//!
//! This function initialize the mcu I2C as master and specified I2C port.the
//! master block will be set up to transfer data at 400 kbps.
//!
//! \return None.
//
//*****************************************************************************
void STMPE811Init(void)
{
//
// Enable GPIO Periph clock and Alternate Fuction I/O clock.
//
xSysCtlPeripheralEnable(STMPE811_I2C_GPIO);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//
// Enable the I2C which is connected with STMPE811
//
xSysCtlPeripheralEnable2(STMPE811_PIN_I2C_PORT);
//
// Set STMPE811_PIN_I2C_SCK as IICx.SCK
//
xSPinTypeI2C(STMPE811_I2C_SCK, STMPE811_PIN_I2C_SCK);
//
// Set STMPE811_PIN_I2C_SDA as I2Cx.SDA
//
xSPinTypeI2C(STMPE811_I2C_SDA, STMPE811_PIN_I2C_SDA);
//
// I2C enable
//
xI2CMasterEnable(STMPE811_PIN_I2C_PORT);
//
// Initializes the I2C Master block.
//
xI2CMasterInit(STMPE811_PIN_I2C_PORT, I2C_Speed);
//
// Set INT pin.
//
xGPIODirModeSet(STMPE811_INT_PORT, STMPE811_INT_GPIO, xGPIO_DIR_MODE_IN);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(STMPE811_INT_PORT, STMPE811_INT_GPIO, STMPE811IntCallback);
// Enable GPIO pin interrupt.
xGPIOPinIntEnable(STMPE811_INT_PORT, STMPE811_INT_GPIO, xGPIO_FALLING_EDGE);
xIntEnable(INT_GPIO);
// STNPE811 initializtion.
STMPE811InitConfig();
}
//////////////////////////////////////////////////////////////////////////////
// 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 PWM output function example.
//!
//! \return None.
//
//*****************************************************************************
void PWM_Output()
{
//
// Initionalize system clock and I/O port.
//
IOInit();
PrintLine( "*** Cox PWM example ***" );
//
// Set GPIO Pin as PWM and enable PWM
//
xSPinTypePWM(PWM2, PA14);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_PWMA);
//
// Set invert, dead zone and mode
//
xPWMInitConfigure(xPWMA_BASE, xPWM_CHANNEL2, xPWM_TOGGLE_MODE |
xPWM_OUTPUT_INVERTER_DIS | xPWM_DEAD_ZONE_DIS );
// Set CNR, Prescale and Divider
xPWMFrequencyConfig(xPWMA_BASE, xPWM_CHANNEL2, 0x3FF1111);
//
// Set CMR
//
xPWMDutySet(xPWMA_BASE, xPWM_CHANNEL2, 40);
//
// Set output enable
//
xPWMOutputEnable(xPWMA_BASE, xPWM_CHANNEL2);
// Set interrupt call back
xPWMIntCallbackInit(xPWMA_BASE, user_Callback);
//
// PWM output interrupt enable
//
xPWMIntEnable(xPWMA_BASE, xPWM_CHANNEL2, xPWM_INT_PWM);
//
// NVIC interrupt enable
//
xIntEnable(xINT_PWMA);
//
// start pwm
//
xPWMStart(xPWMA_BASE, xPWM_CHANNEL2);
}
void
TestIOInit(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
SysCtlDelay(10000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
//xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
//xSPinTypeUART(UART1RX,PA10);
xSPinTypeUART(UART1TX,PA9);
xSysCtlPeripheralReset(xSYSCTL_PERIPH_UART1);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_UART1);
//SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART_S_EXT12M);
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));
}
//*****************************************************************************
//
//! \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));
}
