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

vergilbter C64

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.

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.

Quecksilberzeitschalter

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:

 

Hier ist das Programm aus mp3 Datei: Backgammon

 

Kleines Bastelprojekt zur Sommerzeit

Solarmodul

Als Mini – Bastelprojekt zur Sommerzeit bezeichne ich folgende Bastelei. Ein kleines monokristallines Solarmodul mit der Bezeichnung „SM 6“ von einem bekannten, großen Elektronikdistributor der mit „C“ beginnt und mit „d“ endet, spielt in dem Projekt die Hauptrolle. Das Modul hat eine Nennleistung von 6Wp bei einem maximalen Strom von 320mA. Die Nennspannung liegt bei 17,3V. Die Leerlaufspannung beträgt 20,8V. Die Siliziumzellen sind in einer EVA (Ethylen-Viny-Acetat) Kunststoffplatte eingebettet und UV-und feuchtigkeitsbeständig. Das ganze Modul ist ca. 25cm x 25 cm groß. Es ist also ideal geeignet, um die Energie zum Betreiben von USB-Geräten bereitzustellen. Hierbei habe ich zum Beispiel an WIFI-IP-Cams gedacht. Auch das Laden von Smartphones ode Tablets sollte damit möglich sein.

Um das nun auch durchführen zu können, muss aus der Nennspannung der Photovoltaikzelle die Betriebsspannung des USB-Standards (5V) erzeugt werden. Das könnte man jetzt ganz einfach mit einem 7805er Regler machen und die Differenz dabei in Wärme umwandeln. Doch das ist die, so ziemlich ineffizienteste Möglichkeit, die Energie des Panels in ein Handy zu bekommen.
Zum einen ist der Innenwiderstand des Panels von der Lichtintensität abhängig, was einen großen Einfluss auf den Wirkungsgrad bei nicht angepassten Lastwiderständen hat. Zum anderen ist ein Längsregler ein Energievernichter, da die Differenz zwischen Eingangsspannung und geregelter Ausgangsspannung bei Stromfluß in Verlustleistung, also Wärme umgewandelt wird. Hier ist man mit einem Schaltwandler (Buck-Converter) besser bedient.
 
In einem einfachen Laboraufbau kann das Verhalten des Panels untersucht werden. Dazu wird die Leerlaufspannung des Panels bei unterschiedlicher Beleuchtungsstärke gemessen. Anschliessend wird das Panel mit unterschiedlichen Widerstandswerten belastet und der Strom durch die Last, sowie die Spannung am Panel gemessen. Die Messwerte werden aufgezeichnet und der Ri (Innenwiderstand der Quelle) berechnet. Der nachfolgende Stromlaufplan zeigt den Messaufbau:
Messaufbau – Schaltung
Als Amperemeter dient ein Agilent- und als Voltmeter ein Keithley 2701 Tischmultimeter. Diese Messgeräte können beide über SCPI-Befehle gesteuert werden. Als Schnittstelle ist  jeweils ein LAN-Port vorhanden. Das macht es einfach, über einen PC und ein geeignetes Script, einen automatisierten Messablauf zu realisieren. Und da Matlab eine sehr bequeme Möglichkeit bietet, zu scripten, wird es auch gleich verwendet. Um in einem Labor messen zu können und in etwa die selben Umgebungsbedingungen zu haben, wird anstelle der Sonne eine Tischlampe mit Halogenglühbirne verwendet. Die Helligkeit der Lampe wird einfach durch die Versorgung mit einem Labornetzgerät von 0-13V eingestellt. Natürlich kann auch das Labornetzgerät per Matlab gesteuert werden.
Messaufbau mit Lampe als „Sonne“

Die Lampe ist in einem Abstand von 25cm mittig über dem Panel platziert. Um ein Gefühl zu bekommen, welche Beleuchtungsstärke mit der Lampe erreicht wird, wird mit einem Luxmeter eine Referenzmessung gemacht. Das heißt, die Lampe fährt die Leistungsrampe von 0-13V durch und das Luxmeter misst die Beleuchtungsstärke im Abstand von 25cm unter der Lampe. Das Ganze wird in 0.5V Schritten aufgelöst. Daraus ergibt sich eine Kurve, die so aussieht:

Spannung an der Lampe ergibt Beleuchtungsstärke

