From 600d86e2fbc93ffe7816c172acb88b1254a05be2 Mon Sep 17 00:00:00 2001 From: "Samuele E. Locatelli" Date: Mon, 9 May 2016 16:31:49 +0200 Subject: [PATCH] Fatto completamento gestione strobe, status ed allarmi... da verificare in CMS... --- MTC_Sim/.vs/MTC_Sim/v14/.suo | Bin 165888 -> 165376 bytes MTC_Sim/MTC_Sim/AdapterFanuc.cs | 165 +++++++++++++++++++++++++++++- MTC_Sim/MTC_Sim/AdapterGeneric.cs | 12 ++- MTC_Sim/MTC_Sim/utils.cs | 46 ++++++++- 4 files changed, 213 insertions(+), 10 deletions(-) diff --git a/MTC_Sim/.vs/MTC_Sim/v14/.suo b/MTC_Sim/.vs/MTC_Sim/v14/.suo index 069c6d639d8c85b3e4ec28b7f2f9e1573d0555b4..7ade063389bab0864fdecc9844999e4dafa2f5b3 100644 GIT binary patch delta 2524 zcmeHHdu)?c6z@6x+O^%7dvs7>Q#SU%(T%ZJM`5lj$au5GIe`$|fC*a)bZi48Q<^a# z=;9uC*;!P;Ofq9bWNXbnVh}12AB5;Mf{K;N;vZmex~N1Y0ngVCLPivc{~2%c`+Cp0 z=lt$H_jhhxtp-=Kq1S<$;z{#7H$@HZh6&|{xngiZU&tIX|i6=u4qQ8 zNRm<@L@bqFfj7ieX)@$`HJS~e$#CRty(Mb2_i}`Ez<8n8JrWbg`RR;M##F{F9zTkF z9dn44{9PdGb?Y<+UinFUqf3DVq0!IK|H1Zh##L{={socJ zkSgc2IgfWI8rmbyjNOIFGU_ytfWLp{dfQHJzPyS-q zPSGWhCVbmX)K~%2WY>9cX?s?|B*T^XU`K_jl2H9$AX@Uj)JE6ru zQ^GNXTGYzt1x|l;59~pu8bH-EPtHi&aIwlpoPHj(^5y+7f>ckiBAC^?A9Pelu<|am z<3*So)5UcJM}n`1CyMs-XygVQ3`V}D#m8yHg)2m{B_y<{a&zU@s&(n>YOC%zp@@!# zV7Z*z0hLm`qLR{k3Z^%l8XofJKfAJYu>EECz-L`a8*S&PWFH)$r{hpZtG96#A`+uR z17!O8x++I4bC(B9C1!DA5%UB`j&C1Nw2TOb!q26v;==p-Xr>-b{qKMW$h{DA#MikK zh3BkIwsnIqvfmE}k(ftciSPw$9A}qkJR-N}+QQ zV(G92J@Utim_5iKy zo{bFv=O{7@y|nr&!&a?Zyug>Pv%pDdm}orkA|%Nb5(+tDrY9XSH8T^?9~89+xD zVg~gt#t6!<#q9n?=mM&#MH_SqFz=$iS}dTSm*8&U$UGz}Dh|<>C1?@Nxs&9!M%)54 zkc8=ftyC7pNAr8MSt0`|CCl(A$gOEu3jeF;pa)a0=t0#h=y9SXY-ZbiRTRDo+ZbX0 OQC`pUyum%W>OTP<$Ue&e delta 3215 zcmeHJYfw{H5Wc%fAOso%1x!USDhOhL$SZ(?2_RTo5Q|mBR-uRp5*`B92M(#PKE?-d zl;eyqqz;ZuTOpxbr(>O9ZKrk^bXsexMx(!GhI1$8?7=r1?3H+wdF zcK7V=cXO;;Rn|sTXE`bgGNInd3euSe^_sIV)Y1!@=jrS^ZLO-QO3rpqNQjFAL5L?#Bu*gK()J|!zDucjlblSl ziFn36-DuK9v1)T#Q`NDyU{#wh+6=V{7;UeMlPRz-)V?-p3p8tLaTKssn(Uz|d4VnE z5GrEG%VBoJWQ0rXd(#5N8CqW;uc7LTBuTL)ng;BN!>`stzqn}?#LCn~mYOA& z!lLD+6~#5B7GAj-rbsrUde*`Y6>r!F-s0&y@P-U7N>27Y%HFp=qjIH%Y6B>=Hy&G8 zmc7FCP)M0lNar{2z&TO=HUuCae*p4Wj?vvCqp+f`D6*)gWKboSRD56?WIB6A$xGzO zr-zlF*#m9-><)0}KW&AX9GW3-aH)dQAqp+%XX?;V>1N!2T>thG}$2`Lux_#gDR$S3P43#k^;YhX(K$s5-$C9hdH?`rdv!#(Du zy*1YsRc3D5)wRsj=j^h$p1}cSdmH%hgKxsi&N1Mp*Fc!qu^0T&RqFM1poD@4va{lO zS15psd>x*2eCds)A(nzml?haLbqNxZU8HkpNK2DC%qT7*Hrf~$VUA5pj7T+`+YNv{ ztzZKlI2*IukArq75ZrpYVL$SdMy%joAAv@a%J@4X`0`UBxUBse_(Bwv!KX&TTvoMu z0@q!E>2z7?9h=;efRor#{REa_NaER-VKHps<3%VHKMTg?z&j_QR>H;x2`c40HWYV5 z=Y2m(?8QJe`@F%Q>%;LFcj&>5AMYl=ITq;-;eWUO^`LB+} z75r8t>Udii+IT@EhQV5ARDRxo{!+X$KF@$!_?F-7h9j(FUnJMXpc|Z*)?GX(8pH4J zm_LV;|Az?_{`z_L^8VFtH=!WaXITup;A@FV!3FWffImtoAI1@ z&V;SNtW|10e+70hYy53~p%vnI=t?}_lYv%X)zM>kYdW1Fq6Rh4!a(1^lWQoUhFQ3g z6&BXB@@O@GX&V^X*7z~v+-y7w&sl^jAx1FLbuE^zgiD1|VHte{A(|hI!4IGI`+w~> yr+#O*SE0Pcgy)8}J#FM|A1BgaM1g2(KnGolc0xWcdmfEq(*~@RJ-nWcmGBR_AQI;Q 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) ///