Ich schalte das Licht in der Dusche mit einem hinter den Fliesen
angebrachten TouchPad. Die Routinen habe ich nach einem Besuch beim
QTouch-Seminar nochmal nachempfunden und in einen Mega88 geflasht, die
Libraries von ATMEL benutze ich nicht, weil falsche Programmiersprache
;-). Ich empfinde die Touch-Technik als nützlich, gerade im "IP67 oder
besser Bereich".

Ich hab mir letztens die QTouch Libs angesehen (mit AVR GCC) und musste
feststellen, dass die Messung eines Touchsensors etwas unempfindlich
ist. Oder ich hab die falschen Einstellungen getroffen (keine Ahnung).

Jedenfalls ist die Technik ja relativ leicht nachprogrammiert und
funktioniert bei mir jetzt auch besser (empfindlicher). Hab aber noch
keine Driftkompensation drinnen wie es in der Atmel Lib drinnen ist.

mfg
Andreas

Die Driftkompensation ist nichts weiter als ein Tiefpaß, der den
Mittelwert als Differenz für die Meßwerte stetig anpaßt (etwa um einen
Meßwert pro Sekunde) wenn kein Touch ausgelöst ist. Nach Toucherkennung
wird der Mittelwert nicht verändert, bis der Touch wieder weg ist oder
ein Timeout von, sagen wir mal, 15 Sekunden verstrichen ist.

Ja, so hab ich mir das auch gedacht! Sehr viel anders lässt sich das mit
einfachen Mitteln ja auch nicht implementieren denk ich mal.

Ich habe bisher nur gesehen, daß zwar die tollsten Erklärungen für die
Sensor-ICs gemacht werden, aber es letztendlich auf eine
Kapazitätsmessung hinausläuft.
Es kochen also alle nur mit Selters.


Peter

Nee, Peter. Es ist keine Kapazitätsmessung sondern eine
Charge-Transfer-Messung. Gegenüber der reinen Kapazitätsmessung mit
einer an einem Pin angeschlossenen Meßplatte ist diese Version mit
definierter Paketladung über einen Transferkondensator über 2 Pins
empfindlicher und reproduzierbarer.

@Travel Rec.:
Hast du dir für deine Anwendung eine Platine machen lassen?? Wenn ja,
wie sieht da deine "Touch-Fläche" aus?? Vorallem würde mich
interessieren, wie groß die Fläche ist und ob du im Layer darunter eine
Massefläche hast?!

Achja... und das funktioniert bei dir noch hinter den Fliesen?! Ich hab
schon Probleme, wenn ich bisschen Kunststoff oder Papier drüber hab.

Andreas Auer schrieb:
> @Travel Rec.:
> Hast du dir für deine Anwendung eine Platine machen lassen??

Ja, von mir selber ;-)

> Wenn ja,
> wie sieht da deine "Touch-Fläche" aus??

Ist eine mit kurzem Kabel abgesetzte, einseitig kupferkaschierte
Hartpapier-LP in der Größe eines 2-EUR Stücks, vielleicht ein wenig
größer.


> Vor allem würde mich
> interessieren, wie groß die Fläche ist

Wie gesagt...


> und ob du im Layer darunter eine
> Massefläche hast?!

Natürlich NICHT!


> Achja... und das funktioniert bei dir noch hinter den Fliesen?! Ich hab
> schon Probleme, wenn ich bisschen Kunststoff oder Papier drüber hab.

Ja. Geht durch 1cm Keramik und 1.25cm Rigips.

Travel Rec. schrieb:
> Nee, Peter. Es ist keine Kapazitätsmessung sondern eine
> Charge-Transfer-Messung.

Gibt es irgendwo ne verständliche Beschreibung und Schaltplan mit
Dimensionierung?
Braucht man die speziellen ICs dazu oder reicht ein normaler MC?
Ich bin von den Flyern und Werbung auf der Atmel Seite schon ganz
wuschig im Kopf. Nirgends findet man was sinnvolles.


> Gegenüber der reinen Kapazitätsmessung mit
> einer an einem Pin angeschlossenen Meßplatte ist diese Version mit
> definierter Paketladung über einen Transferkondensator über 2 Pins
> empfindlicher und reproduzierbarer.

Läßt sich das irgendwie belegen?
Ich denke mal, daß auch diese Methode eine Art Kalibration durchführen
muß, um auf Empfindlichkeit zu kommen.


Peter

Peter Dannegger schrieb:
> Gibt es irgendwo ne verständliche Beschreibung und Schaltplan mit
> Dimensionierung?
> Braucht man die speziellen ICs dazu oder reicht ein normaler MC?
> Ich bin von den Flyern und Werbung auf der Atmel Seite schon ganz
> wuschig im Kopf. Nirgends findet man was sinnvolles.

Es gab mal einen Thread da hat Travel Rec. selbst seinen Code und
Schaltplan gepostet. Mit dem war es mir möglich das ganze
nachzuvollziehen und in C zu implementieren.

Beitrag "Quantum Chips"

Die Atmel Seite ist in diese Richtung in der Tat etwas unübersichtlich.

Peter Dannegger schrieb:
> Braucht man die speziellen ICs dazu oder reicht ein normaler MC?
> Ich bin von den Flyern und Werbung auf der Atmel Seite schon ganz
> wuschig im Kopf. Nirgends findet man was sinnvolles.

Die Touch-ICs liefern fertige Schaltsignale und lassen sich geringfügig
von außen konfigurieren. Beim µC kann man die Libraries benutzen oder
selber loslegen. Bedingung ist, daß de µC abschaltbare PullUps hat,
sonst funktionieren die Meßbursts nicht. Touch funktioniert also u.a.
auf allen neueren AVRs und XMegas und den AVR32-Controllern.

Hallo,

ich klinke mich an der Stelle mal ein. :-)

Leider habe ich bezüglich der QTouch-Sache ein wenig ein Brett vor dem
Kopf.

Ich verstehe das funktionsprinzip anhand der Zeichnung im Anhang (die
ist aus dem Atmel-Datasheet) folgendermaßen:

1. Zu beginn wird die Sensorplatte entladen indem PB1 als Eingang und
auf "0" geschaltet wird.
2. PB1 wird nun zur Bursterzeugung kurz auf "1" geschaltet, danach wird
der Pin umkonfiguriert als Eingang, Pull-Ups sind generell
ausgeschaltet.
3. Das ganze Spiel unter 2. wiederholt sich bis der Pin wenn er als
Eingang geschaltet ist als logisch "1" gelesen wird. Die Anzahl der
notwendigen Ladezyklen wird dabei gezählt.
4. Steigt die Anzahl der notwendigen Ladezyklen auf einmal stark an,
geht der Chip davon aus das einer Seine Flossen vor den Sensor hält. Die
Auslöseschwelle wird natürlich ständig langsam nachgeführt (Stichwort
Tiefpass)

Was ich nicht ganz kapiere, für was braucht man den Kondensator Cs?
Warum der eine Verbindung zu PC1 hat und nicht nach GND kapiere ich
nicht so ganz.
Es schwirren viele Infos und Codeschnipsel im Netz rum, auch hier im
Forum, aber eine einfache Erklärung des Funktionsprinzips habe ich bis
jetzt noch nicht gefunden. "Charge Transfer" hört sich zwar interessant
an, aber an klaren Erklärungen mangelt es mir zur Zeit irgendwie. ;-)
Vielleicht kann mir jemand Erklären wie das mit dem Kondensator im
ganzen funktioniert. Für irgendwas muss Cs ja gut sein...

Nachtrag: Ich vermute das durch das Umladen der einen Seite des
Kondensators, etwas Ladung auf die "andere" seite des Kondensator
geschaufelt wird. Stimmt das ?

Nachtrag2: Gehe ich recht in der Annahme das man zum das QTouch Prinzip
zu realisieren keinen ADC benötigt, dies also rein mit den normalen
Pins, wie auch mit den kleineren Tinys, oder dem Tiny2313 der keinen ADC
hat, klappt?


Roland

@Travel Rec.

Die Eingänge werden digital eingelesen, d.h. eine Drift der
Eingangsschwelle spielt keine Rolle?

