Capacitive Sensor

[Wampo]

Hy,

ich möchte gerne einen Capacitive Touch Sensor programmieren der jedoch nicht berühert werden muss und durch ca. 1 cm dickes Holz reagieren kann.

Habe mit dem beispiel CapacitiveSensor experiementiert aber mit den wiederstandswerten von 10 MOhm kommt nur müll raus. Ich benutze jetzt einen 100KOhm Widerstand, dieser reagiert jedoch nur auf direkten Kontakt. Alle anderen widerstandswerte die ich probiert hab funktionieren einfach nicht!

Muss ich hier die Sensorfläche erhöhen oder sind das rein die widerstände die den Abstand bestimmen????


Oder liegt es an der Programmierung?

mfg daniel

[code]

/***************************************************************
Tast-Dimmer für Arduino by Gunther Breu
Steuert mit einem Taster die Helligkeit einer LED
LED: Anode an Pin 10, Kathode über Rv an GND
(Werte für RV: IR: 180R, ROT: 150R, Gelb, grün: 140R, Weiß, blau: 75R)
Wahlweise einen geeignete LED-Treiber.
Taster: Capazitive Sensorfläche an Pin letzte ziffer

mit 100kOhm beste ergebnisse und stabielste


Funktion:
Kurz drücken: An / Aus
lang drücken: langsam heller; beim nächsten mal lang drücken: langsam dunkler

PWM Werte werden beim Ausschalten im EEprom gespeichert.
************************************************************************/

#include <EEPROM.h>
#include <CapacitiveSensor.h>


CapacitiveSensor cs_4_2 = CapacitiveSensor(2,3); // in klammern erste zahl sender zweite zahl empfänger, zwischen tx und rx 100kOHM und am rx draht zum touchen

const byte LED_pin = 0;
const byte PMW_UG = 1; //gedimmt am dunkelsten
const byte PMW_OG = 255; //gedimmt am hellsten
const byte PWM_Schritt = 4;
const byte TasterPeriode = 50;

const int kurz = 1, lang = 2, aus = 0, wechsel = 3; // Tasterstati
const boolean steigend = true, fallend = false; // Reglerstati
const boolean AN = true, AUS = false; // Lichtstati
boolean Regler = fallend;
boolean Licht = AUS;
int LED_PWM;


void setup() {
cs_4_2.set_CS_AutocaL_Millis(0xFFFFFFFF); // turn off autocalibrate on channel 1 - just as an exampl
pinMode(LED_pin, OUTPUT);
EEPromLoad((byte*) &LED_PWM , 2, 0 );
}

void loop() {
int Taster = Tasterlesen();

switch (Taster) {
case kurz:
Licht = !Licht;
if (Licht) analogWrite(LED_pin, LED_PWM);
else digitalWrite(LED_pin, LOW);
break;
case wechsel:
Regler = !Regler;
if (Licht == AUS) Licht = AN;
analogWrite(LED_pin, LED_PWM);
break;
case lang:
if (Regler == steigend){
LED_PWM += PWM_Schritt;
if (LED_PWM > PMW_OG) LED_PWM = PMW_OG;
analogWrite(LED_pin, LED_PWM);
} else {
LED_PWM -= PWM_Schritt;
if (LED_PWM < PMW_UG) LED_PWM = PMW_UG;
analogWrite(LED_pin, LED_PWM);
}
EEPromSave((byte*) &LED_PWM , 2, 0 );
break;
}// end switch

}// end loop()

/********************************************************************************​***********
** Funktion Tasterlesen **
** Liest den Taster und bewertet die Drückdauer **
** **
** input: nix **
** output: Tasterstatus kurz, lang, aus, wechsel **
** genutzte Globale Variablen: DrueckDauerSchwelle Tasterstati **
********************************************************************************​***********/

int Tasterlesen (void){
static int _taste_alt;
static int tasttimer = 0;
const int DrueckDauerSchwelle = 5;

// Diesen Funktionsblock um nur alle y ms taster zu lesen
static unsigned long nextpull = 0;
const unsigned long Tasterpulltime = TasterPeriode; // alle x ms wird der Taster abgefragt
if(millis() < nextpull) return -1;
nextpull += Tasterpulltime;


boolean _taste = cs_4_2.capacitiveSensor(30) ;

if (_taste && _taste_alt){ // Taster ist gedrückt
tasttimer++;
if(tasttimer == DrueckDauerSchwelle){ // Schwelle zum lang drücken erreicht.
_taste_alt = _taste;
return wechsel;
}
if(tasttimer > DrueckDauerSchwelle){ // Taster ist lange gedrückt.
_taste_alt = _taste;
return lang;
}
}
if (!_taste && _taste_alt){ // Taster wurde losgelassen
if(tasttimer < DrueckDauerSchwelle){ // Taster war kurz gedrückt.
_taste_alt = _taste;
return kurz;
}
tasttimer = 0;
}
_taste_alt = _taste;
return aus;
} // end Funktion Tasterlesen



/********************************************************************************​***********
** Funktion EEPRomSave **
** Schreibt die übergebene Variable ins EEProm **
** input: **
** wert: pointer to byte array which holds the value to save **
** numbytes: number of bytes to be saved **
** eprom_offset: offset in EEPROM for saving bytes **
** output: void (nothing) **
********************************************************************************​***********/
void EEPromSave(byte* wert, int numbytes, int eprom_offset)
{
for (int i=0;i<numbytes;i++)
EEPROM.write(eprom_offset+i, wert[i]);
}


/********************************************************************************​***********
** Funktion EEPRomLoad **
** holt die übergebene Variable aus dem EEProm **
** input: **
** wert: pointer to byte array which holds the value to save **
** numbytes: number of bytes to be saved **
** eprom_offset: offset in EEPROM for saving bytes **
** output: void (nothing) **
********************************************************************************​***********/
void EEPromLoad(byte* wert, int numbytes, int eprom_offset)
{
for (int i=0;i<numbytes;i++)
wert[i] = EEPROM.read(eprom_offset+i);
}


uint8_t readCapacitivePin(int pinToMeasure) {
// Variables used to translate from Arduino to AVR pin naming
volatile uint8_t* port;
volatile uint8_t* ddr;
volatile uint8_t* pin;

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);
// Prevent the timer IRQ from disturbing our measurement
noInterrupts();
// 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;}

// End of timing-critical section
interrupts();

// 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;

return cycles;
}
[:code]

[Stefan]

Hallo Wampo, setzen wir einmal voraus, dass das Programm funktioniert, es sieht ja recht plausibel aus. Ich würde jetzt mein Augenmerk auf den Sensor richten. Hier gibt es 2 Varianten, von denen wohl die genutzt werden soll, dass der überall vorhandene Netzbrumm verwendet wird, um den Eingang zu bedienen. Dabei spielen allerdings die äußeren Umstände stark mit, also wie hoch sind die umgebenden Felder? Im Freien wird es damit schlecht aussehen und in Räumen hängt es stark von den vorhandenen Installationen ab. Und klar hängt das von den Eingangswiderständen ab. Dann sollte der Eingang möglichst hochohmig sein, es könnte helfen, einen Impedanzwandler davor zu schalten. Hast du ein Oszilloskop zur Verfügung?