-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
chore: Refactor SpeedSensor.cpp for improved readability and maintain…
…ability
- Loading branch information
1 parent
c9c3f71
commit 54225aa
Showing
4 changed files
with
72 additions
and
129 deletions.
There are no files selected for viewing
This file was deleted.
Oops, something went wrong.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,57 +1,98 @@ | ||
#include <wiringPi.h> | ||
#include <gpiod.h> | ||
#include <iostream> | ||
#include <chrono> | ||
#include <thread> | ||
#include <cmath> | ||
|
||
// Configurações | ||
const int SENSOR_PIN = 0; // Pin 17 na Raspberry Pi corresponde ao 0 no wiringPi | ||
const double RODA_DIAMETRO = 0.065; // Diâmetro da roda em metros | ||
const int FUROS = 36; | ||
#define SENSOR_PIN 17 // Número do pino GPIO na placa | ||
#define RODA_DIAMETRO 0.065 // Diâmetro da roda em metros | ||
#define FUROS 36 // Quantidade de furos no sensor | ||
|
||
// Variáveis globais | ||
volatile int pulsos = 0; | ||
auto ultimo_tempo = std::chrono::steady_clock::now(); | ||
volatile int pulsos = 0; // Contador de pulsos | ||
|
||
// Função de callback para detectar o pulso | ||
void pulso_detectado() { | ||
// Função de callback para quando um pulso é detectado | ||
void pulsoDetectado(int linha) { | ||
pulsos++; | ||
} | ||
|
||
// Função para calcular a velocidade | ||
double calcular_velocidade(int pulsos, double tempo) { | ||
double calcularVelocidade(int pulsos, double tempoSegundos) { | ||
double voltas = static_cast<double>(pulsos) / FUROS; | ||
double distancia = voltas * (RODA_DIAMETRO * 3.14159); // Distância em metros | ||
double velocidade_ms = distancia / tempo; | ||
double distancia = voltas * (RODA_DIAMETRO * M_PI); // Distância em metros | ||
double velocidade_ms = distancia / tempoSegundos; | ||
double velocidade_kmh = velocidade_ms * 3.6; | ||
return velocidade_kmh; | ||
} | ||
|
||
int main() { | ||
// Inicializa a biblioteca wiringPi | ||
wiringPiSetup(); | ||
try { | ||
// Abre o chip GPIO | ||
gpiod_chip* chip = gpiod_chip_open("/dev/gpiochip0"); | ||
if (!chip) { | ||
std::cerr << "Erro ao abrir o chip GPIO." << std::endl; | ||
return 1; | ||
} | ||
|
||
// Obtém a linha GPIO específica para o sensor | ||
gpiod_line* line = gpiod_chip_get_line(chip, SENSOR_PIN); | ||
if (!line) { | ||
std::cerr << "Erro ao obter a linha GPIO." << std::endl; | ||
gpiod_chip_close(chip); | ||
return 1; | ||
} | ||
|
||
// Configura a linha como uma entrada e define uma interrupção para a borda crescente | ||
if (gpiod_line_request_rising_edge_events(line, "pulsos_sensor") < 0) { | ||
std::cerr << "Erro ao configurar a linha para eventos de borda crescente." << std::endl; | ||
gpiod_chip_close(chip); | ||
return 1; | ||
} | ||
|
||
auto ultimoTempo = std::chrono::steady_clock::now(); | ||
double velocidade_kmh = 0.0; | ||
|
||
std::cout << "Contando pulsos. Pressione Ctrl+C para parar." << std::endl; | ||
|
||
while (true) { | ||
// Espera por um evento de interrupção na linha | ||
gpiod_line_event evento; | ||
if (gpiod_line_event_wait(line, nullptr) < 0) { | ||
std::cerr << "Erro ao esperar pelo evento de interrupção." << std::endl; | ||
break; | ||
} | ||
|
||
if (gpiod_line_event_read(line, &evento) < 0) { | ||
std::cerr << "Erro ao ler o evento de interrupção." << std::endl; | ||
break; | ||
} | ||
|
||
// Configura o pino do sensor como entrada com pull-up interno | ||
pinMode(SENSOR_PIN, INPUT); | ||
pullUpDnControl(SENSOR_PIN, PUD_UP); | ||
// Atualiza a contagem de pulsos | ||
pulsoDetectado(SENSOR_PIN); | ||
|
||
// Configura a interrupção para detectar a borda de subida | ||
wiringPiISR(SENSOR_PIN, INT_EDGE_RISING, &pulso_detectado); | ||
// Atualiza o tempo atual | ||
auto agora = std::chrono::steady_clock::now(); | ||
std::chrono::duration<double> duracao = agora - ultimoTempo; | ||
|
||
std::cout << "Aguardando leitura de velocidade. Pressione Ctrl+C para encerrar." << std::endl; | ||
if (duracao.count() >= 1.0) { // Atualiza a cada segundo | ||
velocidade_kmh = calcularVelocidade(pulsos, 1.0); // Tempo = 1 segundo | ||
std::cout << "Velocidade: " << velocidade_kmh << " km/h" << std::endl; | ||
|
||
while (true) { | ||
auto tempo_atual = std::chrono::steady_clock::now(); | ||
double duracao = std::chrono::duration_cast<std::chrono::seconds>(tempo_atual - ultimo_tempo).count(); | ||
// Reseta contadores | ||
pulsos = 0; | ||
ultimoTempo = agora; | ||
} | ||
|
||
if (duracao >= 1) { | ||
double kmh = calcular_velocidade(pulsos, 1); | ||
std::cout << "Velocidade: " << kmh << " km/h" << std::endl; | ||
pulsos = 0; | ||
ultimo_tempo = tempo_atual; | ||
// Adiciona um atraso para evitar alta carga da CPU | ||
std::this_thread::sleep_for(std::chrono::milliseconds(100)); | ||
} | ||
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Reduz o uso da CPU | ||
// Fecha o chip GPIO e libera a linha | ||
gpiod_chip_close(chip); | ||
} catch (const std::exception &e) { | ||
std::cerr << "Erro: " << e.what() << std::endl; | ||
} catch (...) { | ||
std::cerr << "Erro desconhecido." << std::endl; | ||
} | ||
|
||
std::cout << "Encerrando programa..." << std::endl; | ||
return 0; | ||
} |
Binary file not shown.