05_5 タイトル


 1)センサデータの分析と走行距離の計測    
 センサの数や位置の違い、ステッピングモータとDCモータの制御の違いを吸収するために、センサデータの分析や走行距離の計測、壁合わせなどのルーチンを独立したファイルにした。
 現在は使用していないルーチンもあるが、以下のプログラムのとおり。

/*		走行距離の計測 & センサdata分析処理 & 壁合わせ											*/
/*										   				from  1999/04/03		made by k.notoya	*/

#include "d:\H83048File\3048f.h"		/* MCR版 h8のレジスタを定義したヘッダファイル	*/
	/* #include "d:\H83048File\machine.h"	*/	/* 割り込み設定 etc	*/
#include "d:\H83048File\stdio.h"		/* H8 standerd I/O hedder	*/
	/* #include "d:\H83048File\stdlib.h"	*/

#include "d:\standardDef.h"	/* 標準的な定数data & インターフェイス・制御系のマクロ		*/
#include "d:\constant.h"		/* 定数data (走行速度、走行距離、姿勢制御量)		*/
#include "d:\global.h"			/* 全モジュール共通 広域変数						*/
#include "d:\mouselib.h"		/* マイクロマウスのための関数のプロトタイプ宣言		*/


void end_dance(void) ;			/* 探査終了のサイン 360度+ 180度 	左・信地旋回		*/
void position_set_Front(void) ;	/* mouseが停止したとき、前に壁が有るなら、停止位置を迷路の中央に合わせる	*/
void position_set_spin(void) ;	/* 180度反転の後、start位置を迷路の中央に合わせる	*/

void countDistanceFrontWallSla(void) ;	/* 前壁が有るときの、前壁制御(slalom進入位置を前壁で制御)	*/
void count_distance_FrontWall(void) ;	/* 前壁が有るときの、前壁制御(停止位置を前壁で制御)	*/
void count_distance(void) ;	/* 設定距離を走行する	*/

void side_wall_data_management(void) ;	/* 横壁の dataを 壁data set用に変更する	*/
void front_wall_data_management(void) ;	/* 前壁の dataを 壁data set用に変更する	*/
void aslant_front_wall_check(void) ;	/* 斜め走行 前壁data 処理   front wall data management for aslant	*/
void wall_set(UCHAR *dir_old,UCHAR *wall_data) ;	/* wall_set(相対方向,壁の有無)*/
void front_wall_set(void) ;	/* 前壁 記入	*/
void side_wall_set(void) ;	/* 左右の横壁 記入	*/
void wall_data_write(void) ;	/* 壁dataを迷路地図に書き込む	*/
UCHAR side_wall_check(void) ;	/* 横壁dataによる壁合わせのための基本data作成	*/
UCHAR front_wall_check(void) ;	/* 前壁dataによる壁合わせのための基本data作成	*/
void front_wall_emergency_suspend(void) ;	/* 前壁dataによる emergency suspend	*/
void front_wall_in_slalom(void) ;	/* 前壁dataによる壁合わせ	slalomの進入位置を前壁の位置で合わせる	*/
void side_wall_in(void) ;	/* 片側・壁無しの 壁合わせ	壁が無い方向の壁が入るのを待つ	*/
void side_wall_off(void) ;	/* 旋回する方向の壁の切れ目を探す	*/


	/* 360度+ 180度 	左・信地旋回	*/
void end_dance(void)	/* 360度+ 180度 	左・信地旋回	*/
{
		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止 	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 変数とフラグを初期化	*/
	running_condition= HALT ;		/* mouseは停止していた	*/
	accele_condition= ACCELE ;		/* mouseは加速する	*/

		/* 旋回方向 設定	左旋回		*/
	turn_direction= SPIN_LEFT ;	/* 左 信地旋回	*/
		/* 走行距離設定	*/
	mark_distance= ( (SPIN_TURN180)*3 ) ;	/* 360度+ 180度 旋回	*/
	position_now= mark_distance ;	/* position_now is ダウン・カウント(残りの走行パルス数)	*/
		/* 走行速度設定	& 加減速rate reset	*/
	accele_pulse= mark_distance- 100 ;	/* 加速パルス数 set	*/
		/* 減速パルス数をカウンター(reduce_pulse)に設定する	加速パルス数と減速パルス数を一致させる	*/
	reduce_pulse= 125 ;	/* 減速パルス数 set	*/
		/* mouse の走行速度を設定する	*/
	speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
	adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
		/* SLA7033 PWM基準電圧設定		*/
	current= (TANSA_CURRENT+5) ;	/* motor の電流値(A/D.Cに書きこむ値)	*/

		/* 走行基本data設定終了		走行準備完了	*/
	power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
		/* 走行距離(旋回角)を設定する	*/
	distance_compare= 0x00 ;	/* distance_compare is 残りの走行距離	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(WAKE) ;	/* 割り込み 許可	*/
		/* 設定角度を旋回する	*/
	count_distance() ;		/* mouseは設定距離を走行する	*/

		/* mouseは設定距離を走行した  旋回終了	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/

		/* SLA7033 PWM基準電圧を元に戻す	*/
	current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 走行状態flag set	*/
	running_condition= HALT ;	/* if running_condition == HALT then mouseは停止していた	*/
}


	/* mouseが停止したとき、前に壁が有るなら、停止位置を迷路の中央に合わせる	*/
