Amkor/ENIG

Fork 0

Files

ChiKyun Kim 9a9ca4cf32 copilot file backup

2025-09-18 17:25:14 +09:00

25 KiB

Raw Blame History

AGV 경로 계산 알고리즘 설계 문서

1. 시스템 개요

1.1 AGV 하드웨어 특성

구조: 리프트 - 몸체 - 모니터 (가로 직사각형)
이동: 전진/후진만 가능, 제자리 회전 불가
제어: 마그넷 라인 트레이서 (magnet left/right/straight)
도킹: 전진 도킹(충전기), 후진 도킹(버퍼, 로더 등)

1.2 핵심 제약사항

제자리 회전 불가: 방향 전환을 위해서는 갈림길 이용 필수
갈림길 조건: 인접 노드 3개 이상 필요
도킹 조건: AGV 방향과 목적지 도킹 방향이 일치해야 함
상태 의존성: 이전 이동 정보 없이는 현재 방향 판단 불가
인접노드 경유 필수: 갈림길에서 방향전환시 반드시 인접노드를 경유해야 함

2. 경로 계산 알고리즘 아키텍처

2.1 다단계 경로 계산 방식

1단계: 기본 최단 경로 계산
     ↓
2단계: 방향 호환성 검증
     ↓
3단계: 방향 전환 경로 생성 (필요시)
     ↓
4단계: 최종 경로 최적화

2.2 핵심 클래스 구조

AGVPathCalculator (메인 경로 계산기)
├── BasicPathFinder (기본 최단 경로)
├── DirectionAnalyzer (방향 분석 및 호환성 검증)
├── TurnAroundPlanner (방향 전환 경로 계획)
└── PathOptimizer (경로 최적화)

3. 세부 알고리즘 설계

3.1 AGV 상태 모델

public class AgvState
{
    public string CurrentNodeId { get; set; }      // 현재 위치 (RFID)
    public string PreviousNodeId { get; set; }    // 이전 위치 (방향 판단용)
    public AgvDirection MotorDirection { get; set; } // 현재 모터 방향
    public AgvDirection LiftDirection { get; set; }  // 리프트가 향하는 방향
    public AgvDirection MonitorDirection { get; set; } // 모니터가 향하는 방향
}

3.2 방향 판단 알고리즘

3.2.1 현재 AGV 방향 계산

IF 이전노드 → 현재노드 이동 시 모터방향이 전진:
    리프트 방향 = 이전노드 방향
    모니터 방향 = 현재노드에서 이전노드 반대 방향

IF 이전노드 → 현재노드 이동 시 모터방향이 후진:
    리프트 방향 = 현재노드에서 이전노드 반대 방향
    모니터 방향 = 이전노드 방향

3.2.2 도킹 호환성 검증

FOR 목적지 노드:
    IF 목적지.도킹타입 == 전진도킹 (충전기):
        RETURN 모니터방향 == 목적지방향

    IF 목적지.도킹타입 == 후진도킹 (버퍼, 로더):
        RETURN 리프트방향 == 목적지방향

3.3 기본 경로 계산 (1단계)

3.3.1 단순 최단 경로 알고리즘

알고리즘: Dijkstra 또는 BFS (AGV 특성상 가중치가 단순)
목적: 방향 고려 없이 순수한 최단 거리 경로
출력: 노드 시퀀스 [시작 → ... → 목적지]

기본경로 = BFS_최단경로(시작노드, 목적지노드)
예시: 003 → 002 → 001 (언로더)

3.4 방향 호환성 검증 (2단계)

3.4.1 경로상 방향 시뮬레이션

FOR 각 경로 단계:
    현재_AGV_방향 = 시뮬레이션_이동(이전노드, 현재노드, 모터방향)

    IF 현재노드 == 목적지:
        도킹_가능 = 검증_도킹_호환성(현재_AGV_방향, 목적지_도킹타입)

IF 도킹_가능:
    RETURN 기본경로 (방향 전환 불필요)
ELSE:
    PROCEED TO 3단계 (방향 전환 필요)

3.5 방향 전환 경로 계획 (3단계)

3.5.1 갈림길 탐색 알고리즘

갈림길_후보 = []

