private void DisplayDataBody(TcpResponse tcpResponse)
{
TileDetail detail = selectedMenu.Tag as TileDetail;
BaseControl body = detail.BodyControl;
if (tcpResponse.Exception != null)
{
LogWriter.WriteLog_Error(tcpResponse.Exception);
}
else
{
MachineResponseData [] machineResponse = tcpResponse.MachineResponses;
if (machineResponse[0].Message.Length > 0)
{
//사출기 문제 발생
}
else if (machineResponse[0].IsConnected == false)
{
//사출기 통신 안됨
}
else
{
//정상
body.DisplayData(machineResponse[0].MachineData);
}
}
}
private static void IsSuccess(TcpResponse response)
{
if (response.OnTcpFrame != Tool.Sockets.SupportCode.TcpFrameState.Success)
{
throw response.Exception ?? new Exception("未知错误！");
}
}
private void DisplayMoldName(TcpResponse tcpResponse)
{
MachineResponseData[] machineResponse = tcpResponse.MachineResponses;
if (tcpResponse.Exception != null)
{
LogWriter.WriteLog_Error(tcpResponse.Exception);
}
else
{
//정상
for (int i = 0; i < machineResponse.Length; i++)
{
Dictionary <string, string> machineData = machineResponse[i].MachineData;
string[] fieldCodes = machineData.Keys.ToArray();
string moldName = string.Empty;
for (int j = 0; j < machineData.Count; j++)
{
string fieldCode = fieldCodes[j];
string valueString = machineData.GetValueOrDefault(fieldCode);
decimal valueDecimal;
if (decimal.TryParse(valueString, out valueDecimal))
{
char charA = (char)(valueDecimal / 256);
char charB = (char)(valueDecimal % 256);
moldName += charA;
moldName += charB;
}
}
moldNames[machineResponse[i].MachineCode] = moldName;
}
}
}
public static TcpResponse TheMessage(this TcpResponse response, byte[] message)
{
response.Add(new TcpMessage
{
Message = message
});
return(response);
}
public static TcpResponse DropConnection(this TcpResponse response)
{
response.Add(new TcpMessage
{
TerminateConnection = true
});
return(response);
}
public static TcpResponse TheDelayedMessage(this TcpResponse response, byte[] message, int delayTime)
{
response.Add(new TcpMessage
{
Message = message,
ResponseDelay = delayTime
});
return(response);
}
private void DisplayDataRight(TcpResponse tcpResponse)
{
TileDetail detail = selectedMenu.Tag as TileDetail;
BaseControl right = detail.RightControl;
if (tcpResponse.Exception != null)
{
LogWriter.WriteLog_Error(tcpResponse.Exception);
}
else
{
MachineResponseData[] machineResponse = tcpResponse.MachineResponses;
if (machineResponse[0].Message.Length > 0)
{
//사출기 문제 발생
}
else if (machineResponse[0].IsConnected == false)
{
//사출기 통신 안됨
}
else
{
if (right is gbRight_6 || right is rbRight_6 || right is mcRight_6)
{
Dictionary <string, string> WorkOrderData = new Dictionary <string, string>();
string name = right.Name;
switch (name)
{
case "gbRight_6":
gbRight_6 typeGB = new gbRight_6();
WorkOrderData = typeGB.GetWorkOrderData(machineResponse[0].MachineCode);
typeGB.MatchWorkOrderData(WorkOrderData, machineResponse[0].MachineData);
break;
case "rbRight_6":
rbRight_6 typeRB = new rbRight_6();
WorkOrderData = typeRB.GetWorkOrderData(machineResponse[0].MachineCode);
typeRB.MatchWorkOrderData(WorkOrderData, machineResponse[0].MachineData);
break;
case "mcRight_6":
mcRight_6 typeMC = new mcRight_6();
WorkOrderData = typeMC.GetWorkOrderData(machineResponse[0].MachineCode);
typeMC.MatchWorkOrderData(WorkOrderData, machineResponse[0].MachineData);
break;
}
right.DisplayData(machineResponse[0].MachineData);
}
else
{
right.DisplayData(machineResponse[0].MachineData);
}
}
}
}
private async Task<bool> ListKeys(DataBatch batch, TcpResponse tcpResponse)
{
var writer = tcpResponse.CreateTextResponse();
var keys = await _blobStore.ListKeys<MultilayerNetwork>();
foreach (var key in keys)
{
writer.WriteLine(Util.ConvertProtocol(new Uri(_server.BaseEndpoint, key), tcpResponse.Header.TransportProtocol).ToString());
}
return false;
}
private async Task <TcpResponse> Send(IPAddress ipAddress, ushort port, string data)
{
var tcpResponse = new TcpResponse
{
Target = $"{ipAddress}:{port}"
};
try
{
Console.WriteLine($">>>> endpoint {ipAddress} {ipAddress.AddressFamily.ToString()}:{port}");
var client = new TcpClient();
await client.ConnectAsync(ipAddress, port);
var networkStream = client.GetStream();
var streamWriter = new StreamWriter(networkStream);
var streamReader = new StreamReader(networkStream);
streamWriter.AutoFlush = true;
await streamWriter.WriteAsync(data);
tcpResponse.Response = await streamReader.ReadToEndAsync();
tcpResponse.Success = true;
_lastSuccessEndpointIp = ipAddress;
_lastSuccessPort = port;
client.Close();
return(tcpResponse);
}
catch (Exception ex)
{
tcpResponse.Error = ex;
//Console.WriteLine(ex);
return(tcpResponse);
}
}
private void DisplayMoldName(TcpResponse tcpResponse)
{
if (tcpResponse.Exception == null)
{
MachineResponseData responseData = tcpResponse.MachineResponses[0];
if (responseData.Message.Length > 0)
{
//사출기 문제발생
}
else
{
Dictionary <string, string> machineData = responseData.MachineData;
string[] fieldCodes = machineData.Keys.ToArray();
string moldName = string.Empty;
for (int i = 0; i < machineData.Count; i++)
{
string fieldCode = fieldCodes[i];
string valueString = machineData.GetValueOrDefault(fieldCode);
decimal valueDecimal;
if (decimal.TryParse(valueString, out valueDecimal))
{
char charA = (char)(valueDecimal / 256);
char charB = (char)(valueDecimal % 256);
moldName += charA;
moldName += charB;
}
}
//금형명 표기
setControlText(menu_mold, moldName);
}
}
else
{
LogWriter.WriteLog_Error(tcpResponse.Exception);
}
}
private async Task<bool> Restore(DataBatch batch, TcpResponse tcpResponse)
{
var response = tcpResponse.Content;
var key = batch.Properties["key"];
await _blobStore.Transfer<MultilayerNetwork>(key, response);
return true;
}
private bool ServerStatus(DataBatch batch, TcpResponse tcpResponse)
{
tcpResponse.CreateTextResponse().Write(_server.Status.ToString());
return false;
}
protected virtual Task<bool> HandleRequestError(Exception error, TcpResponse response)
{
DebugOutput.Log(error);
return Task.FromResult(true);
}
private async Task<bool> Process(DataBatch batch, TcpResponse tcpResponse)
{
IRawClassifierTrainingContext<NetworkParameters> ctx = await GetOrCreateContext(batch);
if (batch.Vectors.Any())
{
var iterations = batch.PropertyOrDefault("Iterations", 1);
foreach (var i in Enumerable.Range(0, iterations))
{
foreach (var inputOutputPair in batch
.Vectors
.Select(v => v.Split(ctx.Parameters.InputVectorSize))
.RandomOrder()
)
{
ctx.Train(inputOutputPair[1], inputOutputPair[0]);
}
}
}
if (!batch.KeepAlive)
{
if (batch.PropertyOrDefault("SaveOutput", false))
{
var network = (MultilayerNetwork)ctx.Output;
foreach (var prop in batch.Properties)
{
network.Properties[prop.Key] = prop.Value;
}
var name = batch.PropertyOrDefault("Name", batch.Id);
await _blobStore.StoreAsync(name, network);
}
ctx.Output.Save(tcpResponse.Content);
_trainingContexts.Remove(batch.Id);
}
else
{
if (batch.SendResponse)
{
WriteSummaryResponse(ctx, tcpResponse.Content);
}
}
return true;
}
private bool Delete(DataBatch batch, TcpResponse tcpResponse)
{
var response = tcpResponse.Content;
var key = batch.Properties["key"];
var deleted = _blobStore.Delete<MultilayerNetwork>(key);
batch.Properties["Deleted"] = deleted.ToString();
batch.Save(response);
return deleted;
}
private void DisplayMachineState(TcpResponse tcpResponse)
{
string mode = string.Empty;
if (tcpResponse.Exception == null)
{
MachineResponseData responseData = tcpResponse.MachineResponses[0];
if (responseData.Message.Length > 0)
{
//사출기 문제발생
}
else if (responseData.IsConnected == false)
{
if (commonVar.whichLang == "English")
{
mode = "No Response";
}
else
{
mode = "연결안됨";
}
setControlText(menu_mode, mode, (Image)(Properties.Resources.lostConnection));
}
else
{
Dictionary <string, string> machineState = responseData.MachineData;
if (machineState["A00007"].Equals("1"))
{
//경보 on
if (commonVar.whichLang == "English")
{
mode = "Alarm";
}
else
{
mode = "경보";
}
setControlText(menu_alert, mode, (Image)(Properties.Resources.AlarmOn));
}
else
{
//경보 off
if (commonVar.whichLang == "English")
{
mode = "Alarm";
}
else
{
mode = "경보";
}
setControlText(menu_alert, mode, (Image)(Properties.Resources.AlarmOff));
}
if (machineState["A00001"].Equals("1"))
{
//저속개폐
if (commonVar.whichLang == "English")
{
mode = "Mold setup";
}
else
{
mode = "저속개폐";
}
setControlText(menu_mode, mode, (Image)(Properties.Resources.MoldsetupModeOn));
}
else if (machineState["A00002"].Equals("1"))
{
//수동운전
if (commonVar.whichLang == "English")
{
mode = "Manual";
}
else
{
mode = "수동";
}
setControlText(menu_mode, mode, (Image)(Properties.Resources.ManualModeOn));
}
else if (machineState["A00003"].Equals("1"))
{
//semi auto
if (commonVar.whichLang == "English")
{
mode = "Semi Auto";
}
else
{
mode = "반자동";
}
setControlText(menu_mode, mode, (Image)(Properties.Resources.SemiautoModeOn));
}
else if (machineState["A00004"].Equals("1"))
{
//full auto
if (commonVar.whichLang == "English")
{
mode = "Full Auto";
}
else
{
mode = "자동";
}
setControlText(menu_mode, mode, (Image)(Properties.Resources.FullautoModeOn));
}
if (machineState["A00005"].Equals("1"))
{
//1사이클 완료
//flash 혹은 다른 방법
}
if (machineState["A00008"].Equals("1"))
{
//히터 on
if (commonVar.whichLang == "English")
{
mode = "Heater";
}
else
{
mode = "히터";
}
setControlText(menu_heater, mode, (Image)(Properties.Resources.HeaterOn));
}
else
{
//히터 off
if (commonVar.whichLang == "English")
{
mode = "Heater";
}
else
{
mode = "히터";
}
setControlText(menu_heater, mode, (Image)(Properties.Resources.HeaterOff));
}
if (machineState["A00009"].Equals("1"))
{
//모터 on
if (commonVar.whichLang == "English")
{
mode = "Motor";
}
else
{
mode = "모터";
}
setControlText(menu_motor, mode, (Image)(Properties.Resources.MotorOn));
}
else
{
//모터 off
if (commonVar.whichLang == "English")
{
mode = "Motor";
}
else
{
mode = "모터";
}
setControlText(menu_motor, mode, (Image)(Properties.Resources.MotorOff));
}
}
}
else
{
if (commonVar.whichLang == "English")
{
mode = "No Response";
}
else
{
mode = "연결안됨";
}
setControlText(menu_mode, mode, (Image)(Properties.Resources.lostConnection));
LogWriter.WriteLog_Error(tcpResponse.Exception);
}
}
private async Task<bool> ExecuteRequest(TcpReceiveContext state, TcpResponse tcpResponse)
{
bool continueReceive = false;
try
{
continueReceive = await Process(state, tcpResponse);
}
catch (AggregateException ex)
{
if (ex.InnerException is SocketException)
{
_transportError = true;
}
if (!HandleTransportError(ex))
{
throw;
}
}
catch (Exception ex)
{
if (!await HandleRequestError(ex, tcpResponse))
{
throw;
}
}
await SendResponse(state, tcpResponse);
return continueReceive;
}
private async Task ProcessTcpRequest(Socket clientSocket)
{
bool more = true;
while (more)
{
var reader = new AsyncSocketWriterReader(clientSocket);
using (var state = await reader.ReadAsync())
{
using (var tcpResponse = new TcpResponse(state.Header, _compression))
{
more = await ExecuteRequest(state, tcpResponse);
}
if (more)
{
DebugOutput.LogVerbose("Waiting for more data");
}
else
{
DebugOutput.Log("Ending conversation");
state.ClientSocket.Disconnect(true);
}
}
}
}
private async Task SendResponse(TcpReceiveContext state, TcpResponse tcpResponse)
{
var content = tcpResponse.GetSendStream();
DebugOutput.Log("Sending response ({0} bytes)", content.Length);
var sockStream = new AsyncSocketWriterReader(state.ClientSocket);
await sockStream.WriteAsync(content, tcpResponse.Header);
}
static async Task Main(string[] args)
{
ConsoleHelper.ApplicationBanner("Hello World API");
// *************************************************
// STEP 1: SETUP SERVER
// *************************************************
// Create a new TCP Stumps server
var server = new TcpStumpsServer();
// Define a protocol which accepts messages based on a LF character.
var protocol = new SentinelDelimitedProtocolFactory
{
SentinelValues = new byte[] { (byte)'\n' }
};
server.Protocol = protocol;
// Another protocol allows only fixed-length messages
// var protocol = new FixedLengthProtocolFactory()
// {
// MessageLength = 32
// };
// Yet another handles clients that first send a header which includes the total message length
// which in this example is the first two bytes.
// var protocolX = new HeaderDefinedLengthProtocolFactory()
// {
// HeaderLength = 2,
// LengthCalculator = (headerBytes) => BitConverter.ToInt16(headerBytes, 0)
// };
// Create a default response returned when the server doesn't understand the request.
// The default is to simply disconnect.
var defaultResponse = new TcpResponse
{
new TcpMessage
{
Message = "I don't understand. Choose: animal, sing, quit)\r\n".FromAsciiString()
}
};
server.Protocol.DefaultResponse = defaultResponse;
// The server will only listen for local connections by default
// server.AllowExternalConnection = true;
// An open port will be chosen at random unless specified
// server.ListeningPort = 9100;
// *************************************************
// STEP 2: CREATE SOME STUMPS
// *************************************************
// -------------------------------------------------
// Simple Stump
// -------------------------------------------------
// First we will create a new stump for animals, we will return a different animal each time.
var animalStump = server.AddNewStump("animalStump");
// Now we create a rule for the stump
animalStump.AddRule(new ContainsBytesRule("animal".FromAsciiString()));
// The response factory will choose from one of the possible responses.
var animalResponses = new StumpResponseFactory();
animalResponses.AddResponseMessage("Dog\r\n".FromAsciiString());
animalResponses.AddResponseMessage("Cat\r\n".FromAsciiString());
animalResponses.AddResponseMessage("Lion\r\n".FromAsciiString());
animalResponses.AddResponseMessage("Tiger\r\n".FromAsciiString());
animalResponses.AddResponseMessage("Bear\r\n".FromAsciiString());
animalStump.Responses = animalResponses;
// -------------------------------------------------
// Stump where response sends multiple messages
// -------------------------------------------------
// One stump may require multiple messages to be sent as part of a response
var singStump = server.AddNewStump("sing");
singStump.AddRule(new ContainsBytesRule("sing".FromAsciiString()));
var singResponse = new StumpResponseFactory();
singResponse.Add(new TcpResponse
{
new TcpMessage
{
Message = "Twinkle, twinkle little star\r\n".FromAsciiString()
},
new TcpMessage
{
Message = "How I wonder what you are\r\n".FromAsciiString()
},
new TcpMessage
{
Message = "Up above the world so high\r\n".FromAsciiString(),
ResponseDelay = 2000
},
new TcpMessage
{
Message = "Like a diamond in the sky\r\n".FromAsciiString()
},
new TcpMessage
{
Message = "... you get the idea.\r\n".FromAsciiString()
}
});
singStump.Responses = singResponse;
// -------------------------------------------------
// Stump where response closes the connection
// -------------------------------------------------
var quitStump = server.AddNewStump("quit");
quitStump.AddRule(new ContainsBytesRule("quit".FromAsciiString()));
var quitResponse = new StumpResponseFactory();
quitResponse.Add(new TcpResponse
{
new TcpMessage
{
TerminateConnection = true
}
});
quitStump.Responses = quitResponse;
// *************************************************
// STEP 3: Some happy extras!
// *************************************************
server.OnClientConnection += (o, e) => Console.WriteLine($"Connect => {e.Connection.ConnectionId}");
server.OnClientDisconnect += (o, e) => Console.WriteLine($"Disconnect => {e.Connection.ConnectionId}");
// *************************************************
// STEP 4: RUN THE SERVER!
// *************************************************
await server.StartAsync();
// Show the address to the user
Console.WriteLine($"You can access the server by running telnet > 127.0.0.1 : {server.ListeningPort}");
Console.WriteLine();
ConsoleHelper.WaitForExit();
await server.ShutdownAsync();
}
private async Task<bool> Process(TcpReceiveContext state, TcpResponse response)
{
Stream requestBody;
if (state.Header.ContentLength > 0)
{
state.ReceivedData.Position = 0;
requestBody = _compression.DecompressFrom(state.ReceivedData);
}
else
{
requestBody = Stream.Null;
}
var context = new OwinContext(new TcpRequest(state.Header, requestBody), response, GetUriEndpoint(state.ClientSocket.RemoteEndPoint));
state.Cleanup.Add(response);
state.Cleanup.Add(requestBody);
return await Process(context);
}
/// <summary>
/// 基本执行tcp操作
/// </summary>
/// <param name="cmdTag">指令</param>
/// <returns></returns>
public static TcpResponse TcpSendCmdBase(CmdTag cmdTag)
{
int timeDelay = 0;
bool waitRsp = false;
TcpResponse rsp = new TcpResponse();
MemQueue <CmdTag> cmdlist = new MemQueue <CmdTag>();
TcpCommunication tcpService;
CmdTag cmdRspTag;
tcpService = new TcpCommunication();
timeDelay = 0;
//待socket准备好
while (timeDelay < tcpService.TcpWait)
{
if ((tcpService.SOCKET_STATE == TcpCommunication.TCP_SocketState.SOCKET_CONNECTED) ||
(tcpService.SOCKET_STATE == TcpCommunication.TCP_SocketState.SOCKET_CLOSED))
{
break;
}
Thread.Sleep(100);
timeDelay = timeDelay + 1;
}
if (tcpService.SOCKET_STATE != TcpCommunication.TCP_SocketState.SOCKET_CONNECTED)
{
rsp.Description = "与网关通信失败!";
rsp.Status = false;
return(rsp);
}
timeDelay = 0;
byte[] cmd_send = Command.BuildPlatformCmd(cmdTag);
tcpService.SendData(cmd_send, 0, cmd_send.Length);
cmdRspTag = new CmdTag();
timeDelay = 0;
while (timeDelay < tcpService.TcpWait)
{
if (tcpService.socketData.Buffer.Length >= CommandCommon.CMD_MIN_LENGTH)
{
Command.ParsePlatFormCmd(ref tcpService.socketData.Buffer, ref cmdlist, "");
while (cmdlist.Count > 0)
{
cmdRspTag = cmdlist.Get();
//非本设备的回复
if ((cmdRspTag.DeviceInfo.SerialLong != cmdTag.DeviceInfo.SerialLong))
{
continue;
}
if ((cmdRspTag.CmdType == cmdTag.CmdType) && (cmdRspTag.CmdCode == cmdTag.CmdCode))
{
waitRsp = true;
break;
}
}
}
if (waitRsp == true)
{
break;
}
if (tcpService.SOCKET_STATE == TcpCommunication.TCP_SocketState.SOCKET_CLOSED)
{
break;
}
Thread.Sleep(100);
timeDelay = timeDelay + 1;
}
tcpService.Close();
if (waitRsp == false)
{
rsp.Status = false;
rsp.Description = "等待设备回复超时!";
return(rsp);
}
rsp.Status = false;
rsp.Parameter = new byte[cmdRspTag.Param.Length];
if (rsp.Parameter.Length > 0)
{
Array.Copy(cmdRspTag.Param, rsp.Parameter, cmdRspTag.Param.Length);
}
switch (cmdRspTag.CmdState)
{
case CommandState.CMD_STATE_SUCCESS:
{
rsp.Status = true;
rsp.Description = "设备回复成功";
break;
}
case CommandState.CMD_STATE_FAIL:
{
rsp.Description = "设备回复失败";
break;
}
case CommandState.CMD_STATE_NOT_SUPPORT:
{
rsp.Description = "设备回复不支持";
break;
}
default:
{
rsp.Description = "未知回复";
break;
}
}
return(rsp);
}
protected override Task<bool> HandleRequestError(Exception error, TcpResponse response)
{
DebugOutput.Log(error);
Write(response.Content, d =>
{
d.Properties["ErrorMessage"] = error.Message;
d.Properties["ErrorType"] = error.GetType().AssemblyQualifiedName;
d.Properties["ErrorStackTrace"] = error.StackTrace;
});
return Task.FromResult(true);
}
static async Task Main(string[] args)
{
ConsoleHelper.ApplicationBanner("Hello World (Fluent) API");
// *************************************************
// STEP 1: SETUP SERVER
// *************************************************
// Create a new Stumps server
var server = new TcpStumpsServer();
server.UsesProtocol()
.WithSentinelsToDeliminateMessages(
readPastSentinelLength: 1,
sentinels: 13
).ReturnsByDefault()
.TheMessage("I don't understand. (Choose \"animal\", \"sing\", \"noop\" or \"quit\")\r\n".FromAsciiString());
var onConnectionResponse = new TcpResponse
{
new TcpMessage {
Message = "Welcome to TCP-Stumps!\r\n".FromAsciiString()
}
};
server.Protocol.ResponseOnConnection = onConnectionResponse;
// *************************************************
// STEP 2: CREATE SOME STUMPS
// *************************************************
// First we will create a new stump for animals, we will return a different animal with each request.
server.HandlesRequest()
.WhenMessageContainsBytes("animal".FromAsciiString())
.RespondWith()
.TheMessage("Dog\r\n".FromAsciiString())
.TheMessage("Cat\r\n".FromAsciiString())
.TheMessage("Lion\r\n".FromAsciiString())
.TheMessage("Tiger\r\n".FromAsciiString())
.TheMessage("Bear\r\n".FromAsciiString());
// One stump may require multiple messages to be sent as part of a single response. Each one can have
// its own delay or simply drop the connection.
server.HandlesRequest()
.WhenMessageContainsBytes("sing".FromAsciiString())
.RespondWith().MultipleMessages()
.TheMessage("Twinkle, twinkle little star\r\n".FromAsciiString())
.TheMessage("How I wonder what you are\r\n".FromAsciiString())
.TheDelayedMessage(
message: "Up above the world so high\r\n".FromAsciiString(),
delayTime: 2000)
.TheMessage("Like a diamond in the sky.\r\n".FromAsciiString())
.TheMessage("... you get the idea.\r\n".FromAsciiString());
// This one doesn't do anything at all.
server.HandlesRequest()
.WhenMessageContainsBytes("noop".FromAsciiString())
.RespondWith().Nothing();
// Easy to drop the connection when a user calls "quit"
server.HandlesRequest()
.WhenMessageContainsBytes("quit".FromAsciiString())
.RespondWith().DropConnection();
// *************************************************
// STEP 3: Some happy extras!
// *************************************************
server.OnClientConnection += (o, e) => Console.WriteLine($"Connect => {e.Connection.ConnectionId}");
server.OnClientDisconnect += (o, e) => Console.WriteLine($"Disconnect => {e.Connection.ConnectionId}");
// *************************************************
// STEP 4: RUN THE SERVER!
// *************************************************
await server.StartAsync();
// Show the address to the user
Console.WriteLine($"You can access the server by running telnet > 127.0.0.1 : {server.ListeningPort}");
Console.WriteLine();
ConsoleHelper.WaitForExit();
await server.ShutdownAsync();
}
/// <summary>
/// 통신 오류 발생시 서버 off인걸로 판단. 메시지 팝업 이후 타이머 동작 X
/// </summary>
/// <param name="tcpResponse"></param>
private void DisplayMachineState(TcpResponse tcpResponse)
{
DataTable sourceTable = createGridSource();
if (tcpResponse.Exception != null)
{
LogWriter.WriteLog_Error(tcpResponse.Exception);
}
else
{
string message = string.Empty;
MachineResponseData[] machineResponse = tcpResponse.MachineResponses;
//정상
for (int i = 0; i < machineResponse.Length; i++)
{
DataRow dataRow = sourceTable.NewRow();
MachineResponseData responseData = machineResponse[i];
if (responseData.Message.Length > 0)
{
//사출기 문제발생
message = responseData.Message;
}
else if (responseData.IsConnected == false)
{
message = "통신 연결 안됨";
}
else
{
Dictionary <string, string> machineState = responseData.MachineData;
if (machineState != null)
{
MachineStateImageIndex state = MachineStateImageIndex.Null;
if (machineState.GetValueOrDefault("A00007") == "1")
{
state = MachineStateImageIndex.Alert;
}
else if (machineState.GetValueOrDefault("A00001") == "1")
{
state = MachineStateImageIndex.Slow;
}
else if (machineState.GetValueOrDefault("A00002") == "1")
{
state = MachineStateImageIndex.Manual;
}
else if (machineState.GetValueOrDefault("A00003") == "1")
{
state = MachineStateImageIndex.SemiAuto;
}
else if (machineState.GetValueOrDefault("A00004") == "1")
{
state = MachineStateImageIndex.FullAuto;
}
else
{
state = MachineStateImageIndex.Null;
}
//state 1 저속개폐 2 수동 3 세미오토 4 풀오토
dataRow["STATE"] = (int)state;
dataRow["targetQty"] = machineState.GetValueOrDefault("S00002");
dataRow["productQty"] = machineState.GetValueOrDefault("A00011");
message = "통신 정상 작동 중";
}
}
dataRow["MESSAGE"] = message;
string machineCode = responseData.MachineCode;
MachineInformation machineInfo = machineInformations.First(x => x.MachineCode == machineCode);
dataRow["MACHINE_CODE"] = machineCode;
dataRow["MACHINE_NAME"] = machineInfo.MachineName;
dataRow["MACHINE_NUMBER"] = machineInfo.MachineNumber;
dataRow["MACHINE_TYPE"] = machineInfo.MachineType;
if (moldNames.ContainsKey(machineCode))
{
dataRow["moldName"] = moldNames[machineCode];
}
sourceTable.Rows.Add(dataRow);
}
}
setGridControlSource(sourceTable);
}
