Amkor/ATV_STDLabelAttach
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
ChiKyun Kim
2025-07-17 16:11:46 +09:00
parent 4865711adc
commit 4a1b1924ba
743 changed files with 230954 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
Handler/Project/Util/Util.cs Normal file
View File

@@ -0,0 +1,191 @@
//using System;
//using System.Collections.Generic;
//using System.Data;
//using System.Diagnostics;
//using System.Drawing;
//using System.IO;
//using System.Linq;
//using System.Management;
//using System.Net;
//using System.Net.NetworkInformation;
//using System.Runtime.Serialization.Formatters.Binary;
//using System.Text;
//using System.Windows.Forms;
//namespace Project
//{
// public static partial class UTIL
// {
// //public static Boolean SendMail(string title, string body, string from, string[] tolist, string file = "")
// //{
// // //메일을 전송하고 나간다
// // Chilkat.MailMan mailman = new Chilkat.MailMan();
// // bool success = mailman.UnlockComponent("BLUPRT.CBX012020_rzDFf7pQAsCS");
// // if (success != true)
// // {
// // UTIL.MsgE("메일 전송이 실패되었습니다\n잠시 후 다시 시도하세요", true);
// // return false;
// // }
// // else
// // {
// // mailman.SmtpHost = "10.101.10.6";
// // mailman.SmtpPort = 25;
// // Chilkat.Email email = new Chilkat.Email();
// // email.Subject = title;
// // //email.Body = this.textBox1.Text;
// // email.SetHtmlBody(body.Replace("\r", "").Replace("\n", "<br/>"));
// // email.From = from;
// // foreach (var to in tolist)
// // email.AddTo(to.Substring(0, to.IndexOf('@')), to);
// // if (System.IO.File.Exists(file))
// // email.AddFileAttachment(file);
// // success = mailman.SendEmail(email);
// // if (success != true)
// // {
// // UTIL.MsgE("발송 실패", true);
// // return false;
// // }
// // success = mailman.CloseSmtpConnection();
// // if (success != true)
// // {
// // UTIL.MsgE("Connection to SMTP server not closed cleanly.", true);
// // return false;
// // }
// // }
// // return true;
// //}
// //public static string JobListToFile(Class.CHistoryJOB data, string jobdate, string jobseq, out int cnt)
// //{
// // cnt = 0;
// // if (string.IsNullOrEmpty(jobdate)) return string.Empty;
// // //이미저장된 목록을 가져오고 중복된것은 피한다
// // var preSavedFile = System.IO.Path.Combine(COMM.SETTING.Data.Path_Data, "JobData", jobdate.Substring(0, 6), jobdate + "-" + jobseq + ".txt");
// // List<string> preList = new List<string>();
// // if (System.IO.File.Exists(preSavedFile)) preList.AddRange(System.IO.File.ReadAllLines(preSavedFile, System.Text.Encoding.UTF8));
// // //Temp
// // var fiName = System.IO.Path.Combine(COMM.SETTING.Data.Path_Data, "UploadTemp", jobdate + "_" + jobseq + ".tab");
// // var fi = new System.IO.FileInfo(fiName);
// // if (fi.Directory.Exists == false) fi.Directory.Create();
// // var sb = new System.Text.StringBuilder();
// // sb.AppendLine("#Time\tSID\tRID\tRAW");
// // var oklist = data.Items.Where(t => t.VisionData.RID.isEmpty() == false).ToArray();
// // foreach (var item in oklist)
// // {
// // //기존에 전송한 목록에 없어야 한다
// // if (item.error == Class.JobData.ErrorCode.None && item.VisionData.RID.isEmpty() == false)
// // {
// // sb.AppendLine(string.Format("{0}\t{1}\t{2}\t{3}",
// // item.JobStart.ToString("yyyy-MM-dd HH:mm:sss"), item.VisionData.SID, item.VisionData.RID, item.VisionData.QROutRaw));
// // cnt += 1;
// // }
// // }
// // try
// // {
// // System.IO.File.WriteAllText(fi.FullName, sb.ToString(), System.Text.Encoding.UTF8);
// // return fi.FullName;
// // }
// // catch (Exception ex)
// // {
// // PUB.log.AddE("JobListToFile:" + ex.Message);
// // return string.Empty;
// // }
// //}
// //public static bool SendMail(string seqdate, string seqno)
// //{
// // Chilkat.MailMan mailman = new Chilkat.MailMan();
// // bool success = mailman.UnlockComponent("BLUPRT.CBX012020_rzDFf7pQAsCS");
// // if (success != true)
// // {
// // Debug.WriteLine(mailman.LastErrorText);
// // return false;
// // }
// // mailman.SmtpHost = "10.101.10.6";
// // mailman.SmtpPort = 25;
// // // Create a new email object
// // Chilkat.Email email = new Chilkat.Email();
// // var mailform = PUB.mailForm.FirstOrDefault();
// // if (mailform == null)
// // return false;
// // var subject = mailform.subject.Trim();
// // subject = subject.Replace("{seqdate}", seqdate);
// // subject = subject.Replace("{seqno}", seqno);
// // var buffer = System.IO.File.ReadAllText(UTIL.CurrentPath + "\\Mailform.html");
// // //시드별집계데이터생성
// // System.Text.StringBuilder sbFileSID = new StringBuilder();
// // System.Text.StringBuilder sbFileREEL = new StringBuilder();
// // sbFileSID.AppendLine(string.Format("NO,SID,작업수량,예정수량,UNIT"));
// // sbFileREEL.AppendLine(string.Format("NO,SID,REEL,QTY,TIME"));
// // // int cntrid = 1;
// // System.IO.File.WriteAllText(UTIL.CurrentPath + "\\result_sidsummary.csv", sbFileSID.ToString(), System.Text.Encoding.Default);
// // System.IO.File.WriteAllText(UTIL.CurrentPath + "\\result_reelist.csv", sbFileREEL.ToString(), System.Text.Encoding.Default);
// // //메일본문의 내용 치환
// // var contents = buffer.Trim();
// // contents = contents.Replace("{seqdate}", seqdate);
// // contents = contents.Replace("{seqno}", seqno);
// // email.Subject = subject;
// // email.SetHtmlBody(contents);
// // email.From = "ReelSorter";
// // email.AddFileAttachment(UTIL.CurrentPath + "\\result_sidsummary.csv");
// // email.AddFileAttachment(UTIL.CurrentPath + "\\result_reelist.csv");
// // System.Text.StringBuilder maillist = new StringBuilder();
// // foreach (DataSet1.MailRecipientRow r in PUB.mailList.Rows)
// // {
// // success = email.AddTo(r.Name, r.Address);
// // maillist.Append(string.Format("{0}({1})", r.Name, r.Address));
// // }
// // success = mailman.SendEmail(email);
// // if (success != true)
// // {
// // Debug.WriteLine(mailman.LastErrorText);
// // return false;
// // }
// // success = mailman.CloseSmtpConnection();
// // if (success != true)
// // {
// // Debug.WriteLine("Connection to SMTP server not closed cleanly.");
// // PUB.log.AddE("메일 발송 실패(" + maillist.ToString() + ")");
// // }
// // PUB.log.AddI("메일 발송 완료(" + maillist.ToString() + ")");
// // return true;
// //}
// }
//}

964
Handler/Project/Util/Util_DO.cs Normal file
View File

@@ -0,0 +1,964 @@
using System;
using System.Collections;
using System.Data;
using System.Linq;
using AR;
using Emgu.CV;
using Emgu.CV.Cuda;
using Emgu.CV.Face;
using Emgu.CV.Flann;
namespace Project
{
public class PindefineI
{
public int idx { get; set; }
public string description { get; set; }
public int terminalno { get; set; }
public string Title { get; set; }
public bool Invert { get; set; }
public PindefineI(eDIName pin)
{
idx = (int)pin;
Title = pin.ToString();
terminalno = (int)pin;
Invert = false;
}
public string name { get { return $"X{idx:X2}"; } }
}
public class PindefineO
{
public int idx { get; set; }
public string description { get; set; }
public int terminalno { get; set; }
public string Title { get; set; }
public PindefineO(eDOName pin)
{
idx = (int)pin;
Title = pin.ToString();
terminalno = (int)pin;
}
public string name { get { return $"Y{idx:X2}"; } }
}
public class PinList
{
public PindefineI[] input { get; set; }
public PindefineO[] output { get; set; }
/// <summary>
/// 입력포트 목록을 반환합니다.
/// 실제 터미널 번호에 매칭되는 이름으로 반환합니다.
/// </summary>
public string[] GetDIName
{
get
{
return input.OrderBy(t => t.terminalno).ToList().Select(t => t.Title).ToArray();
}
}
public string[] GetDIPinName
{
get
{
return input.OrderBy(t => t.idx).ToList().Select(t => t.name).ToArray();
}
}
/// <summary>
/// 입력포트 목록을 반환합니다.
/// 실제 터미널 번호에 매칭되는 이름으로 반환합니다.
/// </summary>
public string[] GetDOName
{
get
{
return output.OrderBy(t => t.terminalno).ToList().Select(t => t.Title).ToArray();
}
}
public string[] GetDOPinName
{
get
{
return output.OrderBy(t => t.idx).ToList().Select(t => t.name).ToArray();
}
}
public PindefineI this[eDIName pin]
{
get
{
return input[(int)pin];
}
}
public PindefineO this[eDOName pin]
{
get
{
return output[(int)pin];
}
}
public Boolean SetInputData(DataSet1.InputDescriptionDataTable dt)
{
bool retval = true;
var names = Enum.GetNames(typeof(eDIPin));
if (this.input == null) //초기데이터생성
{
this.input = new PindefineI[names.Length];
for (int i = 0; i < input.Length; i++)
input[i] = new PindefineI((eDIName)i);
}
if (dt.Any())
{
foreach (DataSet1.InputDescriptionRow dr in dt)
{
if (dr.RowState == DataRowState.Detached || dr.RowState == DataRowState.Detached) continue;
var item = this.input[dr.Idx];
if (dr.IsDescriptionNull() == false) item.description = dr.Description;
if (dr.IsTerminalNoNull() == false && dr.TerminalNo >= 0) item.terminalno = dr.TerminalNo;
}
}
return retval;
}
public Boolean SetOutputData(DataSet1.OutputDescriptionDataTable dt)
{
bool retval = true;
var names = Enum.GetNames(typeof(eDOPin));
if (this.output == null) //초기데이터새엇ㅇ
{
this.output = new PindefineO[names.Length];
for (int i = 0; i < output.Length; i++)
output[i] = new PindefineO((eDOName)i);
}
if (dt.Any())
{
foreach (DataSet1.OutputDescriptionRow dr in dt)
{
if (dr.RowState == DataRowState.Detached || dr.RowState == DataRowState.Detached) continue;
var item = this.output[dr.Idx];
if (dr.IsDescriptionNull() == false) item.description = dr.Description;
if (dr.IsTerminalNoNull() == false && dr.TerminalNo >= 0) item.terminalno = dr.TerminalNo;
}
}
return retval;
}
public bool CheckData()
{
return false;
}
}
public static partial class DIO
{
public static PinList Pin { get; set; }
static int GetPinTerminal(eDIName pin)
{
var pindef = Pin[pin];
return pindef.terminalno;
}
static int GetPinTerminal(eDOName pin)
{
var pindef = Pin[pin];
return pindef.terminalno;
}
public static void InitDIOSensitive()
{
//인식 딜레이를 건다
PUB.dio.SetInputSensitivity(0, 0);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.PORTL_DET_UP), AR.SETTING.Data.PortDetectFall, AR.SETTING.Data.PortDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.PORTC_DET_UP), AR.SETTING.Data.PortDetectFall, AR.SETTING.Data.PortDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.PORTR_DET_UP), AR.SETTING.Data.PortDetectFall, AR.SETTING.Data.PortDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.BUT_AIRF), AR.SETTING.Data.AirChange, AR.SETTING.Data.AirChange);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.DOORF1), AR.SETTING.Data.SaftyDetectFall, AR.SETTING.Data.SaftyDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.DOORF2), AR.SETTING.Data.SaftyDetectFall, AR.SETTING.Data.SaftyDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.DOORF3), AR.SETTING.Data.SaftyDetectFall, AR.SETTING.Data.SaftyDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.DOORR1), AR.SETTING.Data.SaftyDetectFall, AR.SETTING.Data.SaftyDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.DOORR2), AR.SETTING.Data.SaftyDetectFall, AR.SETTING.Data.SaftyDetectRise);
PUB.dio.SetInputSensitivity(GetPinTerminal(eDIName.DOORR3), AR.SETTING.Data.SaftyDetectFall, AR.SETTING.Data.SaftyDetectRise);
PUB.log.AddAT("DIO 센서 감도 설정");
}
/// <summary>
/// 지정한 출력핀의 상태를 변경하고 최대 10초간 상태를 모니터링 합니다.
/// </summary>
/// <param name="doPin"></param>
/// <param name="isFirst"></param>
/// <param name="stepTime"></param>
/// <param name="checkValue"></param>
/// <param name="sendIntervalMs"></param>
/// <param name="timeoutSec"></param>
/// <returns></returns>
public static eNormalResult checkDigitalO(eDOName doPin, TimeSpan stepTime, Boolean checkValue, int sendIntervalMs = 1000, int timeoutSec = 0, bool raiseerror = true)
{
//eIOCheckResult result = eIOCheckResult.Complete;
eNormalResult retval = eNormalResult.False;
if (timeoutSec == 0) timeoutSec = AR.SETTING.Data.Timeout_DIOCommand;
//지정한 출력핀이 조건에 맞지 않을 경우ㅍ
var curValue = DIO.GetIOOutput(doPin);
if (curValue != checkValue)
{
//Offt신호는 1초에 1번씩 전송하게 한다.
var ts = DateTime.Now - PUB.Result.doCheckTime[(int)doPin];
if (ts.TotalMilliseconds >= sendIntervalMs)
{
SetOutput(doPin, checkValue);
PUB.Result.doCheckTime[(int)doPin] = DateTime.Now;
}
//전체 시간이 10초를 넘어가면 오류로 처리함
if (stepTime.TotalSeconds >= timeoutSec)
{
if (raiseerror)
PUB.Result.SetResultTimeOutMessage(doPin, checkValue, eNextStep.PAUSE);
retval = eNormalResult.Error;
}
}
else retval = eNormalResult.True;
return retval;
}
public static eNormalResult checkDigitalO(eDIName doPin, TimeSpan stepTime, Boolean checkValue, int timeoutSec = 0, bool raiseerror = true, eECode timeoutcode = eECode.NOTSET
)
{
//eIOCheckResult result = eIOCheckResult.Complete;
var retval = eNormalResult.False;
if (timeoutSec == 0) timeoutSec = (int)AR.SETTING.Data.Timeout_DIOCommand;
//지정한 출력핀이 조건에 맞지 않을 경우ㅍ
var curValue = DIO.GetIOInput(doPin);
if (curValue != checkValue)
{
//전체 시간이 10초를 넘어가면 오류로 처리함
//var diRunTime = DateTime.Now - Pub.Result.diCheckTime[shutIdx, (int)doPin];
if (stepTime.TotalSeconds >= timeoutSec)
{
if (raiseerror)
{
if (timeoutcode == eECode.NOTSET)
PUB.Result.SetResultTimeOutMessage(doPin, checkValue, eNextStep.PAUSE);
else
PUB.Result.SetResultMessage(eResult.SENSOR, timeoutcode, eNextStep.PAUSE, doPin);
}
retval = eNormalResult.Error;
}
}
else retval = eNormalResult.True;
return retval;
}
public static Boolean IsEmergencyOn()
{
//둘중 하나라도 켜져있드면 비상 상태이다
var b1 = GetIOInput(eDIName.BUT_EMGF);
return b1;
//BitArray ba1 = new BitArray(8);
//ba1.Set(0, GetIOInput(eDIName.BUT_EMG1));
//ba1.Set(1, GetIOInput(eDIName.BUT_EMG2));
//ba1.Set(2, GetIOInput(eDIName.BUT_EMG3));
//ba1.Set(3, GetIOInput(eDIName.BUT_EMG4));
//return ba1.ValueI();
}
/// <summary>
/// 감지센서확인
/// </summary>
/// <returns></returns>
public static int isVacOKL()
{
var cnt = 0;
if (GetIOOutput(eDOName.PICK_VAC1)) cnt += 1;
if (GetIOOutput(eDOName.PICK_VAC2)) cnt += 1;
if (GetIOOutput(eDOName.PICK_VAC3)) cnt += 1;
if (GetIOOutput(eDOName.PICK_VAC4)) cnt += 1;
return cnt;
}
/// <summary>
/// 포트에 장작된 카트의 크기를 반환합니다. 없는경우 0, 7,13 입니다.
/// </summary>
/// <param name="idx">Port Index(left=0, Center=1, Right=2)</param>
/// <returns></returns>
public static eCartSize getCartSize(int idx)
{
var s07 = false;
var s13 = false;
//컨베어모드에서는 무조건 중앙크기와 동일하게 한다 (오류나지않게)
if (VAR.BOOL[eVarBool.Use_Conveyor])
{
s07 = DIO.GetIOInput(eDIName.PORT1_SIZE_07);
s13 = DIO.GetIOInput(eDIName.PORT1_SIZE_13);
}
else
{
if (idx == 0)
{
s07 = DIO.GetIOInput(eDIName.PORT0_SIZE_07);
s13 = DIO.GetIOInput(eDIName.PORT0_SIZE_13);
}
else if (idx == 1)
{
s07 = DIO.GetIOInput(eDIName.PORT1_SIZE_07);
s13 = DIO.GetIOInput(eDIName.PORT1_SIZE_13);
}
else
{
s07 = DIO.GetIOInput(eDIName.PORT2_SIZE_07);
s13 = DIO.GetIOInput(eDIName.PORT2_SIZE_13);
}
}
if (s07 == false && s13 == false) return eCartSize.None;
else if (s13 == true) return eCartSize.Inch13;
else return eCartSize.Inch7;
}
/// <summary>
/// * 입력값을 확인합니다
/// </summary>
/// <param name="pin"></param>
/// <returns></returns>
public static Boolean GetIOInput(eDIName pin)
{
var pindef = Pin[pin];
var curValue = PUB.dio.GetDIValue(pindef.terminalno);
//B접점으로 쓸 것들만 반전 시킨다.
if (pindef.Invert)
{
curValue = !curValue;
}
else if (pin == eDIName.BUT_EMGF)
{
if (PUB.system.ReverseSIG_Emgergency) curValue = !curValue;
}
else if (pin == eDIName.PICKER_SAFE)
{
if (PUB.system.ReverseSIG_PickerSafe) curValue = !curValue;
}
else if (pin == eDIName.BUT_AIRF)
{
if (PUB.system.ReverseSIG_ButtonAir) curValue = !curValue;
}
else if (pin == eDIName.DOORF1 || pin == eDIName.DOORF2 || pin == eDIName.DOORF3)
{
if (PUB.system.ReverseSIG_DoorF) curValue = !curValue;
}
else if (pin == eDIName.DOORR1 || pin == eDIName.DOORR2 || pin == eDIName.DOORR3)
{
if (PUB.system.ReverseSIG_DoorR) curValue = !curValue;
}
else if (pin == eDIName.AIR_DETECT)
{
if (PUB.system.ReverseSIG_AirCheck) curValue = !curValue;
}
else if (pin == eDIName.PORTL_LIM_UP || pin == eDIName.PORTC_LIM_UP || pin == eDIName.PORTR_LIM_UP)
{
if (PUB.system.ReverseSIG_PortLimitUp) curValue = !curValue;
}
else if (pin == eDIName.PORTL_LIM_DN || pin == eDIName.PORTC_LIM_DN || pin == eDIName.PORTR_LIM_DN)
{
if (PUB.system.ReverseSIG_PortLimitDn) curValue = !curValue;
}
else if (pin == eDIName.PORTL_DET_UP)
{
if (PUB.system.ReverseSIG_PortDetect0Up) curValue = !curValue;
}
else if (pin == eDIName.PORTC_DET_UP)
{
if (PUB.system.ReverseSIG_PortDetect1Up) curValue = !curValue;
}
else if (pin == eDIName.PORTR_DET_UP)
{
if (PUB.system.ReverseSIG_PortDetect2Up) curValue = !curValue;
}
//else if(pin == eDIName.L_CYLUP) //임시코드
//{
// curValue = !curValue;
//}
//else if(pin == eDIName.R_CYLUP) //임시코드
//{
// curValue = !curValue;
//}
//else if (pin == eDIName.L_EXT_READY)
//{
// if (PUB.system.ReverseSIG_ExtConvReady) curValue = !curValue;
//}
//else if (pin == eDIName.R_EXT_READY)
//{
// if (PUB.system.ReverseSIG_ExtConvReady) curValue = !curValue;
//}
else if (pin == eDIName.L_CONV1 || pin == eDIName.L_CONV4 || pin == eDIName.L_CONV3)
curValue = !curValue;
else if (pin == eDIName.R_CONV1 || pin == eDIName.R_CONV4 || pin == eDIName.R_CONV3)
curValue = !curValue;
return curValue;
}
/// <summary>
/// * 출력값을 확인합니다.
/// </summary>
/// <param name="pin"></param>
/// <returns></returns>
public static Boolean GetIOOutput(eDOName pin)
{
var pindef = Pin[pin];
return PUB.dio.GetDOValue(pindef.terminalno);
}
///// <summary>
///// A/D Link Digital input Pin number
///// </summary>
///// <param name="pin"></param>
///// <returns></returns>
//public static int GetDINum(eDIName pin)
//{
// return (int)pin + 1;
// //return COMM.SETTING.Data.DI[(byte)pin];
//}
///// <summary>
///// adlink digital output in number
///// </summary>
///// <param name="pin"></param>
///// <returns></returns>
//public static int Pin[eDOName pin)
//{
// return (int)pin + 1;
// //return COMM.SETTING.Data.DO[(byte)pin];
//}
/// <summary>
/// 포트내의 안전센서 여부
/// </summary>
/// <returns></returns>
public static Boolean isSaftyDoorF(Boolean RealSensor = false)
{
//모든 포트가 안전해야 전체가 안전한것이다
return isSaftyDoorF(0, RealSensor) && isSaftyDoorF(1, RealSensor) && isSaftyDoorF(2, RealSensor);
}
public static Boolean isSaftyDoorR(Boolean RealSensor = false)
{
//모든 포트가 안전해야 전체가 안전한것이다
return isSaftyDoorR(0, RealSensor) && isSaftyDoorR(1, RealSensor) && isSaftyDoorR(2, RealSensor);
}
public static Boolean isSaftyDoorF(int idx, Boolean RealSensor)
{
//비활성화한경우 참 반환
if (RealSensor)
{
if (idx == 0) return DIO.GetIOInput(eDIName.DOORF1) == false;
else if (idx == 1) return DIO.GetIOInput(eDIName.DOORF2) == false;
else if (idx == 2) return DIO.GetIOInput(eDIName.DOORF3) == false;
}
else
{
if (idx == 0)
{
if (AR.SETTING.Data.Disable_safty_F0) return true;
else return DIO.GetIOInput(eDIName.DOORF1) == false;
}
else if (idx == 1)
{
if (AR.SETTING.Data.Disable_safty_F1) return true;
else return DIO.GetIOInput(eDIName.DOORF2) == false;
}
else if (idx == 2)
{
if (AR.SETTING.Data.Disable_safty_F2) return true;
else return DIO.GetIOInput(eDIName.DOORF3) == false;
}
}
return false;
}
public static Boolean isSaftyDoorR(int idx, Boolean RealSensor)
{
if (RealSensor == false && idx == 0 && AR.SETTING.Data.Disable_safty_R0 == true) return true;
else if (RealSensor == false && idx == 1 && AR.SETTING.Data.Disable_safty_R1 == true) return true;
else if (RealSensor == false && idx == 2 && AR.SETTING.Data.Disable_safty_R2 == true) return true;
else if (idx == 0 && DIO.GetIOInput(eDIName.DOORR1) == false) return true;
else if (idx == 1 && DIO.GetIOInput(eDIName.DOORR2) == false) return true;
else if (idx == 2 && DIO.GetIOInput(eDIName.DOORR3) == false) return true;
else return false;
}
private static DateTime RoomLightControlTime = DateTime.Now;
public static Boolean SetRoomLight(Boolean on, bool force = false)
{
if (on == true && AR.SETTING.Data.Disable_RoomLight == true && force == false)
{
PUB.log.Add("Disabled:ROOM Light");
SetOutput(eDOName.ROOMLIGHT, false);// PUB.dio.SetOutput(Pin[eDOName.ROOMLIGHT].terminalno, false);
return true; //200708
}
//형광등은 너무 빠른 제어는 하지 않는다
var ts = DateTime.Now - RoomLightControlTime;
if (ts.TotalMilliseconds < 500) return false;
RoomLightControlTime = DateTime.Now;
return SetOutput(eDOName.ROOMLIGHT, on);// PUB.dio.SetOutput(Pin[eDOName.ROOMLIGHT].terminalno, on);
}
public static Boolean SetAIR(Boolean ON)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
return SetOutput(eDOName.SOL_AIR, ON);//return PUB.dio.SetOutput(Pin[eDOName.SOL_AIR].terminalno, ON);
}
/// <summary>
/// * 출력을 변경 합니다
/// </summary>
/// <param name="pin"></param>
/// <param name="value"></param>
/// <returns></returns>
public static Boolean SetOutput(eDOName pin, Boolean value)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
var pindef = Pin[pin];
return PUB.dio.SetOutput(pindef.terminalno, value);
}
public static bool GetPortMotorRun(int index)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
if (index < 0 || index > 3) throw new Exception("포트번호는 (0~2) 사이로 입력되어야 함");
Boolean b1 = false;
eDOName Pin_Dir = eDOName.PORTL_MOT_RUN;
if (index == 1) Pin_Dir = eDOName.PORTC_MOT_RUN;
else if (index == 2) Pin_Dir = eDOName.PORTR_MOT_RUN;
//direction을 먼저 전송한다
b1 = DIO.GetIOOutput(Pin_Dir);
return b1;
}
public static eMotDir GetPortMotorDir(int index)
{
if (PUB.dio == null || !PUB.dio.IsInit) return eMotDir.CW;
if (index < 0 || index > 3) throw new Exception("포트번호는 (0~2) 사이로 입력되어야 함");
Boolean b1 = false;
eDOName Pin_Dir = eDOName.PORTL_MOT_DIR;
if (index == 1) Pin_Dir = eDOName.PORTC_MOT_DIR;
else if (index == 2) Pin_Dir = eDOName.PORTR_MOT_DIR;
//direction을 먼저 전송한다
b1 = DIO.GetIOOutput(Pin_Dir);
if (b1 == false) return eMotDir.CW;
else return eMotDir.CCW;
}
public static Boolean SetPortMagnet(int index, Boolean on)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
//기능적용 2100129
if (on == true)
{
if (index == 0 && AR.SETTING.Data.Enable_Magnet0 == false) return true;
if (index == 1 && AR.SETTING.Data.Enable_Magnet1 == false) return true;
if (index == 2 && AR.SETTING.Data.Enable_Magnet2 == false) return true;
}
if (index == 0) return DIO.SetOutput(eDOName.CART_MAG0, on);
else if (index == 1) return DIO.SetOutput(eDOName.CART_MAG1, on);
else return DIO.SetOutput(eDOName.CART_MAG2, on);
}
/// <summary>
/// CW = Up, CCW = Dn
/// </summary>
/// <param name="index"></param>
/// <param name="Dir"></param>
/// <param name="run"></param>
/// <returns></returns>
public static Boolean SetPortMotor(int index, eMotDir Dir, Boolean run, string remark, Boolean smalldown = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
//Pub.log.AddI($"포트모터({index}) {(Dir == eMotDir.CW ? "(정)" : "(역)")}방향 : {(run ? "O" : "X")} => {remark}");
Boolean b1, b2; b1 = b2 = false;
eDOName Pin_Dir, Pin_Run;
eDIName pin_limp, pin_limn;
if (index == 0) Pin_Dir = eDOName.PORTL_MOT_DIR;
else if (index == 1) Pin_Dir = eDOName.PORTC_MOT_DIR;
else Pin_Dir = eDOName.PORTR_MOT_DIR;
if (index == 0) Pin_Run = eDOName.PORTL_MOT_RUN;
else if (index == 1) Pin_Run = eDOName.PORTC_MOT_RUN;
else Pin_Run = eDOName.PORTR_MOT_RUN;
if (index == 0) pin_limp = eDIName.PORTL_LIM_UP;
else if (index == 1) pin_limp = eDIName.PORTC_LIM_UP;
else pin_limp = eDIName.PORTR_LIM_UP;
if (index == 0) pin_limn = eDIName.PORTL_LIM_DN;
else if (index == 1) pin_limn = eDIName.PORTC_LIM_DN;
else pin_limn = eDIName.PORTR_LIM_DN;
//direction을 먼저 전송한다
if (run)
{
//b2 = Pub.dio.SetOutput(Pin_Dir, Dir != eMotDir.CW);
//System.Threading.Thread.Sleep(5);
//켜야하는 상황인데.. 리밋이 걸렸다면 처리하지 않는다
if (Dir == eMotDir.CW && DIO.GetIOInput(pin_limp) == true)
{
PUB.log.AddI(string.Format("포트({0})번의 출력을 무시합니다(LIMIT_UP) 방향:{1}", index, Dir));
b1 = true;
}
else if (Dir == eMotDir.CCW && DIO.GetIOInput(pin_limn) == true)
{
PUB.log.AddI(string.Format("포트({0})번의 출력을 무시합니다(LIMIT_DN) 방향:{1}", index, Dir));
b1 = true;
}
else
{
if (smalldown)
{
if (index == 0)
{
PUB.flag.set(eVarBool.FG_PORT0_ENDDOWN, true, remark + ":SETPORT");
VAR.TIME.Update(eVarTime.PORT0); //내린시간
}
if (index == 1)
{
PUB.flag.set(eVarBool.FG_PORT1_ENDDOWN, true, remark + ":SETPORT");
VAR.TIME.Update(eVarTime.PORT1); //내린시간
}
if (index == 2)
{
PUB.flag.set(eVarBool.FG_PORT2_ENDDOWN, true, remark + ":SETPORT");
VAR.TIME.Update(eVarTime.PORT2); //내린시간
}
PUB.log.AddAT(string.Format("P{0} Small Down Active Dir={1}", index, Dir));
}
else
{
//다른곳에서 이동을 설정해버리면 sdmall down 기능을 없앤다 -- 210405
if (index == 0 && PUB.flag.get(eVarBool.FG_PORT0_ENDDOWN) == true)
{
PUB.flag.set(eVarBool.FG_PORT0_ENDDOWN, false, remark + ":SETPORT");
PUB.log.AddAT("P0 Small Down Ignore");
}
if (index == 1 && PUB.flag.get(eVarBool.FG_PORT1_ENDDOWN) == true)
{
PUB.flag.set(eVarBool.FG_PORT1_ENDDOWN, false, remark + ":SETPORT");
PUB.log.AddAT("P1 Small Down Ignore");
}
if (index == 2 && PUB.flag.get(eVarBool.FG_PORT2_ENDDOWN) == true)
{
PUB.flag.set(eVarBool.FG_PORT2_ENDDOWN, false, remark + ":SETPORT");
PUB.log.AddAT("P2 Small Down Ignore");
}
}
//방향전환을 해야한다면 우선 정지 후 500ms 대기한다
if (DIO.GetPortMotorDir(index) != Dir)
{
//일단 멈춤고
b1 = SetOutput(Pin_Run, false);// PUB.dio.SetOutput(Pin_Run, false);
System.Threading.Thread.Sleep(20);
//방향전환 ON
b2 = SetOutput(Pin_Dir, Dir != eMotDir.CW);
System.Threading.Thread.Sleep(20);
//모터 가동
b1 = SetOutput(Pin_Run, run);
System.Threading.Thread.Sleep(20);
}
else
{
//방향전환을 하지 않는 경우
//모터 가동
b2 = true;
b1 = SetOutput(Pin_Run, run);
System.Threading.Thread.Sleep(20);
}
//b1 = Pub.dio.SetOutput(Pin_Run, run);
}
}
else
{
//동작을 먼저 끈다
b1 = SetOutput(Pin_Run, run);
System.Threading.Thread.Sleep(20);
//방향핀을 끈다
b2 = SetOutput(Pin_Dir, false);
System.Threading.Thread.Sleep(20);
}
//System.Threading.Thread.Sleep(5);
return b1 && b2;
}
public static Boolean SetPrintLAir(bool run, bool force = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
if (force == false && AR.SETTING.Data.Disable_PLAir == true) run = false;
return SetOutput(eDOName.PRINTL_AIRON, run);
}
public static Boolean SetPrintRAir(bool run, bool force = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
if (force == false && AR.SETTING.Data.Disable_PRAir == true) run = false;
return SetOutput(eDOName.PRINTR_AIRON, run);
}
public static Boolean SetPrintLVac(ePrintVac run, bool force = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
if (force == false && AR.SETTING.Data.Disable_PLVac == true) run = ePrintVac.off;
bool b1, b2;
if (run == ePrintVac.inhalation)
{
//흡기
b1 = DIO.SetOutput(eDOName.PRINTL_VACO, false);
b2 = DIO.SetOutput(eDOName.PRINTL_VACI, true);
}
else if (run == ePrintVac.exhaust)
{
//배기
b1 = DIO.SetOutput(eDOName.PRINTL_VACI, false);
b2 = DIO.SetOutput(eDOName.PRINTL_VACO, true);
}
else
{
//끄기
b1 = DIO.SetOutput(eDOName.PRINTL_VACO, false);
b2 = DIO.SetOutput(eDOName.PRINTL_VACI, false);
}
return b1 && b2;
}
public static Boolean SetPrintRVac(ePrintVac run, bool force = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
if (force == false && AR.SETTING.Data.Disable_PRVac == true) run = ePrintVac.off;
bool b1, b2;
if (run == ePrintVac.inhalation)
{
//흡기
b1 = DIO.SetOutput(eDOName.PRINTR_VACO, false);
b2 = DIO.SetOutput(eDOName.PRINTR_VACI, true);
}
else if (run == ePrintVac.exhaust)
{
//배기
b1 = DIO.SetOutput(eDOName.PRINTR_VACI, false);
b2 = DIO.SetOutput(eDOName.PRINTR_VACO, true);
}
else
{
//끄기
b1 = DIO.SetOutput(eDOName.PRINTR_VACO, false);
b2 = DIO.SetOutput(eDOName.PRINTR_VACI, false);
}
return b1 && b2;
}
public static Boolean SetPickerVac(Boolean run, Boolean force = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
// Pub.log.Add("[F] 진공 : " + run.ToString());
bool b1, b2, b3, b4;
//if (COMM.SETTING.Data.Disable_vacum) run = false;
if (run)
{
if (force == true || AR.SETTING.Data.Disable_PKVac == false)
{
b1 = SetOutput(eDOName.PICK_VAC1, true);
b2 = SetOutput(eDOName.PICK_VAC2, true);
b3 = SetOutput(eDOName.PICK_VAC3, true);
b4 = SetOutput(eDOName.PICK_VAC4, true);
}
else
{
b1 = b2 = b3 = b4 = true;
}
}
else
{
b1 = SetOutput(eDOName.PICK_VAC1, false);
b2 = SetOutput(eDOName.PICK_VAC2, false);
b3 = SetOutput(eDOName.PICK_VAC3, false);
b4 = SetOutput(eDOName.PICK_VAC4, false);
if (PUB.flag.get(eVarBool.FG_PK_ITEMON) == true)
{
PUB.flag.set(eVarBool.FG_PK_ITEMON, false, "VACOFF");
PUB.logDbg.AddI("피커 아이템플래그 제거");
}
}
return b1 & b2 & b3 & b4;
}
#region "Tower Lamp"
/// <summary>
/// 타워램프버튼 작업
/// </summary>
/// <param name="g"></param>
/// <param name="r"></param>
/// <param name="y"></param>
public static void SetTWLamp(Boolean bFront, Boolean r, Boolean g, Boolean y)
{
if (PUB.dio == null || !PUB.dio.IsInit) return;
if (DIO.GetIOOutput(eDOName.TWR_GRNF) != g) SetOutput(eDOName.TWR_GRNF, g);
if (DIO.GetIOOutput(eDOName.TWR_REDF) != r) SetOutput(eDOName.TWR_REDF, r);
if (DIO.GetIOOutput(eDOName.TWR_YELF) != y) SetOutput(eDOName.TWR_YELF, y);
if (PUB.flag.get(eVarBool.FG_MOVE_PICKER) == true)
{
g = true;
r = true;
if (DIO.GetIOOutput(eDOName.BUT_STARTF) != g) SetOutput(eDOName.BUT_STARTF, g);
if (DIO.GetIOOutput(eDOName.BUT_STOPF) != r) SetOutput(eDOName.BUT_STOPF, r);
}
else
{
if (DIO.GetIOOutput(eDOName.BUT_STARTF) != g) SetOutput(eDOName.BUT_STARTF, g);
if (DIO.GetIOOutput(eDOName.BUT_STOPF) != r) SetOutput(eDOName.BUT_STOPF, r);
}
if (DIO.GetIOOutput(eDOName.BUT_RESETF) != y) SetOutput(eDOName.BUT_RESETF, y);
}
public static Boolean SetTwRed(Boolean ON)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
SetOutput(eDOName.BUT_STOPF, ON);
return SetOutput(eDOName.TWR_REDF, ON);
}
public static Boolean SetTwYel(Boolean ON)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
SetOutput(eDOName.BUT_RESETF, ON);
return SetOutput(eDOName.TWR_YELF, ON);
}
public static Boolean SetTwGrn(Boolean ON)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
SetOutput(eDOName.BUT_STARTF, ON);
return SetOutput(eDOName.TWR_GRNF, ON);
}
#endregion
public static Boolean SetBuzzer(Boolean ON, bool force = false)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
if (ON)
{
if (SETTING.Data.Disable_Buzzer == true && force == false) return true; //부저기능OFF시 사용 안함
}
if (ON && SETTING.Data.Disable_Buzzer == true && force == false)
{
PUB.log.AddAT("buzzer Disabled");
ON = false;
}
return SetOutput(eDOName.BUZZER, ON);
}
public static Boolean SetMotPowerOn(Boolean ON)
{
if (PUB.dio == null || !PUB.dio.IsInit) return false;
var c0 = !DIO.GetIOOutput(eDOName.SVR_PWR_0);
var c1 = !DIO.GetIOOutput(eDOName.SVR_PWR_1);
var c2 = !DIO.GetIOOutput(eDOName.SVR_PWR_2);
var c3 = !DIO.GetIOOutput(eDOName.SVR_PWR_3);
var c4 = !DIO.GetIOOutput(eDOName.SVR_PWR_4);
var c5 = !DIO.GetIOOutput(eDOName.SVR_PWR_5);
var c6 = !DIO.GetIOOutput(eDOName.SVR_PWR_6);
//꺼져잇는 신호가 하나도 없다면 이번에 끄니깐 메세지를 추가하자
//if (c0 == false && c0 == c1 && c0 == c2 && c0 == c3 && c0 == c4 && c0 == c5 && c0 == c6)
// Console.WriteLine("mot power off");
bool b0, b1, b2, b3, b4, b5, b6;
b0 = b1 = b2 = b3 = b4 = b5 = b6 = true;
if (c0 != ON) b0 = SetOutput(eDOName.SVR_PWR_0, !ON);
if (c1 != ON) b1 = SetOutput(eDOName.SVR_PWR_1, !ON);
if (c2 != ON) b2 = SetOutput(eDOName.SVR_PWR_2, !ON);
if (c3 != ON) b3 = SetOutput(eDOName.SVR_PWR_3, !ON);
if (c4 != ON) b4 = SetOutput(eDOName.SVR_PWR_4, !ON);
if (c5 != ON) b5 = SetOutput(eDOName.SVR_PWR_5, !ON);
if (c6 != ON) b6 = SetOutput(eDOName.SVR_PWR_6, !ON);
return b0 && b1 && b2 && b3 && b4 && b5 && b6;
}
public static Boolean SetMotEmergency(Boolean ON)
{
//if (ON == true) Console.WriteLine("mot emg on");
if (PUB.dio == null || !PUB.dio.IsInit) return false;
return true;
//var c0 = DIO.GetIOOutput(eDOName.SVR_EMG_0);
//var c1 = DIO.GetIOOutput(eDOName.SVR_EMG_1);
//var c2 = DIO.GetIOOutput(eDOName.SVR_EMG_2);
//var c3 = DIO.GetIOOutput(eDOName.SVR_EMG_3);
//var c4 = DIO.GetIOOutput(eDOName.SVR_EMG_4);
//var c5 = DIO.GetIOOutput(eDOName.SVR_EMG_5);
//var c6 = DIO.GetIOOutput(eDOName.SVR_EMG_6);
//bool b0, b1, b2, b3, b4, b5, b6;
//b0 = b1 = b2 = b3 = b4 = b5 = b6 = ON;
//if (c0 != ON) b0 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_0) - 1, ON);
//if (c1 != ON) b1 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_1) - 1, ON);
//if (c2 != ON) b2 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_2) - 1, ON);
//if (c3 != ON) b3 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_3) - 1, ON);
//if (c4 != ON) b4 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_4) - 1, ON);
//if (c5 != ON) b5 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_5) - 1, ON);
//if (c6 != ON) b6 = PUB.dio.SetOutput(Pin[eDOName.SVR_EMG_6) - 1, ON);
//return b0 && b1 && b2 && b3 && b4 && b5 && b6;
}
}
}

627
Handler/Project/Util/Util_Mot.cs Normal file
View File

@@ -0,0 +1,627 @@
#pragma warning disable IDE1006 // 명명 스타일
using arDev.MOT;
using AR;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Project
{
public static partial class MOT
{
/// <summary>
/// 상대위치로 모터를 이동합니다
/// </summary>
/// <param name="value"></param>
/// <param name="src"></param>
public static void Rotation(double value,string src)
{
//모터회전
var thpos = MOT.GetPTPos(ePTLoc.READY); //적용할 속도값용
MOT.Move(eAxis.Z_THETA, value, thpos.Speed, thpos.Acc, true);
PUB.log.AddI($"Theta Rorate:{value},Reason:{src}");
}
public static Boolean CheckMotionLimitError()
{
for (int i = 0; i < PUB.mot.DeviceCount; i++)
{
if (PUB.mot.IsUse(i) == false) continue; //미사용축은 제외한다.
//if (PUB.system.UseAxis(i) == false) continue;
//if (PUB.system.UseOriginSignal(i) == false) continue;
if (PUB.mot.IsLimit(i)) return true;
}
return false;
}
#region "Check Motion Position"
public static Boolean CheckMotionPos(TimeSpan stepTime, sPositionData posdata, string source, Boolean useInterLocak = true, int timeoutSec = 0)
{
if (posdata.Axis < 0) throw new Exception("CheckMotionPos:Motion 번호가 없습니다");
//return CheckMotionPos((eAxis)posdata.Axis, stepTime, posdata.Position, posdata.Speed, posdata.Acc, posdata.Dcc, source, useInterLocak, timeoutSec, posdata.inpositionrange);
return CheckMotionPos((eAxis)posdata.Axis, stepTime, posdata.Position, posdata.Speed, posdata.Acc, posdata.Dcc, source, useInterLocak, timeoutSec, posdata.inpositionrange);
}
public static Boolean CheckMotionPos(eAxis Motaxis, TimeSpan stepTime, double pos, double speed, double acc, double dcc, string source, Boolean useInterLocak = true, int timeoutSec = 0, float inpaccr = 0f)
{
var axis = (int)Motaxis;
//타임아웃 적용 191213
if (timeoutSec == 0) timeoutSec = AR.SETTING.Data.Timeout_MotionCommand;
//accr 범위가 지정되잇다며 ㄴ그것을 사용한다
if (inpaccr == 0f)
inpaccr = 0.1f;// PUB.system.INPAccurary(axis);
//X축을 그립위치까지 이동함
if (PUB.mot.IsInp(axis) && PUB.mot.IsMotion(axis) == false)
{
var offset = Math.Abs(PUB.mot.GetCmdPos(axis) - pos);
var offsetReal = Math.Abs(PUB.mot.GetCmdPos(axis) - PUB.mot.GetActPos(axis));
//커맨드위치는 오차가 없어야 한다
if (offset > 0.001 || offsetReal > inpaccr) //220214 0.01)
{
//모션을 옴겨야하는 상황인데 최대시간을 초과했다면 오류로 처리한다
if (timeoutSec != -1 && stepTime.TotalSeconds >= timeoutSec)
{
PUB.Result.SetResultTimeOutMessage(Motaxis, eECode.MOT_CMD, eNextStep.PAUSE, source, pos, PUB.mot.ErrorMessage);
return false;
}
if (MOT.Move(Motaxis, pos, speed, acc, false, true, useInterLocak) == false)
{
Console.WriteLine("move error {0},pos={1} => {2}", Motaxis, pos, PUB.mot.ErrorMessage);
return false;
}
//모션을 이동시켰으니 False 처리한다
//return false;
}
}
//축이 이동중이면 처리하지 않는다.
if (PUB.mot.IsInp(axis) == false || PUB.mot.IsMotion(axis) == true)
{
return false;
}
//X축실위치값 확인
if (MOT.getPositionMatch(axis, pos, inpaccr) == false)
{
return false;
}
return true;
}
#endregion
#region "Get Axis Position"
public static sPositionData GetPXPos(ePXLoc pos) { return GetAxPos(eAxis.PX_PICK, (int)pos); }
public static sPositionData GetPZPos(ePZLoc pos) { return GetAxPos(eAxis.PZ_PICK, (int)pos); }
public static sPositionData GetLMPos(eLMLoc pos) { return GetAxPos(eAxis.PL_MOVE, (int)pos); }
public static sPositionData GetLZPos(eLZLoc pos) { return GetAxPos(eAxis.PL_UPDN, (int)pos); }
public static sPositionData GetRMPos(eRMLoc pos) { return GetAxPos(eAxis.PR_MOVE, (int)pos); }
public static sPositionData GetRZPos(eRZLoc pos) { return GetAxPos(eAxis.PR_UPDN, (int)pos); }
public static sPositionData GetPTPos(ePTLoc pos) { return GetAxPos(eAxis.Z_THETA, (int)pos); }
#endregion
/// <summary>
/// 지정된 축의 위치값에 속한 이름을 반환합니다.
/// 특정 구간에 속하지 않은 경우 UNKNOWN 을 반환 합니다
/// </summary>
/// <param name="axis"></param>
/// <param name="Pos"></param>
/// <returns></returns>
public static String GetPosName(eAxis axis, double Pos = -1, double CheckOffset = 0.1)
{
//홈을 잡지 않았다면 오류로 처리함\
//eYPPosition retval = eYPPosition.Unknown;
var motIndex = (int)axis;
if (PUB.mot.IsInit == false) return "ERROR";// (T)ePickYPosition.ERROR; //200213
if (PUB.mot.IsHomeSet(motIndex) == false) return "ERROR";//ePickYPosition.ERROR;
if (PUB.Result == null || PUB.Result.isSetmModel == false) return "ERROR";//return ePickYPosition.ERROR;
if (PUB.mot.IsUse(motIndex) == false) return "DISABLE";
else if (PUB.mot.IsServAlarm(motIndex)) return "SVALM";
else if (PUB.mot.IsServOn(motIndex) == false) return "SVOFF";
else if (PUB.mot.IsLimitN(motIndex)) return "LIMITN";
else if (PUB.mot.IsLimitP(motIndex)) return "LIMITP";
else if (PUB.mot.IsLimitSWN(motIndex)) return "LIMITN(SW)";
else if (PUB.mot.IsLimitSWP(motIndex)) return "LIMITP(SW)";
else if (PUB.mot.IsOrg(motIndex)) return "HOME";
else
{
//특정위치에있는지 확인한다. match 명령사용
if (Pos == -1) Pos = PUB.mot.GetActPos(motIndex);
var PosT = 0.0;
//해당 모션이 속한 좌표를 모두 가져온다
var pts = PUB.Result.mModel.Position[motIndex].OrderBy(t => t.value).ToList();
//각위치별값을 확인한다.
for (int i = 0; i < pts.Count; i++)
{
var pValue = pts[i];
if (Math.Abs(pValue.value - Pos) <= CheckOffset)
{
//해당위치에 있다i
if (axis == eAxis.PX_PICK) return ((ePXLoc)i).ToString();
else if (axis == eAxis.PZ_PICK) return ((ePZLoc)i).ToString();
else if (axis == eAxis.Z_THETA) return ((ePTLoc)i).ToString();
else if (axis == eAxis.PL_MOVE) return ((eLMLoc)i).ToString();
else if (axis == eAxis.PL_UPDN) return ((eLZLoc)i).ToString();
else if (axis == eAxis.PR_MOVE) return ((eRMLoc)i).ToString();
else if (axis == eAxis.PR_UPDN) return ((eRZLoc)i).ToString();
else return $"P#{i}";
}
}
//위치를 찾지 못했다
if (Math.Abs(Pos) <= CheckOffset) return "ZERO";
else return "UNKNOWN";
}
}
/// <summary>
/// Z-L축이 안전위치에있는가?(Ready 보다 위에있으면 안전위치이다)
/// </summary>
/// <returns></returns>
public static Boolean isAxisSaftyZone(eAxis axis, int allowoffset = 2)
{
//홈을 잡지 않았다면 오류로 처리함
var motIndex = (int)axis;
if (PUB.mot.IsInit == false) return false;
if (PUB.mot.IsHomeSet(motIndex) == false) return false;
if (PUB.Result == null || PUB.Result.isSetmModel == false) return false;
sPositionData readypos;
if (axis == eAxis.PX_PICK)
{
//피커는 안전위이가 2개 있다
readypos = GetPXPos(ePXLoc.PICKON);
//var readypos1 = GetAxPXPos(eAxisPXPos.ReadyR);
//var offset1 = getPositionOffset(axis, readypos.position);
//var offset2 = getPositionOffset(axis, readypos1.position);
//if (offset1 < allowoffset || offset2 < allowoffset ) return true; //오차가 2미만이라면 안전하다
//return false;
}
else if (axis == eAxis.PZ_PICK) readypos = GetPZPos(ePZLoc.READY);
else if (axis == eAxis.Z_THETA) readypos = GetPTPos(ePTLoc.READY);
else if (axis == eAxis.PL_MOVE) readypos = GetLMPos(eLMLoc.READY);
else if (axis == eAxis.PR_MOVE) readypos = GetRMPos(eRMLoc.READY);
else if (axis == eAxis.PR_UPDN) readypos = GetRZPos(eRZLoc.READY);
else if (axis == eAxis.PL_UPDN) readypos = GetLZPos(eLZLoc.READY);
else return false;
var offset = getPositionOffset(axis, readypos.Position);
if (offset < allowoffset) return true; //오차가 2미만이라면 안전하다
return false;
}
private static Boolean Home_Validation(eAxis axis, out string errorMessage)
{
Boolean retval = true;
// int axis = (int)axis_;
var CW = false; //홈검색은 항상 뒤로 움직인다.
if (!Move_Validation(axis, CW, out errorMessage)) retval = false; //이동이 불가한 경우 체크
else if (axis == eAxis.PX_PICK)
{
//Z축 홈이 필요하다
var zFHome = PUB.mot.IsHomeSet((int)eAxis.PZ_PICK);
var zRHome = PUB.mot.IsHomeSet((int)eAxis.Z_THETA);
if (zFHome == false || zRHome == false)
{
//errorMessage = "Z-PICKER,Z-THETA 축 홈이 필요 합니다";
//retval = false;
}
}
else if (axis == eAxis.PL_MOVE) //Z축의 경우 Y축이 홈으로 된 상태여야 한다.
{
if (PUB.mot.IsHomeSet((int)eAxis.PL_UPDN) == false)
{
errorMessage = "PRINT-L Z 축 홈이 필요 합니다";
retval = false;
}
}
else if (axis == eAxis.PR_MOVE) //Z축의 경우 Y축이 홈으로 된 상태여야 한다.
{
if (PUB.mot.IsHomeSet((int)eAxis.PR_UPDN) == false)
{
errorMessage = "PRINT-R Z 축 홈이 필요 합니다";
retval = false;
}
}
return retval;
}
//private static Boolean Move_Validation(eAxis axis, out string errorMessage)
//{
// errorMessage = string.Empty;
// if (DIO.IsEmergencyOn() == true)
// {
// errorMessage = ("비상정지 상태일때에는 움직일 수 없습니다.");
// return false;
// }
// return true;
//}
private static Boolean Move_Validation(eAxis axis, Boolean MoveCW, out string errorMessage)
{
errorMessage = string.Empty;
if (DIO.IsEmergencyOn() == true)
{
errorMessage = ("비상정지 상태일때에는 움직일 수 없습니다.");
return false;
}
//홈이 잡힌상태일때
if (PUB.mot.IsHomeSet((int)axis))
{
if (axis == eAxis.PX_PICK)
{
var Pos = MOT.GetPXPos(ePXLoc.PICKON);
var PosOffset = MOT.getPositionOffset(Pos);
if(AR.SETTING.Data.Log_Debug)
PUB.logDbg.Add($"X축 조그 중앙옵셋:{PosOffset:N3}");
if (MoveCW==false && PosOffset < -1) //좌측위치로 이동하는 경우
{
if(PUB.mot.IsHomeSet((int)eAxis.PL_MOVE))
{
var PosY = MOT.GetLMPos(eLMLoc.READY);
var PosYOffse = MOT.getPositionOffset(PosY);
if(PosYOffse < -1)
{
//프린터 Y축이 더 안쪽으로 들어와있으니 충돌할 수 있다.
errorMessage = "프린트(L) 축과 충돌 가능성 있음";
return false;
}
}
}
else if(MoveCW && PosOffset > 1) //우측으로 이동하는 경우
{
if (PUB.mot.IsHomeSet((int)eAxis.PR_MOVE))
{
var PosY = MOT.GetRMPos(eRMLoc.READY);
var PosYOffse = MOT.getPositionOffset(PosY);
if (PosYOffse < -1)
{
//프린터 Y축이 더 안쪽으로 들어와있으니 충돌할 수 있다.
errorMessage = "프린트(R) 축과 충돌 가능성 있음";
return false;
}
}
}
}
}
return true;
}
#region "Common Util"
/// <summary>
/// 지정한 축의 모델정보에서 해당 위치값을 찾아 반환 합니다
/// </summary>
/// <param name="axis"></param>
/// <param name="pos"></param>
/// <returns></returns>
private static sPositionData GetAxPos(eAxis axis, int pos)
{
return GetAxpos((int)axis, pos);
}
private static sPositionData GetAxpos(int axis, int pos)
{
var retval = new sPositionData();
retval.Clear();
if (PUB.Result.mModel == null || PUB.Result.mModel.isSet == false)
{
retval.Message = "모션 모델이 설정되어 있지 않습니다";
return retval;
}
if(axis >= PUB.Result.mModel.Position.Count)
{
retval.Message = $"모션 모델 (축)정보가 없습니다 ({axis}/{PUB.Result.mModel.Position.Count})";
return retval;
}
if (pos >= PUB.Result.mModel.Position[axis].Length)
{
retval.Message = $"모션 모델 (위치)정보가 없습니다 ({pos}/{PUB.Result.mModel.Position[axis].Length})";
return retval;
}
var data = PUB.Result.mModel.Position[axis][pos];
if (data.index == -1)
{
retval.Message = string.Format("축:{0})의 위치:{1} 의 값이 존재하지 않습니다", axis, pos);// "모션 모델이 설정되어 있지 않습니다";
return retval;
}
retval.Axis = axis; //220301
retval.Position = data.value;
retval.Speed = data.speed;
retval.Acc = data.acc;
//환경설정에서 저속모드로 설정했다면 지정된 속도로만 처리한다
if (AR.SETTING.Data.Enable_SpeedLimit == true)
retval.Speed = Math.Min(retval.Speed, AR.SETTING.Data.LimitSpeed);
////시스템설정의 속도 체크 220524
//var maxspeed = PUB.system.GetMaxSpeed;
//var motidx = (int)axis;
//if (motidx >= 0 && motidx < maxspeed.Length && maxspeed[motidx] > 0)
//{
// retval.Speed = Math.Min(retval.Speed, maxspeed[motidx]);
//}
////시스템설정의 가속도체크
//var maxAcc = PUB.system.GetMaxAcc;
//if (motidx >= 0 && motidx < maxAcc.Length && maxAcc[motidx] > 0)
//{
// retval.Acc = Math.Min(retval.Acc, maxAcc[motidx]);
//}
if (data.dcc < 1) retval.Dcc = retval.Acc;
else retval.Dcc = data.dcc;
//retval.isError = false;
retval.Message = string.Empty;
return retval;
}
/// <summary>
/// 지정축의 모션을 중지 합니다.
/// </summary>
/// <param name="axis"></param>
/// <param name="reason"></param>
/// <param name="estop"></param>
public static void Stop(eAxis axis, string reason, Boolean estop = false)
{
if (PUB.mot.IsInit == false) return;
if (PUB.mot.IsServAlarm((int)axis)) return;
PUB.mot.MoveStop(reason, (int)axis, estop);
}
//지정한 옵셋범위에 들어있는지 체크합니다.
static Boolean MatchPosition(double cpos, double tpos, double diff = 0.1)
{
var offset = Math.Abs(tpos - cpos);
return offset <= diff;
}
public static double getPositionOffset(eAxis axis, double cmdPos)
{
return getPositionOffset((int)axis, cmdPos);
}
/// <summary>
/// 현재위치에서 지정된 위치를 뺀 값입니다. +가 반환되면 현재 위치가 지정위치보다 멀리 있다는 뜻입니다.
/// </summary>
/// <param name="Pos"></param>
/// <returns></returns>
public static double getPositionOffset(sPositionData Pos)
{
return getPositionOffset(Pos.Axis, Pos.Position);
}
/// <summary>
/// 현재위치에서 지정된 위치를 뺀 값입니다. +가 반환되면 현재 위치가 지정위치보다 멀리 있다는 뜻입니다.
/// </summary>
/// <param name="axis"></param>
/// <param name="cmdPos"></param>
/// <returns></returns>
public static double getPositionOffset(int axis, double cmdPos)
{
var coffset = (PUB.mot.GetActPos((int)axis) - cmdPos);
return coffset;// return coffset < offset;
}
public static bool getPositionMatch(eAxis axis, double cmdPos, double offset = 0.1)
{
return getPositionMatch((int)axis, cmdPos, offset);
}
public static bool getPositionMatch(sPositionData pos, double offset = 0.1)
{
return getPositionMatch(pos.Axis, pos.Position, offset);
}
public static bool getPositionMatch(int axis, double cmdPos, double offset = 0.1)
{
var actpos = PUB.mot.GetActPos(axis);
var coffset = Math.Abs(actpos - cmdPos);
return coffset <= offset;
}
public static List<string> GetActiveLockList(eAxis axis, CInterLock Lck)
{
var locklist = new List<string>();
if (Lck.IsEmpty() == false)
{
for (int i = 0; i < Lck.Length; i++)
{
if (Lck.get(i))
{
var vStr = $"[{i}]";
vStr = ((eILock)i).ToString();
locklist.Add(vStr);
}
}
}
return locklist;
}
public static Boolean Home(string reason, eAxis axis_, Boolean useValidcheck = true)
{
string Message;
int axis = (int)axis_;
if (useValidcheck == true && !Home_Validation(axis_, out Message))
{
PUB.mot.RaiseMessage(string.Format("[{0}-Axis] Move Error : {1}", axis, Message), true);
return false;
}
var HomespdH = PUB.system_mot.GetHomeSpeedHigh;
var HomespdL = PUB.system_mot.GetHomeSpeedLow;
var homespdA = PUB.system_mot.GetHomeSpeedAcc;
var useOrgSensor = PUB.system_mot.GetUseOrigin;
//Pub.mot.Home(1, arDev.AzinAxt.eMotionDirection.Negative, arDev.AzinAxt.eSoftLimitStopMode.SStop, COMM.SETTING.Data.HZSpeed, COMM.SETTING.Data.HZAcc);
//Boolean useOrgSensor = !disable_org[axis]; // (axis_ != eAxis.Marking); //A센서는 ORG가 없으므로 NE센서만으로 처리해야 함
return PUB.mot.Home(reason, (short)axis, MOTION_DIRECTION.Negative,
STOPTYPE.EStop,
HomespdH[axis],
HomespdL[axis],
homespdA[axis],
useOrgSensor[axis]);
}
private static DateTime[] MotCmdtime = new DateTime[] { DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now };
private static double[] MotCmdPos = new double[] { 0, 0, 0, 0, 0, 0, 0, 0 };
public static Boolean Move(eAxis axis, sPositionData posdata)
{
return Move(axis, posdata.Position, posdata.Speed, posdata.Acc);
}
public static Boolean Move(sPositionData posdata)
{
return Move((eAxis)posdata.Axis, posdata);
}
public static Boolean Move(eAxis axis, double pos_mm, double speed, double acc = 1000, Boolean relative = false, Boolean validchk = true, Boolean UserInterLock = true)
{
//너무빠른시간 동작하지 못하게 한다
if (MotCmdPos[(int)axis] == pos_mm)
{
var ts = DateTime.Now - MotCmdtime[(int)axis];
if (ts.TotalMilliseconds < 1000)
{
//너무 빠르게 재시도하지 않게 한다 210115
Console.WriteLine("mot command skip : " + axis.ToString() + "pos:" + pos_mm.ToString() + " too short");
MotCmdtime[(int)axis] = DateTime.Now.AddMilliseconds(-1500);
return true;
}
else
{
MotCmdtime[(int)axis] = DateTime.Now;
MotCmdPos[(int)axis] = pos_mm;
}
}
else
{
MotCmdtime[(int)axis] = DateTime.Now;
MotCmdPos[(int)axis] = pos_mm;
}
//이동유효성검사
string Message;
if (validchk == true)
{
//현재위치보다 작으면 ccw
var isCW = pos_mm >= PUB.mot.GetActPos((int)axis);
if (!Move_Validation(axis, isCW, out Message))
{
PUB.log.AddE(string.Format("[{0}-Axis] Move Error : {1}", axis, Message));
//Pub.mot.RaiseMessage(, true);
return false;
}
}
//해당 축 ILOCK체크
if (UserInterLock)
{
//lock이 걸린경우 lock 걸린 항목을 모두 확인하면 좋다
var ilock = PUB.iLock[(int)axis];
if (ilock.IsEmpty() == false)
{
var locklist = MOT.GetActiveLockList(axis, ilock);
PUB.mot.ErrorMessage = $"{ilock.Tag} Interlock(" + string.Join(",", locklist) + ")";
//PUB.Result.SetResultMessage(eResult.MOTION, eECode.INTERLOCK, eNextStep.PAUSE, PUB.mot.ErrorMessage);
return false;
}
}
var pos_pulse = pos_mm;// *10;
var result = PUB.mot.Move((short)axis, pos_pulse, speed, acc, acc, relative, false, validchk);
if (!result) PUB.mot.RaiseMessage("Move(X) Error : " + PUB.mot.ErrorMessage, true);
return result;
}
public static Boolean JOG(int _Axis, MOTION_DIRECTION Dir, double _Vel, double _Acc, double _Dec, Boolean sCurve = false, Boolean EnableValidCheck = true, Boolean UserInterLock = true)
{
eAxis axis = (eAxis)_Axis;
//웨이퍼가 감지되는 상태일때 OPEN 되어있다면 이동하지 못하게 한다
if (EnableValidCheck == true)
{
var curpost = PUB.mot.GetActPos(_Axis);
var IsMoveCW = false;
IsMoveCW = Dir == MOTION_DIRECTION.Positive;
if (!Move_Validation(axis, IsMoveCW, out string Message))
{
PUB.log.AddE(string.Format("[{0}-Axis] JOG Error : {1}", axis, Message));
return false;
}
}
else PUB.log.AddAT($"조그이동시 유효성검사 해제(축:{axis})");
//해당 축 ILOCK체크
if (UserInterLock)
{
//lock이 걸린경우 lock 걸린 항목을 모두 확인하면 좋다
if (PUB.iLock[_Axis].IsEmpty() == false)
{
var locklist = MOT.GetActiveLockList(axis, PUB.iLock[_Axis]);
PUB.mot.ErrorMessage = $"{axis} Interlock(" + string.Join(",", locklist) + ")";
return false;
}
}
else PUB.log.AddAT($"조그이동시 인터락검사 해제(축:{axis})");
return PUB.mot.JOG(_Axis, Dir, _Vel, _Acc, sCurve, EnableValidCheck);
}
#endregion
}
}

486
Handler/Project/Util/Util_Vision.cs Normal file
View File

@@ -0,0 +1,486 @@
//using Emgu.CV;
//using Emgu.CV.CvEnum;
//using Emgu.CV.Structure;
//using Euresys.Open_eVision_2_11;
//using System;
//using System.Collections.Generic;
//using System.Drawing;
//using System.Linq;
//using System.Text;
//using System.Threading.Tasks;
//namespace Project
//{
// public static class Util_Vision
// {
// //private static object imageLockObj = new object();
// //public struct SCodeData
// //{
// // public Point[] corner;
// // public string data;
// // public string model;
// // public string version;
// // public string level;
// // public string sid;
// //}
// //public static void DisplayQRData(List<SCodeData> DataArr, Rectangle roi, arCtl.ImageBox iv)
// //{
// // iv.ClearShape();
// // foreach (var item in DataArr)
// // {
// // var p = new PointF[4];
// // p[0] = new PointF(item.corner[0].X + roi.Left, item.corner[0].Y + roi.Top);
// // p[1] = new PointF(item.corner[1].X + roi.Left, item.corner[1].Y + roi.Top);
// // p[2] = new PointF(item.corner[2].X + roi.Left, item.corner[2].Y + roi.Top);
// // p[3] = new PointF(item.corner[3].X + roi.Left, item.corner[3].Y + roi.Top);
// // iv.AddShapeLine(p[0], p[1], Color.Gold, false, 5);
// // iv.AddShapeLine(p[1], p[2], Color.Gold, false, 5);
// // iv.AddShapeLine(p[2], p[3], Color.Gold, false, 5);
// // iv.AddShapeLine(p[3], p[0], Color.Gold, false, 5);
// // if (item.data.isEmpty() == false)
// // {
// // iv.AddShapeText(item.corner[1], item.data, Color.Black, 200);
// // }
// // }
// //}
// /// <summary>
// /// 마스킹이적용된 이미지가 반환됩니다. 마스킹
// /// </summary>
// /// <param name="orgEImage"></param>
// /// <param name="Message"></param>
// /// <param name="iv"></param>
// /// <param name="reelsize"></param>
// /// <returns></returns>
// //public static EImageBW8 FindReelOutline(EImageBW8 orgEImage, out string Message, out PointF CenterPX, out float Diameter, arCtl.ImageBox iv = null, eCartSize reelsize = eCartSize.Inch7)
// //{
// // EImageBW8 retval = null;// new EImageBW8(orgEImage.Width, orgEImage.Height); //마스킹이적용된 이미지
// // Message = string.Empty;
// // CenterPX = PointF.Empty;
// // Diameter = 0;
// // //EWorldShape EWorldShape1 = new EWorldShape(); // EWorldShape instance
// // ECircleGauge ECircleGauge1 = new ECircleGauge(); // ECircleGauge instance
// // ECircle Circle1 = new ECircle(); // ECircle instance
// // ECircle measuredCircle = null; // ECircle instance
// // iv.ClearShape("OUTLINE");
// // try
// // {
// // // EBW8Image1.Load("C:\\temp\\b.bmp");
// // //ECircleGauge1.Attach(EWorldShape1);
// // ECircleGauge1.Dragable = true;
// // ECircleGauge1.Resizable = true;
// // ECircleGauge1.Rotatable = true;
// // // EWorldShape1.SetSensorSize(3289, 2406);
// // // EWorldShape1.Process(EBW8Image1, true);
// // ECircleGauge1.Thickness = 20;
// // ECircleGauge1.TransitionChoice = ETransitionChoice.NthFromEnd;
// // ECircleGauge1.FilteringThreshold = 3.00f;
// // ECircleGauge1.SetCenterXY(2000f, 1400f);
// // ECircleGauge1.Amplitude = 360f;
// // ECircleGauge1.Tolerance = 500;
// // ECircleGauge1.Diameter = 2200f;
// // ECircleGauge1.Threshold = 20;
// // ECircleGauge1.FilteringThreshold = 3.0f;
// // ECircleGauge1.Measure(orgEImage);
// // measuredCircle = ECircleGauge1.MeasuredCircle;
// // if (measuredCircle.CenterX < 1 && measuredCircle.CenterY < 1)
// // {
// // Message = "outline not found";
// // if (reelsize != eCartSize.None)
// // {
// // //마스크파일이 존재하면 해당 마스크를 사용한다
// // var maskfilname = "Mask" + reelsize.ToString() + ".bmp";
// // var filename = System.IO.Path.Combine(Util.CurrentPath, "Data", maskfilname);
// // if (System.IO.File.Exists(filename))
// // {
// // var maskimg = new EImageBW8(); // Image<Gray, byte>(filename);
// // maskimg.Load(filename);
// // retval = new EImageBW8(orgEImage.Width, orgEImage.Height);
// // EasyImage.Oper(EArithmeticLogicOperation.BitwiseAnd, orgEImage, maskimg, retval);
// // }
// // else Pub.log.AddE("마스크파일:" + maskfilname + "이존재하지 않아 사용하지 않습니다");
// // }
// // }
// // else
// // {
// // retval = new EImageBW8(orgEImage.Width, orgEImage.Height);
// // Diameter = measuredCircle.Diameter;
// // CenterPX = new PointF(measuredCircle.CenterX, measuredCircle.CenterY);
// // var rect = new RectangleF(CenterPX.X - Diameter / 2.0f, CenterPX.Y - Diameter / 2.0f, Diameter, Diameter);
// // var sh = iv.AddShapePoint(CenterPX.X, CenterPX.Y, 50, Color.Gold);
// // sh.Tag = "OUTLINE";
// // var shc = iv.AddShapeCircle(rect, Color.Lime, 50);
// // shc.Tag = "OUTLINE";
// // //찾은 영역을 제외하고 마스크를 만든다.
// // var dt = DateTime.Now;
// // var maskimg = new Image<Gray, byte>(orgEImage.Width, orgEImage.Height);
// // maskimg.SetZero();
// // CvInvoke.Circle(maskimg, new Point((int)measuredCircle.CenterX, (int)measuredCircle.CenterY), (int)(Diameter / 2.0f), new Gray(255).MCvScalar, -1);
// // //maskimg.Save(@"c:\temp\mask_" + dt.ToString("HHmmss") + ".bmp");
// // //마스크와 결합
// // var orgImage = new Image<Gray, byte>(orgEImage.Width, orgEImage.Height, orgEImage.RowPitch, orgEImage.GetImagePtr());
// // {
// // var retimg = new Image<Gray, byte>(retval.Width, retval.Height, retval.RowPitch, retval.GetImagePtr());
// // {
// // CvInvoke.BitwiseAnd(orgImage, maskimg, retimg);
// // }
// // }
// // //orgImage.Save(@"c:\temp\type1_src1_" + dt.ToString("HHmmss") + ".bmp");
// // //maskimg.Save(@"c:\temp\type1_src2_" + dt.ToString("HHmmss") + ".bmp");
// // //maskedimg.Save(@"c:\temp\type1_dest_" + dt.ToString("HHmmss") + ".bmp");
// // //iv.AddShapeBox(rect, Color.Tomato).Tag = "OUTLINE";
// // }
// // }
// // catch (EException ex)
// // {
// // // Insert exception handling code herem
// // Message = ex.Message;
// // }
// // if (iv != null) iv.Invalidate();
// // return retval;
// //}
// //public static PointF GetGainOffset(int idx)
// //{
// // if (idx == 0) return new PointF(1.0f, 0.0f);
// // else if (idx == 1) return new PointF(1.3f, 0.0f);
// // else if (idx == 2) return new PointF(0.7f, 0.0f);
// // else if (idx == 3) return new PointF(1.0f, 50.0f);
// // else if (idx == 4) return new PointF(1.0f, -50.0f);
// // else if (idx == 5) return new PointF(3.0f, 50.0f); //아주어두운이미지용
// // else if (idx == 6) return new PointF(0.5f, -20.0f); //아주밝은이미지용
// // //else if (idx == 7) return new PointF(1.0f, -150.0f); //밝은이미지용
// // //else if (idx == 8) return new PointF(1.0f, -170.0f); //밝은이미지용
// // //else if (idx == 9) return new PointF(1.0f, -190.0f); //밝은이미지용
// // else return new PointF(1f, 0f);
// //}
// //private static List<System.Drawing.PointF> GetGainOffsetList(string gainstr)
// //{
// // var retval = new List<System.Drawing.PointF>();
// // var list = gainstr.Split(';');
// // foreach (var item in list)
// // {
// // var ptitem = item.Split(',');
// // if (ptitem.Length == 2)
// // {
// // retval.Add(new System.Drawing.PointF(float.Parse(ptitem[0]), float.Parse(ptitem[1])));
// // }
// // }
// // return retval;
// //}
// //public static System.Collections.Generic.List<Util_Vision.SCodeData> DetectQR_eVision(
// // EImageBW8 EBW8Image4,
// // arCtl.ImageBox iv1, int idx,
// // out string Message,
// // string erodevaluestr = "3,1",
// // string gainoffsetlist = "2,1",
// // uint blob_area_min = 5000,
// // uint blob_area_max = 50000,
// // float blob_sigmaxy = 500f,
// // float blob_sigmayy = 500f,
// // float blob_sigmaxx = 5000f,
// // string maskfile = "",
// // Image<Bgr, byte> DispImage = null
// // )
// //{
// // Message = string.Empty;
// // var pts = new System.Collections.Generic.List<Util_Vision.SCodeData>();
// // System.Diagnostics.Stopwatch wat = new System.Diagnostics.Stopwatch();
// // wat.Restart();
// // //바코드리더
// // EQRCodeReader EQRCode1 = new EQRCodeReader(); // EQRCodeReader instance
// // EQRCode1.DetectionMethod = 15; //모든방법으로 데이터를 찾는다
// // EQRCode1.TimeOut = 1000 * 1000; //timeout (1초)
// // //Blob 으로 바코드영역을 찾는다
// // ECodedImage2 codedImage4 = new ECodedImage2(); // ECodedImage2 instance
// // EImageEncoder codedImage4Encoder = new EImageEncoder(); // EImageEncoder instance
// // EObjectSelection codedImage4ObjectSelection = new EObjectSelection(); //
// // codedImage4ObjectSelection.FeretAngle = 0.00f;
// // using (var psegment = codedImage4Encoder.GrayscaleSingleThresholdSegmenter) //.BlackLayerEncoded = true;
// // {
// // psegment.BlackLayerEncoded = true;
// // psegment.WhiteLayerEncoded = false;
// // psegment.Mode = EGrayscaleSingleThreshold.MaxEntropy;
// // }
// // //침식해서 바코드영역이 뭉치도록 한다. (바코드는 검은색 영역이 된다)
// // List<uint> erodevalues = new List<uint>();
// // var erodebuffer = erodevaluestr.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
// // foreach (var erbuf in erodebuffer) erodevalues.Add(uint.Parse(erbuf));
// // //마스크적용 - 210209
// // if (maskfile.isEmpty() == false && System.IO.File.Exists(maskfile))
// // {
// // using (var maskmig = new EImageBW8())
// // {
// // maskmig.Load(maskfile);//이미지불러오지
// // EasyImage.Oper(EArithmeticLogicOperation.BitwiseAnd, EBW8Image4, maskmig, EBW8Image4);
// // }
// // }
// // var GainOffsetList = GetGainOffsetList(gainoffsetlist);
// // uint objectCountT = 0;
// // for (int maxtype = 0; maxtype < 2; maxtype++)
// // {
// // //침식데이터도 여러개를 사용한다.
// // foreach (var erodevalue in erodevalues)
// // {
// // //인코딩된 이미지가 들어간다
// // var ErodeImageBW8 = new EImageBW8(EBW8Image4.Width, EBW8Image4.Height);
// // EasyImage.ErodeBox(EBW8Image4, ErodeImageBW8, erodevalue);
// // using (var psegment = codedImage4Encoder.GrayscaleSingleThresholdSegmenter)
// // {
// // if (maxtype == 0)
// // psegment.Mode = EGrayscaleSingleThreshold.MinResidue;
// // else if (maxtype == 1)
// // psegment.Mode = EGrayscaleSingleThreshold.MaxEntropy;
// // else if (maxtype == 2)
// // psegment.Mode = EGrayscaleSingleThreshold.IsoData;
// // }
// // codedImage4Encoder.Encode(ErodeImageBW8, codedImage4);
// // codedImage4ObjectSelection.Clear();
// // codedImage4ObjectSelection.AddObjects(codedImage4);
// // codedImage4ObjectSelection.AttachedImage = ErodeImageBW8;
// // //너무큰 개체를 제거한다.
// // codedImage4ObjectSelection.RemoveUsingUnsignedIntegerFeature(EFeature.Area, blob_area_min, ESingleThresholdMode.LessEqual);
// // codedImage4ObjectSelection.RemoveUsingUnsignedIntegerFeature(EFeature.Area, blob_area_max, ESingleThresholdMode.GreaterEqual);
// // //개체제거
// // codedImage4ObjectSelection.RemoveUsingFloatFeature(EFeature.SigmaXY, blob_sigmaxy, ESingleThresholdMode.GreaterEqual);
// // codedImage4ObjectSelection.RemoveUsingFloatFeature(EFeature.SigmaYY, blob_sigmayy, ESingleThresholdMode.LessEqual);
// // codedImage4ObjectSelection.RemoveUsingFloatFeature(EFeature.SigmaXX, blob_sigmaxx, ESingleThresholdMode.GreaterEqual);
// // //찾은데이터수량
// // var objectCount = codedImage4ObjectSelection.ElementCount;
// // objectCountT += objectCount;
// // //데이터표시
// // //찾은영역을 표시한다.
// // for (uint i = 0; i < objectCount; i++)
// // {
// // //각 요소를 가져와서 처리한다.
// // var CElement = codedImage4ObjectSelection.GetElement(i);
// // var sigXY = CElement.SigmaXY;
// // var sigYY = CElement.SigmaYY;
// // var rCnt = CElement.RunCount;
// // var rArea = CElement.Area;
// // var boxW = CElement.BoundingBoxWidth * COMM.SETTING.Data.RosRectScale;
// // var boxH = CElement.BoundingBoxHeight * COMM.SETTING.Data.RosRectScale; //좀더크게간다 210209
// // var boxCX = CElement.BoundingBoxCenterX;
// // var boxCY = CElement.BoundingBoxCenterY;
// // var boxRate = (boxW * 1.0) / boxH;
// // var rect = new RectangleF(boxCX - boxW / 2.0f, boxCY - boxH / 2.0f, boxW, boxH);
// // //외각상자를 표시한다
// // iv1.AddShapeBox(rect, Color.Tomato, 10);
// // if (DispImage != null)
// // CvInvoke.Rectangle(DispImage,
// // new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height),
// // new Bgr(Color.Tomato).MCvScalar, 2);
// // //해당영역을 ROI로 잡고 이미지를 검색한다
// // var RoiImage = new EROIBW8();
// // RoiImage.Attach(EBW8Image4);
// // //ROI로 사용할 영역의 오류를 체크해야한다
// // var rLeft = (int)rect.Left;
// // var rTop = (int)rect.Top;
// // var rWid = (int)rect.Width;
// // var rHei = (int)rect.Height;
// // //roi 오류수정 210621
// // if (rLeft < 2) rLeft = 1;
// // if (rTop < 2) rTop = 1;
// // if (rWid < 10) rWid = 10;
// // if (rHei < 10) rHei = 10;
// // if (rLeft + rWid > EBW8Image4.Width) rWid = EBW8Image4.Width - rLeft - 1;
// // if (rTop + rHei > EBW8Image4.Height) rHei = EBW8Image4.Height - rTop - 1;
// // var rourect = new Rectangle(rLeft, rTop, rWid, rHei);
// // RoiImage.SetPlacement(rourect.Left, rourect.Top, rourect.Width, rourect.Height); //ROI적용
// // var TargetImage = new EImageBW8(RoiImage.Width, RoiImage.Height);
// // //밝기를 변경해서 처리해야한다
// // //int processCount = 9;
// // foreach (var param in GainOffsetList) //원본, gain +-, offset +- 5가지 색상처리함
// // {
// // EasyImage.ScaleRotate(RoiImage, 0, 0, 0, 0, 1.0f, 1.0f, 0f, TargetImage);
// // //EasyImage.Copy(RoiImage, TargetImage);
// // //밝기를 변경해서 사용할 것이므로 해당 변경된 밝기를 저장할 이미지를 생성한다. 210128
// // //var roiimg = new EImageBW8(TargetImage);
// // //var param = Util_Vision.GetGainOffset(bright);
// // if (param.X != 1.0f || param.Y != 0.0f) EasyImage.GainOffset(TargetImage, TargetImage, param.X, param.Y);
// // //else RoiImage.CopyTo(TargetImage); ;// TargetImage.CopyTo(roiimg); //변경하지 않고 그대로 사용한다
// // //적용파일을 모두 저장해준다.
// // //var roifilename = @"c:\temp\roi_" + i.ToString() + "_g" + param.X.ToString() + "_o" + param.Y.ToString() + ".bmp";
// // //TargetImage.Save(roifilename);
// // EQRCode1.SearchField = TargetImage;
// // var EQRCode2Result = EQRCode1.Read();
// // for (int j = 0; j < EQRCode2Result.Length; j++)
// // {
// // var QrData = EQRCode2Result[j];
// // if (QrData.IsDecodingReliable)
// // {
// // var geo = QrData.Geometry;
// // var pos = geo.Position;
// // var cornous = pos.Corners;
// // var resultData = new Util_Vision.SCodeData();
// // //테두리좌표 읽기
// // var resultcorns = new List<Point>();
// // for (int k = 0; k < cornous.Length; k++)
// // {
// // var con = cornous[k];
// // resultcorns.Add(new Point((int)(con.X + rect.X), (int)(con.Y + rect.Y)));
// // con.Dispose();
// // }
// // resultData.corner = resultcorns.ToArray();
// // //데이터읽기
// // resultData.model = QrData.Model.ToString();
// // resultData.version = QrData.Version.ToString();
// // resultData.level = QrData.Level.ToString();
// // resultData.sid = string.Empty;
// // //바코드데이터확인
// // var decodestr = QrData.DecodedStream;
// // resultData.data = string.Empty;
// // foreach (var item in decodestr.DecodedStreamParts)
// // {
// // resultData.data += System.Text.Encoding.Default.GetString(item.DecodedData);
// // item.Dispose();
// // }
// // var c = new StdLabelPrint.CAmkorSTDBarcode(resultData.data);
// // if (c.isValid) resultData.sid = c.SID;
// // else resultData.sid = string.Empty;
// // //if (c.isValid) break;
// // //else resultData.data = string.Empty;
// // //결과데이터 추가
// // if (resultData.data.isEmpty() == false)
// // {
// // if (pts.Where(t => t.data == resultData.data).Any() == false)
// // {
// // pts.Add(resultData);
// // //자료가잇다면 표시한다.
// // var dispvalue = resultData.data;
// // if (c.isValid == false) dispvalue += "\n" + c.Message;
// // else if (c.DateError) dispvalue += "\n** Date Error **";
// // iv1.AddShapeText(resultcorns[1].X, resultcorns[1].Y, dispvalue, (c.isValid ? Color.Yellow : Color.Red), 50);
// // if (DispImage != null)
// // CvInvoke.PutText(DispImage,
// // dispvalue,
// // new Point(resultcorns[1].X, resultcorns[1].Y), FontFace.HersheyDuplex, 2,
// // new Bgr(Color.Tomato).MCvScalar, 2);
// // //찾은테두리를 화면에 표시한다.
// // foreach (var pt in resultcorns)
// // {
// // iv1.AddShapePoint(pt, 20f, Color.Lime);
// // if (DispImage != null)
// // {
// // CvInvoke.Line(DispImage,
// // new Point(pt.X - 10, pt.Y - 10),
// // new Point(pt.X + 10, pt.Y + 10),
// // new Bgr(Color.Lime).MCvScalar, 2);
// // CvInvoke.Line(DispImage,
// // new Point(pt.X + 10, pt.Y - 10),
// // new Point(pt.X - 10, pt.Y + 10),
// // new Bgr(Color.Lime).MCvScalar, 2);
// // }
// // }
// // }
// // }
// // decodestr.Dispose();
// // decodestr = null;
// // cornous = null;
// // pos.Dispose();
// // geo.Dispose();
// // }
// // QrData.Dispose();
// // }
// // }
// // TargetImage.Dispose();
// // TargetImage = null;
// // CElement.Dispose();
// // }
// // ErodeImageBW8.Dispose(); //침식된 이미지
// // }
// // }
// // EQRCode1.Dispose();
// // codedImage4ObjectSelection.Dispose(); //엔코더결과값소거
// // codedImage4Encoder.Dispose(); //엔코더소거
// // codedImage4.Dispose(); //코딩된이미지
// // wat.Stop();
// // //iv1.AddShapeText(50, 50, wat.ElapsedMilliseconds.ToString() + "ms", Color.Lime, 50f);
// // var mm = "[" + objectCountT.ToString() + "] " + wat.ElapsedMilliseconds.ToString() + "ms";
// // var mmpt = new Point(20, 30 + (idx * 140));
// // iv1.AddShapeText(mmpt.X, mmpt.Y, mm, Color.Lime, 100f);
// // if (DispImage != null)
// // {
// // mmpt.Offset(0, 150);
// // CvInvoke.PutText(DispImage, mm, mmpt, FontFace.HersheyDuplex, 6, new Bgr(Color.Lime).MCvScalar, 4);
// // mmpt.Offset(1100, 0);
// // CvInvoke.PutText(DispImage, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), mmpt, FontFace.HersheyDuplex, 6, new Bgr(Color.Gold).MCvScalar, 4);
// // }
// // iv1.Invalidate();
// // return pts;
// //}
// }
//}