Biblioteca EletroBlocks para Arduino

A Biblioteca EletroBlocks facilita a programação dos blocos no Arduino: em vez de escrever muitas linhas de código para cada bloco funcionar, você usa comandos curtos em português. Esta página reúne tudo — download, instalação, os comandos explicados linha por linha e o que dá para criar com cada um.

Baixar

Versão 2.0.0 · arquivo .ZIP · 38 KB · Arduino UNO e compatíveis

Baixar a biblioteca

Nesta versão: controle de velocidade no bloco de motor CC, display OLED ajustado para funcionar com todos os modelos de tela, e leitura de entradas feita com os próprios comandos do Arduino.

Instalar em 3 passos

  1. Instale a Arduino IDE 2. Baixe em arduino.cc/en/software e conclua a instalação normalmente.
  2. Instale a Adafruit NeoPixel. Na IDE, vá em Tools → Manage Libraries, busque por Adafruit NeoPixel e clique em Install. O bloco de LED RGB depende dela.
  3. Adicione a EletroBlocks. Na IDE, vá em Sketch → Include Library → Add .ZIP Library e selecione o arquivo que você baixou. Não descompacte o arquivo antes.

Como conferir se deu certo: abra File → Examples e procure por EletroBlocks no final da lista. Se a pasta aparecer com os exemplos dentro, está tudo instalado.

O que é a biblioteca

A Biblioteca EletroBlocks é um conjunto de códigos que criamos para facilitar a interação entre os blocos EletroBlocks e o universo Arduino. Ela evita que você tenha que digitar muitas linhas de código para fazer cada bloco funcionar direito.

Um exemplo: para girar o motor a 60% da velocidade para a direita, você escreve uma linha.

motor.girar(60);   // gira para a direita, a 60% da velocidade

Além dos comandos curtos, a biblioteca traz:

  • Comandos em português — definirCor, tocar, girar, moverPara. Cada um também existe em inglês, se você preferir.
  • Cores e notas com nome — vermelho, azul, DO4, LA4, em vez de números.
  • Inicialização automática — um comando no começo do programa prepara tudo.
  • Exemplos prontos que aparecem direto no menu da Arduino IDE.

 

Como um programa Arduino é organizado

Todo programa na Arduino IDE tem duas partes obrigatórias:

  • setup() — roda uma vez, quando a placa liga. É onde você prepara as coisas.
  • loop() — roda para sempre, repetindo do começo assim que chega ao fim. É onde o projeto acontece.

A biblioteca entra em três pontos desse esqueleto: uma linha no topo do arquivo para incluí-la, uma linha dentro do setup() para preparar o shield, e os comandos dos blocos onde você quiser.

#include <EletroBlocks.h>   // 1. avisa a IDE que você vai usar a biblioteca

void setup() {
  EletroBlocks.iniciar();   // 2. prepara o shield. Sempre a primeira linha do setup
}

void loop() {
  // 3. aqui vai o seu projeto
}

As saídas do kit se chamam saida1, saida2 e saida3. As entradas, entrada1, entrada2 e entrada3. Você usa esses nomes tanto nos comandos da biblioteca quanto nos comandos normais do Arduino.

Lendo entradas e acionando saídas

Nem todo projeto precisa de um comando especial da biblioteca. Para ler um botão ou acender um LED simples, os próprios comandos do Arduino funcionam — e são os mesmos que o aluno vai encontrar em qualquer tutorial de Arduino no mundo.

Lendo uma entrada

int valor = analogRead(entrada1);   // lê a Entrada 1 e guarda em "valor"
                                    // resultado: um número, de 0 até cerca de 1000
                                    // quanto maior, maior a tensão que chegou

Serve para botão, sensor de luz, potenciômetro e sensor de cor. A diferença entre eles está no número que voltar: o botão dá um salto entre dois valores, enquanto o sensor de luz varia aos poucos.

Para um botão, você compara essa leitura com um valor de corte:

int leitura = analogRead(entrada1);   // lê a Entrada 1

if (leitura > 500) {                  // 500 é o corte: acima disso, consideramos apertado
  Serial.println("apertado");         // escreve no Serial Monitor
}

Não sabe qual corte usar? Abra o Serial Monitor, imprima analogRead(entrada1) e aperte o botão algumas vezes. Você vai ver os dois grupos de números na tela e pode escolher um valor no meio deles.

Se você só quer saber se está ligado ou desligado, sem o número exato, também dá para ler de forma digital:

if (digitalRead(entrada1) == HIGH) {  // HIGH = ligado, LOW = desligado
  // faz alguma coisa
}

Acionando uma saída

Para blocos simples, como o bloco de LED, você aciona a saída direto:

digitalWrite(saida1, HIGH);   // liga a Saída 1 no máximo
digitalWrite(saida1, LOW);    // desliga a Saída 1

analogWrite(saida1, 128);     // liga pela metade: aceita de 0 (apagado) a 255 (máximo)

Para os blocos de LED RGB, servo, motor CC e para o display, use os comandos da biblioteca. Esses blocos têm eletrônica própria e não respondem a um simples liga/desliga.

Os comandos da biblioteca

LED RGB

Acende em qualquer cor, com controle de brilho e efeito de pisca.

EB_RGB led(saida1);              // cria o LED RGB, dizendo que ele está na Saída 1

led.definirCor(roxo);            // acende na cor roxo
led.definirCor(255, 128, 0);     // ou monte a sua cor: vermelho, verde e azul (0 a 255)
led.definirBrilho(60);           // deixa mais fraco. 0 = apagado, 255 = máximo
led.piscar(azul, 300, 300);      // pisca em azul: 300ms aceso, 300ms apagado
led.desligar();                  // apaga

As cores com nome disponíveis são vermelho, verde, azul, branco, amarelo, ciano, magenta, laranja, roxo e desligado.

Vários LEDs RGB juntos. Quando você conecta mais de um bloco de LED RGB em sequência, eles formam um grupo ligado à mesma saída — e a biblioteca consegue acender cada um de uma cor diferente. Para isso você avisa quantos LEDs tem no grupo, escolhe a cor de cada um pelo número da posição, e depois manda aplicar tudo de uma vez.

EB_RGB grupo(saida1, 3);         // grupo de 3 LEDs RGB conectados na Saída 1

grupo.definirPixel(1, vermelho); // o primeiro LED do grupo fica vermelho
grupo.definirPixel(2, verde);    // o segundo fica verde
grupo.definirPixel(3, azul);     // o terceiro fica azul
grupo.aplicar();                 // só agora as três cores aparecem de uma vez

A conta é pela ordem da ligação: o LED número 1 é o que está mais perto do shield. E as cores só mudam quando você chama aplicar() — é assim que dá para montar a cena inteira antes de mostrar.

Buzzer

Toca notas e melodias. As notas já vêm com nome, de DO4 até LA5.

EB_Buzzer buzzer(saida2);        // cria o buzzer, dizendo que ele está na Saída 2

buzzer.bipe(LA4, 500);           // toca a nota Lá por 500ms e para sozinho
buzzer.tocar(DO5);               // começa a tocar Dó e continua tocando
buzzer.parar();                  // para o som

Para uma melodia, você monta duas listas: uma com as notas e outra com a duração de cada uma.

int notas[]    = {DO4, MI4, SOL4, DO5, -1};  // as notas, na ordem. O -1 marca o fim da lista
int duracoes[] = {200, 200, 200, 400};       // quanto tempo cada nota dura, em ms

buzzer.tocarMelodia(notas, duracoes);        // toca a sequência inteira

Para fazer uma pausa no meio da melodia, use 0 no lugar de uma nota: o buzzer fica em silêncio pelo tempo correspondente.

Sobre o volume: o bloco toca sempre no mesmo volume, e isso não muda por código. O que você controla é qual nota toca e por quanto tempo. Se precisar de um som mais discreto na sala, o caminho é escolher notas mais graves ou usar bipes mais curtos.

Servo motor

Posiciona o eixo em um ângulo exato, entre 0° e 270°. Serve para braços, garras, catracas e tudo que precisa parar num ponto certo.

EB_Servo servo(saida3);          // cria o servo, dizendo que ele está na Saída 3

servo.definirAngulo(90);         // vai direto para 90°, o mais rápido que conseguir
servo.moverPara(270, 15);        // vai devagar até 270°. O 15 é a pausa entre os passos:
                                 // quanto maior o número, mais lento o movimento
servo.centralizar();             // volta para o meio do curso

int onde = servo.lerAngulo();    // guarda em "onde" o último ângulo comandado

Motor CC

Gira para um lado ou para o outro, com velocidade de 0 a 100%. Criamos os comandos da biblioteca justamente para que o sentido e a velocidade possam ser controlados por software, sem você precisar mexer em nada no bloco.

EB_Motor motor(saida1);          // cria o motor, dizendo que ele está na Saída 1

motor.girar(60);                 // gira para a direita a 60%
motor.girar(-60);                // número negativo = gira para a esquerda
motor.girarEsquerda(40);         // mesma coisa, dizendo o sentido por extenso
motor.acelerarAte(100, 2000);    // acelera suavemente até 100%, levando 2 segundos
motor.inverter();                // troca o sentido, mantendo a velocidade
motor.parar();                   // para o motor

A alavanca do bloco. O bloco de motor tem uma chavinha com três posições. Nas duas laterais, o motor gira sempre para um lado fixo, sem depender de programação nenhuma — ótimo para os primeiros projetos, ainda no kit tradicional. No centro, quem manda é o código.

Ou seja: para usar os comandos acima, deixe a alavanca na posição do meio. Se o motor ignorar o que você programou e girar sempre para o mesmo lado, essa é a primeira coisa para conferir.

Display OLED

Tela de 128×64 dividida em 8 linhas de texto, com cerca de 21 caracteres por linha.

EB_OLED oled;                    // cria o display (ele não ocupa nenhuma saída)

void setup() {
  EletroBlocks.iniciar();        // prepara o shield primeiro, sempre
  oled.begin();                  // liga o display

  oled.limpar();                 // apaga a tela inteira
  oled.print(0, 0, "ELETROBLOCKS");  // escreve na coluna 0, linha 0 (a de cima)
  oled.print(0, 2, 42);              // escreve o número 42 na linha 2
}

O display é o único que precisa de begin() escrito por você, e ele tem que vir depois do EletroBlocks.iniciar(). Se a tela não acender, use oled.conectado() para confirmar se ela está respondendo.

Exemplos prontos

Depois de instalar, tudo isso aparece em File → Examples → EletroBlocks. São programas curtos, prontos para carregar na placa e modificar:

  • LED RGB — RGB_Basico, LED_RGB_Exemplo_1, LED_Azul_Saida2
  • Buzzer — Buzzer_Basico, Musica_Mario_Exemplo_2
  • Servo — Servo_Basico, Servo_Botao, Servo_Botao_Instantaneo, Servo_Zero_a_270
  • Motor CC — Motor_Basico, Motor_Botao_Velocidade
  • Entradas — Button_Basico, Botao_Liga_Saida1, Serial_Entrada1
  • Display OLED — OLED_Oi, OLED_Oi_Tudo_Bem, OLED_Pulo_Botao, OLED_Sensor_Entrada1, OLED_SemBiblioteca
  • Projetos completos — Completo, Sensor_Servo_OLED

Antes de começar

  • Desconecte o motor CC e o servo na hora de gravar o código. Ao ligar a placa e ao enviar um programa novo, as saídas passam por um momento indefinido até o seu código assumir. Com esses dois blocos plugados, isso pode virar um movimento inesperado. Grave primeiro, conecte depois.
  • Alavanca do motor no centro se você quiser controlá-lo por programação.
  • Motor CC junto com o display? Prefira a Saída 1 para o motor. As Saídas 2 e 3 usam os mesmos pinos do Arduino que o display ocupa para se comunicar, e medimos que, com o display ligado, a placa perde o controle da chave de alimentação dessas duas saídas.
  • Tela embaralhada? O display sai configurado no ajuste mais compatível. Se você tiver uma tela mais antiga e quiser tentar deixá-la mais rápida, use oled.begin(40).

Referência rápida

Comandos do Arduino que você vai usar

analogRead(entrada1) Lê uma entrada e devolve um número.
digitalRead(entrada1) Lê uma entrada como ligado (HIGH) ou desligado (LOW).
digitalWrite(saida1, HIGH) Liga uma saída no máximo. Use LOW para desligar.
analogWrite(saida1, 128) Liga uma saída com intensidade de 0 a 255.
Serial.begin(9600) / Serial.println(x) Abre o Serial Monitor e escreve nele.

Geral

EletroBlocks.iniciar() Prepara o shield. Sempre primeiro no setup().
saida1 saida2 saida3 As três saídas de blocos.
entrada1 entrada2 entrada3 As três entradas.
Cores vermelho verde azul branco amarelo ciano magenta laranja roxo desligado
Notas DO4 RE4 MI4 FA4 SOL4 LA4 SI4 DO5 RE5 MI5 FA5 SOL5 LA5

LED RGB — EB_RGB

definirCor(cor) / definirCor(r, g, b) Define a cor.
definirBrilho(0–255) Ajusta o brilho.
piscar(cor, aceso, apagado) Pisca uma vez, com os tempos em ms.
definirPixel(n, cor) + aplicar() Escolhe a cor de um LED do grupo e mostra tudo de uma vez.
desligar() Apaga.

Buzzer — EB_Buzzer

bipe(nota, duracao) Toca uma nota por um tempo e para sozinho.
tocar(nota) / parar() Liga e desliga o som.
tocarMelodia(notas, duracoes) Toca uma sequência. A lista de notas termina em -1; 0 é pausa.
estaTocando() Diz se o buzzer está soando.

Servo — EB_Servo

definirAngulo(0–270) Vai direto para o ângulo.
moverPara(angulo, pausa) Vai devagar. Número maior = mais lento.
centralizar() Vai para o meio do curso.
lerAngulo() Última posição comandada.
desconectar() Solta o eixo.

Motor CC — EB_Motor

girar(-100 a +100) Sentido e velocidade em um comando só.
girarDireita(0–100) / girarEsquerda(0–100) Sentido por extenso.
acelerarAte(velocidade, tempo) Acelera suavemente até a velocidade.
inverter() Troca o sentido mantendo a velocidade.
parar() Para o motor.
lerVelocidade() / estaParado() Estado atual.

Display OLED — EB_OLED

begin() / begin(kHz) Liga o display.
conectado() Confirma se a tela está respondendo.
limpar() Apaga a tela.
print(coluna, linha, texto) Escreve texto. Coluna 0–127, linha 0–7.
print(coluna, linha, numero) Escreve números inteiros ou decimais.
drawBitmap(...) Desenha uma imagem gravada na memória.

Travou em alguma coisa?

Se algum comando não fizer o que você espera, ou se você quiser um exemplo para uma aula específica, fale com a gente pelo WhatsApp ou por contato@eletroblocks.com.br. A biblioteca é atualizada com base no que aparece nas salas de aula.

Voltar para o blog