T168_111\system\Task：Task.c

/******************************************************************************
 *                                                                            *
 *                         M O D U L E   D E F I N E                          *
 *                                                                            *
 ******************************************************************************/

#define TASK_C

/******************************************************************************
 *                                                                            *
 *        C O M P I L E R   D E F I N E D   I N C L U D E   F I L E S         *
 *                                                                            *
 ******************************************************************************/

#include <string.h>

/******************************************************************************
 *                                                                            *
 *            U S E R   D E F I N E D   I N C L U D E   F I L E S             *
 *                                                                            *
 ******************************************************************************/

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "Task.h"

/******************************************************************************
 *                                                                            *
 *                         L O C A L   D E F I N E S                          *
 *                                                                            *
 ******************************************************************************/

/******************************************************************************
 *                                                                            *
 *                        L O C A L   T Y P E D E F S                         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *             L O C A L   F U N C T I O N   P R O T O T Y P E S              *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *    L O C A L   I N I T I A L I Z E D   D A T A   D E F I N I T I O N S     *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *    L O C A L   U N I T I A L I Z E D   D A T A   D E F I N I T I O N S     *
 *                                                                            *
 ******************************************************************************/

STATIC VOID (*TaskFunc)(VOID *);
STATIC VOID *TaskArg;
STATIC INT TaskStack;

#if defined(NUTOS)
/*!
 * \brief Task thread.
 */
THREAD(NutTask, arg)
{
    VOID (*func)(VOID *);
    INT serial = 0;
    CHAR name[9];

    // ch_20211229
#ifdef DEBUG_NUTOS
    STATIC UCHAR execDone = 0;    
#endif    

    NutThreadSetPriority(NUT_THREAD_TASK_PRIORITY);

    for (;;)
    {
        func = TaskFunc;
        TaskFunc = _NULL;
        if ( func )
        {
            // ch_20211229
#ifdef DEBUG_NUTOS        
            execDone = 0;
#endif            
            sprintf(name, "task%04d", (serial++ % 10000));
            // ch_20211229
#ifdef DEBUG_NUTOS            
sysprintf("NutTask : name : %s\n", name);
#endif
            NutThreadCreate(name, func, TaskArg, TaskStack);
        }
        // ch_20211229
#ifdef DEBUG_NUTOS
        else if (!execDone)
        {
            execDone = 1;
            sysprintf("NutTask : func()==NULL\n");
            
        }
#endif        
        NutSleep(10);
    }
}
#endif

/******************************************************************************
 *
 * Function:
 *    TaskStart
 *
 * Description: 
 *    
 *
 * Input:
 *    None
 *
 * Output:
 *    None.
 *
 ******************************************************************************/
VOID TaskStart(VOID)
{
    TaskFunc = _NULL;

#if defined(NUTOS)
    NutThreadCreate("task", NutTask, 0, NUT_THREAD_TASK_STACK);
#elif defined(SH7040)
    TASK_IPR = TASK_PRIORITY;
#endif
}

/******************************************************************************
 *
 * Function:
 *    TaskCreate
 *
 * Description: 
 *    
 *
 * Input:
 *    None
 *
 * Output:
 *    None.
 *
 ******************************************************************************/
VOID TaskCreate(VOID (*func)(VOID *), VOID *arg, INT stack)
{
#if defined(NUTOS)
    INT imask;

    imask = DisableInterrupt(TASK_IMASK);

    if ( TaskFunc == _NULL )
    {
        TaskFunc  = func;
        TaskArg   = arg;
        TaskStack = stack;
    }
    EnableInterrupt(imask);

// ch_20211229
#ifdef DEBUG_NUTOS    
if (TaskFunc)
    sysprintf("Create TASK for stack_%d...\n", stack);
#endif        

#elif defined(SH7040)
    BOOL CntStart;
    USHORT time;
    INT imask;

    imask = DisableInterrupt(TASK_IMASK);

    if ( TaskFunc == _NULL )
    {
        CntStart = TASK_CNT_START;
        TASK_CNT_START = 0;

        time = TASK_TIME;
        TASK_TIME = 0xFFFF;

        TaskFunc = func;
        TaskArg = arg;

        TASK_IE = 1;
        while ( !TASK_FLAG )
            TASK_CNT_START = 1;

        TASK_CNT_START = 0;
        TASK_TIME = time;

        TASK_CNT_START = CntStart;
    }

    EnableInterrupt(imask);

#endif
}

VOID TaskExit(VOID)
{
#ifdef DEBUG_NUTOS
//    sysprintf("Exit TASK!\n"); // ch_20211209
//    sysprintf("Memory %u free\n", (unsigned int)NutHeapAvailable()); // ch_20211220
sysprintf("Exit TASK, runningThread->td_name : %s\n", runningThread->td_name); // ch_20211223
#endif

    NutThreadExit();        
}

/******************************************************************************
 *
 * Function:
 *    TaskISR
 *
 * Description: 
 *    
 *
 * Input:
 *    None
 *
 * Output:
 *    None.
 *
 ******************************************************************************/
VOID TaskISR(VOID)
{
#if defined(SH7040)
    VOID (*func)(VOID *);

    TASK_IE = 0;
    TASK_FLAG = 0;

    func = TaskFunc;
    TaskFunc = _NULL;
    if ( func )
    {
        EnableInterrupt(0x0);
        func(TaskArg);
    }
#endif
}

Task.h          。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef TASK_H

/******************************************************************************
 *                                                                            *
 *                         M O D U L E   D E F I N E                          *
 *                                                                            *
 ******************************************************************************/

#define TASK_H
    
/******************************************************************************
 *                                                                            *
 *        C O M P I L E R   D E F I N E D   I N C L U D E   F I L E S         *
 *                                                                            *
 ******************************************************************************/

/*!
 * Number of bytes of the stack space allocated for the new task.
 */

#define TASK_CAL_STACK                    (1024 * 32)
#define TASK_MENU_STACK                    (1024 * 32)
#define TASK_PRINT_STACK                (1024 * 32)
#define TASK_CUT_STACK                    (1024 * 16)
#define TASK_RESET_STACK                (1024 * 16)
#define TASK_VERIFY_STACK                (1024 * 16)
#define TASK_DURALABEL_STACK            (1024 * 8)
#define TASK_BT_STACK                            (1024 * 4)
#define TASK_PRBACK_STACK                     (1024 * 4)

#define TASK_SELFTEST_STACK                (1024 * 32) // ch_20211229

/******************************************************************************
 *                                                                            *
 *            U S E R   D E F I N E D   I N C L U D E   F I L E S             *
 *                                                                            *
 ******************************************************************************/

#ifdef __cplusplus
extern "C" {            /* Assume C declarations for C++ */
#endif    /* __cplusplus */

/******************************************************************************
 *                                                                            *
 *                        G L O B A L   D E F I N E S                         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *                 S T R U C T U R E   D E F I N I T I O N S                  *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *    G L O B A L   V A R I A B L E S   -   N O   I N I T I A L I Z E R S     *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *       G L O B A L   V A R I A B L E S   -   I N I T I A L I Z E R S        *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *                   F U N C T I O N   P R O T O T Y P E S                    *
 *                                                                            *
 ******************************************************************************/

VOID TaskStart(VOID);
VOID TaskCreate(VOID (*)(VOID *), VOID *, INT);
VOID TaskExit(VOID);
VOID TaskISR(VOID);

/*!
 * \brief Macro for swi entry definitions.
 */
#define TASK(fn, arg)            THREAD(fn ,arg)

#ifdef __cplusplus
}                       /* End of extern "C" { */
#endif    /* __cplusplus */

#endif