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

initial commit

Browse Source
This commit is contained in:
chi
2025-01-07 16:08:02 +09:00
parent 9e657e2558
commit 0a93a54a6f
268 changed files with 50767 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
Cs_HMI/SubProject/ProPLC/Arduino/EnumStruct.cs Normal file
View File

@@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace arDev.Arduino
{
public enum IODirection
{
Input = 0,
Output
}
public enum MessageType
{
Normal = 0,
SendData,
ReceiveData,
Message,
RxIOData,
RxSetData,
}
}

82
Cs_HMI/SubProject/ProPLC/Arduino/EventsIO.cs Normal file
View File

@@ -0,0 +1,82 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace arDev.Arduino
{
public partial class DIO
{
/// <summary>
/// Digital Input/Output Changed
/// </summary>
public event EventHandler<IOValueEventArgs> ValueChanged;
public event EventHandler<FlagValueEventArgs> FlagChanged;
/// <summary>
/// 마그넷 센서의 값이 변경되었을때 발생 함
/// </summary>
public event EventHandler PositionChanged;
///// <summary>
///// Digital Input/Output Message
///// </summary>
//public event EventHandler<MessageEventArgs> Message;
public class FlagValueEventArgs : EventArgs
{
private int _arridx;
private Boolean _oldvalue;
private Boolean _newvalue;
public int ArrIDX { get { return _arridx; } }
public Boolean OldValue { get { return _oldvalue; } }
public Boolean NewValue { get { return _newvalue; } }
public FlagValueEventArgs( int ArrIDX, Boolean oldvalue, Boolean newvalue)
{
_arridx = ArrIDX;
_oldvalue = oldvalue;
_newvalue = newvalue;
}
}
public class IOValueEventArgs : EventArgs
{
private int _arridx;
private Boolean _oldvalue;
private Boolean _newvalue;
private IODirection _dir;
public int ArrIDX { get { return _arridx; } }
public Boolean OldValue { get { return _oldvalue; } }
public Boolean NewValue { get { return _newvalue; } }
public IODirection Direction { get { return _dir; } }
public IOValueEventArgs(IODirection dir, int ArrIDX, Boolean oldvalue, Boolean newvalue)
{
_arridx = ArrIDX;
_oldvalue = oldvalue;
_newvalue = newvalue;
_dir = dir;
}
}
//public class MessageEventArgs : EventArgs
//{
// private Boolean _isError = false;
// public Boolean IsError { get { return _isError; } }
// private string _message = string.Empty;
// public string Message { get { return _message; } }
// private Arduino.MessageType _mtype;
// public Arduino.MessageType MessageType { get { return _mtype; } }
// public MessageEventArgs(Arduino.MessageType mType, string Message, Boolean isError)
// {
// _isError = isError;
// _message = Message;
// this._mtype = mType;
// }
//}
}
}

556
Cs_HMI/SubProject/ProPLC/Arduino/MemoryAccess.cs Normal file
View File

@@ -0,0 +1,556 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.ComponentModel;
using System.Reflection;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Collections.Concurrent;
namespace arDev.Arduino
{
public partial class DIO : arRS232
{
protected object lockobj = new object();
public struct SetupInfo
{
public byte ioInterval;
public byte ResetCount;
public byte SpeedH;
public byte SpeedL;
public byte SpeedZ;
public byte pindirRevDILow;
public byte pindirRevDIHigh;
public byte UpTime;
public byte BalanceThd;
public byte MarkThd;
public byte SpeedC;
public byte BalanceThdUp;
public Boolean IsValid;
public void Clear()
{
pindirRevDIHigh = 0;
pindirRevDILow = 0;
ioInterval = 0;
ResetCount = 0;
SpeedH = 0;
SpeedL = 0;
SpeedC = 0;
BalanceThd = 0;
BalanceThd = 0;
UpTime = 0;
MarkThd = 0;
SpeedZ = 0;
IsValid = false;
}
}
public SetupInfo setupInfo;
private Boolean STX11 = false;
private Boolean STX21 = false;
//private Boolean ETX11 = false;
// private byte[] buffer1;
// readonly List<byte> Tempbuffer1 = new List<byte>();
readonly ManualResetEvent mre = new ManualResetEvent(true);
// protected string errorMessage = string.Empty;
// readonly System.IO.Ports.SerialPort dev = null;
private byte LEN1 = 0;
//private byte CHK1 = 0;
//private int bufferCount1 = 0;
public DateTime ConnTryTime = DateTime.Now.AddDays(-1);
protected DateTime[] SetFlagTime = new DateTime[32];
readonly Boolean[] Flag = new bool[32];
readonly Boolean[] DIValue = new bool[16];
readonly Boolean[] DOValue = new bool[16];
public UInt16[] AIValue = new ushort[3];
public byte[] AOValue = new byte[3];
public string ioBinStr = string.Empty;
public string SetupStr = string.Empty;
public byte RunTime = 0;
public byte[] MAG_VALUE = new byte[2];
public byte[] SV_SPEED = new byte[2];
public Boolean isDisposed = false; //dispose가 호출되었는가?
public string LastMessage { get; set; }
public DateTime LastMessageTime { get; set; }
/// <summary>
/// 생성자
/// </summary>
public DIO()
{
//설정의 값
setupInfo = new SetupInfo();
setupInfo.Clear();
SV_SPEED[0] = 0;
SV_SPEED[1] = 0;
//마그넷 센서(0~100)
MAG_VALUE[0] = 50;
MAG_VALUE[1] = 50;
lastRecvTime = DateTime.Parse("1982-11-23");
for (int i = 0; i < Flag.Length; i++)
Flag[i] = false;
for (int i = 0; i < DIValue.Length; i++)
DIValue[i] = false;
for (int i = 0; i < DOValue.Length; i++)
DOValue[i] = false;
for (int i = 0; i < AIValue.Length; i++)
AIValue[i] = 0;
for (int i = 0; i < AOValue.Length; i++)
AOValue[i] = 0;
for (int i = 0; i < SetFlagTime.Length; i++)
SetFlagTime[i] = DateTime.Parse("1982-11-23");
}
protected override bool CustomParser(byte[] buf, out byte[] remainBuffer)
{
List<byte> remain = new List<byte>();
Boolean bComplete = false;
for (int i = 0; i < buf.Length; i++)
{
var incomByte = buf[i];
if (bComplete == true)
{
remain.Add(incomByte);
}
else
{
if (STX11 == false)
{
if (incomByte != '@')
{
STX21 = false;
// ETX11 = false;
continue;
}
else
{
STX11 = true;
tempBuffer.Clear();
tempBuffer.Add(incomByte);
}
}
else if (STX21 == false)
{
if (tempBuffer.Count != 1 || tempBuffer.Count < 1 || tempBuffer[0] != '@' || incomByte != '@')
{
STX11 = false;
//ETX11 = false;
continue;
}
else
{
STX21 = true;
tempBuffer.Add(incomByte);
}
}
else
{
tempBuffer.Add(incomByte);
//여기서부터는무조건 누적한다.
if (tempBuffer.Count == 3)
{
if (tempBuffer[0] != '@' || tempBuffer[1] != '@')
{
STX11 = false;
STX21 = false;
// ETX11 = false;
LEN1 = 0;
tempBuffer.Clear();
}
else LEN1 = incomByte; //데이터 길이가온다
}
//else if (Tempbuffer1.Count == LEN1 + 5) //ETX1
//{
// if (incomingByte != 0x0D)
// {
// //ETX가 와야하는데 다른데이터가 왔다
// STX11 = false;
// STX21 = false;
// // ETX11 = false;
// var str = System.Text.Encoding.Default.GetString(Tempbuffer1.ToArray());
// RaiseMessage(MessageType.ReceiveData, "에러 모두 파기 : " + str, true);
// Tempbuffer1.Clear();
// }
//}
else if (tempBuffer.Count == LEN1 + 6)
{
//전체길이를 만족햇다.
if (incomByte != 0x0A)
{
//ETX가 와야하는데 다른데이터가 왔다
STX11 = false;
STX21 = false;
// ETX11 = false;
//var str = System.Text.Encoding.Default.GetString(Tempbuffer1.ToArray());
RaiseMessage(MessageType.Error, "에러 모두 파기 : ETX 값 오류");
tempBuffer.Clear();
}
else if (tempBuffer[tempBuffer.Count - 2] != 0x0D)
{
//ETX가 와야하는데 다른데이터가 왔다
STX11 = false;
STX21 = false;
// ETX11 = false;
//var str = System.Text.Encoding.Default.GetString(Tempbuffer1.());
RaiseMessage(MessageType.Error, "에러 모두 파기 : ETX 값 오류");
tempBuffer.Clear();
}
else
{
STX11 = false;
STX21 = false;
// ETX11 = false;
//if (LastReceiveBuffer == null) LastReceiveBuffer = new byte[tempBuffer.Count];
//else if (LastReceiveBuffer.Length != tempBuffer.Count) Array.Resize(ref LastReceiveBuffer, Tempbuffer1.Count);
//tempBuffer.CopyTo(LastReceiveBuffer)tempBuffer
//tempBuffer.Clear();
bComplete = true;
}
}
}
}
}
remainBuffer = remain.ToArray();
return bComplete;
}
bool Checksum(byte[] buffer, int datalength)
{
//체크섬필요 221118
if (buffer[buffer.Length-3] == '*')
{
return true;
}
byte checksum = 0;
for (int i = 3; i < datalength + 3; i++)
{
checksum = (byte)(checksum ^ buffer[i]);
}
return checksum == buffer[buffer.Length - 3];
}
public override bool ProcessRecvData(byte[] data)
{
var hexString = GetHexString(data);//.gethe
var len = data[2];
if (len + 6 != data.Length)
{
RaiseMessage(MessageType.Error, string.Format("길이오류 예상:{0},수신:{1},{2}", len + 5, data.Length, hexString));
}
else if (data[0] != 0x40 || data[1] != 0x40 || data[data.Length - 2] != 0x0D || data[data.Length - 1] != 0x0A)
{
RaiseMessage(MessageType.Error, string.Format("헤더 오류 : {0}", hexString));
}
else if (Checksum(data, len) == false) //체크섬 221118
{
RaiseMessage(MessageType.Error, string.Format("체크섬 오류 : {0}", hexString));
}
else
{
//RaiseMessage(MessageType.ReceiveData, hexString);
lastRecvTime = DateTime.Now;
var cmd = data[3];
if (cmd == 'I') //IOData
{
if (len != 10)
RaiseMessage(MessageType.Error, "IO수신길이오류:" + DateTime.Now.ToString("mm:ss.fff") + " 수신 : " + hexString);
else Parse_IOData(data);
}
else if (cmd == 'T')
{
// Boolean errorMessage = buffer[4] == 1;
var message = System.Text.Encoding.Default.GetString(data, 5, len - 2);//데이터타입과 에러여부 제거
LastMessage = message;
LastMessageTime = DateTime.Now;
RaiseMessage(MessageType.Normal, message);
}
else if (cmd == 'S') //setup 정보 200310 (홈)
{
if (len != 13)
RaiseMessage(MessageType.Error, "SETUP수신길이오류:" + DateTime.Now.ToString("mm:ss.fff") + " 수신 : " + hexString);
else Parse_SetupData(data);
}
else
{
RaiseMessage(MessageType.Normal, "Unknown:" + hexString + "\n" + "Data=" + System.Text.Encoding.Default.GetString(data));
}
}
return true;
}
void Parse_IOData(byte[] buffer)
{
var IOData = BitConverter.ToUInt32(buffer, 4);
//var newMagF = BitConverter.ToUInt16(buffer, 8);
//va1r newMagB = BitConverter.ToUInt16(buffer, 10);
//var newAlign = BitConverter.ToUInt16(buffer, 12);
//if (newMagF != AIValue[0] || newMagB != AIValue[1])
//{
// AIValue[0] = newMagF;// BitConverter.ToUInt16(buffer, 8); //마그넷센서 F
// AIValue[1] = newMagB; //BitConverter.ToUInt16(buffer, 10); //마그넷센서 B
// PositionChanged?.Invoke(this, null);
//}
//AIValue[2] = newAlign;
//AOValue[0] = buffer[14]; //왼쪽바퀴 속도
//AOValue[1] = buffer[15]; //오른쪽바퀴 속도
//AOValue[2] = buffer[16]; //Z축 속도
//SV_SPEED[0] = buffer[21]; //왼쪽바퀴의 설정속도
//SV_SPEED[1] = buffer[22]; //오른쪽바퀴의 설정속도
//MAG_VALUE[0] = buffer[23]; //magnet front
//MAG_VALUE[1] = buffer[24]; //magnet rear
RunTime = buffer[12];
//플래그값 확인
byte[] buf_flag = new byte[4];
Array.Copy(buffer, 8, buf_flag, 0, 4);
var baF = new System.Collections.BitArray(buf_flag);
for (int i = 0; i < 32; i++)
{
Boolean val = baF[i];
//입력
if (this.Flag[i] != val)
{
Flag[i] = val;
//변경이벤트 생성
FlagChanged?.Invoke(this, new FlagValueEventArgs(i, !val, val));
}
}
//IO값 확인
byte[] buf_iodata = new byte[4];
Array.Copy(buffer, 4, buf_iodata, 0, 4);
var ba = new System.Collections.BitArray(buf_iodata);
for (int i = 0; i < 32; i++)
{
Boolean val = ba[i];
if (i >= 16)
{
//출력
if (DOValue[i - 16] != val)
{
DOValue[i - 16] = val;
//변경이벤트 생성
ValueChanged?.Invoke(this, new IOValueEventArgs(IODirection.Output, i - 16, !val, val));
}
}
else
{
//입력
if (DIValue[i] != val)
{
DIValue[i] = val;
//변경이벤트 생성
ValueChanged?.Invoke(this, new IOValueEventArgs(IODirection.Input, i, !val, val));
}
}
}
ioBinStr = Convert.ToString(IOData, 2).PadLeft(32, '0');
//string msg = string.Format(DateTime.Now.ToString("mm:ss.fff") + " IO:{0},AN={1:0000},{2:0000},FG={3},AO={4},{5}",
// binstr, An1, An2, FGData, Ao11, Ao12);
}
void Parse_SetupData(byte[] buffer)
{
setupInfo.ioInterval = buffer[4];
setupInfo.ResetCount = buffer[5];
setupInfo.SpeedH = buffer[6];
setupInfo.SpeedL = buffer[7];
setupInfo.SpeedZ = buffer[8];
setupInfo.pindirRevDIHigh = buffer[9];
setupInfo.pindirRevDILow = buffer[10];
setupInfo.UpTime = buffer[11];
setupInfo.BalanceThd = buffer[12];
setupInfo.MarkThd = buffer[13];
setupInfo.SpeedC = buffer[14];
setupInfo.BalanceThdUp = buffer[15];
SetupStr = string.Format("I:{0},R={1},H={2},L={3},Z={4},UP={5},BL={6},MK={7},SPD_C={8},BLUP={9}",
setupInfo.ioInterval,
setupInfo.ResetCount,
setupInfo.SpeedH,
setupInfo.SpeedL,
setupInfo.SpeedZ,
setupInfo.UpTime,
setupInfo.BalanceThd,
setupInfo.MarkThd,
setupInfo.SpeedC,
setupInfo.BalanceThdUp);
}
public byte MakeChecksum(byte[] buffer)
{
//return 0;
byte chk = 0;
foreach (var b in buffer)
chk = (byte)(chk ^ b);
return chk;
}
#region "Method"
protected Boolean Sendcommand(byte cmd, byte p1, byte p2)
{
//이번호의 상태를 on/off 해줘야함
List<byte> buffer = new List<byte>
{
cmd, //command
p1,
p2
};
byte dataLen = (byte)buffer.Count; //데이터길이
byte checksum = MakeChecksum(buffer.ToArray());
buffer.Insert(0, (byte)'@'); //stx
buffer.Insert(1, (byte)'@'); //stx
buffer.Insert(2, dataLen);
buffer.Add(checksum); //길이를 제외한 실제 데이터 영역만 체크섬
buffer.Add(0x0D); //etx
buffer.Add(0x0A); //etx
return WriteData(buffer.ToArray());
}
/// <summary>
/// 이벤트를 강제 생성합니다.(내부변수값도 변경됩니다)
/// </summary>
/// <param name="Direction"></param>
/// <param name="idx"></param>
/// <param name="value"></param>
public void RaiseEvent(IODirection dir, int idx, Boolean value)
{
if (ValueChanged != null)
{
if (!mre.WaitOne(100))
{
RaiseMessage( MessageType.Error, "RaiseEvent WaitOne Timeout");
return;
}
mre.Reset();
bool curValue;
if (dir == IODirection.Input)
{
curValue = DIValue[idx];
DIValue[idx] = value;
}
else
{
curValue = DOValue[idx];
DOValue[idx] = value;
}
try
{
//이벤트를 할당한곳에서 오류가 나면 이곳에서 에러가 잡힌다.
ValueChanged(this, new IOValueEventArgs(dir, idx, curValue, value));
}
catch (Exception ex)
{
RaiseMessage(MessageType.Error, ex.Message);
}
finally
{
mre.Set();
}
}
}
//public Boolean GetFlag(byte idx)
//{
// return Flag[idx];
//}
public Boolean GetValueI(byte idx)
{
if (idx < DIValue.Length) return DIValue[idx];
else return false;
}
public Boolean GetValueO(byte idx)
{
if (idx < DOValue.Length) return DOValue[idx];
else return false;
}
//public Boolean SetValueI(int idx,Boolean value)
//{
// if (idx < DIValue.Length)
// {
// DIValue[idx] = value;
// return true;
// }
// else return false;
//}
public Boolean SetValue(byte idx, Boolean value)
{
byte SET_PINMODE = 3;
if (value == true) return Sendcommand(SET_PINMODE, idx, 1);
else return Sendcommand(SET_PINMODE, idx, 0);
}
public Boolean SetToggle(byte idx)
{
var curbalue = GetValueO(idx);
return SetValue(idx, !curbalue);
}
public string GetErrorMessage()
{
return errorMessage;
}
#endregion
}
}

387
Cs_HMI/SubProject/ProPLC/FakePLC.cs Normal file
View File

@@ -0,0 +1,387 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using arDev.Arduino;
using COMM;
namespace arDev
{
public class FakePLC : arDev.Arduino.DIO
{
private System.Threading.Thread thPLC;
public bool Shutdown { get; set; } = false;
public FakePLC()
{
COMM.VAR.Init(128);
}
~FakePLC()
{
System.Threading.Tasks.Task.Run(() =>
{
//쓰레드가 살아잇다면 대기한다
if (thPLC != null && thPLC.IsAlive)
{
System.Threading.Thread.Sleep(100);
}
this.Close();
});
}
private object lockobjdata = new object();
public enum eEEPAddress
{
EEP_IOINTERVAL = 0,
EEP_RESETCOUNT,
EEP_DIREVH,
EEP_DIREVL,
EEP_OPTION,
EEP_UPTIME,
};
public enum eCommand : byte
{
LOAD = 0, //EEPROM 불러오기
SAVE, //EEPROM 저장
RESET, //초기화
PINGCHK,
SET_PINMODE, //PINMODE 설정
SET_DOUTPUT, //디지털출력설정(포트번호,값[1,0])
SET_AOUTPUT, //아날로그출력설정(포트GET_SETTING = 50, //셋팅값 요청
SET_FLAG,
SET_EEPROM,
SET_MANUALSPEED,
GET_SETTING = 50,
GUIDE_MOT = 90, //가이드커버(양쪽) 0=멈춤,1=UP,2=DN 아스키코드표 90=Z
SET_EEP_DIREV,
};
//public enum MotorType
//{
// Left = 0,
// Right
//}
//public enum Direction
//{
// CW = 0,
// CCW,
//}
//public enum RunType
//{
// Stop = 0,
// Up,
// Dn
//}
public enum DIName
{
PINI_EMG = 0,
PINI_BTN_1,
PINI_BTN_2,
PINI_BTN_3,
PINI_BTN_4,
PINI_OVERLOADL,
PINI_OVERLOADR,
PINI_EMPTY_07,
PINI_EMPTY_08,
PINI_BTN_ZUP,
PINI_BTN_ZDN,
PINI_LIMIT_LU,
PINI_LIMIT_LD,
PINI_LIMIT_RU,
PINI_LIMIT_RD,
PINI_STOP,
}
public enum DIPin
{
PINI_EMG = 30,
PINI_BTN_1,
PINI_BTN_2,
PINI_BTN_3,
PINI_BTN_4,
PINI_OVERLOADL,
PINI_OVERLOADR,
PINI_EMPTY_07,
PINI_EMPTY_08,
PINI_BTN_ZUP,
PINI_BTN_ZDN,
PINI_LIMIT_LU,
PINI_LIMIT_LD,
PINI_LIMIT_RU,
PINI_LIMIT_RD,
PINI_STOP,
}
public enum DOName
{
PINO_GUIDEMOTOR_LDIR,
PINO_GUIDEMOTOR_LRUN,
PINO_GUIDEMOTOR_RDIR,
PINO_GUIDEMOTOR_RRUN,
PINO_EMPTY_04,
PINO_EMPTY_05,
PINO_EMPTY_06,
PINO_EMPTY_07,
}
public enum DOPin
{
PINO_GUIDEMOTOR_LDIR = 22,
PINO_GUIDEMOTOR_LRUN,
PINO_GUIDEMOTOR_RDIR,
PINO_GUIDEMOTOR_RRUN,
PINO_EMPTY_04,
PINO_EMPTY_05,
PINO_EMPTY_06,
PINO_EMPTY_07,
}
public enum Rundirection : byte
{
Stop = 0,
Forward,
Backward,
Left,
Right,
EStop,
}
public enum ZMotDirection
{
Stop = 0,
Up,
Down
}
private bool Sendcommand(eCommand cmd, char p1, char p2)
{
return Sendcommand(cmd, (byte)p1, (byte)p2);
}
private bool Sendcommand(eCommand cmd, char p1, byte p2 = 0)
{
return Sendcommand(cmd, (byte)p1, p2);
}
private bool Sendcommand(eCommand cmd, byte p1 = 0, byte p2 = 0)
{
if (cmd != eCommand.PINGCHK)
{
if (cmd == eCommand.SET_FLAG)
{
//플래그값은 공용변수로 변경
var idx = (eVarBool)p1;
VAR.BOOL[idx] = p2 != 0;
RaiseMessage(MessageType.Send, string.Format("PLC CMD:{0} [{1}]=>{2}", cmd, (eVarBool)p1, p2));
}
else
RaiseMessage(MessageType.Send, string.Format("PLC CMD:{0}, P1:{1}, P2:{2}", cmd, p1, p2));
}
return Sendcommand((byte)cmd, p1, p2);
}
public Boolean GetValueI(DIName idx)
{
return GetValueI((byte)idx);
}
public Boolean GetValueO(DOName idx)
{
return GetValueO((byte)idx);
}
public Boolean GetFlag(int flag)
{
return COMM.VAR.BOOL[flag];
}
public Boolean GetFlag(COMM.eVarBool flag)
{
return COMM.VAR.BOOL[(int)flag];
}
public Boolean SetFlag(byte idx, Boolean value)
{
SetFlagTime[(int)idx] = DateTime.Now; //플래그기록을 시도한 시간
if (value == true)
return Sendcommand(eCommand.SET_FLAG, idx, 1);
else
return Sendcommand(eCommand.SET_FLAG, idx, 0);
}
//public Boolean SetOpt_AD4Invert(Boolean value)
//{
// var idx = (byte)PLCFlag.FLAG_ENABLE_AD4INVERT;
// SetFlagTime[idx] = DateTime.Now; //플래그기록을 시도한 시간
// if (value == true)
// return Sendcommand(eCommand.SET_FLAG, idx, 1);
// else
// return Sendcommand(eCommand.SET_FLAG, idx, 0);
//}
//public Boolean SetLog_SpeedControl(Boolean value)
//{
// var idx = (byte)PLCFlag.FLAG_ENABLE_LOG_SPEED;
// SetFlagTime[idx] = DateTime.Now; //플래그기록을 시도한 시간
// if (value == true)
// return Sendcommand(eCommand.SET_FLAG, idx, 1);
// else
// return Sendcommand(eCommand.SET_FLAG, idx, 0);
//}
public Boolean SetFlag(eVarBool flag, Boolean value)
{
VAR.BOOL[flag] = value;
return true;
}
public Boolean SetEEP(eEEPAddress address, byte value)
{
RaiseMessage(MessageType.Normal, string.Format("[M] Set EEP Rom Addr={0},Val={1}", address, value));
return Sendcommand(eCommand.SET_EEPROM, (byte)address, value);
}
public Boolean SetOutput(byte pinNO, Boolean Value)
{
if (Value == true) return Sendcommand(eCommand.SET_DOUTPUT, pinNO, 1);
else return Sendcommand(eCommand.SET_DOUTPUT, pinNO, 0);
}
public byte ApplySpeedH = 0;
public byte ApplySpeedL = 0;
public byte ApplySpeedC = 0;
public byte ApplySpeedZ = 0;
public DateTime SaveTime = DateTime.Parse("1982-11-23");
public Boolean SetPinReverse(byte High, byte Low)
{
RaiseMessage(MessageType.Normal,
string.Format("Pin Reverse H={0},L={1}", High, Low)
);
bool b1 = Sendcommand(eCommand.SET_EEPROM, (byte)eEEPAddress.EEP_DIREVH, High);
bool b2 = Sendcommand(eCommand.SET_EEPROM, (byte)eEEPAddress.EEP_DIREVL, Low);
return b1 && b2;
}
public Boolean SetMotorUpTime(byte value)
{
RaiseMessage(MessageType.Normal,
string.Format("Motor Up Time Value={0}", value)
);
bool b1 = Sendcommand(eCommand.SET_EEPROM, (byte)eEEPAddress.EEP_UPTIME, value);
return b1;
}
public Boolean SaveEEPROM()
{
RaiseMessage(MessageType.Normal,
string.Format("Save EEPROM")
);
bool b1 = Sendcommand(eCommand.SAVE, 0);
return b1;
}
public Boolean LoadEEPROM()
{
RaiseMessage(MessageType.Normal,
string.Format("Load EEPROM")
);
bool b1 = Sendcommand(eCommand.LOAD, 0);
return b1;
}
//public double ManualSpeed = 0.0;
//public bool SetManualSpeed(double Percvalue)
//{
// var Speed = (byte)((Percvalue / 100.0) * 255.0);
// ManualSpeed = Percvalue;
// // datamanager.COMCONTROLLER.Speak($"{Percvalue} 퍼센트 설정");
// RaiseMessage(MessageType.Normal,
// string.Format("Convert Speed Hold {0}%->{1}", Percvalue, Speed),
// false);
// return Sendcommand(eCommand.SET_MANUALSPEED, Speed);
//}
public DateTime LastPingTime = DateTime.Parse("1982-11-23");
public bool SendPing()
{
LastPingTime = DateTime.Now;
return Sendcommand(eCommand.PINGCHK, 0, 0);
}
public bool ZMot(ZMotDirection dir)
{
if (dir == ZMotDirection.Up)
return Sendcommand(eCommand.GUIDE_MOT, 'A', 'P'); //up
else if (dir == ZMotDirection.Down)
return Sendcommand(eCommand.GUIDE_MOT, 'A', 'N'); //down
else if (dir == ZMotDirection.Stop)
return Sendcommand(eCommand.GUIDE_MOT, 'A', 'S'); //stop
else return false;
}
public bool ZMot_Left(ZMotDirection dir)
{
if (dir == ZMotDirection.Up)
return Sendcommand(eCommand.GUIDE_MOT, 'L', 'P'); //up
else if (dir == ZMotDirection.Down)
return Sendcommand(eCommand.GUIDE_MOT, 'L', 'N'); //down
else if (dir == ZMotDirection.Stop)
return Sendcommand(eCommand.GUIDE_MOT, 'L', 'S'); //stop
else return false;
}
public bool ZMot_Right(ZMotDirection dir)
{
if (dir == ZMotDirection.Up)
return Sendcommand(eCommand.GUIDE_MOT, 'R', 'P'); //up
else if (dir == ZMotDirection.Down)
return Sendcommand(eCommand.GUIDE_MOT, 'R', 'N'); //down
else if (dir == ZMotDirection.Stop)
return Sendcommand(eCommand.GUIDE_MOT, 'R', 'S'); //stop
else return false;
}
/// <summary>
/// 오버로드 또는 L이 활성화되되면 True를 반환함
/// </summary>
/// <returns></returns>
public Boolean IsOverLoad()
{
if (GetValueI(DIName.PINI_OVERLOADL) || GetValueI(DIName.PINI_OVERLOADR)) return true;
else return false;
}
public Boolean IsLimitUp()
{
if (GetValueI(DIName.PINI_LIMIT_LU) || GetValueI(DIName.PINI_LIMIT_RU)) return true;
else return false;
}
public Boolean IsLimitDn()
{
if (GetValueI(DIName.PINI_LIMIT_LD) || GetValueI(DIName.PINI_LIMIT_RD)) return true;
else return false;
}
}
}

59
Cs_HMI/SubProject/ProPLC/PLC.Net45.csproj Normal file
View File

@@ -0,0 +1,59 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{476C8E64-7B6B-4554-ACA2-04302715750F}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Device</RootNamespace>
<AssemblyName>Device_PLC</AssemblyName>
<TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<Deterministic>true</Deterministic>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Arduino\EnumStruct.cs" />
<Compile Include="Arduino\EventsIO.cs" />
<Compile Include="Arduino\MemoryAccess.cs" />
<Compile Include="FakePLC.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\CommData\CommData.csproj">
<Project>{14e8c9a5-013e-49ba-b435-efefc77dd623}</Project>
<Name>CommData</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

36
Cs_HMI/SubProject/ProPLC/Properties/AssemblyInfo.cs Normal file
View File

@@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해
// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면
// 이러한 특성 값을 변경하세요.
[assembly: AssemblyTitle("Device_PLC")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Device_PLC")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에
// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면
// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.
[assembly: ComVisible(false)]
// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다.
[assembly: Guid("476c8e64-7b6b-4554-aca2-04302715750f")]
// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.
//
// 주 버전
// 부 버전
// 빌드 번호
// 수정 버전
//
// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호를
// 기본값으로 할 수 있습니다.
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]