Robotrontechnik-Forum

Registrieren || Einloggen || Hilfe/FAQ || Suche || Mitglieder || Home || Statistik || Kalender || Admins

Willkommen Gast!

Robotrontechnik-Forum » Technische Diskussionen » Hilfe gesucht: Erika 3004 als Drucker an PC anschließen » Themenansicht

Autor

Thread - Seiten: -1-

000
11.10.2018, 09:54 Uhr
octank

Liebe Rototron-Fans,

dies ist mein erster Post in diesem Forum und daher würde ich mich gerne kurz vorstellen.

Seit Samstag bin ich stolzer Besitzer einer Sigma SM 8200i. Diese Schreibmaschine habe ich für 15 EUR über eBay gekauft, weil ich mir vorgenommen habe, diese als Drucker an meinem PC zu verwenden.
Vor dem Kauf habe ich umfassend recherchiert, ob diese Maschine eine Schnittstelle hat, da ich vorher schon versucht hatte, meine Brother AX-110 anzuschließen. Dies gelang mir allerdings nicht, da man dazu auf der Platine hätte herumlöten müssen.

Ich verfüge über langjährige Programmiererfahrung, allerdings eher auf Hochsprachenebene anstatt auf Assemblerebene. Und habe ich ein großes technisches Verständnis, allerdings auch hier wieder nicht bis auf Transistorebene herunter.
Daher habe ich mir einen Raspberry PI 3b+ gekauft, mit dem ich diese Schnittstelle zur Schreibmaschine realisieren wollte. Einerseits um meinen Horizont zu erweitern, andererseits um meinen Sohn auch für Technik und Programmierung zu begeistern.

Allerdings bin ich nun nach mehreren Tagen Probierens an einem Punkt angelangt, an dem ich um Rat fragen muss. Im Laufe der vielen Versuche bin ich nämlich auf dieses tolle Forum gestoßen, das unsagbar viele Informationen bereithält, die ich alle gelesen und versucht habe, in meine Versuche einfließen zu lassen.

Es ist unfassbar, was es hier alles gibt. Für die Brother konnte ich nur mit größter Mühe eine BA finden und hier gibt es Schaltpläne, Fotos von Platinen, Codelistings und noch viel mehr.

Um den Post nicht zu lang werden zu lassen, sehe ich von einer detaillierten Auflistung meiner Versuche ab. Stichwortartig war aber Folgendes dabei:

- RASPI: fertige RS232 Schnittstelle mit Python -> Baud-Rate beim RASPI nicht einheitlich, da von Prozessorlast abhängig
- RASPI: USBSER-Adapter direkt an die 3004-Schnittstelle -> es werden beliebige Buchstaben gedruckt
- RASPI: USBSER <-> Terminal mit Psion 5mxpro -> funktioniert
- Psion 5mxpro an 3004-Schnittstelle im TTL-Modus -> scheint besser zu funktionieren, Buchstaben sind etwas beständiger
- PC: USBSER RS232 an 3004-Schnittstelle -> es werden beliebige Buchstaben gedruckt oder Funktionen ausgeführt (Rückwärtsdruck)
- PC: USBSER RS485 an 3004 -> beliebige Zeichen
- PC: USBSER <-> Steckplatine mit Widerständen <-> 3004 -> beliebige Zeichen

Natürlich habe ich auch alle Permutationen der Einstellungsmöglichkeiten des USBSER-Adapters und des Ports durchgetestet. Und ich habe mit einem Multimeter die Ströme gemessen, um zu testen, ob die konsistent sind. Dann habe ich noch einen Aufbau auf der Steckplatine mit der RS232 und Spannungswandlern gebaut (der RASPI verträgt max. 3.3 V). Aber da habe ich mich bisher nicht getraut, die anzuschließen, da ich schon einen RASPI gegrillt habe.

Was mir jetzt noch aufgefallen ist: die Maschine scheint ein Zwischenmodell zu sein. Irgendwo habe ich etwas über die Gehäuse und die Baureihen gelesen. Und diese hat anscheinend schon das neuere, etwas rundere Gehäuse aber dort, wo das Display wäre, ist eine Kunststoffplatte aufgeklebt. Also quasi das neue Modell, aber ohne Display.
Könnten die Probleme etwas damit zu tun haben, dass in der Maschine schon eine andere Technik steckt und die Doku zur 3004 dafür nicht passt. Lt. Handbuch kann sie nämlich auch 12 statt 10 Zeichen/Sek. und hat einen 20-Zeichen-Speicher.

Ich wäre sehr glücklich, wenn mir jemand Tipps oder Hinweise geben könnte, was ich noch machen muss. Ansonsten muss ich wohl Micha fragen, ob er mir auch so ein hervorragendes Interface baut und verkauft.

Viele Grüße
Oliver

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

001
11.10.2018, 10:12 Uhr
ralle

Normalerweise wird ein IF3000 oder IF6000 als Pegelwandler und Übersetzer benötigt.

Bei einigen Computern wurde die S3004 hart angeschlossen, einerseits wegen der Tastatur, manche Serien-Tastaturen waren eine echte Zumutung, aber auch wegen der ESC-Steuerung. Die IF unterdrücken das wirkungsvoll.

Denk bitte daran, das die CPU der S3004 keinen Schutz vor den Dummheiten der User hat.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

002
11.10.2018, 11:21 Uhr
octank

Hallo Ralle,

ja, das weiß ich, deshalb habe ich die Verbindung auch nur über eine RS232 Schnittstelle hergestellt und nicht direkt über die GPIOs, da ich mich das nicht getraut habe.
Obwohl es ja unzählige Dokumente zum Anschluß gibt, aber die beziehen sich alle auf die alten DDR-Computer. Der RASPI ist zwar auch ein Einplatinengerät, allerdings mit einer modernen CPU ausgestattet. Ich vermute, dass die Bytes nicht korrekt an der Schnittstelle ankommen (trotz CTS/RTS). Vielleicht gilt auch die Code-Tabelle von Michi für meine Schreibmaschine nicht mehr, weil es die Version mit Display-Vorbereitung ist.
Ich hatte die Hoffnung, dass es hier schon mal irgendjemand geschafft hat. Der RASPI sollte dann eigentlich nur die Aufgabe der Interface-Box übernehmen (Übersetzung des Zeichensatzes und ggfs. Pegelwandlung).
Anscheinend ist es doch nicht so einfach, wie ich gehofft hatte.
Gruß
Oliver

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

003
11.10.2018, 11:24 Uhr
wpwsaw
Default Group and Edit

Hallo,

die IF Box wandelt nicht nur die Pegel (3004 hat TTL-Pegel) sondern kodiert auch die Daten um. Die 3004 versteht keinen ASCII-Code.

Gruß
wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

004
11.10.2018, 11:27 Uhr
volkerp
Default Group and Edit

Micha hatte vor 4 Jahren eine eigene Interface-Box Erika-IF2014 gebaut:

in http://www.robotrontechnik.de/html/forum/thwb/showtopic.php?threadid=10266
im Post 092 ist der Link zu den Unterlagen (Schaltplan, Software, Handbuch) zum Nachbau
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)

Dieser Beitrag wurde am 11.10.2018 um 11:53 Uhr von volkerp editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

005
11.10.2018, 11:41 Uhr
octank

Danke für die bisherigen Antworten.

@wpw: genau, das mit den TTL-Pegeln habe ich schon herausgefunden. Daher der RS485-Versuch. An meinem USBSER-Adapter kann man das umstellen. Und Python hat dafür auch eine extra Klasse, um die RTS/CTS Pegel vor dem Senden zu prüfen.
Und dass sie kein ASCII versteht, habe ich aus Michas Dokumentation entnommen. Daher sende ich z.B. b'0x24' bzw. b'00100001' für das K.

@VolkerP: ja, wahrscheinlich muss ich, wie im Eingangspost schon geschrieben, ihn bitten, mir auch so etwas zu bauen und zu verkaufen ;-) Seine umfangreiche und hervorragende Dokumentation habe ich heruntergeladen und sie ist quasi die Basis für meine bisherigen Versuche. So etwas selber nachbauen kann ich nicht, da ich nicht einmal wüsste, wie man das EPROM programmiert.

Grüße
Oliver

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

006
11.10.2018, 11:55 Uhr
wpwsaw
Default Group and Edit

nein, du verstehst das nicht richtig, es gibt eine Umwandlungstabelle speziel ASCII>s3004 und s3004>ASCII vor allem die Steuerzeichen die notwendig sind um die Schreibmaschine in die verschiedenen Modis zu bringen, können und müssen nicht nur von der Tastatur sondern auch vom Port kommen. Z.B. enthält dieses alles der Druckertreiber vom KC85/x speziell für die S3004.

in den erwähnten IF-Boxen, die ja eine CPU mit Software enthalten, wird dieses umwandeln durchgeführt und nicht nur TTL<>V24.

wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

007
11.10.2018, 12:24 Uhr
octank

Okay.

Ich dachte, genau das wäre der Appendix F von Micha.

D.h., wenn ich über die TTL-Schnittstelle z.B. b'0x79' sende, macht sie einen Tab-Sprung, oder bei b'0x85' setzt sie den Zeilenabstand auf 1.5.

Ich hatte mir das so vorgestellt: das Python-Programm kann ein rtf parsen und holt sich über eine Array den 3004-Code für die druckbaren Zeichen (0x01 bis 0x67 und 0x71 für Space), da die 3004 kein reines ASCII versteht.

Alle zusätzlichen Steuercodes, wie z.B. CR und/oder LF oder Zeichen rückwärts, sendet das Programm mit den Codes aus der Tabelle (ab 0x72) auch an die 3004.

Irgendwo habe ich sogar eine noch umfangreichere Liste an Steuercodes gefunden, mit denen man Rückwärtsdruck etc. umschalten kann.

Aber von Windows ist es dann nicht so einfach? Ich kann leider mit den Hex-Listings der Druckertreiber für die KCxx nicht viel anfangen. Gibt es da irgendeine Code-Sequenz, mit der man die Maschine quasi in einen Bereitschaftsmodus oder so etwas schalten muss? Vielleicht liest sie die Bytes ja doch richtig, kann nur nichts damit anfangen, da sie nicht weiß, dass die über den Port kommen oder wer sie sendet? Vielleicht erwartet sie auch eine Initialisierung um zu wissen, welche Codetabelle genutzt werden soll.

Ich hatte auch versucht, die 8x8 Matrix Bytes zu senden (b'01011011' z.B. für Normaldruck, Spalte 3, Zeile 3), aber das macht keinen Unterschied.

Was ich wohl ungewollt hinbekommen hatte, war, dass nach einigen Versuchen die Tastatur dann auch andere Zeichen als die Abgedruckten ausgegeben hat. Also, wenn man C gedrückt hat, hat sie ein F gedruckt.
Vielleicht hat dieses Modell mehrere Codetabellen gespeichert oder wie wäre dieses Verhalten sonst zu erklären?

VG Oliver

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

008
11.10.2018, 12:55 Uhr
volkerp
Default Group and Edit

Da ganz klingt bei Dir noch nach Problemen mit der seriellen Schnittstelle beim RASPI?
Wenn ich Dich richtig verstehe, funktioniert das unter Windows mit einem USB-TTL-Seriell-Adapter, der direkt an die S3004 angeschlossen ist?
Dann kannst Du doch unter Windows und mit Python experimentieren und einen Druckertreiber /Zeichenkonverter bauen. Wenn dort alles läuft, kannst du es auf einen RASPI umsetzen und die Schnittstellenprobleme lösen.

Auf meiner Seite gibt es die Steuercodes:
https://hc-ddr.hucki.net/wiki/doku.php/z9001/erweiterungen/s3004

Die interne Software der Schreibmaschine ist leider nicht bekannt; inwiefern sich die diversen Modelle in solchen Details unterscheiden, leider auch nicht. Alles Bekannte zu den Modellen gibts auf
erika-elektronik.de
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)

Dieser Beitrag wurde am 11.10.2018 um 12:57 Uhr von volkerp editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

009
11.10.2018, 13:40 Uhr
octank

Hallo Volker,

vielen Dank für Deine tolle Webseite. Den genannten Artikel habe ich als PDF auf dem Rechner und ist neben den Unterlagen von Micha mein zweites Kompedium. Deine Liste meinte ich weiter oben mit der ausführlicheren Liste der Steuercodes. Daher habe ich auch die Matrix-Informationen. Und auch die Ideen, den PC direkt zu koppeln, da Du das ganz unten auf der Seite auch so beschreibst.

Gestern habe ich gute zwei Stunden Zeit damit verbracht, auf Deiner Seite zu schmökern. Nicht nur wegen dieses Themas sondern generell sind dort viele interessante Dinge zu lesen.

Zum Thema: Mit Windows funktioniert es auch nicht korrekt. Nachdem ich von der unzureichenden RASPI Schnittstelle gelesen hatte, bin ich direkt auf Windows umgestiegen. Aber auch hier werden die Zeichen beliebig gedruckt. Wenn ich vier mal mit Pausen das gleiche Zeichen sende, druckt sie entweder immer das Pfund-Zeichen oder auch mal zwischen 3 und 4 verschiedene Zeichen. Manchmal auch noch mit Zeilensprüngen nach oben oder unten. Vollkommen willkürlich.

Daher habe ich inzwischen die Vermutung, dass man die Verbindung irgendwie initialisieren muss. So etwas wie hier:
96H Drucker Fertigmeldung Fertigmeldung Drucker: RTS wird erst wieder, wenn das Zeichen gedruckt ist

Vielleicht ist die RTS/CTS Logik nicht korrekt aktiviert oder die default Baud-Rate ist nicht 1200, obwohl ich diverse andere ausprobiert habe.

Mich würde brennend interessieren, was die Druckertreiber für die alten KCxx denn so tun. Oder die 3004.com, die es anscheinend für MS-DOS gibt. Leider kann ich den Code nicht entschlüsseln.

VG Oliver

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

010
11.10.2018, 14:31 Uhr
volkerp
Default Group and Edit

Die Druckertreiber für die DDR-Kleincomputer wie den Z1013 machen nichts besonderes, sondern wie auf meiner Webseite beschrieben warten auf RTS, dann 1 Byte ausgeben mit 8N1.

Die S3004 ist zum Empfang des nächsten Zeichens erst bereit, wenn das aktuelle komplett verarbeitet wurde.

Mit modernen seriellen Schnittstellen und besonders am PC gibt es da ein Problem: Die serielle Schnittstelle muss einen Empfangspuffer von mind. 4 (16?) Zeichen haben. Windows sendet noch munter weiter, auch wenn die Gegenstelle die Empfangsbereitschaft aufgehoben hat!
Leg mal in Deinem Python-Programm testhalber nach jedem gesendeten Zeichen eine Wartezeit ein (0.5 .. 1 Sekunde). Dann sollte die Schreibmaschine wieder bereit zum Empfangen sein.

Andernfalls liest die Schreibmaschine nur die restlichen Bits, die nach RTS noch gesendet werden, und interpretiert diese entsprechend falsch.
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)

Dieser Beitrag wurde am 11.10.2018 um 14:33 Uhr von volkerp editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

011
11.10.2018, 14:32 Uhr
Enrico
Default Group and Edit

Ist die Frage, ob die Schreibmaschine richtig tut.
Du hast nur Unbekannte, und kannst auch die Schreibmaschine nicht als
funktionierend ansehen.

Versuchs mit HTERM, und schick die Codes damit per Hand rüber.
Dort kann man auch direkt Hex eingeben.

Die 3004. com wird doch eher für CPM als DOS als für DOS sein?
--
MFG
Enrico

Dieser Beitrag wurde am 11.10.2018 um 14:32 Uhr von Enrico editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

012
11.10.2018, 17:37 Uhr
Mobby5

@octank

Wenn Du schon RS232 oder RS485 an die S3004 angeschlossen hast, hast Du bestimmt schon den Anschluss an der S3004 zerschossen.
--
und ausserdem muss in Zeile 20 der Doppelpunkt durch ein Semikolon ersetzt werden

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

013
11.10.2018, 19:30 Uhr
ralle

Also, bei der Harten Kopplung wurde ein größerer Treiber geschrieben, der nicht nur als Übersetzer funkierte, sondern es war auch die Übermittlung von Steuer-Codes möglich. Beim KC85/4 und TypeStar war das mit einer modifizierten M003 aka M054 möglich.

Die .COM ist für CPM als nur Druckertreiber gedacht, in der Regel mit einer der beiden IF.

Die Software sowohl für die Schreibmaschine selber als auch für die beiden IF ist für dem Z8, 8830 in der IF und 8840 in der Schreibmaschine. Die Treiber allerdings für die Z80 PIO und SIO.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

014
12.10.2018, 06:55 Uhr
ralle

Ich meinte, das ich eine Anleitung zum Anschluss am Window-PC mit einer IF als nur Text-Drucker gesehen zu haben.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

015
12.10.2018, 08:10 Uhr
wpwsaw
Default Group and Edit

Gibt es doch mit der originalbeschreibung "Informationen zur Interfacebox für elektronische Kleinschreibmaschinen IF3000 (Centronix und Commodore) und IF6000 (V24). Die IF6000 kannst du in der Grundinitialisierung mit 9600,n,8,1 an einen PC mit ASCII-Drucker an die V24 anschließen. Die PC V24 muss nur auf Hardwareprotokoll umgestellt werden, weil sie meines Wissens nach WIN Start auf Xon/off steht.

Gruß
wpw

P.S. wenn die S3004 mit der Box verbunden und in Betrieb ist, kannst du die Einstellungen der IF-Box über die Schreibmaschine anzeigen und ändern.
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Dieser Beitrag wurde am 12.10.2018 um 08:12 Uhr von wpwsaw editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

016
14.10.2018, 13:35 Uhr
octank

So, ein kleines Update meiner Versuche, die S3004 ohne Interface-Box an einen modernen PC anzuschließen.
Der Datentransfer klappt ja schon seit einiger Zeit. Der Empfang von Zeichen in HTERM klappt gut. Und auch in Python ist das problemlos.
Das Problem ist das Senden von Zeichen. Da kommen bei der S3004 willkürlich irgendwelche Zeichen.

Aber heute habe ich einen kleinen Durchbruch erzielt. Die Pegelwandlung hat mir keine Ruhe gelassen und ich vermutete, der USBSER-Adapter ist schlecht implementiert.
Daher habe ich eine RS232-Platine, die ich für den RASPI gekauft hatte, dazwischengeschaltet. Also S3004 -> RS232-Platine -> USBSER-Adapter.
Und siehe da: nun kann ich zuverlässig über HTERM Zeichen (gem. der Codetabelle in Michas Handbuch) an die S3004 senden. Konnte sogar meinen Namen fehlerfrei schreiben. YEAH!

Aber wenn ich in der DOS-Box Zeichen an den COM-Port sende, kommt weiterhin Schmu raus, genau der gleiche Mist, wenn ich das über Python versuche.
Daher vermute ich, dass die Python-Serial-Implementierung das Selbe tut, wie die DOS-Box. Aber: bei Python gibt es ein kleines Test-Minicom-Skript. Das erzeugt quasi eine kleine Terminal-App. Und damit funktioniert das korrekte Senden an die Schreibmaschine.

Nun werde ich das Skript analysieren und schauen, wie dort die Senderoutine implementiert ist und versuchen, das nachzubauen. Ich vermute, es hat einfach etwas mit der Bitsequenz, die an den COM-Port gesendet wird, zu tun.

Falls es danach funktioniert, melde ich mich wieder. Vielleicht interessiert sich ja noch jemand dafür.

Dieser Beitrag wurde am 14.10.2018 um 13:37 Uhr von octank editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

017
14.10.2018, 15:05 Uhr
octank

So, jetzt kann ich auch mit Python über den PC drucken.
Nun muss ich noch eine Code-Ersetzungstabelle bauen, die die Zeichen umwandelt und dann noch ein paar Features wie Fettdruck, Unterstrichen codieren.

Skripte, um ein RTF einzulesen habe ich schon und auch ein Optimierskript, dass den Text in Vorwärts- und Rückwärtsdruck optimal ausdruckt, habe ich schon vorbereitet.

Das ganze wird es zwar wohl nicht als Druckertreiber geben, außer ich komme dahinter, wie ich den seriellen Port als Drucker in Windows einrichten kann. Aber das wäre mich auch nicht so wichtig. Ich kann einen Text als Text oder RTF ausdrucken und das Skript liest die Datei ein und sendet sie an den Drucker. Völlig ausreichend.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

018
14.10.2018, 15:59 Uhr
volkerp
Default Group and Edit

Gratulation!
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

019
14.10.2018, 16:42 Uhr
ralle

andere Frage, Linux oder Windows?
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

020
14.10.2018, 20:13 Uhr
ambrosius

Das dürfte bei Python nicht so die Rolle spielen.
--
viele Grüße
Holger

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

021
14.10.2018, 21:05 Uhr
octank

Zitat:

ralle schrieb
andere Frage, Linux oder Windows?

Win10.
Wollte es ja eigentlich unter Linux auf dem RasPi machen, aber bisher habe ich mich nicht getraut, die Schnittstelle dort anzuschließen, weil ich schon einen RasPi mit 5V gegrillt habe.

Dieser Beitrag wurde am 14.10.2018 um 21:06 Uhr von octank editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

022
14.10.2018, 21:50 Uhr
octank

Der nächste Schritt wurde erreicht:
ich kann beliebige Texte in Vorwärts- und Rückwärtsrichtung ausdrucken.

Dies wäre ein Debug-Output:
--> 35|00[00]: →Willkommen im Robotron-Technikforum↓
<-- 16|35[35]: ↓Ich freue mich, ←
--> 41|16[00]: →mich hier mit Gleichgesinnten austauschen ↓
<-- 49|41[41]: ↓zu können und wertvolle Hinweise zu den Produkten←
--> 24|49[00]: →von Robotron zu erhalten.↓
--> 00|24[24]: →▼ LF
→Willkommen im Robotron-Technikforum↓
↓← ,hcim euerf hcI
→mich hier mit Gleichgesinnten austauschen ↓
↓←netkudorP ned uz esiewniH ellovtrew dnu nennök uz
→von Robotron zu erhalten.↓
→▼

Jetzt müsste ich noch die Vorwärtsschaltung optimieren, indem ich z.B. mehrere Leerzeichen durch einen Wagenvorlauf ersetze, was sicherlich Zeit spart.
Und ich muss doch mal meinen Lötkolben rausholen, ähm, also aus dem Keller holen, und an die CTS und RTS-Anschlüsse zwei Kabel löten. Leider sind die auf der RS232-Platine nicht mit Steckern versehen. Dann kann ich vielleicht den Hardware-Handshake aktivieren und die Druckzeit verbessert sich. Derzeit bekommt jedes Zeichen 0.5 Sek. Zeit, was das Ganze recht behäbig macht.
Falls der Hardware-Handshake nicht geht, kann ich noch versuchen, CTS manuell abzugreifen und erst das nächste Zeichen zu senden, wenn die wieder Luft hat.

Fettdruck geht sogar auch, ist ja nur: \xA9\xA5\x01

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

023
15.10.2018, 08:57 Uhr
ralle

Die Erika ist von Natur aus nicht die Schnellste.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

024
18.10.2018, 00:22 Uhr
octank

