/* System	: 二足歩行ロボット(walk)
* File		: sequence.c
* function	: 歩行動作シーケンス制御
* Version	: 1.0
* Date		: 2019/5/7
* CPU		: RL78/G12 ROM:16KB RAM:1.5KB fCLK:24MHz
* IDE		: CS+ for CC V6.01.00 [01 Dec 2017]
* Programmer	: Hajime Sugiyama
* Note		: */

#include "unit_sequence_data.h"
#include "unit_sequence.h"
#include "sequence.h"

/* 公開変数 */
enum WALKINGORDEREVENT walking_order_event = NO_EVENT;	/* 歩行動作指示イベント */
enum WALKINGORDEREVENT walking_order_event_memory = NO_EVENT;/* 歩行動作指示イベント記憶 */

__f_s f_s = {1,0};					/* 歩行動作シーケンス完了フラグ */

static int s16_counter =0;				/* 歩数・停止時間 */
static int s16_count_target = STOP_COUNTING;		/* 目標歩数・停止時間 */
int s16_count_target_request = STOP_COUNTING;		/* 要求目標歩数・停止時間 */

/* 歩行状態 */
enum WALKINGSTATE {
	STANDBY = 0,					 /* 待機 */
	FORWARD,					 /* 前進 */
	ROTATERIGHT,					 /* 右回転 */
	BACKWARD,					 /* 後退 */
	ROTATELEFT,					 /* 左回転 */
	DANCE						 /* ダンス */
};
static enum WALKINGSTATE walking_state = STANDBY;	/* 歩行状態変数 */

/* 前進の歩行ステップの状態 */
enum FORWARDSTATE {
	FORWARD_FIRSTSTEP_R = 0,			/* 前進開始（右足前へ） */
	FORWARD_FIRSTSTEP_L,				/* 前進開始（左足前へ） */
	FORWARD_L,					/* 前進継続（左足前へ） */
	FORWARD_R,					/* 前進継続（右足前へ） */
	FORWARD_BREAK_L,				/* 前進終了（左足揃え） */
	FORWARD_BREAK_R					/* 前進終了（右足揃え） */
};
static enum FORWARDSTATE forward_state = FORWARD_FIRSTSTEP_R;/* 歩行：前進状態変数	  */

/* 右回転の歩行ステップの状態 */
enum ROTATERSTATE {
	ROTATER_FIRSTSTEP_L = 0,			/* 右回転開始（左足上げ） */
	ROTATER_FIRSTSTEP_R,				/* 右回転開始（右足上げ） */
	ROTATER_R,					/* 右回転継続（右足上げ） */
	ROTATER_L,					/* 右回転継続（左足上げ） */
	ROTATER_BREAK_L,				/* 右回転終了（左足揃え） */
	ROTATER_BREAK_R					/* 右回転終了（右足揃え） */
};
static enum ROTATERSTATE rotater_state = ROTATER_FIRSTSTEP_R;/* 歩行：右回転状態変数 */

/* 後退の歩行ステップの状態 */
enum BACKWARDSTATE {
	BACKWARD_FIRSTSTEP_R = 0,			/* 後退開始（右足後へ） */
	BACKWARD_FIRSTSTEP_L,				/* 後退開始（左足後へ） */
	BACKWARD_L,					/* 後退継続（左足後へ） */
	BACKWARD_R,					/* 後退継続（右足後へ） */
	BACKWARD_BREAK_L,				/* 後退終了（左足揃え） */
	BACKWARD_BREAK_R				/* 後退終了（右足揃え） */
};
static enum BACKWARDSTATE backward_state = BACKWARD_FIRSTSTEP_R;/* 歩行：前進状態変数	  */

