Alle Beiträge von bihlo

Datenknoten mit Arduino

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

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

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

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

Joy-It Uno Boards

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

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

Alle Arduinos sind mit I²C Datenbus und Spannungsversorgung verbunden

Der Ablauf läuft wie folgt:

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

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

Der Programmcode als Beispiel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// I2C Slave Code
// 16.05.2018 
// ver 1.3
#include <Wire.h>
#define ADDRESS 2     // adresse des slave knotens
#define PAYLOAD_SIZE 2 // anzahl der bytes  die vom masterknoten zu erwarten sind
int LED=12;            // indicator led an pin D12
int SENSOR = 8;        // sensor input an pin D8
bool actionState=0;      // sensor zustand
int busstatus;  // statusvariable 
                       // 0 = LED aus | sensor nicht belegt
                       // 1 = LED ein | sensor nicht belegt
                       // 2 = LED aus | sensor belegt
                       // 3 = LED ein | sensor belegt
 
bool sensled=0;          // sensor LED
byte nodePayload[PAYLOAD_SIZE];

void setup()
{
  pinMode(LED, OUTPUT);         //sensorLED
  pinMode(SENSOR, INPUT);       //Sensor 
  Wire.begin(ADDRESS);          // Activate I2C network
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent); // auf master anforderung warten
                      //  // debug interface
                      //  Serial.begin(9600); 
}

// *********************************mainloop****************************************************
void loop()
{ 
  delay(5);
  
   if(sensled){digitalWrite(LED, HIGH);}
         else{digitalWrite(LED, LOW);}

  actionState = digitalRead(SENSOR);  //Sensoreingang abfragen        
   if((actionState==1)&&(sensled==1)) {busstatus=3;}
   else if ((actionState==0)&&(sensled==1)) {busstatus=1;}
   else if ((actionState==1)&&(sensled==0)) {busstatus=2;}
   else if ((actionState==0)&&(sensled==0)) {busstatus=0;}

                      //  Serial.println("######################");
                      //  Serial.print("busstatus neu setzen ");
                      //  Serial.println(busstatus);
                      //  Serial.print("sensled LED            ");
                      //  Serial.println(sensled);
                      //  Serial.print("actionState           ");
                      //  Serial.println(actionState);
                      //  Serial.println("######################");
  nodePayload[0] = ADDRESS;                  // Adresse in byte0 zurücksenden.  
  nodePayload[1] = busstatus;                //byte 1 ist die statusinfo der LED
}



// *********************************************************************************************
void requestEvent()
{ Wire.write(nodePayload,PAYLOAD_SIZE);  
  Serial.println("bytes status schreiben");
  Serial.println(nodePayload[0]);
  Serial.println(nodePayload[1]);
  delay(5);
}

// *********************************************************************************************
void receiveEvent(int bytes)  //einen wert vom I2C lesen
      
{
  
  busstatus = Wire.read(); //If the value received was true turn the led on, otherwise turn it off  
                              //  Serial.println("status empfangen");
                              //  Serial.println(busstatus);
  if((busstatus==1)||(busstatus==3)){sensled = 1;}
                                else{sensled = 0;}
                                              
}

 

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

 

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

#define busbytes 2          // wievele byte vom I2C knoten zu erwarten sind
#define maxKNOTEN  10       // anzahl der zu scannenden slaves
#define startKNOTEN 2       // startadresse der slaves
#define DELAY 5             // einfach ein delay ....

int i; int j=0;
int buttonPin = 12;
int testbut = 0; int anim = 0;
int buttonState = 0;
int DATEN[busbytes];
int adresse; int busstatus;  
byte sensorbelegt; byte ledsensoron;

                       // 0 = LED aus | Sensor nicht belegt
                       // 1 = LED ein | Sensor nicht belegt
                       // 2 = LED aus | Sensor belegt
                       // 3 = LED ein | Sensor belegt

int leddat1[] = {1,1,1,1,0,1,1,1,1}; // -
int leddat2[] = {0,0,0,0,1,0,0,0,0}; // |

