Tutorial de mBlock com Arduino: instalação, modo ao vivo ou upload e blocos

Programar um Arduino com o mBlock é um dos jeitos mais fáceis de fazer um Arduino Uno piscar um LED ou ler um botão ou sensor sem escrever uma única linha de código. O mBlock 5, desenvolvido gratuitamente pela Makeblock, é um ambiente de programação em blocos construído sobre o Scratch 3.0: você encaixa blocos coloridos como um quebra-cabeça, e o mBlock os transforma discretamente em código Arduino C, compila e carrega na sua placa. Você também pode rodar os blocos na placa na hora e fazê-los interagir com personagens no palco. Por isso ele é uma das ferramentas mais populares nas aulas de robótica e programação das escolas, em projetos de feira de ciências e como primeiro passo no Arduino.

Neste guia você vai aprender, passo a passo, como instalar o mBlock no computador ou usá-lo no navegador, adicionar e conectar um Arduino Uno como dispositivo, carregar o firmware do modo Ao vivo, a diferença entre o modo Ao vivo (Live) e o modo Upload, os blocos de LED, botão e sensor, em quais linhas de Arduino C os blocos se transformam, nove atividades para usar na sala de aula, como passar para o Arduino IDE e como resolver os problemas de conexão mais comuns.

O que é o mBlock e como ele funciona com o Arduino?

O mBlock é um ambiente de programação construído sobre o Scratch 3.0, desenvolvido no MIT. A maior diferença em relação ao Scratch é que, além dos personagens na tela (sprites), ele também programa hardware de verdade. A interface tem duas abas separadas: na aba Sprites você programa os personagens do palco, e na aba Devices (dispositivos) você programa placas como Arduino, micro:bit ou robôs da Makeblock. Quando você seleciona um dispositivo, categorias próprias daquela placa são acrescentadas à paleta de blocos; para o Arduino Uno, são os blocos de pinos e de porta serial. No modo Upload, o seu script de blocos é traduzido para Arduino C, compilado em código de máquina e gravado na memória flash da placa pelo USB. Ou seja, o mBlock faz o mesmo trabalho do Arduino IDE por uma interface de blocos e, como mostra o código que gera, também facilita a passagem para o código em texto.

Instalando o mBlock: versão desktop e versão web

1. No navegador, acesse mblock.cc e baixe na página Download a versão desktop do mBlock 5 para o seu sistema operacional. No momento em que escrevemos, a versão atual é a V5.6; ela suporta Windows 7 64 bits ou superior e macOS 10.12 ou superior, com um instalador separado para Macs com chip Apple da série M.
2. No Windows, rode o instalador e siga o assistente. Se durante a instalação ele oferecer instalar o driver CH340, aceite: a maioria das placas Arduino clone usa esse chip USB-serial, e sem o driver a porta não aparece.
3. No macOS, se o instalador não abrir, clique com o botão direito no arquivo e escolha Abrir, ou use o botão Abrir Mesmo Assim em Privacidade e Segurança, nos Ajustes do Sistema.
4. Abra o mBlock e escolha o seu idioma no ícone de globo do menu superior. A partir daí, os menus e os nomes dos blocos aparecem nesse idioma.
5. Em computadores da escola em que não dá para instalar programas, abra ide.mblock.cc no navegador; para a conexão com o Arduino, use uma versão atualizada do Chrome ou do Edge.

Por muito tempo, a versão web se conectava às placas por um pequeno programa auxiliar chamado mLink. Nas versões mais novas, o método padrão é uma conexão direta que usa o recurso de porta serial do navegador: ao clicar em conectar, o navegador abre uma janela, você escolhe a porta do Arduino e se conecta sem instalar nada extra. Isso funciona com o Uno, o Nano, o Nano (old) e o Mega 2560; placas que usam o USB de outro jeito, como o Leonardo, o Micro e o Yun, ainda precisam do mLink. Enquanto o mLink está rodando, um pequeno ícone de panda aparece na barra de tarefas. Não deixe as versões desktop e web, nem duas abas do mBlock, abertas ao mesmo tempo; as duas tentam usar a mesma porta e a conexão falha.

