11. Periferiche Robot

11.1. Configurare Pinza

/**
* @brief  Configurare Pinza
* @param  [in] company  Produttore pinza, da definire
* @param  [in] device  Numero dispositivo, attualmente non utilizzato, default 0
* @param  [in] softvesion  Numero versione software, attualmente non utilizzato, default 0
* @param  [in] bus Posizione bus estremità dove è collegato il dispositivo, attualmente non utilizzato, default 0
* @return   Codice errore
*/
int SetGripperConfig(int company, int device, int softvesion, int bus);

11.2. Ottenere Configurazione Pinza

/**
* @brief  Ottenere Configurazione Pinza
* @param  [in] company  Produttore pinza, da definire
* @param  [in] device  Numero dispositivo, attualmente non utilizzato, default 0
* @param  [in] softvesion  Numero versione software, attualmente non utilizzato, default 0
* @param  [in] bus Posizione bus estremità dove è collegato il dispositivo, attualmente non utilizzato, default 0
* @return   Codice errore
*/
int GetGripperConfig(int *company, int *device, int *softvesion, int *bus);

11.3. Attivare Pinza

/**
* @brief  Attivare Pinza
* @param  [in] index  Numero identificativo pinza
* @param  [in] act  0-reset, 1-attiva
* @return   Codice errore
*/
int ActGripper(int index, byte act);

11.4. Controllare Pinza

/**
* @brief  Controllare Pinza
* @param  [in] index  Numero identificativo pinza
* @param  [in] pos  Percentuale posizione, range [0~100]
* @param  [in] vel  Percentuale velocità, range [0~100]
* @param  [in] force  Percentuale coppia, range [0~100]
* @param  [in] max_time  Tempo di attesa massimo, range [0~30000], unità ms
* @param  [in] block  0-bloccante, 1-non bloccante
* @param  [in] type Tipo pinza, 0-pinza parallela; 1-pinza rotante
* @param  [in] rotNum Numero di giri rotazione
* @param  [in] rotVel Percentuale velocità rotazione [0-100]
* @param  [in] rotTorque Percentuale coppia rotazione [0-100]
* @return   Codice errore
*/
int MoveGripper(int index, int pos, int vel, int force, int max_time, byte block, int type, double rotNum, int rotVel, int rotTorque);

11.5. Ottenere Stato Movimento Pinza

/**
* @brief  Ottenere Stato Movimento Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] staus  0-movimento non completato, 1-movimento completato
* @return   Codice errore
*/
int GetGripperMotionDone(ref int fault, ref int status);

11.6. Ottenere Stato Attivazione Pinza

/**
* @brief  Ottenere Stato Attivazione Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] status  bit0~bit15 corrispondono numeri pinza 0~15, bit=0 non attivato, bit=1 attivato
* @return   Codice errore
*/
int GetGripperActivateStatus(ref int fault, ref int status);

11.7. Ottenere Posizione Pinza

/**
* @brief  Ottenere Posizione Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] position  Percentuale posizione, range 0~100%
* @return   Codice errore
*/
int GetGripperCurPosition(ref int fault, ref int position);

11.8. Ottenere Velocità Pinza

/**
* @brief  Ottenere Velocità Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] speed  Percentuale velocità, range 0~100%
* @return   Codice errore
*/
int GetGripperCurSpeed(ref int fault, ref int speed);

11.9. Ottenere Corrente Pinza

/**
* @brief  Ottenere Corrente Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] current  Percentuale corrente, range 0~100%
* @return   Codice errore
*/
int GetGripperCurCurrent(ref int fault, ref int current);

11.10. Ottenere Tensione Pinza

/**
* @brief  Ottenere Tensione Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] voltage  Tensione, unità 0.1V
* @return   Codice errore
*/
int GetGripperVoltage(ref int fault, ref int voltage);

11.11. Ottenere Temperatura Pinza

/**
* @brief  Ottenere Temperatura Pinza
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] temp  Temperatura, unità ℃
* @return   Codice errore
*/
int GetGripperTemp(ref int fault, ref int temp);

11.12. Calcolare Punto Pre-Presa - Visione

/**
* @brief Calcolare Punto Pre-Presa - Visione
* @param [in] desc_pos Posa cartesiana punto di presa
* @param [in] zlength Offset asse z
* @param [in] zangle Offset rotazione attorno asse z
* @param [out] pre_pos Punto pre-presa
* @return Codice errore
*/
int ComputePrePick(DescPose desc_pos, double zlength, double zangle, ref DescPose pre_pos);

11.13. Calcolare Punto Post-Presa - Visione

/**
* @brief Calcolare Punto Post-Presa - Visione
* @param [in] desc_pos Posa cartesiana punto post-presa
* @param [in] zlength Offset asse z
* @param [in] zangle Offset rotazione attorno asse z
* @param [out] post_pos Punto post-presa
* @return Codice errore
*/
int ComputePostPick(DescPose desc_pos, double zlength, double zangle, ref DescPose post_pos);

11.14. Esempio Codice Operazioni Pinza Robot

