/******************************************************************************
* *
* 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