FOR 기본경로상의 각 노드:
    IF 노드.인접노드수 >= 3:
        갈림길_후보.ADD(노드)

IF 갈림길_후보 == 빈목록:
    // 기본경로에 갈림길 없음 → 외부 갈림길 탐색
    가장_가까운_갈림길 = BFS_갈림길_탐색(현재위치)
    갈림길_후보.ADD(가장_가까운_갈림길)

3.5.2 방향 전환 시퀀스 계획

선택된_갈림길 = 갈림길_후보[0] // 가장 가까운 갈림길

// Phase 1: 갈림길까지 이동 (현재 모터 방향 유지)
Phase1_경로 = 현재위치 → 선택된_갈림길

// Phase 2: 갈림길에서 우회 (인접 노드 경유 필수)
우회_노드 = 계산_우회_방향(선택된_갈림길, 현재_진입_방향)
Phase2_경로 = 선택된_갈림길 → 우회_노드
// 중요: AGV는 갈림길에서 직접 되돌아갈 수 없으므로 반드시 인접노드 방문

// Phase 3: 모터 방향 전환 + 갈림길 재진입
모터방향 = 반전(현재_모터방향)
Phase3_경로 = 우회_노드 → 선택된_갈림길
// 우회노드에서 모터방향 전환 후 갈림길로 복귀

// Phase 4: 목적지까지 이동 (전환된 방향으로)
Phase4_경로 = 선택된_갈림길 → 목적지

3.5.3 갈림길 방향 선택 우선순위

FOR 갈림길의 각 인접노드 (진입방향 제외):
    방향타입 = 계산_마그넷_방향(진입방향, 인접노드방향)

    우선순위:
    1. Straight (직진)
    2. Left (왼쪽)
    3. Right (오른쪽)

선택된_방향 = 우선순위가_가장_높은_방향

3.6 최종 경로 최적화 (4단계)

3.6.1 경로 검증

FOR 최종경로의 각 단계:
    1. 연결성 검증 (모든 인접 노드가 실제 연결되어 있는가)
    2. 마그넷 방향 일관성 검증
    3. 도킹 방향 최종 검증

3.6.2 경로 최적화

IF 여러 갈림길 옵션 존재:
    각_옵션별_총거리 = 계산_총_이동거리(옵션)
    최적_경로 = MIN(각_옵션별_총거리)

4. 데이터 구조 설계

4.1 입력 데이터

public class PathRequest
{
    public AgvState CurrentState { get; set; }    // 현재 AGV 상태
    public string TargetRfidId { get; set; }      // 목적지 RFID
    public MapData MapData { get; set; }          // 맵 데이터
}

4.2 출력 데이터

public class PathResult
{
    public bool Success { get; set; }
    public List<PathStep> Steps { get; set; }     // 단계별 상세 경로
    public string ErrorMessage { get; set; }
    public PathMetrics Metrics { get; set; }     // 성능 지표
}

public class PathStep
{
    public string RfidId { get; set; }           // UI 표시용 RFID
    public string NodeId { get; set; }          // 내부 처리용 NodeID
    public AgvDirection MotorDirection { get; set; }
    public MagnetDirection MagnetDirection { get; set; }
    public string Action { get; set; }          // "이동", "방향전환", "도킹" 등
    public string Description { get; set; }      // 사용자 친화적 설명
}

5. 예외 상황 처리

5.1 불가능한 경로

갈림길 없음: 방향 전환이 불가능한 맵 구조
고립된 노드: 연결이 끊어진 노드
순환 참조: 무한 루프 방지

5.2 복구 전략

IF 방향전환_불가능:
    RETURN 오류 "목적지 도킹 불가능 - 갈림길 부족"

IF 경로_없음:
    RETURN 오류 "목적지 접근 불가능 - 맵 연결 확인 필요"

IF 계산시간_초과:
    RETURN 오류 "경로 계산 시간 초과 - 맵 복잡도 점검 필요"

6. 성능 최적화 전략

6.1 캐싱 전략

맵 구조 캐싱: 갈림길 노드, 인접 노드 정보
거리 매트릭스: 자주 사용되는 노드 간 거리
방향 전환 패턴: 성공한 방향 전환 시퀀스

