INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Capacitive Sensor
01.11.2014, 01:14
Beitrag #1
Capacitive Sensor
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]
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
01.11.2014, 08:16
Beitrag #2
RE: Capacitive Sensor
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?

Gruß, Stefan . . . . . . //Wo mein Kölbchen dampft, da bin ich unverkrampft.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Gyroskop/Kompass Sensor AlphaRay 9 411 10.10.2016 14:41
Letzter Beitrag: AlphaRay
  Kippwinkel/Neigungswinkel Sensor? Binatone 14 633 04.09.2016 15:27
Letzter Beitrag: Bitklopfer
  PIR Sensor auslesen / einsetzen go4sea 6 548 28.04.2016 17:11
Letzter Beitrag: hotsystems
  Multi functional Expansion Board Sensor Shield Astropikus 5 786 03.03.2016 22:32
Letzter Beitrag: hotsystems
  Bosch MAP Sensor auslesen Roman 4 913 12.02.2016 23:02
Letzter Beitrag: Roman
  Flow - Sensor Claus_M 0 459 16.01.2016 19:48
Letzter Beitrag: Claus_M
  Optische Maus als Sensor? Binatone 4 869 20.11.2015 18:26
Letzter Beitrag: Binatone
  Waschbecken Automatisierung Sensor ? Haustechno 8 1.457 05.08.2015 19:29
Letzter Beitrag: Haustechno
  Sensor an Arduino über IP abfragen/steuern kubinek 5 2.624 03.08.2015 21:14
Letzter Beitrag: Haustechno
  Empfehlung gesucht für I2C-GPS-Sensor, auch für Google Maps HaWe 19 2.226 27.07.2015 14:29
Letzter Beitrag: DaniDD

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste