Touch, Entprellen und "Statemachine light"

Hallo Leute,

ich habe hier etwas probiert wo ich grad etwas hänge…
Ich baue einen Touch-Taster mit der CapSense-Bibliothek, der von unten in eine solide Acryl-Platte eingelassen wird - so weit so gut (das funktioniert recht gut).
Den “Taster” möchte ich aber entprellen - und er soll im Betrieb sauber zwischen “Aus” (rote LED) und “An” (grüne LED) schalten und nicht bei jedem Fingerwackler hin-und-her-zappen. (im Grunde also schon entprellen).
Mein Problem ist bei ////Hier ist das Problem!///// - wie übergebe ich den Event richtig, der durch den Schwellwert 49 ausgelöst wird? Der Wert 1 den ich an TasterState übergebe ist falsch, weil ich da meine Modulo- Logik negiere. Aber wie übergebe ich das denn sonst richtig? Ich komm da grad nicht weiter. Kann mir jemand bitte einen Tipp geben, wie ich das lösen kann?

Nette Grüße

Thomas

#include <CapSense.h>

/* CapitiveSense Library Demo Sketch
 * Original: Paul Badger 2008
 */
int ledPin;
int touchWert = 0;
int tasterState = 0;
int old_tasterState = 0;
int zaehler = 0;
CapSense cs = CapSense(8,4);        // 1.8 M R zw. pins 4 u. 8, pin 4 ist sensor pin

void setup()                    
{
  ledPin = 13;
  // redPin =
  // greenPin =
  cs.set_CS_AutocaL_Millis(10000);     // Autocal alle 10sec
  Serial.begin(9600);
}

void loop()                    
{
      long start = millis();
      long touch =  cs.capSense(40);

   if (touch >=49) {                                                                                                                /////Hier ist das Problem! /////////
      touchWert = 1;
      tasterState = touchWert;  //Abfrage Taster
      if(old_tasterState != tasterState){//ist vorheriger Wert ungleich aktuellem?
        if(tasterState == HIGH){
          zaehler++; //Zähler inkrementieren
        }
     }
 old_tasterState = tasterState; //speichern des aktuellem Satus
 
 if(zaehler%2 == 0) //ist Zähler eine gerade Zahl?
 digitalWrite(ledPin,HIGH);
 else
 digitalWrite(ledPin,LOW);
    }
        
    Serial.print(millis() - start);          // gibt millis der Messung aus
    Serial.print("\t");                      
    Serial.println(touch);                  // gibt Sensorwert aus

    delay(800);                             // reduziert den Traffic auf dem Seriellen port 
}

Das habe ich beinahe befürchtet...

Die Problematik scheint ziemlich speziell....

Ich würde mich trotzdem über gedankliche Anregungen freuen...

Grüße

Thomas

Ich kenne diese Capsense Geschichte nicht, aber ein effizienter Weg um zwischen zwei Zuständen zu differenzieren ist eine eingebaute Hysterese. Entkoppelt die Ansprechwerte beliebig.

woodmaster:
Die Problematik scheint ziemlich speziell....

Tja, es gibt wahrscheinlich nicht viele, die zwei Pins und Zusatzhardware für etwas verbraten wollen, das auch mit einem Pin und ohne Zusatzhardware funktioniert.

woodmaster:
Ich würde mich trotzdem über gedankliche Anregungen freuen...

Probier's doch mal mit Touch und einem einzigen Pin!

Vom Feintuning her weiß ich nicht, aber die Touch-Logik ist angelehnt an Arduino Playground - CapacitiveSensor und als Entprellzeit habe ich mal 20 ms delay eingefügt.

Das Demoprogramm schaltet auf Touch an Pin-3 die Board-LED an Pin-13

#define LEDPIN 13

