Amiga und Genlock

Dieses Gerät oder besser gesagt, diese Geräteklasse werden sicherlich viele Commodore Amiga Anwender kennen, die den Amiga seinerzeit auch bei der Videonachbearbeitung benutzt haben.

Das Amiga Genlock VESone

Das Amiga Videosignal hatte ja genau die Zeilenfrequenz der damaligen Fernsehstandards (15,625kHz). Also konnte als Monitor am Amiga ja auch ein Fernseher angeschlossen werden. Vorausgesetzt es war ein Fernsehgerät mit einem R-G-B Scart Videoeingang. Als Bastler hat man sich aus den R-G-B und Sync-Ausgängen des 23poligen Amiga Monitor einen CVBS (Color-Video-Blanking-Sync) Converter zusammengelötet, der alle Signale zu einem Signal zusammenfasst. Und das war im Heimvideobereich das klassische Videosignal, das man aus jeder Camera oder Recorder heraus bekam. Also wurde der Amiga dann einfach an den Videorecorder angeschlossen und schon war eine tolle Deluxe Paint Grafik das Titelbild des letzten Urlaubsfilmes...

 

Effekte und Fader des VESone

Was aber, wenn man damit noch nicht zufrieden war und beispielsweise in das Videobild Titel (Bauchbinden) und Grafiken eingeblendet haben wollte? - Das ging nicht so einfach. Dafür gab es das "Genlock" (Generator Lockingdevice). Hierbei machte man sich die Eigenschaft des Amiga AGNUS-(später ALICE) Chipssatzes zu nutzen, der als Adressgenerator und Timing Chip im Amiga arbeitete. Dieser Custom Chip konnte  extern synchronisiert werden. Und genau das machte sich das Genlock zu nutzen. Denn um zwei Videosignale zeilengenau mischen zu können, ist es notwendig, dass sie auch synchron anliegen (das bedeutet, sie müssen in Frequenz und Phase des Bildwechsels synchron anliegen).

 

Korrekturmöglichkeiten der Signalquellen

Das Genlockinterface oder (der Genlock) gewann aus dem angelegten Videosignal einer Videocamera oder eines Videorecorders den Referenztakt und synchronisierte den Amiga nach diesem Takt. So waren jetzt beide Signale - sowohl das Monitorsignal des Amiga und das Videosignal der Videokamera oder -recorder taktgleich.  Jetzt können die beiden Signale gemischt werden. Es existierten einige Geräte auf dem Markt von ganz einfachen Genlocks, die lediglich den "Alpha Farblayer" des Amiga heranzogen und gegen das Videosignal der externen Quelle ersetzten. Damit konnten schon wunderbar Titel und Grafiken im Videofilm realisiert werden. Wollte man diese noch Ein- und Ausblenden bzw. noch die Sättigung, Helligkeit und Kontrast der beiden Quellen anpassen, dann konnte man komplexere Geräte erwerben. Hier ist ein semiprofessionelles Genlock der Firma Videocomp, das VESone (Video Effect System) dargestellt.

Anschlüsse des VESone

Es gab aber auch noch professionelle Geräte, die in Fernsehstudios eingesetzt wurden um zum Beispiel die Senderlogos in das laufende Programm einzublenden. Diese Profigeräte hatten mehrere Signalstandards als Ein- und Ausgänge zur Verfügung. CVBS, YC (S-VHS), RGB. Vor allem die getrennte RGB-Verarbeitung der Signale ermöglichte viel bessere Bildqualitäten.

Innenleben des VESone

Als Herzstück arbeiteten im VESone die folgenden IC´s:

Ein SAA1043 Universal Sync Generator generiert alle Syncsignale, ein TDA8390 Pal Decoder und RGB Matrix Chip ermöglicht das Mischen und Einfügen eines externen RGB Signals. Als RGB-Video Amplifier kommt ein LM1203 Chip zum Einsatz.

Als Software zur Erstellung von Grafiken, Animationen und Titeln aller Art, kamen Programme wie: Amiga Videotitler, Adorage, Deluxe Paint, Broadcast Titler, Scala Multimedia (ScalaMM), Texture Studio, ART Effect, Imagine etc.  zum Einsatz. 

 

 

Alter Computer wieder schön - oder wie man Kunststoff entgilbt

vergilbter Commodore 64

Als Sammler der 80iger Jahre Computer sind sicher schon viele mit dem Problem der "gelben" oder "vergilbten" Kunststoffgehäuse konfrontiert worden. Die Gehäuse sehen aus, als wären sie Jahre lang in einem Raucherzimmer gestanden und haben durch das Räuchern die Farbe angenommen. Das mag vielleicht für einige auch zutreffen, doch im Allgemeinen ist es das Material bzw. die Materialmischung und der UV Anteil des Sonnenlichtes, der das Vergilben verursacht. Die Gehäuse bestehen aus ABS (Acrylnitril-Butadien-Styrol-Copolymere) einem thermoplastisch formbaren Kunststoff, der in seinem Urzustand farblos bis grau ist. Durch Zusatz von Farbstoffen werden die Granulate, die vorwiegend im Spritzgussverfahren verarbeitet werden, in allen erdenklichen Farben hergestellt. Um die Materialeigenschaften auch dahingehend zu optimieren, dass sie flammhemmend und schlecht brennbar sind, wird Brom zugesetzt. (quelle: Internet). Und genau das Brom verursacht mit UV Licht die Gelb-bräunliche Färbung des Materials.

