/** * @brief This function handles DMA1 Stream1 interrupt request. * @param None * @retval None */ void DMA1_Stream1_IRQHandler(void) { if(DMA_GetITStatus(DMA1_Stream1, DMA_IT_TCIF1)) { DMA_ClearITPendingBit(DMA1_Stream1, DMA_IT_TCIF1); /* Check the received buffer */ ubTestStatus = Buffercmp16(aSrcBuffer, aDstBuffer, 10); if(ubTestStatus == 0) { STM_EVAL_LEDToggle(LED2); } else { STM_EVAL_LEDToggle(LED3); } } }
void DMA2_Stream0_IRQHandler(void){ //5kHz DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_TCIF0); GPIO_SetBits(GPIOB,GPIO_Pin_8); int freq = 5000; float period = 1.0 / freq; //GPIO_ResetBits(GPIOB,GPIO_Pin_3);//messpin systime_s += period; unsigned int start = SysTick->VAL; for(int i = 0; i < hal.rt_func_count; i++){ hal.rt[i](period); } unsigned int end = SysTick->VAL; if(start > end){ PIN(rt_time) = ((float)(start - end)) / RCC_Clocks.HCLK_Frequency; } GPIO_ResetBits(GPIOB,GPIO_Pin_8); }
/** * @brief This function handles the DMA end of transfer fro ADC read * and processing of ADC stick data then calls the mixer. * @param None * @retval None */ void DMA1_Channel1_IRQHandler(void) { DMA_ClearFlag(DMA1_FLAG_TC1); DMA_ClearITPendingBit(DMA_IT_TC); // update the sticks data now sticks_update(); // Don't run the mixer if we're calibrating if (cal_state == CAL_OFF) { if (!g_modelInvalid) { // Run the mixer. mixer_update(); } } else // if (cal_state != CAL_OFF) { cal_update(); } }
/* UART4 Rx; I2C_2 Rx; I2C 3 Rx */ void DMA1_Stream2_IRQHandler(void) { /* Test on DMA Stream Transfer Complete interrupt */ if (DMA_GetITStatus(DMA1_Stream2, DMA_IT_TCIF2)) { DMA_DeInit(DMA1_Stream2); DMA_Init(DMA1_Stream2, &RxStruct[0][2]); USART_DMACmd(UART4, USART_DMAReq_Rx, ENABLE); DMA_ITConfig(DMA1_Stream2, DMA_IT_TC, ENABLE); DMA_Cmd(DMA1_Stream2, ENABLE); DMA_ClearITPendingBit(DMA1_Stream2, DMA_IT_TCIF2); } }
/*----------------------------------------------------------*/ void UART3_TX_DMA_Isr(void) { static int len; static unsigned char *p; //DMA传输完成后触发中断,首先清除中断标记。 DMA_ClearITPendingBit(DMA1_IT_TC2); //将使用过的缓冲区放回内存池。 Cycbuf_NextTailFrame(&U3SendBuf); //将DMA关闭。 DMA_Cmd(DMA1_Channel2, DISABLE); //获取下一个缓冲区 len = Cycbuf_GetAvailFrmTailp(&U3SendBuf,&p); //如果获取到了数据 if( len > 0 ) UART3_TX_DMAStart(p,len); }
/** * @brief This function handles DMA1 Channel 5 interrupt request. * @param None * @retval None */ void DMA1_Channel5_IRQHandler(void) { if(DMA_GetITStatus(DMA1_IT_TC5)) { DMA_ClearITPendingBit(DMA1_IT_GL5); /* Check the received buffer */ TestStatus = Buffercmp16(SRC_Buffer, DST_Buffer, 10); if(TestStatus == 0) { STM_EVAL_LEDToggle(LED2); } else { STM_EVAL_LEDToggle(LED3); } } }
static void HAL_SPI_RX_DMA_Stream_InterruptHandler(HAL_SPI_Interface spi) { if (DMA_GetITStatus(spiMap[spi].SPI_RX_DMA_Stream, spiMap[spi].SPI_RX_DMA_Stream_TC_Event) == SET) { uint32_t remainingCount = DMA_GetCurrDataCounter(spiMap[spi].SPI_RX_DMA_Stream); if (!spiState[spi].SPI_DMA_Aborted) { while (SPI_I2S_GetFlagStatus(spiMap[spi].SPI_Peripheral, SPI_I2S_FLAG_TXE) == RESET); while (SPI_I2S_GetFlagStatus(spiMap[spi].SPI_Peripheral, SPI_I2S_FLAG_BSY) == SET); } if (spiState[spi].mode == SPI_MODE_SLAVE) { SPI_Cmd(spiMap[spi].SPI_Peripheral, DISABLE); if (spiState[spi].SPI_DMA_Aborted) { /* Reset SPI peripheral completely, othewise we might end up with a case where * SPI peripheral has already loaded some data from aborted transfer into its circular register, * but haven't transferred it out yet. The next transfer then will start with this remainder data. * The only way to clear it out is by completely disabling SPI peripheral (stopping its clock). */ spiState[spi].SPI_DMA_Aborted = 0; SPI_DeInit(spiMap[spi].SPI_Peripheral); HAL_SPI_Begin_Ext(spi, SPI_MODE_SLAVE, spiState[spi].SPI_SS_Pin, NULL); } } DMA_ClearITPendingBit(spiMap[spi].SPI_RX_DMA_Stream, spiMap[spi].SPI_RX_DMA_Stream_TC_Event); SPI_I2S_DMACmd(spiMap[spi].SPI_Peripheral, SPI_I2S_DMAReq_Rx, DISABLE); DMA_Cmd(spiMap[spi].SPI_RX_DMA_Stream, DISABLE); spiState[spi].SPI_DMA_Last_Transfer_Length = spiState[spi].SPI_DMA_Current_Transfer_Length - remainingCount; spiState[spi].SPI_DMA_Configured = 0; HAL_SPI_DMA_UserCallback callback = spiState[spi].SPI_DMA_UserCallback; if (callback) { // notify user program about transfer completion callback(); } } }
void DMA1_Channel1_IRQHandler(void) { uint8_t i; s16 raw; DMA_ClearITPendingBit(DMA1_IT_TC1); for(i=0; i<ADC_Channels; i++){ raw = ADC.raw[i] - ADC.unitsOffset; if(raw < 0) raw = 0; ADC.milivolt[i] = raw * ADC.uVoltsPerUnit / 1000; NFComBuf.ReadAnalogInputs.data[i] = ADC.milivolt[i]; if(ADC.milivolt[i] <= ADC.logicZeroMax_mV) ADC.digital[i/8] &= ~(1 << (i%8)); else if(ADC.milivolt[i] >= ADC.logicOneMin_mV) ADC.digital[i/8] |= (1 << (i%8)); } // NFComBuf.ReadDigitalInputs.data[0] = ADC.digital[0]; }
void ACCE_MASTER_DMA_TX_IRQHandler(void) { uint16_t iTempSPIBusyWait = 0; if(DMA_GetITStatus(ACCE_MASTER_DMA_TX_IT_TC)) { DMA_ClearITPendingBit(ACCE_MASTER_DMA_TX_IT_TC); // Check RXNE, TXE, BUSY first before Set NSS Pin // Here only check Busy flag because SPI trans length must larger than 1 while (__IS_SPI_BUSY(ACCE_MASTER_SPI->SR) && (iTempSPIBusyWait < MAX_ACCE_TX_BUSY_WAIT_TIME)) { iTempSPIBusyWait++; } ACCE_MASTER_NSS_DISABLE; DMA_ITConfig(ACCE_MASTER_DMA_TX_CHN, DMA_IT_TC, DISABLE); DMA_Cmd(ACCE_MASTER_DMA_TX_CHN, DISABLE); FLAG_MOTION_ACCE_COMMU_BUSY = RESET; } }
void DMA1_Channel1_IRQHandler(void) { if(DMA_GetITStatus(DMA1_IT_TC1) == SET) { DMA_ClearITPendingBit(DMA1_IT_TC1); adc1 = (int)(2048-ADC1_Value[0]); adc2 = (int)(2048-ADC1_Value[1]); // Iq=-Ia*Sin(Encoder.P)+(0.57735*Ia+1.1547*Ib)*Cos(Encoder.P); // Id=Ia*Cos(Encoder.P)+(0.57735*Ia+1.1547*Ib)*Sin(Encoder.P); hallValue = (GPIOHALL->IDR&(GPIO_Pin_HALL1+GPIO_Pin_HALL2+GPIO_Pin_HALL3)); canopen_statemachine(); } }
//packet received from DSC complete interrupt -> send new packet to DSC void DMA1_Stream5_IRQHandler() { //check if this is correct interrupt if (DMA_GetITStatus( DMA1_Stream5, DMA_IT_TCIF5 ) == SET) { volatile int a,b; a=__get_BASEPRI(); b=__get_PRIMASK(); //clear interrupt flag to avoid repeating interrupts DMA_ClearITPendingBit( DMA1_Stream5, DMA_IT_TCIF5 ); portBASE_TYPE xYieldRequired = pdFALSE; /* Unblock the task by releasing the semaphore. */ xSemaphoreGiveFromISR( MCCommTaskSemaphore, &xYieldRequired ); //must be called because we're at ISR portEND_SWITCHING_ISR( xYieldRequired ); } }
/*************************************************************************************************** * @fn lcd_data_burst_write * * @brief LCD数据批量写入 * @param buf -- 要写入的数据的缓存 * len -- 写入数据的长度 * @return 1 -- busy * -1 - failure * 0 -- success ***************************************************************************************************/ int lcd_data_burst_write(uint8_t *buf, uint16_t len) { IF_PTR_IS_NULL_RET_NULLPTR_ERR(buf); if(len > LCD_TX_BUFF_SIZE) { printf("lcd write lenth is too large,return @ %s, %s, %d\r\n", __FILE__, __func__, __LINE__); return -1; } if(g_LcdWriteBusyFlag) { printf("lcd is busy, return @ %s, %s, %d\r\n", __FILE__, __func__, __LINE__); return 1; } g_LcdWriteBusyFlag = 1; lcd_cursor_addr_set(0,0); LCD_A0_HIGH(); LCD_NCS_LOW(); //启动DMA DMA_Cmd(LCD_DMA_STREAM, DISABLE); DMA_ClearITPendingBit(LCD_DMA_STREAM, LCD_DMA_TC_FLAG); memcpy(g_lcdTxBuff, buf, len); DMA_SetCurrDataCounter(LCD_DMA_STREAM, len); SPI_I2S_DMACmd(LCD_SPI_MASTER,SPI_I2S_DMAReq_Tx,ENABLE); DMA_ITConfig(LCD_DMA_STREAM, DMA_IT_TC, ENABLE); DMA_Cmd(LCD_DMA_STREAM,ENABLE); printf("begin lcd dma write @ %s, %s, %d\r\n", __FILE__, __func__, __LINE__); printf(" SPI3->CR1:%#x, SPI3->CR2:%#x, SPI3->SR:%#x, DMA1_Stream7->CR:%#x, DMA1->HIFCR:%#x\r\n", SPI3->CR1, SPI3->CR2, SPI3->SR, DMA1_Stream7->CR, DMA1->HIFCR); return 0; }
void DMA1_Channel1_IRQHandler(void) { if(DMA_GetITStatus(DMA1_IT_TC1) != RESET) { ADC_SoftwareStartConvCmd(ADC1, DISABLE); filter(); //printf("DMA"); // DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, DISABLE); // for(x=0;x<2;x++) // { // for(y=0;y<32;y++) // printf("%d,,,",ADC_ConvertedValue[y][x]); // printf("----------------------------------------------------\n"); // } // DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE); } DMA_ClearITPendingBit(DMA1_IT_TC1); }
void DMA1_Stream0_IRQHandler(void) { uint8_t Key_Down; //Check to see which set of buffers are currently in use DMA_RX_Memory = DMA_GetCurrentMemoryTarget(DMA1_Stream0 ); DMA_TX_Memory = DMA_GetCurrentMemoryTarget(DMA1_Stream5 ); if (Tx_Flag == 0) { Rcvr_DSP(); } else { switch (Mode_GetCurrentMode()) { case MODE_SSB: Xmit_SSB(); break; case MODE_CW: Key_Down = GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_9 ); if (Key_Down == 0) key = Amp0; else key = 0.0; Xmit_CW(); break; case MODE_PSK: Xmit_PSK(); break; } //End of Mode Switch } DSP_Flag = 1; //Clear the DMA buffer full interrupt flag DMA_ClearITPendingBit(DMA1_Stream0, DMA_IT_TCIF0 ); }
/******************************************************************************* * Function Name : DMA1_Channel5_IRQHandler * Description : This function handles DMA1 Channel 5 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel5_IRQHandler(void) { if(DMA_GetITStatus(DMA1_IT_TC5)) { DMA_ClearITPendingBit(DMA1_IT_TC5); /* Check the received buffer */ TestStatus = Buffercmp16(SRC_Buffer, DST_Buffer, 10); if(TestStatus == 0) { GPIO_WriteBit(GPIO_LED, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_7))); } else { GPIO_WriteBit(GPIO_LED, GPIO_Pin_8, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_8))); } /* Re-configure DMA1 */ DMA_Configuration(); } }
/*************************************************************************************************** * @fn lcd_dma_irq_handler_callback * * @brief LCD DMA写入中断回调函数,完成关闭DMA * @param NULL * @return NULL ***************************************************************************************************/ void lcd_dma_irq_handler_callback(void) { if(DMA_GetITStatus(LCD_DMA_STREAM, LCD_DMA_TC_FLAG) != RESET) { DMA_Cmd(LCD_DMA_STREAM,DISABLE); DMA_ClearITPendingBit(LCD_DMA_STREAM, LCD_DMA_TC_FLAG); DMA_ITConfig(LCD_DMA_STREAM, DMA_IT_TC, DISABLE); SPI_I2S_DMACmd(LCD_SPI_MASTER,SPI_I2S_DMAReq_Tx,DISABLE); while ( LCD_SPI_MASTER->SR & SPI_SR_BSY ) { /* Wait for SPI to finish sending data The DMA TX End interrupt comes two bytes before the end of SPI transmission, therefore we have to wait here. */ } LCD_NCS_HIGH(); g_LcdWriteBusyFlag = 0; printf("enter in lcd dma irq @ %s, %s, %d\r\n", __FILE__, __func__, __LINE__); } }
/** * @brief This function handles DMA1 Channel 3 interrupt request. * @param None * @retval : None */ void DMA1_Channel3_IRQHandler(void) { DMA_InitTypeDef DMA_InitStructure; if (FirstEntry == 1) { /* DMA1 channel3 configuration */ DMA_DeInit(DMA1_Channel3); DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(DMASourceAddress + 0x1FFFF); DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)0x6C000002; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = 11265; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Enable; DMA_Init(DMA1_Channel3, &DMA_InitStructure); /* Enable DMA Channel3 Transfer Complete interrupt */ DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE); /* Enable DMA1 channel3 */ DMA_Cmd(DMA1_Channel3, ENABLE); FirstEntry = 0; } else { DMA_Cmd(DMA1_Channel3, DISABLE); LCD_WriteReg(R3, 0x1018); DMAComplete = 1; } DMA_ClearITPendingBit(DMA1_IT_GL3); }
void DMA2_Stream1_IRQHandler(void) { DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1); //DMA_ClearFlag(DMA2_Stream1,DMA_IT_TCIF1); }
/*----------------------------------------------------------------------------- Function Name : adc_IRQHandler Description : dma channel1 interrupt handler Input : ADC_Val - 4byte Output : None Return : None Comments : .. -----------------------------------------------------------------------------*/ void adc_DMA1_Channel1_IRQHandler(void) { /* Clear DMA1 TC1 pending interrupt bit */ DMA_ClearITPendingBit(DMA2_Stream1,DMA_IT_TCIF1); }
void DMAChannel6_IRQHandler(void) { currDataCounter = DMA_GetCurrDataCounter(DMA1_Channel6); DMA_ClearITPendingBit(DMA1_IT_GL6); }
void restart_periodic_interrupt() { DMA_ClearITPendingBit(DMAx_StreamY_endADC_autoADC, DMAx_IT_TCIFy_endADC_autoADC); // 割り込みフラグのクリア DMA_ITConfig(DMAx_StreamY_endADC_autoADC, DMA_IT_TC, ENABLE); }
void sharps_init(sharps_t* sharps) { ADC_TypeDef* ADCx = ADC1; sharp_t* ADCs = sharps->ADCs; DMA_Channel_TypeDef* DMA = DMA1_Channel1; dma_clock_init(DMA1); adc_clock_init(sharps->ADCx); GPIO_InitTypeDef GPIO_InitStructure = { .GPIO_Pin = 0, .GPIO_Speed = GPIO_Mode_IN_FLOATING, .GPIO_Mode = GPIO_Speed_2MHz, }; for (int i = 0; i < sharps->number; i++) { gpio_clock_init(ADCs[i].GPIOx); GPIO_InitStructure.GPIO_Pin = ADCs[i].GPIO_Pin_x; GPIO_Init(ADCs[i].GPIOx, &GPIO_InitStructure); } ADC_DeInit(ADCx); ADC_Cmd(ADCx, ENABLE); // Wait until it stabilizes wait_us(1000); ADC_InitTypeDef ADC_InitStructure; ADC_StructInit(&ADC_InitStructure); ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; ADC_InitStructure.ADC_ScanConvMode = ENABLE; ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_NbrOfChannel = sharps->number; ADC_Init(ADCx, &ADC_InitStructure); ADC_ResetCalibration(ADCx); while (ADC_GetResetCalibrationStatus(ADCx)); ADC_StartCalibration(ADCx); while (ADC_GetCalibrationStatus(ADCx)); for (int i = 0; i < sharps->number; i++) ADC_RegularChannelConfig(ADCx, ADCs[i].ADC_Channel, i + 1, ADC_SampleTime_239Cycles5); ADC_Cmd(ADCx, ENABLE); DMA_DeInit(DMA); DMA_InitTypeDef DMA_InitStructure; DMA_StructInit(&DMA_InitStructure); DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)ADCx->DR; DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADC_DMA_Buffer; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = sharps->number; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; // 16 ? DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA, &DMA_InitStructure); DMA_ITConfig(DMA, DMA_IT_TC, ENABLE); NVIC_InitTypeDef NVIC_InitStructure = { .NVIC_IRQChannel = DMA1_Channel1_IRQn, .NVIC_IRQChannelPreemptionPriority = 3, // ? .NVIC_IRQChannelSubPriority = 3, // ? .NVIC_IRQChannelCmd = ENABLE, }; NVIC_Init(&NVIC_InitStructure); DMA_Cmd(DMA, ENABLE); vSemaphoreCreateBinary(xSharpsSemaphore); } void DMA1_Channel1_IRQHandler() { portBASE_TYPE resched = pdFALSE; if (DMA_GetFlagStatus(DMA1_FLAG_TC1)) { xSemaphoreGiveFromISR(xSharpsSemaphore, &resched); DMA_ClearITPendingBit(DMA1_IT_TC1); } portEND_SWITCHING_ISR(resched); } void sharps_smooth_task(void* pvParameters) { static int i = 0; static uint32_t average[SHARPS_MAX_NUMBER] = {0}; for (;;) { xSemaphoreTake(xSharpsSemaphore, portMAX_DELAY); for (int j = 0; j < SHARPS_MAX_NUMBER; j++) average[j] += ADC_DMA_Buffer[j]; i++; if (i == AVERAGE_NUMBER) { for (int j = 0; j < SHARPS_MAX_NUMBER; j++) { ADC_Smoothed[j] = average[j] / AVERAGE_NUMBER; average[j] = 0; } i = 0; } } } uint16_t sharps_get_value(int i) { return ADC_Smoothed[i]; }
int main() { SysTick_Config(SystemCoreClock / 1000); InitLeds(); GPIO_SetBits(GPIOD, GREEN_LED); Delay(100); GPIO_ResetBits(GPIOD, GREEN_LED); GPIO_SetBits(GPIOD, ORANGE_LED); Delay(100); GPIO_ResetBits(GPIOD, ORANGE_LED); GPIO_SetBits(GPIOD, RED_LED); Delay(100); GPIO_ResetBits(GPIOD, RED_LED); GPIO_SetBits(GPIOD, BLUE_LED); Delay(100); GPIO_ResetBits(GPIOD, BLUE_LED); /** * USART */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC, ENABLE); GPIO_PinAFConfig(USART2_TX_PORT, USART2_TX_PIN_SOURCE, GPIO_AF_USART2); GPIO_PinAFConfig(USART2_RX_PORT, USART2_RX_PIN_SOURCE, GPIO_AF_USART2); /* Configure USART Tx as alternate function */ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Pin = USART2_TX_PIN; GPIO_Init(USART2_TX_PORT, &GPIO_InitStructure); /* Configure USART Rx as alternate function */ GPIO_InitStructure.GPIO_Pin = USART2_RX_PIN; GPIO_Init(USART2_RX_PORT, &GPIO_InitStructure); USART_InitTypeDef USART_InitStructure; USART_InitStructure.USART_BaudRate = 115200; 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(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Serial_print(USART2, "Hello World! -- Compiled on: "); Serial_print(USART2, __DATE__); Serial_print(USART2, " - "); Serial_println(USART2, __TIME__); /** * Interrupts */ NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = DCMI_IRQn; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_Init(&NVIC_InitStructure); DCMI_ClearITPendingBit(DCMI_IT_FRAME | DCMI_IT_OVF | DCMI_IT_ERR); DCMI_ITConfig(DCMI_IT_FRAME | DCMI_IT_OVF | DCMI_IT_ERR, ENABLE); NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_Init(&NVIC_InitStructure); DMA_ClearITPendingBit(DMA2_Stream1, DMA_IT_TCIF1 | DMA_IT_TEIF1); DMA_ITConfig(DMA2_Stream1, DMA_IT_TC | DMA_IT_FE | DMA_IT_TE | DMA_IT_DME, ENABLE); Serial_print(USART2, "Interrupts done. \r\n"); /** Camera Reset Pin & Power Down Pin */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Speed = GPIO_Low_Speed; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_9; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_SetBits(GPIOA, GPIO_Pin_10); GPIO_ResetBits(GPIOA, GPIO_Pin_9); /** * DCMI */ OV2640_HW_Init(); Serial_print(USART2, "HW_Init done. \r\n"); /* Print camera Id */ OV2640_IDTypeDef camera_id; OV2640_ReadID(&camera_id); Serial_print(USART2, "Camera ID: "); Serial_print(USART2, camera_id.Manufacturer_ID1, 16); Serial_print(USART2, " - "); Serial_print(USART2, camera_id.Manufacturer_ID2, 16); Serial_print(USART2, " - "); Serial_print(USART2, camera_id.PIDH, 16); Serial_print(USART2, " - "); Serial_print(USART2, camera_id.PIDL, 16); Serial_println(USART2, ""); OV2640_QQVGAConfig(); Serial_print(USART2, "QQVGAConfig done. \r\n"); // OV2640_BandWConfig(0x18); // BW OV2640_Init(BMP_QQVGA); Serial_print(USART2, "Init done. \r\n"); // Memset int i; for (i=0; i<160*120; i++) { Targetbuffer[i] = 0xbeef; } DMA_Cmd(DMA2_Stream1, ENABLE); while ( DMA_GetCmdStatus(DMA2_Stream1) != ENABLE ) ; Serial_print(USART2, "DMA Enable done. \r\n"); DCMI_Cmd(ENABLE); Serial_print(USART2, "DCMI Enable done. \r\n"); DCMI_CaptureCmd(ENABLE); Serial_print(USART2, "DCMI Capture start. \r\n"); Serial_print(USART2, "Print: \r\n.\r\n.\r\n"); Serial_print(USART2, "done. \r\n"); Delay(1); // Clear screen Serial_print(USART2, 0x1b); Serial_print(USART2, "[2J"); while (1) { while (DCMI_GetFlagStatus(DCMI_FLAG_FRAMERI) == RESET) ; print_CameraData(); // Move cursor to home position. Serial_print(USART2, 0x1b); Serial_print(USART2, "[H"); } }
/***************************************************************************** Prototype : DMA1_Channel2_IRQHandler Description : uart3 DMA-Tx Handler Input : void Output : None Return Value : Calls : Called By : History : 1.Date : 2015/9/7 Author : qiuweibo Modification : Created function *****************************************************************************/ void DMA1_Channel2_IRQHandler(void) { BaseType_t xHigherPriorityTaskWoken, xResult; // xHigherPriorityTaskWoken must be initialised to pdFALSE. xHigherPriorityTaskWoken = pdFALSE; DMA_ClearITPendingBit(DMA1_IT_TC2); DMA_Cmd(DMA1_Channel2, DISABLE); // close DMA xResult = xSemaphoreTakeFromISR( xSerialTxHandleLock, &xHigherPriorityTaskWoken); if( pdTRUE != xResult) { return; } //After finish this send mission, need to do: clear status --> check next mission if (uart3_tx_dma_buf.IdleBufferIndex) { // reset buffer1 uart3_tx_dma_buf.nBuff1Offset = 0; // check for buffer2 if (uart3_tx_dma_buf.nBuff2Offset > 0) { DMA1_Channel2->CMAR = (uint32_t)uart3_tx_dma_buf.pPingPongBuff2; DMA1_Channel2->CNDTR = uart3_tx_dma_buf.nBuff2Offset; uart3_tx_dma_buf.IdleBufferIndex = 0; DMA_Cmd(DMA1_Channel2, ENABLE); // open DMA } else { uart3_tx_dma_buf.IsDMAWroking = 0; } } else { //reset buffer2 uart3_tx_dma_buf.nBuff2Offset = 0; // check for buffer1 if (uart3_tx_dma_buf.nBuff1Offset > 0) { DMA1_Channel2->CMAR = (uint32_t)uart3_tx_dma_buf.pPingPongBuff1; DMA1_Channel2->CNDTR = uart3_tx_dma_buf.nBuff1Offset; uart3_tx_dma_buf.IdleBufferIndex = 1; DMA_Cmd(DMA1_Channel2, ENABLE); // open DMA } else { uart3_tx_dma_buf.IsDMAWroking = 0; } } xResult = xSemaphoreGiveFromISR( xSerialTxHandleLock , &xHigherPriorityTaskWoken); if( xResult == pdPASS ) { // If xHigherPriorityTaskWoken is now set to pdTRUE then a context // switch should be requested. The macro used is port specific and // will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() - // refer to the documentation page for the port being used. portYIELD_FROM_ISR( xHigherPriorityTaskWoken ); } }
void DMA1_Channel1_IRQHandler(void) { DMA_ClearITPendingBit(DMA1_IT_TC1); }
void spi1Init(void) { GPIO_InitTypeDef GPIO_InitStructure; SPI_InitTypeDef SPI_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; DMA_InitTypeDef DMA_InitStructure; if (!spiData[0].initialized) { // SPI interface RCC_APB2PeriphClockCmd(SPI_SPI1_CLOCK, ENABLE); GPIO_StructInit(&GPIO_InitStructure); 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; // SPI SCK / MOSI / MISO pin configuration GPIO_InitStructure.GPIO_Pin = SPI_SPI1_SCK_PIN; GPIO_Init(SPI_SPI1_SCK_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = SPI_SPI1_MISO_PIN; GPIO_Init(SPI_SPI1_MISO_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = SPI_SPI1_MOSI_PIN; GPIO_Init(SPI_SPI1_MOSI_PORT, &GPIO_InitStructure); // Connect SPI pins to Alternate Function GPIO_PinAFConfig(SPI_SPI1_SCK_PORT,SPI_SPI1_SCK_SOURCE, SPI_SPI1_AF); GPIO_PinAFConfig(SPI_SPI1_MISO_PORT, SPI_SPI1_MISO_SOURCE, SPI_SPI1_AF); GPIO_PinAFConfig(SPI_SPI1_MOSI_PORT, SPI_SPI1_MOSI_SOURCE, SPI_SPI1_AF); // SPI configuration SPI_I2S_DeInit(SPI1); SPI_InitStructure.SPI_Mode = SPI_Mode_Master; SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; SPI_InitStructure.SPI_CRCPolynomial = 7; SPI_Init(SPI1, &SPI_InitStructure); SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, ENABLE); // RX DMA DMA_DeInit(SPI_SPI1_DMA_RX); DMA_StructInit(&DMA_InitStructure); DMA_InitStructure.DMA_Channel = SPI_SPI1_DMA_RX_CHANNEL; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI1->DR; DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)spiData; DMA_InitStructure.DMA_BufferSize = 1; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; // note the buffer must be word aligned DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(SPI_SPI1_DMA_RX, &DMA_InitStructure); // store flags for later use spiData[0].intRxFlags = SPI_SPI1_DMA_RX_FLAGS; DMA_ClearITPendingBit(SPI_SPI1_DMA_RX, spiData[0].intRxFlags); DMA_ITConfig(SPI_SPI1_DMA_RX, DMA_IT_TC, ENABLE); // Enable RX DMA global Interrupt NVIC_InitStructure.NVIC_IRQChannel = SPI_SPI1_DMA_RX_IRQ; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); // TX DMA - one shot DMA_DeInit(SPI_SPI1_DMA_TX); DMA_StructInit(&DMA_InitStructure); DMA_InitStructure.DMA_Channel = SPI_SPI1_DMA_TX_CHANNEL; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI1->DR; DMA_InitStructure.DMA_BufferSize = 1; DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; // note the buffer must be word aligned DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(SPI_SPI1_DMA_TX, &DMA_InitStructure); // store flags for later use spiData[0].intTxFlags = SPI_SPI1_DMA_TX_FLAGS; DMA_ClearITPendingBit(SPI_SPI1_DMA_TX, spiData[0].intTxFlags); spiData[0].spi = SPI1; spiData[0].rxDMAStream = SPI_SPI1_DMA_RX; spiData[0].txDMAStream = SPI_SPI1_DMA_TX; spiData[0].initialized = 1; // Enable Ethernet Interrupt (for our stack management) NVIC_InitStructure.NVIC_IRQChannel = ETH_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } }
void DMA2_Channel4_5_IRQHandler(void) { DMA_ClearITPendingBit(DMA2_IT_TC5); //ADC_DMACmd(ADC3, DISABLE); }
/************************************************************************* * Function Name: MmcInit * Parameters: none * Return: none * * Description: Init SPI, Cart Present, Write Protect and Chip select pins * *************************************************************************/ void MmcInit (void) { SPI_InitTypeDef SPI_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; // Enable GPIO clocks RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE); // Enable SPI2 Periphery clock RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); // Deinitializes the SPI2 SPI_DeInit(SPI2); // Release reset of GPIOB, GPIOC RCC_APB2PeriphResetCmd( RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, DISABLE); // Configure SPI2_CLK, SPI2_MOSI, SPI2_nCS1, Card Present and Write Protect pins GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_Pin = SD_CS; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Pin = SD_SCLK | SD_MOSI | SD_MISO; GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_InitStructure.GPIO_Pin = SD_CP | SD_WP; GPIO_Init(GPIOC, &GPIO_InitStructure); // Chip select MmcChipSelect(0); // Spi init SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_Mode = SPI_Mode_Master; 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_256; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_CRCPolynomial = 7; SPI_Init(SPI2, &SPI_InitStructure); // Enable SPI2 */ SPI_Cmd(SPI2, ENABLE); // Clock Freq. Identification Mode < 400kHz MmcSetClockFreq(IdentificationModeClock); #if SPI_DMA_ENA > 0 // Enable DMA clock RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA, ENABLE); // Clear pending interrupt DMA_ClearITPendingBit( DMA_IT_GL4 | DMA_IT_GL5); // Interrupts DMA enable SPI_DMACmd(SPI2,SPI_DMAReq_Rx,DISABLE); SPI_DMACmd(SPI2,SPI_DMAReq_Tx,DISABLE); #ifndef DMA_ERRATA NVIC_InitTypeDef NVIC_InitStructure; // VIC configuration NVIC_InitStructure.NVIC_IRQChannel = DMAChannel4_IRQChannel; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = SPI_DMA_INTR_PRIO; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_InitStructure.NVIC_IRQChannel = DMAChannel5_IRQChannel; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = SPI_DMA_INTR_PRIO; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); #endif #endif // SPI_DMA_ENA > 0 }
void DMA1_Channel6_IRQHandler(void) { uart_dma_irq_handler(&stm32f1xx_uart_2.uart_descriptor); // DMA_ClearITPendingBit(DMA1_IT_GL6); }
/************************************************************************* * Function Name: SPI2_DmaTransfer * Parameters: pInt8U pData,Int32U Size, SPI_TransferDir_t SPI_TransferDir * Return: none * * Description: DMA transfer * *************************************************************************/ void SPI2_DmaTransfer(pInt8U pData,Int32U Size, SPI_TransferDir_t SPI_TransferDir) { DMA_InitTypeDef DMA_InitStructure; Int32U Dummy = 0xFF; // Initialize DMA Rx channel DMA_DeInit(DMA_Channel4); DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SPI2->DR; DMA_InitStructure.DMA_MemoryBaseAddr = (SPI_TransferDir == SPI_RECEIVE)?(Int32U)pData:(Int32U)&Dummy; DMA_InitStructure.DMA_BufferSize = Size; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = (SPI_TransferDir == SPI_RECEIVE)?DMA_MemoryInc_Enable:DMA_MemoryInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; // Init channel DMA_Init(DMA_Channel4, &DMA_InitStructure); // Initialize DMA Tx channel DMA_DeInit(DMA_Channel5); DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SPI2->DR; DMA_InitStructure.DMA_MemoryBaseAddr = (SPI_TransferDir == SPI_TRANSMIT)?(Int32U)pData:(Int32U)&Dummy; DMA_InitStructure.DMA_BufferSize = Size; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = (SPI_TransferDir == SPI_TRANSMIT)?DMA_MemoryInc_Enable:DMA_MemoryInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; // Init channel DMA_Init(DMA_Channel5, &DMA_InitStructure); // Enable SPI2 DMA transfer SPI_DMACmd(SPI2,SPI_DMAReq_Rx,ENABLE); SPI_DMACmd(SPI2,SPI_DMAReq_Tx,ENABLE); #ifdef DMA_ERRATA ENTR_CRT_SECTION(); // Enable channel DMA_Cmd(DMA_Channel4,ENABLE); DMA_Cmd(DMA_Channel5,ENABLE); while(1) { if ( (DMA_GetITStatus(DMA_IT_TE4) == SET) || (DMA_GetITStatus(DMA_IT_TE5) == SET)) { DMA_ClearITPendingBit(DMA_IT_GL4 | DMA_IT_GL5); DMA_Cmd(DMA_Channel5,DISABLE); DMA_Cmd(DMA_Channel4,DISABLE); break; } if ( (DMA_GetITStatus(DMA_IT_TC4) == SET) && (DMA_GetITStatus(DMA_IT_TC5) == SET)) { break; } }; EXT_CRT_SECTION(); #else // set the flag DMA Transfer in progress TransferStatus = TRUE; DMA_ITConfig(DMA_Channel4, DMA_IT_TC | DMA_IT_TE, ENABLE); DMA_ITConfig(DMA_Channel5, DMA_IT_TE, ENABLE); // Enable SPI2 DMA transfer SPI_DMACmd(SPI2,SPI_DMAReq_Rx,ENABLE); SPI_DMACmd(SPI2,SPI_DMAReq_Tx,ENABLE); while(TransferStatus); #endif // wait until SPI transmit FIFO isn't empty while(SPI_GetFlagStatus(SPI2, SPI_FLAG_TXE)==RESET); // wait until SPI receive FIFO isn't empty while(SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE)==SET); SPI_DMACmd(SPI2,SPI_DMAReq_Tx,DISABLE); SPI_DMACmd(SPI2,SPI_DMAReq_Rx,DISABLE); }