6.2 알고리즘 최적화

조기 종료: 방향 호환 시 3-4단계 건너뛰기
휴리스틱: 갈림길 선택 시 목적지 방향 고려
병렬 처리: 여러 갈림길 옵션 동시 계산

7. 테스트 시나리오

7.1 기본 시나리오

직선 경로: 003 → 002 → 001 (방향 호환)
방향 전환: 003(후진) → 001(언로더) 도킹
복잡한 갈림길: 여러 갈림길이 있는 경우

7.3 실제 맵 검증 시나리오 (NewMap.agvmap 기반)

시나리오: AGV가 034→033 (전진) 상태에서 040(BUF2, 후진도킹) 목적지

기본경로: 033 → 032 → 040
방향호환성: 전진 ≠ 후진 → 방향전환 필요
갈림길: 032 (3개 연결: 031, 033, 040)
4단계 시퀀스:
1. 033 → 032 (전진, magnet right)
2. 032 → 031 (전진, magnet left) - 인접노드 경유
3. 031 → 032 (후진, magnet right) - 모터방향 전환
4. 032 → 040 (후진, magnet straight) - 도킹성공

검증포인트:

032는 Position(148,545)를 중심으로 031(서쪽), 033(동쪽), 040(남쪽) 연결
마그넷 방향 계산시 실제 좌표 기반 방향 확인 필수
040에서 032로의 복귀는 인접노드(031) 경유 없이 불가능

7.2 경계 조건

동일 위치: 시작 = 목적지
인접 노드: 한 번만 이동하면 되는 경우
최대 거리: 맵에서 가장 먼 두 지점

8. 구현 우선순위

Phase 1: 기본 기능

AgvState 및 PathStep 데이터 모델
기본 최단 경로 계산
방향 판단 로직

Phase 2: 고급 기능

방향 호환성 검증
갈림길 탐색 및 방향 전환
최종 경로 최적화

Phase 3: 최적화

성능 최적화 및 캐싱
예외 처리 강화
테스트 케이스 완성

9. 핵심 알고리즘 의사코드

9.1 메인 경로 계산 함수

FUNCTION CalculatePath(currentState, targetRfidId, mapData):
    // 1단계: 기본 최단 경로
    basicPath = FindShortestPath(currentState.CurrentNodeId, targetRfidId)

    // 2단계: 방향 호환성 검증
    IF IsDirectionCompatible(currentState, basicPath, targetRfidId):
        RETURN CreateSuccessResult(basicPath)

    // 3단계: 방향 전환 필요
    turnAroundPath = PlanTurnAround(currentState, basicPath, targetRfidId)

    // 4단계: 최적화
    optimizedPath = OptimizePath(turnAroundPath)

    RETURN CreateSuccessResult(optimizedPath)

9.2 방향 전환 계획 함수

FUNCTION PlanTurnAround(currentState, basicPath, targetRfidId):
    // 갈림길 찾기
    junctions = FindJunctionsInPath(basicPath)
    IF junctions.IsEmpty():
        junctions = FindNearestJunctions(currentState.CurrentNodeId)

    bestJunction = SelectBestJunction(junctions, targetRfidId)

    // 4단계 경로 생성 (인접노드 경유 필수)
    phase1 = PathToJunction(currentState, bestJunction)
    phase2 = DetourToAdjacentNode(bestJunction, currentState.MotorDirection)
    phase3 = ReturnToJunctionWithReversedMotor(phase2.EndNode, bestJunction)
    phase4 = PathFromJunctionToTarget(bestJunction, targetRfidId, !currentState.MotorDirection)

    RETURN CombinePaths(phase1, phase2, phase3, phase4)

9.3 마그넷 방향 계산 함수