Tasten eines Amiga 1200

Will man nun so ein altes Gerät restaurieren und wieder in seinem originalen Glanz erstrahlen lassen, so reicht es leider nicht, die Gehäuseteile mit Seifenlauge oder ähnlichen Mittelchen zu waschen. Hier löst sich zwar jeglicher Schmutz und Verunreinigungen, aber der "Gilb" bleibt. Ich habe an einem kleinen Teststückchen wirklich einiges versucht, die Vergilbung zu entfernen. Mit Isopropanol, Terpentin, Waschbenzin, Kunststoffreiniger, Scheuermilch, Platinenreiniger, etc. - alles vergeblich. Ein mechanischer Abtrag der Oberfläche durch Anschleifen funktioniert zwar, aber dann kann man das Gehäuse gleich entsorgen. Im Netz findet man eine geeignete Lösung. Es gibt hier ein Produkt namens "Retr0bright", das im Wesentlichen aus Wasserstoffperoxid und einem Verdickungsmittel besteht. Mit diesem Mittel bestrichen und dem direkten Sonnenlicht für mehrere Stunden ausgesetzt, wirkt es Wunder. Das Peroxid bleicht mit der UV-Strahlung die Verfärbung des Kunststoffes, sodass er wieder seine ursprüngliche Farbe annimmt. Also habe ich beschlossen, diese Methode zu testen und mir in einer Apotheke 12% iges Wasserstoffperoxid gekauft.

Peroxid und Verdickungsmittel

Als Verdickungsmittel wollte ich Xanthan verwenden, doch das war in unserem "Dorf" nicht zu bekommen. Hier wurde mir, ebenfalls in einer Apotheke ein Nahrungsverdickungsmittel auf Maisstärke-Basis verkauft. Auch das erfüllt seinen Zweck.  Was ich jedoch dabei gelernt habe - solche Dinge nicht mehr in einer Apotheke zu kaufen. Denn die Preise dort sind extrem. Allein für das Peroxid musste ich 28 Euronen hinblättern. Der "Dickmacher" kostete mich nochmal 16 Euro... Das bekommt man online viel, viel günstiger. Aber jammern hilft nicht - also machte ich mich an die Mischung. Eine halbe Tasse Peroxid und drei Teelöfel "ThickenUP" geben eine gut verarbeitbare Konsistenz. Mit einem Pinsel habe ich die Gehäuseteile möglichst gleichmäßig bestrichen und mit Frischhaltefolie abgedeckt. (Dies wird in einigen Internetforen beschrieben, um die Austrocknung der Bleiche zu verhindern) Dabei ist es notwendig, die Frischhaltefolie so glatt und faltenfrei wie möglich auf die Oberfläche aufzulegen. Jede Falte ist dann im Bleichergebnis zu sehen. Danach kommen dann alle Teile in die Sonne. Ich habe sie einen Tag lang in der Sonne liegen lassen, am nächsten Tag nochmal bestrichen und wieder der UV-Strahlung ausgesetzt.

1541II er Floppygehäuse beim "Bleichen"

Nach der Belichtungs- und Reinigungsprozedur wurde wieder zusammengebaut... Die Ergebnisse sind teilweise hervorragend, aber auch mittelmäßig. Besonders wichtig ist es, einen homogenen Auftrag der Bleiche und eine konstante gleichmäßige Ausleuchtung zu erreichen. Die Lösung mit der Frischhaltefolie funktioniert zwar, ist aber noch nicht das Gelbe vom Ei. Hier die Ergebnisse: 

Commodore C64

Amiga 1200

Treppenhausschalter mit Quecksilber

Ein Treppenhauslicht einer Wohnanlage wird ja meistens über Taster in jeder Etage aktiviert. Das Licht bleibt dann für einige Zeit eingeschaltet und erlischt dann (etwa ein bis zwei Minuten) wieder selbstständig. Das kennt jeder und hat auch sicherlich schon jeder einmal selber wahrgenommen. Realisiert wird solch eine Treppenhauslichtschaltung in der klassischen Elektroinstallation über einen sog. Treppenhausautomaten oder Treppenhauszeitschalter. Das ist ein, in den Energieverteiler eingebautes Gerät, das von den Größenordnungen inetwa so aussieht wie ein Sicherungsautomat (Leitungsschutzschalter). Dieser beherbergt eine elektronische Zeitschaltuhr die über ein Relais die Last ansteuert. In den modernen "Smart-Homes" und neuen innovativen Anlagen werden Bus gesteuerte Systeme für Lichtschaltungen eingebaut.

Quecksilberschalter

Doch wie wurde eine Zeitschaltung realisiert, als es noch keine Transistoren und Halbleiter gab, zu einer Zeit, als die Radios noch "Dampfradio" genannt wurden? Ich spreche hier von den Jahren um und nach dem zweiten Weltkrieg. Hier bediente man sich der physikalischen Eigenschaften von Metallen, die bei Raumtemperatur flüssig sind und deren Ausdehnungskoeffizient bei geringer Temperaturänderung groß genug ist, um eine einfache Detektion dieser, durchführen zu können. Ich spreche von Quecksilber. In Fieberthermometern ist dieses "Flüssigmetall" ja bekannt, aber es wurde auch in der Elektrotechnik eingesetzt.

