11. Urządzenia peryferyjne robota

11.1. Konfiguracja chwytaka

/**
* @brief  Konfiguruje chwytak
* @param  [in] company  Producent chwytaka, do ustalenia
* @param  [in] device  Numer urządzenia, tymczasowo nieużywane, domyślnie 0
* @param  [in] softvesion  Numer wersji oprogramowania, tymczasowo nieużywane, domyślnie 0
* @param  [in] bus Pozycja magistrali, na której zawieszono urządzenie, tymczasowo nieużywane, domyślnie 0
* @return  Kod błędu
*/
int SetGripperConfig(int company, int device, int softvesion, int bus);

11.2. Pobranie konfiguracji chwytaka

/**
* @brief  Pobiera konfigurację chwytaka
* @param  [in] company  Producent chwytaka, do ustalenia
* @param  [in] device  Numer urządzenia, tymczasowo nieużywane, domyślnie 0
* @param  [in] softvesion  Numer wersji oprogramowania, tymczasowo nieużywane, domyślnie 0
* @param  [in] bus Pozycja magistrali, na której zawieszono urządzenie, tymczasowo nieużywane, domyślnie 0
* @return  Kod błędu
*/
int GetGripperConfig(int *company, int *device, int *softvesion, int *bus);

11.3. Aktywacja chwytaka

/**
* @brief  Aktywuje chwytak
* @param  [in] index  Numer chwytaka
* @param  [in] act  0-reset, 1-aktywacja
* @return  Kod błędu
*/
int ActGripper(int index, byte act);

11.4. Sterowanie chwytakiem

/**
* @brief  Steruje chwytakiem
* @param  [in] index  Numer chwytaka
* @param  [in] pos  Procent pozycji, zakres [0~100]
* @param  [in] vel  Procent prędkości, zakres [0~100]
* @param  [in] force  Procent momentu, zakres [0~100]
* @param  [in] max_time  Maksymalny czas oczekiwania, zakres [0~30000], jednostka ms
* @param  [in] block  0-blokujące, 1-nieblokujące
* @param  [in] type Typ chwytaka, 0-chwytak równoległy; 1-chwytak obrotowy
* @param  [in] rotNum Liczba obrotów
* @param  [in] rotVel Procent prędkości obrotowej [0-100]
* @param  [in] rotTorque Procent momentu obrotowego [0-100]
* @return  Kod błędu
*/
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. Pobranie stanu ruchu chwytaka

/**
* @brief  Pobiera stan ruchu chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] staus  0-ruch nieukończony, 1-ruch ukończony
* @return  Kod błędu
*/
int GetGripperMotionDone(ref int fault, ref int status);

11.6. Pobranie stanu aktywacji chwytaka

/**
* @brief  Pobiera stan aktywacji chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] status  bit0~bit15 odpowiadają numerom chwytaka 0~15, bit=0 oznacza nieaktywny, bit=1 oznacza aktywny
* @return  Kod błędu
*/
int GetGripperActivateStatus(ref int fault, ref int status);

11.7. Pobranie pozycji chwytaka

/**
* @brief  Pobiera pozycję chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] position  Procent pozycji, zakres 0~100%
* @return  Kod błędu
*/
int GetGripperCurPosition(ref int fault, ref int position);

11.8. Pobranie prędkości chwytaka

/**
* @brief  Pobiera prędkość chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] speed  Procent prędkości, zakres 0~100%
* @return  Kod błędu
*/
int GetGripperCurSpeed(ref int fault, ref int speed);

11.9. Pobranie prądu chwytaka

/**
* @brief  Pobiera prąd chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] current  Procent prądu, zakres 0~100%
* @return  Kod błędu
*/
int GetGripperCurCurrent(ref int fault, ref int current);

11.10. Pobranie napięcia chwytaka

/**
* @brief  Pobiera napięcie chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] voltage  Napięcie, jednostka 0,1 V
* @return  Kod błędu
*/
int GetGripperVoltage(ref int fault, ref int voltage);

11.11. Pobranie temperatury chwytaka

/**
* @brief  Pobiera temperaturę chwytaka
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] temp  Temperatura, jednostka °C
* @return  Kod błędu
*/
int GetGripperTemp(ref int fault, ref int temp);

