Archiv der Kategorie: Allgemein

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)

 

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.

Sony RX100 Digitalkamera (und die Reparatur)

Die Sony RX100 Digitalkamera mit ihrem 20.2 Megapixel EXMOR CMOS Sensor besticht durch ihre hervorragende Bildqualität und die kompakte Bauform. Die Sensorgröße von einem Zoll und das vorgesetzte Zeiss Vario Sonnar F1.8 Objektiv sind mit verantwortlich für die guten Bildergebnisse. Die Kamera ist dabei mit 10x6cm und einer Dicke von 3.6cm immer noch hosentaschentauglich. (Wobei ich das nicht empfehlen würde). Das 3,6fach-optische-Zoomobjektiv wird im ausgeschalteten Zustand ein und bei Gebrauch ausgefahren.

Doch nach einiger Zeit und etlichen Aus- und Einfahrten der Optik kommt es, oder kann es irgendwann zu einer Situation kommen, wo die Optik ihren Dienst verweigert. Das äussert sich auf unterschiedliche Art und Weise. Entweder passiert nach dem Einschalten gar nix, die Optik bewegt sich nicht und am Display erscheint nur die Meldung („Aus und wieder Einschalten“), oder das Objektiv fährt ein Stück heraus und und gleich wieder ein. Jetzt könnte man vermuten, die Kamera hat einen mechanischen Schaden, die Gleitflächen innerhalb der Optik sind verschmutzt, oder es ist durch einen etwaigen Sturz irgendetwas verbogen oder verzogen und klemmt. Doch dem ist meist nicht so. In diesem Fall ist die Kamera nie starken mechanischen, thermischen, etc. Beanspruchungen ausgesetzt worden und trozdem gibt es einen Fehler. Recherchiert man einwenig im Netz, dann findet man einige Reparaturtutorials, wo versucht wird, mit irgenwelchen Papierstreifen zwischen den Gleitringen der Optik zu reinigen etc. Eine vernünftige Information war nicht zu finden. Also bleibt mir nichts übrig, als selber nach der Ursache für das Problem zu suchen. Und es war auch schnell gefunden. Nach dem Öffnen des Gerätes und leichtem Anheben des hinteren Gehäusedeckels ließ sich das Objekt plötzlich wieder ausfahren. Wurde der Deckel wieder aufgesetzt, so war das Problem wieder da. Es mußte also irgendwo ein Kontaktfehler vorliegen. In den folgenden Zeilen stelle ich meinen Weg zur funktionierenden Kamera vor:

Nach dem Lösen der Schrauben und Entfernen der Kunsstoffbodenplatte lässt sich die hintere Abdeckung mit dem Bedienfeld und dem Monitor abnehmen.

Der Flexiprint zum Bildschirm und jener zur Bedieneinheit ist zu lösen, der kleine Lautsprecher kann einfach ausgehangen werden. Jetzt kann noch einmal der Akku eingelegt und eingeschaltet werden. In diesem Fall öffnete sich das Objektiv und fuhr wieder korrekt aus. Es ist also wirklich ein Kontaktproblem. Doch wo ? Ich versuchte mit dem Finger leichten Druck auf den Flexiprint auszuüben, der den mechanischen Teil der Optik versorgt. (Nicht den, der vom Sensor ins Mainboard führt.) Mit diesem leichten Druck am Flexiprint wurde wieder eingeschaltet und siehe da -> Treffer. Die Optik rührte sich nicht. Das ließ sich auch nachvollziehen. Also scheint dieser Flexiprint an den Knickstellen einen Leitungsbruch zu haben. Scheinbar wird dieser Print, bedingt durch das Ein- und Ausfahren der Linse konstruktionsbedingt mechanisch gestresst und gibt so irgendwann nach und bricht. (Vielleicht auch geplante Obsoleszenz). Jedenfalls suchte ich im Netz nach einem Ersatz, fand ihn und nach einer Woche Wartezeit wurde der neue Flexiprint auch schon geliefert.

Der neue Print für die Optik wird ohne jegliche Bauelemente verkauft. Das bedeutet, ab hier ist ein wenig Erfahrung im Umgang mit Lötwerkzeugen, SMD Bauteilen und flexiblen Platinen erforderlich.

Die Optik muß freigelegt und ausgebaut werden. Dazu ist das Mainboard zu lösen. (insgesamt drei Schrauben). Dann ist vorsichtig die schwarze Folie von der Hinterseite der Optik zu entfernen. (Vorsicht bei den ganzen flexiblen Leitungen) Ist die Folie ab, kann der Flexprint zum Sensor abgesteckt werden.

Als nächstes wird die Motoreinheit gelöst und der Motor vom Objektivgehäuse getrennt.

Auf dem Print befinden sich einige Komponenten, wie Steckverbindungen und kleine Gabellichtschranken, die im Obektiv(Objektivposition) und in der Motoreinheit (2 Stück als Inkrementalencoder und zur Drehrichtungsbestimmung)verbaut sind. Diese werden mit kleinen Metallbügeln in Position gehalten und müssen vor dem Ausbau der Objektiveinheit gelöst werden.

Objektiv, Antriebseinheit und Mainboard sind ausgebaut. Alle Steckverbindungen zwischen Optik und dem Antriebsmotor sind zu lösen.

Die Motoreinheit kann nun vom Objektiv getrennt werden. Der Flexiprint ist auf dem Objektivgehäuse mit Tesaband und kleinen Haken befestigt. Diese müssen  gelöst werden.

Mit dem Zerlegen der Motoreinheit geht´s nun weiter. Im Kunststoffgehäuse des Motorgetriebes befinden sich, wie zuvor erwähnt, zwei Gabellichtschranken, die auch mit einer Klammer festgehalten werden. Diese kann einfach ausgeklipst werden. Zum Abschluß des Ausbaus muß noch der Motor abgelötet werden. Nun ist der Flexiprint frei und der heikle Schritt kann beginnen.

Die kleinen SMD Steckverbinder sind vom alten Print abzulöten und wieder auf dem neuen Print zu befestigen. Bei dieser Arbeit ist sauberstes Handtieren gefragt, da die kleinen Kunststoffgeäuse beim Auslöten sehr leicht zerstört werden können. Ich empfehle hier, den Print nur von der Unterseite zu erwärmen, und dann den Stecker mit einer Pinzette abzuheben. Sonst läuft man schnell Gefahr, den Kunststoff des Steckers durch zuviel Hitze zu verformen. Ist das gelungen, können die Stecker auf dem neuen Flexiprint angelötet werden.

Die selbe Arbeit ist auch bei den Gabellichtschranken durchzuführen. Dann sind nur mehr die Kontakte des Motors an den dafür vorgesehen Positionen in der Flexplatine anzulöten.

Wenn das geklappt hat, kann der Zusammenbau in umgekehrter Reihenfolge erfolgen. Beim Biegen der Flexplatine in die richtige Position kann man sich an der alten Platine orientieren. Dann sollte der Einbau kein Problem sein. Vor dem Anbringen der Kamerarückwand (hinterer Deckel) sollte ein Funtkionstest durchgeführt werden. Das Objektiv muß auch ohne Monitor und Bedientastenfeld aus- und wieder einfahren. Wenn auch das funktionert, dann kann finalisiert werden. In meinem Fall war die Reparatur erfolgreich. Mal sehen wie lange es hält, bis wieder eine Leiterbahn im der flexiblen PCB bricht…

Panasonic AG-6400 VHS-Portable

Panasonic AG6400

Ein neues Mitglied in der Sammlung alter Geräte aus dem Bereich Multimedia ist der AG-6400 von Panasonic. Beim AG-6400 handelt es sich um einen (semi)professionellen Videorecorder aus den 80iger Jahren. Das Gerät zeichnet auf VHS Magnetbänder auf  und gibt diesen Standard auch wieder. Es ist tragbar und war der Recorder für die Videocameras der damaligen Zeit. Die Energie bezieht er aus 12V Akkus der Bauform NP1 und kann ca. 27W für die an ihn angeschlossene Camera bereitstellen. Das war inetwa der Leistungsbedarf einer 3-Röhrencamera.

