Eine schnelle Lösung suchte ich für folgendes elektrotechnisches Problem: Ein Grenzwertschalter eines Anemometers liefert als Ausgang ein, von der Winddauer des Sensors abhängiges Signal. Das Signal ist eine geschaltete Netzphase, die, für die Dauer der erfassten Windschwelle plus einer Nachlaufzeit von 3-120 Sekunden, am Ausgang ansteht.
Dieses Signal soll nun aber als Eingang für einen Homematic Schaltaktor verwendet werden, der ebenfalls eine Netzphase als Schalteingang benötigt. Das ansich passt ja schon perfekt. Man muss nur für beide Geräte die gleiche Phase klemmen. ABER: Der homematic Aktor unterscheidet am Eingang unterschiedliche Modi: Einen kurzen „Tastendruck“ z.B. 0.1 < 0.9s, einen langen „Tastendruck“ zB 1 – 2s und einen Tastendruck >4s. Der letzte Modus versetzt den Homematic-Aktor in den „Anlernmodus“ in dem er mit einer CCU oder Sensor verbunden werden kann. Das macht man üblicherweise nur einmal beim Einrichten der Anlage.
Nach Möglichkeit sollte also ein Anliegen der Schaltphase am Homematic-Aktor Eingang für eine bestimmte Zeit erfolgen, die die vier Sekunden nicht überschreiten darf. Das jedoch wird dem Wind, der über den Grenzwertschalter erfasst wird, ziemlich egal sein… Der bläst einfach solange er will 😀
Also benötige ich eine kleine Schaltung, die mir nach Anlegen einer Netzspannung unbekannter Dauer einen Ausgangsimpuls mit einer bestimmten Pulsdauer (zB. 0.5s) erzeugt. Das soll die Skizze darstellen. L ist hierbei das Ausgangssignal des Grenzwertschalters und L´ ist der gewünschte Impuls am Homematic-Aktor Eingang.
Folgende Schaltung soll das Problem lösen: Ein frequenzabhängiger Widerstand (Z) in Reihe mit einer Zenerdiode… Also ein Kondensator in Reihe zu einer 12V Z-Diode dient als Spannungsteiler, der mir eine 12V Versorgung aus der Netzspannung erzeugt. Die 1N4007 zusammen mit dem 100uF Kondensator richtet gleich und glättet die Spannung. An dieser Quelle hängt jetzt ein weiterer Kondensator in Reihe mit der Relaisspule. Wird die Spannung jetzt angelegt und ist der 470uF Elko nicht geladen, so fließt durch ihn und die Spule für kurze Zeit ein Strom, und die Spule zieht an. Sobald der Elko geladen ist (5Tau), fließt kein Strom mehr und die Spule fällt wieder ab. -> und genau das wollen wir ja. Die Zeitkonstante wird durch die Kapazität des Kondensators und des Spulenwiderstandes der Relaisspule bestimmt. Die parallel zu den Kondensatoren geschalteten Widerstände dienen zum Entladen der Kondensatoren im spannungsfreien Zustand. Die hier dargestellte Anordnung erzeugt einen Schaltimpuls von in etwa 500ms und ist nach 10s wieder bereit…
Hier ist die auf einer Lochrasterplatine schnell aufgebaute Schaltung dargestellt:
Das Thema „Radioaktive Strahlung“ bzw. deren Messung, beschäftigt mich auch immer wieder. In einem alten Weblogeintrag habe ich bereits einmal einen Geigerzähler geplant und ihn als Ausbildungsprojekt mit dem damaligen Elektroniker-Lehrling gebaut. Als Zählrohr kam ein Philips-Rohr ZP1400 aus meinen alten Lagerbeständen zum Einsatz. Die benötigte Betriebsspannung für das Zählrohr generierte ein, über einen 555er angesteuerter Transformator/Wandler mit nachgeschalteter Greinacherkaskade. Diese Schaltung hat den Nachteil, dass sie relativ viele und große Komponenten benötigt und somit auch einen unhandlichen Aufbau nach sich zieht. Die Schaltung hat die Impulse lediglich auch nur hörbar gemacht. Einen Zähler, oder Integrator hat die Schaltung nicht mehr bekommen. -> man konnte ja optional ein Mikrocontroller Board (Arduino UNO , PIC, etc.) anschliessen…
Auf jeden Fall wollte ich noch einen anderen Detektor bauen. Irgendwann habe ich bei Neuhold-Elektronik günstig ein weiteres Zählrohr gefunden und auch gleich bestellt. Dabei handelt es sich um eine Geiger-Müller Röhre RFT VA-Z-114 (70014NR) aus DDR Beständen. Also warum damit nicht noch einen weiteren Geiger-Müller Zähler basteln. Diesmal sollte die Elektronik jedoch um einiges kleiner ausfallen. Als Grundlage für den neuen Zähler diente das Konzept eines Bausatzes von Pollin, der schon lange nicht mehr lieferbar ist, jedoch noch immer auf der Webseite publiziert wird. Teile dieses Schaltungskonzeptes habe ich nun für dieses Projekt herangezogen. Hier wird die Hochspannung mit einem Boostconverter – IC MC34063 der über einen FET eine 330uH Induktivität schaltet, erzeugt. Die Impulse der Röhre werden über Schmitt-Trigger und Filter aufbereitet und die Software in einem ATTINY2313 übernimmt das Zählen.
Die Spannungserzeugung habe ich hier übernommen. Für die Auswertung kommt jedoch der Atmega328 zum Einsatz. Ein kleines LC-Display (mit 8×2 Zeichen) wird die Impulse anzeigen. Ein paar andere Funktionen, wie Batteriespannung etc. sollen auch noch implementiert werden, da der Atmega ja auch A/D- Converter Eingänge hat und mit 10Bit auch eine genügend hohe Auflösung. Die ganze Schaltung sollte dann so groß werden, dass sie in einem 15x8x5cm großen Gehäuse Platz findet. Als Energiequelle wird eine 9V Blockbatterie zum Einsatz kommen.
Der Schaltplan ist schnell gezeichnet und daraus ein Layout erstellt.
Das ist das Platinenlayout in der ersten Version. Eine einseitig gelayoutete Platine mit ausschließlich bedrahteten Bauteilen wird hier völlig ausreichend sein und kann die geplante Größe einfach erreichen. Nach den folgenden drei Fertigungsschritten: (auch hier zu sehen)
Bohrplotten
Belichten und Entwickeln
und abschließend Ätzen,
ist die Platine soweit fertig, dass sie bestückt werden kann. Vorher wird auf die Kupferseite noch eine Schicht Lötlack aufgetragen, um hässliche Korrosionen der Kupferschicht zu vermeiden und eine gute Lötoberfläche zu erhalten.
Das ist die Platine in der bestückten Ausführung. Hier fehlen noch der Mikrocontroller, das LC-Display und natürlich das Zählrohr. Doch zuerst habe ich begonnen, das Gehäuse vorzubereiten und eine Alu-Frontplatte zu erstellen, die dem ganzen Konstrukt ein etwas schöneres Aussehen verleiht. Ein Layout hierfür kann mit allen möglichen Konstruktionstools erstellt werden, die die Möglichkeit bieten, die Zeichnung beispielsweise im „dxf“-Format zu exportieren. Die vhf-Fräsbohrplotter müssen jedenfalls mit den Exportformaten umgehen können und sie idealerweise auch maßstabsgetreu auf den Rohling übertragen können.
Das Ergebnis der Fräsarbeiten, sind diese beiden Platten, die dann miteinander verschraubt werden, das Display, die Schalter und Taster halten sollen. Damit die eingefrästen Vertiefungen in der Aluminiumplatte schlussendlich auch schön kontrastreich zu sehen sind, werden sie mit schwarzem Acryllack gefüllt.
So sieht die fertige Frontplatte aus.
Jetzt wird die Elektronik im Gehäuse untergebracht. Wie hier gut zu erkennen ist, hat wieder das ZP1400 Zählrohr von Philips seinen Platz gefunden. Leider war dem Neuhold – DDR Zählrohr trotz vieler Experimente kein einziger Impuls zu entlocken. Ich vermute, das Rohr hat im Laufe der vielen Lagerjahre Luft gezogen und ist einfach defekt.
Alle Komponenten haben ihren Platz gefunden. Die „Trennkammern“ sind kupferbeschichtete FR4 Platten, die einerseits die Röhre in Position halten und andererseits eine Kammer für die 9 Volt Blockbatterie darstellen.
Hier ist nun alles zusammengebaut. Als Testsoftware werden die Impulse vorerst lediglich nur über einen IRQ Eingang gezählt und über den kleinen Lautsprecher hörbar gemacht. Wenn das Programm dann einmal fertig ist, werde ich es hier wieder veröffentlichen…
Ein schon lange in meinem Kopf herumirrender Gedanke war, einmal einen Videospielautomaten zu bauen. Diese Teile haben mich als Kind magisch angezogen, wenn es mit den Eltern in den Sommerurlaub an die Adria ging. Dort gab es und gibt es auch heute noch die Spielhallen. Die Faszination hat aber seit Erscheinen der Heimkonsolen und der Möglichkeit, vor dem heimischen TV-Gerät zu zocken, stark nachgelassen, und die Automaten wurden rar. Auch die einfache Pixelwelt, der 8Bit und 16Bit Spiele ist schon lange verschwunden. Dabei, so finde ich zumindest, haben die alten, einfachen 8Bit Pixelspiele mehr Reiz, als die modernen High-End-Games mit fotorealistischer 3D-Rendergrafik. Vielleicht ist auch aus dem Grund der „Retroboom“ der letzten Zeit entstanden. Nun ja – mein erster Kontakt zu den Videospielautomaten war eben als Kind im Urlaub und dann erstmals am heimischen TV, Ende der siebziger Jahre an einer geliehenen Atari 2600 Konsole. In den letzten Jahren, auch Dank des Internets, habe ich immer wieder mal die Zeit gefunden in Foren und auf Websites zu schmökern und so die Faszination aufrecht zu erhalten. Auch die Vielzahl an Emulatoren (Mame, Vice, etc.) die ganz leicht und schnell auf jedem PC eingerichtet werden können, lässt schnell die alten Gefühle wieder aufkommen.
Nun ja, dieses Jahr habe ich mich überwunden und das Projekt endlich begonnen. Dank Internet und elektronischer Bucht ist es jetzt auch einfach, die benötigten Materialen zu bekommen. Die Basis des Videospielautomaten „Arcade – Station“ soll ein Raspberry Pie sein. Den kleinen Einplatinenrechner gibt es mittlerweile schon in der 3. Generation und der hat auch mächtig Leistung um die alten Homecomputer und Spielekonsolen wie Commodore C64, Amiga, Atari, Nintendo 64 etc. in der Emulation zum Laufen zu bekommen. Als Softwarebasis nutze ich das Projekt retropie , das mittlerweile als DAS Projekt für die Umsetzung von Retrospielekonsolen und -computern bezeichnet wird. RetroPie wird als Image für alle Raspberry Pi Modelle angeboten und ständig weiterentwickelt. Es ist einfach einzurichten und man hat schnell wieder das „feeling“ der guten alten 8 Bit Zeit 🙂
Folgende Dinge benötige ich für den Bau der Retro-Arcade Maschine:
Rasperry Pi als Zentrale Recheneinheit
Ein Interface, das die Microschalter der Joysticks und Tasten in ein USB-HID umsetzt (hier kommt mein Arduino HID Projekt zum Einsatz) es gibt aber auch etliche Controller (XinMo und GPIO Controller etc.)
Tasten und Joysticks für die Bedienkonsole
Ein Gehäuse passend im Stil einer Arcademaschine . (Hier habe ich einen Tischler beauftragt, beschichtete MDF-Platten zu s chneiden und mit der Oberfräse die Kanten zu bearbeiten)
Eine Bemalung des Gehäuses (in meinem Fall schwarzer Mattlack und ein auf Klebefolie gedrucktes Design.)
Adapterkabel für den Anschluss des Monitors an den Raspberry
Lautsprecher und einen Audioverstärker
Eine Hintergrundbeleuchtung für den Ledkasten
Zeit und Geduld, Werkzeug und ein bisschen Geschick
Die folgenden Bilder sollen den Auf- und Zusammenbau der Arcadestation ein wenig dokumentieren:
Die Gehäuseteile sind geliefert und werden erstmal auf Passgenauigkeit und Vollständigkeit überprüft.
Alles passt zusammen.
Das sind die Dekor-Klebefolien
Die Joysticks …
… und die Tasten
Im Garten werden die Teile zum Lackieren vorbereitet. Ja, jetzt vor Beginn der Blütezeit klappt das mit dem Outdoorlackieren noch ganz gut.
Schon bald sind die Teile mit einer matten, schwarzen Lackschicht überzogen.
Mit Klarlack wird dann nochmals übergesprüht.
Jetzt ist der Cutter dran, die Dekorfolien müssen zugeschnitten werden.
auch alle Löcher für Tasten und Joysticks
und natürlich sollen auch die Kanten schön aussehen
nach dem Bekleben mit den Folien wird wieder probiert. Passt perfekt…
Nachdem jetzt alle Teile vorbereitet sind, kann der Zusammenbau beginnen
Tasten einbauen und Microschalter/-taster bestücken
Joystickmodul einbauen und verschrauben
Ansicht von oben (sieht ja schon mal nicht schlecht aus)
Jetzt kann mit der Verkabelung begonnen werden. Es empfiehlt sich, alle Drähte zu beschriften 😉
Nach dem Verkabeln der Tasten wird wieder provisorisch zusammengesteckt und ein erster rein informeller Funktionstest gemacht.
und schon kann mit der Monitorhalterung begonnen werden. Ich habe einen 19″ Monitor mit vier M4 x 20 Schrauben am Brett befestigt. Zwischen Brett und Rückseite des Monitors sind noch 4mm Abstandhalter unterlegt, um die Löcher im Blechkasten des Bildschirmes nicht durch das Bett abzudecken.
So ist der Bildschirm mit dem Brett verschraubt.
Die Monitorhalterung samt Monitor wird jetzt in Position gebracht, die weiteren Montagelöcher gebohrt und dann mit einer Seitenwange verschraubt. Auch das bestückte Bedienpanel sowie das Lautsprecherpanel und die restlichen Gehäuseteile werden mit der Seitenwange verleimt.
Das soll dann so aussehen. Passt alles, dann kann die andere Seitenwange vorbereitet werden. Ist alles gebohrt, wird wieder geleimt und das Gehäuse bekommt seine zweite Seite.
Das Seitenteil liegt perfekt in der Nut. Mit Winkeln wird jetzt alles zusätzlich noch verschraubt.
Jetzt kann der Kasten erst einmal ruhen und der Leim aushärten.
In der Zwischenzeit kann ich eine Montageplatte anfertigen, die den Raspberry und den Controller für die Joysticks tragen soll. Die Platte besteht aus einer 2mm dicken Aluminiumplatte an der ich 20mm lange Sechskant-Abstandhalter schraube. Festgemacht werden die mit M3x10 Senkkopfschrauben.
So sieht die fertige Trägerplatte aus
Sie wird jetzt am Boden des Arcade-Gehäuses angeschraubt
Und hier sind die Platinen auch schon befestigt
Im nächsten Schritt wird die Bildschirmfrontverkleidung, eine 2mm Plexiglasplatte vorbereitet.
Die Ränder der Plexiplatte werde ich von der Rückseite schwarz lackieren. Praktischerweise kann ich die Schutzfolie auch gleich zum Maskieren für die Lackierung verwenden. Mit dem Cutter wird die nicht benötigte Schutzfolie ausgeschnitten und entfernt. Jetzt kann lackiert werden.
Nach dem Lackieren und Entfernen der Schutzfolie habe ich die Ränder mit 9x3mm Unterlegeband (Dichtband) beklebt, das dann auf dem Monitor aufliegen soll und gleichzeitig vor Kratzern in der Plexiplatte und Staub zwischen den Scheiben schützen soll.
Für die seitliche Auflage der Plexischeibe habe ich links und rechts je eine Alukante ans Gehäuse geschraubt.
auch auf die Aluleisten kommt das Dichtband. Jetzt kann die Plexiplatte eingesetzt werden.
Auch innen ist es jetzt ein wenig mehr aufgeräumter. Alle Buttons sind am Controller angeschlossen. Die Innereien eines PC-Speakersets dienen als Audioversorgungseinheit. Ein Led-Streifen soll den „Lichtkasten“ später beleuchten.
Wie der ganze „Automat“ dann im fertigen Zustand aussieht ist im folgenden Video zu sehen:
In den letzten Blogeinträgen habe ich mit dem Arduino einen NTC-Widerstand über einen Spannungsteiler an den Analogeingang des Arduino-UNO angeschlossen und ihn als eigenständiges Programmchen am Arduino als Temperatursensor laufen lassen. Die aktuellen Messwerte wurden auf einem LC-Display angezeigt. Dann habe ich die selbe Hardware über die Matlab Software und das „Arduino for Matlab“-Package betrieben und mittels Matlabcode direkt den Temperaturverlauf geloggt. Im vorhergehenden Blog war dann ein kombinierter Temperatur und Luftfeuchtigkeitssensor (Type HYT939) an der Reihe, der über den I²C Bus am Arduino seine Daten lieferte und wieder am LCD ausgegeben hat.
In diesem Bericht kommt nun wieder Matlab ins Spiel. Hier habe ich versucht, beide Sensoren, den NTC am Analogeingang und den HYT am I²C Bus, gleichzeitig auszulesen. Das sollte über einen mehrere Minuten andauernden Zeitraum passieren, wobei die Messwerte gleich mitgeloggt werden, um sie danach in einem Vergleichsdiagramm zu plotten. Der Hardwareaufbau ist wieder ganz einfach. Der NTC ist in Serie mit einem 2k2 Widerstand geschaltet. Die Enden des Spannungsteilers gehen an die +5V Versorgung und GND und der Teilerpunkt wird an den A0 – Eingang des Arduino Uno angeschlossen. Der HYT bekommt ebenfalls seine 5V vom Arduino selbst und an A4 und A5 ist der I²C anzuschließen (genaue Pinbelegung s. vorgehenden Bericht). Jetzt fehlt noch das Matlab-Script. Es ist hier einzusehen:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Beispielscript um mit ArduinoUno einen Temperaturverlauf aufzuzeichnen
% Sensoren an A0 (Spannungsteiler mit NTC) und HYT939 an I2C
% 03/2016 by I.Bihlo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
a = arduino('com4','Uno','libraries','I2C')
analogpin=0; %Anschlusspin analog des UNO
analog=0; %Variable für den Analogwert festlegen
nn=600; %anzahl der messpunkte
addr='0x28'; %addresse für digitalsensor
bus=i2cdev(a, addr) %i2c object erzeugen
%ein paar konstanten für die weiteren berechnungen
r=2200; %Spannungsteilerwiderstand
rt=0; %das wird der errechnete widerstand des NTC
urt=0; %das wird der errechnete Spannungsabfall am NTC
% konstanten für berechnung der Temperatur aus NTC Widerstand
% B25=3977K
a1=3.354016E-03;
b1=3.2569850E-04;
c1=2.61013E-06;
d1=6.38309e-08;
rref=2200;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Lesen des I2C Bus
% Lesen eines Temperaturabhängigen Widerstandes am Analog Eingang A0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for x=1:nn
%%%% Analog
analog(x)=readVoltage(a, analogpin); %Liest den AnalogIn von A0 und gibt in Volt aus
urt(x)=5-analog(x); %spannungsabfall am NTC
rt(x)=(r/analog(x))*urt(x); %widerstand des NTC
pause(0.5);
%%%%Digital
data = read(bus, 4); %4 byte von i2c auslsesen
pause(0.5);
%Rohdaten aus Puffer lesen und zusammenbauen
humrawh=dec2bin(data(1),8); %byte 1 auf 8bit festlegen in binär wandeln
humrawl=dec2bin(data(2),8); %byte 2 auf 8bit festlegen in binär wandeln
humrawall=strcat(humrawh,humrawl); % beide bins concentenaten
humraw=bin2dec(humrawall); % die ganze kette wieder in dec wandeln
%tempraw=uint16(data(3))*256+uint16(data(4));
temprawh=dec2bin(data(4),8);
temprawl=dec2bin(data(3),8);
temprawall=strcat(temprawl,temprawh);
temprawall=temprawall(1:14); %% die letzten beiden bits abschneiden
tempraw=bin2dec(temprawall);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Humidity berechnen lt. Datenblatt
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
hum(x)=double(100/(16384-1))*double(humraw);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Temperatur berechnen lt. Datenblatt
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
temp(x)=double(165/(16384-1))*double(tempraw)-40.0;
%berechung der analogtemperatur
rvsrref(x)=rt(x)/rref;
tempa(x)=1/(a1+(b1*log(rvsrref(x)))+(c1*(log(rvsrref(x)^2)))+(d1*(log(rvsrref(x)^3))));
tempc(x)=tempa(x)-273.15 %Kelin in Celsius umrechnen
pause(1);
end
clear a;
time=1:nn;
%plotten der daten
figure(1);
subplot(2,1,1);
plot(time,tempc,'m');
grid on; hold on;
%plot(time,analog,'b');
%plot(time,rt/1000,'r');
%plot(time,urt,'g');
plot(time,temp,'g');
legend('Temperatur NTC[°C]','Temperatur HYT939 [°C]');
%legend('Analogspannung des ADC','Widerstand des NTC in kOhm','Spannung am NTC','Temperatur [°C]');
subplot(2,1,2);
plot(time,hum,'m');
grid on; hold on;
legend('Rel Luftfeuchtigkeit HYT939 [%RH]');
%ende
Nachdem der Code nun nach einigen Anpassungen läuft, habe ich beide Sensoren (wie am Titelbild zu sehen) nebeneinander angeordnet und vor Beginn der Messung mit Kältespray (Kälte75 von KontaktChemie) heruntergekühlt. Dann startete das Script und begann aufzuzeichnen. Im Ergebnis sollte der Verlauf der Erwärmung auf die Raumtemperatur zu sehen sein. Da die Kälte am Metallgehäuse des HYT sofort eine Schicht aus gefrorenem Kondensat bildet die langsam taut, erwartete ich mir einen Luftfeuchtigkeitswert im Bereich der Sättigung. (was dann auch deutlich im Plot zu sehen ist).
In den letzten Blog-Einträgen habe ich mit Hilfe des Arduino Uno – Experimentierboards auf unterschiedliche Weise einen NTC-Widerstand zur Messung der Temperatur eingesetzt. Aus einem anderen Projekt habe ich auch noch einen Feuchte/Temperatursensor der Firma IST (Innovative Sensor Technologie) zur Verfügung, der mit einem Raspberry und in Python ausgelesen wurde. Es handelt sich um den digitalen Sensor HYT939, der über den I²C Bus ausgelesen wird. Er zeichnet sich laut Datenblatt mit folgenden Merkmalen aus:
chemisch sehr resistent
sehr weiter Temperatur- und Feuchtigkeitsmessbereich (-40°C .. +125°C, 0% ..100% RH)
mechanisch robuste Bauform
kalibriert und temperaturkompensiert
sehr geringer Drift
einsetzbar bis zu einem Umgebungsdruck von 16bar
Versorgungsspannung von 2.7 bis 5.5V
Auflösung von +/- 0.02% RH und 0.015°C
Genauigkeit von +/- 1.8% RH bei +23°C und +/-0.2K
Also wollte ich diesen Sensor auch mit dem Arduino betreiben und vielleicht in weiterer Folge auch den NTC parallel auslesen und die Ergebnisse vergleichen. Aber zurerst einmal wird der HYT an den Arduino angeschlossen.
Das Bild zeigt das Pinout des HYT in der Ansicht von unten. Die Belegung der Pins lautet:
1…SCL
2…VCC
3…GND
4…SDA
Somit lässt sich der Sensorchip ganz einfach an den Arduino anschließen, wobei die Pins SDA auf den Arduino Pin A4 und SCL auf den Pin A5 gelegt sind. Die Ausgabe der ausgelesenen Werte soll wieder wie beim NTC auf dem LC-Display stattfinden. Nachstehend ist der Code gelistet:
/*
HYT939 bei Arduino UNO an:
SDA pin A4
SCL pin A5
HYT939 bei MEGA2560 an:
SDA pin 20
SCL pin 21
LCDisplay
Pinzuordnungen allgemein für LCD
RS to digital 12
EN to digital 11
D4 to digital 5
D5 to digital 4
D6 to digital 3
D7 to digital 2
R/W to ground
VSS to ground
*/
//I2C Addresse festlegen
#define ADDR 0x28
//Variablen und Datentypen festlegen
double temp;
double hum;
unsigned int tempraw;
unsigned int humraw;
int x;
unsigned char buffer[4];
//Libraries laden
#include <Wire.h>
#include <LiquidCrystal.h>
// interfacepins initialisieren
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
//I2C und LCD Interface initialisieren,
Wire.begin();
lcd.begin(20, 4);
Serial.begin(9600);
lcd.println("HYT939-Sensor");
}
void loop()
{
//I2C auselesen
Wire.beginTransmission(ADDR);
Wire.endTransmission();
delay(200);
//4 Bytes auslesen
Wire.requestFrom(ADDR, 4,true);
x=0;
while(Wire.available())
{ char c = Wire.read(); buffer[x]=c; x++; }
//Rohdaten aus Puffer lesen
tempraw=buffer[2]*256+buffer[3];
humraw=buffer[0]*256+buffer[1];
//Daten laut Datenblatt maskieren
tempraw&=0xfffc;
humraw&=0x3fff;
tempraw=tempraw/4;
//Rohdaten in Ausgabeformat umrechnen
temp=(double)tempraw/99.2909; //skalieren laut datasheet
temp=temp-40.0;
hum=(double)humraw/163.83;
//Daten auf LCD schreiben
lcd.setCursor(0, 2);
lcd.print("Temperatur =");
lcd.setCursor(11, 2);
lcd.print(temp);
lcd.setCursor(0, 3);
lcd.print("Humidity =");
lcd.setCursor(14, 3);
lcd.print(hum);
//lcd.setCursor(0, 2);
//lcd.print('Buffer0 =');
//lcd.setCursor(11, 2);
//lcd.print(buffer[2]);
//lcd.setCursor(0, 3);
//lcd.print('Buffer1 =');
//lcd.setCursor(11, 3);
//lcd.print(buffer[3]);
}
Mein Interesse an Strahlungsmessung im Allgemeinen und das Interesse am Eigenbau von Messgeräten lässt mich oft, vor allem bei langweiligem Fernsehprogramm, im Web recherchieren. Auf der Suche nach dem Begriff Geigerzähler findet man ja unheimlich viele Ergebnisse. Nach einer Unterhaltung mit einem Kollegen, wie es zu Zeiten von Tschernobyl hier mit der Strahlungsbelastung aussah, suchte ich auch nach einer Karte mit der aktuellen Strahlungsverteilung in Österreich und wurde auch fündig. Es gibt ein ganzes Netzwerk an Messgeräten in ganz Österreich verteilt, das stündlich die Radioaktivität misst und aufzeichnet. Über diese Website kann man sich anhand einer Karte mit unterschiedlich (entsprechend der Intensität der Strahlung) eingefärbten Punkten informieren. Klickt man einen Messpunkt an, so erhält man die Detailwerte der Messungen angegeben in nSievert/h dargestellt als Diagramm oder auch in Tabellenform. Die Website nennt sich: https://sfws.lfrz.at.
Toll dachte ich beim Betrachten der Messdaten. Noch toller wäre es, selber so eine Messstation aufzubauen und in mein bestehendes Homematic-System mit aufzunehmen. Oder für´s erste könnte man ja versuchen, die Daten der Website in die Homematic zu integrieren. … und dann beispielsweise bei Überschreitung eines Messwertes eine Nachricht oder einen Alarm zu generieren.
Also perfekte Rohdaten um damit was anfangen zu können 🙂 Im Datensatz ist der Zeitstempel (im Unix-Zeitcode Format), der Messwert in nS/h, sowie ein RGB Farbcode für die Darstellung der Farbe in der Webkarte angegeben. Also beginnen wir, die Messdaten über die Homematic CCU2 Zentrale abzurufen und nach der Datenaufbereitung in Systemvariablen zu speichern.
Als erstes legen wir zwei neue Systemvariablen an:Die erste Variable soll „Strahlungswert“ heissen und vom Datentyp „Zahl“ sein. Als Maßeinheit gebe ich nS/h (nanoSivert pro Stunde) an.
Die zweite Variable benennen wir „Messzeitpunkt“ mit dem Datentyp „Zeichenkette“. Wenn alles mit OK bestätigt ist, dann legen wir unter Programme und Verknüpfungen ein neues Programm an:
Das Programm habe ich „strahlungswerte über web“ genannt und als Trigger ein periodisches Zeitevent definiert. Das Programm soll alle 60 Minuten ausgeführt werden um die Daten vom Web abzuholen und in die Systemvariablen zu schreiben.
Nachdem der Auslöser definiert ist, muss eine Aktivität bestimmt werden. Wir wählen hier keinen Aktor, sondern die Option „Skript“:
Danach klicken wir auf die Script-Zeile und öffnen den Scripteditor:
Die nachfolgenden Zeilen sind am besten per copy und paste in den Scripteditor einzufügen und per OK zu bestätigen.
!script zum importieren der webdaten von der landeswarnzentrale radioaktivität
!by ingmar b.03/2016
string stderr;
string stdout;
string answer;
!Website angeben - die Antwort kommt als string
string url="https://sfws.lfrz.at/json.php?command=getstationdata&stationcode=AT0408&a=&b=";
!mit wget den Inhalt der Antwort in stdout schreiben
!wget commando bei CCU2
!system.Exec("wget -q -O - "#url, &stdout, &stderr);
!Änderung: Ein Blogleser hat mich daraug aufmerksam gemacht, dass der Aufruf von gwet bei der ccu3 nicht wie oben angegeben funktioniert. Darum bei ccu3 Geräten wie folgt:
!wget commande bei CCU3
system.Exec("wget -q -O - '" # url # "'", &stdout, &stderr);
!stdout in die variable answer schreiben
answer = stdout;
!stringlänge des Inhalts von answer ermitteln
integer length = answer.Length();
!foreach(summand, summanden.Split(","))
!answer=answer.Split("},{"));
var rad;
var zeitst;
var radiation;
var zeitstempel;
!Antwort Radiation in index 1,4,7,10,13...70
!Antwort Zeitcode in index 0,3,6,9,12...69
rad=(answer.StrValueByIndex(",", 1));
zeitst=(answer.StrValueByIndex(",",0));
!WriteLine(rad); nur zum debuggen
!WriteLine(zeitst); nur zum debuggen
radiation=rad.Substr(4,4); !String an pos4 substituiern und 4 Stellen ausgeben
zeitstempel=zeitst.Substr(11,10); !String an pos11 substituiern und 10 Stellen ausgeben
zeitst=zeitstempel.ToInteger();
zeitst=zeitst.ToTime();
rad=radiation.ToFloat();
dom.GetObject("Messzeitpunkt").State(zeitst); !Systemvariable muss definiert sein
dom.GetObject("Strahlungswert").State(rad); !Auch die Systemvariable 'Strahlungswert' vorher anlegen
Zum Schluss noch per Fehlerprüfung nachsehen ob der code ein Problem hat und dann OK und mit OK speichern. Hat alles geklappt sollte man jetzt die Systemvariablen ansehen können und es sollten auch gültige Werte zu sehen sein:
Nach dem kleinen Projektchen „Arduino mit Matlab“ möchte ich der Vollständigkeit halber den selben Aufbau auch noch ohne Matlab laufen lassen. Dabei soll der Code mit der mitgelieferten Arduino Entwicklungsumgebung „Arduino Software 1.6.7“ erstellt und in den Atmega 328 geladen werden. Damit man in dieser Stand-Alone-Variante auch was sehen kann, soll ein altes vierzeiliges LC-Display angeschlossen werden. Idealerweise gibt es hier eine schöne library namens LiquidCrystal.h, mit der das LCD im 4Bit Betrieb ganz einfach angesteuert werden kann.
Also schnell die benötigten Pins des LCD (übrigens ein JM204A) aus dem Datenblatt herausgesucht und mit Flachbandkabel und Pinheadern versorgt und an den Arduino angeschlossen. (die Belegung des Arduino habe ich im Script angegeben)
Der NTC-Spannungsteiler bleibt, wie er ist. Und schon kann’s losgehen. Da wir die vier schönen Zeilen mit 20 Zeichen pro Zeile am LCD zur Verfügung haben, kann auch viel Information angezeigt werden. Ich habe mich entschieden, den Integer Wert des 10Bit ADC anzuzeigen (0-1023), den errechneten Widerstandswert des NTC´s und natürlich die daraus errechnete Temperatur.
Und das hier ist der simple Code 😉 …
/* ingmarsretro 2016
* Pinzuordnungen fürs LCDisplay
* RS to digital 12
* EN to digital 11
* D4 to digital 5
* D5 to digital 4
* D6 to digital 3
* D7 to digital 2
* R/W to ground
* VSS to ground
*/
// include libraries
#include <LiquidCrystal.h>
#include <math.h>
int analogpin = 0;
int analogvalue = 0;
double a1=3.354016E-03;
double b1=3.2569850E-04;
double c1=2.61013E-06;
double d1=6.38309e-08;
double urt=0;
double rt=0;
double rvsrref=0;
double temp=0;
double tempc=0;
double r=2200;
double rref=2200;
double analog=0;
// interfacepins initialisieren
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// setup LCD spalten und reihen
lcd.begin(20, 4);
lcd.print("Testprogramm NTC");
Serial.begin(9600);
}
void loop() {
analogvalue=analogRead(analogpin);
analog=(0.004882812*analogvalue);
urt=5-analog;
rt=((r/analog)*urt);
rvsrref=rt/rref;
temp=(1/(a1+(b1*log(rvsrref))+(c1*(log(rvsrref*rvsrref)))+(d1*(log(rvsrref*rvsrref*rvsrref)))));
tempc=temp-273.15;
// column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0,1);lcd.print("ADC-Wert =");
lcd.setCursor(11,1);
lcd.print(analogvalue);
lcd.setCursor(0, 2);
lcd.print("Widerstd =");
lcd.setCursor(11, 2);
lcd.print(rt);
lcd.setCursor(0, 3);
lcd.print("Temp Cels=");
lcd.setCursor(11, 3);
lcd.print(tempc);
Neulich ist mir bei einem Kaltgeräte Anschlusskabel aufgefallen, dass sich der Kabelmantel im Bereich der Zugentlastung gelöst hat. Die Drähte kamen zum Vorschein. Ansich ist das jetzt nichts Besonderes, wenn hier nicht, abgesehen von den ungewöhnlichen Farben, auch der ungewöhnlich kleine Durchmesser der Drähte in Auge stechen würde.
links: Kabel ohne CE Kennzeichnung rechts: StandardkabelStecker ohne jegliche Prüfzeichen.
Normalerweise ist so ein Mantelkabel mit 16A/250V und einem CE Zeichen am Stecker gekennzeichnet. Der Querschnitt der Litzendrähte beträgt 1.5mm2. Bei dem Kabel hier am Foto war aber eine Angabe von 10A/250V aufgedruckt und KEIN CE Zeichen vorhanden. Die Litzen haben einen Querschnitt von unter 0.5mm² !! Wer so ein Kabel verwendet und beispielsweise ein Heizgerät damit betreibt, der darf sich dann nicht wundern, wenn mal schnell ein kleiner Brand ausbricht… Leider kann ich nicht mehr nachvollziehen mit welchem Gerät ich dieses Kabel mitgeliefert bekommen habe. Aber es entspricht nicht den gültigen Normen und stellt eine Gefahr im Betrieb dar. Auf jeden Fall: Finger weg von solchen Produkten!
Nachdem ich im letzten Teil die Installation der Arduino-Matlab Packages zum Laufen bekommen habe, kann es nun weitergehen. Ziel dieses kleinen Beispiels ist es ja, an einen Arduino Uno einen NTC-Widerstand anzuschließen. Dieser soll als analoger Temperatursensor dienen (was er ja ist 😀 ) und über einen der A/D – Eingänge des Arduino eingelesen werden. Matlab soll dann schlussendlich die eingelesenen A/D- Werte in Temperaturwerte umrechnen. Das Ganze soll über eine gewisse Zeit laufen, wobei alle paar n-Sekunden ein Wert eingelesen wird. Am Ende soll ein wunderschöner Temperaturplot mit Temperatur über Zeit erstellt werden.
Doch zuerst zum Sensor. Ich verwende hier einen NTC-Widerstand von dem Hersteller VISHAY mit einem R25 von 2200 Ohm (s.Datenblatt). Das bedeutet, er hat bei 25°C einen ohmschen Widerstand von 2.2kOhm. Je wärmer es nun wird, umso kleiner wird der Widerstand und umgekehrt. Der analoge Eingang des Arduino hat eine Auflösung von 10Bit. Das bedeutet, er kann den Spannungshub am Eingang (eingestellt durch die ADC Referenz) in 210 , also 1024 Teile auflösen (zerlegen). Der Standard beim Arduino ist 0V bis 5V. Also 0V am Eingang bedeutet einen ADC-Wert von 0 und 5V bedeutet einen ADC-Wert von 1024. Die Auflösung, also die kleinste auflösbare Spannungsänderung ist daher:
Gibt der ADC beispielsweise einen Wert von 558 aus, so entspricht dies einer Spannung am Eingang von 558*0.00488V = 2.72304V. Doch wie soll der NTC jetzt an den Eingang angeschlossen werden? Ganz einfach. Man nehme einen Spannungsteiler und dimensioniere ihn so, dass der Strom durch die beiden Widerstände nie so groß werden kann, dass er zum einen die Versorgung des Arduino gefährdet und zum anderen auch nie so groß werden kann, dass er den NTC selbst erwärmt. In der Skizze ist nun dargestellt wie der Spannungsteiler aufgebaut und angeschlossen ist. Jetzt gilt es noch herauszufinden, wie aus der Spannung am ADC der gemessene Widerstandswert berechnet werden kann. Hier hilft die Spannungsteilerregel:
In diesem Beispiel hier besteht der Spannungsteiler aus dem NTC (2k2 @ 25°C) und einem 2k2 Festwiderstand. Wenn der NTC null Ohm haben sollte (nur rein theoretisch), so fließt ein maximaler Strom von 0.002A durch die Widerstände (5V/2200Ohm). Wir lesen jetzt in Matlab den Spannungsabfall am NTC ein und können uns über den Spannungsteiler den Widerstandswert berechnen. Jetzt fehlt nur noch die Formel zur Berechnung der Temperatur. Und die ist, samt den notwendigen Konstanten A1, B1, C1 und D1, im Datenblatt angegeben:Das Ergebnis dieser Berechnung ist die Temperatur in Kelvin. Um die Temperatur aber in °Celsius angezeigt zu bekommen, rechnet man: °C = °K-273,15. Mit all diesen Informationen kann man jetzt ein Matlab-Script schreiben, das dann in etwa so aussieht:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Beispielscript um mit ArduinoUno einen Temperaturverlauf aufzuzeichnen
% 02/2016 by I.Bihlo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%a = arduino('com5','Uno');
a = arduino('com5','Uno','TraceOn', true)
analogpin=0;
analog=0;
%ein paar konstanten für die weiteren berechnungen
%
r=2200; %Spannungsteilerwiderstand
rt=0; %das wird der errechnete widerstand des NTC
urt=0; %das wird der errechnete Spannungsabfall am NTC
% konstanten für berechnung der Temperatur aus NTC Widerstand
% B25=3977K
a1=3.354016E-03;
b1=3.2569850E-04;
c1=2.61013E-06;
d1=6.38309e-08;
rref=2200;
%Lesen eines Temperaturabhängigen Widerstandes am Analog Eingang A0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for x=1:50
analog(x)=readVoltage(a, analogpin) %Liest den AnalogIn von A0 und gibt in Volt aus
urt(x)=5-analog(x); %spannungsabfall am NTC
rt(x)=(r/analog(x))*urt(x); %widerstand des NTC
%berechung der temperatur
rvsrref(x)=rt(x)/rref;
temp(x)=1/(a1+(b1*log(rvsrref(x)))+(c1*(log(rvsrref(x)^2)))+(d1*(log(rvsrref(x)^3))));
tempc(x)=temp(x)-273.15 %Kelin in Celsius umrechnen
pause(2);
end
clear a;
%plot den mist
figure(1);
time=1:50;
plot(time,analog,'b');
grid on; hold on;
plot(time,rt/1000,'r');
plot(time,urt,'g');
plot(time,tempc,'m');
legend('Analogspannung des ADC','Widerstand des NTC in kOhm','Spannung am NTC','Temperatur [°C]');
%ende
So sieht der Graph mit dem Temperaturlog danach aus…
Dieses Teil hier habe ich mir über ebay bestellt. Es ist dies ein Video – „Upscaler“, also ein Teil, das den alten analogen Videostandard (Composite CVBS) digitalisiert und in den HD-Standard 720p bzw. 1080p hochrechnet und über eine HDMI Buchse ausgibt. Gedacht ist es, um den Output eines alten VHS-Recorders, einer alten Spielekonsole oder des guten alten Commodore C64 auf den Fernseher, oder eher auf einen Computermonitor zu bekommen, der einen digitalen Eingang (DVI) hat. So also der Plan. Also im Netz gesucht und unter vielen Angeboten ein Gerät gefunden, das neben den Chinch Buchsen für CVBS-Video und Audio L,R auch noch einen HDMI Eingang besitzt. Cool – dachte ich. Mit drei Tasten soll man Auflösung, 50/60Hz (Pal/NTSC-TV Norm) und eben den Eingang umschalten können.
Also bestellt, bezahlt und auch geliefert bekommen. Und gleich einen ersten Test, wie denn die Bildqualität am PC-Monitor so sei, begonnen. Also das Gerät (in einer Mattschwarzen Metallbox – optisch gut verarbeitet) angeschlossen, das mitgelieferte 5V Steckernetzteil eingestöpselt und in freudiger Erwartung auf den Bildschirm gestarrt. Da stand aber außer „kein Signal“ nur mehr … eben „kein Signal“.
Also erstmal überprüft, ob Saft da ist. Ja – die rote Led am Gerät leuchtete. Dann die Kabelverbindungen überprüft, andere Kabel bzw. Adapter verwendet – nichts. Danach versucht, vom Raspi über HDMI an die Box, dann weiter über HDMI an den TV … nichts. Dann alle möglichen Tasten und Kombinationen gedrückt … wieder nichts. Als Endkontrolle dann den Raspi direkt mit dem TV über HDMI verbunden – und bumm – Bild ist da. Also muß was mit dem Converter nicht stimmen. Kein Problem dachte ich, reklamieren und zurücksenden. Genau das habe ich nach Absprache mit dem Lieferanten auch gemacht. Dann passierte erstmal nicht. Keine Rückerstattung, kein neues Gerät. Die Zeit verging … knapp sechs Wochen später kam dann der Paketdienst – aber er brachte keinen neuen Converter, sondern mein Paket wieder zurück. Mit dem Postvermerk „wurde nicht abgeholt“. Also wieder den Lieferanten kontaktiert… er habe nichts erhalten, auch keinen Abholschein, bekam ich zu hören. Ich solle das Paket einfach noch einmal versenden. Die Kosten für den Rückversand trage er aber nicht. (wieder nicht). Das war jetzt genug. Das Hin- und Her senden übersteigt ja schon fast den Warenwert. Da von diesem Händler kein kulantes Verhalten zurückkam, kam von mir eine negative ebay-Bewertung und ich verzichtete auf den ganzen Rechtsanspruch und Käuferschutz. Dafür nahm ich das Gerät unter die Lupe.
Auf den ersten Blick sieht das Innenleben recht ordentlich aus. Wenn man aber genauer hinsieht, dann erkennt man eine Verarbeitung nach „Fernostqualität“. Der MST6M181VS-LF-Z1 Videoprozessor Chip beispielsweise, wurde bei der Bestückung scheinbar nicht exakt positioniert und leicht verdreht festgelötet. Auch war zwischen den Pads und den Anschlussbeinchen des IC´s ein Spalt zu erkennen. Und hier ist auch das Problem. Als ich testweise mit den Fingern Chip und PCB zusammendrückte, startete der Upscaler und zeigte am TV ein kleines Infofenster mit Auflösung und Scanfrequenz. Das bedeutet, dass es hier Verbindungsprobleme gibt. Also startete ich den Versuch, mit der Reworkanlage und ein wenig Kolophonium, den Chip nachzulöten. Das gelang auch, und der Scaler startet jetzt immer zuverlässig.
IC ist schlecht positioniertNachlöten mit Heißluft
Aber leider hielt das nur kurze Zeit, er startet zwar immer noch, zeigt aber nur mehr wirre Pixel und bunte Flächen an. Vermutlich hat der Reworkprozess den Chip zu sehr gestresst und ihm ein vorzeitiges Ende bereitet. Also noch einmal mit der Heißluft nachgelötet (kann ja sein dass immer noch eine Lötstelle nicht passt), aber das Ergebnis war dasselbe.
Also benötige ich eine kleine Schaltung, die mir nach Anlegen einer Netzspannung unbekannter Dauer einen Ausgangsimpuls mit einer bestimmten Pulsdauer (zB. 0.5s) erzeugt. Das soll die Skizze darstellen. L ist hierbei das Ausgangssignal des Grenzwertschalters und L´ ist der gewünschte Impuls am Homematic-Aktor Eingang.
Folgende Schaltung soll das Problem lösen: Ein frequenzabhängiger Widerstand (Z) in Reihe mit einer Zenerdiode… Also ein Kondensator in Reihe zu einer 12V Z-Diode dient als Spannungsteiler, der mir eine 12V Versorgung aus der Netzspannung erzeugt. Die 1N4007 zusammen mit dem 100uF Kondensator richtet gleich und glättet die Spannung. An dieser Quelle hängt jetzt ein weiterer Kondensator in Reihe mit der Relaisspule. Wird die Spannung jetzt angelegt und ist der 470uF Elko nicht geladen, so fließt durch ihn und die Spule für kurze Zeit ein Strom, und die Spule zieht an. Sobald der Elko geladen ist (5Tau), fließt kein Strom mehr und die Spule fällt wieder ab. -> und genau das wollen wir ja. Die Zeitkonstante wird durch die Kapazität des Kondensators und des Spulenwiderstandes der Relaisspule bestimmt. Die parallel zu den Kondensatoren geschalteten Widerstände dienen zum Entladen der Kondensatoren im spannungsfreien Zustand. Die hier dargestellte Anordnung erzeugt einen Schaltimpuls von in etwa 500ms und ist nach 10s wieder bereit…
