sio_sample.c

来自「最新版IAR FOR ARM（EWARM）5.11中的代码例子」· C语言 代码 · 共 245 行

/*************************************************************************************/
/*                                                                                   */
/*      Copyright (C) 2005 Oki Electric Industry Co., LTD.                           */
/*                                                                                   */
/*      System Name     :  ML675050                                                  */
/*      Module Name     :  SIO Sample Functions                                      */
/*      File   Name     :  sio_sample.c                                              */
/*      Revision        :  1.00                                                      */
/*      Date            :  2005/02/17                                                */
/*                                                                                   */
/*************************************************************************************/
#include "ML675050.h"
#include "common.h"
#include "irq.h"

#ifdef __IAR__
#include <intrinsics.h>
#endif

/* constants */
#define SYSCLK      (64000000L)     /* SYSCLK (Hz) */
#define CGBGR       (8)             /* clock gear */
#define CLKSIO      (SYSCLK/CGBGR)  /* frequency CLKSIO (Hz) */
#define BAUDRATE    (9600)          /* baud rate of SIO (baud) */
#define VALUE_OF_SIO                /* value of SIOBT register */\
            ((256 * (16 * BAUDRATE) - CLKSIO) / (16 * BAUDRATE))

#define SIO_BUF_SIZE 256        /* ring buffer size */

#define rw_buf_in(value)        /* inserts a character in the ring buffer */\
(rw_buf[rw_in] = (value), rw_in++, rw_size++, \
 rw_in = (rw_in >= SIO_BUF_SIZE) ? 0 : rw_in)

#define rw_buf_out(receive)     /* outputs a character from the ring buffer */ \
((receive) = rw_buf[rw_out], rw_out++, rw_size--, \
 rw_out = (rw_out >= SIO_BUF_SIZE) ? 0 : rw_out)

/* function */
int  main(void);                        /* main routine */
static void reg_irq_handler(void);      /* registration of IRQ handler */
static void setup_sio(void);            /* set up of sio registers */
static void puts_sio(const char*,int);  /* output transmission data */
void sio_handler(void);                 /* sio handler */

/* global variables */
static volatile UBYTE rw_buf[SIO_BUF_SIZE];
static volatile int rw_in, rw_out;
static volatile int rw_size;
static volatile int transmit_flag;  /* 1:complete transmit 0: not complete transmit */
static volatile char error_flag;    /* 0:error not happen 1: overrun error
                                       2:parity error 3:framing error 4:overflow error */

/****************************************************************************/
/*  Entry point                                                             */
/*  Function : main                                                         */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   0                                                   */
/****************************************************************************/
int main(void)
{
    UWORD input;

	/* initialize irq */
    init_irq();

    /* registration of irq handler */
    reg_irq_handler();

    /* set up of sio registers */
    setup_sio();

    /* initialize led */
    init_led();   /* set output mode */
    led_on(LED_START_PATTERN);  /* light led start pattern - Orange Led On */

    /* initialize error_flag */
    error_flag = 0;

    /* enable IRQ */
    __enable_interrupt();

    /* start baud rate timer */
    put_wvalue(SIOBCN,SIOBCN_BGRUN);

    while(1)
    {
        if(error_flag >0 || rw_size != 0){  /* error happen ?
                                               & is there any data to transmit ? */
            if(error_flag > 0 ){    /* error ? */
                led_on(LED_ERROR_PATTERN);    /* light led end pattern - Red Led On*/
                if(error_flag == 1) puts_sio("\r\nOERR\r\n", 8);         /* overrun error ? */
                else if(error_flag == 2) puts_sio("\r\nPERR\r\n", 8);    /* parity error ? */
                else if(error_flag == 3) puts_sio("\r\nFERR\r\n", 8);    /* framing error ? */
                else if(error_flag == 4) puts_sio("\r\nOVFD\r\n", 8);    /* overflow error ? */
                else
                    ;
                error_flag = 0;
            }
            else{   /* no error */

               /* disable IRQ */
               __disable_interrupt();

               rw_buf_out(input);

               /* enable IRQ */
               __enable_interrupt();

               if(input == 0x1B)   /* esc */
                    break;
                else if(0x20 <= input && input <= 0x7E){    /* printable character */
                    transmit_flag = 0;
                    put_wvalue(SIOBUF,input);
                }
                else if(input == 0x0D){     /* enter */
                    transmit_flag = 0;
                    put_wvalue(SIOBUF,0x0D);
                    while(transmit_flag == 0)   /* complete transmit ? */
                        ;
                    transmit_flag = 0;
                    put_wvalue(SIOBUF,0x0A);
                }
                else
                    ;
            }
            while(transmit_flag == 0)   /* complete transmit ? */
                ;
        }
    }

    /* stop baud rate timer */
    put_wvalue(SIOBCN,0x0);

    put_wvalue(SIOCON,0x00);    /* disable sio interrupts */
    put_wvalue(ILC0, 0x0);      /* disable all interrupts */
    put_wvalue(ILC1, 0x0);      /* disable all interrupts */

    /* enable IRQ */

    __disable_interrupt();

    led_on(LED_NORMAL_END_PATTERN);    /* light led end pattern - Green Led On*/

    return(0);
}
/****************************************************************************/
/*  Registration of IRQ Handler                                             */
/*  Function : reg_irq_handler                                              */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/*  Note : Initialize of IRQ needs to be performed before this process.     */
/****************************************************************************/
void reg_irq_handler(void)
{
    /* register IRQ handlers into handler table */
    IRQ_HANDLER_TABLE[INT_SIO0] = sio_handler;

    /* setup interrupt level */
    set_wbit(ILC1, ILC1_ILR10 & ILC1_INT_LV2);  /* sio(nIRQ[10]) -> level2 */

    return;
}

/****************************************************************************/
/*  Setup of SIO registers                                                  */
/*  Function : setup_sio                                                    */
/*      Parameters                                                          */
/*          Input   : Nothing                                               */
/*          Output  : Nothing                                               */
/****************************************************************************/
void setup_sio(void)
{
    /* PORT 4 third function */
    set_wbit(PORTSEL4, 0x80008000) ; // uSOUT,uSIN
	
    /* a setup of SIOBT (set a reload value) */
    put_wvalue(SIOBT,VALUE_OF_SIO+1);		/* Adjustment value = 1 */

    /* a setup of SIOCON (8 bits of data length, parity bit none, a stop bit 1) */
    put_wvalue(SIOCON,SIOCON_LN8|SIOCON_PDIS|SIOCON_TSTB1);

    return;
}

/****************************************************************************/
/*  Output transmission data                                                */
/*  Function : puts_sio(*s,l)                                               */
/*      Parameters                                                          */
/*          Input   : Pointer to transmission data                          */
/*                    Length of transmission data                           */
/*          Output  : Nothing                                               */
/****************************************************************************/
void puts_sio(const char *s, int l)
{
    int i = 0;
    while(i <= l){
        transmit_flag = 0;
        put_wvalue(SIOBUF,(UHWORD)s[i]);    /* output one character */
        while(transmit_flag == 0)   /* complete transmit ? */
            ;
        i++;
    }
    return;
}
/*****************************************************************************/
/*  SIO handler                                                              */
/*  Function : sio_handler(void)                                             */
/*      Parameters                                                           */
/*          Input   : Nothing                                                */
/*          Output  : Nothing                                                */
/*****************************************************************************/
void sio_handler(void)
{
    UWORD sta = get_wvalue(SIOSTA);
    UWORD buf;

    if(sta & SIOSTA_RVIRQ){     /*  received interrupt ? */
        /* receive */
        put_wvalue(SIOSTA,SIOSTA_RVIRQ);    /* clear RVIRQ flag */
        buf = get_wvalue(SIOBUF);
        /* error happened */
        if(sta & 0x07){
            if((sta & 0x07) & SIOSTA_OERR) error_flag = 1;      /* overrun error ? */
            else if((sta & 0x07) & SIOSTA_PERR) error_flag = 2; /* parity error ? */
            else if((sta & 0x07) & SIOSTA_FERR) error_flag = 3; /* framing error ? */
            else
                ;
            put_wvalue(SIOSTA,(sta & 0x07));    /* clear error status */
        }
        else if((rw_size >= SIO_BUF_SIZE))   error_flag = 4;    /* overflow error ? */
        /* error did not happen */
        else{
            rw_buf_in((UBYTE)buf);
        }
    }
    else if(sta & SIOSTA_TRIRQ){
        /* transmit */
        put_wvalue(SIOSTA,SIOSTA_TRIRQ);    /* clear TRIRQ flag */
        transmit_flag = 1;
    }
    return ;
}