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();
}