So, jetzt ist es vollbracht. Die Schreibmaschine funktioniert, bis auf ein paar offene Kleinigkeiten (Implementierung von PICA und LINE) wunderbar.
Aber es war schwierig. CTS/RTS Hardware Handshake funktioniert nicht ganz so optimal, obwohl ein Signal ankommt. Also habe ich mir die Mühe gemacht, und alle Buchstaben des Typenrades abgetippt, um die Reihenfolge zu ermitteln.
Damit errechne ich den kürzesten Weg von einem zum nächsten Buchstaben (in der Hoffnung, Erika kann vorwärts und rückwärts drehen). Und diese Anzahl multipliziere ich mit ein paar Millisekungen, um die Radbewegung zu errechnen. Dazu gibt es etwas Zeit für den Datentransfer und das Drucken selbst. Und bei CRLF haue ich noch mehr drauf.
Beim Druck von wiederholenden Zeichen gibts dafür weniger.
Und vor dem Absenden des Zeichens prüfe ich CTS. Und in dieser Kombination rattert die Gute los wie ein Maschinengewehr (naja, fast, an eine Gatling kommt sie natürlich nicht heran).

Der Rückwärtsdruck funktioniert auch blendend, bis auf den Fall, wo ich die Spaces durch Wagenvorschub ersetze. Hier muss ich noch mal ran, dass der Wagenvorschub ein Wagenrücksschub wird, da dies augenscheinlich absolut gilt und nicht abhängig von der Druckrichtung.

Und da ich es leid war, immer im Code irgendwelche Testcases einzutragen, habe ich ein kleines Frontend gebaut, damit ich schneller einen Output erzeugen kann, indem ich Text- oder RTF-Dateien einlese, die in das nötige Format konvertiert werden. Sieht ziemlich mäßig aus, ich weiß, aber ich habe vor 7 Tagen meine erste Zeile Code in Python geschrieben, also kenne ich noch nicht alle Tricks und Kniffe.

Der Dialog zeigt auch den Output in ASCII und RAW an, so spart man zum Testen viel Farbband, wenn man erst mal schaut, ob es auch so ist, wie man es erwartet.

Ich bleibe aktiver Leser in diesem tollen Forum und danke allen, die Hinweise und Kommentare hinterlassen haben.

VG Oliver

Dieser Beitrag wurde am 18.10.2018 um 00:25 Uhr von octank editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

025
18.10.2018, 11:59 Uhr
volkerp
Default Group and Edit

Und nochmal Gratulation zum Ergebnis und zur Ausdauer!
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

026
18.10.2018, 14:51 Uhr
jde

Avatar von jde

Hatte mal von einer S6005 die ROMs reassembliert und diese dann mit einer V.24 Schnittstelle mit SIO und Druckwegoptimierung für bidirektionalen Druck versehen.
Dort wurde je nach Druckfläche des Zeichen auf dem Typenrad die Andruckzeit des Magneten auch noch modifiziert.
Das ist in der 3004 bestimmt auch so und beeinflusst die Zeit die jedes Zeichen zum Druck braucht.

wen es interessiert: www.2jo.de/robotron/Erika/ev24n.mac

Gruß
Jonny

Dieser Beitrag wurde am 18.10.2018 um 14:54 Uhr von jde editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

027
18.10.2018, 16:41 Uhr
holm

Avatar von holm

Cool Jonny!!
Habs mir aufgehoben.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

028
18.10.2018, 18:51 Uhr
ralle

Ich habe mal nach den Phyton geschaut, ganz umsonst ist die nicht...
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

029
18.10.2018, 21:37 Uhr
octank

Zitat:

ralle schrieb
Ich habe mal nach den Phyton geschaut, ganz umsonst ist die nicht...

Hi Ralle,

doch, Python ist über python.org kostenlos zu beziehen. Und als kostenlose Entwicklungsumgebung kann man PyCharm nehmen. Das funktioniert super. Oder man kann auch Plugins für Eclipse finden.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

030
18.10.2018, 22:42 Uhr
jde

Avatar von jde

Die Interfaces IF3000 (Centronics/Commodore) und IF6000 (V.24) die es zur S3004 gab waren mit einem U881 bestückt.
Es wurde ein Software SIO im U881 benutzt. Reassemblierte Software vom IF3000 enthielt diese Routine. Mit sehr schöner Codegrößenoptimierung.

Quellcode:


print:  call    o+serout
        jr      nc,print
        ret
;
;
; Software SIO zur Schreibmaschine
;
serout: tm      p3,#8           ; CTS von Schreibmaschine
        rcf
        jr      nz,serou7       ; nicht bereit
        ld      r9,#8           ; Anzahl Bits
        call    o+serou4        ; Startbit senden
serou1: ld      r10,#.h(serou2+o) ; RET-Adresse
        ld      r11,#.l(serou2+o)
        push    r11
        push    r10
        rr      r8              ; Byte schieben
        jr      nc,serou4       ; 0-Bit
        jr      serou3          ; 1-Bit
;
serou2: dec     r9
        jr      nz,serou1
        call    o+serou3        ; Stop-Bit senden
serou3: or      p3,#10h         ; 1-Bit senden
        jr      serou5
;
serou4: and     p3,#0efh        ; 0-Bit senden
        jr      serou5
;
serou5: ld      r10,#0a0h       ; Warteschleife
serou6: dec     r10
        jr      nz,serou6
        scf
serou7: ret
;

kompletter von mir reassemblierter Code vom IF3000 Interface hier: http://www.2jo.de/robotron/Erika/if3000.asm
Das Faltblatt dazu (bitte doppelseitig ausdrucken und als A5 heften): http://www.2jo.de/robotron/Erika/if3000.pdf

Gruß
Jonny

Dieser Beitrag wurde am 18.10.2018 um 22:57 Uhr von jde editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

031
19.10.2018, 00:21 Uhr
octank

Und zum Abschied ins Bett noch ein kleines Goodie von mir.
Habe eine zweite Version des Druckprogramms geschrieben. Mit der Änderung, dass man nicht komplette Texte läd und druckt, sondern dass man quasi im bidirektionalen Direkt-Modus an der Schreibmaschine schreibt.
Aber eben mit zeilenweise Korrekturmöglichkeit.

Dieser Beitrag wurde am 19.10.2018 um 00:22 Uhr von octank editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

032
19.10.2018, 13:11 Uhr
octank

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

033
19.10.2018, 17:41 Uhr
octank

Jonny,
vielen Dank für das komplette ASM-Programm. Hier sind alle Codes enthalten und nun werde ich mir auch noch mal die Grafikdruck-Fähigkeiten ansehen. Obwohl ich denke, für eine kleine Grafik den Punkt auf dem Typenrad plattzuhämmern macht nicht viel Sinn.
Aber mal sehen...

Zitat:

jde schrieb
Die Interfaces IF3000 (Centronics/Commodore) und IF6000 (V.24) die es zur S3004 gab waren mit einem U881 bestückt.
Es wurde ein Software SIO im U881 benutzt. Reassemblierte Software vom IF3000 enthielt diese Routine. Mit sehr schöner Codegrößenoptimierung.

Gruß
Jonny

Dieser Beitrag wurde am 19.10.2018 um 19:45 Uhr von octank editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

034
26.10.2018, 15:46 Uhr
octank

So, hier noch ein paar Fotos von meiner Schnittstelle IF2018. Leider optisch bei Weitem nicht so ansprechend wie die Platine von Micha.
Aber funktional und in dem Apple-Gehäuse recht schick und zumindest geschützt.

Jetzt funktioniert auch die bidirektionale Datenübergabe. D.h. ich kann auch mit der Schreibmaschine in der PC-App schreiben und erst am Ende der Zeile drucken.
Dazu musste ich aber den DTR-Kanal vom PC mit DTD der Schreibmaschine verbinden. Sonst hat die Übertragung von der Schreibmaschine an den PC nicht funktioniert. Und außerdem musste ich ein Kabel an den nicht ausgeführten CTS-Pin löten, damit ich das mit dem RS232-Stecker verbinden konnte. Erst dann hat alles funktioniert.

Inzwischen ist auch die App fast eine kleine Textverarbeitung geworden. Man kann Dateien laden, bearbeiten, speichern und auch alle Befehle über die Schreibmaschine eintippen. Dazu habe ich ein virtuelles Display eingebaut. Ich habe für den Raspi noch ein kleines LCD-Display, das wollte ich mal an den GPIO anschließen und darüber dann Infos für die Schreibmaschine ausgeben. Das könnte man dann zum Schluß auch in der Schreibmaschine einbauen.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

035
03.12.2018, 11:29 Uhr
octank

Hi zusammen,

hier mal ein Video mit der Maschine in Aktion.

Link zum Video

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

036
03.12.2018, 17:06 Uhr
ralle

Geil, wieder Buchstabenbilder, wie zu wilden DOS-Zeiten auf PaketRadio.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

037
02.10.2024, 19:28 Uhr
bosch

Moin zusammen.

Ich habe die ERIKA (Sigma SM8200i) mit einem Arduino NANO verbunden, auf den ich zuvor den Sketch erika.ino geladen hatte. Das Ergebnis stimmt mich zuversichtlich.
DAs Problem ist nur, dass manche Zeichen nicht übertragen werden. So kann ich eine Reihe aller Großbuchstaben, oder eine reihe Kleinbuchstaben, oder eine Zahlenreihe vom PC aus an die Maschine schicken - und es kommen fast alle an. 'Fast' abcdefgh jklm.....
Ein oder zwei, oder auch schon mal mehr Zahlen fehlen im Ausdruck. 12 567890

Umgekehrt ist es so, dass auch nicht alle Zeichen auf dem PC ankommen. Es sind aber nicht unbedingt die gleichen Zeichen. Und ... wenn ich nicht alle Buchstaben - oder Zahlen - nacheinander vom PC aus rübersende, sondern nur in 2er-Gruppen - dann klappt es. Also die Übersetzung ddr2ascii klappt bidirektional. An sich fehlen auch immer die gleichen Zeichen. 1, 2, A, B, ... fehlt nie.
Ich würde jetzt tippen, dass es was mit der Baud-Rate zu tun hat. Serieller Ausgang PC = 9600; auf erika = 1200 (ist im Programm so voreingestellt)

Warum mir das so wichtig ist ? Zum einen soll es ja auch klappen - einfach so. Aber ich möchte in nächster Zeit meine KW-Station, mit (altem) RTTY-Konverter (YAESU YR-901) über die ERIKA betreiben. Also Senden und Empfangen. Da dürfen dann keine Zeichen fehlen.
Das ich mit verschiedenen Signal-Leveln arbeite - weiß ich. Dazwischen kommt ein TTY-RS232-Adapter (mit MAX323). Das die ERIKA kein ASCII kann - weiß ich. Dafür gibt es ja die beiden Übersetzungs-Header (ascii2ddr und ddr2ascii).

Aber wo liegt also das Problem im Moment ? Baudrate, Zeichensatz, ... ??

Hat jemand einen Hinweis für mich.

Gruß
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

038
02.10.2024, 19:44 Uhr
ralle

Das Protokoll. Probiere mal die Baudrate zu reduzieren. Dann gibt es noch 8Bit und 7Bit sowie 1 oder 2 Stopbit.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

039
02.10.2024, 19:57 Uhr
schlaub_01

Hallo Bodo,
gibt es da auf der PC Seite ein Hardware-Handshake? Ansonsten überrennt ja der PC vermutlich den Zeichenpuffer auf dem Arduino, wenn es den überhaupt gibt. Bisher hatte ich da nur sehr einfache Routinen gesehen. Solche extremen Baudratenunterschiede sind immer kritisch, wenn der PC kontinuierlich die Daten senden kann (trifft meistens bei richtigen RS232 Schnittstellen zu, im Gegensatz zu den USB Adaptern).
Zunächst kann man das aber mit langsameren Baudraten am PC testen. So was geht z.B. gut mit dem H-Term. Da kannst Du eine genaue Anzahl an Zeichen mit optionalen Pausen auch angeben, was für den Test eigentlich ideal wäre.
Ansonsten zeig mal den Code, vielleicht kann man da auch noch etwas verbessern.

