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.

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ística | Valor |
|---|---|
| Microcontrolador | ATmega2560 (AVR de 8 bits) |
| Velocidade de clock | 16 MHz |
| Memória flash | 256 KB (8 KB usados pelo bootloader) |
| SRAM | 8 KB |
| EEPROM | 4 KB |
| Tensão de operação | 5 V |
| Tensão de entrada (conector DC / Vin) | 7–12 V recomendado, 6–20 V limite |
| E/S digitais | 54 (15 delas com PWM) |
| Entradas analógicas | 16 (A0–A15, 10 bits) |
| Portas seriais de hardware | 4 (Serial, Serial1, Serial2, Serial3) |
| Pinos de interrupção externa | 6 |
| Corrente por pino | 20 mA recomendado, 40 mA máximo absoluto |
| Corrente do pino 3.3V | 50 mA no máximo |
| Dimensões | 101,5 × 53,3 mm |
Comparação entre Arduino Mega e Uno
| Característica | Arduino Uno R3 | Arduino Mega 2560 |
|---|---|---|
| Microcontrolador | ATmega328P | ATmega2560 |
| Velocidade de clock | 16 MHz | 16 MHz |
| Pinos digitais | 14 | 54 |
| Pinos PWM | 6 (3, 5, 6, 9, 10, 11) | 15 (2–13, 44, 45, 46) |
| Entradas analógicas | 6 (A0–A5) | 16 (A0–A15) |
| Portas seriais de hardware | 1 | 4 |
| Pinos de interrupção externa | 2 (2, 3) | 6 (2, 3, 18, 19, 20, 21) |
| Flash / SRAM / EEPROM | 32 KB / 2 KB / 1 KB | 256 KB / 8 KB / 4 KB |
| Pinos I2C | A4 (SDA), A5 (SCL) | 20 (SDA), 21 (SCL) |
| Pinos SPI | 10, 11, 12, 13 | 53, 51, 50, 52 |
| Dimensões | 68,6 × 53,4 mm | 101,5 × 53,3 mm |
Mapa de pinos do Arduino Mega: todos os grupos de pinos
| Grupo de pinos | Números dos pinos | Função e observações |
|---|---|---|
| Pinos digitais em comum com o Uno | 0–13 | 0 (RX0) e 1 (TX0) são a linha serial da USB; o pino 13 tem o LED integrado |
| Pinos das portas seriais extras | 14–19 | 14 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1 |
| I2C | 20 (SDA), 21 (SCL) | Biblioteca Wire; a placa tem resistores de pull-up de 10 kΩ ligados a 5 V |
| Barra de pinos digitais dupla | 22–53 | Entrada/saída de uso geral; sem PWM, exceto 44, 45 e 46 |
| PWM | 2–13, 44, 45, 46 | Usados com analogWrite(pino, 0–255) |
| SPI | 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS) | Os mesmos sinais também estão na barra ICSP |
| Entradas analógicas | A0–A15 (digitais 54–69) | Lidas com analogRead, também podem ser usadas como pinos digitais |
| Alimentação e controle | 5V, 3.3V, Vin, GND, IOREF, AREF, RESET | AREF é a entrada de referência analógica externa; colocar RESET em LOW reinicia a placa |
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?.
| Timer | Pinos PWM | Frequência padrão | Com o que entra em conflito? |
|---|---|---|---|
| Timer0 (8 bits) | 4, 13 | ~980 Hz | millis() e delay() |
| Timer1 (16 bits) | 11, 12 | ~490 Hz | Biblioteca Servo (servos 13–24) |
| Timer2 (8 bits) | 9, 10 | ~490 Hz | Função tone() |
| Timer3 (16 bits) | 2, 3, 5 | ~490 Hz | Biblioteca Servo (servos 25–36) |
| Timer4 (16 bits) | 6, 7, 8 | ~490 Hz | Biblioteca Servo (servos 37–48) |
| Timer5 (16 bits) | 44, 45, 46 | ~490 Hz | Biblioteca 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.
| Porta | Pino TX | Pino RX | Uso típico |
|---|---|---|---|
| Serial | 1 | 0 | USB e Monitor Serial |
| Serial1 | 18 | 19 | Módulo Bluetooth HC-05 |
| Serial2 | 16 | 17 | Módulo GPS NEO-6M |
| Serial3 | 14 | 15 | GSM SIM800L ou sensor de impressão digital |
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.
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.
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?.
| Sinal | Arduino Uno | Arduino Mega | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| I2C SDA | A4 | 20 | GPIO 21 | GP4 |
| I2C SCL | A5 | 21 | GPIO 22 | GP5 |
| SPI MISO | 12 | 50 | GPIO 19 | GP16 |
| SPI MOSI | 11 | 51 | GPIO 23 | GP19 |
| SPI SCK | 13 | 52 | GPIO 18 | GP18 |
| SPI SS / CS | 10 | 53 | GPIO 5 | GP17 |
| TX / RX da porta serial extra | Nenhuma (SoftwareSerial) | 18 / 19 (Serial1) | GPIO 17 / 16 (Serial2) | GP0 / GP1 (UART0) |
| Nível lógico | 5 V | 5 V | 3,3 V | 3,3 V |
Passo a passo: seu primeiro programa no Mega (sequencial com 16 LEDs)
- 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.
- Na Arduino IDE, escolha Arduino Mega or Mega 2560 no menu Ferramentas > Placa e deixe o Processador como ATmega2560 (Mega 2560).
- 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).
- 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.
- 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.
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ódulo | Pino do Mega | Por que este pino? |
|---|---|---|
| Bluetooth HC-05 | 18 (TX1), 19 (RX1) | A comunicação com o celular usa uma porta serial de hardware, então nenhum dado se perde |
| GPS NEO-6M | 16 (TX2), 17 (RX2) | O GPS envia muitas linhas por segundo e precisa de uma porta só para ele |
| GSM SIM800L | 14 (TX3), 15 (RX3) | A terceira porta independente, para SMS e chamadas |
| LCD I2C + BME280 | 20 (SDA), 21 (SCL) | Dois dispositivos compartilham a mesma linha I2C com endereços diferentes |
| RFID RC522 | 50, 51, 52, 53 + RST 49 | Barramento SPI de hardware, com o 53 usado como CS |
| Sensores de umidade do solo (4) | A0–A3 | Os quatro primeiros dos 16 canais analógicos |
| Sensor de gás MQ-2 | A4 | Sensor com saída analógica |
| Sensor de fluxo de água | 2 | Pino de interrupção externa, para não perder nenhum pulso |
| Módulo relé de 8 canais | 22–29 | Saídas digitais simples que não precisam de PWM |
| Ventoinha (via MOSFET) | 6 | PWM para controle de velocidade (Timer4) |
| Servo (tampa) | 8 | O 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
| Sintoma | Causa | Solução |
|---|---|---|
| O código não carrega, erro de timeout do avrdude | A placa continua configurada como Uno, a porta está errada ou há um módulo ligado nos pinos 0 e 1 | Selecione 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 é encontrado | Os fios foram ligados no A4 e no A5 por costume do Uno | Ligue SDA no 20 e SCL no 21 |
| O módulo SPI do shield não funciona | O shield pega os sinais SPI dos pinos 11–13 | Use a barra ICSP ou os pinos 50–52 |
| O analogWrite parou no 44–46 depois de adicionar um servo | A biblioteca Servo usa o Timer5 | Passe a saída PWM para um pino entre 2 e 13 |
| O SoftwareSerial não recebe dados | O pino RX escolhido não suporta interrupção por mudança de pino | Use as portas de hardware Serial1, Serial2 ou Serial3 |
| A placa esquenta ou reinicia sozinha | Um motor, a bobina de um relé ou muitos LEDs estão sendo acionados direto pelos pinos | Use um transistor, MOSFET ou driver de motor e adicione uma fonte externa |
| Os valores analógicos ficam oscilando | Leitura de uma entrada flutuante ou vazamento entre canais | Leia só os canais com sensor ligado e leia cada canal duas vezes, tirando a média |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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…

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.

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.

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.

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.

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.

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…

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

