4. Movimento do Robô

4.1. Movimento Jog

Protótipo

StartJOG(ref, nb, dir, max_dis, vel=20.0, acc=100.0)

Descrição

Movimento jog

Parâmetros obrigatórios

  • 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;

  • nb: 1-junta1 (eixo X), 2-junta2 (eixo Y), 3-junta3 (eixo Z), 4-junta4 (rx), 5-junta5 (ry), 6-junta6 (rz);

  • dir: 0-direção negativa, 1-direção positiva;

  • max_dis: Ângulo/distância máxima por movimento jog, em ° ou mm;

Parâmetros padrão

  • vel: Percentagem de velocidade, [0~100], padrão 20;

  • acc: Percentagem de aceleração, [0~100], padrão 100;

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.2. Parada Desacelerada do Movimento Jog

Protótipo

StopJOG(ref)

Descrição

Parada desacelerada do movimento jog

Parâmetros obrigatórios

  • 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

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.3. Parada Imediata do Movimento Jog

Protótipo

ImmStopJOG()

Descrição

Parada imediata do movimento jog

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2import time
 3# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 4robot = Robot.RPC('192.168.58.2')
 5for i in range(6):
 6    robot.StartJOG(0, i + 1, 0, 20.0, 20.0, 30.0)
 7    time.sleep(1)
 8    robot.ImmStopJOG()
 9    time.sleep(1)
10for i in range(6):
11    robot.StartJOG(2, i + 1, 0, 20.0, 20.0, 30.0)
12    time.sleep(1)
13    robot.ImmStopJOG()
14    time.sleep(1)
15for i in range(6):
16    robot.StartJOG(4, i + 1, 0, 20.0, 20.0, 30.0)
17    time.sleep(1)
18    robot.StopJOG(5)
19    time.sleep(1)
20for i in range(6):
21    robot.StartJOG(8, i + 1, 0, 20.0, 20.0, 30.0)
22    time.sleep(1)
23    robot.StopJOG(9)
24    time.sleep(1)
25robot.CloseRPC()

4.5. Movimento no Espaço Articular

Protótipo

MoveJ(joint_pos, tool, user, desc_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=20.0, acc=0.0, ovl=100.0, exaxis_pos=[0.0,0.0,0.0,0.0], blendT=-1.0, offset_flag=0, offset_pos=[0.0,0.0,0.0,0.0,0.0,0.0])

Descrição

Movimento no espaço articular

Parâmetros obrigatórios

  • joint_pos: Posição articular alvo, em [°];

  • tool: Número da ferramenta, [0~14];

  • user: Número da peça, [0~14];

Parâmetros padrão

  • desc_pos: Pose cartesiana alvo, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática direta;

  • vel: Percentagem de velocidade, [0~100], padrão 20.0;

  • acc: Percentagem de aceleração, [0~100], temporariamente não disponível;

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • exaxis_pos: Posição do eixo externo 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • blendT: [-1.0]-movimento até o final (bloqueante), [0~500.0]-tempo de suavização (não bloqueante), unidade [ms], padrão -1.0;

  • offset_flag: [0]-sem deslocamento, [1]-deslocamento no sistema de coordenadas peça/base, [2]-deslocamento no sistema de coordenadas da ferramenta, padrão 0;

  • offset_pos: Deslocamento de pose, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0];

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.6. Movimento Linear no Espaço Cartesiano

Novo na versão python: SDK-v2.1.5

Protótipo

MoveL(desc_pos, tool, user, joint_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel=20.0, acc=0.0, ovl=100.0, blendR=-1.0, blendMode=0, exaxis_pos=[0.0, 0.0, 0.0, 0.0], search=0, offset_flag=0, offset_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], oacc=100.0, config=-1, velAccParamMode=0, overSpeedStrategy=0, speedPercent=10)

Descrição

Movimento linear no espaço cartesiano

Parâmetros obrigatórios

  • desc_pos: Pose cartesiana alvo, unidades [mm][°];

  • tool: Número da ferramenta, [0~14];

  • user: Número da peça, [0~14];

Parâmetros padrão

  • joint_pos: Posição articular alvo, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • vel: Percentagem de velocidade, [0~100], padrão 20.0;

  • acc: Percentagem de aceleração, [0~100], temporariamente não disponível, padrão 0.0;

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • blendR: [-1.0]-movimento até o final (bloqueante), [0~1000]-raio de suavização (não bloqueante), unidade [mm], padrão -1.0;

  • blendMode: Modo de transição; 0-transição tangente; 1-transição de canto, padrão 0;

  • exaxis_pos: Posição do eixo externo 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • search: [0]-sem busca de posição do arame, [1]-com busca de posição do arame;

  • offset_flag: [0]-sem deslocamento, [1]-deslocamento no sistema de coordenadas peça/base, [2]-deslocamento no sistema de coordenadas da ferramenta, padrão 0;

  • offset_pos: Deslocamento de pose, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0];

  • oacc: Fator de escala de aceleração [0-100]/aceleração física (mm/s²), padrão 100;

  • 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, padrão -1;

  • velAccParamMode: Modo de parâmetro de velocidade/aceleração; 0-percentagem; 1-velocidade física (mm/s) aceleração (mm/s²), padrão 0;

  • overSpeedStrategy: Estratégia de tratamento de excesso de velocidade, 0-estratégia desativada; 1-padrão; 2-parar com erro em caso de excesso de velocidade; 3-redução adaptativa de velocidade, padrão 0;

  • speedPercent: Percentagem limite de redução de velocidade permitida [0-100], padrão 10%

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.7. Movimento Circular no Espaço Cartesiano

Novo na versão python: SDK-v2.1.5

Protótipo

MoveC(desc_pos_p, tool_p, user_p, desc_pos_t, tool_t, user_t, joint_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], joint_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel_p=20.0, acc_p=100.0, exaxis_pos_p=[0.0, 0.0, 0.0, 0.0], offset_flag_p=0, offset_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel_t=20.0, acc_t=100.0, exaxis_pos_t=[0.0, 0.0, 0.0, 0.0], offset_flag_t=0, offset_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], ovl=100.0, blendR=-1.0, oacc=100.0, config=-1, velAccParamMode=0)

Descrição

Movimento circular no espaço cartesiano

Parâmetros obrigatórios

  • desc_pos_p: Pose cartesiana do ponto de passagem, unidades [mm][°];

  • tool_p: Número da ferramenta do ponto de passagem, [0~14];

  • user_p: Número da peça do ponto de passagem, [0~14];

  • desc_pos_t: Pose cartesiana do ponto alvo, unidades [mm][°];

  • tool_t: Número da ferramenta, [0~14];

  • user_t: Número da peça, [0~14];

Parâmetros padrão

  • joint_pos_p: Posição articular do ponto de passagem, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • joint_pos_t: Posição articular do ponto alvo, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • vel_p: Percentagem de velocidade do ponto de passagem, [0~100], padrão 20.0;

  • acc_p: Percentagem de aceleração do ponto de passagem, [0~100], temporariamente não disponível, padrão 0.0;

  • exaxis_pos_p: Posição do eixo externo do ponto de passagem 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • offset_flag_p: Se o ponto de passagem tem deslocamento [0]-sem deslocamento, [1]-deslocamento no sistema de coordenadas peça/base, [2]-deslocamento no sistema de coordenadas da ferramenta, padrão 0;

  • vel_t: Percentagem de velocidade do ponto alvo, [0~100], padrão 20.0;

  • acc_t: Percentagem de aceleração do ponto alvo, [0~100], temporariamente não disponível, padrão 0.0;

  • exaxis_pos_t: Posição do eixo externo do ponto alvo 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • offset_flag_t: Se o ponto alvo tem deslocamento [0]-sem deslocamento, [1]-deslocamento no sistema de coordenadas peça/base, [2]-deslocamento no sistema de coordenadas da ferramenta, padrão 0;

  • offset_pos_t: Deslocamento de pose do ponto alvo, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0];

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • blendR: [-1.0]-movimento até o final (bloqueante), [0~1000]-raio de suavização (não bloqueante), unidade [mm], padrão -1.0;

  • oacc: Fator de escala de aceleração [0-100]/aceleração física (mm/s²), padrão 100;

  • 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, padrão -1;

  • velAccParamMode: Modo de parâmetro de velocidade/aceleração; 0-percentagem; 1-velocidade física (mm/s) aceleração (mm/s²), padrão 0

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.8. Movimento Circular Completo no Espaço Cartesiano

