GOVERNADOR DO ESTADO DO PARANÁ

Carlos Massa Ratinho Júnior

SECRETÁRIO DE ESTADO DA EDUCAÇÃO

Renato Feder

DIRETOR DE TECNOLOGIA E INOVAÇÃO

Andre Gustavo Souza Garbosa

COORDENADOR DE TECNOLOGIAS EDUCACIONAIS

Marcelo Gasparin

Produção de Conteúdo
Cleiton Rosa
Simone Sinara de Souza

Validação de Conteúdo
Cleiton Rosa

Revisão Textual
Adilson Carlos Batista

Leitura Crítica e Normalização Bibliográfica

Ricardo Hasper

Projeto Gráfico e Diagramação

Edna do Rocio Becker

Fotografia
Darice Alessandra Deckmann Zanardini
Stella Maris Oliveira Ludwig (Educa Play)

Ilustração
Jocelin Vianna (Educa Play)

2021
Sumário
1. INTRODUÇÃO .................................................................01

2. MONTAGEM DO BRAÇO ROBÓTICO............................02

2.1 MONTAGEM............................................................03
2.2 PROGRAMANDO O BRAÇO ROBÓTICO..................08
2.2.1 Linguagem de programação por codificação.........08
2.2.2 Linguagem de programação por blocos................15

3. VIDEOTUTORIAL ..........................................................22

4. REFERÊNCIAS................................................................23
 Braço Robótico

1. INTRODUÇÃO
Você já parou para pensar
quantos movimentos e ações
realizamos com os braços? Como isso
é possível? Para responder a estas
questões, vamos recordar a anatomia
do corpo humano.
Nosso corpo é dividido em
cabeça, tronco, membros superiores e
membros inferiores. O membro superior
é formado pela cintura escapular (ossos
da escápula e clavícula), braço (osso
úmero), antebraço (ossos ulna e rádio)
e ossos da mão (carpo, metacarpo Fonte: SEED/DTI/CTE
e falanges). As uniões entre os ossos
formam as articulações: ombro, cotovelo e pulso. Tanto os ossos quanto as articulações
do membro superior são revestidas por músculos e tendões que dão sustentação e força,
permitindo diferentes movimentos como dobrar, girar, balançar para trás e para a frente
e mover-se de um lado para o outro.
No dia a dia, realizamos inúmeras ações nas quais, muitas vezes, desejamos ter mais
do que dois braços para efetuá-las. Sabia que isso já é possível? Inovações tecnológicas
vêm aperfeiçoando diferentes áreas do conhecimento, em destaque a área da robótica, a
qual tem possibilitado a otimização de tarefas através da criação de robôs manipuladores
multifuncionais reprogramáveis usados para a realização de tarefas consideradas
difíceis, arriscadas e até mesmo impossíveis para a espécie humana. Podemos citar como
exemplo deste equipamento tecnológico o braço robótico, capaz de realizar movimentos
simples, porém extremamente importantes, como mover objetos, escrever, servir bebidas,
manipular pequenas peças com precisão ou mesmo fazer impressões 3D.
Outra empregabilidade do braço robótico é na medicina para proporcionar a
retomada de movimentos antes comprometidos, bem como a reabilitação da sensação
do toque em pessoas cuja mobilidade é quase inexistente.
Este projeto tem o intuito de demonstrar como funciona um braço robótico. Para
tanto, apresentamos um modelo constituído por material MDF, componentes eletrônicos
e a programação do funcionamento deste, na linguagem escrita e em blocos, além de
videotutorial para a montagem e funcionamento do braço robótico na escola.

1
 Braço Robótico

2. MONTAGEM DO BRAÇO ROBÓTICO

Para a confecção e funcionamento do braço robótico, utilizamos os materiais
demonstrados no quadro 1.

Quadro 1 – Materiais para confecção do braço robótico

01 Placa Protoboard 01 Arduino Uno R3

01 Cabo USB 14 Jumpers Macho-Macho

04 Servos 01 Joystick Shield DIY para Arduino