private void button36_Click(object sender, EventArgs e)
{
    int company = 4;
    int device = 0;
    int softversion = 0;
    int bus = 2;
    int index = 2;
    byte act = 0;
    int max_time = 30000;
    byte block = 0;
    int status=0;
    int fault=0;
    int active_status = 0;
    int current_pos = 0;
    int current = 0;
    int voltage = 0;
    int temp = 0;
    int speed = 0;

    robot.SetGripperConfig(company, device, softversion, bus);
    Thread.Sleep(1000);
    robot.GetGripperConfig(ref company, ref device, ref softversion, ref bus);
    Console.WriteLine("gripper config:{0},{1},{2},{3}\n", company, device, softversion, bus);

    robot.ActGripper(index, act);
    Thread.Sleep(1000);
    act = 1;
    robot.ActGripper(index, act);
    Thread.Sleep(1000);

    robot.MoveGripper(index, 90, 50, 50, max_time, block, 0, 0, 0, 0);
    Thread.Sleep(1000);
    robot.MoveGripper(index, 30, 50, 0, max_time, block, 0, 0, 0, 0);

    robot.GetGripperMotionDone(ref fault, ref status);
    Console.WriteLine("motion status:{0},{1}\n", fault, status);

    robot.GetGripperActivateStatus(ref fault, ref active_status);
    Console.WriteLine("gripper active fault is: {0}, status is: {1}\n", fault, active_status);

    robot.GetGripperCurPosition(ref fault, ref current_pos);
    Console.WriteLine("fault is:{0}, current position is: {1}\n", fault, current_pos);

    robot.GetGripperCurCurrent(ref fault, ref current);
    Console.WriteLine("fault is:{0}, current current is: {1}\n", fault, current);

    robot.GetGripperVoltage(ref fault, ref voltage);
    Console.WriteLine("fault is:{0}, current voltage is: {1} \n", fault, voltage);

    robot.GetGripperTemp(ref fault, ref temp);
    Console.WriteLine("fault is:{0}, current temperature is: {1}\n", fault, temp);

    robot.GetGripperCurSpeed(ref fault, ref speed);
    Console.WriteLine("fault is:{0}, current speed is: {1}\n", fault, speed);

    int retval = 0;
    DescPose prepick_pose = new DescPose();
    DescPose postpick_pose = new DescPose();

    DescPose p1Desc = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
    DescPose p2Desc = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);

    retval = robot.ComputePrePick(p1Desc, 10, 0, ref prepick_pose);
    Console.WriteLine("ComputePrePick retval is: {0}\n", retval);
    Console.WriteLine("xyz is: {0}, {1}, {2}; rpy is: {3}, {4}, {5}\n",
        prepick_pose.tran.x, prepick_pose.tran.y, prepick_pose.tran.z,
        prepick_pose.rpy.rx, prepick_pose.rpy.ry, prepick_pose.rpy.rz);

    retval = robot.ComputePostPick( p2Desc, -10, 0, ref postpick_pose);
    Console.WriteLine("ComputePostPick retval is: {0}\n", retval);
    Console.WriteLine("xyz is: {0}, {1}, {2}; rpy is: {3}, {4}, {5}\n",
        postpick_pose.tran.x, postpick_pose.tran.y, postpick_pose.tran.z,
        postpick_pose.rpy.rx, postpick_pose.rpy.ry, postpick_pose.rpy.rz);

}

11.15. Ottenere Numero Giri Pinza Rotante

/**
* @brief  Ottenere Numero Giri Pinza Rotante
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] num  Numero giri rotazione
* @return   Codice errore
*/
int GetGripperRotNum(ref UInt16 fault, ref double num);

11.16. Ottenere Percentuale Velocità Rotazione Pinza Rotante

/**
* @brief  Ottenere Percentuale Velocità Rotazione Pinza Rotante
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] speed  Percentuale velocità rotazione
* @return   Codice errore
*/
int GetGripperRotSpeed(ref UInt16 fault, ref int speed);

11.17. Ottenere Percentuale Coppia Rotazione Pinza Rotante

/**
* @brief  Ottenere Percentuale Coppia Rotazione Pinza Rotante
* @param  [out] fault  0-nessun errore, 1-errore presente
* @param  [out] torque  Percentuale coppia rotazione
* @return   Codice errore
*/
int GetGripperRotTorque(ref UInt16 fault, ref int torque);

11.18. Esempio Codice Ottenimento Stato Pinza Rotante

int MoveRotGripper(int pos, double rotPos)
{
    robot.ResetAllError();
    robot.ActGripper(1, 1);
    Thread.Sleep(1000);
    int rtn = robot.MoveGripper(1, pos, 50, 50, 5000, 1, 1, rotPos, 50, 100);
    Console.WriteLine($"move gripper rtn is {rtn}" );
    UInt16 fault = 0;
    double rotNum = 0.0;
    int rotSpeed = 0;
    int rotTorque = 0;
    robot.GetGripperRotNum(ref fault, ref rotNum);
    robot.GetGripperRotSpeed(ref fault, ref rotSpeed);
    robot.GetGripperRotTorque(ref fault, ref rotTorque);
    Console.WriteLine($"gripper rot num :{ rotNum}, gripper rotSpeed :{rotSpeed}, gripper rotTorque : { rotTorque}");
    return 0;
}

11.19. Avvio, Arresto Nastro Trasportatore

