Componentes · 12 min de leitura

Pinagem do Arduino Mega 2560: mapa de pinos, PWM, serial e interrupções

Pinagem do Arduino Mega 2560 em um só guia: 54 pinos digitais, 16 analógicos, 15 PWM, 4 portas seriais de hardware e 6 pinos de interrupção. Comparação com o Uno, códigos de exemplo e o caso da impressora 3D.

A pinagem do Arduino Mega oferece a maior capacidade de conexão da família Arduino: a placa Arduino Mega 2560 tem 54 pinos digitais de entrada/saída, 16 entradas analógicas, 15 saídas PWM, 4 portas seriais de hardware e 6 pinos de interrupção externa. Quando os pinos do Uno acabam, quando você precisa conversar com vários dispositivos seriais ao mesmo tempo (GPS, Bluetooth, GSM) ou quando a memória de programa enche, o Mega é a primeira placa que vem à mente. Além disso, ele usa a mesma linguagem Arduino, a mesma IDE e a maioria das mesmas bibliotecas do Uno, então você cresce sem precisar aprender nada novo.

Neste guia vamos percorrer o mapa de pinos do Mega grupo por grupo: quais pinos fornecem PWM, quais pinos cada porta serial usa, onde as interrupções funcionam e por que o I2C e o SPI ficam em lugares diferentes dos do Uno. Depois, seguimos para uma tabela comparativa com o Uno, quando você realmente precisa de um Mega, por que ele virou padrão nas impressoras 3D e como planejar os pinos em um projeto com muitos sensores.

Placa Arduino Mega 2560 e barras de pinos
Arduino Mega 2560: processador ATmega2560, 54 pinos digitais e 16 analógicos; a barra de pinos dupla na borda direita reúne os pinos digitais 22–53.

O que é o Arduino Mega 2560 e como ele funciona?

O Arduino Mega 2560 é uma placa de desenvolvimento construída em torno do microcontrolador de 8 bits ATmega2560. Ele roda no mesmo clock de 16 MHz do Uno, usa o mesmo nível lógico de 5 V e é programado com a mesma Arduino IDE; ou seja, o Mega não é mais rápido que o Uno, ele é mais amplo. Graças ao encapsulamento de 100 pinos, foi possível levar 70 pinos de sinal para a placa. A conexão USB fica por conta do chip ATmega16U2 da placa; nas placas clone, essa tarefa geralmente é do CH340. Você pode alimentar a placa com 5 V pela USB ou com 7–12 V pelo conector DC e pelo Vin; o regulador integrado reduz essa tensão para 5 V. A memória de programa é 8 vezes a do Uno e a RAM é 4 vezes maior, por isso bibliotecas grandes, displays gráficos e menus longos rodam com folga no Mega. A metade esquerda da placa tem a mesma disposição de pinos do Uno, então a maioria dos shields do Uno encaixa diretamente no Mega.

CaracterísticaValor
MicrocontroladorATmega2560 (AVR de 8 bits)
Velocidade de clock16 MHz
Memória flash256 KB (8 KB usados pelo bootloader)
SRAM8 KB
EEPROM4 KB
Tensão de operação5 V
Tensão de entrada (conector DC / Vin)7–12 V recomendado, 6–20 V limite
E/S digitais54 (15 delas com PWM)
Entradas analógicas16 (A0–A15, 10 bits)
Portas seriais de hardware4 (Serial, Serial1, Serial2, Serial3)
Pinos de interrupção externa6
Corrente por pino20 mA recomendado, 40 mA máximo absoluto
Corrente do pino 3.3V50 mA no máximo
Dimensões101,5 × 53,3 mm

Comparação entre Arduino Mega e Uno

CaracterísticaArduino Uno R3Arduino Mega 2560
MicrocontroladorATmega328PATmega2560
Velocidade de clock16 MHz16 MHz
Pinos digitais1454
Pinos PWM6 (3, 5, 6, 9, 10, 11)15 (2–13, 44, 45, 46)
Entradas analógicas6 (A0–A5)16 (A0–A15)
Portas seriais de hardware14
Pinos de interrupção externa2 (2, 3)6 (2, 3, 18, 19, 20, 21)
Flash / SRAM / EEPROM32 KB / 2 KB / 1 KB256 KB / 8 KB / 4 KB
Pinos I2CA4 (SDA), A5 (SCL)20 (SDA), 21 (SCL)
Pinos SPI10, 11, 12, 1353, 51, 50, 52
Dimensões68,6 × 53,4 mm101,5 × 53,3 mm

