AutoRun 진행 시, InitParam Skip

대기 셀(prefetch2)를 기준으로 지그번호를 유추해서 재시작 시, 보존하도록 한다.

.gitignore

@@ -32,3 +32,4 @@ AuroraVision/VisionInspector/bin
 /hislog.config
 
 *.bak
+/ignoreFolder

AuroraDevices/AuroraCellTracker/CellTracker.cs

@@ -146,5 +146,17 @@ namespace AuroraCellTracker
 
             _CellTracker.SetIPConfig();
         }
+        public void getDummyData(out string lotId, out string cellId)
+        {
+            lotId = string.Empty;
+            cellId = string.Empty;
+
+            if (!IsActivated) {
+                return;
+            }
+            if (_CellTracker != null && _CellTracker is CellTrackerDaekhon core) {
+                core.CalcCellInfo("", out lotId, out cellId);
+            }
+        }
     }
 }

AuroraDevices/AuroraCellTracker/CellTrackerConfig.cs

@@ -28,6 +28,8 @@ namespace AuroraCellTracker
         public int LotIdStartNo { get; set; }
         public int LotIdLength { get; set; }
         public int CellIdReceiveMethod { get; set; }
-
+        [DirectoryPath]
+        public string reportDataLocalPath { get; set; } = "D:\\ILSOSConfig\\_device\\_cellTracker\\";
+        public string EquipmentName { get; set; } = "CCW";
     }
 }

AuroraDevices/AuroraCellTracker/DaekhonCoporation/CellTrackerDaekhon.cs

@@ -21,6 +21,8 @@ namespace AuroraCellTracker.DaekhonCoporation
         Logger _Logger = new Logger("CellTrackerDaekhon");
         private const string REG_PATH = @"Software\H52A\H52A_ADPT_CELL";
 
+        public event Action<string, string> OnCellReceived;
+
         public CellInfoStr CellInfoStrings { get; set; } = new CellInfoStr();
         public ConcurrentQueue<CellInfoStr> CellInfoQueue { get; set; } = new ConcurrentQueue<CellInfoStr>();
 
@@ -318,6 +320,7 @@ namespace AuroraCellTracker.DaekhonCoporation
 
                             CalcCellInfo(str, out lotId, out cellId);
                             AddCellInfo(lotId, cellId);
+                            OnCellReceived?.Invoke(lotId, cellId);
                         } catch (Exception e) {
                             _Logger.E(string.Format($"{e.Message}"));
                         }
@@ -339,6 +342,7 @@ namespace AuroraCellTracker.DaekhonCoporation
 
                             //CalcCellInfo(str, out lotId, out cellId);
                             AddCellInfo(lotId, cellId);
+                            OnCellReceived?.Invoke(lotId, cellId);
                         } catch (Exception e) {
                             _Logger.E(string.Format($"{e.Message}"));
                         }
@@ -388,7 +392,7 @@ namespace AuroraCellTracker.DaekhonCoporation
         /// Cell 추적 API에서 받은 문자열에서, Cell ID와 Lot ID를 Parsing 하는 함수
         /// </summary>
         /// <param name="str">Cell 추적 API에서 받은 문자열. Callback 방식일 때와 Queue 방식일 때 각각 다르다</param>
-        private void CalcCellInfo(string str, out string lotId, out string cellId)
+        public void CalcCellInfo(string str, out string lotId, out string cellId)
         {
             lotId = cellId = "";
 

AuroraDevices/AuroraCellTracker/ICellTracker.cs

@@ -10,6 +10,12 @@ namespace AuroraCellTracker
 {
     public interface ICellTracker
     {
+        /// <summary>
+        /// DllSocket_ReceiveDataBuffer에서 lotId/cellId 파싱 완료 시 발화.
+        /// ProcessManager 등 외부에서 구독하여 직접 수신 가능.
+        /// </summary>
+        event Action<string, string> OnCellReceived;
+
         void Initialize(eMode mode, string dllDirectory);
         void Close();
         void CheckDllStatus();

AuroraDevices/AuroraLBAD/Services/StreamLightLBAD.cs

@@ -26,6 +26,10 @@ namespace AuroraLBAD.Service
 
         public static double[] LaserPowerByLBAD = new double[100]; //headnum 크기면 되지만 우선 100으로 해둠
 
+        /// LBAD MES Report 수신 시 발화 — (lotId, cellId, headNum, avg)
+        /// 시퀀스에서 구독하여 Complete 슬롯의 LbadAvg를 채우는 데 사용
+        public event Action<string, string, int, double> MesReportReceived;
+
         public Int16 LBADAlive { get; set; }
         public Int16? LBADAlarmStatus { get; set; }
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
@@ -276,25 +280,6 @@ namespace AuroraLBAD.Service
             return E1.OK;
         }
 
-        public static unsafe stLBADReportData BytesToLBADReportDataStruct(byte[] bytes)
-        {
-            stLBADReportData data = new stLBADReportData();
-
-            for (int i=0; i<40; i++)
-            {
-                data.LotID[i] = bytes[i];
-            }
-            for (int i=0; i<40; i++)
-            {
-                data.CellID[i] = bytes[i + 40];
-            }
-
-            data.HeadNum = BitConverter.ToInt16(bytes, 80);
-            data.AVG = BitConverter.ToDouble(bytes, 82);
-
-            return data;
-        }
-
         public static byte[] StructToBytes<T>(T structure) where T : struct
         {
             int size = Marshal.SizeOf(typeof(T));
@@ -326,37 +311,22 @@ namespace AuroraLBAD.Service
                     Log.I($"StreamLight LBAD Alarm Status : {LBADAlarmStatus}");
                     break;
                 case MESSAGE_LBAD_MES_REPORT:
-                    Log.I($"Received Data : {data}");
+                    Log.I($"Received Data");
-                    //byte[] data_byte = BitConverter.GetBytes(data);
 
-                    if (data is byte[] bytes && bytes.Length > 0)
+                    if (data is byte[] bytes && bytes.Length > 0) {
-                    {
                         Log.I($"Received Data Size : {bytes.Length}");
-                        var replyParsed_LBAD = BytesToLBADReportDataStruct(bytes);
+                        string LotID_string = Encoding.ASCII.GetString(bytes, 0, 40).TrimEnd('\0');
-                        unsafe
+                        string CellID_string = Encoding.ASCII.GetString(bytes, 40, 40).TrimEnd('\0');
-                        {
+                        short HeadNum = BitConverter.ToInt16(bytes, 80);
-                            char[] LotID = new char[40];
+                        double AVG = BitConverter.ToDouble(bytes, 82);
-                            char[] CellID = new char[40];
+                        Log.I($"StreamLight LBAD Report Data (from LBAD to Welder) : LotID {LotID_string}, CellID {CellID_string}");
-                            for (int i=0; i<40; i++)
+                        Log.I($"StreamLight LBAD Report Data (from LBAD to Welder) : HeadNum {HeadNum}");
-                            {
+                        Log.I($"StreamLight LBAD Report Data (from LBAD to Welder) : LaserPower_AVG {AVG}");
-                                LotID[i] = (char)bytes[i];
+                        if (HeadNum > 0) {
-                            }
+                            LaserPowerByLBAD[HeadNum] = AVG;
-                            for (int i=40; i<80; i++)
+                            MesReportReceived?.Invoke(LotID_string, CellID_string, HeadNum, AVG);
-                            {
+                        } else {
-                                CellID[i-40] = (char)bytes[i];
+                            Log.E($"Head Number is {HeadNum}");
-
-                            }
-                            string LotID_string = new string(LotID);
-                            string CellID_string = new string(CellID);
-                            Log.I($"StreamLight LBAD Report Data : LotID {LotID_string}");
-                            Log.I($"StreamLight LBAD Report Data : HeadNum {replyParsed_LBAD.HeadNum}");
-                            Log.I($"StreamLight LBAD Report Data : LaserPower_AVG {replyParsed_LBAD.AVG}");
-                            if (replyParsed_LBAD.HeadNum > 0)
-                                LaserPowerByLBAD[replyParsed_LBAD.HeadNum] = replyParsed_LBAD.AVG;
-                            else
-                            {
-                                Log.E($"Head Number is {replyParsed_LBAD.HeadNum}");
-                            }
                         }
                     }
                     break;

AuroraDevices/AuroraLaserScanner/Scanner.cs

@@ -577,6 +577,15 @@ namespace AuroraLaserScanner
             }
             _scannerObj.SetConfigList(mem1, mem2);
         }
+        public void GetListPointer(out eListNo list_no, out uint list_pos)
+        {
+            if (!IsActivated) {
+                list_no = eListNo.NONE;
+                list_pos = 0;
+                return;
+            }
+            _scannerObj.GetListPointer(out list_no, out list_pos);
+        }
         public double GetCommandPosX()
         {
             return _scannerObj.CommandPosX;

AuroraDevices/AuroraLaserScanner/ScannerObj.cs

@@ -313,6 +313,7 @@ namespace AuroraLaserScanner
         #endregion
         public abstract uint GetListSpace();
         public abstract void SetConfigList(uint mem1, uint mem2);
+        public abstract void GetListPointer(out eListNo list_no, out uint list_pos);
 
         public void WaitForListTaskCompleted(int timeOut, SequenceContext context = null) //단위는 초
         {

AuroraDevices/AuroraLaserScanner/ScannerRTC5.cs

@@ -1111,5 +1111,14 @@ namespace AuroraLaserScanner
         {
             RTC5Wrap.config_list(mem1, mem2);
         }
+        public override void GetListPointer(out eListNo list_no, out uint list_pos)
+        {
+            list_no = eListNo.NONE;
+
+            uint listNo = 0, listPos = 0;
+            RTC5Wrap.get_list_pointer(out listNo, out listPos);
+            list_no = (eListNo)listNo;
+            list_pos = listPos;
+        }
     }
 }

AuroraDevices/AuroraLaserScanner/ScannerRTC6.cs

@@ -1113,5 +1113,14 @@ namespace AuroraLaserScanner
         {
             RTC6Wrap.config_list(mem1, mem2);
         }
+        public override void GetListPointer(out eListNo list_no, out uint list_pos)
+        {
+            list_no = eListNo.NONE;
+
+            uint listNo = 0, listPos = 0;
+            RTC6Wrap.get_list_pointer(out listNo, out listPos);
+            list_no = (eListNo)listNo;
+            list_pos = listPos;
+        }
     }
 }

AuroraDevices/AuroraLaserScanner/ScannerSimul.cs

@@ -53,6 +53,22 @@ namespace AuroraLaserScanner
 
         private long _listStartMs = 0;   // ← 이게 executionStartTime 역할
 
+        // 리스트 기록 대상 추적 (LoadList 성공 시 설정, SetEndList 시 초기화)
+        private eListNo _recordingList = eListNo.NONE;
+
+        // 리스트별 WaitForEncoderRotateRange 조건 저장 (실제 RTC 펌웨어 리스트 명령 역할)
+        private bool _list1HasEncoderWait;
+        private double _list1EncoderMinY, _list1EncoderMaxY;
+        private bool _list2HasEncoderWait;
+        private double _list2EncoderMinY, _list2EncoderMaxY;
+
+        // 현재 실행 중인 리스트의 엔코더 조건 충족 여부
+        private bool _encoderConditionMet;
+
+        // InitFly2D() 호출 시점의 PLC 누적각 (실제 RTC 엔코더 리셋과 동일한 역할)
+        // _angleAbsDeg = PLCGetAbsDeg() - _flyResetAbsDeg 로 항상 InitFly2D 이후 상대각을 유지
+        private double _flyResetAbsDeg = 0.0;
+
         private const int MinListTimeMs = 30;      // 너무 빠른 완료 방지
         private const int MaxListTimeMs = 800;     // 너무 느린 완료 방지
         private int SimulatedListTimeMs = 250; // 리스트 실행 시간
@@ -85,8 +101,25 @@ namespace AuroraLaserScanner
                 return;
 
             long now = sw.ElapsedMilliseconds;
-            long elapsed = now - _listStartMs;
 
+            // ── Phase 1: 엔코더 조건 대기 ───────────────────────────────────────
+            // 실제 RTC 펌웨어에서 WaitForEncoderRotateRange 명령이 리스트 실행 중
+            // 엔코더가 구간에 진입할 때까지 대기하는 동작을 모사.
+            bool hasWait = (_currentExecutingList == eListNo.LIST1) ? _list1HasEncoderWait : _list2HasEncoderWait;
+            if (hasWait && !_encoderConditionMet) {
+                double minY = (_currentExecutingList == eListNo.LIST1) ? _list1EncoderMinY : _list2EncoderMinY;
+                double maxY = (_currentExecutingList == eListNo.LIST1) ? _list1EncoderMaxY : _list2EncoderMaxY;
+                // _angleAbsDeg는 PullEncoderFromPlcOnce에서 InitFly2D 기준 상대각으로 갱신됨
+                double absDeg = _angleAbsDeg;
+                if (absDeg >= minY && absDeg <= maxY) {
+                    _encoderConditionMet = true;
+                    _listStartMs = now; // 조건 충족 시점부터 마킹 타이머 시작
+                }
+                return; // 조건 미충족이면 busy 유지, 충족 직후도 이번 주기는 return
+            }
+
+            // ── Phase 2: 마킹 시간 경과 후 리스트 완료 ─────────────────────────
+            long elapsed = now - _listStartMs;
             int doneTime = GetEffectiveListTimeMs();
 
             // 최소 현실 가드: elapsed가 음수인 경우 방지
@@ -115,8 +148,12 @@ namespace AuroraLaserScanner
                         _list1Busy = false;
                     }
 
-                    _listStartMs = now;
                     _autoChangeRequested = false;
+                    _encoderConditionMet = false; // 새 리스트의 엔코더 조건 초기화
+
+                    bool newHasWait = (_currentExecutingList == eListNo.LIST1) ? _list1HasEncoderWait : _list2HasEncoderWait;
+                    if (!newHasWait)
+                        _listStartMs = now; // 엔코더 대기 없으면 마킹 타이머 즉시 시작
                 } else {
                     _currentExecutingList = eListNo.NONE;
                 }
@@ -344,37 +381,18 @@ namespace AuroraLaserScanner
 
         public override void WaitForEncoderRotateRange(double minX, double maxX, double minY, double maxY)
         {
-            LastWaitMissedRange = false;
+            // 실제 RTC 펌웨어와 동일하게: PC 스레드를 블로킹하지 않고 리스트 명령으로 조건 저장.
-
+            // EquipmentSimulator → UpdateListExecution 에서 PLCGetAbsDeg()가 [minY, maxY] 구간
-            long t0 = sw.ElapsedMilliseconds;
+            // 진입을 확인한 후 마킹 타이머를 시작하므로, 그 전까지 리스트는 busy 상태를 유지.
-
+            // LoadList 폴링(CheckLoadComplete)이 busy 해소를 기다리는 방식으로 타이밍 동기화.
-            while (true) {
+            if (_recordingList == eListNo.LIST1) {
-                // 블로킹 대기 중에도 PLC에서 최신값을 직접 당겨온다
+                _list1HasEncoderWait = true;
-                PullEncoderFromPlcOnce();
+                _list1EncoderMinY = minY;
-
+                _list1EncoderMaxY = maxY;
-                // GetEncoder는 _simEncYCount를 deg로 바꿔줄 것
+            } else if (_recordingList == eListNo.LIST2) {
-                GetEncoder(out _, out double curY, true);
+                _list2HasEncoderWait = true;
-
+                _list2EncoderMinY = minY;
-                // 정상 진입
+                _list2EncoderMaxY = maxY;
-                if (curY >= minY && curY <= maxY)
-                    return;
-
-                // 최소 현실 가드: 구간을 지나쳤으면 TIMEOUT까지 끌지 말고 즉시 종료
-                // (실장에서도 "놓치면" 의미 없고 다음 로직이 꼬임)
-                if (curY > maxY) {
-                    LastWaitMissedRange = true;
-                    Log.W($"[SIM] WaitForEncoderRotateRange MISSED. curY={curY:F3}, range=[{minY:F3}..{maxY:F3}]");
-                    return;
-                }
-
-                // 최후 안전장치
-                if (sw.ElapsedMilliseconds - t0 > 5000) {
-                    LastWaitMissedRange = true;
-                    Log.W($"[SIM] WaitForEncoderRotateRange TIMEOUT. curY={curY:F3}, range=[{minY:F3}..{maxY:F3}]");
-                    return;
-                }
-
-                Thread.Sleep(1);
             }
         }
         private void PullEncoderFromPlcOnce()
@@ -393,7 +411,8 @@ namespace AuroraLaserScanner
             //int absRaw = PLCReadDWord(PLC_CURRENT_POS_ABS_ADDR, ePLCDevice.W, true).data;
             //double angleAbsDeg = absRaw / 100_000.0;
             if (PLCGetAbsDeg != null) {
-                _angleAbsDeg = PLCGetAbsDeg();
+                // InitFly2D 시점 기준 상대각 유지 (실제 RTC 엔코더 리셋 동작과 동일)
+                _angleAbsDeg = PLCGetAbsDeg() - _flyResetAbsDeg;
             }
 
             // 3) count로 변환 (n_get_encoder가 반환한다고 가정하는 값)
@@ -455,7 +474,11 @@ namespace AuroraLaserScanner
 
         public override void InitFly2D(int offsetX = 0, int offsetY = 0)
         {
-            // simulation 할때 값 반영 검토 필요
+            // 실제 RTC InitFly2D는 펌웨어 MOTF 엔코더 카운터를 0으로 리셋.
+            // 시뮬에서는 현재 PLC 누적각을 기준점으로 저장하여 이후 _angleAbsDeg가
+            // 0부터 시작하는 상대각이 되도록 함 → sectionStartAngle 계산과 좌표계 일치.
+            _flyResetAbsDeg = (PLCGetAbsDeg != null) ? PLCGetAbsDeg() : 0.0;
+            _angleAbsDeg = 0.0;
         }
         public override void SimulateEncoder(uint EncoderNo)
         {
@@ -498,11 +521,20 @@ namespace AuroraLaserScanner
             if (busy)
                 return 0;   // 실행 중 → Load 불가
 
+            // 기록 대상 리스트 확정 및 엔코더 대기 조건 초기화
+            // (WaitForEncoderRotateRange가 이번 사이클에서 호출될 때 여기 저장된다)
+            if (_recordingList != no) {
+                _recordingList = no;
+                if (no == eListNo.LIST1) _list1HasEncoderWait = false;
+                else                     _list2HasEncoderWait = false;
+            }
+
             return (uint)no;  // Load 가능
         }
         public override void SetEndList()
         {
             _listClosed = true;
+            _recordingList = eListNo.NONE; // 기록 완료
         }
         public override void ExecuteList(eListNo no)
         {
@@ -511,6 +543,7 @@ namespace AuroraLaserScanner
             _listClosed = false; // 실행 시작하면서 다시 열림 상태로
 
             _currentExecutingList = no;
+            _encoderConditionMet = false; // 엔코더 조건부터 평가
 
             if (no == eListNo.LIST1) {
                 _list1Busy = true;
@@ -520,7 +553,9 @@ namespace AuroraLaserScanner
                 _list1Busy = false;
             }
 
-            _listStartMs = sw.ElapsedMilliseconds;
+            bool hasWait = (no == eListNo.LIST1) ? _list1HasEncoderWait : _list2HasEncoderWait;
+            if (!hasWait)
+                _listStartMs = sw.ElapsedMilliseconds; // 엔코더 대기 없으면 마킹 타이머 즉시 시작
         }
         public override void StartLoop()
         {
@@ -550,6 +585,12 @@ namespace AuroraLaserScanner
             _listStartMs = 0;
             _listClosed = false;
 
+            _recordingList = eListNo.NONE;
+            _list1HasEncoderWait = false;
+            _list2HasEncoderWait = false;
+            _encoderConditionMet = false;
+
+            _flyResetAbsDeg = 0.0;
             _angleAbsDeg = 0.0;
 
             _simEncXCount = 0;
@@ -811,5 +852,15 @@ namespace AuroraLaserScanner
         {
 
         }
+        public override void GetListPointer(out eListNo list_no, out uint list_pos)
+        {
+            list_no = eListNo.NONE;
+            if (_list1Busy)
+                list_no = eListNo.LIST1;
+            else if (_list2Busy)
+                list_no = eListNo.LIST2;
+
+            list_pos = 0;
+        }
     }
 }

Machines/ILSOS_CCW_H52A/Datas/CellInfoScheduler.cs