void position_set_Front(void)		/* mouseが停止したとき、前に壁が有るなら、停止位置を迷路の中央に合わせる	*/
{
	SSHORT counter ;	/* 走行距離 counter	*/

		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 変数とフラグを初期化	*/
	map_renewal= SLEEP ;		/* if map_renewal is WAKE then 迷路地図を更新する		*/
	deside_flag= SLEEP ;		/* if deside_flag is WAKE then call deside direction	*/
	running_condition= HALT ;	/* mouseは停止していた		*/
	turn_direction= STRAIGHT ;	/* mouseは直進する	*/
	accele_condition= ACCELE ;	/* 速度flag    reset	*/

		/* 前壁による壁合わせ		前壁は有るか ???	*/
			/* 【注意】 mouse は、柱の中心(slalom侵入位置)を過ぎているので、柱の中心(slalom侵入位置)の壁dataと比較して壁の有無を判断する	*/
	if ( (analog[LEFT_FRONT] > left_front_mid) && (analog[RIGHT_FRONT] > right_front_mid) )
			/* if ( (analog[LEFT_FRONT] > left_front_min) && (analog[RIGHT_FRONT] > right_front_min) )	*/
		{
		if ( (analog[LEFT_FRONT] > left_front_max) && (analog[RIGHT_FRONT] > right_front_max) )
			{
				/* mouseが後退するので、loopを使って(割り込みを使わない)走行する	*/
				/* SLA7033 PWM基準電圧設定		*/
			current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
			power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
				/* 走行距離設定		迷路中心まで 約33mm 前進するので、33mm+ 誤差分 15mm 後退する	48mm/0.41mm= 117.07パルス	*/
			for ( counter= 117; counter >= 0; counter= counter- 1 )
				{
					/* 左motor励磁data adress 更新	*/
				if ( Left_Reiji > 0 )				Left_Reiji= Left_Reiji- 1 ;
				else								Left_Reiji= 7 ;
					/* 右motor励磁data adress 更新	*/
				if ( Right_Reiji > 0 )				Right_Reiji= Right_Reiji- 1 ;
				else								Right_Reiji= 7 ;

					/* motor駆動信号出力 poat_B	*/
						/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
				PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
					/* 後退の速度を設定(時間稼ぎの無駄演算) */
				wait(3000) ;	/* 後退の速度を設定(時間稼ぎの無駄演算) */

					/* 設定位置まで後退したか ???	*/
				if ( (analog[LEFT_FRONT] <= left_front_max) && (analog[RIGHT_FRONT] <= right_front_max) ) {
													break ; } 	/* 設定位置まで後退した   loop end	*/
				}
					/* mouseは設定距離を走行した		前進方向に励磁する	*/
				long_wait(10,10000) ;
					/* 励磁data 更新 前進方向に励磁する	*/
				Left_Reiji= Left_Reiji+ 1 ;	/* 前進方向に励磁する	*/
				Right_Reiji= Right_Reiji+ 1 ;
					/* motor駆動信号出力 poat_B	*/
						/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
				PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
			}

		else if ( (analog[LEFT_FRONT] < left_front_max) && (analog[RIGHT_FRONT] < right_front_max) )
			{
				/* mouseが前進するので、loopを使って(割り込みを使わない)走行する	*/
				/* SLA7033 PWM基準電圧設定		*/
			current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
			power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
				/* 走行距離設定		迷路中心まで 約33mm 前進するので、33mm+ 誤差分 15mm 後退する	48mm/0.41mm= 117.07パルス	*/
			for ( counter= 117; counter >= 0; counter= counter- 1 )
				{
					/* 左motor励磁data adress 更新	*/
				if ( Left_Reiji < 7 )				Left_Reiji= Left_Reiji+ 1 ;
				else								Left_Reiji= 0 ;
					/* 右motor励磁data adress 更新	*/
				if ( Right_Reiji < 7 )				Right_Reiji= Right_Reiji+ 1 ;
				else								Right_Reiji= 0 ;

					/* motor駆動信号出力 poat_B	*/
						/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
				PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
					/* 前進の速度を設定(時間稼ぎの無駄演算) */
				wait(3000) ;	/* 前進の速度を設定(時間稼ぎの無駄演算) */

					/* 設定位置まで後退したか ???	*/
				if ( (analog[LEFT_FRONT] <= left_front_max) && (analog[RIGHT_FRONT] <= right_front_max) ) {
													break ; } 	/* 設定位置まで後退した   loop end	*/
				}
					/* mouseは設定距離を走行した		後進方向に励磁する	*/
				long_wait(10,10000) ;
					/* 励磁data 更新 後進方向に励磁する	*/
				Left_Reiji= Left_Reiji- 1 ;	/* 後進方向に励磁する	*/
				Right_Reiji= Right_Reiji- 1 ;
					/* motor駆動信号出力 poat_B	*/
						/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
				PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
			}
		}

		/* mouseは設定距離を走行した	短時間励磁する	*/
	long_wait(50,10000) ;
		/* SLA7033 PWM基準電圧設定		*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/
}


	/* 180度反転の後、start位置を迷路の中央に合わせる	*/
void position_set_spin(void)	/* 180度反転の後、start位置を迷路の中央に合わせる	*/
{
	SSHORT counter ;	/* 走行距離 counter	*/

		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 変数とフラグを初期化	*/
	map_renewal= SLEEP ;		/* if map_renewal is WAKE then 迷路地図を更新する		*/
	deside_flag= SLEEP ;		/* if deside_flag is WAKE then call deside direction	*/
	running_condition= HALT ;	/* mouseは停止していた		*/
	turn_direction= STRAIGHT ;	/* mouseは直進する	*/
	accele_condition= ACCELE ;	/* 速度flag    reset	*/

	/* mouseが後退するので、loopを使って(割り込みを使わない)走行する	*/
		/* SLA7033 PWM基準電圧設定		*/
	current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
	power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
		/* 走行距離設定		迷路中心まで 約33mm 前進するので、33mm+ 誤差分 15mm 後退する	48mm/0.41mm= 117.07パルス	*/
	for ( counter= 117; counter >= 0; counter= counter- 1 )
		{
			/* 左motor励磁data adress 更新	*/
		if ( Left_Reiji > 0 )				Left_Reiji= Left_Reiji- 1 ;
		else								Left_Reiji= 7 ;
			/* 右motor励磁data adress 更新	*/
		if ( Right_Reiji > 0 )				Right_Reiji= Right_Reiji- 1 ;
		else								Right_Reiji= 7 ;

			/* motor駆動信号出力 poat_B	*/
				/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
		PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
			/* 後退の速度を設定(時間稼ぎの無駄演算) */
		wait(3000) ;	/* 後退の速度を設定(時間稼ぎの無駄演算) */
		}

		/* mouseは設定距離を走行した		前進方向に励磁する	*/
	long_wait(10,10000) ;
		/* 励磁data 更新 前進方向に励磁する	*/
	Left_Reiji= Left_Reiji+ 1 ;	/* 前進方向に励磁する	*/
	Right_Reiji= Right_Reiji+ 1 ;
		/* motor駆動信号出力 poat_B	*/
			/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
	PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
		long_wait(50,10000) ;
		/* SLA7033 PWM基準電圧設定		*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/
}


	/* 設定距離を走行する	マウスが前進しているときはダウンカウントになる	*/
void count_distance(void)	/* 設定距離を走行する	*/
{
		/* distance_compare is 設定された走行距離	 position_now is 残りの走行距離	*/
	while ( position_now > distance_compare ) {
		;;;		/* 設定距離を走行するまで loop	*/
		}
}


			/* 前壁データ基準値 設定	*/
				/* 車軸中心から先端までの長さ		約 65mm	*/
				/* 前壁の有無			(180mm+ 45mm)- 65mm is 160mm		160mm/0.41mm 390.2 パルスの位置	*/
				/* スラローム進入位置		(180mm-  6mm)- 65mm is 109mm		109mm/0.41mm 265.9 パルスの位置	*/
				/* 迷路の中心(緊急停止)	( 90mm-  6mm)- 65mm is  19mm		 19mm/0.41mm  39.0 パルスの位置	*/

	/* 前壁が入るまで(slalom進入位置を前壁で制御)走行する	但し、前壁が消えたら、設定距離を走って止まる	*/
void countDistanceFrontWallSla(void)	/* 前壁が有るときの、前壁制御(slalom進入位置を前壁で制御)	*/
{
	UCHAR result ;

		/* 左右 両方の前壁dataが設定値(迷路中心の前壁data)を越える or	*/
		/* 前壁を見失う(lost)するまで loopする							*/
	for (;;)
		{
			/* 左右 両方の前壁dataが設定値(slalom進入位置の前壁data)を越えたら、此処を抜ける	*/
		if ( (analog[LEFT_FRONT] >= left_front_mid) && (analog[RIGHT_FRONT] >= right_front_mid) ) {
										result= SUCCESS ;	/* 正常に制御が終わった  成功した	*/
												break ;	}	/* mouse は、迷路の中央まで来た		*/
		if ( (analog[LEFT_FRONT] <= left_front_min) || (analog[RIGHT_FRONT] <= right_front_min) ) {
										result= FAILURE ;	/* mouseは前壁を見失った  失敗した	*/
												break ; }	/* mouseは設定距離を走行する			*/
		}	/* 左右 両方の前壁dataが設定値(迷路中心の前壁data)を越える or	*/
			/* 前壁を見失う(lost)するまで loopする							*/

		/* 前壁制御に成功したか ???	*/
	if (result != SUCCESS)				count_distance() ;	/* mouseは設定距離を走行する	*/
}


	/* 前壁が入るまで(停止位置を前壁で制御)走行する	但し、前壁が消えたら、設定距離を走って止まる	*/
void count_distance_FrontWall(void)	/* 前壁が有るときの、前壁制御(停止位置を前壁で制御)	*/
{
	UCHAR result ;

		/* 左右 両方の前壁dataが設定値(迷路中心の前壁data)を越える or	*/
		/* 前壁を見失う(lost)するまで loopする							*/
	for (;;)
		{
			/* 左右 両方の前壁dataが設定値(迷路中心の前壁data)を越えたら、此処を抜ける	*/
		if ( (analog[LEFT_FRONT] >= left_front_max) && (analog[RIGHT_FRONT] >= right_front_max) ) {
										result= SUCCESS ;	/* 正常に制御が終わった  成功した	*/
												break ;	}	/* mouse は、迷路の中央まで来た		*/
		if ( (analog[LEFT_FRONT] < left_front_mid) || (analog[RIGHT_FRONT] < right_front_mid) ) {
				/* if ( (analog[LEFT_FRONT] < left_front_min) || (analog[RIGHT_FRONT] < right_front_min) ) {	*/
										result= FAILURE ;	/* mouseは前壁を見失った  失敗した	*/
												break ; }	/* mouseは設定距離を走行する			*/
		}	/* 左右 両方の前壁dataが設定値(迷路中心の前壁data)を越える or	*/
			/* 前壁を見失う(lost)するまで loopする							*/

		/* 前壁制御に成功したか ???	*/
	if (result != SUCCESS)				count_distance() ;	/* mouseは設定距離を走行する	*/
}

/*==================================================================================================*/
/*		wall_map へ 壁dataを記入するための前処理	*/
/*==================================================================================================*/

	/* 探査走行 横壁data 処理   side wall data management	*/
void side_wall_data_management(void)	/* 横壁の dataを 壁data set用に変更する	*/
{
		/* 左横壁のdataを造る	*/
	if (left_side_min > analog[LEFT_SIDE]) {		/* 左横に壁は無かった	*/
		led( (((char )read_led())&(~0xc0)) ) ;		/* 1100-0000	LED cut off	*/
		side_wall= ( side_wall   &(~0xf0) ) ; }		/* if side_wall is 0000-xxxx then 左横壁 無し	*/
	else {		/* left side_wall センサー on	*/
		led( (((char )read_led())|(0xc0)) ) ; 		/* 1100-0000	LED on	*/
		side_wall= ( side_wall   | 0xf0 ) ; }		/* if side_wall is 1111-xxx then 左横壁 有り	*/

		/* 右横壁のdataを造る	*/
	if (right_side_min > analog[RIGHT_SIDE]) {		/* 右横に壁は無かった	*/
		led( (((char )read_led())&(~0x03)) ) ;		/* 0000-0011	LED cut off	*/
		side_wall= ( side_wall   &(~0x0f) ) ; }		/* if side_wall is xxxx-0000 then 右横壁 無し	*/
	else {		/* right side_wall センサー on	*/
		led( (((char )read_led())|(0x03)) ) ;		/* 0000-0011	LED on	*/
		side_wall= ( side_wall   | 0x0f) ; }		/* if side_wall is xxxx-1111 then 右横壁 有り	*/
}


	/* 探査走行 前壁data 処理   front wall data management		*/
		/* 左右、どちらかに壁が有れば、前壁有りと判断する	*/
void front_wall_data_management(void)	/* 前壁の dataを 壁data set用に変更する	*/
{
		/* 左前壁のdataを造る	*/
	if (left_front_min > analog[LEFT_FRONT]) {		/* 左前壁は 無かった	*/
		led( (((char )read_led())&(~0x30)) ) ;		/* 0011-0000	LED cut off	*/
		front_wall= (front_wall  &(~0xf0)) ;		/* if front_wall is 0000-xxxx then 左前壁 無し	*/
			/* 前壁の有無を 表示	*/
		wall_data_indication( (((char )read_wall_data_indi())&(~0x03)) ) ;	/* 壁data indication LED	*/
		}
	else {		/* left_front_wall センサー on		*/
		led( (((char )read_led())|(0x30)) ) ;	/* 0011-0000	LED on	*/
		front_wall= (front_wall  | 0xf0) ;		/* if front_wall is 1111-xxxx then 左前壁 有り	*/
			/* 前壁の有無を 表示	*/
		wall_data_indication( (((char )read_wall_data_indi())|(0x03)) ) ;	/* 壁data indication LED	*/
		}

		/* 右前壁のdataを造る	*/
	if (right_front_min > analog[RIGHT_FRONT]) { 	/* 右前壁は 無かった	*/
		led( (((char )read_led())&(~0x0c)) ) ;		/* 0000-1100	LED cut off	*/
		front_wall= (front_wall  &(~0x0f)) ;		/* if front_wall is xxxx-0000 then 右前壁 無し	*/
			/* 前壁の有無を 表示	*/
		wall_data_indication( (((char )read_wall_data_indi())&(~0x0c)) ) ;	/* 壁data indication LED	*/
		}
	else {	/* right front_wall センサー on		*/
		led( (((char )read_led())|(0x0c)) ) ;		/* 0000-1100	LED on	*/
		front_wall= (front_wall  | 0x0f) ;			/* if front_wall is xxxx-1111 then 右前壁 有り	*/
			/* 前壁の有無を 表示	*/
		wall_data_indication( (((char )read_wall_data_indi())|(0x0c)) ) ;	/* 壁data indication LED	*/
		}
}


	/* 壁dataを記入する	*/
void wall_set(UCHAR *dir_old,UCHAR *wall_data)	/* wall_set(相対方向,壁の有無)*/
{
	UCHAR axis_new ;
	UCHAR dir_new ;
	UCHAR wall_data2 ;

	axis_new= axis ;
	dir_new = *dir_old ;

	if (*wall_data == 0xff)	/* if wall_data is 0x00 then 壁を取り外す	*/
		{
		dir_new= direction_rot[dir][dir_new] ;	/* 相対方向を絶対方向に直す			*/
			/* wall_set_rot[絶対方向]			絶対方向に対応する壁dataを読み込む	*/
		wall_data2= wall_set_rot[dir_new] ;		/* 絶対方向に対応する壁dataを読み込む	*/
		wall_data2= wall_data2 & 0x0f ;			/* 上位 4bitを マスクする	*/
		wall_map[axis]= wall_data2 | wall_map[axis] ;	/* 現在の座標の壁dataをset	*/
			/* 1歩直進した座標の壁dataをsetする	*/
		axis_new= axis ;
		dir_new= *dir_old ;
				/*	dir_new= ((dir_new+ dir) & 0x03) ;	*/	/* 相対方向を絶対方向にする		*/
		dir_new= direction_rot[dir][dir_new] ;	/* 相対方向を絶対方向に直す	*/
		if ((axis_forward(&axis_new,dir_new)) == Possible)	/* if return Impossible then 直進すれば 16*16 から 外れる	*/
			{
			dir_new= ((*dir_old+ 0x02) & 0x03) ;	/* 直進した座標なので、反転する	*/
			dir_new= direction_rot[dir][dir_new] ;	/* 相対方向を絶対方向に直す		*/
				/* wall_set_rot[絶対方向]		絶対方向に対応する壁dataを読み込む	*/
			wall_data2= wall_set_rot[dir_new] ; 	/* 絶対方向に対応する壁dataを読み込む	*/
			wall_data2= wall_data2 & 0x0f ;			/* 上位 4bitをマスクする	*/
			wall_map[axis_new]= wall_data2 | wall_map[axis_new] ;	/* 1歩進んだ座標の壁dataをset	*/
			}
		}
	else	/*	壁を消す(壁無しにsetする)		*/
		{
		dir_new= direction_rot[dir][dir_new] ;	/* 相対方向を絶対方向に直す	*/
		wall_data2= wall_res_rot[dir_new] ; 	/* 絶対方向に対応する壁dataを読み込む	*/
		wall_data2= wall_data2 | 0xf0 ;			/* 上位 4bitをマスクする	*/
		wall_map[axis]= wall_data2 & wall_map[axis] ;	/* 現在の座標の壁dataをset	*/
			/*	1歩直進した座標の壁dataをsetする	*/
		axis_new= axis ;
		dir_new= *dir_old ;
			/*	dir_new= ((dir_new+ dir) & 0x03) ;	*/		/* 相対方向を絶対方向にする		*/
		dir_new= direction_rot[dir][dir_new] ;	/* 相対方向を絶対方向に直す	*/
		if ((axis_forward(&axis_new,dir_new)) == Possible)	/* if return Impossible then 直進すれば 16*16 から 外れる	*/
			{
			dir_new= ((*dir_old+ 0x02) & 0x03) ;	/* 直進した座標なので、反転する	*/
			dir_new= direction_rot[dir][dir_new] ;	/* 相対方向を絶対方向に直す		*/
			wall_data2= wall_res_rot[dir_new] ;		/* 絶対方向に対応する壁dataを読み込む	*/
			wall_data2= wall_data2 | 0xf0 ;			/* 上位 4bitをマスクする	*/
			wall_map[axis_new]= wall_data2 & wall_map[axis_new] ;	/* 1歩進んだ座標の壁dataをset	*/
			}
		}
}


	/* 前壁 記入	*/
void front_wall_set(void)	/* 前壁 記入	*/
{
	UCHAR wall_data ;
	UCHAR dir_new ;

		/* 前壁は、あるか ???		*/
	if ((front_wall & 0xff) != 0x00)	wall_data= 0xff ;	/* wall_data is 0xff then 壁有り	*/
	else								wall_data= 0x00 ;	/* wall_data is 0x00 then 壁無し	*/
		/* 相対方向を設定する		相対方向は、前 dir_new is 0x00 */
	dir_new= 0x00 ;					/* 相対方向は、前 dir_new is 0x00 */
	wall_set(&dir_new,&wall_data) ;	/* wall_set(相対方向,壁の有無)		前壁dataをset	*/
}


	/* 左右の横壁 記入	*/
void side_wall_set(void)	/* 左右の横壁 記入	*/
{
	UCHAR wall_data ;
	UCHAR dir_new ;

		/* 左側に壁は有るか ???	*/
	if ((side_wall & 0xf0) == 0xf0)			wall_data= 0xff ;	/* wall_data is 0xff then 壁有り	*/
	else									wall_data= 0x00 ;	/* wall_data is 0x00 then 壁無し	*/
		/* 相対方向を設定する		相対方向は、左 dir_new is 0x00 */
	dir_new= 0x03 ;						/* 相対方向は、左			*/
	wall_set(&dir_new,&wall_data) ;		/* wall_set(相対方向,壁の有無)		左壁dataをset	*/

		/* 次は右壁dataを set		*/
	if ((side_wall & 0x0f) == 0x0f)			wall_data= 0xff ;	/* wall_data is 0xff then 壁有り	*/
	else									wall_data= 0x00 ;	/* wall_data is 0x00 then 壁無し	*/
		/* 相対方向を設定する		相対方向は、右 dir_new is 0x00 */
	dir_new= 0x01 ;						/* 相対方向は右      	*/
	wall_set(&dir_new,&wall_data) ;		/* wall_set(相対方向,壁の有無)		右壁dataをset	*/
}


	/* 壁dataを迷路地図に書き込む	*/
void wall_data_write(void)	/* 壁dataを迷路地図に書き込む	*/
{
		/* 壁データを壁map記入用に処理する	*/
	side_wall_data_management() ;	/* 横壁の dataを 壁data set用に変更する	*/
	front_wall_data_management() ;	/* 前壁の dataを 壁data set用に変更する	*/
		/* 壁dataを迷路地図に書き込む	*/
	side_wall_set() ;	/* 左右横壁data 入力	*/
	front_wall_set() ;	/* 前壁data 入力		*/
}

/*==================================================================================================*/
/*		壁合わせのための基本data作成	*/
/*==================================================================================================*/

	/* 壁の状態をコード化して  wall_condition に記録する	*/
							/*−−−−−    wall condition data	  全タイプ対応	  −−−−−*/
							/*                      Left_Front   Right_Frint				*/
							/*	 data   Left_wall                               Right_wall	*/
							/*	  03h      xx          xx            xx             11		*/
							/*	  0Ch      xx          xx            11             xx		*/
							/*	  30h      xx          11            xx             xx		*/
							/*	 0C0h      11          xx            xx             xx 		*/
			/* センサの生データは割り込みルーチンで自動的に配列変数 analog[channel]に格納され	*/
			/* 壁の有無は、 s_wall_manag()	横壁データ処理	side wall data managementで			*/
			/* 変数 front_wall、side_wall にセットされている									*/
			/* 	if front_wall == 0x00 then  前壁 無し	else if front_wall != 0x00  前壁 有り	*/

	/* 横壁dataによる壁合わせのための基本data作成	*/
UCHAR side_wall_check(void)	/* 横壁dataによる壁合わせのための基本data作成	*/
{
	UCHAR flag ;
	flag= Impossible ;	/* 横壁dataによる壁合わせは不可能(Impossible)に仮設定	*/

		/* 最初は左横壁	*/
	if ( (side_wall & 0xf0) != 0x00 )	wall_condition= wall_condition |  0xc0 ;	/*  0xc0 is 1100-0000	*/
	else								wall_condition= wall_condition &(~0xc0) ;	/* ~0xc0 is 0011-1111	*/
		/* 次は右横壁	*/
	if ( (side_wall & 0x0f) != 0x00 )	wall_condition= wall_condition |  0x03 ;	/*  0x03 is 0000-0011	*/
	else								wall_condition= wall_condition &(~0x03) ;	/* ~0x03 is 1111-1100	*/

		/* 左右 どちらかに壁の無い方向はあるか ???	*/
	if ( (wall_condition & 0xc3) != 0xc3)		flag= Possible ;	/* 横壁dataによる壁合わせは可能(Possible)		*/
	else										flag= Impossible ;	/* 横壁dataによる壁合わせは不可能(Impossible)	*/

		/* 横壁dataによる壁合わせは可能(Possible) or 不可能(Impossible)を返す	*/
	return(flag) ;	/* 横壁dataによる壁合わせは可能(Possible) or 不可能(Impossible)を返す	*/
}


	/* 前壁dataによる壁合わせのための基本data作成	*/
UCHAR front_wall_check(void)	/* 前壁dataによる壁合わせのための基本data作成	*/
{
	UCHAR flag ;
	flag= Impossible ;	/* 前壁dataによる壁合わせは不可能(Impossible)に仮設定	*/

		/* 最初は左前壁	*/
	if ((front_wall & 0xf0) == 0xf0)	wall_condition= wall_condition |  0x30 ;	/*  0x30 is 0011-0000	*/
	else								wall_condition= wall_condition &(~0x30) ;	/* ~0x30 is 1100-1111	*/
		/* 次は右前壁	*/
	if ((front_wall & 0x0f) == 0x0f)	wall_condition= wall_condition |  0x0c ;	/*  0x0c is 0000-1100	*/
	else								wall_condition= wall_condition &(~0x0c) ;	/* ~0x0c is 1111-0011	*/

		/* 左右 どちらかの前壁センサは壁を見つけたか ???	*/
	if ( (wall_condition & 0x3c) != 0x00)		flag= Possible ;	/* 前壁dataによる壁合わせは可能(Possible)		*/
	else										flag= Impossible ;	/* 前壁dataによる壁合わせは不可能(Impossible)	*/

		/* 前壁dataによる壁合わせは可能(Possible) or 不可能(Impossible)を返す	*/
	return(flag) ;	/* 前壁dataによる壁合わせは可能(Possible) or 不可能(Impossible)を返す	*/
}

/*==================================================================================================*/
/*		壁合わせ	*/
/*==================================================================================================*/

	/* 前壁dataによる壁合わせ   前壁dataが 限界値より大きくなったら return		迷路中央で停止	*/
void front_wall_emergency_suspend(void)	/* 前壁dataによる emergency suspend(stop)	迷路中央で停止	*/
{
	for (;;) {
			/* 左右 両方の前壁dataが設定値を越えたら、此処を抜ける	*/
		if ( (analog[LEFT_FRONT] >= left_front_max) && (analog[RIGHT_FRONT] >= right_front_max) )
											 		break ;		/* 迷路の中央まで来た(正常に走行が終わった)	*/
		}
}


	/* 前壁dataによる壁合わせ	slalomの進入位置を前壁の位置で合わせる		*/
void front_wall_in_slalom(void)	/* 前壁dataによる壁合わせ	slalomの進入位置を前壁の位置で合わせる		*/
{
	for (;;) {
			/* 左右 両方の前壁dataが設定値を越えたら、此処を抜ける	*/
		if ( (analog[LEFT_FRONT] >= left_front_mid) && (analog[RIGHT_FRONT] >= right_front_mid) )
													break ;		/* slalomの進入位置まで来た	*/
		}
}


	/* 片側・壁無しの 壁合わせ   壁が無い方向の壁が入るのを待つ	*/
void side_wall_in(void)	/* 片側・壁無しの 壁合わせ   壁が無い方向の壁が入るのを待つ	*/
{
			/* 壁が無い方向の壁が入 or 前壁dataが限界を越えるまで 無限loop	*/
	for (;;) {
			/* 左右 両壁 無し	*/
		if 		( (wall_condition & 0xc3) == 0x00) {
			if ( (side_wall & 0xff ) != 0x00 )		break ;	/* if side_wall is 1111-1111 then 左右・両壁有り	*/
			}
			/* 左壁 無し & 右壁 有り	*/
		else if ( (wall_condition & 0xc3) == 0x03) {
			if ( (side_wall & 0xf0 ) == 0xf0 )		break ;	/* if side_wall is 1111-0000 then 左横壁有り	*/
			}
			/* 左壁 有り & 右壁 無し &	*/
		else if	( (wall_condition & 0xc3) == 0xc0) {
			if ( (side_wall & 0x0f) == 0x0f )		break ;	/* if side_wall is 0000-1111 then 右横壁 有り	*/
			}
				/* slalomの進入位置(迷路の中心)まで mouseが来なら、此処から抜ける		壁合わせの miss	*/
		else if ( (analog[LEFT_FRONT] >= left_front_mid) || (analog[RIGHT_FRONT] >= right_front_mid) )
													break ;		/* slalomの進入位置まで来た	*/
		}
}


	/* 旋回する方向の壁の切れ目を探す	*/
void side_wall_off(void)	/* 旋回する方向の壁の切れ目を探す	*/
{							/*				dir_high is	旋回方向のdata	L_turn  0011-xxxx	*/
							/*			         						R_turn  0010-xxxx	*/
		/* 旋回方向は左		左側の壁は無くなったか ???	*/
	if 		( (dir_high & 0x30) == 0x30 ) {
		for (;;) {
			if ( (side_wall & 0xf0 ) == 0x00 )		break ;	/* if side_wall is 0000-xxxx then 左横壁 無し	*/
				/* slalomの進入位置(迷路の中心)まで mouseが来なら、此処から抜ける		壁合わせの miss	*/
			if ( (analog[LEFT_FRONT] >= left_front_mid) && (analog[RIGHT_FRONT] >= right_front_mid) )
													break ;		/* slalomの進入位置まで来た	*/
			}
		}
		/* 旋回方向は右		右側の壁は無くなったか ???	*/
	else if ( (dir_high & 0x20) == 0x20 ) {
		for (;;) {
			if ( (side_wall & 0x0f) == 0x00 )		break ;	/* if side_wall is xxxx-0000 then 右横壁 無し	*/
				/* slalomの進入位置(迷路の中心)まで mouseが来なら、此処から抜ける		壁合わせの miss	*/
			if ( (analog[LEFT_FRONT] >= left_front_mid) && (analog[RIGHT_FRONT] >= right_front_mid) )
													break ;		/* slalomの進入位置まで来た	*/
			}
		}
}

	



 2)計算ルーチン  
 人それぞれに走り方はある。私の走り方では、斜め走行時には旋廻に入る位置が旋廻角度によって変わってくる。また、走行速度によっても旋廻を開始する位置が異なる。そこで、走行パルス数の計算ルーチンを独立したファイルにした。
 現在は使用していないルーチンもあるが、以下のプログラムのとおり。

/*			走行用 パルス数計算 program		  for  mous 96_AN										*/
/*																	   from	1999/04/03				*/
/*																				made by k.notoya	*/

#include "d:\H83048File\3048f.h"		/* MCR版 h8のレジスタを定義したヘッダファイル	*/
	/* #include "d:\H83048File\machine.h"	*/	/* 割り込み設定 etc	*/
#include "d:\H83048File\stdio.h"		/* H8 standerd I/O hedder	*/

#include "d:\standardDef.h"	/* 標準的な定数data & インターフェイス・制御系のマクロ		*/
#include "d:\constant.h"		/* 定数data (走行速度、走行距離、姿勢制御量)		*/
#include "d:\global.h"			/* 全モジュール共通 広域変数						*/
#include "d:\mouselib.h"		/* マイクロマウスのための関数のプロトタイプ宣言		*/


void set_distance(void) ;	/* slalom 定常直進走行の走行の走行pulse数 set	*/
void calculate_accele_pulse_Max(void) ;	/* 加速区間の走行可能なpulse数を計算setし、加速 & 減速 pulse数も計算 setする	*/
void set_aslant_distance(void) ;	/* slalom 斜め直進走行の走行の走行pulse数 set	*/
void calculate_aslant_accele_Max(void) ;	/* 斜め走行最大速度時 走行pulse数に合わせて 加速 & 減速の pulse数を計算 setする	*/
void calc_sidewall_checkposition(void) ;	/* 次の旋回角に合わせて、壁dataを読み込む位置を計算する	*/
void set_distance_CaptureCenter(void) ;		/* slalomの旋回角に対応して、壁合わせの後に走行する pulse数を補正する	*/
void displace_running_line(void) ;	/* displacement of running line		斜め走行の出口で、旋回方向の反対側に移動させる	*/
void subtract_pulse_set(void) ;		/* 走行速度に合わせて 早めに slalomeに進入するパルス数をset する	*/
void fixd_data_set(void) ;	/* 定数の初期値を代入(ステアリング角度や初速など)	*/
void init_piruette(void) ;	/* piruette turn data 初期値 set	*/
void init_slalom_Search(void) ;	/* 探査走行 slalom旋回のdata 設定	*/
void init_slalom(void) ;	/* slalome定常走行 data 初期設定	*/
void init_slalom_slant(void) ;	/* slalom斜め走行 data 初期設定	*/
void init_slalom_turn(void) ;	/* slalom 旋回のdata 設定	*/

/*==================================================================================================*/
/*			加減速パルス数や走行パルス数を計算 & 代入		No_1 定常走行     						*/
/*==================================================================================================*/

	/* slalom 定常走行の走行の走行pulse数 set	*/
void set_distance(void)	/* slalom 定常直進走行の走行の走行pulse数 set	*/
{
			/* 【注意】	dir_high & dir_high_old の旋回角は、実際の旋回角(route_map_data+ 1)が setされている	*/
			/*						dir_high is  次の   旋回方向 & 旋回角										*/
			/* 						dir_high_old is 前回の  旋回方向 & 旋回角									*/
		/* 前回の 旋回角を調べる		前回の旋回角は 45 deg か ??? 	*/
	if ( (dir_high_old & 0x07) == 0x01 ) {
					/* yes 前回の旋回角は 45 deg   次の区画は gool or start地点(走行end) か ???	*/
		if 		(dir_high == 0xff) 					mark_distance= mark_distance- SUBD45 ;
					/* 前回の旋回角は 45 deg   次の旋回角は  45 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x01 ) {
													mark_distance= mark_distance- SUBD45 ;
													mark_distance= mark_distance- SUBD45 ; }
					/* 前回の旋回角は 45 deg   次の旋回角は  90 deg か ???	*/
		else if	( (dir_high & 0x07) == 0x02 )		mark_distance= mark_distance- SUBD45 ;
					/* 前回の旋回角は 45 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 ) {
													mark_distance= mark_distance- SUBD45 ;
													mark_distance= mark_distance- SUBD135 ; }
					/* 前回の旋回角は 45 deg   次の旋回角は 180 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x04 )		mark_distance= mark_distance- SUBD45 ;
		}
		/* 前回の 旋回角を調べる		前回の旋回角は 90 deg か ??? 	*/
	else if ( (dir_high_old & 0x07) == 0x02 ) {
					/* yes 前回の旋回角は 90 deg   次の区画は gool or start地点(走行end) か ???	*/
		if (dir_high == 0xff) {												}	/* そのまま return	*/
					/* 前回の旋回角は 90 deg   次の旋回角は  45 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x01 )		mark_distance= mark_distance- SUBD45 ;
					/* 前回の旋回角は 90 deg   次の旋回角は  90 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 ) {								}	/* そのまま return	*/
					/* 前回の旋回角は 90 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 )		mark_distance= mark_distance- SUBD135 ;
						/* 前回の旋回角は 90 deg   次の旋回角は 180 deg か ???	*/
		else if	( (dir_high & 0x07) == 0x04 ) {								}	/* そのままreturn	*/
		}
		/* 前回の 旋回角を調べる		前回の旋回角は 135 deg か ??? 	*/
	else if ( (dir_high_old & 0x07) == 0x03 ) {
					/* yes 前回の旋回角は 135 deg   次の区画は gool or start地点(走行end) か ???	*/
		if 		(dir_high == 0xff)					mark_distance= mark_distance- SUBD135 ;
					/* 前回の旋回角は 135 deg   次の旋回角は  45 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x01 ) {
													mark_distance= mark_distance- SUBD135 ;
													mark_distance= mark_distance- SUBD45 ; }
					/* 前回の旋回角は 135 deg   次の旋回角は  90 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 )		mark_distance= mark_distance- SUBD135 ;
					/* 前回の旋回角は 135 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 ) {
													mark_distance= mark_distance- SUBD135 ;
													mark_distance= mark_distance- SUBD135 ; }
					/* 前回の旋回角は 135 deg   次の旋回角は 180 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x04 )		mark_distance= mark_distance- SUBD135 ;
		}
		/* 前回の 旋回角を調べる		前回の旋回角は 180 deg か ??? 	*/
	else if ( (dir_high_old & 0x07) == 0x04 ) {
					/* yes 前回の旋回角は 180 deg   次の区画は gool or start地点(走行end) か ???	*/
		if 		(dir_high == 0xff) {										}	/* そのままreturn	*/
					/* 前回の旋回角は 180 deg   次の旋回角は  45 deg か ???	*/
		else if	( (dir_high & 0x07) == 0x01 )		mark_distance= mark_distance- SUBD45 ;
					/* 前回の旋回角は 180 deg   次の旋回角は  90 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 ) {								}	/* そのままreturn	*/
					/* 前回の旋回角は 90 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 )		mark_distance= mark_distance- SUBD135 ;
					/* 前回の旋回角は 180 deg   次の旋回角は 180 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x04 ) {								}	/* そのままreturn	*/
		}

		/*  走行 pulse数 補正終了 data 確認 	dataは マイナスになっていないか ???	*/
	if ( mark_distance <= 0x00)		mark_distance= 0x03	;	/* dataをプラスの値に補正する	*/
		/*  走行 pulse数 補正終了	走行pulse数に合わせて 加速 & 減速の pulse数を計算 setする 	*/
										/* 1/2 pulse 加速  -->  1/4 pluse 定常走行  -->  1/4 pulse 減速		*/
										/* 減速距離を 1/4 pluseに setし && 減速レートを 2倍に setする		*/
	accele_pulse= ( ((mark_distance+ 1)/2)- 20) ;	/* ( (x 区画 走行の pulse数)/2 )pulse 加速する	*/
		/* 加速パルス数を走行ルーチンで使うように直す	*/
	accele_pulse= mark_distance- accele_pulse ;		/* 加速パルス数 set	*/
	reduce_pulse= ( ((mark_distance+ 3)/4)+ 30 ) ;	/* ( (x 区画 走行の pulse数)/4 )+ 30 pulse手前から減速	*/
}



	/* 減速区間の走行可能なpulse数から、加速区間の走行可能なpulse数を計算setし、加速 & 減速 pulse数を計算 setする	*/
		/* 最大速度 10区画以上直進		5区画加速 --> 1+ x 区画定常走行 --> 3区画減速	*/
	/* return --------------------------------------------
				加速区間の走行パルス数 is mark_distance		補正前の加速区画の走行距離 --> 補正後の加速区画の走行距離
				加速パルス数			 is accele_pulse		補正後の加速パルス数
				減速区間の走行パルス数 is distance_reduce		補正前の減速区画の走行距離 --> 補正後の減速区画の走行距離
				減速パルス数			 is reduce_pulse_mem	補正後の減速パルス数			----------------------------*/
void calculate_accele_pulse_Max(void)	/* 加速区間の走行可能なpulse数を計算setし、加速 & 減速 pulse数も計算 setする	*/
{
		/* 加速区間の走行可能なpulse数を計算する	*/
		/* 前回の旋回角を調べる			前回の旋回角は 45 deg か ??? 	*/
	if		( (dir_high_old & 0x07) == 0x01 )			mark_distance= mark_distance- SUBD45 ;
		/* 	前回の旋回角は 135 deg か ??? 	*/
	else if	( (dir_high_old & 0x07) == 0x03 )			mark_distance= mark_distance- SUBD135 ;
		/* 前回の旋回角が 90 deg or 180 deg の場合は、走行距離のresetは必要無し 	*/
		/* 加速区間の走行パルス数(mark_distance) 計算終了*/
		/* 加速パルス数 仮記憶	*/
	accele_pulse= mark_distance ;	/* 加速パルス数 仮記憶	*/

		/* 加速区間の走行可能なpulse数の計算終了	減速可能なpulse数を計算する	*/
		/* 次の旋回角を調べる			次の旋回角は  45 deg か ???	*/
	if		( (dir_high & 0x07) == 0x01 )			distance_reduce= distance_reduce- SUBD45 ;
		/* 次の旋回角は 135 deg か ???	*/
	else if ( (dir_high & 0x07) == 0x03 )			distance_reduce= distance_reduce- SUBD135 ;
		/* 次の旋回角が 90 deg or 180 deg の場合は、走行距離のresetは必要無し 	*/
		/* 減速区間の走行パルス数(distance_reduce) 計算終了*/
		/* 減速パルス数 仮記憶	*/
	reduce_pulse= distance_reduce ;	/* 減速パルス数 仮記憶	*/

		/* 減速可能な走行pulse数から、加速pulse数を計算する									*/
		/*		加速pulse数 < (減速pulse数*2) ならば、減速pulse数が不足することは無い	*/
		/* 壁合わせによる位置調整のため、減速pulse数に、50pulseの余裕をあたえる				*/
	if ( accele_pulse > ((reduce_pulse* 2)+ 50) )			/* 加速pulse数が大きい		減速pulse数の2倍だけ加速する		*/
				accele_pulse= ( (reduce_pulse* 2)- 20 ) ;	/* 減速pulse数の2倍− 20pulse だけ加速する		*/
	else													/* 減速pulse数が大きい		加速pulse数の 1/2 倍だけ減速する	*/
				reduce_pulse= ( (accele_pulse/2)+ 30) ;		/* 加速pulse数の 1/2 倍+ 30pulse だけ減速する	*/

		/* 加速パルス数を走行ルーチンで使うように直す && 減速パルス数 記憶	*/
	accele_pulse= mark_distance- accele_pulse ;	/* 加速パルス数 set	*/
	reduce_pulse_mem= reduce_pulse ;	/* 減速パルス数 記憶 && 退避	*/
}


	/* slalome走行時   次の旋回角に合わせて、壁dataを読み込む位置を計算する	*/
void calc_sidewall_checkposition(void)		/* 次の旋回角に合わせて、壁dataを読み込む位置を計算する	*/
{				/* 走行pulse数は setしてあるので senserが 横壁を確実に見つけられる位置を計算、setする	*/
		/* 残りの走行pulse数を読み込む	*/
	distance_compare= position_now ;	/* 残りの走行pulse数を読み込む	*/

		/* 次の旋回角は 45 degか ???	*/
	if ( (dir_high & 0x07) == 0x01 ) {
			/* 残りの走行 pulse数は look_45よりも大きいか ???	*/
		if (distance_compare > LOOK45)			distance_compare= LOOK45 ;	/* 壁dataを確実に読める距離 set	*/
			/* 残りの走行 pulse数は look_45よりも小さい	*/
			/* distance_compare には、現在の残りの走行pulseが入っているので、そのまま retrun	*/
		}
		/* 次の旋回角は 90 degか ???	*/
	else if ( (dir_high & 0x07) == 0x02 ) {
			/* 残りの走行 pulse数は look_90よりも大きいか ???	*/
		if (distance_compare > LOOK90)			distance_compare= LOOK90 ;	/* 壁dataを確実に読める距離 set	*/
			/* 残りの走行 pulse数は look_90よりも小さい	*/
			/* distance_compare には、現在の残りの走行pulseが入っているので、そのまま retrun	*/
		}
		/* 次の旋回角は 135 degか ???	*/
	else if ( (dir_high & 0x07) == 0x03 ) {
			/* 残りの走行 pulse数は look_135よりも大きいか ???	*/
		if (distance_compare > LOOK135)			distance_compare= LOOK135 ;	/* 壁dataを確実に読める距離 set	*/
			/* 残りの走行 pulse数は look_135よりも小さい	*/
			/* distance_compare には、現在の残りの走行pulseが入っているので、そのまま retrun	*/
		}
		/* 次の旋回角は 180 degか ???	*/
	else if ( (dir_high & 0x07) == 0x04 ) {
			/* 残りの走行 pulse数は look_90よりも大きいか ???	*/
		if (distance_compare > LOOK90)			distance_compare= LOOK90 ;	/* 壁dataを確実に読める距離 set	*/
			/* 残りの走行 pulse数は look_90よりも小さい	*/
			/* distance_compare には、現在の残りの走行pulseが入っているので、そのまま retrun	*/
		}
}


		/* slalomの旋回角に対応して、壁合わせの後に走行する pulse数を計算、補正する	*/
void set_distance_CaptureCenter(void)	/* slalomの旋回角に対応して、壁合わせの後に走行する pulse数を補正する	*/
{
		/* 次の旋回角は 45 deg か ???	*/
	if		( (dir_high & 0x07) == 0x01 ) {
			if (position_now >= SUBD45)				position_now= position_now- SUBD45 ;
			else									position_now= 1 ;
		}
		/* 次の旋回角は  90 deg か ???	*/
			/* else if ( (dir_high & 0x07) == 0x02 ) {
			if (position_now >= SUBD90)				position_now= position_now- SUBD90 ;
			else									position_now= 1 ;
			}	*/
		/* 次の旋回角は 135 deg か ???	*/
	else if ( (dir_high & 0x07) == 0x03 ) {
			if (position_now >= SUBD135)			position_now= position_now- SUBD135 ;
			else									position_now= 1 ;
		}
		/* 次の旋回角は 180 deg か ???	*/
			/* else if ( (dir_high & 0x07) == 0x04 ) {
			if (position_now >= SUBD90)				position_now= position_now- SUBD90 ;
			else									position_now= 1 ;
		}	*/
}



	/* 走行速度に合わせて 早めに slalomeに進入するパルス数をset する	*/
			/*   position_nowには 壁をの切れ目を見つけてから(snser is off or on)進むパルス数がsetされている
				従って、このルーチンは壁合わせが終わってから callされる								*/
void subtract_pulse_set(void)	/* 走行速度に合わせて 早めに slalomeに進入するパルス数をset する	*/
{
		/* 走行パルス数は、早めにslalomeに進入するパルス数よりも大きいか ???	*/
	if ( (position_now- subtract_pulse) >= 5 )
								/* yes 走行パルス数は、早めにslalomeに進入するパルス数よりも大きい	*/
						position_now= (position_now- subtract_pulse) ;
	else						/* no 走行パルス数は、早めにslalomeに進入するパルス数よりも小さい	*/
								/* 走行パルス数が マイナスにならないように最小のdataをset	*/
						position_now= 5 ;
}

/*==================================================================================================*/
/*			加減速パルス数や走行パルス数を計算 & 代入		No_2 斜め走行    						*/
/*==================================================================================================*/

	/* 【注意】 斜め走行では、危険度を考慮して、走行速度を定常走行の 70%の速度に抑える
					定常走行の1区画は 180mm、斜め走行の1区画は 127mm
					従って、同じ区画数を加速すれば 70%の速度になる					*/
	/* slalom 斜め直進走行の走行の走行pulse数 set	*/
void set_aslant_distance(void)	/* slalom 斜め直進走行の走行の走行pulse数 set	*/
{
			/* 【注意】	dir_high & dir_high_old の旋回角は、(route_map_data+ 1)が setされている	*/
			/*				dir_high is  次の   旋回方向 & 旋回角								*/
			/* 				dir_high_old is 前回の  旋回方向 & 旋回角								*/
			/* 【注意】迷路の特性上、斜め走行 --> goal という走行パターンは存在しない	*/
		/* 前回の旋回角を調べる		前回の旋回角は 45 deg か ??? 	*/
	if ( (dir_high_old & 0x07) == 0x01 ) {
					/* 前回の旋回角は 45 deg   次の旋回角は  45 deg か ???	*/
		if 		( (dir_high & 0x07) == 0x01 ) {							}	/* そのままreturn	*/
					/* 前回の旋回角は 45 deg   次の旋回角は  90 deg か ???	*/
		else if	( (dir_high & 0x07) == 0x02 )		mark_distance= mark_distance- SUBD90 ;
					/* 前回の旋回角は 45 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 ) {							} /* そのままreturn	*/
					/* 前回の旋回角は 45 deg   次の旋回角は 180 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 )
				/* 斜め走行 --> 180 deg turn  -->  斜め走行 の 走行パターンは 迷路の特性上ありえない	*/
													mark_distance= 0x00 ; /* data miss	*/
		}
		/* 前回の旋回角を調べる		前回の旋回角は 90 deg か ??? 	*/
	else if ( (dir_high_old & 0x07) == 0x02 ) {
				/* 前回の旋回角は 90 deg   次の旋回角は  45 deg か ???	*/
		if ( (dir_high & 0x07) == 0x01 )			mark_distance= mark_distance- SUBD90 ;
				/* 前回の旋回角は 90 deg   次の旋回角は  90 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 ) {
													mark_distance= mark_distance- SUBD90 ;
													mark_distance= mark_distance- SUBD90 ; }
				/* 前回の旋回角は 90 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 )		mark_distance= mark_distance- SUBD90 ;
				/* 前回の旋回角は 90 deg   次の旋回角は 180 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 )
				/* 斜め走行 --> 180 deg turn  -->  斜め走行 の 走行パターンは 迷路の特性上ありえない	*/
													mark_distance= 0x00 ; /* data miss	*/
		}
		/* 前回の旋回角を調べる		前回の旋回角は 135 deg か ??? 	*/
	else if ( (dir_high_old & 0x07) == 0x03 ) {
						/* 前回の旋回角は 135 deg   次の旋回角は  45 deg か ???	*/
		if 		( (dir_high & 0x07) == 0x01 ) {									}	/* そのまま return	*/
					/* 前回の旋回角は 135 deg   次の旋回角は  90 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x02 )		mark_distance= mark_distance- SUBD90 ;
						/* 前回の旋回角は 135 deg   次の旋回角は 135 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x03 ) {									}	/* そのまま return	*/
					/* 前回の旋回角は 135 deg   次の旋回角は 180 deg か ???	*/
		else if ( (dir_high & 0x07) == 0x04 )
				/* 斜め走行 --> 180 deg turn  -->  斜め走行 の 走行パターンは 迷路の特性上ありえない	*/
													mark_distance= 0x00 ; /* data miss	*/
		}
		/* 前回の旋回角を調べる		前回の旋回角は 180 deg か ??? 	*/
	else if ( (dir_high_old & 0x07) == 0x01 ) {
				/* slalom では 180 deg turn の連続は存在するが  斜め走行 --> 180 deg turn  -->  斜め走行 の
																 走行パターンは 迷路の特性上ありえない			*/
													mark_distance= 0x00 ; /* data miss	*/
		}

		/*  走行 pulse数 reset終了	dataは マイナスになっていないか ???	*/
	if ( mark_distance <= 0x00)						mark_distance= 0x03	;	/* dataをプラスの値に補正する	*/
		/*  走行 pulse数 補正終了	走行pulse数に合わせて 加速 & 減速の pulse数を計算 setする 	*/
										/* 1/2 pulse 加速  -->  1/4 pluse 定常走行  -->  1/4 pulse 減速		*/
										/* 減速距離を 1/4 pluseに setし && 減速レートを 2倍に setする		*/
	accele_pulse= ( ((mark_distance+ 1)/2)- 20) ;	/* ( (x 区画 走行の pulse数)/2 )pulse 加速する	*/
		/* 加速パルス数を走行ルーチンで使うように直す	*/
	accele_pulse= mark_distance- accele_pulse ;		/* 加速パルス数 set	*/
	reduce_pulse= ( ((mark_distance+ 3)/4)+ 30 ) ;	/* ( (x 区画 走行の pulse数)/4 )+ 30 pulse手前から減速	*/
}


	/* 減速区間の走行可能なpulse数から、加速区間の走行可能なpulse数を計算setし、加速 & 減速 pulse数を計算 setする	*/
		/* 最大速度 10区画以上直進		5区画加速 --> 1+ x 区画定常走行 --> 3区画減速	*/
	/* return --------------------------------------------
				加速区間の走行パルス数 is mark_distance		補正前の加速区画の走行距離 --> 補正後の加速区画の走行距離
				加速パルス数			 is accele_pulse		補正後の加速パルス数
				減速区間の走行パルス数 is distance_reduce		補正前の減速区画の走行距離 --> 補正後の減速区画の走行距離
				減速パルス数			 is reduce_pulse_mem	補正後の減速パルス数			----------------------------*/
void calculate_aslant_accele_Max(void)	/* 斜め走行最大速度時 走行pulse数に合わせて 加速 & 減速の pulse数を計算 setする	*/
{
		/* 【注意】斜め走行時の 45 deg旋回と 135 deg旋回のstart位置と終了位置、区画の境界位置と一致するが	*/
		/* 				90deg旋回(v_turn)だけは、26.5mm境界の内側に入り込む									*/

		/* 斜め走行時の加速区間の走行可能なpulse数を計算する	*/
		/* 前回の旋回角を調べる			前回の旋回角は 90 deg か ??? 	*/
	if ( (dir_high_old & 0x07) == 0x02 )			mark_distance= mark_distance- SUBD90 ;
		/* 斜め走行時は、前回の旋回角が 45 deg or 135 deg の場合は、走行距離のresetは必要無し 	*/
		/* 加速区間の走行パルス数(mark_distance) 計算終了*/
		/* 加速パルス数 仮記憶	*/
	accele_pulse= mark_distance ;	/* 加速パルス数(実際に加速するパルス数) 仮設定	*/

		/* 斜め走行時の加速区間の走行可能なpulse数の計算終了	減速可能なpulse数を計算する	*/
		/* 次の旋回角を調べる			次の旋回角は 90 deg か ???	*/
	if ( (dir_high & 0x07) == 0x02 )			distance_reduce= distance_reduce- SUBD90 ;
		/* 斜め走行時は、次の旋回角が 45 deg or 135 deg の場合は、走行距離のresetは必要無し 	*/
		/* 減速区間の走行パルス数(distance_reduce) 計算終了*/
		/* 減速パルス数 仮記憶	*/
	reduce_pulse= distance_reduce ;	/* 減速パルス数 仮記憶	*/

	/* 減速可能な走行pulse数から、加速pulse数を計算する									*/
	/*		加速pulse数 < (減速pulse数*2) ならば、減速pulse数が不足することは無い	*/
	/* 壁合わせによる位置調整のため、減速pulse数に、50pulseの余裕をあたえる				*/
	if ( accele_pulse > ((reduce_pulse* 2)+ 50) )			/* 加速pulse数が大きい		減速pulse数の2倍だけ加速する		*/
				accele_pulse= ( (reduce_pulse* 2)- 20 ) ;	/* 減速pulse数の2倍− 20pulse だけ加速する		*/
	else													/* 減速pulse数が大きい		加速pulse数の 1/2 倍だけ減速する	*/
				reduce_pulse= ( (accele_pulse/2)+ 30) ;		/* 加速pulse数の 1/2 倍+ 30pulse だけ減速する	*/

		/* 加速パルス数を走行ルーチンで使うように直す		*/
	accele_pulse= mark_distance- accele_pulse ;	/* 加速パルス数 set	*/
	reduce_pulse_mem= reduce_pulse ;	/* 減速パルス数 記憶 && 退避	*/
}



	/* displacement of running line		斜め走行の出口で、走行斜線を旋回方向の反対側に移動させる	*/
void displace_running_line(void)	/* displacement of running line		斜め走行の出口で、旋回方向の反対側に移動させる	*/
{
											/* 旋回方向 data		Left_turn is  xx11-xxxx
																	Right_turn is xx10-xxxx		*/
	/* 次の旋回方向を調べる  (dir_high) is 旋回方向 & 旋回角	*/
		/* 次の旋回方向は、右旋回か ???	*/
	if ( (dir_high & 0x20) == 0x20 ) {
			/* yes 次の旋回方向は 右   mouseを 左に寄せる	*/
		ITU1.GRA= ITU1.GRA+ 5 ;		/* channel_1 Left_motor is speed down	*/
		ITU0.GRA= ITU0.GRA- 5 ;		/* channel_0 Right_motor is speed up	*/
		}
		/* 次の旋回方向は、左旋回か ???	*/
	else if ( (dir_high & 0x30) == 0x30 ) {
			/* yes 次の旋回方向は 左   mouseを 右に寄せる	*/
		ITU1.GRA= ITU1.GRA- 5 ;		/* channel_1 Left_motor is speed up		*/
		ITU0.GRA= ITU0.GRA+ 5 ;		/* channel_0 Right_motor is speed down	*/
		}
}




 3)メインルーチン  
 人それぞれに走り方はある、人それぞれに調整のやり方はある。参考にならないだろうが、これが私の方法。
 自作迷路用のデータは私の迷路専用だが、取り外すのも面倒なので入れてある。以下のプログラムのとおり。

/* program_name  "mouse.c"													 made by k.notoya		*/
/*							山形支部標準マウス メインプログラム										*/
/*																last edit 1998/09/10	k.notoya	*/

	/* CPUmode is mode_7	*/
#include "d:\H83048File\3048f.h"		/* MCR版 H8cpu のレジスタを定義したヘッダファイル	*/
	/* #include "d:\H83048File\machine.h"	*/	/* 割り込み設定 etc	*/
#include "d:\H83048File\stdio.h"		/* H8 standerd I/O hedder	*/

#include "d:\standardDef.h"	/* 標準的な定数data & インターフェイス・制御系のマクロ		*/
#include "d:\constant.h"		/* 定数data (走行速度、走行距離、姿勢制御量)		*/
#include "d:\global.h"			/* 全モジュール共通 広域変数						*/
	/* #include "d:\mouselib.h"	*/		/* マイクロマウスのための関数のプロトタイプ宣言		*/


void front_walldata_indicate(void) ;	/* 前壁data 表示	*/
void side_walldata_indicate(void) ;	/* 横壁data 表示	*/
void side_wall_data_init(void) ;	/* 横壁データの最大値、中央値、最小値を記憶する		*/
void front_wall_data_init(void) ;	/* 前壁データを記憶する		センサ分解能 1.5167mm	*/
void reset_side_wall_data(void) ;	/* start時に、横壁データの中央値を resetする	*/
void start_position_set(void) ;		/* start位置を迷路の中央に合わせる	*/
void temporary_wall_data_set(void) ;	/* 壁dataを仮設定	*/
void emergency_teratment(void) ; 	/* 緊急停止後の処理(再初期化)	*/
void main(void) ;


	/* 前壁dataを 表示する	*/
void front_walldata_indicate(void)	/* 前壁data 表示	*/
{
		rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;	/* 最初は 2行空ける	*/
	rs_send_sentence("\r\n"
			"            ---------------  ATTENTION  --------------                     \r\n"
			"          if start switch is pushed then Front_wall data indicate          \r\n"
			) ;
		rs_send_sentence("\r\n") ;	/* 1行 空ける	*/

	push_sw_with_led() ;	/* LED を brinkしながら、push_switchの入力を待つ	*/
		led_blink() ;		/* LEDを3回点滅させる	*/

		/* 前壁data 最小値 表示	*/
	rs_send_sentence("     left_front_min         right_front_min      ") ;	rs_send_sentence("\r\n") ;
		rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_front_min) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_front_min) ) ;
		rs_send_sentence("\r\n") ;	/* 1行 空ける	*/

		/* 前壁data 中央値 表示	*/
	rs_send_sentence("     left_front_mid         right_front_mid      ") ; rs_send_sentence("\r\n") ;
		rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_front_mid) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_front_mid) ) ;
		rs_send_sentence("\r\n") ;	/* 1行 空ける	*/

		/* 前壁data 最大値 表示	*/
	rs_send_sentence("     left_front_max         right_front_max      ") ; rs_send_sentence("\r\n") ;
		rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_front_max) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_front_max) ) ;
		rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;	/* 最後は 2行空ける	*/
}


	/* 横壁dataを 表示する	*/