Viele Grüße,
Sven.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

040
03.10.2024, 08:17 Uhr
wpwsaw
Default Group and Edit

....moin,

schau mal hier, das wurde schon einmal erfunden......

https://www.robotrontechnik.de/html/forum/thwb/showtopic.php?threadid=10266
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

041
03.10.2024, 09:51 Uhr
bosch

Ganz großen Dank an Euch, die Ihr geantwortet habt !

Ich werde alle dem nachgehen (hab schon mal eine wesentlich kleinere Baudrate am ARDUINO eingestellt - da kamen nur noch Hieroglyphen als Ergebnis). Und ich werde den Hinweis zum Thread 10266 von wpwsaw mal genau durchforsten.
Und ich werde auf jeden Fall hier posten, was draus geworden ist.
Das mit dem Überrennen hatte ich ja auch gedacht. Aber von der Ausgabe sämtlicher Buchstaben nacheinander fehlen ja nur die Buchstaben D E F G H. Alles davor und danach ist ja vorhanden. Und von der Zahlenreihe 1-0 fehlen nur 3 und 4. Anfang und Ende ist ja da. Nur einzeln, oder paarweise übergeben, klappt auch immer fehlerfrei. Ich schau mir alle Hinweise an und gebe Bescheid.
Jetzt werde ich ins Ruhrgebiet fahren und den RTTY-Konverter in Essen abholen. Damit bin ich heute beschäftigt, werde mich also erst die kommenden Tage wieder melden.

Danke für die Hinweise !!
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

042
03.10.2024, 09:59 Uhr
felge1966
Default Group and Edit

Kannst du eventuell auch deine "erika.ino" mal zeigen?
Nur mal so aus Interesse.

Gruß Jörg
--
http://felgentreu.spdns.org/bilder/jacob120.gif

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

043
03.10.2024, 19:10 Uhr
bosch

Klar, Jörg, natürlich.
Gruß
Bodo

#include <SoftwareSerial.h>
#include "ddr2ascii.h"
#include "ascii2ddr.h"

#define PC_BAUD 9600

#define RTS_PIN 3
#define ERIKA_RX 10
#define ERIKA_TX 11
#define ERIKA_BAUD 1200

SoftwareSerial erika(ERIKA_RX, ERIKA_TX); // RX, TX
bool wait = false;

void setup()
{
pinMode(RTS_PIN, INPUT);
Serial.begin(PC_BAUD);
erika.begin(ERIKA_BAUD);
}

void loop()
{ // run over and over
int rtsState = digitalRead(RTS_PIN);

//continue on falling edge
if (rtsState == LOW && wait == false)
{
// Datenuebertragung vom PC in den seriellen Puffer ?
if (Serial.available())
{
int result = ascii2ddr[Serial.read()]; // konvertiere zu RAW (ddr-ascii)
erika.write(result); // Serial.println(result,HEX);
Serial.print("Result lautet: "); Serial.print(result); Serial.println(" "); // Ausgabe der Zeichen-Nummer
wait = true; // warte bis der RTS-Pin 'high' ist
delay(100);
}
}
else //if (val == HIGH)
{
// Wenn der RTS-Pin 'high' war, bedeutet das, dass erika fuer das naechste byte bereit ist, und danach dann wieder RTS zurueck auf 'low
wait = false;
}
if (erika.available()) // erika hat Daten zum Senden
{
Serial.write(ddr2ascii[erika.read()]); // konvertiere ddr-ascci zu ascii und sende das Ergebnis an den PC
// Serial.println(erika.read());
}
}

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

044
03.10.2024, 20:28 Uhr
Ordoban

ich hatte meine Erika am PC über einen MAX232 Pegelwandler angeschlossen. Für den Fall, dass es jemandem hilft, hier mein kurzes C-Programm für Linux:

Quellcode:


// C library headers
#include <stdio.h>
#include <string.h>

// Linux headers
#include <fcntl.h> // Contains file controls like O_RDWR
#include <errno.h> // Error integer and strerror() function
#include <termios.h> // Contains POSIX terminal control definitions
#include <unistd.h> // write(), read(), close()
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <linux/serial.h>

unsigned char convert1[256] = {
    //x0    x1    x2    x3    x4    x5    x6    x7    x8    x9    xa    xb    xc    xd    xe    xf
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x78, 0x00, 0x00, // 0x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1x
    0x71, 0x42, 0x43, 0x00, 0x48, 0x04, 0x02, 0x29, 0x1d, 0x1f, 0x00, 0x25, 0x64, 0x62, 0x63, 0x40, // 2x  ' !".$%&'().+,-./'
    0x0d, 0x11, 0x10, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x13, 0x3b, 0x00, 0x2e, 0x00, 0x35, // 3x  '0123456789:;.=.?'
    0x00, 0x30, 0x18, 0x20, 0x14, 0x34, 0x3e, 0x1c, 0x12, 0x21, 0x32, 0x24, 0x2c, 0x16, 0x2a, 0x1e, // 4x  '.ABCDEFGHIJKLMNO'
    0x2f, 0x1a, 0x36, 0x33, 0x37, 0x28, 0x22, 0x2d, 0x26, 0x31, 0x38, 0x00, 0x00, 0x00, 0x19, 0x01, // 5x  'PQRSTUVWXYZ...^_'
    0x2b, 0x61, 0x4e, 0x57, 0x53, 0x5a, 0x49, 0x60, 0x55, 0x05, 0x4b, 0x50, 0x4d, 0x4a, 0x5c, 0x5e, // 6x  '`abcdefghijklmno'
    0x5b, 0x52, 0x59, 0x58, 0x56, 0x5d, 0x4f, 0x4c, 0x5f, 0x51, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, // 7x  'pqrstuvwxyz.....'
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ax
    0x00, 0x00, 0x15, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // bx
    0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // cx
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x47, // dx
    0x00, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ex
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00};// fx


void punchchar(unsigned char a, int device)
{
  unsigned char b;
  b=a;
  int status;
  usleep(10000);
  do
  {
      ioctl(device, TIOCMGET, &status);
  }
  while ((status & TIOCM_CTS) == 0);
  write(device, &b, 1);
  do
  {
      ioctl(device, TIOCMGET, &status);
  }
  while ((status & TIOCM_CTS) == 0);
}

int main()
{
  // Open the serial port. Change device path as needed (currently set to an standard FTDI USB-UART cable type device)
  int serial_port = open("/dev/ttyS0", O_RDWR);

  // Create new termios struct, we call it 'tty' for convention
  struct termios tty;

  // Read in existing settings, and handle any error
  if(tcgetattr(serial_port, &tty) != 0)
  {
      printf("Error %i from tcgetattr: %s\n", errno, strerror(errno));
      return 1;
  }

  tty.c_cflag &= ~PARENB; // Clear parity bit, disabling parity (most common)
  tty.c_cflag &= ~CSTOPB; // Clear stop field, only one stop bit used in communication (most common)
  tty.c_cflag &= ~CSIZE; // Clear all bits that set the data size
  tty.c_cflag |= CS8; // 8 bits per byte (most common)
  tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control (most common)
  tty.c_cflag |= CREAD | CLOCAL; // Turn on READ & ignore ctrl lines (CLOCAL = 1)

  tty.c_lflag &= ~ICANON;
  tty.c_lflag &= ~ECHO; // Disable echo
  tty.c_lflag &= ~ECHOE; // Disable erasure
  tty.c_lflag &= ~ECHONL; // Disable new-line echo
  tty.c_lflag &= ~ISIG; // Disable interpretation of INTR, QUIT and SUSP
  tty.c_iflag &= ~(IXON | IXOFF | IXANY); // Turn off s/w flow ctrl
  tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL); // Disable any special handling of received bytes

  tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
  tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed
  // tty.c_oflag &= ~OXTABS; // Prevent conversion of tabs to spaces (NOT PRESENT ON LINUX)
  // tty.c_oflag &= ~ONOEOT; // Prevent removal of C-d chars (0x004) in output (NOT PRESENT ON LINUX)

  tty.c_cc[VTIME] = 10;    // Wait for up to 1s (10 deciseconds), returning as soon as any data is received.
  tty.c_cc[VMIN] = 0;

  // Set in/out baud rate to be 9600
  cfsetispeed(&tty, B1200);
  cfsetospeed(&tty, B1200);

  // Save tty settings, also checking for error
  if (tcsetattr(serial_port, TCSANOW, &tty) != 0)
  {
      printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
      return 1;
  }

  unsigned char a;

  while (1)
  {
      int i = read(0, &a, 1);
      if (i>0)
      {
          a = convert1[a];
          if (a>0) punchchar(a,serial_port);
      }
  }

  close(serial_port);
  return 0; // success
};

--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

045
03.10.2024, 21:50 Uhr
Bert

Zitat:

bosch schrieb
SoftwareSerial erika(ERIKA_RX, ERIKA_TX); // RX, TX

Da wundert mich der Empfangsverlust von Zeichen gar nicht.

Bei 9600 bps (Empfang) dauert die Übertragung ca. 1 ms.
(8 Bit Daten + Startbit + Stopbit = 10 Bit * 104 µs)
Die Ausgabe zur Erika braucht bei 2400 bps dann 4 ms.
Da die von Dir genutzten Funktionen im Arduino nicht nebenläufig sind, können während der Ausgabe Zeichen verloren gehen, es sei denn das der Sender Pausen von mindestens 4 ms eingelegt.

Günstiger wäre die Nutzung der Hardware-UARTs, da dort die jeweilige Übertragung im Hintergrund stattfindet und die Software muss nur kurz reagieren, wenn die Übertragung durch ist.
Außerdem sollte man einen gewissen Puffer vorsehen, da ja maximal bis zu 4x mehr Zeichen empfangen werden müssen, als man selber raussenden kann.

Viele Grüße,
Bert
--
Viele Grüße,
Bert

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

046
03.10.2024, 22:18 Uhr
schlaub_01

Zumindest würde es ausreichen, wenn man die USART Hardware-Einheit auf der PC Seite mit einem Hardware Handshake betreibt und per Software die 1200Baud auf der Erika-Seite überträgt. Das würde dann schon vom Timing mit Interrupts passen.
Auf jeden Fall wundert mich das bei dem Code nicht, daß das nicht zuverlässig funktioniert. Selbst die 9600 Baud mit Software zu dekodieren ist mit den AVRs schon mehr als grenzwertig, falls der dazu noch mit 8MHz laufen sollte.

Viele Grüße,
Sven.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

047
04.10.2024, 09:22 Uhr
wpwsaw
Default Group and Edit

....moin,

wie ich oben schon geschrieben habe, @Micha hat das doch alles schon fertig, man sollte ihn dazu befragen....

gruß
wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

048
04.10.2024, 09:53 Uhr
schlaub_01

Zitat:

wpwsaw schrieb
....moin,

wie ich oben schon geschrieben habe, @Micha hat das doch alles schon fertig, man sollte ihn dazu befragen....

gruß
wpw

Da haste Recht - warum alles neu erfinden, was schon funktioniert und erprobt ist? Leider ist der Google-Cloud-Link vom Micha nicht mehr aktiv...

Viele Grüße,
Sven.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

049
04.10.2024, 10:57 Uhr
bosch