boolean touchPin(int pinToMeasure) {
  // Variables used to translate from Arduino to AVR pin naming
  volatile uint8_t* port;
  volatile uint8_t* ddr;
  volatile uint8_t* pin;
  // Here we translate the input pin number from
  //  Arduino pin number to the AVR PORT, PIN, DDR,
  //  and which bit of those registers we care about.
  byte bitmask;
  port = portOutputRegister(digitalPinToPort(pinToMeasure));
  ddr = portModeRegister(digitalPinToPort(pinToMeasure));
  bitmask = digitalPinToBitMask(pinToMeasure);
  pin = portInputRegister(digitalPinToPort(pinToMeasure));
  // Discharge the pin first by setting it low and output
  *port &= ~(bitmask);
  *ddr  |= bitmask;
  delay(1);
  // Make the pin an input with the internal pull-up on
  *ddr &= ~(bitmask);
  *port |= bitmask;

  // Now see how long the pin to get pulled up. This manual unrolling of the loop
  // decreases the number of hardware cycles between each read of the pin,
  // thus increasing sensitivity.
  uint8_t cycles = 17;
       if (*pin & bitmask) { cycles =  0;}
  else if (*pin & bitmask) { cycles =  1;}
  else if (*pin & bitmask) { cycles =  2;}
  else if (*pin & bitmask) { cycles =  3;}
  else if (*pin & bitmask) { cycles =  4;}
  else if (*pin & bitmask) { cycles =  5;}
  else if (*pin & bitmask) { cycles =  6;}
  else if (*pin & bitmask) { cycles =  7;}
  else if (*pin & bitmask) { cycles =  8;}
  else if (*pin & bitmask) { cycles =  9;}
  else if (*pin & bitmask) { cycles = 10;}
  else if (*pin & bitmask) { cycles = 11;}
  else if (*pin & bitmask) { cycles = 12;}
  else if (*pin & bitmask) { cycles = 13;}
  else if (*pin & bitmask) { cycles = 14;}
  else if (*pin & bitmask) { cycles = 15;}
  else if (*pin & bitmask) { cycles = 16;}

  // Discharge the pin again by setting it low and output
  //  It's important to leave the pins low if you want to 
  //  be able to touch more than 1 sensor at a time - if
  //  the sensor is left pulled high, when you touch
  //  two sensors, your body will transfer the charge between
  //  sensors.
  *port &= ~(bitmask);
  *ddr  |= bitmask;
  delay(20); // debounce 20ms
  return (cycles>1);
}


void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(LEDPIN,OUTPUT);
}

boolean touchDown;
void loop() {
  // put your main code here, to run repeatedly: 
  boolean currentTouch=touchPin(3);
  if (currentTouch && !touchDown) 
  {
    touchDown=true;
    digitalWrite(LEDPIN,!digitalRead(LEDPIN));
  }
  else if (!currentTouch && touchDown)  
  {
    touchDown=false;
  }
}

@ jurs

[/quote]
Vom Feintuning her weiß ich nicht, aber die Touch-Logik ist angelehnt an Arduino Playground - CapacitiveSensor und als Entprellzeit habe ich mal 20 ms delay eingefügt.
Das Demoprogramm schaltet auf Touch an Pin-3 die Board-LED an Pin-13
[/quote]

Danke für Deine Anregungen - werd ich gleich mal probieren....
Aber ich ging davon aus, dass bei diesem Beispiel immer ein direkter leitfähiger Kontakt mit dem "Fühler-Draht" erfolgen muss. In meinem Falle ist es ein echter kapazitiver Touch "Schalter" ohne, dass ein direkter leitfähiger Kontakt mit dem Draht erfolgen muss.

Mfg Thomas

woodmaster:
Aber ich ging davon aus, dass bei diesem Beispiel immer ein direkter leitfähiger Kontakt mit dem “Fühler-Draht” erfolgen muss. In meinem Falle ist es ein echter kapazitiver Touch “Schalter” ohne, dass ein direkter leitfähiger Kontakt mit dem Draht erfolgen muss.

Ja, mit der Ein-Pin-Auswertung mußt Du schon an den Draht oder die Sensorfläche richtig dranlangen (“Berührung”), damit der “Touch” erkannt wird. Die aufgebrachte Ladung muß über den Masseschluß des Körpers zur Erde abgeführt werden.

Was machst Du denn? Finger berührungslos über der Sensorfläche schweben lassen?
Und dabei soll es eine einwandfreie Schaltschwelle geben, schon vor einer Berührung?

Da schließe ich mich meinem Vorredner an, das bekommst Du nur mit einer Hysterese-Auswertung hin.

Also nicht schalten auf 49, kleiner ist untouched und größer gleich betatscht.

Sondern mit Hysterese in der Annährung auf größere Werte ist z.B. alles kleiner 52 ein No-Touch und erst 52 ein “Touch”, und bei Entfernung bleiben auch z.B. 52, 51, 50, 49, 48, 47 ein Touch und erst 46 wird dann wieder ein No-Touch.

@ jurs

