- Wymagane materiały
- Obliczanie prędkości i wyświetlanie jej na analogowym prędkościomierzu
- Schemat obwodu i połączenia
- Objaśnienie programowania
Pomiar prędkości / obrotów Pojazdu lub silnika zawsze był fascynującym projektem. W tym projekcie zamierzamy zbudować analogowy prędkościomierz przy użyciu Arduino. Do pomiaru prędkości użyjemy modułu czujnika podczerwieni. Są na to inne sposoby / czujniki, takie jak czujnik halla do pomiaru prędkości, ale użycie czujnika podczerwieni jest łatwe, ponieważ moduł czujnika podczerwieni jest bardzo popularnym urządzeniem i możemy go łatwo dostać z rynku, a także może być używany na każdym typie pojazd silnikowy.
W tym projekcie pokażemy prędkość zarówno w postaci analogowej, jak i cyfrowej. Wykonując ten projekt, zwiększymy również nasze umiejętności w nauce Arduino i silnika krokowego, ponieważ projekt ten obejmuje użycie przerwań i timerów. Na końcu tego projektu będziesz mógł obliczyć prędkość i odległości pokonywane przez dowolny obracający się obiekt i wyświetlić je na ekranie LCD 16x2 w formacie cyfrowym, a także na mierniku analogowym. Zacznijmy więc od tego obwodu prędkościomierza i licznika kilometrów z Arduino
Wymagane materiały
- Arduino
- Silnik krokowy bipolarny (4-przewodowy)
- Sterownik silnika krokowego (moduł L298n)
- Moduł czujnika podczerwieni
- Wyświetlacz LCD 16 * 2
- Rezystor 2,2 k
- Przewody łączące
- Płytka prototypowa.
- Zasilacz
- Wydruk zdjęcia prędkościomierza
Obliczanie prędkości i wyświetlanie jej na analogowym prędkościomierzu
Czujnik podczerwieni to urządzenie, które może wykryć obecność obiektu przed nim. Zastosowaliśmy wirnik z dwoma łopatkami (wentylator) i umieściliśmy przy nim czujnik IR w taki sposób, że za każdym razem, gdy łopatki się obrócą, czujnik IR to wykrywa. Następnie za pomocą timerów i przerwań w Arduino obliczamy czas potrzebny na jeden pełny obrót silnika.
Tutaj, w tym projekcie, użyliśmy przerwania o najwyższym priorytecie do wykrywania obrotów i skonfigurowaliśmy go w trybie rosnącym. Tak więc za każdym razem, gdy wyjście czujnika osiągnie stan LOW do High, zostanie wykonana funkcja RPMCount () . A ponieważ użyliśmy wirnika z dwoma łopatkami, oznacza to, że funkcja zostanie wywołana 4 razy podczas jednego obrotu.
Gdy znany jest czas, możemy obliczyć prędkość obrotową za pomocą poniższych wzorów, gdzie 1000 / czas da nam RPS (obrót na sekundę), a dalsze pomnożenie go przez 60 da obroty (obroty na minutę)
rpm = (60/2) * (1000 / (milis () - czas)) * REV / bladeInFan;
Po uzyskaniu obrotów, prędkość można obliczyć według wzoru:
Prędkość = rpm * (2 * Pi * promień) / 1000
Wiemy, że Pi = 3,14, a promień to 4,7 cala
Ale najpierw musimy przeliczyć promień na metry z cali:
promień = ((promień * 2,54) / 100,0) metrów Prędkość = obr./min * 60,0 * (2,0 * 3,14 * promień) / 1000,0) w kilometrach na godzinę
Tutaj pomnożyliśmy obroty przez 60, aby zamienić obroty na obroty na godzinę (obroty na godzinę) i podzieliliśmy przez 1000, aby przeliczyć metry / godzinę na kilometry / godzinę.
Po uzyskaniu prędkości w km / h możemy pokazać te wartości bezpośrednio na wyświetlaczu LCD w postaci cyfrowej, ale aby wyświetlić prędkość w postaci analogowej, musimy wykonać jeszcze jedno obliczenie, aby znaleźć nie. kroków, silnik krokowy powinien się poruszać, aby wskazać prędkość na mierniku analogowym.
Tutaj użyliśmy 4-przewodowego bipolarnego silnika krokowego dla miernika analogowego, który ma 1,8 stopnia, co oznacza 200 kroków na obrót.
Teraz musimy pokazać 280 kmh na prędkościomierzu. Aby pokazać 280 km / h, silnik krokowy musi się poruszać o 280 stopni
Mamy więc maxSpeed = 280
I będzie maxSteps
maxSteps = 280 / 1,8 = 155 kroków
Teraz mamy funkcję w naszym kodzie Arduino, a mianowicie funkcję mapowania, która jest tutaj używana do mapowania prędkości na kroki.
Steps = map (speed, 0, maxSpeed , 0, maxSteps);
Więc teraz mamy
kroki = mapa (prędkość, 0,280,0,155);
Po obliczeniu kroków możemy bezpośrednio zastosować te kroki w funkcji silnika krokowego do poruszania silnikiem krokowym. Musimy też zadbać o bieżące kroki czy kąt pracy silnika krokowego korzystając z podanych obliczeń
currSteps = Steps kroki = currSteps-preSteps preSteps = currSteps
tutaj currSteps to bieżące kroki pochodzące z ostatnich obliczeń, a preSteps to ostatnie wykonane kroki.
Schemat obwodu i połączenia
Schemat obwodu tego analogowego prędkościomierza jest prosty, tutaj użyliśmy wyświetlacza LCD 16x2 do pokazania prędkości w postaci cyfrowej i silnika krokowego do obracania igły prędkościomierza analogowego.
LCD 16x2 jest podłączony do następujących analogowych pinów Arduino.
RS - A5
RW - GND
EN - A4
D4 - A3
D5 - A2
D6 - A1
D7 - A0
Rezystor 2,2 k jest używany do ustawiania jasności wyświetlacza LCD. Moduł czujnika podczerwieni, który służy do wykrywania łopatek wentylatora w celu obliczenia obrotów, jest podłączony do przerwania 0 oznacza pin D2 Arduino.
Tutaj użyliśmy sterownika silnika krokowego, a mianowicie modułu L293N. Pin IN1, IN2, IN3 i IN4 sterownika silnika krokowego jest bezpośrednio połączony z D8, D9, D10 i D11 Arduino. Pozostałe połączenia są podane na schemacie połączeń.
Objaśnienie programowania
Kompletny kod dla Arduino Speedomete r znajduje się na końcu, tutaj wyjaśniamy kilka ważnych jego części.
W części programistycznej zawarliśmy wszystkie wymagane biblioteki, takie jak biblioteka silników krokowych, biblioteka LiquidCrystal LCD oraz zadeklarowane piny do nich.
#zawierać
Następnie wzięliśmy kilka zmiennych i makr do wykonania obliczeń. Obliczenia zostały już wyjaśnione w poprzedniej sekcji.
ulotny bajt REV; unsigned long int rpm, RPM; unsigned long st = 0; bez znaku długo; int ledPin = 13; int led = 0, RPMlen, prevRPM; int flag = 0; int flag1 = 1; # zdefiniować promień pływania bladeInFan 2 = 4,7; // inch int preSteps = 0; float stepAngle = 360.0 / (float) stepsPerRevolution; float minSpeed = 0; float maxSpeed = 280,0; float minSteps = 0; float maxSteps = maxSpeed / stepAngle;
Następnie inicjalizujemy wyświetlacz LCD, szeregowy, przerwanie i silnik krokowy w funkcji konfiguracji
void setup () { myStepper.setSpeed (60); Serial.begin (9600); pinMode (ledPin, OUTPUT); lcd.begin (16,2); lcd.print ("Prędkościomierz"); opóźnienie (2000); attachInterrupt (0, RPMCount, RISING); }
Następnie odczytujemy obroty w funkcji pętli i wykonujemy obliczenia, aby uzyskać prędkość i przekształcić ją w kroki, aby uruchomić silnik krokowy, aby wyświetlić prędkość w postaci analogowej.
void loop () { readRPM (); promień = ((promień * 2,54) / 100,0); // zbieżne w metrach int Prędkość = ((zmiennoprzecinkowa) RPM * 60,0 * (2,0 * 3,14 * promień) /1000,0); // obroty za 60 minut, średnica opony (2pi r) r to promień, 1000 do przeliczenia w km int Steps = map (Speed, minSpeed, maxSpeed, minSteps, maxSteps); if (flaga1) { Serial.print (Speed); Serial.println ("Kmh"); lcd.setCursor (0,0); lcd.print ("RPM:"); lcd.print (RPM); lcd.print (""); lcd.setCursor (0,1); lcd.print ("Szybkość:"); lcd.print (prędkość); lcd.print ("Km / h"); flag1 = 0; } int currSteps = Kroki;int steps = currSteps-preSteps; preSteps = currSteps; myStepper.step (kroki); }
Tutaj mamy funkcję reapRPM () do obliczania RPM.
int readRPM () { if (REV> = 10 lub millis ()> = st + 1000) // ZAKTUALIZUJE PO KAŻDYCH 10 ODCZYTACH lub 1 sekundę w stanie bezczynności { if (flag == 0) flag = 1; rpm = (60/2) * (1000 / (milis () - czas)) * REV / bladeInFan; time = millis (); REV = 0; int x = rpm; podczas gdy (x! = 0) { x = x / 10; RPMlen ++; } Serial.println (rpm, DEC); RPM = rpm; opóźnienie (500); st = millis (); flag1 = 1; } }
Wreszcie mamy procedurę przerwań odpowiedzialną za pomiar obrotów obiektu
void RPMCount () { REV ++; if (led == LOW) { led = HIGH; } else { led = LOW; } digitalWrite (ledPin, led); }
W ten sposób możesz po prostu zbudować analogowy prędkościomierz za pomocą Arduino. Można to również zbudować za pomocą czujnika Halla, a prędkość może być wyświetlana na smartfonie, postępuj zgodnie z tym samouczkiem prędkościomierza Arduino.