In diesem Beispiel ist es ein Quecksilber-Zeitschalter. Das In dem evakuierten Glasgefäß befindliche Quecksilber, dient hier als Schaltmedium und schließt den Stromkreis eines Verbrauchers (Glühlampe), wenn es durch Erwärmung so weit ausgedeht ist, um die Kontakte zu erreichen. Die Erwärmung wiederum wird, durch einen, in das Glasgefäß eingebauten Heizwiderstand realisiert. Schließt man den Stromkreis zum Heizwiderstand durch Druck auf einen angeschlossenen Taster, so erwärmt sich der Widerstand und das Quecksilber beginnt sich auszudehnen. Nach 2-3 Sekunden hat das sich ausdehnende Quecksilber die Schaltkontakte erreicht und der Stromkreis zur Last ist geschlossen. Jetzt kann man den Taster los lassen und der Lastkreis bleibt weiterhin eingeschaltet. Doch nun, da die Heizung nicht mehr bestromt ist, kühlt sie und das Quecksilber wieder aus, was  zur Folge hat, dass es sich wieder zusammenzieht und nach ein paar Minuten den Stromkreis zur Last wieder öffnet.

Solche Schalter waren noch bis Anfang der 70ger Jahre in vielen Wohnanlagen zu finden. Sie waren in einem Bakelitgehäuse eingebaut und durch Ändern der Schräglage des Glaskörpers konnte die Zeitbasis verändert werden.

Hier der originale Text zur Montageanleitung:

 

Vor der Montage des Gerätes ist es notwendig, das Quecksilber richtig zu verteilen. Durch Schütteln und Drehen muß das Quecksilber in die gezeichnete Lage gebracht werden. Bei senkrechter Stellung des Schaltrohres soll das rechte Ende der Quecksilberfüllung bis zur Marke 1 reichen. Es ist dabei zu beachten, dass in der Quecksilberfüllung keine Gasblasen eingeschlossen werden. Der Napf ist ebenfalls bis zur Marke 2 mit Quuecksilber zu füllen. Danach kann der Automat festgeschraubt und angeschlossen werden.
15 Minuten nach dem ersten Schaltversuch ist zu kontrollieren, ob das Quecksilber wieder bis zur Marke 1 zurückgegangen ist. Wenn nötig ist dann durch neuerliches Einschütteln eine Korrektur vorzunehmen un die Probe zu wiederholen.
In der Mittelstellung beträgt die Schaltzeit cirka vier Minuten. Diese kann durch Drehen kürzer oder länger eingestellt werden.
Achtung! Der Lampenstromkreis darf höchstens mit 6A-Sicherungen abgesichert werden.

Hier ein kurzes Video, das die Funktion des Quecksilberschalters demonstriert:

8-Bit Generation: Der Sinclair ZX-Spectrum

Der ZX-Spectrum von Sinclair

Am 23.April 1982 ist der Sinclair ZX Spectrum von der Firma Sinclair Research auf den Markt gebracht worden. [Quelle: Wikipedia] Er wurde damals zu einem Preis von umgerechnet 140 Euro bzw. 194 Euro verkauft. Die zwei Preise beziehen sich auf die 16kByte Version bzw. auf die 48kByte Version.  16kByte und 48kByte sind die Größen des RAM-Speichers mit der die Rechner ausgestattet wurden. Der ZX-Spectrum ist der Nachfolger der Sinclair ZX81 und der Vorgänger des ZX-Spectrum Plus und Sinclair QL.

Der kleine Rechner (die Abmessungen betragen  gerade einmal 23.5cm *14.5cm*3cm) wird von einer Z80A CPU angetrieben, die mit 3.5MHz Taktfrequenz arbeitet. Die ULA (Uncommitted Logic Array) ist der größte Chip auf dem ZX-Mainboard. Sie ist verantwortlich für die Grafik, die Audio IO´s (für das Laden und Speichern der Programme auf Kassette) und für die Keyboardeingaben. Dann befinden sich, je nach Ausführung noch die DRAM-Chips (Upper und Lower RAM) auf dem Board und noch ein ROM - IC, der den BASIC Interpreter beherbergt. So schafft es der kleine Rechner bunte Grafiken auf den Bildschirm zu zeichnen und das mit einer Auflösung von 256 x192 Pixeln bei 15 Farben. Die Bildausgabe wird über einen eingebauten RF-Modulator an den Antenneneingang eines Fernsehers gesendet. Mit Bildausgabe meine ich aber wirklich nur das "Bild", denn für den Ton wird nicht der Audiokanal der TV-Gerätes benutzt. Dafür gibt es am Mainboard einen kleinen Lautsprecher, der die Geräusche des Rechners ausgibt. Die wiederum werden nicht wie etwa beim C64 in einem eigenen Chip (SID-Chip) erzeugt und das noch in mehreren Stimmen - nein dafür wird der MIC/TAPE Pin der ULA verwendet, der den Lautsprecher einfach über einen Transistor an 5V schaltet. Damit können dann einfache "Beep-Geräusche" erzeugt werden. Aus heutiger Sicht betrachtet, ist das natürlich gar nichts Besonderes, aber für all jene, die damit in Ihrer Kindheit konfrontiert waren, sind bestimmt auch einige Erinnerungen damit verbunden. So eben auch für mich. Ich hatte damals zumindest die Möglichkeit, zusammen mit meinem Bruder ein solches Gerät von einem Freund ausleihen zu dürfen. Darauf wurde dann natürlich - wie kann es anders sein - gespielt. Titel wie "Manic-Miner",  "Ant-Attack" oder Flight-Simulator, gehörten zu den am häufigsten geladenen Kassetten. Ja - Kassetten. Zu der Zeit war es üblich, die Programme auf einer Audiokassette zu kaufen. An den ZX-Spectrum wurde ein einfacher Kassettenrecorder über die Kopfhörerbuchse angeschlossen und über die Gummitasten des ZX der Befehl LOAD "" eingegeben. Dann musste man am Kassettenrecorder nur mehr Play drücken und es konnte losgehen. Voraussetzung war natürlich, dass die Bandgeschwindigkeit und der eingestellte Lautstärkepegel passte. Nur dann war das Laden des Programmes erfolgreich und das Spiel startete. Die Ladezeiten betrugen je nach Programm von zwei bis oft über zehn Minuten.