Die Eingänge werden eingelesen, wenn alles tristate ist, muß das dann
nicht sauempfindlich gegen HF-Störungen sein?
Und der Eingang, der später eingelesen wird, müßte störempfindlicher
sein.
Sollte man nicht besser erst die SBIS-Befehle machen und danach das
ADIW?

Könnte man die Schleife nicht schon abbrechen, wenn beide Eingänge low
sind?

Können die 33nF Keramik sein?
Wenn ja, die haben ja große Toleranzen und Drift, wirkt sich das auf die
Werte der beiden Tasten aus?
D.h. können die stark unterschiedlich sein?

Die Ausgänge TOUCH1A/2A werden nirgends gesetzt, müssen sie low sein,
oder ist das egal?


Vom Prinzip her erinnert mich das an nen DAC mit geschalteten
Kondensatoren. Der Unterschied ist nur, daß beide Kondensatoren nicht
gleich groß sind, sondern stark unterschiedlich.
Das Prinzip hat man früher auch als Rampengenerator verwendet (ein
kleiner Kondensator lädt kleine Ladungen auf einen großen).

Letztendlich ist also auch eine Kapazitätsmessung. Die Frage ist nur,
welcher Unterschied sich bezüglich Bauelementedrift und Störspannungen
gegenüber anderen Meßmethoden ergibt.


Peter

@Roland:
Ich weiß nicht, ob die Beschreibung von Peter jetzt ausreicht um deine
Fragen zu beantworten, da er doch sehr stark auf die Implementierung von
Travel Rec. eingeht.

Ich hab das ganze so implementiert:

1. definierten Zustand für die Kondensatoren herstellen. D.h. PB1 und
PC1 als Ausgänge schalten und auf low ziehen um alles Cs zu entladen
(genügend lange warten).

2. PB1 auf high und PC1 auf low schalten (aber immernoch als Eingänge)

3. PB1 als Ausgang schalten und kurze Zeit (z.B. 5us) warten bis der
unbekannte Touchkondensator geladen ist.

4. PB1 wieder als Eingang schalten und PC1 als Ausgang schalten. Damit
liegt jetzt der "Sampling Kondensator Cs" quasi parallel zum
Touchkondensator und es müssen sich die Ladungen so umverteilen, dass
beide die gleiche Spannung haben (Parallelschaltung). D.h. es wird Cs
leicht geladen, da dieser ja viel größer ist.

5. Überprüfe ob PB1 schon als high eingelesen wird. Wenn nicht, dann
beginne wieder bei Punkt 3 und erhöhe einen Zähler. Wenn PB1 bereits
high ist, dann ist der Zählerstand ein Maß für die Anzahl der
Ladezyklen.

Der Endstand des Zählers wird sich verändern, wenn du mit dem Finger auf
den Touchsensor greifst.

Als C code sieht das so aus:

static int sense(void)
{
    unsigned char i=0; 
    DDRC  = 0x00;
    PORTC = 0x00;
    
    DDRC |= _BV(PC1);
    DDRC |= _BV(PC0);
    _delay_us(5);
    DDRC &= ~_BV(PC1);
    DDRC &= ~_BV(PC0);

    PORTC |= _BV(PC0);
    for(i=0; i<255 && !(PINC & _BV(PC0)); i++)
    {
        DDRC |=  _BV(PC0);
        _delay_us(5);
        DDRC &= ~_BV(PC0);
        DDRC |=  _BV(PC1);
        _delay_us(20);
        DDRC &= ~_BV(PC1);
    } 
    DDRC |= _BV(PC1);
    DDRC |= _BV(PC0);
    PORTC = 0x00;
    
    return i;
}

Andreas Auer schrieb:
> @Roland:
> Ich weiß nicht, ob die Beschreibung von Peter jetzt ausreicht um deine
> Fragen zu beantworten, da er doch sehr stark auf die Implementierung von
> Travel Rec. eingeht.
>
> Ich hab das ganze so implementiert:
>
> 1. definierten Zustand für die Kondensatoren herstellen. D.h. PB1 und
> PC1 als Ausgänge schalten und auf low ziehen um alles Cs zu entladen
> (genügend lange warten).

Habe ich, soweit kein Problem

>
> 2. PB1 auf high und PC1 auf low schalten (aber immernoch als Eingänge)

Aha, dann beide Pins als Eingänge Konfigurieren. Aber wie soll ich dann
High und Low schalten? Ist das eventuell ein Schreibfehler deinerseits
und sollte Ausgang (also für die Konfig der Pins) heißen?

>
> 3. PB1 als Ausgang schalten und kurze Zeit (z.B. 5us) warten bis der
> unbekannte Touchkondensator geladen ist.
>

Hier komme ich gar nicht mehr mit, was macht dann PC1? Ist das immer
noch ein Ausgang und auf Low?

> 4. PB1 wieder als Eingang schalten und PC1 als Ausgang schalten. Damit
> liegt jetzt der "Sampling Kondensator Cs" quasi parallel zum
> Touchkondensator und es müssen sich die Ladungen so umverteilen, dass
> beide die gleiche Spannung haben (Parallelschaltung). D.h. es wird Cs
> leicht geladen, da dieser ja viel größer ist.
>

Sorry jetzt komme ich nicht mehr mit, PC1 als Ausgang kapiere ich aber
was für einen Pegel, High oder Low?

> 5. Überprüfe ob PB1 schon als high eingelesen wird. Wenn nicht, dann
> beginne wieder bei Punkt 3 und erhöhe einen Zähler. Wenn PB1 bereits
> high ist, dann ist der Zählerstand ein Maß für die Anzahl der
> Ladezyklen.
>
> Der Endstand des Zählers wird sich verändern, wenn du mit dem Finger auf
> den Touchsensor greifst.
>
> Als C code sieht das so aus:
>

> static int sense(void)
> {
>     unsigned char i=0;
>     DDRC  = 0x00;
>     PORTC = 0x00;
> 
>     DDRC |= _BV(PC1);
>     DDRC |= _BV(PC0);
>     _delay_us(5);
>     DDRC &= ~_BV(PC1);
>     DDRC &= ~_BV(PC0);
> 
>     PORTC |= _BV(PC0);
>     for(i=0; i<255 && !(PINC & _BV(PC0)); i++)
>     {
>         DDRC |=  _BV(PC0);
>         _delay_us(5);
>         DDRC &= ~_BV(PC0);
>         DDRC |=  _BV(PC1);
>         _delay_us(20);
>         DDRC &= ~_BV(PC1);
>     }
>     DDRC |= _BV(PC1);
>     DDRC |= _BV(PC0);
>     PORTC = 0x00;
> 
>     return i;
> }
> 

Könntest du vielleicht mal das Funktionsprinzip genauer erklären oder
den genauen Status der Pins darstellen? Der C-Code ist zwar interessant
aber ich würde gerne das Funktionsprinzip generell verstehen, also wo
die Ladungen hingehen usw.
Leider fehlen bei deiner Erklärung auch einige Teile die zum Verständnis
notwendig sind, sprich ich verstehe das nicht komplett.


Roland

So, hier mal mein Beispiel, vorausgesetzt, ich habe das Prinzip richtig
verstanden:

#include <atomic.h>
#include "mydefs.h"

#define MAX_CYCLE       1000

#define SENSKEY_A0      SBIT( PORTB, 0 )        // connect to senspad
#define SENSKEY_A0_DDR  SBIT( DDRB,  0 )

#define SENSKEY_B0      SBIT( PORTB, 1 )        // connect to cap to A0
#define SENSKEY_B0_DDR  SBIT( DDRB,  1 )
#define SENSKEY_B0_PIN  SBIT( PINB,  1 )

/*
A0      B0      B0_PIN
0       0               full discharge
loop:
Z       Z               gap
Z       1               partial charge over pin A0 and senspad
Z       Z               gab
0       Z               partial charge over pin B0 only
0       Z       1       end
*/