FUNCTION CalculateMagnetDirection(fromNodeId, toNodeId, junctionNodeId):
    fromPos = GetNodePosition(fromNodeId)
    toPos = GetNodePosition(toNodeId)
    junctionPos = GetNodePosition(junctionNodeId)

    // 갈림길 진입 방향 벡터
    entryVector = Normalize(junctionPos - fromPos)

    // 갈림길 진출 방향 벡터
    exitVector = Normalize(toPos - junctionPos)

    // 외적을 이용한 방향 판단
    crossProduct = CrossProduct(entryVector, exitVector)
    dotProduct = DotProduct(entryVector, exitVector)

    IF Abs(dotProduct) > 0.8:  // 직진 허용 오차
        RETURN MagnetDirection.Straight
    ELSE IF crossProduct > 0:
        RETURN MagnetDirection.Left
    ELSE:
        RETURN MagnetDirection.Right

10. 핵심 설계 원칙 요약

10.1 AGV 하드웨어 제약사항 핵심

방향전환 불가: 제자리 회전 기능 없음 → 갈림길 필수 활용
인접노드 경유: 갈림길에서 직접 복귀 불가 → 반드시 인접노드 방문
양방향 연결: 맵 연결 정보는 단방향 저장, 실제는 양방향 해석
좌표 기반 마그넷: 노드 Position 좌표로 실제 마그넷 방향 계산

10.2 알고리즘 핵심 검증점

갈림길 조건: 인접노드 3개 이상 (진입방향 제외시 2개 선택지)
방향 호환성: 현재 AGV 방향 ≠ 목적지 도킹 방향 → 4단계 전환
마그넷 정확성: 벡터 외적/내적 기반 좌/우/직진 판단
경로 유효성: 모든 연결이 실제 맵에서 존재하는지 검증

10.3 실제 구현시 주의사항

RFID vs NodeID: 사용자 인터페이스는 RFID, 내부 로직은 NodeID
좌표계 정확성: Position 문자열 파싱시 정수 변환 검증
양방향 탐색: ConnectedNodes 뿐만 아니라 역방향 연결도 고려
에러 처리: 갈림길 부족, 경로 없음, 순환참조 등 예외 상황

11. NewMap.agvmap 갈림길 데이터 (참조용)

11.1 확인된 갈림길 노드 목록

주요 갈림길 (3개 이상 연결):

RFID	NodeId	Position	연결 노드	연결 RFID	용도
004	N004	380,340	N003, N022, N031	003, 012, 030	서쪽 주요 갈림길
005	N011	460,420	N012, N004, N015	006, 004, 037	중앙 주요 갈림길
012	N022	459,279	N004, N023, N006	004, 016, 013	중앙-북쪽 갈림길
032	N020	148,545	N021, N005, N028	031, 033, 040	남쪽 갈림길

11.2 갈림길별 방향전환 전략

RFID 005 (중앙 갈림길):

동쪽에서 진입 (006 → 005): 서쪽(004) 또는 남쪽(037)으로 우회 가능
서쪽에서 진입 (004 → 005): 동쪽(006) 또는 남쪽(037)으로 우회 가능
남쪽에서 진입 (037 → 005): 동쪽(006) 또는 서쪽(004)으로 우회 가능

RFID 004 (서쪽 갈림길):

동쪽에서 진입 (005 → 004): 서쪽(003) 또는 남쪽(030)으로 우회 가능
서쪽에서 진입 (003 → 004): 동쪽(005) 또는 남쪽(030)으로 우회 가능
남쪽에서 진입 (030 → 004): 동쪽(005) 또는 서쪽(003)으로 우회 가능

RFID 012 (중앙-북쪽 갈림길):

서쪽에서 진입 (004 → 012): 동쪽(013) 또는 북쪽(016)으로 우회 가능
동쪽에서 진입 (013 → 012): 서쪽(004) 또는 북쪽(016)으로 우회 가능
북쪽에서 진입 (016 → 012): 서쪽(004) 또는 동쪽(013)으로 우회 가능

RFID 032 (남쪽 갈림길):

동쪽에서 진입 (033 → 032): 서쪽(031) 또는 남쪽(040)으로 우회 가능
서쪽에서 진입 (031 → 032): 동쪽(033) 또는 남쪽(040)으로 우회 가능
남쪽에서 진입 (040 → 032): 동쪽(033) 또는 서쪽(031)으로 우회 가능

11.3 경로 계산시 갈림길 활용 지침