Adicionando um dispositivo: conectando o Arduino Uno ao mBlock

1. Ligue o Arduino ao computador com um cabo USB; o LED ON (alimentação) da placa deve acender.
2. No mBlock, passe para a aba Devices embaixo do palco. Remova o dispositivo da Makeblock que vem por padrão (Codey Rocky ou CyberPi, conforme a versão) pelo X no canto dele.
3. Clique em + Add, digite “Arduino” na caixa de busca da Device Library (biblioteca de dispositivos) que abrir, selecione Arduino Uno e clique em OK. Se você clicar na estrela no canto superior esquerdo da placa, o mBlock vai deixá-la pronta na próxima vez que abrir.
4. Clique em Connect (conectar). Na aba USB da janela que abrir, escolha a porta que o mBlock encontrou: no Windows você vai ver um nome como COM3 ou COM4; no macOS, algo como /dev/cu.usbmodem… ou, em placas com CH340, /dev/cu.wchusbserial…. Se a porta não aparecer na lista, marque Show all connectable devices (mostrar todos os dispositivos conectáveis).
5. Clique em Connect de novo. Se aparecer a mensagem “Device connected” (dispositivo conectado), está tudo pronto; os blocos de pinos e de porta serial próprios do Arduino aparecem na paleta de blocos.

Escolher o dispositivo certo já é meio caminho andado. Seja original ou clone, selecione Arduino Uno para um Uno e Arduino Mega2560 para um Mega. A maioria dos clones baratos do Arduino Nano tem o bootloader antigo; nessas placas, o carregamento falha com Arduino Nano, enquanto a opção Arduino Nano (old) funciona. Placas mais novas com outro processador, como o Arduino Uno R4, não podem ser programadas com o dispositivo Uno do mBlock; para elas, use direto o Arduino IDE. Se você ainda não decidiu qual placa comprar, leia Qual Arduino comprar? e, para a disposição dos pinos do Nano, veja o guia de pinagem do Arduino Nano.

Modo Ao vivo ou modo Upload: qual é a diferença?

O mBlock oferece dois modos para programar dispositivos, e você alterna entre eles com a chave da aba Devices. No modo Ao vivo (Live), o programa na verdade roda no computador: o mBlock lê cada bloco por vez e manda ao Arduino, pelo USB, comandos como “ligar o pino 13” ou “ler o A0 e devolver o resultado”. Para isso, o Arduino precisa de um firmware especial que entende esses comandos. Você vê o resultado na hora, pode acompanhar os valores dos sensores no palco e fazer o Arduino conversar com os sprites, mas, no momento em que você tira o cabo USB ou fecha o mBlock, o programa para. No modo Upload, os blocos são traduzidos para Arduino C, compilados e gravados de forma permanente na placa; mesmo com o cabo desligado, o programa continua rodando com uma bateria ou um adaptador. Nesse modo, o seu programa precisa ficar embaixo do bloco de chapéu when Arduino Uno starts up (quando o Arduino Uno inicia); eventos do palco, como a bandeira verde, não são transferidos para a placa.

Carregando o firmware: preparando o Arduino para o modo Ao vivo

1. Conecte o Arduino (Connect) e ponha a chave de modo em Live.
2. Se a placa não tiver o firmware do mBlock, o mBlock geralmente oferece atualizá-lo. Se não oferecer, escolha Update Firmware (atualizar firmware) no menu Setting (configurações) ao lado dos botões de conexão e comece a atualização na janela que abrir.
3. Durante o carregamento, os LEDs TX e RX da placa piscam rápido; não tire o cabo nem feche o mBlock até a barra de progresso terminar.
4. Para testar, arraste o bloco set digital pin (13) output as (high) (definir a saída do pino digital 13 como alta), dos blocos de pinos, para a área de scripts e clique nele uma vez. Se o LED L da placa acender na hora, o modo Ao vivo está funcionando; clique no mesmo bloco com a opção (low) e o LED apaga.

Blocos básicos do Arduino: LEDs, botões e sensores