11.12. Obliczenie punktu wstępnego chwytania - wizja

/**
* @brief Oblicza punkt wstępnego chwytania - wizja
* @param [in] desc_pos Pozycja i orientacja kartezjańska punktu chwytania
* @param [in] zlength Przesunięcie w osi Z
* @param [in] zangle Przesunięcie kątowe wokół osi Z
* @param [out] pre_pos Punkt wstępnego chwytania
* @return Kod błędu
*/
int ComputePrePick(DescPose desc_pos, double zlength, double zangle, ref DescPose pre_pos);

11.13. Obliczenie punktu wycofania - wizja

/**
* @brief Oblicza punkt wycofania - wizja
* @param [in] desc_pos Pozycja i orientacja kartezjańska punktu wycofania
* @param [in] zlength Przesunięcie w osi Z
* @param [in] zangle Przesunięcie kątowe wokół osi Z
* @param [out] post_pos Punkt wycofania
* @return Kod błędu
*/
int ComputePostPick(DescPose desc_pos, double zlength, double zangle, ref DescPose post_pos);

11.14. Przykład kodu operacji chwytakiem robota

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. Pobranie liczby obrotów chwytaka obrotowego

/**
* @brief  Pobiera liczbę obrotów chwytaka obrotowego
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] num  Liczba obrotów
* @return  Kod błędu
*/
int GetGripperRotNum(ref UInt16 fault, ref double num);

11.16. Pobranie procentu prędkości obrotowej chwytaka obrotowego

/**
* @brief  Pobiera procent prędkości obrotowej chwytaka obrotowego
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] speed  Procent prędkości obrotowej
* @return  Kod błędu
*/
int GetGripperRotSpeed(ref UInt16 fault, ref int speed);

11.17. Pobranie procentu momentu obrotowego chwytaka obrotowego

/**
* @brief  Pobiera procent momentu obrotowego chwytaka obrotowego
* @param  [out] fault  0-brak błędu, 1-wystąpił błąd
* @param  [out] torque  Procent momentu obrotowego
* @return  Kod błędu
*/
int GetGripperRotTorque(ref UInt16 fault, ref int torque);

11.18. Przykład kodu pobierania stanu chwytaka obrotowego

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. Uruchomienie, zatrzymanie taśmociągu

/**
* @brief Uruchomienie, zatrzymanie taśmociągu
* @param [in] status Stan, 1-uruchom, 0-zatrzymaj
* @return Kod błędu
*/
int ConveyorStartEnd(byte status);

11.20. Zapis punktu detekcji I/O

/**
* @brief Zapis punktu detekcji I/O
* @return Kod błędu
*/
int ConveyorPointIORecord();

11.21. Zapis punktu A

/**
* @brief Zapis punktu A
* @return Kod błędu
*/
int ConveyorPointARecord();

11.22. Zapis punktu odniesienia

/**
* @brief Zapis punktu odniesienia
* @return Kod błędu
*/
int ConveyorRefPointRecord();

11.23. Zapis punktu B

/**
* @brief Zapis punktu B
* @return Kod błędu
*/
int ConveyorPointBRecord();

11.24. Detekcja I/O przedmiotu na taśmociągu

/**
* @brief Detekcja I/O przedmiotu na taśmociągu
* @param [in] max_t Maksymalny czas detekcji, jednostka ms
* @return Kod błędu
*/
int ConveyorIODetect(int max_t);

11.25. Pobranie bieżącej pozycji przedmiotu

/**
* @brief Pobranie bieżącej pozycji przedmiotu
* @param [in] mode 1-śledzenie chwytania, 2-śledzenie ruchu, 3-śledzenie TPD
* @return Kod błędu
*/
int ConveyorGetTrackData(int mode);

11.26. Rozpoczęcie śledzenia taśmociągu

/**
* @brief Rozpoczęcie śledzenia taśmociągu
* @param [in] status Stan, 1-uruchom, 0-zatrzymaj
* @return Kod błędu
*/
int ConveyorTrackStart(byte status);

11.27. Zatrzymanie śledzenia taśmociągu

/**
* @brief Zatrzymanie śledzenia taśmociągu
* @return Kod błędu
*/
int ConveyorTrackEnd();

