Der NE555 kann als Frequenzgenerator beschaltet werden. Das frequenzändernde Bauteil ist dabei ein Kondensator (im Schaltbild C2). Klebt man zwei Kupferstreifen von außen an einen Behälter, so ändert sich das Dielektrikum und damit die Kapazität, wenn der Behälter mit einer Flüssigkeit gefüllt wird.

Damit ist das Szenario klar, der Arduino darf jetzt die Frequenz zählen.

DIe Schaltung ist so aufgebaut, dass die Messtaste einfach den Strom einschaltet. Die Messung dauert dann einfach 2-3 Sekunden. Eine genaue Frequenz ist bei diesem Aufbau nicht notwendig, es genügt, wenn die Messung einen vier-stelligen Wert ausgibt. Dann kann man mit den beiden anderen Tasten die Schaltung kalibrieren. Zum einfachen Anpassen kann mit dem 1 MOhm-Widerstand  „gespielt“ werden. Zu niedrige Frequenz -> Widerstand niedriger, zu hohe Frequenz -> Widerstand erhöhen. Hierbei hilft der serielle Monitor.

Also: leeres Gefäß: untere Kalibrierungstaste drücken und dann die Einschalt-Taste. Wert wird im EEPROM gespeichert und die vier unteren LEDs leuchten. Dto. für den oberen Wert. Dann kann das fröhliche Messen beginnen.

Die Test-Schaltung habe ich mit einem Uno aufgebaut, für den realen Aufbau habe ich aus Platzgründen einen Nano genommen, eine 9V-Batterie und einen 7805 zur Spannungsregulierung.

Mein Einsatzzweck: ich messe die Füllhöhe meines Abwassertanks im Wohnwagen. Läuft!

// Fuellstandsmelder
// basierend auf einer Frequenzmessung am NE555
// mit 1MOhm und 150pF
//
// Quellen:
// LongInteger EEPROM schreiben / lesen: 
//    http://shelvin.de/long-int-zahl-im-arduino-eeprom-ablegen-und-auslesen/
// Arduino als Frequenzzähler: 
//    http://interface.khm.de/index.php/lab/interfaces-advanced/arduino-frequency-counter-library/index.html
//      (hier gibt es auch die notwendige Library Frequcounter.h
//    http://shelvin.de/frequenzzaehler-mit-dem-arduino-uno/
//
// Nano Layout:
//    http://www.circuitstoday.com/arduino-nano-tutorial-pinout-schematics
//
// Taste_1 (A0) auf LOW: Programmierung für Zustand "leer"
// Taste_2 (A1) auf LOW: Programmierung für Zustand "voll"

#include <EEPROM.h>
#include <FreqCounter.h>

void setup() {
   Serial.begin(38400);               // Serielle Ausgabe
   Serial.println("Fuellstandsmesser");

  // Definition der LEDs
    pinMode(2,OUTPUT);
    pinMode(3,OUTPUT);  
    pinMode(4,OUTPUT);
    // Pin5 = Input
    pinMode(6,OUTPUT);
    pinMode(7,OUTPUT);
    pinMode(8,OUTPUT);
    pinMode(9,OUTPUT);
    pinMode(10,OUTPUT);

    pinMode(13,OUTPUT);
    digitalWrite(13,LOW);
}

void loop() {
  
  // Definition der Taster

    int Taste_1 = analogRead(A0);
    int Taste_2 = analogRead(A1);

    int adr;
    byte by;
    
  // Taste für Programmierung "leer"
  if (Taste_1 <50) {

    Serial.println("Programmierung leer");
    
    // Messreihe für leer
    long int Wert_leer;
    Wert_leer = freq_mess();
    for (int i=0; i<=3; i++) {
     Wert_leer = (Wert_leer + freq_mess()) / 2;
    }
    
    Serial.println(Wert_leer);    
    
    // Wert im EEProm ablegen
    adr = 8;
    for (int i=0; i<4; i++) {
      by = (Wert_leer >> ((3-i)*8)) & 0x000000ff;
      EEPROM.write(adr+i, by);
    }
    
    // LEDs Anzeige fertig
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(6, HIGH);
    
    // Endlos-Loop
    for (;;){
    }

  }
  // Taste für Programmierung "voll"
  if (Taste_2 <50) {

    Serial.println("Programmierung voll");
  
    // Messreihe für voll
    long int Wert_voll;
    Wert_voll = freq_mess();
    for (int i=0; i<=3; i++) {
     Wert_voll = (Wert_voll + freq_mess()) / 2;
    }
    
    Serial.println(Wert_voll);   
     
    // Wert im EEProm ablegen
    adr = 16;
    for (int i=0; i<4; i++) {
      by = (Wert_voll >> ((3-i)*8)) & 0x000000ff;
      EEPROM.write(adr+i, by);
    }
    
    // LEDs Anzeige fertig
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, HIGH);
    digitalWrite(10, HIGH);
    
    // Endlos-Loop
    for (;;){
    }
  }
   
   // keine Taste - Wert berechnen und LEDs anzeigen
  
    // EEProm auslesen
  
      // Wert leer
      long int Wert_leer;
      adr=8;
      for(int i=0;i< 3;i++){
        Wert_leer += EEPROM.read(adr+i);
        Wert_leer = Wert_leer << 8;
      }
      Wert_leer += EEPROM.read(adr+3);
    
      // Wert voll
      long int Wert_voll;
      adr=16;  
      for(int i=0;i< 3;i++){
        Wert_voll += EEPROM.read(adr+i);
        Wert_voll = Wert_voll << 8;
      }
      Wert_voll += EEPROM.read(adr+3);

    Serial.println("Leer");
    Serial.println(Wert_leer);
    Serial.println("Voll");
    Serial.println(Wert_voll);
    Serial.println("Messung");
    
   // Vergleichsmessung 3x
    long int Wert_mess;
      Wert_mess = freq_mess();
      for (int i=0; i<=3; i++) {
       Wert_mess = (Wert_mess + freq_mess()) / 2;
      }
      
    Serial.println(Wert_mess); 
    
    // Auswerten
    int Schritt = (Wert_leer - Wert_voll) / 8;

    Serial.println("Schritt");
    Serial.println(Schritt);
    
    int LED[] = {2,3,4,6,7,8,9,10};
    for (int i=0; i<=7; i++) {
      if (Wert_mess < (Wert_leer - (i * Schritt))) {
        digitalWrite(LED[i], HIGH);
      }
      else {
        digitalWrite(LED[i], LOW);
      }
    }

    // Endlos-Loop
    for (;;) {
    }
}

long int freq_mess() {

  long int mfreq;
  FreqCounter::f_comp= 8;              // Kompensation einstellen
  FreqCounter::start(100);             // Zähler starten für 100ms
  while (FreqCounter::f_ready == 0)    // warten bis der Zähler fertig ist 
  mfreq=FreqCounter::f_freq;           // Ergebnis lesen
  return mfreq;
  
}

 

Füllstandsmelder mit einem Arduino und einem NE555

Beitragsnavigation


Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.