갈림길 우선순위: 목적지와 가까운 갈림길 우선 선택
우회 방향 선택: 막다른 길 < 2개 연결 < 3개 이상 연결 순서로 우선순위
마그넷 방향 계산: 실제 좌표 기반 벡터 계산으로 정확한 left/right/straight 판단
방향전환 검증: 갈림길에서 최소 1회 인접노드 경유 후 모터방향 전환

11.4 실제 활용 예시

007→006 전진모터 → 011(TOPS) 경로:

기본경로: 006 → 005 → 004 → 030 → 009 → 010 → 011
방향전환: 005 갈림길 활용 (006 → 005 → 037 → 005 → 004...)
결과: 후진 도킹으로 TOPS 접근 성공

034→033 전진모터 → 041(BUF1) 경로 ✅ 검증됨:

기본경로: 033 → 032 → 031 → 041
방향호환성: 전진 ≠ 후진 → 방향전환 필요
4단계 시퀀스:
1. 033 → 032 (전진, left)
2. 032 → 040 (전진, straight) - 인접노드 경유
3. 040 → 032 (후진, straight) - 모터방향 전환
4. 032 → 031 → 041 (후진, right → straight) - 도킹성공

12. 구현을 위한 핵심 알고리즘 요약

12.1 필수 구현 클래스

// 1. 메인 경로 계산기
public class AGVPathCalculator
{
    public PathResult CalculatePath(AgvState currentState, string targetRfidId, MapData mapData)

    // 핵심 의존성 클래스들
    private BasicPathFinder _basicPathFinder;
    private DirectionAnalyzer _directionAnalyzer;
    private TurnAroundPlanner _turnAroundPlanner;
    private JunctionFinder _junctionFinder;
}

// 2. 갈림길 탐색기 (중요!)
public class JunctionFinder
{
    public List<string> FindJunctionsInPath(List<string> path, MapData mapData)
    public List<string> FindNearestJunctions(string nodeId, MapData mapData)
    public bool IsJunction(string nodeId, MapData mapData) // 3개 이상 연결 확인
}

// 3. 방향 전환 계획기
public class TurnAroundPlanner
{
    public PathResult PlanTurnAroundPath(AgvState state, List<string> basicPath, string targetId)
    public string SelectBestDetourNode(string junctionId, string entryDirection, MapData mapData)
}

// 4. 마그넷 방향 계산기
public class MagnetDirectionCalculator
{
    public MagnetDirection CalculateDirection(string fromNodeId, string toNodeId, string junctionId, MapData mapData)
    // 벡터 외적/내적 기반 left/right/straight 판단
}

12.2 핵심 알고리즘 단계별 체크리스트

1단계: 기본 최단 경로

BFS/Dijkstra로 최단 경로 계산
양방향 연결 해석 (ConnectedNodes + 역방향 탐색)
RFID ↔ NodeID 매핑 처리

2단계: 방향 호환성 검증

현재 AGV 방향 계산 (이전노드 → 현재노드 + 모터방향)
목적지 도킹 방향 요구사항 확인 (Type + DockDirection)
최종 도착 시 AGV 방향 시뮬레이션

3단계: 방향 전환 (필요시)

경로상 갈림길 탐색 (3개 이상 연결 노드)
가장 가까운 갈림길 선택
4단계 시퀀스 생성:
- Phase1: 갈림길까지 이동
- Phase2: 인접노드 경유 (필수!)
- Phase3: 모터방향 전환 후 갈림길 복귀
- Phase4: 목적지까지 이동

4단계: 최적화 및 검증

마그넷 방향 정확성 검증 (좌표 기반 벡터 계산)
연결성 검증 (모든 단계가 실제 연결되어 있는지)
최종 도킹 방향 재검증

12.3 검증된 테스트 케이스

034→033→041: 방향전환 성공 (032 갈림길, 040 인접노드) ✅
034→033→040: 이전 분석에서 방향전환 성공 ✅
007→006→019: 직선 경로, 방향호환 ✅
007→006→001: 방향전환 필요 (004 갈림길) ✅
007→006→011: 방향전환 성공 (005 갈림길) ✅
031→032→001: 방향전환 필요 (004 갈림길, 030 인접노드) ✅
014→015→019: 방향전환 필요 (012 갈림길, 004 인접노드) ✅
018→019→015: 직선 경로, 방향호환 (막다른 길 시작) ✅