/**
* @brief Avvio, Arresto Nastro Trasportatore
* @param [in] status Stato, 1-avvio, 0-arresto
* @return Codice errore
*/
int ConveyorStartEnd(byte status);

11.20. Registrare Punto Rilevamento IO

/**
* @brief Registrare Punto Rilevamento IO
* @return Codice errore
*/
int ConveyorPointIORecord();

11.21. Registrare Punto A

/**
* @brief Registrare Punto A
* @return Codice errore
*/
int ConveyorPointARecord();

11.22. Registrare Punto Riferimento

/**
* @brief Registrare Punto Riferimento
* @return Codice errore
*/
int ConveyorRefPointRecord();

11.23. Registrare Punto B

/**
* @brief Registrare Punto B
* @return Codice errore
*/
int ConveyorPointBRecord();

11.24. Rilevamento IO Pezzo Nastro Trasportatore

/**
* @brief Rilevamento IO Pezzo Nastro Trasportatore
* @param [in] max_t Tempo massimo rilevamento, unità ms
* @return Codice errore
*/
int ConveyorIODetect(int max_t);

11.25. Ottenere Posizione Corrente Oggetto

/**
* @brief Ottenere Posizione Corrente Oggetto
* @param [in] mode 1-tracciamento presa, 2-tracciamento movimento, 3-tracciamento TPD
* @return Codice errore
*/
int ConveyorGetTrackData(int mode);

11.26. Inizio Tracciamento Nastro Trasportatore

/**
* @brief Inizio Tracciamento Nastro Trasportatore
* @param [in] status Stato, 1-avvio, 0-arresto
* @return Codice errore
*/
int ConveyorTrackStart(byte status);

11.27. Fine Tracciamento Nastro Trasportatore

/**
* @brief Fine Tracciamento Nastro Trasportatore
* @return Codice errore
*/
int ConveyorTrackEnd();

11.28. Configurazione Parametri Nastro Trasportatore

/**
* @brief Configurazione Parametri Nastro Trasportatore
* @param [in] para[0] Canale encoder 1~2
* @param [in] para[1] Numero impulsi per giro encoder
* @param [in] para[2] Distanza percorrenza nastro per giro encoder
* @param [in] para[3] Numero sistema coordinate pezzo Per funzione tracciamento movimento selezionare numero sistema coordinate pezzo, per tracciamento presa, TPD impostare 0
* @param [in] para[4] Se dotato di visione  0 no  1 sì
* @param [in] para[5] Rapporto velocità  Opzione tracciamento presa nastro (1-100)  Altre opzioni default 1
* @param [in] followType Tipo movimento tracciamento, 0-tracciamento movimento; 1-movimento inseguimento ispezione
* @param [in] startDis Necessario per presa inseguimento ispezione, distanza inizio tracciamento, -1: calcolo automatico (inseguimento ispezione automatico dopo arrivo pezzo sotto robot), unità mm, valore default 0
* @param [in] endDis Necessario per presa inseguimento ispezione, distanza fine tracciamento, unità mm, valore default 100
* @return Codice errore
*/
int ConveyorSetParam(int encChannel, int resolution, double lead, int wpAxis, int vision, double speedRadio, int followType, int startDis=0, int endDis=100);

11.29. Impostare Compensazione Punto Presa Nastro Trasportatore

/**
* @brief Impostare Compensazione Punto Presa Nastro Trasportatore
* @param [in] cmp Posizione compensazione double[3]{x, y, z}
* @return Codice errore
*/
int ConveyorCatchPointComp(double[] cmp);

11.30. Movimento Lineare Tracciamento Nastro Trasportatore

/**
* @brief Movimento Lineare Tracciamento Nastro Trasportatore
* @param [in] name Nome punto movimento
* @param [in] tool Numero sistema coordinate utensile, range [0~14]
* @param [in] wobj Numero sistema coordinate pezzo, range [0~14]
* @param [in] vel Percentuale velocità, range [0~100]
* @param [in] acc Percentuale accelerazione, range [0~100], attualmente non disponibile
* @param [in] ovl Fattore di scala velocità, range [0~100]
* @param [in] blendR [-1.0]-movimento fino a posizione (bloccante), [0~1000.0]-raggio smoothing (non bloccante), unità mm
* @return Codice errore
*/
int ConveyorTrackMoveL(string name, int tool, int wobj, float vel, float acc, float ovl, float blendR);

11.31. Rilevamento Input Comunicazione Nastro Trasportatore

/**
* @brief Rilevamento Input Comunicazione Nastro Trasportatore
* @param [in] timeout Tempo attesa timeout ms
* @return Codice errore
*/
int ConveyorComDetect(int timeout);

11.32. Trigger Rilevamento Input Comunicazione Nastro Trasportatore

/**
* @brief Trigger Rilevamento Input Comunicazione Nastro Trasportatore
* @return Codice errore
*/
int ConveyorComDetectTrigger();

11.33. Esempio Programma Trigger Rilevamento Input Comunicazione Nastro Trasportatore

