Ejemplo n.º 1
0
bool SWP::CLauflicht::KonvertiereString(stSequenz &sBefehl)
{
    if(sBefehl.sOriginal.empty() == true)   //Sequenz ist leer
    {
        std::cerr << "Leere Sequenzen sind ungültig!" << std::endl;
        m_bFlagFail = true;
        return false;
    }

    //Uhrzeitbehandlung (Keine Animationen vor Uhrzeit, wenn kein Text in der Sequenz ist)
    CheckClock(sBefehl);

    //Zeichenketten auf Animationen prüfen (Prüfen ob vor jeder Zeichenkette eine Animation ist)
    CheckAnimation(sBefehl);

	if(m_bFlagFail == true) { return false; }

    /**
        int iColors[3]: Dient zur Speicherung der Farbwerte
        iColors[COLOR_FG]: Vordergrundfarbe
        iColors[COLOR_BG]: Hintergrundfarbe
        iColors[COLOR_FB]: Berechnete Farbenkombination (Addition aus Vorder-/Hintergrundfarbe)
    */

    int iColors[3];
    iColors[COLOR_FG] = 3;
    iColors[COLOR_BG] = 0;
    iColors[COLOR_FB] = 3;

    //Autocenter und Left behandeln
    AutoLeft(sBefehl);

	//Temporäre Variable zur Verarbeitung anlegen (beinhaltet den aktuellen Befehl
    std::wstring sTemp;

    //Start der Konvertierung - der fertige Befehl wird in sBefehl.sKonvertiert gespeichert
    for(unsigned int i = 0;i < sBefehl.sOriginal.length() && m_bFlagFail == false;i++)
    {
    	sTemp = L"";

        if(sBefehl.sOriginal[i] == '<') //Befehlsanfang wurde gefunden
        {
            for(;sBefehl.sOriginal[i] != '>';i++)   //Den kompletten Befehl einlesen
            {
                sTemp += sBefehl.sOriginal[i];
            }

            sTemp += '>';   //Da bei '>' die Schleife abgebrochen wird, muss das Zeichen für das Ende des Befehls
                            //hinzugefügt werden

            if(sTemp == L"<BIG>")	//Prüfen, ob der Befehl BIG vorliegt
            {
            	m_bFlagBig = true;
            	continue;
            }

            if(sTemp == L"<NORMAL>")	//Prüfen, ob der Befehl NORMAL vorliegt
            {
            	m_bFlagBig = false;
            	continue;
            }

            //Prüfen, ob Hintergrundfarbe vorliegt
            if(sTemp == L"<BGCOLOR b>" || sTemp == L"<BGCOLOR r>" || sTemp == L"<BGCOLOR g>" || sTemp == L"<BGCOLOR y>")
            {
            	if(iColors[COLOR_FB] == 32)	//Farbe Rainbow
            	{
            		if(sTemp != L"<BGCOLOR b>")	//Bei Regenbogen: Schwarzen Hintergrund ignorieren
            		{
						//Bei Hintergrundänderung auf Schriftfarbe Gelb schalten
						iColors[COLOR_FG] = GetCode(L"<COLOR y>");
						iColors[COLOR_BG] = GetCode(sTemp);
						iColors[COLOR_FB] = iColors[COLOR_FG] + iColors[COLOR_BG];
            		}
            	}
            	else if((sTemp == L"<BGCOLOR b>") && (iColors[COLOR_FG] == GetCode(L"<COLOR b>")))
            	{
            		m_bFlagFail = true;
					std::cerr << "Schwarzer Hintergrund und Textfarbe verboten!" << std::endl;
				}
				else
				{
					iColors[COLOR_BG] = GetCode(sTemp);
					iColors[COLOR_FB] = iColors[COLOR_FG] + iColors[COLOR_BG];
				}
            }//Prüfen, ob Vordergrundfarbe vorliegt
            else if(sTemp == L"<COLOR b>" || sTemp == L"<COLOR r>" || sTemp == L"<COLOR g>" || sTemp == L"<COLOR y>")
            {
                    //Farbe in Tabelle nachschauen und Variablen aktualisieren
                    iColors[COLOR_FG] = GetCode(sTemp);
                    iColors[COLOR_FB] = iColors[COLOR_FG] + iColors[COLOR_BG];
            }
            else if(sTemp == L"<COLOR rainbow>")
            {
            	/*
            		Der Hintergrund muss schwarz sein - Rainbow lässt keinen anderen Hintergrund zu.
            	*/
            	iColors[COLOR_FG] = GetCode(sTemp);
            	iColors[COLOR_BG] = 0;
            	iColors[COLOR_FB] = iColors[COLOR_FG] + iColors[COLOR_BG];
            }
            else if(sTemp == L"<CLOCK24>" || sTemp == L"<CLOCK12>")
            {
                sBefehl.sKonvertiert += 143;    		//Clockbefehl
                sBefehl.sKonvertiert += GetCode(sTemp); //12h oder 24h Uhr
            }
            else if(sTemp.find(L"WAIT") != std::wstring::npos)
            {
                char c = sTemp[sTemp.find(' ') + 1];    //Sekundenanzahl speichern
                if(c != '0')  							//Falls Sekunden != 0, dann WAIT ignorieren
                {
                    sBefehl.sKonvertiert += GetCode(L"<WAIT>");
                    sBefehl.sKonvertiert += c;//GetCode(L&c);
                }
            }
            else if(sTemp.find(L"SPEED") != std::wstring::npos)
            {
            	char c = sTemp[sTemp.find(' ') + 1];    //Geschwindigkeit speichern
				sBefehl.sKonvertiert += GetCode(L"<SPEED>");
				sBefehl.sKonvertiert += c;
            }
            else
            {
                //Befehl in der Codetabelle nachschauen und konvertieren:
                sBefehl.sKonvertiert += GetCode(sTemp);
                sBefehl.sKonvertiert += 3;	//Befehl nur bestimmte Farben!
            }
        }		//if(sBefehl.sOriginal[i] == '<')...
        else    //Wenn kein Befehl gefunden wurde, dann muss es normaler Text sein
        {
            sTemp = sBefehl.sOriginal[i];

            //Prüfen, ob Sonderzeichen vorliegen (Sonderzeichen müssen gesondert behandelt werden)
            if(sTemp == L"Ω" || sTemp == L"Σ" || sTemp == L"¤" || sTemp == L"æ" ||
                        		sTemp == L"£" || sTemp == L"🍷" || sTemp == L"♪" ||
                        		sTemp == L"🚗" || sTemp == L"⛵" || sTemp == L"🕓" ||
                        		sTemp == L"♥" || sTemp == L"⌂" || sTemp == L"◆" ||
                        		sTemp == L"▲" || sTemp == L"▶" || sTemp == L"▼" ||
                        		sTemp == L"◀" || sTemp == L"☉" || sTemp == L"⬆" ||
                        		sTemp == L"⬇" || sTemp == L"⇦" || sTemp == L"⇨" ||
                        		sTemp == L"[" || sTemp == L"]" || sTemp == L"_" )
			{
				sBefehl.sKonvertiert += GetCode(L"<GRAPH>");
				sBefehl.sKonvertiert += GetCode(sTemp, m_bFlagBig);
			}
            else if(sTemp == L"€")
            {
            	switch(iColors[0])
            	{
					case 2:	//Grünes Eurozeichen verwenden
						sTemp += 'G';
					break;
					case 1:	//Rotes Eurozeichen verwenden
						sTemp += 'R';
					break;
					default:	//Für die restlichen Farben das gelbe Eurozeichen verwenden
						sTemp += 'Y';
					break;
            	}
            	sBefehl.sKonvertiert += GetCode(L"<GRAPH>");
            	sBefehl.sKonvertiert += GetCode(sTemp, m_bFlagBig);
            }

            //Bei Zeichen kommt erst die Farbe, anschließend das Zeichen
            else if(sTemp == L"\\")   //Escapezeichen
            {
            	i++;    //Wegen Escapezeichen muss weitergeschaltet werden
                sTemp = sBefehl.sOriginal[i]; //Nächstes Zeichen abholen

                if(sTemp == L"\\") //Dieses Zeichen gibt es nur als Grafik
                {
                    sBefehl.sKonvertiert += GetCode(L"<GRAPH>");
                    sBefehl.sKonvertiert += GetCode(L"\\", m_bFlagBig);
                }
                else //Für die Zeichen '<', '>'
                {
                	sBefehl.sKonvertiert += iColors[COLOR_FB];     //Farbe
                	sBefehl.sKonvertiert += GetCode(sTemp, m_bFlagBig);   //Zeichen
                }
            }
            else
            {
                //Wenn es kein \ ist, dann ist es ein normales Zeichen
                sBefehl.sKonvertiert += iColors[COLOR_FB];     	//Farbe
                sBefehl.sKonvertiert += GetCode(sTemp, m_bFlagBig); //Zeichen
            }
            m_iLetters++;
        }
    }

    //Start- und Endsequenz
    std::string SKonvertiertTemp;

    //Lauflicht initialisieren, sonst Gerät nicht ansprechbar
    for(int i = 0; i < 10; i++) { SKonvertiertTemp += GetCode(L"<INIT>"); }

	//Sequenzstart signalisieren
    SKonvertiertTemp += GetCode(L"<START>");

	//Programmwahl im Lauflicht (für die Website wird immer Programm A benutzt
    SKonvertiertTemp += GetCode(L"<PROGRAM->");
    SKonvertiertTemp += GetCode(L"A");

    SKonvertiertTemp += sBefehl.sKonvertiert;
    sBefehl.sKonvertiert = SKonvertiertTemp;

    //Endbefehl hinzufügen
    sBefehl.sKonvertiert += GetCode(L"<END>");
    sBefehl.sKonvertiert += 177;	//Leider unbekannter Befehl, dient aber vermutlich zur Löschung der vorherigen Sequenz
    sBefehl.sKonvertiert += GetCode(L"<END>");

    if(m_bFlagFail == false)	//Sequenz erfolgreich konvertiert
    {
    	return true;
    }
    else	//Sequenzkonvertierung fehlgeschlagen
    {
    	return false;
    }
}
Ejemplo n.º 2
0
/*************************************************************************
	module		:[アナログ・ファンクション・チェッカー、メイン]
	function	:[アナログ・ファンクション・チェッカー、メイン]
	return		:[なし]
	common		:[]
	condition	:[]
	comment		:[]
	machine		:[V53]
	language	:[MS-C(Ver.6.0)]
	keyword		:[CHK]
	date		:[1995/02/10]
	author		:[増田]
*************************************************************************/
void	AnalogFunctionCheckerMain( void )						/* なし */
{
	UWORD	command;		/*コマンド*/
	UBYTE	machine;		/*機種(0:桐、1:椛)*/
	UBYTE	result;			/*検査結果*/
	UBYTE	result_out;		/*検査結果出力 ON/OFF*/
/*	UBYTE	lcd_work[31];	*/	/* LCD表示ワーク */

	UBYTE	data;
	UWORD	word_data;

	/** コマンド読み込み */
	command = inpw(COMMAND_PORT);	/** コマンド読み込み */
	command &= 0x00ff;
	machine = (UBYTE)(command >> 7);	/** 機種 */

	outpw(COMMAND_PORT,(UWORD)command);					/** 検査結果ステータス出力 */

	/* RTCポートチェック時は、周波数チェックを外す 1997/11/17  By T.Yamaguchi */
	if ((command != CHECK_OUT_RTC_PORT1) && (command != CHECK_OUT_RTC_PORT2)) {
		/** 周波数チェック */
		CheckClock( 0 );			/** 周波数チェック */
	}

	/** コマンド解析 */
	result = 0;						/** 検査結果=OK */
	result_out = OUT_ON;			/** 検査結果出力=ON */

	/** ブザー音消去 */
#if (PRO_KEYPANEL == PANEL_POPLAR_B) || (PRO_KEYPANEL == PANEL_POPLAR_L)
	outpw(ETC_PORT , IO_BIT_MUTE);
#endif
#if (PRO_KEYPANEL == PANEL_ANZU_L)
	IO__PADRH = 0x00ff;
#endif

	switch ( (command & 0x00ff) ) {	/** コマンド内容を調べる */
		case	CHECK_OUT_CPU_PA1:						/* ポートAデータレジスタH */
			CMN_DisableInterrupt();
			outpw(IO_PADRH_PORT, OUT_CPU_PA1);					/* A0H書き込み */
			result = OUT_CPU_PA1;
			break;
		case	CHECK_OUT_CPU_PA2:						/* ポートAデータレジスタH */
			CMN_DisableInterrupt();
			outpw(IO_PADRH_PORT, OUT_CPU_PA2);					/** 51H書き込み */
			result = OUT_CPU_PA2;
			break;
		case	CHECK_OUT_CPU_PA_UB1:					/* ポートAデータレジスタL */
			CMN_DisableInterrupt();
			outpw(IO_PADRL_PORT, OUT_CPU_PA_UB1);					/** A8H書き込み */
			result = OUT_CPU_PA_UB1;
			break;
		case	CHECK_OUT_CPU_PA_UB2:					/* ポートAデータレジスタL */
			CMN_DisableInterrupt();
			outpw(IO_PADRL_PORT, OUT_CPU_PA_UB2);					/** 55H書き込み */
			result = OUT_CPU_PA_UB2;
			break;
#if (PRO_KEYPANEL == PANEL_ANZU_L)
		case	CHECK_OUT_CPU_PA_UB1H:						/* ポートAデータレジスタL */
			CMN_DisableInterrupt();
			outpw(IO_PADRL_PORT, OUT_CPU_PA_UB1H);					/** AAH書き込み */
			result = RSLT_CPU_PA_UB1H;
			break;
		case	CHECK_OUT_CPU_PA_UB2H:						/* ポートAデータレジスタL */
			CMN_DisableInterrupt();
			outpw(IO_PADRL_PORT, OUT_CPU_PA_UB2H);					/** 51H書き込み */
			result = RSLT_CPU_PA_UB2H;
			break;
		case	CHECK_OUT_CPU_PD1H:							/* ポートDデータレジスタH */
			CMN_DisableInterrupt();
			outpw(IO_PDDRH_PORT, OUT_CPU_PD1H);					/* 40H書き込み */
			result = RSLT_CPU_PD1H;
			break;
		case	CHECK_OUT_CPU_PD2H:							/* ポートDデータレジスタH */
			CMN_DisableInterrupt();
			outpw(IO_PDDRH_PORT, OUT_CPU_PD2H);					/** 80H書き込み */
			result = RSLT_CPU_PD2H;
			break;
		case	CHECK_OUT_COM_PORT1:							/* COM・ポ−ト */
			CMN_DisableInterrupt();
			outpw(COM_PORT, OUT_COM_PORT1);					/** 28H書き込み */
			result = OUT_COM_PORT1;
			break;
		case	CHECK_OUT_COM_PORT2:							/* COM・ポ−ト */
			CMN_DisableInterrupt();
			outpw(COM_PORT, OUT_COM_PORT2);					/** 10H書き込み */
			result = OUT_COM_PORT2;
			break;
		case	CHECK_OUT_RTC_PORT1:							/* RTC・ポ−ト */
			CMN_DisableInterrupt();
			outpw(RTC_PORT, OUT_RTC_PORT1);					/** 0AH書き込み */
			result = OUT_RTC_PORT1;
			break;
		case	CHECK_OUT_RTC_PORT2:							/* RTC・ポ−ト */
			CMN_DisableInterrupt();
			outpw(RTC_PORT, OUT_RTC_PORT2);					/** 0AH書き込み */
			result = OUT_RTC_PORT2;
			break;
#endif
#if (PRO_KEYPANEL == PANEL_POPLAR_B) || (PRO_KEYPANEL == PANEL_POPLAR_L)
		case	CHECK_OUT_CPU_PE1:						/* ポートEデータレジスタH */
			CMN_DisableInterrupt();
			outpw(IO_PEDR_PORT, OUT_CPU_PE1);					/* 80H書き込み */
			result = OUT_CPU_PE1;
			break;
		case	CHECK_OUT_CPU_PE2:						/* ポートEデータレジスタH */
			CMN_DisableInterrupt();
			outpw(IO_PEDR_PORT, OUT_CPU_PE2);					/** 00H書き込み */
			result = OUT_CPU_PE2;
			break;
		case	CHECK_OUT_CPU_PE_UB1:					/* ポートEデータレジスタL */
			CMN_DisableInterrupt();
			outpw(IO_PEDR_PORT, OUT_CPU_PE_UB1);				/** 40H書き込み */
			result = RSLT_CPU_PE_UB1;
			break;
		case	CHECK_OUT_CPU_PE_UB2:					/* ポートEデータレジスタL */
			CMN_DisableInterrupt();
			outpw(IO_PEDR_PORT, OUT_CPU_PE_UB2);				/** 00H書き込み */
			result = RSLT_CPU_PE_UB2;
			break;
		case	CHECK_OUT_EXT1:							/* 外部ポート */
			CMN_DisableInterrupt();
			outpw(MODEM2_PORT, OUT_EXT1);					/* 2AH書き込み */
			result = OUT_EXT1;
			break;
		case	CHECK_OUT_EXT2:							/* 外部ポート */
			CMN_DisableInterrupt();
			outpw(MODEM2_PORT, OUT_EXT2);					/** 55H書き込み */
			result = OUT_EXT2;
			break;
		case	CHECK_OUT_EXT_UB1:						/* 外部ポート */
			CMN_DisableInterrupt();
			outpw(MODEM2_PORT, OUT_EXT_UB1);					/** 2AH書き込み */
			result = RSLT_EXT_UB1;
			break;
		case	CHECK_OUT_EXT_UB2:						/* 外部ポート */
			CMN_DisableInterrupt();
			outpw(MODEM2_PORT, OUT_EXT_UB2);					/** 55H書き込み */
			result = RSLT_EXT_UB2;
			break;
		/* I/Oリード項目 */
		case	CHECK_IN_CPU_PA:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (inpw(IO_PADRL_PORT) & IN_CPU_PA));	/** ジャムカバーを読み、ステータスポートに出力 */
			}
			break;
		case	CHECK_IN_CPU_PA_UB:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, ((inpw(IO_PADRL_PORT) >> 8) & IN_CPU_PA_UB));	/** ドラムステータスを読み、ステータスポートに出力 */
			}
			break;
		case	CHECK_IN_CPU_PD:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, ((inpw(IO_PDDRH_PORT) >> 8) & IN_CPU_PD));	/** モータステータスを読み、ステータスポートに出力 */
			}
			break;
#endif
		case	CHECK_IN_CPU_PE:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (inpw(IO_PEDR_PORT) & IN_CPU_PE));	/** ポートEデータレジスタを読み、ステータスポートに出力 */
			}
			break;
		case	CHECK_IN_CPU_PE_UB:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, ((inpw(IO_PEDR_PORT) >> 8) & IN_CPU_PE_UB));	/** ポートEデータレジスタを読み、ステータスポートに出力 */
			}
			break;
		case	CHECK_IN_CPU_PF:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (UWORD)(inp(IO_PFDR_PORT) & IN_CPU_PF));	/** ポートFデータレジスタを読み、ステータスポートに出力 */
			}
			break;
		case	CHECK_IN_MD9604:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (inpw(SENSOR1_PORT) & IN_MD9604) );	/** 入力ポートCS06を読み、ステータスポートに出力 */
			}
			break;
#if 0	/* (PRO_KEYPANEL == PANEL_ANZU_L) 削除1997/11/14  By T.Yamaguchi */
//		case	CHECK_IN_MD9604H:
//			for (;;) {						/** 無限ループ */
//				outpw( COMMAND_PORT, ((inpw(SENSOR1_PORT) >> 8) & IN_MD9604H) );	/** 入力ポートCS06を読み、ステータスポートに出力 */
//			}
//			break;
#endif
#if (PRO_KEYPANEL == PANEL_POPLAR_B) || (PRO_KEYPANEL == PANEL_POPLAR_L)
		case	CHECK_IN_EXT2:		/** ディップスイッチチェックが指定された */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (inpw(SENSOR2_PORT) & IN_EXT2) );	/** 入力ポートCS06を読み、ステータスポートに出力 */
			}
			break;
#endif
#if (PRO_KEYPANEL == PANEL_POPLAR_B)
		case	CHECK_APS_SENSOR:
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (inpw(APS_SENSOR_PORT) & IO_BIT_XAPS) );	/** 入力ポートCS06を読み、ステータスポートに出力 */
			}
			break;
#endif
		case	CHECK_BUZZER_HIGH:	/* ブザー大	*/
			SCN_SetBuzzerFrequency( ACK_BUZZER_FREQ );		/** 周波数の設定 */
			SYB_MonitorSpeakerOutLevel = SYS_VOLUME_MAXIMUM;	/* ボリューム最大に設定 */
			MonitorSpeakerVolumeControl();
			SpeakerMuteOff();
			SpeakerOutBuzzer();
#if 0
//			SYS_ETC_PortStatus = (IO_BIT_SPVR1 | IO_BIT_SPVR2);		/* ボリューム最大に設定 */
//			SYS_ETC_PortStatus &= ~IO_BIT_MUTE;
//			outpw(ETC_PORT , SYS_ETC_PortStatus);
//
//			SYS_Modem2PortStatus &= ~IO_BIT_RXA_BZ;
//			outpw(MODEM2_PORT, SYS_Modem2PortStatus );
#endif
			SCN_SetBuzzer(SCN_ENABLE);						/** ブザー許可 */
			result = BUZZER_HIGH_OK;
			break;
		case	CHECK_BUZZER_LOW:
			SCN_SetBuzzerFrequency( ACK_BUZZER_FREQ );		/** 周波数の設定 */
			SYB_MonitorSpeakerOutLevel = SYS_VOLUME_MINIMUM;	/* ボリューム最小に設定 */
			MonitorSpeakerVolumeControl();
			SpeakerMuteOff();
			SpeakerOutBuzzer();
#if 0
//			SYS_ETC_PortStatus = IO_BIT_SPVR1;		/* ボリューム最小に設定 */
//			SYS_ETC_PortStatus &= ~IO_BIT_MUTE;
//			outpw(ETC_PORT , SYS_ETC_PortStatus);
//
//			SYS_Modem2PortStatus &= ~IO_BIT_RXA_BZ;
//			outpw(MODEM2_PORT, SYS_Modem2PortStatus );
#endif
			SCN_SetBuzzer(SCN_ENABLE);						/** ブザー許可 */
			result = BUZZER_LOW_OK;
			break;
		case	CHECK_DRAM_WR:
			/** DRAMチェック(WR) */
			CMN_DisableInterrupt();				/** 割り込み禁止 */
			CheckMemory(CHK_WRITE,0x1000000);	/** チェック IC36 */
			result = CHECK_RAM_WRITE;			/* RAMライト完了 */
			break;
		case	CHECK_DRAM_RD:
			/** DRAMチェック(RD) */
			CMN_DisableInterrupt();				/** 割り込み禁止 */
			result = CHECK_DRAM_OK;			/** 検査結果=OK */
			if (CheckMemory(CHK_READ,0x1000000) != OK ) {	/** チェック IC36 */
				result = CHECK_ERROR;	/** IC36 NG */
			}
			break;
		case	CHECK_SRAM_WR:
			/** SRAMチェック(WR) */
			CMN_DisableInterrupt();				/** 割り込み禁止 */
			CheckMemory(CHK_WRITE,0x400000);	/** チェック IC36 */
			CheckMemory(CHK_WRITE,0x440000);	/** チェック IC36 add 1998/01/23  By T.Yamaguchi */
			result = CHECK_RAM_WRITE;			/* RAMライト完了 */
			break;
		case	CHECK_SRAM_RD:
			/** SRAMチェック(RD) */
			CMN_DisableInterrupt();				/** 割り込み禁止 */
			result = CHECK_SRAM_OK;			/** 検査結果=OK */
			if (CheckMemory(CHK_READ,0x400000) != OK ) {	/** チェック IC36 */
				result = CHECK_ERROR;	/** NG */
			}
			if (CheckMemory(CHK_READ,0x440000) != OK ) {	/** チェック IC36  add 1998/01/23  By T.Yamaguchi */
				result = CHECK_ERROR;	/** NG */
			}
			break;
		case	CHECK_MD9604:
			/* MD9604チェック(IC12) */
			/* 何処のアドレスをチェックするかよう確認すること */
			result = CheckIoWordLoop(PRINTER1_PORT ,CHECK_MD9604_OK , CHECK_ERROR );
