Samuele Locatelli
1498 lines
50 KiB
C#
1498 lines
50 KiB
C#
using CMSCncLib.CNC;
|
|
using MTC;
|
|
using SCMA.AdapterCom;
|
|
using System;
|
|
using System.Text;
|
|
|
|
namespace SCMA.AdapterPLC.CMS
|
|
{
|
|
public class Fanuc : Generic
|
|
{
|
|
/// <summary>
|
|
/// Oggetto MAIN x connessione FANUC
|
|
/// </summary>
|
|
protected FANUC FANUC_ref;
|
|
/// <summary>
|
|
/// wrapper chiamata lettura/scrittura SINGOLO BYTE...
|
|
/// </summary>
|
|
/// <param name="bWrite"></param>
|
|
/// <param name="MemType"></param>
|
|
/// <param name="memIndex"></param>
|
|
/// <param name="Value"></param>
|
|
/// <returns></returns>
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// wrapper chiamata lettura/scrittura MULTI BYTE...
|
|
/// </summary>
|
|
/// <param name="bWrite"></param>
|
|
/// <param name="MemType"></param>
|
|
/// <param name="memIndex"></param>
|
|
/// <param name="MATRICE Value"></param>
|
|
/// <returns></returns>
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// wrapper chiamata lettura PARAMETRI MULTI BYTE...
|
|
/// </summary>
|
|
/// <param name="bWrite"></param>
|
|
/// <param name="memIndex"></param>
|
|
/// <param name="paramsArray"></param>
|
|
/// <returns></returns>
|
|
public bool FanucReadPar(bool bWrite, Int32 memIndex, ref object[] paramsArray)
|
|
{
|
|
bool answ = false;
|
|
if (FANUC_ref.Connected)
|
|
{
|
|
try
|
|
{
|
|
parentForm.commPlcActive = true;
|
|
for (int i = 0; i < paramsArray.Length; i++)
|
|
{
|
|
FANUC_ref.F_RW_ParamAllAxis_Integer(bWrite, memIndex + i, 2, ref paramsArray[i]);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, "Errore lettura parametri in FanucReadPar");
|
|
}
|
|
}
|
|
parentForm.commPlcActive = false;
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// struttura dati fanuc x ALL DYN DATA
|
|
/// C:\Users\samuele\Documents\FOCAS A02B-0207-K737_04.20\Document\SpecE\Position\cnc_rddynamic2.htm
|
|
/// </summary>
|
|
protected CMSCncLib.Focas1.ODBDY2_1 allDynData;
|
|
/// <summary>
|
|
/// Vettore degli allarmi CNC attivi
|
|
/// </summary>
|
|
public CMSCncLib.Focas1.ODBALMMSG2 allarmiCNC;
|
|
/// <summary>
|
|
/// estende l'init della classe base...
|
|
/// </summary>
|
|
/// <param name="caller">FORM chaimante</param>
|
|
/// <param name="adpConf">CONFIGURAZIONE adapter</param>
|
|
/// <param name="gatewayObj">OGGETTO gestione comunicazione OUT (tipologia e metodi)</param>
|
|
public Fanuc(MainForm caller, AdapterConf adpConf, Gateway gatewayObj) : base(caller, adpConf, gatewayObj)
|
|
{
|
|
// !!!HARD CODED!!! aggiunto banco STATUS del 2 processo IN CODA... (4+1)DW=20byte x strobes...!!!
|
|
Strobes = new byte[20];
|
|
|
|
//fix dimensione memorie MST: 26 short(16bit) x (11+6+6) aree (attenzione: secondo set di 2 bit è VUOTO...)
|
|
MemBlock_MST = new byte[46];
|
|
// salto NON necessario!
|
|
saltoMST = 0;
|
|
// è little endian (NON serve conversione)
|
|
hasBigEndian = false;
|
|
|
|
lg.Info("Start init Adapter FANUC all'IP {0}", utils.CRS("ipPLC"));
|
|
|
|
parentForm.commPlcActive = true;
|
|
Runtime.CreateNC(CNC.NcType.FANUC, utils.CRS("ipPLC"));
|
|
parentForm.commPlcActive = false;
|
|
// inizializzo posizioni assi...
|
|
prevPosAxis = new double[adpConf.nAxis];
|
|
prevDirAxis = new int[adpConf.nAxis];
|
|
|
|
FANUC_ref = (FANUC)Runtime.NC;
|
|
if (utils.CRB("verbose"))
|
|
{
|
|
lg.Info("FANUC_ref da CMSCncLib");
|
|
}
|
|
|
|
// disconnetto e connetto...
|
|
if (utils.CRB("verbose"))
|
|
{
|
|
lg.Info("FANUC: tryDisconnect");
|
|
}
|
|
|
|
tryDisconnect();
|
|
lg.Info("FANUC: tryConnect");
|
|
tryConnect();
|
|
lg.Info("End init Adapter FANUC");
|
|
}
|
|
/// <summary>
|
|
/// Override disconnessione
|
|
/// </summary>
|
|
public override void tryDisconnect()
|
|
{
|
|
if (connectionOk)
|
|
{
|
|
string szStatusConnection = "";
|
|
try
|
|
{
|
|
FANUC_ref.Disconnect(ref szStatusConnection);
|
|
connectionOk = false;
|
|
lg.Info(szStatusConnection);
|
|
lg.Info("Effettuata disconnessione adapter FANUC!");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Fatal(exc, "Errore nella disconnessione dall'adapter FANUC");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lg.Error("IMPOSSIBILE effettuare disconnessione: Connessione non disponibile...");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Override connessione
|
|
/// </summary>
|
|
public override void tryConnect()
|
|
{
|
|
if (!connectionOk)
|
|
{
|
|
string szStatusConnection = "";
|
|
try
|
|
{
|
|
parentForm.commPlcActive = true;
|
|
FANUC_ref.Connect(ref szStatusConnection);
|
|
parentForm.commPlcActive = false;
|
|
lg.Info("szStatusConnection: " + szStatusConnection);
|
|
connectionOk = true;
|
|
// refresh stato allarmi!!!
|
|
if (connectionOk)
|
|
{
|
|
if (adpRunning)
|
|
{
|
|
// carico status allarmi (completo)
|
|
lg.Info("Inizio refresh completo stato allarmi...");
|
|
forceAlarmCheck();
|
|
lg.Info("Completato refresh completo stato allarmi!");
|
|
}
|
|
else
|
|
{
|
|
lg.Info("Connessione OK");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Impossibile procedere, connessione mancante...");
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Fatal(string.Format("Errore nella connessione all'adapter FANUC: {0}{1}{2}", szStatusConnection, Environment.NewLine, exc));
|
|
connectionOk = false;
|
|
lg.Info(string.Format("Segnalo Adapter NON running, pausa di {0} msec prima di ulteriori tentativi di riconnessione", utils.CRI("waitRecMSec")));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifico connessione FANUC...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override bool connectionOk
|
|
{
|
|
get
|
|
{
|
|
return FANUC_ref.Connected;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Effettuo lettura dei 16 byte di strobe/status
|
|
/// </summary>
|
|
public override void getStrobeAndAckStatus()
|
|
{
|
|
base.getStrobeAndAckStatus();
|
|
if (connectionOk)
|
|
{
|
|
// leggo TUTTO ack e strobe,
|
|
byte[] MemBlock = new byte[Strobes.Length + Acknowl.Length];
|
|
int memIndex = 10500;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref MemBlock);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-STROBES", MemBlock.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
// suddivido!
|
|
Buffer.BlockCopy(MemBlock, 0, Acknowl, 0, Acknowl.Length);
|
|
Buffer.BlockCopy(MemBlock, Acknowl.Length, Strobes, 0, Strobes.Length);
|
|
}
|
|
else
|
|
{
|
|
lg.Error("Errore connessione mancante in getStrobeAndAckStatus");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// processing strobe!
|
|
/// </summary>
|
|
public override void processStrobe()
|
|
{
|
|
// 2019.08.03 modifica con processing doppio path...
|
|
// inizializzo userAction
|
|
string UserAction = "";
|
|
// oggetti "accessori" x processing (1 byte di strobe x ogni path)
|
|
StFlag8 currStrobe;
|
|
StFlag8 currAck;
|
|
|
|
// processo ora i dati dei path... di sicuro il primo
|
|
currStrobe = (StFlag8)(Strobes[4]); // 5° byte
|
|
currAck = (StFlag8)(Acknowl[4]); // 5° byte
|
|
procPathStrobes(0, currStrobe, currAck, 10660, 10504, ref UserAction);
|
|
|
|
//...e se c'è pure il secondo...
|
|
if (currAdpConf.nPath > 1)
|
|
{
|
|
currStrobe = (StFlag8)(Strobes[6]); // 7° byte
|
|
currAck = (StFlag8)(Acknowl[6]); // 7° byte
|
|
procPathStrobes(1, currStrobe, currAck, 12110, 10506, ref UserAction);
|
|
}
|
|
|
|
//2019.07.22 NON RIPORTO USER_ACTION x SOUR
|
|
if (currGateway.protocollo != gwProtocol.SOURS)
|
|
{
|
|
// 2017.01.16 INVIO vettore azioni (1 o +)... SE CE NE SONO!
|
|
if (UserAction.Trim() != "")
|
|
{
|
|
currGateway.updateItemNodeValue("USER_ACTION", UserAction.Trim());
|
|
}
|
|
}
|
|
|
|
// verifico strobe dell'auto-test
|
|
currStrobe = (StFlag8)(Strobes[7]); // 8° byte
|
|
currAck = (StFlag8)(Acknowl[7]); // 8° byte
|
|
processTestStrobe(currStrobe, currAck, 10507, 1);
|
|
|
|
// gestione bit di watchdog... sulal DWord successiva
|
|
sendWatchDog();
|
|
|
|
}
|
|
/// <summary>
|
|
/// Scrive ACK x dati MST
|
|
/// </summary>
|
|
/// <param name="idxPath"></param>
|
|
/// <param name="memIndexMST"></param>
|
|
/// <param name="MemBlock_W"></param>
|
|
/// <returns></returns>
|
|
public override bool writeMST_ACK(int memIndexAck, ref byte[] currACK_DW)
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(W, FANUC.MemType.R, memIndexAck, ref currACK_DW);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("W{0}-DW1", currACK_DW.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Errore in scrittura dati ACK MST:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return fatto;
|
|
}
|
|
/// <summary>
|
|
/// Legge area memoria dati MST
|
|
/// </summary>
|
|
/// <param name="idxPath"></param>
|
|
/// <param name="memIndexMST"></param>
|
|
/// <param name="MemBlock_MST"></param>
|
|
/// <returns></returns>
|
|
public override bool readMST_data(int idxPath, int memIndexMST, ref byte[] MemBlock_MST)
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
// leggo tutto!!!
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndexMST, ref MemBlock_MST);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-STRB_DW1-P{1:00}", MemBlock_MST.Length, idxPath), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Errore in lettura dati MST:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return fatto;
|
|
}
|
|
/// <summary>
|
|
/// Scrive watchdog
|
|
/// </summary>
|
|
/// <param name="retACK_DW"></param>
|
|
/// <returns></returns>
|
|
public override bool writeWatchDog(ref byte[] retACK_DW)
|
|
{
|
|
int memIndex = 10508;
|
|
return FanucMemRW(W, FANUC.MemType.R, memIndex, ref retACK_DW);
|
|
}
|
|
/// <summary>
|
|
/// Effettua lettura dati TESTING
|
|
/// </summary>
|
|
/// <param name="MemBlockTestData"></param>
|
|
/// <returns></returns>
|
|
public override bool readTestData(ref uint[] MemBlockTestData)
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
byte[] MemBlockTestDataByte = new byte[64];
|
|
byte singleByte;
|
|
// leggo tutto!!!
|
|
int memIndex = 11000;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref MemBlockTestDataByte);
|
|
// copio da byte a uint...
|
|
for (int i = 0; i < MemBlockTestDataByte.Length; i++)
|
|
{
|
|
singleByte = MemBlockTestDataByte[i];
|
|
MemBlockTestData[i] = Convert.ToUInt32(singleByte);
|
|
}
|
|
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-TEST_DATA", MemBlockTestData.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Errore in lettura dati TEST:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
#region implementazione processing GlobalData
|
|
|
|
/// <summary>
|
|
/// Legge dati globali...
|
|
/// </summary>
|
|
public override void readGlobalData()
|
|
{
|
|
// procedo per PATH
|
|
for (int i = 0; i < currAdpConf.nPath; i++)
|
|
{
|
|
// leggo dati globali...
|
|
parentForm.commPlcActive = true;
|
|
inizio = DateTime.Now;
|
|
allDynData = FANUC_ref.getAllDynData(i + 1);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-ALL-DYN-DATA", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
parentForm.commPlcActive = false;
|
|
// 2019.08.30 fattore feed...
|
|
int fattFeedFanuc = 1;
|
|
if (utils.CRI("fattFeedFanuc") > 0)
|
|
{
|
|
fattFeedFanuc = utils.CRI("fattFeedFanuc");
|
|
}
|
|
FeedRate = allDynData.actf / fattFeedFanuc;
|
|
// salvo in vettore...
|
|
FeedRatePath[i] = FeedRate;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// legge dati override...
|
|
/// </summary>
|
|
/// <param name="sb1"></param>
|
|
/// <returns></returns>
|
|
public override bool readOverrides(ref StringBuilder sb1)
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
|
|
// area path1/2: 7 WORD x ogni path...
|
|
int memIndex = 12000;
|
|
byte[] PathData_mem = new byte[14];
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref PathData_mem);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-PathData", PathData_mem.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
// 2016.07.19 mod con Fabio
|
|
//JogRateOver = PathData_mem[0];
|
|
FeedRateOver = PathData_mem[1];
|
|
RapidOver = PathData_mem[2];
|
|
SpeedRateOver = PathData_mem[3];
|
|
|
|
tryLogMessage(sb1, string.Format("FeedRate: {0} mm/min", FeedRate));
|
|
tryLogMessage(sb1, string.Format("FeedRateOver: {0} %", FeedRateOver));
|
|
tryLogMessage(sb1, string.Format("RapidOver: {0} %", RapidOver));
|
|
tryLogMessage(sb1, string.Format("SpeedRateOver: {0} %", SpeedRateOver));
|
|
|
|
// 2017.04.20: recupero OVER per Jog/Feed/Rapid/Spindle x i path multipli (qui cablati 1-2)
|
|
ushort[] currPathData = new ushort[7];
|
|
// processo ora i dai dei path... di sicuro il primo
|
|
Array.Copy(PathData_mem, 0, currPathData, 0, 7);
|
|
procPathOverride(0, currPathData, ref sb1);
|
|
//...e se c'è pure il secondo...
|
|
if (currAdpConf.nPath > 1)
|
|
{
|
|
Array.Copy(PathData_mem, 7, currPathData, 0, 7);
|
|
// anche il secondo!
|
|
procPathOverride(1, currPathData, ref sb1);
|
|
}
|
|
fatto = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, "Eccezione in readOverrides");
|
|
}
|
|
return fatto;
|
|
}
|
|
/// <summary>
|
|
/// recupera allarmi ed aggiorna strobe (privato) degli allarmi
|
|
/// </summary>
|
|
/// <param name="Alarm2Refresh">32bit mask degli allarmi da aggiornare</param>
|
|
/// <param name="giveAck">boolean: se si debba tornare ACK</param>
|
|
public override void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
|
|
{
|
|
// log bitmap se verboso attivo + ho allarmi da refreshare
|
|
if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose"))
|
|
{
|
|
lg.Info("RAS | Richiesto refresh allarmi x bitmask: {0}", utils.binaryForm((int)Alarm2Refresh));
|
|
}
|
|
|
|
bool ackReturned = false;
|
|
// byte di acknowledge...
|
|
byte[] retACK_DW0 = new byte[4];
|
|
// inizio impostando una bitmap x ACK che abbia i bit abbassati se lo strobe è disattivo: AND logico tra STR e ACK
|
|
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
|
|
|
|
inizio = DateTime.Now;
|
|
byte[] MemBlock;
|
|
// primo blocco memoria allarmi
|
|
int memIndex = 10532;
|
|
// controllo, SE devo leggere tutto uso un unico accesso ai 128byte, altrimenti leggo a blocchi di 32bit...
|
|
|
|
if (Alarm2Refresh == (StFlag32)unchecked((int)UInt32.MaxValue))
|
|
{
|
|
// blocco memoria x lettura dati COMPLETO (4Byte*32 = 128Byte)
|
|
MemBlock = new byte[128];
|
|
// recupero tutti i 32 bit del blocco
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref MemBlock);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
if (currGateway.AlarmFlags != null)
|
|
{
|
|
try
|
|
{
|
|
// aggiorno vettore allarmi x intero! size del vettore di destinazione (in byte!!!!)
|
|
Buffer.BlockCopy(MemBlock, 0, currGateway.AlarmFlags, 0, currGateway.AlarmFlags.Length);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("RAS | Errore in BLOCKCOPY{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Alarm2Refresh != StFlag32.NONE)
|
|
{
|
|
// blocco memoria x lettura dati
|
|
MemBlock = new byte[4];
|
|
// verifico gli allarmi di tutti i bit alzati...
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (Alarm2Refresh.HasFlag((StFlag32)Math.Pow(2, i)))
|
|
{
|
|
// recupero tutti i 32 bit del blocco
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex + i * 4, ref MemBlock);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
// da testare metodo copia alternativo, condizionato a web.config
|
|
if (!utils.CRB("fastCopy"))
|
|
{
|
|
// aggiorno nel vettore allarmi i byte interessati
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
// copy array a blocchi
|
|
currGateway.AlarmFlags[i * 4 + j] = MemBlock[j];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Buffer.BlockCopy(MemBlock, 0, currGateway.AlarmFlags, i * 4, MemBlock.Length);
|
|
}
|
|
if (utils.CRB("verbose"))
|
|
{
|
|
UInt32 valore = BitConverter.ToUInt32(MemBlock, 0);
|
|
lg.Info("RAS | Bit allarme rilevato dalla posizione {0} | {1}", i * 32, utils.binaryForm((int)valore));
|
|
}
|
|
|
|
// segnalo allarme letto! memorizzo allarme nel vettore ack....
|
|
retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, true, i);
|
|
}
|
|
}
|
|
// scrivo ack se richiesto!!!
|
|
if (giveAck)
|
|
{
|
|
// mi preparo a scrivere ACK
|
|
memIndex = 10500;
|
|
// scrivo update ad ack!!!
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(W, FANUC.MemType.R, memIndex, ref retACK_DW0);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
ackReturned = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// SE non ho già tornato un ACK...
|
|
if (!ackReturned)
|
|
{
|
|
// se è diverso il vettori degli ACK in memoria da quello PLC...
|
|
if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0))
|
|
{
|
|
memIndex = 10500;
|
|
// invio INTERO set ACK_DW0 con bit abbassati...
|
|
retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(W, FANUC.MemType.R, memIndex, ref retACK_DW0);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// processa allarmi CNC...
|
|
/// </summary>
|
|
public override bool procCncAlarm()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
parentForm.commPlcActive = true;
|
|
// se ho allarmi li accodo...
|
|
if (allDynData.alarm != 0)
|
|
{
|
|
inizio = DateTime.Now;
|
|
if (!utils.CRB("disableAdvRead"))
|
|
{
|
|
try
|
|
{
|
|
allarmiCNC = FANUC_ref.getCncAlarm();
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-CNC-ALARMS", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
checkCNCAlarms();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("Errore in recupero Allarmi CNC{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allarmiCNC = new CMSCncLib.Focas1.ODBALMMSG2();
|
|
}
|
|
parentForm.commPlcActive = false;
|
|
fatto = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return fatto;
|
|
}
|
|
/// <summary>
|
|
/// Gestione lettura dati manutenzione
|
|
/// </summary>
|
|
public override bool getMtzDataFromPlc()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
if (maintData != null)
|
|
{
|
|
if (maintData.Length > 0)
|
|
{
|
|
|
|
// recupero i dati di manutenzione dall'area di memoria IN BLOCCO
|
|
int memIndex = 14000;
|
|
byte[] tabDatiMtzByte = new byte[4 * maintData.Length];
|
|
uint[] tabDatiMtz = new uint[maintDataMaxNum];
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref tabDatiMtzByte);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-DatiMtz", tabDatiMtzByte.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
// copio byte --> word!
|
|
Buffer.BlockCopy(tabDatiMtzByte, 0, tabDatiMtz, 0, tabDatiMtzByte.Length);
|
|
// decodifico aree memoria secondo tab configurazione
|
|
processMaintData(tabDatiMtz, maintData);
|
|
}
|
|
fatto = true;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return fatto;
|
|
}
|
|
/// <summary>
|
|
/// Gestione lettura dati analogici
|
|
/// </summary>
|
|
public override bool getAnalogDataFromPlc()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
if (analogData.Length > 0)
|
|
{
|
|
// recupero i dati di manutenzione dall'area di memoria IN BLOCCO
|
|
int memIndex = 15000;
|
|
byte[] tabDatiAnalogByte = new byte[4 * analogDataMaxNum];
|
|
uint[] tabDatiAnalog = new uint[analogDataMaxNum];
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref tabDatiAnalogByte);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-DatiAnalog", tabDatiAnalogByte.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
// copio byte --> word!
|
|
Buffer.BlockCopy(tabDatiAnalogByte, 0, tabDatiAnalog, 0, tabDatiAnalogByte.Length);
|
|
// decodifico aree memoria secondo tab configurazione
|
|
processAnalogData(tabDatiAnalog, analogData);
|
|
}
|
|
fatto = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return fatto;
|
|
|
|
}
|
|
/// <summary>
|
|
/// Gestione lettura dati status da PLC
|
|
/// </summary>
|
|
public override bool getStatusDataFromPlc()
|
|
{
|
|
bool fatto = false;
|
|
try
|
|
{
|
|
if (statusDataMaxNum > 0)
|
|
{
|
|
// recupero i dati di manutenzione dall'area di memoria IN BLOCCO
|
|
int memIndex = 14512;
|
|
int numByte = 1 + (statusDataMaxNum / 8);
|
|
byte[] tabDatiStatus = new byte[numByte];
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.R, memIndex, ref tabDatiStatus);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-DatiStatus", tabDatiStatus.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
// decodifico aree memoria secondo tab configurazione
|
|
processStatusData(tabDatiStatus, statusData);
|
|
}
|
|
fatto = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return fatto;
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Carico file conf dati CMS
|
|
/// </summary>
|
|
protected override void loadOtherFile()
|
|
{
|
|
base.loadOtherFile();
|
|
loadMaintData("R", 14000, 4);
|
|
loadStatusData("R", 14512, 1);
|
|
loadAnalogData("R", 15000, 4);
|
|
}
|
|
/// <summary>
|
|
/// Processing allarmi CNC
|
|
/// </summary>
|
|
public override void processAlarm()
|
|
{
|
|
base.processAlarm();
|
|
|
|
// aggiungo gestione allarmi CNC
|
|
checkCNCAlarms();
|
|
}
|
|
/// <summary>
|
|
/// Verifica i 10 allarmi CNC SE presenti
|
|
/// </summary>
|
|
private void checkCNCAlarms()
|
|
{
|
|
// faccio parse allarmi: se ci sono invio e presento
|
|
sendAlarmIfPresent(allarmiCNC.msg1);
|
|
sendAlarmIfPresent(allarmiCNC.msg2);
|
|
sendAlarmIfPresent(allarmiCNC.msg3);
|
|
sendAlarmIfPresent(allarmiCNC.msg4);
|
|
sendAlarmIfPresent(allarmiCNC.msg5);
|
|
sendAlarmIfPresent(allarmiCNC.msg6);
|
|
sendAlarmIfPresent(allarmiCNC.msg7);
|
|
sendAlarmIfPresent(allarmiCNC.msg8);
|
|
sendAlarmIfPresent(allarmiCNC.msg9);
|
|
sendAlarmIfPresent(allarmiCNC.msg10);
|
|
}
|
|
/// <summary>
|
|
/// Invia singolo allarme CNC se presente
|
|
/// </summary>
|
|
/// <param name="allarmiFanuc"></param>
|
|
protected void sendAlarmIfPresent(CMSCncLib.Focas1.ODBALMMSG2_data allarmiFanuc)
|
|
{
|
|
// controllo valore...
|
|
if (allarmiFanuc.alm_no > 0)
|
|
{
|
|
allarme newAlarm;
|
|
try
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if (utils.CRI("loglevel") > 5)
|
|
{
|
|
lg.Info(string.Format("Allarmi CNC: NUM {0} | MESS: {1} | ASSE: {2} | TYPE: {3}", allarmiFanuc.alm_no, allarmiFanuc.alm_msg, allarmiFanuc.axis, allarmiFanuc.type));
|
|
}
|
|
// se ho asse accodo ad asse altrimenti no...
|
|
string codAllarme = string.Format("T{0}-N{1}", allarmiFanuc.type, allarmiFanuc.alm_no);
|
|
if (allarmiFanuc.axis == 0)
|
|
{
|
|
allarme currAllarm = new allarme(codAllarme, currGateway.nCncConditions, "FAULT", allarmiFanuc.alm_msg);
|
|
currGateway.addAlarm(currAllarm);
|
|
}
|
|
else
|
|
{
|
|
newAlarm = new allarme(codAllarme, vettAxis[allarmiFanuc.axis - 1].alarmCncKey, "FAULT", allarmiFanuc.alm_msg);
|
|
currGateway.addAlarm(currGateway.conditionNodes[vettAxis[allarmiFanuc.axis - 1].alarmCncKey], newAlarm);
|
|
}
|
|
// mostro in form!
|
|
sb.AppendLine(codAllarme);
|
|
parentForm.dataMonitor_1 += sb.ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(string.Format("{0}", exc));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Recupero dati x UnOp
|
|
/// </summary>
|
|
public override void getUnOp()
|
|
{
|
|
// leggo in blocco tutte le speed da memoria...
|
|
int memIndex = 3140;
|
|
// buffer memoria 60 byte... speed (16bit 2 * 20) + load (8bit 1 * 20) visto che sono 20 teste max
|
|
byte[] unOpSpeedMem = new byte[60];
|
|
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.D, memIndex, ref unOpSpeedMem);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-SPEED_UNOP", unOpSpeedMem.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
procUnOp(unOpSpeedMem);
|
|
}
|
|
/// <summary>
|
|
/// Procedura di processing lettura memoria x DatiUt - Step 4
|
|
/// </summary>
|
|
/// <param name="int32Mem"></param>
|
|
/// <param name="j"></param>
|
|
/// <returns></returns>
|
|
public override int getDatiUt_step4(ref byte[] int32Mem, int j)
|
|
{
|
|
int memIndex = 13100 + 4 * j;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.D, memIndex, ref int32Mem);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-TabUT-VitaRes", int32Mem.Length), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
return memIndex;
|
|
}
|
|
/// <summary>
|
|
/// Procedura di processing lettura memoria x DatiUt - Step 3b
|
|
/// </summary>
|
|
/// <param name="int8Mem"></param>
|
|
/// <param name="j"></param>
|
|
/// <returns></returns>
|
|
public override int getDatiUt_step3b(ref byte int8Mem, int j)
|
|
{
|
|
int memIndex = 10700 + 1 * j;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(R, FANUC.MemType.D, memIndex, ref int8Mem);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult(string.Format("R{0}-TabUT-FamUT", 8), DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
return memIndex;
|
|
}
|
|
/// <summary>
|
|
/// Procedura di processing lettura memoria x DatiUt - Step 3a
|
|
/// </summary>
|
|
/// <param name="tabFam_FamUt"></param>
|
|
/// <returns></returns>
|
|
public override int getDatiUt_step3a(ref byte[] tabFam_FamUt)
|
|
{
|
|
int memIndex = 8900;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(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);
|
|
}
|
|
|
|
return memIndex;
|
|
}
|
|
/// <summary>
|
|
/// Procedura di processing lettura memoria x DatiUt - Step 2b
|
|
/// </summary>
|
|
/// <param name="int16Mem"></param>
|
|
/// <param name="j"></param>
|
|
/// <returns></returns>
|
|
public override int getDatiUt_step2b(ref byte[] int16Mem, int j)
|
|
{
|
|
int memIndex = 11700 + 2 * j;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(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);
|
|
}
|
|
|
|
return memIndex;
|
|
}
|
|
/// <summary>
|
|
/// Procedura di processing lettura memoria x DatiUt - Step 2a
|
|
/// </summary>
|
|
/// <param name="tabUt_UT"></param>
|
|
/// <returns></returns>
|
|
public override int getDatiUt_step2a(ref byte[] tabUt_UT)
|
|
{
|
|
int memIndex = 11300;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(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);
|
|
}
|
|
|
|
return memIndex;
|
|
}
|
|
/// <summary>
|
|
/// Procedura di processing lettura memoria x DatiUt - Step 1
|
|
/// </summary>
|
|
/// <param name="elencoUtMem"></param>
|
|
/// <returns></returns>
|
|
public override int getDatiUt_step1(ref byte[] elencoUtMem)
|
|
{
|
|
int memIndex = 2960;
|
|
inizio = DateTime.Now;
|
|
FanucMemRW(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);
|
|
}
|
|
|
|
return memIndex;
|
|
}
|
|
/// <summary>
|
|
/// Recupero tutti i dati del PATH
|
|
/// </summary>
|
|
public override void getPath()
|
|
{
|
|
base.getPath();
|
|
|
|
// ciclo su path
|
|
StringBuilder sb_2;
|
|
StringBuilder sb_3;
|
|
for (int i = 0; i < currAdpConf.nPath; i++)
|
|
{
|
|
// recupero codici G per path
|
|
string GCodAttivi = getCodGPath(i + 1);
|
|
// recupero vett coordinate x path
|
|
CMSCncLib.Focas1.ODB5AXMAN vettTTCoord = getVettCoordPath(i + 1);
|
|
|
|
// accodo dati path in DataMonitor...
|
|
sb_2 = new StringBuilder();
|
|
sb_3 = new StringBuilder();
|
|
|
|
currGateway.updateItemNodeValue(vettPath[i].gCodeAct_Key, GCodAttivi);
|
|
if (!utils.CRB("FanucLimit3D"))
|
|
{
|
|
currGateway.updateItemNodeValue(vettPath[i].posAct_X_Key, ((decimal)vettTTCoord.data1) / utils.CRI("fattdecimale"));
|
|
currGateway.updateItemNodeValue(vettPath[i].posAct_Y_Key, ((decimal)vettTTCoord.data2) / utils.CRI("fattdecimale"));
|
|
currGateway.updateItemNodeValue(vettPath[i].posAct_Z_Key, ((decimal)vettTTCoord.data3) / utils.CRI("fattdecimale"));
|
|
currGateway.updateItemNodeValue(vettPath[i].posAct_I_Key, ((decimal)vettTTCoord.c1) / utils.CRI("fattdecimale"));
|
|
currGateway.updateItemNodeValue(vettPath[i].posAct_J_Key, ((decimal)vettTTCoord.c2) / utils.CRI("fattdecimale"));
|
|
currGateway.updateItemNodeValue(vettPath[i].posAct_K_Key, "0"); // è 5 assi...nullo...
|
|
}
|
|
if (currGateway.protocollo != gwProtocol.SOURS)
|
|
{
|
|
// 2017.01.16 da rivedere
|
|
currGateway.updateItemNodeValue(vettPath[i].currProgRowNumKey, "");
|
|
currGateway.updateItemNodeValue(vettPath[i].activeAxesKey, "");
|
|
}
|
|
// 2019.09.18 aggiunta override feed e rapid path...
|
|
currGateway.updateItemNodeValue(vettPath[i].feedOverKey, FeedRateOver);
|
|
currGateway.updateItemNodeValue(vettPath[i].rapidOverKey, RapidOver);
|
|
|
|
|
|
sb_2.AppendLine(string.Format("Path {0}, PROG: {1}", i + 1, currGateway.getItemNode(vettPath[i].currProgKey)));
|
|
sb_3.AppendLine(string.Format("Path {0}, GCodes: {1}", i + 1, GCodAttivi));
|
|
|
|
sb_3.AppendLine(string.Format("Path {0}, Asse 1: {1:N3}", i + 1, ((decimal)vettTTCoord.data1) / utils.CRI("fattdecimale")));
|
|
sb_3.AppendLine(string.Format("Path {0}, Asse 2: {1:N3}", i + 1, ((decimal)vettTTCoord.data2) / utils.CRI("fattdecimale")));
|
|
sb_3.AppendLine(string.Format("Path {0}, Asse 3: {1:N3}", i + 1, ((decimal)vettTTCoord.data3) / utils.CRI("fattdecimale")));
|
|
sb_3.AppendLine(string.Format("Path {0}, Cent 1: {1:N3}", i + 1, ((decimal)vettTTCoord.c1) / utils.CRI("fattdecimale")));
|
|
sb_3.AppendLine(string.Format("Path {0}, Cent 2: {1:N3}", i + 1, ((decimal)vettTTCoord.c2) / utils.CRI("fattdecimale")));
|
|
|
|
parentForm.dataMonitor_2 += sb_2.ToString();
|
|
parentForm.dataMonitor_3 += sb_3.ToString();
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
/// Recupero codici G per path indicato (base 1!!!)
|
|
/// </summary>
|
|
/// <param name="numPath">Numero path (1..n)</param>
|
|
/// <returns></returns>
|
|
private string getCodGPath(int numPath)
|
|
{
|
|
// recupero vettore generale G MODE
|
|
parentForm.commPlcActive = true;
|
|
inizio = DateTime.Now;
|
|
// recupero!
|
|
CMSCncLib.Focas1.ODBGCD vettGCodes = FANUC_ref.getPathGCodeMod(numPath);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-GCodModal", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
parentForm.commPlcActive = false;
|
|
|
|
string GCodAttivi = "";
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd0.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd1.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd2.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd3.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd4.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd5.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd6.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd7.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd8.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd9.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd10.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd11.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd12.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd13.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd14.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd15.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd16.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd17.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd18.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd19.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd20.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd21.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd22.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd23.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd24.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd25.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd26.code);
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd27.code);
|
|
|
|
parentForm.commPlcActive = true;
|
|
inizio = DateTime.Now;
|
|
vettGCodes = FANUC_ref.getPathGCode1Shot(numPath);
|
|
parentForm.commPlcActive = false;
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-GCodOneShot", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
if (vettGCodes.gcd0.flag > 0)
|
|
{
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd0.code);
|
|
}
|
|
|
|
if (vettGCodes.gcd1.flag > 0)
|
|
{
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd1.code);
|
|
}
|
|
|
|
if (vettGCodes.gcd2.flag > 0)
|
|
{
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd2.code);
|
|
}
|
|
|
|
if (vettGCodes.gcd3.flag > 0)
|
|
{
|
|
GCodAttivi += string.Format("[{0}]", vettGCodes.gcd3.code);
|
|
}
|
|
|
|
return GCodAttivi;
|
|
}
|
|
/// <summary>
|
|
/// Recupera il vettore delle coordinate (base 1!!!)
|
|
/// </summary>
|
|
/// <param name="numPath">Numero path (1..n)</param>
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private CMSCncLib.Focas1.ODB5AXMAN getVettCoordPath(int numPath)
|
|
{
|
|
// 2017.12.27 gestione assi limitati --> non sono abilitate le funzioni 3D, quindi DISABILITO da conf...
|
|
CMSCncLib.Focas1.ODB5AXMAN vettTTCoord = new CMSCncLib.Focas1.ODB5AXMAN();
|
|
if (!utils.CRB("FanucLimit3D"))
|
|
{
|
|
parentForm.commPlcActive = true;
|
|
inizio = DateTime.Now;
|
|
vettTTCoord = FANUC_ref.getPathTTCoord(numPath);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-TTCoord", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
parentForm.commPlcActive = false;
|
|
}
|
|
|
|
return vettTTCoord;
|
|
}
|
|
|
|
public override void getAxis()
|
|
{
|
|
// mostro assi in DataMonitor......
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
// controllo se ho gestione path FANUC con COMB
|
|
bool isFanucPathComb = utils.CRB("FanucPathComb");
|
|
// processo le assegnazioni, partendo da quelle configurate "teoriche" da conf
|
|
int[] assegnazioni = new int[] { 1, 1, 1, 2, 2, 2 };
|
|
// ora rileggo da conf... se c'è...
|
|
string FanucAxPathAssign = utils.CRS("FanucAxPathAssign");
|
|
if (FanucAxPathAssign != "")
|
|
{
|
|
string[] valori = FanucAxPathAssign.Split(',');
|
|
for (int i = 0; i < valori.Length; i++)
|
|
{
|
|
int.TryParse(valori[i], out assegnazioni[i]);
|
|
}
|
|
}
|
|
|
|
// ora calcolo gli indici deli assi (1..N, NON zero based) sui 2 path
|
|
int[] iAxP1 = new int[] { 1, 2, 3, 4, 5, 6 }; // FIXME HARD CODED!!!
|
|
int[] iAxP2 = new int[] { 0, 0, 0, 4, 5, 6 }; ;
|
|
|
|
try
|
|
{
|
|
// se gestisco COMP + PATH fanuc faccio ragionamenti specifici...
|
|
if (isFanucPathComb)
|
|
{
|
|
/******************************************************
|
|
* Procedura x recupero assi <--> path
|
|
*
|
|
* parametro 981 --> assegnato come (1-2-3 al path1, 4-5-6 al path 2 oppure al path 1)
|
|
* 1 1 1 2 2 2
|
|
*
|
|
* devo guardare dove ho 2 (processo predisposto x variare 1..2)
|
|
*
|
|
*
|
|
* valori bitmap x capire SE processo migrato
|
|
* G1128 ed F1343
|
|
*
|
|
*
|
|
* leggo bit, se in AND sono 1 --> processo migrato
|
|
*
|
|
* e se i bit delle G1128 && F1343 sono 1 --> sono spostati di PROCESSO, e devo guardare quelli che saranno 1.2.3 del path 2...
|
|
*
|
|
******************************************************/
|
|
|
|
// per iniziare: devo capire quante siano le assegnazioni in ballo (conto i "2")
|
|
int numAxComp = 0;
|
|
int firstComp = 0;
|
|
foreach (var item in assegnazioni)
|
|
{
|
|
if (item == 1)
|
|
{
|
|
// solo se NON HO ancora assi COMP... incremento
|
|
if (numAxComp == 0) firstComp++;
|
|
}
|
|
else if (item == 2)
|
|
{
|
|
numAxComp++;
|
|
}
|
|
}
|
|
// leggo le conf delle variabili COMPOSITE impiegate...
|
|
byte bmapG1128 = 0;
|
|
FanucMemRW(R, FANUC.MemType.G, 1128, ref bmapG1128);
|
|
byte bmapF1343 = 0;
|
|
FanucMemRW(R, FANUC.MemType.F, 1343, ref bmapF1343);
|
|
|
|
// ora scorro il vettore iniziale e verifico dai bit le effettive assegnazioni...
|
|
int bitIdx = 0;
|
|
for (int i = 0; i < numAxComp; i++)
|
|
{
|
|
// controllo il bit...
|
|
if (baseUtils.IsSetBit(bmapG1128, bitIdx))
|
|
{
|
|
assegnazioni[firstComp + i] = 2;
|
|
}
|
|
else
|
|
{
|
|
assegnazioni[firstComp + i] = 1;
|
|
}
|
|
bitIdx++;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, "getAxis - 1");
|
|
}
|
|
|
|
|
|
// indice corrente dell'asse...
|
|
int axIdx = 0;
|
|
// ora leggo i vari path e procedo...
|
|
for (int iPath = 0; iPath < currAdpConf.nPath; iPath++)
|
|
{
|
|
int numAx4path = 0;
|
|
// controllo SE HO assi sul processo...
|
|
foreach (var item in assegnazioni)
|
|
{
|
|
if (item == iPath + 1)
|
|
{
|
|
numAx4path++;
|
|
}
|
|
}
|
|
|
|
// procedo SOLO SE HO degli assi su path corrente...
|
|
if (numAx4path > 0)
|
|
{
|
|
parentForm.commPlcActive = true;
|
|
inizio = DateTime.Now;
|
|
CMSCncLib.Focas1.ODBPOS posAssi = FANUC_ref.getAllAxisPos(iPath + 1);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-AXIS_POS", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
inizio = DateTime.Now;
|
|
CMSCncLib.Focas1.ODBSVLOAD loadAssi = FANUC_ref.getAllAxisLoad(iPath + 1);
|
|
if (utils.CRB("recTime"))
|
|
{
|
|
TimingData.addResult("R-AXIS_LOAD", DateTime.Now.Subtract(inizio).Ticks);
|
|
}
|
|
|
|
parentForm.commPlcActive = false;
|
|
|
|
CMSCncLib.Focas1.LOADELM valLoad = new CMSCncLib.Focas1.LOADELM();
|
|
CMSCncLib.Focas1.POSELMALL valPos = new CMSCncLib.Focas1.POSELMALL();
|
|
|
|
// nuova posizione (per calcoli)
|
|
double newPos = 0;
|
|
double distPerc = 0;
|
|
int newDir = 0;
|
|
string direzione = "";
|
|
|
|
|
|
// indice effettivo dell'asse i-esimo (i < currAdpConf.nAxis) su cui ciclare in base ad assegnazioni
|
|
int axPathIdx = -1;
|
|
int i = 0;
|
|
int shiftAssi = axIdx > 0 ? axIdx + 1 : 0;
|
|
// ciclo x gli assi configurati, tra il TOTALE assi e quelli inseriti sul processo
|
|
//for (int i = 0; i < currAdpConf.nAxis; i++)
|
|
int numStart = shiftAssi; // axIdx;
|
|
int numEnd = numStart + numAx4path;
|
|
for (int nAx = numStart; nAx < numEnd; nAx++)
|
|
{
|
|
try
|
|
{
|
|
// devo verificare SE il mio attuale PATH abbia assi configurati con COMB
|
|
axPathIdx = Array.IndexOf(assegnazioni, iPath + 1, nAx);
|
|
// se trovato --> è indice asse, sennò NON lo aggiorno...
|
|
if (axPathIdx >= 0)
|
|
{
|
|
axIdx = axPathIdx;
|
|
if (iPath == 0)
|
|
{
|
|
i = iAxP1[axPathIdx] - 1 >= 0 ? iAxP1[axPathIdx] - 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
i = iAxP2[axPathIdx] - 1 >= 0 ? iAxP2[axPathIdx] - 1 : 0;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, "getAxis - 2");
|
|
}
|
|
// per sicurezza try-catch
|
|
try
|
|
{
|
|
if (axIdx >= shiftAssi)
|
|
{
|
|
readValuesForAxis(axIdx - shiftAssi, posAssi, loadAssi, out valLoad, out valPos);
|
|
|
|
// popolo valori...
|
|
currGateway.updateItemNodeValue(vettAxis[i].loadKey, valLoad.data / Math.Pow(10, valLoad.dec));
|
|
newPos = valPos.abs.data / Math.Pow(10, valPos.abs.dec);
|
|
currGateway.updateItemNodeValue(vettAxis[i].posActKey, newPos);
|
|
currGateway.updateItemNodeValue(vettAxis[i].posTgtKey, newPos + valPos.dist.data / Math.Pow(10, valPos.dist.dec));
|
|
// se ho FeedRatePath --> uso quello
|
|
if (FeedRatePath.Length > 1)
|
|
{
|
|
currGateway.updateItemNodeValue(vettAxis[i].feedrateKey, FeedRatePath[iPath]);
|
|
currGateway.updateItemNodeValue(vettAxis[i].feedOverKey, FeedRateOverPath[iPath]);
|
|
}
|
|
else
|
|
{
|
|
currGateway.updateItemNodeValue(vettAxis[i].feedrateKey, FeedRate);
|
|
currGateway.updateItemNodeValue(vettAxis[i].feedOverKey, FeedRateOver);
|
|
}
|
|
// 2019.08.05 aggiungo NOME asse + path master...
|
|
string axName = Convert.ToChar(valLoad.name).ToString();
|
|
// se ho suffisso aggiungo...
|
|
if (valLoad.suff1 > 0)
|
|
{
|
|
axName += Convert.ToChar(valLoad.suff1);
|
|
}
|
|
currGateway.updateItemNodeValue(vettAxis[i].descriptionKey, axName);
|
|
// 2019.08.30 fix x calcolo processo esatto, MAYBE
|
|
currGateway.updateItemNodeValue(vettAxis[i].mainProcKey, i + 1);
|
|
//currGateway.updateItemNodeValue(vettAxis[i].mainProcKey, iPath + 1);
|
|
|
|
// calcolo distanza e salvo valore...
|
|
distPerc = newPos - prevPosAxis[i];
|
|
|
|
// sistemo direzione +/- (POS/NEG se lineari, CCW/CW se rotativi)
|
|
if (distPerc != 0)
|
|
{
|
|
newDir = Convert.ToInt32(distPerc / Math.Abs(distPerc));
|
|
}
|
|
else
|
|
{
|
|
newDir = prevDirAxis[i];
|
|
}
|
|
// calcolo direzione
|
|
direzione = calculateDirection(newDir, i);
|
|
// imposto direzione
|
|
currGateway.updateItemNodeValue(vettAxis[i].directionKey, direzione);
|
|
|
|
if (utils.CRB("verbose"))
|
|
{
|
|
sb.AppendLine(string.Format("Asse {0}: PosAct:{1:N3}, ToGo:{2:N3}{3} | {4}", valPos.abs.name, valPos.abs.data / Math.Pow(10, valPos.abs.dec), valPos.dist.name, valPos.dist.data / Math.Pow(10, valPos.dist.dec), direzione));
|
|
}
|
|
|
|
// salvo valori vettore prec...
|
|
prevPosAxis[i] = newPos;
|
|
prevDirAxis[i] = newDir;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, string.Format("Errore in lettura asse {0}", i));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
// update visualizzazione
|
|
parentForm.dataMonitor_3 += sb.ToString();
|
|
}
|
|
/// <summary>
|
|
/// Recupera info x l'asse corrente (base 0, letto per processo...)
|
|
/// </summary>
|
|
/// <param name="axIdx">idx asse base 0</param>
|
|
/// <param name="posAssi">vettore valori posizionali</param>
|
|
/// <param name="loadAssi">vettore carichi</param>
|
|
/// <param name="valLoad">valore carico attuale</param>
|
|
/// <param name="valPos">valore posizione attuale</param>
|
|
private static void readValuesForAxis(int axIdx, CMSCncLib.Focas1.ODBPOS posAssi, CMSCncLib.Focas1.ODBSVLOAD loadAssi, out CMSCncLib.Focas1.LOADELM valLoad, out CMSCncLib.Focas1.POSELMALL valPos)
|
|
{
|
|
// in base a indice scelgo valore posizione e load
|
|
switch (axIdx)
|
|
{
|
|
case 0:
|
|
valPos = posAssi.p1;
|
|
valLoad = loadAssi.svload1;
|
|
break;
|
|
case 1:
|
|
valPos = posAssi.p2;
|
|
valLoad = loadAssi.svload2;
|
|
break;
|
|
case 2:
|
|
valPos = posAssi.p3;
|
|
valLoad = loadAssi.svload3;
|
|
break;
|
|
case 3:
|
|
valPos = posAssi.p4;
|
|
valLoad = loadAssi.svload4;
|
|
break;
|
|
case 4:
|
|
valPos = posAssi.p5;
|
|
valLoad = loadAssi.svload5;
|
|
break;
|
|
case 5:
|
|
valPos = posAssi.p6;
|
|
valLoad = loadAssi.svload6;
|
|
break;
|
|
case 6:
|
|
valPos = posAssi.p7;
|
|
valLoad = loadAssi.svload7;
|
|
break;
|
|
case 7:
|
|
valPos = posAssi.p8;
|
|
valLoad = loadAssi.svload8;
|
|
break;
|
|
case 8:
|
|
valPos = posAssi.p9;
|
|
valLoad = loadAssi.svload9;
|
|
break;
|
|
case 9:
|
|
valPos = posAssi.p10;
|
|
valLoad = loadAssi.svload10;
|
|
break;
|
|
case 10:
|
|
valPos = posAssi.p11;
|
|
valLoad = loadAssi.svload11;
|
|
break;
|
|
case 11:
|
|
valPos = posAssi.p12;
|
|
valLoad = loadAssi.svload12;
|
|
break;
|
|
case 12:
|
|
valPos = posAssi.p13;
|
|
valLoad = loadAssi.svload13;
|
|
break;
|
|
case 13:
|
|
valPos = posAssi.p14;
|
|
valLoad = loadAssi.svload14;
|
|
break;
|
|
case 14:
|
|
valPos = posAssi.p15;
|
|
valLoad = loadAssi.svload15;
|
|
break;
|
|
case 15:
|
|
valPos = posAssi.p16;
|
|
valLoad = loadAssi.svload16;
|
|
break;
|
|
case 16:
|
|
valPos = posAssi.p17;
|
|
valLoad = loadAssi.svload17;
|
|
break;
|
|
case 17:
|
|
valPos = posAssi.p18;
|
|
valLoad = loadAssi.svload18;
|
|
break;
|
|
case 18:
|
|
valPos = posAssi.p19;
|
|
valLoad = loadAssi.svload19;
|
|
break;
|
|
case 19:
|
|
valPos = posAssi.p20;
|
|
valLoad = loadAssi.svload20;
|
|
break;
|
|
case 20:
|
|
valPos = posAssi.p21;
|
|
valLoad = loadAssi.svload21;
|
|
break;
|
|
case 21:
|
|
valPos = posAssi.p22;
|
|
valLoad = loadAssi.svload22;
|
|
break;
|
|
case 22:
|
|
valPos = posAssi.p23;
|
|
valLoad = loadAssi.svload23;
|
|
break;
|
|
case 23:
|
|
valPos = posAssi.p24;
|
|
valLoad = loadAssi.svload24;
|
|
break;
|
|
case 24:
|
|
valPos = posAssi.p25;
|
|
valLoad = loadAssi.svload25;
|
|
break;
|
|
case 25:
|
|
valPos = posAssi.p26;
|
|
valLoad = loadAssi.svload26;
|
|
break;
|
|
case 26:
|
|
valPos = posAssi.p27;
|
|
valLoad = loadAssi.svload27;
|
|
break;
|
|
case 27:
|
|
valPos = posAssi.p28;
|
|
valLoad = loadAssi.svload28;
|
|
break;
|
|
case 28:
|
|
valPos = posAssi.p29;
|
|
valLoad = loadAssi.svload29;
|
|
break;
|
|
case 29:
|
|
valPos = posAssi.p30;
|
|
valLoad = loadAssi.svload30;
|
|
break;
|
|
case 30:
|
|
valPos = posAssi.p31;
|
|
valLoad = loadAssi.svload31;
|
|
break;
|
|
case 31:
|
|
valPos = posAssi.p32;
|
|
valLoad = loadAssi.svload32;
|
|
break;
|
|
default:
|
|
// 2017.03.01 suggerimento Fabio: in CMS_FANUC in advanced compiler options mettere FS30D=1,SIEMENS=1 x leggere + assi?!?
|
|
valPos = posAssi.p1;
|
|
valLoad = loadAssi.svload1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|