uart_drv.c

在ARM7和UC/OSII的平台上实现了GPS自动报站的功能,涉及GPS模块LEA_4S的驱动,位置速寻算法,语音芯片ISD4004的录放音驱动,LED页面管理等等.从启动代码到操作系统的移植以及到业

void uarts_write(INT32U chan, INT8U data)
{
    INT16S cur;
    USART_DESC *usart;
    
    if(MAX_UART < chan) return ;
        
    usart = &dev_usart[chan];
    if (chan == 0) {    
    if (WriteRoundBuf(&uarts[chan].s_round, data)) {
        if ((uarts[chan].status & UART_SENDING) == 0) {
            if ((cur = ReadRoundBuf(&uarts[chan].s_round)) != -1) {
                uarts[chan].status |= UART_SENDING;
                WriteUARTReg(chan, cur);
                EnableUARTInt(chan,AT91C_US_TXRDY);
            }
        }
    }
    } else {   
    if (WriteRoundBuf(&uarts[chan].s_round, data)) {
        if ((uarts[chan].status & UART_SENDING) == 0) {
            if ((cur = ReadRoundBuf(&uarts[chan].s_round)) != -1) {
                uarts[chan].status |= UART_SENDING;
                WriteUARTReg(chan, cur);
                EnableUARTInt(chan,AT91C_US_TXRDY);
            }
        }
    }   
    } 
}

INT16S uarts_read(INT32U chan)
{

    if(MAX_UART < chan) return -1;
  
    return ReadRoundBuf(&uarts[chan].r_round);
}
	
void uarts_writeblock(INT32U chan, INT8U *data, INT32U datalen)
{

    if(MAX_UART < chan) return ;
        
    for (; datalen > 0; datalen--) {
        uarts_write(chan, *data++);
    }
}

BOOLEAN uarts_pdcsend(INT32U chan,INT8U *buf,INT32U datalen)
{
    USART_DESC *usart = &dev_usart[chan];
    if (chan > MAX_UART)  return FALSE;	
 
    if ((uarts[chan].status & UART_SENDING) == 0) {
       OS_ENTER_CRITICAL();
       uarts[chan].status |= UART_SENDING;
       usart->reg->US_TPR = (INT32U)buf;
	   usart->reg->US_TCR = datalen;	
	   OS_EXIT_CRITICAL();
	   //使能发送
	   DisableUARTInt(chan,AT91C_US_TXRDY);
	   EnableUARTInt(chan,AT91C_US_ENDTX);	
	   usart->reg->US_CR = AT91C_US_TXEN;
	   
	   return TRUE;
    }
	else
	   return FALSE;
}

BOOLEAN uarts_issending(INT32U chan)
{
	if (uarts[chan].status & UART_SENDING) 
		return TRUE;
	else 
		return FALSE;
}

void USART0_ISR(void)
{
    INT32U status,imr_reg;
    USART_DESC *usart = &dev_usart[0];
    status = usart->reg->US_CSR;
    imr_reg = usart->reg->US_IMR;
    if (imr_reg & AT91C_US_RXRDY) {
        if (status & AT91C_US_RXRDY) { 
           uarts_isr_r(0); 
        }
    }
        
    if (imr_reg & AT91C_US_TXRDY) {
        if (status & AT91C_US_TXRDY) {
           uarts_isr_s(0);
        }   
    }
        
    if(imr_reg & AT91C_US_ENDTX) {
        if (status & AT91C_US_ENDTX) {
           pdc_isr_s(0);
        }   
    }
        
    if(imr_reg & AT91C_US_ENDRX) {
        if (status & AT91C_US_ENDRX) {
           pdc_isr_r(0);
        }    
    } 
    if(imr_reg & AT91C_US_TIMEOUT) {
        if (status & AT91C_US_TIMEOUT) {
           pdc_isr_r(0);
        }   
    } else {
        //uarts_reset(1);
    }
}

void USART1_ISR(void)
{
    INT32U status,imr_reg;
    USART_DESC *usart = &dev_usart[1];
    status = usart->reg->US_CSR;
    imr_reg = usart->reg->US_IMR;
    if (imr_reg & AT91C_US_RXRDY) {
        if (status & AT91C_US_RXRDY) { 
           uarts_isr_r(1); 
        }
    }
    if (imr_reg & AT91C_US_TXRDY) {
        if (status & AT91C_US_TXRDY) {
           uarts_isr_s(1);
        }   
    }    
    if(imr_reg & AT91C_US_ENDTX) {
        if (status & AT91C_US_ENDTX) {
           pdc_isr_s(1);
        }   
    }   
    if(imr_reg & AT91C_US_ENDRX) {
        if (status & AT91C_US_ENDRX) {
           pdc_isr_r(1);
        }    
    } 
    if(imr_reg & AT91C_US_TIMEOUT) {
        if (status & AT91C_US_TIMEOUT) {
           pdc_isr_r(1);
        }   
    } else {
        //uarts_reset(1);
    }    
}