Jetzt kann die Messung beginnen. Als Lastwiderstand werden manuell Widerstände an das Panel geschaltet und Strom und Spannung bei jeder Helligkeitsstufe gemessen. Es sind elf Lastwiderstandswerte die von 4.7 Ohm bis 220 Ohm reichen nacheinander angeschlossen. Eine Leerlaufmessung wird dann natürlich ohne Lastwiderstand gemacht. Folgender Graph zeigt den errechneten Innenwiderstand bei zwei Lasten des Panels über den Helligkeitsverlauf der Lampe in Lux und im weiteren Graph über die Spannung an der Lampe(für die bessere Skalierung). Den Innenwiderstand einer Quelle errechnet man aus der Leerlaufspannung der Quelle abzüglich der Spannung unter Last, dividiert durch den Strom. Mit der Differenz der Leerlauf und Lastspannung erhält man also den Spannungsabfall am Innenwiderstand. Da im Lastfall auch der Strom bekannt ist, braucht man nur mehr das Ohm´sche Gesetz anzuwenden, um den Widerstandswert zu erhalten…

Innenwiderstand vs. Beleuchtungsstärke
Innenwiderstand vs. Spannung an der Lampe

Da jetzt einige Klarheiten über das Verhalten der PV-Zelle beseitigt wurden, kann ich noch kurz über den Aufbau des Spannungswandlers berichten. Wie schon zuvor angekündigt, ist ein Schaltwandler der effizientere Weg, die Energie an den Verbraucher anzupassen. Hier kommt ein LM2596S zum Einsatz. Der LM 2596 ist ein „Simple Switcher Power Converter, der mit 150kHz schaltet und ein Last mit 3A versorgen kann.) Hier eine Übersicht der Funktionen:

  • 3.3-V, 5-V, 12-V, and Adjustable Output Versions
  • Adjustable Version Output Voltage Range: 1.2-V to 37-V ± 4% Maximum
    Over Line and Load Conditions
  • Available in TO-220 and TO-263 Packages
  • 3-A Output Load Current
  • Input Voltage Range Up to 40 V
  • Excellent Line and Load Regulation Specifications
  • 150-kHz Fixed-Frequency Internal Oscillator
  • TTL Shutdown Capability
  • Low Power Standby Mode, IQ, Typically 80μA
  • Uses Readily Available Standard Inductors
  • Thermal Shutdown and Current-Limit Protection

(Quelle: Datenblatt des Herstellers TEXAS Instrument)

Mit diesem Schaltwandler und noch ein paar wenigen anderen Komponenten lässt sich schnell eine Schaltung zusammenzimmern und mit dem Layouttool „Eagle“ in eine Platine verwandeln. Diese Schaltung ist aber so einfach aufgebaut, dass sie lediglich mit den Vorzügen des LM2596 möglichst effizent arbeitet, aber kein Powertracking durchführt. Das heisst, die Last, die die Schaltung für die Solarzelle darstellt wird nicht an den Innenwiderstand der Solarzelle angepasst.

 

Schaltbild des DC-DC Converters

Aus dieser Schaltung wurde dann ein einfaches Layout erstellt, eine Platine geätzt und diese bestückt. Eine USB-Buchse am Ausgang ermöglicht das direkte Ansschliessen von USB-Geräten. Um das Ganze auch einwenig vernünftig aussehen zu lassen habe ich der Platine noch ein kleines Kunsstoffgehäuse gespendet…

Messung der Beleuchtungsstärke

Messaufbau
Schaltbare Lastwiderstände
Layout am Computer
Folie zum Erstellen der Printplatte
Geätzte PCB
Bestückte PCB
Fertige Schaltung

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.
Siebensegment – Anzeige mit 8 Digits

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
DC/DC Converterschaltung für die 17V der CPU
Datenblatt des C593 (Quelle: 1977 Datacatalog GI Microelectronics)
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

Der Ablauf läuft wie folgt:

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…

 

 

 

Solar – Radiometer

Der/das Radiometer – auch Lichtmühle genannt – ist ein lehrreiches, physikalisches Demonstrationsobjekt, das schon vor ca. 100 Jahren von dem englischen Physiker Crookes erfunden wurde. Dieses kleine pyhsikalisch-technische Anordnung zeigt in anschaulicher Weise, wie Licht in mechanische Energie umgewandelt wird.

 

