Pollin Touchpad MODEL TM1001A

[Nervbold (Gast)]

Hallo,
Pollin bietet sehr kostengünstig dieses Touchpad an: Touchpad mit 
Synaptics-Chip (T1001) und 8-poligem Flexprint-Anschluss. Maße (LxBxH): 
62x50x4,7 mm. Keine weiteren Daten verfügbar.

Hab mir mal eins bestellt und hab jetzt das Problem dass mir wirklich 
jegliche Daten fehlen.
Synaptics stellt solche Dinger her, die Seriennummer passt aber nicht 
besonders in die Reihe (das einzige wo passt ist TM für Touchpad-modul).

Hat das Ding mal wer angesteuert oder kann mir irgendwer sagen wo man 
dazu nen Datenblatt herkriegt?
über den Chip der da druff ist habbich rausgefundne dass es 4 Pins gibt: 
GND, VDD, und zwei Datenleitungen wovon eine über einen 
Pullupwiderstandauf VDD gezogen wird (vermutlich also ein 
Bidirektionaler Datenpin?).

Synaptics schreibt über die eigenen Touchpads dass sie über 
PS2/ADB/RS232 angesprochen werden (je nach model).
Da wäre meiner Meinung nach das passendste ADB aber da antwortet das 
Gerät nicht. Übehraupt sagt das Ding extrem wenig und tut überhaupt 
nichts:-P (nagut solls ja auch erst auf Abfrage).

Also es ist ein Chip von Synaptics druff aber der chip zur Kommunikation 
ist ein PIC16C58A (über den habe ich die Pinbelegung gemessen).

Auf der Platine ist nen Aufkleber:
TM1001AL 1. 4ALU1C PT51045VJ133E
(falls damit wer was anfangen kann).
Mir wäre schon extrem geholfn wenn mir wer sagen könnte wer das ding 
aufn markt geworfen hat.

Kann es sein dass das Ding über USB anzusteuern ist?
LG

[Klugscheiss (Gast)]

Schon mal dran gedacht, dass das Teil eine PS2-Maus ersetzen könnte ? 
Und eine Forensuche mit 'Touchpad' wirkt auch Wunder ...

[Nervbold (Gast)]

Jop dran gedacht habbich tatsächlich schon öfters habbich vergessen zu 
sagen hab das ding schon an nen uralt laptop angeschlossen das ding wird 
nicht erkannt.
Und die Forensuche hilft insofern Wunder dass man nix zu dem Touchpad 
findet das ich hier liegen habe (es sei denn jemand hat sich in der 
Nummer vertan).
Ich will nicht irgendein Touchpad ansteuern sondern genau dieses hier 
weil es schön billig ist^^
LG

[Klugscheiss (Gast)]

Und alles schön auf dem Silbertablett serviert oder wie ?
Nun ja, wenn Du nicht in der Lage bist die hier reichlich vorhandenen 
Informationen abzugreifen solltest Du ein eine der Ecken des Touchpad 
ein Loch bohren, 'nen Bindfaden durchfriemeln (ACHTUNG! DURCHMESSER 
BEACHTEN!) und an den Autorückspiegel, soweit vorhanden, hängen.
Mann, mann, mann, Du fasst doch auch nicht an die Pole einer 9V-Batterie 
um festzustellen ob sie voll ist, oder ? Schon mal die beiden 
Datenleitung per Ozsi angeguckt, mit am Touchpad angeschlossenen 
Betriebsspannung versteht sich ?

[Nervbold (Gast)]

Also erstmal: silbertablett ist nicht wie man ja sieht: ich habe etwa 6 
Stundne das halbe inet nach Datenblättern durchsucht. Weder für den 
Synaptics Chip fiundet man was sinnvolles noch in irgendeiner weise was 
über die existens dieses Touchpads (außer bei pollin).

Außerdem habe ich wie gesgat schon ne ganze Menge ausprobiert etc.

"Schon mal die beiden
Datenleitung per Ozsi angeguckt, mit am Touchpad angeschlossenen
Betriebsspannung versteht sich ?"
Nicht nötig; wie oben beschrieben tut das Ding von sich aus NICHTS!
Außerdem habbich kein Oszi....

Die Idee mit dem Loch ist aber auch nicht schlecht^^

[Nervbold (Gast)]

Aso und gegen PS2 spricht doch eigentlich dass das Gerät nur einen 
Pullup hat. PS2 sieht so weit ich weiß an beiden Datenleitungen (data + 
clock) einen vor oder täusch ich mich?