Datenrecorder zum Laden und Speichern von Programmcode

In meiner 8Bit - Retrorechner Sammlung fehlte bis jetzt die komplette Serie der Sinclair Rechner, doch endlich konnte ich ein Schnäppchen machen und ein ganzes Set mit ZX-Spectrum, Joystickmodul, einem Datenrecorder und vielen originalen Spielekassetten erwerben. Die Aufbereitung und Restauration des ZX möchte ich hier kurz beschreiben. Wenn man einen Rechner mit unbekannter Vorgeschichte, der sicherlich die letzten 30 Jahre in irgendeinem Keller herumgelegen hat, in die Hände bekommt, so sollte man keinesfalls versuchen, ihn direkt in Betrieb zu nehmen. Falls er es nicht ohnehin schon ist, könnte das dann sein Tod sein. Denn wie immer gibt es darin einige Teile, die altern und ihre Parameter ändern können. Es könnte auch jemand vorher darin herumgebastelt haben um etwas zu reparieren oder umzurüsten.  In diesem Fall war das Gehäuse zwar staubig und schmutzig, aber es gab keine fehlenden Schrauben, Dellen oder von außen ersichtliche Nachrüstungen, wie Taster oder Stecker. Also konnte ich die Gehäuseschrauben lösen.

Die Tastaturfolie war schnell aus den Klemmbuchsen gezogen und der Deckel mit den Gummitasten entfernt. Jetzt offenbarte sich das Innenleben des Spectrum - und was soll ich sagen - 1A. Alles im Originalzustand. An dem Gerät wurden noch keine Reparaturen oder Basteleien durchgeführt. So begann ich zuerst mit der Reinigung der Gehäuseteile. Die Tastatur ist einfach zu zerlegen. Bei dieser Revision des Spektrums (ISSUE 4A) ist das Blech, das die Gummimatte im Gehäuse hält, mit vier "Messing Biegenasen" befestigt. Diese lassen sich leicht zurückbiegen und das Blech entfernen. 

Frontblech und Gummitastenmatte enfernt

freigelegte Tastaturfolie

Die Gehäuseteile waren jetzt ganz einfach zu reinigen. Ich habe sie mit Seife unter lauwarmem Wasser gespült. Auch die Rückstände zwischen den Tasten der Gummimatte ließen sich so leicht entfernen. Während die Teile jetzt zum Trocknen beiseitegelegt wurden, widmete ich mich dem Mainboard.

Mainboard des ZX-Spectrum 48K Issue 4A

Hier waren alle Lötstellen sauber, keine Spuren von Fremdeingriffen und alle Teile noch im Originalzustand. Also konnte ich direkt mit den ersten Prüfungen beginnen. Mit einem Ohmmeter wurde zunächst auf Kurzschlüsse im Bereich der Spannungsversorgungen geprüft. Wenn man sich die Schaltpläne des Spektrums ansieht, so kann man schnell erkennen, dass der Rechner mit einer Eingangsspannung von DC9V versorgt wird. Wobei hier die Belegung der Netzteilbuchse zu beachten ist. Hier ist der Plus-Pol nicht der innere Stift, sondern der äußere Ring des Steckers. Dies ist besonders wichtig, wenn das originale Netzteil nicht mehr vorhanden ist und man einen Ersatz nimmt. Der weitere Aufbau des Versorgungskonzeptes ist wie folgt: Aus den 9VDC wird über einen Linearregler 7805 die +5V Versorgung gemacht. Über eine DC/DC- Converter Schaltung bestehend im Wesentlichen aus den Komponenten TR4 und TR5 und einem kleinen Transformator (Zylinderspule mit zwei Wicklungen), werden eine 12VDC und weiters eine -5VDC Spannungsversorgung generiert.  Diesem Bereich gilt eine besondere Aufmerksamkeit, denn hier kann eine falsche oder fehlende Spannungsversorgung weitere Bauteile (insbesondere die DRAM-ICs) beschädigen. Dazu sind mit einem Dioden Tester die Transistoren auf ihr Durchlass- und Sperrverhalten der PN-Übergänge zu prüfen. Den kleinen Übertrager testet man am einfachsten mit dem Ohmmeter auf niederohmiges Verhalten der jeweiligen Wicklung und auf ein hochohmiges Verhalten zwischen Primär- und Sekundärwicklung. Ist hier alles in Ordnung testet man noch den Ausgang jeder der drei Spannungsquellen gegenüber dem Masse 0V Potential. Hier sind folgende Richtwerte zu messen:

• Eingang des Linearreglers (9V) gegen GND -> ca. 100k-150k
• Ausgang des Linearregler (+5V) gegen GND oder an Pin9 des RAM ICs -> ca. 300 - 500 Ohm
• Pin1 des RAM ICs (-5V) gegen GND -> ca. 300 Ohm (im 400Ohm Messbereich)
• Pin8 des RAM ICs (12V) gegen GND -> ca. 2.6k bis 2.8kOhm

Elektrolytkondensatoren erneuern

Im nächsten Schritt werden die über 30 Jahre alten axialen Elektrolytkondensatoren getauscht. Dies ist eine reine Vorsichtsmaßnahme, denn wie allseits bekannt, ändern diese Teile gerne ihre Werte mit der zunehmenden Alterung oder laufen aus. Und was ausgelaufene Elektrolyten so alles anrichten können, habe ich ja schon in älteren Beiträgen gezeigt. Um dem ZX also wieder ein längeres Überleben zu ermöglichen, werden alle Elkos getauscht.

die alten Elkos

Mainboard mit neuen radialen Elkos

Sind diese Arbeiten erledigt, dann beginnt jetzt der spannende Teil. Die Spannungsversorgung wird eingeschaltet. Am besten man versorgt den ZX über ein Labornetzteil mit einstellbarer Strombegrenzung. Er darf nach dem Einschalten nicht mehr als 750mA bei 9VDC nehmen. Passt auch das, können die Spannungen (am besten an einem der Lower RAM-ICs gemessen werden). Hierbei sollte an PIN1 -5V, an PIN9 +5V und an PIN8 12V gemessen werden.

Umbau des RF-Modulators auf Videoausgang

Um den ZX-Spectrum auch an ein Sichtgerät anschließen zu können, gibt es den RF-Modulator, der das intern generierte Composit-Videosignal auf einen UHF - Kanalträger moduliert, um damit einen klassischen analogen TV zu bedienen. Da Fernsehempfänger mit analogem Tuner mittlerweile kaum mehr vorhanden sind, aber viele TV zumindest einen SCART oder Videoeingang besitzen, wird der RF-Modulator des ZX-deaktiviert. Die ehemalige Antennenbuchse wird zu einem Videoausgang umfunktioniert. Zuerst werden die beiden Drähte, die aus dem Modulator herauskommen vom Mainboard abgelötet. (Dies sind +5V und CVBS).  Dann wird innen im Modulator der Pin des Widerstandes vom Innenleiter der Antennenbuchse abgelötet und weggebogen. Somit ist der Modulator von der Schaltung komplett getrennt. Jetzt muss nur mehr der CVBS Ausgang vom Mainboard über einen Kondensator an den inneren Stift der Buchse gelötet werden. Der Kondensator sollte dabei um die 100uF haben. Er dient als DC-Entkopplung des Signals.

Wenn das alles erledigt ist, dann kann jetzt angeschlossen und eingeschaltet werden. In meinem Fall war es ein voller Erfolg. Der Sinclair meldete sich sofort mit seinem grau hinterlegten Einschaltbild "(c) 1982 Sinclair Research Ltd"

Als nächstes versuchte ich ein altes Originalspiel (Backgammon) über den Kassettenrecorder (Datarecorder) in den ZX zu laden. Das klappte vorerst nicht. Manchmal wurde ein Teil geladen, dann wieder nicht und es kam zu "Tape Error" Meldungen. Also wurde der Kassettenrecorder auch noch schnell überholt. Ein neuer Riemen sorgte für einen besseren Gleichlauf des Bandes und eine Kopfreinigung für schönere Pegel des Ausgangssignals. Doch auch jetzt klappte das Laden noch nicht. (das erinnerte mich doch stark an die damalige Zeit, wo oft sehr lange versucht wurde ein Spiel zu laden) Also sah ich mir mit dem Oszi das Ausgangssignal an und vor allem die Periodendauer des Initalsignals (der erste Pfeifton am Band :) )

Einstellung der Bandgeschwindigkeit

Hier war es, das Problem. Die Frequenz des Initalsignals lag bei ca. 890-910Hz. Das bedeutet das Band läuft viel zu schnell. Das Problem ist schnell behoben. Fast jedes Kassettenlaufwerk hat ein kleines Poti mit dem man die Bandgeschwindigkeit des Servoantriebes einstellen kann. Auch so in diesem Fall. Die Frequenz sollte so um die 800Hz liegen. Das Ergebnis war dann folgendes:

 

Taschenrechner aus dem Jahr 1975: PICO PA-80N

Aus dem Jahr 1975 stammt dieser japanische Taschenrechner. Er wurde von 1975 bis 1976 von der Eduscho - Tchibo Kaffeekette verkauft. Das Gerät trägt die Bezeichnung "PICO" PA-80N. Genau dieses Modell  war auch einst im Besitz meines Vaters und ich war als Kind schon fasziniert von den leuchtenden Siebensegmentanzeigen. Und das war wieder das Problem. Soweit ich mich erinnern kann, war ich etwa im Volksschulalter, als ich das Gerät das erste mal in seine Einzelteile zerlegte. Das war ansich noch nicht das Problem, jedoch es blieb nicht dabei. Im Laufe der Zeit zerlegte ich den Rechner einige male. Irgenwann brachen dann Drähte ab und es funktionierte nichts mehr. Wieder zusammengebaut verwschwand der Pico dann in einem Kasten und wurde Jahre später von meinem Vater entsorgt. Warum ich den kleinen Rechner immer wieder auseinandernahm und zusammenbaute, kann ich heute nicht mehr sagen. Scheinbar war es das Erfolgserlebnis eines Achtjährigen, nach dem Zusammenbau wieder ein funktionierendes Gerät zu haben - eben bis zuletzt. :) Auf einer Online - Flohmarktplatform habe ich genau so einen Rechner gefunden und das noch dazu in einem TOP-Zustand und noch dazu fast geschenkt. Also musste ich ihn haben...

