7. Ustawienia bezpieczeństwa robota
7.1. Ustawienie poziomu kolizji
1/**
2* @brief Ustawia poziom kolizji
3* @param [in] mode 0-poziom, 1-procent
4* @param [in] level Próg kolizji, zakres dla poziomu [], zakres dla procentu [0~1]
5* @param [in] config 0-nie aktualizuj pliku konfiguracyjnego, 1-aktualizuj plik konfiguracyjny
6* @return Kod błędu
7*/
8int SetAnticollision(int mode, double[] level, int config);
7.2. Ustawienie strategii po kolizji
1/**
2* @brief Ustawia strategię po kolizji
3* @param [in] strategy 0-zatrzymaj z błędem i wstrzymaj; 1-kontynuuj działanie; 2-zatrzymaj z błędem; 3-tryb momentu grawitacyjnego; 4-tryb odpowiedzi oscylacyjnej; 5-tryb odbicia kolizyjnego
4* @param [in] safeTime Czas bezpiecznego zatrzymania [1000 - 2000] ms
5* @param [in] safeDistance Odległość bezpiecznego zatrzymania [1-150] mm
6* @param [in] safeVel Prędkość bezpiecznego zatrzymania TCP [50-250] mm/s
7* @param [in] safetyMargin Współczynniki bezpieczeństwa j1-j6 [1-10]
8* @return Kod błędu
9*/
10int SetCollisionStrategy(int strategy, int safeTime, int safeDistance, int safeVel,int[] safetyMargin);
7.3. Rozpoczęcie funkcji niestandardowego progu wykrywania kolizji
1/**
2* @brief Rozpoczęcie funkcji niestandardowego progu wykrywania kolizji, ustawienie progów wykrywania kolizji dla strony stawów i strony TCP
3* @param [in] flag 1-tylko wykrywanie stawów włączone; 2-tylko wykrywanie TCP włączone; 3-wykrywanie stawów i TCP włączone jednocześnie
4* @param [in] jointDetectionThreshould Próg wykrywania kolizji stawów j1-j6
5* @param [in] tcpDetectionThreshould Próg wykrywania kolizji TCP, xyzabc
6* @param [in] block 0-nieblokujące; 1-blokujące
7* @return Kod błędu
8*/
9int CustomCollisionDetectionStart(int flag, double[] jointDetectionThreshould, double[] tcpDetectionThreshould, int block);
7.4. Zakończenie funkcji niestandardowego progu wykrywania kolizji
1/**
2* @brief Zakończenie funkcji niestandardowego progu wykrywania kolizji
3* @return Kod błędu
4*/
5int CustomCollisionDetectionEnd()
7.5. Przykład kodu ustawiania poziomu kolizji robota
1private void button24_Click(object sender, EventArgs e)
2{
3 int mode = 0;
4 int config = 1;
5 double[] level1 = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
6 double[] level2 = { 50.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f };
7
8 int rtn = robot.SetAnticollision(mode, level1, config);
9 Console.WriteLine($"SetAnticollision mode 0 rtn is {rtn}");
10 mode = 1;
11 rtn = robot.SetAnticollision(mode, level2, config);
12 Console.WriteLine($"SetAnticollision mode 1 rtn is {rtn}");
13
14 JointPos p1Joint = new JointPos(-11.904f, -99.669f, 117.473f, -108.616f, -91.726f, 74.256f);
15 JointPos p2Joint = new JointPos(-45.615f, -106.172f, 124.296f, -107.151f, -91.282f, 74.255f);
16
17 DescPose p1Desc = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
18 DescPose p2Desc = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);
19
20 ExaxisPos exaxisPos = new ExaxisPos(0.0f, 0.0f, 0.0f, 0.0f);
21 DescPose offdese = new DescPose(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
22 robot.MoveL( p2Joint, p2Desc, 0, 0, 100, 100, 100, 2, exaxisPos, 0, 0, offdese);
23 robot.ResetAllError();
24 int[] safety = { 5, 5, 5, 5, 5, 5 };
25 rtn = robot.SetCollisionStrategy(3, 1000, 150, 250, safety);
26 Console.WriteLine($"SetCollisionStrategy rtn is {rtn}");
27
28 double[] jointDetectionThreshould = { 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 };
29 double[] tcpDetectionThreshould = { 60, 60, 60, 60, 60, 60 };
30 rtn = robot.CustomCollisionDetectionStart(3, jointDetectionThreshould, tcpDetectionThreshould, 0);
31 Console.WriteLine($"CustomCollisionDetectionStart rtn is {rtn}");
32
33 robot.MoveL( p1Joint, p1Desc, 0, 0, 100, 100, 100, -1, exaxisPos, 0, 0, offdese);
34 robot.MoveL( p2Joint, p2Desc, 0, 0, 100, 100, 100, -1, exaxisPos, 0, 0, offdese);
35 rtn = robot.CustomCollisionDetectionEnd();
36 Console.WriteLine($"CustomCollisionDetectionEnd rtn is {rtn}");
37}
7.6. Ustawienie dodatniego limitu
1/**
2* @brief Ustawia dodatni limit
3* @param [in] limit Pozycje sześciu stawów, jednostka deg
4* @return Kod błędu
5*/
6int SetLimitPositive(double[] limit);
7.7. Ustawienie ujemnego limitu
1/**
2* @brief Ustawia ujemny limit
3* @param [in] limit Pozycje sześciu stawów, jednostka deg
4* @return Kod błędu
5*/
6int SetLimitNegative(double[] limit);
7.8. Pobranie kąta miękkiego limitu stawu
1/**
2* @brief Pobiera kąt miękkiego limitu stawu
3* @param [in] flag 0-blokujący, 1-nieblokujący
4* @param [out] negative Kąt ujemnego limitu, jednostka deg
5* @param [out] positive Kąt dodatniego limitu, jednostka deg
6* @return Kod błędu
7*/
8int GetJointSoftLimitDeg(byte flag, ref double[] negative, ref double[] positive);
7.9. Przykład kodu ustawiania limitów robota
1private void btnRobotSafetySet_Click(object sender, EventArgs e)
2{
3 double[] plimit = { 170.0f, 80.0f, 150.0f, 80.0f, 170.0f, 160.0f };
4 robot.SetLimitPositive(plimit);
5 double[] nlimit = { -170.0f, -260.0f, -150.0f, -260.0f, -170.0f, -160.0f };
6 robot.SetLimitNegative(nlimit);
7
8 double[] neg_deg = new double[6] {0,0,0,0,0,0 };
9 double[] pos_deg = new double[6] { 0, 0, 0, 0, 0, 0 };
10 robot.GetJointSoftLimitDeg(0, ref neg_deg,ref pos_deg);
11 Console.WriteLine($"neg limit deg:{neg_deg[0]},{neg_deg[1]},{neg_deg[2]},{neg_deg[3]},{neg_deg[4]},{neg_deg[5]}");
12 Console.WriteLine($"pos limit deg:{pos_deg[0]},{pos_deg[1]},{pos_deg[2]},{pos_deg[3]},{pos_deg[4]},{pos_deg[5]}");
13}
7.10. Ustawienie metody wykrywania kolizji robota
1/**
2* @brief Ustawia metodę wykrywania kolizji robota
3* @param [in] method Metoda wykrywania kolizji: 0-tryb prądowy; 1-podwójny enkoder; 2-tryb prądowy i podwójny enkoder włączone jednocześnie
4* @param [in] thresholdMode Sposób progu poziomu kolizji; 0-stały próg poziomu kolizji; 1-niestandardowy próg wykrywania kolizji
5* @return Kod błędu
6*/
7int SetCollisionDetectionMethod(int method,int thresholdMode=0);
7.11. Ustawienie włączania/wyłączania wykrywania kolizji w stanie spoczynku
1/**
2* @brief Ustawia włączanie/wyłączanie wykrywania kolizji w stanie spoczynku
3* @param [in] status 0-wyłączone; 1-włączone
4* @return Kod błędu
5*/
6int SetStaticCollisionOnOff(int status);
7.12. Przykład kodu ustawiania metody wykrywania kolizji robota
1private void button26_Click(object sender, EventArgs e)
2{
3 int rtn = robot.SetCollisionDetectionMethod(0, 0);
4
5 rtn = robot.SetStaticCollisionOnOff(1);
6 Console.WriteLine($"SetStaticCollisionOnOff On rtn is {rtn}");
7 Thread.Sleep(5000);
8 rtn = robot.SetStaticCollisionOnOff(0);
9 Console.WriteLine($"SetStaticCollisionOnOff Off rtn is {rtn}");
10}
7.13. Wykrywanie momentu obrotowego i mocy stawu
1/**
2* @brief Wykrywanie momentu obrotowego i mocy stawu
3* @param [in] status 0-wyłączone; 1-włączone
4* @param [in] power Ustawiona maksymalna moc (W)
5* @return Kod błędu
6*/
7int SetPowerLimit(int status, double power);
7.14. Przykład kodu wykrywania momentu obrotowego i mocy stawu
1private void button26_Click(object sender, EventArgs e)
2{
3 robot.DragTeachSwitch(1);
4 robot.SetPowerLimit(1, 200);
5 double[] torques = { 0, 0, 0, 0, 0, 0 };
6 robot.GetJointTorques(1, torques);
7
8 int count = 100;
9 robot.ServoJTStart();
10 int error = 0;
11 while (count > 0)
12 {
13 error = robot.ServoJT(torques, 0.001f);
14 count--;
15 Thread.Sleep(1);
16 }
17 error = robot.ServoJTEnd();
18 robot.DragTeachSwitch(0);
19}
7.15. Ustawienie parametrów bezpiecznej prędkości
1/**
2* @brief Ustawia parametry bezpiecznej prędkości
3* @param [in] enable 0-wył.; 1-włącz w trybie ręcznym; 2-włącz we wszystkich trybach (nie obsługuje automatycznego ograniczenia prędkości)
4* @param [in] maxTCPVel Maksymalna prędkość TCP do ograniczenia; [0-1000] mm/s
5* @param [in] strategy Strategia po przekroczeniu prędkości; 0-zatrzymaj z alarmem; 1-automatyczne ograniczenie prędkości; 2-zatrzymaj z alarmem i odłącz
6* @param [in] maxJointVel Maksymalna prędkość dla 6 stawów (°/s), domyślnie 45°/s
7* @return Kod błędu
8*/
9public int SetVelReducePara(int enable, double maxTCPVel, int strategy, double[] maxJointVel = null)
7.16. Przykład kodu SDK ustawiania parametrów bezpiecznej prędkości
1public int TestSetVelReducePara()
2{
3 int rtn = 0;
4 JointPos j1 = new JointPos(10.220, -11.121, -118.086, -46.739, 82.036, 131.503);
5 JointPos j2 = new JointPos(89.782, -11.122, -118.086, -46.740, 82.036, 131.504);
6 ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
7 DescPose offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
8 double[] maxJointVel = new double[] { 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 };
9
10 robot.SetSpeed(20);
11 rtn = robot.SetVelReducePara(0, 200, 0, maxJointVel);
12 robot.MoveJ(j2, 1, 2, 100, 100, 100, epos, -1, 0, offset_pos);
13
14 // 1st
15 rtn = robot.SetVelReducePara(2, 200, 0, maxJointVel);
16 Console.WriteLine($"SetVelReduceParaA param error rtn is {rtn}");
17 robot.MoveJ(j1, 1, 2, 100, 100, 100, epos, -1, 0, offset_pos);
18 robot.MoveJ(j2, 1, 2, 100, 100, 100, epos, -1, 0, offset_pos);
19
20 // 2rd
21 maxJointVel = new double[] { 20.0, 20.0, 20.0, 20.0, 20.0, 20.0 };
22 rtn = robot.SetVelReducePara(2, 200, 0, maxJointVel);
23 Console.WriteLine($"SetVelReduceParaB reduce vel rtn is {rtn}");
24 robot.MoveJ(j1, 1, 2, 100, 100, 100, epos, -1, 0, offset_pos);
25 robot.MoveJ(j2, 1, 2, 100, 100, 100, epos, -1, 0, offset_pos);
26 return 0;
27}
7.17. Pobieranie Sumy Kontrolnej Parametrów Konfiguracji Bezpieczeństwa
1/**
2* @brief Pobiera sumę kontrolną parametrów konfiguracji bezpieczeństwa
3* @param [out] status Status weryfikacji, 0-ważny, 1-w trakcie weryfikacji, 2-weryfikacja nieudana
4* @param [out] checksum Suma kontrolna, 8-cyfrowa liczba szesnastkowa
5* @return Kod błędu
6*/
7public int GetSafetyParamsCheckSum(ref int status, ref uint checksum)
7.18. Ustawianie włączenia szyfrowania mTLS i ścieżki certyfikatu
1//Główny przełącznik mTLS: domyślnie false; przed inicjalizacją RPC ustaw false, aby wymusić tryb jawny
2public bool EnableMtls { get; set; } = false;
3
4//Katalog certyfikatów mTLS: domyślnie null = certs/ w tym samym katalogu co dll SDK; należy ustawić przed RPC()
5public string MtlsCertDir { get; set; }
7.19. Przykład kodu ustawiania włączenia szyfrowania mTLS i ścieżki certyfikatu
1public Form1()
2{
3 InitializeComponent();
4 robot = new Robot();//Utwórz instancję obiektu robota
5 string path = "D://log/";
6 robot.LoggerInit(FrLogType.BUFFER, FrLogLevel.INFO, path, 5, 5);
7 robot.SetLoggerLevel(FrLogLevel.INFO);
8
9 // Wyświetl końcową konfigurację CNDE
10 List<RobotState> finalStates;
11 int finalPeriod;
12 robot.GetRobotRealtimeStateConfig(out finalStates, out finalPeriod);
13 Console.WriteLine($"Liczba stanów końcowej konfiguracji: {finalStates.Count}");
14 foreach (var s in finalStates) Console.WriteLine($" {s}");
15 Console.WriteLine($"Końcowy okres: {finalPeriod} ms");
16 robot.SetReconnectParam(true, 1000, 500);//Parametry ponownego połączenia
17
18 robot.EnableMtls = true;
19 robot.MtlsCertDir = @"D:\C#SDK\MTLS-certs"; // Jeśli ścieżka certyfikatu nie zostanie ustawiona, domyślnie jest to <katalog libfairino.dll>\certs
20 rrpc = robot.RPC("192.168.58.2"); //Nawiąż połączenie ze skrzynką sterowniczą
21 //Limit czasu odbioru portu 20004
22 //robot.SetReceivePortTimeout(40);
23}
7.20. Weryfikacja Hasła Operacji Bezpieczeństwa
1/**
2* @brief Weryfikacja hasła operacji bezpieczeństwa
3* @param [in] status Weryfikacja, 0-włączona, 1-wyłączona
4* @param [in] password Hasło
5* @return Kod błędu
6*/
7public int SafetyOPPasswordCheck(int status, string password)
7.21. Przykład Kodu Pobierania Sumy Kontrolnej Parametrów Konfiguracji Bezpieczeństwa i Weryfikacji Hasła Operacji Bezpieczeństwa
1public void TestSafetyParamsCheckSum()
2{
3 int status = 0;
4 uint checksum = 0;
5
6 int error = robot.GetSafetyParamsCheckSum(ref status, ref checksum);
7 Console.WriteLine("GetSafetyParamsCheckSum: error={0}, status={1}, hex_code={2:X8}", error, status, checksum);
8 Thread.Sleep(3000);
9
10 error = robot.SafetyOPPasswordCheck(0, "12345678");
11 Console.WriteLine("SafetyOPPasswordCheck: error={0}", error);
12
13 if (error == 0)
14 {
15 error = robot.SetAnticollision(0, new double[] { 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 }, 1);
16 Console.WriteLine("SetAnticollision: error={0}", error);
17
18 error = robot.SetCollisionStrategy(0, 1000, 150, 0, new int[] { 10, 10, 10, 10, 10, 10 });
19 Console.WriteLine("SetCollisionStrategy: error={0}", error);
20 }
21
22 Thread.Sleep(1000);
23
24 error = robot.GetSafetyParamsCheckSum(ref status, ref checksum);
25 Console.WriteLine("GetSafetyParamsCheckSum(again): error={0}, status={1}, hex_code={2:X8}", error, status, checksum);
26}