4.1.2 - Drehzahl mit Potisteuerung

 

Ich füge dabei den benötigten Code um die Drehzahl des 3 Pin Lüfters auszulesen, aus dem Teil 4.1.1 in 3.3 ein und lasse die Drehzahl am Seriellen Monitor ausgeben. Das erfassen der Drehzahl passiert wieder über das schon von mir beschriebene Pulse Stretching.
 
 
 
 

Teileliste

 
 
 
 

Anschlussplan

 
anschlussplan 4.2     schaltplan 4.1.2
 
 
 
 

Code

 

//Konstanten
const int fanPin = 9;          // Lüfter an Pin 9 angeschlossen
const int potiPin = A0 ;       // Potenzometer am analogen Eingang Pin 0 angeschlossen
const int tachoPin = 2;        // Pin des Tachosignals des Lüfters


// Variablen
int fanSpeed = 0;              // Variable für die Lüftergeschwindigkeit
int fanMin = 50;               // Minimaler PWM Wert für den Lüfter. Kommt auf den Lüfter an
int potiVar = 0 ;              // Variable zum speichern des Potentiometereingangs  
int abfrZeit = 2000;           // Zeitabstand für die Abfragen des Tachosignals
long tachoMillis = abfrZeit;   // Zeitabstand für Pulse Stretching Funktion 
float rps = 0;                 // Variable mit Kommastelle für die Berechnung der Umdrehungen pro Sekunde
int rpm = 0;                   // Variable für die gemittelte Drehzahl
float umdrZeit = 0;            // Variable mit Kommastelle für die Zeit pro Umdrehung des Lüfters
float flankenZeit =0;          // Variable mit Kommastelle für die Zeit pro Puls des Lüfters  
 
 
void setup()
{
  TCCR1B = TCCR1B & 0b11111000 | 0x01;    // Setzt Timer1 (Pin 9 und 10) auf 31300Hz
  Serial.begin(9600);            // Baudrate für den Seriellen Monitor
  pinMode(fanPin, OUTPUT) ;      // Setzt den Lüfter Pin als Ausgang
  pinMode(potiPin, INPUT) ;      // Setzt den LEDPin als Ausgang
  pinMode(tachoPin, INPUT);      // Setzt den Tacho Pin als Eingang
}
 
 
void loop()
{
  potiVar = analogRead(potiPin) ;               // Liest das Potentiometer aus
  fanSpeed = map(potiVar, 50, 1023, fanMin, 255);   // Verteilt den PWM Wert über den Messbereich des Potis
 
  // Unterer Potenziometerbereichs (0-50) = Lüfter aus
  if(potiVar < 50)
  {                  
    fanSpeed = 0;
  }
  
  analogWrite(fanPin, fanSpeed);     // Gibt die Variable mit PWM aus
  
  // Alle 2000ms pulse_stretch starten um die Drehzal auszulesen
  if((millis() - tachoMillis) >= abfrZeit) 
  {      
    pulse_stretch();
  }
}


void pulse_stretch()
{
  // Nur wenn PotiVar größer als 50 ist, wird die RPM ausgelesen
  if(potiVar > 50)
  {
    analogWrite(fanPin, 255);                // Den Lüfter konstant mit Strom versorgen damit das Tachosignal funktioniert
    flankenZeit = pulseIn(tachoPin, HIGH);   // Abfrage der Zeit pro Puls in Mikrosekunden
    analogWrite(fanPin, fanSpeed);           // Setzt die Lüftergeschwindigkeit zurück
    umdrZeit = ((flankenZeit * 4)/1000);     // Berechnung der Zeit pro Umdrehung in Millisekunden
    rps = (1000/umdrZeit);                   // Umrechnung auf Umdrehungen pro Sekunde
    rpm = (rps*60);                          // Umrechnung auf Umdrehungen pro Minute
    Serial.println(rpm);                     // Ausgabe der Drehzahl im Seriellen Monitor
  }
  // Wenn der Lüfter nicht angesteuert wird, schreibe Drehzahl 0
  else{
    Serial.println("0");
    }
  tachoMillis = millis();      // Die TachoMillis werden aktualisiert um die nächsten 2000ms zählen zu können    
}

 

 
Nachdem die Konstanten und Variablen gesetzt sind, starten wir im setup. Hier wird zu allererst die Frequenz des PWM Ausgangs 9 und 10 auf 31300kHz gesetzt, damit der Lüfter nicht pfeift und dann die Ein- und Ausgänge deklariert.
Am Anfang des loops, lesen wir das Potentiometer am potiPin aus und speicher den Wert, der sich zwischen 0 - 1023 bewegt in der Variable potiVar ab.
Jetzt verteilen wir per map Befehl (Erklärung) über den Bereich des Potentiometer von 51 - 1023 den PWM Wert von fanMin(50) - 255 und speichern den PWM Wert dann in der Variable fanSpeedUm den Lüfter auch abschalten zu können, lege ich im Bereich des Potis von 0 - 49 einen PWM Wert von 0 fest.
Jetzt  geben wir den Wert dann per analogWrite an den Lüfter aus.
Als nächstes wird per if Befehl abgefragt, ob 2000ms vergangen sind. Wenn das zutrifft wird die Funktion pulse_stretch ausgeführt.
In der puls_stretch Funktion wird als erstes mit einer if Abfrage geprüft, ob der Wert von potiVar über 50 liegt und der Lüfter somit läuft. Wenn das zutrifft, wird der Lüfter mit einem PWM Wert von 255 (100%) angesteuert, damit er ein sauberes Tachosignal ausgibt.
Dann wird die Zeit zwischen zwei Flanken des Tachosignals per pulsIn Befehl (Erklärungerfasst und in der Variable flankenZeit gespeichert. Dieser Vorgang dauert nur wenige Millisekunden und beeinflusst so die Drehzahl nicht viel. Anschließend senken wir die Geschwindigkeit des Lüfters wieder auf seinen Ausgangswert.
Jetzt kommt die Berechnung der Drehzahl mittels der erfassten flankenZeit. Der berechnete Wert wird dann am Seriellen Monitor dargestellt.
Falls der Wert von potiVar unter 50 liegt und somit der Lüfter nicht läuft, wird keine erfassung der Drehzahl durchgeführt und einfach 0 RPM am Seriellen Monitor ausgegeben
Zum Schluss muss die Variable tachoMillis auf den aktuellen Wert der millis gesetzt werden, damit die nächste Abfrage im loop funktioniert und pulse_stretch wieder ausgeführt werden kann.
 
 
Das war es auch schon  fertig
 
 
 
  
        downloadbutton arduino
 
 
 
 

Seitennavigation
 
arrow button prev               arrow button up               arrow button next

Einen Kommentar verfassen

Als Gast kommentieren

0
  • Keine Kommentare gefunden
Zum Seitenanfang Menü