wdt_sample.c

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

/**********************************************************************************/
/*                                                                                */
/*    Copyright (C) 2005 Oki Electric Industry Co., LTD.                          */
/*                                                                                */
/*    System Name    :  ML674051/ML4061 series                                    */
/*    Module Name    :  WDT Sample Program                                        */
/*    File   Name    :  wdt_sample.c                                              */
/*    Revision       :  01.00                                                     */
/*    Date           :  2005/02/18 initial version                                */
/*                                                                                */
/**********************************************************************************/
#include "ML674061.h"
#include "common.h"
#include "irq.h"

#ifdef __IAR__
#include "intrinsics.h"
#endif

/* constants */
#define TMRCYC   (30)           /* interval of timer interrupt (ms) */
#define SYSCLK	(33)			/* SYSCLK (MHz)*/
#define VALUE_OF_TMRLR          /* reload value of timer */\
                (65536 - (TMRCYC * SYSCLK * 1000) / 16)

#if ((VALUE_OF_TMRLR) < 0 || 0x10000 <= (VALUE_OF_TMRLR))
#error Invalid value : VALUE_OF_TMRLR
#endif

/* functions */
int main(void);                     /* main routine */
static void reg_irq_handler(void);  /* registration of IRQ handler */
static void set_timer(void);        /* setup TIMER */
static void set_wdt(void);          /* setup WDT */
static void init_var(void);         /* initialize variables */
static void wdt_handler(void);      /* WDT handler */
static void timer_handler(void);    /* TIMER handler */

/* global variables */
static volatile int count;    /* counter of timer interrupt */
static volatile int end_flag;   /* end flag */

/****************************************************************************/
/*  Entry point                                                             */
/*  Function : main                                                         */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   0                                                   */
/****************************************************************************/
int main(void)
{
    init_irq(); /* initialize IRQ */

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

    set_timer();    /* setup TIMER */

    set_wdt();  /* setup WDT */

    init_var(); /* initialize variables */

      /* enable IRQ */
#ifdef __IAR__
      __enable_interrupt();
#else
    irq_en();
#endif

    /* light LED */
    init_led();    /* output mode */
    led_on(LED_START_PATTERN);

    /* timer start */
    put_wvalue(TMEN, 0x01); /* enable timer (write '1' in TMEN[0]) */

    put_value(WDTCON, WDTCON_0x3C);    /* wdt start */

    /* loop */
    while(end_flag != 1)
        ;

    /* wdt stop */
    put_value(TBGCON, TBGCON_0x5A);		/* enable writing to TBGCON register */
    set_bit(TBGCON, TBGCON_WDHLT);

    put_wvalue(TMEN, 0);    /* timer stop */

       /* enable IRQ */
#ifdef __IAR__
      __disable_interrupt();
#else
    irq_dis();
#endif


    /* output exit status */
    if(count >= 100)
        led_on(LED_NORMAL_END_PATTERN);   /* normal end */
    else
        led_on(LED_E);   /* error end */

    while(1);
    //return 0;
}

/****************************************************************************/
/*  Registration of IRQ Handler                                             */
/*  Function : reg_irq_handler                                              */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/*  Note : Initialization of IRQ needs to be performed before this process. */
/****************************************************************************/
void reg_irq_handler(void)
{
    /* register IRQ handlers into IRQ handler table */
    IRQ_HANDLER_TABLE[INT_SYSTEM_TIMER] = timer_handler;
    IRQ_HANDLER_TABLE[INT_WDT] = wdt_handler;

    /* setup interrupt level */
    set_wbit(ILC0, ILC0_ILR0 & ILC0_INT_LV1);   /* system timer(nIRQ[0]) -> level1 */
    set_wbit(ILC0, ILC0_ILR1 & ILC0_INT_LV2);   /* wdt(nIR[1]) -> level2 */

    return;
}

/****************************************************************************/
/*  Setup of timer                                                          */
/*  Function : set_timer                                                    */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void set_timer(void)
{
    put_wvalue(TMEN, 0x0);      /* disable timer (write '0' in TMEN[0])*/
    put_wvalue(TMOVF, 0x01);    /* clear overflow register (write '1' in TMOVF[0])*/
    put_wvalue(TMRLR, VALUE_OF_TMRLR);  /* set TMRLR */

    return;
}

/****************************************************************************/
/*  Setup of WDT                                                            */
/*  Function : set_wdt                                                      */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void set_wdt(void)
{
    put_value(TBGCON, TBGCON_0x5A);		/* enable writing to TBGCON register */
    put_value(TBGCON, TBGCON_WDCK256);	/* CCLK/256 */
    clr_bit(TBGCON, TBGCON_OFINT);		/* when WDT overflowed, interrupt occurs */

    return;
}

/****************************************************************************/
/*  initialize variables                                                    */
/*  Function : init_var                                                     */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void init_var(void)
{
    count = 0;
    end_flag = 0;

    return;
}

/****************************************************************************/
/*  WDT handler                                                             */
/*  Function : wdt_handler                                                  */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void wdt_handler(void)
{
    clr_bit(INTST, INTST_WDTINT);   /* clear WDT interrupt */
    end_flag = 1;
}

/****************************************************************************/
/*  System Timer handler                                                    */
/*  Function : timer_handler                                                */
/*      Parameters                                                          */
/*          Input   :   Nothing                                             */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void timer_handler(void)
{
    static UBYTE clr_value = WDTCON_0xC3;

    put_wvalue(TMOVF, 0x01);    /* clear TMOVF register (write '1' in TMOVF[0])
                                   if TMOVF register isn't cleared,
                                   timer interrupt never occur. */

    /* clear WDT */
    put_value(WDTCON, clr_value);
    clr_value = ~clr_value;

    count++;

    if(count >= 100)
        put_wvalue(TMEN, 0x00); /* stop timer */

    return;
}