Mapa de pinos do Arduino Mega: todos os grupos de pinos

Grupo de pinosNúmeros dos pinosFunção e observações
Pinos digitais em comum com o Uno0–130 (RX0) e 1 (TX0) são a linha serial da USB; o pino 13 tem o LED integrado
Pinos das portas seriais extras14–1914 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1
I2C20 (SDA), 21 (SCL)Biblioteca Wire; a placa tem resistores de pull-up de 10 kΩ ligados a 5 V
Barra de pinos digitais dupla22–53Entrada/saída de uso geral; sem PWM, exceto 44, 45 e 46
PWM2–13, 44, 45, 46Usados com analogWrite(pino, 0–255)
SPI50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)Os mesmos sinais também estão na barra ICSP
Entradas analógicasA0–A15 (digitais 54–69)Lidas com analogRead, também podem ser usadas como pinos digitais
Alimentação e controle5V, 3.3V, Vin, GND, IOREF, AREF, RESETAREF é a entrada de referência analógica externa; colocar RESET em LOW reinicia a placa
Cada pino de E/S do Mega suporta no máximo 40 mA; fique abaixo de 20 mA para operar com segurança. A corrente total que o processador consegue fornecer somando todos os pinos é de cerca de 200 mA. Ter 54 pinos não significa que você pode acionar 54 LEDs diretamente ao mesmo tempo, nem ligar um motor ou a bobina de um relé em um pino; isso danifica o processador. Para essas cargas, use um transistor ou um driver. Além disso, os pinos 0 e 1 estão ligados à linha serial da USB, então o código pode não carregar enquanto houver um módulo conectado neles.

Pinos PWM e timers

O Mega tem 15 saídas PWM: os 12 pinos de 2 a 13, mais o 44, o 45 e o 46. Com esses pinos você ajusta o brilho de LEDs e a velocidade de motores usando analogWrite(pino, 0–255). Os sinais PWM vêm de seis timers de hardware (Timer0–Timer5); o Timer0 e o Timer2 são de 8 bits, os demais de 16 bits. Como o Timer0 também controla millis() e delay(), os pinos 4 e 13 funcionam a cerca de 980 Hz e os demais pinos PWM a cerca de 490 Hz. O ponto principal de atenção é que, quando uma biblioteca assume um timer, o PWM nos pinos ligados a esse timer deixa de funcionar: no Mega, a biblioteca Servo usa o Timer5 para os 12 primeiros servos, então no momento em que você conecta um servo, o analogWrite para de funcionar no 44, no 45 e no 46; já o tone() usa o Timer2 e afeta os pinos 9 e 10. Você encontra ciclo de trabalho e frequência explicados em detalhes em O que é PWM?.

TimerPinos PWMFrequência padrãoCom o que entra em conflito?
Timer0 (8 bits)4, 13~980 Hzmillis() e delay()
Timer1 (16 bits)11, 12~490 HzBiblioteca Servo (servos 13–24)
Timer2 (8 bits)9, 10~490 HzFunção tone()
Timer3 (16 bits)2, 3, 5~490 HzBiblioteca Servo (servos 25–36)
Timer4 (16 bits)6, 7, 8~490 HzBiblioteca Servo (servos 37–48)
Timer5 (16 bits)44, 45, 46~490 HzBiblioteca Servo (12 primeiros servos)

4 portas seriais de hardware: Serial, Serial1, Serial2, Serial3

O Uno tem uma única porta serial de hardware, e ela é compartilhada com a USB; para um segundo dispositivo, você é obrigado a usar SoftwareSerial. O SoftwareSerial pode perder dados em velocidades altas, só consegue escutar uma porta por vez e deixa o resto do código mais lento, porque desativa as interrupções enquanto recebe bytes. O Mega tem quatro periféricos UART independentes; cada um trabalha em segundo plano com seu próprio buffer de recepção de 64 bytes, então os dados que chegam não se perdem enquanto você cuida de outras tarefas no loop(). A regra de ligação é a mesma em todas as portas: o TX do módulo vai no RX do Mega, o RX do módulo vai no TX do Mega e o GND precisa ser sempre comum. Ao ligar a saída TX de 5 V do Mega na entrada RX de um módulo que trabalha com lógica de 3,3 V, reduza o sinal para cerca de 3,3 V com um divisor de tensão de 1 kΩ e 2 kΩ. O código de ponte abaixo passa o que você digita no Monitor Serial para o Serial1 e o que chega do Serial1 de volta para o Monitor Serial; é o jeito mais rápido de testar módulos como o HC-05. Para entender como o UART funciona, veja o post sobre comunicação serial UART.