11.28. Konfiguracja parametrów taśmociągu

/**
* @brief Konfiguracja parametrów taśmociągu
* @param [in] para[0] Kanał enkodera 1~2
* @param [in] para[1] Liczba impulsów enkodera na jeden obrót
* @param [in] para[2] Odległość przebyta przez taśmociąg na jeden obrót enkodera
* @param [in] para[3] Numer układu współrzędnych przedmiotu dla funkcji śledzenia ruchu, dla śledzenia chwytania i śledzenia TPD ustaw na 0
* @param [in] para[4] Czy z wizją 0-bez 1-z
* @param [in] para[5] Współczynnik prędkości dla opcji śledzenia chwytania taśmociągu (1-100) dla innych opcji domyślnie 1
* @param [in] followType Typ ruchu śledzenia, 0-ruch śledzący; 1-ruch doganiający
* @param [in] startDis Dla chwytania doganiającego, odległość początkowa śledzenia, -1: automatyczne obliczenie (po dotarciu przedmiotu pod robota), jednostka mm, wartość domyślna 0
* @param [in] endDis Dla chwytania doganiającego, odległość końcowa śledzenia, jednostka mm, wartość domyślna 100
* @return Kod błędu
*/
int ConveyorSetParam(int encChannel, int resolution, double lead, int wpAxis, int vision, double speedRadio, int followType, int startDis=0, int endDis=100);

11.29. Ustawienie kompensacji punktu chwytania taśmociągu

/**
* @brief Ustawienie kompensacji punktu chwytania taśmociągu
* @param [in] cmp Pozycja kompensacji double[3]{x, y, z}
* @return Kod błędu
*/
int ConveyorCatchPointComp(double[] cmp);

11.30. Ruch liniowy śledzenia taśmociągu

/**
* @brief Ruch liniowy śledzenia taśmociągu
* @param [in] name Nazwa punktu ruchu
* @param [in] tool Numer układu współrzędnych narzędzia, zakres [0~14]
* @param [in] wobj Numer układu współrzędnych przedmiotu, zakres [0~14]
* @param [in] vel Procent prędkości, zakres [0~100]
* @param [in] acc Procent przyspieszenia, zakres [0~100], tymczasowo nieudostępnione
* @param [in] ovl Współczynnik skalowania prędkości, zakres [0~100]
* @param [in] blendR [-1.0]-ruch do pozycji (blokujący), [0~1000.0]-promień wygładzenia (nieblokujący), jednostka mm
* @return Kod błędu
*/
int ConveyorTrackMoveL(string name, int tool, int wobj, float vel, float acc, float ovl, float blendR);

11.31. Detekcja wejścia komunikacji taśmociągu

/**
* @brief Detekcja wejścia komunikacji taśmociągu
* @param [in] timeout Czas oczekiwania na przekroczenie limitu ms
* @return Kod błędu
*/
int ConveyorComDetect(int timeout);

11.32. Wyzwolenie detekcji wejścia komunikacji taśmociągu

/**
* @brief Wyzwolenie detekcji wejścia komunikacji taśmociągu
* @return Kod błędu
*/
int ConveyorComDetectTrigger();

11.33. Przykładowy program wyzwalania detekcji wejścia komunikacji taśmociągu

private void button3_Click(object sender, EventArgs e)
{

    // Wyłącz przycisk, aby zapobiec wielokrotnemu kliknięciu
    button3.Enabled = false;

    // Wykonaj operację czasochłonną w wątku tła
    Thread conveyorThread = new Thread(ConveyorTest);
    conveyorThread.IsBackground = true;
    conveyorThread.Start();
}

private void button4_Click(object sender, EventArgs e)
{
    // Pobierz dane wejściowe użytkownika
    string input = texBox.Text;
    Console.WriteLine($"please input a number to trigger:{input}");

    int rtn = robot.ConveyorComDetectTrigger();
    Console.WriteLine($"ConveyorComDetectTrigger 返回值: {rtn}");

}

private void ConveyorTest()
{
    // Użyj Invoke do aktualizacji kontrolek w wątku UI
    this.Invoke((MethodInvoker)delegate {
        Console.WriteLine("开始传送带测试...");
    });

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

    /* Przebieg chwytania taśmociągu */
    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);

    // Przejdź do bezpiecznej pozycji
    retval = robot.MoveL(homejointPos, homePose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);
    Console.WriteLine($"MoveL 到安全位置返回值: {retval}");

    // Detekcja taśmociągu
    retval = robot.ConveryComDetect(1000 * 10);
    Console.WriteLine($"ConveyorComDetect 返回值: {retval}");

    // Pobierz dane śledzenia
    retval = robot.ConveyorGetTrackData(2);
    Console.WriteLine($"ConveyorGetTrackData 返回值: {retval}");

    // Rozpocznij śledzenie
    retval = robot.ConveyorTrackStart(2);
    Console.WriteLine($"ConveyorTrackStart 返回值: {retval}");

    // Przejdź do pozycji początkowej
    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);

    // Zakończ śledzenie
    retval = robot.ConveyorTrackEnd();
    Console.WriteLine($"ConveyorTrackEnd 返回值: {retval}");

    // Wróć do bezpiecznej pozycji
    robot.MoveL(homejointPos, homePose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);

    this.Invoke((MethodInvoker)delegate {
        Console.WriteLine("传送带测试完成!");
        button3.Enabled = true;
    });
}

11.34. Przykładowy program operacji taśmociągu robota

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. Konfiguracja czujnika końcowego

/**
* @brief  Konfiguruje czujnik końcowy
* @param  [in] idCompany Producent, 18-JUNKONG; 25-HUIDE
* @param  [in] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
* @param  [in] idSoftware Wersja oprogramowania, 0-J1.0/HuiDe1.0 (tymczasowo nieudostępnione)
* @param  [in] idBus Miejsce podłączenia, 1-port końcowy 1; 2-port końcowy 2...8-port końcowy 8 (tymczasowo nieudostępnione)
* @return  Kod błędu
*/
int AxleSensorConfig(int idCompany, int idDevice, int idSoftware, int idBus);

11.36. Pobranie konfiguracji czujnika końcowego

/**
* @brief  Pobiera konfigurację czujnika końcowego
* @param  [out] idCompany Producent, 18-JUNKONG; 25-HUIDE
* @param  [out] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
* @return  Kod błędu
*/
int AxleSensorConfigGet(ref int idCompany, ref int idDevice);

11.37. Aktywacja czujnika końcowego

/**
* @brief  Aktywuje czujnik końcowy
* @param  [in] actFlag 0-reset; 1-aktywacja
* @return  Kod błędu
*/
int AxleSensorActivate(int actFlag);

11.38. Zapis do rejestru czujnika końcowego

/**
* @brief  Zapis do rejestru czujnika końcowego
* @param  [in] devAddr  Numer adresu urządzenia 0-255
* @param  [in] regHAddr Wysoka 8 bitów adresu rejestru
* @param  [in] regLAddr Niska 8 bitów adresu rejestru
* @param  [in] regNum  Liczba rejestrów 0-255
* @param  [in] data1 Wartość 1 zapisywana do rejestru
* @param  [in] data2 Wartość 2 zapisywana do rejestru
* @param  [in] isNoBlock 0-blokujące; 1-nieblokujące
* @return  Kod błędu
*/
 int AxleSensorRegWrite(int devAddr, int regHAddr, int regLAddr, int regNum, int data1, int data2, int isNoBlock);

11.39. Przykład kodu czujnika końcowego

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. Pobranie protokołu urządzenia peryferyjnego robota

Nowe w wersji C#SDK-v1.0.6.

/**
* @brief Pobiera protokół urządzenia peryferyjnego robota
* @param [out] protocol Numer protokołu urządzenia peryferyjnego robota 4096-karta sterująca osią rozszerzoną; 4097-ModbusSlave; 4098-ModbusMaster
* @return Kod błędu
*/
int GetExDevProtocol(ref int protocol);

11.41. Ustawienie protokołu urządzenia peryferyjnego robota

Nowe w wersji C#SDK-v1.0.6.

/**
* @brief Ustawia protokół urządzenia peryferyjnego robota
* @param [in] protocol Numer protokołu urządzenia peryferyjnego robota 4096-karta sterująca osią rozszerzoną; 4097-ModbusSlave; 4098-ModbusMaster
* @return Kod błędu
*/
int SetExDevProtocol(int protocol);