void side_walldata_indicate(void)	/* 横壁data 表示	*/
{
		rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;	/* 最初は 2行空ける	*/
	rs_send_sentence("\r\n"
	"            ---------------  ATTENTION  --------------                     \r\n"
	"          if start switch is pushed then Side_wall data indicate           \r\n"
	) ;
		rs_send_sentence("\r\n") ;	/* 1行 空ける	*/
	push_sw_with_led() ;	/* LED を brinkしながら、push_switchの入力を待つ	*/
		led_blink() ;		/* LEDを3回点滅させる	*/

		/* 左横壁 最大値 & 右横壁 最小値 表示	*/
	rs_send_sentence("     left_side_min          right_side_min       ") ; rs_send_sentence("\r\n") ;
		rs_send_sentence("     ") ;	/* 表示の位置合わせ	*/
	Hex16DeciSend( (unsigned short int )(left_side_min) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_side_min) ) ;
		rs_send_sentence("\r\n") ;	/* 1行 空ける	*/

		/* 左横壁 & 右横壁 中央値 表示	*/
	rs_send_sentence("     left_side_mid          right_side_mid       ") ; rs_send_sentence("\r\n") ;
		 rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_side_mid) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_side_mid) ) ;
		rs_send_sentence("\r\n") ;

		/* 左横壁 最小値 & 右横壁 最大値 表示	*/
	rs_send_sentence("     left_side_max          right_side_max      ") ; rs_send_sentence("\r\n") ;
		 rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_side_max) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_side_max) ) ;
		rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;	/* 最後は 2行空ける	*/
}


	/* 停止状態で、横壁データの最大値、中央値 & 最小値を記憶する		*/