Wie ich schrieb arbeite ich einen Sensor in eine solid surface -Platte ein (in meinem Falle Corian), dabei soll die hygienische und wasserfeste Oberfläche des Materials nicht beeinträchtigt werden.

Ich hatte auch keinerlei Probleme mit der touch - Funktionalität - mein Problem bestand und besteht noch in der korrekten Übergabe an die "state machine" also an die Umschaltlogik. Ich habe eine klassische tasterabfrage durch meine CapSense Geschichte ersetzt und dann eine kombinierte Entprellfunktion und einen Zustandsautomaten angefügt. Wie ich feststellen musste nicht korrekt. Nun meine Frage: Was habe ich falsch gemacht bzw. was kann ich besser machen?

Alle Probleme kulminieren so in etwa um die Zeile 30 im Code...

Thomas

woodmaster:
Wie ich schrieb arbeite ich einen Sensor in eine solid surface -Platte ein (in meinem Falle Corian), dabei soll die hygienische und wasserfeste Oberfläche des Materials nicht beeinträchtigt werden.

Ah, jetzt ist der Groschen gefallen: Ich war davon ausgegangen, dass Du eine "Kontaktniete" durch Deine Platte nietest, die dann berührt wird und deren Berührung wird ausgewertet ("Touch"). Tatsächlich ist der elektrische Kontakt aber unterhalb einer isolierenden Fläche und ausgewertet wird eher eine "Annährung" als ein tatsächliches "Touch".

Also mehr kapazitiver Nährungsschalter statt kapazitiver Berührungsschalter.

Um so einen Versuchsaufbau hier nachzustellen, fehlt mir ein hochohmiger Widerstand in meiner Bastelkiste. Gerade mal nachgesehen, bei 500 K ist Schluss und 10 M Widerstände habe ich gar nicht.

Ohne Testmöglichkeit habe ich Dir trotzdem mal zwei Funktionen gemacht.

Einmal die Funktion "pressed()", die beim Aufruf immer Null zurückliefert, außer in dem Augenblick, in dem ein "Touch" ausgelöst wird, einmal pro Annährung/Berührung.

Und einmal die Funktion "state()", die bei jedem Aufruf den Status zurückliefert, also ob die Schaltfläche gerade "berührt" wird oder nicht.

Beide Funktionen arbeiten mit Hysterese, statt mit einem festen Schaltpunkt. Statt also fest vorzugeben, dass bei 49 die Schaltgrenze ist, liegt die Schaltgrenze bei nicht ausgelöstem Schalter in der Annährung etwas höher (z.B. 51), so dass erst bei 51 (statt 49) geschaltet wird. Und wenn man sich bei ausgelöstem Schalter wieder entfernt, wird erst bei einem etwas niedrigeren Wert (47) der logische Schaltzustand wieder auf "nicht geschaltet" zurückgesetzt. Diese Hysterese verhindert ein nervöses Hin- und Herschalten des logischen Schaltzustands in der Nähe des Schaltpunktes.

Die tatsächlichen Schaltpunkte können in meinem Beispiel eingestellt werden und es muss experimentell ermittelt werden, wie gross der Unterschied zwischen beiden Werten am besten ist:
#define SCHALTPLUSHYST 51
#define SCHALTMINUSHYST 47

Code für die pressed() und die state() Funktion:

// Statt Schaltpunkt bei 49, zwei Schaltpunkte mit Hysterese
#define SCHALTPLUSHYST 3
#define SCHALTMINUSHYST 1

boolean pressed()
{
  static boolean touchDown=false;
  boolean currentTouch;
  if (touchDown) currentTouch=(cs.capSense(40)>SCHALTMINUSHYST);
  else currentTouch=(cs.capSense(40)>SCHALTPLUSHYST);
  if (currentTouch && !touchDown) 
  {
    touchDown=true;
    return true;
  }
  else if (!currentTouch && touchDown)  
  {
    touchDown=false;
  }
  return false;
}

boolean state()
{
  static boolean touchDown=false;
  boolean currentTouch;
  if (touchDown) currentTouch=(cs.capSense(40)>SCHALTMINUSHYST);
  else currentTouch=(cs.capSense(40)>SCHALTPLUSHYST);
  if (currentTouch && !touchDown) 
  {
    touchDown=true;
  }
  else if (!currentTouch && touchDown)  
  {
    touchDown=false;
  }
  return touchDown;
}