void setup()
{
  Serial.begin(9600);  
  Serial.println("MASTER-KNOTEN");
  Serial.print("Maximum Slaveknoten: ");
  Serial.println(maxKNOTEN);
  Serial.print("Datengroesse in byte: ");
  Serial.println(busbytes);
  Serial.println("***********************");
  
  Wire.begin();                 // Activate I2C link
  pinMode(buttonPin, INPUT);    // test-tastereingang festlegen
}


//#####################################################################################################
void loop()
    
{
  for (int Knotenadresse = startKNOTEN;         //alle knoten scannen
           Knotenadresse <= maxKNOTEN; 
           Knotenadresse++) 

        
    //################################################################################################       
    { 
     // testbut = 0;  
     anim = 0;   
    Wire.requestFrom(Knotenadresse, busbytes);        // daten vom jeweiligen knoten anfordern
                                                 
           DATEN[0]=255; DATEN[1]=255;   // wenn kein knoten dann auf 255 setzen    
          if(Wire.available() == busbytes) {                                    // wenn knoten und daten dann
            for (i = 0; i < busbytes; i++) DATEN[i] = Wire.read();          // daten holen (zuerst busID, dann daten)
           // for (j = 0; j < busbytes; j++) Serial.println(DATEN[j]);        // daten an rs232 ausgeben   
          }            

//            Serial.println(Knotenadresse);
//            Serial.println(DATEN[0]);
//            Serial.println(DATEN[1]);
//            Serial.println(" ");
           
            adresse=DATEN[0]; 
            busstatus=DATEN[1];
           
            if(busstatus == 0)       {sensorbelegt=false;  ledsensoron=false;}
            else if (busstatus == 1) {sensorbelegt=false;  ledsensoron=true;}
            else if (busstatus == 2) {sensorbelegt=true;  ledsensoron=false;}
            else if (busstatus == 3) {sensorbelegt=true;  ledsensoron=true;}
      
         //################################################################################################
         //Testbutton Status lesen und variable testbut entsprechend setzen
       
          buttonState = digitalRead(buttonPin);               //tastereingang einlesen
          if(buttonState == HIGH){                            //wenn taster aktiv dann variable anim setzen
          anim = 1;
          //delay(5); 
          }
            
//            //debug debuginfo tasterstatus auf rs232 ausgeben
//            Serial.println("#######################");
//            Serial.print("Knoten Adresse    :");
//            Serial.println(adresse);
//            Serial.print("Busstatus         :");
//            Serial.println(busstatus);
//            
//            Serial.println("----------------");
//            Serial.print("Fliese belegt    :");
//            Serial.println(sensorbelegt);
//            Serial.print("LED Fliese       :");
//            Serial.println(ledsensoron);
//            Serial.print("#######################");
//            Serial.println(" ");
      
          //################################################################################################
          //Testbutton Status an jeweiligen knoten senden
      
          Wire.beginTransmission(Knotenadresse);           // transmit to device actual in for loop
          //anim schreiben
                    
           if (anim==0) {testbut=leddat1[j]; j++;}
                   else {testbut=leddat2[j]; j++;}
           if (j>8){j=0;}
          
          Wire.write(testbut);                             // senden des tasterstatus
          Wire.endTransmission();                          // ende gelände mit uerbertragung
       
          delay(DELAY);
          

    }
   
}

 

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

 

 

 

Solar – Radiometer

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

 

Die Funktionsweise des Solar-Radiometer:

Flügelrad im inneren der teilevakuierten Glaskugel

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

 

Temperatursensor für IV-11 DCF melody

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

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

Sendermodul

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

Sender mit Solarzelle

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

Empfängerplatine im Gehäuse

 

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

USB – Stick defekt?

 

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

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

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

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

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

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

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

DAT-Walkman Sony TCD-D3

Sony TCD-D3

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

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

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

reparierte Leiterbahn

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

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

lackierte Seitenteile

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

Spezifikationen des TCD-D3

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

 

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)

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.

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!