diff --git a/MTC_Sim/.vs/MTC_Sim/v14/.suo b/MTC_Sim/.vs/MTC_Sim/v14/.suo index 069c6d6..7ade063 100644 Binary files a/MTC_Sim/.vs/MTC_Sim/v14/.suo and b/MTC_Sim/.vs/MTC_Sim/v14/.suo differ diff --git a/MTC_Sim/MTC_Sim/AdapterFanuc.cs b/MTC_Sim/MTC_Sim/AdapterFanuc.cs index 4c66128..fce99d3 100644 --- a/MTC_Sim/MTC_Sim/AdapterFanuc.cs +++ b/MTC_Sim/MTC_Sim/AdapterFanuc.cs @@ -28,7 +28,6 @@ namespace MTC_Sim string szStatusConnection = ""; FANUC_ref.Connect(ref szStatusConnection); - } /// /// 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); + } + /// /// processing strobe! /// 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(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(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(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(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(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); + } /// /// 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(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); } /// /// processing! diff --git a/MTC_Sim/MTC_Sim/AdapterGeneric.cs b/MTC_Sim/MTC_Sim/AdapterGeneric.cs index ac22fb9..af9f649 100644 --- a/MTC_Sim/MTC_Sim/AdapterGeneric.cs +++ b/MTC_Sim/MTC_Sim/AdapterGeneric.cs @@ -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... } /// - /// recupero iniziale di TUTTI gli strobes/status attivi + /// recupero di TUTTI gli strobes/status attivi /// public virtual void getStrobeStatus() { // da gestire su ogni adapter... legge tutto array STROBE!!! } + /// + /// recupero di TUTTI gli ack attivi + /// + public virtual void getAckStatus() + { + // da gestire su ogni adapter... legge tutto array STROBE!!! + } #endregion diff --git a/MTC_Sim/MTC_Sim/utils.cs b/MTC_Sim/MTC_Sim/utils.cs index 9001086..e002f32 100644 --- a/MTC_Sim/MTC_Sim/utils.cs +++ b/MTC_Sim/MTC_Sim/utils.cs @@ -99,10 +99,48 @@ namespace MTC_Sim { } return answ; } + /// + /// imposta un bita al valore richiesto duplicando il valore IN come OUT + /// + /// valore originale da aggiornare + /// valore richiesto x il bit (0/1) + /// indice bit, 0 based (es: 0..31 per 32bit) + /// + 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; } - + /// /// Vettore completo posizione (X-Y-Z con versori i-j-k) ///