private void button3_Click(object sender, EventArgs e)
{

    // Disabilitare pulsante per evitare clic ripetuti
    button3.Enabled = false;

    // Eseguire operazione lunga in thread background
    Thread conveyorThread = new Thread(ConveyorTest);
    conveyorThread.IsBackground = true;
    conveyorThread.Start();
}

private void button4_Click(object sender, EventArgs e)
{
    // Ottenere input utente
    string input = texBox.Text;
    Console.WriteLine($"please input a number to trigger:{input}");

    int rtn = robot.ConveyorComDetectTrigger();
    Console.WriteLine($"ConveyorComDetectTrigger valore restituito: {rtn}");

}

private void ConveyorTest()
{
    // Usare Invoke per aggiornare controlli sul thread UI
    this.Invoke((MethodInvoker)delegate {
        Console.WriteLine("Inizio test nastro trasportatore...");
    });

    int retval = 0;
    int index = 1;
    int max_time = 30000;
    bool block = false;
    retval = 0;

    /* Processo presa nastro trasportatore */
    DescPose startdescPose = new DescPose(139.176f, 4.717f, 9.088f, -179.999f, -0.004f, -179.990f);
    JointPos startjointPos = new JointPos(-34.129f, -88.062f, 97.839f, -99.780f, -90.003f, -34.140f);

    DescPose homePose = new DescPose(139.177f, 4.717f, 69.084f, -180.000f, -0.004f, -179.989f);
    JointPos homejointPos = new JointPos(-34.129f, -88.618f, 84.039f, -85.423f, -90.003f, -34.140f);

    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);

    // Spostarsi a posizione sicura
    retval = robot.MoveL(homejointPos, homePose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);
    Console.WriteLine($"MoveL a posizione sicura valore restituito: {retval}");

    // Rilevamento nastro trasportatore
    retval = robot.ConveryComDetect(1000 * 10);
    Console.WriteLine($"ConveyorComDetect valore restituito: {retval}");

    // Ottenere dati tracciamento
    retval = robot.ConveyorGetTrackData(2);
    Console.WriteLine($"ConveyorGetTrackData valore restituito: {retval}");

    // Inizio tracciamento
    retval = robot.ConveyorTrackStart(2);
    Console.WriteLine($"ConveyorTrackStart valore restituito: {retval}");

    // Spostarsi a posizione iniziale
    robot.MoveL(startjointPos, startdescPose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);
    robot.MoveL(startjointPos, startdescPose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);

    // Fine tracciamento
    retval = robot.ConveyorTrackEnd();
    Console.WriteLine($"ConveyorTrackEnd valore restituito: {retval}");

    // Ritorno a posizione sicura
    robot.MoveL(homejointPos, homePose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);

    this.Invoke((MethodInvoker)delegate {
        Console.WriteLine("Test nastro trasportatore completato!");
        button3.Enabled = true;
    });
}

11.34. Esempio Programma Operazioni Nastro Trasportatore Robot

private void btnConvert_Click(object sender, EventArgs e)
    {
    Robot robot = new Robot();
    robot.RPC("192.168.58.2");
    DescPose pos1 = new DescPose(0, 0, 0, 0 ,0 ,0);
    DescPose pos2 = new DescPose(0, 0, 0, 0, 0, 0);

    pos1.tran.x = -351.175;
    pos1.tran.y = 3.389;
    pos1.tran.z = 431.172;
    pos1.rpy.rx = -179.111;
    pos1.rpy.ry = -0.241;
    pos1.rpy.rz = 90.388;

    pos2.tran.x = -333.654;
    pos2.tran.y = -229.003;
    pos2.tran.z = 404.335;
    pos2.rpy.rx = -179.139;
    pos2.rpy.ry = -0.779;
    pos2.rpy.rz = 91.269;
    int rtn = -1;

    double[] cmp = new double[3] { 0, 9.99, 0};
    rtn = robot.ConveyorCatchPointComp(cmp);
    if(rtn != 0)
    {
        return;
    }
    Console.WriteLine($"ConveyorCatchPointComp: rtn  {rtn}");

    rtn = robot.MoveCart(pos1, 0, 0, 100.0f, 180.0f, 100.0f, -1.0f, -1);
    Console.WriteLine($"MoveCart: rtn  {rtn}");

    rtn = robot.ConveyorIODetect(10000);
    Console.WriteLine($"ConveyorIODetect: rtn  {rtn}");

    robot.ConveyorGetTrackData(1);
    rtn = robot.ConveyorTrackStart(1);
    Console.WriteLine($"ConveyorTrackStart: rtn  {rtn}");

    rtn = robot.ConveyorTrackMoveL("cvrCatchPoint", 0, 0, 100.0f, 0.0f, 100.0f, -1.0f, 0, 0);
    Console.WriteLine($"ConveyorTrackMoveL: rtn  {rtn}");

    rtn = robot.MoveGripper(1, 59, 43, 21, 30000, 0);
    Console.WriteLine($"MoveGripper: rtn  {rtn}");

    rtn = robot.ConveyorTrackMoveL("cvrRaisePoint", 0, 0, 100.0f, 0.0f, 100.0f, -1.0f, 0, 0);
    Console.WriteLine($"ConveyorTrackMoveL: rtn  {rtn}");

    rtn = robot.ConveyorTrackEnd();
    Console.WriteLine($"ConveyorTrackEnd: rtn  {rtn}");

    rtn = robot.MoveCart(pos2, 0, 0, 100.0f, 180.0f, 100.0f, -1.0f, -1);
    Console.WriteLine($"MoveCart: rtn  {rtn}");

    rtn = robot.MoveGripper(1, 100, 43, 21, 30000, 0);
    Console.WriteLine($"MoveGripper: rtn  {rtn}");
}

11.35. Configurazione Sensore Estremità

/**
* @brief  Configurazione Sensore Estremità
* @param  [in] idCompany Produttore, 18-JUNKONG；25-HUIDE
* @param  [in] idDevice Tipo, 0-JUNKONG/RYR6T.V1.0
* @param  [in] idSoftware Versione software, 0-J1.0/HuiDe1.0(attualmente non disponibile)
* @param  [in] idBus Posizione montaggio, 1-porta 1 estremità; 2-porta 2 estremità...8-porta 8 estremità(attualmente non disponibile)
* @return   Codice errore
*/
int AxleSensorConfig(int idCompany, int idDevice, int idSoftware, int idBus);

11.36. Ottenere Configurazione Sensore Estremità

/**
* @brief  Ottenere Configurazione Sensore Estremità
* @param  [out] idCompany Produttore, 18-JUNKONG；25-HUIDE
* @param  [out] idDevice Tipo, 0-JUNKONG/RYR6T.V1.0
* @return   Codice errore
*/
int AxleSensorConfigGet(ref int idCompany, ref int idDevice);

11.37. Attivazione Sensore Estremità

/**
* @brief  Attivazione Sensore Estremità
* @param  [in] actFlag 0-reset; 1-attiva
* @return   Codice errore
*/
int AxleSensorActivate(int actFlag);

11.38. Scrittura Registro Sensore Estremità

/**
* @brief  Scrittura Registro Sensore Estremità
* @param  [in] devAddr  Numero indirizzo dispositivo 0-255
* @param  [in] regHAddr Indirizzo registro 8 bit alti
* @param  [in] regLAddr Indirizzo registro 8 bit bassi
* @param  [in] regNum  Numero registri 0-255
* @param  [in] data1 Valore scrittura registro 1
* @param  [in] data2 Valore scrittura registro 2
* @param  [in] isNoBlock 0-bloccante; 1-non bloccante
* @return   Codice errore
*/
 int AxleSensorRegWrite(int devAddr, int regHAddr, int regLAddr, int regNum, int data1, int data2, int isNoBlock);

11.39. Esempio Codice Sensore Estremità

private void button2_Click_1(object sender, EventArgs e)
{
    robot.AxleSensorConfig(18, 0, 0, 1);
    int company = -1;
    int type = -1;
    robot.AxleSensorConfigGet(ref company, ref type);
    Console.WriteLine("company is " + company + ", type is " + type);

    int rtn = robot.AxleSensorActivate(1);
    Console.WriteLine("AxleSensorActivate rtn is " + rtn);

    Thread.Sleep(1000);

    rtn = robot.AxleSensorRegWrite(1, 4, 6, 1, 0, 0, 0);
    Console.WriteLine("AxleSensorRegWrite rtn is " + rtn);
}

11.40. Ottenere Protocollo Periferiche Robot

Nuovo nella versione C#SDK-v1.0.6.

/**
* @brief Ottenere Protocollo Periferiche Robot
* @param [out] protocol Numero protocollo periferiche robot 4096-scheda controllo asse esteso; 4097-ModbusSlave; 4098-ModbusMaster
* @return Codice errore
*/
int GetExDevProtocol(ref int protocol);

11.41. Impostare Protocollo Periferiche Robot

Nuovo nella versione C#SDK-v1.0.6.

/**
* @brief Impostare Protocollo Periferiche Robot
* @param [in] protocol Numero protocollo periferiche robot 4096-scheda controllo asse esteso; 4097-ModbusSlave; 4098-ModbusMaster
* @return Codice errore
*/
int SetExDevProtocol(int protocol);

11.42. Esempio Programma Impostazione Protocollo Periferiche Robot

private void btnSetProto_Click(object sender, EventArgs e)
{
  int protocol = 4096;
  int rtn = robot.SetExDevProtocol(protocol);
  Console.WriteLine("SetExDevProtocol rtn " + rtn);
  rtn = robot.GetExDevProtocol(ref protocol);
  Console.WriteLine("GetExDevProtocol rtn " + rtn + " protocol is: " + protocol);
}

11.43. Ottenere Parametri Comunicazione Estremità

/**
* @brief Ottenere Parametri Comunicazione Estremità
* @param param Parametri comunicazione estremità
* @return   Codice errore
*/
int GetAxleCommunicationParam(ref AxleComParam getParam);

11.44. Impostare Parametri Comunicazione Estremità

/**
* @brief Impostare Parametri Comunicazione Estremità
* @param param  Parametri comunicazione estremità
* @return   Codice errore
*/
int SetAxleCommunicationParam(AxleComParam param);

11.45. Impostare Tipo Trasmissione File Estremità

/**
* @brief Impostare Tipo Trasmissione File Estremità
* @param type 1-file aggiornamento MCU; 2-file LUA
* @return   Codice errore
*/
int SetAxleFileType(int type);