Vielen Dank für all Eure umfassenden Antworten. Da habe ich erst einmal genügend Futter um all die Empfehlungen zu testen, bzw. umzusetzen.
Meine Ausgangsbasis war ja die, dass die ERIKA mit ChatGPT kommunizieren kann - und dazu gab es eben auch den Arduino-Sketch 'erika.ino', der für mich zunächst einmal eine Basis für mein Vorhaben darstellen sollte. Wenn ERIKA per ESP32 mit dem Internet bidirektional kommunizieren kann, dann geht das auch mit jedem anderen Eingangstext.
Und weder im Zeitschriften-Text der MAKE 02/2023, noch in einem der dazugehörigen Videos, war von zusätzlichen, notwendigen Komponenten, wie Hardware-UART, die Rede. Scheinbar geklappt hat es trotzdem.
Aber Eure Einwände sind absolut nachvollziehbar. Und ich werde in der Richtung weitermachen.
UART-Hardware ? Ist ein TTY-RS232-Adapter mit einem MAX323 schon eine solche Lösung ? Oder ist das noch etwas anderes ?
Gruß
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

050
04.10.2024, 11:02 Uhr
schlaub_01

Hallo Bodo,
Du hast aber erst was von einem Arduino Nano geschrieben, jetzt von einem ESP32 - das sind aber völlig verschiedene Dinge. Mit dem ESP sollte das alles auch mit Software-Uart gehen, denn der hat ja auch ganz andere Möglichkeiten und eine wesentlich höhere Taktfrequenz. Ich würde trotzdem in jedem Fall eine Hardware Uart im IC vorziehen. Das hat nichts mit dem TTL-RS232 zu tun. Das ist ja nur ein Pegelwandler.
Ich denke mal, daß der ESP auch mehrere UARTs hat, so daß Dein Vorhaben noch viel einfacher wird. Aber da kennen sich die ESP Profis hier besser aus.

Viele Grüße,
Sven.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

051
04.10.2024, 13:15 Uhr
bosch

Hallo Sven.

Da hast Du was falsch verstanden - der ChatGPT-Sketch mit der ERIKA wird auf einen ESP32 geladen, weil die Systematik per WLAN läuft. Mein Aufbau basiert auf einem NANO, weil ich kein WLAN benötige. Ich will ja versuchen die ERIKA an einen RTTY-Konverter anzuschließen.

Das bisherige Problem scheint aber auch schon gelöst zu sein. So wie ich anfangs schon vermutete, liegt es an der BAUD-Rate. Das hatte ralle ja auch gleich in der ersten Antwort als mögliche Ursache bestätigt.
Ich habe nun die PC (!) - Baudrate von 9600 auf 2400 reduziert. Die ERIKA-Baudrate habe ich bei 1200 belassen. --> Vollständig - Fehlerfrei = Spaß dabei ;-)

Dieser erfolgreiche Einstieg war mir wichtig. Jetzt kann ich darauf aufbauend weitermachen. So gibt es noch die Problematik des 'ä, ö, ü, ß'. Das ist aber auch erst einmal nicht so tragisch, denn auch diese Zeichen werden in RTTY nicht verwendet. Allein schon deshalb nicht, weil die Funkverbindungen zumeist ins Ausland gehen - und die haben diese Zeichen nicht.
Das andere 'Problemchen' ist da schon gewichtiger: Ist die Zeile 'voll geschrieben' wird der Datentransfer gestoppt; der Rest geht verloren.
Das aber ist sicher herauszufinden. Da muß ich vielleicht ggf. mit einem Zähler arbeiten, der dann den Umbruch im laufenden Text erzwingt. Aber auch das ist bei RTTY erst einmal noch nicht so wichtig, denn auch das wird dort im Datenstrom geregelt.

Ich halte Euch auf dem Laufenden ! Sowie ich eine (auch nur teilweise) funktionierende zum RTTY-Konverter habe, gebe ich Bescheid und poste mal ein Foto.

Danke für Eure bisherige Unterstützung ! Wenn Ihr mal vorbeikommt, gebe ich ein Bier aus.
Viele Grüße
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

052
04.10.2024, 13:16 Uhr
bosch

..Sowie ich eine (auch nur teilweise) funktionierende bidirektionale Verbindung zum RTTY-Konverter habe, gebe ich Bescheid und poste mal ein Foto.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

053
04.10.2024, 18:11 Uhr
ambrosius

Mit den Baudraten 2400/1200 hast Du das Problem trotzdem noch, da der PC doppelt so schnell senden kann, als der ESP an die Erika. Da kann es bei langen Sendungen mit großen Texten auch wieder zu 'Verschluckern' kommen. Da Du einen RTTY-Konverter anschließen willst, würde ich empfehlen, auch auf PC-Seite - das wird ja dann der Konverter - auf 1200 Baud zu gehen.
--
viele Grüße
Holger

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

054
04.10.2024, 18:27 Uhr
Ordoban

"Serial." im AVR-Code ist doch schon das Hardware-Uart vom AVR. Das sollte doch auch höhere Datenraten können. Was hier fehlt ist eine Flusskontrolle vom PC zum AVR.
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

055
04.10.2024, 18:35 Uhr
schlaub_01

In Bodos Code ist aber "SoftwareSerial.h" eingebunden und wenn ich mir den Code dazu anschaue, ist das alles über Timer und Pinchange gebildete Datenwerte. Das kann auch der AVR mit der USART besser und sollte eigentlich immer genommen werden. Die Ausgabe mit 1200 Baud kann ja problemlos über Timerinterrupt und normale Pinausgabe gehen, da ist genug Zeit und kleine Schwankungen, z.B. durch ein UART Interrupt, machen dann auch nicht mehr viel aus.

Viele Grüße,
Sven.

Dieser Beitrag wurde am 04.10.2024 um 18:36 Uhr von schlaub_01 editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

056
04.10.2024, 19:12 Uhr
Ordoban

"Serial." ist beim Arduino die Default Ein/Ausgabe. Die ist immer vorhanden, und sollte den Hardware Uart benutzen. Dazu wird zusätzlich noch ein zweiter Uart vom Typ "SoftwareSerial" mit dem Namen "erika" angelegt.
Das ist auch ganz logisch, da die meisten Microcontroller die ich kenne nur einen Hardware Uart haben.
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

057
05.10.2024, 10:54 Uhr
bosch

Es ist lehrreich hier bei Euch im Forum zu sein. Die verschiedenen Sichtweisen und Erklärungen sind hilfreich. Auch dann (!), oder gerade dann, wenn sie kontrovers zu sein scheinen.
Noch eine Rand-Info: Bei 9600 PC-Baud fehlten ja einzelne Zeichen, wenn ich viele Zeichen auf einmal ausgeben wollte. Bei 2400 PC-Baud läuft alles soweit glatt. Bei 4800 PC-Baud fängt die Schreibmaschine an erste Aussetzer zu haben. Und zwar habe ich zum Testen immer ein Leerzeichen zwischen die auszugebenden Zeichen gesetzt. Bei 4800 werden zwar die Zeichen alle ausgegeben, es fehlen aber ein paar Leerzeichen.
Könnte mir auch vorstellen, dass das Typenrad (bei 9600) nicht schnell genug in die korrekte Position rasen kann und noch während dem Weg dorthin vom nächsten Zeichen 'überrannt' wird. "Aber klappt ja jetzt."

Heute soll das Adapter-Kabel kommen - TTY-RS232. Bin gespannt. Habe gestern zum Thema RTTY einen Telereader CWR-675EP aus 1983 in Betrieb genommen. Feinste Technik von damals !!!! Der spuckt einfach mal eben den Klartext eines Funkfernschreiben auf den Bildschirm aus. Genial ! Und, .... der hat einen RS232-Druckerausgang (das 'P' in der Typenbezeichnung steht für Printer). ERIKA wird sich freuen gebraucht zu werden.

Schönes Wochenende
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

058
05.10.2024, 11:16 Uhr
Ordoban

Die Erika signalisiert mit dem RTS-Signal, ob sie für ein neues Zeichen bereit ist. Dein Arduino-Programm wartet auch fein auf das RTS-Signal. Wer nicht wartet ist der PC. Der flutet gnadenlos den Arduino mit Daten.
Das Typenrad ist deutlich langsamer als die serielle Übertragung. Ohne eine Datenfluss-Kontrolle wirst du immer irgendwo Zeichen-Verluste haben. Es sei denn du hast 120 Baud... oder so.
Ist dir klar, dass die Erika mit 5V TTL-Pegeln arbeitet? Also nicht den TTY-RS232-Wandler direkt an die Erika anstöpseln!
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

059
05.10.2024, 11:27 Uhr
wpwsaw
Default Group and Edit

...auf Micha hin zu weisen war wohl nicht wichtig.

ich habe mehrere S3004 an den verschiedensten Computern. Und wenn man das Hardwareprotokoll der S3004 nicht beachtet und auswertet dann passiert so etwas, das Zeichen verschwinden. Der Puffer der S3004 ist ja nicht riesig. Die S3004 benötigt ca. 100ms um 1 Zeichen zu drucken, deshalb gibt ja das RTS Signal der S3004 den Empfang von Zeichen frei.

2 punkte noch:

1. die S3004 kann keine ASCII Zeichen verarbeiten. Sie hat ihren eigenen Code. Zeichen, die sie nicht kennt ignuriert sie bzw. interpretiert sie was zu Fehlern in der abarbeitung führen kann.

2. wenn man das RTS Signal doch beachtet hat und die Maschine auch mit den richtigen Codes befeuert, kann es am PC liegen. Ih habe bei mehreren PCs festgestellt, wenn sie unter WIN10 z.B. arbeiten, das die COM Schnittstelle nicht immer korrekt oder garnicht initialisiert wird. (Sind Erfahrungen meiner Tests DDR Plotter mit unterschiedlichen Schnittstellen an modernen PCs zu betreiben) . Ich initialisiere die COM Schnittstelle immer noch einmal in der Konsole mit den Parametern die ich benötige, egal was im Gerätemanager eingestellt ist. Und das klappt sehr gut. Wichtig ist die komplette Einstellung mit MODE (baud, data, stop, RTS, XON, DTR....)

Da hatte ich lange gerätzelt, warum es unter WIN7 mit den Geräteeinstellungen klappt und am gleichen PC unter WIN10 nicht, hatte ich aber schon hier wo anders darüber berichtet.

Und noch etwas, ich nutze die S3004 auch am KC85/5 mit direkt am modifizuierten V24 Modul als Drucker und Tastatur unter Typestar

wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

060
05.10.2024, 11:30 Uhr
octank

Zitat:

bosch schrieb
Es ist lehrreich hier bei Euch im Forum zu sein. Die verschiedenen Sichtweisen und Erklärungen sind hilfreich. Auch dann (!), oder gerade dann, wenn sie kontrovers zu sein scheinen.
Noch eine Rand-Info: Bei 9600 PC-Baud fehlten ja einzelne Zeichen, wenn ich viele Zeichen auf einmal ausgeben wollte. Bei 2400 PC-Baud läuft alles soweit glatt. Bei 4800 PC-Baud fängt die Schreibmaschine an erste Aussetzer zu haben. Und zwar habe ich zum Testen immer ein Leerzeichen zwischen die auszugebenden Zeichen gesetzt. Bei 4800 werden zwar die Zeichen alle ausgegeben, es fehlen aber ein paar Leerzeichen.
Könnte mir auch vorstellen, dass das Typenrad (bei 9600) nicht schnell genug in die korrekte Position rasen kann und noch während dem Weg dorthin vom nächsten Zeichen 'überrannt' wird. "Aber klappt ja jetzt."

Heute soll das Adapter-Kabel kommen - TTY-RS232. Bin gespannt. Habe gestern zum Thema RTTY einen Telereader CWR-675EP aus 1983 in Betrieb genommen. Feinste Technik von damals !!!! Der spuckt einfach mal eben den Klartext eines Funkfernschreiben auf den Bildschirm aus. Genial ! Und, .... der hat einen RS232-Druckerausgang (das 'P' in der Typenbezeichnung steht für Printer). ERIKA wird sich freuen gebraucht zu werden.

Schönes Wochenende
Bodo

Hallo.
Nach Jahren ist in meinem Task wieder etwas los.
Ganz oben habe ich irgendwo beschrieben, wie ich das mache.
Ich berechne die Anzahl der Zeichen, die das Typenrad drehen muss (links oder rechts, was kürzer ist) und multipliziere das mit einem Wert.
Daraus ergibt sich die Wartezeit vor dem nächsten Zeichen.
Wenn man zb mehrfach das gleiche Zeichen sendet, gibt es kaum Wartezeit und sie rattert schön. Und bei Einrückungen sende ich keine Leerzeichen, sondern errechne anhand der Pica die Breite und bewege den Schreibkopf. Das ist schneller.
So werden keine Zeichen verschluckt aber es wird mit höchstmöglicher Geschwindigkeit gedruckt.

Viele Grüße
Oliver

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

061
05.10.2024, 11:34 Uhr
wpwsaw
Default Group and Edit

...übrigens die IF3000, welche speziell für die S3004 ist kann sogar mit 19200 befeuert wwerden obwohl die S3004 nur 1200 kann, also muss es an deinem Wandler liegen was er macht und mit welchem protokoll er Daten empfängt und dann weiter sendet. Diese müssen vom PC zu deinem Wandler und von deinem Wandler zur S3004 jeweils passen (sind 2 verschiedene Paar Schuhe ;-)

wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

062
05.10.2024, 12:28 Uhr
Ordoban

Die Methode, im PC die Zeit auszurechnen, wie lange die Erika zum drucken brauchen sollte erscheint mir auch nicht richtig. Da ist zu viel Unsicherheit drin.
Das RTS-Signal ist der bessere Weg. Das Problem damit ist die Umsetzung im PC.
Unter Linux hört der UART bei RTS Stop nicht direkt mit Senden auf, sondern macht noch den gesamten Sendebuffer leer. Das Betriebssystem schiebt nur keine neuen Daten in den Sendebuffer nach. Die Erika braucht auch ein bischen Zeit um das RTS auf Stop zu setzen. In der Zeit beginnt der PC gerne schonmal mit dem nächsten Zeichen. Die einzige Möglichkeit damit gescheit umzugehen war für mich vor jedem Zeichen den Status der RTS-Leitung manuell abzufragen. Sämtliches Handshake vom Linux-System selbst funktioniert mit der Erika nicht. Und wie wpwsaw schon sagte: die Erika hat nur einen sehr kleinen Empfangsbuffer. Ich habe sogar den Verdacht, dass die gar keinen hat.
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

063
05.10.2024, 13:12 Uhr
wpwsaw
Default Group and Edit

um nicht noch mehr zu schreiben stelle ich hier mal, ich hoffe ich bekomme keinen Ärger mit dem Urheber, die Bedienanleitung des IF2014 Moduls von Micha ein

https://magentacloud.de/s/FS7ZS675prZQg3a

das Modul arbeitet in beiden Richtungen (Tastatur/Drucker) und die Verbindung Modul-S3004 hat Hardwareprotokoll (RTS/CTS) und die Verbindung Modul-PC hat Softwareprotokoll (XON/OFF)

wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Dieser Beitrag wurde am 05.10.2024 um 13:16 Uhr von wpwsaw editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

064
05.10.2024, 13:48 Uhr
octank

Zitat:

Ordoban schrieb
Die Methode, im PC die Zeit auszurechnen, wie lange die Erika zum drucken brauchen sollte erscheint mir auch nicht richtig. Da ist zu viel Unsicherheit drin.
Das RTS-Signal ist der bessere Weg. Das Problem damit ist die Umsetzung im PC.
Unter Linux hört der UART bei RTS Stop nicht direkt mit Senden auf, sondern macht noch den gesamten Sendebuffer leer. Das Betriebssystem schiebt nur keine neuen Daten in den Sendebuffer nach. Die Erika braucht auch ein bischen Zeit um das RTS auf Stop zu setzen. In der Zeit beginnt der PC gerne schonmal mit dem nächsten Zeichen. Die einzige Möglichkeit damit gescheit umzugehen war für mich vor jedem Zeichen den Status der RTS-Leitung manuell abzufragen. Sämtliches Handshake vom Linux-System selbst funktioniert mit der Erika nicht. Und wie wpwsaw schon sagte: die Erika hat nur einen sehr kleinen Empfangsbuffer. Ich habe sogar den Verdacht, dass die gar keinen hat.

Hm, soweit ich mich erinnere, war das RTS auch etwas unzuverlässig. Ich prüfe es vor dem Versand eines Zeichens, aber der timeout war mEn trotzdem nötig, da es so war, wie du schriebst.
Der RTS kam zu spät und das Ding hat anscheinend keinen Buffer. In der Kombination hat es dann bei mir irgendwie funktioniert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

065
05.10.2024, 14:01 Uhr
bosch

Ja, dieser Thread lebt wieder, Oliver. ;-)

Da lag ich also nicht ganz falsch mit dem Gefühl, das die Elektromechanik nicht so schnell sein wird, wie der Datenfluß.
Das TTY kann ich nicht bei V24/Centronics/RS232/... 'anstöpseln'. Ja, weiß ich --> +/-12V Pegel auf der einen Seite zu +5V auf der anderen Seite) . Deshalb der bestellte TTY-RS232-Adapter (mit MAX323-Chip). JA - kein ASCII - weiß ich.

Was ich nicht verstanden habe war: vom "PC zum Wandler und vom Wandler zur ERIKA". PC ? Wandler ? Da habe ich was nicht verstanden. Ich habe 'nur' einen Arduino NANO - der übersetzt rein - und rausgehende Daten zur - und von ERIKA und könnte diese dann auch anderweitig weitergeben. So der Plan; so sollen die aufbereiteten Daten der Schreibmaschine später an einen RTTY-Encoder übergeben werden - und das als TTY-Signal; also +/-12V Pegel; wenn das zu komplex wird, dann mache ich daraus einen FSK-Pegel; der schaltet nur gegen Masse. Und ich könnte noch einen AFSK-Pegel erstellen; dazu setze ich HIGH & LOW dann in zwei Tonsignale um.
Das werde ich schon dem kleinen Kerl (NANO) beibringen.
Viele Grüße
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

066
05.10.2024, 15:28 Uhr
wpwsaw
Default Group and Edit

...du schreibst doch immer von einem PC.....

gut Wandler muß ein Pegelwandler und Datenwandler sein der zwischen PC und S3004 sitzt.

der PC kann auch alles andere sein, z.B. dein RTTY-Encoder mit TTY-V24 Wandler.

Bitte lese dir die BA des IF2014 durch dort ist alles beschrieben und hier wäre die IF2014 Box der Wandler zwischen PC und S3004 und es sind 2 verschiedene Protokolle notwendig, einmal zwischen S3004 und IF2014 (RTS/CTS) und zwischen IF2014 und PC (XON/OFF) und jede Verbindung hat seine eigene Baud-Rate.

RTS unzuverlässig??? wie schon mehrfach geschrieben habe, meine Verbindungen zur S3004 egal woher (PC, KC , MG), haben noch nie ein Zeichen verloren.

wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

067
05.10.2024, 15:32 Uhr
wpwsaw
Default Group and Edit

...Achso zur Info TTY ist eine Stromschleife 20ma und kein +/-12V (V24) !!!

wpw
--
RECORD, CRN1; CRN2; PicoDat; LC80; Poly880; KC85/2,3,4,5 ; KC87; Z1013; BIC; PC1715; K8915; K8924; A7100; A7150; EC1834; und P8000 ab jetzt ohne Tatra813-8x8 aber mit W50LA/Z/A; P3; ES175/2 und Multicar M25 3SK; Barkas B1000 HP

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

068
06.10.2024, 10:28 Uhr
bosch

Danke für die Tipps und Hinweise !
Schönen Sonntag
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

069
06.10.2024, 10:31 Uhr
bosch

Hab mir die BA mal heruntergeladen.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

070
15.11.2025, 11:33 Uhr
bosch

Mehr als ein Jahr ist um - und ich muß zugeben: 'Ich trete teilweise noch immer an der gleichen Stelle'. In den letzten 5 Wochen habe ich mich wieder Tag für Tag mit der Lösungsfíndung zu meinen noch offenen Fragen beschäftigt. Leider ohne nennenswerten Erfolg.
Es geht an sich nur um die Zeichen-Übergabe von ERIKA zum PC und umgekehrt. Das funktioniert nicht voll umfänglich. Nicht alle Zeichen werden übertragen, oder korrekt angezeigt. Da gibt es dann für mich Ungereimtheiten wie es genau funktioniert und dem zur Folge 'wie ich es korrigieren kann'.
An sich werden alle Groß- und Kleinbuchstaben, sowie die Ziffern und einige Satzzeichen korrekt bidirektional von einem zum anderen übergeben. Prima !
Es gibt aber auch Zeichen die werden gar nicht - oder auch falsch übergeben.
An sich eine simple Aufgabenstellung für eine notwendige Korrektur in einem der beiden Arrays (ddr2ascii , bzw. ascii2ddr).
Die Funktionsweise die ich meine verstanden zu haben geht dabei zunächst so:
Auf der ERIKA wird ein Zeichen - nehmen wir ein bspw. ein 'A' - eingetippt; das wird umgesetzt in den DEC-Wert '48' und an den seriellen Ausgang gesendet; vom Arduino gelesen und dann mit dem Array 'ddr2ascii' an Position '48' verglichen - wo dann auch wieder das 'A' steht. Soweit so klar.
Umgekehrt werden vom PC aus die Standard-ASCII-DEC-Werte in die ASCII-Werte für die ERIKA umgewandelt
Sämtliche Umlaute werden zwar zu Papier gebracht, aber nicht auf den Arduino, bzw. den PC übergeben. Warum ? Mein Ansatz: Weil diese Zeichen nicht im Array aufgeführt sind. Umgekehrt gibt es die gleichen - , oder ähnliche Übersetzungsprobleme auf dem Weg vom PC zur Schreibmaschine. So passiert es das ein 'mikro-Zeichen', oder ein ² (hoch 2) vom PC zu einem 'Ü', bzw. 'ä' auf der ERIKA führt.
An sich wären das gute Ansätze um auf diesem Verhalten aufzubauen und sich die Logik zu erarbeiten. Ich kann es aber drehen und wenden wie ich will - Ich finde es nicht heraus.
So ist es für mich unerklärlich, warum z.B. die Ziffern 3, 4, 5, ... gar nicht im Array ddr2ascii stehen - aber trotzdem fehlerfrei übergeben werden. Und wieso stehen in der ascii2ddr so viele '0x71' - also immer das Gleiche ?

An welcher Stelle müsste ich eingreifen, um dort zu ergänzen, oder zu korrigieren ?
Bin ich auf dem völlig falschen Pferd ?
Kann mir bitte jemand von Euch auf die Sprünge helfen. Wo habe ich was nicht verstanden ?
Viele Grüße
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

071
15.11.2025, 13:24 Uhr
Ordoban

Zitat:

bosch schrieb
Es gibt aber auch Zeichen die werden gar nicht - oder auch falsch übergeben.
An sich eine simple Aufgabenstellung für eine notwendige Korrektur in einem der beiden Arrays (ddr2ascii , bzw. ascii2ddr).

...

Zitat:

Sämtliche Umlaute werden zwar zu Papier gebracht, aber nicht auf den Arduino, bzw. den PC übergeben. Warum ? Mein Ansatz: Weil diese Zeichen nicht im Array aufgeführt sind. Umgekehrt gibt es die gleichen - , oder ähnliche Übersetzungsprobleme auf dem Weg vom PC zur Schreibmaschine. So passiert es das ein 'mikro-Zeichen', oder ein ² (hoch 2) vom PC zu einem 'Ü', bzw. 'ä' auf der ERIKA führt.
An sich wären das gute Ansätze um auf diesem Verhalten aufzubauen und sich die Logik zu erarbeiten. Ich kann es aber drehen und wenden wie ich will - Ich finde es nicht heraus.

Das Problem hier ist ASCII. Im originalen ASCII-Standard waren Zeichen wie Umlaute gar nicht enthalten. Die sind später als länderspezifische Codepages dazu gekommen. Das war ganz schön umständlich, da die Umlaute in Texten nur richtig dargestellt wurden, wenn die richtige Codepage bei der Anzeige (oder Ausdruck) benutzt wird. Das ganze Gemähr mit den Codepages ist mittlerweile durch den UTF-Standard abgelöst worden. Heute wird meist UTF-8 verwendet. Siehe https://de.wikipedia.org/wiki/UTF-8

Zitat:

So ist es für mich unerklärlich, warum z.B. die Ziffern 3, 4, 5, ... gar nicht im Array ddr2ascii stehen - aber trotzdem fehlerfrei übergeben werden.

Da haste dich vermutlich verguckt. Die Ziffern müssen drin stehen.

Zitat:

Und wieso stehen in der ascii2ddr so viele '0x71' - also immer das Gleiche ?

Das sind Zeichen, die die Erika nicht drucken kann. An deren Stelle wird stattdessen ein Leerzeichen (eben 0x71) gedruckt.

Zitat:

An welcher Stelle müsste ich eingreifen, um dort zu ergänzen, oder zu korrigieren ?
Bin ich auf dem völlig falschen Pferd ?
Kann mir bitte jemand von Euch auf die Sprünge helfen. Wo habe ich was nicht verstanden ?
Viele Grüße
Bodo

Du müsstest erstmal feststellen welche Codierung der Text auf deinem PC hat. Dann müsstest du feststellen welche Codierung deine ddr2ascii oder ascii2ddr Tabellen haben. Dann kannst du entweder deine Texte manuell umcodieren (z.B. mit Notepad++) oder deinem Programm eine Umcodierung beibringen. Mein Programm in #044 verwendet übrigends die CP1250 Codepage.
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

072
15.11.2025, 13:48 Uhr
octank

Hallo Bodo,
für meine Python-Textverarbeitung habe ich damals diese Codetabellen verwendet:

S3004_ASCII = {"?": '\x84', "?": '\x85', "?": '\x86', "¥": '\x87', "?": '\x88', "?": '\x89', "FETT": '\xA9\xA5\x01', "?": '\x8E',
"?": '\x8D', "±": '\x77', "\r": '\x78', "\n": '\x9f', "_": '\x01', "&": '\x02', "¨": '\x03', "%": '\x04', "i": '\x05',
"£": '\x06', "µ": '\x07', "9": '\x08', "8": '\x09', "7": '\x0A', "6": '\x0B', "5": '\x0C', "0": '\x0D', "4": '\x0E',
"3": '\x0F', "2": '\x10', "1": '\x11', "H": '\x12', ":": '\x13', "D": '\x14', "²": '\x15', "M": '\x16', "'": '\x17',
"B": '\x18', "^": '\x19', "Q": '\x1A', "*": '\x1B', "G": '\x1C', "(": '\x1D', "O": '\x1E', ")": '\x1F', "C": '\x20',
"I": '\x21', "V": '\x22', "³": '\x23', "K": '\x24', "+": '\x25', "X": '\x26', "|": '\x27', "U": '\x28', "´": '\x29',
"N": '\x2A', "`": '\x2B', "L": '\x2C', "W": '\x2D', "=": '\x2E', "P": '\x2F', "A": '\x30', "Y": '\x31', "J": '\x32',
"S": '\x33', "E": '\x34', "?": '\x35', "R": '\x36', "T": '\x37', "Z": '\x38', "°": '\x39', "Ü": '\x3A', ";": '\x3B',
"Ö": '\x3C', "§": '\x3D', "F": '\x3E', "Ä": '\x3F', "/": '\x40', "#": '\x41', "!": '\x42', '"': '\x43', "é": '\x44',
"ç": '\x45', "è": '\x46', "ß": '\x47', "$": '\x48', "f": '\x49', "m": '\x4A', "j": '\x4B', "w": '\x4C', "l": '\x4D',
"b": '\x4E', "v": '\x4F', "k": '\x50', "y": '\x51', "q": '\x52', "d": '\x53', "z": '\x54', "h": '\x55', "t": '\x56',
"c": '\x57', "s": '\x58', "r": '\x59', "e": '\x5A', "p": '\x5B', "n": '\x5C', "u": '\x5D', "o": '\x5E', "x": '\x5F',
"g": '\x60', "a": '\x61', "-": '\x62', ".": '\x63', ",": '\x64', "ä": '\x65', "ö": '\x66', "ü": '\x67', " ": '\x71',
"?": '\xA5', "\t": '\x79',
"?": '\x1E', "??": '\x28', "?": '\x32', "?": '\x3C', "¤": '\x46', "ð": '\x50', "Ð": '\x5A', "Ê": '\x64',
"Ë": '\x24', "È": '\x30', "ì": '\x3c', "Í": '\x48', "Î": '\x54', "Ï": '\x60', "?": '\x6C', "?": '\x78',
"?": '\x18', "ò": '\x20', "ó": '\x28', "ô": '\x30', "ù": '\x38', "ÿ": '\x40', "÷": '\x48', "ø": '\x50',
"?": '\xE0', "?": '\xD6', "¦": '\xCC', "Ì": '\xC2', "?": '\xB8', "Ó": '\xAE', "Ô": '\xA4', "Ò": '\x9A',
"õ": '\xDA', "Õ": '\xCE', "ý": '\xC2', "þ": '\xB6', "Þ": '\xAA', "Ú": '\x9E', "Û": '\x92', "Ù": '\x86'}

S3004_INPUT = {"10000100": "", "10000101": "", "10000110": "", "10000111": "", "10001000": "", "10001001": "", "10001110": "",
"10001101": "", "01110111": "\n", "01111000": "±", "10011111": "\n", "00000001": "_", "00000010": "&", "00000011": "¨",
"00000100": "%", "00000101": "i", "00000110": "£", "00000111": "µ", "00001000": "9", "00001001": "8", "00001010": "7",
"00001011": "6", "00001100": "5", "00001101": "0", "00001110": "4", "00001111": "3", "00010000": "2", "00010001": "1",
"00010010": "H", "00010011": ": ", "00010100": "D", "00010101": "²", "00010110": "M", "00010111": "", "00011000": "B",
"00011001": "^", "00011010": "Q", "00011011": "*", "00011100": "G", "00011101": "(", "00011110": "O", "00011111": ")",
"00100000": "C", "00100001": "I", "00100010": "V", "00100011": "³", "00100100": "K", "00100101": "+", "00100110": "X",
"00100111": "|", "00101000": "U", "00101001": "´", "00101010": "N", "00101011": "`", "00101100": "L", "00101101": "W",
"00101110": "=", "00101111": "P", "00110000": "A", "00110001": "Y", "00110010": "J", "00110011": "S", "00110100": "E",
"00110101": "?", "00110110": "R", "00110111": "T", "00111000": "Z", "00111001": "°", "00111010": "Ü", "00111011": ";",
"00111100": "Ö", "00111101": "§", "00111110": "F", "00111111": "Ä", "01000000": "/", "01000001": "#", "01000010": "!",
"01000011": "\"", "01000100": "é", "01000101": "ç", "01000110": "è", "01000111": "ß", "01001000": "$", "01001001": "f",
"01001010": "m", "01001011": "j", "01001100": "w", "01001101": "l", "01001110": "b", "01001111": "v", "01010000": "k",
"01010001": "y", "01010010": "q", "01010011": "d", "01010100": "z", "01010101": "h", "01010110": "t", "01010111": "c",
"01011000": "s", "01011001": "r", "01011010": "e", "01011011": "p", "01011100": "n", "01011101": "u", "01011110": "o",
"01011111": "x", "01100000": "g", "01100001": "a", "01100010": "-", "01100011": ".", "01100100": ", ", "01100101": "ä",
"01100110": "ö", "01100111": "ü", "01110001": " ", "01111001": "\t", "11000011": ">"}

Ich hatte allerdings keinen Arduino dazwischen sondern alles über eine Serielle Schnittstelle gemacht.

Vielleicht hilft das?
Die Codierung des Codes ist UTF-8.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

073
15.11.2025, 14:05 Uhr
bosch

Hallo Oliver.
Danke für den unglaublich schnelle Rückantwort.
OK - Ich habe mir eine Tabelle erstellt die den 'Code' bei der Zeicheneingabe auf dem PC ausgibt. Das ist - entsprechend der Standard-ASCII-Tabelle bei einem 'A' der DEC-Wert '65'. Dieser wird dann aber übersetzt in der Tabelle 'ascii2ddr' auf den Wert '48' und an die ERIKA übergeben. Das funktioniert auch so. Umgekehrt funktioniert es auch - da heißt das Äquivalent in der Tabelle ddr2ascii dann aber 0x0D. Bei Deinem Code wäre es dann wohl die 'x30'.
Die Funktionsweise ist an sich klar. Ich hätte auch kein Problem damit die gesamten Arrays schlicht nochmals neu zu erstellen.
Deine Erklärung zu den 0x71 leuchtet ein - ich hatte auch vermutet, dass hier nichts übersetzt wird und die Werte 'eins-zu-eins' übergeben werden.
Und das mit den Ziffern habe ich genauestens kontrolliert (quasi stundenlang) in der Tabelle sind u.a. die Zahlen 3-0 nicht aufgeführt; nur die beiden Ziffern 1 und 2. Funktionieren tut es trotzdem.
Danke aber für Deine Hinweise : Ich gehe jedem Detail nochmals nach. "Kann doch nicht sein wie es ist." Es muß ja eine Logik geben.

Ich bleib dran und melde mich dann wieder.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

074
15.11.2025, 17:04 Uhr
Ordoban

Kannste mal deine beiden Tabellen (ascii2ddr und ddr2ascii) posten?
Edit: oder gleich das ganze Programm?
--
Gruß
Stefan

Dieser Beitrag wurde am 15.11.2025 um 17:07 Uhr von Ordoban editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

075
15.11.2025, 17:21 Uhr
bosch

Klaro !

char ascii2ddr [128] = {
0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x91,0x77,0x71,0x71,0x92,
0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,
0x71,71,0x71,0x71,0x71,0x42,0x43,0x41,0x48,0x04,0x02,0x17,0x1D,0x1F,0x1B,0x25,
0x64,0x62,0x63,0x40,0x0D,0x11,0x10,0x0F,0x0E,0x0C,0x0B,0x0A,0x09,0x08,0x13,
0x3B,0x71,0x2E,0x71,0x35,0x71,0x30,0x18,0x20,0x14,0x34,0x3E,0x1C,0x12,0x21,
0x32,0x24,0x2C,0x16,0x2A,0x1E,0x2F,0x1A,0x36,0x33,0x37,0x28,0x22,0x2D,0x26,
0x31,0x38,0x71,0x71,0x71,0x19,0x01,0x2B,0x61,0x4E,0x57,0x53,0x5A,0x49,0x60,
0x55,0x05,0x4B,0x50,0x4D,0x4A,0x5C,0x5E,0x5B,0x52,0x59,0x58,0x56,0x5D,0x4F,
0x4C,0x5F,0x51,0x54,0x71,0x27,0x71,0x71,0x71
};

Im Script stehen die einzelnen Einträge untereinander; wie auch in der folgenden Tabelle