Depois que o Arduino Uno é adicionado, a paleta de blocos ganha categorias de pinos e de porta serial próprias da placa ao lado das categorias Eventos, Controle, Operadores, Variáveis e Meus Blocos que você conhece do Scratch. A tabela abaixo lista os blocos pelos nomes em inglês, junto com o que fazem. Os nomes dos blocos podem variar um pouco entre versões; se você clicar com o botão direito em qualquer bloco e escolher Help (ajuda), o mBlock mostra uma descrição dele. No Uno, o PWM só funciona nos pinos 3, 5, 6, 9, 10 e 11; você pode ver o mapa completo dos pinos na ferramenta Pinagem.

Tabela de ligações: um kit de aula para todas as atividades

Remontar o circuito toda semana desperdiça tempo de aula. Se você montar uma vez as ligações abaixo em uma protoboard, dá para fazer as nove atividades sem mexer nos cabos. Você pode conferir o resistor do LED com a calculadora de resistor para LED e a tensão que o divisor do LDR fornece com a ferramenta divisor de tensão. Se é a primeira vez que você usa essas peças, os artigos sobre LED, botão, LDR e servo motor explicam cada ligação em detalhes.

Primeiro programa: piscando um LED no modo Upload

1. Ponha a chave de modo em Upload.
2. Arraste o bloco when Arduino Uno starts up da categoria Eventos para a área de scripts.
3. Encaixe embaixo dele um bloco forever (sempre) da categoria Controle.
4. Dentro do bloco forever, coloque nesta ordem set digital pin (13) output as (high), wait (1) seconds, set digital pin (13) output as (low) e mais um wait (1) seconds.
5. Clique em Upload. O mBlock compila o código e o manda para a placa; depois de alguns segundos, uma mensagem avisa que o carregamento terminou.
6. O LED L da placa começa a piscar uma vez por segundo. Se você tirar o cabo USB e alimentar a placa com um power bank ou um adaptador de 7–12 V, o programa continua rodando; falamos das opções de alimentação em como alimentar o Arduino com bateria.

Como os blocos viram código Arduino C?

No modo Upload, clique no botão de código Arduino C na borda direita (o ícone de colchetes angulares) e o mBlock mostra em um painel o código que corresponde aos seus blocos. Cada mudança que você faz nos blocos atualiza o código na hora; é o jeito mais fácil de aprender qual bloco gera qual linha. Se você acrescentar ao programa Blink acima uma variável chamada sayac (contador, em turco) e aumentá-la em 1 a cada volta, o código gerado fica mais ou menos assim. Os comentários foram acrescentados por nós; o espaçamento e a posição de algumas linhas, como o pinMode, podem variar um pouco entre versões.

1// generated by mBlock5 for <your product>
2// codes make you happy
3// mBlock'un ürettiği kodun yapısı: Blink + sayaç / Structure of mBlock-generated code: Blink + counter
4
5#include <Arduino.h>
6#include <Wire.h>
7#include <SoftwareSerial.h>
8
9float sayac = 0;               // mBlock değişkenleri float olur / mBlock variables become float
10
11void _loop();                  // ön bildirim, Arduino IDE de ekler / forward declaration, the Arduino IDE adds it too
12
13void _delay(float seconds) {   // "wait (1) seconds" bloğu / the "wait (1) seconds" block
14  long endTime = millis() + seconds * 1000;
15  while (millis() < endTime) _loop();
16}
17
18void setup() {                 // "when Arduino Uno starts up" altındaki bloklar / blocks under "when Arduino Uno starts up"
19  pinMode(13, OUTPUT);
20  while (1) {                  // "forever" bloğu / the "forever" block
21    digitalWrite(13, 1);       // pin 13 HIGH: dahili L LED'i yanar / pin 13 HIGH: the built-in L LED turns on
22    _delay(1);
23    digitalWrite(13, 0);       // pin 13 LOW: LED söner / pin 13 LOW: the LED turns off
24    _delay(1);
25    sayac += 1;                // "change sayac by 1" bloğu / the "change sayac by 1" block
26    _loop();
27  }
28}
29
30void _loop() {                 // uzantıların sürekli çalışan kodu buraya eklenir / extensions add their recurring code here
31}
32
33void loop() {
34  _loop();
35}

