Archiv der Kategorie: Elektronikbastler

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

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…

 

 

 

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:

Sony Video8 Walkman GV-8E

Sony GV-8E

Gelegentlich stöbere ich auf Flohmarkt Webseiten nach Vintage- und Retrogeräten aus den 70er, 80er und 90er Jahren. Wenn ein absolutes Schnäppchen in Sicht ist, dann schlage ich zu und opfere ein paar Euro. Dieses Mal habe ich eine ganze Kiste mit portablen Medienwiedergabegeräten der Marke Sony gefunden. Das Ganze hat mich gerade einmal den Gegenwert einer Packung Cafe gekostet. Allerdings ist auch der Zustand der Geräte, was die Funktion betrifft, unbekannt. Ein besonders schönes Stück (ja – das liegt immer im Auge des Betrachters) aus dieser Kiste ist der Videowalkman GV-8E von Sony. Das ist ein portabler, analoger Video Player/Recorder, der einen VHF/UHF Fernsehtuner und einen LCD Monitor in einem Gerät integriert hat. Das mag zwar heute nichts Aufregendes mehr sein, jedoch war der GV8E zur Markteinführung 1988 ein sehr schönes und teures Stück Technik. Also landet der Portable auf meinem Tisch und bekommt vom Netzteil seine 6V DC Versorgung. Die Ernüchterung kommt dann auch so schnell wie die anfängliche Euphorie. Das Gerät zeigt trotz aufrechter Energieversorgung keinerlei Funktion. Es reagiert auf keinen Tastendruck, es leuchtet keine Led. (Irgendwie habe ich das auch schon so oder ähnlich erwartet)

Doch der Ehrgeiz ist zu groß, nicht doch einmal in das Innere des Gerätes zu blicken und nach dem Problem Ausschau zu halten. Schnell habe ich mit dem Zerlegen begonnen und das Gerät einmal grob ein seine Komponenten aufgeteilt. Im Netz findet man die Serviceunterlagen,  die hier sehr hilfreich sind.

GV8E in Einzelteilen

Nach der Begutachtung des Blockschaltbildes des gesamten Systems, war der Start der Fehlersuche das DC/DC Converterboard. Diese von einem Schirmblech umhüllte Platine produziert aus der 6V Eingangsspannung sämtliche, für die Versorgung der einzelnen Komponenten benötigten Spannungen. Eine Messung an den Testpins am Board zeigte, dass einige Spannungen fehlten. Also muß hier schon ein Problem zu suchen sein.

Lötseite des DC/DC Converter Boards
Bauteilseite des DC/DC Converter Boards

Nach dem Entfernen des Schirmblechs und einer Inspektion der Bauteile ist mir eine defekte 1.6A Sicherung (F103) aufgefallen. Diese Sicherung schützt den Primärkreis des Schaltwandlers. Aus dem Plan ist ersichtlich, dass der Transistor Q114 niederohmig war und so das Auslösen der Sicherung verursacht hat.

Auszug aus dem Schaltplan des DC/DC Converters

Bei dem Transistor handelt es sich um einen 2SB1121 Bipolar PNP Transistor. Den hatte ich natürlich nicht in meiner Sammlung. Also die Bauteilekisten nach einem geeigneten Ersatz durchforstet…

Ersatz für 2SB1121 ist ein PBSS5250Z

Gefunden habe ich dann einen PBSS5250Z, der zwar ein etwas größeres Gehäuse hat, aber dafür seinen Dienst in der Schaltung verrichten sollte.

Defekter Q114 ausgebaut

Aufgrund der größeren Bauform und des geringen Platzangebotes konnte ich den Ersatztransistor nur stehend einlöten.

Q114 erneuert

Jetzt fehlt noch eine neue Sicherung in der Platine. Nach dem Einbau und der Überprüfung der weiteren Bauteile in den betroffenen Stromkreisen ging´s an den nächsten Funktionstest. Alle Boards wieder elektrisch miteinander Verbunden und 6V an die Batterieklemmengelegt – und siehe da, das Powersupply Board fährt hoch und die Spannungen sind da. Jetzt lässt dich der GV8E mit dem Powertaster wieder einschalten, die LED leuchtet auch und aus dem Lautsprecher ist ein leises Rauschen zu hören. Jedoch läuft keiner der Laufwerksmotoren und der LCD-Monitor bleibt auch dunkel. Beim Betätigen des „Ejekt“ Tasters leuchtet die LED ganz kurz, aber der für den Auswurf des Kassettenfaches zuständige Motor läuft nicht an. Das bedeutet -> weiter nach Fehlern suchen. Zunächst widme ich mich einmal dem LCD Monitor. Der ist schnell ausgebaut und zerlegt. Um so weniger erfreulich, ist der Zustand der Platine. Hier haben die „verwesenden“ Elektrolytkondensatoren mit ihren „Körperflüssigkeiten“ gewütet. (Damit sind natürlich die Elektrolyte gemeint)