@@ -0,0 +1,280 @@
+using Aurora.Api;
+using Aurora.Util.HislogPlus;
+using ILSOS_CCW_H52A.Data;
+using ILSOS_CCW_H52A.Sequences;
+using System;
+using System.Collections.Generic;
+
+namespace ILSOS_CCW_H52A.Data
+{
+    // 물리 지그 번호 (0-based enum, 1-based 변환: (eJigNo)(jigNo - 1))
+    public enum eJigNo
+    {
+        Jig1, Jig2, Jig3, Jig4,
+        Jig5, Jig6, Jig7, Jig8,
+        Jig9, Jig10, Jig11, Jig12,
+        Jig13, Jig14, Jig15, Jig16,
+    }
+
+    /// <summary>
+    /// Dictionary<eJigNo, JigInfo> 상속으로 물리 지그 번호 직접 접근과
+    /// 파이프라인 단계 접근을 동시에 지원하는 셀 스케줄러.
+    ///
+    /// - 물리 지그 접근: scheduler[eJigNo.Jig5]
+    /// - 파이프라인 접근: scheduler.Prefetch2, scheduler.Prefetch1, scheduler.Complete, scheduler.ReportSlot
+    ///
+    /// 4단계 파이프라인: Prefetch2 → Prefetch1 → Complete → ReportSlot
+    ///   Prefetch2  : 셀 정보 수신 완료, 스캐너 리스트 업로드 전
+    ///   Prefetch1  : 업로드 완료, 실행 중 — EncoderMonitor 감시 + 완료 체크 대상
+    ///   Complete   : 용접 완료, LBAD MES Report 수신 대기 (~100ms)
+    ///                MesReportReceived 콜백이 CellId 매칭 후 LbadAvg를 채움
+    ///   ReportSlot : 지그 1회전(~320ms) 경과 → LBAD 데이터 보장, CellTracker 보고 대상
+    ///
+    /// Shift()가 4단계 전체를 전진. GC 할당 없음.
+    ///   ReportSlot ← Complete ← Prefetch1 ← Prefetch2 ← this[nextJig]
+    /// </summary>
+    public class CellInfoScheduler : Dictionary<eJigNo, JigInfo>
+    {
+        private readonly Logger _log = new Logger("CellInfoScheduler");
+        public JigInfo Prefetch2 { get; private set; }  // 전전 셀: 셀 정보 수신, 업로드 전
+
+        // volatile: Shift()에서 Prefetch1 = Prefetch2 대입이 release fence 역할.
+        // EncoderMonitor 스레드가 Prefetch1을 읽을 때 acquire fence로 JigNo 등 모든 필드 가시성 보장.
+        private volatile JigInfo _prefetch1;
+        public JigInfo Prefetch1 {
+            get => _prefetch1;
+            private set => _prefetch1 = value;
+        }
+
+        public JigInfo Complete   { get; private set; } // 용접 완료, LBAD 수신 대기
+        public JigInfo ReportSlot { get; private set; } // LBAD 보장, CellTracker 보고 대상
+
+        // ── 재시작 보존용 독립 슬롯 — Reset()에서 건드리지 않음 ──────────────────────
+        private readonly JigInfo _pendingPrefetch1    = new JigInfo(); // 정지 직전 Prefetch1 (업로드 완료, 용접 미완)
+        private readonly JigInfo _pendingPrefetch2    = new JigInfo(); // 정지 직전 Prefetch2 (업로드 완료, 용접 미완)
+
+        // 정지 직전 ReportSlot: LBAD 수신 완료 상태로 보고만 남은 셀
+        private readonly JigInfo _pendingFromReportSlot = new JigInfo();
+        // 정지 직전 Complete: 용접은 완료됐으나 ReportSlot 진입 전 정지 (LBAD 수신 여부 불확실)
+        private readonly JigInfo _pendingFromComplete   = new JigInfo();
+        // 정지 직전 큐 잔류: Dequeue 전 큐에만 있던 셀 (파이프라인 미진입)
+        private readonly JigInfo _pendingFromQueue      = new JigInfo();
+
+        // ── 재시작 미완료 보고 접근 ──────────────────────────────────────────────────
+        // 우선순위: _pendingFromReportSlot > _pendingFromComplete
+        public JigInfo PendingComplete {
+            get {
+                if (_pendingFromReportSlot.IsCanExist && !_pendingFromReportSlot.ReportComplete)
+                    return _pendingFromReportSlot;
+                if (_pendingFromComplete.IsCanExist && !_pendingFromComplete.ReportComplete)
+                    return _pendingFromComplete;
+                return null;
+            }
+        }
+
+        public bool HasPendingComplete =>
+               (_pendingFromReportSlot.IsCanExist && !_pendingFromReportSlot.ReportComplete)
+            || (_pendingFromComplete.IsCanExist   && !_pendingFromComplete.ReportComplete);
+
+        // 현재 활성 보고 슬롯 — 재시작 pending 우선, 그 다음 ReportSlot
+        public JigInfo ActiveReportSlot {
+            get {
+                if (_pendingFromReportSlot.IsCanExist && !_pendingFromReportSlot.ReportComplete)
+                    return _pendingFromReportSlot;
+                if (_pendingFromComplete.IsCanExist && !_pendingFromComplete.ReportComplete)
+                    return _pendingFromComplete;
+                return ReportSlot;
+            }
+        }
+
+        // 정지 전 미용접 슬롯이 보존돼 있는지 (재시작 후 복원 가능 여부)
+        public bool HasPendingPrefetch =>
+               !string.IsNullOrEmpty(_pendingPrefetch1.CellId)
+            || !string.IsNullOrEmpty(_pendingPrefetch2.CellId)
+            || !string.IsNullOrEmpty(_pendingFromQueue.CellId);
+
+        // 보고가 필요한 상태인지 (정상 + 재시작 모두 포함) >> 용접 완, 보고 미완
+        // ReportSlot은 Shift()마다 갱신되므로 IsCanExist·WeldComplete 조건을 함께 확인한다.
+        public bool HasReport => HasPendingComplete ||
+            (ReportSlot != null && ReportSlot.IsCanExist && ReportSlot.WeldComplete && !ReportSlot.ReportComplete);
+
+        public CellInfoScheduler()
+        {
+            foreach (eJigNo no in Enum.GetValues(typeof(eJigNo)))
+                Add(no, new JigInfo());
+        }
+
+        // 1-based jigNo (_WeldingJigNo 등) → 0-based eJigNo 변환 인덱서
+        public JigInfo this[int jigNo] {
+            get => base[(eJigNo)(jigNo - 1)];
+        }
+
+        // Reset() 전에 호출 — 미완료 보고 및 미용접 슬롯을 보존.
+        public void SavePendingComplete()
+        {
+            // ReportSlot: LBAD 수신 완료 상태, 보고만 남은 셀
+            if (ReportSlot != null
+                && ReportSlot.IsCanExist
+                && ReportSlot.WeldComplete
+                && !ReportSlot.ReportComplete)
+                _pendingFromReportSlot.CopyFrom(ReportSlot);
+            else
+                _pendingFromReportSlot.Clear();
+
+            // Complete: 용접 완료, ReportSlot 진입 전 정지 (LBAD 도착 여부 불확실)
+            if (Complete != null
+                && Complete.IsCanExist
+                && Complete.WeldComplete
+                && !Complete.ReportComplete)
+                _pendingFromComplete.CopyFrom(Complete);
+            else
+                _pendingFromComplete.Clear();
+
+            // 업로드 완료됐으나 로터리 정지로 용접 자체가 안 된 경우 (_pendingPrefetch1/2)
+            if (Prefetch1 != null
+                && Prefetch1.IsCanExist
+                && !string.IsNullOrEmpty(Prefetch1.CellId)
+                && !Prefetch1.WeldComplete)
+                _pendingPrefetch1.CopyFrom(Prefetch1);
+            else
+                _pendingPrefetch1.Clear();
+
+            if (Prefetch2 != null
+                && Prefetch2.IsCanExist
+                && !string.IsNullOrEmpty(Prefetch2.CellId)
+                && !Prefetch2.WeldComplete)
+                _pendingPrefetch2.CopyFrom(Prefetch2);
+            else
+                _pendingPrefetch2.Clear();
+        }
+
+        /// <summary>
+        /// 재시작 시 해당 JigNo의 보존된 셀 정보 복원 시도.
+        /// 성공 시 해당 슬롯을 즉시 클리어하여 한 번만 사용되도록 보장.
+        /// canExist=false 지그가 들어오면 슬롯을 소비(폐기)하여 이후 오염 방지.
+        /// 우선순위: _pendingPrefetch1 → _pendingPrefetch2 → _pendingFromQueue
+        /// </summary>
+        /// <returns>복원 성공 시 true (ReceivedCellInfoQueue TryDequeue 불필요)</returns>
+        public bool TryRestoreCell(int jigNo, out string lotId, out string cellId)
+        {
+            if (_pendingPrefetch1.JigNo == jigNo && !string.IsNullOrEmpty(_pendingPrefetch1.CellId)) {
+                lotId  = _pendingPrefetch1.LotId;
+                cellId = _pendingPrefetch1.CellId;
+                _pendingPrefetch1.Clear();
+                return true;
+            }
+            if (_pendingPrefetch2.JigNo == jigNo && !string.IsNullOrEmpty(_pendingPrefetch2.CellId)) {
+                lotId  = _pendingPrefetch2.LotId;
+                cellId = _pendingPrefetch2.CellId;
+                _pendingPrefetch2.Clear();
+                return true;
+            }
+            if (_pendingFromQueue.JigNo == jigNo && !string.IsNullOrEmpty(_pendingFromQueue.CellId)) {
+                lotId  = _pendingFromQueue.LotId;
+                cellId = _pendingFromQueue.CellId;
+                _pendingFromQueue.Clear();
+                return true;
+            }
+            lotId  = null;
+            cellId = null;
+            return false;
+        }
+
+        /// <summary>
+        /// 정지 시점에 큐에 잔류한 셀을 JigNo와 함께 보존.
+        /// Prefetch2.JigNo 기준으로 다음 지그 번호를 계산하여 호출자가 전달.
+        /// DrainCellInfoQueue() 호출 전에 먼저 호출해야 한다.
+        /// </summary>
+        public void SaveQueueEntry(string lotId, string cellId, int jigNo)
+        {
+            _pendingFromQueue.Clear();
+            _pendingFromQueue.LotId  = lotId;
+            _pendingFromQueue.CellId = cellId;
+            _pendingFromQueue.JigNo  = jigNo;
+            // IsCanExist는 재시작 후 ReadyScannerList에서 PLC 실측값으로 채워지므로 여기서 설정하지 않음
+        }
+
+        /// <summary>
+        /// LBAD MES Report 수신 시 CellId로 파이프라인 슬롯을 찾아 LbadAvg를 저장.
+        /// 정상 경로: Complete 단계에서 수신 (~100ms 후).
+        /// 폴백: Shift 타이밍이 빠른 경우 ReportSlot에도 확인.
+        /// </summary>
+        public bool TrySetLbadAvg(string cellId, double avg)
+        {
+            if (Complete != null && Complete.CellId == cellId) {
+                Complete.LbadAvg = avg;
+                return true;
+            }
+            if (ReportSlot != null && ReportSlot.CellId == cellId) {
+                ReportSlot.LbadAvg = avg;
+                return true;
+            }
+            return false;
+        }
+
+        // 보고 완료 처리.
+        // 정상 경로: ReportSlot.ReportComplete = true
+        // 재시작 경로: _pendingFromReportSlot 또는 _pendingFromComplete 클리어
+        public void CompleteReport()
+        {
+            var reported = ActiveReportSlot;
+            _log.I($"Report >> CellId({reported?.CellId}), JigNo({reported?.JigNo})");
+
+            if (_pendingFromReportSlot.IsCanExist && !_pendingFromReportSlot.ReportComplete)
+                _pendingFromReportSlot.Clear();
+            else if (_pendingFromComplete.IsCanExist && !_pendingFromComplete.ReportComplete)
+                _pendingFromComplete.Clear();
+            else
+                ReportSlot?.SetReportComplete(true);
+        }
+
+        /// <summary>
+        /// 4단계 파이프라인 전진. GC 할당 없음.
+        /// ReportSlot ← Complete ← Prefetch1 ← Prefetch2 ← this[nextJig] (Clear)
+        /// 새 Prefetch2 슬롯은 Clear 후 반환 — 호출자가 셀 정보를 채워야 한다.
+        /// </summary>
+        public void Shift(eJigNo nextJig)
+        {
+            ReportSlot = Complete;       // Complete → ReportSlot
+            Complete   = Prefetch1;      // Prefetch1 → Complete
+            Prefetch1  = Prefetch2;      // Prefetch2 → Prefetch1  (volatile write: release fence)
+            Prefetch2  = base[nextJig];
+            Prefetch2.Clear();
+        }
+        // AutoRun에서 사용되는 자료형으로 추가 (편의 인덱서 사용)
+        public void Shift(int nextJig)
+        {
+            ReportSlot = Complete;       // Complete → ReportSlot
+            Complete   = Prefetch1;      // Prefetch1 → Complete
+            Prefetch1  = Prefetch2;      // Prefetch2 → Prefetch1  (volatile write: release fence)
+            Prefetch2  = this[nextJig];
+            Prefetch2.Clear();
+        }
+
+        /// <summary>
+        /// 전체 초기화 (AutoRun 시작 시 호출).
+        /// SavePendingComplete() 호출 후 이 메서드를 호출할 것.
+        /// pending 슬롯들은 재시작 복원을 위해 건드리지 않음.
+        /// </summary>
+        public void Reset()
+        {
+            foreach (var info in Values)
+                info.Clear();
+
+            Prefetch2  = null;
+            Prefetch1  = null;
+            Complete   = null;
+            ReportSlot = null;
+            // _pendingFromReportSlot, _pendingFromComplete, _pendingPrefetch1/2:
+            // SavePendingComplete()가 복사해 둔 데이터를 유지
+        }
+
+        /// <summary>
+        /// 스케줄러 자체는 Clear 할 수 없도록 함
+        /// </summary>
+        public new void Clear()
+        {
+            Reset();
+        }
+    }
+}

Machines/ILSOS_CCW_H52A/Datas/JigInfo.cs

@@ -0,0 +1,130 @@
+using AuroraLaserScanner;
+using System;
+using WeldingCommon.Data;
+
+namespace ILSOS_CCW_H52A.Data
+{
+    public class JigInfo
+    {
+        // --- 지그 식별 ---
+        public int JigNo;               // 물리 지그 번호 (1-based, -1: 미설정)
+
+        // --- 스캐너 리스트 파라미터 (ReadyScannerList에서 채워짐) ---
+        public eListNo ListNo;
+        public DateTime WriteTime;
+        public double StartAngle;
+        public int WeldingCount;
+
+        // --- 캔 유무 / 용접 상태 ---
+        public bool IsCanExist;
+        public bool IsWelding;
+        public bool WeldComplete;
+        public DateTime WeldStartTime;
+        public DateTime WeldEndTime;
+        public TimeSpan WeldingSpanTime;    // 스캐너 리스트 실행 시간 (GetTime() 결과)
+
+        // CellTracker 수신 정보
+        public string LotId;
+        public string CellId;
+
+        // LBAD MES Report 수신 값 — Complete 단계에서 콜백으로 채워짐, ReportSlot 단계에서 보고에 사용
+        public double LbadAvg;
+
+        // --- 플래그 ---
+        public bool CheckSendCellinfo;
+        public bool ReportComplete;
+
+        // --- 리포팅/뷰 용 상세 정보 ---
+        public WeldingData InnerCellInfo;
+
+        public JigInfo()
+        {
+            InnerCellInfo = new WeldingData();
+            Clear();
+        }
+
+        public void SetReportComplete(bool comp) => ReportComplete = comp;
+
+        /// <summary>
+        /// 다른 JigInfo의 모든 필드를 이 슬롯에 복사 (재시작 보존용 pendingSlot에 사용)
+        /// </summary>
+        public void CopyFrom(JigInfo src)
+        {
+            JigNo = src.JigNo;
+            ListNo = src.ListNo;
+            WriteTime = src.WriteTime;
+            StartAngle = src.StartAngle;
+            WeldingCount = src.WeldingCount;
+            IsCanExist = src.IsCanExist;
+            IsWelding = src.IsWelding;
+            WeldComplete = src.WeldComplete;
+            WeldStartTime = src.WeldStartTime;
+            WeldEndTime = src.WeldEndTime;
+            WeldingSpanTime = src.WeldingSpanTime;
+            LotId = src.LotId;
+            CellId = src.CellId;
+            LbadAvg = src.LbadAvg;
+            CheckSendCellinfo = src.CheckSendCellinfo;
+            ReportComplete = src.ReportComplete;
+            UpdateCellInfo(src.InnerCellInfo);
+        }
+
+        /// <summary>
+        /// 슬롯 전체 초기화 (Shift 시 새 Prefetch2 슬롯에 자동 호출됨)
+        /// </summary>
+        public void Clear()
+        {
+            JigNo = -1;
+            ListNo = 0;
+            WriteTime = DateTime.MinValue;
+            StartAngle = 0.0;
+            WeldingCount = -1;
+
+            IsCanExist = false;
+            IsWelding = false;
+            WeldComplete = false;
+            WeldStartTime = DateTime.MinValue;
+            WeldEndTime = DateTime.MinValue;
+            WeldingSpanTime = TimeSpan.Zero;
+
+            LotId = string.Empty;
+            CellId = string.Empty;
+            LbadAvg = double.NaN;  // NaN = 미수신, 0.0은 수신됐으나 측정값 0
+
+            CheckSendCellinfo = false;
+            ReportComplete = false;
+
+            InnerCellInfo.Clear();
+        }
+
+        /// <summary>
+        /// InnerCellInfo를 WeldingData 로부터 필드 단위로 복사 (GC 할당 없음)
+        /// </summary>
+        public void UpdateCellInfo(WeldingData data)
+        {
+            InnerCellInfo.CellId = data.CellId;
+            InnerCellInfo.LotId = data.LotId;
+            InnerCellInfo.AutoRunStartTime = data.AutoRunStartTime;
+            InnerCellInfo.WeldingStartTime = data.WeldingStartTime;
+            InnerCellInfo.WeldingEndTime = data.WeldingEndTime;
+            InnerCellInfo.WeldingSpanTimeMilliseconds = data.WeldingSpanTimeMilliseconds;
+            InnerCellInfo.TodayProduct = data.TodayProduct;
+            InnerCellInfo.TotalProduct = data.TotalProduct;
+            InnerCellInfo.RecipeNo = data.RecipeNo;
+            InnerCellInfo.WeldStartTime = data.WeldStartTime;
+            InnerCellInfo.WeldTime = data.WeldTime;
+            InnerCellInfo.WorkCellId = data.WorkCellId;
+            InnerCellInfo.WorkLotId = data.WorkLotId;
+            InnerCellInfo.LBAD_Judge = data.LBAD_Judge;
+            InnerCellInfo.LDD_Judge = data.LDD_Judge;
+            InnerCellInfo.LaserPowerCore = data.LaserPowerCore;
+            InnerCellInfo.LaserPowerRing = data.LaserPowerRing;
+            InnerCellInfo.MarkSpeed = data.MarkSpeed;
+            InnerCellInfo.FocalLength = data.FocalLength;
+            InnerCellInfo.WeldingJigNo = data.WeldingJigNo;
+            InnerCellInfo.LaserPowerByLBAD = data.LaserPowerByLBAD;
+            InnerCellInfo.CheckCanExist = data.CheckCanExist;
+            InnerCellInfo.CheckScannerListEnd = data.CheckScannerListEnd;
+        }
+    }
+}

Machines/ILSOS_CCW_H52A/Device/PLC/PLCController.Address.cs

@@ -274,6 +274,10 @@ namespace ILSOS_CCW_H52A.Device
             PLC_PARAM_3_WELDING_RAMPING_END_POWER_1 = 134,
             PLC_PARAM_3_WELDING_RAMPING_END_POWER_2 = 136,
             PLC_PARAM_3_WELDING_RAMPING_END_DISTANCE = 138,
+
+            PLC_PARAM_1_WELDING_LASER_POWER_RING = 140,
+            PLC_PARAM_2_WELDING_LASER_POWER_RING = 142,
+            PLC_PARAM_3_WELDING_LASER_POWER_RING = 144,
         }
 
         public enum eWordOutput : int
@@ -399,7 +403,12 @@ namespace ILSOS_CCW_H52A.Device
             PC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE = 132,
             PC_PARAM_3_WELDING_RAMPING_END_POWER_1 = 134,
             PC_PARAM_3_WELDING_RAMPING_END_POWER_2 = 136,
-            PC_PARAM_3_WELDING_RAMPING_END_DISTANCE = 138
+            PC_PARAM_3_WELDING_RAMPING_END_DISTANCE = 138,
+
+            // 260227 Laser 개조 후 파라미터 추가
+            PC_PARAM_1_WELDING_LASER_POWER_RING = 140,
+            PC_PARAM_2_WELDING_LASER_POWER_RING = 142,
+            PC_PARAM_3_WELDING_LASER_POWER_RING = 144,
         }
     }
 }

Machines/ILSOS_CCW_H52A/EquipDef.cs

@@ -1,7 +1,15 @@
-using WeldingCommon;
+using Aurora;
+using Aurora.Api;
+using ILSOS_CCW_H52A.Sequences.ProcessObjects;
+using WeldingCommon;
 
 namespace ILSOS_CCW_H52A
 {
+    public static class AuroraEnvironmentExt
+    {
+        public static ProcessManager GetProcessManager(this IAuroraEnvironment _) => ProcessManager.Instance;
+        public static ProcessManager GetProcessManager(this SequenceContext _) => ProcessManager.Instance;
+    }
     internal class EquipDef
     {
     }

Machines/ILSOS_CCW_H52A/EquipmentSetup.cs

@@ -39,6 +39,9 @@ using WeldingCommon.Utils;
 using WeldingCommon.Views;
 using WeldingCommon.Vision.Factory;
 using static WeldingCommon.Vision.Factory.VisionFactory;
+using System.Reactive.Linq;
+using System;
+using System.Windows;
 
 namespace ILSOS_CCW_H52A
 {
@@ -57,7 +60,8 @@ namespace ILSOS_CCW_H52A
 
         public override string GetEquipmentName()
         {
-            return "ILSOS CCWH52A";
+            var equipSetting = AuroraEnv.SettingEntry[AuroraSettings.Equipment] as EquipmentInfo;
+            return equipSetting is null ? "ILSOS CCWH52A" : equipSetting.EquipmentName;
         }
 
         public void OnSetAlarm(int code, bool isHeavy)
@@ -76,6 +80,45 @@ namespace ILSOS_CCW_H52A
             base.OnStartUp();
 
             AuroraEnv.SequenceEntry[SequenceIds.AlarmMonitoring].Start();
+
+            AuroraEnv.GetProcessManager().Init(AuroraEnv);
+
+            // 최초에 permission에 대한 값을 적용해줌
+            OnPermissionChanged(null);
+            AuroraEnv.EventObservable.AsObservable(AuroraSysEvent.SYS_PERMISSION_CHANGED)
+                  .Subscribe(OnPermissionChanged);
+
+            var seq = AuroraEnv.SequenceEntry[SequenceIds.SeqAutoRunCCWH52A] as ISequence;
+            seq.RunStateChanged += AutoRunSeq_RunStateChanged;
+        }
+        private void AutoRunSeq_RunStateChanged(object sender, (string sequenceId, SequenceRunState state) e)
+        {
+            //AutoRun 상황에서 Recipe Save Lock
+            AuroraEnv.RecipeManager.SaveLock(CommonRecipeIds.ScannerObjectTeaching, e.state != SequenceRunState.Idle);
+            //AutoRun 상황에서 Reicpe 화면 수정할 수 없도록 함
+            Application.Current.Dispatcher.Invoke(() => {
+                // Running으로 변경되면 Active된 레시피로 변경하도록 함
+                if (e.state == SequenceRunState.Running) {
+                    WeldingRecipeManager.OnActiveReloaded();
+                }
+
+                _UCRecipe.IsEnabled = e.state != SequenceRunState.Running;
+            });
+        }
+        private void OnPermissionChanged(EventMessage message)
+        {
+            bool LoginState = ApplicationExt.PermissionLevel <= (ushort)PermissionLevel.LEVEL3;
+            if (LoginState == false) {
+                // Login 권한이 없어지면 Active된 레시피로 변경하도록 함
+                Application.Current.Dispatcher.Invoke(() => {
+                    WeldingRecipeManager.OnActiveReloaded();
+                });
+            }
+
+            //LogOut 상황에서 Recipe Save Lock
+            AuroraEnv.RecipeManager.SaveLock(CommonRecipeIds.ScannerObjectTeaching, !LoginState);
+            //LogOut 상황에서 Reicpe 화면 수정할 수 없도록 함
+            Application.Current.Dispatcher.Invoke(() => { _UCRecipe.IsEnabled = LoginState; });
         }
 
         // For Selection LaserDevice

Machines/ILSOS_CCW_H52A/ILSOS_CCW_H52A.csproj

@@ -92,6 +92,8 @@
   <ItemGroup>
     <Compile Include="Alarm\AlarmHelper.cs" />
     <Compile Include="Alarm\AlarmManager.cs" />
+    <Compile Include="Datas\CellInfoScheduler.cs" />
+    <Compile Include="Datas\JigInfo.cs" />
     <Compile Include="Device\IO\IOController.Address.cs" />
     <Compile Include="Device\IO\IOController.Logic.cs" />
     <Compile Include="Device\Laser\LaserCoherentArm_IO.cs" />
@@ -109,7 +111,6 @@
     <Compile Include="Sequences\ProcessObjects\ProcessManager.cs" />
     <Compile Include="Sequences\ProcessObjects\ReceivedCellInfo.cs" />
     <Compile Include="Sequences\SeqAutoRunCCWH52A.cs" />
-    <Compile Include="Sequences\SeqAutoRunRMOTF.cs" />
     <Compile Include="Sequences\SequenceContextEx.cs" />
     <Compile Include="Views\Main\UCMainAutoRun.xaml.cs">
       <DependentUpon>UCMainAutoRun.xaml</DependentUpon>

Machines/ILSOS_CCW_H52A/Properties/AssemblyInfo.cs

@@ -49,5 +49,5 @@ using System.Windows;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.0.1")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.1")]

