Egalware/CMS-MTConn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

modificato anche siemens x gestione lettura strobe / ack degli allarmi... VALUTARE se leggere sempre tutto (misurare siemens prima di decidere...)

Browse Source
This commit is contained in:
Samuele E. Locatelli
2017-05-12 17:40:11 +02:00
parent 7c5127a0f7
commit 27ec7cdb54
1 changed files with 34 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MTC_Adapter/MTC_Adapter/AdapterSiemens.cs
+34 -106
View File
@@ -510,116 +510,44 @@ namespace MTC_Adapter
return answ;
}
/// <summary>
/// recupera allarmi ed aggiorna strobe (privato) degli allarmi
/// Scrive vettore ACK degli allarmi
/// </summary>
/// <param name="Alarm2Refresh">32bit mask degli allarmi da aggiornare</param>
/// <param name="giveAck">boolean: se si debba tornare ACK</param>
public override void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
/// <param name="retACK_DW0"></param>
/// <returns></returns>
public override bool writeAlarmAck(ref byte[] retACK_DW0)
{
// log bitmap se verboso attivo + ho allarmi da refreshare
if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose"))
{
lg.Info("Richiesto refresh allarmi x bitmask: {0}", utils.binaryForm((int)Alarm2Refresh));
}
bool ackReturned = false;
// byte di acknowledge...
byte[] retACK_DW0 = new byte[4];
// inizio impostando una bitmap x ACK che abbia i bit abbassati se lo strobe è disattivo: AND logico tra STR e ACK
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
inizio = DateTime.Now;
byte[] MemBlock;
// primo blocco memoria allarmi
int memIndex = 10532;
// controllo, SE devo leggere tutto uso un unico accesso ai 128byte, altrimenti leggo a blocchi di 32bit...
if (Alarm2Refresh == (StFlag32)unchecked((int)UInt32.MaxValue))
{
// blocco memoria x lettura dati COMPLETO (4Byte*32 = 128Byte)
MemBlock = new byte[128];
// recupero tutti i 32 bit del blocco
inizio = DateTime.Now;
SIEMENSMemRW_Byte(R, baseMemDb, memIndex, ref MemBlock);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length), DateTime.Now.Subtract(inizio).Ticks);
if (AlarmFlags != null)
{
try
{
// aggiorno vettore allarmi x intero! size del vettore di destinazione (in byte!!!!)
Buffer.BlockCopy(MemBlock, 0, AlarmFlags, 0, AlarmFlags.Length);
}
catch (Exception exc)
{
lg.Error(string.Format("Errore in BLOCKCOPY{0}{1}", Environment.NewLine, exc));
}
}
}
else
{
if (Alarm2Refresh != StFlag32.NONE)
{
// blocco memoria x lettura dati
MemBlock = new byte[4];
// verifico gli allarmi di tutti i bit alzati...
for (int i = 0; i < 32; i++)
{
if (Alarm2Refresh.HasFlag((StFlag32)Math.Pow(2, i)))
{
// recupero tutti i 32 bit del blocco
inizio = DateTime.Now;
SIEMENSMemRW_Byte(R, baseMemDb, memIndex + i * 4, ref MemBlock);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length), DateTime.Now.Subtract(inizio).Ticks);
// da testare metodo copia alternativo, condizionato a web.config
if (!utils.CRB("fastCopy"))
{
// aggiorno nel vettore allarmi i byte interessati
for (int j = 0; j < 4; j++)
{
// copy array a blocchi
AlarmFlags[i * 4 + j] = MemBlock[j];
}
}
else
{
Buffer.BlockCopy(MemBlock, 0, AlarmFlags, i, MemBlock.Length);
}
// segnalo allarme letto! memorizzo allarme nel vettore ack....
retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, true, i);
}
}
// scrivo ack se richiesto!!!
if (giveAck)
{
// mi preparo a scrivere ACK
memIndex = 10500;
// scrivo update ad ack!!!
inizio = DateTime.Now;
SIEMENSMemRW_Byte(W, baseMemDb, memIndex, ref retACK_DW0);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
ackReturned = true;
}
}
}
// SE non ho già tornato un ACK...
if (!ackReturned)
{
// se è diverso il vettori degli ACK in memoria da quello PLC...
if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0))
{
memIndex = 10500;
// invio INTERO set ACK_DW0 con bit abbassati...
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
inizio = DateTime.Now;
SIEMENSMemRW_Byte(W, baseMemDb, memIndex, ref retACK_DW0);
if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
}
}
// DB1499.DBX0.0
int memIndexAck = 0;
return SIEMENSMemRW_Byte(W, baseMemDb, memIndexAck, ref retACK_DW0);
}
/// <summary>
/// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo)
/// </summary>
/// <param name="MemBlock"></param>
/// <returns></returns>
public override bool readAllAlarms(ref uint[] MemBlock)
{
// DB1499.DBW118
int memIndex = 118;
return SIEMENSMemRW_DWord(R, baseMemDb, memIndex, ref MemBlock);
}
/// <summary>
/// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie
/// </summary>
/// <param name="MemBlock"></param>
/// <param name="blockIndex"></param>
/// <returns></returns>
public override bool readAlarmBlock(ref uint[] MemBlock, int blockIndex)
{
// DB1499.DBW118
int memIndex = 118;
return SIEMENSMemRW_DWord(R, baseMemDb, memIndex + blockIndex * 2, ref MemBlock);
}
/// <summary>
/// processing!
/// </summary>