http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                              Wels, am 2019-05-10

Stückzähler mit dem KY-010

Counting pulses with interrupt

void loop() {  time=micros();  do {    T = pulseIn(pin, HIGH) + pulseIn(pin, LOW);    if (T==0) {      Serial.println("Timeout.");    }    else {      f=1/(double)T;        // f=1/T         k++;        }      fsum+=f*1e6;  } while( micros() < (time+1e6)); // 1 Sekunde mitteln  f = fsum/k*0.9925;         // Korrekturwert einrechnen  Serial.println(f);  fsum=0.0;  k=0;}

Im Programm wird über 1 Sekunde (1e6 Mikrosekunden) gemittelt, deshalb sind nur Frequenzen bis runter zu ca. 3 Hz messbar.

Für niedrigerer Frequenzen muss entsprechend länger gemittelt werden, zum Beispiel 10, 100 oder 1000 Sekunden um 3 Millihertz erfassen zu können.

Fazit

Mit dieser einfachen und flexiblen Routine sind Messung von 3Hz bis 10 kHz möglich incl. einiger Nachkommastellen.

/*
  State change detection (edge detection)

  Often, you don't need to know the state of a digital input all the time, but
  you just need to know when the input changes from one state to another.
  For example, you want to know when a button goes from OFF to ON. This is called
  state change detection, or edge detection.

  This example shows how to detect when a button or button changes from off to on
  and on to off.

  The circuit:
  - pushbutton attached to pin 2 from +5V
  - 10 kilohm resistor attached to pin 2 from ground
  - LED attached from pin 13 to ground (or use the built-in LED on most
    Arduino boards)

  created  27 Sep 2005
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/ButtonStateChange
*/

// this constant won't change:
const int  buttonPin = 41;    // the pin that the pushbutton is attached to
const int ledPin = 13;       // the pin that the LED is attached to

// Variables will change:
int buttonPushCounter = 0;   // counter for the number of button presses
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button

void setup() {
  // initialize the button pin as a input:
  pinMode(buttonPin, INPUT);
  // initialize the LED as an output:
  pinMode(ledPin, OUTPUT);
  // initialize serial communication:
  Serial.begin(9600);
  Serial.print("läuft"); 
}


void loop() {
  // read the pushbutton input pin:
  buttonState = digitalRead(buttonPin);

  // compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == HIGH) {
      // if the current state is HIGH then the button went from off to on:
      buttonPushCounter++;
      Serial.println("on");
      Serial.print("number of button pushes: ");
      Serial.println(buttonPushCounter);
      
        if (buttonPushCounter == 0)
  {digitalWrite (ledPin, 0);
  Serial.println("nix");
  }

  else 
  if  (buttonPushCounter == 1)
  {digitalWrite (ledPin, 1);
   Serial.println("lichtmodus == 1");

  }

  else
  if (buttonPushCounter == 2)

  {
   Serial.println("lichtmodus == 2");

    digitalWrite (ledPin, 0);}


  else
  if  (buttonPushCounter == 3)
  {digitalWrite (ledPin, 1);
   Serial.println("lichtmodus == 3");

  }
    } else {
      // if the current state is LOW then the button went from on to off:
      Serial.println("off");
    }
    // Delay a little bit to avoid bouncing
    delay(50);
  }
  // save the current state as the last state, for next time through the loop
  lastButtonState = buttonState;


  // turns on the LED every four button pushes by checking the modulo of the
  // button push counter. the modulo function gives you the remainder of the
  // division of two numbers:
  if (buttonPushCounter % 4 == 0) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Zählen von Tastenbetätigungen / Entprellen

Tastenbetätigungen zählen / entprellen

/* Impulszähler Gibt die Impulse pro Sekunde des Spannungsignals  an Pin 7 aus */int pin = 7;unsigned long N;          //Anzahl der Impulseunsigned long T;          //Zeitintervall in usunsigned long time;       //Startzeitvoid setup() { Serial.begin(9600);  pinMode(pin, INPUT);  T = 1e6;}void loop() { N = 0; time = micros();  do //what goes up must come down  {if (pulseIn(pin, HIGH)>0) N++;  }while( micros() < (time+T) );   Serial.println(N);}

/* Frequenzzähler   Gibt die Frequenz des Spannungsignals an Pin 7 aus */#include <LiquidCrystal.h>int pin = 7;unsigned long T;          //Periodendauer in usdouble f;                 //Frequenz in MHz char fm[] = " %8ld Hertz";LiquidCrystal lcd(12, 11, 5, 4, 3, 2);void setup() { lcd.begin(16, 2);  pinMode(pin, INPUT);  lcd.print("FrequencyCounter");}void loop() { char s[20];     // Messen von ti + tp = T  T = pulseIn(pin, HIGH) + pulseIn(pin, LOW);  T == 0 ? f = 0 : f=1/(double)T;  sprintf(s,fm,(unsigned long)(f*1e6));  lcd.setCursor(0, 1);  lcd.print(s);  delay(200);}

// UNO mit Messung an Pin2

const byte messpin = 2;
volatile unsigned long zaehler;

void setup() {
  Serial.begin(9600);
  pinMode(messpin,INPUT_PULLUP);
  attachInterrupt(0, messung, CHANGE);
}

void loop()
{
  delay(1000); // every second
  Serial.print("Zaehler: "); Serial.println(zaehler); 
}

void messung() {
  if (digitalRead(messpin)) zaehler++;
}

const int buttonPin = 6;     // the number of the pushbutton pin
boolean buttonState, oldButtonState;
unsigned long anzeigeMillis, aktMillis;
const int anzeigeZeit = 1000;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  Serial.begin(9600);
  buttonState = digitalRead(buttonPin);
  oldButtonState = buttonState;
}

void loop() {
  static int Puls;
  aktMillis = millis();
  buttonState = digitalRead(buttonPin);

  if ( buttonState && !oldButtonState ) {   // positive Flanke erkannt
    delay(10); // Entprellen
    Puls++;
  }
  oldButtonState = buttonState;
  if (aktMillis - anzeigeMillis >= anzeigeZeit) {
    anzeigeMillis = aktMillis;
    Serial.print("Puls: ");
    Serial.println(Puls);
  }
}

Ereignis-Zähler

Möchte man verschiedene Ereignisse die als Signal an einem Eingang des Arduino vorliegen zählen, gibt es die einfache Möglichkeit über das sogenannte Polling-Verfahren die Werte einzulesen und zu verarbeiten. Beim Polling wird der Zustand des digitalen Eingangs durch eine Schleife in regelmäßigen Abständen abgefragt wird:

Der Nachteil bei dieser Methode ist, dass die Abfrageintervalle abhängig vom nachfolgenden Code verschieden lang sein können und dadurch kurze Ereignisse am digitalen Eingang (kurze Zustandswechsel zwischen HIGH und LOW) unbemerkt bleiben können. Der Vorteil dieser Methode ist aber die Einfachheit ihrer Implementierung.

Möchte man auch schnellere Ereignisse sicher erfassen, so bietet sich der Einsatz der Interrupt-Methode an. Der Arduino bietet zwei spezielle Interrupt-Eingänge (INT0 und INT1) an, an denen ein Zustandswechsel die Unterbrechung der bisherigen Programmabarbeitung und den Sprung in eine sogenannte Interrupt Service Routine (ISR) auslöst. Im Beitrag Interrupt-Programmierung wird darauf ausführlicher eingegangen.

Nach dem Durchlauf der ISR wird die Programmabarbeitung an der zuvor unterbrochenen Stelle fortgesetzt. Der Vorteil dieser Methode ist, dass keine Ereignisse am digitalen Eingang mehr “verpasst” werden können und die Reaktion auf einen Zustandswechsel unmittelbar darauf erfolgt.

Das nachfolgende Programm nutzt diesen Mechanismus, um die Signale einer Gabellichtschranke zu zählen. Dazu wurde ein kleiner Versuchsaufbau entwickelt, bei dem ein geregelter Elektromotor die Lichtschranke unterschiedlich schnell unterbricht.

Die Idee hinter diesem Aufbau besteht darin, eine kontinuierliche und definierte Auslösung der Lichtschranke zu erhalten. Ebenso ermöglicht er natürlich die Impulse der Lichtschranke mit Hilfe eines Oszilloskops genauer zu untersuchen.

Bild Oszi-Signale einfügen…

Impulse einer Lichtschranke zählen

Nach dem der erste Versuch erfolgreich abgeschlossen wurde, kann die Lichtschranke mit dem Arduino verbunden werden. Hier ist auf die Spannungspegel zu achten und ggf. über einen Spannungsteiler ein 5V Signal zu erzeugen.

Um nun die Impulse der Lichtschranke zu zählen gibt es verschiedene Möglichkeiten: Das nachfolgende Programm, definiert eine Interrupt Service Routine mit dem Namen counter(), in der die Ereignisse gezählt und ausgegeben werden.

Impuls-Zähler pro Zeit

Der Arduino hat eine interessante Advanced IO-Funktion implementiert, die pulseIN(pin,HIGH/LOW) Funktion. Wie man mit dieser Funktion Impulse zählen und sogar Frequenzen messen kann, wird im folgenden Beitrag vorgestellt.

Impulsraten sind Ereignisse aperiodischer Signale pro Zeiteinheit, wie zum Beispiel die Impulsfolge eines Geiger-Müller-Zählrohrs oder die Signale einer Lichtschranke.  Im folgenden Programm wird auf einen Interrupt verzichtet, und mittels der Funktionen (pulseIN() und micros()) die Impulsrate an Pin 7 gemessen.

Als Zeitintervall T ist hier eine Sekunde, bzw. 1000000 (1e6) Mikrosekunden voreingestellt.

In der Hauptschleife wird die Einzelmessung initialisiert und dann während des Zeitintervalls T mittels pulseIn() auf eine ansteigende Flanke gewartet. Anschließend enthält N die Anzahl der Impulse pro Sekunde und wird via Serial.println gesendet.

Frequenz-Zähler

Der Arduino hat eine interessante Advanced IO-Funktion implementiert, die pulseIN(pin,HIGH/LOW) Funktion.

Bei einem symmetrischen Rechtecksignal ist T1 = T2, also die Zeit für HIGH-Pegel gleich der Zeit für LOW-Pegel.

Der Kehrwert der Periodendauer T entspricht der Frequenz f. Da die gemessene Zeit in  Mikrosekunden (10^-6s) vorliegt, wird bei der Frequenz-Berechnung dadurch ein Wert mit der Einheit Megahertz (MHz) heraus kommen. Um eine Anzeige in Hertz (Hz) zu bekommen, muss entsprechend umgerechnet werden.

Der Programmcode sieht in der einfachsten Form wie folgt aus:

Arduino Drehzahl Impulse zählen

void setup() {  pinMode(2, INPUT);                        // Eingangspin auf Eingang     attachInterrupt(0, readmicros, RISING );  // Interrupt 0 auf Routine}volatile unsigned long dauer=1;             // microsekunden volatile unsigned long last=0;              // Zählerwert long drehzahl;                              // selbstredendchar buf[17];                               // Pufferstring für sprintfvoid loop() {                               // Hauptprogramm  drehzahl =  dauer / 60000000;              // Drehzahl ausrechnen und  sprintf(buf, "%5lu", drehzahl);           // als 5 Zahl in den Puffer   serial.println(buf);                      // Puffer ausgeben  delay(500);                               // Eine halbe Sekunde warten}void readmicros() {                         // Interrupt-Routine  unsigned long m = micros();               // Microsekunden auslesen  dauer = m - last;                         // Differenz letzte  last = m;                                 // Letzten Wert merken}

Arduino-Tutorial online

Schematische Darstellung

Arduino Sketch

Sparkfun COM-11408 4 Digit 7-Segment Display Hookup Guide

Arduino Sketch

SparkFun 7-Segment Serial Display - White

Interfacing Arduino with 7-segment display | 4-Digit counter example

/*
  The circuit:
 * LCD RS pin to digital pin 7
 * LCD Enable pin to digital pin 6
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 */

// include the library code:
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

volatile int counter0    = 0;     // Incremented by switch0
volatile int counter1    = 0;     // Incremented by switch1

const int RTCLED = 13;
const int RTC = 20;
const int TAPE = 21;
int RTCstate = 0;
int sec0 = 00;          
int min0 = 00;
int hour0 = 00;
int sec1 = 00;          
int min1 = 00;
int hour1 = 00;

// Setup
void setup() {
  pinMode(RTCLED, OUTPUT);            // Pin13 as output
  pinMode(RTC, INPUT);             // Pin20 is input
  digitalWrite(RTC, HIGH);         // Switch on pull up
  pinMode(TAPE, INPUT);             // Pin21 is input
  digitalWrite(TAPE, HIGH);         // Switch on pull up
  attachInterrupt(2, tapeINT, FALLING);
  attachInterrupt(3, rtcINT, FALLING);
  
  // set up the LCD's number of columns and rows: 
  lcd.begin(20, 4);
  // Print a message to the LCD
  lcd.print("Tape vs. Real Time");
}

// Zähler 0
void rtcINT(){
    counter0++;
}

// Zähler 1
void tapeINT(){
    counter1++;
}

void rtcZeit(){
  char Cnt[30];
  hour0=counter0/3600;
  min0=(counter0/60)-(hour0*60);
  sec0=counter0-(hour0*3600)-(min0*60);
  lcd.setCursor(0, 2);
  lcd.print("Real: ");
  sprintf(Cnt,"%02d:%02d:%02d",hour0,min0,sec0);
  lcd.print(Cnt);
}

void tapeZeit(){
  char Cnt[30];
  hour1=counter1/3600;
  min1=(counter1/60)-(hour1*60);
  sec1=counter1-(hour1*3600)-(min1*60);
  lcd.setCursor(0, 3);
  lcd.print("Tape: ");
  sprintf(Cnt,"%02d:%02d:%02d",hour1,min1,sec1);
  lcd.print(Cnt);
}

void loop(){
  rtcZeit();
  tapeZeit();
  RTCstate = digitalRead(RTC);
  if (RTCstate == HIGH) {     
    // turn LED on:    
    digitalWrite(RTCLED, HIGH);  
  } else {
    // turn LED off:
    digitalWrite(RTCLED, LOW); 
  }
}

If (rtcChanged==1){
rtcZeit();
rtcChanged=0;
}
if (tapeChanged==1{
tapeZeit();
tapeChanged=0;
}

Arduino lesson – 4 Digit 7 Segment LED Display

4digit-7segment-12pin-arduino/0-to-9999-counter.c

SparkFun 7-Segment display library for Arduino

SparkFun 7-Segment Serial Display - White

Tropfenzähler Teil 1

Eine Gabellichtschranke (Photounterbrecher) ist zentraler Bestandteil des Tropfenzählers. Die lichte Weite der Gabel ist so groß zu wählen, dass ein freier Fall der Tropfen auch unter Bewegung sicher gewährleistet ist.

Die verwendete Lichtschranke besitzt eine Weite von 10 mm. Datenblatt Die Firma Sparkfun bietet ein Breakoutboard an, dem die geeignete Belegung und der Vorwiderstand (220 Ω) für die Verwendung mit dem Arduino UNO oder MEGA zu entnehmen ist.

Hieraus wurde ein fliegender Aufbau auf dem Breadboard entwickelt. Die „Beinchen“ der Lichtschranke sind dünn und beweglich, so dass es bei ungeeigneter Handhabung leicht zu Kurzschlüssen kommen kann. Eine Verwendung unmittelbar auf dem Breadboard ist nicht möglich.

Aufgabe dieses ersten Teils ist zunächst die sichere Erfassung fallender Tropfen. Zusätzlich soll anhand des Zeitabstandes zwischen zwei nacheinander fallenden Tropfen die Tropfgeschwindigkeit pro Minute geschätzt werden.

Hier der Code / Sketch

Die sichere Erfassung  zeitkritischer Vorgänge erfordert den Einsatz von Interrupts. Der Arduino UNO verfügt über 2 Pins / digitale Eingänge zur Erfassung externer Interrupts. Es sind dies die Pins 2 und 3. Hier wird Pin 2 als Eingang verwendet. Der Signalausgang der Gabellichtschranke funktioniert als Schmitt-Trigger. Die Signaländerungen verlaufen also sehr steil und schnell, so dass es kaum zu einer „Fehlinterpretation“ in Bezug auf eine Unterbrechung des Lichtweges kommen kann. Wird der Lichtweg unterbrochen fällt die Spannung am Signalausgang auf nahezu 0 V. Die Interruptroutine muss also stets bei fallendem Pegel („falling“)aufgerufen werden. Wird sie bei sich ändernden Peglen („change“) aufgerufen, ergeben sich pro Tropfenfall 2 Signale. Das erste entsteht zu Beginn der Unterbrechung des Lichtweges und das zweite beim Verlassen des Lichtweges durch den fallenden Tropfen.

Die Sprache des Arduino sieht die Funktion „millis()“ zur Bestimmung der Zeit vom Einschalten des Prozessors vor. Wie der Name nahe legt erfolgt die Angabe in Millisekunden. Damit lässt sich ein Zeitraum von bis zu 50 Tagen erfassen, da die Funktion den Datentyp „Long“ als Ergebnis liefert. Eine genauere Erfassung in z.B. Mikrosekunden wäre zwar möglich, ist auf Grund der  Größe der Tropfen und der maximal möglichen Fallgeschwindigkeit nicht nötig.

Die Ermittlung einer Zeitdifferenz erfordert die Bestimmung von mindestens 2 Zeitpunkten. Die Bestimmung der Tropfgeschwindigkeit kann also erst vom zweiten Tropfendurchgang an erfolgen, weshalb „dropNumber > 1“ eine notwendige Bedingung ist, die abgefragt wird sobald die Tropfenzahl „dropNumber“ größer als die vorangegangene temporär gespeicherte Tropfenzahl „tmpDropNumber“ ist. Die temporäre Variable wird mit „0“ initialisiert. Somit wäre „dropNumber > temDropNumer“ schon für den ersten fallen Tropfen erfüllt. Eine alternative – aber weniger transparente – Lösung wäre die Initialisierung von tempDropNumber mit „1“.

Die Kommunikation des Arduino über die serielle Schnittstelle mit dem PC (Serial Monitor) kostet Zeit. Experimentell stellte sich heraus, dass erst ab einer Baudrate von mehr als 38400 eine zuverlässige Tropfenerkennung möglich ist. Einer weiteren Erhöhung der Baudrate steht allerdings nichts im Wege.

Das eingefügte „delay(5)“ bgrenzt den unnötigen Energieverbrauch der Prozessors und damit Erwärmung. Die verwendeten 5 ms entsprechen der Zeit die ohnehin in der Interruptroutine gewartet wird. Der gewählte Zeitrahmen stammt auf dem Encoder-Beispiel und funktionierte auch hier.

Klare Plastikfolie oder Polycarbonat stören den Strahlengang nicht. Durch einen Ring aus Polycarbonat kann eine Kontamination der IR-LED oder des Sensors vermieden werden.

Die Folgeversion der Software soll zusätzlich eine Funktion zur Näherung der Tropfgeschwindigkeit aus der Mittelung mehrerer Tropfzeitdifferenzen enthalten. Ein Ausgangssignal auf einen Digitalausgang soll zudem den sicheren und frei definierbaren Zeitrahmen für die Bewegung des Tropfenzählers zum nächsten Gefäß signalisieren.

Interrupts am Arduino: Rundenzähler

Adafruit LEDBackpack       Adafruit_LEDBackpack.h
Adafruit GFX                                      Adafruit_GFX.h
LCD-Display 16x2                               LiquidCrystal.h







Stückzähler mit dem KY-032 Modul zur Hinderniserkennung

Multi Function Shield Einrichtung und Nutzung

• 4-fach Sieben-Segment-Anzeige (über 2x 74HC595 und D4, D7, D8 angesteuert)
• Buzzer (GPIO 3)
• 4 LEDs (D1 - D4, GPIO 13 - 10)
• 2 Jumper J1 (Pullup 10KΩ A0-A3=1023; muss gesetzt sein für Tasterfunktion) und J2 (Pullup 10KΩ A4=1023)
• 3 Taster S1 - S3 (Analog 1 - 3)
• ein Potentiometer (Analog 0)
• oben links ein 7-Pin-Female-Header für Module "APC 220 Bluetooth Voice Rec.". Belegung von oben nach unten:
  • 1: -
  • 2: -
  • 3: GPIO 0
  • 4: GPIO 1
  • 5: -
  • 6: 5V
  • 7: GND
• mittig ein 6-Pin-Female-Header für Module "U4-IR-2" und "U5-18b20-LM35-A4". Belegung von links nach rechts:
  • 1: GPIO 2
  • 2: GND
  • 3: +5V
  • 4: GND
  • 5: Analog 4
  • 6: +5V
• unten rechts ein 3x4-Pin-Male-Header-Feld. Links GND, mittig +5V, rechts oben nach unten:
  • 1: GPIO 5
  • 2: GPIO 6
  • 3: GPIO 9
  • 4: Analog 5

Durchflussmesser mit Display und Reset-Taste - wie mit Arduino realisieren

// der IRQ-PIN 2/3 auf dem der Sensor geschaltet ist#define PIN_FUEL  2#define FLOW_AVG_CNT   8#define FLOW_AVG_MSK   0x07#define FLOW_AVG_SH    3                          // n/8, # shift right für Divisonvolatile uint32_t MesureAvg[FLOW_AVG_CNT];  // die jeweils letzten n Messungen in uSstatic uint32_t FlowCntTank;                // # Impulse gesamt entnommenvoid setup(){  // da der Sensor fallende Flanken liefert den PIN intern mit einem PULL-UP versehen  pinMode( PIN_FUEL, INPUT_PULLUP );  // dann die Interrupt-Service Routine für diesen PIN definieren, IRQ Auslöser ist fallende Flanke  attachInterrupt( digitalPinToInterrupt(PIN_FUEL), FlowIRQ, FALLING );}// ============================// capture Durchfluss interrupt// ============================void FlowIRQ( void )    // >> ISR( PCINT1_vect ) PIN change IRQ{ static uint8_t  CaptureIdx; static uint32_t LastMicros; register uint32_t uS = micros();  // Pulse/Min und entspr. Abstände  //   1mL = 10,5 Pulse = 5714,29mS  //  50mL =  525 Pulse =  114,29mS  // 800mL = 8400 Pulse =    7143uS  // für Flowanzeige je n Messungen zur Durchschnittsberechnung sichern  if( LastMicros )                                // aus irgendeinem Grund löst der IRQ nach Init 1x aus, 1. IRQ verwerfen    MesureAvg[CaptureIdx++] = uS - LastMicros;  CaptureIdx &= FLOW_AVG_MSK;  LastMicros = uS;  FlowCntTank++;                               // Summe der Pulse, entnommenes Volumen}#define  TIM_BASE 10                                                                     // Timeraufruf alle 10mSstatic uint8_t TmoVolumeRefresh;  #define TMO_VOL_REFRESH  (1000/TIM_BASE)  // jede Sek. das Restvolumen berechnenstatic uint8_t  TmoFlowCalc;  #define TMO_FLOW_CALC     (500/TIM_BASE)  // alle 500mS die akt. Durchflussmenge berechnenstatic uint8_t TmoFlowOff;  #define TMO_FLOW_OFF  TMO_FLOW_CALC + (100/TIM_BASE)  // mS ohne Flow Impulsstatic float Flow;                            // akt. Flow in mLstatic uint16_t VolumeConsumed;               // akt. entnommene Menge in mLstatic uint32_t FlowCntLast = -1;// dann noch eine Routine die alle 10mS aufgerufen wird// davon abgeleitet dann alle 500mS eine Flowberechnung und jede Sek. eine Restvolumen// ==========// 10mS Timer// ==========void Tim10mS(){  // ------------------------------------  // Durchflussmenge berechnen, alle n mS  // ------------------------------------  if( TmoFlowCalc )    TmoFlowCalc--;  else if( FlowCntTank != FlowCntLast )       // liegt neue Messung vor ? oder Init ?    {    uint32_t Avg = 0L;    uint8_t Idx;    Idx = FLOW_AVG_CNT;    while( Idx-- )      Avg += MesureAvg[Idx];                    // Summe der Messungen in uS    Avg >>= FLOW_AVG_SH;                        // Sum/n, Mittelwert Impulsabstand in uS    // Impuls Anzahl auf 1 Min hochrechnen, akt. Flow    float FCntMin;    if( Avg )                                   // Division durch 0 vermeiden ;)      {      FCntMin = (60L*1000L*1000L) / Avg;      // # uL/Pulse auf ml/Min umrechnen      Flow = (FCntMin * uL_OnePulse) / 1000.0;  // uL > mL      }    // akt. entnommene Menge    VolumeConsumed = ((float)FlowCntTank * uL_OnePulse) / 1000.0;    FlowCntLast = NV_FlowCntTot;    TmoFlowCalc = TMO_FLOW_CALC;            // nur alle n mS bewerten und das nur bei Änderungen    TmoFlowOff  = TMO_FLOW_OFF;             // Zeit ohne Impulse bis Durchfluss Stopp erkannt    }  // ----------------------------  // Motor steht, kein Durchfluss  // ----------------------------  if( TmoFlowOff && (--TmoFlowOff == 0) )   // entnommene Menge sichern nur wenn wir ausreiched Flow hatten    {    Flow = 0;                          // Flow Anzeige = 0mL/Min    //memset( MesureAvg, 0, sizeof(MesureAvg) );  // Durchnitt neu berechnen    }}

Herzfrequenzsensor "Pulsesensor"

https://pulsesensor.com/

Nr.21 – Herzfrequenzmessung

int SensorPin = A0;  // Signalleitung an Analoa A0  int LED=13; // LED an Port 13 wird verwendetint Sensorwert;                // Variable für den Sensworwertint Grenzwert = 510;       // Grenzwert, ab dem die LED an Pin13 später leuchten sollvoid setup() {pinMode(LED,OUTPUT);    // Pin 13 ist ein Ausgang, damit die LED mit Spannung versorgt wirdSerial.begin(9600);       // Serielle Verbindung starten, damit Daten am Seriellen Monitor angezeigt werden können  }void loop() {Sensorwert = analogRead(SensorPin);  // Sensorwert vom Sensor auslesen und unter der Variablen "Sensor" abspeichernSerial.println(Sensorwert);          // Sensorwert über die Serielle Schnittstelle an den PC senden.if(Sensorwert > Grenzwert) // Hier wird eine Verarbeitung gestartet. Wenn der Sensorwert über dem Grenzwert ist...{                          digitalWrite(LED,HIGH);  // ...dann soll die LED leuchten} else                       // Ansonsten...{digitalWrite(LED,LOW);    //  ...ist die LED aus}delay(10);  // Kurze Pause im Code, damit die Messwerte besser zu erkennen sind.     }

Impuls-Zähler pro Zeit

Frequenz-Zähler

Nr. 33 – Der Rotary Encoder KY-040

#include <Encoder.h>    // Verwendung der <Encoder.h> Bibliothek const int CLK = 6;      // Definition der Pins. CLK an D6, DT an D5. const int DT = 5;const int SW = 2;       // Der Switch wird mit Pin D2 Verbunden. ACHTUNG : Verwenden Sie einen interrupt-Pin!long altePosition = -999;  // Definition der "alten" Position (Diese fiktive alte Position wird benötigt, damit die aktuelle Position später im seriellen Monitor nur dann angezeigt wird, wenn wir den Rotary Head bewegen)Encoder meinEncoder(DT,CLK);  // An dieser Stelle wird ein neues Encoder Projekt erstellt. Dabei wird die Verbindung über die zuvor definierten Varibalen (DT und CLK) hergestellt.void setup()   // Beginn des Setups{  Serial.begin(9600);       pinMode(SW, INPUT);   // Hier wird der Interrupt installiert.    attachInterrupt(digitalPinToInterrupt(SW), Interrupt, CHANGE); // Sobald sich der Status (CHANGE) des Interrupt Pins (SW = D2) ändern, soll der Interrupt Befehl (onInterrupt)ausgeführt werden.}void loop(){    long neuePosition = meinEncoder.read();  // Die "neue" Position des Encoders wird definiert. Dabei wird die aktuelle Position des Encoders über die Variable.Befehl() ausgelesen.         if (neuePosition != altePosition)  // Sollte die neue Position ungleich der alten (-999) sein (und nur dann!!)...        {        altePosition = neuePosition;               Serial.println(neuePosition);      // ...soll die aktuelle Position im seriellen Monitor ausgegeben werden.        }}void Interrupt() // Beginn des Interrupts. Wenn der Rotary Knopf betätigt wird, springt das Programm automatisch an diese Stelle. Nachdem...{  Serial.println("Switch betaetigt"); //... das Signal ausgegeben wurde, wird das Programm fortgeführt.}