Panasonic R191 mit Centronics Interface

Vor Jahren hatte ich das Protokoll des KX-R60 Interface in Verbindung einer KX-R194 Schreibmaschine

angeschaut ... nun habe mir mein eigenes KX-R60 Interface gebaut. Im Vergleich zum Original kann es

auch Daten über eine Serielle Schnittstelle verarbeiten.

Im original Interface gibt es vermutlich keinen Mikrocontroller, sondern einen

programmierten Logic-Baustein. Es gibt keinen Datenpuffer, das übernimmt die Schreibmaschine.

3 Signale (CS, Daten und Clock) führen vom Interface zur Schreibmaschine, ein Signal (Acknowledge) kommt

von der Schreibmaschine zum Interface.

Das Interface bekommt ca. 12V DC von der Schreibmaschine. Im KX-R60 Interface gibt es einen 5V Spannungsregler.

Hier mal ein Bild (Unterseite, aber gespiegelt) der Platine der KX-R191. Am linken Bildrand befindet sich die 8-polige Mini-Din-Buchse.

Zitat von detlef

Wow! Hast du das Protokoll irgendwo dokumentiert?

Ich melde hiermit auch mein Interesse an dem Protokoll an, danke.

Detlef, ich habe auch schon in deinem Youtube Video kommentiert: Wärst du bereit, mir deinen Adapter auszuleihen, damit ich mir das Protokoll anschauen kann?

Ich habe gerade meine Panasonic KX-R195 repariert und würde gerne mit dem PC drucken und, ähnlich wie Leguito, einen Adapter nachbauen.

Gruß.

Es gibt, wie ich weiter oben geschrieben hatte, 3 Signale die zur Panasonic gehen und 1 Signal von der SM zum Drucker-Intrface.

Ich habe die Signale CS, Data und Clock genannt, welche zur SM gehen und das was von der SM kommt ACK (Acknowledge). Die Signale zur SM hin, sind über einen 100-Ohm Widerstand direkt an den CPU Pins!

Das ACK Signal kommt (meine ich) direkt so aus der CPU!

Die 8 Datenbits werden sequenziell zur SM übertragen.

Im Ruhezustand ist

DATA LOW (im Screenshot weiss)

CS HIGH (rot)

CLOCK HIGH (orange)

Um die Aufmerksamkeit der Panasonic auf das Interface zu lenken, geht CS nach LOW.

Dann das Data-Signal entsprechend setzen (LSR - LOGICAL SHIFT RIGHT ... also LSB zuerst).

Dann Clock nach High, kurz warten und wieder auf low. Die Panasonic quittiert den Empfang mit einem

kurzen High-Pulse auf der Acknoledge Leitung (im Screenshot gelb).

Sind alle 8 Datenbits so übertragen, geht CS wieder auf HIGH-Level.

Soll in weiteres Zeichen übertragen werden, dann CS wieder auf LOW usw.

Die SM muss selbstverständlich 'On Line' sein.

Verbindung zur Schreibmaschine:

Diese 8-Poligen Mini-Din Stecker ... möchte man nicht unbedingt löten.

Zumal da auch noch 12V geführt werden und bei einem Kurzschluss die CPU der SM ...

Es gibt diese RS232-Terminal-Adapter für (ich glaube LANCOM ?) Router. Diese haben auf der einen Seite einen 8-Poligen Mini-Din Stecker und am anderen Kabelende eine 9-Pin-SUB-D Buchse.

Es gibt aber auch Adapterkabel, die eine andere Pinbelegung haben und nicht alle Pins des

Mini-Din Steckers belegt sind. Da kann man also an ein ungeeignetes Adapterkabel geraten.

P.S. Ich hätte mal Bock auf ein neues Projekt. AEG Olympia Carrera SI oder so. Interface nachbauen. Nur leider fehlt mir die Hardware. Vielleicht hat jemand eine Idee.

Alle Angaben ohne Gewähr.

Leguito You mention AEG Olimpia Carrera SI, I have an Olympia Compact S. A while ago, I'd made a unix style (stdin/stdout) printer 'driver' for this typewriter that would receive RTF files and print in the serial format with codes that made the output very close to the RTF file in as far as the capabilities of the typewriter.

You think the protocol would be similar for these two printers? I could dig it up and put it on github if so. (I think I have it on 1/4" backup tape!)

In trying to establish communication, I've created a cable, hooked it up to this Pro Micro for testing, and have the device printing characters. But, they are all garbled. Any idea what is wrong here? I show a pic. of my setup, the code, and some snapshots of the wire activity.

int ACK_IN =  SDA;  // pin 2
int CLK_OUT = SCL;  // pin 3
int CS_OUT =  A6;  // pin 4
int DAT_OUT = A7;  // pin 6


/*
* On Setup :
*  > CLK - set low
* Send byte:
*  > CS - set low
*  -- loop over 8 bits
*    > DAT - set value
*    > CLK - set high
*    < ACK - wait for high pulse
*    > CLK - set low
*  > CS - set high
*/
volatile byte state = LOW;


void setup() {
pinMode(CLK_OUT, OUTPUT);
pinMode(CS_OUT, OUTPUT);
pinMode(DAT_OUT, OUTPUT);
pinMode(ACK_IN, INPUT);


digitalWrite(CLK_OUT, LOW);


attachInterrupt(digitalPinToInterrupt(ACK_IN), valuechange, CHANGE);
}
void valuechange() {
state = HIGH;
}
 write_byte(char b) {
  int bits = 8;
  int ackbit = 0;
  int timeout = 0;
  //state = LOW; // Set flag
  while(digitalRead(ACK_IN) == LOW); // Wait until it is high
  digitalWrite(CS_OUT, LOW); 
  delay(1);
  //while(state == LOW); // wait for acknowledgement state change
  while(bits--) {      
    digitalWrite(DAT_OUT, ( b >> (7-bits) & 0x01 ) ? HIGH : LOW );
    delay(10);
    while(digitalRead(ACK_IN) == LOW); // Wait until it is high
    digitalWrite(CLK_OUT, HIGH);    
    while(digitalRead(ACK_IN) == HIGH); // Wait until it is LOW
    delay(5);
    digitalWrite(CLK_OUT, LOW); 
    while(digitalRead(ACK_IN) == LOW); // Wait until it is high
  }
  digitalWrite(CS_OUT, HIGH); 
  delay(10);
}

void loop() {
char phrase[] = "Hello World!   ";
for(int i=0; phrase[i] != 0x00; i++) {
write_byte(phrase[i]);
}
delay(1000);                       // wait for a second
}

This appears to be the closest I'd gotten it. As shown in the last line of text. I'd then tried with a start bit and a stop bit, but that was worse.
It is like there should be a parity bit or something.

void write_byte(char b) {
int bits = 8;
int ackbit = 0;
int timeout = 0;
//state = LOW; // Set flag
while(digitalRead(ACK_IN) == LOW); // Wait until it is high
digitalWrite(CS_OUT, LOW);
delay(1);
while(bits--) {
digitalWrite(DAT_OUT, ( b >> (8-bits) & 0x01 ) ? HIGH : LOW );
delay(10);
while(digitalRead(ACK_IN) == LOW); // Wait until it is high
digitalWrite(CLK_OUT, HIGH);
while(digitalRead(ACK_IN) == HIGH); // Wait until it is LOW
delay(5);
digitalWrite(CLK_OUT, LOW);
while(digitalRead(ACK_IN) == LOW); // Wait until it is high
}
digitalWrite(CS_OUT, HIGH);
delay(10);
}