Ausgelaufene Elektrolytkondensatoren

Die flüssigen Elektrolyte der Elkos sind über die Jahre ausgelaufen und haben die Leiterbahnen und auch die Lötstellen angegriffen. Teilweise ist es so schlimm, dass kleine Bauteile, wie SMD Transistoren und Widerstande, schon beim Berühren von der Platine abfallen. Spätestens jetzt ist es unbedingt notwendig, den Schaltplan des Gerätes bei der Hand zu haben. Sonst wird´s nachher schwer, die fehlenden Teile wieder richtig nachzubestücken. Aber vorher mussten die alten Elkos erst einmal entfernt werden.

so sieht die Platine unter den Elkos aus

Mit Leiterplattenreiniger konnte ich die Reste der Elektrolyte entfernen, um dann erst die Beschädigungen an der Platine  zu sehen. Korrodierte Bereiche mussten mit einem Glaspinsel angeschliffen und verätzte Bauteile erneuert werden. Nach einer erneuten Reinigung haben die neuen Kondensatoren (diesmal Keramik-Vielschicht-Kondensatoren anstelle der Elkos) ihren Platz gefunden.

Platine mit neuen Bauteilen

Nach dieser Prozedur war es dann soweit. Der nächste Funktionstest startete. Nach dem erneuten Verbinden sämtlicher Steckverbindungen und der Energieversorgung gab es weitere Lebenszeichen. Die Hintergrundbeleuchtung (CCFL) startete wieder und in der linken oberen Ecke war „00:00“, die blinkende Uhr des Onscreendisplays zu erkennen… Leider war das auch schon alles. Die OSD-Darstellung war sehr verschwommen und der Rest des Bildes war weiss. Die Helligkeitsregler reagierten nicht. Also musste das Board unter die „große“ Lupe.

Das Board des LCD-Monitors hatte noch viele unterbrochene Leiterbahnen, die mühevoll mit einzelnen Litzen und Kupferlackdraht repariert werden mussten. Es waren auch noch einige SMD Komponenten (Widerstände und Transistoren) an ihren Anschlüssen derart korrodiert, dass hier nur ein Austausch half. Das Ergebnis sieht zwar etwas wild aus, aber ein weiterer Funtkionstest verlief dann endlich positiv.

Repariertes Displayboard

Nachdem ich den Monitor wieder zusammenbaut hatte, ging´s an das Laufwerk. Auch hier habe ich zuerst alle SMD-Elkos geprüft bzw. erneuert, da wirklich ALLE ausgelaufen waren. Glücklicherweise waren die Platinen hier nicht so extrem verätzt und konnen einfach gereinigt werden. Dann kam der Funktionstest. Und leider gab es auch hier noch Probleme. Es gab keinen Kassettenfachauswurf und keinerlei Reaktionen eines der Antriebe. Nach dem Studium des Servicemanual und dem Messen vieler Versorgungsspannungen konnte ich einen Prozessor als Fehlerquelle ausmachen. Es handelt sich um einen SONY CXP80116.

Sony CXP80116

Dieser Chip steuert sämtliche Antriebe, Leds, fragt Sensoren ab, etc.. Für das Auswerfen des Kassettenfaches ist er auch zuständig. Über Pin 20 und 21 steuert er ein TreiberIC (Brücke)  an, das wiederum den Lademotor versorgt. Und genau die beiden Ausgänge blieben auf 0V.  Wenn die „Eject“ Taste betätigt wurde, waren anstelle der 5V nur ein paar Millivolt zu messen. Also stand zuerst der Verdacht nahe, der Treiber IC hat einen Fehler und zieht die Ausgänge des Controllers hinunter. Also die Ausgänge vom Controller zum Motortreiber getrennt und an den Motortreibereingang direkt 5V angelegt – und siehe da, der Lademotor wurde angesteuert. Also liegt der Fehler am 80116er. So einen konnte ich nach einigem hin und her auch noch finden und tauschte ihn aus. Ein erneuter Test erfreute mich, denn die Kassette konnte wieder geladen werden und die Kopftrommel startete.

