Ejemplo n.º 1
0
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);
	}
}
Ejemplo n.º 2
0
/*******************************************************************************
* 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 
}
Ejemplo n.º 3
0
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
            {

            }
        }
    }       
}
Ejemplo n.º 5
0
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;
					}
				}
			}
		}

}
Ejemplo n.º 6
0
// обработчик прерываний для всех прерываний связанных с UART1
void USART1_IRQHandler(void){
	// если установлен флаг прерывания по поступлению данных
	if( USART_GetITStatus(USART1, USART_IT_RXNE) )
		USART_putc(USART1, USART1->DR);
}
Ejemplo n.º 7
0
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;
        }
    }
}
Ejemplo n.º 8
0
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
}
Ejemplo n.º 9
0
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");
				}	
			}
		}		
  }	
	
}
Ejemplo n.º 10
0
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();
}
Ejemplo n.º 11
0
/* 说明一下,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;
}
Ejemplo n.º 12
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);
} 
Ejemplo n.º 13
0
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);
		
    }	
}
Ejemplo n.º 14
0
/**
* @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 */
}
Ejemplo n.º 15
0
//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;
		}*/

	}
}
	
}
Ejemplo n.º 16
0
// 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;//接收数据错误,重新开始接收	  
// 							}		 
// 				}
// 			}   		 
    }
		
} 
Ejemplo n.º 17
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;
		}
	}
}
Ejemplo n.º 18
0
Archivo: serial.c Proyecto: mxx/cabra
/* 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);
}
Ejemplo n.º 20
0
// 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))
      ;
}
Ejemplo n.º 21
0
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
	}
}
Ejemplo n.º 22
0
/*
*********************************************************************************************************
*	函 数 名: 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--;
		}
	}
}
Ejemplo n.º 23
0
static int int_uart_rx_get_status( elua_int_resnum resnum )
{
  return USART_GetITStatus( stm32_usart[ resnum ], USART_IT_RXNE ) == SET ? 1 : 0;
}
Ejemplo n.º 24
0
/*void PPP_IRQHandler(void)
{
}*/
void USART1_IRQHandler(void)
{
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
	{ 	
	} 
}
Ejemplo n.º 25
0
void USART6_IRQHandler(void){
	// check if the USART1 receive interrupt flag was set
	if(USART_GetITStatus(USART6, USART_IT_RXNE) != RESET){

	}
}
Ejemplo n.º 26
0
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 );
    }
}
Ejemplo n.º 27
0
/**
* @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);
      }
    }
  }     
}
Ejemplo n.º 28
0
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 );

}
Ejemplo n.º 29
0
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);
				

			}

			

		}
	




}
Ejemplo n.º 30
0
/**
  * @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
}