int main() { GPIO_InitTypeDef GPIO_InitStructure; ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_OCInitTypeDef TIM_OCInitStructure; DMA_InitTypeDef DMA_InitStructure; uint16_t PrescalerValue; LED_Init(); LED_R_ON(); LLIO_Init(115200); printf("\r\nPWM dimming\r\n"); /* Enable ADC, GPIO, Timer, DMA clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); /* DMA2 Channel0(ADC) configuration */ DMA_InitStructure.DMA_Channel = DMA_Channel_0; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)ADC1_DR_Address; // source DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)TIM3_CCR1_Address; // destination DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; DMA_InitStructure.DMA_BufferSize = 1; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA2_Stream0, &DMA_InitStructure); DMA_Cmd(DMA2_Stream0, ENABLE); /* TIM3_CH1(PB4-LED) configuration */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_TIM3); /* ADC Common Init */ ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent; ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div4; // ADC clock = PCLK2/prescaler. ADC freq = typical 30MHz, Max 36MHz. PCLK2 = 168/2=84MHz. ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled; ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles; ADC_CommonInit(&ADC_CommonInitStructure); /* ADC channel 10 (PC0) configuration */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOC, &GPIO_InitStructure); /* ADC channel configuration */ ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b; ADC_InitStructure.ADC_ScanConvMode = DISABLE; ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_Rising; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T3_TRGO; // TIM3의 트리거 발생시 ADC 수행 ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfConversion = 1; ADC_Init(ADC1, &ADC_InitStructure); /* ADC1 regular channel10 configuration */ ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_3Cycles); /* Enable ADC1 DMA */ ADC_DMACmd(ADC1, ENABLE); /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /* Enable DMA request after last transfer (Single-ADC mode) */ ADC_DMARequestAfterLastTransferCmd(ADC1, ENABLE); /* Compute the prescaler value */ SystemCoreClockUpdate(); PrescalerValue = (uint16_t) (SystemCoreClock / 2 / TIMER_PRESCALER_FREQ) - 1; // timer base counter에 1MHz 입력 /* Time base configuration */ TIM_TimeBaseStructure.TIM_Period = PWM_WIDTH - 1; TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); // TIM3 update 이벤트에서 트리거 발생하도록 설정 -> ADC trigger로 사용 TIM_SelectOutputTrigger(TIM3, TIM_TRGOSource_Update); TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse = DUTY_IDLE; // default 50% TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC1Init(TIM3, &TIM_OCInitStructure); TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable); /* TIM3 enable counter */ TIM_Cmd(TIM3, ENABLE); while(1) { __WFI(); } }
/** * application main entry point */ int main(void) { int n=0; int button = 0; int oldButton = 0; int targetBlocking = 0; //!< debounce SysTicker target time volatile int exercisePart=3; int timestart=0; int timestop=0; volatile int time=0; SystemCoreClockUpdate(); SysTick_Config(SystemCoreClock/1000); /* Generate interrupt each 1 ms */ RCC_GetClocksFreq(&clocks); RCC_Configuration(); GPIO_Configuration(); printf("Debug printf starting with GPIO\n\n"); while(1) { button = GPIOC->IDR & (1 << 13); switch (exercisePart) { case 0: if (!oldButton && button && (ticks > targetBlocking)) { n++; targetBlocking = ticks + 500; GPIOA->ODR ^= (1 << 5); //! toggle bit #5 which is the LED printf("pressed %d\n",n); } oldButton = button; break; case 1: timestart = ticks; printf("12345678901234567890\n"); timestop = ticks; time=timestop-timestart; // Debuger shows less than 1 ms break; case 2: timestart = ticks; printf("Global Time: %u",msTic); timestop = ticks; time=timestop-timestart; // Debuger shows approx 1ms break; case 3: if (!oldButton && button ) { time=ticks-timestop; timestop=ticks; } oldButton = button; break; default: __NOP; } } }
/** * @brief requests System clock frequency * * @note This function should be used only after reset. * @param None * @retval None */ uint32_t SysCtlClockGet(void) { SystemCoreClockUpdate(); return SystemCoreClock; }
/** * @brief Main program. * @param None * @retval None */ int main(void) { int i = 0, j = 0; int addr; //usb atjungimo kintamasis bool usbDisabled = true; //adc variables float *result; char mockResult[600]; char UARTTxPacket[100]; static short ultrasoundPacketTxMultiplier = 0; static int ULTRASOUND_PACKET_COUNT = 100; //usart state machine switch uartSwitch = 'r'; //USB buffer variables uint8_t buf[255],outstrg[100],inchar; uint8_t len; //dac variables uint16_t waveform[32]; uint8_t continueReading = 1; uint8_t intCount = 0; uint8_t charCount = 0; bool bufferReadSuccessful = false; char tempString[4]; int cs; volatile float a,b,elapsedtime,angle,radius,angleinc; RCC_ClocksTypeDef RCC_Clocks; // Initialize System and Setup clocks. SystemInit(); SystemCoreClockUpdate(); //ini ADC adcConfigure(); //init USART USARTInit(); USART_puts(USART2, "P_Cmd\n\n"); //USARTSendByte(); //USARTReadByte(); /* SysTick end of count event each 40ms */ RCC_GetClocksFreq(&RCC_Clocks); //SysTick_Config(RCC_Clocks.HCLK_Frequency /100); // Initialize FPU *((volatile unsigned long*)0xE000ED88) = 0xF << 20; // Initialize LEDs and User_Button on STM32F4-Discovery STM_EVAL_LEDInit(LED4); STM_EVAL_LEDInit(LED3); STM_EVAL_LEDInit(LED5); STM_EVAL_LEDInit(LED6); if(!usbDisabled){ // USB Device Initialize USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, &USR_cb); // Wait for USB connection goes live while (!gbUsbDeviceReady); // Clean USB RX buffer while(VCP_get_string(&buf[0]) == 0); // Output signon printf("USB serial DEMO\r\n"); printf("test\n\r>"); } // Main loop while(1) { //SPI (WITH MSP) STATE MACHINE if(uartSwitchGet() != 'r') switch(uartSwitchGet()){ case 't': //cmd tx packet for (i=0;i<600;i++) mockResult[i] = i; for(i=0;i<100;i++) UARTTxPacket[i] = mockResult[i+ultrasoundPacketTxMultiplier]; txDataArrayToMsp(UARTTxPacket); uartSwitchSet('r'); break; case 'e': //Delay(1000); USART_puts(USART2, "P_End\n\n"); ultrasoundPacketTxMultiplier = 0; uartSwitchSet('r'); break; case 'c': //cmd_packet_received_msg. ultrasoundPacketTxMultiplier++; if (ultrasoundPacketTxMultiplier >= 10) uartSwitchSet('e'); //finish transmission, or... else uartSwitchSet('r'); // prepare for the next packet break; default: break; } if(!usbDisabled){ //USB COMM STATE MACHINE inchar = GetCharnw(); if(inchar) { switch (inchar){ case 'a': result = adcConvert(); float* k; uint16_t j; //for (j=0;j<250;j++){ for(k=result;k<result+10/*28000*/;k++){ printf("%f \n",*k); } // } break; case 'd': intCount = charCount = bufferReadSuccessful = 0; while(continueReading){ for(i=0;i<rxbuflen;i++){ if(inbuf[i]!='d' && inbuf[i]!='e' && inbuf[i]!=' ' && continueReading == true){ tempString[charCount]=inbuf[i]; charCount++; if(charCount==4){ waveform[intCount] = 0; for(j=0;j<4;j++) waveform[intCount] += (int)(tempString[j]-'0')*pow(10,3-j); intCount++; charCount = 0; } } if(inbuf[i]=='e'||intCount == 32) { continueReading = 0; bufferReadSuccessful = true;} } rxbuflen = 0; char inchar = GetCharnw(); } if(bufferReadSuccessful)DAC_SignalsGenerate(&waveform); break; case 's': printf("\n\rF4 Discovery Test V0.55\n\r>"); break; case 't': printf("\n\rDo 10000 circular interpolation calculations\n\r"); TimingDelay4 = 10000; angle = 0.125; radius = 2.56; angleinc = 0.0001; for(i=0; i<100000; i++) { a = radius * sinf(angle); b = radius * cosf(angle); angle += angleinc; } elapsedtime = ((float)(10000 - TimingDelay4))/25.0; printf("timing delay=%d\n\r",TimingDelay4); printf("Single precision finished in %f seconds or %f usec/loop\n\r",elapsedtime,elapsedtime*10.0); TimingDelay4 = 10000; angle = 0.125; radius = 2.56; angleinc = 0.0001; for(i=0; i<100000; i++) { a = radius * sinfp(angle); b = radius * cosfp(angle); angle += angleinc; } elapsedtime = ((float)(10000 - TimingDelay4))/25.0; printf("timing delay=%d\n\r",TimingDelay4); printf("Single prec fp finished in %f seconds or %f usec/loop\n\r",elapsedtime,elapsedtime*10.0); TimingDelay4 = 10000; angle = 0.125; radius = 2.56; angleinc = 0.0001; printf("angle=%f radius=%f angleinc=%f\n\r",angle,radius,angleinc); for(i=0; i<100000; i++) { a = radius * sin(angle); b = radius * cos(angle); angle += angleinc; } printf("timing delay=%d\n\r",TimingDelay4); elapsedtime = ((float)(10000 - TimingDelay4))/25.0; printf("Double precision finished in %f seconds or %f usec/loop\n\r>",elapsedtime,elapsedtime*10.0); break; case 'f': printf("f\n\rTry float output: 1.234\n\r"); a = 1.234; printf("a = %f\n\r",a); i = 35; printf("i = %d\n\r",i); a = 35.45; printf("a = %f\n\r",a); printf("a = %f\n\r",12.345); printf("a = %f\n\r",-12.345); printf("i = %d\n\r",i); break; case 'g': printf("d\n\rRCC_Clocks.HCLK_Frequency=%ld",RCC_Clocks.HCLK_Frequency); printf("\n\rDelay 2 second\n\r"); Delay(200); printf("finished\n\r>"); break; case CR: printf("\n\r>"); break; default: printf("%c\n\r>",inchar); break; } } } if (i == 0x100000) { STM_EVAL_LEDOff(LED4); STM_EVAL_LEDOff(LED3); STM_EVAL_LEDOff(LED5); STM_EVAL_LEDOff(LED6); } if (i++ == 0x200000) { i = 0; STM_EVAL_LEDOn(LED4); STM_EVAL_LEDOn(LED3); STM_EVAL_LEDOn(LED5); STM_EVAL_LEDOn(LED6); } } }
/** * @brief This function get CPU frequency. The frequency unit is Hz. * @return CPU frequency */ uint32_t CLK_GetCPUFreq(void) { SystemCoreClockUpdate(); return SystemCoreClock; }
void SystemInit (void) { SystemCoreClockUpdate(); }
void sysclk_init(void) { /* Set flash wait state to max in case the below clock switching. */ system_init_flash(CHIP_FREQ_CPU_MAX); /* Config system clock setting */ if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_SLCK_RC) { osc_enable(OSC_SLCK_32K_RC); osc_wait_ready(OSC_SLCK_32K_RC); pmc_switch_mck_to_sclk(CONFIG_SYSCLK_PRES); } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_SLCK_XTAL) { osc_enable(OSC_SLCK_32K_XTAL); osc_wait_ready(OSC_SLCK_32K_XTAL); pmc_switch_mck_to_sclk(CONFIG_SYSCLK_PRES); } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_SLCK_BYPASS) { osc_enable(OSC_SLCK_32K_BYPASS); osc_wait_ready(OSC_SLCK_32K_BYPASS); pmc_switch_mck_to_sclk(CONFIG_SYSCLK_PRES); } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_MAINCK_4M_RC) { /* Already running from SYSCLK_SRC_MAINCK_4M_RC */ } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_MAINCK_8M_RC) { osc_enable(OSC_MAINCK_8M_RC); osc_wait_ready(OSC_MAINCK_8M_RC); pmc_switch_mck_to_mainck(CONFIG_SYSCLK_PRES); } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_MAINCK_12M_RC) { osc_enable(OSC_MAINCK_12M_RC); osc_wait_ready(OSC_MAINCK_12M_RC); pmc_switch_mck_to_mainck(CONFIG_SYSCLK_PRES); } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_MAINCK_XTAL) { osc_enable(OSC_MAINCK_XTAL); osc_wait_ready(OSC_MAINCK_XTAL); pmc_switch_mck_to_mainck(CONFIG_SYSCLK_PRES); } else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_MAINCK_BYPASS) { osc_enable(OSC_MAINCK_BYPASS); osc_wait_ready(OSC_MAINCK_BYPASS); pmc_switch_mck_to_mainck(CONFIG_SYSCLK_PRES); } #ifdef CONFIG_PLL0_SOURCE else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_PLLACK) { struct pll_config pllcfg; pll_enable_source(CONFIG_PLL0_SOURCE); pll_config_defaults(&pllcfg, 0); pll_enable(&pllcfg, 0); pll_wait_for_lock(0); pmc_switch_mck_to_pllack(CONFIG_SYSCLK_PRES); } #endif #ifdef CONFIG_PLL1_SOURCE else if (CONFIG_SYSCLK_SOURCE == SYSCLK_SRC_PLLBCK) { struct pll_config pllcfg; pll_enable_source(CONFIG_PLL1_SOURCE); pll_config_defaults(&pllcfg, 1); pll_enable(&pllcfg, 1); pll_wait_for_lock(1); pmc_switch_mck_to_pllbck(CONFIG_SYSCLK_PRES); } #endif /* Update the SystemFrequency variable */ SystemCoreClockUpdate(); /* Set a flash wait state depending on the new cpu frequency */ system_init_flash(sysclk_get_cpu_hz()); #if (defined CONFIG_SYSCLK_DEFAULT_RETURNS_SLOW_OSC) /* Signal that the internal frequencies are setup */ sysclk_initialized = 1; #endif #ifdef CONFIG_CPCLK_ENABLE /* Enable coprocessor clock */ sysclk_configure_cpclk(); #endif }
// Initialize the system tick void InitSystick(void){ SystemCoreClockUpdate(); if (SysTick_Config(SystemCoreClock / 1000)) { while (1); } }
/** * @brief Main UART/DMA program body * @return Does not exit */ int main(void) { int bytes = 0, idx; uint8_t buff[UARTRXBUFFSIZE]; SystemCoreClockUpdate(); Board_Init(); Init_UART_PinMux(); Board_LED_Set(0, false); #if defined(USE_INTEGER_CLOCK) /* Use main clock rate as base for UART baud rate divider */ Chip_Clock_SetUARTBaseClockRate(Chip_Clock_GetMainClockRate(), false); #else /* Use 128x expected UART baud rate for fractional baud mode. */ Chip_Clock_SetUARTBaseClockRate((115200 * 128), true); #endif /* Setup UART */ Chip_UART_Init(LPC_USART0); Chip_UART_ConfigData(LPC_USART0, UART_CFG_DATALEN_8 | UART_CFG_PARITY_NONE | UART_CFG_STOPLEN_1); Chip_UART_SetBaud(LPC_USART0, 115200); /* Optional for low clock rates only: Chip_UART_SetBaudWithRTC32K(LPC_USART, 300); */ Chip_UART_Enable(LPC_USART0); Chip_UART_TXEnable(LPC_USART0); /* DMA initialization - enable DMA clocking and reset DMA if needed */ Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_DMA); Chip_SYSCTL_PeriphReset(RESET_DMA); /* Initialize ROM API pointer */ pDMAApi = LPC_DMAD_API; size_in_bytes = pDMAApi->dma_get_mem_size(); if (size_in_bytes > RAMBLOCK) { /* Adjust RAMBLOCK size in this case */ return 1; } /* Setup DMA ROM driver, provided RAM blocks for DMA Handle */ dma_handle = pDMAApi->dma_setup(LPC_DMA_BASE, dma_ram_block); /* Init UART 0 TX descriptor */ countTXDescUsed = 0; /* Enable the DMA IRQ */ NVIC_EnableIRQ(DMA_IRQn); /* Enqueue a bunch of strings in DMA transmit descriptors and start transmit. In this use of DMA, the descriptors aren't chained, so the DMA restarts the next queued descriptor in the DMA interrupt handler. */ for (idx = 0; idx < DMASENDSTRCNT; idx++) { sprintf(dmaSendStr[idx], "DMA send string (unlinked) #%d\r\n", idx); dmaTXSend((uint8_t *) dmaSendStr[idx], strlen(dmaSendStr[idx])); } /* Wait for UART TX DMA channel to go inactive */ while (1) { __WFI(); if (countTXDescUsed == 0) { break; } } /* Receive buffers are queued. The DMA interrupt will only trigger on a full DMA buffer receive, so if the UART is idle, but the DMA is only partially complete, the DMA interrupt won't fire. For UART data receive where data is not continuous, a timeout method will be required to flush the DMA when the DMA has pending data and no data has been received on the UART in a specified timeout */ dmaRXQueue(); /* Get RX data via DMA and send it out on TX via DMA */ while (1) { /* Sleep until something happens */ __WFI(); /* Did any data come in? */ bytes = checkRxData(buff); if (bytes > 0) { /* RX data received, send it via TX DMA */ dmaTXSend(buff, bytes); } } return 1; }
int main() { initialize_stk(); /* Chip errata */ CHIP_Init(); /* Ensure core frequency has been updated */ SystemCoreClockUpdate(); IO_Init(); UART1->ROUTE = UART_ROUTE_LOCATION_LOC3 | UART_ROUTE_TXPEN | UART_ROUTE_RXPEN; static const uint32_t baud = 9600; static const uint32_t ovs = 16; static const uint32_t refclk = 14060000; UART1->CLKDIV = (256 * refclk) / ((ovs * baud) - 1); UART1->CMD = UART_CMD_TXEN | UART_CMD_RXEN; UART1->IEN = UART_IEN_RXDATAV; //TIMER_IntClear(TIMER0, TIMER_IF_OF); //InitRGBLEDPWM(); //TIMER_IntClear(TIMER0, TIMER_IF_OF); clockAppDisplay(); float time0 = atoi(&displayStringBuf); for (;;){ clockAppDisplay(); float time1 = atoi(&displayStringBuf); if(time1-time0>=1){ printf("%.3f",time1); printf(" "); printf("%.4f",5556.5404+(distance*SPEEDLAT)); printf(" "); printf("%0010.4f",311.4366+(distance*SPEEDLONG)); printf("\n"); if((distancef < DIS1 && fw) || STRAIGHT){ distanceb=0; distance+=FINC; distancef+=FINC; } else{ fw =0; distancef=0; distance-=BINC; distanceb+=BINC; if (distanceb >= DIS2){ fw = 1; } } time0 = time1; } } }
/** * @brief main routine for ADC example * @return Function should not exit */ int main(void) { SystemCoreClockUpdate(); Board_Init(); DEBUGSTR("ADC ROM sequencer demo\r\n"); /* Power up, enable clock and reset ADC0 */ Chip_SYSCTL_PowerUp(SYSCTL_POWERDOWN_ADC0_PD); Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_ADC0); Chip_SYSCTL_PeriphReset(RESET_ADC0); /* Power up, enable clock and reset ADC1 */ Chip_SYSCTL_PowerUp(SYSCTL_POWERDOWN_ADC1_PD); Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_ADC1); Chip_SYSCTL_PeriphReset(RESET_ADC1); /* Power up the internal temperature sensor */ Chip_SYSCTL_PowerUp(SYSCTL_POWERDOWN_TS_PD); #if defined(BOARD_NXP_LPCXPRESSO_1549) /* Disables pullups/pulldowns and disable digital mode */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 9, (IOCON_MODE_INACT | IOCON_ADMODE_EN)); /* Assign ADC1_1 to PIO0_9 via SWM (fixed pin) */ Chip_SWM_EnableFixedPin(SWM_FIXED_ADC1_1); #else #warning "No ADC setup for this example" #endif /* Initialize ROM API base address for ADC */ pAdcApi = LPC_ADCD_API; size_in_bytes = pAdcApi->adc_get_mem_size(); if (size_in_bytes / 4 > RAMBLOCK_H) { /* Adjust RAMBLOCK size in this case */ return 1; } /* ADC Handle Setup*/ adc_handle[0] = pAdcApi->adc_setup(LPC_ADC0_BASE, (uint8_t *) start_of_ram_block[0]); adc_handle[1] = pAdcApi->adc_setup(LPC_ADC1_BASE, (uint8_t *) start_of_ram_block[1]); /* ADC0 Config */ adc_cfg[0].system_clock = SystemCoreClock; /* System clock */ adc_cfg[0].adc_clock = 500000; /* ADC clock set to 500KHz for calibration*/ /* ADC1 Config */ adc_cfg[1].system_clock = SystemCoreClock; /* System clock */ adc_cfg[1].adc_clock = 500000; /* ADC clock set to 500KHz for calibration*/ pAdcApi->adc_calibration(adc_handle[0], &adc_cfg[0]); pAdcApi->adc_calibration(adc_handle[1], &adc_cfg[1]); /* ADC0 Config for Init */ adc_cfg[0].system_clock = SystemCoreClock; /* System clock */ adc_cfg[0].adc_clock = ADC_CLOCK_RATE; /* ADC clock */ adc_cfg[0].async_mode = 0; /* Synchronous mode */ adc_cfg[0].tenbit_mode = 0; /* 12 Bit ADC mode */ adc_cfg[0].lpwr_mode = 0; /* Disable low power mode */ adc_cfg[0].input_sel = ADC_INSEL_TS; adc_cfg[0].seqa_ctrl = (ADC_SEQ_CTRL_CHANSEL(0) | ADC_SEQ_CTRL_MODE_EOS); adc_cfg[0].channel_num = 1; /* Channel number is one higher than the maximum channel number used */ /* ADC1 Config for Init */ adc_cfg[1].system_clock = SystemCoreClock; /* System clock */ adc_cfg[1].adc_clock = ADC_CLOCK_RATE; /* ADC clock */ adc_cfg[1].async_mode = 0; /* Synchronous mode */ adc_cfg[1].tenbit_mode = 0; /* 12 Bit ADC mode */ adc_cfg[1].lpwr_mode = 0; /* Disable low power mode */ adc_cfg[1].seqa_ctrl = (ADC_SEQ_CTRL_CHANSEL(BOARD_ADC_CH) | ADC_SEQ_CTRL_MODE_EOS); adc_cfg[1].thrsel = 0; adc_cfg[1].thr0_low = ((1 * 0xFFF) / 4) << 4; adc_cfg[1].thr0_high = ((3 * 0xFFF) / 4) << 4; adc_cfg[1].thcmp_en = ADC_INTEN_CMP_ENABLE(ADC_INTEN_CMP_CROSSTH, BOARD_ADC_CH); adc_cfg[1].channel_num = BOARD_ADC_CH + 1; /* Channel number is one higher than the maximum channel number used */ pAdcApi->adc_init(adc_handle[0], &adc_cfg[0]); pAdcApi->adc_init(adc_handle[1], &adc_cfg[1]); /* When using ADC ROM API's lower the priority of ADC Sequence completion interrupt when compared to the threshold interrupt*/ NVIC_SetPriority(ADC1_SEQA_IRQn, 1); /* Enable related ADC NVIC interrupts */ NVIC_EnableIRQ(ADC0_SEQA_IRQn); NVIC_EnableIRQ(ADC1_SEQA_IRQn); NVIC_EnableIRQ(ADC1_THCMP); /* This example uses the periodic sysTick to manually trigger the ADC, but a periodic timer can be used in a match configuration to start an ADC sequence without software intervention. */ SysTick_Config(Chip_Clock_GetSysTickClockRate() / TICKRATE_HZ); /* Endless loop */ while (1) { /* Sleep until something happens */ __WFI(); if (threshold1Crossed) { threshold1Crossed = false; DEBUGSTR("********ADC1 threshold event********\r\n"); } /* Is a conversion sequence complete? */ if (sequence0Complete) { sequence0Complete = false; showValudeADC(LPC_ADC0); } if (sequence1Complete) { sequence1Complete = false; showValudeADC(LPC_ADC1); } } /* Should not run to here */ return 0; }
/** * @brief Main entry point * @return Nothing */ int main(void) { SystemCoreClockUpdate(); Board_Init(); setupClock(); SystemCoreClockUpdate(); On = true; enableOut = false; controlFlag = false; Board_LED_Set(0, On); DEBUGOUT("Starting\n"); /* Initialize RITimer */ Chip_RIT_Init(LPC_RITIMER); LPC_IOCON->PINSEL[4] |= 0x00000555; //Change this after you know which pwm outputs are needed. LPC_IOCON->PINMODE[3] |= (3 << 6); LPC_IOCON->PINMODE[3] |= (3 << 12); LPC_IOCON->PINSEL[1] |= (1 << 14); LPC_IOCON->PINSEL[1] |= (1 << 16); LPC_IOCON->PINSEL[1] |= (1 << 18); LPC_IOCON->PINSEL[1] |= (1 << 20); LPC_IOCON->PINMODE[1] |= (2 << 14); LPC_IOCON->PINMODE[1] |= (2 << 16); LPC_IOCON->PINMODE[1] |= (2 << 18); LPC_IOCON->PINMODE[1] |= (2 << 20); LPC_SYSCTL->PCLKSEL[0] |= (1 << 12); //PCLK_PWM1 = CCLK LPC_IOCON->PINMODE[4] |= (3 << 26); LPC_SYSCTL->PCONP |= (1 << 17); //Enable clock LPC_SYSCTL->PCLKSEL[1] |= (1 << 30); //PCLKMPWM = CCLK LPC_SYSCTL->PCLKSEL[0] |= (1 << 24); Chip_PWM_Init(LPC_PWM1); LPC_PWM1->PR = 0; Chip_PWM_SetMatch(LPC_PWM1, 0, 3000); Chip_PWM_SetMatch(LPC_PWM1, 1, 1500); Chip_PWM_SetMatch(LPC_PWM1, 2, 1500); Chip_PWM_SetMatch(LPC_PWM1, 3, 1500); Chip_PWM_ResetOnMatchEnable(LPC_PWM1, 0); Chip_PWM_SetCountClockSrc(LPC_PWM1, PWM_CAPSRC_RISING_PCLK, 0); Chip_PWM_SetControlMode(LPC_PWM1, 0, PWM_SINGLE_EDGE_CONTROL_MODE, PWM_OUT_ENABLED); Chip_PWM_SetControlMode(LPC_PWM1, 1, PWM_SINGLE_EDGE_CONTROL_MODE, PWM_OUT_ENABLED); Chip_PWM_SetControlMode(LPC_PWM1, 2, PWM_SINGLE_EDGE_CONTROL_MODE, PWM_OUT_ENABLED); Chip_PWM_LatchEnable(LPC_PWM1, 0, PWM_OUT_ENABLED); Chip_PWM_LatchEnable(LPC_PWM1, 1, PWM_OUT_ENABLED); Chip_PWM_LatchEnable(LPC_PWM1, 2, PWM_OUT_ENABLED); Chip_PWM_LatchEnable(LPC_PWM1, 3, PWM_OUT_ENABLED); Chip_PWM_Enable(LPC_PWM1); Chip_PWM_Reset(LPC_PWM1); Chip_GPIO_Init(LPC_GPIO); LPC_MCPWM->CON_SET |= (1 <<3); DCACSetFreq(1074); LPC_MCPWM->DT = 12; LPC_MCPWM->INTEN_SET |= 1; LPC_MCPWM->INTF_SET |= 1; LPC_MCPWM->CON_SET |= 1; freq = 1074; NVIC_EnableIRQ(RITIMER_IRQn); Chip_ADC_Init(LPC_ADC, &ADCSetup); Chip_ADC_SetBurstCmd(LPC_ADC, DISABLE); /* Configure RIT for a 1s interrupt tick rate */ Chip_RIT_SetTimerInterval(LPC_RITIMER, TIME_INTERVAL); /* LED is toggled in interrupt handler */ vout = 0; voutOldest = 0; voutOld = 0; while (1) { if(controlFlag) { bool emergency = !Chip_GPIO_GetPinState(LPC_GPIO,2,13); emergency |= !Chip_GPIO_GetPinState(LPC_GPIO,2,13); emergency |= !Chip_GPIO_GetPinState(LPC_GPIO,2,13); emergency |= !Chip_GPIO_GetPinState(LPC_GPIO,2,13); emergency |= !Chip_GPIO_GetPinState(LPC_GPIO,2,13); emergency |= !Chip_GPIO_GetPinState(LPC_GPIO,2,13); emergency = !emergency; if(emergency) { enableOut = false; vout = 0; } else { #ifdef enableLoad enableOut = Chip_GPIO_GetPinState(LPC_GPIO,0,28); #else enableOut = true; #endif } Board_LED_Set(0, enableOut); DCDCControl(); DCACControl(); Vmeasure += readADC(VIN_PIN); Imeasure += readADC(CURRENT_PIN); times++; if(times >= delayFactor && enableOut) { DEBUGOUT("%d %d %d %d\n",readADC(VIN_PIN), readADC(VOUT_PIN), readADC(CURRENT_PIN), vout); times = 0; cycles++; if(cycles < ncycles) { #ifdef enableMPPT MPPT(Vmeasure/delayFactor, Imeasure/delayFactor); #endif Vmeasure = 0; Imeasure = 0; } else { cycles = 0; } } if(enablePrev != enableOut) { DEBUGOUT("TOGGLING %d\n",enableOut); } enablePrev = enableOut; controlFlag = false; if(emergency) return 0; } } }
// This function is called after RAM initialization and before main. void mbed_sdk_init() { // Update the SystemCoreClock variable. SystemCoreClockUpdate(); }
/*! Sets up the clock out of RESET *! */ void clock_initialise(void) { #ifdef ENABLE_CLKOUT showClocks(); #endif #if (CLOCK_MODE == CLOCK_MODE_RESET) // No clock setup #else // XTAL/EXTAL Pins // Out of reset MCG is in FEI mode // ============================================================= // Switch from FEI -> FEI/FBI/FEE/FBE // ============================================================= // Set up crystal or external clock source MCGC2 = MCGC2_BDIV_M | // BDIV = MCGC2_RANGE_M | // RANGE = 0,1,2 -> Oscillator low/high/very high clock range MCGC2_HGO_M | // HGO = 0,1 -> Oscillator low power/high gain MCGC2_EREFS_M | // EREFS = 0,1 -> Select external clock/crystal oscillator MCGC2_ERCLKEN_M | // MCGC2_EREFSTEN_M; // #if ((CLOCK_MODE == CLOCK_MODE_FEI) || (CLOCK_MODE == CLOCK_MODE_FBI) || (CLOCK_MODE == CLOCK_MODE_BLPI) ) // Transition via FBI //===================================== #define BYPASS (1) // CLKS value used while FLL locks MCGC1 = (BYPASS<<MCGC1_CLKS_BITNUM) | // CLKS = 1 -> Internal reference source while PLL locks MCGC1_RDIV_M | // FRDIV = N -> XTAL/2^n ~ 31.25 kHz MCGC1_IREFS_M | // IREFS = 0,1 -> External/Slow IRC for FLL source MCGC1_IRCLKEN_M | // IRCLKEN = 0,1 -> IRCLK disable/enable MCGC1_IREFSTEN_M; // IREFSTEN = 0,1 -> Internal reference enabled in STOP mode // Wait for S_IREFST to indicate FLL Reference has switched do { __asm__("nop"); } while ((MCGSC & MCGSC_IREFST_MASK) != (MCGC1_IREFS_V?MCGSC_IREFST_MASK:0)); // Wait for S_CLKST to indicating that OUTCLK has switched to bypass PLL/FLL do { __asm__("nop"); } while ((MCGSC & MCGSC_CLKST_MASK) != (BYPASS<<MCGSC_CLKST_BITNUM)); // Set FLL Parameters MCGC4 = (MCGC4&~(MCGC4_DMX32_MASK|MCGC4_DRST_DRS_MASK))|MCGC4_DMX32_M|MCGC4_DRS_M; #endif #if ((CLOCK_MODE == CLOCK_MODE_FBE) || (CLOCK_MODE == CLOCK_MODE_FEE) || (CLOCK_MODE == CLOCK_MODE_PLBE) || (CLOCK_MODE == CLOCK_MODE_PBE) || (CLOCK_MODE == CLOCK_MODE_PEE)) // Transition via FBE //===================================== #define BYPASS (2) // CLKS value used while PLL locks MCGC1 = (BYPASS<<MCGC1_CLKS_BITNUM) | // CLKS = 2 -> External reference source while PLL locks MCGC1_RDIV_M | // FRDIV = N -> XTAL/2^n ~ 31.25 kHz MCGC1_IREFS_M | // IREFS = 0,1 -> External/Slow IRC for FLL source MCGC1_IRCLKEN_M | // IRCLKEN = 0,1 -> IRCLK disable/enable MCGC1_IREFSTEN_M; // IREFSTEN = 0,1 -> Internal reference enabled in STOP mode #if (MCGC2_EREFS_V != 0) // Wait for oscillator stable (if used) do { __asm__("nop"); } while ((MCGSC & MCGSC_OSCINIT_MASK) == 0); #endif // Wait for S_IREFST to indicate FLL Reference has switched do { __asm__("nop"); } while ((MCGSC & MCGSC_IREFST_MASK) != (MCGC1_IREFS_V?MCGSC_IREFST_MASK:0)); // Wait for S_CLKST to indicating that OUTCLK has switched to bypass PLL/FLL do { __asm__("nop"); } while ((MCGSC & MCGSC_CLKST_MASK) != (BYPASS<<MCGSC_CLKST_BITNUM)); // Set FLL Parameters MCGC4 = (MCGC4&~(MCGC4_DMX32_MASK|MCGC4_DRST_DRS_MASK))|MCGC4_DMX32_M|MCGC4_DRS_M; #endif #if ((CLOCK_MODE == CLOCK_MODE_PBE) || (CLOCK_MODE == CLOCK_MODE_PEE)) // Transition via PBE // ============================================================= MCGC3 = MCGC3_LOLIE_M | MCGC3_PLLS_M | // PLLS = 0,1 -> Enable PLL MCGC3_CME_M | // CME0 = 0,1 -> Disable/enable clock monitor MCGC3_VDIV_M; // VDIV0 = N -> PLL Multiplication factor // Wait for PLL to lock do { __asm__("nop"); } while((MCGSC & MCGSC_LOCK_MASK) == 0); // Wait until PLLS clock source changes to the PLL clock out do { __asm__("nop"); } while((MCGSC & MCGSC_PLLST_MASK) == 0); #endif #if ((CLOCK_MODE == CLOCK_MODE_FEI) || (CLOCK_MODE == CLOCK_MODE_FEE)) // Wait for FLL to lock do { __asm__("nop"); } while ((MCGC4&MCGC4_DRST_DRS_MASK) != MCGC4_DRS_M); #endif // Select FEI/FBI/FEE/FBE/PBE/PEE clock mode MCGC1 = MCGC1_CLKS_M | // CLKS = 0,1,2 -> Select FLL/IRCSCLK/ERCLK MCGC1_RDIV_M | // RDIV = N -> XTAL/2^n ~ 31.25 kHz MCGC1_IREFS_M | // IREFS = 0,1 -> External/Slow IRC for FLL source MCGC1_IRCLKEN_M | // IRCLKEN = 0,1 -> IRCLK disable/enable MCGC1_IREFSTEN_M; // IREFSTEN = 0,1 -> Internal reference enabled in STOP mode // Wait for mode change do { __asm__("nop"); } while ((MCGSC & MCGSC_IREFST_MASK) != (MCGC1_IREFS_V?MCGSC_IREFST_MASK:0)); #if defined (MCGC3_PLLS_V) && (MCGC1_CLKS_V == 0) // FLL or PLL #define MCGSC_CLKST_M ((MCGC3_PLLS_V?3:0)<<MCGSC_CLKST_BITNUM) #else #define MCGSC_CLKST_M (MCGC1_CLKS_V<<MCGSC_CLKST_BITNUM) #endif // Wait for S_CLKST to indicating that OUTCLK has switched do { __asm__("nop"); } while ((MCGSC & MCGSC_CLKST_MASK) != MCGSC_CLKST_M); #if (CLOCK_MODE == CLOCK_MODE_BLPE) || (CLOCK_MODE == CLOCK_MODE_BLPI) // Select BLPE/BLPI clock mode MCGC2 = MCGC2_LOCRE_M | // LOCRE0 = 0,1 -> Loss of clock reset MCGC2_RANGE_M | // RANGE0 = 0,1,2 -> Oscillator low/high/very high clock range MCGC2_HGO_M | // HGO0 = 0,1 -> Oscillator low power/high gain MCGC2_EREFS_M | // EREFS0 = 0,1 -> Select external clock/crystal oscillator MCGC2_LP_M | // LP = 0,1 -> Select FLL enabled/disabled in bypass mode MCGC2_IRCS_M; // IRCS = 0,1 -> Select slow/fast internal clock for internal reference #endif // (CLOCK_MODE == CLOCK_MODE_BLPE) || (CLOCK_MODE == CLOCK_MODE_BLPI) #endif // (CLOCK_MODE == CLOCK_MODE_RESET) // Basic clock multiplexing #if defined(MCU_mcf51jm128) // SIM_SOPT2 = SIM_SOPT2_UART0SRC_M | // UART0 clock - 0,1,2,3 -> Disabled, (MCGFLLCLK, MCGPLLCLK/2), OSCERCLK, MCGIRCLK // SIM_SOPT2_TPMSRC_M ; // TPM2 source #else #error "Modify as required" #endif #ifdef SIM_CLKDIV1_USBFRAC_MASK SIM_CLKDIV1 = SIM_CLKDIV1_USBDIV_M | SIM_CLKDIV1_USBFRAC_M | SIM_CLKDIV1_USBSRC_M; #endif #ifdef SIM_CLKDIV0 SIM_CLKDIV0 = SIM_CLKDIV0_M; #endif SystemCoreClockUpdate(); }
/** * Initializes the system. * System control registers must be unlocked. */ void SYS_Init() { // TODO: why is SYS_UnlockReg() needed? Should be already unlocked. SYS_UnlockReg(); // HIRC clock (internal RC 22.1184MHz) CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk); CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk); // HCLK clock source: HIRC, HCLK source divider: 1 CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC, CLK_CLKDIV0_HCLK(1)); // HXT clock (external XTAL 12MHz) CLK_EnableXtalRC(CLK_PWRCTL_HXTEN_Msk); CLK_WaitClockReady(CLK_STATUS_HXTSTB_Msk); // Enable 72MHz optimization FMC_EnableFreqOptimizeMode(FMC_FTCTL_OPTIMIZE_72MHZ); // Core clock: PLL CLK_SetCoreClock(PLL_CLOCK); CLK_WaitClockReady(CLK_STATUS_PLLSTB_Msk); // SPI0 clock: PCLK0 CLK_SetModuleClock(SPI0_MODULE, CLK_CLKSEL2_SPI0SEL_PCLK0, 0); CLK_EnableModuleClock(SPI0_MODULE); // TMR0-3 clock: HXT CLK_SetModuleClock(TMR0_MODULE, CLK_CLKSEL1_TMR0SEL_HXT, 0); CLK_SetModuleClock(TMR1_MODULE, CLK_CLKSEL1_TMR1SEL_HXT, 0); CLK_SetModuleClock(TMR2_MODULE, CLK_CLKSEL1_TMR2SEL_HXT, 0); CLK_SetModuleClock(TMR3_MODULE, CLK_CLKSEL1_TMR3SEL_HXT, 0); CLK_EnableModuleClock(TMR0_MODULE); CLK_EnableModuleClock(TMR1_MODULE); CLK_EnableModuleClock(TMR2_MODULE); CLK_EnableModuleClock(TMR3_MODULE); // PWM clock: PCLK0 CLK_SetModuleClock(PWM0_MODULE, CLK_CLKSEL2_PWM0SEL_PCLK0, 0); CLK_EnableModuleClock(PWM0_MODULE); // USBD clock CLK_SetModuleClock(USBD_MODULE, 0, CLK_CLKDIV0_USB(3)); CLK_EnableModuleClock(USBD_MODULE); // Enable USB 3.3V LDO SYS->USBPHY = SYS_USBPHY_LDO33EN_Msk; // EADC clock: 72Mhz / 8 CLK_SetModuleClock(EADC_MODULE, 0, CLK_CLKDIV0_EADC(8)); CLK_EnableModuleClock(EADC_MODULE); // Enable BOD (reset, 2.2V) SYS_EnableBOD(SYS_BODCTL_BOD_RST_EN, SYS_BODCTL_BODVL_2_2V); // Update system core clock SystemCoreClockUpdate(); // Initialize dataflash Dataflash_Init(); // Initialize I/O Display_SetupSPI(); Button_Init(); ADC_Init(); Atomizer_Init(); // Initialize display Display_Init(); }
static void prvSetupHardware( void ) { SystemCoreClockUpdate(); vParTestInitialise(); }
/** * @brief main routine for blinky example * @return Function should not exit. */ int main(void) { int i; /* Generic Initialization */ SystemCoreClockUpdate(); Board_Init(); Board_LED_Set(0, false); /* Enable SysTick Timer */ SysTick_Config(SystemCoreClock / TICKRATE_HZ); /* Initialize the array data to be written to FLASH */ for (i = 0; i < WRITECOUNT; i++) { array_data[i] = 0x11223340 + i; } /* Read Part Identification Number*/ command[0] = IAP_REPID_CMD; /* Read ID command code */ iap_entry(command, result); /* Reinvoke ISP mode so that reprogamming of Flash possible */ __disable_irq(); command[0] = IAP_REPID_CMD; iap_entry(command, result); /* Prepare to write/erase the last sector */ command[0] = IAP_PREWRRITE_CMD; /* Prepare to write/erase command code */ command[1] = IAP_LAST_SECTOR; /* Start Sector Number */ command[2] = IAP_LAST_SECTOR; /* End Sector Number */ iap_entry(command, result); /* Erase the last sector */ command[0] = IAP_ERSSECTOR_CMD; /* Erase command code*/ command[1] = IAP_LAST_SECTOR; /* Start Sector Number */ command[2] = IAP_LAST_SECTOR; /* Start Sector Number */ iap_entry(command, result); /* Prepare to write/erase the last sector */ command[0] = IAP_PREWRRITE_CMD; /* Prepare to write/erase command code */ command[1] = IAP_LAST_SECTOR; /* Start Sector Number */ command[2] = IAP_LAST_SECTOR; /* Start Sector Number */ iap_entry(command, result); /* Write to the last sector */ command[0] = IAP_WRISECTOR_CMD; /* Write command code */ command[1] = (uint32_t) last_sector_flash; /* Destination Flash Address */ command[2] = (uint32_t) &array_data; /* Source RAM Address */ command[3] = IAP_NUM_BYTES_TO_WRITE; /* Number of Bytes to be written */ command[4] = SystemCoreClock / 1000; /* System clock frequency */ iap_entry(command, result); /* Re-enable interrupt mode */ __enable_irq(); while (1) { __WFI(); } return 0; }
void SYS_Init(void) { /*---------------------------------------------------------------------------------------------------------*/ /* Init System Clock */ /*---------------------------------------------------------------------------------------------------------*/ /* Enable IRC22M clock */ CLK->PWRCON |= CLK_PWRCON_IRC22M_EN_Msk; /* Waiting for IRC22M clock ready */ while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_IRC22M_STB_Msk)); /* Switch HCLK clock source to HIRC */ CLK->CLKSEL0 = CLK_CLKSEL0_HCLK_S_HIRC; /* Set PLL to Power-down mode and PLL_STB bit in CLKSTATUS register will be cleared by hardware.*/ CLK->PLLCON |= CLK_PLLCON_PD_Msk; /* Enable external 12 MHz XTAL */ CLK->PWRCON |= CLK_PWRCON_XTL12M_EN_Msk; /* Enable PLL and Set PLL frequency */ CLK->PLLCON = PLLCON_SETTING; /* Waiting for clock ready */ while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_PLL_STB_Msk)); while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_XTL12M_STB_Msk)); /* Switch HCLK clock source to PLL, STCLK to HCLK/2 */ CLK->CLKSEL0 = CLK_CLKSEL0_STCLK_S_HCLK_DIV2 | CLK_CLKSEL0_HCLK_S_PLL; /* Enable peripheral clock */ CLK->APBCLK = CLK_APBCLK_UART0_EN_Msk | CLK_APBCLK_TMR0_EN_Msk | CLK_APBCLK_TMR2_EN_Msk | CLK_APBCLK_TMR3_EN_Msk; /* Peripheral clock source */ CLK->CLKSEL1 = CLK_CLKSEL1_UART_S_PLL | CLK_CLKSEL1_TMR0_S_HCLK | CLK_CLKSEL1_TMR1_S_HXT | CLK_CLKSEL1_TMR3_S_HXT; /* Update System Core Clock */ /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */ SystemCoreClockUpdate(); /*---------------------------------------------------------------------------------------------------------*/ /* Init I/O Multi-function */ /*---------------------------------------------------------------------------------------------------------*/ /* Set PB multi-function pins for UART0 RXD, TXD */ SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk); SYS->GPB_MFP |= (SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD); /* Set PB multi-function pins for TM0 on PB.8 and TM0_EXT on PB.15 */ SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB8_Msk | SYS_GPB_MFP_PB15_Msk); SYS->GPB_MFP |= (SYS_GPB_MFP_PB8_TM0 | SYS_GPB_MFP_PB15_TM0_EXT); SYS->ALT_MFP &= ~(SYS_ALT_MFP_PB15_Msk); SYS->ALT_MFP |= SYS_ALT_MFP_PB15_TM0_EXT; /* Set PB multi-function pins for TM2 on PB.2 and TM3 on PB.3 */ SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB2_Msk | SYS_GPB_MFP_PB3_Msk); SYS->GPB_MFP |= (SYS_GPB_MFP_PB2_TM2 | SYS_GPB_MFP_PB3_TM3); SYS->ALT_MFP2 &= ~(SYS_ALT_MFP2_PB2_Msk | SYS_ALT_MFP2_PB3_Msk); SYS->ALT_MFP2 |= (SYS_ALT_MFP2_PB2_TM2 | SYS_ALT_MFP2_PB3_TM3); }
/** * @brief Main program body * @return int */ int main(void) { CHIP_PMU_MCUPOWER_T crntPowerSetting; /* Setup SystemCoreClock and any needed board code */ SystemCoreClockUpdate(); Board_Init(); Board_LED_Set(0, true); /* Clear any previously set deep power down and sleep flags */ Chip_PMU_ClearSleepFlags(LPC_PMU, PMU_PCON_SLEEPFLAG | PMU_PCON_DPDFLAG); /* Enable the RTC oscillator, oscillator rate can be determined by calling Chip_Clock_GetRTCOscRate() */ Chip_Clock_EnableRTCOsc(); /* Initialize RTC driver (enables RTC clocking) */ Chip_RTC_Init(LPC_RTC); /* RTC reset */ Chip_RTC_Reset(LPC_RTC); /* Start RTC at a count of 0 when RTC is disabled. If the RTC is enabled, you need to disable it before setting the initial RTC count. */ Chip_RTC_Disable(LPC_RTC); Chip_RTC_SetCount(LPC_RTC, 0); /* Set a long alarm time so the interrupt won't trigger */ Chip_RTC_SetAlarm(LPC_RTC, 1000); /* Enable RTC */ Chip_RTC_Enable(LPC_RTC); /* Clear latched RTC interrupt statuses */ Chip_RTC_ClearStatus(LPC_RTC, (RTC_CTRL_OFD | RTC_CTRL_ALARM1HZ | RTC_CTRL_WAKE1KHZ)); /* Enable RTC interrupt */ NVIC_EnableIRQ(RTC_ALARM_IRQn); /* Enable RTC alarm interrupt */ Chip_RTC_EnableWakeup(LPC_RTC, RTC_CTRL_ALARMDPD_EN); /* Output example's activity banner */ DEBUGSTR("\r\n"); DEBUGSTR("-----------------------------------------------------------------\r\n"); #ifdef RESET_POWER_CYCLE_COUNT ProcessCycleCounter(); DEBUGOUT("Power Control Example\r\n"); #else DEBUGOUT("Power Control Example Cycle Count: %d\r\n", ProcessCycleCounter()); #endif DEBUGSTR(" System will cycle through SLEEP, DEEP SLEEP, POWER\r\n"); DEBUGSTR(" DOWN, and DEEP POWER DOWN power states\r\n"); DEBUGSTR("-----------------------------------------------------------------\r\n\r\n"); /* Setup alarm, process next power state then wait for alarm to wake-up system */ crntPowerSetting = PMU_MCU_SLEEP; while (1) { /* Set alarm to wakeup in POWER_CYCLE_SEC_DELAY seconds */ Chip_RTC_SetAlarm(LPC_RTC, Chip_RTC_GetCount(LPC_RTC) + POWER_CYCLE_SEC_DELAY); /* Enter first (or next) power state */ ProcessPowerState(crntPowerSetting); /* Inc current power setting and test for overflow */ if (crntPowerSetting == PMU_MCU_DEEP_PWRDOWN) { /* Reset to lowest power setting */ crntPowerSetting = PMU_MCU_SLEEP; } else { crntPowerSetting++; } } return 0; }
int main(void) { #if defined (__USE_LPCOPEN) // Read clock settings and update SystemCoreClock variable SystemCoreClockUpdate(); #if !defined(NO_BOARD_LIB) // Set up and initialize all required blocks and // functions related to the board hardware Board_Init(); // Set the LED to the state of "On" Board_LED_Set(0, true); #endif #endif ModbusMaster node(2); // Create modbus object that connects to slave id 2 node.begin(9600); // set transmission rate - other parameters are set inside the object and can't be changed here printRegister(node, 3); // for debugging node.writeSingleRegister(0, 0x0406); // prepare for starting printRegister(node, 3); // for debugging Sleep(1000); // give converter some time to set up // note: we should have a startup state machine that check converter status and acts per current status // but we take the easy way out and just wait a while and hope that everything goes well printRegister(node, 3); // for debugging node.writeSingleRegister(0, 0x047F); // set drive to start mode printRegister(node, 3); // for debugging Sleep(1000); // give converter some time to set up // note: we should have a startup state machine that check converter status and acts per current status // but we take the easy way out and just wait a while and hope that everything goes well printRegister(node, 3); // for debugging int i = 0; int j = 0; const uint16_t fa[20] = { 1000, 2000, 3000, 3500, 4000, 5000, 7000, 8000, 8300, 10000, 10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000 }; while (1) { uint8_t result; // slave: read (2) 16-bit registers starting at register 102 to RX buffer j = 0; do { result = node.readHoldingRegisters(102, 2); j++; } while(j < 3 && result != node.ku8MBSuccess); // note: sometimes we don't succeed on first read so we try up to threee times // if read is successful print frequency and current (scaled values) if (result == node.ku8MBSuccess) { printf("F=%4d, I=%4d (ctr=%d)\n", node.getResponseBuffer(0), node.getResponseBuffer(1),j); } else { printf("ctr=%d\n",j); } Sleep(3000); i++; if(i >= 20) { i=0; } // frequency is scaled: // 20000 = 50 Hz, 0 = 0 Hz, linear scale 400 units/Hz setFrequency(node, fa[i]); } return 0; }
/** * \brief Set system clock prescaler configuration * * This function will change the system clock prescaler configuration to * match the parameters. * * \note The parameters to this function are device-specific. * * \param ul_pres The CPU clock will be divided by \f$2^{mck\_pres}\f$ */ void sysclk_set_prescalers(uint32_t ul_pres) { pmc_mck_set_prescaler(ul_pres); SystemCoreClockUpdate(); }
int main(void) { SystemInit(); STM32F4_Discovery_LEDInit(LED3); //Orange STM32F4_Discovery_LEDInit(LED4); //Green STM32F4_Discovery_LEDInit(LED5); //Red STM32F4_Discovery_LEDInit(LED6); //Blue STM32F4_Discovery_PBInit(BUTTON_USER, BUTTON_MODE_GPIO); USBD_Init(&USB_OTG_dev,USB_OTG_FS_CORE_ID,&USR_desc,&USBD_CDC_cb,&USR_cb); SystemCoreClockUpdate(); // inicjalizacja dystrybucji czasu procesora init_I2C1(); // na podstawie: http://eliaselectronics.com/stm32f4-tutorials/stm32f4-i2c-mastertutorial/ //acc I2C_start(I2C1, LSM303DL_A_ADDRESS, I2C_Direction_Transmitter); I2C_write(I2C1,0x20); // LSM303_CTRL_REG1_A 0x20 I2C_write(I2C1,0x27); // Enable Accelerometer // 0x27 = 0b00100111 // Normal power mode, all axes enabled I2C_stop(I2C1); // stop the transmission //acc //mag I2C_start(I2C1, LSM303DL_M_ADDRESS, I2C_Direction_Transmitter); I2C_write(I2C1,0x02); //LSM303_MR_REG_M 0x02 I2C_write(I2C1,0x00); // Enable Magnetometer // 0x00 = 0b00000000 // Continuous conversion mode I2C_stop(I2C1); //mag //gyro I2C_start(I2C1, LSM303DL_G_ADDRESS, I2C_Direction_Transmitter); I2C_write(I2C1, 0x20); //L3G_CTRL_REG1 0x20 I2C_write(I2C1, 0x0F); // 0x0F = 0b00001111 // Normal power mode, all axes enabled I2C_stop(I2C1); //gyro char start='0'; while(1) { Delay(5); read_acc(); read_mag(); read_gyro(); start='0'; while(1) { start = usb_cdc_getc(); if(start=='1') { break; } } } /*while (1){ if(usb_cdc_kbhit()){ char c, buffer_out[15]; c = usb_cdc_getc(); switch(c){ case '3': STM32F4_Discovery_LEDToggle(LED3); sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED3_PIN)); usb_cdc_printf(buffer_out); break; case '4': STM32F4_Discovery_LEDToggle(LED4); sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED4_PIN)); usb_cdc_printf(buffer_out); break; case '5': STM32F4_Discovery_LEDToggle(LED5); sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED5_PIN)); usb_cdc_printf(buffer_out); break; case '6': STM32F4_Discovery_LEDToggle(LED6); sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED6_PIN)); usb_cdc_printf(buffer_out); break; } } button_sts = STM32F4_Discovery_PBGetState(BUTTON_USER); if(button_sts){ STM32F4_Discovery_LEDOff(LED3); STM32F4_Discovery_LEDOff(LED5); STM32F4_Discovery_LEDOff(LED3); STM32F4_Discovery_LEDOff(LED5); } }*/ }
/** * @brief Main routine for example_nandflash * @return Nothing */ int main(void) { K9F1G_ID_T nandId; const lpc_nandflash_size_t *flashInfo; uint32_t stSize, useBlock = BLOCK_INDEX; volatile int loop = 1, idx; /* For debug message only */ SystemCoreClockUpdate(); Board_Init(); Board_NANDFLash_Init(); lpc_nandflash_init(); /* Read flash information */ flashInfo = lpc_nandflash_get_size(); lpc_nandflash_get_id((uint8_t*)&nandId); DEBUGOUT(" Flash Information: \r\n"); DEBUGOUT(" Manufacturer ID: 0x%02x\r\n", nandId.MarkerCode); DEBUGOUT(" Device ID: 0x%02x\r\n", nandId.DeviceCode); DEBUGOUT(" Page Size: %dB\r\n", flashInfo->page_size); DEBUGOUT(" Spare Size: %dB\r\n", flashInfo->spare_size); DEBUGOUT(" Block Size: %dKB\r\n", flashInfo->pages_per_block*flashInfo->page_size/1024); DEBUGOUT(" Block count: %d\r\n", flashInfo->block_cnt); /* Show bad block list */ DEBUGOUT("Checking bad blocks...\r\n"); for (idx = 0; idx < flashInfo->block_cnt; idx++) { if (checkBadBlock(idx)) { DEBUGOUT(" Bad block at %d\r\n", idx); if (useBlock == idx) { /* Skip to next block for the example if this one is bad */ useBlock++; } } } /* Read data */ lpc_nandflash_read_start(useBlock, PAGE_INDEX, 0); waitForReady(); lpc_nandflash_read_data((uint8_t *) buffer, BUFFER_SIZE); /* Check and display string if it exists */ ShowString((char *) buffer); /* Get a string to save */ stSize = MakeString((uint8_t *) buffer); /* Erase flash */ lpc_nandflash_erase_block(useBlock); waitForReady(); /* Check the result of erasing */ if(lpc_nandflash_read_status() & NANDFLASH_STATUS_BLOCK_ERASE_FAIL) { DEBUGSTR("Erase failed!!!\r\n"); while(1){} } /* Write header + size + data to page */ DEBUGSTR("\r\nWrite to flash...\r\n"); lpc_nandflash_write_page(useBlock, PAGE_INDEX,(uint8_t *) buffer, (4 + stSize)); waitForReady(); /* Check the result of writting */ if(lpc_nandflash_read_status() & NANDFLASH_STATUS_PAGE_PROG_FAIL) { DEBUGSTR("Writing failed!!!\r\n"); while(1){} } DEBUGSTR("Reading back string...\r\n"); /* Read all data from flash */ lpc_nandflash_read_start(useBlock, PAGE_INDEX, 0); waitForReady(); lpc_nandflash_read_data((uint8_t *) buffer, BUFFER_SIZE); /* Check and display string if it exists */ ShowString((char *) buffer); /* Wait forever */ while (loop) {} return 0; }
/*! Sets up the clock out of RESET *! */ void clock_initialise(void) { #if (CLOCK_MODE == CLOCK_MODE_RESET) // No clock setup #else // XTAL/EXTAL Pins SIM_SCGC5 |= SIM_SCGC5_PORTA_MASK; PORTA_PCR3 = PORT_PCR_MUX(0); PORTA_PCR4 = PORT_PCR_MUX(0); // Configure the Crystal Oscillator OSC0_CR = OSC_CR_ERCLKEN_M|OSC_CR_EREFSTEN_M|OSC_CR_SCP_M; // Fast Internal Clock divider MCG_SC = MCG_SC_FCRDIV_M; // Out of reset MCG is in FEI mode // ============================================================= SIM_CLKDIV1 = SIM_CLKDIV1_OUTDIV1(3) | SIM_CLKDIV1_OUTDIV2(7) | SIM_CLKDIV1_OUTDIV3(3) | SIM_CLKDIV1_OUTDIV4(7); // Switch from FEI -> FEI/FBI/FEE/FBE // ============================================================= // Set up crystal or external clock source MCG_C2 = MCG_C2_LOCRE0_M | // LOCRE0 = 0,1 -> Loss of clock reset MCG_C2_RANGE0_M | // RANGE0 = 0,1,2 -> Oscillator low/high/very high clock range MCG_C2_HGO0_M | // HGO0 = 0,1 -> Oscillator low power/high gain MCG_C2_EREFS0_M | // EREFS0 = 0,1 -> Select external clock/crystal oscillator MCG_C2_IRCS_M; // IRCS = 0,1 -> Select slow/fast internal clock for internal reference #if ((CLOCK_MODE == CLOCK_MODE_FEI) || (CLOCK_MODE == CLOCK_MODE_FBI) || (CLOCK_MODE == CLOCK_MODE_BLPI) ) // Transition via FBI //===================================== #define BYPASS (1) // CLKS value used while FLL locks MCG_C1 = MCG_C1_CLKS(BYPASS) | // CLKS = 2 -> External reference source while PLL locks MCG_C1_FRDIV_M | // FRDIV = N -> XTAL/2^n ~ 31.25 kHz MCG_C1_IREFS_M | // IREFS = 0,1 -> External/Slow IRC for FLL source MCG_C1_IRCLKEN_M | // IRCLKEN = 0,1 -> IRCLK disable/enable MCG_C1_IREFSTEN_M; // IREFSTEN = 0,1 -> Internal reference enabled in STOP mode // Wait for S_IREFST to indicate FLL Reference has switched do { __asm__("nop"); } while ((MCG_S & MCG_S_IREFST_MASK) != (MCG_C1_IREFS_V<<MCG_S_IREFST_SHIFT)); // Wait for S_CLKST to indicating that OUTCLK has switched to bypass PLL/FLL do { __asm__("nop"); } while ((MCG_S & MCG_S_CLKST_MASK) != MCG_S_CLKST(BYPASS)); // Set FLL Parameters MCG_C4 = (MCG_C4&~(MCG_C4_DMX32_MASK|MCG_C4_DRST_DRS_MASK))|MCG_C4_DMX32_M|MCG_C4_DRST_DRS_M; #endif #if ((CLOCK_MODE == CLOCK_MODE_FBE) || (CLOCK_MODE == CLOCK_MODE_FEE) || (CLOCK_MODE == CLOCK_MODE_PLBE) || (CLOCK_MODE == CLOCK_MODE_PBE) || (CLOCK_MODE == CLOCK_MODE_PEE)) // Transition via FBE //===================================== #define BYPASS (2) // CLKS value used while PLL locks MCG_C1 = MCG_C1_CLKS(BYPASS) | // CLKS = 2 -> External reference source while PLL locks MCG_C1_FRDIV_M | // FRDIV = N -> XTAL/2^n ~ 31.25 kHz MCG_C1_IREFS_M | // IREFS = 0,1 -> External/Slow IRC for FLL source MCG_C1_IRCLKEN_M | // IRCLKEN = 0,1 -> IRCLK disable/enable MCG_C1_IREFSTEN_M; // IREFSTEN = 0,1 -> Internal reference enabled in STOP mode #if (MCG_C2_EREFS_V != 0) // Wait for oscillator stable (if used) do { __asm__("nop"); } while ((MCG_S & MCG_S_OSCINIT0_MASK) == 0); #endif // Wait for S_IREFST to indicate FLL Reference has switched do { __asm__("nop"); } while ((MCG_S & MCG_S_IREFST_MASK) != (MCG_C1_IREFS_V<<MCG_S_IREFST_SHIFT)); // Wait for S_CLKST to indicating that OUTCLK has switched to bypass PLL/FLL do { __asm__("nop"); } while ((MCG_S & MCG_S_CLKST_MASK) != MCG_S_CLKST(BYPASS)); // Set FLL Parameters MCG_C4 = (MCG_C4&~(MCG_C4_DMX32_MASK|MCG_C4_DRST_DRS_MASK))|MCG_C4_DMX32_M|MCG_C4_DRST_DRS_M; #endif // Select FEI/FBI/FEE/FBE clock mode MCG_C1 = MCG_C1_CLKS_M | // CLKS = 0,1,2 -> Select FLL/IRCSCLK/ERCLK MCG_C1_FRDIV_M | // FRDIV = N -> XTAL/2^n ~ 31.25 kHz MCG_C1_IREFS_M | // IREFS = 0,1 -> External/Slow IRC for FLL source MCG_C1_IRCLKEN_M | // IRCLKEN = 0,1 -> IRCLK disable/enable MCG_C1_IREFSTEN_M; // IREFSTEN = 0,1 -> Internal reference enabled in STOP mode // Wait for mode change do { __asm__("nop"); } while ((MCG_S & MCG_S_IREFST_MASK) != (MCG_C1_IREFS_V<<MCG_S_IREFST_SHIFT)); #if defined (MCG_C6_PLLS_V) && (MCG_C1_CLKS_V == 0) // FLL or PLL #define MCG_S_CLKST_M MCG_S_CLKST(MCG_C6_PLLS_V?3:0) #else #define MCG_S_CLKST_M MCG_S_CLKST(MCG_C1_CLKS_V) #endif // Wait for S_CLKST to indicating that OUTCLK has switched do { __asm__("nop"); } while ((MCG_S & MCG_S_CLKST_MASK) != MCG_S_CLKST_M); // Set the SIM _CLKDIV dividers SIM_CLKDIV1 = SIM_CLKDIV1_OUTDIV1_M | SIM_CLKDIV1_OUTDIV2_M | SIM_CLKDIV1_OUTDIV3_M | SIM_CLKDIV1_OUTDIV4_M; #if (CLOCK_MODE == CLOCK_MODE_BLPE) || (CLOCK_MODE == CLOCK_MODE_BLPI) // Select BLPE/BLPI clock mode MCG_C2 = MCG_C2_LOCRE0_M | // LOCRE0 = 0,1 -> Loss of clock reset MCG_C2_RANGE0_M | // RANGE0 = 0,1,2 -> Oscillator low/high/very high clock range MCG_C2_HGO0_M | // HGO0 = 0,1 -> Oscillator low power/high gain MCG_C2_EREFS0_M | // EREFS0 = 0,1 -> Select external clock/crystal oscillator MCG_C2_LP_M | // LP = 0,1 -> Select FLL enabled/disabled in bypass mode MCG_C2_IRCS_M; // IRCS = 0,1 -> Select slow/fast internal clock for internal reference #endif // (CLOCK_MODE == CLOCK_MODE_BLPE) || (CLOCK_MODE == CLOCK_MODE_BLPI) #endif // (CLOCK_MODE == CLOCK_MODE_RESET) // Basic clock multiplexing #if defined(MCU_MK20D5) || defined(MCU_MK20D7) || defined(MCU_MK40D10) || defined(MCU_MK40DZ10) // Peripheral clock choice (incl. USB), USBCLK = MCGCLK SIM_SOPT2 |= SIM_SOPT2_PLLFLLSEL_M | // PLL rather than FLL for peripheral clock SIM_SOPT2_USBSRC_MASK; // MCGPLLCLK/2 Source as USB clock (48MHz req.) SIM_SOPT1 = (SIM_SOPT1&~SIM_SOPT1_OSC32KSEL_MASK)|SIM_SOPT1_OSC32KSEL_M; // ERCLK32K source #elif defined(MCU_MK60D10) || defined(MCU_MK60DZ10) // Peripheral clock choice (incl. USB), USBCLK = MCGCLK SIM_SOPT2 |= SIM_SOPT2_PLLFLLSEL_MASK | // PLL rather than FLL for peripheral clock SIM_SOPT2_USBSRC_MASK; // MCGPLLCLK/2 Source as USB clock (48MHz req.) #elif defined(MCU_MKL24Z4) || defined(MCU_MKL25Z4) || defined(MCU_MKL26Z4) || defined(MCU_MKL46Z4) SIM_SOPT2 = SIM_SOPT2_UART0SRC_M | // UART0 clock - 0,1,2,3 -> Disabled, (MCGFLLCLK, MCGPLLCLK/2), OSCERCLK, MCGIRCLK SIM_SOPT2_TPMSRC_M | // TPM clock - 0,1,2,3 -> Disabled, (MCGFLLCLK, MCGPLLCLK/2), OSCERCLK, MCGIRCLK SIM_SOPT2_PLLFLLSEL_M | // Peripheral clock - 0,1 -> MCGFLLCLK,MCGPLLCLK/2 SIM_SOPT2_USBSRC_MASK; // MCGPLLCLK/2 Source as USB clock (48MHz req.) SIM_SOPT1 = (SIM_SOPT1&~SIM_SOPT1_OSC32KSEL_MASK)|SIM_SOPT1_OSC32KSEL_M; // ERCLK32K clock - 0,1,2,3 -> OSC32KCLK, - , RTC_CLKIN, LPO (1kHz) #elif defined(MCU_MKL14Z4) || defined(MCU_MKL15Z4) || defined(MCU_MKL16Z4) || defined(MCU_MKL34Z4) || defined(MCU_MKL36Z4) SIM_SOPT2 = SIM_SOPT2_UART0SRC_M | // UART0 clock - 0,1,2,3 -> Disabled, (MCGFLLCLK, MCGPLLCLK/2), OSCERCLK, MCGIRCLK SIM_SOPT2_TPMSRC_M | // TPM clock - 0,1,2,3 -> Disabled, (MCGFLLCLK, MCGPLLCLK/2), OSCERCLK, MCGIRCLK SIM_SOPT2_PLLFLLSEL_M; // Peripheral clock - 0,1 -> MCGFLLCLK,MCGPLLCLK/2 SIM_SOPT1 = (SIM_SOPT1&~SIM_SOPT1_OSC32KSEL_MASK)|SIM_SOPT1_OSC32KSEL_M; // ERCLK32K clock - 0,1,2,3 -> OSC32KCLK, - , RTC_CLKIN, LPO (1kHz) #elif defined(MCU_MKL02Z4) || defined(MCU_MKL04Z4) || defined(MCU_MKL05Z4) SIM_SOPT2 = SIM_SOPT2_UART0SRC_M | // UART0 clock - 0,1,2,3 -> Disabled, (MCGFLLCLK, MCGPLLCLK/2), OSCERCLK, MCGIRCLK SIM_SOPT2_TPMSRC_M ; // TPM2 source #else #error "CPU not set" #endif SystemCoreClockUpdate(); }
/** * @brief This function set HCLK clock source and HCLK clock divider * @param u32ClkSrc is HCLK clock source. Including : * - \ref CLK_CLKSEL0_HCLK_S_HXT * - \ref CLK_CLKSEL0_HCLK_S_LXT * - \ref CLK_CLKSEL0_HCLK_S_PLL * - \ref CLK_CLKSEL0_HCLK_S_LIRC * - \ref CLK_CLKSEL0_HCLK_S_HIRC * @param u32ClkDiv is HCLK clock divider. Including : * - \ref CLK_HCLK_CLK_DIVIDER(x) * @return None */ void CLK_SetHCLK(uint32_t u32ClkSrc, uint32_t u32ClkDiv) { CLK->CLKDIV0 = (CLK->CLKDIV0 & ~CLK_CLKDIV0_HCLK_N_Msk) | u32ClkDiv; CLK->CLKSEL0 = (CLK->CLKSEL0 & ~CLK_CLKSEL0_HCLK_S_Msk) | u32ClkSrc; SystemCoreClockUpdate(); }
int main(void) { SystemCoreClockUpdate(); // Read IAP before any interrupts are enabled UPER_PART_NUMBER = IAP_GetPartNumber(); UPER_BOOT_CODE_VERSION = IAP_GetBootCodeVersion(); IAP_GetSerialNumber(GUID); // Init the rest of the system Time_init(); while (CDC_Init(&stream, GUID) != LPC_OK); // Load SFPPacketStream LPC_SYSCON->SYSAHBCLKCTRL |= BIT6 | BIT16 | BIT19; // Enable clock for GPIO, IOConfig and Pin Interrupts #ifndef DEBUG // Disabled for debugging (JTAG) lpc_config_gpioInit(); #endif // PIO0_4 and PIO0_5 forced to I2C LPC_IOCON->PIO0_4 |= 1; // I2C SCL LPC_IOCON->PIO0_5 |= 1; // I2C SDA /* SFP initialization, configuration and launch */ SFPServer *server = SFPServer_new(&stream); SFPServer_setDataTimeout(server, 30000); // 300k is about a second (30k ~100ms) /* GPIO/Pin functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_SETPRIMARY, UPER_FID_SETPRIMARY, lpc_config_setPrimary); SFPServer_addFunctionHandler(server, UPER_FNAME_SETSECONDARY, UPER_FID_SETSECONDARY, lpc_config_setSecondary); SFPServer_addFunctionHandler(server, UPER_FNAME_PINMODE, UPER_FID_PINMODE, lpc_pinMode); SFPServer_addFunctionHandler(server, UPER_FNAME_DIGITALWRITE, UPER_FID_DIGITALWRITE, lpc_digitalWrite); SFPServer_addFunctionHandler(server, UPER_FNAME_DIGITALREAD, UPER_FID_DIGITALREAD, lpc_digitalRead); SFPServer_addFunctionHandler(server, UPER_FNAME_ATTACHINTERRUPT, UPER_FID_ATTACHINTERRUPT, lpc_attachInterrupt); SFPServer_addFunctionHandler(server, UPER_FNAME_DETACHINTERRUPT, UPER_FID_DETACHINTERRUPT, lpc_detachInterrupt); SFPServer_addFunctionHandler(server, UPER_FNAME_PULSEIN, UPER_FID_PULSEIN, lpc_pulseIn); /* ADC functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_ANALOGREAD, UPER_FID_ANALOGREAD, lpc_analogRead); /* SPI functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_SPI0BEGIN, UPER_FID_SPI0BEGIN, lpc_spi0_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI0TRANS, UPER_FID_SPI0TRANS, lpc_spi0_trans); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI0END, UPER_FID_SPI0END, lpc_spi0_end); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI1BEGIN, UPER_FID_SPI1BEGIN, lpc_spi1_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI1TRANS, UPER_FID_SPI1TRANS, lpc_spi1_trans); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI1END, UPER_FID_SPI1END, lpc_spi1_end); /* I2C functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_I2CBEGIN, UPER_FID_I2CBEGIN, lpc_i2c_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_I2CTRANS, UPER_FID_I2CTRANS, lpc_i2c_trans); SFPServer_addFunctionHandler(server, UPER_FNAME_I2CEND, UPER_FID_I2CEND, lpc_i2c_end); /* PWM functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_PWM0BEGIN, UPER_FID_PWM0BEGIN, lpc_pwm0_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM0SET, UPER_FID_PWM0SET, lpc_pwm0_set); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM0END, UPER_FID_PWM0END, lpc_pwm0_end); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM1BEGIN, UPER_FID_PWM1BEGIN, lpc_pwm1_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM1SET, UPER_FID_PWM1SET, lpc_pwm1_set); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM1END, UPER_FID_PWM1END, lpc_pwm1_end); /* Other functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_RESTART, UPER_FID_RESTART, lpc_system_restart); SFPServer_addFunctionHandler(server, UPER_FNAME_GETDEVICEINFO, UPER_FID_GETDEVICEINFO, lpc_system_getDeviceInfo); SFPServer_loop(server); SFPServer_delete(server); while (1); }
/** * \brief getting-started Application entry point. * * \return Unused (ANSI-C compatibility). */ extern int main(void) { uint32_t id_offset = 0; uint32_t fifo_entries; uint32_t button_state = BUTTON_PUSHED; uint32_t button_state2 = BUTTON_NOT_PUSHED; uint32_t can_mode = CAN_STANDARD; /* Disable watchdog */ WDT_Disable(WDT); /* Output example information */ printf("\n\r-- Controller Area Network (CAN) Example %s --\n\r", SOFTPACK_VERSION); printf("-- %s\n\r", BOARD_NAME); printf("-- Compiled: %s %s --\n\r\n\r", __DATE__, __TIME__); printf("-- LED0 toggles on CAN message reception\n\r"); printf("-- LED1 toggles on CAN message transmission\n\r"); printf("-- CAN message transmission stopped while SW0 is pushed\n\r"); printf("-- SW1 pushes alternate between standard CAN and CAN-FD\n\r"); SCB_EnableICache(); SCB_EnableDCache(); /* Configure systick for 1 ms. */ TimeTick_Configure(); /* Configure Board LED's */ LED_Configure(0); #if 2 == LED_NUM LED_Configure(1); #endif /* Configure Timer/Counter for 250msec Tick */ _ConfigureTc(); /* Configure Board Push-buttons */ // SW1 is a ERASE system function, switch it to port function MATRIX->CCFG_SYSIO |= (1u << 12); /* have to disable the pull down on PB12 for SW1 before the pull up can be enabled */ PIOB->PIO_PPDDR = 1 << 12; PIO_Configure(pushbutton, PIO_LISTSIZE(pushbutton)); /* Adjust pio denounce filter parameters, uses 10 Hz filter. */ PIO_SetDebounceFilter(&pushbutton[0], 10); #if 2 == BUTTON_NUM PIO_SetDebounceFilter(&pushbutton[1], 10000); #endif SystemCoreClockUpdate(); MCAN_Init(&mcan1Config); MCAN_InitFdBitRateSwitchEnable(&mcan1Config); MCAN_InitTxQueue(&mcan1Config); MCAN_InitLoopback(&mcan1Config); // remove to disable loop back mode MCAN_Enable(&mcan1Config); MCAN_IEnableMessageStoredToRxDedBuffer(&mcan1Config, CAN_INTR_LINE_1); txMailbox0 = (uint32_t *)MCAN_ConfigTxDedBuffer(&mcan1Config, TX_BUFFER_0, MSG_ID_0, CAN_STD_ID, CAN_DLC_1); txMailbox1 = (uint32_t *)MCAN_ConfigTxDedBuffer(&mcan1Config, TX_BUFFER_1, MSG_ID_1, CAN_EXT_ID, CAN_DLC_8); MCAN_ConfigRxBufferFilter(&mcan1Config, RX_BUFFER_0, FILTER_0, MSG_ID_0, CAN_STD_ID); MCAN_ConfigRxBufferFilter(&mcan1Config, RX_BUFFER_1, FILTER_0, MSG_ID_1, CAN_EXT_ID); MCAN_ConfigRxClassicFilter(&mcan1Config, CAN_FIFO_0, FILTER_1, MSG_ID_2, CAN_STD_ID, MSG_ID_2_MASK); while (1) { if (tick) { tick = 0; if (PIO_Get(&pushbutton[0]) == BUTTON_NOT_PUSHED) { if (button_state2 == BUTTON_NOT_PUSHED) { /* periodically transmit messages while SW0 is not pushed */ // send standard ID from a dedicated buffer *txMailbox0 = MSG_ID_0_DATA1; // write data into CAN mailbox MCAN_SendTxDedBuffer(&mcan1Config, TX_BUFFER_0); // send data txdCntr++; // send extended ID from a dedicated buffer *txMailbox1 = MSG_ID_1_DATA1_4; // write data into CAN mailbox *(txMailbox1 + 1) = MSG_ID_1_DATA5_8; // write data into CAN mailbox MCAN_SendTxDedBuffer(&mcan1Config, TX_BUFFER_1); // send the data txdCntr++; // send from Tx Queue MCAN_AddToTxFifoQ(&mcan1Config, MSG_ID_2 + id_offset, CAN_STD_ID, CAN_DLC_1, &txData[0]); txdCntr++; // increment the offset so we send different ID's within the // range defined by the mask id_offset = (id_offset + 1) & (uint32_t) ~MSG_ID_2_MASK; // update data being sent for next time txData[0]++; button_state2 = BUTTON_NOT_PUSHED; } } else { if (button_state2 == BUTTON_NOT_PUSHED) button_state2 = BUTTON_PUSHED; else button_state2 = BUTTON_NOT_PUSHED; } } /* poll for TX'd message complete */ if (MCAN_IsTxComplete(&mcan1Config)) { MCAN_ClearTxComplete(&mcan1Config); if (MCAN_IsBufferTxd(&mcan1Config, TX_BUFFER_0)) { #if 2 == LED_NUM LED_Toggle(1); #endif } } /* Poll for new CAN messages in RX FIFO */ do { fifo_entries = MCAN_GetRxFifoBuffer(&mcan1Config, CAN_FIFO_0, (Mailbox64Type *) &rxMailbox2); if (fifo_entries > 0) rxdCntr++; } while (fifo_entries > 1); /* SW1 used to alternate between standard CAN and CAN-FD operation */ #if 2 == BUTTON_NUM if (PIO_Get(&pushbutton[1]) == BUTTON_NOT_PUSHED) { #else if (1) { #endif button_state = BUTTON_NOT_PUSHED; } else { if (button_state == BUTTON_NOT_PUSHED ) { // Switch on a NOT PUSHED to PUSHED edge button_state = BUTTON_PUSHED; if (can_mode == CAN_STANDARD) { can_mode = CAN_FD; MCAN_RequestFdBitRateSwitch( &mcan1Config ); } else { can_mode = CAN_STANDARD; MCAN_RequestIso11898_1( &mcan1Config ); } } } #ifdef POLLKEYBOARD /* poll for keyboard entry */ if (DBG_IsRxReady()) { keyboard = DBG_GetChar(); if (((char) keyboard == 'L' ) || ( (char) keyboard == 'l')) { if (loopback == 1) { MCAN_LoopbackOff(&mcan1Config); loopback = 0; } else { MCAN_LoopbackOn(&mcan1Config); loopback = 1; } } } #endif } }
void board_init(void) { GPIO_InitTypeDef gpio; SystemCoreClockUpdate( ); // turn on peripherals needed by all RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_DMA1 | RCC_AHB1Periph_DMA2 | RCC_AHB1Periph_BKPSRAM, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_TIM1 | RCC_APB2Periph_SYSCFG, ENABLE); RCC_APB1PeriphClockCmd( RCC_APB1Periph_SPI2 | RCC_APB1Periph_SPI3 | RCC_APB1Periph_TIM2 | RCC_APB1Periph_TIM3 | RCC_APB1Periph_TIM4 | RCC_APB1Periph_TIM5 | RCC_APB1Periph_TIM12 | RCC_APB1Periph_PWR, ENABLE); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK); RCC_LSEConfig(RCC_LSE_OFF); LEDInit(LED_BLUE); LEDInit(LED_GREEN); gpio.GPIO_Pin = GPIO_Pin_0; gpio.GPIO_Mode = GPIO_Mode_OUT; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_PuPd = GPIO_PuPd_UP; gpio.GPIO_Speed = GPIO_Speed_100MHz; GPIO_Init(GPIOC, &gpio); GPIO_SetBits(GPIOC, GPIO_Pin_0); gpio.GPIO_Pin = GPIO_Pin_1; gpio.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_Init(GPIOC, &gpio); GPIO_ResetBits(GPIOC, GPIO_Pin_1); //SPI1 output to electronic switch to control mask GPIO_StructInit(&gpio); gpio.GPIO_Pin = GPIO_Pin_6; // SPI1 MISO gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_50MHz; gpio.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOA, &gpio); GPIO_ResetBits(GPIOA, GPIO_Pin_6); GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SPI3); GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SPI3); GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SPI3); // max7456 SPI MOIS MISO SLK pin config gpio.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12; gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_50MHz; gpio.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_Init(GPIOC, &gpio); // max7456 SPI CS Pin gpio.GPIO_Pin = GPIO_Pin_15; gpio.GPIO_Mode = GPIO_Mode_OUT; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_50MHz; gpio.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOA, &gpio); GPIO_SetBits(GPIOA,GPIO_Pin_15); Build_Sin_Cos_Tables(); LoadParams(); checkDefaultParam(); SPI_MAX7456_init(); atti_mp_scale = (float)eeprom_buffer.params.Atti_mp_scale_real + (float)eeprom_buffer.params.Atti_mp_scale_frac * 0.01; atti_3d_scale = (float)eeprom_buffer.params.Atti_3D_scale_real + (float)eeprom_buffer.params.Atti_3D_scale_frac * 0.01; atti_3d_min_clipX = eeprom_buffer.params.Atti_mp_posX - (uint32_t)(22*atti_mp_scale); atti_3d_max_clipX = eeprom_buffer.params.Atti_mp_posX + (uint32_t)(22*atti_mp_scale); atti_3d_min_clipY = eeprom_buffer.params.Atti_mp_posY - (uint32_t)(30*atti_mp_scale); atti_3d_max_clipY = eeprom_buffer.params.Atti_mp_posY + (uint32_t)(34*atti_mp_scale); }
int_t main(void) { error_t error; NetInterface *interface; OsTask *task; MacAddr macAddr; #if (APP_USE_DHCP == DISABLED) Ipv4Addr ipv4Addr; #endif #if (APP_USE_SLAAC == DISABLED) Ipv6Addr ipv6Addr; #endif //Update system core clock SystemCoreClockUpdate(); //Initialize kernel osInitKernel(); //Configure debug UART debugInit(115200); //Start-up message TRACE_INFO("\r\n"); TRACE_INFO("**********************************\r\n"); TRACE_INFO("*** CycloneTCP FTP Client Demo ***\r\n"); TRACE_INFO("**********************************\r\n"); TRACE_INFO("Copyright: 2010-2014 Oryx Embedded\r\n"); TRACE_INFO("Compiled: %s %s\r\n", __DATE__, __TIME__); TRACE_INFO("Target: MK60N512MD100\r\n"); TRACE_INFO("\r\n"); //Configure I/Os ioInit(); //TCP/IP stack initialization error = tcpIpStackInit(); //Any error to report? if(error) { //Debug message TRACE_ERROR("Failed to initialize TCP/IP stack!\r\n"); } //Configure the first Ethernet interface interface = &netInterface[0]; //Set interface name tcpIpStackSetInterfaceName(interface, "eth0"); //Set host name tcpIpStackSetHostname(interface, "FTPClientDemo"); //Select the relevant network adapter tcpIpStackSetDriver(interface, &mk60EthDriver); tcpIpStackSetPhyDriver(interface, &ksz8041PhyDriver); //Set host MAC address macStringToAddr(APP_MAC_ADDR, &macAddr); tcpIpStackSetMacAddr(interface, &macAddr); //Initialize network interface error = tcpIpStackConfigInterface(interface); //Any error to report? if(error) { //Debug message TRACE_ERROR("Failed to configure interface %s!\r\n", interface->name); } #if (IPV4_SUPPORT == ENABLED) #if (APP_USE_DHCP == ENABLED) //Get default settings dhcpClientGetDefaultSettings(&dhcpClientSettings); //Set the network interface to be configured by DHCP dhcpClientSettings.interface = interface; //Disable rapid commit option dhcpClientSettings.rapidCommit = FALSE; //DHCP client initialization error = dhcpClientInit(&dhcpClientContext, &dhcpClientSettings); //Failed to initialize DHCP client? if(error) { //Debug message TRACE_ERROR("Failed to initialize DHCP client!\r\n"); } //Start DHCP client error = dhcpClientStart(&dhcpClientContext); //Failed to start DHCP client? if(error) { //Debug message TRACE_ERROR("Failed to start DHCP client!\r\n"); } #else //Set IPv4 host address ipv4StringToAddr(APP_IPV4_HOST_ADDR, &ipv4Addr); ipv4SetHostAddr(interface, ipv4Addr); //Set subnet mask ipv4StringToAddr(APP_IPV4_SUBNET_MASK, &ipv4Addr); ipv4SetSubnetMask(interface, ipv4Addr); //Set default gateway ipv4StringToAddr(APP_IPV4_DEFAULT_GATEWAY, &ipv4Addr); ipv4SetDefaultGateway(interface, ipv4Addr); //Set primary and secondary DNS servers ipv4StringToAddr(APP_IPV4_PRIMARY_DNS, &ipv4Addr); ipv4SetDnsServer(interface, 0, ipv4Addr); ipv4StringToAddr(APP_IPV4_SECONDARY_DNS, &ipv4Addr); ipv4SetDnsServer(interface, 1, ipv4Addr); #endif #endif #if (IPV6_SUPPORT == ENABLED) #if (APP_USE_SLAAC == ENABLED) //Get default settings slaacGetDefaultSettings(&slaacSettings); //Set the network interface to be configured slaacSettings.interface = interface; //SLAAC initialization error = slaacInit(&slaacContext, &slaacSettings); //Failed to initialize SLAAC? if(error) { //Debug message TRACE_ERROR("Failed to initialize SLAAC!\r\n"); } //Start IPv6 address autoconfiguration process error = slaacStart(&slaacContext); //Failed to start SLAAC process? if(error) { //Debug message TRACE_ERROR("Failed to start SLAAC!\r\n"); } #else //Set link-local address ipv6StringToAddr(APP_IPV6_LINK_LOCAL_ADDR, &ipv6Addr); ipv6SetLinkLocalAddr(interface, &ipv6Addr, IPV6_ADDR_STATE_VALID); //Set IPv6 prefix ipv6StringToAddr(APP_IPV6_PREFIX, &ipv6Addr); ipv6SetPrefix(interface, &ipv6Addr, APP_IPV6_PREFIX_LENGTH); //Set global address ipv6StringToAddr(APP_IPV6_GLOBAL_ADDR, &ipv6Addr); ipv6SetGlobalAddr(interface, &ipv6Addr, IPV6_ADDR_STATE_VALID); //Set router ipv6StringToAddr(APP_IPV6_ROUTER, &ipv6Addr); ipv6SetRouter(interface, &ipv6Addr); //Set primary and secondary DNS servers ipv6StringToAddr(APP_IPV6_PRIMARY_DNS, &ipv6Addr); ipv6SetDnsServer(interface, 0, &ipv6Addr); ipv6StringToAddr(APP_IPV6_SECONDARY_DNS, &ipv6Addr); ipv6SetDnsServer(interface, 1, &ipv6Addr); #endif #endif //Create user task task = osCreateTask("User Task", userTask, NULL, 500, 1); //Failed to create the task? if(task == OS_INVALID_HANDLE) { //Debug message TRACE_ERROR("Failed to create task!\r\n"); } //Create a task to blink the LED task = osCreateTask("Blink", blinkTask, NULL, 500, 1); //Failed to create the task? if(task == OS_INVALID_HANDLE) { //Debug message TRACE_ERROR("Failed to create task!\r\n"); } //Start the execution of tasks osStartKernel(); //This function should never return return 0; }
//------------------------------------------------------------------------------------------------------------------------------------- // Main Function //------------------------------------------------------------------------------------------------------------------------------------- int main(void){ SystemCoreClockUpdate(); // Enable clocks to peripherals we use RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); // enable clock to GPIOC RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); // Enable clock to GPIOB RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); // Enable clock to USART 1 //RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); // Configure I/O pins on GPIO PORT C GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 | GPIO_Pin_14 | GPIO_Pin_13; // PC15, PC14, PC13 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; // Outputs GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; // Push pull GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; // 2MHz max speed GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; // No pull-ups or pull-downs GPIO_Init(GPIOC, &GPIO_InitStructure); // Configure I/O pin on PORTB for the UART (PB6) GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOB, &GPIO_InitStructure); // Configure UART 1 USART_InitStructure.USART_BaudRate = 9600; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; USART_Init(USART1, &USART_InitStructure); USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); // Enable receive interrupt.... NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; // we want to configure the USART1 interrupts NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // the USART1 interrupts are globally enabled NVIC_Init(&NVIC_InitStructure); USART_Cmd(USART1, ENABLE); SysTick_Config(4800); printf("STM32F052RBT8 bootup... \r\n"); fflush(stdout); for(;;){ GPIO_SetBits(GPIOC, GPIO_Pin_13); Delay(0x3FFFFF); GPIO_ResetBits(GPIOC, GPIO_Pin_13); Delay(0x3FFFFF); } }