char ddr2ascii [128] = {
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','2',
'1','H',':','D','²','M','\"','B','^','Q','*','G','(','O',
')','C','I','V','³','K','+','X','|','U',' ','N','`','L','W',
'=','P','A','Y','J','S','E','?','R','T','Z','°','Ü',';','Ö',
'§','F','Ä','/','#','!','"','é','ç','è','ß','$','f','m','j',
'w','l','b','v','k','y','q','d','z','h','t','c','s','r','e',
'p','n','u','o','x','g','a','-','.',',','ä','ö','ü',' ',' ',' ',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','\n',' ',' ',' ',' ',
' ',' ',' ',' '
};

Und hier ist keine Ziffer - mit Ausnahme von 1 und 2 aufgeführt - die aber trotzdem von
ERIKA aus übergeben werden. Aber es sind auch 'Umlaute' dabei - und die werden nicht
übergeben; und das auch nicht umgekehrt vom PC an ERIKA.
Das ist genau mein Problem: Ich finde kein 'Packende', keine Logik, auf die ich aufbauen
könnte.
Nächstes Etappen-Ziel wäre für mich - falls Du/Ihr nicht noch eine Erklärung habt - tatsächlich ein komplett neues Array zu erstellen. Dabei frage ich in einem Schritt davor den 'noch nicht übersetzten' DEC-Wert der ERIKA ab. Damit hätte ich dann wohl eine Basis für einen Neuanfang.

Danke !
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

076
15.11.2025, 17:42 Uhr
ralle

Sind den nicht zufällig die Quellen des Z1013 offen? Da gab es doch auch eine Direkte Kopplung ohne IF-Kasten.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

077
15.11.2025, 17:49 Uhr
bosch

Zumindest beim ChaosComputerClub-Rostock gibt es umfangreich viele Infos, aber zu diesem Punkt habe ich nichts gefunden. Da war auch mal ein Link für den Einsatz mit dem ARDUINO - der ist aber nicht mehr aktiv.

Aber speziell deine Frage nach 'Z1030' ist schon interessant. Wieso Z1013 ? Ist das der Chip, oder der Computer, der genau diesen Code (oder CODEC) verwendet ? Da habe ich explizit nicht nach gesucht.

Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

078
15.11.2025, 18:25 Uhr
Ordoban

Aha. Diese Tabellen sind nur 128 Werte. Damit ist klar, warum die Richtung ascii2ddr für Umlaute nicht funktioniert. Die Umlaute sind da schlicht nicht drin. Du könntest die Tabelle um die Umlaute erweitern. Wie, ist abhängig von der Codepage:

CP1250 (Windows bis ca. win7)
ÄÖÜäöüß ---> c4 d6 dc e4 f6 fc df

IBM850 (DOS)
ÄÖÜäöüß ---> 8e 99 9a 84 94 81 e1

UTF8 (Windows ab ca. 8, Linux, MacOS etc.)
ÄÖÜäöüß ---> c384 c396 c39c c3a4 c3b6 c3bc c39f
(jaaaa, bei UTF8 sind Umlaute 2 Bytes...)

Für CP1250 würde das etwa so aussehen:

Quellcode:


char ascii2ddr [256] = {
0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x91,0x77,0x71,0x71,0x92,
0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,0x71,
0x71,71,0x71,0x71,0x71,0x42,0x43,0x41,0x48,0x04,0x02,0x17,0x1D,0x1F,0x1B,0x25,
0x64,0x62,0x63,0x40,0x0D,0x11,0x10,0x0F,0x0E,0x0C,0x0B,0x0A,0x09,0x08,0x13,
0x3B,0x71,0x2E,0x71,0x35,0x71,0x30,0x18,0x20,0x14,0x34,0x3E,0x1C,0x12,0x21,
0x32,0x24,0x2C,0x16,0x2A,0x1E,0x2F,0x1A,0x36,0x33,0x37,0x28,0x22,0x2D,0x26,
0x31,0x38,0x71,0x71,0x71,0x19,0x01,0x2B,0x61,0x4E,0x57,0x53,0x5A,0x49,0x60,
0x55,0x05,0x4B,0x50,0x4D,0x4A,0x5C,0x5E,0x5B,0x52,0x59,0x58,0x56,0x5D,0x4F,
0x4C,0x5F,0x51,0x54,0x71,0x27,0x71,0x71,0x71,
    0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, // 8x
    0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, // 9x
    0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x3d, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, // ax
    0x71, 0x71, 0x15, 0x23, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, // bx
    0x71, 0x71, 0x71, 0x71, 0x3f, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, // cx
    0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x3c, 0x71, 0x71, 0x71, 0x71, 0x71, 0x3a, 0x71, 0x71, 0x47, // dx
    0x71, 0x71, 0x71, 0x71, 0x65, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, // ex
    0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x66, 0x71, 0x71, 0x71, 0x71, 0x71, 0x67, 0x71, 0x71, 0x71} // fx

Es muss irgendwo im Programm eine Begrenzung auf 128 Charpositionen stehen. Die müsstest du dann auf 256 erweitern. (oder ganz entfernen)

Bei der anderen Richtung wird das echt komisch. Da fehlen tatsächlich die Nummern. Die müssten etwa so sein:

Quellcode:


char ddr2ascii [128] = {
' ',' ',' ',' ',' ',' ',' ',' ','9','8','7','6','5','0','4','3',             // 00-0F
'2','1','H',':','D','²','M','"','B','^','Q','*','G','(','O',')',    // 10-1F
'C','I','V','³','K','+','X','|','U',' ','N','`','L','W','=','P',    // 20-2F
'A','Y','J','S','E','?','R','T','Z','°','Ü',';','Ö','§','F','Ä', // 30-3F
'/','#','!','"','é','ç','è','ß','$','f','m','j','w','l','b','v',        // 40-4F
'k','y','q','d','z','h','t','c','s','r','e','p','n','u','o','x',      // 50-5F
'g','a','-','.',',','ä','ö','ü',' ',' ',' ',' ',' ',' ',' ',' ',              // 60-6F
' ',' ',' ',' ',' ',' ',' ','\n',' ',' ',' ',' ',' ',' ',' ',' '                  // 70-7F
};

Ich wundere mich echt, warum der bei dir trotzdem Nummern ausspuckt.

Und ich sehe hier noch ein anderes Problem. Woher weiß der Compiler, welche Codepage bzw. Codierung der verwenden soll? Wenn man sicherstellen will, dass da am Ende das richtige raus kommt, sollte man für Sonderzeichen die Hex-Codes der gewünschten Codepage verwenden. Etwa so (für CP1250):

Quellcode:


'A','Y','J','S','E','?','R','T','Z','°',0xDC,';',0xD6,'§','F',0xC4, // 30-3F
'/','#','!','"','é','ç','è',0xDF,'$','f','m','j','w','l','b','v',        // 40-4F
'k','y','q','d','z','h','t','c','s','r','e','p','n','u','o','x',      // 50-5F
'g','a','-','.',',',0xE4,0xF6,0xFC,' ',' ',' ',' ',' ',' ',' ',' ',              // 60-6F

Edit: Zeile 8x vergessen...
Edit2: Ich sehe gerade als Datentyp "char". Bei Zahlen größer 127 sollte man "unsigned char" nehmen. Sonst kann es passieren, dass einem der Compiler Unsinn mit dem Vorzeichen macht - was genau solche blöden Fehler woe mit den Umlauten gibt.
--
Gruß
Stefan

Dieser Beitrag wurde am 15.11.2025 um 18:49 Uhr von Ordoban editiert.

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

079
15.11.2025, 19:05 Uhr
Ordoban

Zitat:

bosch schrieb
Zumindest beim ChaosComputerClub-Rostock gibt es umfangreich viele Infos, aber zu diesem Punkt habe ich nichts gefunden. Da war auch mal ein Link für den Einsatz mit dem ARDUINO - der ist aber nicht mehr aktiv.

Aber speziell deine Frage nach 'Z1030' ist schon interessant. Wieso Z1013 ? Ist das der Chip, oder der Computer, der genau diesen Code (oder CODEC) verwendet ? Da habe ich explizit nicht nach gesucht.

Bodo

Es gab in der DDR Computer, die die Unterstützung für die Erika als Drucker und/oder Tastatur schon fest im ROM eingebaut hatten. Ist das der Z1030? Ich kenn den auch nicht. Ich vermute aber, dass die Verarbeitung der Umlaute da nicht mit heutiger Technik kompatibel ist.
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

080
15.11.2025, 19:23 Uhr
bosch

Stefan, ich habe mich da vertan, bzw. vertippt. Ich habe keinen Hinweis auf 'Z1030' - es sollte an der Stelle auch 'Z1013' heißen.

Das andere, sehr schön umfangreiche, Antwort-Potential von Dir ist aber wieder 'Futter' für mich. Den einzelnen Ansätzen werde ich nachgehen.
Aber Du verstehst jetzt auch, dass man schon auch völlig ratlos ist. Da geht manches, jedoch ohne Logik. Da geht manches nicht, was aber gehen müsste. Und da geht manches schlicht anders wie erwartet.
Und dann ist ad noch die Erkenntnis, oder Frage: Wie haben das andere gemacht. Immerhin stand dieser Artikel zum Projekt in der Heise-Verlag 'MAKE' von 2023. Und der Arduino Sketch erika.ino, mit seinen beiden lokalen Bibliotheken soll vom CCC-Ristock kommen (mit einem Link dorthin); so stehen dann auch der Sketch und alles Beiwerk im Heise-Link zum Download. --> Aber wieso habe ich nur die Probleme ???
Vielleicht bin ich der Einzige, der nicht gleich nach den ersten Fehlversuchen aufgegeben hat ;-).
Ich bleib dran, Stefan (und Oliver und Ralle).
Bodo

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

081
15.11.2025, 19:31 Uhr
ralle

Der Z1013 ist ein Computerbausatz aus dem VEB Robotron Riesa. Da nicht immer alles verfügbar war und der Z1013 eigentlich als Einplatinenrechner die denkbar ungünstigsten Vorraussetzungen mitbrachte. 32x32 Zeichen, eine Folienflachtastatur, wenig brauchbare Schnittstellen. Aber eben dadurch eine Herausforderung für die User. Der Monitor ist gerade 2Kb groß. Und somit wurden nicht nur funktionstüchtige Tastaturen angeschlossen, sondern alles, was irgenwie Druckte. Und somit auch die S3004 inklusive der Nutzung der ESC- Funktionen.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

082
15.11.2025, 22:52 Uhr
Ordoban

Zitat:

ralle schrieb
Der Z1013 ist ein Computerbausatz aus dem VEB Robotron Riesa. Da nicht immer alles verfügbar war und der Z1013 eigentlich als Einplatinenrechner die denkbar ungünstigsten Vorraussetzungen mitbrachte. 32x32 Zeichen, eine Folienflachtastatur, wenig brauchbare Schnittstellen. Aber eben dadurch eine Herausforderung für die User. Der Monitor ist gerade 2Kb groß. Und somit wurden nicht nur funktionstüchtige Tastaturen angeschlossen, sondern alles, was irgenwie Druckte. Und somit auch die S3004 inklusive der Nutzung der ESC- Funktionen.

Hatten die in den 2K ROM sämtliche Ein/Ausgabe-Optionen drin, oder gabs für alles ein extra ROM-Image?
Schon krass was mit 2K alles ging.
Heute hat man TEAMS, (ein Programm mit abgef**ckt viel Schnickschnack, das im Endeffekt zum Chatten und Telefonieren benutzt wird)... das macht mal eben mehrere GB RAM weg.
--
Gruß
Stefan

Profil || Private Nachricht || Suche

Zitatantwort || Editieren || Löschen

Seiten: -1- [ Technische Diskussionen ]