Machines/ILSOS_CCW_H52A/Recipes/RecipeEventHelper.cs

@@ -8,6 +8,7 @@ using static ILSOS_CCW_H52A.Device.PLCControllerCCWH52A;
 using Aurora.Api.Manager;
 using ILSOS_CCW_H52A.Device;
 using WeldingCommon.Recipes;
+using WeldingCommon.Settings;
 
 namespace ILSOS_CCW_H52A.Recipes
 {
@@ -15,62 +16,14 @@ namespace ILSOS_CCW_H52A.Recipes
     // 추가로 SYS_RECIPE_ACTIVATED 에서 처리가 다르게 이루어져야 할 수도 있음. 확장 가능하도록 사용성 열어둠
     internal class RecipeEventHelper
     {
+        private static SystemParameter param;
         internal static void ExternalRecipeUpdate(Logger Log, IAuroraEnvironment aurora)
         {
+            if(param == null)
+                param = aurora.SettingEntry[CommonSettingIds.SystemParameter] as SystemParameter;
             var plc = aurora.DeviceManager[CommonDeviceIds.PLCDevice] as PLCController;
             var activatedRecipeId = aurora.RecipeManager.ActivatedRecipe().Id;
 
-            #region 기존 RMS 방식
-            //Line _Line = null;
-            //var layerObjectList = WeldingRecipeManager.GetWeldingLayerObjects(0);
-            //if (layerObjectList.ElementAt(0) is Line) {
-            //    _Line = (Line)layerObjectList.ElementAt(0);
-            //}
-
-            //if (_Line != null) {
-            //    #region 확인 필요 항목
-            //    //plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_OFF_DELAY, (int)(_LineParam.LaserOffDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_WELDING_LASER_OFF_DELAY.ToString())));
-            //    //plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_MARK_DELAY, (int)(_LineParam.MarkDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_WELDING_MARK_DELAY.ToString())));
-            //    //plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_POLYGON_DELAY, (int)(_LineParam.PolygonDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_WELDING_POLYGON_DELAY.ToString())));
-            //    #endregion
-
-            //    plc.WriteDWord((int)eWordOutput.PC_RECIPE_NO, (int)(activatedRecipeId * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_RECIPE_NO.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_WELDING_RECIPE_NO, (int)(activatedRecipeId * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_RECIPE_NO.ToString())));
-
-            //    plc.WriteDWord((int)eWordOutput.PC_WELDING_FOCAL_LENGTH, (int)(plc.ReadDWord((int)eWordInput.PLC_WELDING_FOCAL_LENGTH).data));      // PLC에서 받은 데이터를 그대로 넘겨주니 변환이 필요 없다
-            //    plc.WriteDWord((int)eWordOutput.PC_SCANNER_X_AXIS, (int)(plc.ReadDWord((int)eWordInput.PLC_SCANNER_X_AXIS).data));                  // PLC에서 받은 데이터를 그대로 넘겨주니 변환이 필요 없다
-
-            //    ScannerParam _LineParam = ScannerCanvasUserCtrl.ScannerParams[_Line.ScannerParamNo];
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_POWER, (int)(_LineParam.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_LASER_POWER.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_DRAW_SPEED, (int)(_LineParam.MarkSpeed * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_DRAW_SPEED.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_JUMP_SPEED, (int)(_LineParam.JumpSpeed * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_JUMP_SPEED.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_ON_DELAY, (int)(_LineParam.LaserOnDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_LASER_ON_DELAY.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_JUMP_DELAY, (int)(_LineParam.JumpDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_JUMP_DELAY.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_1, (int)(_LineParam.RampingStartAPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_1.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam.RampingStartAPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE, (int)(_LineParam.RampingStartADist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1, (int)(_LineParam.RampingStartPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam.RampingStartPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE, (int)(_LineParam.RampingStartDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_1, (int)(_LineParam.RampingEndPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_1.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_2, (int)(_LineParam.RampingEndPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_2.ToString())));
-            //    plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_DISTANCE, (int)(_LineParam.RampingEndDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_DISTANCE.ToString())));
-
-            //    plc.WriteDWord((int)eWordOutput.PC_EQUIPMENT_SPEED, (int)(plc.ReadDWord((int)eWordInput.PLC_EQUIPMENT_SPEED).data));      // PLC에서 받은 데이터를 그대로 넘겨주니 변환이 필요 없다. Equipment Speed는 Rotary Speed로 PC에서는 사용하지 않고 그냥 표기만 해준다.
-
-            //    Log.I(string.Format($"SET PC_RECIPE_PARAM_UPLOAD_COMPLETE True"));
-            //    plc.WriteBit((int)eBitOutput.PC_RECIPE_PARAM_UPLOAD_COMPLETE, true);
-
-            //} else {
-            //    Log.W("Check Whether there is Line in the Activated Recipe Object!");
-            //}
-            #endregion
-            #region 확인 필요 항목
-            //plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_OFF_DELAY, (int)(_LineParam.LaserOffDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_WELDING_LASER_OFF_DELAY.ToString())));
-            //plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_MARK_DELAY, (int)(_LineParam.MarkDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_WELDING_MARK_DELAY.ToString())));
-            //plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_POLYGON_DELAY, (int)(_LineParam.PolygonDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_WELDING_POLYGON_DELAY.ToString())));
-            #endregion
-
             plc.WriteDWord((int)eWordOutput.PC_RECIPE_NO, (int)(activatedRecipeId * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_RECIPE_NO.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_WELDING_RECIPE_NO, (int)(activatedRecipeId * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_RECIPE_NO.ToString())));
 
@@ -89,12 +42,16 @@ namespace ILSOS_CCW_H52A.Recipes
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam_1.RampingStartAPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE, (int)(_LineParam_1.RampingStartADist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1, (int)(_LineParam_1.RampingStartPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1.ToString())));
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam_1.RampingStartPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam_1.RampingStartPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE, (int)(_LineParam_1.RampingStartDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_1, (int)(_LineParam_1.RampingEndPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_1.ToString())));
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_2, (int)(_LineParam_1.RampingEndPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_2.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_2, (int)(_LineParam_1.RampingEndPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_DISTANCE, (int)(_LineParam_1.RampingEndDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_DISTANCE.ToString())));
+            // 260227 Laser 개조 후 파라미터 추가
+            if(param.UseRingPowerRMS)
+                plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_POWER_RING, (int)(_LineParam_1.LaserPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_LASER_POWER_RING.ToString())));
             #endregion
+
             #region PLC Upload Parameter 2
             ScannerParam _LineParam_2 = ScannerCanvasUserCtrl.ScannerParams[1];
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_LASER_POWER, (int)(_LineParam_2.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_LASER_POWER.ToString())));
@@ -106,12 +63,16 @@ namespace ILSOS_CCW_H52A.Recipes
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam_2.RampingStartAPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_A_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE, (int)(_LineParam_2.RampingStartADist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_POWER_1, (int)(_LineParam_2.RampingStartPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_POWER_1.ToString())));
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam_2.RampingStartPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam_2.RampingStartPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE, (int)(_LineParam_2.RampingStartDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_POWER_1, (int)(_LineParam_2.RampingEndPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_POWER_1.ToString())));
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_POWER_2, (int)(_LineParam_2.RampingEndPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_POWER_2.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_POWER_2, (int)(_LineParam_2.RampingEndPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_DISTANCE, (int)(_LineParam_2.RampingEndDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_DISTANCE.ToString())));
+            // 260227 Laser 개조 후 파라미터 추가
+            if (param.UseRingPowerRMS)
+                plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_LASER_POWER_RING, (int)(_LineParam_2.LaserPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_LASER_POWER_RING.ToString())));
             #endregion
+
             #region PLC Upload Parameter 3
             ScannerParam _LineParam_3 = ScannerCanvasUserCtrl.ScannerParams[2];
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_LASER_POWER, (int)(_LineParam_3.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_LASER_POWER.ToString())));
@@ -123,11 +84,14 @@ namespace ILSOS_CCW_H52A.Recipes
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam_3.RampingStartAPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_A_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE, (int)(_LineParam_3.RampingStartADist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_POWER_1, (int)(_LineParam_3.RampingStartPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_POWER_1.ToString())));
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam_3.RampingStartPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2, (int)(_LineParam_3.RampingStartPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE, (int)(_LineParam_3.RampingStartDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_POWER_1, (int)(_LineParam_3.RampingEndPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_POWER_1.ToString())));
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_POWER_2, (int)(_LineParam_3.RampingEndPower3 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_POWER_2.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_POWER_2, (int)(_LineParam_3.RampingEndPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_POWER_2.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_DISTANCE, (int)(_LineParam_3.RampingEndDist * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_DISTANCE.ToString())));
+            // 260227 Laser 개조 후 파라미터 추가
+            if (param.UseRingPowerRMS)
+                plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_LASER_POWER_RING, (int)(_LineParam_3.LaserPower2 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_LASER_POWER_RING.ToString())));
             #endregion
 
             Log.I(string.Format($"SET PC_RECIPE_PARAM_UPLOAD_COMPLETE True"));
@@ -136,6 +100,8 @@ namespace ILSOS_CCW_H52A.Recipes
 
         internal static bool ExternalRecipeChangeRequest(Logger Log, IAuroraEnvironment aurora)
         {
+            if(param == null)
+                param = aurora.SettingEntry[CommonSettingIds.SystemParameter] as SystemParameter;
             var plc = aurora.DeviceManager[CommonDeviceIds.PLCDevice] as PLCController;
             int recipeRequestId = (int)plc.ReadDWord((int)eWordInput.PLC_WELDING_RECIPE_NO).data;
 
@@ -149,47 +115,6 @@ namespace ILSOS_CCW_H52A.Recipes
                 return false;
             }
 
-            #region 기존 RMS 방식
-            //Line _Line = null;
-            //var layerObjectList = WeldingRecipeManager.GetWeldingLayerObjects(0);
-            //if (layerObjectList.ElementAt(0) is Line) {
-            //    _Line = (Line)layerObjectList.ElementAt(0);
-            //}
-
-            //if (_Line != null) {
-            //    ScannerParam _LineParam = ScannerCanvasUserCtrl.ScannerParams[_Line.ScannerParamNo];
-            //    _LineParam.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_LASER_POWER);
-            //    _LineParam.MarkSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_DRAW_SPEED);
-            //    _LineParam.JumpSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_JUMP_SPEED);
-
-            //    // 레이저 포커스 Z축 포지션영역, 해당 파라미터를 어떻게 받아 어떻게 전달할지에 대해서 논의 필요
-            //    //ZPosition?? = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_FOCAL_LENGTH);
-
-            //    _LineParam.LaserOnDelay = (int)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_LASER_ON_DELAY);
-            //    _LineParam.LaserOffDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_LASER_OFF_DELAY);
-            //    _LineParam.JumpDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_JUMP_DELAY);
-            //    _LineParam.MarkDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_MARK_DELAY);
-            //    _LineParam.PolygonDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_POLYGON_DELAY);
-            //    _LineParam.RampingStartAPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_START_A_POWER_1);
-            //    _LineParam.RampingStartAPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_START_A_POWER_2);
-            //    _LineParam.RampingStartADist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_START_A_DISTANCE);
-            //    _LineParam.RampingStartPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_START_B_POWER_1);
-            //    _LineParam.RampingStartPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_START_B_POWER_2);
-            //    _LineParam.RampingStartDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_START_B_DISTANCE);
-            //    _LineParam.RampingEndPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_END_POWER_1);
-            //    _LineParam.RampingEndPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_END_POWER_2);
-            //    _LineParam.RampingEndDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_WELDING_RAMPING_END_DISTANCE);
-
-            //} else {
-            //    Log.W("Check Whether there is Line in the Activated Recipe Object!");
-            //}
-            #endregion
-            #region 확인 필요 항목
-            //_LineParam.LaserOffDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_LASER_OFF_DELAY);
-            //_LineParam.MarkDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_MARK_DELAY);
-            //_LineParam.PolygonDelay = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_POLYGON_DELAY);
-            #endregion
-
             #region Scanner Upload Parameter 1
             ScannerParam _LineParam_1 = ScannerCanvasUserCtrl.ScannerParams[0];
             _LineParam_1.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_LASER_POWER);
@@ -201,11 +126,14 @@ namespace ILSOS_CCW_H52A.Recipes
             _LineParam_1.RampingStartAPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_2);
             _LineParam_1.RampingStartADist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE);
             _LineParam_1.RampingStartPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_1);
-            _LineParam_1.RampingStartPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2);
+            _LineParam_1.RampingStartPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2);
             _LineParam_1.RampingStartDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE);
             _LineParam_1.RampingEndPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_POWER_1);
-            _LineParam_1.RampingEndPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_POWER_2);
+            _LineParam_1.RampingEndPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_POWER_2);
             _LineParam_1.RampingEndDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_DISTANCE);
+            // 260227 Laser 개조 후 파라미터 추가
+            if (param.UseRingPowerRMS)
+                _LineParam_1.LaserPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_LASER_POWER_RING);
             #endregion
             #region Scanner Upload Parameter 2
             ScannerParam _LineParam_2 = ScannerCanvasUserCtrl.ScannerParams[1];
@@ -218,11 +146,13 @@ namespace ILSOS_CCW_H52A.Recipes
             _LineParam_2.RampingStartAPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_2);
             _LineParam_2.RampingStartADist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE);
             _LineParam_2.RampingStartPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_1);
-            _LineParam_2.RampingStartPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2);
+            _LineParam_2.RampingStartPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2);
             _LineParam_2.RampingStartDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE);
             _LineParam_2.RampingEndPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_POWER_1);
-            _LineParam_2.RampingEndPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_POWER_2);
+            _LineParam_2.RampingEndPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_POWER_2);
             _LineParam_2.RampingEndDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_DISTANCE);
+            if (param.UseRingPowerRMS)
+                _LineParam_2.LaserPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_LASER_POWER_RING);
             #endregion
             #region Scanner Upload Parameter 3
             ScannerParam _LineParam_3 = ScannerCanvasUserCtrl.ScannerParams[2];
@@ -235,11 +165,13 @@ namespace ILSOS_CCW_H52A.Recipes
             _LineParam_3.RampingStartAPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_2);
             _LineParam_3.RampingStartADist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE);
             _LineParam_3.RampingStartPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_1);
-            _LineParam_3.RampingStartPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2);
+            _LineParam_3.RampingStartPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2);
             _LineParam_3.RampingStartDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE);
             _LineParam_3.RampingEndPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_POWER_1);
-            _LineParam_3.RampingEndPower3 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_POWER_2);
+            _LineParam_3.RampingEndPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_POWER_2);
             _LineParam_3.RampingEndDist = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_DISTANCE);
+            if (param.UseRingPowerRMS)
+                _LineParam_3.LaserPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_LASER_POWER_RING);
             #endregion
 
             //TODO: Recipe 저장 되어지면 안될꺼 같은데, 확인 필요함.

Machines/ILSOS_CCW_H52A/Sequences/ProcessObjects/ProcessManager.cs

@@ -1,14 +1,18 @@
 using Aurora;
 using Aurora.Api;
 using Aurora.Util.HislogPlus;
+using AuroraCellTracker;
 using AuroraLaserScanner;
 using AuroraPLC;
+using ILSOS_CCW_H52A.Data;
 using ILSOS_CCW_H52A.Device;
+using OpenCvSharp;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows;
@@ -29,12 +33,21 @@ namespace ILSOS_CCW_H52A.Sequences.ProcessObjects
                 return _Instance;
             }
         }
+        private bool usedAnalyzerLog = false;
+        private readonly Logger _log = new Logger("ProcessManager");
+
+
         private IAuroraEnvironment _env;
         private PLCControllerCCWH52A _plc;
         private ScannerCCWH52A _scanner;
+        private CellTracker _cellTracker;
 
-        private bool usedAnalyzerLog = false;
+        public CellInfoScheduler cellScheduler { get; set; }
-        private readonly Logger _log = new Logger("ProcessManager");
+
+        /// CellTracker 콜백에서 직접 수신한 (LotId, CellId) 큐.
+        /// DllSocket_ReceiveDataBuffer 발화 시 즉시 Enqueue — 시퀀스는 TryDequeue로 소비.
+        public ConcurrentQueue<(string LotId, string CellId)> ReceivedCellInfoQueue { get; }
+            = new ConcurrentQueue<(string, string)>();
 
         public const double compensateEncoderReset = 0.015;  // 엔코더 리셋 보상 각도 설정(70도/sec 기준 약 0.015도)
         public const int RotaryJigCount = 16;
@@ -48,7 +61,54 @@ namespace ILSOS_CCW_H52A.Sequences.ProcessObjects
             _env = env;
             _plc = _env.DeviceManager[DeviceIds.PLCDevice] as PLCControllerCCWH52A;
             _scanner = _env.DeviceManager[DeviceIds.Scanner] as ScannerCCWH52A;
+            _cellTracker = _env.DeviceManager[CommonDeviceIds.CellTracker] as CellTracker;
+
+            //CellTracker의 OnCellReceived 이벤트를 구독하여 콜백 수신 시 CellQueue에 직접 적재
+            if (_cellTracker._CellTracker != null)
+                _cellTracker._CellTracker.OnCellReceived += OnCellReceived;
+
+            cellScheduler = new CellInfoScheduler();
         }
