μT-Kernel 2.0 Specification
Prev		Next

Common Rules of μT-Kernel

Data Types

General Data Types

typedef signed char          B;     /* signed 8-bit integer */
typedef signed short         H;     /* signed 16-bit integer */
typedef signed long          W;     /* signed 32-bit integer */
typedef signed long long     D;     /* signed 64-bit integer */
typedef unsigned char       UB;     /* unsigned 8-bit integer */
typedef unsigned short      UH;     /* unsigned 16-bit integer */
typedef unsigned long       UW;     /* unsigned 32-bit integer */
typedef unsigned long long  UD;     /* unsigned 64-bit integer */

typedef char                VB;     /* 8-bit data without an intended type */
typedef short               VH;     /* 16-bit data without an intended type */
typedef long                VW;     /* 32-bit data without an intended type */
typedef long long           VD;     /* 64-bit data without an intended type */
typedef void                *VP;    /* pointer to data without an intended type */

typedef volatile B          _B;     /* volatile declaration */
typedef volatile H          _H;
typedef volatile W          _W;
typedef volatile D          _D;
typedef volatile UB         _UB;
typedef volatile UH         _UH;
typedef volatile UW         _UW;
typedef volatile UD         _UD;

typedef signed int          INT;    /* signed integer of processor bit width */
typedef unsigned int        UINT;   /* unsigned integer of processor bit width */

typedef INT                 SZ;     /* Generic SiZe */

typedef INT                 ID;     /* general ID */
typedef W                   MSEC;   /* general time (in milliseconds) */

typedef void            (*FP)();    /* general function address */
typedef INT             (*FUNCP)(); /* general function address */

#define LOCAL           static      /* local symbol definition */
#define EXPORT                      /* global symbol definition */
#define IMPORT          extern      /* global symbol reference */

/*
 * Boolean values
 *      TRUE = 1 is defined, but any value other than 0 is logically TRUE.
 *      Do NOT use as in if ( bool == TRUE )
 *      use as in if ( bool ) 
 */
typedef INT             BOOL;
#define TRUE            1           /* true */
#define FALSE           0           /* false */

/*
 * TRON character codes
 */
typedef UH              TC;         /* TRON character codes */
#define TNULL           ((TC)0)     /* TRON code string termination */

VB, VH, VW, and VD differ from B, H, W, and D in that the former mean only the bit width is known, not the contents of the data type, whereas the latter clearly indicate integer type.
BOOL defines TRUE as 1, but any value other than 0 is also true. For this reason, TRUE must not be used as left-hand or right-hand value of comparison operators (== and !=) for deciding whether the value is true or false. That is, conditional operations like "if (boolean value == TRUE)" should be avoided, and instead use boolean value directly as condition, like "if (boolean value)".
The definition of VP is preserved for compatibility with the legacy version of μT-Kernel. But we do not recommend the new use of it because of the complications with CONST specifier. Instead, we recommend the direct description as "void *".

Related Service Profile Items

The 64-bit data types, D, UD, and VD, are guaranteed to be usable when the following service profile item is set to be effective.

TK_HAS_DOUBLEWORD Support of 64-bit data types (D, UD, VD)

Additional Notes

Parameters such as stksz, wupcnt, and message size that clearly do not take negative values are also in principle signed integer (INT or W) data type. This is in keeping with the overall TRON project rule that integers should be treated as signed numbers as much as possible. As for the timeout (TMO tmout) parameter, its being a signed integer enables the use of TMO_FEVR(＝ -1) having special meaning. Parameters with unsigned data type are those treated as bit patterns (object attribute, event flag, etc.)

	Difference from T-Kernel 2.0
	A new scalar type to represent size, SZ type, has been introduced in μT-Kernel 2.0 'SZ' stands for SiZe. 'SZ' shall be defined as signed scalar type that has enough bit width to represent the required memory address ranges. In the previous example, SZ is defined as INT. However, on 16-bit CPU, if memory space larger than 32KB space is to be handled, a definition that uses W which has larger bit width is appropriate.

Difference from T-Kernel 2.0

A new scalar type to represent size, SZ type, has been introduced in μT-Kernel 2.0 'SZ' stands for SiZe. 'SZ' shall be defined as signed scalar type that has enough bit width to represent the required memory address ranges. In the previous example, SZ is defined as INT. However, on 16-bit CPU, if memory space larger than 32KB space is to be handled, a definition that uses W which has larger bit width is appropriate.