Verwendung der pressed() Funktion beispielsweise:

void loop() {
   if (pressed())  Serial.println("Touch");
}

Verwendung der state() Funktion beispielsweise:

boolean bstate=false;
void loop() {
   boolean curstate;
   curstate=state();
   if (curstate!=bstate)
   {
     bstate=curstate;
     Serial.println(bstate);
   }  
}

(Sämtlicher Code ungetestet, da ich weder Deine Library noch Deinen Versuchsaufbau hier habe)

@jurs

Danke für Deine Mühe - ich werd es mal ausprobieren. Das wird aber erst morgen... War heute zu einer Tagung und hab auf dem Heimweg noch einen Termin drangehängt, bin also noch nicht lang daheim...
Der Verkehr und das Wetter waren auch eher bescheiden - drum werden heute Abend keine "Basteleien" mehr stattfinden - ich hab einfach keinen Nerv mehr dafür....

Grüße

Thomas

PS: Ich habe noch eine andere Idee - es gibt da einen touch IC von Atmel, den werd ich mal testen (hab ein Sample bestellt und gestern Abend noch eine Protoplatine für QFN28...)
Der chip ist 4 x 4 mm bei 28 pins.... :wink:

@jurs

Ich muss Dich leider enttäuschen - es funktioniert im Grunde schlechter als meine Varianten - es ist wesentlich volatiler, dann passiert eine ganze Zeit gar nichts, plötzlich wieder ein Haufen Touchs..... Nee so wird das nix...

Ich werde meine Variante noch mal überarbeiten und gut.

Danke trotzdem für die Hilfe.

Mfg Thomas

hi,

ich mehme an, mit dem touch-ic von atmel meinst Du einen QTouch-fähigen. das können die meisten atmel-avrs (auch tinys), aber dazu muß die qtouch-library ins atmel-studio eingebunden werden und das kann man nur damit programmieren. eine portierung auf arduino ist mir nicht bekannt.

gruß stefan

woodmaster:
@jurs

Ich muss Dich leider enttäuschen - es funktioniert im Grunde schlechter als meine Varianten - es ist wesentlich volatiler, dann passiert eine ganze Zeit gar nichts, plötzlich wieder ein Haufen Touchs… Nee so wird das nix…

OK, jetzt habe ich mal den größten aufzufindenden Widerstand aus meiner Bastelkiste herausgekramt und einen Versuchsaufbau gemacht. 820K ist zwar nicht 10M, aber besser als nichts und folgendes habe ich beim Testen festgestellt:

  1. Ich verwende irgendwie eine etwas andere Library als Du. Ich habe mich an http://playground.arduino.cc//Main/CapacitiveSensor?from=Main.CapSense gehalten und die dort genannte Library installiert. Die Klasse und die Funktionen sind teilweise etwas anders benannt als bei Dir.

  2. Die Messwerte bei den Messungen schwanken extrem stark. Viel stärker, als ich gedacht hatte. Daher muss eine viel größere Hysterese angenommen werden. Bei meinem Versuchsaufbau verwende ich nun:
    #define SCHALTPLUSHYST 60
    #define SCHALTMINUSHYST 20

Die Codeschnipsel waren schon völlig korrekt, nur die angenommene Hysterese viel zu klein.

Mein Test-Sketch mit Library https://github.com/arduino-libraries/CapacitiveSensor/zipball/master :

#include <CapacitiveSensor.h>

CapacitiveSensor cs = CapacitiveSensor(8,4);   // 1.8 M R zw. pins 4 u. 8, pin 4 ist sensor pin
// bei mir getestet mit R= 820K
#define SCHALTPLUSHYST 60
#define SCHALTMINUSHYST 20

boolean pressed()
{
  static boolean touchDown=false;
  boolean currentTouch;
  if (touchDown) currentTouch=(cs.capacitiveSensor(40)>SCHALTMINUSHYST);
  else currentTouch=(cs.capacitiveSensor(40)>SCHALTPLUSHYST);
  if (currentTouch && !touchDown) 
  {
    touchDown=true;
    return true;
  }
  else if (!currentTouch && touchDown)  
  {
    touchDown=false;
  }
  return false;
}