uint16_t read_senskey( void )
{
  uint16_t i = MAX_CYCLE + 1;

  SENSKEY_A0 = 0;
  SENSKEY_A0_DDR = 1;
  SENSKEY_B0 = 0;
  SENSKEY_B0_DDR = 1;           // discharge cap

  ATOMIC_BLOCK(ATOMIC_FORCEON){
    do{
      SENSKEY_A0_DDR = 0;       // A0 = tristate
      SENSKEY_B0 = 1;           // B0 = weak high
      SENSKEY_B0_DDR = 1;       // B0 = strong high
      SENSKEY_B0_DDR = 0;       // B0 = weak high
      SENSKEY_B0 = 0;           // B0 = tristate
      SENSKEY_A0_DDR = 1;       // A0 = strong low
      if( --i == 0 )
        break;                          // timeout
    }while( SENSKEY_B0_PIN == 0 );      // until charged
  }
  SENSKEY_B0_DDR = 1;           // discharge cap
  return MAX_CYCLE - i;         // big value = key touched or timeout
}

Ich habe es etwas geändert.
Es wird der Pin eingelesen, der nicht mit dem Pad verbunden ist und
während das Pad auf low gezogen wird. Damit können Störungen auf dem Pad
nicht die Lesung beeinflussen.


Das Prinzip ist das eines Treppengenerators, wie er z.B. früher zum
Erzeugen des Fernsehtestbildes verwendet wurde. Interessant, wie man für
altbekannte Schaltungen neue Einsatzfelder findet.


Peter

@Peter Danneger,

heißt das du wertest die durch den Kondensator transportierte Ladung
aus, bzw lässt den Ladezyklus so lange laufen bis der Pin als Logisch 1
gelesen wird.
Klingt interessant, somit hat man keine Probleme bei Störverseuchter
Umgebung auf die das Pad wie eine Antenne wirken würde....

Roland

@Joe,

Das Design Guide habe ich gelesen, würde ich das genaue Funktionsprinzip
verstehen, würde ich hier ja nicht fragen. Mir will einfach nicht in den
Kopf wie der verdammte Kondensator Cs funktioniert, also wie das mit der
Ladungsmengenmessung funktioniert. Auf welcher seite des Kondensators
messe ich die Ladung und wie kommt die dahin? Sinn würde es ja nur
machen wenn man an PC1 (auf mein obriges Bild bezogen) Messen würde, nur
wie muss sich dieser Pin während des Ladezyklus verhalten? Dauernd als
Eingang Schalten und warten bis er logisch 1 wird? Meine Frage ist wie
und wo kommt die Ladung in den Kondensator und an welchem Pin messe ich
das.
Dein zitierter Text von Atmel ist etwas allgemein gehalten, es wird
nicht darauf eingegangen wie die Ladung in den Kondensator kommt und
welche Zustände die beteiligten Pins einnehmen.
Es geht mir um das GENAUE Funktionsprinzip, nicht um das allgemeine, da
ich das Verstehen will. ;-)

Nachtrag: Mit dem Routing hast du recht, habe mal bei der Verwendung des
QT100 seltsame Fehler in der Schaltung gehabt. Schlussendlich lags am
Routing, waren zwei "heisse" Leiterbahnen zu dicht beisammen... So kanns
gehen.

Roland

Peter Dannegger schrieb:
> @Travel Rec.
>
> Die Eingänge werden digital eingelesen, d.h. eine Drift der
> Eingangsschwelle spielt keine Rolle?

Durch den implementierten Tiefpaß spielt das keine Rolle.

> Die Eingänge werden eingelesen, wenn alles tristate ist, muß das dann
> nicht sauempfindlich gegen HF-Störungen sein?

Nö. Ich werte die Spannung im Cs aus, da gibt´s keine HF

> Und der Eingang, der später eingelesen wird, müßte störempfindlicher
> sein.
> Sollte man nicht besser erst die SBIS-Befehle machen und danach das
> ADIW?

Konnte keinen Unterscheid feststellen, müßte man mal mit noch mehr
Tasten testen.

>
> Könnte man die Schleife nicht schon abbrechen, wenn beide Eingänge low
> sind?

Ja, aber das verändert die Laufzeit des Programms bei jedem Zyklus. So
kann man die Meßzyklen quasi auch als Timer für die nachgeschalteten
Tiefpässe nehmen -> starre Kopplung.

> Können die 33nF Keramik sein?
> Wenn ja, die haben ja große Toleranzen und Drift, wirkt sich das auf die
> Werte der beiden Tasten aus?
> D.h. können die stark unterschiedlich sein?

Kein Problem. Tiefpaß und dynamische Auswertung der Abweichung vom
Mittelwert rechnen Toleranzen heraus. Zwischen 22n und 47n gab es keinen
nennenswerten Unterschied.

> Die Ausgänge TOUCH1A/2A werden nirgends gesetzt, müssen sie low sein,
> oder ist das egal?

Die sind immer low. Sorry.


> Vom Prinzip her erinnert mich das an nen DAC mit geschalteten
> Kondensatoren. Der Unterschied ist nur, daß beide Kondensatoren nicht
> gleich groß sind, sondern stark unterschiedlich.
> Das Prinzip hat man früher auch als Rampengenerator verwendet (ein
> kleiner Kondensator lädt kleine Ladungen auf einen großen).

Ja, kann man so sagen.

> Letztendlich ist also auch eine Kapazitätsmessung. Die Frage ist nur,
> welcher Unterschied sich bezüglich Bauelementedrift und Störspannungen
> gegenüber anderen Meßmethoden ergibt.

Meinen Langzeittest hat die Schaltung schon überstanden. Läuft seit
August in unserem Badezimmer ;-)


>Ich habe es etwas geändert.
>Es wird der Pin eingelesen, der nicht mit dem Pad verbunden ist und
>während das Pad auf low gezogen wird. Damit können Störungen auf dem Pad
>nicht die Lesung beeinflussen.

Mache ich doch auch :-)

@Joe,

ahhhh, danke für die Ausfühliche Erklärung, jetzt hats bei mir "klick"
gemacht. Wenn man das mal Verstanden hat ist es eigentlich sehr einfach
das Prinzip. Maximaler Effekt bei wenig externen Bauteilen... Da haben
bei Qantum sicherlich etlichen Entwicklern Wochenlang die Köpfe geraucht
als die das Prinzip erstellt haben... ;-)

Zur Fangfrage mit dem Wasser:
Ich könnte mir vorstellen das der Sensor dann "betätigt" meldet, da das
Wasser ja auch die Kapazität der Sensorplatte erhöht. Liege ich richtig?

@Tim,

auch dir Danke für die Erklärung, die hat mir geholfen das ganze mal zu
Testzwekcne in einen Tiny13 zu integrieren (zwei-Kanalig). Ist zwar noch
ne Baustelle aber "gut Ding will weile haben" frei Nach Brösels Werner.
:-))

Roland

Nachdem nun die Wirkungsweise des Qtouch klar ist, stellt sich immer
noch die Frage, welche und warum sie Vorteile gegenüber anderen Methoden
der Kapazitätsmessung haben soll?

Sie hat zumindest einige Nachteile:
- es werden 2 IO-Pins benötigt
- es erfolgt eine größere Störaussendung auf den Sensor
- die Messung dauert länger und muß unter Interruptsperre erfolgen.

Wenn man sich die verschiedenen Applikationen bei Atmel ansieht, fällt
auch auf, welchen entscheidenden Einfluß der mechanische und elektrische
Aufbau auf die Eigenschaften hat. Warscheinlich ist dieser viel größer,
als der Einfluß der Meßmethode.
Ich hätte z.B. nicht vermutet, daß eine LED nahe dem Sensor die Messung
stören kann.


Peter

Noch eine Frage. Der Kondensator Cx, wo genau befindet der sich? Ist das
der menschliche Körper? Oder ist der Körper die eine Platte des
Kondensators und die Kontaktfläche die andere Platte?
Wenn der Charge Transfer stattfindet, wird ja die Ladung "ausgeglichen",
sodass beide Kondensatoren die gleiche Ladung haben. Wenn dann die
Kondensatoren wieder auf hochohmig geschaltet werden, wer lädt dann Cx
wieder auf? Der menschliche Körper?

Der Vorteil liegt denke ich mal darin, dass man nicht zwingend das
Gebilde als Schalter nutzen muss, sondern auch zum Beispiel als Touchpad
nutzen kann (Indem man die Ladung im Cs misst und nicht auf einen
Komparator gibt).
Oder man kann so Ipod-Like Slider damit machen.

