/** * @brief Configures the CAN. * @param None * @retval None */ static void CAN_Config(void) { GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; CAN_InitTypeDef CAN_InitStructure; CAN_FilterInitTypeDef CAN_FilterInitStructure; /* CAN GPIOs configuration **************************************************/ /* Enable GPIO clock */ RCC_AHBPeriphClockCmd(CAN_GPIO_CLK, ENABLE); /* Connect CAN pins to AF7 */ GPIO_PinAFConfig(CAN_GPIO_PORT, CAN_RX_SOURCE, CAN_AF_PORT); GPIO_PinAFConfig(CAN_GPIO_PORT, CAN_TX_SOURCE, CAN_AF_PORT); /* Configure CAN RX and TX pins */ GPIO_InitStructure.GPIO_Pin = CAN_RX_PIN | CAN_TX_PIN; 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(CAN_GPIO_PORT, &GPIO_InitStructure); /* NVIC configuration *******************************************************/ NVIC_InitStructure.NVIC_IRQChannel = CEC_CAN_IRQn; NVIC_InitStructure.NVIC_IRQChannelPriority = 0x0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* CAN configuration ********************************************************/ /* Enable CAN clock */ RCC_APB1PeriphClockCmd(CAN_CLK, ENABLE); /* CAN register init */ CAN_DeInit(CANx); CAN_StructInit(&CAN_InitStructure); /* CAN cell init */ CAN_InitStructure.CAN_TTCM = DISABLE; CAN_InitStructure.CAN_ABOM = DISABLE; CAN_InitStructure.CAN_AWUM = DISABLE; CAN_InitStructure.CAN_NART = DISABLE; CAN_InitStructure.CAN_RFLM = DISABLE; CAN_InitStructure.CAN_TXFP = DISABLE; CAN_InitStructure.CAN_Mode = CAN_Mode_Normal; CAN_InitStructure.CAN_SJW = CAN_SJW_1tq; /* CAN Baudrate = 1MBps (CAN clocked at 36 MHz) */ CAN_InitStructure.CAN_BS1 = CAN_BS1_9tq; CAN_InitStructure.CAN_BS2 = CAN_BS2_8tq; CAN_InitStructure.CAN_Prescaler = 2; CAN_Init(CANx, &CAN_InitStructure); /* CAN filter init */ CAN_FilterInitStructure.CAN_FilterNumber = 0; CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit; CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000; CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000; CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000; CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000; CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0; CAN_FilterInitStructure.CAN_FilterActivation = ENABLE; CAN_FilterInit(&CAN_FilterInitStructure); /* Transmit Structure preparation */ TxMessage.StdId = 0x321; TxMessage.ExtId = 0x01; TxMessage.RTR = CAN_RTR_DATA; TxMessage.IDE = CAN_ID_STD; TxMessage.DLC = 1; /* Enable FIFO 0 message pending Interrupt */ CAN_ITConfig(CANx, CAN_IT_FMP0, ENABLE); }
void GpioMcuSetInterrupt( Gpio_t *obj, IrqModes irqMode, IrqPriorities irqPriority, GpioIrqHandler *irqHandler ) { NVIC_InitTypeDef NVIC_InitStructure; EXTI_InitTypeDef EXTI_InitStructure; if( irqHandler == NULL ) { return; } GpioIrq[obj->pin & 0x0F] = irqHandler; /* Enable SYSCFG clock */ RCC_APB2PeriphClockCmd( RCC_APB2Periph_SYSCFG, ENABLE ); /* Connect EXTI Line to GPIO pin */ SYSCFG_EXTILineConfig( obj->portIndex, ( ( obj->pin ) & 0x0F ) ); /* Configure EXTI line */ EXTI_InitStructure.EXTI_Line = ( 0x01 << ( obj->pin & 0x0F ) ); printf("PIN : %x and EXTI line %x \n", obj->pin & 0x0F , EXTI_InitStructure.EXTI_Line); EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; if( irqMode == IRQ_RISING_EDGE ) { EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; } else if( irqMode == IRQ_FALLING_EDGE ) { EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; } else if( irqMode == IRQ_RISING_FALLING_EDGE ) { EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling; } else { while( 1 ); } EXTI_InitStructure.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStructure); if( ( ( obj->pin ) & 0x0F ) < 5 ) { NVIC_InitStructure.NVIC_IRQChannel = ( ( obj->pin ) & 0x0F ) + 6; } else if( ( ( obj->pin ) & 0x0F ) < 10 ) { NVIC_InitStructure.NVIC_IRQChannel = 23; } else if( ( ( obj->pin ) & 0x0F ) < 16 ) { NVIC_InitStructure.NVIC_IRQChannel = 40; } else { while( 1 ); } if( irqPriority == IRQ_VERY_LOW_PRIORITY ) { NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 15; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; } else if( irqPriority == IRQ_LOW_PRIORITY ) { NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 12; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; } else if( irqPriority == IRQ_MEDIUM_PRIORITY ) { NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 8; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; } else if( irqPriority == IRQ_HIGH_PRIORITY ) { NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 4; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; } else if( irqPriority == IRQ_VERY_HIGH_PRIORITY ) { NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; } else { while( 1 ); } NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init( &NVIC_InitStructure ); }
void TIM_Configuration(void) { TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_OCInitTypeDef TIM_OCInitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6 | RCC_APB1Periph_TIM7 | RCC_APB1Periph_TIM2, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); /* Enable the TIM6 global Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = TIM6_DAC_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); //============================================================================== TIM_DeInit(TIM1); /* Time base configuration */ TIM_TimeBaseStructure.TIM_Period = 2999; TIM_TimeBaseStructure.TIM_Prescaler = 7; TIM_TimeBaseStructure.TIM_ClockDivision = 0x00; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* Channel 1, 2, 3 Configuration in PWM mode */ TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse = 0; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC1Init(TIM1, &TIM_OCInitStructure); TIM_OC2Init(TIM1, &TIM_OCInitStructure); TIM_OC3Init(TIM1, &TIM_OCInitStructure); /* TIM3 Enable */ TIM_Cmd(TIM1, ENABLE); TIM_CtrlPWMOutputs(TIM1, ENABLE); //============================================================================== /* Time base configuration */ TIM_TimeBaseStructure.TIM_Period = 10; TIM_TimeBaseStructure.TIM_Prescaler = 2399; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM6, &TIM_TimeBaseStructure); /* Clear TIM2 update pending flags */ TIM_ClearFlag(TIM6, TIM_FLAG_Update); /* TIM Interrupts enable */ TIM_ITConfig(TIM6, TIM_IT_Update, ENABLE); /* TIM6 enable counter */ TIM_Cmd(TIM6, ENABLE); //============================================================================== /* Time base configuration */ TIM_TimeBaseStructure.TIM_Period = 2; TIM_TimeBaseStructure.TIM_Prescaler = 23999; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM7, &TIM_TimeBaseStructure); /* Clear TIM2 update pending flags */ TIM_ClearFlag(TIM7, TIM_FLAG_Update); /* TIM Interrupts enable */ TIM_ITConfig(TIM7, TIM_IT_Update, ENABLE); /* TIM7 enable counter */ TIM_Cmd(TIM7, ENABLE); //============================================================================== /* Time base configuration */ TIM_TimeBaseStructure.TIM_Period = 5; TIM_TimeBaseStructure.TIM_Prescaler = 2399; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); /* Clear TIM2 update pending flags */ TIM_ClearFlag(TIM2, TIM_FLAG_Update); /* TIM Interrupts enable */ TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); /* TIM2 enable counter */ TIM_Cmd(TIM2, ENABLE); //============================================================================== };
/** * @brief HY-STM32 board test * @param None * @retval None */ int main(void) { /* Set Systick to 1 ms */ if (SysTick_Config(SystemCoreClock / 1000)) while (1) ; SystemTicks = 0; NVIC_InitStructure.NVIC_IRQChannel = SysTick_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* GPIOF Periph clock enable */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE); /* Configure PF6 as output (state LED) */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_Init(GPIOF, &GPIO_InitStructure); LCD5110_init(); LCD5110_Led(0); LCD5110_Set_XY(0, 0); LCD5110_Write_String("HY32 Test"); initUART4(115200); SerialSetCallBack((callBack) ProcessSerialInput); SerialSendBytes("Hello\r\n", 7); //WriteReadStatus = testNOR(0x10000, 0x100, 0x100); //WriteReadStatus = testSRAM(0, 0x400000, 0x1000); //testDS18B20(); testDS1307(); if (WriteReadStatus == 0) { blink = 500; /* Ok */ } else { blink = 100; /* Ko */ } while (1) { Delay_ms(blink); GPIO_ToggleBits(GPIOF, GPIO_Pin_6); if (GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_6) == 0) { LCD5110_Set_XY(0, 5); LCD5110_Write_String("- - - - - - - "); } else { LCD5110_Set_XY(0, 5); LCD5110_Write_String(" - - - - - - -"); } if (tempInterval & 0x1) { DS1307ReadTime(&currDate); DS1307GetTimeString(&currDate, timeBuffer); LCD5110_Set_XY(0, 3); LCD5110_Write_String(timeBuffer); DS1307GetDateString(&currDate, timeBuffer); LCD5110_Set_XY(0, 4); LCD5110_Write_String(timeBuffer); } if (++tempInterval == 120) { testDS18B20(tempBuffer); LCD5110_Write_String(tempBuffer); DS1307GetDateString(&currDate, timeBuffer); SerialSendBytes(timeBuffer, 8); SerialSendBytes(" ", 1); DS1307GetTimeString(&currDate, timeBuffer); SerialSendBytes(timeBuffer, 8); SerialSendBytes(" ", 1); tempBuffer[11] = 0x0D; tempBuffer[12] = 0x0A; SerialSendBytes(tempBuffer, 13); tempBuffer[11] = 0x00; tempInterval = 0; } } }
/* D0 -- PC6 D1 -- PA10 D2 -- PC8 D3 -- PC9 D4 -- PE4 D5 -- PB6 D6 -- PE5 D7 -- PE6 PCK - PA6 HS -- PA4 VS -- PB7 */ void InitDCMI(void) { GPIO_InitTypeDef GPIO_InitStruct; DCMI_InitTypeDef DCMI_InitStruct; DMA_InitTypeDef DMA_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_DCMI, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOE, ENABLE); GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_DCMI); //HSYNC GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_DCMI); //PCLK GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_DCMI); //VSYNC //RED GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_DCMI); GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_DCMI); GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_DCMI); //Blue GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_DCMI); GPIO_PinAFConfig(GPIOE, GPIO_PinSource4, GPIO_AF_DCMI); GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_DCMI); GPIO_PinAFConfig(GPIOE, GPIO_PinSource5, GPIO_AF_DCMI); GPIO_PinAFConfig(GPIOE, GPIO_PinSource6, GPIO_AF_DCMI); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_6 | GPIO_Pin_10; GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStruct.GPIO_OType = GPIO_OType_OD; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_8 | GPIO_Pin_9; GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6; GPIO_Init(GPIOE, &GPIO_InitStruct); DCMI_InitStruct.DCMI_CaptureMode = DCMI_CaptureMode_Continuous; DCMI_InitStruct.DCMI_SynchroMode = DCMI_SynchroMode_Hardware; DCMI_InitStruct.DCMI_PCKPolarity = DCMI_PCKPolarity_Falling; DCMI_InitStruct.DCMI_VSPolarity = DCMI_VSPolarity_High; DCMI_InitStruct.DCMI_HSPolarity = DCMI_HSPolarity_High; DCMI_InitStruct.DCMI_CaptureRate = DCMI_CaptureRate_All_Frame; DCMI_InitStruct.DCMI_ExtendedDataMode = DCMI_ExtendedDataMode_8b; DCMI_Init(&DCMI_InitStruct); DCMI_ITConfig(DCMI_IT_VSYNC, ENABLE); DCMI_ITConfig(DCMI_IT_LINE, ENABLE); DCMI_ITConfig(DCMI_IT_FRAME, ENABLE); DCMI_ITConfig(DCMI_IT_ERR, ENABLE); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); NVIC_InitStructure.NVIC_IRQChannel = DCMI_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Configures the DMA2 to transfer Data from DCMI to the LCD ****************/ /* Enable DMA2 clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); /* DMA2 Stream1 Configuration */ DMA_DeInit(DMA2_Stream1); DMA_InitStructure.DMA_Channel = DMA_Channel_1; DMA_InitStructure.DMA_PeripheralBaseAddr = DCMI_DR_ADDRESS; DMA_InitStructure.DMA_Memory0BaseAddr = FSMC_LCD_ADDRESS; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; DMA_InitStructure.DMA_BufferSize = 0xfffe; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word; 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_Enable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA2_Stream1, &DMA_InitStructure); }
void adc_init(void){ NVIC_InitTypeDef nvic; GPIO_InitTypeDef gpio; ADC_InitTypeDef adc; /* enable ADC1 clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); /* Configure and enable ADC interrupt */ nvic.NVIC_IRQChannel = ADC1_2_IRQn; nvic.NVIC_IRQChannelPreemptionPriority = 0; nvic.NVIC_IRQChannelSubPriority = 0; nvic.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&nvic); /* GPIOA: ADC Channel 0, 1, 2 as analog input * Ch 0 -> BEMF/I_Sense of PHASE A * Ch 1 -> BEMF/I_Sense of PHASE B * Ch 2 -> BEMF/I_Sense of PHASE C */ gpio.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2; gpio.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &gpio); adc_comm = 0; adc_filtered = 0; /* Configure ADC1 */ adc.ADC_Mode = ADC_Mode_Independent; adc.ADC_ScanConvMode = DISABLE; adc.ADC_ContinuousConvMode = DISABLE; adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; adc.ADC_DataAlign = ADC_DataAlign_Right; adc.ADC_NbrOfChannel = 0; ADC_Init(ADC1, &adc); ADC_InjectedSequencerLengthConfig(ADC1, 1); ADC_InjectedChannelConfig(ADC1, ADC_Channel_2, 1, ADC_SampleTime_28Cycles5); ADC_ExternalTrigInjectedConvConfig(ADC1, ADC_ExternalTrigInjecConv_T1_CC4); ADC_ExternalTrigInjectedConvCmd(ADC1, ENABLE); /* Enable ADC1 JEOC interrupt */ ADC_ITConfig(ADC1, ADC_IT_JEOC, ENABLE); /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /* Enable ADC1 reset calibaration register */ ADC_ResetCalibration(ADC1); /* Check the end of ADC1 reset calibration */ while(ADC_GetResetCalibrationStatus(ADC1)); /* Start ADC1 calibaration */ ADC_StartCalibration(ADC1); /* Check the end of ADC1 calibration */ while(ADC_GetCalibrationStatus(ADC1)); /* Enable ADC1 External Trigger */ ADC_ExternalTrigConvCmd(ADC1, ENABLE); //ADC_ExternalTrigConvCmd(ADC1, DISABLE); }
void Uart3Config(UartPort* me) { USART_InitTypeDef USART_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; DMA_InitTypeDef DMA_InitStructure; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_USART3); GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_USART3); 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_InitStructure.GPIO_Pin = GPIO_Pin_10; //tx GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; //rx GPIO_Init(GPIOB, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = (unsigned int) me->baudrate; 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_Rx | USART_Mode_Tx; USART_Init(USART3, &USART_InitStructure); USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); //USARTx_TX_DMA_STREAM DMA_DeInit(DMA1_Stream3); DMA_InitStructure.DMA_Channel = DMA_Channel_4; DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&(USART3->DR)); DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t) me->txBuf; DMA_InitStructure.DMA_BufferSize = me->txBufSize; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA1_Stream3, &DMA_InitStructure); DMA_SetCurrDataCounter(DMA1_Stream3, 0); DMA_ITConfig(DMA1_Stream3, DMA_IT_TC | DMA_IT_FE | DMA_IT_TE, ENABLE); USART_DMACmd(USART3, USART_DMAReq_Tx, DISABLE); DMA_Cmd(DMA1_Stream3, DISABLE); NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_Init(&NVIC_InitStructure); NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable USART */ USART_Cmd(USARTx, ENABLE); }
/** * @brief Configures the SPI Peripheral. * @param None * @retval None */ static void SPI_Config(void) { GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; /* Peripheral Clock Enable -------------------------------------------------*/ /* Enable the SPI clock */ SPIx_CLK_INIT(SPIx_CLK, ENABLE); /* Enable GPIO clocks */ RCC_AHB1PeriphClockCmd(SPIx_SCK_GPIO_CLK | SPIx_MISO_GPIO_CLK | SPIx_MOSI_GPIO_CLK, ENABLE); /* SPI GPIO Configuration --------------------------------------------------*/ /* GPIO Deinitialisation */ GPIO_DeInit(SPIx_SCK_GPIO_PORT); GPIO_DeInit(SPIx_MISO_GPIO_PORT); GPIO_DeInit(SPIx_MOSI_GPIO_PORT); /* Connect SPI pins to AF5 */ GPIO_PinAFConfig(SPIx_SCK_GPIO_PORT, SPIx_SCK_SOURCE, SPIx_SCK_AF); GPIO_PinAFConfig(SPIx_MISO_GPIO_PORT, SPIx_MISO_SOURCE, SPIx_MISO_AF); GPIO_PinAFConfig(SPIx_MOSI_GPIO_PORT, SPIx_MOSI_SOURCE, SPIx_MOSI_AF); 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_DOWN; /* SPI SCK pin configuration */ GPIO_InitStructure.GPIO_Pin = SPIx_SCK_PIN; GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStructure); /* SPI MISO pin configuration */ GPIO_InitStructure.GPIO_Pin = SPIx_MISO_PIN; GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStructure); /* SPI MOSI pin configuration */ GPIO_InitStructure.GPIO_Pin = SPIx_MOSI_PIN; GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStructure); /* SPI configuration -------------------------------------------------------*/ SPI_I2S_DeInit(SPIx); SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_CRCPolynomial = 7; /* Configure the Priority Group to 1 bit */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); /* Configure the SPI interrupt priority */ NVIC_InitStructure.NVIC_IRQChannel = SPIx_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }
int uart_open (uint8_t uart, uint32_t baud, uint32_t flags) { USART_InitTypeDef USART_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; if (uart == 1) { // get things to a known state USART_DeInit(USART1); // Enable clock for GPIOA RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1); GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1); // Turn on clocks for USART1 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); // DEBUG GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Speed = GPIO_High_Speed; GPIO_Init(GPIOB, &GPIO_InitStructure); // Configure TX pin GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; //GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Speed = GPIO_High_Speed; GPIO_Init(GPIOB, &GPIO_InitStructure); // Configure RX pin GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; //GPIO_Mode_IN;//GPIO_Mode_IN_FLOATING; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Speed = GPIO_High_Speed; GPIO_Init(GPIOB, &GPIO_InitStructure); #ifdef HWFLOWCTRL // Configure CTS pin GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//GPIO_Mode_IN_FLOATING; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOA, &GPIO_InitStructure); // Configure RTS pin -- software controlled GPIO_WriteBit(GPIOA, GPIO_Pin_12, 1); //TODO // nRTS disabled GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOA, &GPIO_InitStructure); #endif // Configure the UART USART_StructInit(&USART_InitStructure); USART_InitStructure.USART_BaudRate = baud; #ifdef HWFLOWCTRL USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_CTS; #else USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; #endif USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_Init(USART1, &USART_InitStructure); // Enable RX Interrupt. TX interrupt enabled in send routine USART_ClearITPendingBit(USART1, USART_IT_RXNE); //disable Transmit Data Register empty interrupt USART_ITConfig(USART1, USART_IT_TXE, DISABLE); //enable Receive Data register not empty interrupt USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); InitQueue(&UART1_RXq); InitQueue(&UART1_TXq); // Configure NVIC /* Configure the NVIC Preemption Priority Bits */ //NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); /* Enable the USART1 Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); // Enable USART1 USART_Cmd(USART1, ENABLE); #ifdef HWFLOWCTRL // nRTS enabled GPIO_WriteBit(GPIOA, GPIO_Pin_12, 0); #endif return 0; } return 1; // only handle UART2 }
void adcInit(void) { if(isInit) return; ADC_InitTypeDef ADC_InitStructure; TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_OCInitTypeDef TIM_OCInitStructure; NVIC_InitTypeDef NVIC_InitStructure; // Enable TIM2, GPIOA and ADC1 clock RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE); //Timer configuration TIM_TimeBaseStructure.TIM_Period = ADC_TRIG_PERIOD; TIM_TimeBaseStructure.TIM_Prescaler = ADC_TRIG_PRESCALE; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); // TIM2 channel2 configuration in PWM mode TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse = 1; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low; TIM_OC2Init(TIM2, &TIM_OCInitStructure); TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable); // Halt timer 2 during debug halt. DBGMCU_Config(DBGMCU_TIM2_STOP, ENABLE); adcDmaInit(); // ADC1 configuration ADC_DeInit(ADC1); ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_CC2; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = NBR_OF_ADC_CHANNELS; ADC_Init(ADC1, &ADC_InitStructure); // ADC1 channel sequence ADC_RegularChannelConfig(ADC1, CH_VREF, 1, ADC_SampleTime_28Cycles5); // ADC2 configuration ADC_DeInit(ADC2); ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = NBR_OF_ADC_CHANNELS; ADC_Init(ADC2, &ADC_InitStructure); // ADC2 channel sequence ADC_RegularChannelConfig(ADC2, CH_VBAT, 1, ADC_SampleTime_28Cycles5); // Enable ADC1 ADC_Cmd(ADC1, ENABLE); // Calibrate ADC1 ADC_ResetCalibration(ADC1); while(ADC_GetResetCalibrationStatus(ADC1)); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1)); // Enable ADC1 external trigger ADC_ExternalTrigConvCmd(ADC1, ENABLE); ADC_TempSensorVrefintCmd(ENABLE); // Enable ADC2 ADC_Cmd(ADC2, ENABLE); // Calibrate ADC2 ADC_ResetCalibration(ADC2); while(ADC_GetResetCalibrationStatus(ADC2)); ADC_StartCalibration(ADC2); while(ADC_GetCalibrationStatus(ADC2)); // Enable ADC2 external trigger ADC_ExternalTrigConvCmd(ADC2, ENABLE); // Enable the DMA1 channel1 Interrupt NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_ADC_PRI; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); adcQueue = xQueueCreate(1, sizeof(AdcGroup*)); xTaskCreate(adcTask, (const signed char *)"ADC", configMINIMAL_STACK_SIZE, NULL, /*priority*/3, NULL); isInit = true; }
/*============================================================================*/ void init_External_Interrupt(void){ GPIO_InitTypeDef GPIO_InitStruct; EXTI_InitTypeDef EXTI_InitStruct; NVIC_InitTypeDef NVIC_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); /* Connect EXTI Line0 to PA0 pin */ SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA,EXTI_PinSource0); EXTI_InitStruct.EXTI_Line = EXTI_Line0; EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling; EXTI_InitStruct.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStruct); EXTI_ClearITPendingBit(EXTI_Line0); NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Connect EXTI Line1 to PA1 pin */ SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA,EXTI_PinSource1); EXTI_InitStruct.EXTI_Line = EXTI_Line1; EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling; EXTI_InitStruct.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStruct); EXTI_ClearITPendingBit(EXTI_Line1); NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Connect EXTI Line2 to PA2 pin */ SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA,EXTI_PinSource2); EXTI_InitStruct.EXTI_Line = EXTI_Line2; EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling; EXTI_InitStruct.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStruct); EXTI_ClearITPendingBit(EXTI_Line2); NVIC_InitStructure.NVIC_IRQChannel = EXTI2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Connect EXTI Line3 to PA3 pin */ SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA,EXTI_PinSource3); EXTI_InitStruct.EXTI_Line = EXTI_Line3; EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling; EXTI_InitStruct.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStruct); EXTI_ClearITPendingBit(EXTI_Line3); NVIC_InitStructure.NVIC_IRQChannel = EXTI3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }
// Setup ADC void setup_adc(){ RCC_ADCCLKConfig(RCC_PCLK2_Div4); /* Enable DMA1 clock */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); /* Enable ADC1 and GPIOC clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE); GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; #ifdef TROLLER //PINA0 IN0 DC link //PINA6 IN6 iu //PINA7 IN7 iv //PINB0 IN8 iw //PINA5 IN5 uu //PINA4 IN4 uv //PINA1 IN1 uw GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_6 | GPIO_Pin_7; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; GPIO_Init(GPIOB, &GPIO_InitStructure); #else //PINC5 IN15 DC link //PINC4 IN14 AMP //PINB0 IN8 temperature GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5; GPIO_Init(GPIOC, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; GPIO_Init(GPIOB, &GPIO_InitStructure); #endif DMA_DeInit(DMA1_Channel1); DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address; DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADCConvertedValue; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = ADC_channels; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; 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_M2M = DMA_M2M_Disable; DMA_Init(DMA1_Channel1, &DMA_InitStructure); NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable DMA1 channel1 */ DMA_Cmd(DMA1_Channel1, ENABLE); DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE); /* ADC1 configuration ------------------------------------------------------*/ ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = ADC_channels; ADC_Init(ADC1, &ADC_InitStructure); ADC_TempSensorVrefintCmd(ENABLE); #ifdef TROLLER ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_13Cycles5); //volt ADC_RegularChannelConfig(ADC1, ADC_Channel_6, 2, ADC_SampleTime_13Cycles5); //iu ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 3, ADC_SampleTime_13Cycles5); //iv ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 4, ADC_SampleTime_13Cycles5); //iw #else ADC_RegularChannelConfig(ADC1, ADC_Channel_15, 1, ADC_SampleTime_13Cycles5); //volt ADC_RegularChannelConfig(ADC1, ADC_Channel_14, 2, ADC_SampleTime_13Cycles5); //amp ADC_RegularChannelConfig(ADC1, ADC_Channel_8 , 3, ADC_SampleTime_13Cycles5); //temp #endif /* Enable ADC1 DMA */ ADC_DMACmd(ADC1, ENABLE); /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /* Enable ADC1 reset calibration register */ ADC_ResetCalibration(ADC1); /* Check the end of ADC1 reset calibration register */ while(ADC_GetResetCalibrationStatus(ADC1)); /* Start ADC1 calibration */ ADC_StartCalibration(ADC1); /* Check the end of ADC1 calibration */ while(ADC_GetCalibrationStatus(ADC1)); }
//UART3对应板子上的uart2 void UART3_init(u32 bound){ //GPIO端口设置 GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO, ENABLE); //使能USART3 GPIO时钟 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE); USART_DeInit(USART3); //复位串口3 // //USART1_TX PA.9 // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9 // GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出 // GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA9 //USART3_TX PB.10 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PA.9 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出 GPIO_Init(GPIOB, &GPIO_InitStructure); //初始化PA9 // // //USART1_RX PA.10 // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入 // GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA10 //USART3_RX PB.11 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//浮空输入 GPIO_Init(GPIOB, &GPIO_InitStructure); //初始化PA10 //Usart3 NVIC 配置 NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能 NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器 // //Usart3 NVIC 配置 // NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; // NVIC_Init(&NVIC_InitStructure); //USART 初始化设置 USART_InitStructure.USART_BaudRate = bound;//一般设置为9600; USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式 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_Rx | USART_Mode_Tx; //收发模式 // USART_Init(USART1, &USART_InitStructure); //初始化串口 // USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启中断 //USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // USART_ClearFlag(USART1,USART_FLAG_TC); // USART_Cmd(USART1, ENABLE); //使能串口 USART_Init(USART3, &USART_InitStructure); USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启中断 // USART_ITConfig(USART3, USART_IT_TXE, ENABLE); USART_Cmd(USART3, ENABLE); //使能串口 }
/** * @brief This function configures the system to enter Stop mode with RTC * clocked by LSE or LSI for current consumption measurement purpose. * STOP Mode with RTC clocked by LSE/LSI * ===================================== * - RTC Clocked by LSE or LSI * - Regulator in LP mode * - HSI, HSE OFF and LSI OFF if not used as RTC Clock source * - No IWDG * - FLASH in deep power down mode * - Automatic Wakeup using RTC clocked by LSE/LSI (~20s) * @param None * @retval None */ void StopMode_Measure(void) { __IO uint32_t index = 0; GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; EXTI_InitTypeDef EXTI_InitStructure; /* Allow access to RTC */ PWR_BackupAccessCmd(ENABLE); #if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/ /* The RTC Clock may varies due to LSI frequency dispersion. */ /* Enable the LSI OSC */ RCC_LSICmd(ENABLE); /* Wait till LSI is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); #elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */ /* Enable the LSE OSC */ RCC_LSEConfig(RCC_LSE_ON); /* Wait till LSE is ready */ while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) { } /* Select the RTC Clock Source */ RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); #else #error Please select the RTC Clock source inside the main.c file #endif /* RTC_CLOCK_SOURCE_LSI */ /* Enable the RTC Clock */ RCC_RTCCLKCmd(ENABLE); /* Wait for RTC APB registers synchronisation */ RTC_WaitForSynchro(); /* Configure all GPIO as analog to reduce current consumption on non used IOs */ /* Enable GPIOs clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_GPIOI, ENABLE); GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; GPIO_Init(GPIOC, &GPIO_InitStructure); GPIO_Init(GPIOD, &GPIO_InitStructure); GPIO_Init(GPIOE, &GPIO_InitStructure); GPIO_Init(GPIOF, &GPIO_InitStructure); GPIO_Init(GPIOG, &GPIO_InitStructure); GPIO_Init(GPIOH, &GPIO_InitStructure); GPIO_Init(GPIOI, &GPIO_InitStructure); GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_Init(GPIOB, &GPIO_InitStructure); /* Disable GPIOs clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOE | RCC_AHB1Periph_GPIOF | RCC_AHB1Periph_GPIOG | RCC_AHB1Periph_GPIOH | RCC_AHB1Periph_GPIOI, DISABLE); /* EXTI configuration *******************************************************/ EXTI_ClearITPendingBit(EXTI_Line22); EXTI_InitStructure.EXTI_Line = EXTI_Line22; EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; EXTI_InitStructure.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStructure); /* Enable the RTC Wakeup Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* RTC Wakeup Interrupt Generation: Clock Source: RTCCLK_Div16, Wakeup Time Base: ~20s RTC Clock Source LSE 32.768KHz or LSI ~32KHz Wakeup Time Base = (16 / (LSE or LSI)) * WakeUpCounter */ RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16); RTC_SetWakeUpCounter(0xA000-1); /* Enable the Wakeup Interrupt */ RTC_ITConfig(RTC_IT_WUT, ENABLE); /* Enable Wakeup Counter */ RTC_WakeUpCmd(ENABLE); /* FLASH Deep Power Down Mode enabled */ PWR_FlashPowerDownCmd(ENABLE); /* Enter Stop Mode */ PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI); /* Initialize LED3 on STM32F429I-DISCO board */ STM_EVAL_LEDInit(LED3); /* Infinite loop */ while (1) { /* Toggle The LED3 */ STM_EVAL_LEDToggle(LED3); /* Inserted Delay */ for(index = 0; index < 0x5FF; index++); } }
// ------------------------------------------------------------ // configuters a SIT's TIMER registers, etc and enables // interrupts, effectively starting the timer upon completion // ------------------------------------------------------------ void IntervalTimer::start_SIT(intPeriod Period, bool scale) { TIM_TimeBaseInitTypeDef timerInitStructure; NVIC_InitTypeDef nvicStructure; intPeriod prescaler; TIM_TypeDef* TIMx; //use SIT_id to identify TIM# switch (SIT_id) { #if defined(STM32F10X_MD) || !defined(PLATFORM_ID) //Core case 0: // TIM2 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); nvicStructure.NVIC_IRQChannel = TIM2_IRQn; TIMx = TIM2; break; case 1: // TIM3 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); nvicStructure.NVIC_IRQChannel = TIM3_IRQn; TIMx = TIM3; break; case 2: // TIM4 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); nvicStructure.NVIC_IRQChannel = TIM4_IRQn; TIMx = TIM4; break; #elif defined(STM32F2XX) && defined(PLATFORM_ID) //Photon case 0: // TIM3 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); nvicStructure.NVIC_IRQChannel = TIM3_IRQn; TIMx = TIM3; break; case 1: // TIM4 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); nvicStructure.NVIC_IRQChannel = TIM4_IRQn; TIMx = TIM4; break; case 2: // TIM5 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE); nvicStructure.NVIC_IRQChannel = TIM5_IRQn; TIMx = TIM5; break; case 3: // TIM6 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE); nvicStructure.NVIC_IRQChannel = TIM6_DAC_IRQn; TIMx = TIM6; break; case 4: // TIM7 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE); nvicStructure.NVIC_IRQChannel = TIM7_IRQn; TIMx = TIM7; break; #endif } // Initialize Timer switch (scale) { case uSec: prescaler = SIT_PRESCALERu; // Set prescaler for 1MHz clock, 1us period break; case hmSec: prescaler = SIT_PRESCALERm; // Set prescaler for 2Hz clock, .5ms period break; default: prescaler = SIT_PRESCALERu; scale = uSec; // Default to microseconds break; } timerInitStructure.TIM_Prescaler = prescaler; timerInitStructure.TIM_CounterMode = TIM_CounterMode_Up; timerInitStructure.TIM_Period = Period; timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; timerInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIMx, &timerInitStructure); TIM_Cmd(TIMx, ENABLE); TIM_ITConfig(TIMx, TIM_IT_Update, ENABLE); // point to the correct SIT ISR SIT_CALLBACK[SIT_id] = myISRcallback; //Enable Timer Interrupt nvicStructure.NVIC_IRQChannelPreemptionPriority = 10; nvicStructure.NVIC_IRQChannelSubPriority = 1; nvicStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&nvicStructure); }
int8 wizpf_usart_init(wizpf_usart usart, usart_param *param) { USART_TypeDef *usartx; USART_InitTypeDef USART_InitStructure; switch(usart) { case WIZ_USART1: RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); #ifdef USART1_TX_PIN wizpf_gpio_init(USART1_TX_PORT, USART1_TX_PIN, GMOD_AF_PUSHPULL); #endif #ifdef USART1_RX_PIN wizpf_gpio_init(USART1_RX_PORT, USART1_RX_PIN, GMOD_IN_FLOAT); #endif #ifdef USART1_RTS_PIN wizpf_gpio_init(USART1_RTS_PORT, USART1_RTS_PIN, GMOD_AF_PUSHPULL); #endif #ifdef USART1_CTS_PIN wizpf_gpio_init(USART1_CTS_PORT, USART1_CTS_PIN, GMOD_IN_FLOAT); #endif #if (USART1_RX_INTERRUPT == VAL_ENABLE) { NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } #endif usartx = USART1; break; case WIZ_USART2: RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); #ifdef USART2_TX_PIN wizpf_gpio_init(USART2_TX_PORT, USART2_TX_PIN, GMOD_AF_PUSHPULL); #endif #ifdef USART2_RX_PIN wizpf_gpio_init(USART2_RX_PORT, USART2_RX_PIN, GMOD_IN_FLOAT); #endif #ifdef USART2_RTS_PIN wizpf_gpio_init(USART2_RTS_PORT, USART2_RTS_PIN, GMOD_AF_PUSHPULL); #endif #ifdef USART2_CTS_PIN wizpf_gpio_init(USART2_CTS_PORT, USART2_CTS_PIN, GMOD_IN_FLOAT); #endif #if (USART2_RX_INTERRUPT == VAL_ENABLE) { NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } #endif usartx = USART2; break; //case WIZ_USART3: // break; default: return RET_NOK; } USART_Cmd(usartx, DISABLE); USART_InitStructure.USART_BaudRate = param->baudrate; switch(param->wordlen) { case UWL_8: USART_InitStructure.USART_WordLength = USART_WordLength_8b; break; case UWL_9: USART_InitStructure.USART_WordLength = USART_WordLength_9b; break; } switch(param->stopbit) { case UST_0d5: USART_InitStructure.USART_StopBits = USART_StopBits_0_5; break; case UST_1: USART_InitStructure.USART_StopBits = USART_StopBits_1; break; case UST_1d5: USART_InitStructure.USART_StopBits = USART_StopBits_1_5; break; case UST_2: USART_InitStructure.USART_StopBits = USART_StopBits_2; break; } switch(param->parity) { case UPB_NO: USART_InitStructure.USART_Parity = USART_Parity_No; break; case UPB_EVEN:USART_InitStructure.USART_Parity = USART_Parity_Even; break; case UPB_ODD: USART_InitStructure.USART_Parity = USART_Parity_Odd; break; } switch(param->flowcon) { case UFC_NO: USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; break; case UFC_HW: USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS_CTS; break; //case UFC_SW: } USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_Init(usartx, &USART_InitStructure); #if (USART1_RX_INTERRUPT == VAL_ENABLE) USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); #endif #if (USART2_RX_INTERRUPT == VAL_ENABLE) USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); #endif USART_Cmd(usartx, ENABLE); return RET_OK; }
// ------------------------------------------------------------ // Enables or disables an active SIT's interrupt without // removing the SIT. // ------------------------------------------------------------ void IntervalTimer::interrupt_SIT(action ACT) { NVIC_InitTypeDef nvicStructure; TIM_TypeDef* TIMx; //use SIT_id to identify TIM# switch (SIT_id) { #if defined(STM32F10X_MD) || !defined(PLATFORM_ID) //Core case 0: // TIM2 nvicStructure.NVIC_IRQChannel = TIM2_IRQn; TIMx = TIM2; break; case 1: // TIM3 nvicStructure.NVIC_IRQChannel = TIM3_IRQn; TIMx = TIM3; break; case 2: // TIM4 nvicStructure.NVIC_IRQChannel = TIM4_IRQn; TIMx = TIM4; break; #elif defined(STM32F2XX) && defined(PLATFORM_ID) //Photon case 0: // TIM3 nvicStructure.NVIC_IRQChannel = TIM3_IRQn; TIMx = TIM3; break; case 1: // TIM4 nvicStructure.NVIC_IRQChannel = TIM4_IRQn; TIMx = TIM4; break; case 2: // TIM5 nvicStructure.NVIC_IRQChannel = TIM5_IRQn; TIMx = TIM5; break; case 3: // TIM6 nvicStructure.NVIC_IRQChannel = TIM6_DAC_IRQn; TIMx = TIM6; break; case 4: // TIM7 nvicStructure.NVIC_IRQChannel = TIM7_IRQn; TIMx = TIM7; break; #endif } switch (ACT) { case INT_ENABLE: //Enable Timer Interrupt nvicStructure.NVIC_IRQChannelPreemptionPriority = 0; nvicStructure.NVIC_IRQChannelSubPriority = 1; nvicStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&nvicStructure); break; case INT_DISABLE: // disable interrupt nvicStructure.NVIC_IRQChannelCmd = DISABLE; NVIC_Init(&nvicStructure); break; default: //Do nothing break; } }
//默认一个主机 串口 波特率可设置 奇偶检验可设置 BOOL xMBMasterPortSerialInit(UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity) { GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; //======================时钟初始化======================================= /* Enable USART3 GPIO clocks */ RCC_AHB1PeriphClockCmd(MB_GPIO_RCC | MB_GPIO_DE_RCC, ENABLE); /* Enable USART3 clock */ RCC_APB1PeriphClockCmd(MB_USART_RCC, ENABLE); /* Connect alternate function */ GPIO_PinAFConfig(MB_USART_GPIO, MB_GPIO_TX_SOURCE, MB_USART_AF); GPIO_PinAFConfig(MB_USART_GPIO, MB_GPIO_RX_SOURCE, MB_USART_AF); //======================IO初始化======================================= /* Configure USART Tx and Rx as alternate function push-pull */ 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_InitStructure.GPIO_Pin = MB_GPIO_RX; GPIO_Init(MB_USART_GPIO, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = MB_GPIO_TX; GPIO_Init(MB_USART_GPIO, &GPIO_InitStructure); //配置485发送和接收模式 /* Configure RS485DE as alternate function push-pull */ GPIO_InitStructure.GPIO_Pin = MB_GPIO_DE; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(MB_DE_GPIO, &GPIO_InitStructure); //======================串口初始化======================================= USART_InitStructure.USART_BaudRate = ulBaudRate; //设置校验模式 switch (eParity) { case MB_PAR_NONE: //无校验 USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_WordLength = USART_WordLength_8b; break; case MB_PAR_ODD: //奇校验 USART_InitStructure.USART_Parity = USART_Parity_Odd; USART_InitStructure.USART_WordLength = USART_WordLength_9b; break; case MB_PAR_EVEN: //偶校验 USART_InitStructure.USART_Parity = USART_Parity_Even; USART_InitStructure.USART_WordLength = USART_WordLength_9b; break; default: return FALSE; } USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; if (ucPORT != 2) return FALSE; ENTER_CRITICAL_SECTION(); //关全局中断 USART_Init(MODBUS_USE_USART, &USART_InitStructure); USART_ITConfig(MODBUS_USE_USART, USART_IT_RXNE, ENABLE); USART_Cmd(MODBUS_USE_USART, ENABLE); //=====================中断初始化====================================== //设置NVIC优先级分组为Group2:0-3抢占式优先级,0-3的响应式优先级 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); NVIC_InitStructure.NVIC_IRQChannel = MB_USART_IRQ; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); EXIT_CRITICAL_SECTION(); //开全局中断 return TRUE; }
/** * @brief Configure NVIC and interrupts used by I2C Device according to * enabled options * @param Device : I2C Device instance. * @param Options : I2C Transfer Options. * @retval None. */ void CPAL_I2C_HAL_ITInit(CPAL_DevTypeDef Device, uint32_t Options, CPAL_DirectionTypeDef Direction, CPAL_ProgModelTypeDef ProgModel) { NVIC_InitTypeDef NVIC_InitStructure; /* Configure NVIC priority Group */ CPAL_HAL_NVICInit(); /* Enable the IRQ channel */ NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; /* Configure NVIC for I2Cx EVT Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = CPAL_I2C_IT_EVT_IRQn [Device] ; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C_IT_EVT_PREPRIO[Device]; NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C_IT_EVT_SUBPRIO[Device]; NVIC_Init(&NVIC_InitStructure); /* If I2C ERR Interrupt Option Bit not selected */ if ((Options & CPAL_OPT_I2C_ERRIT_DISABLE) == 0) { /* Configure NVIC for I2Cx ERR Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = CPAL_I2C_IT_ERR_IRQn [Device] ; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C_IT_ERR_PREPRIO[Device]; NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C_IT_ERR_SUBPRIO[Device]; NVIC_Init(&NVIC_InitStructure); /* Enable I2C Error Interrupts */ __CPAL_I2C_HAL_ENABLE_ERRIT(Device); } #ifdef CPAL_I2C_DMA_PROGMODEL if (ProgModel == CPAL_PROGMODEL_DMA) { if ( (Direction & CPAL_DIRECTION_TX) != 0) { /* Configure NVIC for DMA TX channel interrupt */ NVIC_InitStructure.NVIC_IRQChannel = CPAL_I2C_DMA_TX_IRQn [Device] ; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C_IT_DMATX_PREPRIO[Device]; NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C_IT_DMATX_SUBPRIO[Device]; NVIC_Init(&NVIC_InitStructure); /* Enable DMA TX Channel TCIT */ __I2C_HAL_ENABLE_DMATX_TCIT(Device); /* Enable DMA TX Channel TEIT */ __I2C_HAL_ENABLE_DMATX_TEIT(Device); /* If DMA TX HT interrupt Option Bits Selected */ if ((Options & CPAL_OPT_DMATX_HTIT) != 0) { /* Enable DMA TX Channel HTIT */ __I2C_HAL_ENABLE_DMATX_HTIT(Device); } } if ((Direction & CPAL_DIRECTION_RX) != 0) { /* Configure NVIC for DMA RX channel interrupt */ NVIC_InitStructure.NVIC_IRQChannel = CPAL_I2C_DMA_RX_IRQn [Device] ; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C_IT_DMARX_PREPRIO[Device]; NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C_IT_DMARX_SUBPRIO[Device]; NVIC_Init(&NVIC_InitStructure); /* Enable DMA RX Channel TCIT */ __I2C_HAL_ENABLE_DMARX_TCIT(Device); /* Enable DMA RX Channel TEIT */ __I2C_HAL_ENABLE_DMARX_TEIT(Device); /* If DMA RX HT interrupt Option Bits Selected */ if ((Options & CPAL_OPT_DMARX_HTIT) != 0) { /* Enable DMA RX Channel HTIT */ __I2C_HAL_ENABLE_DMARX_HTIT(Device); } } } #endif /* CPAL_I2C_DMA_PROGMODEL */ }
/** * @fn void Key_Init(void) * @brief * - Key 초기화 함수 * @remarks * @param void * @return void */ void Key_Init(void) { EXTI_InitTypeDef EXTI_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; ADC_InitTypeDef ADC_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; /***** 키 인터럽트 설정(PA1) *****/ /* 외부 인터럽트 라인 설정 */ GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource1); /* 외부 인터럽트 설정 */ EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStructure.EXTI_Line = EXTI_Line1; EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; EXTI_InitStructure.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStructure); /* EXTI line 1 활성화 */ NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* PF6 (ADC Channel3_IN4) 를 아날로그 입력으로 설정 */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; // 아날로그 모드 GPIO_Init(GPIOF, &GPIO_InitStructure); /* ADC3 클럭 활성화 */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC3, ENABLE); /* ADC3 설정*/ ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigInjecConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = 3; // Regular 채널의 개수 ADC_Init(ADC3, &ADC_InitStructure); /* ADC3 Injected 채널 설정 */ ADC_InjectedChannelConfig(ADC3, ADC_Channel_4, 1, ADC_SampleTime_55Cycles5); ADC_InjectedSequencerLengthConfig(ADC3,1); // Injected 채널의 개수 설정 /* ADC3 활성화*/ ADC_Cmd(ADC3, ENABLE); /* ADC Interrupt Configuation */ ADC_ITConfig(ADC3, ADC_IT_JEOC, ENABLE); /* ADC3 IRQ 초기화 */ NVIC_InitStructure.NVIC_IRQChannel = ADC3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }
void Cam_Init() { GPIO_InitTypeDef GPIO_InitStructure; DCMI_InitTypeDef DCMI_InitStructure; DCMI_CROPInitTypeDef DCMI_CROPInitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_DCMI, ENABLE);//DCMI RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);//DMA2 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOE, ENABLE);//使能DCMI的GPIO时钟 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE); GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_MCO);//MCO1:PA8 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOA, &GPIO_InitStructure); RCC_MCO1Config(RCC_MCO1Source_HSE, RCC_MCO1Div_1);//25MHz GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//PE5:PWRDOWN GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_ResetBits(GPIOA, GPIO_Pin_7);//power on GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 ; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; // GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ; GPIO_Init(GPIOD, &GPIO_InitStructure); GPIO_SetBits(GPIOD, GPIO_Pin_7);//reset delay_ms(10); OV7670_RST(0); //复位OV7670 delay_ms(10); OV7670_RST(1); //结束复位 GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_DCMI);//DCMI_HSYNC GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_DCMI);//DCMI_PIXCLK GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_DCMI);//DCMI_D5 GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_DCMI);//DCMI_VSYNC GPIO_PinAFConfig(GPIOE, GPIO_PinSource5, GPIO_AF_DCMI);//DCMI_D6 GPIO_PinAFConfig(GPIOE, GPIO_PinSource6, GPIO_AF_DCMI);//DCMI_D7 GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_DCMI);//DCMI_D0 GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_DCMI);//DCMI_D1 GPIO_PinAFConfig(GPIOE, GPIO_PinSource0, GPIO_AF_DCMI);//DCMI_D2 GPIO_PinAFConfig(GPIOE, GPIO_PinSource1, GPIO_AF_DCMI);//DCMI_D3 GPIO_PinAFConfig(GPIOE, GPIO_PinSource4, GPIO_AF_DCMI);//DCMI_D4 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ; GPIO_Init(GPIOC, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6; GPIO_Init(GPIOE, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 ; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_6; GPIO_Init(GPIOA, &GPIO_InitStructure); DCMI_CROPInitStructure.DCMI_CaptureCount=319; DCMI_CROPInitStructure.DCMI_HorizontalOffsetCount=1; DCMI_CROPInitStructure.DCMI_VerticalLineCount=119; DCMI_CROPInitStructure.DCMI_VerticalStartLine=1; DCMI_CROPConfig(&DCMI_CROPInitStructure); DCMI_CROPCmd(ENABLE); DCMI_InitStructure.DCMI_CaptureMode =DCMI_CaptureMode_Continuous; DCMI_InitStructure.DCMI_SynchroMode = DCMI_SynchroMode_Hardware; DCMI_InitStructure.DCMI_PCKPolarity = DCMI_PCKPolarity_Falling; DCMI_InitStructure.DCMI_VSPolarity = DCMI_VSPolarity_High; DCMI_InitStructure.DCMI_HSPolarity = DCMI_HSPolarity_Low; DCMI_InitStructure.DCMI_CaptureRate = DCMI_CaptureRate_All_Frame; DCMI_InitStructure.DCMI_ExtendedDataMode = DCMI_ExtendedDataMode_8b; DCMI_Init(&DCMI_InitStructure); DCMI_ITConfig(DCMI_IT_FRAME,ENABLE);//开启帧中断 DCMI_Cmd(ENABLE); //DCMI使能 DCMI_DMA_Init((u32)&jpeg_buf,jpeg_buf_size,DMA_MemoryDataSize_Word,DMA_MemoryInc_Enable); NVIC_InitStructure.NVIC_IRQChannel = DCMI_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=NVIC_DCMI_P;//抢占优先级1 NVIC_InitStructure.NVIC_IRQChannelSubPriority =NVIC_DCMI_S; //子优先级2 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能 NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器、 }
uartPort_t *serialUSART1(uint32_t baudRate, portMode_t mode) { uartPort_t *s; static volatile uint8_t rx1Buffer[UART1_RX_BUFFER_SIZE]; static volatile uint8_t tx1Buffer[UART1_TX_BUFFER_SIZE]; NVIC_InitTypeDef NVIC_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; s = &uartPort1; s->port.vTable = uartVTable; s->port.baudRate = baudRate; s->port.rxBuffer = rx1Buffer; s->port.txBuffer = tx1Buffer; s->port.rxBufferSize = UART1_RX_BUFFER_SIZE; s->port.txBufferSize = UART1_TX_BUFFER_SIZE; #ifdef USE_USART1_RX_DMA s->rxDMAChannel = DMA1_Channel5; #endif s->txDMAChannel = DMA1_Channel4; s->USARTx = USART1; s->rxDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->RDR; s->txDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->TDR; RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); 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; if (mode & MODE_TX) { GPIO_InitStructure.GPIO_Pin = UART1_TX_PIN; GPIO_PinAFConfig(UART1_GPIO, UART1_TX_PINSOURCE, GPIO_AF_7); GPIO_Init(UART1_GPIO, &GPIO_InitStructure); } if (mode & MODE_RX) { GPIO_InitStructure.GPIO_Pin = UART1_RX_PIN; GPIO_PinAFConfig(UART1_GPIO, UART1_RX_PINSOURCE, GPIO_AF_7); GPIO_Init(UART1_GPIO, &GPIO_InitStructure); } // DMA TX Interrupt NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); #ifndef USE_USART1_RX_DMA NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); #endif return s; }
void attachInterrupt(uint32_t pin, void (*callback)(void), uint32_t mode) { static int enabled = 0; if (!enabled) { __initialize(); enabled = 1; } uint8_t GPIO_PortSource = 0; //variable to hold the port number uint8_t GPIO_PinSource = 0; //variable to hold the pin number uint16_t PinNumber; //temp variable to calculate the pin number //EXTI structure to init EXT EXTI_InitTypeDef EXTI_InitStructure; //NVIC structure to set up NVIC controller NVIC_InitTypeDef NVIC_InitStructure; GPIO_TypeDef *gpio_port = g_APinDescription[pin].pPort; uint16_t gpio_pin = g_APinDescription[pin].ulPin; #if defined(STM32F10X_HD) || defined (STM32F10X_MD) RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); #elif defined (STM32F40_41xxx) RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG,ENABLE); #endif //Select the port source if (gpio_port == GPIOA ) { #if defined(STM32F10X_HD) || defined (STM32F10X_MD) GPIO_PortSource = GPIO_PortSourceGPIOA; #elif defined (STM32F40_41xxx) GPIO_PortSource = EXTI_PortSourceGPIOA; #endif } else if (gpio_port == GPIOB ) { #if defined(STM32F10X_HD) || defined (STM32F10X_MD) GPIO_PortSource = GPIO_PortSourceGPIOB; #elif defined (STM32F40_41xxx) GPIO_PortSource = EXTI_PortSourceGPIOB; #endif } else if (gpio_port == GPIOC ) { #if defined(STM32F10X_HD) || defined (STM32F10X_MD) GPIO_PortSource = GPIO_PortSourceGPIOC; #elif defined (STM32F40_41xxx) GPIO_PortSource = EXTI_PortSourceGPIOC; #endif } else if (gpio_port == GPIOD ) { #if defined(STM32F10X_HD) || defined (STM32F10X_MD) GPIO_PortSource = GPIO_PortSourceGPIOD; #elif defined (STM32F40_41xxx) GPIO_PortSource = EXTI_PortSourceGPIOD; #endif } else if (gpio_port == GPIOE ) { #if defined(STM32F10X_HD) || defined (STM32F10X_MD) GPIO_PortSource = GPIO_PortSourceGPIOE; #elif defined (STM32F40_41xxx) GPIO_PortSource = EXTI_PortSourceGPIOE; #endif } //Find out the pin number from the mask PinNumber = gpio_pin; PinNumber = PinNumber >> 1; while(PinNumber) { PinNumber = PinNumber >> 1; GPIO_PinSource++; } // Register the handler for the user function name callbacksEXTI[GPIO_PinSource] = callback; //Connect EXTI Line to appropriate Pin #if defined(STM32F10X_HD) || defined (STM32F10X_MD) GPIO_EXTILineConfig(GPIO_PortSource, GPIO_PinSource); #elif defined (STM32F40_41xxx) SYSCFG_EXTILineConfig(GPIO_PortSource, GPIO_PinSource); #endif //Configure GPIO EXTI line EXTI_InitStructure.EXTI_Line = gpio_pin;//EXTI_Line; //select the interrupt mode EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; switch (mode) { //case LOW: //There is no LOW mode in STM32, so using falling edge as default //EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //break; case CHANGE: //generate interrupt on rising or falling edge EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling; break; case RISING: //generate interrupt on rising edge EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; break; case FALLING: //generate interrupt on falling edge EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; break; } //enable EXTI line EXTI_InitStructure.EXTI_LineCmd = ENABLE; //send values to registers EXTI_Init(&EXTI_InitStructure); //configure NVIC //select NVIC channel to configure NVIC_InitStructure.NVIC_IRQChannel = GPIO_IRQn[GPIO_PinSource]; if(GPIO_PinSource > 4) NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 14; else NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 13; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //enable IRQ channel NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //update NVIC registers NVIC_Init(&NVIC_InitStructure); }
void TM_RTC_Interrupts(TM_RTC_Int_t int_value) { uint32_t int_val; /* Clear pending bit */ EXTI_ClearITPendingBit(EXTI_Line22); /* NVIC init for RTC */ NVIC_InitStruct.NVIC_IRQChannel = RTC_WKUP_IRQn; NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = RTC_PRIORITY; NVIC_InitStruct.NVIC_IRQChannelSubPriority = RTC_WAKEUP_SUBPRIORITY; /* RTC connected to EXTI_Line22 */ EXTI_InitStruct.EXTI_Line = EXTI_Line22; EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising; if (int_value == TM_RTC_Int_Disable) { /* Disable wakeup interrupt */ RTC_WakeUpCmd(DISABLE); /* Disable RTC interrupt flag */ RTC_ITConfig(RTC_IT_WUT, DISABLE); /* Disable NVIC */ NVIC_InitStruct.NVIC_IRQChannelCmd = DISABLE; NVIC_Init(&NVIC_InitStruct); /* Disable EXT1 interrupt */ EXTI_InitStruct.EXTI_LineCmd = DISABLE; EXTI_Init(&EXTI_InitStruct); } else { /* Enable NVIC */ NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStruct); /* Enable EXT1 interrupt */ EXTI_InitStruct.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTI_InitStruct); /* First disable wake up command */ RTC_WakeUpCmd(DISABLE); if (int_value == TM_RTC_Int_60s) { int_val = 0x3BFFF; /* 60 seconds = 60 * 4096 / 1 = 245760 */ } else if (int_value == TM_RTC_Int_30s) { int_val = 0x1DFFF; /* 30 seconds */ } else if (int_value == TM_RTC_Int_15s) { int_val = 0xEFFF; /* 15 seconds */ } else if (int_value == TM_RTC_Int_10s) { int_val = 0x9FFF; /* 10 seconds */ } else if (int_value == TM_RTC_Int_5s) { int_val = 0x4FFF; /* 5 seconds */ } else if (int_value == TM_RTC_Int_2s) { int_val = 0x1FFF; /* 2 seconds */ } else if (int_value == TM_RTC_Int_1s) { int_val = 0x0FFF; /* 1 second */ } else if (int_value == TM_RTC_Int_500ms) { int_val = 0x7FF; /* 500 ms */ } else if (int_value == TM_RTC_Int_250ms) { int_val = 0x3FF; /* 250 ms */ } else if (int_value == TM_RTC_Int_125ms) { int_val = 0x1FF; /* 125 ms */ } /* Clock divided by 8, 32768 / 8 = 4068 */ /* 4096 ticks for 1second interrupt */ RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div8); /* Set RTC wakeup counter */ RTC_SetWakeUpCounter(int_val); /* Enable wakeup interrupt */ RTC_ITConfig(RTC_IT_WUT, ENABLE); /* Enable wakeup command */ RTC_WakeUpCmd(ENABLE); } }
void VedioBoard_Com3Init(void) { USART_InitTypeDef USART_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; DMA_InitTypeDef DMA_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; /* Peripheral Clock Enable -------------------------------------------------*/ /* Enable GPIO clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOB, ENABLE); /* Enable USART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); /* Enable the DMA clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE); /* USART3 GPIO configuration -----------------------------------------------*/ /* Connect USART pins to AF7 */ GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_USART3); GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_USART3); /* Configure USART Tx and Rx as alternate function push-pull */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; GPIO_Init(GPIOB, &GPIO_InitStructure); /* USART3 configuration ----------------------------------------------------*/ /* Enable the USART OverSampling by 8 */ USART_OverSampling8Cmd(USART3, ENABLE); /* USART3 configured as follow: - BaudRate = 5250000 baud - Maximum BaudRate that can be achieved when using the Oversampling by 8 is: (USART APB Clock / 8) Example: - (USART3 APB1 Clock / 8) = (42 MHz / 8) = 5250000 baud - (USART1 APB2 Clock / 8) = (84 MHz / 8) = 10500000 baud - Maximum BaudRate that can be achieved when using the Oversampling by 16 is: (USART APB Clock / 16) Example: (USART3 APB1 Clock / 16) = (42 MHz / 16) = 2625000 baud Example: (USART1 APB2 Clock / 16) = (84 MHz / 16) = 5250000 baud - Word Length = 8 Bits - one Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = 115200; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; /* When using Parity the word length must be configured to 9 bits */ USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_Init(USART3, &USART_InitStructure); /* Configure DMA controller to manage USART TX and RX DMA request ----------*/ /* Configure DMA Initialization Structure */ DMA_InitStructure.DMA_BufferSize = BOARDRXLEN; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable ; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull ; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single ; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_PeripheralBaseAddr =(uint32_t) (&(USART3->DR)) ; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_Priority = DMA_Priority_High; /* Configure TX DMA */ // DMA_InitStructure.DMA_Channel = DMA_Channel_4 ; // DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral ; // DMA_InitStructure.DMA_Memory0BaseAddr =(uint32_t)BCTxBuffer; // // DMA_Init(DMA1_Stream3,&DMA_InitStructure); /* Configure RX DMA */ DMA_InitStructure.DMA_Channel = DMA_Channel_4 ; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; DMA_InitStructure.DMA_Memory0BaseAddr =(uint32_t)BCRxBuffer ; DMA_Init(DMA1_Stream1,&DMA_InitStructure); DMA_ITConfig(DMA1_Stream1, DMA_IT_TC, ENABLE); NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable USART */ USART_Cmd(USART3, ENABLE); }
void timerInit( void) { TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; TIM_OCInitTypeDef TIM_OCInitStructure; GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; /* Description: PA8 --> TIM1_CH1 PA6 --> TIM3_CH1 PA7 --> TIM3_CH2 PB0 --> TIM3_CH3 PB1 --> TIM3_CH4 PB6 --> TIM4_CH1 PB7 --> TIM4_CH2 PB8 --> TIM4_CH3 PB9 --> TIM4_CH4 TIM2 dinh thoi gian xu ly 1ms */ #ifdef VECT_TAB_RAM /* Set the Vector Table base location at 0x20000000 */ NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); #else /* VECT_TAB_FLASH */ /* Set the Vector Table base location at 0x08000000 */ NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0); #endif /* configuration gpio of pin enable l6234*/ GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable,ENABLE); GPIO_InitStructure.GPIO_Pin = PIN_EN_MOTOR ; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(PORT_EN_MOTOR, &GPIO_InitStructure); /* configuration gpio for pwm */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 ; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_8 | GPIO_Pin_9; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOB, &GPIO_InitStructure); /** PWM ------------------------------------------------------------------------------------------------------------------------*/ /* Time Base configuration */ TIM_TimeBaseStructure.TIM_Prescaler = 1; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_Period = MOTOR_FREQ_36KHZ; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* Channel 1 Configuration in PWM mode */ // TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2; TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Disable; //disable khi dung spi2 tranh dung channel Not. TIM_OCInitStructure.TIM_Pulse = 0; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_Low; TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set; TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset; TIM_OC1Init(TIM1, &TIM_OCInitStructure); /* TIM1 counter enable */ TIM_Cmd(TIM1, ENABLE); /* TIM1 Main Output Enable */ TIM_CtrlPWMOutputs(TIM1, ENABLE); /* set Timer 3 clock running at 36Mhz */ TIM_TimeBaseStructure.TIM_Period =MOTOR_FREQ_36KHZ; TIM_TimeBaseStructure.TIM_Prescaler = 0; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); TIM_PrescalerConfig(TIM3, 0, TIM_PSCReloadMode_Immediate); // /* PWM Mode configuration for Channel 1 : TIM3_CCR1 */ // TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // TIM_OCInitStructure.TIM_Pulse = 0; // TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; // TIM_OC1Init(TIM3, &TIM_OCInitStructure); // TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable); /* PWM Mode configuration for Channel 2 : TIM3_CCR2 */ TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse =0; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC2Init(TIM3, &TIM_OCInitStructure); TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable); /* PWM Mode configuration for Channel 3 : TIM3_CCR3 */ TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse = 0; TIM_OC3Init(TIM3, &TIM_OCInitStructure); TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable); /* PWM Mode configuration for Channel 4 : TIM3_CCR4 */ // TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // TIM_OCInitStructure.TIM_Pulse = 0; // TIM_OC4Init(TIM3, &TIM_OCInitStructure); // TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable); TIM_ARRPreloadConfig(TIM3, ENABLE); TIM_Cmd(TIM3, ENABLE); /* set Timer 4 clock running at 36Mhz */ TIM_TimeBaseStructure.TIM_Period = MOTOR_FREQ_36KHZ; TIM_TimeBaseStructure.TIM_Prescaler = 0; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); TIM_PrescalerConfig(TIM4, 0, TIM_PSCReloadMode_Immediate); /* PWM Mode configuration for Channel 1 : TIM4_CCR1 */ // TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // TIM_OCInitStructure.TIM_Pulse = 0; // TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; // TIM_OC1Init(TIM4, &TIM_OCInitStructure); // TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable); // // /* PWM Mode configuration for Channel 2 : TIM4_CCR2 */ // TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // TIM_OCInitStructure.TIM_Pulse =0; // TIM_OC2Init(TIM4, &TIM_OCInitStructure); // TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable); /* PWM Mode configuration for Channel 3 : TIM4_CCR3 */ TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse =0; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OC3Init(TIM4, &TIM_OCInitStructure); TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable); /* PWM Mode configuration for Channel 4 : TIM4_CCR4 */ TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse =0; TIM_OC4Init(TIM4, &TIM_OCInitStructure); TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable); TIM_ARRPreloadConfig(TIM4, ENABLE); TIM_Cmd(TIM4, ENABLE); /* TIME BASE -------------------------------------------------------------------------------------------------------------------*/ /* set Timer 2 clock running at 36Mhz */ TIM_TimeBaseStructure.TIM_Period = FREQ_1KHZ; TIM_TimeBaseStructure.TIM_Prescaler = 0; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); TIM_PrescalerConfig(TIM2, 0, TIM_PSCReloadMode_Immediate); TIM_ARRPreloadConfig(TIM2, ENABLE); /* set timer 2 interrup to make 1ms update tick */ TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); TIM_Cmd(TIM2, ENABLE); NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //3 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //0 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }
void adcInit(void) { ADC_InitTypeDef ADC_InitStructure; DMA_InitTypeDef DMA_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; int i; adcSetConstants(); histSize = ADC_HIST_SIZE; // Use STM32's Dual Regular Simultaneous Mode capable of ~ 1.7M samples per second // NOTE: assume that RCC code has already placed all pins into Analog In mode during startup // DMA1 channel1 configuration (ADC1) DMA_DeInit(DMA1_Channel1); DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)ADC1 + 0x4c; DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&adcRawData[0]; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = sizeof(adcRawData)/4; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word; DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA1_Channel1, &DMA_InitStructure); DMA_ITConfig(DMA1_Channel1, DMA_IT_TC | DMA_IT_HT, ENABLE); DMA_ClearITPendingBit(DMA1_IT_GL1 | DMA1_IT_TC1 | DMA1_IT_HT1); DMA_Cmd(DMA1_Channel1, ENABLE); // Enable the DMA1_Channel1 global Interrupt NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); // ADC1 configuration // ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult; ADC_InitStructure.ADC_Mode = ADC_Mode_RegInjecSimult; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = sizeof(adcRawData)/4; ADC_Init(ADC1, &ADC_InitStructure); #ifdef ADC_FAST_SAMPLE ADC_RegularChannelConfig(ADC1, ADC_Channel_5, 1, ADC_SAMPLE_TIME); // SENSE_CURRENT ADC_RegularChannelConfig(ADC1, ADC_Channel_5, 2, ADC_SAMPLE_TIME); // SENSE_CURRENT ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 3, ADC_SAMPLE_TIME); // SENSE_B ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 4, ADC_SAMPLE_TIME); // SENSE_B ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 5, ADC_SAMPLE_TIME); // SENSE_VIN ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 6, ADC_SAMPLE_TIME); // SENSE_VIN ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 7, ADC_SAMPLE_TIME); // SENSE_B ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 8, ADC_SAMPLE_TIME); // SENSE_B #else ADC_RegularChannelConfig(ADC1, ADC_Channel_5, 1, ADC_SAMPLE_TIME); // SENSE_CURRENT ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 2, ADC_SAMPLE_TIME); // SENSE_B ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 3, ADC_SAMPLE_TIME); // SENSE_VIN ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 4, ADC_SAMPLE_TIME); // SENSE_B #endif ADC_DMACmd(ADC1, ENABLE); // ADC2 configuration // ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult; ADC_InitStructure.ADC_Mode = ADC_Mode_RegInjecSimult; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = sizeof(adcRawData)/4; ADC_Init(ADC2, &ADC_InitStructure); #ifdef ADC_FAST_SAMPLE ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SAMPLE_TIME); // SENSE_A ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 2, ADC_SAMPLE_TIME); // SENSE_A ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 3, ADC_SAMPLE_TIME); // SENSE_C ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 4, ADC_SAMPLE_TIME); // SENSE_C ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 5, ADC_SAMPLE_TIME); // SENSE_A ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 6, ADC_SAMPLE_TIME); // SENSE_A ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 7, ADC_SAMPLE_TIME); // SENSE_C ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 8, ADC_SAMPLE_TIME); // SENSE_C #else ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SAMPLE_TIME); // SENSE_A ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 2, ADC_SAMPLE_TIME); // SENSE_C ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 3, ADC_SAMPLE_TIME); // SENSE_A ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 4, ADC_SAMPLE_TIME); // SENSE_C #endif ADC_ExternalTrigConvCmd(ADC2, ENABLE); // enable and calibrate ADC_Cmd(ADC1, ENABLE); adcCalibrateADC(ADC1); ADC_Cmd(ADC2, ENABLE); adcCalibrateADC(ADC2); nextCrossingDetect = adcMaxPeriod; // setup injection sequence ADC_InjectedSequencerLengthConfig(ADC1, 1); ADC_InjectedSequencerLengthConfig(ADC2, 1); ADC_InjectedChannelConfig(ADC1, ADC_Channel_5, 1, ADC_SAMPLE_TIME); ADC_InjectedChannelConfig(ADC2, ADC_Channel_4, 1, ADC_SAMPLE_TIME); ADC_ExternalTrigInjectedConvCmd(ADC1, ENABLE); ADC_ExternalTrigInjectedConvCmd(ADC2, ENABLE); ADC_ExternalTrigInjectedConvConfig(ADC1, ADC_ExternalTrigInjecConv_None); ADC_ExternalTrigInjectedConvConfig(ADC2, ADC_ExternalTrigInjecConv_None); // Start ADC1 / ADC2 Conversions ADC_SoftwareStartConvCmd(ADC1, ENABLE); }
void hcsr04_init(const sonarHardware_t *initialSonarHardware, sonarRange_t *sonarRange) { sonarHardware = initialSonarHardware; sonarRange->maxRangeCm = HCSR04_MAX_RANGE_CM; sonarRange->detectionConeDeciDegrees = HCSR04_DETECTION_CONE_DECIDEGREES; sonarRange->detectionConeExtendedDeciDegrees = HCSR04_DETECTION_CONE_EXTENDED_DECIDEGREES; #if !defined(UNIT_TEST) gpio_config_t gpio; EXTI_InitTypeDef EXTIInit; #ifdef STM32F10X // enable AFIO for EXTI support RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); #endif #ifdef STM32F303xC RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); /* Enable SYSCFG clock otherwise the EXTI irq handlers are not called */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); #endif // trigger pin gpio.pin = sonarHardware->trigger_pin; gpio.mode = Mode_Out_PP; gpio.speed = Speed_2MHz; gpioInit(GPIOB, &gpio); // echo pin gpio.pin = sonarHardware->echo_pin; gpio.mode = Mode_IN_FLOATING; gpioInit(GPIOB, &gpio); #ifdef STM32F10X // setup external interrupt on echo pin gpioExtiLineConfig(GPIO_PortSourceGPIOB, sonarHardware->exti_pin_source); #endif #ifdef STM32F303xC gpioExtiLineConfig(EXTI_PortSourceGPIOB, sonarHardware->exti_pin_source); #endif EXTI_ClearITPendingBit(sonarHardware->exti_line); EXTIInit.EXTI_Line = sonarHardware->exti_line; EXTIInit.EXTI_Mode = EXTI_Mode_Interrupt; EXTIInit.EXTI_Trigger = EXTI_Trigger_Rising_Falling; EXTIInit.EXTI_LineCmd = ENABLE; EXTI_Init(&EXTIInit); NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = sonarHardware->exti_irqn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SONAR_ECHO); NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SONAR_ECHO); NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); lastMeasurementAt = millis() - 60; // force 1st measurement in hcsr04_get_distance() #else lastMeasurementAt = 0; // to avoid "unused" compiler warning #endif }
uartPort_t *serialUSART3(uint32_t baudRate, portMode_t mode, portOptions_t options) { uartPort_t *s; static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE]; static volatile uint8_t tx3Buffer[UART3_TX_BUFFER_SIZE]; NVIC_InitTypeDef NVIC_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; s = &uartPort3; s->port.vTable = uartVTable; s->port.baudRate = baudRate; s->port.rxBufferSize = UART3_RX_BUFFER_SIZE; s->port.txBufferSize = UART3_TX_BUFFER_SIZE; s->port.rxBuffer = rx3Buffer; s->port.txBuffer = tx3Buffer; s->USARTx = USART3; #ifdef USE_USART3_RX_DMA s->rxDMAChannel = DMA1_Channel3; s->rxDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->RDR; #endif #ifdef USE_USART3_TX_DMA s->txDMAChannel = DMA1_Channel2; s->txDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->TDR; #endif RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); #if defined(USE_USART3_TX_DMA) || defined(USE_USART3_RX_DMA) RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); #endif 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; if (options & SERIAL_BIDIR) { GPIO_InitStructure.GPIO_Pin = UART3_TX_PIN; GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PINSOURCE, UART3_GPIO_AF); GPIO_Init(UART3_GPIO, &GPIO_InitStructure); } else { if (mode & MODE_TX) { GPIO_InitStructure.GPIO_Pin = UART3_TX_PIN; GPIO_PinAFConfig(UART3_GPIO, UART3_TX_PINSOURCE, UART3_GPIO_AF); GPIO_Init(UART3_GPIO, &GPIO_InitStructure); } if (mode & MODE_RX) { GPIO_InitStructure.GPIO_Pin = UART3_RX_PIN; GPIO_PinAFConfig(UART3_GPIO, UART3_RX_PINSOURCE, UART3_GPIO_AF); GPIO_Init(UART3_GPIO, &GPIO_InitStructure); } } #ifdef USE_USART3_TX_DMA // DMA TX Interrupt NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART3_TXDMA); NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART3_TXDMA); NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); #endif #ifndef USE_USART3_RX_DMA NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART3_RXDMA); NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART3_RXDMA); NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); #endif return s; }
//默认一个主机 串口2 波特率可设置 奇偶检验可设置 BOOL xMBMasterPortSerialInit(UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity) { GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; //======================时钟初始化======================================= RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); //======================IO初始化======================================= //USART2_TX GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; GPIO_Init(GPIOA, &GPIO_InitStructure); //USART2_RX GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; GPIO_Init(GPIOA, &GPIO_InitStructure); //配置485发送和接收模式 // TODO 暂时先写B13 等之后组网测试时再修改 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13; GPIO_Init(GPIOB, &GPIO_InitStructure); //======================串口初始化======================================= USART_InitStructure.USART_BaudRate = ulBaudRate; //设置校验模式 switch (eParity) { case MB_PAR_NONE: //无校验 USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_WordLength = USART_WordLength_8b; break; case MB_PAR_ODD: //奇校验 USART_InitStructure.USART_Parity = USART_Parity_Odd; USART_InitStructure.USART_WordLength = USART_WordLength_9b; break; case MB_PAR_EVEN: //偶校验 USART_InitStructure.USART_Parity = USART_Parity_Even; USART_InitStructure.USART_WordLength = USART_WordLength_9b; break; default: return FALSE; } USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; if (ucPORT != 2) return FALSE; ENTER_CRITICAL_SECTION(); //关全局中断 USART_Init(USART2, &USART_InitStructure); USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); USART_Cmd(USART2, ENABLE); //=====================中断初始化====================================== //设置NVIC优先级分组为Group2:0-3抢占式优先级,0-3的响应式优先级 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); EXIT_CRITICAL_SECTION(); //开全局中断 return TRUE; }