/**
* @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);
}