12.4 구현 우선순위

Phase 1 (핵심 기능):

MapData, AgvState, PathResult 모델 구현
BasicPathFinder (BFS 기반)
JunctionFinder (갈림길 탐색)
DirectionAnalyzer (방향 호환성)

Phase 2 (고급 기능):

TurnAroundPlanner (4단계 방향전환)
MagnetDirectionCalculator (벡터 기반)
PathOptimizer (경로 최적화)

Phase 3 (완성):

예외 처리 강화
성능 최적화
테스트 케이스 완성

13. 중요한 구현 주의사항 및 함정

13.1 AGV 방향성 함정 (매우 중요!)

함정 1: 막다른 길에서의 방향 전환 불가

❌ 잘못된 분석: "010에서 009로 후진 → 009에서 010으로 후진"
✅ 올바른 이해: 010(막다른 길)에서는 들어온 방향으로만 되돌아갈 수 있음
교훈: 갈림길에서만 방향전환 가능, 막다른 길/편도에서는 불가능

함정 2: 입구 방향과 출구 방향 혼동

❌ 잘못된 분석: "015→014 전진 후 014→015 전진"
✅ 올바른 이해: 014→015 전진으로 왔으면 015→014는 후진만 가능
교훈: AGV는 들어온 방향의 반대로만 되돌아갈 수 있음

함정 3: 가짜 갈림길 식별

❌ 잘못된 분석: "015-014-013-012는 갈림길"
✅ 올바른 이해: 이것은 편도 1차선, 진짜 갈림길은 3개 이상 연결
교훈: 연결 개수와 실제 구조를 정확히 파악해야 함

13.2 경로 계산 알고리즘 핵심 원칙

원칙 1: 막다른 길 우선순위

막다른 길에서 시작 → 방향 자동 결정 → 가장 간단한 케이스
예: 018→019→015 (후진→전진, 방향호환)

원칙 2: 가장 가까운 갈림길 활용

경로상 갈림길 없음 → 더 먼 갈림길 탐색
예: 014→015→019 (012 갈림길 활용, 004까지 갈 필요 없음)

원칙 3: 인접노드 경유 필수

갈림길에서 직접 되돌아가기 불가능
반드시 인접노드 방문 후 모터방향 전환

13.3 디버깅 체크리스트

방향 계산 검증:

현재 AGV 방향 정확히 계산 (이전→현재 + 모터방향)
목적지 도킹 방향 요구사항 확인
최종 도착 시 AGV 방향 시뮬레이션

갈림길 검증:

3개 이상 연결 확인 (편도 vs 진짜 갈림길)
양방향 연결 해석 (ConnectedNodes + 역방향)
인접노드 경유 가능성 확인

경로 유효성 검증:

모든 연결이 실제 존재하는지 확인
마그넷 방향 계산 정확성
막다른 길에서 방향전환 시도하지 않는지

13.4 성공 패턴

직선 경로 (방향호환): 034→033→040, 018→019→015
단일 갈림길 방향전환: 034→033→041 (032 갈림길)
원거리 갈림길 활용: 014→015→019 (012 갈림길)
복합 경로: 031→032→001 (004 갈림길, 030 인접노드)

이 설계 문서를 바탕으로 단계별로 구현을 진행하면, AGV의 복잡한 방향 전환 요구사항을 체계적으로 해결할 수 있습니다.

테스트 예제 (각 목표별 답안계산 : 경유 노드의 RFID도 모두 포함)

Q1-1.033->032(전진) : 목표 040,041,008,001,011,019,015 040 : 032 ->(F) 031 ->(R) 032 -> 040 041 : 032 ->(F) 040 ->(R) 032 -> 031 -> 041 008 : 032 ->(B) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 006 -> 007 -> 008 001 : 032 ->(B) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 003 -> 002 -> 001 011 : 032 ->(B) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 030 -> 009 -> 010 -> 011 019 : 032 ->(B) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 012 -> 013 ->(F) -> 012 -> 016 -> 017 -> 018 -> 019 015 : 032 ->(B) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 012 -> 016 ->(F) -> 012 -> 013 -> 014 -> 015