+
+        /// <summary>
+        /// LBAD MES Report 수신 콜백을 등록.
+        /// InitDev에서 StreamLightLBAD 생성 후 호출.
+        /// </summary>
+        public void RegisterLbadStream(AuroraLBAD.Service.StreamLightLBAD lbad)
+        {
+            lbad.MesReportReceived += OnLbadMesReportReceived;
+        }
+
+        private void OnLbadMesReportReceived(string lotId, string cellId, int headNum, double avg)
+        {
+            if (cellScheduler.TrySetLbadAvg(cellId, avg))
+                _log.I($"[LBAD] AVG 저장 >> CellId({cellId}) HeadNum({headNum}) AVG({avg:F3})");
+            else
+                _log.W($"[LBAD] 매칭 슬롯 없음 >> CellId({cellId}) HeadNum({headNum}) AVG({avg:F3})");
+        }
+
+        private void OnCellReceived(string lotId, string cellId)
+        {
+            lotId = lotId.Replace("\0", "").Trim();
+            cellId = cellId.Replace("\0", "").Trim();
+            ReceivedCellInfoQueue.Enqueue((lotId, cellId));
+            _log.I($"Cell Tracker CallBack Received >> [LotId({lotId})] [CellId({cellId})] [QueueCount({ReceivedCellInfoQueue.Count})]");
+        }
+
+        /// <summary>
+        /// 재시작 시 큐 잔류 데이터 전량 폐기.
+        /// CellTracker는 투입 기준으로 선읽음하므로, 정지 시점에 큐에 남은 데이터는
+        /// 이미 처리됐거나 이전 회차의 셀 정보일 수 있어 모두 버린다.
+        /// _pendingPrefetch1/2 는 이미 TryDequeue 이후 저장된 별도 슬롯이므로 영향 없음.
+        /// </summary>
+        public void DrainCellInfoQueue()
+        {
+            int count = 0;
+            while (ReceivedCellInfoQueue.TryDequeue(out _)) count++;
+            if (count > 0)
+                _log.W($"[QueueDrain] 재시작 시 잔류 데이터 {count}건 폐기");
+        }
+
         public IEnumerable<bool> CheckRotaryState()
         {
             List<bool> rotaryStates = new List<bool>();

Machines/ILSOS_CCW_H52A/Sequences/SeqAutoRunCCWH52A.cs

@@ -14,16 +14,23 @@ using CoreUnit.Control.UserControl.Canvas;
 using CoreUnit.Scanner.UserControl.ScannerCanvas;
 using DB;
 using Hermes;
+using ILSOS_CCW_H52A.Data;
 using ILSOS_CCW_H52A.Device;
 using ILSOS_CCW_H52A.Models;
 using ILSOS_CCW_H52A.RMS;
+using ILSOS_CCW_H52A.Sequences.ProcessObjects;
+using Microsoft.Win32;
+using OpenCvSharp;
+using OpenCvSharp.Aruco;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reactive.Subjects;
 using System.Reflection;
 using System.Threading;
 using System.Windows;
+using System.Windows.Media.Animation;
 using WeldingCommon;
 using WeldingCommon.Alarm;
 using WeldingCommon.Devices;
@@ -52,24 +59,25 @@ namespace ILSOS_CCW_H52A.Sequences
         // TODO: [장비구현필요] 실제 공정 추가
         const string SEQ_CHECK_LOAD_COMPLETE = "[SeqAutoRunCCWH52A] Check Load Complete";
 
+        public const string SEQ_CHECK_SCANNER_LIST_COMPLETE = "[SeqAutoRunCCWH52A] Check Scanner List Complete";
+        const string SEQ_READY_SCANNER_LIST = "[SeqAutoRunCCWH52A] Ready ScannerList";
+
+        //const string SEQ_SET_PARAMS_RECEIVE_CELL_INFO_SEQ = "[SeqAutoRunCCWH52A] Set Sequence Param (ReceiveCellInfo Seq)";
+        //const string SEQ_DO_ID_RECEIVE_CELL_INFO_SEQ = "[SeqAutoRunCCWH52A] Process (ReceiveCellInfo Seq)";
+        //const string SEQ_GET_PARAMS_RECEIVE_CELL_INFO_SEQ = "[SeqAutoRunCCWH52A] Get Sequence Result (ReceiveCellInfo Seq)";
+
         const string SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ = "[SeqAutoRunCCWH52A] Set Sequence Param (UploadWeldingList Seq)";
         const string SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ = "[SeqAutoRunCCWH52A] Process (UploadWeldingList Seq)";
         const string SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ = "[SeqAutoRunCCWH52A] Get Sequence Result (UploadWeldingList Seq)";
 
-        public const string SEQ_CHECK_SCANNER_LIST_COMPLETE = "[SeqAutoRunCCWH52A] Check Scanner List Complete";
-        const string SEQ_READY_SCANNER_LIST = "[SeqAutoRunCCWH52A] Ready ScannerList";
-
-        const string SEQ_SET_PARAMS_RECEIVE_CELL_INFO_SEQ = "[SeqAutoRunCCWH52A] Set Sequence Param (ReceiveCellInfo Seq)";
-        const string SEQ_DO_ID_RECEIVE_CELL_INFO_SEQ = "[SeqAutoRunCCWH52A] Process (ReceiveCellInfo Seq)";
-        const string SEQ_GET_PARAMS_RECEIVE_CELL_INFO_SEQ = "[SeqAutoRunCCWH52A] Get Sequence Result (ReceiveCellInfo Seq)";
-
         const string SEQ_EXECUTE_WELDING = "[SeqAutoRunCCWH52A] Execute Welding";
         const string SEQ_REQUEST_UNLOAD_CELL = "[SeqAutoRunCCWH52A] Request Unload Cell";
         //const string SEQ_WAIT_LBAD_JUDGE = "[SeqAutoRunCCWH52A] Wait LBAD Judge";
+        const string SEQ_REPORT_CELL_RESULT = "[SeqAutoRunCCWH52A] Report Cell Result";
 
-        const string SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ = "[SeqAutoRunCCWH52A] Set Sequence Param (ReportCellResult Seq)";
+        //const string SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ = "[SeqAutoRunCCWH52A] Set Sequence Param (ReportCellResult Seq)";
-        const string SEQ_DO_ID_REPORT_CELL_RESULT_SEQ = "[SeqAutoRunCCWH52A] Process (ReportCellResult Seq)";
+        //const string SEQ_DO_ID_REPORT_CELL_RESULT_SEQ = "[SeqAutoRunCCWH52A] Process (ReportCellResult Seq)";
-        const string SEQ_GET_RESULT_REPORT_CELL_RESULT_SEQ = "[SeqAutoRunCCWH52A] Get Sequence Result (ReportCellResult Seq)";
+        //const string SEQ_GET_RESULT_REPORT_CELL_RESULT_SEQ = "[SeqAutoRunCCWH52A] Get Sequence Result (ReportCellResult Seq)";
 
         //const string SEQ_REPORT_CELLINFO_TO_PLC = "[SeqAutoRunCCWH52A] ReportCellInfoToPLC";
         const string SEQ_CHECK_CYCLE_STOP = "[SeqAutoRunCCWH52A] Check Cycle Stop";
@@ -101,8 +109,7 @@ namespace ILSOS_CCW_H52A.Sequences
         private SystemParameter _SystemParameter;
         private ScannerCanvasUserCtrl _ScannerCanvasUserCtrl; //스캐너 동작관련 객체 선언
 
-        private string _LotId = "N/A";
+        private int _RecipeNo;
-        private string _CellId = "N/A";
         private int _ModelNo;
 
         private IRecipeManager _RecipeManager;
@@ -113,29 +120,14 @@ namespace ILSOS_CCW_H52A.Sequences
 
         private SeqAutoRunCCWH52A_InitParam _InitParam;
 
-        private uint _TodayProduct;
-        private uint _TotalProduct;
-
         private double _LaserPowerByLBAD;
-        private int _CompletedJigNo;
-        private static bool isWeled;
 
         private bool _ModulationMode;
 
         private DateTime _AutoRunStartTime;
-        private DateTime _WeldingStartTime;
+        // 연속 지그 간 용접 간격 계산 전용 (보고 데이터 아님 — 인터벌 로그용)
-        private TimeSpan _WeldingSpanTime;
+        private DateTime _prevWeldEndTime;
-        private DateTime _WeldEndTime;
-        private TimeSpan _InterfaceSpanTime;
-        private DateTime _InterfaceStartTime;
 
-        private double _CellMeasureCenterOffsetX;
-        private double _CellMeasureCenterOffsetY;
-
-        // MOTF
-        private TimeSpan _WeldInterval;
-
-        private int _LastScannerParamNo = -1; //마지막 작업한 스캔 변수값들이 현재 작업하려는 스캔 변수값과 같은지 판단함(같으면 설정작업을 skip함)
         private int _EncoderOverflowCount = 0;
 
         private double _RotaryEncoderOffset = 0;
@@ -143,12 +135,12 @@ namespace ILSOS_CCW_H52A.Sequences
         private int _WeldingCount = 0;
         private int _RotaryJigCount = 16;
 
+        // 전전 셀/전 셀/대기 셀/완료 셀 파이프라인 스케줄러 (16개 JigInfo 풀, GC-free)
+        private CellInfoScheduler _CellScheduler;
+
         private double _WeldingStartAngle;
 
-        private bool isTheFirstListWrite;
-        private bool isTheSecondListWrite;
         private bool isTheFirstListExecute;
-        private int _RecipeNo;
 
         private bool UsePlcShotThemAll { get; set; } = false;
         private bool UsePlcPositionCompensation { get; set; } = false;
@@ -176,26 +168,29 @@ namespace ILSOS_CCW_H52A.Sequences
 
             sb.AddAction(SEQ_CHECK_LOAD_COMPLETE, CheckLoadComplete);
 
-            sb.AddAction(SEQ_SET_PARAMS_RECEIVE_CELL_INFO_SEQ, SetReceiveCellInfo_SeqParams); // Cell 정보를 받아와 입력한다.
-            sb.AddSubsequence(SEQ_DO_ID_RECEIVE_CELL_INFO_SEQ, SequenceManager.GetSeqBuilder_SeqReceiveCellInfo()); // cell 정보를 받아오는 Sub Seq 실행
-            sb.AddAction(SEQ_GET_PARAMS_RECEIVE_CELL_INFO_SEQ, GetReceiveCellInfo_SeqResult); // Cell 정보를 가져온다
-
             sb.AddAction(SEQ_CHECK_SCANNER_LIST_COMPLETE, CheckScannerListComplete);
             sb.AddDecision(SEQ_READY_SCANNER_LIST, ReadyScannerList);
 
+#warning 아래 서브시퀀스가 CellTracker에서 받은 데이터를 WeldingData에 넣기만함, ProcessManager에서 Cell정보를 직접 Callback으로 받도록 수정함
+            //sb.AddAction(SEQ_SET_PARAMS_RECEIVE_CELL_INFO_SEQ, SetReceiveCellInfo_SeqParams); // Cell 정보를 받아와 입력한다.
+            //sb.AddSubsequence(SEQ_DO_ID_RECEIVE_CELL_INFO_SEQ, SequenceManager.GetSeqBuilder_SeqReceiveCellInfo()); // cell 정보를 받아오는 Sub Seq 실행
+            //sb.AddAction(SEQ_GET_PARAMS_RECEIVE_CELL_INFO_SEQ, GetReceiveCellInfo_SeqResult); // Cell 정보를 가져온다
+
             sb.AddAction(SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ, SetUploadWeldingList_SeqParams);
             sb.AddSubsequence(SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ, SequenceManager.GetSeqBuilder_SeqUploadWeldingList());
             sb.AddAction(SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ, GetUploadWeldingList_SeqResult);
 
             sb.AddAction(SEQ_EXECUTE_WELDING, ExecuteWelding);
             sb.AddAction(SEQ_REQUEST_UNLOAD_CELL, RequestUnloadCell);
+            sb.AddDecision(SEQ_CHECK_CAN_WELDED, CheckCanWelded);
+            sb.AddAction(SEQ_REPORT_CELL_RESULT, ReportCellResult);
 
-            sb.AddAction(SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ, SetReportCellResult_SeqParams);
+#warning ReportCellResult함수로 아래 시퀀스 대체
-            sb.AddSubsequence(SEQ_DO_ID_REPORT_CELL_RESULT_SEQ, SequenceManager.GetSeqBuilder_SeqReportCellResult());
+            //sb.AddAction(SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ, SetReportCellResult_SeqParams);
-            sb.AddAction(SEQ_GET_RESULT_REPORT_CELL_RESULT_SEQ, GetReportCellResult_SeqResult);
+            //sb.AddSubsequence(SEQ_DO_ID_REPORT_CELL_RESULT_SEQ, SequenceManager.GetSeqBuilder_SeqReportCellResult());
+            //sb.AddAction(SEQ_GET_RESULT_REPORT_CELL_RESULT_SEQ, GetReportCellResult_SeqResult);
 
             sb.AddDecision(SEQ_CHECK_CYCLE_STOP, CheckCycleStop);
-            sb.AddDecision(SEQ_CHECK_CAN_WELDED, CheckCanWelded);
 
             sb.AddAction(SEQ_SAVE_RESULT_DATA, SaveResultData);      // 해당 공정의 정보를 기록 함.
             sb.AddAction(SEQ_WRITE_COMPLETION_PLC_BIT, WriteCompletionPLCBit);      // 정상적으로 종료 되면, complete bit write
@@ -203,13 +198,12 @@ namespace ILSOS_CCW_H52A.Sequences
             sb.AddAction(SEQ_COMPLETE, Complete);
 
             sb.Flows(sb.Init > sb[SEQ_ENTER] > sb[SEQ_CHECK_INIT_CONDITION] > sb[SEQ_FORK_ENCODER_MONITOR] > sb[SEQ_CHECK_LOAD_COMPLETE]
-                    > sb[SEQ_SET_PARAMS_RECEIVE_CELL_INFO_SEQ] > sb[SEQ_DO_ID_RECEIVE_CELL_INFO_SEQ] > sb[SEQ_GET_PARAMS_RECEIVE_CELL_INFO_SEQ]
                     > sb[SEQ_CHECK_SCANNER_LIST_COMPLETE] > sb[SEQ_READY_SCANNER_LIST]
                     > sb[SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ] > sb[SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ] > sb[SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ]
-                    > sb[SEQ_EXECUTE_WELDING] > sb[SEQ_REQUEST_UNLOAD_CELL] > sb[SEQ_CHECK_CAN_WELDED]
+                    > sb[SEQ_EXECUTE_WELDING] > sb[SEQ_REQUEST_UNLOAD_CELL] > sb[SEQ_CHECK_CAN_WELDED] > sb[SEQ_REPORT_CELL_RESULT]
-                    > sb[SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ] > sb[SEQ_DO_ID_REPORT_CELL_RESULT_SEQ] > sb[SEQ_GET_RESULT_REPORT_CELL_RESULT_SEQ]
+                    //> sb[SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ] > sb[SEQ_DO_ID_REPORT_CELL_RESULT_SEQ] > sb[SEQ_GET_RESULT_REPORT_CELL_RESULT_SEQ]
                     > sb[SEQ_SAVE_RESULT_DATA] > sb[SEQ_CHECK_CYCLE_STOP]
-                    > sb[SEQ_WRITE_COMPLETION_PLC_BIT] > sb[SEQ_JOIN_ENCODER_MONITOR] > sb[SEQ_COMPLETE]);
+                    > sb[SEQ_WRITE_COMPLETION_PLC_BIT] > sb[SEQ_JOIN_ENCODER_MONITOR] > sb[SEQ_COMPLETE] > sb.Final);
 
             sb.Flows(sb[SEQ_READY_SCANNER_LIST] > sb[SEQ_EXECUTE_WELDING]);
 
@@ -217,7 +211,7 @@ namespace ILSOS_CCW_H52A.Sequences
             sb.Flows(sb[SEQ_CHECK_CYCLE_STOP] > sb[SEQ_CHECK_LOAD_COMPLETE]);
 
             sb.Flows(sb[SEQ_CHECK_INIT_CONDITION] > sb[SEQ_INIT_CONDITION_ERROR] > sb.Final);
-            sb.Flows(sb[SEQ_FORK_ENCODER_MONITOR] > sb[SEQ_ENCODER_MONITOR] > sb[SEQ_JOIN_ENCODER_MONITOR] > sb[SEQ_COMPLETE]);
+            sb.Flows(sb[SEQ_FORK_ENCODER_MONITOR] > sb[SEQ_ENCODER_MONITOR] > sb[SEQ_JOIN_ENCODER_MONITOR] > sb[SEQ_COMPLETE] > sb.Final);
 
             #region
             //sb.Flows(sb[SEQ_FORK_ENCODER_MONITOR] > sb[SEQ_ENCODER_MONITOR]);
