Trabalho Final — Esteira Ergométrica Inteligente no Visuino
Esteira Eletrônica com Arduino Mega
Desenvolvimento e simulação de uma esteira de academia utilizando Visuino Pro e SimulIDE
Equipe: Beatriz Moresco Joaquim e Haiko Rüdiger
Curso: Ciência da Computação
Disciplina: Visuino
Professor(a): Miguel Alexandre Wisintainer
Data: 30/07/2026
1. Introdução
Este projeto apresenta o desenvolvimento de uma esteira eletrônica simulada, inspirada nos painéis encontrados em esteiras de academia. O sistema foi construído com um Arduino Mega 2560, programado por meio do Visuino Pro, enquanto todo o circuito eletrônico foi montado e testado no simulador SimulIDE.
O painel informa cinco grandezas importantes durante o exercício: tempo, distância percorrida, calorias estimadas, batimentos cardíacos simulados e velocidade. Além disso, o usuário controla o funcionamento por três botões: Iniciar, Parar/Continuar e Reset.
O trabalho reúne conteúdos de programação embarcada, eletrônica digital, leitura analógica, temporização, cálculo matemático, controle de estados e multiplexação de displays. Embora seja uma simulação acadêmica, a organização utilizada se aproxima da estrutura de um equipamento real: entradas são lidas pelo microcontrolador, os valores são processados e os resultados são apresentados em um painel.
2. Objetivos do projeto
2.1 Objetivo geral
Desenvolver e simular um painel eletrônico de esteira capaz de controlar o início, a pausa, a continuação e o reinício do exercício, apresentando as principais informações em displays de sete segmentos.
2.2 Objetivos específicos
- Utilizar um Arduino Mega 2560 como unidade central de processamento.
- Ler um potenciômetro para definir a velocidade da esteira.
- Limitar a velocidade apresentada à faixa de 0 a 16 km/h.
- Exibir o tempo no formato minutos e segundos.
- Acumular a distância sem diminuí-la quando a velocidade for reduzida.
- Manter a distância congelada quando a velocidade for igual a zero.
- Estimar as calorias com base na distância e em um peso médio.
- Simular uma faixa de batimentos cardíacos durante o exercício.
- Congelar todos os valores ao pausar e continuar do mesmo ponto.
- Zerar o sistema por meio de um botão exclusivo de reset.
- Organizar o circuito com túneis para reduzir a quantidade de fios visíveis.
3. Ferramentas utilizadas
Visuino Pro
Ambiente de programação visual utilizado para criar a lógica do Arduino por blocos. Cada componente representa uma função, como contador, gerador de pulsos, conversor, cálculo, display ou código personalizado.
SimulIDE
Simulador de circuitos utilizado para montar o Arduino Mega, os displays, os resistores, os transistores, o potenciômetro e os botões. Ele permite carregar o programa compilado e observar o funcionamento do circuito.
Arduino Mega 2560
Placa escolhida por possuir uma quantidade elevada de pinos digitais e analógicos. Isso foi necessário porque o projeto utiliza 16 dígitos multiplexados, cinco conjuntos de segmentos e três botões.
4. Arquitetura geral do sistema
O funcionamento pode ser dividido em quatro etapas: entrada, controle, processamento e saída.
Quando o sistema é energizado, ele permanece aguardando o botão Iniciar. Após o início, geradores de pulsos habilitam os contadores e as atualizações periódicas. A leitura do potenciômetro é convertida em velocidade, a velocidade alimenta o cálculo da distância e a distância alimenta o cálculo das calorias. Paralelamente, um gerador aleatório simula os batimentos cardíacos.
O botão Parar/Continuar não apaga os valores. Ele apenas desabilita ou habilita as atualizações. O botão Reset, por outro lado, reinicia o programa e retorna todos os valores para o estado inicial.
5. Componentes do circuito eletrônico
| Componente | Quantidade | Função no projeto |
|---|---|---|
| Arduino Mega 2560 | 1 | Executa o programa, lê as entradas, realiza os cálculos e controla os displays. |
| Display de 7 segmentos | 16 | Apresenta tempo, distância, calorias, batimentos e velocidade. |
| Transistor BJT NPN | 16 | Seleciona o dígito ativo durante a multiplexação. |
| Rede de resistores de 100 Ω | 5 | Limita a corrente dos segmentos A a G. |
| Rede de resistores de 1 kΩ | 5 | Limita a corrente aplicada às bases dos transistores. |
| Potenciômetro de 1 kΩ | 1 | Permite selecionar a velocidade simulada. |
| Botão normalmente aberto | 3 | Controla as funções Parar/Continuar, Iniciar e Reset. |
| Túneis | Vários | Substituem fios longos por conexões identificadas por nomes. |
5.1 Arduino Mega 2560
O Arduino Mega foi escolhido principalmente pela quantidade de pinos. Cada conjunto de displays precisa de sete linhas para os segmentos A, B, C, D, E, F e G, além de uma linha para selecionar cada dígito. Como o projeto possui cinco conjuntos e 16 dígitos, uma placa com poucos pinos dificultaria a montagem.
Outra vantagem é que as entradas analógicas do Mega também podem funcionar como pinos digitais. No projeto, os pinos digitais 54 a 69 correspondem às entradas analógicas A0 a A15. O pino 54/A0 é usado para o potenciômetro, enquanto vários dos demais são usados como saídas digitais para os displays.
5.2 Potenciômetro
O potenciômetro funciona como um divisor de tensão. Seus terminais externos são ligados à alimentação e ao terra, enquanto o terminal central fornece uma tensão variável para a entrada A0 do Arduino. No Visuino, essa leitura é representada normalmente por um valor decimal entre 0 e 1.
5.3 Botões com pull-up interno
Os três botões são conectados entre o pino digital e o GND. Os pinos 3, 4 e 5 utilizam o pull-up interno do Arduino. Dessa forma, o pino permanece em nível lógico alto quando o botão está solto e vai para nível baixo quando o botão é pressionado.
Como essa lógica é invertida em relação à leitura mais intuitiva, foram adicionados componentes inversores no Visuino. Depois da inversão, pressionar o botão passa a ser interpretado como verdadeiro.
6. Displays de sete segmentos e multiplexação
6.1 O que é um display de sete segmentos?
Um display de sete segmentos é formado por sete barras luminosas identificadas pelas letras A, B, C, D, E, F e G. Ao acender combinações específicas dessas barras, é possível formar os algarismos de 0 a 9.
─ A ─ | | F B | | ─ G ─ | | E C | | ─ D ─
Os displays utilizados no SimulIDE são configurados como cátodo comum. Isso significa que o terminal comum do dígito deve ser conectado ao GND para que os segmentos possam acender quando recebem nível alto.
6.2 Por que utilizar transistores?
Cada um dos 16 dígitos possui um transistor BJT NPN. O emissor do transistor é conectado ao GND, o coletor é conectado ao cátodo comum do display e a base recebe o sinal do Arduino através de um resistor de 1 kΩ.
Quando o Arduino ativa a base, o transistor conduz e conecta o cátodo daquele dígito ao terra. Dessa forma, o Arduino consegue selecionar individualmente qual display ficará ativo.
6.3 Como funciona a multiplexação?
Não é necessário manter os 16 displays ligados ao mesmo tempo. O programa ativa um dígito, envia o padrão dos segmentos, desativa esse dígito e passa rapidamente para o próximo. Esse ciclo se repete muitas vezes por segundo.
Como a troca é muito rápida, ocorre o efeito conhecido como persistência da visão: para o observador, todos os dígitos parecem permanecer acesos simultaneamente.
6.4 Resistores utilizados
As redes de resistores de 0 Ω ficam nas linhas dos segmentos e limitam a corrente dos LEDs internos. As redes de 1 kΩ ficam nas bases dos transistores e limitam a corrente de acionamento.
O arquivo do SimulIDE possui cinco redes de 0 Ω e cinco redes de 1 kΩ, uma dupla para cada conjunto: tempo, distância, calorias, batimentos e velocidade.
6.5 Organização dos túneis
Os túneis do SimulIDE conectam pontos com o mesmo nome sem a necessidade de desenhar um fio entre eles. Isso evita cruzamentos e deixa o circuito legível.
| Indicador | Túneis dos segmentos | Dígitos |
|---|---|---|
| Tempo | A, B, C, D, E, F e G | 4 |
| Distância | A1, B1, C1, D1, E1, F1 e G1 | 3 |
| Calorias | A2, B2, C2, D2, E2, F2 e G2 | 3 |
| Batimentos | A3, B3, C3, D3, E3, F3 e G3 | 3 |
| Velocidade | A4, B4, C4, D4, E4, F4 e G4 | 3 |
7. Mapeamento dos pinos do Arduino Mega
O mapeamento abaixo foi extraído da configuração final do projeto no Visuino. A coluna “dígitos” corresponde às linhas que acionam as bases dos transistores.
| Indicador | A | B | C | D | E | F | G | Seleção dos dígitos |
|---|---|---|---|---|---|---|---|---|
| Tempo | 69 | 68 | 67 | 66 | 65 | 64 | 63 | 59, 60, 61 e 62 |
| Distância | 49 | 48 | 46 | 47 | 44 | 45 | 42 | 41, 40 e 43 |
| Calorias | 39 | 38 | 37 | 36 | 35 | 34 | 33 | 30, 31 e 32 |
| Batimentos | 29 | 28 | 27 | 26 | 25 | 24 | 23 | 20, 21 e 22 |
| Velocidade | 53 | 52 | 51 | 50 | 58 | 57 | 56 | 2, 15 e 55 |
7.1 Pinos das entradas
| Entrada | Pino | Configuração |
|---|---|---|
| Potenciômetro | A0 / digital 54 | Entrada analógica |
| Parar/Continuar | 3 | Entrada com pull-up interno |
| Iniciar | 4 | Entrada com pull-up interno |
| Reset | 5 | Entrada com pull-up interno |
8. Estrutura do programa no Visuino
O Visuino permite construir a lógica conectando componentes. O arquivo final utiliza componentes para tempo, velocidade, distância, calorias, batimentos, displays e controle dos botões.
| Componente do Visuino | Função | Uso no projeto |
|---|---|---|
| PulseGenerator1 | Gera pulsos periódicos. | Avança o contador de segundos. |
| Counter1 | Conta de 0 a 59. | Representa os segundos. |
| CounterMinutos | Conta de 0 a 59. | Recebe o pulso de estouro dos segundos. |
| DynamicDisplay7SegmentTempo | Multiplexa quatro dígitos. | Mostra minutos e segundos com zeros à esquerda. |
| MapRangeVelocidade | Converte uma faixa numérica em outra. | Transforma a leitura de A0 na faixa de 0 a 16. |
| Snapshot1 | Captura o valor existente em um instante. | Amostra a velocidade quando recebe um pulso. |
| PulseGenerator3 | Gera o clock de amostragem. | Atualiza a velocidade e a distância periodicamente. |
| AnalogToInteger1 | Converte decimal para inteiro. | Gera a velocidade inteira de 0 a 16. |
| DivideByValue1 | Divide um valor inteiro. | Divide a velocidade por 4 para obter o incremento de distância da simulação. |
| Add1 | Soma entradas. | Soma o novo incremento ao total anterior por realimentação. |
| IntegerToAnalog1 | Converte inteiro para decimal. | Prepara a distância para o cálculo das calorias. |
| DivideByValue3 | Divide por 1.000. | Converte metros em quilômetros. |
| MultiplyByValue3 | Multiplica por 70. | Aplica o peso médio definido em quilogramas. |
| MultiplyByValue4 | Multiplica por 0,7. | Aplica o fator simplificado de gasto calórico. |
| AnalogToInteger2 | Converte o resultado para inteiro. | Envia as calorias ao display. |
| RandomUnsignedGenerator1 | Gera números aleatórios sem sinal. | Simula valores entre 60 e 115 bpm. |
| PulseGenerator2 | Gera pulsos periódicos. | Solicita um novo valor de batimento. |
| DynamicDisplay7Segment... | Controla segmentos e seleção de dígitos. | Há um componente para cada indicador. |
| InverterBotao... | Inverte verdadeiro e falso. | Compensa a lógica ativa em nível baixo do pull-up. |
| ControleTresBotoes | Executa código C++ personalizado. | Implementa iniciar, pausar, continuar, debounce e reset. |
9. Controle e exibição do tempo
O tempo é apresentado por quatro dígitos no formato MM:SS. O componente PulseGenerator1 envia pulsos ao Counter1, que representa os segundos.
O contador de segundos possui mínimo 0 e máximo 59. Ao atingir o valor máximo, sua saída de limite envia um pulso ao contador de minutos. O contador de minutos também trabalha de 0 a 59.
O componente de display possui dois grupos internos: um grupo com dois dígitos para os segundos e outro com dois dígitos para os minutos. A opção Leading Zeroes está habilitada, por isso valores menores que 10 são apresentados com zero à esquerda, como 01:05.
10. Controle da velocidade
O potenciômetro é ligado à entrada A0 do Arduino. O Visuino recebe essa leitura e a envia ao componente MapRangeVelocidade, configurado com saída máxima igual a 16.
O Snapshot1 não envia continuamente cada pequena variação do potenciômetro. Ele captura o valor quando recebe o pulso do PulseGenerator3. Isso cria uma atualização controlada e fornece o mesmo valor para o display e para o cálculo da distância.
Como os displays apresentam números inteiros, o componente AnalogToInteger1 converte o valor decimal em uma velocidade inteira. Assim, o painel mostra valores entre 000 e 016 km/h.
11. Cálculo e acumulação da distância
11.1 Fórmula física
A distância é calculada a partir da velocidade e do tempo. A fórmula básica é:
Como a velocidade está em quilômetros por hora e a distância deve ser apresentada em metros, a conversão correta é:
Em um intervalo de um segundo, a distância acumulada pode ser expressa por:
11.2 Implementação utilizada no projeto
No arquivo final do Visuino, a velocidade inteira passa pelo componente DivideByValue1, configurado com o valor 4. O resultado é enviado ao primeiro terminal de Add1.
A saída de Add1 retorna ao seu segundo terminal. Essa realimentação é o que cria a acumulação:
Essa estrutura corrige o problema de a distância acompanhar diretamente o potenciômetro. Ao reduzir a velocidade, a distância total não diminui; apenas passa a crescer mais lentamente. Em velocidade zero, o incremento é zero e o último valor permanece armazenado.
11.3 Exemplo
Considerando a implementação atual e uma velocidade de 16 km/h:
Se a velocidade for reduzida para 8 km/h, o incremento passa para 2. Se for reduzida para zero, nenhum novo valor é somado, mas o total anterior continua no display.
12. Cálculo das calorias
O cálculo das calorias utiliza uma fórmula simplificada baseada na distância em quilômetros, em um peso médio de 70 kg e em um fator igual a 0,7:
No Visuino, o fluxo é:
- IntegerToAnalog1: converte a distância inteira em valor decimal.
- DivideByValue3: divide por 1.000 para transformar metros em quilômetros.
- MultiplyByValue3: multiplica pelo peso médio de 70 kg.
- MultiplyByValue4: multiplica pelo fator 0,7.
- AnalogToInteger2: converte o resultado para um número inteiro.
12.1 Exemplo com 128 metros
Conversão: 128 m = 0,128 km
Cálculo: 0,128 × 70 × 0,7 = 6,272
Valor inteiro exibido: aproximadamente 6 calorias
13. Simulação dos batimentos cardíacos
O circuito não possui um sensor cardíaco real. Para representar essa informação no painel, foi utilizado o componente RandomUnsignedGenerator1.
Ele está configurado para gerar valores inteiros entre 60 e 115 bpm. O PulseGenerator2 envia pulsos ao gerador, fazendo o valor variar periodicamente durante a execução.
Quando o sistema é pausado, o gerador aleatório e o gerador de pulsos são desabilitados. Por isso, o último valor permanece congelado no display. Quando a execução continua, novos valores voltam a ser gerados.
14. Botões e código personalizado
A lógica dos três botões foi centralizada no componente de código personalizado ControleTresBotoes. Ele possui três entradas digitais e uma saída chamada Executando.
Iniciar
Retira o sistema do estado de espera, define Executando = true e habilita todas as atualizações.
Parar/Continuar
Alterna o valor de Executando. Na pausa, os valores ficam congelados; no próximo toque, continuam.
Reset
Desabilita a execução e reinicia o programa, zerando contadores, acumuladores e displays.
14.1 Estados internos
- FAguardandoInicio: informa se o sistema ainda aguarda o primeiro início.
- FExecutando: indica se as atualizações devem acontecer.
- FResetArmado: impede múltiplos resets durante o mesmo pressionamento.
- FPararArmado: garante uma alternância por pressionamento do botão de pausa.
- FUltimoParar, FUltimoIniciar e FUltimoReset: armazenam o instante do último acionamento.
14.2 Debounce
Botões mecânicos podem produzir pequenas oscilações elétricas durante o contato, fazendo um único toque parecer vários. O código verifica se passaram pelo menos 80 milissegundos desde o último acionamento. Esse processo é chamado de debounce.
14.3 Saída Executando
A saída Executando é ligada às entradas de habilitação de quatro componentes:
- PulseGenerator1 — contagem do tempo;
- PulseGenerator2 — atualização dos batimentos;
- PulseGenerator3 — amostragem da velocidade e cálculo da distância;
- RandomUnsignedGenerator1 — geração dos batimentos simulados.
Ao pausar, esses componentes são desabilitados. Os componentes de display continuam multiplexando os últimos valores recebidos, evitando que a tela apague.
14.4 Código utilizado
Clique para visualizar o código dos três botões
// Variáveis internas
bool FAguardandoInicio = true;
bool FExecutando = false;
bool FResetArmado = false;
bool FPararArmado = true;
unsigned long FUltimoParar = 0;
unsigned long FUltimoIniciar = 0;
unsigned long FUltimoReset = 0;
// Entrada Parar/Continuar
if( !AValue )
{
FPararArmado = true;
}
else if( FPararArmado )
{
FPararArmado = false;
if( !FAguardandoInicio )
{
unsigned long AAgora = millis();
if(( AAgora - FUltimoParar >= 80 ) || ( FUltimoParar == 0 ))
{
FUltimoParar = AAgora;
FExecutando = !FExecutando;
Executando.Send( FExecutando );
}
}
}
// Entrada Iniciar
if( AValue )
{
unsigned long AAgora = millis();
if(( AAgora - FUltimoIniciar >= 80 ) || ( FUltimoIniciar == 0 ))
{
FUltimoIniciar = AAgora;
FAguardandoInicio = false;
FExecutando = true;
Executando.Send( true );
}
}
// Entrada Reset
if( !AValue )
{
FResetArmado = true;
}
else if( FResetArmado )
{
unsigned long AAgora = millis();
if(( AAgora - FUltimoReset >= 80 ) || ( FUltimoReset == 0 ))
{
FResetArmado = false;
FUltimoReset = AAgora;
FExecutando = false;
FAguardandoInicio = true;
Executando.Send( false );
delay( 20 );
asm volatile ( "jmp 0" );
}
}
// Inicialização
FAguardandoInicio = true;
FExecutando = false;
Executando.Send( false );
asm volatile ("jmp 0") faz o fluxo do programa retornar ao início. Na prática deste projeto, isso reinicializa as variáveis e os componentes do sketch, fazendo os displays voltarem ao estado inicial.
15. Testes realizados
Para validar o funcionamento, foram considerados diferentes cenários de uso.
| Teste | Procedimento | Resultado esperado |
|---|---|---|
| Estado inicial | Ligar a simulação sem pressionar Iniciar. | Valores permanecem parados. |
| Início | Pressionar Iniciar. | Tempo e demais atualizações começam. |
| Velocidade máxima | Levar o potenciômetro ao máximo. | Display mostra 016 km/h. |
| Redução da velocidade | Diminuir o potenciômetro durante a execução. | Distância continua aumentando, porém mais devagar. |
| Velocidade zero | Posicionar o potenciômetro em zero. | Distância permanece no último valor. |
| Pausa | Pressionar Parar/Continuar. | Todos os valores ficam congelados. |
| Continuação | Pressionar novamente Parar/Continuar. | Contagem continua do ponto anterior. |
| Reset | Pressionar Reset. | Valores zeram e o sistema volta a aguardar Iniciar. |
| Virada do minuto | Aguardar a passagem de 00:59. | Tempo passa para 01:00. |
16. Problemas encontrados e soluções aplicadas
Solução: deixar de apresentar diretamente um valor calculado a partir da posição atual do potenciômetro e criar um acumulador com realimentação no componente Add1.
Solução: somar incremento zero ao total anterior, preservando o valor acumulado.
Solução: criar uma saída única chamada Executando e conectá-la às entradas Enabled dos geradores e do gerador aleatório.
Solução: desabilitar as fontes de atualização sem zerar os contadores nem o acumulador.
Solução: aplicar debounce de 80 ms e variáveis de armamento para pausa e reset.
Solução: utilizar túneis A–G e A1–G4 para organizar cada conjunto de displays.
Solução: utilizar o Arduino Mega e aproveitar pinos analógicos como saídas digitais.
17. Limitações e possíveis melhorias
O projeto atende ao objetivo de demonstrar o funcionamento de um painel de esteira, mas algumas melhorias poderiam aproximá-lo ainda mais de um equipamento real.
- Substituir a divisão inteira por 4 por um cálculo decimal usando velocidade ÷ 3,6.
- Utilizar o intervalo real entre atualizações, calculado com
millis(), para tornar a distância independente da frequência exata do pulso. - Implementar tratamento explícito para valores acima de 999 nos displays de três dígitos.
- Substituir os batimentos aleatórios por um sensor de frequência cardíaca.
- Adicionar controle de inclinação da esteira.
- Simular ou controlar um motor com PWM.
- Adicionar alerta sonoro, botão de emergência e indicação de estado.
- Salvar o treino em memória para não perder os dados em uma queda de energia.
- Utilizar um circuito integrado de expansão de saídas ou drivers de display para reduzir a quantidade de pinos.
- Montar uma interface gráfica em LCD ou TFT como evolução do painel.
18. Conclusão
O desenvolvimento da esteira eletrônica permitiu integrar software e hardware em um único projeto. O Arduino Mega recebeu informações do potenciômetro e dos botões, processou o tempo, a velocidade, a distância e as calorias e controlou 16 displays de sete segmentos por multiplexação.
O Visuino facilitou a construção da lógica por componentes, tornando visíveis as etapas de processamento. O SimulIDE permitiu testar as ligações e visualizar o comportamento do circuito antes de uma possível montagem física.
Um dos principais aprendizados foi compreender que a distância deve ser acumulada a partir dos incrementos de movimento, em vez de ser ligada diretamente à posição do potenciômetro. Outro ponto importante foi o controle de pausa: para congelar os valores sem apagá-los, foi necessário interromper as fontes de atualização e manter os displays apresentando o último estado.
O código personalizado dos botões complementou a programação visual e possibilitou implementar uma máquina simples de estados, com espera, execução e pausa. O debounce evitou acionamentos indevidos, enquanto o reset de software retornou todo o sistema à condição inicial.
Dessa forma, o trabalho alcançou o objetivo de simular um painel completo de esteira de academia e demonstrou conceitos importantes de sistemas embarcados, eletrônica e programação.
Links dos projetos:
ProjetoBeatrizHaiko
Resultado final
O sistema inicia somente após o comando do usuário, apresenta cinco informações simultâneas, responde à alteração de velocidade, acumula distância e calorias, simula batimentos, pausa sem perder dados e retorna ao estado inicial pelo botão Reset.
Apêndice — Resumo do funcionamento
| Informação | Origem | Processamento | Exibição |
|---|---|---|---|
| Tempo | Gerador de pulsos | Contadores de segundos e minutos | 4 dígitos |
| Velocidade | Potenciômetro em A0 | Mapeamento de 0 a 16 | 3 dígitos |
| Distância | Velocidade amostrada | Divisão e soma acumulativa | 3 dígitos |
| Calorias | Distância acumulada | km × 70 × 0,7 | 3 dígitos |
| Batimentos | Gerador aleatório | Faixa de 60 a 115 | 3 dígitos |
Comentários
Enviar um comentário