SAU0EN  = 1U;										// 1 = ｼﾘｱﾙｱﾚｲﾕﾆｯﾄ0 ｸﾛｯｸ供給開始
	SAU1EN  = 1U;										// 1 = ｼﾘｱﾙｱﾚｲﾕﾆｯﾄ1 ｸﾛｯｸ供給開始
	NOP();
	NOP();
	NOP();
	NOP();

	SPS0    = (uint16_t)( 0x0050U | 0x0002U );			// ｼﾘｱﾙｸﾛｯｸ分周 CK00 - fCLK/4  8MHz
														//              CK01 - fCLK/32 1MHz
	SPS1    = (uint16_t)( 0x0050U | 0x0002U );			// ｼﾘｱﾙｸﾛｯｸ分周 CK10 - fCLK/4  8MHz
														//              CK11 - fCLK/32 1MHz

	ST0    |= (uint16_t)( 0x0002U | 0x0001U );			// UART0 送受信停止
	ST0    |= (uint16_t)( 0x0008U | 0x0004U );			// UAR10 送受信停止
	ST1    |= (uint16_t)( 0x0002U | 0x0001U );			// UART2 送受信停止

	/* ---< UART0(割込無効) >--- */
	STMK0   = 1U;										// UART0 送信完了割込みﾏｽｸ(INTST0)
	STIF0   = 0U;										// UART0 送信完了割込み要求ﾌﾗｸﾞｸﾘｱ
	SRMK0   = 1U;										// UART0 受信完了割込みﾏｽｸ(INTSR0)
	SRIF0   = 0U;										// UART0 受信完了割込み要求ﾌﾗｸﾞｸﾘｱ
	SREMK0  = 1U;										// UART0 受信ｴﾗｰ割込みﾏｽｸ(INTSRE0)
	SREIF0  = 0U;										// UART0 受信ｴﾗｰ割込み要求ﾌﾗｸﾞｸﾘｱ

	/* ---< UART0(割込ﾚﾍﾞﾙ) >--- */
	STPR10  = 0U;										// UART0 送信割込み優先1
	STPR00  = 1U;
	SRPR10  = 0U;										// UART0 受信割込み優先1
	SRPR00  = 1U;
	SREPR10 = 0U;										// UART0 受信ｴﾗｰ割込み優先1
	SREPR00 = 1U;

	/* ---< ｼﾘｱﾙ通信(TxD0) >--- */
	SMR00 = (uint16_t)(0x0020U|0x0002U|0x0001U);		// ｼﾘｱﾙﾓｰﾄﾞ
	SCR00 = (uint16_t)(0x8000U|0x0080U|0x0010U|0x0004U|0x0003U);// ｼﾘｱﾙ通信動作設定									
	SDR00 = 0x4400U;									// b15-b8	転送ｸﾛｯｸ
	SOE0 |= BIT0;										// 出力Hi

	/* ---< ｼﾘｱﾙ通信(RxD0) >--- */
	SIR01 = (uint16_t)( 0x0004U|0x0002U|0x0001U);		// ｴﾗｰﾌﾗｸﾞｸﾘｱ
	SMR01 = (uint16_t)( 0x0100U|0x0020U|0x0002U);		// ｼﾘｱﾙﾓｰﾄﾞ
	SCR01 = (uint16_t)(0x4000U|0x0400U|0x0080U|0x0010U|0x0007U);// ｼﾘｱﾙ通信動作設定
	SDR01 = 0x4400U;									// b15-b8	転送ｸﾛｯｸ
	NFEN0 |= BIT0;										// RxD0 ﾉｲｽﾞﾌｨﾙﾀ有効

#define C_SIZE_COM_BUF 40								// 割込内送受信ﾊﾞｯﾌｧｻｲｽﾞ
#define M_RING_INC(a,b) (((b)<=(a+1)) ? (a=0):(a+=1))	// ﾏｸﾛ定義

//************************
//         UART
//    割込内送受信ﾊﾞｯﾌｧ
//************************
typedef struct
{
	uint16_t		WriteIdx;							// 書込みｲﾝﾃﾞｯｸｽ
	uint16_t		ReadIdx;							// 読込みｲﾝﾃﾞｯｸｽ
	uint8_t			Buf[ C_SIZE_COM_BUF ];				// ﾊﾞｯﾌｧ
} T_COM_BUFFER;

static volatile T_COM_BUFFER _gSndBuf = { 0 };			// 割込内送信ﾊﾞｯﾌｧ