11.46. Impostare Abilitazione Esecuzione LUA Estremità

/**
* @brief Impostare Abilitazione Esecuzione LUA Estremità
* @param enable 0-non abilitato; 1-abilitato
* @return   Codice errore
*/
int SetAxleLuaEnable(int enable);

11.47. Recupero Errore Anomalo File LUA Estremità

/**
* @brief Recupero Errore Anomalo File LUA Estremità
* @param status 0-non recuperare; 1-recupera
* @return   Codice errore
*/
int SetRecoverAxleLuaErr(int status);

11.48. Ottenere Stato Abilitazione Esecuzione LUA Estremità

/**
* @brief Ottenere Stato Abilitazione Esecuzione LUA Estremità
* @param [out] status 0-non abilitato; 1-abilitato
* @return   Codice errore
*/
int GetAxleLuaEnableStatus(ref int status);

11.49. Impostare Tipo Dispositivi Estremità Abilitati LUA Estremità

/**
* @brief Impostare Tipo Dispositivi Estremità Abilitati LUA Estremità
* @param [in] forceSensorEnable Stato abilitazione sensore forza, 0-non abilitato; 1-abilitato
* @param [in] gripperEnable Stato abilitazione pinza, 0-non abilitato; 1-abilitato
* @param [in] IOEnable Stato abilitazione dispositivo IO, 0-non abilitato; 1-abilitato
* @return   Codice errore
*/
int SetAxleLuaEnableDeviceType(int forceSensorEnable, int gripperEnable, int IOEnable);

11.50. Ottenere Tipo Dispositivi Estremità Abilitati LUA Estremità

/**
* @brief Ottenere Tipo Dispositivi Estremità Abilitati LUA Estremità
* @param [out] forceSensorEnable Stato abilitazione sensore forza, 0-non abilitato; 1-abilitato
* @param [out] gripperEnable Stato abilitazione pinza, 0-non abilitato; 1-abilitato
* @param [out] IOEnable Stato abilitazione dispositivo IO, 0-non abilitato; 1-abilitato
* @return   Codice errore
*/
int GetAxleLuaEnableDeviceType(ref int forceSensorEnable, ref int gripperEnable, ref int IOEnable);

11.51. Ottenere Dispositivi Estremità Configurati Correntemente

/**
* @brief Ottenere Dispositivi Estremità Configurati Correntemente
* @param [out] forceSensorEnable Numero dispositivo sensore forza abilitato 0-non abilitato; 1-abilitato
* @param [out] gripperEnable Numero dispositivo pinza abilitato, 0-non abilitato; 1-abilitato
* @param [out] IODeviceEnable Numero dispositivo IO abilitato, 0-non abilitato; 1-abilitato
* @return   Codice errore
*/
int GetAxleLuaEnableDevice(ref int[] forceSensorEnable, ref int[] gripperEnable, ref int[] IODeviceEnable);

11.52. Impostare Funzione Controllo Azione Pinza Abilitata

/**
* @brief Impostare Funzione Controllo Azione Pinza Abilitata
* @param [in] id Numero dispositivo pinza
* @param [in] func func[0]-abilitazione pinza; func[1]-inizializzazione pinza; 2-impostazione posizione; 3-impostazione velocità; 4-impostazione coppia; 6-lettura stato pinza; 7-lettura stato inizializzazione; 8-lettura codice errore; 9-lettura posizione; 10-lettura velocità; 11-lettura coppia
* @return   Codice errore
*/
int SetAxleLuaGripperFunc(int id, int[] func);

11.53. Ottenere Funzione Controllo Azione Pinza Abilitata

/**
* @brief Ottenere Funzione Controllo Azione Pinza Abilitata
* @param [in] id Numero dispositivo pinza
* @param [out] func func[0]-abilitazione pinza; func[1]-inizializzazione pinza; 2-impostazione posizione; 3-impostazione velocità; 4-impostazione coppia; 6-lettura stato pinza; 7-lettura stato inizializzazione; 8-lettura codice errore; 9-lettura posizione; 10-lettura velocità; 11-lettura coppia
* @return   Codice errore
*/
int GetAxleLuaGripperFunc(int id, ref int[] func);

11.54. Scrittura File Slave Robot Ethercat

/**
* @brief Scrittura File Slave Robot Ethercat
* @param [in] type Tipo file slave, 1-aggiornamento file slave; 2-aggiornamento file configurazione slave
* @param [in] slaveID Numero slave
* @param [in] fileName Nome file caricamento
* @return   Codice errore
*/
int SlaveFileWrite(int type, int slaveID, string fileName);

11.55. Caricamento File Protocollo Aperto LUA Estremità

/**
* @brief Caricamento File Protocollo Aperto LUA Estremità
* @param filePath Nome percorso file lua locale ".../AXLE_LUA_End_DaHuan.lua"
* @return Codice errore
*/
int AxleLuaUpload(string filePath);

11.56. Impostare Modalità Boot Slave Ethercat Robot

/**
* @brief Impostare Modalità Boot Slave Ethercat Robot
* @return   Codice errore
*/
int SetSysServoBootMode();

