Kapazität messen, 400-700pF

[Hugo P. (portisch)]

Hallo,

ich möchte eine Wassersäule über die Kapazität bestimmen.
Ich habe ein Rohr (Durchmesser 20mm) das mir den Wasserstand im Pool 
anzeigt.

Nun habe ich am Rohr außen beidseitig ein Kupferband angebracht und 
diese Werte gemessen:

Rohr leer (0mm Wassersäule): ~400pF
Rohr voll (1500mm Wassersäule): ~610pF

(Gemessen mit Fluke)

Nun bin ich auf der Suche wie man das am besten und genau messen kann.

Die Messung befindet sich im Keller im Technikraum, also sollte die 
Luftfeuchtigkeit und Temperatur "fast" konstant bleiben.

Jetzt habe ich erste Versuche mit einem Atmega zur Kapazitätmessung 
gemacht:
Beitrag "Re: Ladekurve Kondensator, Analog Comparator, ACI"
Diese scheint mir aber zu ungenau. Umgerechnet komme ich auf eine 
Toleranz von +-15mm.

Nun will ich den Versuch wagen den Kondensator über einen Schwingkreis 
zu messen. Dazu habe ich den AD9533 entdeckt.


Bei einer Frequenz von 1kHz sollten ca. diese Werte rauskommen:
400pF: Xc == 397887,4 Ohm -> 0mm
610pF: Xc == 260909,7 Ohm -> 1500mm

Die echte Kapazität interessiert mich eigentlich nicht.
Ich brauche nur diese Werte um die Höhe rausrechnen zu können.
Die Kapazität ist ja linear proportional zur Wassersäule.

Also wäre das eine Differenz von 136977,6 Ohm was bei 1500mm Wassersäule 
91,318 Ohm/mm bedeutet.

Das könnte doch eigentlich recht gut funktionieren, oder?
Ich brauche vom AD9533 jedoch nur eine Messung mit konstanter Frequenz - 
kein Sweep. Gibt es da Alternativen?

Oder kann das auch mit einem NE555 und mit Input Capture des AVRs 
funktionieren um eine Auflösung von +-1-2mm zu bekommen?

Als Ausgang mache ich dann ein Analogsignal 0-5V was 0..1500mm 
entsprechen soll.

[Falk B. (falk)]

@Hugo Portisch (portisch)

>Rohr leer (0mm Wassersäule): ~400pF
>Rohr voll (1500mm Wassersäule): ~610pF

Geht so.

>Nun bin ich auf der Suche wie man das am besten und genau messen kann.

RC-Oszillator mit NE7555 oder TLC555, das ist die CMOS-Version des 
NE555.

>Jetzt habe ich erste Versuche mit einem Atmega zur Kapazitätmessung
>gemacht:
>Beitrag "Re: Ladekurve Kondensator, Analog Comparator, ACI"
>Diese scheint mir aber zu ungenau.

Naja, man muss es hat besser umsetzen. Im Prinzip geht das schon besser.

>Die echte Kapazität interessiert mich eigentlich nicht.

Eben. Also baut man es auf und kalibriert danach. Fertig.

>Also wäre das eine Differenz von 136977,6 Ohm was bei 1500mm Wassersäule
>91,318 Ohm/mm bedeutet.

Man nutzt die Kapazität zur Frequenzerzeugung. Ob nun ein RC oder 
LC-Oszillator ist egal.

>Oder kann das auch mit einem NE555 und mit Input Capture des AVRs
>funktionieren um eine Auflösung von +-1-2mm zu bekommen?

Kann sein. Aber man macht da eine Frequenzmessung, die ist genauer. 
Schließlich hast du alle Zeit der Welt.

>Als Ausgang mache ich dann ein Analogsignal 0-5V was 0..1500mm
>entsprechen soll.

Und wozu? Wenn du den Wert im AVR digital hast, wandelt den man doch 
nicht wieder in analog!

[Der Andere (Gast)]

Hugo P. schrieb:
> Nun habe ich am Rohr außen beidseitig ein Kupferband angebracht und
> diese Werte gemessen:

Wie hast du das Band aufgebracht?
Kannst du noch jeweils 2 Bänder daneben machen? Damit erhöht sich die 
Kapazität und du kannst ggf. genauer messen.

[foobar (Gast)]

BigClive hatte mal nen Wasserstandsensor einer Waschmaschine 
auseinandergenommen. Die benutzen ne Spule, nen "schwimmenden" Kern und 
einen 74HC4060 (Oszillator mit Teiler). Der Oszillator schwingt bei ca 
200kHz und wird dann auf die Ausgangsfrequenz von 8-13Hz runtergeteilt.

https://www.youtube.com/watch?v=O-0KGbd91_I

[Patrick B. (p51d)]

Wie währe es mit einer kapazitiven Messbrücke? Diese mit "genauen" NPO 
Kondensatoren bestücken und die Brückenspannung messen. Dann etwas 
rechnen und schon hast du einen sehr genauen Wert. Kannst das ganze 
durch eichen und Verstärker natürlich noch verbessern...

[Gerhard D. (gedu)]