/* 左回転の歩行ステップの状態 */
enum ROTATELSTATE {
	ROTATEL_FIRSTSTEP_L = 0,			/* 左回転開始（左足上げ） */
	ROTATEL_FIRSTSTEP_R,				/* 左回転開始（右足上げ） */
	ROTATEL_R,					/* 左回転継続（右足上げ） */
	ROTATEL_L,					/* 左回転継続（左足上げ） */
	ROTATEL_BREAK_R,				/* 左回転終了（右足揃え） */
	ROTATEL_BREAK_L					/* 左回転終了（左足揃え） */
};
static enum ROTATELSTATE rotatel_state = ROTATEL_FIRSTSTEP_L;/* 歩行：左回転状態変数 */

static void execute_standby(void);			/* 停止状態制御 */
static void execute_forward(void);			/* 前進状態制御 */
static void execute_rotateright(void);			/* 右回転状態制御 */
static void execute_backward(void);			/* 後退状態制御 */
static void execute_rotateleft(void);			/* 左回転状態制御 */
static void execute_dance(void);			/* ダンス状態制御 */

static void forward_nextstep_is_r_exe(void);		/* 前進中次ステップ右足 */
static void forward_nextstep_is_l_exe(void);		/* 前進中次ステップ左足 */
static void rotater_nextstep_is_r_exe(void);		/* 右回転中次ステップ右足 */
static void rotater_nextstep_is_l_exe(void);		/* 右回転中次ステップ左足 */
static void backward_nextstep_is_r_exe(void);		/* 後退中次ステップ右足 */
static void backward_nextstep_is_l_exe(void);		/* 後退中次ステップ左足 */
static void rotatel_nextstep_is_r_exe(void);		/* 左回転中次ステップ右足 */
static void rotatel_nextstep_is_l_exe(void);		/* 左回転中次ステップ左足 */

/* 歩行動作シーケンス制御処理ユニット */
void sequence_control(void){
	switch(walking_state){				/* 歩行状態 */
		case STANDBY:				/* 歩行状態：停止 */
			execute_standby();		/* 停止状態制御 */
			break;
		case FORWARD:				/* 歩行状態：前進 */
			if(f_us.complete == 1U){	/* 単位ステップシーケンス完了 */
				f_us.complete = 0U;
				execute_forward();	/* 前進状態制御 */
			}
			break;
		case ROTATERIGHT:			/* 歩行状態：右回転 */
			if(f_us.complete == 1){		/* 単位ステップシーケンス完了 */
				f_us.complete = 0;
				execute_rotateright();	/* 右回転状態制御 */
			}
			break;
		case BACKWARD:				/* 歩行状態：後退 */
			if(f_us.complete == 1){		/* 単位ステップシーケンス完了 */
				f_us.complete = 0;
				execute_backward();	/* 後退状態制御 */
			}
			break;
		case ROTATELEFT:			/* 歩行状態：左回転 */
			if(f_us.complete == 1){		/* 単位ステップシーケンス完了 */
				f_us.complete = 0;
				execute_rotateleft();	/* 左回転状態制御 */
			}
			break;
		case DANCE:				/* 歩行状態：ダンス */
			if(f_us.complete == 1){		/* 単位ステップシーケンス完了 */
				f_us.complete = 0;
				execute_dance();	/* ダンス状態制御 */
			}
			break;
	}
}

