void USART2_IRQHandler() { if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET) { Data = USART_ReceiveData(USART2); if(Data!=122&&Bot_Flag==0) { if(Data==TeamID && Flag==0 ) { Flag++; } else if(Flag==2*Bot_Id+1) { Velocity[0]=Data; Flag++; } else if(Flag==2*Bot_Id+2) { Velocity[1]=Data; Flag++; } else if(Flag==11) { Target[0]=Velocity[0]; Target[1]=Velocity[1]; Store[StoreIdx][0]=Data; Store[StoreIdx][1]=Target[0]; Store[StoreIdx][2]=Target[1]; Store[StoreIdx][3]=VL; Store[StoreIdx][4]=VR; StoreIdx = (StoreIdx + 1 ) % STORE_SIZE; NumStored++; if(NumStored > STORE_SIZE) { NumStored = STORE_SIZE; } Flag=0; } else { Flag++; } } else if(Data==122) { Bot_Flag=1; } else if(Data!=122&&Bot_Flag==1) { if(Data==Bot_Id) { Send_Back_Flag=1; } Bot_Flag=0; } USART_ClearITPendingBit(USART2,USART_IT_RXNE); NVIC_ClearPendingIRQ(USART2_IRQn); } }
/******************************************************************************* * Function Name : USART1_Irq_Function * Description : 串口中断服务函数. * Input : None * Output : None * Return : None *******************************************************************************/ extern void USART1_Irq_Function(void) { static u8 temp; static u16 head; //RX while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))//接收到数据 { USART_ClearFlag(USART1, USART_FLAG_RXNE); temp = USART_ReceiveData(USART1); head = RBUF_NEXT_PT(usart1.rx.head, 1, sizeof(usart1_rx_buf)); if (head != usart1.rx.tail) { usart1_rx_buf[usart1.rx.head] = temp; usart1.rx.head = head; usart1.rx.timeout = RXTIMEOUT; } else { usart1.rx.error = 1; // error } } //TX if (USART_GetFlagStatus(USART1,USART_FLAG_TXE)) { USART_ClearFlag(USART1, USART_FLAG_TXE); if (usart1.tx.head == usart1.tx.tail) { usart1.tx.busy = 0; USART_ITConfig(USART1,USART_IT_TXE,DISABLE); } else { USART_SendData(USART1, usart1_tx_buf[usart1.tx.tail]); usart1.tx.tail = RBUF_NEXT_PT(usart1.tx.tail, 1, sizeof(usart1_tx_buf)); } } #if 0 /* USART in Receiver mode */ if (USART_GetITStatus(USARTx, USART_IT_RXNE) == SET) { if (ubRxIndex < BUFFERSIZE) { /* Receive Transaction data */ aRxBuffer[ubRxIndex++] = USART_ReceiveData(USARTx); } else { /* Disable the Rx buffer not empty interrupt */ USART_ITConfig(USARTx, USART_IT_RXNE, DISABLE); } } /* USART in Transmitter mode */ if (USART_GetITStatus(USARTx, USART_IT_TXE) == SET) { if (ubTxIndex < BUFFERSIZE) { /* Send Transaction data */ USART_SendData(USARTx, aTxBuffer[ubTxIndex++]); } else { /* Disable the Tx buffer empty interrupt */ USART_ITConfig(USARTx, USART_IT_TXE, DISABLE); } } #endif }
void USART1_IRQHandler(void) //����1�жϷ������ { u8 Res; u16 len; u16 t; #ifdef OS_TICKS_PER_SEC //���ʱ�ӽ�����������,˵��Ҫʹ��ucosII��. OSIntEnter(); #endif if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //�����ж�(���յ������ݱ�����0x0d 0x0a��β) { Res =USART_ReceiveData(USART1);//(USART1->DR); //��ȡ���յ������� if((USART_RX_STA&0x8000)==0)//����δ��� { if(USART_RX_STA&0x4000)//���յ���0x0d { if(Res!=0x0a)USART_RX_STA=0;//���մ���,���¿�ʼ else USART_RX_STA|=0x8000; //��������� } else //��û�յ�0X0D { if(Res==0x0d)USART_RX_STA|=0x4000; else { USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ; USART_RX_STA++; if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//�������ݴ���,���¿�ʼ���� } } } if (USART_RX_STA & 0x8000)//bit15?? ?��?��3��?? ?��?���?????�??��?���? { len = USART_RX_STA & 0x3FFF;////?��?�?�?3�?�'�13-0 printf("usart_flag1::%d and usart_flag2:: %d\n",usart_flag1,usart_flag2); // printf("_usart_recv_packet1::%s and usart_flag2:: %s\n",_usart_recv_packet1,_usart_recv_packet2); printf("USART_RX_BUF::%s \n",USART_RX_BUF); //USART1->DR = USART_RX_BUF[t]; if( usart_flag1==0){ USART_ERR_NOMESSAGE=0; for (t = 0; t<len; t++){ _usart_recv_packet1[t]=USART_RX_BUF[t]; while ((USART1->SR & 0X40) == 0); } usart_flag1=1; } else if ( usart_flag2==0&&usart_flag1==1){ USART_ERR_NOMESSAGE=0; for (t = 0; t<len; t++){ _usart_recv_packet2[t]=USART_RX_BUF[t]; while ((USART1->SR & 0X40) == 0); } usart_flag2=1; } printf("over\n"); USART_RX_STA=0; } // _usart_recv_packet_len=sizeof(_usart_recv_packet_current); } #ifdef OS_TICKS_PER_SEC //���ʱ�ӽ�����������,˵��Ҫʹ��ucosII��. OSIntExit(); #endif }
void USART3_IRQHandler(void) { if(USART_GetITStatus(USART3, USART_IT_TXE) != RESET) { if(!FIFO_S_IsEmpty(UART_TranFifo)) { uint16_t data = (uint16_t)FIFO_S_Get(UART_TranFifo); USART_SendData(USART3, data); } else { USART_ITConfig(USART3, USART_IT_TXE, DISABLE); } }else if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) //接收中断 { uint8_t tmp = USART_ReceiveData(USART3); if(FrameUnpack(tmp, rx_buffer)) { if(GetFrameCmd(rx_buffer) == CMD_ID_SENSOR_CALI) //传感器校准命令ID { CALI_CMD *pData = (CALI_CMD *)GetFrameDataAddress(rx_buffer); //get the pData->type if(pData->type == GYRO_CALI_START) { SetCaliCmdFlag(CALI_START_FLAG_GYRO); } else if(pData->type == GYRO_CALI_END) { SetCaliCmdFlag(CALI_END_FLAG_GYRO); } else if(pData->type == MAG_CALI_START) { SetCaliCmdFlag(CALI_START_FLAG_MAG); } else if(pData->type == MAG_CALI_END) { SetCaliCmdFlag(CALI_END_FLAG_MAG); } else if(pData->type == Encoder_CALI_START) { SetCaliCmdFlag(CALI_START_FLAG_GIMBAL); } else if(pData->type == Encoder_CALI_END) { SetCaliCmdFlag(CALI_END_FLAG_GIMBAL); } } else if(GetFrameCmd(rx_buffer) == CMD_ID_UPLOAD_CALI_INFO) //如果是要求上传校准信息 { } else if(GetFrameCmd(rx_buffer) == CMD_ID_PID_CALI) //接收PID参数校准命令 { PIDParamStruct_t *pData = (PIDParamStruct_t *)GetFrameDataAddress(rx_buffer); PIDCaliProcess(pData); //保存calidata到static变量中 SetCaliCmdFlag(CALI_FLAG_PID); //PID参数 } else { } } } }
void USART2_IRQHandler(void) //串口1中断服务程序 { u8 c; if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾) { TimerRxLed = UART2_RX_LED_TIMER_START; c =USART_ReceiveData(USART2);//(USART1->DR); //读取接收到的数据 if (Uart2FrameData.RecNewFlag == FALSE) // 只有接收的数据处理完成才接收新的数据 { Uart2FrameData.RecIrqNum++; Uart2FrameData.RecBuf[Uart2FrameData.Rindex++] = c; // 从接收FIFO里读取字符; if (Uart2FrameData.RecIrqNum == 1) { if (Uart2FrameData.RecBuf[0] != START1) { Uart2FrameData.Rindex = 0; // 若没有接收到包头,则清各标志 继续接收新的包 Uart2FrameData.RecIrqNum = 0; } else { Timer2 = UART2_RX_WAIT_TIMER_START; } } else if (Uart2FrameData.RecIrqNum == 2) { if (Uart2FrameData.RecBuf[1] != START2) { Uart2FrameData.Rindex = 0; // 若没有接收到包头,则清各标志 继续接收新的包 Uart2FrameData.RecIrqNum = 0; } else { Timer2 = UART2_RX_WAIT_TIMER_START; } } else if (Uart2FrameData.RecIrqNum == 3) { Uart2FrameData.RecDataNum = c; //数据个数 Uart2FrameData.Rindex = 0; // 从索引0开始接收数据 if ((Uart2FrameData.RecDataNum < Uart2RecFrameNumMin) || (Uart2FrameData.RecDataNum > Uart2RecFrameNumMax)) // 判断数据个数是否有效 若无效 { Uart2FrameData.Rindex = 0; // 若数据个数错误,则清各标志 继续接收新的包 Uart2FrameData.RecIrqNum = 0; } } else if (Uart2FrameData.RecIrqNum == 4) { Uart2FrameData.Cmd = c; // 命令 Uart2FrameData.Rindex = 0; // 从索引0开始接收数据 // if (CheckRecFrame(Uart0D.Cmd,Uart0D.RecDataNum) == FALSE) // 判断帧是否错误 // { // Uart0D.Rindex = 0; // 若有错误,则清各标志 继续接收新的包 // Uart0D.RecIrqNum = 0; // } } if (Uart2FrameData.RecIrqNum > 3) // 根据帧中提供的有效数据个数判断数据是否接收完成 { if (Uart2FrameData.Rindex == Uart2FrameData.RecDataNum-2) // 数据接收完毕 置接收新数据包标志 清其他标志 { Uart2FrameData.Rindex = 0; Uart2FrameData.RecIrqNum = 0; Uart2FrameData.RecNewFlag = TRUE; Timer2 = 0; } } } } }
// обработчик прерываний для всех прерываний связанных с UART1 void USART1_IRQHandler(void){ // если установлен флаг прерывания по поступлению данных if( USART_GetITStatus(USART1, USART_IT_RXNE) ) USART_putc(USART1, USART1->DR); }
void USART3_IRQHandler(void) { unsigned char data; if (USART_GetITStatus(USART3, USART_IT_RXNE) == RESET) { return; } data = USART_ReceiveData(USART3); USART_SendData(USART1, data); USART_ClearITPendingBit(USART3, USART_IT_RXNE); if (isIPD) { __gmsReceiveIPDData(data); return; } if (isRTC) { __gmsReceiveRTCData(data); return; } if (isTUDE) { __gmsReceiveTUDEData(data); return; } if (isCSQ) { __gmsReceiveCSQData(data); return; } if(ispdp) { if(data==0x0a) { ispdp=0; bufferIndex=0; } else { buffer[bufferIndex++]=data; } return ; } if (data == 0x0A) { buffer[bufferIndex++] = 0; if (bufferIndex >= 2) { portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE; const GSMAutoReportMap *p; if (strncmp(buffer, "+CMT:", 5) == 0) { bufferIndex = 0; isSMS = 1; } if(strncmp(buffer, "+PDP", 4) == 0) { bufferIndex=0; ispdp=1; } for (p = __gsmAutoReportMaps; p->prefix != NULL; ++p) { if (strncmp(p->prefix, buffer, strlen(p->prefix)) == 0) { GsmTaskMessage *message = __gsmCreateMessage(p->type, buffer, bufferIndex); if (pdTRUE != xQueueSendFromISR(__queue, &message, &xHigherPriorityTaskWoken)) { __gsmDestroyMessage(message); } break; } } if (p->prefix == NULL) { ATCommandGotLineFromIsr(buffer, bufferIndex, &xHigherPriorityTaskWoken); } if (xHigherPriorityTaskWoken) { taskYIELD(); } } bufferIndex = 0; } else if (data != 0x0D) { buffer[bufferIndex++] = data; if ((bufferIndex == 2) && (strncmp("#H", buffer, 2) == 0)) { isIPD = 1; } if (strncmp(buffer, "+QNITZ: ", 8) == 0) { bufferIndex = 0; isRTC = 1; } if (strncmp(buffer, "+CCLK: ", 7) == 0) { bufferIndex = 0; isRTC = 1; } if (strncmp(buffer, "+CSQ: ", 6) == 0) { bufferIndex = 0; isCSQ = 1; } if (strncmp(buffer, "+CME ERROR: 3517", 16) == 0) { bufferIndex = 0; CardisEXIST = 0; } if (strncmp(buffer, "+QCELLLOC: ", 11) == 0) { bufferIndex = 0; isTUDE = 1; CELLloc = 1; } if (strncmp(buffer, "+QGSMLOC: ", 10) == 0) { bufferIndex = 0; isTUDE = 1; GSMloc = 1; } } }
void USART2_IRQHandler(void){ #if 0 static u8 i=0; if(USART_GetITStatus(USART2,USART_IT_RXNE)!=RESET){ USART_ClearITPendingBit(USART2,USART_IT_RXNE); Rev_Buffer[i]=USART_ReceiveData(USART2); } if(USART_GetFlagStatus(USART2,USART_FLAG_ORE)==SET){ USART_ClearFlag(USART2,USART_FLAG_ORE); USART_ReceiveData(USART2); } if(Rev_Buffer[i]=='a'){ usart_send("nihao"); } i++; #else unsigned char c; if(USART_GetITStatus(USART2,USART_IT_RXNE)!=RESET){ USART_ClearITPendingBit(USART2,USART_IT_RXNE); c=USART_ReceiveData(USART2); }else{ //not recive data return ; } /***********SHP*******begin*******/{ save_char_to_buf_or_handle(c,0); /***********SHP*******end*********/} #endif #if 0 len = tcpSoc->read(temp_recv,sizeof(temp_recv)); if(len>0) { qDebug("recived %d byte data :",len); qDebug(mem2Hex(temp_recv,len)); //memcpy(temp_recv,recv_buffer+recved_len,len); min_len = sizeof(rd.recv_buffer) - rd.recved_size; if(min_len>len){ min_len=len; } memcpy(rd.recv_buffer+rd.recved_size,temp_recv,min_len); rd.recved_size+=min_len; if(recived_data_handler){ int used_len = 0; while(rd.recved_size){ used_len = recived_data_handler(&rd); if(used_len>0 && used_len<=rd.recved_size){ rd.recved_size -= used_len; memcpy(rd.recv_buffer+used_len,rd.recv_buffer,rd.recved_size); }else { rd.recved_size = 0; } } }else { rd.recved_size = 0; } }else{ qDebug("len = %d break",len); break; } #endif }
void USART2_IRQHandler(void) { uint8_t vlue; if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) { // printf("**\r\n"); USART_ClearITPendingBit(USART2,USART_IT_RXNE); vlue = USART_ReceiveData(USART2); if(UART_HandleStruct.Package_Flag ==0) { if(UART_HandleStruct.UART_Flag1 ==0) { if(vlue == 0xff) { UART_HandleStruct.UART_Count = 0; UART_HandleStruct.UART_Buf[UART_HandleStruct.UART_Count]=vlue; UART_HandleStruct.UART_Count++; UART_HandleStruct.UART_Flag1 = 1; } return ; } else if(UART_HandleStruct.UART_Flag2 ==0) { UART_HandleStruct.UART_Buf[UART_HandleStruct.UART_Count]=vlue; UART_HandleStruct.UART_Count++; if(UART_HandleStruct.UART_Buf[1] == 0xff) { UART_HandleStruct.UART_Flag2 = 1; } else { UART_HandleStruct.UART_Flag1 = 0; } return ; } else { UART_HandleStruct.UART_Buf[UART_HandleStruct.UART_Count] = vlue; if(UART_HandleStruct.UART_Count >=4 && UART_HandleStruct.UART_Buf[UART_HandleStruct.UART_Count] == 0x55 && UART_HandleStruct.UART_Buf[UART_HandleStruct.UART_Count - 1] == 0xFF) {} else UART_HandleStruct.UART_Count++; if(UART_HandleStruct.UART_Count == 0x04) { UART_HandleStruct.UART_Cmd_len = UART_HandleStruct.UART_Buf[2]*256+ UART_HandleStruct.UART_Buf[3]; } if(UART_HandleStruct.UART_Count == (UART_HandleStruct.UART_Cmd_len + 4)) { UART_HandleStruct.Package_Flag = 1; UART_HandleStruct.UART_Flag1 = 0; UART_HandleStruct.UART_Flag2 = 0; // printf("Package_Flag =1 \r\n"); } } } } }
void USART1_IRQHandler(void) // Interrupt on char recieving from USART1 (Android board) { unsigned char param[16]; LED_LED1_ON(); if (USART_GetITStatus(USART1, USART_IT_RXNE) != (u16)RESET) { USART_ClearITPendingBit(USART1, USART_IT_RXNE); AndroidReceivedChar = USART_ReceiveData(USART1); AndroidBuffer[AndroidBufferIndex] = AndroidReceivedChar; AndroidBufferIndex++; if (AndroidReceivedChar == 19) // f*****g programmer { AndroidBuffer[AndroidBufferIndex-1] = 0; //EOL AndroidBufferIndex = 0; strcpy(param, AndroidBuffer+1); switch (AndroidBuffer[0]) { case 'R': if (!strcmp(param, "0")) { GUI_DispString("Radio Mute\n"); // TODO: Radio mute break; } GUI_DispString("Freq = "); GUI_DispDec(atol(param)*100000, 9); GUI_DispString("Hz\n"); SetPLL(atol(param)*100000); break; case 'V': setAudioVolume(atoi(param)); GUI_DispString("Volume = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'B': setAudioBalance(atoi(param)); GUI_DispString("Balance = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'J': setAudioBass(atoi(param)); GUI_DispString("Bass = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'K': setAudioTreble(atoi(param)); GUI_DispString("Treble = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'L': setAudioRearLeftVolume(atoi(param)); GUI_DispString("Rear Left volume = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'X': setAudioRearRightVolume(atoi(param)); GUI_DispString("Rear Right volume = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'M': setAudioMute(atoi(param)); GUI_DispString("Audio mute = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; case 'S': setAudioSource(atoi(param)); GUI_DispString("Audio source = "); GUI_DispDec(atoi(param), 2); GUI_DispString("\n"); break; default: break; } } } LED_LED1_OFF(); }
/* 说明一下,IDLE的中断在串口无数据接收的情况下,是不会一直产生的, 产生的条件是这样的,当清除IDLE标志位后,必须有接收到第一个数据后,才开始触发, 一断接收的数据断流,没有接收到数据,即产生IDLE中断。*/ UINT32 IO_DataUartISR(UINT32 data) { static UINT32 index = 0; UINT16 rxc; UINT8 txc; UINT32 Fifodepth; UINT8* temp; #if 1 /*******************************************************/ /* handle RX interrupt */ /*******************************************************/ /* Service RX data ready as long as there is data in RX FIFO */ if( USART_GetIntBitState(USART1, USART_INT_RBNE) != RESET) { USART_INT_Set( USART1, USART_INT_IDLEF, ENABLE ); /* Read data from RX UART1 DR and store in buffer */ rxc = USART_DataReceive(USART1) & 0xff; UartDev.DATA.RxBufWrPtr[index] = (UINT8)rxc; UartDev.DATA.RxBufCount++; index++; USART_ClearIntBitState(USART1, USART_INT_RBNE); } if( USART_GetIntBitState(USART1, USART_INT_IDLEF) != RESET) { USART_INT_Set(USART1, USART_INT_IDLEF, DISABLE ); USART_ClearIntBitState(USART1, USART_INT_IDLEF); index = 0; temp = UartDev.DATA.RxBufRdPtr; UartDev.DATA.RxBufRdPtr = UartDev.DATA.RxBufWrPtr; UartDev.DATA.RxBufWrPtr = temp; OS_SetEvent(IO_EVENT_GROUP_ID, IO_UART_RXIND_FLG); } /*******************************************************/ /* handle TX interrupt */ /*******************************************************/ if( USART_GetIntBitState(USART1, USART_INT_TBE) != RESET) { USART_ClearIntBitState(USART1, USART_INT_TBE); /* Init FIFO count */ Fifodepth = UART_UART_TX_HW_FIFO_SIZE; /* Add data to TX UART FIFO until it is full */ while((UartDev.DATA.TxBufCount != 0) && (Fifodepth > 0)) { /* Write data byte to UART TX FIFO */ /* Write one byte to the transmit data register */ txc = *(UartDev.DATA.TxBufPtr); USART_DataSend( USART1 , txc ); UartDev.DATA.TxBufPtr++; /* Decrement Tx Serial count */ UartDev.DATA.TxBufCount--; /* Decrement FIFO count */ Fifodepth--; } /* if we have send all character in fifo */ if (UartDev.DATA.TxBufCount == 0 ) { /* disable the USART1 Transmoit interrupt */ USART_INT_Set(USART1, USART_INT_TBE, DISABLE ); OS_SetEvent(IO_EVENT_GROUP_ID, IO_UART_TXRSP_FLG); } } #else /*******************************************************/ /* handle RX interrupt */ /*******************************************************/ /* Service RX data ready as long as there is data in RX FIFO */ if( USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) { USART_ITConfig( USART1, USART_IT_IDLE, ENABLE ); /* Read data from RX UART1 DR and store in buffer */ rxc = USART_ReceiveData(USART1) & 0xff; UartDev.DATA.RxBufWrPtr[index] = (UINT8)rxc; UartDev.DATA.RxBufCount++; index++; USART_ClearITPendingBit(USART1, USART_IT_RXNE); } if( USART_GetITStatus(USART1, USART_IT_IDLE) != RESET) { USART_ClearITPendingBit(USART1, USART_IT_IDLE); USART_ITConfig(USART1, USART_IT_IDLE, DISABLE ); index = 0; temp = UartDev.DATA.RxBufRdPtr; UartDev.DATA.RxBufRdPtr = UartDev.DATA.RxBufWrPtr; UartDev.DATA.RxBufWrPtr = temp; OS_SetEvent(IO_EVENT_GROUP_ID, IO_UART_RXIND_FLG); } /*******************************************************/ /* handle TX interrupt */ /*******************************************************/ if( USART_GetITStatus(USART1, USART_IT_TXE) != RESET) { USART_ClearITPendingBit(USART1, USART_IT_TXE); /* Init FIFO count */ Fifodepth = UART_UART_TX_HW_FIFO_SIZE; /* Add data to TX UART FIFO until it is full */ while((UartDev.DATA.TxBufCount != 0) && (Fifodepth > 0)) { /* Write data byte to UART TX FIFO */ /* Write one byte to the transmit data register */ txc = *(UartDev.DATA.TxBufPtr); USART_SendData( USART1 , txc ); UartDev.DATA.TxBufPtr++; /* Decrement Tx Serial count */ UartDev.DATA.TxBufCount--; /* Decrement FIFO count */ Fifodepth--; } /* if we have send all character in fifo */ if (UartDev.DATA.TxBufCount == 0 ) { /* Enable the USART1 Transmoit interrupt */ USART_ITConfig(USART1, USART_IT_TXE, DISABLE ); OS_SetEvent(IO_EVENT_GROUP_ID, IO_UART_TXRSP_FLG); } } #endif return 0; }
void USART3_IRQHandler(void) //串口3中断服务程序 { u32 temp; u8 data; u16 nms=1000; int times=10; data_i=0; if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾) { //失能接收中断--准备处理连续字符 USART_ITConfig(USART3, USART_IT_RXNE, DISABLE); while(times--) { SysTick->LOAD=(u32)nms*fac_ms; //时间加载(SysTick->LOAD为24bit) SysTick->VAL =0x00; //清空计数器 SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //开始倒数 do { if( USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) { data = USART_ReceiveData(USART3); wifi_feedback[data_i]=data ; //CONNECT if( wifi_feedback[data_i] == 'T' && data_i>=6 && wifi_feedback[data_i-1] == 'C' && wifi_feedback[data_i-2] == 'E' && wifi_feedback[data_i-3] == 'N' && wifi_feedback[data_i-4] == 'N' && wifi_feedback[data_i-5] == 'O' && wifi_feedback[data_i-6] == 'C' ) { SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器 SysTick->VAL =0X00; //清空计数器 //返回成功信息 is_con_slave=1; LCD_Print(0,6,"WIFI-从机连接成功"); return ; } //ERROR if( wifi_feedback[data_i] == 'R' && data_i>=4 && wifi_feedback[data_i-1] == 'O' && wifi_feedback[data_i-2] == 'R' && wifi_feedback[data_i-3] == 'R' && wifi_feedback[data_i-4] == 'E' ) { SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器 SysTick->VAL =0X00; //清空计数器 //返回失败信息 is_con_slave=0; LCD_Print(0,6,"WIFI-从机连接失败"); //连接从机失败--重新使能接受中断--准备下次连接 USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); return ; } //接收成功-重新装载倒计时秒数 times=10; data_i++; } temp=SysTick->CTRL; }while((temp&0x01)&&!(temp&(1<<16))); //等待时间到达 SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器 SysTick->VAL =0X00; //清空计数器 } } is_con_slave=0; //连接从机失败--重新使能接受中断--准备下次连接 USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); }
void USART3_IRQHandler(void) { u8 SendData; if(SET == USART_GetITStatus(USART3, USART_IT_TXE)) { USART_ClearITPendingBit(USART3, USART_IT_TXE); #if 1 if (FIFO_GET_ONE(McuUart3_TxFifo,&SendData)) { USART_SendData(USART3,SendData); } else { USART_ITConfig(USART3, USART_IT_TXE, DISABLE); USART_ITConfig(USART3, USART_IT_TC, ENABLE); } #else if (m_SendBuff.len > 0 ) { USART_SendData(USART3, m_SendBuff.buf[m_SendBuff.ind++]); m_SendBuff.len--; } else { USART_ITConfig(USART3, USART_IT_TXE, DISABLE); USART_ITConfig(USART3, USART_IT_TC, ENABLE); } #endif } if (USART_GetITStatus(USART3, USART_IT_TC) != RESET)//去掉else { USART_ClearITPendingBit(USART3, USART_IT_TC); USART_ITConfig(USART3, USART_IT_TC, DISABLE); m_SendBuff.len = 0; eTXIdle = TRUE; } if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)//去掉else { u8 ch; USART_ClearITPendingBit(USART3, USART_IT_RXNE); ch = USART_ReceiveData(USART3); if(UpgradeReady == 1) { ReceOneChar(ch); //IAP } else { #ifdef ANDROID_UPGRADE FIFO_PUT_ONE(McuUart3_RxFifo,ch); //ReceOneCharByandroid(ch); #else ReceOneCharVerify(ch); #endif } // if (receChar != NULL) // (*receChar)(ch); } }
/** * @brief This function handles USRAT interrupt request. * @param None * @retval None */ void USARTx_IRQHandler(void) { #ifdef MODE_TRANSMITTER /* ------------------ USART in mode Tramitter ------------------------------*/ if (USART_GetITStatus(USARTx, USART_IT_TXE) == SET) { if (TxIndex < 0x48) { /* Send TxBuffer data */ USART_SendData(USARTx, TxBuffer[TxIndex]); /* Compute 8-bit CRC */ CRC_CalcCRC8bits(TxBuffer[TxIndex++]); } else if (TxIndex == 0x48) { /* Get computed computed value */ TxBuffer[TxIndex] = (uint8_t)CRC_GetCRC(); /* Reset CRC calculation unit */ CRC_ResetDR(); /* Send CRC computed value */ USART_SendData(USARTx, TxBuffer[TxIndex]); /* Disable the USARTx transmit data register empty interrupt */ USART_ITConfig(USARTx, USART_IT_TXE, DISABLE); /*Discard CRC sent value*/ TxBuffer[TxIndex] = 0; /*reset TxBuffer index*/ TxIndex = 0; } } #else /* ------------------ USART in mode Receiver -------------------------------*/ if (USART_GetITStatus(USARTx, USART_IT_RXNE) == SET) { if (RxIndex < 0x48) { /* Receive the USART data */ RxBuffer[RxIndex] = USART_ReceiveData(USARTx); /* compute 8-bit CRC */ CRC_CalcCRC8bits(RxBuffer[RxIndex++]); } else if (RxIndex == 0x48) { /* Get computed computed value */ ComputedCRC = (uint8_t)CRC_GetCRC(); /* Reset CRC calculation unit */ CRC_ResetDR(); /* Recive expected CRC value */ RxBuffer[RxIndex] = USART_ReceiveData(USARTx); /* Compare computed CRC and recived CRC values*/ if (ComputedCRC == RxBuffer[RxIndex]) { /* LED3 Off */ STM_EVAL_LEDOff(LED3); /* Toggle LED2 */ STM_EVAL_LEDToggle(LED2); } else { /* LED3 On */ STM_EVAL_LEDOn(LED3); /* LED2 Off */ STM_EVAL_LEDOff(LED2); } /* Reset RxBuffer index */ RxIndex = 0; } } #endif /* MODE_TRANSMITTER */ }
//Interrupt handler for USART1 interrupt void USART1_IRQHandler(void) { int received_data; //Test source of interrupt if (USART_GetITStatus(USART1, USART_IT_RXNE) == 1) //RNXE - Receive buffer not empty (ie we have an RX byte) { //Clear interrupt flag USART_ClearITPendingBit(USART1, USART_IT_RXNE); received_data=USART_ReceiveData(USART1); //Check that this is a new command and not a component of a previous command if (waitingforrate) { waitingforrate=0; Config[2]=received_data; I2C_EE_WriteConfig(); } else{ if (currentstate == WAITING) { if (received_data=='U') { currentstate = UPLOADING; } if (received_data=='E') { currentstate = ERASING; } if (received_data=='L') { currentstate = STREAMING; } if (received_data=='R') { waitingforrate=1; } } else if (currentstate == STREAMING) { if (received_data=='S') { currentstate=WAITING; } } /* u is upload, e for erase, l start STREAMING, s stop STREAMING */ /*R 123 for 123 seconds */ /* if (command_flag == 0) { //This is a new command //Get command command_flag = USART_ReceiveData(USART1); //Get value value = USART_ReceiveData(USART1); value_received = 0; } else { //This is a continuation of a previous command //Get value value = USART_ReceiveData(USART1); value_received = 1; }*/ } } }
// void USART2_IRQHandler(void) // { // u8 Res; // if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾) // { // Res =USART_ReceiveData(USART2);//(USART2->DR); //读取接收到的数据 // // if((USART_RX_STA&0x80)==0)//接收未完成 // { // if(USART_RX_STA&0x40)//接收到了0x0d // { // if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始 // else USART_RX_STA|=0x80; //接收完成了 // } // else //还没收到0X0D // { // if(Res==0x0d)USART_RX_STA|=0x40; // else // { // USART_RX_BUF[USART_RX_STA&0X3F]=Res ; // USART_RX_STA++; // if(USART_RX_STA>63)USART_RX_STA=0;//接收数据错误,重新开始接收 // } // } // } // } // } void USART1_IRQHandler(void) //串口1中断服务程序 { u8 Res; u8 i; if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾) { // Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据 USART_RX_BUF[usart_rx_buf_num]=Res-'0'; usart_rx_buf_num++; // if((Res==';')&(usart_rx_buf_num==9)) if(Res==';') { if(usart_rx_buf_num==9) { x=(USART_RX_BUF[0]*1000+USART_RX_BUF[1]*100+USART_RX_BUF[2]*10+(float)USART_RX_BUF[3])+delta_x; y=(USART_RX_BUF[4]*1000+USART_RX_BUF[5]*100+USART_RX_BUF[6]*10+(float)USART_RX_BUF[7]); IsUsartReceived=1; } usart_rx_buf_num=0; } // if(Res==';')//x // { // LED0_Toggle(); // // x=USART_RX_BUF[0]*1000+USART_RX_BUF[1]*100+USART_RX_BUF[2] // // usart_rx_buf_num=0; // IsUsartReceived=1; // // } // if(Res==',') // { // LED0_Toggle(); // usart_rx_buf_num=0; // IsUsartReceived=2; // } // if((USART_RX_STA&0x80)==0)//接收未完成 // { // LED0_Toggle(); // if(USART_RX_STA&0x40)//接收到了0x0d // { // // if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始 // else USART_RX_STA|=0x80; //接收完成了 // // } // else //还没收到0X0D // { // if(Res==0x0d)USART_RX_STA|=0x40; // else // { // USART_RX_BUF[USART_RX_STA&0X3F]=Res ; // USART_RX_STA++; // if(USART_RX_STA>63)USART_RX_STA=0;//接收数据错误,重新开始接收 // } // } // } } }
/******************************************************************************* *Обработка прерывания USART2 ******************************************************************************/ void USART2_IRQHandler(void) { uint8_t byte; static uint8_t lock = 0; //Клавиша еще нажата static uint8_t byteCount = 0; //Счетчик байт в пакете static uint8_t comCount = 0; //Счетчик команд if (USART_GetITStatus(USART2, USART_IT_RXNE) == SET) { //Если пришел байт SetClock(); //Разогнали микроконтроллер state.taskList |= TASK_USER; // Отметим активность пользователя byte = USART_ReceiveData(USART2); switch (byteCount) { case 0: if (byte == 0xFF) byteCount = 1; break; case 1: if (byte == 0x55) byteCount = 2; else byteCount = 0; break; case 2: if (byte == 0x03) byteCount = 3; else byteCount = 0; break; case 3: if (byte == 0x02) byteCount = 4; else byteCount = 0; break; case 4: if (byte == 0x00) byteCount = 5; else byteCount = 0; break; case 5: if ((!lock || comCount == 5) && !state.button) { comCount = 0; switch (byte) { case 0x02: state.button = BUTTON_UP; break; case 0x04: state.button = BUTTON_DOWN; break; case 0x08: state.button = BUTTON_RIGHT; break; case 0x10: state.button = BUTTON_LEFT; break; } if (byte) lock = 1; } else if (!byte) { lock = 0; } else comCount++; byteCount = 6; break; case 6: byteCount = 0; break; } } }
/* ISR for serial interrupt */ void rt_hw_serial_isr(rt_device_t device) { struct stm32_serial_device* uart = (struct stm32_serial_device*) device->user_data; static unsigned char checksum = 0; static uint16_t lenth; // static unsigned char gprmcbuf[400]; static unsigned char isgprmc=0; static unsigned short gprmccnt = 0; if(USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET) { /* interrupt mode receive */ RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX); /* save on rx buffer */ while (uart->uart_device->SR & USART_FLAG_RXNE) { rt_base_t level; /* disable interrupt */ level = rt_hw_interrupt_disable(); /* save character */ if((&uart2_device )== device) { uartcount++; uart->int_rx->rx_buffer[uart->int_rx->save_index] = uart->uart_device->DR & 0xff; rt_device_write(&uart2_device, 0,&(uart->int_rx->rx_buffer[uart->int_rx->save_index]), 1); checksum = checksum^(uart->int_rx->rx_buffer[uart->int_rx->save_index]); switch (Uart2PackStatus ) { case Get_sync_head: if ((uart->int_rx->rx_buffer[uart->int_rx->save_index])== 0xaa) { checksum = uart->int_rx->rx_buffer[uart->int_rx->save_index]; Uart2PackStatus = Start_head_end; } else { uart->int_rx->getcmd = 0x7f; } break; case Start_head_end: if((uart->int_rx->rx_buffer[uart->int_rx->save_index])== 0x75) { Uart2PackStatus = Get_the_Command; //rt_device_write(&uart2_device, 0,&(uart->int_rx->rx_buffer[uart->int_rx->save_index]), 1); } else { uart->int_rx->getcmd = 0x7f; Uart2PackStatus = Get_sync_head; } break; case Get_the_Command: if(((uart->int_rx->rx_buffer[uart->int_rx->save_index]) <0x16) ||((uart->int_rx->rx_buffer[uart->int_rx->save_index])>0x81 &&(uart->int_rx->rx_buffer[uart->int_rx->save_index])<0x85 ) ||((uart->int_rx->rx_buffer[uart->int_rx->save_index])>0x81 &&(uart->int_rx->rx_buffer[uart->int_rx->save_index])<0x85 ) ||((uart->int_rx->rx_buffer[uart->int_rx->save_index])>0xc1 &&(uart->int_rx->rx_buffer[uart->int_rx->save_index])<0xc5 )) { Uart2PackStatus = Get_the_lenth_high; } else { uart->int_rx->getcmd = 0x7f; Uart2PackStatus = Get_sync_head; } break; case Get_the_lenth_high: lenth = uart->int_rx->rx_buffer[uart->int_rx->save_index]; Uart2PackStatus = Get_the_lenth_low; break; case Get_the_lenth_low: lenth = ((lenth<<8)&0xff00)+(uart->int_rx->rx_buffer[uart->int_rx->save_index]); Uart2PackStatus = Get_the_reserve; break; case Get_the_reserve: if (lenth != 0) { Uart2PackStatus = Get_the_data; } else Uart2PackStatus = Get_the_checksum; break; case Get_the_data: if(lenth ) lenth--; if(lenth == 0) Uart2PackStatus = Get_the_checksum; break; case Get_the_checksum: if(checksum == 0) { uart->int_rx->getcmd ++; } else { uart->int_rx->getcmd = 0x7f; } Uart2PackStatus = Get_sync_head; break; default: break; } uart->int_rx->save_index ++; if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE) uart->int_rx->save_index = 0; /* if the next position is read index, discard this 'read char' */ if (uart->int_rx->save_index == uart->int_rx->read_index) { uart->int_rx->read_index ++; if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE) uart->int_rx->read_index = 0; } } if((&uart3_device)== device) { if((uart->uart_device->DR & 0xff) == '$') { SectionID=0; isgprmc = 0; gprmccnt =0; uart3flag =1; } else if((uart->uart_device->DR & 0xff)==',') { if((isgprmc == 1)&&(SectionID== FIELD_NIGHT)) { //get the time GetGPSLocation3(gprmcbuf,gprmccnt); } else if((isgprmc == 2) &&(SectionID == FIELD_SEVEN )) { GetGPSSpeed(gprmcbuf,gprmccnt); } SectionID++; gprmccnt = 0; uart3flag =2; } else { if(gprmccnt == 400) { gprmccnt = 0; } gprmcbuf[gprmccnt] = uart->uart_device->DR & 0xff; gprmccnt++; switch(SectionID) { case FIELD_NONE: if(gprmccnt == 5) { uart3flag =2; gprmccnt =0 ; if ( (gprmcbuf[0] == 'G') &&(gprmcbuf[1] == 'P')&&(gprmcbuf[2] =='G') &&(gprmcbuf[3] =='G')&&(gprmcbuf[4] == 'A')) { isgprmc =1;//位置信息 } if ( (gprmcbuf[0] == 'G') &&(gprmcbuf[1] == 'P')&&(gprmcbuf[2] =='V') &&(gprmcbuf[3] == 'T')&&(gprmcbuf[4] == 'G')) { isgprmc =2;//速度信息 uart3flag =2; } } break; case FIELD_ONE://提取时间 uart3flag =1; if(isgprmc == 1) { if(gprmccnt == 10 ) { //get the time GetTheGPSTime(gprmcbuf); } } break; case FIELD_TWO: //判断数据是否可信(当GPS天线能接收到有3颗GPS卫星时为A,可信 if(isgprmc == 1) { if(gprmccnt == 9 ) { //get the time GetGPSLocation1(gprmcbuf); } } break; case FIELD_THREE://提取出纬度 break; case FIELD_FOUR://提取出速度 if(isgprmc == 1) { if(gprmccnt == 10 ) { //get the time GetGPSLocation2(gprmcbuf); } } break; case FIELD_FIVE://提取出经度 break; case FIELD_SEVEN: if(isgprmc == 1) { if(gprmccnt == 2 ) { //get the singal GettheSinaldata(gprmcbuf); } } break; case FIELD_NIGHT://提取高度 break; default: break; } } } if((&uart4_device )== device) { gprmcbuf[gprmccnt] = uart->uart_device->DR & 0xff; gprmccnt++; } /* enable interrupt */ rt_hw_interrupt_enable(level); } /* clear interrupt */ USART_ClearITPendingBit(uart->uart_device, USART_IT_RXNE); /* invoke callback */ if (device->rx_indicate != RT_NULL) { rt_size_t rx_length; /* get rx length */ rx_length = uart->int_rx->read_index > uart->int_rx->save_index ? UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index : uart->int_rx->save_index - uart->int_rx->read_index; device->rx_indicate(device, rx_length); } } if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET) { /* clear interrupt */ USART_ClearITPendingBit(uart->uart_device, USART_IT_TC); } }
void uart1_irq_handler(void) { uint32_t ulReceived = 0; portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE; const unsigned portBASE_TYPE uxUARTNumber = 1UL; Transfer_Control_t *pxTransferStruct; if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) { pxTransferStruct = pxRxTransferControlStructs[uxUARTNumber]; if (pxTransferStruct != NULL) { switch(diGET_TRANSFER_TYPE_FROM_CONTROL_STRUCT(pxTransferStruct)) { case ioctlUSE_CIRCULAR_BUFFER_RX: #if ioconfigUSE_UART_CIRCULAR_BUFFER_RX == 1 { ioutilsRX_CHARS_INTO_CIRCULAR_BUFFER_FROM_ISR( pxTransferStruct, /* The structure that contains the reference to the circular buffer. */ (USART_GetFlagStatus(USART1, USART_FLAG_RXNE) != RESET), /* While loop condition. */ USART_ReceiveData(USART1), /* Register holding the received character. */ ulReceived, xHigherPriorityTaskWoken); } #endif /* ioconfigUSE_UART_CIRCULAR_BUFFER_RX */ break; case ioctlUSE_CHARACTER_QUEUE_RX: #if ioconfigUSE_UART_RX_CHAR_QUEUE == 1 { size_t i = 1; ioutilsRX_CHARS_INTO_QUEUE_FROM_ISR( pxTransferStruct, i--, USART_ReceiveData(USART1), ulReceived, xHigherPriorityTaskWoken); } #endif /* ioconfigUSE_UART_RX_CHAR_QUEUE */ break; default: break; } } USART_ClearITPendingBit(USART1, USART_IT_RXNE); } if (USART_GetITStatus(USART1, USART_IT_TXE) != RESET) { pxTransferStruct = pxTxTransferControlStructs[uxUARTNumber]; if (pxTransferStruct != NULL) { switch (diGET_TRANSFER_TYPE_FROM_CONTROL_STRUCT(pxTransferStruct)) { case ioctlUSE_ZERO_COPY_TX: #if ioconfigUSE_UART_ZERO_COPY_TX == 1 { iouitlsTX_SINGLE_CHAR_FROM_ZERO_COPY_BUFFER_FROM_ISR( pxTransferStruct, USART_SendData(USART1, ucChar), xHigherPriorityTaskWoken); } #endif /* ioconfigUSE_UART_ZERO_COPY_TX */ if (xHigherPriorityTaskWoken != pdTRUE) USART_ITConfig(USART1, USART_IT_TXE, DISABLE); break; case ioctlUSE_CHARACTER_QUEUE_TX: #if ioconfigUSE_UART_TX_CHAR_QUEUE == 1 { size_t i = 1; ioutilsTX_CHARS_FROM_QUEUE_FROM_ISR( pxTransferStruct, i--, USART_SendData(USART1, ucChar), xHigherPriorityTaskWoken); } #endif /* ioconfigUSE_UART_TX_CHAR_QUEUE */ if (xHigherPriorityTaskWoken != pdTRUE) USART_ITConfig(USART1, USART_IT_TXE, DISABLE); break; default: /* This must be an error. Force an assert. */ configASSERT( xHigherPriorityTaskWoken ); break; } } USART_ClearITPendingBit(USART1, USART_IT_TXE); } /* The ulReceived parameter is not used by the UART ISR. */ (void) ulReceived; /* If xHigherPriorityTaskWoken is now equal to pdTRUE, then a context switch should be performed before the interrupt exists. That ensures the unblocked (higher priority) task is returned to immediately. */ portEND_SWITCHING_ISR(xHigherPriorityTaskWoken); }
// Flushes the transmit shift register // warning: this call is blocking void TXSerialFlush1() { // wait until the TXE shows the shift register is empty while (USART_GetITStatus(USART1, USART_FLAG_TXE)) ; }
void USART1_IRQHandler(void) { //#ifdef USART_DEBUG //printf("ok_1!\r\n"); //#endif if(USART_GetFlagStatus(USART1, USART_IT_RXNE) == SET) { /*Usart1_Instruct_Rec[Usart1_i] = USART_ReceiveData(USART1); Usart1_i++; #ifdef USART_DEBUG //printf("%d\r\n",Usart1_i); #endif*/ /* if(Usart1_i == 8) { if(Usart1_Instruct_Rec[7] == Usart1_Instruct_Rec[6] + Usart1_Instruct_Rec[5] + Usart1_Instruct_Rec[4] + Usart1_Instruct_Rec[3] + Usart1_Instruct_Rec[2]) { Instruct_Rec = Usart1_Instruct_Rec[2]; } else { Usart1_i = 0; } } */ Usart1_Rec = USART_ReceiveData(USART1); #ifdef USART_DEBUG printf("ok_2!\r\n"); #endif switch(Rec_State) { case CheckS: if(Usart1_Rec == (short int)'S') { Rec_State = CheckW; } else Rec_State = CheckS; break; case CheckW: if(Usart1_Rec == (short int )'W') { Rec_State = CheckD; } else if(Usart1_Rec == (short int)'S') Rec_State = CheckW; else Rec_State = CheckS; break; case CheckD: Usart1_Instruct_Rec[0] = Usart1_Rec; Rec_State = Check4_0; break; case Check4_0: Usart1_Instruct_Rec[1] = Usart1_Rec; Rec_State = Check4_1; break; case Check4_1: Usart1_Instruct_Rec[2] = Usart1_Rec; Rec_State = Check4_2; break; case Check4_2: Usart1_Instruct_Rec[3] = Usart1_Rec; Rec_State = Check4_3; break; case Check4_3: Usart1_Instruct_Rec[4] = Usart1_Rec; Rec_State = CheckSum; break; case CheckSum: Usart1_Instruct_Rec[5] = Usart1_Rec; if(Usart1_Instruct_Rec[5] == Usart1_Instruct_Rec[0] + Usart1_Instruct_Rec[1] + Usart1_Instruct_Rec[2] + Usart1_Instruct_Rec[3] + Usart1_Instruct_Rec[4]) { Instruct_Rec[0] = Usart1_Instruct_Rec[0];//Up Instruct_Rec[1] = Usart1_Instruct_Rec[1];//Down Instruct_Rec[2] = Usart1_Instruct_Rec[2];//Left Instruct_Rec[3] = Usart1_Instruct_Rec[3];//Right } Rec_State = CheckS; break; default: Rec_State = CheckS; break; } //USART_ClearFlag(USART1,USART_IT_RXNE); USART_ClearITPendingBit(USART1, USART_IT_RXNE); } if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) { USART_ClearITPendingBit(USART1, USART_IT_TXE); } //溢出-如果发生溢出需要先清空SR的溢出位,再读DR寄存器 则可清除不断入中断的问题 if(USART_GetFlagStatus(USART1,USART_FLAG_ORE)==SET) { USART_ClearFlag(USART1,USART_FLAG_ORE); //清溢出位 USART_ReceiveData(USART1); //读DR } }
/* ********************************************************************************************************* * 函 数 名: UartIRQ * 功能说明: 供中断服务程序调用,通用串口中断处理函数 * 形 参: _pUart : 串口设备 * 返 回 值: 无 ********************************************************************************************************* */ static void UartIRQ(UART_T *_pUart) { /* 处理接收中断 */ if (USART_GetITStatus(_pUart->uart, USART_IT_RXNE) != RESET) { /* 从串口接收数据寄存器读取数据存放到接收FIFO */ uint8_t ch; ch = USART_ReceiveData(_pUart->uart); _pUart->pRxBuf[_pUart->usRxWrite] = ch; if (++_pUart->usRxWrite >= _pUart->usRxBufSize) { _pUart->usRxWrite = 0; } if (_pUart->usRxCount < _pUart->usRxBufSize) { _pUart->usRxCount++; } /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */ //if (_pUart->usRxWrite == _pUart->usRxRead) //if (_pUart->usRxCount == 1) { if (_pUart->ReciveNew) { _pUart->ReciveNew(ch); } } } /* 处理发送缓冲区空中断 */ if (USART_GetITStatus(_pUart->uart, USART_IT_TXE) != RESET) { //if (_pUart->usTxRead == _pUart->usTxWrite) if (_pUart->usTxCount == 0) { /* 发送缓冲区的数据已取完时, 禁止发送缓冲区空中断 (注意:此时最后1个数据还未真正发送完毕)*/ USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE); /* 使能数据发送完毕中断 */ USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE); } else { /* 从发送FIFO取1个字节写入串口发送数据寄存器 */ USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]); if (++_pUart->usTxRead >= _pUart->usTxBufSize) { _pUart->usTxRead = 0; } _pUart->usTxCount--; } } /* 数据bit位全部发送完毕的中断 */ else if (USART_GetITStatus(_pUart->uart, USART_IT_TC) != RESET) { //if (_pUart->usTxRead == _pUart->usTxWrite) if (_pUart->usTxCount == 0) { /* 如果发送FIFO的数据全部发送完毕,禁止数据发送完毕中断 */ USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE); /* 回调函数, 一般用来处理RS485通信,将RS485芯片设置为接收模式,避免抢占总线 */ if (_pUart->SendOver) { _pUart->SendOver(); } } else { /* 正常情况下,不会进入此分支 */ /* 如果发送FIFO的数据还未完毕,则从发送FIFO取1个数据写入发送数据寄存器 */ USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]); if (++_pUart->usTxRead >= _pUart->usTxBufSize) { _pUart->usTxRead = 0; } _pUart->usTxCount--; } } }
static int int_uart_rx_get_status( elua_int_resnum resnum ) { return USART_GetITStatus( stm32_usart[ resnum ], USART_IT_RXNE ) == SET ? 1 : 0; }
/*void PPP_IRQHandler(void) { }*/ void USART1_IRQHandler(void) { if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) { } }
void USART6_IRQHandler(void){ // check if the USART1 receive interrupt flag was set if(USART_GetITStatus(USART6, USART_IT_RXNE) != RESET){ } }
void USART3_IRQHandler(void) { volatile u32 tem_reg; volatile u16 u16BufferUsedLen = 0; BaseType_t xHigherPriorityTaskWoken, xResult; // xHigherPriorityTaskWoken must be initialised to pdFALSE. xHigherPriorityTaskWoken = pdFALSE; // error happen if(USART_GetITStatus(USART3, USART_IT_PE) != RESET) { USART_ClearITPendingBit(USART3, USART_IT_PE); xSerialRxParityFlag = DMA_UART_PACKET_PARITY_ERR; } // uart idle interrupt if(USART_GetITStatus(USART3, USART_IT_IDLE) != RESET) { USART_ClearITPendingBit(USART3, USART_IT_IDLE); DMA_ClearFlag(DMA1_FLAG_GL3);//clear all interrupt flags DMA_Cmd(DMA1_Channel3, DISABLE); //close DMA incase receive data while handling xResult = xSemaphoreTakeFromISR( xSerialRxHandleLock, &xHigherPriorityTaskWoken); if( pdTRUE == xResult) { if (uart3_rx_dma_buf.IdleBufferIndex) //buf1 busy, buf2 idle { u16BufferUsedLen = uart3_rx_dma_buf.nBuff1MaxLength - DMA_GetCurrDataCounter(DMA1_Channel3); if (u16BufferUsedLen > 0) { uart3_rx_dma_buf.nBuff1Offset = u16BufferUsedLen; DMA1_Channel3->CMAR = (uint32_t)uart3_rx_dma_buf.pPingPongBuff2; DMA1_Channel3->CNDTR = uart3_rx_dma_buf.nBuff2MaxLength; uart3_rx_dma_buf.IdleBufferIndex = 0; } } else { u16BufferUsedLen = uart3_rx_dma_buf.nBuff2MaxLength - DMA_GetCurrDataCounter(DMA1_Channel3); if (u16BufferUsedLen > 0) { uart3_rx_dma_buf.nBuff2Offset = u16BufferUsedLen; DMA1_Channel3->CMAR = (uint32_t)uart3_rx_dma_buf.pPingPongBuff1; DMA1_Channel3->CNDTR = uart3_rx_dma_buf.nBuff1MaxLength; uart3_rx_dma_buf.IdleBufferIndex = 1; } } xResult = xSemaphoreGiveFromISR( xSerialRxHandleLock ,&xHigherPriorityTaskWoken); if (u16BufferUsedLen > 0) { //boardcast message to handle xResult = xEventGroupSetBitsFromISR( xUart3RxEventGroup, // The event group being updated. UART_DMA_RX_INCOMPLETE_EVENT_BIT,// The bits being set. &xHigherPriorityTaskWoken ); } //End if u16BufferUsedLen > 0 }// End if pdTRUE == xSemaphoreTakeFromISR DMA_Cmd(DMA1_Channel3, ENABLE); //open DMA after handled //clear Idle flag by read SR and DR tem_reg = USART3->SR; tem_reg = USART3->DR; tem_reg = tem_reg; // slove warning }// End if USART_IT_IDLE if(USART_GetITStatus(USART3, USART_IT_FE | USART_IT_NE) != RESET) { USART_ClearITPendingBit(USART3, USART_IT_FE | USART_IT_NE); } 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 ); } }
/** * @brief This function handles USRAT interrupt request. * @param None * @retval None */ void USARTx_IRQHandler(void) { /* USART in mode Tramitter -------------------------------------------------*/ if (USART_GetITStatus(USARTx, USART_IT_TXE) == SET) { /* When Joystick Pressed send the command then send the data */ if (UsartMode == USART_MODE_TRANSMITTER) { /* Send the command */ if (UsartTransactionType == USART_TRANSACTIONTYPE_CMD) { USART_SendData(USARTx, CmdBuffer[TxIndex++]); if (TxIndex == 0x02) { /* Disable the USARTx transmit data register empty interrupt */ USART_ITConfig(USARTx, USART_IT_TXE, DISABLE); } } /* Send the data */ else { USART_SendData(USARTx, TxBuffer[TxIndex++]); if (TxIndex == GetVar_NbrOfData()) { /* Disable the USARTx transmit data register empty interrupt */ USART_ITConfig(USARTx, USART_IT_TXE, DISABLE); } } } /*If Data Received send the ACK*/ else { USART_SendData(USARTx, AckBuffer[TxIndex++]); if (TxIndex == 0x02) { /* Disable the USARTx transmit data register empty interrupt */ USART_ITConfig(USARTx, USART_IT_TXE, DISABLE); } } } /* USART in mode Receiver --------------------------------------------------*/ if (USART_GetITStatus(USARTx, USART_IT_RXNE) == SET) { if (UsartMode == USART_MODE_TRANSMITTER) { AckBuffer[RxIndex++] = USART_ReceiveData(USARTx); } else { /* Receive the command */ if (UsartTransactionType == USART_TRANSACTIONTYPE_CMD) { CmdBuffer[RxIndex++] = USART_ReceiveData(USARTx); } /* Receive the USART data */ else { RxBuffer[RxIndex++] = USART_ReceiveData(USARTx); } } } }
void USART1_IRQHandler (void)//следует разработать систему распознавания старого протокола или заменить на выбор вручную { static portBASE_TYPE xHigherPriorityTaskWoken; xHigherPriorityTaskWoken = pdFALSE; // if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) { USART_ClearITPendingBit(USART1, USART_IT_RXNE); symbol=USART_ReceiveData (USART1); //----------------------обрабатываем возможные ошибки длины кадра------------- if(recieve_count>MAX_LENGTH_REC_BUF) //если посылка слишком длинная { recieve_count=0x0; return; } if(recieve_count==0x0) { if(symbol==':')//признак старого протокола { proto_type=PROTO_TYPE_OLD; } else { if((symbol==0x0) || (symbol==0xD7))//новый протокол { proto_type=PROTO_TYPE_NEW; } else//ошибка кадра или не с начала { return; } } } switch(proto_type) { case PROTO_TYPE_OLD: { if(symbol==':') { recieve_count=0x0; } tab.tablo_proto_buf[recieve_count]=symbol; recieve_count++; if(recieve_count>1) { if(tab.tablo_proto_buf[1]==(recieve_count-2))//кадр принят { USART_ITConfig(USART1, USART_IT_RXNE , DISABLE); xSemaphoreGiveFromISR( xProtoSemaphore, &xHigherPriorityTaskWoken ); if( xHigherPriorityTaskWoken != pdFALSE ) { portEND_SWITCHING_ISR( xHigherPriorityTaskWoken ); } } } } break; case PROTO_TYPE_NEW: { //--------------------------начало кадра...проверка до длины кадра-------- if(recieve_count<6) { switch(recieve_count) { case 0: //первый символ 0 { if(symbol!=0x00) { recieve_count=0; fr_err++; //return; } } break; case 1: //второй символ 0xD7 { if(symbol!=0xD7) { recieve_count=0; //return; } } break; case 2: // третий символ 0x29 { if(symbol!=0x29) { recieve_count=0; //return; } } break; case 3: //если адрес не совпал, то сбросим//NEW { if(symbol!=ADRESS_DEV)//если адрес совпал { recieve_count=0; //return; } } break; default: // { } break; } RecieveBuf[recieve_count]=symbol;//сохраняем принятый символ в буфер recieve_count++;//счетчик буфера if(recieve_count==6) { frame_len=RecieveBuf[recieve_count-1]; //получим оставшуюся длину } } //--------------------------------------------------------- else //отсюда знаем длину кадра и удаляем нули после 0xD7 { switch(symbol)//проверим, это 0x0 ,0xD7 или другое { case 0xD7: { CUT_OUT_NULL=1; // RecieveBuf[recieve_count]=symbol; recieve_count++; } break; case 0x0: { if(!CUT_OUT_NULL) //если вырезать 0x0 не надо, то не вырезаем { RecieveBuf[recieve_count]=symbol; recieve_count++; } else //иначе в буфер не кладем, сбросим флаг { CUT_OUT_NULL=0; } } break; default: //другие кладем в буфер { CUT_OUT_NULL=0; RecieveBuf[recieve_count]=symbol; recieve_count++; } break; } if(recieve_count>=frame_len+6)//если приняты все байты { USART_ITConfig(USART1, USART_IT_RXNE , DISABLE); /* 'Дать' семафор для разблокировки задачи. */ xSemaphoreGiveFromISR( xProtoSemaphore, &xHigherPriorityTaskWoken ); if( xHigherPriorityTaskWoken != pdFALSE ) { portEND_SWITCHING_ISR( xHigherPriorityTaskWoken ); } } } } } } //----------------------------передача---------------------------------------------------------------- if(USART_GetITStatus(USART1, USART_IT_TC) != RESET) { USART_ClearITPendingBit(USART1, USART_IT_TC);//очищаем признак прерывания if(transf_count<buf_len) { if(transf_count<3)//передаем заголовок { USART_SendData(USART1,TransferBuf[transf_count]); transf_count++; } else //тело... подставляем 0 после 0xD7 { if(CUT_OUT_NULL==0) { if(TransferBuf[transf_count]==(uint8_t)0xD7)//проверим, это ,0xD7 или другое { CUT_OUT_NULL=0x1; } USART_SendData(USART1,TransferBuf[transf_count]); transf_count++; } else { USART_SendData(USART1,(uint8_t)0x0); CUT_OUT_NULL=0; } } } else { transf_count=0; //обнуляем счетчик recieve_count=0; CUT_OUT_NULL=0; USART_ITConfig(USART1, USART_IT_RXNE , ENABLE); } } portEND_SWITCHING_ISR( xHigherPriorityTaskWoken ); }
void UART4_IRQHandler(void){ if(count>120){ count=0; } if(USART_GetITStatus(UART4, USART_IT_RXNE)==RESET){ return; } dwin_receive[count++]=USART_ReceiveData(UART4); USART_SendData(USART1, dwin_receive[count-1]); while(USART_GetFlagStatus( USART1, USART_FLAG_TXE)==RESET); USART_ClearITPendingBit(UART4, USART_IT_RXNE); if(isregister==1){ if(count==len){ portBASE_TYPE xHigherPriorityTaskWoken=pdFALSE; lcd_data *info=pvPortMalloc(sizeof(lcd_data)+len); if(info!=NULL){ info->type=0x81; info->len=len; info->addr=address; // USART_SendData(USART1, dwin_receive[0]); // while(USART_GetFlagStatus( USART1, USART_FLAG_TXE)==RESET); // USART_SendData(USART1, dwin_receive[1]); // while(USART_GetFlagStatus( USART1, USART_FLAG_TXE)==RESET); // USART_SendData(USART1, 0xff); // while(USART_GetFlagStatus( USART1, USART_FLAG_TXE)==RESET); memcpy(&info[1],dwin_receive,len); if(xQueueSendFromISR(dwin_queue,&info,&xHigherPriorityTaskWoken)==pdPASS){ if(xHigherPriorityTaskWoken==pdTRUE){ taskYIELD(); } } } vPortFree(info); count=0; isregister=0; len=0; address=0; memset(dwin_receive,0,120); } return; } if(isvariable==1){ if(count==len){ portBASE_TYPE xHigherPriorityTaskWoken=pdFALSE; lcd_data *info=pvPortMalloc(sizeof(lcd_data)); if(info!=NULL){ info->type=0x83; info->len=len; info->addr=address; memcpy(&info[1],dwin_receive,len); if(xQueueSendFromISR(dwin_queue,&info,&xHigherPriorityTaskWoken)==pdPASS){ if(xHigherPriorityTaskWoken==pdTRUE){ taskYIELD(); } } } vPortFree(info); count=0; isvariable=0; len=0; address=0; memset(dwin_receive,0,120); } return; } if((count==6)&&(strncmp(dwin_receive,s,2)==0)){ //0x81 if(strncmp(&dwin_receive[3],&s[2],1)==0){ isregister=1; count=0; len=dwin_receive[2]-3; address=dwin_receive[4]; memset(dwin_receive,0,5); } } //0x83 if((count==7)&&(strncmp(dwin_receive,s,2)==0)){ if(strncmp(&dwin_receive[3],&s[3],1)==0){ isvariable=1; count=0; len=dwin_receive[2]-4; address=dwin_receive[4]; address=(address<<8)+dwin_receive[5]; memset(dwin_receive,0,6); } } }
/** * @brief MB_USARTx中断服务函数 * @param None * @retval None */ ARMAPI void BSP_IntHandlerUSART1_0(void) { #if defined(__GSF_VER2) //发生接收中断 if (USART1.Event(USART_FLAG_RXNE)) { prvvUARTRxISR(NULL); //清除中断标志位 USART1.Clear(USART_FLAG_RXNE); } //发生完成中断 if (USART1.Event(USART_FLAG_TC)) { prvvUARTTxReadyISR(NULL); //清除中断标志 USART1.Clear(USART_FLAG_TC); } //清除错误 if (USART1.Event(USART_FLAG_ORE)) { //清除中断标志 USART1.Clear(USART_FLAG_ORE); } #elif defined(__GSF_VER1) //发生接收中断 if (Serial1.Received()) { // Serial1.Read_ISR(); prvvUARTRxISR(); //清除中断标志位 Serial1.ClearITPendingBit(RXNE_FLAG); } //发生完成中断 if (Serial1.Transmitted()) { prvvUARTTxReadyISR(); //清除中断标志 Serial1.ClearITPendingBit(TC_FLAG); } #else if(USART_GetITStatus(MB_USARTx, USART_IT_RXNE) == SET) { prvvUARTRxISR(); //清除中断标志位 USART_ClearITPendingBit(MB_USARTx, USART_IT_RXNE); } //发生完成中断 if(USART_GetITStatus(MB_USARTx, USART_IT_TC) == SET) { prvvUARTTxReadyISR(); //清除中断标志 USART_ClearITPendingBit(MB_USARTx, USART_IT_TC); } //测试看是否可以去除 2012-07-23 //溢出-如果发生溢出需要先读SR,再读DR寄存器 则可清除不断入中断的问题 /* if(USART_GetFlagStatus(MB_USARTx,USART_FLAG_ORE)==SET) { USART_ClearFlag(MB_USARTx,USART_FLAG_ORE); //读SR USART_ReceiveData(MB_USARTx); //读DR } */ #endif }