Novo na versão python: SDK-v2.1.5

Protótipo

Circle(desc_pos_p, tool_p, user_p, desc_pos_t, tool_t, user_t, joint_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], joint_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel_p=20.0, acc_p=0.0, exaxis_pos_p=[0.0, 0.0, 0.0, 0.0], vel_t=20.0, acc_t=0.0, exaxis_pos_t=[0.0, 0.0, 0.0, 0.0], ovl=100.0, offset_flag=0, offset_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], oacc=100.0, blendR=-1, config=-1, velAccParamMode=0)

Descrição

Movimento circular completo no espaço cartesiano

Parâmetros obrigatórios

  • desc_pos_p: Pose cartesiana do ponto de passagem, unidades [mm][°];

  • tool_p: Número da ferramenta, [0~14];

  • user_p: Número da peça, [0~14];

  • desc_pos_t: Pose cartesiana do ponto alvo, unidades [mm][°];

  • tool_t: Número da ferramenta, [0~14];

  • user_t: Número da peça, [0~14];

Parâmetros padrão

  • joint_pos_p: Posição articular do ponto de passagem, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • joint_pos_t: Posição articular do ponto alvo, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • vel_p: Percentagem de velocidade, [0~100], padrão 20.0;

  • acc_p: Percentagem de aceleração do ponto de passagem, [0~100], temporariamente não disponível, padrão 0.0;

  • exaxis_pos_p: Posição do eixo externo do ponto de passagem 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • vel_t: Percentagem de velocidade do ponto alvo, [0~100], padrão 20.0;

  • acc_t: Percentagem de aceleração do ponto alvo, [0~100], temporariamente não disponível, padrão 0.0;

  • exaxis_pos_t: Posição do eixo externo do ponto alvo 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • offset_flag: Se tem deslocamento [0]-sem deslocamento, [1]-deslocamento no sistema de coordenadas peça/base, [2]-deslocamento no sistema de coordenadas da ferramenta, padrão 0;

  • offset_pos: Deslocamento de pose, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0];

  • oacc: Fator de escala de aceleração [0-100]/aceleração física (mm/s²), padrão 100;

  • blendR: -1: bloqueante; 0~1000: raio de suavização, padrão -1;

  • 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, padrão -1;

  • velAccParamMode: Modo de parâmetro de velocidade/aceleração; 0-percentagem; 1-velocidade física (mm/s) aceleração (mm/s²), padrão 0

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.9. Movimento Ponto a Ponto no Espaço Cartesiano

Protótipo

MoveCart(desc_pos, tool, user, vel=20.0, acc=0.0, ovl=100.0, blendT=-1.0, config=-1)

Descrição

Movimento ponto a ponto no espaço cartesiano

Parâmetros obrigatórios

  • desc_pos: Posição cartesiana alvo;

  • tool: Número da ferramenta, [0~14];

  • user: Número da peça, [0~14];

Parâmetros padrão

  • vel: Velocidade, intervalo [0~100], padrão 20.0;

  • acc: Aceleração, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • blendT: [-1.0]-movimento até o final (bloqueante), [0~500]-tempo de suavização (não bloqueante), unidade [ms], padrão -1.0;

  • config: Configuração articular, [-1]-resolver com base na posição articular atual, [0~7]-resolver com base na configuração articular, padrão -1

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6j3 = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257]
 7j4 = [-31.154, -95.317, 94.276, -88.079, -89.740, 74.256]
 8desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 9desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
10desc_pos3 = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061]
11desc_pos4 = [-443.165, 147.881, 480.951, 179.511, -0.775, -15.409]
12offset_pos = [0.0] * 6
13epos = [0.0] * 4
14tool = 0
15user = 0
16vel = 100.0
17acc = 100.0
18ovl = 100.0
19oacc = 100.0
20blendT = 0.0
21blendR = 0.0
22flag = 0
23search = 0
24blendMode = 0
25velAccMode = 0
26robot.SetSpeed(20)
27rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
28print(f"movej errcode:{rtn}")
29rtn = robot.MoveL(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendR=blendR, blendMode=blendMode, exaxis_pos=epos, search=search, offset_flag=flag, offset_pos=offset_pos, oacc=oacc, velAccParamMode=velAccMode)
30print(f"movel errcode:{rtn}")
31rtn = robot.MoveC(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, offset_flag_p=flag, offset_pos_p=offset_pos, desc_pos_t=desc_pos4, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, offset_flag_t=flag, offset_pos_t=offset_pos, ovl=ovl, blendR=blendR, oacc=oacc, velAccParamMode=velAccMode)
32print(f"movec errcode:{rtn}")
33rtn = robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
34print(f"movej errcode:{rtn}")
35rtn = robot.Circle(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, desc_pos_t=desc_pos1, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos, oacc=oacc, blendR=-1, velAccParamMode=velAccMode)
36print(f"circle errcode:{rtn}")
37rtn = robot.MoveCart(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendT=blendT, config=-1)
38print(f"MoveCart errcode:{rtn}")
39rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
40print(f"movej errcode:{rtn}")
41rtn = robot.MoveL(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendR=blendR, blendMode=blendMode, exaxis_pos=epos, search=search, offset_flag=flag, offset_pos=offset_pos, config=-1, velAccParamMode=velAccMode)
42print(f"movel errcode:{rtn}")
43rtn = robot.MoveC(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, offset_flag_p=flag, offset_pos_p=offset_pos, desc_pos_t=desc_pos4, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, offset_flag_t=flag, offset_pos_t=offset_pos, ovl=ovl, blendR=blendR, config=-1, velAccParamMode=velAccMode)
44print(f"movec errcode:{rtn}")
45rtn = robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
46print(f"movej errcode:{rtn}")
47rtn = robot.Circle(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, desc_pos_t=desc_pos1, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos, oacc=oacc, blendR=-1, velAccParamMode=velAccMode)
48print(f"circle errcode:{rtn}")
49robot.CloseRPC()
50return 0

4.11. Movimento Helicoidal no Espaço Cartesiano

Novo na versão python: SDK-v2.1.7

Protótipo

NewSpiral(desc_pos, tool, user, param, joint_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=20.0, acc=0.0, exaxis_pos=[0.0,0.0,0.0,0.0], ovl=100.0, offset_flag=0, offset_pos=[0.0,0.0,0.0,0.0,0.0,0.0], config=-1)

Descrição

Movimento helicoidal no espaço cartesiano

Parâmetros obrigatórios

  • desc_pos: Pose cartesiana alvo, unidades [mm][°];

  • tool: Número da ferramenta, [0~14];

  • user: Número da peça, [0~14];

  • param=[circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode]: circle_num: Número de voltas da espiral; circle_angle: Ângulo de inclinação da espiral; rad_init: Raio inicial da espiral; rad_add: Incremento do raio; rotaxis_add: Incremento na direção do eixo de rotação; rot_direction: Direção de rotação, 0-horário, 1-anti-horário; velAccMode: Modo de parâmetro de velocidade/aceleração: 0-velocidade angular constante, 1-velocidade linear constante;

Parâmetros padrão

  • joint_pos: Posição articular alvo, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • vel: Percentagem de velocidade, [0~100], padrão 20.0;

  • acc: Percentagem de aceleração, [0~100], padrão 100.0;

  • exaxis_pos: Posição do eixo externo 1 ~ posição do eixo externo 4, padrão [0.0,0.0,0.0,0.0];

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • offset_flag: [0]-sem deslocamento, [1]-deslocamento no sistema de coordenadas peça/base, [2]-deslocamento no sistema de coordenadas da ferramenta, padrão 0;

  • offset_pos: Deslocamento de pose, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0];

  • 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, padrão -1

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.12. Exemplo de Código

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4j = [67.957, -81.482, 87.595, -95.691, -94.899, -9.727]
 5desc_pos = [-123.142, -551.735, 430.549, 178.753, -4.757, 167.754]
 6offset_pos1 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0]
 7offset_pos2 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0]
 8epos = [0.0] * 4
 9sp = [2, 30.0, 50.0, 10.0, 10.0, 0, 1]  # [circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode]