/* 停止状態制御処理ユニット */
static void execute_standby(void){
	/* 設定回数 × 0.5 秒 停止 */
	if(s16_count_target != STOP_COUNTING){
		/* 歩数カウントを利用する場合（歩行動作順序実行時） */
		if(s16_counter < s16_count_target){	/* 停止時間カウントアップ */
			s16_counter++;
			if(s16_counter == s16_count_target){/* 停止時間到達 */
				f_s.complete = 1U;	/* 歩行ステップシーケンス完了（停止時間） */
			}
		}
	}else{
		/* 歩数カウントを利用しない場合（シーケンスプログラム実行時以外） */
		/* 記憶した歩行動作指示があればイベント発行 */
		if(walking_order_event_memory != NO_EVENT){
			walking_order_event = walking_order_event_memory;
			walking_order_event_memory = NO_EVENT;
		}
	}
	switch(walking_order_event){			/* 歩行動作指示イベント */
		case FORWARD_EVENT:			/* 前進 */
			/* 前進開始（右足前）へ */
			sequence_shift_preprocess(u16_forward_firststep_right,c_forward_firststep_right);/* (BD1,2,5) */
			walking_state = FORWARD;
			forward_state = FORWARD_FIRSTSTEP_R;
			s16_count_target = s16_count_target_request;
			s16_counter = 0;
			break;
		case RIGHT_EVENT:			/* 右回転 */
			/* 右回転開始（右足上げ）へ */
			sequence_shift_preprocess(u16_rotate_right_firststep_right,c_rotate_right_firststep_right);/* (BD1,2,5) */
			walking_state = ROTATERIGHT;
			rotater_state = ROTATER_FIRSTSTEP_R;
			s16_count_target = s16_count_target_request;
			s16_counter = 0;
			break;
		case BACKWARD_EVENT:			/* 後退 */
			/* 後退開始（右足後へ） */
			sequence_shift_preprocess(u16_backward_firststep_right,c_backward_firststep_right);/* (BD1,2,5) */
			walking_state = BACKWARD;
			backward_state = BACKWARD_FIRSTSTEP_R;
			s16_count_target = s16_count_target_request;
			s16_counter = 0;
			break;
		case LEFT_EVENT:			/* 左回転 */
			/* 左回転開始（左足上げへ） */
			sequence_shift_preprocess(u16_rotate_left_firststep_left,c_rotate_left_firststep_left);/* (BD1,2,5) */
			walking_state = ROTATELEFT;
			rotatel_state = ROTATEL_FIRSTSTEP_L;
			s16_count_target = s16_count_target_request;
			s16_counter = 0;
			break;
		case DANCE_EVENT:			/* ダンス */
			sequence_shift_preprocess(u16_dance,c_dance);/* (BD1,2,5) */
			walking_state = DANCE;
			s16_count_target = s16_count_target_request;
			s16_counter = 0;
			break;
		case STOP_EVENT:			/* 停止 */
			s16_count_target = s16_count_target_request;
			s16_counter = 0;
			if(s16_count_target == STOP_COUNTING){
				/* 歩数カウントを利用しない場合（歩行動作順序実行時以外）は */
				/* 歩行動作をせずに歩行動作シーケンス完了フラグを立てる */
				f_s.complete =1U;
			}
			break;
		case NO_EVENT:
			/* 以下同処理のためbreak省略 */
		default:
			break;
	}
	walking_order_event = NO_EVENT;			/* 歩行動作指示イベント消去 */
}

/* 前進状態制御処理ユニット */
static void execute_forward(void){
	switch(forward_state){
		case FORWARD_FIRSTSTEP_R:		/* 前進開始（右足前へ） */
			forward_nextstep_is_l_exe();
			break;
		case FORWARD_FIRSTSTEP_L:		/* 前進開始（左足前へ） */
			forward_nextstep_is_r_exe();
			break;
		case FORWARD_L:				/* 前進継続（左足前へ） */
			forward_nextstep_is_r_exe();
			break;
		case FORWARD_R:				/* 前進継続（右足前へ） */
			forward_nextstep_is_l_exe();
			break;
		case FORWARD_BREAK_L:			/* 前進終了（左足揃え） */
			/* 右足停止(FORWARD_BREAK_R)と同処理のためbreak省略 */
		case FORWARD_BREAK_R:			/* 前進終了（右足揃え） */
			if(s16_count_target != STOP_COUNTING){
				f_s.complete = 1U;	/* 歩行動作シーケンス完了 */
			}else if((walking_order_event != NO_EVENT) && (walking_order_event != FORWARD_EVENT)){
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
			}
			walking_state = STANDBY;	/* 待機（ホームポジション）へ */
			break;
	}
}