Auch dieses Gerät hatte einige Spuren der Zeit abbekommen, die seine Funktion weitgehend einschränkten. Einfach gesagt – er war defekt. Dieser Defekt äusserte sich in einer festsitzenden Capstan-Welle. Zuerst dachte ich, die Welle war aufgrund von Korrosion ‚festgefressen‘, doch der Grund war ein ganz anderer. Interessanter Weise war ein Kugellager aus seiner Presspassung herausgedrückt worden, sodass die an der Welle befestigte Schwungscheibe die Spulenkörper des Capstan-Motors berührte. Durch die Magneten in der Schwungscheibe wurde sie richtig fest gehalten. Dieser Fehler ließ sich durch Zurückdrücken des Kugellagers und anschließendes Fixieren  einfach und schnell beheben.

Der Recorder ohne Gehäuse
Ausgeklappte Platinen (Serviceposition)
Blick auf die Mechanik (Kopfscheibe etc.)

Nach der Reparatur des mechanischen Fehlers und einem ersten Funktionstest, war noch auf dem Powerboard ein Fehler der 5V Spannungsversorgung zu finden. Dieser äußerte sich durch ein Nichtanlaufen sämtlicher Antriebe. Hier war im Schaltwandler eine IC-Sicherung defekt. Diese wurde duch eine defekte Schottky-Diode der Buck-Converterschaltung ausgelöst. Auch dieser Fehler war schnell behoben. Und nach einer Überprüfung und Justage der Betriebsspannungen nach den Sollwerten des Servicemanuals, verrichtete das Laufwerk wieder seinen Dienst. Ich war sogar über die hervorragende Bildqualität erstaunt, die das Gerät wiedergeben konnte. Durch seine kompakten Abmessungen kann ich den AG6400 zukünftig sogar zum Digtalisieren alter VHS-Bänder einsetzen.

Aufwendige Verdrahtung zwischen den Boards

 

Frontansicht ohne Gehäuse

In den Datenblättern und der Werbung zu dem  AG-6400 hat der Hersteller einige Features und Funktionen sinngemäß wie folgt beworben:

High Quality Bildwiedergabe
Die Bandgeschwindigkeit entspricht dem VHS Standard bei einer Videospurbreite von 49µm. Mehrere Technologien zur klaren und detaillierten Bildwiedergabe sind in dem Gerät vereint.

HI-FI Sound
Ein Vierkanal System bestehend aus zwei ’normal‘ Audiokanälen mit Dolby Rauschunterdrückung und zwei ‚HD-Sound‘ Kanälen ermöglichen den Genuss von High Quality Aufnahmen. Eine 3.5mm Kopfhörerbuchse sowie zwei 6.3mm Mikrofonbuchsen zur getrennten Einspeisung beider Kanäle samt getrennter Aussteuerung mit VU-Metern runden das Spektrum der Audiooptionen ab.

VU-Meter und Audioregler

Time Code Aufnahme und Wiedergabe
Zur Steuerung in linearen Schnittsystemen ermöglicht der Recorder die Aufzeichnung von externen EBU Timecode Signalen auf Kanal 2 der Längsspur.

Externer Cameraanschluss
Ein Anschluß für eine externe Camera mit einer maximalen Leistungsaufnahme mit bis zu 27W ist ebenfalls vorhanden. Hier können Cameras mit 3-Röhren Vidicon System angeschlossen werden.

Ein Schema mit den Anschlussmöglichkeiten ist im folgenden Bild dargestellt:

Anschlußschema de AG6400 (Bild: Herstellermanual)

Technische Daten:

Hersteller National/Panasonic  Central Osaka Japan
Baujahr ca. 1988
System VHS Portabel Videorecorder
Energieversorgung DC 10.5 bis 16V
Leistungsaufnahme 14Watt, (mit Camera ca. 41W)
Videosystem Vierkopf Rotationssystem (helical scanning)
Luminanz FM azimuth recording
Farbsignal Unterträger Phasenshift Recording
Video SNR 43dB
Audiosystem Normal und HD-Audio
Normalton 1 feststehender Audiokopf
HD-Audio 2 rotierende Köpfe, 1 Löschkopf
Stereoton Normalstereo (2Kanäle über Längsspur )
  HD-Stereo (2Kanäle über Schrägspur)
TV-System CCIR (625 Zeilen, 50Halbbilder) PAL Colour
Bandgeschwindiglkeit 23.39mm/s
Umspuldauer(180min) Band 4.5min
Abmessungen 222x90x270mm
Gewicht 3.0kg (ohne Batterie)

