diff --git a/Cs_HMI/AGVCSharp.sln b/Cs_HMI/AGVCSharp.sln
index 7594e59..61e51ba 100644
--- a/Cs_HMI/AGVCSharp.sln
+++ b/Cs_HMI/AGVCSharp.sln
@@ -37,10 +37,13 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "솔루션 항목", "솔루
CHANGELOG.md = CHANGELOG.md
CLAUDE.md = CLAUDE.md
TODO.md = TODO.md
+ PATHSCENARIO.md = PATHSCENARIO.md
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AGVNavigationCore", "AGVNavigationCore\AGVNavigationCore.csproj", "{C5F7A8B2-8D3E-4A1B-9C6E-7F4D5E2A9B1C}"
EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AGVPathTester", "AGVPathTester\AGVPathTester.csproj", "{F1E2D3C4-B5A6-9788-0123-456789ABCDEF}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -207,6 +210,18 @@ Global
{C5F7A8B2-8D3E-4A1B-9C6E-7F4D5E2A9B1C}.Release|x64.Build.0 = Release|Any CPU
{C5F7A8B2-8D3E-4A1B-9C6E-7F4D5E2A9B1C}.Release|x86.ActiveCfg = Release|x86
{C5F7A8B2-8D3E-4A1B-9C6E-7F4D5E2A9B1C}.Release|x86.Build.0 = Release|x86
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Debug|x64.Build.0 = Debug|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Debug|x86.ActiveCfg = Debug|x86
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Debug|x86.Build.0 = Debug|x86
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Release|Any CPU.Build.0 = Release|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Release|x64.ActiveCfg = Release|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Release|x64.Build.0 = Release|Any CPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Release|x86.ActiveCfg = Release|x86
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}.Release|x86.Build.0 = Release|x86
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
diff --git a/Cs_HMI/AGVNavigationCore/PathFinding/Planning/DirectionChangePlanner.cs b/Cs_HMI/AGVNavigationCore/PathFinding/Planning/DirectionChangePlanner.cs
index 33a2940..13fc52a 100644
--- a/Cs_HMI/AGVNavigationCore/PathFinding/Planning/DirectionChangePlanner.cs
+++ b/Cs_HMI/AGVNavigationCore/PathFinding/Planning/DirectionChangePlanner.cs
@@ -84,7 +84,27 @@ namespace AGVNavigationCore.PathFinding.Planning
}
}
- // 방향 전환이 필요한 경우
+ // 방향 전환이 필요한 경우 - 먼저 간단한 직접 경로 확인
+ var directPath2 = _pathfinder.FindPath(startNodeId, targetNodeId);
+ if (directPath2.Success)
+ {
+ // 직접 경로에 갈림길이 포함된 경우 그 갈림길에서 방향 전환
+ foreach (var nodeId in directPath2.Path.Skip(1).Take(directPath2.Path.Count - 2)) // 시작과 끝 제외
+ {
+ var junctionInfo = _junctionAnalyzer.GetJunctionInfo(nodeId);
+ if (junctionInfo != null && junctionInfo.IsJunction)
+ {
+ // 간단한 방향 전환: 직접 경로 사용하되 방향 전환 노드 표시
+ return DirectionChangePlan.CreateSuccess(
+ directPath2.Path,
+ nodeId,
+ $"갈림길 {nodeId}에서 방향 전환: {currentDirection} → {requiredDirection}"
+ );
+ }
+ }
+ }
+
+ // 복잡한 방향 전환이 필요한 경우
return PlanDirectionChangeRoute(startNodeId, targetNodeId, currentDirection, requiredDirection);
}
diff --git a/Cs_HMI/AGVPathTester/AGVPathTester.csproj b/Cs_HMI/AGVPathTester/AGVPathTester.csproj
new file mode 100644
index 0000000..10b28c9
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/AGVPathTester.csproj
@@ -0,0 +1,82 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {F1E2D3C4-B5A6-9788-0123-456789ABCDEF}
+ Exe
+ AGVPathTester
+ AGVPathTester
+ v4.8
+ 512
+ true
+ true
+
+
+ AnyCPU
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ AnyCPU
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+ true
+ bin\x86\Debug\
+ DEBUG;TRACE
+ full
+ x86
+ prompt
+
+
+ bin\x86\Release\
+ TRACE
+ true
+ pdbonly
+ x86
+ prompt
+
+
+
+
+
+
+
+
+
+
+
+
+ ..\packages\Newtonsoft.Json.13.0.3\lib\net45\Newtonsoft.Json.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {C5F7A8B2-8D3E-4A1B-9C6E-7F4D5E2A9B1C}
+ AGVNavigationCore
+
+
+
+
\ No newline at end of file
diff --git a/Cs_HMI/AGVPathTester/App.config b/Cs_HMI/AGVPathTester/App.config
new file mode 100644
index 0000000..d8ef5cf
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/App.config
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Cs_HMI/AGVPathTester/PathTester.cs b/Cs_HMI/AGVPathTester/PathTester.cs
new file mode 100644
index 0000000..a195c78
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/PathTester.cs
@@ -0,0 +1,471 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AGVNavigationCore.Models;
+using AGVNavigationCore.PathFinding.Planning;
+
+namespace AGVPathTester
+{
+ ///
+ /// AGV 경로 탐색 및 방향전환 로직 테스트 클래스
+ ///
+ public class PathTester
+ {
+ private readonly string _mapFilePath;
+ private List _mapNodes;
+ private AGVPathfinder _pathfinder;
+ private DirectionChangePlanner _directionChangePlanner;
+
+ public PathTester(string mapFilePath)
+ {
+ _mapFilePath = mapFilePath;
+ _mapNodes = new List();
+ }
+
+ ///
+ /// PathTester 초기화
+ ///
+ public bool Initialize()
+ {
+ try
+ {
+ // 맵 파일 로딩
+ var mapLoadResult = MapLoader.LoadMapFromFile(_mapFilePath);
+ if (!mapLoadResult.Success)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 맵 로딩 실패: {mapLoadResult.ErrorMessage}");
+ Console.ResetColor();
+ return false;
+ }
+
+ _mapNodes = mapLoadResult.Nodes;
+
+ // PathFinder 초기화
+ _pathfinder = new AGVPathfinder(_mapNodes);
+
+ // DirectionChangePlanner 초기화
+ _directionChangePlanner = new DirectionChangePlanner(_mapNodes);
+
+ return true;
+ }
+ catch (Exception ex)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 초기화 중 오류: {ex.Message}");
+ Console.ResetColor();
+ return false;
+ }
+ }
+
+ ///
+ /// 로드된 노드 수 반환
+ ///
+ public int GetNodeCount()
+ {
+ return _mapNodes?.Count ?? 0;
+ }
+
+ ///
+ /// 기본 경로 탐색 테스트 실행
+ ///
+ public void RunBasicPathTests()
+ {
+ Console.WriteLine("🔍 기본 경로 탐색 테스트 시작...");
+
+ var testCases = TestCases.GetBasicPathTestCases();
+ int passCount = 0;
+ int totalCount = testCases.Count;
+
+ foreach (var testCase in testCases)
+ {
+ Console.WriteLine($"\n--- 테스트: {testCase.StartNodeId} → {testCase.TargetNodeId} ---");
+
+ var result = _pathfinder.FindPath(
+ GetNodeById(testCase.StartNodeId),
+ GetNodeById(testCase.TargetNodeId),
+ testCase.CurrentDirection
+ );
+
+ bool passed = EvaluateBasicPathResult(result, testCase);
+ if (passed) passCount++;
+
+ DisplayPathResult(result, testCase.Description);
+ }
+
+ // 결과 요약
+ Console.ForegroundColor = ConsoleColor.White;
+ Console.WriteLine($"\n📊 기본 경로 테스트 결과: {passCount}/{totalCount} 통과");
+ if (passCount == totalCount)
+ {
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("🎉 모든 기본 경로 테스트 통과!");
+ }
+ else
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($"⚠️ {totalCount - passCount}개 테스트 실패");
+ }
+ Console.ResetColor();
+ }
+
+ ///
+ /// 방향 전환 경로 테스트 실행
+ ///
+ public void RunDirectionChangeTests()
+ {
+ Console.WriteLine("🔄 방향 전환 경로 테스트 시작...");
+
+ var testCases = TestCases.GetDirectionChangeTestCases();
+ int passCount = 0;
+ int totalCount = testCases.Count;
+
+ foreach (var testCase in testCases)
+ {
+ Console.WriteLine($"\n--- 방향전환 테스트: {testCase.StartNodeId} → {testCase.TargetNodeId} ---");
+ Console.WriteLine($"현재방향: {testCase.CurrentDirection}, 요구방향: {testCase.RequiredDirection}");
+
+ var plan = _directionChangePlanner.PlanDirectionChange(
+ testCase.StartNodeId,
+ testCase.TargetNodeId,
+ testCase.CurrentDirection,
+ testCase.RequiredDirection
+ );
+
+ bool passed = EvaluateDirectionChangeResult(plan, testCase);
+ if (passed) passCount++;
+
+ DisplayDirectionChangePlan(plan, testCase.Description);
+ }
+
+ // 결과 요약
+ Console.ForegroundColor = ConsoleColor.White;
+ Console.WriteLine($"\n📊 방향전환 테스트 결과: {passCount}/{totalCount} 통과");
+ if (passCount == totalCount)
+ {
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("🎉 모든 방향전환 테스트 통과!");
+ }
+ else
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($"⚠️ {totalCount - passCount}개 테스트 실패");
+ }
+ Console.ResetColor();
+ }
+
+ ///
+ /// 단일 테스트 실행
+ ///
+ public void RunSingleTest(string startNodeId, string targetNodeId, AgvDirection currentDirection)
+ {
+ Console.WriteLine($"\n🎯 단일 테스트: {startNodeId} → {targetNodeId} (방향: {currentDirection})");
+
+ var startNode = GetNodeById(startNodeId);
+ var targetNode = GetNodeById(targetNodeId);
+
+ if (startNode == null)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 시작 노드를 찾을 수 없습니다: {startNodeId}");
+ Console.ResetColor();
+ return;
+ }
+
+ if (targetNode == null)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 목표 노드를 찾을 수 없습니다: {targetNodeId}");
+ Console.ResetColor();
+ return;
+ }
+
+ // 1. 기본 경로 탐색
+ Console.WriteLine("\n📍 기본 경로 탐색:");
+ var basicResult = _pathfinder.FindPath(startNode, targetNode, currentDirection);
+ DisplayPathResult(basicResult, "사용자 정의 테스트");
+
+ // 2. 방향 전환이 필요한지 확인
+ var requiredDirection = GetRequiredDockingDirection(targetNode);
+ if (requiredDirection.HasValue && requiredDirection.Value != currentDirection)
+ {
+ Console.WriteLine($"\n🔄 방향 전환 필요: {currentDirection} → {requiredDirection.Value}");
+ var plan = _directionChangePlanner.PlanDirectionChange(
+ startNodeId, targetNodeId, currentDirection, requiredDirection.Value);
+ DisplayDirectionChangePlan(plan, "방향전환 경로");
+ }
+ else
+ {
+ Console.WriteLine("\n✅ 방향 전환 불필요");
+ }
+ }
+
+ ///
+ /// 배치 테스트 실행
+ ///
+ public void RunBatchTests()
+ {
+ Console.WriteLine("📦 배치 테스트 실행 중...\n");
+
+ RunBasicPathTests();
+ Console.WriteLine("\n" + new string('=', 50) + "\n");
+ RunDirectionChangeTests();
+ }
+
+ ///
+ /// 맵 정보 표시
+ ///
+ public void ShowMapInfo()
+ {
+ Console.WriteLine($"📊 맵 파일: {_mapFilePath}");
+ Console.WriteLine($"🔢 총 노드 수: {_mapNodes.Count}");
+
+ // 노드 타입별 통계
+ var nodeStats = _mapNodes.GroupBy(n => n.Type)
+ .ToDictionary(g => g.Key, g => g.Count());
+
+ Console.WriteLine("\n📈 노드 타입별 통계:");
+ foreach (var stat in nodeStats)
+ {
+ Console.WriteLine($" {stat.Key}: {stat.Value}개");
+ }
+
+ // 도킹 방향별 통계
+ var dockingStats = _mapNodes.GroupBy(n => n.DockDirection)
+ .ToDictionary(g => g.Key, g => g.Count());
+
+ Console.WriteLine("\n🚢 도킹 방향별 통계:");
+ foreach (var stat in dockingStats)
+ {
+ Console.WriteLine($" {stat.Key}: {stat.Value}개");
+ }
+
+ // 연결 정보
+ var totalConnections = _mapNodes.Sum(n => n.ConnectedNodes.Count);
+ Console.WriteLine($"\n🔗 총 연결 수: {totalConnections}");
+
+ // 갈림길 정보 분석
+ ShowJunctionInfo();
+
+ // 샘플 노드 정보
+ Console.WriteLine("\n📋 샘플 노드 (처음 5개):");
+ foreach (var node in _mapNodes.Take(5))
+ {
+ var rfidInfo = string.IsNullOrEmpty(node.RfidId) ? "RFID 없음" : node.RfidId;
+ Console.WriteLine($" {node.NodeId}: {node.Type}, {node.DockDirection}, {rfidInfo}, 연결:{node.ConnectedNodes.Count}개");
+ }
+ }
+
+ ///
+ /// 갈림길 정보 분석 및 표시
+ ///
+ public void ShowJunctionInfo()
+ {
+ Console.WriteLine("\n🛤️ 갈림길 분석:");
+
+ var junctions = _mapNodes.Where(n => n.ConnectedNodes.Count > 2).ToList();
+ Console.WriteLine($"갈림길 노드 수: {junctions.Count}개");
+
+ foreach (var node in junctions)
+ {
+ Console.WriteLine($" {node.NodeId}: {node.ConnectedNodes.Count}개 연결 - {string.Join(", ", node.ConnectedNodes)}");
+
+ // DirectionChangePlanner의 JunctionAnalyzer에서 실제로 갈림길로 인식되는지 확인
+ var junctionInfo = _directionChangePlanner.GetType()
+ .GetField("_junctionAnalyzer", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?
+ .GetValue(_directionChangePlanner);
+
+ if (junctionInfo != null)
+ {
+ var getJunctionInfoMethod = junctionInfo.GetType().GetMethod("GetJunctionInfo");
+ var info = getJunctionInfoMethod?.Invoke(junctionInfo, new object[] { node.NodeId });
+
+ if (info != null)
+ {
+ Console.WriteLine($" -> JunctionAnalyzer 인식: {info}");
+ }
+ else
+ {
+ Console.WriteLine($" -> JunctionAnalyzer 인식: null (인식 실패)");
+ }
+ }
+ }
+
+ if (junctions.Count == 0)
+ {
+ Console.WriteLine(" ⚠️ 갈림길 노드가 없습니다! 이것이 방향전환 실패의 원인일 수 있습니다.");
+ }
+ }
+
+ #region Private Helper Methods
+
+ private MapNode GetNodeById(string nodeId)
+ {
+ return _mapNodes.FirstOrDefault(n => n.NodeId == nodeId);
+ }
+
+ private AgvDirection? GetRequiredDockingDirection(MapNode targetNode)
+ {
+ switch (targetNode.DockDirection)
+ {
+ case DockingDirection.Forward:
+ return AgvDirection.Forward;
+ case DockingDirection.Backward:
+ return AgvDirection.Backward;
+ case DockingDirection.DontCare:
+ default:
+ return null;
+ }
+ }
+
+ private bool EvaluateBasicPathResult(AGVNavigationCore.PathFinding.Core.AGVPathResult result, TestCases.BasicPathTestCase testCase)
+ {
+ // 기본 평가: 성공 여부와 경로 존재 여부
+ bool basicSuccess = result.Success && result.Path != null && result.Path.Count > 0;
+
+ if (!basicSuccess)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 기본 조건 실패: Success={result.Success}, PathCount={result.Path?.Count ?? 0}");
+ Console.ResetColor();
+ return false;
+ }
+
+ // 되돌아가기 패턴 체크
+ if (HasBacktrackingPattern(result.Path))
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine("❌ 되돌아가기 패턴 발견!");
+ Console.ResetColor();
+ return false;
+ }
+
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("✅ 기본 경로 테스트 통과");
+ Console.ResetColor();
+ return true;
+ }
+
+ private bool EvaluateDirectionChangeResult(DirectionChangePlanner.DirectionChangePlan plan, TestCases.DirectionChangeTestCase testCase)
+ {
+ if (!plan.Success)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 방향전환 계획 실패: {plan.ErrorMessage}");
+ Console.ResetColor();
+ return false;
+ }
+
+ // 되돌아가기 패턴 체크
+ if (HasBacktrackingPattern(plan.DirectionChangePath))
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine("❌ 방향전환 경로에서 되돌아가기 패턴 발견!");
+ Console.ResetColor();
+ return false;
+ }
+
+ // 기대 경로와 비교 (기대 경로가 정의된 경우)
+ if (testCase.ExpectedPath != null && testCase.ExpectedPath.Count > 0)
+ {
+ bool pathMatches = ComparePathsWithTolerance(plan.DirectionChangePath, testCase.ExpectedPath);
+ if (!pathMatches)
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine("⚠️ 경로가 기대 결과와 다릅니다:");
+ Console.WriteLine($" 기대: {string.Join(" → ", testCase.ExpectedPath)}");
+ Console.WriteLine($" 실제: {string.Join(" → ", plan.DirectionChangePath)}");
+ Console.ResetColor();
+ // 경로가 다르더라도 되돌아가기가 없으면 부분 성공으로 처리
+ return true;
+ }
+ else
+ {
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("✅ 경로가 기대 결과와 일치합니다!");
+ Console.ResetColor();
+ }
+ }
+
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("✅ 방향전환 테스트 통과");
+ Console.ResetColor();
+ return true;
+ }
+
+ private bool HasBacktrackingPattern(List path)
+ {
+ if (path == null || path.Count < 3) return false;
+
+ for (int i = 0; i < path.Count - 2; i++)
+ {
+ if (path[i] == path[i + 2] && path[i] != path[i + 1])
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine($"⚠️ 되돌아가기 패턴: {path[i]} → {path[i + 1]} → {path[i + 2]}");
+ Console.ResetColor();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void DisplayPathResult(AGVNavigationCore.PathFinding.Core.AGVPathResult result, string description)
+ {
+ Console.WriteLine($"📝 {description}");
+
+ if (result.Success)
+ {
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine($"✅ 성공 - 경로: {string.Join(" → ", result.Path)}");
+ Console.WriteLine($"📏 거리: {result.TotalDistance:F1}, 단계: {result.Path.Count}");
+ Console.ResetColor();
+ }
+ else
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 실패 - {result.ErrorMessage}");
+ Console.ResetColor();
+ }
+ }
+
+ private void DisplayDirectionChangePlan(DirectionChangePlanner.DirectionChangePlan plan, string description)
+ {
+ Console.WriteLine($"📝 {description}");
+
+ if (plan.Success)
+ {
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine($"✅ 성공 - 경로: {string.Join(" → ", plan.DirectionChangePath)}");
+ Console.WriteLine($"🔄 방향전환 노드: {plan.DirectionChangeNode}");
+ Console.WriteLine($"📋 설명: {plan.PlanDescription}");
+ Console.ResetColor();
+ }
+ else
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 실패 - {plan.ErrorMessage}");
+ Console.ResetColor();
+ }
+ }
+
+ private bool ComparePathsWithTolerance(List actualPath, List expectedPath)
+ {
+ if (actualPath == null || expectedPath == null)
+ return false;
+
+ if (actualPath.Count != expectedPath.Count)
+ return false;
+
+ for (int i = 0; i < actualPath.Count; i++)
+ {
+ if (actualPath[i] != expectedPath[i])
+ return false;
+ }
+
+ return true;
+ }
+
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/Cs_HMI/AGVPathTester/Program.cs b/Cs_HMI/AGVPathTester/Program.cs
new file mode 100644
index 0000000..68b0db4
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/Program.cs
@@ -0,0 +1,224 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace AGVPathTester
+{
+ ///
+ /// AGV 경로 탐색 및 방향전환 로직 테스트 프로그램
+ ///
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ Console.Title = "AGV Path Tester - ENIG Navigation System";
+ Console.ForegroundColor = ConsoleColor.Cyan;
+ Console.WriteLine("======================================");
+ Console.WriteLine(" AGV Path Tester v1.0");
+ Console.WriteLine(" ENIG Navigation System");
+ Console.WriteLine("======================================");
+ Console.ResetColor();
+ Console.WriteLine();
+
+ try
+ {
+ // 맵 파일 경로
+ string mapFilePath = @"C:\Data\Source\(5613#) ENIG AGV\Source\Cs_HMI\Data\NewMap.agvmap";
+
+ if (!File.Exists(mapFilePath))
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 맵 파일을 찾을 수 없습니다: {mapFilePath}");
+ Console.ResetColor();
+ Console.WriteLine("Enter 키를 눌러 종료하세요...");
+ Console.ReadLine();
+ return;
+ }
+
+ // PathTester 초기화
+ var pathTester = new PathTester(mapFilePath);
+
+ if (!pathTester.Initialize())
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine("❌ PathTester 초기화 실패");
+ Console.ResetColor();
+ Console.WriteLine("Enter 키를 눌러 종료하세요...");
+ Console.ReadLine();
+ return;
+ }
+
+ Console.ForegroundColor = ConsoleColor.Green;
+ Console.WriteLine("✅ PathTester 초기화 완료");
+ Console.WriteLine($"📍 로드된 맵 노드 수: {pathTester.GetNodeCount()}");
+ Console.ResetColor();
+ Console.WriteLine();
+
+ // 자동 테스트 모드 체크
+ bool autoMode = args.Length > 0 && (args[0].ToLower() == "auto" || args[0].ToLower() == "batch");
+
+ if (autoMode)
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine("🚀 자동 테스트 모드 실행");
+ Console.ResetColor();
+ Console.WriteLine();
+
+ // 먼저 맵 정보 표시
+ ShowMapInfo(pathTester);
+ Console.WriteLine("\n" + new string('=', 50) + "\n");
+
+ // 자동으로 모든 테스트 실행
+ RunBatchTests(pathTester);
+
+ Console.WriteLine();
+ Console.ForegroundColor = ConsoleColor.Cyan;
+ Console.WriteLine("📊 모든 자동 테스트 완료!");
+ Console.ResetColor();
+ return;
+ }
+
+ // 대화형 메뉴
+ bool continueRunning = true;
+ while (continueRunning)
+ {
+ ShowMenu();
+
+ Console.Write("선택: ");
+ var input = Console.ReadLine()?.Trim();
+
+ switch (input)
+ {
+ case "1":
+ RunBasicPathTests(pathTester);
+ break;
+ case "2":
+ RunDirectionChangeTests(pathTester);
+ break;
+ case "3":
+ RunCustomTest(pathTester);
+ break;
+ case "4":
+ RunBatchTests(pathTester);
+ break;
+ case "5":
+ ShowMapInfo(pathTester);
+ break;
+ case "0":
+ case "q":
+ case "quit":
+ case "exit":
+ continueRunning = false;
+ break;
+ default:
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine("❓ 잘못된 선택입니다.");
+ Console.ResetColor();
+ break;
+ }
+
+ if (continueRunning)
+ {
+ Console.WriteLine("\nEnter 키를 눌러 계속하세요...");
+ Console.ReadLine();
+ // Console.Clear(); // Windows 콘솔 호환성 문제로 제거
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Console.ForegroundColor = ConsoleColor.Red;
+ Console.WriteLine($"❌ 프로그램 오류: {ex.Message}");
+ Console.WriteLine($"상세 정보: {ex}");
+ Console.ResetColor();
+ Console.WriteLine("Enter 키를 눌러 종료하세요...");
+ Console.ReadLine();
+ }
+ }
+
+ static void ShowMenu()
+ {
+ Console.ForegroundColor = ConsoleColor.White;
+ Console.WriteLine("============ 메뉴 ============");
+ Console.WriteLine("1. 기본 경로 탐색 테스트");
+ Console.WriteLine("2. 방향 전환 경로 테스트");
+ Console.WriteLine("3. 사용자 정의 테스트");
+ Console.WriteLine("4. 배치 테스트 실행");
+ Console.WriteLine("5. 맵 정보 보기");
+ Console.WriteLine("0. 종료");
+ Console.WriteLine("=============================");
+ Console.ResetColor();
+ }
+
+ static void RunBasicPathTests(PathTester pathTester)
+ {
+ Console.ForegroundColor = ConsoleColor.Magenta;
+ Console.WriteLine("🧪 기본 경로 탐색 테스트 실행");
+ Console.ResetColor();
+
+ pathTester.RunBasicPathTests();
+ }
+
+ static void RunDirectionChangeTests(PathTester pathTester)
+ {
+ Console.ForegroundColor = ConsoleColor.Magenta;
+ Console.WriteLine("🔄 방향 전환 경로 테스트 실행");
+ Console.ResetColor();
+
+ pathTester.RunDirectionChangeTests();
+ }
+
+ static void RunCustomTest(PathTester pathTester)
+ {
+ Console.ForegroundColor = ConsoleColor.Magenta;
+ Console.WriteLine("🎯 사용자 정의 테스트");
+ Console.ResetColor();
+
+ Console.Write("시작 노드 ID: ");
+ string startNodeId = Console.ReadLine()?.Trim();
+
+ Console.Write("목표 노드 ID: ");
+ string targetNodeId = Console.ReadLine()?.Trim();
+
+ Console.WriteLine("현재 방향 선택:");
+ Console.WriteLine("1. Forward (전진)");
+ Console.WriteLine("2. Backward (후진)");
+ Console.Write("선택 (기본값: Forward): ");
+
+ var directionInput = Console.ReadLine()?.Trim();
+ var currentDirection = (directionInput == "2") ?
+ AGVNavigationCore.Models.AgvDirection.Backward :
+ AGVNavigationCore.Models.AgvDirection.Forward;
+
+ if (!string.IsNullOrEmpty(startNodeId) && !string.IsNullOrEmpty(targetNodeId))
+ {
+ pathTester.RunSingleTest(startNodeId, targetNodeId, currentDirection);
+ }
+ else
+ {
+ Console.ForegroundColor = ConsoleColor.Yellow;
+ Console.WriteLine("❓ 시작 노드 또는 목표 노드 ID가 비어있습니다.");
+ Console.ResetColor();
+ }
+ }
+
+ static void RunBatchTests(PathTester pathTester)
+ {
+ Console.ForegroundColor = ConsoleColor.Magenta;
+ Console.WriteLine("📦 배치 테스트 실행");
+ Console.ResetColor();
+
+ pathTester.RunBatchTests();
+ }
+
+ static void ShowMapInfo(PathTester pathTester)
+ {
+ Console.ForegroundColor = ConsoleColor.Cyan;
+ Console.WriteLine("🗺️ 맵 정보");
+ Console.ResetColor();
+
+ pathTester.ShowMapInfo();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Cs_HMI/AGVPathTester/Properties/AssemblyInfo.cs b/Cs_HMI/AGVPathTester/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..bef7c27
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/Properties/AssemblyInfo.cs
@@ -0,0 +1,19 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("AGVPathTester")]
+[assembly: AssemblyDescription("AGV 경로 탐색 및 방향전환 로직 테스트 도구")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("ENIG")]
+[assembly: AssemblyProduct("AGV Navigation System")]
+[assembly: AssemblyCopyright("Copyright © ENIG 2024")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+[assembly: ComVisible(false)]
+
+[assembly: Guid("a1b2c3d4-e5f6-7890-abcd-ef1234567890")]
+
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
\ No newline at end of file
diff --git a/Cs_HMI/AGVPathTester/TestCases.cs b/Cs_HMI/AGVPathTester/TestCases.cs
new file mode 100644
index 0000000..2722f1e
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/TestCases.cs
@@ -0,0 +1,192 @@
+using System.Collections.Generic;
+using AGVNavigationCore.Models;
+
+namespace AGVPathTester
+{
+ ///
+ /// AGV 경로 탐색 테스트 케이스 정의
+ ///
+ public static class TestCases
+ {
+ ///
+ /// 기본 경로 탐색 테스트 케이스
+ ///
+ public class BasicPathTestCase
+ {
+ public string StartNodeId { get; set; }
+ public string TargetNodeId { get; set; }
+ public AgvDirection CurrentDirection { get; set; }
+ public string Description { get; set; }
+ public bool ExpectedSuccess { get; set; }
+
+ public BasicPathTestCase(string startNodeId, string targetNodeId, AgvDirection currentDirection, string description, bool expectedSuccess = true)
+ {
+ StartNodeId = startNodeId;
+ TargetNodeId = targetNodeId;
+ CurrentDirection = currentDirection;
+ Description = description;
+ ExpectedSuccess = expectedSuccess;
+ }
+ }
+
+ ///
+ /// 방향 전환 테스트 케이스
+ ///
+ public class DirectionChangeTestCase
+ {
+ public string StartNodeId { get; set; }
+ public string TargetNodeId { get; set; }
+ public AgvDirection CurrentDirection { get; set; }
+ public AgvDirection RequiredDirection { get; set; }
+ public string Description { get; set; }
+ public bool ExpectedSuccess { get; set; }
+ public List ExpectedPath { get; set; }
+
+ public DirectionChangeTestCase(string startNodeId, string targetNodeId, AgvDirection currentDirection, AgvDirection requiredDirection, string description, bool expectedSuccess = true, List expectedPath = null)
+ {
+ StartNodeId = startNodeId;
+ TargetNodeId = targetNodeId;
+ CurrentDirection = currentDirection;
+ RequiredDirection = requiredDirection;
+ Description = description;
+ ExpectedSuccess = expectedSuccess;
+ ExpectedPath = expectedPath ?? new List();
+ }
+ }
+
+ ///
+ /// 기본 경로 탐색 테스트 케이스 목록
+ ///
+ public static List GetBasicPathTestCases()
+ {
+ return new List
+ {
+ // 단순 직선 경로
+ new BasicPathTestCase("N001", "N002", AgvDirection.Forward, "단순 인접 노드 이동"),
+ new BasicPathTestCase("N001", "N003", AgvDirection.Forward, "단거리 직선 경로"),
+
+ // 중거리 경로
+ new BasicPathTestCase("N001", "N010", AgvDirection.Forward, "중거리 경로 탐색"),
+ new BasicPathTestCase("N005", "N015", AgvDirection.Backward, "후진 상태에서 중거리 이동"),
+
+ // 갈림길을 포함한 경로
+ new BasicPathTestCase("N001", "N020", AgvDirection.Forward, "갈림길 포함 경로"),
+ new BasicPathTestCase("N010", "N030", AgvDirection.Forward, "복잡한 갈림길 경로"),
+
+ // 도킹 노드 관련
+ new BasicPathTestCase("N001", "N037", AgvDirection.Backward, "버퍼 노드로의 후진 이동"),
+ new BasicPathTestCase("N005", "N041", AgvDirection.Forward, "충전기로의 전진 이동"),
+
+ // 문제가 될 수 있는 경우들
+ new BasicPathTestCase("N004", "N015", AgvDirection.Forward, "문제 패턴: 004→005→004 가능성"),
+ new BasicPathTestCase("N006", "N037", AgvDirection.Backward, "문제 패턴: 006→005→004→005 가능성"),
+ new BasicPathTestCase("N012", "N016", AgvDirection.Backward, "문제 패턴: 012→016→012 가능성"),
+ };
+ }
+
+ ///
+ /// 방향 전환 테스트 케이스 목록 (실제 맵 파일 기반)
+ ///
+ public static List GetDirectionChangeTestCases()
+ {
+ return new List
+ {
+ // 실제 맵 기반 간단한 테스트 케이스들
+ // N004 갈림길 활용 (N003, N022, N031 연결)
+ new DirectionChangeTestCase("N003", "N022", AgvDirection.Forward, AgvDirection.Backward,
+ "N004 갈림길: N003→N022 (전진→후진 전환)",
+ true, new List { "N003", "N004", "N022" }),
+
+ new DirectionChangeTestCase("N003", "N031", AgvDirection.Forward, AgvDirection.Backward,
+ "N004 갈림길: N003→N031 (전진→후진 전환)",
+ true, new List { "N003", "N004", "N031" }),
+
+ // N011 갈림길 활용 (N012, N004, N015 연결)
+ new DirectionChangeTestCase("N012", "N015", AgvDirection.Forward, AgvDirection.Backward,
+ "N011 갈림길: N012→N015 (전진→후진 전환)",
+ true, new List { "N012", "N011", "N015" }),
+
+ new DirectionChangeTestCase("N004", "N015", AgvDirection.Forward, AgvDirection.Backward,
+ "N011 갈림길: N004→N015 (전진→후진 전환)",
+ true, new List { "N004", "N011", "N015" }),
+
+ // 역방향 테스트
+ new DirectionChangeTestCase("N022", "N003", AgvDirection.Backward, AgvDirection.Forward,
+ "N004 갈림길: N022→N003 (후진→전진 전환)",
+ true, new List { "N022", "N004", "N003" }),
+
+ new DirectionChangeTestCase("N015", "N012", AgvDirection.Backward, AgvDirection.Forward,
+ "N011 갈림길: N015→N012 (후진→전진 전환)",
+ true, new List { "N015", "N011", "N012" }),
+
+ // 방향 전환이 필요 없는 경우 (같은 방향)
+ new DirectionChangeTestCase("N003", "N022", AgvDirection.Forward, AgvDirection.Forward,
+ "방향 전환 불필요: N003→N022 (전진→전진)",
+ true, new List { "N003", "N004", "N022" }),
+
+ new DirectionChangeTestCase("N012", "N015", AgvDirection.Backward, AgvDirection.Backward,
+ "방향 전환 불필요: N012→N015 (후진→후진)",
+ true, new List { "N012", "N011", "N015" }),
+
+ // 좀 더 복잡한 경로 (여러 갈림길 통과)
+ new DirectionChangeTestCase("N003", "N015", AgvDirection.Forward, AgvDirection.Backward,
+ "복합 갈림길: N003→N015 (N004, N011 통과)",
+ true, new List { "N003", "N004", "N011", "N015" }),
+
+ new DirectionChangeTestCase("N022", "N012", AgvDirection.Backward, AgvDirection.Forward,
+ "복합 갈림길: N022→N012 (N004, N011 통과)",
+ true, new List { "N022", "N004", "N011", "N012" }),
+
+ // 실제 존재하지 않는 노드들로 인한 실패 테스트
+ new DirectionChangeTestCase("N001", "N999", AgvDirection.Forward, AgvDirection.Backward,
+ "존재하지 않는 노드 테스트 (실패 예상)",
+ false, new List())
+ };
+ }
+
+ ///
+ /// 특정 문제 시나리오 테스트 케이스 (디버깅용)
+ ///
+ public static List GetProblematicTestCases()
+ {
+ return new List
+ {
+ // 사용자가 직접 보고한 문제들
+ new DirectionChangeTestCase("N004", "N015", AgvDirection.Forward, AgvDirection.Backward,
+ "🚨 사용자 보고: 004→005→004 되돌아가기 발생"),
+ new DirectionChangeTestCase("N006", "N037", AgvDirection.Backward, AgvDirection.Backward,
+ "🚨 사용자 보고: 006→005→004→005 비효율적 경로"),
+ new DirectionChangeTestCase("N012", "N016", AgvDirection.Backward, AgvDirection.Forward,
+ "🚨 사용자 보고: 012→016→012 되돌아가기 발생"),
+ };
+ }
+
+ ///
+ /// 스트레스 테스트용 대량 케이스 생성
+ ///
+ public static List GenerateStressTestCases(List allNodeIds, int count = 50)
+ {
+ var testCases = new List();
+ var random = new System.Random(42); // 고정 시드로 재현 가능한 테스트
+
+ for (int i = 0; i < count; i++)
+ {
+ var startNodeId = allNodeIds[random.Next(allNodeIds.Count)];
+ var targetNodeId = allNodeIds[random.Next(allNodeIds.Count)];
+ var direction = random.Next(2) == 0 ? AgvDirection.Forward : AgvDirection.Backward;
+
+ if (startNodeId != targetNodeId)
+ {
+ testCases.Add(new BasicPathTestCase(
+ startNodeId,
+ targetNodeId,
+ direction,
+ $"스트레스 테스트 #{i + 1}"
+ ));
+ }
+ }
+
+ return testCases;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Cs_HMI/AGVPathTester/packages.config b/Cs_HMI/AGVPathTester/packages.config
new file mode 100644
index 0000000..8b1a8d0
--- /dev/null
+++ b/Cs_HMI/AGVPathTester/packages.config
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/Cs_HMI/PATHSCENARIO.md b/Cs_HMI/PATHSCENARIO.md
new file mode 100644
index 0000000..6af5bb0
--- /dev/null
+++ b/Cs_HMI/PATHSCENARIO.md
@@ -0,0 +1,100 @@
+## 경로시뮬레이션 설명
+## AGV는 같은경로상에서 방향을 전환할 수 없음
+## 경로계산을 위해서는 반드시 AGV는 2개 이상의 RFID를 읽어야 한다. (최소 2개를 읽어야 모터방향과 RFID의 읽히는 순서를 가지고 현재 AGV의 방향을 결정지을 수 있다)
+## 하기 케이스의 경우 케이스 설명전에 AGV가 어떻게 이동했는지 최소 2개의 RFID정보를 제공한다.
+## AGV의 RFID로 위치이동하는 것은 시뮬레이터폼의 SetAGVPositionByRfid 함수를 참고하면 됨
+## 방향전환이 필요할 때에 갈림길은 AGV와 가장 가까운 갈림길을 사용한다.
+
+## case 1 (AGV가 전진방향으로 이동하는 경우)
+## AGV는 모터전진방향으로 008 -> 007 로 이동 (최종위치는 007)
+
+Q1.목적지 : 015 (충전기 이므로 전진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 동일하므로 방향전환이 필요없다. 목적지 까지의 최단거리를 계산한 후 그대로 이동하면됨
+ 007 - 006 - 005 - 004 - 012 - 013 - 014 - 015
+
+Q2.목적지 : 019 (충전기 이므로 전진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 동일하므로 방향전환이 필요없다. 목적지 까지의 최단거리를 계산한 후 그대로 이동하면됨
+ 007 - 006 - 005 - 004 - 012 - 016 - 017 - 018 - 019
+
+Q3.목적지 : 001 (장비 이므로 후진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 일치하지 않으니 방향전환이 필요하다,
+ 목적지까의 RFID목록은 007 - 006 - 005 - 004 - 003 - 002 - 001
+ 갈림길은 005 , 004 총 2개가 있으나 AGV 이동 방향상 가장 가까운 갈림길은 005이다. 전환은 005에서 하기로 한다.
+ 005갈림길은 내경로상의 006 과 037이 있다. 내 경로상에서 방향전환은 할 수 없으니 005 갈림길에서는 037로 방향을 틀어서 (Magnet Left) 전진이동을 한후
+ 037이 발견되면 방향을 후진으로 전환하면서 005를 거쳐 004방향으로 가도록 (Magnet Right) 로 유도해서 진행한다.
+ 그렇게하면 005를 지나 004를 갈때에는 후진방향으로 이동하게 된다. 후진시에는 전진과 magtnet 방향전환이 반대로 필요하다,
+ 037 -> 005 -> 004 의 경우 후진이동으로 좌회전을 해야하는데. 후진이기때문에 magnet 은 right 로 유도한다.
+
+ 최종 경로는 아래와 같다
+
+ 007(F) - 006(F) - 005(F) - 037(B) - 005(B) - 004(B) - 003(B) - 002(B) - 001(B)
+
+Q4.목적지 : 011 (장비 이므로 후진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 일치하지 않으니 방향전환이 필요하다,
+ 목적지까의 RFID목록은 007 - 006 - 005 - 004 - 030 - 009 - 010 - 011
+ 갈림길은 005 , 004 총 2개가 있으나 AGV 이동 방향상 가장 가까운 갈림길은 005이다. 전환은 005에서 하기로 한다.
+ 005갈림길은 내 경로상의 006 과 037이 있다. 내 경로상에서 방향전환은 할 수 없으니 005 갈림길에서는 037로 방향을 틀어서 (Magnet Left) 전진이동을 한후
+ 037이 발견되면 방향을 후진으로 전환하면서 005를 거쳐 004방향으로 가도록 (Magnet Right) 로 유도해서 진행한다.
+ 그렇게하면 005를 지나 004를 갈때에는 후진방향으로 이동하게 된다. 후진시에는 전진과 magtnet 방향전환이 반대로 필요하다,
+ 037 -> 005 -> 004 의 경우 후진이동으로 좌회전을 해야하는데. 후진이기때문에 magnet 은 right 로 유도한다.
+
+ 최종 경로는 아래와 같다
+
+ 007(F) - 006(F) - 005(F) - 037(B) - 005(B) - 004(B) - 030(B) - 009(B) - 010(B) - 011(B)
+
+Q.목적지 : 041 (장비 이므로 후진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 일치하지 않으니 방향전환이 필요하다,
+ 목적지까의 RFID목록은 007 - 006 - 005 - 037 - 036 - 035 - 034 - 033 - 032 - 031 - 041
+ 경로상 갈림길은 005 총 1개가 있으므로 전환은 005에서 하기로 한다.
+ 005갈림길은 내 경로상의 006 과 037(이 경우엔 037도 내 경로는 맞다)
+ 이 경우에는 006도 037도 내 경로이므로 005에 연결된 004포인트로 이동하면서 방향전환이 필요하다
+ 005 갈림길에서는 004까지 전진으로 진행하고 004도착시 후진을 하고 005에서 037로 방향을 틀도록 마그넷을(left)로 유도한다
+ 그렇게하면 005를 지나 037를 갈때에는 후진방향으로 이동하게 된다.
+
+ 최종 경로는 아래와 같다
+
+ 007(F) - 006(F) - 005(F) - 004(F) - 005(B) - 037(B) - 036(B) - 035(B) - 034(B) - 033(B) - 032(B) - 031(B) - 041(B)
+
+Q5.8 (장비 이므로 후진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 일치하지 않으니 방향전환이 필요하다,
+ 목적지까의 RFID목록은 007 - 006 - 005 - 037 - 036 - 035 - 034 - 038
+ 경로상 갈림길은 005 총 1개가 있으므로 전환은 005에서 하기로 한다.
+ 005갈림길은 내 경로상의 006 과 037(이 경우엔 037도 내 경로는 맞다)
+ 이 경우에는 006도 037도 내 경로이므로 005에 연결된 004포인트로 이동하면서 방향전환이 필요하다
+ 005 갈림길에서는 004까지 전진으로 진행하고 004도착시 후진을 하고 005에서 037로 방향을 틀도록 마그넷을(left)로 유도한다
+ 그렇게하면 005를 지나 037를 갈때에는 후진방향으로 이동하게 된다.
+
+ 최종 경로는 아래와 같다
+
+ 007(F) - 006(F) - 005(F) - 004(F) - 005(B) - 037(B) - 036(B) - 035(B) - 034(B) - 038(B)
+
+
+## AGV는 모터전진방향으로 037 -> 036 로 이동 (최종위치는 036)
+Q6.목적지 : 038 (장비 이므로 후진 방향 도킹해야하는 곳)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 일치하지 않으니 방향전환이 필요하다,
+ 목적지까의 RFID목록은 036 - 035 - 034 - 038
+ 경로상 갈림길이 없다, 가장 가까운 갈림길은 005이므로 전환은 005에서 하기로 한다.
+ 005갈림길은 내 경로상 포인트가 없으니 전환은 004 혹은 006 어떤쪽이던 상관없다.
+ 다만 이러한 경우 일관성을 위해 Magnet 유도를 Left를 사용한다
+ 036에서 후진으로 이동을 시작하면 037 -> 005 순으로 후진 이동을 한다. 여기서 방향전환을 해야하고 마그넷이 left로 유도가 되면
+ AGV는 006방향으로 틀게된다. 이제 이러면 바로위의 Q5와 동일한 조건이 완성된다. 위치 006에서는 005 037 모두 목적지까지 포함되므로 004로
+ 이동해서 전환을 해야한다. 005(f), 004(f) 까지 이동을 한 후 이제 방향전환을 해서 후진으로 005까지 이동이 필요하다. 후진이므로
+ magnet을 left유도하여 037로 이동할 수 있게한다
+
+ 최종 경로는 아래와 같다
+
+ 036(B) - 037(B) - 005(B) - 006(B) - 005(F) - 004(F) - 005(F) - 037(B) - 036(B) - 035(B) - 034(B) - 038(B)
+
+
+## case 2 (AGV가 후진방향으로 이동하는 경우)
+AGV는 모터후진방향으로 008 -> 007 로 이동 (최종위치는 007)
+Q7.목적지 : 015 (충전기는 전진 도킹해야합니다.)
+ A. 목적지 도킹방향과 현재 AGV도킹 방향이 일치하지 않으니 방향전환이 필요하다,
+ 목적지까의 RFID목록은 007 - 006 - 005 - 004 - 012 - 013 -014 -015
+ 경로상 갈림길은 005, 004, 012 총 3개가 있다, 가장 가까운 갈림길은 005이므로 전환은 005에서 하기로 한다.
+ 005 갈림길은 내 경로상 포인트 (006,004)가 있으니 037 포인트를 이용하여 전환을 하면 된다.
+ 006(B) -> 005(B - 마그넷유도 RIGHT) -> 037(F) -> 그런후 방향전화을 해서 005까지 전진으로 이동을 하고 004로 방향을 틀면된다.
+
+ 최종 경로는 아래와 같다
+
+ 007(B) - 006(B) - 005(B-maget right) - 037(에 B로 도착하면 F로 전환한다) - 005(F) - 004(F) - 012(F) - 013(F) - 014(F) - 015(F)
\ No newline at end of file