#if 0
//			result = CheckIoLoop(PRINTER2_PORT ,CHECK_MD9604_OK , CHECK_ERROR );
//			result = CheckIoLoop(PRINTER3_PORT ,CHECK_MD9604_OK , CHECK_ERROR );
//			result = CheckIoLoop(PRINTER6_PORT ,CHECK_MD9604_OK , CHECK_ERROR );
//			result = CheckIoLoop(PRINTER7_PORT ,CHECK_MD9604_OK , CHECK_ERROR );
#endif
			break;
		case	CHECK_MD9605:
			/* MD9605チェック(IDP) */
			/** IDP301チェックが指定された */
			result = CheckIDP( machine, CHECK_IDP301_OK, CHECK_IDP301_NG );	/** IDP301チェック */
			break;
#if (PRO_KEYPANEL == PANEL_POPLAR_B)
		case	CHECK_MD9509:
			/* MD9509チェック(プリンタ) */
			/* 何処のアドレスをチェックするかよう確認すること */
			if (CheckMortor(1)) {
				result = 0xC0;		/* モーター回転中 */
			}
			result = CHECK_MD9509_OK;
			break;
#endif
		case	CHECK_EXTEND_RAM:
			/** 拡張DRAMチェック(RD) */
			result = CHECK_EXT_DRAM_OK;			/** 検査結果=OK */
			CMN_DisableInterrupt();				/** 割り込み禁止 */
			CheckMemory(CHK_WRITE,0x1200000);	/** チェック IC36 */
			if (CheckMemory(CHK_READ,0x1200000) != OK ) {	/** チェック IC36 */
				result |= CHECK_DRAM_EX12_NG;	/** IC36 NG */
			}
			CheckMemory(CHK_WRITE,0x1400000);	/** チェック IC36 */
			if (CheckMemory(CHK_READ,0x1400000) != OK ) {	/** チェック IC36 */
				result |= CHECK_DRAM_EX14_NG;	/** IC36 NG */
 			}
			CheckMemory(CHK_WRITE,0x1600000);	/** チェック IC36 */
			if (CheckMemory(CHK_READ,0x1600000) != OK ) {	/** チェック IC36 */
				result |= CHECK_DRAM_EX16_NG;	/** IC36 NG */
			}
			CheckMemory(CHK_WRITE,0x1800000);	/** チェック IC36 */
			if (CheckMemory(CHK_READ,0x1800000) != OK ) {	/** チェック IC36 */
				result |= CHECK_DRAM_EX18_NG;	/** IC36 NG */
			}
			break;