So, ich hab mal beide Methoden ausprobiert, die Ladungspumpe (Qtouch)
und die Messung der Entladezeit über einen Widerstand.
Im Prinzip gehen beide, aber die Qtouch-Methode ist deutlich
störunempfindlicher, d.h. die Auslesungen sind sehr stabil.
Bedingt wird das durch die Tiefpaßwirkung des Integrationskondensators
und durch die Abtastung bei kurzgeschlossenem Sensorpad.

Ich hab die Schaltung allerdings auch unter verschärften Bedingungen
getestet, am Notebook, welches keinen Schukostecker hat, d.h. die ganze
Schaltung liegt auf 115V 50Hz gegen Erde (durch die Filter-Kondies vorm
Schaltnetzteil).

Das Qtouch ist also doch nicht nur Selters.

Ich hab 2 * 1,8k und nen 10nF genommen. Die Sensorfläche sind 4*4 Pads
einer Rasterplatine, Berührung auf der Bestückungsseite.
Es ergeben sich 382 Counts ungedrückt und 352 Counts gedrückt.


Peter

Mit einem größeren Integrations-C bekommst Du noch etwas weiter
auseinanderliegende Auslesungen für Touch und kein Touch, 22...33nF sind
optimal für 10Bit Auflösung. Hierbei können die Sensorflächen auch
größer sein.

Ist einfacher anzusprechen, wenn die Pinne auf demselben Bit liegen,
geht natürlich auch mit einem einzigen Port.

Um sicher zu gehen, sollte man die Design-Guides von ATMEL/Quantum
befolgen.

Björn schrieb:
> @Peter Dannegger:
> Wie sieht denn dein SBIT Makro aus?

Z.B.:

Beitrag "AVR-GCC Power-Down Tutorial"


Peter

Ich glaube nicht, daß das mit nem Timerinterrupt funktioniert.
Das sind ja nur sehr kleine Ladungen, wenn man da zu langsam schaltet,
ist die Selbstentladung zu hoch.

Es reichen die Delays durch die Ausführungszeit der Meßloop vollkommen
aus, um die wenigen pF umzuladen.
Nur für die Entladung des 33nF bis zur nächsten Messung sollte man etwas
Zeit lassen.

Hier noch ein Beispiel für 3 Tasten:

#include <avr\io.h>
#include <util\atomic.h>


#define SK_A0   (1<<5)
#define SK_B0   (1<<4)
#define SK_A1   (1<<2)
#define SK_B1   (1<<3)
#define SK_A2   (1<<0)
#define SK_B2   (1<<1)

#define SK_A012 (SK_A0 | SK_A1 | SK_A2)
#define SK_B012 (SK_B0 | SK_B1 | SK_B2)


#define MAX_CYCLE       2000


uint16_t keys[3];


void read_senskey( void )
{
  uint16_t i = MAX_CYCLE;
  uint8_t a, b, x, y;

  ATOMIC_BLOCK(ATOMIC_FORCEON){
    a = DDRA  & ~(SK_A012 | SK_B012);
    b = PORTA & ~(SK_A012 | SK_B012);
    y = SK_B012;                        // input mask
    do{
      DDRA = a;                         // tristate
      PORTA = b | SK_B012;
      DDRA = a | SK_B012;               // Bx = strong high
      DDRA = a;                         // tristate
      PORTA = b;
      DDRA = a | SK_A012;               // Ax = strong low
      if( --i == 0 )                    // timeout
        break;
      x = y & PINA;                     // not immediately after set DDRA !!!
      if( x ){
        if( x & SK_B0 )
          keys[0] = i;
        if( x & SK_B1 )
          keys[1] = i;
        if( x & SK_B2 )
          keys[2] = i;
      }
      y ^= x;                           // clear processed input
    }while( y );                        // all inputs done
    DDRA = a | SK_A012 | SK_B012;       // discharge
  }
}

Peter

Hi,

hab mir jetzt mal eine Platine gemacht mit 3 Touchelementen (ca.
15x15mm² Touchfläche pro Element, 33n Messkondensator, 1k
Serienwiderstand zur Touchfläche) drauf. Funktioniert grundsätzlich
auch. Sehr gut funktioniert es natürlich wenn man direkt die durch
Lötstopplack geschützten Flächen berührt. Jedoch sinkt die
Empfindlichkeit drastisch, wenn man die Touchfläche hinter anderen
Materialien anbringt, sodass es kaum mehr möglich ist die Berührung zu
detektieren.

Deshalb wollt ich euch mal fragen wie eure Erfahrungen sind. Ich hab
gestern mal die Wirkung meines Fingers durch ein paar Materialien
untersucht (ein paar Seiten Papier, Cover einer CD) und war etwas
enttäuscht, da ich meist nur noch eine ganz geringe Änderung (Delta im
Bereich von 1 oder 2) messen konnte.

Ich wollte die Platine eigentlich hinter einer dünnen Plexiglasscheibe
montieren. Hat jemand sowas schonmal gemacht?? Wäre für jeden Tipp zur
Verbesserung dankbar!

mfg
Andreas

Andreas Auer schrieb:
> Deshalb wollt ich euch mal fragen wie eure Erfahrungen sind. Ich hab
> gestern mal die Wirkung meines Fingers durch ein paar Materialien
> untersucht (ein paar Seiten Papier, Cover einer CD) und war etwas
> enttäuscht, da ich meist nur noch eine ganz geringe Änderung (Delta im
> Bereich von 1 oder 2) messen konnte.
>
> Ich wollte die Platine eigentlich hinter einer dünnen Plexiglasscheibe
> montieren. Hat jemand sowas schonmal gemacht?? Wäre für jeden Tipp zur
> Verbesserung dankbar!

Beitrag "Re: qtouch - sekt oder selters"

Versteh ich nicht, warum das bei mir durch ein Stück Kunststoff schon
nicht mehr klappt. Wie groß ist dein Kondensator??

33nF.

Also gleiche Kapazität wie ich... interessant...

Und du hast auch einen Serienwiderstand zum Touchpad drin!? Bzw. deine
Schaltung sieht wie folgt aus??

                             ------           ----
PORTx   -----------+--------|______|---------|    | Touchpad
                   |           R             |____|
                 ----- C
                 -----
                   |
PORTy   -----------+

Danke,
Andreas

Nicht ganz. Ich habe noch ein zusätzliches R zwischen Portx und C, Wert
ist 2.2k. Der Widerstand zum Touchpanel ist bei mir 10k.

Hi all,

bin gerade auf diesen Thread gestoßen und gleich eine Frage:

Travel Rec. schrieb:
> Nicht ganz. Ich habe noch ein zusätzliches R zwischen Portx und C, Wert
> ist 2.2k. Der Widerstand zum Touchpanel ist bei mir 10k.

Wozu dient dieser Widerstand, Strombegrenzung beim Entladen?

Gruß Stefan

Der Widerstand macht den nutzbaren Bereich  bei der Zeit-/Pegelmessung
größer. Zu viel R verringert aber die Empfindlichkeit.

Die Widerstände dienen hauptsächlich zur Verringerung von
Störaussendung.
Es müßte auch ganz ohne Widerstände gehen, d.h. 0 Ohm.


Peter

Natürlich geht es ohne die Widerstände. Aber durch den niedrigen
Portinnenwiderstand ist der Transfer-C dann sehr schnell aufgeladen und
es traten mehr Rauschanteile im Meßsignal aus. Das R zwischen Port und C
brachte sehr viel mehr Ruhe und eine größere Meßauflösung. Das R zur
Taste ist zum Dämpfen der Störaussendung und Verhindern von statischen
Entladungen in die Portpins gedacht. Wie gesagt.

Hallo,

ich hab das ganze mal aufgebaut und mit dem code von  Andreas Auer
versucht. Das hat nicht funktioniert, nach einigen messungen und kleinen
anpassungen wurd es schon besser.

Mein problem ist ich bekomme nur einen unterschied von 1 bei berührung.

Mein erster aufbau war mit bedrahtetetn bauelementen, um das
auszuschliesen habe ich jetz das ganze in smd aufgebaut, was leider
keine verbesserung brachte.

Wenn ich den code ohne abruchbedingung (code zeile 111 sieht dann so aus
}while(i<510); ), laufen lasse und mir das ganze am osziloskop ansehe
ändert sich die Kurve bei berührung nur sehr gering.


noch kurtz zum aufbau:
- µC: Atmega8
- Touch fläche: ca. 15x15 mm mit tesa abgeklebt.
- Die messungen in den bildern habe ich zwischen GND und dem im
Schematic eingezeichnetetn messpunkt gemacht.
- Auf dem Osziloskop ist die untere kurve PB1 und kurzz nach der
steigenden flanke wird TA ausgewertet.

Nun meine frage hat jemand eine idee an was das liegen könnte?

Danke im voraus.

mfg
kr2

Hier mal meine Testschaltung.

Software:

Beitrag "Re: qtouch - sekt oder selters"

Dimensionierung, Ergebnisse:

Beitrag "Re: qtouch - sekt oder selters"

Berührt wird auf der Oberseite (rotes Klebeband), d.h. durch die Platine
hindurch.


Peter

Ich finde die Peaks ziemlich breit, mehr als 200ns sollten sie nicht
sein, sonst ist der Speicherkondensator zu schnell voll. Deshalb ergibt
sich eine relative Unempfindlichkeit. Du brauchst mindestens 256 Pulse
(8-Bit) Auflösung, bis der Kondensator so weit geladen ist, daß der Pin
kippt. Die Pausen zwischen den Peaks ist auch recht lang, so daß sich
eine unnötig lange Meßzeit ergibt.

Ob das Timing kritisch ist, kann man überprüfen, indem man den CPU-Takt
halbiert (CLKPR entsprechend setzen).
Die Zählwerte dürfen sich nur wenig ändern.


Peter

Moin,

Du hast schon Gerberdaten? Wo ist dann das Problem?
Das nach einem Gerber-Plot im Layoutprogramm der Wahl nachzubauen,
sollte doch nicht wirklich schwierig sein.
ggf. lassen sich die Daten sogar auf irgendeinem Weg als Vektorsymbol
ins Layoutprogramm importieren...

Zusätzlich würde ich noch einen Blick in das
Touch_Sensors_Design_Guide von Atmel werfen:
http://www.atmel.com/dyn/resources/prod_documents/...
die gehen darin auch auf Probleme wie den ESD-Schutz ein.

Nachtrag: Für EAGLE gibts ein Tool, um Grafikdaten in diversen Formaten
(auch Gerber) zu importieren: EAGLE PCB Power Tools V5.06 ->
http://www.cadsoft.de/cgi-bin/download.pl?page=/ho...

Gruß,
Thorsten

Hier der Versuch, die qtouch-Variante in Bascom umzusetzen.

$regfile = "m8def.dat"
$crystal = 8e6
$baud = 9600

$hwstack = 32                 ' default use 32 for the hardware stack
$swstack = 32                 ' default use 10 for the SW stack
$framesize =                  ' default use 40 for the frame space

Dim Cycles As Byte

'PC5--- 2K2 ---+---- 100K ---- Touchpad
'              |
'             ---
'             --- 22n
'              |
'PC4-----------+

Do
Cycles = 0

'Alles Entladen
'beide out - beide low
Ddrc.5 = 1 : Portc.5 = 0
Ddrc.4 = 1 : Portc.4 = 0

'auf vollstaendige Entladung warten
Waitus 5

   Do

   'beide als tristate inp schalten, damit keine Ladung abfliessen kann
   Ddrc.5 = 0 : Portc.5 = 0
   Ddrc.4 = 0 : Portc.4 = 0
   Waitus 5

   'PC4 Out und high schalten, um C aufzuladen
   Ddrc.4 = 1 : Portc.4 = 1
   Waitus 2

   'und wieder aus
   Ddrc.4 = 0 : Portc.4 = 0

   'Die Ladung aus C jetzt nach PD5 auf GND abfuehren
   Ddrc.5 = 1 : Portc.5 = 0

   'messen, ob Ladung schon fuer eine 1 an PD4 reicht, sonst von vorn
   If Pinc.4 = 1 Then Goto Printout
   Incr Cycles

   Loop Until Cycles >= 254        'wiederholen und im Zweifel beenden

Printout:
Print Cycles
Waitms 100

Loop

Es ergeben sich Werte zwischen 15 und 25 ungedrückt und 40 - 80 gedrückt
(Direkter Kontakt).

Als Sensor verwende ich eine Kotflügelscheibe mit 30mm Durchmesser.

Allerdings ergibt sich bei Verwendung einer isolierenden Folie kaum noch
ein messbarer Ausschlag.

lg,
arne

ich hab das ganze grade mal schnell aufgebaut.

ein kurzes video findet man auf Youtube:
http://www.youtube.com/watch?v=z3nLNGeyadU

Aufbau:
- Schaltung auf der Rückseite von einer Lochrasterplatine
- Vorderseite Tastenlayout mit Papier beklebt
                             ------           ----
PORTx   -----------+--------|______|---------|    | Touchpad 4x4
Lötraster
                   |        R = 1Kohm        |____|
                 -----
                 -----  C = 33nF
                   |
PORTy   -----------+

Code von peter Dannegger:

include <avr\io.h>
#include <util\atomic.h>

#define SK_A0   (1<<5)
#define SK_B0   (1<<4)
#define SK_A1   (1<<2)
#define SK_B1   (1<<3)
#define SK_A2   (1<<0)
#define SK_B2   (1<<1)
#define SK_A012 (SK_A0 | SK_A1 | SK_A2)
#define SK_B012 (SK_B0 | SK_B1 | SK_B2)
#define MAX_CYCLE       2000

uint16_t keys[3];

void read_senskey( void )
{
  uint16_t i = MAX_CYCLE;
  uint8_t a, b, x, y;

  ATOMIC_BLOCK(ATOMIC_FORCEON){
    a = DDRA  & ~(SK_A012 | SK_B012);
    b = PORTA & ~(SK_A012 | SK_B012);
    y = SK_B012;                        // input mask
    do{
      DDRA = a;                         // tristate
      PORTA = b | SK_B012;
      DDRA = a | SK_B012;               // Bx = strong high
      DDRA = a;                         // tristate
      PORTA = b;
      DDRA = a | SK_A012;               // Ax = strong low
      if( --i == 0 )                    // timeout
        break;
      x = y & PINA;                     // not immediately after set DDRA !!!
      if( x ){
        if( x & SK_B0 )
          keys[0] = i;
        if( x & SK_B1 )
          keys[1] = i;
        if( x & SK_B2 )
          keys[2] = i;
      }
      y ^= x;                           // clear processed input
    }while( y );                        // all inputs done
    DDRA = a | SK_A012 | SK_B012;       // discharge
  }
}

Funktioniert super!!

Es funktioniert auch, wenn ich zwischen den Tasten und meinem Finger
noch eine 3mm Plexiglasscheibe lege.
Die Scheibe sollte dafür mit auf die Lochrasterplatine geklebt sein -->
also kein Luftspalt, wegen Ladungsausbreitung

Eine genaue Beschreibeung folgt dann auch noch bald.

martin

noch'n Bild :-)

Das hier ist der Code für die Auswertung der 3 tasten.

hat jemand eine Idee wie man am besten und einfachsten solch ein
Touch-Scrollrad sinnvoll auswerten kann?
Die einzelnen Sensoren funktionieren.
Ist ein Sensorfeld betätigt, also aktiv, so wird bei der Abfrage eine 1
zurückgegeben, ansonsten eine 0.

Das Scrollrad besteht aus 9 einzelnen Touchsensoren.

Ich habe mir zwar schon einige Gedanken gemacht, aber so richtig bin ich
auf noch keine Idee gekommen, wie es am besten gehen könnte.

Danke martin

is mir dann doch etwas zu teuer ;-)

aber ne idee zum auswerten von solch einem Touch Scrollrad hat wohl
keiner?
--> Das Scrollrad besteht aus 9 einzelnen Touchsensoren.Ist ein
Sensorfeld
    betätigt, also aktiv, so wird bei der Abfrage eine 1 zurückgegeben,
    ansonsten eine 0.

Ich hab grade noch eine Autokallibrierung für Touchsensoren hinzugefügt.
Die Basis bildet eine gleitende Mittelwertberechnung der Sensorwerte,
wenn der Sensor nicht aktiv ist.

--> Sensor aktiv = Messung > kallibrier_Mittelwert + 20;

Code muss ncoh bisschen überarbeitet werden.

Bis dann

über Ideen zu dem Scrollrad würd ich mcih freuen.

wegen dem nicht grad aussagekräftigen Namen habe ich einen neuen Thread
aufgemacht...
Beitrag "kapazitiver Touch Sensor - Slider - Wheel"

Hallo zusammen

Hab gerade die Sache auf einem MSP430 zum laufen gekriegt und endlich
mal das "eZ430-F2013 Development Tool" einsetzen können, welches schon
seit Jahren im Schrank verstaubt...

Dankeschön an alle die ihre Erfahrungen hier geteilt haben!

Habe übrigens auch die Schaltung mit dem 1k Widerstand und 33n
Kondensator verwendet.

Ich habe die application notes und design guides von Quantum gelesen und
habe nicht herausgefunden, ob man ohne weiteres auch multiplexer
verwenden kann. Hat hier jemand erfahrungen gemacht?

Es geht mir vor allem darum auf einem grösseren Board Leiterbahnen
einzusparen. Das PCB ist sehr lange, aber schmal und es sollten doch
etwa 15 Tasten realisiert werden :-). Was passiert wohl mit dem Signal
wenn ich 2 Mux hintereinander schalte, aber immer mit denselben Pins
auslese?

Ich habe noch ein Symbolbild angehängt, MCU wäre ganz rechts auf dem
PCB, der letzte Sensor ganz links. Die mux steuerleitungen könnten
eventuell auch mit einem Schieberegister betrieben werden.

Grüsse

Hat schon jemand versucht das Prinzip auf einen STM32 zu portieren?

Übrigens, das Schöne an der Methode ist, die Umladungsschleife kann
jederzeit für (relativ kurze Zeit) unterbrochen werden (durch
Interrupts), ohne dass sich etwas ändert (da die Ladung ja erhalten
bleibt, abgesehen von Leckströmen - deshalb ist die Zeit trotzdem kurz
zu halten).
Ich habe mit dem usb-Stack von obdev auf einem attiny2313 eine simple
usb-"Tastatur" (mit nur einer Taste) mit dem qtouch-Prinzip gebaut, es
funktioniert einwandfrei, obwohl die Messroutine jederzeit vom
einkommenden usb-Poll unterbrochen werden kann.

Gruß,
droelf

beschreibst du deinen aufbau ncoh etwas genauer mit bilder, zeichungen
software .... ?

Martin J. schrieb:
> beschreibst du deinen aufbau ncoh etwas genauer mit bilder, zeichungen
> software .... ?

Anbei die Software sowie ein Bild des Aufbaus. Die Software besteht
hauptsächlich aus dem 1-Key-Keyboard mit dem VUSB-Stack von hier:
http://blog.flipwork.nl/?x=entry:entry081009-142605
Informationen zur Beschaltung finden sich in der main.c im zip.
Ich verwende einen ATTiny2313 mit 16MHz, mit 3,3V, die ich aus USB und
einem Festspannungsregler (ist auf der Rückseite der Platine, deshalb
nicht sichtbar) gewinne.
Ebenso auf dem Bild ist die serielle Debugschnittstelle zu sehen. Erste
Versuche den AVR direkt mit 5V zu betreiben (und Z-Dioden an den
USB-Pins) lieferten recht verrauschte Messwerte, mit dem Spannungsregler
geht das wesentlich besser.
Die Sensorplatte ist einfach ein ca. 1,5cmx3cm großes Metallplättchen,
welches auf einem Stück Plastik in ca. 1,5cm Höhe über der Platine
angebracht ist.
Die Firmware ist sehr schnell zusammengehackt und nicht sonderlich
schön, zumal ist der Tiny mit dem USB-Stack schon ziemlich voll, aktuell
haben nur noch 2 Bytes Platz im Flash.
Im Unterschied zu anderen Beispielen verwende ich den eingebauten
Komparator, um die Aufladeschwelle zu erkennen (habe aber keine Versuche
gemacht, ob das was bringt ggü. normalem Portpin). Die
Signalverarbeitung der Rohdaten sieht folgendermaßen aus:
- Vergleich, ob der gemessene Rohwert unter Vergleichswert minus
Threshold liegt (der Threshold ist über das "#define th 5" einstellbar).
- die Ausgabe dieses Vergleichs geht in ein 8-Bit Schieberegister, d.h.
es werden immer die letzten 8 Messungen berücksichtigt.
- Nur wenn dieses SR mehr als "#define filtth 6" Nullen bzw. Einsen
enthält wird abhängig vom aktuellen Zustand in einer fsm in den anderen
übergegangen.
Damit erreiche ich eine sehr stabile Auswertung ohne Fehlauslösungen,
schon bei knapp unter 1cm Entfernung eines Fingers zur Sensorplatte.
Solange die Taste "gedrückt" wird, wird einfach eine gedrückte
Space-Taste ausgegeben.
Was noch fehlt, ist u.A. eine ständige Nachkalibrierung, bisland wird
nur einmal beim Start der Schnitt von 8 Messungen genommen als
Vergleichswert. Leider ist jedoch wiegesagt der Platz sehr beschränkt,
ich habe bereits die Vendor- und Device-Strings auf nur je 2 Zeichen
gekürzt, um mehr Platz zu haben ;-).

Gruß,
droelf


Nachtrag: Es werden alle nicht benötigten Pins auf Ausgang und 0
geschaltet, ich hatte mit dem seriellen Kabel angesteckt, aber uart-tx
nicht an (das tx-Pin also auf Eingang) eine Verschlechterung der
Empfindlichkeit festgestellt.
Außerdem habe ich noch auf der Lochrasterplatte die Lötinseln rund um
die beiden benötigten Pins, den Kondensator und den Widerstand zur
Sensorfläche weggekratzt, um eben möglichst wenige zusätzliche
Kapazitäten an der Sensorplatte zu haben.

Hallo,
ich hab mir hier aus dem Thread mal die sense_key Funktion von Andreas
Auer (Beitrag "Re: qtouch - sekt oder selters") geholt und
zwischen Port C0 und C1 10nF und daran über 1kohm eine Touchfläche mit
20x20mm.

Das Ergebnis der sense_key Funktion soll nun auf dem LCD ausgegeben
werden. Dies funktioniert auch soweit aber leider wird immer nur eine
Null angezeigt.

#include <avr/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <util/atomic.h>
#include <oldmacros.h>
#include "lcd-routines.h"
#include <util/delay.h>
#define TAKT 16000000UL;

static int sense(void)
{
    unsigned char i=0; 
    DDRC  = 0x00;
    PORTC = 0x00;
    
    DDRC |= _BV(PC1);
    DDRC |= _BV(PC0);
    _delay_us(5);
    DDRC &= ~_BV(PC1);
    DDRC &= ~_BV(PC0);

    PORTC |= _BV(PC0);
    for(i=0; i<255 && !(PINC & _BV(PC0)); i++)
    {
        DDRC |=  _BV(PC0);
        _delay_us(5);
        DDRC &= ~_BV(PC0);
        DDRC |=  _BV(PC1);
        _delay_us(20);
        DDRC &= ~_BV(PC1);
    } 
    DDRC |= _BV(PC1);
    DDRC |= _BV(PC0);
    PORTC = 0x00;
    
    return i;
}


int main(void)
{
  
  while(1)
  {
  lcd_init();
  lcd_string("Sensekey:");
  lcd_data(sense());
  lcd_setcursor(0,2);
  
    {
    char Buffer[20];
    itoa(sense(), Buffer, 10);
    lcd_string(Buffer);
    }
  }
}

Was mache ich falsch?

Meine Sensorfläche ist einfach ein Stück Leiterplatte mit Tesa darauf
als Berührungsschutz, also nur eine Kupferfläche. Ich hab mir auch schon
mal den Designguide von Atmel angesehen, aber wurde auch nicht schlau
daraus.

Vielen Dank schon mal im Vorraus

Update:

Ich hab jetzt ne Sensorfläche dran wo aussen rum ein streifen geerdet
ist und die Fläche hängt am Capture bin.

Der Wert am Display ändert sich allerdings nur wenn ich mit dem Finger
direkt auf die Platine zwischen GND und der Sensorfläche drücke von 0
auf so an die 30 mein Kondensator zwischen den beiden Ports hat 100nF.

Hat jemand ne Idee für diesen Fehler? Warum ist das so?

Johannes Huber schrieb:
> Was mache ich falsch?

Vielleicht solltest Du mal Deinen Code kommentieren. Das macht es
anderen und vor allem Dir einfacher zu sehen, was er macht und ob das
richtig ist.

Kombibedingungen im for()-Ausdruck halte ich für besonders
unübersichtlich.
Gibt es weitere Abbruchmöglichkeiten, nehme ich dafür ein break.

Und Du mußt schon sagen, was Du wo angeschlossen hast, ein Schaltplan
wäre natürlich noch besser.

Und statt nichtssagenden PC0, PC1 usw. nenne ich die Portpins nach ihrer
Funktion.
Dann ist es auch einfacher, die Pins zu wechseln.


Mindestens ein Fehler ist, daß Du den einen Pin ständig auf high läßt,
dadurch lädt Dir der interne Pullup den Kondensator sofort auf, so kanns
nicht gehen.


Peter

Sorry,
ich hab gestern nur in aller schnelle vl ein bisschen unüberlegt
gepostet also nochmal:

Ich benutzte nen Mega8 am Capture PIN PB0 hängt über 1kohm die
Touchfläche und zwischen PB1 und PB0 hängt  bei mir ein 100nf Elko.

#include <avr/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <util/atomic.h>
#include <oldmacros.h>
#include "lcd-routines.h"
#include <util/delay.h>

static int sense(void) //Funktion aus Andreas Auers Beitrag auf nen Mega8 angepasst
{
    unsigned char i=0; 
    DDRB  = 0x00;
    PORTB = 0x00;
    
    DDRB |= _BV(PB1);
    DDRB |= _BV(PB0);
    _delay_us(5);
    DDRB &= ~_BV(PB1);
    DDRB &= ~_BV(PB0);

    PORTB |= _BV(PB0);
    for(i=0; i<255 && !(PINB & _BV(PB0)); i++)
    {
        DDRB |=  _BV(PB0);
        _delay_us(5);
        DDRB &= ~_BV(PB0);
        DDRB |=  _BV(PB1);
        _delay_us(20);
        DDRB &= ~_BV(PB1);
    } 
    DDRB |= _BV(PB1);
    DDRB |= _BV(PB0);
    PORTB = 0x00;
    
    return i;
}


@Peter Dannegger
Ich hab es auch schon mal mit deinem Code herum experimentiert welchen du auf Andreas Auers Beitrag hin gepostet hast aber mit der mydefs.h komme ich nicht so recht klar =)

Danke für deine Hilfe

Johannes


int main(void)
{
  
  while(1)
  {
  sense();
  lcd_init();
  lcd_string("Sensekey:");
  lcd_setcursor(0,2);
  
    {
    char Buffer[20];
    itoa(sense(), Buffer, 10);
    lcd_string(Buffer);
    }
  }
}

Ich habe heute auch angefangen, mit QTouch rumzuexperimentieren.
Habe auf Lochraster einen ATmega8 und ein 4x4-Rasterfeld für einen
Touch-Key neben minimalst-Beschaltung des mega ( ja, nicht einmal die
Abblock-Kondensatoren habe ich drin ).
Eine LED signalisiert, wenn man am Key rumdrückt/sich in der Nähe
aufhält.

Der Code von Andreas Auer hat mir leider immer nur 0 zurückgeliefert,
aber mit dem Code von Peter Dannegger läuft es nun ( musste MAX_CYCLE
nur anpassen, vielen Dank nochmal ).

Mein Aufbau ist alles andere als Ideal ( 100nF Kondensator, hatte gerade
keinen besser passenden da ), trotzdem ist es für einen ersten Test
wunderbar.

Werde das ganze demnächst auf einer geätzten Platine ( mit richtigen
Werten und "guter" Beschaltung ) aufbauen, und habe prompt eine Frage
...
Hat einer von euch schon einen Slider ( 3 Channels ) zum laufen bekommen
( am liebsten ohne die Lib von Atmel ) ? Wie müsste man die 3 Werte
miteinander verrechnen, um einen schönen linearen Weg zu haben ?

nein ich bin noch nciht wieder dazu gekommen, aber würde mich über deine
erfahrungen freuen.

mit der atmel lib hab ich mich noch nicht groß beschäftigt

Also ich weiß nicht genau wie das bei mir aussieht. Ich kann mal
schauen, dass ich mir auch diese Werte ausgeben lasse und dann kann ich
mehr dazu sagen, ob das bei dir normal ist oder nicht!

Vom Programm her könnte ich jetzt nichts besonderes feststellen!

mfg
Andreas

Es könnte helfen, wenn Du das Programm compilierbar postest.
Also mit allen nötigen Variablen, Defines und Includes und als Anhang.
Und der Schaltplan wäre auch nicht zu verachten.



Peter

Hat von euch schon jemand nen Vergleichstest verschiedener Sensorflächen
gemacht? Bis jetzt hab ich nur Kupfermünzen als Sensorfläche
verwendet...funktioniert zwar ganz gut, aber gibts da vielleicht etwas
besseres? Das ganze soll hinter eine 4mm Plexiglasscheibe

Hi,

also ich hab vor kurzem einen Prototypen mit 3 Sensortasten gebaut. Die
Sensorflächen sind quadratische Kupferflächen direkt auf der Platine mit
ca. 1,2cm x 1,2cm und mit Lötstopplack bedeckt.
Die Tasten sind hinter 2mm Plexiglas und 2mm Luftspalt ist zwischen
Sensorfläche und Plexiglas auch noch. Funktioniert einwandfrei.

Ich mach die Messung aber nicht in Software sondern mit den fertigen
Chips von Atmel AT42QT1010.

Ach ja... hab ich noch vergessen. Ich hab auch noch eine Bohrung mitten
in der Sensorfläche wo ich eine LED durchscheinen lasse.

mfg
Andreas

Hans schrieb:
> Kann man diese Charge-Transfer Methode uneingeschränkt verwenden, oder
> hält jemand (Atmel) Patente? Oder gelten etwaige Einschränkungen nur für
> deren Bibliothek?

Atmel verfolgt die Philosophie, die Anwender der verschiedensten
Bausteine mit Applikationen zu unterstützen. Daher kann man das
qTouch-Prinzip überall und uneingeschränkt anwenden. Bei den Lehrgängen
zu dem Thema wurde dies auch ausdrücklich betont ;-)

Bernhard B. schrieb:
> Das ganze soll hinter eine 4mm Plexiglasscheibe

Gar kein Problem. Die Flächen müssen nur groß genug sein. In deinem Fall
etwa 2cm Kantenlänge bei quadratischen oder 3cm Durchmesser bei runden
Flächen. Die Kapazität des Ladekondensators sollte in dem Fall etwas
höher gewählt werden.

Andreas Auer schrieb:
> Die
> Sensorflächen sind quadratische Kupferflächen direkt auf der Platine mit
> ca. 1,2cm x 1,2cm und mit Lötstopplack bedeckt.
> Die Tasten sind hinter 2mm Plexiglas und 2mm Luftspalt ist zwischen
> Sensorfläche und Plexiglas auch noch. Funktioniert einwandfrei.

Das klingt echt gut, ich denke ich werde das ebenfalls mit den
Kupferflächen probieren. Ist einfach & billig. Danke!

Andreas Auer schrieb:
> Ach ja... hab ich noch vergessen. Ich hab auch noch eine Bohrung mitten
> in der Sensorfläche wo ich eine LED durchscheinen lasse.
Rein aus Interesse: Wie groß hast du das Loch gemacht?

Knut Ballhause schrieb:
> Gar kein Problem. Die Flächen müssen nur groß genug sein. In deinem Fall
> etwa 2cm Kantenlänge bei quadratischen oder 3cm Durchmesser bei runden
> Flächen. Die Kapazität des Ladekondensators sollte in dem Fall etwas
> höher gewählt werden.

Ok, dann werde ich die Fläche quadratisch machen, das ist mechanisch
einfacher herzustellen. Bezüglich der Kapazität: Ich hätte da an
irgendetwas zwischen 33nF und 50nF gedacht. Passt das?

Danke!

Bernhard B. schrieb:
> Rein aus Interesse: Wie groß hast du das Loch gemacht?

Ich hab jetzt meine Eagle Files nochmal angesehen... und zwar war meine
Sensorfläche 14mm x 10mm groß. Und die Kreisfläche ohne Kupfer (ist ja
etwas größer als die Bohrung selbst) hatte einen Durchmesser von ca.
3mm.

Als Kondensator hab ich 33nF verwendet. War ohne Plexiglas und Luftspalt
sehr sehr empfindlich. Mit Plexiglas und Luftspalt hats dann gepasst.
Bessere wäre bei mir auch gewesen, wenn die Platine direkt am Plexiglas
aufgelegen wäre (war nicht möglich, da noch ein OLED Display dazwischen
war). Der Luftspalt ist sehr ungünstig. Sollte also in deinem Fall ganz
leicht funktionieren.

mfg
Andreas

Hans schrieb:
> Je größer im Verhältnis zur Kapazität der Sensorfläche, desto länger
> braucht die Messung.

Stimmt, aber nur so kann man große Flächen überhaupt messen und eine
gescheite Reichweite erzielen. Ist die Fläche zu groß und der
Kondensator zu klein, gibt es zu wenig Hub, den man auswerten könnte.
Ist also alles ein wenig experimentell, aber wenn man die richtigen
Werte hat, sehr zuverlässig.

Andreas Auer schrieb:
> Ich hab jetzt meine Eagle Files nochmal angesehen... und zwar war meine
> Sensorfläche 14mm x 10mm groß. Und die Kreisfläche ohne Kupfer (ist ja
> etwas größer als die Bohrung selbst) hatte einen Durchmesser von ca.
> 3mm.
>
> Als Kondensator hab ich 33nF verwendet. War ohne Plexiglas und Luftspalt
> sehr sehr empfindlich. Mit Plexiglas und Luftspalt hats dann gepasst.
> Bessere wäre bei mir auch gewesen, wenn die Platine direkt am Plexiglas
> aufgelegen wäre (war nicht möglich, da noch ein OLED Display dazwischen
> war). Der Luftspalt ist sehr ungünstig. Sollte also in deinem Fall ganz
> leicht funktionieren.

Danke für die ausführliche Beschreibung!

Nachdem ich mich jetzt mehrere Tage lang an der (zuverlässigen)
Auswertung von Tastendrücken beschäftigt habe, haben sich noch ein paar
Fragen aufgetan.
Wie schirmt man die Verbindung vom Touchpad zum Mikrocontroller am
besten ab? Im Moment verwende ich dafür ein geschirmtes, ca. 20cm langes
Kabel (da fällt mir ein: den Schirm des Kabels hab ich im Moment nicht
angeschlossen - den ich sollte den vielleicht mal einseitig auf Masse
legen) Ich weiß, man sollte die Verbindung möglichst kurz halten, doch
kürzer kann ichs für den Testaufbau nicht machen. Die Auswertung des
Tastendrucks klappt eigentlich ganz zufriedenstellend, aber nur solange
ich das Kabel nicht bewege. Wenn ich das Kabel wenige cm nach rechts
oder links bewege, kann ich nur noch mit Mühe einen Tastendruck
erkennen, da sich die Schwellwerte ändern. Mit dieser Einschränkung kann
ich jedoch leben, da ich das Verbindungskabel einfach mit Heisskleber an
einer Stelle montiere wo man nicht so leicht hinlangen kann.

Was mich wesentlich mehr stört, ist folgendes: Auf der Platine wo der uC
sitzt, der die Auswertung des Tastendrucks vornimmt befindet sich noch
ein Anschluss für den USART. Jedes Mal wenn ich da ein Kabel anschließe,
dann funktioniert die Auswertung nicht mehr. Meine Vermutung ist, dass
das USART Kabel wie ne Antenne wirkt und die Schwellwerte dadurch
verschoben werden. Kann man da schaltungstechnisch vielleicht etwas
machen?

Der Vollständigkeit halber: Mit angeschlossenem Kabelschirm
funktioniert's ausgezeichnet!

Hallo,
in der Application Note von Atmel und auch hier wurde erwähnt, dass
Wasser auf der Sensorfläche die Messung beeinflussen kann. Nun möchte
ich aber genau das: ein Regensensor mittels qtouch. Im Atmel-Forum hat
ein Mitarbeiter bestätigt, dass das geht, aber "it needs some
experiments".  Hat das schon mal jemand ausprobiert?
Wie sollte das Ganze dimensioniert werden, und welche Sensorgeometrie
eignet sich dafür? Bei einer einfachen Kapazitätsmessung wäre ja eher
eine mit einer GND-Fläche kammarting verzahnte Sensorfläche geeignet.
Wie schaut das hier aus? Einmal GND außenrum oder GND ganz weglassen?
Die Messung kann/soll sehr langsam erfolgen - es macht nichts, wenn der
Regen erst nach 10 oder 30 Sekunden oder noch später registriert wird,
aber es soll ignoriert werden wenn mal jemand kurz mit dem Finger
hinfasst. Zur Not kann das aber auch per Software rausgerechnet werden.
Gruß, Christian

Regensensor mit qTouch ist nicht ratsam. Gerade bei diesem Prinzip hat
Wasser ohne Bezugspotenzial zur Erde einen verschwindend geringen
Einfluss. Ich kann mit meiner Dusche voll auf die Fliese draufhalten,
hinter der die Elektrode liegt, ohne den Schaltvorgang auszulösen. Kommt
hingegen die Hand auf die nasse oder trockene Fliese, wird sicher
geschaltet. Besorge Dir besser eine Sensorfläche mit vergoldeter
Kammstruktur (einfach) oder nutze einen Reflexkoppler unter einer zu
beregnenden Scheibe (schwieriger).

Nochmal eine kurze Verständnisfrage: Was meint Atmel mit
QTouch-Channels? Kann ich nicht x-beliebige Pins hernehmen? Beim
ATmega16M1 werden z.B. 12 Channels angegeben. Das Ding hat 32 Pins,
davon 27 I/O Pins. Bei allen sind die PullUps abschaltbar. Da ich für
einen Channel immer 2 Pins brauche, wären das also 13 Channels. Schaut
12 einfach nur schöner aus oder darf ich 3 bestimmte Pins nicht
verwenden?

Ok, da hätt ich auch gleich draufkommen können: die fehlenden Pins sind
XTAL1 und XTAL2 :-)

Hallo,

ja ich mal ganz kurz. Nachdem die Lib aber nicht wirklich gut
funktioniert hat - vielleicht war ich auch nur zu doof - und ich sowieso
wissen wollte wie es funktioniert, hab ich es auch selbst implementiert.

mfg
Andreas

Stefan schrieb:
> Leider bekomme ich immer "0" als Rückmeldung.
> Woran könnte denn der Fehler liegen?

Du läßt immer den Pullup eingeschaltet, da kann das nichts werden.

Schau Dir mal meinen Code an:

Beitrag "Re: qtouch - sekt oder selters"


Peter

Domsk schrieb:
> Hab also den nächst größeren genommen. Einen 4,7uF + 4,8 Ohm Widerstand.

Das ist ein verspäteter Aprilscherz, oder?
Im QTouch Bild oben im thread stehen als Beispielswerte 22nF und 1KOhm.
Jetzt rechne mal aus, wieviele Dekaden Du da weg von bist....

Wenn Du den ganzen thread mal durchliest, wirst Du sehen, daß es eher am
Kondensator liegt, der so zwischen 10nF und 33nF sein sollte.

Domsk schrieb:
> Dann hab ich es noch mit einem 104pF Kondensator probiert.
Soso, ein 104pF Kondensator also...

Sieh dir mal an, wie Kondensatoren gekennzeichnet werden. Könnte es
sein, dass auch dein 104 pF Kondensator (wie so viele andere auch) in
Wirklichkeit 10_0000 pF hat (also eine 10 und 4 Nullen), und mithin ein
100nF Kondensator ist?