4. Movimento do Robô

4.1. Movimento Jog

 1/**
 2* @brief Movimento jog
 3* @param [in] ref 0-jog por junta, 2-jog no sistema de coordenadas base, 4-jog no sistema de coordenadas da ferramenta, 8-jog no sistema de coordenadas da peça
 4* @param [in] nb 1-junta1 (ou eixo X), 2-junta2 (ou eixo Y), 3-junta3 (ou eixo Z), 4-junta4 (ou rotação em torno do eixo X), 5-junta5 (ou rotação em torno do eixo Y), 6-junta6 (ou rotação em torno do eixo Z)
 5* @param [in] dir 0-direção negativa, 1-direção positiva
 6* @param [in] vel Percentagem de velocidade, [0~100]
 7* @param [in] acc Percentagem de aceleração, [0~100]
 8* @param [in] max_dis Ângulo máximo por movimento jog, em [°] ou distância, em [mm]
 9* @return Código de erro
10*/
11errno_t StartJOG(uint8_t ref, uint8_t nb, uint8_t dir, float vel, float acc, float max_dis);

4.2. Parada Desacelerada do Movimento Jog

1/**
2* @brief Parada desacelerada do movimento jog
3* @param [in] ref 1-parada de jog por junta, 3-parada de jog no sistema de coordenadas base, 5-parada de jog no sistema de coordenadas da ferramenta, 9-parada de jog no sistema de coordenadas da peça
4* @return Código de erro
5*/
6errno_t StopJOG(uint8_t ref);

4.3. Parada Imediata do Movimento Jog

1/**
2* @brief Parada imediata do movimento jog
3* @return Código de erro
4*/
5errno_t ImmStopJOG();

4.4. Exemplo de Código de Controle de Movimento Jog do Robô

 1int TestJOG(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    for (int i = 0; i < 6; i++)
14    {
15        robot.StartJOG(0, i + 1, 0, 20.0, 20.0, 30.0);
16        robot.Sleep(1000);
17        robot.ImmStopJOG();
18        robot.Sleep(1000);
19    }
20    for (int i = 0; i < 6; i++)
21    {
22        robot.StartJOG(2, i + 1, 0, 20.0, 20.0, 30.0);
23        robot.Sleep(1000);
24        robot.ImmStopJOG();
25        robot.Sleep(1000);
26    }
27    for (int i = 0; i < 6; i++)
28    {
29        robot.StartJOG(4, i + 1, 0, 20.0, 20.0, 30.0);
30        robot.Sleep(1000);
31        robot.StopJOG(5);
32        robot.Sleep(1000);
33    }
34    for (int i = 0; i < 6; i++)
35    {
36        robot.StartJOG(8, i + 1, 0, 20.0, 20.0, 30.0);
37        robot.Sleep(1000);
38        robot.StopJOG(9);
39        robot.Sleep(1000);
40    }
41    robot.CloseRPC();
42    return 0;
43}

4.5. Movimento no Espaço Articular

 1/**
 2* @brief Movimento no espaço articular
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] desc_pos Pose cartesiana alvo
 5* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] user Número da coordenada da peça, intervalo [0~14]
 7* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
10* @param [in] epos Posição do eixo estendido, em mm
11* @param [in] blendT [-1.0]-movimento até o final (bloqueante), [0~500.0]-tempo de suavização (não bloqueante), em ms
12* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
13* @param [in] offset_pos Deslocamento de pose
14* @return Código de erro
15*/
16errno_t MoveJ(JointPos *joint_pos, DescPose *desc_pos, int tool, int user, float vel, float acc, float ovl, ExaxisPos *epos, float blendT, uint8_t offset_flag, DescPose *offset_pos);

4.6. Movimento no Espaço Articular (com cálculo automático de cinemática direta)

 1/**
 2* @brief Movimento no espaço articular (com cálculo automático de cinemática direta)
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] user Número da coordenada da peça, intervalo [0~14]
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
 9* @param [in] epos Posição do eixo estendido, em mm
10* @param [in] blendT [-1.0]-movimento até o final (bloqueante), [0~500.0]-tempo de suavização (não bloqueante), em ms
11* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
12* @param [in] offset_pos Deslocamento de pose
13* @return Código de erro
14*/
15errno_t MoveJ(JointPos* joint_pos, int tool, int user, float vel, float acc, float ovl, ExaxisPos* epos, float blendT, uint8_t offset_flag, DescPose* offset_pos);

4.7. Movimento Linear no Espaço Cartesiano

 1/**
 2* @brief Movimento linear no espaço cartesiano
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] desc_pos Pose cartesiana alvo
 5* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] user Número da coordenada da peça, intervalo [0~14]
 7* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] ovl Fator de escala de velocidade [0~100]/velocidade física (mm/s)
10* @param [in] blendR [-1.0]-movimento até o final (bloqueante), [0~1000.0]-raio de suavização (não bloqueante), em mm
11* @param [in] blendMode Modo de transição; 0-transição tangente; 1-transição de canto
12* @param [in] epos Posição do eixo estendido, em mm
13* @param [in] search 0-sem busca de posição do arame, 1-com busca de posição do arame
14* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
15* @param [in] offset_pos Deslocamento de pose
16* @param [in] oacc Fator de escala de aceleração [0-100]/aceleração física (mm/s2)
17* @param [in] velAccParamMode Modo de parâmetro de velocidade/aceleração; 0-percentagem; 1-velocidade física (mm/s) aceleração (mm/s2)
18* @param [in] overSpeedStrategy Estratégia de tratamento de excesso de velocidade, 1-padrão; 2-parar com erro em caso de excesso de velocidade; 3-redução adaptativa de velocidade, padrão 0
19* @param [in] speedPercent Percentagem limite de redução de velocidade permitida [0-100], padrão 10%
20* @return Código de erro
21*/
22errno_t MoveL(JointPos *joint_pos, DescPose *desc_pos, int tool, int user, float vel, float acc, float ovl, float blendR, int blendMode, ExaxisPos *epos, uint8_t search, uint8_t offset_flag, DescPose *offset_pos, float oacc = 100.0, int velAccParamMode = 0, int overSpeedStrategy = 0, int speedPercent = 10);

4.8. Movimento Linear no Espaço Cartesiano (com cálculo automático de cinemática inversa)

 1/**
 2* @brief Movimento linear no espaço cartesiano (com cálculo automático de cinemática inversa)
 3* @param [in] desc_pos Pose cartesiana alvo
 4* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] user Número da coordenada da peça, intervalo [0~14]
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
 9* @param [in] blendR [-1.0]-movimento até o final (bloqueante), [0~1000.0]-raio de suavização (não bloqueante), em mm
10* @param [in] blendMode Modo de transição; 0-transição tangente; 1-transição de canto
11* @param [in] epos Posição do eixo estendido, em mm
12* @param [in] search 0-sem busca de posição do arame, 1-com busca de posição do arame
13* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
14* @param [in] offset_pos Deslocamento de pose
15* @param [in] config Configuração do espaço articular para cinemática inversa, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base em uma configuração específica do espaço articular
16* @param [in] overSpeedStrategy Estratégia de tratamento de excesso de velocidade, 1-padrão; 2-parar com erro em caso de excesso de velocidade; 3-redução adaptativa de velocidade, padrão 0
17* @param [in] speedPercent Percentagem limite de redução de velocidade permitida [0-100], padrão 10%
18* @return Código de erro
19*/
20errno_t MoveL(DescPose* desc_pos, int tool, int user, float vel, float acc, float ovl, float blendR, int blendMode, ExaxisPos* epos, uint8_t search, uint8_t offset_flag, DescPose* offset_pos, int config = -1, int overSpeedStrategy = 0, int speedPercent = 10);

4.9. Movimento Circular no Espaço Cartesiano

 1/**
 2* @brief Movimento circular no espaço cartesiano
 3* @param [in] joint_pos_p Posição articular do ponto de passagem, em graus
 4* @param [in] desc_pos_p Pose cartesiana do ponto de passagem
 5* @param [in] ptool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] puser Número da coordenada da peça, intervalo [0~14]
 7* @param [in] pvel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] pacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] epos_p Posição do eixo estendido, em mm
10* @param [in] poffset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
11* @param [in] offset_pos_p Deslocamento de pose
12* @param [in] joint_pos_t Posição articular do ponto alvo, em graus
13* @param [in] desc_pos_t Pose cartesiana do ponto alvo
14* @param [in] ttool Número da coordenada da ferramenta, intervalo [0~14]
15* @param [in] tuser Número da coordenada da peça, intervalo [0~14]
16* @param [in] tvel Percentagem de velocidade, intervalo [0~100]
17* @param [in] tacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
18* @param [in] epos_t Posição do eixo estendido, em mm
19* @param [in] toffset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
20* @param [in] offset_pos_t Deslocamento de pose
21* @param [in] ovl Fator de escala de velocidade [0~100]/velocidade física (mm/s)
22* @param [in] blendR [-1.0]-movimento até o final (bloqueante), [0~1000.0]-raio de suavização (não bloqueante), em mm
23* @param [in] oacc Fator de escala de aceleração [0-100]/aceleração física (mm/s2)
24* @param [in] velAccParamMode Modo de parâmetro de velocidade/aceleração; 0-percentagem; 1-velocidade física (mm/s) aceleração (mm/s2)
25* @return Código de erro
26*/
27errno_t MoveC(JointPos *joint_pos_p, DescPose *desc_pos_p, int ptool, int puser, float pvel, float pacc, ExaxisPos *epos_p, uint8_t poffset_flag, DescPose *offset_pos_p, JointPos *joint_pos_t, DescPose *desc_pos_t, int ttool, int tuser, float tvel, float tacc, ExaxisPos *epos_t, uint8_t toffset_flag, DescPose *offset_pos_t, float ovl, float blendR, float oacc = 100.0, int velAccParamMode = 0);

