int main(void) { DelayInit(); GPIO_QuickInit(HW_GPIOE, 6, kGPIO_Mode_OPP); UART_QuickInit(UART0_RX_PD06_TX_PD07, 115200); /* 设置PORTE PORTA 中断 */ GPIO_QuickInit(HW_GPIOE,26, kGPIO_Mode_IPU); GPIO_QuickInit(HW_GPIOA, 4, kGPIO_Mode_IPU); GPIO_CallbackInstall(HW_GPIOE, PORTE_ISR); GPIO_CallbackInstall(HW_GPIOA, PORTA_ISR); GPIO_ITDMAConfig(HW_GPIOE, 26, kGPIO_IT_RisingEdge, true); GPIO_ITDMAConfig(HW_GPIOA, 4, kGPIO_IT_RisingEdge, true); printf("NVIC test connect E26&A04\r\n"); /* 将系统 中断优先级分组 可以配置 16个 抢占优先级 和16个 子优先级 */ NVIC_SetPriorityGrouping(NVIC_PriorityGroup_2); //中断优先级分成2组 NVIC_SetPriority(PORTE_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, 2, 2)); //设置PTE端口的抢占优先级的子优先级 NVIC_SetPriority(PORTA_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, 2, 2)); while(1) { GPIO_ToggleBit(HW_GPIOE, 6); DelayMs(500); } }
void init_Priority(void){ uint32_t priority, PG = 5, PP, SP; // priority grouping, pre-empt priority, subpriority NVIC_SetPriorityGrouping(5); PP = 0, SP = 0; priority = NVIC_EncodePriority(PG,PP,SP); NVIC_SetPriority(SysTick_IRQn, priority); PP = 1, SP = 0; priority = NVIC_EncodePriority(PG,PP,SP); NVIC_SetPriority(EINT3_IRQn, priority); // light sensor and SW3 // interrupt with smallest time interval is given higher priority PP = 2, SP = 0; priority = NVIC_EncodePriority(PG,PP,SP); NVIC_SetPriority(TIMER1_IRQn, priority); // pca9532 led (250ms) PP = 2, SP = 1; priority = NVIC_EncodePriority(PG,PP,SP); NVIC_SetPriority(TIMER2_IRQn, priority); // rgb (1s) PP = 2, SP = 2; priority = NVIC_EncodePriority(PG,PP,SP); NVIC_SetPriority(TIMER3_IRQn, priority); // sampling (2s) // clear pending status before enabling NVIC_ClearPendingIRQ(EINT3_IRQn); NVIC_ClearPendingIRQ(TIMER1_IRQn); NVIC_ClearPendingIRQ(TIMER2_IRQn); NVIC_ClearPendingIRQ(TIMER3_IRQn); NVIC_EnableIRQ(EINT3_IRQn); NVIC_EnableIRQ(TIMER1_IRQn); NVIC_EnableIRQ(TIMER2_IRQn); NVIC_EnableIRQ(TIMER3_IRQn); }
void Timerx_Init(GPTM_TypeDef* GPTMx,u16 arr,u16 psc) { GPTM_TimeBaseInitTypeDef GPTM_TimeBaseStructure; //NVIC_InitTypeDef NVIC_InitStructure; Assert_Param(IS_GPTM(GPTMx)); if(GPTMx==GPTM0) { CKCU_APBPerip1ClockConfig(CKCU_APBEN1_GPTM0,ENABLE); } else if(GPTMx==GPTM1) { CKCU_APBPerip1ClockConfig(CKCU_APBEN1_GPTM1,ENABLE); } GPTM_DeInit(GPTMx); GPTM_TimeBaseStructure.CounterReload = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值 计数到5000为500ms GPTM_TimeBaseStructure.Prescaler =(7200-1); //设置用来作为TIMx时钟频率除数的预分频值 10Khz的计数频率 GPTM_TimeBaseStructure.PSCReloadTime = GPTM_PSC_RLD_UPDATE;//无事件发生,等待下一次重载//TIM 中断源 GPTM_TimeBaseStructure.CounterMode = GPTM_CNT_MODE_UP; //TIM向上计数模式 GPTM_TimeBaseInit(GPTMx, &GPTM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位 /* TIM IT enable */ GPTM_IntConfig( //使能或者失能指定的TIM中断 GPTMx, //TIMx TIM_IT_Update | //TIM 中断源 TIM_IT_Trigger, //TIM 触发中断源 ENABLE //使能 ); /* Enable the TIMx global Interrupt */ if(GPTMx==GPTM0) { NVIC_SetPriority(GPTM0_IRQn,NVIC_EncodePriority(5,0,3)); NVIC_EnableIRQ(GPTM0_IRQn); GPTM_IntConfig(GPTM0,GPTM_INT_UEV,ENABLE); } else if(GPTMx==GPTM1) { NVIC_SetPriority(GPTM1_IRQn,NVIC_EncodePriority(5,0,3)); NVIC_EnableIRQ(GPTM1_IRQn); GPTM_IntConfig(GPTM1,GPTM_INT_UEV,ENABLE); } /* NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3中断 NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //先占优先级0级 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //从优先级3级 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能 NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器 */ GPTM_Cmd(GPTMx, ENABLE); //使能TIMx外设 }
/******************************************************************************* * @function_name: Config_SystemClock_Priority * @function_file: BT.c * @描述:配置各中断优先级 * @入口参数: * @出口参数: 无 * @Attention: *--------------------------------------------------------- * @修改人: ******************************************************************************/ void Config_SystemClock_Priority(void) { //开启系统定时器,重装载值(时间)为1ms //SysTick_Config(SystemCoreClock/1000); //设置优先级组:抢占式优级(0~3),子优先级(0~3) NVIC_SetPriorityGrouping(5); //设置FRTIM_IRQn抢占优先级为1 NVIC_SetPriority(FRTIM_IRQn,NVIC_EncodePriority(5,0,0)); //设置系统定时器中断抢占优先级为2 NVIC_SetPriority(SysTick_IRQn,NVIC_EncodePriority(5,1,0)); //设置基本定时器7中断抢占优先级为3 NVIC_SetPriority(BTIM0_7_IRQn,NVIC_EncodePriority(5,0,0)); }
/** * @brief . * @param None * @retval None */ void _BSP_NvicInit (void) { #ifdef VECT_TAB_RAM SCB->VTOR = 0X1FFF0000; #else /* VECT_TAB_FLASH */ SCB->VTOR = 0x4000; #endif NVIC_SetPriorityGrouping (5);//抢占式优先级(0~3),亚优先级(0~3) //NVIC_SetPriority(PORTA_IRQn,NVIC_EncodePriority(5,1,0)); NVIC_SetPriority(PIT0_IRQn,NVIC_EncodePriority(5,1,1)); NVIC_SetPriority(UART3_RX_TX_IRQn,NVIC_EncodePriority(5,1,2)); NVIC_SetPriority(SysTick_IRQn,NVIC_EncodePriority(5,1,3)); }
/* * Initialization function which initializes the App internal data * structures to default values. */ void SYSTM002_Init( void) { volatile uint32_t Timer_Status = SYSTM002_TIMER_CONFIGURATION_SUCCESS; /* <<<DD_SYSTM002 _API_1>>> */ /** Initialize the header of the list */ TimerList = NULL; /** Initialize timer tracker */ Timer_Status = SysTick_Config((uint32_t)(SYSTM002_SysTickMicroSec( \ SYSTM002_SYSTICK_INTERVAL))); if(SYSTM002_TIMER_CONFIGURATION_FAILURE == Timer_Status) { DBG002_INFO(APP_GID, DBG002_MESSAGEID_LITERAL, \ sizeof("SYSTM002_Init: Timer reload value out of range"), \ "SYSTM002_Init: Timer reload value out of range"); } else { /** setting of Priority and subpriority value for XMC4000 devices */ #if ((__TARGET_DEVICE__ == XMC44) || (__TARGET_DEVICE__ == XMC42) || \ (__TARGET_DEVICE__ == XMC41) || (__TARGET_DEVICE__ == XMC45)) NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority( \ NVIC_GetPriorityGrouping(),SYSTM002_PRIORITY,SYSTM002_SUBPRIORITY)); /** setting of Priority value for XMC1000 devices */ #elif ((__TARGET_DEVICE__ == XMC11) || (__TARGET_DEVICE__ == XMC12) \ || (__TARGET_DEVICE__ == XMC13)) NVIC_SetPriority(SysTick_IRQn, SYSTM002_PRIORITY); #endif TimerTracker = 0UL; } }
/* * API to initialize the PIN_INTERRUPT APP ERU Event Trigger Logic, Output Gating Unit Hardware initialization * and NVIC node configuration. */ PIN_INTERRUPT_STATUS_t PIN_INTERRUPT_Init(const PIN_INTERRUPT_t *const handle) { XMC_ASSERT("PIN_INTERRUPT_Init: PIN_INTERRUPT APP handle function pointer uninitialized", (handle != NULL)); /* Initializes input pin characteristics */ XMC_GPIO_Init(handle->port, handle->pin, &handle->gpio_config); /* ERU Event Trigger Logic Hardware initialization based on UI */ XMC_ERU_ETL_Init(handle->eru, handle->etl, &handle->etl_config); /* OGU is configured to generate event on configured trigger edge */ XMC_ERU_OGU_SetServiceRequestMode(handle->eru, handle->ogu, XMC_ERU_OGU_SERVICE_REQUEST_ON_TRIGGER); #if (UC_FAMILY == XMC1) /* Configure NVIC node and priority */ NVIC_SetPriority((IRQn_Type)handle->IRQn, handle->irq_priority); #else /* Configure NVIC node, priority and subpriority */ NVIC_SetPriority((IRQn_Type)handle->IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), handle->irq_priority, handle->irq_subpriority)); #endif #if (UC_SERIES == XMC14) XMC_SCU_SetInterruptControl((IRQn_Type)handle->IRQn, (XMC_SCU_IRQCTRL_t)handle->irqctrl); #endif if (true == handle->enable_at_init) { /* Clear pending interrupt before enabling it */ NVIC_ClearPendingIRQ((IRQn_Type)handle->IRQn); /* Enable NVIC node */ NVIC_EnableIRQ((IRQn_Type)handle->IRQn); } return (PIN_INTERRUPT_STATUS_SUCCESS); }
error_t extIntInit(void) { volatile uint32_t status; //Enable PIO peripheral clock PMC->PMC_PCER0 = (1 << ID_PIOD); //Enable pull-up resistor on PHY IRQ pin PIOD->PIO_PUER = PIO_PD28; //Configure the corresponding pin as an input PIOD->PIO_ODR = PIO_PD28; PIOD->PIO_PER = PIO_PD28; //Enable interrupts-on-change PIOD->PIO_IDR = 0xFFFFFFFF; PIOD->PIO_IER = PIO_PD28; //Reset PHY transceiver by asserting NRST pin //RSTC->RSTC_MR = RSTC_MR_KEY(0xA5) | RSTC_MR_ERSTL(4); //RSTC->RSTC_CR = RSTC_CR_KEY(0xA5) | RSTC_CR_EXTRST; //Wait for the reset to complete //while(!(RSTC->RSTC_SR & RSTC_SR_NRSTL)); //Delay before accessing PHY transceiver sleep(10); //Read PIO ISR register to clear any pending interrupt status = PIOD->PIO_ISR; //Configure PIOD interrupt priority NVIC_SetPriority(PIOD_IRQn, NVIC_EncodePriority(3, 15, 0)); //Successful processing return NO_ERROR; }
/* * API to initialize the INTERRUPT APP */ INTERRUPT_STATUS_t INTERRUPT_Init(const INTERRUPT_t *const handler) { XMC_ASSERT("INTERRUPT_Init:HandlePtr NULL", (handler != NULL)); #if(UC_FAMILY == XMC4) NVIC_SetPriority(handler->node, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), handler->priority, handler->subpriority)); if (handler->enable_at_init == true) { INTERRUPT_Enable(handler); } #endif #if(UC_FAMILY == XMC1) NVIC_SetPriority(handler->node, handler->priority); #if (UC_SERIES == XMC14) XMC_SCU_SetInterruptControl((uint8_t)handler->node, (XMC_SCU_IRQCTRL_t)((handler->node << 8) | handler->irqctrl)); #endif /* Enable the interrupt if enable_at_init is enabled */ if (handler->enable_at_init == true) { INTERRUPT_Enable(handler); } #endif return (INTERRUPT_STATUS_SUCCESS); }
/* Function to configure SCU Interrupts based on user configuration. * */ void NVIC_SCU001_Init() { FUNCTION_ENTRY(GID_NVIC_SCU001,NVIC_SCU001_FUNC_ENTRY); NVIC_SetPriority(64, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),63,0)); /* Enable Interrupt */ NVIC_EnableIRQ(64); FUNCTION_EXIT(GID_NVIC_SCU001,NVIC_SCU001_FUNC_EXIT); }
void clock_init( ) { u_long nirq_Priority = 0; current_clock = 0; /* Setup SysTick Timer for 1 msec interrupts */ if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000)) while (1) ; nirq_Priority = NVIC_EncodePriority(INT_SYSTICK_nIRQ_GROUP, INT_SYSTICK_nIRQ_PREP, INT_SYSTICK_nIRQ_SUBP); NVIC_SetPriority(SysTick_IRQn, nirq_Priority); }
/** Function to initialize the NVIC node parameters based on * UI configuration. */ void NVIC002_Init(void) { /*<<<DD_NVIC002_API_1>>>*/ FUNCTION_ENTRY(GID_NVIC002,NVIC002_FUNC_ENTRY); // Set Interrupt Priority for NVIC 5 Node App Instance 0 NVIC_SetPriority(5, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),63,0)); /* Enable Interrupt */ NVIC_EnableIRQ(5); FUNCTION_EXIT(GID_NVIC002,NVIC002_FUNC_EXIT); }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f10x_xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f10x.c file */ /* Initialize LED1..LED4, Key and Wakeup Buttons mounted on STM3210X-EVAL board */ STM_EVAL_LEDInit(LED1); STM_EVAL_LEDInit(LED2); STM_EVAL_LEDInit(LED3); STM_EVAL_LEDInit(LED4); STM_EVAL_PBInit(BUTTON_KEY, BUTTON_MODE_EXTI); STM_EVAL_PBInit(BUTTON_WAKEUP, BUTTON_MODE_EXTI); /* Configure one bit for preemption priority */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); /* Enable the WAKEUP_BUTTON_EXTI_IRQn Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = WAKEUP_BUTTON_EXTI_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = PreemptionPriorityValue; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable the KEY_BUTTON_EXTI_IRQn Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = KEY_BUTTON_EXTI_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Configure the SysTick Handler Priority: Preemption priority and subpriority */ NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), !PreemptionPriorityValue, 0)); while (1) { if(PreemptionOccured != FALSE) { STM_EVAL_LEDToggle(LED1); Delay(0x5FFFF); STM_EVAL_LEDToggle(LED2); Delay(0x5FFFF); STM_EVAL_LEDToggle(LED3); Delay(0x5FFFF); STM_EVAL_LEDToggle(LED4); Delay(0x5FFFF); } } }
/** * @brief Sets the priority of an interrupt. * @param IRQn: External interrupt number. * This parameter can be an enumerator of IRQn_Type enumeration * (For the complete STM32 Devices IRQ Channels list, please refer to the appropriate CMSIS device file (stm32f4xxxx.h)) * @param PreemptPriority: The preemption priority for the IRQn channel. * This parameter can be a value between 0 and 15 * A lower priority value indicates a higher priority * @param SubPriority: the subpriority level for the IRQ channel. * This parameter can be a value between 0 and 15 * A lower priority value indicates a higher priority. * @retval None */ void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority) { uint32_t prioritygroup = 0x00; /* Check the parameters */ assert_param(IS_NVIC_SUB_PRIORITY(SubPriority)); assert_param(IS_NVIC_PREEMPTION_PRIORITY(PreemptPriority)); prioritygroup = NVIC_GetPriorityGrouping(); NVIC_SetPriority(IRQn, NVIC_EncodePriority(prioritygroup, PreemptPriority, SubPriority)); }
/** * @brief Main program * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup files (startup_stm32f40_41xxx.s/startup_stm32f427_437xx.s/startup_stm32f429_439xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f4xx.c file */ /* NVIC configuration ------------------------------------------------------*/ NVIC_Config(); /* Initialize LEDs mounted on EVAL board */ STM_EVAL_LEDInit(LED1); STM_EVAL_LEDInit(LED2); STM_EVAL_LEDInit(LED3); STM_EVAL_LEDInit(LED4); /* Initialize the KEY/Tamper and Wakeup buttons mounted on EVAL board */ STM_EVAL_PBInit(BUTTON_KEY_TAMPER, BUTTON_MODE_EXTI); STM_EVAL_PBInit(BUTTON_WAKEUP, BUTTON_MODE_EXTI); /* Configure the SysTick Handler Priority: Preemption priority and subpriority */ NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), !ubPreemptionPriorityValue, 0)); while (1) { if(ubPreemptionOccurred != 0) { /* Toggle LED1 */ STM_EVAL_LEDToggle(LED1); /* Insert delay Time */ Delay(0x5FFFF); /* Toggle LED2 */ STM_EVAL_LEDToggle(LED2); Delay(0x5FFFF); /* Toggle LED3 */ STM_EVAL_LEDToggle(LED3); Delay(0x5FFFF); /* Toggle LED4 */ STM_EVAL_LEDToggle(LED4); Delay(0x5FFFF); } } }
void ConfigZeroCross_NVIC() { //NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); ZeroCross_VectorPrior.NVIC_IRQChannel = EXTI15_10_IRQn; ZeroCross_VectorPrior.NVIC_IRQChannelPreemptionPriority = 15; ZeroCross_VectorPrior.NVIC_IRQChannelSubPriority = 0; ZeroCross_VectorPrior.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&ZeroCross_VectorPrior); NVIC_SetPriority(EXTI15_10_IRQn, NVIC_EncodePriority(4,15,0)); }
void setISRPriorities() { __disable_irq(); // set two bits for preemptive data, two bits for priority as the // structure for the IPRs. Grouping is global withing the IPRs so // this value should only be changed here. NVIC_SetPriorityGrouping(5); uint32_t priorityGrouping = NVIC_GetPriorityGrouping(); // set preemptive priority default to 2 (0..3) // set priority default to 1 (0..3) uint32_t defaultPriority = NVIC_EncodePriority(priorityGrouping, 2, 1); // When the kernel initialzes the PNVIC, all ISRs are set to the // highest priority, making it impossible to elevate a few over // the rest, so the default priority is lowered globally for the // table first. // // Consult LPC17xx.h under IRQn_Type for PNVIC ranges, this is LPC1768 // specific for (uint32_t IRQn = TIMER0_IRQn; IRQn <= CANActivity_IRQn; IRQn++) NVIC_SetPriority((IRQn_Type)IRQn, defaultPriority); // reestablish watchdog NVIC_SetPriority(WDT_IRQn, NVIC_EncodePriority(priorityGrouping, 0, 0)); // make TIMER #2 2nd in line t the watchdog timer NVIC_SetPriority(TIMER2_IRQn, NVIC_EncodePriority(priorityGrouping, 0, 1)); // this is the timer used in the mbed Ticker library NVIC_SetPriority(TIMER3_IRQn, NVIC_EncodePriority(priorityGrouping, 0, 2)); // Brown-Out Detect NVIC_SetPriority(BOD_IRQn, NVIC_EncodePriority(priorityGrouping, 0, 4)); // The I2C interface that's in use NVIC_SetPriority(I2C2_IRQn, NVIC_EncodePriority(priorityGrouping, 1, 1)); // The SPI interface that's in use. NVIC_SetPriority(SPI_IRQn, NVIC_EncodePriority(priorityGrouping, 1, 2)); // set UART (console) interrupts to minimal priority // when debugging radio and other time sensitive operations, this // interrupt will need to be deferred. NVIC_SetPriority(UART0_IRQn, NVIC_EncodePriority(priorityGrouping, 1, 4)); __enable_irq(); }
error_t a2fxxxm3EthInit(NetInterface *interface) { error_t error; //Debug message TRACE_INFO("Initializing A2FxxxM3 Ethernet MAC...\r\n"); //Save underlying network interface nicDriverInterface = interface; //Perform a software reset MAC->CSR0 |= CSR0_SWR_MASK; //Wait for the reset to complete while(MAC->CSR0 & CSR0_SWR_MASK); //PHY transceiver initialization error = interface->phyDriver->init(interface); //Failed to initialize PHY transceiver? if(error) return error; //Enable store and forward mode MAC->CSR6 |= CSR6_SF_MASK; //Initialize DMA descriptor lists a2fxxxm3EthInitDmaDesc(interface); //Enable the desired Ethernet interrupts MAC->CSR7 |= CSR7_NIE_MASK | CSR7_RIE_MASK | CSR7_TIE_MASK; //Set priority grouping (5 bits for pre-emption priority, no bits for subpriority) NVIC_SetPriorityGrouping(A2FXXXM3_ETH_IRQ_PRIORITY_GROUPING); //Configure Ethernet interrupt priority NVIC_SetPriority(EthernetMAC_IRQn, NVIC_EncodePriority(A2FXXXM3_ETH_IRQ_PRIORITY_GROUPING, A2FXXXM3_ETH_IRQ_GROUP_PRIORITY, A2FXXXM3_ETH_IRQ_SUB_PRIORITY)); //Enable transmission and reception MAC->CSR6 |= CSR6_ST_MASK | CSR6_SR_MASK; //Set MAC address error = a2fxxxm3EthSendSetup(interface); //Any error to report? if(error) return error; //Accept any packets from the upper layer osSetEvent(&interface->nicTxEvent); //Successful initialization return NO_ERROR; }
/* * Initialization function which initializes the SYSTIMER APP, configures SysTick timer and SysTick exception. */ SYSTIMER_STATUS_t SYSTIMER_Init(SYSTIMER_t *handle) { SYSTIMER_STATUS_t status = SYSTIMER_STATUS_SUCCESS; XMC_ASSERT("SYSTIMER_Init: SYSTIMER APP handle pointer uninitialized", (handle != NULL)); /* Check APP initialization status to ensure whether SYSTIMER_Init called or not, initialize SYSTIMER if * SYSTIMER_Init called first time. */ if (false == handle->init_status) { #if (UC_FAMILY == XMC4) /* Initialization of CPU_CTRL_XMC4 APP */ status = (SYSTIMER_STATUS_t)CPU_CTRL_XMC4_Init(CPU_CTRL_HANDLE); #else /* Initialization of CPU_CTRL_XMC1 APP */ status = (SYSTIMER_STATUS_t)CPU_CTRL_XMC1_Init(CPU_CTRL_HANDLE); #endif if (SYSTIMER_STATUS_FAILURE != status) { /* Initialize the header of the list */ g_timer_list = NULL; /* Initialize SysTick timer */ status = (SYSTIMER_STATUS_t)SysTick_Config((uint32_t)(SYSTIMER_SYSTICK_CLOCK * SYSTIMER_TICK_PERIOD)); if (SYSTIMER_STATUS_FAILURE == status) { XMC_DEBUG("SYSTIMER_Init: Timer reload value out of range"); } else { #if (UC_FAMILY == XMC4) /* setting of First SW Timer period is always and subpriority value for XMC4000 devices */ NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority( NVIC_GetPriorityGrouping(), SYSTIMER_PRIORITY, SYSTIMER_SUBPRIORITY)); #elif (UC_FAMILY == XMC1) /* setting of priority value for XMC1000 devices */ NVIC_SetPriority(SysTick_IRQn, SYSTIMER_PRIORITY); #endif g_timer_tracker = 0U; /* Update the Initialization status of the SYSTIMER APP instance */ handle->init_status = true; status = SYSTIMER_STATUS_SUCCESS; } } } return (status); }
/*Channel initialization function*/ UART_STATUS_t TempUart_init() { UART_STATUS_t status = UART_STATUS_SUCCESS; /*Configure Receive pin*/ XMC_GPIO_Init((XMC_GPIO_PORT_t *)PORT5_BASE, 0U, &TempUart_rx_pin_config); /* Initialize USIC channel in UART mode*/ XMC_UART_CH_Init(XMC_UART0_CH0, &TempUart_channel_config); /*Set input source path*/ XMC_USIC_CH_SetInputSource(XMC_UART0_CH0, XMC_USIC_CH_INPUT_DX0, 3U); /* Start UART */ XMC_UART_CH_Start(XMC_UART0_CH0); /* Initialize UART TX pin */ XMC_GPIO_Init((XMC_GPIO_PORT_t *)PORT5_BASE, 1U, &TempUart_tx_pin_config); /*Set service request for transmit interrupt*/ XMC_USIC_CH_SetInterruptNodePointer(XMC_UART0_CH0, XMC_USIC_CH_INTERRUPT_NODE_POINTER_TRANSMIT_BUFFER, 3U); /*Set service request for receive interrupt*/ XMC_USIC_CH_SetInterruptNodePointer(XMC_UART0_CH0, XMC_USIC_CH_INTERRUPT_NODE_POINTER_RECEIVE, 5U); XMC_USIC_CH_SetInterruptNodePointer(XMC_UART0_CH0, XMC_USIC_CH_INTERRUPT_NODE_POINTER_ALTERNATE_RECEIVE, 5U); /*Set service request for UART protocol events*/ XMC_USIC_CH_SetInterruptNodePointer(XMC_UART0_CH0, XMC_USIC_CH_INTERRUPT_NODE_POINTER_PROTOCOL, 0U); /*Set priority and enable NVIC node for transmit interrupt*/ NVIC_SetPriority((IRQn_Type)87, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 18U, 0U)); NVIC_EnableIRQ((IRQn_Type)87); /*Set priority and enable NVIC node for receive interrupt*/ NVIC_SetPriority((IRQn_Type)89, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 18U, 0U)); NVIC_EnableIRQ((IRQn_Type)89); return status; }
/** * @brief Main program. * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f10x_xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f10x.c file */ /* NVIC configuration ------------------------------------------------------*/ NVIC_Config(); /* Initialize LED1..LED4, Key and Sel Joystick Buttons mounted on STM3210X-EVAL board */ STM_EVAL_LEDInit(LED1); STM_EVAL_LEDInit(LED2); STM_EVAL_LEDInit(LED3); STM_EVAL_LEDInit(LED4); STM_EVAL_PBInit(BUTTON_KEY, BUTTON_MODE_EXTI); STM_EVAL_PBInit(BUTTON_WAKEUP, BUTTON_MODE_EXTI); /* Configure the SysTick Handler Priority: Preemption priority and subpriority */ NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), !PreemptionPriorityValue, 0)); while (1) { if(PreemptionOccured != 0) { /* Toggel The lED1 */ STM_EVAL_LEDToggle(LED1); /* Insert delay Time */ Delay(0x5FFFF); STM_EVAL_LEDToggle(LED2); Delay(0x5FFFF); STM_EVAL_LEDToggle(LED3); Delay(0x5FFFF); STM_EVAL_LEDToggle(LED4); Delay(0x5FFFF); } } }
/** * @brief Configures NVIC. * @param None * @retval None */ void NVIC_Configuration(void) { NVIC_InitTypeDef NVIC_InitStructure; /* 1 bits for pre-emption priority and 3 bits for subpriority */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); /* Set Button EXTI Interrupt priority to 0 (highest) */ NVIC_SetPriority(KEY_BUTTON_EXTI_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),0,0)); /* Set WWDG interrupt vector Preemption Priority to 1 */ NVIC_InitStructure.NVIC_IRQChannel = WWDG_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }
static void stm32f4_adc_dma_init(ADC_HandleTypeDef* hadc) { DMA_HandleTypeDef *hdma; assert(hadc); hdma = hadc->DMA_Handle; stm32f4_adc_clk_enable(hadc); __HAL_RCC_DMA2_CLK_ENABLE(); HAL_DMA_Init(hdma); dma_handle[stm32f4_resolve_dma_handle_idx(hdma)] = hdma; NVIC_SetPriority(stm32f4_resolve_adc_dma_irq(hdma), NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 0, 0)); NVIC_SetVector(stm32f4_resolve_adc_dma_irq(hdma), stm32f4_resolve_adc_dma_irq_handler(hdma)); NVIC_EnableIRQ(stm32f4_resolve_adc_dma_irq(hdma)); }
/** * @brief This function handles External lines 15 to 10 interrupt request. * @param None * @retval None */ void EXTI15_10_IRQHandler(void) { NVIC_InitTypeDef NVIC_InitStructure; if(EXTI_GetITStatus(KEY_BUTTON_EXTI_LINE) != RESET) { PreemptionPriorityValue = !PreemptionPriorityValue; PreemptionOccured = 0; /* Modify the WAKEUP_BUTTON_EXTI_IRQn Interrupt Preemption Priority */ NVIC_InitStructure.NVIC_IRQChannel = WAKEUP_BUTTON_EXTI_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = PreemptionPriorityValue; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Configure the SysTick Handler Priority: Preemption priority and subpriority */ NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), !PreemptionPriorityValue, 0)); /* Clear KEY_BUTTON_EXTI_LINE pending bit */ EXTI_ClearITPendingBit(KEY_BUTTON_EXTI_LINE); } }
//IRQ priority init helper functions void IRQ_priority_init(IRQn_Type IRQn, U8 P1, U8 P2){ NVIC_SetPriority(IRQn, NVIC_EncodePriority(IRQ_priority_grouping, P1, P2)); }
error_t samv71EthInit(NetInterface *interface) { error_t error; volatile uint32_t status; //Debug message TRACE_INFO("Initializing SAMV71 Ethernet MAC...\r\n"); //Save underlying network interface nicDriverInterface = interface; //Enable GMAC peripheral clock PMC->PMC_PCER1 = (1 << (ID_GMAC - 32)); //GPIO configuration samv71EthInitGpio(interface); //Configure MDC clock speed GMAC->GMAC_NCFGR = GMAC_NCFGR_CLK_MCK_96; //Enable management port (MDC and MDIO) GMAC->GMAC_NCR |= GMAC_NCR_MPE; //PHY transceiver initialization error = interface->phyDriver->init(interface); //Failed to initialize PHY transceiver? if(error) return error; //Set the MAC address GMAC->GMAC_SA[0].GMAC_SAB = interface->macAddr.w[0] | (interface->macAddr.w[1] << 16); GMAC->GMAC_SA[0].GMAC_SAT = interface->macAddr.w[2]; //Configure the receive filter GMAC->GMAC_NCFGR |= GMAC_NCFGR_UNIHEN | GMAC_NCFGR_MTIHEN; //DMA configuration GMAC->GMAC_DCFGR = GMAC_DCFGR_DRBS(SAMV71_ETH_RX_BUFFER_SIZE / 64) | GMAC_DCFGR_TXPBMS | GMAC_DCFGR_RXBMS_FULL | GMAC_DCFGR_FBLDO_INCR4; GMAC->GMAC_RBSRPQ[0] = GMAC_RBSRPQ_RBS(SAMV71_ETH_DUMMY_BUFFER_SIZE / 64); GMAC->GMAC_RBSRPQ[1] = GMAC_RBSRPQ_RBS(SAMV71_ETH_DUMMY_BUFFER_SIZE / 64); GMAC->GMAC_RBSRPQ[2] = GMAC_RBSRPQ_RBS(SAMV71_ETH_DUMMY_BUFFER_SIZE / 64); //Initialize hash table GMAC->GMAC_HRB = 0; GMAC->GMAC_HRT = 0; //Initialize buffer descriptors samv71EthInitBufferDesc(interface); //Clear transmit status register GMAC->GMAC_TSR = GMAC_TSR_HRESP | GMAC_TSR_TXCOMP | GMAC_TSR_TFC | GMAC_TSR_TXGO | GMAC_TSR_RLE | GMAC_TSR_COL | GMAC_TSR_UBR; //Clear receive status register GMAC->GMAC_RSR = GMAC_RSR_HNO | GMAC_RSR_RXOVR | GMAC_RSR_REC | GMAC_RSR_BNA; //First disable all GMAC interrupts GMAC->GMAC_IDR = 0xFFFFFFFF; GMAC->GMAC_IDRPQ[0] = 0xFFFFFFFF; GMAC->GMAC_IDRPQ[1] = 0xFFFFFFFF; GMAC->GMAC_IDRPQ[2] = 0xFFFFFFFF; //Only the desired ones are enabled GMAC->GMAC_IER = GMAC_IER_HRESP | GMAC_IER_ROVR | GMAC_IER_TCOMP | GMAC_IER_TFC | GMAC_IER_RLEX | GMAC_IER_TUR | GMAC_IER_RXUBR | GMAC_IER_RCOMP; //Read GMAC ISR register to clear any pending interrupt status = GMAC->GMAC_ISR; //Set priority grouping (4 bits for pre-emption priority, no bits for subpriority) NVIC_SetPriorityGrouping(SAMV71_ETH_IRQ_PRIORITY_GROUPING); //Configure GMAC interrupt priority NVIC_SetPriority(GMAC_IRQn, NVIC_EncodePriority(SAMV71_ETH_IRQ_PRIORITY_GROUPING, SAMV71_ETH_IRQ_GROUP_PRIORITY, SAMV71_ETH_IRQ_SUB_PRIORITY)); //Enable the GMAC to transmit and receive data GMAC->GMAC_NCR |= GMAC_NCR_TXEN | GMAC_NCR_RXEN; //Force the TCP/IP stack to check the link state osSetEvent(&interface->nicRxEvent); //SAMV71 Ethernet MAC is now ready to send osSetEvent(&interface->nicTxEvent); //Successful initialization return NO_ERROR; }
/** * @brief Initializes SDRAM MSP. * @param hsdram: SDRAM handle * @param Params * @retval None */ static void BSP_SDRAM_MspInit(SDRAM_HandleTypeDef *hsdram) { static DMA_HandleTypeDef dma_handle; #if !GFX_USE_OS_CHIBIOS GPIO_InitTypeDef gpio_init_structure; #endif /* Enable FMC clock */ __HAL_RCC_FMC_CLK_ENABLE(); /* Enable chosen DMAx clock */ __DMAx_CLK_ENABLE(); /* Enable GPIOs clock */ __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); __HAL_RCC_GPIOH_CLK_ENABLE(); /* Common GPIO configuration - some are already setup by ChibiOS Init */ #if !GFX_USE_OS_CHIBIOS gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Speed = GPIO_SPEED_FAST; gpio_init_structure.Alternate = GPIO_AF12_FMC; /* GPIOC configuration */ gpio_init_structure.Pin = GPIO_PIN_3; HAL_GPIO_Init(GPIOC, &gpio_init_structure); /* GPIOD configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOD, &gpio_init_structure); /* GPIOE configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_7| GPIO_PIN_8 | GPIO_PIN_9 |\ GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOE, &gpio_init_structure); /* GPIOF configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 | GPIO_PIN_4 |\ GPIO_PIN_5 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOF, &gpio_init_structure); /* GPIOG configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4| GPIO_PIN_5 | GPIO_PIN_8 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOG, &gpio_init_structure); /* GPIOH configuration */ gpio_init_structure.Pin = GPIO_PIN_3 | GPIO_PIN_5; HAL_GPIO_Init(GPIOH, &gpio_init_structure); #endif /* Configure common DMA parameters */ dma_handle.Init.Channel = SDRAM_DMAx_CHANNEL; dma_handle.Init.Direction = DMA_MEMORY_TO_MEMORY; dma_handle.Init.PeriphInc = DMA_PINC_ENABLE; dma_handle.Init.MemInc = DMA_MINC_ENABLE; dma_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_handle.Init.Mode = DMA_NORMAL; dma_handle.Init.Priority = DMA_PRIORITY_HIGH; dma_handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; dma_handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_handle.Init.MemBurst = DMA_MBURST_SINGLE; dma_handle.Init.PeriphBurst = DMA_PBURST_SINGLE; dma_handle.Instance = SDRAM_DMAx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsdram, hdma, dma_handle); /* Deinitialize the stream for new transfer */ _HAL_DMA_DeInit(&dma_handle); /* Configure the DMA stream */ _HAL_DMA_Init(&dma_handle); /* NVIC configuration for DMA transfer complete interrupt */ NVIC_SetPriority(SDRAM_DMAx_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0)); /* Enable interrupt */ NVIC_EnableIRQ(SDRAM_DMAx_IRQn); }
void _start(void) { /* copy data from rom */ if (&__data_start != &__data_start_rom) { unsigned int *src = &__data_start_rom; unsigned int *dest = &__data_start; while (dest != &__data_end) *dest++ = *src++; } /* zero out bss */ unsigned int *bss = &__bss_start; while (bss != &__bss_end) *bss++ = 0; USART_TypeDef *debug_usart; #if TARGET_STM3210E /* configure the usart1 pins */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); GPIO_PinRemapConfig(GPIO_Remap_USART1, DISABLE); GPIO_InitTypeDef init; init.GPIO_Pin = GPIO_Pin_9; init.GPIO_Speed = GPIO_Speed_50MHz; init.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &init); init.GPIO_Pin = GPIO_Pin_10; init.GPIO_Speed = GPIO_Speed_50MHz; init.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &init); debug_usart = USART1; #endif #if TARGET_STM32_P107 /* configure the usart3 pins */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); GPIO_PinRemapConfig(GPIO_FullRemap_USART3, ENABLE); GPIO_InitTypeDef init; init.GPIO_Pin = GPIO_Pin_8; init.GPIO_Speed = GPIO_Speed_50MHz; init.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOD, &init); init.GPIO_Pin = GPIO_Pin_9; init.GPIO_Speed = GPIO_Speed_50MHz; init.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOD, &init); debug_usart = USART3; #endif init_leds(); usart_init(debug_usart); printf("how are you gentlemen\n"); printf("devid 0x%x\n", DBGMCU_GetDEVID()); dump_clocks(); // bring up te HSE printf("enabling external crystal\n"); RCC_HSEConfig(RCC_HSE_ON); RCC_WaitForHSEStartUp(); printf("external crystal up\n"); // try to program up the pll printf("enabling pll\n"); #if STM32F10X_CL RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_4); #else RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9); #endif RCC_PLLCmd(ENABLE); while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) ; printf("pll latched\n"); printf("setting up clocks\n"); FLASH_SetLatency(FLASH_Latency_2); RCC_HCLKConfig(RCC_SYSCLK_Div1); RCC_PCLK1Config(RCC_HCLK_Div2); RCC_PCLK2Config(RCC_HCLK_Div1); #if STM32F10X_CL RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE); #else RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); #endif usart_init(debug_usart); set_led(3, 0); set_led(3, 1); printf("after new sysclk\n"); dump_clocks(); printf("done!\n"); /* try to fire the systick */ // __set_BASEPRI(8 << __NVIC_PRIO_BITS); /* start the systick timer */ NVIC_SetVectorTable(0, 0); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); uint32_t pri = NVIC_EncodePriority(3, 0, 0); NVIC_SetPriority(SysTick_IRQn, pri); SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK); SysTick_Config(systick_counter); #if 0 uint32_t last = 0; for (;;) { uint32_t now = current_time(); if (now - last >= 1000000) { printf("time %d\n", now); last = now; } } #endif #if 0 uint32_t val; for (val = 0; ; val++) { set_led(0, val & 0x1); set_led(1, val & 0x2); set_led(2, val & 0x4); set_led(3, val & 0x8); } #endif /* write the boot sequence */ led_panel_command_write(0b100000000010, 12); // SYS_EN led_panel_command_write(0b100000000110, 12); // LED_ON led_panel_command_write(0b100000010000, 12); // BLINK_OFF led_panel_command_write(0b100000110000, 12); // INT_RC led_panel_command_write(0b100001001000, 12); // n-mos open drain, 16 com led_panel_command_write(0b100101011110, 12); // PWM_CTRL | 0xf for(uint j = 0; ; j++) { GPIO_ResetBits(GPIOF, LED_CS); led_panel_write(0b1010000000, 10); // start write at address 0 for (int i = 0; i < 96; i++) { led_panel_write(((j % 96) > i) ? 0b1111: 0, 4); } GPIO_SetBits(GPIOF, LED_CS); spin(10000); } for(;;) ; }
// Set up all timer interrupts void HAL::setupTimer() { uint32_t tc_count, tc_clock; pmc_set_writeprotect(false); // set 3 bits for interrupt group priority, 1 bits for sub-priority NVIC_SetPriorityGrouping(4); #if USE_ADVANCE // Timer for extruder control pmc_enable_periph_clk(EXTRUDER_TIMER_IRQ); // enable power to timer NVIC_SetPriority((IRQn_Type)EXTRUDER_TIMER_IRQ, NVIC_EncodePriority(4, 4, 1)); // count up to value in RC register using given clock TC_Configure(EXTRUDER_TIMER, EXTRUDER_TIMER_CHANNEL, TC_CMR_WAVSEL_UP_RC | TC_CMR_WAVE | TC_CMR_TCCLKS_TIMER_CLOCK4); TC_SetRC(EXTRUDER_TIMER, EXTRUDER_TIMER_CHANNEL, (F_CPU_TRUE / TIMER0_PRESCALE) / EXTRUDER_CLOCK_FREQ); // set frequency TC_Start(EXTRUDER_TIMER, EXTRUDER_TIMER_CHANNEL); // start timer running // enable RC compare interrupt EXTRUDER_TIMER->TC_CHANNEL[EXTRUDER_TIMER_CHANNEL].TC_IER = TC_IER_CPCS; // clear the "disable RC compare" interrupt EXTRUDER_TIMER->TC_CHANNEL[EXTRUDER_TIMER_CHANNEL].TC_IDR = ~TC_IER_CPCS; // allow interrupts on timer NVIC_EnableIRQ((IRQn_Type)EXTRUDER_TIMER_IRQ); #endif // Regular interrupts for heater control etc pmc_enable_periph_clk(PWM_TIMER_IRQ); NVIC_SetPriority((IRQn_Type)PWM_TIMER_IRQ, NVIC_EncodePriority(4, 6, 0)); TC_FindMckDivisor(PWM_CLOCK_FREQ, F_CPU_TRUE, &tc_count, &tc_clock, F_CPU_TRUE); TC_Configure(PWM_TIMER, PWM_TIMER_CHANNEL, TC_CMR_WAVSEL_UP_RC | TC_CMR_WAVE | tc_clock); TC_SetRC(PWM_TIMER, PWM_TIMER_CHANNEL, (F_CPU_TRUE / tc_count) / PWM_CLOCK_FREQ); TC_Start(PWM_TIMER, PWM_TIMER_CHANNEL); PWM_TIMER->TC_CHANNEL[PWM_TIMER_CHANNEL].TC_IER = TC_IER_CPCS; PWM_TIMER->TC_CHANNEL[PWM_TIMER_CHANNEL].TC_IDR = ~TC_IER_CPCS; NVIC_EnableIRQ((IRQn_Type)PWM_TIMER_IRQ); // Timer for stepper motor control pmc_enable_periph_clk(TIMER1_TIMER_IRQ ); NVIC_SetPriority((IRQn_Type)TIMER1_TIMER_IRQ, NVIC_EncodePriority(4, 4, 0)); TC_Configure(TIMER1_TIMER, TIMER1_TIMER_CHANNEL, TC_CMR_WAVSEL_UP_RC | TC_CMR_WAVE | TC_CMR_TCCLKS_TIMER_CLOCK1); TC_SetRC(TIMER1_TIMER, TIMER1_TIMER_CHANNEL, (F_CPU_TRUE / TIMER1_PRESCALE) / TIMER1_CLOCK_FREQ); TC_Start(TIMER1_TIMER, TIMER1_TIMER_CHANNEL); TIMER1_TIMER->TC_CHANNEL[TIMER1_TIMER_CHANNEL].TC_IER = TC_IER_CPCS; TIMER1_TIMER->TC_CHANNEL[TIMER1_TIMER_CHANNEL].TC_IDR = ~TC_IER_CPCS; NVIC_EnableIRQ((IRQn_Type)TIMER1_TIMER_IRQ); // Servo control #if FEATURE_SERVO #if SERVO0_PIN > -1 SET_OUTPUT(SERVO0_PIN); WRITE(SERVO0_PIN,LOW); #endif #if SERVO1_PIN > -1 SET_OUTPUT(SERVO1_PIN); WRITE(SERVO1_PIN,LOW); #endif #if SERVO2_PIN > -1 SET_OUTPUT(SERVO2_PIN); WRITE(SERVO2_PIN,LOW); #endif #if SERVO3_PIN > -1 SET_OUTPUT(SERVO3_PIN); WRITE(SERVO3_PIN,LOW); #endif pmc_enable_periph_clk(SERVO_TIMER_IRQ ); NVIC_SetPriority((IRQn_Type)SERVO_TIMER_IRQ, NVIC_EncodePriority(4, 5, 0)); TC_Configure(SERVO_TIMER, SERVO_TIMER_CHANNEL, TC_CMR_WAVSEL_UP_RC | TC_CMR_WAVE | TC_CMR_TCCLKS_TIMER_CLOCK1); TC_SetRC(SERVO_TIMER, SERVO_TIMER_CHANNEL, (F_CPU_TRUE / SERVO_PRESCALE) / SERVO_CLOCK_FREQ); TC_Start(SERVO_TIMER, SERVO_TIMER_CHANNEL); SERVO_TIMER->TC_CHANNEL[SERVO_TIMER_CHANNEL].TC_IER = TC_IER_CPCS; SERVO_TIMER->TC_CHANNEL[SERVO_TIMER_CHANNEL].TC_IDR = ~TC_IER_CPCS; NVIC_EnableIRQ((IRQn_Type)SERVO_TIMER_IRQ); #endif }
void setup(){ // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); // 0 bits for preemption, 4 bits for subpriority /* Set up interrupt controller: 2 bits for priority (0-3), * 2 bits for sub-priority (0-3). Priorities control which * interrupts are allowed to preempt one another. */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); /* Increase SysTick priority to be higher than USB interrupt * priority. USB code stalls inside interrupt and we can't let * this throw off the SysTick timer. */ NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, SYSTICK_PRIORITY, SYSTICK_SUBPRIORITY)); NVIC_SetPriority(DMA1_Stream3_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, 0, 0)); NVIC_SetPriority(DMA1_Stream4_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, 0, 0)); NVIC_SetPriority(SPI2_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, 1, 0)); NVIC_SetPriority(ADC_IRQn, NVIC_EncodePriority(NVIC_PriorityGroup_2, 2, 0)); ledSetup(); setLed(RED); /* check if we need to DFU boot */ configureDigitalInput(SWITCH_B_PORT, SWITCH_B_PIN, GPIO_PuPd_UP); if(isPushButtonPressed()) jump_to_bootloader(); adcSetup(); clockSetup(); setupSwitchA(footSwitchCallback); setupSwitchB(pushButtonCallback); settings.init(); midi.init(MIDI_CHANNEL); patches.init(); #ifdef EXPRESSION_PEDAL #ifndef OWLMODULAR setupExpressionPedal(); #endif #endif RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); // DEBUG configureDigitalOutput(GPIOB, GPIO_Pin_1); // PB1, DEBUG LED debugClear(); #ifdef DEBUG_AUDIO RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); // DEBUG configureDigitalOutput(GPIOA, GPIO_Pin_7); // PA7 DEBUG configureDigitalOutput(GPIOC, GPIO_Pin_5); // PC5 DEBUG clearPin(GPIOC, GPIO_Pin_5); // DEBUG clearPin(GPIOA, GPIO_Pin_7); // DEBUG #endif /* DEBUG_AUDIO */ usb_init(); #if SERIAL_PORT == 1 setupSerialPort1(115200); #elif SERIAL_PORT == 2 setupSerialPort2(115200); // expression pedal #warning expression pedal jack configured as serial port #ifdef EXPRESSION_PEDAL #error invalid configuration #endif #endif #ifdef OWLMODULAR configureDigitalInput(GPIOB, GPIO_Pin_6, GPIO_PuPd_NOPULL); // PB6 OWL Modular digital input configureDigitalOutput(GPIOB, GPIO_Pin_7); // PB7 OWL Modular digital output setPin(GPIOB, GPIO_Pin_7); // PB7 OWL Modular digital output #endif codec.setup(); codec.init(settings); printString("startup\n"); updateBypassMode(); codec.start(); }