Und schon zeigte sich das nächste Problem. Einer der beiden Ladearme fuhr nur den halben weg und blieb dann hängen. Das bedeutet, auch die Mechanik des Laufwerks muß ich zerlegen. Gesagt – getan. Glücklicher Weise war nur ein kleiner Bolzen schuld, der einen Mitnehmerhebel festhält. Dieser hatte sich gelockert und ist herausgerutscht. Das Problem war also schnell behoben. Jetzt endlich konnte ich wieder einen Funktionstest machen. Und dieses Mal klappte auch alles. Die Kassette wurde geladen, die Kopfscheibe startete, das Band fädelte ein und schlussendlich ließ es sich auch Abspielen. Nachdem ich alle Funktionen getestet hatte, der GV-8E wieder zusammengesetzt werden. Jetzt kann er als „Museumsstück“ in die Vitrine 😉

läuft wieder

 

Technische Daten des GV-8E:

  • Video recording System: Rotierendes Zweikopf-Helical-Scan-FM System
  • Audio recording System: Rotierender Kopf, FM System
  • Videonorm: CCIR, PAL color
  • Kassettenformat: 8mm Videokassette
  • Bandgeschwindigkeit: SP: 2.0051 cm/s LP:1.0058cm/s
  • LCD Bildschirm: 6.2×4.6cm (3inch Diagonale)
  • Bildschirmtyp: TN LCD/TFT active Matrix mit 92.160 Bildpunkte
  • TV-Tuner: VHF Kanal 2-12, UHF Kanal 21-69
  • Anschlüsse: RF-Antenne, Video Input/ Output Chinch, Audio Input/Output Chinch (mono), Headphone 3.5mm Klinke
  • Energieversorgung 6V (Akku oder Netzadapter)
  • Leistungsaufnahme: 7.1W
  • Abmessungen: 129x67x213mm
  • Gewicht: 1.15kg ohne Akku
Typenschild des GV -8E

 

Langzeitmessungen mit Keithley und Matlab

Keithley2000 Tischmultimeter

Ein alter Begleiter im Bereich Messgeräte ist das Tischmultimeter von Keithley. In unseren Labors  werden vorwiegend die Typen der 2000er Serie eingesetzt. Es gibt sie in unterschiedlichen Ausstattungsvarianten betreffend der Schnittstellen zur Aussenwelt. Hier ist GBIP-Bus natürlich ein Standard, ebenso wie RS232. Die neueren Geräte besitzen mittlerweile ein LAN Interface mit dem eine Kommunikation über das InternetProtokoll möglich ist. Über jede dieser Schnittstellen kann über „Standard Commands for Programmable Instruments“ (SCPI) mit dem Gerät kommuniziert werden. In diesem Beispiel werde ich das Keithley 2000 über Matlab ansteuern und zyklisch über einen längeren Zeitraum Messwerte auslesen, diese in Matlab speichern und schlußendlich in einem Plot ausgeben – quasi einen simplen Datalogger konfigurieren. Der Zweck dieses Aufbaus ist es, den Spannungsverlauf (bzw. auch Strom) eines Akkus bzw. Batterie eines Low-Energie Device zu erfassen.

Rückseite des Keithley 2000
GPIB Interface (IEEE488)
RS232 Schnittstelle

In diesem Beispiel werde ich die serielle Datenübertragung per klassischer RS232 Schnittstelle verwenden, da diese für meine Anwendung vollkommen ausreicht. Zudem kann ich mir die Installation der Treiberpakete für das GPIP-USB Interface ersparen. 🙂 Da viele der aktuellen Rechner und Laptops auch keine RS232 Ports mehr haben, muß ein USB-RS232 Adapter (beispielsweise FTDI232 etc.) her.

USB-RS232 Adaper am Keithley2000

Ist die Verbindung zwischen dem Multimeter und dem Rechner hergestellt, kann, wie in diesem Beispiel, über ein Matlabscript kommuniziert werden. Dem Keithley muß nur mehr mitgeteilt werden, dass es über die serielle Schnittstelle „sprechen“ soll. Die folgenden Code-Schnipsel zeigen, wie man einfach über SCPI Daten auslesen kann:


serialObject = instrfind('Type', 'serial', 'Port', 'COM26', 'Tag', '');
%serialPort = 'COM23';
%serialObject = serial(serialPort,'BaudRate',9600, 'DataBits',8);

if isempty(serialObject)
serialObject = serial('COM26','BaudRate',57600, 'DataBits',8);
else
fclose(serialObject);
serialObject = serialObject(1)
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Sourcemeter 2000 setup
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
fopen(serialObject)
% fprintf(serialObject,':*RST')

time = now;
voltage = 0;
%%
figureinstanz = figure('NumberTitle','off',...
'Name','Spannungslogg',...
'Color',[0 0 0],'Visible','off');
plotinstanz = plot(voltage,time,'Color','red');

%% Messzeit und evtl Messintervall
stoptime = 10; %60 seconds
timeInterval = 1; % brauch' ma jetzt nicht