Pico mit dem Kunstleder Etui

Zu den Daten:

Das Display hat acht 7 Segment Ziffern (Digits), die auf LED-Technologie aufgebaut sind. Um die MikroLED´s auch ablesen zu können sind sie in einem konvex geformten Kunsstoff eingebettet. Damit wird ein Lupeneffekt erreicht, der die Ziffern ablesbar macht.

LED´s unter der konvexen Kunststoffvergußmasse

Das Gehäuse besteht aus Aluminium und Kunststoff und hat die Abmessungen inetwa einer Zigarettenschachtel. 8.2 x 5.7 x 2.4 cm. Um den Rechner schonend aufbewahren zu können, gab es ein Kunstleder Etui dazu.

Mainboard des PICO

Angetrieben wird der Rechner von zwei Tripple A (AAA) Batterien, also mit 3V. Optional gab es dazu auch ein extenes Netzteil das lt. damaliger Preisliste um knapp 18DM erworben werden konnte. (leider keine Preisinformationen für Österreich)

Netzteilbuchse an der Oberseite

Technisch betrachtet besteht der kleine Rechner aus einer Display-Platine, einem "Mainboard" und einer Tastaturplatine. Diese Platinen sind untereinander mit einer mehrpoligen Stegleitung verbunden. Diese sollte nicht all zu oft gebogen werden, da dann schnell einzelne Drähte abbrechen...

Aufgeklappte Platinen

Die Displayplatine wird von einem Toshiba T1337 Displaydriver IC angesteuert und der Rechner selbst, ist ein GI C593 (General Instruments) Prozessor, der die Grundrechenarten und Prozentrechnung beherrscht.  Der Prozessor arbeitetmit einer Versorgungsspannung con 15-17VDC und ist imstande Floureszentdisplays direkt zu treiben. Um in dem kleinen Pico Rechner aus den 3V der AAA Batterien auch die 17VDC zu erzeugen abeitet ein kleiner DC/DC Converter am Mainboard.

Prozessor

Displaytreiber

Datenblatt des C593 (Quelle: 1977 Datacatalog GI Microelectronics)

DC/DC Converterschaltung für die 17V der CPU

Neben dem Kunstleder Etui gab es auch noch eine Karte mit einer Bedienungsanleitung und einen Flyer. Der war mit Garantiehinweisen und einem Werbespruch bedruckt:

„Der Pico wird für Sie zum unentbehrlichen Rechenhelfer werden. In der Schule, im Haushalt, im Beruf - überall wo es was zu rechnen gibt, ist der Pico schnell zur Hand. Einfach Tasten drücken, und schon haben Sie die kompliziertesten Aufgaben ausgerechnet. So wird Rechnen zum Vergnügen!“(Quelle:Internet)

Datenknoten mit Arduino

Leider sind die Abstände, in denen ich einwenig Zeit finde, einen neuen Beitrag für den Blog zu schreiben, nicht kürzer geworden. Aber einen Beitrag pro Monat zu posten, halte ich ein... :)

Dieses Mal ist es kein retro Bastelprojekt aus den heimischen Gefielden oder eine Restauration eines alten Gerätes, sondern wieder etwas zum Thema Arduino. Die Idee - es soll ein Sensor gebaut werden, der wie immer, eine physikalische Größe in ein elektrisches Signal umwandelt. Das ist jetzt nichts Besonderes und um welche Art von Sensor es sich handeln wird, werde ich vorerst noch nicht beschreiben. Aber es soll nicht ein Sensorboard geben, sondern viele. Und diese Sensorboard kurz "Sensoren" sollen in einer zweidimensionalen Matrix miteinander vernetzt werden. Man kann sich das inetwa vorstellen wie ein Schachbrett, wobei jedes der Schachbrettfelder einen Sensor darstellt. Dieses Netzwerk an Sensoren - also Sensorknoten - soll dann über eine Übergabestelle mit einem Rechner verbunden sein und die Sensordaten des jeweiligen Feldes ausgeben. Es soll dann auch möglich sein, einzelne Felder aus dem Netzwerk zu entfernen ohne dass das verbleibende Netzwerk seine Funktion verliert.

Das ganze System soll möglichst einfach und günstig aufgebaut werden. Und so ist schnell ein Systemkonzept entstanden, in dem die Knoten über den I²C Bus kommunizieren und ihre Daten zu einem Master senden. Das folgende Diagramm soll das verdeutlichen.

Dieses Konzept, so dachte ich mir, lässt sich am einfachsten mit einem ATmega Microcontroller realisieren. Der hat genügend IO´s, einen I²C Bus und UART onboard, ebenso auch analoge Eingänge und benötigt wenig Bauteilperipherie, um ihn in einem eigenen Layout zum Leben zu erwecken. Und es gibt nichts schnelleres, so einen Testaufbau eines solchen Knotennetzwerks zu realisieren, als die gut bekannten Arduino Developmentboards zu benutzen. Ich habe die günstigste Variante für einen Testaufbau gewählt -> den Chinanachbau vom ArduinoUno (Joy-IT UNO) mit dem Atmga328 im gesockelten DIL Gehäuse.

