uart_sample.c

oki测试uart,pwm,a/d的程序

    /***********************************************************
        The value of a baud rate is set as 115,200 bps
    ***********************************************************/
    set_bit(UARTLCR,UARTLCR_DLAB);
    
    put_value(UARTDLL,DLL_BAUD);   /* DLL of divider latch register */
    put_value(UARTDLM,DLM_BAUD);   /* DLM of divider latch register */

    clr_bit(UARTLCR,UARTLCR_DLAB);

    /***********************************************************
        Setup of FIFO
        FCR_FE       corresponds to transmit/receive FIFO enable
        FCR_RFCRL    corresponds to receiving FIFO clear
        FCR_TFCLR    corresponds to transmission FIFO clear
        FCR_RF_LV14 corresponds to trigger level size :14
    ***********************************************************/
    put_value(UARTFCR, UARTFCR_FE | UARTFCR_RFCLR | UARTFCR_TFCLR | UARTFCR_RFLV14);

    /***********************************************************
        Setup of LCR
        LCR_LN8   corresponds to character length :8
        LCR_STB1S corresponds to stop bit   : 1
        LCR_PDIS  corresponds to parity bit : none
    ***********************************************************/
    put_value(UARTLCR,UARTLCR_LEN8 | UARTLCR_STB1 | UARTLCR_PDIS);

    /*******************************************************
        A setup of a modem control register
            == This function is not used ==
    *******************************************************/
    put_value(UARTMCR,0x0);

    /*******************************************************
        Enable uart interrupt 
        IER_ERBF  corresponds  to receiving data effective
        IER_ETBEF corresponds  to transmission data empty
        IER_ELSI  corresponds  to receiving line status
    *******************************************************/
    put_value(UARTIER,UARTIER_ERBF | UARTIER_ETBEF | UARTIER_ELSI);

    return;
}

/********************************************************************/
/*  UART Interruption processing                                    */
/*  Function : uart_handler                                         */
/*        Parameters                                                */
/*            Input  :  Nothing                                     */
/*            Output :  Nothing                                     */
/********************************************************************/
void uart_handler()
{
    int  i,j;
    int  uart_interrupt_kind;
    int  error_status;
    unsigned  char  tmp;

    uart_interrupt_kind =  get_value(UARTIIR);
    uart_interrupt_kind &= 0x0f;

    switch (uart_interrupt_kind){

        case UARTIIR_LINE :            /* receiving line status interrupt */

            tmp = get_value(UARTRBR);       /* read error data */

            error_status = get_value(UARTLSR);
                             
            if(error_status & UARTLSR_OE){      /* overrun error ? */
                error_flag = 1;
            }

            else if(error_status & UARTLSR_PE){ /* parity error ? */
                error_flag = 2;
            }

            else if(error_status & UARTLSR_FE){ /* framing error ? */
                error_flag = 3;
            }
            
            else
                ;
            
            break;


        case  UARTIIR_RCV : /* receiving data effective interrupt */

            for(i = 0; i < TRIGGER_LEVEL; i++){

                if ( rec_data_counter > BUFF_SIZE ){   /* overflow error ? */
                    /* clear receiving FIFO */
                    put_value(UARTFCR,UARTFCR_FE | UARTFCR_RFCLR | UARTFCR_RFLV14);
                    error_flag = 4;
                    break;
                }

                rw_buff[write_pointer] = get_value(UARTRBR);
                rec_data_counter++;
                
                if( (rw_buff[write_pointer] == 0x0a) || (rw_buff[write_pointer] == 0x0d) )
                {
                	uart_printf("***",3,0);
                	for( j = 0 ; j < write_pointer/10 ; j++ )
                	{
                		uart_printf((char *)rw_buff+j*10,10,0);
                	}
                	
                	uart_printf((char *)(rw_buff+j*10),write_pointer-j*10,1);
                	write_pointer = 0;;
                }
                else
                	/* update write pointer */
                	write_pointer++;
                
                if(write_pointer >= BUFF_SIZE){
                    write_pointer = 0;
                }
            }
            break;


        case UARTIIR_TO : /* time out interrupt */

            /* exist receiving data? */
            while ((get_value(UARTLSR) & UARTLSR_DR) == UARTLSR_DR){

                if ( rec_data_counter > BUFF_SIZE ){    /* overflow error ? */
                   /* clear receiving FIFO */
                   put_value(UARTFCR,UARTFCR_FE | UARTFCR_RFCLR | UARTFCR_RFLV14); 
                   error_flag = 4;
                   break;
                }
                
                rw_buff[write_pointer] = get_value(UARTRBR);
                rec_data_counter++;
                
                if( (rw_buff[write_pointer] == 0x0a) || (rw_buff[write_pointer] == 0x0d) )
                {
                	uart_printf("***",3,0);
                	for( j = 0 ; j < write_pointer/10 ; j++ )
                	{
                		uart_printf((char *)rw_buff+j*10,10,0);
                	}
                	
                	uart_printf((char *)(rw_buff+j*10),write_pointer-j*10,1);
                	
                	write_pointer = 0;;
                }
                else
                	/* update write pointer */
                	write_pointer++;
                	
                if (write_pointer >= BUFF_SIZE){
                    write_pointer = 0;
                }
            }
            break;


        case UARTIIR_TRA : /* transmission empty interrupt */
            break;


        default   : break;
    }
}

/****************************************************************************/
/*  Registration of IRQ Handler                                             */
/*  Function : reg_irq_handler                                              */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/*  Note : Initialize IRQ needs to be performed before this process.        */
/****************************************************************************/
void reg_irq_handler(void)
{
    /* register IRQ handler into IRQ handler table */
    IRQ_HANDLER_TABLE[INT_UART] = uart_handler;  /* UART interrupt number 9 */

    set_wbit(ILC1, ILC1_ILR9 & ILC1_INT_LV7 ); /* interrupt level of
                       ||          ||             IRQ number 9 is set as 7
                   IRQ number   interrupt level  */
    return;
}

/*!!! Cannot exceed 12 char !!!*/
void uart_printf(char* p,int len,int iNeedLine)
{
	int i;
	unsigned char temp;
	
	for( i = 0 ; i < len ; i++ )
	{
		put_value(UARTTHR,p[i]);	
	}
	if(iNeedLine)
	{
		put_value(UARTTHR,0x0D);  /* carriage return */
		put_value(UARTTHR,0x0A);  /* line feed */
	}
	
	for( i = 0 ; i < 3000 ; i++ )
		;
	/* clear receiving and write FIFO */
    put_value(UARTFCR, UARTFCR_FE | UARTFCR_RFCLR | UARTFCR_TFCLR | UARTFCR_RFLV14);
}

void __gccmain()
{
}