Há quatro coisas a notar neste código. Primeiro, o bloco forever não vira a função loop() do Arduino, e sim um laço infinito while(1) dentro do setup(); o loop() só chama a função _loop(). Segundo, o bloco wait usa uma função _delay() no lugar do delay(); enquanto espera, essa função continua chamando _loop(), para que o trabalho que algumas extensões precisam fazer em segundo plano não fique parado. Terceiro, toda variável que você cria no mBlock é declarada como float (número decimal); no Uno, cada uma ocupa 4 bytes de RAM e pode causar pequenos erros de arredondamento em comparações de igualdade. Por exemplo, uma variável que você aumenta em passos de 0,1 pode não ser exatamente 1 depois de dez passos, então uma comparação de “maior que” ou “menor que” é mais segura do que “igual a”. Quarto, as bibliotecas Wire e SoftwareSerial no topo costumam ser incluídas mesmo que você não as use; o programa funciona do mesmo jeito, mas pode ocupar um pouco mais de espaço que uma versão escrita à mão.

Atividades de exemplo para aulas de robótica e programação

As nove atividades abaixo estão em ordem da mais fácil à mais difícil, para aulas de 40 minutos, e todas funcionam com o kit de ligações único acima. Começar toda atividade no modo Ao vivo é uma boa abordagem: os alunos clicam em um bloco e veem o resultado na hora, acompanham os valores dos sensores no palco e acham os próprios erros. Quando o programa funcionar como esperado, levar os mesmos blocos para o modo Upload e gravá-los de forma permanente na placa ensina a ideia de “um dispositivo que funciona sem computador”. Você também encontra os conceitos de programação por trás dessas atividades em código de texto no artigo sobre fundamentos de programação Arduino.

As conversões de números são a parte mais instrutiva das aulas. O potenciômetro dá um valor de 0 a 1023 enquanto o PWM espera de 0 a 255, então na atividade 5 você divide a leitura por 4 (1023 ÷ 4 ≈ 255). Para transformar o mesmo valor em ângulo para o servo, você monta valor × 180 ÷ 1023 com blocos de operadores. Na atividade 9, você dá ao Arduino, no modo Ao vivo, o script “quando a bandeira verde for clicada, sempre, definir [pot] como (read analog pin A1)”; no sprite, você usa a mesma variável em um bloco mude x para (pot × 480 ÷ 1023 − 240) para espalhar a raquete pela largura do palco, de −240 a 240. Se você não marcar a opção “para todos os atores” ao criar a variável, o dispositivo e o sprite não enxergam a mesma variável. Para o sensor de estacionamento, abra o Extension Center (central de extensões) com o botão + extension no fim da paleta de blocos e acrescente uma extensão de sensor ultrassônico; a maioria dessas extensões é feita por desenvolvedores da comunidade, então os nomes dos blocos e os pinos suportados variam de uma extensão para outra. Você encontra como o sensor funciona no artigo sobre o sensor de distância HC-SR04 e as frequências das notas no artigo sobre o buzzer.

Passando para o Arduino IDE: dos blocos ao código de verdade

Em algum momento, os blocos não bastam: à medida que os programas crescem, a área de scripts fica bagunçada, você precisa de uma biblioteca de sensor que não está no Extension Center ou quer rodar várias tarefas ao mesmo tempo sem delay. É a hora da instalação do Arduino IDE e da passagem para o código em texto; acrescentar bibliotecas para sensores novos passa a estar nas suas mãos. O melhor jeito de suavizar a transição é reescrever no Arduino IDE um projeto que você fez no mBlock, para ver lado a lado duas visões da mesma lógica.

1. No mBlock, selecione e copie o código do painel Arduino C; abra um sketch novo no Arduino IDE e cole.
2. Escolha a placa (Arduino Uno) e a porta no menu Ferramentas e clique primeiro em Verificar e depois em Carregar. O código deve funcionar igual ao que funcionava no mBlock.
3. Depois simplifique o código: junte as linhas pinMode no setup(), leve o conteúdo do laço while(1) para o loop() e use delay() ou millis() no lugar de _delay().
4. Troque as variáveis float por int ou bool onde fizer sentido e dê nomes significativos aos números dos pinos com const int.
5. Mostre as variáveis no Monitor Serial para acompanhar o que o programa faz; é o equivalente, no código em texto, ao monitoramento ao vivo do mBlock.

