//*****************************************************************************
//
//! \brief Ininite the DMA case which is needed
//!
//! \param None
//!
//! \details This function is to ininite the DMA including clock source and
//! enable DMA
//!
//! \return none
//
//*****************************************************************************
void DMAInit(void)
{
unsigned long i;
xIntEnable(INT_DMA0);
xIntEnable(INT_DMA1);
xIntEnable(INT_DMA2);
xIntEnable(INT_DMA3);
for(i = 0; i < 4; i++)
{
DMAChannelDeAssign(ulDMAChannelID[i]);
DMAEnable(ulDMAChannelID[i]);
}
for(i = 0; i < 4; i++)
{
ulAssignChannel[i] = DMAChannelDynamicAssign(DMA_REQUEST_MEM,
DMA_REQUEST_MEM);
}
for(i = 0; i < 4; i++)
{
DMAChannelIntEnable(ulDMAChannelID[i], DMA_EVENT_TC);
DMAChannelIntCallbackInit(ulDMAChannelID[i], DmaCallbackFunc[i]);
}
}
static void xpwm002Execute(void)
{
unsigned long ulBase;
int i, j;
for(i = 0; i < 2; i++)
{
for(j = 0; j < 4; j++)
{
ulBase = PWMBase[i];
//
// Set invert, dead zone and mode
//
xPWMInitConfigure(ulBase, PWMChannel[i], xPWM_TOGGLE_MODE |
xPWM_OUTPUT_INVERTER_DIS | xPWM_DEAD_ZONE_DIS);
// Set CNR, Prescale and Divider
xPWMFrequencyConfig(ulBase, PWMChannel[i], 0x0E100028);
//
// Set CMR
//
xPWMDutySet(ulBase, PWMChannel[i], 40);
//
// Set output enable
//
xPWMOutputEnable(ulBase, PWMChannel[i]);
//
// Set interrupt call back
//
xPWMIntCallbackInit(ulBase, user_Callback);
//
// PWM output interrupt enable
//
xPWMIntEnable(ulBase, PWMChannel[i], xPWM_INT_PWM);
//
// NVIC interrupt enable
//
xIntEnable(xINT_TIMER1);
xIntEnable(xINT_TIMER2);
xIntEnable(xINT_TIMER3);
xIntEnable(xINT_TIMER4);
//
// start pwm
//
xPWMStart(ulBase, PWMChannel[i]);
TestAssertQBreak("a", " pwm intterupt test error!", 0xffffffff);
}
}
}
void Enable_LLWU(void)
{
// Enables LLWU interrupt
xIntEnable(INT_LLWU);
/* Initialization of the LLWU module */
LLWU_PE1 = 0;
LLWU_PE2 = 0;
LLWU_PE3 = 0;
LLWU_PE4 = 0x20;
/* LLWU_ME: WUME7=0,WUME5=0,WUME4=0,WUME1=0,WUME0=1 */
LLWU_ME = (uint8_t)((LLWU_ME & (uint8_t)~(uint8_t)(
LLWU_ME_WUME7_MASK |
LLWU_ME_WUME5_MASK |
LLWU_ME_WUME4_MASK |
LLWU_ME_WUME1_MASK
)) | (uint8_t)(
LLWU_ME_WUME0_MASK
));
/* LLWU_FILT1: FILTF=1,FILTE=0,??=0,FILTSEL=0 */
LLWU_FILT1 = LLWU_FILT1_FILTF_MASK |
LLWU_FILT1_FILTE(0x00) |
LLWU_FILT1_FILTSEL(0x00);
/* LLWU_FILT2: FILTF=1,FILTE=0,??=0,FILTSEL=0 */
LLWU_FILT2 = LLWU_FILT2_FILTF_MASK |
LLWU_FILT2_FILTE(0x00) |
LLWU_FILT2_FILTSEL(0x00);
}
//*****************************************************************************
//
//! \brief Wdt api wdt interrupt test.
//!
//! \return None.
//
//*****************************************************************************
static void wdt_WDTInterrupt_test(void)
{
//
// Set WatchDog Timer(WDT)'s Timer Interval.
//
WDTimerInit(WDT_INTERVAL_2_10T);
//
// Enable the WDT Interrupt
//
WDTimerFunctionEnable(WDT_INT_FUNCTION);
xIntEnable(INT_WDT);
//
// Install the callback function
//
WDTimerIntCallbackInit(WDTCallback);
//
// Start the WDT
//
WDTimerEnable();
TestAssertQBreak("a", "Transfer Over Interrupy fialed!", 5000000);
}
//*****************************************************************************
//
//! \brief adc api interrupt state and data get test.
//!
//! \return None.
//
//*****************************************************************************
static void adcIntTest(void)
{
//
// Set the length of converter
//
// ADCConverLenSet(ADC1_BASE, 1, 1);
//
// Test ADC configure API
//
// ADCSequenceIndexSet(ADC1_BASE, ulAdcSeqNo, ulAdcSeqNo);
// ADCSampLenSet(ADC1_BASE, 14, ADC_SAMPTIME_7_5_CYCLE);
//
// A/D interrupt enable
//
ADCIntEnable(ADC_BASE, ADC_INT_END_CONVERSION);
xIntEnable(INT_ADC);
xADCIntCallbackInit(ADC_BASE, ADC0IntFucntion);
//
// A/D configure
//
ADCConfigure(ADC_BASE, ADC_INPUT_SINGLE, ADC_OP_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
ADCProcessorTrigger(ADC_BASE);
TestAssertQBreak("T", "xadc interrupt function error!", 0xFFFFFFFF);
}
//*****************************************************************************
//
//! \brief Wdt wakeup example.
//!
//! \return None.
//
//*****************************************************************************
void Wakeup(void)
{
//
// Set WDT clock and interval time.
//
xWDTInit(xWDT_BASE, SYSCTL_PERIPH_WDG_S_INT10K, xWDT_INTERVAL_2_10T);
//
// Set WDT interrupt and initionalize callback.
//
xWDTIntCallbackInit(xWDT_BASE, user_Callback);
//
// Enable WDT wake up function.
//
xWDTFunctionEnable(xWDT_BASE, xWDT_WAKEUP_FUNCTION | xWDT_INT_FUNCTION);
xIntEnable( xINT_WDT );
//
// Start WDT timer.
//
xWDTEnable( xWDT_BASE );
//
// Make chip enter into sleep state.
//
xSysCtlSleep();
//
// Interrupt wake up cpu.
//
xCPUwfi();
}
int main(void)
{
unsigned char i;
xSysCtlClockSet(16000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
// xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
SensorShieldInit();
SensorShieldIOInit();
xGPIOSPinDirModeSet(SENSOR_SHIELD_I0, xGPIO_DIR_MODE_IN);
xGPIOSPinDirModeSet(SENSOR_SHIELD_I1, xGPIO_DIR_MODE_IN);
xGPIOSPinDirModeSet(SENSOR_SHIELD_I2, xGPIO_DIR_MODE_IN);
xGPIOSPinIntEnable(SENSOR_SHIELD_I0, xGPIO_RISING_EDGE);
xGPIOSPinIntEnable(SENSOR_SHIELD_I1, xGPIO_RISING_EDGE);
xGPIOSPinIntEnable(SENSOR_SHIELD_I2, xGPIO_RISING_EDGE);
xGPIOSPinIntCallbackInit(SENSOR_SHIELD_I0, Key1Callback);
xGPIOSPinIntCallbackInit(SENSOR_SHIELD_I1, Key2Callback);
xGPIOSPinIntCallbackInit(SENSOR_SHIELD_I2, Key3Callback);
xIntEnable(xINT_GPIOB);
xIntEnable(xINT_GPIOB);
SensorShieldOutWrite(SENSOR_SHIELD_O0, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O1, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O2, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O3, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O4, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O5, 1);
while(1)
{
if(key2)
{
key2 = 0;
for(i=0;i<10;i++){
SensorShieldOutWrite(SENSOR_SHIELD_O0, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O1, 1);
SensorShieldOutWrite(SENSOR_SHIELD_O2, 1);
SysCtlDelay(1000000);
SensorShieldOutWrite(SENSOR_SHIELD_O0, 0);
SensorShieldOutWrite(SENSOR_SHIELD_O1, 0);
SensorShieldOutWrite(SENSOR_SHIELD_O2, 0);
SysCtlDelay(1000000);
}
}
}
}
/*
* Initiate the Wire library and join the I2C bus as a slave. This should normally be called only once.
* Parameters: address: the 7-bit slave address (optional);
*/
void WireClass::begin(uint8_t address){
// Init the I2C as slave
//xI2CSlaveInit(i2cPort, address, xI2C_GENERAL_CALL_EN); //mcy
xI2CSlaveEnable(i2cPort);
xI2CIntCallbackInit(i2cPort, WireClass::I2CCallbackFunc);
xI2CSlaveIntEnable(i2cPort, xI2C_SLAVE_INT_DATA | xI2C_MASTER_INT_DATA);
xIntEnable(xSysCtlPeripheraIntNumGet(i2cPort));
}
void main(void)
{
//unsigned long ulTmp = 0;
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
// Configure LED(PC3) pin
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
xGPIOSPinTypeGPIOOutput(PC3);
// Turn off LED
GPIOPinClr(GPIOC_BASE, GPIO_PIN_3);
// Disable NVIC RTC interrupt
xIntDisable(xINT_RTC);
RTCDisable();
RTCIntCallbackInit(RTCHandler);
// Enable RTC second increment interrupt.
// Enable RTC minute interrupt.
RTCIntCfg( INT_SEC_EN | INT_MIN_DIS |
INT_HOUR_DIS | INT_DOM_DIS |
INT_DOW_DIS | INT_DOY_DIS |
INT_MON_DIS | INT_YEAR_DIS |
INT_ALARM_SEC_DIS | INT_ALARM_MIN_EN |
INT_ALARM_HOUR_DIS | INT_ALARM_DOM_DIS |
INT_ALARM_DOW_DIS | INT_ALARM_DOY_DIS |
INT_ALARM_MON_DIS | INT_ALARM_YEAR_DIS );
RTCTimeSet(RTC_TIMETYPE_SECOND, 0);
RTCTimeSet(RTC_TIMETYPE_MINUTE, 0);
RTCTimeSet(RTC_TIMETYPE_HOUR, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFWEEK, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFMONTH, 0);
RTCTimeSet(RTC_TIMETYPE_DAYOFYEAR, 0);
RTCTimeSet(RTC_TIMETYPE_MONTH, 0);
RTCTimeSet(RTC_TIMETYPE_YEAR, 0);
RTCAlarmSet(RTC_TIMETYPE_SECOND, 0);
RTCAlarmSet(RTC_TIMETYPE_MINUTE, 1);
RTCAlarmSet(RTC_TIMETYPE_HOUR, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFWEEK, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFMONTH, 0);
RTCAlarmSet(RTC_TIMETYPE_DAYOFYEAR, 0);
RTCAlarmSet(RTC_TIMETYPE_MONTH, 0);
RTCAlarmSet(RTC_TIMETYPE_YEAR, 0);
RTCEnable();
RTCCounterReset();
xIntEnable(xINT_RTC);
while (1)
{
; // DoNothing
}
}
//*****************************************************************************
//
//! \brief Enable OTI mode corresponding pin interrupt.
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
void ADT75IntEnable(void)
{
unsigned long ulBase;
xGPIOSPinTypeGPIOInput(ADT75_PIN_OS);
xGPIOSPinIntEnable(ADT75_PIN_OS, ADT75_LEVEL_OS);
ulBase = xGPIOSPinToPort(ADT75_PIN_OS);
xIntEnable(xSysCtlPeripheraIntNumGet(ulBase));
}
//*****************************************************************************
//
//! 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 UART_Example_Basic(void)
{
/********************** Configure System clock *************************/
SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ);
SysCtlDelay(TICK_SLOW);
/********************** Configure GPIO Port ****************************/
#if (UART_ID == 0)
// 1: Enable GPIO Power and Clock
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// 2: Map GPIO Pin
// UART0 TX --> PA2
// UART0 RX --> PA3
xSPinTypeUART(UART0TX, PA2);
xSPinTypeUART(UART0RX, PA3);
#elif (UART_ID == 1)
// 1: Enable GPIO Power and Clock
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
// 2: Map GPIO Pin
// UART1 TX --> PC0
// UART1 RX --> PC1
xSPinTypeUART(UART1TX, PC0);
xSPinTypeUART(UART1RX, PC1);
#endif
/********************** Configure UART *********************************/
// 1: Enable UART0 Power and clock
#if (UART_ID == 0)
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
UARTCfg(UART0_BASE, 9600, UART_CFG_LEN_8_BIT | UART_CFG_STOP_1_BIT |
UART_CFG_PARITY_NONE | UART_CFG_BREAK_DIS);
UARTFIFOCfg(UART0_BASE, FIFO_CFG_FIFO_EN | FIFO_CFG_RX_TRI_LVL_0);
UARTIntEnable(UART0_BASE, INT_ABEO | INT_ABTO);
UARTIntCallbackInit(UART0_BASE, UserUARTHandler);
xIntEnable(xINT_UART0);
xHWREG(UART0_BASE + ACR) |= ACR_START;
while(Passed == 0);
UARTStrSend(UART0_BASE, "\r\nHello world\r\n");
#elif (UART_ID == 1)
// 1: Enable UART1 Power and clock
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
UARTCfg(UART1_BASE, 9600, UART_CFG_LEN_8_BIT | UART_CFG_STOP_1_BIT |
UART_CFG_PARITY_NONE | UART_CFG_BREAK_DIS);
UARTFIFOCfg(UART1_BASE, FIFO_CFG_FIFO_EN | FIFO_CFG_RX_TRI_LVL_0);
UARTStrSend(UART1_BASE, "Hello world\r\n");
#endif
while (1)
{
;
}
}
//*****************************************************************************
//
//! \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);
}
//*****************************************************************************
//
//! \brief xacmp 002 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
static void xACMP002Execute(void)
{
unsigned long ulTemp;
for(ulTemp=0;ulTemp<2;ulTemp++)
{
ACMPConfigure(ulBase, ulTemp, ulTempData[0]);
ACMPCancellation(ulBase, ulTemp, ACMP_POSITIVE_INPUT);
ACMPEnable(ulBase, ulTemp);
ACMPIntEnable(ulBase, ulTemp, ACMP_INT_RISING | ACMP_INT_FALLING);
xACMPIntCallbackInit(ulBase, ulTemp, ACMPCallback);
xIntEnable(xSysCtlPeripheralIntNumGet(ulBase));
SysCtlDelay(20000);
TestAssertQBreak("a", "Int error!", -1);
}
}
void Init_UART0(int baud, int buffer_size)
{
xtEventCallback UART0_INT_HANDLE = USART0IntHandler;
// Enable GPIO and UART Clock
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// Remap UART pin to GPIO Port UART0_RX --> PA2 UART0_TX --> PA1
xSPinTypeUART(UART0RX, PA1);
xSPinTypeUART(UART0TX, PA2);
// Set UART clock
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART0_S_MCGPLLCLK_2);
// Disable UART Receive/Transmit
UARTDisable(UART0_BASE, UART_TX | UART_RX);
// Configure UART Baud 115200
UARTConfigSet(UART0_BASE, baud, UART_CONFIG_SAMPLE_RATE_DEFAULT | UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_1);
if (OSSemCreate(0, &SerialTX0) != ALLOC_EVENT_OK)
{
// Oh Oh
// Não deveria entrar aqui !!!
while(1){};
};
// Só cria fila se for passado um tamanho maior que 0
if (buffer_size){
if (OSQueueCreate(buffer_size, &Serial0) != ALLOC_EVENT_OK)
{
// Oh Oh
// Não deveria entrar aqui !!!
while(1){};
};
}
UARTIntEnable(UART0_BASE, UART_INT_R);
UARTIntCallbackInit(UART0_BASE, UART0_INT_HANDLE);
// Enable UART Receive and Transmit
UARTEnable(UART0_BASE, UART_TX | UART_RX);
xIntEnable(28);
}
void Init_UART2(void)
{
xtEventCallback UART2_INT_HANDLE = USART2IntHandler;
// Enable GPIO and UART Clock
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
// Remap UART pin to GPIO Port UART0_RX --> PA2 UART0_TX --> PA1
xSPinTypeUART(UART2RX, PE23);
xSPinTypeUART(UART2TX, PE22);
// Set UART clock
SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_UART0_S_MCGPLLCLK_2);
// Disable UART Receive/Transmit
UARTDisable(UART2_BASE, UART_TX | UART_RX);
// Configure UART Baud 115200
UARTConfigSet(UART2_BASE, 9600, UART_CONFIG_SAMPLE_RATE_DEFAULT | UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_1);
if (OSSemCreate(0, &SerialTX2) != ALLOC_EVENT_OK)
{
// Oh Oh
// Não deveria entrar aqui !!!
while(1){};
};
if (OSQueueCreate(128, &Serial2) != ALLOC_EVENT_OK)
{
// Oh Oh
// Não deveria entrar aqui !!!
while(1){};
};
UARTIntEnable(UART2_BASE, UART_INT_R);
UARTIntCallbackInit(UART2_BASE, UART2_INT_HANDLE);
// Enable UART Receive and Transmit
UARTEnable(UART2_BASE, UART_TX | UART_RX);
xIntEnable(30);
}
void Enable_INT_Pin(void)
{
// Enables pin clock
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
// Init pin as GPIO, with pull-up enabled
PORTD_PCR4 = (uint32_t)((PORTD_PCR4 & (uint32_t)~(uint32_t)(
PORT_PCR_ISF_MASK |
PORT_PCR_MUX(0x06)
)) | (uint32_t)(
PORT_PCR_MUX(0x01) | PORT_PCR_PS_MASK | PORT_PCR_PE_MASK
));
// Enable interrupt as falling edge
GPIOPinIntEnable(GPIOD_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE);
// Enable INT
xIntEnable(INT_PORTD);
}
//*****************************************************************************
//
//! test RX,TX interrupt
//!
//! \return None.
//
//*****************************************************************************
void xuart005Execute_uartInt(void)
{
unsigned char info[] = "Hello,CooCox World!";
//
// Register the uart0 interrupt handler, Enable uart0 receive interrupt.
//
UARTIntCallbackInit(UART0_BASE, uart0CallbackFunc);
UARTIntEnable(UART0_BASE, UART_INT_THRE);
xIntEnable(INT_UART0);
xIntMasterEnable();
UARTBufferWrite(UART0_BASE, info, countof(info));
//
// wait until Transmitter FIFO level is less than the transmitter FIFO threshold.
//
TestAssertQBreak("b","UART Tx FIFO interrupt test fail", 0xFFFFFFFF);
}
//*****************************************************************************
//
//! \brief Wdt wakeup example.
//!
//! \return None.
//
//*****************************************************************************
void Wakeup(void)
{
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
SysCtlDelay(10000);
//
// Enable WDT wake up function.
//
xWDTFunctionEnable(xWDT_BASE, xWDT_INT_FUNCTION);
//
// Set WDT clock and interval time.
//
xWDTInit(xWDT_BASE, SYSCTL_PERIPH_WDG_S_EXTSL, 512);
//
// Set WDT interrupt and initionalize callback.
//
xWDTIntCallbackInit(xWDT_BASE, WdtCallback);
xIntEnable(xINT_WDT);
}
void TCN75Exp()
{
//
// Initalizes I2C.
//
TCN75Init(5000);
//
// config TCN75.
//
TCN75WakeUp();
TCN75Config(TCN75_MODE_CMP | TCN75_POLARITY_HIGH | TCN75_FAULTQUE_6);
TCN75LowLimitSet(fTemp);
TCN75UpLimitSet(fTemp);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_GPIO);
xGPIODirModeSet(GPIO_PORTA_BASE, GPIO_PIN_12, GPIO_DIR_MODE_OUT);
TCN75IntConfig(test_Led);
xIntEnable(xINT_GPIOB);
xIntMasterEnable();
uli = 0;
while(!uli)
{
fTemp = TCN75TempReadFDC();
for(ulj = 0; ulj < 0xfff ;ulj++);
}
xIntDisable(xINT_GPIOB);
xIntMasterDisable();
//
// Disables I2C0, set TCN75 as shutdown mode.
//
TCN75DeInit();
}
//*****************************************************************************
//
//! \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();
}
//*****************************************************************************
//
//! \brief Wdt api wdt wakeup test.
//!
//! \return None.
//
//*****************************************************************************
static void wdt_WakeUp_test(void)
{
unsigned long ulTemp;
//
// Set WatchDog Timer(WDT)'s Timer Interval.
//
WDTimerInit(WDT_INTERVAL_2_14T);
//
// Enter WDT function of wake up
//
WDTimerFunctionEnable(WDT_WAKEUP_FUNCTION | WDT_INT_FUNCTION);
xIntEnable(INT_WDT);
//
// Install WDT callback function
//
WDTimerIntCallbackInit(WDTCallbackSW);
//
// Start the WDT
//
WDTimerEnable();
ulTemp = xHWREG(WDT_WTCR);
//
// Enter power down mode
//
SysCtlPWRWUIntEnable(xtrue, xtrue);
SysCtlPowerDownEnable(xtrue);
SysCtlPowerDownWaitCPUSet(xtrue);
xCPUwfi();
PrintLine("Leave sleep mode!");
TestIOPut('\r');
TestIOPut('\n');
ulTemp = xHWREG(WDT_WTCR);
TestAssert(WDT_WTCR_WTWKF == (ulTemp & WDT_WTCR_WTWKF), "WDT API error!");
}
static void xspi004_MasterIntFunction(void)
{
unsigned long i, ulTemp=0;
//
// Configure Some GPIO pins as SPI Mode
//
xSPinTypeSPI(SPI0CLK, PC5);
xSPinTypeSPI(SPI0CS, PC4);
xSPinTypeSPI(SPI0MISO, PC7);
xSPinTypeSPI(SPI0MOSI, PC6);
//xHWREGB(xSPI0_BASE + SPI_C1) = 0x54;
//xHWREGB(xSPI0_BASE + SPI_C2) = 0x80;
//xHWREGB(xSPI0_BASE + SPI_BR) = 0x00;
//xHWREGB(xSPI0_BASE + SPI_M) = 0x04;
//
// Master Mode polarity 0,Rx latched at rising edge Tx changed at rising edge
// 2000000Hz 8Bits Data windth SPI MSB First
//
ulTemp = xSPI_MOTO_FORMAT_MODE_0 | xSPI_MODE_MASTER | xSPI_MSB_FIRST;
xSPIConfigSet(xSPI0_BASE, 20000, ulTemp);
xSPIEnable(xSPI0_BASE);
xIntEnable(INT_SPI0);
xIntPrioritySet(INT_SPI0, 1);
xSPIIntCallbackInit(xSPI0_BASE, SPI0Callback);
xSPIIntEnable(xSPI0_BASE, SPI_SPTEF | SPI_SPRF);
while(!ulFlag);
for(i = 0; i < 8; i++)
{
TestAssert((ulSourceData[i] == ulDestData[i]), "xspi API error!");
ulSourceData[i] = 0;
}
}
//*****************************************************************************
//
//! \brief xtimer 002 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
static void xTimer002Execute(void)
{
unsigned long ulTemp;
unsigned long ulBase;
int i;
//
// Periodic mode
//
for(i = 0; i < 2; i++)
{
ulBase = ulTimerBase[i];
ulTemp = 0;
//
// Clear the flag first
//
TimerIntClear(ulBase, TIMER_INT_UEV1);
//
// Config as periodic mode
//
xTimerInitConfig(ulBase, xTIMER_CHANNEL0, xTIMER_MODE_PERIODIC | xTIMER_COUNT_UP, 1000);
xTimerMatchSet(ulBase, xTIMER_CHANNEL0, 1000);
xTimerPrescaleSet(ulBase, xTIMER_CHANNEL0, 8);
xTimerIntCallbackInit(ulBase, TimerCallbackFunc[i]);
xTimerIntEnable(ulBase, xTIMER_CHANNEL0, xTIMER_INT_MATCH);
xIntEnable(ulTimerIntID[i]);
xTimerStart(ulBase, xTIMER_CHANNEL0);
TestAssertQBreak("b","Intterrupt test not happen", 0xfffffffe);
xTimerStop(ulBase, xTIMER_CHANNEL0);
}
}
//*****************************************************************************
//
//! \brief xgpio002 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
void External_Int(void)
{
xSysCtlClockSet(12000000, xSYSCTL_XTAL_12MHZ | xSYSCTL_OSC_MAIN);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOD);
//
// Level trigger interrupt
//
xGPIOSPinTypeGPIOInput(PD7);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(ulGPIO[1], xGPIO_PIN_7, user_Callback);
//
// Enable GPIO pin interrupt.
//
xGPIOPinIntEnable(ulGPIO[1], xGPIO_PIN_7, xGPIO_FALLING_EDGE);
xIntEnable(ulGPIOInt[1]);
while(1);
}
//*****************************************************************************
//
//! \brief xgpio002 test execute main body.
//!
//! \return None.
//
//*****************************************************************************
static void xgpio002Execute(void)
{
cIntCount = 0;
//
// Level trigger interrupt
//
xGPIOSPinTypeGPIOInput(PD7);
//
// Set GPIO pin interrupt callback.
//
xGPIOPinIntCallbackInit(ulGPIO[1], xGPIO_PIN_7, user_Callback);
//
// Enable GPIO pin interrupt.
//
xGPIOPinIntEnable(ulGPIO[1], xGPIO_PIN_7, xGPIO_FALLING_EDGE);
xIntEnable(ulGPIOInt[1]);
TestAssertQBreak("a", "gpio interrupt teset fail", 0xffffffff);
}
//*****************************************************************************
//
//! Ininite the acmp
//!
//! \param None
//!
//! This function ininite the ACMP including clock source and enable ACMP
//!
//! \return none
//
//*****************************************************************************
void ACMPCompare(void)
{
//
// Set SysClk 36MHz using Extern 12M oscillator
//
xSysCtlClockSet(12000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ);
//
// Enable Peripheral SPI0
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ACMP0);
//
// Configure the ACMP pin
//
xSPinTypeACMP(CMP0IN0, PC6);
xSPinTypeACMP(CMP0IN1, PC7);
xSPinTypeACMP(CMP0IN2, PC8);
//
// Congigure Comp-(Analog source negative input) is CPN pin
//
xACMPConfigure(xACMP0_BASE, 0, xACMP_ASRCN_PIN_IN0);
xACMPConfigure(xACMP0_BASE, 0, xACMP_ASRCN_PIN_IN1);
//
// Configure the INT
//
xACMPIntCallbackInit( xACMP0_BASE, 0, user_Callback );
xACMPIntEnable( xACMP0_BASE, 0 );
xIntEnable( xINT_ACMP0 );
//
// Enable ACMP
//
xACMPEnable( xACMP0_BASE, 0 );
}
//*****************************************************************************
//
//! \brief something should do before the test execute of xsysctl002 test.
//!
//! \return None.
//
//*****************************************************************************
static void xI2C001Setup(void)
{
xSysCtlPeripheralEnable2(ulSlave);
xSysCtlPeripheralReset2(ulSlave);
xSysCtlPeripheralEnable2(ulMaster);
xSysCtlPeripheralReset2(ulMaster);
xSysCtlPeripheralEnable2(GPIOB_BASE);
xSysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO);
xSPinTypeI2C(I2C1SCK, PB6);
xSPinTypeI2C(I2C1SDA, PB7);
//xSPinTypeI2C(I2C1SCK, PB8);
//xSPinTypeI2C(I2C1SDA, PB9);
xSPinTypeI2C(I2C2SCK, PB10);
xSPinTypeI2C(I2C2SDA, PB11);
I2CSlaveInit(ulSlave, I2C_ADDR_7BIT, 0x12, I2C_GENERAL_CALL_DIS);
I2CEnable(ulSlave);
I2CIntEnable(ulSlave, I2C_INT_BUF | I2C_INT_EVT | I2C_INT_ERR);
xIntEnable(xSysCtlPeripheraIntNumGet(ulSlave));
I2CIntCallbackInit(ulSlave, I2CSlaveCallback);
I2CMasterInit(ulMaster, SysCtlAPB1ClockGet(), xfalse, xtrue);
I2CEnable(ulMaster);
I2CMasterWriteS1(ulMaster, 0x12, 'a', xfalse);
I2CMasterWriteS2(ulMaster, 'b', xfalse);
I2CMasterWriteS2(ulMaster, 'c', xfalse);
I2CMasterWriteS2(ulMaster, 'd', xfalse);
I2CMasterReadS1(ulMaster, 0x12, ucTemp, xfalse);
I2CMasterReadS2(ulMaster, &ucTemp[1], xfalse);
I2CMasterReadS2(ulMaster, &ucTemp[2], xfalse);
I2CMasterReadS2(ulMaster, &ucTemp[3], xfalse);
I2CMasterReadS2(ulMaster, &ucTemp[4], xtrue);
}
//*****************************************************************************
//
//! \brief Wdt api wdt wakeup test.
//!
//! \return None.
//
//*****************************************************************************
static void wdt_WakeUp_test(void)
{
unsigned long ulTemp;
//
// Set WatchDog Timer(WDT)'s Timer Interval.
//
WDTimerInit(WDT_INTERVAL_2_14T);
//
// Enter WDT function of wake up
//
WDTimerFunctionEnable(WDT_WAKEUP_FUNCTION | WDT_INT_FUNCTION);
xIntEnable(INT_WDT);
//
// Install WDT callback function
//
WDTimerIntCallbackInit(WDTCallbackSW);
//
// Start the WDT
//
WDTimerEnable();
ulTemp = xHWREG(WDT_WTCR);
//
// Enter power down mode
//
SysCtlSleep();
SysCtlDelay(200);
ulTemp = xHWREG(WDT_WTCR);
TestAssert(WDT_WTCR_WTWKF == (ulTemp & WDT_WTCR_WTWKF), "WDT API error!");
}
//*****************************************************************************
//
//! \brief xrtc004 test for rtc interrupt.
//!
//! \return None.
//
//*****************************************************************************
static void xrtc004Execute_Int()
{
RTCTimeInit();
tTime2.ulSecond = 40;
tTime2.ulMinute = 20;
tTime2.ulHour = 17;
tTime2.ulMDay = 11;
tTime2.ulMonth = 8;
tTime2.ulYear = 2011;
tTime2.ulWDay = 4;
tTime2.ulFormat = RTC_TIME_24H;
//
// Writes current time to corresponding register.
//
RTCTimeWrite(&tTime2, ulTimeAlarm[0]);
//
// Alarm interrupt after 10 seconds.
//
tTime2.ulSecond +=10;
//
// Writes current time to corresponding register.
//
RTCTimeWrite(&tTime2, ulTimeAlarm[1]);
for(ulj = 0; ulj < 0xffff; ulj ++);
xRTCTimeRead(&tTime1, ulTimeAlarm[1]);
TestAssert(2011 == tTime1.ulYear && 8 == tTime1.ulMonth
&& 11 == tTime1.ulMDay && RTC_TIME_24H == tTime1.ulFormat
&& 17 == tTime1.ulHour && 20 == tTime1.ulMinute
&& 50 == tTime1.ulSecond,
"xrtc API \" RTCTimeWrite()\" or \"xRTCTimeRead()\" error!");
//
// Enables alarm interrupt.
//
RTCIntCallbackInit(RTC_INT_ALARM, xRTCACallback);
RTCIntEnable(RTC_INT_ALARM);
xIntEnable(INT_RTCA);
xIntMasterEnable();
RTCStart();
TestAssertQBreak("a","Alarm interrupt failed!", 0xffffffff);
for(ulj = 0; ulj < 0xffff; ulj ++);
TestAssert(2011 == tTime1.ulYear && 8 == tTime1.ulMonth
&& 11 == tTime1.ulMDay && RTC_TIME_24H == tTime1.ulFormat
&& 17 == tTime1.ulHour && 20 == tTime1.ulMinute
&& 50 == tTime1.ulSecond ,
"xrtc API \" RTCTimeWrite()\" or \"xRTCTimeRead()\" error!");
//
// Disables alarm interrupt.
//
RTCIntDisable(RTC_INT_ALARM);
//
// Enables seconds interrupt.
//
RTCIntCallbackInit(RTC_INT_TIME_TICK, xRTCSCallback);
RTCIntEnable(RTC_INT_TIME_TICK);
xIntEnable(INT_RTCS);
RTCStart();
TestAssertQBreak("b","Tick interrupt failed!",0xffffffff);
//
// Disables seconds interrupt.
//
RTCIntDisable(RTC_INT_TIME_TICK);
}
