Arduino vs Pico Elecrow Starter Kit

Neste artigo vamos comparar o Arduino com o Pico Elecrow Starter Kit para educação STEM. Ambos os kits oferecem vários sensores diferentes (luz, som, distância, …) e alguns atuadores (servo, LED, relé, buzzer, …) que podem ser programados via Arduino IDE.

A principal diferença é que um Starter Kit usa o Arduino (ATmega328P) como microcontrolador, enquanto o outro contém o chip Pico 2 (RP2350). Existem também algumas diferenças nos sensores integrados, atuadores e no ecrã, que iremos discutir.

Peças Necessárias

Abaixo encontrará os links para os dois Starter Kits. Como pode ver, vêm em forma de pequenas malas (195*170*46mm) com os sensores e atuadores facilmente acessíveis num painel frontal:

Nas próximas duas secções, primeiro analisamos mais de perto o kit baseado em Arduino e depois discutimos o Starter Kit com o Pico 2.

Starter Kit com Arduino

O Starter Kit baseado em Arduino vem com sensores integrados para Luz, Temperatura, Humidade, Som, Distância, Aceleração, Movimento e luz IR, e um sensor adicional de Humidade do Solo que pode ser ligado via interface Crowtail. Existem seis dessas interfaces Crowtail, que fornecem dois IOs analógicos, um IO digital, duas interfaces I2C e uma interface UART.

Além dos sensores, há um LCD, um Botão, um Relé, um Buzzer, um Servo e um Potenciômetro linear como atuadores. A imagem abaixo mostra o Painel Frontal do Kit com os sensores e atuadores identificados.

O kit vem com Demo Cod, um Tutorial/User Manual e o Schematics do hardware. A tabela seguinte lista os pinos GPIO ou endereços I2C (source) para os diferentes sensores e atuadores:

Sensor	Pino GPIO	I2C
I2C	A5/SCLA4/SDA
UART	D0/RXD1/TX
Entrada Analógica	A3
Entrada Analógica	A6
IO Digital	D11
Sensor de Luz	A5/SCLA4/SDA	0X5C
LED	D10
Botão	D7
Servo	D9
PIR	A2
MPU-6050	A5/SCLA4/SDA	0x68
Buzzer	D3
Potenciômetro Linear	A0
Relé	D4
Sensor de Som	A1
Sensor Remoto IR	D2
Temperatura & Humidade	A5/SCLA4/SDA	0X38
Sensor Ultrassónico	D5_US_ECHOD6_US_TRIG
LCD	A5/SCLA4/SDA	0X21

Programação do Starter Kit Arduino

Programar o Starter Kit baseado em Arduino funciona da mesma forma que programar um Arduino UNO. Primeiro Install the Arduino IDE no seu PC como de costume. Ligue o Kit via USB ao seu PC. Depois abra o Board Manager e selecione a placa “Arduino Uno” como mostrado abaixo.

A placa deve ser reconhecida como ligada a uma das portas COM. No exemplo acima é COM5, mas no seu caso pode aparecer numa porta diferente.

Se isso funcionar, pode começar a escrever e carregar código. Infelizmente, o Demo Code e o Tutorial para o Starter Kit contêm vários erros e, na minha opinião, não são fáceis de entender. Por isso, implementei alguns exemplos de código que pode encontrar abaixo.

Exemplo de Código: Piscar LED

O código seguinte é o clássico exemplo Blink. Liga o LED vermelho durante um segundo, depois desliga durante um segundo e repete este ciclo indefinidamente:

const int ledPin = 10;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Exemplo de Código: Botão & LED

No próximo exemplo usamos o botão para ligar ou desligar o LED vermelho. Enquanto o botão estiver pressionado, o LED estará ligado:

const int buttonPin = 7;
const int ledPin = 10;

void setup() {
  pinMode(buttonPin , INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  if (!digitalRead(buttonPin)) {
    digitalWrite(ledPin, HIGH);
    delay(100);
    digitalWrite(ledPin, LOW);
  }
}

Se quiser aprender mais sobre botões, veja o tutorial How To Use A Push Button With Arduino.

Exemplo de Código: Sensor de Movimento & LED

Este exemplo mostra como controlar o LED com o sensor de movimento. Sempre que o sensor PIR deteta movimento, o LED vermelho liga-se durante um segundo.

const int pirPin = A2;
const int ledPin = 10;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  if (digitalRead(pirPin)) {
    digitalWrite(ledPin, HIGH);
    delay(1000);
  }
  digitalWrite(ledPin, LOW);
  delay(10);
}