[Klugscheiss (Gast)]

Ja, nee, ist klar. Ich glaube das führt hier zu nichts. Letzter Tip: 
Lies' Dir noch mal meinen ersten Beitrag durch und beherzige diesen ggf.

[John S. (linux_80)]

<SENF>
Ich hab noch ein T1002SU, mit etwas mehr drumrum, das schaut von der 
weite auch so aus wie das hier.
Das konnte ich mal rauspiepsen:

Verbindung auf Touchmodul zu PIC
1 Vdd
2   (U2 PIC Pin18 RA1)
3   (U2 PIC Pin17 RA0)
4 Taste R von Tastenmodul (Low aktiv)  (U1 Pin32)
5 Taste L (Low aktiv)  (U1 Pin31)
6 Vss/Gnd
7 ?, schaut nach nix aus ;)
8 ?

U1 = T1002, U2 = PIC16C58A-04

Und PS2 ist es nicht, denn ich hab das einfach mit den 2 Pins an nen 
alten PC gehängt, dann geht der PC nicht mehr, egal wie rum die beiden 
Pins verkabelt werden :/
Pins wackelten keine wenn man Spannung drauf gibt.
Der Anschluss zum Mainboard ist dann auch nur noch 6 polig.
</SENF>

[Nervbold (Gast)]

Hallo,
vielen Dank für Deine Antwort!

2   (U2 PIC Pin18 RA1)
3   (U2 PIC Pin17 RA0)

Dies ist genau wie bei meinem. Am PIC sind RA0 und RA1 die Inputs.
Tastermodule hat meins nicht soweit ich weiß.
Hast Du eine Ahnung welcher Hersteller das ist?
LG

[John S. (linux_80)]

Weiss ich nicht, hatte das Teil mal vom Flohmarkt mitgenommen, war schon 
aus dem Laptopgehäuse ausgesägt, incl. Tasten :)

[Nervbold (Gast)]

Lol aus einer uralt Readme von Synaptics hab ich folgendes:
Improved support for older (model TM1001) TouchPad hardware.
Die Readme ist aus dem Jahre 1996:-) also scheint das ding tatsächlich 
ein Uraltes Modell von Synaptics zu sein...
Aber Datenblätter gabs damals wohl noch nicht schade:-P

[Christian H. (netzwanze)]

Eventuell mal die Firma freundlich anschreiben und ggf einen 
interessierten Studenten mimen.

[John S. (linux_80)]

Auf den ICs an meinem Touch steht 9537.

[Benedikt K. (benedikt)]

Ja, das Touchpad ist uralt, aber bei dem Preis ist das egal. Ich habe 
auch schon versucht das zum Laufen zu bekommen.
Es gibt 3 Leitungen die über 5,1k Pullups an 5V und über 51k zum PIC und 
zum ASIC gehen. Wenn man diese Leitungen auf Low zieht, beginnt der ASIC 
diese Leitungen wie wild zu toggeln. Am Ausgang kommt aber kaum was 
davon an, aufgrund des 51k Serienwiderstands. Daher tippe ich auf 
Tastereingänge für die Maustasten, die z.b. gemultiplexed mit dem ASIC 
geteilt werden.
Die beiden mit IO bezeichneten Pins gehen direkt an den PIC. Hier 
vermute ich PS2 oder sonst ein Interface. Diese Leitungen sind aber nur 
Tristate, hier tut sich nix, selbst wenn Pullups gegen 5V angeschlossen 
werden. Eigentlich hätte ich erwartet, dass das Touchpad direkt anfängt 
zu senden, so wie dies bei PS2 üblich ist.

Die Belegung die ich ermittelt habe:
1 5V
2 IO1
3 Key1
4 GND
5 Key2
6 IO2
7 Key3
8 GND

[Nervbold (Gast)]

Hey,
bin ich ja doch nicht allein mit meinem Problem:-P
Also deine Pinbelegung entspricht der die ich rausgefundne habe wobei 
ich den 3 Tasterpins keine Bedeutung zugesprochen hatte (bisher).


Also in der uralt-readme stehen nur die Protokolle PS2/Seriell. Ich gehe 
mal davon aus dass dann das ADB rausfällt oder? kann sein dass synaptics 
die ADB's erst später rausgeworfen hat.

In der Datei ist auch von "Treibern" die Rede. brauchte man früher für 
PS/2 Treiber? (keine Ahnung wie das vor Urzeiten aussah).

