문서 업데이트

- PLC Start Address, W0800
- word Address 중간에 추가하기 쉽도록 주소변수를 직렬화함
- Weld Ring Power 추가

.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}");
-                    //byte[] data_byte = BitConverter.GetBytes(data);
+                    Log.I($"Received 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);
-                        unsafe
-                        {
-                            char[] LotID = new char[40];
-                            char[] CellID = new char[40];
-                            for (int i=0; i<40; i++)
-                            {
-                                LotID[i] = (char)bytes[i];
-                            }
-                            for (int i=40; i<80; i++)
-                            {
-                                CellID[i-40] = (char)bytes[i];
-
-                            }
-                            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}");
-                            }
+                        string LotID_string = Encoding.ASCII.GetString(bytes, 0, 40).TrimEnd('\0');
+                        string CellID_string = Encoding.ASCII.GetString(bytes, 40, 40).TrimEnd('\0');
+                        short HeadNum = BitConverter.ToInt16(bytes, 80);
+                        double AVG = BitConverter.ToDouble(bytes, 82);
+                        Log.I($"StreamLight LBAD Report Data (from LBAD to Welder) : LotID {LotID_string}, CellID {CellID_string}");
+                        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}");
+                        if (HeadNum > 0) {
+                            LaserPowerByLBAD[HeadNum] = AVG;
+                            MesReportReceived?.Invoke(LotID_string, CellID_string, HeadNum, AVG);
+                        } else {
+                            Log.E($"Head Number is {HeadNum}");
                         }
                     }
                     break;

AuroraDevices/AuroraLaserScanner/Scanner.cs

@@ -37,9 +37,7 @@ namespace AuroraLaserScanner
             Config = config as ScannerConfig;
             if (IsSimul) {
                 _scannerObj = new ScannerSimul();
-                //return E1.OK;
-            }
-            else if (Config.Type == eRTCType.RTC5) {
+            } else if (Config.Type == eRTCType.RTC5) {
                 _scannerObj = new ScannerRTC5();
             } else if (Config.Type == eRTCType.RTC6) {
                 _scannerObj = new ScannerRTC6();
@@ -577,6 +575,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;
-
-            long t0 = sw.ElapsedMilliseconds;
-
-            while (true) {
-                // 블로킹 대기 중에도 PLC에서 최신값을 직접 당겨온다
-                PullEncoderFromPlcOnce();
-
-                // GetEncoder는 _simEncYCount를 deg로 바꿔줄 것
-                GetEncoder(out _, out double curY, true);
-
-                // 정상 진입
-                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);
+            // 실제 RTC 펌웨어와 동일하게: PC 스레드를 블로킹하지 않고 리스트 명령으로 조건 저장.
+            // EquipmentSimulator → UpdateListExecution 에서 PLCGetAbsDeg()가 [minY, maxY] 구간
+            // 진입을 확인한 후 마킹 타이머를 시작하므로, 그 전까지 리스트는 busy 상태를 유지.
+            // LoadList 폴링(CheckLoadComplete)이 busy 해소를 기다리는 방식으로 타이밍 동기화.
+            if (_recordingList == eListNo.LIST1) {
+                _list1HasEncoderWait = true;
+                _list1EncoderMinY = minY;
+                _list1EncoderMaxY = maxY;
+            } else if (_recordingList == eListNo.LIST2) {
+                _list2HasEncoderWait = true;
+                _list2EncoderMinY = minY;
+                _list2EncoderMaxY = maxY;
             }
         }
         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;
+        }
     }
 }

External/Aurora/bin/hislogger.config

@@ -5,7 +5,7 @@
    "collector_mode": "MANUAL",
    "console_out": false,
    "file_out": true,
-   "log_save_dir": "_log",
+   "log_save_dir": "D:\\ILSOSConfig\\_log",
    "log_save_level": 0,
    "log_file_prefix": "Aurora",
    "log_file_size": 5,
@@ -20,7 +20,7 @@
    "collector_mode": "MANUAL",
    "console_out": false,
    "file_out": true,
-   "log_save_dir": "_process",
+   "log_save_dir": "D:\\ILSOSConfig\\_process",
    "log_save_level": 0,
    "log_file_prefix": "process",
    "log_file_size": 5,
@@ -35,7 +35,7 @@
    "collector_mode": "MANUAL",
    "console_out": false,
    "file_out": true,
-   "log_save_dir": "_vision",
+   "log_save_dir": "D:\\ILSOSConfig\\_vision",
    "log_save_level": 0,
    "log_file_prefix": "vision",
    "log_file_size": 5,

Machines/ILSOS_ACW_H52A/RMS/EDC.cs

@@ -35,7 +35,7 @@ namespace ILSOS_ACW_H52A.RMS
             string strLaserCenterPower = Status.GetProcessingWeldingData().LaserPowerCore;
             string strMarkSpeed = Status.GetProcessingWeldingData().MarkSpeed;
             string strFocalLength = Status.GetProcessingWeldingData().FocalLength;
-            string strJigNo = Status.GetProcessingWeldingData().WeldingJigNo;
+            string strJigNo = Status.GetProcessingWeldingData().JigNo;
 
             string strLaserPowerByLBAD = Status.GetProcessingWeldingData().LaserPowerByLBAD;
 

Machines/ILSOS_ACW_H52A/Recipes/RecipeEventHelper.cs

@@ -87,10 +87,10 @@ namespace ILSOS_ACW_H52A.Recipes {
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam_1.RampingStartAPower2 * (plc as PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_RAMPING_END_DISTANCE.ToString())));
             #endregion
             #region PLC Upload Parameter 2
@@ -104,10 +104,10 @@ namespace ILSOS_ACW_H52A.Recipes {
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam_2.RampingStartAPower2 * (plc as PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_RAMPING_END_DISTANCE.ToString())));
             #endregion
             #region PLC Upload Parameter 3
@@ -121,10 +121,10 @@ namespace ILSOS_ACW_H52A.Recipes {
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_RAMPING_START_A_POWER_2, (int)(_LineParam_3.RampingStartAPower2 * (plc as PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).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 PLCControllerACWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_RAMPING_END_DISTANCE.ToString())));
             #endregion
 
@@ -199,10 +199,10 @@ namespace ILSOS_ACW_H52A.Recipes {
             _LineParam_1.RampingStartAPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_2);
             _LineParam_1.RampingStartADist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE);
             _LineParam_1.RampingStartPower1 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_1);
-            _LineParam_1.RampingStartPower3 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2);
+            _LineParam_1.RampingStartPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2);
             _LineParam_1.RampingStartDist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE);
             _LineParam_1.RampingEndPower1 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_POWER_1);
-            _LineParam_1.RampingEndPower3 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_POWER_2);
+            _LineParam_1.RampingEndPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_POWER_2);
             _LineParam_1.RampingEndDist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_RAMPING_END_DISTANCE);
             #endregion
             #region Scanner Upload Parameter 2
@@ -216,10 +216,10 @@ namespace ILSOS_ACW_H52A.Recipes {
             _LineParam_2.RampingStartAPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_2);
             _LineParam_2.RampingStartADist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE);
             _LineParam_2.RampingStartPower1 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_1);
-            _LineParam_2.RampingStartPower3 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2);
+            _LineParam_2.RampingStartPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2);
             _LineParam_2.RampingStartDist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE);
             _LineParam_2.RampingEndPower1 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_POWER_1);
-            _LineParam_2.RampingEndPower3 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_POWER_2);
+            _LineParam_2.RampingEndPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_POWER_2);
             _LineParam_2.RampingEndDist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_RAMPING_END_DISTANCE);
             #endregion
             #region Scanner Upload Parameter 3
@@ -233,10 +233,10 @@ namespace ILSOS_ACW_H52A.Recipes {
             _LineParam_3.RampingStartAPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_2);
             _LineParam_3.RampingStartADist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE);
             _LineParam_3.RampingStartPower1 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_1);
-            _LineParam_3.RampingStartPower3 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2);
+            _LineParam_3.RampingStartPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2);
             _LineParam_3.RampingStartDist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE);
             _LineParam_3.RampingEndPower1 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_POWER_1);
-            _LineParam_3.RampingEndPower3 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_POWER_2);
+            _LineParam_3.RampingEndPower2 = (uint)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_POWER_2);
             _LineParam_3.RampingEndDist = (double)(plc as PLCControllerACWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_RAMPING_END_DISTANCE);
             #endregion
 

Machines/ILSOS_ACW_H52A/Sequences/SeqAutoRunACWH52A.cs

@@ -871,7 +871,7 @@ namespace ILSOS_ACW_H52A.Sequences
                 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();
+                Status.GetProcessingWeldingData().JigNo = _WeldingJigNo.ToString();
             }
         }
 
@@ -1131,7 +1131,7 @@ namespace ILSOS_ACW_H52A.Sequences
             Status.GetProcessingWeldingData().RecipeNo = _RecipeNo;
             Status.GetProcessingWeldingData().LaserPowerByLBAD = _LaserPowerByLBAD.ToString();
 
-            Status.GetProcessingWeldingData().WeldingJigNo = _CompletedJigNo.ToString();
+            Status.GetProcessingWeldingData().JigNo = _CompletedJigNo.ToString();
 
         }
         private SequenceActionResult SetReportCellResult_SeqParams(SequenceContext context, string id, SequenceActionResult param)

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.JigNo = data.JigNo;
+            InnerCellInfo.LaserPowerByLBAD = data.LaserPowerByLBAD;
+            InnerCellInfo.CheckCanExist = data.CheckCanExist;
+            InnerCellInfo.CheckScannerListEnd = data.CheckScannerListEnd;
+        }
+    }
+}

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

@@ -176,8 +176,6 @@ namespace ILSOS_CCW_H52A.Device
             PC_WELD_COMPLETE_14,                //지그 14번 용접완료 여부
             PC_WELD_COMPLETE_15,                //지그 15번 용접완료 여부
             PC_WELD_COMPLETE_16                //지그 16번 용접완료 여부
-
-
         }
 
         public enum eWordInput : int