boolean state()
{
  static boolean touchDown=false;
  boolean currentTouch;
  if (touchDown) currentTouch=(cs.capacitiveSensor(40)>SCHALTMINUSHYST);
  else currentTouch=(cs.capacitiveSensor(40)>SCHALTPLUSHYST);
  if (currentTouch && !touchDown) 
  {
    touchDown=true;
  }
  else if (!currentTouch && touchDown)  
  {
    touchDown=false;
  }
  return touchDown;
}

void setup()
{
  Serial.begin(9600);
  cs.set_CS_Timeout_Millis(100);
}



void Messwert() {
  // Ausgabe eines Messwertes
  Serial.println(cs.capacitiveSensor(40));
}

void touched() {
  // Gibt bei jeder Annährung einmalig "Touch" aus.
   if (pressed()) Serial.println("Touch");
}

void StateChange() {
  // Statuswechsel: Funktion gibt bei Annährung eine "1" und bei Entfernung eine "0" aus
  static boolean bstate=false;
  boolean curstate;
  curstate=state();
  if (curstate!=bstate)
  {
    bstate=curstate;
    Serial.println(bstate);
  }  
}


void loop() 
{
  // Zum Testen je eine der folgenden drei Funktionen aktivieren
  // und die zwei anderen auskommentieren:
//  Messwert();
//  touched();
  StateChange();
}

In der loop stehen drei verschiedene Funktionsaufrufe, von denen man zum Testen je zwei auskommentieren und einen aufrufen kann.

Hast Du in Deiner Schaltung eigentlich den optionalen kleinen Kondensator “Cpin” eingebaut, der die Messwerte der Library stabilisieren soll? Ich habe diesen Kondensator jedenfalls nicht eingebaut.

Für Deinen konkreten Sensor (Sensorfläche, Widerstand, ggf. Kondensator Cpin) mußt Du anhand der Messwerte die optimalen Werte für die Konstanten SCHALTPLUSHYST und SCHALTMINUSHYST finden. Mein Vorschlag wäre, dass da nicht nur wenige Zahlen zwischen diesen beiden Konstanten liegen, sondern eher ein Faktor 2 oder 3, also dass SCHALTPLUSHYST zwei- bis dreimal größer eingestellt wird als SCHALTMINUSHYST, damit schwankende Messwerte nicht zu schnellen Schaltungen führen können.

Hallo woodmaster,
hallo jurs,

auch ich kämpfe im Moment mit der Library und mit den extrem schwankenden Werten. Ich versuche im Moment 4 Schalter zum laufen zu bekommen. De Aufbau ist bei allen 4 gleich jedoch funktionieren nur die letzten beiden......

Testen tue ich grad mit dem Mega2560. Als R kommen jeweils 4 Mohm zum einsatz. Will heute Abend mal 10MOhm probieren ob das besser geht.

Das einzigste was ich anders habe: Ich benutze jeweils einen "neuen" SendePin. Also jeder Touch Sensor hat seinen eigenen SendePin. Das scheint irgendwie nicht so gut zu funktionieren. Ich werde das heute Abend ebenfalls probieren auf einen einzigen zu reduzieren.

@woodmaster: Biste jetzt eigentlich weitergekommen?

ht81:
auch ich kämpfe im Moment mit der Library und mit den extrem schwankenden Werten. Ich versuche im Moment 4 Schalter zum laufen zu bekommen. De Aufbau ist bei allen 4 gleich jedoch funktionieren nur die letzten beiden…

Testen tue ich grad mit dem Mega2560. Als R kommen jeweils 4 Mohm zum einsatz. Will heute Abend mal 10MOhm probieren ob das besser geht.

Kapazitive Nährungsschalter reagieren mit einem Ansteigen der Messwerte auf um so größere Entfernung, je größer der Widerstandswert in der Schaltung ist.

Die Werte von Messung zu Messung schwanken selbst bei identischem Handabstand zum Sensor innerhalb einer einzigen Millisekunde extrem stark.

http://playground.arduino.cc//Main/CapacitiveSensor?from=Main.CapSense
Mit Verwendung eines kleinen Kondensators Cpin soll das die Messwerte stabilisieren. Ich habe es nicht ausprobiert. Verwendest Du einen Cpin in der Schaltung?

Bei Verwendung mehrer Nährungsschaltflächen gilt es auch zu beachten, dass wenn die Schaltflächen zu dicht nebeneinander liegen, die Annährung einer Hand mehrere Schalter gleichzeitig betätigt. Wenn ich mal die Breite einer Hand (die wohl meistens zum Schalten verwendet wird) mit ca. 15 cm annehme, dann müssen die Schaltflächen ja weiter als die 15 cm auseinander liegen, um eindeutig unterschieden werden zu können. Also bei Verwendung kapazitiver Nährungsschalter nebeneinander angeordnet mindestens 20 cm Abstand zwischen Schalter und Schalter. Hast Du so einen Mindestabstand zwischen den Schaltern?

Wenn nicht, dann würde ich anstelle eines kapazitiven Nährungsschalters mit 2-pin Beschaltung wie ihn woodmaster verwenden möchte, eher einen kapazitiven Berührungsschalter mit 1-pin Beschaltung (ohne Widerstand, ohne Kondensator) verwenden, bei dem sich die Hand einem metallischen Teil nicht nur annähren muss, sondern das tatsächlich berührt werden muß.

Jedenfalls muß wegen der schwankenden Messwerte eine Hysterese in ausreichender Höhe berücksichtigt werden, beim Berührungsschalter (mein Code in Reply #3) genauso wie beim Nährungsschalter (mein Code in Reply #11).

Hallo,

also ich bekomme es nicht hin. Ich habe jetzt mal den Beispielsketch genommen und mir die Werte nochmals angesehen. Mein Abstand zwischen den "Buttons" sind ca. 8mm. Mein Problem ist nicht die Erkennung sondern die enorm Schwankende Werte. Ich setzte als R 4 MOhm ein. Den cPin bringt rein gar nichts. Mein Problem ist, wenn ich die Platten mit dem Finger berühre klappt alles sehr gut, da bekomme ich ganz eindeutige Signale und kann mit der Hysterese gut Arbeiten.

Ich möchte die Platten jedoch hinter 6mm Plexiglas setzten. Hier habe ich einen Wert von "nur" noch ca.irgendwo zwischen 70 & 120 jenachdem wie stark ich drücke. Jedoch "rauscht" das Signal irgendwo zwischen 0 - keine Ahnung. Jedenfalls nicht gut genug. Der cPin hat nur wirklich Minimale auswirkungen. Ein weiterer Versuch wäre 10M zu nehmen. Jedoch wird dann alles wirklich schei....e empfindlich. Aber das mache ich erst morgen. Für heute habe ich keinen Bock mehr..... :roll_eyes:

ht81:
Jedoch "rauscht" das Signal irgendwo zwischen 0 - keine Ahnung.

Ein Rauschen "von 0 bis irgendwo" kannst Du niemals entprellen.
Damit ist die Messung nicht in Ordnung.
Vielleicht hilft ein kleines "delay" nach jeder Messung, um die Werte konstanter zu bekommen?

Was Du als Messwerte beispielsweise gut entprellen kannst, wäre, wenn Du

  • im Ruhezustand einen Messwert "0 bis 90" hast
  • bei Annährung einen Messwert "50 bis 200"

Dann setzt Du beispielsweise:
#define SCHALTPLUSHYST 100
#define SCHALTMINUSHYST 40

D.h. SCHALTPLUSHYST muß oberhalb des höchsten Messwertes im Ruhezustand liegen.

Und SCHALTMINUSHYST muß auf jeden Fall zwei Bedingungen erfüllen:
a) SCHALTMINUSHYST muß deutlich kleiner sein als SCHALTPLUSHYST
b) SCHALTMINUSHYST muss kleiner sein als der kleinste bei Annährung gemessene Wert

Solange die Messwerte in einem bestimmten Annährungszustand um das dreifache schwanken, ist alles kein Problem und Du kannst problemlos Schaltpunkte für das perfekte Schalten finden.

Aber wenn sowohl im Ruhezustand als auch bei Annährung Werte "von null bis irgendwo" gemessen werden, sind das keine geeigneten Messwerte, sondern Zufallswerte, mit denen nichts sinnvoll geschaltet werden kann.

Wenn wenigstens "der Durchschnitt der Messungen" im Zeitverlauf bei Annährung größere Werte ergibt als im Ruhezustand, könnte man eventuell was mit exponentieller Glättung machen: Man nimmt dann nicht einen der stark schwankenden Einzel-Messwerte als Messwert an, sondern ermittelt zunächst einen "gleitenden Durchschnittswert" aus mehreren Messungen nacheinander, der per exponentieller Glättung ermittelt wird. Der geglättete Wert schwankt weniger als die verrauschten Einzelwerte und kann daher besser zum Schalten verwendet werden. Allerdings wird der Schalter dadurch träger. Hast Du mal festgestellt, wieviele Messwerte pro Sekunde man überhaupt bekommt? Falls es mehr als ca. 30 Messungen pro Sekunde sind würde ich sagen, dass man ggf. mit exponentieller Glättung zunächst problemlos Durchschnittswerte ermitteln kann, und geschaltet wird dann nach diesen Durchschnittswerten statt nach den stark schwankenden Einzelmesswerten.