#if (PRO_CLASS1 == ENABLE)
		case	CHECK_RS232C:
			/*	??????????????????????????????????????????????????????	*/
			/* RS-232C速度19200
			** RS-232Cキャラクタービット8
			** RS-232Cパリティなし
			** RS-232Cストップビット1
			*/
			SYB_SettingStatus[5] = 0x0e;
			Class1InitVar();
			result = CHECK_ERROR;	/* チェックエラー */
			RsTestMode = 0x03;	/* 折り返しテスト */
			RsTestChar = RsTestMode;	/**	テスト用キャラクタ=?をセット	**/
			if (RsOpen('t', 'c', 60) == 1) {
				if ( RsClose('t') == 1) {		/**	テスト終了を待つ	**/
					result = CHECK_RS232C_OK;
				}
			}
#endif
			break;
		case	CHECK_OPTION:
			if (DPRD_CheckSlaveBoardEnable() == 1) {
				result = CHECK_OPTION_OK;
			}
			else {
				result = CHECK_ERROR;	/* チェックエラー */
			}
			break;
#if (PRO_KEYPANEL == PANEL_POPLAR_B) || (PRO_KEYPANEL == PANEL_POPLAR_L)
		case	CHECK_AD_PORT_F0:	/* CASET1 */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRA >> 2));	/** A/DデータレジスタA */
			}
			break;
		case	CHECK_AD_PORT_F1:	/* CASET2 */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRB >> 2));	/** A/DデータレジスタB */
			}
			break;
		case	CHECK_AD_PORT_F2:	/* CASET3 */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRC >> 2));	/** A/DデータレジスタB */
			}
			break;
		case	CHECK_AD_PORT_F3:	/* TEMPR */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRD >> 2));	/** A/DデータレジスタB */
			}
			break;
		case	CHECK_AD_PORT_F5:	/* HVR */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRF >> 2));	/** A/DデータレジスタB */
			}
			break;
		case	CHECK_AD_PORT_F6:	/* THMST */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRG >> 2));	/** A/DデータレジスタB */
			}
			break;
		case	CHECK_AD_PORT_F7:	/* TS */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRH >> 2));	/** A/DデータレジスタB */
			}
			break;
