7048 lines
331 KiB
C#
7048 lines
331 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 InModbus;
|
|
using INT63DC_6CH.In_UserManager;
|
|
using INT63DC_6CH.In_Encryption;
|
|
using INT63DC_6CH.DialogForms;
|
|
|
|
namespace INT63DC_6CH.Forms
|
|
{
|
|
public partial class FormMain : Form
|
|
{
|
|
#region Field
|
|
private SmartX.SmartSplash SmartSplashProgramLoad;
|
|
private int CommunicationCheckCount;
|
|
public bool IsCommunicationLogOpen;
|
|
public bool IsCom1LogOpen;
|
|
public bool IsCom3LogOpen;
|
|
public bool IsBootingComplete;
|
|
public int BufferSmartUart; // Buffer size 정의
|
|
public bool FlagThreadMessage1; // 플레그 쓰레드 메시지 11
|
|
private int ProductChangNumber; // 변경할 품번
|
|
private int FlagTimeoutCount; // 품번 변경 실패 시 재시도 횟수
|
|
public bool IsServoOrigin; // 비상정지 시 false 처리
|
|
public string BalanceWeight; // 중량 조정 - 분동중량
|
|
private bool IsModbusCommonDataSend; // Modbus 공통 데이터 Start 시 한번 전송용
|
|
public int FlagAutomaticLogoutWarningTime; //Part11 Auto Logout
|
|
|
|
public bool FlagDllSerial; // DllSerial 사용 유무
|
|
|
|
private string ComPortMainToLCD;
|
|
|
|
// 파일 위치
|
|
private string m_PathLaunchFolder;
|
|
private string m_PathSystemFileFolder;
|
|
private string m_PathDataBackupFolder;
|
|
private string m_PathDataStatisticsFolder;
|
|
private string m_PathDataFolder;
|
|
private string m_PathDataHistoryFolder;
|
|
private string m_PathDataInspectionFolder;
|
|
private string m_PathDataOthersFolder;
|
|
private string m_PathEncryptionFolder;
|
|
private string m_PathHeaderFolder;
|
|
private static string m_PathBinFolder;
|
|
|
|
// 로그온 색상
|
|
public Color ColorLogOff;
|
|
public Color ColorLogOn;
|
|
|
|
// Form 생성
|
|
public FormMainDisplay ChildFormMainDisplay;
|
|
public FormMenu ChildFormMenu;
|
|
public FormSystemSetting ChildFormSystemSetting;
|
|
public FormCalibration ChildFormCalibration;
|
|
public FormIOTest ChildFormIOTest;
|
|
public FormEquipmentSetting ChildFormEquipmentSetting;
|
|
public FormDataBackup ChildFormDataBackup;
|
|
public FormConfiguration ChildFormConfiguration;
|
|
public FormTimeSetting ChildFormTimeSetting;
|
|
public FormInformation ChildFormInformation;
|
|
public FormFactoryInitialize ChildFormFactoryInitialize;
|
|
public FormProgramUpdate ChildFormProgramUpdate;
|
|
public FormEquipmentTest ChildFormEquipmentTest;
|
|
public FormDataStatistics ChildFormDataStatistics;
|
|
public FormOptionSetting ChildFormOptionSetting;
|
|
public FormMotorSetting ChildFormMotorSetting;
|
|
public FormUserGroupEditor ChildFormUserGroupEditor;
|
|
public FormUserEditor ChildFormUserEditor;
|
|
public FormCommunication ChildFormCommunication;
|
|
public FormDataViewer ChildFormDataViewer;
|
|
public FormDataBackup_Part11 ChildFormDataBackup_Part11;
|
|
|
|
// System Configuration
|
|
public SystemConfigurationItem SystemConfig;
|
|
// 현재 선택 된 품목
|
|
public ProductItem CurrentProductItem;
|
|
// 현재 선택 된 판정 설정 값
|
|
public JudgmentSetItem CurrentJudgmentSetItem;
|
|
// UserGroup
|
|
public UserGroup CurrentUserGroup;
|
|
// Dll User_Name List
|
|
public List<string> ListDllUserName;
|
|
// Dataviewer Filter
|
|
public DataViewerFilter CurrentDataViewerFilter;
|
|
// 장비 구동 상태
|
|
private DataStore.EquipmentStatus m_EquipmentStatus;
|
|
private DataStore.EquipmentStatus m_EquipmentStatus1;
|
|
// 알람
|
|
public AlarmList CurrentAlarmList;
|
|
|
|
// Collection
|
|
public Collection<WeightData> CollectionWeightData; // 열별 중량 데이터
|
|
private Collection<int> CollectionGraphData; // 판정설정 그래프 데이터
|
|
private Collection<string> CollectionIOTest_InputData; // IO Test Input 데이터 취합
|
|
private Collection<string> CollectionIOTest_InputData1; // IO Test Input1 데이터 취합 확장보드
|
|
public Collection<string> CollectionProductName; // 품목명 리스트
|
|
|
|
// Modbus Data
|
|
public _30000_ModbusData Current30000ModbusData;
|
|
public _40000_ModbusData Current40000ModbusData;
|
|
// Modbus
|
|
public Modbus Modbus;
|
|
// 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 PathSystemFileFolder
|
|
{
|
|
get { return this.m_PathSystemFileFolder; }
|
|
set { this.m_PathSystemFileFolder = value; }
|
|
}
|
|
public string PathDataBackupFolder
|
|
{
|
|
get { return this.m_PathDataBackupFolder; }
|
|
set { this.m_PathDataBackupFolder = value; }
|
|
}
|
|
public string PathDataStatisticsFolder
|
|
{
|
|
get { return this.m_PathDataStatisticsFolder; }
|
|
private set { this.m_PathDataStatisticsFolder = value; }
|
|
}
|
|
public string PathDataFolder
|
|
{
|
|
get { return this.m_PathDataFolder; }
|
|
private set { this.m_PathDataFolder = value; }
|
|
}
|
|
public string PathDataHistoryFolder
|
|
{
|
|
get { return this.m_PathDataHistoryFolder; }
|
|
private set { this.m_PathDataHistoryFolder = value; }
|
|
}
|
|
public string PathDataInspectionFolder
|
|
{
|
|
get { return this.m_PathDataInspectionFolder; }
|
|
private set { this.m_PathDataInspectionFolder = value; }
|
|
}
|
|
public string PathDataOthersFolder
|
|
{
|
|
get { return this.m_PathDataOthersFolder; }
|
|
private set { this.m_PathDataOthersFolder = value; }
|
|
}
|
|
public string PathEncryptionFolder
|
|
{
|
|
get { return this.m_PathEncryptionFolder; }
|
|
set { this.m_PathEncryptionFolder = value; }
|
|
}
|
|
public string PathHeaderFolder
|
|
{
|
|
get { return this.m_PathHeaderFolder; }
|
|
private set { this.m_PathHeaderFolder = value; }
|
|
}
|
|
public static string PathBinFolder
|
|
{
|
|
get { return m_PathBinFolder; }
|
|
private set { m_PathBinFolder = value; }
|
|
}
|
|
|
|
public DataStore.EquipmentStatus EquipmentStatus
|
|
{
|
|
get { return this.m_EquipmentStatus; }
|
|
private set { this.m_EquipmentStatus = value; }
|
|
}
|
|
public DataStore.EquipmentStatus EquipmentStatus1
|
|
{
|
|
get { return this.m_EquipmentStatus1; }
|
|
private set { this.m_EquipmentStatus1 = value; }
|
|
}
|
|
#endregion
|
|
|
|
#region Method
|
|
private void CreateForm()
|
|
{
|
|
this.ChildFormMainDisplay = new FormMainDisplay(this);
|
|
this.ChildFormMenu = new FormMenu(this);
|
|
this.ChildFormSystemSetting = new FormSystemSetting(this);
|
|
this.ChildFormEquipmentSetting = new FormEquipmentSetting(this);
|
|
this.ChildFormConfiguration = new FormConfiguration(this);
|
|
this.ChildFormCalibration = new FormCalibration(this);
|
|
this.ChildFormCommunication = new FormCommunication(this);
|
|
this.ChildFormEquipmentTest = new FormEquipmentTest(this);
|
|
this.ChildFormIOTest = new FormIOTest(this);
|
|
this.ChildFormTimeSetting = new FormTimeSetting(this);
|
|
this.ChildFormInformation = new FormInformation(this);
|
|
this.ChildFormFactoryInitialize = new FormFactoryInitialize(this);
|
|
this.ChildFormProgramUpdate = new FormProgramUpdate(this);
|
|
this.ChildFormUserEditor = new FormUserEditor(this);
|
|
this.ChildFormDataStatistics = new FormDataStatistics(this);
|
|
this.ChildFormOptionSetting = new FormOptionSetting(this);
|
|
this.ChildFormMotorSetting = new FormMotorSetting(this);
|
|
this.ChildFormUserGroupEditor = new FormUserGroupEditor(this);
|
|
this.ChildFormDataViewer = new FormDataViewer(this);
|
|
if (this.SystemConfig.IsOptPart11 == true)
|
|
this.ChildFormDataBackup_Part11 = new FormDataBackup_Part11(this);
|
|
else
|
|
this.ChildFormDataBackup = new FormDataBackup(this);
|
|
|
|
this.smartForm.MainForm = this;
|
|
|
|
this.smartForm.AddChildForm(this.ChildFormMainDisplay);
|
|
this.smartForm.AddChildForm(this.ChildFormMenu);
|
|
this.smartForm.AddChildForm(this.ChildFormSystemSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormEquipmentSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormConfiguration);
|
|
this.smartForm.AddChildForm(this.ChildFormCalibration);
|
|
this.smartForm.AddChildForm(this.ChildFormCommunication);
|
|
this.smartForm.AddChildForm(this.ChildFormEquipmentTest);
|
|
this.smartForm.AddChildForm(this.ChildFormIOTest);
|
|
this.smartForm.AddChildForm(this.ChildFormTimeSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormInformation);
|
|
this.smartForm.AddChildForm(this.ChildFormFactoryInitialize);
|
|
this.smartForm.AddChildForm(this.ChildFormProgramUpdate);
|
|
this.smartForm.AddChildForm(this.ChildFormUserEditor);
|
|
this.smartForm.AddChildForm(this.ChildFormDataStatistics);
|
|
this.smartForm.AddChildForm(this.ChildFormOptionSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormMotorSetting);
|
|
this.smartForm.AddChildForm(this.ChildFormUserGroupEditor);
|
|
this.smartForm.AddChildForm(this.ChildFormDataViewer);
|
|
if (this.SystemConfig.IsOptPart11 == true)
|
|
this.smartForm.AddChildForm(this.ChildFormDataBackup_Part11);
|
|
else
|
|
this.smartForm.AddChildForm(this.ChildFormDataBackup);
|
|
}
|
|
private void CreateCollection()
|
|
{
|
|
this.CollectionWeightData = new Collection<WeightData>();
|
|
this.CollectionGraphData = new Collection<int>();
|
|
this.CollectionIOTest_InputData = new Collection<string>();
|
|
this.CollectionIOTest_InputData1 = new Collection<string>();
|
|
this.CollectionProductName = new Collection<string>();
|
|
|
|
this.CollectionWeightData.Clear();
|
|
this.CollectionGraphData.Clear();
|
|
this.CollectionIOTest_InputData.Clear();
|
|
this.CollectionIOTest_InputData1.Clear();
|
|
this.CollectionProductName.Clear();
|
|
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.CollectionWeightData.Add(new WeightData());
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
this.CollectionGraphData.Add(0);
|
|
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
this.CollectionIOTest_InputData.Add("0");
|
|
this.CollectionIOTest_InputData1.Add("0");
|
|
}
|
|
}
|
|
private void DefaultSetting1()
|
|
{
|
|
this.ColorLogOff = Color.Red;
|
|
this.ColorLogOn = Color.Green;
|
|
|
|
this.CommunicationCheckCount = 0;
|
|
this.IsCommunicationLogOpen = false;
|
|
this.IsCom1LogOpen = false;
|
|
this.IsCom3LogOpen = false;
|
|
this.IsBootingComplete = false;
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Stop;
|
|
this.BufferSmartUart = 1000000; // 1MB
|
|
this.FlagThreadMessage1 = false;
|
|
this.ProductChangNumber = 1;
|
|
this.FlagTimeoutCount = 0;
|
|
this.IsServoOrigin = false;
|
|
this.BalanceWeight = "100.000";
|
|
|
|
// Path
|
|
this.PathLaunchFolder = "SD Card\\";
|
|
this.PathSystemFileFolder = this.PathLaunchFolder + "SystemFile\\";
|
|
this.PathDataBackupFolder = this.PathLaunchFolder + "DataBackup\\";
|
|
this.PathDataStatisticsFolder = this.PathLaunchFolder + "DataStatistics\\";
|
|
this.PathDataFolder = this.PathLaunchFolder + "Data\\";
|
|
this.PathDataHistoryFolder = this.PathDataFolder + "History\\";
|
|
this.PathDataInspectionFolder = this.PathDataFolder + "Inspection\\";
|
|
this.PathDataOthersFolder = this.PathDataFolder + "Others\\";
|
|
this.PathEncryptionFolder = this.PathLaunchFolder + "Encryption\\";
|
|
this.PathHeaderFolder = this.PathLaunchFolder + "Header\\";
|
|
PathBinFolder = this.PathLaunchFolder + "Bin\\";
|
|
|
|
this.SystemConfig = new SystemConfigurationItem();
|
|
this.CurrentProductItem = new ProductItem();
|
|
this.CurrentJudgmentSetItem = new JudgmentSetItem();
|
|
this.CurrentAlarmList = new AlarmList();
|
|
this.CurrentUserGroup = new UserGroup();
|
|
this.CurrentDataViewerFilter = new DataViewerFilter();
|
|
|
|
this.ListDllUserName = new List<string>();
|
|
this.ListDllUserName.Clear();
|
|
|
|
// SystemFile 폴더 생성
|
|
if (Directory.Exists(this.PathSystemFileFolder) == false)
|
|
Directory.CreateDirectory(this.PathSystemFileFolder);
|
|
|
|
// DataBackup 폴더 생성
|
|
if (Directory.Exists(this.PathDataBackupFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataBackupFolder);
|
|
|
|
// DataStatistics 폴더 생성
|
|
if (Directory.Exists(this.PathDataStatisticsFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataStatisticsFolder);
|
|
|
|
// Data 폴더 생성
|
|
if (Directory.Exists(this.PathDataFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataFolder);
|
|
|
|
// History 폴더 생성
|
|
if (Directory.Exists(this.PathDataHistoryFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataHistoryFolder);
|
|
|
|
// Inspection 폴더 생성
|
|
if (Directory.Exists(this.PathDataInspectionFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataInspectionFolder);
|
|
|
|
// Others 폴더 생성
|
|
if (Directory.Exists(this.PathDataOthersFolder) == false)
|
|
Directory.CreateDirectory(this.PathDataOthersFolder);
|
|
|
|
// Encryption 폴더 생성
|
|
if (Directory.Exists(this.PathEncryptionFolder) == false)
|
|
Directory.CreateDirectory(this.PathEncryptionFolder);
|
|
|
|
// Header 폴더 생성
|
|
if (Directory.Exists(this.PathHeaderFolder) == false)
|
|
Directory.CreateDirectory(this.PathHeaderFolder);
|
|
|
|
// Bin 폴더 생성
|
|
if (Directory.Exists(PathBinFolder) == false)
|
|
Directory.CreateDirectory(PathBinFolder);
|
|
}
|
|
private void DefaultSetting2()
|
|
{
|
|
// DllSerial 사용유무
|
|
this.FlagDllSerial = false;
|
|
// COM port 설정
|
|
this.ComPortMainToLCD = "COM2:";
|
|
|
|
// SerialDll Initialize
|
|
SerialMgrComm.IntializeSerialManager();
|
|
SerialMgrComm.SerialPortMessageReceive += this.SerialPort_MessageReceive;
|
|
SerialMgrComm.SerialPortErrMessageReceive += this.SerialPort_ErrMessageReceive;
|
|
}
|
|
|
|
private bool UI_Invoke(System.Threading.ThreadStart invoker)
|
|
{
|
|
try
|
|
{
|
|
if (this.InvokeRequired)
|
|
{
|
|
if (this.IsDisposed)
|
|
return true;
|
|
|
|
this.Invoke(invoker);
|
|
}
|
|
else
|
|
{
|
|
invoker();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
private void SerialPort_MessageReceive(object data)
|
|
{
|
|
this.UI_Invoke(delegate
|
|
{
|
|
this.Serialport_ReceiveDataEvent(data.ToString());
|
|
});
|
|
}
|
|
private void SerialPort_ErrMessageReceive(object data)
|
|
{
|
|
this.UI_Invoke(delegate
|
|
{
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1} : Dll(Err MSG)", DateTime.Now, data));
|
|
});
|
|
}
|
|
private void InitializeUserManager()
|
|
{
|
|
UserManager.UserListNewDataEvent += this.UserManager_UserListNewDataEvent;
|
|
UserManager.UserListAddDataEvent += this.UserManager_UserListAddDataEvent;
|
|
UserManager.UserListModifyUserDataEvent += this.UserManager_UserListModifyUserDataEvent;
|
|
UserManager.UserListModifyInfoDataEvent += this.UserManager_UserListModifyInfoDataEvent;
|
|
UserManager.UserListDeleteDataEvent += this.UserManager_UserListDeleteDataEvent;
|
|
UserManager.UserListLockDataEvent += this.UserManager_UserListLockDataEvent;
|
|
UserManager.UserListDefautSettingDataEvent += this.UserManager_UserListDefaultSettingDataEvent;
|
|
UserManager.UserListLoginTimeoutDataEvent += this.UserManager_UserListLoginTimeoutDataEvent;
|
|
UserManager.UserListGetListDataEvent += this.UserManager_UserListGetListDataEvent;
|
|
UserManager.UserListLoginDataEvent += this.UserManager_UserListLoginDataEvent;
|
|
UserManager.UserListLogoutDataEvent += this.UserManager_UserListLogoutDataEvent;
|
|
UserManager.UserListGetListNameDataEvent += this.UserManager_UserListGetListNameDataEvent;
|
|
UserManager.UserListGetVersionDataEvent += this.UserManager_UserListGetVersionDataEvent;
|
|
|
|
UserManager.IntializeUserManager(this.PathSystemFileFolder);
|
|
|
|
if (this.SystemConfig.AutoLogoutTime == 1)
|
|
this.FlagAutomaticLogoutWarningTime = 30;
|
|
else
|
|
this.FlagAutomaticLogoutWarningTime = 60;
|
|
|
|
UserManager.UserManager_AutoLogoutSetTimeout(this.SystemConfig.AutoLogoutTime, this.FlagAutomaticLogoutWarningTime);
|
|
}
|
|
private void InitializeAES()
|
|
{
|
|
Encryption.DllAesEncryption_Event += AesEncryption_Event;
|
|
Encryption.DllAesEncryption_GetVersionDataEvent += AesEncryption_GetVersionDataEvent;
|
|
|
|
Encryption.InitializeEncryption();
|
|
}
|
|
|
|
private void TrasferSystemParameter(SystemConfigurationItem item)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
// 장비열개수
|
|
sb.Append(Helper.StringZeroFillDigits4(item.EquipmentColumns.ToString()));
|
|
// 개별NG사용유무
|
|
if (item.IsEachNG == false)
|
|
sb.Append(Helper.StringZeroFillDigits4("0"));
|
|
else
|
|
sb.Append(Helper.StringZeroFillDigits4("1"));
|
|
// 선별기1 위치
|
|
sb.Append(Helper.StringZeroFillDigits4(item.Sorter1Location.ToString()));
|
|
// 선별기2 위치
|
|
sb.Append(Helper.StringZeroFillDigits4(item.Sorter2Location.ToString()));
|
|
// Empty중량설정
|
|
sb.Append(Helper.StringZeroFillDigits7(item.EmptyWeight));
|
|
// 부저동작시간
|
|
sb.Append(Helper.StringZeroFillDigits4(item.BuzzerRunTime.ToString()));
|
|
// 릴레이동작시간
|
|
sb.Append(Helper.StringZeroFillDigits4(item.RelayRunTime.ToString()));
|
|
// 채터링
|
|
sb.Append(Helper.StringZeroFillDigits4(item.Chattering.ToString()));
|
|
|
|
this.TransferDataStream(CommunicationCommand.Write, CommunicationID.MainBoard, CommunicationAddress._9054_ParameterSystem, sb.ToString());
|
|
}
|
|
private void TransferProductParameter(int productNumber)
|
|
{
|
|
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));
|
|
sb.Append(Helper.StringZeroFillDigits7(pItem.UnderRangeLimit));
|
|
sb.Append(Helper.StringZeroFillDigits7(pItem.OverRangeLimit));
|
|
if (this.SystemConfig.IsWeightLimitEnable == false)
|
|
sb.Append(Helper.StringZeroFillDigits4("0"));
|
|
else
|
|
sb.Append(Helper.StringZeroFillDigits4("1"));
|
|
sb.Append(Helper.StringZeroFillDigits4(this.SystemConfig.WeightLimitIgnoreCount.ToString()));
|
|
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.JudgmentDelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.JudgmentCount.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.TurnDelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter1DelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter1RunTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter2DelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.Sorter2RunTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.EntryGateDelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.EntryGateRunTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.DischargeStopperDelayTime.ToString()));
|
|
sb.Append(Helper.StringZeroFillDigits4(jItem.DischargeStopperRunTime.ToString()));
|
|
|
|
this.TransferDataStream(CommunicationCommand.Write, CommunicationID.MainBoard, CommunicationAddress._9055_ParameterRecipe, sb.ToString());
|
|
}
|
|
public void ProductChange(int productNumber)
|
|
{
|
|
this.ProductChangNumber = productNumber;
|
|
|
|
this.TransferProductParameter(this.ProductChangNumber);
|
|
|
|
this.FlagTimeoutCount = 0;
|
|
this.timerTimeout.Enabled = true;
|
|
}
|
|
|
|
private void StartThreadMessage1()
|
|
{
|
|
if (this.smartThread.State != SmartThread.ThreadState.Running)
|
|
{
|
|
this.smartThread.Start();
|
|
this.FlagThreadMessage1 = false;
|
|
}
|
|
}
|
|
|
|
// Interlock 중량 체크 후 정지
|
|
private void InterlockCheckWeightStop(Collection<WeightData> datas)
|
|
{
|
|
if (this.SystemConfig.IsWeightLimitEnable == true)
|
|
{
|
|
for (int i = 0; i < datas.Count; i++)
|
|
{
|
|
if (int.Parse(datas[i].WeightString) > int.Parse(this.CurrentProductItem.OverRangeLimit))
|
|
{
|
|
this.TransferData(CommunicationCommand.Stop, CommunicationID.MainBoard);
|
|
//this.ChildFormMainDisplay.UpdateDisplayPinchPointAlarm(i + 1);
|
|
this.timerEmergencyStop.Enabled = true;
|
|
return;
|
|
}
|
|
|
|
if (int.Parse(datas[i].WeightString) < int.Parse(this.CurrentProductItem.UnderRangeLimit))
|
|
{
|
|
this.TransferData(CommunicationCommand.Stop, CommunicationID.MainBoard);
|
|
//this.ChildFormMainDisplay.UpdateDisplayPinchPointAlarm(i + 1);
|
|
this.timerEmergencyStop.Enabled = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Uart Communication
|
|
public void OpenSmartUartLink()
|
|
{
|
|
string fullPath = "";
|
|
|
|
try
|
|
{
|
|
// Port : COM1 or COM2
|
|
// Baudrate : 115200
|
|
|
|
if (this.FlagDllSerial == true)
|
|
SerialMgrComm.serialPortOpen(this.ComPortMainToLCD, 115200, 0, 0, 8);
|
|
else
|
|
{
|
|
if (this.smartSerialPortLink.IsOpen == false)
|
|
this.smartSerialPortLink.Open();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
#region Test 용 통신 로그
|
|
fullPath = this.PathDataBackupFolder + "Communicationlog.txt";
|
|
this.smartFileCommunicationLog.FilePathName = fullPath;
|
|
//this.smartFileCommunicationLog.Open();
|
|
//this.IsCommunicationLogOpen = true;
|
|
#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 = this.Checksumcalculator(strTemp.Substring(0, strTemp.Length - 2));
|
|
|
|
if (chkSum == dataChksum)
|
|
ret = true;
|
|
else
|
|
ret = false;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
private string Checksumcalculator(string strTemp)
|
|
{
|
|
string chkSum = "";
|
|
byte[] temp;
|
|
int value = 0, first = 0, second = 0;
|
|
char char1, char2;
|
|
|
|
if (strTemp == null || strTemp.Length == 0)
|
|
chkSum = "cc";
|
|
else
|
|
{
|
|
temp = new UTF8Encoding().GetBytes(strTemp);
|
|
|
|
for (int i = 0; i < temp.Length; i++)
|
|
value += temp[i];
|
|
|
|
first = (value & 0x00f0) >> 4;
|
|
if (first > 9)
|
|
char1 = (char)(first + 0x37);
|
|
else
|
|
char1 = (char)(first + 0x30);
|
|
|
|
second = value & 0x000f;
|
|
if (second > 9)
|
|
char2 = (char)(second + 0x37);
|
|
else
|
|
char2 = (char)(second + 0x30);
|
|
|
|
chkSum = char1.ToString() + char2.ToString();
|
|
}
|
|
|
|
return chkSum;
|
|
}
|
|
|
|
public int TransferData(string command, string id)
|
|
{
|
|
int ret = 0;
|
|
string chkSum = "cc";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(command);
|
|
sb.Append(id);
|
|
|
|
chkSum = this.Checksumcalculator(sb.ToString());
|
|
|
|
sb.Append(chkSum);
|
|
|
|
// Serial Write
|
|
if (this.FlagDllSerial == true)
|
|
SerialMgrComm.serialPortMessage(this.ComPortMainToLCD, sb.ToString());
|
|
else
|
|
{
|
|
if (this.smartSerialPortLink.IsOpen == 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;
|
|
}
|
|
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 = this.Checksumcalculator(sb.ToString());
|
|
|
|
sb.Append(chkSum);
|
|
|
|
// Serial Write
|
|
if (this.FlagDllSerial == true)
|
|
SerialMgrComm.serialPortMessage(this.ComPortMainToLCD, sb.ToString());
|
|
else
|
|
{
|
|
if (this.smartSerialPortLink.IsOpen == 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 int TransferDataRespone(string command, string id, string transactionID, string TransferCount, string respone)
|
|
{
|
|
int ret = 0;
|
|
string chkSum = "cc";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(command);
|
|
sb.Append(transactionID);
|
|
sb.Append(TransferCount);
|
|
sb.Append(respone);
|
|
|
|
chkSum = this.Checksumcalculator(sb.ToString());
|
|
|
|
sb.Append(chkSum);
|
|
|
|
// Serial Write
|
|
if (this.FlagDllSerial == true)
|
|
SerialMgrComm.serialPortMessage(this.ComPortMainToLCD, sb.ToString());
|
|
else
|
|
{
|
|
if (this.smartSerialPortLink.IsOpen == 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(string strTemp)
|
|
{
|
|
int ret = 0;
|
|
|
|
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;
|
|
}
|
|
}
|
|
private void ReceiveData()
|
|
{
|
|
int ret = 0;
|
|
string strTemp = "";
|
|
byte[] readByte;
|
|
|
|
SmartSerialPort.FRAMEDATAREADSTATUS receiveDataState = SmartSerialPort.FRAMEDATAREADSTATUS.EMPTY;
|
|
|
|
try
|
|
{
|
|
receiveDataState = this.smartSerialPortLink.ReadQueue(out readByte);
|
|
strTemp = Encoding.Default.GetString(readByte, 0, readByte.Length);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return;
|
|
}
|
|
|
|
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)
|
|
{
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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;
|
|
}
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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.IsBootingComplete = false;
|
|
this.TrasferSystemParameter(this.SystemConfig);
|
|
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Stop;
|
|
// 생산속도 Clear
|
|
foreach (WeightData data in this.CollectionWeightData)
|
|
{
|
|
data.ProductionSpeed = 0;
|
|
}
|
|
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
if (this.ChildFormEquipmentTest != null)
|
|
this.ChildFormEquipmentTest.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
break;
|
|
case "CBS":
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Start;
|
|
this.timerEquipmentStatus.Enabled = true;
|
|
|
|
// 운전시 중량 0 으로 Clear
|
|
foreach (WeightData data in this.CollectionWeightData)
|
|
data.WeightString = "0";
|
|
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
if (this.ChildFormEquipmentTest != null)
|
|
this.ChildFormEquipmentTest.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
|
|
// 비상정지시 장비 정지상태로 변환
|
|
if (this.IsServoOrigin == true)
|
|
{
|
|
this.TransferData(CommunicationCommand.Stop, CommunicationID.MainBoard);
|
|
this.ChildFormMainDisplay.UpdateDisplayAlarmMessageServoOrigin();
|
|
}
|
|
break;
|
|
case "CBT":
|
|
this.EquipmentStatus = DataStore.EquipmentStatus.Stop;
|
|
this.timerEquipmentStatus.Enabled = true;
|
|
|
|
// 생산속도 Clear
|
|
foreach (WeightData data in this.CollectionWeightData)
|
|
{
|
|
data.ProductionSpeed = 0;
|
|
}
|
|
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
if (this.ChildFormEquipmentTest != null)
|
|
this.ChildFormEquipmentTest.UpdateEquipmentStatusDisplay(this.EquipmentStatus);
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.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)
|
|
{
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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)
|
|
{
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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;
|
|
}
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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 = "", dataID = "", transferCNT = "";
|
|
|
|
// SIZE 확인
|
|
if (this.SizeCheck("S", strTemp) == false)
|
|
{
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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)
|
|
{
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
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;
|
|
}
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Receive ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, strTemp));
|
|
|
|
cmd = strTemp.Substring(0, 3);
|
|
dataID = strTemp.Substring(3, 1);
|
|
transferCNT = strTemp.Substring(4, 1);
|
|
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, dataID, transferCNT)) != 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;
|
|
case "ST1":
|
|
if ((ret = this.ReceiveCommandST1(lane, receiveData)) != 0)
|
|
return ret;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// 파라미터 읽기 응답
|
|
private int ReceiveCommandPR0(string lane, string address, string receiveData)
|
|
{
|
|
int ret = 0, iValue = 0;
|
|
string sValue = "";
|
|
|
|
try
|
|
{
|
|
switch (address)
|
|
{
|
|
case "1502":
|
|
#region Value Assign
|
|
sValue = receiveData.Substring(0, 8);
|
|
|
|
if (this.ChildFormInformation != null)
|
|
this.ChildFormInformation.UpdateProgreamVersionDisplay(this.EquipmentStatus, sValue);
|
|
#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;
|
|
// 부팅 후 영점이안맞아 강제로 영점 잡는 명령 보냄..(V1.0.3)
|
|
this.TransferData(CommunicationCommand.Zero, CommunicationID.SubBoardAll);
|
|
}
|
|
|
|
// Retry Timer stop
|
|
this.timerTimeout.Enabled = false;
|
|
|
|
this.SaveSystemConfigurationFile(this.SystemConfig);
|
|
|
|
this.LoadProductFile(ref this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
this.LoadCounterFile1(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;
|
|
}
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateCurrentProductDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem, this.CollectionWeightData);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormSystemSetting)
|
|
{
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateItemNoDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem);
|
|
}
|
|
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 "9054":
|
|
if (response == DataStore.ResponseData.ACK)
|
|
this.ProductChange(this.SystemConfig.ProductNumber);
|
|
break;
|
|
case "9055":
|
|
if(response == DataStore.ResponseData.ACK)
|
|
this.TransferDataStream(CommunicationCommand.Read, CommunicationID.MainBoard, CommunicationAddress._2001_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.IsWeightViewForward == true)
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
{
|
|
this.CollectionWeightData[i].Status = Helper.StringToWeightStatus(receiveData.Substring(i * 10, 2));
|
|
this.CollectionWeightData[i].Sign = receiveData.Substring(i * 10 + 2, 1);
|
|
this.CollectionWeightData[i].WeightString = receiveData.Substring(i * 10 + 3, 7);
|
|
}
|
|
else
|
|
{
|
|
this.CollectionWeightData[i].Status = Helper.StringToWeightStatus(receiveData.Substring(i * 10, 2));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 1; i <= this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
{
|
|
this.CollectionWeightData[this.SystemConfig.EquipmentColumns - i].Status = Helper.StringToWeightStatus(receiveData.Substring((i - 1) * 10, 2));
|
|
this.CollectionWeightData[this.SystemConfig.EquipmentColumns - i].Sign = receiveData.Substring((i - 1) * 10 + 2, 1);
|
|
this.CollectionWeightData[this.SystemConfig.EquipmentColumns - i].WeightString = receiveData.Substring((i - 1) * 10 + 3, 7);
|
|
}
|
|
else
|
|
{
|
|
this.CollectionWeightData[this.SystemConfig.EquipmentColumns - i].Status = Helper.StringToWeightStatus(receiveData.Substring((i - 1) * 10, 2));
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateStopWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 운전시 중량
|
|
private int ReceiveCommandSR0(string lane, string receiveData, string transactionID, string transferCNT)
|
|
{
|
|
int ret = 0;
|
|
string data;
|
|
StringBuilder weightLimit = new StringBuilder();
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
try
|
|
{
|
|
// Modbus
|
|
if (this.SystemConfig.EthernetMode == 4)
|
|
{
|
|
if (this.IsModbusCommonDataSend == false)
|
|
{
|
|
this.ModbusCommonDataSend();
|
|
this.IsModbusCommonDataSend = true;
|
|
}
|
|
}
|
|
|
|
switch (lane)
|
|
{
|
|
case "Z":
|
|
#region Value Assign
|
|
// Respone
|
|
//this.TransferDataRespone(CommunicationCommand.StartDataCMD, lane, transactionID, transferCNT, CommunicationAddress.ACK);
|
|
//Application.DoEvents();
|
|
|
|
//if (this.CurrentComRespone.TransactionID != transactionID)
|
|
//{
|
|
// this.CurrentComRespone.TransactionID = transactionID;
|
|
// this.CurrentComRespone.TransferCount = transferCNT;
|
|
|
|
if (this.SystemConfig.IsWeightViewForward == true)
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightData[i].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring(i * 10, 2));
|
|
this.CollectionWeightData[i].Sign = receiveData.Substring(i * 10 + 2, 1);
|
|
this.CollectionWeightData[i].WeightString = receiveData.Substring(i * 10 + 3, 7).Trim();
|
|
|
|
// SamplingData Check
|
|
data = receiveData.Substring(i * 10, 2);
|
|
if (data == "sU" || data == "sO" || data == "sP" || data == "sT")
|
|
this.CollectionWeightData[i].IsSamplingData = true;
|
|
else
|
|
this.CollectionWeightData[i].IsSamplingData = false;
|
|
|
|
// Weight Limit Check
|
|
if (data == "sa" || data == "sj")
|
|
{
|
|
if (weightLimit.ToString().Length == 0)
|
|
weightLimit.Append(string.Format("#{0}", i + 1));
|
|
else
|
|
{
|
|
weightLimit.Append(", ");
|
|
weightLimit.Append(string.Format("#{0}", i + 1));
|
|
}
|
|
}
|
|
if (weightLimit.ToString().Length != 0)
|
|
this.ChildFormMainDisplay.UpdateDisplayPinchPointAlarm(weightLimit.ToString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 1; i <= this.SystemConfig.EquipmentColumns; i++)
|
|
{
|
|
this.CollectionWeightData[this.CollectionWeightData.Count - i].JudgmentStatus = Helper.StringToJudgmentStatus(receiveData.Substring((i - 1) * 10, 2));
|
|
this.CollectionWeightData[this.CollectionWeightData.Count - i].Sign = receiveData.Substring((i - 1) * 10 + 2, 1);
|
|
this.CollectionWeightData[this.CollectionWeightData.Count - i].WeightString = receiveData.Substring((i - 1) * 10 + 3, 7).Trim();
|
|
|
|
// SamplingData Check
|
|
data = receiveData.Substring((i - 1) * 10, 2);
|
|
if (data == "sU" || data == "sO" || data == "sP" || data == "sT")
|
|
this.CollectionWeightData[this.CollectionWeightData.Count - i].IsSamplingData = true;
|
|
else
|
|
this.CollectionWeightData[this.CollectionWeightData.Count - i].IsSamplingData = false;
|
|
|
|
// Weight Limit Check
|
|
if (data == "sa" || data == "sj")
|
|
{
|
|
if (weightLimit.ToString().Length == 0)
|
|
weightLimit.Append(string.Format("#{0}", (this.CollectionWeightData.Count - i) + 1));
|
|
else
|
|
{
|
|
weightLimit.Append(", ");
|
|
weightLimit.Append(string.Format("#{0}", (this.CollectionWeightData.Count - i) + 1));
|
|
}
|
|
}
|
|
if (weightLimit.ToString().Length != 0)
|
|
this.ChildFormMainDisplay.UpdateDisplayPinchPointAlarm(weightLimit.ToString());
|
|
}
|
|
}
|
|
|
|
// 생산속도
|
|
try
|
|
{
|
|
this.CollectionWeightData[0].ProductionSpeed = int.Parse(receiveData.Substring(receiveData.Length - 4, 4).Trim());
|
|
}
|
|
catch
|
|
{
|
|
this.CollectionWeightData[0].ProductionSpeed = 0;
|
|
}
|
|
#endregion
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
#region Serial 3
|
|
if (this.SystemConfig.Serial3Mode == 1) // OPT1 - 중량 데이터 피드백
|
|
{
|
|
// V1.10.0 아남자동기 수정
|
|
// FeedbackEmptyTransfer - 제품 안들어 올때 데이터 전송 여부
|
|
// 중량이 0.3g 이하이면 전송 안함 (제품이 안들어 올때) <- 전체열이 0.3g이하일때 전송안함
|
|
// V3.1.0 HRG 수정 (V1.10.0 기능 삭제)
|
|
// Empty중량설정 추가 - 판정이 Empty이면 데이터 전송 안함
|
|
// V3.3.2
|
|
// Empty판정이 1개라도 있으면 데이터 전송 안함
|
|
// V8.0.0
|
|
// Empty 중량설정 이하면 전송 안하도록 수정(바이패스 시 GRD 'P'로 전송되어, 0g 이여도 전송됨
|
|
int cnt = 0;
|
|
foreach (WeightData weight in this.CollectionWeightData)
|
|
{
|
|
//if (weight.JudgmentStatus == DataStore.JudgmentStatus.Empty)
|
|
// cnt++;
|
|
|
|
if (int.Parse(weight.WeightString) < int.Parse(this.SystemConfig.EmptyWeight))
|
|
cnt++;
|
|
}
|
|
|
|
if (cnt == 0)
|
|
this.SerialCH3STD1(this.CollectionWeightData);
|
|
}
|
|
else if (this.SystemConfig.Serial3Mode == 2)
|
|
this.SerialCH3STD2(this.CollectionWeightData);
|
|
#endregion
|
|
|
|
#region FormMainDisplay
|
|
this.DataBackup(this.CollectionWeightData);
|
|
|
|
if (this.ChildFormMainDisplay != null)
|
|
{
|
|
this.ChildFormMainDisplay.UpdateStartWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
}
|
|
#endregion
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormSystemSetting)
|
|
{
|
|
#region FormSystemSetting
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateStartWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
#endregion
|
|
}
|
|
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 * 10, 2));
|
|
this.CollectionWeightData[i].Sign = receiveData.Substring(i * 10 + 2, 1);
|
|
this.CollectionWeightData[i].WeightString = receiveData.Substring(i * 10 + 3, 7);
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormCalibration != null)
|
|
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 * 10, 2));
|
|
this.CollectionWeightData[i].Sign = receiveData.Substring(i * 10 + 2, 1);
|
|
this.CollectionWeightData[i].WeightString = receiveData.Substring(i * 10 + 3, 7);
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateStopWeightDisplay(this.EquipmentStatus, this.CollectionWeightData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// 판정설정 그래프
|
|
private int ReceiveCommandSG0(string lane, string receiveData)
|
|
{
|
|
int ret = 0, temp = 10;
|
|
|
|
switch (lane)
|
|
{
|
|
case "A":
|
|
#region Value Assign
|
|
this.CollectionWeightData[0].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[0], this.CollectionGraphData);
|
|
break;
|
|
case "B":
|
|
#region Value Assign
|
|
this.CollectionWeightData[1].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[1], this.CollectionGraphData);
|
|
break;
|
|
case "C":
|
|
#region Value Assign
|
|
this.CollectionWeightData[2].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[2], this.CollectionGraphData);
|
|
break;
|
|
case "D":
|
|
#region Value Assign
|
|
this.CollectionWeightData[3].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[3], this.CollectionGraphData);
|
|
break;
|
|
case "E":
|
|
#region Value Assign
|
|
this.CollectionWeightData[4].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[4], this.CollectionGraphData);
|
|
break;
|
|
case "F":
|
|
#region Value Assign
|
|
this.CollectionWeightData[5].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[5], this.CollectionGraphData);
|
|
break;
|
|
case "G":
|
|
#region Value Assign
|
|
this.CollectionWeightData[6].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[6], this.CollectionGraphData);
|
|
break;
|
|
case "H":
|
|
#region Value Assign
|
|
this.CollectionWeightData[7].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[7], this.CollectionGraphData);
|
|
break;
|
|
case "I":
|
|
#region Value Assign
|
|
this.CollectionWeightData[8].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[8], this.CollectionGraphData);
|
|
break;
|
|
case "J":
|
|
#region Value Assign
|
|
this.CollectionWeightData[9].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[9], this.CollectionGraphData);
|
|
break;
|
|
case "K":
|
|
#region Value Assign
|
|
this.CollectionWeightData[10].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[10], this.CollectionGraphData);
|
|
break;
|
|
case "L":
|
|
#region Value Assign
|
|
this.CollectionWeightData[11].WeightString = receiveData.Substring(3, 7);
|
|
|
|
for (int i = 0; i < this.CollectionGraphData.Count; i++)
|
|
{
|
|
this.CollectionGraphData[i] = int.Parse(receiveData.Substring(temp, 7));
|
|
temp += 7;
|
|
}
|
|
#endregion
|
|
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateGraphDataDisplay(this.EquipmentStatus, this.CollectionWeightData[11], 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)
|
|
{
|
|
if (this.ChildFormIOTest != null)
|
|
this.ChildFormIOTest.UpdateInputRead(this.CollectionIOTest_InputData);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormEquipmentTest)
|
|
{
|
|
if (this.ChildFormEquipmentTest != null)
|
|
this.ChildFormEquipmentTest.UpdateInputRead(this.CollectionIOTest_InputData);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
// IO테스트1-IN
|
|
private int ReceiveCommandST1(string lane, string receiveData)
|
|
{
|
|
int ret = 0;
|
|
|
|
switch (lane)
|
|
{
|
|
case "0":
|
|
#region Value Assign
|
|
for (int i = 0; i < 16; i++)
|
|
this.CollectionIOTest_InputData1[i] = receiveData.Substring(i, 1);
|
|
#endregion
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormIOTest)
|
|
{
|
|
if (this.ChildFormIOTest != null)
|
|
this.ChildFormIOTest.UpdateInputRead1(this.CollectionIOTest_InputData1);
|
|
}
|
|
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
|
|
// Servo Origin (Emergency Stop)
|
|
if (this.CurrentAlarmList.IsEmergencyStop == true)
|
|
{
|
|
if (this.EquipmentStatus1 == DataStore.EquipmentStatus.Start)
|
|
{
|
|
if (this.IsServoOrigin == false)
|
|
this.IsServoOrigin = true;
|
|
}
|
|
}
|
|
|
|
// Display
|
|
if (this.ChildFormMainDisplay != null)
|
|
{
|
|
this.ChildFormMainDisplay.UpdateDisplayAlarmView(this.CurrentAlarmList);
|
|
this.ChildFormMainDisplay.UpdateDisplayAlarmMessageServoOrigin();
|
|
}
|
|
|
|
if (this.ChildFormMotorSetting != null)
|
|
this.ChildFormMotorSetting.UpdateDisplayAlarmView(this.CurrentAlarmList);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endregion
|
|
|
|
#region SystemConfiguration File1
|
|
private void CreateSystemConfigurationFile()
|
|
{
|
|
StructSystemConfigurationItem structItem;
|
|
|
|
this.SystemConfig.Initialization();
|
|
|
|
// bool
|
|
structItem.IsDataBackup = this.SystemConfig.IsDataBackup;
|
|
structItem.IsEachNG = this.SystemConfig.IsEachNG;
|
|
structItem.IsLogin = this.SystemConfig.IsLogin;
|
|
structItem.IsWeightViewForward = this.SystemConfig.IsWeightViewForward;
|
|
structItem.IsOptDataStatistics = this.SystemConfig.IsOptDataStatistics;
|
|
structItem.IsOptPart11 = this.SystemConfig.IsOptPart11;
|
|
// int
|
|
structItem.AutoLogoutTime = this.SystemConfig.AutoLogoutTime;
|
|
structItem.UsbID = this.SystemConfig.UsbID;
|
|
structItem.ProductNumber = this.SystemConfig.ProductNumber;
|
|
structItem.DataStoragePeriod = this.SystemConfig.DataStoragePeriod;
|
|
structItem.EquipmentColumns = this.SystemConfig.EquipmentColumns;
|
|
structItem.EquipmentID = this.SystemConfig.EquipmentID;
|
|
structItem.Chattering = this.SystemConfig.Chattering;
|
|
structItem.BuzzerRunTime = this.SystemConfig.BuzzerRunTime;
|
|
structItem.RelayRunTime = this.SystemConfig.RelayRunTime;
|
|
structItem.Sorter1Location = this.SystemConfig.Sorter1Location;
|
|
structItem.Sorter2Location = this.SystemConfig.Sorter2Location;
|
|
structItem.WeightLimitIgnoreCount = this.SystemConfig.WeightLimitIgnoreCount;
|
|
structItem.Serial3BaudRate = this.SystemConfig.Serial3BaudRate;
|
|
structItem.Serial3Mode = this.SystemConfig.Serial3Mode;
|
|
structItem.EthernetLocalPort = this.SystemConfig.EthernetLocalPort;
|
|
structItem.EthernetMode = this.SystemConfig.EthernetMode;
|
|
structItem.EthernetOperationMode = this.SystemConfig.EthernetOperationMode;
|
|
structItem.EthernetServerPort = this.SystemConfig.EthernetServerPort;
|
|
structItem.ModbusTcpAddress1 = this.SystemConfig.ModbusTcpAddress1;
|
|
structItem.ModbusTcpAddress2 = this.SystemConfig.ModbusTcpAddress2;
|
|
structItem.ModbusTcpStartAddress = this.SystemConfig.ModbusTcpStartAddress;
|
|
// string
|
|
structItem.Unit = this.SystemConfig.Unit;
|
|
structItem.EmptyWeight = this.SystemConfig.EmptyWeight;
|
|
structItem.SerialNumber = this.SystemConfig.SerialNumber;
|
|
structItem.User_Level1_Name = this.SystemConfig.User_Level1_Name;
|
|
structItem.User_Level2_Name = this.SystemConfig.User_Level2_Name;
|
|
structItem.User_Level3_Name = this.SystemConfig.User_Level3_Name;
|
|
structItem.EthernetServerAddress = this.SystemConfig.EthernetServerAddress;
|
|
// enum
|
|
structItem.Language = this.SystemConfig.Language;
|
|
|
|
this.smartFileIO.WriteStructure(structItem, 0);
|
|
}
|
|
public void SaveSystemConfigurationFile(SystemConfigurationItem item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructSystemConfigurationItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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();
|
|
}
|
|
|
|
// bool
|
|
structItem.IsDataBackup = item.IsDataBackup;
|
|
structItem.IsEachNG = item.IsEachNG;
|
|
structItem.IsLogin = item.IsLogin;
|
|
structItem.IsWeightViewForward = item.IsWeightViewForward;
|
|
structItem.IsOptDataStatistics = item.IsOptDataStatistics;
|
|
structItem.IsOptPart11 = item.IsOptPart11;
|
|
// int
|
|
structItem.AutoLogoutTime = item.AutoLogoutTime;
|
|
structItem.UsbID = item.UsbID;
|
|
structItem.ProductNumber = item.ProductNumber;
|
|
structItem.DataStoragePeriod = item.DataStoragePeriod;
|
|
structItem.EquipmentColumns = item.EquipmentColumns;
|
|
structItem.EquipmentID = item.EquipmentID;
|
|
structItem.Chattering = item.Chattering;
|
|
structItem.BuzzerRunTime = item.BuzzerRunTime;
|
|
structItem.RelayRunTime = item.RelayRunTime;
|
|
structItem.Sorter1Location = item.Sorter1Location;
|
|
structItem.Sorter2Location = item.Sorter2Location;
|
|
structItem.WeightLimitIgnoreCount = item.WeightLimitIgnoreCount;
|
|
structItem.Serial3BaudRate = item.Serial3BaudRate;
|
|
structItem.Serial3Mode = item.Serial3Mode;
|
|
structItem.EthernetLocalPort = item.EthernetLocalPort;
|
|
structItem.EthernetMode = item.EthernetMode;
|
|
structItem.EthernetOperationMode = item.EthernetOperationMode;
|
|
structItem.EthernetServerPort = item.EthernetServerPort;
|
|
structItem.ModbusTcpAddress1 = item.ModbusTcpAddress1;
|
|
structItem.ModbusTcpAddress2 = item.ModbusTcpAddress2;
|
|
structItem.ModbusTcpStartAddress = item.ModbusTcpStartAddress;
|
|
// string
|
|
structItem.Unit = item.Unit;
|
|
structItem.EmptyWeight = item.EmptyWeight;
|
|
structItem.SerialNumber = item.SerialNumber;
|
|
structItem.User_Level1_Name = item.User_Level1_Name;
|
|
structItem.User_Level2_Name = item.User_Level2_Name;
|
|
structItem.User_Level3_Name = item.User_Level3_Name;
|
|
structItem.EthernetServerAddress = item.EthernetServerAddress;
|
|
// enum
|
|
structItem.Language = item.Language;
|
|
|
|
this.smartFileIO.WriteStructure(structItem, 0);
|
|
this.smartFileIO.Close();
|
|
}
|
|
private void LoadSystemConfigurationFile()
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructSystemConfigurationItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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));
|
|
|
|
// bool
|
|
this.SystemConfig.IsDataBackup = structItem.IsDataBackup;
|
|
|
|
// bool
|
|
this.SystemConfig.IsDataBackup = structItem.IsDataBackup;
|
|
this.SystemConfig.IsEachNG = structItem.IsEachNG;
|
|
this.SystemConfig.IsLogin = structItem.IsLogin;
|
|
this.SystemConfig.IsWeightViewForward = structItem.IsWeightViewForward;
|
|
this.SystemConfig.IsOptDataStatistics = structItem.IsOptDataStatistics;
|
|
this.SystemConfig.IsOptPart11 = structItem.IsOptPart11;
|
|
// int
|
|
this.SystemConfig.AutoLogoutTime = structItem.AutoLogoutTime;
|
|
this.SystemConfig.UsbID = structItem.UsbID;
|
|
this.SystemConfig.ProductNumber = structItem.ProductNumber;
|
|
this.SystemConfig.DataStoragePeriod = structItem.DataStoragePeriod;
|
|
this.SystemConfig.EquipmentColumns = structItem.EquipmentColumns;
|
|
this.SystemConfig.EquipmentID = structItem.EquipmentID;
|
|
this.SystemConfig.Chattering = structItem.Chattering;
|
|
this.SystemConfig.BuzzerRunTime = structItem.BuzzerRunTime;
|
|
this.SystemConfig.RelayRunTime = structItem.RelayRunTime;
|
|
this.SystemConfig.Sorter1Location = structItem.Sorter1Location;
|
|
this.SystemConfig.Sorter2Location = structItem.Sorter2Location;
|
|
this.SystemConfig.WeightLimitIgnoreCount = structItem.WeightLimitIgnoreCount;
|
|
this.SystemConfig.Serial3BaudRate = structItem.Serial3BaudRate;
|
|
this.SystemConfig.Serial3Mode = structItem.Serial3Mode;
|
|
this.SystemConfig.EthernetLocalPort = structItem.EthernetLocalPort;
|
|
this.SystemConfig.EthernetMode = structItem.EthernetMode;
|
|
this.SystemConfig.EthernetOperationMode = structItem.EthernetOperationMode;
|
|
this.SystemConfig.EthernetServerPort = structItem.EthernetServerPort;
|
|
this.SystemConfig.ModbusTcpAddress1 = structItem.ModbusTcpAddress1;
|
|
this.SystemConfig.ModbusTcpAddress2 = structItem.ModbusTcpAddress2;
|
|
this.SystemConfig.ModbusTcpStartAddress = structItem.ModbusTcpStartAddress;
|
|
// string
|
|
this.SystemConfig.Unit = structItem.Unit;
|
|
this.SystemConfig.EmptyWeight = structItem.EmptyWeight;
|
|
this.SystemConfig.SerialNumber = structItem.SerialNumber;
|
|
this.SystemConfig.User_Level1_Name = structItem.User_Level1_Name;
|
|
this.SystemConfig.User_Level2_Name = structItem.User_Level2_Name;
|
|
this.SystemConfig.User_Level3_Name = structItem.User_Level3_Name;
|
|
this.SystemConfig.EthernetServerAddress = structItem.EthernetServerAddress;
|
|
// enum
|
|
this.SystemConfig.Language = structItem.Language;
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
#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.OverRangeLimit = this.CurrentProductItem.OverRangeLimit;
|
|
structItem.UnderRangeLimit = this.CurrentProductItem.UnderRangeLimit;
|
|
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.PathSystemFileFolder + "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.OverRangeLimit = item.OverRangeLimit;
|
|
structItem.UnderRangeLimit = item.UnderRangeLimit;
|
|
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, save = false;
|
|
string fullFilePath = "";
|
|
StructProductItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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
|
|
{
|
|
if (this.smartFileIO.ReadStructureAllBuffer() == true)
|
|
{
|
|
structItem = (StructProductItem)this.smartFileIO.ReadStructureBuffer(typeof(StructProductItem), index);
|
|
|
|
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;
|
|
|
|
// OverRangeLimit
|
|
if (structItem.OverRangeLimit == "")
|
|
{
|
|
item.OverRangeLimit = "99999";
|
|
save = true;
|
|
}
|
|
else
|
|
item.OverRangeLimit = structItem.OverRangeLimit;
|
|
// UnderRangeLimit
|
|
if (structItem.UnderRangeLimit == "")
|
|
item.UnderRangeLimit = "0";
|
|
else
|
|
item.UnderRangeLimit = structItem.UnderRangeLimit;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
|
|
this.smartFileIO.Close();
|
|
|
|
this.SaveProductFile(item, index);
|
|
}
|
|
public void LoadProductName(ref Collection<string> values)
|
|
{
|
|
string fullFilePath = "";
|
|
StructProductItem structItem;
|
|
|
|
values.Clear();
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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.JudgmentDelayTime = this.CurrentJudgmentSetItem.JudgmentDelayTime;
|
|
structItem.JudgmentCount = this.CurrentJudgmentSetItem.JudgmentCount;
|
|
structItem.FeedSpeed = this.CurrentJudgmentSetItem.FeedSpeed;
|
|
structItem.TurnDelayTime = this.CurrentJudgmentSetItem.TurnDelayTime;
|
|
structItem.Sorter1RunTime = this.CurrentJudgmentSetItem.Sorter1RunTime;
|
|
structItem.Sorter1DelayTime = this.CurrentJudgmentSetItem.Sorter1DelayTime;
|
|
structItem.Sorter2DelayTime = this.CurrentJudgmentSetItem.Sorter2DelayTime;
|
|
structItem.Sorter2RunTime = this.CurrentJudgmentSetItem.Sorter2RunTime;
|
|
structItem.EntryGateDelayTime = this.CurrentJudgmentSetItem.EntryGateDelayTime;
|
|
structItem.EntryGateRunTime = this.CurrentJudgmentSetItem.EntryGateRunTime;
|
|
structItem.DischargeStopperDelayTime = this.CurrentJudgmentSetItem.DischargeStopperDelayTime;
|
|
structItem.DischargeStopperRunTime = this.CurrentJudgmentSetItem.DischargeStopperRunTime;
|
|
|
|
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.PathSystemFileFolder + "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.JudgmentDelayTime = item.JudgmentDelayTime;
|
|
structItem.JudgmentCount = item.JudgmentCount;
|
|
structItem.FeedSpeed = item.FeedSpeed;
|
|
structItem.TurnDelayTime = item.TurnDelayTime;
|
|
structItem.Sorter1RunTime = item.Sorter1RunTime;
|
|
structItem.Sorter1DelayTime = item.Sorter1DelayTime;
|
|
structItem.Sorter2DelayTime = item.Sorter2DelayTime;
|
|
structItem.Sorter2RunTime = item.Sorter2RunTime;
|
|
structItem.EntryGateDelayTime = item.EntryGateDelayTime;
|
|
structItem.EntryGateRunTime = item.EntryGateRunTime;
|
|
structItem.DischargeStopperDelayTime = item.DischargeStopperDelayTime;
|
|
structItem.DischargeStopperRunTime = item.DischargeStopperRunTime;
|
|
|
|
structItem.DummyString1 = "";
|
|
structItem.DummyString2 = "";
|
|
structItem.DummyString3 = "";
|
|
structItem.DummyString4 = "";
|
|
structItem.DummyString5 = "";
|
|
|
|
this.smartFileIO.WriteStructure(structItem, index);
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
public void LoadJudgmentSetFile(ref JudgmentSetItem item, int index)
|
|
{
|
|
bool fileCheck = false;
|
|
string fullFilePath = "";
|
|
StructJudgmentSetItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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
|
|
{
|
|
if (this.smartFileIO.ReadStructureAllBuffer() == true)
|
|
{
|
|
structItem = (StructJudgmentSetItem)this.smartFileIO.ReadStructureBuffer(typeof(StructJudgmentSetItem), index);
|
|
|
|
item.JudgmentDelayTime = structItem.JudgmentDelayTime;
|
|
item.JudgmentCount = structItem.JudgmentCount;
|
|
item.FeedSpeed = structItem.FeedSpeed;
|
|
item.TurnDelayTime = structItem.TurnDelayTime;
|
|
item.Sorter1DelayTime = structItem.Sorter1DelayTime;
|
|
item.Sorter1RunTime = structItem.Sorter1RunTime;
|
|
item.Sorter2DelayTime = structItem.Sorter2DelayTime;
|
|
item.Sorter2RunTime = structItem.Sorter2RunTime;
|
|
item.EntryGateDelayTime = structItem.EntryGateDelayTime;
|
|
item.EntryGateRunTime = structItem.EntryGateRunTime;
|
|
item.DischargeStopperDelayTime = structItem.DischargeStopperDelayTime;
|
|
item.DischargeStopperRunTime = structItem.DischargeStopperRunTime;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region Counter File1
|
|
private void CreateCounterFile1()
|
|
{
|
|
StructCounter structItem1;
|
|
|
|
for (int i = 0; i < 1000; i++)
|
|
{
|
|
structItem1.OverCount1 = 0;
|
|
structItem1.PassCount1 = 0;
|
|
structItem1.UnderCount1 = 0;
|
|
structItem1.ExNGCount1 = 0;
|
|
|
|
structItem1.OverCount2 = 0;
|
|
structItem1.PassCount2 = 0;
|
|
structItem1.UnderCount2 = 0;
|
|
structItem1.ExNGCount2 = 0;
|
|
|
|
structItem1.OverCount3 = 0;
|
|
structItem1.PassCount3 = 0;
|
|
structItem1.UnderCount3 = 0;
|
|
structItem1.ExNGCount3 = 0;
|
|
|
|
structItem1.OverCount4 = 0;
|
|
structItem1.PassCount4 = 0;
|
|
structItem1.UnderCount4 = 0;
|
|
structItem1.ExNGCount4 = 0;
|
|
|
|
structItem1.OverCount5 = 0;
|
|
structItem1.PassCount5 = 0;
|
|
structItem1.UnderCount5 = 0;
|
|
structItem1.ExNGCount5 = 0;
|
|
|
|
structItem1.OverCount6 = 0;
|
|
structItem1.PassCount6 = 0;
|
|
structItem1.UnderCount6 = 0;
|
|
structItem1.ExNGCount6 = 0;
|
|
|
|
structItem1.OverCount7 = 0;
|
|
structItem1.PassCount7 = 0;
|
|
structItem1.UnderCount7 = 0;
|
|
structItem1.ExNGCount7 = 0;
|
|
|
|
structItem1.OverCount8 = 0;
|
|
structItem1.PassCount8 = 0;
|
|
structItem1.UnderCount8 = 0;
|
|
structItem1.ExNGCount8 = 0;
|
|
|
|
structItem1.OverCount9 = 0;
|
|
structItem1.PassCount9 = 0;
|
|
structItem1.UnderCount9 = 0;
|
|
structItem1.ExNGCount9 = 0;
|
|
|
|
structItem1.OverCount10 = 0;
|
|
structItem1.PassCount10 = 0;
|
|
structItem1.UnderCount10 = 0;
|
|
structItem1.ExNGCount10 = 0;
|
|
|
|
structItem1.OverCount11 = 0;
|
|
structItem1.PassCount11 = 0;
|
|
structItem1.UnderCount11 = 0;
|
|
structItem1.ExNGCount11 = 0;
|
|
|
|
structItem1.OverCount12 = 0;
|
|
structItem1.PassCount12 = 0;
|
|
structItem1.UnderCount12 = 0;
|
|
structItem1.ExNGCount12 = 0;
|
|
|
|
structItem1.DummyInt1 = 0;
|
|
structItem1.DummyInt2 = 0;
|
|
structItem1.DummyInt3 = 0;
|
|
structItem1.DummyInt4 = 0;
|
|
structItem1.DummyInt5 = 0;
|
|
structItem1.DummyInt6 = 0;
|
|
structItem1.DummyInt7 = 0;
|
|
structItem1.DummyInt8 = 0;
|
|
structItem1.DummyInt9 = 0;
|
|
structItem1.DummyInt10 = 0;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem1, i);
|
|
}
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveCounterFile1(Collection<WeightData> items, int index)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructCounter structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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.CreateCounterFile1();
|
|
}
|
|
|
|
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;
|
|
|
|
switch (this.SystemConfig.EquipmentColumns)
|
|
{
|
|
case 2:
|
|
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.OverCount7 = 0;
|
|
structItem.PassCount7 = 0;
|
|
structItem.UnderCount7 = 0;
|
|
structItem.ExNGCount7 = 0;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 3:
|
|
structItem.OverCount3 = items[2].OverCount;
|
|
structItem.PassCount3 = items[2].PassCount;
|
|
structItem.UnderCount3 = items[2].UnderCount;
|
|
structItem.ExNGCount3 = items[2].ExNGCount;
|
|
|
|
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.OverCount7 = 0;
|
|
structItem.PassCount7 = 0;
|
|
structItem.UnderCount7 = 0;
|
|
structItem.ExNGCount7 = 0;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 4:
|
|
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 = 0;
|
|
structItem.PassCount5 = 0;
|
|
structItem.UnderCount5 = 0;
|
|
structItem.ExNGCount5 = 0;
|
|
|
|
structItem.OverCount6 = 0;
|
|
structItem.PassCount6 = 0;
|
|
structItem.UnderCount6 = 0;
|
|
structItem.ExNGCount6 = 0;
|
|
|
|
structItem.OverCount7 = 0;
|
|
structItem.PassCount7 = 0;
|
|
structItem.UnderCount7 = 0;
|
|
structItem.ExNGCount7 = 0;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 5:
|
|
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 = 0;
|
|
structItem.PassCount6 = 0;
|
|
structItem.UnderCount6 = 0;
|
|
structItem.ExNGCount6 = 0;
|
|
|
|
structItem.OverCount7 = 0;
|
|
structItem.PassCount7 = 0;
|
|
structItem.UnderCount7 = 0;
|
|
structItem.ExNGCount7 = 0;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 6:
|
|
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.OverCount7 = 0;
|
|
structItem.PassCount7 = 0;
|
|
structItem.UnderCount7 = 0;
|
|
structItem.ExNGCount7 = 0;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 7:
|
|
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.OverCount7 = items[6].OverCount;
|
|
structItem.PassCount7 = items[6].PassCount;
|
|
structItem.UnderCount7 = items[6].UnderCount;
|
|
structItem.ExNGCount7 = items[6].ExNGCount;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 8:
|
|
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.OverCount7 = items[6].OverCount;
|
|
structItem.PassCount7 = items[6].PassCount;
|
|
structItem.UnderCount7 = items[6].UnderCount;
|
|
structItem.ExNGCount7 = items[6].ExNGCount;
|
|
|
|
structItem.OverCount8 = items[7].OverCount;
|
|
structItem.PassCount8 = items[7].PassCount;
|
|
structItem.UnderCount8 = items[7].UnderCount;
|
|
structItem.ExNGCount8 = items[7].ExNGCount;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 10:
|
|
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.OverCount7 = items[6].OverCount;
|
|
structItem.PassCount7 = items[6].PassCount;
|
|
structItem.UnderCount7 = items[6].UnderCount;
|
|
structItem.ExNGCount7 = items[6].ExNGCount;
|
|
|
|
structItem.OverCount8 = items[7].OverCount;
|
|
structItem.PassCount8 = items[7].PassCount;
|
|
structItem.UnderCount8 = items[7].UnderCount;
|
|
structItem.ExNGCount8 = items[7].ExNGCount;
|
|
|
|
structItem.OverCount9 = items[8].OverCount;
|
|
structItem.PassCount9 = items[8].PassCount;
|
|
structItem.UnderCount9 = items[8].UnderCount;
|
|
structItem.ExNGCount9 = items[8].ExNGCount;
|
|
|
|
structItem.OverCount10 = items[9].OverCount;
|
|
structItem.PassCount10 = items[9].PassCount;
|
|
structItem.UnderCount10 = items[9].UnderCount;
|
|
structItem.ExNGCount10 = items[9].ExNGCount;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
case 12:
|
|
case 16:
|
|
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.OverCount7 = items[6].OverCount;
|
|
structItem.PassCount7 = items[6].PassCount;
|
|
structItem.UnderCount7 = items[6].UnderCount;
|
|
structItem.ExNGCount7 = items[6].ExNGCount;
|
|
|
|
structItem.OverCount8 = items[7].OverCount;
|
|
structItem.PassCount8 = items[7].PassCount;
|
|
structItem.UnderCount8 = items[7].UnderCount;
|
|
structItem.ExNGCount8 = items[7].ExNGCount;
|
|
|
|
structItem.OverCount9 = items[8].OverCount;
|
|
structItem.PassCount9 = items[8].PassCount;
|
|
structItem.UnderCount9 = items[8].UnderCount;
|
|
structItem.ExNGCount9 = items[8].ExNGCount;
|
|
|
|
structItem.OverCount10 = items[9].OverCount;
|
|
structItem.PassCount10 = items[9].PassCount;
|
|
structItem.UnderCount10 = items[9].UnderCount;
|
|
structItem.ExNGCount10 = items[9].ExNGCount;
|
|
|
|
structItem.OverCount11 = items[10].OverCount;
|
|
structItem.PassCount11 = items[10].PassCount;
|
|
structItem.UnderCount11 = items[10].UnderCount;
|
|
structItem.ExNGCount11 = items[10].ExNGCount;
|
|
|
|
structItem.OverCount12 = items[11].OverCount;
|
|
structItem.PassCount12 = items[11].PassCount;
|
|
structItem.UnderCount12 = items[11].UnderCount;
|
|
structItem.ExNGCount12 = items[11].ExNGCount;
|
|
break;
|
|
default:
|
|
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.OverCount7 = 0;
|
|
structItem.PassCount7 = 0;
|
|
structItem.UnderCount7 = 0;
|
|
structItem.ExNGCount7 = 0;
|
|
|
|
structItem.OverCount8 = 0;
|
|
structItem.PassCount8 = 0;
|
|
structItem.UnderCount8 = 0;
|
|
structItem.ExNGCount8 = 0;
|
|
|
|
structItem.OverCount9 = 0;
|
|
structItem.PassCount9 = 0;
|
|
structItem.UnderCount9 = 0;
|
|
structItem.ExNGCount9 = 0;
|
|
|
|
structItem.OverCount10 = 0;
|
|
structItem.PassCount10 = 0;
|
|
structItem.UnderCount10 = 0;
|
|
structItem.ExNGCount10 = 0;
|
|
|
|
structItem.OverCount11 = 0;
|
|
structItem.PassCount11 = 0;
|
|
structItem.UnderCount11 = 0;
|
|
structItem.ExNGCount11 = 0;
|
|
|
|
structItem.OverCount12 = 0;
|
|
structItem.PassCount12 = 0;
|
|
structItem.UnderCount12 = 0;
|
|
structItem.ExNGCount12 = 0;
|
|
break;
|
|
}
|
|
|
|
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 LoadCounterFile1(ref Collection<WeightData> items, int index)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructCounter structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "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.CreateCounterFile1();
|
|
}
|
|
|
|
try
|
|
{
|
|
if (this.smartFileIO.ReadStructureAllBuffer() == true)
|
|
{
|
|
structItem = (StructCounter)this.smartFileIO.ReadStructureBuffer(typeof(StructCounter), index);
|
|
|
|
items[0].UnderCount = structItem.UnderCount1;
|
|
items[0].PassCount = structItem.PassCount1;
|
|
items[0].OverCount = structItem.OverCount1;
|
|
items[0].ExNGCount = structItem.ExNGCount1;
|
|
|
|
switch (this.SystemConfig.EquipmentColumns)
|
|
{
|
|
case 2:
|
|
items[1].UnderCount = structItem.UnderCount2;
|
|
items[1].PassCount = structItem.PassCount2;
|
|
items[1].OverCount = structItem.OverCount2;
|
|
items[1].ExNGCount = structItem.ExNGCount2;
|
|
break;
|
|
case 3:
|
|
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;
|
|
break;
|
|
case 4:
|
|
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;
|
|
break;
|
|
case 5:
|
|
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;
|
|
break;
|
|
case 6:
|
|
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;
|
|
break;
|
|
case 7:
|
|
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;
|
|
|
|
items[6].UnderCount = structItem.UnderCount7;
|
|
items[6].PassCount = structItem.PassCount7;
|
|
items[6].OverCount = structItem.OverCount7;
|
|
items[6].ExNGCount = structItem.ExNGCount7;
|
|
break;
|
|
case 8:
|
|
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;
|
|
|
|
items[6].UnderCount = structItem.UnderCount7;
|
|
items[6].PassCount = structItem.PassCount7;
|
|
items[6].OverCount = structItem.OverCount7;
|
|
items[6].ExNGCount = structItem.ExNGCount7;
|
|
|
|
items[7].UnderCount = structItem.UnderCount8;
|
|
items[7].PassCount = structItem.PassCount8;
|
|
items[7].OverCount = structItem.OverCount8;
|
|
items[7].ExNGCount = structItem.ExNGCount8;
|
|
break;
|
|
case 10:
|
|
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;
|
|
|
|
items[6].UnderCount = structItem.UnderCount7;
|
|
items[6].PassCount = structItem.PassCount7;
|
|
items[6].OverCount = structItem.OverCount7;
|
|
items[6].ExNGCount = structItem.ExNGCount7;
|
|
|
|
items[7].UnderCount = structItem.UnderCount8;
|
|
items[7].PassCount = structItem.PassCount8;
|
|
items[7].OverCount = structItem.OverCount8;
|
|
items[7].ExNGCount = structItem.ExNGCount8;
|
|
|
|
items[8].UnderCount = structItem.UnderCount9;
|
|
items[8].PassCount = structItem.PassCount9;
|
|
items[8].OverCount = structItem.OverCount9;
|
|
items[8].ExNGCount = structItem.ExNGCount9;
|
|
|
|
items[9].UnderCount = structItem.UnderCount10;
|
|
items[9].PassCount = structItem.PassCount10;
|
|
items[9].OverCount = structItem.OverCount10;
|
|
items[9].ExNGCount = structItem.ExNGCount10;
|
|
break;
|
|
case 12:
|
|
case 16:
|
|
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;
|
|
|
|
items[6].UnderCount = structItem.UnderCount7;
|
|
items[6].PassCount = structItem.PassCount7;
|
|
items[6].OverCount = structItem.OverCount7;
|
|
items[6].ExNGCount = structItem.ExNGCount7;
|
|
|
|
items[7].UnderCount = structItem.UnderCount8;
|
|
items[7].PassCount = structItem.PassCount8;
|
|
items[7].OverCount = structItem.OverCount8;
|
|
items[7].ExNGCount = structItem.ExNGCount8;
|
|
|
|
items[8].UnderCount = structItem.UnderCount9;
|
|
items[8].PassCount = structItem.PassCount9;
|
|
items[8].OverCount = structItem.OverCount9;
|
|
items[8].ExNGCount = structItem.ExNGCount9;
|
|
|
|
items[9].UnderCount = structItem.UnderCount10;
|
|
items[9].PassCount = structItem.PassCount10;
|
|
items[9].OverCount = structItem.OverCount10;
|
|
items[9].ExNGCount = structItem.ExNGCount10;
|
|
|
|
items[10].UnderCount = structItem.UnderCount11;
|
|
items[10].PassCount = structItem.PassCount11;
|
|
items[10].OverCount = structItem.OverCount11;
|
|
items[10].ExNGCount = structItem.ExNGCount11;
|
|
|
|
items[11].UnderCount = structItem.UnderCount12;
|
|
items[11].PassCount = structItem.PassCount12;
|
|
items[11].OverCount = structItem.OverCount12;
|
|
items[11].ExNGCount = structItem.ExNGCount12;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region UserGroupFile
|
|
private void CreateUserGroupFile()
|
|
{
|
|
StructUserGroupItem structItem;
|
|
UserGroupItem item = new UserGroupItem();
|
|
|
|
#region Level1
|
|
structItem.IsMainDisplayProductNo = true;
|
|
structItem.IsMainDisplayWeightSetting = false;
|
|
structItem.IsMainDisplayClear = true;
|
|
structItem.IsMainDisplaySubMenu = false;
|
|
|
|
structItem.IsMenuTimeSetting = false;
|
|
structItem.IsMenuInformation = true;
|
|
structItem.IsMenuDataBackup = true;
|
|
structItem.IsMenuCalibration = false;
|
|
structItem.IsMenuCommunication = false;
|
|
structItem.IsMenuConfiguration = false;
|
|
structItem.IsMenuSystemSetting = false;
|
|
structItem.IsMenuMotorSetting = false;
|
|
structItem.IsMenuUpdate = false;
|
|
structItem.IsMenuFactoryReset = false;
|
|
structItem.IsMenuEquipmentSetting = false;
|
|
structItem.IsMenuIOTest = false;
|
|
structItem.IsMenuDataStatistics = true;
|
|
structItem.IsMenuUserSetting = true;
|
|
structItem.IsMenuUserGroupSetting = false;
|
|
structItem.IsMenuDataViewer = false;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 0);
|
|
#endregion
|
|
|
|
#region Level2
|
|
structItem.IsMainDisplayProductNo = true;
|
|
structItem.IsMainDisplayWeightSetting = true;
|
|
structItem.IsMainDisplayClear = true;
|
|
structItem.IsMainDisplaySubMenu = true;
|
|
|
|
structItem.IsMenuTimeSetting = false;
|
|
structItem.IsMenuInformation = true;
|
|
structItem.IsMenuDataBackup = true;
|
|
structItem.IsMenuCalibration = true;
|
|
structItem.IsMenuCommunication = false;
|
|
structItem.IsMenuConfiguration = false;
|
|
structItem.IsMenuSystemSetting = true;
|
|
structItem.IsMenuMotorSetting = false;
|
|
structItem.IsMenuUpdate = false;
|
|
structItem.IsMenuFactoryReset = false;
|
|
structItem.IsMenuEquipmentSetting = false;
|
|
structItem.IsMenuIOTest = false;
|
|
structItem.IsMenuDataStatistics = true;
|
|
structItem.IsMenuUserSetting = true;
|
|
structItem.IsMenuUserGroupSetting = false;
|
|
structItem.IsMenuDataViewer = true;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 1);
|
|
#endregion
|
|
|
|
#region Level3
|
|
structItem.IsMainDisplayProductNo = true;
|
|
structItem.IsMainDisplayWeightSetting = true;
|
|
structItem.IsMainDisplayClear = true;
|
|
structItem.IsMainDisplaySubMenu = true;
|
|
|
|
structItem.IsMenuTimeSetting = true;
|
|
structItem.IsMenuInformation = true;
|
|
structItem.IsMenuDataBackup = true;
|
|
structItem.IsMenuCalibration = true;
|
|
structItem.IsMenuCommunication = true;
|
|
structItem.IsMenuConfiguration = true;
|
|
structItem.IsMenuSystemSetting = true;
|
|
structItem.IsMenuMotorSetting = true;
|
|
structItem.IsMenuUpdate = true;
|
|
structItem.IsMenuFactoryReset = true;
|
|
structItem.IsMenuEquipmentSetting = true;
|
|
structItem.IsMenuIOTest = true;
|
|
structItem.IsMenuDataStatistics = true;
|
|
structItem.IsMenuUserSetting = true;
|
|
structItem.IsMenuUserGroupSetting = true;
|
|
structItem.IsMenuDataViewer = true;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 2);
|
|
#endregion
|
|
|
|
#region NotLogin
|
|
structItem.IsMainDisplayProductNo = true;
|
|
structItem.IsMainDisplayWeightSetting = true;
|
|
structItem.IsMainDisplayClear = true;
|
|
structItem.IsMainDisplaySubMenu = true;
|
|
|
|
structItem.IsMenuTimeSetting = true;
|
|
structItem.IsMenuInformation = true;
|
|
structItem.IsMenuDataBackup = true;
|
|
structItem.IsMenuCalibration = true;
|
|
structItem.IsMenuCommunication = true;
|
|
structItem.IsMenuConfiguration = true;
|
|
structItem.IsMenuSystemSetting = true;
|
|
structItem.IsMenuMotorSetting = true;
|
|
structItem.IsMenuUpdate = true;
|
|
structItem.IsMenuFactoryReset = true;
|
|
structItem.IsMenuEquipmentSetting = true;
|
|
structItem.IsMenuIOTest = true;
|
|
structItem.IsMenuDataStatistics = false;
|
|
structItem.IsMenuUserSetting = false;
|
|
structItem.IsMenuUserGroupSetting = false;
|
|
structItem.IsMenuDataViewer = false;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, 3);
|
|
#endregion
|
|
|
|
this.smartFileIO.WriteStructure_End();
|
|
}
|
|
public void SaveUserGroupFile(UserGroup item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserGroupItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "UserGroup.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.CreateUserGroupFile();
|
|
}
|
|
|
|
#region Level1
|
|
structItem.IsMainDisplayProductNo = item.Level1.IsMainDisplayProductNo;
|
|
structItem.IsMainDisplayWeightSetting = item.Level1.IsMainDisplayWeightSetting;
|
|
structItem.IsMainDisplayClear = item.Level1.IsMainDisplayClear;
|
|
structItem.IsMainDisplaySubMenu = item.Level1.IsMainDisplaySubMenu;
|
|
|
|
structItem.IsMenuTimeSetting = item.Level1.IsMenuTime;
|
|
structItem.IsMenuInformation = item.Level1.IsMenuInformation;
|
|
structItem.IsMenuDataBackup = item.Level1.IsMenuDataBackup;
|
|
structItem.IsMenuCalibration = item.Level1.IsMenuCalibration;
|
|
structItem.IsMenuCommunication = item.Level1.IsMenuCommunication;
|
|
structItem.IsMenuConfiguration = item.Level1.IsMenuConfiguration;
|
|
structItem.IsMenuSystemSetting = item.Level1.IsMenuSystem;
|
|
structItem.IsMenuMotorSetting = item.Level1.IsMenuMotor;
|
|
structItem.IsMenuUpdate = item.Level1.IsMenuUpdate;
|
|
structItem.IsMenuFactoryReset = item.Level1.IsMenuInitialization;
|
|
structItem.IsMenuEquipmentSetting = item.Level1.IsMenuEquipment;
|
|
structItem.IsMenuIOTest = item.Level1.IsMenuIOTest;
|
|
structItem.IsMenuDataStatistics = item.Level1.IsMenuStatistics;
|
|
structItem.IsMenuUserSetting = item.Level1.IsMenuUser;
|
|
structItem.IsMenuUserGroupSetting = item.Level1.IsMenuUserGroupEditor;
|
|
structItem.IsMenuDataViewer = item.Level1.IsMenuViewer;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, (int)DataStore.E_UserGroup_FileIndex.f0_Level1);
|
|
#endregion
|
|
|
|
#region Level2
|
|
structItem.IsMainDisplayProductNo = item.Level2.IsMainDisplayProductNo;
|
|
structItem.IsMainDisplayWeightSetting = item.Level2.IsMainDisplayWeightSetting;
|
|
structItem.IsMainDisplayClear = item.Level2.IsMainDisplayClear;
|
|
structItem.IsMainDisplaySubMenu = item.Level2.IsMainDisplaySubMenu;
|
|
|
|
structItem.IsMenuTimeSetting = item.Level2.IsMenuTime;
|
|
structItem.IsMenuInformation = item.Level2.IsMenuInformation;
|
|
structItem.IsMenuDataBackup = item.Level2.IsMenuDataBackup;
|
|
structItem.IsMenuCalibration = item.Level2.IsMenuCalibration;
|
|
structItem.IsMenuCommunication = item.Level2.IsMenuCommunication;
|
|
structItem.IsMenuConfiguration = item.Level2.IsMenuConfiguration;
|
|
structItem.IsMenuSystemSetting = item.Level2.IsMenuSystem;
|
|
structItem.IsMenuMotorSetting = item.Level2.IsMenuMotor;
|
|
structItem.IsMenuUpdate = item.Level2.IsMenuUpdate;
|
|
structItem.IsMenuFactoryReset = item.Level2.IsMenuInitialization;
|
|
structItem.IsMenuEquipmentSetting = item.Level2.IsMenuEquipment;
|
|
structItem.IsMenuIOTest = item.Level2.IsMenuIOTest;
|
|
structItem.IsMenuDataStatistics = item.Level2.IsMenuStatistics;
|
|
structItem.IsMenuUserSetting = item.Level2.IsMenuUser;
|
|
structItem.IsMenuUserGroupSetting = item.Level2.IsMenuUserGroupEditor;
|
|
structItem.IsMenuDataViewer = item.Level2.IsMenuViewer;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, (int)DataStore.E_UserGroup_FileIndex.f1_Level2);
|
|
#endregion
|
|
|
|
#region Level3
|
|
structItem.IsMainDisplayProductNo = item.Level3.IsMainDisplayProductNo;
|
|
structItem.IsMainDisplayWeightSetting = item.Level3.IsMainDisplayWeightSetting;
|
|
structItem.IsMainDisplayClear = item.Level3.IsMainDisplayClear;
|
|
structItem.IsMainDisplaySubMenu = item.Level3.IsMainDisplaySubMenu;
|
|
|
|
structItem.IsMenuTimeSetting = item.Level3.IsMenuTime;
|
|
structItem.IsMenuInformation = item.Level3.IsMenuInformation;
|
|
structItem.IsMenuDataBackup = item.Level3.IsMenuDataBackup;
|
|
structItem.IsMenuCalibration = item.Level3.IsMenuCalibration;
|
|
structItem.IsMenuCommunication = item.Level3.IsMenuCommunication;
|
|
structItem.IsMenuConfiguration = item.Level3.IsMenuConfiguration;
|
|
structItem.IsMenuSystemSetting = item.Level3.IsMenuSystem;
|
|
structItem.IsMenuMotorSetting = item.Level3.IsMenuMotor;
|
|
structItem.IsMenuUpdate = item.Level3.IsMenuUpdate;
|
|
structItem.IsMenuFactoryReset = item.Level3.IsMenuInitialization;
|
|
structItem.IsMenuEquipmentSetting = item.Level3.IsMenuEquipment;
|
|
structItem.IsMenuIOTest = item.Level3.IsMenuIOTest;
|
|
structItem.IsMenuDataStatistics = item.Level3.IsMenuStatistics;
|
|
structItem.IsMenuUserSetting = item.Level3.IsMenuUser;
|
|
structItem.IsMenuUserGroupSetting = item.Level3.IsMenuUserGroupEditor;
|
|
structItem.IsMenuDataViewer = item.Level3.IsMenuViewer;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, (int)DataStore.E_UserGroup_FileIndex.f2_Level3);
|
|
#endregion
|
|
|
|
#region NotLogin
|
|
structItem.IsMainDisplayProductNo = item.NotLogin.IsMainDisplayProductNo;
|
|
structItem.IsMainDisplayWeightSetting = item.NotLogin.IsMainDisplayWeightSetting;
|
|
structItem.IsMainDisplayClear = item.NotLogin.IsMainDisplayClear;
|
|
structItem.IsMainDisplaySubMenu = item.NotLogin.IsMainDisplaySubMenu;
|
|
|
|
structItem.IsMenuTimeSetting = item.NotLogin.IsMenuTime;
|
|
structItem.IsMenuInformation = item.NotLogin.IsMenuInformation;
|
|
structItem.IsMenuDataBackup = item.NotLogin.IsMenuDataBackup;
|
|
structItem.IsMenuCalibration = item.NotLogin.IsMenuCalibration;
|
|
structItem.IsMenuCommunication = item.NotLogin.IsMenuCommunication;
|
|
structItem.IsMenuConfiguration = item.NotLogin.IsMenuConfiguration;
|
|
structItem.IsMenuSystemSetting = item.NotLogin.IsMenuSystem;
|
|
structItem.IsMenuMotorSetting = item.NotLogin.IsMenuMotor;
|
|
structItem.IsMenuUpdate = item.NotLogin.IsMenuUpdate;
|
|
structItem.IsMenuFactoryReset = item.NotLogin.IsMenuInitialization;
|
|
structItem.IsMenuEquipmentSetting = item.NotLogin.IsMenuEquipment;
|
|
structItem.IsMenuIOTest = item.NotLogin.IsMenuIOTest;
|
|
structItem.IsMenuDataStatistics = item.NotLogin.IsMenuStatistics;
|
|
structItem.IsMenuUserSetting = item.NotLogin.IsMenuUser;
|
|
structItem.IsMenuUserGroupSetting = item.NotLogin.IsMenuUserGroupEditor;
|
|
structItem.IsMenuDataViewer = item.NotLogin.IsMenuViewer;
|
|
|
|
structItem.Dummy1 = false;
|
|
structItem.Dummy2 = false;
|
|
structItem.Dummy3 = false;
|
|
structItem.Dummy4 = false;
|
|
structItem.Dummy5 = false;
|
|
structItem.Dummy6 = false;
|
|
structItem.Dummy7 = false;
|
|
structItem.Dummy8 = false;
|
|
structItem.Dummy9 = false;
|
|
structItem.Dummy10 = false;
|
|
structItem.Dummy11 = false;
|
|
structItem.Dummy12 = false;
|
|
structItem.Dummy13 = false;
|
|
structItem.Dummy14 = false;
|
|
structItem.Dummy15 = false;
|
|
structItem.Dummy16 = false;
|
|
structItem.Dummy17 = false;
|
|
structItem.Dummy18 = false;
|
|
structItem.Dummy19 = false;
|
|
structItem.Dummy20 = false;
|
|
|
|
this.smartFileIO.WriteStructure_Begin(structItem, (int)DataStore.E_UserGroup_FileIndex.f3_NotLogin);
|
|
#endregion
|
|
|
|
this.smartFileIO.WriteStructure_End();
|
|
this.smartFileIO.Close();
|
|
}
|
|
private void LoadUserGroupFile(ref UserGroup item)
|
|
{
|
|
string fullFilePath = "";
|
|
bool fileCheck = false;
|
|
StructUserGroupItem structItem;
|
|
|
|
fullFilePath = this.PathSystemFileFolder + "UserGroup.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.CreateUserGroupFile();
|
|
}
|
|
|
|
try
|
|
{
|
|
if (this.smartFileIO.ReadStructureAllBuffer() == true)
|
|
{
|
|
#region Level1
|
|
structItem = (StructUserGroupItem)this.smartFileIO.ReadStructureBuffer(typeof(StructUserGroupItem), (int)DataStore.E_UserGroup_FileIndex.f0_Level1);
|
|
|
|
item.Level1.IsMainDisplayProductNo = structItem.IsMainDisplayProductNo;
|
|
item.Level1.IsMainDisplayWeightSetting = structItem.IsMainDisplayWeightSetting;
|
|
item.Level1.IsMainDisplayClear = structItem.IsMainDisplayClear;
|
|
item.Level1.IsMainDisplaySubMenu = structItem.IsMainDisplaySubMenu;
|
|
|
|
item.Level1.IsMenuTime = structItem.IsMenuTimeSetting;
|
|
item.Level1.IsMenuInformation = structItem.IsMenuInformation;
|
|
item.Level1.IsMenuDataBackup = structItem.IsMenuDataBackup;
|
|
item.Level1.IsMenuCalibration = structItem.IsMenuCalibration;
|
|
item.Level1.IsMenuCommunication = structItem.IsMenuCommunication;
|
|
item.Level1.IsMenuConfiguration = structItem.IsMenuConfiguration;
|
|
item.Level1.IsMenuSystem = structItem.IsMenuSystemSetting;
|
|
item.Level1.IsMenuMotor = structItem.IsMenuMotorSetting;
|
|
item.Level1.IsMenuUpdate = structItem.IsMenuUpdate;
|
|
item.Level1.IsMenuInitialization = structItem.IsMenuFactoryReset;
|
|
item.Level1.IsMenuEquipment = structItem.IsMenuEquipmentSetting;
|
|
item.Level1.IsMenuIOTest = structItem.IsMenuIOTest;
|
|
item.Level1.IsMenuStatistics = structItem.IsMenuDataStatistics;
|
|
item.Level1.IsMenuUser = true;
|
|
item.Level1.IsMenuUserGroupEditor = structItem.IsMenuUserGroupSetting;
|
|
item.Level1.IsMenuViewer = structItem.IsMenuDataViewer;
|
|
#endregion
|
|
|
|
#region Level2
|
|
structItem = (StructUserGroupItem)this.smartFileIO.ReadStructureBuffer(typeof(StructUserGroupItem), (int)DataStore.E_UserGroup_FileIndex.f1_Level2);
|
|
|
|
item.Level2.IsMainDisplayProductNo = structItem.IsMainDisplayProductNo;
|
|
item.Level2.IsMainDisplayWeightSetting = structItem.IsMainDisplayWeightSetting;
|
|
item.Level2.IsMainDisplayClear = structItem.IsMainDisplayClear;
|
|
item.Level2.IsMainDisplaySubMenu = structItem.IsMainDisplaySubMenu;
|
|
|
|
item.Level2.IsMenuTime = structItem.IsMenuTimeSetting;
|
|
item.Level2.IsMenuInformation = structItem.IsMenuInformation;
|
|
item.Level2.IsMenuDataBackup = structItem.IsMenuDataBackup;
|
|
item.Level2.IsMenuCalibration = structItem.IsMenuCalibration;
|
|
item.Level2.IsMenuCommunication = structItem.IsMenuCommunication;
|
|
item.Level2.IsMenuConfiguration = structItem.IsMenuConfiguration;
|
|
item.Level2.IsMenuSystem = structItem.IsMenuSystemSetting;
|
|
item.Level2.IsMenuMotor = structItem.IsMenuMotorSetting;
|
|
item.Level2.IsMenuUpdate = structItem.IsMenuUpdate;
|
|
item.Level2.IsMenuInitialization = structItem.IsMenuFactoryReset;
|
|
item.Level2.IsMenuEquipment = structItem.IsMenuEquipmentSetting;
|
|
item.Level2.IsMenuIOTest = structItem.IsMenuIOTest;
|
|
item.Level2.IsMenuStatistics = structItem.IsMenuDataStatistics;
|
|
item.Level2.IsMenuUser = true;
|
|
item.Level2.IsMenuUserGroupEditor = structItem.IsMenuUserGroupSetting;
|
|
item.Level2.IsMenuViewer = structItem.IsMenuDataViewer;
|
|
#endregion
|
|
|
|
#region Level3
|
|
structItem = (StructUserGroupItem)this.smartFileIO.ReadStructureBuffer(typeof(StructUserGroupItem), (int)DataStore.E_UserGroup_FileIndex.f2_Level3);
|
|
|
|
item.Level3.IsMainDisplayProductNo = structItem.IsMainDisplayProductNo;
|
|
item.Level3.IsMainDisplayWeightSetting = structItem.IsMainDisplayWeightSetting;
|
|
item.Level3.IsMainDisplayClear = structItem.IsMainDisplayClear;
|
|
item.Level3.IsMainDisplaySubMenu = structItem.IsMainDisplaySubMenu;
|
|
|
|
item.Level3.IsMenuTime = structItem.IsMenuTimeSetting;
|
|
item.Level3.IsMenuInformation = structItem.IsMenuInformation;
|
|
item.Level3.IsMenuDataBackup = structItem.IsMenuDataBackup;
|
|
item.Level3.IsMenuCalibration = structItem.IsMenuCalibration;
|
|
item.Level3.IsMenuCommunication = structItem.IsMenuCommunication;
|
|
item.Level3.IsMenuConfiguration = structItem.IsMenuConfiguration;
|
|
item.Level3.IsMenuSystem = structItem.IsMenuSystemSetting;
|
|
item.Level3.IsMenuMotor = structItem.IsMenuMotorSetting;
|
|
item.Level3.IsMenuUpdate = structItem.IsMenuUpdate;
|
|
item.Level3.IsMenuInitialization = structItem.IsMenuFactoryReset;
|
|
item.Level3.IsMenuEquipment = structItem.IsMenuEquipmentSetting;
|
|
item.Level3.IsMenuIOTest = structItem.IsMenuIOTest;
|
|
item.Level3.IsMenuStatistics = structItem.IsMenuDataStatistics;
|
|
item.Level3.IsMenuUser = true;
|
|
item.Level3.IsMenuUserGroupEditor = structItem.IsMenuUserGroupSetting;
|
|
item.Level3.IsMenuViewer = structItem.IsMenuDataViewer;
|
|
#endregion
|
|
|
|
#region NotLogin
|
|
structItem = (StructUserGroupItem)this.smartFileIO.ReadStructureBuffer(typeof(StructUserGroupItem), (int)DataStore.E_UserGroup_FileIndex.f3_NotLogin);
|
|
|
|
item.NotLogin.IsMainDisplayProductNo = structItem.IsMainDisplayProductNo;
|
|
item.NotLogin.IsMainDisplayWeightSetting = structItem.IsMainDisplayWeightSetting;
|
|
item.NotLogin.IsMainDisplayClear = structItem.IsMainDisplayClear;
|
|
item.NotLogin.IsMainDisplaySubMenu = structItem.IsMainDisplaySubMenu;
|
|
|
|
item.NotLogin.IsMenuTime = structItem.IsMenuTimeSetting;
|
|
item.NotLogin.IsMenuInformation = structItem.IsMenuInformation;
|
|
item.NotLogin.IsMenuDataBackup = structItem.IsMenuDataBackup;
|
|
item.NotLogin.IsMenuCalibration = structItem.IsMenuCalibration;
|
|
item.NotLogin.IsMenuCommunication = structItem.IsMenuCommunication;
|
|
item.NotLogin.IsMenuConfiguration = structItem.IsMenuConfiguration;
|
|
item.NotLogin.IsMenuSystem = structItem.IsMenuSystemSetting;
|
|
item.NotLogin.IsMenuMotor = structItem.IsMenuMotorSetting;
|
|
item.NotLogin.IsMenuUpdate = structItem.IsMenuUpdate;
|
|
item.NotLogin.IsMenuInitialization = structItem.IsMenuFactoryReset;
|
|
item.NotLogin.IsMenuEquipment = structItem.IsMenuEquipmentSetting;
|
|
item.NotLogin.IsMenuIOTest = structItem.IsMenuIOTest;
|
|
item.NotLogin.IsMenuStatistics = structItem.IsMenuDataStatistics;
|
|
item.NotLogin.IsMenuUser = false;
|
|
item.NotLogin.IsMenuUserGroupEditor = structItem.IsMenuUserGroupSetting;
|
|
item.NotLogin.IsMenuViewer = structItem.IsMenuDataViewer;
|
|
#endregion
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DialogFormMessage myMsg = new DialogFormMessage(17, this.SystemConfig.Language);
|
|
myMsg.ShowDialog();
|
|
|
|
this.smartFileIO.Close();
|
|
}
|
|
this.smartFileIO.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region Data Backup
|
|
private void DeleteLogFile(string path, DataStore.E_DataType type)
|
|
{
|
|
string dataFolderPath = "";
|
|
|
|
switch (type)
|
|
{
|
|
case DataStore.E_DataType.None:
|
|
break;
|
|
case DataStore.E_DataType.History:
|
|
dataFolderPath = this.PathDataHistoryFolder;
|
|
break;
|
|
case DataStore.E_DataType.Inspection:
|
|
dataFolderPath = this.PathDataInspectionFolder;
|
|
break;
|
|
case DataStore.E_DataType.Others:
|
|
dataFolderPath = this.PathDataOthersFolder;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
foreach (string Folder in Directory.GetDirectories(path))
|
|
{
|
|
this.DeleteLogFile(Folder, type); //재귀함수 호출
|
|
if (Directory.GetDirectories(Folder).Count() == 0 && Directory.GetFiles(Folder).Count() == 0 && Folder != dataFolderPath)
|
|
Directory.Delete(Folder, true);
|
|
}
|
|
|
|
foreach (string file in Directory.GetFiles(path))
|
|
{
|
|
FileInfo fi = new FileInfo(file);
|
|
if (DateTime.ParseExact(fi.Name.Substring(1, 8), "yyyyMMdd", null) < DateTime.Now.AddMonths(-1 * this.SystemConfig.DataStoragePeriod))
|
|
fi.Delete();
|
|
}
|
|
}
|
|
|
|
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}_{3}.csv", this.PathDataBackupFolder, DateTime.Now, this.SystemConfig.ProductNumber, 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");
|
|
sw.Write(",");
|
|
sw.Write("UnderRange");
|
|
sw.Write(",");
|
|
sw.Write("PassRange");
|
|
sw.Write(",");
|
|
sw.Write("OverRange");
|
|
sw.Write(",");
|
|
sw.Write("TareRange");
|
|
|
|
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);
|
|
sw.Write(",");
|
|
sw.Write(Helper.StringToDecimalPlaces(this.CurrentProductItem.UnderRange, this.SystemConfig.DecimalPlaces));
|
|
sw.Write(",");
|
|
sw.Write(Helper.StringToDecimalPlaces(this.CurrentProductItem.PassRange, this.SystemConfig.DecimalPlaces));
|
|
sw.Write(",");
|
|
sw.Write(Helper.StringToDecimalPlaces(this.CurrentProductItem.OverRange, this.SystemConfig.DecimalPlaces));
|
|
sw.Write(",");
|
|
sw.Write(Helper.StringToDecimalPlaces(this.CurrentProductItem.TareRange, this.SystemConfig.DecimalPlaces));
|
|
|
|
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 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
|
|
#region Tracking History data
|
|
public void SetTrackingHistoryData(DataStore.TrackingOperation type, string detail)
|
|
{
|
|
if (this.SystemConfig.IsOptPart11 == false)
|
|
return;
|
|
|
|
HistoryData data = new HistoryData();
|
|
|
|
data.Type = "Operation";
|
|
data.Time = DateTime.Now;
|
|
data.LoginID = this.SystemConfig.CurrentUser.ID;
|
|
data.Event = type.ToString();
|
|
data.Detail = detail;
|
|
data.BeforeData = "";
|
|
data.AfterData = "";
|
|
|
|
this.TrackingHistoryData(data);
|
|
}
|
|
public void SetTrackingHistoryData(DataStore.TrackingAlarm type, string detail)
|
|
{
|
|
if (this.SystemConfig.IsOptPart11 == false)
|
|
return;
|
|
|
|
HistoryData data = new HistoryData();
|
|
|
|
data.Type = "Alarm";
|
|
data.Time = DateTime.Now;
|
|
data.LoginID = this.SystemConfig.CurrentUser.ID;
|
|
data.Event = type.ToString();
|
|
data.Detail = detail;
|
|
data.BeforeData = "";
|
|
data.AfterData = "";
|
|
|
|
this.TrackingHistoryData(data);
|
|
}
|
|
public void SetTrackingHistoryData(DataStore.TrackingParameter type, string detail, string before, string after)
|
|
{
|
|
if (this.SystemConfig.IsOptPart11 == false)
|
|
return;
|
|
|
|
if (before == after)
|
|
return;
|
|
|
|
HistoryData data = new HistoryData();
|
|
|
|
data.Type = "Parameter";
|
|
data.Time = DateTime.Now;
|
|
data.LoginID = this.SystemConfig.CurrentUser.ID;
|
|
data.Event = type.ToString();
|
|
data.Detail = detail;
|
|
data.BeforeData = before;
|
|
data.AfterData = after;
|
|
|
|
this.TrackingHistoryData(data);
|
|
}
|
|
|
|
private void TrackingHistoryData(HistoryData data)
|
|
{
|
|
bool fileCheck = false, directoryCheck = false;
|
|
string fullFilePath = "", folderPath = "", fileName = "";
|
|
StreamWriter sw;
|
|
DateTime time = DateTime.Now;
|
|
|
|
folderPath = string.Format("{0}{1}\\{2}\\", this.PathDataHistoryFolder, time.Year, time.Month);
|
|
fileName = string.Format("H{0:yyyyMMdd}.csv", time);
|
|
|
|
fullFilePath = string.Format("{0}{1}", folderPath, fileName);
|
|
|
|
DirectoryInfo di = new DirectoryInfo(folderPath);
|
|
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)
|
|
{
|
|
this.RemoveHistoryDataFile();
|
|
|
|
sw.Write("Date");
|
|
sw.Write(",");
|
|
sw.Write("Time");
|
|
sw.Write(",");
|
|
sw.Write("LoginID");
|
|
sw.Write(",");
|
|
sw.Write("Event");
|
|
sw.Write(",");
|
|
sw.Write("Detail");
|
|
sw.Write(",");
|
|
sw.Write("Before");
|
|
sw.Write(",");
|
|
sw.Write("After");
|
|
sw.Write(",");
|
|
sw.Write("Type");
|
|
|
|
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(data.LoginID);
|
|
sw.Write(",");
|
|
sw.Write(data.Event.ToString());
|
|
sw.Write(",");
|
|
sw.Write(data.Detail);
|
|
sw.Write(",");
|
|
sw.Write(data.BeforeData);
|
|
sw.Write(",");
|
|
sw.Write(data.AfterData);
|
|
sw.Write(",");
|
|
sw.Write(data.Type);
|
|
sw.WriteLine();
|
|
|
|
sw.Close();
|
|
}
|
|
private void RemoveHistoryDataFile()
|
|
{
|
|
try
|
|
{
|
|
this.DeleteLogFile(this.PathDataHistoryFolder, DataStore.E_DataType.History);
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Modbus
|
|
public void ModbusInitizlise()
|
|
{
|
|
this.Update30000ModbusData();
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.Update30000ModbusData(i);
|
|
}
|
|
|
|
public static byte[] GetBytes(int argument)
|
|
{
|
|
byte[] byteArray = BitConverter.GetBytes(argument);
|
|
return byteArray;
|
|
}
|
|
public static byte[] GetBytes(Single argument)
|
|
{
|
|
byte[] byteArray = BitConverter.GetBytes(argument);
|
|
return byteArray;
|
|
}
|
|
public static byte[] GetBytes(uint argument)
|
|
{
|
|
byte[] byteArray = BitConverter.GetBytes(argument);
|
|
return byteArray;
|
|
}
|
|
|
|
public ushort Grade(DataStore.JudgmentStatus status)
|
|
{
|
|
ushort judgmentStatus = 0;
|
|
|
|
switch (status)
|
|
{
|
|
case DataStore.JudgmentStatus.Pass:
|
|
judgmentStatus = 1;
|
|
break;
|
|
case DataStore.JudgmentStatus.Over:
|
|
judgmentStatus = 2;
|
|
break;
|
|
case DataStore.JudgmentStatus.Under:
|
|
judgmentStatus = 3;
|
|
break;
|
|
case DataStore.JudgmentStatus.Double:
|
|
case DataStore.JudgmentStatus.ExNG:
|
|
case DataStore.JudgmentStatus.SensorError:
|
|
judgmentStatus = 4;
|
|
break;
|
|
default:
|
|
judgmentStatus = 0;
|
|
break;
|
|
}
|
|
|
|
return judgmentStatus;
|
|
}
|
|
|
|
private void Update30000UpdateData(int index)
|
|
{
|
|
if (this.CollectionWeightData[index].UpdateCount > 65535)
|
|
this.CollectionWeightData[index].UpdateCount = 0;
|
|
else
|
|
this.CollectionWeightData[index].UpdateCount++;
|
|
|
|
this.Current30000ModbusData.LaneModbusData[index].Update = this.CollectionWeightData[index].UpdateCount;
|
|
}
|
|
public void Update30000ModbusData()
|
|
{
|
|
for (int i = 0; i < this.SystemConfig.EquipmentColumns; i++)
|
|
this.Update30000UpdateData(i);
|
|
|
|
this.Current30000ModbusData.UnderValue = Helper.StringToWeight(this.CurrentProductItem.UnderRange, this.SystemConfig.DecimalPlaces);
|
|
this.Current30000ModbusData.PassValue = Helper.StringToWeight(this.CurrentProductItem.PassRange, this.SystemConfig.DecimalPlaces);
|
|
this.Current30000ModbusData.OverValue = Helper.StringToWeight(this.CurrentProductItem.OverRange, this.SystemConfig.DecimalPlaces);
|
|
this.Current30000ModbusData.TareValue = Helper.StringToWeight(this.CurrentProductItem.TareRange, this.SystemConfig.DecimalPlaces);
|
|
}
|
|
public void Update30000ModbusData(int index)
|
|
{
|
|
this.Update30000UpdateData(index);
|
|
|
|
this.Current30000ModbusData.LaneModbusData[index].Grade = this.Grade(this.CollectionWeightData[index].JudgmentStatus);
|
|
this.Current30000ModbusData.LaneModbusData[index].Weight = this.CollectionWeightData[index].Weight;
|
|
this.Current30000ModbusData.LaneModbusData[index].UnderCount = (UInt32)this.CollectionWeightData[index].UnderCount;
|
|
this.Current30000ModbusData.LaneModbusData[index].PassCount = (UInt32)this.CollectionWeightData[index].PassCount;
|
|
this.Current30000ModbusData.LaneModbusData[index].OverCount = (UInt32)this.CollectionWeightData[index].OverCount;
|
|
this.Current30000ModbusData.LaneModbusData[index].ExNGCount = (UInt32)this.CollectionWeightData[index].ExNGCount;
|
|
}
|
|
|
|
// Common 값 변경 시 통신전송
|
|
public void ModbusCommonDataSend()
|
|
{
|
|
// 이더넷
|
|
if (this.SystemConfig.EthernetOperationMode == 1)
|
|
{
|
|
byte[] etherByteData = this.Modbus.WriteMultipleRegisterTCP(this.Protocol_Modbus_Client_Write_Common_Data(), 1010);
|
|
|
|
if (this.smartTCPMultiServer.ClientInfoList != null)
|
|
{
|
|
foreach (SmartTCPMultiServer.CLIENTSINFOS info in this.smartTCPMultiServer.ClientInfoList)
|
|
this.EthernetServerSendMessage(info, etherByteData);
|
|
}
|
|
}
|
|
else if (this.SystemConfig.EthernetOperationMode == 2)
|
|
{
|
|
byte[] etherByteData = this.Modbus.WriteMultipleRegisterTCP(
|
|
this.Protocol_Modbus_Client_Write_Common_Data(), this.SystemConfig.ModbusTcpStartAddress);
|
|
this.EthernetWeightDataForModbus(etherByteData);
|
|
}
|
|
}
|
|
// Lane Test 통신전송
|
|
public void ModbusLaneTestDataSend(int lane)
|
|
{
|
|
// 이더넷
|
|
if (this.SystemConfig.EthernetOperationMode == 1)
|
|
{
|
|
byte[] etherByteData = this.Modbus.WriteMultipleRegisterTCP(this.Protocol_Modbus_Client_Write_Common_Data(), 1010 + 140 + (lane * 50));
|
|
|
|
if (this.smartTCPMultiServer.ClientInfoList != null)
|
|
{
|
|
foreach (SmartTCPMultiServer.CLIENTSINFOS info in this.smartTCPMultiServer.ClientInfoList)
|
|
this.EthernetServerSendMessage(info, etherByteData);
|
|
}
|
|
}
|
|
else if (this.SystemConfig.EthernetOperationMode == 2)
|
|
{
|
|
byte[] etherByteData = this.Modbus.WriteMultipleRegisterTCP(
|
|
this.Protocol_Modbus_Client_Write_Lane_Test_Data(lane), this.SystemConfig.ModbusTcpStartAddress + 140 + (lane * 50));
|
|
this.EthernetWeightDataForModbus(etherByteData);
|
|
}
|
|
}
|
|
public byte[] Protocol_Modbus_Client_Write_Lane_Test_Data(int laneIndex)
|
|
{
|
|
int index = 0;
|
|
byte[] madeData = new byte[32];
|
|
byte[] length4Value = new byte[4];
|
|
byte[] length2Value = new byte[2];
|
|
|
|
var random = new Random();
|
|
Single ranDouble = Single.Parse(string.Format("{0:F2}", random.NextDouble()));
|
|
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[i] = length2Value[1 - i];
|
|
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[2 + i] = length2Value[1 - i];
|
|
|
|
length4Value = GetBytes(ranDouble + random.Next(999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[4 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(random.Next(9999999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[8 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(random.Next(9999999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[12 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(random.Next(9999999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[16 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(random.Next(9999999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[20 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(random.Next(9999999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[24 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(random.Next(9999999));
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[28 + i] = length4Value[3 - i];
|
|
|
|
return madeData;
|
|
}
|
|
/// <summary>
|
|
/// Modbus TCP - Write Multiple Register에 대한 Manage 메소드
|
|
/// </summary>
|
|
/// <param name="readByte">전송받은 Modbus Data</param>
|
|
public void ReceiveModbusTCPWriteManager(byte[] readByte)
|
|
{
|
|
int startAddressInt;
|
|
int numberOfRegisterInt;
|
|
float floatNum;
|
|
byte[] startAddressByte = new byte[2] { readByte[8], readByte[9] };
|
|
byte[] numberOfRegisterByte = new byte[2] { readByte[10], readByte[11] };
|
|
|
|
int madeDataIndex = 0;
|
|
byte[] Length2Value = new byte[2];
|
|
byte[] Length4Value = new byte[4];
|
|
byte[] Length12Value = new byte[12];
|
|
byte[] Length14Value = new byte[14];
|
|
|
|
startAddressInt = Modbus.ToBigEndianAndInt(startAddressByte);
|
|
numberOfRegisterInt = Modbus.ToBigEndianAndInt(numberOfRegisterByte);
|
|
|
|
for (int j = startAddressInt; j < startAddressInt + numberOfRegisterInt; j++)
|
|
{
|
|
switch (j)
|
|
{
|
|
#region Change data
|
|
case _40000_ModbusAddress._01_Clear:
|
|
#region 40011_소거 요청
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40011_Clear = Modbus.ToBigEndianAndInt(Length2Value);
|
|
|
|
if (this.Current40000ModbusData._40011_Clear == 1)
|
|
{
|
|
try
|
|
{
|
|
this.ChildFormMainDisplay.Clear();
|
|
this.Current40000ModbusData._40011_Clear = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40012_ClearResult = 1;
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40012_ClearResult = 2;
|
|
}
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._02_ClearResult:
|
|
#region 40012_소거 요청 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40012_ClearResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._03_Operation:
|
|
#region 40013_운전/정지 요청, 1:운전/2:정지
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40013_Operation = Modbus.ToBigEndianAndInt(Length2Value);
|
|
|
|
if (this.Current40000ModbusData._40013_Operation != 0)
|
|
{
|
|
try
|
|
{
|
|
if (this.Current40000ModbusData._40013_Operation == 1)
|
|
this.TransferData(CommunicationCommand.Start, CommunicationID.MainBoard);
|
|
else
|
|
this.TransferData(CommunicationCommand.Stop, CommunicationID.MainBoard);
|
|
|
|
this.Current40000ModbusData._40013_Operation = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40014_OperationResult = 1;
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40014_OperationResult = 2;
|
|
}
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._04_OperationResult:
|
|
#region 40014_운전/정지 요청 수행 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40014_OperationResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._05_ProductChange_High:
|
|
#region 40015_품번 변경 요청
|
|
for (int i = 0; i < 4; i++)
|
|
Length4Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40015_ProductChange = Modbus.ToBigEndianAndInt(Length4Value);
|
|
|
|
if (this.Current40000ModbusData._40015_ProductChange != 0)
|
|
{
|
|
try
|
|
{
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
{
|
|
if (this.Current40000ModbusData._40015_ProductChange >= 1
|
|
&& this.Current40000ModbusData._40015_ProductChange <= 1000)
|
|
this.ChildFormMainDisplay.ProductChange(this.Current40000ModbusData._40015_ProductChange);
|
|
|
|
this.Current40000ModbusData._40015_ProductChange = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40017_ProductChangeResult = 1;
|
|
}
|
|
else
|
|
{
|
|
this.Current40000ModbusData._40015_ProductChange = 0;
|
|
this.Current40000ModbusData._40017_ProductChangeResult = 2;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40017_ProductChangeResult = 2;
|
|
}
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._07_ProductChangeResult:
|
|
#region 40017_품번 변경 요청 수행 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40017_ProductChangeResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._08_UnderRange_High:
|
|
#region 40018_Under 중량설정 요청
|
|
for (int i = 0; i < 4; i++)
|
|
Length4Value[i] = readByte[13 + madeDataIndex + i];
|
|
floatNum = Modbus.ToBigEndianAndFloat(Length4Value);
|
|
this.Current40000ModbusData._40018_UnderRange =
|
|
int.Parse(Helper.DoubleToString((double)floatNum, this.SystemConfig.DecimalPlaces).Replace(".", ""));
|
|
|
|
if (this.Current40000ModbusData._40018_UnderRange >= 0 && this.Current40000ModbusData._40018_UnderRange <= 99999)
|
|
{
|
|
try
|
|
{
|
|
this.CurrentProductItem.UnderRange = this.Current40000ModbusData._40018_UnderRange.ToString();
|
|
|
|
this.SaveProductFile(this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
this.TransferProductParameter(this.SystemConfig.ProductNumber);
|
|
|
|
this.Update30000ModbusData();
|
|
this.ModbusCommonDataSend();
|
|
this.ChildFormMainDisplay.UpdateCurrentProductDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem, this.CollectionWeightData);
|
|
|
|
// 초기값으로 설정해놓기
|
|
this.Current40000ModbusData._40018_UnderRange = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40020_UnderRangeResult = 1;
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40020_UnderRangeResult = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40020_UnderRangeResult = 2;
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._10_UnderRangeResult:
|
|
#region 40020_Under 중량설정 요청 수행 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40020_UnderRangeResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._11_PassRange_High:
|
|
#region 40021_Pass 중량설정 요청
|
|
for (int i = 0; i < 4; i++)
|
|
Length4Value[i] = readByte[13 + madeDataIndex + i];
|
|
floatNum = Modbus.ToBigEndianAndFloat(Length4Value);
|
|
this.Current40000ModbusData._40021_PassRange =
|
|
int.Parse(Helper.DoubleToString((double)floatNum, this.SystemConfig.DecimalPlaces).Replace(".", ""));
|
|
|
|
if (this.Current40000ModbusData._40021_PassRange >= 0 && this.Current40000ModbusData._40021_PassRange <= 99999)
|
|
{
|
|
try
|
|
{
|
|
string value = "";
|
|
int digit = 0, temp = 0;
|
|
|
|
this.CurrentProductItem.PassRange = this.Current40000ModbusData._40021_PassRange.ToString();
|
|
|
|
this.SaveProductFile(this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
this.TransferProductParameter(this.SystemConfig.ProductNumber);
|
|
|
|
this.Update30000ModbusData();
|
|
this.ModbusCommonDataSend();
|
|
this.ChildFormMainDisplay.UpdateCurrentProductDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem, this.CollectionWeightData);
|
|
|
|
// 초기값으로 설정해놓기
|
|
this.Current40000ModbusData._40021_PassRange = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40023_PassRangeResult = 1;
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40023_PassRangeResult = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40023_PassRangeResult = 2;
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._13_PassRangeResult:
|
|
#region 40023_Pass 중량설정 요청 수행 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40023_PassRangeResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._14_OverRange_High:
|
|
#region 40024_Over 중량설정 요청
|
|
for (int i = 0; i < 4; i++)
|
|
Length4Value[i] = readByte[13 + madeDataIndex + i];
|
|
floatNum = Modbus.ToBigEndianAndFloat(Length4Value);
|
|
this.Current40000ModbusData._40024_OverRange =
|
|
int.Parse(Helper.DoubleToString((double)floatNum, this.SystemConfig.DecimalPlaces).Replace(".", ""));
|
|
|
|
if (this.Current40000ModbusData._40024_OverRange >= 0 && this.Current40000ModbusData._40024_OverRange <= 99999)
|
|
{
|
|
try
|
|
{
|
|
this.CurrentProductItem.OverRange = this.Current40000ModbusData._40024_OverRange.ToString();
|
|
|
|
this.SaveProductFile(this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
this.TransferProductParameter(this.SystemConfig.ProductNumber);
|
|
|
|
this.Update30000ModbusData();
|
|
this.ModbusCommonDataSend();
|
|
this.ChildFormMainDisplay.UpdateCurrentProductDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem, this.CollectionWeightData);
|
|
|
|
// 초기값으로 설정해놓기
|
|
this.Current40000ModbusData._40024_OverRange = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40026_OverRangeResult = 1;
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40026_OverRangeResult = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40026_OverRangeResult = 2;
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._16_OverRangeResult:
|
|
#region 40026_Over 중량설정 요청 수행 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40026_OverRangeResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._17_TareWeight_High:
|
|
#region 40027_Tare 중량설정 요청
|
|
for (int i = 0; i < 4; i++)
|
|
Length4Value[i] = readByte[13 + madeDataIndex + i];
|
|
floatNum = Modbus.ToBigEndianAndFloat(Length4Value);
|
|
this.Current40000ModbusData._40027_TareWeight =
|
|
int.Parse(Helper.DoubleToString((double)floatNum, this.SystemConfig.DecimalPlaces).Replace(".", ""));
|
|
|
|
if (this.Current40000ModbusData._40027_TareWeight >= 0 && this.Current40000ModbusData._40027_TareWeight <= 99999)
|
|
{
|
|
try
|
|
{
|
|
this.CurrentProductItem.TareRange = this.Current40000ModbusData._40027_TareWeight.ToString();
|
|
|
|
this.SaveProductFile(this.CurrentProductItem, this.SystemConfig.ProductNumber - 1);
|
|
this.TransferProductParameter(this.SystemConfig.ProductNumber);
|
|
|
|
this.Update30000ModbusData();
|
|
this.ModbusCommonDataSend();
|
|
this.ChildFormMainDisplay.UpdateCurrentProductDisplay(this.EquipmentStatus, this.CurrentProductItem, this.CurrentJudgmentSetItem, this.CollectionWeightData);
|
|
|
|
// 초기값으로 설정해놓기
|
|
this.Current40000ModbusData._40027_TareWeight = 0;
|
|
|
|
// 성공
|
|
this.Current40000ModbusData._40029_TareWeightResult = 1;
|
|
}
|
|
catch
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40029_TareWeightResult = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 실패
|
|
this.Current40000ModbusData._40029_TareWeightResult = 2;
|
|
}
|
|
#endregion
|
|
break;
|
|
case _40000_ModbusAddress._19_TareWeightResult:
|
|
#region 40029_Tare 중량설정 요청 수행 결과
|
|
for (int i = 0; i < 2; i++)
|
|
Length2Value[i] = readByte[13 + madeDataIndex + i];
|
|
this.Current40000ModbusData._40029_TareWeightResult = Modbus.ToBigEndianAndInt(Length2Value);
|
|
#endregion
|
|
break;
|
|
default:
|
|
break;
|
|
#endregion
|
|
}
|
|
madeDataIndex += 2;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Communication Protocol
|
|
private string Protocol_STD1_NotStxEtx(SystemConfigurationItem system, Collection<WeightData> datas)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(string.Format("IN{0:D3}", system.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", system.ProductNumber));
|
|
|
|
for (int i = 0; i < system.EquipmentColumns; i++)
|
|
{
|
|
if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Pass)
|
|
sb.Append("P");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("E");
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.DoubleToString(datas[i].Weight, system.DecimalPlaces)));
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_STD1(SystemConfigurationItem system, Collection<WeightData> datas)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(this.Protocol_STD1_NotStxEtx(system, datas));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
private string Protocol_STD1_NotStxEtx(SystemConfigurationItem system, WeightData data, int lane)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(string.Format("IN{0:D3}", system.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", system.ProductNumber));
|
|
sb.Append(string.Format("{0:D2}", lane));
|
|
|
|
if (data.JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Pass)
|
|
sb.Append("P");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("E");
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.DoubleToString(data.Weight, system.DecimalPlaces)));
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_STD1(SystemConfigurationItem system, WeightData data, int lane)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(this.Protocol_STD1_NotStxEtx(system, data, lane));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private string Protocol_STD2_NotStxEtx(SystemConfigurationItem system, Collection<WeightData> datas, ProductItem pItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(string.Format("IN{0:D3}", system.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", system.ProductNumber));
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.UnderRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.PassRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.OverRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.TareRange, system.DecimalPlaces)));
|
|
|
|
for (int i = 0; i < system.EquipmentColumns; i++)
|
|
{
|
|
if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Pass)
|
|
sb.Append("P");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("E");
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.DoubleToString(datas[i].Weight, system.DecimalPlaces)));
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_STD2(SystemConfigurationItem system, Collection<WeightData> datas, ProductItem pItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(this.Protocol_STD2_NotStxEtx(system, datas, pItem));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
private string Protocol_STD2_NotStxEtx(SystemConfigurationItem system, WeightData data, int lane, ProductItem pItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(string.Format("IN{0:D3}", system.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", system.ProductNumber));
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.UnderRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.PassRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.OverRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.TareRange, system.DecimalPlaces)));
|
|
sb.Append(string.Format("{0:D2}", lane));
|
|
|
|
if (data.JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Pass)
|
|
sb.Append("P");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("E");
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.DoubleToString(data.Weight, system.DecimalPlaces)));
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_STD2(SystemConfigurationItem system, WeightData data, int lane, ProductItem pItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(this.Protocol_STD2_NotStxEtx(system, data, lane, pItem));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private string Protocol_STD3_NotStxEtx(SystemConfigurationItem system, Collection<WeightData> datas, ProductItem pItem)
|
|
{
|
|
int toTalAll = 0, toTalPass = 0, totalNg = 0;
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
for (int i = 0; i < system.EquipmentColumns; i++)
|
|
{
|
|
toTalAll += datas[i].TotalCount;
|
|
toTalPass += datas[i].PassCount;
|
|
totalNg += datas[i].TotalNGCount;
|
|
}
|
|
|
|
sb.Append(string.Format("IN{0:D3}", system.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", system.ProductNumber));
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.UnderRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.PassRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.OverRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.TareRange, system.DecimalPlaces)));
|
|
|
|
sb.Append(Helper.StringBlankFillDigits7(toTalPass.ToString()));
|
|
sb.Append(Helper.StringBlankFillDigits7(totalNg.ToString()));
|
|
sb.Append(Helper.StringBlankFillDigits9(toTalAll.ToString()));
|
|
|
|
for (int i = 0; i < system.EquipmentColumns; i++)
|
|
{
|
|
if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Pass)
|
|
sb.Append("P");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (datas[i].JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("E");
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.DoubleToString(datas[i].Weight, system.DecimalPlaces)));
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_STD3(SystemConfigurationItem system, Collection<WeightData> datas, ProductItem pItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(this.Protocol_STD3_NotStxEtx(system, datas, pItem));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
private string Protocol_STD3_NotStxEtx(SystemConfigurationItem system, WeightData data, int lane, ProductItem pItem)
|
|
{
|
|
string value = "";
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(string.Format("IN{0:D3}", system.EquipmentID));
|
|
sb.Append(string.Format("{0:D4}", system.ProductNumber));
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.UnderRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.PassRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.OverRange, system.DecimalPlaces)));
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.StringToDecimalPlaces(pItem.TareRange, system.DecimalPlaces)));
|
|
|
|
sb.Append(Helper.StringBlankFillDigits7(data.PassCount.ToString()));
|
|
sb.Append(Helper.StringBlankFillDigits7(data.TotalNGCount.ToString()));
|
|
sb.Append(Helper.StringBlankFillDigits9(data.TotalCount.ToString()));
|
|
|
|
sb.Append(string.Format("{0:D2}", lane));
|
|
|
|
if (data.JudgmentStatus == DataStore.JudgmentStatus.Under)
|
|
sb.Append("U");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Pass)
|
|
sb.Append("P");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Over)
|
|
sb.Append("O");
|
|
else if (data.JudgmentStatus == DataStore.JudgmentStatus.Double)
|
|
sb.Append("D");
|
|
else
|
|
sb.Append("E");
|
|
|
|
sb.Append(Helper.StringBlankFillDigits6(Helper.DoubleToString(data.Weight, system.DecimalPlaces)));
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string Protocol_STD3(SystemConfigurationItem system, WeightData data, int lane, ProductItem pItem)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append((char)0x02);
|
|
sb.Append(this.Protocol_STD3_NotStxEtx(system, data, lane, pItem));
|
|
sb.Append((char)0x03);
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
public byte[] Protocol_Modbus_Client_Write_Common_Data()
|
|
{
|
|
int index = 0;
|
|
byte[] madeData = new byte[16];
|
|
byte[] length4Value = new byte[4];
|
|
byte[] length2Value = new byte[2];
|
|
|
|
double underValue = this.Current30000ModbusData.UnderValue; // Helper.StringToWeight(this.Current30000ModbusData.UnderRange, this.SystemConfig.DecimalPlaces);
|
|
double passValue = Helper.StringToWeight(this.CurrentProductItem.PassRange, this.SystemConfig.DecimalPlaces);
|
|
double overValue = Helper.StringToWeight(this.CurrentProductItem.OverRange, this.SystemConfig.DecimalPlaces);
|
|
double tareValue = Helper.StringToWeight(this.CurrentProductItem.TareRange, this.SystemConfig.DecimalPlaces);
|
|
|
|
#region 고정 Data(4개, 16 bytes)
|
|
// 하한값
|
|
length4Value = GetBytes((Single)underValue);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[i] = length4Value[3 - i];
|
|
|
|
// 기준값
|
|
length4Value = GetBytes((Single)passValue);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[4 + i] = length4Value[3 - i];
|
|
|
|
// 상한값
|
|
length4Value = GetBytes((Single)overValue);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[8 + i] = length4Value[3 - i];
|
|
|
|
// 용기값
|
|
length4Value = GetBytes((Single)tareValue);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[12 + i] = length4Value[3 - i];
|
|
#endregion
|
|
|
|
return madeData;
|
|
}
|
|
public byte[] Protocol_Modbus_Client_Write_Lane_Data(int laneIndex)
|
|
{
|
|
int index = 0;
|
|
byte[] madeData = new byte[32];
|
|
byte[] length4Value = new byte[4];
|
|
byte[] length2Value = new byte[2];
|
|
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[i] = length2Value[1 - i];
|
|
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[2 + i] = length2Value[1 - i];
|
|
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[laneIndex].Weight);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[4 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].UnderCount);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[8 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].PassCount);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[12 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].OverCount);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[16 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].NGCount);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[20 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].ExNGCount);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[24 + i] = length4Value[3 - i];
|
|
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[laneIndex].TotalCount);
|
|
for (int i = 0; i < 4; i++)
|
|
madeData[28 + i] = length4Value[3 - i];
|
|
|
|
return madeData;
|
|
}
|
|
private byte[] Protocol_Modbus_Server_Read_Lane_Data(byte[] readByte)
|
|
{
|
|
byte[] startAddressByte = new byte[2] { readByte[8], readByte[9] };
|
|
byte[] numberOfRegisterByte = new byte[2] { readByte[10], readByte[11] };
|
|
int startAddressInt;
|
|
int numberOfRegisterInt;
|
|
int madeDataIndex = 0;
|
|
byte[] length2Value = new byte[2];
|
|
byte[] length4Value = new byte[4];
|
|
|
|
startAddressInt = Modbus.ToBigEndianAndInt(startAddressByte);
|
|
numberOfRegisterInt = Modbus.ToBigEndianAndInt(numberOfRegisterByte);
|
|
|
|
byte[] madeData = new byte[numberOfRegisterInt * 2];
|
|
|
|
if (readByte[7] == ModbusFunctionCode.FunctionCode_03)
|
|
{
|
|
#region Read Holding Register(0x03)
|
|
for (int j = startAddressInt; j < startAddressInt + numberOfRegisterInt; j++)
|
|
{
|
|
switch (j)
|
|
{
|
|
#region Make data
|
|
case _40000_ModbusAddress._01_Clear:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40011_Clear);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._02_ClearResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40012_ClearResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._03_Operation:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40013_Operation);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._04_OperationResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40014_OperationResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._05_ProductChange_High:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40015_ProductChange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case _40000_ModbusAddress._06_ProductChange_Low:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40015_ProductChange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._07_ProductChangeResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40017_ProductChangeResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._08_UnderRange_High:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40018_UnderRange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case _40000_ModbusAddress._09_UnderRange_Low:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40018_UnderRange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._10_UnderRangeResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40020_UnderRangeResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._11_PassRange_High:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40021_PassRange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case _40000_ModbusAddress._12_PassRange_Low:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40021_PassRange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._13_PassRangeResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40023_PassRangeResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._14_OverRange_High:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40024_OverRange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case _40000_ModbusAddress._15_OverRange_Low:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40024_OverRange);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._16_OverRangeResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40026_OverRangeResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._17_TareWeight_High:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40027_TareWeight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case _40000_ModbusAddress._18_TareWeight_Low:
|
|
length4Value = GetBytes(this.Current40000ModbusData._40027_TareWeight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case _40000_ModbusAddress._19_TareWeightResult:
|
|
length2Value = GetBytes(this.Current40000ModbusData._40029_TareWeightResult);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
default:
|
|
break;
|
|
#endregion
|
|
}
|
|
madeDataIndex += 2;
|
|
}
|
|
#endregion
|
|
}
|
|
else if (readByte[7] == ModbusFunctionCode.FunctionCode_04)
|
|
{
|
|
#region Read Input Register(0x04)
|
|
double underValue = this.Current30000ModbusData.UnderValue;
|
|
double passValue = this.Current30000ModbusData.PassValue;
|
|
double overValue = this.Current30000ModbusData.OverValue;
|
|
double tareValue = this.Current30000ModbusData.TareValue;
|
|
double lowLimit = this.Current30000ModbusData.LowLimit;
|
|
double highLimit = this.Current30000ModbusData.HighLimit;
|
|
double deadZoneLow = this.Current30000ModbusData.DeadZoneLowLimit;
|
|
double deadZoneHigh = this.Current30000ModbusData.DeadZoneHighLimit;
|
|
|
|
int equipmentStatus;
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Start)
|
|
equipmentStatus = 1;
|
|
else
|
|
equipmentStatus = 0;
|
|
|
|
for (int j = startAddressInt; j < startAddressInt + numberOfRegisterInt; j++)
|
|
{
|
|
switch (j)
|
|
{
|
|
#region Common data
|
|
case (int)DataStore._30000_Modbus.UnderRange_High:
|
|
length4Value = GetBytes((Single)underValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.UnderRange_Low:
|
|
length4Value = GetBytes((Single)underValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.PassRange_High:
|
|
length4Value = GetBytes((Single)passValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.PassRange_Low:
|
|
length4Value = GetBytes((Single)passValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.OverRange_High:
|
|
length4Value = GetBytes((Single)overValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.OverRange_Low:
|
|
length4Value = GetBytes((Single)overValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.TareRange_High:
|
|
length4Value = GetBytes((Single)tareValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.TareRange_Low:
|
|
length4Value = GetBytes((Single)tareValue);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.HighLimit_High:
|
|
length4Value = GetBytes((Single)highLimit);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.HighLimit_Low:
|
|
length4Value = GetBytes((Single)highLimit);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.DeadZoneHighLimit_High:
|
|
length4Value = GetBytes((Single)deadZoneHigh);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.DeadZoneHighLimit_Low:
|
|
length4Value = GetBytes((Single)deadZoneHigh);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.DeadZoneLowLimit_High:
|
|
length4Value = GetBytes((Single)deadZoneLow);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.DeadZoneLowLimit_Low:
|
|
length4Value = GetBytes((Single)deadZoneLow);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.LowLimit_High:
|
|
length4Value = GetBytes((Single)lowLimit);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.LowLimit_Low:
|
|
length4Value = GetBytes((Single)lowLimit);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.SampleCount_High:
|
|
length4Value = GetBytes(0);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.SampleCount_Low:
|
|
length4Value = GetBytes(0);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.IgnoreCount_High:
|
|
length4Value = GetBytes(0);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus.IgnoreCount_Low:
|
|
length4Value = GetBytes(0);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #1
|
|
case (int)DataStore._30000_Modbus._1_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[0].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[0].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._1_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[0].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #2
|
|
case (int)DataStore._30000_Modbus._2_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[1].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[1].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._2_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[1].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #3
|
|
case (int)DataStore._30000_Modbus._3_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[2].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[2].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._3_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[2].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #4
|
|
case (int)DataStore._30000_Modbus._4_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[3].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[3].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._4_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[3].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #5
|
|
case (int)DataStore._30000_Modbus._5_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[4].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[4].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._5_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[4].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #6
|
|
case (int)DataStore._30000_Modbus._6_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[5].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[5].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._6_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[5].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #7
|
|
case (int)DataStore._30000_Modbus._7_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[6].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[6].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._7_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[6].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #8
|
|
case (int)DataStore._30000_Modbus._8_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[7].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[7].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._8_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[7].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #9
|
|
case (int)DataStore._30000_Modbus._9_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[8].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[8].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._9_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[8].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #10
|
|
case (int)DataStore._30000_Modbus._10_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[9].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[9].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._10_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[9].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #11
|
|
case (int)DataStore._30000_Modbus._11_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[10].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[10].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._11_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[10].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
#region #12
|
|
case (int)DataStore._30000_Modbus._12_Update:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].Update);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_Grade:
|
|
length2Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].Grade);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_Weight_High:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[11].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_Weight_Low:
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Stop)
|
|
length4Value = GetBytes((Single)0.0);
|
|
else
|
|
length4Value = GetBytes((Single)this.Current30000ModbusData.LaneModbusData[11].Weight);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_UnderCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_UnderCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].UnderCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_PassCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_PassCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].PassCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_OverCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_OverCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].OverCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_NGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_NgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].NGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_ExNGCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_ExNgCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].ExNGCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_TotalCount_High:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[3 - i];
|
|
break;
|
|
case (int)DataStore._30000_Modbus._12_TotalCount_Low:
|
|
length4Value = GetBytes(this.Current30000ModbusData.LaneModbusData[11].TotalCount);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length4Value[1 - i];
|
|
break;
|
|
#endregion
|
|
|
|
default:
|
|
length2Value = GetBytes(0);
|
|
for (int i = 0; i < 2; i++)
|
|
madeData[madeDataIndex + i] = length2Value[1 - i];
|
|
break;
|
|
}
|
|
madeDataIndex += 2;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
return madeData;
|
|
}
|
|
#endregion
|
|
#region SerialCH3
|
|
public void SerialCH3Open()
|
|
{
|
|
string fullPath = "";
|
|
int baudrate = 9600;
|
|
|
|
if (this.SystemConfig.Serial3Mode != 0)
|
|
{
|
|
try
|
|
{
|
|
switch (this.SystemConfig.Serial3BaudRate)
|
|
{
|
|
case 0:
|
|
baudrate = 9600;
|
|
break;
|
|
case 1:
|
|
baudrate = 19200;
|
|
break;
|
|
case 2:
|
|
baudrate = 38400;
|
|
break;
|
|
case 3:
|
|
baudrate = 115200;
|
|
break;
|
|
default:
|
|
baudrate = 9600;
|
|
break;
|
|
}
|
|
|
|
// Port : COM3
|
|
SerialMgrComm.serialPortOpen("COM3:", baudrate, 0, 0, 8);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
#region Test 용 통신 로그
|
|
fullPath = this.PathDataBackupFolder + "COM3log.txt";
|
|
this.smartFileCom3Log.FilePathName = fullPath;
|
|
//this.smartUARTCom3.Open();
|
|
//this.IsCom3LogOpen = true;
|
|
#endregion
|
|
}
|
|
|
|
public string PadLeft(int length, string sValue)
|
|
{
|
|
string temp;
|
|
|
|
temp = sValue.PadLeft(length, ' ');
|
|
|
|
return temp;
|
|
}
|
|
|
|
public void SerialCH3STD1(Collection<WeightData> datas)
|
|
{
|
|
string value = "";
|
|
|
|
value = this.Protocol_STD1(this.SystemConfig, datas);
|
|
|
|
SerialMgrComm.serialPortMessage("COM3:", value);
|
|
|
|
if (this.IsCom3LogOpen == true)
|
|
this.smartFileCom3Log.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, value));
|
|
}
|
|
public void SerialCH3STD2(Collection<WeightData> datas)
|
|
{
|
|
string value = "";
|
|
|
|
value = this.Protocol_STD2(this.SystemConfig, datas, this.CurrentProductItem);
|
|
|
|
SerialMgrComm.serialPortMessage("COM3:", value);
|
|
|
|
if (this.IsCom3LogOpen == true)
|
|
this.smartFileCom3Log.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, value));
|
|
}
|
|
public void SerialCH3STD3(Collection<WeightData> datas)
|
|
{
|
|
string value = "";
|
|
|
|
value = this.Protocol_STD3(this.SystemConfig, datas, this.CurrentProductItem);
|
|
|
|
SerialMgrComm.serialPortMessage("COM3:", value);
|
|
|
|
if (this.IsCom3LogOpen == true)
|
|
this.smartFileCom3Log.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, value));
|
|
}
|
|
#endregion
|
|
#region Ethernet
|
|
private void SendEthernetData(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.EthernetWeightData(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.IsModbusCommonDataSend = false;
|
|
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();
|
|
}
|
|
|
|
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");
|
|
this.SetTrackingHistoryData(DataStore.TrackingOperation.EthernetConnect, "Client");
|
|
|
|
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 = this.EthernetStmReader.ReadLine();
|
|
|
|
if (null == strRecvMsg)
|
|
{
|
|
this.DelegateTextStatusOut(">Server Out");
|
|
this.SetTrackingHistoryData(DataStore.TrackingOperation.EthernetDisconnect, "Client");
|
|
this.IsEthernetThreadStop = true;
|
|
break;
|
|
}
|
|
|
|
this.DelegateTextStatusOut(strRecvMsg);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateTextStatusOut(">Connect Fail !");
|
|
}
|
|
finally
|
|
{
|
|
this.IsEthernetThreadStop = true;
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut(">Disconnected Server");
|
|
this.SetTrackingHistoryData(DataStore.TrackingOperation.EthernetDisconnect, "Client");
|
|
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();
|
|
}
|
|
|
|
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.EthernetSendMessage), data);
|
|
}
|
|
private void DelegateTransferData(byte[] data)
|
|
{
|
|
this.Invoke(new TransferDataByteArrayCallback(this.EthernetSendMessage), data);
|
|
}
|
|
private void DelegateTransferData(byte data)
|
|
{
|
|
this.Invoke(new TransferDataStringCallback(this.EthernetSendMessage), data);
|
|
}
|
|
public void EthernetSendMessage(string msg)
|
|
{
|
|
try
|
|
{
|
|
this.EthernetStmWriter.Write(msg);
|
|
this.EthernetStmWriter.Flush();
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, msg));
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut("> Disconnect");
|
|
}
|
|
}
|
|
public void EthernetSendMessage(byte[] msg)
|
|
{
|
|
try
|
|
{
|
|
this.EthernetStmWriter.BaseStream.Write(msg, 0, msg.Length);
|
|
this.EthernetStmWriter.Flush();
|
|
|
|
// 로그
|
|
if (this.IsCommunicationLogOpen == true)
|
|
this.smartFileCommunicationLog.WriteString(string.Format("Send ({0:yyyy-MM-dd HH:mm:ss}): {1}", DateTime.Now, BitConverter.ToString(msg)));
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut("> Disconnect");
|
|
}
|
|
}
|
|
public void EthernetSendMessage(byte msg)
|
|
{
|
|
try
|
|
{
|
|
this.EthernetStmWriter.WriteLine(msg);
|
|
this.EthernetStmWriter.Flush();
|
|
}
|
|
catch
|
|
{
|
|
this.DelegateUISeverStatus(false);
|
|
this.DelegateTextStatusOut("> Disconnect");
|
|
}
|
|
}
|
|
public void EthernetWeightData(string strTemp)
|
|
{
|
|
this.IsEthernetTransferData = true;
|
|
this.EthernetTransferData = strTemp;
|
|
|
|
if (this.IsEthernetThreadStop == true)
|
|
this.EthernetClientConnect();
|
|
else
|
|
this.EthernetSendMessage((string)this.EthernetTransferData);
|
|
}
|
|
public void EthernetWeightData(byte temp)
|
|
{
|
|
this.IsEthernetTransferData = true;
|
|
this.EthernetTransferData = temp;
|
|
|
|
if (this.IsEthernetThreadStop == true)
|
|
this.EthernetClientConnect();
|
|
else
|
|
this.EthernetSendMessage((byte)this.EthernetTransferData);
|
|
}
|
|
public void EthernetWeightDataForModbus(byte[] bytes)
|
|
{
|
|
this.IsEthernetTransferData = true;
|
|
this.EthernetTransferData = bytes;
|
|
|
|
if (this.IsEthernetThreadStop == true)
|
|
this.EthernetClientConnect();
|
|
else
|
|
this.EthernetSendMessage(bytes);
|
|
}
|
|
#endregion
|
|
|
|
#endregion
|
|
#region Servo Motor COM
|
|
public void ModbusOpen()
|
|
{
|
|
if (this.smartModbus.IsOpen == true)
|
|
this.smartModbus.PortClose();
|
|
|
|
this.smartModbus.PortOpen();
|
|
}
|
|
public void ModbusClose()
|
|
{
|
|
this.smartModbus.PortClose();
|
|
}
|
|
|
|
public string ServoMotorRead1(int slaveAddress, int parameterAddress)
|
|
{
|
|
int value = 0;
|
|
byte[] readData = new byte[2];
|
|
|
|
this.smartModbus.SlaveAddress = slaveAddress;
|
|
this.smartModbus.ReadHoldingRegister(parameterAddress, 1, ref readData);
|
|
|
|
Array.Reverse(readData);
|
|
value = BitConverter.ToInt16(readData, 0);
|
|
|
|
return string.Format("{0}", value);
|
|
}
|
|
public string ServoMotorRead2(int slaveAddress, int parameterAddress)
|
|
{
|
|
int value = 0;
|
|
byte[] readData = new byte[4];
|
|
|
|
this.smartModbus.SlaveAddress = slaveAddress;
|
|
this.smartModbus.ReadHoldingRegister(parameterAddress, 2, ref readData);
|
|
|
|
byte[] readData1 = new byte[4];
|
|
readData1[0] = readData[1];
|
|
readData1[1] = readData[0];
|
|
readData1[2] = readData[3];
|
|
readData1[3] = readData[2];
|
|
|
|
value = BitConverter.ToInt32(readData1, 0);
|
|
|
|
return string.Format("{0}", value);
|
|
}
|
|
public void ServoMotorWrite1(int slaveAddress, int parameterAddress, int value, SmartLabel label)
|
|
{
|
|
this.smartModbus.SlaveAddress = slaveAddress;
|
|
if (this.smartModbus.WriteSingleRegister(parameterAddress, value) == SmartX.SmartModbus.EXCEPTIONCODE.SUCCESS)
|
|
{
|
|
//MessageBox.Show("쓰기완료");
|
|
}
|
|
label.Text = this.ServoMotorRead1(slaveAddress, parameterAddress);
|
|
}
|
|
public void ServoMotorWrite1(int slaveAddress, int parameterAddress, int value)
|
|
{
|
|
this.smartModbus.SlaveAddress = slaveAddress;
|
|
if (this.smartModbus.WriteSingleRegister(parameterAddress, value) == SmartX.SmartModbus.EXCEPTIONCODE.SUCCESS)
|
|
{
|
|
//MessageBox.Show("쓰기완료");
|
|
}
|
|
}
|
|
public void ServoMotorWrite2(int slaveAddress, int parameterAddress, int value, SmartLabel label)
|
|
{
|
|
byte[] data = BitConverter.GetBytes(value);
|
|
|
|
byte[] readData1 = new byte[4];
|
|
readData1[0] = data[1];
|
|
readData1[1] = data[0];
|
|
readData1[2] = data[3];
|
|
readData1[3] = data[2];
|
|
|
|
this.smartModbus.SlaveAddress = slaveAddress;
|
|
if (this.smartModbus.WriteMultipleRegister(parameterAddress, 4, readData1) == SmartX.SmartModbus.EXCEPTIONCODE.SUCCESS)
|
|
{
|
|
//MessageBox.Show("쓰기완료");
|
|
}
|
|
label.Text = this.ServoMotorRead2(slaveAddress, parameterAddress);
|
|
}
|
|
public void ServoMotorWrite(int slaveAddress, int parameterAddress, int value)
|
|
{
|
|
this.smartModbus.SlaveAddress = slaveAddress;
|
|
if (this.smartModbus.WriteSingleRegister(parameterAddress, value) == SmartX.SmartModbus.EXCEPTIONCODE.SUCCESS)
|
|
{
|
|
//MessageBox.Show("쓰기완료");
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
#region Override Member
|
|
protected override void OnLoad(EventArgs e)
|
|
{
|
|
base.OnLoad(e);
|
|
|
|
// 변수 초기 셋팅1
|
|
this.DefaultSetting1();
|
|
// SystemConfiguration 1 읽기
|
|
this.LoadSystemConfigurationFile();
|
|
// Collection 생성
|
|
this.CreateCollection();
|
|
// Count 읽기
|
|
this.LoadCounterFile1(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);
|
|
// UserGroup File Load
|
|
this.LoadUserGroupFile(ref this.CurrentUserGroup);
|
|
|
|
// 변수 초기 셋팅2
|
|
// 시스템설정 값 로딩 후 셋팅
|
|
this.DefaultSetting2();
|
|
|
|
// Modbus 데이터 초기화
|
|
if (this.SystemConfig.IsModbusUse == true)
|
|
this.ModbusInitizlise();
|
|
|
|
// UserManager 초기화
|
|
if (this.SystemConfig.IsLogin == true)
|
|
{
|
|
this.InitializeUserManager();
|
|
this.SystemConfig.CurrentUser.Group = DataStore.UserGroup.LogOut;
|
|
|
|
if (this.SystemConfig.IsOptPart11 == false)
|
|
UserManager.UserManager_AutoLogoutTimeoutPause();
|
|
|
|
// User List Timer
|
|
this.timerUserList.Enabled = true;
|
|
}
|
|
else
|
|
this.SystemConfig.CurrentUser.Group = DataStore.UserGroup.NotLogin;
|
|
// Encryption 초기화
|
|
if (this.SystemConfig.IsOptPart11 == true)
|
|
{
|
|
this.InitializeAES();
|
|
this.SetTrackingHistoryData(DataStore.TrackingOperation.PowerOn, "");
|
|
}
|
|
|
|
// 폼생성
|
|
this.CreateForm();
|
|
|
|
// 통신 OPEN
|
|
this.OpenSmartUartLink();
|
|
this.SmartSplashProgramLoad.Finish();
|
|
this.smartForm.Show((int)DataStore.FormStore.FormMainDisplay);
|
|
|
|
// Serial3 통신 Open
|
|
this.SerialCH3Open();
|
|
// Modbus Open
|
|
this.ModbusOpen();
|
|
// 초기 파라미터 전송
|
|
this.TrasferSystemParameter(this.SystemConfig);
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region Event Handler
|
|
private void smartSerialPort_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 smartThread_UIThreadFunction(ThreadArgs args)
|
|
{
|
|
// 메시지 11. 입력센서 에러에 의해 정지하였습니다.
|
|
if (this.FlagThreadMessage1 == false)
|
|
{
|
|
DialogFormMessage msg = new DialogFormMessage(11, this.SystemConfig.Language, this);
|
|
msg.ShowDialog();
|
|
|
|
this.FlagThreadMessage1 = true;
|
|
}
|
|
}
|
|
private void timerTimeout_Tick(object sender, EventArgs e)
|
|
{
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
{
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.UpdateDisplayProductChangeInfo(this.FlagTimeoutCount);
|
|
}
|
|
else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormSystemSetting)
|
|
{
|
|
if (this.ChildFormSystemSetting != null)
|
|
this.ChildFormSystemSetting.UpdateDisplayProductChangeInfo(this.FlagTimeoutCount);
|
|
}
|
|
|
|
this.TransferProductParameter(this.SystemConfig.ProductNumber);
|
|
|
|
this.FlagTimeoutCount++;
|
|
}
|
|
private void timerEmergencyStop_Tick(object sender, EventArgs e)
|
|
{
|
|
this.timerEmergencyStop.Enabled = false;
|
|
|
|
if (this.EquipmentStatus == DataStore.EquipmentStatus.Start)
|
|
{
|
|
this.TransferData(CommunicationCommand.Stop, CommunicationID.MainBoard);
|
|
this.timerEmergencyStop.Enabled = true;
|
|
}
|
|
}
|
|
private void timerUserList_Tick(object sender, EventArgs e)
|
|
{
|
|
this.timerUserList.Enabled = false;
|
|
UserManager.UserManager_GetUserListName();
|
|
}
|
|
|
|
#region DLL_SerialportEvent
|
|
private void Serialport_ReceiveDataEvent(string data)
|
|
{
|
|
try
|
|
{
|
|
this.ReceiveData(data);
|
|
|
|
// 통신 확인
|
|
if (this.CommunicationCheckCount / 3 == 1)
|
|
{
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.pictureBoxCommunicationStatus.Visible = true;
|
|
|
|
this.CommunicationCheckCount = 0;
|
|
}
|
|
else
|
|
{
|
|
if (this.ChildFormMainDisplay != null)
|
|
this.ChildFormMainDisplay.pictureBoxCommunicationStatus.Visible = false;
|
|
|
|
this.CommunicationCheckCount += 1;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
private void Serialport_GetVersionDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
if (this.ChildFormInformation != null)
|
|
{
|
|
|
|
this.UI_Invoke(delegate
|
|
{
|
|
this.ChildFormInformation.UpdateSerialportVersionDisplay(data.ToString());
|
|
});
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region UserManagerEvent
|
|
private void UserManager_UserListLogoutDataEvent(int status)
|
|
{
|
|
try
|
|
{
|
|
if (status == (int)UserManager.USERMGR_LOGOUT_STATUS_OK)
|
|
{
|
|
// logout
|
|
}
|
|
else
|
|
{
|
|
// logout fail !!!
|
|
//MessageBox.Show("Logout Failed !!!!");
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListLoginDataEvent(int status, object data)
|
|
{
|
|
try
|
|
{
|
|
if (status == (int)UserManager.E_user_mgr_status.USER_MGR_STATUS_OK)
|
|
{
|
|
UserManager.UserMgr_user_info_t userInfo = (UserManager.UserMgr_user_info_t)data;
|
|
|
|
//this.ChildFormMainDisplay.updatedisplayuser
|
|
|
|
//String Message;
|
|
}
|
|
else
|
|
{
|
|
this.UI_Invoke(delegate
|
|
{
|
|
// login fail !!!
|
|
//textBox_id.Enabled = true;
|
|
//textBox_pw.Enabled = true;
|
|
//comboBox_logout_timeout.Enabled = true;
|
|
|
|
//button_login.Text = "LOGIN";
|
|
//Activation.IsLogin = false;
|
|
});
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListGetListDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_list_t userList = (UserManager.UserMgr_user_list_t)data;
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormUserEditor)
|
|
this.ChildFormUserEditor.CallBackGetUserData(userList);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListLoginTimeoutDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_login_timeout_t loginTimeout = (UserManager.UserMgr_login_timeout_t)data;
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
this.ChildFormMainDisplay.CallBackUserListLoginTimeoutDataEvent(loginTimeout);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListLockDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_lock_t user = (UserManager.UserMgr_user_lock_t)data;
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormUserEditor)
|
|
this.ChildFormUserEditor.CallBackUserListLockDataEvent(user);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListDefaultSettingDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListDeleteDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_del_t user = (UserManager.UserMgr_user_del_t)data;
|
|
this.ChildFormUserEditor.CallBackUserListDeleteDataEvent(user);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListModifyUserDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_modify_t user = (UserManager.UserMgr_user_modify_t)data;
|
|
|
|
this.ChildFormUserEditor.CallBackUserModifyUserData(user);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListModifyInfoDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_info_t user = (UserManager.UserMgr_user_info_t)data;
|
|
|
|
if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormUserEditor)
|
|
this.ChildFormUserEditor.CallBackUserListModifyInfoDataEvent(user);
|
|
//else if (this.SystemConfig.CurrentForm == DataStore.FormStore.FormMainDisplay)
|
|
//this.ChildFormMainDisplay.CallBackUserListModifyInfoDataEvent(user);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListNewDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_info_t user = (UserManager.UserMgr_user_info_t)data;
|
|
|
|
this.ChildFormUserEditor.CallBackUserListNewData(user);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListAddDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_add_t userAdd = (UserManager.UserMgr_user_add_t)data;
|
|
|
|
if (userAdd.status == (int)UserManager.E_user_mgr_status.USER_MGR_STATUS_OK)
|
|
{
|
|
//for (int i = 0; i < this.CollectionUser.Count; i++)
|
|
//{
|
|
// if (this.CollectionUser[i].ID == userAdd.user_id)
|
|
// {
|
|
// this.FlagUserListCNT++;
|
|
// this.CollectionUser[i].IsUpdate = true;
|
|
// this.CollectionUser[i].IsLockAccount = userAdd.flock_status_account == 0 ? false : true;
|
|
// this.CollectionUser[i].IsLockPassword = userAdd.flock_status_password == 0 ? false : true;
|
|
// break;
|
|
// }
|
|
//}
|
|
}
|
|
else
|
|
{
|
|
//for (int i = 0; i < this.CollectionUser.Count; i++)
|
|
//{
|
|
// if (this.CollectionUser[i].ID == userAdd.user_id)
|
|
// {
|
|
// this.CollectionUser.RemoveAt(i);
|
|
// break;
|
|
// }
|
|
//}
|
|
|
|
//this.SaveUserFile(this.CollectionUser);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListGetListNameDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
UserManager.UserMgr_user_list_name_t name = (UserManager.UserMgr_user_list_name_t)data;
|
|
|
|
if (name.total_count == 0)
|
|
return;
|
|
|
|
this.ListDllUserName.Add(name.user_id);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
private void UserManager_UserListGetVersionDataEvent(object data)
|
|
{
|
|
try
|
|
{
|
|
if (this.ChildFormInformation != null)
|
|
this.ChildFormInformation.UpdatePart11UserManagerVersionDisplay(data.ToString());
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region EncryptionEvent
|
|
private void AesEncryption_Event(object data)
|
|
{
|
|
try
|
|
{
|
|
Encryption.auth_encryption_status_t status = (Encryption.auth_encryption_status_t)data;
|
|
|
|
//this.labelStatus.Text = status.percentage.ToString();
|
|
//this.StatusPercentage = status.percentage;
|
|
|
|
this.ChildFormDataBackup_Part11.CallBackEncryptionEvent(status);
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
private void AesEncryption_GetVersionDataEvent(object data)
|
|
{
|
|
if (this.ChildFormInformation != null)
|
|
this.ChildFormInformation.UpdatePart11AesEncryptionVersionDisplay(data.ToString());
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
private void timerEquipmentStatus_Tick(object sender, EventArgs e)
|
|
{
|
|
this.timerEquipmentStatus.Enabled = false;
|
|
|
|
this.EquipmentStatus1 = this.EquipmentStatus;
|
|
}
|
|
}
|
|
} |