Hi,

ja das mit dem Mittelwert hatte ich mir auch schon überlegt. Meine Idee wäre den Sensor für 100ms zu messen und dann den Mittelwert zu errechnen und anschließend per if ob der Zustand HIGH oder LOW ist. Das mit dem Delay wäre evtl. noch eine Option. Ja, ich denke “durch” das Plexiglas ist meine Änderung des Werten <= oder minimal Höher als das Rauschen und das wird auch das ganze Problem sein. Wenn ich die Kupferplatte direkt berühre funktioniert es einwandfrei. Da habe ich allerdings auch Werte die bis 300 gehen (Mit den 4MOhms), damit komme ich doch deutlich aus dem Rauschen raus. Ich will / werde heute, sofern ich Zeit dazu finde, die 10MOhms probieren. Und hoffe das ich so einen deutlichere Änderung “hinter” dem Plexiglas erreiche.

Das ganze Thema ist so zum k…en aber irgendwie fasziniert es dann doch so arg das man damit nicht aufhören kann ^^

Also es ist doch echt zum kot…en, Ich habe jetzt das ganze mit den 10MOhm erfolgreich auf dem Mega 2560 ans laufen gebracht (Werte waren bei 400 beim berühren, und ca. bei <= 80 beim Rauschen. Dann habe ich das ganze auf meinem “nackigen” Atmega328 gepackt und dort sind die Werte komischerweise “nur noch” bei 230 statt 400 und das Rauschen ist auch wieder höher. Meine Folien (Kupferklebeband) und die 10MOhm Widerstände sind gelötet und Stecken dann mit einer Stifleiste direkt an den Ports vom Mega328. Komisches verhalten. Der Kontakt ist einwandfrei. P.s. der cPin habe ich jetzt mal durchprobiert. Also von 100p bis 100n, alles was halt dazwischen liegt und ich Zuhause habe…

Es stabilisiert sich zwar etwas, aber nicht so das ich es für notwendig halte. Ich habe noch ein normalen Arduino UNO und da werde ich morgen schauen ob ich dort auch “nur” die 230 habe. Wenn ja, dan scheint es als ob es der 2560 besser messen kann, wenn nicht, dann ist wohl mein Steckbrett im Eimer, was ich jetzt aber nicht glaube.

ht81:
Dann habe ich das ganze auf meinem "nackigen" Atmega328 gepackt und dort sind die Werte komischerweise "nur noch" bei 230 statt 400 und das Rauschen ist auch wieder höher.

Welche Erdung hat Dein Arduino denn am GND-Anschluss?

GND muß bei so einem Berührungssensor auf Erdpotential liegen.

Wenn ein Arduino an der USB-Buchse eines Desktop-PC angeschlossen ist, ist er automatisch geerdet, da Masse vom USB dann auf Potential des Schutzleiters der Steckdose liegt. Da besteht über das metallische PC-Gehäuse aufgrund der Netzteil- und USB-Konstruktion eine direkte Verbindung zur Erde.

Ansonsten muß der Arduino ggf. geerdet werden, damit es funktioniert. Also ein dünnes Kabel von GND an die nächste Wasserleitung, (Kupfer-)Heizungsleitung oder mit dem Schutzleiter einer Steckdose verbinden.

Eisebaer:
hi,

ich mehme an, mit dem touch-ic von atmel meinst Du einen QTouch-fähigen. das können die meisten atmel-avrs (auch tinys), aber dazu muß die qtouch-library ins atmel-studio eingebunden werden und das kann man nur damit programmieren. eine portierung auf arduino ist mir nicht bekannt.

gruß stefan

Hallo Stefan,

sorry, dass ich mich so spät melde - Offline war grad etwas heftig.....

ich meine den QT1060, der kann I2C ausgeben wenn man einen Microcontroller ansteuern möchte. Oder aber selbst 6 Ausgänge schalten (lediglich LED und so/ oder eben Optokoppler etc.)

Grüße Thomas