#endif
		case	CHECK_AD_PORT_F4:	/* BAT */
			for (;;) {						/** 無限ループ */
				outpw( COMMAND_PORT, (AD__ADDRE >> 2));	/** A/DデータレジスタB */
			}
			break;
		case	CHECK_MODEM_TX:				/** モデム送信チェックが指定された */
			CheckModemTx(0);						/** モデム送信チェック */
			result = CHECK_MODEM_TX;
			break;
		case	CHECK_MODEM_RX:				/** モデム受信チェックが指定された */
			result = CheckModemRx();			/** モデム受信チェック */
			break;
/*	その他の項目	*/
		case	CHECK_DMAU:			/** DMAUチェックが指定された */
			CMN_DisableInterrupt();				/** 割り込み禁止 */
			result = CheckIoLoop(DMAU_PORT,CHECK_DMAU_OK,CHECK_DMAU_NG);/** DMAUチェック */
			break;
		case	CHECK_RXA_RXOUT:	/** RXA−RXOUTチェックが指定された*/
			result_out = OUT_OFF;				/** 検査結果出力=OFF */
			outp( ModemFilterControl, CHECK_RXA_RXOUT_BIT);	/** RXA−RXOUT*/
			break;
		case	CHECK_1100_BPF:		/** 1100BPFチェックが指定された*/
			result_out = OUT_OFF;				/** 検査結果出力=OFF */
			outp( ModemFilterControl, CHECK_1100_BPF_BIT);	/** 1100BPF*/
			break;
		case	CHECK_462_LPF:		/** 462LPFチェックが指定された*/
			result_out = OUT_OFF;				/** 検査結果出力=OFF */
			outp( ModemFilterControl, CHECK_462_LPF_BIT);	/** 462LPF*/
			break;
		case	CHECK_CODEC_SCN:	/** CODECスキャナーチェックが指定された */
			result = CheckIoWordLoop( CodecRegisterAddressTable[0][1], CHECK_CODEC_SCN_OK, CHECK_CODEC_SCN_NG );	/** CODECスキャナーチェック */
			break;
		case	CHECK_CODEC_PRN:	/** CODECプリンターチェックが指定された */
			result = CheckIoWordLoop( CodecRegisterAddressTable[1][1], CHECK_CODEC_PRN_OK, CHECK_CODEC_PRN_NG );	/** CODECプリンターチェック */
			break;
		case	CHECK_CODEC_COM:	/** CODEC通信チェックが指定された */
			result = CheckIoWordLoop( CodecRegisterAddressTable[2][1], CHECK_CODEC_COM_OK, CHECK_CODEC_COM_NG );	/** CODEC通信チェック */
			break;
		case	CHECK_SHADING:		/** 白黒判定 for ANZU_L */
			CheckShading();