% Messgeraet einstellen
fprintf(serialObject,':SOUR:FUNC:MODE CURR'); % current source selection.
fprintf(serialObject,':SOUR:CURR:MODE FIXED'); % changes voltage mode to fixed
fprintf(serialObject,':SOUR:CURR:LEV 0'); % sets current to 0

fprintf(serialObject,':SENS:FUNC &quot;VOLT&quot;');
fprintf(serialObject,':SENS:VOLT:PROT 4');
%fprintf(serialObject,':SENS:CURR:RANG:AUTO ON');
fprintf(serialObject,':SENS:VOLT:RANG 10');
fprintf(serialObject,':FORM:ELEM VOLT');

% %fprintf(serialObject,':TRAC:COUN 1');
% %fprintf(serialObject,':TRAC:FEED:CONT NEV');
%
%
% fprintf(serialObject,':TRAC:CLE');
%
% fprintf(serialObject,':TRAC:POIN 10');
% fprintf(serialObject,'TRAC:FEED:SENS');
% fprintf(serialObject,'TRAC:FEED:CONT NECT');
% fprintf(serialObject,'TRIG:COUN 10');
% fprintf(serialObject,':OUTP ON');
%
% fprintf(serialObject,':INIT');
% fprintf(serialObject,':TRACE:DATA?');

%% Daten abholen
count = 1; voltage(1)=4
tic;
time=toc;
% while time&lt;=stoptime
while voltage&gt;=1.5
% fprintf(serialObject,':INIT');
% fprintf(serialObject,':TRAC:FEED SENS');
% fprintf(serialObject,':TRAC:DATA?');
%
fprintf(serialObject,':READ?');
voltage(count) = fscanf(serialObject,'%f');
time(count) = toc;
set(plotinstanz,'YData',voltage,'XData',time);
set(figureinstanz,'Visible','on');
pause(timeInterval);
count = count +1;
end

figure(1);
plot(time,voltage);
grid on; hold on;
xlabel('Zeit [s]'); ylabel('Batteriespannung [V]')
title('Spannungsverlauf Batterie 3V Lithium (2032 mit Modul) im default mode');

% fprintf(serialObject,':OUTP OFF');
%% Put the instrument in local mode
fprintf(serialObject,'SYSTEM:LOCAL');
fclose(serialObject);

Wie so ein Datalog dann aussieht ist in der folgenden Grafik dargestellt. Hier ist der Spannungsverlauf einer nahezu entladenen Batterie bis zum Abschalten des Verbrauchers über die Zeit aufgezeichnet worden.

Kassettenrecorder SONY TC150B

Sony TC-150 Kassettenrecorder

Der Sony TC-150 ist das neueste, alte Mitglied in der Sammlung. Wiederum als Defektgerät erworben, fand dieses Schätzchen einen Platz in der Werkstatt. Nach einer schnellen Inspektion war gleich klar, hier hat der Zahn der Zeit genagt und wie oft üblich, die Antriebsriemen spröde gemacht, bzw. sie zersetzt. Ansonsten ist das Gerät in tadellosem Zustand, kaum Krazter und Beschädigungen am Gehäuse. Auch das Batteriefach war sauber. In dem Gerät befinden sich vier unterschiedlich lange Vierkanriemen.

die zu erneuernden Riemen

Geeignete Ersatzriemen bekommt man beispielsweise bei einem großen Elektronikhandel, der in Österreich mit sechs Megastores vertreten ist. Unter der Bezeichnung „Antriebsriemensortiment“ und „1.1mm Kantenlänge“ wird man schnell fündig. Weniger schnell geht das Austauschen der Riemen. Hier sollte man sich zumindest eine halbe Stunde Zeit nehmen und das Zerlegen des Laufwerks vorsichtig angehen.

Um zu den Riemenscheiben zu gelangen, bzw. diese weiter freischrauben zu können, muss die Hauptplatine abgenommen werden. Dies geht aber nur, wenn einige Leitungen abgelötet werden. Erst dann kann man die Platine hochklappen. Ist das erledigt, kann man die Haltebleche über den Riemenscheiben abschrauben.  Sie bilden den Gegenhalt der Schwungräder (Kapstanwelle). Bei dieser Gelegenheit bietet es sich an, die Kapstanwelle auf Schmutz (durch Bandabrieb) und Beschädigungen zu prüfen, bzw. sollte sie gereinigt werden. Auch die Andruckrolle darf nicht ausser Acht gelassen werden. Bei diesem Modell war beides in einem super Zustand. Die Andruckrolle war weder verglast und spröde, noch mit Bandabrieb verunreinigt oder eingelaufen. So konnte ich die neuen Riemen auflegen. Der Hauptriemen vom Motor wird mit einer Drehung von 90° aufgelegt. Hier sollte man sich, falls noch vorhanden, die Einbaulage des alten Riemens merken, oder nach dem Auflegen des neuen Riemens zumindest einen kurzen Probelauf machen.