Joy-It Uno Boards

Im Bild sind zehn Stück dieser Microcontrollerboards zu sehen. Von denen soll einer als Bus-Master und neun Stück als Slaves eingesetzt werden. Jeder dieser Slaves hat natürlich eine eindeutige Bus-Adresse, die im System nur einmal vorkommt. Im Testaufbau wird diese Busadresse über den Programmcode fest vergeben, da ohnehin jeder Arduino einmal mit dem Rechner verbunden werden muß, um den Programm-Upload durchzuführen. Das soll natürlich später anders aussehen. Denn der Arduino wird auf den Atmega328 Chip, seinen Quarz und die paar Widerstände reduziert auf dem Sensorboard mit gelayoutet. Programmiert soll der Chip dann über die ISP Pins werden. Da bei vielen Boards natürlich nicht jedes Mal der Programmcode individuell angepasst wird und alle das gleiche Flashfile erhalten sollen, will ich die Sensoradresse mit einem 7Bit Dipschalter einstellen. Ein 4021 Cmos  Static Shift Register soll die Bits nach nach dem Einschalten des Controllers auslesen und seriell in den Controller schieben. Der daraus resultierende Wert steht dann in einer Variable als Busadresse zu Verfügung.

Jeder dieser Slaves mit seiner individellen Busadresse wird nun vom Masterknoten der Reihe nach abgefragt, welchen Zustand er hat und ob er einen Ausgang schalten soll, oder nicht. Das bedeutet, der Knoten hat lediglich einen DO (Digitalen Ausgang) mit dem er beispielsweise eine LED aus- und einschalten kann und einen oder mehrere DI (Digitalen Eingang) der einen Zustand, zum Beispiel eines einfachen Schalters abfragt. Diese Funktionen werden in 2 Bits eines Bytes gespeichert. Ein weiteres Byte dient zur Übertragung der Busadresse. Es werden also zwei Bytes über den Bus geschickt. Das untenstehende Bild zeigt den Testaufbau mit den "UNO-Boards"

Alle Arduinos sind mit I²C Datenbus und Spannungsversorgung verbunden

MASTER:Der Masterknoten sendet nach der Reihe an alle Slave-Adressen eine Anfrage und einen Schaltbefehl (der kommt für alle Knoten von einem TEST-Tastereingang am Master) für den LED-Ausgang des Knotens und sieht ob eine Antwort zurückkommt oder nicht. Wenn keine Antwort kommt, ist der Knoten nicht im Netz oder defekt. Kommt eine Antwort, so besteht diese aus der Adresse des Knotens und seinem Statusbyte. Diese Informationen werden über ein RS232 Terminal an den, am Master angeschlossenen Rechner übertragen. So kann dort beispielsweise über eine Visualisierung mittels (NI LabView, oder Matlab o.ä.) der Schaltzustand jedes einzelnen Knotens  am Bildschirm angezeigt werden. Mit einer Anpassung des MasterProgrammes ist es auch möglich, die LED-Ausgänge der Slaves über den Rechner zu schalten.

SLAVE:
Wenn der Masterknoten vom Slave Daten anfordert, so sendet der Slave zwei Bytes zurück. Wobei Byte0 wieder die Slave ID (also Busadresse ist) und Byte1 die Daten. Byte1 besteht eigentlich aus nur zwei Bit, die wie folgt kodiert sind (in dezimaler Darstellung):
 0 = LED aus | Sensor nicht ausgelöst
 1 = LED ein | Sensor nicht ausgelöst
 2 = LED aus | Sensor ausgelöst
 3 = LED ein | Sensor ausgelöst

Der Programmcode als Beispiel:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

// I2C Slave Code // 16.05.2018 // ver 1.3 #include <Wire.h> #define ADDRESS 2 // adresse des slave knotens #define PAYLOAD_SIZE 2 // anzahl der bytes die vom masterknoten zu erwarten sind int LED=12; // indicator led an pin D12 int SENSOR = 8; // sensor input an pin D8 bool actionState=0; // sensor zustand int busstatus; // statusvariable // 0 = LED aus | sensor nicht belegt // 1 = LED ein | sensor nicht belegt // 2 = LED aus | sensor belegt // 3 = LED ein | sensor belegt bool sensled=0; // sensor LED byte nodePayload[PAYLOAD_SIZE]; void setup() { pinMode(LED, OUTPUT); //sensorLED pinMode(SENSOR, INPUT); //Sensor Wire.begin(ADDRESS); // Activate I2C network Wire.onReceive(receiveEvent); Wire.onRequest(requestEvent); // auf master anforderung warten // // debug interface // Serial.begin(9600); } // *********************************mainloop**************************************************** void loop() { delay(5); if(sensled){digitalWrite(LED, HIGH);} else{digitalWrite(LED, LOW);} actionState = digitalRead(SENSOR); //Sensoreingang abfragen if((actionState==1)&&(sensled==1)) {busstatus=3;} else if ((actionState==0)&&(sensled==1)) {busstatus=1;} else if ((actionState==1)&&(sensled==0)) {busstatus=2;} else if ((actionState==0)&&(sensled==0)) {busstatus=0;} // Serial.println("######################"); // Serial.print("busstatus neu setzen "); // Serial.println(busstatus); // Serial.print("sensled LED "); // Serial.println(sensled); // Serial.print("actionState "); // Serial.println(actionState); // Serial.println("######################"); nodePayload[0] = ADDRESS; // Adresse in byte0 zurücksenden. nodePayload[1] = busstatus; //byte 1 ist die statusinfo der LED } // ********************************************************************************************* void requestEvent() { Wire.write(nodePayload,PAYLOAD_SIZE); Serial.println("bytes status schreiben"); Serial.println(nodePayload[0]); Serial.println(nodePayload[1]); delay(5); } // ********************************************************************************************* void receiveEvent(int bytes) //einen wert vom I2C lesen { busstatus = Wire.read(); //If the value received was true turn the led on, otherwise turn it off // Serial.println("status empfangen"); // Serial.println(busstatus); if((busstatus==1)||(busstatus==3)){sensled = 1;} else{sensled = 0;} }

 

