2013년 12월15일 Facebook 열한 번째 이야기

• 
  오장훈 |facebook

  주차장시스템 KEY
  
  2008.11. 21 미니 홈피
  
  ;;======================================================================================
  ;;
  ;; # KEY_CHECK_IN :
  ;;
  ;; 키를 눌렀을 때 무엇을 눌렀는지 체크한다.
  ;;
  ;; 눌러진 키에 따른 액션을 취한다.
  ;;
  ;;======================================================================================
  KEY_CHECK_IN:
  CLR KEY_IN_0 ;// 각 키에 따른 플래그를 클리어 해준다.
  CLR KEY_IN_1
  CLR KEY_IN_2
  CLR KEY_IN_3
  
  MOV DPTR, #HC574 ;// 574를 가리킨다.
  MOV A, #08H ;// D3, OUT 3를 선택한다.
  MOVX @DPTR, A ;// OUT 3로 전류가 흐른다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.4, KEY_SW_0 ;// 마지막 비트에 전류가 흐르면 KEY_0가 눌러진 상태다.
  JB ACC.5, KEY_SW_2 ;// 두번째 비트에 전류가 흐르면 KEY_1이 눌러진 상태
  MOV DPTR, #HC574 ;// 다시 574를 가리킨다.
  MOV A, #10H ;// D4, OUT 4을 선택한다.
  MOVX @DPTR, A ;// OUT 4로 전류를 흘려준다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.4, KEY_SW_1 ;// 마지막 비트에 전류가 흐르면 KEY_2가 눌러진 상태
  JB ACC.5, KEY_SW_3 ;// 두번째 비트에 전류가 흐르면 KEY_3가 눌러진 상태
  MOV OLD_KEY_FLAG, #0FFH ;// 키를 누르고 뗀 후에는 OLD_KEY_FLAG값을 초기화 해준다.
  RET ;// 아무키도 눌러지지 않았을 때는 메인함수로 나간다.
  KEY_SW_0: ;// 첫번째 키가 눌러진 경우
  SETB KEY_IN_0 ;// 키 플래그를 SET시켜준다.
  MOV NO_TOUCH_EIGHT, #08H ;// 8초동안 키를 누르지 않았는지 체크
  JMP KEY_CHG_CHK ;// 키 값에 대한 액션을 취하기 전에 키를 꾹누를 때도 한번만 실행되도록 비교한다.
  KEY_SW_1: ;// 두번째 키가 눌러진 경우
  SETB KEY_IN_1
  MOV NO_TOUCH_EIGHT, #08H ;// 8초동안 키를 누르지 않았는지 체크
  JMP KEY_CHG_CHK
  KEY_SW_2: ;// 세번째 키가 눌러진 경우
  SETB KEY_IN_2
  MOV NO_TOUCH_EIGHT, #08H ;// 8초동안 키를 누르지 않았는지 체크
  JMP KEY_CHG_CHK
  KEY_SW_3: ;// 네번째 키가 눌러진 경우
  SETB KEY_IN_3
  KEY_CHG_CHK: ;// 한개의 키가 꾸욱 눌러졌는지 비교한다.
  MOV A, KEY_IN_FLAG ;// 현재의 키 값을 저장한다.
  CJNE A, OLD_KEY_FLAG, KEY_IN_0_ACTION ;// 한번 실행 한 값과 현재의 키 값이 다른 경우만 키 값에 따른 액션을 취하도록한다.
  JMP KEY_CHECK_IN_END ;// 한번 실행했던 값과 현재의 키 값이 같으면 키 체크를 끝낸다.
  KEY_IN_0_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_IN_0, KEY_IN_1_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  
  CLR HOUR_CHANGE_FLAG ;// 키 0의 플래그들을 클리어 시킨다.
  CLR MIN_CHANGE_FLAG
  CLR SEC_CHANGE_FLAG
  
  INC RTC_CHANGE_MODE ;// RTC시간 수정 모드 결정 변수값 증가
  
  HOUR_UP_MODE: ;// 시간 증가 감소 모드
  MOV A, RTC_CHANGE_MODE ;// 동작 결정 변수가 01인 경우실핼
  CJNE A, #01H, MIN_UP_MODE ;// 01이 아닌 경우는 02인지 비교하러 점프
  SETB HOUR_CHANGE_FLAG ;// 01인 경우는 시간을 변화 시키는 플래그 SET
  SETB RTC_WATCH_FLAG ;// 밖으로 보이는 RTC의 동작을 멈춘다. 내부적으로는 동작중
  JMP KEY_CHECK_IN_END
  
  MIN_UP_MODE: ;// 분 증가 감소 모드
  MOV A, RTC_CHANGE_MODE ;// 동작 결정 변수가 02인 경우 실행
  CJNE A, #02H, SEC_UP_MODE ;// 02가 아닌 경우는 03인지 비교하러 점프
  SETB MIN_CHANGE_FLAG ;// 02인 경우는 분을 변화시키는 플래그 SET
  SETB RTC_WATCH_FLAG ;// 밖으로 보이는 RTC의 동작을 멈춘다. 내부적으로는 동작중
  JMP KEY_CHECK_IN_END
  
  SEC_UP_MODE: ;// 초 증가 감소 모드
  MOV A, RTC_CHANGE_MODE ;// 동작 결정 변수가 03인 경우 실행
  CJNE A, #03H, START_MODE ;// 03이 아닌 경우는 처음 상태로 만들러 점프
  SETB SEC_CHANGE_FLAG ;// 03인 경우는 초를 변화 시키는 플래그 SET
  SETB RTC_WATCH_FLAG ;// 밖으로 보이는 RTC의 동작을 멈춘다. 내부적으로는 동작중
  JMP KEY_CHECK_IN_END
  
  START_MODE: ;// 처음 상태
  MOV RTC_CHANGE_MODE, #00H ;// 동작 결정 변수를 초기화
  SETB RTC_WATCH_FLAG ;// 밖으로 보이는 RTC의 동작을 멈춘다. 내부적으로는 동작중
  
  CALL LCD_TO_RTC ;// LCD에 보이는 시간을 RTC에 써 넣을수 있는 변수로 바꿈
  CALL RTC_RE_WRITE ;// RTC에 시간을 다시 쓴다
  
  JMP KEY_CHECK_IN_END ;// 함수 나감
  
  KEY_IN_1_ACTION: ;// 두번째 키가 눌러진 경우
  JNB KEY_IN_1, KEY_IN_2_ACTION ;// 두번째 키 확인, 아니면 다음 플래그를 확인하러 점프
  
  JNB HOUR_CHANGE_FLAG, MIN_UP_CHANGE ;// 시간을 변화 시키는 플래그가 SET되어 있는지 확인
  CALL HOUR_UP
  JMP KEY_CHECK_IN_END ;// 키 체크 끝
  MIN_UP_CHANGE:
  JNB MIN_CHANGE_FLAG, SEC_UP_CHANGE ;// 분을 변화 시키는 플래그가 SET되어 있는지 확인
  CALL MIN_UP
  JMP KEY_CHECK_IN_END ;// 키 체크 끝
  SEC_UP_CHANGE:
  JNB SEC_CHANGE_FLAG, KEY_CHECK_IN_END ;// 초를 변화 시키는 플래그가 SET되어 있는지 확인
  CALL SEC_UP
  JMP KEY_CHECK_IN_END
  
  KEY_IN_2_ACTION: ;// 세번째 키가 눌러진 경우
  JNB KEY_IN_2, KEY_IN_3_ACTION ;// 세번째 키 확인, 아니면 다음키 확인
  CALL INITIAL_MID
  JMP KEY_CHECK_IN_END
  
  KEY_IN_3_ACTION: ;// 네번째 키가 눌러진 경우
  JNB KEY_IN_3, KEY_CHECK_IN_END ;// 네번재 키 확인, 아니면 키 체크 함수 끝으로
  
  JNB HOUR_CHANGE_FLAG, MIN_DOWN_CHANGE ;// 시간 변화 플래그가 SET되어 있는지 확인
  CALL HOUR_DOWN
  JMP KEY_CHECK_IN_END ;// 키 체크 끝
  
  MIN_DOWN_CHANGE:
  JNB MIN_CHANGE_FLAG, SEC_DOWN_CHANGE ;// 분 변화 플래그가 SET되어 있는지 확인
  CALL MIN_DOWN
  JMP KEY_CHECK_IN_END ;// 키 체크 끝
  
  SEC_DOWN_CHANGE:
  JNB SEC_CHANGE_FLAG, KEY_CHECK_IN_END ;// 초 변화 플래그가 SET되어 있는지 확인
  CALL SEC_DOWN
  
  
  KEY_CHECK_IN_END: ;// 키 체크 끝
  MOV OLD_KEY_FLAG, KEY_IN_FLAG ;// 현재 누르고 있는 키를 저장
  RET ;// 메인 함수로
  
  ;;======================================================================================
  ;;
  ;; # KEY_CHECK_OUT_1 :
  ;;
  ;; 키를 눌렀을 때 무엇을 눌렀는지 체크한다.
  ;;
  ;; 눌러진 키에 따른 액션을 취한다.
  ;;
  ;;======================================================================================
  KEY_CHECK_OUT_1:
  CLR KEY_OUT_0
  CLR KEY_OUT_1
  CLR KEY_OUT_2
  CLR KEY_OUT_3
  CLR KEY_OUT_4
  CLR KEY_OUT_5
  CLR KEY_OUT_6
  CLR KEY_OUT_7
  CLR KEY_OUT_8
  CLR KEY_OUT_9
  CLR KEY_OUT_10
  CLR KEY_OUT_11
  
  CLR KEY_OUT_12
  CLR KEY_OUT_13
  CLR KEY_OUT_14
  CLR KEY_OUT_15
  CLR KEY_OUT_16
  CLR KEY_OUT_17
  CLR KEY_OUT_18
  CLR KEY_OUT_19
  CLR KEY_OUT_20
  CLR KEY_OUT_21
  CLR KEY_OUT_22
  CLR KEY_OUT_23
  
  MOV DPTR, #HC574 ;// 574를 가리킨다.
  MOV A, #01H ;// D0, OUT0를 선택한다.
  MOVX @DPTR, A ;// OUT 3로 전류가 흐른다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.0, KEY_OUT_SW_0 ;// 마지막 비트에 전류가 흐르면 KEY_0가 눌러진 상태다.
  JB ACC.1, KEY_OUT_SW_3 ;// 두번째 비트에 전류가 흐르면 KEY_1이 눌러진 상태
  JB ACC.2, KEY_OUT_SW_6
  JB ACC.3, KEY_OUT_SW_9
  MOV DPTR, #HC574 ;// 다시 574를 가리킨다.
  MOV A, #02H ;// D1, OUT1을 선택한다.
  MOVX @DPTR, A ;// OUT 4로 전류를 흘려준다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.0, KEY_OUT_SW_1 ;// 마지막 비트에 전류가 흐르면 KEY_2가 눌러진 상태
  JB ACC.1, KEY_OUT_SW_4 ;// 두번째 비트에 전류가 흐르면 KEY_3가 눌러진 상태
  JB ACC.2, KEY_OUT_SW_7
  JB ACC.3, KEY_OUT_SW_10
  MOV DPTR, #HC574 ;// 574를 가리킨다.
  MOV A, #04H ;// D2, OUT2를 선택한다.
  MOVX @DPTR, A ;// OUT 3로 전류가 흐른다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.0, KEY_OUT_SW_2 ;// 마지막 비트에 전류가 흐르면 KEY_0가 눌러진 상태다.
  JB ACC.1, KEY_OUT_SW_5 ;// 두번째 비트에 전류가 흐르면 KEY_1이 눌러진 상태MOV DPTR, #HC574 ;// 574를 가리킨다.
  JB ACC.2, KEY_OUT_SW_8
  JB ACC.3, KEY_OUT_SW_11
  
  MOV OLD_KEY_OUT_FLAG1, #0FFH ;// 키를 누르고 뗀 후에는 OLD_KEY_FLAG값을 초기화 해준다.
  MOV OLD_KEY_OUT_FLAG2, #0FFH
  RET ;// 아무키도 눌러지지 않았을 때는 메인함수로 나간다.
  KEY_OUT_SW_0: ;// 첫번째 키가 눌러진 경우
  SETB KEY_OUT_0 ;// 키 플래그를 SET시켜준다.
  JMP KEY_OUT_CHG_CHK1 ;// 키 값에 대한 액션을 취하기 전에 키를 꾹누를 때도 한번만 실행되도록 비교한다.
  KEY_OUT_SW_1: ;// 두번째 키가 눌러진 경우
  SETB KEY_OUT_1
  JMP KEY_OUT_CHG_CHK1
  KEY_OUT_SW_2: ;// 세번째 키가 눌러진 경우
  SETB KEY_OUT_2
  JMP KEY_OUT_CHG_CHK1
  KEY_OUT_SW_3: ;// 네번째 키가 눌러진 경우
  SETB KEY_OUT_3
  JMP KEY_OUT_CHG_CHK1
  KEY_OUT_SW_4: ;// 다섯번째 키가 눌러진 경우
  SETB KEY_OUT_4
  JMP KEY_OUT_CHG_CHK1
  KEY_OUT_SW_5: ;// 여섯번째 키가 눌러진 경우
  SETB KEY_OUT_5
  JMP KEY_OUT_CHG_CHK1
  KEY_OUT_SW_6: ;// 일곱번째 키가 눌러진 경우
  SETB KEY_OUT_6
  JMP KEY_OUT_CHG_CHK2
  KEY_OUT_SW_7: ;// 여덟번째 키가 눌러진 경우
  SETB KEY_OUT_7
  JMP KEY_OUT_CHG_CHK2
  KEY_OUT_SW_8: ;// 아홉번째 키가 눌러진 경우
  SETB KEY_OUT_8
  JMP KEY_OUT_CHG_CHK2
  KEY_OUT_SW_9: ;// 열번째 키가 눌러진 경우
  SETB KEY_OUT_9
  JMP KEY_OUT_CHG_CHK2
  KEY_OUT_SW_10: ;// 열한번째 키가 눌러진 경우
  SETB KEY_OUT_10
  JMP KEY_OUT_CHG_CHK2
  KEY_OUT_SW_11: ;// 열두번째 키가 눌러진 경우
  SETB KEY_OUT_11
  JMP KEY_OUT_CHG_CHK2
  
  KEY_OUT_CHG_CHK1: ;// 한개의 키가 꾸욱 눌러졌는지 비교한다.
  MOV A, KEY_OUT_FLAG1 ;// 현재의 키 값을 저장한다.
  CJNE A, OLD_KEY_OUT_FLAG1, KEY_OUT_0_ACTION ;// 한번 실행 한 값과 현재의 키 값이 다른 경우만 키 값에 따른 액션을 취하도록한다.
  JMP KEY_OUT_CHG_CHK2 ;// 한번 실행했던 값과 현재의 키 값이 같으면 키 체크를 끝낸다.
  KEY_OUT_0_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_0, KEY_OUT_1_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_0_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_1_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_1, KEY_OUT_2_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_1_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_2_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_2, KEY_OUT_3_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_2_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_3_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_3, KEY_OUT_4_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_3_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_4_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_4, KEY_OUT_5_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_4_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_5_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_5, KEY_CHECK_OUT_1_END;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_5_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_CHG_CHK2: ;// 한개의 키가 꾸욱 눌러졌는지 비교한다.
  MOV A, KEY_OUT_FLAG2 ;// 현재의 키 값을 저장한다.
  CJNE A, OLD_KEY_OUT_FLAG2, KEY_OUT_6_ACTION ;// 한번 실행 한 값과 현재의 키 값이 다른 경우만 키 값에 따른 액션을 취하도록한다.
  JMP KEY_CHECK_OUT_1_END ;// 한번 실행했던 값과 현재의 키 값이 같으면 키 체크를 끝낸다.
  KEY_OUT_6_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_6, KEY_OUT_7_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_6_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_7_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_7, KEY_OUT_8_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_7_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_8_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_8, KEY_OUT_9_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_8_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_9_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_9, KEY_OUT_10_ACTION;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_9_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_10_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_10, KEY_OUT_11_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_10_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_OUT_11_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_11, KEY_CHECK_OUT_1_END ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_11_CHK
  JMP KEY_CHECK_OUT_1_END
  
  KEY_CHECK_OUT_1_END: ;// 키 체크 끝
  MOV OLD_KEY_OUT_FLAG1, KEY_OUT_FLAG1 ;// 현재 누르고 있는 키를 저장
  MOV OLD_KEY_OUT_FLAG2, KEY_OUT_FLAG2
  RET ;// 메인 함수로
  
  
  
  
  ;;======================================================================================
  ;;
  ;; # KEY_CHECK_OUT_2 :
  ;;
  ;; 키를 눌렀을 때 무엇을 눌렀는지 체크한다.
  ;;
  ;; 눌러진 키에 따른 액션을 취한다.
  ;;
  ;;======================================================================================
  KEY_CHECK_OUT_2:
  CLR KEY_OUT_12
  CLR KEY_OUT_13
  CLR KEY_OUT_14
  CLR KEY_OUT_15
  CLR KEY_OUT_16
  CLR KEY_OUT_17
  CLR KEY_OUT_18
  CLR KEY_OUT_19
  CLR KEY_OUT_20
  CLR KEY_OUT_21
  CLR KEY_OUT_22
  CLR KEY_OUT_23
  
  MOV DPTR, #HC574 ;// 574를 가리킨다.
  MOV A, #20H ;// D5, OUT5를 선택한다.
  MOVX @DPTR, A ;// OUT 3로 전류가 흐른다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.0, KEY_OUT_SW_12 ;// 마지막 비트에 전류가 흐르면 KEY_0가 눌러진 상태다.
  JB ACC.1, KEY_OUT_SW_15 ;// 두번째 비트에 전류가 흐르면 KEY_1이 눌러진 상태
  JB ACC.2, KEY_OUT_SW_18
  JB ACC.3, KEY_OUT_SW_21
  MOV DPTR, #HC574 ;// 다시 574를 가리킨다.
  MOV A, #40H ;// D6, OUT6을 선택한다.
  MOVX @DPTR, A ;// OUT 4로 전류를 흘려준다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.0, KEY_OUT_SW_13 ;// 마지막 비트에 전류가 흐르면 KEY_2가 눌러진 상태
  JB ACC.1, KEY_OUT_SW_16 ;// 두번째 비트에 전류가 흐르면 KEY_3가 눌러진 상태
  JB ACC.2, KEY_OUT_SW_19
  JB ACC.3, KEY_OUT_SW_22
  MOV DPTR, #HC574 ;// 574를 가리킨다.
  MOV A, #80H ;// D7, OUT7를 선택한다.
  MOVX @DPTR, A ;// OUT 3로 전류가 흐른다.
  MOV DPTR, #HC541
  MOVX A, @DPTR ;// 541에 흘러 들어가는 전류가 있는지 확인한다.
  JB ACC.0, KEY_OUT_SW_14 ;// 마지막 비트에 전류가 흐르면 KEY_0가 눌러진 상태다.
  JB ACC.1, KEY_OUT_SW_17 ;// 두번째 비트에 전류가 흐르면 KEY_1이 눌러진 상태MOV DPTR, #HC574 ;// 574를 가리킨다.
  JB ACC.2, KEY_OUT_SW_20
  JB ACC.3, KEY_OUT_SW_23
  
  MOV OLD_KEY_OUT_FLAG3, #0FFH ;// 키를 누르고 뗀 후에는 OLD_KEY_FLAG값을 초기화 해준다.
  MOV OLD_KEY_OUT_FLAG4, #0FFH
  RET ;// 아무키도 눌러지지 않았을 때는 메인함수로 나간다.
  KEY_OUT_SW_12: ;// 첫번째 키가 눌러진 경우
  SETB KEY_OUT_12 ;// 키 플래그를 SET시켜준다.
  JMP KEY_OUT_CHG_CHK3 ;// 키 값에 대한 액션을 취하기 전에 키를 꾹누를 때도 한번만 실행되도록 비교한다.
  KEY_OUT_SW_13: ;// 두번째 키가 눌러진 경우
  SETB KEY_OUT_13
  JMP KEY_OUT_CHG_CHK3
  KEY_OUT_SW_14: ;// 세번째 키가 눌러진 경우
  SETB KEY_OUT_14
  JMP KEY_OUT_CHG_CHK3
  KEY_OUT_SW_15: ;// 네번째 키가 눌러진 경우
  SETB KEY_OUT_15
  JMP KEY_OUT_CHG_CHK3
  KEY_OUT_SW_16: ;// 다섯번째 키가 눌러진 경우
  SETB KEY_OUT_16
  JMP KEY_OUT_CHG_CHK3
  KEY_OUT_SW_17: ;// 여섯번째 키가 눌러진 경우
  SETB KEY_OUT_17
  JMP KEY_OUT_CHG_CHK3
  KEY_OUT_SW_18: ;// 일곱번째 키가 눌러진 경우
  SETB KEY_OUT_18
  JMP KEY_OUT_CHG_CHK4
  KEY_OUT_SW_19: ;// 여덟번째 키가 눌러진 경우
  SETB KEY_OUT_19
  JMP KEY_OUT_CHG_CHK4
  KEY_OUT_SW_20: ;// 아홉번째 키가 눌러진 경우
  SETB KEY_OUT_20
  JMP KEY_OUT_CHG_CHK4
  KEY_OUT_SW_21: ;// 열번째 키가 눌러진 경우
  SETB KEY_OUT_21
  JMP KEY_OUT_CHG_CHK4
  KEY_OUT_SW_22: ;// 열한번째 키가 눌러진 경우
  SETB KEY_OUT_22
  JMP KEY_OUT_CHG_CHK4
  KEY_OUT_SW_23: ;// 열두번째 키가 눌러진 경우
  SETB KEY_OUT_23
  JMP KEY_OUT_CHG_CHK4
  
  KEY_OUT_CHG_CHK3: ;// 한개의 키가 꾸욱 눌러졌는지 비교한다.
  MOV A, KEY_OUT_FLAG3 ;// 현재의 키 값을 저장한다.
  CJNE A, OLD_KEY_OUT_FLAG3, KEY_OUT_12_ACTION ;// 한번 실행 한 값과 현재의 키 값이 다른 경우만 키 값에 따른 액션을 취하도록한다.
  JMP KEY_OUT_CHG_CHK2 ;// 한번 실행했던 값과 현재의 키 값이 같으면 키 체크를 끝낸다.
  KEY_OUT_12_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_12, KEY_OUT_13_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_12_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_13_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_13, KEY_OUT_14_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_13_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_14_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_14, KEY_OUT_15_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_14_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_15_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_15, KEY_OUT_16_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_15_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_16_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_16, KEY_OUT_17_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_16_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_17_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_17, KEY_CHECK_OUT_2_END;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_17_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_CHG_CHK4: ;// 한개의 키가 꾸욱 눌러졌는지 비교한다.
  MOV A, KEY_OUT_FLAG4 ;// 현재의 키 값을 저장한다.
  CJNE A, OLD_KEY_OUT_FLAG4, KEY_OUT_18_ACTION ;// 한번 실행 한 값과 현재의 키 값이 다른 경우만 키 값에 따른 액션을 취하도록한다.
  JMP KEY_CHECK_OUT_2_END ;// 한번 실행했던 값과 현재의 키 값이 같으면 키 체크를 끝낸다.
  KEY_OUT_18_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_18, KEY_OUT_19_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_18_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_19_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_19, KEY_OUT_20_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_19_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_20_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_20, KEY_OUT_21_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_20_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_21_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_21, KEY_OUT_22_ACTION;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_21_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_22_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_22, KEY_OUT_23_ACTION ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_22_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_OUT_23_ACTION: ;// 첫번재 키가 눌러진 경우
  JNB KEY_OUT_23, KEY_CHECK_OUT_2_END ;// 키 플래그 확인, 아니면 다음 플래그를 확인하러 점프
  CALL KEY_OUT_23_CHK
  JMP KEY_CHECK_OUT_2_END
  
  KEY_CHECK_OUT_2_END: ;// 키 체크 끝
  MOV OLD_KEY_OUT_FLAG3, KEY_OUT_FLAG3 ;// 현재 누르고 있는 키를 저장
  MOV OLD_KEY_OUT_FLAG4, KEY_OUT_FLAG4
  RET ;// 메인 함수로
  
  
  ;;============================================================================================
  ;;
  ;; # KEY_OUT_0_CHK :
  ;;
  ;; 외부의 키를 눌렀을 때 그에 따른 동작을 한다.
  ;;
  ;;============================================================================================
  KEY_OUT_0_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_0_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_0_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_0_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #01H ;// 첫번째 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_0_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_0_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #01H ;// 두번째 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_0_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_0_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #01H ;// 세번쩨 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_0_NUM_4:
  MOV SEG_NUM_4, #01H ;// 네번째 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_1_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_1_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_1_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_1_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #02H ;// 첫번째 세그먼트의 변수에 2저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_1_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_1_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #02H ;// 두번째 세그먼트의 변수에 2저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_1_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_1_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #02H ;// 세번쩨 세그먼트의 변수에 2저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_1_NUM_4:
  MOV SEG_NUM_4, #02H ;// 네번째 세그먼트의 변수에 2저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  KEY_OUT_2_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_2_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_2_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_2_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #03H ;// 첫번째 세그먼트의 변수에 3저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_2_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_2_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #03H ;// 두번째 세그먼트의 변수에 3저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_2_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_2_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #03H ;// 세번쩨 세그먼트의 변수에 3저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_2_NUM_4:
  MOV SEG_NUM_4, #03H ;// 네번째 세그먼트의 변수에 3저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_3_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_3_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_3_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_3_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #04H ;// 첫번째 세그먼트의 변수에 4저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_3_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_3_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #04H ;// 두번째 세그먼트의 변수에 4저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_3_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_3_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #04H ;// 세번쩨 세그먼트의 변수에 4저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_3_NUM_4:
  MOV SEG_NUM_4, #04H ;// 네번째 세그먼트의 변수에 4저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  KEY_OUT_4_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_4_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_4_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_4_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #05H ;// 첫번째 세그먼트의 변수에 5저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_4_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_4_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #05H ;// 두번째 세그먼트의 변수에 5저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_4_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_4_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #05H ;// 세번쩨 세그먼트의 변수에 5저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_4_NUM_4:
  MOV SEG_NUM_4, #05H ;// 네번째 세그먼트의 변수에 5저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_5_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_5_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_5_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_5_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #06H ;// 첫번째 세그먼트의 변수에 6저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_5_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_5_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #06H ;// 두번째 세그먼트의 변수에 6저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_5_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_5_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #06H ;// 세번쩨 세그먼트의 변수에 6저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_5_NUM_4:
  MOV SEG_NUM_4, #06H ;// 네번째 세그먼트의 변수에 6저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_6_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_6_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_6_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_6_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #07H ;// 첫번째 세그먼트의 변수에 7저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_6_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_6_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #07H ;// 두번째 세그먼트의 변수에 7저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_6_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_6_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #07H ;// 세번쩨 세그먼트의 변수에 7저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_6_NUM_4:
  MOV SEG_NUM_4, #07H ;// 네번째 세그먼트의 변수에 7저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_7_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_7_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_7_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_7_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #08H ;// 첫번째 세그먼트의 변수에 8저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_7_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_7_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #08H ;// 두번째 세그먼트의 변수에 8저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_7_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_7_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #08H ;// 세번쩨 세그먼트의 변수에 8저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_7_NUM_4:
  MOV SEG_NUM_4, #08H ;// 네번째 세그먼트의 변수에 8저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_8_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_8_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_8_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_8_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #09H ;// 첫번째 세그먼트의 변수에 9저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_8_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_8_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #09H ;// 두번째 세그먼트의 변수에 9저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_8_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_8_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #09H ;// 세번쩨 세그먼트의 변수에 9저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_8_NUM_4:
  MOV SEG_NUM_4, #09H ;// 네번째 세그먼트의 변수에 9저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_9_CHK:
  JB MOTOR_1_OPEN_FLAG, KEY_OUT_9_CHK_END ;// 차단기가 열려있는 경우는 함수 나감
  
  KEY_OUT_9_MID_1:
  MOV A, SEG_NUM_1 ;// 첫번째 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_9_MID_2
  RET
  KEY_OUT_9_MID_2:
  MOV A, SEG_NUM_2 ;// 두번재 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_9_MID_3
  RET
  KEY_OUT_9_MID_3:
  MOV A, SEG_NUM_3 ;// 세번째 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_9_MID_4
  RET
  KEY_OUT_9_MID_4:
  MOV A, SEG_NUM_4 ;// 네번째 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_9_MID_5
  RET
  KEY_OUT_9_MID_5:
  MOV PACKET_COUNT, #01H ;// 패킷 카운트에 입구의 데이터임을 저장
  MOV A, SEG_NUM_1 ;// 숫자 네개를 XOR해서 체크섬 만듬
  XRL A, SEG_NUM_2
  XRL A, SEG_NUM_3
  XRL A, SEG_NUM_4
  MOV CHECK_SUM, A ;// XOR결과 값을 체크섬에 저장
  
  CALL SERIAL_OUTPUT_1 ;// VB로 데이터를 전송하는 함수
  CALL INITIAL_MID ;// 전송 후 데이터 초기화
  
  MOV DPTR, #A8255 ;// 포트A를 선택한다.
  MOV A, #00H ;// 데이터를 00H로 준다.
  MOVX @DPTR,A ;// 포트 A로 뿌린다.
  MOV DPTR, #C8255 ;// 포트C를 선택한다.
  MOV A, #0F7H ;// 4번째 세그먼트를 선택한다.
  MOVX @DPTR, A ;// 포트 C로 뿌린다.
  
  KEY_OUT_9_CHK_END:
  RET
  
  KEY_OUT_10_CHK:
  MOV A, SEG_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_10_NUM_1
  MOV SEG_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_10_NUM_1:
  MOV A, SEG_NUM_COUNT
  CJNE A, #00H, KEY_OUT_10_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV SEG_NUM_1, #00H ;// 첫번째 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, SEG_NUM_2
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_3
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_4
  CJNE A, #00H, KEY_OUT_10_CHK_END
  CALL SEG_CLEAR
  RET
  
  KEY_OUT_10_NUM_2:
  MOV A, SEG_NUM_COUNT
  CJNE A, #01H, KEY_OUT_10_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV SEG_NUM_2, #00H ;// 두번째 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, SEG_NUM_3
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_4
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_1
  CJNE A, #00H, KEY_OUT_10_CHK_END
  CALL SEG_CLEAR
  RET
  
  KEY_OUT_10_NUM_3:
  MOV A, SEG_NUM_COUNT
  CJNE A, #02H, KEY_OUT_10_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV SEG_NUM_3, #00H ;// 세번쩨 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, SEG_NUM_4
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_1
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_2
  CJNE A, #00H, KEY_OUT_10_CHK_END
  CALL SEG_CLEAR
  RET
  
  
  KEY_OUT_10_NUM_4:
  MOV SEG_NUM_4, #00H ;// 네번째 세그먼트의 변수에 1저장.
  INC SEG_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, SEG_NUM_1
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_2
  CJNE A, #00H, KEY_OUT_10_CHK_END
  MOV A, SEG_NUM_3
  CJNE A, #00H, KEY_OUT_10_CHK_END
  CALL SEG_CLEAR
  
  KEY_OUT_10_CHK_END:
  RET ;// 함수 나감.
  
  KEY_OUT_11_CHK:
  CALL INITIAL_MID ;// 전송 후 데이터 초기화
  
  MOV DPTR, #A8255 ;// 포트A를 선택한다.
  MOV A, #00H ;// 데이터를 00H로 준다.
  MOVX @DPTR,A ;// 포트 A로 뿌린다.
  MOV DPTR, #C8255 ;// 포트C를 선택한다.
  MOV A, #0F7H ;// 4번째 세그먼트를 선택한다.
  MOVX @DPTR, A ;// 포트 C로 뿌린다.
  
  KEY_OUT_11_CHK_END:
  RET
  
  
  
  KEY_OUT_12_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_12_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_12_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_12_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #01H ;// 첫번째 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_12_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_12_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #01H ;// 두번째 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_12_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_12_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #01H ;// 세번쩨 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_12_NUM_4:
  MOV LCD_NUM_4, #01H ;// 네번째 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_13_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_13_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_13_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_13_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #02H ;// 첫번째 세그먼트의 변수에 2저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_13_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_13_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #02H ;// 두번째 세그먼트의 변수에 2저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_13_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_13_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #02H ;// 세번쩨 세그먼트의 변수에 2저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_13_NUM_4:
  MOV LCD_NUM_4, #02H ;// 네번째 세그먼트의 변수에 2저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  KEY_OUT_14_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_14_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_14_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_14_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #03H ;// 첫번째 세그먼트의 변수에 3저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_14_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_14_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #03H ;// 두번째 세그먼트의 변수에 3저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_14_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_14_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #03H ;// 세번쩨 세그먼트의 변수에 3저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_14_NUM_4:
  MOV LCD_NUM_4, #03H ;// 네번째 세그먼트의 변수에 3저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_15_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_15_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_15_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_15_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #04H ;// 첫번째 세그먼트의 변수에 4저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_15_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_15_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #04H ;// 두번째 세그먼트의 변수에 4저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_15_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_15_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #04H ;// 세번쩨 세그먼트의 변수에 4저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_15_NUM_4:
  MOV LCD_NUM_4, #04H ;// 네번째 세그먼트의 변수에 4저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  KEY_OUT_16_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_16_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_16_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_16_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #05H ;// 첫번째 세그먼트의 변수에 5저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_16_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_16_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #05H ;// 두번째 세그먼트의 변수에 5저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_16_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_16_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #05H ;// 세번쩨 세그먼트의 변수에 5저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_16_NUM_4:
  MOV LCD_NUM_4, #05H ;// 네번째 세그먼트의 변수에 5저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_17_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_17_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_17_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_17_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #06H ;// 첫번째 세그먼트의 변수에 6저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_17_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_17_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #06H ;// 두번째 세그먼트의 변수에 6저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_17_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_17_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #06H ;// 세번쩨 세그먼트의 변수에 6저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_17_NUM_4:
  MOV LCD_NUM_4, #06H ;// 네번째 세그먼트의 변수에 6저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_18_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_18_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_18_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_18_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #07H ;// 첫번째 세그먼트의 변수에 7저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_18_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_18_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #07H ;// 두번째 세그먼트의 변수에 7저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_18_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_18_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #07H ;// 세번쩨 세그먼트의 변수에 7저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_18_NUM_4:
  MOV LCD_NUM_4, #07H ;// 네번째 세그먼트의 변수에 7저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_19_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_19_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_19_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_19_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #08H ;// 첫번째 세그먼트의 변수에 8저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_19_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_19_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #08H ;// 두번째 세그먼트의 변수에 8저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_19_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_19_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #08H ;// 세번쩨 세그먼트의 변수에 8저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_19_NUM_4:
  MOV LCD_NUM_4, #08H ;// 네번째 세그먼트의 변수에 8저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_20_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_20_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_20_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_20_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #09H ;// 첫번째 세그먼트의 변수에 9저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_20_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_20_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #09H ;// 두번째 세그먼트의 변수에 9저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_20_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_20_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #09H ;// 세번쩨 세그먼트의 변수에 9저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_20_NUM_4:
  MOV LCD_NUM_4, #09H ;// 네번째 세그먼트의 변수에 9저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  RET ;// 함수 나감.
  
  KEY_OUT_21_CHK:
  JB MOTOR_2_OPEN_FLAG, KEY_OUT_21_CHK_END ;// 차단기가 열려있는 경우는 함수 나감
  
  KEY_OUT_21_MID_1:
  MOV A, LCD_NUM_1 ;// 첫번째 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_21_MID_2
  RET
  KEY_OUT_21_MID_2:
  MOV A, LCD_NUM_2 ;// 두번재 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_21_MID_3
  RET
  KEY_OUT_21_MID_3:
  MOV A, LCD_NUM_3 ;// 세번째 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_21_MID_4
  RET
  KEY_OUT_21_MID_4:
  MOV A, LCD_NUM_4 ;// 네번째 숫자를 입력 받았는지 체크
  CJNE A, #0E0H, KEY_OUT_21_MID_5
  RET
  KEY_OUT_21_MID_5:
  MOV PACKET_COUNT, #02H ;// 패킷 카운트에 출구의 데이터임을 저장
  MOV A, LCD_NUM_1 ;// 숫자 네개를 XOR해서 체크섬 만듬
  XRL A, LCD_NUM_2
  XRL A, LCD_NUM_3
  XRL A, LCD_NUM_4
  MOV CHECK_SUM, A ;// XOR결과 값을 체크섬에 저장
  
  CALL SERIAL_OUTPUT_2 ;// VB로 데이터를 전송하는 함수
  CALL INITIAL_MID ;// 전송 후 데이터 초기화
  
  KEY_OUT_21_CHK_END:
  RET
  
  KEY_OUT_22_CHK:
  MOV A, LCD_NUM_COUNT ;// 숫자 4개를 입력 받았으면
  CJNE A, #04H, KEY_OUT_22_NUM_1
  MOV LCD_NUM_COUNT, #00H ;// 카운트를 0으로 만들어준다.
  
  KEY_OUT_22_NUM_1:
  MOV A, LCD_NUM_COUNT
  CJNE A, #00H, KEY_OUT_22_NUM_2 ;// 첫번째 세그먼트의 값인지 확인.
  MOV LCD_NUM_1, #00H ;// 첫번째 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, LCD_NUM_2
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_3
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_4
  CJNE A, #00H, KEY_OUT_22_CHK_END
  CALL LCD_CLEAR
  RET ;// 함수 나감.
  
  KEY_OUT_22_NUM_2:
  MOV A, LCD_NUM_COUNT
  CJNE A, #01H, KEY_OUT_22_NUM_3 ;// 두번재 세그먼트의 값인지 확인.
  MOV LCD_NUM_2, #00H ;// 두번째 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, LCD_NUM_3
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_4
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_1
  CJNE A, #00H, KEY_OUT_22_CHK_END
  CALL LCD_CLEAR
  RET ;// 함수 나감.
  
  KEY_OUT_22_NUM_3:
  MOV A, LCD_NUM_COUNT
  CJNE A, #02H, KEY_OUT_22_NUM_4 ;// 세번재 세그먼트의 값인지 확인
  MOV LCD_NUM_3, #00H ;// 세번쩨 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  
  MOV A, LCD_NUM_4
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_1
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_2
  CJNE A, #00H, KEY_OUT_22_CHK_END
  CALL LCD_CLEAR
  RET ;// 함수 나감.
  
  KEY_OUT_22_NUM_4:
  MOV LCD_NUM_4, #00H ;// 네번째 세그먼트의 변수에 1저장.
  INC LCD_NUM_COUNT ;// 숫자 입력을 확인한 경우, 카운터 1증가
  MOV A, LCD_NUM_1
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_2
  CJNE A, #00H, KEY_OUT_22_CHK_END
  MOV A, LCD_NUM_3
  CJNE A, #00H, KEY_OUT_22_CHK_END
  CALL LCD_CLEAR
  
  KEY_OUT_22_CHK_END:
  RET ;// 함수 나감.
  
  
  
  KEY_OUT_23_CHK:
  CALL INITIAL_MID ;// 전송 후 데이터 초기화
  CALL LCD_CLEAR
  KEY_OUT_23_CHK_END:
  RET
  
  
  PS) 공학학사, 석사가 아니라서 지금 돈 못벌고 안하고 있다. 설치지나 마라