void side_wall_data_init(void)	/* 横壁データの最大値、中央値、最小値を記憶する		*/
{								/* 最初は左壁の最大値と右壁の最小値を入力	*/
		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電力 停止	*/

	rs_send_sentence("\r\n"
	"            ---------------  attention  --------------                     \r\n"
	"                   Side_wall data initialize without running               \r\n"
	"          *******************************************************          \r\n"
	) ;
		/* データ入力開始 シグナル	*/
	data_read_start_sig() ;	/* データ入力開始 シグナル	*/

		/* 左壁横の最大値と右横壁の最小値を設定する	*/
	push_sw_led_Left() ;	/* 左壁横の最大値と右横壁の最小値を設定する シグナル	*/
	led_blink() ;			/* LEDを3回点滅させる		*/
			/* 左横壁  最大値  left_side_max 設定	*/
				/*	left_side_max= analog[LEFT_SIDE] ;		*/
	left_side_max= (int )(adcread_Phot(LEFT_SIDE) ) ;
			/* 右横壁  最小値  right_side_min 設定		*/
	right_side_min= (int )(adcread_Phot(RIGHT_SIDE) ) ;
		/* 左壁横の最大値 & 右横壁の最小値を表示	*/
	rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;	/* 最初は、2行空ける	*/
	rs_send_sentence("     left_side_max          right_side_min       ") ; rs_send_sentence("\r\n") ;
		rs_send_sentence("     ") ;		/* 表示の位置合わせ	*/
	Hex16DeciSend( (unsigned short int )(left_side_max) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_side_min) ) ;
		rs_send_sentence("\r\n") ;		/* 1行 空ける	*/
		/* 左壁横 最大値 & 右横壁 最小値	 設定終了	*/
	data_read_end_sig() ;	/* データ入力終了 シグナル	*/