/* 前進中次ステップ右足制御処理ユニット */
static void forward_nextstep_is_r_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case RIGHT_EVENT:
			case BACKWARD_EVENT:
			case LEFT_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、前進終了（右足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_forward_break_right,c_forward_break_right);/* (BD1,2,5) */
				walking_state = FORWARD;
				forward_state = FORWARD_BREAK_R;
				break;
			default:
				/* 前進継続（右足前へ）へ */
				sequence_shift_preprocess(u16_forward_right,c_forward_right);/* (BD1,2,5) */
				walking_state = FORWARD;
				forward_state = FORWARD_R;
				break;
		}
	}else if((++s16_counter >= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 歩行動作指示：停止イベント */
		/* 前進終了（右足揃え）へ */
		sequence_shift_preprocess(u16_forward_break_right,c_forward_break_right);/* (BD1,2,5) */
		walking_state = FORWARD;
		forward_state = FORWARD_BREAK_R;
	}else{
		/* 前進継続（右足前へ） */
		sequence_shift_preprocess(u16_forward_right,c_forward_right);/* (BD1,2,5) */
		walking_state = FORWARD;
		forward_state = FORWARD_R;
	}
}

/* 前進中次ステップ左足制御処理ユニット */
static void forward_nextstep_is_l_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case RIGHT_EVENT:
			case BACKWARD_EVENT:
			case LEFT_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、前進終了（左足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_forward_break_left,c_forward_break_left);/* (BD1,2,5) */
				walking_state = FORWARD;
				forward_state = FORWARD_BREAK_L;
				break;
			default:
				/* 前進継続（左足前へ）へ */
				sequence_shift_preprocess(u16_forward_left,c_forward_left);/* (BD1,2,5) */
				walking_state = FORWARD;
				forward_state = FORWARD_L;
				break;
		}
	}else if((++s16_counter >= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 歩行動作指示：停止イベント */
		/* 前進終了（左足揃え）へ */
		sequence_shift_preprocess(u16_forward_break_left,c_forward_break_left);/* (BD1,2,5) */
		walking_state = FORWARD;
		forward_state = FORWARD_BREAK_L;
	}else{
		/* 前進継続（左足前へ）へ */
		sequence_shift_preprocess(u16_forward_left,c_forward_left);/* (BD1,2,5) */
		walking_state = FORWARD;
		forward_state = FORWARD_L;
	}
}

/* 右回転状態制御処理ユニット */
static void execute_rotateright(void){
	switch(rotater_state){
		case ROTATER_FIRSTSTEP_L:		/* 右回転開始（左足上げ） */
			rotater_nextstep_is_r_exe();
			break;
		case ROTATER_FIRSTSTEP_R:		/* 右回転開始（右足上げ） */
			rotater_nextstep_is_l_exe();
			break;
		case ROTATER_L:				/* 右回転継続（左足上げ） */
			rotater_nextstep_is_r_exe();
			break;
		case ROTATER_R:				/* 右回転継続（右足上げ） */
			rotater_nextstep_is_l_exe();
			break;
		case ROTATER_BREAK_L:			/* 右回転停止（左足揃え） */
			/* 右足停止(ROTATER_BREAK_R)と同処理のためbreak省略 */
		case ROTATER_BREAK_R:			/* 右回転停止（右足揃え） */

			if(s16_count_target != STOP_COUNTING){
				f_s.complete = 1U;	/* 歩行動作シーケンス完了 */
			}else if((walking_order_event != NO_EVENT) && (walking_order_event != RIGHT_EVENT)){
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
			}
			walking_state = STANDBY;	/* 待機（ホームポジション）へ */
			break;
	}
}

