Samuele E. Locatelli
1853 lines
55 KiB
C#
1853 lines
55 KiB
C#
using IOB_UT;
|
|
using NLog;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace IOB_WIN
|
|
{
|
|
public class IobGeneric
|
|
{
|
|
#region variabili ed oggetti base
|
|
|
|
/// <summary>
|
|
/// Indica se si debba leggere e fare DUMP delel aree di memoria (1 volta x debug...)
|
|
/// </summary>
|
|
public bool doMemDump;
|
|
/// <summary>
|
|
/// Indica se sia richiesto campionamento memoria
|
|
/// </summary>
|
|
public bool doSampleMemory;
|
|
/// <summary>
|
|
/// Evento Iob ha subito un refresh
|
|
/// </summary>
|
|
public event EventHandler eh_refreshed;
|
|
/// <summary>
|
|
/// Determina se sia encessario convertire valori little/big endian (SIEMENS=true, OSAI=FALSE)
|
|
/// </summary>
|
|
public bool hasBigEndian = false;
|
|
/// <summary>
|
|
/// alias booleano false = R
|
|
/// </summary>
|
|
public bool R = false;
|
|
/// <summary>
|
|
/// alias booleano true = W
|
|
/// </summary>
|
|
public bool W = true;
|
|
/// <summary>
|
|
/// wrapper di log
|
|
/// </summary>
|
|
public static Logger lg;
|
|
/// <summary>
|
|
/// ULtimo valore inviato (in caso di disconnessione lo reinvia x garantire watchdog...)
|
|
/// </summary>
|
|
public string lastSignInVal = "";
|
|
/// <summary>
|
|
/// dataOra ultimo log periodico...
|
|
/// </summary>
|
|
public DateTime lastPeriodicLog;
|
|
/// <summary>
|
|
/// dataOra ultimo segnale inviato...
|
|
/// </summary>
|
|
public DateTime lastWatchDog;
|
|
/// <summary>
|
|
/// dataOra ultima verifica CNC disconnesso...
|
|
/// </summary>
|
|
public DateTime lastDisconnCheck;
|
|
/// <summary>
|
|
/// dataOra ultimo PING inviato...
|
|
/// </summary>
|
|
public DateTime lastPING;
|
|
/// <summary>
|
|
/// Oggetto della coda degli elementi letti (e non ancora trasmessi)
|
|
/// </summary>
|
|
public Queue<string> QueueIN = new Queue<string>();
|
|
/// <summary>
|
|
/// Oggetto della coda degli elementi letti di tipo FluxLog (e non ancora trasmessi)
|
|
/// </summary>
|
|
public Queue<string> QueueFLog = new Queue<string>();
|
|
/// <summary>
|
|
/// Coda valori simulazione deterministica...
|
|
/// </summary>
|
|
public Queue<int> QueueSIM = new Queue<int>();
|
|
/// <summary>
|
|
/// Coda valori letti x DEBUG...
|
|
/// </summary>
|
|
public Queue<int> QueueDebug = new Queue<int>();
|
|
|
|
/// <summary>
|
|
/// valore booleano di check se sia in fase di COMUNICAZIONE ATTIVA con il PLC/NC
|
|
/// </summary>
|
|
protected bool adpCommAct;
|
|
/// <summary>
|
|
/// valore booleano di check se sia stato AVVIATO l'adapter (Running)
|
|
/// </summary>
|
|
public bool adpRunning = false;
|
|
/// <summary>
|
|
/// valore booleano di check se l'adapter STIA SALVANDO
|
|
/// </summary>
|
|
public bool adpSaving = false;
|
|
/// <summary>
|
|
/// valore booleano (richiesta di riavvio automatico)
|
|
/// </summary>
|
|
public bool adpTryRestart;
|
|
/// <summary>
|
|
/// Verifica se sia in modalità DEMO x dati INPUT
|
|
/// </summary>
|
|
public bool DemoIn
|
|
{
|
|
get
|
|
{
|
|
return IOB_UT.baseUtils.CRB("DemoIn");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica se sia in modalità DEMO avanzata (campionamento da set di valori ammessi...)
|
|
/// </summary>
|
|
public bool DemoInSample
|
|
{
|
|
get
|
|
{
|
|
return IOB_UT.baseUtils.CRB("DemoInSample");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Numero simulazioni ammesse...
|
|
/// </summary>
|
|
protected int numSim { get; set; }
|
|
/// <summary>
|
|
/// Numero letture IN da avvio
|
|
/// </summary>
|
|
protected int nReadIN { get; set; }
|
|
/// <summary>
|
|
/// Numero letture IN da avvio
|
|
/// </summary>
|
|
protected int nReadFilt { get; set; }
|
|
/// <summary>
|
|
/// Numero invii OUT (svuotamento coda)
|
|
/// </summary>
|
|
protected int nSendOut { get; set; }
|
|
/// <summary>
|
|
/// Verifica se sia in modalità DEMO x dati OUTPUT
|
|
/// </summary>
|
|
public bool DemoOut
|
|
{
|
|
get
|
|
{
|
|
return utils.CRB("DemoOut");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Contatore x invio dati SignalIN
|
|
/// </summary>
|
|
public int counterSigIN { get; set; }
|
|
/// <summary>
|
|
/// Contatore x invio dati FluxLog
|
|
/// </summary>
|
|
public int counterFLog { get; set; }
|
|
/// <summary>
|
|
/// Ultimo URL
|
|
/// </summary>
|
|
public string lastUrl { get; set; }
|
|
/// <summary>
|
|
/// Ultimo programma letto
|
|
/// </summary>
|
|
public string lastPrgName { get; set; }
|
|
/// <summary>
|
|
/// Ultimo SysInfo letto
|
|
/// </summary>
|
|
public string lastSysInfo { get; set; }
|
|
/// <summary>
|
|
/// Ultimo DynData letto
|
|
/// </summary>
|
|
public string lastDynData { get; set; }
|
|
/// <summary>
|
|
/// Ultimo Override set letto
|
|
/// </summary>
|
|
public string lastOverrideFS { get; set; }
|
|
/// <summary>
|
|
/// Ultimo Override set letto
|
|
/// </summary>
|
|
public string lastOverrideRapid { get; set; }
|
|
|
|
/// <summary>
|
|
/// Array dei contatori x segnali blinking
|
|
/// </summary>
|
|
protected int[] i_counters;
|
|
/// <summary>
|
|
/// Vettore 16 BIT valori precedenti
|
|
/// </summary>
|
|
protected int B_previous;
|
|
/// <summary>
|
|
/// Vettore 16 BIT valori in ingresso al filtro
|
|
/// </summary>
|
|
protected int B_input;
|
|
/// <summary>
|
|
/// Vettore 16 BIT valori in uscita dal filtro
|
|
/// </summary>
|
|
protected int B_output;
|
|
/// <summary>
|
|
/// 32 byte input base (es strobe, 8 word da 32 bit di flags...)
|
|
/// </summary>
|
|
public byte[] RawInput = new byte[32];
|
|
/// <summary>
|
|
/// 32 byte output base (es ack, 8 word da 32 bit di flags...)
|
|
/// </summary>
|
|
public byte[] RawOutput = new byte[32];
|
|
/// <summary>
|
|
/// Modo corrente (da classe ENUM)
|
|
/// </summary>
|
|
public CNC_MODE currMode;
|
|
|
|
/// <summary>
|
|
/// Verifica SE si debba fare log verboso (verboso + ogni tot letture IN)
|
|
/// </summary>
|
|
public bool verboseLog
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
int logEvery = utils.CRI("logEvery");
|
|
if (logEvery < 1) logEvery = 10;
|
|
answ = utils.CRB("verbose") && (nReadIN % logEvery == 0);
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica SE si debba fare log periodico (ogni "verboseLogTOut" sec...)
|
|
/// </summary>
|
|
public bool periodicLog
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
answ = (DateTime.Now.Subtract(lastPeriodicLog).TotalSeconds > utils.CRI("verboseLogTOut"));
|
|
if (answ) lastPeriodicLog = DateTime.Now;
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determina se utilizzare blocchi di memoria IOT contigui (e quindi processing "monoblocco" semplificato"=
|
|
/// </summary>
|
|
public bool procIotMem = false;
|
|
/// <summary>
|
|
/// porta x adapter (x restart)
|
|
/// </summary>
|
|
protected int adpPortNum;
|
|
/// <summary>
|
|
/// DataOra ultimo avvio adapter x watchdog
|
|
/// </summary>
|
|
protected DateTime adpStartRun;
|
|
/// <summary>
|
|
/// Data/ora ultimo avvio adapter
|
|
/// </summary>
|
|
public DateTime dtAvvioAdp = DateTime.Now;
|
|
/// <summary>
|
|
/// Data/ora ultimo spegnimento adapter
|
|
/// </summary>
|
|
public DateTime dtStopAdp = DateTime.Now;
|
|
/// <summary>
|
|
/// Oggetto cronometro x campionamento durate chiamate
|
|
/// </summary>
|
|
public Stopwatch stopwatch = new Stopwatch();
|
|
/// <summary>
|
|
/// Conteggio ATTUALE ore macchina ON
|
|
/// </summary>
|
|
public double contOreMaccOn;
|
|
/// <summary>
|
|
/// Conteggio ATTUALE ore macchina IN LAVORO
|
|
/// </summary>
|
|
public double contOreMaccLav;
|
|
/// <summary>
|
|
/// stato Online/Offline della IOB
|
|
/// </summary>
|
|
public bool IobOnline;
|
|
/// <summary>
|
|
/// stato Online/Offline della IOB
|
|
/// </summary>
|
|
public bool MPOnline;
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Form chiamante
|
|
/// </summary>
|
|
protected AdapterForm parentForm;
|
|
/// <summary>
|
|
/// Conf adapter corrente
|
|
/// </summary>
|
|
public IobConfiguration currIobConf;
|
|
/// <summary>
|
|
/// inizializzo l'oggetto sulla form SULLA BASE DEL FILE DI CONFIGURAZIONE letto
|
|
/// </summary>
|
|
/// <param name="caller"></param>
|
|
/// <param name="adpConf"></param>
|
|
public IobGeneric(AdapterForm caller, IobConfiguration IOBConf)
|
|
{
|
|
lg = LogManager.GetCurrentClassLogger();
|
|
lg.Info("Avvio preliminare AdapterGeneric");
|
|
|
|
// configurazione...
|
|
currIobConf = IOBConf;
|
|
// aggiungo altri defaults
|
|
setDefaults();
|
|
// salvo il form chiamante
|
|
parentForm = caller;
|
|
|
|
// concluso!
|
|
lg.Info("Istanziata classe preliminare IOBGeneric");
|
|
}
|
|
/// <summary>
|
|
/// Imposto alcuni valori di default
|
|
/// </summary>
|
|
private void setDefaults()
|
|
{
|
|
numSim = utils.CRI("numSim");
|
|
lastPrgName = "";
|
|
nReadIN = 0;
|
|
nReadFilt = 0;
|
|
nSendOut = 0;
|
|
currMode = 0;
|
|
doMemDump = utils.CRB("doMemDump");
|
|
doSampleMemory = utils.CRB("doSampleMemory");
|
|
// svuoto code... SE NON SIM...
|
|
if (!DemoIn)
|
|
{
|
|
QueueIN.Clear();
|
|
QueueFLog.Clear();
|
|
QueueSIM.Clear();
|
|
}
|
|
// imposto contatori blink a zero...
|
|
i_counters = new int[32];
|
|
lastPeriodicLog = DateTime.Now;
|
|
}
|
|
|
|
|
|
#region metodi adapter
|
|
|
|
|
|
/// <summary>
|
|
/// lettura file di persistenza
|
|
/// </summary>
|
|
public void loadPersData()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Avvia l'adapter sulla porta richiesta
|
|
/// </summary>
|
|
/// <param name="port"></param>
|
|
public virtual void startAdapter(int port)
|
|
{
|
|
lg.Info("Starting adapter...");
|
|
parentForm.commPlcActive = false;
|
|
adpRunning = true;
|
|
dtAvvioAdp = DateTime.Now;
|
|
lastWatchDog = dtAvvioAdp;
|
|
lastPING = dtAvvioAdp;
|
|
lastDisconnCheck = dtAvvioAdp;
|
|
TimingData.resetData();
|
|
// aggiungo altri defaults
|
|
setDefaults();
|
|
adpTryRestart = true;
|
|
parentForm.displayTaskAndLog("Adapter Started!");
|
|
}
|
|
|
|
/// <summary>
|
|
/// ferma l'adapter...
|
|
/// </summary>
|
|
/// <param name="tryRestart">indica se si debba tentare di riavviare l'adapter (con caduta connessione viene fermato in automatico)</param>
|
|
public void stopAdapter(bool tryRestart)
|
|
{
|
|
// svuoto le code dei valori letti e non ancora trasmessi...
|
|
parentForm.displayTaskAndLog("Svuotamento FORZATO coda segnali...");
|
|
while (QueueIN.Count > 0)
|
|
{
|
|
// INVIO COMUNQUE...!!!
|
|
sendToMoonPro(urlType.SignIN, QueueIN.Dequeue());
|
|
}
|
|
parentForm.displayTaskAndLog("Svuotamento FORZATO coda FluxLOG...");
|
|
while (QueueFLog.Count > 0)
|
|
{
|
|
// INVIO COMUNQUE...!!!
|
|
sendToMoonPro(urlType.FLog, QueueFLog.Dequeue());
|
|
}
|
|
|
|
parentForm.displayTaskAndLog("Stopping adapter...");
|
|
adpTryRestart = false;
|
|
|
|
parentForm.displayTaskAndLog("Stopping adapter - last periodic data read...");
|
|
|
|
// chiudo la connessione all'adapter...
|
|
tryDisconnect();
|
|
dtStopAdp = DateTime.Now;
|
|
adpTryRestart = tryRestart;
|
|
adpRunning = false;
|
|
// chiudo!
|
|
parentForm.displayTaskAndLog("Adapter Stopped.");
|
|
parentForm.commPlcActive = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua recupero dati ed invio valori modificati...
|
|
/// </summary>
|
|
/// <param name="ciclo"></param>
|
|
public void getAndSend(gatherCycle ciclo)
|
|
{
|
|
// IN OGNI CASO a prima di tutto EFFETTUO GESTIONE INVII dati da code!!!
|
|
try
|
|
{
|
|
// gestione queue SignalIN (invio, display)
|
|
svuotaCodaSignIN();
|
|
// gestione queue FluxLog (invio, display)
|
|
svuotaCodaFLog();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, string.Format("Errore in gestione svuotamento/invio preliminare code memoria{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
// controllo connessione/connettività
|
|
if (connectionOk)
|
|
{
|
|
// controllo non sia già in esecuzione...
|
|
if (!adpCommAct)
|
|
{
|
|
// provo ad avviare
|
|
try
|
|
{
|
|
// imposto flag adapter running..
|
|
adpCommAct = true;
|
|
adpStartRun = DateTime.Now;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
parentForm.displayTaskAndLog(string.Format("Adapter NOT STARTED!!!{0}{1}", Environment.NewLine, exc));
|
|
adpCommAct = false;
|
|
adpStartRun = DateTime.Now;
|
|
}
|
|
if (adpCommAct)
|
|
{
|
|
// try / catch generale altrimenti segno che è disconnesso...
|
|
try
|
|
{
|
|
bool showDebugData = false;
|
|
if (ciclo == gatherCycle.VHF)
|
|
{
|
|
}
|
|
// processing dati memoria (lettura, filtraggio, enqueque)
|
|
else if (ciclo == gatherCycle.HF)
|
|
{
|
|
processAllMemory();
|
|
}
|
|
else if (ciclo == gatherCycle.MF)
|
|
{
|
|
processMode();
|
|
processOverride();
|
|
}
|
|
else if (ciclo == gatherCycle.LF)
|
|
{
|
|
processContapezzi();
|
|
processProgram();
|
|
}
|
|
else if (ciclo == gatherCycle.VLF)
|
|
{
|
|
processDynData();
|
|
// recupero dati SETUP (sysinfo) e li invio/mostro se variati...
|
|
processSysInfo();
|
|
// se richiesto faccio salvataggio aree memorie
|
|
if (utils.CRB("doSampleMemory")) sampleMemDump();
|
|
// eventuale log!
|
|
if (utils.CRB("recTime")) logTimeResults();
|
|
}
|
|
// mostra eventuali altri dati di processo...
|
|
reportDataProc();
|
|
if (showDebugData)
|
|
{
|
|
// verifica se debba salvare e mostrare dati
|
|
checkSavePersDataLayer();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// segnalo eccezione e indico disconnesso...
|
|
lg.Error(exc, string.Format("Errore in gestione ciclo principale ADP, fermo adapter{0}{1}", Environment.NewLine, exc));
|
|
parentForm.fermaAdapter(true);
|
|
}
|
|
// tolgo flag running
|
|
adpCommAct = false;
|
|
}
|
|
else
|
|
{
|
|
if (periodicLog) lg.Info("ADP not running...");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// log ADP running
|
|
lg.Error("Non eseguo chiamata: ADP ancora in running");
|
|
// se è bloccato da oltre maxSec lo sblocco...
|
|
if (DateTime.Now.Subtract(adpStartRun).TotalSeconds > utils.CRI("maxAdapterLockSec"))
|
|
{
|
|
// tolgo flag running
|
|
adpCommAct = false;
|
|
adpStartRun = DateTime.Now;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// provo a riconnettere SE abilitato tryRestart...
|
|
if (adpTryRestart && !connectionOk)
|
|
{
|
|
tryConnect();
|
|
}
|
|
}
|
|
// segnalo refresh!
|
|
if (eh_refreshed != null)
|
|
{
|
|
eh_refreshed(this, new EventArgs());
|
|
}
|
|
}
|
|
|
|
private void reportDataProc()
|
|
{
|
|
// update valori visualizzazione...
|
|
parentForm.dataProcLabel = string.Format("RAW: {0} --> IN: {1} --> OUT: {2}", nReadIN, nReadFilt, nSendOut);
|
|
}
|
|
|
|
/// <summary>
|
|
/// riporta il log di tutti i dati di results temporali registrati
|
|
/// </summary>
|
|
public void logTimeResults()
|
|
{
|
|
if (TimingData.results.Count > 0)
|
|
{
|
|
lg.Info("{0}--------------- START TIMING DATA ---------------", Environment.NewLine);
|
|
int globNumCall = 0;
|
|
TimeSpan globAvgMsec = new TimeSpan(0);
|
|
foreach (TimeRec item in TimingData.results)
|
|
{
|
|
lg.Info("Chiamate {0}: effettuate {1}, tempo medio {2:N2} msec | impegno canale {3:P3}", item.codCall, item.numCall, item.avgMsec, item.totMsec.TotalSeconds / DateTime.Now.Subtract(dtAvvioAdp).TotalSeconds);
|
|
globNumCall += item.numCall;
|
|
globAvgMsec += item.totMsec;
|
|
}
|
|
// riporto conteggio medio al secondo...
|
|
lg.Info("Chiamate GLOBALI: {0}, periodo: {1:N2} minuti.cent, tempo medio {2:N2} msec | impegno canale {3:P3}", globNumCall, DateTime.Now.Subtract(dtAvvioAdp).TotalMinutes, globAvgMsec.TotalMilliseconds / globNumCall, globAvgMsec.TotalSeconds / DateTime.Now.Subtract(dtAvvioAdp).TotalSeconds);
|
|
lg.Info("{0}--------------- STOP TIMING DATA ---------------{0}", Environment.NewLine);
|
|
// mostro in form statistiche globali!
|
|
parentForm.updateComStats(string.Format("Periodo: {0:N2}min | {1} x {2:N2}ms | canale {3:P3}", DateTime.Now.Subtract(dtAvvioAdp).TotalMinutes, globNumCall, globAvgMsec.TotalMilliseconds / globNumCall, globAvgMsec.TotalSeconds / DateTime.Now.Subtract(dtAvvioAdp).TotalSeconds));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// processa dataLayer e se necessario salva/mostra
|
|
/// </summary>
|
|
public void checkSavePersDataLayer()
|
|
{
|
|
}
|
|
public void resetDebugConsole()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo base connessione...
|
|
/// </summary>
|
|
public virtual void tryConnect()
|
|
{
|
|
|
|
}
|
|
/// <summary>
|
|
/// Metodo base disconnessione...
|
|
/// </summary>
|
|
public virtual void tryDisconnect()
|
|
{
|
|
|
|
}
|
|
protected bool _connOk = false;
|
|
/// <summary>
|
|
/// Salva verifica stato connessione OK
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public virtual bool connectionOk
|
|
{
|
|
get
|
|
{
|
|
return _connOk || DemoIn;
|
|
}
|
|
set
|
|
{
|
|
_connOk = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region layer persistenza dati
|
|
|
|
/// <summary>
|
|
/// Dizionario di persistenza per i valori da salvare da/su file
|
|
/// </summary>
|
|
public Dictionary<string, string> persistenceLayer;
|
|
|
|
/// <summary>
|
|
/// recupera valore salvato in persistence layer (se non c'è crea...)
|
|
/// </summary>
|
|
/// <param name="keyVal"></param>
|
|
/// <returns></returns>
|
|
private string getStoredVal(string keyVal)
|
|
{
|
|
string value = "";
|
|
try
|
|
{
|
|
if (persistenceLayer != null)
|
|
{
|
|
if (!persistenceLayer.TryGetValue(keyVal, out value))
|
|
{
|
|
persistenceLayer.Add(keyVal, "0");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Eccezione in getStoredVal: {0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return value;
|
|
}
|
|
/// <summary>
|
|
/// recupera valore salvato in persistence layer (se non c'è crea...) come UINT
|
|
/// </summary>
|
|
/// <param name="keyVal"></param>
|
|
/// <returns></returns>
|
|
private uint getStoredValUInt(string keyVal)
|
|
{
|
|
uint answ = 0;
|
|
try
|
|
{
|
|
answ = Convert.ToUInt32(getStoredVal(keyVal));
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Eccezione in getStoredValUInt: {0}{1}", Environment.NewLine, exc));
|
|
}
|
|
// verifico che il valore sia minore di 9/10 del valore massimo...
|
|
answ = (answ < (uint.MaxValue / 10 * 9)) ? answ : 0;
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// recupera valore salvato in persistence layer (se non c'è crea...) come INT
|
|
/// </summary>
|
|
/// <param name="keyVal"></param>
|
|
/// <returns></returns>
|
|
private long getStoredValLong(string keyVal)
|
|
{
|
|
long answ = 0;
|
|
try
|
|
{
|
|
answ = Convert.ToInt64(getStoredVal(keyVal));
|
|
}
|
|
catch
|
|
{ }
|
|
// verifico che il valore sia minore di 9/10 del valore massimo...
|
|
answ = (answ < (long.MaxValue / 10 * 9)) ? answ : 0;
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// recupera valore salvato in persistence layer (se non c'è crea...) come double
|
|
/// </summary>
|
|
/// <param name="keyVal"></param>
|
|
/// <returns></returns>
|
|
private double getStoredValDouble(string keyVal)
|
|
{
|
|
double answ = 0;
|
|
try
|
|
{
|
|
answ = Convert.ToDouble(getStoredVal(keyVal));
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Eccezione in getStoredValDouble: {0}{1}", Environment.NewLine, exc));
|
|
}
|
|
answ = (answ < (double.MaxValue / 10 * 9)) ? answ : 0;
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un valore del dizionario in SOSTITUZIONE
|
|
/// </summary>
|
|
/// <param name="i"></param>
|
|
/// <param name="newVal"></param>
|
|
/// <param name="searchString"></param>
|
|
/// <returns>Nuovo valore incrementato</returns>
|
|
private void updateValString(int i, string newVal, string searchString)
|
|
{
|
|
// stringa da cercare..
|
|
string keyVal = string.Format(searchString, i + 1);
|
|
// salvo in ram!
|
|
persistenceLayer[keyVal] = newVal;
|
|
}
|
|
/// <summary>
|
|
/// Aggiorna un valore del dizionario in SOSTITUZIONE e lo restituisce
|
|
/// </summary>
|
|
/// <param name="i"></param>
|
|
/// <param name="newVal"></param>
|
|
/// <param name="searchString"></param>
|
|
/// <returns>Nuovo valore incrementato</returns>
|
|
private void updateValUInt(int i, uint newVal, string searchString)
|
|
{
|
|
// stringa da cercare..
|
|
string keyVal = string.Format(searchString, i + 1);
|
|
// salvo in ram!
|
|
persistenceLayer[keyVal] = newVal.ToString();
|
|
}
|
|
/// <summary>
|
|
/// Aggiorna un valore del dizionario in INCREMENTO e lo restituisce
|
|
/// </summary>
|
|
/// <param name="i"></param>
|
|
/// <param name="delta"></param>
|
|
/// <param name="searchString"></param>
|
|
/// <returns>Nuovo valore incrementato</returns>
|
|
private uint updateValUIntByIncr(int i, uint delta, string searchString)
|
|
{
|
|
// stringa da cercare..
|
|
string keyVal = string.Format(searchString, i + 1);
|
|
// recupero valore precedente...
|
|
uint contAct = getStoredValUInt(keyVal);
|
|
// nuovo valore...
|
|
contAct += delta;
|
|
// salvo in ram!
|
|
persistenceLayer[keyVal] = contAct.ToString();
|
|
// rendo il valore!
|
|
return contAct;
|
|
}
|
|
/// <summary>
|
|
/// Aggiorna un valore del dizionario in INCREMENTO e lo restituisce
|
|
/// </summary>
|
|
/// <param name="i"></param>
|
|
/// <param name="delta"></param>
|
|
/// <param name="searchString"></param>
|
|
/// <returns>Nuovo valore incrementato</returns>
|
|
private long updateValLongByIncr(int i, long delta, string searchString)
|
|
{
|
|
// stringa da cercare..
|
|
string keyVal = string.Format(searchString, i + 1);
|
|
// recupero valore precedente...
|
|
long contAct = getStoredValLong(keyVal);
|
|
// nuovo valore...
|
|
contAct += delta;
|
|
// salvo in ram!
|
|
persistenceLayer[keyVal] = contAct.ToString();
|
|
// rendo il valore!
|
|
return contAct;
|
|
}
|
|
/// <summary>
|
|
/// Aggiorna un valore del dizionario in INCREMENTO e lo restituisce
|
|
/// </summary>
|
|
/// <param name="i"></param>
|
|
/// <param name="delta"></param>
|
|
/// <param name="searchString"></param>
|
|
/// <returns>Nuovo valore incrementato</returns>
|
|
private double updateValDoubleByIncr(int i, double delta, string searchString)
|
|
{
|
|
// stringa da cercare..
|
|
string keyVal = string.Format(searchString, i + 1);
|
|
// recupero valore precedente...
|
|
double contAct = getStoredValDouble(keyVal);
|
|
// nuovo valore...
|
|
contAct += delta;
|
|
// salvo in ram!
|
|
persistenceLayer[keyVal] = contAct.ToString();
|
|
// rendo il valore!
|
|
return contAct;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region area lettura configurazioni
|
|
|
|
/// <summary>
|
|
/// Legge il file di conf di una MAP di informazioni da gestire con lettura set memoria
|
|
/// </summary>
|
|
/// <param name="vettoreConf">nome vettore memoria</param>
|
|
/// <param name="nomeFile">file origine</param>
|
|
/// <param name="memSize">dimensione (in byte) della memoria</param>
|
|
/// <param name="numVett">dimensione (in byte) della memoria</param>
|
|
protected void loadConfFile(ref otherData[] vettoreConf, string nomeFile, int memSize, ref int numVett)
|
|
{
|
|
otherData lastData = new otherData();
|
|
int totRighe = 0;
|
|
string linea;
|
|
totRighe = File.ReadLines(nomeFile).Count();
|
|
// creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
|
|
vettoreConf = new otherData[File.ReadLines(nomeFile).Count()];
|
|
// carica da file...
|
|
StreamReader file = new StreamReader(nomeFile);
|
|
// leggo 1 linea alla volta...
|
|
int numRiga = 0;
|
|
int bitNum = 0;
|
|
int byteNum = 0;
|
|
while ((linea = file.ReadLine()) != null)
|
|
{
|
|
// SE non è un commento...
|
|
if (linea.Substring(0, 1) != "#")
|
|
{
|
|
// se finisce per BIT allora processo bit-a-bit...
|
|
if (linea.EndsWith("BOOL"))
|
|
{
|
|
try
|
|
{
|
|
string[] memIdx = linea.Split(utils.CRC("testCharSep"))[0].Split('.');
|
|
// calcolo bit e byte number...
|
|
int.TryParse(memIdx[0], out byteNum);
|
|
if (memIdx.Length > 1)
|
|
{
|
|
int.TryParse(memIdx[1], out bitNum);
|
|
}
|
|
else
|
|
{
|
|
bitNum = 0;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
byteNum = 0;
|
|
bitNum = 0;
|
|
}
|
|
lastData = decodeBitData(linea, utils.CRC("testCharSep"), byteNum, 1, bitNum);
|
|
vettoreConf[numRiga] = lastData;
|
|
}
|
|
else
|
|
{
|
|
lastData = decodeOtherData(linea, utils.CRC("testCharSep"), "", 1, memSize);
|
|
vettoreConf[numRiga] = lastData;
|
|
}
|
|
numRiga++;
|
|
}
|
|
}
|
|
// salvo lunghezza file...
|
|
try
|
|
{
|
|
numVett = Convert.ToInt32(lastData.memAddr) + 1;
|
|
}
|
|
catch
|
|
{
|
|
numVett = numRiga + 1;
|
|
}
|
|
// chiudo file
|
|
file.Close();
|
|
// ora trimmo vettore al solo numero VERO dei valori caricati...
|
|
Array.Resize<otherData>(ref vettoreConf, numRiga);
|
|
|
|
if (utils.CRB("verbose")) lg.Info(string.Format("Fine caricamento vettore di {0} variabili per file {1}", numRiga, nomeFile));
|
|
}
|
|
/// <summary>
|
|
/// Decodifica file MAP generico
|
|
/// </summary>
|
|
/// <param name="linea"></param>
|
|
/// <param name="separator"></param>
|
|
/// <param name="memPre"></param>
|
|
/// <param name="baseAddr"></param>
|
|
/// <param name="memSize"></param>
|
|
/// <returns></returns>
|
|
protected otherData decodeOtherData(string linea, char separator, string memPre, int baseAddr, int memSize)
|
|
{
|
|
string[] valori = linea.Split(separator);
|
|
int shift = 0;
|
|
try
|
|
{
|
|
shift = Convert.ToInt32(valori[0]) - 1;
|
|
}
|
|
catch
|
|
{ }
|
|
string memAddr = string.Format("{0}{1}", memPre, baseAddr + shift * memSize);
|
|
return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
|
|
}
|
|
/// <summary>
|
|
/// Decodifica file MAP (caso <paramref name="ByteNum"/>.bit)
|
|
/// </summary>
|
|
/// <param name="linea"></param>
|
|
/// <param name="separator"></param>
|
|
/// <param name="ByteNum">indirizzo Byte: indirizzo di partenza memoria</param>
|
|
/// <param name="memSize">dimensione singolo slot in byte</param>
|
|
/// <param name="BitNum">indirizzo bit: numero riga x calcolo indice bit</param>
|
|
/// <returns></returns>
|
|
protected otherData decodeBitData(string linea, char separator, int ByteNum, int memSize, int BitNum)
|
|
{
|
|
string[] valori = linea.Split(separator);
|
|
int shift = 0;
|
|
try
|
|
{
|
|
shift = Convert.ToInt32(valori[0]) - 1;
|
|
}
|
|
catch
|
|
{ }
|
|
int resto = 0;
|
|
Math.DivRem(BitNum, 8, out resto);
|
|
string memAddr = string.Format("{0}.{1}", ByteNum + shift * memSize, resto);
|
|
return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// effettua ogni log period una rilettura di TUTTI gli allarmi...
|
|
/// </summary>
|
|
public virtual void forceAlarmCheck()
|
|
{
|
|
}
|
|
|
|
#region area simulazione
|
|
|
|
/// <summary>
|
|
/// lettura memoria in SIMULAZIONE
|
|
/// </summary>
|
|
public void simReadMem()
|
|
{
|
|
if (lastSim == null)
|
|
{
|
|
lastSim = DateTime.Now;
|
|
}
|
|
// simulazione complessa (basata su samples dei parametri effettivi...)
|
|
if (utils.CRB("DemoInSample"))
|
|
{
|
|
if (numSim >= 0)
|
|
{
|
|
// verifico se la coda di simulazione sia piena altrimenti la RICARICO...
|
|
if (QueueSIM.Count == 0)
|
|
{
|
|
leggiSimFile();
|
|
numSim--;
|
|
}
|
|
// processo la coda di simulazione (stacco ed accodo 1 valore...)
|
|
B_input = QueueSIM.Dequeue();
|
|
countSim++;
|
|
// ogni 5 loggo...
|
|
if (countSim % 5 == 0)
|
|
{
|
|
lg.Info("Read {0} sim data", countSim);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// fermo tutto!
|
|
parentForm.sIN = Semaforo.SR;
|
|
parentForm.fermaAdapter(false);
|
|
}
|
|
}
|
|
// simulazione semplice (counter crescente)
|
|
else
|
|
{
|
|
// se passato 1 sec genero NUOV num casuale e lo metto nel bit strobe... ogni 2 sec...
|
|
if (DateTime.Now.Subtract(lastSim).TotalMilliseconds > 100)
|
|
{
|
|
countSim++;
|
|
if (countSim > 255) countSim = 0;
|
|
B_input = countSim;
|
|
}
|
|
}
|
|
lastSim = DateTime.Now;
|
|
}
|
|
/// <summary>
|
|
/// legge ed accoda file Sim in QueueSIM
|
|
/// </summary>
|
|
private void leggiSimFile()
|
|
{
|
|
int totRighe = 0;
|
|
string fileName = utils.simDataFile;
|
|
string linea;
|
|
totRighe = File.ReadLines(fileName).Count();
|
|
lg.Info("File SIM: TROVATE {0} righe", totRighe);
|
|
// ora conto righe effettive...
|
|
totRighe = 0;
|
|
// carica da file...
|
|
StreamReader file = new StreamReader(fileName);
|
|
// leggo 1 linea alla volta...
|
|
int valore = 0;
|
|
while ((linea = file.ReadLine()) != null)
|
|
{
|
|
// SE non è un commento...
|
|
if (linea.Substring(0, 1) != ";")
|
|
{
|
|
//elencoAllarmi[rumRiga] = decodeAlarmLine(linea, ':');
|
|
Int32.TryParse(linea, out valore);
|
|
QueueSIM.Enqueue(valore);
|
|
totRighe++;
|
|
}
|
|
}
|
|
// chiudo file
|
|
file.Close();
|
|
lg.Info("File SIM: LETTE {0} righe", totRighe);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IOB METHODS
|
|
|
|
/// <summary>
|
|
/// Valore del num max invii consecutivi da coda...
|
|
/// </summary>
|
|
protected int nMaxSend = 5;
|
|
/// <summary>
|
|
/// DateTime Ultimo valore simulazione generato
|
|
/// </summary>
|
|
public DateTime lastSim;
|
|
/// <summary>
|
|
/// contatore x simulazione valori input
|
|
/// </summary>
|
|
public int countSim = 0;
|
|
/// <summary>
|
|
/// URL per check alive...
|
|
/// </summary>
|
|
public string urlAlive
|
|
{
|
|
get
|
|
{
|
|
return string.Format(@"{0}{1}{2}", currIobConf.serverData.MPIP, currIobConf.serverData.MPURL, currIobConf.serverData.CMDALIVE);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// URL per check alive...
|
|
/// </summary>
|
|
public string urlIobEnabled
|
|
{
|
|
get
|
|
{
|
|
return string.Format(@"{0}{1}{2}{3}", currIobConf.serverData.MPIP, currIobConf.serverData.MPURL, currIobConf.serverData.CMDENABLED, currIobConf.codIOB);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// URL per segnalazione reboot...
|
|
/// </summary>
|
|
public string urlReboot
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format(@"{0}{1}{2}{3}&mac={4}", currIobConf.serverData.MPIP, currIobConf.serverData.MPURL, currIobConf.serverData.CMDREBO, currIobConf.codIOB, GetMACAddress());
|
|
}
|
|
catch
|
|
{
|
|
answ = string.Format(@"{0}{1}{2}{3}", currIobConf.serverData.MPIP, currIobConf.serverData.MPURL, currIobConf.serverData.CMDREBO, currIobConf.codIOB);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
public string GetMACAddress()
|
|
{
|
|
NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();
|
|
String sMacAddress = string.Empty;
|
|
foreach (NetworkInterface adapter in nics)
|
|
{
|
|
if (sMacAddress == String.Empty)// only return MAC Address from first card
|
|
{
|
|
IPInterfaceProperties properties = adapter.GetIPProperties();
|
|
//sMacAddress = adapter.GetPhysicalAddress().ToString();
|
|
sMacAddress = string.Join(":", (from z in adapter.GetPhysicalAddress().GetAddressBytes() select z.ToString("X2")).ToArray());
|
|
}
|
|
}
|
|
return sMacAddress;
|
|
}
|
|
/// <summary>
|
|
/// Fornisce URL INPUT per i parametri richiesti
|
|
/// </summary>
|
|
/// <param name="queueVal">valore salvato in coda formato dtEve#valore#counter</param>
|
|
/// <returns></returns>
|
|
public string urlInput(string queueVal)
|
|
{
|
|
// URL base x input
|
|
string answ = string.Format(@"{0}{1}{2}", currIobConf.serverData.MPIP, currIobConf.serverData.MPURL, currIobConf.serverData.CMDBASE);
|
|
// decodifica valore!
|
|
string[] valori = qDecodeIN(queueVal);
|
|
// aggiungo macchina e valore...
|
|
answ += string.Format(@"{0}?valore={1}", currIobConf.codIOB, valori[1]);
|
|
// aggiondo dataOra evento e corrente + contatore...
|
|
answ += string.Format(@"&&dtEve={0}&&dtCurr={1:yyyyMMddHHmmssfff}&&cnt={2}", valori[0], DateTime.Now, valori[2]);
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Fornisce URL di tipo FluxLog
|
|
/// </summary>
|
|
/// <param name="queueVal">valore salvato in coda nel formato dtEve#flux#valore#counter</param>
|
|
/// <returns></returns>
|
|
public string urlFLog(string queueVal)
|
|
{
|
|
// URL base x input
|
|
string answ = string.Format(@"{0}{1}{2}", currIobConf.serverData.MPIP, currIobConf.serverData.MPURL, currIobConf.serverData.CMDFLOG);
|
|
// decodifica valore!
|
|
string[] valori = qDecodeIN(queueVal);
|
|
// aggiungo macchina e valore...
|
|
answ += string.Format(@"{0}?flux={1}&&valore={2}", currIobConf.codIOB, valori[1], valori[2]);
|
|
// aggiondo dataOra evento e corrente + contatore...
|
|
answ += string.Format(@"&&dtEve={0}&&dtCurr={1:yyyyMMddHHmmssfff}&&cnt={2}", valori[0], DateTime.Now, valori[3]);
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Effettua chaimata URL e restituisce risultato
|
|
/// </summary>
|
|
/// <param name="URL"></param>
|
|
/// <returns></returns>
|
|
public string callUrl(string URL)
|
|
{
|
|
string answ = "";
|
|
var client = new WebClient();
|
|
client.Headers.Add("user-agent", utils.CRS("appName"));
|
|
answ = client.DownloadString(URL);
|
|
// restituisco valore!
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Verifica se il server sia ALIVE
|
|
/// </summary>
|
|
private bool checkServerAlive
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
if (DemoOut)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
// chiamo URL, se restituisce "OK" è alive!
|
|
answ = (callUrl(urlAlive) == "OK");
|
|
}
|
|
catch
|
|
{ }
|
|
// verifico SE è variato stato online/offline...
|
|
if (MPOnline != answ)
|
|
{
|
|
// se ORA sono online riporto...
|
|
if (answ)
|
|
{
|
|
lg.Info("SERVER ONLINE");
|
|
}
|
|
else
|
|
{
|
|
lg.Info("SERVER OFFLINE");
|
|
}
|
|
// salvo nuovo status...
|
|
MPOnline = answ;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica se la IOB sia ENABLED (da server o Demo)
|
|
/// </summary>
|
|
private bool checkIobEnabled
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
if (DemoOut)
|
|
{
|
|
answ = (QueueIN.Count + QueueFLog.Count >= nMaxSend);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
// chiamo URL, se restituisce "OK" è enabled!
|
|
answ = (callUrl(urlIobEnabled) == "OK");
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
// verifico SE è variato stato online/offline...
|
|
if (IobOnline != answ)
|
|
{
|
|
// se ORA sono online riporto...
|
|
if (answ)
|
|
{
|
|
lg.Info("IOB ONLINE");
|
|
}
|
|
else
|
|
{
|
|
lg.Info("IOB OFFLINE");
|
|
}
|
|
// salvo nuovo status...
|
|
IobOnline = answ;
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Processo la coda SignalIN...
|
|
/// </summary>
|
|
public void svuotaCodaSignIN()
|
|
{
|
|
// verifico SE la coda abbia dei valori...
|
|
if (QueueIN.Count > 0)
|
|
{
|
|
// verifico se risponde il server...
|
|
if (checkServerAlive)
|
|
{
|
|
// verifico SE posso inviare dati
|
|
if (checkIobEnabled)
|
|
{
|
|
// invio pacchetto di dati (max da conf)
|
|
for (int i = 0; i < nMaxSend; i++)
|
|
{
|
|
// SE ho qualcosa in coda...
|
|
if (QueueIN.Count > 0)
|
|
{
|
|
// recupero ed aggiorno ULTIMO valore...
|
|
lastSignInVal = QueueIN.Dequeue();
|
|
// INVIO!!!
|
|
sendToMoonPro(urlType.SignIN, lastSignInVal);
|
|
}
|
|
else
|
|
{
|
|
// ...ANCHE SE NON AVESSI NULLA controllo se è passato oltre watchdog e non ho inviato nulla --> INVIO!!!!
|
|
if (DateTime.Now.Subtract(lastWatchDog).TotalSeconds > utils.CRI("watchdogMaxSec"))
|
|
{
|
|
// se ultimo valore è coerente...
|
|
if (lastSignInVal != "") sendToMoonPro(urlType.SignIN, lastSignInVal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// mostro VETO-SEND x invio... GIALLO
|
|
parentForm.sOUT = Semaforo.SG;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// mostro SERVER KO x invio... ROSSO
|
|
parentForm.sOUT = Semaforo.SR;
|
|
}
|
|
}
|
|
//controllo se è passato oltre watchdog e non ho inviato nulla --> RE-INVIO (ultimo inviato)!!!!
|
|
}
|
|
/// <summary>
|
|
/// Processo la coda FLog...
|
|
/// </summary>
|
|
private void svuotaCodaFLog()
|
|
{
|
|
// verifico SE la coda abbia dei valori...
|
|
if (QueueFLog.Count > 0)
|
|
{
|
|
// verifico se risponde il server...
|
|
if (checkServerAlive)
|
|
{
|
|
// verifico SE posso inviare dati
|
|
if (checkIobEnabled)
|
|
{
|
|
// invio pacchetto di dati (max da conf)
|
|
for (int i = 0; i < nMaxSend; i++)
|
|
{
|
|
// SE ho qualcosa in coda...
|
|
if (QueueFLog.Count > 0)
|
|
{
|
|
// INVIO!!!
|
|
sendToMoonPro(urlType.FLog, QueueFLog.Dequeue());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// mostro VETO-SEND x invio... GIALLO
|
|
parentForm.sOUT = Semaforo.SG;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// mostro SERVER KO x invio... ROSSO
|
|
parentForm.sOUT = Semaforo.SR;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Classe fittizia in caso di processing GLOBALE di tutto in 1 solo colpo...
|
|
/// </summary>
|
|
private void processAllMemory()
|
|
{
|
|
// in primis SALVO valori previous/precedenti
|
|
B_previous = B_output;
|
|
// poi faccio lettura NUOVI valori
|
|
readAllData();
|
|
// eseguo il filtering dei valori (per i bit "blinking")
|
|
filterData();
|
|
// effettuo confronto valori vecchi/nuovi... SE trovo variazione
|
|
if (B_output != B_previous)
|
|
{
|
|
accodaSigIN();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Processa gestione memoria x invio dati QUANDO IOB è disconensso da CNC...
|
|
/// </summary>
|
|
public void processMemoryDiscon()
|
|
{
|
|
// controllo contatore invio "keepalive"... invio solo a scadenza
|
|
if (DateTime.Now.Subtract(lastDisconnCheck).TotalSeconds > utils.CRI("disconMaxSec"))
|
|
{
|
|
// resetto tutti i vlaori BYTE IN/PREV/OUT... così invio macchina spenta...
|
|
B_input = 0;
|
|
B_output = 0;
|
|
B_previous = 0;
|
|
accodaSigIN();
|
|
// update controllo
|
|
lastDisconnCheck = DateTime.Now;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Esegue filtraggio dati x bit blinking!!!
|
|
/// </summary>
|
|
private void filterData()
|
|
{
|
|
// effettuo filtraggio dei valori letti... inizializzo OUT!
|
|
B_output = 0;
|
|
// in primis verifico SE ci siano bit blinkng... se non ci sono OUT=IN...
|
|
if (currIobConf.BLINK_FILT == 0)
|
|
{
|
|
B_output = B_input;
|
|
}
|
|
else
|
|
{
|
|
// incomincio con i valori NON blinking: questi "passano invariati", inizio a sommare nel valore OUT...
|
|
B_output = B_input & ~currIobConf.BLINK_FILT;
|
|
// calcolo il valore dei BIT che "passano la maschera"
|
|
int iBlink = B_input & currIobConf.BLINK_FILT;
|
|
// ...aggiungo i "bit che passano"
|
|
B_output += iBlink;
|
|
|
|
// calcolo QUALI valori (tra quelli blink) siano PASSATI da 0 a 1 --> init counters...
|
|
BitArray bBlinkStart = new BitArray(new byte[] { Convert.ToByte(iBlink) });
|
|
int[] bitsUp = bBlinkStart.Cast<bool>().Select(bit => bit ? 1 : 0).ToArray();
|
|
for (int i = 0; i < bitsUp.Length; i++)
|
|
{
|
|
// SE 1... impostiamo contatori al MAX
|
|
if (bitsUp[i] == 1)
|
|
{
|
|
// se era zero indico START blink...
|
|
if (i_counters[i] == 0)
|
|
{
|
|
lg.Info("START BLINK: B{0}", i);
|
|
}
|
|
// imposto comunque contatore al cambio fronte...
|
|
i_counters[i] = currIobConf.MAX_COUNTER_BLINK;
|
|
}
|
|
}
|
|
|
|
// quelli che sono zero... LI RECUPERO E LI PROCESSO...
|
|
int iZero = ~B_input & currIobConf.BLINK_FILT;
|
|
BitArray bBlinkEnd = new BitArray(new byte[] { Convert.ToByte(iZero) });
|
|
int[] bitsDown = bBlinkEnd.Cast<bool>().Select(bit => bit ? 1 : 0).ToArray();
|
|
for (int i = 0; i < bitsDown.Length; i++)
|
|
{
|
|
// se era a zero (invertito...)
|
|
if (bitsDown[i] == 1)
|
|
{
|
|
// SE è in corso il conteggio...
|
|
if (i_counters[i] > 0)
|
|
{
|
|
// decremento!
|
|
i_counters[i] -= 1;
|
|
// se è zero NON faccio nulla, altrimenti SOMMO...
|
|
if (i_counters[i] > 0)
|
|
{
|
|
B_output += 1 << i;
|
|
}
|
|
else
|
|
{
|
|
lg.Info("END BLINK: B{0}", i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua lettura dati
|
|
/// </summary>
|
|
public virtual void readAllData()
|
|
{
|
|
if (!DemoIn)
|
|
{
|
|
if (connectionOk)
|
|
{
|
|
readSemafori();
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Errore connessione mancante x readSemafori");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// segnalo ceh sono in Demo
|
|
parentForm.sIN = Semaforo.SS;
|
|
// simulo letura
|
|
simReadMem();
|
|
}
|
|
nReadIN++;
|
|
// aggiorno valore mostrato...
|
|
displayRawData();
|
|
}
|
|
/// <summary>
|
|
/// Effettua gestioen programma: legge e mostra su display...
|
|
/// </summary>
|
|
private void processProgram()
|
|
{
|
|
string currPrgName = "";
|
|
if (!DemoIn)
|
|
{
|
|
if (connectionOk)
|
|
{
|
|
currPrgName = getPrgName();
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Errore connessione mancante x getPrgName");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currPrgName = string.Format("{0:HHmmss}|O{0:HHmmss}", DateTime.Now);
|
|
}
|
|
// verifico SE sia cambiato il programma...
|
|
if (lastPrgName != currPrgName)
|
|
{
|
|
// salvo!
|
|
lastPrgName = currPrgName;
|
|
string sVal = string.Format("[PROG]{0}", currPrgName);
|
|
|
|
// chiamo accodamento...
|
|
accodaFLog(sVal, qEncodeFLog("PROG", currPrgName));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Processo lettura dati sysinfo
|
|
/// </summary>
|
|
private void processSysInfo()
|
|
{
|
|
if (utils.CRB("enableSysInfo"))
|
|
{
|
|
Dictionary<string, string> currSysInfo = new Dictionary<string, string>();
|
|
if (!DemoIn)
|
|
{
|
|
if (connectionOk)
|
|
{
|
|
currSysInfo = getSysInfo();
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Errore connessione mancante x getSysInfo");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currSysInfo.Add("SYS-DEMO", string.Format("S-{0:HHmm}", DateTime.Now));
|
|
}
|
|
// verifico SE sia cambiato il programma...
|
|
if (lastSysInfo != currSysInfo["SYSINFO"])
|
|
{
|
|
// salvo!
|
|
lastSysInfo = currSysInfo["SYSINFO"];
|
|
// per ogni valore del dizionario mostro ed accodo!
|
|
string sVal = "";
|
|
foreach (var item in currSysInfo)
|
|
{
|
|
sVal = string.Format("[SYSINFO]{0}|{1}", item.Key, item.Value);
|
|
// chiamo accodamento...
|
|
accodaFLog(sVal, qEncodeFLog(item.Key, item.Value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Restituisce info sistema
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public virtual Dictionary<string, string> getSysInfo()
|
|
{
|
|
Dictionary<string, string> outVal = new Dictionary<string, string>();
|
|
return outVal;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce info DINAMICHE
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public virtual Dictionary<string, string> getDynData()
|
|
{
|
|
Dictionary<string, string> outVal = new Dictionary<string, string>();
|
|
return outVal;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce info OVERRIDES
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public virtual Dictionary<string, string> getOverrides()
|
|
{
|
|
Dictionary<string, string> outVal = new Dictionary<string, string>();
|
|
return outVal;
|
|
}
|
|
/// <summary>
|
|
/// Restituisce programma in esecuzione
|
|
/// </summary>
|
|
public virtual string getPrgName()
|
|
{
|
|
return "";
|
|
}
|
|
/// <summary>
|
|
/// Effettua lettura semafori principale
|
|
/// </summary>
|
|
public virtual void readSemafori()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua processing contapezzi (ed eventualmente alza il bit di contapezzo...)
|
|
/// </summary>
|
|
public virtual void processContapezzi()
|
|
{ }
|
|
/// <summary>
|
|
/// Effettua processing mode/status (EDIT/MDI/...)
|
|
/// </summary>
|
|
public virtual void processMode()
|
|
{ }
|
|
/// <summary>
|
|
/// Effettua processing del recupero delle speed (RPM, feedrate) degli assi
|
|
/// </summary>
|
|
public void processDynData()
|
|
{
|
|
if (utils.CRB("enableDynData"))
|
|
{
|
|
Dictionary<string, string> currDynData = new Dictionary<string, string>();
|
|
if (!DemoIn)
|
|
{
|
|
if (connectionOk)
|
|
{
|
|
currDynData = getDynData();
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Errore connessione mancante x getDynData");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currDynData.Add("DYNDATA", string.Format("D-{0:HHmm}", DateTime.Now));
|
|
}
|
|
// verifico SE sia cambiato il programma...
|
|
if (lastDynData != currDynData["DYNDATA"])
|
|
{
|
|
// salvo!
|
|
lastDynData = currDynData["DYNDATA"];
|
|
// per ogni valore del dizionario mostro ed accodo!
|
|
string sVal = "";
|
|
foreach (var item in currDynData)
|
|
{
|
|
sVal = string.Format("[DYNDATA]{0}|{1}", item.Key, item.Value);
|
|
// chiamo accodamento...
|
|
accodaFLog(sVal, qEncodeFLog(item.Key, item.Value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua processing del recupero delle OVERRIDE (spindle, feedrate, rapid)
|
|
/// </summary>
|
|
public virtual void processOverride()
|
|
{
|
|
if (utils.CRB("enableOverrides"))
|
|
{
|
|
Dictionary<string, string> currOverride = new Dictionary<string, string>();
|
|
if (!DemoIn)
|
|
{
|
|
|
|
if (connectionOk)
|
|
{
|
|
currOverride = getOverrides();
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Errore connessione mancante x getOverrides");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currOverride.Add("FEED_OVER", string.Format("D-{0:HHmm}", DateTime.Now));
|
|
}
|
|
// SE sono connesso...
|
|
if (connectionOk)
|
|
{
|
|
// verifico SE sia cambiato il programma...
|
|
if (lastOverrideFS != currOverride["FEED_OVER"] || lastOverrideRapid != currOverride["RAPID_OVER"])
|
|
{
|
|
// salvo!
|
|
lastOverrideFS = currOverride["FEED_OVER"];
|
|
lastOverrideRapid = currOverride["RAPID_OVER"];
|
|
// per ogni valore del dizionario mostro ed accodo!
|
|
string sVal = "";
|
|
foreach (var item in currOverride)
|
|
{
|
|
sVal = string.Format("[OVERRIDES]{0}|{1}", item.Key, item.Value);
|
|
// chiamo accodamento...
|
|
accodaFLog(sVal, qEncodeFLog(item.Key, item.Value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// metodo dummy x salvataggio aree memoria conf x CN
|
|
/// </summary>
|
|
public virtual void saveMemDump()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// metodo dummy x salvataggio aree memoria conf x CN
|
|
/// </summary>
|
|
public virtual void sampleMemDump()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione code (accumulo, invio)
|
|
|
|
/// <summary>
|
|
/// Fornisce il valore letto da BITMAP in formato valido x messa in coda nel formato dtEve#value#cont
|
|
/// </summary>
|
|
protected string qEncodeIN
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("{0:yyyyMMddHHmmssfff}#{1:X2}#{2}", DateTime.Now, (int)B_output, counterSigIN);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Fornisce il valore di flusso e valore in formato valido x messa in coda nel formato dtEve#flux#value#cont
|
|
/// </summary>
|
|
public string qEncodeFLog(string flusso, string valore)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("{0:yyyyMMddHHmmssfff}#{1}#{2}#{3}", DateTime.Now, flusso, valore, counterFLog);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Decodifica valore della coda IN nel formato
|
|
/// answ[0]=dtEve
|
|
/// answ[1]=valore
|
|
/// answ[2]=counter
|
|
/// </summary>
|
|
/// <param name="queueVal">dtEve + '#' + value + '#' + cont</param>
|
|
/// <returns></returns>
|
|
protected string[] qDecodeIN(string queueVal)
|
|
{
|
|
return queueVal.Split('#');
|
|
}
|
|
/// <summary>
|
|
/// Accumula in coda i valori Signal IN e logga...
|
|
/// </summary>
|
|
public void accodaSigIN()
|
|
{
|
|
// mostro dati variati letti...
|
|
displayInData();
|
|
// --> accodo (valore già formattato)!
|
|
QueueIN.Enqueue(qEncodeIN);
|
|
// loggo!
|
|
lg.Info(string.Format("[QUEUE-IN] {0}", qEncodeIN));
|
|
// aggiorno counters ed eventuale reset
|
|
nReadFilt++;
|
|
if (nReadFilt > int.MaxValue - 1) nReadFilt = 0; // per evitare buffer overflow...
|
|
counterSigIN++;
|
|
if (counterSigIN > 9999) counterSigIN = 0;
|
|
}
|
|
/// <summary>
|
|
/// Accumula in coda i valori Signal IN e logga...
|
|
/// </summary>
|
|
/// <param name="val">VALORE RAW (x display)</param>
|
|
/// <param name="encodedVal">VALORE già processato con qEncodeFLog(...)</param>
|
|
public void accodaFLog(string val, string encodedVal)
|
|
{
|
|
// mostro dati variati letti...
|
|
displayOtherData(val);
|
|
// --> accodo (valore già formattato)!
|
|
QueueFLog.Enqueue(encodedVal);
|
|
// loggo!
|
|
lg.Info(string.Format("[QUEUE-FLOG] {0}", encodedVal));
|
|
counterFLog++;
|
|
if (counterFLog > 9999) counterFLog = 0;
|
|
}
|
|
/// <summary>
|
|
/// Effettua invio a MoonPro del valore richiesto
|
|
/// </summary>
|
|
/// <param name="tipoUrl"></param>
|
|
/// <param name="queueVal">Valore da trasmettere: es
|
|
/// INPUT: lo status rilevato in HEX
|
|
/// FLog: il valore da trasmettere per il flusso indicato</param>
|
|
public void sendToMoonPro(urlType tipoUrl, string queueVal)
|
|
{
|
|
// recupero e formatto URL dati da coda...
|
|
switch (tipoUrl)
|
|
{
|
|
case urlType.FLog:
|
|
lastUrl = urlFLog(queueVal);
|
|
break;
|
|
case urlType.SignIN:
|
|
lastUrl = urlInput(queueVal);
|
|
break;
|
|
default:
|
|
lastUrl = "";
|
|
break;
|
|
}
|
|
// se NON sono in demo effettuo invio!
|
|
if (!DemoOut)
|
|
{
|
|
// chiamo URL!
|
|
string answ = callUrl(lastUrl);
|
|
// loggo!
|
|
lg.Info(string.Format("[SEND] {0} -> {1}", queueVal, answ));
|
|
// se "OK" verde, altrimenti errore --> ROSSO
|
|
if (answ == "OK")
|
|
{
|
|
parentForm.sOUT = Semaforo.SV;
|
|
}
|
|
else
|
|
{
|
|
parentForm.sOUT = Semaforo.SR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parentForm.sOUT = Semaforo.SV;
|
|
// loggo!
|
|
lg.Info(string.Format("{0} -> [SIM]", queueVal));
|
|
}
|
|
nSendOut++;
|
|
// riporto cosa inviato
|
|
displayOutData();
|
|
// aggiorno data ultimo watchdog...
|
|
lastWatchDog = DateTime.Now;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione dataMonitor (update visualizzazione valori)
|
|
|
|
/// <summary>
|
|
/// Mostra i dati grezzi letti in esadecimale
|
|
/// </summary>
|
|
private void displayRawData()
|
|
{
|
|
// mostro update...
|
|
string newString = string.Format("{0:X}", (int)B_input);
|
|
accodaRawData(newString);
|
|
// salvo coda debug...
|
|
QueueDebug.Enqueue(B_input);
|
|
}
|
|
/// <summary>
|
|
/// Update visualizzaizone BIT in ingresso
|
|
/// </summary>
|
|
public void displayInData()
|
|
{
|
|
// mostro update...
|
|
string newString = string.Format("{0:0000}|{1}", counterSigIN, utils.IntToBinStr((int)B_output, 8));
|
|
accodaSignaInlData(newString);
|
|
}
|
|
/// <summary>
|
|
/// Mostra cosa ha/avrebbe inviato
|
|
/// </summary>
|
|
public void displayOutData()
|
|
{
|
|
accodaUrlData(lastUrl);
|
|
}
|
|
/// <summary>
|
|
/// Mostra cosa ha/avrebbe inviato
|
|
/// </summary>
|
|
/// <param name="newData"></param>
|
|
public void displayOtherData(string newData)
|
|
{
|
|
// mostro update...
|
|
accodaOtherData(newData);
|
|
}
|
|
/// <summary>
|
|
/// Accoda (visualizzando in cima allo stack) la nuova stringa di output per area OTHER DATA
|
|
/// </summary>
|
|
/// <param name="newLine"></param>
|
|
public void accodaRawData(string newLine)
|
|
{
|
|
// inserisco in cima allo stack, trimmo e aggiorno display
|
|
parentForm.dataMonitor_0 = limitLine2show(string.Format("{0}{1}{2}", newLine, Environment.NewLine, parentForm.dataMonitor_0));
|
|
}
|
|
/// <summary>
|
|
/// Accoda (visualizzando in cima allo stack) la nuova stringa di output per area OTHER DATA
|
|
/// </summary>
|
|
/// <param name="newLine"></param>
|
|
public void accodaSignaInlData(string newLine)
|
|
{
|
|
// inserisco in cima allo stack, trimmo e aggiorno display
|
|
parentForm.dataMonitor_1 = limitLine2show(string.Format("{0}{1}{2}", newLine, Environment.NewLine, parentForm.dataMonitor_1));
|
|
}
|
|
/// <summary>
|
|
/// Accoda (visualizzando in cima allo stack) la nuova stringa di output per area OTHER DATA
|
|
/// </summary>
|
|
/// <param name="newLine"></param>
|
|
public void accodaUrlData(string newLine)
|
|
{
|
|
// inserisco in cima allo stack, trimmo e aggiorno display
|
|
parentForm.dataMonitor_2 = limitLine2show(string.Format("{0}{1}{2}", newLine, Environment.NewLine, parentForm.dataMonitor_2));
|
|
}
|
|
/// <summary>
|
|
/// Accoda (visualizzando in cima allo stack) la nuova stringa di output per area OTHER DATA
|
|
/// </summary>
|
|
/// <param name="newLine"></param>
|
|
public void accodaOtherData(string newLine)
|
|
{
|
|
// inserisco in cima allo stack, trimmo e aggiorno display
|
|
parentForm.dataMonitor_3 = limitLine2show(string.Format("{0}{1}{2}", newLine, Environment.NewLine, parentForm.dataMonitor_3));
|
|
}
|
|
/// <summary>
|
|
/// Effettua un trim della stringa al numero max di linee da mostrare a video
|
|
/// </summary>
|
|
/// <param name="newString"></param>
|
|
/// <returns></returns>
|
|
private string limitLine2show(string newString)
|
|
{
|
|
// se num righe superiore a limite trimmo...
|
|
if (newString.Split('\n').Length > parentForm.nLine2show)
|
|
{
|
|
//int idx = newString.LastIndexOf('\r');
|
|
int idx = newString.LastIndexOf(Environment.NewLine);
|
|
newString = newString.Substring(0, idx);
|
|
}
|
|
return newString;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|