//***************************************************************************** // //! \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]); } }
//***************************************************************************** // //! \brief The example of the function of read and write. //! //! \param None //! //! \details The example of the function of read and write. //! \return None. // //***************************************************************************** void M24CxxReadWrite(void) { unsigned long i; xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ); UartInit(); HT24CxxInit(); UartPrintfChar('\r'); UartPrintfChar('\n'); // // write data to M24Cxx // HT24CxxBufferWrite(ucWriteData, WriteAddress, Length); // // Read data from M24Cxx // HT24CxxBufferRead(ucReadData, WriteAddress, Length); for(i = 0; i < Length; i++) { UartPrintfChar(ucReadData[i]); } }
//***************************************************************************** // //! \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]); } }
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 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 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 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); } }
void main(void) { //Set System clock to 72MHz xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ); SysCtlDelay(10000); xSysCtlPeripheralEnable2(I2C1_BASE); xSysCtlPeripheralEnable2(xGPIO_PORTB_BASE); //Map I2C1 Pin //SCK --> PB6 //SDA --> PB7 xSPinTypeI2C(I2C1SCK, PB6); xSPinTypeI2C(I2C1SDA, PB7); //Initialize I2C Module 100K I2CInit(I2C1_BASE, 100000); I2CEnable(I2C1_BASE); //Enable ADXL345 Measure Function I2CMasterWriteS1(I2C1_BASE, I2C_SLAVE_ADDR, 0x2D, xfalse); I2CMasterWriteS2(I2C1_BASE, 0x08, xtrue); SysCtlDelay(100000); //Read Accelerometer XYZ data in continue mode I2CMasterWriteS1(I2C1_BASE, I2C_SLAVE_ADDR, 0x32, xfalse); I2CMasterReadBufS1(I2C1_BASE, I2C_SLAVE_ADDR, RecvBuf, 6, xtrue); while(1); }
//***************************************************************************** // //! \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); }
//***************************************************************************** // //! \brief something should do before the test execute of VS1838B test. //! //! \return None. // //***************************************************************************** static void VS1838BSetup(void) { // // Set SysClk 72MHz using Extern 8M oscillator // xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN|xSYSCTL_XTAL_8MHZ); IRInit(); }
static void SysInit(void) { // Close watchdog (*((volatile unsigned long *)(0x40048100))) = 0x00; // Configure System clock xSysCtlClockSet(F_CLK, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ); SysCtlDelay(100*TICK_1MS); }
//***************************************************************************** // //! 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 di_adt75001 test. //! //! \return None. // //***************************************************************************** static void adt75001Setup(void) { // //Set the external 12MHZ clock as system clock // xSysCtlClockSet(12000000, xSYSCTL_XTAL_12MHZ | xSYSCTL_OSC_MAIN); ADT75Init(500, ADT75_POWER_SHOTDOWN); }
//***************************************************************************** // //! \brief something should do before the test execute of AT25FS0x test. //! //! \return None. // //***************************************************************************** static void AT25FS0xSetup(void) { unsigned long i; // // Set SysClk 50MHz using Extern 12M oscillator // xSysCtlClockSet(50000000, xSYSCTL_OSC_MAIN|xSYSCTL_XTAL_12MHZ); AT25FS0xInit(2000000); for(i=0;i<Length;i++) { ucWriteData[i] = (unsigned char)(i); } }
//***************************************************************************** // //! \brief something should do before the test execute of di_ad7417arz001 test. //! //! \return None. // //***************************************************************************** static void di_ad7417arz001Setup(void) { // //Set the external 12MHZ clock as system clock // xSysCtlClockSet(12000000, xSYSCTL_XTAL_12MHZ | xSYSCTL_OSC_MAIN); // // AD7417 device init // AD7417Init(10000, AD7417_POWER_NORMAL | AD7417_TRIGGER_DISABLE); UART0Configuration(); }
//***************************************************************************** // //! \brief something should do before the test execute of AT45DB161 test. //! //! \return None. // //***************************************************************************** static void AT45DB161Setup(void) { unsigned long i; // // Set SysClk 50MHz using Extern 12M oscillator // xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN|xSYSCTL_XTAL_8MHZ); for(i=0; i<Length; i++) { ucWriteData[i] = (unsigned char)(i); } AT45DB161_Init(16000000); }
//***************************************************************************** // //! \brief The example of the function of Dispaly. //! //! \param None //! //! \details The example of the function of Dispaly. //! \return None. // //***************************************************************************** void UC1601DispalyExample(void) { // // Set SysClk 50MHz using Extern 12M oscillator // xSysCtlClockSet(50000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_12MHZ); UC1601Init(1500000); UC1601Clear(); UC1601CharDispaly(0, 0, "I love google?"); UC1601CharDispaly(1, 0, "Yes,I love!"); UC1601ChineseDispaly(3, 0, 4, (char *)&HZ); HD44780DisplayN(2,0,5201314); xSysCtlDelay(1000000); }
//***************************************************************************** // //! \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 something should do before the test execute of xspi001 test. //! //! \return None. // //***************************************************************************** static void xSpi004Setup(void) { // // Set SysClk 8MHz using Extern 8M oscillator // xSysCtlClockSet(8000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ); // // Enable Peripheral SPI0 // SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI0); SysCtlPeripheralEnable(SYSCTL_PERIPH_AFIO); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); }
int main() { xSysCtlClockSet(72000000, (xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ)); AMSDCMotorPWMInit(AMS_MOTOR_B, 100000, 50); AMSDCMotorPWMInit(AMS_MOTOR_A, 100000, 50); AMSDCMotorRun(AMS_MOTOR_B, AMS_RUN_FORWARD); // AMSStepMotorInit(); // AMSStepMotorRun(AMS_RUN_FORWARD, 100); while(1); }
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); } } } }
// Digital Compass int main(void) { uint8_t Res; int16_t Com_Data[3]; uint16_t x0, y0; unsigned long angle = 0; double radian; /* Setup the microcontroller system. Initialize the Embedded Flash Interface, initialize the PLL and update the SystemFrequency variable. */ xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ); xSysCtlDelay(10000); delay_init(72); Lcd_Init(); HMC5883L_Init(); HMC5883L_Cfg(MODE_SIG | GAIN_1090 | SAMPLE_8 | DATA_RATE_15); Lcd_Clear(GRAY0); // Gui_Circle(64, 80, 50, BLUE); Gui_DrawFont_GBK16(64,14,BLUE,GRAY0,"N"); Gui_DrawFont_GBK16(64,132,BLUE,GRAY0,"S"); Gui_DrawFont_GBK16(5,80,BLUE,GRAY0,"W"); Gui_DrawFont_GBK16(116,80,BLUE,GRAY0,"E"); while(1){ Res = HMC5883L_DataGet(&Com_Data[0], &Com_Data[1], &Com_Data[2]); if(Res) break; angle = (unsigned long) (atan2((double)Com_Data[0],(double)Com_Data[1])*(180/3.14159265)+180); //angle = rand()%360; radian = angle * 3.1415926 / 180; if(angle <= 180){ x0 = 64 + (int16_t)(40 * sin(radian)); y0 = 80 - (int16_t)(40 * cos(radian)); } else { x0 = 64 + (int16_t)(40 * sin(radian)); y0 = 80 - (int16_t)(40 * cos(radian)); } Gui_DrawLine(64, 80, x0, y0, BLUE); delay_ms(500); Gui_DrawLine(64, 80, x0, y0, GRAY0); } return 0; }
//***************************************************************************** // //! The main function of the adt75 one-shot mode. // //! return none // //***************************************************************************** void TemperatureGet(void) { long lTemp; // //Set the external 12MHZ clock as system clock // xSysCtlClockSet(12000000, xSYSCTL_XTAL_12MHZ | xSYSCTL_OSC_MAIN); ADT75Init(10000, ADT75_POWER_NORMAL); // // OS Int mode configure // ADT75IntModeConfig(ADT75_OPEMODE_CMP); // // OS pin active level is low, a pull-up register should add on this pin. // ADT75OSActiveLevelConfig(ADT75_OSALERT_LEVEL_LOW); // // Set the Faultqueue is 1 // ADT75FaultQueueConfig(ADT75_FAULTQUE_1); // // Enable the one-shot mode // ADT75OneShotEnable(); // // Configure the setpoint register // ADT75LowLimitSetLong(25); ADT75UpLimitSetLong(28); while(1) { ADT75OneShotConvst(); lTemp = ADT75TempReadLDC(); } }
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)); }
//***************************************************************************** // //! The function is to set the i2c slave receive with poll mode // //! return none // //***************************************************************************** void SlaveReceivePoll(void) { // // Set system clock // xSysCtlClockSet(12000000, xSYSCTL_XTAL_12MHZ | xSYSCTL_OSC_MAIN); // // Congigure the i2c pin // xSPinTypeI2C(I2C0SCK, PD5); xSPinTypeI2C(I2C0SDA, PD4); // // Enable the i2c peripheral // xSysCtlPeripheralEnable(xSYSCTL_PERIPH_I2C0); // // Init the I2C as slave // xI2CSlaveInit(I2C0_BASE, SlaveAddress, I2C_GENERAL_CALL_DIS); WriteBuf[8] = '\0'; // // I2C master transfer config // I2CSlaveRcCfg.pvWBuf = WriteBuf; I2CSlaveRcCfg.ulWLen = WriteLength; I2CSlaveRcCfg.ulWCount = 0; I2CSlaveRcCfg.pvRBuf = ReceiveBuf; I2CSlaveRcCfg.ulRLen = ReceiveLength; I2CSlaveRcCfg.ulRCount = 0; xI2CIntCallbackInit(I2C0_BASE, SlavaRecvFunc); // // I2C salve receive wiht polling mode // xI2CSlaveTransfer(I2C0_BASE, &I2CSlaveRcCfg, xI2C_TRANSFER_POLLING); }
//***************************************************************************** // //! \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); }
//show clock int main() { /* Setup the microcontroller system. Initialize the Embedded Flash Interface, initialize the PLL and update the SystemFrequency variable. */ xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ); xSysCtlDelay(10000); delay_init(72); Lcd_Init(); Lcd_Clear(GRAY0); Gui_DrawFont_GBK16(30,50,BLUE,GRAY0,"Show Clock"); Gui_DrawFont_GBK16(36,70,BLUE,GRAY0,"@ CooCox"); delay_ms(2000); Lcd_Clear(GRAY0); while(1){ Show_Clock(); } }
//***************************************************************************** // //! \brief something should do before the test execute of xTimer002 test. //! //! \return None. // //***************************************************************************** static void xTimer002Setup(void) { int i; // //Set the external 8MHZ clock as system clock // xSysCtlClockSet(8000000, xSYSCTL_XTAL_8MHZ | xSYSCTL_OSC_MAIN); // // Enable the tiemr0-3 peripheral // for(i = 0; i < 2; i++) { xSysCtlPeripheralEnable(ulTimerID[i]); } }
//***************************************************************************** // //! \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); }
////////////////////////////////////////////////////////////////////////////// // 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)); }