errtask.c

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

/****************************************************************
**                                                              *
**  FILE         :  ErrTask.C                                   *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : CCH 2002.1.15                                          *
****************************************************************/
#include "includes.h"
#include "bsp.h"
#include "simuarts.h"
#include "errtask.h"
#include "errcode.h"
#include "watchdog.h"
#include "tools.h"
#include "uart_drv.h"

#include "errcode.h"
#include "zprint.h"





/*
********************************************************************************
*                  DEFINE CONFIG PARAMETERS
********************************************************************************
*/
static OS_STK ErrTaskStack[STACK_ERRTASK];



/*
********************************************************************************
*                  DEFINE ERR CONTROL BLOCK
********************************************************************************
*/
static struct {
    INT32U  CurTag;
    INT32U  nUsed;
    INT32U  nBackup;
    void (* DiagProc[MAX_DIAGSUBS])(void);
    void (* BackProc[MAX_DIAGSUBS])(void);
} ECB;

static INT8U wdgid;


static void InitErrTask(void)
{
    INT32U i;

#if EN_RESETREC > 0
    if (!PubParaValid(RESETREC_)) ClearPubPara(RESETREC_);
    ResetRec.nReset++;
    if (RSTSRC & 0x01) ResetRec.nExtWDT++;
    if (RSTSRC & 0x04) ResetRec.nIntWDT++;
    RSTSRC = 0;
    StorePubPara(RESETREC_);
#endif

    ECB.CurTag   = 0;
    ECB.nUsed    = 0;
    ECB.nBackup  = 0;
    for (i = 0; i < MAX_DIAGSUBS; i++) {
        ECB.DiagProc[i] = 0;
        ECB.BackProc[i] = 0;
    }
    wdgid = ApplyWatchDogID();              /* apply watch dog */
}

static void ErrTask(void *pd)
{
    INT32U curtag;

    pd = pd;
#if  DEBUG_UARTNo_SYSTEM <=1  
    PrintFromUART(DEBUG_UARTNo_SYSTEM, "启动ErrTask......\n");
#endif
    InitErrTask();                          /* initialize err task */

    for(;;) {
        ClearWatchdog();
	if (ECB.nUsed != ECB.nBackup  ||  ECB.nUsed > MAX_DIAGSUBS) ErrExit(ERR_ERRTASK_MEM);
        if ((curtag = ECB.CurTag++) >= ECB.nUsed) {
            curtag = 0;
            ECB.CurTag = 0;
        }
        if (ECB.DiagProc[curtag] != ECB.BackProc[curtag]) {
            ErrExit(ERR_ERRTASK_MEM);
        } else if (ECB.DiagProc[curtag] != 0) {
            ECB.DiagProc[curtag]();
        }
        ResetWatchDog(wdgid);               /* clear watch dog */
        OSTimeDly(1);
    }
}

void CreateErrTask(void)
{
    OSTaskCreate(ErrTask, (void *)0, &ErrTaskStack[STACK_ERRTASK-1], PRIO_ERRTASK);
}

INT8U GetErrRecord(INT8U *ptr)
{
#if EN_RESETREC > 0
    INT8U i, pos, len;

    *ptr++ = ResetRec.nReset;
    *ptr++ = ResetRec.nExtWDT;
    *ptr++ = ResetRec.nIntWDT;
    *ptr++ = ResetRec.nException;
    len = 4;
    for (i = 0, pos = ResetRec.RecPos; i < ResetRec.nException; i++, pos++) {
        if (i >= MAX_ERRRECORD) break;
        *ptr++ = ResetRec.ErrRecord[pos] >> 8;
        *ptr++ = ResetRec.ErrRecord[pos];
        len += 2;
    }
    return len;
#else
    ptr = ptr;
    return 0;
#endif
}

void ClearErrRecord(void)
{
#if EN_RESETREC > 0
    ClearPubPara(RESETREC_);
#endif
}

void ErrExit(INT32U ErrID)
{
    INT32U  i;
    BOOLEAN redlighted, greenlighted;


    ErrID = ErrID;

#if EN_RESETREC > 0
    ResetRec.nException++;
    if (ResetRec.RecPos >= MAX_ERRRECORD) ResetRec.RecPos = 0;
    ResetRec.ErrRecord[ResetRec.RecPos++] = ErrID;
    if (ResetRec.RecPos >= MAX_ERRRECORD) ResetRec.RecPos = 0;
    StorePubPara(RESETREC_);
#endif
    
   OS_ENTER_CRITICAL();
    Printu("===ErrCode:%x======\r\n",ErrID);
	while(1) ;
   OS_EXIT_CRITICAL();

    OS_ENTER_CRITICAL();                    /* disable all event interrupt */
    
    InitUART(DEBUG_UARTNo_ERR, DEBUG_UART_BAUD);  /* initialize ERR UART */
    
    redlighted   = FALSE;
    greenlighted = TRUE;
    Pulldown_LEDRED();
    Pullup_LEDGREEN();
    for(;;) {
        if (redlighted) {
            redlighted   = FALSE;
            Pulldown_LEDRED();
        } else {
            redlighted   = TRUE;
            Pullup_LEDRED();
        }
        if (greenlighted) {
            greenlighted = FALSE;
            Pulldown_LEDGREEN();
        } else {
            greenlighted = TRUE;
            Pullup_LEDGREEN();
        }
        SendFromUART_HEX(DEBUG_UARTNo_ERR, 0xaf);
        SendFromUART_HEX(DEBUG_UARTNo_ERR, ErrID >> 8);
        SendFromUART_HEX(DEBUG_UARTNo_ERR, ErrID);
        for (i = 0; i < 0xffff; i++) {
            ClearWatchdog();            /* clear watch dog */
        }
    }

}

void InitErrUART(void)
{
    uarts_init(DEBUG_UARTNo_ERR, DEBUG_UART_BAUD); /* initialize ERR UART */
}

void ErrPrint(char *errinf)
{
    OS_ENTER_CRITICAL();                /* disable all event interrupt */
    PrintFromUART(DEBUG_UARTNo_ERR, errinf);
}

BOOLEAN InstallDiagProc(void (*fp)(void))
{
    if (ECB.nUsed >= MAX_DIAGSUBS || fp == 0) {
        ErrExit(ERR_ERRTASK_INSTALL);
        return FALSE;
    }

    ECB.DiagProc[ECB.nUsed++] = ECB.BackProc[ECB.nBackup++] = fp;
    return TRUE;
}