//************************************************************************************************
//	機能概要	：送信ﾊﾞｯﾌｧへ指定ﾊﾞｲﾄｾｯﾄして送信する
//	引数	：Data  送信ﾃﾞｰﾀ
//			：Count ﾃﾞｰﾀ数
//	戻り値	：TRUE(成功)、FALSE(ｴﾗｰ)
//	備考	：
//************************************************************************************************
static BOOL Send( uint8_t* Data, uint16_t Count )
{
	uint16_t index;

	for( index = 0; index < Count; index++ )			// ﾒｯｾｰｼﾞ・ﾃﾞｰﾀｾｯﾄ
	{
		if( FALSE == SetByte( Data[ index ] ))
		{
			return FALSE;
		}
	}
	return SendStart();									// 書込みｲﾝﾃﾞｯｸｽ更新と送信
}
//************************************************************************************************
//	機能概要	：送信ﾊﾞｯﾌｧへ1ﾊﾞｲﾄｾｯﾄする
//	引数	：Data ｾｯﾄするﾃﾞｰﾀ
//	戻り値	：TRUE(成功)、FALSE(ｴﾗｰ)
//	備考	：
//************************************************************************************************
static BOOL SetByte( uint8_t Data )
{
	STMK0  = 1U;										// 送信割込みﾏｽｸ

	/* ---< 送信ﾊﾞｯﾌｧへｾｯﾄ >--- */
	_gSndBuf.Buf[ _gSndBuf.WriteIdx ] = Data;			// ﾃﾞｰﾀ格納	
	M_RING_INC(_gSndBuf.WriteIdx,C_SIZE_COM_BUF);		// 書込みｲﾝﾃﾞｯｸｽ更新
	if( _gSndBuf.ReadIdx == _gSndBuf.WriteIdx )		// 読込みｲﾝﾃﾞｯｸｽに追いついた
	{
		return FALSE;
	}

	STMK0 = 0U;											// 送信割込み許可
	return TRUE;
}
//************************************************************************************************
//	機能概要	：送信開始
//	引数	：なし
//	戻り値	：TRUE(成功)、FALSE(ｴﾗｰ)
//	備考	：送信割込動作中は自動で送信されるので起動の必要なし
//************************************************************************************************
static BOOL SendStart( void )
{
	STMK0  = 1U;										// 送信割込みﾏｽｸ

	/* ---< 送信ﾃﾞｰﾀなしの場合 >--- */
	if( _gSending == FALSE )
	{
		_gSending = TRUE;
		SMR00 |= 0x0001U;								// 転送前のﾊﾞｯﾌｧ空きでの割込み
		TXD0   = _gSndBuf.Buf[_gSndBuf.ReadIdx];		// ﾃﾞｰﾀをｾｯﾄ
		M_RING_INC(_gSndBuf.ReadIdx,C_SIZE_COM_BUF);	// 読込みｲﾝﾃﾞｯｸｽ更新
	}
	/* ---< 送信ﾃﾞｰﾀありの場合 >--- */
	else
	{
		;/* Do Nothing 割り込み処理内で書き込みｲﾝﾃﾞｯｸｽまで勝手に送信する */
	}
	STMK0 = 0U;											// 送信割込み許可
	return TRUE;
}

#define C_SIZE_COM_FRAME 22								// 送受信ﾌﾚｰﾑの最大長

//*************************
//         UART
//     割込外送受信ﾌﾚｰﾑ
//*************************
typedef struct
{
	uint16_t		Count;								// 送受信ﾊﾞｲﾄ数
	uint8_t			Data[ C_SIZE_COM_FRAME ];			// 送受信ﾃﾞｰﾀ
} T_COM_FRAME;

static T_COM_FRAME _gRcvFrame = { 0 };					// 割込外受信ﾌﾚｰﾑ

void main( void )
{
	_gRcvFrame.Count = 0;								// 割込外受信ﾌﾚｰﾑの受信ｸﾘｱ
	while( 1 )
	{
		if( TRUE == RcvFrame())
		{
			// C_SIZE_COM_FRAME 分のﾃﾞｰﾀを受信完了
			// ここに受信処理を入れる
			_gRcvFrame.Count = 0;						// 割込外受信ﾌﾚｰﾑの受信ｸﾘｱ
		}
	}
}
BOOL RcvFrame( void )
{
	uint8_t rcvData;									// 1ﾊﾞｲﾄ受信ﾃﾞｰﾀ

	/* ---< 受信ﾃﾞｰﾀなし >--- */
	if( _gRcvBuf.ReadIdx == _gRcvBuf.WriteIdx )
	{
		return FALSE;
	}

	/* ---< 受信ﾃﾞｰﾀあり >--- */
	rcvData = _gRcvBuf.Buf[ _gRcvBuf.ReadIdx ];		// ﾃﾞｰﾀ取得
	M_RING_INC( _gRcvBuf.ReadIdx, C_SIZE_COM_BUF );	// 読込ｲﾝﾃﾞｯｸｽ更新

	_gRcvFrame.Data[ _gRcvFrame.Count++ ] = rcvData;	// ﾃﾞｰﾀｾｯﾄ

	if( _gRcvFrame.Count >= C_SIZE_COM_FRAME )
	{
		return TRUE;
	}
	return FALSE;
}

#pragma interrupt IntRcv_0( vect = INTSR0  )			// ﾍﾞｸﾀｰﾃﾌﾞﾙへの関数ｾｯﾄ
#pragma interrupt IntSnd_0( vect = INTST0  )
#pragma interrupt IntErr_0( vect = INTSRE0 )