Dreht sich wieder alles (und vorallem auch in die richtige Richtung) dann kann mit dem Zusammenbau begonnen werden. Drähte wieder anlöten, Platine verschrauben und schon ist die „Reparatur“ beendet. Sollte man eine Testkassette besitzen, so können hier noch einige Parameter, wie zum Beispiel Bandgeschwindigkeit oder die Spurlage des Tonkopfes überprüft und gegebenfalls justiert werden.

Der TC150 nach Austausch der Riemen
Das VU-Meter zur Aufnahmeaussteuerung und Batteriekontrolle

 

Technische Daten des SONY TC-150:

Hersteller:                             Sony
Type:                                         TC-150 (Europa) bzw. BT-50 USA
Herstellungsjahr:              ca. 1977 – 1982 (lt. diverser Internetquellen)
Modellart:                             portabler Kassettenrecorder
                                                     (Cassette Corder)
Hauptprinzip:                      NF-Audio
                                                     Magnetbandaufzeichung/Wiedergabe
Bandgeschwindigkit:      4.8cm/s
Magnetköpfe:                     1 Aufnahme-/Wiedergabekopf
                                                     1 Löschkopf (Permanentmagnet)
Halbleiter:                             8 Tranistoren, 5 Dioden, 2IC´s, 1 FET
Leistungen:                           Ausgangsleistung: max 360mW
                                                     Leistungsbedarf Versorgung: max 9W
Versorgungsspannung: Batterie 4×1.5V AA, oder Akkupack BP28
                                                     12V Caradapter bzw. 6V 4W Steckernetzteil
Betriebszeit:                         2.5h bei kontinuierlicher Aufnahme
Lautsprecher:                      Dynamischer 5cm Lautsprecher
Abmessungen:                    174 x 29.5 x 113 mm (BxHxT)
Gewicht:                                 ca. 769g

 

 

 

Mini-TV Broksonic

Broksonic CIRT-2097T

Dieses schöne, kleine, neue Stück Technik aus den achziger Jahren ist zu meiner Sammlung dazugekommen. Es ist ein kleiner Röhrenfernsehempfänger mit Radioteil mit der Bezeichnung CIRT-2097T von dem Hersteller Broksonic (ist lt. Internetrecherchen eine US-Firma). Das Gerät habe ich mit dem Attribut „defekt“ ganz günstig über eine Flohmarktplattform  erhalten.  Also dachte ich, das Risiko kann man eingehen und einen Reparaturversuch wagen. Was Großartiges kann ja nicht kaputt sein – wenn´s nicht gerade die Bildröhre ist.

Das Innenleben des Broksonic

Nach einem kurzen Funktionstest mit dem Steckernetzteil, zeigte sich schnell, dass sich nichts zeigte. Kein Bild – kein Ton, kein gar nix. Da das Gerät auch ein Batteriefach besitzt, wollte ich als nächstes versuchen, die Energieversorgung über die Batterieklemmen einzuspeisen um zu sehen, ob hier vielleicht schon ein Problem liegt. Und da war es auch schon – das Problem. Der Batteriedeckel war fast nicht abzubekommen, er hielt wie angeklebt. Nach einigem hin und her, bekam ich den Deckel dann doch noch zerstörungsfrei ab und es offenbarte sich die Ursache der „Verklemmung“ oder besser „Verklebung“. Im Batteriefach befanden sich (wahrscheinlich schon seit 20, oder mehr Jahren) immer noch Batterien. Die waren in einem schlimmen Zustand, total korrodiert und ausgelaufen. Teilweise war der äussere Mantel der Zelle verätzt und nicht mehr vorhanden. Ohje – dachte ich, hoffentlich hat sich das ausgelaufene Dielektrikum nicht ins Innere des Gerätes bewegt und dort Schaden angerichtet. Es blieb mir nichts anderes übrig, als alles zu zerlegen und zu überprüfen. Und da offenbarte sich dann  das Übel:

Von Batteriedielektrikum beschädigte Platine

In etwa ein Viertel der TV-Platine war mit der Batterieflüssigkeit in Kontakt gekommen. Und das Zeug hat ganze Arbeit geleistet und Leiterbahnen und Anschlussdrähte von Bauteilen fast vollständig weggeätzt.

Also habe ich zuerst einmal versucht mit Leiterplattenreiniger,alle Kistalle und den Rest des Batteriesaftes zu entfernen um dann einen genaueren Blick auf die Beschädigungen zu erhalten. Ein paar stichprobenartige Messungen mit dem Ohmmeter zeigten schnell, dass viele Leiterbahnen durchtrennt waren. Es half also nichts, die Leiterbahnen mussten freigelegt werden. Erst dann wäre eine vernünftige Reparatur möglich.

