Samuele E. Locatelli
355 lines
14 KiB
C#
355 lines
14 KiB
C#
using IOB_UT;
|
|
using MapoSDK;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace IOB_WIN
|
|
{
|
|
/// <summary>
|
|
/// Controllo Siemens specifico x impianti SAET
|
|
/// </summary>
|
|
public class IobSiemensAt2001 : IobSiemens
|
|
{
|
|
/* --------------------------------------------------------------------------------
|
|
* Controlli VIPA/SIEMENS (Interclays) di @2001
|
|
* - VIPA, COMPATIBILE SIEMENS
|
|
* - S7 vers 300
|
|
*
|
|
*
|
|
|
|
* -------------------------------------------------------------------------------- */
|
|
|
|
protected DateTime lastPLCWatchDog;
|
|
protected int counterMes2Plc = 0;
|
|
protected int counterPlc2Mes = 0;
|
|
|
|
/// <summary>
|
|
/// Classe base con i metodi x Siemens
|
|
/// </summary>
|
|
/// <param name="caller"></param>
|
|
/// <param name="adpConf"></param>
|
|
public IobSiemensAt2001(AdapterForm caller, IobConfiguration IOBConf) : base(caller, IOBConf)
|
|
{
|
|
lgInfo("NEW IOB SIEMENS versione VIPA");
|
|
lastPLCWatchDog = DateTime.Now.AddMinutes(-1);
|
|
}
|
|
|
|
#region Metodi specifici (da verificare/completare in implementazione)
|
|
|
|
/// <summary>
|
|
/// Effettua processing del recupero delle OVERRIDE (spindle, feedrate, rapid)
|
|
/// </summary>
|
|
public override void processOverride()
|
|
{
|
|
}
|
|
|
|
public override void processWhatchDog()
|
|
{
|
|
//NON SERVE!!!!
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processo i task richiesti e li elimino dalla coda 1:1
|
|
/// </summary>
|
|
/// <param name="task2exe"></param>
|
|
public override Dictionary<string, string> executeTasks(Dictionary<string, string> task2exe)
|
|
{
|
|
// Verificare il protocollo: dovrebeb togliere SOLO i task eseguiti...
|
|
Dictionary<string, string> taskDone = new Dictionary<string, string>();
|
|
bool taskOk = false;
|
|
string taskVal = "";
|
|
// inizio VUOTO
|
|
byte[] MemBlock = new byte[parametri.memSizeWrite];
|
|
|
|
// cerco task specifici: se ho startSetup --> imposto bit DBB701.DBB0.4
|
|
foreach (var item in task2exe)
|
|
{
|
|
taskOk = false;
|
|
taskVal = "";
|
|
// converto richiesta in enum...
|
|
taskType tName = taskType.nihil;
|
|
Enum.TryParse(item.Key, out tName);
|
|
// controllo sulla KEY
|
|
switch (tName)
|
|
{
|
|
case taskType.nihil:
|
|
case taskType.fixStopSetup:
|
|
case taskType.forceResetPzCount:
|
|
case taskType.forceSetPzCount:
|
|
case taskType.startSetup:
|
|
case taskType.stopSetup:
|
|
taskVal = $"taskReq: {tName} | key: {item.Key} | val: {item.Value} | SKIPPED | NO EXEC";
|
|
break;
|
|
case taskType.setArt:
|
|
case taskType.setComm:
|
|
case taskType.setProg:
|
|
// imposto i valori...
|
|
if (currProdData.ContainsKey(item.Key))
|
|
{
|
|
currProdData[item.Key] = item.Value;
|
|
}
|
|
else
|
|
{
|
|
currProdData.Add(item.Key, item.Value);
|
|
}
|
|
taskVal = item.Value;
|
|
break;
|
|
case taskType.setParameter:
|
|
// deserializzo il valore del parametro in primis
|
|
var paramData = JsonConvert.DeserializeObject<dataConf>(item.Value);
|
|
// !!!FIXME!!! fare!!!
|
|
break;
|
|
case taskType.sendWatchDogMes2Plc:
|
|
//// compogo in byte... primo bit è setup/run, ultimo è watchdog
|
|
//int valore = inSetup ? 1 : 0;
|
|
int valore = counterMes2Plc;
|
|
MemBlock[68] = (byte)valore;
|
|
taskVal = $"VALUE DB1001.68 --> {counterMes2Plc}";
|
|
break;
|
|
default:
|
|
taskVal = "SKIPPED | NO EXEC";
|
|
break;
|
|
}
|
|
|
|
// aggiungo task!
|
|
taskDone.Add(item.Key, taskVal);
|
|
}
|
|
|
|
// controllo SE HO da scrivere articolo/commessa/programma
|
|
saveStringOnMemBlock(ref MemBlock, "setArt", 0, 20, true);
|
|
saveStringOnMemBlock(ref MemBlock, "setComm", 22, 20, true);
|
|
saveStringOnMemBlock(ref MemBlock, "setProg", 44, 20, true);
|
|
|
|
|
|
|
|
// !!!FIXME!!! rendere parametrico
|
|
// SE HO un valore ART scrivo...
|
|
if (currProdData.ContainsKey("setArt"))
|
|
{
|
|
if (currProdData["setArt"] != "")
|
|
{
|
|
// imposto i valori...
|
|
upsertKey("kgParz", "1234");
|
|
saveIntOnMemBlock(ref MemBlock, "kgParz", 66);
|
|
upsertKey("set_th", "601");
|
|
saveIntOnMemBlock(ref MemBlock, "set_th", 72);
|
|
upsertKey("set_c", "101");
|
|
saveRealOnMemBlock(ref MemBlock, "set_c", 74);
|
|
upsertKey("aria_1", "1801");
|
|
saveIntOnMemBlock(ref MemBlock, "aria_1", 78);
|
|
upsertKey("aria_2", "1851");
|
|
saveIntOnMemBlock(ref MemBlock, "aria_2", 80);
|
|
upsertKey("setMmH20", "9");
|
|
saveRealOnMemBlock(ref MemBlock, "setMmH20", 82);
|
|
upsertKey("rpmci", "101");
|
|
saveIntOnMemBlock(ref MemBlock, "rpmci", 86);
|
|
}
|
|
}
|
|
|
|
// fare un controllo x forzare update...
|
|
|
|
// scrivo comunque!
|
|
taskOk = S7WriteBB(ref MemBlock);
|
|
|
|
return taskDone;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero dati dinamici in formato dictionary
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override Dictionary<string, string> getDynData()
|
|
{
|
|
Dictionary<string, string> outVal = new Dictionary<string, string>();
|
|
// controllo se eseguire versione base del getDynData
|
|
#if false
|
|
if (getOptPar("NEW_DYN_DATA") != "")
|
|
{
|
|
#endif
|
|
outVal = base.getDynData();
|
|
#if false
|
|
}
|
|
else
|
|
{
|
|
// processing SOL OSE ho in memoria abb dati...
|
|
if (RawInput.Length < parametri.memSizeRead)
|
|
{
|
|
lgError($"Impossibile processare getDynData x Siemens AT2001, vettore memoria troppo piccolo: {RawInput.Length} byte / {parametri.memSizeRead} byte presenti/richiesti)");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
// campi REAL
|
|
double T_Attuale_Cil = S7.Net.Types.Double.FromByteArray(RawInput.Skip(16).Take(4).ToArray());
|
|
int Bruc_0_100 = S7.Net.Types.Int.FromByteArray(RawInput.Skip(28).Take(2).ToArray());
|
|
int Dep_Cil_mmH2O = S7.Net.Types.Int.FromByteArray(RawInput.Skip(30).Take(2).ToArray());
|
|
int Asp_0_100 = S7.Net.Types.Int.FromByteArray(RawInput.Skip(32).Take(2).ToArray());
|
|
int Ampere_Asp = S7.Net.Types.Int.FromByteArray(RawInput.Skip(34).Take(2).ToArray());
|
|
int Temp_Filtro = S7.Net.Types.Int.FromByteArray(RawInput.Skip(36).Take(2).ToArray());
|
|
int Ampere_Cil = S7.Net.Types.Int.FromByteArray(RawInput.Skip(38).Take(2).ToArray());
|
|
int Flowrate = S7.Net.Types.Int.FromByteArray(RawInput.Skip(40).Take(2).ToArray());
|
|
int Ampere_Dosat = S7.Net.Types.Int.FromByteArray(RawInput.Skip(42).Take(2).ToArray());
|
|
int Tot_Parz_Dosatore = S7.Net.Types.DInt.FromByteArray(RawInput.Skip(48).Take(4).ToArray());
|
|
int Tot_Dosatore = S7.Net.Types.DInt.FromByteArray(RawInput.Skip(52).Take(4).ToArray());
|
|
|
|
// verifico SE devo riportare dati VC
|
|
if (utils.CRB("enableTSVC"))
|
|
{
|
|
bool[] scaduti = new bool[11];
|
|
// salvo in stack le VC rilevate
|
|
scaduti[0] = stackVal_TSVC("T_Attuale_Cil", T_Attuale_Cil);
|
|
scaduti[1] = stackVal_TSVC("Bruc_0_100", Bruc_0_100);
|
|
scaduti[2] = stackVal_TSVC("Dep_Cil_mmH2O", Dep_Cil_mmH2O);
|
|
scaduti[3] = stackVal_TSVC("Asp_0_100", Asp_0_100);
|
|
scaduti[4] = stackVal_TSVC("Ampere_Asp", Ampere_Asp);
|
|
scaduti[5] = stackVal_TSVC("Temp_Filtro", Temp_Filtro);
|
|
scaduti[6] = stackVal_TSVC("Ampere_Cil", Ampere_Cil);
|
|
scaduti[7] = stackVal_TSVC("Flowrate", Flowrate);
|
|
scaduti[8] = stackVal_TSVC("Ampere_Dosat", Ampere_Dosat);
|
|
scaduti[9] = stackVal_TSVC("Tot_Parz_Dosatore", Tot_Parz_Dosatore);
|
|
scaduti[10] = stackVal_TSVC("Tot_Dosatore", Tot_Dosatore);
|
|
|
|
// verifico SE devo riportare dati VC
|
|
if (baseUtils.CountTrue(scaduti) > 0)
|
|
{
|
|
T_Attuale_Cil = getVal_TSVC_int("T_Attuale_Cil", scaduti[0]);
|
|
Bruc_0_100 = getVal_TSVC_int("Bruc_0_100", scaduti[1]);
|
|
Dep_Cil_mmH2O = getVal_TSVC_int("Dep_Cil_mmH2O", scaduti[2]);
|
|
Asp_0_100 = getVal_TSVC_int("Asp_0_100", scaduti[3]);
|
|
Ampere_Asp = getVal_TSVC_int("Ampere_Asp", scaduti[4]);
|
|
Temp_Filtro = getVal_TSVC_int("Temp_Filtro", scaduti[5]);
|
|
Ampere_Cil = getVal_TSVC_int("Ampere_Cil", scaduti[6]);
|
|
Flowrate = getVal_TSVC_int("Flowrate", scaduti[7]);
|
|
Ampere_Dosat = getVal_TSVC_int("Ampere_Dosat", scaduti[8]);
|
|
Tot_Parz_Dosatore = getVal_TSVC_int("Tot_Parz_Dosatore", scaduti[9]);
|
|
Tot_Dosatore = getVal_TSVC_int("Tot_Dosatore", scaduti[10]);
|
|
outVal.Add("T_Attuale_Cil", $"{T_Attuale_Cil:N1}");
|
|
outVal.Add("Bruc_0_100", $"{Bruc_0_100}");
|
|
outVal.Add("Dep_Cil_mmH2O", $"{Dep_Cil_mmH2O}");
|
|
outVal.Add("Asp_0_100", $"{Asp_0_100}");
|
|
outVal.Add("Ampere_Asp", $"{Ampere_Asp}");
|
|
outVal.Add("Temp_Filtro", $"{Temp_Filtro}");
|
|
outVal.Add("Ampere_Cil", $"{Ampere_Cil}");
|
|
outVal.Add("Flowrate", $"{Flowrate}");
|
|
outVal.Add("Ampere_Dosat", $"{Ampere_Dosat}");
|
|
outVal.Add("Tot_Parz_Dosatore", $"{Tot_Parz_Dosatore}");
|
|
outVal.Add("Tot_Dosatore", $"{Tot_Dosatore}");
|
|
|
|
// salvo!
|
|
LastTSVC["T_Attuale_Cil"] = T_Attuale_Cil;
|
|
LastTSVC["Bruc_0_100"] = Bruc_0_100;
|
|
LastTSVC["Dep_Cil_mmH2O"] = Dep_Cil_mmH2O;
|
|
LastTSVC["Asp_0_100"] = Asp_0_100;
|
|
LastTSVC["Ampere_Asp"] = Ampere_Asp;
|
|
LastTSVC["Temp_Filtro"] = Temp_Filtro;
|
|
LastTSVC["Ampere_Cil"] = Ampere_Cil;
|
|
LastTSVC["Flowrate"] = Flowrate;
|
|
LastTSVC["Ampere_Dosat"] = Ampere_Dosat;
|
|
LastTSVC["Tot_Parz_Dosatore"] = Tot_Parz_Dosatore;
|
|
LastTSVC["Tot_Dosatore"] = Tot_Dosatore;
|
|
}
|
|
else
|
|
{
|
|
outVal.Add("DYNDATA", $"T_Attuale_Cil {LastTSVC["T_Attuale_Cil"]:N1} | Tot_Dosatore {LastTSVC["Tot_Dosatore"]} | Bruc_0_100 {LastTSVC["Bruc_0_100"]} | Flowrate {LastTSVC["Flowrate"]}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
outVal.Add("DYNDATA", $"T_Attuale_Cil {LastTSVC["T_Attuale_Cil"]:N1} | Tot_Dosatore {LastTSVC["Tot_Dosatore"]} | Bruc_0_100 {LastTSVC["Bruc_0_100"]} | Flowrate {LastTSVC["Flowrate"]}");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lgError(exc, "Errore in getDynData x Siemens AT2001");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return outVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua decodifica aree memoria alla bitmap usata x MAPO
|
|
/// </summary>
|
|
protected override void decodeToBaseBitmap()
|
|
{
|
|
// init a zero...
|
|
B_input = 0;
|
|
|
|
/* -----------------------------------------------------
|
|
* bitmap MAPO STANDARD
|
|
* B0: POWER_ON
|
|
* B1: RUN
|
|
* B2: pzCount
|
|
* B3: allarme
|
|
* B4: manuale
|
|
* B5: avvio/spegnimento
|
|
* B6: emergenza
|
|
*
|
|
*
|
|
* - BYTE di stato
|
|
* - +0.0 AutoStatus BYTE B#16#0 Valore 0=Fermo/1->3=Avviamento/4=Avviato/5=Pausa/6->8spegnimento/9->10 allarme
|
|
* - +1.0 Dosatore BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +2.0 V_Dosatore BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +3.0 Nas_Lancio BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +4.0 Cilindro BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +5.0 Bruciatore BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +6.0 Aspiratore BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +7.0 Nas_Raccolta BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +8.0 Nas_Brandeg BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +9.0 Coclea_Filtro BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
* - +10.0 Ciclico_Filtro BYTE B#16#0 Stato (bit0=in avviamento/1=marcia sx/2=marcia dx/3=in allarme/4=by-pass on)
|
|
----------------------------------------------------- */
|
|
|
|
|
|
// recupero byte segnali...
|
|
int byteSignals = RawInput[0];
|
|
|
|
// bit 0 (poweron) imposto a 1 SE connected...
|
|
B_input = currPLC.IsConnected ? 1 : 0;
|
|
|
|
// avviamento --> manuale
|
|
switch (byteSignals)
|
|
{
|
|
case 0:
|
|
B_input = 1;
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
B_input += (1 << 5);
|
|
break;
|
|
case 4:
|
|
B_input += (1 << 1);
|
|
break;
|
|
case 5:
|
|
B_input += (1 << 4);
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
B_input += (1 << 5);
|
|
break;
|
|
case 9:
|
|
B_input += (1 << 3);
|
|
break;
|
|
case 10:
|
|
B_input += (1 << 6);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// log opzionale!
|
|
if (verboseLog)
|
|
{
|
|
lgInfo(string.Format($"Trasformazione dati: RawInput:{RawInput[0]} --> B_input: {B_input}"));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|