Se quiser aprender mais sobre sensores Passive InfraRed (PIR) para deteção de movimento, veja o tutorial How to use HC-SR501 PIR Motion Sensor with Arduino.

Exemplo de Código: Sensor de Som & Relé

No exemplo seguinte, ligamos o Relé se o microfone detetar qualquer som com volume acima do limiar definido de 50. Pode alterar o limiar para tornar a deteção de som mais ou menos sensível.

const int soundPin = A1;
const int relayPin = 4;
const int threshold = 50;

void setup() {
  pinMode(soundPin, INPUT);
  pinMode(relayPin, OUTPUT);
}

void loop() {
  if (analogRead(soundPin) > threshold) {
    digitalWrite(relayPin, HIGH);
    delay(1000);
    digitalWrite(relayPin, LOW);
    delay(100);    
  }
}

Para mais informações sobre Relés, veja o tutorial How To Use A Relay With Arduino.

Exemplo de Código: Sensor Ultrassónico de Distância & Buzzer

O exemplo abaixo usa o Sensor Ultrassónico para medir distâncias e, se a distância for menor que 30 centímetros, o buzzer é ativado para emitir um som de aviso:

#include "HCSR04.h"

const int triggerPin = 6;
const int echoPin = 5;
const int buzzerPin = 3;

UltraSonicDistanceSensor sensor(triggerPin, echoPin);

void setup() {
}

void loop() {
  float dist = sensor.measureDistanceCm();
  if (dist > 0 && dist < 30) {
    tone(buzzerPin, 2000);
    delay(100);
    noTone(buzzerPin);
  }
}

Se precisar de mais informações sobre buzzers, veja o tutorial Use A Piezo Buzzer With Arduino. E se quiser aprender mais sobre o Sensor Ultrassónico de Distância, pode ler o nosso tutorial How to use an HC-SR04 Ultrasonic Distance Sensor with Arduino.

Exemplo de Código: Sensor Ultrassónico de Distância & Servo

Este próximo exemplo usa novamente o Sensor Ultrassónico, mas agora para controlar o Servo. Quanto mais perto um objeto estiver do sensor, mais o Servo gira.

#include "HCSR04.h"
#include "Servo.h"

const int triggerPin = 6;
const int echoPin = 5;
const int servoPin = 9;

Servo servo;
UltraSonicDistanceSensor sensor(triggerPin, echoPin);

void setup() {
  servo.attach(servoPin, 600, 2520);
}

void loop() {
  float dist = sensor.measureDistanceCm();
  if (dist > 0 && dist < 30) {
    int pos = map(dist, 0, 30, 0, 180);
    servo.write(pos);
    delay(50);
  }
}

Para mais informações sobre servos, veja o nosso tutorial How to control servo motors with Arduino. E se quiser controlar o Servo via controlo remoto IR usando o sensor IR incorporado, leia o tutorial How to Control a Servo with an IR Remote.

Exemplo de Código: Sensor de Temperatura & Humidade & LCD

Como exemplo final, medimos a Temperatura e Humidade com o sensor DHT20 e mostramos os valores medidos no LCD:

#include "DHT20.h"
#include "Adafruit_LiquidCrystal.h"

DHT20 dht(&Wire);
Adafruit_LiquidCrystal lcd(0x21);

void setup() {
  lcd.begin(16, 2);
  Wire.begin();
  dht.begin();
}

void loop() {
  dht.read();
 
  lcd.setCursor(2, 0);
  lcd.print("Tem: ");
  lcd.print(dht.getTemperature());
  lcd.print(" C");

  lcd.setCursor(2, 1);
  lcd.print("Hum: ");
  lcd.print(dht.getHumidity());
  lcd.print(" %");

  delay(500);
}

Se precisar de mais ajuda com LCDs, veja os tutoriais Interfacing 128 x 64 Graphical LCD With Arduino e How to use a 16×2 character LCD with Arduino.

Starter Kit com Pico 2

O Starter Kit baseado no microcontrolador Raspberry Pico 2 vem com sensores de toque, luz, campos magnéticos, gás, som, temperatura, humidade e um sensor ultrassónico de distância.

Quanto a atuadores e outros dispositivos de saída, há um buzzer, um servo motor, um motor de vibração, um relé, um potenciômetro, vários botões, três LEDs, duas tiras de LEDs RGB e um ecrã TFT. A imagem abaixo mostra o Painel Frontal do Kit com os seus sensores e atuadores.

Este kit vem também com Demo Cod, um Tutorial/Manual, um Wiki e o Schematics para os circuitos de hardware.

Programação do Pico Starter Kit