@@ -288,8 +282,6 @@ namespace ILSOS_CCW_H52A.Sequences
         private bool InitSequenceVariable(SequenceContext context)
         {
             _AutoRunStartTime = DateTime.Now;
-            _TodayProduct = _SystemParameter.TodayProductCount;
-            _TotalProduct = _SystemParameter.TotalProductCount;
 
             var ActivateRecipeName = _RecipeManager.ActivatedRecipe();
             Log.I($"Current Activate Recipe, ID : {ActivateRecipeName.Id}, Name : {ActivateRecipeName.Name}");
@@ -299,11 +291,9 @@ namespace ILSOS_CCW_H52A.Sequences
 
             _WeldingScannerListNo = eListNo.LIST1;
 
-            _CellMeasureCenterOffsetX = 0.0;
+            _RecipeNo = ActivateRecipeName.Id;
-            _CellMeasureCenterOffsetY = 0.0;
-
             var currentModelName = context.Recipes.ActivatedModelName();
-            var modelItem = context.GetModel<EquipmentSpecificModel_CCW_H52A>(currentModelName, CommonModelIds.EquipmentSpecificModel);
+            var modelItem = context.Models.ModelItem(currentModelName, CommonModelIds.EquipmentSpecificModel) as EquipmentSpecificModel_CCW_H52A;
             _ModelNo = modelItem.Model_No;
 
             return true;
@@ -314,24 +304,27 @@ namespace ILSOS_CCW_H52A.Sequences
             //Device Init
             _Scanner = context.GetLaserScanner();
             _Laser = context.GetLaser();
-            if (_InitParam.UseStream) {
+            //if (_InitParam.UseStream) {
                 _StreamLightLBAD = new StreamLightLBAD();
                 _StreamLightLBAD._Client = context.GetStreamLightClient();
                 _StreamLightLBAD._Sub = context.GetStreamLightSub();
-            }
+                ProcessManager.Instance.RegisterLbadStream(_StreamLightLBAD);
+            //}
             _CellTracker = context.GetCellTracker();
             _PLC = context.Devices[DeviceIds.PLCDevice] as PLCControllerCCWH52A;
             _IO = context.GetIOUnit();
+            _CellScheduler = ProcessManager.Instance.cellScheduler;
+
         }
 
         private bool CheckDeviceReady(SequenceContext context)
         {
             List<string> deviceListToCheck = new List<string>() { CommonDeviceIds.Scanner, CommonDeviceIds.Laser, CommonDeviceIds.PLCDevice, CommonDeviceIds.IODevice };
 
-            if (_InitParam.UseStream) {
+            //if (_InitParam.UseStream) {
                 deviceListToCheck.Add(CommonServiceIds.StreamLightLBADClient);
                 deviceListToCheck.Add(CommonServiceIds.StreamLightLBADSub);
-            }
+            //}
 
             bool isAllDeviceActivated = true;
             foreach (string item in deviceListToCheck) {
@@ -403,15 +396,13 @@ namespace ILSOS_CCW_H52A.Sequences
                 _ModulationMode = false;
             }
 
-            //// PLC Initialize  AutoRun Bit 최소화 작업 진행
+            /////  AutoRun Bit가 OFF인 경우
-            if (_PLC.ReadBit((int)eBitInput.PLC_AUTO_STATUS).data == false)     //  AutoRun Bit가 OFF인 경우
+            if (_PLC.ReadBit((int)eBitInput.PLC_AUTO_STATUS).data == false) {
-            {
+                // AutoRun Request 상태 체크
-                if (_PLC.ReadBit((int)eBitInput.PLC_AUTO_REQ).data == false)    // AutoRun Request 상태 체크
+                if (_PLC.ReadBit((int)eBitInput.PLC_AUTO_REQ).data == false) {
-                {
                     Log.E(string.Format("ERROR Initialize PLC, PLC Alarm ON"));     // AutoRun Request와 AutoRun Bit 모두 OFF인 경우, PLC 측에서 Alarm 발생함.
                     return (int)InitErrorList.PLC_ALARM;
-                }
+                } else {
-                else {
                     Log.E(string.Format("ERROR Initialize PLC, Bit Off PLC_AUTO_STATUS"));       // AutoRun Request가 ON인데 AutoRun Bit 모두 OFF인 경우, PLC에서 AutoRun Bit를 켜지 않음.
                     return (int)InitErrorList.PLC_AUTORUN_BIT_OFF;
                 }
@@ -433,10 +424,6 @@ namespace ILSOS_CCW_H52A.Sequences
             string[] strArr = Dao.SystemRecipe.WorkRecipeFile.Split('\\');
             RecipeFileName = strArr[strArr.Length - 1];
 
-            _LastScannerParamNo = -1;
-
-            // 트럼프 TruDisk를 쓰기 위해서는 SetFirstPulseKiller를 사용해야 함.
-
             // Rotary는 시작 트리거 미사용
             _Scanner.SetControlMode(0);
             UtilUnit.logUnit.SetLog(LogUnit.eLogType.DEBUG, MethodBase.GetCurrentMethod().Name, "[AutoRun] 외부 시작 트리거 DISABLE");
@@ -455,13 +442,32 @@ namespace ILSOS_CCW_H52A.Sequences
 
             Log.I(string.Format($"ScannerUnit.InitRotaryOnTheFlyWeldingCount : m_abwRotaryEncoderOffset({_RotaryEncoderOffset}), weldingCount({_WeldingCount}), weldingJigNo({_WeldingJigNo}), rotaryJigCount({_RotaryJigCount})"));
 
-            // 용접 완료 대기 스캐너 List 리셋
+            // JigInfo 풀 스케줄러 초기화 (전전/전/대기/완료 셀 파이프라인)
-            ResetInputScannerList();
+            // ── 재시작 전 미완료 보고 보존 ───────────────────────────────────────────────
-            WaitingScannerList.Reset();
+            // Complete가 있는 상태로 정지가 들어오면 Reset() 후 슬롯이 Clear()되어 보고 불가.
-            CompleteScannerList.Reset();
+            // SavePendingComplete()로 _pendingSlot에 복사한 뒤 Reset()을 호출한다.
+
+            _CellScheduler.SavePendingComplete();
+
+            // 큐 잔류 셀 보존 — DrainCellInfoQueue 전에 선행 (Prefetch2 다음 지그 기준)
+            // Prefetch2.JigNo가 확정값이므로 다음 지그 = (JigNo % 16) + 1 로 신뢰성 있게 계산
+            if (_CellScheduler.Prefetch2 != null && _CellScheduler.Prefetch2.JigNo > 0) {
+                int nextJigNo = (_CellScheduler.Prefetch2.JigNo % ProcessManager.RotaryJigCount) + 1;
+                if (ProcessManager.Instance.ReceivedCellInfoQueue.TryDequeue(out var qCell)) {
+                    _CellScheduler.SaveQueueEntry(qCell.LotId, qCell.CellId, nextJigNo);
+                    Log.I($"[QueueSave] Jig{nextJigNo} 큐 잔류 셀 보존 >> CellId({qCell.CellId})");
+                }
+            }
+
+            if (_CellScheduler.HasPendingPrefetch)
+                Log.I("[PendingRestore] 미용접 셀 보존됨 >> 재시작 후 JigNo 매칭 시 복원 예정");
+            _CellScheduler.Reset();
+            ProcessManager.Instance.DrainCellInfoQueue();
+
+            // 정지 전 미저장 APD 잔존 데이터 클리어 — 재시작 시 중복 누적 방지
+            Status.GetProcessingWeldingData().APD.Clear();
+            // ─────────────────────────────────────────────────────────────────────────────
 
-            isTheFirstListWrite = true;     // 작업 시작 시 처음 2개의 List는 입력하고 시작한다
-            isTheSecondListWrite = true;
             isTheFirstListExecute = true;   // 제일 첫 List는 ExecuteList 필요. 이후는 AutoChange
 
             _PLC.WriteBit(eBitOutput.PC_AUTO_STATUS, true);
@@ -534,9 +540,6 @@ namespace ILSOS_CCW_H52A.Sequences
             //return SEQ_CHECK_LOAD_COMPLETE;
         }
 
-        #region TODO: [장비구현필요]
-        // TODO: [장비구현필요] 공정 Node 구현
-
         // 지그 상태 확인
         private SequenceActionResult CheckLoadComplete(SequenceContext context, string id, SequenceActionResult param)
         {
@@ -559,69 +562,77 @@ namespace ILSOS_CCW_H52A.Sequences
 
         private SequenceActionResult CheckScannerListComplete(SequenceContext context, string id, SequenceActionResult param)
         {
-            if (isTheFirstListWrite)    // 작업 시작 시, 첫번째 리스트는 바로 쓰고, 바로 시작한다(ExecuteList). 다만 List 명령에 의해 Encoder가 들어올 때까지 대기.
+            // Prefetch1 = 2회 전 업로드된 지그 = 현재 물리적으로 레이저 통과 중 = 완료 체크 대상.
-            {
+            // Shift()는 이 메서드 이후 ReadyScannerList에서 실행되므로, 이 시점의 Prefetch1이
-                isTheFirstListWrite = false;
+            // 원본 코드의 InputScannerList[(listNo-1)]과 동일 대상이다.
-                Log.I("Write the 1st scanner list");
+            // 예열 구간: iter 1~2(Pf1=null) → 통과. iter 3~: Pf1=Jig1 → 실제 처리.
-
+            var jigComplete = _CellScheduler.Prefetch1;
+            if (jigComplete == null) {
+                Log.I($"[Warmup] ScannerList {_WeldingCount}: pipeline not ready, skip complete check");
+                return SequenceAction.Ok();
             }
-            else {
+            if (!CheckInsideWeldPosition(jigComplete.StartAngle)) {
-                if (isTheSecondListWrite)  // 두번째 리스트는 바로 쓰지만, 첫번째 리스트 실행이 완료되면 자동으로 이어서 실행된다(AutoChange)
+                // IsCanExist=false(공 지그)는 리스트 실행은 하지만 용접이 없으므로
-                {
+                // 엔코더 범위를 벗어나도 에러가 아님
-                    isTheSecondListWrite = false;
+                if (jigComplete.IsCanExist) {
-                    Log.I("Write the 2nd scanner list");
-
-                }
-                else {
-                    isWeled = false;
-                    // 첫번째나 두번째가 아니라면, 실제 리스트 실행이 끝난 것이기 때문에 완료 처리가 필요
-                    CompleteScannerList = InputScannerList[(int)_WeldingScannerListNo - 1];
-
-                    if (!CheckCurrentEncoderAngle(CompleteScannerList.StartAngle)) {
-                        // 에러 상황(현재 Rotary Encoder 값이 정상적인 스캐너 리스트 각도 범위를 벗어남)
                     Log.I("ERR_SCANNER_LIST_PROCESSING_TIMEOVER");
-
                     return SequenceAction.Error();
-
+                }
-                        // WON : 2칸 전에 용접을 진행하지 않아 현재 Angle이 CompleteScannerList.StartAngle + 45 범위를 벗어난 경우라면 에러 상황이 아니므로 에러로 처리 할 필요가 없다
+                return SequenceAction.Ok();
-                        // 위에 CheckCurrentEncoderAngle if문 조건 대신 아래 내용으로 테스트 해본 뒤에 적용 필요
-                        //if (!CheckCurrentEncoderAngle(CompleteScannerList.StartAngle)) {
-                        //    // 에러 상황(현재 Rotary Encoder 값이 정상적인 스캐너 리스트 각도 범위를 벗어남)
-                        //    if (CompleteScannerList.CanExist) {
-                        //        Log.I("ERR_SCANNER_LIST_PROCESSING_TIMEOVER");
-                        //        return SequenceAction.Error();
-                        //    }
-                        //    return SequenceAction.Ok();
             }
             else {
-                        if (CompleteScannerList.CanExist) {
+                if (jigComplete.IsCanExist) {
-                            isWeled = true;
                     #region 용접 시간, 엔코더 측정/기록
-                            //_WeldInterval = DateTime.Now - _WeldEndTime;
-                            //_WeldEndTime = DateTime.Now;
-                            //double elapsedTime = _Scanner.GetTime();
-                            //_WeldingSpanTime = TimeSpan.FromSeconds(elapsedTime);  // Encoder 대기 넘어간 후의, 실제 스캐너 리스트 실행 시간
-                            //_WeldingStartTime = _WeldEndTime.Subtract(_WeldingSpanTime);
-
                     double elaspedTime = _Scanner.GetTime();
 
-                            if (CompleteScannerList.WeldComplete) {
+                    if (jigComplete.WeldComplete) {
-                                _WeldInterval = DateTime.Now - _WeldEndTime;
+                        jigComplete.WeldEndTime = DateTime.Now;
-                                _WeldEndTime = DateTime.Now;
+                        jigComplete.WeldingSpanTime = TimeSpan.FromSeconds(elaspedTime);
-                                _WeldingStartTime = CompleteScannerList.WeldStartTime;
+                        TimeSpan weldInterval = jigComplete.WeldEndTime - _prevWeldEndTime;
-                                _WeldingSpanTime = TimeSpan.FromSeconds(elaspedTime);
+                        _prevWeldEndTime = jigComplete.WeldEndTime;
-                                _LotId = CompleteScannerList.LotId;
-                                _CellId = CompleteScannerList.CellId;
 
+                        // 보고 대상 지정 불필요 — Shift()가 Prefetch1 → Complete로 자동 전진
                         Log.I(string.Format("JigNo : {0}, Weld start : {1}, Weld End : {2}, WeldTime : {3}, interval : {4:F3}",
-                                    CompleteScannerList.JigNo, _WeldingStartTime.ToString("HH:mm:ss.fff"), _WeldEndTime.ToString("HH:mm:ss.fff"), _WeldingSpanTime.TotalMilliseconds, _WeldInterval.TotalSeconds));
+                            jigComplete.JigNo,
+                            jigComplete.WeldStartTime.ToString("HH:mm:ss.fff"),
+                            jigComplete.WeldEndTime.ToString("HH:mm:ss.fff"),
+                            jigComplete.WeldingSpanTime.TotalMilliseconds,
+                            weldInterval.TotalSeconds));
 
-                                if (_PLC.ReadBit((int)eBitInput.PLC_USE_WELD_JIG_1 + CompleteScannerList.JigNo - 1).data) {
+                        if (_PLC.ReadBit((int)eBitInput.PLC_USE_WELD_JIG_1 + jigComplete.JigNo - 1).data) {
-                                    _PLC.WriteBit((int)eBitOutput.PC_WELD_COMPLETE_1 + CompleteScannerList.JigNo - 1, true);
+                            _PLC.WriteBit((int)eBitOutput.PC_WELD_COMPLETE_1 + jigComplete.JigNo - 1, true);
-                                    Log.I(string.Format($"PC_WELD_COMPLETE_{CompleteScannerList.JigNo} -> true)"));
+                            Log.I(string.Format($"PC_WELD_COMPLETE_{jigComplete.JigNo} -> true)"));
+                        }
+
+                        if (_SystemParameter.LastResetTime < DateTime.Now.Date) {
+                            _SystemParameter.LastResetTime = DateTime.Now.Date;
+                            Log.I($"Today Count Reset. {_SystemParameter.TodayProductCount} -> 0");
+                            _SystemParameter.TodayProductCount = 0;
+                        }
+
+                        if (_SystemParameter.TodayProductCount < uint.MaxValue) {
+                            _SystemParameter.TodayProductCount++;
+                        }
+                        if (_SystemParameter.TotalProductCount < uint.MaxValue) {
+                            _SystemParameter.TotalProductCount++;
+                        }
+
+                        Status.GetProcessingWeldingData().TotalProduct = _SystemParameter.TotalProductCount;
+                        Status.GetProcessingWeldingData().TodayProduct = _SystemParameter.TodayProductCount;
+                        Status.GetProcessingWeldingData().AutoRunStartTime = _AutoRunStartTime;
+                        Status.GetProcessingWeldingData().RecipeNo = _RecipeNo;
+                        Status.GetProcessingWeldingData().LaserPowerByLBAD = _LaserPowerByLBAD.ToString();
+
+                        // 보고 데이터는 스케줄러의 ActiveReportSlot(Complete 또는 PendingComplete)에서 읽음
+                        var report = _CellScheduler.ActiveReportSlot;
+                        if (report != null) {
+                            Status.GetProcessingWeldingData().LotId = report.LotId;
+                            Status.GetProcessingWeldingData().CellId = report.CellId;
+                            Status.GetProcessingWeldingData().WeldingStartTime = report.WeldStartTime;
+                            Status.GetProcessingWeldingData().WeldingEndTime = report.WeldEndTime;
+                            Status.GetProcessingWeldingData().WeldingSpanTimeMilliseconds = report.WeldingSpanTime.TotalMilliseconds.ToString();
+                            Status.GetProcessingWeldingData().WeldingJigNo = report.JigNo.ToString();
                         }
-                                UpdateProductCount(context);
-                                UpdateProductInfoForView();
                         SaveCellAPD();
                     }
 
@@ -632,8 +643,8 @@ namespace ILSOS_CCW_H52A.Sequences
                     //    }
                     //}
 
-                            UtilUnit.logUnit.SetLog(LogUnit.eLogType.PRODUCT, MethodBase.GetCurrentMethod().Name, "UPDATE_WELDING_TIME;" + _WeldingSpanTime.TotalMilliseconds);
+                    UtilUnit.logUnit.SetLog(LogUnit.eLogType.PRODUCT, MethodBase.GetCurrentMethod().Name, "UPDATE_WELDING_TIME;" + jigComplete.WeldingSpanTime.TotalMilliseconds);
-                            UtilUnit.logUnit.SetLog(LogUnit.eLogType.PRODUCT, MethodBase.GetCurrentMethod().Name, "UPDATE_PRODUCT_COUNT;" + _WeldEndTime.ToString("yyyy-MM-dd HH:mm:ss"));
+                    UtilUnit.logUnit.SetLog(LogUnit.eLogType.PRODUCT, MethodBase.GetCurrentMethod().Name, "UPDATE_PRODUCT_COUNT;" + jigComplete.WeldEndTime.ToString("yyyy-MM-dd HH:mm:ss"));
 
                     double encoder0_0, encoder1_0, encoder0_1, encoder1_1;
                     _Scanner.ReadEncoder(out encoder0_0, out encoder1_0, out encoder0_1, out encoder1_1, true);
@@ -646,36 +657,47 @@ namespace ILSOS_CCW_H52A.Sequences
                     #endregion
                     #region 스캐너 리스트 Record 파일 기록
                     if (_Scanner.Config.UseRecordSignal) {
-                                String RecordFileName = _RecipeManager.ActivatedRecipe().Name + "_Jig#" + CompleteScannerList.JigNo.ToString();
+                        String RecordFileName = _RecipeManager.ActivatedRecipe().Name + "_Jig#" + jigComplete.JigNo.ToString();
                         string DataFilePath = ProjectUtil.GetDataLogSetting().GetFilePath_ScannerRecordLog(RecordFileName, true);
                         _Scanner.SaveRecord(DataFilePath);
                     }
                     #endregion
                 }
             }
-                }
-            }
             return SequenceAction.Ok();
         }
 
-        public bool CheckCurrentEncoderAngle(double startAngle)
+        /// <summary>
+        /// startAngle           startAngle+45
+        ///     │←── OK 구간 ────►│
+        /// ────┼─────────────────┼──────────────►  로터리 각도
+        ///   리스트             여기까지
+        ///   시작             와야 완료 체크 가능
+        /// 판정 로직:
+        /// currentAngle < startAngle          → Too early  (아직 리스트 실행 중, 완료 체크 너무 이름)
+        /// startAngle ≤ current < start+45   → OK         (정상 완료 구간)
+        /// currentAngle ≥ startAngle + 45    → Too late   (너무 늦음, 타임오버 에러)
+        /// </summary>
+        /// <param name="startAngle"> 현재 지그의 시작 각도 </param>
+        /// <returns> 지나갔으면 True </returns>
+        public bool CheckInsideWeldPosition(double startAngle)
         {
             double encoderX, currentAngle;
-
             _Scanner.GetEncoder(out encoderX, out currentAngle, true);
 
-            if (0 < startAngle && currentAngle < 0) {
             // Encoder 반전되는 순간이며, 이 때만 인터락 무시
-            }
+            if (0 < startAngle && currentAngle < 0)
-            else if (startAngle <= currentAngle) {
+                return false;
-                if (currentAngle < startAngle + 45)// 다음 리스트 구간이 끝나기 전까지는 완료가 되어야 한다
+
-                {
+            if (startAngle <= currentAngle && currentAngle < startAngle + 45) {
                 Log.I(string.Format("Current encoder check OK, startAngle : {0}, currentAngle : {1})", startAngle, currentAngle));
                 return true;
             }
-                else Log.W(string.Format("Current encoder check NG(Too late), startAngle : {0}, currentAngle : {1})", startAngle, currentAngle));
+
-            }
+            if (currentAngle < startAngle)
-            else Log.W(string.Format("Current encoder check NG(Too early), startAngle : {0}, currentAngle : {1})", startAngle, currentAngle));
+                Log.W(string.Format("Current encoder check NG(Too early), startAngle : {0}, currentAngle : {1})", startAngle, currentAngle));
+            else
+                Log.W(string.Format("Current encoder check NG(Too late), startAngle : {0}, currentAngle : {1})", startAngle, currentAngle));
 
             return false;
         }
@@ -725,7 +747,65 @@ namespace ILSOS_CCW_H52A.Sequences
             else
                 canExist = GetRotaryCanExist(_WeldingJigNo);
 
-            Log.I("Can Exist : " + canExist.ToString() + ", JigNo " + _WeldingJigNo + " ,CountNo " + _WeldingCount + ", StartAngle(Y) : " + _WeldingStartAngle);
+            //Log.I("Can Exist : " + canExist.ToString() + ", JigNo " + _WeldingJigNo + " ,CountNo " + _WeldingCount + ", StartAngle(Y) : " + _WeldingStartAngle);
+
+            // canExist 여부와 무관하게 매 지그마다 파이프라인 전진
+            // canExist=false 지그도 Shift()해야 Prefetch1 타이밍이 올바르게 유지됨.
+            _CellScheduler.Shift(_WeldingJigNo);
+
+            _CellScheduler.Prefetch2.JigNo = _WeldingJigNo;
+            _CellScheduler.Prefetch2.ListNo = _WeldingScannerListNo;
+            _CellScheduler.Prefetch2.WriteTime = DateTime.Now;
+            _CellScheduler.Prefetch2.StartAngle = _WeldingStartAngle;
+            _CellScheduler.Prefetch2.WeldingCount = _WeldingCount;
+            _CellScheduler.Prefetch2.IsCanExist = canExist;
+
+#warning OC2 ACW 기준 >> Cell Tracker는 어느 시점에 데이터는 주는지 모르겠지만, '전전전 셀' 쯤에서 이미 건네받음! 다른 프로젝트에서 확인 필요함
+            // 복원 우선: 정지 전 업로드됐으나 로터리 감속·정지로 용접 미완된 셀 정보 복원.
+            // canExist=false 지그도 TryRestoreCell을 호출하여 슬롯 소비(폐기) — 이후 오염 방지.
+            (string LotId, string CellId) recvInfo = (string.Empty, string.Empty);
+            if (_CellScheduler.TryRestoreCell(_WeldingJigNo, out var rLot, out var rCell)) {
+                if (canExist) {
+                    recvInfo.LotId = rLot;
+                    recvInfo.CellId = rCell;
+                    Log.I($"[PendingRestore] Jig{_WeldingJigNo} 셀 복원 >> CellId({rCell})");
+                }
+                else {
+                    Log.W($"[PendingRestore] Jig{_WeldingJigNo} canExist=false, 복원 데이터 폐기 >> CellId({rCell})");
+                }
+            }
+            else if (ProcessManager.Instance.ReceivedCellInfoQueue.TryDequeue(out var cell)) {
+                if (canExist) {
+                    recvInfo.LotId = cell.LotId;
+                    recvInfo.CellId = cell.CellId;
+                } else {
+                    // 앞공정 NG 셀: CellTracker는 투입 시 이미 스캔했으므로 큐에서 소비 후 폐기.
+                    // 소비하지 않으면 다음 정상 셀이 이 NG 데이터를 가져가 정합성 붕괴.
+                    Log.W($"[NG Skip] Jig{_WeldingJigNo} canExist=false, 큐 데이터 폐기 >> CellId({cell.CellId})");
+                }
+            } else {
+                if (canExist)
+                    Log.E($"[QueueEmpty] Jig{_WeldingJigNo} canExist=true 이지만 큐가 비어있음");
+
+                _CellTracker.getDummyData(out string lotId, out string cellId);
+                recvInfo.LotId = lotId;
+                recvInfo.CellId = cellId;
+            }
+
+            _CellScheduler.Prefetch2.LotId = recvInfo.LotId;
+            _CellScheduler.Prefetch2.CellId = recvInfo.CellId;
+            Status.GetProcessingWeldingData().WorkLotId = recvInfo.LotId;
+            Status.GetProcessingWeldingData().WorkCellId = recvInfo.CellId;
+
+            if (_CellScheduler.Prefetch2 != null)
+                Log.I($"Prefetch2 >> CellId({_CellScheduler.Prefetch2.CellId}) [CanExist({_CellScheduler.Prefetch2.IsCanExist})] [JigNo({_CellScheduler.Prefetch2.JigNo})] " +
+                      $"[ListNo({_CellScheduler.Prefetch2.ListNo})] [WeldingCount({_CellScheduler.Prefetch2.WeldingCount})]" +
+                      $"[StartAngle(Y)({_CellScheduler.Prefetch2.StartAngle})]");
+
+            if(_CellScheduler.Prefetch1 != null)
+                Log.I($"Prefetch1 >> CellId({_CellScheduler.Prefetch1.CellId}) [CanExist({_CellScheduler.Prefetch1.IsCanExist})] [JigNo({_CellScheduler.Prefetch1.JigNo})] " +
+                    $"[ListNo({_CellScheduler.Prefetch1.ListNo})] [WeldingCount({_CellScheduler.Prefetch1.WeldingCount})]" +
+                    $"[StartAngle(Y)({_CellScheduler.Prefetch1.StartAngle})]");
 
             if (canExist) {
                 #region 용접할 Objects 선택
@@ -738,15 +818,7 @@ namespace ILSOS_CCW_H52A.Sequences
                     Log.I(string.Format("Page 불러오기 : [0])"));
                 }
                 #endregion
-                // 입력한 Scanner List를 완료대기열에 추가
-                // Won : GetProcessingWeldingData().WorkLotId 는 CellTrakcer로 부터 받은 상태의 LotId
-                // GetProcessingWeldingData().LotId 는 AutorunView에 표기할 용접이 완료 된 LotID
-                string LotId = Status.GetProcessingWeldingData().WorkLotId;            // CellTracker로 부터 WorkLotID, WorkCellID 받는 구문 추가 후 해당 데이터로 입력 필요
-                string CellId = Status.GetProcessingWeldingData().WorkCellId;
-                SetInputScannerList(_WeldingScannerListNo, DateTime.Now, _WeldingCount, _WeldingStartAngle, _WeldingJigNo, _RotaryJigCount, canExist, LotId, CellId);
-                _RecipeNo = _RecipeManager.ActivatedRecipe().Id;
 
-                SetWeldingData();
                 return SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ;
             }
             else {
@@ -766,19 +838,6 @@ namespace ILSOS_CCW_H52A.Sequences
 
             return null;
         }
-        private void SetWeldingData()
-        {
-            ScannerParam laserParam = null;
-            laserParam = GetSelectedDrawObjectData(_SelectedDrawObjectList[0]);
-
-            if (laserParam != null) {
-                // EDC 보내는 용도
-                Status.GetProcessingWeldingData().LaserPowerCore = laserParam.LaserPower1.ToString();
-                Status.GetProcessingWeldingData().MarkSpeed = laserParam.MarkSpeed.ToString();
-                Status.GetProcessingWeldingData().FocalLength = (_PLC.ReadDWord((int)eWordInput.PLC_WELDING_FOCAL_LENGTH).data / 1000f).ToString();
-                Status.GetProcessingWeldingData().WeldingJigNo = _WeldingJigNo.ToString();
-            }
-        }
 
         public void WaitForEncoderNextRotarySection(int weldingCount, int rotaryJigCount, double rotaryAngleOffset, double encoderResetOffset, out double sectionStartAngle)
         {
@@ -812,28 +871,7 @@ namespace ILSOS_CCW_H52A.Sequences
 
         public bool GetRotaryCanExist(int jigNo)
         {
-            #region 지그 16개 요청기록 로그 남기기, 빠져나간 캔에 대한 Complete Bit 초기화
-            string result = "";
-
-            for (int i = 1; i <= _RotaryJigCount; i++) {
-                if (_PLC.ReadBit((int)eBitInput.PLC_USE_WELD_JIG_1 + i).data)
-                    result += "1, ";
-                else {
-                    result += "0, ";
-
-                    string outId = string.Format("PC_WELD_COMPLETE_{0}", i);
-
-                    if (_PLC.ReadBit((int)eBitInput.PLC_USE_WELD_JIG_1 + i).data) {
-                        _PLC.WriteBit((int)eBitOutput.PC_WELD_COMPLETE_1 + i, false);
-                        Log.I(string.Format($"PC_WELD_COMPLETE_{1 + i} -> FALSE)"));
-                    }
-                }
-            }
-            //UtilUnit.logUnit.SetLog(LogUnit.eLogType.DEBUG, MethodBase.GetCurrentMethod().Name, string.Format("PLC -> PC 용접 Cmd : ({0})", result));
-            #endregion
-
             if (jigNo <= _RotaryJigCount)
-                //return m_rscPlc.GetDIStatus(string.Format("PLC_USE_WELD_JIG_{0}", jigNo));
                 return _PLC.ReadBit((int)eBitInput.PLC_USE_WELD_JIG_1 + (jigNo - 1)).data;
             else
                 return false;
@@ -845,8 +883,8 @@ namespace ILSOS_CCW_H52A.Sequences
             SeqUploadWeldingList_InitParam seqParams = new SeqUploadWeldingList_InitParam() {
                 NeedSetLaserTiming = _ModulationMode,
                 IncludeListStartEnd = false,
-                CellMeasureCenterOffsetX = _CellMeasureCenterOffsetX,
+                CellMeasureCenterOffsetX = 0,
-                CellMeasureCenterOffsetY = _CellMeasureCenterOffsetY,
+                CellMeasureCenterOffsetY = 0,
                 SelectedDrawObjectList = _SelectedDrawObjectList,
                 WeldingScannerListNo = _WeldingScannerListNo,
                 Rotation_Degree = 11.25,
@@ -863,26 +901,42 @@ namespace ILSOS_CCW_H52A.Sequences
                 return SequenceAction.ForceStopByAlarm(AlarmCode.ALARM_SEQUENCE_UploadWeldingList_ResultFailed);
                 //return null;
             }
+            ScannerParam laserParam = null;
+            laserParam = GetSelectedDrawObjectData(_SelectedDrawObjectList[0]);
 
+            _CellScheduler.Prefetch2.InnerCellInfo.RecipeNo = _RecipeNo;
+            _CellScheduler.Prefetch2.InnerCellInfo.LaserPowerCore = laserParam.LaserPower1.ToString();
+            _CellScheduler.Prefetch2.InnerCellInfo.LaserPowerRing = laserParam.LaserPower2.ToString();
+            _CellScheduler.Prefetch2.InnerCellInfo.MarkSpeed = laserParam.MarkSpeed.ToString();
+            _CellScheduler.Prefetch2.InnerCellInfo.FocalLength = (_PLC.ReadDWord((int)eWordInput.PLC_WELDING_FOCAL_LENGTH).data / 1000f).ToString();
+            _CellScheduler.Prefetch2.InnerCellInfo.WeldingJigNo = _WeldingJigNo.ToString();
+
+            // 업로드 성공 확인 후 뷰/EDC용 Status 갱신 (ReadyScannerList에서 중복 갱신 제거)
+            Status.GetProcessingWeldingData().LaserPowerCore = laserParam.LaserPower1.ToString();
+            Status.GetProcessingWeldingData().LaserPowerRing = laserParam.LaserPower2.ToString();
+            Status.GetProcessingWeldingData().MarkSpeed = laserParam.MarkSpeed.ToString();
+            Status.GetProcessingWeldingData().FocalLength = _CellScheduler.Prefetch2.InnerCellInfo.FocalLength;
+            Status.GetProcessingWeldingData().WeldingJigNo = _WeldingJigNo.ToString();
+            Log.FuncI("CellTracker Load");
             return SequenceAction.Ok();
         }
 
-        private SequenceActionResult SetReceiveCellInfo_SeqParams(SequenceContext context, string id, SequenceActionResult param)
+        //private SequenceActionResult SetReceiveCellInfo_SeqParams(SequenceContext context, string id, SequenceActionResult param)
-        {
+        //{
-            SeqReceiveCellInfo_InitParam seqParams = new SeqReceiveCellInfo_InitParam() {
+        //    SeqReceiveCellInfo_InitParam seqParams = new SeqReceiveCellInfo_InitParam() {
-            };
+        //    };
 
-            return SequenceAction.Ok(seqParams);
+        //    return SequenceAction.Ok(seqParams);
-        }
+        //}
 
-        private SequenceActionResult GetReceiveCellInfo_SeqResult(SequenceContext context, string id, SequenceActionResult param)
+        //private SequenceActionResult GetReceiveCellInfo_SeqResult(SequenceContext context, string id, SequenceActionResult param)
-        {
+        //{
-            var resultOutParam = param.Param as SeqReceiveCellInfo_OutParam;
+        //    var resultOutParam = param.Param as SeqReceiveCellInfo_OutParam;
-            if (resultOutParam.Success == false) {
+        //    if (resultOutParam.Success == false) {
-                return null;
+        //        return null;
-            }
+        //    }
-            return SequenceAction.Ok();
+        //    return SequenceAction.Ok();
-        }
+        //}
 
         private SequenceActionResult ExecuteWelding(SequenceContext context, string id, SequenceActionResult param)
         {
@@ -918,48 +972,61 @@ namespace ILSOS_CCW_H52A.Sequences
         }
         private SequenceActionResult EncoderMonitor(SequenceContext context, string id, SequenceActionResult param)
         {
-            int EncoderLogCount = 0;
             double send_time_offset = 0.1;
-            string LotID = "", CellID = "";
 
             while (!context.Stopped) {
                 double encoderX, currentAngle;
                 _Scanner.GetEncoder(out encoderX, out currentAngle, true);
                 double CurrentPosPLC = GetRotaryCurrentPosition();
-                bool WeldingInPosition = encoderX > _Scanner.Config.MarkingRangeMinRotate + 11.25 - send_time_offset - 0.1 && encoderX < _Scanner.Config.MarkingRangeMinRotate + 11.25 - send_time_offset + 0.1;
+                bool WeldingInPosition = encoderX > _Scanner.Config.MarkingRangeMinRotate + 11.25 - send_time_offset - 0.1
+                                      && encoderX < _Scanner.Config.MarkingRangeMinRotate + 11.25 - send_time_offset + 0.1;
+
+                // ── JigScheduler: 포크 내에서 참조 캡처 (Shift와의 경합 방지) ──────
+                // Prefetch1: 2회 전 업로드된 지그 = 현재 물리적으로 실행 중인 지그.
+                // 원본 코드의 InputScannerList[(listNo-1)]과 동일 대상.
+                // Shift()는 메인 시퀀스에서만 호출되므로 루프 시작 시 캡처해도 안전.
+                var executeTarget = _CellScheduler.Prefetch1;
 
                 if (WeldingInPosition) {
-                    if (InputScannerList[(int)_WeldingScannerListNo - 1].CanExist) {
+                    if (executeTarget != null && executeTarget.IsCanExist && executeTarget.JigNo > 0) {
-                        Log.I($"Fork Before Min Rotate Encoder X : ({encoderX}), Encoder Y : ({currentAngle}), PLC Rotary : ({CurrentPosPLC}), List {_WeldingScannerListNo}, JigNo : ({InputScannerList[(int)_WeldingScannerListNo - 1].JigNo})");
+                        Log.I($"Fork Before Min Rotate Encoder X : ({encoderX}), Encoder Y : ({currentAngle}), PLC Rotary : ({CurrentPosPLC}), List {executeTarget.ListNo}, JigNo : ({executeTarget.JigNo})");
                         if (!_SystemParameter.BypassModeLBAD) {
-                            if (InputScannerList[(int)_WeldingScannerListNo - 1].CheckSendCellinfo == false) {
+                            if (!executeTarget.CheckSendCellinfo) {
-                                LotID = InputScannerList[(int)_WeldingScannerListNo - 1].LotId;
+                                if (currentAngle > executeTarget.StartAngle) {
-                                CellID = InputScannerList[(int)_WeldingScannerListNo - 1].CellId;
+                                    executeTarget.CheckSendCellinfo = _StreamLightLBAD.SendCellInfo(executeTarget.LotId, executeTarget.CellId, _RecipeNo, _ModelNo, executeTarget.JigNo);
-                                if (currentAngle > InputScannerList[(int)_WeldingScannerListNo - 1].StartAngle) {
-                                    InputScannerList[(int)_WeldingScannerListNo - 1].CheckSendCellinfo = _StreamLightLBAD.SendCellInfo(LotID, CellID, _RecipeNo, _ModelNo, InputScannerList[(int)_WeldingScannerListNo - 1].JigNo);
 
-                                    if (InputScannerList[(int)_WeldingScannerListNo - 1].CheckSendCellinfo == false)
+                                    if (!executeTarget.CheckSendCellinfo)
-                                        Log.I($"[LBAD Interface]SendCellInfo null, LotID [{LotID}], CellID [{CellID}], JigNo [{InputScannerList[(int)_WeldingScannerListNo - 1].JigNo}]");
+                                        Log.I($"[LBAD Interface]SendCellInfo null, LotID [{executeTarget.LotId}], CellID [{executeTarget.CellId}], JigNo [{executeTarget.JigNo}]");
                                     else
-                                        Log.I($"[StreamLight]SendCellInfo LotID [{LotID}], CellID [{CellID}], JigNo [{InputScannerList[(int)_WeldingScannerListNo - 1].JigNo}]");
+                                        Log.I($"[StreamLight]SendCellInfo LotID [{executeTarget.LotId}], CellID [{executeTarget.CellId}], JigNo [{executeTarget.JigNo}]");
                                 }
                             }
                         }
                     }
                 }
 
-                if (_IO._iOUnit.ReadDiBit(Convert.ToInt32(eADIAddress.LaserOn))) {
+                var LaserIO = _IO._iOUnit.ReadDiBit(Convert.ToInt32(eADIAddress.LaserOn));
-                    if (InputScannerList[(int)_WeldingScannerListNo - 1].WeldStartTime == DateTime.MinValue && InputScannerList[(int)_WeldingScannerListNo - 1].CanExist) {
+                var IsLaserOn = ChangeChecker.IsChangedBoolMonitoring("LaserOn", LaserIO, true);
-                        InputScannerList[(int)_WeldingScannerListNo - 1].WeldStartTime = DateTime.Now;
+                if (IsLaserOn) {
-                        InputScannerList[(int)_WeldingScannerListNo - 1].WeldComplete = true;
+                    if (executeTarget != null && executeTarget.IsCanExist && executeTarget.WeldStartTime == DateTime.MinValue) {
-                        EncoderLogCount = 0;
+                        executeTarget.WeldStartTime = DateTime.Now;
-                        Log.I($"Laser On, Welding Complete. JigNo : ({InputScannerList[(int)_WeldingScannerListNo - 1].JigNo})");
+                        executeTarget.WeldComplete = true;
+                        Log.I($"Laser On, Welding Complete. JigNo : ({executeTarget.JigNo})");
+                    }
                 }
 
-                    if (EncoderLogCount == 0) {
+                // List의 시작/종료 로그 — MOTF에서 LIST1 -> LIST2 전환 시 종료+시작 각각 기록
-                        Log.I($"Fork Laser On Encoder X : ({encoderX}), Encoder Y : ({currentAngle}), PLC Rotary : ({CurrentPosPLC}), List {_WeldingScannerListNo}, JigNo : ({InputScannerList[(int)_WeldingScannerListNo - 1].JigNo})");
+                _Scanner.GetListPointer(out eListNo curList, out uint pos);
-                    }
+                var isBusy = _Scanner.GetBusyStatus();
-                    EncoderLogCount = (EncoderLogCount + 1) % 7;
+                eListNo effectiveList = (!isBusy && (curList == eListNo.LIST1 || curList == eListNo.LIST2))
+                    ? eListNo.NONE : curList;
+
+                if (ChangeChecker.IsChangedInt("ListState", (int)effectiveList, out int prevListRaw)) {
+                    var prevList = (eListNo)prevListRaw;
+                    if (prevList != eListNo.NONE)
+                        Log.I($"[ListEnd] List {prevList} 종료 >> LaserOn({LaserIO}) EncoderY({currentAngle:F3}) JigNo({executeTarget?.JigNo})");
+                    if (effectiveList != eListNo.NONE)
+                        Log.I($"[ListStart] List {effectiveList} 시작 >> LaserOn({LaserIO}) EncoderY({currentAngle:F3}) JigNo({executeTarget?.JigNo})");
                 }
 
                 for (int i = 0; i < _RotaryJigCount; i++) {
@@ -974,72 +1041,88 @@ namespace ILSOS_CCW_H52A.Sequences
             return SequenceAction.Ok();
         }
 
-        private void UpdateProductCount(SequenceContext context)
+        private SequenceActionResult ReportCellResult(SequenceContext context, string id, SequenceActionResult param)
-        {
-            if (_SystemParameter.LastResetTime < DateTime.Now.Date) {
-                _SystemParameter.LastResetTime = DateTime.Now.Date;
-                Log.I($"Today Count Reset. {_SystemParameter.TodayProductCount} -> 0");
-                _SystemParameter.TodayProductCount = 0;
-            }
-
-            _TodayProduct = _SystemParameter.TodayProductCount;
-            _TotalProduct = _SystemParameter.TotalProductCount;
-            if (_TodayProduct < uint.MaxValue) {
-                _TodayProduct++;
-            }
-            if (_TotalProduct < uint.MaxValue) {
-                _TotalProduct++;
-            }
-            _SystemParameter.TodayProductCount = _TodayProduct;
-            _SystemParameter.TotalProductCount = _TotalProduct;
-        }
-
-        private void UpdateProductInfoForView()
-        {
-            Status.GetProcessingWeldingData().TotalProduct = _TotalProduct;
-            Status.GetProcessingWeldingData().TodayProduct = _TodayProduct;
-
-            Status.GetProcessingWeldingData().AutoRunStartTime = _AutoRunStartTime;
-
-            Status.GetProcessingWeldingData().WeldingStartTime = _WeldingStartTime;
-            Status.GetProcessingWeldingData().WeldingEndTime = _WeldEndTime;
-            Status.GetProcessingWeldingData().WeldingSpanTimeMilliseconds = _WeldingSpanTime.TotalMilliseconds.ToString();
-
-            // Status.GetProcessingWeldingData().LotId 는 Autorun View에 표기할 용접이 완료 된 LotId 이므로 WorkLotID 와의 구분 확인
-            Status.GetProcessingWeldingData().LotId = _LotId;
-            Status.GetProcessingWeldingData().CellId = _CellId;
-
-            Status.GetProcessingWeldingData().RecipeNo = _RecipeNo;
-            Status.GetProcessingWeldingData().LaserPowerByLBAD = _LaserPowerByLBAD.ToString();
-
-            Status.GetProcessingWeldingData().WeldingJigNo = _CompletedJigNo.ToString();
-
-        }
-        private SequenceActionResult SetReportCellResult_SeqParams(SequenceContext context, string id, SequenceActionResult param)
         {
             Status.SetWorkingPosition(eWorkingPosition.REPORTING_RESULT);
 
-            SeqReportCellResult_InitParam seqParams = new SeqReportCellResult_InitParam() {
+            string strDate = DateTime.Now.Date.ToString("yyyyMMdd");
-                EDC_Interface = new EDC(),
+            string strTime = DateTime.Now.ToString("HHmmss");
-            };
 
-            return SequenceAction.Ok(seqParams);
+            // 셀 식별 정보 + LBAD AVG는 스케줄러 슬롯에서 직접 읽음 (ReportSlot 또는 pendingSlot)
-        }
+            // ReportSlot 단계에서는 지그 1회전(~320ms) 경과 → LBAD MES Report(~100ms) 보장 수신
+            var report = _CellScheduler.ActiveReportSlot;
+            bool lbadReceived = !double.IsNaN(report.LbadAvg);
+            string lbadAvg = lbadReceived ? report.LbadAvg.ToString("F3") : "0";
+            if (!lbadReceived)
+                Log.W($"[LBAD] ReportSlot LbadAvg 미수신 >> CellId({report.CellId})");
+            // 레시피·장비 계측값은 Status에서 읽음 (TodayProduct/TotalProduct 포함)
+            var wd = Status.GetProcessingWeldingData();
 
-        private SequenceActionResult GetReportCellResult_SeqResult(SequenceContext context, string id, SequenceActionResult param)
+            string reportDataLocalPath = _CellTracker._CellTrackerConfig.reportDataLocalPath;
-        {
+            string equipName = _CellTracker._CellTrackerConfig.EquipmentName;
-            var resultOutParam = param.Param as SeqReportCellResult_OutParam;
-            if (resultOutParam.Success == false) {
-                return null;
-            }
 
-            // 중복 보고 방지 플래그 세팅
+            string directory = string.Format(reportDataLocalPath + "{0}", strDate);
-            CompleteScannerList.SetReportComplete(true);
+            if (!Directory.Exists(directory))
-            isWeled = false;
+                Directory.CreateDirectory(directory);
+
+            string strPath = string.Format(reportDataLocalPath + "{0}\\{1}_{2}_{3}.csv",
+                strDate, strDate, "H52A_" + equipName, strTime.Substring(0, 2));
+
+            // ECS 전송용 strData 빌드
+            string strData = string.Format(
+                "Date={0},Time={1},LotID={2},CellID={3}," +
+                equipName + "DATA001={4}," +
+                equipName + "DATA002={5}," +
+                equipName + "DATA003={6}," +
+                equipName + "DATA004={7}," +
+                equipName + "DATA005={8}," +
+                equipName + "DATA006={9}," +
+                equipName + "DATA007={10}," +
+                equipName + "DATA008={11}," +
+                equipName + "DATA009={12}",
+                strDate, strTime, report.LotId, report.CellId,
+                report.InnerCellInfo.RecipeNo, report.InnerCellInfo.LaserPowerCore, report.InnerCellInfo.MarkSpeed, report.InnerCellInfo.FocalLength,
+                report.JigNo, report.WeldingSpanTime.TotalMilliseconds.ToString(), lbadAvg,
+                wd.TodayProduct, wd.TotalProduct);
+            _CellTracker.SendEcsData(report.CellId, strPath, strData + "");
+            Log.I($"Report to CellTracker >> [LotID({report.LotId})] [CellID({report.CellId})] [LbadAvg({lbadAvg})]");
+
+            // 로컬 CSV 저장
+            string strItem = "//Date, Time, LotID, CellID, RecipeNo, LaserPower, MarkSpeed, FocalLength, HeadNo, WeldingTime, LaserPowerByLBAD, TodayCount, TotalCount";
+            string strCsvData = string.Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}",
+                strDate, strTime, report.LotId, report.CellId,
+                report.InnerCellInfo.RecipeNo, report.InnerCellInfo.LaserPowerCore, report.InnerCellInfo.MarkSpeed, report.InnerCellInfo.FocalLength,
+                report.JigNo, report.WeldingSpanTime.TotalMilliseconds.ToString(), lbadAvg,
+                wd.TodayProduct, wd.TotalProduct);
+            WeldingCommon.Utils.ExcelManagementUnit.AppendStringInCSV(strPath, strItem, strCsvData);
+
+            // 보고 완료: Complete.ReportComplete=true 설정 + pendingSlot 클리어
+            _CellScheduler.CompleteReport();
 
             return SequenceAction.Ok();
         }
 
+        //private SequenceActionResult SetReportCellResult_SeqParams(SequenceContext context, string id, SequenceActionResult param)
+        //{
+        //    Status.SetWorkingPosition(eWorkingPosition.REPORTING_RESULT);
+
+        //    SeqReportCellResult_InitParam seqParams = new SeqReportCellResult_InitParam() {
+        //        EDC_Interface = new EDC(),
+        //    };
+
+        //    return SequenceAction.Ok(seqParams);
+        //}
+
+        //private SequenceActionResult GetReportCellResult_SeqResult(SequenceContext context, string id, SequenceActionResult param)
+        //{
+        //    var resultOutParam = param.Param as SeqReportCellResult_OutParam;
+        //    if (resultOutParam.Success == false) {
+        //        return null;
+        //    }
+
+        //    return SequenceAction.Ok();
+        //}
+
         private static string CheckCycleStop(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param)
         {
             Status.SetWorkingPosition(eWorkingPosition.CHECKING_CYCLE);
@@ -1058,23 +1141,23 @@ namespace ILSOS_CCW_H52A.Sequences
                 return SEQ_CHECK_LOAD_COMPLETE;
             }
         }
-        // END ALL
+
-        #endregion
         private string CheckCanWelded(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param)
         {
-            // 중복 보고 방지:
+            // ── 재시작 전 미완료 보고 우선 처리 ─────────────────────────────────────────
-            //  - CanExist=false (skip 대상) 는 보고하지 않음(미사용)
+            // SavePendingComplete()로 보존된 슬롯이 있으면 정상 파이프라인(Complete)보다 우선.
-            //  - WeldComplete=false (레이저 ON 감지/완료 처리 전) 는 보고하지 않음(미사용)
+            if (_CellScheduler.HasPendingComplete) {
-            //  - ReportComplete=true (이미 보고 완료) 는 다시 보고하지 않음
+                var p = _CellScheduler.PendingComplete;
-            //    .시퀀스가 너무 빨리 내려가서 보고하는 케이스로 예상
+                Log.I($"[PendingReport] 재시작 전 미완료 보고: LotId={p.LotId}, CellId={p.CellId}, JigNo={p.JigNo}");
+                return SEQ_REPORT_CELL_RESULT;
+            }
+            // ─────────────────────────────────────────────────────────────────────────────
 
-            // 보고 누락:
+            // 정상 보고 경로:
-            //  - 첫번째, 두번째는 UploadWeldingList를 해야하기 때문에 일단 넘긴다.
+            //  - Complete(Shift로 자동 승격)에 용접 완료된 셀이 있고 아직 보고 미완인 경우
-            if (isWeled
+            //  - 예열 구간(Complete=null 또는 WeldComplete=false)은 자연스럽게 통과
-                //CompleteScannerList.CanExist &&
+            if (_CellScheduler.HasReport)
-                //CompleteScannerList.WeldComplete &&
+                return SEQ_REPORT_CELL_RESULT;
-                && !CompleteScannerList.ReportComplete)
-                return SEQ_SET_PARAMS_REPORT_CELL_RESULT_SEQ;
 
             return SEQ_CHECK_CYCLE_STOP;
         }
@@ -1090,7 +1173,6 @@ namespace ILSOS_CCW_H52A.Sequences
         }
         private SequenceActionResult SaveResultData(SequenceContext context, string id, SequenceActionResult param)
         {
-
             context.PutValue(ContextKey.KEY_SEQUENCE_RESULT, true);
             return SequenceAction.Ok();
         }
@@ -1211,13 +1293,16 @@ namespace ILSOS_CCW_H52A.Sequences
         {
             Status.EquipmentMode = eEquipmentMode.MANUAL;
 
-            if((_CellTracker._CellTracker as CellTrackerDaekhon) != null && _CellTracker._CellTracker is CellTrackerDaekhon tracker){
+            foreach (var info in ProcessManager.Instance.ReceivedCellInfoQueue.Select((value, index) => (value, index))) {
-                Log.I($"Stoped Seq >> CellTracker Recv Queue count ({tracker.CellInfoQueue.Count})");
+                Log.I($"[{info.index}]Queue >> CellId({info.value.CellId}) LotId({info.value.LotId})");
-                foreach (var info in tracker.CellInfoQueue.Select((value, index) => (value, index))) {
-                    Log.I($"[{info.index}]Queue >> CellId[{info.value.CellID}] / LotId[{info.value.LotID}]");
-                }
             }
 
+            // 정지 시점 파이프라인 상태 로그 (재시작 후 복원 여부 사전 확인용)
+            if (_CellScheduler.Prefetch1 != null && !string.IsNullOrEmpty(_CellScheduler.Prefetch1.CellId))
+                Log.I($"Stoped Seq >> Prefetch1[Jig{_CellScheduler.Prefetch1.JigNo}] CellId={_CellScheduler.Prefetch1.CellId}, WeldComplete={_CellScheduler.Prefetch1.WeldComplete}");
+            if (_CellScheduler.Prefetch2 != null && !string.IsNullOrEmpty(_CellScheduler.Prefetch2.CellId))
+                Log.I($"Stoped Seq >> Prefetch2[Jig{_CellScheduler.Prefetch2.JigNo}] CellId={_CellScheduler.Prefetch2.CellId}, WeldComplete={_CellScheduler.Prefetch2.WeldComplete}");
+
             //PLC All BIT OFF
             for (int i = 0; i < _RotaryJigCount; i++)
                 _PLC.WriteBit(eBitOutput.PC_WELD_COMPLETE_1 + i, false);

Machines/ILSOS_CCW_H52A/Views/Main/UCMainAutoRunViewModel.cs

@@ -78,7 +78,6 @@ namespace ILSOS_CCW_H52A.Views
             _Plc = _Aurora.DeviceManager[CommonDeviceIds.PLCDevice] as PLCControllerCCWH52A;
 
             _SeqAutoRun = _Aurora.SequenceEntry[SequenceIds.SeqAutoRunCCWH52A];
-            _SeqAutoRun.RunStateChanged += AutoRunSeq_RunStateChanged;
 
             InitVariable();
 
@@ -253,24 +252,5 @@ namespace ILSOS_CCW_H52A.Views
                     return;
             }
         }
-
-        private void AutoRunSeq_RunStateChanged(object sender, (string sequenceId, SequenceRunState state) e)
-        {
-            //AutoRun 상황에서 Recipe Save Lock
-            _RecipeManager.SaveLock(
-                CommonRecipeIds.ScannerObjectTeaching,
-                e.state != SequenceRunState.Idle);
-            //AutoRun 상황에서 Reicpe 화면 수정할 수 없도록 함
-            if (e.state == SequenceRunState.Running) {
-                Application.Current.Dispatcher.InvokeAsync(() => {
-                    _UCRecipe.IsEnabled = false;
-                });
-            } else {
-                Application.Current.Dispatcher.InvokeAsync(() => {
-                    _UCRecipe.IsEnabled = true;
-                });
-            }
-        }
-
     }
 }

WeldingComponents/LASA/GUI/Dialog/WeldingParamDlg.Designer.cs

@@ -149,10 +149,8 @@
             this.label81 = new System.Windows.Forms.Label();
             this.nudRampingEndPower1 = new System.Windows.Forms.NumericUpDown();
             this.nudRampingEndPower2 = new System.Windows.Forms.NumericUpDown();
-            this.nudRampingEndPower3 = new System.Windows.Forms.NumericUpDown();
             this.nudRampingStartPower1 = new System.Windows.Forms.NumericUpDown();
             this.nudRampingStartPower2 = new System.Windows.Forms.NumericUpDown();
-            this.nudRampingStartPower3 = new System.Windows.Forms.NumericUpDown();
             this.nudRampingStartDist = new System.Windows.Forms.NumericUpDown();
             this.nudRampingEndDist = new System.Windows.Forms.NumericUpDown();
             this.lbRampingInterval = new System.Windows.Forms.Label();
@@ -193,10 +191,8 @@
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartADist)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndPower1)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndPower2)).BeginInit();
-            ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndPower3)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartPower1)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartPower2)).BeginInit();
-            ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartPower3)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartDist)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndDist)).BeginInit();
             this.SuspendLayout();
@@ -1381,10 +1377,8 @@
             this.gbRamping.Controls.Add(this.label81);
             this.gbRamping.Controls.Add(this.nudRampingEndPower1);
             this.gbRamping.Controls.Add(this.nudRampingEndPower2);
-            this.gbRamping.Controls.Add(this.nudRampingEndPower3);
             this.gbRamping.Controls.Add(this.nudRampingStartPower1);
             this.gbRamping.Controls.Add(this.nudRampingStartPower2);
-            this.gbRamping.Controls.Add(this.nudRampingStartPower3);
             this.gbRamping.Controls.Add(this.nudRampingStartDist);
             this.gbRamping.Controls.Add(this.nudRampingEndDist);
             this.gbRamping.Controls.Add(this.nudRampingInterval);
@@ -1564,20 +1558,6 @@
             this.nudRampingEndPower2.TabIndex = 23;
             this.nudRampingEndPower2.Leave += new System.EventHandler(this.textBoxScannerParam_Leave);
             //
-            // nudRampingEndPower3
-            // 
-            this.nudRampingEndPower3.Location = new System.Drawing.Point(234, 204);
-            this.nudRampingEndPower3.Maximum = new decimal(new int[] {
-            200,
-            0,
-            0,
-            0});
-            this.nudRampingEndPower3.Name = "nudRampingEndPower3";
-            this.nudRampingEndPower3.Size = new System.Drawing.Size(78, 21);
-            this.nudRampingEndPower3.TabIndex = 25;
-            this.nudRampingEndPower3.Visible = false;
-            this.nudRampingEndPower3.Leave += new System.EventHandler(this.textBoxScannerParam_Leave);
-            // 
             // nudRampingStartPower1
             //
             this.nudRampingStartPower1.Location = new System.Drawing.Point(234, 108);
@@ -1604,19 +1584,6 @@
             this.nudRampingStartPower2.TabIndex = 21;
             this.nudRampingStartPower2.Leave += new System.EventHandler(this.textBoxScannerParam_Leave);
             //
-            // nudRampingStartPower3
-            // 
-            this.nudRampingStartPower3.Location = new System.Drawing.Point(234, 132);
-            this.nudRampingStartPower3.Maximum = new decimal(new int[] {
-            200,
-            0,
-            0,
-            0});
-            this.nudRampingStartPower3.Name = "nudRampingStartPower3";
-            this.nudRampingStartPower3.Size = new System.Drawing.Size(78, 21);
-            this.nudRampingStartPower3.TabIndex = 24;
-            this.nudRampingStartPower3.Visible = false;
-            // 
             // nudRampingStartDist
             //
             this.nudRampingStartDist.DecimalPlaces = 3;
@@ -1918,10 +1885,8 @@
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartADist)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndPower1)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndPower2)).EndInit();
-            ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndPower3)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartPower1)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartPower2)).EndInit();
-            ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartPower3)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingStartDist)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nudRampingEndDist)).EndInit();
             this.ResumeLayout(false);
@@ -2069,10 +2034,8 @@
         private System.Windows.Forms.NumericUpDown nudRampingStartDist;
         private System.Windows.Forms.NumericUpDown nudRampingEndPower1;
         private System.Windows.Forms.NumericUpDown nudRampingEndPower2;
-        private System.Windows.Forms.NumericUpDown nudRampingEndPower3;
         private System.Windows.Forms.NumericUpDown nudRampingStartPower1;
         private System.Windows.Forms.NumericUpDown nudRampingStartPower2;
-        private System.Windows.Forms.NumericUpDown nudRampingStartPower3;
         private System.Windows.Forms.NumericUpDown nudRampingStartAPower1;
         private System.Windows.Forms.NumericUpDown nudRampingStartAPower2;
         private System.Windows.Forms.NumericUpDown nudRampingStartADist;

WeldingComponents/LASA/GUI/Dialog/WeldingParamDlg.cs

@@ -86,16 +86,16 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
                 btnOk.Enabled = false;
                 btnCancel.Enabled = true;
             }
-            if(_MachineName == eMachineName.H52A_CCW || _MachineName == eMachineName.H52A_ACW || _MachineName == eMachineName.CIT) {
+            //if(_MachineName == eMachineName.H52A_CCW || _MachineName == eMachineName.H52A_ACW || _MachineName == eMachineName.CIT) {
-                label58.Text = "(0~4000)";
+            label58.Text = _MachineName == eMachineName.H52A_CCW ? "(0~1500)" : "(0~4000)";
-                label31.Text = "(0~4000)";
+            label31.Text = _MachineName == eMachineName.H52A_CCW ? "(0~2500)" : "(0~4000)";
             label32.Text = "(0~10000)";
             label17.Text = "(1~8000)";
 
-                label22.Enabled = false;
+            label22.Enabled = _MachineName == eMachineName.H52A_CCW;
-                tbLaserPower2.Enabled = false;
+            tbLaserPower2.Enabled = _MachineName == eMachineName.H52A_CCW;
-                label29.Enabled = false;
+            label29.Enabled = _MachineName == eMachineName.H52A_CCW;
-                label31.Enabled = false;
+            label31.Enabled = _MachineName == eMachineName.H52A_CCW;
 
             // Ramping Start, End 구분 후 사용한다.       Power 2번은 여전히 막아둠
             //label68.Enabled = false;
@@ -157,9 +157,6 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             nudRampingStartPower1.Enabled = PermissionCheck;
             nudRampingEndPower1.Enabled = PermissionCheck;
 
-                nudRampingStartPower3.Enabled = PermissionCheck;
-                nudRampingEndPower3.Enabled = PermissionCheck;
-
             nudRampingStartAPower1.Enabled = PermissionCheck;
             nudRampingStartAPower2.Enabled = PermissionCheck;
             nudRampingStartADist.Enabled = PermissionCheck;
@@ -184,10 +181,8 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             nudRampingStartPower2.Visible = false;
             nudRampingEndPower2.Visible = false;
 
-                nudRampingStartPower3.Visible = true;
-                nudRampingEndPower3.Visible = true;
             #endregion
-            }
+            //}
 
             //Welding Paramter 색 지정
             //rbParam1.ForeColor = Color.FromName(((WeldingParameterIDEditor.eWeldingColor)1).ToString());
@@ -329,13 +324,6 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             else
                 nudRampingStartPower2.Value = Convert.ToDecimal(selectedParam.RampingStartPower2);
 
-            if (nudRampingStartPower3.Maximum < Convert.ToDecimal(selectedParam.RampingStartPower3))
-                nudRampingStartPower3.Value = nudRampingStartPower3.Maximum;
-            else if (nudRampingStartPower3.Minimum > Convert.ToDecimal(selectedParam.RampingStartPower3))
-                nudRampingStartPower3.Value = nudRampingStartPower3.Minimum;
-            else
-                nudRampingStartPower3.Value = Convert.ToDecimal(selectedParam.RampingStartPower3);
-
             if (nudRampingStartDist.Maximum < Convert.ToDecimal(selectedParam.RampingStartDist))
                 nudRampingStartDist.Value = nudRampingStartDist.Maximum;
             else if (nudRampingStartDist.Minimum > Convert.ToDecimal(selectedParam.RampingStartDist))
@@ -357,15 +345,6 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             else
                 nudRampingEndPower2.Value = Convert.ToDecimal(selectedParam.RampingEndPower2);
 
-
-            if (nudRampingEndPower3.Maximum < Convert.ToDecimal(selectedParam.RampingEndPower3))
-                nudRampingEndPower3.Value = nudRampingEndPower3.Maximum;
-            else if (nudRampingEndPower3.Minimum > Convert.ToDecimal(selectedParam.RampingEndPower3))
-                nudRampingEndPower3.Value = nudRampingEndPower3.Minimum;
-            else
-                nudRampingEndPower3.Value = Convert.ToDecimal(selectedParam.RampingEndPower3);
-
-
             if (nudRampingEndDist.Maximum < Convert.ToDecimal(selectedParam.RampingEndDist))
                 nudRampingEndDist.Value = nudRampingEndDist.Maximum;
             else if (nudRampingEndDist.Minimum > Convert.ToDecimal(selectedParam.RampingEndDist))
@@ -425,11 +404,9 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
 
                 selectedParam.RampingStartPower1 = Convert.ToUInt32(nudRampingStartPower1.Value);
                 selectedParam.RampingStartPower2 = Convert.ToUInt32(nudRampingStartPower2.Value);
-                selectedParam.RampingStartPower3 = Convert.ToUInt32(nudRampingStartPower3.Value);
                 selectedParam.RampingStartDist = (double)nudRampingStartDist.Value;
                 selectedParam.RampingEndPower1 = Convert.ToUInt32(nudRampingEndPower1.Value);
                 selectedParam.RampingEndPower2 = Convert.ToUInt32(nudRampingEndPower2.Value);
-                selectedParam.RampingEndPower3 = Convert.ToUInt32(nudRampingEndPower3.Value);
                 selectedParam.RampingEndDist = (double)nudRampingEndDist.Value;
                 selectedParam.RampingInterval = (double)nudRampingInterval.Value;
 
@@ -873,11 +850,9 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
                 nudRampingStartDist.Enabled = false;
                 nudRampingStartPower1.Enabled = false;
                 nudRampingStartPower2.Enabled = false;
-                nudRampingStartPower3.Enabled = false;
                 nudRampingEndDist.Enabled = false;
                 nudRampingEndPower1.Enabled = false;
                 nudRampingEndPower2.Enabled = false;
-                nudRampingEndPower3.Enabled = false;
                 nudRampingInterval.Enabled = false;
                 checkBoxStartRampingSlopeMode.Enabled = false;
                 checkBoxEndRampingSlopeMode.Enabled = false;
@@ -886,11 +861,9 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
                 nudRampingStartDist.Enabled = true;
                 nudRampingStartPower1.Enabled = true;
                 nudRampingStartPower2.Enabled = true;
-                nudRampingStartPower3.Enabled = true;
                 nudRampingEndDist.Enabled = true;
                 nudRampingEndPower1.Enabled = true;
                 nudRampingEndPower2.Enabled = true;
-                nudRampingEndPower3.Enabled = true;
                 nudRampingInterval.Enabled = true;
                 checkBoxStartRampingSlopeMode.Enabled = true;
                 checkBoxEndRampingSlopeMode.Enabled = true;
@@ -938,19 +911,17 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             tbWobbelLongitudinal.ImeMode = ImeMode.Disable;
             tbWobbelFrequency.ImeMode = ImeMode.Disable;
 
-            nudRampingStartAPower1.ImeMode = ImeMode.Disable;;
+            nudRampingStartAPower1.ImeMode = ImeMode.Disable;
-            nudRampingStartAPower2.ImeMode = ImeMode.Disable;;
+            nudRampingStartAPower2.ImeMode = ImeMode.Disable;
-            nudRampingStartADist.ImeMode = ImeMode.Disable;;
+            nudRampingStartADist.ImeMode = ImeMode.Disable;
 
-            nudRampingStartPower1.ImeMode = ImeMode.Disable;;
+            nudRampingStartPower1.ImeMode = ImeMode.Disable;
-            nudRampingStartPower2.ImeMode = ImeMode.Disable;;
+            nudRampingStartPower2.ImeMode = ImeMode.Disable;
-            nudRampingStartPower3.ImeMode = ImeMode.Disable;;
+            nudRampingStartDist.ImeMode = ImeMode.Disable;
-            nudRampingStartDist.ImeMode = ImeMode.Disable;;
+            nudRampingEndPower1.ImeMode = ImeMode.Disable;
-            nudRampingEndPower1.ImeMode = ImeMode.Disable;;
+            nudRampingEndPower2.ImeMode = ImeMode.Disable;
-            nudRampingEndPower2.ImeMode = ImeMode.Disable;;
+            nudRampingEndDist.ImeMode = ImeMode.Disable;
-            nudRampingEndPower3.ImeMode = ImeMode.Disable;;
+            nudRampingInterval.ImeMode = ImeMode.Disable;
-            nudRampingEndDist.ImeMode = ImeMode.Disable;;
-            nudRampingInterval.ImeMode = ImeMode.Disable;;
         }
     }
 }

WeldingComponents/LASA/GUI/Scanner/ScannerParam.cs

@@ -297,20 +297,6 @@ namespace CoreUnit.Scanner.UserControl.ScannerCanvas
             set { m_rampingStartPower2 = value; }
         }
 
-
-        uint m_rampingStartPower3;
-        [Browsable(true)]
-        [ReadOnly(false)]
-        [Category("Ramping")]
-        [DisplayName("Start Power(%)")]
-        [Description("Start Power(Max:100, Min:0, Unit: %)")]
-        [XmlSerializable]
-        public uint RampingStartPower3
-        {
-            get { return m_rampingStartPower3; }
-            set { m_rampingStartPower3 = value; }
-        }
-
         //bool m_rampingStartSlopeMode;
         //[Browsable(true)]
         //[ReadOnly(false)]
@@ -358,18 +344,6 @@ namespace CoreUnit.Scanner.UserControl.ScannerCanvas
             get { return m_rampingEndPower2; }
             set { m_rampingEndPower2 = value; }
         }
-        uint m_rampingEndPower3;
-        [Browsable(true)]
-        [ReadOnly(false)]
-        [Category("Ramping")]
-        [DisplayName("End Power(%)")]
-        [Description("End Power(Max:100, Min:0, Unit: %)")]
-        [XmlSerializable]
-        public uint RampingEndPower3
-        {
-            get { return m_rampingEndPower3; }
-            set { m_rampingEndPower3 = value; }
-        }
 
         //bool m_rampingEndSlopeMode;
         //[Browsable(true)]
@@ -1568,11 +1542,9 @@ namespace CoreUnit.Scanner.UserControl.ScannerCanvas
             m_rampingStartDist = 0;
             m_rampingStartPower1 = 0;
             m_rampingStartPower2 = 0;
-            m_rampingStartPower3 = 0;
 
             m_rampingEndPower1 = 0;
             m_rampingEndPower2 = 0;
-            m_rampingEndPower3 = 0;
             m_rampingEndDist = 0;
             m_RampingInterval = 0;
             //m_rampingStartSlopeMode = false;
@@ -1633,11 +1605,9 @@ namespace CoreUnit.Scanner.UserControl.ScannerCanvas
 
             param.m_rampingStartPower1 = this.m_rampingStartPower1;
             param.m_rampingStartPower2 = this.m_rampingStartPower2;
-            param.m_rampingStartPower3 = this.m_rampingStartPower3;
             param.m_rampingStartDist = this.m_rampingStartDist;
             param.m_rampingEndPower1 = this.m_rampingEndPower1;
             param.m_rampingEndPower2 = this.m_rampingEndPower2;
-            param.m_rampingEndPower3 = this.m_rampingEndPower3;
             param.m_rampingEndDist = this.m_rampingEndDist;
             //param.m_rampingStartSlopeMode = this.m_rampingStartSlopeMode;
             //param.m_rampingEndSlopeMode = this.m_rampingEndSlopeMode;

WeldingComponents/WeldingCommon/Data/ActualProcessData.cs

@@ -41,7 +41,8 @@ namespace WeldingCommon.Data
             table.Columns.Add(nameof(ActualProcessUnit.JumpDelay), typeof(double));
             table.Columns.Add(nameof(ActualProcessUnit.MarkDelay), typeof(double));
             table.Columns.Add(nameof(ActualProcessUnit.PolygonDelay), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.Power), typeof(double));
+            table.Columns.Add(nameof(ActualProcessUnit.PowerCore), typeof(double));
+            table.Columns.Add(nameof(ActualProcessUnit.PowerRing), typeof(double));
             table.Columns.Add(nameof(ActualProcessUnit.JumpSpeed), typeof(double));
             table.Columns.Add(nameof(ActualProcessUnit.MarkSpeed), typeof(double));
             table.Columns.Add(nameof(ActualProcessUnit.JumpX), typeof(double));
@@ -65,7 +66,7 @@ namespace WeldingCommon.Data
             table.Rows.Add(item.Date.ToString("yyyy-MM-dd"), item.Date.ToString("HH:mm:ss.fff"), item.LotID, item.CellID, item.HeadNo, item.WeldType, item.EncoderCheck,
                            item.StartPointX, item.StartPointY, item.EndPointX, item.EndPointY,
                            item.WeldCondition, item.LaserOnDelay, item.LaserOffDelay, item.JumpDelay, item.MarkDelay,
-                           item.PolygonDelay, item.Power, item.JumpSpeed, item.MarkSpeed, item.JumpX,
+                           item.PolygonDelay, item.PowerCore, item.PowerRing, item.JumpSpeed, item.MarkSpeed, item.JumpX,
                            item.JumpY);
         }
 
@@ -110,8 +111,10 @@ namespace WeldingCommon.Data
         private double _MarkDelay;
         public double PolygonDelay { get => _PolygonDelay; set => SetProperty(ref _PolygonDelay, value); }
         private double _PolygonDelay;
-        public double Power { get => _Power; set => SetProperty(ref _Power, value); }
+        public double PowerCore { get => _PowerCore; set => SetProperty(ref _PowerCore, value); }
-        private double _Power;
+        private double _PowerCore;
+        public double PowerRing { get => _PowerRing; set => SetProperty(ref _PowerRing, value); }
+        private double _PowerRing;
         public double JumpSpeed { get => _JumpSpeed; set => SetProperty(ref _JumpSpeed, value); }
         private double _JumpSpeed;
         public double MarkSpeed { get => _MarkSpeed; set => SetProperty(ref _MarkSpeed, value); }

WeldingComponents/WeldingCommon/Data/WeldingData.cs

@@ -12,7 +12,7 @@ using System.Threading.Tasks;
 
 namespace WeldingCommon.Data
 {
-    public class WeldingData : NotifyPropertyChangedBase
+    public class WeldingData : NotifyPropertyChangedBase, ICloneable
     {
         protected readonly Logger Log = new Logger("WeldingData");
 
@@ -103,11 +103,63 @@ namespace WeldingCommon.Data
 
         public WeldingData()
         {
+            Clear();
         }
 
         public void Clear()
         {
+            this.CellId = string.Empty;
+            this.LotId = string.Empty;
+            this.AutoRunStartTime = DateTime.MinValue;
+            this.WeldingStartTime = DateTime.MinValue;
+            this.WeldingEndTime = DateTime.MinValue;
+            this.WeldingSpanTimeMilliseconds = string.Empty;
+            this.TodayProduct = 0;
+            this.TotalProduct = 0;
+            this.RecipeNo = 0;
+            this.WeldStartTime = string.Empty;
+            this.WeldTime = string.Empty;
+            this.WorkCellId = string.Empty;
+            this.WorkLotId = string.Empty;
+            this.LBAD_Judge = string.Empty;
+            this.LDD_Judge = string.Empty;
+            this.LaserPowerCore = string.Empty;
+            this.LaserPowerRing = string.Empty;
+            this.MarkSpeed = string.Empty;
+            this.FocalLength = string.Empty;
+            this.WeldingJigNo = string.Empty;
+            this.LaserPowerByLBAD = string.Empty;
+            this.CheckCanExist = false;
+            this.CheckScannerListEnd = false;
+        }
 
+        public object Clone()
+        {
+            var clone = new WeldingData();
+            clone._CellId = _CellId;
+            clone._LotId = _LotId;
+            clone._AutoRunStartTime = _AutoRunStartTime;
+            clone._WeldingStartTime = _WeldingStartTime;
+            clone._WeldingEndTime = _WeldingEndTime;
+            clone._WeldingSpanTimeMilliseconds = _WeldingSpanTimeMilliseconds;
+            clone._TodayProduct = _TodayProduct;
+            clone._TotalProduct = _TotalProduct;
+            clone._RecipeNo = _RecipeNo;
+            clone._WeldStartTime = _WeldStartTime;
+            clone._WeldTime = _WeldTime;
+            clone._WorkCellId = _WorkCellId;
+            clone._WorkLotId = _WorkLotId;
+            clone._LBAD_Judge = _LBAD_Judge;
+            clone._LDD_Judge = _LDD_Judge;
+            clone._LaserPowerCore = _LaserPowerCore;
+            clone._LaserPowerRing = _LaserPowerRing;
+            clone._MarkSpeed = _MarkSpeed;
+            clone._FocalLength = _FocalLength;
+            clone._WeldingJigNo = _WeldingJigNo;
+            clone._LaserPowerByLBAD = _LaserPowerByLBAD;
+            clone._CheckCanExist = _CheckCanExist;
+            clone._CheckScannerListEnd = _CheckScannerListEnd;
+            return clone;
         }
     }
 }