Q1-2.033->032(후진) : 목표 040,041,008,001,011,019,015 040 : 032 ->(F) 033 ->(R) 032 -> 040 041 : 032 ->(R) 031 -> 041 008 : 032 ->(F) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 ->(B) -> 005 -> 006 -> 007 -> 008 001 : 032 ->(F) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 006 ->(B) -> 004 -> 003 -> 002 -> 001 011 : 032 ->(F) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 003 ->(B) -> 004 -> 030 -> 009 -> 010 -> 011 032 ->(F) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 012 ->(B) -> 004 -> 030 -> 009 -> 010 -> 011 019 : 032 ->(F) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 012 -> 016 -> 017 -> 018 -> 019 015 : 032 ->(F) 033 -> 034 -> 035 -> 036 -> 037 -> 005 -> 004 -> 012 -> 013 -> 014 -> 015

Q2-1.006->007(전진) : 목표 040,041,008,001,011,019,015 040 : 007 ->(B) 006 -> 005 -> 037 -> 036 -> 035 -> 034 -> 033 -> 032 -> 040 041 : 007 ->(B) 006 -> 005 -> 037 -> 036 -> 035 -> 034 -> 033 -> 032 -> 031 -> 041 008 : 007 ->(F) 006 -> 005 -> 037 ->(B) 005 -> 006 -> 007 -> 008 001 : 007 ->(B) 006 -> 005 -> 004 -> 003 -> 002 -> 001 011 : 007 ->(B) 006 -> 005 -> 004 -> 030 -> 009 -> 010 -> 011 019 : 007 ->(B) 006 -> 005 -> 004 -> 012 -> 013 ->(F) 012 -> 016 -> 017 -> 018 -> 019 015 : 007 ->(B) 006 -> 005 -> 004 -> 012 -> 016 ->(F) 012 -> 013 -> 014 -> 015

Q2-2.006->007(후진) : 목표 040,041,008,001,011,019,015 040 : 007 ->(F) 006 -> 005 -> 004 ->(B) 005 -> 037 -> 036 -> 035 -> 034 -> 033 -> 032 -> 040 041 : 007 ->(F) 006 -> 005 -> 004 ->(B) 005 -> 037 -> 036 -> 035 -> 034 -> 033 -> 032 -> 031 -> 041 008 : 007 ->(B) 008 001 : 007 ->(F) 006 -> 005 -> 004 -> 030 ->(B) 004 -> 003 -> 002 -> 001 : 007 ->(F) 006 -> 005 -> 004 -> 012 ->(B) 004 -> 003 -> 002 -> 001 011 : 007 ->(F) 006 -> 005 -> 004 -> 003 ->(B) 004 -> 030 -> 009 -> 010 -> 011 007 ->(F) 006 -> 005 -> 004 -> 012 ->(B) 004 -> 030 -> 009 -> 010 -> 011 019 : 007 ->(F) 006 -> 005 -> 004 -> 012 -> 016 -> 017 -> 018 -> 019 015 : 007 ->(F) 006 -> 005 -> 004 -> 012 -> 013 -> 014 -> 015

Q3-1.009->010(전진) : 목표 040,041,008,001,011,019,015 Q3-2.009->010(후진) : 목표 040,041,008,001,011,019,015 Q4-1.013->014(전진) : 목표 040,041,008,001,011,019,015 Q4-2.013->014(후진) : 목표 040,041,008,001,011,019,015

Q5-1.033->032(전진) : 목표 040,041,008,001,011,019,015 Q5-2.033->032(후진) : 목표 040,041,008,001,011,019,015 Q6-1.006->007(전진) : 목표 040,041,008,001,011,019,015 Q6-2.006->007(후진) : 목표 040,041,008,001,011,019,015 Q7-1.009->010(전진) : 목표 040,041,008,001,011,019,015 Q7-2.009->010(후진) : 목표 040,041,008,001,011,019,015 Q8-1.013->014(전진) : 목표 040,041,008,001,011,019,015 Q8-2.013->014(후진) : 목표 040,041,008,001,011,019,015

25 KiB Raw Blame History