/* 右回転中次ステップ右足制御処理ユニット */
static void rotater_nextstep_is_r_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case LEFT_EVENT:
			case BACKWARD_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、右回転終了（右足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_rotate_right_break_right,c_rotate_right_break_right);/* (BD1,2,5) */
				walking_state = ROTATERIGHT;
				rotater_state = ROTATER_BREAK_R;
				break;
			default:
				/* 右回転継続（右足上げ）へ */
				sequence_shift_preprocess(u16_rotate_right_right,c_rotate_right_right);/* (BD1,2,5) */
				walking_state = ROTATERIGHT;
				rotater_state = ROTATER_R;
				break;
		}
	}else if((++s16_counter >= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 停止イベント */
		/* 右回転停止（右足揃え）へ */
		sequence_shift_preprocess(u16_rotate_right_break_right,c_rotate_right_break_right);/* (BD1,2,5) */
		walking_state = ROTATERIGHT;
		rotater_state = ROTATER_BREAK_R;
	}else{
		/* 右回転継続（右足上げ）へ */
		sequence_shift_preprocess(u16_rotate_right_right,c_rotate_right_right);/* (BD1,2,5) */
		walking_state = ROTATERIGHT;
		rotater_state = ROTATER_R;
	}
}

/* 右回転中次ステップ左足制御処理ユニット(BD1,2,5) */
static void rotater_nextstep_is_l_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case BACKWARD_EVENT:
			case LEFT_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、右回転終了（左足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_rotate_right_break_left,c_rotate_right_break_left);/* (BD1,2,5) */
				walking_state = ROTATERIGHT;
				rotater_state = ROTATER_BREAK_L;
				break;
			default:
				/* 右回転継続（左足上げ）へ */
				sequence_shift_preprocess(u16_rotate_right_left,c_rotate_right_left);/* (BD1,2,5) */
				walking_state = ROTATERIGHT;
				rotater_state = ROTATER_L;
				break;
		}
	}else if((++s16_counter >= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 歩行動作指示：停止イベント */
		/* 右回転終了（左足揃え）へ */
		sequence_shift_preprocess(u16_rotate_right_break_left,c_rotate_right_break_left);/* (BD1,2,5) */
		walking_state = ROTATERIGHT;
		rotater_state = ROTATER_BREAK_L;
	}else{
		/* 右回転継続（左足上げ）へ */
		sequence_shift_preprocess(u16_rotate_right_left,c_rotate_right_left);/* (BD1,2,5) */
		walking_state = ROTATERIGHT;
		rotater_state = ROTATER_L;
	}
}

/* 後退状態制御処理ユニット */
static void execute_backward(void){
	switch(backward_state){
		case BACKWARD_FIRSTSTEP_R:		/* 後退開始（右足後へ） */
			backward_nextstep_is_l_exe();
			break;
		case BACKWARD_FIRSTSTEP_L:		/* 後退開始（左足後へ） */
			backward_nextstep_is_r_exe();
			break;
		case BACKWARD_L:			/* 後退継続（左足後へ） */
			backward_nextstep_is_r_exe();
			break;
		case BACKWARD_R:			/* 後退継続（右足後へ） */
			backward_nextstep_is_l_exe();
			break;
		case BACKWARD_BREAK_L:			/* 後退終了（左足揃え） */
			/* 右足停止(BACKWARD_BREAK_R)と同処理のためbreak省略 */
		case BACKWARD_BREAK_R:			/* 後退終了（右足揃え） */
			if(s16_count_target != STOP_COUNTING){
				f_s.complete = 1U;	/* 歩行動作シーケンス完了 */
			}else if((walking_order_event != NO_EVENT) && (walking_order_event != BACKWARD_EVENT)){
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
			}
			walking_state = STANDBY;	/* 待機（ホームポジション）へ */
			break;
	}
}

