Samuele E. Locatelli
529 lines
14 KiB
C#
529 lines
14 KiB
C#
using MTC;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace SCMA.AdapterCom
|
|
{
|
|
/// <summary>
|
|
/// Gateway di comunicazione secondo diversi standard, partendo da oggetti BASE MTC
|
|
/// </summary>
|
|
public class Gateway
|
|
{
|
|
|
|
#region oggetti base
|
|
|
|
/// <summary>
|
|
/// Protocollo attivo per la comunicazione dell'adapter
|
|
/// </summary>
|
|
public gwProtocol protocollo;
|
|
/// <summary>
|
|
/// STOBE allarmi:
|
|
/// 1024 bit di strobe degli allarmi attivi (32 word da 4byte/32 bit di flags...)
|
|
/// </summary>
|
|
public byte[] AlarmFlags;
|
|
/// <summary>
|
|
/// Oggetto elenco allarmi
|
|
/// </summary>
|
|
public allarme[] elencoAllarmi;
|
|
/// <summary>
|
|
/// Porta comunicazione standard oggetto
|
|
/// </summary>
|
|
public int port;
|
|
/// <summary>
|
|
/// Stringa di configurazione globale
|
|
/// </summary>
|
|
public string connConfig;
|
|
/// <summary>
|
|
/// Flag per indicare se l'obj stia ancora girando
|
|
/// </summary>
|
|
private bool myRunning = false;
|
|
/// <summary>
|
|
/// Indicatore public di oggetto running running.
|
|
/// </summary>
|
|
public bool Running { get { return myRunning; } }
|
|
/// <summary>
|
|
/// la parte di "mark & sweep" (segnala ed invia) è iniziata e stiamo tracciando le conditions.
|
|
/// </summary>
|
|
bool myBegun = false;
|
|
/// <summary>
|
|
/// Elenco di TUTTI i NODI ITEMS gestiti dal gateway (item/variabile)...
|
|
/// </summary>
|
|
public Dictionary<string, object> itemNodes = new Dictionary<string, object>();
|
|
/// <summary>
|
|
/// Elenco di TUTTI i NODI CONDITIONS gestiti dal gateway (allarme/condizione)...
|
|
/// </summary>
|
|
public Dictionary<string, object> conditionNodes = new Dictionary<string, object>();
|
|
|
|
#endregion
|
|
|
|
#region gestione globale oggetto
|
|
|
|
/// <summary>
|
|
/// init classe come output su LOGFILE
|
|
/// </summary>
|
|
public Gateway()
|
|
{
|
|
port = 0;
|
|
connConfig = "";
|
|
protocollo = gwProtocol.LOGFILE;
|
|
}
|
|
/// <summary>
|
|
/// Inizia la raccolta dati per confronto modifica da precedente...
|
|
/// </summary>
|
|
public virtual void beginDataCollect()
|
|
{
|
|
myBegun = true;
|
|
foreach (object di in itemNodes)
|
|
{
|
|
// inizializza ogni oggetto (in particolare di tipo alarm/conditions x check variazione)
|
|
//di.Begin();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Fa la verifica di cosa sia cambiato ed invia
|
|
/// </summary>
|
|
public virtual void sendChanged()
|
|
{
|
|
if (myBegun)
|
|
{
|
|
foreach (object di in itemNodes)
|
|
{
|
|
//di.Prepare();
|
|
}
|
|
}
|
|
|
|
#if false
|
|
// Separate out the data items into those that are on one line and those
|
|
// need separate lines.
|
|
List<SimpleDataItem> together = new List<SimpleDataItem>();
|
|
List<SimpleDataItem> separate = new List<SimpleDataItem>();
|
|
foreach (object di in trackItems)
|
|
{
|
|
List<SimpleDataItem> list = di.ItemList();
|
|
if (di.NewLine)
|
|
separate.AddRange(list);
|
|
else
|
|
together.AddRange(list);
|
|
}
|
|
|
|
// Compone all the same line data items onto one line.
|
|
string line;
|
|
if (timestamp == null)
|
|
{
|
|
DateTime now = DateTime.UtcNow;
|
|
timestamp = now.ToString("yyyy-MM-dd\\THH:mm:ss.fffffffK");
|
|
}
|
|
if (together.Count > 0)
|
|
{
|
|
line = timestamp;
|
|
foreach (SimpleDataItem di in together)
|
|
line += "|" + di.ToString();
|
|
line += "\n";
|
|
|
|
SendToAll(line);
|
|
}
|
|
|
|
// Now write out all the separate lines
|
|
if (separate.Count > 0)
|
|
{
|
|
foreach (SimpleDataItem di in separate)
|
|
{
|
|
line = timestamp;
|
|
line += "|" + di.ToString() + "\n";
|
|
SendToAll(line);
|
|
}
|
|
}
|
|
|
|
// Flush the output
|
|
FlushAll();
|
|
#endif
|
|
|
|
// Cleanup
|
|
foreach (object di in itemNodes)
|
|
{
|
|
// pulizia oggetti
|
|
//di.Cleanup();
|
|
}
|
|
myBegun = false;
|
|
}
|
|
/// <summary>
|
|
/// Imposta TUTTI i data items unavailable
|
|
/// </summary>
|
|
public virtual void setAllUnavailable()
|
|
{
|
|
foreach (object di in itemNodes)
|
|
{
|
|
//// imposta a unavailable
|
|
//di.Unavailable();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// AVVIA processo lettura CNC e invio dati a client
|
|
/// </summary>
|
|
public virtual void start()
|
|
{
|
|
#if false
|
|
if (!mRunning)
|
|
{
|
|
mListener = new TcpListener(IPAddress.Any, mPort);
|
|
mListener.Start();
|
|
mListenThread = new Thread(new ThreadStart(ListenForClients));
|
|
mListenThread.Start();
|
|
}
|
|
#endif
|
|
}
|
|
/// <summary>
|
|
/// FERMA processo lettura CNC e invio dati a client
|
|
/// </summary>
|
|
public virtual void stop()
|
|
{
|
|
#if false
|
|
if (mRunning)
|
|
{
|
|
mRunning = false;
|
|
mListener.Stop();
|
|
foreach (Object obj in mClients)
|
|
{
|
|
Stream client = (Stream)obj;
|
|
client.Close();
|
|
}
|
|
mClients.Clear();
|
|
|
|
// Wait 5 seconds for the thread to exit.
|
|
mListenThread.Join(2000);
|
|
|
|
// Wait for all client threads to exit.
|
|
mActiveClients.Wait(2000);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione nodi (dataItems / conditions)
|
|
|
|
/// <summary>
|
|
/// Aggiunge un generico item all'elenco di quelli tracciati INDICANDO IL TYPE
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public virtual void addItemNodeByType(string key, itemType tipo)
|
|
{
|
|
if (!itemNodes.ContainsKey(key))
|
|
{
|
|
// di base salvo tipo/valore come KVP nell'item...
|
|
Dictionary<itemType, object> currObj = new Dictionary<itemType, object>();
|
|
currObj.Add(tipo, "UNAVAILABLE");
|
|
itemNodes.Add(key, currObj);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Aggiunge un generico item all'elenco di quelli tracciati INDICANDO IL TYPE ed il valore iniziale
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public virtual void addItemNodeAndSet(string key, itemType tipo, object value)
|
|
{
|
|
addItemNodeByType(key, tipo);
|
|
updateItemNodeValue(key, value);
|
|
}
|
|
/// <summary>
|
|
/// Aggiunge un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public virtual void addItemNode(string key, object value)
|
|
{
|
|
// se non c'è già elemento lo aggiungo...
|
|
if (!itemNodes.ContainsKey(key))
|
|
{
|
|
itemNodes.Add(key, value);
|
|
}
|
|
}
|
|
public virtual void addItemNode(object value)
|
|
{
|
|
if (!itemNodes.ContainsKey(value.ToString()))
|
|
{
|
|
itemNodes.Add(value.ToString(), value.ToString());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Rimuove TUTTI i data items tracciati
|
|
/// </summary>
|
|
public virtual void removeAllItemNodes()
|
|
{
|
|
itemNodes.Clear();
|
|
}
|
|
/// <summary>
|
|
/// Rimuove un item dall'elenco di quelli tracciati
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
public virtual void removeItemNode(string key)
|
|
{
|
|
itemNodes.Remove(key);
|
|
}
|
|
/// <summary>
|
|
/// RESTITUISCE un item da KEY
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public virtual object getItemNode(string key)
|
|
{
|
|
return itemNodes[key];
|
|
}
|
|
/// <summary>
|
|
/// AGGIORNA un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public virtual void updateItemNodeValue(string key, object value)
|
|
{
|
|
itemNodes[key] = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public virtual void addConditionNode(string key, object value)
|
|
{
|
|
conditionNodes.Add(key, value);
|
|
}
|
|
/// <summary>
|
|
/// Rimuove TUTTI i CONDITION NODES tracciati
|
|
/// </summary>
|
|
public virtual void removeAllConditionNodes()
|
|
{
|
|
conditionNodes.Clear();
|
|
}
|
|
/// <summary>
|
|
/// Rimuove un CONDITION NODE dall'elenco di quelli tracciati
|
|
/// </summary>
|
|
/// <param name="key">chaive</param>
|
|
public virtual void removeConditionNode(string key)
|
|
{
|
|
conditionNodes.Remove(key);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione allarmi
|
|
|
|
/// <summary>
|
|
/// processo il vettore LOCALE degli allarmi
|
|
/// </summary>
|
|
public virtual void processAlarm()
|
|
{
|
|
if (AlarmFlags != null)
|
|
{
|
|
// variabili helper
|
|
StFlag32 AlarmBlock = 0;
|
|
allarme currAllarm;
|
|
// controllo TUTTI i bit della variabile COMPLETA degli status allarmi: se ce ne sono di alzati DEVO processare...
|
|
for (int i = 0; i < AlarmFlags.Length / 4; i++)
|
|
{
|
|
// leggo 32bit alla volta...
|
|
AlarmBlock = (StFlag32)BitConverter.ToUInt32(AlarmFlags, i * 4);
|
|
for (int j = 0; j < 32; j++)
|
|
{
|
|
// converto! e aggiungo allarmi sollevati al corretto controller allarmi...
|
|
if (AlarmBlock.HasFlag((StFlag32)Math.Pow(2, j)))
|
|
{
|
|
// recupero allarme da oggetto in memoria...
|
|
currAllarm = elencoAllarmi[i * 32 + j];
|
|
addAlarm(currAllarm);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// SETUP oggetti gestione allarmi
|
|
/// </summary>
|
|
public virtual void addAlarmNodes()
|
|
{
|
|
// minimo sempre PLC/CNC
|
|
addConditionNode("CNC", "CNC");
|
|
addConditionNode("PLC", "PLC");
|
|
}
|
|
/// <summary>
|
|
/// INIT allarmi a normal
|
|
/// </summary>
|
|
public virtual void initAlarms()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// INIT di un SINGOLO NODO di allarme a normal
|
|
/// </summary>
|
|
/// <param name="alarmNode"></param>
|
|
public virtual void initAlarm(object alarmNode)
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Aggiunta SINGOLO allarme su GENERICO (global) nodo
|
|
/// </summary>
|
|
/// <param name="currAllarm">Allarme da riportare al nodo</param>
|
|
public virtual void addAlarm(allarme currAllarm)
|
|
{
|
|
#if false
|
|
// in base al tipo di allarme decodifico condizione...
|
|
Condition.Level livello = Condition.Level.NORMAL;
|
|
switch (currAllarm.livello)
|
|
{
|
|
case "WARNING":
|
|
livello = Condition.Level.WARNING;
|
|
break;
|
|
case "FAULT":
|
|
default:
|
|
livello = Condition.Level.FAULT;
|
|
break;
|
|
}
|
|
// in base al gruppo decido dove assegnare come CONDITION...
|
|
switch (currAllarm.gruppo)
|
|
{
|
|
case "PLC":
|
|
mAlarmPLC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
|
|
break;
|
|
case "CNC":
|
|
default:
|
|
mAlarmCNC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
/// <summary>
|
|
/// Aggiunta SINGOLO allarme su SPECIFICO nodo
|
|
/// </summary>
|
|
/// <param name="alarmNode">Generico nodo di tipo condition</param>
|
|
/// <param name="currAllarm">Allarme da riportare al nodo</param>
|
|
public virtual void addAlarm(object alarmNode, allarme currAllarm)
|
|
{
|
|
#if false
|
|
// in base al tipo di allarme decodifico condizione...
|
|
Condition.Level livello = Condition.Level.NORMAL;
|
|
switch (currAllarm.livello)
|
|
{
|
|
case "WARNING":
|
|
livello = Condition.Level.WARNING;
|
|
break;
|
|
case "FAULT":
|
|
default:
|
|
livello = Condition.Level.FAULT;
|
|
break;
|
|
}
|
|
// in base al gruppo decido dove assegnare come CONDITION...
|
|
switch (currAllarm.gruppo)
|
|
{
|
|
case "PLC":
|
|
mAlarmPLC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
|
|
break;
|
|
case "CNC":
|
|
default:
|
|
mAlarmCNC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
/// <summary>
|
|
/// Tipologia protocolli di comunicazione ammessi
|
|
/// </summary>
|
|
public enum gwProtocol
|
|
{
|
|
/// <summary>
|
|
/// NESSUN protocollo reale --> FILE DUMP sul log...
|
|
/// </summary>
|
|
LOGFILE,
|
|
/// <summary>
|
|
/// Protocollo di comunicazione MTConnect
|
|
/// </summary>
|
|
MTC,
|
|
/// <summary>
|
|
/// Protocollo di comunicazione SCM.OPC.UA.REDIS.SERVER
|
|
/// </summary>
|
|
SOURS
|
|
}
|
|
/// <summary>
|
|
/// Tipologia di ITEM
|
|
/// </summary>
|
|
public enum itemType
|
|
{
|
|
/// <summary>
|
|
/// CONDIZION = ALLARME
|
|
/// </summary>
|
|
Condition,
|
|
/// <summary>
|
|
/// Evento = point in time data
|
|
/// </summary>
|
|
Event,
|
|
/// <summary>
|
|
/// Messaggio generico
|
|
/// </summary>
|
|
Message,
|
|
/// <summary>
|
|
/// Campionamento continuo
|
|
/// </summary>
|
|
Sample
|
|
}
|
|
/// <summary>
|
|
/// Varibili STATO ATTIVO (es attuatori, sistemi...)
|
|
/// </summary>
|
|
public enum actStatus
|
|
{
|
|
/// <summary>
|
|
/// Stato inattivo
|
|
/// </summary>
|
|
INACTIVE = 0,
|
|
/// <summary>
|
|
/// Stato Attivo
|
|
/// </summary>
|
|
ACTIVE
|
|
}
|
|
/// <summary>
|
|
/// Varibili STATO OnOff
|
|
/// </summary>
|
|
public enum onOffStatus
|
|
{
|
|
/// <summary>
|
|
/// Stato OFF
|
|
/// </summary>
|
|
OFF = 0,
|
|
/// <summary>
|
|
/// Stato ON
|
|
/// </summary>
|
|
ON
|
|
}
|
|
/// <summary>
|
|
/// Varibili STATO per EMERGENZA
|
|
/// </summary>
|
|
public enum emStatus
|
|
{
|
|
/// <summary>
|
|
/// Stato ARMATO
|
|
/// </summary>
|
|
ARMED = 0,
|
|
/// <summary>
|
|
/// Stato EMERGENZA PREMUTA
|
|
/// </summary>
|
|
TRIGGERED
|
|
}
|
|
/// <summary>
|
|
/// Varibili STATO per AVAIL
|
|
/// </summary>
|
|
public enum availStatus
|
|
{
|
|
/// <summary>
|
|
/// Stato DISPONIBILE
|
|
/// </summary>
|
|
AVAILABLE = 0,
|
|
/// <summary>
|
|
/// Stato NON disponibile
|
|
/// </summary>
|
|
UNAVAILABLE
|
|
}
|
|
}
|