Modulo 2.8 - Como Programar Robos: do Teach Pendant ao Codigo

Diagrama ilustrativo: cada degrau sobe em poder e complexidade — do teach pendant (sem codigo) ate a linguagem natural com VLA.

🕹️ Teach Pendant e Lead-Through

O metodo dominante hoje nao usa uma linha de codigo. No teach pendant, voce navega num console portatil para mover o braco e gravar posicoes. No lead-through (hand-guiding), voce simplesmente segura o braco com a mao e o guia pela trajetoria, gravando cada pose. E a base dos cobots (UR, FANUC CRX) e a porta de entrada de quem nunca programou.

📍 Como o robo "aprende" uma rotina

Programar por teach pendant e gravar uma sequencia de waypoints (pontos de passagem). Cada waypoint e uma pose — posicao mais orientacao do efetuador — relativa a um frame (base ou tool).

•Jog manual: mover o braco eixo a eixo (ou no espaco cartesiano) pelo console.
•Gravar waypoint: salvar a pose atual como ponto da trajetoria.
•Velocidade e aceleracao: ajustar o quao rapido o robo vai entre pontos.

📊 Por que comeca aqui

Metodo dominante - a maioria das celulas de cobot em chao de fabrica e programada assim.
Zero codigo - operador aprende em horas, nao meses; ideal para tarefas repetitivas.
Cobots UR e FANUC CRX - lead-through nativo: pressiona um botao e guia o braco com a mao.

💡 Dica Pratica

Antes de gravar waypoints, defina bem os frames base/tool. Um frame de ferramenta errado faz o robo "pensar" que a garra esta em outro lugar — e toda a trajetoria sai deslocada. Dominar frames e o primeiro salto de qualidade de quem programa por teach pendant.

Conceitos-chave

Waypoints

Pontos da trajetoria

Pose / frames

Base e tool

Jog manual

Mover pelo console

Lead-through

Guiar com a mao

🧱 No-Code e Blocos / Fluxo

O segundo degrau adiciona logica sem escrever texto. Interfaces visuais — blocos tipo Blockly, fluxogramas e o PolyScope da UR com drag-and-drop — deixam voce montar condicionais, loops e esperas arrastando pecas. Isso democratiza: quem domina teach pendant passa a programar comportamento, nao so trajetorias.

Programa visual (ilustrativo)

▸ Programa
  ┌ Loop (sempre)
  │   ◆ Se sensor_peca == verdadeiro
  │       → MoveJ  waypoint_pegar
  │       → Garra  fechar
  │       → MoveL  waypoint_soltar
  │       → Garra  abrir
  │   ◆ Senao
  │       → Esperar  0.5 s
  └ Fim Loop

✓ Quando usar NO-CODE

✓Tarefa repetitiva com poucas variacoes (pick-and-place)
✓Equipe sem programadores; operadores montam a rotina
✓Logica simples: if por sensor, loop, wait, templates prontos
✓Prototipo rapido na celula, sem ciclo de build

✗ Quando o NO-CODE trava

✗Logica complexa com muitos ramos e estados
✗Integrar visao computacional ou IA externa
✗Reuso entre robos de fabricantes diferentes
✗Versionar e testar codigo como software de verdade

Conceitos-chave

Blocos if/loop

Logica arrastavel

Nos de acao

Mover, garra, wait

Condicional

If por sensor

Templates

Reuso de rotinas

🐍 Python e a Fronteira do Codigo

Python e a linguagem mais usada em robotica e IA. Com ela voce controla cobots via SDK (ex.: ur_rtde), processa visao computacional e integra modelos de IA. Sair do no-code para o codigo abre tarefas complexas que blocos nao alcancam — e, na pratica, abre salarios melhores.

controle_cobot.py (ilustrativo)

# Mover um cobot UR e acionar a garra (ilustrativo)
from rtde_control import RTDEControlInterface as RTDEControl
robo = RTDEControl("192.168.0.10")
pose = [-0.14, -0.40, 0.20, 0, 3.14, 0]   # x, y, z + rotacao
robo.moveL(pose, speed=0.25, acceleration=0.5)
robo.setStandardDigitalOut(0, True)         # fecha a garra

📈 O que o codigo destrava

Loop de controle - ler sensores e reagir em tempo real, alem do que blocos permitem.
Visao computacional - localizar pecas com camera e calcular a pose de pegada na hora.
Scripts reutilizaveis - versionar, testar e reaproveitar codigo entre projetos.

💡 Dica Pratica

Voce nao precisa abandonar o teach pendant para aprender Python. Comece grava a trajetoria no console, exporte as poses, e use o SDK so para a parte que blocos nao fazem (visao, decisao, integracao). Esse "hibrido" e o caminho real de quem migra de operador para tecnico.

Conceitos-chave

SDK

ur_rtde, fabricante

Loop de controle

Ler e reagir

Visao

Camera + pose

Scripts

Reutilizaveis

🤖 ROS 2: o Middleware Padrao

Apesar do nome, ROS 2 nao e um sistema operacional de verdade — e um middleware: uma camada que conecta as partes de um robo. Programas viram nos que conversam por topicos (publish/subscribe), mensagens e servicos. AMRs, humanoides e a pesquisa academica rodam ROS 2.

🧩 O ecossistema que vem junto

A forca do ROS 2 nao e so a comunicacao: e a pilha de ferramentas maduras que voce reusa em vez de reescrever.

•Nav2: navegacao autonoma para robos moveis (AMRs).
•MoveIt 2: planejamento de movimento e manipulacao de bracos.
•Gazebo: simulacao fisica para testar antes do hardware real.