Frohe Weihnachten 2017

Frohe Weihnachten an die Besucher des Blogs!

Das dritte Jahr „Technik- und Retroblog“ ist jetzt um und ich habe es geschafft, mindestens einen Beitrag im Monat zu erstellen. Es gibt auch noch reichlich Material aus alten Zeiten, worüber ich hier wieder posten möchte. Die Zugriffsstatistik auf die Blogseite zeigt mir auch, dass sich auch einige Besucher hierher verirren…

Ich bin auch immer wieder auf der Suche nach kleinen, kuriosen Geräten und Spielzeugen aus den 70er, 80er Jahren. Doch Vieles ist nicht mehr zu bekommen und komplett verschwunden. Es wird leider immer schwieriger Dinge aus seiner Jugendzeit zu finden. Aber wir werden sehen, was das neue Jahr bringen wird 🙂

In diesem Sinn:

Fröhliche Weihnachten und schöne Feiertage!

 

LCR-Meter über Matlab auslesen

LCR-Meter 4297A Agilent

In diesem Post möchte ich mich einmal etwas anderem widmen. Es geht nicht um Retrotechnik, sondern um eine Kleinigkeit, die mir das Arbeiten im Büro erleichtert. Eines der vielen Messgeräte mit denen ich zu tun habe, ist ein Agilent LCR-Meter. Mit dem LCR-Meter 4297A kann man bekannterweise ja die Induktivität, die Kapazität, etc. von elektrischen Bauteilen und generell von Strukturen, die dem Bereich der Elektronik/Elektrotechnik zugeordnet sind, messen. Grob gesagt, der 4297A misst eigentlich nur Strom / Spannung, die Phasenlage  zwischen den beiden und die Energierichtung. Und das bei einer bestimmten Frequenz. Mathematisch werden dann aus diesen Paramatern alle Größen wie L,C,R,X,Y,Q,PHI,… errechnet und ausgegeben. Die Frequenz hier hierbei vom 1MHz bis 3GHz (in 100kHz Schritten) einstellbar. Idealerweise kann das Messgerät nicht nur in einem Frequenzpunkt messen, sondern auch in vielen. Mit „vielen“ ist hier gemeint, dass das Messgerät Frequenztabellen mit 32 Einträgen erzeugen kann. Von diesen Tabellen existieren acht Stück. So ist es möglich, den Verlauf einer gemessenen Größe in Form einer Kurve darzustellen. Allerdings ist das ziemlich umständlich. Die Inhalte der Tabellen müssen händisch (als „csv“ Dateien) Tabelle für Tabelle exportiert und gespeichert werden. Das bedeutet, jede Tabelle muss einzeln angewählt werden. Danach ist der Dialog „Export List View“ zu selektieren – dann ein Speicherpfad und Dateiname anzugeben. Erst jetzt werden die ersten 32 Datensätze exportiert. Dieser Vorgang ist insgesamt acht mal zu wiederholen. Gespeichert wird auf eine 3,5 Zoll Floppy Disc – das einzige verfügbare Medium. Man könnte den 4297A optiona auch in ein LAN hängen und eine Dateifreigabe einrichten. Der händische Export bleibt aber nicht erspart. Auf einem „normalen“ Rechner können die  .csv Files jetzt geöffnet werden. Die müssen dann im postprocessing händisch zusammengefügt werden. Erst jetzt kann aus den Daten ein Diagramm gebastelt werden. Hier bietet sich als Tool Matlab von Matworks an, das in unseren Laboren im Rahmen der Ausbildung häufig eingesetzt wird.

NI GPIB – USB Controller

Um diesen umständlichen Prozess wesentlich zu vereinfachen, habe ich ein kleines Skript erstellt, das über die SCPI – Befehle (Standard Commands for Progammable Instruments) mit dem Messgerät kommuniziert. Das soll heissen: Das Messgerät ist über einen GPIB-USB Controller mit einem PC verbunden. Auf dem PC befindet eine Matworks Matlab Installation samt den benötigten Toolboxen. Das Matlab-Script soll nun einfach die Tabellen der Reihe nach durchschalten und die Inhalte der einzelnen Parameter auslesen und einem Array speichern. Der Inhalt der Arrays wir dann direkt in einem Plot dargestellt. Diese Methode bedient sich aber nur der Inhalte der Tabellen. Es wäre natürlich auch möglich, über das Script in einer Schleife jede gewünschte Frequenz direkt einzustellen, die Messwerte auszulesen, die nächste Frequenz anzuwählen usw.  Das würde max. 29990 Punkte über den gesamten Frequenzbereich ergeben. Die acht Tabellen á 32 Punkte erlauben hingegen nur 256 Punkte. Das ist fürs erste aber ausreichend und auch viel schneller.

