O Projeto Elevador Altum V2 é a evolução direta do nosso clássico elevador em MDF, trazendo novos recursos que deixam a experiência ainda mais completa e próxima de um sistema real de automação predial. Esta versão conta com um display indicador de andares, mostrando em tempo real a posição do elevador, além da substituição do antigo sensor reed switch pelos modernos sensores de Efeito Hall, que oferecem maior precisão e confiabilidade na detecção de posição.
Com essas melhorias, o projeto vai além de um simples exercício de programação: ele se torna uma plataforma didática completa, unindo conceitos de mecânica, eletrônica e programação em uma montagem acessível. O código foi adaptado para incluir as novas funcionalidades, permitindo explorar desde noções básicas de controle até desafios mais avançados, como a coordenação entre motor, sensores e interface de usuário.
Montagem Final Elevador Altum V2
O Altum V2 mantém a proposta educacional de seu antecessor, mas agora com recursos que aproximam ainda mais o funcionamento de um elevador real, sendo ideal para makers, estudantes e entusiastas de robótica educacional que desejam ampliar seus conhecimentos em automação e sistemas inteligentes.
Conexão com Arduino e Ponte H
Apesar de todo o sistema ser controlado pelo Arduino, a alimentação principal não passa diretamente por ele, mas sim pelo EPX10. Isso acontece porque alguns componentes, como a ponte H responsável pelo motor, demandam uma corrente maior do que o microcontrolador poderia fornecer em segurança.
A ponte H continua sendo a peça fundamental para o motor DC, já que permite controlar não apenas a velocidade, mas também o sentido de rotação (subida e descida do elevador). Ela recebe a alimentação vinda do EPX10 e apenas os sinais de controle são enviados a partir do Arduino, garantindo eficiência e protegendo o microcontrolador contra sobrecarga.
Pinout / Pinos de Conexão Ponte H L9110s
Por sua vez, as saídas da ponte H não possuem polaridade definida, sendo possível inverter os fios do motor caso o sentido de rotação não corresponda ao esperado pelo código ou pelo display.
Comunicação PWM
A Modulação por Largura de Pulso, conhecida pela sigla PWM (Pulse Width Modulation), é uma técnica que permite ao Arduino simular uma saída analógica utilizando apenas sinais digitais. Esse recurso é bastante usado para controlar a intensidade de LEDs ou regular a velocidade de motores DC, entre muitas outras aplicações.
Normalmente, os pinos digitais do Arduino só podem assumir dois estados: HIGH (5V) ou LOW (0V). Isso significa que, de forma direta, não seria possível gerar valores intermediários de tensão, como 2V ou 3,3V, por exemplo. A solução encontrada é variar o tempo que o sinal fica em nível alto e em nível baixo, alternando em alta velocidade entre os dois estados.
Esse processo é chamado de ciclo de trabalho (duty cycle). Ele representa a porcentagem de tempo em que o sinal permanece em nível alto dentro de um ciclo. Por exemplo:
– Um ciclo de 50% significa que o sinal fica metade do tempo em HIGH e metade em LOW.
– Já um ciclo de 25% fica apenas um quarto do tempo em HIGH e o restante em LOW.
Na prática, o que acontece é que o motor ou LED “enxergam” essa média de tempo como se fosse uma tensão intermediária. Assim, conseguimos controlar a velocidade de um motor ou o brilho de um LED de forma gradual, mesmo usando apenas saídas digitais.
Gráfico Funcionamento PWM – tempo x pulso
Como usar PWM no Arduino
O Arduino já traz uma função pronta para isso: analogWrite();.
Ela aceita valores entre 0 e 255, onde:
– analogWrite(0); corresponde a 0% (sempre desligado),
– analogWrite(127); corresponde a 50% (meio tempo ligado, meio tempo desligado),
– analogWrite(255); corresponde a 100% (sempre ligado).
Essa escala de 0 a 255 é apenas uma forma simplificada de representar as porcentagens, facilitando o uso no código. Em nosso Elevador utilizamos a variável velocidadeMotor para controlar a velocidade do motor, podendo ser ajustada conforme a necessidade.
Quais pinos do Arduino têm PWM?
Nem todos os pinos digitais suportam PWM. No caso do Arduino UNO, os pinos habilitados são 3, 5, 6, 9, 10 e 11.
Eles são facilmente identificados por um “~” (til) antes do número no próprio corpo da placa.
A frequência padrão desses pinos é de 490 Hz, com exceção dos pinos 5 e 6, que operam em aproximadamente 980 Hz.
Pinos PWM do Arduino UNO destacados pelo símbolo “~”.
Produtos Utilizados no Projeto Elevador Arduino
Abaixo seguem todos produtos utilizados no desenvolvimento do projeto, os quais podem ser adquiridos de forma avulsa conforme a listagem. Se você quiser, pode adquirir a versão do Elevador Altum V2 Completo, o qual já possui todas as peças necessárias para montagem.
– 01 x Estrutura em MDF Elevador Altum V2 + Manual de Montagem
– 01 x Placa Uno SMD compatível Arduino + Cabo USB
– 01 x Fonte de Alimentação Chaveada 5VDC 1A
– 01 x Driver Duplo Ponte H de motor DC ou Passo L9110s
– 01 x Extensor e Expansor de Portas 0 a 6V 10 Saídas com Jack P4 – EPX10
– 01 x Fio de Nylon 50cm espessura 0,4mm (acompanha o kit básico)
– 01 x Motor DC 3-6V 80RPM com Caixa de Redução 120:1
– 04 x Chaves Push Button PBS-102 104 Preta NA 1A
– 04 x Módulo Sensor de Efeito Hall para Arduino
– 01 x Imã De Neodímio N50 Super Forte 10mm x 4mm
– 01 x Display LCD 16×2 I2C com Fundo Azul
– 20 x Jumper Premium para Protoboard Macho-Fêmea 30cm – Kit c/ 20 peças (recomendamos 2 kits)
– 12 x Jumper Premium para Protoboard Fêmea-Fêmea 30cm – Kit c/ 20 peças
– 02 x Parafusos Philips M3 x 30mm Metálicos
– 06 x Porcas M3
– 12 x Parafusos M3 x 6mm Metálicos
– 04 x Parafuso Philips M3 x 12mm Metálico
– 01 x Pacote Abraçadeira de Nylon
Esquema de Ligação do Projeto Elevador Arduino
No Projeto Elevador Altum V2, toda a alimentação do sistema parte do módulo EPX10, uma pequena placa que funciona como central de distribuição de energia. Ele conta com um conector Jack P4 para ligação da fonte de 5V 1A que acompanha o kit, e a partir dele a energia é derivada para todos os demais componentes do circuito.
O diferencial do EPX10 é justamente a praticidade: por possuir saídas em pinos, compatíveis com jumpers padrão, ele evita emendas desnecessárias e permite uma conexão organizada e confiável. Assim, conseguimos ligar a ponte H, o Arduino e demais módulos diretamente ao EPX10, cada um recebendo a energia necessária de forma estável.
Distribuição de energia Módulo EPX10
Do EPX10 derivamos as conexões principais:
– Arduino UNO: recebe alimentação do EPX10, mas fica responsável apenas pela lógica de controle e comunicação.
– Driver Ponte H (L9110S): ligado ao motor, recebe energia direta do EPX10 e sinais de controle do Arduino, permitindo regular a velocidade e inverter a direção de movimento.
– Display I2C: conectado ao Arduino pelos pinos SDA e SCL, mas alimentado pelo EPX10, garantindo estabilidade no fornecimento de energia.
– Sensores de efeito Hall: posicionados nos andares para detectar a posição do elevador com precisão, também alimentados pelo EPX10 e seu sinal indo diretamente ao Arduino.
– Botões de chamada: possuem seus pinos de GND interligados entre si com fio e solda e depois unidos ao GND do Arduino por meio de um jumper. Já os sinais individuais vão para diferentes pinos digitais do microcontrolador.
Esquema de Ligação do Projeto Elevador Arduino
Essa organização tem duas vantagens principais:
1. Distribuição eficiente da energia, sem sobrecarregar o Arduino.
2. Fiação simplificada, já que todos os módulos recebem energia de um ponto central.
Outro detalhe importante está nos botões de chamada: em vez de utilizar resistores externos de Pull-up, aproveitamos o recurso interno do Arduino, que já realiza essa função via software. Isso simplifica a montagem e reduz a quantidade de componentes necessários no circuito.
Botões e Emendas
Outro ponto interessante é o sistema de botões de chamada dos andares. Cada botão precisa de uma linha de sinal individual, mas todos compartilham o mesmo GND. Para simplificar, foi utilizado um jumper descascado e soldado manualmente, unindo os terminais de GND entre si.
Assim, obtemos quatro saídas de sinal (uma para cada botão) e uma entrada de GND compartilhada, que nesse caso vem do Arduino. Isso é possível porque, diferentemente do motor, o consumo aqui é mínimo, não representando risco de sobrecarga.
Soldagem Botões do Elevador Altum V2
Display de Andares
Logo acima dos botões temos o display, responsável por indicar em tempo real o andar atual do elevador. Ele se comunica com o Arduino via I2C, o que simplifica bastante a ligação, já que utiliza apenas dois pinos de sinal.
No entanto, sua alimentação também segue o padrão centralizado do projeto: o VCC e GND vêm diretamente do EPX10, reforçando a função desse módulo como ponto central de distribuição de energia.
Conexão Display I2C
Extensão de Jumpers e Organização dos Cabos
Em alguns pontos do projeto, especialmente nos sensores posicionados nos andares mais elevados, os jumpers premium convencionais não possuem comprimento suficiente para realizar a ligação direta até o Arduino ou a central de energia.
Para resolver isso, recomendamos a utilização de jumpers Macho-Fêmea emendados entre si, funcionando como uma extensão, como mostrado na imagem abaixo:
Exemplo de emenda utilizada para extensão de Jumper Macho-Fêmea
Além disso, a organização dos cabos é essencial para garantir um projeto limpo e de fácil manutenção. Os suportes localizados próximos aos sensores foram projetados para servir como guia de fixação, permitindo prender os fios com fitas Hellermann ou abraçadeiras plásticas (não inclusas no kit). Assim, os cabos ficam alinhados à estrutura do elevador, evitando cruzamentos e desordem. Essa prática melhora o acabamento e facilita futuras manutenções.
Sensores de Efeito Hall
Diferente dos reed switches utilizados no modelo anterior, nesta versão utilizamos Sensores de Efeito Hall, que oferecem maior confiabilidade e precisão na detecção dos andares.
Vale destacar que esses sensores são unipolares, ou seja, apenas um dos lados do ímã aciona corretamente o sensor.
Caso perceba falhas na detecção basta inverter a posição do ímã para que o sistema funcione de forma adequada.
Ajuste detecção ímã Sensor Hall
Código de Funcionamento do Projeto Elevador Arduino
Um dos pontos positivos deste projeto é que ele utiliza apenas uma biblioteca externa, a LiquidCrystal_I2C, responsável pela comunicação do display LCD com o Arduino. Todas as demais funções foram desenvolvidas com comandos básicos da IDE Arduino, o que torna o código mais fácil de entender e ideal para fins didáticos.
Você pode baixar a biblioteca LiquidCrystal_I2C clicando aqui.
O programa é responsável por controlar todo o funcionamento do elevador: leitura dos botões, detecção dos andares por sensores de efeito Hall, movimentação do motor via ponte H e exibição das informações no display LCD.
Como funciona o código:
– Sensores de efeito Hall: identificam em qual andar o elevador está, substituindo os antigos reed switches com maior precisão.
– Botões de chamada: ligados ao Arduino com resistores de pull-up internos ativados, evitando a necessidade de resistores externos.
– Ponte H L298: faz o controle de direção e velocidade do motor (subir, descer ou parar).
– Display LCD I2C: mostra em tempo real o andar atual e o status do elevador (subindo, descendo, parado).
– Serial Monitor: auxilia no debug e permite também chamar andares digitando números.
O código foi escrito de forma modular, com funções específicas para cada tarefa, como sobe(), desce(), parado(), ondeEstou() e atualizarDisplay(). Assim, o entendimento e a manutenção ficam mais simples para quem está aprendendo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 |
/************************** Usinainfo www.usinainfo.com.br Autor: Victor E. Ferreira (RC0D3) **************************/ #include <Wire.h> #include <LiquidCrystal_I2C.h> // Faça o download da biblioteca ou adicione .ZIP LiquidCrystal_I2C lcd(0x27, 16, 2); // Endereço da tela, Digitos, Linhas // Define os pinos do Sensor HALL const int hall4 = 7; // Andar 3 const int hall3 = 6; // Andar 2 const int hall2 = 5; // Andar 1 const int hall1 = 4; // Terreo /* * Botões devem ser ligados ao GND */ // Define os pinos dos Botões const int botao4 = 13; // Andar 3 const int botao3 = 12; // Andar 2 const int botao2 = 11; // Andar 1 const int botao1 = 8; // Terreo // Define os pinos de utilização do Driver ponte H L9110s const int motorB1 = 10; // Conectado ao B-1A da ponte H const int motorB2 = 9; // Conectado ao B-1B da ponte H int andarAlvo = 1; // Andar onde devemos parar (1 a 4) int andarAtual = -1; // Inicia com um andar inexistente (-1 a 4) String displayLinha1 = ""; // Sistema de cachê do display, evitando String displayLinha2 = ""; // atualizações desnecessárias e bugs visuais const int tempoAtualizar = 10; // Milissegundos, variável de delay de checagem dos sensores const int velocidadeMotor = 255; // Velocidade do motor de 0 a 255 const int sensibilidadeDescida = 5; // Quanto maior, menos sensívl aos sensores void setup() { // Setup do display LCD lcd.init(); lcd.backlight(); // Define os pinos do Drive como saída de sinal pinMode(motorB1, OUTPUT); pinMode(motorB2, OUTPUT); // Define os pinos dos HALL como entrada de sinal pinMode(hall1, INPUT_PULLUP); pinMode(hall2, INPUT_PULLUP); pinMode(hall3, INPUT_PULLUP); pinMode(hall4, INPUT_PULLUP); // Define os pinos dos Botões como entrada de sinal pinMode(botao1, INPUT_PULLUP); pinMode(botao2, INPUT_PULLUP); pinMode(botao3, INPUT_PULLUP); pinMode(botao4, INPUT_PULLUP); Serial.begin(115200); Serial.println("Elevador Altum V2 - Usinainfo"); atualizarDisplay("Elevador AltumV2", 1); atualizarDisplay(" USINAINFO", 2); delay(3000); } void loop() { verificarBotoes(); if (andarAtual == -1) { // Iniciou o programa procurarAndarMaisProximo(); // Se posicionar em um andar corretamente } if (andarAlvo > andarAtual) { // Queremos ir para um andar acima da gente Serial.println("Indo ao próximo andar"); // Mostrar que estamos subindo e o andar que queremos ir String tmpDisplay = " Subindo > " + nomeAndar(andarAlvo) + " "; atualizarDisplay(tmpDisplay, 2); // Atualizar apenas a 2° linha delay(500); proximoAndar(); // Ir para o próximo andar } else if (andarAlvo < andarAtual) { // Queremos ir para um andar abaixo da gente Serial.println("Indo ao andar anterior"); // Mostrar que estamos descendo e o andar que queremos ir String tmpDisplay = " Descendo > " + nomeAndar(andarAlvo) + " "; atualizarDisplay(tmpDisplay, 2); // Atualizar apenas a 2° linha delay(500); andarAnterior(); // Ir para o andar anterior } else { parado(); // Desligar o motor delay(100); atualizarDisplay("ESCOLHA UM ANDAR", 2); // Terminamos, solicitar andar ao usuário Serial.print("Cheguei ao andar "); Serial.println(andarAlvo); } } void procurarAndarMaisProximo() { while (andarAtual == -1) { Serial.println("Procurando andar mais próximo..."); atualizarDisplay("----------------", 1); // Atualizar 1° linha atualizarDisplay(" AGUARDE... ", 2); // Atualizar 2° linha if (ondeEstou() != -1) { // Se encontrar um andar andarAtual = ondeEstou(); // Salva o andar andarAlvo = andarAtual; // Define o Alvo no mesmo andar Serial.println("Andar ondeEstou:"); Serial.println(andarAtual); atualizarAndar(andarAtual); // Atualiza a Tela } delay(tempoAtualizar); desce(); // Desce até encontrar um andar... } } void verificarBotoes() { int andar = -1; // Inicia sem botão clicado if (!digitalRead(botao1)) { // Caso tenha clicado no botão T andar = 1; } else if (!digitalRead(botao2)) { andar = 2; } else if (!digitalRead(botao3)) { andar = 3; } else if (!digitalRead(botao4)) { andar = 4; } if (andar >= 1 && andar < 5) { // Caso um botão tenha sido pressionado andarAlvo = andar; } } void atualizarAndar(int andar) { // Atualização da tela switch (andar) { // Recebe o Andar do sistema case 1: atualizarDisplay("------ T ------", 1); // Mostra o Andar correto na tela break; case 2: atualizarDisplay("------ 1 ------", 1); break; case 3: atualizarDisplay("------ 2 ------", 1); break; case 4: atualizarDisplay("------ 3 ------", 1); break; } } void proximoAndar() { while (andarAtual < andarAlvo) { // Enquanto não chegar no andarAlvo /* * Caso seja diferente ou chegue ao ultimo andar, pare * ajuda evitar que estoure a linha caso algum sensor antes falhe. */ if (ondeEstou() == 4) { andarAtual = 4; atualizarAndar(andarAtual); // Atualização forçada do sistema break; } sobe(); delay(tempoAtualizar); // Verifica qual andar passamos int novoAndar = ondeEstou(); if (novoAndar != -1) { andarAtual = novoAndar; atualizarAndar(novoAndar); } } parado(); // Desliga os motores depois de encontrar o Andar delay(500); } void andarAnterior() { // Lógica semelhante à função acima while (andarAtual > andarAlvo) { // Verifica qual andar passamos int novoAndar = ondeEstou(); if (novoAndar != -1) { andarAtual = novoAndar; atualizarAndar(novoAndar); } desce(); delay(tempoAtualizar * sensibilidadeDescida); } parado(); delay(500); } int ondeEstou() { // Reliza a leitura dos sensores Hall if (!digitalRead(hall1)) { return 1; } else if (!digitalRead(hall2)) { return 2; } else if (!digitalRead(hall3)) { return 3; } else if (!digitalRead(hall4)) { return 4; } return -1; // Estamos em movimento ou posição indefinida } String nomeAndar(int andar) { // Transforma o número dos sensores em nome do andar switch (andar) { case 1: return "T"; case 2: return "1"; case 3: return "2"; case 4: return "3"; default: return "?"; // Retorno padrão para valores inválidos } } // Inicia o motor com o comando descer void desce() { analogWrite(motorB1, velocidadeMotor); analogWrite(motorB2, 0); } // Inicia o motor com o comando subir void sobe() { analogWrite(motorB2, velocidadeMotor); analogWrite(motorB1, 0); } // Para o motor void parado() { analogWrite(motorB1, 0); analogWrite(motorB2, 0); } // Função para gerenciamento do display void atualizarDisplay(String texto, int linha) { // 1° Linha && apenas se mudar o texto da tela seguimos, assim evitamos bugs visuais e atualização desnecessária if (linha == 1 && texto != displayLinha1) { lcd.setCursor(0, 0); // Move ao início lcd.print(" "); // limpa linha lcd.setCursor(0, 0); // Move ao início lcd.print(texto); // Mostra o novo texto displayLinha1 = texto; // Salva o texto em cachê } else if (linha == 2 && texto != displayLinha2) { // 2° Linha, lógica semelhante lcd.setCursor(0, 1); lcd.print(" "); lcd.setCursor(0, 1); lcd.print(texto); displayLinha2 = texto; } } |
Personalizações possíveis:
Uma das vantagens do código é que ele já está pronto para uso, mas ainda assim pode ser facilmente adaptado:
– Alterar a velocidade do motor modificando o valor na variável velocidadeMotor.
– Personalizar as mensagens exibidas no display LCD.
– Incluir novos recursos como LEDs indicadores, buzzer ou até áudio com módulo MP3.
Dessa forma, além de ser um projeto funcional, o elevador também serve como base de aprendizado para quem deseja aprofundar seus conhecimentos em programação, controle de motores e automação com Arduino.
Conclusão
O Projeto Elevador Altum V2 mostra como é possível unir mecânica, eletrônica e programação em um único desafio didático. Embora a quantidade de conexões e componentes possa parecer complexa em um primeiro momento, o código já está pronto para uso, facilitando a montagem e o aprendizado.
A nova versão do elevador traz melhorias importantes em relação à anterior: agora conta com display LCD para indicar os andares em tempo real e utiliza sensores de efeito Hall, que oferecem maior precisão e confiabilidade em comparação aos antigos reed switches. Essas atualizações tornam o projeto mais robusto e aproximam ainda mais a experiência de um elevador real.
Além disso, o código é facilmente adaptável. É possível, por exemplo, alterar a velocidade do motor, modificar mensagens no display ou até integrar novos recursos, como LEDs indicadores, buzzer sonoro ou mesmo um módulo MP3 para anunciar os andares. Isso abre espaço para personalizações criativas e torna o projeto ainda mais interessante tanto para uso educacional quanto para makers que gostam de explorar novos desafios.
No fim, o Elevador Altum V2 não é apenas um exercício técnico, mas uma ferramenta de aprendizado que ajuda a consolidar conceitos de programação, controle de motores, sensores digitais e integração de periféricos no Arduino. Se você montou este projeto, compartilhe suas experiências e melhorias nos comentários, sua ideia pode ajudar outros desenvolvedores a evoluírem ainda mais este protótipo.
