Hilfe! Problem mit LPTLogger (STK500)

[_matze (Gast)]

Moin!

Ich bin's mal wieder mit einem kleinen bis mittleren Problem.

Folgende Situation:

Ich habe ein Gerät (Scanner), dass über den Parallel-Port gesteuert 
wird. Meine Aufgabe ist es, die Daten, die über den LPT-Port geschickt 
werden, im EEPROM eines Tiny2313 zu speichern. Zu diesem Zweck wird der 
Controller auf eine kleine Platine gesteckt, auf der natürlich auch der 
LPT-Port ist.

Ich habe mir das Programm folgendermaßen gedacht:

  iLptBytePB = PINB; 
  iLptBytePD = PIND; 
  // 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,'P'); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,'B'); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,':'); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,PINB); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,'P'); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,'D'); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,':'); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,PIND); 
  eeprom_write_byte((uint8_t*)iEEPROMCounter++,' '); 
  // 
  for(;;) { 
    if( iLptBytePB != PINB ) { 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'P'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'B'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,':'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,PINB); 
      iLptBytePB = PINB; 
    } 
    if( iLptBytePD != PIND ) { 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'P'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'D'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,':'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,PIND); 
      iLptBytePD = PIND; 
    } 
    if( iEEPROMCounter >= 120 ) { 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'E'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'N'); 
      eeprom_write_byte((uint8_t*)iEEPROMCounter++,'D'); 
      break; 
    } 

  }

Wenn sich an Port B bzw. D etwas ändert, wird das ganze Byte im EEPROM 
gespeichert. So logisch wie simpel. Die überflüssigen chars ("PB:", ...) 
sind natürlich nur zu Testzwecken implementiert. Außerdem wird vor 
Beginn der Schleife der Anfangszustand der Ports gespeichert.

Mein Problem ist, dass das Programm grundsätzlich funktioniert, jedoch 
muss ich den Controller ja erstmal im STK500 brennen, und da fängt das 
Programm bereits an zu laufen und beschreibt das EEPROM.
Beim ersten Mal ist das kein Problem, schließlich werden diese Bytes 
wieder überschrieben, sobald das Programm auf der Zielplatine läuft. Da 
ich das EEPROM jedoch nur über das STK500 wieder einlesen kann, und das 
Programm dort zwangsläufig startet, sobald Strom da ist, werden meine 
Daten natürlich wieder überschrieben.

Nun weiß ich nicht so recht, wie ich diesem Phänomen zu begegnen habe. 
Mein erster (und bislang einziger) Einfall war, irgendwie zu erkennen, 
wo der Controller sich befindet.

Hat jemand schonmal ein ähnliches Problem gehabt? Kann ich irgendwie 
erkennen, dass ich mich auf dem STK500 befinde?

Im Voraus schonmal vielen Dank für eure Mühe!

[Michael U. (Gast)]

Hallo,

das Gerät muß doch irgendein Hardware-Protokoll am LPT benutzen?

Du speicherst, wenn sich irgendwas am PortB oder PortD ändert?
Irgendwie muß das Gerät doch melden, daß an irgendwelchen Leitungen 
jetzt gültige Daten anliegen, die für Dich interessant zum speichern 
sind?

Ansonsten: Taster an irgendeinen freien Pin und das Programm erst per 
Tastendruck starten...

Gruß aus Berlin
Michael

[_matze (Gast)]

Mir fällt gerade eine Notlösung ein:

Man könnte einfach am Anfang des Programms ein delay von, sagen wir mal, 
20 Sekunden einbauen. Dann müsste ich nach dem Brennen direkt den Strom 
wegnehmen. Ebenso muss das Auslesen des EEPROM dann schnell gehen.

Ist natürlich keine schöne Lösung, ich wäre froh, wenn jemandem was 
besseres einfällt.

[_matze (Gast)]

Es geht weniger um Nutzdaten, sondern eher darum, zu sehen was alles 
über den LPT gejagt wird. Daher sollte schon jede Veränderung 
gespeichert werden, denke ich.

Die Idee mit dem Taster klingt grundsätzlich gut. Besser wäre es aber 
schon, wenn das Programm starten könnte, sobald Strom da ist. So kann 
ich auch den Anfangszustand festhalten. Falls dies in Kombination mit 
meinen Wünschen nicht möglich ist, ist ein Taster aber wahrscheinlich 
eine gute Lösung.

Trotzdem wäre es perfekt, wenn jemand eine Möglichkeit wüsste, das 
STK500 an irgendeinem Merkmal zu identifizieren. Jemand eine Idee?

[Michael U. (Gast)]

Hallo,

dann schau Dir die STK500-Schaltung an. Die Port-Pins sollten dort ja 
größtenteils unbeschaltet sein. Lege auf Deinem Logger solch ein Pin 
über 3,3k an GND und frage beim Start den L-Pegel ab. Wenn H da ist auf 
dem STK500, dann eben Elnlos-Loop.

Gruß aus Berlin
Michael

[_matze (Gast)]

Erstmal herzlichen Dank, Michael, dass du dir die Mühe machst, mir zu 
helfen.

Ich bin jedoch in der Elektrotechnik nicht sehr bewandert. Ich bin 
eigentlich eher der Programmierer. Ich kann dir die tollsten Programme 
schreiben, aber was diese hardware-mäßig bewirken, wie und wo Strom 
fließt, ist mir immer ein Rätsel gewesen.

Erst jetzt muss ich mich damit beschäftigen (und erkenne, dass meine 
Programmier-Fähigkeiten bei der AVR-Programmierung gar nicht soviel 
bringen, wie ich gehofft hatte ;-) ).

Kannst du mir das vielleicht nochmal für Blöde erklären? Wäre wirklich 
klasse! Was du mit L(ow) und H(igh) meinst, kann ich mir ja denken, aber 
insgesamt habe ich leider keine Ahnung, was du meinst...

Gruß Matze

[_matze (Gast)]

Tja, Michael hat leider nicht mehr geantwortet. Trotzdem hat mir sein 
Tipp sehr geholfen.

Anfangs habe ich nicht verstanden, was er meinte. Heute habe ich zum 
ersten Mal in meinen 26 Lebensjahren (!) mit einem Voltmeter gearbeitet, 
und irgendwie ist da der Groschen (bzw. 10-Cent-Stück) gefallen.

Jedenfalls habe ich mein Problem so gelöst, dass Pin 1 von Port D 
(eigentlich low) auf dem Testboard mit dem TXD-Pin (Transmitter für 
UART) verbunden ist. Somit ist der Pin high und ich habe ein eindeutiges 
Unterscheidungsmerkmal. Funktioniert perfekt!

Dankeschön Michael!

Gruß Matze

[Michael U. (Gast)]

Hallo,

freut mich, daß es Dir geholfen hat. :)
Manchmal ist es eben doch hilfreich, wenn man die Programm-Logik mit der 
physkalischen Logik in Form von Bauteilen und einem Voltmeter in 
Verbindung bringt. Zumindest bei Microcontrollern halte ich das für 
wichtig. Da ist die Verbindung (im Gegensatz zu einem PC) meist noch gut 
sichtbar, anfaßbar und meßbar. Etwas Schaltplan-lesen ist da auch oft 
hilfreich. Im PC hat man weniger Chancen, den Zustand eines zu lesenden 
Bits mit dem Voltmeter zu finden. ;)

Gruß aus Berlin
Michael