PortaPino TXPino RXUso típico
Serial10USB e Monitor Serial
Serial11819Módulo Bluetooth HC-05
Serial21617Módulo GPS NEO-6M
Serial31415GSM SIM800L ou sensor de impressão digital
C++ (Arduino IDE)
1// USB Seri Monitör <-> Serial1 köprüsü / USB Serial Monitor <-> Serial1 bridge
2// Serial1: TX1 = 18, RX1 = 19
3
4void setup() {
5  Serial.begin(9600);    // bilgisayar (USB) / computer (USB)
6  Serial1.begin(9600);   // HC-05, GPS vb. / HC-05, GPS, etc.
7  Serial.println(F("Mega seri kopru hazir / serial bridge ready"));
8}
9
10void loop() {
11  if (Serial1.available()) {        // modülden gelen veri / data from the module
12    Serial.write(Serial1.read());
13  }
14  if (Serial.available()) {         // Seri Monitör'den gelen veri / data from the Serial Monitor
15    Serial1.write(Serial.read());
16  }
17}

Pinos de interrupção

Uma interrupção externa permite captar uma mudança em um pino em microssegundos, não importa o que o loop() esteja fazendo naquele momento; é ideal para encoders, sensores de fluxo de água, tacômetros e botões que exigem resposta rápida. O Mega tem 6 pinos que podem ser usados com attachInterrupt: 2, 3, 18, 19, 20 e 21. Os números das interrupções não seguem a ordem dos pinos (2 → 0, 3 → 1, 21 → 2, 20 → 3, 19 → 4, 18 → 5); por isso, em vez de digitar o número à mão, use sempre digitalPinToInterrupt(pino). Atenção: 18 e 19 são os pinos do Serial1, e 20 e 21 são os pinos do I2C; se você usa Serial1 e I2C, sobram apenas o 2 e o 3. Se precisar de mais pinos, as interrupções por mudança de pino (PCINT) do ATmega2560 funcionam nos pinos 10–15, 50–53 e A8–A15 e podem ser usadas com bibliotecas adequadas. O código abaixo conta pulsos nos pinos 2 e 18; as funções de interrupção são curtas, os contadores compartilhados são declarados como volatile e as interrupções são pausadas brevemente durante a leitura. Como neste exemplo o 18 é usado para a interrupção, o Serial1 não pode ser usado. Para se aprofundar, leia o post sobre interrupções no Arduino.

C++ (Arduino IDE)
1// Arduino Mega: 2 ve 18 numaralı pinlerde darbe sayma / pulse counting on pins 2 and 18
2volatile unsigned long countA = 0;   // pin 2
3volatile unsigned long countB = 0;   // pin 18
4
5void onPulseA() { countA++; }        // kısa tut / keep it short
6void onPulseB() { countB++; }
7
8void setup() {
9  Serial.begin(115200);
10  pinMode(2, INPUT_PULLUP);          // buton ya da sensör GND'ye çeker / button or sensor pulls to GND
11  pinMode(18, INPUT_PULLUP);
12  attachInterrupt(digitalPinToInterrupt(2), onPulseA, FALLING);
13  attachInterrupt(digitalPinToInterrupt(18), onPulseB, FALLING);
14}
15
16void loop() {
17  noInterrupts();                    // okurken kesmeleri durdur / pause interrupts while reading
18  unsigned long a = countA;
19  unsigned long b = countB;
20  interrupts();
21
22  Serial.print(F("Pin 2: "));
23  Serial.print(a);
24  Serial.print(F("  Pin 18: "));
25  Serial.println(b);
26  delay(500);
27}

16 entradas analógicas (A0–A15)

As 16 entradas analógicas do Mega compartilham um único ADC de 10 bits por meio de um multiplexador. Cada leitura retorna um valor entre 0 e 1023; com referência de 5 V, um passo equivale a cerca de 4,9 mV. Uma conversão leva cerca de 100 microssegundos, então você consegue fazer em torno de 10.000 leituras por segundo; ou seja, varrer os 16 canais em sequência não é problema nenhum. Se precisar de medições mais precisas, você pode usar analogReference para escolher a referência interna de 1,1 V (INTERNAL1V1) ou de 2,56 V (INTERNAL2V56); a opção INTERNAL do Uno não existe no Mega. Os pinos analógicos também podem ser usados como digitais: A0 é o pino digital 54 e A15 é o pino digital 69, então escrevendo pinMode(A8, OUTPUT) você acende um LED nesse pino. Ao alternar rapidamente entre canais, a tensão do canal anterior pode vazar para a medição seguinte; em fontes com resistência interna acima de 10 kΩ, ler cada canal duas vezes e descartar o primeiro valor reduz esse erro. Você encontra como o ADC funciona no post sobre conversão analógico-digital.

C++ (Arduino IDE)
1// 16 analog kanalı sırayla oku / read all 16 analog channels in turn
2void setup() {
3  Serial.begin(115200);
4}
5
6void loop() {
7  for (byte ch = 0; ch < 16; ch++) {
8    int raw = analogRead(A0 + ch);          // A0..A15 = 54..69
9    float volts = raw * (5.0 / 1023.0);     // ham değeri volta çevir / convert raw value to volts
10    Serial.print(F("A"));
11    Serial.print(ch);
12    Serial.print(F("="));
13    Serial.print(volts, 2);
14    if (ch < 15) {
15      Serial.print(F("  "));
16    }
17  }
18  Serial.println();                         // satır sonu / end of line
19  delay(1000);
20}

Pinos I2C e SPI: compatibilidade com os shields do Uno

A diferença que mais confunde quem passa para o Mega é a posição dos pinos de comunicação. No Uno, o I2C fica no A4 e no A5 e o SPI nos pinos 10–13, enquanto no Mega o I2C fica nos pinos 20 (SDA) e 21 (SCL) e o SPI nos pinos 50–53. Nas placas R3, SDA e SCL se repetem na barra de pinos ao lado do AREF; os sinais SPI ficam no mesmo lugar nas duas placas, na barra ICSP de 6 pinos no meio. Por isso, shields que pegam o SPI da barra ICSP funcionam bem no Mega, enquanto shields antigos que pegam o SPI diretamente dos pinos 11–13 não funcionam. As bibliotecas Wire e SPI usam os pinos certos sozinhas; o seu trabalho é ligar os fios nos lugares certos. No SPI, você pode ligar o pino CS de um dispositivo em qualquer pino digital, mas nunca configure o pino 53 como entrada: se esse pino virar entrada e for levado a LOW, o processador entra em modo escravo no SPI e a comunicação para. Por exemplo, você ligaria um leitor RFID RC522 assim: SDA → 53, SCK → 52, MOSI → 51, MISO → 50. Para os detalhes dos protocolos, veja O que é I2C? e O que é SPI?.

SinalArduino UnoArduino MegaESP32Raspberry Pi Pico
I2C SDAA420GPIO 21GP4
I2C SCLA521GPIO 22GP5
SPI MISO1250GPIO 19GP16
SPI MOSI1151GPIO 23GP19
SPI SCK1352GPIO 18GP18
SPI SS / CS1053GPIO 5GP17
TX / RX da porta serial extraNenhuma (SoftwareSerial)18 / 19 (Serial1)GPIO 17 / 16 (Serial2)GP0 / GP1 (UART0)
Nível lógico5 V5 V3,3 V3,3 V

Passo a passo: seu primeiro programa no Mega (sequencial com 16 LEDs)

  1. Ligue o Mega ao computador com um cabo USB-B; se o chip USB da sua placa clone for um CH340, instale o driver dele primeiro.
  2. Na Arduino IDE, escolha Arduino Mega or Mega 2560 no menu Ferramentas > Placa e deixe o Processador como ATmega2560 (Mega 2560).
  3. Selecione a porta da placa no menu Ferramentas > Porta (algo como COM3 no Windows, ou um nome começando com /dev/cu.usbmodem ou /dev/cu.wchusbserial no macOS).
  4. Ligue 16 LEDs nos pinos 22–37, cada um com um resistor de 220 Ω, e leve as pernas curtas dos LEDs (cátodos) para a linha de GND. Um LED vermelho consome (5 − 2) / 220 ≈ 13,6 mA; para outras cores, você pode usar a calculadora Resistor para LED.
  5. Carregue o código abaixo; os LEDs vão acender um após o outro em sequência. Como só um LED fica aceso por vez, a corrente total fica abaixo de 20 mA. O efeito de vai e vem está no post efeito Super Máquina e LEDs sequenciais.
C++ (Arduino IDE)
1// Arduino Mega: 22-37 pinlerinde 16 LED'li yürüyen ışık / 16-LED chaser on pins 22-37
2const byte FIRST_PIN = 22;   // ilk LED pini / first LED pin
3const byte LED_COUNT = 16;   // 22..37
4
5void setup() {
6  for (byte i = 0; i < LED_COUNT; i++) {
7    pinMode(FIRST_PIN + i, OUTPUT);   // tüm LED pinleri çıkış / all LED pins as outputs
8  }
9}
10
11void loop() {
12  for (byte i = 0; i < LED_COUNT; i++) {
13    digitalWrite(FIRST_PIN + i, HIGH);  // LED'i yak / turn LED on
14    delay(60);
15    digitalWrite(FIRST_PIN + i, LOW);   // LED'i söndür / turn LED off
16  }
17}

Quando você precisa de um Arduino Mega?

  • Se os pinos estão acabando: só um teclado matricial 4x4 precisa de 8 pinos e um LCD em paralelo precisa de 6; some relés, botões e sensores e os 20 pinos do Uno acabam rapidinho.
  • Se você tem vários dispositivos seriais: escutar um GPS, um Bluetooth e um GSM ao mesmo tempo é quase impossível no Uno, enquanto no Mega cada um ganha sua própria porta de hardware.
  • Se a memória está acabando: se o compilador avisa que há pouca memória, ou se você está combinando display TFT, cartão SD e código de menu, 256 KB de flash e 8 KB de RAM dão muito mais folga; detalhes no post Arduino sem memória.
  • Se você tem muitos sensores analógicos: com 16 canais, você lê umidade do solo, gás, luz e potenciômetros sem precisar de multiplexador.
  • Para robôs com muitos servos: a biblioteca Servo suporta até 48 servos no Mega (12 no Uno); é uma boa opção para um braço robótico e robôs que andam.
  • Quando você não precisa de um Mega: se precisa de Wi-Fi, alta velocidade ou baixo consumo, o ESP32 faz mais sentido (Arduino ou ESP32?); se faltam só algumas saídas, expandir os pinos do Uno com um registrador de deslocamento 74HC595 é uma solução mais barata e menor.

Arduino Mega e RAMPS 1.4 nas impressoras 3D

Durante anos, a maioria das impressoras 3D do tipo faça você mesmo e das pequenas máquinas CNC funcionou com um Arduino Mega e uma placa RAMPS 1.4 encaixada por cima; essa dupla ainda é a eletrônica de impressora mais comum para fins educacionais. O motivo é simples: um firmware de impressora como o Marlin passa facilmente de 100 KB com suporte a display e cartão SD; cinco drivers de motor de passo (X, Y, Z e duas extrusoras), três saídas MOSFET, seis chaves de fim de curso, termistores, um LCD e um cartão SD também exigem dezenas de pinos. Na RAMPS, os sinais de passo e direção do eixo X estão ligados ao 54 e ao 55 (A0 e A1), os do eixo Y ao 60 e ao 61 (A6 e A7), os do eixo Z ao 46 e ao 48, e os da primeira extrusora ao 26 e ao 28. O aquecedor do bico é acionado pelo pino PWM 10, o da mesa pelo 8 e a ventoinha pelo 9; os termistores do bico e da mesa são lidos no A13 e no A14. Essa disposição também é um ótimo exemplo de como os pinos analógicos podem ser aproveitados com eficiência como saídas digitais. Para o ajuste de corrente e o micropasso dos drivers de motor de passo, dê uma olhada no post driver de motor de passo A4988.

Exemplo de projeto com vários sensores: planejando bem os pinos

MóduloPino do MegaPor que este pino?
Bluetooth HC-0518 (TX1), 19 (RX1)A comunicação com o celular usa uma porta serial de hardware, então nenhum dado se perde
GPS NEO-6M16 (TX2), 17 (RX2)O GPS envia muitas linhas por segundo e precisa de uma porta só para ele
GSM SIM800L14 (TX3), 15 (RX3)A terceira porta independente, para SMS e chamadas
LCD I2C + BME28020 (SDA), 21 (SCL)Dois dispositivos compartilham a mesma linha I2C com endereços diferentes
RFID RC52250, 51, 52, 53 + RST 49Barramento SPI de hardware, com o 53 usado como CS
Sensores de umidade do solo (4)A0–A3Os quatro primeiros dos 16 canais analógicos
Sensor de gás MQ-2A4Sensor com saída analógica
Sensor de fluxo de água2Pino de interrupção externa, para não perder nenhum pulso
Módulo relé de 8 canais22–29Saídas digitais simples que não precisam de PWM
Ventoinha (via MOSFET)6PWM para controle de velocidade (Timer4)
Servo (tampa)8O sinal do servo pode sair de qualquer pino digital; como o Timer5 é usado, 44–46 não podem ser usados para PWM

Erros comuns e como resolver

SintomaCausaSolução
O código não carrega, erro de timeout do avrdudeA placa continua configurada como Uno, a porta está errada ou há um módulo ligado nos pinos 0 e 1Selecione Mega 2560 e a porta correta no menu Ferramentas e desconecte os fios do 0 e do 1 durante o carregamento
Display ou sensor I2C não é encontradoOs fios foram ligados no A4 e no A5 por costume do UnoLigue SDA no 20 e SCL no 21
O módulo SPI do shield não funcionaO shield pega os sinais SPI dos pinos 11–13Use a barra ICSP ou os pinos 50–52
O analogWrite parou no 44–46 depois de adicionar um servoA biblioteca Servo usa o Timer5Passe a saída PWM para um pino entre 2 e 13
O SoftwareSerial não recebe dadosO pino RX escolhido não suporta interrupção por mudança de pinoUse as portas de hardware Serial1, Serial2 ou Serial3
A placa esquenta ou reinicia sozinhaUm motor, a bobina de um relé ou muitos LEDs estão sendo acionados direto pelos pinosUse um transistor, MOSFET ou driver de motor e adicione uma fonte externa
Os valores analógicos ficam oscilandoLeitura de uma entrada flutuante ou vazamento entre canaisLeia só os canais com sensor ligado e leia cada canal duas vezes, tirando a média
Escreva seu plano de pinos no papel antes de começar o projeto: posicione primeiro os pinos com função especial (portas seriais, I2C, SPI, interrupções e PWM) e distribua por último os pinos digitais simples entre 22 e 53. Seguindo essa ordem, você não vai precisar arrancar fios no meio do projeto. Para comparar os pinos visualmente, use a ferramenta Pinagem e, para leituras de sensor com ruído, o post sobre filtragem de dados de sensores.

O Arduino Mega é o passo mais fácil para quem já conhece o Uno: o mesmo código, as mesmas bibliotecas, mas muito mais pinos, portas e memória. Os guias Pinagem do Arduino Uno e Pinagem do Arduino Nano também vão ajudar em projetos menores. No app BlueGrays, você pode seguir passo a passo, com esquema do circuito e código, projetos que pedem muitos pinos, como um relógio digital com display de 7 segmentos de 4 dígitos, uma fechadura com senha usando teclado matricial e LCD, um robô que desvia de obstáculos e um cofre eletrônico inteligente, e adaptar a disposição dos pinos ao seu próprio Mega.

Perguntas frequentes

Quantos pinos tem o Arduino Mega?

O Arduino Mega 2560 tem 70 pinos de sinal no total: 54 de entrada/saída digital e 16 entradas analógicas. 15 dos pinos digitais fornecem saída PWM, e os pinos analógicos (A0–A15) também podem ser usados como os pinos digitais 54–69 quando necessário. Além disso, há pinos de alimentação e controle como 5V, 3.3V, Vin, GND, AREF, IOREF e RESET.

Quais são os pinos PWM do Arduino Mega?

No Mega, os pinos de 2 a 13 e os pinos 44, 45 e 46 fornecem PWM, totalizando 15 saídas PWM. Os pinos 4 e 13 funcionam a cerca de 980 Hz e os demais a cerca de 490 Hz. Quando a biblioteca Servo é usada, o PWM no 44, no 45 e no 46 fica desativado.

Onde ficam os pinos SDA e SCL do Arduino Mega?

No Mega, o barramento I2C fica nos pinos 20 (SDA) e 21 (SCL); nas placas R3, os mesmos sinais também estão na barra de pinos ao lado do AREF. No Mega, A4 e A5 são entradas analógicas comuns, e não I2C como no Uno. O SPI fica nos pinos 50 (MISO), 51 (MOSI), 52 (SCK) e 53 (SS) e na barra ICSP.

Código do Arduino Uno funciona no Mega?

A maior parte do código do Uno compila e roda no Mega sem nenhuma alteração; você só precisa selecionar Mega 2560 como placa no menu Ferramentas. Os problemas costumam aparecer no lado do hardware: os pinos I2C e SPI ficam em outros lugares, e códigos que acessam diretamente registradores de timers e portas precisam ser reorganizados. Passar códigos que usam SoftwareSerial para as portas seriais de hardware do Mega também dá resultados mais confiáveis.

Quais são os pinos de interrupção do Arduino Mega?

Os pinos de interrupção externa que podem ser usados com attachInterrupt são 2, 3, 18, 19, 20 e 21. Como 18 e 19 são compartilhados com o Serial1, e 20 e 21 com o I2C, se você usa esses barramentos sobram livres apenas o 2 e o 3. Usar digitalPinToInterrupt(pino) em vez de digitar o número da interrupção à mão evita erros.

Posso ligar um sensor de 3,3 V no Arduino Mega?

Sim, mas com cuidado. O Mega trabalha com lógica de 5 V; em geral ele lê uma saída de 3,3 V como HIGH, mas a saída de 5 V do Mega pode danificar uma entrada de 3,3 V. Por isso, use um divisor de tensão ou um conversor de nível lógico nos pinos de entrada do módulo; no I2C, prefira um conversor de nível bidirecional por causa dos resistores de pull-up de 5 V da placa.

Ver todos os projetos
Sequencial de LEDs
AR-5Intermediário

Sequencial de LEDs

Luzes que acendem uma após a outra, como se estivessem correndo. O Arduino acende seis LEDs, um de cada vez; cada um brilha por um instante e apaga, fazendo a luz percorrer a sequência do início ao…

4.6(87)
218
Efeito Knight Rider com LEDs
AR-6Intermediário

Efeito Knight Rider com LEDs

O clássico efeito Knight Rider: um ponto de luz percorre seis LEDs de uma ponta à outra e depois volta.

4.8(107)
214
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

Medição de distância com HC-SR04 (Monitor Serial)

O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

4.6(50)
82
Relógio digital com display de 7 segmentos de 4 dígitos
AR-48Intermediário
Premium

Relógio digital com display de 7 segmentos de 4 dígitos

Um relógio digital luminoso de quatro dígitos, parecido com o de um forno de cozinha.

4.8(56)
73
Fechadura com senha, teclado 4x4 e LCD
AR-64Avançado
Premium

Fechadura com senha, teclado 4x4 e LCD

Uma pequena fechadura eletrônica que impede a entrada de quem não sabe a senha. Você pressiona a cerquilha e digita a senha no teclado.

4.8(59)
75
Robô que desvia de obstáculos
AR-81Avançado
Premium

Robô que desvia de obstáculos

Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

5.0(38)
49
Cofre eletrônico inteligente
AR-92Avançado
Premium

Cofre eletrônico inteligente

Um pequeno cofre para guardar seus objetos de valor, que abre com uma senha. Você digita sua senha de quatro dígitos no teclado; se estiver correta, o servo motor abre a trava, a luz verde acende e o…

4.7(42)
63
Coreografia em círculo: animações com 32 servos
AR-97Avançado
Premium

Coreografia em círculo: animações com 32 servos

Um projeto de animação visual com 32 servo motores dispostos em círculo e controlados por um Arduino Mega. Os servos são gerenciados em um único array e conectados aos pinos 22–53 do Mega. Eles executam quatro sequências de movimento: uma vibração caótica em que todos vão para ângulos aleatórios, uma varredura sincronizada em que todos se movem ao mesmo tempo, uma onda que gira suavemente pelo círculo e, por fim, uma agulha de bússola que oscila de um lado para o outro.

4.5(40)
62