Hallo,
zur Wandfeuchtmessung habe ich mir sowas gebaut:
Mit einem ATMEGA48 wird ein astabiler Multivibrator programmiert, der 
über die Input Capture Funktion des Timers1 und den analogen Komparator 
die Periode(256 Perioden gemittelt) des AMV misst. Als stabiler 
Nullpunkt wird ein 100pF Kondensator(Syroflex o. ä.) fest an den Eingang 
geschaltet.
Die Auflösung ist besser als 0,1pF. Der Meßbereich ca. 0 ... 18000pF, 
kann durch Zählen der Überläufe von Timer1 erweitert werden.

Gerhard

[Alex E. (tecnologic)]

Hi

ich habe eine ähnliche Anwendung, ich nutze dafür den FDC1004 siehe 
folgende AppNote:

http://www.ti.com/lit/ug/tidu736a/tidu736a.pdf

Gruß

Alex

[Info (Gast)]

https://www.mikrocontroller.net/search?query=füllstand*

http://njhurst.com/electronics/watersensor/

https://www.elv.de/kapazitiver-fuellstandsmesser-hm-sen-wa-od-komplettbausatz.html

Beitrag "Füllstandsanzeige"
Beitrag "Kapazitive Füllstandsmessung"

Beitrag "qtouch - sekt oder selters"

[Harald (Gast)]

Das sehr erfolgreiche Projekt des Transistortesters hat auch eine 
Kapazitätsmessung im Programm, die verblüffend genau ist. Die solltest 
du dir anschauen und ggf. übernehmen.

Artikel:

https://www.mikrocontroller.net/articles/AVR_Transistortester

Thread (lang & unübersichtlich):

Beitrag "Transistortester AVR"

[Hugo P. (portisch)]

Also ich habe nun folgendes ausprobiert:
Oszilator mit NE555. Über den Kondensator wird dann die Frequenz 
gemessen.
Das ganze war wegen dem Jitter des NE555 zu unstabil.

Dann habe ich mir das mit dem 74HC4060 wie foobar vorgeschlagen hat 
angesehen.
Super Sache!

Ich greife das Signal bei Q11 ab was um die 450Hz liegt. Das Signal 
sollte also 450Hz * 2048 == 921600Hz haben.

Nun habe ich einen Laboraufbau mit zwei Flaschen gemacht die per 
Schlauch verbunden sind. Dann habe ich eine Aufnahme mit "virtuell" 0mm 
gemacht und dann 40mm:
mm  digits
0  27071
40  30335

Dadurch komm ich auf eine Auflösung von 81,6 Digits/mm was 
~0,012mm/Digit bedeutet.

Also habe ich dann Gain und Offset bestimmt und kann die Höhen von den 
Digits rausrechnen.

Dann habe ich aber eine Kurve aufgenommen wo ich nicht rausfinde wo der 
Fehler liegt. Man sieht das von 0mm auf 40mm gefüllt wird. Danach sollte 
es auf 2,5mm und 0mm runtergehen. Es bleibt aber bei 5,1mm und 2,9mm 
stehen!?

Warum kommt es nicht mehr auf 2,5 und 0mm?
Oder hängt das mit Oberflächenspannung usw. zusammen?

Werde noch einen Versuch machen wo ich eine Definierte Menge Wasser 
entferne und hinzufüge.

Wie wirkt es sich aus wie "schlampig" die Kupferbänder geklebt sind?
Sollte eigentlich nur die Linearität beeinflussen aber nicht den 
Absolutwert, oder?

Oder ist meine Messfrequenz zu hoch? Was wäre ein "brauchbarer" Wert, 
100kHz?

EDIT:
Habe gerade nochmal von 0mm auf 40mm getestet. Das Ergebnis liegt bei 
30313 Digits was 39,7mm entspricht... Warum nicht 40mm?

Verwendet wurde der Source von hier:
https://www.mikrocontroller.net/articles/High-Speed_capture_mit_ATmega_Timer

Abgeändert schaut er nun so aus und macht 5*100 Messungen nur auf die 
Positive Flanke:

/*
 * Created: 09.04.2018 11:06:58
 */ 

#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include "uart/uart.h"
#define BAUD  9600L


uint16_t single_capture[100];
uint16_t captures[5];
uint32_t result;

////////////////////////////////////////////////////////////////////////////////
// Helper macros
////////////////////////////////////////////////////////////////////////////////
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) // clear bit 
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))  // set bit

void io_init(void)
{
  // all pins output
  DDRB = 0xFF;
  DDRC = 0xFF;
  DDRD = 0xFF;
  
  PORTB = 0;
  PORTC = 0;
  PORTD = 0;
    
  /* disable pull up on analog channels */  
  cbi(DDRB, PB0);      // switch to input
  PORTB &= ~(1 << PB0);  // no Pull-up
}