WeldingComponents/WeldingCommon/Sequences/Main/SeqUploadWeldingList.cs

@@ -294,6 +294,7 @@ namespace WeldingCommon.Sequences {
             foreach (IDrawObject obj in objects) {
                 drawObjectCount += FuncLoadDrawObjectScannerParamSelected(obj);
             }
+            Debug.WriteLine($"Scanner Space Check({_Scanner.GetListSpace()})");
 
             return drawObjectCount;
         }
@@ -307,7 +308,6 @@ namespace WeldingCommon.Sequences {
                     count += FuncLoadDrawObjectScannerParamSelected(subObj);
                 }
             }
-
             return count;
         }
 
@@ -405,7 +405,7 @@ namespace WeldingCommon.Sequences {
             float percentLaser1 = 0.0f;
             float percentLaser2 = 0.0f;
             SetScannerProcessCondition(param, out percentLaser1, out percentLaser2);
-            Log.I(string.Format($"[Line Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[Line Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             //CSV Laser Log 추가
             laserLog.Date = DateTime.Now;
@@ -416,7 +416,8 @@ namespace WeldingCommon.Sequences {
             laserLog.JumpDelay = param.JumpDelay;
             laserLog.MarkDelay = param.MarkDelay;
             laserLog.PolygonDelay = param.PolygonDelay;
-            laserLog.Power = param.LaserPower1;
+            laserLog.PowerCore = param.LaserPower1;
+            laserLog.PowerRing = param.LaserPower2;
             laserLog.JumpSpeed = param.JumpSpeed;
             laserLog.MarkSpeed = param.MarkSpeed;
 
@@ -634,22 +635,23 @@ namespace WeldingCommon.Sequences {
                 int risingCount = (int)(StartDistance / length);
                 int fallingCount = (int)(EndDistance / length);
                 int totalCount = (int)(obj.Distance / length);
+                Log.I($"Ramping count >> firstCount({firstCount}) / risingCount({risingCount}) / fallingCount({fallingCount}) / totalCount({totalCount})");
 
                 // Power1    A -> Start Power, B -> End Power
                 float firstPower_A1 = percentLaser1 * (float)param.RampingStartAPower1 / 100;   // Ramping First Power 1
                 float firstPower_B1 = percentLaser1 * (float)param.RampingStartAPower2 / 100;   // Ramping First Power 2
                 float startPower_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100;    // Ramping Start Power 1
-                float startPower_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100;    // Ramping Start Power 3
+                float startPower_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100;    // Ramping Start Power 3
                 float endPower_A1 = percentLaser1 * (float)param.RampingEndPower1 / 100;        // Ramping End Power 1
-                float endPower_B1 = percentLaser1 * (float)param.RampingEndPower3 / 100;        // Ramping End Power 3
+                float endPower_B1 = percentLaser1 * (float)param.RampingEndPower2 / 100;        // Ramping End Power 3
 
                 // Power2    A -> Start Power, B -> End Power
                 float firstPower_A2 = percentLaser2 * (float)param.RampingStartAPower1 / 100;   // Ramping First Power 1
                 float firstPower_B2 = percentLaser2 * (float)param.RampingStartAPower2 / 100;   // Ramping First Power 2
                 float startPower_A2 = percentLaser2 * (float)param.RampingStartPower1 / 100;    // Ramping Start Power 1
-                float startPower_B2 = percentLaser2 * (float)param.RampingStartPower3 / 100;    // Ramping Start Power 3
+                float startPower_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100;    // Ramping Start Power 3
                 float endPower_A2 = percentLaser2 * (float)param.RampingEndPower1 / 100;        // Ramping End Power 1
-                float endPower_B2 = percentLaser2 * (float)param.RampingEndPower3 / 100;        // Ramping End Power 3
+                float endPower_B2 = percentLaser2 * (float)param.RampingEndPower2 / 100;        // Ramping End Power 3
 
                 double dx = (obj.P2.X - obj.P1.X) / obj.Distance * length;
                 double dy = (obj.P2.Y - obj.P1.Y) / obj.Distance * length;
@@ -659,36 +661,49 @@ namespace WeldingCommon.Sequences {
 
                 Log.I($"[Line Weld] Ramping Condition No({obj.No + 1}), Line Length : {obj.Distance}" +
                     $"(Start_A:{param.RampingStartADist}%, Dist {FirstDistance}mm {(float)param.RampingStartAPower1}% -> {(float)param.RampingStartAPower2}%) " +
-                    $"(Start_B:{param.RampingStartDist}%, Dist {StartDistance}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower3}%) " +
+                    $"(Start_B:{param.RampingStartDist}%, Dist {StartDistance}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
-                    $"(End:{param.RampingEndDist}%, Dist {EndDistance}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
+                    $"(End:{param.RampingEndDist}%, Dist {EndDistance}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower2}%)");
 
 
                 for (int iter = 0; iter < totalCount + 1; iter++) {
                     float power1 = percentLaser1;
                     float power2 = percentLaser2;
 
-                    // first Ramping은 Start 지점의 연속으로 Start Ramping과 이어서 한다.
                     if (iter <= (risingCount + firstCount)) {
-                        // power1은 startPower_A1 에서 startPower_B1 까지 변한다
-                        // float IntervalPerPower = (B - A) / Cnt
-                        // power1 = PowerA + (iter * IntervalPerPower);
                         if (iter <= firstCount) {
-                            if (iter == 0) {
+                            if (iter == 0 || firstCount == 0) {
                                 power1 = firstPower_A1;
                                 power2 = firstPower_A2;
                             } else {
                                 power1 = firstPower_A1 + (firstPower_B1 - firstPower_A1) * (iter / (float)firstCount);
                                 power2 = firstPower_A2 + (firstPower_B2 - firstPower_A2) * (iter / (float)firstCount);
                             }
-                        } else if ((iter - firstCount) <= risingCount) {
+                        }
+                        else if ((iter - firstCount) <= risingCount) {
+                            if (risingCount == 0) {
+                                power1 = startPower_B1;
+                                power2 = startPower_B2;
+                            }
+                            else {
                                 power1 = startPower_A1 + (startPower_B1 - startPower_A1) * ((iter - firstCount) / (float)risingCount);
                                 power2 = startPower_A2 + (startPower_B2 - startPower_A2) * ((iter - firstCount) / (float)risingCount);
                             }
-                    } else if (iter >= totalCount - fallingCount) {
+                        }
-                        // power1은 endPower_A1 에서 endPower_B1 까지 변한다
+                    }
+                    else if (iter >= totalCount - fallingCount) {
+                        if (fallingCount == 0) {
+                            power1 = endPower_A1;
+                            power2 = endPower_A2;
+                        }
+                        else {
                             power1 = endPower_B1 + (endPower_A1 - endPower_B1) * (totalCount - iter) / (float)fallingCount;
                             power2 = endPower_B2 + (endPower_A2 - endPower_B2) * (totalCount - iter) / (float)fallingCount;
                         }
+                    }
+                    else {
+                        power1 = startPower_B1;
+                        power2 = startPower_B2;
+                    }
 
                     _Scanner.WriteDA((uint)eAnalogPortOut.DA1, power1, eFunctionType.LIST);
                     _Scanner.WriteDA((uint)eAnalogPortOut.DA2, power2, eFunctionType.LIST);
@@ -742,7 +757,7 @@ namespace WeldingCommon.Sequences {
             float percentLaser2 = 0.0f;
             SetScannerProcessCondition(param, out percentLaser1, out percentLaser2);
 
-            Log.I(string.Format($"[Point Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[Point Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             // 2. 스캐너 가공 작업
             // 2.1. Jump(Point Shot)
@@ -791,7 +806,7 @@ namespace WeldingCommon.Sequences {
             // Spline 의 경우 Wobbel 해제
             _Scanner.SetWobbelMode(false, 0, 0, 0, 0);
 
-            Log.I(string.Format($"[Spline Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[Spline Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             // 1. Ramping을 위한 변수 설정
             // totalCount를 전체 Count에서 Mark가 시작하는 구간으로 2를 빼준다.. 아래수식에서 헷갈리지 않기 위해서..
@@ -839,8 +854,8 @@ namespace WeldingCommon.Sequences {
                 float startingPercentLaser_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                 percentLaser1 * (float)param.RampingStartPower1 / 100 : 100;
 
-                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100 <= 100 ?
+                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
-                                               percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                                               percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                 float risingEdgePercentLaser1 = 0;
                 float startingPercentLaser2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
@@ -851,8 +866,8 @@ namespace WeldingCommon.Sequences {
                 //                            percentLaser1 * (float)param.RampingEndPower1 / 100 : 100;
                 float endingPercentLaser_A1 = percentLaser1 * (float)param.RampingEndPower1 / 100 <= 100 ?
                                            percentLaser1 * (float)param.RampingEndPower1 / 100 : 100;
-                float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower3 / 100 <= 100 ?
+                float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower2 / 100 <= 100 ?
-                                            percentLaser1 * (float)param.RampingEndPower3 / 100 : 100;
+                                            percentLaser1 * (float)param.RampingEndPower2 / 100 : 100;
 
                 float fallingEdgePercentLaser1 = 0;
                 float endingPercentLaser2 = percentLaser2 * (float)param.RampingEndPower2 / 100 <= 100 ?
@@ -1360,7 +1375,7 @@ namespace WeldingCommon.Sequences {
             float percentLaser2 = 0;
             SetScannerProcessCondition(param, out percentLaser1, out percentLaser2);
 
-            Log.I(string.Format($"[SnowMan Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[SnowMan Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             // 2. 스캐너 가공 작업
             // SnowMan 로드 시작
@@ -1417,7 +1432,7 @@ namespace WeldingCommon.Sequences {
             float percentLaser2 = 0;
             SetScannerProcessCondition(param, out percentLaser1, out percentLaser2);
 
-            Log.I(string.Format($"[Arc Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[Arc Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             //CSV Laser Log 추가
             laserLog.Date = DateTime.Now;
@@ -1428,7 +1443,8 @@ namespace WeldingCommon.Sequences {
             laserLog.JumpDelay = param.JumpDelay;
             laserLog.MarkDelay = param.MarkDelay;
             laserLog.PolygonDelay = param.PolygonDelay;
-            laserLog.Power = param.LaserPower1;
+            laserLog.PowerCore = param.LaserPower1;
+            laserLog.PowerRing = param.LaserPower2;
             laserLog.JumpSpeed = param.JumpSpeed;
             laserLog.MarkSpeed = param.MarkSpeed;
 
@@ -1570,13 +1586,13 @@ namespace WeldingCommon.Sequences {
 
                 float startingPercentLaser_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                 percentLaser1 * (float)param.RampingStartPower1 / 100 : 100;
-                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100 <= 100 ?
+                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
-                                                percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                                                percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                 float startingPercentLaser_A2 = percentLaser2 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                 percentLaser2 * (float)param.RampingStartPower1 / 100 : 100;
-                float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower3 / 100 <= 100 ?
+                float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
-                                                percentLaser2 * (float)param.RampingStartPower3 / 100 : 100;
+                                                percentLaser2 * (float)param.RampingStartPower2 / 100 : 100;
 
 
                 float risingEdgePercentLaser1 = 0;
@@ -1585,8 +1601,8 @@ namespace WeldingCommon.Sequences {
 
                 Log.I($"[Arc Weld] Ramping Condition No({obj.No + 1}), Arc Length : {obj.Length}, Arc Angle : {obj.SweepAngle} " +
                  $"(Start_A:{param.RampingStartADist}%, Dist {FirstAngle}mm {(float)param.RampingStartAPower1}% -> {(float)param.RampingStartAPower2}%) " +
-                 $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower3}%) " +
+                 $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
-                 $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
+                 $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower2}%)");
 
 
                 // 2.2.2.2. Rising Edge 구간 파워 및 위치 변경
@@ -1617,16 +1633,16 @@ namespace WeldingCommon.Sequences {
                 // 2.2.4.1. Falling Edge 마지막 파워 설정
                 float endingPercentLaser_A1 = percentLaser1 * (float)param.RampingEndPower1 / 100 <= 100 ?
                                               percentLaser1 * (float)param.RampingEndPower1 / 100 : 100;
-                float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower3 / 100 <= 100 ?
+                float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower2 / 100 <= 100 ?
-                                              percentLaser1 * (float)param.RampingEndPower3 / 100 : 100;
+                                              percentLaser1 * (float)param.RampingEndPower2 / 100 : 100;
 
                 float fallingEdgePercentLaser1 = 0;
 
 
                 float endingPercentLaser_A2 = percentLaser2 * (float)param.RampingEndPower1 / 100 <= 100 ?
                                               percentLaser2 * (float)param.RampingEndPower1 / 100 : 100;
-                float endingPercentLaser_B2 = percentLaser2 * (float)param.RampingEndPower3 / 100 <= 100 ?
+                float endingPercentLaser_B2 = percentLaser2 * (float)param.RampingEndPower2 / 100 <= 100 ?
-                                              percentLaser2 * (float)param.RampingEndPower3 / 100 : 100;
+                                              percentLaser2 * (float)param.RampingEndPower2 / 100 : 100;
 
                 float fallingEdgePercentLaser2 = 0;
 
@@ -1686,7 +1702,7 @@ namespace WeldingCommon.Sequences {
             float percentLaser2 = 0;
             SetScannerProcessCondition(param, out percentLaser1, out percentLaser2);
 
-            Log.I(string.Format($"[Arc3P Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[Arc3P Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             //CSV Laser Log 추가
             laserLog.Date = DateTime.Now;
@@ -1697,7 +1713,8 @@ namespace WeldingCommon.Sequences {
             laserLog.JumpDelay = param.JumpDelay;
             laserLog.MarkDelay = param.MarkDelay;
             laserLog.PolygonDelay = param.PolygonDelay;
-            laserLog.Power = param.LaserPower1;
+            laserLog.PowerCore = param.LaserPower1;
+            laserLog.PowerRing = param.LaserPower2;
             laserLog.JumpSpeed = param.JumpSpeed;
             laserLog.MarkSpeed = param.MarkSpeed;
 
@@ -1844,13 +1861,13 @@ namespace WeldingCommon.Sequences {
 
                     float startingPercentLaser_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                     percentLaser1 * (float)param.RampingStartPower1 / 100 : 100;
-                    float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100 <= 100 ?
+                    float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
-                                                    percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                                                    percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                     float startingPercentLaser_A2 = percentLaser2 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                     percentLaser2 * (float)param.RampingStartPower1 / 100 : 100;
-                    float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower3 / 100 <= 100 ?
+                    float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
-                                                    percentLaser2 * (float)param.RampingStartPower3 / 100 : 100;
+                                                    percentLaser2 * (float)param.RampingStartPower2 / 100 : 100;
 
 
                     float risingEdgePercentLaser1 = 0;
@@ -1858,8 +1875,8 @@ namespace WeldingCommon.Sequences {
 
                     Log.I($"[Arc3P Weld] Ramping Condition No({obj.No + 1}), Arc Angle : {obj.SweepAngle} " +
                             $"(Start_A:{param.RampingStartADist}%, Dist {FirstAngle}mm {(float)param.RampingStartAPower1}% -> {(float)param.RampingStartAPower2}%) " +
-                            $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower3}%) " +
+                            $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
-                            $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
+                            $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower2}%)");
 
 
                     // 2.2.2.2. Rising Edge 구간 파워 및 위치 변경
@@ -1889,15 +1906,15 @@ namespace WeldingCommon.Sequences {
                     // 2.2.4.1. Falling Edge 마지막 파워 설정
                     float endingPercentLaser_A1 = percentLaser1 * (float)param.RampingEndPower1 / 100 <= 100 ?
                                                   percentLaser1 * (float)param.RampingEndPower1 / 100 : 100;
-                    float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower3 / 100 <= 100 ?
+                    float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower2 / 100 <= 100 ?
-                                                  percentLaser1 * (float)param.RampingEndPower3 / 100 : 100;
+                                                  percentLaser1 * (float)param.RampingEndPower2 / 100 : 100;
 
                     float fallingEdgePercentLaser1 = 0;
 
                     float endingPercentLaser_A2 = percentLaser2 * (float)param.RampingEndPower1 / 100 <= 100 ?
                                                   percentLaser2 * (float)param.RampingEndPower1 / 100 : 100;
-                    float endingPercentLaser_B2 = percentLaser2 * (float)param.RampingEndPower3 / 100 <= 100 ?
+                    float endingPercentLaser_B2 = percentLaser2 * (float)param.RampingEndPower2 / 100 <= 100 ?
-                                                  percentLaser2 * (float)param.RampingEndPower3 / 100 : 100;
+                                                  percentLaser2 * (float)param.RampingEndPower2 / 100 : 100;
 
                     float fallingEdgePercentLaser2 = 0;
 
@@ -1955,7 +1972,7 @@ namespace WeldingCommon.Sequences {
             float percentLaser2 = 0;
             SetScannerProcessCondition(param, out percentLaser1, out percentLaser2);
 
-            Log.I(string.Format($"[Zigzag Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},Power:{param.LaserPower1},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
+            Log.I(string.Format($"[Zigzag Weld] Weld Condition(No:{param.No + 1}) Setting(LaserOnDelay:{param.LaserOnDelay},LaserOffDelay:{param.LaserOffDelay},JumpDelay:{param.JumpDelay},MarkDelay:{param.MarkDelay},PolygonDelay:{param.PolygonDelay},CorePower:{param.LaserPower1},RingPower:{param.LaserPower2},JumpSpeed:{param.JumpSpeed},MarkSpeed:{param.MarkSpeed})"));
 
             // 1. 시작 위치로 점프
             if (Math.Abs(_LastX - obj.PF1.X - xOffset) < 0.01 && Math.Abs(_LastY - obj.PF1.Y - yOffset) < 0.01) {
@@ -2105,7 +2122,7 @@ namespace WeldingCommon.Sequences {
 
                     // A -> Start Power,    B -> End Power
                     float startingPercentLaser_A1 = Math.Min(percentLaser1 * (float)param.RampingStartPower1 / 100, 100);
-                    float startingPercentLaser_B1 = Math.Min(percentLaser1 * (float)param.RampingStartPower3 / 100, 100);
+                    float startingPercentLaser_B1 = Math.Min(percentLaser1 * (float)param.RampingStartPower2 / 100, 100);
 
                     // 2170은 Power를 사용하지 않는다.
                     float startingPercentLaser2 = 0;        // Math.Min(percentLaser2 * (float)param.RampingStartPower2 / 100, 100);
@@ -2247,7 +2264,7 @@ namespace WeldingCommon.Sequences {
                     int endRampStep = 0;
                     // A -> Start Power,    B -> End Power
                     float endingPercentLaser_A1 = Math.Min(percentLaser1 * (float)param.RampingEndPower1 / 100, 100);
-                    float endingPercentLaser_B1 = Math.Min(percentLaser1 * (float)param.RampingEndPower3 / 100, 100);
+                    float endingPercentLaser_B1 = Math.Min(percentLaser1 * (float)param.RampingEndPower2 / 100, 100);
 
                     // 2170은 Power를 사용하지 않는다.
                     float endingPercentLaser2 = 0;      // Math.Min(percentLaser2 * (float)param.RampingEndPower2 / 100, 100);

WeldingComponents/WeldingCommon/Settings/SystemParameter.cs

@@ -479,6 +479,12 @@ namespace WeldingCommon.Settings
         [DisplayName("CellCenterOffsetY")]
         public double CellPosMeasureCenterOffsetY { get; set; } = 0;
 
+        // 260227 Laser 개조 후 파라미터 추가
+        [Browsable(true)]
+        [ReadOnly(false)]
+        [Category("RMS")]
+        [DisplayName("Use RingPower RMS")]
+        public bool UseRingPowerRMS { get; set; } = false;
     }
     public class ILSOSSizeF
     {

WeldingComponents/WeldingCommon/Utils/ChangeChecker.cs

@@ -41,5 +41,39 @@ namespace WeldingCommon.Utils
 
             return false;
         }
+
+        private static Dictionary<string, int> mappingInt = new Dictionary<string, int>();
+        public static bool IsChangedInt(string Resource, int value, int defaultVal = 0)
+        {
+            if (mappingInt.ContainsKey(Resource) == false) {
+                mappingInt[Resource] = defaultVal;
+                return false;
+            }
+
+            if (mappingInt[Resource] == value) {
+                return false;
+            }
+
+            mappingInt[Resource] = value;
+            return true;
+        }
+
+        public static bool IsChangedInt(string Resource, int value, out int prevalue, int defaultVal = 0)
+        {
+            if (mappingInt.ContainsKey(Resource) == false) {
+                mappingInt[Resource] = defaultVal;
+                prevalue = mappingInt[Resource];
+                return false;
+            }
+
+            if (mappingInt[Resource] == value) {
+                prevalue = value;
+                return false;
+            }
+
+            prevalue = mappingInt[Resource];
+            mappingInt[Resource] = value;
+            return true;
+        }
     }
 }

WeldingComponents/WeldingCommon/Views/Recipes/UCScannerObjectTeachingControlBoxViewModel.cs

@@ -354,6 +354,10 @@ namespace WeldingCommon.Views
 
         private void PerformCmdRunTeachingRun(object obj)
         {
+            var autorun = _Aurora.SequenceEntry["SeqAutoRunCCWH52A"];
+            autorun.Start();
+            return;
+
             var result = MessageUtil.ShowYesNoMessageDialog("Teaching Run", "Start TeachingRun Sequence?");
             if (result == false) {
                 return;