3243 lines
137 KiB
C#
3243 lines
137 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Net.Sockets;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
|
|
using SmartX;
|
|
using INT89DB_26.DialogForms;
|
|
using INT89DB_26_ImageDll;
|
|
|
|
namespace INT89DB_26.Forms
|
|
{
|
|
public partial class FormMain : Form
|
|
{
|
|
#region Field
|
|
private SmartX.SmartSplash SmartSplashProgramLoad;
|
|
private int CommunicationCheckCount;
|
|
public bool IsCommunicationLogOpen;
|
|
public bool IsAdcLogOpen;
|
|
private bool FlagADCValueWrite;
|
|
public bool IsBootingComplete;
|
|
public int BufferSmartUart; // Buffer size 정의
|
|
|
|
// Motor Download 통신용 변수
|
|
public int LineNum;
|
|
// LineNum 현재값 저장
|
|
public int CurrentLineNum;
|
|
// Timeout 설정을 위한 변수
|
|
public int TimeOut;
|
|
|
|
// 파일 위치
|
|
private string m_PathLaunchFolder;
|
|
private string m_PathSystemFileFolder1;
|
|
private string m_PathSystemFileFolder2;
|
|
private string m_PathDataBackupFolder;
|
|
private string m_PathProgramSaveFolder;
|
|
|
|
// 로그온 색상
|
|
public Color ColorLogOff;
|
|
public Color ColorLogOn;
|
|
|
|
// Form 생성
|
|
public FormMainDisplay ChildFormMainDisplay;
|
|
public FormMenu ChildFormMenu;
|
|
public FormCalibration ChildFormCalibration;
|
|
public FormSystemSetting ChildFormSystemSetting;
|
|
public FormIOTest ChildFormIOTest;
|
|
public FormEquipmentSetting ChildFormEquipmentSetting;
|
|
public FormDataBackup ChildFormDataBackup;
|
|
public FormConfiguration ChildFormConfiguration;
|
|
public FormTimeSetting ChildFormTimeSetting;
|
|
public FormInformation ChildFormInformation;
|
|
public FormFactoryReset ChildFormFactoryInitialize;
|
|
public FormProgramUpdate ChildFormProgramUpdate;
|
|
public FormEquipmentTest ChildFormEquipmentTest;
|
|
public FormUserSetting ChildFormUserSetting;
|
|
public FormCommunication ChildFormCommunication;
|
|
|
|
// System Configuration
|
|
public SystemConfigurationItem SystemConfig;
|
|
// 현재 선택 된 품목
|
|
public ProductItem CurrentProductItem;
|
|
// 현재 선택 된 판정 설정 값
|
|
public JudgmentSetItem CurrentJudgmentSetItem;
|
|
// 중량 조정 설정값
|
|
public CalibrationItem CurrentCalibrationItem;
|
|
// 제로 파라미터 설정값
|
|
public ZeroParameterItem CurrentZeroParameterItem;
|
|
// 옵션 파라미터 설정값
|
|
public OptionParameterItem CurrentOptionParameterItem;
|
|
// FeedBack Range (아남자동기 PLC)
|
|
public FeedBackRangeItem CurrentFeedBackRangeItem;
|
|
// User
|
|
public CollectionUser CurrentCollectionUser;
|
|
// 열별 중량 데이터
|
|
public Collection<WeightData> CollectionWeightData;
|
|
// 장비테스트모드 열별 중량 데이터
|
|
public Collection<WeightData> CollectionWeightDataTest;
|
|
// 장비 구동 상태
|
|
private DataStore.EquipmentStatus m_EquipmentStatus;
|
|
// 알람
|
|
private AlarmList CurrentAlarmList;
|
|
|
|
// Collection
|
|
private Collection<int> CollectionGraphData; // 판정설정 그래프 데이터
|
|
private Collection<string> CollectionIOTest_InputData; // IO Test Input 데이터 취합
|
|
private Collection<string> CollectionZeroParameterRange; // 자동영점 - 범위
|
|
private Collection<string> CollectionZeroParameterTime; // 자동영점 - 시간
|
|
private Collection<string> CollectionZeroParameterVariates; // 자동영점 - 변량
|
|
private Collection<string> CollectionBalanceWeight; // 분동중량값
|
|
private Collection<string> CollectionMaxWeight; // 분동중량값
|
|
private Collection<string> CollectionDigit; // 한눈의값
|
|
private Collection<string> CollectionFilter; // 필터
|
|
private Collection<string> CollectionVersion; // 프로그램 버전
|
|
public Collection<string> CollectionProductName; // 품목명 리스트
|
|
|
|
// Ethernet
|
|
public bool IsEthernetThreadStop;
|
|
private bool IsEthernetTransferData;
|
|
|
|
public object EthernetTransferData;
|
|
|
|
private TcpClient EthernetTcpClient;
|
|
|
|
private NetworkStream EthernetNetStream;
|
|
private StreamReader EthernetStmReader;
|
|
private StreamWriter EthernetStmWriter;
|
|
|
|
private delegate void TransferDataByteArrayCallback(byte[] byteArray);
|
|
private delegate void TransferDataStringCallback(string strtext);
|
|
private delegate void TextStatusCallback(string strtext);
|
|
private delegate void UIControlCallback(bool bEnable);
|
|
private delegate void UIServerStatusCallback(bool bEnable);
|
|
#endregion
|
|
|
|
#region Constructor
|
|
public FormMain()
|
|
{
|
|
InitializeComponent();
|
|
|
|
// 프로그램 로딩 이미지
|
|
this.SmartSplashProgramLoad = new SmartX.SmartSplash();
|
|
this.SmartSplashProgramLoad.CenterPosition = true;
|
|
this.SmartSplashProgramLoad.AnimationInterval = 100;
|
|
this.SmartSplashProgramLoad.LoadingImagePathname = "SmartLoading3";
|
|
this.SmartSplashProgramLoad.Start();
|
|
}
|
|
#endregion
|
|
|
|
#region Property
|
|
public string PathLaunchFolder
|
|
{
|
|
get { return this.m_PathLaunchFolder; }
|
|
set { this.m_PathLaunchFolder = value; }
|
|
}
|
|
public string PathSystemFileFolder1
|
|
{
|
|
get { return this.m_PathSystemFileFolder1; }
|
|
set { this.m_PathSystemFileFolder1 = value; }
|
|
}
|
|
public string PathSystemFileFolder2
|
|
{
|
|
get { return this.m_PathSystemFileFolder2; }
|
|
set { this.m_PathSystemFileFolder2 = value; }
|
|
}
|
|
public string PathDataBackupFolder
|
|
{
|
|
get { return this.m_PathDataBackupFolder; }
|
|
set { this.m_PathDataBackupFolder = value; }
|
|
}
|
|
public string PathProgramSaveFolder
|
|
{
|
|
get { return this.m_PathProgramSaveFolder; }
|
|
set { this.m_PathProgramSaveFolder = value; }
|
|
}
|
|
|
|
public DataStore.EquipmentStatus EquipmentStatus
|
|
{
|
|
get { return this.m_EquipmentStatus; }
|
|
private set { this.m_EquipmentStatus = value; }
|
|
}
|
|
#endregion
|
|
|
|
#region Method
|
|
private void CreateForm()
|
|
{
|
|
this.ChildFormMainDisplay = new FormMainDisplay(this);
|
|
this.ChildFormMenu = new FormMenu(this);
|
|
this.ChildFormCalibration = new FormCalibration(this);
|
|
this.ChildFormSystemSetting = new FormSystemSetting(this);
|
|
this.ChildFormIOTest = new FormIOTest(this);
|
|
this.ChildFormEquipmentSetting = new FormEquipmentSetting(this);
|
|
this.ChildFormDataBackup = new FormDataBackup(this);
|
|
this.ChildFormConfiguration = new FormConfiguration(this);
|
|
this.ChildFormTimeSetting = new FormTimeSetting(this);
|
|
this.ChildFormInformation = new FormInformation(this);
|
|
this.ChildFormFactoryInitialize = new FormFactoryReset(this);
|
|
this.ChildFormProgramUpdate = new FormProgramUpdate(this);
|
|
this.ChildFormEquipmentTest = new FormEquipmentTest(this);
|
|
this.ChildFormUserSetting = new FormUserSetting(this);
|
|
this.ChildFormCommunication = new FormCommunication(this);
|
|
|
|
this.smartForm.MainForm = this;
|
|
|
|
this.smartForm.AddChildForm(this.ChildFormMainDisplay);
|
|
this.smartForm.AddChildForm(this.ChildFormMenu);
|
|
this.smartForm.AddChildForm(this.ChildFormCalibration);
|
|
this.smartForm.AddChildForm(this.ChildFormSystemSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormIOTest);
|
|
this.smartForm.AddChildForm(this.ChildFormEquipmentSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormDataBackup);
|
|
this.smartForm.AddChildForm(this.ChildFormConfiguration);
|
|
this.smartForm.AddChildForm(this.ChildFormTimeSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormInformation);
|
|
this.smartForm.AddChildForm(this.ChildFormFactoryInitialize);
|
|
this.smartForm.AddChildForm(this.ChildFormProgramUpdate);
|
|
this.smartForm.AddChildForm(this.ChildFormEquipmentTest);
|
|
this.smartForm.AddChildForm(this.ChildFormUserSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormCommunication);
|
|
}
|
|
private void CreateCollection()
|
|
{
|
|
this.CollectionWeightData = new Collection<WeightData>();
|
|
this.CollectionWeightDataTest = new Collection<WeightData>();
|
|
this.CollectionGraphData = new Collection<int>();
|
|
this.CollectionIOTest_InputData = new Collection<string>();
|
|
this.CollectionZeroParameterRange = new Collection<string>();
|
|
this.CollectionZeroParameterTime = new Collection<string>();
|
|
this.CollectionZeroParameterVariates = new Collection<string>();
|
|
this.CollectionBalanceWeight = new Collection<string>();
|
|
this.CollectionMaxWeight = new Collection<string>();
|
|
this.CollectionDigit = new Collection<string>();
|
|
this.CollectionFilter = new Collection<string>();
|
|
this.CollectionVersion = new Collection<string>();
|
|
this.CollectionProductName = new Collection<string>();
|
|
|
|
this.CollectionWeightData.Clear();
|
|
this.CollectionWeightDataTest.Clear();
|
|
this.CollectionGraphData.Clear();
|
|
this.CollectionIOTest_InputData.Clear();
|
|
this.CollectionZeroParameterRange.Clear();
|
|
this.CollectionZeroParameterTime.Clear();
|
|
this.CollectionZeroParameterVariates.Clear();
|
|
this.CollectionBalanceWeight.Clear();
|
|
this.CollectionMaxWeight.Clear();
|
|
this.CollectionDigit.Clear();
|
|
this.CollectionFilter.Clear();
|
|
this.CollectionVersion.Clear();
|
|
this.CollectionProductName.Clear();
|
|
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
this.CollectionWeightData.Add(new WeightData());
|
|
this.CollectionWeightDataTest.Add(new WeightData());
|
|
this.CollectionZeroParameterRange.Add("");
|
|
this.CollectionZeroParameterTime.Add("");
|
|
this.CollectionZeroParameterVariates.Add("");
|
|
this.CollectionBalanceWeight.Add("");
|
|
this.CollectionMaxWeight.Add("");
|
|
this.CollectionDigit.Add("");
|
|
this.CollectionFilter.Add("");
|
|
}
|
|
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
this.CollectionVersion.Add("");
|
|
}
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
this.CollectionGraphData.Add(0);
|
|
}
|
|
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
this.CollectionIOTest_InputData.Add("0");
|
|
}
|
|
}
|
|
private void DefaultSetting1()
|
|
{
|
|
this.LineNum = 1;
|
|
this.CurrentLineNum = 0;
|
|
this.TimeOut = 0;
|
|
this.CommunicationCheckCount = 0;
|
|
this.IsCommunicationLogOpen = false;
|
|
this.IsAdcLogOpen = false;
|
|
this.FlagADCValueWrite = false;
|
|
this.IsBootingComplete = false;
|
|
this.PathLaunchFolder = "SD Card\\";
|
|
this.PathSystemFileFolder1 = this.PathLaunchFolder + "SystemFile1\\";
|
|
this.PathSystemFileFolder2 = this.PathLaunchFolder + "SystemFile2\\";
|
|
this.PathDataBackupFolder = this.PathLaunchFolder + "DataBackup\\";
|
|
this.PathProgramSaveFolder = this.PathLaunchFolder + "Program\\";
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Stop;
|
|
this.BufferSmartUart = 1000000; // 1MB
|
|
this.ColorLogOff = Color.Red;
|
|
this.ColorLogOn = Color.Yellow;
|
|
|
|
this.SystemConfig = new SystemConfigurationItem();
|
|
this.CurrentProductItem = new ProductItem();
|
|
this.CurrentJudgmentSetItem = new JudgmentSetItem();
|
|
this.CurrentCalibrationItem = new CalibrationItem();
|
|
this.CurrentZeroParameterItem = new ZeroParameterItem();
|
|
this.CurrentOptionParameterItem = new OptionParameterItem();
|
|
this.CurrentFeedBackRangeItem = new FeedBackRangeItem();
|
|
this.CurrentCollectionUser = new CollectionUser();
|
|
this.CurrentAlarmList = new AlarmList();
|
|
|
|
// SystemFile1 폴더 생성
|
|
if (Directory.Exists(this.PathSystemFileFolder1) == false)
|
|
Directory.CreateDirectory(this.PathSystemFileFolder1);
|
|
|
|
// SystemFile2 폴더 생성
|
|
if (Directory.Exists(this.PathSystemFileFolder2) == false)
|
|
Directory.CreateDirectory(this.PathSystemFileFolder2);
|
|
|
|
// DataBackup 폴더 생성
|
|
if (Directory.Exists(this.PathDataBackupFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataBackupFolder);
|
|
}
|
|
private void DefaultSetting2()
|
|
{
|
|
// 이더넷
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetOperationMode == 1)
|
|
{
|
|
try
|
|
{
|
|
if (string.Compare(this.smartConfigs.IPSettings.DeviceIP, "0.0.0.0") != 0)
|
|
this.EthernetServerStart();
|
|
|
|
if (this.SystemConfig.EthernetOperationMode == 1 && this.smartTCPMultiServer.IsStart == true)
|
|
this.ChildFormMainDisplay.TimerServer(true);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
private void TrasferSystemParameter(SystemConfigurationItem item)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(Helper.StringZeroFillDigits4(item.EquipmentID.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(item.EquipmentColumns.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(item.InverterQTY.ToString()));
|
|
|
|
this.TransferDataStream(CommunicationCommand.Write, CommunicationID.MainBoard, CommunicationAddress._9047_ParameterSystem, sb.ToString());
|
|
}
|
|
public void TransferProductParameter(int productNumber)
|
|
{
|
|
string value = "";
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
ProductItem pItem = new ProductItem();
|
|
JudgmentSetItem jItem = new JudgmentSetItem();
|
|
|
|
this.LoadProductFile(ref pItem, productNumber - 1);
|
|
this.LoadJudgmentSetFile(ref jItem, productNumber - 1);
|
|
|
|
sb.Append(Helper.StringZeroFillDigits4(productNumber.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits7(pItem.UnderRange));
|
|
sb.Append(Helper.StringZeroFillDigits7(pItem.OverRange));
|
|
sb.Append(Helper.StringZeroFillDigits7(pItem.TareRange));
|
|
value = Helper.DoubleToString(jItem.DynamicCorrection, 7);
|
|
value = value.Replace(".", "");
|
|
sb.Append(Helper.StringZeroFillDigits7(value));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Filter.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.JudgmentDelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.DoubleDelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.JudgmentCount.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter1Mode.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter1DelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter1RunTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.ConveyorSpeed1.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.ConveyorSpeed2.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.ConveyorSpeed3.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.ConveyorSpeed4.ToString()));
|
|
|
|
this.TransferDataStream(CommunicationCommand.Write, CommunicationID.MainBoard, CommunicationAddress._9048_ParameterProduct, sb.ToString());
|
|
}
|
|
|
|
#region Communication Protocol
|
|
public string Protocol_OPT1(int lane, WeightData data)
|
|
{
|
|
string value = "";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(string.Format("IN{0:D3}", this.SystemConfig.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", this.SystemConfig.ProductNumber));
|
|
sb.Append(string.Format("{0:D2}", lane));
|
|
|
|
if (data.JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("P");
|
|
|
|
value = Helper.DoubleToString(data.Weight, this.SystemConfig.DecimalPlaces);
|
|
sb.Append(value.PadLeft(6, ' '));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_OPT2(int lane, WeightData data)
|
|
{
|
|
int value = 0, passWeight = 0, weight = 0;
|
|
string value2 = "";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(string.Format("IN{0:D3}", this.SystemConfig.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", this.SystemConfig.ProductNumber));
|
|
sb.Append(string.Format("{0:D2}", lane));
|
|
|
|
passWeight = int.Parse(this.CurrentProductItem.PassRange.Trim());
|
|
weight = int.Parse(data.WeightString.Trim());
|
|
value = weight - passWeight;
|
|
|
|
// SIGN
|
|
if (value < 0)
|
|
sb.Append("-");
|
|
else
|
|
sb.Append("+");
|
|
|
|
// WEIGHT
|
|
value = Math.Abs(value);
|
|
value2 = Helper.StringToDecimalPlaces(value.ToString(), this.SystemConfig.DecimalPlaces);
|
|
sb.Append(value2.PadLeft(6, ' '));
|
|
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
#endregion
|
|
#region Serial CH3
|
|
private void SerialUart3Open()
|
|
{
|
|
if (this.serialPort3.IsOpen == true)
|
|
this.serialPort3.Close();
|
|
|
|
if (this.SystemConfig.Serial3Mode != 0)
|
|
{
|
|
this.serialPort3.BaudRate = this.SystemConfig.Serial3BaudRate;
|
|
this.serialPort3.Open();
|
|
}
|
|
}
|
|
|
|
public void SerialCom3Write(string data)
|
|
{
|
|
this.serialPort3.Write(data);
|
|
}
|
|
#endregion
|
|
#region Ethernet
|
|
private void TreatEthernetCommunication(int lane, WeightData data)
|
|
{
|
|
if (this.SystemConfig.IsEthernetEnable == false)
|
|
return;
|
|
|
|
string sendData = "";
|
|
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1)
|
|
{
|
|
sendData = this.Protocol_OPT1(lane, data);
|
|
this.EthernetWrite(sendData);
|
|
}
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2)
|
|
{
|
|
sendData = this.Protocol_OPT2(lane, data);
|
|
this.EthernetWrite(sendData);
|
|
}
|
|
}
|
|
private void EthernetWrite(string etherData)
|
|
{
|
|
if (this.SystemConfig.EthernetOperationMode == 1)
|
|
{
|
|
if (this.smartTCPMultiServer.ClientInfoList != null)
|
|
{
|
|
foreach (SmartTCPMultiServer.CLIENTSINFOS client in this.smartTCPMultiServer.ClientInfoList)
|
|
this.EthernetServerSendMessage(client, etherData);
|
|
}
|
|
}
|
|
else
|
|
this.EthernetClientWeightData(etherData);
|
|
}
|
|
|
|
#region Server
|
|
public void EthernetServerStart()
|
|
{
|
|
if (this.smartTCPMultiServer.IsStart == false)
|
|
{
|
|
this.ChildFormCommunication.DisplayLabelLocalPort(false);
|
|
this.smartTCPMultiServer.Port = this.SystemConfig.EthernetLocalPort;
|
|
this.smartTCPMultiServer.Start();
|
|
}
|
|
}
|
|
public void EthernetServerStop()
|
|
{
|
|
if (this.smartTCPMultiServer.IsStart == true)
|
|
{
|
|
this.ChildFormCommunication.DisplayLabelLocalPort(true);
|
|
this.smartTCPMultiServer.Stop();
|
|
}
|
|
}
|
|
public void EthernetServerSendMessage(SmartTCPMultiServer.CLIENTSINFOS client, string msg)
|
|
{
|
|
this.smartTCPMultiServer.SendStringASCIIID(client.strID, msg);
|
|
}
|
|
public void EthernetServerSendMessage(SmartTCPMultiServer.CLIENTSINFOS client, byte[] bytes)
|
|
{
|
|
this.smartTCPMultiServer.SendByteByClientID(client.strID, bytes);
|
|
}
|
|
#endregion
|
|
|
|
#region Client
|
|
Thread cpClientThread;
|
|
|
|
public void EthernetClientConnect()
|
|
{
|
|
if (this.IsEthernetThreadStop == false)
|
|
return; // Online 경우
|
|
if (this.SystemConfig.IsEthernetEnable == false)
|
|
{
|
|
this.TextStatusOut("<Disable");
|
|
return;
|
|
}
|
|
|
|
if (string.Compare(this.SystemConfig.EthernetServerAddress, "0.0.0.0") == 0)
|
|
{
|
|
this.TextStatusOut("<Addr Err");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
this.cpClientThread = new Thread(new ThreadStart(EthernetClientReceiveThread));
|
|
|
|
this.cpClientThread.IsBackground = true;
|
|
|
|
this.cpClientThread.Start();
|
|
}
|
|
catch
|
|
{
|
|
TextStatusOut(">Thread Error");
|
|
}
|
|
}
|
|
public void EthernetClientDisconnect()
|
|
{
|
|
this.IsEthernetThreadStop = true;
|
|
this.DelegateUISeverStatus(false);
|
|
if (null != this.EthernetStmReader)
|
|
this.EthernetStmReader.Close();
|
|
|
|
if (null != this.EthernetStmWriter)
|
|
this.EthernetStmWriter.Close();
|
|
|
|
if (null != this.EthernetNetStream)
|
|
this.EthernetNetStream.Close();
|
|
|
|
if (null != this.EthernetTcpClient)
|
|
this.EthernetTcpClient.Close();
|
|
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client ({0:yyyy-MM-dd HH:mm:ss}): Disconnect", DateTime.Now));
|
|
}
|
|
|
|
private void EthernetClientReceiveThread()
|
|
{
|
|
//this.cpClientThread.Abort();
|
|
|
|
int nConnectPort = Convert.ToInt32(this.SystemConfig.EthernetServerPort);
|
|
try
|
|
{
|
|
this.DelegateTextStatusOut(">Now Connecting..");
|
|
this.EthernetTcpClient = new TcpClient(this.SystemConfig.EthernetServerAddress, nConnectPort);
|
|
|
|
this.EthernetNetStream = EthernetTcpClient.GetStream();
|
|
this.EthernetStmReader = new StreamReader(EthernetNetStream);
|
|
this.EthernetStmWriter = new StreamWriter(EthernetNetStream);
|
|
|
|
this.DelegateUISeverStatus(true);
|
|
this.DelegateTextStatusOut(">Connected Server");
|
|
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client ({0:yyyy-MM-dd HH:mm:ss}): Connect", DateTime.Now));
|
|
|
|
this.IsEthernetThreadStop = false;
|
|
|
|
// 판정 데이터 전송
|
|
if (this.IsEthernetTransferData == true)
|
|
{
|
|
this.IsEthernetTransferData = false;
|
|
Type type = this.EthernetTransferData.GetType();
|
|
if (type == typeof(string))
|
|
this.DelegateTransferData((string)this.EthernetTransferData);
|
|
else if (type == typeof(byte[]))
|
|
this.DelegateTransferData((byte[])this.EthernetTransferData);
|
|
else if (type == typeof(byte))
|
|
this.DelegateTransferData((byte)this.EthernetTransferData);
|
|
}
|
|
|
|
while (this.IsEthernetThreadStop == false)
|
|
{
|
|
string strRecvMsg = "";
|
|
char[] datas = new char[12];
|
|
int sum = 0;
|
|
|
|
try
|
|
{
|
|
//strRecvMsg = this.EthernetStmReader.ReadLine();
|
|
this.EthernetStmReader.Read(datas, 0, datas.Length);
|
|
for (int i = 0; i < datas.Length; i++)
|
|
sum += datas[i];
|
|
if (sum == 0)
|
|
return;
|
|
|
|
strRecvMsg = BitConverter.ToString(Encoding.UTF8.GetBytes(datas));
|
|
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client Receive ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, strRecvMsg));
|
|
|
|
if (null == strRecvMsg)
|
|
{
|
|
this.DelegateTextStatusOut(">Server Out");
|
|
this.IsEthernetThreadStop = true;
|
|
break;
|
|
}
|
|
|
|
this.DelegateTextStatusOut(strRecvMsg);
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateTextStatusOut(">Server Out");
|
|
this.IsEthernetThreadStop = true;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateTextStatusOut(">Connect Fail !");
|
|
}
|
|
finally
|
|
{
|
|
this.IsEthernetThreadStop = true;
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut(">Disconnected Server");
|
|
if (null != this.EthernetStmReader)
|
|
this.EthernetStmReader.Close();
|
|
|
|
if (null != this.EthernetStmWriter)
|
|
this.EthernetStmWriter.Close();
|
|
|
|
if (null != this.EthernetNetStream)
|
|
this.EthernetNetStream.Close();
|
|
|
|
if (null != this.EthernetTcpClient)
|
|
this.EthernetTcpClient.Close();
|
|
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client ({0:yyyy-MM-dd HH:mm:ss}): Disconnect", DateTime.Now));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
private void UIServerStatus(bool status)
|
|
{
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateEthernetStatusDisplay(status);
|
|
}
|
|
private void DelegateUISeverStatus(bool status)
|
|
{
|
|
this.Invoke(new UIServerStatusCallback(this.UIServerStatus), status);
|
|
}
|
|
|
|
private void TextStatusOut(string value)
|
|
{
|
|
if (this.ChildFormCommunication != null)
|
|
this.ChildFormCommunication.UpdateEthernetStatusDisplay(value);
|
|
}
|
|
private void DelegateTextStatusOut(string value)
|
|
{
|
|
this.Invoke(new TextStatusCallback(this.TextStatusOut), value);
|
|
}
|
|
|
|
private void DelegateTransferData(string data)
|
|
{
|
|
this.Invoke(new TransferDataStringCallback(this.EthernetClientSendMessage), data);
|
|
}
|
|
private void DelegateTransferData(byte[] data)
|
|
{
|
|
this.Invoke(new TransferDataByteArrayCallback(this.EthernetClientSendMessage), data);
|
|
}
|
|
private void DelegateTransferData(byte data)
|
|
{
|
|
this.Invoke(new TransferDataStringCallback(this.EthernetClientSendMessage), data);
|
|
}
|
|
public void EthernetClientSendMessage(string msg)
|
|
{
|
|
try
|
|
{
|
|
this.EthernetStmWriter.Write(msg);
|
|
this.EthernetStmWriter.Flush();
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, msg));
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut("> Disconnect");
|
|
}
|
|
}
|
|
public void EthernetClientSendMessage(byte[] msg)
|
|
{
|
|
try
|
|
{
|
|
this.EthernetStmWriter.BaseStream.Write(msg, 0, msg.Length);
|
|
this.EthernetStmWriter.Flush();
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, BitConverter.ToString(msg)));
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut("> Disconnect");
|
|
}
|
|
}
|
|
public void EthernetClientSendMessage(byte msg)
|
|
{
|
|
try
|
|
{
|
|
this.EthernetStmWriter.WriteLine(msg);
|
|
this.EthernetStmWriter.Flush();
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Client Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, msg));
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut("> Disconnect");
|
|
}
|
|
}
|
|
public void EthernetClientWeightData(string strTemp)
|
|
{
|
|
this.IsEthernetTransferData = true;
|
|
this.EthernetTransferData = strTemp;
|
|
|
|
if (this.IsEthernetThreadStop == true)
|
|
this.EthernetClientConnect();
|
|
else
|
|
this.EthernetClientSendMessage((string)this.EthernetTransferData);
|
|
}
|
|
public void EthernetClientWeightData(byte temp)
|
|
{
|
|
this.IsEthernetTransferData = true;
|
|
this.EthernetTransferData = temp;
|
|
|
|
if (this.IsEthernetThreadStop == true)
|
|
this.EthernetClientConnect();
|
|
else
|
|
this.EthernetClientSendMessage((byte)this.EthernetTransferData);
|
|
}
|
|
public void EthernetClientWeightDataForModbus(byte[] bytes)
|
|
{
|
|
this.IsEthernetTransferData = true;
|
|
this.EthernetTransferData = bytes;
|
|
|
|
if (this.IsEthernetThreadStop == true)
|
|
this.EthernetClientConnect();
|
|
else
|
|
this.EthernetClientSendMessage(bytes);
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
#region Uart Communication
|
|
private void OpenSmartUartLink()
|
|
{
|
|
string fullPath = "";
|
|
|
|
try
|
|
{
|
|
if (this.smartSerialPortLink.IsReadStart == false)
|
|
this.smartSerialPortLink.Open();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
#region Test 용 통신 로그
|
|
fullPath = this.PathDataBackupFolder + "Communicationlog.txt";
|
|
this.smartFileCommunicationLog.FilePathName = fullPath;
|
|
//this.smartFileCommunicationLog.Open();
|
|
//this.IsCommunicationLogOpen = true;
|
|
#endregion
|
|
|
|
#region ADC 통신 로그
|
|
fullPath = this.PathDataBackupFolder + this.SystemConfig.UsbID.ToString() + "ADC_log.txt";
|
|
this.smartFileAdcLog.FilePathName = fullPath;
|
|
#endregion
|
|
}
|
|
public void CloseSmartUartLink()
|
|
{
|
|
this.smartSerialPortLink.Close();
|
|
}
|
|
|
|
private bool SizeCheck(string cmd, string strTemp)
|
|
{
|
|
bool ret = false;
|
|
string dataSize = "";
|
|
int size = 0;
|
|
|
|
if (strTemp == null || strTemp.Length == 0)
|
|
{
|
|
ret = false;
|
|
return ret;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (cmd == "P")
|
|
dataSize = strTemp.Substring(14, strTemp.Length - 16);
|
|
else // "S"
|
|
dataSize = strTemp.Substring(10, strTemp.Length - 12);
|
|
|
|
size = int.Parse(strTemp.Substring(6, 4).Trim());
|
|
}
|
|
catch
|
|
{
|
|
ret = false;
|
|
return ret;
|
|
}
|
|
|
|
if (dataSize.Length == size)
|
|
ret = true;
|
|
else
|
|
ret = false;
|
|
|
|
return ret;
|
|
}
|
|
private bool ChksumCheck(string strTemp)
|
|
{
|
|
bool ret = false;
|
|
string chkSum = "", dataChksum = "";
|
|
|
|
if (strTemp == null || strTemp.Length == 0)
|
|
ret = false;
|
|
else
|
|
{
|
|
chkSum = strTemp.Substring(strTemp.Length - 2, 2);
|
|
dataChksum = Helper.Checksumcalculator(strTemp.Substring(0, strTemp.Length - 2));
|
|
|
|
if (chkSum == dataChksum)
|
|
ret = true;
|
|
else
|
|
ret = false;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public int TransferData(string command, string id)
|
|
{
|
|
int ret = 0;
|
|
string chkSum = "cc";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(command);
|
|
sb.Append(id);
|
|
|
|
chkSum = Helper.Checksumcalculator(sb.ToString());
|
|
|
|
sb.Append(chkSum);
|
|
|
|
if (this.smartSerialPortLink.IsReadStart == true)
|
|
this.smartSerialPortLink.WriteFrame(sb.ToString(), SmartX.SmartSerialPort.CODETYPES.ASCIICODE);
|
|
|
|
// 통신 확인 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, sb.ToString()));
|
|
|
|
return ret;
|
|
}
|
|
public int TransferDataStream(string command, string id, string address, string data)
|
|
{
|
|
int ret = 0;
|
|
string chkSum = "cc";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(command);
|
|
sb.Append(id);
|
|
sb.Append(Helper.StringZeroFillDigits4(data.Length.ToString()));
|
|
sb.Append(address);
|
|
sb.Append(data);
|
|
|
|
chkSum = Helper.Checksumcalculator(sb.ToString());
|
|
|
|
sb.Append(chkSum);
|
|
|
|
if (this.smartSerialPortLink.IsReadStart == true)
|
|
this.smartSerialPortLink.WriteFrame(sb.ToString(), SmartSerialPort.CODETYPES.ASCIICODE);
|
|
|
|
// 통신 확인 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, sb.ToString()));
|
|
|
|
return ret;
|
|
}
|
|
private void ReceiveData()
|
|
{
|
|
int ret = 0;
|
|
string strTemp = "";
|
|
byte[] readByte;
|
|
|
|
SmartSerialPort.FRAMEDATAREADSTATUS receiveDataState = SmartSerialPort.FRAMEDATAREADSTATUS.EMPTY;
|
|
|
|
receiveDataState = this.smartSerialPortLink.ReadQueue(out readByte);
|
|
strTemp = Encoding.Default.GetString(readByte, 0, readByte.Length);
|
|
|
|
if ((receiveDataState == SmartSerialPort.FRAMEDATAREADSTATUS.EMPTY) || (receiveDataState == SmartSerialPort.FRAMEDATAREADSTATUS.FAILDATA))
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
switch (strTemp[0])
|
|
{
|
|
case 'C':
|
|
if ((ret = this.ReceiveCommandC(strTemp)) != 0)
|
|
return;
|
|
break;
|
|
case 'P':
|
|
if ((ret = this.ReceiveCommandP(strTemp)) != 0)
|
|
return;
|
|
break;
|
|
case 'S':
|
|
if ((ret = this.ReceiveCommandS(strTemp)) != 0)
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private int ReceiveCommandC(string strTemp)
|
|
{
|
|
int ret = 0;
|
|
string cmd = "";
|
|
|
|
if (this.ChksumCheck(strTemp) == false)
|
|
{
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1} : Receive Command Data CHKSUM Error", DateTime.Now, strTemp));
|
|
return ret = -1;
|
|
}
|
|
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, strTemp));
|
|
|
|
cmd = strTemp.Substring(0, 3);
|
|
|
|
switch (cmd)
|
|
{
|
|
case "CI0":
|
|
this.TrasferSystemParameter(this.SystemConfig);
|
|
break;
|
|
case "CBS":
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Start;
|
|
|
|
// 운전시 중량 0 으로 Clear
|
|
foreach (WeightData data in this.CollectionWeightData)
|
|
{
|
|
data.Weight = 0.0;
|
|
}
|
|
|
|
// Ethernet Client 연결 시도
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetOperationMode == 2)
|
|
{
|
|
this.EthernetClientDisconnect();
|
|
this.EthernetClientConnect();
|
|
}
|
|
}
|
|
|
|
this.ChildFormMainDisplay.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
this.ChildFormSystemSetting.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
this.ChildFormEquipmentTest.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
break;
|
|
case "CBT":
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Stop;
|
|
|
|
// 생산속도 Clear
|
|
foreach (WeightData data in this.CollectionWeightData)
|
|
{
|
|
data.ProductionSpeed = 0;
|
|
data.IsStart = false;
|
|
}
|
|
|
|
this.ChildFormMainDisplay.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
this.ChildFormSystemSetting.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
this.ChildFormEquipmentTest.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
break;
|
|
case "CBE":
|
|
break;
|
|
case "CBZ":
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
private int ReceiveCommandP(string strTemp)
|
|
{
|
|
int ret = 0;
|
|
string cmd = "", address = "", lane = "", receiveData = "";
|
|
|
|
// SIZE 확인
|
|
if (this.SizeCheck("P", strTemp) == false)
|
|
{
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1} : Receive Stream Data SIZE Error", DateTime.Now, strTemp));
|
|
return ret = -1;
|
|
}
|
|
// CHKSUM 확인
|
|
if (this.ChksumCheck(strTemp) == false)
|
|
{
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1} : Receive Stream Data CHKSUM Error", DateTime.Now, strTemp));
|
|
return ret = -1;
|
|
}
|
|
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, strTemp));
|
|
|
|
cmd = strTemp.Substring(0, 3);
|
|
lane = strTemp.Substring(5, 1);
|
|
address = strTemp.Substring(10, 4);
|
|
receiveData = strTemp.Substring(14, strTemp.Length - 16);
|
|
|
|
switch (cmd)
|
|
{
|
|
case "PR0":
|
|
if ((ret = this.ReceiveCommandPR0(lane, address, receiveData)) != 0)
|
|
return ret = -1;
|
|
break;
|
|
case "PW0":
|
|
if ((ret = this.ReceiveCommandPW0(lane, address, receiveData)) != 0)
|
|
return ret = -1;
|
|
break;
|
|
case "PB0":
|
|
if ((ret = this.ReceiveCommandPB0(lane, address, receiveData)) != 0)
|
|
return ret = -1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
private int ReceiveCommandS(string strTemp)
|
|
{
|
|
int ret = 0;
|
|
string cmd = "", lane = "", receiveData = "";
|
|
|
|
// SIZE 확인
|
|
if (this.SizeCheck("S", strTemp) == false)
|
|
{
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1} : Receive Stream Data SIZE Error", DateTime.Now, strTemp));
|
|
return ret = -1;
|
|
}
|
|
// CHKSUM 확인
|
|
if (this.ChksumCheck(strTemp) == false)
|
|
{
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1} : Receive Stream Data CHKSUM Error", DateTime.Now, strTemp));
|
|
return ret = -1;
|
|
}
|
|
|
|
// 로그
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, strTemp));
|
|
|
|
cmd = strTemp.Substring(0, 3);
|
|
lane = strTemp.Substring(5, 1);
|
|
receiveData = strTemp.Substring(10, strTemp.Length - 12);
|
|
|
|
switch (cmd)
|
|
{
|
|
case "SA0":
|
|
if ((ret = this.ReceiveCommandSA0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
case "SN0":
|
|
if ((ret = this.ReceiveCommandSN0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
case "SR0":
|
|
if ((ret = this.ReceiveCommandSR0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
case "SC0":
|
|
if ((ret = this.ReceiveCommandSC0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
case "SF0":
|
|
if ((ret = this.ReceiveCommandSF0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
case "SG0":
|
|
if ((ret = this.ReceiveCommandSG0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
case "ST0":
|
|
if ((ret = this.ReceiveCommandST0(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// 파라미터 읽기 응답
|
|
private int ReceiveCommandPR0(string lane, string address, string receiveData)
|
|
{
|
|
int ret = 0, iValue = 0;
|
|
|
|
try
|
|
{
|
|
switch (address)
|
|
{
|
|
case "1500":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns + 1; i++)
|
|
{
|
|
this.CollectionVersion[i] = receiveData.Substring(i * 4, 4);
|
|
}
|
|
this.ChildFormInformation.UpdateProgreamVersionDisplay(this.EquipmentStatus, this.CollectionVersion);
|
|
#endregion
|
|
break;
|
|
case "2001":
|
|
#region Value Assign
|
|
iValue = int.Parse(receiveData);
|
|
if (iValue <= 0 || iValue > 1000)
|
|
return ret = -1;
|
|
|
|
this.SystemConfig.ProductNumber = iValue;
|
|
|
|
#endregion
|
|
|
|
// 최초에 부팅이 완료 되었는지 확인
|
|
if (this.IsBootingComplete == false)
|
|
this.IsBootingComplete = true;
|
|
|
|
this.SaveSystemConfigurationFile(this.SystemConfig);
|
|
|
|
this.LoadProductFile(ref this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
this.LoadCounterFile(ref this.CollectionWeightData, this.SystemConfig.ProductNumber - 1);
|
|
this.LoadJudgmentSetFile(ref this.CurrentJudgmentSetItem, this.SystemConfig.ProductNumber - 1);
|
|
|
|
// 생산속도 Clear
|
|
foreach (WeightData data in this.CollectionWeightData)
|
|
{
|
|
data.ProductionSpeed = 0;
|
|
data.IsStart = false;
|
|
}
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
this.ChildFormMainDisplay.UpdateCurrentProductDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem, this.CollectionWeightData);
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormSystemSetting)
|
|
this.ChildFormSystemSetting.UpdateItemNoDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem);
|
|
break;
|
|
case "3001":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionMaxWeight[i] = receiveData.Substring(i * 7, 7).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateMaxWeightDisplay(this.EquipmentStatus, this.CollectionMaxWeight);
|
|
break;
|
|
case "3002":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionBalanceWeight[i] = receiveData.Substring(i * 7, 7).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateBalanceWeightDisplay(this.EquipmentStatus, this.CollectionBalanceWeight);
|
|
break;
|
|
case "3003":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionDigit[i] = receiveData.Substring(i * 7, 7).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateDigitDisplay(this.EquipmentStatus, this.CollectionDigit);
|
|
break;
|
|
case "3901":
|
|
#region Value Assign
|
|
this.CurrentCalibrationItem.MaxWeight = receiveData.Substring(0, 7).Trim();
|
|
this.CurrentCalibrationItem.BalanceWeight = receiveData.Substring(7, 7).Trim();
|
|
this.CurrentCalibrationItem.Digit = receiveData.Substring(14, 7).Trim();
|
|
|
|
switch (this.SystemConfig.EquipmentColumns)
|
|
{
|
|
case 2:
|
|
this.CurrentCalibrationItem.Constant1 = receiveData.Substring(21, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant2 = receiveData.Substring(28, 7).Trim();
|
|
break;
|
|
case 3:
|
|
this.CurrentCalibrationItem.Constant1 = receiveData.Substring(21, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant2 = receiveData.Substring(28, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant3 = receiveData.Substring(35, 7).Trim();
|
|
break;
|
|
case 4:
|
|
this.CurrentCalibrationItem.Constant1 = receiveData.Substring(21, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant2 = receiveData.Substring(28, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant3 = receiveData.Substring(35, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant4 = receiveData.Substring(42, 7).Trim();
|
|
break;
|
|
case 5:
|
|
this.CurrentCalibrationItem.Constant1 = receiveData.Substring(21, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant2 = receiveData.Substring(28, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant3 = receiveData.Substring(35, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant4 = receiveData.Substring(42, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant5 = receiveData.Substring(49, 7).Trim();
|
|
break;
|
|
case 6:
|
|
this.CurrentCalibrationItem.Constant1 = receiveData.Substring(21, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant2 = receiveData.Substring(28, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant3 = receiveData.Substring(35, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant4 = receiveData.Substring(42, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant5 = receiveData.Substring(49, 7).Trim();
|
|
this.CurrentCalibrationItem.Constant6 = receiveData.Substring(56, 7).Trim();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
#endregion
|
|
this.ChildFormCalibration.UpdateConfiguration(this.EquipmentStatus, this.CurrentCalibrationItem);
|
|
break;
|
|
case "4001":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionZeroParameterTime[i] = receiveData.Substring(i * 4, 4).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateZeroParameterTimeDisplay(this.EquipmentStatus, this.CollectionZeroParameterTime);
|
|
break;
|
|
case "4002":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionZeroParameterRange[i] = receiveData.Substring(i * 4, 4).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateZeroParameterRangeDisplay(this.EquipmentStatus, this.CollectionZeroParameterRange);
|
|
break;
|
|
case "4003":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionZeroParameterVariates[i] = receiveData.Substring(i * 4, 4).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateZeroParameterVariateDisplay(this.EquipmentStatus, this.CollectionZeroParameterVariates);
|
|
break;
|
|
case "4901":
|
|
#region Value Assign
|
|
this.CurrentZeroParameterItem.Time = receiveData.Substring(0, 4).Trim();
|
|
this.CurrentZeroParameterItem.Range = receiveData.Substring(4, 4).Trim();
|
|
this.CurrentZeroParameterItem.Variate = receiveData.Substring(8, 4).Trim();
|
|
this.CurrentZeroParameterItem.Mode = receiveData.Substring(12, 4).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateZeroParameterDisplay(this.EquipmentStatus, this.CurrentZeroParameterItem);
|
|
break;
|
|
case "5001":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionFilter[i] = receiveData.Substring(i * 4, 4).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateFilterDisplay(this.EquipmentStatus, this.CollectionFilter);
|
|
break;
|
|
case "6901":
|
|
#region Value Assign
|
|
this.CurrentOptionParameterItem.BuzzerOnTime = receiveData.Substring(0, 4).Trim();
|
|
this.CurrentOptionParameterItem.RelayOnTime = receiveData.Substring(4, 4).Trim();
|
|
this.CurrentOptionParameterItem.PassAlarm = receiveData.Substring(8, 4).Trim();
|
|
this.CurrentOptionParameterItem.PassAlarmCount = receiveData.Substring(12, 4).Trim();
|
|
this.CurrentOptionParameterItem.DoubleEnter = receiveData.Substring(16, 4).Trim();
|
|
this.CurrentOptionParameterItem.Chattering = receiveData.Substring(20, 4).Trim();
|
|
#endregion
|
|
this.ChildFormConfiguration.UpdateOptionParameterDisplay(this.EquipmentStatus, this.CurrentOptionParameterItem);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 파라미터 쓰기 응답
|
|
private int ReceiveCommandPW0(string lane, string address, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
DataStore.ResponseData response = DataStore.ResponseData.NAK;
|
|
|
|
try
|
|
{
|
|
if (receiveData == "0000")
|
|
response = DataStore.ResponseData.NAK;
|
|
else
|
|
response = DataStore.ResponseData.ACK;
|
|
|
|
switch (address)
|
|
{
|
|
case "9047":
|
|
if (response == DataStore.ResponseData.ACK)
|
|
this.TransferProductParameter(this.SystemConfig.ProductNumber);
|
|
break;
|
|
case "9048":
|
|
if (response == DataStore.ResponseData.ACK)
|
|
this.TransferDataStream(CommunicationCommand.Read, CommunicationID.MainBoard, CommunicationAddress.ProductNumber, "");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// Bypass to motor
|
|
private int ReceiveCommandPB0(string lane, string address, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
DataStore.ResponseData response = DataStore.ResponseData.NAK;
|
|
|
|
try
|
|
{
|
|
if (receiveData == "0000")
|
|
response = DataStore.ResponseData.NAK;
|
|
else
|
|
response = DataStore.ResponseData.ACK;
|
|
|
|
switch (address)
|
|
{
|
|
case "1101":
|
|
break;
|
|
case "1102":
|
|
break;
|
|
case "1103":
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// 정지시 중량
|
|
private int ReceiveCommandSN0(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
try
|
|
{
|
|
switch (lane)
|
|
{
|
|
case "Z":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightData[i].Status = Helper.StringToWeightStatus(receiveData.Substring(i * 12, 2));
|
|
this.CollectionWeightData[i].Weight = Helper.StringToWeight(receiveData.Substring(i * 12 + 2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[i].ADCValue = receiveData.Substring(i * 12 + 7, 5);
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightDataTest[i].Status = Helper.StringToWeightStatus(receiveData.Substring(i * 12, 2));
|
|
this.CollectionWeightDataTest[i].Weight = Helper.StringToWeight(receiveData.Substring(i * 12 + 2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[i].ADCValue = receiveData.Substring(i * 12 + 7, 5);
|
|
}
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.ChildFormMainDisplay.UpdateStopWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateStopWeightDisplay(this.EquipmentStatus, this.CollectionWeightDataTest);
|
|
|
|
if (this.IsAdcLogOpen == true)
|
|
{
|
|
if (this.FlagADCValueWrite == true)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
sb.Append(this.CollectionWeightDataTest[i].ADCValue);
|
|
sb.Append(",");
|
|
}
|
|
|
|
this.smartFileAdcLog.WriteString(string.Format("Receive,{0:yyyy-MM-dd HH:mm:ss},{1}", DateTime.Now, sb.ToString()));
|
|
this.FlagADCValueWrite = false;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 운전시 중량
|
|
private int ReceiveCommandSR0(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
try
|
|
{
|
|
switch (lane)
|
|
{
|
|
case "A":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.CollectionWeightData[0].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightData[0].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[0].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightData[0].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.CollectionWeightDataTest[0].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightDataTest[0].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[0].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightDataTest[0].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData[0], 1);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay1(this.EquipmentStatus, this.CollectionWeightData[0]);
|
|
|
|
// CH3
|
|
if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.SerialCom3Write(this.Protocol_OPT1(1, this.CollectionWeightData[0]));
|
|
else if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.SerialCom3Write(this.Protocol_OPT2(1, this.CollectionWeightData[0]));
|
|
|
|
// Ethernet
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.EthernetWrite(this.Protocol_OPT1(1, this.CollectionWeightData[0]));
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.EthernetWrite(this.Protocol_OPT2(1, this.CollectionWeightData[0]));
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay1(this.EquipmentStatus, this.CollectionWeightDataTest[0]);
|
|
}
|
|
break;
|
|
case "B":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.CollectionWeightData[1].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightData[1].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[1].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightData[1].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.CollectionWeightDataTest[1].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightDataTest[1].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[1].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightDataTest[1].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData[1], 2);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay2(this.EquipmentStatus, this.CollectionWeightData[1]);
|
|
|
|
// CH3
|
|
if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.SerialCom3Write(this.Protocol_OPT1(2, this.CollectionWeightData[1]));
|
|
else if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.SerialCom3Write(this.Protocol_OPT2(2, this.CollectionWeightData[1]));
|
|
|
|
// Ethernet
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.EthernetWrite(this.Protocol_OPT1(2, this.CollectionWeightData[1]));
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.EthernetWrite(this.Protocol_OPT2(2, this.CollectionWeightData[1]));
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay2(this.EquipmentStatus, this.CollectionWeightDataTest[1]);
|
|
}
|
|
break;
|
|
case "C":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.CollectionWeightData[2].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightData[2].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[2].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightData[2].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.CollectionWeightDataTest[2].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightDataTest[2].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[2].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightDataTest[2].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData[2], 3);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay3(this.EquipmentStatus, this.CollectionWeightData[2]);
|
|
|
|
// CH3
|
|
if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.SerialCom3Write(this.Protocol_OPT1(3, this.CollectionWeightData[2]));
|
|
else if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.SerialCom3Write(this.Protocol_OPT2(3, this.CollectionWeightData[2]));
|
|
|
|
// Ethernet
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.EthernetWrite(this.Protocol_OPT1(3, this.CollectionWeightData[2]));
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.EthernetWrite(this.Protocol_OPT2(3, this.CollectionWeightData[2]));
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay3(this.EquipmentStatus, this.CollectionWeightDataTest[2]);
|
|
}
|
|
break;
|
|
case "D":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.CollectionWeightData[3].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightData[3].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[3].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightData[3].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.CollectionWeightDataTest[3].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightDataTest[3].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[3].ADCValue = receiveData.Substring(7, 5);
|
|
this.CollectionWeightDataTest[3].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData[3], 4);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay4(this.EquipmentStatus, this.CollectionWeightData[3]);
|
|
|
|
// CH3
|
|
if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.SerialCom3Write(this.Protocol_OPT1(4, this.CollectionWeightData[3]));
|
|
else if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.SerialCom3Write(this.Protocol_OPT2(4, this.CollectionWeightData[3]));
|
|
|
|
// Ethernet
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.EthernetWrite(this.Protocol_OPT1(4, this.CollectionWeightData[3]));
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.EthernetWrite(this.Protocol_OPT2(4, this.CollectionWeightData[3]));
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay4(this.EquipmentStatus, this.CollectionWeightDataTest[3]);
|
|
}
|
|
break;
|
|
case "E":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.CollectionWeightData[4].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightData[4].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[4].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightData[4].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.CollectionWeightDataTest[4].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightDataTest[4].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[4].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightDataTest[4].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData[4], 5);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay5(this.EquipmentStatus, this.CollectionWeightData[4]);
|
|
|
|
// CH3
|
|
if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.SerialCom3Write(this.Protocol_OPT1(5, this.CollectionWeightData[4]));
|
|
else if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.SerialCom3Write(this.Protocol_OPT2(5, this.CollectionWeightData[4]));
|
|
|
|
// Ethernet
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.EthernetWrite(this.Protocol_OPT1(5, this.CollectionWeightData[4]));
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.EthernetWrite(this.Protocol_OPT2(5, this.CollectionWeightData[4]));
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay5(this.EquipmentStatus, this.CollectionWeightDataTest[4]);
|
|
}
|
|
break;
|
|
case "F":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.CollectionWeightData[5].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightData[5].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[5].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightData[5].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.CollectionWeightDataTest[5].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(0, 2));
|
|
this.CollectionWeightDataTest[5].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[5].WeightString = receiveData.Substring(2, 5);
|
|
this.CollectionWeightDataTest[5].ADCValue = receiveData.Substring(7, 5);
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData[5], 6);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay6(this.EquipmentStatus, this.CollectionWeightData[5]);
|
|
|
|
// CH3
|
|
if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.SerialCom3Write(this.Protocol_OPT1(6, this.CollectionWeightData[5]));
|
|
else if (this.SystemConfig.Serial3Mode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.SerialCom3Write(this.Protocol_OPT2(6, this.CollectionWeightData[5]));
|
|
|
|
// Ethernet
|
|
if (this.SystemConfig.IsEthernetEnable == true)
|
|
{
|
|
if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f1_OPT1) // OPT1
|
|
this.EthernetWrite(this.Protocol_OPT1(6, this.CollectionWeightData[5]));
|
|
else if (this.SystemConfig.EthernetMode == (int)DataStore.CommunicationMode.f2_OPT2) // OPT2
|
|
this.EthernetWrite(this.Protocol_OPT2(6, this.CollectionWeightData[5]));
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay6(this.EquipmentStatus, this.CollectionWeightDataTest[5]);
|
|
}
|
|
break;
|
|
case "Z":
|
|
#region Value Assign
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightData[i].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(i * 12, 2));
|
|
this.CollectionWeightData[i].Weight = Helper.StringToWeight(receiveData.Substring(i * 12 + 2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[i].WeightString = receiveData.Substring(i * 12 + 2, 5);
|
|
this.CollectionWeightData[i].ADCValue = receiveData.Substring(i * 12 + 7, 5);
|
|
}
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightDataTest[i].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(i * 12, 2));
|
|
this.CollectionWeightDataTest[i].Weight = Helper.StringToWeight(receiveData.Substring(i * 12 + 2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightDataTest[i].WeightString = receiveData.Substring(i * 12 + 2, 5);
|
|
this.CollectionWeightDataTest[i].ADCValue = receiveData.Substring(i * 12 + 7, 5);
|
|
}
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
this.DataBackup(this.CollectionWeightData);
|
|
this.ChildFormMainDisplay.UpdateUpdateStartWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
this.ChildFormEquipmentTest.UpdateUpdateStartWeightDisplay(this.EquipmentStatus, this.CollectionWeightDataTest);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 중량조정시 중량
|
|
private int ReceiveCommandSC0(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (lane)
|
|
{
|
|
case "Z":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightData[i].Status = Helper.StringToWeightStatus(receiveData.Substring(i * 12, 2));
|
|
this.CollectionWeightData[i].Weight = Helper.StringToWeight(receiveData.Substring(i * 12 + 2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[i].ADCValue = receiveData.Substring(i * 12 + 7, 5);
|
|
}
|
|
#endregion
|
|
this.ChildFormCalibration.UpdateWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 판정설정시 중량 - 정지
|
|
private int ReceiveCommandSF0(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (lane)
|
|
{
|
|
case "Z":
|
|
#region Value Assign
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightData[i].Status = Helper.StringToWeightStatus(receiveData.Substring(i * 12, 2));
|
|
this.CollectionWeightData[i].Weight = Helper.StringToWeight(receiveData.Substring(i * 12 + 2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[i].ADCValue = receiveData.Substring(i * 12 + 7, 5);
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateStopWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 판정설정 그래프
|
|
private int ReceiveCommandSG0(string lane, string receiveData)
|
|
{
|
|
int ret = 0, temp = 12;
|
|
|
|
switch (lane)
|
|
{
|
|
case "A":
|
|
#region Value Assign
|
|
this.CollectionWeightData[0].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[0].ADCValue = receiveData.Substring(7, 5);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 5));
|
|
temp += 5;
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[0], this.CollectionGraphData);
|
|
break;
|
|
case "B":
|
|
#region Value Assign
|
|
this.CollectionWeightData[1].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[1].ADCValue = receiveData.Substring(7, 5);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 5));
|
|
temp += 5;
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[1], this.CollectionGraphData);
|
|
break;
|
|
case "C":
|
|
#region Value Assign
|
|
this.CollectionWeightData[2].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[2].ADCValue = receiveData.Substring(7, 5);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 5));
|
|
temp += 5;
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[2], this.CollectionGraphData);
|
|
break;
|
|
case "D":
|
|
#region Value Assign
|
|
this.CollectionWeightData[3].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[3].ADCValue = receiveData.Substring(7, 5);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 5));
|
|
temp += 5;
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[3], this.CollectionGraphData);
|
|
break;
|
|
case "E":
|
|
#region Value Assign
|
|
this.CollectionWeightData[4].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[4].ADCValue = receiveData.Substring(7, 5);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 5));
|
|
temp += 5;
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[4], this.CollectionGraphData);
|
|
break;
|
|
case "F":
|
|
#region Value Assign
|
|
this.CollectionWeightData[5].Weight = Helper.StringToWeight(receiveData.Substring(2, 5), this.SystemConfig.DecimalPlaces);
|
|
this.CollectionWeightData[5].ADCValue = receiveData.Substring(7, 5);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 5));
|
|
temp += 5;
|
|
}
|
|
#endregion
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[5], this.CollectionGraphData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// IO테스트-IN
|
|
private int ReceiveCommandST0(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (lane)
|
|
{
|
|
case "0":
|
|
#region Value Assign
|
|
for (int i = 0; i < 16; i++)
|
|
this.CollectionIOTest_InputData[i] = receiveData.Substring(i, 1);
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormIOTest)
|
|
this.ChildFormIOTest.UpdateInputRead(this.CollectionIOTest_InputData);
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
this.ChildFormEquipmentTest.UpdateInputRead(this.CollectionIOTest_InputData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 알람
|
|
private int ReceiveCommandSA0(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (lane)
|
|
{
|
|
case "0":
|
|
#region Value Assign
|
|
this.CurrentAlarmList.SetAlarm(receiveData.Substring(0, 8));
|
|
#endregion
|
|
|
|
this.ChildFormMainDisplay.UpdateDisplayAlarmView(this.CurrentAlarmList);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endregion
|
|
|
|
#region SystemConfiguration File
|
|
private void CreateSystemConfigurationFile()
|
|
{
|
|
StructSystemConfigurationItem structItem;
|
|
|
|
this.SystemConfig.Initialization();
|
|
|
|
structItem.IsDataBackup = this.SystemConfig.IsDataBackup;
|
|
structItem.DummyBool5 = false;
|
|
structItem.DummyBool6 = false;
|
|
structItem.DummyBool7 = false;
|
|
structItem.DummyBool8 = false;
|
|
structItem.DummyBool9 = false;
|
|
structItem.IsLogin = this.SystemConfig.IsLogin;
|
|
structItem.IsWeightViewForward = this.SystemConfig.IsWeightViewForward;
|
|
structItem.DecimalPlaces = this.SystemConfig.DecimalPlaces;
|
|
structItem.InverterQTY = this.SystemConfig.InverterQTY;
|
|
structItem.EquipmentColumns = this.SystemConfig.EquipmentColumns;
|
|
structItem.EquipmentID = this.SystemConfig.EquipmentID;
|
|
structItem.EquipmentMode = this.SystemConfig.EquipmentMode;
|
|
structItem.ProductNumber = this.SystemConfig.ProductNumber;
|
|
structItem.EthernetLocalPort = this.SystemConfig.EthernetLocalPort;
|
|
structItem.EthernetServerPort = this.SystemConfig.EthernetServerPort;
|
|
structItem.UsbID = this.SystemConfig.UsbID;
|
|
structItem.DummyString6 = "";
|
|
structItem.Unit = this.SystemConfig.Unit;
|
|
structItem.Language = this.SystemConfig.Language;
|
|
structItem.EthernetMode = this.SystemConfig.EthernetMode;
|
|
structItem.EthernetOperationMode = this.SystemConfig.EthernetOperationMode;
|
|
structItem.SerialNumber = this.SystemConfig.SerialNumber;
|
|
structItem.Serial3BaudRate = this.SystemConfig.Serial3BaudRate;
|
|
structItem.Serial3Mode = this.SystemConfig.Serial3Mode;
|
|
|
|
structItem.DummyBool1 = false;
|
|
structItem.DummyBool2 = false;
|
|
structItem.DummyBool3 = false;
|
|
structItem.DummyBool4 = false;
|
|
structItem.DummyInt1 = 0;
|
|
structItem.DummyInt2 = 0;
|
|
structItem.DummyInt8 = 0;
|
|
|
|
structItem.EthernetServerAddress = this.SystemConfig.EthernetServerAddress;
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
|
|
this.smartFileIO.WriteStructure(structItem, 0);
|
|
}
|
|
public void SaveSystemConfigurationFile(SystemConfigurationItem item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructSystemConfigurationItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "system.cfg";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateSystemConfigurationFile();
|
|
}
|
|
|
|
structItem.IsDataBackup = item.IsDataBackup;
|
|
structItem.DummyBool5 = false;
|
|
structItem.DummyBool6 = false;
|
|
structItem.DummyBool7 = false;
|
|
structItem.DummyBool8 = false;
|
|
structItem.DummyBool9 = false;
|
|
structItem.IsLogin = item.IsLogin;
|
|
structItem.IsWeightViewForward = item.IsWeightViewForward;
|
|
structItem.DecimalPlaces = item.DecimalPlaces;
|
|
structItem.InverterQTY = item.InverterQTY;
|
|
structItem.EquipmentColumns = item.EquipmentColumns;
|
|
structItem.EquipmentID = item.EquipmentID;
|
|
structItem.EquipmentMode = item.EquipmentMode;
|
|
structItem.ProductNumber = item.ProductNumber;
|
|
structItem.EthernetLocalPort = item.EthernetLocalPort;
|
|
structItem.EthernetServerPort = item.EthernetServerPort;
|
|
structItem.UsbID = item.UsbID;
|
|
structItem.DummyString6 = "";
|
|
structItem.Unit = item.Unit;
|
|
structItem.Language = item.Language;
|
|
structItem.EthernetMode = item.EthernetMode;
|
|
structItem.EthernetOperationMode = item.EthernetOperationMode;
|
|
structItem.SerialNumber = item.SerialNumber;
|
|
structItem.Serial3BaudRate = item.Serial3BaudRate;
|
|
structItem.Serial3Mode = item.Serial3Mode;
|
|
|
|
structItem.DummyBool1 = false;
|
|
structItem.DummyBool2 = false;
|
|
structItem.DummyBool3 = false;
|
|
structItem.DummyBool4 = false;
|
|
structItem.DummyInt1 = 0;
|
|
structItem.DummyInt2 = 0;
|
|
structItem.DummyInt8 = 0;
|
|
|
|
structItem.EthernetServerAddress = item.EthernetServerAddress;
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
|
|
this.smartFileIO.WriteStructure(structItem, 0);
|
|
this.smartFileIO.Close();
|
|
}
|
|
private void LoadSystemConfigurationFile()
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false, save = false;
|
|
StructSystemConfigurationItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "system.cfg";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateSystemConfigurationFile();
|
|
}
|
|
|
|
try
|
|
{
|
|
structItem = (StructSystemConfigurationItem)this.smartFileIO.ReadStructure(0, typeof(StructSystemConfigurationItem));
|
|
|
|
this.SystemConfig.IsDataBackup = structItem.IsDataBackup;
|
|
this.SystemConfig.IsWeightViewForward = structItem.IsWeightViewForward;
|
|
this.SystemConfig.DecimalPlaces = structItem.DecimalPlaces;
|
|
this.SystemConfig.EquipmentColumns = structItem.EquipmentColumns;
|
|
this.SystemConfig.EquipmentID = structItem.EquipmentID;
|
|
this.SystemConfig.EquipmentMode = structItem.EquipmentMode;
|
|
this.SystemConfig.ProductNumber = structItem.ProductNumber;
|
|
this.SystemConfig.UsbID = structItem.UsbID;
|
|
this.SystemConfig.Unit = structItem.Unit;
|
|
this.SystemConfig.Language = structItem.Language;
|
|
this.SystemConfig.SerialNumber = structItem.SerialNumber;
|
|
this.SystemConfig.Serial3BaudRate = structItem.Serial3BaudRate;
|
|
this.SystemConfig.Serial3Mode = structItem.Serial3Mode;
|
|
this.SystemConfig.IsLogin = structItem.IsLogin;
|
|
|
|
if (structItem.InverterQTY < 1 || structItem.InverterQTY > 4)
|
|
{
|
|
save = true;
|
|
this.SystemConfig.InverterQTY = 2;
|
|
}
|
|
else
|
|
this.SystemConfig.InverterQTY = structItem.InverterQTY;
|
|
|
|
if (structItem.EthernetLocalPort == 0)
|
|
{
|
|
save = true;
|
|
this.SystemConfig.EthernetLocalPort = 5001;
|
|
this.SystemConfig.EthernetServerPort = 5002;
|
|
this.SystemConfig.EthernetMode = 0;
|
|
this.SystemConfig.EthernetOperationMode = 0;
|
|
this.SystemConfig.EthernetServerAddress = "0.0.0.0";
|
|
}
|
|
else
|
|
{
|
|
this.SystemConfig.EthernetLocalPort = structItem.EthernetLocalPort;
|
|
this.SystemConfig.EthernetServerPort = structItem.EthernetServerPort;
|
|
this.SystemConfig.EthernetMode = structItem.EthernetMode;
|
|
this.SystemConfig.EthernetOperationMode = structItem.EthernetOperationMode;
|
|
this.SystemConfig.EthernetServerAddress = structItem.EthernetServerAddress;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language, "");
|
|
myMsg.Location = new Point(167, 207);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
|
|
this.smartFileIO.Close();
|
|
|
|
if (save == true)
|
|
this.SaveSystemConfigurationFile(this.SystemConfig);
|
|
}
|
|
#endregion
|
|
|
|
#region ProductItem File
|
|
private void CreateProductFile()
|
|
{
|
|
StructProductItem structItem;
|
|
|
|
this.CurrentProductItem.Initialization();
|
|
|
|
for (int i = 0; i < 1000; i++)
|
|
{
|
|
structItem.Number = i + 1;
|
|
structItem.Name = string.Format("Product {0}", i + 1);
|
|
structItem.LotNo = string.Format("Lot {0}", i + 1);
|
|
structItem.OverRange = this.CurrentProductItem.OverRange;
|
|
structItem.PassRange = this.CurrentProductItem.PassRange;
|
|
structItem.UnderRange = this.CurrentProductItem.UnderRange;
|
|
structItem.TareRange = this.CurrentProductItem.TareRange;
|
|
structItem.DummyString1 = "";
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
structItem.DummyString6 = "";
|
|
structItem.DummyString7 = "";
|
|
structItem.DummyString8 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveProductFile(ProductItem item, int index)
|
|
{
|
|
bool fileCheck = false;
|
|
string fullFilePath = "";
|
|
StructProductItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "ProductItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
this.CreateProductFile();
|
|
}
|
|
|
|
structItem.Number = item.Number;
|
|
structItem.Name = item.Name;
|
|
structItem.LotNo = item.LotNo;
|
|
structItem.OverRange = item.OverRange;
|
|
structItem.PassRange = item.PassRange;
|
|
structItem.UnderRange = item.UnderRange;
|
|
structItem.TareRange = item.TareRange;
|
|
structItem.DummyString1 = "";
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
structItem.DummyString6 = "";
|
|
structItem.DummyString7 = "";
|
|
structItem.DummyString8 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, index);
|
|
this.smartFileIO.WriteStructure_End();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadProductFile(ref ProductItem item, int index)
|
|
{
|
|
bool fileCheck = false;
|
|
string fullFilePath = "";
|
|
StructProductItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "ProductItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateProductFile();
|
|
}
|
|
|
|
try
|
|
{
|
|
structItem = (StructProductItem)this.smartFileIO.ReadStructure(index, typeof(StructProductItem));
|
|
|
|
item.Number = structItem.Number;
|
|
item.Name = structItem.Name;
|
|
item.LotNo = structItem.LotNo;
|
|
item.OverRange = structItem.OverRange;
|
|
item.PassRange = structItem.PassRange;
|
|
item.UnderRange = structItem.UnderRange;
|
|
item.TareRange = structItem.TareRange;
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language, "");
|
|
myMsg.Location = new Point(167, 207);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadProductName(ref Collection<string> values)
|
|
{
|
|
string fullFilePath = "";
|
|
StructProductItem structItem;
|
|
|
|
values.Clear();
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "ProductItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
if (this.smartFileIO.ReadStructureAllBuffer() == true)
|
|
{
|
|
for (int i = 0; i < 1000; i++)
|
|
{
|
|
structItem = (StructProductItem)this.smartFileIO.ReadStructureBuffer(typeof(StructProductItem), i);
|
|
|
|
values.Add(structItem.Name);
|
|
}
|
|
}
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region JudgmentSetItem File
|
|
private void CreateJudgmentSetFile()
|
|
{
|
|
StructJudgmentSetItem structItem;
|
|
|
|
this.CurrentJudgmentSetItem.Initialization();
|
|
|
|
for (int i = 0; i < 1000; i++)
|
|
{
|
|
structItem.Filter = this.CurrentJudgmentSetItem.Filter;
|
|
structItem.JudgmentDelayTime = this.CurrentJudgmentSetItem.JudgmentDelayTime;
|
|
structItem.DoubleDelayTime = this.CurrentJudgmentSetItem.DoubleDelayTime;
|
|
structItem.JudgmentCount = this.CurrentJudgmentSetItem.JudgmentCount;
|
|
structItem.ConveyorSpeed1 = this.CurrentJudgmentSetItem.ConveyorSpeed1;
|
|
structItem.DynamicCorrection = this.CurrentJudgmentSetItem.DynamicCorrection;
|
|
structItem.DummyInt1 = 0;
|
|
structItem.DummyInt2 = 0;
|
|
structItem.DummyInt3 = 0;
|
|
structItem.DummyInt4 = 0;
|
|
structItem.Sorter1Mode = this.CurrentJudgmentSetItem.Sorter1Mode;
|
|
structItem.Sorter1DelayTime = this.CurrentJudgmentSetItem.Sorter1DelayTime;
|
|
structItem.Sorter1OperatingTime = this.CurrentJudgmentSetItem.Sorter1RunTime;
|
|
structItem.DummyInt5 = 0;
|
|
structItem.DummyInt6 = 0;
|
|
structItem.DummyInt7 = 0;
|
|
structItem.DummyInt8 = 0;
|
|
structItem.DummyInt9 = 0;
|
|
structItem.DummyInt10 = 0;
|
|
structItem.DummyInt11 = 0;
|
|
structItem.DummyInt12 = 0;
|
|
structItem.DummyInt13 = 0;
|
|
structItem.ConveyorSpeed4 = this.CurrentJudgmentSetItem.ConveyorSpeed4;
|
|
structItem.ConveyorSpeed3 = this.CurrentJudgmentSetItem.ConveyorSpeed3;
|
|
structItem.ConveyorSpeed2 = this.CurrentJudgmentSetItem.ConveyorSpeed2;
|
|
structItem.DummyInt14 = 0;
|
|
structItem.DummyInt15 = 0;
|
|
structItem.DummyString1 = "";
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveJudgmentSetFile(JudgmentSetItem item, int index)
|
|
{
|
|
bool fileCheck = false;
|
|
string fullFilePath = "";
|
|
StructJudgmentSetItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "JudgmentSetItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
this.CreateJudgmentSetFile();
|
|
}
|
|
|
|
structItem.Filter = item.Filter;
|
|
structItem.JudgmentDelayTime = item.JudgmentDelayTime;
|
|
structItem.DoubleDelayTime = item.DoubleDelayTime;
|
|
structItem.JudgmentCount = item.JudgmentCount;
|
|
structItem.ConveyorSpeed1 = item.ConveyorSpeed1;
|
|
structItem.DynamicCorrection = item.DynamicCorrection;
|
|
structItem.DummyInt1 = 0;
|
|
structItem.DummyInt2 = 0;
|
|
structItem.DummyInt3 = 0;
|
|
structItem.DummyInt4 = 0;
|
|
structItem.Sorter1Mode = item.Sorter1Mode;
|
|
structItem.Sorter1DelayTime = item.Sorter1DelayTime;
|
|
structItem.Sorter1OperatingTime = item.Sorter1RunTime;
|
|
structItem.DummyInt5 = 0;
|
|
structItem.DummyInt6 = 0;
|
|
structItem.DummyInt7 = 0;
|
|
structItem.DummyInt8 = 0;
|
|
structItem.DummyInt9 = 0;
|
|
structItem.DummyInt10 = 0;
|
|
structItem.DummyInt11 = 0;
|
|
structItem.DummyInt12 = 0;
|
|
structItem.DummyInt13 = 0;
|
|
structItem.ConveyorSpeed4 = item.ConveyorSpeed4;
|
|
structItem.ConveyorSpeed3 = item.ConveyorSpeed3;
|
|
structItem.ConveyorSpeed2 = item.ConveyorSpeed2;
|
|
structItem.DummyInt14 = 0;
|
|
structItem.DummyInt15 = 0;
|
|
structItem.DummyString1 = "";
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, index);
|
|
this.smartFileIO.WriteStructure_End();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadJudgmentSetFile(ref JudgmentSetItem item, int index)
|
|
{
|
|
bool fileCheck = false, save = false;
|
|
string fullFilePath = "";
|
|
StructJudgmentSetItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "JudgmentSetItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
this.CreateJudgmentSetFile();
|
|
}
|
|
|
|
try
|
|
{
|
|
structItem = (StructJudgmentSetItem)this.smartFileIO.ReadStructure(index, typeof(StructJudgmentSetItem));
|
|
|
|
item.Filter = structItem.Filter;
|
|
item.JudgmentDelayTime = structItem.JudgmentDelayTime;
|
|
item.DoubleDelayTime = structItem.DoubleDelayTime;
|
|
item.JudgmentCount = structItem.JudgmentCount;
|
|
item.ConveyorSpeed1 = structItem.ConveyorSpeed1;
|
|
item.DynamicCorrection = structItem.DynamicCorrection;
|
|
item.Sorter1Mode = structItem.Sorter1Mode;
|
|
item.Sorter1DelayTime = structItem.Sorter1DelayTime;
|
|
item.Sorter1RunTime = structItem.Sorter1OperatingTime;
|
|
|
|
if (structItem.ConveyorSpeed2 == 0)
|
|
{
|
|
save = true;
|
|
item.ConveyorSpeed2 = 60;
|
|
item.ConveyorSpeed3 = 60;
|
|
item.ConveyorSpeed4 = 60;
|
|
}
|
|
else
|
|
{
|
|
item.ConveyorSpeed2 = structItem.ConveyorSpeed2;
|
|
item.ConveyorSpeed3 = structItem.ConveyorSpeed3;
|
|
item.ConveyorSpeed4 = structItem.ConveyorSpeed4;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language, "");
|
|
myMsg.Location = new Point(167, 207);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
|
|
if (save == true)
|
|
this.SaveJudgmentSetFile(item, index);
|
|
}
|
|
#endregion
|
|
|
|
#region Counter File
|
|
private void CreateCounterFile()
|
|
{
|
|
StructCounter structItem;
|
|
|
|
for (int i = 0; i < 1000; i++)
|
|
{
|
|
structItem.OverCount1 = 0;
|
|
structItem.PassCount1 = 0;
|
|
structItem.UnderCount1 = 0;
|
|
structItem.ExNGCount1 = 0;
|
|
|
|
structItem.OverCount2 = 0;
|
|
structItem.PassCount2 = 0;
|
|
structItem.UnderCount2 = 0;
|
|
structItem.ExNGCount2 = 0;
|
|
|
|
structItem.OverCount3 = 0;
|
|
structItem.PassCount3 = 0;
|
|
structItem.UnderCount3 = 0;
|
|
structItem.ExNGCount3 = 0;
|
|
|
|
structItem.OverCount4 = 0;
|
|
structItem.PassCount4 = 0;
|
|
structItem.UnderCount4 = 0;
|
|
structItem.ExNGCount4 = 0;
|
|
|
|
structItem.OverCount5 = 0;
|
|
structItem.PassCount5 = 0;
|
|
structItem.UnderCount5 = 0;
|
|
structItem.ExNGCount5 = 0;
|
|
|
|
structItem.OverCount6 = 0;
|
|
structItem.PassCount6 = 0;
|
|
structItem.UnderCount6 = 0;
|
|
structItem.ExNGCount6 = 0;
|
|
|
|
structItem.DummyInt1 = 0;
|
|
structItem.DummyInt2 = 0;
|
|
structItem.DummyInt3 = 0;
|
|
structItem.DummyInt4 = 0;
|
|
structItem.DummyInt5 = 0;
|
|
structItem.DummyInt6 = 0;
|
|
structItem.DummyInt7 = 0;
|
|
structItem.DummyInt8 = 0;
|
|
structItem.DummyInt9 = 0;
|
|
structItem.DummyInt10 = 0;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveCounterFile(Collection<WeightData> items, int index)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructCounter structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "counterItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateCounterFile();
|
|
}
|
|
|
|
structItem.OverCount1 = items[0].OverCount;
|
|
structItem.PassCount1 = items[0].PassCount;
|
|
structItem.UnderCount1 = items[0].UnderCount;
|
|
structItem.ExNGCount1 = items[0].ExNGCount;
|
|
|
|
structItem.OverCount2 = items[1].OverCount;
|
|
structItem.PassCount2 = items[1].PassCount;
|
|
structItem.UnderCount2 = items[1].UnderCount;
|
|
structItem.ExNGCount2 = items[1].ExNGCount;
|
|
|
|
structItem.OverCount3 = items[2].OverCount;
|
|
structItem.PassCount3 = items[2].PassCount;
|
|
structItem.UnderCount3 = items[2].UnderCount;
|
|
structItem.ExNGCount3 = items[2].ExNGCount;
|
|
|
|
structItem.OverCount4 = items[3].OverCount;
|
|
structItem.PassCount4 = items[3].PassCount;
|
|
structItem.UnderCount4 = items[3].UnderCount;
|
|
structItem.ExNGCount4 = items[3].ExNGCount;
|
|
|
|
structItem.OverCount5 = items[4].OverCount;
|
|
structItem.PassCount5 = items[4].PassCount;
|
|
structItem.UnderCount5 = items[4].UnderCount;
|
|
structItem.ExNGCount5 = items[4].ExNGCount;
|
|
|
|
structItem.OverCount6 = items[5].OverCount;
|
|
structItem.PassCount6 = items[5].PassCount;
|
|
structItem.UnderCount6 = items[5].UnderCount;
|
|
structItem.ExNGCount6 = items[5].ExNGCount;
|
|
|
|
structItem.DummyInt1 = 0;
|
|
structItem.DummyInt2 = 0;
|
|
structItem.DummyInt3 = 0;
|
|
structItem.DummyInt4 = 0;
|
|
structItem.DummyInt5 = 0;
|
|
structItem.DummyInt6 = 0;
|
|
structItem.DummyInt7 = 0;
|
|
structItem.DummyInt8 = 0;
|
|
structItem.DummyInt9 = 0;
|
|
structItem.DummyInt10 = 0;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, index);
|
|
this.smartFileIO.WriteStructure_End();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadCounterFile(ref Collection<WeightData> items, int index)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructCounter structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder2 + "counterItem.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateCounterFile();
|
|
}
|
|
|
|
try
|
|
{
|
|
structItem = (StructCounter)this.smartFileIO.ReadStructure(index, typeof(StructCounter));
|
|
|
|
items[0].UnderCount = structItem.UnderCount1;
|
|
items[0].PassCount = structItem.PassCount1;
|
|
items[0].OverCount = structItem.OverCount1;
|
|
items[0].ExNGCount = structItem.ExNGCount1;
|
|
|
|
items[1].UnderCount = structItem.UnderCount2;
|
|
items[1].PassCount = structItem.PassCount2;
|
|
items[1].OverCount = structItem.OverCount2;
|
|
items[1].ExNGCount = structItem.ExNGCount2;
|
|
|
|
items[2].UnderCount = structItem.UnderCount3;
|
|
items[2].PassCount = structItem.PassCount3;
|
|
items[2].OverCount = structItem.OverCount3;
|
|
items[2].ExNGCount = structItem.ExNGCount3;
|
|
|
|
items[3].UnderCount = structItem.UnderCount4;
|
|
items[3].PassCount = structItem.PassCount4;
|
|
items[3].OverCount = structItem.OverCount4;
|
|
items[3].ExNGCount = structItem.ExNGCount4;
|
|
|
|
items[4].UnderCount = structItem.UnderCount5;
|
|
items[4].PassCount = structItem.PassCount5;
|
|
items[4].OverCount = structItem.OverCount5;
|
|
items[4].ExNGCount = structItem.ExNGCount5;
|
|
|
|
items[5].UnderCount = structItem.UnderCount6;
|
|
items[5].PassCount = structItem.PassCount6;
|
|
items[5].OverCount = structItem.OverCount6;
|
|
items[5].ExNGCount = structItem.ExNGCount6;
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language, "");
|
|
myMsg.Location = new Point(167, 207);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region UserLevel1File
|
|
private void CreateUserLevel1File()
|
|
{
|
|
StructUserItem structItem;
|
|
User item = new User();
|
|
|
|
structItem.ID = "L1";
|
|
structItem.Password = "1111";
|
|
structItem.Group = DataStore.UserGroup.Level1Operator;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 0);
|
|
|
|
for (int i = 1; i < 5; i++)
|
|
{
|
|
structItem.ID = item.ID;
|
|
structItem.Password = item.Password;
|
|
structItem.Group = item.Group;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveUserLevel1File(Collection<User> item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "UserLevel1.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateUserLevel1File();
|
|
}
|
|
|
|
if (item.Count == 0)
|
|
return;
|
|
|
|
for (int i = 0; i < item.Count; i++)
|
|
{
|
|
structItem.ID = item[i].ID;
|
|
structItem.Password = item[i].Password;
|
|
structItem.Group = item[i].Group;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteString_End();
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadUserLevel1File(Collection<User> item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "UserLevel1.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateUserLevel1File();
|
|
}
|
|
|
|
try
|
|
{
|
|
for (int i = 0; i < item.Count; i++)
|
|
{
|
|
structItem = (StructUserItem)this.smartFileIO.ReadStructure(i, typeof(StructUserItem));
|
|
|
|
item[i].ID = structItem.ID;
|
|
item[i].Password = structItem.Password;
|
|
item[i].Group = structItem.Group;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(31, this.SystemConfig.Language, "");
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
#region UserLevel2File
|
|
private void CreateUserLevel2File()
|
|
{
|
|
StructUserItem structItem;
|
|
User item = new User();
|
|
|
|
structItem.ID = "L2";
|
|
structItem.Password = "2222";
|
|
structItem.Group = DataStore.UserGroup.Level2Engineer;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 0);
|
|
|
|
for (int i = 1; i < 5; i++)
|
|
{
|
|
structItem.ID = item.ID;
|
|
structItem.Password = item.Password;
|
|
structItem.Group = item.Group;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveUserLevel2File(Collection<User> item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "UserLevel2.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateUserLevel2File();
|
|
}
|
|
|
|
if (item.Count == 0)
|
|
return;
|
|
|
|
for (int i = 0; i < item.Count; i++)
|
|
{
|
|
structItem.ID = item[i].ID;
|
|
structItem.Password = item[i].Password;
|
|
structItem.Group = item[i].Group;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteString_End();
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadUserLevel2File(Collection<User> item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "UserLevel2.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateUserLevel2File();
|
|
}
|
|
|
|
try
|
|
{
|
|
for (int i = 0; i < item.Count; i++)
|
|
{
|
|
structItem = (StructUserItem)this.smartFileIO.ReadStructure(i, typeof(StructUserItem));
|
|
|
|
item[i].ID = structItem.ID;
|
|
item[i].Password = structItem.Password;
|
|
item[i].Group = structItem.Group;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(31, this.SystemConfig.Language, "");
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
#region UserLevel3File
|
|
private void CreateUserLevel3File()
|
|
{
|
|
StructUserItem structItem;
|
|
User item = new User();
|
|
|
|
structItem.ID = "L3";
|
|
structItem.Password = "3333";
|
|
structItem.Group = DataStore.UserGroup.Level3Manager;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 0);
|
|
|
|
for (int i = 1; i < 5; i++)
|
|
{
|
|
structItem.ID = item.ID;
|
|
structItem.Password = item.Password;
|
|
structItem.Group = item.Group;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveUserLevel3File(Collection<User> item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "UserLevel3.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateUserLevel3File();
|
|
}
|
|
|
|
if (item.Count == 0)
|
|
return;
|
|
|
|
for (int i = 0; i < item.Count; i++)
|
|
{
|
|
structItem.ID = item[i].ID;
|
|
structItem.Password = item[i].Password;
|
|
structItem.Group = item[i].Group;
|
|
|
|
structItem.Dummy1 = "";
|
|
structItem.Dummy2 = "";
|
|
structItem.Dummy3 = "";
|
|
structItem.Dummy4 = "";
|
|
structItem.Dummy5 = "";
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, i);
|
|
}
|
|
this.smartFileIO.WriteString_End();
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadUserLevel3File(Collection<User> item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder1 + "UserLevel3.int";
|
|
this.smartFileIO.FilePathName = fullFilePath;
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
if (fileCheck == true)
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
else
|
|
{
|
|
this.smartFileIO.Open(this.BufferSmartUart);
|
|
|
|
this.CreateUserLevel3File();
|
|
}
|
|
|
|
try
|
|
{
|
|
for (int i = 0; i < item.Count; i++)
|
|
{
|
|
structItem = (StructUserItem)this.smartFileIO.ReadStructure(i, typeof(StructUserItem));
|
|
|
|
item[i].ID = structItem.ID;
|
|
item[i].Password = structItem.Password;
|
|
item[i].Group = structItem.Group;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(31, this.SystemConfig.Language, "");
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region Data Backup
|
|
private void WriteUsingStreamWriter(WeightData item, string fullFilePath)
|
|
{
|
|
StreamWriter sw;
|
|
|
|
sw = new StreamWriter(fullFilePath, true, Encoding.Default);
|
|
|
|
sw.Write(string.Format("{0:yyyy-MM-dd}", DateTime.Now));
|
|
sw.Write(",");
|
|
sw.Write(string.Format("{0:HH:mm:ss}", DateTime.Now));
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.Number);
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.Name);
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.LotNo);
|
|
sw.Write(",");
|
|
sw.Write(Helper.DoubleToString(item.Weight, this.SystemConfig.DecimalPlaces));
|
|
sw.Write(",");
|
|
sw.Write(item.JudgmentStatus);
|
|
sw.WriteLine();
|
|
|
|
sw.Close();
|
|
}
|
|
|
|
private void DataBackup(Collection<WeightData> items)
|
|
{
|
|
bool fileCheck = false, directoryCheck = false;
|
|
string fullFilePath = "";
|
|
StreamWriter sw;
|
|
|
|
this.RemoveUsbBackupFile();
|
|
|
|
if (this.SystemConfig.IsDataBackup == true)
|
|
{
|
|
fullFilePath = string.Format("{0}{1:yyyyMMdd}_{2}.csv", this.PathDataBackupFolder, DateTime.Now, this.SystemConfig.UsbID);
|
|
|
|
DirectoryInfo di = new DirectoryInfo(this.PathDataBackupFolder);
|
|
directoryCheck = di.Exists;
|
|
// 폴더 체크
|
|
if (directoryCheck == false)
|
|
di.Create();
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
sw = new StreamWriter(fullFilePath, true, Encoding.UTF8);
|
|
|
|
if (fileCheck == false)
|
|
{
|
|
sw.Write("Date");
|
|
sw.Write(",");
|
|
sw.Write("Time");
|
|
sw.Write(",");
|
|
sw.Write("P_No");
|
|
sw.Write(",");
|
|
sw.Write("Name");
|
|
sw.Write(",");
|
|
sw.Write("Lot");
|
|
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
sw.Write(",");
|
|
sw.Write(string.Format("#{0}_Weight", i + 1));
|
|
sw.Write(",");
|
|
sw.Write("Grade");
|
|
}
|
|
|
|
sw.WriteLine();
|
|
}
|
|
|
|
sw.Write(string.Format("{0:yyyy-MM-dd}", DateTime.Now));
|
|
sw.Write(",");
|
|
sw.Write(string.Format("{0:HH:mm:ss}", DateTime.Now));
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.Number);
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.Name);
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.LotNo);
|
|
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
sw.Write(",");
|
|
sw.Write(Helper.DoubleToString(items[i].Weight, this.SystemConfig.DecimalPlaces));
|
|
sw.Write(",");
|
|
sw.Write(items[i].JudgmentStatus);
|
|
}
|
|
sw.WriteLine();
|
|
sw.Close();
|
|
}
|
|
}
|
|
private void DataBackup(WeightData item, int line)
|
|
{
|
|
bool fileCheck = false, directoryCheck = false;
|
|
string fullFilePath = "";
|
|
StreamWriter sw;
|
|
|
|
this.RemoveUsbBackupFile();
|
|
|
|
if (this.SystemConfig.IsDataBackup == true)
|
|
{
|
|
fullFilePath = string.Format("{0}{1:yyyyMMdd}_{2}_{3}Lane.csv", this.PathDataBackupFolder, DateTime.Now, this.SystemConfig.UsbID, line);
|
|
|
|
DirectoryInfo di = new DirectoryInfo(this.PathDataBackupFolder);
|
|
directoryCheck = di.Exists;
|
|
// 폴더 체크
|
|
if (directoryCheck == false)
|
|
di.Create();
|
|
|
|
FileInfo fileInfo = new FileInfo(fullFilePath);
|
|
fileCheck = fileInfo.Exists;
|
|
|
|
sw = new StreamWriter(fullFilePath, true, Encoding.UTF8);
|
|
|
|
if (fileCheck == false)
|
|
{
|
|
sw.Write("Date");
|
|
sw.Write(",");
|
|
sw.Write("Time");
|
|
sw.Write(",");
|
|
sw.Write("P_No");
|
|
sw.Write(",");
|
|
sw.Write("Name");
|
|
sw.Write(",");
|
|
sw.Write("Lot");
|
|
sw.Write(",");
|
|
sw.Write("Weight");
|
|
sw.Write(",");
|
|
sw.Write("Grade");
|
|
|
|
sw.WriteLine();
|
|
}
|
|
|
|
sw.Write(string.Format("{0:yyyy-MM-dd}", DateTime.Now));
|
|
sw.Write(",");
|
|
sw.Write(string.Format("{0:HH:mm:ss}", DateTime.Now));
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.Number);
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.Name);
|
|
sw.Write(",");
|
|
sw.Write(this.CurrentProductItem.LotNo);
|
|
sw.Write(",");
|
|
sw.Write(Helper.DoubleToString(item.Weight, this.SystemConfig.DecimalPlaces));
|
|
sw.Write(",");
|
|
sw.Write(item.JudgmentStatus);
|
|
sw.WriteLine();
|
|
|
|
sw.Close();
|
|
}
|
|
}
|
|
|
|
private void RemoveUsbBackupFile()
|
|
{
|
|
bool directoryCheck = false;
|
|
|
|
try
|
|
{
|
|
string dday = string.Format("{0:yyyyMMdd}", DateTime.Now.AddDays(-180)) + ".csv";
|
|
|
|
DirectoryInfo dir = new DirectoryInfo(this.PathDataBackupFolder);
|
|
|
|
directoryCheck = dir.Exists;
|
|
// 폴더 체크
|
|
if (directoryCheck == false)
|
|
dir.Create();
|
|
|
|
FileInfo[] files = dir.GetFiles();
|
|
foreach (FileInfo subfile in files)
|
|
{
|
|
if (subfile.Name.StartsWith("20")) // 날짜 비교하여 10일 지난화일은 삭제함
|
|
{
|
|
if (subfile.Name.CompareTo(dday) < 0)
|
|
{
|
|
subfile.Delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
#region Override Member
|
|
protected override void OnLoad(EventArgs e)
|
|
{
|
|
base.OnLoad(e);
|
|
|
|
// 변수 초기 셋팅1
|
|
this.DefaultSetting1();
|
|
// SystemConfiguration 읽기
|
|
this.LoadSystemConfigurationFile();
|
|
// Collection 생성
|
|
this.CreateCollection();
|
|
// Count 읽기
|
|
this.LoadCounterFile(ref this.CollectionWeightData, this.SystemConfig.ProductNumber - 1);
|
|
// 품목 파일 읽기
|
|
this.LoadProductFile(ref this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
// 판정설정 파일 읽기
|
|
this.LoadJudgmentSetFile(ref this.CurrentJudgmentSetItem, this.SystemConfig.ProductNumber - 1);
|
|
// 품목명 읽기
|
|
this.LoadProductName(ref this.CollectionProductName);
|
|
// User 파일 읽기
|
|
this.LoadUserLevel1File(this.CurrentCollectionUser.Level1Users);
|
|
this.LoadUserLevel2File(this.CurrentCollectionUser.Level2Users);
|
|
this.LoadUserLevel3File(this.CurrentCollectionUser.Level3Users);
|
|
|
|
// 폼생성
|
|
this.CreateForm();
|
|
|
|
// 변수 초기 셋팅2
|
|
this.DefaultSetting2();
|
|
|
|
// 통신 OPEN
|
|
this.OpenSmartUartLink();
|
|
|
|
// Serial3 Open
|
|
this.SerialUart3Open();
|
|
|
|
// 초기 파라미터 전송
|
|
this.TrasferSystemParameter(this.SystemConfig);
|
|
|
|
this.SmartSplashProgramLoad.Finish();
|
|
|
|
this.smartForm.Show((int)DataStore.FormStore.FormMainDisplay);
|
|
}
|
|
#endregion
|
|
|
|
#region Event Handler
|
|
private void timerForTimeOutSetting_Tick(object sender, EventArgs e)
|
|
{
|
|
this.TimeOut++;
|
|
|
|
if (TimeOut == 2)
|
|
{
|
|
// 에러 발생! 다시 시도해주세요
|
|
DialogFormMessage myMsg = new DialogFormMessage(16, this.SystemConfig.Language, "");
|
|
myMsg.ShowDialog();
|
|
|
|
this.TimeOut = 0;
|
|
|
|
this.LineNum = 1;
|
|
this.CurrentLineNum = 0;
|
|
}
|
|
}
|
|
|
|
private void smartSerialPortLink_OnReadQueueEvent()
|
|
{
|
|
this.ReceiveData();
|
|
|
|
// 통신 확인
|
|
if (this.CommunicationCheckCount / 3 == 1)
|
|
{
|
|
this.ChildFormMainDisplay.pictureBoxCommunicationStatus.Visible = true;
|
|
this.CommunicationCheckCount = 0;
|
|
}
|
|
else
|
|
{
|
|
this.ChildFormMainDisplay.pictureBoxCommunicationStatus.Visible = false;
|
|
this.CommunicationCheckCount += 1;
|
|
}
|
|
}
|
|
|
|
private void timerAdcLog_Tick(object sender, EventArgs e)
|
|
{
|
|
this.FlagADCValueWrite = true;
|
|
}
|
|
#endregion
|
|
}
|
|
} |