/* 後退中次ステップ右足制御処理ユニット */
static void backward_nextstep_is_r_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case RIGHT_EVENT:
			case LEFT_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、後退終了（右足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_backward_break_right,c_backward_break_right);/* (BD1,2,5) */
				walking_state = BACKWARD;
				backward_state = BACKWARD_BREAK_R;
				break;
			default:
				/* 後退継続（右足後へ）へ */
				sequence_shift_preprocess(u16_backward_right,c_backward_right);/* (BD1,2,5) */
				walking_state = BACKWARD;
				backward_state = BACKWARD_R;
				break;
		}
	}else if((--s16_counter <= s16_count_target)	/* 目標歩数到達 */
		|| (walking_order_event == STOP_EVENT)){/* 歩行動作指示：停止イベント */
		/* 後退終了（右足揃え）へ */
		sequence_shift_preprocess(u16_backward_break_right,c_backward_break_right);/* (BD1,2,5) */
		walking_state = BACKWARD;
		backward_state = BACKWARD_BREAK_R;
	}else{
		/* 後退継続（右足後へ）へ */
		sequence_shift_preprocess(u16_backward_right,c_backward_break_right);/* (BD1,2,5) */
		walking_state = BACKWARD;
		backward_state = BACKWARD_R;
	}
}

/* 後退中次ステップ左足制御処理ユニット */
static void backward_nextstep_is_l_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case RIGHT_EVENT:
			case LEFT_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、後退終了（左足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_backward_break_left,c_backward_break_left);/* (BD1,2,5) */
				walking_state = BACKWARD;
				backward_state = BACKWARD_BREAK_L;
				break;
			default:
				/* 後退継続（左足後へ）へ */
				sequence_shift_preprocess(u16_backward_left,c_backward_left);/* (BD1,2,5) */
				walking_state = BACKWARD;
				backward_state = BACKWARD_L;
				break;
		}
	}else if((--s16_counter <= s16_count_target)	/* 目標歩数到達 */
		|| (walking_order_event == STOP_EVENT)){/* 停止イベント */
		/* 後退終了（左足揃え）へ */
		sequence_shift_preprocess(u16_backward_break_left,c_backward_break_left);/* (BD1,2,5) */
		walking_state = BACKWARD;
		backward_state = BACKWARD_BREAK_L;
	}else{
		/* 後退継続（左足後へ）へ */
		sequence_shift_preprocess(u16_backward_left,c_backward_left);/* (BD1,2,5) */
		walking_state = BACKWARD;
		backward_state = BACKWARD_L;
	}
}

/* 左回転状態制御処理ユニット */
static void execute_rotateleft(void){
	switch(rotatel_state){
		case ROTATEL_FIRSTSTEP_L:		/* 左回転開始（左足上げ） */
			rotatel_nextstep_is_r_exe();
			break;
		case ROTATEL_FIRSTSTEP_R:		/* 左回転開始（右足上げ） */
			rotatel_nextstep_is_l_exe();
			break;
		case ROTATEL_L:				/* 左回転継続（左足上げ） */
			rotatel_nextstep_is_r_exe();
			break;
		case ROTATEL_R:				/* 左回転継続（右足上げ） */
			rotatel_nextstep_is_l_exe();
			break;
		case ROTATEL_BREAK_L:			/* 左回転終了（左足揃え） */
			/* 右足停止(ROTATEL_BREAK_R)と同処理のためbreak省略 */
		case ROTATEL_BREAK_R:			/* 左回転終了（右足揃え） */

			if(s16_count_target != STOP_COUNTING){
				f_s.complete = 1U;	/* 歩行動作シーケンス完了 */
			}else if((walking_order_event != NO_EVENT) && (walking_order_event != LEFT_EVENT)){
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
			}
			walking_state = STANDBY;	/* 待機（ホームポジション）へ */
			break;
	}
}