Die Busadresse ist in diesem Slave-Code noch individuell einzugeben. In der nächsten Version ist dann der vorherbeschriebene "Serializer" der parallelen Dip-Schaltervariante implementiert. Das folgende Codebeispiel ist von Masterknoten, der die Slaves ausliest und mittel Prüftaster ein LEDmuster an die Sensorslaves sendet:

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119

// I2C masterknoten // 16.05.2018 // ver 1.2 // changes abfrage wenn kein knoten am bus dann 255 ausgeben #include <Wire.h> #define busbytes 2 // wievele byte vom I2C knoten zu erwarten sind #define maxKNOTEN 10 // anzahl der zu scannenden slaves #define startKNOTEN 2 // startadresse der slaves #define DELAY 5 // einfach ein delay .... int i; int j=0; int buttonPin = 12; int testbut = 0; int anim = 0; int buttonState = 0; int DATEN[busbytes]; int adresse; int busstatus; byte sensorbelegt; byte ledsensoron; // 0 = LED aus | Sensor nicht belegt // 1 = LED ein | Sensor nicht belegt // 2 = LED aus | Sensor belegt // 3 = LED ein | Sensor belegt int leddat1[] = {1,1,1,1,0,1,1,1,1}; // - int leddat2[] = {0,0,0,0,1,0,0,0,0}; // | void setup() { Serial.begin(9600); Serial.println("MASTER-KNOTEN"); Serial.print("Maximum Slaveknoten: "); Serial.println(maxKNOTEN); Serial.print("Datengroesse in byte: "); Serial.println(busbytes); Serial.println("***********************"); Wire.begin(); // Activate I2C link pinMode(buttonPin, INPUT); // test-tastereingang festlegen } //##################################################################################################### void loop() { for (int Knotenadresse = startKNOTEN; //alle knoten scannen Knotenadresse <= maxKNOTEN; Knotenadresse++) //################################################################################################ { // testbut = 0; anim = 0; Wire.requestFrom(Knotenadresse, busbytes); // daten vom jeweiligen knoten anfordern DATEN[0]=255; DATEN[1]=255; // wenn kein knoten dann auf 255 setzen if(Wire.available() == busbytes) { // wenn knoten und daten dann for (i = 0; i < busbytes; i++) DATEN[i] = Wire.read(); // daten holen (zuerst busID, dann daten) // for (j = 0; j < busbytes; j++) Serial.println(DATEN[j]); // daten an rs232 ausgeben } // Serial.println(Knotenadresse); // Serial.println(DATEN[0]); // Serial.println(DATEN[1]); // Serial.println(" "); adresse=DATEN[0]; busstatus=DATEN[1]; if(busstatus == 0) {sensorbelegt=false; ledsensoron=false;} else if (busstatus == 1) {sensorbelegt=false; ledsensoron=true;} else if (busstatus == 2) {sensorbelegt=true; ledsensoron=false;} else if (busstatus == 3) {sensorbelegt=true; ledsensoron=true;} //################################################################################################ //Testbutton Status lesen und variable testbut entsprechend setzen buttonState = digitalRead(buttonPin); //tastereingang einlesen if(buttonState == HIGH){ //wenn taster aktiv dann variable anim setzen anim = 1; //delay(5); } // //debug debuginfo tasterstatus auf rs232 ausgeben // Serial.println("#######################"); // Serial.print("Knoten Adresse :"); // Serial.println(adresse); // Serial.print("Busstatus :"); // Serial.println(busstatus); // // Serial.println("----------------"); // Serial.print("Fliese belegt :"); // Serial.println(sensorbelegt); // Serial.print("LED Fliese :"); // Serial.println(ledsensoron); // Serial.print("#######################"); // Serial.println(" "); //################################################################################################ //Testbutton Status an jeweiligen knoten senden Wire.beginTransmission(Knotenadresse); // transmit to device actual in for loop //anim schreiben if (anim==0) {testbut=leddat1[j]; j++;} else {testbut=leddat2[j]; j++;} if (j>8){j=0;} Wire.write(testbut); // senden des tasterstatus Wire.endTransmission(); // ende gelände mit uerbertragung delay(DELAY); } }

 

Mit dieser Anordnung ist es jetzt möglich alle Arduinos und deren Eingang auszulesen bzw. die LED über den Bus zu steuern. Im nächsten Schritt wird ein "Sensor" gebaut, eine Platine gelayoutet und der ArduinoUno auf seinen Microcontroller reduziert. Darüber werde ich in einem der nächsten Posts berichten...