Transmission Line 50 Ohm mit Abschlusswiderstand
die Leitung ist terminiert

In dem Beispiel ist der Impedanzverlauf (Z-Verlauf) einer 50 Ohm Transmissionline dargestellt. Das Ende der Leitung ist dabei mit einem 50Ohm Widerstand abgeschlossen. Der Frequenzbereich ist 1MHz bis 3 GHz. Anders sieht es aus, wenn die Leitung offen oder kurz geschlossen ist. Die elektromagnetische Welle wird dann nicht, wie bei dem „gematchten“ System am Ende der Leitung in Wärmeenergie umgewandelt, sondern zurück in das System reflektiert.

die Leitung ist kurzgeschlossen

Das folgende ganz einfache Matlabscript ermöglicht das Auslesen der Messgeräteparameter. Das Script dient als Beispiel, wie man schnell zu den Messdaten kommt. Im Programmingmanual des Herstellers vom LCR-Meter sind alle SCPI Commandos und reichlich Beispiele angeführt, mit denen man mit dem Messgerät kommunizieren kann.


%auslesen der agilent LCR Keule 4287A
%gekodet von ingmar bihlo Ende November 2017

%anschluss über gpib ni adapter
%LCR gpip adresse: 5
%%
%vorarbeiten an LCR Keule
%
% Es müssen 8 Tabellen mit je 32 Punkten definiert sein
% (power und average ist egal, wird nicht ausgelesen)
% die CALibration muss gemacht worden sein
% unter "measurement parameters" muessen vier parameter definiert sein
% zb. Z, qhi, R, L, etc... diese sind dann in den variablen param1 bis 4
% enthalten

%%

% gpib interface oeffnen und identifier lesen
g = gpib('ni', 0, 5);
g.InputBufferSize = 100000; % Set the buffer size
fopen(g);
fprintf(g, '*IDN?')
idn = fscanf(g);
fclose(g);

num1all=0; % initialisieren der variablen für den summenvector
num2all=0;
num3all=0;
num4all=0;
freq=0;

fopen(g);
%read list parameters (frequency points)
fprintf(g, ':SOUR:LIST?');
fpoint=fscanf(g);
listchar=strsplit(fpoint,',');
list=[cellfun(@str2num, listchar(:,1:end))]
clear listchat; clear fpoint;

%analyze list content
points=freq(1);

for i=1:8
%Tables selecten
fprintf(g, strcat(':SOUR:LIST:TABL 0',num2str(i)));
pause(1); %pause 1s zum umschalten der tabelle

%parameter1 abholen
fprintf(g, ':DATA:FDAT1?'); %parameter 1 anfragen
par1=fscanf(g); %parameter 1 holen

string1=strsplit(par1,','); %parameter 1 string nach komma zerlegen
%num1=[cellfun(@str2num, string1(:,1:end))] %parameter 1 strings in dec konvertieren
num1=[cellfun(@str2num, string1(:,1:end))];
num1all=[num1all,num1]; %parameter1 aktuell mit parameter1 aus vorherigem durchlauf concentenaten

fprintf(g, ':DATA:FDAT2?');
par2=fscanf(g);
string2=strsplit(par2,',');
num2=[cellfun(@str2num, string2(:,1:end))]
num2all=[num2all,num2];

fprintf(g, ':DATA:FDAT3?');
par3=fscanf(g);
string3=strsplit(par3,',');
num3=[cellfun(@str2num, string3(:,1:end))]
num3all=[num3all,num3];

fprintf(g, ':DATA:FDAT4?');
par4=fscanf(g);
string4=strsplit(par4,',');
num4=[cellfun(@str2num, string4(:,1:end))]
num4all=[num4all,num4];