10tool = 0
11user = 0
12vel = 30.0
13acc = 60.0
14ovl = 100.0
15blendT = -1.0
16flag = 2
17robot.SetSpeed(20)
18rtn = robot.MoveJ(joint_pos=j, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos1)
19print(f"movej errcode:{rtn}")
20rtn = robot.NewSpiral(desc_pos=desc_pos, tool=tool, user=user, vel=vel, acc=acc, exaxis_pos=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos2, param=sp)
21print(f"newspiral errcode:{rtn}")
22robot.CloseRPC()
23return 0

4.13. Início do Movimento Servo

Protótipo

ServoMoveStart(cmdType=0)

Descrição

Início do movimento servo, para uso com instruções ServoJ e ServoCart

Parâmetros obrigatórios

  • cmdType: Tipo de transmissão de comando, 0=XML-RPC, 1=transmissão transparente UDP

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.14. Fim do Movimento Servo

Protótipo

ServoMoveEnd(cmdType=0)

Descrição

Fim do movimento servo, para uso com instruções ServoJ e ServoCart

Parâmetros obrigatórios

  • cmdType: Tipo de transmissão de comando, 0=XML-RPC, 1=transmissão transparente UDP

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.15. Movimento no Modo Servo no Espaço Articular

Protótipo

ServoJ(joint_pos, axisPos, acc=0.0, vel=0.0, cmdT=0.008, filterT=0.0, gain=0.0, id=0, cmdType=0)

Descrição

Movimento no modo servo no espaço articular

Parâmetros obrigatórios

  • joint_pos: Posição articular alvo, em [°];

  • axisPos: Posição do eixo externo, em mm;

Parâmetros padrão

  • acc: Aceleração, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • vel: Velocidade, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • cmdT: Período de envio de instrução, em s, intervalo recomendado [0.001~0.0016], padrão 0.008;

  • filterT: Tempo de filtro, em [s], temporariamente não disponível, padrão 0.0;

  • gain: Amplificador proporcional da posição alvo, temporariamente não disponível, padrão 0.0;

  • id: ID da instrução ServoJ, padrão 0;

  • cmdType: Tipo de transmissão de comando, 0=XML-RPC, 1=transmissão transparente UDP;

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.16. Exemplo de Código SDK para ServoJ, ServoMoveStart, ServoMoveEnd com comunicação UDP

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Estabelece conexão com o controlador do robô
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestServoJUDP(self):
 9    # Definir retorno de chamada
10    def callback(src_type, count, cmd_id, data_len, content):
11        print("Função de retorno de chamada: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content))
12        return 0
13
14    robot.SetUDPCmdRpyCallback(callback)
15    # # Inicializar posição articular e posição do eixo externo
16    j = [105, -108, 74, -66, -88.893, -1.621]
17    offset_pos = [0, 0, 0, 0, 0, 0]
18    epos = [0, 0, 0, 0]
19    # # Mover para posição inicial
20    result = robot.MoveJ(joint_pos=j, tool=0, user=0, vel=100, acc=100, ovl=100, exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
21    print("Resultado de MoveJ: {}".format(result))
22    vel = 0.0
23    acc = 0.0
24    cmdT = 0.016
25    filterT = 0.0
26    gain = 0.0
27    flag = 0
28    dt = 0.1
29    cmdID = 0
30
31    # Obter posição articular atual
32    ret, j = robot.GetActualJointPosDegree(flag)
33    if ret != 0:
34        print(f"GetActualJointPosDegree errcode:{ret}")
35    while 1:
36        count = 300
37        result = robot.ServoMoveStart(cmdType=1)
38        print("Resultado de ServoMoveStart: {}".format(result))
39        while count > 0:
40            result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT, filterT=filterT, gain=gain, id=cmdID, cmdType=1)
41            j[0] += dt
42            j[1] += dt
43            j[2] += dt
44            j[3] += dt
45            j[4] += dt
46            j[5] += dt
47            count -= 1
48            time.sleep(0.01)
49        result = robot.ServoMoveEnd(cmdType=1)
50        print("Resultado de ServoMoveEnd: {}".format(result))
51
52        count = 300
53        result = robot.ServoMoveStart(cmdType=1)
54        print("Resultado de ServoMoveStart: {}".format(result))
55        while count > 0:
56            result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT, filterT=filterT, gain=gain, id=cmdID, cmdType=1)
57            j[0] -= dt
58            j[1] -= dt
59            j[2] -= dt
60            j[3] -= dt
61            j[4] -= dt
62            j[5] -= dt
63            count -= 1
64            time.sleep(0.01)
65        result = robot.ServoMoveEnd(cmdType=1)
66        print("Resultado de ServoMoveEnd: {}".format(result))
67    robot.CloseRPC()
68    return 0
69
70TestServoJUDP(robot)

4.17. Exemplo de Código de Movimento no Modo Servo no Espaço Articular

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4j = [0.0] * 6
 5epos = [0.0] * 4
 6vel = 0.0
 7acc = 0.0
 8cmdT = 0.008
 9filterT = 0.0
10gain = 0.0
11flag = 0
12count = 500
13dt = 0.1
14cmdID = 0
15ret, j = robot.GetActualJointPosDegree(flag)
16if ret == 0:
17    cmdID += 1
18    robot.ServoMoveStart()
19    while count:
20        robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT, filterT=filterT, gain=gain, id=cmdID)
21        j[4] += dt
22        count -= 1
23        time.sleep(cmdT)
24        rtn, pkg = robot.GetRobotRealTimeState()
25        print(f"Servoj Count {pkg.servoJCmdNum}; last pos is {pkg.lastServoTarget[0]},{pkg.lastServoTarget[1]},{pkg.lastServoTarget[2]},{pkg.lastServoTarget[3]},{pkg.lastServoTarget[4]},{pkg.lastServoTarget[5]}")
26
27        if count < 50:
28            robot.MotionQueueClear()
29            print(f"After queue clear, Servoj Count {pkg.servoJCmdNum}; last pos is {pkg.lastServoTarget[0]},{pkg.lastServoTarget[1]},{pkg.lastServoTarget[2]},{pkg.lastServoTarget[3]},{pkg.lastServoTarget[4]},{pkg.lastServoTarget[5]}")
30            break
31    robot.ServoMoveEnd()
32else:
33    print(f"GetActualJointPosDegree errcode:{ret}")
34robot.CloseRPC()

4.18. Início do Controle de Torque Articular

Protótipo

ServoJTStart(cmdType=0)

Descrição

Início do controle de torque articular

Parâmetros obrigatórios

  • cmdType: Tipo de transmissão de comando, 0=XML-RPC, 1=transmissão transparente UDP

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.19. Controle de Torque Articular

Protótipo

ServoJT(torque, interval, checkFlag=0, jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], cmdType=0)

Descrição

Controle de torque articular

Parâmetros obrigatórios
  • torque: Torque das juntas j1~j6, em Nm

    • interval: Período de instrução, em s, intervalo [0.001~0.008]

    • 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, padrão 0

    • jPowerLimit: Parâmetros padrão jPowerLimit Limite máximo de potência da junta (W), padrão [0.0,0.0,0.0,0.0,0.0,0.0]

    • jVelLimit: Velocidade máxima da junta (°/s), padrão [0.0,0.0,0.0,0.0,0.0,0.0]

    • cmdType: Tipo de transmissão de comando, 0=XML-RPC, 1=transmissão transparente UDP

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.20. Fim do Controle de Torque Articular

Protótipo

ServoJTEnd(cmdType=0)

Descrição

Fim do controle de torque articular

Parâmetros obrigatórios

  • cmdType: Tipo de transmissão de comando, 0=XML-RPC, 1=transmissão transparente UDP

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.21. Exemplo de Código SDK para ServoJT, ServoJTStart, ServoJTEnd com comunicação UDP

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Estabelece conexão com o controlador do robô
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestServoJTUDP(self):
 9    # Definir retorno de chamada