LG

[Nervbold (Gast)]

"kann sein dass synaptics die ADB's erst später rausgeworfen hat."
.. kann aber auch sein dass ich "auf dem Markt geworfen hat" gemeint 
hab:-P
LG

[Sebastian (Gast)]

Sicher, daß es nicht PS/2 ist? Ich würde mir mal das (im Netz an 
diversen Stellen dokumentierte) Initialisierungsverhalten von 
PS/2-Mäusen anschauen.

[Benedikt K. (benedikt)]

Sebastian schrieb:
> Sicher, daß es nicht PS/2 ist?

Ich bin ziemlich sicher, dass die beiden Pins die ich als IO bezeichnet 
habe, kein normales PS2 sein (es könnte natürlich auch sein, dass meine 
Anschlussbelegung komplett falsch ist...)

> Ich würde mir mal das (im Netz an
> diversen Stellen dokumentierte) Initialisierungsverhalten von
> PS/2-Mäusen anschauen.

z.B hier:
http://www.computer-engineering.org/ps2mouse/

Bei allen Beschreibungen die ich gesehen habe, muss sich die Maus zuerst 
melden, so wie auch in dem Beispiel auf obiger Seite:

Mouse: AA  Self-test passed
Mouse: 00  Mouse ID

Genau das sendet z.B. auch die Maus die ich wegen dem PS2 Kabel 
geschlachtet habe.
Das Touchpad macht dagegen nach dem Einschalten rein gar nichts und 
funktioniert natürlich auch nicht am PC.

[Sebastian (Gast)]

Stimmt. "The device always generates the clock signal." Ich hatte das 
falsch in Erinnerung. Aber vielleicht verhält sich ein "Kombigerät" 
(RS232 und PS/2) anders, zumindest bis das benutzte Interface erkannt 
wurde?

[Benedikt K. (benedikt)]

Ich habe keine Ahnung woran das Kombigerät den Unterschied erkennt, denn 
in beiden Fällen müsste die Maus sich zuerst melden (bei PS2 mit dem 
0xAA, bei der COM Port Maus mit einem 'M').
Da es 3 gleiche Eingänge gibt (mit je einem 5,1k Pullup und einem 51k 
Serienwiderstand), (und eine 3 Tasten Maus zur damaligen Zeit bei 
Touchpads eher wenig Sinn macht), könnte einer davon CTS oder sowas 
sein, was normalerweise bei einer RS232 Maus als Spannungsversorgung 
benutzt wird. Diese Leitung wurde vom Treiber auf Low gezogen (da RS232 
invertiert ist und die Leitung dann auf +12V liegen würde). Allerdings 
habe ich eigentlich schon alles durchprobiert, leider erfolglos.

[Rufus Τ. F. (rufus)]

Hmm. ADB scheint es dann wohl nicht zu sein, das hat nur eine 
kombinierte Takt- und Datenleitung. Und ein Mac-Touchpad hat nur eine 
Taste. Also ein Eingang zu viel.

[Mitbastler (Gast)]

Vielleicht hilft das hier weiter:

http://www.neophob.com/serendipity/index.php?/archives/146-Reuse-old-notebook-parts.html


oder

http://www.synaptics.com/sites/default/files/ACF126.pdf?q=decaf/utilities/ACF126.pdf

[Benedikt K. (benedikt)]

Beides ist leider schon bekannt.
Das Problem ist, dass das Touchpad derart alt ist. Der erste Link 
beschreibt die 4er Generation der ASICs (die glaube ich noch aktuell 
ist), das älteste was in der Datei von Synaptics auftaucht ist der T1002 
ASIC. Auf dem Pollin Touchpad ist der Vorgänger davon, der T1001 
verbaut.
Die Belegung im Datenblatt hat sich zwischen 1001 und 1002 leider 
geändert.
Die Pins von dem PIC die bei der 1002er Version verwendet werden, sind 
Pin 17 und 18. Das sind auch die Pins die ich bei dem 1001er als IO 
bezeichnet habe.

In der PDF steht "Second Edition". Die First Edition könnte eventuell 
die gesuchten Infos beinhalten...

[Benedikt K. (benedikt)]

Ich habe gerade mal das TM1002 Touchpad rausgekramt und angeschlossen: 
Das läuft wunderbar an PS2.
Bei dem sind Pin 18 vom PIC PS2 DATA und Pin 17 PS2 CLOCK.
Für das TM1001 würde das also bedeuten Pin 6 wäre DATA und Pin 2 wäre 
CLOCK.

