uart_sample.c

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

/**************************************************************************/
/*                                                                        */
/*     Copyright (C) 2001 Oki Electric Industry Co., LTD.                 */
/*                                                                        */
/*     System Name  :  ML674000                                           */
/*     Module Name  :  ML674000 uart sample program                       */
/*     File   Name  :  uart_sample.c                                      */
/*     Revision     :  01.00                                              */
/*     Date         :  2001/01/17                                         */
/*                     Initial version                                    */
/*                                                                        */
/**************************************************************************/
#include   "ML674000.h"
#include   "common.h"
#include   "irq.h"

/* constants */
#define    TRIGGER_LEVEL        14
#define    BUFF_SIZE            1024
#define    FIFO_SIZE            16

#define    DLM_BAUD             0x00  /* baud = 115,200 */
#define    DLL_BAUD             0x12  /* baud = 115,200 */
/* === setting baud rate value === */
/*     baud  | DLM_BAUD | DLL_BAUD */
/*     1,200 |   0x06   |   0xB7   */
/*     2,400 |   0x03   |   0x5B   */
/*     4,800 |   0x01   |   0xAE   */
/*     9,600 |   0x00   |   0xD7   */
/*    19,200 |   0x00   |   0x6B   */
/*    38,400 |   0x00   |   0x36   */
/*    57,600 |   0x00   |   0x24   */
/*   115,200 |   0x00   |   0x12   */
 
/* functions */
int     main(void);             /* main routine */
void    init_uart(void);        /* initialize UART */
void    uart_handler(void);     /* UART interrupt handler */
void    reg_irq_handler(void);  /* registration of IRQ handler */
void    led_on(UHWORD);         /* LED on */
void    uart_printf(char* p,int len, int iNeedLine);	/* uart printf */

/* global variables */
volatile  unsigned  char  rw_buff[BUFF_SIZE];  /* ring buffer */
volatile  int  write_pointer;
volatile  int  rec_data_counter;
volatile  int  error_flag;  /* 0:no error, 1:overrun error, 2:parity error,
                               3:framing error, 4:overflow error */
/******************************************************************/
/*  Entry point                                                   */
/*  Function : main                                               */
/*      Parameters                                                */
/*          Input  :  Nothing                                     */
/*          Output :  0                                           */
/******************************************************************/
int main(void)
{
    unsigned char temporary_area;
    int  read_pointer;
    int  end_flag;             /* escape code flag */
    int  trans_count;

    init_irq();                /* initialize IRQ */
    
    reg_irq_handler();         /* registration of IRQ handler */
    
    put_wvalue(ROMAC,0x0);     /* OE/WE palse width :1 (fastest) */

    /* setting of PORT */
    set_hbit(GPCTL,0x0001);    /* selection of a secondary function (GPCTL 0bit)*/

    init_uart();               /* initialize UART */

    set_hbit(GPPMB,0x00ff);    /* initialize LED */

    led_on(LED_START_PATTERN); /* turn on upper square LED */
    
    /* initialize variables */
    end_flag    =  0;
    trans_count =  0;
    error_flag  =  0;
    write_pointer  =  0;
    read_pointer   =  0;
    rec_data_counter  = 0;

    irq_en();                   /* enable IRQ */

	uart_printf("Welcome use",12,0);
	uart_printf(" Embest IDE",11,1);
	uart_printf("Input:",6,1);
	
    while (end_flag == 0){

        /* transmission FIFO empty ? */
        while ((get_value(UARTLSR) & UARTLSR_THRE) != UARTLSR_THRE)
            ;

        trans_count = 0;

        do {
            if (error_flag != 0){  /* error ? */

                /* transmission FIFO empty ? */
                while ((get_value(UARTLSR) & UARTLSR_THRE) != UARTLSR_THRE)
                    ;

                switch (error_flag){
                    case 1 :    /* overrun error */
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line feed */
                            put_value(UARTTHR,'O');   /* overrun error */
                            put_value(UARTTHR,'E');
                            put_value(UARTTHR,'E');
                            put_value(UARTTHR,'R');
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line feed */
                            break;

                    case 2 :    /* parity error */
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line Feed */
                            put_value(UARTTHR,'P');   /* parity error */
                            put_value(UARTTHR,'E');
                            put_value(UARTTHR,'E');
                            put_value(UARTTHR,'R');
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line feed */
                            break;

                    case 3 :    /* framing error */
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line feed */
                            put_value(UARTTHR,'F');   /* framing error */
                            put_value(UARTTHR,'E');
                            put_value(UARTTHR,'E');
                            put_value(UARTTHR,'R');
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line feed */
                            break;

                    case 4 :    /* overflow error */
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* fine feed */
                            put_value(UARTTHR,'O');   /* overflow error */
                            put_value(UARTTHR,'V');
                            put_value(UARTTHR,'F');
                            put_value(UARTTHR,'D');
                            put_value(UARTTHR,0x0D);  /* carriage return */
                            put_value(UARTTHR,0x0A);  /* line feed */
                            break;

                    default : break;
                }
                error_flag = 0;
            }

            /* exist data ? */
            else if ( rec_data_counter > 0){

                temporary_area = rw_buff[read_pointer];

                /* update read pointer */
                read_pointer++;
                if (read_pointer >= BUFF_SIZE){ 
                    read_pointer = 0;
                }

                irq_dis();           /* disable IRQ */
                rec_data_counter--;            
                irq_en();            /* enable IRQ */
                    
                /* Esc */
                if (temporary_area == 0x1B){
                    end_flag = 1;
                    break;
                }

                /* Enter */
                else if (temporary_area == 0x0D){
                    put_value(UARTTHR,0x0D);    /* carriage return */
                    put_value(UARTTHR,0x0A);    /* line feed */
                    trans_count += 2;
                }
                  
                /* printable character */
                else if (0x20 <= temporary_area && temporary_area<= 0x7E){
                    put_value(UARTTHR,temporary_area);
                    trans_count++;
                }
                
                else
                    continue;
            }
        }while (trans_count < (FIFO_SIZE - 1)); 
    }                        

    put_value(UARTIER,0x0);          /* disable UART interrupt */
    irq_dis();                       /* disable IRQ */
    
    led_on(LED_NORMAL_END_PATTERN);       /* turn on lower square LED */
    
    return 0;
}

/******************************************************************/
/*  Initialize UART                                               */
/*  Function : init_uart                                          */
/*      Parameters                                                */
/*          Input  :  Nothing                                     */
/*          Output :  Nothing                                     */
/******************************************************************/
void init_uart()
{