/*-------------------
							 この間にマウスを移動させる
																---------------*/
		/* 左壁横と右横壁の中央値を設定する	*/
			/*	data_read_start_sig() ;	*/	/* データ入力開始 シグナル	*/
	push_sw_led_Center() ;	/* 左壁横と右横壁の中央値を設定するシグナル	*/
	led_blink() ;			/* LEDを3回点滅させる	*/
			/* 左横壁  中央値  left_side_mid 設定	*/
	left_side_mid=  (int )(adcread_Phot(LEFT_SIDE) ) ;
			/* 右横壁  中央値  right_side_mid 設定		*/
	right_side_mid=  (int )(adcread_Phot(RIGHT_SIDE) ) ;
		/* 左壁横 & 右横壁の中央値を表示	*/
	rs_send_sentence("     left_side_mid          right_side_mid       ") ; rs_send_sentence("\r\n") ;
		 rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_side_mid) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_side_mid) ) ;
			rs_send_sentence("\r\n") ;
		/* 左壁横 中央値 & 右横壁 中央値	 設定終了	*/
	data_read_end_sig() ;	/* データ入力終了 シグナル	*/

/*-------------------
							 この間にマウスを移動させる
																	---------------*/
		/* 左壁横の最小値と右横壁の最大値を設定する	*/
			/*	data_read_start_sig() ;		*/	/* データ入力開始 シグナル	*/
	push_sw_led_Right() ;	/* 左壁横の最小値と右横壁の最大値を設定するシグナル	*/
	led_blink() ;			/* LEDを3回点滅させる	*/
		/* data転送	*/
			/* 左横壁  最小値  left_side_min 設定	*/
	left_side_min= (int )(adcread_Phot(LEFT_SIDE) ) ;
			/* 右横壁  最大値  right_side_max 設定		*/
	right_side_max= (int )(adcread_Phot(RIGHT_SIDE) ) ;
		/* 左壁横の最小値 & 右横壁の最大値を表示	*/
	rs_send_sentence("     left_side_min          right_side_max      ") ; rs_send_sentence("\r\n") ;
		 rs_send_sentence("     ") ;
	Hex16DeciSend( (unsigned short int )(left_side_min) ) ; rs_send_sentence("                    ") ;
	Hex16DeciSend( (unsigned short int )(right_side_max) ) ;
		rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;	/* 最後は2行 空ける	*/
		/* 左壁横 最小値 & 右横壁 最大値  設定終了	*/
	data_read_end_sig() ;	/* データ入力終了 シグナル	*/
}


	/* 前壁データを記憶する		*/
