7-Segment-Display

Drehzahlmesser

Energiezähler

#include <LiquidCrystal.h>                    // LCD Library einbinden

LiquidCrystal mylcd(8, 11, 9, 4, 5, 6, 7);    // Display Anschlußpins definieren

const int LCDdimmer = 10;                     // LCD Beleuchtung via Pin 10
const int Eingang = 2;                        // Pin 2 ist Eingang für Sensor

const int AVG = 4;                            // Glättung über mindestens 4 Messwerte

volatile unsigned long dauer=0;               // microsekunden seit dem letzten Interrupt
volatile unsigned long last=0;                // Zählerwert beim letzten Interrupt
volatile unsigned long average=1;             // Integrierte Dauer // =1: divide by 0 vermeiden
volatile int avgcnt=0;                        // Anzahl Messwerte im Puffer

void setup() {
  pinMode(Eingang, INPUT);                    // Eingangspin auf Eingang stellen
  digitalWrite(Eingang, HIGH);                // und Pullup-Widerstand einschalten

  pinMode(LCDdimmer, OUTPUT);                 // Display-Dimmer-Pin auf Ausgang
  analogWrite(10, 200);                       // Helligkeit auf 200

  mylcd.begin(16, 2);                         // Display hat 2 Zeilen a 16 Zeichen
  mylcd.print("Drehzahlmesser");              // Überschrift ausgeben

  attachInterrupt(0, readmicros, RISING );    // Interrupt 0 auf Routine readmillis setzen
}                                             // reagiert auf steigende Flanken an Pin 2

void loop() {                                 // Hauptprogramm
  char buf[17];                               // Pufferstring für sprintf
  unsigned long drehzahl=0;                   // selbstredend
  if (dauer != 0) {
    drehzahl = myround(60000000 / average);   // Drehzahl ausrechnen und runden
  } else {
    drehzahl = 0;                             // keine Messung? -> Stillstand
    avgcnt = 0;                               // entwerten des Average-Puffers
  }
  sprintf(buf, "RPM %5lu       ", drehzahl);  // als 5stellig formatierte Zahl in den Puffer schreiben
  mylcd.setCursor(0, 1);                      // cursor an den Anfang der 2. Zeile (fängt mit 0 an)
  mylcd.print(buf);                           // Puffer ausgeben
  dauer >>= 10;                               // Flag für Stillstand ( : 1024 )
  delay(500);                                 // eine halbe Sekunde schlafen
}                                             // mehr als zwei Werte pro Sekunde kann eh keiner lesen

void readmicros() {                           // Interrupt-Routine
  detachInterrupt(0);                         // Interrupt ausschalten damit er uns nicht beißt
  int avgmax;
  unsigned long us = micros();                // Microsekundenzähler auslesen
  if (last == 0) {                            // erster Messwert? 
    last = us;                                // merken und nicht weiter bearbeiten
  } else {
    if ( us < last ) {                        // Zählerüberlauf
      dauer = 4294967295 - last + us;         // erzeugt einen Fehler von 1µS - vernachlässigbar
    } else {
      dauer = us - last;                      // Differenz zum letzten Durchlauf berechnen
    }
    if (dauer > 5000) {                       // ignorieren wenn <= 5ms (Kontaktpreller)
      average = dauer + average * avgcnt++;   // Wert in buffer und mit Faktor avgcnt glätten
      average /= avgcnt;                      // und zurückrechnen
      avgmax = 1000000 / dauer;               // dynamische Größe des Integrationspuffers
      if (avgmax < AVG) avgmax = AVG;         // Trägheit mindestens 1 Sekunde
      if (avgcnt >= avgmax) avgcnt--;
      last = us;                              // und wieder den letzten Wert merken
    }
  }
  attachInterrupt(0, readmicros, RISING );    // Interrupt wieder einschalten.
}

unsigned long myround(unsigned long value) {  // Gewichtete Rundung
  int rto;
  if (value > 3000) {                         // Rundungswert bestimmen 
    rto = 100;
  } else if (value > 1500) {
    rto = 50;
  } else if (value > 500) {
    rto = 10;
  } else if (value > 100) {
    rto = 5;
  } else {
    return (value);
  }
  return (_myround(value, rto));
}

unsigned long _myround(unsigned long value, int roundto) {
  value += (roundto >> 1);                    // halben roundto Wert addieren
  value /= roundto;                           // integer division 
  value *= roundto;                           // integer multiplikation
  return (value);
}

Die Idee bei dieser Art der Drehzahlmessung ist, dass z.B. ein Lüfter (Ventilator) mit seinen Rotorblättern einen Lichtstrahl durch Rotation immer wieder unterbricht. Dies geschieht umso häufiger, je schneller sich der Lüfter dreht. Diesen Umstand machen wir uns im folgenden Aufbau zunutze, denn wir bauen eine Lichtschranke, die jede Unterbrechung zählt und dann in regelmäßigen Zeitabständen die Anzahl der Umdrehungen ausrechnet.

Sketch

#define PIN_LED 9#define PIN_LED_DETECTOR A0// [0..1023] = [dark..bright]const unsigned int SENSOR_SENSITIVITY  = 500;// e.g. number of blades in a fanconst byte INTERUPTIONS_PER_REVOLUTION = 7;// in msconst unsigned long CALCULATE_INVERVAL = 2500;bool sensorStatus = false;unsigned int brightness = 0, rpm = 0;unsigned long interruptions, revolutions = 0, lastCalculateTime;void setup(){    Serial.begin(9600);    lastCalculateTime = millis();    pinMode(PIN_LED, OUTPUT);    digitalWrite(PIN_LED, HIGH);}void loop(){    if (millis() - lastCalculateTime > CALCULATE_INVERVAL) {        revolutions = interruptions / INTERUPTIONS_PER_REVOLUTION;        rpm = revolutions / (CALCULATE_INVERVAL / 1000) * 60;        revolutions = 0;        interruptions = 0;        lastCalculateTime = millis();        // show sensor brightness        Serial.print("B = " + (String)+brightness);        // show amount of interruptions of the sensor        Serial.print("; I = " + (String)interruptions);        // show amount of revolutions        Serial.print("; R = " + (String)revolutions);        // show rpm = "revolutions per minute"        Serial.println("; " + String(rpm) + " RPM");    }    brightness = analogRead(PIN_LED_DETECTOR);    if (sensorStatus == false && brightness >= SENSOR_SENSITIVITY) {        interruptions++;        sensorStatus = true;    }    if (sensorStatus == true && brightness < SENSOR_SENSITIVITY) {        sensorStatus = false;    }}

http://elektro.turanis.de/html/prj095/index.html

Nicht spezifizierte Toleranz: ± 0,2 mm
Die mit * gekennzeichneten Maße beziehen sich auf die von der Bleibasis gemessenen.
Grat ist nicht in den Maßen enthalten. Gratabmessungen: max. 0,15

********************************************************I*