From ef22d00a19b8b5152c9f52f7d7f797784041bfd1 Mon Sep 17 00:00:00 2001 From: "Samuele E. Locatelli" Date: Thu, 30 Jun 2016 12:35:15 +0200 Subject: [PATCH] git #598: decodificato vita utensili x le varie UnOp ed utensili... --- MTC_Sim/MTC_Sim/AdapterFanuc.cs | 145 ++++++++++++++++++++++++++++++-- 1 file changed, 139 insertions(+), 6 deletions(-) diff --git a/MTC_Sim/MTC_Sim/AdapterFanuc.cs b/MTC_Sim/MTC_Sim/AdapterFanuc.cs index 727ad37..36bd692 100644 --- a/MTC_Sim/MTC_Sim/AdapterFanuc.cs +++ b/MTC_Sim/MTC_Sim/AdapterFanuc.cs @@ -380,7 +380,7 @@ namespace MTC_Adapter // ora salvo valori letti... - foreach (KeyValuePair item in generalStatus) + foreach (KeyValuePair item in generalStatus) { // verifico la chiave e nel caso aggiorno... switch (item.Key) @@ -406,6 +406,10 @@ namespace MTC_Adapter case "Path_06_CurrProg": vettPath[5].mPathCurrProg.Value = item.Value; break; + // FARE gestione altri valori opzionali da file... + //case "OTHER_KEY": + // vettPath[5].mPathCurrProg.Value = item.Value; + // break; default: break; } @@ -690,9 +694,14 @@ namespace MTC_Adapter mAccTime.Value = "NA"; mAccTimeWork.Value = "NA"; - // !!!FARE!!! - togliere?!? // reload dati da file... reloadDataFromFile(); + + // area gestione dati utensili... + + int numUnOp = currAdpConf.nUnOp; + // in base al num max di UnOp recupero i dati utensile... PROCEDURA AD HOC!!! + getDatiUtCMS_Fanuc(numUnOp); } /// @@ -794,7 +803,7 @@ namespace MTC_Adapter // leggo in blocco tutte le speed da memoria... int memIndex = 3140; - // byte di acknowledge... + // buffer memoria 40 byte... byte[] unOpSpeedMem = new byte[40]; inizio = DateTime.Now; @@ -809,8 +818,7 @@ namespace MTC_Adapter if (utils.CRB("recTime")) TimingData.addResult("R-SpindleLoad", DateTime.Now.Subtract(inizio).Ticks); #endif - // FARE!! per ora solo 1 UnOp... - int numUnOp = 1; + int numUnOp = currAdpConf.nUnOp; // cicl su path for (int i = 0; i < numUnOp; i++) { @@ -826,7 +834,7 @@ namespace MTC_Adapter // leggo valore Codice SpeedRate = BitConverter.ToUInt16(unOpSpeedMem, 2 * i); vettUnOp[i].mUnOpSpeed.Value = SpeedRate; - + //vettUnOp[i].mUnOpToolId.Value = uoData.UnOpToolId; //vettUnOp[i].mUnOpNumCU.Value = uoData.UnOpNumCU; //vettUnOp[i].mUnOpStatus.Value = uoData.UnOpStatus; @@ -840,6 +848,131 @@ namespace MTC_Adapter parentForm.dataMonitor += sb.ToString(); } + + // in base al num max di UnOp recupero i dati utensile... PROCEDURA AD HOC!!! + getDatiUtCMS_Fanuc(numUnOp); + + } + /// + /// procedura di lettura (Multipla) dati da memoria x caricare dati utensile + /// + /// num max di teste da recuperare + private void getDatiUtCMS_Fanuc(int maxNumOp) + { + // variabili "Indice" utensile e famiglia da decodificare + utils + int maxMemAddr = 200; + int[] idUtMontato = new int[maxNumOp]; + int[] idFamUt = new int[maxNumOp]; + int[] idTipoVitaUt = new int[maxNumOp]; + int[] valVitaUtRes = new int[maxNumOp]; + int[] tabUt = new int[maxMemAddr]; + int[] tabFamUt = new int[maxMemAddr]; + int memIndex = 0; + byte[] int16Mem = new byte[2]; + byte[] int8Mem = new byte[1]; + + // step 1: lettura ID dell'utensile x ogni testa... + byte[] elencoUtMem = new byte[2 * maxNumOp]; + // leggo area memoria degli UT montati + memIndex = 2960; + inizio = DateTime.Now; + FANUC_ref.F_RW_Byte(R, FANUC.MemType.D, memIndex, ref elencoUtMem); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-NUMUT", elencoUtMem.Length), DateTime.Now.Subtract(inizio).Ticks); + // decodifica da byte a int16 dell'ID Utensile + for (int i = 0; i < maxNumOp; i++) + { + idUtMontato[i] = BitConverter.ToUInt16(elencoUtMem, 2 * i); + } + + // step 2a: leggo vettore memoria dei maxMemAddr(200) UT in Tabella Utensili + memIndex = 11300; + byte[] tabUt_UT = new byte[2 * maxMemAddr]; + inizio = DateTime.Now; + FANUC_ref.F_RW_Byte(R, FANUC.MemType.D, memIndex, ref tabUt_UT); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-UT", tabUt_UT.Length), DateTime.Now.Subtract(inizio).Ticks); + // decodifico TUTTI i maxMemAddr utensili + for (int i = 0; i < maxMemAddr; i++) + { + tabUt[i] = BitConverter.ToUInt16(tabUt_UT, 2 * i); + } + // step 2a: devo cercare l'UT di ogni UnOp nella Tabella Utensili + for (int i = 0; i < maxNumOp; i++) + { + // spazzo la tab Utensili x cercare quelli delle UnOp... + for (int j = 0; j < maxMemAddr; j++) + { + // controllo, se l'id utensile è quello dell'attuale UnOp... + if (tabUt_UT[j] == idUtMontato[i]) + { + // leggo FamUt puntuale.. + memIndex = 11700 + 2 * j; + inizio = DateTime.Now; + FANUC_ref.F_RW_Byte(R, FANUC.MemType.D, memIndex, ref int16Mem); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-FamUT", int16Mem.Length), DateTime.Now.Subtract(inizio).Ticks); + // step 2b: leggo puntualmente la FamUt dal suo indice... + idFamUt[i] = BitConverter.ToUInt16(int16Mem, 0); + } + } + } + + + // step 3: leggo vettore memoria dei maxMemAddr(200) FamUT in Tabella Famiglie Utensili (x ricavare unità misura vita) + memIndex = 8900; + byte[] tabFam_FamUt = new byte[2 * maxMemAddr]; + inizio = DateTime.Now; + FANUC_ref.F_RW_Byte(R, FANUC.MemType.D, memIndex, ref tabFam_FamUt); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabFamUT-FamUT", tabFam_FamUt.Length), DateTime.Now.Subtract(inizio).Ticks); + // decodifico TUTTI i maxMemAddr utensili + for (int i = 0; i < maxMemAddr; i++) + { + tabFamUt[i] = BitConverter.ToUInt16(tabFam_FamUt, 2 * i); + } + // step 3a: devo cercare la famiglia dell'UT di ogni UnOp nella Tabella Famiglie + for (int i = 0; i < maxNumOp; i++) + { + // spazzo la tab Utensili x cercare quelli delle UnOp... + for (int j = 0; j < maxMemAddr; j++) + { + // controllo, se l'id utensile è quello dell'attuale UnOp... + if (tabFamUt[j] == idFamUt[i]) + { + // leggo FamUt puntuale.. + memIndex = 10700 + 2 * j; + inizio = DateTime.Now; + FANUC_ref.F_RW_Byte(R, FANUC.MemType.D, memIndex, ref int8Mem); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-FamUT", int8Mem.Length), DateTime.Now.Subtract(inizio).Ticks); + // step 3b: leggo puntualmente il TIPO DI vita UT dal suo indice... + idTipoVitaUt[i] = Convert.ToInt16(int8Mem); + } + } + } + + // step 4: recupero la vita residua dell'utente + for (int i = 0; i < maxNumOp; i++) + { + // spazzo la tab Utensili x cercare quelli delle UnOp... + for (int j = 0; j < maxMemAddr; j++) + { + // controllo, se l'id utensile è quello dell'attuale UnOp... + if (tabUt_UT[j] == idUtMontato[i]) + { + // leggo FamUt puntuale.. + memIndex = 13100 + 2 * j; + inizio = DateTime.Now; + FANUC_ref.F_RW_Byte(R, FANUC.MemType.D, memIndex, ref int16Mem); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-VitaRes", int16Mem.Length), DateTime.Now.Subtract(inizio).Ticks); + // leggo puntualmente valore della vita ut residua da indice utensile... + valVitaUtRes[i] = BitConverter.ToUInt16(int16Mem, 0); + } + } + } + + // salvo in adapter vita UT residua... + for (int i = 0; i < maxNumOp; i++) + { + vettUnOp[i].mUnOpToolId.Value = idUtMontato[i]; + vettUnOp[i].mUnOpVitaRes.Value = valVitaUtRes[i]; + } } public override void getPath()