//*************************
//         ﾋﾞｯﾄ
//*************************
#define BIT0 (0x00000001U)
#define BIT1 (0x00000002U)
#define BIT2 (0x00000004U)
#define BIT3 (0x00000008U)
#define BIT4 (0x00000010U)
#define BIT5 (0x00000020U)
#define BIT6 (0x00000040U)
#define BIT7 (0x00000080U)

//************************************************************************************************
//	機能概要：UART動作・割込み許可
//	引数	：なし
//	戻り値	：なし
//	備考	：
//************************************************************************************************
static void Start( void )
{
	SO0		|= BIT0;									// 出力Hiｾｯﾄ
	SOE0	|= BIT0;									// 出力許可
	SS0		|= ( BIT1 | BIT0 );							// 送受信開始
	STIF0	 = 0U; 										// 送信割込み要求ﾌﾗｸﾞｸﾘｱ
	SRIF0	 = 0U;										// 受信割込み要求ﾌﾗｸﾞｸﾘｱ
	SREIF0	 = 0U;										// 受信ｴﾗｰ割込み要求ﾌﾗｸﾞｸﾘｱ	
	STMK0	 = 0U;										// 送信割込み許可
	SRMK0	 = 0U;										// 受信割込み許可
	SREMK0	 = 0U;										// 受信ｴﾗｰ割込み許可
}
//************************************************************************************************
//	機能概要：UART停止・割込み禁止
//	引数	：なし
//	戻り値	：なし
//	備考	：
//************************************************************************************************
static void Stop( void )
{
	STMK0	 = 1U;										// 送信割込みﾏｽｸ
	SRMK0	 = 1U;										// 受信割込みﾏｽｸ
	SREMK0	 = 1U;										// 受信ｴﾗｰ割込みﾏｽｸ
	ST0		|= ( BIT1 | BIT0 );							// 送受信停止
	SOE0	&= ~(BIT0);									// 出力禁止
	STIF0	 = 0U;										// 送信割込み要求ﾌﾗｸﾞｸﾘｱ
	SRIF0	 = 0U;										// 受信割込み要求ﾌﾗｸﾞｸﾘｱ
	SREIF0	 = 0U;										// 受信ｴﾗｰ割込み要求ﾌﾗｸﾞｸﾘｱ
}
//************************************************************************************************
//	機能概要：受信割込みﾊﾝﾄﾞﾗ
//	引数	：なし
//	戻り値	：なし
//	備考	：
//************************************************************************************************/
static void __near IntRcv_0( void )
{
	volatile uint8_t rx_data = RXD0;					// ﾚｼﾞｽﾀ読込み
	_gRcvBuf.Buf[ _gRcvBuf.WriteIdx ] = rx_data;		// ﾃﾞｰﾀ格納
	M_RING_INC(_gRcvBuf.WriteIdx,C_SIZE_COM_BUF);		// 書込ｲﾝﾃﾞｯｸｽ更新
	if( _gRcvBuf.WriteIdx == _gRcvBuf.ReadIdx )		// 書込が読込に追いついた
	{
		return;
	}
}
//************************************************************************************************
//	機能概要：送信割込みﾊﾝﾄﾞﾗ
//	引数	：なし
//	戻り値	：なし
//	備考	：転送完了で_gSendingをFALSEにｾｯﾄ。転送完了でなけれな送信ﾊﾞｯﾌｧ内ﾃﾞｰﾀを送信し続ける
//************************************************************************************************
static void __near IntSnd_0( void )
{
	if( _gSndBuf.ReadIdx == _gSndBuf.WriteIdx )		// 読込みが書込みに追いついた場合
	{
		/* ---< 転送完了での割込み >--- */
		if(( SMR00 & 0x0001U ) == 0U )
		{
			_gSending = FALSE;							// 転送完了
		}
		/* ---< 転送前のﾊﾞｯﾌｧ空きでの割込み >--- */
		else
		{
			SMR00 &= ~(0x0001U);						// 転送完了割込みｾｯﾄ
		}
	}
	else
	{
		SMR00 |= 0x0001U;								// 転送前のﾊﾞｯﾌｧ空きでの割込み
		TXD0   = _gSndBuf.Buf[ _gSndBuf.ReadIdx ];		// ﾚｼﾞｽﾀ書込み
		M_RING_INC(_gSndBuf.ReadIdx,C_SIZE_COM_BUF);	// 読込みｲﾝﾃﾞｯｸｽ更新
	}
}
//************************************************************************************************
//	機能概要：受信ｴﾗｰ割込み
//	引数	：なし
//	戻り値	：なし
//	備考	：
//************************************************************************************************
static void __near IntErr_0( void )
{
	volatile uint8_t err;
	volatile uint8_t rx = 0;
	
	rx   |= RXD0;										// ﾀﾞﾐｰﾘｰﾄﾞ
	err   = (uint8_t)( SSR01 & 0x0007U );				// ｴﾗｰ取得(ﾌﾚｰﾐﾝｸﾞ、ﾊﾟﾘﾃｨ、ｵｰﾊﾞｰﾗﾝ)
	SIR01 = (uint16_t)err;								// 同ｴﾗｰｸﾘｱ
	// ここでｴﾗｰ処理追加
}