11.57. Esempio Codice Operazioni File LUA Estremità Robot

private void button41_Click(object sender, EventArgs e)
{
    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
    robot.AxleLuaUpload("D://zUP/AXLE_LUA_End_JunDuo_Xinjingcheng.lua");

    AxleComParam param = new AxleComParam(7, 8, 1, 0, 5, 3, 1);
    robot.SetAxleCommunicationParam(param);

    AxleComParam getParam = new AxleComParam();
    robot.GetAxleCommunicationParam(ref getParam);
    Console.WriteLine("GetAxleCommunicationParam param is {0} {1} {2} {3} {4} {5} {6}",
        getParam.baudRate, getParam.dataBit, getParam.stopBit, getParam.verify,
        getParam.timeout, getParam.timeoutTimes, getParam.period);

    robot.SetAxleLuaEnable(1);
    int luaEnableStatus = 0;
    robot.GetAxleLuaEnableStatus(ref luaEnableStatus);
    robot.SetAxleLuaEnableDeviceType(0, 1, 0);

    int forceEnable = 0;
    int gripperEnable = 0;
    int ioEnable = 0;
    robot.GetAxleLuaEnableDeviceType(ref forceEnable, ref gripperEnable, ref ioEnable);
    Console.WriteLine("GetAxleLuaEnableDeviceType param is {0} {1} {2}", forceEnable, gripperEnable, ioEnable);

    int[] func = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
    robot.SetAxleLuaGripperFunc(1, func);
    int[] getFunc = new int[16];
    robot.GetAxleLuaGripperFunc(1, ref getFunc);
    int[] getforceEnable = new int[16];
    int[] getgripperEnable = new int[16];
    int[] getioEnable = new int[16];
    robot.GetAxleLuaEnableDevice(ref getforceEnable, ref getgripperEnable, ref getioEnable);
    Console.WriteLine("\ngetforceEnable status : ");
    foreach (int i in getforceEnable)
    {
        Console.Write(i + ",");
    }
    Console.WriteLine("\ngetgripperEnable status : ");
    foreach (int i in getgripperEnable)
    {
        Console.Write(i + ",");
    }
    Console.WriteLine("\ngetioEnable status : ");
    foreach (int i in getioEnable)
    {
        Console.Write(i + ",");
    }
    Console.WriteLine();
    robot.ActGripper(1, 0);
    Thread.Sleep(2000);
    robot.ActGripper(1, 1);
    Thread.Sleep(2000);
    robot.MoveGripper(1, 90, 10, 100, 50000, 0, 0, 0, 0, 0);
    int pos = 0;
    while (true)
    {
        robot.GetRobotRealTimeState(ref pkg);
        Console.WriteLine("gripper pos is " + pkg.gripper_position);
        Thread.Sleep(100);
    }
}

11.58. Ottenere Stato Pulsante SmartTool

Nuovo nella versione C#SDK-V1.1.3: Web-3.8.2

/**
* @brief Ottenere Stato Pulsante SmartTool
* @param [out] state Stato pulsanti manopola SmartTool;(bit0:0-comunicazione normale; 1-perdita comunicazione; bit1-annulla operazione; bit2-svuota programma;
    bit3-pulsante A; bit4-pulsante B; bit5-pulsante C; bit6-pulsante D; bit7-pulsante E; bit8-pulsante IO; bit9-manuale/automatico; bit10-inizia)
* @return Codice errore
*/
int GetSmarttoolBtnState(ref int state);

11.59. Esempio Codice

Nuovo nella versione C#SDK-V1.1.3: Web-3.8.2

private void button11_Click(object sender, EventArgs e)
{

    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
    int state = 0;
    while (true)
    {
        int rtn = robot.GetSmarttoolBtnState(ref state);
        string binaryString = Convert.ToString(state, 2).PadLeft(32, '0');
        Console.WriteLine($"GetSmarttoolBtnState rtn (binario): {binaryString}");
        Thread.Sleep(100);
    }

}

11.60. Caricamento File Lua Protocollo Aperto

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Caricamento File Lua Protocollo Aperto
* @param  filePath Nome percorso file lua protocollo aperto locale
* @return Codice errore
*/
public int OpenLuaUpload(string filePath)

11.61. Ottenere Parametri Scheda Slave

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Ottenere Parametri Scheda Slave
* @param  type  0-Ethercat，1-CClink, 3-Ethercat, 4-EIP
* @param  version  Versione protocollo
* @param  connState  0-non connesso 1-connesso
* @return   Codice errore
*/
public int GetFieldBusConfig(int[] type, int[] version, int[] connState)

11.62. Scrittura DO Slave

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Scrittura DO Slave
* @param   DOIndex  Numero DO
* @param   wirteNum  Quantità scrittura
* @param   status Valori scrittura, massimo 8
* @return   Codice errore
*/
public int FieldBusSlaveWriteDO(int DOIndex, int wirteNum, int[] status)

11.63. Scrittura AO Slave

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Scrivere AO della stazione slave
* @param [in] AOIndex Numero AO
* @param [in] writeNum Numero di valori da scrivere
* @param [in] status Array di valori da scrivere (massimo 8), AO0~AO15 sono di tipo intero, AO16~AO31 sono di tipo floating point
* @return Codice di errore
*/
public int FieldBusSlaveWriteAO(int AOIndex, int writeNum, double[] status)