11.42. Przykładowy program ustawiania protokołu urządzenia peryferyjnego robota

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. Pobranie parametrów komunikacji końcowej

/**
* @brief Pobiera parametry komunikacji końcowej
* @param param Parametry komunikacji końcowej
* @return  Kod błędu
*/
int GetAxleCommunicationParam(ref AxleComParam getParam);

11.44. Ustawienie parametrów komunikacji końcowej

/**
* @brief Ustawia parametry komunikacji końcowej
* @param param  Parametry komunikacji końcowej
* @return  Kod błędu
*/
int SetAxleCommunicationParam(AxleComParam param);

11.45. Ustawienie typu przesyłania plików końcowych

/**
* @brief Ustawia typ przesyłania plików końcowych
* @param type 1-plik aktualizacji MCU; 2-plik LUA
* @return  Kod błędu
*/
int SetAxleFileType(int type);

11.46. Ustawienie włączenia wykonania LUA końcowego

/**
* @brief Ustawia włączenie wykonania LUA końcowego
* @param enable 0-nie włączaj; 1-włączaj
* @return  Kod błędu
*/
int SetAxleLuaEnable(int enable);

11.47. Przywracanie błędu wyjątkowego pliku LUA końcowego

/**
* @brief Przywracanie błędu wyjątkowego pliku LUA końcowego
* @param status 0-nie przywracaj; 1-przywracaj
* @return  Kod błędu
*/
int SetRecoverAxleLuaErr(int status);

11.48. Pobranie stanu włączenia wykonania LUA końcowego

/**
* @brief Pobiera stan włączenia wykonania LUA końcowego
* @param [out] status 0-nie włączone; 1-włączone
* @return  Kod błędu
*/
int GetAxleLuaEnableStatus(ref int status);

11.49. Ustawienie typu włączenia urządzenia końcowego LUA końcowego

/**
* @brief Ustawia typ włączenia urządzenia końcowego LUA końcowego
* @param [in] forceSensorEnable Stan włączenia czujnika siły, 0-nie włączaj; 1-włączaj
* @param [in] gripperEnable Stan włączenia chwytaka, 0-nie włączaj; 1-włączaj
* @param [in] IOEnable Stan włączenia urządzenia I/O, 0-nie włączaj; 1-włączaj
* @return  Kod błędu
*/
int SetAxleLuaEnableDeviceType(int forceSensorEnable, int gripperEnable, int IOEnable);

11.50. Pobranie typu włączenia urządzenia końcowego LUA końcowego

/**
* @brief Pobiera typ włączenia urządzenia końcowego LUA końcowego
* @param [out] forceSensorEnable Stan włączenia czujnika siły, 0-nie włączaj; 1-włączaj
* @param [out] gripperEnable Stan włączenia chwytaka, 0-nie włączaj; 1-włączaj
* @param [out] IOEnable Stan włączenia urządzenia I/O, 0-nie włączaj; 1-włączaj
* @return  Kod błędu
*/
int GetAxleLuaEnableDeviceType(ref int forceSensorEnable, ref int gripperEnable, ref int IOEnable);

11.51. Pobranie aktualnie skonfigurowanego urządzenia końcowego

/**
* @brief Pobiera aktualnie skonfigurowane urządzenie końcowe
* @param [out] forceSensorEnable Numer włączonego urządzenia czujnika siły 0-nie włączone; 1-włączone
* @param [out] gripperEnable Numer włączonego urządzenia chwytaka, 0-nie włączone; 1-włączone
* @param [out] IODeviceEnable Numer włączonego urządzenia I/O, 0-nie włączone; 1-włączone
* @return  Kod błędu
*/
int GetAxleLuaEnableDevice(ref int[] forceSensorEnable, ref int[] gripperEnable, ref int[] IODeviceEnable);

11.52. Ustawienie włączenia funkcji sterowania ruchem chwytaka

/**
* @brief Ustawia włączenie funkcji sterowania ruchem chwytaka
* @param [in] id Numer urządzenia chwytaka
* @param [in] func func[0]-załączenie chwytaka; func[1]-inicjalizacja chwytaka; 2-ustawienie pozycji; 3-ustawienie prędkości; 4-ustawienie momentu; 6-odczyt stanu chwytaka; 7-odczyt stanu inicjalizacji; 8-odczyt kodu błędu; 9-odczyt pozycji; 10-odczyt prędkości; 11-odczyt momentu
* @return  Kod błędu
*/
int SetAxleLuaGripperFunc(int id, int[] func);

11.53. Pobranie włączenia funkcji sterowania ruchem chwytaka

/**
* @brief Pobiera włączenie funkcji sterowania ruchem chwytaka
* @param [in] id Numer urządzenia chwytaka
* @param [out] func func[0]-załączenie chwytaka; func[1]-inicjalizacja chwytaka; 2-ustawienie pozycji; 3-ustawienie prędkości; 4-ustawienie momentu; 6-odczyt stanu chwytaka; 7-odczyt stanu inicjalizacji; 8-odczyt kodu błędu; 9-odczyt pozycji; 10-odczyt prędkości; 11-odczyt momentu
* @return  Kod błędu
*/
int GetAxleLuaGripperFunc(int id, ref int[] func);

11.54. Zapis pliku stacji podrzędnej Ethercat robota

/**
* @brief Zapis pliku stacji podrzędnej Ethercat robota
* @param [in] type Typ pliku stacji podrzędnej, 1-aktualizacja pliku stacji podrzędnej; 2-aktualizacja pliku konfiguracyjnego stacji podrzędnej
* @param [in] slaveID Numer stacji podrzędnej
* @param [in] fileName Nazwa przesyłanego pliku
* @return  Kod błędu
*/
int SlaveFileWrite(int type, int slaveID, string fileName);

11.55. Przesłanie pliku protokołu otwartego LUA końcowego

/**
* @brief Przesłanie pliku protokołu otwartego LUA końcowego
* @param filePath Ścieżka lokalnego pliku lua ".../AXLE_LUA_End_DaHuan.lua"
* @return Kod błędu
*/
int AxleLuaUpload(string filePath);

11.56. Wejście stacji podrzędnej Ethercat robota w tryb boot

/**
* @brief Wejście stacji podrzędnej Ethercat robota w tryb boot
* @return  Kod błędu
*/
int SetSysServoBootMode();

11.57. Przykład kodu operacji na pliku LUA końcowego robota

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. Pobranie stanu przycisków SmartTool

Nowe w wersji C#SDK-V1.1.3: Web-3.8.2

/**
* @brief Pobiera stan przycisków SmartTool
* @param [out] state Stan przycisków uchwytu SmartTool; (bit0:0-komunikacja normalna; 1-utrata komunikacji; bit1-cofnij operację; bit2-wyczyść program;
    bit3-przycisk A; bit4-przycisk B; bit5-przycisk C; bit6-przycisk D; bit7-przycisk E; bit8-przycisk I/O; bit9-ręczny/automatyczny; bit10-start)
* @return Kod błędu
*/
int GetSmarttoolBtnState(ref int state);

11.59. Przykład kodu

Nowe w wersji 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 (binary): {binaryString}");
        Thread.Sleep(100);
    }

}

11.60. Przesłanie pliku Lua protokołu otwartego

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Przesłanie pliku Lua protokołu otwartego
* @param  filePath Ścieżka lokalnego pliku lua protokołu otwartego
* @return Kod błędu
*/
public int OpenLuaUpload(string filePath)

11.61. Pobranie parametrów karty stacji podrzędnej

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Pobiera parametry karty stacji podrzędnej
* @param  type  0-Ethercat, 1-CClink, 3-Ethercat, 4-EIP
* @param  version  Wersja protokołu
* @param  connState  0-odłączony 1-połączony
* @return  Kod błędu
*/
public int GetFieldBusConfig(int[] type, int[] version, int[] connState)

11.62. Zapis DO stacji podrzędnej

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Zapis DO stacji podrzędnej
* @param   DOIndex  Numer DO
* @param   wirteNum  Liczba zapisywanych
* @param   status Wartości do zapisania, maksymalnie 8
* @return  Kod błędu
*/
public int FieldBusSlaveWriteDO(int DOIndex, int wirteNum, int[] status)

11.63. Zapis AO stacji podrzędnej

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Zapis AO stacji podrzędnej
* @param [in] AOIndex Numer AO
* @param [in] wirteNum Liczba zapisywanych
* @param [in] status Tablica wartości do zapisania (maksymalnie 8), AO0~AO15 są typu całkowitego, AO16~AO31 są typu zmiennoprzecinkowego
* @return Kod błędu
*/
public int FieldBusSlaveWriteAO(int AOIndex, int wirteNum, double[] status)

11.64. Odczyt DI stacji podrzędnej

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Odczyt DI stacji podrzędnej
* @param  DOIndex  Numer DI
* @param  readNum  Liczba odczytywanych
* @param  status Odczytywane wartości, maksymalnie 8
* @return  Kod błędu
*/
public int FieldBusSlaveReadDI(int DOIndex, int readNum, int[] status)

11.65. Odczyt AI stacji podrzędnej

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief  Odczyt AI stacji podrzędnej
* @param  AIIndex  Numer AI
* @param  readNum  Liczba odczytywanych
* @param  status Odczytywane wartości, maksymalnie 8
* @return  Kod błędu
*/
public int FieldBusSlaveReadAI(int AIIndex, int readNum, double[] status)

11.66. Oczekiwanie na wejście rozszerzone DI

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Oczekiwanie na wejście rozszerzone DI
* @param  DIIndex Numer DI
* @param  status 0-poziom niski; 1-poziom wysoki
* @param  waitMs Maksymalny czas oczekiwania (ms)
* @return Kod błędu
*/
public int FieldBusSlaveWaitDI(int DIIndex, int status, int waitMs)

11.67. Oczekiwanie na wejście rozszerzone AI

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Oczekiwanie na wejście rozszerzone AI
* @param  AIIndex Numer AI
* @param  waitType 0-większe niż; 1-mniejsze niż
* @param  value Wartość AI
* @param  waitMs Maksymalny czas oczekiwania (ms)
* @return Kod błędu
*/
public int FieldBusSlaveWaitAI(int AIIndex, int waitType, double value, int waitMs)

11.68. Przykład kodu instrukcji interfejsu trybu stacji podrzędnej

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;
    }
    // Upload and load open protocol file
    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);

    // Get protocol type, software version, and connection status with PLC
    robot.GetFieldBusConfig(ref type, ref version, ref connState);
    Console.WriteLine($"type is {type}, version is {version}, connState is {connState}");

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

    // Write 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. Sterowanie macierzową przyssawką

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Sterowanie macierzową przyssawką
* @param  slaveID Numer stacji podrzędnej
* @param  len Długość
* @param  ctrlValue Wartość sterowania 1-zasysanie z maksymalnym podciśnieniem 2-zasysanie z ustawionym podciśnieniem 3-zatrzymanie zasysania
* @return Kod błędu
*/
public int SetSuckerCtrl(int slaveID, int len, int[] ctrlValue)

11.70. Pobranie stanu macierzowej przyssawki

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Pobranie stanu macierzowej przyssawki
* @param  slaveID Numer stacji podrzędnej
* @param  state Stan przyssania 0-uwolnienie przedmiotu 1-wykryto pomyślne przyssanie przedmiotu 2-brak przyssania przedmiotu 3-oderwanie przedmiotu
* @param  pressValue Bieżące podciśnienie, jednostka kPa
* @param  error Bieżący kod błędu przyssawki
* @return Kod błędu
*/
public int GetSuckerState(int slaveID, int[] state, int[] pressValue, int[] error)

11.71. Oczekiwanie na stan przyssawki

Nowe w wersji C#SDK-V1.1.7: Web-3.8.5

/**
* @brief Oczekiwanie na stan przyssawki
* @param  slaveID Numer stacji podrzędnej
* @param  state Stan przyssania 0-uwolnienie przedmiotu 1-wykryto pomyślne przyssanie przedmiotu 2-brak przyssania przedmiotu 3-oderwanie przedmiotu
* @param  ms Maksymalny czas oczekiwania
* @return Kod błędu
*/
public int WaitSuckerState(int slaveID, int state, int ms)