[Fabian S. (jacky2k)]

Hallo,
habe das Gerät heute auch von Pollin bekommen. Habe dann im Netz das 
hier gefunden:
The Combo TouchPad module should be wired to a DB-9 female connector; 
the signals TxD, RxD, DTR, RTS, CTS, and GND should be wired between the 
two connectors as indicated in Figures 4-1 and 4-2. To support 
plug-and-play, DTR and DSR should be wired together on the connector. 
The DB-9 connector can be plugged directly into a computer’s RS-232 port 
for Serial TouchPad operation. (Note that the CTS pin must be wired from 
pin 8 of the DB-9 connector to pin 7 of the module connector, even 
though the CTS signal is marked “not used” in Figure 4-1. The CTS wire 
will be unused when operating in Serial mode but it is needed to supply 
power in PS/2 mode.)

Die Pinbelegungen kommen zwar nicht hin, aber hilft das evtl dennoch 
weiter?
Das ganze kommt von hier: 
http://www.aquaphoenix.com/hardware/ledlamp/reference/synaptics_touchpad_interfacing_guide.pdf

[Fabian S. (jacky2k)]

Ich habe grade eine interessante Entdeckung gemacht, kann sie allerdings 
nicht zuordnen :)
Und zwar habe ich GND und Vdd angeschlossen, alle anderen Pins NC 
gelassen.
Jetzt kann ich mitdem Ossi an Pin 3, 5 und 7 (sprich den angeblichen 
KeyX Pins) ein digitales Signal sehen. Es ist zwar sehr schwach 
(schwankt um ca. 0.5V bei 5V rum). Interessant ist, dass sich das Signal 
verändert wenn ich meinen Finger auf das Feld lege. Und es nimmt 
nochmals eine andere Form an, wenn ich ihn bewege. Die Veränderun ist 
allerdings nur minimal.
Hat das vorher schon mal jemand gesehen?
Der rot markierte Pegel geht dann auch auf den niedrigen Wert wenn ich 
mein Finger drauf lege, wenn ich ihn bewege wird der Ausschlag wieder 
etwas breiter, aber immernoch kleiner als der da jetzt.
Edit: noch was: wenn ich Pin2 mit nem 10k gegen GND ziehe höhrt das 
Signal auf!

[Benedikt K. (benedikt)]

Fabian S. schrieb:

> Hat das vorher schon mal jemand gesehen?

Ja, das liegt daran, dass sich die Eingänge wohl Leitungen mit dem ASIC 
Teilen. Da aber die weiter oben beschriebene 5,1k Pullup - 51k 
Serienwiderstand Kombination zwischen den Leitungen und dem PIC/ASIC 
liegen. Daher meine Vermutung dass diese Eingänge sind für die Taster: 
Ist der ASIC auf Tristate, wird der Maustaster eingelesen, ansonsten die 
Signale vom ASIC. Das würde auch einigermaßen Sinn machen.
Ähnliche Signale findet man übrigens an den meisten anderen Pins die vom 
ASIC zum PIC gehen.
Auch interessant: Die Signale an den Leitungen die zum Touchfeld gehen. 
Da sieht man an den Flanken deutlich wenn man mit dem Finger drüber 
fährt.

[Fabian S. (jacky2k)]

Klingt logsich. Aber warum hörts auf, wenn ich Pin 2 auf GND ziehe?

[Helmchen74 (Gast)]

Hi Nervbold,
habe evtl. einen interessanten Link gefunden - allerdings nur grob 
überflogen, sind m.E. aber die Informationen für dich drin:

http://www.aquaphoenix.com/hardware/ledlamp/reference/synaptics_touchpad_interfacing_guide.pdf

Viel Erfolg,
Helmchen74

[Maxwell (Gast)]

Hallo,

das Datenblatt vom Helmchen74 sieht ja ganz interessant aus.
Hat hier schon jemand das Touchpad erfolgreich in Betrieb genommen ?
Bei den Preis kann man ja echt nicht widerstehen.
Überlege mir das Teil in Verbindung mit einer programmierbaren Logik zu 
verwenden.

LG

Maxwell

[Franky (Gast)]

Hallo zusammen,
falls noch jemand Interesse hat. Ich hab mich mit dem Touchpad mal über 
den Jahreswechsel beschäftigt und es an einem AT90S2313 zum Laufen 
gebracht. Das TP wird mit dem "Apple Desktop Bus" (ADP) Protokoll 
angesteuert.

