1094 lines
42 KiB
C#
Executable file
1094 lines
42 KiB
C#
Executable file
using System;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Diagnostics;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace FanucProgramManager
|
|
{
|
|
class FANUCMachine
|
|
{
|
|
private static string get_cnc_path(int path = 1)
|
|
{
|
|
return "//CNC_MEM/USER/PATH" + path.ToString() + "/";
|
|
}
|
|
/// <summary>
|
|
/// Parametri connessione
|
|
/// </summary>
|
|
|
|
private string Name;
|
|
private string IPAddress; //IP ethernet
|
|
private string Port; //Port ethernet
|
|
private int Node; //nodo HSSB per connessione si tipo allclibhndl2
|
|
private int ReadTime;
|
|
private int ConnectionType;
|
|
private Boolean compatibiltyMode;
|
|
|
|
|
|
|
|
public bool CONNECTED;
|
|
private string ConnectionStatus { get; set; }
|
|
|
|
public bool ConnectionRequest;
|
|
short[] ret_array = new short[11] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
// valore di ritorno della funzioni richiamate dalle librerie FOCAS, in generale se ret == 0
|
|
// la funzione e' terminata senza errori
|
|
// in ordine nell'array:
|
|
// 0 -> connect
|
|
// 1 -> disconnect
|
|
// 2 -> cicle time
|
|
// 3 -> pieces counter
|
|
// 4 -> alarm messages
|
|
// 5 -> operator messages
|
|
// 6 -> machine state
|
|
// 7 -> main program
|
|
// 8 -> comment program
|
|
// 9 -> download
|
|
// 10 -> upload
|
|
|
|
ushort hndl; // handle di comunicazione: questo valore viene scritto una volta eseguita la connessione
|
|
// questo valore si passa come riferimento ad ogni funzione focas e rappresenta i
|
|
// parametri di connessione
|
|
|
|
private string FOCAS_ERRORS = "";
|
|
private string machine_status = "";
|
|
|
|
/// <summary>
|
|
/// Strutture per la lettura dati da controlli FANUC.
|
|
/// </summary>
|
|
|
|
// Strutture per tempo ciclo e contapezzi
|
|
Focas1.IODBPSD cicloMSp1 = new Focas1.IODBPSD();
|
|
Focas1.IODBPSD ciclo2MINp1 = new Focas1.IODBPSD();
|
|
Focas1.IODBPSD ContaPezzip1 = new Focas1.IODBPSD(); // struttura dati per memorizzazione contapezzi path 1
|
|
private string StrContaPezzip1;
|
|
private string StrTempoCiclop1;
|
|
// Strutture per nome programma
|
|
Focas1.PRGDIR3 info_prg = new Focas1.PRGDIR3();
|
|
Focas1.ODBPRO prognum = new Focas1.ODBPRO();
|
|
private string NomeProgrammaISO;
|
|
private string NomeSubProgrammaISO;
|
|
private string CommentoProgrammaISO;
|
|
// Strutture per allarmi
|
|
private string[] AlarmMessage = new string[17];
|
|
// Strutture per messaggi operatore
|
|
private string[] OperatorMessage = new string[17];
|
|
// Strutture per stati
|
|
Focas1.ODBST odbst = new Focas1.ODBST();
|
|
|
|
|
|
//Strutture per letture range di dati pmc
|
|
Focas1.IODBPMC0 iodbpmcByte = new Focas1.IODBPMC0(); // 8 Bit
|
|
Focas1.IODBPMC1 iodbpmcShort = new Focas1.IODBPMC1(); // 16 Bit
|
|
Focas1.IODBPMC2 iodbpmcInt = new Focas1.IODBPMC2(); //32bit
|
|
//relative al contapezzi
|
|
|
|
short CPMacroPiecesCounter = -1; //Variabile macro dove viene aggiornato il contapezzi #500 a #999 memria ritentiva
|
|
short CPMacroLength = 1; //quante variabili macro leggere
|
|
short CPlength = 4; //numero di byte scelto in CPdata_type (X)
|
|
//short CPdata_type = 2; // 0 Byte (1), 1 Short(2), 2 int (4)
|
|
//ushort CPStart;
|
|
|
|
|
|
|
|
|
|
public string GetFocasErrorsBuffer()
|
|
{
|
|
string errorBuffer = FOCAS_ERRORS;
|
|
FOCAS_ERRORS = "";
|
|
return errorBuffer;
|
|
}
|
|
|
|
|
|
public string GetStatus()
|
|
{
|
|
return machine_status;
|
|
}
|
|
|
|
public string GetNomeProgramma()
|
|
{
|
|
if (NomeProgrammaISO == null)
|
|
{
|
|
return "null";
|
|
}
|
|
else
|
|
return NomeProgrammaISO;
|
|
}
|
|
|
|
public string GetSubProgramma()
|
|
{
|
|
if (NomeSubProgrammaISO == null)
|
|
{
|
|
return "null";
|
|
}
|
|
else
|
|
return NomeSubProgrammaISO;
|
|
}
|
|
|
|
public string GetCommentoProgramma()
|
|
{
|
|
if (CommentoProgrammaISO == null)
|
|
{
|
|
return "Commento Assente";
|
|
}
|
|
else
|
|
return CommentoProgrammaISO;
|
|
}
|
|
|
|
public string[] GetAlarmMessage()
|
|
{
|
|
return AlarmMessage;
|
|
}
|
|
|
|
public string[] GetOperatorMessage()
|
|
{
|
|
return OperatorMessage;
|
|
}
|
|
|
|
public string GetStrContaPezzip1()
|
|
{
|
|
if (StrContaPezzip1 == null)
|
|
{
|
|
return "0";
|
|
}
|
|
else
|
|
return StrContaPezzip1;
|
|
}
|
|
|
|
public string GetStrTempoCiclop1()
|
|
{
|
|
if (StrTempoCiclop1 == null)
|
|
{
|
|
return "null";
|
|
}
|
|
else
|
|
return StrTempoCiclop1;
|
|
}
|
|
|
|
public string GetName()
|
|
{
|
|
if (Name == null)
|
|
{
|
|
return "null";
|
|
}
|
|
else
|
|
return Name;
|
|
}
|
|
|
|
public ushort GetHandle()
|
|
{
|
|
return hndl;
|
|
}
|
|
|
|
private string getFocasFunctionName(short index)
|
|
{
|
|
string functionName = "";
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
functionName = "connect";
|
|
break;
|
|
case 1:
|
|
functionName = "disconnect";
|
|
break;
|
|
case 2:
|
|
functionName = "cicle time";
|
|
break;
|
|
case 3:
|
|
functionName = "pieces counter";
|
|
break;
|
|
case 4:
|
|
functionName = "alarm messages";
|
|
break;
|
|
case 5:
|
|
functionName = "operator messages";
|
|
break;
|
|
case 6:
|
|
functionName = "machine state";
|
|
break;
|
|
case 7:
|
|
functionName = "main program and comment";
|
|
break;
|
|
case 8:
|
|
functionName = "download";
|
|
break;
|
|
case 9:
|
|
functionName = "upload";
|
|
break;
|
|
}
|
|
return functionName;
|
|
}
|
|
|
|
public FANUCMachine(string name, string ipaddress, string port, Boolean compatibiltyMode, int readtime, int connectiontype, int MacroPiecesCounter)
|
|
{
|
|
this.Name = name;
|
|
this.IPAddress = ipaddress;
|
|
this.Port = port;
|
|
this.compatibiltyMode = compatibiltyMode;
|
|
this.Node = -1;
|
|
this.ConnectionStatus = "Not Connected";
|
|
this.ConnectionRequest = false;
|
|
this.NomeProgrammaISO = "";
|
|
this.NomeSubProgrammaISO = "";
|
|
this.ReadTime = readtime;
|
|
this.ConnectionType = connectiontype;
|
|
this.ConnectionRequest = true;
|
|
this.CONNECTED = false;
|
|
this.CPMacroPiecesCounter = (short)MacroPiecesCounter;
|
|
}
|
|
|
|
public FANUCMachine(string name, int node, Boolean compatibiltyMode, int readtime, int connectiontype, int MacroPiecesCounter) //Per controlli HSSB
|
|
{
|
|
this.Name = name;
|
|
this.IPAddress = null;
|
|
this.Port = null;
|
|
this.compatibiltyMode = compatibiltyMode;
|
|
this.Node = node; //il paramatro node serve solo nel caso connectiontype = 2 altrimenti puo essere messo a 0
|
|
this.ConnectionStatus = "Not Connected";
|
|
this.ConnectionRequest = false;
|
|
this.NomeProgrammaISO = "";
|
|
this.NomeSubProgrammaISO = "";
|
|
this.ReadTime = readtime;
|
|
this.ConnectionType = connectiontype;
|
|
this.ConnectionRequest = true;
|
|
this.CONNECTED = false;
|
|
this.CPMacroPiecesCounter = (short)MacroPiecesCounter;
|
|
}
|
|
|
|
private short readCicleTime()
|
|
{
|
|
// read cycle time
|
|
short time_ret = 0;
|
|
//millisecondi
|
|
time_ret = Focas1.cnc_rdparam(hndl, 6757, 0, 8, cicloMSp1);
|
|
//minuti
|
|
time_ret = (short)(time_ret + Focas1.cnc_rdparam(hndl, 6758, 0, 8, ciclo2MINp1));
|
|
StrTempoCiclop1 = ciclo2MINp1.u.ldata.ToString() + " minuti : " + (cicloMSp1.u.ldata / 1000).ToString() + " secondi";
|
|
return time_ret;
|
|
}
|
|
private short readAlarmMessages()
|
|
{
|
|
// Dati di stato macchina
|
|
// Allarmi
|
|
short num_alm = 17;
|
|
short almmsg_ret = -1;
|
|
|
|
if (compatibiltyMode)
|
|
{
|
|
Focas1.ODBALMMSG_data_custom[] alm = new Focas1.ODBALMMSG_data_custom[17];
|
|
almmsg_ret = Focas1.cnc_rdalmmsg_custom(hndl, 0, ref num_alm, alm);
|
|
for (int i = 0; i < num_alm; i++)
|
|
{
|
|
AlarmMessage[i] = "";
|
|
if (alm[i].msg_len > 0)
|
|
AlarmMessage[i] = alm[i].alm_msg;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Plese use cnc_rdalmmsg2 fucntion for Series 30i/31i/32i, 0i-D/F and PMi-A.
|
|
Focas1.ODBALMMSG2_data_custom[] alm = new Focas1.ODBALMMSG2_data_custom[17];
|
|
almmsg_ret = Focas1.cnc_rdalmmsg2_custom(hndl, -1, ref num_alm, alm);
|
|
for (int i = 0; i < num_alm; i++)
|
|
{
|
|
AlarmMessage[i] = "";
|
|
if (alm[i].msg_len > 0)
|
|
AlarmMessage[i] = alm[i].alm_msg;
|
|
}
|
|
}
|
|
return almmsg_ret;
|
|
}
|
|
|
|
private short readOperatorMessages()
|
|
{
|
|
// Messaggi operatore
|
|
short num_alm = 1;
|
|
short opmsg_ret = 0;
|
|
Focas1.OPMSG3_data_custom[] opmsg = new Focas1.OPMSG3_data_custom[17];
|
|
opmsg_ret = Focas1.cnc_rdopmsg3_custom(hndl, 4, ref num_alm, opmsg);
|
|
for (int i = 0; i < num_alm; i++)
|
|
{
|
|
OperatorMessage[i] = "";
|
|
if (opmsg[i].char_num > 0)
|
|
OperatorMessage[i] = opmsg[i].data;
|
|
}
|
|
return opmsg_ret;
|
|
}
|
|
|
|
private short readMachineState()
|
|
{
|
|
// Stati macchina
|
|
short state_ret = Focas1.cnc_statinfo(hndl, odbst);
|
|
if (state_ret == Focas1.EW_OK)
|
|
{
|
|
machine_status = "";
|
|
|
|
switch (odbst.aut)
|
|
{
|
|
case 0:
|
|
machine_status += "MDI -";
|
|
break;
|
|
case 1:
|
|
machine_status += "AUTO -";
|
|
break;
|
|
case 3:
|
|
machine_status += "EDIT -";
|
|
break;
|
|
case 4:
|
|
machine_status += "HNDL -";
|
|
break;
|
|
case 5:
|
|
machine_status += "JOG -";
|
|
break;
|
|
default:
|
|
machine_status += "**** -";
|
|
break;
|
|
}
|
|
|
|
if (odbst.aut != 3)
|
|
{
|
|
ret_array[7] = readMainProgram();
|
|
ret_array[8] = readMainProgramComment();
|
|
}
|
|
|
|
machine_status += " ";
|
|
|
|
switch (odbst.run)
|
|
{
|
|
case 1:
|
|
machine_status += "STOP - ";
|
|
break;
|
|
case 3:
|
|
machine_status += "ESEC ISO - ";
|
|
break;
|
|
|
|
default:
|
|
machine_status += " **** - ";
|
|
break;
|
|
}
|
|
|
|
machine_status += " ";
|
|
|
|
switch (odbst.motion)
|
|
{
|
|
case 1:
|
|
machine_status += "IN MOVIMENTO - ";
|
|
break;
|
|
case 2:
|
|
machine_status += "PAUSA - ";
|
|
break;
|
|
|
|
default:
|
|
machine_status += "*** - ";
|
|
break;
|
|
}
|
|
|
|
machine_status += " ";
|
|
|
|
switch (odbst.mstb)
|
|
{
|
|
case 1:
|
|
machine_status += "FIN - ";
|
|
break;
|
|
default:
|
|
machine_status += "*** - ";
|
|
break;
|
|
}
|
|
|
|
machine_status += " ";
|
|
|
|
switch (odbst.emergency)
|
|
{
|
|
case 1:
|
|
machine_status += "EMERGENZA -";
|
|
break;
|
|
case 2:
|
|
machine_status += "RST -";
|
|
break;
|
|
default:
|
|
machine_status += "*** -";
|
|
break;
|
|
}
|
|
|
|
machine_status += " ";
|
|
|
|
switch (odbst.alarm)
|
|
{
|
|
case 1:
|
|
machine_status += "ALM";
|
|
break;
|
|
default:
|
|
machine_status += "***";
|
|
break;
|
|
}
|
|
}
|
|
return state_ret;
|
|
}
|
|
|
|
public short readMainProgram()
|
|
{
|
|
short program_ret = 0;
|
|
Focas1.ODBPRO prog_num = new Focas1.ODBPRO();
|
|
// nome programma
|
|
program_ret = Focas1.cnc_rdprgnum(hndl, prog_num);
|
|
NomeSubProgrammaISO = "O" + prog_num.data.ToString();
|
|
NomeProgrammaISO = "O" + prog_num.mdata.ToString();
|
|
if (!compatibiltyMode)
|
|
{
|
|
byte[] nome_main = new byte[242];
|
|
// nome programma
|
|
program_ret = Focas1.cnc_pdf_rdmain(hndl, nome_main);
|
|
string str_main = ASCIIEncoding.ASCII.GetString(nome_main).TrimEnd('\0');
|
|
string[] words = str_main.Split('/');
|
|
int indiceUltimoElemento = words.Length - 1;
|
|
if (NomeProgrammaISO != words[indiceUltimoElemento])
|
|
NomeProgrammaISO = words[indiceUltimoElemento];
|
|
}
|
|
return program_ret;
|
|
}
|
|
|
|
public short readMainProgramComment()
|
|
{
|
|
short program_ret = 0;
|
|
string[] words;
|
|
byte[] alpha_comment = new byte[100];
|
|
if (compatibiltyMode)
|
|
{
|
|
ushort caratteriDaLeggere = 100;
|
|
program_ret = Focas1.cnc_rdexecprog(hndl, ref caratteriDaLeggere, out short blknumber, alpha_comment);
|
|
}
|
|
else
|
|
{
|
|
uint lunghezza = 100; //va lasciato qui perche' viene riscritto ogni volta da "cnc_rdpdf_line"
|
|
uint numero_righe = 1; //va lasciato qui perche' viene riscritto ogni volta da "cnc_rdpdf_line"
|
|
byte[] nome_main = new byte[242];
|
|
program_ret = Focas1.cnc_pdf_rdmain(hndl, nome_main);
|
|
string str_main = ASCIIEncoding.ASCII.GetString(nome_main).TrimEnd('\0');
|
|
program_ret = Focas1.cnc_rdpdf_line(hndl, str_main, 0, alpha_comment, ref numero_righe, ref lunghezza);
|
|
}
|
|
string str_alpha_comment = ASCIIEncoding.ASCII.GetString(alpha_comment).TrimEnd('\0');
|
|
// caso commento presente
|
|
if (str_alpha_comment.Contains("("))
|
|
{
|
|
words = str_alpha_comment.Split('(', ')');
|
|
int indiceUltimoElemento = words.Length - 2;
|
|
//CommentoProgrammaISO = '(' + words[indiceUltimoElemento] + ')';
|
|
int open_index = str_alpha_comment.IndexOf('(');
|
|
int close_index = str_alpha_comment.IndexOf(')');
|
|
if (open_index > 0)
|
|
{
|
|
CommentoProgrammaISO = str_alpha_comment.Substring(open_index + 1, close_index - open_index - 1);
|
|
}
|
|
}
|
|
// caso di programma senza commento
|
|
else
|
|
{
|
|
// CommentoProgrammaISO = '(' + NomeProgrammaISO + ')';
|
|
CommentoProgrammaISO = "Commento Assente";
|
|
}
|
|
return program_ret;
|
|
}
|
|
|
|
public void Read()
|
|
{
|
|
// leggo i dati
|
|
|
|
// Dati di produzione
|
|
// path 1
|
|
Focas1.cnc_setpath(hndl, 1);
|
|
short a, b;
|
|
Focas1.cnc_getpath(hndl, out a, out b);
|
|
|
|
ret_array[2] = readCicleTime();
|
|
ret_array[3] = readContaPezzi();
|
|
ret_array[4] = readAlarmMessages();
|
|
ret_array[5] = readOperatorMessages();
|
|
ret_array[6] = readMachineState();
|
|
|
|
CheckErrors(ret_array);
|
|
|
|
}
|
|
|
|
public void Connect()
|
|
{
|
|
//Thread.Sleep(500);
|
|
if (ConnectionRequest)
|
|
{
|
|
if (!CONNECTED && ConnectionType == 3)
|
|
{
|
|
// apro il canale di comunicazione verso la macchina
|
|
short timeout = 4; //sec
|
|
ret_array[0] = Focas1.cnc_allclibhndl3(IPAddress, Convert.ToUInt16(Port), timeout, out hndl);
|
|
}
|
|
else if (!CONNECTED && ConnectionType == 0)
|
|
{
|
|
ret_array[0] = Focas1.cnc_allclibhndl(out hndl);
|
|
}
|
|
else if (!CONNECTED && ConnectionType == 2)
|
|
{
|
|
ret_array[0] = Focas1.cnc_allclibhndl2(Node, out hndl);
|
|
}
|
|
if (ret_array[0] == 0)
|
|
{
|
|
// abilito il timer: comincio a fare il refresh dei dati su Cn e Robot
|
|
CONNECTED = true;
|
|
machine_status = "CONNECTED";
|
|
ConnectionRequest = false;
|
|
}
|
|
else
|
|
{
|
|
ConnectionRequest = true;
|
|
CONNECTED = false;
|
|
machine_status = "DISCONNECTED";
|
|
CheckErrors(ret_array);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Disconnect()
|
|
{
|
|
ret_array[1] = Focas1.cnc_freelibhndl(hndl);
|
|
if (ret_array[1] == 0)
|
|
{
|
|
ConnectionRequest = true;
|
|
CONNECTED = false;
|
|
machine_status = "DISCONNECTED";
|
|
}
|
|
resetMachineRet();
|
|
}
|
|
|
|
private void resetMachineRet()
|
|
{
|
|
for (short index = 0; index < ret_array.Length; index++)
|
|
{
|
|
ret_array[index] = 0;
|
|
}
|
|
}
|
|
|
|
private void CheckErrors(short[] error)
|
|
{
|
|
FOCAS_ERRORS = "";
|
|
bool disconnect = false;
|
|
for (short index = 0; index < error.Length; index++)
|
|
{
|
|
string focas_function = getFocasFunctionName(index);
|
|
switch (error[index])
|
|
{
|
|
case (short)Focas1.focas_ret.EW_PROTOCOL: /* protocol error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "protocol error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_SOCKET: /* Windows socket error */
|
|
disconnect = CONNECTED;
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "windows socket error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_NODLL: /* DLL not exist error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "DLL not exist error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_BUS: /* bus error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "bus error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_SYSTEM2: /* system error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "system error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_HSSB: /* hssb communication error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " hssb communication error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_HANDLE: /* Windows library handle error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " Windows library handle error" + " in " + focas_function + "\n";
|
|
disconnect = CONNECTED;
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_VERSION: /* CNC/PMC version missmatch */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " CNC/PMC version missmatch" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_UNEXP: /* abnormal error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "abnormal error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_SYSTEM: /* system error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " system error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_PARITY: /* shared RAM parity error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "shared RAM parity error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_MMCSYS: /* emm386 or mmcsys install error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "emm386 or mmcsys install error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_RESET: /* reset or stop occured error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "reset or stop occured error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_BUSY: /* busy error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "busy error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_OK: /* no problem */
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_FUNC: /* command prepare error --or-- pmc not exist */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "command prepare error --or-- pmc not exist" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_LENGTH: /* data block length error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "data block length error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_NUMBER: /* data number error --or-- address range error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "data number error --or-- address range error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_ATTRIB: /* data attribute error --or-- data type error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "data attribute error --or-- data type error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_DATA: /* data error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "data error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_NOOPT: /* no option error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "no option error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_PROT: /* write protect error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "write protect error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_OVRFLOW: /* memory overflow error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "memory overflow error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_PARAM: /* cnc parameter not correct error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "cnc parameter not correct error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_BUFFER: /* buffer error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " buffer error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_PATH: /* path error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "path error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_MODE: /* cnc mode error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "cnc mode error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_REJECT: /* execution rejected error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "execution rejected error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_DTSRVR: /* data server error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " data server error" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_ALARM: /* alarm has been occurred */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + "alarm has been occurred" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_STOP: /* CNC is not running */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " CNC is not running" + " in " + focas_function + "\n";
|
|
break;
|
|
case (short)Focas1.focas_ret.EW_PASSWD: /* protection data error */
|
|
FOCAS_ERRORS += "Error " + error[index] + ": " + " protection data error" + " in " + focas_function + "\n";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (FOCAS_ERRORS == "")
|
|
{
|
|
FOCAS_ERRORS = "OK";
|
|
}
|
|
if (disconnect)
|
|
{
|
|
Disconnect();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private short readContaPezzi()
|
|
{
|
|
short pieces_ret = 0;
|
|
try
|
|
{
|
|
if (CPMacroPiecesCounter == -1)
|
|
{
|
|
// Conta pezzi
|
|
pieces_ret = Focas1.cnc_rdparam(hndl, 6711, 0, 8, ContaPezzip1);
|
|
StrContaPezzip1 = ContaPezzip1.u.ldata.ToString();
|
|
}
|
|
else
|
|
{
|
|
CPlength = (short)(8 + 8 * 1);
|
|
Focas1.ODBM macro = new Focas1.ODBM();
|
|
pieces_ret = Focas1.cnc_rdmacro(hndl, CPMacroPiecesCounter, 10, macro);
|
|
if (pieces_ret == Focas1.EW_OK)
|
|
{
|
|
StrContaPezzip1 = string.Format("{0:d9}", Math.Abs(macro.mcr_val));
|
|
if (0 < macro.dec_val) StrContaPezzip1 = StrContaPezzip1.Insert(9 - macro.dec_val, ".");
|
|
if (macro.mcr_val < 0) StrContaPezzip1 = "-" + StrContaPezzip1;
|
|
int index = StrContaPezzip1.IndexOf(".");
|
|
if (index >= 0)
|
|
StrContaPezzip1 = StrContaPezzip1.Substring(0, index);
|
|
Console.WriteLine("{0}", StrContaPezzip1);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("ERR-READ-MACRO**********");
|
|
}
|
|
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
StrContaPezzip1 = "Errore Contapezzi";
|
|
}
|
|
return pieces_ret;
|
|
}
|
|
|
|
private void DownloadStd(short cnc_path = 1)
|
|
{
|
|
var PROG_MEMORY_PATH = get_cnc_path(cnc_path);
|
|
int num;
|
|
int len;
|
|
string program = "%\n<OSTD>\n%";
|
|
|
|
if (CONNECTED)
|
|
{
|
|
ret_array[9] = Focas1.cnc_pdf_del(hndl, PROG_MEMORY_PATH + "OSTD");
|
|
|
|
try
|
|
{
|
|
|
|
|
|
ret_array[9] = Focas_StartNCFileDownload(PROG_MEMORY_PATH, FanucProgram.FILE_TYPE.CNC_PROGRAM);
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
Focas_EndNCFileDownload();
|
|
ret_array[9] = ret_array[9];
|
|
CheckErrors(ret_array);
|
|
return;
|
|
}
|
|
|
|
len = program.Length;
|
|
int startPos = 0;
|
|
|
|
while (len > 0)
|
|
{
|
|
if (len >= 1024)
|
|
{
|
|
num = 1024;
|
|
}
|
|
else
|
|
{
|
|
num = len;
|
|
}
|
|
char[] prg_temp = new char[num];
|
|
program.CopyTo(startPos, prg_temp, 0, num);
|
|
|
|
ret_array[9] = Focas_NCFileDownload(ref num, prg_temp);
|
|
if (ret_array[9] == (short)Focas1.focas_ret.EW_BUFFER)
|
|
{
|
|
Thread.Sleep(100);
|
|
continue;
|
|
}
|
|
if (ret_array[9] == Focas1.EW_OK)
|
|
{
|
|
startPos += num;
|
|
len -= num;
|
|
}
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
Focas1.ODBERR odd = new Focas1.ODBERR();
|
|
Focas1.cnc_getdtailerr(hndl, odd);
|
|
Debug.WriteLine(odd.err_no + " " + odd.err_dtno);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
Focas_EndNCFileDownload();
|
|
CheckErrors(ret_array);
|
|
return;
|
|
}
|
|
|
|
Focas_EndNCFileDownload();
|
|
Focas1.ODBERR odd2 = new Focas1.ODBERR();
|
|
Focas1.cnc_getdtailerr(hndl, odd2);
|
|
Debug.WriteLine(odd2.err_no + " " + odd2.err_dtno);
|
|
}
|
|
catch
|
|
{
|
|
CheckErrors(ret_array);
|
|
return;
|
|
}
|
|
|
|
ret_array[9] = Focas1.cnc_pdf_slctmain(hndl, PROG_MEMORY_PATH + "OSTD");
|
|
CheckErrors(ret_array);
|
|
}
|
|
}
|
|
|
|
|
|
private bool canDownloadNC()
|
|
{
|
|
ret_array[9] = Focas1.cnc_statinfo(hndl, odbst);
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
CheckErrors(ret_array);
|
|
return false;
|
|
}
|
|
else if (odbst.aut != 0 //MDI STATE
|
|
&& odbst.aut != 3) //EDIT STATE
|
|
{
|
|
ret_array[9] = (short)Focas1.focas_ret.EW_MODE;
|
|
CheckErrors(ret_array);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* SEND PROGRAM TO CNC MEMORY
|
|
*/
|
|
public short Download(string file, FanucProgram.FILE_TYPE type, short cnc_path = 1)
|
|
{
|
|
if (!canDownloadNC()) return ret_array[9];
|
|
Focas1.cnc_setpath(hndl, cnc_path);
|
|
var PROG_MEMORY_PATH = get_cnc_path(cnc_path);
|
|
int num;
|
|
int len;
|
|
string prog_name = "";
|
|
if (CONNECTED)
|
|
{
|
|
if (type == FanucProgram.FILE_TYPE.CNC_PROGRAM)
|
|
{
|
|
try
|
|
{
|
|
prog_name = FanucProgram.GetProgramTitle(file);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
FOCAS_ERRORS = "tentativo Download fallito nome file in formato errato\n" + e.StackTrace;
|
|
return (short)Focas1.focas_ret.EW_DATA;
|
|
}
|
|
|
|
if (!compatibiltyMode)
|
|
{
|
|
ret_array[9] = Focas1.cnc_pdf_slctmain(hndl, PROG_MEMORY_PATH + "OSTD");
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
DownloadStd();
|
|
}
|
|
ret_array[9] = Focas_DeleteNCProgram(prog_name, PROG_MEMORY_PATH);
|
|
if (ret_array[9] != Focas1.EW_OK && ret_array[9] != (short)Focas1.focas_ret.EW_BUSY && ret_array[9] != (short)Focas1.focas_ret.EW_DATA)
|
|
{
|
|
CheckErrors(ret_array);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
ret_array[9] = Focas_StartNCFileDownload(PROG_MEMORY_PATH, type);
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
Focas_EndNCFileDownload();
|
|
CheckErrors(ret_array);
|
|
return ret_array[9];
|
|
}
|
|
|
|
len = file.Length;
|
|
int startPos = 0;
|
|
|
|
while (len > 0)
|
|
{
|
|
if (len >= 1024)
|
|
{
|
|
num = 1024;
|
|
}
|
|
else
|
|
{
|
|
num = len;
|
|
}
|
|
char[] prg_temp = new char[num];
|
|
file.CopyTo(startPos, prg_temp, 0, num);
|
|
string a = file.Substring(startPos);
|
|
|
|
ret_array[9] = Focas_NCFileDownload(ref num, prg_temp);
|
|
if (ret_array[9] == (short)Focas1.focas_ret.EW_BUFFER)
|
|
{
|
|
Thread.Sleep(100);
|
|
continue;
|
|
}
|
|
if (ret_array[9] == Focas1.EW_OK)
|
|
{
|
|
startPos += num;
|
|
len -= num;
|
|
}
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
Focas1.ODBERR odd = new Focas1.ODBERR();
|
|
Focas1.cnc_getdtailerr(hndl, odd);
|
|
Debug.WriteLine(odd.err_no + " " + odd.err_dtno);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
CheckErrors(ret_array);
|
|
Focas_EndNCFileDownload();
|
|
return ret_array[9];
|
|
}
|
|
|
|
Focas_EndNCFileDownload();
|
|
}
|
|
catch
|
|
{
|
|
CheckErrors(ret_array);
|
|
Focas_EndNCFileDownload();
|
|
return ret_array[9];
|
|
}
|
|
|
|
if (!compatibiltyMode && type == FanucProgram.FILE_TYPE.CNC_PROGRAM)
|
|
ret_array[9] = Focas1.cnc_pdf_slctmain(hndl, PROG_MEMORY_PATH + prog_name);
|
|
|
|
if (ret_array[9] != Focas1.EW_OK)
|
|
{
|
|
CheckErrors(ret_array);
|
|
return 18;
|
|
}
|
|
return Focas1.EW_OK;
|
|
}
|
|
return (short)Focas1.focas_ret.EW_BUSY;
|
|
}
|
|
|
|
private short Focas_DeleteNCProgram(string prog_name, string prog_path)
|
|
{
|
|
Regex rx = new Regex(@"(\b[O]+\d{4}\b)|(\b\d{4}\b)"); //cerca per O#### o #### dove # è un carattere numerico
|
|
// Find matches.
|
|
MatchCollection matches = rx.Matches(prog_name);
|
|
if (matches.Count > 0)
|
|
{
|
|
prog_name = prog_name.Trim(new Char[] { 'O' });
|
|
return Focas1.cnc_delete(hndl, (short)Convert.ToUInt32(prog_name));
|
|
}
|
|
else
|
|
{
|
|
return Focas1.cnc_pdf_del(hndl, prog_path + prog_name);
|
|
}
|
|
}
|
|
|
|
private short Focas_StartNCFileDownload(string file_path, FanucProgram.FILE_TYPE type)
|
|
{
|
|
//il path del file non può essere selezionato se compatibilityMode = true
|
|
if (compatibiltyMode) return Focas1.cnc_dwnstart3(hndl, (short)type); else return Focas1.cnc_dwnstart4(hndl, (short)type, file_path);
|
|
}
|
|
|
|
private short Focas_NCFileDownload(ref int program_lenght, char[] program)
|
|
{
|
|
if (compatibiltyMode) return Focas1.cnc_download3(hndl, ref program_lenght, program); else return Focas1.cnc_download4(hndl, ref program_lenght, program);
|
|
}
|
|
|
|
private short Focas_EndNCFileDownload()
|
|
{
|
|
if (compatibiltyMode) return Focas1.cnc_dwnend3(hndl); else return Focas1.cnc_dwnend4(hndl);
|
|
}
|
|
|
|
private short Focas_StartNCFileUpload(string file_path, FanucProgram.FILE_TYPE type)
|
|
{
|
|
//il file_path cambia a seconda di compatibilityMode
|
|
if (compatibiltyMode)
|
|
{
|
|
try
|
|
{
|
|
//file_path deve essere il codice del programma e.g. O1234 --> file_path = 1234
|
|
int file_code = Convert.ToInt32(file_path);
|
|
return Focas1.cnc_upstart3(hndl, (short)type, file_code, file_code);
|
|
}
|
|
catch
|
|
{
|
|
return (short)Focas1.focas_ret.EW_DATA;
|
|
}
|
|
}
|
|
else
|
|
//file_path deve essere il path del programma compreso il nome file e.g. "//CNC_MEM/USER/PATH1/SAMPLE" dove SAMPLE è il nome del programma
|
|
return Focas1.cnc_upstart4(hndl, (short)type, file_path);
|
|
}
|
|
|
|
private short Focas_NCFileUpload(int program_lenght, char[] program)
|
|
{
|
|
//il path del file non può essere selezionato se compatibilityMode = true
|
|
if (compatibiltyMode) return Focas1.cnc_upload4(hndl, ref program_lenght, program); else return Focas1.cnc_upload4(hndl, ref program_lenght, program);
|
|
}
|
|
|
|
private short Focas_EndNCFileUpload()
|
|
{
|
|
//il path del file non può essere selezionato se compatibilityMode = true
|
|
if (compatibiltyMode) return Focas1.cnc_upend3(hndl); else return Focas1.cnc_upend4(hndl);
|
|
}
|
|
|
|
private string Focas_GetMainForNCDownloadUpload()
|
|
{
|
|
if (compatibiltyMode)
|
|
{
|
|
Focas1.ODBPRO buf = new Focas1.ODBPRO();
|
|
ret_array[10] = Focas1.cnc_rdprgnum(hndl, buf);
|
|
CheckErrors(ret_array);
|
|
//buf.data->programma in esecuzione
|
|
//buf.mdata-> main program
|
|
return buf.mdata.ToString();
|
|
}
|
|
else
|
|
{
|
|
byte[] nome_main = new byte[242];
|
|
// nome programma
|
|
ret_array[10] = Focas1.cnc_pdf_rdmain(hndl, nome_main);
|
|
string path = ASCIIEncoding.ASCII.GetString(nome_main).TrimEnd('\0');
|
|
CheckErrors(ret_array);
|
|
return path;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GET MAIN PROGRAM FROM CNC MEMORY
|
|
*/
|
|
public string Upload(FanucProgram.FILE_TYPE type, short cnc_path = 1)
|
|
{
|
|
Focas1.cnc_setpath(hndl, cnc_path);
|
|
//file_path = PROG_MEMORY_PATH
|
|
//file_name = "SAMPLE";
|
|
int BUFFER_SIZE = 10000;//dimensione del buffer di caratteri. Solitamente scarica meno di 1000 caratteri al ciclo
|
|
char[] buffer = new char[BUFFER_SIZE + 1];
|
|
string buf;
|
|
int len;
|
|
string output = "";
|
|
char[] path = new char[244];
|
|
|
|
if (CONNECTED == false)
|
|
return "";
|
|
else
|
|
{
|
|
ret_array[10] = Focas_StartNCFileUpload(Focas_GetMainForNCDownloadUpload(), type);
|
|
|
|
if (ret_array[10] != Focas1.EW_OK)
|
|
{
|
|
Focas_EndNCFileUpload();
|
|
CheckErrors(ret_array);
|
|
return "";
|
|
}
|
|
|
|
do
|
|
{
|
|
len = BUFFER_SIZE;
|
|
ret_array[10] = Focas_NCFileUpload(len, buffer);
|
|
|
|
if (ret_array[10] == (short)Focas1.focas_ret.EW_BUFFER)
|
|
{
|
|
Thread.Sleep(100);
|
|
continue;
|
|
}
|
|
|
|
if (ret_array[10] == Focas1.EW_OK)
|
|
{
|
|
buffer[len] = '\0'; ;
|
|
buf = new string(buffer).TrimEnd('\0');
|
|
output = output + buf;
|
|
}
|
|
|
|
if (buffer[len - 1] == '%')
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
while ((ret_array[10] == Focas1.EW_OK) || (ret_array[10] == (short)Focas1.focas_ret.EW_BUFFER));
|
|
|
|
|
|
ret_array[10] = Focas_EndNCFileUpload();
|
|
|
|
return output;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|