@@ -189,91 +187,160 @@ namespace ILSOS_CCW_H52A.Device
             PLC_CURRENT_POS_1,                 // 현재 Rotary 절대엔코더값 1
             PLC_CURRENT_POS_2,                 // 현재 Rotary 절대엔코더값 2
             PLC_NUM_OF_REVOLUTIONS,            // 현재 Rotary 회전수
-                                               //PLC_SCANNER_Z_AXIS_1 = 0x08,       // 현재 Scanner Z축 위치 1
-                                               //PLC_SCANNER_Z_AXIS_2,              // 현재 Scanner Z축 위치 2
-
-            //// WON : 2170 RMS 대비 enum 추가 추후 해당 주소 영역 확인 후 주소 매핑 필요
-            //PLC_WELDING_RECIPE_NO = 48,               // 설정할 PLC Recipe 번호
-            //PLC_WELDING_LASER_POWER = 50,
-            //PLC_WELDING_DRAW_SPEED = 52,
-            //PLC_WELDING_JUMP_SPEED = 54,
-            //PLC_SCANNER_X_AXIS = 56,             // 현재 Scanner X축 위치 
-            //PLC_WELDING_FOCAL_LENGTH = 58,       // 현재 Scanner Z축 위치 
-            //PLC_WELDING_LASER_ON_DELAY = 60,
-            //PLC_WELDING_LASER_OFF_DELAY = 62,
-            //PLC_WELDING_JUMP_DELAY = 64,
-            //PLC_WELDING_MARK_DELAY = 66,
-            //PLC_WELDING_POLYGON_DELAY = 68,
-            //PLC_WELDING_RAMPING_START_A_POWER_1 = 70,
-            //PLC_WELDING_RAMPING_START_A_POWER_2 = 72,
-            //PLC_WELDING_RAMPING_START_A_DISTANCE = 74,
-            //PLC_WELDING_RAMPING_START_B_POWER_1 = 76,
-            //PLC_WELDING_RAMPING_START_B_POWER_2 = 78,
-            //PLC_WELDING_RAMPING_START_B_DISTANCE = 80,
-            //PLC_WELDING_RAMPING_END_POWER_1 = 82,
-            //PLC_WELDING_RAMPING_END_POWER_2 = 84,
-            //PLC_WELDING_RAMPING_END_DISTANCE = 86,
-            //PLC_EQUIPMENT_SPEED = 88,
-
-
-
-            //// WON : 2170 RMS 대비 enum 추가 추후 해당 주소 영역 확인 후 주소 매핑 필요, 하기 영역은 2word 로 구성되어야 할 것으로 보이므로 매핑 간격을 2word로
-            // List에 제외 되어 있음 - 확인 필요 (CMY - 26.01.09)
-            //PLC_WELDING_LASER_OFF_DELAY = 62,
-            //PLC_WELDING_MARK_DELAY = 66,
-            //PLC_WELDING_POLYGON_DELAY = 66,
-
 
             // RMS 최종 버전
-            PLC_WELDING_RECIPE_NO = 48,               // 설정할 PLC Recipe 번호
-            PLC_SCANNER_X_AXIS = 50,             // 현재 Scanner X축 위치 
-            PLC_WELDING_FOCAL_LENGTH = 52,       // 현재 Scanner Z축 위치 
-            PLC_EQUIPMENT_SPEED = 54,
+            PLC_WELDING_RECIPE_NO = 48,
+            PLC_WELDING_RECIPE_NO_2WORD,
 
-            PLC_PARAM_1_WELDING_LASER_POWER = 56,
-            PLC_PARAM_1_WELDING_DRAW_SPEED = 58,
-            PLC_PARAM_1_WELDING_JUMP_SPEED = 60,
-            PLC_PARAM_1_WELDING_LASER_ON_DELAY = 62,
-            PLC_PARAM_1_WELDING_JUMP_DELAY = 64,
-            PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_1 = 66,
-            PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_2 = 68,
-            PLC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE = 70,
-            PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_1 = 72,
-            PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2 = 74,
-            PLC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE = 76,
-            PLC_PARAM_1_WELDING_RAMPING_END_POWER_1 = 78,
-            PLC_PARAM_1_WELDING_RAMPING_END_POWER_2 = 80,
-            PLC_PARAM_1_WELDING_RAMPING_END_DISTANCE = 82,
+            PLC_SCANNER_X_AXIS,
+            PLC_SCANNER_X_AXIS_2WORD,
 
-            PLC_PARAM_2_WELDING_LASER_POWER = 84,
-            PLC_PARAM_2_WELDING_DRAW_SPEED = 86,
-            PLC_PARAM_2_WELDING_JUMP_SPEED = 88,
-            PLC_PARAM_2_WELDING_LASER_ON_DELAY = 90,
-            PLC_PARAM_2_WELDING_JUMP_DELAY = 92,
-            PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_1 = 94,
-            PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_2 = 96,
-            PLC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE = 98,
-            PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_1 = 100,
-            PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2 = 102,
-            PLC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE = 104,
-            PLC_PARAM_2_WELDING_RAMPING_END_POWER_1 = 106,
-            PLC_PARAM_2_WELDING_RAMPING_END_POWER_2 = 108,
-            PLC_PARAM_2_WELDING_RAMPING_END_DISTANCE = 110,
+            PLC_WELDING_FOCAL_LENGTH,
+            PLC_WELDING_FOCAL_LENGTH_2WORD,
 
-            PLC_PARAM_3_WELDING_LASER_POWER = 112,
-            PLC_PARAM_3_WELDING_DRAW_SPEED = 114,
-            PLC_PARAM_3_WELDING_JUMP_SPEED = 116,
-            PLC_PARAM_3_WELDING_LASER_ON_DELAY = 118,
-            PLC_PARAM_3_WELDING_JUMP_DELAY = 120,
-            PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_1 = 122,
-            PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_2 = 124,
-            PLC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE = 126,
-            PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_1 = 128,
-            PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2 = 130,
-            PLC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE = 132,
-            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_EQUIPMENT_SPEED,
+            PLC_EQUIPMENT_SPEED_2WORD,
+
+            PLC_PARAM_1_WELDING_LASER_POWER_CORE,
+            PLC_PARAM_1_WELDING_LASER_POWER_CORE_2WORD,
+
+            PLC_PARAM_1_WELDING_LASER_POWER_RING,
+            PLC_PARAM_1_WELDING_LASER_POWER_RING_2WORD,
+
+            PLC_PARAM_1_WELDING_DRAW_SPEED,
+            PLC_PARAM_1_WELDING_DRAW_SPEED_2WORD,
+
+            PLC_PARAM_1_WELDING_JUMP_SPEED,
+            PLC_PARAM_1_WELDING_JUMP_SPEED_2WORD,
+
+            PLC_PARAM_1_WELDING_LASER_ON_DELAY,
+            PLC_PARAM_1_WELDING_LASER_ON_DELAY_2WORD,
+
+            PLC_PARAM_1_WELDING_JUMP_DELAY,
+            PLC_PARAM_1_WELDING_JUMP_DELAY_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_1,
+            PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_1_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_2,
+            PLC_PARAM_1_WELDING_RAMPING_START_A_POWER_2_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE,
+            PLC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_1,
+            PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_1_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2,
+            PLC_PARAM_1_WELDING_RAMPING_START_B_POWER_2_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE,
+            PLC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_END_POWER_1,
+            PLC_PARAM_1_WELDING_RAMPING_END_POWER_1_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_END_POWER_2,
+            PLC_PARAM_1_WELDING_RAMPING_END_POWER_2_2WORD,
+
+            PLC_PARAM_1_WELDING_RAMPING_END_DISTANCE,
+            PLC_PARAM_1_WELDING_RAMPING_END_DISTANCE_2WORD,
+
+            PLC_PARAM_2_WELDING_LASER_POWER_CORE,
+            PLC_PARAM_2_WELDING_LASER_POWER_CORE_2WORD,
+
+            PLC_PARAM_2_WELDING_LASER_POWER_RING,
+            PLC_PARAM_2_WELDING_LASER_POWER_RING_2WORD,
+
+            PLC_PARAM_2_WELDING_DRAW_SPEED,
+            PLC_PARAM_2_WELDING_DRAW_SPEED_2WORD,
+
+            PLC_PARAM_2_WELDING_JUMP_SPEED,
+            PLC_PARAM_2_WELDING_JUMP_SPEED_2WORD,
+
+            PLC_PARAM_2_WELDING_LASER_ON_DELAY,
+            PLC_PARAM_2_WELDING_LASER_ON_DELAY_2WORD,
+
+            PLC_PARAM_2_WELDING_JUMP_DELAY,
+            PLC_PARAM_2_WELDING_JUMP_DELAY_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_1,
+            PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_1_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_2,
+            PLC_PARAM_2_WELDING_RAMPING_START_A_POWER_2_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE,
+            PLC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_1,
+            PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_1_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2,
+            PLC_PARAM_2_WELDING_RAMPING_START_B_POWER_2_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE,
+            PLC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_END_POWER_1,
+            PLC_PARAM_2_WELDING_RAMPING_END_POWER_1_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_END_POWER_2,
+            PLC_PARAM_2_WELDING_RAMPING_END_POWER_2_2WORD,
+
+            PLC_PARAM_2_WELDING_RAMPING_END_DISTANCE,
+            PLC_PARAM_2_WELDING_RAMPING_END_DISTANCE_2WORD,
+
+            PLC_PARAM_3_WELDING_LASER_POWER_CORE,
+            PLC_PARAM_3_WELDING_LASER_POWER_CORE_2WORD,
+
+            PLC_PARAM_3_WELDING_LASER_POWER_RING,
+            PLC_PARAM_3_WELDING_LASER_POWER_RING_2WORD,
+
+            PLC_PARAM_3_WELDING_DRAW_SPEED,
+            PLC_PARAM_3_WELDING_DRAW_SPEED_2WORD,
+
+            PLC_PARAM_3_WELDING_JUMP_SPEED,
+            PLC_PARAM_3_WELDING_JUMP_SPEED_2WORD,
+
+            PLC_PARAM_3_WELDING_LASER_ON_DELAY,
+            PLC_PARAM_3_WELDING_LASER_ON_DELAY_2WORD,
+
+            PLC_PARAM_3_WELDING_JUMP_DELAY,
+            PLC_PARAM_3_WELDING_JUMP_DELAY_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_1,
+            PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_1_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_2,
+            PLC_PARAM_3_WELDING_RAMPING_START_A_POWER_2_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE,
+            PLC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_1,
+            PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_1_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2,
+            PLC_PARAM_3_WELDING_RAMPING_START_B_POWER_2_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE,
+            PLC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_END_POWER_1,
+            PLC_PARAM_3_WELDING_RAMPING_END_POWER_1_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_END_POWER_2,
+            PLC_PARAM_3_WELDING_RAMPING_END_POWER_2_2WORD,
+
+            PLC_PARAM_3_WELDING_RAMPING_END_DISTANCE,
+            PLC_PARAM_3_WELDING_RAMPING_END_DISTANCE_2WORD,
+
+            PLC_MASK_LOAD_CELL_ADHENSION_PRESSURE_UPPER_LIMIT,
+            PLC_MASK_LOAD_CELL_ADHENSION_PRESSURE_UPPER_LIMIT_2WORD,
+
+            PLC_MASK_LOAD_CELL_ADHENSION_PRESSURE_LOWER_LIMIT,
+            PLC_MASK_LOAD_CELL_ADHENSION_PRESSURE_LOWER_LIMIT_2WORD,
         }
 
         public enum eWordOutput : int