// Wait for a signal on pin ICP1 and store the captured time values in the array 'captureData'
uint16_t startCapture(void)
{
  register uint8_t ices1_val = _BV(ICES1) | _BV(CS10); 
  register uint8_t tccr1b = TCCR1B | ices1_val; // trigger on rising edge
  TCCR1B = tccr1b;
  OCR1A = TCNT1 - 1;
  TIFR1 = _BV(ICF1) | _BV(OCF1A) | _BV(TOV1); // clear all timer flags
  register uint16_t prevVal = 0;
  register uint8_t tifr; // cache the result of reading TIFR1 (masked with ICF1 and OCF1A)
  int i;

  for(i = 0; i < sizeof(single_capture); i++)
  {
    // wait for edge or overflow (output compare match)
    while(! (tifr = (TIFR1 & (_BV(ICF1) | _BV(OCF1A)))));
    
    uint16_t val = ICR1;
    OCR1A = val; // timeout based on previous trigger time

    TIFR1 = _BV(ICF1) | _BV(OCF1A); // clear input capture and output compare flag bit

    uint16_t diffVal = val - prevVal;
    single_capture[i] = diffVal;

    prevVal = val;
  }
 
  // the first array entry contains only the starting time and no time
  // difference, therefore it is no longer needed and will be removed 
  uint32_t average = 0;
  for(i = 1; i < sizeof(single_capture); i++)
    average  += single_capture[i];
  
  average /= sizeof(single_capture) - 1;
 
  return (uint16_t)average;
}

int main(void)
{
  static char buff[6];
  
  cli();
  MCUSR = 0;
  wdt_disable();
  
  io_init();
  
  // initialize uart  
  uart_init((UART_BAUD_SELECT((BAUD),F_CPU)));
  
    while(1)
    {
        //TODO:: Please write your application code           
    static int i;
    
    for (i = 0 ; i < sizeof(captures); i++)
      captures[i] = startCapture();
    
    result = 0;
    for (i = 0 ; i < sizeof(captures); i++)
      result += captures[i];

    result /= sizeof(captures);
    
    sprintf(buff, "%05u", (uint16_t)result);
    buff[sizeof(buff) - 1] = '\n';
    
    for (i = 0; i < sizeof(buff); i++)
      uart_putc(buff[i]);    
    }
}

[Andre R. (ltisystem)]

oder du nutzt nen ultraschallsensor, den du oben am rohr anbringst. das 
geht schnell, ist einfach und ziemlich genau. ggf. musste dort n 
bisschen glätten, falls das schwankt aber sonst sollte das 
funktionieren.


https://de.aliexpress.com/item/HC-SR04-Ultrasonic-Sensor-Distance-Measuring-Module-for-Arduino-Microcontroller/32316140080.html?src=google&albslr=202742307&isdl=y&aff_short_key=UneMJZVf&source=%7Bifdyn:dyn%7D%7Bifpla:pla%7D%7Bifdbm:DBM&albch=DID%7D&src=google&albch=shopping&acnt=494-037-6276&isdl=y&albcp=664345099&albag=32945289759&slnk=&trgt=61865531738&plac=&crea=de32316140080&netw=g&device=c&mtctp=&gclid=EAIaIQobChMIusyoqcmt2gIVEImyCh1C0Q0pEAQYAiABEgK7UPD_BwE&gclsrc=aw.ds
--> das sind die, kannste mit nem arduino ansteuern, die nano kosten 3 
stück 6 euro bei ebay.


https://de.aliexpress.com/item/Waterproof-Ultrasonic-Module-JSN-SR04T-Water-Proof-Integrated-Distance-Measuring-Transducer-Sensor-for-Arduino/32737664269.html?src=google&albslr=220833420&isdl=y&aff_short_key=UneMJZVf&source=%7Bifdyn:dyn%7D%7Bifpla:pla%7D%7Bifdbm:DBM&albch=DID%7D&src=google&albch=shopping&acnt=494-037-6276&isdl=y&albcp=664345099&albag=32945289759&slnk=&trgt=61865531738&plac=&crea=de32737664269&netw=g&device=c&mtctp=&gclid=EAIaIQobChMIusyoqcmt2gIVEImyCh1C0Q0pEAQYAyABEgKiq_D_BwE&gclsrc=aw.ds
--> wasserdicht variante

[DerDaDrüben (Gast)]

Sieh dir mal die Schaltung an:
https://www.mikrocontroller.net/articles/Giess-o-mat#Die_Feuchtigkeitssensoren

[Harald W. (wilhelms)]

foobar schrieb:

> BigClive hatte mal nen Wasserstandsensor einer Waschmaschine
> auseinandergenommen. Die benutzen ne Spule, nen "schwimmenden" Kern und
> einen 74HC4060 (Oszillator mit Teiler). Der Oszillator schwingt bei ca
> 200kHz und wird dann auf die Ausgangsfrequenz von 8-13Hz runtergeteilt.

In den achtziger Jahren gab es mal viele Schaltungsvorschläge für
kapazitive Feuchtigkeitssensoren von Phillips. Die arbeiten in
einem ähnlichen Kapazitätsbereich wie der Sensor vom TE, sodas
man diese Auswerteschaltung, die man sicher auch im Netz finden
wird, ohne grössere Änderungen übernehmen könnte. Die Anzeige
hat man damals typischerweise per Zeigerinstrument gemacht.