/*
//			if (DIPP_ShadingExecute() == OK) {
//				result = 0xC0;			@* 終了 *@
//			}
//			else {
//				result = CHECK_ERROR;	@* チェックエラー *@
//			}
*/
			break;
		case CHECK_MOTOR:
			if (CheckMortor(1)) {
				result = 0xC0;		/* モーター回転中 */
			}
			break;
		case CHECK_MOTOR_STOP:
			CheckMortor(0);
			result = 0xC0;		/* モーターSTOP */
			break;
#if (PRO_KEYPANEL == PANEL_POPLAR_B)
		case CHECK_FBS_MOTOR:
			if (CheckMortor(3)) {
				result = 0xC0;		/* FBSモーター回転中 */
			}
			break;
		case CHECK_FBS_MOTOR_STOP:
			CheckMortor(2);
			result = 0xC0;		/* FBSモーターSTOP */
			break;
#endif
		case CHECK_TX_OUT_1080HZ:
			CheckModemTx(1);						/** モデム送信チェック */
		case CHECK_TX_OUT_5000HZ:
			CheckModemTx(2);						/** モデム送信チェック */
		default:	/* ここには来ないはず */
			break;

	}

	/** 検査結果出力 */
	if ( result_out == OUT_ON ) {		/** 検査結果出力=ONの時 */
		for (;;) {						/** 無限ループ */
			outpw(COMMAND_PORT,(UWORD)result);		/** 検査結果ステータス出力 */
		}
	}

	/** 終了処理 */
	CMN_DisableInterrupt();		/** 割り込み禁止 */
	for (;;);						/** 無限ループ */
}