Die Funktionsweise des Solar-Radiometer:

Flügelrad im inneren der teilevakuierten Glaskugel

Trifft warmes Licht, also Sonnenlicht, Licht von Glühbirnen oder Punktstrahlern, eben Licht in dessen Spektrum auch der infrarote Anteil vofhanden ist (aber kein kaltes Licht von Leuchtstofflampen) auf das, auf einer Nadel ruhende Flügelkreuz, so dreht sich dieses je nach Stärke der Lichtquelle. In einem besonderen Verfahren wird in der Glaskugel ein Teilvakuum erzeugt, so dass der Luftwiderstand nicht stärker als die, durch die Lichtenergie erzeugte Drehkraft des Flügelrades ist. Die geschwärzten Flächen des Flügelkreuzes nehmen mehr Lichtenergie auf, als die hellen Flächen. Durch die Erwärmung der Luftmoleküle entsteht an den dunklen Flächen ein wesentlich höherer Druck als an den hellen Flächen. Dadurch wird die ständige Rotation des Flügelkreuzes bewirkt. (Brownsche Molekular-Theorie). Es sollen je nach Lichtstärke bis zu 3000 Umdrehungen pro Minute erreicht werden. (Quelle: Hersteller des Radiometer)

 

Temperatursensor für IV-11 DCF melody

Ein Funktionsupdate für die IV-11 DCF melody Uhr ist von gr-projects erhältlich. Es handelt sich dabei um einen Funktemperatursender. Das besondere daran ist, dass der im ISM-Band 433MHz arbeitende Sender mit einer Photovoltaikzelle (Solarzelle) ausgestattet ist. Je nach Ausführung kann im Sender ein kleiner Akku oder eine CR2032 Knopfzelle verbaut werden. Die Batterie wird so bei Sonneneinstrahlung von der Solarzelle gestützt bzw. in der Akkuversion wird dieser tagsüber geladen und hält den Sender dann über die dunkle Zeit weiter in Betrieb.

Der Zusammenbau ist einfach. Der Bausatz besteht aus einem Sender und einem Empfänger. Die Platinen von Sender und Empfänger sind mit wenigen Bauteilen schnell bestückt. Hier ist aber doch etwas Aufmerksamkeit gefragt und man sollte die Dokumentation sorgfältig lesen, denn aufgrund der geringeren Stückzahl der Bausätze werden die Platinen ohne Bauteilaufdruck und Lötstoplack gefertigt.

Sendermodul

Die Funkmodule selbst sind vollständig vorbestückt (SMD) und müssen nur mehr in die entsprechenden Platinen eingelötet werden. Dem Temperaturfühler (NTC) kann zu Abgleichzwecken optional ein Trimmpotentiometer parallel geschaltet werden. Der Sender wird, wie auch der Empfänger, in ein kleines PVC-Gehäuse eingebaut. Hier sind ausser einem 3mm Bohrloch und ggf. etwas Silikon für die Abdichtung der Solarzelle (für den Betrieb aussen am Fenstersims) keine weiteren Werkzeuge von Nöten.

Sender mit Solarzelle

Um den Empfänger mit der Uhr zu verbinden, sind am Mainboared der Uhr ein paar kleine Änderungen durchzuführen. Zum einen wird der Microcontroller getauscht – logisch – denn es gibt ja ein neues Programm, das in der Datumszeile dann auch die Temperatur anzeigt. Ein Widerstand wird entfernt, einer kommt hinzu und ein Jumper kann gegen eine Brücke getauscht werden. Die Verbindung zwischen dem Mainboard der Uhr und dem Funkempänger wird mit einem Stück Kabel hergestellt. Drei Leitungen sind erforderlich (GND, +5V und das Datensignal vom Empfängercontroller zum Uhrencontroller). Das war´s dann auch schon. Die Uhr kann in Betrieb gehen. Nach einigen Sekunden wird die empfangene Temperatur in der Röhre angezeigt.

Empfängerplatine im Gehäuse

 

Ein Video über den Aufbau der Schaltung gibt es hier:

USB – Stick defekt?

 

