From 51d39e743de4ea3bbe47d1b9a80caf477e519d4e Mon Sep 17 00:00:00 2001 From: "Samuele E. Locatelli" Date: Mon, 26 Nov 2018 17:27:01 +0100 Subject: [PATCH] Inizio pulizia codice kawasaki + "appunti OSAI" --- IOB-WIN/IobKawasaki.cs | 1482 ++++++++++++++-------------------------- 1 file changed, 525 insertions(+), 957 deletions(-) diff --git a/IOB-WIN/IobKawasaki.cs b/IOB-WIN/IobKawasaki.cs index c8174ef4..56621c66 100644 --- a/IOB-WIN/IobKawasaki.cs +++ b/IOB-WIN/IobKawasaki.cs @@ -23,58 +23,6 @@ namespace IOB_WIN /// protected string comando; - -#if false - /// - /// wrapper chiamata lettura/scrittura SINGOLO BYTE... - /// - /// - /// - /// - /// - /// - public bool FanucMemRW(bool bWrite, FANUC.MemType MemType, Int32 memIndex, ref byte Value) - { - bool answ = false; - if (FANUC_ref.Connected) - { - try - { - parentForm.commPlcActive = true; - answ = FANUC_ref.F_RW_Byte(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - parentForm.commPlcActive = false; - return answ; - } - /// - /// wrapper chiamata lettura/scrittura MULTI BYTE... - /// - /// - /// - /// - /// - /// - public bool FanucMemRW(bool bWrite, FANUC.MemType MemType, Int32 memIndex, ref byte[] Value) - { - bool answ = false; - if (FANUC_ref.Connected) - { - try - { - parentForm.commPlcActive = true; - answ = FANUC_ref.F_RW_Byte(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - parentForm.commPlcActive = false; - return answ; - } -#endif - /// /// estende l'init della classe base... /// @@ -279,6 +227,521 @@ namespace IOB_WIN #endif } +#if false + /// + /// Override disconnessione + /// + public override void tryDisconnect() + { + if (connectionOk) + { + string szStatusConnection = ""; + try + { + OSAI_ref.CloseSession(); + connectionOk = false; + // resetto timing! + TimingData.resetData(); + lgInfo(szStatusConnection); + lgInfo("Effettuata disconnessione adapter OSAI!"); + } + catch (Exception exc) + { + lgFatal(exc, "Errore nella disconnessione dall'adapter OSAI"); + } + } + else + { + lgError("IMPOSSIBILE effettuare disconnessione: Connessione non disponibile..."); + } + } + /// + /// Override connessione + /// + public override void tryConnect() + { + if (!connectionOk) + { + // controllo che il ping sia stato tentato almeno pingTestSec fa... + if (DateTime.Now.Subtract(lastPING).TotalSeconds > utils.CRI("pingTestSec")) + { + if (verboseLog || periodicLog) + { + lgInfo("ConnKO - tryConnect"); + } + // PING SOLO x OPEN!!! + bool needPing = (currIobConf.tipoIob == tipoAdapter.OSAI_OPEN); + bool pingOk = false; + Ping pingSender = new Ping(); + PingReply reply = pingSender.Send("127.0.0.1", 100); + // se serve PING... + if (needPing) + { + // in primis salvo data ping... + lastPING = DateTime.Now; + // ora PING!!! + IPAddress address = IPAddress.Loopback; + IPAddress.TryParse(currIobConf.cncIpAddr, out address); + reply = pingSender.Send(address, 100); + pingOk = reply.Status == IPStatus.Success; + } + // se passa il ping faccio il resto... + if (pingOk || !needPing) + { + string szStatusConnection = ""; + try + { + // ora provo connessione... + parentForm.commPlcActive = true; + bool fatto = OSAI_ref.OpenSession(); + if (!fatto) + { + // log errore! + lgInfo("Impossibile effettuare apertura sessione: " + OSAI_ref.ErrMsg); + } + parentForm.commPlcActive = false; + lgInfo("szStatusConnection: " + szStatusConnection); + connectionOk = true; + // refresh stato allarmi!!! + if (connectionOk) + { + dtAvvioAdp = DateTime.Now; + if (adpRunning) + { + // carico status allarmi (completo) + lgInfo("Inizio refresh completo stato allarmi..."); + forceAlarmCheck(); + lgInfo("Completato refresh completo stato allarmi!"); + } + else + { + lgInfo("Connessione OK"); + } + } + else + { + lgError("Impossibile procedere, connessione mancante..."); + } + } + catch (Exception exc) + { + lgFatal(string.Format("Errore nella connessione all'adapter OSAI: {0}{1}{2}", szStatusConnection, Environment.NewLine, exc)); + connectionOk = false; + lgInfo(string.Format("Eccezione in TryConnect, Adapter NON running, pausa di {0} msec prima di ulteriori tentativi di riconnessione", utils.CRI("waitRecMSec"))); + } + } + else + { + // loggo no risposta ping ... + connectionOk = false; + if (needPing) + { + if (verboseLog || periodicLog) + { + lgInfo(string.Format("Attenzione: controllo PING fallito per IP {0} - {1}", currIobConf.cncIpAddr, reply.Status)); + } + } + } + } + } + // se non è ancora connesso faccio procesisng memoria caso disconnesso... + if (!connectionOk) + { + // processo semafori ed invio... + processMemoryDiscon(); + } + } + /// + /// lettura principale (bit semafori) + /// + public override void readSemafori() + { + base.readSemafori(); + try + { + if (verboseLog) + { + lgInfo("inizio read semafori"); + } + + parentForm.sIN = Semaforo.SV; + + stopwatch.Restart(); + // possiamo leggere tutto da qui che contiene tutto: status, mode, last_nc_error + var ncInfo = OSAI_ref.NcInfo1(ref oData); + // time rec + if (utils.CRB("recTime")) + { + TimingData.addResult(currIobConf.codIOB, "GETINFO1DATA", stopwatch.ElapsedTicks); + } + stopwatch.Stop(); + + // salvo il solo BYTE dell'input decifrando il semaforo... + decodeToBitmap(); + } + catch (Exception exc) + { + lgError(string.Format("Eccezione in readSemafori:{0}{1}", Environment.NewLine, exc)); + connectionOk = false; + } + } + /// + /// Effettua decodifica aree memoria alla bitmap usata x MAPO + /// + private void decodeToBitmap() + { + // init a zero... + B_input = 0; + // SE SI E' CONNESSO al CNC allora è 1=powerON... + if (OSAI_ref.Connected) + { + B_input += 1 << 0; + } + + // decodifico impiegando dictionary... cercando il TIPO di memoria & co... + string bKey = ""; + string bVal = ""; + for (int i = 0; i < 8; i++) + { + bKey = string.Format("BIT{0}", i); + // cerco se ci sia in LUT + if (signLUT.ContainsKey(bKey)) + { + // recupero nome variabile... + bVal = signLUT[bKey]; + // se l'area è PZCOUNT... processo PUNTUALMENTE il CONTAPEZZI... + if (bVal.StartsWith("PZCOUNT")) + { + string currODL = ""; + try + { + currODL = utils.callUrl(urlGetCurrODL); + if (utils.CRB("verbose")) + { + lgInfo(string.Format("Lettura ODL, {0} --> {1}", currIdxODL, currODL)); + } + // provo a salvare nuovo ODL + int.TryParse(currODL, out currIdxODL); + } + catch (Exception exc) + { + if (DateTime.Now.Subtract(lastWarnODL).TotalSeconds > 15) + { + lgError(exc, "Errore in fase di chiamata URL x ODL corrente | URL chiamato: {0}", urlGetCurrODL); + lastWarnODL = DateTime.Now; + } + } + if (currODL != null && currODL != "" && currODL != "0") + { + // controllo se è passato intervallo minimo tra 2 controlli/elaborazioni x distanziare invio e ridurre letture + if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay)) + { + // verifico se variato contapezzi in area STD PAR6711... e se passato ritardo minimo... + if (lastCountCNC > contapezzi) + { + // salvo nuovo contapezzi (incremento di 1...) + contapezzi++; + // salvo in semaforo! + B_input += 1 << 2; + } + // registro contapezzi + lgInfo(string.Format("Contapezzi OSAI: {0} | Contapezzi interno {1}", lastCountCNC, contapezzi)); + + // invio a server contapezzi (aggiornato) + string retVal = utils.callUrl(urlSetPzCount + contapezzi.ToString()); + // verifica se tutto OK + if (retVal != "OK") + { + // errore salvataggio contapezzi + lgInfo(string.Format("Errore salvataggio Contapezzi OSAI: {0} | Contapezzi interno {1} | Errore salvataggio: {2}", lastCountCNC, contapezzi, retVal)); + } + // resetto timer... + lastPzCountSend = DateTime.Now; + } + } + else + { + if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay)) + { + lgInfo(string.Format("Attenzione: mancanza ODL non procedo con gestione contapezzi. Contapezzi OSAI: {0} | Contapezzi interno {1}", lastCountCNC, contapezzi)); + // resetto timer... + lastPzCountSend = DateTime.Now; + } + } + } + // controllo le condizioni x costruire il bit1 RUN! + if (oData.mode_select == 2 && oData.status == 2) + { + B_input += 1 << 1; + } + // errore su bit3 + if (oData.mode_select == 6) + { + B_input += 1 << 3; + } + // auto su bit4 + if (oData.mode_select != 2) + { + B_input += 1 << 4; + } + // emergenza su bit5 + if (oData.mode_select == 9) + { + B_input += 1 << 5; + } + } + } + // log opzionale! + if (verboseLog) + { + lgInfo(string.Format("Trasformazione B_input: {0}", B_input)); + } + } + /// + /// Recupero programma in lavorazione + /// + /// + public override string getPrgName() + { + string prgName = ""; + // recupero NUOVO prgName... + try + { + // recupero nome programma MAIN + prgName = System.Text.Encoding.Default.GetString(oData.main_progr_name); + // trimmo path del programma, ovvero "CNCMEMUSERPATH1" + prgName = prgName.Replace(utils.CRS("basePrgMemPath"), ""); + lgInfo("Current PROG: {0}", prgName); + } + catch (Exception exc) + { + lgError(string.Format("Eccezione in recupero PRG NAME MAIN:{0}{1}", Environment.NewLine, exc)); + connectionOk = false; + } + return prgName; + } + /// + /// Effettua vero processing contapezzi appoggiato ad area specifica da CONF + /// + public override void processContapezzi() + { + if (utils.CRB("enableContapezzi")) + { + try + { + // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area) + if (currIobConf.optPar.Count > 0 && currIobConf.optPar["PZCOUNT_MODE"] != "") + { + string memAddr = currIobConf.optPar["PZCOUNT_MODE"]; + if (memAddr.StartsWith("STD")) + { + // inizio verifica area memoria/parametro levando prima parte codice + memAddr = memAddr.Replace("STD.", ""); + // var di appoggio + int cntAddr = 0; + // verifico se si tratta di lettura MEMORIA... formato tipo STD.MEM.6711 + if (memAddr.StartsWith("MEM.")) + { + // recupero parametro... + int.TryParse(memAddr.Replace("MEM.", ""), out cntAddr); + if (cntAddr == 0) + { + cntAddr = 29; + } + // processo parametro contapezzi (lavorati) + stopwatch.Restart(); + // vera lettura area memoria... + int resVal = 0; + // lettura variabili (es contapezzi) + resVal = (int)OSAI_ref.ReadVarSN((short)cntAddr); + + if (utils.CRB("recTime")) + { + TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-MEM", 2), stopwatch.ElapsedTicks); + } + // aggiungo in visualizzazione SE variata... + if (resVal != lastCountCNC) + { + string mCount = string.Format("MEM{0}", cntAddr); + string sVal = string.Format("[PZCOUNT]{0}|{1}", mCount, resVal); + // chiamo accodamento... + accodaFLog(sVal, qEncodeFLog(mCount, resVal.ToString())); + } + // salvo ultimo conteggio rilevato + lastCountCNC = resVal; + } + stopwatch.Stop(); + } + } + } + catch (Exception exc) + { + lgError(exc, "Errore in contapezzi CNC"); + connectionOk = false; + } + } + } + /// + /// Esegue processing MODE (e nel contempo recupera altri dati dell'area G) + /// + public override void processMode() + { + if (utils.CRB("enableMode")) + { + try + { + // verifico modo con valore corrente, se cambia aggiorno... + CNC_MODE newMode = decodeModeOsai(oData.mode_select); + if (newMode != currMode) + { + // aggiorno! + currMode = newMode; + // conversione NUM MODE in descrizione da ENUM + string descrMode = Enum.GetName(typeof(CNC_MODE), currMode); + // accodo x invio + string sVal = string.Format("[CNC_MODE]{0}", descrMode); + // chiamo accodamento... + accodaFLog(sVal, qEncodeFLog("CNC_MODE", descrMode)); + } + } + catch (Exception exc) + { + lgError(exc, string.Format("Errore in process Mode OSAI: {0}{1}", Environment.NewLine, exc)); + connectionOk = false; + stopwatch.Stop(); + } + } + // lo status lo processo SEMPRE + try + { + // verifico modo con valore corrente, se cambia aggiorno... + CNC_STATUS_OSAI newStatus = (CNC_STATUS_OSAI)(oData.status); + if (newStatus != currStatus) + { + // aggiorno! + currStatus = newStatus; + // accodo x invio + string sVal = string.Format("[CNC_STATUS]{0}", currStatus.ToString()); + // chiamo accodamento... + accodaFLog(sVal, qEncodeFLog("CNC_STATUS", currStatus.ToString())); + } + } + catch (Exception exc) + { + lgError(exc, string.Format("Errore in process Mode OSAI: {0}{1}", Environment.NewLine, exc)); + connectionOk = false; + stopwatch.Stop(); + } + } + /// + /// Decodifica del MODE selezionato + /// + /// + /// + protected CNC_MODE decodeModeOsai(int mode) + { + CNC_MODE answ = CNC_MODE.ND; + switch (mode) + { + case 1: + answ = CNC_MODE.MDI; + break; + case 2: + answ = CNC_MODE.AUTO; + break; + case 3: + answ = CNC_MODE.SEMI; + break; + case 4: + answ = CNC_MODE.JOG_MAN; + break; + case 5: + answ = CNC_MODE.JOG_INC; + break; + case 6: + answ = CNC_MODE.PROFILE; + break; + case 7: + answ = CNC_MODE.HOME; + break; + case 8: + answ = CNC_MODE.HANDLE_INC; + break; + default: + break; + } + return answ; + } + /// + /// Recupero dati dinamici... + /// + public override Dictionary getDynData() + { + Dictionary outVal = new Dictionary(); + stopwatch.Restart(); + try + { + string actf = oData.real_feed.ToString(); + string acts = oData.real_speed.ToString(); + outVal.Add("DYNDATA", string.Format("FEED {0}#SPEED_RPM {1}", actf, acts)); + + if (utils.CRB("SendFeedSpeed")) + { + outVal.Add("FEED", actf); + outVal.Add("SPEED_RPM", acts); + //outVal.Add("NUM_ALARM", numAlarm); + outVal.Add("ACT_TOOL", oData.actual_tool.ToString()); + } + if (utils.CRB("SendAxPos")) + { + // salvo info assi... + outVal.Add("AX_SEL", oData.ax_sel.ToString()); + outVal.Add("NUM_AX_SEL", oData.num_ax_sel.ToString()); + } + } + catch (Exception exc) + { + lgError(exc, "Errore in getDynData"); + } + stopwatch.Stop(); + return outVal; + } + /// + /// Recupero dati override (da area G che è già stata letta...) + /// + /// + public override Dictionary getOverrides() + { + Dictionary outVal = new Dictionary(); + outVal.Add("FEED_OVER", (oData.feed_ov).ToString()); + outVal.Add("RAPID_OVER", (oData.rapid_override).ToString()); + return outVal; + } + /// + /// Recupera e processa allarmi CNC... + /// + public override Dictionary getCncAlarms() + { + Dictionary outVal = new Dictionary(); + // se ho allarmi li accodo... + if (oData.last_nc_error != 0) + { + try + { + outVal.Add("CNC_ALARM", (oData.last_nc_error).ToString()); + } + catch (Exception exc) + { + lg.Error(exc, "Eccezione in getCncAlarms"); + } + } + return outVal; + } +#endif + + /// + /// Oggetto per lettura/scrittura counter pezzi robot + /// private int pzCounter { get @@ -300,7 +763,6 @@ namespace IOB_WIN resDataArray = KAWASAKI_ref.command(comando, 3000); // imposto cicli depositati/fatti a 3 --> " 0\r\n" } } - } /// @@ -340,7 +802,6 @@ namespace IOB_WIN } } } - /// /// Effettua invio del programma di alvorazione al ROBOT /// Dir di riferimento @@ -356,913 +817,20 @@ namespace IOB_WIN // carico... KAWASAKI_ref.asInquiry = delegate (string as_msg) { - Console.WriteLine(as_msg); if (as_msg.StartsWith("Are you sure ?")) return "0\n"; // 0 [RET] - if (as_msg.StartsWith("Load data?")) return "1\n"; // 1 [RET] + Console.WriteLine(as_msg); if (as_msg.StartsWith("Are you sure ?")) + { + return "0\n"; // 0 [RET] + } + + if (as_msg.StartsWith("Load data?")) + { + return "1\n"; // 1 [RET] + } + return null; }; int retLoad = KAWASAKI_ref.load(prgPath, "/Q"); // LOAD/Q default.as[RET] } } - - -#if false - /// - /// Area memoria G (copia) - /// - protected byte[] MemBlockG = new byte[2]; - /// - /// Area memoria R (copia) - /// - protected byte[] MemBlockR = new byte[2]; - /// - /// Area memoria X (copia) - /// - protected byte[] MemBlockX = new byte[2]; - /// - /// Area memoria Y (copia) - /// - protected byte[] MemBlockY = new byte[2]; - - /// - /// Oggetto MAIN x connessione FANUC - /// - protected FANUC FANUC_ref; - - /// - /// Dati dell'area D - /// - protected memAreaFanuc areaD; - /// - /// Dati dell'area PARameters - /// - protected memAreaFanuc areaPAR; - /// - /// Dati dell'area R - /// - protected memAreaFanuc areaR; - /// - /// Dati dell'area X - /// - protected memAreaFanuc areaX; - /// - /// Dati dell'area Y - /// - protected memAreaFanuc areaY; -#endif - - -#if false - - /// - /// Override disconnessione - /// - public override void tryDisconnect() - { - if (connectionOk) - { - string szStatusConnection = ""; - try - { - FANUC_ref.Disconnect(ref szStatusConnection); - connectionOk = false; - // resetto timing! - TimingData.resetData(); - lgInfo(szStatusConnection); - lgInfo("Effettuata disconnessione adapter FANUC!"); - } - catch (Exception exc) - { - lgFatal(exc, "Errore nella disconnessione dall'adapter FANUC"); - } - } - else - { - lgError("IMPOSSIBILE effettuare disconnessione: Connessione non disponibile..."); - } - } - /// - /// Override connessione - /// - public override void tryConnect() - { - if (!connectionOk) - { - // controllo che il ping sia stato tentato almeno pingTestSec fa... - if (DateTime.Now.Subtract(lastPING).TotalSeconds > utils.CRI("pingTestSec")) - { - if (verboseLog || periodicLog) - { - lgInfo("ConnKO - tryConnect"); - } - // in primis salvo data ping... - lastPING = DateTime.Now; - // ora PING!!! - Ping pingSender = new Ping(); - IPAddress address = IPAddress.Loopback; - IPAddress.TryParse(currIobConf.cncIpAddr, out address); - PingReply reply = pingSender.Send(address, 100); - // se passa il ping faccio il resto... - if (reply.Status == IPStatus.Success) - { - string szStatusConnection = ""; - try - { - // ora provo connessione... - parentForm.commPlcActive = true; - FANUC_ref.Connect(ref szStatusConnection); - parentForm.commPlcActive = false; - lgInfo("szStatusConnection: " + szStatusConnection); - connectionOk = true; - // refresh stato allarmi!!! - if (connectionOk) - { - dtAvvioAdp = DateTime.Now; - if (adpRunning) - { - // carico status allarmi (completo) - lgInfo("Inizio refresh completo stato allarmi..."); - forceAlarmCheck(); - lgInfo("Completato refresh completo stato allarmi!"); - } - else - { - lgInfo("Connessione OK"); - } - } - else - { - lgError("Impossibile procedere, connessione mancante..."); - } - } - catch (Exception exc) - { - lgFatal(string.Format("Errore nella connessione all'adapter FANUC: {0}{1}{2}", szStatusConnection, Environment.NewLine, exc)); - connectionOk = false; - lgInfo(string.Format("Eccezione in TryConnect, Adapter NON running, pausa di {0} msec prima di ulteriori tentativi di riconnessione", utils.CRI("waitRecMSec"))); - } - } - else - { - // loggo no risposta ping ... - connectionOk = false; - if (verboseLog || periodicLog) - { - lgInfo(string.Format("Attenzione: controllo PING fallito per IP {0} - {1}", currIobConf.cncIpAddr, reply.Status)); - } - } - } - } - // se non è ancora connesso faccio procesisng memoria caso disconnesso... - if (!connectionOk) - { - // processo semafori ed invio... - processMemoryDiscon(); - } - } - /// - /// lettura principale (bit semafori) - /// - public override void readSemafori() - { - base.readSemafori(); - try - { - if (verboseLog) - { - lgInfo("inizio read semafori"); - } - - parentForm.sIN = Semaforo.SV; - // inizio letture, SEMPRE DA ZERO (possibile ottimizzazione...) - int memIndex = 0; - // controllo area R: se ha dati (> 0 byte) --> leggo! - if (MemBlockR.Length > 0) - { - stopwatch.Restart(); - FanucMemRW(R, FANUC.MemType.R, memIndex, ref MemBlockR); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-R", MemBlockR.Length), stopwatch.ElapsedTicks); - } - // log - if (verboseLog) - { - for (int i = 0; i < MemBlockR.Length; i++) - { - lgInfo(string.Format("MemBlockR{0}: {1}", i, utils.binaryForm(MemBlockR[i]))); - } - } - } - // controllo area X: se ha dati (> 0 byte) --> leggo! - if (MemBlockX.Length > 0) - { - stopwatch.Restart(); - FanucMemRW(R, FANUC.MemType.X, memIndex, ref MemBlockX); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-X", MemBlockX.Length), stopwatch.ElapsedTicks); - } - // log - if (verboseLog) - { - for (int i = 0; i < MemBlockX.Length; i++) - { - lgInfo(string.Format("MemBlockX{0}: {1}", i, utils.binaryForm(MemBlockX[i]))); - } - } - } - // controllo area Y: se ha dati (> 0 byte) --> leggo! - if (MemBlockY.Length > 0) - { - stopwatch.Restart(); - FanucMemRW(R, FANUC.MemType.Y, memIndex, ref MemBlockY); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-Y", MemBlockY.Length), stopwatch.ElapsedTicks); - } - // log - if (verboseLog) - { - for (int i = 0; i < MemBlockY.Length; i++) - { - lgInfo(string.Format("MemBlockY{0}: {1}", i, utils.binaryForm(MemBlockY[i]))); - } - } - } - stopwatch.Stop(); - // salvo il solo BYTE dell'input decifrando il semaforo... - decodeToBitmap(); - } - catch (Exception exc) - { - lgError(string.Format("Eccezione in readSemafori:{0}{1}", Environment.NewLine, exc)); - connectionOk = false; - } - } - /// - /// Effettua decodifica aree memoria alla bitmap usata x MAPO - /// - private void decodeToBitmap() - { - // init a zero... - B_input = 0; - // SE SI E' CONNESSO al FANUC allora è 1=powerON... - if (FANUC_ref.Connected) - { - B_input += 1 << 0; - } - - // decodifico impiegando dictionary... cercando il TIPO di memoria & co... - string bKey = ""; - string bVal = ""; - char area; - // valore INVERTED (default è false) - bool invSignal = false; - string memArea = ""; - string[] memIdx; - int bitNum = 0; - int byteNum = 0; - int byte2check = 0; - for (int i = 0; i < 8; i++) - { - bKey = string.Format("BIT{0}", i); - // cerco se ci sia in LUT - if (signLUT.ContainsKey(bKey)) - { - // recupero nome variabile... - bVal = signLUT[bKey]; - // se l'area è PZCOUNT... processo PUNTUALMENTE il CONTAPEZZI... - if (bVal.StartsWith("PZCOUNT")) - { - string currODL = ""; - try - { - currODL = utils.callUrl(urlGetCurrODL); - lgInfo(string.Format("Lettura ODL, {0} --> {1}", currIdxODL, currODL)); - // provo a salvare nuovo ODL - int.TryParse(currODL, out currIdxODL); - } - catch (Exception exc) - { - if (DateTime.Now.Subtract(lastWarnODL).TotalSeconds > 15) - { - lgError(exc, "Errore in fase di chiamata URL x ODL corrente | URL chiamato: {0}", urlGetCurrODL); - lastWarnODL = DateTime.Now; - } - } - if (currODL != null && currODL != "" && currODL != "0") - { - // controllo se è passato intervallo minimo tra 2 controlli/elaborazioni x distanziare invio e ridurre letture - if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay)) - { - // verifico se variato contapezzi in area STD PAR6711... e se passato ritardo minimo... - if (lastCountCNC > contapezzi) - { - // salvo nuovo contapezzi (incremento di 1...) - contapezzi++; - // salvo in semaforo! - B_input += 1 << 2; - } - // registro contapezzi - lgInfo(string.Format("Contapezzi FANUC: {0} | Contapezzi interno {1}", lastCountCNC, contapezzi)); - - // 2018.06.26 NON resetto perché si deve resettare da solo da conteggio TC POST cambio ODL... -#if false - else if (contapezzi > lastCountCNC) // in questo caso resetto - { - contapezzi = lastCountCNC; - } -#endif - // invio a server contapezzi (aggiornato) - string retVal = utils.callUrl(urlSetPzCount + contapezzi.ToString()); - // verifica se tutto OK - if (retVal != "OK") - { - // errore salvataggio contapezzi - lgInfo(string.Format("Errore salvataggio Contapezzi FANUC: {0} | Contapezzi interno {1} | Errore salvataggio: {2}", lastCountCNC, contapezzi, retVal)); - } - // resetto timer... - lastPzCountSend = DateTime.Now; - } - } - else - { - if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay)) - { - lgInfo(string.Format("Attenzione: mancanza ODL non procedo con gestione contapezzi. Contapezzi FANUC: {0} | Contapezzi interno {1}", lastCountCNC, contapezzi)); - // resetto timer... - lastPzCountSend = DateTime.Now; - } - } - } - else // area "normale" byte.bit - { - // di norma è segnale normale => 1, altrimenti inverse => 0... - invSignal = false; - // cerco se sia inverse (ultimo char "!") --> registro e elimino char... - invSignal = bVal.StartsWith("!"); - // tolgo comunque inversione... - bVal = bVal.Replace("!", ""); - // recupero area... - area = bVal[0]; - // altrimenti decodifico area... - memArea = bVal.Substring(1, bVal.Length - 1); - memIdx = memArea.Split('.'); - // calcolo bit e byte number... - int.TryParse(memIdx[0], out byteNum); - if (memIdx.Length > 1) - { - int.TryParse(memIdx[1], out bitNum); - } - // in base al nome cerco in una delle aree.. e prendo solo solo quel bit di quel byte... - switch (area) - { - case 'G': - byte2check = MemBlockG[byteNum]; - break; - case 'R': - byte2check = MemBlockR[byteNum]; - break; - case 'X': - byte2check = MemBlockX[byteNum]; - break; - case 'Y': - byte2check = MemBlockY[byteNum]; - break; - default: - break; - } - // a secondo che sia segnale normale o inverso... - if (invSignal) - { - // controllo se il bit sia NON attivo (basso)... == 0... - if ((byte2check & (1 << bitNum)) == 0) - { - B_input += 1 << i; - } - } - else - { - // controllo se il bit sia attivo (alto)... != 0 - if ((byte2check & (1 << bitNum)) != 0) - { - B_input += 1 << i; - } - } - -#if false - // da rivedere x gestione contapezzi a bit... - // verifico se si tratta di un segnale contapezzo... nel qual caso conteggio ed invio... - if (currIobConf.optPar["PZCOUNT_MODE"].StartsWith("BIT")) - { - // salvo nuovo contapezzi (incremento di 1...) - contapezzi++; - // invio a server contapezzi (aggiornato) - utils.callUrl(urlSetPzCount + contapezzi.ToString()); - lgInfo("Aggiornato contapezzi: {0}", contapezzi); - // resetto timer... - lastPzCountSend = DateTime.Now; - } -#endif - } - - } - } - // log opzionale! - if (verboseLog) - { - lgInfo(string.Format("Trasformazione B_input: {0}", B_input)); - } - } - /// - /// Recupero programma in lavorazione - /// - /// - public override string getPrgName() - { - string prgName = ""; - // recupero NUOVO prgName... - try - { - // recupero nome programma MAIN - prgName = utils.purgedChar2String(FANUC_ref.getPrgNameMain()); - // trimmo path del programma, ovvero "CNCMEMUSERPATH1" - prgName = prgName.Replace(utils.CRS("basePrgMemPath"), ""); - lgInfo("Current PROG: {0}", prgName); - } - catch (Exception exc) - { - lgError(string.Format("Eccezione in recupero PRG NAME MAIN:{0}{1}", Environment.NewLine, exc)); - connectionOk = false; - } - return prgName; - } - - /// - /// Recupero programma in lavorazione come Dictionary FANUC... - /// - SYSINFO: (prima KEY globale) TUTTI i valori separati da # (x fare check modifica) - /// - altre stringhe: ogni singolo parametro / valore - /// - /// - public override Dictionary getSysInfo() - { - Dictionary outVal = new Dictionary(); - stopwatch.Restart(); - CncLib.Focas1.ODBSYS answ = FANUC_ref.getSysInfo(); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("SYS-INFO"), stopwatch.ElapsedTicks); - } - - try - { - string cnc_type = new string(answ.cnc_type); - string mt_type = new string(answ.mt_type); - string series = new string(answ.series); - string version = new string(answ.version); - string axes = new string(answ.axes); - //short addInfo = answ.addinfo; - short max_axis = answ.max_axis; - // preparo i singoli valori dell'array... - outVal.Add("SYSINFO", string.Format("{0}#{1}#{2}#{3}#{4}#{5}", cnc_type, mt_type, series, version, axes, max_axis)); - outVal.Add("CNC", cnc_type); - outVal.Add("MTT", mt_type); - outVal.Add("SER", series); - outVal.Add("VER", version); - outVal.Add("AXS", string.Format("{0}|{1}", axes, max_axis)); - } - catch (Exception exc) - { - lgError(exc, "Errore in getSysInfo"); - connectionOk = false; - } - return outVal; - } - /// - /// Effettua vero processing contapezzi: - /// 6711: pezzi lavorati - /// 6712: pezzi lavorati totali - /// 6713: pezzi richiesti - /// - public override void processContapezzi() - { - if (utils.CRB("enableContapezzi")) - { - try - { - // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area) - if (currIobConf.optPar.Count > 0 && currIobConf.optPar["PZCOUNT_MODE"] != "") - { - string memAddr = currIobConf.optPar["PZCOUNT_MODE"]; - if (memAddr.StartsWith("STD")) - { - // inizio verifica area memoria/parametro levando prima parte codice - memAddr = memAddr.Replace("STD.", ""); - // var di appoggio - int cntAddr = 0; - object outputVal = new object(); - // verifico se si tratta di lettura parametro... formato tipo STD.PAR.6711 - if (memAddr.StartsWith("PAR.")) - { - // recupero parametro... - int.TryParse(memAddr.Replace("PAR.", ""), out cntAddr); - if (cntAddr == 0) - { - cntAddr = 6711; - } - - // processo parametro contapezzi (lavorati) - stopwatch.Restart(); - FANUC_ref.F_RW_Param_Integer(false, cntAddr, 3, ref outputVal); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-PAR", 4), stopwatch.ElapsedTicks); - } - - // salvo ultimo conteggio rilevato - Int32.TryParse(outputVal.ToString(), out lastCountCNC); - } - // altrimenti se legge da area memoria specifica leggo da li... formto tipo STD.D.1604.DW - else - { - memAddressFanuc areaCounter = new memAddressFanuc(memAddr); - - if (utils.CRB("verbose")) - { - lgInfo("[0] area memoria: {0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType); - } - - // leggo! - stopwatch.Restart(); - // switch x tipo dati --> tipo lettura... e salvo ultimo conteggio rilevato - switch (areaCounter.vType) - { - case "B": - byte valB = 0; - FANUC_ref.F_RW_Byte(false, areaCounter.mType, areaCounter.mPos, ref valB); - outputVal = valB; - break; - case "D": - ushort valW = 0; - FANUC_ref.F_RW_Word(false, areaCounter.mType, areaCounter.mPos, ref valW); - outputVal = valW; - break; - case "DW": - uint valDW = 0; - FANUC_ref.F_RW_DWord(false, areaCounter.mType, areaCounter.mPos, ref valDW); - if (utils.CRB("verbose")) - { - lgInfo("[1] valDW contapezzi: {0}", valDW); - } - - outputVal = valDW; - if (utils.CRB("verbose")) - { - lgInfo("[2] outputVal contapezzi: {0}", outputVal); - } - - break; - default: - break; - } - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R-{0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType), stopwatch.ElapsedTicks); - } - - // salvo... - Int32.TryParse(outputVal.ToString(), out lastCountCNC); - if (utils.CRB("verbose")) - { - lgInfo("[3] lastCountCNC contapezzi: {0}", lastCountCNC); - } - } - stopwatch.Stop(); - } - } - } - catch (Exception exc) - { - lgError(exc, "Errore in contapezzi FANUC"); - connectionOk = false; - } - } - } - /// - /// Esegue processing MODE (e nel contempo recupera altri dati dell'area G) - /// - public override void processMode() - { - if (utils.CRB("enableMode")) - { - try - { - // leggo tutto da 0 a 43... - int memIndex = 0; - // controllo modalità lettura memoria - stopwatch.Restart(); - FanucMemRW(R, FANUC.MemType.G, memIndex, ref MemBlockG); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-G-AREA", MemBlockG.Length), stopwatch.ElapsedTicks); - } - - stopwatch.Stop(); - // verifico modo con valore corrente, se cambia aggiorno... - CNC_MODE newMode = decodeG43(MemBlockG[43]); - if (newMode != currMode) - { - // aggiorno! - currMode = newMode; - // conversione NUM MODE in descrizione da ENUM - string descrMode = Enum.GetName(typeof(CNC_MODE), currMode); - // accodo x invio - string sVal = string.Format("[CNC_MODE]{0}", descrMode); - // chiamo accodamento... - accodaFLog(sVal, qEncodeFLog("CNC_MODE", descrMode)); - } - } - catch (Exception exc) - { - lgError(exc, string.Format("Errore in process Mode G43: {0}{1}", Environment.NewLine, exc)); - connectionOk = false; - stopwatch.Stop(); - } - } - } - /// - /// decodifica il modo dai valori del byte G43 - /// - /// - /// - protected CNC_MODE decodeG43(byte currVal) - { - // hard coded da valori tabellari a MODI definiti in CNC_MODE... - CNC_MODE answ = CNC_MODE.ND; - switch (currVal) - { - case 0: - answ = CNC_MODE.MDI; - break; - case 1: - answ = CNC_MODE.MEN; - break; - case 3: - answ = CNC_MODE.EDIT; - break; - case 4: - answ = CNC_MODE.HANDLE_INC; - break; - case 5: - answ = CNC_MODE.JOG; - break; - case 6: - answ = CNC_MODE.TJOG; - break; - case 7: - answ = CNC_MODE.THND; - break; - case 33: - answ = CNC_MODE.RMT; - break; - case 133: - answ = CNC_MODE.REF; - break; - default: - answ = CNC_MODE.ND; - break; - } - return answ; - } - /// - /// Recupero dati dinamici... - /// - public override Dictionary getDynData() - { - Dictionary outVal = new Dictionary(); - stopwatch.Restart(); - CncLib.Focas1.ODBDY2_1 answ = FANUC_ref.getAllDynData(); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("PROC-DYN-DATA"), stopwatch.ElapsedTicks); - } - - try - { - string actf = answ.actf.ToString(); - string acts = answ.acts.ToString(); - //string numAlarm = answ.alarm.ToString(); - // preparo i singoli valori dell'array... - //outVal.Add("DYNDATA", string.Format("{0}#{1}#{2}", actf, acts, numAlarm)); - outVal.Add("DYNDATA", string.Format("FEED {0}#SPEED_RPM {1}", actf, acts)); - if (utils.CRB("SendFeedSpeed")) - { - outVal.Add("FEED", actf); - outVal.Add("SPEED_RPM", acts); - //outVal.Add("NUM_ALARM", numAlarm); - } - if (utils.CRB("SendAxPos")) - { - // salvo le posizioni... - CncLib.Focas1.FAXIS posAx = answ.pos; - int[] currPosAbs = posAx.absolute; - int i = 0; - foreach (var item in currPosAbs) - { - i++; - outVal.Add(string.Format("POS_{0:00}", i), item.ToString()); - } - } - } - catch (Exception exc) - { - lgError(exc, "Errore in getDynData"); - } - stopwatch.Stop(); - return outVal; - } - /// - /// Recupero dati override (da area G che è già stata letta...) - /// - /// - public override Dictionary getOverrides() - { - Dictionary outVal = new Dictionary(); - if (utils.CRB("enableMode") && MemBlockG != null) - { - outVal.Add("FEED_OVER", MemBlockG[30].ToString()); - outVal.Add("RAPID_OVER", MemBlockG[12].ToString()); - } - return outVal; - } - - /// - /// Override salvataggio valori in memoria... - /// - /// tipo di DUMP - public override void saveMemDump(dumpType tipo) - { - // se l'area ha una size > 0... - if (areaD.arraySize > 0) - { - dump_MemArea(tipo, FANUC.MemType.D, areaD.startIdx, areaD.arraySize); - } - // se l'area ha una size > 0... - if (areaR.arraySize > 0) - { - dump_MemArea(tipo, FANUC.MemType.R, areaR.startIdx, areaR.arraySize); - } - // se l'area ha una size > 0... - if (areaX.arraySize > 0) - { - dump_MemArea(tipo, FANUC.MemType.X, areaX.startIdx, areaX.arraySize); - } - // se l'area ha una size > 0... - if (areaY.arraySize > 0) - { - dump_MemArea(tipo, FANUC.MemType.Y, areaY.startIdx, areaY.arraySize); - } - // se l'area ha una size > 0... - if (areaPAR.arraySize > 0) - { - dump_ParArea(tipo, areaPAR.startIdx, areaPAR.arraySize); - } - } - /// - /// Dump area D della memoria - /// - /// tipo di DUMP: START (sovrascrivendo) / SAMPLE (salva tanti campionamenti) - /// tipo memoria - /// area memoria di partenza - /// dimensione memoria - private void dump_MemArea(dumpType tipo, FANUC.MemType tipoMem, int memIndex, int memSizeByte) - { - DateTime adesso = DateTime.Now; - string nomeFileB = ""; - string nomeFileW = ""; - string nomeFileDW = ""; - Dictionary mappaValori = new Dictionary(); - // per sicurezza verifico < 9999 byte - if (memSizeByte > 9999) - { - memSizeByte = 9999; - } - // leggo TUTTI i (MAX 9999) byte della memoria D... - byte[] MemBlockCurr = new byte[memSizeByte]; - if (verboseLog) - { - lgInfo("START MemDump", tipoMem); - } - - stopwatch.Restart(); - FanucMemRW(R, tipoMem, memIndex, ref MemBlockCurr); - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-{1}", MemBlockCurr.Length, tipoMem), stopwatch.ElapsedTicks); - } - - if (verboseLog) - { - lgInfo("END MemDump", tipoMem); - } - - // seconda del tipo di lettura definisco i nomi delle variabili... - if (tipo == dumpType.SAMPLE) - { - nomeFileB = string.Format(@"{0}\SAMPLES\{1}_{2}_Byte_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, currIobConf.codIOB, tipoMem, adesso); - nomeFileW = string.Format(@"{0}\SAMPLES\{1}_{2}_W_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, currIobConf.codIOB, tipoMem, adesso); - nomeFileDW = string.Format(@"{0}\SAMPLES\{1}_{2}_DW_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, currIobConf.codIOB, tipoMem, adesso); - } - else - { - // salvo in file i dati letti come BYTE - nomeFileB = string.Format(@"{0}\{1}_{2}_Byte.dat", utils.dataDatDir, currIobConf.codIOB, tipoMem); - nomeFileW = string.Format(@"{0}\{1}_{2}_W.dat", utils.dataDatDir, currIobConf.codIOB, tipoMem); - nomeFileDW = string.Format(@"{0}\{1}_{2}_DW.dat", utils.dataDatDir, currIobConf.codIOB, tipoMem); - } - - // salvo in file i dati letti come BYTE - mappaValori = new Dictionary(); - for (int i = 0; i < MemBlockCurr.Length; i++) - { - mappaValori.Add(i.ToString("0000"), MemBlockCurr[i].ToString()); - } - utils.WritePlain(mappaValori, nomeFileB); - - // salvo in file i dati letti come Word (2byte) - mappaValori = new Dictionary(); - for (int i = 0; i < MemBlockCurr.Length / 2; i++) - { - mappaValori.Add(i.ToString("0000"), BitConverter.ToUInt16(MemBlockCurr, i * 2).ToString()); - } - utils.WritePlain(mappaValori, nomeFileW); - - // salvo in file i dati letti come DWord (4byte) - mappaValori = new Dictionary(); - for (int i = 0; i < MemBlockCurr.Length / 4; i++) - { - mappaValori.Add(i.ToString("0000"), BitConverter.ToUInt32(MemBlockCurr, i * 4).ToString()); - } - utils.WritePlain(mappaValori, nomeFileDW); - } - /// - /// Dump area PARAMETRI - /// - /// tipo di DUMP: START (sovrascrivendo) / SAMPLE (salva tanti campionamenti) - /// Parametro di partenza - /// Numero parametri da esportare... memoria - private void dump_ParArea(dumpType tipo, int memIndex, int numPar) - { - DateTime adesso = DateTime.Now; - string nomeFile = ""; - Dictionary mappaValori = new Dictionary(); - // per sicurezza verifico < 9999 parametri - if (numPar > 9999) - { - numPar = 9999; - } - - // leggo TUTTI i (MAX 9999) byte della memoria D... - object[] paramsArray = new object[numPar]; - if (verboseLog) - { - lgInfo("START ParamDump"); - } - - stopwatch.Restart(); - for (int i = 0; i < numPar; i++) - { - FANUC_ref.F_RW_Param_Integer(false, memIndex + i, 3, ref paramsArray[i]); - } - - if (utils.CRB("recTime")) - { - TimingData.addResult(currIobConf.codIOB, string.Format("R{0}-PAR", 4 * numPar), stopwatch.ElapsedTicks); - } - - if (verboseLog) - { - lgInfo("END ParamDump"); - } - - // seconda del tipo di lettura definisco i nomi delle variabili... - if (tipo == dumpType.SAMPLE) - { - nomeFile = string.Format(@"{0}\SAMPLES\{1}_{2}_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, currIobConf.codIOB, "PAR", adesso); - } - else - { - nomeFile = string.Format(@"{0}\{1}_{2}.dat", utils.dataDatDir, currIobConf.codIOB, "PAR"); - } - - // salvo in file i dati letti - mappaValori = new Dictionary(); - for (int i = 0; i < paramsArray.Length; i++) - { - mappaValori.Add(i.ToString("0000"), paramsArray[i].ToString()); - } - utils.WritePlain(mappaValori, nomeFile); - } -#endif } }