10    def callback(src_type, count, cmd_id, data_len, content):
11        print("Função de retorno de chamada: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content))
12        return 0
13
14    robot.SetUDPCmdRpyCallback(callback)
15    while True:
16        # Inicializar posição articular e posição do eixo externo
17        j = [0, -90, 90, 0, 0, 0]
18        epos = [0, 0, 0, 0]
19        offset_pos = [0, 0, 0, 0, 0, 0]
20
21        # Mover para posição inicial
22        robot.MoveJ(joint_pos=j, tool=0, user=0, vel=100, acc=100, ovl=100,
23                    exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
24        time.sleep(3)
25        # Ativar arrasto para ensino
26        result = robot.DragTeachSwitch(1)
27        print("Resultado de DragTeachSwitch: {}".format(result))
28        torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
29
30        # Obter torque das juntas
31        ret, torques = robot.GetJointTorques(flag=1)
32        if ret != 0:
33            print(f"GetJointTorques errcode:{ret}")
34
35        count = 100
36        result = robot.ServoJTStart(cmdType=1)
37        print("Resultado de ServoJTStart: {}".format(result))
38        # Controle de torque positivo
39        while True:
40            torques[0] = 0.03
41            result = robot.ServoJT(
42                torque=torques,
43                interval=0.001,
44                checkFlag=0,
45                jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
46                jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
47                cmdType=1
48            )
49            print("Resultado: {}".format(result))
50            time.sleep(1)
51
52            ret, pkg = robot.GetRobotRealTimeState()
53            if pkg.jt_cur_pos[0] > 30:
54                break
55
56        # Controle de torque negativo
57        while True:
58            torques[0] = -0.03
59            result = robot.ServoJT(
60                    torque=torques,
61                    interval=0.001,
62                    checkFlag=0,
63                    jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
64                    jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
65                    cmdType=1
66                )
67            print("Resultado: {}".format(result))
68            time.sleep(1)
69
70            ret, pkg = robot.GetRobotRealTimeState()
71            if pkg.jt_cur_pos[0] < 0:
72                break
73
74        # Finalizar controle de torque e desativar arrasto para ensino
75        result = robot.ServoJTEnd(cmdType=1)
76        print("Resultado de ServoJTEnd: {}".format(result))
77        result = robot.DragTeachSwitch(0)
78        print("Resultado de DragTeachSwitch: {}".format(result))
79
80    robot.CloseRPC()
81    return 0
82
83TestServoJTUDP(robot)

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

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4robot.DragTeachSwitch(1)
 5# torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
 6error, torques = robot.GetJointTorques(1)
 7robot.ServoJTStart()
 8count = 100
 9while count > 0:
10    error = robot.ServoJT(torques, 0.001)
11    count -= 1
12    time.sleep(0.001)
13error = robot.ServoJTEnd()
14robot.DragTeachSwitch(0)
15robot.CloseRPC()

4.23. Movimento no Modo Servo no Espaço Cartesiano

Protótipo

ServoCart(mode, desc_pos, exaxis, pos_gain=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], acc=0.0, vel=0.0, cmdT=0.008, filterT=0.0, gain=0.0)

Descrição

Movimento no modo servo no espaço cartesiano

Parâmetros obrigatórios

  • mode: [0]-movimento absoluto (sistema de coordenadas base), [1]-movimento incremental (sistema de coordenadas base), [2]-movimento incremental (sistema de coordenadas da ferramenta);

  • exaxis: Posição do eixo estendido;

  • desc_pos: Posição cartesiana alvo/incremento da posição cartesiana alvo;

Parâmetros padrão

  • pos_gain: Coeficiente de escala do incremento de pose, ativo apenas em movimento incremental, intervalo [0~1], padrão [1.0, 1.0, 1.0, 1.0, 1.0, 1.0];

  • acc: Aceleração, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • vel: Velocidade, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • cmdT: Período de envio de instrução, em s, intervalo recomendado [0.001~0.0016], padrão 0.008;

  • filterT: Tempo de filtro, em [s], temporariamente não disponível, padrão 0.0;

  • gain: Amplificador proporcional da posição alvo, temporariamente não disponível, padrão 0.0;

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4desc_pos_dt = [83.00800, 50.525000, 29.246, 179.629, -7.138, -166.975]
 5exaxis = [100.0, 0.0, 0.0, 0.0]
 6pos_gain = [0.0] * 6
 7mode = 0
 8vel = 0.0
 9acc = 0.0
10cmdT = 0.001
11filterT = 0.0
12gain = 0.0
13flag = 0
14count = 5000
15robot.SetSpeed(20)
16while count:
17    rtn = robot.ServoCart(mode, desc_pos_dt, exaxis, pos_gain, acc, vel, cmdT, filterT, gain)
18    print(f"ServoCart rtn is {rtn}")
19    count -= 1
20    desc_pos_dt[0] += 0.01
21    exaxis[0] += 0.01
22robot.CloseRPC()
23return 0

4.25. Início do Movimento Spline

Protótipo

SplineStart()

Descrição

Início do movimento spline

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.26. Movimento Spline PTP

Protótipo

SplinePTP(joint_pos, tool, user, desc_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=20.0, acc=100.0, ovl=100.0)

Descrição

Movimento spline PTP

Parâmetros obrigatórios

  • joint_pos: Posição articular alvo, em [°];

  • tool: Número da ferramenta, [0~14];

  • user: Número da peça, [0~14];

Parâmetros padrão

  • desc_pos: Pose cartesiana alvo, unidades [mm][°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática direta;

  • vel: Velocidade, intervalo [0~100], padrão 20.0;

  • acc: Aceleração, intervalo [0~100], padrão 100.0;

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.27. Fim do Movimento Spline

Protótipo

SplineEnd()

Descrição

Fim do movimento spline

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.28. Exemplo de Código de Movimento Spline

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4joint_points = [
 5    [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256],  # j1
 6    [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255],  # j2
 7    [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260],  # j3
 8    [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267]  # j4
 9]
10cart_points = [
11    [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833],  # desc_pos1
12    [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869],  # desc_pos2
13    [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207],  # desc_pos3
14    [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818]  # desc_pos4
15]
16offset_pos = [0] * 6
17epos = [0] * 4
18tool = user = 0
19vel = acc = ovl = 100.0
20blendT = -1.0
21flag = 0
22robot.SetSpeed(20)
23err1 = robot.MoveJ(joint_pos=joint_points[0], tool=tool, user=user, vel=vel)
24print(f"MoveJ 错误码: {err1}")
25robot.SplineStart()
26robot.SplinePTP(joint_pos=joint_points[0], tool=tool, user=user)
27robot.SplinePTP(joint_pos=joint_points[1], tool=tool, user=user)
28robot.SplinePTP(joint_pos=joint_points[2], tool=tool, user=user)
29robot.SplinePTP(joint_pos=joint_points[3], tool=tool, user=user)
30robot.SplineEnd()
31robot.CloseRPC()

4.29. Início do Novo Movimento Spline

Alterado na versão python: SDK-v2.0.3

Protótipo

NewSplineStart(type, averageTime=2000)

Descrição

Início do novo movimento spline

Parâmetros obrigatórios

  • type: 0-transição circular, 1-pontos fornecidos são pontos de caminho

Parâmetros padrão

  • averageTime: Tempo médio global de transição (ms), padrão 2000

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.30. Ponto de Instrução do Novo Spline

Protótipo

NewSplinePoint(desc_pos, tool, user, lastFlag, joint_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=0.0, acc=0.0, ovl=100.0, blendR=0.0)

Descrição

Ponto de instrução do novo spline

Parâmetros obrigatórios

  • desc_pos: Pose cartesiana alvo, unidades [mm][°];

  • tool: Número da ferramenta, [0~14];

  • user: Número da peça, [0~14];

  • lastFlag: Se é o último ponto, 0-não, 1-sim;

Parâmetros padrão

  • joint_pos: Posição articular alvo, unidade [°], padrão [0.0,0.0,0.0,0.0,0.0,0.0], valor padrão é o retorno da solução de cinemática inversa;

  • vel: Velocidade, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • acc: Aceleração, intervalo [0~100], temporariamente não disponível, padrão 0.0;

  • ovl: Fator de escala de velocidade, [0~100], padrão 100.0;

  • blendR: [0~1000]-raio de suavização, unidade [mm], padrão 0.0;

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.31. Fim do Novo Movimento Spline

Protótipo

NewSplineEnd()

Descrição

Fim do novo movimento spline

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.32. Exemplo de Código do Novo Movimento Spline

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6j3 = [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260]
 7j4 = [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267]
 8j5 = [-95.228, -54.621, 73.691, -112.245, -91.280, 74.268]
 9desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
10desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
11desc_pos3 = [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207]
12desc_pos4 = [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818]
13desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482]
14offset_pos = [0, 0, 0, 0, 0, 0]
15epos = [0, 0, 0, 0]
16tool = 0
17user = 0
18vel = 100.0
19acc = 100.0
20ovl = 100.0
21blendT = -1.0
22flag = 0
23robot.SetSpeed(20)
24err1 = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
25print(f"movej errcode:{err1}")
26robot.NewSplineStart(1, 2000)
27robot.NewSplinePoint(desc_pos=desc_pos1, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
28robot.NewSplinePoint(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
29robot.NewSplinePoint(desc_pos=desc_pos3, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
30robot.NewSplinePoint(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
31robot.NewSplinePoint(desc_pos=desc_pos5, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
32robot.NewSplineEnd()
33robot.CloseRPC()

4.33. Parar Movimento do Robô

Protótipo

StopMotion()

Descrição

Parar movimento, o uso de parar movimento requer que a instrução de movimento esteja em estado não bloqueante

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.34. Pausar Movimento do Robô

Protótipo

PauseMotion()

Descrição

Pausar movimento, o uso de pausar movimento requer que a instrução de movimento esteja em estado não bloqueante

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.35. Retomar Movimento do Robô

Protótipo

ResumeMotion()

Descrição

Retomar movimento, o uso de retomar movimento requer que a instrução de movimento esteja em estado não bloqueante

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j5 = [-95.228, -54.621, 73.691, -112.245, -91.280, 74.268]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9epos = [0, 0, 0, 0]
10tool = 0
11user = 0
12vel = 100.0
13acc = 100.0
14ovl = 100.0
15blendT = -1.0
16flag = 0
17robot.SetSpeed(20)
18rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
19rtn = robot.MoveJ(joint_pos=j5, tool=tool, user=user, vel=vel, blendT=1)
20time.sleep(1)
21robot.PauseMotion()
22time.sleep(1)
23robot.ResumeMotion()
24time.sleep(1)
25robot.StopMotion()
26time.sleep(1)
27robot.CloseRPC()

4.37. Início do Deslocamento Global de Pontos

Protótipo

PointsOffsetEnable(flag, offset_pos)

Descrição

Início do deslocamento global de pontos

Parâmetros obrigatórios

  • flag: 0-deslocamento no sistema de coordenadas base/peça, 2-deslocamento no sistema de coordenadas da ferramenta;

  • offset_pos: Quantidade de deslocamento, unidades [mm][°].

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.38. Fim do Deslocamento Global de Pontos

Protótipo

PointsOffsetDisable()

Descrição

Fim do deslocamento global de pontos

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.39. Exemplo de Código de Deslocamento de Pontos

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9offset_pos1 = [0, 0, 50, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 100.0
14acc = 100.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
20robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
21time.sleep(1)
22robot.PointsOffsetEnable(flag=0, offset_pos=offset_pos1)
23robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
24robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
25robot.PointsOffsetDisable()
26robot.CloseRPC()

4.40. Início do AO de Movimento da Caixa de Controle

Novo na versão python: SDK-v2.0.4

Protótipo

MoveAOStart(AONum, maxTCPSpeed=1000, maxAOPercent=100, zeroZoneCmp=20)

Descrição

Início do AO de movimento da caixa de controle

Parâmetros obrigatórios

  • AONum: Número da AO da caixa de controle

Parâmetros padrão

  • maxTCPSpeed: Valor máximo da velocidade TCP [1-5000 mm/s], padrão 1000;

  • maxAOPercent: Percentagem de AO correspondente ao valor máximo da velocidade TCP, padrão 100%;

  • zeroZoneCmp: Valor de compensação da zona morta em percentagem de AO, inteiro, padrão 20%, intervalo [0-100].

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.41. Fim do AO de Movimento da Caixa de Controle

Novo na versão python: SDK-v2.0.4

Protótipo

MoveAOStop()

Descrição

Fim do AO de movimento da caixa de controle

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.42. Início do AO de Movimento da Extremidade

Novo na versão python: SDK-v2.0.4

Protótipo

MoveToolAOStart(AONum, maxTCPSpeed=1000, maxAOPercent=100, zeroZoneCmp=20)

Descrição

Início do AO de movimento da extremidade

Parâmetros obrigatórios

  • AONum: Número da AO da extremidade

Parâmetros padrão

  • maxTCPSpeed: Valor máximo da velocidade TCP [1-5000 mm/s], padrão 1000;

  • maxAOPercent: Percentagem de AO correspondente ao valor máximo da velocidade TCP, padrão 100%;

  • zeroZoneCmp: Valor de compensação da zona morta em percentagem de AO, inteiro, padrão 20%, intervalo [0-100].

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.43. Fim do AO de Movimento da Extremidade

Novo na versão python: SDK-v2.0.4

Protótipo

MoveToolAOStop()

Descrição

Fim do AO de movimento da extremidade

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.44. Exemplo de Código de Captura com AO

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9offset_pos1 = [0, 0, 50, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 20.0
14acc = 20.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19robot.MoveAOStart(0, 100, 100, 20)
20robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
21robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
22robot.MoveAOStop()
23time.sleep(1)
24robot.MoveToolAOStart(0, 100, 100, 20)
25robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
26robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
27robot.MoveToolAOStop()
28robot.CloseRPC()

4.45. Início do Filtro FIR para Movimento Ptp

Novo na versão python: SDK-v2.1.2

Protótipo

PtpFIRPlanningStart(maxAcc, maxJek)

Descrição

Início do filtro FIR para movimento Ptp

Parâmetros obrigatórios

  • maxAcc: Valor extremo máximo de aceleração (deg/s²)

  • maxJek: Valor extremo de jerk uniforme das juntas (deg/s³)

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.46. Desligar o Filtro FIR para Movimento Ptp

Novo na versão python: SDK-v2.0.7

Protótipo

PtpFIRPlanningEnd()

Descrição

Desligar o filtro FIR para movimento Ptp

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

Novo na versão python: SDK-v2.0.7

Protótipo

LinArcFIRPlanningStart(maxAccLin, maxAccDeg, maxJerkLin, maxJerkDeg)

Descrição

Início do filtro FIR para movimento LIN e ARC

Parâmetros obrigatórios

  • maxAccLin: Valor extremo de aceleração linear (mm/s²)

  • maxAccDeg: Valor extremo de aceleração angular (deg/s²)

  • maxJerkLin: Valor extremo de jerk linear (mm/s³)

  • maxJerkDeg: Valor extremo de jerk angular (deg/s³)

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.48. Desligar o Filtro FIR para Movimento LIN e ARC

Novo na versão python: SDK-v2.0.7

Protótipo

LinArcFIRPlanningEnd()

Descrição

Desligar o filtro FIR para movimento LIN e ARC

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.49. Exemplo de Código de Filtro FIR

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6midjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 7endjointPos = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257]
 8startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 9middescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
10enddescPose = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061]
11exaxisPos = [0.0, 0.0, 0.0, 0.0]
12offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
13rtn = robot.PtpFIRPlanningStart(1000.0, 1000.0)
14print(f"PtpFIRPlanningStart rtn is {rtn}")
15error = robot.MoveJ(joint_pos=startjointPos, tool=0, user=0, desc_pos=startdescPose, vel=100, acc=100, ovl=100, blendT=-1.0, offset_flag=0)
16print(f"MoveJ rtn is {rtn}")
17error = robot.MoveJ(joint_pos=endjointPos, tool=0, user=0, desc_pos=enddescPose, vel=100, acc=100, ovl=100, blendT=-1.0, offset_flag=0)
18print(f"MoveJ rtn is {rtn}")
19robot.PtpFIRPlanningEnd()
20print(f"PtpFIRPlanningEnd rtn is {rtn}")
21rtn = robot.LinArcFIRPlanningStart(1000, 1000, 1000, 1000)
22print(f"LinArcFIRPlanningStart rtn is {rtn}")
23error = robot.MoveL(desc_pos=startdescPose, tool=0, user=0, joint_pos=startjointPos, vel=100, overSpeedStrategy=1, speedPercent=1)
24print(f"MoveL rtn is {rtn}")
25error = robot.MoveC(desc_pos_p=middescPose, tool_p=0, user_p=0, joint_pos_p=midjointPos, vel_p=100, desc_pos_t=enddescPose, tool_t=0, user_t=0, joint_pos_t=endjointPos, vel_t=100)
26print(f"MoveC rtn is {rtn}")
27robot.LinArcFIRPlanningEnd()
28print(f"LinArcFIRPlanningEnd rtn is {rtn}")
29robot.CloseRPC()

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

Novo na versão python: SDK-v2.1.1

Protótipo

AccSmoothStart(saveFlag_flag)

Descrição

Ativar suavização de aceleração

Parâmetros obrigatórios

  • saveFlag_flag: Se salvar após desligamento

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

Novo na versão python: SDK-v2.1.1

Protótipo

AccSmoothEnd(saveFlag_flag)

Descrição

Desativar suavização de aceleração

Parâmetros obrigatórios

  • saveFlag_flag: Se salvar após desligamento

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8exaxisPos = [0.0, 0.0, 0.0, 0.0]
 9offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
10rtn = robot.AccSmoothStart(0)
11print(f"AccSmoothStart rtn is {rtn}")
12robot.MoveJ(joint_pos=startjointPos, tool=0, user=0, vel=100)
13robot.MoveJ(joint_pos=endjointPos, tool=0, user=0, vel=100)
14rtn = robot.AccSmoothEnd(0)
15print(f"AccSmoothEnd rtn is {rtn}")

4.53. Ativar Velocidade de Postura Especificada do Robô

Novo na versão python: SDK-v2.0.5

Protótipo

AngularSpeedStart(ratio)

Descrição

Ativar velocidade de postura especificada

Parâmetros obrigatórios

  • ratio: Percentagem da velocidade de postura [0-300]

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.54. Desativar Velocidade de Postura Especificada

Novo na versão python: SDK-v2.0.5

Protótipo

AngularSpeedEnd()

Descrição

Desativar velocidade de postura especificada

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8exaxisPos = [0.0, 0.0, 0.0, 0.0]
 9offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
10rtn = robot.AngularSpeedStart(50)
11print(f"AngularSpeedStart rtn is {rtn}")
12robot.MoveJ(joint_pos=startjointPos, tool=0, user=0, vel=100)
13robot.MoveJ(joint_pos=endjointPos, tool=0, user=0, vel=100)
14rtn = robot.AngularSpeedEnd()
15print(f"AngularSpeedEnd rtn is {rtn}")
16robot.CloseRPC()

4.56. Ativar Proteção contra Pose Singular

Novo na versão python: SDK-v2.0.5

Protótipo

SingularAvoidStart(protectMode, minShoulderPos=100, minElbowPos=50, minWristPos=10)

Descrição

Ativar proteção contra pose singular

Parâmetros obrigatórios

  • protectMode: Modo de proteção contra pose singular: 0-modo articular; 1-modo cartesiano

Parâmetros padrão

  • minShoulderPos: Faixa de ajuste da singularidade do ombro (mm), padrão 100.0

  • minElbowPos: Faixa de ajuste da singularidade do cotovelo (mm), padrão 50.0

  • minWristPos: Faixa de ajuste da singularidade do pulso (°), padrão 10.0

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

4.57. Desativar Proteção contra Pose Singular

Novo na versão python: SDK-v2.0.5

Protótipo

SingularAvoidEnd()

Descrição

Desativar proteção contra pose singular

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2import time
 3# Estabelece conexão com o controlador do robô, retorna um objeto robô se a conexão for bem-sucedida
 4robot = Robot.RPC('192.168.58.2')
 5startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 7startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 8enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 9exaxisPos = [0.0, 0.0, 0.0, 0.0]
10offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
11rtn = robot.SingularAvoidStart(2, 10, 5, 5)
12print(f"SingularAvoidStart rtn is {rtn}")
13robot.MoveJ(joint_pos=startjointPos, tool=0, user=0, vel=100)
14robot.MoveJ(joint_pos=endjointPos, tool=0, user=0, vel=100)
15rtn = robot.SingularAvoidEnd()
16print(f"SingularAvoidEnd rtn is {rtn}")
17robot.CloseRPC()

4.59. Limpar Fila de Instruções de Movimento

Novo na versão python: SDK-v2.1.7

Protótipo

MotionQueueClear()

Descrição

Limpar fila de instruções de movimento

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

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

Protótipo

MoveToIntersectLineStart(mainPoint, piecePoint, tool, wobj, vel, acc, ovl, oacc, moveType, mainExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], pieceExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], extAxisFlag=0, exaxisPos=[0.0,0.0,0.0,0.0], moveDirection=0, offset=[0.0,0.0,0.0,0.0,0.0,0.0])

Descrição

Mover para ponto inicial da linha de interseção

Parâmetros obrigatórios

  • mainPoint: Poses cartesianas dos 6 pontos de ensino do tubo principal

  • piecePoint: Poses cartesianas dos 6 pontos de ensino do tubo auxiliar

  • tool: Número do sistema de coordenadas da ferramenta

  • wobj: Número do sistema de coordenadas da peça

  • vel: Percentagem de velocidade

  • acc: Percentagem de aceleração

  • ovl: Fator de escala de velocidade

  • oacc: Fator de escala de aceleração

  • moveType: Tipo de movimento; 0-PTP; 1-LIN

  • mainExaxisPos: Posições dos eixos estendidos dos 6 pontos de ensino do tubo principal, padrão [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • pieceExaxisPos: Posições dos eixos estendidos dos 6 pontos de ensino do tubo de junção, padrão [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • extAxisFlag: Se habilita o eixo estendido; 0-não habilita; 1-habilita

  • exaxisPos: Posição do eixo estendido inicial [0.0,0.0,0.0,0.0]

  • moveDirection: Direção do movimento; 0-horário; 1-anti-horário

  • offset: Deslocamento

Parâmetros padrão

Nenhum

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

4.61. Movimento na Linha de Interseção

Protótipo

MoveIntersectLine(mainPoint, piecePoint, tool, wobj, vel, acc, ovl, oacc, moveDirection, mainExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], pieceExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], extAxisFlag=0, exaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], offset=[0.0,0.0,0.0,0.0,0.0,0.0])

Descrição

Movimento na linha de interseção

Parâmetros obrigatórios

  • mainPoint: Poses cartesianas dos 6 pontos de ensino do tubo principal

  • piecePoint: Poses cartesianas dos 6 pontos de ensino do tubo auxiliar

  • tool: Número do sistema de coordenadas da ferramenta

  • wobj: Número do sistema de coordenadas da peça

  • vel: Percentagem de velocidade

  • acc: Percentagem de aceleração

  • ovl: Fator de escala de velocidade

  • oacc: Fator de escala de aceleração

  • moveDirection: Direção do movimento; 0-horário; 1-anti-horário

  • mainExaxisPos: Posições dos eixos estendidos dos 6 pontos de ensino do tubo principal, padrão [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • pieceExaxisPos: Posições dos eixos estendidos dos 6 pontos de ensino do tubo de junção, padrão [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • extAxisFlag: Se habilita o eixo estendido; 0-não habilita; 1-habilita

  • exaxisPos: Posição do eixo estendido inicial [0.0,0.0,0.0,0.0]

  • offset: Deslocamento

Parâmetros padrão

Nenhum

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4mainPoint = [[0.0] * 6 for _ in range(6)]
 5piecePoint = [[0.0] * 6 for _ in range(6)]
 6mainExaxisPos = [[0.0] * 4 for _ in range(6)]
 7pieceExaxisPos = [[0.0] * 4 for _ in range(6)]
 8extAxisFlag = 1
 9exaxisPos = [[0.0] * 4 for _ in range(4)]
10offset = [0.0, 2.0, 30.0, -2.0, 0.0, 0.0]
11mainPoint[0] = [490.004, -383.194, 402.735, -9.332, -1.528, 69.594]
12mainPoint[1] = [444.950, -407.117, 389.011, -5.546, -2.196, 65.279]
13mainPoint[2] = [445.168, -463.605, 355.759, -1.544, -10.886, 57.104]
14mainPoint[3] = [507.529, -485.385, 343.013, -0.786, -4.834, 61.799]
15mainPoint[4] = [554.390, -442.647, 367.701, -4.761, -10.181, 64.925]
16mainPoint[5] = [532.552, -394.003, 396.467, -13.732, -13.592, 67.411]
17mainExaxisPos[0] = [-29.996, 0.000, 0.000, 0.000]
18mainExaxisPos[1] = [-29.996, 0.000, 0.000, 0.000]
19mainExaxisPos[2] = [-29.996, 0.000, 0.000, 0.000]
20mainExaxisPos[3] = [-29.996, 0.000, 0.000, 0.000]
21mainExaxisPos[4] = [-29.996, 0.000, 0.000, 0.000]
22mainExaxisPos[5] = [-29.996, 0.000, 0.000, 0.000]
23piecePoint[0] = [505.571, -192.408, 316.759, 38.098, 37.051, 139.447]
24piecePoint[1] = [533.837, -201.558, 332.340, 34.644, 42.339, 137.748]
25piecePoint[2] = [530.386, -225.085, 373.808, 35.431, 45.111, 137.560]
26piecePoint[3] = [485.646, -229.195, 383.778, 33.870, 45.173, 137.064]
27piecePoint[4] = [460.551, -212.161, 354.256, 28.856, 45.602, 135.930]
28piecePoint[5] = [474.217, -197.124, 324.611, 42.469, 41.133, 148.167]
29pieceExaxisPos[0] = [-29.996, -0.000, 0.000, 0.000]
30pieceExaxisPos[1] = [-29.996, -0.000, 0.000, 0.000]
31pieceExaxisPos[2] = [-29.996, -0.000, 0.000, 0.000]
32pieceExaxisPos[3] = [-29.996, -0.000, 0.000, 0.000]
33pieceExaxisPos[4] = [-29.996, -0.000, 0.000, 0.000]
34pieceExaxisPos[5] = [-29.996, -0.000, 0.000, 0.000]
35exaxisPos[0] = [-29.996, -0.000, 0.000, 0.000]
36exaxisPos[1] = [-44.994, 90.000, 0.000, 0.000]
37exaxisPos[2] = [-59.992, 0.002, 0.000, 0.000]
38exaxisPos[3] = [-44.994, -89.997, 0.000, 0.000]
39tool = 2
40wobj = 0
41vel = 100.0
42acc = 100.0
43ovl = 12.0
44oacc = 12.0
45moveType = 1
46moveDirection = 1
47rtn = robot.MoveToIntersectLineStart(mainPoint=mainPoint, mainExaxisPos=mainExaxisPos, piecePoint=piecePoint, pieceExaxisPos=pieceExaxisPos, extAxisFlag=extAxisFlag, exaxisPos=exaxisPos[0], tool=tool, wobj=wobj, vel=vel, acc=acc, ovl=ovl, oacc=oacc, moveType=moveType, moveDirection=moveDirection, offset=offset)
48print(f"MoveToIntersectLineStart rtn is {rtn}")
49rtn = robot.MoveIntersectLine(mainPoint=mainPoint, mainExaxisPos=mainExaxisPos, piecePoint=piecePoint, pieceExaxisPos=pieceExaxisPos, extAxisFlag=extAxisFlag, exaxisPos=exaxisPos, tool=tool, wobj=wobj, vel=vel, acc=acc, ovl=5.0, oacc=5.0, moveDirection=moveDirection, offset=offset)
50print(f"MoveIntersectLine rtn is {rtn}")
51robot.CloseRPC()

4.63. Movimento Estacionário no Local

Protótipo

MoveStationary()

Descrição

Movimento estacionário no local

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

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

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4rtn = robot.LaserSensorRecordandReplay(0, 10, 1, 0, 0.1, 1, 0, 10, 100)
 5print(f"LaserSensorRecordandReplay rtn is {rtn}")
 6rtn = robot.MoveStationary()
 7print(f"MoveStationary rtn is {rtn}")
 8rtn = robot.LaserSensorRecord1(0, 10)
 9print(f"LaserSensorRecordandReplay rtn is {rtn}")
10robot.CloseRPC()
11return 0

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

Protótipo

OriginPointWeaveStart(weaveNum, mode, refPoint, weaveTime)

Descrição

Início da oscilação em ponto fixo

Parâmetros obrigatórios

  • weaveNum: Número da oscilação [0-7]

  • mode: 0-sistema de coordenadas da ferramenta; 1-ponto de referência

  • refPoint: Coordenadas cartesianas do ponto de referência [x, y, z, a, b, c]

  • weaveTime: Tempo de oscilação [s]

Parâmetros padrão

Nenhum

Valor de retorno

Código de erro: sucesso-0, falha-código de erro

4.66. Fim da Oscilação em Ponto Fixo

Protótipo

OriginPointWeaveEnd()

Descrição

Fim da oscilação em ponto fixo

Parâmetros obrigatórios

Nenhum

Parâmetros padrão

Nenhum

Valor de retorno

  • Código de erro: sucesso-0, falha-código de erro

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

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Estabelece conexão com o controlador do robô
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestOriginPointWeave(self):
 9    time.sleep(2)
10    # Inicializar posição articular, eixo externo e deslocamento
11    j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842]
12    epos = [0, 0, 0, 0]
13    offset_pos = [0, 0, 0, 0, 0, 0]
14
15    # Posição do ponto de referência [x, y, z, rx, ry, rz]
16    refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956]
17
18    # Mover para posição inicial
19    robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100,
20                exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
21
22    # Primeira oscilação: sistema de coordenadas absoluto (tool=0), modo 0
23    robot.OriginPointWeaveStart(0, 0, refPoint, 3)
24    robot.MoveStationary()
25    robot.OriginPointWeaveEnd()
26
27    time.sleep(2)
28
29    # Mover novamente para posição inicial
30    robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100,
31                exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
32
33    # Segunda oscilação: sistema de coordenadas absoluto (tool=0), modo 1
34    robot.OriginPointWeaveStart(0, 1, refPoint, 3)
35    robot.MoveStationary()
36    robot.OriginPointWeaveEnd()
37
38    # Fechar conexão
39    robot.CloseRPC()
40    time.sleep(1)
41
42TestOriginPointWeave(robot)

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

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Estabelece conexão com o controlador do robô
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestOriginPointWeave(self):
 9    time.sleep(2)
10    # Inicializar posição articular, eixo externo e deslocamento
11    j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842]
12    epos1 = [0, 0, 0, 0]
13    offset_pos = [0, 0, 0, 0, 0, 0]
14    epos2 = [5, 0.000, 0.000, 0.000]
15    # Posição do ponto de referência [x, y, z, rx, ry, rz]
16    refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956]
17
18    rtn = 0
19    robot.LaserTrackingSensorConfig("192.168.58.20", 5020)
20    robot.LaserTrackingSensorSamplePeriod(20)
21    robot.LoadPosSensorDriver(101)
22
23    # Carregar driver UDP
24    robot.ExtDevLoadUDPDriver()
25
26    # Definir tempo de conclusão do comando do eixo externo
27    rtn = robot.SetExAxisCmdDoneTime(5000.0)
28    print(f"SetExAxisCmdDoneTime rtn is {rtn}")
29
30    # Habilitar eixos externos 1 e 2
31    rtn = robot.ExtAxisServoOn(1, 1)
32    print(f"ExtAxisServoOn axis id 1 rtn is {rtn}")
33    rtn = robot.ExtAxisServoOn(2, 1)
34    print(f"ExtAxisServoOn axis id 2 rtn is {rtn}")
35    time.sleep(2)
36
37    # Definir retorno à origem do eixo externo
38    robot.ExtAxisSetHoming(1, 0, 10, 2)
39    robot.LaserTrackingLaserOnOff(1)
40
41    # 1---sem eixo estendido
42    robot.LaserTrackingTrackOnOff(1, 4)
43    time.sleep(0.2)
44    # Iniciar oscilação em ponto fixo
45    robot.OriginPointWeaveStart(0, 0, refPoint, 10)
46    robot.MoveStationary()  # Executar movimento fixo
47    robot.OriginPointWeaveEnd()
48    robot.LaserTrackingTrackOnOff(0, 4)
49
50    time.sleep(2)  # Aguardar 2 segundos
51
52    # 2----com eixo estendido
53    robot.ExtAxisMove(epos1, 100, -1)
54    robot.LaserTrackingTrackOnOff(1, 4)
55    # Iniciar oscilação em ponto fixo
56    robot.OriginPointWeaveStart(0, 0, refPoint, 20)
57    robot.ExtAxisMove(epos2, 100, -1)
58    robot.OriginPointWeaveEnd()
59    robot.LaserTrackingTrackOnOff(0, 4)
60
61    # Fechar conexão
62    robot.CloseRPC()
63    time.sleep(1)
64
65TestOriginPointWeave(robot)

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

Protótipo

ServoJV(self, joint_vel, exis_vel, acc=0.0, vel=0.0, cmdT=0.008, filterT=0.0, gain=0.0, id=0, comType=0)

Descrição

Movimento em modo servo de velocidade no espaço das juntas

Parâmetros Obrigatórios

  • joint_vel: 6 velocidades alvo das juntas, unidade deg/s

  • exis_vel: 4 velocidades dos eixos externos, unidade deg/s

  • acc: Percentual de aceleração, intervalo [0~100], ainda não aberto, padrão 0

  • vel: Percentual de velocidade, intervalo [0~100], ainda não aberto, padrão 0

  • cmdT: Período do ciclo de comando, unidade s, intervalo recomendado [0.001~0.0016]

  • filterT: Tempo de filtro, unidade s, ainda não aberto, padrão 0

  • gain: Ganho proporcional para posição alvo, ainda não aberto, padrão 0

  • id: ID do comando servoJ, padrão 0

  • comType: Tipo de comando; 0-xmlrpc; 1-UDP (correspondente à porta 20007 do robô)

Parâmetros Padrão

Nenhum

Valor de Retorno

Código de erro Sucesso-0 Falha- errcode

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

 1from fairino import Robot
 2import time
 3
 4def main():
 5    # Estabelecer conexão com o controlador do robô
 6    robot = Robot.RPC('192.168.58.2')
 7    time.sleep(0.5)  # Aguardar conexão e recebimento de dados
 8
 9    # Inicializar array de velocidade das juntas e array de velocidade dos eixos externos
10    joint_vel = [10.0, 0.0, 0.0, 0.0, 0.0, 0.0]
11    exis_vel = [0.0, 0.0, 0.0, 0.0]
12    acc = 0.0
13    vel = 0.0
14    cmdT = 0.008
15    filterT = 0.0
16    gain = 0.0
17    cnt = 0
18
19    # Chamar ServoJV em loop, total de 200 vezes
20    while cnt < 200:
21        rtn = robot.ServoJV(joint_vel=joint_vel, exis_vel=exis_vel, acc=acc, vel=vel,
22                            cmdT=cmdT, filterT=filterT, gain=gain)
23        print(f"ServoJV rtn is {rtn}")
24        cnt += 1
25
26    # Fechar conexão
27    robot.CloseRPC()
28
29
30# Chamar função de teste
31main()

4.71. Início do Controle MIT das Juntas

Protótipo

ServoMITStart(self, comType=0)

Descrição

Início do controle MIT das juntas

Parâmetros Obrigatórios

  • comType: Tipo de comando; 0-xmlrpc; 1-UDP (correspondente à porta 20007 do robô)

Parâmetros Padrão

Nenhum

Valor de Retorno

Código de erro Sucesso-0 Falha- errcode

4.72. Fim do Controle MIT das Juntas

Protótipo

ServoMITEnd(self, comType=0)

Descrição

Fim do controle MIT das juntas

Parâmetros Obrigatórios

  • comType: Tipo de comando; 0-xmlrpc; 1-UDP (correspondente à porta 20007 do robô)

Parâmetros Padrão

Nenhum

Valor de Retorno

Código de erro Sucesso-0 Falha- errcode

4.73. Controle MIT das Juntas

Protótipo

ServoMIT(self, posGain, desPos, velGain, desVel, torque_ff, interval, comType=0)

Descrição

Controle MIT das juntas

Parâmetros Obrigatórios

  • posGain: Ganhos de posição das juntas j1~j6

  • desPos: Posições desejadas das juntas j1~j6, unidade: deg

  • velGain: Ganhos de velocidade das juntas j1~j6

  • desVel: Velocidades desejadas das juntas j1~j6, unidade: deg/s

  • torque_ff: Torques feedforward j1~j6, unidade: Nm

  • interval: Período do ciclo de comando, unidade s, intervalo [0.001~0.008]

  • comType: Tipo de comando; 0-xmlrpc; 1-UDP (correspondente à porta 20007 do robô)

Parâmetros Padrão

Nenhum

Valor de Retorno

Código de erro Sucesso-0 Falha- errcode

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

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Estabelecer conexão com o controlador do robô
 6robot = Robot.RPC('192.168.58.2')
 7
 8# Definir função de callback
 9def udp_frame_callback(src_type, count, cmd_id, data_len, content):
10    """Função de callback de resposta de comando UDP"""
11    print(f"Callback: cmd_id={cmd_id} count={count} data_len={data_len} content={content}")
12    return 0
13
14def ServoMITtest(self):
15    # Definir callback de resposta de comando UDP
16    robot.SetUDPCmdRpyCallback(udp_frame_callback)
17
18    while True:
19        # Resetar todos os erros
20        robot.ResetAllError()
21        time.sleep(0.5)
22
23        # Inicializar arrays de parâmetros
24        posGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
25        desPos = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
26        velGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
27        desVel = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
28        torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
29
30        # Obter torques das juntas
31        rtn, torques = robot.GetJointTorques(flag=1)
32        print(f"GetJointTorques rtn: {rtn}")
33        print("111111")
34
35        # Iniciar modo Servo MIT
36        rtn = robot.ServoMITStart(0)
37        print(f"ServoMITStart rtn: {rtn}")
38
39        # Ativar drag teaching
40        rtn = robot.DragTeachSwitch(1)
41        print(f"DragTeachSwitch rtn: {rtn}")
42
43        intev = 0.008
44
45        # Movimento para frente: torque positivo no eixo 6 até o ângulo ultrapassar 30 graus
46        while True:
47            torques[5] = 0.03
48            rtn = robot.ServoMIT(posGain, desPos, velGain,
49                                desVel, torques, intev, comType=0)
50            print(f"ServoMIT call rtn is {rtn}")
51            time.sleep(0.001)  # 1ms
52
53            rtn, pkg = robot.GetRobotRealTimeState()
54            print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}")
55
56            if pkg.jt_cur_pos[5] > 30:
57                break
58
59        # Movimento reverso: torque negativo no eixo 6 até o ângulo ser menor que 0 graus
60        while True:
61            torques[5] = -0.03
62            rtn = robot.ServoMIT(posGain, desPos, velGain,
63                                desVel, torques, intev, comType=0)
64            print(f"ServoMIT call rtn is {rtn}")
65            time.sleep(0.001)  # 1ms
66
67            rtn, pkg = robot.GetRobotRealTimeState()
68            print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}")
69
70            if pkg.jt_cur_pos[5] < 0:
71                break
72
73        # Desativar drag teaching
74        rtn = robot.DragTeachSwitch(0)
75        print(f"DragTeachSwitch off rtn: {rtn}")
76
77        # Encerrar modo Servo MIT
78        rtn = robot.ServoMITEnd(0)
79        print(f"ServoMITEnd rtn: {rtn}")
80
81# Chamar função de teste
82ServoMITtest(robot)