- Vereiste materialen
- Snelheid berekenen en weergeven op analoge snelheidsmeter
- Schakelschema en aansluitingen
- Uitleg over programmeren
Het meten van de snelheid / het toerental van een voertuig of motor is altijd een fascinerend project geweest om te proberen. In dit project gaan we een analoge snelheidsmeter bouwen met behulp van de Arduino. We zullen de IR-sensormodule gebruiken om de snelheid te meten. Er zijn andere manieren / sensoren hiervoor, zoals een hall-sensor om snelheid te meten, maar het gebruik van een IR-sensor is eenvoudig omdat de IR-sensormodule een heel gebruikelijk apparaat is en we het gemakkelijk uit de markt kunnen halen en ook op elk type motorvoertuig.
In dit project gaan we snelheid laten zien in zowel analoge als digitale vorm. Door dit project te doen, zullen we ook onze vaardigheden in het leren van Arduino en stappenmotor verbeteren, aangezien dit project het gebruik van Interrupts en Timers omvat. Aan het einde van dit project zul je in staat zijn om de snelheid en afstanden afgelegd door een roterend object te berekenen en deze weer te geven op een 16x2 LCD-scherm in digitaal formaat en ook op een analoge meter. Dus laten we beginnen met dit snelheidsmeter en kilometertellercircuit met Arduino
Vereiste materialen
- Arduino
- Een bipolaire stappenmotor (4-draads)
- Stappenmotorbesturing (L298n-module)
- IR-sensormodule
- 16 * 2 LCD-scherm
- 2.2k weerstand
- Draden aansluiten
- Breadboard.
- Stroomvoorziening
- Snelheidsmeter foto afdruk
Snelheid berekenen en weergeven op analoge snelheidsmeter
Een IR- sensor is een apparaat dat de aanwezigheid van een object ervoor kan detecteren. We hebben een rotor met twee bladen (ventilator) gebruikt en de IR-sensor er zo dichtbij geplaatst dat elke keer dat de bladen draaien, de IR-sensor dit detecteert. Vervolgens gebruiken we de hulp van timers en Interrupts in Arduino om de tijd te berekenen die nodig is voor een volledige rotatie van de motor.
Hier in dit project hebben we interrupt met de hoogste prioriteit gebruikt om rpm te detecteren en we hebben deze geconfigureerd in stijgende modus. Zodat telkens wanneer de sensoruitgang LOW naar High gaat, de functie RPMCount () wordt uitgevoerd. En omdat we een rotor met twee bladen hebben gebruikt, betekent dit dat de functie 4 keer in één omwenteling wordt aangeroepen.
Zodra de benodigde tijd bekend is, kunnen we de RPM berekenen met behulp van de onderstaande formules, waarbij 1000 / genomen tijd ons de RPS (revolutie per seconde) geeft en verder vermenigvuldigen met 60 geeft u de RPM (revolutie per minuut)
rpm = (60/2) * (1000 / (millis () - tijd)) * REV / bladesInFan;
Na het verkrijgen van RPM, kan de snelheid worden berekend met de gegeven formule:
Snelheid = rpm * (2 * Pi * radius) / 1000
We weten dat Pi = 3,14 en de straal 4,7 inch is
Maar eerst moeten we de straal omzetten in meters van inches:
straal = ((straal * 2,54) /100,0) meter Snelheid = rpm * 60,0 * (2,0 * 3,14 * straal) / 1000,0) in kilometers per uur
Hier hebben we tpm vermenigvuldigd met 60 om tpm om te rekenen naar tpm (omwenteling per uur) en gedeeld door 1000 om meters / uur om te rekenen naar kilometers / uur.
Nadat we de snelheid in km / u hebben bereikt, kunnen we deze waarden direct op het LCD-scherm in digitale vorm weergeven, maar om de snelheid in analoge vorm weer te geven, moeten we nog een berekening uitvoeren om erachter te komen dat er nee is. stappen, moet de stappenmotor bewegen om de snelheid op de analoge meter weer te geven.
Hier hebben we een 4-draads bipolaire stappenmotor gebruikt voor een analoge meter, die 1,8 graden heeft, betekent 200 stappen per omwenteling.
Nu moeten we 280 Kmh op de snelheidsmeter laten zien. Dus om te laten zien dat de 280 Kmh-stappenmotor 280 graden moet bewegen
Dus we hebben maxSpeed = 280
En maxSteps zal zijn
maxSteps = 280 / 1.8 = 155 stappen
Nu hebben we een functie in onze Arduino code namelijk kaart functie die hier wordt gebruikt om snelheid in kaart te stappen.
Stappen = kaart (snelheid, 0, maxSpeed , 0, maxSteps);
Dus nu hebben we
stappen = kaart (snelheid, 0,280,0,155);
Na het berekenen van de stappen kunnen we deze stappen direct toepassen in de stappenmotorfunctie om de stappenmotor te verplaatsen. We moeten ook zorgen voor de huidige stappen of hoek van de stappenmotor met behulp van gegeven berekeningen
currSteps = Stappen stappen = currSteps-preSteps preSteps = currSteps
hier zijn currSteps de huidige stappen die afkomstig zijn van de laatste berekening en preSteps zijn de laatst uitgevoerde stappen.
Schakelschema en aansluitingen
Het schakelschema voor deze analoge snelheidsmeter is eenvoudig, hier hebben we 16x2 LCD gebruikt om de snelheid in digitale vorm weer te geven en stappenmotor om de analoge snelheidsmeternaald te draaien.
16x2 LCD is aangesloten op de volgende analoge pinnen van Arduino.
RS - A5
RW - GND
EN - A4
D4 - A3
D5 - A2
D6 - A1
D7 - A0
Een 2.2k-weerstand wordt gebruikt om de helderheid van het LCD-scherm in te stellen. Een IR-sensormodule, die wordt gebruikt om het blad van de ventilator te detecteren om het toerental te berekenen, is verbonden met interrupt 0 betekent D2-pin van Arduino.
Hier hebben we een stappenmotor driver gebruikt namelijk de L293N module. IN1, IN2, IN3 en IN4 pin van stappenmotor driver is direct verbonden met D8, D9, D10 en D11 van Arduino. De rest van de aansluitingen wordt gegeven in het schakelschema.
Uitleg over programmeren
De volledige code voor Arduino Speedomete r wordt aan het einde gegeven, hier leggen we enkele belangrijke delen ervan uit.
In het programmeergedeelte hebben we alle vereiste bibliotheken opgenomen, zoals stappenmotorbibliotheek, LiquidCrystal LCD-bibliotheek en aangegeven pinnen voor hen.
# omvatten
Hierna hebben we enkele variabelen en macro's genomen om de berekeningen uit te voeren. Berekeningen zijn al uitgelegd in de vorige paragraaf.
vluchtige byte REV; unsigned lange int rpm, RPM; niet-ondertekende lange st = 0; lange tijd niet ondertekend; int ledPin = 13; int led = 0, RPMlen, prevRPM; int vlag = 0; int vlag1 = 1; #define bladesInFan 2 zwevende straal = 4.7; // inch int preSteps = 0; float stepAngle = 360.0 / (float) stepsPerRevolution; zweven minSpeed = 0; zweven maxSpeed = 280,0; zweven minSteps = 0; zweven maxSteps = maxSpeed / stepAngle;
Hierna initialiseren we de LCD, Serial, Interrupt en Stepper motor in de setup- functie
leegte setup () { myStepper.setSpeed (60); Serial.begin (9600); pinMode (ledPin, OUTPUT); lcd.begin (16,2); lcd.print ("Snelheidsmeter"); vertraging (2000); attachInterrupt (0, RPMCount, RISING); }
Hierna lezen we het toerental in de lusfunctie en voeren we een berekening uit om snelheid te krijgen en dat om te zetten in stappen om de stappenmotor te laten draaien om de snelheid in analoge vorm weer te geven.
void loop () { readRPM (); straal = ((straal * 2.54) /100.0); // convering in meter int Speed = ((float) RPM * 60.0 * (2.0 * 3.14 * radius) /1000.0); // RPM in 60 minuten, diameter van band (2pi r) r is straal, 1000 om te rekenen in km int Steps = map (Speed, minSpeed, maxSpeed, minSteps, maxSteps); if (flag1) { Serial.print (snelheid); Serial.println ("Kmh"); lcd.setCursor (0,0); lcd.print ("RPM:"); lcd.print (RPM); lcd.print (""); lcd.setCursor (0,1); lcd.print ("Snelheid:"); lcd.print (snelheid); lcd.print ("Km / h"); vlag1 = 0; } int currSteps = Stappen;int steps = currSteps-preSteps; preSteps = currSteps; myStepper.step (stappen); }
Hier hebben we de functie reapRPM () om de RPM te berekenen.
int readRPM () { if (REV> = 10 of millis ()> = st + 1000) // HET ZAL NA ELKE 10 LEZINGEN of 1 seconde in inactiviteit updaten { if (flag == 0) flag = 1; rpm = (60/2) * (1000 / (millis () - tijd)) * REV / bladesInFan; tijd = millis (); REV = 0; int x = rpm; terwijl (x! = 0) { x = x / 10; RPMlen ++; } Serial.println (rpm, DEC); RPM = tpm; vertraging (500); st = millis (); vlag1 = 1; } }
Ten slotte hebben we een interruptroutine die verantwoordelijk is voor het meten van de omwenteling van het object
ongeldig RPMCount () { REV ++; if (led == LOW) { led = HIGH; } else { led = LOW; } digitalWrite (ledPin, led); }
Dit is hoe je eenvoudig een analoge snelheidsmeter kunt bouwen met Arduino. Dit kan ook worden gebouwd met behulp van een Hall-sensor en de snelheid kan op een smartphone worden weergegeven, volg hiervoor deze Arduino Speedometer-zelfstudie.