11.64. Lettura DI Slave

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Lettura DI Slave
* @param  DOIndex  Numero DI
* @param  readNum  Quantità lettura
* @param  status Valori letti, massimo 8
* @return   Codice errore
*/
public int FieldBusSlaveReadDI(int DOIndex, int readNum, int[] status)

11.65. Lettura AI Slave

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Lettura AI Slave
* @param  AIIndex  Numero AI
* @param  readNum  Quantità lettura
* @param  status Valori letti, massimo 8
* @return   Codice errore
*/
public int FieldBusSlaveReadAI(int AIIndex, int readNum, double[] status)

11.66. Attesa Input DI Esteso

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Attesa Input DI Esteso
* @param  DIIndex Numero DI
* @param  status 0-livello basso; 1-livello alto
* @param  waitMs Tempo massimo attesa(ms)
* @return Codice errore
*/
public int FieldBusSlaveWaitDI(int DIIndex, int status, int waitMs)

11.67. Attesa Input AI Esteso

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Attesa Input AI Esteso
* @param  AIIndex Numero AI
* @param  waitType 0-maggiore; 1-minore
* @param  value Valore AI
* @param  waitMs Tempo massimo attesa(ms)
* @return Codice errore
*/
public int FieldBusSlaveWaitAI(int AIIndex, int waitType, double value, int waitMs)

11.68. Esempio Codice Istruzioni Interfacce Relative Modalità Slave

private void button101_Click(object sender, EventArgs e)
{
    int rtn = 0;

    int type = 0, version = 0, connState = 0;
    int[] ctrl = new int[8];
    double[] ctrlAO = new double[8];
    int[] DI = new int[8];
    double[] AI = new double[8];
    if (rtn != 0)
    {
        return;
    }
    // Caricare e caricare file protocollo aperto
    robot.OpenLuaUpload("E://temp/CtrlDev_field.lua");
    Thread.Sleep(2000);
    robot.SetCtrlOpenLUAName(3, "CtrlDev_field.lua");
    robot.UnloadCtrlOpenLUA(3);
    robot.LoadCtrlOpenLUA(3);
    Thread.Sleep(8000);

    // Ottenere tipo protocollo, versione software, stato connessione con PLC
    robot.GetFieldBusConfig(ref type, ref version, ref connState);
    Console.WriteLine($"type is {type}, version is {version}, connState is {connState}");

    // Scrivere DO0 = 1, DO1 = 0, DO2 = 1
    ctrl[0] = 1;
    ctrl[1] = 0;
    ctrl[2] = 1;
    robot.FieldBusSlaveWriteDO(0, 3, ctrl);

    // Scrivere AO2 = 0x1000
    ctrlAO[0] = 0x1000;
    robot.FieldBusSlaveWriteAO(2, 1, ctrlAO);

    for (int i = 0; i < 100; i++)
    {
        robot.FieldBusSlaveReadDI(0, 4, ref DI);
        Console.WriteLine($"DI0 is {DI[0]}, DI1 is {DI[1]}, DI2 is {DI[2]}, DI3 is {DI[3]}");
        robot.FieldBusSlaveReadAI(0, 3, ref AI);
        Console.WriteLine($"AI0 is {AI[0]}, AI1 is {AI[1]}, AI2 is {AI[2]}");
        Thread.Sleep(10);
    }
    int ret = robot.FieldBusSlaveWaitDI(0, 1, 100);
    Console.WriteLine($"FieldBusSlaveWaitDI result is {ret}");

    ret = robot.FieldBusSlaveWaitAI(0, 0, 400.00f, 100);
    Console.WriteLine($"FieldBusSlaveWaitAI result is {ret}");
}

11.69. Controllo Ventosa a Matrice

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Controllo Ventosa a Matrice
* @param  slaveID Numero slave
* @param  len Lunghezza
* @param  ctrlValue Valore controllo 1-aspirazione massima pressione vuoto 2-aspirazione pressione vuoto impostata 3-fermare aspirazione
* @return Codice errore
*/
public int SetSuckerCtrl(int slaveID, int len, int[] ctrlValue)

11.70. Ottenere Stato Ventosa a Matrice

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Ottenere Stato Ventosa a Matrice
* @param  slaveID Numero slave
* @param  state Stato aspirazione 0-rilascio oggetto 1-rilevato presa oggetto riuscita 2-nessun oggetto aspirato 3-oggetto staccato
* @param  pressValue Pressione vuoto corrente unità kpa
* @param  error Codice errore corrente ventosa
* @return Codice errore
*/
public int GetSuckerState(int slaveID, int[] state, int[] pressValue, int[] error)

11.71. Attesa Stato Ventosa

Nuovo nella versione C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Attesa Stato Ventosa
* @param  slaveID Numero slave
* @param  state Stato aspirazione 0-rilascio oggetto 1-rilevato presa oggetto riuscita 2-nessun oggetto aspirato 3-oggetto staccato
* @param  ms Tempo massimo attesa
* @return Codice errore
*/
public int WaitSuckerState(int slaveID, int state, int ms)