Difference from μT-Kernel 1.0

	Difference from μT-Kernel 1.0
	As stated previously, μT-Kernel 2.0 has introduced new SZ data type. The following changes introduced in T-Kernel 2.0 specification have been adopted in this specification, too. 64-bit D and UD are added. 'D' means Double integer. "signed" is added to the declaration of a signed integer. int is changed to long to clearly indicate that W and UW are 32-bit. μT-Kernel 1.0 used VP as the data type of parameters such as `exinf`. μT-Kernel 2.0 recommends the direct description of "void *" instead of using VP in general to handle the use of CONST qualifier better. μT-Kernel 2.0 preserves the definition of VP for compatibility with the legacy version of μT-Kernel. But we do not recommend the new use of VP.

As stated previously, μT-Kernel 2.0 has introduced new SZ data type.

The following changes introduced in T-Kernel 2.0 specification have been adopted in this specification, too.

64-bit D and UD are added. 'D' means Double integer. "signed" is added to the declaration of a signed integer. int is changed to long to clearly indicate that W and UW are 32-bit.
μT-Kernel 1.0 used VP as the data type of parameters such as exinf. μT-Kernel 2.0 recommends the direct description of "void *" instead of using VP in general to handle the use of CONST qualifier better. μT-Kernel 2.0 preserves the definition of VP for compatibility with the legacy version of μT-Kernel. But we do not recommend the new use of VP.

Other Defined Data Types

The following names are used for other data types that appear frequently or have special meaning, in order to make The parameter meaning clear.

typedef INT             FN;             /* Function Codes */
typedef INT             RNO;            /* rendezvous number */
typedef UW              ATR;            /* Object/handler attributes */
typedef INT             ER;             /* Error Code */
typedef INT             PRI;            /* Priority */
typedef W               TMO;            /* Timeout specification in milliseconds */
typedef D               TMO_U;          /* Timeout specification in microseconds with 64-bit integer */
typedef UW              RELTIM;         /* Relative time in milliseconds */
typedef UD              RELTIM_U;       /* Relative time in microseconds with 64-bit integer */

typedef struct systim {                 /* System time in milliseconds */
        W       hi;                     /* High 32 bits */
        UW      lo;                     /* Low 32 bits */
} SYSTIM;

typedef D               SYSTIM_U;       /* System time in microseconds with 64-bit integer */

/*
 * Common constants
 */
#define NULL            0               /* Null pointer */
#define TA_NULL         0               /* No special attributes indicated */
#define TMO_POL         0               /* Polling */
#define TMO_FEVR        (-1)            /* Eternal wait */

A data type that combines two or more data types is represented by its main data type. For example, the value returned by tk_cre_tsk can be a task ID or error code, but since it is mainly a task ID, the data type is ID.

Related Service Profile Items

TMO_U, RELTIM_U, and SYSTEM_U dealing with date and relative time in microsecond resolution are guaranteed to be usable only when the following service profile items are set to be effective.

TK_SUPPORT_USEC Support instructions that can handle time in microsecond resolutions

	Difference from μT-Kernel 1.0
	Following the lead of T-Kernel 2.0 specification, TMO_U that represents timeout specification in microseconds with 64-bit integer, RELTIM_U that represents relative time in microseconds with 64-bit integer, and SYSTIM_U that represents system time in microseconds with 64-bit integer are added. RELTIM_U is unsigned corresponding to RELTIM, and SYSTIM_U is signed corresponding to SYSTIM. Though SYSTIM is a structure consisting of two 32-bit members, SYSTIM_U is a plain 64-bit integer rather than a structure to directly take advantage of the convenience of a 64-bit data.

Difference from μT-Kernel 1.0

Following the lead of T-Kernel 2.0 specification, TMO_U that represents timeout specification in microseconds with 64-bit integer, RELTIM_U that represents relative time in microseconds with 64-bit integer, and SYSTIM_U that represents system time in microseconds with 64-bit integer are added. RELTIM_U is unsigned corresponding to RELTIM, and SYSTIM_U is signed corresponding to SYSTIM. Though SYSTIM is a structure consisting of two 32-bit members, SYSTIM_U is a plain 64-bit integer rather than a structure to directly take advantage of the convenience of a 64-bit data.

	Additional Notes
	The policy is to append "_u" (u means μ) or "_U" at the end for parameters and data types representing microsecond (μsec), or append "_d" (d means double integer) or "_D" at the end for other parameters and data types representing 64-bit integer. TMO_U, RELTIM_U, and SYSTIM_U are data type names complying to this policy.