Lucio Maranta
2089 lines
74 KiB
C#
2089 lines
74 KiB
C#
using CMS_CORE.Demo.Models;
|
|
using CMS_CORE.Utils;
|
|
using CMS_CORE_Library.Demo.Models;
|
|
using Nc_Demo_Application.Server.Service;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Description;
|
|
using System.Threading;
|
|
using static CMS_CORE.Nc;
|
|
using static CMS_CORE_Library.DataStructures;
|
|
using static CMS_CORE.Demo.MEMORY_ADDRESS;
|
|
using static CMS_CORE_Library.ToolConfigurations;
|
|
|
|
namespace CMS_CORE.Demo
|
|
{
|
|
public class Nc_Demo : Nc
|
|
{
|
|
private EndpointAddress serverAddress;
|
|
private ChannelFactory<ILibraryService> cf;
|
|
private ILibraryService serverService;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region Contructor & global methods
|
|
|
|
public Nc_Demo(String IpAddress, ushort RemotePort)
|
|
{
|
|
Ip = IpAddress;
|
|
Port = RemotePort;
|
|
}
|
|
|
|
public override CmsError NC_Connect()
|
|
{
|
|
// Create new connection to the demo server
|
|
String url = "http://" + Ip + ":" + Port + "/api";
|
|
serverAddress = new EndpointAddress(url);
|
|
|
|
cf = new ChannelFactory<ILibraryService>(new WebHttpBinding(), serverAddress);
|
|
cf.Endpoint.EndpointBehaviors.Add(new WebHttpBehavior());
|
|
|
|
serverService = cf.CreateChannel();
|
|
string serialNumber = "";
|
|
|
|
try
|
|
{
|
|
// Get serial number from Demo server
|
|
serverService.GetSerialNumber(out serialNumber);
|
|
Connected = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_Disconnect()
|
|
{
|
|
if (cf != null)
|
|
cf.Close();
|
|
|
|
Connected = false;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_GetTranslatedPlcMessages(string language, ref Dictionary<int, string> messages)
|
|
{
|
|
try
|
|
{
|
|
messages = new Dictionary<int, string>();
|
|
serverService.GetTranslations(language, out messages);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
#endregion Contructor & global methods
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region High level methods
|
|
|
|
public override CmsError NC_RDateTime(ref DateTime ActualTime)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get datetime from Demo server
|
|
string demoDateTime = "";
|
|
serverService.GetDateTime(out demoDateTime);
|
|
|
|
ActualTime = Convert.ToDateTime(demoDateTime);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RSerialNumber(ref String SN)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get serial number from Demo server
|
|
serverService.GetSerialNumber(out SN);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//Get the NC model Name
|
|
public override CmsError NC_RModelName(ref string ModelName)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.GetModel(out ModelName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RSoftwareVersion(ref String SWV)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get software version from Demo server
|
|
serverService.GetSoftwareVersion(out SWV);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RMachineNumber(ref string MachNumber)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get machine number from Demo server
|
|
serverService.GetMachineNumber(out MachNumber);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RProcessesNum(ref ushort ProcNumber)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{ // Get Process Cout from Demo server
|
|
serverService.GetProcessNumber(out ProcNumber);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RLanguage(ref CultureInfo Language)
|
|
{
|
|
//Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get language from Demo server
|
|
string demoLanguage = "";
|
|
serverService.GetLanguage(out demoLanguage);
|
|
|
|
Language = ConverToSTEPLanguage(demoLanguage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RActiveAlarms(ref List<AlarmModel> alarms)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
alarms.Clear();
|
|
|
|
List<NcAlarmModel> demoAlarms;
|
|
// Get Alarms from server
|
|
serverService.NcAlarms(out demoAlarms);
|
|
// Parse response
|
|
foreach (NcAlarmModel demoAlarm in demoAlarms)
|
|
{
|
|
AddNcAlarmToList((uint)demoAlarm.code, demoAlarm.text, alarms);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// Check if the NC is in running state
|
|
public override CmsError NC_RIsRunning(ref bool running)
|
|
{
|
|
ushort nProcess = 0;
|
|
// Get the number of processes
|
|
CmsError cmsError = NC_RProcessesNum(ref nProcess);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
ushort i = 1;
|
|
running = false;
|
|
do
|
|
{
|
|
PROC_STATUS procStatus = PROC_STATUS.IDLE;
|
|
|
|
// Read process status
|
|
cmsError = PROC_RStatus(i, ref procStatus);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
// If one process is runninc, nc is running
|
|
if (procStatus == PROC_STATUS.RUN)
|
|
running = true;
|
|
i++;
|
|
} while (!running || i <= nProcess);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
#endregion High level methods
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region PLC High-level data
|
|
|
|
//public override CmsError PLC_RActiveMessages(ref List<PlcAlarmModel> alarms)
|
|
//{
|
|
// try
|
|
// {
|
|
// alarms.Clear();
|
|
// List<int> readValues = new List<int>();
|
|
|
|
// // Read status alarm data data from memory
|
|
// CmsError cmsError = MEM_RWIntegerList(R, 0,
|
|
// ALARMS_STATUS.MemType,
|
|
// ALARMS_STATUS.Address,
|
|
// ALARMS_STATUS.Size / 4,
|
|
// ref readValues);
|
|
|
|
// bool[] statusBits = new BitArray(readValues.ToArray()).Cast<bool>().ToArray();
|
|
|
|
// // Convert array into structured data
|
|
// byte alarmData = 0;
|
|
// for (int i = 0; i < statusBits.Count(); i++)
|
|
// {
|
|
// // If alarm is active
|
|
// if (statusBits[i])
|
|
// {
|
|
// // Read data from plc
|
|
// cmsError = MEM_RWByte(R, 0, ALARMS_DATA.MemType, ALARMS_DATA.Address + i, 0, ref alarmData);
|
|
// if (cmsError.IsError())
|
|
// return cmsError;
|
|
// var dataBits = new BitArray(new int[] { alarmData }).Cast<bool>().ToArray();
|
|
// var processList = new List<int>();
|
|
|
|
// for(int j = 2; j < 8; j++)
|
|
// {
|
|
// if (dataBits[j])
|
|
// processList.Add(j - 1);
|
|
// }
|
|
|
|
// alarms.Add(new PlcAlarmModel()
|
|
// {
|
|
// Id = (uint)i,
|
|
// IsWarning = dataBits[0],
|
|
// RestorationIsActive = dataBits[1],
|
|
// Process = processList
|
|
// });
|
|
// }
|
|
// }
|
|
// ///////////////////////////////
|
|
// //alarms.Clear();
|
|
|
|
// //List<NcAlarmModel> demoAlarms;
|
|
// //// Get Alarms from server
|
|
// //serverService.PlcAlarms(out demoAlarms);
|
|
// //// Parse response
|
|
// //foreach (NcAlarmModel demoAlarm in demoAlarms)
|
|
// //{
|
|
// // AddAlarmToList((uint)demoAlarm.code, demoAlarm.text, alarms);
|
|
// //}
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// return ManageException(ex);
|
|
// }
|
|
|
|
// return NO_ERROR;
|
|
//}
|
|
|
|
public override CmsError PLC_RActiveMessages(ref List<PlcAlarmModel> alarms)
|
|
{
|
|
alarms.Clear();
|
|
List<int> readValues = new List<int>();
|
|
|
|
// Read on data from memory
|
|
CmsError cmsError = MEM_RWIntegerList(R, 0,
|
|
ALARMS_STATUS.MemType,
|
|
ALARMS_STATUS.Address,
|
|
(ALARMS_STATUS.Size + ALARMS_DATA.Size) / 4,
|
|
ref readValues);
|
|
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
// Convert integer array into bit array
|
|
bool[] statusBits = new BitArray(readValues.ToArray()).Cast<bool>().ToArray();
|
|
|
|
for (int i = 0; i < ALARMS_STATUS.Size * 8; i++)
|
|
{
|
|
// If alarm is active
|
|
if (statusBits[i])
|
|
{
|
|
// Calculate matching alarm byte info address
|
|
int dataByteAddress = i * 8 + (ALARMS_STATUS.Size * 8);
|
|
|
|
var processList = new List<int>();
|
|
|
|
// Get processes on which alarm is active
|
|
for (int j = dataByteAddress; j < dataByteAddress + 6; j++)
|
|
{
|
|
if (statusBits[j])
|
|
processList.Add(j + 1 - dataByteAddress);
|
|
}
|
|
// Add alarm info into active alarms list
|
|
alarms.Add(new PlcAlarmModel()
|
|
{
|
|
Id = (uint)i + 1,
|
|
IsWarning = statusBits[dataByteAddress + 7],
|
|
RestorationIsActive = statusBits[dataByteAddress + 6],
|
|
Process = processList
|
|
});
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WRefreshMessage(uint id)
|
|
{
|
|
// Check id range
|
|
if (id > ALARMS_NUMBER)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
|
|
CmsError cmsError;
|
|
bool readValue = false;
|
|
bool writeValue = true;
|
|
|
|
int ackByte = ALARM_ACK.Address + (((int)id - 1) / 8);
|
|
int strobeByte = ALARM_REFRESH_STROBE.Address + (((int)id - 1) / 8);
|
|
int alarmBitId = (((int)id - 1) % 8);
|
|
|
|
// Check ACK
|
|
cmsError = MEM_RWBoolean(R, 0, ALARM_ACK.MemType, ackByte, alarmBitId, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// If PLC it's performing another request then return
|
|
if (readValue)
|
|
return NO_ERROR;
|
|
|
|
// Write data
|
|
cmsError = MEM_RWBoolean(W, 0, ALARM_REFRESH_STROBE.MemType, strobeByte, alarmBitId, ref writeValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// Reset wait ack = 1 and reset the strobe
|
|
cmsError = ResetStrobe(alarmBitId, strobeByte, ackByte, ALARM_REFRESH_STROBE.MemType);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WRestoreMessage(uint id)
|
|
{
|
|
// Call restore message
|
|
CmsError cmsError = PLC_WRefreshMessage(id);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WRefreshAllMessages()
|
|
{
|
|
int numberOfInteger = (32 / 8) / 4;
|
|
List<uint> defaultValue = Enumerable.Repeat(uint.MaxValue, numberOfInteger).ToList();
|
|
|
|
CmsError cmsError = MEM_RWDWordList(W, 0, ALARM_REFRESH_STROBE.MemType, ALARM_REFRESH_STROBE.Address, numberOfInteger, ref defaultValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RPowerOnData(ref PreAndPostPowerOnModel powerOnModel)
|
|
{
|
|
int readValue = 0;
|
|
// Read pre power on and post power on data from memory
|
|
CmsError cmsError = MEM_RWInteger(R, 0, PRE_POWER_ON.MemType, PRE_POWER_ON.Address, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
bool[] bits = new bool[32];
|
|
|
|
// Convert int into to true/false array
|
|
bits = new BitArray(new int[] { readValue }).Cast<bool>().ToArray();
|
|
// Create adn set pre power on object
|
|
PrePowerOnModel prePowerOn = new PrePowerOnModel()
|
|
{
|
|
PowerOn = new PowerOnDataModel() { Id = 0, Active = bits[0], Clickable = bits[8] }, // id = N, bits = N, Clickable = N + 8 (Second bit)
|
|
AirPressure = new PowerOnDataModel() { Id = 1, Active = bits[1], Clickable = bits[9] },
|
|
ProtectionStatus = new PowerOnDataModel() { Id = 2, Active = bits[2], Clickable = bits[10] },
|
|
EmergencyButtons = new PowerOnDataModel() { Id = 3, Active = bits[3], Clickable = bits[11] },
|
|
SettingMode = new PowerOnDataModel() { Id = 4, Active = bits[4], Clickable = bits[12] },
|
|
StartingKey = new PowerOnDataModel() { Id = 5, Active = bits[5], Clickable = bits[13] }
|
|
};
|
|
// Create and set post power on object
|
|
PostPowerOnModel postPowerOn = new PostPowerOnModel()
|
|
{
|
|
AxisReset = new PowerOnDataModel() { Id = 8, Active = bits[16], Clickable = bits[24] }, // id = N - 8, bits = N, Clickable = N + 8 (Second bit)
|
|
WaterjetPump = new PowerOnDataModel() { Id = 9, Active = bits[17], Clickable = bits[25] }
|
|
};
|
|
|
|
powerOnModel = new PreAndPostPowerOnModel()
|
|
{
|
|
PostPowerOn = postPowerOn,
|
|
PrePowerOn = prePowerOn
|
|
};
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WPowerOnData(uint id, bool value)
|
|
{
|
|
CmsError cmsError;
|
|
// Check bit range
|
|
if (id > 16)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
// Choose Pre-Power-On or Post-Power-Om
|
|
if (id < 8)
|
|
// Pre: memory bit = id
|
|
cmsError = MEM_RWBoolean(W, 0, PRE_POWER_ON_CLICKED.MemType, PRE_POWER_ON_CLICKED.Address, (int)id, ref value);
|
|
else
|
|
// Post: memory bit = id - 8
|
|
cmsError = MEM_RWBoolean(W, 0, POST_POWER_ON_CLICKED.MemType, POST_POWER_ON_CLICKED.Address, (int)id - 8, ref value);
|
|
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RFunctionAccess(ref List<FunctionalityModel> functions)
|
|
{
|
|
List<int> readValues = new List<int>();
|
|
// Read functions access data from memory
|
|
CmsError cmsError = MEM_RWIntegerList(R, 0, FUNCTION_ACCESS.MemType, FUNCTION_ACCESS.Address, 4, ref readValues);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
functions = new List<FunctionalityModel>();
|
|
// Convert int into to true/false array
|
|
bool[] bits = new BitArray(readValues.ToArray()).Cast<bool>().ToArray();
|
|
// Convert array into structured data
|
|
for (int i = 0; i < bits.Count(); i++)
|
|
{
|
|
functions.Add(new FunctionalityModel()
|
|
{
|
|
Id = (uint)i,
|
|
IsActive = bits[i]
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RAxesResetData(ref AxisResetDataModel axisResetData)
|
|
{
|
|
byte value = 0;
|
|
// Read byte from memory
|
|
CmsError cmsError = MEM_RWByte(R, 0, AXIS_RESET_PROCEDURE.MemType, AXIS_RESET_PROCEDURE.Address, 1, ref value);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// Check last bit
|
|
if ((value & 128) == 128)
|
|
{
|
|
// Set to 0 last bit and 7 bit percentage and check if is higher than 100
|
|
byte percentage = value - 128 > 100 ? (byte)100 : (byte)(value - 128);
|
|
axisResetData = new AxisResetDataModel()
|
|
{
|
|
IsActive = true,
|
|
Percentage = percentage
|
|
};
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RMachineCounters(ref List<CounterModel> counters)
|
|
{
|
|
counters = new List<CounterModel>();
|
|
List<int> readValues = new List<int>();
|
|
// Read on data from memory
|
|
CmsError cmsError = MEM_RWIntegerList(R, 0, COUNTERS.MemType, COUNTERS.Address, COUNTERS.Size / 4, ref readValues);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// Foreach counters
|
|
for (int i = 0; i < readValues.Count; i++)
|
|
{
|
|
// Add counters value into returned value
|
|
counters.Add(new CounterModel()
|
|
{
|
|
Id = (uint)i,
|
|
Value = (uint)readValues[i]
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RNcSoftKeys(ref List<SoftKeysModel> ncSoftKeys)
|
|
{
|
|
CmsError cmsError = PLC_RSoftKeys(NC_SOFTKEYS_VALUE, NC_SOFTKEYS_CLICKABLE, ref ncSoftKeys);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RUserSoftKeys(ref List<SoftKeysModel> softKeys)
|
|
{
|
|
CmsError cmsError = PLC_RSoftKeys(USER_SOFTKEYS_VALUE, USER_SOFTKEYS_CLICKABLE, ref softKeys);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
private CmsError PLC_RSoftKeys(MEMORY_CELL softKeyStatusMemory, MEMORY_CELL softKeysClickableMemory, ref List<SoftKeysModel> softKeys)
|
|
{
|
|
softKeys = new List<SoftKeysModel>();
|
|
List<int> readValue = new List<int>();
|
|
|
|
int memorySizeToRead = (softKeyStatusMemory.Size + softKeysClickableMemory.Size);
|
|
// Offset between status and clicable data
|
|
int offset = softKeyStatusMemory.Size * 8;
|
|
|
|
// Read on data from memory
|
|
CmsError cmsError = MEM_RWIntegerList(R, 0,
|
|
softKeyStatusMemory.MemType,
|
|
softKeyStatusMemory.Address,
|
|
memorySizeToRead / 4,
|
|
ref readValue);
|
|
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
bool[] bits = new BitArray(readValue.ToArray()).Cast<bool>().ToArray();
|
|
|
|
// Convert array into structured data
|
|
for (ushort i = 0; i < bits.Count() / 2; i++)
|
|
{
|
|
softKeys.Add(new SoftKeysModel()
|
|
{
|
|
Id = (uint)i + 1,
|
|
Value = bits[i],
|
|
Active = bits[i + offset]
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WNcSoftKey(uint id)
|
|
{
|
|
// Check id range
|
|
if (id > NC_SOFTKEYS_NUMBER)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
|
|
CmsError cmsError;
|
|
bool readValue = false;
|
|
bool writeValue = true;
|
|
|
|
int ackByte = NC_SOFT_KEYS_ACK.Address + (((int)id - 1) / 8);
|
|
int strobeByte = NC_SOFT_KEYS_CLICKED.Address + (((int)id - 1) / 8);
|
|
int softkeyBitId = (((int)id - 1) % 8);
|
|
|
|
// Check ACK
|
|
cmsError = MEM_RWBoolean(R, 0, NC_SOFT_KEYS_ACK.MemType, ackByte, softkeyBitId, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// If PLC it's performing another request then return
|
|
if (readValue)
|
|
return NO_ERROR;
|
|
|
|
// Write data
|
|
cmsError = MEM_RWBoolean(W, 0, NC_SOFT_KEYS_CLICKED.MemType, strobeByte, softkeyBitId, ref writeValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// Reset wait ack = 1 and reset the strobe
|
|
cmsError = ResetStrobe(softkeyBitId, strobeByte, ackByte, NC_SOFT_KEYS_CLICKED.MemType);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WUserSoftKey(uint id)
|
|
{
|
|
// Check id range
|
|
if (id > USER_SOFTKEYS_NUMBER)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
|
|
CmsError cmsError;
|
|
bool readValue = false;
|
|
bool writeValue = true;
|
|
|
|
int ackByte = USER_SOFT_KEYS_ACK.Address + (((int)id - 1) / 8);
|
|
int strobeByte = USER_SOFT_KEYS_CLICKED.Address + (((int)id - 1) / 8);
|
|
int softkeyBitId = (((int)id - 1) % 8);
|
|
|
|
// Check ACK
|
|
cmsError = MEM_RWBoolean(R, 0, USER_SOFT_KEYS_ACK.MemType, ackByte, softkeyBitId, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// If PLC it's performing another request then return
|
|
if (readValue)
|
|
return NO_ERROR;
|
|
|
|
// Write data
|
|
cmsError = MEM_RWBoolean(W, 0, USER_SOFT_KEYS_CLICKED.MemType, strobeByte, softkeyBitId, ref writeValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// Reset wait ack = 1 and reset the strobe
|
|
cmsError = ResetStrobe(softkeyBitId, strobeByte, ackByte, USER_SOFT_KEYS_CLICKED.MemType);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_RHeadsData(List<HeadDataModel> heads, int number)
|
|
{
|
|
// Check parameters
|
|
if (number > 20)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
heads.Clear();
|
|
|
|
List<int> readInts = new List<int>();
|
|
List<byte> readValues = new List<byte>();
|
|
// Find the size of a single head
|
|
int headsByte = (HEADS_DATA.Size / HEADS_NUMBER);
|
|
double headsInts = Math.Ceiling((double)(headsByte / 4 ) + 1);
|
|
|
|
// Read data for N heads
|
|
CmsError cmsError = MEM_RWIntegerList(R, 0, HEADS_DATA.MemType, 0,HEADS_DATA.Address, (int)headsInts * number, ref readInts);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
readValues = readInts.SelectMany(BitConverter.GetBytes).ToList();
|
|
|
|
// Parse and format readed data
|
|
for (int i = 0; i < number; i++)
|
|
{
|
|
// Head address = posizion * size of single head in memory
|
|
var headOffset = i * headsByte;
|
|
heads.Add(new HeadDataModel()
|
|
{
|
|
Id = (uint)i + 1,
|
|
Process = readValues[headOffset],
|
|
Override = readValues[headOffset + 1],
|
|
Load_Abrasive = BitConverter.ToUInt16(readValues.ToArray(), headOffset + 2), // Uint16 = 2 byte
|
|
ActualSpeed_Pressure = BitConverter.ToInt32(readValues.ToArray(), headOffset + 4), // Int32 = 4byte
|
|
MountedTool_Vacum = BitConverter.ToInt16(readValues.ToArray(), headOffset + 8), // Uint 16 = 2byte
|
|
IsActive = (readValues[headOffset + 10] & 1) != 0, // bit 0
|
|
IsSelected = (readValues[headOffset + 10] & 2) != 0, // bit 1
|
|
OverrideEditable = (readValues[headOffset + 10] & 4) != 0 // bit 2
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PLC_WHeadOverride(uint id, HEAD_OVERRIDE_SIGN sign)
|
|
{
|
|
if (id > HEADS_NUMBER)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
|
|
CmsError cmsError;
|
|
bool readValue = false;
|
|
bool writeValue = true;
|
|
|
|
MEMORY_CELL currentStrobeCell = sign == HEAD_OVERRIDE_SIGN.PLUS ? HEADS_STROBE_INCREMENT : HEADS_STROBE_DECREMENT;
|
|
|
|
int ackByte = HEADS_ACK.Address + (((int)id - 1) / 8);
|
|
int strobeByte = currentStrobeCell.Address + (((int)id - 1) / 8);
|
|
int headBit = (((int)id - 1) % 8);
|
|
|
|
// Check ACK
|
|
cmsError = MEM_RWBoolean(R, 0, HEADS_ACK.MemType, ackByte, headBit, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// If PLC it's performing another request then return
|
|
if (readValue)
|
|
return NO_ERROR;
|
|
|
|
// Write strobe data
|
|
cmsError = MEM_RWBoolean(W, 0, currentStrobeCell.MemType, strobeByte, headBit, ref writeValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// Reset wait ack = 1 and reset the strobe
|
|
cmsError = ResetStrobe(headBit, strobeByte, ackByte, currentStrobeCell.MemType);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
private CmsError ResetStrobe(int bitId, int strobeByte, int ackByte, MEMORY_TYPE memType)
|
|
{
|
|
int n = 5;
|
|
bool readValue = false;
|
|
bool writeValue = false;
|
|
CmsError cmsError;
|
|
do
|
|
{
|
|
// Check ACK
|
|
cmsError = MEM_RWBoolean(R, 0, memType, ackByte, bitId, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
// If true reset strobe
|
|
if (readValue == true)
|
|
{
|
|
// Reset strobe
|
|
cmsError = MEM_RWBoolean(W, 0, memType, strobeByte, bitId, ref writeValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
// Exit from cycle
|
|
n = 0;
|
|
}
|
|
else
|
|
{
|
|
// Decrement
|
|
n--;
|
|
// Wait befor next cycle
|
|
Thread.Sleep(20);
|
|
}
|
|
} while (n > 0);
|
|
|
|
return cmsError;
|
|
}
|
|
|
|
#endregion PLC High-level data
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region PROCESS (PATH) High-level data
|
|
|
|
public override CmsError PROC_RStatus(ushort ProcNumber, ref PROC_STATUS Status)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get status from server
|
|
serverService.GetProcessStatus(ProcNumber.ToString(), out int demoStatus);
|
|
|
|
Status = (PROC_STATUS)demoStatus;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PROC_RMode(ushort ProcNumber, ref PROC_MODE Mode)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get mode from server
|
|
serverService.GetProcessMode(ProcNumber.ToString(), out int demoMode);
|
|
|
|
Mode = (PROC_MODE)demoMode;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PROC_RActiveAlarms(ushort ProcNumber, ref List<AlarmModel> alarms)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
alarms.Clear();
|
|
serverService.GetProcessAlarms(ProcNumber.ToString(), out List<NcAlarmModel> demoAlarms);
|
|
|
|
// Parse response
|
|
foreach (NcAlarmModel demoAlarm in demoAlarms)
|
|
{
|
|
AddAlarmToList((uint)demoAlarm.code, demoAlarm.text, demoAlarm.processId, alarms);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PROC_RPPLines(ushort ProcNumber, ref List<string> Lines)
|
|
{
|
|
return FUNCTION_NOT_ALLOWED_ERROR;
|
|
}
|
|
|
|
// Get process part program data
|
|
public override CmsError PROC_RStatusAndData(ushort procNumber, ref ProcessDataModel processData)
|
|
{
|
|
processData.Id = procNumber;
|
|
// Read part program name
|
|
CmsError cmsError = PROC_RPPName(procNumber, ref processData.PartProgramName);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
ushort readValue = 0;
|
|
// Read processes status from memory
|
|
cmsError = MEM_RWWord(R, 0, PROCESS_STATUS.MemType, PROCESS_STATUS.Address + 2 * (procNumber - 1), ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
byte[] bytes = BitConverter.GetBytes(readValue);
|
|
|
|
// Convert Byte into true/false array
|
|
BitArray bits = new BitArray(new byte[] { bytes[0] }); //1st byte -> 0 : Proccess type (AUX-WORK), 1: Process in alarm status, 2: Run, 3: Hold, 4: Read, 5: PartProgramVisible
|
|
|
|
// Get part program info visibility
|
|
processData.Visible = bits[0];
|
|
processData.IsInAlarm = bits[1];
|
|
processData.IsSelected = bits[2];
|
|
// Populate response structure
|
|
processData.Type = bits[3] ? "AUX" : "WORK";
|
|
|
|
|
|
// Choose process status
|
|
if (bits[4])
|
|
processData.Status = "HOLD";
|
|
else
|
|
{
|
|
if (bits[5])
|
|
processData.Status = "RUN";
|
|
else
|
|
processData.Status = "READY";
|
|
}
|
|
|
|
|
|
|
|
// Get Reps from 2nd byte
|
|
processData.Reps = bytes[1];
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PROC_RSelectedProcess(ref ushort procNumber)
|
|
{
|
|
CmsError cmsError;
|
|
bool readValue = false;
|
|
|
|
for (int i = 0; i < PROCESS_NUMBER; i++)
|
|
{
|
|
int memoryAddress = SELECTED_PROCESS.Address + i * (2);
|
|
// Read memory from plc
|
|
cmsError = MEM_RWBoolean(R, 0, SELECTED_PROCESS.MemType, memoryAddress, SELECTED_PROCESS.SubAddress, ref readValue);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
if (readValue)
|
|
{
|
|
procNumber = (ushort)(i + 1);
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PROC_WSelectProcess(ushort procNumber)
|
|
{
|
|
CmsError cmsError;
|
|
byte processNum = (byte)procNumber;
|
|
|
|
// Check parameter
|
|
if (processNum > PROCESS_NUMBER)
|
|
return INCORRECT_PARAMETERS_ERROR;
|
|
|
|
// Write process number
|
|
cmsError = MEM_RWByte(W, 0, SELECT_PROCESS.MemType, SELECT_PROCESS.Address, 1, ref processNum);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
#endregion PROCESS (PATH) High-level data
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region PROCESS-AXES (PATH) High-level data
|
|
|
|
public override CmsError AXES_RInterpPosition(ushort ProcNumber, ref Dictionary<string, double> Axes)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get axes position from Demo Server
|
|
serverService.GetAxesPosition(ProcNumber.ToString(), out List<NcAxisModel> demoAxes);
|
|
|
|
// Parse server response
|
|
foreach (NcAxisModel demoAxis in demoAxes)
|
|
{
|
|
Axes.Add(demoAxis.name, demoAxis.actual);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_RProgrPosition(ushort ProcNumber, ref Dictionary<string, double> Axes)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get Axes Position from server
|
|
serverService.GetAxesPosition(ProcNumber.ToString(), out List<NcAxisModel> demoAxes);
|
|
// Parse server response and retrieve programmed position
|
|
foreach (NcAxisModel demoAxis in demoAxes)
|
|
{
|
|
Axes.Add(demoAxis.name, demoAxis.programmed);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_RMachinePosition(ushort procNumber, ref Dictionary<string, double> Axes)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
try
|
|
{
|
|
// Get Axes Position from server
|
|
serverService.GetAxesPosition(procNumber.ToString(), out List<NcAxisModel> demoAxes);
|
|
|
|
// Parse Server response and retrieve machine position
|
|
foreach (NcAxisModel demoAxis in demoAxes)
|
|
{
|
|
Axes.Add(demoAxis.name, demoAxis.machinePosition);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_RFollowingError(ushort procNumber, ref Dictionary<string, double> Axes)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get Axes position from Demo server
|
|
serverService.GetAxesPosition(procNumber.ToString(), out List<NcAxisModel> demoAxes);
|
|
// Parse response retrieve following error
|
|
foreach (NcAxisModel demoAxis in demoAxes)
|
|
{
|
|
Axes.Add(demoAxis.name, demoAxis.distanceToGo);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_RDistanceToGo(ushort procNumber, ref Dictionary<string, double> Axes)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.GetAxesPosition(procNumber.ToString(), out List<NcAxisModel> demoAxes);
|
|
// Parse response and retrieve distance to go
|
|
foreach (NcAxisModel demoAxis in demoAxes)
|
|
{
|
|
Axes.Add(demoAxis.name, demoAxis.distanceToGo);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_RAxesNames(ushort process, ref List<AxisModel> axesData)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.GetAxesPosition(process.ToString(), out List<NcAxisModel> demoAxes);
|
|
int i = 1;
|
|
// Parse response get distance to go
|
|
foreach (NcAxisModel demoAxis in demoAxes)
|
|
{
|
|
axesData.Add(new AxisModel()
|
|
{
|
|
Id = i++,
|
|
Name = demoAxis.name
|
|
});
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_RSelectedAxis(ref byte axisId)
|
|
{
|
|
// Read byte from memory
|
|
CmsError cmsError = MEM_RWByte(R, 0, SELECTED_AXIS.MemType, SELECTED_AXIS.Address, 1, ref axisId);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError AXES_WSelectAxis(byte axisId)
|
|
{
|
|
// Write byte from memory
|
|
CmsError cmsError = MEM_RWByte(W, 0, SELECT_AXIS.MemType, SELECT_AXIS.Address, 1, ref axisId);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
#endregion PROCESS-AXES (PATH) High-level data
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region NC Low-level function: single valiable in memory
|
|
|
|
public override CmsError MEM_RWBoolean(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int MemBit, ref bool Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
cmsError = CheckBitRange(MemBit);
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case: Read bit
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetBoolean(MemIndex.ToString(), MemBit.ToString(), out Value);
|
|
}
|
|
// Write case: write bit
|
|
else
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.boolean = Value;
|
|
serverService.PutBoolean(MemIndex.ToString(), MemBit.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWByte(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int MemByte, ref byte Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetByte(MemIndex.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.binary = Value;
|
|
serverService.PutByte(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWWord(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, ref ushort Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetWord(MemIndex.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.uWord = Value;
|
|
serverService.PutWord(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWShort(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, ref short Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetShort(MemIndex.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.word = Value;
|
|
serverService.PutShort(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWDWord(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, ref uint Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetDWord(MemIndex.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.dWord = Value;
|
|
serverService.PutDWord(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWInteger(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, ref int Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetInteger(MemIndex.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.integer = Value;
|
|
serverService.PutInteger(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------------------------
|
|
// Siemens Version of Memory-Access Methods
|
|
|
|
public override CmsError MEM_RWBoolean(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int MemBit, ref bool Value)
|
|
{
|
|
return MEM_RWBoolean(bWrite, Process, MemType, MemIndex, MemBit, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWByte(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int MemByte, ref byte Value)
|
|
{
|
|
return MEM_RWByte(bWrite, Process, MemType, MemIndex, MemByte, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWWord(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref ushort Value)
|
|
{
|
|
return MEM_RWWord(bWrite, Process, MemType, MemIndex, MemIndex, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWShort(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref short Value)
|
|
{
|
|
return MEM_RWShort(bWrite, Process, MemType, MemIndex, MemIndex, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWDWord(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref uint Value)
|
|
{
|
|
return MEM_RWDWord(bWrite, Process, MemType, MemIndex, MemIndex, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWInteger(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref int Value)
|
|
{
|
|
return MEM_RWInteger(bWrite, Process, MemType, MemIndex, MemIndex, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWByteList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int MemByteStart, int Number, ref List<byte> Value)
|
|
{
|
|
return MEM_RWByteList(bWrite, Process, MemType, MemIndex, MemByteStart, Number, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWWordList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<ushort> Value)
|
|
{
|
|
return MEM_RWWordList(bWrite, Process, MemType, MemIndex, Number, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWShortList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<short> Value)
|
|
{
|
|
return MEM_RWShortList(bWrite, Process, MemType, MemIndex, Number, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWDWordList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<uint> Value)
|
|
{
|
|
return MEM_RWDWordList(bWrite, Process, MemType, MemIndex, Number, ref Value);
|
|
}
|
|
|
|
public override CmsError MEM_RWIntegerList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<int> Value)
|
|
{
|
|
return MEM_RWIntegerList(bWrite, Process, MemType, MemIndex, Number, ref Value);
|
|
}
|
|
|
|
#endregion NC Low-level function: single valiable in memory
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region NC Low-level function: variables List in memory
|
|
|
|
public override CmsError MEM_RWByteList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int MemByteStart, int Number, ref List<byte> Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetByteList(MemIndex.ToString(), Number.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.byteList = Value;
|
|
serverService.PutByteList(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWWordList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int Number, ref List<ushort> Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetWordList(MemIndex.ToString(), Number.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.wordList = Value;
|
|
serverService.PutWordList(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWShortList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int Number, ref List<short> Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetShortList(MemIndex.ToString(), Number.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.shortList = Value;
|
|
serverService.PutShortList(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWIntegerList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int Number, ref List<int> Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetIntegerList(MemIndex.ToString(), Number.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.integerList = Value;
|
|
serverService.PutIntegerList(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError MEM_RWDWordList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemIndex, int Number, ref List<uint> Value)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Read case
|
|
if (bWrite == R)
|
|
{
|
|
serverService.GetDWordList(MemIndex.ToString(), Number.ToString(), out Value);
|
|
}
|
|
else // Write case
|
|
{
|
|
BinaryMemoryModel binaryMemoryModel = new BinaryMemoryModel();
|
|
binaryMemoryModel.dWordList = Value;
|
|
serverService.PutDWordList(MemIndex.ToString(), binaryMemoryModel);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
#endregion NC Low-level function: variables List in memory
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region NC Low-level function: Parameters
|
|
|
|
public override CmsError NC_RParam(short Index, short Bit, ref bool Value)
|
|
{
|
|
return FUNCTION_NOT_ALLOWED_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RParam(short Index, ref byte Value)
|
|
{
|
|
return FUNCTION_NOT_ALLOWED_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RParam(short Index, ref short Value)
|
|
{
|
|
return FUNCTION_NOT_ALLOWED_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RParam(short Index, ref int Value)
|
|
{
|
|
return FUNCTION_NOT_ALLOWED_ERROR;
|
|
}
|
|
|
|
public override CmsError NC_RParam(short Index, ref double Value)
|
|
{
|
|
return FUNCTION_NOT_ALLOWED_ERROR;
|
|
}
|
|
|
|
#endregion NC Low-level function: Parameters
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region File Management
|
|
|
|
public override CmsError FILES_RProgramToFile(string partProgramPath, FileStream localFile)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.GetFile(partProgramPath, out string fileContent);
|
|
Nc_Utils.WriteLocalFile(fileContent, ref localFile);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError FILES_WProgramFromFile(string partProgramPath, FileStream localFile)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
FileModel fileData = new FileModel
|
|
{
|
|
fileContent = Nc_Utils.ReadLocalFile(localFile),
|
|
destFileName = partProgramPath
|
|
};
|
|
serverService.PostFile(fileData);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError FILES_CopyProgram(string partProgramPath, string newPartProgramPath, bool failIfExist)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
FileModel fileData = new FileModel
|
|
{
|
|
sourceFileName = partProgramPath,
|
|
destFileName = newPartProgramPath,
|
|
failIfExist = failIfExist
|
|
};
|
|
serverService.CopyFile(fileData);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError FILES_DeleteProgram(string partProgramPath, string partProgramName)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.DeleteFile(partProgramName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
#endregion File Management
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region Tools Management
|
|
|
|
public override CmsError TOOLS_RConfiguration(ref ToolTableConfiguration config)
|
|
{
|
|
config.FieldsConfiguration = SiemensToolsConfig;
|
|
|
|
config.Magazines = new List<MagazineModel>()
|
|
{
|
|
new MagazineModel{Id = 1, Type = MAGAZINE_TYPE.MAGAZINE},
|
|
new MagazineModel{Id = 2, Type = MAGAZINE_TYPE.MAGAZINE},
|
|
new MagazineModel{Id = 3, Type = MAGAZINE_TYPE.SPINDLE},
|
|
|
|
};
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError TOOLS_RToolTable(ref List<SiemensToolModel> toolTable)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
toolTable = new List<SiemensToolModel>();
|
|
// Get tool table data
|
|
serverService.GetTools(out List<ToolsDataModel> toolsData);
|
|
|
|
foreach(ToolsDataModel tool in toolsData)
|
|
{
|
|
toolTable.Add(new SiemensToolModel()
|
|
{
|
|
Id = tool.Id,
|
|
FamilyName = tool.FamilyName,
|
|
ChildId = tool.ChildId,
|
|
MagazinePositionType = tool.MagazinePositionType,
|
|
ToolType = tool.ToolType,
|
|
LeftSize = tool.LeftSize,
|
|
RightSize = tool.RightSize,
|
|
Rotation = (ROTATION)tool.Rotation,
|
|
Cooling1 = tool.Cooling1,
|
|
Cooling2 = tool.Cooling2,
|
|
IsActive = tool.IsActive,
|
|
FixedPlace = tool.FixedPlace,
|
|
IsInhibited = tool.IsInhibited,
|
|
IsMeasured = tool.IsMeasured,
|
|
ChangeTool = tool.ChangeTool,
|
|
IsInUse = tool.IsInUse,
|
|
PreAlarm = tool.PreAlarm,
|
|
EdgesData = tool.EdgesData
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
public override CmsError TOOLS_WAddTool(ref SiemensToolModel tool)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.AddTool(ref tool);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
public override CmsError TOOLS_RShanksData(ref List<ShankModel> shanks)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
shanks = new List<ShankModel>();
|
|
// Get tool table data
|
|
serverService.GetShanks(out List<ShankDataModel> demoShanksData);
|
|
|
|
foreach (ShankDataModel shank in demoShanksData)
|
|
{
|
|
shanks.Add(new ShankModel()
|
|
{
|
|
Id = shank.Id,
|
|
childsTools = shank.childsTools.Select(x => new ShankChildModel()
|
|
{
|
|
ToolId = x.ToolId,
|
|
ChildId = x.ChildId,
|
|
FamilyName = x.FamilyName,
|
|
Type = x.Type
|
|
}).ToList()
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
public override CmsError TOOLS_WAddShank(ref ShankModel shank)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.AddShank(out shank);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
|
|
public override CmsError TOOLS_RFamilyData(ref List<FamilyModel> families)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
families = new List<FamilyModel>();
|
|
try
|
|
{
|
|
// Get families data
|
|
serverService.GetFamilies(out List<DemoFamilyModel> demoFamilies);
|
|
// Populate output model
|
|
foreach (DemoFamilyModel family in demoFamilies)
|
|
{
|
|
families.Add(new FamilyModel()
|
|
{
|
|
Id = family.Id,
|
|
Name = family.Name,
|
|
ChildTools = family.ChildTools.Select(x => new FamilyChildModel()
|
|
{
|
|
Id = x.Id,
|
|
ChildId = x.ChildId,
|
|
Type = x.Type
|
|
}).ToList()
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
//public override CmsError TOOLS_WUpdateFamilyData(int id, string name)
|
|
//{
|
|
// // Check if the NC Demo is Connected
|
|
// CmsError cmsError = CheckConnection();
|
|
// if (cmsError.IsError())
|
|
// return cmsError;
|
|
// try
|
|
// {
|
|
// DemoFamilyModel demo = new DemoFamilyModel()
|
|
// {
|
|
// Id = id,
|
|
// Name = name
|
|
// };
|
|
|
|
// // Get families data
|
|
// serverService.PutFamily();
|
|
|
|
|
|
// return NO_ERROR;
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// return ManageException(ex);
|
|
// }
|
|
//}
|
|
|
|
public override CmsError TOOLS_WAddFamily(ref FamilyModel family)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
serverService.AddFamily(ref family);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
public override CmsError TOOLS_RMagazinePositions(ref List<MagazinePositionsModel> positions)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
positions = new List<MagazinePositionsModel>();
|
|
try
|
|
{
|
|
// Get position data from demo
|
|
serverService.GetPositions(out List<DemoPositionsModel> demoPositions);
|
|
// Populate output model
|
|
foreach (DemoPositionsModel position in demoPositions)
|
|
{
|
|
positions.Add(new MagazinePositionsModel()
|
|
{
|
|
Id = position.Id,
|
|
MagazineId = position.MagazineId,
|
|
Type = position.Type
|
|
});
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
}
|
|
|
|
#endregion Tools Management
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region Subordinate Private Functions
|
|
|
|
//Check if NC is connected
|
|
private CmsError CheckConnection()
|
|
{
|
|
if (!NC_IsConnected())
|
|
return NOT_CONNECTED_ERROR;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//Manage the Languages
|
|
private CultureInfo ConverToSTEPLanguage(String Lang)
|
|
{
|
|
CultureInfo Culture = CultureInfo.GetCultures(CultureTypes.AllCultures).FirstOrDefault(X => X.EnglishName.ToLower() == Lang.ToLower());
|
|
|
|
if (Culture != null)
|
|
return Culture;
|
|
else
|
|
return new CultureInfo("en");
|
|
}
|
|
|
|
//Manage the Exception Launch
|
|
private CmsError ManageException(Exception ex)
|
|
{
|
|
//Catch the .Net exceptions
|
|
if (ex is EndpointNotFoundException)
|
|
{
|
|
Connected = false;
|
|
return NOT_CONNECTED_ERROR;
|
|
}
|
|
else
|
|
return CmsError.InternalError(ex.Message);
|
|
}
|
|
|
|
//Check Bit In Range
|
|
private CmsError CheckBitRange(int bitnum)
|
|
{
|
|
if (bitnum < 0 || bitnum > 7)
|
|
return BIT_NOT_IN_RANGE_ERROR;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
public override CmsError PROC_RPPName(ushort ProcNumber, ref string Name)
|
|
{
|
|
// Check if the NC Demo is Connected
|
|
CmsError cmsError = CheckConnection();
|
|
if (cmsError.IsError())
|
|
return cmsError;
|
|
|
|
try
|
|
{
|
|
// Get status from server
|
|
serverService.GetProcessPartProgram(ProcNumber.ToString(), out Name);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ManageException(ex);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// Create and return CmsError object
|
|
private CmsError GetNcError(string message)
|
|
{
|
|
return CmsError.NcError(message);
|
|
}
|
|
|
|
#endregion Subordinate Private Functions
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#region Memory addresses
|
|
|
|
internal static class MEMORY_ADDRESS
|
|
{
|
|
internal const int STARTING_ADDRESS = 0;
|
|
|
|
internal static MEMORY_CELL FUNCTION_ACCESS = new MEMORY_CELL(MEMORY_TYPE.Demo, 13, 8);
|
|
|
|
internal static MEMORY_CELL PRE_POWER_ON = new MEMORY_CELL(MEMORY_TYPE.Demo, 21, 1);
|
|
internal static MEMORY_CELL PRE_POWER_ON_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Demo, 22, 1);
|
|
|
|
internal static MEMORY_CELL POST_POWER_ON = new MEMORY_CELL(MEMORY_TYPE.Demo, 23, 1);
|
|
internal static MEMORY_CELL POST_POWER_ON_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Demo, 24, 1);
|
|
|
|
internal static MEMORY_CELL PRE_POWER_ON_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Demo, 25, 1);
|
|
internal static MEMORY_CELL POST_POWER_ON_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Demo, 26, 1);
|
|
|
|
internal static MEMORY_CELL AXIS_RESET_PROCEDURE = new MEMORY_CELL(MEMORY_TYPE.Demo, 27, 7, 2);
|
|
|
|
internal static MEMORY_CELL SELECTED_PROCESS = new MEMORY_CELL(MEMORY_TYPE.Demo, 31, 2, 1);
|
|
internal static MEMORY_CELL SELECT_PROCESS = new MEMORY_CELL(MEMORY_TYPE.Demo, 30, 1);
|
|
internal static MEMORY_CELL PROCESS_STATUS = new MEMORY_CELL(MEMORY_TYPE.Demo, 31, 0, 12);
|
|
|
|
internal static MEMORY_CELL COUNTERS = new MEMORY_CELL(MEMORY_TYPE.Demo, 43, 0, 40);
|
|
|
|
internal static MEMORY_CELL SELECTED_AXIS = new MEMORY_CELL(MEMORY_TYPE.Demo, 83, 0, 1);
|
|
internal static MEMORY_CELL SELECT_AXIS = new MEMORY_CELL(MEMORY_TYPE.Demo, 84, 0, 1);
|
|
|
|
internal static MEMORY_CELL NC_SOFTKEYS_VALUE = new MEMORY_CELL(MEMORY_TYPE.Demo, 85, 0, 4);
|
|
internal static MEMORY_CELL NC_SOFTKEYS_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Demo, 89, 0, 4);
|
|
internal static MEMORY_CELL NC_SOFT_KEYS_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Demo, 93, 4);
|
|
internal static MEMORY_CELL NC_SOFT_KEYS_ACK = new MEMORY_CELL(MEMORY_TYPE.Demo, 97, 4);
|
|
|
|
internal static MEMORY_CELL USER_SOFTKEYS_VALUE = new MEMORY_CELL(MEMORY_TYPE.Demo, 101, 0, 16);
|
|
internal static MEMORY_CELL USER_SOFTKEYS_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Demo, 117, 0, 16);
|
|
internal static MEMORY_CELL USER_SOFT_KEYS_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Demo, 133, 16);
|
|
internal static MEMORY_CELL USER_SOFT_KEYS_ACK = new MEMORY_CELL(MEMORY_TYPE.Demo, 149, 16);
|
|
|
|
internal static MEMORY_CELL ALARMS_STATUS = new MEMORY_CELL(MEMORY_TYPE.Demo, 165, 4);
|
|
internal static MEMORY_CELL ALARMS_DATA = new MEMORY_CELL(MEMORY_TYPE.Demo, 169, 32);
|
|
|
|
internal static MEMORY_CELL ALARM_ACK = new MEMORY_CELL(MEMORY_TYPE.Demo, 201, 4);
|
|
internal static MEMORY_CELL ALARM_REFRESH_STROBE = new MEMORY_CELL(MEMORY_TYPE.Demo, 205, 4);
|
|
|
|
internal static MEMORY_CELL HEADS_DATA = new MEMORY_CELL(MEMORY_TYPE.Demo, 209, 220);
|
|
|
|
internal static MEMORY_CELL HEADS_ACK = new MEMORY_CELL(MEMORY_TYPE.Demo, 429, 4);
|
|
internal static MEMORY_CELL HEADS_STROBE_INCREMENT = new MEMORY_CELL(MEMORY_TYPE.Demo, 432, 4);
|
|
internal static MEMORY_CELL HEADS_STROBE_DECREMENT = new MEMORY_CELL(MEMORY_TYPE.Demo, 436, 4);
|
|
}
|
|
|
|
#endregion Memory addresses
|
|
} |