/* 左回転中次ステップ右足制御処理ユニット */
static void rotatel_nextstep_is_r_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case RIGHT_EVENT:
			case BACKWARD_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、左回転終了（右揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_rotate_left_break_right,c_rotate_left_break_right);/* (BD1,2,5) */
				walking_state = ROTATELEFT;
				rotatel_state = ROTATEL_BREAK_R;
				break;
			default:
				/* 左回転継続（右足上げ） */
				sequence_shift_preprocess(u16_rotate_left_right,c_rotate_left_right);/* (BD1,2,5) */
				walking_state = ROTATELEFT;
				rotatel_state = ROTATEL_R;
				break;
		}
	}else if((--s16_counter <= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 停止イベント */
		/* 左回転終了（右足揃え）へ */
		sequence_shift_preprocess(u16_rotate_left_break_right,c_rotate_left_break_right);/* (BD1,2,5) */
		walking_state = ROTATELEFT;
		rotatel_state = ROTATEL_BREAK_R;
	}else{
		/* 左回転継続（右足上げ）へ */
		sequence_shift_preprocess(u16_rotate_left_right,c_rotate_left_right);/* (BD1,2,5) */
		walking_state = ROTATELEFT;
		rotatel_state = ROTATEL_R;
	}
}

/* 左回転中次ステップ左足制御処理ユニット */
static void rotatel_nextstep_is_l_exe(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case RIGHT_EVENT:
			case BACKWARD_EVENT:
			case DANCE_EVENT:
				/* 歩行動作指示イベントを記憶し、左回転終了（左足揃え）へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				sequence_shift_preprocess(u16_rotate_left_break_left,c_rotate_left_break_left);/* (BD1,2,5) */
				walking_state = ROTATELEFT;
				rotatel_state = ROTATEL_BREAK_L;
				break;
			default:
				/* 左回転継続（左足上げ）へ */
				sequence_shift_preprocess(u16_rotate_left_left,c_rotate_left_left);/* (BD1,2,5) */
				walking_state = ROTATELEFT;
				rotatel_state = ROTATEL_L;
				break;
		}
	}else if((--s16_counter <= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 歩行動作指示：停止イベント */
		/* 左回転終了（左足揃え）へ */
		sequence_shift_preprocess(u16_rotate_left_break_left,c_rotate_left_break_left);/* (BD1,2,5) */
		walking_state = ROTATELEFT;
		rotatel_state = ROTATEL_BREAK_L;
	}else{
		/* 左回転継続（左足上げ）へ */
		sequence_shift_preprocess(u16_rotate_left_left,c_rotate_left_left);/* (BD1,2,5) */
		walking_state = ROTATELEFT;
		rotatel_state = ROTATEL_L;
	}
}

/* ダンス状態制御処理ユニット */
static void execute_dance(void){
	if(s16_count_target == STOP_COUNTING){
		switch(walking_order_event){
			case STOP_EVENT:
			/* 以下同処理のためbreak省略 */
			case FORWARD_EVENT:
			case RIGHT_EVENT:
			case BACKWARD_EVENT:
			case LEFT_EVENT:
				/* 歩行動作指示イベントを記憶し、待機状態へ */
				walking_order_event_memory = walking_order_event;
				walking_order_event = NO_EVENT;	/* 歩行動作指示イベント消去 */
				walking_state = STANDBY;/* 待機（ホームポジション）へ */
				break;
			default:
				/* ダンス継続 */
				sequence_shift_preprocess(u16_dance,c_dance);/* (BD1,2,5) */
				walking_state = DANCE;
				break;
		}
	}else if((++s16_counter >= s16_count_target)	/* 目標歩数到達 */
			|| (walking_order_event == STOP_EVENT)){/* 停止イベント */
		/* 待機（ホームポジション）へ */
		f_s.complete = 1U;			/* 歩行動作シーケンス完了 */
		walking_state = STANDBY;
	}else{
		/* ダンス継続 */
		sequence_shift_preprocess(u16_dance,c_dance);/* (BD5) */
		walking_state = DANCE;
	}
}