Abaixo está, escrito no Arduino IDE, o programa que junta as atividades 3 e 4: uma luz noturna automática que você liga e desliga com um botão. Os números dos pinos são os da tabela de ligações acima.

1// mBlock gece lambası etkinliğinin Arduino IDE ile yazılmış hali
2// The mBlock night-light activity rewritten for the Arduino IDE
3const int LED_PIN = 5;         // LED + 220 ohm direnç (PWM pini) / LED + 220 ohm resistor (PWM pin)
4const int BUTON_PIN = 2;       // buton 5V'a, 10k pull-down GND'ye / button to 5V, 10k pull-down to GND
5const int LDR_PIN = A0;        // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
6const int ESIK = 400;          // bu değerin altı "karanlık" sayılır / below this value counts as "dark"
7
8bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
9int oncekiButon = LOW;         // önceki buton durumu / previous button state
10unsigned long sonYazma = 0;    // son Seri Monitör yazma zamanı / last Serial Monitor print time
11
12void setup() {
13  pinMode(LED_PIN, OUTPUT);
14  pinMode(BUTON_PIN, INPUT);   // harici pull-down olduğu için INPUT / INPUT because of the external pull-down
15  Serial.begin(9600);          // Seri Monitör 9600 baud / Serial Monitor at 9600 baud
16}
17
18void loop() {
19  int buton = digitalRead(BUTON_PIN);
20  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
21    sistemAcik = !sistemAcik;
22    delay(30);                                 // basit debounce / simple debounce
23  }
24  oncekiButon = buton;
25
26  int isik = analogRead(LDR_PIN);              // 0 karanlık, 1023 aydınlık / 0 dark, 1023 bright
27  if (sistemAcik && isik < ESIK) {
28    int parlaklik = map(isik, 0, ESIK, 255, 40);   // karardıkça daha parlak / brighter as it gets darker
29    analogWrite(LED_PIN, parlaklik);
30  } else {
31    analogWrite(LED_PIN, 0);
32  }
33
34  if (millis() - sonYazma >= 500) {            // delay olmadan yarım saniyede bir yaz / print every half second without delay
35    sonYazma = millis();
36    Serial.print("Isik: ");
37    Serial.print(isik);
38    Serial.print("  Sistem: ");
39    Serial.println(sistemAcik ? "acik" : "kapali");
40  }
41}

Veja as diferenças em relação à versão do mBlock: o setup() roda só uma vez e prepara os pinos, enquanto o loop() se repete sozinho, então não é preciso while(1). O botão é comparado com o estado anterior e registrado só no momento em que é apertado; senão, com o dedo no botão, o sistema alternaria centenas de vezes por segundo. A função map() escala o valor do LDR para entre 255 e 40, então o LED brilha mais à medida que o quarto escurece. A impressão no Monitor Serial acontece a cada meio segundo com millis() no lugar de delay(), para que o programa não perca um toque no botão enquanto espera. Você encontra os detalhes dessa técnica em millis ou delay e mais sobre impressão de dados no artigo do Monitor Serial do Arduino.

O mesmo programa no ESP32 e no Raspberry Pi Pico

A biblioteca de dispositivos do mBlock inclui as placas da própria Makeblock baseadas no ESP32, como a CyberPi e a HaloCode, mas não há dispositivo oficial para uma placa de desenvolvimento ESP32 comum nem para o Raspberry Pi Pico; as extensões da comunidade que aparecem às vezes também mudam de versão para versão. A boa notícia é que a lógica que você aprendeu com blocos não muda de placa para placa. Quando você programa o ESP32 com o Arduino IDE, usa quase o mesmo código; só mudam os números dos pinos, a tensão de funcionamento de 3,3 V e a escala de 12 bits do ADC, de 0 a 4095. Por isso o limite de escuro passa a ser cerca de 1600 em vez de 400.

1// Aynı gece lambası ESP32'de (Arduino IDE) / The same night light on the ESP32 (Arduino IDE)
2const int LED_PIN = 18;        // LED + 220 ohm direnç / LED + 220 ohm resistor
3const int BUTON_PIN = 4;       // buton 3V3'e, 10k pull-down GND'ye / button to 3V3, 10k pull-down to GND
4const int LDR_PIN = 34;        // ADC1 girişi, LDR + 10k bölücü (3V3) / ADC1 input, LDR + 10k divider (3V3)
5const int ESIK = 1600;         // ESP32 ADC 12 bit: 0-4095 / ESP32 ADC is 12-bit: 0-4095
6
7bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
8int oncekiButon = LOW;         // önceki buton durumu / previous button state
9unsigned long sonYazma = 0;    // son yazma zamanı / last print time
10
11void setup() {
12  pinMode(LED_PIN, OUTPUT);
13  pinMode(BUTON_PIN, INPUT);   // harici pull-down / external pull-down
14  Serial.begin(115200);        // ESP32 için yaygın hız / common speed for the ESP32
15}
16
17void loop() {
18  int buton = digitalRead(BUTON_PIN);
19  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
20    sistemAcik = !sistemAcik;
21    delay(30);                                 // basit debounce / simple debounce
22  }
23  oncekiButon = buton;
24
25  int isik = analogRead(LDR_PIN);              // 0 karanlık, 4095 aydınlık / 0 dark, 4095 bright
26  if (sistemAcik && isik < ESIK) {
27    analogWrite(LED_PIN, map(isik, 0, ESIK, 255, 40));   // karardıkça daha parlak / brighter as it gets darker
28  } else {
29    analogWrite(LED_PIN, 0);
30  }
31
32  if (millis() - sonYazma >= 500) {            // yarım saniyede bir yaz / print every half second
33    sonYazma = millis();
34    Serial.printf("Isik: %d  Sistem: %s\n", isik, sistemAcik ? "acik" : "kapali");
35  }
36}

No Raspberry Pi Pico, o caminho mais comum é o MicroPython. O programa abaixo, que você roda no editor Thonny, faz o mesmo trabalho: read_u16() retorna o valor do ADC de 0 a 65535, e duty_u16() espera o ciclo de trabalho do PWM na mesma escala. Explicamos por que o Python é um bom segundo passo depois da programação em blocos no artigo sobre fundamentos de MicroPython.