%read list parameters (frequency points)
fprintf(g, ':SOUR:LIST?');
fpoint=fscanf(g);
listchar=strsplit(fpoint,',');
listraw=[cellfun(@str2num, listchar(:,1:end))];
list=listraw(:,2:end); %von pos2 das feld schreiben (an pos ist die anzahl der zeilen)

for c=1:3:96
freq=[freq,list(c)]; %von jedem 3. wert aus list ein neues array bilden
end

clear listchat; clear fpoint;

pause (1);
end

%%

%ausgabevariablen festlegen
frequency=freq(:,2:end);
param1=num1all(:,2:end);
param2=num2all(:,2:end);
param3=num3all(:,2:end);
param4=num4all(:,2:end);

%%
% Cell array richtig uma drahn
x1=param1(1:32);
y1=param1(33:256);
param1 = [y1 x1];

x2=param2(1:32);
y2=param2(33:256);
param2 = [y2 x2];

x3=param3(1:32);
y3=param3(33:256);
param3 = [y3 x3];

x4=param4(1:32);
y4=param4(33:256);
param4 = [y4 x4];
%%
%uerberflüssige variablen loeschen
clear c; clear i; clear list; %clear freq;
clear par1;clear par2;clear par3;clear par4;
clear string1;clear string2;clear string3;clear string4;
clear num1all;clear num2all;clear num3all;clear num4all;

fclose(g);

%plotten der ergebnisse
figure(1);
plot(frequency,param1);
grid on; hold on;
xlabel('Frequency [Hz]'); ylabel('Measurement Parameter1 |Z| [Ohm]');
title('Agilent LCR Keule');

figure(2);
plot(frequency,param2);
grid on; hold on;
xlabel('Frequency'); ylabel('Measurement Parameter2');
title('Agilent LCR Keule');

figure(3);
plot(frequency,param3);
grid on; hold on;
xlabel('Frequency'); ylabel('Measurement Parameter3');
title('Agilent LCR Keule');

figure(4);
plot(frequency,param4);
grid on; hold on;
xlabel('Frequency'); ylabel('Measurement Parameter4');
title('Agilent LCR Keule');

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

 

 

 

Technik-Spielzeug von früher – aus Kunststoff

Gar nichts mit Elektronik hat dieser Beitrag zu tun. In meinem Retrowahn war ich wieder einmal in den Kellerräumen des Elternhauses stöbern und habe dort hinter staubigen Einmachgläsern  modrig riechende Kartons mit unbekanntem Inhalt entdeckt. Also was blieb mir übrig, den Inhalt dieser Kartonagen freizulegen und anzusehen. Und was hier zum Vorschein kam, waren weitere Kartons des bekannten Spielzeugherstellers „LEGO“. Einige sehr verstaubte originale Schachteln von Lego-Technik Modellen und alte Waschpulverkartons, die mit vielen, vielen bunt gemischten Lego-Bausteinen und anderem Zeug und leider auch Müll gefüllt waren. Eigentlich, dachte ich mir, diese vielen Plastikteile kann ich in den Müll werfen, denn damit wird auch mein Sohn sicher nicht mehr spielen. Alles riecht nach Keller und ist schmutzig und die Arbeit, das alles zu reinigen und zu sortieren wird sich sicherlich niemand mehr antun. Aber anderer seits ist das wirklich altes Spielzeug aus den 70igern und 80iger Jahren – also schon über vierzig Jahre alt. Und das ist wieder genau mein´s. 🙂 Dinge aus meiner Kindheit und entsprechende Erinnerungen daran.

Also alles eingepackt und nach Hause transportiert. Und dann in mühevoller Arbeit alles einmal nach Farben sortiert und von Müll und legofremden Teilen befreit. Und jetzt begann die eigentliche Arbeit. Das Ziel sollte sein, aus den vielen Teilen wieder die alten Lego-Technik Modelle zusammen zu setzen und fehlende Teile soweit noch vorhanden, nach zu bestellen. Es sollten die „Vintage Baukästen“ so gut wie möglich in ihrer Originalität wieder hergestellt werden.

Gut durchmischte und nicht vollständige Legoboxen