Antes de poder programar o Pico 2 com a Arduino IDE, precisa de instalar o core RP2350. Vá a File -> Preferences na Arduino IDE e abra o diálogo de Preferências

No diálogo de Preferências vá ao separador Settings. Na parte inferior verá “Additional boards manager URLs:”. Clique no botão à direita (marcado a amarelo) para abrir o editor de URLs

No editor de URLs adicione o seguinte URL à lista (marcado a amarelo abaixo):
“https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json”

Apesar do nome, o package_rp2040_index suporta o chip RP2040 e o RP2350, que é usado no Pico Starter Kit.

Como pode ver, também instalei os cores ESP8266 e ESP32, mas só precisa do core RP2350 para o Starter Kit baseado em Pico.

Instalação das Placas RP2350

De seguida, precisamos de instalar as placas RP2350. Vá a Tools -> Board -> Board Manager e pesquise por RP2350 usando a barra de pesquisa. Instale as placas Raspberry Pi Pico/RP2040/RP2350 de Earle F. Philhower. Após a instalação, deverá ficar assim.

Selecionar placa Raspberry Pi Pico 2

Depois de completar a instalação do core RP2350, ligue o Pico Starter Kit à porta USB do seu computador. Depois vá ao Board Manager e selecione a placa “Raspberry Pi Pico 2” como mostrado abaixo:

A placa deve ser reconhecida pela Arduino IDE e deverá vê-la ligada a uma porta COM via USB (veja a captura de ecrã acima).

Agora estamos prontos para programar. Para conveniência, aqui está uma tabela com alguns dos pinos GPIO e os sensores ou atuadores a que estão ligados (source):

Pino GPIO	Função
GP0_LED_BK	LED_BK
GP1_PSRAM_CS	Seleção do chip PSARM
GP4/I2C0_SDA	Toque no ecrã TFT
GP5/I2C0_SCL
GP2/I2C1_SDA	Temperatura & Humidade DHT20 (0X38) MPU-6050 (0x68) SENSOR DE LUZ (0x5C)
GP3/I2C1_SCL
GP6_SPI0_CLK_TFT	Exibição no ecrã TFT
GP7_SPI0_MOSI_TFT
GP16_RS_TFT
GP17_SPI0_CS_TFT
GPIO24_TP_RST
GPIO25_TP_INT
GP26_A0_GAS	Sensor de Fumo
GP27_A1_KEY	4*botões
GP28_A2_POT	Potenciômetros deslizantes
GP29_A3_SOUND	Módulo Sensor de Som
QSPI_SD3	W25Q64 NORFlash & APS6404L PSRAM
QSPI_SCLK
QSPI_SD0
QSPI_SD2
QSPI_SD1
QSPI_SS
GPIO8_US_ECHO	Módulo Ultrassónico
GPIO9_US_TRIG
GPIO10_BUZZER	Módulo BUZZER
GPIO11_IR	Módulo IR
GPIO12_RELAY	Módulo RELÉ
GPIO13_SERVO	Módulo SERVO
GPIO14_TOUCH	Módulo TOQUE
GPIO15_VIB	Módulo Motor de Vibração
GPIO18_LED_RED	LED
GPIO19_LED_GREEN	LED
GPIO20_LED_YELLOW	LED
GPIO21_HALL	Módulos Sensor Hall
GPIO22_RGB	LED RGB*20
GPIO23_RGB_EN

O Pico Starter Kit vem com alguns Demo Code e um Tutorial mas o código é um grande bloco e não é muito adequado para aprender a usar os diferentes sensores do kit. Por isso, implementei alguns exemplos simples que o ajudarão a começar facilmente.

Exemplo de Código: Piscar três LEDs

Este primeiro exemplo simplesmente pisca os três LEDs (vermelho, verde, amarelo) um de cada vez:

// red, green, yellow LEDS
const int leds[] = { 18, 19, 20 };

void setup() {
  for (int i = 0; i < 3; i++) {
    pinMode(leds[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < 3; i++) {
    digitalWrite(leds[i], HIGH);
    delay(500);
    digitalWrite(leds[i], LOW);
  }
}

Exemplo de Código: Sensor de Gás & Monitor Serial

No próximo exemplo, lemos o valor do Sensor de Gás e imprimimos no Monitor Serial:

void setup() {
  Serial.begin(115200);
}

void loop() {
  int sensorValue = analogRead(A0);
  Serial.print("Gas:");
  Serial.println(sensorValue);
  
  delay(1000);
}

Se quiser aprender mais sobre o Sensor de Gás MQ-2 e como interpretar esses valores, veja o nosso tutorial How to use the MQ-2 Gas Sensor with Arduino.

Exemplo de Código: Sensor de Toque & Buzzer

O código seguinte lê o sensor de toque e emite um tom no buzzer, se for detetado toque:

const int touchPin = 14;
const int buzzerPin = 10;

void setup() {
  pinMode(buzzerPin, OUTPUT);
  pinMode(touchPin, INPUT);
}

void loop() {
  delay(50);
  if (digitalRead(touchPin)) {
    tone(buzzerPin, 2000);
  } else {
    noTone(buzzerPin);
  }
}

Para mais informações sobre buzzers, veja o tutorial Use A Piezo Buzzer With Arduino.

Exemplo de Código: Sensor de Som & LED

O exemplo seguinte usa o microfone para detetar som e, se o volume do som ultrapassar um certo limiar, o LED vermelho liga-se.

const int ledPin = 18;
const int soundPin = 29;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(soundPin, INPUT);
}

void loop() {
  if (analogRead(soundPin) > 50) {
    digitalWrite(ledPin, HIGH);
    delay(100);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Exemplo de Código: Servo & Potenciômetro

Com este exemplo pode usar o Potenciômetro linear para controlar a posição do braço do Servo:

#include "Servo.h"

const int servoPin = 13;
Servo servo;

void setup() {
  servo.attach(servoPin, 600, 2520); 
}

void loop() {
  int pot = analogRead(A2);
  int pos = map(pot, 0, 1024, 0, 180);
  servo.write(pos); 
  delay(10); 
}

Para mais informações sobre servos, veja os tutoriais How to control servo motors with Arduino e Positional versus Continuous Servos. Se quiser controlar o Servo via controlo remoto IR usando o sensor IR incorporado no kit, o tutorial How to Control a Servo with an IR Remote será útil.

Exemplo de Código: Sensor Ultrassónico de Distância & Relé

No exemplo de código seguinte, ligamos o Relé (e o LED vermelho) se a distância medida pelo Sensor Ultrassónico for menor que 10 cm:

#include "HCSR04.h"

const int triggerPin = 9;
const int echoPin = 8;
const int relayPin = 12;
const int ledPin = 18;

UltraSonicDistanceSensor sensor(triggerPin, echoPin);

void setup() {
  pinMode(relayPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  float dist = sensor.measureDistanceCm();
  if (dist > 0 && dist < 10) {
    digitalWrite(relayPin, HIGH);
    digitalWrite(ledPin, HIGH);
    delay(1000);
  }
  digitalWrite(relayPin, LOW);
  digitalWrite(ledPin, LOW);
}

Se quiser aprender mais sobre o Sensor Ultrassónico de Distância, pode ler o nosso tutorial How to use an HC-SR04 Ultrasonic Distance Sensor with Arduino. E para mais informações sobre Relés, veja o tutorial How To Use A Relay With Arduino.

Exemplo de Código: Ecrã TFT

O Pico Starter Kit contém um ecrã TFT e aqui está um exemplo simples de como usar este ecrã com o Adafruit-ST7735-Library. O código simplesmente escreve o texto “Makerguides” no ecrã.

#include "Adafruit_GFX.h"    
#include "Adafruit_ST7789.h" 
#include "SPI.h"

#define TFT_CS    17   
#define TFT_RST   -1 
#define TFT_DC    16  
#define TFT_MOSI   7  
#define TFT_SCLK   6  

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
const int tftBacklight = 0;

void setup() {
  pinMode(tftBacklight, OUTPUT);
  digitalWrite(tftBacklight, HIGH);

  tft.init(240, 320);      
  tft.fillScreen(ST77XX_BLACK);
  tft.setRotation(3);
  tft.setCursor(60, 100);
  tft.setTextColor(ST77XX_WHITE);
  tft.setTextSize(3);
  tft.print("Makerguides");
}

void loop() {}

Se quiser fazer mais do que apenas escrever texto, veja o Adafruit GFX Graphics Library documentation. Para além de texto, pode mostrar todo o tipo de gráficos (linhas, retângulos, …) e cores.

Algumas outras informações relevantes também estão disponíveis nos tutoriais Interface TFT ST7789 Display with ESP32 e Interfacing 1.8-inch TFT Color Display With Arduino.

Exemplo de Código: Ecrã TFT & Sensor de Temperatura & Humidade

Este exemplo final demonstra como ler dados do Sensor de Temperatura e Humidade e como mostrar os valores medidos no ecrã TFT:

#include "Adafruit_GFX.h"
#include "Adafruit_ST7789.h"
#include "SPI.h"
#include "DHT20.h"

const int tftBacklight = 0;

// CS, DC, MOSI, SCLK, RST
Adafruit_ST7789 tft = Adafruit_ST7789(17, 16, 7, 6, -1);
DHT20 dht(&Wire1);  

void setup() {
  pinMode(tftBacklight, OUTPUT);
  digitalWrite(tftBacklight, HIGH);

  tft.init(240, 320);
  tft.fillScreen(ST77XX_BLACK);
  tft.setRotation(3);
  tft.setTextColor(ST77XX_WHITE);
  tft.setTextSize(3);

  Wire1.setSDA(2);
  Wire1.setSCL(3);
  Wire1.begin();
  dht.begin();
}

void loop() {
  dht.read();

  tft.fillScreen(ST77XX_BLACK);
  tft.setCursor(30, 50);
  tft.printf("Tmp: %.2f C", dht.getTemperature());
  tft.setCursor(30, 100);
  tft.printf("Hum: %.2f %%", (double)dht.getHumidity());

  delay(1000);
}

Vai notar que o ecrã pisca a cada atualização dos valores mostrados. Precisamos de limpar o ecrã entre cada atualização, pois o texto é escrito com um transparent background e por isso sobrepõe-se a si próprio. Pode evitar isto escrevendo primeiro numa canvas e depois atualizando o ecrã. Veja o Adafruit GFX Graphics Library documentation, se quiser fazer isso.

Comparação dos Starter Kits

A principal diferença entre os dois Starter Kits é o microcontrolador. Um usa um Arduino (ATmega328P) como microcontrolador, enquanto o outro usa o Pico 2 (RP2350). O Pico é muito mais potente, mas é mais recente e, por isso, tem menos suporte em termos de bibliotecas, informação e ajuda geral.

Além disso, o Starter Kit baseado no Pico vem com um ecrã TFT que tem muito maior resolução (e cor), comparado com o ecrã LCD do Starter Kit baseado em Arduino. No entanto, é um pouco mais fácil escrever código para o ecrã LCD.

O Kit Pico tem mais LEDs, incluindo LEDs RGB, e mais sensores como Sensor de Gás, Sensor Hall e um Sensor de Toque. Também tem um motor de vibração que o Kit Arduino não tem. E o Kit Pico tem quatro botões, enquanto o Kit Arduino tem apenas um.

Por outro lado, o Kit Pico não tem interfaces Crowtail nem quaisquer outros pinos GPIO expostos que possam ser usados para ligar sensores externos, como o Sensor de Humidade do Solo que vem com o Kit Arduino.

Ambos os Starter Kits têm pinos GPIO e endereços I2C para os sensores e atuadores identificados na serigrafia (painel), o que é muito útil ao escrever o código de controlo.

À exceção do ecrã TFT do Kit Pico, pode escrever código muito semelhante e construir muitos projetos semelhantes com ambos os kits, já que os sensores são em grande parte os mesmos e podem ser programados da mesma forma.

Conclusões

Ambos os kits são ótimos se quiser aprender a escrever código Arduino para ler dados de sensores e controlar atuadores. No entanto, os tutoriais e exemplos de código fornecidos podiam ser melhores. Especialmente o código de exemplo para o Starter Kit baseado em Pico vem como um grande bloco de código e não está dividido em tutoriais individuais para cada sensor.

O objetivo de ambos os Starter Kits é claramente fornecer uma plataforma de hardware fácil para educação STEM e nisso têm sucesso. São fantásticos se quiser experimentar rapidamente e brincar com diferentes sensores ou atuadores. O formato de mala é muito prático, e não precisa de se preocupar em perder cabos ou sensores.

Por outro lado, não vai aprender a construir um circuito sozinho. Os circuitos internos dos kits são mais complexos (mais robustos) do que os que se construiriam para fins educativos e, por isso, não são exemplos adequados para iniciantes. Embora ter os esquemas de ambos os kits seja muito útil.

Se quiser uma plataforma de hardware para educação STEM, eu escolheria o kit baseado em Arduino, pois o Arduino (ATmega328P) tem melhor suporte que o Pico e o LCD é mais fácil de usar.

No entanto, se o foco for mais em efeitos de iluminação ou desenvolvimento de jogos, o Kit baseado em Pico é a melhor escolha devido às tiras de LEDs RGB, ao ecrã TFT e aos quatro botões que podem ser usados para controlo de jogos. Além disso, se preferir MicroPython, o Pico com maior poder de computação e memória é o que deseja.

Boas experiências de tinkering ; )