- Erforderliche Materialien
- Geschwindigkeit berechnen und auf dem analogen Tachometer anzeigen
- Schaltplan und Anschlüsse
- Programmiererklärung
Das Messen der Drehzahl / Drehzahl eines Fahrzeugs oder eines Motors war schon immer ein faszinierendes Projekt. In diesem Projekt werden wir einen analogen Tachometer mit dem Arduino bauen. Wir werden das IR-Sensormodul verwenden, um die Geschwindigkeit zu messen. Es gibt andere Möglichkeiten / Sensoren dafür, wie den Hallsensor, um die Geschwindigkeit zu messen, aber die Verwendung eines IR-Sensors ist einfach, da das IR-Sensormodul ein sehr verbreitetes Gerät ist und wir es leicht vom Markt bekommen können und es auch für jede Art von Sensor verwendet werden kann Kraftfahrzeug.
In diesem Projekt werden wir Geschwindigkeit sowohl in analoger als auch in digitaler Form zeigen. Durch dieses Projekt werden wir auch unsere Fähigkeiten beim Erlernen des Arduino- und Schrittmotors verbessern, da dieses Projekt die Verwendung von Interrupts und Timern beinhaltet. Am Ende dieses Projekts können Sie die Geschwindigkeit und die Entfernungen berechnen, die von einem rotierenden Objekt zurückgelegt werden, und diese auf einem 16x2-LCD-Bildschirm in digitalem Format sowie auf einem analogen Messgerät anzeigen. Beginnen wir also mit diesem Tachometer- und Kilometerzähler-Schaltkreis mit Arduino
Erforderliche Materialien
- Arduino
- Ein bipolarer Schrittmotor (4 Draht)
- Schrittmotortreiber (L298n-Modul)
- IR-Sensormodul
- 16 * 2 LCD-Anzeige
- 2,2k Widerstand
- Kabel anschließen
- Steckbrett.
- Energieversorgung
- Tacho Bildausdruck
Geschwindigkeit berechnen und auf dem analogen Tachometer anzeigen
Ein IR- Sensor ist ein Gerät, das das Vorhandensein eines Objekts vor ihm erkennen kann. Wir haben zwei Rotoren (Lüfter) verwendet und den IR-Sensor so in der Nähe platziert, dass der IR-Sensor ihn jedes Mal erkennt, wenn sich die Blätter drehen. Wir verwenden dann die Hilfe von Timern und Interrupts in Arduino, um die Zeit zu berechnen, die für eine vollständige Umdrehung des Motors benötigt wird.
Hier in diesem Projekt haben wir den Interrupt mit der höchsten Priorität verwendet, um die Drehzahl zu erkennen, und wir haben ihn im ansteigenden Modus konfiguriert. Wenn die Sensorausgabe auf LOW nach High geht, wird die Funktion RPMCount () ausgeführt. Und da wir einen Rotor mit zwei Blättern verwendet haben, bedeutet dies, dass die Funktion in einer Umdrehung viermal aufgerufen wird.
Sobald die benötigte Zeit bekannt ist, können wir die Drehzahl mithilfe der folgenden Formeln berechnen. Wenn 1000 / benötigte Zeit die RPS (Umdrehung pro Sekunde) ergibt und eine weitere Multiplikation mit 60 die Umdrehzahl (Umdrehung pro Minute) ergibt.
U / min = (60/2) * (1000 / (Millis () - Zeit)) * REV / BladesInFan;
Nach Erreichen der Drehzahl kann die Geschwindigkeit nach folgender Formel berechnet werden:
Geschwindigkeit = U / min * (2 * Pi * Radius) / 1000
Wir wissen, dass Pi = 3,14 und der Radius 4,7 Zoll beträgt
Aber zuerst müssen wir den Radius in Meter von Zoll umrechnen:
Radius = ((Radius * 2,54) / 100,0) Meter Geschwindigkeit = U / min * 60,0 * (2,0 * 3,14 * Radius) / 1000,0) in Kilometern pro Stunde
Hier haben wir die Drehzahl mit 60 multipliziert, um die Drehzahl in U / min (Umdrehung pro Stunde) umzuwandeln, und durch 1000 geteilt, um Meter / Stunde in Kilometer / Stunde umzuwandeln.
Nachdem wir die Geschwindigkeit in kmh haben, können wir diese Werte in digitaler Form direkt über dem LCD anzeigen. Um die Geschwindigkeit in analoger Form anzuzeigen, müssen wir eine weitere Berechnung durchführen, um herauszufinden, nein. Der Schrittmotor sollte sich bewegen, um die Geschwindigkeit auf dem analogen Messgerät anzuzeigen.
Hier haben wir einen 4-Draht-Bipolar-Schrittmotor für ein analoges Messgerät verwendet, der 1,8 Grad bedeutet und 200 Schritte pro Umdrehung bedeutet.
Jetzt müssen wir 280 km / h auf dem Tachometer anzeigen. Um 280 km / h Schrittmotor zu zeigen, muss er sich um 280 Grad bewegen
Wir haben also maxSpeed = 280
Und maxSteps wird es sein
maxSteps = 280 / 1,8 = 155 Schritte
Jetzt haben wir eine Funktion in unserem Arduino-Code, nämlich die Kartenfunktion , die hier verwendet wird, um die Geschwindigkeit in Schritte abzubilden.
Schritte = Karte (Geschwindigkeit, 0, maxSpeed , 0, maxSteps);
Also jetzt haben wir
Schritte = Karte (Geschwindigkeit, 0,280,0,155);
Nach der Berechnung der Schritte können wir diese Schritte direkt in der Schrittmotorfunktion anwenden, um den Schrittmotor zu bewegen. Wir müssen auch die aktuellen Schritte oder den Winkel des Schrittmotors anhand vorgegebener Berechnungen berücksichtigen
currSteps = Schritte Schritte = currSteps-preSteps preSteps = currSteps
Hier sind currSteps aktuelle Schritte, die aus der letzten Berechnung stammen, und preSteps sind die zuletzt ausgeführten Schritte.
Schaltplan und Anschlüsse
Der Schaltplan für diesen analogen Tachometer ist einfach. Hier haben wir ein 16x2-LCD verwendet, um die Geschwindigkeit in digitaler Form anzuzeigen, und einen Schrittmotor, um die Nadel des analogen Tachometers zu drehen.
16x2 LCD wird an folgenden analogen Pins von Arduino angeschlossen.
RS - A5
RW - GND
DE - A4
D4 - A3
D5 - A2
D6 - A1
D7 - A0
Ein 2,2k-Widerstand wird verwendet, um die Helligkeit des LCD einzustellen. Ein IR-Sensormodul, das zur Erkennung des Lüfterflügels zur Berechnung der Drehzahl verwendet wird, ist mit dem Interrupt 0 (D2-Pin von Arduino) verbunden.
Hier haben wir einen Schrittmotortreiber verwendet, nämlich das L293N-Modul. Der Pin IN1, IN2, IN3 und IN4 des Schrittmotortreibers ist direkt mit D8, D9, D10 und D11 von Arduino verbunden. Die restlichen Verbindungen sind im Schaltplan angegeben.
Programmiererklärung
Der vollständige Code für Arduino Speedomete r ist am Ende angegeben. Hier erklären wir einige wichtige Teile davon.
Im Programmierteil haben wir alle erforderlichen Bibliotheken wie die Schrittmotorbibliothek, die LiquidCrystal LCD-Bibliothek und deklarierte Pins für sie aufgenommen.
#einschließen
Danach haben wir einige Variablen und Makros für die Durchführung der Berechnungen verwendet. Berechnungen wurden bereits im vorherigen Abschnitt erläutert.
flüchtiges Byte REV; vorzeichenlose lange Drehzahl, U / min; unsigned long st = 0; lange Zeit ohne Vorzeichen; int ledPin = 13; int led = 0, RPMlen, prevRPM; int flag = 0; int flag1 = 1; #define bladesInFan 2 float radius = 4.7; // inch int preSteps = 0; float stepAngle = 360.0 / (float) stepPerRevolution; float minSpeed = 0; float maxSpeed = 280,0; float minSteps = 0; float maxSteps = maxSpeed / stepAngle;
Danach initialisieren wir den LCD-, Serial-, Interrupt- und Schrittmotor in der Setup- Funktion
void setup () { myStepper.setSpeed (60); Serial.begin (9600); pinMode (ledPin, OUTPUT); lcd.begin (16,2); lcd.print ("Tachometer"); Verzögerung (2000); attachInterrupt (0, RPMCount, RISING); }}
Danach lesen wir die Drehzahl in der Schleifenfunktion und führen eine Berechnung durch, um die Drehzahl zu erhalten, und wandeln diese in Schritte um, um den Schrittmotor zu betreiben und die Drehzahl in analoger Form anzuzeigen.
void loop () { readRPM (); Radius = ((Radius * 2,54) / 100,0); // Konvergenz in Meter int Geschwindigkeit = ((Schwimmer) U / min * 60,0 * (2,0 * 3,14 * Radius) / 1000,0); // U / min in 60 Minuten, Reifendurchmesser (2pi r) r ist Radius, 1000 in km umzurechnen int Schritte = Karte (Geschwindigkeit, minSpeed, maxSpeed, minSteps, maxSteps); if (flag1) { Serial.print (Geschwindigkeit); Serial.println ("Kmh"); lcd.setCursor (0,0); lcd.print ("RPM:"); lcd.print (RPM); lcd.print (""); lcd.setCursor (0,1); lcd.print ("Geschwindigkeit:"); lcd.print (Geschwindigkeit); lcd.print ("km / h"); flag1 = 0; } int currSteps = Steps;int step = currSteps-preSteps; preSteps = currSteps; myStepper.step (Schritte); }}
Hier haben wir die Funktion reapRPM () , um die Drehzahl zu berechnen.
int readRPM () { if (REV> = 10 oder millis ()> = st + 1000) // ES WIRD ALLE 10 LESUNGEN oder 1 Sekunde im Leerlauf AKTUALISIEREN { if (flag == 0) flag = 1; U / min = (60/2) * (1000 / (Millis () - Zeit)) * REV / BladesInFan; Zeit = Millis (); REV = 0; int x = U / min; während (x! = 0) { x = x / 10; RPMlen ++; } Serial.println (U / min, DEC); U / min = U / min; Verzögerung (500); st = millis (); flag1 = 1; } }
Schließlich haben wir eine Interruptroutine, die für die Messung der Objektumdrehung verantwortlich ist
void RPMCount () { REV ++; if (led == LOW) { led = HIGH; } else { led = LOW; } digitalWrite (ledPin, led); }}
So können Sie mit Arduino einfach einen analogen Tachometer bauen. Dies kann auch mit einem Hallsensor erstellt werden und die Geschwindigkeit kann auf dem Smartphone angezeigt werden. Befolgen Sie dazu auch dieses Tutorial zum Arduino-Tachometer.