void uarts_init(INT32U chan, INT32U baud)
{
    uarts[chan].status  = UART_INIT;
    uarts[chan].baud    = baud;
    InitRoundBuf(&uarts[chan].s_round, uarts[chan].s_buf, sizeof(uarts[chan].s_buf), 0);
    InitRoundBuf(&uarts[chan].r_round, uarts[chan].r_buf, sizeof(uarts[chan].r_buf), 0);
    InitUART(chan, baud);
    if (chan == USART0) {
       AIC_Install(AT91C_ID_US0,US0_PRIO,AIC_LEVEL_LOW,USART0_ISR);
       AIC_Int_Enable(AT91C_ID_US0);
    } else if (chan == USART1) {  
       AIC_Install(AT91C_ID_US1,US1_PRIO,AIC_LEVEL_LOW,USART1_ISR);
       AIC_Int_Enable(AT91C_ID_US1);
    }  
    EnableUARTInt(chan,AT91C_US_RXRDY);     
}

void SendFromUART_BYTE(INT32U chan, INT8U ch)
{
    USART_DESC *usart = &dev_usart[chan];

    if (chan > MAX_UART)  return;
    while ((usart->reg->US_CSR & AT91C_US_TXRDY) == 0) {}
    WriteUARTReg(chan, ch);
}

static INT8U HexToChar(INT8U ch)
{
    INT8U temp;
    temp = ch & 0x0f;
    if (temp <= 0x09)
        temp = '0' + temp;
    else 
       temp = 'a' + temp - 0x0a;
   return temp;         
}    

void SendFromUART_HEX(INT32U chan, INT8U ch)
{
    SendFromUART_BYTE(chan, HexToChar(ch >> 4));
    SendFromUART_BYTE(chan, HexToChar(ch));
    SendFromUART_BYTE(chan, ' ');
}

void SendFromUART_STR(INT32U chan, INT8U *p)
{
    while(*p) {SendFromUART_BYTE(chan, *p++);}
}

void SendFromUART_MEM(INT32U chan, INT8U *p, INT32U memsize)
{
    INT16U i;
    for (i = 0; i < memsize; i++) SendFromUART_BYTE(chan, *p++);
}

void SendFromUART_MEM_HEX(INT32U chan, INT8U *p, INT32U memsize)
{
    for (; memsize > 0; memsize--)
        SendFromUART_HEX(chan, *p++);
}

void PrintFromUART(INT32U chan, char *p)
{
    while(*p)
    {
        if (*p == '\n') {
            SendFromUART_BYTE(chan, 0x0D);
            SendFromUART_BYTE(chan, 0x0A);
            p++;
        } else {
            SendFromUART_BYTE(chan, *p++);
        }
    }
}

void uarts_write_D(INT32U chan, INT8U data)
{
    USART_DESC *usart = &dev_usart[chan];

    if(MAX_UART < chan) return ;
   	while(!(usart->reg->US_CSR & AT91C_US_TXRDY)) ;
   	WriteUARTReg(chan, data);
   
}
#if EN_DEBUG_BSP > 0
static INT8U temp[200];
static void Poll1Uart(void)
{ 

 	INT16U i,usedlen;

 	usedlen = UsedOfRoundBuf(&uarts[0].r_round);
 	if(usedlen >100) {
 		for(i=0;i<usedlen;i++) {
 			temp[i] = ReadRoundBuf(&uarts[0].r_round);
 		}
 		uarts_writeblock(DEBUG_UARTNo_DRIV, temp, usedlen);
 		//PrintFromUART(DEBUG_UARTNo_DRIV,"\nuartID=");
 		//SendFromUART_HEX(DEBUG_UARTNo_DRIV, j); 		
 		//PrintFromUART(DEBUG_UARTNo_DRIV,"\nrecvdatalen=");
 		//SendFromUART_HEX(DEBUG_UARTNo_DRIV, usedlen);
 		//PrintFromUART(DEBUG_UARTNo_DRIV,"\ndata=");
 		//SendFromUART_MEM_HEX(DEBUG_UARTNo_DRIV, temp, usedlen);
 	}
}

static INT8U checkarray[200];
void checkuartsend(void)
{
    INT16U i,j;
    INT8U *ptr;     
    uarts_init(0, 57600);
	uarts_init(1, 57600); 
    for(;;) {
    	ptr = checkarray;
    	for(i=1; i<65535; i++) {
    		*ptr++ = i;
    		if(i%200 == 0) {
    			ClearWatchdog();    			
    			uarts_writeblock(0, checkarray, 200);
    			//uarts_writeblock(1, checkarray, 200);
    			ptr = checkarray;
    			for(j=65535; j>0; j--);
    			for(j=65535; j>0; j--);
    	    		
    		}
    	ClearWatchdog();
		for(j=5000; j>0; j--);
    	Poll1Uart();
    	ClearWatchdog();
		}
	}
    
}
#endif