Grobe Reinigung mit der Messingdrahtbürste

Mit einer rotierenden Messingdrahtbürste habe ich dann begonnen, die verätzten Bereiche abzutragen, die Reste des Lötstoplackes zu entfernen und die Kupferbahnen freizulegen.

Feinarbeiten mit Glaspinsel

Nach den groben Vorabeiten musste der Glaspinsel ran. Nur mit dem war es möglich, alle Lack- und Korrosionsreste zu entfernen und schlussendlich die Leiterbahnen freizulegen. Eine langwierige Arbeit…

die freigelegten und reparierten Kupfebahnen

… doch schlussendlich gelang es, alle beschädigten Bereiche freizulegen und zu reparieren. Einige Widerstände und Kondensatoren mussten auch erneuert werden, da deren Anschlussdrähte auch in einem schlechten Zustand waren.

Nach der Reparatur konnte dann ein Funktionstest durchgeführt werden – und siehe da, es war kein weiterer Fehler mehr vorhanden und das Gerät funktionierte schon wieder einwandfrei. Also konnte ich den reparierten Bereich der Platine mit Lötlack vor erneuter Korrosion schützen und das Gerät wieder zusammenbauen.

 

 

 

 

Abschliessend liste ich hier noch eine Übersicht der technischen Daten:

Hersteller:                          Broksonic (US-Firma New York)
Type:                                      CIRT-2097T
Herstellungsjahr:           ca. 1982
Modellart:                          TV+FM Empfänger portable
Hauptprinzip:                   Superhet
Bildschirmdiagonale:  2 Zoll SW Bildröhre
Wellenbereiche:             AM, FM, SW (Radio), VHFI,VHFIII,UHF (TV)
                                                  AM: 535-1605kHz
                                                  SW:3200-9700kHz
                                                  FM:88-108MHzTV:
                                                  VHF Kanal 2-13(US), 2-12 (E)
                                                  UHF Kanal 14-83(US),21-69(E)
Betriebsart:                       Batterie oder Akku, Netzbetrieb mit Steckernetzteil
Versorgungsspannung: Akku 6V, Batterie 6×1.5V AA
Lautsprecher:                    Dynamischer 16 Ohm Lautsprecher mit Permanentmagneterregung
Ausgangsleistung:          150mW
Abmessungen:                  150x53x202 mm (BxHxT)
Gewicht:                                ca 1.1kg

NES Classic Mini : Aus mit Wucherpreisen

Das Unternehmen Nintendo hat im Jahr 2016 die Spielekonsole Nintendo Classic Mini aufgelegt und in den Verkauf gebracht. Sie ist ein Revival der 8-Bit Ur-Spielekonsole Nintendo Entertainment System aus dem Jahr 1983 (Veröffentlichung in Japan) bzw. 1986 (Veröffentlichung in Europa). Die Ur-NES Konsole hat sich ca. 61 Millionen mal verkauft und wurde 1992 von der SNES (Super Nintendo Entertainment System) einer 16Bit Konsole abgelöst. Die Beliebtheit der Nintendokonsolen ist scheinbar so groß, dass die Neuauflage mit einem Verkaufspreis von ca. 60 Euro kurz nach der Veröffentlichung ausverkauft war. Hier witterten Geschäftemacher den großen Deal und boten die Geräte über Amazon, ebay und co zu teilweise horrenden Preisen an. Auch jetzt, knapp ein Jahr später sind sie noch nicht unter 100 Euro zu bekommen. Und Nintendo produziert auch keine weitere Einheiten. Stattdessen hat das selbe Spiel mit dem Revival der SNES Serie in einer Miniaturausgabe begonnen. 

Der NESPI in seiner Verpackung

Es gibt aber auch andere Möglichkeiten, um mit viel weniger Geld in den Besitz einer miniaturisierten Version dieser Konsole zu gelangen. Um ein paar Euro bekommt man ein Gehäuse namens NESPI CASE, das der NES CLASSIC MINI entspricht, jedoch mit einem großen Unterschied: Den Rechner kann man in Form eines Raspberry PI selber einbauen. Damit eröffnen sich unzählige Möglichkeiten mit Emulatorsoftware eigene Konsolen softwaremäße nachzubauen.  Das NESPI-Case besitzt einen integrierten 4 Port – USB Hub sowie einen LAN Ethernet Connector, der die Anschlüsse des Raspberry PI nach aussen führt. Hierbei sind zwei USB Ports so angeordnet, dass sie als Controller-Anschlüsse dienen. Die weiteren zwei USB Ports sowie der Ethernetanschluss liegen unter der Geräteklappe, wo einst die Spielemodule eingesteckt wurden. Das Gerät ist mit einem Einschalter mit Power LED  sowie einem Reset-Taster ausgestattet.

NESPI Case ausgepackt
Bedienelemente und Anschlüsse

Das Gehäuse wird mit bereits vormontierten Adapterplatinen geliefert. Auch die Schrauben für die Montage des Raspberry Pi, sowie für die Gehäuseschalen sind im Lieferumfang enthalten. Ein kleiner beiliegender Kreuzschraubendreher, sowie ein Zettel mit einer Montageanleitung machen die Sache noch einfacher.

Raspberry PI im NESPI-Gehäuse

Die Lan und USB- Ports des RaspberryPi werden über die, an den Adapterplatinen befindlichen Kabel samt Steckern nach aussen geführt. Sind die Steckverbindungen hergestellt, so kann die RapsberryPI-Platine im Gehäuse verschraubt werden. Optional kann auch noch ein 5VDC Lüfter mit den Abmessungen 30x30x10mm im Gehäusedeckel per Rastnasen befestigt werden. Für die Stromversorgung des Lüfters steht auf der Platine ein zweipoliger Pinheader zur Verfügung. Ist alles eingebaut und angeschlossen, dann kann das Gehäuseoberteil angeschraubt werden.

Raspberry Pi eingebaut

Nun kann die Software eingerichtet werden. Ich bevorzuge hierbei die Images von retropie bzw. recalbox. Nähere Indormatinen dazu findet man auf den entsprechenden Webseiten. Sind die gewünschten Emulatoren eingerichtet, so muss man nur mehr die Spieledateien, die sogenannten „Roms“, also binäre Kopien der Spielemodule der einstigen Originalhardware in einer .bin oder .rom oder .iso Datei etc. auf die SD-Karte oder einen USB-Stick kopieren und in die „EmulationStation“ einbinden. Und schon kanns losgehen. Auch die USB-Controller im NES – Look sind um ganz wenige Euro aus China zu bekommen…

NESPIE mit NES-Nachbau „ChinaController“

 

Ein alter NES „Klassiker“

 

VFD-Uhr mit Datum, Wochentag und Sound

Einen neuen Bausatz zum Thema Vakuum Floureszenz Display habe ich von Günter (gr-pojects) erhalten. Vielen Dank!

Es ist eine Uhr mit Vakuum-Floureszenz-Anzeigeröhren der Typen IV-11 für die Stunden, Minuten und Sekundenanzeige und einer IV-18 Röhre für die Datumsanzeige, sowie IV-3 zur Darstellung des Wochentages. Die Uhr besteht aus einem Mainboard mit Spannungsversorgung, CPU, MP3-Modul sowie den Treiberbausteinen für die Röhren. Die Uhrzeit wird über einen extern angeschlossenen DCF-77 Empfänger eingestellt und synchronisiert. Später wird das Board noch mit einer Realtimeclock-Schaltung erweitert.  Die Energieversorgung für die gesamte Schaltung kommt von einem kleinen Steckernetzteil mit 12V/1.2A. Die gesamte Stromaufnahme beträgt ca. 450mA. Als besonderes Feature besitzt die Uhr ein kleines MP3-Soundmodul mit MicroSD-Kartenslot. Dieses erhält vom Microcontroller über die serielle Schnittstelle zu jeder viertel-Stunde ein entsprechendes Commando, ein MP3 File abzuspielen. So wird die viertel Stunde mit einem „Gongschlag“, die halbe Stunde mit zwei und die dreiviertel Stunde mit drei „Gongschlägen“ signalisiert. Zur vollen Stunde wird die entsprechende Uhrzeit angesagt.

Die gesamte Schaltung ist in ein Alu-Acryl Gehäuse eingebaut. Alle Formteile sind gefräst und werden  verschraubt. Ein Video vom Aufbau und der Funktion ist unten zu sehen:

ABS Steuergerät und der Wackelkontakt

In den modernen Kraftfahrzeugen ist ja massenweise Elektronik verbaut, die über unterschiedliche Bussysteme miteinander kommuniziert. Zahlreiche Steuergeräte verarbeiten Sensordaten und führen damit Regel- und Steueraufgaben durch und senden diese an Aktoren und Geber. Doch leider ist viel Elektronik, vorallem die hochintegrierte, auch fehleranfällig. Die rauhen Umgebungsbedinungen, die in einem Fahrzeug herrschen, insbesonders im Motorraum, lassen diese Komponenten schneller altern. So treten immer wieder Ausfälle von Komponenten auf. Manchmal sind es nur Kleinigkeiten, wie Kontaktfehler durch zum Beispiel kalte Löstellen. Diese Fehler lassen sich oft auch einfach reparieren, ohne gleich ein neues Teil kaufen zu müssen. Oder zumindest provisorisch reparieren, um das Fahrzeug im betriebsfähigen Zustand zu halten, bis ein Neuteil verfügbar ist.

Dieses Mal habe ich ein Auge auf ein Steuergerät eines BMW geworfen, das für die Bremsdruckunterbrechung im Radblockier-Fall zuständig ist – also ein ABS – Steuergerät. Die ABS-Kontrolleuchten im Tachomodul signalisierten durch ein Dauerleuchten, dass hier ein Defekt vorliegt. Die Radsensoren und Verbindungsleitungen zum Steuergerät kamen als Fehlerursache nicht in Betracht – es konnte dann nur das Steuergerät sein. Vom Hydraulikblock getrennt landet es auf meinem Tisch.

Bosch ABS-Steuergerät 34.52-6750345

Die Elektronik verbirgt sich unter einer verschweissten Kunststoffabdeckung. (im Bild direkt vor dem Stecker zu sehen). Diese lässt sich nur mit gröberer Gewalt öffnen. Ich wählte hier eine kleine Trennscheibe für den Drehmel, mit dem ich die Klebestellen an drei Kanten vorsichtig auftrennen konnte.

Schnitt entlang der Klebeschweissstelle

Im Bild kann man die Schnittstelle erkennen. Die hintere Seite unter dem Stecker ist für die Trennscheibe nicht zugänglich. Das ist aber auch nicht notwendig, da der Deckel so zum Stecker hin hochgebogen werden kann und nicht vollständig entfernt werden muss.

Deckel ist hochgeklappt

Nun kann der Deckel hochgeklappt werden. Darunter kommt die Elektronik zum Vorschein. Hier ist nun höchste Vorsicht geboten. Die Trägerplatine (vermutlich Rogers-Material) ist lediglich mit Silikongel geschützt. Und darunter befinden sich nicht nur einige SMD-Komponenten, sondern auch direkt die DIEs (also die Siliziumhalbleiter – so wie sie vom Waver geschnitten werden, bevor sie in einem Gehäuse vergossen und gesichtert werden) Diese wiederum sind auf die Platine geklebt und mit Bonddrähten zu dieser verbunden. Die Drähte haben teilweise einen Durchmesser von 25µm und man kann sich vorstellen, die sind auch ziemlich empfindlich. Geschützt sind sie lediglich durch das Silikongel, das immer extrem dauerelastisch ist. Diese Konstruktion macht den extremen mechanischen Materialstress, der durch die thermischen Gegebenheiten im Motorraum und Vibrationen besteht, vermutlich am besten mit…

Betrachtet man die Platine genauer, so ist zu erkennen, dass auch die Verbindungsleitungen zur Aussenwelt (Stecker und Elektromagnete) mit unterschiedlich dicken Bonddrähten ausgeführt sind. Und hier ist in den meisten Fällen auch der Fehler zu suchen. Manche Bondstellen brechen.

Die ersten fünf dicken Leitungen von links sehen unter dem Mikroskop wie folgt aus:

Bruchstellen an den Bondstellen

Wenn man ganz genau hinsieht kann man die Bruchstellen erkennen. Mit einer Pinzette lassen sich die defekten Leitungen einfach herunterziehen.

defekte Bonddrähte sind entfernt

Sind die defekten Bonddrähte entfernt, dann muss das Silikongel vorsichtig zur Seite geschoben werden. (Ideal wäre an dieser Stelle, das gesamte Gel zu entfernen – das würde eine professionelle Reparatur unter dem Wirebonder ermöglichen) Da ich die Möglichkeit zur Gelentfernung leider nicht habe, muss hier gelötet werden. Aber auch hier ist doch ein wenig Geschick von Nöten.

Neue Verbindungsleitungen

Es sieht zwar nicht perfekt aus, aber die Lötverbindungen halten und haben Kontakt. Ich habe hier lackierten Kuperdraht mit 100µm Durchmesser genommen, da die Silberbonddrahtbestände in dieser riesigen Dimension nicht vorrätig sind…

Jetzt kann das fehlende Silikongel ersetzt werden. Ein vorsichtiges Verstreichen des umliegenden ist bedingt ebenfalls möglich. Der Deckel kann nun mit Kleber wieder verschlossen und versiegelt werden. Hier bietet sich der KFZ-Scheibenkleber an.

Wenn alles geklappt hat und keine weiteren Bonddrähte (auch auf dem Board selbst) beschädigt sind, dann sollte das Steuergerät wieder arbeiten.  Hier ein kurzes Video zur Reparatur: