From f2dbd0b9c9715ff552620967c4aa256f2bced9d2 Mon Sep 17 00:00:00 2001 From: chojy Date: Tue, 11 Jul 2023 00:54:54 +0000 Subject: [PATCH] Upload files to "" --- Barcode.cs | 220 ++ ClassDiagram1.cd | 1 + DataStore.cs | 8503 ++++++++++++++++++++++++++++++++++++++++++++++ ITC81DB.sln | 28 + ITC81DB.suo | Bin 0 -> 193024 bytes 5 files changed, 8752 insertions(+) create mode 100644 Barcode.cs create mode 100644 ClassDiagram1.cd create mode 100644 DataStore.cs create mode 100644 ITC81DB.sln create mode 100644 ITC81DB.suo diff --git a/Barcode.cs b/Barcode.cs new file mode 100644 index 0000000..25588b9 --- /dev/null +++ b/Barcode.cs @@ -0,0 +1,220 @@ +using System; +using System.Linq; +using System.Collections.ObjectModel; +using System.Collections.Generic; +using System.Text; + +namespace ITC81DB +{ + #region Enum + public enum BarcodeStatus + { + None, + Normal, + NoRead, + NoMatch, + } + #endregion + + public class BarcodeShortCut + { + public static readonly string MinAngle = "5362"; + public static readonly string MaxAngle = "5363"; + public static readonly string Frequency = "5364"; + public static readonly string ReadingPhaseTimeout = "78"; + public static readonly string Timeout = "79"; + public static readonly string ReadingConditions = "5250"; + } + + public class Barcode + { + #region Field + public static byte[] EnterHostMode = { 0x1B, 0x5B, 0x43 }; + public static byte[] EnterTerminalMode = { 0x1B, 0x5D, 0x42 }; + public static byte[] EnterProgrammingMode = { 0x1B, 0x63, 0x4D, 0xB0, 0x30 }; + public static byte[] ExitProgrammingMode = { 0x1B, 0x64, 0x4D, 0xB0, 0x30 }; + public static byte[] ExitTerminalMode = { 0x1B, 0x49, 0x41, 0x20 }; + public static byte[] ExitHostMode = { 0x1B, 0x5B, 0x41 }; + public static byte[] AutoExitCommandMode = { 0x1B, 0x5B, 0x41 }; + public static byte[] SavePermanently = { 0x45, 0x20, 0x50, 0x0D, 0x0A }; + + private bool m_IsCommandMode; // 현재 커맨드 모드인지 확인 + private int m_SaveValue; // 설정한 값 저장 변수 + private string m_SaveGettingShortCut; // 설정한 Getting ShortCut 변수 + private string m_SaveSettingShortCut; // 설정한 Setting ShortCut 변수 + + private Queue QueueBarcode; + private Collection CollectionLotNo; + #endregion + + #region Constructor + public Barcode(Collection items, int productCount) + { + this.DefaultSetting(productCount); + + for (int i = 0; i < productCount; i++) + this.CollectionLotNo[i] = items[i].LotNo; + } + #endregion + + #region Property + public bool IsCommandMode + { + get { return this.m_IsCommandMode; } + set { this.m_IsCommandMode = value; } + } + public int SaveValue + { + get { return this.m_SaveValue; } + set { this.m_SaveValue = value; } + } + public string SaveGettingShortCut + { + get { return this.m_SaveGettingShortCut; } + set { this.m_SaveGettingShortCut = value; } + } + public string SaveSettingShortCut + { + get { return this.m_SaveSettingShortCut; } + set { this.m_SaveSettingShortCut = value; } + } + + public int GetQueueCount + { + get + { + return this.QueueBarcode.Count; + } + } + #endregion + + #region Method + private void DefaultSetting(int barcodeCount) + { + this.IsCommandMode = false; + this.QueueBarcode = new Queue(); + + this.CollectionLotNo = new Collection(); + for (int i = 0; i < barcodeCount; i++) + this.CollectionLotNo.Add(""); + } + + public void SetLotNo(Collection items, int productCount) + { + for (int i = 0; i < productCount; i++) + this.CollectionLotNo[i] = items[i].LotNo; + } + public void SetData(string data) + { + //value = this.DecisionLength(data); + this.QueueBarcode.Enqueue(data); + } + public BarcodeStatus GetData(ref int productNo) + { + string value = ""; + BarcodeStatus ret = BarcodeStatus.None; + + if (this.QueueBarcode.Count > 0) + { + value = this.QueueBarcode.Peek(); + if (value.Length > 14) + value = value.Substring(value.Length - 14, 14); + + if (value == "NoRead") + { + productNo = 991; + return ret = BarcodeStatus.NoRead; + } + else + { + for (int i = 0; i < this.CollectionLotNo.Count; i++) + { + if (this.CollectionLotNo[i] == value) + { + productNo = i + 1; + return ret = BarcodeStatus.Normal; + } + } + + productNo = 992; + return ret = BarcodeStatus.NoMatch; + } + } + + productNo = 0; + return ret = BarcodeStatus.None; + } + public BarcodeStatus GetData(ref int productNo, int startIndex, int endIndex) + { + string value = ""; + BarcodeStatus ret = BarcodeStatus.None; + + if (this.QueueBarcode.Count > 0) + { + value = this.QueueBarcode.Peek(); + + if (value == "NoRead") + { + productNo = 991; + return ret = BarcodeStatus.NoRead; + } + else + { + int length = endIndex - startIndex + 1; + if(value.Length >= length) + value = value.Substring(startIndex, length); + if (value.Length > 14) + value = value.Substring(value.Length - 14, 14); + + for (int i = 0; i < this.CollectionLotNo.Count; i++) + { + if (this.CollectionLotNo[i] == value) + { + productNo = i + 1; + return ret = BarcodeStatus.Normal; + } + } + + productNo = 992; + return ret = BarcodeStatus.NoMatch; + } + } + + productNo = 0; + return ret = BarcodeStatus.None; + } + + /// + /// 바코드 길이를 14 이하로 결정 + /// + /// + /// string + private string DecisionLength(string barcode) + { + if (barcode.Length > 14) + return barcode.Substring(barcode.Length - 14, 14); + else + return barcode; + } + + public string BarcodePeek() + { + string ret = ""; + + if (this.QueueBarcode.Count > 0) + ret = this.QueueBarcode.Peek(); + + return ret; + } + public void BarcodeDequeue() + { + if (this.QueueBarcode.Count > 0) + this.QueueBarcode.Dequeue(); + } + public void Clear() + { + this.QueueBarcode.Clear(); + } + #endregion + } +} diff --git a/ClassDiagram1.cd b/ClassDiagram1.cd new file mode 100644 index 0000000..0519ecb --- /dev/null +++ b/ClassDiagram1.cd @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/DataStore.cs b/DataStore.cs new file mode 100644 index 0000000..cc7de8d --- /dev/null +++ b/DataStore.cs @@ -0,0 +1,8503 @@ +using System; +using System.Linq; +using System.Collections.ObjectModel; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +using InModbus; + +namespace ITC81DB +{ + public class DataStore + { + #region Enum + public enum EquipmentStatus + { + Stop = 0, + Start = 1, + } + + public enum DisplayMode + { + Normal, + Menu, + Calibration, + SystemSetting, + IOTest, + Bypass, + EquipmentTest, + SorterTest, + } + + public enum DisplayStore + { + MainDisplay, + + BasicDataBackup, + BasicDataStatistics, + BasicHelp, + BasicProduct, + BasicRandomMode, + BasicTime, + + ConfiCountingOutput, + ConfiSerial, + ConfiEthernet, + ConfiHelp, + ConfiOption, + ConfiOptionBoard, + ConfiSerialSeparate, + ConfiOptionBoard1, + ConfiOptionBoard2, + + EquipHelp, + EquipInitialize, + EquipUpdate, + EquipFuctionSetting, + EquipUser, + EquipTest, + EquipEngineer, + EquipSystemLog, + + InforAS, + InforHelp, + InforSystem, + InforSystem2, + InforSystem3, + + SystemAutoZero, + SystemCalibration, + SystemHelp, + SystemIOTest, + SystemJudgmentManual, + SystemJudgmentUpdown, + SystemExternalOutput, + SystemSorterSetting, + SystemJudgmentAuto, + SystemJudgmentSelect, + SystemExternalInput, + } + + public enum FormStore + { + FormNone = 0, + FormMainDisplay, + FormMenu, + ControlConversion, + } + + public enum MainDisplayStore + { + //DisplayStop, + BarGraph, + LineGraph, + List, + ListForRFID, + DataStat, + SpotCheck, + SubMenu, + Feedback, + AverageTracking, + Modbus, + } + + public enum MenuSide + { + Basic, + Configuration, + System, + Equipment, + Information, + HiddenMenu, + } + + public enum MenuBottomBasic + { + DataBackup, + DataStatistics, + Help, + Product, + Time, + } + + public enum MenuBottomConfiguration + { + CountingOutput, + SerialCOM1, + SerialCOM3, + SerialCOM4, + Ethernet, + Help, + Option, + OptionBoard, + } + + public enum MenuBottomEquipment + { + FunctionSetting, + Help, + Initialize, + Test, + Update, + User, + Engineer, + SystemLog, + } + + public enum MenuBottomSystem + { + AutoZero, + Calibration, + ExternalOutput, + Help, + IOTest, + JudgmentSetting, + SorterSetting, + ExternalInput, + } + + public enum MenuBottomInformation + { + Help, + SystemInformation, + AS, + SystemInformation2, + SystemInformation3, + } + + public enum LanguageID + { + Korean, + English, + German, + Chinese, + Russian, + Spanish, + Czech, + } + + public enum JudgmentStatus + { + Empty, + Under, + Pass, + Over, + Double, + Metal, + ExNg, + ExNg1, // 외부입력 PIN5 + ExNg2, // 외부입력 Photo B + LengthError, // 제품길이 이상 + } + + public enum WeightStatus + { + Empty, + WeightChange, + WeightZero, + CalNomal, + CalBalans, + CalStandby, + CalFinish, + CalError, + } + + public enum UserGroup + { + None = 0, + Level1Operator, + Level2Engineer, + Level3Manager, + Level4Developer, + NotLogin, + LogOut, + } + + public enum ResponseData + { + NAK = 0, + ACK = 1, + } + + public enum UpdateCheck + { + Fail, + Success, + NotUsbMomery, + NotUpdateFolder, + NotFile, + } + + public enum WeightInputMode + { + Weight, + Deviation, + } + + public enum Step2 + { + Step1, + Step2, + } + + public enum Step3 + { + Step1, + Step2, + Step3, + } + + public enum Step4 + { + Step1, + Step2, + Step3, + Step4, + } + + public enum Step5 + { + Step1 = 1, + Step2 = 2, + Step3 = 3, + Step4 = 4, + Step5 = 5, + } + + public enum SeparateType + { + STXANDETX, + ETXONLY, + NONEFRAME_READTIMEOUT, + STXONLY, + } + + public enum EnumFileUserPassword + { + f0_Level1 = 0, + f1_Level2 = 1, + f2_Level3 = 2, + } + + public enum EnumFileUserGroup + { + f0_Level1 = 0, + f1_Level2 = 1, + f2_Level3 = 2, + f3_NotLogin = 3, + } + + public enum JudgmentResult + { + None, + OK, + NG, + STOP, // 정지 + Timeout, // 타임아웃 + } + + public enum CharValue + { + ENQ, // 0x05 + ACK, // 0x06 + NAK, // 0x15 + Space, // 0x20 + } + + public enum SerialCOM + { + COM1 = 0, + COM3 = 1, + COM4 = 2, + } + + public enum SerialMode + { + f0_None = 0, + f1_STD1, + f2_Remote, + f3_Printer, + f4_imaje_9410_OPT1, + f5_imaje_9028_OPT1 = 5, + f6_OPT0, + f7_imaje_9410_OPT2, + f8_imaje_9028_OPT2, + f9_Hitachi, + f10_MACSA_Laser = 10, + f11_Markoprint, + f12_alphaJET, + f13_Marking_VJ1510, + f14_OPT1, + f15_OPT2 = 15, + f16_OPC, + f17_OPT3, + f18_HP_200, + f19_SmartJet, + f20_imaje_9410_OPT3 = 20, + f21_Impinj_Speedway_R420 = 21, // RFID + f22_Modbus_RTU, + f23_STD2, + f24_MULTi_JET, + f25_DJ_VIDEOJET, + f26_LINX8830, + f27_MYJET, + f28_OPT4, + } + + public enum EthernetMode + { + f0_None = 0, + f1_STD1, + f2_Remote, + f3_Printer, + f4_imaje_9410_OPT1, + f5_imaje_9028_OPT1 = 5, + f6_OPT0, + f7_imaje_9410_OPT2, + f8_imaje_9028_OPT2, + f9_Hitachi, + f10_MACSA_Laser = 10, + f11_Markoprint, + f12_alphaJET, + f13_Marking_VJ1510, + f14_OPT1, + f15_OPT2 = 15, + f16_OPC, + f17_OPT3, + f18_HP_200, + f19_SmartJet, + f20_imaje_9410_OPT3 = 20, + f21_Impinj_Speedway_R420 = 21, // RFID + f22_Modbus_TCP, + f23_STD2, + f24_MULTi_JET, + f25_DJ_VIDEOJET, + f26_LINX8830, + f27_MYJET, + f28_OPT4, + } + + public enum ExternalInputMode + { + IN0_None, + IN1_Metal, + IN2_START, + IN3_STOP, + IN4_DischargeSorterA, + IN5_Air = 5, + IN6_Door, + IN7_Stopper, + IN8_Windproof, + IN9_ExternalOperation, + IN10_DispensorEntry1 = 10, + IN11_DispensorEntry2, + IN12_StackUp, + IN13_ExNG1, + IN14_ExNG2, + IN15_ExInputCheck, + IN16_DischargeSorterB, + } + + public enum ExternalOutputMode + { + OUT0_None, + OUT1_Over, + OUT2_Under, + OUT3_NG, + OUT4_Pass, + OUT5_Run, + OUT6_Count, + OUT7_CountingOutput1, + OUT8_CountingOutput2, + OUT9_ExNG, + OUT10_LatchControl = 10, + OUT11_Stopper, + OUT12_ExternalInput, + OUT13_Alarm_Level, + OUT14_Alarm_Pulse, + } + + public enum ModbusFunction + { + _04_ReadInputRegister, + _16_WriteMultipleRegister, + _03_ReadHoldingRegister, + } + #endregion + } + + #region AlarmList + public class AlarmList + { + #region Field + private bool m_Flag; + + private bool m_IsLoadCellError; + private bool m_IsEntrySensorError; + private bool m_IsInverterError; + private bool m_IsPressureSensingError; + private bool m_IsEmergencyStop; + private bool m_IsDoorInterlock; + private bool m_IsSorterAError; + private bool m_IsStackUpSensorError; + private bool m_IsWindProofError; + private bool m_IsSorterBError; + private bool m_IsEntryNotDetected; + #endregion + + #region Constructor + public AlarmList() + { + this.Initialize(); + } + #endregion + + #region Property + public bool Flag + { + get { return this.m_Flag; } + set { this.m_Flag = value; } + } + + public bool IsLoadCellError + { + get { return this.m_IsLoadCellError; } + set { this.m_IsLoadCellError = value; } + } + public bool IsEntrySensorError + { + get { return this.m_IsEntrySensorError; } + set { this.m_IsEntrySensorError = value; } + } + public bool IsInverterError + { + get { return this.m_IsInverterError; } + set { this.m_IsInverterError = value; } + } + public bool IsPressureSensingError + { + get { return this.m_IsPressureSensingError; } + set { this.m_IsPressureSensingError = value; } + } + public bool IsEmergencyStop + { + get { return this.m_IsEmergencyStop; } + set { this.m_IsEmergencyStop = value; } + } + public bool IsDoorInterlock + { + get { return this.m_IsDoorInterlock; } + set { this.m_IsDoorInterlock = value; } + } + public bool IsSorterAError + { + get { return this.m_IsSorterAError; } + set { this.m_IsSorterAError = value; } + } + public bool IsStackUpSensorError + { + get { return this.m_IsStackUpSensorError; } + set { this.m_IsStackUpSensorError = value; } + } + public bool IsWindProofError + { + get { return this.m_IsWindProofError; } + set { this.m_IsWindProofError = value; } + } + public bool IsSorterBError + { + get { return this.m_IsSorterBError; } + set { this.m_IsSorterBError = value; } + } + public bool IsEntryNotDetected + { + get { return this.m_IsEntryNotDetected; } + set { this.m_IsEntryNotDetected = value; } + } + #endregion + + #region Method + private void Initialize() + { + this.Flag = false; + + this.IsLoadCellError = false; + this.IsEntrySensorError = false; + this.IsInverterError = false; + this.IsPressureSensingError = false; + this.IsEmergencyStop = false; + this.IsDoorInterlock = false; + this.IsSorterAError = false; + this.IsStackUpSensorError = false; + this.IsWindProofError = false; + this.IsSorterBError = false; + this.IsEntryNotDetected = false; + } + + public bool IsAlarmOccured(string alarm) + { + bool occur = false; + + if (alarm != "00000000") + occur = true; + + return occur; + } + public void SetAlarm(string alarm) + { + string sValue1 = "", sValue2 = "", sValue3 = "", sValue4 = "", sValue5 = "", sValue6 = "", sValue7 = "", sValue8 = ""; + + this.Flag = false; + + if (alarm.Length != 8) + return; + + sValue1 = Convert.ToString(Convert.ToInt16(alarm.Substring(0, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue2 = Convert.ToString(Convert.ToInt16(alarm.Substring(1, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue3 = Convert.ToString(Convert.ToInt16(alarm.Substring(2, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue4 = Convert.ToString(Convert.ToInt16(alarm.Substring(3, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue5 = Convert.ToString(Convert.ToInt16(alarm.Substring(4, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue6 = Convert.ToString(Convert.ToInt16(alarm.Substring(5, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue7 = Convert.ToString(Convert.ToInt16(alarm.Substring(6, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + sValue8 = Convert.ToString(Convert.ToInt16(alarm.Substring(7, 1), 16), 2).PadLeft((4 <= 1) ? 1 : 4, '0'); + + // 알람 20- + if (sValue5[0] == '0') + { } + else + { } + // 알람 19- + if (sValue5[1] == '0') + { } + else + { } + // 알람 18-제품진입 미감지 + if (sValue5[2] == '0') + this.IsEntryNotDetected = false; + else + { + this.IsEntryNotDetected = true; + this.Flag = true; + } + // 알람 17-사용X + if (sValue5[3] == '0') + { } + else + { } + + // 알람 16- + if (sValue4[0] == '0') + { } + else + { } + // 알람 15- + if (sValue4[1] == '0') + { } + else + { } + // 알람 14-배출센서 B + if (sValue4[2] == '0') + this.IsSorterBError = false; + else + { + this.IsSorterBError = true; + this.Flag = true; + } + // 알람 13-방풍커버열림 + if (sValue4[3] == '0') + this.IsWindProofError = false; + else + { + this.IsWindProofError = true; + this.Flag = true; + } + + // 알람 12-서보알람토크 + if (sValue3[0] == '0') + { } + else + { } + // 알람 11-통신에러 + if (sValue3[1] == '0') + { } + else + { } + // 알람 10-서보알람 + if (sValue3[2] == '0') + { } + else + { } + // 알람 9-인버터알람 + if (sValue3[3] == '0') + this.IsInverterError = false; + else + { + this.IsInverterError = true; + this.Flag = true; + } + + // 알람 8-비상정지 + if (sValue2[0] == '0') + this.IsEmergencyStop = false; + else + { + this.IsEmergencyStop = true; + this.Flag = true; + } + // 알람 7-리젝터알람(배출센서 A) + if (sValue2[1] == '0') + this.IsSorterAError = false; + else + { + this.IsSorterAError = true; + this.Flag = true; + } + // 알람 6-적체센서 + if (sValue2[2] == '0') + this.IsStackUpSensorError = false; + else + { + this.IsStackUpSensorError = true; + this.Flag = true; + } + // 알람 5-입력센서2(넘어짐) + if (sValue2[3] == '0') + { } + else + { } + + // 알람 4-도어알람 + if (sValue1[0] == '0') + this.IsDoorInterlock = false; + else + { + this.IsDoorInterlock = true; + this.Flag = true; + } + // 알람 3-공압에러 + if (sValue1[1] == '0') + this.IsPressureSensingError = false; + else + { + this.IsPressureSensingError = true; + this.Flag = true; + } + // 알람 2-셀 에러 + if (sValue1[2] == '0') + this.IsLoadCellError = false; + else + { + this.IsLoadCellError = true; + this.Flag = true; + } + + // 알람 1-입력센서 에러 + if (sValue1[3] == '0') + this.IsEntrySensorError = false; + else + { + this.IsEntrySensorError = true; + this.Flag = true; + } + } + #endregion + } + #endregion + + #region SerialData + public class SerialData + { + public static readonly char STX = Convert.ToChar(0x02); + public static readonly char ETX = Convert.ToChar(0x03); + public static readonly char ETXs1 = Convert.ToChar(0x0D); + public static readonly char ETXs2 = Convert.ToChar(0x0A); + public static readonly char[] CharSaperate = { (char)0x0D, (char)0x0A }; + } + #endregion + + #region CommunicationCommand + public class CommunicationCommand + { + // 불량알람(레벨) + public static readonly string AlarmNgLevel = "Caa00"; + // 불량알람 해지 + public static readonly string AlarmNgClear = "CAA00"; + // 불량알람(펄스) + public static readonly string AlarmPulse = "Cac00"; + // 부저ON(부저ON시간과 연동) + public static readonly string BuzzerOn = "Cad00"; + // 부저ON(연속) + public static readonly string BuzzerOnContinuousEnable = "Cae00"; + // 외부출력ON(연속) + public static readonly string ExternalOutputContinuousEnable = "Cai00"; + // 부저해지 + public static readonly string BuzzerOnContinuousDisable = "CAE00"; + // 선별기알람해지 + public static readonly string AlarmNgClearSorter = "CA700"; + // 카운팅출력1(펄스) + public static readonly string CountingOutput1Pulse = "Caf00"; + // 카운팅출력2(펄스) + public static readonly string CountingOutput2Pulse = "Cag00"; + // 램프ON(연속, 적색/황색 점등) + public static readonly string LampOnContinuousEnable = "Cah00"; + // 램프해지 + public static readonly string LampOnContinuousDisable = "CAH00"; + // 외부출력 해지 + public static readonly string ExternalOutputContinuousDisable = "CAI00"; + + // 중량조정모드 + public static readonly string ModeCalibration = "Csc00"; + // 노멀모드 + public static readonly string ModeNormal = "Csn00"; + // 메뉴 모드 + public static readonly string ModeMenu = "Csm00"; + // 판정설정모드 + public static readonly string ModeJudgment = "Csg00"; + // IO 테스트모드 + public static readonly string ModeIOTest = "Cst00"; + // 바이패스 + public static readonly string ModeBypass = "Csb00"; + // 장비 테스트모드 + public static readonly string ModeEquipmentTest = "Csy00"; + // 선별기 테스트모드 + public static readonly string ModeRejectorTest = "Csr00"; + + // 중량조정 - 분동 + public static readonly string CalibrationBalance = "Ccb00"; + // 중량조정 - 시작 + public static readonly string CalibrationStart = "Ccs00"; + // 중량조정 - 취소 + public static readonly string CalibrationCancel = "Ccx00"; + // 중량보정 - 한자리올림 + public static readonly string CalibrationUp = "Ccu00"; + // 중량보정 - 한자리내림 + public static readonly string CalibrationDown = "Ccd00"; + + // 파라미터 쓰기 + public static readonly string Write = "Pw000"; + // 파라미터 읽기 + public static readonly string Read = "Pr000"; + // Bypass To Motor + public static readonly string BypassToMotor = "Pb000"; + // IO테스트 - OUT + public static readonly string IOTest = "Pt000"; + + // 임펠러 모터 - 정회전 + public static readonly string ImpellerMotorForward = "Cmc00"; + // 임펠러 모터 - 역회전 + public static readonly string ImpellerMotorReverse = "Cmr00"; + // 모터 - 원점초기화 + public static readonly string MotorOrigin = "Cmo00"; + // 모터 - Step + public static readonly string MotorStep = "Cms00"; + // 업다운 - 다운 + public static readonly string MotorDown = "Cmd00"; + // 업다운 - 업 + public static readonly string MotorUp = "Cmu00"; + // 모터 - 업2 + public static readonly string MotorUp2 = "Cmp00"; + + // Cut 신호 + public static readonly string CutInpupt = "Cbc00"; + // 공장초기화 + public static readonly string Initialization = "Cbi00"; + // 외부출력(Pulse) + public static readonly string ExternalOutput = "Cbd00"; + // 운전 + public static readonly string Start = "Cbs00"; + // 정지 + public static readonly string Stop = "Cbt00"; + // 영점 + public static readonly string Zero = "Cbz00"; + // 소거 + public static readonly string Clear = "Cbe00"; + // Output 제어 + public static readonly string Output = "Cbd00"; + + // ACK + public static readonly string ACK = "ACK"; + // NAK + public static readonly string NAK = "NAK"; + // 운전중 중량 + public static readonly string RunWeightData = "Sr"; + + // 카운팅출력 - 통신에러 + public static readonly string CountingOutputClearCommunicationError = "Cra00"; + + // 기타NG + public static readonly string JudgmentExternalNG = "Cja00"; + + // 판정 - bypass 1회 + public static readonly string BypassOnce = "Cjb00"; + // 판정 - byNG 1회 + public static readonly string ByNGOnce = "Cjc00"; + // 판정 - bypass 연속 OFF + public static readonly string BypassOFF = "Cjd00"; + // 판정 - bypass 연속 ON + public static readonly string BypassON = "Cjd01"; + // 판정 - byNG 연속 OFF + public static readonly string ByNGOFF = "Cje00"; + // 판정 - byNG 연속 ON + public static readonly string ByNGON = "Cje01"; + } + public class CommunicationID + { + public static readonly string MainBoard = "0"; + public static readonly string SubBoard1 = "A"; + public static readonly string SubBoard2 = "B"; + public static readonly string SubBoard3 = "C"; + public static readonly string SubBoard4 = "D"; + public static readonly string SubBoard5 = "E"; + public static readonly string SubBoard6 = "F"; + public static readonly string SubBoard7 = "G"; + public static readonly string SubBoard8 = "H"; + public static readonly string SubBoard9 = "I"; + public static readonly string SubBoard10 = "J"; + public static readonly string SubBoard11 = "K"; + public static readonly string SubBoard12 = "L"; + public static readonly string SubBoardAll = "Z"; + } + public class CommunicationAddress + { + // Address None + public static readonly string None = "0000"; + + // 장비타입 + public static readonly string EquipmentType = "1002"; + + // 임펠러 모터 - 회전각도 + public static readonly string ImpellerMotorAngle = "1101"; + // 임펠러 모터 - 통신속도 + public static readonly string ImpellerMotorBaudrate = "1102"; + // 임펠러 모터 - 회전방향 + public static readonly string ImpellerMotorDirection = "1103"; + // 바이패스 + public static readonly string Bypass = "1201"; + // 정지계량 사용 여부 + public static readonly string IsStopWeighing = "1401"; + // OPT(옵션보드) 사용 + public static readonly string OptionBoard = "1402"; + // 외부운전 사용 여부 + public static readonly string IsExternalOperation = "1403"; + // 초기구동 사용 여부 + public static readonly string IsInitialDrive = "1404"; + // 공기압감지 사용 여부 + public static readonly string IsPressureSensing = "1405"; + // 적체센서 사용 여부 + public static readonly string IsStackSensing = "1406"; + // 선별부 동작감지 사용 여부 + public static readonly string IsSorterDetecting = "1407"; + // 진입 스토퍼 사용 여부 + public static readonly string IsEntryStopper = "1408"; + // 품번선별 기능 사용 여부 + public static readonly string IsSortByProductNo = "1409"; + // 인버터 선택(미쯔비시, LS산전) + public static readonly string Inverter = "1410"; + // PI2 + public static readonly string PI2 = "1421"; + // PI3 + public static readonly string PI3 = "1422"; + // PI4 + public static readonly string PI4 = "1423"; + // PI5 + public static readonly string PI5 = "1424"; + // PI6 + public static readonly string PI6 = "1425"; + // PI7 + public static readonly string PI7 = "1426"; + // PI8 + public static readonly string PI8 = "1427"; + // 메인보드1 버전 읽기 + public static readonly string ProgramVersion = "1501"; + + // 품목설정 - 품번 + public static readonly string ProductNumber = "2001"; + // 품목설정 - 하한 설정값 + public static readonly string UnderRange = "2002"; + // 품목설정 - 기준 설정값 + public static readonly string PassRange = "2003"; + // 품목설정 - 상한 설정값 + public static readonly string OverRange = "2004"; + // 품목설정 - 용기 설정값 + public static readonly string TareRange = "2005"; + // 품목설정 - 센서검출시간 + public static readonly string SensingTime = "2020"; + + // 중량조정 - 최대중량 설정값 + public static readonly string MaxWeight = "3001"; + // 중량조정 - 분동중량 설정값 + public static readonly string BalanceWeight = "3002"; + // 중량조정 - 한눈의 값 + public static readonly string Digit = "3003"; + // 중량조정 - 상수값 읽기 + public static readonly string ReadConstant = "3601"; + // 중량조정 - 파라미터 읽기 + public static readonly string ParameterRead3901 = "3901"; + + // 자동영점 - 모드1 시간 + public static readonly string Zero1Time = "4001"; + // 자동영점 - 모드1 범위 + public static readonly string Zero1Range = "4002"; + // 자동영점 - 모드1 변량 + public static readonly string Zero1Variate = "4003"; + // 자동영점 - 모드1 모드 + public static readonly string Zero1Mode = "4004"; + // 자동영점 - 모드2 모드 + public static readonly string Zero2Mode = "4005"; + // 자동영점 - 모드2 시간 + public static readonly string Zero2Time = "4006"; + // 자동영점 - 모드2 범위 + public static readonly string Zero2Range = "4007"; + // 자동영점 - 모드2 변량 + public static readonly string Zero2Variate = "4008"; + + // 자동영점 - 모드1 파라미터 읽기 + public static readonly string ParameterRead4901 = "4901"; + // 자동영점 - 모드2 파라미터 읽기 + public static readonly string ParameterRead4902 = "4902"; + + // 판정설정 - 필터 + public static readonly string Filter = "5001"; + // 판정설정 - 판정지연 + public static readonly string JudgmentDelayTime = "5002"; + // 판정설정 - 이중지연 + public static readonly string DoubleDelayTime = "5003"; + // 판정설정 - 판정개수 + public static readonly string JudgmentCount = "5004"; + // 판정설정 - 이송속도 + public static readonly string FeedSpeed = "5005"; + // 판정설정 - 동보정 + public static readonly string DynamicCorrection = "5006"; + // 판정설정 - Feeding 컨베어 지연시간 + public static readonly string FeedingConveyorDelayTime = "5007"; + // 판정설정 - Feeding 컨베어 동작시간 + public static readonly string FeedingConveyorRunTime = "5008"; + // 판정설정 - 배출 컨베어 지연시간 + public static readonly string DischargeConveyorDelayTime = "5009"; + // 판정설정 - 배출 컨베어 동작시간 + public static readonly string DischargeConveyorRunTime = "5010"; + // 판정설정 - 자동판정 - 센서 검출 시간 읽기 + public static readonly string ReadSensingTime = "5057"; + // 판정설정 - 자동판정 - 필터갭 + public static readonly string FilterGap = "5058"; + // 판정설정 - 상승 지연시간 + public static readonly string AscendDelayTime = "5011"; + // 판정설정 - 하강 지연시간 + public static readonly string DescendDelayTime = "5012"; + // 판정설정 - 선별기 테스트 + public static readonly string SorterTest = "5100"; + // 판정설정 - 선별기1 모드 값 + public static readonly string Sorter1Mode = "5101"; + // 판정설정 - 선별기1 지연시간 + public static readonly string Sorter1DelayTime = "5102"; + // 판정설정 - 선별기1 동작시간 + public static readonly string Sorter1RunTime = "5103"; + // 판정설정 - 선별기2 모드 값 + public static readonly string Sorter2Mode = "5104"; + // 판정설정 - 선별기2 지연시간 + public static readonly string Sorter2DelayTime = "5105"; + // 판정설정 - 선별기2 동작시간 + public static readonly string Sorter2RunTime = "5106"; + // 판정설정 - 외부출력1 모드 + public static readonly string ExternalOut1Mode = "5201"; + // 판정설정 - 외부출력1 지연시간 + public static readonly string ExternalOut1DelayTime = "5202"; + // 판정설정 - 외부출력1 동작시간 + public static readonly string ExternalOut1RunTime = "5203"; + // 판정설정 - 외부출력2 모드 + public static readonly string ExternalOut2Mode = "5204"; + // 판정설정 - 외부출력2 지연시간 + public static readonly string ExternalOut2DelayTime = "5205"; + // 판정설정 - 외부출력2 동작시간 + public static readonly string ExternalOut2RunTime = "5206"; + // 판정설정 - 외부출력3 모드 + public static readonly string ExternalOut3Mode = "5207"; + // 판정설정 - 외부출력3 지연시간 + public static readonly string ExternalOut3DelayTime = "5208"; + // 판정설정 - 외부출력3 동작시간 + public static readonly string ExternalOut3RunTime = "5209"; + // 판정설정 - 외부출력4 모드 + public static readonly string ExternalOut4Mode = "5210"; + // 판정설정 - 외부출력4 지연시간 + public static readonly string ExternalOut4DelayTime = "5211"; + // 판정설정 - 외부출력4 동작시간 + public static readonly string ExternalOut4RunTime = "5212"; + // 판정설정 - 외부출력9 모드 + public static readonly string ExternalOut9Mode = "5225"; + // 판정설정 - 외부출력9 지연시간 + public static readonly string ExternalOut9DelayTime = "5226"; + // 판정설정 - 외부출력9 동작시간 + public static readonly string ExternalOut9RunTime = "5227"; + // 판정설정 - 외부출력10 모드 + public static readonly string ExternalOut10Mode = "5228"; + // 판정설정 - 외부출력10 지연시간 + public static readonly string ExternalOut10DelayTime = "5229"; + // 판정설정 - 외부출력10 동작시간 + public static readonly string ExternalOut10RunTime = "5230"; + // 판정설정 - 파라미터 읽기 + public static readonly string ParameterRead5901 = "5901"; + // 판정설정 - 스타휠 회전주기 + public static readonly string WheelCycleTime = "5301"; + // 판정설정 - 스타휠 슬롯개수 + public static readonly string WheelSlotCount = "5302"; + // 판정설정 - 스타휠 슬롯배출지연개수 + public static readonly string WheelSlotOutCount = "5303"; + // 판정설정 - 진입센서 지연시간 + public static readonly string EntrySensorDelayTime = "5304"; + // 판정설정 - 서보드라이버 토크제한 + public static readonly string ServoTorque = "5351"; + // 판정설정 - 서보드라이버 회전속도 + public static readonly string ServoSpeed = "5352"; + // 판정설정 - 원점옵셋 + public static readonly string ServoOffset = "5353"; + // 판정설정 - 사용자정의1(선별기1모드,지연,동작,선별기2모드,지연,동작) + public static readonly string UserDefined1 = "5901"; + + // 옵션 - 부저 ON시간 + public static readonly string BuzzerOnTime = "6001"; + // 옵션 - 릴레이 동작시간 + public static readonly string RelayRunTime = "6002"; + // 옵션 - 이중진입사용여부 + public static readonly string DoubleEnter = "6005"; + // 옵션 - 채터링감지 설정 + public static readonly string Chattering = "6006"; + // 옵션 - 외부 NG 입력 사용 + public static readonly string ExternalInput = "6007"; + // 옵션 - 기타 NG 사용 + public static readonly string ExternalNG = "6008"; + // 옵션 - 제품길이 이상 시 선별 + public static readonly string SortingWhenNGLength = "6009"; + // 옵션 - 제품진입 미감지 + public static readonly string EntryNotDetectedWeight = "6010"; + // 옵션 - OPT1_샘플링개수 + public static readonly string OPT1SamplingCount = "6201"; + // 옵션 - OPT1_지연개수 + public static readonly string OPT1DelayCount = "6202"; + // 옵션 - OPT1_펄스폭 + public static readonly string OPT1PulseWidth = "6203"; + // 옵션 - OPT1_범위설정사용여부 + public static readonly string OPT1RangeSetting = "6204"; + // 옵션 - OPT1_상한범위 + public static readonly string OPT1OverRange = "6205"; + // 옵션 - OPT1_하한범위 + public static readonly string OPT1UnderRange = "6206"; + // 옵션 - OPT1_포트 + public static readonly string OPT1Port = "6207"; + // 옵션 - OPT2_포트 + public static readonly string OPT2Port = "6231"; + // 옵션 - OPT2_지연시간1 + public static readonly string OPT2DelayTime1 = "6232"; + // 옵션 - OPT2_지연시간2 + public static readonly string OPT2DelayTime2 = "6233"; + // 옵션 - 파라미터 읽기 + public static readonly string ParameterRead6901 = "6901"; + + // RS232 통신1 속도 + public static readonly string Serial1_BaudRate = "7001"; + // RS232 통신1 모드 + public static readonly string Serial1_Mode = "7002"; + // RS232 통신 1 속도, 모드 + public static readonly string Serial1 = "7003"; + + // 통신,IO설정 - INPUT ALL + public static readonly string InputAll = "7500"; + // 통신,IO설정 = OUTPUT1 + public static readonly string Output1 = "7701"; + // 통신,IO설정 = OUTPUT2 + public static readonly string Output2 = "7702"; + // 통신,IO설정 = OUTPUT3 + public static readonly string Output3 = "7703"; + // 통신,IO설정 = OUTPUT4 + public static readonly string Output4 = "7704"; + // 통신,IO설정 = OUTPUT5 + public static readonly string Output5 = "7705"; + // 통신,IO설정 = OUTPUT6 + public static readonly string Output6 = "7706"; + // 통신,IO설정 = OUTPUT7 + public static readonly string Output7 = "7707"; + // 통신,IO설정 = OUTPUT8 + public static readonly string Output8 = "7708"; + // 통신,IO설정 = OUTPUT9 + public static readonly string Output9 = "7709"; + // 통신,IO설정 = OUTPUT10 + public static readonly string Output10 = "7710"; + // 통신,IO설정 = OUTPUT11 + public static readonly string Output11 = "7711"; + // 통신,IO설정 = OUTPUT12 + public static readonly string Output12 = "7712"; + // 통신,IO설정 = OUTPUT13 + public static readonly string Output13 = "7713"; + // 통신,IO설정 = OUTPUT14 + public static readonly string Output14 = "7714"; + // 통신,IO설정 = OUTPUT15 + public static readonly string Output15 = "7715"; + // 통신,IO설정 = OUTPUT16 + public static readonly string Output16 = "7716"; + + // 전체파라미터 쓰기 1 + public static readonly string SystemParameterWrite1 = "9018"; + // 전체파라미터 쓰기 2 + public static readonly string SystemParameterWrite2 = "9019"; + // 전체파라미터 쓰기 3 + public static readonly string SystemParameterWrite3 = "9020"; + // 전체파라미터 쓰기 4 + public static readonly string SystemParameterWrite4 = "9021"; + // 랜덤모드 쓰기 + public static readonly string RandomModeWrite = "9023"; + // 중량설정값 쓰기 + public static readonly string ParameterWeightSetting = "9024"; + // 전체파라미터 쓰기(Ver5 이전 : 9014, Ver5부터 : 9025) + public static readonly string SystemParameterWriteAll = "9025"; + // 전체 카운트 읽기/쓰기 + public static readonly string ParameterCount = "9031"; + //// 시스템파라미터 읽기1 + //public static readonly string SystemParameterRead1 = "9501"; + //// 시스템파라미터 읽기2 + //public static readonly string SystemParameterRead2 = "9502"; + //// 시스템파라미터 읽기3 + //public static readonly string SystemParameterRead3 = "9503"; + //// 시스템파라미터 읽기4 + //public static readonly string SystemParameterRead4 = "9504"; + + + // 시스템정보 파라미터 읽기1 + public static readonly string SystemInformationRead1 = "9512"; + // 시스템정보 파라미터 읽기2 + public static readonly string SystemInformationRead2 = "9513"; + // 시스템정보 파라미터 읽기3 + public static readonly string SystemInformationRead3 = "9514"; + // 시스템정보 파라미터 읽기4 + public static readonly string SystemInformationRead4 = "9515"; + } + #endregion + + #region CommunicationServo + public class ServoMotorParameterAddress + { + // Alarm Reset - 0x0049 + public static readonly int AlarmReset = 73; + + // CCW TRQ LMT - 0x00C8 + public static readonly int CCWTorqueLimit = 200; + // CW TRQ LMT - 0x00C9 + public static readonly int CWTorqueLimit = 201; + + // Grop Speed 0 - 0x0131 + public static readonly int GropSpeed0 = 305; + + // Position CMD 0 - 0x01F4 + public static readonly int PositionCMD0 = 500; + // Position CMD 1 - 0x01F5 + public static readonly int PositionCMD1 = 501; + // Position CMD 2 - 0x01F6 + public static readonly int PositionCMD2 = 502; + // Position CMD 3 - 0x01F7 + public static readonly int PositionCMD3 = 503; + + // ORG Speed 0 - 0x0258 + public static readonly int ORGSpeed0 = 600; + // ORG Speed 1 - 0x0259 + public static readonly int ORGSpeed1 = 601; + // Origin Offset - 0x025B + public static readonly int OriginOffset = 603; + // Jog Speed 0 - 0x025D + public static readonly int JogSpeed0 = 605; + + // Angle Division - 0x02C2 + public static readonly int AngleDivision = 706; + } + #endregion + + #region Modbus + public class _30000_ModbusAddress + { + public const int _01_IsUpdate_High = 10; + public const int _02_IsUpdate_Low = 11; + public const int _03_EquipmentID_High = 12; + public const int _04_EquipmentID_Low = 13; + public const int _05_ProductNo_High = 14; + public const int _06_ProductNo_Low = 15; + public const int _07_UnderValue_High = 16; + public const int _08_UnderValue_Low = 17; + public const int _09_PassValue_High = 18; + public const int _10_PassValue_Low = 19; + public const int _11_OverValue_High = 20; + public const int _12_OverValue_Low = 21; + public const int _13_TareValue_High = 22; + public const int _14_TareValue_Low = 23; + public const int _15_UnderCount_High = 24; + public const int _16_UnderCount_Low = 25; + public const int _17_PassCount_High = 26; + public const int _18_PassCount_Low = 27; + public const int _19_OverCount_High = 28; + public const int _20_OverCount_Low = 29; + public const int _21_NGCount_High = 30; + public const int _22_NGCount_Low = 31; + public const int _23_ExNGCount_High = 32; + public const int _24_ExNGCount_Low = 33; + public const int _25_TotalCount_High = 34; + public const int _26_TotalCount_Low = 35; + public const int _27_Grade_High = 36; + public const int _28_Grade_Low = 37; + public const int _29_Weight_High = 38; + public const int _30_Weight_Low = 39; + public const int _31_OperationStatus_High = 40; + public const int _32_OperationStatus_Low = 41; + public const int _33_AlarmStatus_High = 42; + public const int _34_AlarmStatus_Low = 43; + + #region V7 + //public const int _01_EquipmentID = 10; + //public const int _02_ProductNo = 11; + //public const int _03_UnderValue_High = 12; + //public const int _04_UnderValue_Low = 13; + //public const int _05_PassValue_High = 14; + //public const int _06_PassValue_Low = 15; + //public const int _07_OverValue_High = 16; + //public const int _08_OverValue_Low = 17; + //public const int _09_UnderCount_High = 18; + //public const int _10_UnderCount_Low = 19; + //public const int _11_PassCount_High = 20; + //public const int _12_PassCount_Low = 21; + //public const int _13_OverCount_High = 22; + //public const int _14_OverCount_Low = 23; + //public const int _15_NGCount_High = 24; + //public const int _16_NGCount_Low = 25; + //public const int _17_ExNGCount_High = 26; + //public const int _18_ExNGCount_Low = 27; + //public const int _19_TotalCount_High = 28; + //public const int _20_TotalCount_Low = 29; + //public const int _21_Grade = 30; + //public const int _22_Weight_High = 31; + //public const int _23_Weight_Low = 32; + //public const int _24_OperationStatus = 33; + #endregion + } + public class _30000_ModbusData + { + #region Field + private int m_IsUpdate; + private int m_EquipmentID; + private int m_ProductNo; + private double m_UnderValue; + private double m_PassValue; + private double m_OverValue; + private double m_TareValue; + private UInt32 m_UnderCount; + private UInt32 m_PassCount; + private UInt32 m_OverCount; + private UInt32 m_NGCount; + private UInt32 m_ExNGCount; + private UInt32 m_TotalCount; + private int m_Grade; + private double m_Weight; + private int m_OperationStatus; + private int m_AlarmStatus; + #endregion + + #region Constructor + public _30000_ModbusData() + { + this.Initialization(); + } + #endregion + + #region Property + public int IsUpdate + { + get { return this.m_IsUpdate; } + set { this.m_IsUpdate = value; } + } + public int EquipmentID + { + get { return this.m_EquipmentID; } + set { this.m_EquipmentID = value; } + } + public int ProductNo + { + get { return this.m_ProductNo; } + set { this.m_ProductNo = value; } + } + + public double UnderValue + { + get { return this.m_UnderValue; } + set { this.m_UnderValue = value; } + } + public double PassValue + { + get { return this.m_PassValue; } + set { this.m_PassValue = value; } + } + public double OverValue + { + get { return this.m_OverValue; } + set { this.m_OverValue = value; } + } + public double TareValue + { + get { return this.m_TareValue; } + set { this.m_TareValue = value; } + } + + public UInt32 UnderCount + { + get { return this.m_UnderCount; } + set { this.m_UnderCount = value; } + } + public UInt32 PassCount + { + get { return this.m_PassCount; } + set { this.m_PassCount = value; } + } + public UInt32 OverCount + { + get { return this.m_OverCount; } + set { this.m_OverCount = value; } + } + public UInt32 NGCount + { + get { return this.m_NGCount; } + set { this.m_NGCount = value; } + } + public UInt32 ExNGCount + { + get { return this.m_ExNGCount; } + set { this.m_ExNGCount = value; } + } + public UInt32 TotalCount + { + get { return this.m_TotalCount; } + set { this.m_TotalCount = value; } + } + + public int Grade + { + get { return this.m_Grade; } + set { this.m_Grade = value; } + } + public double Weight + { + get { return this.m_Weight; } + set { this.m_Weight = value; } + } + public int OperationStatus + { + get { return this.m_OperationStatus; } + set { this.m_OperationStatus = value; } + } + public int AlarmStatus + { + get { return this.m_AlarmStatus; } + set { this.m_AlarmStatus = value; } + } + + public string HexStringIsUpdate + { + get + { + string hexString = this.IsUpdate.ToString("X8"); + return hexString; + } + } + public string HexStringEquipmentID + { + get + { + string hexString = this.EquipmentID.ToString("X8"); + return hexString; + } + } + public string HexStringProductNo + { + get + { + string hexString = this.ProductNo.ToString("X8"); + return hexString; + } + } + public string HexStringUnderValue + { + get + { + byte[] bytes = BitConverter.GetBytes((float)this.UnderValue); + Array.Reverse(bytes); + string hexString = BitConverter.ToString(bytes); + hexString = hexString.Replace("-", ""); + + return hexString; + } + } + public string HexStringPassValue + { + get + { + byte[] bytes = BitConverter.GetBytes((float)this.PassValue); + Array.Reverse(bytes); + string hexString = BitConverter.ToString(bytes); + hexString = hexString.Replace("-", ""); + + return hexString; + } + } + public string HexStringOverValue + { + get + { + byte[] bytes = BitConverter.GetBytes((float)this.OverValue); + Array.Reverse(bytes); + string hexString = BitConverter.ToString(bytes); + hexString = hexString.Replace("-", ""); + + return hexString; + } + } + public string HexStringTareValue + { + get + { + byte[] bytes = BitConverter.GetBytes((float)this.TareValue); + Array.Reverse(bytes); + string hexString = BitConverter.ToString(bytes); + hexString = hexString.Replace("-", ""); + + return hexString; + } + } + public string HexStringUnderCount + { + get + { + string hexString = this.UnderCount.ToString("X8"); + return hexString; + } + } + public string HexStringPassCount + { + get + { + string hexString = this.PassCount.ToString("X8"); + return hexString; + } + } + public string HexStringOverCount + { + get + { + string hexString = this.OverCount.ToString("X8"); + return hexString; + } + } + public string HexStringNGCount + { + get + { + string hexString = this.NGCount.ToString("X8"); + return hexString; + } + } + public string HexStringExNGCount + { + get + { + string hexString = this.ExNGCount.ToString("X8"); + return hexString; + } + } + public string HexStringTotalCount + { + get + { + string hexString = this.TotalCount.ToString("X8"); + return hexString; + } + } + public string HexStringGrade + { + get + { + string hexString = this.Grade.ToString("X8"); + return hexString; + } + } + public string HexStringWeight + { + get + { + byte[] bytes = BitConverter.GetBytes((float)this.Weight); + byte[] reverseBytes = new byte[bytes.Length]; + for (int i = 0; i < bytes.Length; i++) + reverseBytes[bytes.Length - 1 - i] = bytes[i]; + string hexString = BitConverter.ToString(reverseBytes); + + hexString = hexString.Replace("-", ""); + + return hexString; + } + } + public string HexStringOperationStatus + { + get + { + string hexString = this.OperationStatus.ToString("X8"); + return hexString; + } + } + public string HexStringAlarmStatus + { + get + { + string hexString = this.AlarmStatus.ToString("X8"); + return hexString; + } + } + + public byte[] _01_IsUpdate_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.IsUpdate); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _02_IsUpdate_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.IsUpdate); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _03_EquipmentID_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.EquipmentID); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _04_EquipmentID_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.EquipmentID); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _05_ProductNo_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.ProductNo); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _06_ProductNo_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.ProductNo); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _07_UnderValue_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.UnderValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _08_UnderValue_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.UnderValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _09_PassValue_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.PassValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _10_PassValue_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.PassValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _11_OverValue_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.OverValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _12_OverValue_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.OverValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _13_TareValue_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.TareValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _14_TareValue_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.TareValue); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _15_UnderCount_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.UnderCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _16_UnderCount_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.UnderCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _17_PassCount_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.PassCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _18_PassCount_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.PassCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _19_OverCount_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.OverCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _20_OverCount_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.OverCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _21_NGCount_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.NGCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _22_NGCount_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.NGCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _23_ExNGCount_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.ExNGCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _24_ExNGCount_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.ExNGCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _25_TotalCount_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.TotalCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _26_TotalCount_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.TotalCount); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _27_Grade_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.Grade); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _28_Grade_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.Grade); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _29_Weight_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.Weight); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _30_Weight_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes((Single)this.Weight); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _31_OperationStatus_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.OperationStatus); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _32_OperationStatus_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.OperationStatus); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + public byte[] _33_AlarmStatus_High + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.AlarmStatus); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[3 - i]; + + return madeData; + } + } + public byte[] _34_AlarmStatus_Low + { + get + { + byte[] madeData = new byte[2]; + byte[] Length4Value = new byte[4]; + + Length4Value = Modbus.GetBytes(this.AlarmStatus); + for (int i = 0; i < 2; i++) + madeData[i] = Length4Value[1 - i]; + + return madeData; + } + } + #endregion + + #region Method + public void Initialization() + { + this.IsUpdate = 0; + this.EquipmentID = 1; + this.ProductNo = 1; + this.UnderValue = 100.0; + this.PassValue = 200.0; + this.OverValue = 300.0; + this.TareValue = 0.0; + this.UnderCount = 0; + this.PassCount = 0; + this.OverCount = 0; + this.NGCount = 0; + this.ExNGCount = 0; + this.TotalCount = 0; + this.Grade = 5; + this.Weight = 0.0; + this.OperationStatus = 0; + this.AlarmStatus = 0; + } + #endregion + } + + public class _40000_ModbusAddress + { + public const int _01_Clear = 10; + public const int _02_ClearResult = 11; + public const int _03_Operation = 12; + public const int _04_OperationResult = 13; + public const int _05_ProductChange_High = 14; + public const int _06_ProductChange_Low = 15; + public const int _07_ProductChangeResult = 16; + public const int _08_UnderRange_High = 17; + public const int _09_UnderRange_Low = 18; + public const int _10_UnderRangeResult = 19; + public const int _11_PassRange_High = 20; + public const int _12_PassRange_Low = 21; + public const int _13_PassRangeResult = 22; + public const int _14_OverRange_High = 23; + public const int _15_OverRange_Low = 24; + public const int _16_OverRangeResult = 25; + public const int _17_TareWeight_High = 26; + public const int _18_TareWeight_Low = 27; + public const int _19_TareWeightResult = 28; + } + public class _40000_ModbusData + { + #region Field + private int m_40011_Clear; + private int m_40012_ClearResult; + private int m_40013_Operation; + private int m_40014_OperationResult; + private int m_40015_ProductChange; + private int m_40017_ProductChangeResult; + private int m_40018_UnderRange; + private int m_40020_UnderRangeResult; + private int m_40021_PassRange; + private int m_40023_PassRangeResult; + private int m_40024_OverRange; + private int m_40026_OverRangeResult; + private int m_40027_TareWeight; + private int m_40029_TareWeightResult; + #endregion + + #region Constructor + public _40000_ModbusData() + { + this.Initialization(); + } + #endregion + + #region Property + public int _40011_Clear + { + get { return this.m_40011_Clear; } + set { this.m_40011_Clear = value; } + } + public int _40012_ClearResult + { + get { return this.m_40012_ClearResult; } + set { this.m_40012_ClearResult = value; } + } + public int _40013_Operation + { + get { return this.m_40013_Operation; } + set { this.m_40013_Operation = value; } + } + public int _40014_OperationResult + { + get { return this.m_40014_OperationResult; } + set { this.m_40014_OperationResult = value; } + } + public int _40015_ProductChange + { + get { return this.m_40015_ProductChange; } + set { this.m_40015_ProductChange = value; } + } + public int _40017_ProductChangeResult + { + get { return this.m_40017_ProductChangeResult; } + set { this.m_40017_ProductChangeResult = value; } + } + public int _40018_UnderRange + { + get { return this.m_40018_UnderRange; } + set { this.m_40018_UnderRange = value; } + } + public int _40020_UnderRangeResult + { + get { return this.m_40020_UnderRangeResult; } + set { this.m_40020_UnderRangeResult = value; } + } + public int _40021_PassRange + { + get { return this.m_40021_PassRange; } + set { this.m_40021_PassRange = value; } + } + public int _40023_PassRangeResult + { + get { return this.m_40023_PassRangeResult; } + set { this.m_40023_PassRangeResult = value; } + } + public int _40024_OverRange + { + get { return this.m_40024_OverRange; } + set { this.m_40024_OverRange = value; } + } + public int _40026_OverRangeResult + { + get { return this.m_40026_OverRangeResult; } + set { this.m_40026_OverRangeResult = value; } + } + public int _40027_TareWeight + { + get { return this.m_40027_TareWeight; } + set { this.m_40027_TareWeight = value; } + } + public int _40029_TareWeightResult + { + get { return this.m_40029_TareWeightResult; } + set { this.m_40029_TareWeightResult = value; } + } + #endregion + + #region Method + public void Initialization() + { + this._40011_Clear = 0; + this._40012_ClearResult = 0; + this._40013_Operation = 0; + this._40014_OperationResult = 0; + this._40015_ProductChange = 0; + this._40017_ProductChangeResult = 0; + this._40018_UnderRange = 0; + this._40020_UnderRangeResult = 0; + this._40021_PassRange = 0; + this._40023_PassRangeResult = 0; + this._40024_OverRange = 0; + this._40026_OverRangeResult = 0; + this._40027_TareWeight = 0; + this._40029_TareWeightResult = 0; + } + #endregion + } + #endregion + + #region SystemConfigurationItem1 + public class SystemConfigurationItem1 + { + #region Field + private bool m_IsDataBackup; + private bool m_IsLogin; + private bool m_IsPrintPerProductEnable; + private bool m_IsExternalInputBuzzer; + private bool m_IsExternalInputLamp; + private bool m_IsAverageTracking; + + private int m_EquipmentID; + private int m_DecimalPlaces; + private int m_ProductNumber; + private int m_SerialCOM1BaudRate; + private int m_SerialCOM1Mode; + private int m_SerialCOM3BaudRate; + private int m_SerialCOM3Mode; + private int m_SerialCOM4BaudRate; + private int m_SerialCOM4Mode; + private int m_DatabackupFormat; + private int m_TransmissionDelayTimeCOM1; + private int m_TransmissionDelayTimeCOM3; + private int m_TransmissionDelayTimeCOM4; + private int m_StatisticsPrintFormat; + + private string m_SerialNumber; + private string m_MainBoardVersion; + private string m_Unit; + private string m_UserDefineCOM1; + private string m_UserDefineCOM3; + private string m_UserDefineCOM4; + + private DataStore.LanguageID m_Language; + #endregion + + #region Constructor + public SystemConfigurationItem1() + { + this.Initialization(); + } + #endregion + + #region Property + public bool IsDataBackup + { + get { return this.m_IsDataBackup; } + set { this.m_IsDataBackup = value; } + } + public bool IsLogin + { + get { return this.m_IsLogin; } + set { this.m_IsLogin = value; } + } + public bool IsPrinterEnable + { + get + { + if (this.SerialCOM1Mode == 3 || this.SerialCOM3Mode == 3 || this.SerialCOM4Mode == 3) + return true; + else + return false; + } + } + public bool IsPrintPerProductEnable + { + get { return this.m_IsPrintPerProductEnable; } + set { this.m_IsPrintPerProductEnable = value; } + } + public bool IsExternalInputLamp + { + get { return this.m_IsExternalInputLamp; } + set { this.m_IsExternalInputLamp = value; } + } + public bool IsExternalInputBuzzer + { + get { return this.m_IsExternalInputBuzzer; } + set { this.m_IsExternalInputBuzzer = value; } + } + public bool IsAverageTracking + { + get { return this.m_IsAverageTracking; } + set { this.m_IsAverageTracking = value; } + } + + public int EquipmentID + { + get { return this.m_EquipmentID; } + set { this.m_EquipmentID = value; } + } + public int DecimalPlaces + { + get { return this.m_DecimalPlaces; } + set { this.m_DecimalPlaces = value; } + } + public int ProductNumber + { + get { return this.m_ProductNumber; } + set { this.m_ProductNumber = value; } + } + public int SerialCOM1BaudRate + { + get { return this.m_SerialCOM1BaudRate; } + set { this.m_SerialCOM1BaudRate = value; } + } + public int SerialCOM1Mode + { + get { return this.m_SerialCOM1Mode; } + set { this.m_SerialCOM1Mode = value; } + } + public int SerialCOM3BaudRate + { + get { return this.m_SerialCOM3BaudRate; } + set { this.m_SerialCOM3BaudRate = value; } + } + public int SerialCOM3Mode + { + get { return this.m_SerialCOM3Mode; } + set { this.m_SerialCOM3Mode = value; } + } + public int SerialCOM4BaudRate + { + get { return this.m_SerialCOM4BaudRate; } + set { this.m_SerialCOM4BaudRate = value; } + } + public int SerialCOM4Mode + { + get { return this.m_SerialCOM4Mode; } + set { this.m_SerialCOM4Mode = value; } + } + public int DatabackupFormat + { + get { return this.m_DatabackupFormat; } + set { this.m_DatabackupFormat = value; } + } + public int ProductCount + { + get + { + return 1000; + } + } + public int TransmissionDelayTimeCOM1 + { + get { return this.m_TransmissionDelayTimeCOM1; } + set { this.m_TransmissionDelayTimeCOM1 = value; } + } + public int TransmissionDelayTimeCOM3 + { + get { return this.m_TransmissionDelayTimeCOM3; } + set { this.m_TransmissionDelayTimeCOM3 = value; } + } + public int TransmissionDelayTimeCOM4 + { + get { return this.m_TransmissionDelayTimeCOM4; } + set { this.m_TransmissionDelayTimeCOM4 = value; } + } + public int StatisticsPrintFormat + { + get { return this.m_StatisticsPrintFormat; } + set { this.m_StatisticsPrintFormat = value; } + } + + public string SerialNumber + { + get { return this.m_SerialNumber; } + set { this.m_SerialNumber = value; } + } + public string MainBoardVersion + { + get { return this.m_MainBoardVersion; } + set { this.m_MainBoardVersion = value; } + } + public string Unit + { + get { return this.m_Unit; } + set { this.m_Unit = value; } + } + public string UserDefineCOM1 + { + get { return this.m_UserDefineCOM1; } + set { this.m_UserDefineCOM1 = value; } + } + public string UserDefineCOM3 + { + get { return this.m_UserDefineCOM3; } + set { this.m_UserDefineCOM3 = value; } + } + public string UserDefineCOM4 + { + get { return this.m_UserDefineCOM4; } + set { this.m_UserDefineCOM4 = value; } + } + + public DataStore.LanguageID Language + { + get { return this.m_Language; } + set { this.m_Language = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.IsDataBackup = false; + this.IsLogin = false; + this.IsPrintPerProductEnable = false; + this.IsExternalInputBuzzer = false; + this.IsExternalInputLamp = false; + this.IsAverageTracking = false; + + this.EquipmentID = 1; + this.DecimalPlaces = 1; + this.ProductNumber = 1; + this.SerialCOM1BaudRate = 0; + this.SerialCOM1Mode = 0; + this.SerialCOM3BaudRate = 0; + this.SerialCOM3Mode = 0; + this.SerialCOM4BaudRate = 0; + this.SerialCOM4Mode = 0; + this.DatabackupFormat = 0; + this.TransmissionDelayTimeCOM1 = 0; + this.TransmissionDelayTimeCOM3 = 0; + this.TransmissionDelayTimeCOM4 = 0; + this.StatisticsPrintFormat = 0; + + this.SerialNumber = "23A0000"; + this.MainBoardVersion = "000"; + this.Unit = "g"; + this.UserDefineCOM1 = ""; + this.UserDefineCOM3 = ""; + this.UserDefineCOM4 = ""; + + this.Language = DataStore.LanguageID.Korean; + } + #endregion + } + #endregion + #region StructSystemConfigurationItem1 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemConfigurationItem1 + { + public bool IsDataBackup; + public bool IsLogin; + + public int EquipmentID; + public int DecimalPlaces; + public int ProductNumber; + public int Dummy1Int; + public int Serial1BaudRate; + public int Serial1Mode; + public int Serial2BaudRate; + public int Serial2Mode; + public int Serial3BaudRate; + public int Serial3Mode; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 15)] + public string SerialNumber; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)] + public string Unit; + + public DataStore.LanguageID Language; + + public bool IsAverageTracking; + public bool IsExternalInputLamp; + public bool IsExternalInputBuzzer; + public bool IsPrintPerProductEnable; + public bool DummyBool1; + + public int StatisticsPrintFormat; + public int TransmissionDelayTimeCOM1; + public int TransmissionDelayTimeCOM3; + public int TransmissionDelayTimeCOM4; + public int DatabackupFormat; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string UserDefineCOM1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string UserDefineCOM3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string UserDefineCOM4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 100)] + public string DummyString5; + } + #endregion + + #region SystemConfigurationItem2 + public class SystemConfigurationItem2 + { + #region Field + // 카운터출력 관련 + private int m_CountingOutput1Mode; + private int m_CountingOutput1Number; + private int m_CountingOutput1BuzzerTime; + private bool m_IsCountingOutput1ConveyorStop; + private bool m_IsCountingOutput1BuzzerOn; + private bool m_IsCountingOutput1Continuous; + private bool m_IsCountingOutput1ExternalOutput; + + private int m_CountingOutput2Mode; + private int m_CountingOutput2Number; + private int m_CountingOutput2BuzzerTime; + private bool m_IsCountingOutput2Continuous; + private bool m_IsCountingOutput2ConveyorStop; + private bool m_IsCountingOutput2BuzzerOn; + private bool m_IsCountingOutput2ExternalOutput; + + // 통신모드 관련 + private int m_HitachiRoomNumberCOM1; + private int m_MarkoprintLineNumberCOM1; + private bool m_IsHitachiBlankToNoneCOM1; + private bool m_IsMarkoprintDatePrintCOM1; + private bool m_IsMarkoprintTodaytDatePrintCOM1; + private string m_MarkoprintDateSettingCOM1; + + private int m_HitachiRoomNumberCOM3; + private int m_MarkoprintLineNumberCOM3; + private bool m_IsHitachiBlankToNoneCOM3; + private bool m_IsMarkoprintDatePrintCOM3; + private bool m_IsMarkoprintTodaytDatePrintCOM3; + private string m_MarkoprintDateSettingCOM3; + + private int m_HitachiRoomNumberCOM4; + private int m_MarkoprintLineNumberCOM4; + private bool m_IsHitachiBlankToNoneCOM4; + private bool m_IsMarkoprintDatePrintCOM4; + private bool m_IsMarkoprintTodaytDatePrintCOM4; + private string m_MarkoprintDateSettingCOM4; + + // 랜덤모드 관련 + private bool m_IsGroup1UsingRandomMode; + private bool m_IsGroup2UsingRandomMode; + private bool m_IsGroup3UsingRandomMode; + private bool m_IsGroup4UsingRandomMode; + private bool m_IsGroup5UsingRandomMode; + + private int m_FileNameExtension; + + private int m_HitachiRoomNumberEthernet; + private int m_MarkoprintLineNumberEthernet; + private bool m_IsMarkoprintDatePrintEthernet; + private bool m_IsMarkoprintTodaytDatePrintEthernet; + private string m_MarkoprintDateSettingEthernet; + private int m_EthernetHostPort; + private int m_EthernetCommMode; + private int m_EthernetOperationMode; + private string m_EthernetAddress; + private int m_ConveyorLength; + private int m_SortingPointLength; + private int m_Barcode; + private int m_CommunicationControlCharacter; + private int m_EthernetLocalPort; + + private bool m_IsBypassDirectionPass; + private bool m_IsBypassOnce; + private bool m_IsCommunicationOption; + private bool m_IsRFIDSpeedwayR420; + + private int m_ModbusRTUSelectFunction; + private int m_ModbusSlaveIDCOM1; + private int m_ModbusSlaveIDCOM3; + private int m_ModbusSlaveIDCOM4; + + private int m_ModbusTCPSelectFunction; + + private string m_EntryNotDetectedWeight; + + private string m_RFID_R420_BARCD; + private string m_RFID_R420_EPC_Filter; + private int m_AverageTracking; + + private int m_MULTiJETSlaveAddressCOM1; + private int m_MULTiJETSlaveAddressCOM3; + private int m_MULTiJETSlaveAddressCOM4; + private int m_MULTiJETSlaveAddressEthernet; + #endregion + + #region Constructor + public SystemConfigurationItem2() + { + this.Initialization(); + } + #endregion + + #region Property + public int CountingOutput1Mode + { + get { return this.m_CountingOutput1Mode; } + set { this.m_CountingOutput1Mode = value; } + } + public int CountingOutput1Number + { + get { return this.m_CountingOutput1Number; } + set { this.m_CountingOutput1Number = value; } + } + public bool IsCountingOutput1Continuous + { + get { return this.m_IsCountingOutput1Continuous; } + set { this.m_IsCountingOutput1Continuous = value; } + } + public bool IsCountingOutput1ConveyorStop + { + get { return this.m_IsCountingOutput1ConveyorStop; } + set { this.m_IsCountingOutput1ConveyorStop = value; } + } + public bool IsCountingOutput1BuzzerOn + { + get { return this.m_IsCountingOutput1BuzzerOn; } + set { this.m_IsCountingOutput1BuzzerOn = value; } + } + public bool IsCountingOutput1ExternalOutput + { + get { return this.m_IsCountingOutput1ExternalOutput; } + set { this.m_IsCountingOutput1ExternalOutput = value; } + } + + public int CountingOutput2Mode + { + get { return this.m_CountingOutput2Mode; } + set { this.m_CountingOutput2Mode = value; } + } + public int CountingOutput2Number + { + get { return this.m_CountingOutput2Number; } + set { this.m_CountingOutput2Number = value; } + } + public bool IsCountingOutput2Continuous + { + get { return this.m_IsCountingOutput2Continuous; } + set { this.m_IsCountingOutput2Continuous = value; } + } + public bool IsCountingOutput2ConveyorStop + { + get { return this.m_IsCountingOutput2ConveyorStop; } + set { this.m_IsCountingOutput2ConveyorStop = value; } + } + public bool IsCountingOutput2BuzzerOn + { + get { return this.m_IsCountingOutput2BuzzerOn; } + set { this.m_IsCountingOutput2BuzzerOn = value; } + } + public bool IsCountingOutput2ExternalOutput + { + get { return this.m_IsCountingOutput2ExternalOutput; } + set { this.m_IsCountingOutput2ExternalOutput = value; } + } + + public int CountingOutput1BuzzerTime + { + get { return this.m_CountingOutput1BuzzerTime; } + set { this.m_CountingOutput1BuzzerTime = value; } + } + public int CountingOutput2BuzzerTime + { + get { return this.m_CountingOutput2BuzzerTime; } + set { this.m_CountingOutput2BuzzerTime = value; } + } + + public int HitachiRoomNumberCOM1 + { + get { return this.m_HitachiRoomNumberCOM1; } + set { this.m_HitachiRoomNumberCOM1 = value; } + } + public bool IsHitachiBlankToNoneCOM1 + { + get { return this.m_IsHitachiBlankToNoneCOM1; } + set { this.m_IsHitachiBlankToNoneCOM1 = value; } + } + public int MarkoprintLineNumberCOM1 + { + get { return this.m_MarkoprintLineNumberCOM1; } + set { this.m_MarkoprintLineNumberCOM1 = value; } + } + public bool IsMarkoprintDatePrintCOM1 + { + get { return this.m_IsMarkoprintDatePrintCOM1; } + set { this.m_IsMarkoprintDatePrintCOM1 = value; } + } + public bool IsMarkoprintTodaytDatePrintCOM1 + { + get { return this.m_IsMarkoprintTodaytDatePrintCOM1; } + set { this.m_IsMarkoprintTodaytDatePrintCOM1 = value; } + } + public string MarkoprintDateSettingCOM1 + { + get { return this.m_MarkoprintDateSettingCOM1; } + set { this.m_MarkoprintDateSettingCOM1 = value; } + } + + public int HitachiRoomNumberCOM3 + { + get { return this.m_HitachiRoomNumberCOM3; } + set { this.m_HitachiRoomNumberCOM3 = value; } + } + public bool IsHitachiBlankToNoneCOM3 + { + get { return this.m_IsHitachiBlankToNoneCOM3; } + set { this.m_IsHitachiBlankToNoneCOM3 = value; } + } + public int MarkoprintLineNumberCOM3 + { + get { return this.m_MarkoprintLineNumberCOM3; } + set { this.m_MarkoprintLineNumberCOM3 = value; } + } + public bool IsMarkoprintDatePrintCOM3 + { + get { return this.m_IsMarkoprintDatePrintCOM3; } + set { this.m_IsMarkoprintDatePrintCOM3 = value; } + } + public bool IsMarkoprintTodaytDatePrintCOM3 + { + get { return this.m_IsMarkoprintTodaytDatePrintCOM3; } + set { this.m_IsMarkoprintTodaytDatePrintCOM3 = value; } + } + public string MarkoprintDateSettingCOM3 + { + get { return this.m_MarkoprintDateSettingCOM3; } + set { this.m_MarkoprintDateSettingCOM3 = value; } + } + + public int HitachiRoomNumberCOM4 + { + get { return this.m_HitachiRoomNumberCOM4; } + set { this.m_HitachiRoomNumberCOM4 = value; } + } + public bool IsHitachiBlankToNoneCOM4 + { + get { return this.m_IsHitachiBlankToNoneCOM4; } + set { this.m_IsHitachiBlankToNoneCOM4 = value; } + } + public int MarkoprintLineNumberCOM4 + { + get { return this.m_MarkoprintLineNumberCOM4; } + set { this.m_MarkoprintLineNumberCOM4 = value; } + } + public bool IsMarkoprintDatePrintCOM4 + { + get { return this.m_IsMarkoprintDatePrintCOM4; } + set { this.m_IsMarkoprintDatePrintCOM4 = value; } + } + public bool IsMarkoprintTodaytDatePrintCOM4 + { + get { return this.m_IsMarkoprintTodaytDatePrintCOM4; } + set { this.m_IsMarkoprintTodaytDatePrintCOM4 = value; } + } + public string MarkoprintDateSettingCOM4 + { + get { return this.m_MarkoprintDateSettingCOM4; } + set { this.m_MarkoprintDateSettingCOM4 = value; } + } + + public bool IsGroup1UsingRandomMode + { + get { return this.m_IsGroup1UsingRandomMode; } + set { this.m_IsGroup1UsingRandomMode = value; } + } + public bool IsGroup2UsingRandomMode + { + get { return this.m_IsGroup2UsingRandomMode; } + set { this.m_IsGroup2UsingRandomMode = value; } + } + public bool IsGroup3UsingRandomMode + { + get { return this.m_IsGroup3UsingRandomMode; } + set { this.m_IsGroup3UsingRandomMode = value; } + } + public bool IsGroup4UsingRandomMode + { + get { return this.m_IsGroup4UsingRandomMode; } + set { this.m_IsGroup4UsingRandomMode = value; } + } + public bool IsGroup5UsingRandomMode + { + get { return this.m_IsGroup5UsingRandomMode; } + set { this.m_IsGroup5UsingRandomMode = value; } + } + public bool IsUsingRandomMode + { + get + { + if (this.IsGroup1UsingRandomMode == true || this.IsGroup2UsingRandomMode == true || + this.IsGroup3UsingRandomMode == true || this.IsGroup4UsingRandomMode == true || + this.IsGroup5UsingRandomMode == true) + return true; + else + return false; + } + } + + public int FileNameExtension + { + get { return this.m_FileNameExtension; } + set { this.m_FileNameExtension = value; } + } + + public int HitachiRoomNumberEthernet + { + get { return this.m_HitachiRoomNumberEthernet; } + set { this.m_HitachiRoomNumberEthernet = value; } + } + public int MarkoprintLineNumberEthernet + { + get { return this.m_MarkoprintLineNumberEthernet; } + set { this.m_MarkoprintLineNumberEthernet = value; } + } + public bool IsMarkoprintDatePrintEthernet + { + get { return this.m_IsMarkoprintDatePrintEthernet; } + set { this.m_IsMarkoprintDatePrintEthernet = value; } + } + public bool IsMarkoprintTodaytDatePrintEthernet + { + get { return this.m_IsMarkoprintTodaytDatePrintEthernet; } + set { this.m_IsMarkoprintTodaytDatePrintEthernet = value; } + } + public string MarkoprintDateSettingEthernet + { + get { return this.m_MarkoprintDateSettingEthernet; } + set { this.m_MarkoprintDateSettingEthernet = value; } + } + public bool IsEthernetEnable + { + get + { + if (this.EthernetOperationMode != 0) + return true; + else + return false; + } + } + public int EthernetHostPort + { + get { return this.m_EthernetHostPort; } + set { this.m_EthernetHostPort = value; } + } + public int EthernetCommMode + { + get { return this.m_EthernetCommMode; } + set { this.m_EthernetCommMode = value; } + } + public int EthernetOperationMode + { + get { return this.m_EthernetOperationMode; } + set { this.m_EthernetOperationMode = value; } + } + public string EthernetAddress + { + get { return this.m_EthernetAddress; } + set { this.m_EthernetAddress = value; } + } + public int ConveyorLength + { + get { return this.m_ConveyorLength; } + set { this.m_ConveyorLength = value; } + } + public int SortingPointLength + { + get { return this.m_SortingPointLength; } + set { this.m_SortingPointLength = value; } + } + public int Barcode + { + get { return this.m_Barcode; } + set { this.m_Barcode = value; } + } + public int CommunicationControlCharacter + { + get { return this.m_CommunicationControlCharacter; } + set { this.m_CommunicationControlCharacter = value; } + } + public int EthernetLocalPort + { + get { return this.m_EthernetLocalPort; } + set { this.m_EthernetLocalPort = value; } + } + + public bool IsBypassDirectionPass + { + get { return this.m_IsBypassDirectionPass; } + set { this.m_IsBypassDirectionPass = value; } + } + public bool IsBypassOnce + { + get { return this.m_IsBypassOnce; } + set { this.m_IsBypassOnce = value; } + } + public bool IsCommunicationOption + { + get { return this.m_IsCommunicationOption; } + set { this.m_IsCommunicationOption = value; } + } + public bool IsRFIDSpeedwayR420 + { + get { return this.m_IsRFIDSpeedwayR420; } + set { this.m_IsRFIDSpeedwayR420 = value; } + } + + public int ModbusRTUSelectFunction + { + get { return this.m_ModbusRTUSelectFunction; } + set { this.m_ModbusRTUSelectFunction = value; } + } + public int ModbusSlaveIDCOM1 + { + get { return this.m_ModbusSlaveIDCOM1; } + set { this.m_ModbusSlaveIDCOM1 = value; } + } + public int ModbusSlaveIDCOM3 + { + get { return this.m_ModbusSlaveIDCOM3; } + set { this.m_ModbusSlaveIDCOM3 = value; } + } + public int ModbusSlaveIDCOM4 + { + get { return this.m_ModbusSlaveIDCOM4; } + set { this.m_ModbusSlaveIDCOM4 = value; } + } + + public int ModbusTCPSelectFunction + { + get { return this.m_ModbusTCPSelectFunction; } + set { this.m_ModbusTCPSelectFunction = value; } + } + + public string EntryNotDetectedWeight + { + get { return this.m_EntryNotDetectedWeight; } + set { this.m_EntryNotDetectedWeight = value; } + } + public int EntryNotDetectedWeightInt + { + get + { + if (this.EntryNotDetectedWeight == null) + return -1; + else + return int.Parse(this.EntryNotDetectedWeight); + } + } + public bool IsUsingEntryNotDetected + { + get + { + if (this.EntryNotDetectedWeight == "0") + return false; + else + return true; + } + } + + public string RFID_R420_BARCD + { + get { return this.m_RFID_R420_BARCD; } + set { this.m_RFID_R420_BARCD = value; } + } + public string RFID_R420_EPC_Filter + { + get { return this.m_RFID_R420_EPC_Filter; } + set { this.m_RFID_R420_EPC_Filter = value; } + } + public int AverageTrackingCount + { + get { return this.m_AverageTracking; } + set { this.m_AverageTracking = value; } + } + + public int MULTiJETSlaveAddressCOM1 + { + get { return this.m_MULTiJETSlaveAddressCOM1; } + set { this.m_MULTiJETSlaveAddressCOM1 = value; } + } + public int MULTiJETSlaveAddressCOM3 + { + get { return this.m_MULTiJETSlaveAddressCOM3; } + set { this.m_MULTiJETSlaveAddressCOM3 = value; } + } + public int MULTiJETSlaveAddressCOM4 + { + get { return this.m_MULTiJETSlaveAddressCOM4; } + set { this.m_MULTiJETSlaveAddressCOM4 = value; } + } + public int MULTiJETSlaveAddressEthernet + { + get { return this.m_MULTiJETSlaveAddressEthernet; } + set { this.m_MULTiJETSlaveAddressEthernet = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.CountingOutput1Mode = 0; + this.CountingOutput1Number = 0; + this.CountingOutput1BuzzerTime = 1000; + this.IsCountingOutput1Continuous = false; + this.IsCountingOutput1ConveyorStop = false; + this.IsCountingOutput1BuzzerOn = false; + this.IsCountingOutput1ExternalOutput = false; + + this.CountingOutput2Mode = 0; + this.CountingOutput2Number = 0; + this.CountingOutput2BuzzerTime = 1000; + this.IsCountingOutput2Continuous = false; + this.IsCountingOutput2ConveyorStop = false; + this.IsCountingOutput2BuzzerOn = false; + this.IsCountingOutput2ExternalOutput = false; + + this.HitachiRoomNumberCOM1 = 1; + this.MarkoprintLineNumberCOM1 = 0; + this.IsHitachiBlankToNoneCOM1 = false; + this.IsMarkoprintDatePrintCOM1 = false; + this.IsMarkoprintTodaytDatePrintCOM1 = false; + this.MarkoprintDateSettingCOM1 = ""; + + this.HitachiRoomNumberCOM3 = 1; + this.MarkoprintLineNumberCOM3 = 0; + this.IsHitachiBlankToNoneCOM3 = false; + this.IsMarkoprintDatePrintCOM3 = false; + this.IsMarkoprintTodaytDatePrintCOM3 = false; + this.MarkoprintDateSettingCOM3 = ""; + + this.HitachiRoomNumberCOM4 = 1; + this.MarkoprintLineNumberCOM4 = 0; + this.IsHitachiBlankToNoneCOM4 = false; + this.IsMarkoprintDatePrintCOM4 = false; + this.IsMarkoprintTodaytDatePrintCOM4 = false; + this.MarkoprintDateSettingCOM4 = ""; + + this.IsGroup1UsingRandomMode = false; + this.IsGroup2UsingRandomMode = false; + this.IsGroup3UsingRandomMode = false; + this.IsGroup4UsingRandomMode = false; + this.IsGroup5UsingRandomMode = false; + + this.FileNameExtension = 0; + + this.HitachiRoomNumberEthernet = 1; + this.MarkoprintLineNumberEthernet = 0; + this.IsMarkoprintDatePrintEthernet = false; + this.IsMarkoprintTodaytDatePrintEthernet = false; + this.MarkoprintDateSettingEthernet = ""; + this.EthernetHostPort = 0; + this.EthernetCommMode = 0; + this.EthernetOperationMode = 0; + this.EthernetAddress = "0.0.0.0"; + this.ConveyorLength = 450; + this.SortingPointLength = 250; + this.Barcode = 0; + this.CommunicationControlCharacter = 0; + this.EthernetLocalPort = 0; + + this.IsBypassDirectionPass = true; + this.IsBypassOnce = true; + this.IsCommunicationOption = false; + this.IsRFIDSpeedwayR420 = false; + + this.ModbusRTUSelectFunction = (int)DataStore.ModbusFunction._04_ReadInputRegister; + this.ModbusSlaveIDCOM1 = 1; + this.ModbusSlaveIDCOM3 = 1; + this.ModbusSlaveIDCOM4 = 1; + + this.ModbusTCPSelectFunction = (int)DataStore.ModbusFunction._04_ReadInputRegister; + + this.EntryNotDetectedWeight = "0"; + this.RFID_R420_BARCD = "0000000000000"; + this.RFID_R420_EPC_Filter = "1"; + this.AverageTrackingCount = 0; + + this.MULTiJETSlaveAddressCOM1 = 58; + this.MULTiJETSlaveAddressCOM3 = 58; + this.MULTiJETSlaveAddressCOM4 = 58; + this.MULTiJETSlaveAddressEthernet = 58; + } + + public bool IsCountingOutput1Activated() + { + bool ret; + + if (this.CountingOutput1Mode != 0 && this.CountingOutput1Number > 0) + ret = true; + else + ret = false; + + return ret; + } + public bool IsCountingOutput2Activated() + { + bool ret; + + if (this.CountingOutput2Mode != 0 && this.CountingOutput2Number > 0) + ret = true; + else + ret = false; + + return ret; + } + #endregion + } + #endregion + #region StructSystemConfigurationItem2 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemConfigurationItem2 + { + public bool IsCountingOutput1Continuous; + public bool IsCountingOutput1ConveyorStop; + public bool IsCountingOutput1BuzzerOn; + public bool IsCountingOutput1ExternalOutput; + public bool IsCountingOutput2Continuous; + public bool IsCountingOutput2ConveyorStop; + public bool IsCountingOutput2BuzzerOn; + public bool IsCountingOutput2ExternalOutput; + + public bool IsRFIDSpeedwayR420; + public bool IsCommunicationOption; + public bool IsBypassOnce; + public bool IsBypassDirectionPass; + public bool IsHitachiBlankToNoneCOM4; + public bool IsHitachiBlankToNoneCOM3; + public bool IsHitachiBlankToNoneCOM1; + public bool IsMarkoprintTodaytDatePrintEthernet; + public bool IsMarkoprintDatePrintEthernet; + public bool IsGroup1UsingRandomMode; + public bool IsGroup2UsingRandomMode; + public bool IsGroup3UsingRandomMode; + public bool IsGroup4UsingRandomMode; + public bool IsGroup5UsingRandomMode; + public bool IsMarkoprintTodaytDatePrintCOM4; + public bool IsMarkoprintDatePrintCOM4; + public bool IsMarkoprintTodaytDatePrintCOM3; + public bool IsMarkoprintDatePrintCOM3; + public bool IsMarkoprintTodaytDatePrintCOM1; + public bool IsMarkoprintDatePrintCOM1; + + public int CountingOutput1Mode; + public int CountingOutput1Number; + public int CountingOutput2Mode; + public int CountingOutput2Number; + + public int DummyInt1; + public int MULTiJETSlaveAddressEthernet; + public int MULTiJETSlaveAddressCOM1; + public int MULTiJETSlaveAddressCOM3; + public int MULTiJETSlaveAddressCOM4; + public int ModbusTCPSelectFunction; + public int EthernetLocalPort; + public int CommunicationControlCharacter; + public int Barcode; + public int AverageTracking; + public int ModbusRTUSelectFunction; + public int ModbusRTUSlaveIDCOM1; + public int ModbusRTUSlaveIDCOM3; + public int ModbusRTUSlaveIDCOM4; + public int Alarm1BuzzerTime; + public int Alarm2BuzzerTime; + public int SortingPointLength; + public int ConveyorLength; + public int MarkoprintLineNumberEthernet; + public int HitachiRoomNumberEthernet; + public int EthernetHostPort; + public int EthernetCommMode; + public int EthernetOperationMode; + public int FileNameExtension; + public int MarkoprintLineNumberCOM4; + public int HitachiRoomNumberCOM4; + public int MarkoprintLineNumberCOM3; + public int HitachiRoomNumberCOM3; + public int MarkoprintLineNumberCOM1; + public int HitachiRoomNumberCOM1; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString6; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString7; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string EntryNotDetectedWeight; // 제품진입 미감지 + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string RFID_R420_EPC_Filter; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string RFID_R420_BARCD; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string MarkoprintDateSettingEthernet; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string EthernetAddress; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string MarkoprintDateSettingCOM4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string MarkoprintDateSettingCOM3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string MarkoprintDateSettingCOM1; + } + #endregion + + #region SystemConfigurationItem3 + public class SystemConfigurationItem3 + { + #region Field + private bool m_IsCountingOutputCrossMode; + private bool m_IsStartStopLog; + private bool m_IsEthernetPingTimer; + private bool m_IsCharToFillZeroEthernet; + private bool m_IsTransmitWhenPassEthernet; + private bool m_IsCharToFillZeroCOM1; + private bool m_IsTransmitWhenPassCOM1; + private bool m_IsCharToFillZeroCOM3; + private bool m_IsTransmitWhenPassCOM3; + private bool m_IsCharToFillZeroCOM4; + private bool m_IsTransmitWhenPassCOM4; + + private int m_SensorErrorDetectingTime; + private int m_LOTExtractDataFromIndex; + private int m_LOTExtractDataToIndex; + private int m_ModbusTCPStartAddress; + private int m_ModbusRTUStartAddressCOM1; + private int m_ModbusRTUStartAddressCOM3; + private int m_ModbusRTUStartAddressCOM4; + #endregion + + #region Constructor + public SystemConfigurationItem3() + { + this.Initialization(); + } + #endregion + + #region Property + public bool IsCountingOutputCrossMode + { + get { return this.m_IsCountingOutputCrossMode; } + set { this.m_IsCountingOutputCrossMode = value; } + } + public bool IsStartStopLog + { + get { return this.m_IsStartStopLog; } + set { this.m_IsStartStopLog = value; } + } + public bool IsEthernetPingTimer + { + get { return this.m_IsEthernetPingTimer; } + set { this.m_IsEthernetPingTimer = value; } + } + public bool IsCharToFillZeroEthernet + { + get { return this.m_IsCharToFillZeroEthernet; } + set { this.m_IsCharToFillZeroEthernet = value; } + } + public bool IsTransmitWhenPassEthernet + { + get { return this.m_IsTransmitWhenPassEthernet; } + set { this.m_IsTransmitWhenPassEthernet = value; } + } + public bool IsCharToFillZeroCOM1 + { + get { return this.m_IsCharToFillZeroCOM1; } + set { this.m_IsCharToFillZeroCOM1 = value; } + } + public bool IsTransmitWhenPassCOM1 + { + get { return this.m_IsTransmitWhenPassCOM1; } + set { this.m_IsTransmitWhenPassCOM1 = value; } + } + public bool IsCharToFillZeroCOM3 + { + get { return this.m_IsCharToFillZeroCOM3; } + set { this.m_IsCharToFillZeroCOM3 = value; } + } + public bool IsTransmitWhenPassCOM3 + { + get { return this.m_IsTransmitWhenPassCOM3; } + set { this.m_IsTransmitWhenPassCOM3 = value; } + } + public bool IsCharToFillZeroCOM4 + { + get { return this.m_IsCharToFillZeroCOM4; } + set { this.m_IsCharToFillZeroCOM4 = value; } + } + public bool IsTransmitWhenPassCOM4 + { + get { return this.m_IsTransmitWhenPassCOM4; } + set { this.m_IsTransmitWhenPassCOM4 = value; } + } + + public int SensorErrorDetectingTime + { + get { return this.m_SensorErrorDetectingTime; } + set { this.m_SensorErrorDetectingTime = value; } + } + public int LOTExtractDataFromIndex + { + get { return this.m_LOTExtractDataFromIndex; } + set { this.m_LOTExtractDataFromIndex = value; } + } + public int LOTExtractDataToIndex + { + get { return this.m_LOTExtractDataToIndex; } + set { this.m_LOTExtractDataToIndex = value; } + } + public int ModbusTCPStartAddress + { + get { return this.m_ModbusTCPStartAddress; } + set { this.m_ModbusTCPStartAddress = value; } + } + public int ModbusRTUStartAddressCOM1 + { + get { return this.m_ModbusRTUStartAddressCOM1; } + set { this.m_ModbusRTUStartAddressCOM1 = value; } + } + public int ModbusRTUStartAddressCOM3 + { + get { return this.m_ModbusRTUStartAddressCOM3; } + set { this.m_ModbusRTUStartAddressCOM3 = value; } + } + public int ModbusRTUStartAddressCOM4 + { + get { return this.m_ModbusRTUStartAddressCOM4; } + set { this.m_ModbusRTUStartAddressCOM4 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.IsCountingOutputCrossMode = false; + this.IsStartStopLog = false; + this.IsEthernetPingTimer = false; + this.IsCharToFillZeroEthernet = false; + this.IsTransmitWhenPassEthernet = false; + this.IsCharToFillZeroCOM1 = false; + this.IsTransmitWhenPassCOM1 = false; + this.IsCharToFillZeroCOM3 = false; + this.IsTransmitWhenPassCOM3 = false; + this.IsCharToFillZeroCOM4 = false; + this.IsTransmitWhenPassCOM4 = false; + + this.SensorErrorDetectingTime = 0; + this.LOTExtractDataFromIndex = 0; + this.LOTExtractDataToIndex = 13; + this.ModbusTCPStartAddress = 10; + this.ModbusRTUStartAddressCOM1 = 10; + this.ModbusRTUStartAddressCOM3 = 10; + this.ModbusRTUStartAddressCOM4 = 10; + } + #endregion + } + #endregion + #region StructSystemConfigurationItem3 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemConfigurationItem3 + { + public bool DummyBool1; + public bool DummyBool2; + public bool DummyBool3; + public bool DummyBool4; + public bool DummyBool5; + public bool DummyBool6; + public bool DummyBool7; + public bool DummyBool8; + public bool DummyBool9; + public bool DummyBool10; + public bool DummyBool11; + public bool DummyBool12; + public bool DummyBool13; + public bool DummyBool14; + public bool DummyBool15; + public bool DummyBool16; + public bool DummyBool17; + public bool DummyBool18; + public bool IsCountingOutputCrossMode; + public bool DummyBool20; + public bool IsStartStopLog; + public bool IsEthernetPingTimer; + public bool IsCharToFillZeroEthernet; + public bool IsTransmitWhenPassEthernet; + public bool IsCharToFillZeroCOM1; + public bool IsTransmitWhenPassCOM1; + public bool IsCharToFillZeroCOM3; + public bool IsTransmitWhenPassCOM3; + public bool IsCharToFillZeroCOM4; + public bool IsTransmitWhenPassCOM4; + + public int DummyInt1; + public int DummyInt2; + public int DummyInt3; + public int DummyInt4; + public int DummyInt5; + public int DummyInt6; + public int DummyInt7; + public int DummyInt8; + public int DummyInt9; + public int DummyInt10; + public int DummyInt11; + public int DummyInt12; + public int DummyInt13; + public int DummyInt14; + public int DummyInt15; + public int DummyInt16; + public int DummyInt17; + public int DummyInt18; + public int DummyInt19; + public int DummyInt20; + public int DummyInt21; + public int DummyInt22; + public int DummyInt23; + public int SensorErrorDetectingTime; + public int LOTExtractDataFromIndex; + public int LOTExtractDataToIndex; + public int ModbusTCPStartAddress; + public int ModbusRTUStartAddressCOM1; + public int ModbusRTUStartAddressCOM3; + public int ModbusRTUStartAddressCOM4; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString6; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString7; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString8; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString9; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString10; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString11; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString12; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString13; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString14; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString15; + } + #endregion + + #region ProductItem + public class ProductItem + { + #region Field + private int m_Number; + + private string m_Name; + private string m_LotNo; + private string m_UnderRange; + private string m_PassRange; + private string m_OverRange; + private string m_TareRange; + private string m_SensingTime; + private string m_DispenserDelayTime1; + private string m_DispenserDelayTime2; + private string m_Sorting; + + private int m_ProgressBarMaximum; + private int m_ProgressBarMinimum; + + private Collection m_CollectionNormalDistributionRange; + private Collection m_CollectionNormalDistributionViewRange; + #endregion + + #region Constructor + public ProductItem() + { + this.Initialization(); + } + #endregion + + #region Property + public int Number + { + get { return this.m_Number; } + set { this.m_Number = value; } + } + + public string Name + { + get { return this.m_Name; } + set { this.m_Name = value; } + } + public string LotNo + { + get { return this.m_LotNo; } + set { this.m_LotNo = value; } + } + public string UnderRange + { + get { return this.m_UnderRange; } + set + { + this.m_UnderRange = value; + + this.ProgressBarLevelRescale(); + this.NormalDistributionRangeCalculation(); + } + } + public string PassRange + { + get { return this.m_PassRange; } + set + { + this.m_PassRange = value; + + this.NormalDistributionRangeCalculation(); + } + } + public string OverRange + { + get { return this.m_OverRange; } + set + { + this.m_OverRange = value; + + this.ProgressBarLevelRescale(); + this.NormalDistributionRangeCalculation(); + } + } + public string TareRange + { + get { return this.m_TareRange; } + set { this.m_TareRange = value; } + } + public string DispenserDelayTime1 + { + get { return this.m_DispenserDelayTime1; } + set { this.m_DispenserDelayTime1 = value; } + } + public string DispenserDelayTime2 + { + get { return this.m_DispenserDelayTime2; } + set { this.m_DispenserDelayTime2 = value; } + } + public string Sorting + { + get { return this.m_Sorting; } + set { this.m_Sorting = value; } + } + + public int OverRangeDeviation + { + get { return this.OverRangeInt - this.PassRangeInt; } + //set + //{ + // int iValue = 0; + + // iValue = this.OverRangeInt - Math.Abs(value); + + // this.m_OverRange = iValue.ToString(); + // this.m_OverRangeDeviation = value; + //} + } + public int UnderRangeDeviation + { + get { return this.UnderRangeInt - this.PassRangeInt; } + //set + //{ + // int iValue = 0; + + // iValue = this.UnderRangeInt - Math.Abs(value); + + // this.m_UnderRange = iValue.ToString(); + // this.m_UnderRangeDeviation = value; + //} + } + + public int UnderRangeInt + { + get + { + if (this.UnderRange == null) + return -1; + else + return int.Parse(this.UnderRange); + } + } + public int PassRangeInt + { + get + { + if (this.PassRange == null) + return -1; + else + return int.Parse(this.PassRange); + } + } + public int OverRangeInt + { + get + { + if (this.OverRange == null) + return -1; + else + return int.Parse(this.OverRange); + } + } + public int TareRangeInt + { + get { return int.Parse(this.TareRange); } + } + public string SensingTime + { + get { return this.m_SensingTime; } + set { this.m_SensingTime = value; } + } + + public int ProgressBarMaximum + { + get { return this.m_ProgressBarMaximum; } + private set { this.m_ProgressBarMaximum = value; } + } + public int ProgressBarMinimum + { + get { return this.m_ProgressBarMinimum; } + private set { this.m_ProgressBarMinimum = value; } + } + + public Collection CollectionNormalDistributionRange + { + get { return this.m_CollectionNormalDistributionRange; } + private set { this.m_CollectionNormalDistributionRange = value; } + } + public Collection CollectionNormalDistributionViewRange + { + get { return this.m_CollectionNormalDistributionViewRange; } + private set { this.m_CollectionNormalDistributionViewRange = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.CollectionNormalDistributionRange = new Collection(); + this.CollectionNormalDistributionRange.Clear(); + for (int i = 0; i < 8; i++) + this.CollectionNormalDistributionRange.Add(0); + + this.CollectionNormalDistributionViewRange = new Collection(); + this.CollectionNormalDistributionViewRange.Clear(); + for (int i = 0; i < 9; i++) + this.CollectionNormalDistributionViewRange.Add(0); + + this.Number = 1; + this.Name = "Product 1"; + this.LotNo = "Lot 1"; + this.PassRange = "2000"; + this.UnderRange = "1000"; + this.OverRange = "3000"; + this.TareRange = "0"; + this.SensingTime = "0"; + this.DispenserDelayTime1 = "200"; + this.DispenserDelayTime2 = "200"; + this.Sorting = "0"; + + this.ProgressBarMinimum = 0; + this.ProgressBarMaximum = 5000; + } + + private void ProgressBarLevelRescale() + { + int minBar, maxBar, gap; + int OverRange, UnderRange; + + if (this.OverRange == null || this.UnderRange == null) + return; + + OverRange = int.Parse(this.OverRange); + UnderRange = int.Parse(this.UnderRange); + + gap = OverRange - UnderRange; + + minBar = UnderRange - gap; + maxBar = OverRange + gap; + + this.ProgressBarMaximum = maxBar; + this.ProgressBarMinimum = minBar; + } + + private void NormalDistributionRangeCalculation() + { + int overGap = 0, underGap = 0, gap = 0, gap1 = 0; + + if (this.OverRangeInt == -1 || this.PassRangeInt == -1 || this.UnderRangeInt == -1) + return; + + overGap = this.OverRangeInt - this.PassRangeInt; + underGap = this.PassRangeInt - this.UnderRangeInt; + + if (overGap > underGap) + gap = overGap; + else + gap = underGap; + + gap1 = gap / 5; + + if (gap1 == 0) + gap1 = gap; + + this.CollectionNormalDistributionViewRange[0] = gap1 * 12; + this.CollectionNormalDistributionViewRange[1] = gap1 * 9; + this.CollectionNormalDistributionViewRange[2] = gap1 * 6; + this.CollectionNormalDistributionViewRange[3] = gap1 * 3; + this.CollectionNormalDistributionViewRange[4] = 0; + this.CollectionNormalDistributionViewRange[5] = gap1 * 3; + this.CollectionNormalDistributionViewRange[6] = gap1 * 6; + this.CollectionNormalDistributionViewRange[7] = gap1 * 9; + this.CollectionNormalDistributionViewRange[8] = gap1 * 12; + + this.CollectionNormalDistributionRange[0] = this.PassRangeInt + (gap1 * 9) + 1; + this.CollectionNormalDistributionRange[1] = this.PassRangeInt + (gap1 * 6) + 1; + this.CollectionNormalDistributionRange[2] = this.PassRangeInt + (gap1 * 3) + 1; + this.CollectionNormalDistributionRange[3] = this.PassRangeInt + gap1 + 1; + this.CollectionNormalDistributionRange[4] = this.PassRangeInt - gap1 + 1; + this.CollectionNormalDistributionRange[5] = this.PassRangeInt - (gap1 * 3) + 1; + this.CollectionNormalDistributionRange[6] = this.PassRangeInt - (gap1 * 6) + 1; + this.CollectionNormalDistributionRange[7] = this.PassRangeInt - (gap1 * 9) + 1; + } + #endregion + } + #endregion + #region StructProductItem + #region ~V7 + //[StructLayout(LayoutKind.Sequential)] + //public struct StructProductItem + //{ + // public int Number; + + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + // public string Name; + + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + // public string LotNo; + + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + // public string OverRange; + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + // public string UnderRange; + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + // public string PassRange; + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + // public string TareRange; + + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + // public string SensingTime; + + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + // public string DummyString1; + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + // public string DummyString2; + // [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + // public string DummyString3; + //} + #endregion + [StructLayout(LayoutKind.Sequential)] + public struct StructProductItemUntilV7 + { + public int Number; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string Name; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string LotNo; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string OverRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string UnderRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string PassRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string TareRange; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string SensingTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString3; + } + [StructLayout(LayoutKind.Sequential)] + public struct StructProductItem + { + public int Number; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string Name; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string LotNo; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string OverRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string UnderRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string PassRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string TareRange; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string SensingTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DispenserDelayTime1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DispenserDelayTime2; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Sorting; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString6; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string DummyString7; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString8; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 40)] + public string DummyString9; + } + #endregion + + #region WeightData + public class WeightData + { + #region Field + private bool m_IsLoadCellError; + private bool m_IsEntrySensorError; + private bool m_IsInverterError; + private bool m_IsPressureSensingError; + private bool m_IsMetalError; + private bool m_IsEmergencyStop; + private bool m_IsDoorInterlock; + private bool m_IsSorterError; + private bool m_IsStackUpSensorError; + private bool m_IsWindProofError; + + private DateTime m_StartTime; + private DateTime m_StopTime; + + private int m_UnderCount; + private double m_UnderSumWeight; + + private int m_PassCount; + private double m_PassSumWeight; + + private int m_OverCount; + private double m_OverSumWeight; + + private int m_ExNGCount; + private double m_Weight; + private DataStore.JudgmentStatus m_JudgmentStatus; + private DataStore.WeightStatus m_Status; + + private string m_ADCValue; + private int m_ProductionSpeed; + + private int PreviousTimeTickCount; + private bool m_IsStart; + + private string m_WeightString; + + private Collection m_CollectionNormalDistributionCount; + + private string m_ReceiveDataID; + private string m_ReceiveTransferCount; + + private int m_BoardProductNumber; + private int m_BoardUnderCount; + private int m_BoardPassCount; + private int m_BoardOverCount; + private int m_BoardExNGCount; + private int m_BoardNGCount; + private int m_BoardTotalCount; + #endregion + + #region Constructor + public WeightData() + { + this.Initialization(); + } + #endregion + + #region Property + public bool IsLoadCellError + { + get { return this.m_IsLoadCellError; } + set { this.m_IsLoadCellError = value; } + } + public bool IsEntrySensorError + { + get { return this.m_IsEntrySensorError; } + set { this.m_IsEntrySensorError = value; } + } + public bool IsInverterError + { + get { return this.m_IsInverterError; } + set { this.m_IsInverterError = value; } + } + public bool IsPressureSensingError + { + get { return this.m_IsPressureSensingError; } + set { this.m_IsPressureSensingError = value; } + } + public bool IsMetalError + { + get { return this.m_IsMetalError; } + set { this.m_IsMetalError = value; } + } + public bool IsEmergencyStop + { + get { return this.m_IsEmergencyStop; } + set { this.m_IsEmergencyStop = value; } + } + public bool IsDoorInterlock + { + get { return this.m_IsDoorInterlock; } + set { this.m_IsDoorInterlock = value; } + } + public bool IsSorterError + { + get { return this.m_IsSorterError; } + set { this.m_IsSorterError = value; } + } + public bool IsStackUpSensorError + { + get { return this.m_IsStackUpSensorError; } + set { this.m_IsStackUpSensorError = value; } + } + public bool IsWindProofError + { + get { return this.m_IsWindProofError; } + set { this.m_IsWindProofError = value; } + } + + public DateTime StartTime + { + get { return this.m_StartTime; } + set { this.m_StartTime = value; } + } + public DateTime StopTime + { + get { return this.m_StopTime; } + set { this.m_StopTime = value; } + } + + public int UnderCount + { + get { return this.m_UnderCount; } + set { this.m_UnderCount = value; } + } + public double UnderSumWeight + { + get { return this.m_UnderSumWeight; } + set { this.m_UnderSumWeight = value; } + } + public string UnderRatio + { + get + { + string ret = ""; + + if (this.UnderCount == 0 || this.TotalCount == 0) + ret = "0.00"; + else + ret = string.Format("{0:##0.00}", (float.Parse(this.UnderCount.ToString()) * 100.0F) / this.TotalCount); + + return ret; + } + } + public double UnderAverage + { + get + { + double ret = 0.0; + + if (this.UnderCount == 0 || this.UnderSumWeight == 0.0) + ret = 0.0; + else + ret = this.UnderSumWeight / this.UnderCount; + + return ret; + } + } + public string UnderSumWeightKG + { + get + { + string temp = "", ret = ""; + + temp = string.Format("{0:f0}", this.UnderSumWeight); + ret = string.Format("{0}", int.Parse(temp) / 1000); + + return ret; + } + } + + public int PassCount + { + get { return this.m_PassCount; } + set { this.m_PassCount = value; } + } + public double PassSumWeight + { + get { return this.m_PassSumWeight; } + set { this.m_PassSumWeight = value; } + } + public string PassRatio + { + get + { + string ret = ""; + + if (this.PassCount == 0 || this.TotalCount == 0) + ret = "0.00"; + else + ret = string.Format("{0:##0.00}", (float.Parse(this.PassCount.ToString()) * 100.0F) / this.TotalCount); + + return ret; + } + } + public double PassAverage + { + get + { + double ret = 0.0; + + if (this.PassCount == 0 || this.PassSumWeight == 0.0) + ret = 0.0; + else + ret = this.PassSumWeight / this.PassCount; + + return ret; + } + } + public string PassSumWeightKG + { + get + { + string temp = "", ret = ""; + + temp = string.Format("{0:f0}", this.PassSumWeight); + ret = string.Format("{0}", int.Parse(temp) / 1000); + + return ret; + } + } + + public int OverCount + { + get { return this.m_OverCount; } + set { this.m_OverCount = value; } + } + public double OverSumWeight + { + get { return this.m_OverSumWeight; } + set { this.m_OverSumWeight = value; } + } + public string OverRatio + { + get + { + string ret = ""; + + if (this.OverCount == 0 || this.TotalCount == 0) + ret = "0.00"; + else + ret = string.Format("{0:##0.00}", (float.Parse(this.OverCount.ToString()) * 100.0F) / this.TotalCount); + + return ret; + } + } + public double OverAverage + { + get + { + double ret = 0.0; + + if (this.OverCount == 0 || this.OverSumWeight == 0.0) + ret = 0.0; + else + ret = this.OverSumWeight / this.OverCount; + + return ret; + } + } + public string OverSumWeightKG + { + get + { + string temp = "", ret = ""; + + temp = string.Format("{0:f0}", this.OverSumWeight); + ret = string.Format("{0}", int.Parse(temp) / 1000); + + return ret; + } + } + + public int ExNGCount + { + get { return this.m_ExNGCount; } + set { this.m_ExNGCount = value; } + } + + public int TotalUnderOverCount + { + get { return this.UnderCount + this.OverCount; } + } + public int TotalNGCount + { + get { return this.UnderCount + this.OverCount + this.ExNGCount; } + } + + public int TotalCount + { + get { return this.UnderCount + this.PassCount + this.OverCount + this.ExNGCount; } + } + + public double Weight + { + get { return this.m_Weight; } + set { this.m_Weight = value; } + } + + public string ADCValue + { + get { return this.m_ADCValue; } + set { this.m_ADCValue = value; } + } + + public DataStore.JudgmentStatus JudgmentStatus + { + get { return this.m_JudgmentStatus; } + set + { + this.m_JudgmentStatus = value; + + if (value == DataStore.JudgmentStatus.Under) + { + if (this.UnderCount < 10000000) + this.UnderCount++; + else + this.UnderCount = 0; + } + else if (value == DataStore.JudgmentStatus.Pass) + { + if (this.PassCount < 10000000) + this.PassCount++; + else + this.PassCount = 0; + } + else if (value == DataStore.JudgmentStatus.Over) + { + if (this.OverCount < 10000000) + this.OverCount++; + else + this.OverCount = 0; + } + else if (value == DataStore.JudgmentStatus.Double || value == DataStore.JudgmentStatus.Metal + || value == DataStore.JudgmentStatus.ExNg || value == DataStore.JudgmentStatus.ExNg1 || value == DataStore.JudgmentStatus.ExNg2 + || value == DataStore.JudgmentStatus.LengthError) + { + if (this.ExNGCount < 10000000) + this.ExNGCount++; + else + this.ExNGCount = 0; + } + } + } + + public DataStore.WeightStatus Status + { + get { return this.m_Status; } + set { this.m_Status = value; } + } + + public int ProductionSpeed + { + get { return this.m_ProductionSpeed; } + set { this.m_ProductionSpeed = value; } + } + // 미사용 + public bool IsStart + { + get { return this.m_IsStart; } + set { this.m_IsStart = value; } + } + + public string WeightString + { + get { return this.m_WeightString; } + set { this.m_WeightString = value; } + } + + public Collection CollectionNormalDistributionCount + { + get { return this.m_CollectionNormalDistributionCount; } + set { this.m_CollectionNormalDistributionCount = value; } + } + + public string ReceiveDataID + { + get { return this.m_ReceiveDataID; } + private set { this.m_ReceiveDataID = value; } + } + public string ReceiveTransferCount + { + get { return this.m_ReceiveTransferCount; } + private set { this.m_ReceiveTransferCount = value; } + } + + public int BoardProductNumber + { + get { return this.m_BoardProductNumber; } + set { this.m_BoardProductNumber = value; } + } + public int BoardUnderCount + { + get { return this.m_BoardUnderCount; } + set { this.m_BoardUnderCount = value; } + } + public int BoardPassCount + { + get { return this.m_BoardPassCount; } + set { this.m_BoardPassCount = value; } + } + public int BoardOverCount + { + get { return this.m_BoardOverCount; } + set { this.m_BoardOverCount = value; } + } + public int BoardExNGCount + { + get { return this.m_BoardExNGCount; } + set { this.m_BoardExNGCount = value; } + } + public int BoardNGCount + { + get { return this.BoardUnderCount + this.BoardOverCount; } + } + public int BoardTotalCount + { + get { return this.BoardUnderCount + this.BoardPassCount + this.BoardOverCount + this.BoardExNGCount; } + } + #endregion + + #region Mehtod + public void ClearCount() + { + this.UnderCount = 0; + this.UnderSumWeight = 0.0; + this.PassCount = 0; + this.PassSumWeight = 0.0; + this.OverCount = 0; + this.OverSumWeight = 0.0; + this.ExNGCount = 0; + + this.StartTime = new DateTime(1111, 11, 11, 11, 11, 11); + this.StopTime = new DateTime(1111, 11, 11, 11, 11, 11); + + for (int i = 0; i < this.CollectionNormalDistributionCount.Count; i++) + this.CollectionNormalDistributionCount[i] = 0; + } + + private void Initialization() + { + this.IsLoadCellError = false; + this.IsEntrySensorError = false; + this.IsInverterError = false; + this.IsPressureSensingError = false; + this.IsMetalError = false; + this.IsDoorInterlock = false; + this.IsSorterError = false; + this.IsStackUpSensorError = false; + this.IsWindProofError = false; + + this.StartTime = new DateTime(1111, 11, 11, 11, 11, 11); + this.StopTime = new DateTime(1111, 11, 11, 11, 11, 11); + this.UnderCount = 0; + this.UnderSumWeight = 0.0; + this.PassCount = 0; + this.PassSumWeight = 0.0; + this.OverCount = 0; + this.OverSumWeight = 0.0; + this.ExNGCount = 0; + this.Weight = 0.0; + this.ADCValue = "12345"; + this.JudgmentStatus = DataStore.JudgmentStatus.Empty; + this.Status = DataStore.WeightStatus.Empty; + this.ProductionSpeed = 0; + this.WeightString = "0"; + + this.CollectionNormalDistributionCount = new Collection(); + this.CollectionNormalDistributionCount.Clear(); + for (int i = 0; i < 10; i++) + this.CollectionNormalDistributionCount.Add(0); + + this.ReceiveDataID = "0"; + this.ReceiveTransferCount = "0"; + + this.BoardProductNumber = 1; + this.BoardOverCount = 0; + this.BoardPassCount = 0; + this.BoardUnderCount = 0; + this.BoardExNGCount = 0; + } + + // 미사용 + private void ProductionSpeedCalculation() + { + int currentTimeTickCount = 0, gap = 0; + double millisecond = 0.0, speed = 0.0; + + if (this.IsStart == false) + { + this.PreviousTimeTickCount = Environment.TickCount & Int32.MaxValue; + this.IsStart = true; + } + else + { + currentTimeTickCount = Environment.TickCount & Int32.MaxValue; + gap = Math.Abs(currentTimeTickCount - this.PreviousTimeTickCount); + millisecond = gap / 1000.0; + speed = 60 / millisecond; + this.ProductionSpeed = int.Parse(string.Format("{0:f0}", speed)); + + this.PreviousTimeTickCount = Environment.TickCount; + } + } + + public void WeightSum(DataStore.JudgmentStatus status) + { + if (status == DataStore.JudgmentStatus.Over) + this.OverSumWeight += this.Weight; + else if (status == DataStore.JudgmentStatus.Pass) + this.PassSumWeight += this.Weight; + else if (status == DataStore.JudgmentStatus.Under) + { + if (this.Weight > 0.0) + this.UnderSumWeight += this.Weight; + } + } + + public void SetNormalDistribution(Collection collectionRange, string weight) + { + int value = 0; + + value = int.Parse(weight); + + for (int i = 0; i < this.CollectionNormalDistributionCount.Count; i++) + { + if (i == collectionRange.Count) + { + this.CollectionNormalDistributionCount[i]++; + break; + } + + if (collectionRange[i] < value) + { + this.CollectionNormalDistributionCount[i]++; + break; + } + } + } + + public void SetDataIDTransferCount(string dataId, string transferCount) + { + this.ReceiveDataID = dataId; + this.ReceiveTransferCount = transferCount; + } + #endregion + } + #endregion + #region StructCounter + [StructLayout(LayoutKind.Sequential)] + public struct StructCounterItem + { + public int OverCount; + public int PassCount; + public int UnderCount; + public int ExNGCount; + + public int NormalDistribution1; + public int NormalDistribution2; + public int NormalDistribution3; + public int NormalDistribution4; + public int NormalDistribution5; + public int NormalDistribution6; + public int NormalDistribution7; + public int NormalDistribution8; + public int NormalDistribution9; + public int NormalDistribution10; + + public double OverSumWeight; + public double PassSumWeight; + public double UnderSumWeight; + + public DateTime StartTime; + public DateTime StopTime; + + public int DummyInt1; + public int DummyInt2; + public int DummyInt3; + public int DummyInt4; + public int DummyInt5; + } + #endregion + + #region AverageTrackingData + public class AverageTrackingItem + { + #region Field + private string m_LimitOver; + private string m_LimitUnder; + + private Queue m_QueueWeight; + + private int m_SumWeight; + #endregion + + #region Constructor + public AverageTrackingItem() + { + this.Initialization(); + } + #endregion + + #region Property + public string LimitUnder + { + get { return this.m_LimitUnder; } + set { this.m_LimitUnder = value; } + } + public string LimitOver + { + get { return this.m_LimitOver; } + set { this.m_LimitOver = value; } + } + + public Queue QueueWeight + { + get { return this.m_QueueWeight; } + private set { this.m_QueueWeight = value; } + } + + public int SumWeight + { + get { return this.m_SumWeight; } + private set { this.m_SumWeight = value; } + } + + public int GetQueueCount + { + get { return this.QueueWeight.Count; } + } + public int GetAverageWeight + { + get + { + int value = 0; + + if (this.QueueWeight.Count == 0) + return value; + + try + { + value = this.SumWeight / this.GetQueueCount; + return value; + } + catch + { + return value; + } + } + } + #endregion + + #region Method + public void Initialization() + { + this.LimitOver = "99999"; + this.LimitUnder = "0"; + + this.QueueWeight = new Queue(); + + this.SumWeight = 0; + } + + public void SetValue(int value, int trackingCount) + { + int iValue = 0; + + if (this.QueueWeight.Count == trackingCount) + { + iValue = this.QueueWeight.Dequeue(); + this.SumWeight -= iValue; + } + + this.QueueWeight.Enqueue(value); + this.SumWeight += value; + } + + public void DataClear() + { + this.QueueWeight.Clear(); + this.SumWeight = 0; + } + #endregion + } + #endregion + #region StructAverageTracking + [StructLayout(LayoutKind.Sequential)] + public struct StructAverageTrackingItem + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string LimitOver; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string LimitUnder; + + public int DummyInt1; + public int DummyInt2; + public int DummyInt3; + public int DummyInt4; + public int DummyInt5; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string DummyString2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string DummyString3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string DummyString4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] + public string DummyString5; + } + #endregion + + #region JudgmentSetItem + public class JudgmentSetItem + { + #region Field + private int m_Filter; + private int m_JudgmentDelayTime; + private int m_DoubleDelayTime; + private int m_JudgmentCount; + private int m_FeedSpeed1; + private int m_FeedSpeed2; + private int m_FeedSpeed3; + private double m_DynamicCorrection; + + private int m_Sorter1Mode; + private int m_Sorter1DelayTime; + private int m_Sorter1RunTime; + private int m_Sorter2Mode; + private int m_Sorter2DelayTime; + private int m_Sorter2RunTime; + + private int m_ProductLength; + private int m_AutoJudgmentTime; + private int m_AutoJudgment2; + private int m_AutoJudgment3; + + private int m_AscendDelayTime; + private int m_DescendDelayTime; + #endregion + + #region Constructor + public JudgmentSetItem() + { + this.Initialization(); + } + #endregion + + #region Property + public int Filter + { + get { return this.m_Filter; } + set { this.m_Filter = value; } + } + public int JudgmentDelayTime + { + get { return this.m_JudgmentDelayTime; } + set { this.m_JudgmentDelayTime = value; } + } + public int DoubleDelayTime + { + get { return this.m_DoubleDelayTime; } + set { this.m_DoubleDelayTime = value; } + } + public int JudgmentCount + { + get { return this.m_JudgmentCount; } + set { this.m_JudgmentCount = value; } + } + public int FeedSpeed1 + { + get { return this.m_FeedSpeed1; } + set { this.m_FeedSpeed1 = value; } + } + public int FeedSpeed2 + { + get { return this.m_FeedSpeed2; } + set { this.m_FeedSpeed2 = value; } + } + public int FeedSpeed3 + { + get { return this.m_FeedSpeed3; } + set { this.m_FeedSpeed3 = value; } + } + public double DynamicCorrection + { + get { return this.m_DynamicCorrection; } + set { this.m_DynamicCorrection = value; } + } + public int DescendDelayTime + { + get { return this.m_DescendDelayTime; } + set { this.m_DescendDelayTime = value; } + } + public int AscendDelayTime + { + get { return this.m_AscendDelayTime; } + set { this.m_AscendDelayTime = value; } + } + + public int Sorter1Mode + { + get { return this.m_Sorter1Mode; } + set { this.m_Sorter1Mode = value; } + } + public int Sorter1DelayTime + { + get { return this.m_Sorter1DelayTime; } + set { this.m_Sorter1DelayTime = value; } + } + public int Sorter1RunTime + { + get { return this.m_Sorter1RunTime; } + set { this.m_Sorter1RunTime = value; } + } + public int Sorter2Mode + { + get { return this.m_Sorter2Mode; } + set { this.m_Sorter2Mode = value; } + } + public int Sorter2DelayTime + { + get { return this.m_Sorter2DelayTime; } + set { this.m_Sorter2DelayTime = value; } + } + public int Sorter2RunTime + { + get { return this.m_Sorter2RunTime; } + set { this.m_Sorter2RunTime = value; } + } + + public int ProductLength + { + get { return this.m_ProductLength; } + set { this.m_ProductLength = value; } + } + public int AutoJudgment1 + { + get { return this.m_AutoJudgmentTime; } + set { this.m_AutoJudgmentTime = value; } + } + public int AutoJudgment2 + { + get { return this.m_AutoJudgment2; } + set { this.m_AutoJudgment2 = value; } + } + public int AutoJudgment3 + { + get { return this.m_AutoJudgment3; } + set { this.m_AutoJudgment3 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.Filter = 8; + this.JudgmentDelayTime = 1000; + this.DoubleDelayTime = 900; + this.JudgmentCount = 10; + this.FeedSpeed1 = 60; + this.FeedSpeed2 = 60; + this.FeedSpeed3 = 60; + this.DynamicCorrection = 1.000000; + this.AscendDelayTime = 1000; + this.DescendDelayTime = 1000; + + this.Sorter1Mode = 0; + this.Sorter1DelayTime = 1; + this.Sorter1RunTime = 1000; + this.Sorter2Mode = 0; + this.Sorter2DelayTime = 1; + this.Sorter2RunTime = 1000; + + this.ProductLength = 100; + this.AutoJudgment1 = 100; + this.AutoJudgment2 = 100; + this.AutoJudgment3 = 100; + } + #endregion + } + #endregion + #region Struct JudgmentSetItem + [StructLayout(LayoutKind.Sequential)] + public struct StructJudgmentSetItem + { + public int Filter; + public int JudgmentDelayTime; + public int DoubleDelayTime; + public int JudgmentCount; + public int FeedSpeed1; + public int FeedSpeed2; + public int FeedSpeed3; + public double DynamicCorrection; + + public int Sorter1Mode; + public int Sorter1DelayTime; + public int Sorter1RunTime; + public int Sorter2Mode; + public int Sorter2DelayTime; + public int Sorter2RunTime; + + public int ProductLength; + public int AutoJudgment1; + public int AutoJudgment2; + public int AutoJudgment3; + + public int DescendDelayTime; + public int AscendDelayTime; + public int DummyInt1; + public int DummyInt2; + public int DummyInt3; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string DummyString5; + } + #endregion + + #region CalibrationItem + public class CalibrationItem + { + #region Field + private string m_BalanceWeight; + private string m_MaxWeight; + private string m_Digit; + private string m_Constant; + #endregion + + #region Constructor + public CalibrationItem() + { + this.BalanceWeight = "5000"; + this.MaxWeight = "9999"; + this.Digit = "1"; + this.Constant = "1000000"; + } + #endregion + + #region Property + public string BalanceWeight + { + get { return this.m_BalanceWeight; } + set { this.m_BalanceWeight = value; } + } + + public string MaxWeight + { + get { return this.m_MaxWeight; } + set { this.m_MaxWeight = value; } + } + public string OverloadWeightString + { + get { return string.Format("{0, 5}", Math.Floor(double.Parse(this.MaxWeight) * 1.1)); } + } + + public string Digit + { + get { return this.m_Digit; } + set { this.m_Digit = value; } + } + + public string Constant + { + get { return this.m_Constant; } + set { this.m_Constant = value; } + } + #endregion + } + #endregion + + #region FeedbackItem + public class FeedbackItem + { + #region Field + private bool m_IsUsingFeedback; + + private string m_SampleCount; + private string m_DelayCount; + private string m_Sign; + private string m_FeedbackWeight; + + private string m_UnderRangeDeviation; + private string m_OverRangeDeviation; + #endregion + + #region Constructor + public FeedbackItem() + { + this.IsUsingFeedback = false; + + this.SampleCount = "0"; + this.DelayCount = "0"; + this.Sign = "+"; + this.FeedbackWeight = "0"; + + this.UnderRangeDeviation = "0"; + this.OverRangeDeviation = "0"; + } + #endregion + + #region Property + public bool IsUsingFeedback + { + get { return this.m_IsUsingFeedback; } + set { this.m_IsUsingFeedback = value; } + } + + public string SampleCount + { + get { return this.m_SampleCount; } + set { this.m_SampleCount = value; } + } + public string DelayCount + { + get { return this.m_DelayCount; } + set { this.m_DelayCount = value; } + } + public string Sign + { + get { return this.m_Sign; } + set { this.m_Sign = value; } + } + public string FeedbackWeight + { + get { return this.m_FeedbackWeight; } + set { this.m_FeedbackWeight = value; } + } + + + public string UnderRangeDeviation + { + get { return this.m_UnderRangeDeviation; } + set { this.m_UnderRangeDeviation = value; } + } + public string OverRangeDeviation + { + get { return this.m_OverRangeDeviation; } + set { this.m_OverRangeDeviation = value; } + } + public int OverRangeDeviationInt + { + get + { + if (this.OverRangeDeviation == null) + return -1; + else + return int.Parse(this.OverRangeDeviation); + } + } + public int UnderRangeDeviationInt + { + get + { + if (this.UnderRangeDeviation == null) + return -1; + else + return int.Parse(this.UnderRangeDeviation); + } + } + + #endregion + + #region Method + #endregion + } + #endregion + + #region SystemParameter1 + public class SystemParameter1 + { + #region Field + + private string m_BuzzerOnTime; + private string m_RelayOnTime; + private string m_SorterDoubleEntry; + private string m_Chattering; + private string m_SorterExternalNgInput; + private string m_SorterEtcNg; + private string m_StopWeighing; + private string m_OptionBoard; + private string m_InitialDrive; + + private int m_PI2; + private int m_PI3; + private int m_PI4; + private int m_PI5; + private int m_PI6; + private int m_PI7; + private int m_PI8; + + private string m_SortingWhenNGLength; + private string m_SortingByProductNo; + private string m_Inverter; + private string m_EquipmentType; + #endregion + + #region Constructor + public SystemParameter1() + { + this.Initialization(); + } + #endregion + + #region Property + public string BuzzerOnTime + { + get { return this.m_BuzzerOnTime; } + set { this.m_BuzzerOnTime = value; } + } + public string RelayOnTime + { + get { return this.m_RelayOnTime; } + set { this.m_RelayOnTime = value; } + } + public string SorterDoubleEntry + { + get { return this.m_SorterDoubleEntry; } + set { this.m_SorterDoubleEntry = value; } + } + public string Chattering + { + get { return this.m_Chattering; } + set { this.m_Chattering = value; } + } + public string SorterExternalNgInput + { + get { return this.m_SorterExternalNgInput; } + set { this.m_SorterExternalNgInput = value; } + } + public string SorterEtcNg + { + get { return this.m_SorterEtcNg; } + set { this.m_SorterEtcNg = value; } + } + public string StopWeighing + { + get { return this.m_StopWeighing; } + set { this.m_StopWeighing = value; } + } + public string OptionBoard + { + get { return this.m_OptionBoard; } + set { this.m_OptionBoard = value; } + } + public string InitialDrive + { + get { return this.m_InitialDrive; } + set { this.m_InitialDrive = value; } + } + + public int PI2 + { + get { return this.m_PI2; } + set { this.m_PI2 = value; } + } + public int PI3 + { + get { return this.m_PI3; } + set { this.m_PI3 = value; } + } + public int PI4 + { + get { return this.m_PI4; } + set { this.m_PI4 = value; } + } + public int PI5 + { + get { return this.m_PI5; } + set { this.m_PI5 = value; } + } + public int PI6 + { + get { return this.m_PI6; } + set { this.m_PI6 = value; } + } + public int PI7 + { + get { return this.m_PI7; } + set { this.m_PI7 = value; } + } + public int PI8 + { + get { return this.m_PI8; } + set { this.m_PI8 = value; } + } + + public string EquipmentType + { + get { return this.m_EquipmentType; } + set { this.m_EquipmentType = value; } + } + + public string SortingWhenNGLength + { + get { return this.m_SortingWhenNGLength; } + set { this.m_SortingWhenNGLength = value; } + } + public string SortingByProductNo + { + get { return this.m_SortingByProductNo; } + set { this.m_SortingByProductNo = value; } + } + public string Inverter + { + get { return this.m_Inverter; } + set { this.m_Inverter = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.BuzzerOnTime = "1000"; + this.RelayOnTime = "1000"; + this.Chattering = "100"; + this.SorterDoubleEntry = "0"; + this.SorterExternalNgInput = "0"; + this.SorterEtcNg = "0"; + this.StopWeighing = "0"; + this.OptionBoard = "0"; + this.InitialDrive = "0"; + + this.PI2 = 0; + this.PI3 = 0; + this.PI4 = 0; + this.PI5 = 0; + this.PI6 = 0; + this.PI7 = 0; + this.PI8 = 0; + + this.EquipmentType = "0"; + + this.SortingWhenNGLength = "0"; + this.SortingByProductNo = "0"; + this.Inverter = "0"; + } + #endregion + } + #endregion + #region StructSystemParameter1 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemParameter1 + { + public int PI2; + public int PI3; + public int PI4; + public int PI5; + public int PI6; + public int PI7; + public int PI8; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string BuzzerOnTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string RelayOnTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SorterDoubleEntry; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Chattering; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SorterExternalNgInput; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SorterEtcNgInput; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string StopWeighing; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OptionBoard; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string InitialDrive; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string EquipmentType; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SortingWhenNGLength; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SortingByProductNo; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Inverter; + } + #endregion + #region StructSystemParameter1V1V2 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemParameter1V1V2 + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Serial1Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Serial1BaudRate; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string BuzzerOnTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string RelayOnTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Chattering; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SorterDoubleEntry; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SorterExternalNgInput; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string StopWeighting; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOperation; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string InitialDrive; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string PressureSensing; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string StackSensing; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string SorterDetecting; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OptionBoard; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string EntryStopper; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy6; + } + #endregion + #region SystemParameter2 + public class SystemParameter2 + { + #region Field + private string m_OPT1SamplingCount; + private string m_OPT1DelayCount; + private string m_OPT1PulseWidth; + private string m_OPT1IsWeightSetting; + private string m_OPT1OverRange; + private string m_OPT1UnderRange; + private string m_OPT1Port; + + private string m_OPT2Port; + private string m_OPT2DelayTime1; + private string m_OPT2DelayTime2; + + private string m_Dummy1; + private string m_Dummy2; + private string m_Dummy3; + private string m_Dummy4; + private string m_Dummy5; + private string m_Dummy6; + private string m_Dummy7; + #endregion + + #region Constructor + public SystemParameter2() + { + this.Initialization(); + } + #endregion + + #region Property + public string OPT1SamplingCount + { + get { return this.m_OPT1SamplingCount; } + set { this.m_OPT1SamplingCount = value; } + } + public string OPT1DelayCount + { + get { return this.m_OPT1DelayCount; } + set { this.m_OPT1DelayCount = value; } + } + public string OPT1PulseWidth + { + get { return this.m_OPT1PulseWidth; } + set { this.m_OPT1PulseWidth = value; } + } + public string OPT1IsWeightSetting + { + get { return this.m_OPT1IsWeightSetting; } + set { this.m_OPT1IsWeightSetting = value; } + } + public string OPT1OverRange + { + get { return this.m_OPT1OverRange; } + set { this.m_OPT1OverRange = value; } + } + public string OPT1UnderRange + { + get { return this.m_OPT1UnderRange; } + set { this.m_OPT1UnderRange = value; } + } + public string OPT1Port + { + get { return this.m_OPT1Port; } + set { this.m_OPT1Port = value; } + } + + public int OPT1OverRangeInt + { + get + { + if (this.OPT1OverRange == null) + return -1; + else + return int.Parse(this.OPT1OverRange); + } + } + public int OPT1UnderRangeInt + { + get + { + if (this.OPT1UnderRange == null) + return -1; + else + return int.Parse(this.OPT1UnderRange); + } + } + + public string OPT2Port + { + get { return this.m_OPT2Port; } + set { this.m_OPT2Port = value; } + } + public string OPT2DelayTime1 + { + get { return this.m_OPT2DelayTime1; } + set { this.m_OPT2DelayTime1 = value; } + } + public string OPT2DelayTime2 + { + get { return this.m_OPT2DelayTime2; } + set { this.m_OPT2DelayTime2 = value; } + } + + public string Dummy1 + { + get { return this.m_Dummy1; } + set { this.m_Dummy1 = value; } + } + public string Dummy2 + { + get { return this.m_Dummy2; } + set { this.m_Dummy2 = value; } + } + public string Dummy3 + { + get { return this.m_Dummy3; } + set { this.m_Dummy3 = value; } + } + public string Dummy4 + { + get { return this.m_Dummy4; } + set { this.m_Dummy4 = value; } + } + public string Dummy5 + { + get { return this.m_Dummy5; } + set { this.m_Dummy5 = value; } + } + public string Dummy6 + { + get { return this.m_Dummy6; } + set { this.m_Dummy6 = value; } + } + public string Dummy7 + { + get { return this.m_Dummy7; } + set { this.m_Dummy7 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.OPT1SamplingCount = "0"; + this.OPT1DelayCount = "0"; + this.OPT1PulseWidth = "0"; + this.OPT1IsWeightSetting = "0"; + this.OPT1OverRange = "0"; + this.OPT1UnderRange = "0"; + this.OPT1Port = "0"; + + this.OPT2Port = "0"; + this.OPT2DelayTime1 = "200"; + this.OPT2DelayTime2 = "200"; + + this.Dummy1 = "0"; + this.Dummy2 = "0"; + this.Dummy3 = "0"; + this.Dummy4 = "0"; + this.Dummy5 = "0"; + this.Dummy6 = "0"; + this.Dummy7 = "0"; + } + #endregion + } + #endregion + #region StructSystemParameter2 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemParameter2 + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1SamplingCount; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1DelayCount; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1PulseWidth; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1IsWeightSetting; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1OverRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1UnderRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT1Port; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT2Port; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT2DelayTime1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string OPT2DelayTime2; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy6; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy7; + } + #endregion + #region SystemParameter3 + public class SystemParameter3 + { + #region Field + private string m_ExternalOut1Mode; + private string m_ExternalOut1DelayTime; + private string m_ExternalOut1RunTime; + + private string m_ExternalOut2Mode; + private string m_ExternalOut2DelayTime; + private string m_ExternalOut2RunTime; + + private string m_ExternalOut3Mode; + private string m_ExternalOut3DelayTime; + private string m_ExternalOut3RunTime; + + private string m_ExternalOut4Mode; + private string m_ExternalOut4DelayTime; + private string m_ExternalOut4RunTime; + + private string m_ExternalOut9Mode; + private string m_ExternalOut9DelayTime; + private string m_ExternalOut9RunTime; + + private string m_ExternalOut10Mode; + private string m_ExternalOut10DelayTime; + private string m_ExternalOut10RunTime; + + private string m_Dummy1; + private string m_Dummy2; + #endregion + + #region Constructor + public SystemParameter3() + { + this.Initialization(); + } + #endregion + + #region Property + public string ExternalOut1Mode + { + get { return this.m_ExternalOut1Mode; } + set { this.m_ExternalOut1Mode = value; } + } + public string ExternalOut1DelayTime + { + get { return this.m_ExternalOut1DelayTime; } + set { this.m_ExternalOut1DelayTime = value; } + } + public string ExternalOut1RunTime + { + get { return this.m_ExternalOut1RunTime; } + set { this.m_ExternalOut1RunTime = value; } + } + + public string ExternalOut2Mode + { + get { return this.m_ExternalOut2Mode; } + set { this.m_ExternalOut2Mode = value; } + } + public string ExternalOut2DelayTime + { + get { return this.m_ExternalOut2DelayTime; } + set { this.m_ExternalOut2DelayTime = value; } + } + public string ExternalOut2RunTime + { + get { return this.m_ExternalOut2RunTime; } + set { this.m_ExternalOut2RunTime = value; } + } + + public string ExternalOut3Mode + { + get { return this.m_ExternalOut3Mode; } + set { this.m_ExternalOut3Mode = value; } + } + public string ExternalOut3DelayTime + { + get { return this.m_ExternalOut3DelayTime; } + set { this.m_ExternalOut3DelayTime = value; } + } + public string ExternalOut3RunTime + { + get { return this.m_ExternalOut3RunTime; } + set { this.m_ExternalOut3RunTime = value; } + } + + public string ExternalOut4Mode + { + get { return this.m_ExternalOut4Mode; } + set { this.m_ExternalOut4Mode = value; } + } + public string ExternalOut4DelayTime + { + get { return this.m_ExternalOut4DelayTime; } + set { this.m_ExternalOut4DelayTime = value; } + } + public string ExternalOut4RunTime + { + get { return this.m_ExternalOut4RunTime; } + set { this.m_ExternalOut4RunTime = value; } + } + + public string ExternalOut9Mode + { + get { return this.m_ExternalOut9Mode; } + set { this.m_ExternalOut9Mode = value; } + } + public string ExternalOut9DelayTime + { + get { return this.m_ExternalOut9DelayTime; } + set { this.m_ExternalOut9DelayTime = value; } + } + public string ExternalOut9RunTime + { + get { return this.m_ExternalOut9RunTime; } + set { this.m_ExternalOut9RunTime = value; } + } + + public string ExternalOut10Mode + { + get { return this.m_ExternalOut10Mode; } + set { this.m_ExternalOut10Mode = value; } + } + public string ExternalOut10DelayTime + { + get { return this.m_ExternalOut10DelayTime; } + set { this.m_ExternalOut10DelayTime = value; } + } + public string ExternalOut10RunTime + { + get { return this.m_ExternalOut10RunTime; } + set { this.m_ExternalOut10RunTime = value; } + } + + public string Dummy1 + { + get { return this.m_Dummy1; } + set { this.m_Dummy1 = value; } + } + public string Dummy2 + { + get { return this.m_Dummy2; } + set { this.m_Dummy2 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.ExternalOut1Mode = "0"; + this.ExternalOut1DelayTime = "500"; + this.ExternalOut1RunTime = "1000"; + + this.ExternalOut2Mode = "0"; + this.ExternalOut2DelayTime = "500"; + this.ExternalOut2RunTime = "1000"; + + this.ExternalOut3Mode = "0"; + this.ExternalOut3DelayTime = "500"; + this.ExternalOut3RunTime = "1000"; + + this.ExternalOut4Mode = "0"; + this.ExternalOut4DelayTime = "500"; + this.ExternalOut4RunTime = "1000"; + + this.ExternalOut9Mode = "0"; + this.ExternalOut9DelayTime = "500"; + this.ExternalOut9RunTime = "1000"; + + this.ExternalOut10Mode = "0"; + this.ExternalOut10DelayTime = "500"; + this.ExternalOut10RunTime = "1000"; + + this.Dummy1 = "0"; + this.Dummy2 = "0"; + } + #endregion + } + #endregion + #region StructSystemParameter3 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemParameter3 + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut1Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut1DelayTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut1RunTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut2Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut2DelayTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut2RunTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut3Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut3DelayTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut3RunTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut4Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut4DelayTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut4RunTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut9Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut9DelayTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut9RunTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut10Mode; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut10DelayTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string ExternalOut10RunTime; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy2; + } + #endregion + #region SystemParameter4 + public class SystemParameter4 + { + #region Field + // 메인보드 저장값 + private string m_MainAutoZero1Range; + private string m_MainAutoZero1Time; + private string m_MainAutoZero1Variate; + private string m_MainAutoZero1Mode; + private string m_MainAutoZero2Mode; + private string m_MainAutoZero2Range; + private string m_MainAutoZero2Time; + private string m_MainAutoZero2Variate; + + // LCD 저장값 + private string m_LCDAutoZero1Range; + private string m_LCDAutoZero1Time; + private string m_LCDAutoZero1Variate; + private string m_LCDAutoZero1Mode; + private string m_LCDAutoZero2Mode; + private string m_LCDAutoZero2Range; + private string m_LCDAutoZero2Time; + private string m_LCDAutoZero2Variate; + + private string m_Dummy1; + private string m_Dummy2; + private string m_Dummy3; + private string m_Dummy4; + private string m_Dummy5; + private string m_Dummy6; + #endregion + + #region Constructor + public SystemParameter4() + { + this.Initialization(); + } + #endregion + + #region Property + public string MainAutoZero1Range + { + get { return this.m_MainAutoZero1Range; } + set { this.m_MainAutoZero1Range = value; } + } + public string MainAutoZero1Time + { + get { return this.m_MainAutoZero1Time; } + set { this.m_MainAutoZero1Time = value; } + } + public string MainAutoZero1Variate + { + get { return this.m_MainAutoZero1Variate; } + set { this.m_MainAutoZero1Variate = value; } + } + public string MainAutoZero1Mode + { + get { return this.m_MainAutoZero1Mode; } + set { this.m_MainAutoZero1Mode = value; } + } + public string MainAutoZero2Mode + { + get { return this.m_MainAutoZero2Mode; } + set { this.m_MainAutoZero2Mode = value; } + } + public string MainAutoZero2Range + { + get { return this.m_MainAutoZero2Range; } + set { this.m_MainAutoZero2Range = value; } + } + public string MainAutoZero2Time + { + get { return this.m_MainAutoZero2Time; } + set { this.m_MainAutoZero2Time = value; } + } + public string MainAutoZero2Variate + { + get { return this.m_MainAutoZero2Variate; } + set { this.m_MainAutoZero2Variate = value; } + } + + public string LCDAutoZero1Range + { + get { return this.m_LCDAutoZero1Range; } + set { this.m_LCDAutoZero1Range = value; } + } + public string LCDAutoZero1Time + { + get { return this.m_LCDAutoZero1Time; } + set { this.m_LCDAutoZero1Time = value; } + } + public string LCDAutoZero1Variate + { + get { return this.m_LCDAutoZero1Variate; } + set { this.m_LCDAutoZero1Variate = value; } + } + public string LCDAutoZero1Mode + { + get { return this.m_LCDAutoZero1Mode; } + set { this.m_LCDAutoZero1Mode = value; } + } + public string LCDAutoZero2Mode + { + get { return this.m_LCDAutoZero2Mode; } + set { this.m_LCDAutoZero2Mode = value; } + } + public string LCDAutoZero2Range + { + get { return this.m_LCDAutoZero2Range; } + set { this.m_LCDAutoZero2Range = value; } + } + public string LCDAutoZero2Time + { + get { return this.m_LCDAutoZero2Time; } + set { this.m_LCDAutoZero2Time = value; } + } + public string LCDAutoZero2Variate + { + get { return this.m_LCDAutoZero2Variate; } + set { this.m_LCDAutoZero2Variate = value; } + } + + public string Dummy1 + { + get { return this.m_Dummy1; } + set { this.m_Dummy1 = value; } + } + public string Dummy2 + { + get { return this.m_Dummy2; } + set { this.m_Dummy2 = value; } + } + public string Dummy3 + { + get { return this.m_Dummy3; } + set { this.m_Dummy3 = value; } + } + public string Dummy4 + { + get { return this.m_Dummy4; } + set { this.m_Dummy4 = value; } + } + public string Dummy5 + { + get { return this.m_Dummy5; } + set { this.m_Dummy5 = value; } + } + public string Dummy6 + { + get { return this.m_Dummy6; } + set { this.m_Dummy6 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.MainAutoZero1Time = "100"; + this.MainAutoZero1Range = "17"; + this.MainAutoZero1Variate = "1"; + this.MainAutoZero1Mode = "2"; + + this.MainAutoZero2Mode = "0"; + this.MainAutoZero2Time = "5"; + this.MainAutoZero2Range = "10"; + this.MainAutoZero2Variate = "1"; + + this.LCDAutoZero1Mode = "2"; + this.LCDAutoZero1Time = "100"; + this.LCDAutoZero1Range = "17"; + this.LCDAutoZero1Variate = "1"; + + this.LCDAutoZero2Mode = "0"; + this.LCDAutoZero2Time = "5"; + this.LCDAutoZero2Range = "10"; + this.LCDAutoZero2Variate = "1"; + + this.Dummy1 = "0"; + this.Dummy2 = "0"; + this.Dummy3 = "0"; + this.Dummy4 = "0"; + this.Dummy5 = "0"; + this.Dummy6 = "0"; + } + #endregion + } + #endregion + #region StructSystemParameter4 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemParameter4 + { + // 각 모드별 시간/범위/변량 저장값은 UserSetting 값만 + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero1UserSettingRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero1UserSettingTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero1UserSettingVariate; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero1Mode; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero2UserSettingRange; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero2UserSettingTime; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero2UserSettingVariate; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string AutoZero2Mode; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy6; + } + #endregion + #region SystemParameter5 + public class SystemParameter5 + { + #region Field + + private bool m_PhotoBBuzzer; + private bool m_PIN3Buzzer; + private bool m_PIN4Buzzer; + private bool m_PIN5Buzzer; + private bool m_PIN6Buzzer; + private bool m_PIN7Buzzer; + private bool m_PIN8Buzzer; + + private bool m_PhotoBLamp; + private bool m_PIN3Lamp; + private bool m_PIN4Lamp; + private bool m_PIN5Lamp; + private bool m_PIN6Lamp; + private bool m_PIN7Lamp; + private bool m_PIN8Lamp; + + private bool m_PhotoBConveyorStop; + private bool m_PIN3ConveyorStop; + private bool m_PIN4ConveyorStop; + private bool m_PIN5ConveyorStop; + private bool m_PIN6ConveyorStop; + private bool m_PIN7ConveyorStop; + private bool m_PIN8ConveyorStop; + + private bool m_DummyBool1; + private bool m_DummyBool2; + private bool m_DummyBool3; + private bool m_DummyBool4; + private bool m_DummyBool5; + private bool m_DummyBool6; + private bool m_DummyBool7; + private bool m_DummyBool8; + private bool m_DummyBool9; + private bool m_DummyBool10; + private bool m_DummyBool11; + private bool m_DummyBool12; + private bool m_DummyBool13; + private bool m_DummyBool14; + + private int m_DummyInt1; + private int m_DummyInt2; + private int m_DummyInt3; + private int m_DummyInt4; + private int m_DummyInt5; + private int m_DummyInt6; + private int m_DummyInt7; + private int m_DummyInt8; + private int m_DummyInt9; + private int m_DummyInt10; + private int m_DummyInt11; + private int m_DummyInt12; + private int m_DummyInt13; + private int m_DummyInt14; + + private string m_Dummy1; + private string m_Dummy2; + private string m_Dummy3; + private string m_Dummy4; + private string m_Dummy5; + private string m_Dummy6; + private string m_Dummy7; + #endregion + + #region Constructor + public SystemParameter5() + { + this.Initialization(); + } + #endregion + + #region Property + public bool PhotoBBuzzer + { + get { return this.m_PhotoBBuzzer; } + set { this.m_PhotoBBuzzer = value; } + } + public bool PIN3Buzzer + { + get { return this.m_PIN3Buzzer; } + set { this.m_PIN3Buzzer = value; } + } + public bool PIN4Buzzer + { + get { return this.m_PIN4Buzzer; } + set { this.m_PIN4Buzzer = value; } + } + public bool PIN5Buzzer + { + get { return this.m_PIN5Buzzer; } + set { this.m_PIN5Buzzer = value; } + } + public bool PIN6Buzzer + { + get { return this.m_PIN6Buzzer; } + set { this.m_PIN6Buzzer = value; } + } + public bool PIN7Buzzer + { + get { return this.m_PIN7Buzzer; } + set { this.m_PIN7Buzzer = value; } + } + public bool PIN8Buzzer + { + get { return this.m_PIN8Buzzer; } + set { this.m_PIN8Buzzer = value; } + } + + public bool PhotoBLamp + { + get { return this.m_PhotoBLamp; } + set { this.m_PhotoBLamp = value; } + } + public bool PIN3Lamp + { + get { return this.m_PIN3Lamp; } + set { this.m_PIN3Lamp = value; } + } + public bool PIN4Lamp + { + get { return this.m_PIN4Lamp; } + set { this.m_PIN4Lamp = value; } + } + public bool PIN5Lamp + { + get { return this.m_PIN5Lamp; } + set { this.m_PIN5Lamp = value; } + } + public bool PIN6Lamp + { + get { return this.m_PIN6Lamp; } + set { this.m_PIN6Lamp = value; } + } + public bool PIN7Lamp + { + get { return this.m_PIN7Lamp; } + set { this.m_PIN7Lamp = value; } + } + public bool PIN8Lamp + { + get { return this.m_PIN8Lamp; } + set { this.m_PIN8Lamp = value; } + } + + public bool PhotoBConveyorStop + { + get { return this.m_PhotoBConveyorStop; } + set { this.m_PhotoBConveyorStop = value; } + } + public bool PIN3ConveyorStop + { + get { return this.m_PIN3ConveyorStop; } + set { this.m_PIN3ConveyorStop = value; } + } + public bool PIN4ConveyorStop + { + get { return this.m_PIN4ConveyorStop; } + set { this.m_PIN4ConveyorStop = value; } + } + public bool PIN5ConveyorStop + { + get { return this.m_PIN5ConveyorStop; } + set { this.m_PIN5ConveyorStop = value; } + } + public bool PIN6ConveyorStop + { + get { return this.m_PIN6ConveyorStop; } + set { this.m_PIN6ConveyorStop = value; } + } + public bool PIN7ConveyorStop + { + get { return this.m_PIN7ConveyorStop; } + set { this.m_PIN7ConveyorStop = value; } + } + public bool PIN8ConveyorStop + { + get { return this.m_PIN8ConveyorStop; } + set { this.m_PIN8ConveyorStop = value; } + } + + public bool DummyBool1 + { + get { return this.m_DummyBool1; } + set { this.m_DummyBool1 = value; } + } + public bool DummyBool2 + { + get { return this.m_DummyBool2; } + set { this.m_DummyBool2 = value; } + } + public bool DummyBool3 + { + get { return this.m_DummyBool3; } + set { this.m_DummyBool3 = value; } + } + public bool DummyBool4 + { + get { return this.m_DummyBool4; } + set { this.m_DummyBool4 = value; } + } + public bool DummyBool5 + { + get { return this.m_DummyBool5; } + set { this.m_DummyBool5 = value; } + } + public bool DummyBool6 + { + get { return this.m_DummyBool6; } + set { this.m_DummyBool6 = value; } + } + public bool DummyBool7 + { + get { return this.m_DummyBool7; } + set { this.m_DummyBool7 = value; } + } + public bool DummyBool8 + { + get { return this.m_DummyBool8; } + set { this.m_DummyBool8 = value; } + } + public bool DummyBool9 + { + get { return this.m_DummyBool9; } + set { this.m_DummyBool9 = value; } + } + public bool DummyBool10 + { + get { return this.m_DummyBool10; } + set { this.m_DummyBool10 = value; } + } + public bool DummyBool11 + { + get { return this.m_DummyBool11; } + set { this.m_DummyBool11 = value; } + } + public bool DummyBool12 + { + get { return this.m_DummyBool12; } + set { this.m_DummyBool12 = value; } + } + public bool DummyBool13 + { + get { return this.m_DummyBool13; } + set { this.m_DummyBool13 = value; } + } + public bool DummyBool14 + { + get { return this.m_DummyBool14; } + set { this.m_DummyBool14 = value; } + } + + public int DummyInt1 + { + get { return this.m_DummyInt1; } + set { this.m_DummyInt1 = value; } + } + public int DummyInt2 + { + get { return this.m_DummyInt2; } + set { this.m_DummyInt2 = value; } + } + public int DummyInt3 + { + get { return this.m_DummyInt3; } + set { this.m_DummyInt3 = value; } + } + public int DummyInt4 + { + get { return this.m_DummyInt4; } + set { this.m_DummyInt4 = value; } + } + public int DummyInt5 + { + get { return this.m_DummyInt5; } + set { this.m_DummyInt5 = value; } + } + public int DummyInt6 + { + get { return this.m_DummyInt6; } + set { this.m_DummyInt6 = value; } + } + public int DummyInt7 + { + get { return this.m_DummyInt7; } + set { this.m_DummyInt7 = value; } + } + public int DummyInt8 + { + get { return this.m_DummyInt8; } + set { this.m_DummyInt8 = value; } + } + public int DummyInt9 + { + get { return this.m_DummyInt9; } + set { this.m_DummyInt9 = value; } + } + public int DummyInt10 + { + get { return this.m_DummyInt10; } + set { this.m_DummyInt10 = value; } + } + public int DummyInt11 + { + get { return this.m_DummyInt11; } + set { this.m_DummyInt11 = value; } + } + public int DummyInt12 + { + get { return this.m_DummyInt12; } + set { this.m_DummyInt12 = value; } + } + public int DummyInt13 + { + get { return this.m_DummyInt13; } + set { this.m_DummyInt13 = value; } + } + public int DummyInt14 + { + get { return this.m_DummyInt14; } + set { this.m_DummyInt14 = value; } + } + + public string Dummy1 + { + get { return this.m_Dummy1; } + set { this.m_Dummy1 = value; } + } + public string Dummy2 + { + get { return this.m_Dummy2; } + set { this.m_Dummy2 = value; } + } + public string Dummy3 + { + get { return this.m_Dummy3; } + set { this.m_Dummy3 = value; } + } + public string Dummy4 + { + get { return this.m_Dummy4; } + set { this.m_Dummy4 = value; } + } + public string Dummy5 + { + get { return this.m_Dummy5; } + set { this.m_Dummy5 = value; } + } + public string Dummy6 + { + get { return this.m_Dummy6; } + set { this.m_Dummy6 = value; } + } + public string Dummy7 + { + get { return this.m_Dummy7; } + set { this.m_Dummy7 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.PhotoBBuzzer = false; + this.PIN3Buzzer = false; + this.PIN4Buzzer = false; + this.PIN5Buzzer = false; + this.PIN6Buzzer = false; + this.PIN7Buzzer = false; + this.PIN8Buzzer = false; + + this.PhotoBLamp = false; + this.PIN3Lamp = false; + this.PIN4Lamp = false; + this.PIN5Lamp = false; + this.PIN6Lamp = false; + this.PIN7Lamp = false; + this.PIN8Lamp = false; + + this.PhotoBConveyorStop = false; + this.PIN3ConveyorStop = false; + this.PIN4ConveyorStop = false; + this.PIN5ConveyorStop = false; + this.PIN6ConveyorStop = false; + this.PIN7ConveyorStop = false; + this.PIN8ConveyorStop = false; + + this.DummyBool1 = false; + this.DummyBool2 = false; + this.DummyBool3 = false; + this.DummyBool4 = false; + this.DummyBool5 = false; + this.DummyBool6 = false; + this.DummyBool7 = false; + this.DummyBool8 = false; + this.DummyBool9 = false; + this.DummyBool10 = false; + this.DummyBool11 = false; + this.DummyBool12 = false; + this.DummyBool13 = false; + this.DummyBool14 = false; + + this.DummyInt1 = 0; + this.DummyInt2 = 0; + this.DummyInt3 = 0; + this.DummyInt4 = 0; + this.DummyInt5 = 0; + this.DummyInt6 = 0; + this.DummyInt7 = 0; + this.DummyInt8 = 0; + this.DummyInt9 = 0; + this.DummyInt10 = 0; + this.DummyInt11 = 0; + this.DummyInt12 = 0; + this.DummyInt13 = 0; + this.DummyInt14 = 0; + + this.Dummy1 = "0"; + this.Dummy2 = "0"; + this.Dummy3 = "0"; + this.Dummy4 = "0"; + this.Dummy5 = "0"; + this.Dummy6 = "0"; + this.Dummy7 = "0"; + } + #endregion + } + #endregion + #region StructSystemParameter5 + [StructLayout(LayoutKind.Sequential)] + public struct StructSystemParameter5 + { + public bool PhotoBBuzzer; + public bool PIN3Buzzer; + public bool PIN4Buzzer; + public bool PIN5Buzzer; + public bool PIN6Buzzer; + public bool PIN7Buzzer; + public bool PIN8Buzzer; + + public bool PhotoBLamp; + public bool PIN3Lamp; + public bool PIN4Lamp; + public bool PIN5Lamp; + public bool PIN6Lamp; + public bool PIN7Lamp; + public bool PIN8Lamp; + + public bool PhotoBConveyorStop; + public bool PIN3ConveyorStop; + public bool PIN4ConveyorStop; + public bool PIN5ConveyorStop; + public bool PIN6ConveyorStop; + public bool PIN7ConveyorStop; + public bool PIN8ConveyorStop; + + public bool DummyBool1; + public bool DummyBool2; + public bool DummyBool3; + public bool DummyBool4; + public bool DummyBool5; + public bool DummyBool6; + public bool DummyBool7; + public bool DummyBool8; + public bool DummyBool9; + public bool DummyBool10; + public bool DummyBool11; + public bool DummyBool12; + public bool DummyBool13; + public bool DummyBool14; + + public int DummyInt1; + public int DummyInt2; + public int DummyInt3; + public int DummyInt4; + public int DummyInt5; + public int DummyInt6; + public int DummyInt7; + public int DummyInt8; + public int DummyInt9; + public int DummyInt10; + public int DummyInt11; + public int DummyInt12; + public int DummyInt13; + public int DummyInt14; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy5; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy6; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)] + public string Dummy7; + } + #endregion + + #region SystemStatus + public class SystemStatus + { + #region Field + private DataStore.EquipmentStatus m_Equipment; + private DataStore.DisplayStore m_CurrentDisplay; + private DataStore.DisplayMode m_CurrentMode; + private DataStore.WeightInputMode m_CurrentWeightInputMode; + + private UserPasswordType m_CurrentUserPasswordType; + private UserItem m_CurrentUser; + #endregion + + #region Constructor + public SystemStatus() + { + this.Initialization(); + } + #endregion + + #region Property + public DataStore.EquipmentStatus Equipment + { + get { return this.m_Equipment; } + set { this.m_Equipment = value; } + } + public DataStore.DisplayStore CurrentDisplay + { + get { return this.m_CurrentDisplay; } + set { this.m_CurrentDisplay = value; } + } + public DataStore.DisplayMode CurrentMode + { + get { return this.m_CurrentMode; } + set { this.m_CurrentMode = value; } + } + public DataStore.WeightInputMode CurrentWeightInputMode + { + get { return this.m_CurrentWeightInputMode; } + set { this.m_CurrentWeightInputMode = value; } + } + + public UserPasswordType CurrentUserPasswordType + { + get { return this.m_CurrentUserPasswordType; } + set { this.m_CurrentUserPasswordType = value; } + } + public UserItem CurrentUser + { + get { return this.m_CurrentUser; } + set { this.m_CurrentUser = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.Equipment = DataStore.EquipmentStatus.Stop; + this.CurrentDisplay = DataStore.DisplayStore.MainDisplay; + this.CurrentMode = DataStore.DisplayMode.Normal; + this.CurrentWeightInputMode = DataStore.WeightInputMode.Weight; + this.CurrentUserPasswordType = new UserPasswordType(); + + this.CurrentUser = new UserItem(); + this.CurrentUser.ID = ""; + this.CurrentUser.Password = ""; + this.CurrentUser.Group = DataStore.UserGroup.LogOut; + } + #endregion + } + #endregion + + #region SystemInformation2 + public class SystemInformation2 + { + #region Field + private string m_MaxWeight; + private string m_BalanceWeight; + private string m_Digit; + private string m_Calc; + + private string m_Filter; + private string m_JudgmentDelay; + private string m_DoubleDelay; + private string m_JudgmentNumber; + private string m_Speed; + private string m_Dynamic; + + private string m_SorterAMode; + private string m_SorterADelay; + private string m_SorterAOperation; + private string m_SorterBMode; + private string m_SorterBDelay; + private string m_SorterBOperation; + private string m_DoubleEntry; + private string m_ExternalInput; + private string m_ETCNG; + + private string m_AutoZero1Time; + private string m_AutoZero1Range; + private string m_AutoZero1Variate; + private string m_AutoZero1Mode; + private string m_AutoZero2Time; + private string m_AutoZero2Range; + private string m_AutoZero2Variate; + private string m_AutoZero2Mode; + + private string m_UnderRange; + private string m_PassRange; + private string m_OverRange; + private string m_TareRange; + + private string m_ExternalOutput1Mode; + private string m_ExternalOutput1Delay; + private string m_ExternalOutput1Operation; + private string m_ExternalOutput2Mode; + private string m_ExternalOutput2Delay; + private string m_ExternalOutput2Operation; + private string m_ExternalOutput3Mode; + private string m_ExternalOutput3Delay; + private string m_ExternalOutput3Operation; + private string m_ExternalOutput4Mode; + private string m_ExternalOutput4Delay; + private string m_ExternalOutput4Operation; + private string m_ExternalOutput9Mode; + private string m_ExternalOutput9Delay; + private string m_ExternalOutput9Operation; + private string m_ExternalOutput10Mode; + private string m_ExternalOutput10Delay; + private string m_ExternalOutput10Operation; + + private string m_AscendDelay; + private string m_DescendDelay; + + private string m_dummy1; + private string m_dummy2; + private string m_dummy3; + private string m_dummy4; + private string m_dummy5; + private string m_dummy6; + private string m_dummy7; + private string m_dummy8; + #endregion + + #region Constructor + public SystemInformation2() + { + this.Initialization(); + } + #endregion + + #region Property + public string MaxWeight + { + get { return this.m_MaxWeight; } + set { this.m_MaxWeight = value; } + } + public string BalanceWeight + { + get { return this.m_BalanceWeight; } + set { this.m_BalanceWeight = value; } + } + public string Digit + { + get { return this.m_Digit; } + set { this.m_Digit = value; } + } + public string Calc + { + get { return this.m_Calc; } + set { this.m_Calc = value; } + } + + public string Filter + { + get { return this.m_Filter; } + set { this.m_Filter = value; } + } + public string JudgmentDelay + { + get { return this.m_JudgmentDelay; } + set { this.m_JudgmentDelay = value; } + } + public string DoubleDelay + { + get { return this.m_DoubleDelay; } + set { this.m_DoubleDelay = value; } + } + public string JudgmentNumber + { + get { return this.m_JudgmentNumber; } + set { this.m_JudgmentNumber = value; } + } + public string Speed + { + get { return this.m_Speed; } + set { this.m_Speed = value; } + } + public string Dynamic + { + get { return this.m_Dynamic; } + set { this.m_Dynamic = value; } + } + + public string SorterAMode + { + get { return this.m_SorterAMode; } + set { this.m_SorterAMode = value; } + } + public string SorterADelay + { + get { return this.m_SorterADelay; } + set { this.m_SorterADelay = value; } + } + public string SorterAOperation + { + get { return this.m_SorterAOperation; } + set { this.m_SorterAOperation = value; } + } + public string SorterBMode + { + get { return this.m_SorterBMode; } + set { this.m_SorterBMode = value; } + } + public string SorterBDelay + { + get { return this.m_SorterBDelay; } + set { this.m_SorterBDelay = value; } + } + public string SorterBOperation + { + get { return this.m_SorterBOperation; } + set { this.m_SorterBOperation = value; } + } + public string DoubleEntry + { + get { return this.m_DoubleEntry; } + set { this.m_DoubleEntry = value; } + } + public string ExternalInput + { + get { return this.m_ExternalInput; } + set { this.m_ExternalInput = value; } + } + public string ETCNG + { + get { return this.m_ETCNG; } + set { this.m_ETCNG = value; } + } + + public string AutoZero1Time + { + get { return this.m_AutoZero1Time; } + set { this.m_AutoZero1Time = value; } + } + public string AutoZero1Range + { + get { return this.m_AutoZero1Range; } + set { this.m_AutoZero1Range = value; } + } + public string AutoZero1Variate + { + get { return this.m_AutoZero1Variate; } + set { this.m_AutoZero1Variate = value; } + } + public string AutoZero1Mode + { + get { return this.m_AutoZero1Mode; } + set { this.m_AutoZero1Mode = value; } + } + public string AutoZero2Time + { + get { return this.m_AutoZero2Time; } + set { this.m_AutoZero2Time = value; } + } + public string AutoZero2Range + { + get { return this.m_AutoZero2Range; } + set { this.m_AutoZero2Range = value; } + } + public string AutoZero2Variate + { + get { return this.m_AutoZero2Variate; } + set { this.m_AutoZero2Variate = value; } + } + public string AutoZero2Mode + { + get { return this.m_AutoZero2Mode; } + set { this.m_AutoZero2Mode = value; } + } + + public string UnderRange + { + get { return this.m_UnderRange; } + set { this.m_UnderRange = value; } + } + public string PassRange + { + get { return this.m_PassRange; } + set { this.m_PassRange = value; } + } + public string OverRange + { + get { return this.m_OverRange; } + set { this.m_OverRange = value; } + } + public string TareRange + { + get { return this.m_TareRange; } + set { this.m_TareRange = value; } + } + + public string ExternalOutput1Mode + { + get { return this.m_ExternalOutput1Mode; } + set { this.m_ExternalOutput1Mode = value; } + } + public string ExternalOutput1Delay + { + get { return this.m_ExternalOutput1Delay; } + set { this.m_ExternalOutput1Delay = value; } + } + public string ExternalOutput1Operation + { + get { return this.m_ExternalOutput1Operation; } + set { this.m_ExternalOutput1Operation = value; } + } + public string ExternalOutput2Mode + { + get { return this.m_ExternalOutput2Mode; } + set { this.m_ExternalOutput2Mode = value; } + } + public string ExternalOutput2Delay + { + get { return this.m_ExternalOutput2Delay; } + set { this.m_ExternalOutput2Delay = value; } + } + public string ExternalOutput2Operation + { + get { return this.m_ExternalOutput2Operation; } + set { this.m_ExternalOutput2Operation = value; } + } + public string ExternalOutput3Mode + { + get { return this.m_ExternalOutput3Mode; } + set { this.m_ExternalOutput3Mode = value; } + } + public string ExternalOutput3Delay + { + get { return this.m_ExternalOutput3Delay; } + set { this.m_ExternalOutput3Delay = value; } + } + public string ExternalOutput3Operation + { + get { return this.m_ExternalOutput3Operation; } + set { this.m_ExternalOutput3Operation = value; } + } + public string ExternalOutput4Mode + { + get { return this.m_ExternalOutput4Mode; } + set { this.m_ExternalOutput4Mode = value; } + } + public string ExternalOutput4Delay + { + get { return this.m_ExternalOutput4Delay; } + set { this.m_ExternalOutput4Delay = value; } + } + public string ExternalOutput4Operation + { + get { return this.m_ExternalOutput4Operation; } + set { this.m_ExternalOutput4Operation = value; } + } + public string ExternalOutput9Mode + { + get { return this.m_ExternalOutput9Mode; } + set { this.m_ExternalOutput9Mode = value; } + } + public string ExternalOutput9Delay + { + get { return this.m_ExternalOutput9Delay; } + set { this.m_ExternalOutput9Delay = value; } + } + public string ExternalOutput9Operation + { + get { return this.m_ExternalOutput9Operation; } + set { this.m_ExternalOutput9Operation = value; } + } + public string ExternalOutput10Mode + { + get { return this.m_ExternalOutput10Mode; } + set { this.m_ExternalOutput10Mode = value; } + } + public string ExternalOutput10Delay + { + get { return this.m_ExternalOutput10Delay; } + set { this.m_ExternalOutput10Delay = value; } + } + public string ExternalOutput10Operation + { + get { return this.m_ExternalOutput10Operation; } + set { this.m_ExternalOutput10Operation = value; } + } + + public string AscendDelay + { + get { return this.m_AscendDelay; } + set { this.m_AscendDelay = value; } + } + public string DescendDelay + { + get { return this.m_DescendDelay; } + set { this.m_DescendDelay = value; } + } + + public string dummy1 + { + get { return this.m_dummy1; } + set { this.m_dummy1 = value; } + } + public string dummy2 + { + get { return this.m_dummy2; } + set { this.m_dummy2 = value; } + } + public string dummy3 + { + get { return this.m_dummy3; } + set { this.m_dummy3 = value; } + } + public string dummy4 + { + get { return this.m_dummy4; } + set { this.m_dummy4 = value; } + } + public string dummy5 + { + get { return this.m_dummy5; } + set { this.m_dummy5 = value; } + } + public string dummy6 + { + get { return this.m_dummy6; } + set { this.m_dummy6 = value; } + } + public string dummy7 + { + get { return this.m_dummy7; } + set { this.m_dummy7 = value; } + } + public string dummy8 + { + get { return this.m_dummy8; } + set { this.m_dummy8 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.MaxWeight = "0"; + this.BalanceWeight = "0"; + this.Digit = "0"; + this.Calc = "0"; + + this.Filter = "8"; + this.JudgmentDelay = "1000"; + this.DoubleDelay = "900"; + this.JudgmentNumber = "10"; + this.Speed = "60"; + this.Dynamic = "1000000"; + + this.SorterAMode = "0"; + this.SorterADelay = "1"; + this.SorterAOperation = "1000"; + this.SorterBMode = "0"; + this.SorterBDelay = "1"; + this.SorterBOperation = "1000"; + this.DoubleEntry = "0"; + this.ExternalInput = "0"; + this.ETCNG = "0"; + + this.AutoZero1Mode = "2"; + this.AutoZero1Range = "17"; + this.AutoZero1Time = "100"; + this.AutoZero1Variate = "1"; + this.AutoZero2Mode = "0"; + this.AutoZero2Range = "10"; + this.AutoZero2Time = "5"; + this.AutoZero2Variate = "1"; + + this.UnderRange = "0"; + this.PassRange = "0"; + this.OverRange = "0"; + this.TareRange = "0"; + + this.ExternalOutput1Mode = "0"; + this.ExternalOutput1Delay = "500"; + this.ExternalOutput1Operation = "1000"; + this.ExternalOutput2Mode = "0"; + this.ExternalOutput2Delay = "500"; + this.ExternalOutput2Operation = "1000"; + this.ExternalOutput3Mode = "0"; + this.ExternalOutput3Delay = "500"; + this.ExternalOutput3Operation = "1000"; + this.ExternalOutput4Mode = "0"; + this.ExternalOutput4Delay = "500"; + this.ExternalOutput4Operation = "1000"; + this.ExternalOutput9Mode = "0"; + this.ExternalOutput9Delay = "500"; + this.ExternalOutput9Operation = "1000"; + this.ExternalOutput10Mode = "0"; + this.ExternalOutput10Delay = "500"; + this.ExternalOutput10Operation = "1000"; + + this.AscendDelay = "1000"; + this.DescendDelay = "1000"; + + this.dummy1 = "0"; + this.dummy2 = "0"; + this.dummy3 = "0"; + this.dummy4 = "0"; + this.dummy5 = "0"; + this.dummy6 = "0"; + this.dummy7 = "0"; + this.dummy8 = "0"; + } + #endregion + } + #endregion + #region SystemInformation3 + public class SystemInformation3 + { + #region Field + private string m_Random1Number; + private string m_Random1Using; + private string m_Random1Under; + private string m_Random1Over; + private string m_Random1Tare; + + private string m_Random2Number; + private string m_Random2Using; + private string m_Random2Under; + private string m_Random2Over; + private string m_Random2Tare; + + private string m_Random3Number; + private string m_Random3Using; + private string m_Random3Under; + private string m_Random3Over; + private string m_Random3Tare; + + private string m_Random4Number; + private string m_Random4Using; + private string m_Random4Under; + private string m_Random4Over; + private string m_Random4Tare; + + private string m_Random5Number; + private string m_Random5Using; + private string m_Random5Under; + private string m_Random5Over; + private string m_Random5Tare; + + private string m_OPT1SampleNumber; + private string m_OPT1DelayNumber; + private string m_OPT1PulseWidth; + private string m_OPT1Using; + private string m_OPT1OverRange; + private string m_OPT1UnderRange; + + private string m_OPT2Port; + private string m_OPT2Delay1; + private string m_OPT2Delay2; + + private string m_PI8; + private string m_PI7; + private string m_PI6; + private string m_PI5; + private string m_PI4; + private string m_PI3; + private string m_PhotoB; + + private string m_EquipmentType; + private string m_OptionBoard; + private string m_Relay; + private string m_Chattering; + private string m_BuzzerONTime; + + private string m_dummy1; + private string m_dummy2; + private string m_dummy3; + private string m_dummy4; + private string m_dummy5; + private string m_dummy6; + private string m_dummy7; + private string m_dummy8; + private string m_dummy9; + private string m_dummy10; + #endregion + + #region Constructor + public SystemInformation3() + { + this.Initialization(); + } + #endregion + + #region Property + public string Random1Number + { + get { return this.m_Random1Number; } + set { this.m_Random1Number = value; } + } + public string Random1Using + { + get { return this.m_Random1Using; } + set { this.m_Random1Using = value; } + } + public string Random1Under + { + get { return this.m_Random1Under; } + set { this.m_Random1Under = value; } + } + public string Random1Over + { + get { return this.m_Random1Over; } + set { this.m_Random1Over = value; } + } + public string Random1Tare + { + get { return this.m_Random1Tare; } + set { this.m_Random1Tare = value; } + } + + public string Random2Number + { + get { return this.m_Random2Number; } + set { this.m_Random2Number = value; } + } + public string Random2Using + { + get { return this.m_Random2Using; } + set { this.m_Random2Using = value; } + } + public string Random2Under + { + get { return this.m_Random2Under; } + set { this.m_Random2Under = value; } + } + public string Random2Over + { + get { return this.m_Random2Over; } + set { this.m_Random2Over = value; } + } + public string Random2Tare + { + get { return this.m_Random2Tare; } + set { this.m_Random2Tare = value; } + } + + public string Random3Number + { + get { return this.m_Random3Number; } + set { this.m_Random3Number = value; } + } + public string Random3Using + { + get { return this.m_Random3Using; } + set { this.m_Random3Using = value; } + } + public string Random3Under + { + get { return this.m_Random3Under; } + set { this.m_Random3Under = value; } + } + public string Random3Over + { + get { return this.m_Random3Over; } + set { this.m_Random3Over = value; } + } + public string Random3Tare + { + get { return this.m_Random3Tare; } + set { this.m_Random3Tare = value; } + } + + public string Random4Number + { + get { return this.m_Random4Number; } + set { this.m_Random4Number = value; } + } + public string Random4Using + { + get { return this.m_Random4Using; } + set { this.m_Random4Using = value; } + } + public string Random4Under + { + get { return this.m_Random4Under; } + set { this.m_Random4Under = value; } + } + public string Random4Over + { + get { return this.m_Random4Over; } + set { this.m_Random4Over = value; } + } + public string Random4Tare + { + get { return this.m_Random4Tare; } + set { this.m_Random4Tare = value; } + } + + public string Random5Number + { + get { return this.m_Random5Number; } + set { this.m_Random5Number = value; } + } + public string Random5Using + { + get { return this.m_Random5Using; } + set { this.m_Random5Using = value; } + } + public string Random5Under + { + get { return this.m_Random5Under; } + set { this.m_Random5Under = value; } + } + public string Random5Over + { + get { return this.m_Random5Over; } + set { this.m_Random5Over = value; } + } + public string Random5Tare + { + get { return this.m_Random5Tare; } + set { this.m_Random5Tare = value; } + } + + public string OPT1SampleNumber + { + get { return this.m_OPT1SampleNumber; } + set { this.m_OPT1SampleNumber = value; } + } + public string OPT1DelayNumber + { + get { return this.m_OPT1DelayNumber; } + set { this.m_OPT1DelayNumber = value; } + } + public string OPT1PulseWidth + { + get { return this.m_OPT1PulseWidth; } + set { this.m_OPT1PulseWidth = value; } + } + public string OPT1Using + { + get { return this.m_OPT1Using; } + set { this.m_OPT1Using = value; } + } + public string OPT1OverRange + { + get { return this.m_OPT1OverRange; } + set { this.m_OPT1OverRange = value; } + } + public string OPT1UnderRange + { + get { return this.m_OPT1UnderRange; } + set { this.m_OPT1UnderRange = value; } + } + + public string OPT2Port + { + get { return this.m_OPT2Port; } + set { this.m_OPT2Port = value; } + } + public string OPT2Delay1 + { + get { return this.m_OPT2Delay1; } + set { this.m_OPT2Delay1 = value; } + } + public string OPT2Delay2 + { + get { return this.m_OPT2Delay2; } + set { this.m_OPT2Delay2 = value; } + } + + public string BuzzerONTime + { + get { return this.m_BuzzerONTime; } + set { this.m_BuzzerONTime = value; } + } + public string Chattering + { + get { return this.m_Chattering; } + set { this.m_Chattering = value; } + } + public string Relay + { + get { return this.m_Relay; } + set { this.m_Relay = value; } + } + public string OptionBoard + { + get { return this.m_OptionBoard; } + set { this.m_OptionBoard = value; } + } + public string EquipmentType + { + get { return this.m_EquipmentType; } + set { this.m_EquipmentType = value; } + } + + public string PhotoB + { + get { return this.m_PhotoB; } + set { this.m_PhotoB = value; } + } + public string PI3 + { + get { return this.m_PI3; } + set { this.m_PI3 = value; } + } + public string PI4 + { + get { return this.m_PI4; } + set { this.m_PI4 = value; } + } + public string PI5 + { + get { return this.m_PI5; } + set { this.m_PI5 = value; } + } + public string PI6 + { + get { return this.m_PI6; } + set { this.m_PI6 = value; } + } + public string PI7 + { + get { return this.m_PI7; } + set { this.m_PI7 = value; } + } + public string PI8 + { + get { return this.m_PI8; } + set { this.m_PI8 = value; } + } + + public string dummy1 + { + get { return this.m_dummy1; } + set { this.m_dummy1 = value; } + } + public string dummy2 + { + get { return this.m_dummy2; } + set { this.m_dummy2 = value; } + } + public string dummy3 + { + get { return this.m_dummy3; } + set { this.m_dummy3 = value; } + } + public string dummy4 + { + get { return this.m_dummy4; } + set { this.m_dummy4 = value; } + } + public string dummy5 + { + get { return this.m_dummy5; } + set { this.m_dummy5 = value; } + } + public string dummy6 + { + get { return this.m_dummy6; } + set { this.m_dummy6 = value; } + } + public string dummy7 + { + get { return this.m_dummy7; } + set { this.m_dummy7 = value; } + } + public string dummy8 + { + get { return this.m_dummy8; } + set { this.m_dummy8 = value; } + } + public string dummy9 + { + get { return this.m_dummy9; } + set { this.m_dummy9 = value; } + } + public string dummy10 + { + get { return this.m_dummy10; } + set { this.m_dummy10 = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.Random1Number = "996"; + this.Random1Using = "0"; + this.Random1Under = "0"; + this.Random1Over = "0"; + this.Random1Tare = "0"; + + this.Random2Number = "997"; + this.Random2Using = "0"; + this.Random2Under = "0"; + this.Random2Over = "0"; + this.Random2Tare = "0"; + + this.Random3Number = "998"; + this.Random3Using = "0"; + this.Random3Under = "0"; + this.Random3Over = "0"; + this.Random3Tare = "0"; + + this.Random4Number = "999"; + this.Random4Using = "0"; + this.Random4Under = "0"; + this.Random4Over = "0"; + this.Random4Tare = "0"; + + this.Random5Number = "1000"; + this.Random5Using = "0"; + this.Random5Under = "0"; + this.Random5Over = "0"; + this.Random5Tare = "0"; + + this.OPT1SampleNumber = "0"; + this.OPT1DelayNumber = "0"; + this.OPT1PulseWidth = "0"; + this.OPT1Using = "0"; + this.OPT1OverRange = "0"; + this.OPT1UnderRange = "0"; + + this.OPT2Port = "0"; + this.OPT2Delay1 = "0"; + this.OPT2Delay2 = "0"; + + this.BuzzerONTime = "1000"; + this.Chattering = "100"; + this.Relay = "1000"; + this.OptionBoard = "0"; + this.EquipmentType = "0"; + + this.PhotoB = "0"; + this.PI3 = "1"; + this.PI4 = "2"; + this.PI5 = "0"; + this.PI6 = "0"; + this.PI7 = "0"; + this.PI8 = "2"; + + this.dummy1 = "0"; + this.dummy2 = "0"; + this.dummy3 = "0"; + this.dummy4 = "0"; + this.dummy5 = "0"; + this.dummy6 = "0"; + this.dummy7 = "0"; + this.dummy8 = "0"; + this.dummy9 = "0"; + this.dummy10 = "0"; + } + #endregion + } + #endregion + + #region UserPasswordType + public class UserPasswordType + { + #region Field + private string m_Level1Password; + private string m_Level2Password; + private string m_Level3Password; + private string m_Level4Password; + private string m_HiddenMenuPassword; + + private DataStore.UserGroup m_Group; + #endregion + + #region Constructor + public UserPasswordType() + { + this.Initialization(); + } + #endregion + + #region Property + public string Level1Password + { + get { return this.m_Level1Password; } + set { this.m_Level1Password = value; } + } + public string Level2Password + { + get { return this.m_Level2Password; } + set { this.m_Level2Password = value; } + } + public string Level3Password + { + get { return this.m_Level3Password; } + set { this.m_Level3Password = value; } + } + public string Level4Password + { + get { return this.m_Level4Password; } + set { this.m_Level4Password = value; } + } + public string HiddenMenuPassword + { + get { return this.m_HiddenMenuPassword; } + set { this.m_HiddenMenuPassword = value; } + } + + public DataStore.UserGroup Group + { + get { return this.m_Group; } + set { this.m_Group = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.Level1Password = "1000"; + this.Level2Password = "2000"; + this.Level3Password = "3000"; + this.Level4Password = "0714"; + this.HiddenMenuPassword = DateTime.Now.ToString("MMdd") + "0810"; + + this.Group = DataStore.UserGroup.None; + } + #endregion + } + #endregion + + #region DataBackup OPT1 + public class DataBackupOPT1 + { + #region Field + private string m_DataID; + private string m_Name; + private string m_Lot; + private string m_OverRange; + private string m_UnderRange; + private string m_Weight; + private string m_Date; + private string m_Time; + private string m_PassCount; + private string m_Grade; + private string m_Status; + #endregion + + #region Constructor + public DataBackupOPT1() + { + this.Initialize(); + } + #endregion + + #region Property + public string DataID + { + get { return this.m_DataID; } + set { this.m_DataID = value; } + } + public string Name + { + get { return this.m_Name; } + private set { this.m_Name = value; } + } + public string Lot + { + get { return this.m_Lot; } + private set { this.m_Lot = value; } + } + public string OverRange + { + get { return this.m_OverRange; } + private set { this.m_OverRange = value; } + } + public string UnderRange + { + get { return this.m_UnderRange; } + private set { this.m_UnderRange = value; } + } + public string Weight + { + get { return this.m_Weight; } + private set { this.m_Weight = value; } + } + public string Date + { + get { return this.m_Date; } + private set { this.m_Date = value; } + } + public string Time + { + get { return this.m_Time; } + private set { this.m_Time = value; } + } + public string PassCount + { + get { return this.m_PassCount; } + private set { this.m_PassCount = value; } + } + public string Grade + { + get { return this.m_Grade; } + private set { this.m_Grade = value; } + } + public string Status + { + get { return this.m_Status; } + set { this.m_Status = value; } + } + #endregion + + #region Method + private void Initialize() + { + this.DataID = ""; + this.Name = ""; + this.Lot = ""; + this.OverRange = ""; + this.UnderRange = ""; + this.Weight = ""; + this.Date = ""; + this.Time = ""; + this.PassCount = ""; + this.Grade = ""; + this.Status = ""; + } + + public void SetData(ProductItem item, WeightData data, SystemConfigurationItem1 system, DateTime time) + { + this.DataID = data.ReceiveDataID; + this.Name = item.Name; + this.Lot = item.LotNo; + this.OverRange = Helper.StringToDecimalPlaces(item.OverRange, system.DecimalPlaces); + this.UnderRange = Helper.StringToDecimalPlaces(item.UnderRange, system.DecimalPlaces); + this.Weight = Helper.DoubleToString(data.Weight, system.DecimalPlaces); + this.Date = string.Format("{0:yyyy-MM-dd}", time); + this.Time = string.Format("{0:HH:mm:ss}", time); + this.PassCount = data.PassCount.ToString(); + this.Grade = data.JudgmentStatus.ToString(); + } + #endregion + } + #endregion + + #region JudgmentResult + public class JudgmentResult + { + #region Field + private DataStore.JudgmentResult m_Judgment1; + private DataStore.JudgmentResult m_Judgment2; + private DataStore.JudgmentResult m_Judgment3; + private DataStore.JudgmentResult m_Judgment4; + private DataStore.JudgmentResult m_Judgment5; + private DataStore.JudgmentResult m_Judgment6; + private DataStore.JudgmentResult m_Judgment7; + private DataStore.JudgmentResult m_Judgment8; + private DataStore.JudgmentResult m_PreviousRejectData; + private DataStore.JudgmentResult m_Judgment10; + private DataStore.JudgmentResult m_Judgment11; + private DataStore.JudgmentResult m_Judgment12; + private DataStore.JudgmentResult m_CurrentRejectData; + private DataStore.JudgmentResult m_Judgment14; + private DataStore.JudgmentResult m_Judgment15; + private DataStore.JudgmentResult m_Judgment16; + #endregion + + #region Constructor + public JudgmentResult() + { + this.Initialize(); + } + #endregion + + #region Property + public DataStore.JudgmentResult Judgment1 + { + get { return this.m_Judgment1; } + set { this.m_Judgment1 = value; } + } + public DataStore.JudgmentResult Judgment2 + { + get { return this.m_Judgment2; } + set { this.m_Judgment2 = value; } + } + public DataStore.JudgmentResult Judgment3 + { + get { return this.m_Judgment3; } + set { this.m_Judgment3 = value; } + } + public DataStore.JudgmentResult Judgment4 + { + get { return this.m_Judgment4; } + set { this.m_Judgment4 = value; } + } + public DataStore.JudgmentResult Judgment5 + { + get { return this.m_Judgment5; } + set { this.m_Judgment5 = value; } + } + public DataStore.JudgmentResult Judgment6 + { + get { return this.m_Judgment6; } + set { this.m_Judgment6 = value; } + } + public DataStore.JudgmentResult Judgment7 + { + get { return this.m_Judgment7; } + set { this.m_Judgment7 = value; } + } + public DataStore.JudgmentResult Judgment8 + { + get { return this.m_Judgment8; } + set { this.m_Judgment8 = value; } + } + public DataStore.JudgmentResult PreviousRejectData + { + get { return this.m_PreviousRejectData; } + set { this.m_PreviousRejectData = value; } + } + public DataStore.JudgmentResult Judgment10 + { + get { return this.m_Judgment10; } + set { this.m_Judgment10 = value; } + } + public DataStore.JudgmentResult Judgment11 + { + get { return this.m_Judgment11; } + set { this.m_Judgment11 = value; } + } + public DataStore.JudgmentResult Judgment12 + { + get { return this.m_Judgment12; } + set { this.m_Judgment12 = value; } + } + public DataStore.JudgmentResult CurrentRejectData + { + get { return this.m_CurrentRejectData; } + set { this.m_CurrentRejectData = value; } + } + public DataStore.JudgmentResult Judgment14 + { + get { return this.m_Judgment14; } + set { this.m_Judgment14 = value; } + } + public DataStore.JudgmentResult Judgment15 + { + get { return this.m_Judgment15; } + set { this.m_Judgment15 = value; } + } + public DataStore.JudgmentResult Judgment16 + { + get { return this.m_Judgment16; } + set { this.m_Judgment16 = value; } + } + #endregion + + #region Method + public void Initialize() + { + this.Judgment1 = DataStore.JudgmentResult.None; + this.Judgment2 = DataStore.JudgmentResult.None; + this.Judgment3 = DataStore.JudgmentResult.None; + this.Judgment4 = DataStore.JudgmentResult.None; + this.Judgment5 = DataStore.JudgmentResult.None; + this.Judgment6 = DataStore.JudgmentResult.None; + this.Judgment7 = DataStore.JudgmentResult.None; + this.Judgment8 = DataStore.JudgmentResult.None; + this.PreviousRejectData = DataStore.JudgmentResult.None; + this.Judgment10 = DataStore.JudgmentResult.None; + this.Judgment11 = DataStore.JudgmentResult.None; + this.Judgment12 = DataStore.JudgmentResult.None; + this.CurrentRejectData = DataStore.JudgmentResult.None; + this.Judgment14 = DataStore.JudgmentResult.None; + this.Judgment15 = DataStore.JudgmentResult.None; + this.Judgment16 = DataStore.JudgmentResult.None; + } + #endregion + } + #endregion + + #region Serial Com - OPT2(나우시스템즈) + public class SerialOPT2 + { + #region Field + private bool m_IsReceivedData; + private bool m_IsErrorReceivedData; + private bool m_IsErrorSettingStatus; + private bool m_IsFailProductChange; + #endregion + + #region Constructor + public SerialOPT2() + { + this.Initialization(); + } + #endregion + + #region Property + public bool IsReceivedData + { + get { return this.m_IsReceivedData; } + set { this.m_IsReceivedData = value; } + } + public bool IsErrorReceivedData + { + get { return this.m_IsErrorReceivedData; } + set { this.m_IsErrorReceivedData = value; } + } + public bool IsErrorSettingStatus + { + get { return this.m_IsErrorSettingStatus; } + set { this.m_IsErrorSettingStatus = value; } + } + public bool IsFailProductChange + { + get { return this.m_IsFailProductChange; } + set { this.m_IsFailProductChange = value; } + } + #endregion + + #region Method + public void Initialization() + { + this.IsReceivedData = false; + this.IsErrorReceivedData = false; + this.IsErrorSettingStatus = false; + this.IsFailProductChange = false; + } + #endregion + } + #endregion + + #region User + public class User + { + #region Field + private Collection m_Level1Users; + private Collection m_Level2Users; + private Collection m_Level3Users; + + private UserItem m_DeveloperUser; + #endregion + + #region Constructor + public User() + { + this.Initialize(); + } + #endregion + + #region Property + public Collection Level1Users + { + get { return this.m_Level1Users; } + set { this.m_Level1Users = value; } + } + public Collection Level2Users + { + get { return this.m_Level2Users; } + set { this.m_Level2Users = value; } + } + public Collection Level3Users + { + get { return this.m_Level3Users; } + set { this.m_Level3Users = value; } + } + + public UserItem DeveloperUser + { + get { return this.m_DeveloperUser; } + private set { this.m_DeveloperUser = value; } + } + #endregion + + #region Method + private void Initialize() + { + this.Level1Users = new Collection(); + this.Level2Users = new Collection(); + this.Level3Users = new Collection(); + + this.Level1Users.Clear(); + this.Level2Users.Clear(); + this.Level3Users.Clear(); + + for (int i = 0; i < 5; i++) + { + this.Level1Users.Add(new UserItem()); + this.Level2Users.Add(new UserItem()); + this.Level3Users.Add(new UserItem()); + } + + this.DeveloperUser = new UserItem(); + this.DeveloperUser.ID = "Intech"; + this.DeveloperUser.Password = "20090810"; + this.DeveloperUser.Group = DataStore.UserGroup.Level4Developer; + } + + public UserItem FindUser(string id) + { + UserItem user = null; + + // 개발자 유저 검색 + if (id == this.DeveloperUser.ID) + { + user = new UserItem(); + user.ID = this.DeveloperUser.ID; + user.Password = this.DeveloperUser.Password; + user.Group = this.DeveloperUser.Group; + return user; + } + + // 일반 유저 검색 + for (int i = 0; i < this.Level1Users.Count; i++) + { + if (this.Level1Users[i].Group != DataStore.UserGroup.None) + { + if (this.Level1Users[i].ID.Trim() == id.Trim()) + { + user = new UserItem(); + user.ID = this.Level1Users[i].ID.Trim(); + user.Password = this.Level1Users[i].Password; + user.Group = this.Level1Users[i].Group; + return user; + } + } + + if (this.Level2Users[i].Group != DataStore.UserGroup.None) + { + if (this.Level2Users[i].ID.Trim() == id.Trim()) + { + user = new UserItem(); + user.ID = this.Level2Users[i].ID.Trim(); + user.Password = this.Level2Users[i].Password; + user.Group = this.Level2Users[i].Group; + return user; + } + } + + if (this.Level3Users[i].Group != DataStore.UserGroup.None) + { + if (this.Level3Users[i].ID.Trim() == id.Trim()) + { + user = new UserItem(); + user.ID = this.Level3Users[i].ID.Trim(); + user.Password = this.Level3Users[i].Password; + user.Group = this.Level3Users[i].Group; + return user; + } + } + } + + return user; + } + public UserItem FindDeveloperUser(string id) + { + UserItem user = null; + + // 개발자 유저 검색 + if (id == this.DeveloperUser.ID) + { + user = new UserItem(); + user.ID = this.DeveloperUser.ID; + user.Password = this.DeveloperUser.Password; + user.Group = this.DeveloperUser.Group; + return user; + } + + return user; + } + + public bool SearchID(string id) + { + bool ret = false; + + for (int i = 0; i < this.Level1Users.Count; i++) + { + if (this.Level1Users[i].ID.Trim() == id.Trim()) + return ret = true; + } + for (int i = 0; i < this.Level2Users.Count; i++) + { + if (this.Level2Users[i].ID.Trim() == id.Trim()) + return ret = true; + } + for (int i = 0; i < this.Level3Users.Count; i++) + { + if (this.Level3Users[i].ID.Trim() == id.Trim()) + return ret = true; + } + + return ret; + } + + #region Level1 + public UserItem Level1FindUser(string id) + { + UserItem user = null; + + for (int i = 0; i < this.Level1Users.Count; i++) + { + if (this.Level1Users[i].ID.Trim() == id.Trim()) + { + user = new UserItem(); + user.ID = this.Level1Users[i].ID.Trim(); + user.Password = this.Level1Users[i].Password; + user.Group = this.Level1Users[i].Group; + return user; + } + } + + return user; + } + public bool Level1SearchID(string id) + { + bool ret = false; + + for (int i = 0; i < this.Level1Users.Count; i++) + { + if (this.Level1Users[i].ID.Trim() == id.Trim()) + return ret = true; + } + + return ret; + } + public bool Level1DeleteLevel1User(UserItem user) + { + bool ret = false; + + return ret; + } + public bool Level1AddUser(UserItem user) + { + bool ret = false; + + return ret; + } + public bool Level1ModifyUser(UserItem user) + { + bool ret = false; + + return ret; + } + #endregion + #region Level2 + public UserItem Level2FindUser(string id) + { + UserItem user = null; + + for (int i = 0; i < this.Level2Users.Count; i++) + { + if (this.Level2Users[i].ID.Trim() == id.Trim()) + { + user = new UserItem(); + user.ID = this.Level2Users[i].ID.Trim(); + user.Password = this.Level2Users[i].Password; + user.Group = this.Level2Users[i].Group; + return user; + } + } + + return user; + } + public bool Level2DeleteLevel1User(UserItem user) + { + bool ret = false; + + return ret; + } + public bool Level2AddUser(UserItem user) + { + bool ret = false; + + return ret; + } + public bool Level2ModifyUser(UserItem user) + { + bool ret = false; + + return ret; + } + #endregion + #region Level3 + public UserItem Level3FindUser(string id) + { + UserItem user = null; + + for (int i = 0; i < this.Level3Users.Count; i++) + { + if (this.Level3Users[i].ID.Trim() == id.Trim()) + { + user = new UserItem(); + user.ID = this.Level3Users[i].ID.Trim(); + user.Password = this.Level3Users[i].Password; + user.Group = this.Level3Users[i].Group; + return user; + } + } + + return user; + } + public bool Level3DeleteLevel1User(UserItem user) + { + bool ret = false; + + return ret; + } + public bool Level3AddUser(UserItem user) + { + bool ret = false; + + return ret; + } + public bool Level3ModifyUser(UserItem user) + { + bool ret = false; + + return ret; + } + #endregion + + #endregion + } + #endregion + #region UserItem + public class UserItem + { + #region Field + private string m_ID; + private string m_Password; + private DataStore.UserGroup m_Group; + #endregion + + #region Constructor + public UserItem() + { + this.Initialize(); + } + #endregion + + #region Property + public string ID + { + get { return this.m_ID; } + set { this.m_ID = value; } + } + public string Password + { + get { return this.m_Password; } + set { this.m_Password = value; } + } + public DataStore.UserGroup Group + { + get { return this.m_Group; } + set { this.m_Group = value; } + } + #endregion + + #region Method + private void Initialize() + { + this.ID = "-"; + this.Password = "-"; + this.Group = DataStore.UserGroup.None; + } + #endregion + } + #endregion + #region StructUserItem + [StructLayout(LayoutKind.Sequential)] + public struct StructUserItem + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string ID; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string Password; + + public DataStore.UserGroup Group; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string Dummy1; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string Dummy2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string Dummy3; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string Dummy4; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)] + public string Dummy5; + } + #endregion + + #region UserGroup + public class UserGroup + { + #region Field + private UserGroupItem m_Level1; + private UserGroupItem m_Level2; + private UserGroupItem m_Level3; + private UserGroupItem m_NotLogin; + #endregion + + #region Constructor + public UserGroup() + { + this.Initialize(); + } + #endregion + + #region Property + public UserGroupItem Level1 + { + get { return this.m_Level1; } + set { this.m_Level1 = value; } + } + public UserGroupItem Level2 + { + get { return this.m_Level2; } + set { this.m_Level2 = value; } + } + public UserGroupItem Level3 + { + get { return this.m_Level3; } + set { this.m_Level3 = value; } + } + public UserGroupItem NotLogin + { + get { return this.m_NotLogin; } + set { this.m_NotLogin = value; } + } + #endregion + + #region Method + private void Initialize() + { + this.Level1 = new UserGroupItem(); + this.Level2 = new UserGroupItem(); + this.Level3 = new UserGroupItem(); + this.NotLogin = new UserGroupItem(); + } + + public bool GetLevel1AccessRight(DataStore.DisplayStore display) + { + bool ret = false; + + return ret; + } + public bool GetLevel2AccessRight(DataStore.DisplayStore display) + { + bool ret = false; + + return ret; + } + public bool GetLevel3AccessRight(DataStore.DisplayStore display) + { + bool ret = false; + + return ret; + } + #endregion + } + #endregion + #region UserGroupItem + public class UserGroupItem + { + #region Field + private bool m_IsMainDisplayProductNo; + private bool m_IsMainDisplayWeightSetting; + private bool m_IsMainDisplayClear; + private bool m_IsMainDisplaySubMenu; + + private bool m_IsBasicTime; + private bool m_IsBasicProduct; + private bool m_IsBasicDataBackup; + private bool m_IsBasicDataStatistics; + + private bool m_IsConfiSerial; + private bool m_IsConfiEthernet; + private bool m_IsConfiCountingOutput; + private bool m_IsConfiOptionBoard; + + private bool m_IsSystemCalibration; + private bool m_IsSystemJudgmentSetting; + private bool m_IsSystemSorterSetting; + private bool m_IsSystemAutoZero; + private bool m_IsSystemIOTest; + private bool m_IsSystemExternalOutput; + private bool m_IsSystemExternalInput; + + private bool m_IsEquipUpdate; + private bool m_IsEquipInitialize; + private bool m_IsEquipFunctionSetting; + private bool m_IsEquipUserSetting; + private bool m_IsEquipEngineerSetting; + private bool m_IsEquipSystemLog; + + private bool m_IsInforSystem; + private bool m_IsInforAS; + #endregion + + #region Constructor + public UserGroupItem() + { + this.Initialize(); + } + #endregion + + #region Property + public bool IsMainDisplayProductNo + { + get { return this.m_IsMainDisplayProductNo; } + set { this.m_IsMainDisplayProductNo = value; } + } + public bool IsMainDisplayWeightSetting + { + get { return this.m_IsMainDisplayWeightSetting; } + set { this.m_IsMainDisplayWeightSetting = value; } + } + public bool IsMainDisplayClear + { + get { return this.m_IsMainDisplayClear; } + set { this.m_IsMainDisplayClear = value; } + } + public bool IsMainDisplaySubMenu + { + get { return this.m_IsMainDisplaySubMenu; } + set { this.m_IsMainDisplaySubMenu = value; } + } + public bool IsMainEnable + { + get + { + bool ret = false; + + if (this.IsMainDisplayProductNo == true || this.IsMainDisplayWeightSetting == true + || this.IsMainDisplayClear == true || this.IsMainDisplaySubMenu == true) + ret = true; + + return ret; + } + } + + public bool IsBasicTime + { + get { return this.m_IsBasicTime; } + set { this.m_IsBasicTime = value; } + } + public bool IsBasicProduct + { + get { return this.m_IsBasicProduct; } + set { this.m_IsBasicProduct = value; } + } + public bool IsBasicDataBackup + { + get { return this.m_IsBasicDataBackup; } + set { this.m_IsBasicDataBackup = value; } + } + public bool IsBasicDataStatistics + { + get { return this.m_IsBasicDataStatistics; } + set { this.m_IsBasicDataStatistics = value; } + } + public bool IsBasicEnable + { + get + { + bool ret = false; + + if (this.IsBasicTime == true || this.IsBasicProduct == true + || this.IsBasicDataBackup == true || this.IsBasicDataStatistics == true) + ret = true; + + return ret; + } + } + + public bool IsConfiSerial + { + get { return this.m_IsConfiSerial; } + set { this.m_IsConfiSerial = value; } + } + public bool IsConfiEthernet + { + get { return this.m_IsConfiEthernet; } + set { this.m_IsConfiEthernet = value; } + } + public bool IsConfiCountingOutput + { + get { return this.m_IsConfiCountingOutput; } + set { this.m_IsConfiCountingOutput = value; } + } + public bool IsConfiOptionBoard + { + get { return this.m_IsConfiOptionBoard; } + set { this.m_IsConfiOptionBoard = value; } + } + public bool IsConfiEnable + { + get + { + bool ret = false; + + if (this.IsConfiSerial == true || this.IsConfiEthernet == true + || this.IsConfiCountingOutput == true || this.IsConfiOptionBoard == true) + ret = true; + + return ret; + } + } + + public bool IsSystemCalibration + { + get { return this.m_IsSystemCalibration; } + set { this.m_IsSystemCalibration = value; } + } + public bool IsSystemJudgmentSetting + { + get { return this.m_IsSystemJudgmentSetting; } + set { this.m_IsSystemJudgmentSetting = value; } + } + public bool IsSystemSorterSetting + { + get { return this.m_IsSystemSorterSetting; } + set { this.m_IsSystemSorterSetting = value; } + } + public bool IsSystemAutoZero + { + get { return this.m_IsSystemAutoZero; } + set { this.m_IsSystemAutoZero = value; } + } + public bool IsSystemIOTest + { + get { return this.m_IsSystemIOTest; } + set { this.m_IsSystemIOTest = value; } + } + public bool IsSystemExternalOutput + { + get { return this.m_IsSystemExternalOutput; } + set { this.m_IsSystemExternalOutput = value; } + } + public bool IsSystemExternalInput + { + get { return this.m_IsSystemExternalInput; } + set { this.m_IsSystemExternalInput = value; } + } + public bool IsSystemEnable + { + get + { + bool ret = false; + + if (this.IsSystemCalibration == true || this.IsSystemJudgmentSetting == true + || this.IsSystemSorterSetting == true || this.IsSystemAutoZero == true + || this.IsSystemIOTest == true || this.IsSystemExternalOutput == true || this.IsSystemExternalInput == true) + ret = true; + + return ret; + } + } + + public bool IsEquipUpdate + { + get { return this.m_IsEquipUpdate; } + set { this.m_IsEquipUpdate = value; } + } + public bool IsEquipInitialize + { + get { return this.m_IsEquipInitialize; } + set { this.m_IsEquipInitialize = value; } + } + public bool IsEquipFunctionSetting + { + get { return this.m_IsEquipFunctionSetting; } + set { this.m_IsEquipFunctionSetting = value; } + } + public bool IsEquipUserSetting + { + get { return this.m_IsEquipUserSetting; } + set { this.m_IsEquipUserSetting = value; } + } + public bool IsEquipSystemLog + { + get { return this.m_IsEquipSystemLog; } + set { this.m_IsEquipSystemLog = value; } + } + public bool IsEquipEngineerSetting + { + get { return this.m_IsEquipEngineerSetting; } + set { this.m_IsEquipEngineerSetting = value; } + } + public bool IsEquipEnable + { + get + { + bool ret = false; + + if (this.IsEquipUpdate == true || this.IsEquipInitialize == true || this.IsEquipSystemLog == true + || this.IsEquipFunctionSetting == true || this.IsEquipUserSetting == true || this.IsEquipEngineerSetting == true) + ret = true; + + return ret; + } + } + + public bool IsInforSystem + { + get { return this.m_IsInforSystem; } + set { this.m_IsInforSystem = value; } + } + public bool IsInforAS + { + get { return this.m_IsInforAS; } + set { this.m_IsInforAS = value; } + } + public bool IsInforEnable + { + get + { + bool ret = false; + + if (this.IsInforSystem == true || this.IsInforAS == true) + ret = true; + + return ret; + } + } + #endregion + + #region Method + private void Initialize() + { + this.IsMainDisplayProductNo = false; + this.IsMainDisplayWeightSetting = false; + this.IsMainDisplayClear = false; + this.IsMainDisplaySubMenu = false; + + this.IsBasicTime = false; + this.IsBasicProduct = false; + this.IsBasicDataBackup = false; + this.IsBasicDataStatistics = false; + + this.IsConfiSerial = false; + this.IsConfiEthernet = false; + this.IsConfiCountingOutput = false; + this.IsConfiOptionBoard = false; + + this.IsSystemCalibration = false; + this.IsSystemJudgmentSetting = false; + this.IsSystemSorterSetting = false; + this.IsSystemAutoZero = false; + this.IsSystemIOTest = false; + this.IsSystemExternalOutput = false; + this.IsSystemExternalInput = false; + + this.IsEquipUpdate = false; + this.IsEquipInitialize = false; + this.IsEquipFunctionSetting = false; + this.IsEquipUserSetting = false; + this.IsEquipEngineerSetting = false; + this.IsEquipSystemLog = false; + + this.IsInforSystem = true; + this.IsInforAS = true; + } + #endregion + } + #endregion + #region StructUserGroupItem + [StructLayout(LayoutKind.Sequential)] + public struct StructUserGroupItem + { + public bool IsEquipSystemLog; + public bool IsMainDisplayProductNo; + public bool IsMainDisplayWeightSetting; + public bool IsMainDisplayClear; + public bool IsMainDisplaySubMenu; + + public bool IsBasicTime; + public bool IsBasicProduct; + public bool IsBasicDataBackup; + public bool IsBasicDataStatistics; + + public bool IsConfiSerial; + public bool IsConfiOptionBoard; + + public bool IsSystemCalibration; + public bool IsSystemJudgmentSetting; + public bool IsSystemSorterSetting; + public bool IsSystemAutoZero; + public bool IsSystemIOTest; + public bool IsSystemExternalOutput; + + public bool IsEquipUpdate; + public bool IsEquipInitialize; + public bool IsEquipFunctionSetting; + public bool IsEquipUserSetting; + + public bool IsInforSystem; + public bool IsInforAS; + + public bool IsConfiEthernet; + public bool IsConfiCountingOutput; + public bool IsSystemExternalInput; + public bool IsEquipEngineerSetting; + + public bool Dummy1; + public bool Dummy2; + public bool Dummy3; + public bool Dummy4; + public bool Dummy5; + public bool Dummy6; + public bool Dummy7; + public bool Dummy8; + public bool Dummy9; + public bool Dummy10; + public bool Dummy11; + public bool Dummy12; + public bool Dummy13; + public bool Dummy14; + public bool Dummy15; + public bool Dummy16; + } + #endregion +} diff --git a/ITC81DB.sln b/ITC81DB.sln new file mode 100644 index 0000000..0ada7e2 --- /dev/null +++ b/ITC81DB.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ITC81DB", "ITC81DB\ITC81DB.csproj", "{F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ITC81DB_ImageDll", "ITC81DB_ImageDll\ITC81DB_ImageDll\ITC81DB_ImageDll.csproj", "{501CC4ED-3B74-4189-8FD5-29F990358D21}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}.Debug|Any CPU.Deploy.0 = Debug|Any CPU + {F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}.Release|Any CPU.Build.0 = Release|Any CPU + {F3AC32D4-8DAC-4F4D-AD52-2610D6237DD5}.Release|Any CPU.Deploy.0 = Release|Any CPU + {501CC4ED-3B74-4189-8FD5-29F990358D21}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {501CC4ED-3B74-4189-8FD5-29F990358D21}.Debug|Any CPU.Build.0 = Debug|Any CPU + {501CC4ED-3B74-4189-8FD5-29F990358D21}.Release|Any CPU.ActiveCfg = Release|Any CPU + {501CC4ED-3B74-4189-8FD5-29F990358D21}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/ITC81DB.suo b/ITC81DB.suo new file mode 100644 index 0000000000000000000000000000000000000000..8ce59dafddc8382afe9e25b1967fb2ce6fe4bf39 GIT binary patch literal 193024 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 literal 0 HcmV?d00001