Auf dem Foto ist ein kleiner Teil der „ausgegrabenen“ Legoboxen zu sehen. Hier waren zumindest die Schachteln schon einmal grob gereinigt. Was nach der mühevollen Sortier- und Aufbauarbeit herauskam kann sich allerdings auch wieder sehen lassen.

 

Nr. 853 Lego Car-Chassis

 

Die Nummer 853 ist das Autochassis. Verkauft wurde der Bausatz im Jahr 1977. Er besteht aus 601 Teilen und fertig aufgebaut ca. 52cm lang und 22cm breit.

Das Modell hat einen Vierzylinder Reihenmotor mit Zweiganggetriebe und Kardanwelle zur starren Hinterachse. Das Getriebe, sowie die Kolben sind funktionstüchtig. Ebenso funktioniert die Lenkung. Die Sitze sind in der Längsachse verschiebbar.

In dieser Serie war die Hinterachse noch starr und mit einem Differential ausgestattet. Im folgenden Bild ist der aufgeräumte, wieder hergestellte Baukasten zu sehen.

 

Nr.: 8860 Car Chassis

Aus 671 Einzelteilen ist das Auto Chassis mit der Nummer 8860 zusammenzusetzen. Das Set stammt aus dem Jahr 1980 und hat eine Grösse von 46×19 cm. Hier wurde im Vergleich zum 853er schon einiges erweitert. Die Hinterräder sind einzeln aufgehangen und besitzen eine Federung. Der Motor sitzt hinten und ist diesmal ein Vierzylinder Boxer. Auch hier gibt es ein Getriebe mit drei Stufen.

Die Sitze sind in Längsrichtung verstellbar und die Neigung der Sitzlehne kann ebenfalls eingestellt werden. Auch hier ist wieder eine Zahnstangenlenkung verbaut.

Die Originalverpackung ist noch vorhanden und sieht im sortierten Zustand wie folgt aus:

 

Nr. 854 Lego GoKart

Aus dem Jahr 1978 stammt das Lego GoKart Nr. 854. Es hat die Abmessungen von ca. 21 x 13cm und wird aus 206 Teilen zusammengesetzt. An realisierten Funktionen gibt es eine Zahnstangenlenkung und einen Einzylinder-Motor, mit einem funktionstüchtigen Kolben. Die Hinterachse ist starr und die Welle über eine Übersetzung mit der Kurbel des Kolbens verbunden. Laut Angaben im Netz hat dieses Modell mittlerweile Kultstatus erreicht, da es eines der ersten Lego-Technik Modelle überhaupt sein soll. Ist hier die Originalverpackung und vorallem die Nummer 9 an der Frontseite noch vorhanden, dann soll das Modell in Sammlerkreisen richtig wertvoll sein. Leider kann ich keines der beiden Kriterien erfüllen.

Nr. 856 Lego Bulldozer

 

Mit dem Modell Nr. 856 hat Lego eines der unzähligen Baufahrzeug-Modelle auf den Markt gebracht. Der Bulldozer stammt aus dem Jahr 1979 und besteht aus 370 Teilen. Die Grundfläche beträgt 24x 11cm bei einer Höhe von 14cm. Von den Funktionen ist die Schaufel kipp-, heb- und senkbar. Zwei Ketten auf Zahnrädern stellen die Verbindung zur Auflagefläche dar.

 

Leider ist auch hier von der Originalverpackung auch nur mehr die Schachtel ohne Innenteilung vorhanden.

 

Nr. 8848 Lego Unimog

Der Unimog 8848 aus dem Jahr 1981 misst an der Grundfläche knapp 30x12cm bei einer Höhe von 14cm. Er besteht aus 398 Teilen. Als funktionierende Technik ist hier wieder die Lenkung, die kippbare Ladefläche, sowie eine heb- und senkbare, sowie kippbare Schaufel vorhanden.

Auch hier fehlt von der Schachtel leider die Innenausstattung, ansonsten ist auch das Modell komplett. Ausser den hier vorgestellten, vollständigen Baukästen sind noch einige weitere vorhanden, bei denen aber leider zu viele Teile fehlen. Aber irgend ein Flohmarkt oder online Konvolut an Legoteilen wird sich wohl einmal ergeben, um auch diese Sets zu komplettieren und vollständig in eine Retrosammlung aufnehmen zu können.

 

 

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: