Mudanças entre as edições de "Medidor de Velocidade Papel Alumínio"

De Garoa Hacker Clube
Ir para navegação Ir para pesquisar
m (Gabriel Almeida moveu Medidor de Velocidade para Medidor de Velocidade Papel Alumínio: Deixar o nome mais específico)
 
(13 revisões intermediárias por 2 usuários não estão sendo mostradas)
Linha 1: Linha 1:
 
== Circuito ==
 
== Circuito ==
Bem simples, apenas um Arduino com o GND ligado a um dos trilhos e deois sensores que são lâminas de papel aluminio por cima deste trilho, quando o trem passa ele fecha contato e detecta que o momento, quando passa pelo segundo o Arduino calcula a velocidade e manda via serial.
+
Muito simples, apenas um Arduino, dois sensores que são lâminas de papel aluminio e um display LCD.
  +
Funcionamento: Com o GND do Arduino ligado a um dos trilhos é colocado 2 lâminas de papel alumínio em cima do trilho mas sem encostar, quando o trem passa ele faz o papel aluminio encostar no trilho e o Arduino começa a contar o tempo, quando a roda encosta na outra folha o Arduino então usa a distância colocada no código ( DIST_MM ) para calcular a velocidade do trem, tanto em cm/s real quanto o que seria equivalente em km/h considerando a escala 1:87
   
== TODO ==
+
=== Componentes ===
  +
* Arduino Uno (ou semelhante)
* colocar um display para exibir a velocidade
 
  +
* Papel Alumínio
* melhorar o código com uma função para fazer o Seria.print
 
  +
* Display LCD
  +
* Potenciômetro (controle do LCD)
   
  +
https://www.tinkercad.com/things/eed0i7NN28G-fantastic-bombul/editel?sharecode=9VOF30qxlMP9vHSS02JtBoU2ATyaAA2d22DF8d53F3w
== Código==
 
  +
==Implementação==
<pre>
 
  +
https://t.me/garoaclube/50718/53895 (20/06/2024 idéia primordial)
   
  +
https://t.me/garoaclube/50718/56158 (12/09/2024 com displayLCD 20x4)
/*
 
   
  +
== Resultados ==
Escala H0 1:87
 
  +
Utiliza esse sensor foi possível fazer diversas medições de velocidade e aferir conforme a tensão qual velocidade o trem anda.
  +
Um fato curioso é que a velocidade demora a estabilizar, por exemplo com o teste a 9V a velocidade foi crescendo a cada volta começando em 75,05Km/h até estabilizar em 78,25Km/h depois de algumas voltas.
  +
Depois de colher aproximadamente 10 medições de velocidade (10 voltas completas) foi possível fazer regressão obtendo a equação:
   
Velocidade = Espaço / Tempo
+
Velocidade = 11,8*Volts + -26,6 com R^2 de 0,999 (vermelho)
v = dist [mm] / Time [micro_sec]
 
v = dist/Time*3600 [km/h]
 
v = dist/Time*3600*87[km/h em escala real]
 
   
  +
Velocidade = -29,2 + 12,5*Volts + -0,0496Volts^2 com R^2 de 0,999 (verde)
*/
 
   
  +
Um teste rápido foi feito com uma meta de velocidade de 50Km/h para isso utilizando a equação da regressão linear o valor da fonte deveria ser de 6,49V.
  +
O teste foi um sucesso, com velocidade bem próxima da esperada.
   
  +
[[Arquivo:Regressão_Medidor_de_velocidade.png|1000px]]
#include <LiquidCrystal.h>
 
   
#define sensor_1 7 // Pino do sensor
 
#define sensor_2 8 // Pino do sensor
 
#define Esperando 13 // Pino do LED de leitura
 
   
  +
Os dados brutos podem ser consultados no link abaixo:
float dist = 74; //em mm
 
  +
https://docs.google.com/spreadsheets/d/1IByOs3CQukwv-ikAh96F56S8vzPb0XLuwKb1vcBK8-I/edit?usp=sharing
   
  +
Um fato curioso foi de que a locomotiva de ré anda mais devagar do que indo de fente (considerando de frente como no vídeo) e também a sujeira nos trilhos e também na roda altera bastante a velocidade.
unsigned long Time = 0; //micro sec
 
unsigned long delta_time = 0; //micro sec
 
   
  +
== TODO ==
float vel = 0; //em mm/s
 
  +
* <s>colocar um display para exibir a velocidade. </s>
  +
* <s>melhorar o código com uma função para fazer o Seria.print </s>
  +
* exibir o tempo obtido?
  +
* deixar configurável a distância sem precisar subir de novo o programa no Arduino.
   
  +
== Código==
LiquidCrystal lcd_1(12, 11, 5, 4, 3, 2);
 
  +
<pre>
   
  +
#include <LiquidCrystal.h>
   
  +
#define SENSOR_1 7 // Pino do sensor 1
void setup(){
 
  +
#define SENSOR_2 8 // Pino do sensor 2
lcd_1.begin(16, 2); // Set up the number of columns and rows on the LCD.
 
  +
#define LED_STATUS 13 // Pino do LED de leitura
  +
  +
const float DIST_MM = 74; // Distância em mm
  +
  +
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
  +
  +
unsigned long startTime = 0; // Tempo em microssegundos
  +
unsigned long elapsedTime = 0; // Tempo decorrido em microssegundos
  +
float speed_mm_per_us = 0; // Velocidade em mm/µs
  +
float speed_kmh = 0; // Velocidade em km/h
  +
  +
void setup() {
  +
lcd.begin(16, 2); // Inicializa o LCD com 16 colunas e 2 linhas
  +
pinMode(SENSOR_1, INPUT_PULLUP);
  +
pinMode(SENSOR_2, INPUT_PULLUP);
  +
pinMode(LED_STATUS, OUTPUT);
 
 
  +
lcd.print("hello world!");
pinMode(sensor_1, INPUT_PULLUP);
 
pinMode(sensor_2, INPUT_PULLUP);
 
// Print a message to the LCD.
 
lcd_1.print("hello world!");
 
 
delay(500);
 
delay(500);
lcd_1.setCursor(0, 0);
+
lcd.clear();
lcd_1.print("vel(cm/s)maquete");
+
lcd.print("Vel(cm/s) Maquete");
lcd_1.setCursor(0, 1);
+
lcd.setCursor(0, 1);
lcd_1.print("Vel(Km/h): real");
+
lcd.print("Vel(Km/h): Real");
 
delay(2000);
 
delay(2000);
lcd_1.clear();
+
lcd.clear();
lcd_1.print("Esperando");
+
lcd.print("Esperando");
 
 
}
 
}
   
void loop(){
+
void loop() {
if (!digitalRead(sensor_1)) {
+
if (!digitalRead(SENSOR_1)) {
Time = micros();
+
startTime = micros();
lcd_1.clear();
+
lcd.clear();
lcd_1.print("Fazendo leitura");
+
lcd.print("Fazendo leitura");
digitalWrite(Esperando,HIGH);
+
digitalWrite(LED_STATUS, HIGH);
while (digitalRead(sensor_2)) {
 
}
 
delta_time = micros() - Time;
 
 
 
  +
while (digitalRead(SENSOR_2)) {
//APARTIR DAQUI DEVERIA SER UMA FUNÇÂO//
 
  +
// Espera até o SENSOR_2 ser acionado
//// Eu não sei tipagem ._. ////
 
  +
}
////// Vai dar merda ... //////
 
 
 
  +
elapsedTime = micros() - startTime;
vel = dist/delta_time; //em mm/us
 
  +
calculateSpeed();
lcd_1.clear();
 
lcd_1.print("vel(cm/s): ");
+
displaySpeed();
lcd_1.print(vel*pow(10, 5));
 
lcd_1.setCursor(0, 1);
 
lcd_1.print("Vel(Km/h): ");
 
lcd_1.print(vel*3600*87);
 
 
delay(5000);
 
delay(5000);
lcd_1.clear();
+
lcd.clear();
lcd_1.print("Esperando");
+
lcd.print("Esperando");
digitalWrite(Esperando,LOW);
+
digitalWrite(LED_STATUS, LOW);
 
}
 
}
  +
if (!digitalRead(SENSOR_2)) {
//IGNORAR DAQUI PARA BAIXO
 
  +
startTime = micros();
if (!digitalRead(sensor_2)) {
 
Time = micros();
+
lcd.clear();
  +
lcd.print("Fazendo leitura");
while (digitalRead(sensor_1)) {
 
digitalWrite(Esperando,HIGH);
+
digitalWrite(LED_STATUS, HIGH);
  +
  +
while (digitalRead(SENSOR_1)) {
  +
// Espera até o SENSOR_2 ser acionado
 
}
 
}
  +
digitalWrite(Esperando,LOW);
 
delta_time = micros() - Time;
+
elapsedTime = micros() - startTime;
Serial.print("Time: ");
+
calculateSpeed();
Serial.println(Time);
+
displaySpeed();
Serial.print("Delta: ");
 
Serial.println(delta_time);
 
Serial.print("Velocidade: ");
 
Serial.print(dist/delta_time);
 
Serial.println("mm/us");
 
Serial.print("Velocidade: ");
 
Serial.print(dist*3600*87/delta_time);
 
Serial.println("Km/h");
 
Serial.println();
 
 
delay(5000);
 
delay(5000);
  +
lcd.clear();
  +
lcd.print("Esperando");
  +
digitalWrite(LED_STATUS, LOW);
 
}
 
}
 
}
 
}
   
  +
void calculateSpeed() {
  +
// Calcula a velocidade em mm/µs e km/h
  +
speed_mm_per_us = DIST_MM / elapsedTime;
  +
speed_kmh = speed_mm_per_us * 3600 * 87; // 87 é o fator de escala
  +
}
  +
  +
void displaySpeed() {
  +
lcd.clear();
  +
lcd.print("Vel(cm/s): ");
  +
lcd.print(speed_mm_per_us * 1e5); // Convertendo para cm/s
  +
lcd.setCursor(0, 1);
  +
lcd.print("Vel(Km/h): ");
  +
lcd.print(speed_kmh); // Velocidade em km/h
  +
}
   
 
</pre>
 
</pre>
  +
  +
  +
[[Categoria:Projetos]][[Category:Ferromodelismo]][[Category:EFG]]
  +
[[Category:Medidores de velocidade H0]]

Edição atual tal como às 12h11min de 2 de outubro de 2024

Circuito

Muito simples, apenas um Arduino, dois sensores que são lâminas de papel aluminio e um display LCD. Funcionamento: Com o GND do Arduino ligado a um dos trilhos é colocado 2 lâminas de papel alumínio em cima do trilho mas sem encostar, quando o trem passa ele faz o papel aluminio encostar no trilho e o Arduino começa a contar o tempo, quando a roda encosta na outra folha o Arduino então usa a distância colocada no código ( DIST_MM ) para calcular a velocidade do trem, tanto em cm/s real quanto o que seria equivalente em km/h considerando a escala 1:87

Componentes

  • Arduino Uno (ou semelhante)
  • Papel Alumínio
  • Display LCD
  • Potenciômetro (controle do LCD)

https://www.tinkercad.com/things/eed0i7NN28G-fantastic-bombul/editel?sharecode=9VOF30qxlMP9vHSS02JtBoU2ATyaAA2d22DF8d53F3w

Implementação

https://t.me/garoaclube/50718/53895 (20/06/2024 idéia primordial)

https://t.me/garoaclube/50718/56158 (12/09/2024 com displayLCD 20x4)

Resultados

Utiliza esse sensor foi possível fazer diversas medições de velocidade e aferir conforme a tensão qual velocidade o trem anda. Um fato curioso é que a velocidade demora a estabilizar, por exemplo com o teste a 9V a velocidade foi crescendo a cada volta começando em 75,05Km/h até estabilizar em 78,25Km/h depois de algumas voltas. Depois de colher aproximadamente 10 medições de velocidade (10 voltas completas) foi possível fazer regressão obtendo a equação:

Velocidade = 11,8*Volts + -26,6 com R^2 de 0,999 (vermelho)

Velocidade = -29,2 + 12,5*Volts + -0,0496Volts^2 com R^2 de 0,999 (verde)

Um teste rápido foi feito com uma meta de velocidade de 50Km/h para isso utilizando a equação da regressão linear o valor da fonte deveria ser de 6,49V. O teste foi um sucesso, com velocidade bem próxima da esperada.

Regressão Medidor de velocidade.png


Os dados brutos podem ser consultados no link abaixo: https://docs.google.com/spreadsheets/d/1IByOs3CQukwv-ikAh96F56S8vzPb0XLuwKb1vcBK8-I/edit?usp=sharing

Um fato curioso foi de que a locomotiva de ré anda mais devagar do que indo de fente (considerando de frente como no vídeo) e também a sujeira nos trilhos e também na roda altera bastante a velocidade.

TODO

  • colocar um display para exibir a velocidade.
  • melhorar o código com uma função para fazer o Seria.print
  • exibir o tempo obtido?
  • deixar configurável a distância sem precisar subir de novo o programa no Arduino.

Código


#include <LiquidCrystal.h>

#define SENSOR_1    7  // Pino do sensor 1
#define SENSOR_2    8  // Pino do sensor 2
#define LED_STATUS   13  // Pino do LED de leitura

const float DIST_MM = 74; // Distância em mm

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

unsigned long startTime = 0; // Tempo em microssegundos
unsigned long elapsedTime = 0; // Tempo decorrido em microssegundos
float speed_mm_per_us = 0; // Velocidade em mm/µs
float speed_kmh = 0; // Velocidade em km/h

void setup() {
  lcd.begin(16, 2); // Inicializa o LCD com 16 colunas e 2 linhas
  pinMode(SENSOR_1, INPUT_PULLUP);
  pinMode(SENSOR_2, INPUT_PULLUP);
  pinMode(LED_STATUS, OUTPUT);
  
  lcd.print("hello world!");
  delay(500);
  lcd.clear();
  lcd.print("Vel(cm/s) Maquete");
  lcd.setCursor(0, 1);
  lcd.print("Vel(Km/h): Real");
  delay(2000);
  lcd.clear();
  lcd.print("Esperando");
}

void loop() {
  if (!digitalRead(SENSOR_1)) {
    startTime = micros();
    lcd.clear();
    lcd.print("Fazendo leitura");
    digitalWrite(LED_STATUS, HIGH);
    
    while (digitalRead(SENSOR_2)) {
      // Espera até o SENSOR_2 ser acionado
    }
    
    elapsedTime = micros() - startTime;
    calculateSpeed();
    displaySpeed();
    delay(5000);
    lcd.clear();
    lcd.print("Esperando");
    digitalWrite(LED_STATUS, LOW);
  }
  if (!digitalRead(SENSOR_2)) {
    startTime = micros();
    lcd.clear();
    lcd.print("Fazendo leitura");
    digitalWrite(LED_STATUS, HIGH);
    
    while (digitalRead(SENSOR_1)) {
      // Espera até o SENSOR_2 ser acionado
    }
    
    elapsedTime = micros() - startTime;
    calculateSpeed();
    displaySpeed();
    delay(5000);
    lcd.clear();
    lcd.print("Esperando");
    digitalWrite(LED_STATUS, LOW);
  }
}

void calculateSpeed() {
  // Calcula a velocidade em mm/µs e km/h
  speed_mm_per_us = DIST_MM / elapsedTime;
  speed_kmh = speed_mm_per_us * 3600 * 87; // 87 é o fator de escala
}

void displaySpeed() {
  lcd.clear();
  lcd.print("Vel(cm/s): ");
  lcd.print(speed_mm_per_us * 1e5); // Convertendo para cm/s
  lcd.setCursor(0, 1);
  lcd.print("Vel(Km/h): ");
  lcd.print(speed_kmh); // Velocidade em km/h
}