Samuele E. Locatelli
1170 lines
35 KiB
C#
1170 lines
35 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
namespace MTC_Sim
|
|
{
|
|
using MTConnect;
|
|
using System.Configuration;
|
|
using System.Diagnostics;
|
|
|
|
|
|
#region macro oggetti da istanziare a blocchi da configurazione XML
|
|
|
|
|
|
/// <summary>
|
|
/// Singola pompa da vuoto, 0..n
|
|
/// </summary>
|
|
public class VacuumPomp : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mVacPumpAlias;
|
|
/// <summary>
|
|
/// valore numero attivazioni/disattivazioni valvola
|
|
/// </summary>
|
|
public Event mVacPumpStatus;
|
|
/// <summary>
|
|
/// Classe Vacuum Pump (pompa)
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public VacuumPomp(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
// genero elementi specifici MTConnect
|
|
mVacPumpAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mVacPumpAlias.Value = alias;
|
|
mVacPumpStatus = new Event(dataRefList[0].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singolo attuatore vuoto, 0..n
|
|
/// </summary>
|
|
public class VacuumAct : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mVacActAlias;
|
|
/// <summary>
|
|
/// valore numero attivazioni/disattivazioni valvola
|
|
/// </summary>
|
|
public Sample mVacActCount;
|
|
|
|
/// <summary>
|
|
/// Classe Vacuum Actuator (valvola)
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public VacuumAct(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mVacActAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mVacActAlias.Value = alias;
|
|
mVacActCount = new Sample(dataRefList[0].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singolo attuatore per lubrificazione, 0..n
|
|
/// </summary>
|
|
public class Lubro : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mLubroAlias;
|
|
/// <summary>
|
|
/// numero pompate necessarie per far scattare sensore
|
|
/// </summary>
|
|
public Sample mLubroNum;
|
|
|
|
/// <summary>
|
|
/// Classe Lubrorefrigerante
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public Lubro(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mLubroAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mLubroAlias.Value = alias;
|
|
mLubroNum = new Sample(dataRefList[0].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singolo refrigeratore, 0..n
|
|
/// </summary>
|
|
public class Cooler : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mCoolAlias;
|
|
/// <summary>
|
|
/// Stato istantaneo (evento aperto/chiuso)
|
|
/// </summary>
|
|
public Event mCoolStatus;
|
|
|
|
/// <summary>
|
|
/// Classe refrigeratore
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public Cooler(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mCoolAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mCoolAlias.Value = alias;
|
|
mCoolStatus = new Event(dataRefList[0].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singola Pressione rilevata, 0..n
|
|
/// </summary>
|
|
public class Press : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mPressAlias;
|
|
/// <summary>
|
|
/// valore pressione istantaneo
|
|
/// </summary>
|
|
public Sample mPressValIst;
|
|
/// <summary>
|
|
/// Classe pressione con Idx e descrizione
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public Press(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mPressAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mPressAlias.Value = alias;
|
|
mPressValIst = new Sample(dataRefList[0].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singola temperatura rilevata, 0..n
|
|
/// </summary>
|
|
public class Tempe : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mTempAlias;
|
|
/// <summary>
|
|
/// valore temperatura istantaneo
|
|
/// </summary>
|
|
public Sample mTempValIst;
|
|
/// <summary>
|
|
/// Classe temperatura con Idx e descrizione
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public Tempe(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mTempAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mTempAlias.Value = alias;
|
|
mTempValIst = new Sample(dataRefList[0].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singolo path, da 1..20
|
|
/// </summary>
|
|
public class Path : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mPathAlias;
|
|
/// <summary>
|
|
/// Feedrate
|
|
/// </summary>
|
|
public Sample mPathFeed;
|
|
/// <summary>
|
|
/// Override feed
|
|
/// </summary>
|
|
public Sample mPathFeedOver;
|
|
/// <summary>
|
|
/// Override speed
|
|
/// </summary>
|
|
public Sample mPathSpeedOver;
|
|
/// <summary>
|
|
/// Posizione X
|
|
/// </summary>
|
|
public Sample mPathPosActX;
|
|
/// <summary>
|
|
/// Posizione Y
|
|
/// </summary>
|
|
public Sample mPathPosActY;
|
|
/// <summary>
|
|
/// Posizione Z
|
|
/// </summary>
|
|
public Sample mPathPosActZ;
|
|
/// <summary>
|
|
/// Angolo I
|
|
/// </summary>
|
|
public Sample mPathPosActI;
|
|
/// <summary>
|
|
/// Angolo J
|
|
/// </summary>
|
|
public Sample mPathPosActJ;
|
|
/// <summary>
|
|
/// Angolo K
|
|
/// </summary>
|
|
public Sample mPathPosActK;
|
|
|
|
/// <summary>
|
|
/// Classe Path con Idx e descrizione
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public Path(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mPathAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mPathAlias.Value = alias;
|
|
mPathFeed = new Sample(dataRefList[0].Key);
|
|
mPathFeedOver = new Sample(dataRefList[1].Key);
|
|
mPathSpeedOver = new Sample(dataRefList[2].Key);
|
|
mPathPosActX = new Sample(dataRefList[3].Key);
|
|
mPathPosActY = new Sample(dataRefList[4].Key);
|
|
mPathPosActZ = new Sample(dataRefList[5].Key);
|
|
mPathPosActI = new Sample(dataRefList[6].Key);
|
|
mPathPosActJ = new Sample(dataRefList[7].Key);
|
|
mPathPosActK = new Sample(dataRefList[8].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Singolo mandrino, 1..n
|
|
/// </summary>
|
|
public class UnOp : element
|
|
{
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mUnOpAlias;
|
|
/// <summary>
|
|
/// Alias
|
|
/// </summary>
|
|
public Event mUnOpToolId;
|
|
/// <summary>
|
|
/// valore numero Cambi Utensili effettuato
|
|
/// </summary>
|
|
public Event mUnOpNumCU;
|
|
/// <summary>
|
|
/// status utensil
|
|
/// </summary>
|
|
public Event mUnOpStatus;
|
|
/// <summary>
|
|
/// valore vita residua utensile
|
|
/// </summary>
|
|
public Event mUnOpVitaRes;
|
|
/// <summary>
|
|
/// valore speed
|
|
/// </summary>
|
|
public Sample mUnOpSpeed;
|
|
/// <summary>
|
|
/// valore load
|
|
/// </summary>
|
|
public Sample mUnOpLoad;
|
|
/// <summary>
|
|
/// valore tempo cumulato di impiego
|
|
/// </summary>
|
|
public Sample mUnOpAccTime;
|
|
/// <summary>
|
|
/// Classe Unita Operatrice (Mandrino) con Idx e descrizione
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public UnOp(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
mUnOpAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mUnOpAlias.Value = alias;
|
|
mUnOpToolId = new Event(dataRefList[0].Key);
|
|
mUnOpNumCU = new Event(dataRefList[1].Key);
|
|
mUnOpStatus = new Event(dataRefList[2].Key);
|
|
mUnOpVitaRes = new Event(dataRefList[3].Key);
|
|
mUnOpSpeed = new Sample(dataRefList[4].Key);
|
|
mUnOpLoad = new Sample(dataRefList[5].Key);
|
|
mUnOpAccTime = new Sample(dataRefList[6].Key);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Asse singolo, 1..n
|
|
/// </summary>
|
|
public class Axis : element
|
|
{
|
|
/// <summary>
|
|
/// Descrizione / Alias
|
|
/// </summary>
|
|
public Event mAxAlias;
|
|
/// <summary>
|
|
/// Processo di appartenenza
|
|
/// </summary>
|
|
public Event mAxMainProc;
|
|
/// <summary>
|
|
/// Bit se sia master (=1) o slave (=0)
|
|
/// </summary>
|
|
public Event mAxIsMaster;
|
|
/// <summary>
|
|
/// ID del master
|
|
/// </summary>
|
|
public Event mAxMastId;
|
|
/// <summary>
|
|
/// Event tipo asse: lineare, rotazionale...
|
|
/// </summary>
|
|
public Event mAxType;
|
|
/// <summary>
|
|
/// Bit direzione: 1 = avanti/clockwise, 0 indietro/counterclockwise
|
|
/// </summary>
|
|
public Sample mAxDir;
|
|
/// <summary>
|
|
/// Load
|
|
/// </summary>
|
|
public Sample mAxLoad;
|
|
/// <summary>
|
|
/// Posizione Attuale
|
|
/// </summary>
|
|
public Sample mAxPosAct;
|
|
/// <summary>
|
|
/// Posizione Target
|
|
/// </summary>
|
|
public Sample mAxPosTgt;
|
|
/// <summary>
|
|
/// Feed Attuale
|
|
/// </summary>
|
|
public Sample mAxFeedAct;
|
|
/// <summary>
|
|
/// Feed Override
|
|
/// </summary>
|
|
public Sample mAxFeedOver;
|
|
/// <summary>
|
|
/// Accelerazione Attuale
|
|
/// </summary>
|
|
public Sample mAxAccelAct;
|
|
/// <summary>
|
|
/// Tempo Lavoro cumulato
|
|
/// </summary>
|
|
public Sample mAxAccTime;
|
|
/// <summary>
|
|
/// Carica batteria
|
|
/// </summary>
|
|
public Sample mAxBattery;
|
|
|
|
/// <summary>
|
|
/// Classe Asse con relativo ID UNIVOCO ed alias
|
|
/// </summary>
|
|
/// <param name="baseElem">element base contenente parametri (da XML)</param>
|
|
public Axis(element baseElem)
|
|
{
|
|
ident = baseElem.ident;
|
|
alias = baseElem.alias;
|
|
fonte = baseElem.fonte;
|
|
dataRefList = baseElem.dataRefList;
|
|
|
|
// inizializzo vari eventi, sample, condizioni
|
|
mAxAlias = new Event(string.Format("{0}_Alias", ident));
|
|
mAxAlias.Value = alias;
|
|
mAxMainProc = new Event(dataRefList[0].Key);
|
|
mAxIsMaster = new Event(dataRefList[1].Key);
|
|
mAxMastId = new Event(dataRefList[2].Key);
|
|
mAxType = new Event(dataRefList[3].Key);
|
|
mAxDir = new Sample(dataRefList[4].Key);
|
|
mAxLoad = new Sample(dataRefList[5].Key);
|
|
mAxPosAct = new Sample(dataRefList[6].Key);
|
|
mAxPosTgt = new Sample(dataRefList[7].Key);
|
|
mAxFeedAct = new Sample(dataRefList[8].Key);
|
|
mAxFeedOver = new Sample(dataRefList[9].Key);
|
|
mAxAccelAct = new Sample(dataRefList[10].Key);
|
|
mAxAccTime = new Sample(dataRefList[11].Key);
|
|
mAxBattery = new Sample(dataRefList[12].Key);
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
public class AdapterGeneric
|
|
{
|
|
/// <summary>
|
|
/// adapter globale
|
|
/// </summary>
|
|
public Adapter mAdapter = new Adapter();
|
|
|
|
protected CMS_MachineSim parentForm;
|
|
|
|
#region altri oggetti
|
|
|
|
public Strobe STROBE_PLC = 0;
|
|
public Strobe STROBE_ADP = 0;
|
|
|
|
|
|
public List<string> codaM = new List<string>();
|
|
public List<string> codaS = new List<string>();
|
|
public List<string> codaT = new List<string>();
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
/// <summary>
|
|
/// D.D1.AVAIL - disponibilità
|
|
/// </summary>
|
|
public Event mAvail = new Event("avail");
|
|
/// <summary>
|
|
/// XX.XX.STOP - stop per pressione emergenze
|
|
/// </summary>
|
|
public Event mEStop = new Event("PROTECTION_STATUS");
|
|
/// <summary>
|
|
/// STATUS macchina (ON/OFF)
|
|
/// </summary>
|
|
public Event mStatus = new Event("STATUS");
|
|
/// <summary>
|
|
/// Minuti funzionamento globale macchina
|
|
/// </summary>
|
|
public Event mAccTime = new Event("ACC_TIME");
|
|
/// <summary>
|
|
/// Orologio
|
|
/// </summary>
|
|
public Event mClock = new Event("CLOCK_TIME");
|
|
/// <summary>
|
|
/// Consumo elettrico globale
|
|
/// </summary>
|
|
public Event mPower = new Event("POWER");
|
|
|
|
/// <summary>
|
|
/// D.D1.NAME
|
|
/// </summary>
|
|
public Event mName = new Event("Name");
|
|
/// <summary>
|
|
/// D.D1.ID
|
|
/// </summary>
|
|
public Event mID = new Event("ID");
|
|
/// <summary>
|
|
/// D.D1.UUID
|
|
/// </summary>
|
|
public Event mUUID = new Event("UUID");
|
|
/// <summary>
|
|
/// D.D1.SAMPLE_INTERVAL
|
|
/// </summary>
|
|
public Event mSampleInt = new Event("SampleInt");
|
|
|
|
|
|
/// <summary>
|
|
/// CURR_PROG - programma in esecuzione
|
|
/// </summary>
|
|
public Event mProgram = new Event("CurrProg");
|
|
/// <summary>
|
|
/// CURR_PROG_ROWNUM - programma in esecuzione
|
|
/// </summary>
|
|
public Event mProgRowNum = new Event("CurrProg_RowNum");
|
|
/// <summary>
|
|
/// PartId - particolare prodotto
|
|
/// </summary>
|
|
public Event mPartId = new Event("PartID");
|
|
/// <summary>
|
|
/// CURR_PROG_ROWNUM - programma in esecuzione
|
|
/// </summary>
|
|
public Event mOperator = new Event("OperatorId");
|
|
|
|
|
|
/// <summary>
|
|
/// D.D1.P1.PATH_MODE - modalità esecuzione
|
|
/// </summary>
|
|
public Event mMode = new Event("PATH_MODE");
|
|
/// <summary>
|
|
/// D.D1.P1.PATH_STATUS - status macchina
|
|
/// </summary>
|
|
public Event mExec = new Event("PATH_STATUS");
|
|
|
|
/// <summary>
|
|
/// M_CODE
|
|
/// </summary>
|
|
public Event mCod_M = new Event("Cod_M");
|
|
/// <summary>
|
|
/// S_CODE
|
|
/// </summary>
|
|
public Event mCod_S = new Event("Cod_S");
|
|
/// <summary>
|
|
/// T_CODE
|
|
/// </summary>
|
|
public Event mCod_T = new Event("Cod_T");
|
|
|
|
|
|
/// <summary>
|
|
/// Pezzi totali
|
|
/// </summary>
|
|
public Event mPz_Tot = new Event("PZ_TOT");
|
|
/// <summary>
|
|
/// Pezzi OK
|
|
/// </summary>
|
|
public Event mPz_Ok = new Event("PZ_OK");
|
|
/// <summary>
|
|
/// Pezzi KO
|
|
/// </summary>
|
|
public Event mPz_Ko = new Event("PZ_KO");
|
|
|
|
/// <summary>
|
|
/// modalità funzionale
|
|
/// </summary>
|
|
public Event mFunctionalMode = new Event("func");
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region oggetti complessi/completi
|
|
|
|
|
|
public VacuumPomp[] vettVacPump;
|
|
public VacuumAct[] vettVacAct;
|
|
public Lubro[] vettLubro;
|
|
public Cooler[] vettCooler;
|
|
public Press[] vettPress;
|
|
public Tempe[] vettTempe;
|
|
public Path[] vettPath;
|
|
public UnOp[] vettUnOp;
|
|
public Axis[] vettAxis;
|
|
|
|
#endregion
|
|
|
|
|
|
#region Conditions
|
|
|
|
// vettori vari: allarmi sistema, PLC, CNC ed allarmi HMI
|
|
public Condition mAlarmSystem = new Condition("system");
|
|
public Condition mAlarmCNC = new Condition("CNC");
|
|
public Condition mAlarmPLC = new Condition("PLC");
|
|
public Condition mAlarmHMI = new Condition("HMI");
|
|
|
|
#endregion
|
|
|
|
#region Messages
|
|
|
|
public Message mMessage = new Message("message");
|
|
|
|
#endregion
|
|
#if false
|
|
|
|
#region Samples
|
|
|
|
|
|
public Sample mPosition = new Sample("xPosition");
|
|
public Sample mxLoad = new Sample("xLoad");
|
|
|
|
public Sample mSpeed = new Sample("sSpeed");
|
|
public Sample mcLoad = new Sample("sLoad");
|
|
|
|
|
|
#endregion
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// inizializzo l'oggetto sulla form SULLA BASE DEL FILE DI CONFIGURAZIONE letto
|
|
/// </summary>
|
|
/// <param name="caller"></param>
|
|
/// <param name="adpConf"></param>
|
|
public AdapterGeneric(CMS_MachineSim caller, AdapterConf adpConf)
|
|
{
|
|
// salvo al form chiamante
|
|
parentForm = caller;
|
|
|
|
// item disponibilità
|
|
mAdapter.AddDataItem(mAvail);
|
|
mAvail.Value = "AVAILABLE";
|
|
|
|
|
|
// status, clock, emergency stop
|
|
mAdapter.AddDataItem(mStatus);
|
|
mAdapter.AddDataItem(mAccTime);
|
|
mAdapter.AddDataItem(mClock);
|
|
mAdapter.AddDataItem(mPower);
|
|
mAdapter.AddDataItem(mEStop);
|
|
|
|
// nome ed ID/UUID - e li imposto...
|
|
mAdapter.AddDataItem(mName);
|
|
mAdapter.AddDataItem(mID);
|
|
mAdapter.AddDataItem(mUUID);
|
|
|
|
// programma e produzione
|
|
mAdapter.AddDataItem(mProgram);
|
|
mAdapter.AddDataItem(mProgRowNum);
|
|
mAdapter.AddDataItem(mPartId);
|
|
mAdapter.AddDataItem(mPz_Tot);
|
|
mAdapter.AddDataItem(mPz_Ok);
|
|
mAdapter.AddDataItem(mPz_Ko);
|
|
mAdapter.AddDataItem(mOperator);
|
|
|
|
// codici speciali M/S/T
|
|
mAdapter.AddDataItem(mCod_M);
|
|
mAdapter.AddDataItem(mCod_S);
|
|
mAdapter.AddDataItem(mCod_T);
|
|
|
|
// modalità esecutiva e funzionale
|
|
mAdapter.AddDataItem(mMode);
|
|
mAdapter.AddDataItem(mExec);
|
|
mAdapter.AddDataItem(mFunctionalMode);
|
|
|
|
// Pompe vuoto
|
|
vettVacPump = new VacuumPomp[adpConf.nVacuumPump];
|
|
for (int i = 0; i < adpConf.nVacuumPump; i++)
|
|
{
|
|
vettVacPump[i] = new VacuumPomp(adpConf.VacuumPump[i]);
|
|
mAdapter.AddDataItem(vettVacPump[i].mVacPumpAlias);
|
|
mAdapter.AddDataItem(vettVacPump[i].mVacPumpStatus);
|
|
}
|
|
// Attuatori vuoto
|
|
vettVacAct = new VacuumAct[adpConf.nVacuumAct];
|
|
for (int i = 0; i < adpConf.nVacuumAct; i++)
|
|
{
|
|
vettVacAct[i] = new VacuumAct(adpConf.VacuumAct[i]);
|
|
mAdapter.AddDataItem(vettVacAct[i].mVacActAlias);
|
|
mAdapter.AddDataItem(vettVacAct[i].mVacActCount);
|
|
}
|
|
// Lubrorefrigeranti
|
|
vettLubro = new Lubro[adpConf.nLubro];
|
|
for (int i = 0; i < adpConf.nLubro; i++)
|
|
{
|
|
vettLubro[i] = new Lubro(adpConf.Lubro[i]);
|
|
mAdapter.AddDataItem(vettLubro[i].mLubroAlias);
|
|
mAdapter.AddDataItem(vettLubro[i].mLubroNum);
|
|
}
|
|
// Cooler
|
|
vettCooler = new Cooler[adpConf.nCooler];
|
|
for (int i = 0; i < adpConf.nCooler; i++)
|
|
{
|
|
vettCooler[i] = new Cooler(adpConf.Cooler[i]);
|
|
mAdapter.AddDataItem(vettCooler[i].mCoolAlias);
|
|
mAdapter.AddDataItem(vettCooler[i].mCoolStatus);
|
|
}
|
|
// Press
|
|
vettPress = new Press[adpConf.nPress];
|
|
for (int i = 0; i < adpConf.nPress; i++)
|
|
{
|
|
vettPress[i] = new Press(adpConf.Press[i]);
|
|
mAdapter.AddDataItem(vettPress[i].mPressAlias);
|
|
mAdapter.AddDataItem(vettPress[i].mPressValIst);
|
|
}
|
|
// Temp
|
|
vettTempe = new Tempe[adpConf.nTemp];
|
|
for (int i = 0; i < adpConf.nTemp; i++)
|
|
{
|
|
vettTempe[i] = new Tempe(adpConf.Temp[i]);
|
|
mAdapter.AddDataItem(vettTempe[i].mTempAlias);
|
|
mAdapter.AddDataItem(vettTempe[i].mTempValIst);
|
|
}
|
|
// Path
|
|
vettPath = new Path[adpConf.nPath];
|
|
for (int i = 0; i < adpConf.nPath; i++)
|
|
{
|
|
vettPath[i] = new Path(adpConf.Path[i]);
|
|
mAdapter.AddDataItem(vettPath[i].mPathAlias);
|
|
mAdapter.AddDataItem(vettPath[i].mPathFeed);
|
|
mAdapter.AddDataItem(vettPath[i].mPathFeedOver);
|
|
mAdapter.AddDataItem(vettPath[i].mPathSpeedOver);
|
|
mAdapter.AddDataItem(vettPath[i].mPathPosActX);
|
|
mAdapter.AddDataItem(vettPath[i].mPathPosActY);
|
|
mAdapter.AddDataItem(vettPath[i].mPathPosActZ);
|
|
mAdapter.AddDataItem(vettPath[i].mPathPosActI);
|
|
mAdapter.AddDataItem(vettPath[i].mPathPosActJ);
|
|
mAdapter.AddDataItem(vettPath[i].mPathPosActK);
|
|
}
|
|
// UnOp
|
|
vettUnOp = new UnOp[adpConf.nUnOp];
|
|
for (int i = 0; i < adpConf.nUnOp; i++)
|
|
{
|
|
vettUnOp[i] = new UnOp(adpConf.UnOp[i]);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpAlias);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpToolId);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpNumCU);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpStatus);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpVitaRes);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpSpeed);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpLoad);
|
|
mAdapter.AddDataItem(vettUnOp[i].mUnOpAccTime);
|
|
}
|
|
// Assi
|
|
vettAxis = new Axis[adpConf.nAxis];
|
|
for (int i = 0; i < adpConf.nAxis; i++)
|
|
{
|
|
vettAxis[i] = new Axis(adpConf.Axis[i]);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxAlias);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxMainProc);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxIsMaster);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxMastId);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxType);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxDir);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxLoad);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxPosAct);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxPosTgt);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxFeedAct);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxFeedOver);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxAccelAct);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxAccTime);
|
|
mAdapter.AddDataItem(vettAxis[i].mAxBattery);
|
|
}
|
|
|
|
|
|
|
|
// messaggi ulteriori
|
|
mAdapter.AddDataItem(mMessage);
|
|
|
|
#if false
|
|
mAdapter.AddDataItem(mPosition);
|
|
mAdapter.AddDataItem(mxLoad);
|
|
|
|
mAdapter.AddDataItem(mSpeed);
|
|
mAdapter.AddDataItem(mcLoad);
|
|
#endif
|
|
|
|
// allarmi "base"
|
|
mAdapter.AddDataItem(mAlarmSystem);
|
|
mAdapter.AddDataItem(mAlarmCNC);
|
|
mAdapter.AddDataItem(mAlarmPLC);
|
|
mAdapter.AddDataItem(mAlarmHMI);
|
|
}
|
|
|
|
|
|
#region metodi adapter
|
|
|
|
/// <summary>
|
|
/// Avvia l'adapter sulla porta richiesta
|
|
/// </summary>
|
|
/// <param name="port"></param>
|
|
public virtual void startAdapter(int port)
|
|
{
|
|
// Start the adapter lib with the port number in the text box
|
|
mAdapter.Port = port;
|
|
mAdapter.Start();
|
|
|
|
|
|
mAlarmSystem.Normal();
|
|
mAlarmCNC.Normal();
|
|
mAlarmPLC.Normal();
|
|
mAlarmHMI.Normal();
|
|
}
|
|
|
|
/// <summary>
|
|
/// ferma l'adapter...
|
|
/// </summary>
|
|
public void stopAdapter()
|
|
{
|
|
// Stop everything...
|
|
mAdapter.Stop();
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua recupero dati ed invio valori modificati...
|
|
/// </summary>
|
|
public void gaterAndSend()
|
|
{
|
|
// !!!FARE!!!: ripensare se riscrivere con un timer rapido ed un insieme di task preimpostati a scadenza... (al posto di altri timers...)
|
|
|
|
|
|
// avvio fase raccolta dati
|
|
mAdapter.Begin();
|
|
|
|
// leggo parametri da config file
|
|
getConfigParam();
|
|
|
|
///acquisisco dati su programma in esecuzione e dati generali (stato, orologio, power...)
|
|
getCurrProgramData();
|
|
|
|
// fix codici M/S/T
|
|
getCodMST();
|
|
|
|
getProduzione();
|
|
|
|
// fix dati x ulteriori (allarmi, modalità RUN/EXEC, ...)
|
|
getCurrMode();
|
|
|
|
getPath();
|
|
|
|
getUnOp();
|
|
|
|
getAxis();
|
|
|
|
getAlarms();
|
|
|
|
|
|
// INVIO dati variati!
|
|
mAdapter.SendChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupero dati PATH
|
|
/// </summary>
|
|
public virtual void getPath()
|
|
{
|
|
// SE presente recupero dati path
|
|
checkPath();
|
|
}
|
|
/// <summary>
|
|
/// Recupero dati Unità Operatrici / Mandrini
|
|
/// </summary>
|
|
public virtual void getUnOp()
|
|
{
|
|
|
|
}
|
|
/// <summary>
|
|
/// recupero dati ASSI
|
|
/// </summary>
|
|
public virtual void getAxis()
|
|
{
|
|
|
|
}
|
|
|
|
private void getProduzione()
|
|
{
|
|
// SE presente recupero dati produzione
|
|
checkProd();
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupero allarmi
|
|
/// </summary>
|
|
public virtual void getAlarms()
|
|
{
|
|
// da gestire su ogni adapter...
|
|
}
|
|
|
|
/// <summary>
|
|
/// controllo codici MST
|
|
/// </summary>
|
|
public void getCodMST()
|
|
{
|
|
// SE presente recupero Cod_M/S/T
|
|
checkCodM();
|
|
checkCodS();
|
|
checkCodT();
|
|
}
|
|
|
|
/// <summary>
|
|
/// metodo di recupero dei dati di identificativo macchina - DA CONF!!!
|
|
/// </summary>
|
|
public void getConfigParam()
|
|
{
|
|
mName.Value = utils.CRS("D1_NAME");
|
|
mID.Value = utils.CRS("D1_ID");
|
|
mUUID.Value = utils.CRS("D1_UUID");
|
|
}
|
|
/// <summary>
|
|
/// dati relativi al programma
|
|
/// </summary>
|
|
public virtual void getCurrProgramData()
|
|
{
|
|
// da gestire su ogni adapter...
|
|
}
|
|
/// <summary>
|
|
/// dati relativi al RUN mode
|
|
/// </summary>
|
|
public virtual void getCurrMode()
|
|
{
|
|
// da gestire su ogni adapter...
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region area metodi comunicazione con PLC/CNC
|
|
|
|
public void checkPath()
|
|
{
|
|
#if false
|
|
// controllo feed e velocità
|
|
if (utils.IsSetAny(STROBE_PLC, Strobe.FEED_SPEED))
|
|
{
|
|
// leggo i valori feed/speed
|
|
mPathFeed.Value = FeedRate;
|
|
mPathFeedOver.Value = FeedRateOver;
|
|
mPathSpeedOver.Value = SpeedRateOver;
|
|
|
|
// alzo flag lettura...
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.FEED_SPEED)) STROBE_ADP = STROBE_ADP | Strobe.FEED_SPEED;
|
|
|
|
}
|
|
else
|
|
{
|
|
// resetto eventuali flag di lettura...
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.FEED_SPEED)) STROBE_ADP -= Strobe.FEED_SPEED;
|
|
}
|
|
|
|
// controllo posizione...
|
|
if (utils.IsSetAny(STROBE_PLC, Strobe.POS_ACT))
|
|
{
|
|
// leggo i valori posizione attuale
|
|
mPathPosActX.Value = PosAct.x;
|
|
mPathPosActY.Value = PosAct.y;
|
|
mPathPosActZ.Value = PosAct.z;
|
|
mPathPosActI.Value = PosAct.i;
|
|
mPathPosActJ.Value = PosAct.j;
|
|
mPathPosActK.Value = PosAct.k;
|
|
|
|
// alzo flag lettura...
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.POS_ACT)) STROBE_ADP = STROBE_ADP | Strobe.POS_ACT;
|
|
}
|
|
else
|
|
{
|
|
// resetto eventuali flag di lettura...
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.POS_ACT)) STROBE_ADP -= Strobe.POS_ACT;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera FeedRate (fare override!)
|
|
/// </summary>
|
|
public virtual int FeedRate
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// recupera FeedRateOver (fare override!)
|
|
/// </summary>
|
|
public virtual int FeedRateOver
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// recupera SpeedRateOver (fare override!)
|
|
/// </summary>
|
|
public virtual int SpeedRateOver
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera Vettore completo PosAct (fare override!)
|
|
/// </summary>
|
|
public virtual position PosAct
|
|
{
|
|
get
|
|
{
|
|
position answ = new position();
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public void checkProd()
|
|
{
|
|
if (utils.IsSetAny(STROBE_PLC, Strobe.PZ_OK | Strobe.PZ_KO))
|
|
{
|
|
// leggo i valori pezzi OK / KO e li salvo (insieme a tot...)
|
|
mPz_Ok.Value = getNumPzOk;
|
|
mPz_Ko.Value = getNumPzKo;
|
|
mPz_Tot.Value = getNumPzOk + getNumPzKo;
|
|
// alzo flag lettura...
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.PZ_OK)) STROBE_ADP = STROBE_ADP | Strobe.PZ_OK;
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.PZ_KO)) STROBE_ADP = STROBE_ADP | Strobe.PZ_KO;
|
|
|
|
}
|
|
else
|
|
{
|
|
// resetto eventuali flag di lettura...
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.PZ_OK)) STROBE_ADP -= Strobe.PZ_OK;
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.PZ_KO)) STROBE_ADP -= Strobe.PZ_KO;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// recupera pezzi OK (fare override!)
|
|
/// </summary>
|
|
public virtual int getNumPzOk
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// recupera pezzi KO (fare override!)
|
|
/// </summary>
|
|
public virtual int getNumPzKo
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public void checkCodM()
|
|
{
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.M_CODE))
|
|
{
|
|
mCod_M.Value = getNextMCode;
|
|
// se il valore è "" allora alzo flag lettura...
|
|
if (mCod_M.Value.ToString() == "") STROBE_ADP = STROBE_ADP | Strobe.M_CODE;
|
|
|
|
}
|
|
else
|
|
{
|
|
// resetto eventuali flag di lettura...
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.M_CODE))
|
|
{
|
|
STROBE_ADP -= Strobe.M_CODE;
|
|
}
|
|
}
|
|
}
|
|
public void checkCodS()
|
|
{
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.S_CODE))
|
|
{
|
|
mCod_S.Value = getNextSCode;
|
|
// se il valore è "" allora alzo flag lettura...
|
|
if (mCod_S.Value.ToString() == "") STROBE_ADP = STROBE_ADP | Strobe.S_CODE;
|
|
}
|
|
else
|
|
{
|
|
// resetto eventuali flag di lettura...
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.S_CODE))
|
|
{
|
|
STROBE_ADP -= Strobe.S_CODE;
|
|
}
|
|
}
|
|
}
|
|
public void checkCodT()
|
|
{
|
|
if (utils.IsSetAll(STROBE_PLC, Strobe.T_CODE))
|
|
{
|
|
mCod_T.Value = getNextTCode;
|
|
// se il valore è "" allora alzo flag lettura...
|
|
if (mCod_T.Value.ToString() == "") STROBE_ADP = STROBE_ADP | Strobe.T_CODE;
|
|
}
|
|
else
|
|
{
|
|
// resetto eventuali flag di lettura...
|
|
if (utils.IsSetAll(STROBE_ADP, Strobe.T_CODE))
|
|
{
|
|
STROBE_ADP -= Strobe.T_CODE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera primo elemento codaM
|
|
/// </summary>
|
|
protected string getNextMCode
|
|
{
|
|
get
|
|
{
|
|
// PRE: eventuale rilettura da PLC x accumulare in coda...
|
|
tryGetMCode();
|
|
// ora controllo array locale
|
|
string answ = "";
|
|
if (codaM.Count > 0)
|
|
{
|
|
// accodo codice M...
|
|
answ = codaM.First();
|
|
// tolgo elemento
|
|
codaM.RemoveAt(0);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// recupera primo elemento codaS
|
|
/// </summary>
|
|
protected string getNextSCode
|
|
{
|
|
get
|
|
{
|
|
// PRE: eventuale rilettura da PLC x accumulare in coda...
|
|
tryGetSCode();
|
|
// ora controllo array locale
|
|
string answ = "";
|
|
if (codaS.Count > 0)
|
|
{
|
|
// accodo codice S...
|
|
answ = codaS.First();
|
|
// tolgo elemento
|
|
codaS.RemoveAt(0);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// recupera primo elemento codaT
|
|
/// </summary>
|
|
protected string getNextTCode
|
|
{
|
|
get
|
|
{
|
|
// PRE: eventuale rilettura da PLC x accumulare in coda...
|
|
tryGetTCode();
|
|
// ora controllo array locale
|
|
string answ = "";
|
|
if (codaT.Count > 0)
|
|
{
|
|
// accodo codice T...
|
|
answ = codaT.First();
|
|
// tolgo elemento
|
|
codaT.RemoveAt(0);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
|
|
protected virtual void tryGetMCode()
|
|
{
|
|
// altri adapter: DA IMPLEMENTARE lettura buffer codici M (1 alla volta?)
|
|
}
|
|
protected virtual void tryGetSCode()
|
|
{
|
|
// DA IMPLEMENTARE: lettura buffer codici S (1 alla volta?)
|
|
}
|
|
protected virtual void tryGetTCode()
|
|
{
|
|
// DA IMPLEMENTARE: lettura buffer codici T (1 alla volta?)
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|