no ROS 2 publicando um topico (ilustrativo)

import rclpy
from geometry_msgs.msg import Twist

no = rclpy.create_node("motorista")
pub = no.create_publisher(Twist, "/cmd_vel", 10)
cmd = Twist()
cmd.linear.x = 0.2     # anda pra frente
pub.publish(cmd)         # publica no topico /cmd_vel

💡 Dica Pratica

Voce nao precisa de um robo fisico para aprender ROS 2: o Gazebo simula a fisica e os sensores. Boa parte dos engenheiros de robotica comeca publicando topicos num robo virtual antes de tocar em hardware caro — erre na simulacao, nao na celula de producao.

Conceitos-chave

Nos / topicos

Publish/subscribe

Mensagens

Servicos e dados

Nav2 / MoveIt 2

Navegacao e bracos

Gazebo

Simulacao fisica

🗣️ Programar por Linguagem Natural

A nova fronteira: voce descreve a tarefa em portugues e o robo gera e executa a rotina. Liga direto ao modulo 2.7 (VLA). No paradigma "code-as-policies", um LLM escreve o codigo de controle e o humano revisa antes de rodar. A skill deixa de ser "digitar codigo" e passa a ser "especificar bem a tarefa e revisar o que a IA gerou".

✨ Como funciona o code-as-policies

Voce escreve um prompt de tarefa ("separe as pecas vermelhas da esteira"). O LLM gera o codigo que aciona o robo; voce revisa e aprova. A IA acelera, mas a responsabilidade pela seguranca continua humana.

•Prompt de tarefa: descrever o objetivo, nao os passos.
•VLA: modelos visao-linguagem-acao que ligam percepcao a movimento.
•Revisao humana: aprovar o codigo antes de ele tocar o hardware.

🚫 Atencao: seguranca do codigo autogerado

Codigo gerado por LLM pode estar sintaticamente perfeito e ainda assim mandar o braco para uma colisao. Nunca rode codigo autogerado direto em producao: valide em simulacao, limite velocidade/forca e mantenha o operador no loop. A IA escreve rapido, mas nao responde por um acidente — voce responde.

Conceitos-chave

Code-as-policies

LLM escreve controle

Prompt de tarefa

Objetivo em texto

VLA

Visao-linguagem-acao

Revisao humana

Seguranca no loop

🧭 Que Caminho Seguir

Nao existe "o jeito certo" — existe o degrau certo para o seu perfil. A rota e progressiva: cada nivel abre um patamar salarial e se liga as certificacoes do modulo 3.4. O segredo nao e pular degraus, e subir um de cada vez construindo um portfolio de projetos.

Operador: teach pendant → no-code

Do braco guiado a logica em blocos

Comece dominando lead-through e waypoints; depois suba para no-code (PolyScope, blocos) para programar condicionais e loops. Aqui voce ja entrega celulas inteiras sem escrever codigo.

Tecnico: no-code → Python

O salto para o codigo

Quem ja monta logica em blocos aprende Python e SDKs (ur_rtde) para integrar visao e decisao. E o degrau onde o salario mais sobe, porque destrava tarefas que no-code nao alcanca.

Engenheiro: Python → ROS 2 → VLA

Topo da escada

Com Python solido, avance para ROS 2 (sistemas complexos, AMRs, humanoides) e para a fronteira VLA / linguagem natural. Aprendizado continuo: a fronteira de hoje vira o padrao de amanha.

✓ Como subir a escada

✓Dominar um degrau antes de avancar para o proximo
✓Construir portfolio de projetos reais em cada nivel
✓Ligar a aprendizagem a certificacoes (modulo 3.4)
✓Manter aprendizado continuo: a fronteira se move

✗ Erros de quem se perde

✗Pular para ROS 2 sem base de Python
✗Achar que no-code "nao conta" como skill — conta, e muito
✗Estudar so teoria, sem entregar projeto nenhum
✗Parar de aprender ao chegar num degrau confortavel

💡 Dica Pratica

Identifique seu degrau atual com honestidade e mire o degrau imediatamente acima — nao o topo. Um operador que aprende no-code vale mais que um operador parado; um tecnico que aprende Python vale mais que um tecnico de blocos. A escada paga em cada passo, nao so no fim.

Conceitos-chave

Trilha por perfil

Operador a engenheiro

Do simples ao complexo

Um degrau por vez

Portfolio

Projetos reais

Aprendizado continuo

A fronteira se move

🏁 Resumo do Modulo

✓

Teach pendant e lead-through - metodo dominante e sem codigo: grava waypoints e poses guiando o braco; base dos cobots UR e FANUC CRX.

✓

No-code e blocos - logica visual (Blockly, PolyScope) com if/loop/wait; democratiza, mas trava em complexidade e integracao.

✓

Python - SDK (ur_rtde), loop de controle, visao e IA; o salto que destrava tarefas complexas e salarios melhores.

✓

ROS 2 - middleware com nos, topicos e mensagens; Nav2, MoveIt 2 e Gazebo movem AMRs, humanoides e pesquisa.

✓

Linguagem natural / VLA - code-as-policies: descrever a tarefa, a IA gera o codigo, o humano revisa. Seguranca continua humana.

✓

Rota por perfil - operador, tecnico, engenheiro: cada degrau paga e liga as certificacoes do modulo 3.4.

Proxima Trilha:

Trilha 3 - Estrategico: como liderar a transicao robotica no nivel organizacional, do piloto a escala.

← Voltar para Trilha Proxima Trilha →