void front_wall_data_init(void)	/* 前壁データを記憶する		*/
{
	SSHORT counter ;	/* 走行距離 counter	*/

		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

	rs_send_sentence("\r\n"
	"            ---------------  attention  --------------                     \r\n"
	"                   Front_wall data initiialize with running                \r\n"
	"          *******************************************************          \r\n"
	) ;

		/* 変数とフラグを初期化	*/
	map_renewal= SLEEP ;		/* if map_renewal is WAKE then 迷路地図を更新する		*/
	deside_flag= SLEEP ;		/* if deside_flag is WAKE then call deside direction	*/
	running_condition= HALT ;	/* mouseは停止していた	*/
	turn_direction= STRAIGHT ;	/* mouseは直進する	*/
	accele_condition= ACCELE ; 	/* 速度flag reset	*/

		/* 前壁data読み込み シグナル		*/
	data_read_start_sig() ;	/* データ入力開始 シグナル	*/
	led_blink() ;			/* LEDを3回点滅させる	*/

	/* mouseが後退するので、loopを使って(割り込みを使わない)走行する	*/
		/* SLA7033 PWM基準電圧設定		*/
	current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
	power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
		/* 走行距離設定		1−2相励磁 250mm 後退		250mm/0.41mm= 609.7パルス	*/
	for ( counter= 610; counter >= 0; counter= counter- 1 )
		{
			/* 左motor励磁data adress 更新	*/
		if ( Left_Reiji > 0 )				Left_Reiji= Left_Reiji- 1 ;
		else								Left_Reiji= 7 ;
			/* 右motor励磁data adress 更新	*/
		if ( Right_Reiji > 0 )				Right_Reiji= Right_Reiji- 1 ;
		else								Right_Reiji= 7 ;

			/* motor駆動信号出力 poat_B	*/
				/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
		PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
			/* 後退の速度を設定(時間稼ぎの無駄演算) */
		wait(3000) ;	/* 後退の速度を設定(時間稼ぎの無駄演算) */
		}

		/* mouseは設定距離を走行した		前進方向に励磁する	*/
	long_wait(10,10000) ;
		/* 励磁data 更新 前進方向に励磁する	*/
	Left_Reiji= Left_Reiji+ 1 ;	/* 前進方向に励磁する	*/
	Right_Reiji= Right_Reiji+ 1 ;
		/* motor駆動信号出力 poat_B	*/
			/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
	PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
		long_wait(50,10000) ;
		/* SLA7033 PWM基準電圧設定		*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/
	led_blink() ;	/* LEDを3回点滅させる	*/

/*-------------------------------------------
		前進しながら、前壁dataを読みこむ
												-------------------------------------------------------*/
		/* 変数とフラグを初期化	*/
	map_renewal= WAKE ;		/* if map_renewal is WAKE then 迷路地図を更新する		*/
	deside_flag= WAKE ;		/* if deside_flag is WAKE then call deside direction	*/
	running_condition= HALT ;	/* mouseは停止していた		*/
	turn_direction= STRAIGHT ;	/* mouseは直進する	*/
	accele_condition= ACCELE ; 		/* 速度flag    reset	*/

		/* 走行距離設定		1−2相励磁 250mm 後退		250mm/0.41mm= 609.7パルス	*/
	mark_distance= 610 ;			/* 基本走行パルス数 set(error_pulseによる補正)	*/
	position_now= mark_distance ;	/* position_now is ダウン・カウント(残りの走行パルス数)	*/
		/* 走行速度設定	& 加減速rate reset	*/
	accele_pulse= ( mark_distance- 30 ) ;	/* 加速パルス数 set	*/
	reduce_pulse= 45 ;						/* 減速パルス数 set  加速パルス数の1/2パルス 減速する	*/
		/* mouse の走行速度を設定する	*/
	speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
	adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
		/* SLA7033 PWM基準電圧設定		*/
	current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/

	power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
		/* 全割り込み、マスク解除	*/
	interrupt_control(WAKE) ;	/* 割り込み 禁止 or 許可	*/
		/* センサ入力start & 姿勢制御 禁止	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/

		/* 設定距離を走る	250mm(610パルス) 前進 */
			/* 前壁データ基準値 設定	*/
				/* 車軸中心から先端までの長さ		約 65mm	*/
				/* 前壁の有無			(180mm+ 45mm)- 65mm is 160mm		160mm/0.41mm 390.2 パルスの位置	*/
				/* スラローム進入位置		(180mm-  6mm)- 65mm is 109mm		109mm/0.41mm 265.9 パルスの位置	*/
				/* 迷路の中心(緊急停止)	( 90mm-  6mm)- 65mm is  19mm		 19mm/0.41mm  39.0 パルスの位置	*/
	while (position_now >= 5) {
		/* 前壁dataを 入力する	*/
			/* 前壁判定位置		*/
		if (position_now >= 400) {
										left_front_min= analog[LEFT_FRONT] ;
										right_front_min= analog[RIGHT_FRONT] ; }
			/* slalom 侵入位置	*/
		else if (position_now >= 266) {
										left_front_mid= analog[LEFT_FRONT] ;
										right_front_mid= analog[RIGHT_FRONT] ; }
			/* 絶対停止位置(迷路の中心)	*/
		else if (position_now >=  39) {
										left_front_max= analog[LEFT_FRONT] ;
										right_front_max= analog[RIGHT_FRONT] ; }

			/* 走行中に前壁のdataを転送する	*/
		rs_send_sentence("     position_now           left_front             right_front          ") ;
			rs_send_sentence("\r\n") ;		/* 1行の終わり	*/
		rs_send_sentence("     ") ;
		Hex16DeciSend( (unsigned short int )(position_now) ) ;	/* position_now is 残りの走行パルス数	*/
			rs_send_sentence("                    ") ;
		Hex16DeciSend( (unsigned short int )(analog[LEFT_FRONT]) ) ;	/* 左・前壁data	*/
			rs_send_sentence("                    ") ;
		Hex16DeciSend( (unsigned short int )(analog[RIGHT_FRONT]) ) ;	/* 右・前壁data	*/
		rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;
		}

		/* 設定距離を走行した		マウスを止める	*/
	distance_compare= 0x00 ;	/* distance_compare is 残りの走行距離	*/
	count_distance() ;			/* mouseは設定距離を走行する	*/
		/* センサ入力 停止 & 姿勢制御 禁止	*/
	revision_control(SLEEP) ;	/* センサ入力 停止 & 姿勢制御 禁止	*/
		/* 設定距離を走行した		マウスを止める	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止 or 許可	*/
	ifrray_off() ;	/* 赤外LED 発光停止				*/
	led(0x00) ;		/* インターフェイス LED cut off		*/

		/* mouseは停止した	慣性が消えるまで待つ	*/
	long_wait(10,10000) ;
	reverse() ;		/* 進行方向(旋回方向)と反対向きに励磁し、強制的に停止させる	*/
		long_wait(90,10000) ;
		/* SLA7033 PWM基準電圧設定		*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 前壁data 設定終了  		*/
	data_read_end_sig() ;	/* データ入力終了 シグナル	*/
	led_blink() ;			/* LEDを3回点滅させる	*/
}


	/* start時に、横壁データの中央値を resetする	*/