Immer wieder passiert es mir, dass ein USB – Speicherstick seine Funktion verliert und plötzlich nicht mehr erkannt wird. Oft ist der Stick noch als Laufwerk im System angemeldet, aber es fehlt der Datenträger, oder auch das System meldet, dass der Stick nicht formatiert ist. Und das obwohl er gerade eben noch, voll mit wichtigen Daten, in einem anderen Rechner funktioniert hat. 🙂  (Hier würde jetzt die Geschichte mit den Backups oder Sicherungskopien herpassen… ). All diese Probleme sind meist auf Bedienungsfehler oder mechanische Probleme zurückzuführen. Ein Bedienungsfehler kann beispielsweise sein, dass der Stick gezogen wird, während noch ein Schreibvorgang stattfindet. Der Stick wird dann während eines Prozesses stromlos gemacht. Und je nach dem, ob der Controller oder der Flash-Speicher damit umgehen kann, überlebt der Stick oder eben nicht. Oft sind auch mechanische Gebrechen die Ursache für Ausfälle. So kann es sein, dass die Lötstellen zwischen dem Connector und der Platine brechen, oder auch die Anschlussbeinchen der Quarze oder Oszillatoren  Kontaktprobleme bekommen.

In diesem Fall habe ich einen Miniaturstick von extrememory bekommen, der seine gespeicherten Daten nicht mehr hergeben will. Er wird in der Systemverwaltung zwar angezeigt, aber will man darauf zugreifen, kommt die Meldung „kein Datenträger gefunden“. Der Versuch über diskpart aus der Commandline zu formatieren oder zu partitionieren klappte nicht. Auch diverse Tools wie „SDFormatter“ oder „USBstick_Formattool“ schlugen fehl. Auch mit Linux oder auf MAC-Systemen war kein Erfolg zu erzielen. Also ein Stick für die Tonne… Aber ich dachte mir, auch wenn der Stick in seiner kleinen Bauform eher nicht auf einen mechanischen defekt schliessen lässt – warum nicht trotzdem mal reinschauen 🙂 Und bei 16GB gebe ich auch nicht so schnell auf.

Also versuchte ich das Gehäuse vorsichtig zu öffnen, indem ich zuerst das Metallgehäuse des USB-Steckers entferne.

Das klappt ganz gut. Nachdem ich das zum Vorschein gekommende Platinchen mit seinen Leiterbahnen näher betrachten wollte, tauchte da plötzlich etwas Bekanntes auf.

Das sieht doch aus wie eine SD-Karte. Genauer gesagt, wie eine MicroSD-Karte.

Genau so war es auch. Der USB-Stick ist nichts anderes als ein MicroSD-Card Reader, in den eine solche Karte eingebaut ist. Mit einer Pinzette ließ sich die SD-Card heraushebeln.

Scheinbar ist auch hier wieder das Problem mit den Kontakten, bzw. Kontaktfedern zwischen Card und Cardreader die Ursache für das Problem, denn die SD-Card funktionierte in einem anderen Cardreader einwandfrei und alle Daten waren vorhanden. Es zahlt sich also aus, vor der Mülltonne ein paar Minuten zu investieren und die Innereien des Gerätes zu begutachten.

DAT-Walkman Sony TCD-D3

Sony TCD-D3

Zumindest einen Blog-Beitrag pro Monat zu schreiben habe ich mir zum Ziel gesetzt, auch wenn es nicht immer ganz einfach ist, dies zeitlich auch umzusetzen. Jeder der selber kleine Kinder hat, kann sich das vielleicht vorstellen. Doch abends und zwischendurch kann ich Material sammeln und es bearbeiten. -> es dauert eben nur alles viel länger. Diesmal habe ich zum Thema Retro-Audio einen Sony DAT-Recorder organisiert. Es ist ein Sony TCD-D3 aus dem Jahr 1990-91, ein sogenannter DAT Walkman.

Das DAT (Digital Audio Tape) ist ein Audio-Magnetband, auf das digital aufgezeichnet wird. Das Aufzeichnungsformat und die die Tonqualität sind im Wesentlichen mit dem der Audio-CD zu vergleichen. Die Aufzeichnung erfolgt auf kleine Kassetten, die auch im Storagebereich in der EDV eingesetzt wurden (DDS-Bänder). Das DAT Format war als Nachfolger der Audiokassette vorgesehen, konnte sich auf dem breiten Markt nicht durchsetzen. Es wird hier auch diskutiert, dass die Musikindustrie das Format nicht in der Consumerwelt sehen wollte, da es mit dem System möglich sei, digitale, verlustfreie Kopien herzustellen.

Vom technischen Aufbau entspricht das Kassettenlaufwerk dem eines Videorecorders. Das Band wird mit Ladearmen aus der Kassette gezogen und um einen rotierenden Kopf (DAT-R) geführt. Die Aufzeichnung erfolgt im Schrägspurverfahren. Das Exemplar, das ich diesmal als „defekt“ erworben habe, wurde mit dem Defekt: Kassettenschacht öffnet nicht, beschrieben. Nach der Demontage fiel mir auf, dass ich nicht als erster das Innenleben des Gerätes nach der Fabrik betrachten durfte. Da hat schon jemand herumgebastelt. An allen (Tantal)Kondensatoren wurde gelötet, die Zuleitungsdrähte zu den Batteriepolkontakten war „abgezwickt“ und die Drähte fehlten. Der Flexiprint, der das Front-Bedienteil mit dem Mainboard verbindet hatte bei genauer Betrachtung eine gebrochene Leiterbahn.

reparierte Leiterbahn

Die gebrochene Leitung ließ sich durch vorsichtiges Abkratzen der Isolation und Auflöten einer Litze reparieren. Die Kondensatoren habe ich alle neu verlötet und natürlich vorher überprüft. Hierbei ist mir aufgefallen, dass einige nicht anständig verlötet waren und an einem Pol eine kalte Löststelle hatten bzw. gar nicht mit dem Pad verbunden waren. Auch die Batterikontakte wurden mit neuen Drähten versehen. Auf dem Mainboard befindet sich auch noch ein DC/DC Converter, der aus den 9V Eingangsspannung die Versorgungsspannungen für die Logik und die Audiokomponenten macht. (5V +/-7V). Dieser Converter ist in einer vollständig verlöteten Weissblechbox untergebracht. Hier war natürlich noch niemand drinnen und hat die darin befindlichen Elkos überprüft. Das war dann auch recht schnell gemacht und die kleine Box überholt. Jetzt konnte ich die Platinen und das Laufwerk provisorisch wieder zusammenstecken und in Betrieb nehmen. Als Datenträger verwendete ich eine DDS (Storage) Kassette. Also Spannung drauf´ und „Eject“ gerdrückt und siehe da, das Kassettenfach öffnet auf Anhieb. Von meinem Handyaudioplayer als Musikquelle machte ich eine Probeaufnahme. Und was soll ich sagen, eine wunderbare Tonqualität!

Das nächste zu behebende Problem ist eher optischer Natur. Es handelt sich hier um die Seitlichen Gehäuseteile, die mit einer Gummierung überzogen sind und diese beginnt sich scheinbar chemisch zu verändern und wird klebrig. So habe ich diese Gummierung vorsichtig mit Isopropanol abgewaschen und versucht, die weis bedruckte Beschriftung nicht mit abzulösen. Das klappte ganz gut. Mit Acrylklarlack habe ich die Teile dann lackiert.

lackierte Seitenteile

Nach der Aushärtung des Klarlackes konnte ich wieder alles zusammenbauen und den finalen Test starten. Die folgenden Bilder zeigen das Innenleben des  TCD-D3.

Spezifikationen des TCD-D3

  • Type: Digital Audio Tape Dec
  • kTonspuren : 2-channel stereo
  • Bandgeschwindigkeit: 4.075, 8.15 mm/s
  • Aufzeichnungsdauer: 240 minutes
  • Kopfsystem: 2000rpm, rotary
  • D/A Converter: 16 bit linear
  • A/D Converter: 16 bit linear
  • Samplefrequenz: 32-48kHz
  • Frequency Response: 20Hz to 22kHz
  • Signal to Noise Ratio: 90dB
  • Dynamic Range: 90dB
  • Total Harmonic Distortion: 0.0008%
  • Analogeingang: 80mV (line), 0.25mV (mic)
  • Analogausgang: 0.5V (line)
  • Abmessungen: 85.2 x 40 x 120.1mm
  • Gewicht: 0.42kg