1# Aynı gece lambası Raspberry Pi Pico'da (MicroPython) / The same night light on Raspberry Pi Pico (MicroPython)
2from machine import Pin, ADC, PWM
3import time
4
5led = PWM(Pin(14))                     # LED + 220 ohm direnç / LED + 220 ohm resistor
6led.freq(1000)                         # PWM frekansı 1 kHz / PWM frequency 1 kHz
7buton = Pin(2, Pin.IN, Pin.PULL_DOWN)  # buton 3V3'e, pull-down / button to 3V3, pull-down
8ldr = ADC(26)                          # GP26 = ADC0, LDR + 10k bölücü / GP26 = ADC0, LDR + 10k divider
9ESIK = 25000                           # 0-65535 arası karanlık eşiği / darkness threshold on 0-65535
10
11sistem_acik = True                     # butonla açılıp kapanır / toggled with the button
12onceki = 0                             # önceki buton durumu / previous button state
13son_yazma = time.ticks_ms()            # son yazma zamanı / last print time
14
15while True:
16    b = buton.value()
17    if b == 1 and onceki == 0:         # yalnız basıldığı an / only at the moment of the press
18        sistem_acik = not sistem_acik
19        time.sleep_ms(30)              # basit debounce / simple debounce
20    onceki = b
21
22    isik = ldr.read_u16()              # 0 karanlık, 65535 aydınlık / 0 dark, 65535 bright
23    if sistem_acik and isik < ESIK:
24        # karardıkça daha parlak / brighter as it gets darker
25        led.duty_u16(65535 - isik * 55000 // ESIK)
26    else:
27        led.duty_u16(0)
28
29    if time.ticks_diff(time.ticks_ms(), son_yazma) >= 500:   # yarım saniyede bir / every half second
30        son_yazma = time.ticks_ms()
31        print("Isik:", isik, " Sistem:", "acik" if sistem_acik else "kapali")

Abrindo os mesmos projetos em blocos no celular

Se você quer continuar trabalhando com a lógica de blocos que montou no mBlock quando estiver longe do computador, dê uma olhada no app BlueGrays. O código de mais de 100 projetos de Arduino, ESP32 e Raspberry Pi Pico do app também está disponível nos nossos próprios blocos, baseados no Blockly. Ligue o Ver em blocos em um projeto e o código é substituído pelo mesmo programa em blocos; a aba Entenda os blocos então explica passo a passo o que cada bloco faz. As atividades de LED, semáforo, LED com botão, luz noturna com LDR, buzzer, sensor de estacionamento e servo com potenciômetro deste guia estão todas lá, em blocos e em código Arduino C, e você alterna entre os dois com um toque. Comparar a sequência que você montou no mBlock com os blocos do app é um jeito fácil de ver como a mesma lógica é montada em duas ferramentas diferentes.

Para o ESP32 e o Pico, que não têm dispositivo oficial no mBlock, como vimos acima, o app também tem projetos com blocos: olhe primeiro a versão em blocos e depois passe para o código Arduino C ou MicroPython do mesmo projeto. No Guia de código do app, os exemplos de comandos básicos como digitalWrite, if/else e laços também aparecem em blocos. Se quiser reforçar o que aprendeu, as Perguntas do dia trazem 5 perguntas por dia em níveis de A1 a C2, além de um ranking semanal e medalhas.

Problemas comuns de conexão e soluções

Um jeito rápido de saber se o problema vem do mBlock ou da placa é tentar carregar o exemplo Blink na mesma placa com o Arduino IDE. Se o Arduino IDE também mostrar um erro como avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00, a placa e o computador não conseguem se comunicar: o problema está na porta, no cabo, no tipo de placa ou no bootloader. Passamos por todas as causas desse erro no guia erro ao carregar código no Arduino; para mais sobre o chip CH340 e os drivers dele, veja o artigo sobre o conversor USB-TTL. Se a placa reinicia sozinha com um servo ligado, as dicas de alimentação de Arduino reiniciando sozinho vão ajudar.

Ideias de projetos para fazer com o mBlock

• Semáforo com botão de pedestre: aperte o botão e o sinal dos carros fica vermelho enquanto o verde dos pedestres acende; para o circuito e o código, veja o artigo do semáforo com Arduino.
• Sensor de estacionamento: um bipe que acelera e mais LEDs que acendem à medida que o HC-SR04 mede uma distância menor.
• Robô que desvia de obstáculos: um carrinho com dois motores e um sensor de distância que vê o obstáculo à frente e muda de direção; detalhes no guia do robô que desvia de obstáculos.
• Robô seguidor de linha: um robô de competição que segue uma fita preta usando sensores infravermelhos (robô seguidor de linha).
• Controle do palco: um jogo no modo Ao vivo em que um potenciômetro ou um joystick pilota uma nave no palco.
• Irrigação automática de plantas: um sistema que liga uma pequena bomba quando um sensor de umidade do solo detecta solo seco.
• Radar com servo: um projeto que varre os arredores com um sensor de distância montado em um servo e desenha uma tela de radar no palco (radar com Arduino).
• Carrinho robô: leve a lógica de motores e sensores que você aprendeu no mBlock para o projeto do carrinho robô com Arduino.

O mBlock é o jeito mais suave de programar um Arduino de verdade com o conforto da programação em blocos e de passar para o código em texto quando você estiver pronto. Se você ainda não tem uma placa, pode testar as mesmas atividades no navegador com a simulação de Arduino no Tinkercad. No app BlueGrays você encontra esquemas de circuito e código passo a passo para os projetos de LED, semáforo, LED com botão, luz noturna com LDR, buzzer, sensor de estacionamento com HC-SR04 e servo com potenciômetro, e também pode abrir os mesmos projetos em blocos, para comparar com um toque a versão em blocos e a versão em código de texto de cada atividade que você montou no mBlock.