8-Bit Generation: Der Sinclair ZX-Spectrum

Der ZX-Spectrum von Sinclair

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

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

Datenrecorder zum Laden und Speichern von Programmcode

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

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

Frontblech und Gummitastenmatte enfernt

freigelegte Tastaturfolie

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

Mainboard des ZX-Spectrum 48K Issue 4A

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

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

Elektrolytkondensatoren erneuern

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

die alten Elkos

Mainboard mit neuen radialen Elkos

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

Umbau des RF-Modulators auf Videoausgang

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

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

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

Einstellung der Bandgeschwindigkeit

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

 

Taschenrechner aus dem Jahr 1975: PICO PA-80N

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

Pico mit dem Kunstleder Etui

Zu den Daten:

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

LED´s unter der konvexen Kunststoffvergußmasse

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

Mainboard des PICO

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

Netzteilbuchse an der Oberseite

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

Aufgeklappte Platinen

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

Prozessor

Displaytreiber

Datenblatt des C593 (Quelle: 1977 Datacatalog GI Microelectronics)

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

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

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

Datenknoten mit Arduino

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

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

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

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

Joy-It Uno Boards

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

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

Alle Arduinos sind mit I²C Datenbus und Spannungsversorgung verbunden

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

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

Der Programmcode als Beispiel:

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

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

 

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

 

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

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

 

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

     

Kleines Bastelprojekt zur Sommerzeit

Solarmodul

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

Um das nun auch durchführen zu können, muss aus der Nennspannung der Photovoltaikzelle die Betriebsspannung des USB-Standards (5V) erzeugt werden. Das könnte man jetzt ganz einfach mit einem 7805er Regler machen und die Differenz dabei in Wärme umwandeln. Doch das ist die, so ziemlich ineffizienteste Möglichkeit, die Energie des Panels in ein Handy zu bekommen.

Zum einen ist der Innenwiderstand des Panels von der Lichtintensität abhängig, was einen großen Einfluss auf den Wirkungsgrad bei nicht angepassten Lastwiderständen hat. Zum anderen ist ein Längsregler ein Energievernichter, da die Differenz zwischen Eingangsspannung und geregelter Ausgangsspannung bei Stromfluß in Verlustleistung, also Wärme umgewandelt wird. Hier ist man mit einem Schaltwandler (Buck-Converter) besser bedient.

In einem einfachen Laboraufbau kann das Verhalten des Panels untersucht werden. Dazu wird die Leerlaufspannung des Panels bei unterschiedlicher Beleuchtungsstärke gemessen. Anschliessend wird das Panel mit unterschiedlichen Widerstandswerten belastet und der Strom durch die Last, sowie die Spannung am Panel gemessen. Die Messwerte werden aufgezeichnet und der Ri (Innenwiderstand der Quelle) berechnet. Der nachfolgende Stromlaufplan zeigt den Messaufbau:

Messaufbau - Schaltung

Als Amperemeter dient ein Agilent- und als Voltmeter ein Keithley 2701 Tischmultimeter. Diese Messgeräte können beide über SCPI-Befehle gesteuert werden. Als Schnittstelle ist  jeweils ein LAN-Port vorhanden. Das macht es einfach, über einen PC und ein geeignetes Script, einen automatisierten Messablauf zu realisieren. Und da Matlab eine sehr bequeme Möglichkeit bietet, zu scripten, wird es auch gleich verwendet. Um in einem Labor messen zu können und in etwa die selben Umgebungsbedingungen zu haben, wird anstelle der Sonne eine Tischlampe mit Halogenglühbirne verwendet. Die Helligkeit der Lampe wird einfach durch die Versorgung mit einem Labornetzgerät von 0-13V eingestellt. Natürlich kann auch das Labornetzgerät per Matlab gesteuert werden.

Messaufbau mit Lampe als "Sonne"

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

Spannung an der Lampe ergibt Beleuchtungsstärke

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

Innenwiderstand vs. Beleuchtungsstärke

Innenwiderstand vs. Spannung an der Lampe

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

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

(Quelle: Datenblatt des Herstellers TEXAS Instrument)

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

Schaltbild des DC-DC Converters

Messung der Beleuchtungsstärke

Messaufbau

Schaltbare Lastwiderstände

Layout am Computer

Folie zum Erstellen der Printplatte

Geätzte PCB

 

Bestückte PCB

Fertige Schaltung

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:

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.

Sendermodul

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.

Sender mit Solarzelle

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.

Empfängerplatine im Gehäuse

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.

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