01 Kit Braço MDF 01 Computador

Software IDE Arduino ou Software mBlock

Fonte: SEED/DTI/CTE

2
 Braço Robótico

Atenção!
Antes de iniciar a montagem do braço robótico, é necessário calibrar
os Servos Motores conforme as instruções do vídeo abaixo:

https://rebrand.ly/calibragemServoMotor

2.1 MONTAGEM
Iniciamos a confecção do braço robótico com a montagem dos
componentes eletrônicos. Para tal, utilizamos a matriz de contato Protoboard,
que é uma placa de prototipagem eletrônica com orifícios e conexões
condutoras, que permite montar circuitos eletrônicos sem haver a necessidade
de soldar os componentes na placa.
A Protoboard é composta por faixas terminais e faixas de barramento.
Cada faixa terminal possui cinco pontos conectados por um condutor metálico
e representados por letras do alfabeto; já as faixas de barramento possuem,
geralmente, uma faixa azul, que serve como sinal de alimentação negativa
do circuito eletrônico, e uma de cor vermelha, como sinal de alimentação
positiva, conforme mostra a figura 1.

Figura 1 – Placa Protoboard

Fonte: SEED/DTI/CTE

3
 Braço Robótico

Para o controle e o funciona- Figura 2 – Placa Arduino Uno R3

mento dos componentes eletrôni-
cos que serão inseridos na placa
Protoboard, utilizamos a placa Ar-
duino Uno R3. Esta placa micro-
controladora facilita a programa-
ção de circuitos eletrônicos, pois
possui saídas analógicas e digitais,
e conexões feitas através de encai-
xes, não havendo a necessidade de
soldar os componentes na placa.
Além disso, é de fácil conexão com
computadores por meio de comu-
Fonte: SEED/DTI/CTE
nicação USB (figura 2).

A conexão da placa Arduino com a placa Protoboard é feita por meio de

Jumpers, que são cabos condutores utilizados para conectar dois pontos de
um circuito eletrônico. Existem dois tipos de Jumpers: o Macho, que possui um
conector para ser utilizado na Protoboard; e a Fêmea, que possui um orifício
que pode ser conectado a um componente eletrônico ou Jumper Macho. Há,
ainda, três variedades de Jumpers: Jumper Macho-Macho, que apresenta
as extremidades com conectores; Jumper Macho-Fêmea, que possui uma
extremidade contendo conector e outra extremidade com orifício; e Jumper
Fêmea-Fêmea, cujas extremidades são formadas por orifícios, conforme
mostra a figura 3.
Figura 3 – Variedades de Jumpers

Jumper Macho - Macho Jumper Fêmea - Fêmea Jumper Macho - Fêmea

Fonte: SEED/DTI/CTE

4
 Braço Robótico

Para controlar os movimentos do braço robótico em seus diferentes eixos

e sua garra, utilizamos quatro Servos Motores. O Servo é um dispositivo de
malha fechada que apresenta movimento proporcional a um comando, ou
seja, ao receber um sinal de controle, verifica a posição atual e se movimenta
para a posição desejada com velocidade monitorada. Sua estrutura possui os
seguintes componentes: engrenagens, circuito de controle (responsável pelo
monitoramento do potenciômetro e acionamento do motor), potenciômetro,
motor e caixa do Servo, além de três fios: marrom (GND) e vermelho (5V)
que levam energia elétrica para o motor, e amarelo que recebe os comandos
do Arduino (figura 4).

Figura 4 – Servo Motor e seus componentes internos

Para realizar o controle dos Servos, acoplamos sobre a placa Arduino

uma placa Joystick Shield para Arduino. Esta placa possui 4 chaves botão de
pressão (push button), instaladas no formato de cruz, duas chaves botão de
pressão pequenas de seleção e um sistema de alavanca analógico, formado
por dois potenciômetros, com diversos movimentos. Há, ainda, uma chave
que possibilita escolher a tensão de alimentação do Shield, podendo optar
entre 3,3 V ou 5 V, permitindo a utilização em outros microcontroladores. É
utilizada para aumentar a capacidade do Arduino e expandir o número de
portas de entrada e saída (figura 5).

5
 Braço Robótico

Figura 5
Placa Joystick Shield para Arduino

Fonte: SEED/DTI/CTE

Conecte um Jumper Macho-Macho entre a porta GND do Arduino e

a linha azul da Protoboard. Na sequência, conecte outro Jumper Macho-
Macho entre a porta 5V do Arduino e a linha vermelha da Protoboard, como
mostra a figura 6.
Figura 6 - Ligação de Jumpers Macho-Macho a placa Protoboard e Arduino

6
 Braço Robótico

A última etapa da montagem dos componentes eletrônicos é a conexão

dos Servos, através de 12 Jumpers, às placas Arduino e Protoboard. Para tanto,
ligamos três Jumpers aos terminais de cada Servo. Os Jumpers conectados
aos terminais marrons são ligados às linhas azuis da Protoboard, enquanto
os Jumpers inseridos nos terminais vermelhos dos Servos são conectados
às linhas vermelhas da Protoboard. O terceiro Jumper conectado em cada
Servo é interligado, respectivamente, às portas digitais 9, 10, 11 e 12 do
Arduino, conforme demonstra a figura 7.
Figura 7 - Conexão dos Servos às placas Protoboard e Arduino

Finalizada a montagem dos componentes eletrônicos, o próximo passo

é programar o Arduino para a ativação dos movimentos do braço robótico.

7
 Braço Robótico

2.2 PROGRAMANDO O BRAÇO ROBÓTICO

Neste projeto, apresentamos duas formas de programar o funcionamento
do braço robótico: por meio da linguagem escrita (codificação) ou da
linguagem em blocos. Vamos conhecê-las.

2.2.1 Linguagem de programação por

codificação
Para iniciar a programação, conecte a placa Arduino ao computador,
através de um cabo USB, a fim de que ocorra a comunicação entre a placa
microcontroladora e a IDE de programação do Arduino, caso essa esteja
instalada em seu computador. Caso contrário, a comunicação poderá ser
feita via on-line, por meio do endereço eletrônico abaixo:

https://create.arduino.cc/editor

Fonte: SEED/DTI/CTE

8
 Braço Robótico

Na IDE de programação do Arduino, escreva ou copie e cole o código-

fonte de programação, conforme apresentado no quadro 2

Quadro 2 - Código-fonte da programação na linguagem do Arduino (Wiring)

/*******************************************************/
/* Projeto - Braço Robótico                            */
/* Programação do braço robótico com joystick shield.  */
/*******************************************************/

/* Inclui a biblioteca Servo.                          */

#include <Servo.h>
/* Declaração das variáveis.                           */
int btA = 2;
int btB = 3;
int btC = 4;
int btD = 5;
int potA0 = 0;
int potA1 = 0;
char escolha = "";
/* Definição dos ângulos iniciais dos servos.          */
int angBase = 90;
int angDir = 90;
int angEsq = 90;
int angGuarra = 90;
/* Declaração dos servos.                              */
Servo servo_9;
Servo servo_10;
Servo servo_11;
Servo servo_12;
void setup() {
 /* Configuração do modo de operação das portas para  */
 /* os botões (ENTRADA).                              */
 pinMode(btA, INPUT);
 pinMode(btB, INPUT);
 pinMode(btC, INPUT);
 pinMode(btD, INPUT);
 /* Configuração das portas de operação dos servos.   */
 servo_9.attach(9);
 servo_10.attach(10);
 servo_11.attach(11);
 servo_12.attach(12);

9
 Braço Robótico

 /* Define os ângulos inicias dos servos em 90°.      */

 servo_9.write(90);
 servo_10.write(90);
 servo_11.write(90);
 servo_12.write(90);
}
void loop() {
 /* Coleta os valores analógicos dos potenciômetros.  */
 potA0 = analogRead(A0);
 potA1 = analogRead(A1);
 /* Se for pressionado o botão A.                     */
 if (digitalRead(btA) == 0) {
   /* Defina a escolha como A.                        */
   escolha = 'A';
 }
 /* Se for pressionado o botão B.                     */
 if (digitalRead(btB) == 0) {
   /* Defina a escolha como B.                        */
   escolha = 'B';
 }
 /* Se for pressionado o botão C.                     */
 if (digitalRead(btC) == 0) {
   /* Defina a escolha como C.                        */
   escolha = 'C';
 }
 /* Se for pressionado o botão D.                     */
 if (digitalRead(btD) == 0) {
   /* Defina a escolha como D.                        */
   escolha = 'D';
 }
 /* Após um botão ser pressionado, entrará em um dos  */
 /* quatro modos de operação (A, B, C e D).           */
 switch (escolha) {
   /* Caso a escolha for A.                           */
   case 'A':
     /* Se o joystick for deslocado para a esquerda e */
     /* o ângulo do servo da garra for menor que 100°,*/
     /* abrirá a garra.                               */

10
 Braço Robótico

     if (potA0 > 700 && angGuarra < 100) {

       /* Posiciona o servo no ângulo atual.          */
       servo_12.write(angGuarra);
       /* Aumenta 1° no valor do ângulo atual.        */
       angGuarra = angGuarra + 1;
       /* Aguarda 50 milissegundos para atualizar o   */
       /* ângulo.                                     */
       delay(50);
     }
     /* Se o joystick for deslocado para a direita e o*/
     /* ângulo do servo da garra for maior que 60°,   */
     /* fechará a garra.                              */
     if (potA0 < 300 && angGuarra > 60) {
       /* Posiciona o servo no ângulo atual.          */
       servo_12.write(angGuarra);
       /* Diminui 1° no valor do ângulo atual.        */
       angGuarra = angGuarra - 1;
       /* Aguarda 50 milissegundos para atualizar o   */
       /* ângulo.                                     */
       delay(50);
     }
     /* Final desse caso.                             */
     break;
   /* Caso a escolha for B.                           */
   case 'B':
     /* Se o joystick for deslocado para a frente e o */
     /* ângulo do servo da direita for menor que 180°,*/
     /* abaixará o braço.                             */
     if (potA1 > 700 && angDir < 180) {
       /* Posiciona o servo no ângulo atual.          */
       servo_10.write(angDir);
       /* Aumenta 1° no valor do ângulo atual.        */
       angDir = angDir + 1;
       /* Aguarda 50 milissegundos para atualizar o   */
       /* ângulo.                                     */
       delay(50);
     }
     /* Se o joystick for deslocado para a trás e o   */
     /* ângulo do servo da direita for maior que 50º, */
     /* levantará o braço.                            */
     if (potA1 < 300 && angDir > 50) {
       /* Posiciona o servo no ângulo atual.          */
       servo_10.write(angDir);
       /* Diminui 1° no valor do ângulo atual.        */
       angDir = angDir - 1;

11
 Braço Robótico

       /* Aguarda 50 milissegundos para atualizar o   */

       /* ângulo.                                     */
       delay(50);
     }
     /* Final desse caso.                             */
     break;
   /* Caso a escolha for C.                           */
   case 'C':
     /* Se o joystick for deslocado para a direita e o*/
     /* ângulo do servo da base for menor que 180°, o */
     /* braço girará no sentido horário.              */
     if (potA0 < 300 && angBase < 180) {
       /* Posiciona o servo no ângulo atual.          */
       servo_9.write(angBase);
       /* Aumenta 1° no valor do ângulo atual.        */
       angBase = angBase + 1;
       /* Aguarda 50 milissegundos para atualizar o   */
       /* ângulo.                                     */
       delay(50);
     }
     /* Se o joystick for deslocado para a esquerda e */
     /* o ângulo do servo da base for maior que 0°, o */
     /* braço girará no sentido anti-horário.         */
     if (potA0 > 700 && angBase > 0) {
       /* Posiciona o servo no ângulo atual.          */
       servo_9.write(angBase);
       /* Diminui 1° no valor do ângulo atual.        */
       angBase = angBase - 1;
       /* Aguarda 50 milissegundos para atualizar o   */
       /* ângulo.                                     */
       delay(50);
     }
     /* Final desse caso.                             */
     break;
   /* Caso a escolha for D.                           */
   case 'D':
     /* Se o joystick for deslocado para a frente e o */
     /* ângulo do servo da esquerda for menor que 180°,*/
     /* levantará o antebraço.                         */
     if (potA1 > 700 && angEsq < 180) {
       /* Posiciona o servo no ângulo atual.          */
       servo_11.write(angEsq);
       /* Aumenta 1° no valor do ângulo atual.        */
       angEsq = angEsq + 1;

12
 Braço Robótico

       /* Aguarda 50 milissegundos para atualizar o   */

       /* ângulo.                                     */
       delay(50);
     }
     /* Se o joystick for deslocado para a trás e o   */
     /* ângulo do servo da esquerda for maior que 90°,*/
     /* abaixará o antebraço.                         */
     if (potA1 < 300 && angEsq > 90) {
       /* Posiciona o servo no ângulo atual.          */
       servo_11.write(angEsq);
       /* Diminui 1° no valor do ângulo atual.        */
       angEsq = angEsq - 1;
       /* Aguarda 50 milissegundos para atualizar o   */
       /* ângulo.                                     */
       delay(50);
     }
     /* Final desse caso.                             */
     break;
 }
}

A seguir, compile o programa pressionando o botão “Verificar” (botão

com sinal de tique) para verificar se não há erros de sintaxe. Estando o
código correto, o próximo passo é realizar a transferência do programa para
o Arduino. Pressione o botão “Carregar” (botão com uma seta apontando
para a direita), para realizar upload do programa para o Arduino, conforme
demostra a figura 10.

13
 Braço Robótico

Figura 10 – Compilando a programação em linguagem escrita

Após a transferência do programa para o Arduino, este ativa o Joystick,

informando ao Servo qual ângulo deve ocupar, formar ou ir. Cada Servo é
responsável por um movimento: para cima e para baixo; da esquerda para
direita; abertura e fechamento da garra; e rotação do pulso. A execução de
cada movimento é determinada pelo acionamento de cada chave botão de
pressão (formato de cruz) da placa Joystick Shield.

14
 Braço Robótico

2.2.2 Linguagem de programação em

blocos
Outra forma de programar o braço robótico é por meio da linguagem
de programação que utiliza blocos de funções prontas, os quais representam
comandos de programação. Neste projeto, utilizamos o software mBlock,
disponível no seguinte endereço eletrônico: https://ide.mblock.cc/, que
permite programar, arrastando e soltando blocos de construção (figura 11).
Este software também pode ser instalado no computador:

http://www.mblock.cc/en-us/download

Figura 11 – Layout do software mBlock

15
 Braço Robótico

Figura 12 – Selecionando a placa Arduino Uno

Para conectar o
mBlock ao Arduino, você
deve clicar no ícone
“Adicionar”, localizado
no campo “Dispositivos”
(figura 11), e selecionar o
Arduino, na biblioteca de
dispositivos do mBlock,
clicando, em seguida, no
botão “OK”, conforme
mostra a figura 12.

Figura 13 – Conectando Arduino Uno ao mBlock

Uma vez selecionado, o

Arduino Uno é visualizado no
campo “Dispositivos do mBlock” e
já é possível iniciar a programação
em blocos (figura 13).

Monte os blocos, arrastando e soltando, de acordo com a programação

de funcionamento do braço robótico, como mostra a figura 14.

16
 Braço Robótico

Figura 14 - Programação em blocos para funcionamento do braço robótico

17
 Braço Robótico

18
Braço Robótico

19
 Braço Robótico

Assim que os blocos estiverem montados, clique no botão “Conectar”

(figura 13) para transferir os comandos criados no mBlock para o Arduino
Uno. Caso você esteja utilizando o software mBlock na versão on-line, ao
clicar sobre o botão “Conectar”, aparecerá um Tooltip para que seja instalado
e ativado o driver, o controlador de dispositivo mLink, para o funcionamento
do mBlock Web (figura 15), permitindo, assim, a conexão entre os dois
dispositivos.
Figura 15 – Instalar dispositivo mBlock Web.

20
 Braço Robótico

Figura 16
Confirmar conexão entre mBlock e Arduino Uno

Por outro lado, se estiver utilizando a

versão mBlock instalada no computador, ao
clicar sobre o botão “Conectar” aparecerá
um Tooltip solicitando a confirmação
da conexão entre os dois dispositivos,
conforme mostra a figura 16.

Uma vez realizada a conexão entre os dispositivos, será ativado, na

interface do mBlock, o botão “Upload” o qual, ao ser clicado, carrega os
comandos criados no software para o Arduino Uno (figura 17).

Figura 17 - Botão de Upload e carregamento da programação em blocos

Com a transferência do código para o dispositivo Arduino Uno, inicia-

se o funcionamento do braço robótico.

21
 Braço Robótico

3. VIDEOTUTORIAL
Com o intuito de auxiliar na montagem e na programação do Braço
Robótico, apresentamos um videotutorial, disponível em:

https://rebrand.ly/p3robotica

Acesse, também, pelo QRCode:

22
 Braço Robótico

Desafio!
Agora é sua vez de mostrar o quanto aprendeu com este projeto!

Para aumentar o seu conhecimento em Programação Arduino, que

tal fazer esse braço, que está sendo controlado pelo Joystick Shield,
ficar autônomo?
Faça uma programação para que o braço pegue um objeto de um
lado da estrutura e o transporte para o outro lado, em um movimento
de 180 graus da base e fazendo movimentos suaves para que o
braço não derrube o objeto que está sendo transportado, nem no
momento de pegá-lo e nem no momento de soltá-lo.

Boa sorte com o desafio!

4 REFERÊNCIAS

ARDUINO. Ambiente de Programação do Arduino. Disponível em:

https://create.arduino.cc/editor Acesso em: 15 out. 2021.

BRASIL. Ministério da Educação. Base Nacional Comum Curricular. Brasília, 2018.

Disponível em:
http://basenacionalcomum.mec.gov.br/images/BNCC_EI_EF_110518_versaofinal_site.pdf
Acesso em: 08 out. 2021.

MAKEBLOCK. mBlock. Download mBlock. Disponível em: https://mblock.makeblock.com/

en-us/download/ Acesso em: 15 out. 2021.

MAKEBLOCK. mBlock. Programação em blocos. Disponível em: https://ide.mblock.cc/

Acesso em: 15 out. 2021.

23
 Braço Robótico

COORDENAÇÃO DE TECNOLOGIAS EDUCACIONAIS (CTE)

DIRETORIA DE TECNOLOGIAS E INOVAÇÃO (DTI)

EQUIPE ROBÓTICA PARANÁ

Adilson Carlos Batista
Cleiton Rosa
Darice Alessandra Deckmann Zanardini
Edna do Rocio Becker
Marcelo Gasparin
Michelle dos Santos
Ricardo Hasper
Simone Sinara de Souza

Os materiais, aulas e projetos da “Robótica Paraná”, foram produzidos pela

Coordenação de Tecnologias Educacionais (CTE), da Diretoria de Tecnologia e
Inovação (DTI), da Secretaria de Estado da Educação e do Esporte do Paraná (Seed),
com o objetivo de subsidiar as práticas docentes com os estudantes por meio da
Robótica.
Este material foi produzido para uso didático-pedagógico exclusivo em sala de aula.

Este trabalho está licenciado com uma Licença

Creative Commons – CC BY-NC-SA
Atribuição - NãoComercial - CompartilhaIgual 4.0

24
DTI - DIRETORIA DE TECNOLOGIA E INOVAÇÃO