void reset_side_wall_data(void)	/* start時に、横壁データの中央値を resetする	*/
{
	unsigned char i,j ;

		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 左壁横と右横壁の中央値を設定するシグナル	*/
	for (i= 0x00 ; i < 3; i++) {
		for( j=0; j<10; j++ ) {
			led(led_Center[j]) ;
			long_wait(5,10000) ; }
		}

		/* 左壁横と右横壁の中央値を設定する	*/
			/* 左横壁  中央値  left_side_mid 設定	*/
	left_side_mid=  (int )(adcread_Phot(LEFT_SIDE) ) ;
		long_wait(10,10000) ;
			/* 右横壁  中央値  right_side_mid 設定		*/
	right_side_mid=  (int )(adcread_Phot(RIGHT_SIDE) ) ;
		led_blink() ;	/* LEDを3回点滅させる		*/
		/* 左壁横と右横壁の中央値を設定する	*/
			/* 左横壁  中央値  left_side_mid 設定	*/
	left_side_mid=  (int )(adcread_Phot(LEFT_SIDE) ) ;
		long_wait(10,10000) ;
			/* 右横壁  中央値  right_side_mid 設定		*/
	right_side_mid=  (int )(adcread_Phot(RIGHT_SIDE) ) ;


		/* データ入力終了 シグナル	*/
	for (i= 0x00 ; i < 3; i++) {
		led(0x03) ;
			long_wait(25,10000) ;	/* 時間待ちの無駄演算	*/
		led(0xc0) ;
			long_wait(25,10000) ;
		}
}


	/* start位置を迷路の中央に合わせる	*/
void start_position_set(void)	/* start位置を迷路の中央に合わせる	*/
{
	SSHORT counter ;	/* 走行距離 counter	*/

		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 変数とフラグを初期化	*/
	map_renewal= SLEEP ;		/* if map_renewal is WAKE then 迷路地図を更新する		*/
	deside_flag= SLEEP ;		/* if deside_flag is WAKE then call deside direction	*/
	running_condition= HALT ;	/* mouseは停止していた		*/
	turn_direction= STRAIGHT ;	/* mouseは直進する	*/
	accele_condition= ACCELE ;	/* 速度flag    reset	*/

	/* mouseが後退するので、loopを使って(割り込みを使わない)走行する	*/
		/* SLA7033 PWM基準電圧設定		*/
	current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
	power(WAKE) ;	/* 操舵用及び駆動用 電流制御	*/
		/* 走行距離設定		1−2相励磁  10mm 後退		10mm/0.41mm=  24.39パルス	*/
	for ( counter= 25; counter >= 0; counter= counter- 1 )
		{
			/* 左motor励磁data adress 更新	*/
		if ( Left_Reiji > 0 )				Left_Reiji= Left_Reiji- 1 ;
		else								Left_Reiji= 7 ;
			/* 右motor励磁data adress 更新	*/
		if ( Right_Reiji > 0 )				Right_Reiji= Right_Reiji- 1 ;
		else								Right_Reiji= 7 ;

			/* motor駆動信号出力 poat_B	*/
				/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
		PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
			/* 後退の速度を設定(時間稼ぎの無駄演算) */
		wait(3000) ;	/* 後退の速度を設定(時間稼ぎの無駄演算) */
		}

		/* mouseは設定距離を走行した		前進方向に励磁する	*/
	long_wait(10,10000) ;
		/* 励磁data 更新 前進方向に励磁する	*/
	Left_Reiji= Left_Reiji+ 1 ;	/* 前進方向に励磁する	*/
	Right_Reiji= Right_Reiji+ 1 ;
		/* motor駆動信号出力 poat_B	*/
			/* 左motor  bit 7 <-- bit 4				右motor bit 3 <-- bit 0	*/
	PB.DR.BYTE= ( (reiji_L12[Left_Reiji] & 0xf0) | (reiji_R12[Right_Reiji] & 0x0f) ) ;
		long_wait(50,10000) ;
		/* SLA7033 PWM基準電圧設定		*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/
	led_blink() ;	/* LEDを3回点滅させる	*/

	/* 【注意】次の1歩目を設定距離よりも多く走り、迷路の中心で止まらない	*/
		/* 迷路の中心まで前進するパルス数を設定(走行距離に加算するパルス数)	*/
	error_pulse= CENTER_ADJUST ;	/* mouseの後端が壁に接触した位置から、前進するパルス数	*/
		/* 走行準備完了の合図をする	*/
	led_blink() ;	/* LEDを3回点滅させる	*/
	led(0x00) ;		/* all led cut_off	*/
}


	/* 壁dataを仮設定	*/
void temporary_wall_data_set(void)	/* 壁dataを仮設定	*/
{
		/* 右・横壁dataを仮設定	*/
	right_side_max= Right_Side_MAX, right_side_mid= Right_Side_MID, right_side_min= Right_Side_MIN ;
		/* 右・前壁dataを仮設定	*/
	right_front_max= Right_Front_MAX, right_front_mid= Right_Front_MID, right_front_min= Right_Front_MIN ;
		/* 左・前壁dataを仮設定	*/
	left_front_max= Left_Front_MAX, left_front_mid= Left_Front_MID, left_front_min= Left_Front_MIN ;
		/* 左・横壁dataを仮設定	*/
	left_side_max= Left_Side_MAX, left_side_mid= Left_Side_MID, left_side_min= Left_Side_MIN ;
}


	 	/* 緊急停止後の処理(再初期化)	*/
void emergency_teratment(void) 	/* 緊急停止後の処理(再初期化)	*/
{
	char escape ;	/* A/D.C channel 退避エリア	*/

		/* 初期設定		*/
			/* H8cpu_init() ;	*/		/* H8cpu 初期化	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/

		/* 座標の初期化		緊急停止をしたので、座標と方向を reset する	*/
	axis= 0x00 ;	/* mouse は start 地点に戻った	*/
	dir= 0x00 ;		/* mouse の 現在の絶対方向は 北	*/
	axis_x= 0x00 ;	/* 未探査の座標は start地点の座標に仮設定		*/
	dir_x= 0x00 ;	/* 未探査の座標のmouseの絶対方向は 北 に仮設定	*/

/*	crisis() ;	*/	/* 探査中に走行に失敗したときの処理		*/

		/* 変数とフラグを初期化	*/
			/* turn_direction= STRAIGHT ;	*/	/* mouseは直進する	*/
			/* turn_direction= SPIN_LEFT ;		*/	/* 旋回方向は左		*/
			/* turn_direction= SPIN_RIGHT ;		*/	/* 旋回方向は右		*/
			/* turn_direction= REVERS_SPIN ;		*/	/* 右180度 反転	*/
			/* map_renewal= WAKE ;	*/	/* if map_renewal is WAKE then 迷路地図を更新する		*/
			/* deside_flag= WAKE ;	*/	/* if deside_flag is WAKE then call deside direction	*/
	accele_condition= ACCELE ; 	/* 速度flag    reset	*/
	running_condition= HALT ;	/* mouseは停止していた	*/
		/* mouse の走行速度を設定する	*/
	speed_select= speed_0 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
	adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/

		/* ウオッチドッグタイマ OVFflag reset	*/
	escape= TCSRR ;		/* TCSR 下位 8bit data 読み込み	*/
	escape= escape & 0x7f ;	/* 0x7f is 0xxx-xxxx	OVF flag cls	*/
	TCSRW= ( 0xa500 | ((int )escape) ) ;	/* 0xa5xx is TCSR 制御語	*/
		/*	TCSRW= ( 0xa500 | ((int )( (TCSRR & 0x7f) )) ) ;	*/	/* 0xa5xx is TCSR 制御語	*/
	led(0x00) ;
}



