//*****************************************************************************
//
//! \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);
}
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 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"));
}
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]);
}
}
}
//*****************************************************************************
//
//! 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);
}
//*****************************************************************************
//
//! \brief something should do before the test execute of xwdt002 test.
//!
//! \return None.
//
//*****************************************************************************
static void xwdt002Setup(void)
{
//
// Set WDT clock source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_WDT0_EXTSL, 16);
//
// Enable WDT
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_WDT);
}
//*****************************************************************************
//
//! \brief Initializes the PTC08 device.
//!
//! Initializes the PTC08 device,it will set the baud rate 115200,image size
//! 320*240,ziprate 36 and non-save power.
//!
//! \return None.
//
//*****************************************************************************
xtBoolean
PTC08Init(void)
{
xSysCtlPeripheralEnable2(PTC08_UART);
xSysCtlPeripheralEnable2(xGPIOSPinToPeripheralId(PTC08_PIN_UART_RX));
xSysCtlPeripheralEnable2(xGPIOSPinToPeripheralId(PTC08_PIN_UART_TX));
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART1_MAIN, 1);
xSPinTypeUART(PTC08_UART_RX, PTC08_PIN_UART_RX);
xSPinTypeUART(PTC08_UART_TX, PTC08_PIN_UART_TX);
xUARTConfigSet(PTC08_UART, 38400, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
xUARTEnable(PTC08_UART, (xUART_BLOCK_UART | xUART_BLOCK_TX | xUART_BLOCK_RX));
//
// Must wait for 2.5s before the camera can received Command
//
xSysCtlDelay(25000000);
if(!PTC08PhotoReset())
{
return xfalse;
}
if(!PTC08PhotoSizeSet(PTC08_SIZE_320_240))
{
return xfalse;
}
if(!PTC08ZipRateSet(0x36))
{
return xfalse;
}
xSysCtlDelay(10);
if(!PTC08SavePowerSet(PTC08_SAVE_POWER_DIS))
{
return xfalse;
}
if(!PTC08BaudRateSet(PTC08_BAUDRATE_115200))
{
return xfalse;
}
xUARTConfigSet(PTC08_UART, 115200, (UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
return xtrue;
}
//*****************************************************************************
//
//! \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 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);
}
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));
}
//*****************************************************************************
//
//! \brief Init the ADC with the corresponding configuration in the
//! LPR5150AL_Configure gorup.
//!
//! \return None.
//
//*****************************************************************************
void
LPR5150ALInit()
{
//
// Select the ADC clock source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_HCLK, 3);
//
// Enable Peripheral ADC0
//
xSysCtlPeripheralEnable2(LPR5150AL_ADC_BASE);
//
// Configure Some GPIO pins as ADC Mode
//
XAXIS_PIN_IN_CFG();
YAXIS_PIN_IN_CFG();
//
// Enable the ADC
//
xADCEnable(LPR5150AL_ADC_BASE);
//
// ADC Channel0 convert once, Software tirgger.
//
xADCConfigure(LPR5150AL_ADC_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Enable the channel2/3
//
xADCStepConfigure(LPR5150AL_ADC_BASE, 0, xADC_CTL_CH2);
xADCStepConfigure(LPR5150AL_ADC_BASE, 1, xADC_CTL_CH3);
//
// ADC start Convert
//
xADCProcessorTrigger(LPR5150AL_ADC_BASE);
}
//*****************************************************************************
//
//! \brief something should do before the test execute of xadc001 test.
//!
//! \return None.
//
//*****************************************************************************
static void xadc001Setup( void )
{
//
// Enable ADC clock
//
SysCtlPeripheralEnable( SYSCTL_PERIPH_ADC);
//
// Enable GPIO clock
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
//
// configure GPIO pin as ADC function
//
xSPinTypeADC(ADC0, PE20);
//
// Set ADC clock source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_MAIN, 8);
}
//*****************************************************************************
//
//! \brief Dalay some time in ms.
//!
//! \param ulDelay is the delay number of ms.
//!
//! \return None.
//
//*****************************************************************************
void
DelayMS(unsigned long ulDelay)
{
//
// Set the timer clock
//
xSysCtlPeripheralClockSourceSet(LPR5150AL_TIMER_CLK, 1);
xSysCtlPeripheralEnable2(LPR5150AL_TIMER_BASE);
//
// Clear the status first
//
xTimerStatueClear(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0, xTIMER_INT_MATCH);
//
// Config as periodic mode
//
xTimerInitConfig(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0, xTIMER_MODE_PERIODIC, 1000);
xTimerIntEnable(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0, xTIMER_INT_MATCH);
xTimerStart(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0);
//
// Delay ulDelay cycles, one cycle delay is 1ms.
//
while(ulDelay)
{
while(!xTimerStatusGet(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0, xTIMER_INT_MATCH));
xTimerStatueClear(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0, xTIMER_INT_MATCH);
ulDelay--;
}
//
// Stop the timer
//
xTimerStop(LPR5150AL_TIMER_BASE, xTIMER_CHANNEL0);
xSysCtlPeripheralDisable2(LPR5150AL_TIMER_BASE);
}
//*****************************************************************************
//
//! \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]);
}
}
void Blinky(void)
{
unsigned long i;
//
// Initionalize system clock.
//
xSysCtlPeripheralClockSourceSet( 10000000, xSYSCTL_XTAL_12MHZ );
//
// Set GPIO port c pin 0 , 1 output mode.
//
xGPIODirModeSet( xGPIO_PORTC_BASE, xGPIO_PIN_0, xGPIO_DIR_MODE_OUT );
xGPIODirModeSet( xGPIO_PORTC_BASE, xGPIO_PIN_1, xGPIO_DIR_MODE_OUT );
while (1)
{
//
// Delay some time.
//
for( i = 0; i < 0x1FFFF; i++ )
//
// Output high level.
//
xGPIOPinWrite( xGPIO_PORTC_BASE, xGPIO_PIN_0 | xGPIO_PIN_1, 1 );
for( i = 0; i < 0x1FFFF; i++ )
//
// Output low level.
//
xGPIOPinWrite( xGPIO_PORTC_BASE, xGPIO_PIN_0 | xGPIO_PIN_1, 0 );
}
}
//*****************************************************************************
//
//! \brief Init the sensor shield board.
//!
//! \param None.
//!
//! Init the sensor shield board.
//!
//! \return None
//
//*****************************************************************************
void
SensorShieldInit(void)
{
#if(SENSOR_SHIELD_OUT_USED > 0)
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O0);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O1);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O2);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O3);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O4);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O5);
#endif
#if((SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG))
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_HCLK, 3);
//
// Enable Peripheral ADC0
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC0);
//
// Configure Some GPIO pins as ADC Mode
//
//
// Enable the adc
//
xADCEnable(xADC0_BASE);
//
// ADC Channel0 convert once, Software tirgger.
//
xADCConfigure(xADC0_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Enable the channel0
//
//
// Set Compare Condition(Moisture Sensor Limited Value)
//
xADCCompConditionConfig(ADC_BASE, 0, xADC_COMP_INT_LOW);
ADCCompDataSet(ADC_BASE, 0, 1600, 1);
xADCCompEnable(ADC_BASE, 0);
//
// Enable the ADC end of conversion interrupt
//
xADCIntEnable(xADC0_BASE, xADC_INT_COMP);
//
// install the call back interrupt
//
xADCIntCallbackInit(xADC0_BASE, ADCCallback);
//
// Enable the NVIC ADC interrupt
//
xIntEnable(xINT_ADC0);
xADCProcessorTrigger(xADC0_BASE);
#endif
#if(SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG)
sA0PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH0);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A0);
#endif
#if(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG)
sA1PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH1);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A1);
#endif
#if(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG)
sA2PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH2);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A2);
#endif
#if(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG)
sA3PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH3);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A3);
#endif
#if(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG)
sA4PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH4);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A4);
#endif
#if(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG)
sA5PinTypeADC();
xADCStepConfigure(xADC0_BASE, 1, xADC_CTL_CH5);
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_A5);
#endif
#if(SENSOR_SHIELD_I2C_USED > 0)
//
// Enable the GPIOx port which is connected with I2C
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SDA));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SCK));
//
// Enable the I2Cx which is connected with device
//
xSysCtlPeripheralEnable2(sI2C_BASE);
//
// Set BH1750_PIN_I2C_CLK as CLK
//
sPinTypeI2C(sI2C_BASE);
//
// Configure MCU as a master device and Set Clcok Rates
//
xI2CMasterInit(sI2C_BASE, 100000);
xI2CMasterEnable(sI2C_BASE);
#endif
#if(SENSOR_SHIELD_UART_USED > 0)
xSysCtlPeripheralEnable2(sUART_BASE);
xSysCtlPeripheralClockSourceSet(xSYSCTL_UART1_MAIN, 1);
sPinTypeUART(sUART_BASE);
xUARTConfigSet(sUART_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
#endif
}
//*****************************************************************************
//
//! \brief xsysctl 004 test of Set a peripheral clock source and peripheral
//£¡ divide test .
//!
//! \return None.
//
//*****************************************************************************
static void xsysctl_xSysCtlPeripheralClockSourceSet_test(void)
{
unsigned long ulTemp,i,ulTempValue,j;
for(i = 1; i < 3; i++)
{
xSysCtlPeripheralClockSourceSet(ulxWDT0ClkSource[i], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert(((i+1) == (ulTemp & SYSCLK_CLKSEL1_WDG_M)), "xsysctl API error!");
}
xSysCtlPeripheralClockSourceSet(ulxWDT0ClkSource[0], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((0 == (ulTemp & SYSCLK_CLKSEL1_WDG_M)), "xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxPWMAClkSource[0], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((2 == (ulTemp & SYSCLK_CLKSEL1_PWM01_M)>>SYSCLK_CLKSEL1_PWM01_S),
"xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxTIMER0ClkSource[0], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((0 == (ulTemp & SYSCLK_CLKSEL1_TMR0_M)>>SYSCLK_CLKSEL1_TMR0_S),
"xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxTIMER0ClkSource[1], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((2 == (ulTemp & SYSCLK_CLKSEL1_TMR0_M)>>SYSCLK_CLKSEL1_TMR0_S),
"xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxTIMER0ClkSource[2], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((7 == (ulTemp & SYSCLK_CLKSEL1_TMR0_M)>>SYSCLK_CLKSEL1_TMR0_S),
"xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxTIMER1ClkSource[0], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((0 == (ulTemp & SYSCLK_CLKSEL1_TMR1_M)>>SYSCLK_CLKSEL1_TMR1_S),
"xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxTIMER1ClkSource[1], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((2 == (ulTemp & SYSCLK_CLKSEL1_TMR1_M)>>SYSCLK_CLKSEL1_TMR1_S),
"xsysctl API error!");
xSysCtlPeripheralClockSourceSet(ulxTIMER1ClkSource[2], 1);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((7 == (ulTemp & SYSCLK_CLKSEL1_TMR1_M)>>SYSCLK_CLKSEL1_TMR1_S),
"xsysctl API error!");
//
// UART0 Clock Source and Divide Test
//
for(j = 1; j <= 16; j++)
{
for(i = 0; i < 1; i++)
{
xSysCtlPeripheralClockSourceSet(ulxUART0ClkSource[i], j);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((i == (ulTemp & SYSCLK_CLKSEL1_UART_M)>>SYSCLK_CLKSEL1_UART_S),
"xsysctl API error!");
ulTempValue = xHWREG(SYSCLK_CLKDIV);
TestAssert(((j-1) == (ulTempValue & SYSCLK_CLKDIV_UART_M)>>SYSCLK_CLKDIV_UART_S),
"xsysctl API error!");
}
xSysCtlPeripheralClockSourceSet(ulxUART0ClkSource[1], j);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((3 == (ulTemp & SYSCLK_CLKSEL1_UART_M)>>SYSCLK_CLKSEL1_UART_S),
"xsysctl API error!");
}
xSysCtlPeripheralClockSourceSet2(ADC0, INT, 159);
ulTemp = xHWREG(SYSCLK_CLKSEL1);
TestAssert((2 == (ulTemp &0x00000008)>>SYSCLK_CLKSEL1_ADC_S),
"xsysctl API error!");
ulTemp = xHWREG(SYSCLK_CLKDIV);
TestAssert((158 == (ulTemp & SYSCLK_CLKDIV_ADC_M)>>SYSCLK_CLKDIV_ADC_S),
"xsysctl API error!");
}
//*****************************************************************************
//
//! \brief Initialize the sensor shield board.
//!
//! \param None.
//!
//! Initialize the sensor shield board.
//!
//! \return None
//
//*****************************************************************************
void
SensorShieldInit(void)
{
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O0));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O1));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O2));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O3));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O4));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_O5));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I0));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I1));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I2));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I3));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I4));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_I5));
#if(SENSOR_SHIELD_OUT_USED > 0)
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O0);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O1);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O2);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O3);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O4);
xGPIOSPinTypeGPIOOutput(SENSOR_SHIELD_O5);
//xSysCtlPeripheralEnable2();
#endif
#if((SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG) || \
(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG))
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(sD45));
//
// Set ADCCLK prescaler, ADCCLK=PCLK2(max 72MHz)/Div(Div:2,4,6,8)
// You should set ADCCLK < 14MHz to ensure the accuracy of ADC
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_MAIN, 8);
//
// Enable Peripheral ADC clock
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC1);
//
// Enable the ADC conversion
//
xADCEnable(sADC_BASE);
//
// The two sentences below configure ADC to scan mode, continuous convert, software trigger.
//
xADCConfigure(sADC_BASE, xADC_MODE_SCAN_SINGLE_CYCLE, ADC_TRIGGER_PROCESSOR);
xADCConfigure(sADC_BASE, xADC_MODE_SCAN_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
//
// Configure channel step by step.(Max 4 steps, the 2nd parameter start from 0, max is 3)
// Must not jump over a step, or the ADC result may be in wrong position.
//
xADCStepConfigure(sADC_BASE, 0, sADC_CH0);
xADCStepConfigure(sADC_BASE, 1, sADC_CH1);
xADCStepConfigure(sADC_BASE, 2, sADC_CH2);
xADCStepConfigure(sADC_BASE, 3, sADC_CH3);
#endif
#if(SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_ANALOG)
sA0PinTypeADC();
#elif (SENSOR_SHIELD_IN0_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I0);
#endif
#if(SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_ANALOG)
sA1PinTypeADC();
#elif (SENSOR_SHIELD_IN1_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I1);
#endif
#if(SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_ANALOG)
sA2PinTypeADC();
#elif (SENSOR_SHIELD_IN2_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I2);
#endif
#if(SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_ANALOG)
sA3PinTypeADC();
#elif (SENSOR_SHIELD_IN3_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I3);
#endif
#if(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_ANALOG)|| \
(SENSOR_SHIELD_IN4_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I4);
#endif
#if(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_ANALOG)|| \
(SENSOR_SHIELD_IN5_USED == SENSOR_SHIELD_IN_DIGITAL)
xGPIOSPinTypeGPIOInput(SENSOR_SHIELD_I5);
#endif
#if(SENSOR_SHIELD_I2C_USED > 0)
//
// Enable the GPIOx port which is connected with I2C
//
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SDA));
xSysCtlPeripheralEnable(xGPIOSPinToPeripheralId(SENSOR_SHIELD_TWI_SCK));
//
// Enable the I2Cx which is connected with device
//
xSysCtlPeripheralEnable2(sI2C_BASE);
//
// Set BH1750_PIN_I2C_CLK as CLK
//
sPinTypeI2C(sI2C_BASE);
//
// Configure MCU as a master device and Set Clcok Rates
//
xI2CMasterInit(sI2C_BASE, 100000);
xI2CMasterEnable(sI2C_BASE);
#endif
#if(SENSOR_SHIELD_UART_USED > 0)
xSysCtlPeripheralEnable2(sUART_BASE);
// xSysCtlPeripheralClockSourceSet(xSYSCTL_UART1_MAIN, 1);
sPinTypeUART(sUART_BASE);
xUARTConfigSet(sUART_BASE, 115200, (xUART_CONFIG_WLEN_8 |
xUART_CONFIG_STOP_1 |
xUART_CONFIG_PAR_NONE));
#endif
}