4.10. Movimento Circular no Espaço Cartesiano (com cálculo automático de cinemática inversa)

 1/**
 2* @brief Movimento circular no espaço cartesiano (com cálculo automático de cinemática inversa)
 3* @param [in] desc_pos_p Pose cartesiana do ponto de passagem
 4* @param [in] ptool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] puser Número da coordenada da peça, intervalo [0~14]
 6* @param [in] pvel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] pacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] epos_p Posição do eixo estendido, em mm
 9* @param [in] poffset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
10* @param [in] offset_pos_p Deslocamento de pose
11* @param [in] desc_pos_t Pose cartesiana do ponto alvo
12* @param [in] ttool Número da coordenada da ferramenta, intervalo [0~14]
13* @param [in] tuser Número da coordenada da peça, intervalo [0~14]
14* @param [in] tvel Percentagem de velocidade, intervalo [0~100]
15* @param [in] tacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
16* @param [in] epos_t Posição do eixo estendido, em mm
17* @param [in] toffset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
18* @param [in] offset_pos_t Deslocamento de pose
19* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
20* @param [in] blendR [-1.0]-movimento até o final (bloqueante), [0~1000.0]-raio de suavização (não bloqueante), em mm
21* @param [in] config Configuração do espaço articular para cinemática inversa, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base em uma configuração específica do espaço articular
22* @return Código de erro
23*/
24errno_t MoveC(DescPose* desc_pos_p, int ptool, int puser, float pvel, float pacc, ExaxisPos* epos_p, uint8_t poffset_flag, DescPose* offset_pos_p, DescPose* desc_pos_t, int ttool, int tuser, float tvel, float tacc, ExaxisPos* epos_t, uint8_t toffset_flag, DescPose* offset_pos_t, float ovl, float blendR, int config = -1);

4.11. Movimento Circular Completo no Espaço Cartesiano

 1/**
 2* @brief Movimento circular completo no espaço cartesiano
 3* @param [in] joint_pos_p Posição articular do ponto de passagem 1, em graus
 4* @param [in] desc_pos_p Pose cartesiana do ponto de passagem 1
 5* @param [in] ptool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] puser Número da coordenada da peça, intervalo [0~14]
 7* @param [in] pvel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] pacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] epos_p Posição do eixo estendido, em mm
10* @param [in] joint_pos_t Posição articular do ponto de passagem 2, em graus
11* @param [in] desc_pos_t Pose cartesiana do ponto de passagem 2
12* @param [in] ttool Número da coordenada da ferramenta, intervalo [0~14]
13* @param [in] tuser Número da coordenada da peça, intervalo [0~14]
14* @param [in] tvel Percentagem de velocidade, intervalo [0~100]
15* @param [in] tacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
16* @param [in] epos_t Posição do eixo estendido, em mm
17* @param [in] ovl Fator de escala de velocidade [0~100]/velocidade física (mm/s)
18* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
19* @param [in] offset_pos Deslocamento de pose
20* @param [in] oacc Fator de escala de aceleração [0-100]/aceleração física (mm/s2)
21* @param [in] blendR -1: bloqueante; 0~1000: raio de suavização
22* @param [in] velAccParamMode Modo de parâmetro de velocidade/aceleração; 0-percentagem; 1-velocidade física (mm/s) aceleração (mm/s2)
23* @return Código de erro
24*/
25errno_t Circle(JointPos* joint_pos_p, DescPose* desc_pos_p, int ptool, int puser, float pvel, float pacc, ExaxisPos* epos_p, JointPos* joint_pos_t, DescPose* desc_pos_t, int ttool, int tuser, float tvel, float tacc, ExaxisPos* epos_t, float ovl, uint8_t offset_flag, DescPose* offset_pos, double oacc = 100.0, double blendR = -1, int velAccParamMode = 0);

4.12. Movimento Circular Completo no Espaço Cartesiano (com cálculo automático de cinemática inversa)

 1/**
 2* @brief Movimento circular completo no espaço cartesiano (com cálculo automático de cinemática inversa)
 3* @param [in] desc_pos_p Pose cartesiana do ponto de passagem 1
 4* @param [in] ptool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] puser Número da coordenada da peça, intervalo [0~14]
 6* @param [in] pvel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] pacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] epos_p Posição do eixo estendido, em mm
 9* @param [in] desc_pos_t Pose cartesiana do ponto de passagem 2
10* @param [in] ttool Número da coordenada da ferramenta, intervalo [0~14]
11* @param [in] tuser Número da coordenada da peça, intervalo [0~14]
12* @param [in] tvel Percentagem de velocidade, intervalo [0~100]
13* @param [in] tacc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
14* @param [in] epos_t Posição do eixo estendido, em mm
15* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
16* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
17* @param [in] offset_pos Deslocamento de pose
18* @param [in] oacc Percentagem de aceleração
19* @param [in] blendR -1: bloqueante; 0~1000: raio de suavização
20* @param [in] config Configuração do espaço articular para cinemática inversa, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base em uma configuração específica do espaço articular
21* @return Código de erro
22*/
23errno_t Circle(DescPose* desc_pos_p, int ptool, int puser, float pvel, float pacc, ExaxisPos* epos_p, DescPose* desc_pos_t, int ttool, int tuser, float tvel, float tacc, ExaxisPos* epos_t, float ovl, uint8_t offset_flag, DescPose* offset_pos, double oacc = 100.0, double blendR = -1, int config = -1);

4.13. Movimento Ponto a Ponto no Espaço Cartesiano

 1/**
 2* @brief Movimento ponto a ponto no espaço cartesiano
 3* @param [in] desc_pos Pose cartesiana alvo ou incremento de pose
 4* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] user Número da coordenada da peça, intervalo [0~14]
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
 9* @param [in] blendT [-1.0]-movimento até o final (bloqueante), [0~500.0]-tempo de suavização (não bloqueante), em ms
10* @param [in] config Configuração do espaço articular, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base em uma configuração específica do espaço articular, padrão -1
11* @return Código de erro
12*/
13errno_t MoveCart(DescPose *desc_pos, int tool, int user, float vel, float acc, float ovl, float blendT, int config);

