🧠 Pensamento Computacional

🧩 PROJETO DE ROBÔ

Robô Otto Dançarino

👤 Equipe RoboFeed 📶 Intermediario ⏱ 3 a 5 aulas 6º ano7º ano8º ano9º ano1º ano (EM)2º ano (EM)3º ano (EM) ⚡ Plugada

🔧 Modo Bancada · passo a passo, pro aluno no tablet

🧭 Habilidades BNCC Computação (13)

🧠 Pensamento Computacional

EF67CO01 Aplicar técnicas de decomposição, abstração e reconhecimento de padrões na resolução de problemas computacionais e cotidianos.

EF67CO02 Elaborar e implementar algoritmos com estruturas de controle (sequência, seleção e repetição), utilizando variáveis e operadores lógicos.

EF67CO03 Representar dados e estados de um sistema usando fluxogramas, tabelas-verdade e diagramas de estado.

EF89CO01 Desenvolver projetos computacionais que integrem decomposição, abstração, generalização e avaliação crítica da solução proposta.

EF89CO02 Implementar algoritmos com funções/sub-rotinas, listas/arrays e leitura de sensores, em linguagens de blocos ou textuais (C++, Python).

💻 Mundo Digital

EF67CO04 Construir protótipos eletrônicos usando placas programáveis (Arduino, ESP32, micro:bit), sensores (ultrassônico, LDR, DHT) e atuadores (LED, servo, buzzer).

EF67CO05 Compreender como dados são representados no computador (binário, ASCII, imagem, áudio) e como circulam por redes (LAN, Wi-Fi, internet).

EF89CO03 Projetar e construir sistemas integrados que combinem hardware (placa, sensores, atuadores) e software (algoritmo) para resolver problemas reais.

EF89CO04 Avaliar arquiteturas de hardware (processador, memória, periféricos) e modelos de comunicação (cliente-servidor, IoT) em soluções tecnológicas.

🌐 Cultura Digital

EF67CO06 Analisar criticamente o uso das tecnologias digitais e sua influência no comportamento social, no consumo de informação e na privacidade.

EF67CO07 Identificar fontes confiáveis de informação em ambientes digitais, reconhecendo desinformação (fake news), deepfakes e manipulação algorítmica.

EF89CO05 Discutir aspectos éticos do uso de inteligência artificial (viés algorítmico, automação, direitos autorais, deepfakes) e propor princípios de uso responsável.

EF89CO06 Compreender legislações de proteção de dados (LGPD) e aplicar boas práticas de segurança digital, autoria e propriedade intelectual em produções escolares.

Habilidades dos anos selecionados (6º ano, 7º ano, 8º ano, 9º ano, 1º ano (EM), 2º ano (EM), 3º ano (EM)) — Resolução CNE/CP nº 1/2022. Em turmas de Ensino Médio, mapear para EM13CO.

🧰 Materiais e componentes

1×

Arduino Nano (placa controladora)

1×

🧰

Shield de expansão (Sparkfun Nano Shield)

4×

Micro servo SG90 (ou compatível)

1×

Sensor ultrassônico HC-SR04 (os olhos)

1×

Buzzer (zumbador)

1×

🧰

Interruptor ON/OFF

1×

Bateria recarregável Li-ion 16340 (3,7V)

1×

Cabo USB (para programação)

1×

Peças impressas em 3D (corpo, cabeça, 2 pernas, 2 pés)

1×

Parafusos, chave de fenda e cabos Dupont (opcional)

🎯 O desafio

Montar e programar um robô humanoide que dança: encadear movimentos dos servos (andar, virar, moonwalk, gingado, chutes) numa coreografia — trabalhando sequência, repetição, calibração e autoria.

📶 Intermediario · ⏱ 3 a 5 aulas

🪜 Passo a passo

1) Imprimir e montar as peças (corpo, cabeça, 2 pernas, 2 pés).
2) Encaixar os 4 servos CENTRADOS em ~90° (pernas D2/D3, pés D4/D5) — não forçar.
3) Ligar o HC-SR04 (olhos, D8/D9), o buzzer (D13), o interruptor e a bateria.
4) Calibrar os servos e carregar o código da dança.
5) Testar e criar a própria coreografia.
6) Apresentar a dança pra turma.

🔌 Montagem do robô

Placa: Arduino Nano

pinoscorrente⬇ baixar SVG

as peças reagem: LED acende, botão é clicável, serial abaixo

🖥️ Monitor serial

⚡ Energia: uma bateria recarregável Li-ion 16340 (3,7V) alimenta o shield do Nano através de um interruptor ON/OFF. O shield distribui a energia para os 4 servos, o sensor e o buzzer (GND comum).

📋 Tabela de ligações (fio a fio)

Sensores

Sensor HC-SR04 (os olhos)

Trig → D8 disparo

Echo → D9 eco

VCC → 5V alimentação

GND → GND terra

Saídas

Servo da perna esquerda (YL)

sinal → D2 quadril esq

Servo da perna direita (YR)

sinal → D3 quadril dir

Servo do pé esquerdo (RL)

sinal → D4 tornozelo esq

Servo do pé direito (RR)

sinal → D5 tornozelo dir

Buzzer

+ → D13 som

Outros

Interruptor ON/OFF

entre bateria e shield → bateria liga/desliga

Bateria Li-ion 16340 (3,7V)

VIN/GND → shield alimentação geral

🔧 Passo a passo de ligação

Imprimir e montar as peças: corpo, cabeça, 2 pernas e 2 pés.
Encaixar os 4 micro servos e ligar no shield do Nano: perna esquerda no D2, perna direita no D3, pé esquerdo no D4, pé direito no D5. Antes de parafusar, deixe cada servo CENTRADO em ~90° (centro do giro de 180°). NÃO force.
Ligar o sensor HC-SR04 (os 'olhos', na cabeça): Trig no D8, Echo no D9, mais VCC (5V) e GND. Ligar o buzzer no D13.
Ligar o interruptor ON/OFF entre a bateria Li-ion 16340 e o shield, e encaixar a bateria.
Conferir o GND comum, ligar via USB, CALIBRAR os servos (deixar o Otto reto) e carregar o código da dança.

💻 Código

aula.ino

/*
 * Robô Otto Dançarino — dança 'Smooth Criminal'
 * Código original da biblioteca OttoDIY (humanoide com 4 servos: pernas D2/D3, pés D4/D5).
 * Mantido como na pasta do kit. Os comentários internos seguem do original.
 */

//----------------------------------------------------------------
//-- Otto Dance smooth criminal
//-- This code will make Otto dance play the by Michael Jackson song at the same time and see it in action
//-- https://www.ottodiy.com/
//-----------------------------------------------------------------
#include <Servo.h>
#include <Oscillator.h>
#include <EEPROM.h>
#define N_SERVOS 4
//-- Make sure the servos are in the right pin
/*                  -------- 
                   |  O  O  |
                   |--------|
  RIGHT LEG (YR) 3 |        | LEFT LEG 2 (YL)
                    -------- 
                    ||     ||
RIGHT FOOT (RR) 5 |---     ---| LEFT FOOT 4 (RL)  
*/
#define EEPROM_TRIM false 
// Activate to take callibration data from internal memory
#define TRIM_RR 7
#define TRIM_RL 4
#define TRIM_YR  4
#define TRIM_YL -7
//OTTO.setTrims(-7,-4,-4,7);

#define PIN_RR 5
#define PIN_RL 4
#define PIN_YR 3
#define PIN_YL 2

#define INTERVALTIME 10.0 

Oscillator servo[N_SERVOS];

void goingUp(int tempo);
void drunk (int tempo);
void noGravity(int tempo);
void kickLeft(int tempo);
void kickRight(int tempo);
void run(int steps, int T=500);
void walk(int steps, int T=1000);
void backyard(int steps, int T=3000);
void backyardSlow(int steps, int T=5000);
void turnLeft(int steps, int T=3000);
void turnRight(int steps, int T=3000);
void moonWalkLeft(int steps, int T=1000);
void moonWalkRight(int steps, int T=1000);
void crusaito(int steps, int T=1000);
void swing(int steps, int T=1000);
void upDown(int steps, int T=1000);
void flapping(int steps, int T=1000);

void setup()
{
  Serial.begin(19200);
  
  servo[0].attach(PIN_RR);
  servo[1].attach(PIN_RL);
  servo[2].attach(PIN_YR);
  servo[3].attach(PIN_YL);
  
  //EEPROM.write(0,TRIM_RR);
  //EEPROM.write(1,TRIM_RL);
  //EEPROM.write(2,TRIM_YR);
  //EEPROM.write(3,TRIM_YL);
  
  int trim;
  
  if(EEPROM_TRIM){
    for(int x=0;x<4;x++){
      trim=EEPROM.read(x);
      if(trim>128)trim=trim-256;
      Serial.print("TRIM ");
      Serial.print(x);
      Serial.print(" en ");
      Serial.println(trim);
      servo[x].SetTrim(trim);
    }
  }
  else{
    servo[0].SetTrim(TRIM_RR);
    servo[1].SetTrim(TRIM_RL);
    servo[2].SetTrim(TRIM_YR);
    servo[3].SetTrim(TRIM_YL);
  }
  
  for(int i=0;i<4;i++) servo[i].SetPosition(90);
}

// TEMPO: 121 BPM
int t=495;
double pause=0;

void loop()
{
 // if(Serial.available()){
  //  char init = Serial.read();
   // if (init=='X'){
   //   delay(4000); //3000 - 4500
   
dance();

//for(int i=0;i<4;i++) servo[i].SetPosition(90);

          for(int i=0;i<4;i++) servo[i].SetPosition(90);
   // }
 // }
}

void dance(){
  primera_parte(); segunda_parte();
  moonWalkLeft(4,t*2); moonWalkRight(4,t*2); moonWalkLeft(4,t*2); moonWalkRight(4,t*2);
  primera_parte(); 
  crusaito(1,t*8); crusaito(1,t*7);
  for (int i=0; i<16; i++){   flapping(1,t/4);   delay(3*t/4); }
  moonWalkRight(4,t*2); moonWalkLeft(4,t*2);  moonWalkRight(4,t*2);  moonWalkLeft(4,t*2);
  drunk(t*4);drunk(t*4);  drunk(t*4);  drunk(t*4);
  kickLeft(t);  kickRight(t);
  drunk(t*8);  drunk(t*4);drunk(t/2);
  delay(t*4); 
  drunk(t/2);
  delay(t*4); 
  walk(2,t*2);
  backyard(2,t*2);
  goingUp(t*2);  goingUp(t*1);
  noGravity(t*2);
  crusaito(1,t*2);  crusaito(1,t*8); crusaito(1,t*2); crusaito(1,t*8); crusaito(1,t*2); crusaito(1,t*3);
  delay(t);
  primera_parte();
    for (int i=0; i<32; i++){   flapping(1,t/2);  delay(t/2); } 
  for(int i=0;i<4;i++) servo[i].SetPosition(90);}

//////////////////////////////////CONTROL FUNCTIONS//////////////////////////////////

void oscillate(int A[N_SERVOS], int O[N_SERVOS], int T, double phase_diff[N_SERVOS]){
  for (int i=0; i<4; i++) {
    servo[i].SetO(O[i]);
    servo[i].SetA(A[i]);
    servo[i].SetT(T);
    servo[i].SetPh(phase_diff[i]);
  }
  double ref=millis();
   for (double x=ref; x<T+ref; x=millis()){
     for (int i=0; i<4; i++){
        servo[i].refresh();
     }
  }
}

unsigned long final_time;
unsigned long interval_time;
int oneTime;
int iteration;
float increment[N_SERVOS]; 
int oldPosition[]={90,90,90,90};

void moveNServos(int time, int  newPosition[]){
  for(int i=0;i<N_SERVOS;i++)	increment[i] = ((newPosition[i])-oldPosition[i])/(time/INTERVALTIME);
  
  final_time =  millis() + time; 
  
  iteration = 1; 
  while(millis() < final_time){ //Javi del futuro cambia esto  
      interval_time = millis()+INTERVALTIME;  
      
      oneTime=0;      
      while(millis()<interval_time){	  
          if(oneTime<1){ 
              for(int i=0;i<N_SERVOS;i++){
                  servo[i].SetPosition(oldPosition[i] + (iteration * increment[i]));
              }			
              iteration++;
              oneTime++;
          }
      }     
  }   

  for(int i=0;i<N_SERVOS;i++){	
    oldPosition[i] = newPosition[i];
  }   
}

////////////////////////////////Dance Steps////////////////////////////////

void goingUp(int tempo){
  
      pause=millis();
      for(int i=0;i<4;i++) servo[i].SetPosition(90);
      delay(tempo);
      servo[0].SetPosition(80);
      servo[1].SetPosition(100);
      delay(tempo);
      servo[0].SetPosition(70);
      servo[1].SetPosition(110);
      delay(tempo);
      servo[0].SetPosition(60);
      servo[1].SetPosition(120);
      delay(tempo);
      servo[0].SetPosition(50);
      servo[1].SetPosition(130);
      delay(tempo);
      servo[0].SetPosition(40);
      servo[1].SetPosition(140);
      delay(tempo);
      servo[0].SetPosition(30);
      servo[1].SetPosition(150);
      delay(tempo);
      servo[0].SetPosition(20);
      servo[1].SetPosition(160);
      delay(tempo);
      
      while(millis()<pause+8*t);

}

void primera_parte(){
  
  int move1[4] = {60,120,90,90};
  int move2[4] = {90,90,90,90};
  int move3[4] = {40,140,90,90};
  
  for(int x=0; x<3; x++){
    for(int i=0; i<3; i++){
      lateral_fuerte(1,t/2);
      lateral_fuerte(0,t/4);
      lateral_fuerte(1,t/4);
      delay(t);
    }
  
    pause=millis();
    for(int i=0;i<4;i++) servo[i].SetPosition(90);
    moveNServos(t*0.4,move1);
    moveNServos(t*0.4,move2);
    while(millis()<(pause+t*2));
  }
  
  for(int i=0; i<2; i++){
    lateral_fuerte(1,t/2);
    lateral_fuerte(0,t/4);
    lateral_fuerte(1,t/4);
    delay(t);
  }
    
  pause=millis();
  for(int i=0;i<4;i++) servo[i].SetPosition(90);
  crusaito(1,t*1.4);
  moveNServos(t*1,move3);
  for(int i=0;i<4;i++) servo[i].SetPosition(90);
  while(millis()<(pause+t*4));
}

void segunda_parte(){
  
  int move1[4] = {90,90,80,100};
  int move2[4] = {90,90,100,80};
  int move3[4] = {90,90,80,100};
  int move4[4] = {90,90,100,80};
    
  int move5[4] = {40,140,80,100};
  int move6[4] = {40,140,100,80};
  int move7[4] = {90,90,80,100};
  int move8[4] = {90,90,100,80};
       
  int move9[4] = {40,140,80,100};
  int move10[4] = {40,140,100,80};
  int move11[4] = {90,90,80,100};
  int move12[4] = {90,90,100,80};
  
  for(int x=0; x<7; x++){ 
    for(int i=0; i<3; i++){
      pause=millis();
      moveNServos(t*0.15,move1);
      moveNServos(t*0.15,move2);
      moveNServos(t*0.15,move3);
      moveNServos(t*0.15,move4);
      while(millis()<(pause+t));
    }
    pause=millis();
    moveNServos(t*0.15,move5);
    moveNServos(t*0.15,move6);
    moveNServos(t*0.15,move7);
    moveNServos(t*0.15,move8);
    while(millis()<(pause+t));
  }
 
  for(int i=0; i<3; i++){
    pause=millis();
    moveNServos(t*0.15,move9);
    moveNServos(t*0.15,move10);
    moveNServos(t*0.15,move11);
    moveNServos(t*0.15,move12);
    while(millis()<(pause+t));
  }
}

void lateral_fuerte(boolean side, int tempo){
  
  for(int i=0;i<4;i++) servo[i].SetPosition(90);
  if (side) servo[0].SetPosition(40);
  else servo[1].SetPosition(140);
  delay(tempo/2);
  servo[0].SetPosition(90);
  servo[1].SetPosition(90);
  delay(tempo/2);

}

void drunk (int tempo){
  
  pause=millis();
  
  int move1[] = {60,70,90,90};
  int move2[] = {110,120,90,90};
  int move3[] = {60,70,90,90};
  int move4[] = {110,120,90,90};
  
  moveNServos(tempo*0.235,move1);
  moveNServos(tempo*0.235,move2);
  moveNServos(tempo*0.235,move3);
  moveNServos(tempo*0.235,move4);
  while(millis()<(pause+tempo));

}


void noGravity(int tempo){
  
  int move1[4] = {120,140,90,90};
  int move2[4] = {140,140,90,90};
  int move3[4] = {120,140,90,90};
  int move4[4] = {90,90,90,90};
  
  
  for(int i=0;i<4;i++) servo[i].SetPosition(90);
  for(int i=0;i<N_SERVOS;i++) oldPosition[i]=90;
  moveNServos(tempo*2,move1);
  moveNServos(tempo*2,move2);
  delay(tempo*2);
  moveNServos(tempo*2,move3);
  moveNServos(tempo*2,move4);

}

void kickLeft(int tempo){
  for(int i=0;i<4;i++) servo[i].SetPosition(90);
  delay(tempo);
  servo[0].SetPosition(50); //pie derecho
  servo[1].SetPosition(70); //pie izquiero
  delay(tempo);
  servo[0].SetPosition(80); //pie derecho
  servo[1].SetPosition(70); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(30); //pie derecho
  servo[1].SetPosition(70); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(80); //pie derecho
  servo[1].SetPosition(70); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(30); //pie derecho
  servo[1].SetPosition(70); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(80); //pie derecho
  servo[1].SetPosition(70); //pie izquiero
  delay(tempo);
}

void kickRight(int tempo){
for(int i=0;i<4;i++) servo[i].SetPosition(90);
  delay(tempo);
  servo[0].SetPosition(110); //pie derecho
  servo[1].SetPosition(130); //pie izquiero
  delay(tempo);
  servo[0].SetPosition(110); //pie derecho
  servo[1].SetPosition(100); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(110); //pie derecho
  servo[1].SetPosition(150); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(110); //pie derecho
  servo[1].SetPosition(80); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(110); //pie derecho
  servo[1].SetPosition(150); //pie izquiero
  delay(tempo/4);
  servo[0].SetPosition(110); //pie derecho
  servo[1].SetPosition(100); //pie izquiero
  delay(tempo);
}

void walk(int steps, int T){
    int A[4]= {15, 15, 30, 30};
    int O[4] = {0, 0, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(90), DEG2RAD(90)};
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void run(int steps, int T){
    int A[4]= {10, 10, 10, 10};
    int O[4] = {0, 0, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(90), DEG2RAD(90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void backyard(int steps, int T){
    int A[4]= {15, 15, 30, 30};
    int O[4] = {0, 0, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(-90), DEG2RAD(-90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void backyardSlow(int steps, int T){
    int A[4]= {15, 15, 30, 30};
    int O[4] = {0, 0, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(-90), DEG2RAD(-90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}


void turnLeft(int steps, int T){
    int A[4]= {20, 20, 10, 30};
    int O[4] = {0, 0, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(90), DEG2RAD(90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void turnRight(int steps, int T){
    int A[4]= {20, 20, 30, 10};
    int O[4] = {0, 0, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(90), DEG2RAD(90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void moonWalkRight(int steps, int T){
    int A[4]= {25, 25, 0, 0};
    int O[4] = {-15 ,15, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(180 + 120), DEG2RAD(90), DEG2RAD(90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void moonWalkLeft(int steps, int T){
    int A[4]= {25, 25, 0, 0};
    int O[4] = {-15, 15, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(180 - 120), DEG2RAD(90), DEG2RAD(90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void crusaito(int steps, int T){
    int A[4]= {25, 25, 30, 30};
    int O[4] = {- 15, 15, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(180 + 120), DEG2RAD(90), DEG2RAD(90)}; 
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void swing(int steps, int T){
    int A[4]= {25, 25, 0, 0};
    int O[4] = {-15, 15, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(0), DEG2RAD(90), DEG2RAD(90)};
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void upDown(int steps, int T){
    int A[4]= {25, 25, 0, 0};
    int O[4] = {-15, 15, 0, 0};
    double phase_diff[4] = {DEG2RAD(180), DEG2RAD(0), DEG2RAD(270), DEG2RAD(270)};
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void flapping(int steps, int T){
    int A[4]= {15, 15, 8, 8};
    int O[4] = {-A[0], A[1], 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(180), DEG2RAD(90), DEG2RAD(-90)};
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

void test(int steps, int T){
    int A[4]= {15, 15, 8, 8};
    int O[4] = {-A[0] + 10, A[1] - 10, 0, 0};
    double phase_diff[4] = {DEG2RAD(0), DEG2RAD(180), DEG2RAD(90), DEG2RAD(-90)};
    
    for(int i=0;i<steps;i++)oscillate(A,O, T, phase_diff);
}

🖨️ Modelos 3D para impressão

Toque para ver em 3D · gire com o dedo.

⏳

Corpo 📥 Baixar

⏳

Cabeça (com shield do Nano) 📥 Baixar

⏳

Perna 📥 Baixar

⏳

Pé esquerdo 📥 Baixar

⏳

Pé direito 📥 Baixar

🤖 Transforme este projeto em aula

O Co-professor gera um plano de aula completo — ou uma sequência didática de 2 a 4 encontros — adaptado à sua turma. Cadastre-se grátis pra usar.

✨ Gerar aula ou sequência com IA

💬 Comentários

Entre na sua conta ou crie uma grátis pra comentar.

Seja o primeiro a comentar.

Gostou desta aula?

Monte aulas como esta em minutos, com ajuda da IA — e compartilhe com professores do Brasil todo. É grátis.

Criar minha conta grátis