@@ -317,89 +384,160 @@ namespace ILSOS_CCW_H52A.Device
             PC_DISPLACEMETNT_SENSOR_14,     //PC 변위센서 결과값(#지그14번)	RESET 값 0, OK이면 1, NG이면 2
             PC_DISPLACEMETNT_SENSOR_15,     //PC 변위센서 결과값(#지그15번)	RESET 값 0, OK이면 1, NG이면 2
             PC_DISPLACEMETNT_SENSOR_16,     //PC 변위센서 결과값(#지그16번)	RESET 값 0, OK이면 1, NG이면 2
-                                            ////////////////////////////////////////////////////////////////////////////////
-
-            //// WON : 2170 RMS 대비 enum 추가 추후 해당 주소 영역 확인 후 주소 매핑 필요, 하기 영역은 2word 로 구성되어야 할 것으로 보이므로 매핑 간격을 2word로
-            //PC_WELDING_RECIPE_NO = 48,                   //설정된 PC Recipe 번호
-            //PC_WELDING_LASER_POWER = 50,                 //PC 용접 레이저 파워
-            //PC_WELDING_DRAW_SPEED = 52,
-            //PC_WELDING_JUMP_SPEED = 54,
-            //PC_WELDING_X_AXIS = 56,
-            //PC_WELDING_FOCAL_LENGTH = 58,
-            //PC_WELDING_LASER_ON_DELAY = 60,
-            //PC_WELDING_LASER_OFF_DELAY = 62,
-            //PC_WELDING_JUMP_DELAY = 64,
-            //PC_WELDING_MARK_DELAY = 66,
-            //PC_WELDING_POLYGON_DELAY = 68,
-            //PC_WELDING_RAMPING_START_A_POWER_1 = 70,
-            //PC_WELDING_RAMPING_START_A_POWER_2 = 72,
-            //PC_WELDING_RAMPING_START_A_DISTANCE = 74,
-            //PC_WELDING_RAMPING_START_B_POWER_1 = 76,
-            //PC_WELDING_RAMPING_START_B_POWER_2 = 78,
-            //PC_WELDING_RAMPING_START_B_DISTANCE = 80,
-            //PC_WELDING_RAMPING_END_POWER_1 = 82,
-            //PC_WELDING_RAMPING_END_POWER_2 = 84,
-            //PC_WELDING_RAMPING_END_DISTANCE = 86,
-            //PC_EQUIPMENT_SPEED = 88,
-
-
-
-            //// WON : 2170 RMS 대비 enum 추가 추후 해당 주소 영역 확인 후 주소 매핑 필요, 하기 영역은 2word 로 구성되어야 할 것으로 보이므로 매핑 간격을 2word로
-            // List에 제외 되어 있음 - 확인 필요 (CMY - 26.01.09)
-            //PLC_WELDING_LASER_OFF_DELAY = 62,
-            //PLC_WELDING_MARK_DELAY = 66,
-            //PLC_WELDING_POLYGON_DELAY = 66,
 
             // RMS 최종 버전
-            PC_WELDING_RECIPE_NO = 48,               // 설정할 PLC Recipe 번호
-            PC_SCANNER_X_AXIS = 50,             // 현재 Scanner X축 위치 
-            PC_WELDING_FOCAL_LENGTH = 52,       // 현재 Scanner Z축 위치 
-            PC_EQUIPMENT_SPEED = 54,
+            PC_WELDING_RECIPE_NO = 48,
+            PC_WELDING_RECIPE_NO_2WORD,
 
-            PC_PARAM_1_WELDING_LASER_POWER = 56,
-            PC_PARAM_1_WELDING_DRAW_SPEED = 58,
-            PC_PARAM_1_WELDING_JUMP_SPEED = 60,
-            PC_PARAM_1_WELDING_LASER_ON_DELAY = 62,
-            PC_PARAM_1_WELDING_JUMP_DELAY = 64,
-            PC_PARAM_1_WELDING_RAMPING_START_A_POWER_1 = 66,
-            PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2 = 68,
-            PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE = 70,
-            PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1 = 72,
-            PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2 = 74,
-            PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE = 76,
-            PC_PARAM_1_WELDING_RAMPING_END_POWER_1 = 78,
-            PC_PARAM_1_WELDING_RAMPING_END_POWER_2 = 80,
-            PC_PARAM_1_WELDING_RAMPING_END_DISTANCE = 82,
+            PC_SCANNER_X_AXIS,
+            PC_SCANNER_X_AXIS_2WORD,
 
-            PC_PARAM_2_WELDING_LASER_POWER = 84,
-            PC_PARAM_2_WELDING_DRAW_SPEED = 86,
-            PC_PARAM_2_WELDING_JUMP_SPEED = 88,
-            PC_PARAM_2_WELDING_LASER_ON_DELAY = 90,
-            PC_PARAM_2_WELDING_JUMP_DELAY = 92,
-            PC_PARAM_2_WELDING_RAMPING_START_A_POWER_1 = 94,
-            PC_PARAM_2_WELDING_RAMPING_START_A_POWER_2 = 96,
-            PC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE = 98,
-            PC_PARAM_2_WELDING_RAMPING_START_B_POWER_1 = 100,
-            PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2 = 102,
-            PC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE = 104,
-            PC_PARAM_2_WELDING_RAMPING_END_POWER_1 = 106,
-            PC_PARAM_2_WELDING_RAMPING_END_POWER_2 = 108,
-            PC_PARAM_2_WELDING_RAMPING_END_DISTANCE = 110,
+            PC_WELDING_FOCAL_LENGTH,
+            PC_WELDING_FOCAL_LENGTH_2WORD,
 
-            PC_PARAM_3_WELDING_LASER_POWER = 112,
-            PC_PARAM_3_WELDING_DRAW_SPEED = 114,
-            PC_PARAM_3_WELDING_JUMP_SPEED = 116,
-            PC_PARAM_3_WELDING_LASER_ON_DELAY = 118,
-            PC_PARAM_3_WELDING_JUMP_DELAY = 120,
-            PC_PARAM_3_WELDING_RAMPING_START_A_POWER_1 = 122,
-            PC_PARAM_3_WELDING_RAMPING_START_A_POWER_2 = 124,
-            PC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE = 126,
-            PC_PARAM_3_WELDING_RAMPING_START_B_POWER_1 = 128,
-            PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2 = 130,
-            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_EQUIPMENT_SPEED,
+            PC_EQUIPMENT_SPEED_2WORD,
+
+            PC_PARAM_1_WELDING_LASER_POWER_CORE,
+            PC_PARAM_1_WELDING_LASER_POWER_CORE_2WORD,
+
+            PC_PARAM_1_WELDING_LASER_POWER_RING,
+            PC_PARAM_1_WELDING_LASER_POWER_RING_2WORD,
+
+            PC_PARAM_1_WELDING_DRAW_SPEED,
+            PC_PARAM_1_WELDING_DRAW_SPEED_2WORD,
+
+            PC_PARAM_1_WELDING_JUMP_SPEED,
+            PC_PARAM_1_WELDING_JUMP_SPEED_2WORD,
+
+            PC_PARAM_1_WELDING_LASER_ON_DELAY,
+            PC_PARAM_1_WELDING_LASER_ON_DELAY_2WORD,
+
+            PC_PARAM_1_WELDING_JUMP_DELAY,
+            PC_PARAM_1_WELDING_JUMP_DELAY_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_START_A_POWER_1,
+            PC_PARAM_1_WELDING_RAMPING_START_A_POWER_1_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2,
+            PC_PARAM_1_WELDING_RAMPING_START_A_POWER_2_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE,
+            PC_PARAM_1_WELDING_RAMPING_START_A_DISTANCE_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1,
+            PC_PARAM_1_WELDING_RAMPING_START_B_POWER_1_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2,
+            PC_PARAM_1_WELDING_RAMPING_START_B_POWER_2_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE,
+            PC_PARAM_1_WELDING_RAMPING_START_B_DISTANCE_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_END_POWER_1,
+            PC_PARAM_1_WELDING_RAMPING_END_POWER_1_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_END_POWER_2,
+            PC_PARAM_1_WELDING_RAMPING_END_POWER_2_2WORD,
+
+            PC_PARAM_1_WELDING_RAMPING_END_DISTANCE,
+            PC_PARAM_1_WELDING_RAMPING_END_DISTANCE_2WORD,
+
+            PC_PARAM_2_WELDING_LASER_POWER_CORE,
+            PC_PARAM_2_WELDING_LASER_POWER_CORE_2WORD,
+
+            PC_PARAM_2_WELDING_LASER_POWER_RING,
+            PC_PARAM_2_WELDING_LASER_POWER_RING_2WORD,
+
+            PC_PARAM_2_WELDING_DRAW_SPEED,
+            PC_PARAM_2_WELDING_DRAW_SPEED_2WORD,
+
+            PC_PARAM_2_WELDING_JUMP_SPEED,
+            PC_PARAM_2_WELDING_JUMP_SPEED_2WORD,
+
+            PC_PARAM_2_WELDING_LASER_ON_DELAY,
+            PC_PARAM_2_WELDING_LASER_ON_DELAY_2WORD,
+
+            PC_PARAM_2_WELDING_JUMP_DELAY,
+            PC_PARAM_2_WELDING_JUMP_DELAY_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_START_A_POWER_1,
+            PC_PARAM_2_WELDING_RAMPING_START_A_POWER_1_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_START_A_POWER_2,
+            PC_PARAM_2_WELDING_RAMPING_START_A_POWER_2_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE,
+            PC_PARAM_2_WELDING_RAMPING_START_A_DISTANCE_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_START_B_POWER_1,
+            PC_PARAM_2_WELDING_RAMPING_START_B_POWER_1_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2,
+            PC_PARAM_2_WELDING_RAMPING_START_B_POWER_2_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE,
+            PC_PARAM_2_WELDING_RAMPING_START_B_DISTANCE_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_END_POWER_1,
+            PC_PARAM_2_WELDING_RAMPING_END_POWER_1_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_END_POWER_2,
+            PC_PARAM_2_WELDING_RAMPING_END_POWER_2_2WORD,
+
+            PC_PARAM_2_WELDING_RAMPING_END_DISTANCE,
+            PC_PARAM_2_WELDING_RAMPING_END_DISTANCE_2WORD,
+
+            PC_PARAM_3_WELDING_LASER_POWER_CORE,
+            PC_PARAM_3_WELDING_LASER_POWER_CORE_2WORD,
+
+            PC_PARAM_3_WELDING_LASER_POWER_RING,
+            PC_PARAM_3_WELDING_LASER_POWER_RING_2WORD,
+
+            PC_PARAM_3_WELDING_DRAW_SPEED,
+            PC_PARAM_3_WELDING_DRAW_SPEED_2WORD,
+
+            PC_PARAM_3_WELDING_JUMP_SPEED,
+            PC_PARAM_3_WELDING_JUMP_SPEED_2WORD,
+
+            PC_PARAM_3_WELDING_LASER_ON_DELAY,
+            PC_PARAM_3_WELDING_LASER_ON_DELAY_2WORD,
+
+            PC_PARAM_3_WELDING_JUMP_DELAY,
+            PC_PARAM_3_WELDING_JUMP_DELAY_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_START_A_POWER_1,
+            PC_PARAM_3_WELDING_RAMPING_START_A_POWER_1_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_START_A_POWER_2,
+            PC_PARAM_3_WELDING_RAMPING_START_A_POWER_2_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE,
+            PC_PARAM_3_WELDING_RAMPING_START_A_DISTANCE_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_START_B_POWER_1,
+            PC_PARAM_3_WELDING_RAMPING_START_B_POWER_1_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2,
+            PC_PARAM_3_WELDING_RAMPING_START_B_POWER_2_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE,
+            PC_PARAM_3_WELDING_RAMPING_START_B_DISTANCE_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_END_POWER_1,
+            PC_PARAM_3_WELDING_RAMPING_END_POWER_1_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_END_POWER_2,
+            PC_PARAM_3_WELDING_RAMPING_END_POWER_2_2WORD,
+
+            PC_PARAM_3_WELDING_RAMPING_END_DISTANCE,
+            PC_PARAM_3_WELDING_RAMPING_END_DISTANCE_2WORD,
+
+            PC_MASK_LOAD_CELL_ADHENSION_PRESSURE_UPPER_LIMIT,
+            PC_MASK_LOAD_CELL_ADHENSION_PRESSURE_UPPER_LIMIT_2WORD,
+
+            PC_MASK_LOAD_CELL_ADHENSION_PRESSURE_LOWER_LIMIT,
+            PC_MASK_LOAD_CELL_ADHENSION_PRESSURE_LOWER_LIMIT_2WORD,
         }
     }
 }

Machines/ILSOS_CCW_H52A/Device/Scanner/ScannerCCWH52A.cs

@@ -31,7 +31,7 @@ namespace ILSOS_CCW_H52A.Device
             if (ret == E1.OK && IsSimul) {
                 if (_plc == null) {
                     _plc = Application.Current.AuroraEnv().DeviceManager[CommonDeviceIds.PLCDevice] as PLCControllerCCWH52A;
-                    return E2.ABORTED;
+                    //return E2.ABORTED;
                 }
 
                 // 값의 동기화가 필요해서 추가 함

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

@@ -23,12 +23,16 @@ using CoreUnit.Scanner.UserControl.ScannerCanvas;
 using DB;
 using DB.Recipe;
 using GUI;
+using Hermes;
 using ILSOS_CCW_H52A.Alarm;
 using ILSOS_CCW_H52A.Device;
 using ILSOS_CCW_H52A.Models;
 using ILSOS_CCW_H52A.Recipes;
 using ILSOS_CCW_H52A.Sequences;
 using ILSOS_CCW_H52A.Views;
+using System;
+using System.Reactive.Linq;
+using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Media;
 using WeldingCommon;
@@ -40,12 +44,10 @@ using WeldingCommon.Views;
 using WeldingCommon.Vision.Factory;
 using static WeldingCommon.Vision.Factory.VisionFactory;
 
-namespace ILSOS_CCW_H52A
-{
-    internal class EquipmentSetup : CommonEquipmentSetup, IEquipmentSetup
-    {
+namespace ILSOS_CCW_H52A {
+    internal class EquipmentSetup : CommonEquipmentSetup, IEquipmentSetup {
         private SequenceBuilder _SeqAutoRunCCWH52A_Builder;
-
+        public Logger Log = new Logger("EquipmentSetup");
         public override void BuildMainStatusView(MainStatusBuilder builder)
         {
             base.BuildMainStatusView(builder);
@@ -57,7 +59,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 +79,60 @@ 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)
+        {
+            //Idle 상태에서는 Permission에 따라서 Recipe Lock이 결정된다.
+            if (e.state == SequenceRunState.Idle) {
+                OnPermissionChanged(null);
+            }
+            //Running 상태에서는 무조건 Recipe Lock
+            else if (e.state == SequenceRunState.Running) {
+                Application.Current.Dispatcher.Invoke(() => {
+                    WeldingRecipeManager.OnActiveReloaded();
+                    _UCRecipe.IsEnabled = false;
+                    AuroraEnv.RecipeManager.SaveLock(CommonRecipeIds.ScannerObjectTeaching, true);
+                });
+            }
+            //다른 경우는? 중복호출이 될 것 같긴한데? 사실상 Idle과 동일하게 처리하는게 나을지?
+            else {
+
+            }
+
+            Log.E($"AutoRun State Changed[{Enum.GetName(typeof(SequenceRunState), e.state)}].");
+        }
+
+        private void OnPermissionChanged(EventMessage message)
+        {
+            // 자동상태에서는 권한 변경에 따른 인터락 설정 무시(Admin이라면 이것도 되게 해야하나?)
+            if (Status.EquipmentMode == eEquipmentMode.AUTO)
+                return;
+
+            bool IsAdmin = ApplicationExt.PermissionLevel <= (ushort)eEditablePermissionLevel.Engineer;
+
+            // Login 권한이 없어지면 Active된 레시피로 변경하도록 함
+            Application.Current.Dispatcher.Invoke(() => {
+                if (!IsAdmin)
+                    WeldingRecipeManager.OnActiveReloaded();
+                else
+                    WeldingRecipeManager.ReloadWeldingRecipe(WeldingRecipeManager.SelectedRecipe.name);
+
+                AuroraEnv.RecipeManager.SaveLock(CommonRecipeIds.ScannerObjectTeaching, !IsAdmin);
+                _UCRecipe.IsEnabled = IsAdmin;
+            });
+
+            Log.E($"OnPermissionChanged >> Permission[{Enum.GetName(typeof(eEditablePermissionLevel), ApplicationExt.PermissionLevel)}] / RecipeLock[{!IsAdmin}]");
         }
 
         // 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

@@ -45,9 +45,9 @@ using System.Windows;
 //      Minor Version
 //      Build Number
 //      Revision
-//
+//ㄴ
 // 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: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.0.5")]
+[assembly: AssemblyFileVersion("1.0.0.5")]

Machines/ILSOS_CCW_H52A/RMS/EDC.cs

@@ -35,7 +35,7 @@ namespace ILSOS_CCW_H52A.RMS
             string strLaserCenterPower = Status.GetProcessingWeldingData().LaserPowerCore;
             string strMarkSpeed = Status.GetProcessingWeldingData().MarkSpeed;
             string strFocalLength = Status.GetProcessingWeldingData().FocalLength;
-            string strJigNo = Status.GetProcessingWeldingData().WeldingJigNo;
+            string strJigNo = Status.GetProcessingWeldingData().JigNo;
 
             string strLaserPowerByLBAD = Status.GetProcessingWeldingData().LaserPowerByLBAD;
 

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())));
 
@@ -80,7 +33,8 @@ namespace ILSOS_CCW_H52A.Recipes
 
             #region PLC Upload Parameter 1
             ScannerParam _LineParam_1 = ScannerCanvasUserCtrl.ScannerParams[0];
-            plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_POWER, (int)(_LineParam_1.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_LASER_POWER.ToString())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_LASER_POWER_CORE, (int)(_LineParam_1.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_LASER_POWER_CORE.ToString())));
+            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())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_1_WELDING_DRAW_SPEED, (int)(_LineParam_1.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_1.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_1.LaserOnDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_1_WELDING_LASER_ON_DELAY.ToString())));
@@ -89,15 +43,17 @@ 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())));
             #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())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_LASER_POWER_CORE, (int)(_LineParam_2.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_LASER_POWER_CORE.ToString())));
+            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())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_DRAW_SPEED, (int)(_LineParam_2.MarkSpeed * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_DRAW_SPEED.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_JUMP_SPEED, (int)(_LineParam_2.JumpSpeed * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_JUMP_SPEED.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_2_WELDING_LASER_ON_DELAY, (int)(_LineParam_2.LaserOnDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_2_WELDING_LASER_ON_DELAY.ToString())));
@@ -106,15 +62,17 @@ 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())));
             #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())));
+            plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_LASER_POWER_CORE, (int)(_LineParam_3.LaserPower1 * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_LASER_POWER_CORE.ToString())));
+            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())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_DRAW_SPEED, (int)(_LineParam_3.MarkSpeed * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_DRAW_SPEED.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_JUMP_SPEED, (int)(_LineParam_3.JumpSpeed * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_JUMP_SPEED.ToString())));
             plc.WriteDWord((int)eWordOutput.PC_PARAM_3_WELDING_LASER_ON_DELAY, (int)(_LineParam_3.LaserOnDelay * (plc as PLCControllerCCWH52A).ConvertTo2WordDivisionIndex(eWordOutput.PC_PARAM_3_WELDING_LASER_ON_DELAY.ToString())));
@@ -123,19 +81,25 @@ 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())));
             #endregion
 
+            //260527 RMS 항목 추가
+            plc.WriteDWord((int)eWordOutput.PC_MASK_LOAD_CELL_ADHENSION_PRESSURE_UPPER_LIMIT, (int)(plc.ReadDWord((int)eWordInput.PLC_MASK_LOAD_CELL_ADHENSION_PRESSURE_UPPER_LIMIT).data));      // PLC에서 받은 데이터를 그대로 넘겨주니 변환이 필요 없다
+            plc.WriteDWord((int)eWordOutput.PC_MASK_LOAD_CELL_ADHENSION_PRESSURE_LOWER_LIMIT, (int)(plc.ReadDWord((int)eWordInput.PLC_MASK_LOAD_CELL_ADHENSION_PRESSURE_LOWER_LIMIT).data));      // PLC에서 받은 데이터를 그대로 넘겨주니 변환이 필요 없다
+
             Log.I(string.Format($"SET PC_RECIPE_PARAM_UPLOAD_COMPLETE True"));
             plc.WriteBit((int)eBitOutput.PC_RECIPE_PARAM_UPLOAD_COMPLETE, true);
         }
 
         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,50 +113,10 @@ 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);
+            _LineParam_1.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_LASER_POWER_CORE);
+            _LineParam_1.LaserPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_LASER_POWER_RING);
             _LineParam_1.MarkSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_DRAW_SPEED);
             _LineParam_1.JumpSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_JUMP_SPEED);
             _LineParam_1.LaserOnDelay = (int)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_1_WELDING_LASER_ON_DELAY);
@@ -201,15 +125,16 @@ 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);
             #endregion
             #region Scanner Upload Parameter 2
             ScannerParam _LineParam_2 = ScannerCanvasUserCtrl.ScannerParams[1];
-            _LineParam_2.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_LASER_POWER);
+            _LineParam_2.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_LASER_POWER_CORE);
+            _LineParam_2.LaserPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_LASER_POWER_RING);
             _LineParam_2.MarkSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_DRAW_SPEED);
             _LineParam_2.JumpSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_JUMP_SPEED);
             _LineParam_2.LaserOnDelay = (int)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_2_WELDING_LASER_ON_DELAY);
@@ -218,15 +143,16 @@ 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);
             #endregion
             #region Scanner Upload Parameter 3
             ScannerParam _LineParam_3 = ScannerCanvasUserCtrl.ScannerParams[2];
-            _LineParam_3.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_LASER_POWER);
+            _LineParam_3.LaserPower1 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_LASER_POWER_CORE);
+            _LineParam_3.LaserPower2 = (uint)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_LASER_POWER_RING);
             _LineParam_3.MarkSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_DRAW_SPEED);
             _LineParam_3.JumpSpeed = (double)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_JUMP_SPEED);
             _LineParam_3.LaserOnDelay = (int)(plc as PLCControllerCCWH52A).ReadDWordByDivision(eWordInput.PLC_PARAM_3_WELDING_LASER_ON_DELAY);
@@ -235,10 +161,10 @@ 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);
             #endregion
 

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;
-        private readonly Logger _log = new Logger("ProcessManager");
+        public CellInfoScheduler cellScheduler { get; set; }
+
+        /// 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/Views/Main/UCMainAutoRun.xaml

@@ -104,7 +104,7 @@
                     <Button Grid.Row="0" Grid.Column="2" Margin="3" Command="{Binding CMD_Reset}" Content="Reset" CommandParameter="TotalProduct" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Height="auto" Style="{StaticResource StButtonAccentBlue}" />
                     <Button Grid.Row="1" Grid.Column="2" Margin="3" Command="{Binding CMD_Reset}" Content="Reset" CommandParameter="TodayProduct" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Height="auto" Style="{StaticResource StButtonAccentBlue}" />
 
-                    <UniformGrid Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="3" Rows="7">
+                    <UniformGrid Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="3" Rows="8">
                         <usercontrols:UCKeyValueString Height="30" KeyText="Date Time" ValueText="{Binding NowDateTime, StringFormat={}{0:yyyy-MM-dd HH:mm:ss}}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" IsReadOnly="True"/>
                         <usercontrols:UCKeyValueString Height="30" KeyText="AutoRun Start Time" ValueText="{Binding CurrentWeldingData.AutoRunStartTime, StringFormat={}{0:yyyy-MM-dd HH:mm:ss}}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" IsReadOnly="True"/>
                         <usercontrols:UCKeyValueString Height="30" KeyText="Weld Start Time" ValueText="{Binding CurrentWeldingData.WeldingStartTime, StringFormat={}{0:yyyy-MM-dd HH:mm:ss}}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" IsReadOnly="True"/>
@@ -112,6 +112,7 @@
                         <usercontrols:UCKeyValueString Height="30" KeyText="Welding Time (ms)" ValueText="{Binding CurrentWeldingData.WeldingSpanTimeMilliseconds}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" IsReadOnly="True"/>
                         <usercontrols:UCKeyValueString Height="30" KeyText="Lot ID" ValueText="{Binding CurrentWeldingData.LotId}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" IsReadOnly="True"/>
                         <usercontrols:UCKeyValueString Height="30" KeyText="Cell ID" ValueText="{Binding CurrentWeldingData.CellId}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" ValueTextSize="11" IsReadOnly="True"/>
+                        <usercontrols:UCKeyValueString Height="30" KeyText="Head No" ValueText="{Binding CurrentWeldingData.JigNo}" KeyHorizontalAlignment="Right" KeyTextWidth="0.8*" IsReadOnly="True"/>
                     </UniformGrid>
                 </Grid>
             </GroupBox>

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();
 
@@ -116,6 +115,7 @@ namespace ILSOS_CCW_H52A.Views
             CurrentWeldingData.WeldingSpanTimeMilliseconds = "0";
             CurrentWeldingData.LotId = "Default_Lot_Id";
             CurrentWeldingData.CellId = "Default_Cell_Id";
+            CurrentWeldingData.JigNo = "0";
         }
 
         private void VisibleChanged(object obj)
@@ -253,24 +253,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/Canvas/CanvasCtrl/Canvas.cs

@@ -1,9 +1,13 @@
+using Aurora.Api;
 using CoreUnit.ScannerCanvasCoreUnit;
 using GUI.Properties;
 using System;
 using System.Collections.Generic;
 using System.Drawing;
+using System.Drawing.Text;
 using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
 using System.Windows.Forms;
 
 namespace CoreUnit.Control.UserControl.Canvas
@@ -253,6 +257,7 @@ namespace CoreUnit.Control.UserControl.Canvas
     public partial class CanvasCtrl : System.Windows.Forms.UserControl
     {
         public List<Color> scannerParamColorList = new List<Color>();
+        public Logger Log = new Logger("CanvasCtrl");
 
         // ´õºí¹öÆÛ Å×½ºÆ®
         private BufferedGraphicsContext context;
@@ -1305,7 +1310,7 @@ namespace CoreUnit.Control.UserControl.Canvas
             if (m_commandType == eCommandType.select || m_commandType == eCommandType.move) {
                 m_commandType = eCommandType.pan;
             }
-
+            Log.E("Recipe View Command Pan");
             UpdateCursor();
         }
 
@@ -1319,11 +1324,16 @@ namespace CoreUnit.Control.UserControl.Canvas
 
         public void CommandDeleteSelected()
         {
+            StringBuilder sb = new StringBuilder();
             if (m_model.SelectedCount > 0) {
+                foreach(var layer in m_model.SelectedObjects) {
+                    sb.Append($"{layer.No + 1} ");
+                }
                 m_model.DeleteObjects(m_model.SelectedObjects);
                 m_model.ClearSelectedObjects();
                 DoInvalidate(true);
                 UpdateCursor();
+                Log.E($"Layer Delete Success. No. [{sb}]");
             }
         }
 
@@ -1340,6 +1350,7 @@ namespace CoreUnit.Control.UserControl.Canvas
         public void CommandScaleToFit()
         {
             Model.Zoom = ((DataModel)Model).ScaleToFit;
+            Log.E("Recipe View Scale to Fit");
             DoInvalidate(true);
         }
 
@@ -1353,6 +1364,7 @@ namespace CoreUnit.Control.UserControl.Canvas
         {
             SetCenter(new UnitPoint(0, 0));
             DoInvalidate(true);
+            Log.E("Recipe View Focus Center");
         }
 
         public void CommandZoomIn()
@@ -1528,14 +1540,15 @@ namespace CoreUnit.Control.UserControl.Canvas
 
             if ((System.Windows.Forms.Control.ModifierKeys & Keys.Control) == Keys.Control) {
                 if (e.KeyCode >= Keys.D1 && e.KeyCode <= Keys.D9) {
-                    int id = e.KeyCode - Keys.D0;
+                    //int id = e.KeyCode - Keys.D0;
 
-                    foreach (var obj in m_model.ActiveLayer.Objects) {
-                        if (obj.ScannerParamID == id)
-                            m_model.AddSelectedObject(obj);
-                    }
-
-                    DoInvalidate(true);
+                    // CMY - Arc를 선택하려고 하면 OverFlow 뜬다.. 확인 필요
+                    //foreach (var obj in m_model.ActiveLayer.Objects) {
+                    //    if (obj.ScannerParamID == id)
+                    //        m_model.AddSelectedObject(obj);
+                    //}
+                    //Log.I($"Recipe View Parameter All Select. ID : {id}");
+                    //DoInvalidate(true);
                 } else {
                     switch (e.KeyCode) {
                         case Keys.G:
@@ -1545,6 +1558,7 @@ namespace CoreUnit.Control.UserControl.Canvas
 
                         case Keys.S:
                             RunningSnapsModeChange();
+                            Log.E("Recipe View Key Input Save!");
                             break;
 
                         case Keys.Right:
@@ -1552,6 +1566,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                                 float offsetValue = evtGetOffsetValue();
                                 ((DataModel)Model).RotateObjects((float)(-1 * offsetValue), Model.SelectedObjects, true);
                                 DoInvalidate(true);
+                                Log.E("Recipe View Key Input Right Rotate");
                             }
                             break;
 
@@ -1560,56 +1575,69 @@ namespace CoreUnit.Control.UserControl.Canvas
                                 float offsetValue = evtGetOffsetValue();
                                 ((DataModel)Model).RotateObjects((float)offsetValue, Model.SelectedObjects, true);
                                 DoInvalidate(true);
+                                Log.E("Recipe View Key Input Left Rotate");
                             }
                             break;
 
                         case Keys.C:
                             copies = new List<IDrawObject>();
+                            StringBuilder Copy_sb = new StringBuilder();
                             foreach (IDrawObject obj in Model.SelectedObjects) {
                                 copies.Add(obj.Clone());
+                                Copy_sb.Append($"{obj.No + 1} ");
                             }
                             iterationOffsetValue = 0;
                             DoInvalidate(true);
+                            Log.E($"Recipe View Layer Copy. No [{Copy_sb}]");
                             break;
 
                         case Keys.V:
                             if (copies.Count != 0) {
+                                StringBuilder Paste_sb = new StringBuilder();
+
                                 double offsetValue = 3;
                                 ((DataModel)Model).CopyObjects(new UnitPoint(iterationOffsetValue + offsetValue, iterationOffsetValue + offsetValue), copies);
                                 iterationOffsetValue = iterationOffsetValue + offsetValue;
                                 DoInvalidate(true);
+                                foreach (var layer in copies) {
+                                    Paste_sb.Append($"{layer.No + 1} ");
+                                }
+                                Log.E($"Recipe View Layer Paste. No [{Paste_sb}]");
                             }
                             break;
 
                         case Keys.Z: //Undo
                             CommandDoUndo();
+                            Log.E("Recipe View Do Undo");
                             break;
 
                         case Keys.Y: //Redo
                             CommandDoRedo();
+                            Log.E("Recipe View Do Redo");
                             break;
 
-                        //키보드로 객체 이동
-                        case Keys.Up://선택된 객체를 지정된 위치값 만큼 상승
-                            if (evtGetOffsetValue != null) {
-                                float offsetValue = evtGetOffsetValue();
-                                Model.MoveObjects(new UnitPoint(0, offsetValue), Model.SelectedObjects, true);
-                                DoInvalidate(true);
-                            }
-                            break;
+                        ////키보드로 객체 이동
+                        //case Keys.Up://선택된 객체를 지정된 위치값 만큼 상승
+                        //    if (evtGetOffsetValue != null) {
+                        //        float offsetValue = evtGetOffsetValue();
+                        //        Model.MoveObjects(new UnitPoint(0, offsetValue), Model.SelectedObjects, true);
+                        //        DoInvalidate(true);
+                        //    }
+                        //    break;
 
-                        case Keys.Down://선택된 객체를 지정된 위치값 만큼 하강
-                            if (evtGetOffsetValue != null) {
-                                float offsetValue = evtGetOffsetValue();
-                                Model.MoveObjects(new UnitPoint(0, -1 * offsetValue), Model.SelectedObjects, true);
-                                DoInvalidate(true);
-                            }
-                            break;
+                        //case Keys.Down://선택된 객체를 지정된 위치값 만큼 하강
+                        //    if (evtGetOffsetValue != null) {
+                        //        float offsetValue = evtGetOffsetValue();
+                        //        Model.MoveObjects(new UnitPoint(0, -1 * offsetValue), Model.SelectedObjects, true);
+                        //        DoInvalidate(true);
+                        //    }
+                        //    break;
 
                         case Keys.A:
                             foreach (var obj in m_model.ActiveLayer.Objects) {
                                 m_model.AddSelectedObject(obj);
                             }
+                            Log.E("Recipe View All Layer Select");
                             break;
 
                     }
@@ -1660,6 +1688,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                     if (evtGetOffsetValue != null) {
                         float offsetValue = evtGetOffsetValue();
                         Model.MoveObjects(new UnitPoint(0, offsetValue), Model.SelectedObjects, true);
+                        Log.E($"Input Key Up, Layer Move. [X : 0, |  Y : {offsetValue}]");
                         DoInvalidate(true);
                     }
                     break;
@@ -1668,6 +1697,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                     if (evtGetOffsetValue != null) {
                         float offsetValue = evtGetOffsetValue();
                         Model.MoveObjects(new UnitPoint(0, -1 * offsetValue), Model.SelectedObjects, true);
+                        Log.E($"Input Key Down, Layer Move. [X : 0, |  Y : {-1 * offsetValue}]");
                         DoInvalidate(true);
                     }
                     break;
@@ -1676,6 +1706,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                     if (evtGetOffsetValue != null) {
                         float offsetValue = evtGetOffsetValue();
                         Model.MoveObjects(new UnitPoint(offsetValue, 0), Model.SelectedObjects, true);
+                        Log.E($"Input Key Right, Layer Move. [X : {offsetValue} |  Y : 0]");
                         DoInvalidate(true);
                     }
                     break;
@@ -1684,6 +1715,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                     if (evtGetOffsetValue != null) {
                         double offsetValue = evtGetOffsetValue();
                         Model.MoveObjects(new UnitPoint(-1 * offsetValue, 0), Model.SelectedObjects, true);
+                        Log.E($"Input Key Left, Layer Move. [X : {-1 * offsetValue} |  Y : 0]");
                         DoInvalidate(true);
                     }
                     break;
@@ -1692,6 +1724,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                     if (evtGetAngleOffsetValue != null) {
                         float angleOffset = evtGetAngleOffsetValue();
                         ((DataModel)Model).RotateObjects(-1 * (float)angleOffset, Model.SelectedObjects, true);
+                        Log.E($"Input Key E, Angle Rotate");
                         DoInvalidate(true);
                     }
                     break;
@@ -1700,6 +1733,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                     if (evtGetAngleOffsetValue != null) {
                         float angleOffset = evtGetAngleOffsetValue();
                         ((DataModel)Model).RotateObjects((float)angleOffset, Model.SelectedObjects, true);
+                        Log.E($"Input Key Q, Angle Rotate");
                         DoInvalidate(true);
                     }
                     break;

WeldingComponents/LASA/GUI/Canvas/Model.cs

@@ -1032,7 +1032,7 @@ namespace CoreUnit.Control.UserControl.Canvas
                 EnableCanvasColor = org.EnableCanvasColor;
                 EnableCanvasGrid = org.EnableCanvasGrid;
                 Layers = (ICanvasLayer[])org.Layers.Clone();
-
+                m_activeLayer = m_layers[0];
                 //var thisDrawing = ActiveLayer as DrawingLayer;
                 //var orgDrawing = org.ActiveLayer as DrawingLayer;
                 //thisDrawing.Copy(orgDrawing, 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) {
-                label58.Text = "(0~4000)";
-                label31.Text = "(0~4000)";
+            //if(_MachineName == eMachineName.H52A_CCW || _MachineName == eMachineName.H52A_ACW || _MachineName == eMachineName.CIT) {
+            label58.Text = _MachineName == eMachineName.H52A_CCW ? "(0~1500)" : "(0~4000)";
+            label31.Text = _MachineName == eMachineName.H52A_CCW ? "(0~2500)" : "(0~4000)";
             label32.Text = "(0~10000)";
             label17.Text = "(1~8000)";
 
-                label22.Enabled = false;
-                tbLaserPower2.Enabled = false;
-                label29.Enabled = false;
-                label31.Enabled = false;
+            label22.Enabled = _MachineName == eMachineName.H52A_CCW;
+            tbLaserPower2.Enabled = _MachineName == eMachineName.H52A_CCW;
+            label29.Enabled = _MachineName == eMachineName.H52A_CCW;
+            label31.Enabled = _MachineName == eMachineName.H52A_CCW;
 
             // Ramping Start, End 구분 후 사용한다.       Power 2번은 여전히 막아둠
             //label68.Enabled = false;
@@ -105,11 +105,6 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             //label73.Enabled = false;
             //label70.Enabled = false;
 
-                nudRampingStartPower2.Enabled = false;
-
-                nudRampingEndPower2.Enabled = false;
-
-
             #region Permission Checking
             // Engineer 이상 등급만 사용 가능
             bool PermissionCheck = ApplicationExt.PermissionLevel <= (ushort)Aurora.Api.PermissionLevel.LEVEL3;
@@ -157,9 +152,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;
@@ -181,13 +173,8 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             label65.Enabled = PermissionCheck;
             label78.Enabled = PermissionCheck;
 
-                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 +316,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 +337,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 +396,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 +842,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 +853,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 +903,17 @@ namespace CoreUnit.Scanner.UserControl.Canvas.Dialog
             tbWobbelLongitudinal.ImeMode = ImeMode.Disable;
             tbWobbelFrequency.ImeMode = ImeMode.Disable;
 
-            nudRampingStartAPower1.ImeMode = ImeMode.Disable;;
-            nudRampingStartAPower2.ImeMode = ImeMode.Disable;;
-            nudRampingStartADist.ImeMode = ImeMode.Disable;;
+            nudRampingStartAPower1.ImeMode = ImeMode.Disable;
+            nudRampingStartAPower2.ImeMode = ImeMode.Disable;
+            nudRampingStartADist.ImeMode = ImeMode.Disable;
 
-            nudRampingStartPower1.ImeMode = ImeMode.Disable;;
-            nudRampingStartPower2.ImeMode = ImeMode.Disable;;
-            nudRampingStartPower3.ImeMode = ImeMode.Disable;;
-            nudRampingStartDist.ImeMode = ImeMode.Disable;;
-            nudRampingEndPower1.ImeMode = ImeMode.Disable;;
-            nudRampingEndPower2.ImeMode = ImeMode.Disable;;
-            nudRampingEndPower3.ImeMode = ImeMode.Disable;;
-            nudRampingEndDist.ImeMode = ImeMode.Disable;;
-            nudRampingInterval.ImeMode = ImeMode.Disable;;
+            nudRampingStartPower1.ImeMode = ImeMode.Disable;
+            nudRampingStartPower2.ImeMode = ImeMode.Disable;
+            nudRampingStartDist.ImeMode = ImeMode.Disable;
+            nudRampingEndPower1.ImeMode = ImeMode.Disable;
+            nudRampingEndPower2.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

@@ -29,25 +29,36 @@ namespace WeldingCommon.Data
             table.Columns.Add(nameof(ActualProcessUnit.LotID), typeof(string));
             table.Columns.Add(nameof(ActualProcessUnit.CellID), typeof(string));
             table.Columns.Add(nameof(ActualProcessUnit.HeadNo), typeof(string));
-            table.Columns.Add(nameof(ActualProcessUnit.WeldType), typeof(string));
             table.Columns.Add(nameof(ActualProcessUnit.EncoderCheck), typeof(bool));
-            table.Columns.Add(nameof(ActualProcessUnit.StartPointX), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.StartPointY), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.EndPointX), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.EndPointY), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.WeldCondition), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.LaserOnDelay), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.LaserOffDelay), typeof(double));
-            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.JumpSpeed), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.MarkSpeed), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.JumpX), typeof(double));
-            table.Columns.Add(nameof(ActualProcessUnit.JumpY), typeof(double));
-        }
+            //table.Columns.Add(nameof(ActualProcessUnit.WeldType), typeof(string));
 
+            for (int i = 0; i < 16; i++)
+                TableColumnsAdd("_" + (i + 1).ToString());
+        }
+        public void TableClear()
+        {
+            table.Clear();
+        }
+        public void TableColumnsAdd(string objectNo)
+        {
+            table.Columns.Add(nameof(ActualProcessParameter.WeldType) + objectNo, typeof(string));
+            table.Columns.Add(nameof(ActualProcessParameter.StartPointX) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.StartPointY) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.EndPointX) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.EndPointY) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.WeldCondition) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.LaserOnDelay) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.LaserOffDelay) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.JumpDelay) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.MarkDelay) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.PolygonDelay) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.PowerCore) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.PowerRing) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.JumpSpeed) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.MarkSpeed) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.JumpX) + objectNo, typeof(double));
+            table.Columns.Add(nameof(ActualProcessParameter.JumpY) + objectNo, typeof(double));
+        }
         public void CreateFiles(string fullPathNoExt, ExportFormat format = ExportFormat.CSV)
         {
             if (fullPathNoExt == null)
@@ -62,11 +73,48 @@ namespace WeldingCommon.Data
         protected override void InsertItem(int index, ActualProcessUnit item)
         {
             base.InsertItem(index, item);
-            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.JumpY);
+
+            var values = new List<object>();
+
+            // 공통값 1회만 추가
+            values.Add(item.Date.ToString("yyyy-MM-dd"));
+            values.Add(item.Date.ToString("HH:mm:ss.fff"));
+            values.Add(item.LotID);
+            values.Add(item.CellID);
+            values.Add(item.HeadNo);
+            values.Add(item.EncoderCheck);
+
+            // ParamAPD[0] ~ [15] 반복 추가
+            for (int i = 0; i < item.ParamAPD.Count; i++)
+            {
+                var apd = item.ParamAPD[i];
+                values.Add(apd.WeldType);
+                values.Add(apd.StartPointX);
+                values.Add(apd.StartPointY);
+                values.Add(apd.EndPointX);
+                values.Add(apd.EndPointY);
+                values.Add(apd.WeldCondition);
+                values.Add(apd.LaserOnDelay);
+                values.Add(apd.LaserOffDelay);
+                values.Add(apd.JumpDelay);
+                values.Add(apd.MarkDelay);
+                values.Add(apd.PolygonDelay);
+                values.Add(apd.PowerCore);
+                values.Add(apd.PowerRing);
+                values.Add(apd.JumpSpeed);
+                values.Add(apd.MarkSpeed);
+                values.Add(apd.JumpX);
+                values.Add(apd.JumpY);
+            }
+
+            table.Rows.Add(values.ToArray());
+        }
+        public void UpdateHeadNo(string headNo)
+        {
+            foreach (var item in this)
+                item.HeadNo = headNo;
+            foreach (DataRow row in table.Rows)
+                row["HeadNo"] = headNo;
         }
 
         protected override void ClearItems()
@@ -86,10 +134,19 @@ namespace WeldingCommon.Data
         private string _CellID;
         public string HeadNo { get => _HeadNo; set => SetProperty(ref _HeadNo, value); }
         private string _HeadNo;
-        public string WeldType { get => _WeldType; set => SetProperty(ref _WeldType, value); }
-        private string _WeldType;
+
         public bool EncoderCheck { get => _EncoderCheck; set => SetProperty(ref _EncoderCheck, value); }
         private bool _EncoderCheck;
+
+        public List<ActualProcessParameter> ParamAPD { get => _ParamAPD; set => SetProperty(ref _ParamAPD, value); }
+        private List<ActualProcessParameter> _ParamAPD = new List<ActualProcessParameter>();
+
+    }
+
+    public class ActualProcessParameter : NotifyPropertyChangedBase
+    {
+        public string WeldType { get => _WeldType; set => SetProperty(ref _WeldType, value); }
+        private string _WeldType;
         public double StartPointX { get => _StartPointX; set => SetProperty(ref _StartPointX, value); }
         private double _StartPointX;
         public double StartPointY { get => _StartPointY; set => SetProperty(ref _StartPointY, value); }
@@ -110,8 +167,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); }
-        private double _Power;
+        public double PowerCore { get => _PowerCore; set => SetProperty(ref _PowerCore, value); }
+        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");
 
@@ -59,6 +59,8 @@ namespace WeldingCommon.Data
 
 
         // <EDC, SeqAutoRunSMW, SeqAutoRunLHS_Normal, SeqReceiveCellInfo>
+        private string _WorkJigNo;
+        public string WorkJigNo { get => _WorkJigNo; set => SetProperty(ref _WorkJigNo, value); }
         private string _WorkCellId;
         public string WorkCellId { get => _WorkCellId; set => SetProperty(ref _WorkCellId, value); }
         private string _WorkLotId;
@@ -84,8 +86,8 @@ namespace WeldingCommon.Data
         public string MarkSpeed { get => _MarkSpeed; set => SetProperty(ref _MarkSpeed, value); }
         private string _FocalLength;
         public string FocalLength { get => _FocalLength; set => SetProperty(ref _FocalLength, value); }
-        private string _WeldingJigNo;
-        public string WeldingJigNo { get => _WeldingJigNo; set => SetProperty(ref _WeldingJigNo, value); }
+        private string _JigNo;
+        public string JigNo { get => _JigNo; set => SetProperty(ref _JigNo, value); }
 
         private string _LaserPowerByLBAD;
         public string LaserPowerByLBAD { get => _LaserPowerByLBAD; set => SetProperty(ref _LaserPowerByLBAD, value); }
@@ -103,11 +105,65 @@ 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.WorkJigNo = 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.JigNo = 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._WorkJigNo = _WorkJigNo;
+            clone._LBAD_Judge = _LBAD_Judge;
+            clone._LDD_Judge = _LDD_Judge;
+            clone._LaserPowerCore = _LaserPowerCore;
+            clone._LaserPowerRing = _LaserPowerRing;
+            clone._MarkSpeed = _MarkSpeed;
+            clone._FocalLength = _FocalLength;
+            clone._JigNo = _JigNo;
+            clone._LaserPowerByLBAD = _LaserPowerByLBAD;
+            clone._CheckCanExist = _CheckCanExist;
+            clone._CheckScannerListEnd = _CheckScannerListEnd;
+            return clone;
         }
     }
 }

WeldingComponents/WeldingCommon/Sequences/Main/SeqUploadWeldingList.cs

@@ -69,6 +69,7 @@ namespace WeldingCommon.Sequences {
         private static DateTime _UploadstartTime;
         private static TimeSpan _UploadSpanTime;
 
+        public ActualProcessUnit LaserAPD;
         private double Rotation_Degree = 0;
 
         public SequenceBuilder Builder()
@@ -116,6 +117,8 @@ namespace WeldingCommon.Sequences {
             _LaserPowerCalParam = context.GetSetting<LaserPowerCalParam>(CommonSettingIds.LaserPowerCalParam);//우선 AuroraRecipe로 상속받아서 함수 사용하도록 함
             _SystemParameter = context.GetSetting<SystemParameter>(CommonSettingIds.SystemParameter);
 
+            LaserAPD = new ActualProcessUnit();
+
             InitDev(context);
             if (!CheckDeviceReady(context)) { //Check Device
                 AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_UploadWeldingList_DeviceNotReady);
@@ -283,8 +286,15 @@ namespace WeldingCommon.Sequences {
             _ExternalCommandOffset.X = (float)_InitParam.CellMeasureCenterOffsetX;
             _ExternalCommandOffset.Y = (float)_InitParam.CellMeasureCenterOffsetY;
 
+            LaserAPD.Date = DateTime.Now;
+            LaserAPD.LotID = Status.GetProcessingWeldingData().WorkLotId;
+            LaserAPD.CellID = Status.GetProcessingWeldingData().WorkCellId;
+            LaserAPD.HeadNo = Status.GetProcessingWeldingData().WorkJigNo;
+
             int drawObjectCount = FuncLoadDrawObjectScannerParam(_InitParam.SelectedDrawObjectList);
 
+            Status.GetProcessingWeldingData().APD.Add(LaserAPD);
+            LaserAPD = null;
             return SequenceAction.Ok();
         }
 
@@ -294,6 +304,7 @@ namespace WeldingCommon.Sequences {
             foreach (IDrawObject obj in objects) {
                 drawObjectCount += FuncLoadDrawObjectScannerParamSelected(obj);
             }
+            Debug.WriteLine($"Scanner Space Check({_Scanner.GetListSpace()})");
 
             return drawObjectCount;
         }
@@ -307,7 +318,6 @@ namespace WeldingCommon.Sequences {
                     count += FuncLoadDrawObjectScannerParamSelected(subObj);
                 }
             }
-
             return count;
         }
 
@@ -401,14 +411,13 @@ namespace WeldingCommon.Sequences {
             // 1. 스캐너 가공 조건 설정
             // TODO: ScannerCanvasUserCtrl 의 값이 제대로 가져와 지는지 확인 필요함. mainPage 로 접근해서 가져와야 할 것인데.
             ScannerParam param = ScannerCanvasUserCtrl.ScannerParams[obj.ScannerParamNo];
-            var laserLog = new ActualProcessUnit();
+            var laserLog = new ActualProcessParameter();
             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;
             laserLog.WeldType = "Line";
             laserLog.WeldCondition = param.No + 1;
             laserLog.LaserOnDelay = param.LaserOnDelay;
@@ -416,7 +425,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 +644,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 +670,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}%) " +
-                    $"(End:{param.RampingEndDist}%, Dist {EndDistance}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
+                    $"(Start_B:{param.RampingStartDist}%, Dist {StartDistance}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
+                    $"(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);
@@ -724,10 +748,8 @@ namespace WeldingCommon.Sequences {
             laserLog.StartPointY = obj.PF1.Y;
             laserLog.EndPointX = obj.PF2.X;
             laserLog.EndPointY = obj.PF2.Y;
-            laserLog.LotID = Status.GetProcessingWeldingData().WorkLotId;
-            laserLog.CellID = Status.GetProcessingWeldingData().WorkCellId;
-            laserLog.HeadNo = Status.GetProcessingWeldingData().WeldingJigNo;
-            Status.GetProcessingWeldingData().APD.Add(laserLog);
+
+            LaserAPD.ParamAPD.Add(laserLog);
         }
 
         private void LoadDotScannerParam(Dot obj)
@@ -742,7 +764,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 +813,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 +861,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 ?
-                                               percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                               percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                 float risingEdgePercentLaser1 = 0;
                 float startingPercentLaser2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
@@ -851,8 +873,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 ?
-                                            percentLaser1 * (float)param.RampingEndPower3 / 100 : 100;
+                float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower2 / 100 <= 100 ?
+                                            percentLaser1 * (float)param.RampingEndPower2 / 100 : 100;
 
                 float fallingEdgePercentLaser1 = 0;
                 float endingPercentLaser2 = percentLaser2 * (float)param.RampingEndPower2 / 100 <= 100 ?
@@ -1360,7 +1382,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 로드 시작
@@ -1412,25 +1434,25 @@ namespace WeldingCommon.Sequences {
 
             // 1.스캐너 가공조건 설정
             ScannerParam param = ScannerCanvasUserCtrl.ScannerParams[obj.ScannerParamNo];
-            var laserLog = new ActualProcessUnit();
+            var laserParamLog = new ActualProcessParameter();
             float percentLaser1 = 0;
             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;
-            laserLog.WeldType = "Arc";
-            laserLog.WeldCondition = param.No + 1;
-            laserLog.LaserOnDelay = param.LaserOnDelay;
-            laserLog.LaserOffDelay = param.LaserOffDelay;
-            laserLog.JumpDelay = param.JumpDelay;
-            laserLog.MarkDelay = param.MarkDelay;
-            laserLog.PolygonDelay = param.PolygonDelay;
-            laserLog.Power = param.LaserPower1;
-            laserLog.JumpSpeed = param.JumpSpeed;
-            laserLog.MarkSpeed = param.MarkSpeed;
+            laserParamLog.WeldType = "Arc";
+            laserParamLog.WeldCondition = param.No + 1;
+            laserParamLog.LaserOnDelay = param.LaserOnDelay;
+            laserParamLog.LaserOffDelay = param.LaserOffDelay;
+            laserParamLog.JumpDelay = param.JumpDelay;
+            laserParamLog.MarkDelay = param.MarkDelay;
+            laserParamLog.PolygonDelay = param.PolygonDelay;
+            laserParamLog.PowerCore = param.LaserPower1;
+            laserParamLog.PowerRing = param.LaserPower2;
+            laserParamLog.JumpSpeed = param.JumpSpeed;
+            laserParamLog.MarkSpeed = param.MarkSpeed;
 
             // 2. 스캐너 가공 작업
             // 2.1. Wobbel 관련 설정
@@ -1570,13 +1592,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 ?
-                                                percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 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 ?
-                                                percentLaser2 * (float)param.RampingStartPower3 / 100 : 100;
+                float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                                percentLaser2 * (float)param.RampingStartPower2 / 100 : 100;
 
 
                 float risingEdgePercentLaser1 = 0;
@@ -1585,8 +1607,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}%) " +
-                 $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
+                 $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
+                 $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower2}%)");
 
 
                 // 2.2.2.2. Rising Edge 구간 파워 및 위치 변경
@@ -1617,16 +1639,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 ?
-                                              percentLaser1 * (float)param.RampingEndPower3 / 100 : 100;
+                float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower2 / 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 ?
-                                              percentLaser2 * (float)param.RampingEndPower3 / 100 : 100;
+                float endingPercentLaser_B2 = percentLaser2 * (float)param.RampingEndPower2 / 100 <= 100 ?
+                                              percentLaser2 * (float)param.RampingEndPower2 / 100 : 100;
 
                 float fallingEdgePercentLaser2 = 0;
 
@@ -1657,13 +1679,11 @@ namespace WeldingCommon.Sequences {
             _LastY = obj.PF2.Y + yOffset;
 
             //CSV Laser Log 추가
-            laserLog.StartPointX = obj.PF1.X;
-            laserLog.StartPointY = obj.PF1.Y;
-            laserLog.EndPointX = obj.PF2.X;
-            laserLog.EndPointY = obj.PF2.Y;
-            laserLog.LotID = Status.GetProcessingWeldingData().WorkLotId;
-            laserLog.CellID = Status.GetProcessingWeldingData().WorkCellId;
-            Status.GetProcessingWeldingData().APD.Add(laserLog);
+           laserParamLog.StartPointX = obj.PF1.X;
+           laserParamLog.StartPointY = obj.PF1.Y;
+           laserParamLog.EndPointX = obj.PF2.X;
+            laserParamLog.EndPointY = obj.PF2.Y;
+            LaserAPD.ParamAPD.Add(laserParamLog);
 
             if (obj.MadebyRCC) {
                 Log.I(string.Format($"[RCC SubPath Arc Weld] Arc center ({obj.CenterPointF.X + xOffset},{obj.CenterPointF.Y + yOffset}), Sweep angle : ({obj.SweepAngle})"));
@@ -1681,15 +1701,14 @@ namespace WeldingCommon.Sequences {
 
             // 1.스캐너 가공조건 설정
             ScannerParam param = ScannerCanvasUserCtrl.ScannerParams[obj.ScannerParamNo];
-            var laserLog = new ActualProcessUnit();
+            var laserLog = new ActualProcessParameter();
             float percentLaser1 = 0;
             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;
             laserLog.WeldType = "Arc3";
             laserLog.WeldCondition = param.No + 1;
             laserLog.LaserOnDelay = param.LaserOnDelay;
@@ -1697,7 +1716,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 +1864,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 ?
-                                                    percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                    float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 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 ?
-                                                    percentLaser2 * (float)param.RampingStartPower3 / 100 : 100;
+                    float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                                    percentLaser2 * (float)param.RampingStartPower2 / 100 : 100;
 
 
                     float risingEdgePercentLaser1 = 0;
@@ -1858,8 +1878,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}%) " +
-                            $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
+                            $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
+                            $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower2}%)");
 
 
                     // 2.2.2.2. Rising Edge 구간 파워 및 위치 변경
@@ -1889,15 +1909,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 ?
-                                                  percentLaser1 * (float)param.RampingEndPower3 / 100 : 100;
+                    float endingPercentLaser_B1 = percentLaser1 * (float)param.RampingEndPower2 / 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 ?
-                                                  percentLaser2 * (float)param.RampingEndPower3 / 100 : 100;
+                    float endingPercentLaser_B2 = percentLaser2 * (float)param.RampingEndPower2 / 100 <= 100 ?
+                                                  percentLaser2 * (float)param.RampingEndPower2 / 100 : 100;
 
                     float fallingEdgePercentLaser2 = 0;
 
@@ -1931,9 +1951,7 @@ namespace WeldingCommon.Sequences {
             laserLog.StartPointY = obj.PF1.Y;
             laserLog.EndPointX = obj.PF2.X;
             laserLog.EndPointY = obj.PF2.Y;
-            laserLog.LotID = Status.GetProcessingWeldingData().WorkLotId;
-            laserLog.CellID = Status.GetProcessingWeldingData().WorkCellId;
-            Status.GetProcessingWeldingData().APD.Add(laserLog);
+            LaserAPD.ParamAPD.Add(laserLog);
 
             if (obj.MadebyRCC) {
                 Log.I(string.Format($"[RCC SubPath Arc3P Weld] Arc center ({obj.CenterPointF.X + xOffset},{obj.CenterPointF.Y + yOffset}), Sweep angle : ({obj.SweepAngle})"));
@@ -1955,7 +1973,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 +2123,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 +2265,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

@@ -478,7 +478,6 @@ namespace WeldingCommon.Settings
         [Category("CellPosMeasure")]
         [DisplayName("CellCenterOffsetY")]
         public double CellPosMeasureCenterOffsetY { get; set; } = 0;
-
     }
     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/UCScannerObjectTeachingViewModel.cs

@@ -181,6 +181,7 @@ namespace WeldingCommon.Views
 
         public void OnChanged((int id, string name) recipe)
         {
+            Log.I($"Recipe Select. ID : {recipe.id}, Name : {recipe.name}");
             if (WeldingRecipeManager.SelectedRecipe.id == recipe.id && WeldingRecipeManager.SelectedRecipe.name == recipe.name) {
                 return;
             }