/*
* EMPILHADEIRA DIDATICA - ARDUINO MEGA 2560 - WOKWI
* Firmware sem delay() / pulseIn(), com intertravamentos por nivel.
* Wokwi: chaves representam saídas dos radares e dos indutivos.
* Wokwi: LEDs representam os comandos do L298N. Buzzer piezo via tone().
*
* ATENCAO: NAO E SISTEMA DE SEGURANCA FUNCIONAL CERTIFICADO.
* O botao de emergencia deve cortar fisicamente a energia dos motores,
* em circuito apropriado (contator/rele/driver com seguranca),
* independente do Arduino. Nunca usar este prototipo para transportar pessoas.
*
* ALTERACOES DE HARDWARE EM RELACAO AO PROJETO ORIGINAL:
* - HC-SR04 ECHO: pino 18 (antes 32), usando interrupcao CHANGE.
* - Emergencia: contato NF entre pino 2 e GND; normal=LOW,
* pressionado ou fio rompido=HIGH (interrupcao RISING).
* - Reset de seguranca: botao NA separado, pino 3 e GND, pull-up.
* - ENA/ENB: remover os jumpers da L298N.
* - LD2410C: OUT -> D34/D35; 5V regulados; GND comum.
* - Indutivos NPN coletor aberto: OUT -> D36/D37, com interface segura
* de nivel, pull-up no lado Arduino e GND conforme projeto eletrico.
*
* Demais pinos: joystick esquerdo A0, direito A1;
* L298N: ENA 5, IN1 22, IN2 23; ENB 6, IN3 24, IN4 25.
* LED vermelho 30, TRIG 31, buzzer 33, amarelo 38, azul 39.
*
* Tempos: verificacao de sensores a cada volta do loop;
* comando PWM a cada 10 ms (paradas, sem espera);
* 3 s de retencao APOS desaparecer a deteccao;
* eco ultrassom por interrupcao, timeout 25 ms;
* disparo ultrassom a cada 60 ms;
* reset manual: 2 s com botao de reset pressionado.
*/
#include <Arduino.h>
#include <util/atomic.h>
#include <stdio.h>
// ---------------- MAPEAMENTO ----------------
constexpr uint8_t PIN_EMERGENCIA = 2;
constexpr uint8_t PIN_RESET = 3;
constexpr uint8_t PIN_JOY_ESQ = A0;
constexpr uint8_t PIN_JOY_DIR = A1;
constexpr uint8_t PIN_ENA = 5, PIN_IN1 = 22, PIN_IN2 = 23;
constexpr uint8_t PIN_ENB = 6, PIN_IN3 = 24, PIN_IN4 = 25;
constexpr uint8_t PIN_LED_VERMELHO = 30;
constexpr uint8_t PIN_TRIG = 31;
constexpr uint8_t PIN_ECHO = 18; // USAR D18, nao D32
constexpr uint8_t PIN_BUZZER = 33;
constexpr uint8_t PIN_RADAR_FRENTE = 34;
constexpr uint8_t PIN_RADAR_TRAS = 35;
constexpr uint8_t PIN_INDUTIVO_1 = 36;
constexpr uint8_t PIN_INDUTIVO_2 = 37;
constexpr uint8_t PIN_LED_AMARELO = 38;
constexpr uint8_t PIN_LED_AZUL = 39;
// ---------------- PARAMETROS ----------------
constexpr uint32_t TEMPO_RETENCAO_MS = 3000UL;
constexpr uint32_t TEMPO_BOOT_MS = 2000UL; // retencao inicial, NAO atesta sensor pronto
constexpr uint32_t TEMPO_LED_TESTE_MS = 1000UL;
constexpr uint32_t TEMPO_RESET_MS = 2000UL;
constexpr uint32_t TEMPO_PWM_MS = 10UL;
constexpr uint32_t TEMPO_LOG_MS = 500UL;
constexpr uint32_t TEMPO_BIP_MS = 60UL;
constexpr uint32_t ULTRA_PERIODO_US = 60000UL;
constexpr uint32_t ULTRA_TRIG_US = 12UL;
constexpr uint32_t ULTRA_TIMEOUT_US = 25000UL;
constexpr int ZONA_MORTA = 60;
constexpr int CENTRO_JOY = 512;
constexpr int VEL_MAXIMA = 255;
constexpr int DIST_ALERTA_CM = 60;
constexpr int DIST_CRITICA_CM = 10;
constexpr bool INVERTER_JOY_ESQ = false;
constexpr bool INVERTER_JOY_DIR = false;
constexpr bool INDUTIVO_ATIVO_EM_LOW = true;
constexpr bool RADAR_ATIVO_EM_HIGH = true;
// ---------------- FLAGS / ESTADOS ----------------
volatile bool emergenciaTravada = true; // sempre exige reset manual apos energizar
// Compartilhados com ISR do eco. Variaveis multi-byte sao lidas atomicamente.
volatile bool ultraCapturando = false;
volatile bool ecoSubiu = false;
volatile bool ecoPronto = false;
volatile uint32_t ecoInicioUs = 0;
volatile uint32_t ecoLarguraUs = 0;
enum EstadoUltra : uint8_t { ULTRA_ESPERA, ULTRA_TRIG_ALTO, ULTRA_AGUARDA_ECO };
EstadoUltra estadoUltra = ULTRA_ESPERA;
uint32_t ultimoTrigUs = 0;
uint32_t instanteTrigUs = 0;
uint32_t inicioEsperaEcoUs = 0;
int distanciaCm = -1; // -1: sem eco (pode ser fora do alcance ou falha)
uint32_t inicioSistemaMs = 0;
uint32_t ultimoPWMms = 0;
uint32_t ultimoLogMs = 0;
uint32_t ultimaPessoaMs = 0;
uint32_t ultimoMetalMs = 0;
bool pessoaJaDetectada = false;
bool metalJaDetectado = false;
bool radarFrente = false;
bool radarTras = false;
bool indutivo1 = false;
bool indutivo2 = false;
bool pessoaBloqueada = false;
bool metalBloqueado = false;
bool movimentoArmado = false;
bool resetFoiSolto = false;
bool contandoReset = false;
uint32_t inicioResetMs = 0;
bool buzzerLigado = false;
bool alertaBuzzerAnterior = false;
uint32_t ultimaMudancaBuzzerMs = 0;
// ---------------- ISR: MINIMAS ----------------
void isrEmergencia() {
emergenciaTravada = true;
// Desabilita PWM de imediato; contato de seguranca FISICO e obrigatorio.
digitalWrite(PIN_ENA, LOW);
digitalWrite(PIN_ENB, LOW);
}
void isrEco() {
if (!ultraCapturando) return;
const uint32_t agoraUs = micros();
if (digitalRead(PIN_ECHO) == HIGH) {
ecoInicioUs = agoraUs;
ecoSubiu = true;
} else if (ecoSubiu && !ecoPronto) {
ecoLarguraUs = agoraUs - ecoInicioUs;
ecoPronto = true;
ecoSubiu = false;
}
}
// ---------------- MOTORES ----------------
void pararMotores() {
// Prioridade de corte do enable (e do PWM) antes de alterar direcao.
digitalWrite(PIN_ENA, LOW);
digitalWrite(PIN_ENB, LOW);
digitalWrite(PIN_IN1, LOW);
digitalWrite(PIN_IN2, LOW);
digitalWrite(PIN_IN3, LOW);
digitalWrite(PIN_IN4, LOW);
}
void acionarMotor(uint8_t en, uint8_t inA, uint8_t inB, int velocidade) {
velocidade = constrain(velocidade, -VEL_MAXIMA, VEL_MAXIMA);
// Desabilitar EN antes de mudar o sentido, evitando transitorio na ponte.
analogWrite(en, 0);
if (velocidade > 0) {
digitalWrite(inA, HIGH);
digitalWrite(inB, LOW);
} else if (velocidade < 0) {
digitalWrite(inA, LOW);
digitalWrite(inB, HIGH);
} else {
digitalWrite(inA, LOW);
digitalWrite(inB, LOW);
}
analogWrite(en, abs(velocidade));
}
int lerJoystick(uint8_t pino, bool inverter) {
int bruto = analogRead(pino) - CENTRO_JOY;
if (abs(bruto) <= ZONA_MORTA) return 0;
int velocidade;
if (bruto > 0)
velocidade = map(bruto, ZONA_MORTA, 511, 0, VEL_MAXIMA);
else
velocidade = map(bruto, -512, -ZONA_MORTA, -VEL_MAXIMA, 0);
velocidade = constrain(velocidade, -VEL_MAXIMA, VEL_MAXIMA);
return inverter ? -velocidade : velocidade;
}
// ---------------- LEITURA E INTERTRAVAMENTO ----------------
void atualizarSensores(uint32_t agoraMs) {
// HIGH = presenca para LD2410C; LOW = metal para NPN NA.
radarFrente = digitalRead(PIN_RADAR_FRENTE) == (RADAR_ATIVO_EM_HIGH ? HIGH : LOW);
radarTras = digitalRead(PIN_RADAR_TRAS) == (RADAR_ATIVO_EM_HIGH ? HIGH : LOW);
indutivo1 = digitalRead(PIN_INDUTIVO_1) == (INDUTIVO_ATIVO_EM_LOW ? LOW : HIGH);
indutivo2 = digitalRead(PIN_INDUTIVO_2) == (INDUTIVO_ATIVO_EM_LOW ? LOW : HIGH);
if (radarFrente || radarTras) {
pessoaJaDetectada = true;
ultimaPessoaMs = agoraMs;
}
if (indutivo1 || indutivo2) {
metalJaDetectado = true;
ultimoMetalMs = agoraMs;
}
pessoaBloqueada = (radarFrente || radarTras) ||
(pessoaJaDetectada &&
(uint32_t)(agoraMs - ultimaPessoaMs) < TEMPO_RETENCAO_MS);
metalBloqueado = (indutivo1 || indutivo2) ||
(metalJaDetectado &&
(uint32_t)(agoraMs - ultimoMetalMs) < TEMPO_RETENCAO_MS);
// Ativo por NIVEL, nao depende de bordas de deteccao.
if (digitalRead(PIN_EMERGENCIA) == HIGH) emergenciaTravada = true;
}
bool duranteBoot(uint32_t agoraMs) {
return (uint32_t)(agoraMs - inicioSistemaMs) < TEMPO_BOOT_MS;
}
void atualizarReset(uint32_t agoraMs, int velEsq, int velDir) {
if (!emergenciaTravada) {
resetFoiSolto = false;
contandoReset = false;
return;
}
bool resetPressionado = digitalRead(PIN_RESET) == LOW;
if (!resetPressionado) {
resetFoiSolto = true;
contandoReset = false;
return;
}
bool liberacaoPermitida = resetFoiSolto &&
digitalRead(PIN_EMERGENCIA) == LOW &&
!pessoaBloqueada && !metalBloqueado &&
!duranteBoot(agoraMs) && velEsq == 0 && velDir == 0;
if (!liberacaoPermitida) {
contandoReset = false;
return;
}
if (!contandoReset) {
contandoReset = true;
inicioResetMs = agoraMs;
} else if ((uint32_t)(agoraMs - inicioResetMs) >= TEMPO_RESET_MS) {
// Verifica novamente a condicao fisica antes de liberar a trava.
if (!pessoaBloqueada && !metalBloqueado) {
// Pequena secao atomica: a ISR nao pode travar e perder a trava
// entre a ultima leitura do NF e a liberacao por software.
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
if (digitalRead(PIN_EMERGENCIA) == LOW) {
emergenciaTravada = false;
movimentoArmado = false;
}
}
}
contandoReset = false;
resetFoiSolto = false;
}
}
void atualizarControleMotores(uint32_t agoraMs, int velEsq, int velDir) {
bool bloqueado = emergenciaTravada ||
digitalRead(PIN_EMERGENCIA) == HIGH ||
pessoaBloqueada || metalBloqueado || duranteBoot(agoraMs);
// Uma parada desarma o comando: exige voltar joysticks ao centro.
if (bloqueado) movimentoArmado = false;
else if (velEsq == 0 && velDir == 0) movimentoArmado = true;
if (bloqueado || !movimentoArmado) {
pararMotores(); // executado em TODA volta do loop, sem aguardar 10 ms
return;
}
if ((uint32_t)(agoraMs - ultimoPWMms) < TEMPO_PWM_MS) return;
ultimoPWMms = agoraMs;
acionarMotor(PIN_ENA, PIN_IN1, PIN_IN2, velEsq);
acionarMotor(PIN_ENB, PIN_IN3, PIN_IN4, velDir);
// Protege contra corrida com ISR ocorrida durante atualizacao do PWM.
if (emergenciaTravada || digitalRead(PIN_EMERGENCIA) == HIGH) pararMotores();
}
// ---------------- HC-SR04 NAO BLOQUEANTE ----------------
void atualizarUltrassom() {
const uint32_t agoraUs = micros();
switch (estadoUltra) {
case ULTRA_ESPERA:
if ((uint32_t)(agoraUs - ultimoTrigUs) >= ULTRA_PERIODO_US &&
digitalRead(PIN_ECHO) == LOW) {
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
ultraCapturando = false;
ecoSubiu = false;
ecoPronto = false;
}
digitalWrite(PIN_TRIG, HIGH);
instanteTrigUs = agoraUs;
ultimoTrigUs = agoraUs;
estadoUltra = ULTRA_TRIG_ALTO;
}
break;
case ULTRA_TRIG_ALTO:
if ((uint32_t)(agoraUs - instanteTrigUs) >= ULTRA_TRIG_US) {
digitalWrite(PIN_TRIG, LOW);
inicioEsperaEcoUs = micros();
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
ecoSubiu = false;
ecoPronto = false;
ultraCapturando = true;
}
estadoUltra = ULTRA_AGUARDA_ECO;
}
break;
case ULTRA_AGUARDA_ECO: {
uint32_t largura = 0;
bool pronto = false;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
if (ecoPronto) {
largura = ecoLarguraUs;
ecoPronto = false;
ultraCapturando = false;
pronto = true;
}
}
if (pronto) {
// Ignora pulsos impossiveis e fora da janela esperada.
distanciaCm = (largura >= 100UL && largura <= ULTRA_TIMEOUT_US)
? (int)(largura / 58UL) : -1;
estadoUltra = ULTRA_ESPERA;
} else if ((uint32_t)(agoraUs - inicioEsperaEcoUs) >= ULTRA_TIMEOUT_US) {
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
ultraCapturando = false;
ecoSubiu = false;
ecoPronto = false;
}
distanciaCm = -1; // timeout: falha de leitura OU objeto fora do alcance
estadoUltra = ULTRA_ESPERA;
}
break;
}
}
}
// ---------------- SAIDAS ----------------
void atualizarLeds(uint32_t agoraMs) {
digitalWrite(PIN_LED_VERMELHO, HIGH);
if ((uint32_t)(agoraMs - inicioSistemaMs) < TEMPO_LED_TESTE_MS) {
digitalWrite(PIN_LED_AMARELO, HIGH);
digitalWrite(PIN_LED_AZUL, HIGH);
} else if (emergenciaTravada) {
bool pisca = ((agoraMs / 250UL) & 1U) != 0;
digitalWrite(PIN_LED_AMARELO, pisca ? HIGH : LOW);
digitalWrite(PIN_LED_AZUL, pisca ? HIGH : LOW);
} else {
digitalWrite(PIN_LED_AMARELO, pessoaBloqueada ? HIGH : LOW);
digitalWrite(PIN_LED_AZUL, metalBloqueado ? HIGH : LOW);
}
}
void atualizarBuzzer(uint32_t agoraMs, bool comandoDeRe) {
bool alerta = !emergenciaTravada && comandoDeRe &&
distanciaCm >= 0 && distanciaCm <= DIST_ALERTA_CM;
if (!alerta) {
noTone(PIN_BUZZER);
buzzerLigado = false;
alertaBuzzerAnterior = false;
return;
}
if (distanciaCm <= DIST_CRITICA_CM) {
tone(PIN_BUZZER, 2000);
buzzerLigado = true;
alertaBuzzerAnterior = true;
ultimaMudancaBuzzerMs = agoraMs;
return;
}
if (!alertaBuzzerAnterior) {
tone(PIN_BUZZER, 2000);
buzzerLigado = true;
ultimaMudancaBuzzerMs = agoraMs;
alertaBuzzerAnterior = true;
return;
}
const uint32_t esperaOffMs = (uint32_t)map(distanciaCm,
DIST_CRITICA_CM, DIST_ALERTA_CM, 80L, 600L);
const uint32_t prazo = buzzerLigado ? TEMPO_BIP_MS : esperaOffMs;
if ((uint32_t)(agoraMs - ultimaMudancaBuzzerMs) >= prazo) {
buzzerLigado = !buzzerLigado;
if (buzzerLigado) tone(PIN_BUZZER, 2000);
else noTone(PIN_BUZZER);
ultimaMudancaBuzzerMs = agoraMs;
}
}
void atualizarDiagnostico(uint32_t agoraMs) {
if ((uint32_t)(agoraMs - ultimoLogMs) < TEMPO_LOG_MS) return;
ultimoLogMs = agoraMs;
char buffer[64];
// Sensores independentes: radar F/T; indutivo 1/2; bloqueios P/M.
int n = snprintf(buffer, sizeof(buffer),
"R:%u%u I:%u%u BP:%u BM:%u EM:%u ARM:%u U:%d\n",
(unsigned)radarFrente, (unsigned)radarTras,
(unsigned)indutivo1, (unsigned)indutivo2,
(unsigned)pessoaBloqueada, (unsigned)metalBloqueado,
(unsigned)emergenciaTravada, (unsigned)movimentoArmado,
distanciaCm);
// Escreve somente se couber no buffer TX, evitando espera por Serial.
if (n > 0 && n < (int)sizeof(buffer) && Serial.availableForWrite() >= n) {
Serial.write((const uint8_t*)buffer, (size_t)n);
}
}
// ---------------- SETUP / LOOP ----------------
void setup() {
pinMode(PIN_ENA, OUTPUT);
pinMode(PIN_ENB, OUTPUT);
pinMode(PIN_IN1, OUTPUT);
pinMode(PIN_IN2, OUTPUT);
pinMode(PIN_IN3, OUTPUT);
pinMode(PIN_IN4, OUTPUT);
pararMotores();
pinMode(PIN_EMERGENCIA, INPUT_PULLUP); // NF: normal LOW, emergencia HIGH
pinMode(PIN_RESET, INPUT_PULLUP); // NA: pressionado LOW
pinMode(PIN_JOY_ESQ, INPUT);
pinMode(PIN_JOY_DIR, INPUT);
pinMode(PIN_RADAR_FRENTE, INPUT);
pinMode(PIN_RADAR_TRAS, INPUT);
pinMode(PIN_INDUTIVO_1, INPUT_PULLUP);
pinMode(PIN_INDUTIVO_2, INPUT_PULLUP);
pinMode(PIN_LED_VERMELHO, OUTPUT);
pinMode(PIN_LED_AMARELO, OUTPUT);
pinMode(PIN_LED_AZUL, OUTPUT);
pinMode(PIN_BUZZER, OUTPUT);
pinMode(PIN_TRIG, OUTPUT);
pinMode(PIN_ECHO, INPUT);
digitalWrite(PIN_TRIG, LOW);
digitalWrite(PIN_BUZZER, LOW);
digitalWrite(PIN_LED_VERMELHO, HIGH);
digitalWrite(PIN_LED_AMARELO, HIGH);
digitalWrite(PIN_LED_AZUL, HIGH);
inicioSistemaMs = millis();
ultimoTrigUs = micros() - ULTRA_PERIODO_US;
attachInterrupt(digitalPinToInterrupt(PIN_EMERGENCIA), isrEmergencia, RISING);
attachInterrupt(digitalPinToInterrupt(PIN_ECHO), isrEco, CHANGE);
emergenciaTravada = true; // requer rearmamento deliberado apos boot
Serial.begin(115200);
Serial.println(F("Empilhadeira: parada na partida. Solte E-STOP e segure RESET 2 s."));
}
void loop() {
const uint32_t agoraMs = millis();
// 1. Leitura das entradas (sempre, inclusive durante emergencia).
atualizarSensores(agoraMs);
const int cmdEsq = lerJoystick(PIN_JOY_ESQ, INVERTER_JOY_ESQ);
const int cmdDir = lerJoystick(PIN_JOY_DIR, INVERTER_JOY_DIR);
// 2. Captura assincrona do ultrassom (a largura do ECHO e medida na ISR).
atualizarUltrassom();
// 3. Maquina de estados de reset, sem desabilitar interrupcoes por 2 s.
atualizarReset(agoraMs, cmdEsq, cmdDir);
// 4. Intertravamento e motores; parada prevalece sobre intervalo de PWM.
atualizarControleMotores(agoraMs, cmdEsq, cmdDir);
// 5. Sinalizacao e diagnostico de baixa prioridade.
atualizarLeds(agoraMs);
atualizarBuzzer(agoraMs, cmdEsq < 0 || cmdDir < 0);
atualizarDiagnostico(agoraMs);
}
EMPILHADEIRA DIDATICA - ARDUINO MEGA 2560 - SIMULACAO WOKWI
Radares e indutivos: chaves simulam apenas as SAIDAS digitais (nao o sensor fisico).
L298N/Motores: LEDs PWM e direcao representam sinais do driver; motores DC nao modelados.
JOYSTICKS (eixo VERT / VRy)
ESQUERDO - A0
DIREITO - A1
EMERGENCIA (NC): esquerda=NORMAL, direita=PARADA
REARME: segurar 2 s apos boot, com joysticks no centro
RADARES LD2410C (SIMULADOS): esquerda=SEM PESSOA, direita=PESSOA
FRONTAL - D34
TRASEIRO - D35
INDUTIVOS NPN/PC817 (SIMULADOS): esquerda=LIVRE, direita=METAL
INDUTIVO 1 - D36
INDUTIVO 2 - D37
HC-SR04 TRASEIRO
TRIG = D31 | ECHO = D18 (INT)
L298N - SINAIS DO DRIVER / LEDS INDICADORES
PWM 5/6: brilho ~ velocidade. INx: sentido de giro.
MOTOR ESQUERDO
MOTOR DIREITO
No projeto real: D5-ENA, D22-IN1, D23-IN2, D6-ENB, D24-IN3, D25-IN4.
L298N recebe alimentacao propria e aciona os motores 12 V (nao simulados).
SINALIZACAO
BUZZER DE RE - D33 (piezo simulado)
Timbre via tone() no sketch Wokwi; distancia ajustavel no HC-SR04.