Hier die Pinbelegung:
1 5V
2 ADB
3 ?
4 GND
5 ?
6 ?
7 BUTTON 1 / nach Masse schalten
8 GND

Weitere Info's gibt es hier:
http://www.snark.de/mac/tpad/
http://developer.apple.com/legacy/mac/library/technotes/hw/hw_01.html


Falls jemand tiefer einsteigen möchte.
Das TP läuft standardmäsig im normalen Mausmodus. Interessanter ist 
allerding der Absolutmodus. Dort kann die Position des Fingers in X und 
Y Richtung und die abgedeckte Fläche (ein, zwei oder drei Finger) 
abgefragt werden.
Das TP lässt sich durch folgende Operationen in diesen Modus schalten:

ADP Register 3
Byte 1 auf 0x63
Byte 2 auf 0x04

ADP Register 1
Byte 7 auf 0x00

Hab mir gleich mal 10 TP's bestellt, falls das Echo den Lagerbestand von 
Pollin übersteigt ;-).

Gruß
Frank

[Klaus R. (klaus2)]

Sehr gut Franky - jetzt muss ich die 3 Dinger doch mal wieder 
rauskramen, die ich mal "vorsichtshalber" bestellt hab :)

Wird es da deinerseits codetechnisch eine "Orientierungshilfe" geben? :)

Klaus.

[Franky (Gast)]

Hallo Klaus,
hier der Teil, der für das Auslesen und Schreiben der ADB Regsiter 
zuständig ist. Hab das nur mal auf die schnelle geschrieben, deshalb 
nicht sehr gut kommentiert. Hoffe du kommst damit klar. 
"BITS(XXXX,XXXX)" ist bei mir ein Makro. Kannst die Werte ja in HEX 
eingeben.

#define ADB_BIT 1<<PB0  // ADB
#define ADB_PIN PINB 
#define ADB_POUT PORTB 
#define ADB_PDIR DDRB

// ADB Befehle
#define COM_TALK0 BITS(0011,1100) //Adresse 3, Talk, Register0
#define COM_TALK1 BITS(0011,1101) //Adresse 3, Talk, Register1
#define COM_LISTEN1 BITS(0011,1001) //Adresse 3, Listen, Register1
#define COM_TALK2 BITS(0011,1110) //Adresse 3, Talk, Register2
#define COM_TALK3 BITS(0011,1111) //Adresse 3, Talk, Register3
#define COM_LISTEN3 BITS(0011,1011) //Adresse 3, Listen, Register3

// Register auslesen / schreiben
u08 adb(u08 command){
  u08 bitpos;
  u08 z_byte;
  u08 anzahl_out;
  //Teilerwerte TC0     
  #define ADB_VORTEILER_A TIMER_VT_64
  #define ADB_VORTEILER_A_BIT TIMER_VT_64_B
  #define ADB_VORTEILER_B TIMER_VT_8
  #define ADB_VORTEILER_B_BIT TIMER_VT_8_B
  #define ADB_IMPULS_LANG TAKT/ADB_VORTEILER_B*65/1000000
  #define ADB_IMPULS_KURZ TAKT/ADB_VORTEILER_B*35/1000000
  #define ADB_IMPULS_ATT TAKT/ADB_VORTEILER_A*800/1000000
  #define ADB_IMPULS_SYNC TAKT/ADB_VORTEILER_B*70/1000000
  #define ADB_IMPULS_TLT TAKT/ADB_VORTEILER_B*250/1000000
  #define ADB_IMPULS_PAUSE TAKT/ADB_VORTEILER_B*200/1000000

  ADB_PDIR |= ADB_BIT; // Ausgang 0
  ADB_POUT &= ~ADB_BIT; 
  
  ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
  ADB_POUT |= ADB_BIT; 

  //Attention Signal
  TCCR0 = ADB_VORTEILER_A_BIT;    
  TCNT0 = 0; // Zähler auf null setzen  
  ADB_PDIR |= ADB_BIT; // Ausgang 0
  ADB_POUT &= ~ADB_BIT; 
  while (TCNT0 < ADB_IMPULS_ATT);

  //Sync Impuls
  TCCR0 = ADB_VORTEILER_B_BIT;    
  TCNT0 = 0; // Zähler auf null setzen  
  ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
  ADB_POUT |= ADB_BIT; 
  while (TCNT0 < ADB_IMPULS_SYNC);

  for(bitpos=128;bitpos;bitpos>>=1){  //Command ausgeben
    TCNT0 = 0;
    ADB_PDIR |= ADB_BIT; // Ausgang 0
    ADB_POUT &= ~ADB_BIT; 
    if(command&bitpos) 
      while (TCNT0 < ADB_IMPULS_KURZ);
    else 
      while (TCNT0 < ADB_IMPULS_LANG);
    ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
    ADB_POUT |= ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);
  }
  // STOP BIT (0)
  TCNT0 = 0;
  ADB_PDIR |= ADB_BIT; // Ausgang 0
  ADB_POUT &= ~ADB_BIT; 
  while (TCNT0 < ADB_IMPULS_LANG);
  ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
  ADB_POUT |= ADB_BIT; 
  while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);

  
  anzahl_out = 0;
  if(command == COM_LISTEN3)
    anzahl_out = 2;
  else if(command == COM_LISTEN1)
    anzahl_out = 8;
    
  if(anzahl_out){
    TCNT0 = 0;
    while (TCNT0 < ADB_IMPULS_PAUSE);

    // START BIT (1)
    TCNT0 = 0;
    ADB_PDIR |= ADB_BIT; // Ausgang 0
    ADB_POUT &= ~ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ);
    ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
    ADB_POUT |= ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);

    for(z_byte=0;z_byte<anzahl_out;z_byte++){
      for(bitpos=128;bitpos;bitpos>>=1){  //Daten ausgeben
        TCNT0 = 0;
        ADB_PDIR |= ADB_BIT; // Ausgang 0
        ADB_POUT &= ~ADB_BIT; 
        if(adb_werte[z_byte]&bitpos) 
          while (TCNT0 < ADB_IMPULS_KURZ);
        else 
          while (TCNT0 < ADB_IMPULS_LANG);
        ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
        ADB_POUT |= ADB_BIT; 
        while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);
      }
    }
    // STOP BIT (0)
    TCNT0 = 0;
    ADB_PDIR |= ADB_BIT; // Ausgang 0
    ADB_POUT &= ~ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_LANG);
    ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
    ADB_POUT |= ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);
  }
  else{
    // Warten auf Daten sonst Abbruch
    TCNT0 = 0;
    do{  
      if(TCNT0 > ADB_IMPULS_TLT){
        return(0);
      }
    }while(ADB_PIN & ADB_BIT);
    while(!(ADB_PIN & ADB_BIT)); // Start Bit
    z_byte = 0;
    while(z_byte < 8){
      adb_werte[z_byte] = 0;
      for(bitpos=128;bitpos;bitpos>>=1){  //Bits einlesen
        TCNT0 = 0;
        // Abbruch wenn keine weiteren Bytes übertragen werden.
        do{ 
          if(TCNT0 > ADB_IMPULS_KURZ+ADB_IMPULS_LANG){
            return(z_byte);
          }
        }while(ADB_PIN & ADB_BIT);
        TCNT0 = 0;
        while(!(ADB_PIN & ADB_BIT));
        if(TCNT0 < (ADB_IMPULS_KURZ+ADB_IMPULS_LANG)/2)
          adb_werte[z_byte] += bitpos;
      }
      z_byte++;
    }
  }
  return(z_byte);
}

[Klaus R. (klaus2)]

Das sieht gut aus, vielen Dank - muss ich nur noch das gut versteckte 
Touchpadtütchen wiederfinden! :)

Aber ich geh lieber erstmal rodeln...

Klaus.

[Hauke (Gast)]

Hallo Franky,
Ich finds super, dass du deinen Sourcode mit uns teilst, allerdings muss 
ich sagen, hab ich da noch nicht so viel von verstanden :-(
Das liegt mit Sicherheit gröstenteils daran, dass ich von der Materie 
noch nicht so viel Ahnung hab, deswegen hab ich ein paar konkrete 
Fragen, zu deinem Code:

Ist das eine Funktionsdefinition? Eine Headerdatei? z_byte wird 
zurückgegeben, aber was genau steht da drin?
Ich geb zu ich bin ein Noob, besonders was ADB angeht, aber wie genau 
muss ich vorgehen, wenn ich das Pollin touchpad mit einem Avr auslesen 
möchte?

Ich bin für jede hilfe dankbar...
hauke

[Klaus R. (klaus2)]

Hast du schonmal I2C am AVR genutzt?

Klaus.

[Frank H. (franky1969)]

Hallo zusammen,
freut mich dass es doch noch ein paar Mitstreiter gibt. Habe den Code 
nochmals überarbeitet und gekürzt. Hoffe Ihr kommt klar damit. Es wird 
nur ein Standardport benutzt der zwischen Ausgang und Eingang mit Pull 
Up umgeschaltet wird. Mit I2C hab ich noch keine Erfahrungen. wird aber, 
denke ich, nicht funktionieren da das Protokoll mit verschiedenen 
Pulsweiten arbeitet und nur eine bidirektionale Leitung verwendet wird.

Viel Spaß damit
Frank

#define TAKT 7372800  //Quarzfrequenz

//Vorteiler Timer 0 und 1 bei 2313, 8515, Mega8 (nicht Timer 2)
#define TIMER_VT_1_B BITS(0000,0001)  
#define TIMER_VT_8_B BITS(0000,0010)  
#define TIMER_VT_64_B BITS(0000,0011)
#define TIMER_VT_256_B BITS(0000,0100)
#define TIMER_VT_1024_B BITS(0000,0101)

#define TIMER_VT_1 1  
#define TIMER_VT_8 8  
#define TIMER_VT_64 64
#define TIMER_VT_256 256
#define TIMER_VT_1024 1024

// PORT B
#define ADB_BIT 1<<PB0  // ADB
#define ADB_PIN PINB 
#define ADB_POUT PORTB 
#define ADB_PDIR DDRB

typedef unsigned char  u08;
typedef unsigned short int u16;


// Eingänge
ADB_PDIR &= ~ADB_BIT;

// Pull Up einschalten
ADB_POUT |= ADB_BIT;
  

#define COM_TALK0 BITS(0011,1100) //Adresse 3, Talk, Register0
#define COM_TALK1 BITS(0011,1101) //Adresse 3, Talk, Register1
#define COM_LISTEN1 BITS(0011,1001) //Adresse 3, Listen, Register1
#define COM_TALK2 BITS(0011,1110) //Adresse 3, Talk, Register2
#define COM_TALK3 BITS(0011,1111) //Adresse 3, Talk, Register3
#define COM_LISTEN3 BITS(0011,1011) //Adresse 3, Listen, Register3

#define MAX_ADB 9
u08 adb_werte[MAX_ADB];


// ADB Register auslesen / schreiben 
// Rückgabe Anzahl der Empfangenen Daten 
// Befehl in adb_werte[0]. Empfangene bzw. zu sendende Daten in adb_werte[1 bis 8]
u08 adb(void){
  u08 bitpos;
  u08 z_byte;
  u08 anzahl_out;
  //Teilerwerte TC0     
  #define ADB_VORTEILER_A TIMER_VT_64
  #define ADB_VORTEILER_A_BIT TIMER_VT_64_B
  #define ADB_VORTEILER_B TIMER_VT_8
  #define ADB_VORTEILER_B_BIT TIMER_VT_8_B
  #define ADB_IMPULS_LANG TAKT/ADB_VORTEILER_B*65/1000000
  #define ADB_IMPULS_KURZ TAKT/ADB_VORTEILER_B*35/1000000
  #define ADB_IMPULS_ATT TAKT/ADB_VORTEILER_A*570/1000000
  #define ADB_IMPULS_SYNC TAKT/ADB_VORTEILER_B*70/1000000
  #define ADB_IMPULS_TLT TAKT/ADB_VORTEILER_B*250/1000000
  #define ADB_IMPULS_PAUSE TAKT/ADB_VORTEILER_B*200/1000000

  //Attention Signal
  TCCR0 = ADB_VORTEILER_A_BIT;    
  TCNT0 = 0; // Zähler auf null setzen  
  ADB_PDIR |= ADB_BIT; // Ausgang 0
  ADB_POUT &= ~ADB_BIT; 
  while (TCNT0 < ADB_IMPULS_ATT);

  TCCR0 = ADB_VORTEILER_B_BIT;    
  
  anzahl_out = 1; // Mindestens Befehl übertragen
  z_byte = 0;
  do{
    // START BIT (1)
    TCNT0 = 0;
    ADB_PDIR |= ADB_BIT; // Ausgang 0
    ADB_POUT &= ~ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ);
    ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
    ADB_POUT |= ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);

    for(;z_byte<anzahl_out;z_byte++){
      for(bitpos=128;bitpos;bitpos>>=1){  //Daten ausgeben
        TCNT0 = 0;
        ADB_PDIR |= ADB_BIT; // Ausgang 0
        ADB_POUT &= ~ADB_BIT; 
        if(adb_werte[z_byte]&bitpos) 
          while (TCNT0 < ADB_IMPULS_KURZ);
        else 
          while (TCNT0 < ADB_IMPULS_LANG);
        ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
        ADB_POUT |= ADB_BIT; 
        while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);
      }
    }
    // STOP BIT (0)
    TCNT0 = 0;
    ADB_PDIR |= ADB_BIT; // Ausgang 0
    ADB_POUT &= ~ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_LANG);
    ADB_PDIR &= ~ADB_BIT; // Eingang über Pullup
    ADB_POUT |= ADB_BIT; 
    while (TCNT0 < ADB_IMPULS_KURZ+ADB_IMPULS_LANG);

    // Entscheidung, ob noch weitere Daten übertragen werden
    if(adb_werte[0] == COM_LISTEN3)
      anzahl_out = 2+1;
    else if(adb_werte[0] == COM_LISTEN1)
      anzahl_out = 8+1;
    else
      z_byte = 8;
  }while(z_byte < 2);

  // Warten auf Rückgabewerte sonst Abbruch
  TCNT0 = 0;
  do{  
    if(TCNT0 > ADB_IMPULS_TLT){
      return(0);
    }
  }while(ADB_PIN & ADB_BIT);
  while(!(ADB_PIN & ADB_BIT)); // Start Bit

  z_byte = 1; 
  while(z_byte < MAX_ADB){
    adb_werte[z_byte] = 0;
    for(bitpos=128;bitpos;bitpos>>=1){  //Bits einlesen
      TCNT0 = 0;
      // Abbruch wenn keine weiteren Bytes übertragen werden.
      do{ 
        if(TCNT0 > ADB_IMPULS_KURZ+ADB_IMPULS_LANG){
          return(z_byte-1);
        }
      }while(ADB_PIN & ADB_BIT);
      TCNT0 = 0;
      while(!(ADB_PIN & ADB_BIT));
      if(TCNT0 < (ADB_IMPULS_KURZ+ADB_IMPULS_LANG)/2)
        adb_werte[z_byte] += bitpos;
    }
    z_byte++;
  }
  return(z_byte-1);
}



int main(void) {
  // Auf Absolutmodus umschalten
  adb_werte[0] = COM_LISTEN3;
  adb_werte[1] = BITS(0110,0011);
  adb_werte[2] = 4; //CDM Modus
  adb();
  
  adb_werte[0] = COM_TALK1;
  adb(); // Werte holen

  adb_werte[0] = COM_LISTEN1;
  adb_werte[7] = 0x00; //Absolutmodus
  adb();
  
  // Register 0 auslesen 
  adb_werte[0] = COM_TALK0;
  adb();
      
}

[Klaus R. (klaus2)]

Ich sags mal so: Kuul!

Klaus.

[Bingo (Gast)]

Hier einer version von die

//Bits Makro
#define BITS(H,L)  (0b##H ##L)


Und diser als comment
// Eingänge
ADB_PDIR &= ~ADB_BIT;

// Pull Up einschalten
ADB_POUT |= ADB_BIT

// Eingänge
// ADB_PDIR &= ~ADB_BIT;

// Pull Up einschalten
// ADB_POUT |= ADB_BIT

Dann gehts ohne fehler

mfg
Bingo Dänemark

[Michael W. (acidbourbon)]

Hi Leute, danke für die gute Vorarbeit,
damit meine ich natürlich die ganze Datenblatt-Recherche
sowie vor Allem die ausgezeichnete Arbeit von Franky.

Ich hab Frankys Code mal ein wenig modifiziert, so dass er auch auf 
ATMegas mit mehr als 7KommaEppes MHz läuft.

Im Anhang mal Quelldaten und Hex von einem niedlichen Demoprojekt was 
das TM1001A Touchpad für jeden AVR-Anfänger zu Plug-And-Play-Hardware 
machen sollte.

Liebe Grüße

Micha

@Franky: Ich hoffe du bist einverstanden, dass ich deinen Code benutzt 
habe

[Michael W. (acidbourbon)]

Btw: man muss sich keinen Stress machen die Litzen an den FPC-Connector 
zu löten, das ist viel zu fuddelig. Auf der Platine sind noch lauter 
Testpads über die man auch an die gewünschten Leitungen kommt. Siehe 
Foto im Anhang.

Gruß

Micha