4.14. Exemplo de Código de Instruções Básicas de Movimento do Robô

 1int TestMove(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5
 6    robot.LoggerInit();
 7    robot.SetLoggerLevel(1);
 8    int rtn = robot.RPC("192.168.58.2");
 9    if (rtn != 0)
10    {
11        return -1;
12    }
13    robot.SetReConnectParam(true, 30000, 500);
14
15    JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
16    JointPos j2(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
17    JointPos j3(-29.777, -84.536, 109.275, -114.075, -86.655, 74.257);
18    JointPos j4(-31.154, -95.317, 94.276, -88.079, -89.740, 74.256);
19    DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
20    DescPose desc_pos2(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
21    DescPose desc_pos3(-487.434, 154.362, 308.576, 176.600, 0.268, -14.061);
22    DescPose desc_pos4(-443.165, 147.881, 480.951, 179.511, -0.775, -15.409);
23    DescPose offset_pos(0, 0, 0, 0, 0, 0);
24    ExaxisPos epos(0, 0, 0, 0);
25    int tool = 0;
26    int user = 0;
27    float vel = 100.0;
28    float acc = 100.0;
29    float ovl = 100.0;
30    float oacc = 100.0;
31    float blendT = 0.0;
32    float blendR = 0.0;
33    uint8_t flag = 0;
34    uint8_t search = 0;
35    int blendMode = 0;
36    int velAccMode = 0;
37    robot.SetSpeed(20);
38    rtn = robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
39    printf("movej errcode:%d\n", rtn);
40    rtn = robot.MoveL(&j2, &desc_pos2, tool, user, vel, acc, ovl, blendR, blendMode, &epos, search, flag, &offset_pos, oacc, velAccMode);
41    printf("movel errcode:%d\n", rtn);
42    rtn = robot.MoveC(&j3, &desc_pos3, tool, user, vel, acc, &epos, flag, &offset_pos, &j4, &desc_pos4, tool, user, vel, acc, &epos, flag, &offset_pos, ovl, blendR, oacc, velAccMode);
43    printf("movec errcode:%d\n", rtn);
44    rtn = robot.MoveJ(&j2, &desc_pos2, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
45    printf("movej errcode:%d\n", rtn);
46    rtn = robot.Circle(&j3, &desc_pos3, tool, user, vel, acc, &epos, &j1, &desc_pos1, tool, user, vel, acc, &epos, ovl, flag, &offset_pos, oacc, -1, velAccMode);
47    printf("circle errcode:%d\n", rtn);
48    rtn = robot.MoveCart(&desc_pos4, tool, user, vel, acc, ovl, blendT, -1);
49    printf("MoveCart errcode:%d\n", rtn);
50    rtn = robot.MoveJ(&j1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
51    printf("movej errcode:%d\n", rtn);
52    rtn = robot.MoveL(&desc_pos2, tool, user, vel, acc, ovl, blendR, blendMode, &epos, search, flag, &offset_pos, -1, velAccMode);
53    printf("movel errcode:%d\n", rtn);
54    rtn = robot.MoveC(&desc_pos3, tool, user, vel, acc, &epos, flag, &offset_pos, &desc_pos4, tool, user, vel, acc, &epos, flag, &offset_pos, ovl, blendR, -1, velAccMode);
55    printf("movec errcode:%d\n", rtn);
56    rtn = robot.MoveJ(&j2, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
57    printf("movej errcode:%d\n", rtn);
58    rtn = robot.Circle(&desc_pos3, tool, user, vel, acc, &epos, &desc_pos1, tool, user, vel, acc, &epos, ovl, flag, &offset_pos, oacc, blendR, -1, velAccMode);
59    printf("circle errcode:%d\n", rtn);
60    robot.CloseRPC();
61    return 0;
62}

4.15. Movimento Helicoidal no Espaço Cartesiano

 1/**
 2* @brief Movimento helicoidal no espaço cartesiano
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] desc_pos Pose cartesiana alvo
 5* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] user Número da coordenada da peça, intervalo [0~14]
 7* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] epos Posição do eixo estendido, em mm
10* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
11* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
12* @param [in] offset_pos Deslocamento de pose
13* @param [in] spiral_param Parâmetros da espiral
14* @return Código de erro
15*/
16errno_t NewSpiral(JointPos *joint_pos, DescPose *desc_pos, int tool, int user, float vel, float acc, ExaxisPos *epos, float ovl, uint8_t offset_flag, DescPose *offset_pos, SpiralParam spiral_param);

4.16. Movimento Helicoidal no Espaço Cartesiano (com cálculo automático de cinemática inversa)

 1/**
 2* @brief Movimento helicoidal no espaço cartesiano (com cálculo automático de cinemática inversa)
 3* @param [in] desc_pos Pose cartesiana alvo
 4* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] user Número da coordenada da peça, intervalo [0~14]
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] epos Posição do eixo estendido, em mm
 9* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
10* @param [in] offset_flag 0-sem deslocamento, 1-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
11* @param [in] offset_pos Deslocamento de pose
12* @param [in] spiral_param Parâmetros da espiral
13* @param [in] config Configuração do espaço articular para cinemática inversa, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base em uma configuração específica do espaço articular
14* @return Código de erro
15*/
16errno_t NewSpiral(DescPose* desc_pos, int tool, int user, float vel, float acc, ExaxisPos* epos, float ovl, uint8_t offset_flag, DescPose* offset_pos, SpiralParam spiral_param, int config = -1);

4.17. Exemplo de Código de Movimento Helicoidal

 1int TestSpiral(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return -1;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  JointPos j(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14  DescPose desc_pos(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
15  DescPose offset_pos1(50, 0, 0, -30, 0, 0);
16  DescPose offset_pos2(50, 0, 0, -5, 0, 0);
17  ExaxisPos epos(0, 0, 0, 0);
18  SpiralParam sp;
19  sp.circle_num = 5;
20  sp.circle_angle = 5.0;
21  sp.rad_init = 50.0;
22  sp.rad_add = 10.0;
23  sp.rotaxis_add = 10.0;
24  sp.rot_direction = 0;
25  int tool = 0;
26  int user = 0;
27  float vel = 100.0;
28  float acc = 100.0;
29  float ovl = 100.0;
30  float blendT = 0.0;
31  uint8_t flag = 2;
32  robot.SetSpeed(20);
33  rtn = robot.MoveJ(&j, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos1);
34  printf("movej errcode:%d\n", rtn);
35  rtn = robot.NewSpiral(&desc_pos, tool, user, vel, acc, &epos, ovl, flag, &offset_pos2, sp);
36  printf("newspiral errcode:%d\n", rtn);
37  robot.CloseRPC();
38  return 0;
39}

4.18. Início do Movimento Servo

1/**
2* @brief Início do movimento servo, para uso com instruções ServoJ e ServoCart
3* @param [in] comType Tipo de envio de instrução; 0-xmlrpc; 1-UDP (porta 20007 do robô)
4* @return Código de erro
5*/
6errno_t ServoMoveStart(int comType = 0);

4.19. Fim do Movimento Servo

1/**
2* @brief Fim do movimento servo, para uso com instruções ServoJ e ServoCart
3* @param [in] comType Tipo de envio de instrução; 0-xmlrpc; 1-UDP (porta 20007 do robô)
4* @return Código de erro
5*/
6errno_t ServoMoveEnd(int comType = 0);

4.20. Movimento no Modo Servo no Espaço Articular

 1/**
 2* @brief Movimento no modo servo no espaço articular
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] axisPos Posição do eixo externo, em mm
 5* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível, padrão 0
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100], temporariamente não disponível, padrão 0
 7* @param [in] cmdT Período de envio de instrução, em s, intervalo recomendado [0.001~0.0016]
 8* @param [in] filterT Tempo de filtro, em s, temporariamente não disponível, padrão 0
 9* @param [in] gain Amplificador proporcional da posição alvo, temporariamente não disponível, padrão 0
10* @param [in] id ID da instrução ServoJ, padrão 0
11* @param [in] comType Tipo de envio de instrução; 0-xmlrpc; 1-UDP (porta 20007 do robô)
12* @return Código de erro
13*/
14errno_t ServoJ(JointPos *joint_pos, ExaxisPos* axisPos, float acc, float vel, float cmdT, float filterT, float gain, int id = 0, int comType = 0);

4.21. Programa de Exemplo de Movimento no Modo Servo no Espaço Articular

 1int TestServoJ(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos j(0, 0, 0, 0, 0, 0);
14    ExaxisPos epos(0, 0, 0, 0);
15    float vel = 0.0;
16    float acc = 0.0;
17    float cmdT = 0.008;
18    float filterT = 0.0;
19    float gain = 0.0;
20    uint8_t flag = 0;
21    int count = 500;
22    float dt = 0.1;
23    int cmdID = 0;
24    int ret = robot.GetActualJointPosDegree(flag, &j);
25    if (ret == 0)
26    {
27        robot.ServoMoveStart();
28        while (count)
29        {
30            robot.ServoJ(&j, &epos, acc, vel, cmdT, filterT, gain, cmdID);
31            j.jPos[0] += dt;
32            count -= 1;
33            robot.WaitMs(cmdT * 1000);
34        }
35        robot.ServoMoveEnd();
36    }
37    else
38    {
39        printf("GetActualJointPosDegree errcode:%d\n", ret);
40    }
41    robot.CloseRPC();
42    return 0;
43}

4.22. Exemplo de Código de Movimento no Modo Servo no Espaço Articular com comunicação UDP

 1void UDPFrameCallBack(int srcType, int count, int cmdID, int len, std::string content)
 2{
 3    cout << "recv cmd: cmdID:  " << to_string(cmdID) << "  content is " << content << "  count is " << count << endl;;
 4        return;
 5}
 6
 7int TestServoJUDP(void)
 8{
 9    ROBOT_STATE_PKG pkg = {};
10    FRRobot robot;
11    int rtn = 0;
12    robot.LoggerInit();
13    robot.SetLoggerLevel(1);
14    rtn = robot.SetCmdRpyCallback(UDPFrameCallBack);
15    printf("SetCmdRpyCallback rtn is %d\n", rtn);
16    rtn = robot.RPC("192.168.58.2");
17    if (rtn != 0)
18    {
19        return -1;
20    }
21    robot.SetReConnectParam(true, 30000, 50);
22    JointPos j(0, -90, 90, 0, 0, 0);
23    ExaxisPos epos(0, 0, 0, 0);
24    DescPose offset_pos(0, 0, 0, 0, 0, 0);
25    while (true)
26    {
27        robot.MoveJ(&j, 0, 0, 100, 100, 100, &epos, -1, 0, &offset_pos);
28        float vel = 0.0;
29        float acc = 0.0;
30        float cmdT = 0.016;
31        float filterT = 0.0;
32        float gain = 0.0;
33        uint8_t flag = 0;
34        float dt = 0.1;
35        int cmdID = 0;
36        int ret = robot.GetActualJointPosDegree(flag, &j);
37        if (ret != 0)
38        {
39            printf("GetActualJointPosDegree errcode:%d\n", ret);
40        }
41        int comType = 1;
42        int count = 300;
43        rtn = robot.ServoMoveStart(comType);
44        printf("ServoMoveStart rtn is %d\n", rtn);
45        while (count)
46        {
47            rtn = robot.ServoJ(&j, &epos, acc, vel, cmdT, filterT, gain, cmdID, comType);
48            printf("ServoJ rtn is %d\n", rtn);
49            j.jPos[0] += dt;
50            j.jPos[1] += dt;
51            j.jPos[2] += dt;
52            j.jPos[3] += dt;
53            j.jPos[4] += dt;
54            j.jPos[5] += dt;
55            epos.ePos[0] += dt;
56            count -= 1;
57            robot.Sleep(15);
58        }
59        robot.ServoMoveEnd(comType);
60        printf("ServoMoveEnd rtn is %d\n", rtn);
61        count = 300;
62        robot.ServoMoveStart(comType);
63        printf("ServoMoveStart rtn is %d\n", rtn);
64        while (count)
65        {
66            robot.ServoJ(&j, &epos, acc, vel, cmdT, filterT, gain, cmdID, comType);
67            printf("ServoJ rtn is %d\n", rtn);
68            j.jPos[0] -= dt;
69            j.jPos[1] -= dt;
70            j.jPos[2] -= dt;
71            j.jPos[3] -= dt;
72            j.jPos[4] -= dt;
73            j.jPos[5] -= dt;
74            epos.ePos[0] -= dt;
75            count -= 1;
76            robot.Sleep(15);
77        }
78        robot.ServoMoveEnd(comType);
79        printf("ServoMoveEnd rtn is %d\n", rtn);
80    }
81    robot.Sleep(4000);
82    robot.CloseRPC();
83    return 0;
84}

4.23. Início do Controle de Torque Articular

Novo na versão C++SDK-v2.1.5.0.

1/**
2* @brief Início do controle de torque articular
3* @param [in] comType Tipo de envio de instrução; 0-xmlrpc; 1-UDP (porta 20007 do robô)
4* @return Código de erro
5*/
6errno_t ServoJTStart(int comType = 0);

4.24. Controle de Torque Articular

Novo na versão C++SDK-v2.1.5.0.

 1/**
 2* @brief Controle de torque articular
 3* @param [in] torque Torque das juntas j1~j6, em Nm
 4* @param [in] interval Período de instrução, em s, intervalo [0.001~0.008]
 5* @param [in] checkFlag Estratégia de detecção 0-sem limitação; 1-limitação de potência; 2-limitação de velocidade; 3-limitação simultânea de potência e velocidade
 6* @param [in] jPowerLimit Limite máximo de potência da junta (W)
 7* @param [in] jVelLimit Velocidade máxima da junta (°/s)
 8* @param [in] comType Tipo de envio de instrução; 0-xmlrpc; 1-UDP (porta 20007 do robô)
 9* @return Código de erro
10*/
11errno_t ServoJT(float torque[], double interval, int checkFlag, double jPowerLimit[6], double jVelLimit[6], int comType = 0);

4.25. Fim do Controle de Torque Articular

Novo na versão C++SDK-v2.1.5.0.

1/**
2* @brief Fim do controle de torque articular
3* @param [in] comType Tipo de envio de instrução; 0-xmlrpc; 1-UDP (porta 20007 do robô)
4* @return Código de erro
5*/
6errno_t ServoJTEnd(int comType = 0);

4.26. Exemplo de Código de Controle de Torque Articular

Novo na versão C++SDK-v2.1.5.0.

 1int TestServoJT(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    robot.DragTeachSwitch(1);
14    float torques[] = { 0, 0, 0, 0, 0, 0 };
15    robot.GetJointTorques(1, torques);
16    int count = 100;
17    robot.ServoJTStart();
18    int error = 0;
19    while (count > 0)
20    {
21        error = robot.ServoJT(torques, 0.001);
22        count = count - 1;
23        robot.Sleep(1);
24    }
25    error = robot.ServoJTEnd();
26    robot.DragTeachSwitch(0);
27    robot.CloseRPC();
28    return 0;
29}

4.27. Exemplo de Código de Controle de Torque Articular com Proteção contra Excesso de Velocidade

 1int ServoJTWithSafety(FRRobot* robot)
 2{
 3    robot->ResetAllError();
 4    robot->Sleep(500);
 5    float torques[] = { 0, 0, 0, 0, 0, 0 };
 6    robot->GetJointTorques(1, torques);
 7    robot->ServoJTStart();
 8    ROBOT_STATE_PKG pkg = {};
 9    robot->DragTeachSwitch(1);
10    int checkFlag = 3;
11    //double jPowerLimit[6] = {1, 1, 1, 1, 1, 1};
12    double jPowerLimit[6] = { 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 };
13    double jVelLimit[6] = { 181, 80, 80, 80, 80, 80 };
14    int count = 800000;
15    int error = 0;
16    while (count > 0)
17    {
18        torques[2] = torques[2] + 0.01;
19        error = robot->ServoJT(torques, 0.008, checkFlag, jPowerLimit, jVelLimit);
20        if (error != 0)
21        {
22            robot->ServoJTEnd();
23        }
24        printf("ServoJT rtn is %d\n", error);
25        count = count - 1;
26        robot->Sleep(1);
27        robot->GetRobotRealTimeState(&pkg);
28        printf("maincode %d, subcode %d\n", pkg.main_code, pkg.sub_code);
29    }
30    robot->DragTeachSwitch(0);
31    error = robot->ServoJTEnd();
32    return 0;
33}

4.28. Exemplo de Código de Controle de Torque Articular com comunicação UDP

 1void UDPFrameCallBack(int srcType, int count, int cmdID, int len, std::string content)
 2{
 3    cout << "recv cmd: cmdID:  " << to_string(cmdID) << "  content is " << content << "  count is " << count << endl;
 4
 5    return;
 6}
 7int TestServoJTUDP(void)
 8{
 9    ROBOT_STATE_PKG pkg = {};
10    FRRobot robot;
11    robot.LoggerInit();
12    robot.SetLoggerLevel(1);
13    robot.SetCmdRpyCallback(UDPFrameCallBack);
14    int rtn = robot.RPC("192.168.58.2");
15    if (rtn != 0)
16    {
17        return -1;
18    }
19    robot.SetReConnectParam(true, 30000, 500);
20    JointPos j(0, -90, 90, 0, 0, 0);
21    ExaxisPos epos(0, 0, 0, 0);
22    DescPose offset_pos(0, 0, 0, 0, 0, 0);
23    robot.MoveJ(&j, 0, 0, 100, 100, 100, &epos, -1, 0, &offset_pos);
24    robot.Sleep(1000);
25    robot.DragTeachSwitch(1);
26    float torques[] = { 0, 0, 0, 0, 0, 0 };
27    robot.GetJointTorques(1, torques);
28    int comType = 1;
29    int count = 100;
30    int checkFlag = 3;
31    double jPowerLimit[6] = { 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 };
32    double jVelLimit[6] = { 80, 80, 80, 80, 80, 80 };
33    rtn = robot.ServoJTStart(comType);
34    printf("ServoJTStart rtn is %d\n", rtn);
35    while (true)
36    {
37        torques[0] = 0.05;
38        rtn = robot.ServoJT(torques, 0.001, checkFlag, jPowerLimit, jVelLimit, comType);
39        printf("ServoJT rtn is %d\n", rtn);
40        robot.Sleep(1);
41        robot.GetRobotRealTimeState(&pkg);
42        if (pkg.jt_cur_pos[0] > 30)
43        {
44            break;
45        }
46    }
47    while (true)
48    {
49        torques[0] = -0.03;
50        rtn = robot.ServoJT(torques, 0.001, checkFlag, jPowerLimit, jVelLimit, comType);
51        printf("ServoJT rtn is %d\n", rtn);
52        robot.Sleep(1);
53        robot.GetRobotRealTimeState(&pkg);
54        if (pkg.jt_cur_pos[0] < 0 || pkg.jt_cur_pos[1] < -110)
55        {
56            break;
57        }
58    }
59    rtn = robot.ServoJTEnd(comType);
60    printf("ServoJTEnd rtn is %d\n", rtn);
61    robot.DragTeachSwitch(0);
62    robot.Sleep(1000);
63    robot.CloseRPC();
64    return 0;
65}

4.29. Movimento no Modo Servo no Espaço Cartesiano

 1/**
 2* @brief Movimento no modo servo no espaço cartesiano
 3* @param [in] mode 0-movimento absoluto (sistema de coordenadas base), 1-movimento incremental (sistema de coordenadas base), 2-movimento incremental (sistema de coordenadas da ferramenta)
 4* @param [in] desc_pos Pose cartesiana alvo ou incremento de pose
 5* @param [in] exaxis Posição do eixo estendido
 6* @param [in] pos_gain Coeficiente de escala do incremento de pose, ativo apenas em movimento incremental, intervalo [0~1]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível, padrão 0
 8* @param [in] vel Percentagem de velocidade, intervalo [0~100], temporariamente não disponível, padrão 0
 9* @param [in] cmdT Período de envio de instrução, em s, intervalo recomendado [0.001~0.016]
10* @param [in] filterT Tempo de filtro, em s, temporariamente não disponível, padrão 0
11* @param [in] gain Amplificador proporcional da posição alvo, temporariamente não disponível, padrão 0
12* @return Código de erro
13*/
14errno_t ServoCart(int mode, DescPose *desc_pose, ExaxisPos exaxis, float pos_gain[6], float acc, float vel, float cmdT, float filterT, float gain);

4.30. Exemplo de Código de Movimento no Modo Servo no Espaço Cartesiano

 1int TestServoCart(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    DescPose desc_pos_dt = { 83.00800, 50.525000 , 29.246 , 179.629 , -7.138 , -166.975 };
14    ExaxisPos exaxis = { 100.0, 0.0, 0.0, 0.0 };
15    float pos_gain[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
16    int mode = 0;
17    float vel = 0.0;
18    float acc = 0.0;
19    float cmdT = 0.001;
20    float filterT = 0.0;
21    float gain = 0.0;
22    uint8_t flag = 0;
23    int count = 5000;
24    robot.SetSpeed(20);
25    while (count)
26    {
27        rtn = robot.ServoCart(mode, &desc_pos_dt, exaxis, pos_gain, acc, vel, cmdT, filterT, gain);
28        printf("ServoCart rtn is %d\n", rtn);
29        count -= 1;
30        desc_pos_dt.tran.x += 0.01;
31        exaxis.ePos[0] += 0.01;
32    }
33    robot.CloseRPC();
34    return 0;
35}

4.31. Início do Movimento Spline

1/**
2* @brief Início do movimento spline
3* @return Código de erro
4*/
5errno_t SplineStart();

4.32. Movimento Spline no Espaço Articular (com cálculo automático de cinemática direta)

 1/**
 2* @brief Movimento spline no espaço articular (com cálculo automático de cinemática direta)
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] user Número da coordenada da peça, intervalo [0~14]
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
 9* @return Código de erro
10*/
11errno_t SplinePTP(JointPos* joint_pos, int tool, int user, float vel, float acc, float ovl);

4.33. Movimento Spline PTP

 1/**
 2* @brief Movimento spline no espaço articular
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] desc_pos Pose cartesiana alvo
 5* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] user Número da coordenada da peça, intervalo [0~14]
 7* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
10* @return Código de erro
11*/
12errno_t SplinePTP(JointPos *joint_pos, DescPose *desc_pos, int tool, int user, float vel, float acc, float ovl);

4.34. Fim do Movimento Spline

1/**
2* @brief Fim do movimento spline
3* @return Código de erro
4*/
5errno_t SplineEnd();

4.35. Exemplo de Código de Movimento Spline

 1int TestSpline(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return -1;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14  JointPos j2(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15  JointPos j3(-61.954, -84.409, 108.153, -116.316, -91.283, 74.260);
16  JointPos j4(-89.575, -80.276, 102.713, -116.302, -91.284, 74.267);
17  DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
18  DescPose desc_pos2(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
19  DescPose desc_pos3(-327.622, 402.230, 320.402, -178.067, 2.127, -46.207);
20  DescPose desc_pos4(-104.066, 544.321, 327.023, -177.715, 3.371, -73.818);
21  DescPose offset_pos(0, 0, 0, 0, 0, 0);
22  ExaxisPos epos(0, 0, 0, 0);
23  int tool = 0;
24  int user = 0;
25  float vel = 100.0;
26  float acc = 100.0;
27  float ovl = 100.0;
28  float blendT = -1.0;
29  uint8_t flag = 0;
30  robot.SetSpeed(20);
31  int err1 = robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
32  printf("movej errcode:%d\n", err1);
33  robot.SplineStart();
34  robot.SplinePTP(&j1, &desc_pos1, tool, user, vel, acc, ovl);
35  robot.SplinePTP(&j2, &desc_pos2, tool, user, vel, acc, ovl);
36  robot.SplinePTP(&j3, &desc_pos3, tool, user, vel, acc, ovl);
37  robot.SplinePTP(&j4, &desc_pos4, tool, user, vel, acc, ovl);
38  robot.SplineEnd();
39  err1 = robot.MoveJ(&j1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
40  printf("movej errcode:%d\n", err1);
41  robot.SplineStart();
42  robot.SplinePTP(&j1, tool, user, vel, acc, ovl);
43  robot.SplinePTP(&j2, tool, user, vel, acc, ovl);
44  robot.SplinePTP(&j3, tool, user, vel, acc, ovl);
45  robot.SplinePTP(&j4, tool, user, vel, acc, ovl);
46  robot.SplineEnd();
47  robot.CloseRPC();
48  return 0;
49}

4.36. Início do Novo Movimento Spline

Alterado na versão C++SDK-v2.1.3.0.

1/**
2* @brief Início do novo movimento spline
3* @param [in] type 0-transição circular, 1-pontos fornecidos são pontos de caminho
4* @param [in] averageTime Tempo médio global de transição (ms) (10 ~ ), padrão 2000
5* @return Código de erro
6*/
7errno_t NewSplineStart(int type, int averageTime=2000);

4.37. Ponto de Instrução do Novo Spline

 1/**
 2* @brief Ponto de instrução do novo spline
 3* @param [in] joint_pos Posição articular alvo, em graus
 4* @param [in] desc_pos Pose cartesiana alvo
 5* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 6* @param [in] user Número da coordenada da peça, intervalo [0~14]
 7* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 8* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 9* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
10* @param [in] blendR [-1.0]-movimento até o final (bloqueante), [0~1000.0]-raio de suavização (não bloqueante), em mm
11* @param [in] lastFlag Se é o último ponto, 0-não, 1-sim
12* @return Código de erro
13*/
14errno_t NewSplinePoint(JointPos *joint_pos, DescPose *desc_pos, int tool, int user, float vel, float acc, float ovl, float blendR, int lastFlag);

4.38. Ponto de Instrução do Novo Spline (com cálculo automático de cinemática inversa)

 1/**
 2* @brief Ponto de instrução do novo spline (com cálculo automático de cinemática inversa)
 3* @param [in] desc_pos Pose cartesiana alvo
 4* @param [in] tool Número da coordenada da ferramenta, intervalo [0~14]
 5* @param [in] user Número da coordenada da peça, intervalo [0~14]
 6* @param [in] vel Percentagem de velocidade, intervalo [0~100]
 7* @param [in] acc Percentagem de aceleração, intervalo [0~100], temporariamente não disponível
 8* @param [in] ovl Fator de escala de velocidade, intervalo [0~100]
 9* @param [in] blendR [-1.0]-movimento até o final (bloqueante), [0~1000.0]-raio de suavização (não bloqueante), em mm
10* @param [in] lastFlag Se é o último ponto, 0-não, 1-sim
11* @param [in] config Configuração do espaço articular para cinemática inversa, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base em uma configuração específica do espaço articular
12* @return Código de erro
13*/
14errno_t NewSplinePoint(DescPose* desc_pos, int tool, int user, float vel, float acc, float ovl, float blendR, int lastFlag, int config = -1);

4.39. Fim do Novo Movimento Spline

1/**
2* @brief Fim do novo movimento spline
3* @return Código de erro
4*/
5errno_t NewSplineEnd();

4.40. Exemplo de Código do Novo Movimento Spline

 1int TestNewSpline(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return -1;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14  JointPos j2(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15  JointPos j3(-61.954, -84.409, 108.153, -116.316, -91.283, 74.260);
16  JointPos j4(-89.575, -80.276, 102.713, -116.302, -91.284, 74.267);
17  JointPos j5(-95.228, -54.621, 73.691, -112.245, -91.280, 74.268);
18  DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
19  DescPose desc_pos2(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
20  DescPose desc_pos3(-327.622, 402.230, 320.402, -178.067, 2.127, -46.207);
21  DescPose desc_pos4(-104.066, 544.321, 327.023, -177.715, 3.371, -73.818);
22  DescPose desc_pos5(-33.421, 732.572, 275.103, -177.907, 2.709, -79.482);
23  DescPose offset_pos(0, 0, 0, 0, 0, 0);
24  ExaxisPos epos(0, 0, 0, 0);
25  int tool = 0;
26  int user = 0;
27  float vel = 100.0;
28  float acc = 100.0;
29  float ovl = 100.0;
30  float blendT = -1.0;
31  uint8_t flag = 0;
32  robot.SetSpeed(20);
33  int err1 = robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
34  printf("movej errcode:%d\n", err1);
35  robot.NewSplineStart(1, 2000);
36  robot.NewSplinePoint(&j1, &desc_pos1, tool, user, vel, acc, ovl, -1, 0);
37  robot.NewSplinePoint(&j2, &desc_pos2, tool, user, vel, acc, ovl, -1, 0);
38  robot.NewSplinePoint(&j3, &desc_pos3, tool, user, vel, acc, ovl, -1, 0);
39  robot.NewSplinePoint(&j4, &desc_pos4, tool, user, vel, acc, ovl, -1, 0);
40  robot.NewSplinePoint(&j5, &desc_pos5, tool, user, vel, acc, ovl, -1, 0);
41  robot.NewSplineEnd();
42  err1 = robot.MoveJ(&j1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
43  printf("movej errcode:%d\n", err1);
44  robot.NewSplineStart(1, 2000);
45  robot.NewSplinePoint(&desc_pos1, tool, user, vel, acc, ovl, -1, 0);
46  robot.NewSplinePoint(&desc_pos2, tool, user, vel, acc, ovl, -1, 0);
47  robot.NewSplinePoint(&desc_pos3, tool, user, vel, acc, ovl, -1, 0);
48  robot.NewSplinePoint(&desc_pos4, tool, user, vel, acc, ovl, -1, 0);
49  robot.NewSplinePoint(&desc_pos5, tool, user, vel, acc, ovl, -1, 0);
50  robot.NewSplineEnd();
51  robot.CloseRPC();
52  return 0;
53}

4.41. Parar Movimento

1/**
2* @brief Parar movimento
3* @return Código de erro
4*/
5errno_t StopMotion();

4.42. Pausar Movimento

1/**
2* @brief Pausar movimento
3* @return Código de erro
4*/
5errno_t PauseMotion();

4.43. Retomar Movimento

1/**
2* @brief Retomar movimento
3* @return Código de erro
4*/
5errno_t ResumeMotion();

4.44. Exemplo de Código de Pausa, Retomada e Parada de Movimento

 1int TestPause(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos j5(-95.228, -54.621, 73.691, -112.245, -91.280, 74.268);
15    DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
16    DescPose desc_pos5(-33.421, 732.572, 275.103, -177.907, 2.709, -79.482);
17    DescPose offset_pos(0, 0, 0, 0, 0, 0);
18    ExaxisPos epos(0, 0, 0, 0);
19    int tool = 0;
20    int user = 0;
21    float vel = 100.0;
22    float acc = 100.0;
23    float ovl = 100.0;
24    float blendT = -1.0;
25    uint8_t flag = 0;
26    robot.SetSpeed(20);
27    rtn = robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
28    rtn = robot.MoveJ(&j5, &desc_pos5, tool, user, vel, acc, ovl, &epos, 1, flag, &offset_pos);
29    robot.Sleep(1000);
30    robot.PauseMotion();
31    robot.Sleep(1000);
32    robot.ResumeMotion();
33    robot.Sleep(1000);
34    robot.StopMotion();
35    robot.Sleep(1000);
36    robot.CloseRPC();
37    return 0;
38}

4.45. Início do Deslocamento Global de Pontos

1/**
2* @brief Início do deslocamento global de pontos
3* @param [in] flag 0-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta
4* @param [in] offset_pos Deslocamento de pose
5* @return Código de erro
6*/
7errno_t PointsOffsetEnable(int flag, DescPose *offset_pos);

4.46. Fim do Deslocamento Global de Pontos

1/**
2* @brief Fim do deslocamento global de pontos
3* @return Código de erro
4*/
5errno_t PointsOffsetDisable();

4.47. Exemplo de Código de Deslocamento de Pontos

 1int TestOffset(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos j2(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15    DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
16    DescPose desc_pos2(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
17    DescPose offset_pos(0, 0, 0, 0, 0, 0);
18    DescPose offset_pos1(0, 0, 50, 0, 0, 0);
19    ExaxisPos epos(0, 0, 0, 0);
20    int tool = 0;
21    int user = 0;
22    float vel = 100.0;
23    float acc = 100.0;
24    float ovl = 100.0;
25    float blendT = -1.0;
26    uint8_t flag = 0;
27    robot.SetSpeed(20);
28    robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
29    robot.MoveJ(&j2, &desc_pos2, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
30    robot.Sleep(1000);
31    robot.PointsOffsetEnable(0, &offset_pos1);
32    robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
33    robot.MoveJ(&j2, &desc_pos2, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
34    robot.PointsOffsetDisable();
35    robot.CloseRPC();
36    return 0;
37}

4.48. Início da Captura com AO da Caixa de Controle

Novo na versão C++SDK-v2.1.4.0.

1/**
2* @brief Início da captura com AO da caixa de controle
3* @param [in] AONum Número da AO da caixa de controle
4* @param [in] maxTCPSpeed Valor máximo da velocidade TCP [1-5000 mm/s], padrão 1000
5* @param [in] maxAOPercent Percentagem de AO correspondente ao valor máximo da velocidade TCP, padrão 100%
6* @param [in] zeroZoneCmp Valor de compensação da zona morta em percentagem de AO, inteiro, padrão 20%, intervalo [0-100]
7* @return Código de erro
8*/
9errno_t MoveAOStart(int AONum, int maxTCPSpeed, int maxAOPercent, int zeroZoneCmp);

4.49. Parada da Captura com AO da Caixa de Controle

Novo na versão C++SDK-v2.1.4.0.

1/**
2* @brief Parada da captura com AO da caixa de controle
3* @return Código de erro
4*/
5errno_t MoveAOStop();

4.50. Início da Captura com AO da Extremidade

Novo na versão C++SDK-v2.1.4.0.

1/**
2* @brief Início da captura com AO da extremidade
3* @param [in] AONum Número da AO da extremidade
4* @param [in] maxTCPSpeed Valor máximo da velocidade TCP [1-5000 mm/s], padrão 1000
5* @param [in] maxAOPercent Percentagem de AO correspondente ao valor máximo da velocidade TCP, padrão 100%
6* @param [in] zeroZoneCmp Valor de compensação da zona morta em percentagem de AO, inteiro, padrão 20%, intervalo [0-100]
7* @return Código de erro
8*/
9errno_t MoveToolAOStart(int AONum, int maxTCPSpeed, int maxAOPercent, int zeroZoneCmp);

4.51. Parada da Captura com AO da Extremidade

Novo na versão C++SDK-v2.1.4.0.

1/**
2* @brief Parada da captura com AO da extremidade
3* @return Código de erro
4*/
5errno_t MoveToolAOStop();

4.52. Exemplo de Código de Captura com AO

 1int TestMoveAO(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos j2(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15    DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
16    DescPose desc_pos2(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
17    DescPose offset_pos(0, 0, 0, 0, 0, 0);
18    DescPose offset_pos1(0, 0, 50, 0, 0, 0);
19    ExaxisPos epos(0, 0, 0, 0);
20    int tool = 0;
21    int user = 0;
22    float vel = 20.0;
23    float acc = 20.0;
24    float ovl = 100.0;
25    float blendT = -1.0;
26    uint8_t flag = 0;
27    robot.SetSpeed(20);
28    robot.MoveAOStart(0, 100, 100, 20);
29    robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
30    robot.MoveJ(&j2, &desc_pos2, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
31    robot.MoveAOStop();
32    robot.Sleep(1000);
33    robot.MoveToolAOStart(0, 100, 100, 20);
34    robot.MoveJ(&j1, &desc_pos1, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
35    robot.MoveJ(&j2, &desc_pos2, tool, user, vel, acc, ovl, &epos, blendT, flag, &offset_pos);
36    robot.MoveToolAOStop();
37    robot.CloseRPC();
38    return 0;
39}

4.53. Início do Filtro FIR para Movimento Ptp

Novo na versão V3.7.7.

1/**
2* @brief Início do filtro FIR para movimento Ptp
3* @param [in] maxAcc Valor extremo máximo de aceleração (deg/s2)
4* @param [in] maxJek Valor extremo de jerk uniforme das juntas (deg/s3)
5* @return Código de erro
6*/
7errno_t PtpFIRPlanningStart(double maxAcc, double maxJek = 1000);

4.54. Desligar o Filtro FIR para Movimento Ptp

Novo na versão V3.7.7.

1/**
2* @brief Desligar o filtro FIR para movimento Ptp
3* @return Código de erro
4*/
5errno_t PtpFIRPlanningEnd();

4.55. Início do Filtro FIR para Movimento LIN e ARC

Novo na versão V3.7.7.

1/**
2* @brief Início do filtro FIR para movimento LIN e ARC
3* @param [in] maxAccLin Valor extremo de aceleração linear (mm/s2)
4* @param [in] maxAccDeg Valor extremo de aceleração angular (deg/s2)
5* @param [in] maxJerkLin Valor extremo de jerk linear (mm/s3)
6* @param [in] maxJerkDeg Valor extremo de jerk angular (deg/s3)
7* @return Código de erro
8*/
9errno_t LinArcFIRPlanningStart(double maxAccLin, double maxAccDeg, double maxJerkLin, double maxJerkDeg);

4.56. Desligar o Filtro FIR para Movimento LIN e ARC

Novo na versão V3.7.7.

1/**
2* @brief Desligar o filtro FIR para movimento LIN e ARC
3* @return Código de erro
4*/
5errno_t LinArcFIRPlanningEnd();

4.57. Exemplo de Código de Filtro FIR

 1int TestFIR(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos startjointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos midjointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15    JointPos endjointPos(-29.777, -84.536, 109.275, -114.075, -86.655, 74.257);
16    DescPose startdescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
17    DescPose middescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
18    DescPose enddescPose(-487.434, 154.362, 308.576, 176.600, 0.268, -14.061);
19    ExaxisPos exaxisPos(0, 0, 0, 0);
20    DescPose offdese(0, 0, 0, 0, 0, 0);
21    rtn = robot.PtpFIRPlanningStart(1000, 1000);
22    cout << "PtpFIRPlanningStart rtn is " << rtn << endl;
23    robot.MoveJ(&startjointPos, &startdescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
24    robot.MoveJ(&endjointPos, &enddescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
25    robot.PtpFIRPlanningEnd();
26    cout << "PtpFIRPlanningEnd rtn is " << rtn << endl;
27    robot.LinArcFIRPlanningStart(1000, 1000, 1000, 1000);
28    cout << "LinArcFIRPlanningStart rtn is " << rtn << endl;
29    robot.MoveL(&startjointPos, &startdescPose, 0, 0, 100, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
30    robot.MoveC(&midjointPos, &middescPose, 0, 0, 100, 100, &exaxisPos, 0, &offdese, &endjointPos, &enddescPose, 0, 0, 100, 100, &exaxisPos, 0, &offdese, 100, -1);
31    robot.LinArcFIRPlanningEnd();
32    cout << "LinArcFIRPlanningEnd rtn is " << rtn << endl;
33    robot.CloseRPC();
34    return 0;
35}

4.58. Ativar Suavização de Aceleração

Novo na versão C++SDK-v2.2.1-3.8.1.

1/**
2* @brief Ativar suavização de aceleração
3* @param [in] saveFlag Se salvar após desligamento
4* @return Código de erro
5*/
6errno_t AccSmoothStart(bool saveFlag);

4.59. Desativar Suavização de Aceleração

Novo na versão C++SDK-v2.2.1-3.8.1.

1/**
2* @brief Desativar suavização de aceleração
3* @param [in] saveFlag Se salvar após desligamento
4* @return Código de erro
5*/
6errno_t AccSmoothEnd(bool saveFlag);

4.60. Exemplo de Código de Suavização de Aceleração

 1int TestAccSmooth(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos startjointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos endjointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15    DescPose startdescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
16    DescPose enddescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
17    ExaxisPos exaxisPos(0, 0, 0, 0);
18    DescPose offdese(0, 0, 0, 0, 0, 0);
19    rtn = robot.AccSmoothStart(0);
20    cout << "AccSmoothStart rtn is " << rtn << endl;
21    robot.MoveJ(&startjointPos, &startdescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
22    robot.MoveJ(&endjointPos, &enddescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
23    rtn = robot.AccSmoothEnd(0);
24    cout << "AccSmoothEnd rtn is " << rtn << endl;
25    robot.CloseRPC();
26    return 0;
27}

4.61. Ativar Velocidade de Postura Especificada

Novo na versão C++SDK-v2.1.5.0.

1/**
2* @brief Ativar velocidade de postura especificada
3* @param [in] ratio Percentagem da velocidade de postura [0-300]
4* @return Código de erro
5*/
6errno_t AngularSpeedStart(int ratio);

4.62. Desativar Velocidade de Postura Especificada

Novo na versão C++SDK-v2.1.5.0.

1/**
2* @brief Desativar velocidade de postura especificada
3* @return Código de erro
4*/
5errno_t AngularSpeedEnd();

4.63. Exemplo de Código de Velocidade de Postura Especificada do Robô

 1int TestAngularSpeed(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos startjointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos endjointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15    DescPose startdescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
16    DescPose enddescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
17    ExaxisPos exaxisPos(0, 0, 0, 0);
18    DescPose offdese(0, 0, 0, 0, 0, 0);
19    rtn = robot.AngularSpeedStart(50);
20    cout << "AngularSpeedStart rtn is " << rtn << endl;
21    robot.MoveJ(&startjointPos, &startdescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
22    robot.MoveJ(&endjointPos, &enddescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
23    rtn = robot.AngularSpeedEnd();
24    cout << "AngularSpeedEnd rtn is " << rtn << endl;
25    robot.CloseRPC();
26    return 0;
27}

4.64. Iniciar Proteção contra Pose Singular

Novo na versão C++SDK-v2.1.5.0.

1/**
2* @brief Iniciar proteção contra pose singular
3* @param [in] protectMode Modo de proteção contra singularidade, 0: modo articular; 1-modo cartesiano
4* @param [in] minShoulderPos Faixa de ajuste da singularidade do ombro (mm), padrão 100
5* @param [in] minElbowPos Faixa de ajuste da singularidade do cotovelo (mm), padrão 50
6* @param [in] minWristPos Faixa de ajuste da singularidade do pulso (°), padrão 10
7* @return Código de erro
8*/
9errno_t SingularAvoidStart(int protectMode, double minShoulderPos, double minElbowPos, double minWristPos);

4.65. Parar Proteção contra Pose Singular

Novo na versão C++SDK-v2.1.5.0.

1/**
2* @brief Parar proteção contra pose singular
3* @return Código de erro
4*/
5errno_t SingularAvoidEnd();

4.66. Exemplo de Código de Proteção contra Pose Singular do Robô

 1int TestAngularSpeed(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos startjointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14    JointPos endjointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
15    DescPose startdescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
16    DescPose enddescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
17    ExaxisPos exaxisPos(0, 0, 0, 0);
18    DescPose offdese(0, 0, 0, 0, 0, 0);
19    rtn = robot.SingularAvoidStart(2, 10, 5, 5);
20    cout << "SingularAvoidStart rtn is " << rtn << endl;
21    robot.MoveJ(&startjointPos, &startdescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
22    robot.MoveJ(&endjointPos, &enddescPose, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
23    rtn = robot.SingularAvoidEnd();
24    cout << "SingularAvoidEnd rtn is " << rtn << endl;
25    robot.CloseRPC();
26    return 0;
27}

4.67. Limpar Fila de Instruções de Movimento

1/**
2* @brief Limpar fila de instruções de movimento
3* @return Código de erro
4*/
5errno_t MotionQueueClear();

4.68. Mover para Ponto Inicial da Linha de Interseção

 1/**
 2* @brief Mover para ponto inicial da linha de interseção
 3* @param [in] mainPoint Poses cartesianas dos 6 pontos de ensino do tubo principal
 4* @param [in] mainExaxisPos Posições dos eixos estendidos dos 6 pontos de ensino do tubo principal
 5* @param [in] piecePoint Poses cartesianas dos 6 pontos de ensino do tubo auxiliar
 6* @param [in] pieceExaxisPos Posições dos eixos estendidos dos 6 pontos de ensino do tubo de junção
 7* @param [in] extAxisFlag Se habilita o eixo estendido; 0-não habilita; 1-habilita
 8* @param [in] exaxisPos Posição do eixo estendido inicial
 9* @param [in] tool Número do sistema de coordenadas da ferramenta
10* @param [in] wobj Número do sistema de coordenadas da peça
11* @param [in] vel Percentagem de velocidade
12* @param [in] acc Percentagem de aceleração
13* @param [in] ovl Fator de escala de velocidade
14* @param [in] oacc Fator de escala de aceleração
15* @param [in] moveType Tipo de movimento; 0-PTP; 1-LIN
16* @param [in] moveDirection Direção do movimento; 0-horário; 1-anti-horário
17* @param [in] offset Deslocamento
18* @return Código de erro
19*/
20errno_t MoveToIntersectLineStart(DescPose mainPoint[6], ExaxisPos mainExaxisPos[6], DescPose piecePoint[6], ExaxisPos pieceExaxisPos[6], int extAxisFlag, ExaxisPos exaxisPos, int tool, int wobj, double vel, double acc, double ovl, double oacc, int moveType, int moveDirection, DescPose offset);

4.69. Movimento na Linha de Interseção

 1/**
 2* @brief Movimento na linha de interseção
 3* @param [in] mainPoint Poses cartesianas dos 6 pontos de ensino do tubo principal
 4* @param [in] mainExaxisPos Posições dos eixos estendidos dos 6 pontos de ensino do tubo principal
 5* @param [in] piecePoint Poses cartesianas dos 6 pontos de ensino do tubo auxiliar
 6* @param [in] pieceExaxisPos Posições dos eixos estendidos dos 6 pontos de ensino do tubo de junção
 7* @param [in] extAxisFlag Se habilita o eixo estendido; 0-não habilita; 1-habilita
 8* @param [in] exaxisPos Posição do eixo estendido inicial
 9* @param [in] tool Número do sistema de coordenadas da ferramenta
10* @param [in] wobj Número do sistema de coordenadas da peça
11* @param [in] vel Percentagem de velocidade
12* @param [in] acc Percentagem de aceleração
13* @param [in] ovl Fator de escala de velocidade
14* @param [in] oacc Fator de escala de aceleração
15* @param [in] moveDirection Direção do movimento; 0-horário; 1-anti-horário
16* @param [in] offset Deslocamento
17* @return Código de erro
18*/
19errno_t MoveIntersectLine(DescPose mainPoint[6], ExaxisPos mainExaxisPos[6], DescPose piecePoint[6], ExaxisPos pieceExaxisPos[6], int extAxisFlag, ExaxisPos exaxisPos[4], int tool, int wobj, double vel, double acc, double ovl, double oacc, int moveDirection, DescPose offset);

4.70. Exemplo de Código de Movimento na Linha de Interseção do Robô

 1void TestIntersectLineMove()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(3);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    DescPose mainPoint[6] = {};
14    DescPose piecePoint[6] = {};
15    ExaxisPos mainExaxisPos[6] = {};
16    ExaxisPos pieceExaxisPos[6] = {};
17    int extAxisFlag = 1;
18    ExaxisPos exaxisPos[4] = {};
19    DescPose offset = { 0.0, 2.0 ,30.0, -2.0, 0.0, 0.0 };
20    mainPoint[0] = {490.004, -383.194, 402.735, -9.332, -1.528, 69.594};
21    mainPoint[1] = {444.950, -407.117, 389.011, -5.546, -2.196, 65.279};
22    mainPoint[2] = {445.168, -463.605, 355.759, -1.544, -10.886, 57.104};
23    mainPoint[3] = {507.529, -485.385, 343.013, -0.786, -4.834, 61.799};
24    mainPoint[4] = {554.390, -442.647, 367.701, -4.761, -10.181, 64.925};
25    mainPoint[5] = {532.552, -394.003, 396.467, -13.732, -13.592, 67.411};
26    mainExaxisPos[0] = { -29.996, 0.000, 0.000, 0.000 };
27    mainExaxisPos[1] = { -29.996, 0.000, 0.000, 0.000 };
28    mainExaxisPos[2] = { -29.996, 0.000, 0.000, 0.000 };
29    mainExaxisPos[3] = { -29.996, 0.000, 0.000, 0.000 };
30    mainExaxisPos[4] = { -29.996, 0.000, 0.000, 0.000 };
31    mainExaxisPos[5] = { -29.996, 0.000, 0.000, 0.000 };
32    piecePoint[0] = { 505.571, -192.408, 316.759, 38.098, 37.051, 139.447 };
33    piecePoint[1] = {533.837, -201.558, 332.340, 34.644, 42.339, 137.748};
34    piecePoint[2] = {530.386, -225.085, 373.808, 35.431, 45.111, 137.560};
35    piecePoint[3] = {485.646, -229.195, 383.778, 33.870, 45.173, 137.064};
36    piecePoint[4] = {460.551, -212.161, 354.256, 28.856, 45.602, 135.930};
37    piecePoint[5] = {474.217, -197.124, 324.611, 42.469, 41.133, 148.167};
38    pieceExaxisPos[0] = { -29.996, -0.000, 0.000, 0.000 };
39    pieceExaxisPos[1] = { -29.996, -0.000, 0.000, 0.000 };
40    pieceExaxisPos[2] = { -29.996, -0.000, 0.000, 0.000 };
41    pieceExaxisPos[3] = { -29.996, -0.000, 0.000, 0.000 };
42    pieceExaxisPos[4] = { -29.996, -0.000, 0.000, 0.000 };
43    pieceExaxisPos[5] = { -29.996, -0.000, 0.000, 0.000 };
44    exaxisPos[0] = {-29.996, -0.000, 0.000, 0.000};
45    exaxisPos[1] = {-44.994, 90.000, 0.000, 0.000};
46    exaxisPos[2] = {-59.992, 0.002, 0.000, 0.000};
47    exaxisPos[3] = {-44.994, -89.997, 0.000, 0.000};
48    int tool = 2;
49    int wobj = 0;
50    double vel = 100.0;
51    double acc = 100.0;
52    double ovl = 12.0;
53    double oacc = 12.0;
54    int moveType = 1;
55    int moveDirection = 1;
56    rtn = robot.MoveToIntersectLineStart(mainPoint, mainExaxisPos, piecePoint, pieceExaxisPos, extAxisFlag, exaxisPos[0], tool, wobj, vel, acc, ovl, oacc, moveType, moveDirection, offset);
57    printf("MoveToIntersectLineStart rtn is %d\n", rtn);
58    rtn = robot.MoveIntersectLine(mainPoint, mainExaxisPos, piecePoint, pieceExaxisPos, extAxisFlag, exaxisPos, tool, wobj, vel, acc, 5.0, 5.0, moveDirection, offset);
59    printf("MoveIntersectLine rtn is %d\n", rtn);
60    robot.CloseRPC();
61    return;
62}

4.71. Movimento Estacionário no Local

1/**
2* @brief Movimento estacionário no local
3* @return Código de erro
4*/
5errno_t MoveStationary();

4.72. Exemplo de Código de Movimento Estacionário no Local

 1int TestLaserStationary(void)
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return 0;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    rtn = robot.LaserSensorRecordandReplay(0, 10, 1, 0, 0.1, 1, 0, 10, 100);
14    printf("LaserSensorRecordandReplay rtn is %d\n", rtn);
15    rtn = robot.MoveStationary();
16    printf("MoveStationary rtn is %d\n", rtn);
17    rtn = robot.LaserSensorRecord1(0, 10);
18    printf("LaserSensorRecordandReplay rtn is %d\n", rtn);
19    robot.CloseRPC();
20    robot.Sleep(9999999);
21    return 0;
22}

4.73. Início da Oscilação em Ponto Fixo

1/**
2* @brief Início da oscilação em ponto fixo
3* @param [in] weaveNum Número da oscilação [0-7]
4* @param [in] mode 0-sistema de coordenadas da ferramenta; 1-ponto de referência
5* @param [in] refPoint Coordenadas cartesianas do ponto de referência [x, y, z, a, b, c]
6* @param [in] weaveTime Tempo de oscilação [s]
7* @return Código de erro
8*/
9errno_t OriginPointWeaveStart(int weaveNum, int mode, DescPose refPoint, double weaveTime);

4.74. Fim da Oscilação em Ponto Fixo

1/**
2* @brief Fim da oscilação em ponto fixo
3* @return Código de erro
4*/
5errno_t OriginPointWeaveEnd();

4.75. Exemplo de Código SDK de Oscilação em Ponto Fixo

 1int TestOriginPointWeave()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos j(39.886, -98.580, -124.032, -47.393, 90.000, 40.842);
14    ExaxisPos epos(0, 0, 0, 0);
15    DescPose offset_pos(0, 0, 0, 0, 0, 0);
16    DescPose refPoint = { 400.021,300.022,299.996,179.997,-0.003,-90.956 };
17    robot.MoveJ(&j, 1, 0, 100, 100, 100, &epos, -1, 0, &offset_pos);
18    robot.OriginPointWeaveStart(0, 0, refPoint, 3);
19    robot.MoveStationary();
20    robot.OriginPointWeaveEnd();
21    robot.Sleep(2000);
22    robot.MoveJ(&j, 1, 0, 100, 100, 100, &epos, -1, 0, &offset_pos);
23    robot.OriginPointWeaveStart(0, 1, refPoint, 3);
24    robot.MoveStationary();
25    robot.OriginPointWeaveEnd();
26    robot.CloseRPC();
27    robot.Sleep(1000);
28    return 0;
29}

4.76. Exemplo de Código de Oscilação em Ponto Fixo (incluindo sensor a laser e eixo estendido)

 1int TestOriginPointWeave()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return -1;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    JointPos j(39.886, -98.580, -124.032, -47.393, 90.000, 40.842);
14    ExaxisPos epos1(0, 0, 0, 0);
15    DescPose offset_pos(0, 0, 0, 0, 0, 0);
16    ExaxisPos epos2(5, 0.000, 0.000, 0.000);
17    DescPose refPoint(400.021, 300.022, 299.996, 179.997, -0.003, -90.956);
18    robot.LaserTrackingSensorConfig("192.168.58.20", 5020);
19    robot.LaserTrackingSensorSamplePeriod(20);
20    robot.LoadPosSensorDriver(101);
21    robot.ExtDevLoadUDPDriver();
22    rtn = robot.SetExAxisCmdDoneTime(5000.0);
23    printf("SetExAxisCmdDoneTime rtn is %d\n", rtn);
24    rtn = robot.ExtAxisServoOn(1, 1);
25    printf("ExtAxisServoOn axis id 1 rtn is %d\n", rtn);
26    rtn = robot.ExtAxisServoOn(2, 1);
27    printf("ExtAxisServoOn axis id 2 rtn is %d\n", rtn);
28    robot.Sleep(2000);
29    robot.ExtAxisSetHoming(1, 0, 10, 2);
30    rtn = robot.LaserTrackingLaserOnOff(1, 0);
31    printf("LaserTrackingLaserOnOff id 2 rtn is %d\n", rtn);
32    robot.LaserTrackingTrackOnOff(1, 4);
33    robot.Sleep(200);
34    robot.OriginPointWeaveStart(0, 0, refPoint, 10);
35    robot.MoveStationary();
36    robot.OriginPointWeaveEnd();
37    robot.LaserTrackingTrackOnOff(0, 4);
38
39    robot.Sleep(2000);
40
41    robot.ExtAxisMove(epos1, 100, -1);
42    robot.LaserTrackingTrackOnOff(1, 4);
43    robot.OriginPointWeaveStart(0, 0, refPoint, 20);
44    robot.ExtAxisMove(epos2, 100, -1);
45    robot.OriginPointWeaveEnd();
46    robot.LaserTrackingTrackOnOff(0, 4);
47    robot.CloseRPC();
48    robot.Sleep(1000);
49    return 0;
50}

4.77. Movimento em Modo Servo de Velocidade no Espaço das Juntas

 1/**
 2* @brief Movimento em modo servo de velocidade no espaço das juntas
 3* @param [in] joint_pos 6 velocidades das juntas alvo, unidade deg/s
 4* @param [in] axisPos 4 velocidades dos eixos externos, unidade deg/s
 5* @param [in] acc Percentual de aceleração, intervalo [0~100], temporariamente não aberto, padrão 0
 6* @param [in] vel Percentual de velocidade, intervalo [0~100], temporariamente não aberto, padrão 0
 7* @param [in] cmdT Período de envio do comando, unidade s, intervalo recomendado [0.001~0.0016]
 8* @param [in] filterT Tempo de filtro, unidade s, temporariamente não aberto, padrão 0
 9* @param [in] gain Amplificador proporcional para posição alvo, temporariamente não aberto, padrão 0
10* @param [in] id ID do comando ServoJ, padrão 0
11* @param[in] comType Tipo de envio do comando; 0-xmlrpc; 1-UDP (corresponde à porta 20007 do robô)
12* @return Código de erro
13*/
14errno_t ServoJV(double jointVel[6], double exisVel[4], float acc, float vel, float cmdT, float filterT, float gain, int id = 0, int comType = 0);

4.78. Exemplo de Código para Movimento em Modo Servo de Velocidade no Espaço das Juntas

 1int ServoJVtest()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    robot.SetReConnectParam(true, 300000, 500);
 8    int rtn = robot.RPC("192.168.58.2");
 9    if (rtn != 0)
10    {
11        return -1;
12    }
13    double joint_vel[6] = { 10.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
14    double exis_vel[4] { 0.0, 0.0, 0.0, 0.0 };
15    float acc = 0.0f;
16    float vel = 0.0f;
17    float cmdT = 0.008f;
18    float filterT = 0.0f;
19    float gain = 0.0f;
20    int cnt = 0;
21    while (cnt < 200)
22    {
23        int error = robot.ServoJV(joint_vel, exis_vel, acc, vel, cmdT, filterT, gain);
24        printf("ServoJV rtn is %d\n", error);
25        cnt++;
26    }
27    robot.CloseRPC();
28    robot.Sleep(1000000);
29    return 0;
30}

4.79. Início do Controle MIT das Juntas

1/**
2* @brief Início do controle MIT das juntas
3* @param [in] comType Tipo de envio do comando; 0-xmlrpc; 1-UDP (corresponde à porta 20007 do robô)
4* @return Código de erro
5*/
6errno_t ServoMITStart(int comType = 0);

4.80. Fim do Controle MIT das Juntas

1/**
2* @brief Fim do controle MIT das juntas
3* @param [in] comType Tipo de envio do comando; 0-xmlrpc; 1-UDP (corresponde à porta 20007 do robô)
4* @return Código de erro
5*/
6errno_t ServoMITEnd(int comType = 0);

4.81. Controle MIT das Juntas

 1/**
 2* @brief Controle MIT das juntas
 3* @param [in] posGain Ganho de posição das juntas j1~j6
 4* @param [in] desPos Posição desejada das juntas j1~j6, unidade: deg
 5* @param [in] velGain Ganho de velocidade das juntas j1~j6
 6* @param [in] desVel Velocidade desejada das juntas j1~j6, unidade: deg/s
 7* @param [in] torque_ff Torque de feedforward j1~j6, unidade: Nm
 8* @param [in] interval Período do comando, unidade s, intervalo [0.001~0.008]
 9* @param [in] comType Tipo de envio do comando; 0-xmlrpc; 1-UDP (corresponde à porta 20007 do robô)
10* @return Código de erro
11*/
12errno_t ServoMIT(double posGain[6], double desPos[6], double velGain[6], double desVel[6], double torque_ff[6], double interval, int comType = 0);

4.82. Exemplo de Código para Controle MIT das Juntas do Robô

 1int ServoMITtest()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    robot.SetReConnectParam(true, 30000, 500);
 8    int rtn = robot.SetCmdRpyCallback(UDPFrameCallBack);
 9    printf("SetCmdRpyCallback rtn is %d\n", rtn);
10    rtn = robot.RPC("192.168.58.2");
11    if (rtn != 0)
12    {
13        return -1;
14    }
15    while (true)
16    {
17        robot.ResetAllError();
18        robot.Sleep(500);
19        double posGain[6] = { 0.0 };
20        double desPos[6] = { 0.0 };
21        double velGain[6] = { 0.0 };
22        double desVel[6] = { 0.0 };
23        double torques[6] = { 0.0 };
24        float curTorque[6] = { 0.0 };
25        robot.GetJointTorques(1, curTorque);
26        for (int i = 0; i < 6; i++)
27        {
28            torques[i] = curTorque[i];
29        }
30        robot.ServoMITStart(0);
31        ROBOT_STATE_PKG pkg = {};
32        robot.DragTeachSwitch(1);
33        double intev = 0.008;
34        double jPowerLimit[6] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
35        double jVelLimit[6] = { 50, 50, 50, 50, 50, 50 };
36        int error = 0;
37        while (true)
38        {
39            torques[5] = 0.02;
40            error = robot.ServoMIT(posGain, desPos, velGain, desVel, torques, intev, 0);
41            robot.Sleep(1);
42            robot.GetRobotRealTimeState(&pkg);
43            printf("pkg.jt_cur_pos[5]: %f\n", pkg.jt_cur_pos[5]);
44            if (pkg.jt_cur_pos[5] > 30)
45            {
46                break;
47            }
48        }
49        while (true)
50        {
51            torques[5] = -0.02;
52            error = robot.ServoMIT(posGain, desPos, velGain, desVel, torques, intev, 0);
53            robot.Sleep(1);
54            robot.GetRobotRealTimeState(&pkg);
55            printf("pkg.jt_cur_pos[5]:%f\n", pkg.jt_cur_pos[5]);
56            if (pkg.jt_cur_pos[5] < 0)
57            {
58                break;
59            }
60        }
61        robot.DragTeachSwitch(0);
62        error = robot.ServoMITEnd(0);
63    }
64    robot.CloseRPC();
65    robot.Sleep(1000000);
66    return 0;
67}