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

Fatto completamento gestione strobe, status ed allarmi... da verificare in CMS...

Browse Source
This commit is contained in:
Samuele E. Locatelli
2016-05-09 16:31:49 +02:00
parent 424a39f76d
commit 600d86e2fb
4 changed files with 213 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MTC_Sim/.vs/MTC_Sim/v14/.suo
BIN
View File
Binary file not shown.
MTC_Sim/MTC_Sim/AdapterFanuc.cs
+161 -4
View File
@@ -28,7 +28,6 @@ namespace MTC_Sim
string szStatusConnection = "";
FANUC_ref.Connect(ref szStatusConnection);
}
/// <summary>
/// Effettuo lettura dei 16 byte di strobe/status
@@ -43,11 +42,141 @@ namespace MTC_Sim
// hard coded: leggo le 16 word standard dello strobe... R10516--> R10532
FANUC_ref.F_RW_Byte(R, FANUC.MemType.R, 10516, ref Strobes);
}
public override void getAckStatus()
{
base.getAckStatus();
// se non sono connesso esco
if (!FANUC_ref.Connected) return;
// hard coded: leggo le 16 word standard dello strobe... R10500--> R10515
FANUC_ref.F_RW_Byte(R, FANUC.MemType.R, 10500, ref Acknowl);
}
/// <summary>
/// processing strobe!
/// </summary>
public override void processStrobe()
{
base.processStrobe();
// se non sono connesso esco
if (!FANUC_ref.Connected) return;
// verifico i vari strobe x recuperare i dati... PER ORA SOLO DW1 per path1 (indice 0)...
int idxPath = 0;
int memIndex = 0;
int bitNum = 0;
// byte di acknowledge...
byte[] retACK_DW1 = new byte[4];
// controllo TUTTI i flag: se ce ne sono di alzati DEVO processare...
if (STRB_DW1 != StFlag32.NONE)
{
int numEv = 0;
int codEv = 0;
// blocco memoria x lettura dati (qui max 2*16bit...)
byte[] MemBlock = new byte[4];
// 2016.05.09 ci sono solo 4 bit x ora da controllare...
// check COD_M
bitNum = 0;
if (STRB_DW1.getBit<StFlag32>(bitNum))
{
memIndex = 10660;
// recupero tutti i 16+16 bit del blocco
FANUC_ref.F_RW_Byte(R, FANUC.MemType.R, memIndex, ref MemBlock);
// verifico sia > 0 il numero di valori da leggere...
numEv = BitConverter.ToUInt16(MemBlock, 0);
if (numEv > 0)
{
// leggo valore Codice M
codEv = BitConverter.ToUInt16(MemBlock, 2);
// salvo evento Codice M
vettPath[idxPath].mPathCodM.Value = string.Format("M{0:###}", codEv); // VERIFICARE num cod M... 3 cifre?
}
// memorizzo allarme nel vettore ack....
retACK_DW1 = utils.setBitOnStFlag(retACK_DW1, 1, bitNum);
}
// check COD_S
bitNum = 1;
if (STRB_DW1.getBit<StFlag32>(1))
{
memIndex = 10682;
// recupero tutti i 16+16 bit del blocco
FANUC_ref.F_RW_Byte(R, FANUC.MemType.R, memIndex, ref MemBlock);
// verifico sia > 0 il numero di valori da leggere...
numEv = BitConverter.ToUInt16(MemBlock, 0);
if (numEv > 0)
{
// leggo valore Codice S
codEv = BitConverter.ToUInt16(MemBlock, 2);
// salvo evento Codice S
vettPath[idxPath].mPathCodS.Value = string.Format("S{0:###}", codEv); // VERIFICARE num cod S... 3 cifre?
}
// memorizzo allarme nel vettore ack....
retACK_DW1 = utils.setBitOnStFlag(retACK_DW1, 1, bitNum);
}
// check COD_T
bitNum = 2;
if (STRB_DW1.getBit<StFlag32>(2))
{
memIndex = 10694;
// recupero tutti i 16+16 bit del blocco
FANUC_ref.F_RW_Byte(R, FANUC.MemType.R, memIndex, ref MemBlock);
// verifico sia > 0 il numero di valori da leggere...
numEv = BitConverter.ToUInt16(MemBlock, 0);
if (numEv > 0)
{
// leggo valore Codice T
codEv = BitConverter.ToUInt16(MemBlock, 2);
// salvo evento Codice T
vettPath[idxPath].mPathCodT.Value = string.Format("T{0:###}", codEv); // VERIFICARE num cod T... 3 cifre?
}
// memorizzo allarme nel vettore ack....
retACK_DW1 = utils.setBitOnStFlag(retACK_DW1, 1, bitNum);
}
// check assi assegnati al path 01...
bitNum = 3;
if (STRB_DW1.getBit<StFlag32>(3))
{
// mi basta un solo byte...
MemBlock = new byte[1];
memIndex = 10706;
string AssiAttivi = "";
StFlag8 StrobeBlock = 0;
// recupero tutti gli 8 bit del blocco
FANUC_ref.F_RW_Byte(R, FANUC.MemType.R, memIndex, ref MemBlock);
StrobeBlock = (StFlag8)BitConverter.ToUInt16(MemBlock, 0);
// spazzo i bit, dove è 1 metto nella stringa degli assi attivi...
for (int i = 0; i < 8; i++)
{
if (StrobeBlock.getBit<StFlag8>(i))
{
AssiAttivi += string.Format(" {0}", i);
}
}
// salvo evento Assi attivi
vettPath[idxPath].mPathActiveAxes.Value = AssiAttivi;
// memorizzo allarme nel vettore ack....
retACK_DW1 = utils.setBitOnStFlag(retACK_DW1, 1, bitNum);
}
}
else
{
// se mi sono rimasti degli strobe di lettura allarmi alzati li abbasso
if (ACK_DW1 != StFlag32.NONE)
{
// inizializzo 4 byte a zero!!!
retACK_DW1 = new byte[4];
}
}
memIndex = 10504;
// scrivo update ad ack!!!
FANUC_ref.F_RW_Byte(W, FANUC.MemType.R, memIndex, ref retACK_DW1);
}
/// <summary>
/// processing strobe degli allarmi
@@ -55,6 +184,13 @@ namespace MTC_Sim
public override void processAlarm()
{
base.processAlarm();
// se non sono connesso esco
if (!FANUC_ref.Connected) return;
// procedo!
int memIndex = 0;
// byte di acknowledge...
byte[] retACK_DW0 = new byte[4];
// controllo TUTTI i flag: se ce ne sono di alzati DEVO processare...
if (STRB_DW0 != StFlag32.NONE)
{
@@ -63,7 +199,7 @@ namespace MTC_Sim
StFlag32 AlarmBlock = 0;
allarme currAllarm;
// primo blocco memoria allarmi
int memIndex = 10532;
memIndex = 10532;
// verifico gli allarmi di tutti i bit alzati...
for (int i = 0; i < 32; i++)
{
@@ -79,9 +215,9 @@ namespace MTC_Sim
if (AlarmBlock.getBit<StFlag32>(j))
{
// recupero allarme da oggetto in memoria...
currAllarm= elencoAllarmi[i * 32 + j];
currAllarm = elencoAllarmi[i * 32 + j];
// in base al gruppo decido dove assegnare come CONDITION...
switch(currAllarm.gruppo)
switch (currAllarm.gruppo)
{
case "PLC":
mAlarmPLC.Add(MTConnect.Condition.Level.FAULT, currAllarm.descrizione, currAllarm.codNum, "", "");
@@ -93,9 +229,30 @@ namespace MTC_Sim
}
}
}
// memorizzo allarme nel vettore ack....
retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, 1, i);
}
#if false
else
{
// abbasso eventuali flag di ack se non ne ho + dall'altro caso...
retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, 0, i);
}
#endif
}
}
else
{
// se mi sono rimasti degli strobe di lettura allarmi alzati li abbasso
if (ACK_DW0 != StFlag32.NONE)
{
// inizializzo 4 byte a zero!!!
retACK_DW0 = new byte[4];
}
}
memIndex = 10500;
// scrivo update ad ack!!!
FANUC_ref.F_RW_Byte(W, FANUC.MemType.R, memIndex, ref retACK_DW0);
}
/// <summary>
/// processing!
MTC_Sim/MTC_Sim/AdapterGeneric.cs
+10 -2
View File
@@ -921,8 +921,9 @@ namespace MTC_Sim
// avvio fase raccolta dati
mAdapter.Begin();
// parte che eseguo SEMPRE: RECUPERO stato di tutti gli strobe/status
// parte che eseguo SEMPRE: RECUPERO stato di tutti gli strobe/status e degli ack attualmente noti
getStrobeStatus();
getAckStatus();
// acquisizione degli status
processStatus();
@@ -1026,12 +1027,19 @@ namespace MTC_Sim
// da gestire su ogni adapter...
}
/// <summary>
/// recupero iniziale di TUTTI gli strobes/status attivi
/// recupero di TUTTI gli strobes/status attivi
/// </summary>
public virtual void getStrobeStatus()
{
// da gestire su ogni adapter... legge tutto array STROBE!!!
}
/// <summary>
/// recupero di TUTTI gli ack attivi
/// </summary>
public virtual void getAckStatus()
{
// da gestire su ogni adapter... legge tutto array STROBE!!!
}
#endregion
MTC_Sim/MTC_Sim/utils.cs
+42 -4
View File
@@ -99,10 +99,48 @@ namespace MTC_Sim
{ }
return answ;
}
/// <summary>
/// imposta un bita al valore richiesto duplicando il valore IN come OUT
/// </summary>
/// <param name="original">valore originale da aggiornare</param>
/// <param name="bitVal">valore richiesto x il bit (0/1)</param>
/// <param name="bitIndex">indice bit, 0 based (es: 0..31 per 32bit)</param>
/// <returns></returns>
public static byte[] setBitOnStFlag(byte[] original, int bitVal, int bitIndex)
{
// risposta è identica ad originale...
byte[] answ = original;
// verifico se il bit è 0/1
if (bitVal <= 1 && bitVal >= 0)
{
// verifico se si possa aggiornare il bit richiesto (<= al totale dei bit...)
if (bitIndex <= original.Length * 8 - 1)
{
// calcolo byte
int byteIndex = bitIndex / 8;
// bit nel byte
int bitInByteIndex = bitIndex % 8;
// bit richiesto
byte mask = (byte)(bitVal << bitInByteIndex);
// imposto!
answ[byteIndex] |= mask;
#if false
byte mask = (byte)(1 << bitInByteIndex);
bool isSet = (bytes[byteIndex] & mask) != 0;
// set to 1
bytes[byteIndex] |= mask;
// Set to zero
bytes[byteIndex] &= ~mask;
// Toggle
bytes[byteIndex] ^= mask;
#endif
}
}
return answ;
}
}
public enum tipoAdapter
{
@@ -178,7 +216,7 @@ namespace MTC_Sim
public string MessageText;
}
public struct PathData
{
public int PathSel;
@@ -227,7 +265,7 @@ namespace MTC_Sim
public string AxisAccTime;
public string AxisBattery;
}
/// <summary>
/// Vettore completo posizione (X-Y-Z con versori i-j-k)
/// </summary>