void main(void)
{
	UCHAR i,j ;
	UCHAR channel ;
	unsigned int counter, counter2 ;
	unsigned int result ;	/* 変換結果格納用変数	*/

		/* 初期設定	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/
		/* H8cpu 初期化		*/
	H8cpu_init() ;	/* H8cpu 初期化 & ITUタイマstart	*/
	revision_control(SLEEP) ;	/* 姿勢制御 禁止	*/
	interrupt_control(SLEEP) ;	/* 割り込み 禁止	*/
	ifrray_off() ;	/* 赤外LED 発光停止		*/
	led(0x00) ;		/* インターフェイス LED cut off	*/
	power(SLEEP) ;	/* 操舵用及び駆動用 電流制御	*/
		/* mouse の走行速度を設定する	*/
	speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
	adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
		/* 励磁data(励磁パターン)配列を、ルーチンの最初に、1回だけ初期化する	*/
	Right_Reiji= 0 ;	/* 励磁data配列変数の添字を、初期値(0x00)に戻す	*/
	Left_Reiji= 0 ;

		/* CPUモードの表示 & シリアル通信 作動確認 	*/
	rs_send_sentence("\r\n") ;	rs_send_sentence("\r\n") ;
	rs_send_sentence("     CPU mode is      ") ;
	Hex16DeciSend( (unsigned short int )(MDCR.BYTE & 0x07) ) ;	/* 16bit binary --> ASCII --> 転送		*/
		rs_send_sentence("\r\n") ;		/* 1行の終わり	*/
		/* INT dataのバス幅 確認	*/
	rs_send_sentence("     INT data size is ") ;
	Hex16DeciSend( (unsigned short int )(sizeof(int)) ) ;
	rs_send_sentence("  byte( 1 byte is 8 bit)  ") ;
		rs_send_sentence("\r\n"), send_end() ;		/* 1行の終わり	& 1行 空ける	*/
	preparation_communicat() ;		/* シリアル通信 作動確認	*/
		/* 初期化 終了		H8cpu 作動 準備完了		start_switchの入力を待つ	*/
	push_sw_with_led() ;	/* LED を brinkしながら、push_switchの入力を待つ	*/
	led_blink() ;			/* LEDを3回点滅させる	*/

		/* 走行mode 表示 & 確認	*/
			/* led(mode&0x0f) ;		*/	/* 走行mode 表示	*/
	led( (dip_switch()&0x0f) ) ;	/* 走行mode 表示	*/
	do {
		wall_data_indication(0x06) ;	/* 前壁data indication LED		-----x11x	*/
			long_wait(20,10000) ;
		wall_data_indication(0x09) ;	/* 横壁data indication LED		-----1xx1	*/
			long_wait(20,10000) ;
		} while  ( push_switch() != WAKE ) ;
	wall_data_indication(0x00) ;	/* wall_data indication LED		cut_off	*/
	led(0x00) ;		/* 走行mode 表示 end	インターフェイス LED cut off	*/

		/* 走行開始		無限loop	*/
	for (;;) {
			/* 走行準備 完了	dip_switch のdata確認	*/
		push_sw_with_led() ;	/* LED is blink for push_sw on	*/
		led_blink() ;			/* LEDを3回点滅させる		*/

		switch ( (dip_switch()&0x0f) )	/* dip_switch のデータ入力	*/
			{
			case 0 : /* 重ね探査のため、1回だけ迷路地図を初期化する	*/
					led(0x00) ;	/* all led cut_off	*/
				warning_sin() ;	/* 迷路地図 クリア 警告シグナル	cls_warning_sin	*/
					/* 迷路地図の初期化	& 壁data転送の再確認		*/
				if ((dip_switch() & 0x0f) != 0x00)		break ;	/* 再入力	*/
					/* 迷路地図の初期化	 全区画  壁無し & 未探査	*/
				wall_cls() ;	/* 迷路地図の初期化	 全区画  壁無し & 未探査	*/
					/* 記憶しておいた壁dataを変数(memory)に転送する	*/
				temporary_wall_data_set() ;	/* 壁dataを仮設定	*/
					/* 走行modeの初期化 mode_1 is  start --> goal --> start	*/
				init_1() ;		/* 走行modeの初期化 mode_1 is  start --> goal --> start	*/
				data_read_end_sig() ;	/* データ入力終了 シグナル	*/
					break ;
				/* 横壁データの最大値、中央値、最小値を記憶する		*/
			case 1 : /* 横壁データの最大値、中央値、最小値を記憶する		*/
					led(0x00) ;	/* all led cut_off	*/
				side_wall_data_init() ;	/* 横壁データの最大値、中央値、最小値を記憶する		*/
					break ;
				/* 前壁データを記憶する	*/
			case 2 : /* 前壁データを記憶する	*/
					led(0x00) ;	/* all led cut_off	*/
					/* 走行モードの初期化	start --> goal --> start	 */
				running_mode= SEARCH ;	/* mouseは探査走行を行う	*/
				front_wall_data_init() ;	/* 前壁データを記憶する		センサ分解能 1.5167mm	*/
					break ;
				 /* 探査走行 */
			case 3 :	/* 探査走行 開始	*/
					/* 横壁データの中央値を reset && start位置を合わせる	*/
				reset_side_wall_data() ;	/* start時に、横壁データの中央値を resetする	*/
				start_position_set() ;		/* start位置を迷路の中央に合わせる	*/
					/* mouse の走行速度を設定する	*/
				speed_select= speed_0 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
				adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
					/* 走行モードの初期化	start --> goal --> start	 */
				running_mode= SEARCH ;		/* mouseは探査走行を行う	*/
				init_1() ;	/* 探査走行 変数の初期化	start --> goal --> start	 */
					/* SLA7033 PWM基準電圧設定		*/
				current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
				current_flows= current ;	/* motor の電流値(A/D.Cに書きこむ値)を記憶	*/
					/* 探査走行 main loop	*/
				first() ;	/* 探査走行 主プログラム	*/
					break ;


				/* slalom旋廻 高速走行	*/
			case 4 :
					/* 横壁データの中央値を reset && start位置を合わせる	*/
				reset_side_wall_data() ;	/* start時に、横壁データの中央値を resetする	*/
				start_position_set() ;		/* start位置を迷路の中央に合わせる	*/
					/* mouse の走行速度を設定する	*/
				speed_select= speed_0 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_2 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
				adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
					/* 走行モードの初期化	start --> goal --> start	 */
				running_mode= ATTACK_SLA1 ;	/* time attack		slalom 定常走行		*/
				init_2() ;	/* マウスは start --> goal を走行する	*/
					/* SLA7033 PWM基準電圧設定		*/
				current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
				current_flows= current ;	/* motor の電流値(A/D.Cに書きこむ値)を記憶	*/
					/* slalom旋回 高速走行	*/
				slalom() ;	/* slalom旋回 高速走行	*/
						/* マウスを goalから start地点まで戻す		*/
					/* mouse の走行速度を設定する	*/
					/*		speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
					/*		adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
						/* 走行モードの初期化	start --> goal --> start	 */
					/*	running_mode= ATTACK_SLA1 ;	/* 	time attack		slalom 低速走行	*/
					/*	init_3() ;	/* マウスは goalから start地点まで戻る		*/
					/* slalom旋回 高速走行	*/
					/*		slalomLow() ;		/* slalom旋回 高速走行	*/
					break ;


				/* slalom 斜め走行	*/
			case 5 :
					/* 横壁データの中央値を reset && start位置を合わせる	*/
				reset_side_wall_data() ;	/* start時に、横壁データの中央値を resetする	*/
				start_position_set() ;		/* start位置を迷路の中央に合わせる	*/
					/* mouse の走行速度を設定する	*/
				speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_2 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_3 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_4 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
				adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
					/* 走行モードの初期化	start --> goal --> start	 */
				running_mode= ATTACK_ASL1 ;	/* time attack		slalom 斜め走行		*/
				init_2() ;	/* マウスは start --> goal を走行する	*/
					/* slalom 斜め走行の dataを 造る	*/
				short_d() ;		/* slalom 斜め走行の dataを 造る		*/
				short_d2() ;	/* スラローム 斜め走行の dataを 造る  No_2	*/
					/* SLA7033 PWM基準電圧設定		*/
				current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
				current_flows= current ;	/* motor の電流値(A/D.Cに書きこむ値)を記憶	*/
					/* slalom旋回 高速走行	*/
				slalom() ;	/* slalom旋回 高速走行	*/
						/* マウスを goalから start地点まで戻す		*/
					/* mouse の走行速度を設定する	*/
					/*		speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
					/*		adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
						/* 走行モードの初期化	start --> goal --> start	 */
					/*	running_mode= ATTACK_SLA1 ;	/* 	time attack		slalom 低速走行	*/
					/*	init_3() ;	/* マウスは goalから start地点まで戻る		*/
					/* slalom旋回 高速走行	*/
					/*		slalomLow() ;		/* slalom旋回 高速走行	*/
					break ;



				/* slalom斜め走行試験		基準クロック 2分周	*/
			case 13 :
					/* ITUの再設定		走行試験用	クロックを2分周する	*/
				itu_reset_low() ;		/* ITUの再設定		走行試験用	クロックを2分周する	*/
					/* 横壁データの中央値を reset && start位置を合わせる	*/
				reset_side_wall_data() ;	/* start時に、横壁データの中央値を resetする	*/
				start_position_set() ;		/* start位置を迷路の中央に合わせる	*/
					/* mouse の走行速度を設定する	*/
						/* speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
				speed_select= speed_2 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_3 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_4 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
				adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
					/* 走行モードの初期化	start --> goal --> start	 */
				running_mode= ATTACK_ASL1 ;	/* time attack		slalom 定常走行		*/
					/* init_2() ;	*/	/* マウスは start --> goal を走行する	*/

						/* 連続スラローム試験用 最短コース data	*/
				route_map[0x00]= 0x84, route_map[0x01]= 0x21 ;	/*  4		R		*/
				route_map[0x02]= 0x80, route_map[0x03]= 0x21 ;	/*  0		R		*/
				route_map[0x04]= 0x80, route_map[0x05]= 0x31 ;	/*  0		L		*/
				route_map[0x06]= 0x80, route_map[0x07]= 0x21 ;	/*  0		R		*/
				route_map[0x08]= 0x81, route_map[0x09]= 0x31 ;	/*  1		L	 5	*/
				route_map[0x0a]= 0x80, route_map[0x0b]= 0x21 ;	/*  0		R		*/
				route_map[0x0c]= 0x81, route_map[0x0d]= 0x31 ;	/*  1		L		*/
				route_map[0x0e]= 0x80, route_map[0x0f]= 0x31 ;	/*  0		L		*/
				route_map[0x10]= 0x80, route_map[0x11]= 0x21 ;	/*  0		R		*/
				route_map[0x12]= 0x80, route_map[0x13]= 0x31 ;	/*  0		L	10	*/
				route_map[0x14]= 0x80, route_map[0x15]= 0x31 ;	/*  0		L		*/
				route_map[0x16]= 0x80, route_map[0x17]= 0x21 ;	/*  0		R		*/
				route_map[0x18]= 0x81, route_map[0x19]= 0x21 ;	/*  1		R		*/
				route_map[0x1a]= 0x80, route_map[0x1b]= 0x31 ;	/*  0		L		*/
				route_map[0x1c]= 0x80, route_map[0x1d]= 0x21 ;	/*  0		R	15	*/
				route_map[0x1e]= 0x80, route_map[0x1f]= 0x31 ;	/*  0		L		*/
				route_map[0x20]= 0x80, route_map[0x21]= 0xff ;	/*  0		ゴール	*/

				short_d() ;		/* slalom 斜め走行の dataを 造る		*/
				short_d2() ;	/* スラローム 斜め走行の dataを 造る  No_2	*/

					/* SLA7033 PWM基準電圧設定		*/
				current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
				current_flows= current ;	/* motor の電流値(A/D.Cに書きこむ値)を記憶	*/
					/* slalom旋回 高速走行	*/
				slalom() ;	/* slalom旋回 高速走行	*/
						/* マウスを goalから start地点まで戻す		*/
					/* mouse の走行速度を設定する	*/
					/*		speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
					/*		adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
						/* 走行モードの初期化	start --> goal --> start	 */
					/*	running_mode= ATTACK_SLA1 ;	/* 	time attack		slalom 低速走行	*/
					/*	init_3() ;	/* マウスは goalから start地点まで戻る		*/
					/* slalom旋回 高速走行	*/
					/*		slalomLow() ;		/* slalom旋回 高速走行	*/
					/* ITUの再設定		2分周したクロックを初期値に戻す	*/
				itu_init() ;	/* ITU 初期化	*/
					break ;


				/* slalom 斜め走行 高速走行試験	*/
			case 14 :
					/* 横壁データの中央値を reset && start位置を合わせる	*/
				reset_side_wall_data() ;	/* start時に、横壁データの中央値を resetする	*/
				start_position_set() ;		/* start位置を迷路の中央に合わせる	*/
					/* mouse の走行速度を設定する	*/
				speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_2 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_3 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
						/* speed_select= speed_4 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
				adress_set() ;	/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
					/* 走行モードの初期化	start --> goal --> start	 */
				running_mode= ATTACK_ASL1 ;	/* time attack		slalom 定常走行		*/
					/* init_2() ;	*/	/* マウスは start --> goal を走行する	*/

						/* 連続スラローム試験用 最短コース data	*/
				route_map[0x00]= 0x84, route_map[0x01]= 0x21 ;	/*  4		R		*/
				route_map[0x02]= 0x80, route_map[0x03]= 0x21 ;	/*  0		R		*/
				route_map[0x04]= 0x80, route_map[0x05]= 0x31 ;	/*  0		L		*/
				route_map[0x06]= 0x80, route_map[0x07]= 0x21 ;	/*  0		R		*/
				route_map[0x08]= 0x81, route_map[0x09]= 0x31 ;	/*  1		L	 5	*/
				route_map[0x0a]= 0x80, route_map[0x0b]= 0x21 ;	/*  0		R		*/
				route_map[0x0c]= 0x81, route_map[0x0d]= 0x31 ;	/*  1		L		*/
				route_map[0x0e]= 0x80, route_map[0x0f]= 0x31 ;	/*  0		L		*/
				route_map[0x10]= 0x80, route_map[0x11]= 0x21 ;	/*  0		R		*/
				route_map[0x12]= 0x80, route_map[0x13]= 0x31 ;	/*  0		L	10	*/
				route_map[0x14]= 0x80, route_map[0x15]= 0x31 ;	/*  0		L		*/
				route_map[0x16]= 0x80, route_map[0x17]= 0x21 ;	/*  0		R		*/
				route_map[0x18]= 0x81, route_map[0x19]= 0x21 ;	/*  1		R		*/
				route_map[0x1a]= 0x80, route_map[0x1b]= 0x31 ;	/*  0		L		*/
				route_map[0x1c]= 0x80, route_map[0x1d]= 0x21 ;	/*  0		R	15	*/
				route_map[0x1e]= 0x80, route_map[0x1f]= 0x31 ;	/*  0		L		*/
				route_map[0x20]= 0x80, route_map[0x21]= 0xff ;	/*  0		ゴール	*/

				short_d() ;		/* slalom 斜め走行の dataを 造る		*/
				short_d2() ;	/* スラローム 斜め走行の dataを 造る  No_2	*/
					/* SLA7033 PWM基準電圧設定		*/
				current= TANSA_CURRENT ;	/* motor の電流値(A/D.Cに書きこむ値)	*/
				current_flows= current ;	/* motor の電流値(A/D.Cに書きこむ値)を記憶	*/
					/* slalom旋回 高速走行	*/
				slalom() ;	/* slalom旋回 高速走行	*/
						/* マウスを goalから start地点まで戻す		*/
					/* mouse の走行速度を設定する	*/
					/*		speed_select= speed_1 ;	/* speed_select is 加速テーブルadressの offset(初速)	*/
					/*		adress_set() ;			/* 仮想車輪、駆動輪の速度テーブルのadress(初期値+ offset) & 分周比を設定	*/
						/* 走行モードの初期化	start --> goal --> start	 */
					/*	running_mode= ATTACK_SLA1 ;	/* 	time attack		slalom 低速走行	*/
					/*	init_3() ;	/* マウスは goalから start地点まで戻る		*/
					/* slalom旋回 高速走行	*/
					/*		slalomLow() ;		/* slalom旋回 高速走行	*/
					break ;


					/* 設定された、横壁data && 前壁dataを 表示する	*/
			case 15 :
					/* 横壁dataを 表示する	*/
				side_walldata_indicate() ;	/* 横壁data 表示	*/
					/* 前壁dataを 表示する	*/
				front_walldata_indicate() ;	/* 前壁data 表示	*/
				break ;

			default :
				break ;
			}
		}

		/* 走行状態flag set	*/
			/*  running_condition= CONTINUE ;	*/	/* if running_condition == CONTINUE then mouseは定常走行をしていた	*/
			/*	running_condition= SLALOM ;	*/	/* if running_condition == SLALOM then mouseは slalom をした		*/
			/*	running_condition= ASLANT ;	*/	/* if running_condition == ASLANT then mouseは斜め走行をしていた	*/
	running_condition= HALT ;	/* if running_condition == HALT then mouseは停止していた		*/
}






Mouse2005の部屋へ
MicroMouseの部屋へ
ホーム