Archiv der Kategorie: Elektronikbastler

Beiträge über Bastelprojekte zum Thema Elektronik
zum Beispiel: Ein Radio mit Arduino, Geigerzähler…

Feuchtesensor am Arduino

Loading

DSC_2268In 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:

  • DSC_2269chemisch 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.

hytpinDas 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);
 
 &nbsp; void setup()
 &nbsp; {
 &nbsp; //I2C und LCD Interface initialisieren,
 &nbsp; Wire.begin();
 &nbsp; lcd.begin(20, 4);
 &nbsp;&nbsp;
 &nbsp; Serial.begin(9600);
 &nbsp; lcd.println("HYT939-Sensor");
 &nbsp; }
 
 void loop()
 &nbsp; {
 &nbsp; //I2C auselesen
 &nbsp; Wire.beginTransmission(ADDR);&nbsp;
 &nbsp; Wire.endTransmission();
 &nbsp; delay(200);
 
 &nbsp; //4 Bytes auslesen
 &nbsp; Wire.requestFrom(ADDR, 4,true);
 &nbsp; x=0;
 &nbsp; while(Wire.available())&nbsp;
 &nbsp; { 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; &nbsp;//skalieren laut datasheet
 temp=temp-40.0;
 hum=(double)humraw/163.83;
 
 //Daten auf LCD schreiben
 &nbsp; lcd.setCursor(0, 2); &nbsp;
 &nbsp; lcd.print("Temperatur =");
 &nbsp; lcd.setCursor(11, 2);
 &nbsp; lcd.print(temp);
 &nbsp;&nbsp;
 &nbsp; lcd.setCursor(0, 3); &nbsp;
 &nbsp; lcd.print("Humidity =");
 &nbsp; lcd.setCursor(14, 3);
 &nbsp; 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]);
 }

 

Ortsradioaktivität mit Homematic

Loading

sfws.lfrz.atMein 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 habe ich mir die Website genauer angesehen und die java- und php-scripten analysiert, die hier aufgerufen werden. Schlussendlich lässt sich über die Seite https://sfws.lfrz.at/json.php ein gutes Interface erreichen, dass mit den entsprechenden Kommandos bedienen kann. Für meinen Fall hole ich mit https://sfws.lfrz.at/json.php?command=getstationdata&stationcode=AT0408&a=&b= die Messdaten für eine nahe Messstation ab.

Der webresponse sieht dann in etwa so aus:

{"v":[{"d":1457276400,"v":90.1,"c":32768}, {"d":1457272800,"v":88.9,"c":32771}, {"d":1457269200,"v":85.8,"c":32781}, {"d":1457265600,"v":83.1,"c":32790}, {"d":1457262000,"v":83.7,"c":32788}, {"d":1457258400,"v":86.6,"c":32778}, {"d":1457254800,"v":88.2,"c":32773}, {"d":1457251200,"v":83.1,"c":32790}, {"d":1457247600,"v":84.2,"c":32786}, {"d":1457244000,"v":85.1,"c":32783}, {"d":1457240400,"v":89.7,"c":32768}, {"d":1457236800,"v":99.1,"c":38656}, {"d":1457233200,"v":101,"c":39680}, {"d":1457229600,"v":90.8,"c":33280}, {"d":1457226000,"v":92,"c":34048}, {"d":1457222400,"v":112,"c":46848}, {"d":1457218800,"v":115,"c":48896}, {"d":1457215200,"v":109,"c":45056}, {"d":1457211600,"v":104,"c":41728}, {"d":1457208000,"v":91.5,"c":33536}, {"d":1457204400,"v":89.7,"c":32768}, {"d":1457200800,"v":84.9,"c":32784}, {"d":1457197200,"v":84.4,"c":32785}, {"d":1457193600,"v":83.5,"c":32788}], "a":"1457190947","b":"1457277347"}

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:Systemvariable_StrahlungswertDie erste Variable soll „Strahlungswert“ heissen und vom Datentyp „Zahl“ sein. Als Maßeinheit gebe ich nS/h (nanoSivert pro Stunde) an.

Systemvariable_MesszeitpunktDie 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:

neuesProgrammDas 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.

Zeiteinstellung

Nachdem der Auslöser definiert ist, muss eine Aktivität bestimmt werden. Wir wählen hier keinen Aktor, sondern die Option „Skript“:

neuesProgrammDanach klicken wir auf die Script-Zeile und öffnen den Scripteditor:

scripteingebenDie 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
&nbsp;&nbsp;&nbsp; string url="https://sfws.lfrz.at/json.php?command=getstationdata&stationcode=AT0408&a=&b=";

!mit wget den Inhalt der Antwort in stdout schreiben&nbsp;&nbsp; &nbsp;
!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&nbsp; 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);&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; !String an pos4 substituiern und 4 Stellen ausgeben
zeitstempel=zeitst.Substr(11,10);&nbsp;&nbsp; !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:

Systemvariablen

NTC am Arduino

Loading

ArduTemp(2)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)

 

ArduTemp(1)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
&nbsp;* RS to digital 12
&nbsp;* EN to digital 11
&nbsp;* D4 to digital 5
&nbsp;* D5 to digital 4
&nbsp;* D6 to digital 3
&nbsp;* D7 to digital 2
&nbsp;* R/W to ground
&nbsp;* 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() {
&nbsp; // setup LCD spalten und reihen
&nbsp; lcd.begin(20, 4);
&nbsp; lcd.print("Testprogramm NTC");
&nbsp; Serial.begin(9600);
}

void loop() {
&nbsp; analogvalue=analogRead(analogpin);
&nbsp; analog=(0.004882812*analogvalue);
&nbsp; urt=5-analog;
&nbsp; rt=((r/analog)*urt);

&nbsp; rvsrref=rt/rref;
&nbsp; temp=(1/(a1+(b1*log(rvsrref))+(c1*(log(rvsrref*rvsrref)))+(d1*(log(rvsrref*rvsrref*rvsrref)))));
&nbsp; tempc=temp-273.15;
&nbsp;
&nbsp; //&nbsp; column 0, line 1
&nbsp; // (note: line 1 is the second row, since counting begins with 0):
&nbsp; lcd.setCursor(0,1);lcd.print("ADC-Wert =");
&nbsp; lcd.setCursor(11,1);
&nbsp; lcd.print(analogvalue);
&nbsp;
&nbsp; lcd.setCursor(0, 2); &nbsp;
&nbsp; lcd.print("Widerstd =");
&nbsp; lcd.setCursor(11, 2);
&nbsp; lcd.print(rt);

&nbsp; lcd.setCursor(0, 3); &nbsp;
&nbsp; lcd.print("Temp Cels=");
&nbsp; lcd.setCursor(11, 3);
&nbsp; lcd.print(tempc);

 

Arduino mit Matlab … Der Sensor

Loading

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:
formelarduino01 (2)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:
formel2
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:formel3Das 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
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
&nbsp;
%a = arduino('com5','Uno');
&nbsp; a = arduino('com5','Uno','TraceOn', true)
&nbsp; analogpin=0;
&nbsp; analog=0;
&nbsp;
&nbsp; %ein paar konstanten für die weiteren berechnungen
&nbsp; %
&nbsp; r=2200;&nbsp; %Spannungsteilerwiderstand
&nbsp; rt=0; %das wird der errechnete widerstand des NTC
&nbsp; urt=0; %das wird der errechnete Spannungsabfall am NTC
&nbsp;
&nbsp; % konstanten für berechnung der Temperatur aus NTC Widerstand
&nbsp; % B25=3977K
&nbsp; a1=3.354016E-03;
&nbsp; b1=3.2569850E-04;
&nbsp; c1=2.61013E-06;
&nbsp; d1=6.38309e-08;
&nbsp; rref=2200;
&nbsp;
&nbsp;
&nbsp;
&nbsp; %Lesen eines Temperaturabhängigen Widerstandes am Analog Eingang A0
&nbsp; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
&nbsp;
&nbsp; for x=1:50
&nbsp; analog(x)=readVoltage(a, analogpin) %Liest den AnalogIn von A0 und gibt in Volt aus
&nbsp; urt(x)=5-analog(x); %spannungsabfall am NTC
&nbsp; rt(x)=(r/analog(x))*urt(x); %widerstand des NTC
&nbsp;
&nbsp; %berechung der temperatur
&nbsp; rvsrref(x)=rt(x)/rref;
&nbsp; temp(x)=1/(a1+(b1*log(rvsrref(x)))+(c1*(log(rvsrref(x)^2)))+(d1*(log(rvsrref(x)^3))));
&nbsp; tempc(x)=temp(x)-273.15 %Kelin in Celsius umrechnen
&nbsp; pause(2);
&nbsp;
&nbsp; end
&nbsp;
&nbsp; clear a;
&nbsp;
&nbsp; %plot den mist
&nbsp; figure(1);
&nbsp; time=1:50;
&nbsp; plot(time,analog,'b');
&nbsp; grid on; hold on;
&nbsp; plot(time,rt/1000,'r');
&nbsp; plot(time,urt,'g');
&nbsp; plot(time,tempc,'m');
&nbsp; legend('Analogspannung des ADC','Widerstand des NTC in kOhm','Spannung am NTC','Temperatur [°C]'); 
&nbsp; %ende

 

 
temperaturgraph
So sieht der Graph mit dem Temperaturlog danach aus…

Arduino mit Matlab … Startschwierigkeiten

Loading

arduino01 (4)Heute möchte ich ein Thema vorstellen, mit dem ich mich kurz im Rahmen einer Recherche beschäftigt habe. Viele (Techniker) kennen vielleicht die Software Matlab von der Firma Matworks. Das ist ein extrem umfangreiches Softwarepaket, das bei uns in der Lehre eingesetzt wird, um Studierende in allen möglichen technischen Bereichen zu unterrichten. Sei es Signalverarbeitung, Regelungstechnik, Bildverarbeitung, etc. – Matlab ist das Tool, um all das professionell umzusetzen. Auch wenn es um Messdatenerfassung geht, muß man nicht unbedingt auf Tools zurückgreifen, mit denen ein Projekt oder Programm „gezeichnet“ wird. Das ist zwar toll für den Einstieg, kann (und wird) in späterer Folge aber aufgrund des riesen Overheads und der benötigten PC Resourcen viel zu umständlich, wenn man schnell einmal über eine externe Hardware irgendwelche physikalischen Größen aufzeichnen und verarbeiten will.

In diesem kleinen Projektchen möchte ich nun zeigen, wie einfach man mit Hilfe eines Arduino Uno Boards zusammen mit Matlab eine Temperaturmessung realisieren kann. Der Sensor soll hier ein ganz einfacher NTC Widerstand sein. Das bedeutet, der ohmsche Widerstand des Bauteils ändert sich mit der Temperatur, in dessen Umgebung sich das Bauteil befindet. Die Änderung passiert hier folgendermaßen: wenn die Temperatur steigt, so wird der ohmsche Widerstand kleiner. (Negativer Temperatur Koeffizient) (Coefficient engl. -> NTC). Einziger kleiner Haken – die Änderung passiert nicht linear wie zum Beispiel beim PT100. Das bedeutet der Verlauf  des Widerstands bei Änderung der Temperatur ist keine Gerade mit irgendeiner Steigung, sondern eine e-Funktion. Das wiederum bedeutet, dass, will man aus den gemessenen Widerstandwerten in eine Temperatur zurückrechnen, die Funktionsgleichung zum NTC gefunden werden muss. Glücklicherweise findet man diese aber fix und fertig in den Herstellerdatenblättern 😉 aber dazu später.

Man hat nun einen temperaturabhängigen Widerstand, ein Arduino Uno – Board und einen PC auf dem Matlab läuft. Wie geht´s nun weiter? Nehmen wir als Beispiel an, dass Matlab 2014b installiert ist. Nun gibt es in Matlab unter dem Tab „Home“ eine Rubrik, die sich „Add-Ons“ nennt. Klick man auf  diese, so klappt ein Menue auf, in dem man den Eintrag „Get Hardware Support Packages“ findet. Den klickt man an und es öffnet sich ein Fenster namens „Support Package Installer“.

Unter „Install from Internet“ und „Next>“ kommt man zu einem Auswahlmenue der verfügbaren Packages. Hier sucht man sich „Arduino“ aus und setzt im rechten Bereich des Fensters einen Haken – und zwar bei dem Paket „Aquire inputs and send outputs on Arduino Uno…“. Danach wieder auf „Next>“ klicken und die Installation vollenden.

Ist alles erledigt so kann man den Arduino am USB-Port anstecken. Windows sollte einen Treiber zuordnen. (Unter Systemsteuerung – Gerätemanger – Anschlüsse > sollte ein Arduino Uno (COMx) zu finden sein). Ist das der Fall, dann sollte es klappen 🙂

Jetzt kann in der Matlab Console folgender Befehl eingegeben werden:

arduino()

Folgende Antwort kommt nun zurück:

 arduino with properties:

Port: 'COM5'
Board: 'Uno'
AvailableAnalogPins: [0, 1, 2, 3, 4, 5]
AvailableDigitalPins: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
Libraries: {'I2C', 'SPI', 'Servo'}

Der COM-Port unterscheidet sich natürlich und wird meist auf den nächsten freien COM gemappt. Hat das aber geklappt, so ist der erste Teil schon gewonnen. Matlab kommuniziert mit dem Arduinoboard. Es kann aber auch vorkommen, dass Fehlermeldungen auftauchen. Wie bei mir der Fall:

Cannot detect Arduino hardware. Make sure original Arduino hardware is properly plugged in. If
using unofficial(clone) hardware, specify port and board type. For more information, see the
arduino function reference page.

Das war die erste Meldung nach der Installation: Dafür gibt’s aber auch Abhilfe. Man gibt folgendes ein:

a = arduino('com5','Uno')

Wenn auch dann eine Fehlermeldung kommt, so wie natürlich bei mir, dann kann man mit folgendem commando auf Fehlersuche gehen:

 a = arduino('com5','Uno','TraceOn', true)

Jetzt kam bei mir die Meldung : Updating server code on Arduino Uno (COM5). Please wait.  Und danach gleich ein Errorfenster mit einem „avr-gcc.exe
Die Anwendung konnte nicht korrekt gestartet werden (0xc00000142)“ Fehler. Danach habe ich lange in diversen Foren gesucht, Tracelogs verglichen und nach den Fehlermeldungen gegoogelt. Hier gab es Tips von: die make.exe in den Tiefen des SupportPackages Ordner ist nicht kompatibel mit 64bit Systemen, mit Windows8.1 und Windows10 gibt es Zugriffsrechteprobleme und und und. Leider war aber nie ein Lösungsvorschlag dabei der bei mir funktionierte. Also habe ich auf einem zweiten Rechner eine jungfräuliche Installation von Matlab und dem Arduino Matlab Package durchgeführt. Und siehe da – es funktionierte. Aber wie jetzt nach dem Fehler suchen, oder ihn beheben. Also habe ich auf dem funktionierenden Rechner einen Tracelog durchgeführt, indem ich beim Aufrufen der Arduinofunktion einen Port angegeben habe, auf dem ein anderes NICHT Arudino Gerät angeschlossen ist. Und siehe da, der Errortracelog war seeehr lange und ausführlich. Man konnte ansehen was die Funktion alles aufruft. Und irgendwo ganz unten im Log las ich was von avrdude… Da kam mir die Idee. Auf meinem PC sind einige Entwicklungsumgebungen installiert. Unter anderem auch AVR-Studio und der WinAVR20100110 Compiler. Und genau der war das Problem. Den WinAVR gelöscht und schon klappte es.

Also steht dem weiteren Aufbau zur Realisierung des Projektchens nichts mehr im Weg. Aber darüber scheibe ich beim nächsten Mal in Teil 2…

 

Stylophone – Pocket Synthesizer

Loading

stylo(7)Ein interessantes Gerät ist das sogenannte „Stylophone„. Es ist ein einfaches elektronisches Musikinstrument das ursprünglich von der Firma Dubreq hergestellt wurde. Es handelt sich dabei um ein Miniaturkeyboard, dessen „Tasten“ mit einem „Stift oder Stylus“ berührt werden. Der Stift hat eine elektrisch leitfähige Spitze und ist mit einem Draht zum Gerät verbunden. Die Tasten sind eigentlich keine Tasten, sondern nur elektrisch leitfähige Flächen einer Platine. Berührt man mit dem Stift jetzt eine der Tastenflächen, so wird ein Stromkreis geschlossen, der einen elektronischen Tongenerator aktiviert. Jede der Tastenflächen stellt für den Tongenerator einen anderen elektrischen Widerstand dar, der damit auch die Tonfrequenz des Generators verändert.

Es ist also ein einfacher Synthesizer. Das Klangbild kann durch Zuschalten eines Multivibrators und verschiedenen Filtern verändert werden. Auch die Oktaven lassen sich umschalten. Das erste Stylophone oder Elektrophon wurde im Jahr 1967 entwickelt und in den Siebzigerjahren von einigen Bands eingesetzt. Bei dem hier vorgestellten Gerät handelt es sich um eine Nachbau-Neuauflage, die mit modernerer Elektronik ausgestattet ist.

stylo(1)Die kleine Platine beherbergt die Schaltung für den Tongenerator und einen Audioverstärker für die Tonausgabe über den Lautsprecher. Auf der großen Platine sind die Tastenfelder angebracht. Es gibt noch zwei Umschalter für die Klangbilder, zwei 3.5mm Klinkenbuchsen um ein externes Audiosignal einzumischen und das Gesamtsignal auszugeben, sowie ein Potentiometer zum Stimmen.

 

stylo(2)

Hier ist die Platine mit einer einfachen Multivibratorschaltung (Oszillator) und dem NF-Verstärker zu sehen. Das Stylophone erzeugt einen monophonen, also einen Kanal, Audioausgang.

stylo(5)

Gespielt wird das Stylophone mit dem Stylus, dem Stift, der den elektrischen Kontakt zu den Tastenflächen herstellt.

stylo(9)

Im folgenden Video“16 Classic Hits On Stylophone“ wird gezeigt, was man mit dem Stylophone machen kann, wenn man es kann. (c)YouTube user: maromaro1337

Nachlöten von BGA-Chips

Loading


DSC_0002
Immer wieder kommt es vor, dass bei Rechnern, vorwiegend bei Notebooks und Laptops, nach einiger Betriebszeit Systemabstürze und Graphikfehler entstehen. Diese Graphikfehler äußern sich meistens als farbige Linien am Bildschirm, oder ungewöhnlichen Zeichen und Artefakten, die plötzlich auftreten. In sehr vielen Fällen ist das auf einen Fehler der GPU (Graphic Processing Unit) also den Graphikprozessor zurückzuführen. Da der je nach Bildschirmauflösung und Komplexität seiner Rechenoperationen thermisch sehr heiß wird, kann es zu Problemen kommen. Folgende Punkte verursachen diese Probleme:

  • die Kühlung des Rechners ist durch verstaubte und blockierte Luftwege eingeschränkt
  • die Wärmeleitpaste zwischen dem Prozessor und der Heatpipe ist vertrocknet und spröde und kann die Wärme der Die-Cores nicht an die Pipe übergeben
  • der Rechner ist falsch aufgestellt (z.B. auf Polstern oder Decken), sodass Lüftungsöffnungen blockiert sind

All das führt zu einer starken Erwärmung bzw. Überhitzung der GPU. Die ist ja meist intern mit einem Schutz versehen und schaltet sich ab, bevor sie stirbt.  Der Chip besteht aber aus einem Substrat (einem Trägermaterial mit den vielen Anschlüssen BGA (BallGridArray) und dem eigentlichen Chip, dem Die, also dem Halbleiter). Um die unzähligen Anschlüsse von so einer GPU nun auch nach außen führen zu können, muss das Substrat um einiges größer sein als der Die. Und genau da entsteht das Problem. Der Die, also der Kern erwärmt sich und den Bereich des Substrats auf dem er liegt, nun erheblich mehr, als den restlichen Bereich des Substrates. Dieses Erwärmen und Abkühlen verursacht auch eine thermische Längenänderung des Substratmaterials. Diese ist aber nicht homogen. Jetzt kann man sich vorstellen was mit den hunderten Balls (also den Zinnbällen mit denen das Substrat elektrisch zum Mainboard verbunden ist) passiert. Die werden durch die ständige thermomechanische Beanspruchung auch gestresst und beginnen irgendwann zu brechen. Dabei genügt es oft schon, wenn ein Ball keine saubere Verbindung mehr zum Mainboard herstellt. Dann führt das zu Ausfällen und Graphikfehlern.

Man findet im Netz oft viele Tipps und Tricks, solcher Probleme Herr zu werden. Manche Leute nehmen einen Haarfön und braten mit heißer Luft auf den BGA Chip, in der Hoffnung, ein Neuverbinden der Zinnverbindungen auszulösen. Manche legen das ganze Mainboard in den Pizzaofen und backen es.  Wenn man es etwas professioneller angehen will, so kann man, wie in diesem Fall, mit einer Rework-Lötanlage den BGA nachlöten.

Die besten Varianten sind allerdings, den Chip zu reballen, also den Chip auszulöten und jegliches Zinn von Mainboard und Chip zu entfernen, danach den BGA-Chip mit neuen Zinnballs versehen und dann wieder auf das Mainboard zu löten. Die allerbeste Variante ist es, die GPU komplett zu erneuern. Jedoch sind diese beiden Möglichkeiten eine Preisfrage und bei älteren Laptops und Notebook sicher nicht mehr rentabel.

Also stelle ich hier das Nachlöten (resoldern) des BGA Chips mit Hilfe der Rework-Lötstation von ERSA (IR550) vor.

DSC_0005Zuerst muss der Rechner zerlegt und das Mainboard freigelegt und ausgebaut werden. Hierbei ist es besonders wichtig, vorher alle Energiequellen (Akku) zu trennen und zu entfernen!

 

DSC_0006Hier ist das Kühlsystem schon demontiert. Man sieht die trockene und spröde Wärmeleitpaste an den DIEs der CPUs und Bridge IC´s.

DSC_0007Ein klassisches Beispiel für einen schlechten Airflow 😀

DSC_0012Ist das Mainboard nun ausgebaut, wird der betroffene Baustein entlang seiner Kante mit Flussmittelgel bestrichen. Das wird später beim Erhitzen dünnflüssig und durch die Kapillarwirkung unter den Baustein gesogen. Dort sorgt es dann wieder für einen verbindungsfreudigeren Lötprozess.

DSC_0011Jetzt kann das Mainboard in der Lötanlage platziert und ausgerichtet werden.

DSC_0014Der Lötvorgang wird vollständig vom Rechner gesteuert. Hier ist es wichtig, ein Temperatur- und Zeitprofil zu erstellen, das den Erwärmungs- und Abkühlvorgang entsprechend der Baustein-Lötspezifikation erfüllt.

DSC_0015Während des Lötprozesses kann man das Verhalten des Flussmittels und der Balls mit Hilfe eines Macrokamerasystems verfolgen.

DSC_0020Ist der Lötprozess vollendet, kann man nach dem Reinigen sämtlicher, mit der Kühlung zusammenhängenden Teile, mit dem Zusammenbau beginnen. Ebenso muss die alte Wärmeleitpaste vorsichtig entfernt und durch neue ersetzt werden.

Das Video zeigt den hier beschriebenen Lötprozess.

 

Hier ein allgemeiner Film zur ERSA IR550 Lötanlage

Röhrenradio Eigenbau – Der Anfang

Loading

IMAG1370
Ein Projekt, das schon seit einigen Jahren in der Werkstatt herumliegt und bei dem ich mich nie zum Weitermachen motivieren konnte, ist ein selbstgebastelter UKW Radioempfänger mit einer Röhrenendstufe. Da ich aus Kindertagen noch einiges an gesammelten Elektronenröhren aufbewahrt habe, ist mir irgendwann einmal in den Sinn gekommen mit diesen Röhren etwas zu basteln. So habe ich vor nun schon fast 15 Jahren begonnen, aus 2 Stück Endpentoden EL84 und einer Doppeltriode ECC83, einen AB Verstärker aufzubauen. Als Grundplatte habe ich ein Stück Pertinaxplatte zugeschnitten, darauf die drei Röhrensockel montiert und auf der Unterseite alles fliegend verlötet.

 

 

schaltplan
LT-Spice Schaltplan des Verstärkers

Die Verschaltung der Komponenten habe ich nach folgendem Schaltplan aufgebaut. Der Schaltplan ist mit der freien Schaltungssimulationssoftware LT-Spice erstellt worden. Um die hohe Anodenspannung von 250 bis 300V bei knapp 48mA an den Lautsprecher zu bringen, bedient man sich eines Impedanzwandlers in Form eines Transformators. Es gibt Berechnungstabellen, nach denen man einfach einen Transformator dimensionieren und wickeln kann. Während meiner Schulausbildung habe ich die Berechnung und Dimensionierung von Übertragern und Transformatoren einmal ziemlich ausführlich erlernt, doch mangels Anwendungsbedarf auch wieder ziemlich schnell verlernt oder vergessen. (oder doch ein Problem des Alterns??) So hat sich der Griff zu den Dimensionierungstabellen und -rechnern als sehr praktisch und zielführend erwiesen… In meinem Fall habe ich einen EI78 Kern mit 2×0,5mm Luftspalt ermittelt und mit knapp 6000Windungen bei 0,2mm Cu auf der Primärseite und knapp 200 Windungen bei 0,7mm auf der Sekundärseite gewickelt.

Dann ging´s an den Zusammenbau der Komponenten: Zuerst habe ich die Pertinax-Platte zugeschnitten und Löcher für die Röhrensockel gebohrt.

IMAG1361Jetzt können die Röhrensockel eingebaut werden. Die großen Siebelkos habe ich auch durch die Grundplatte gesteckt und auf der Rückseite mit einem „Drahthaken“ verankert, um sie später einfach anlöten zu können. Der Brückengleichrichter soll die Anodenspannung gleichrichten…

IMAG1368Das Drahtgewirr im folgenden Bild zeigt die fertig verlöteten und mit Bauteilen bestückten Sockel der Trägerplatte.

IMAG1367

Von der anderen Seite sieht das ganze schon ein wenig aufgeräumter aus… Hier ist die Trägerplatte und der Impedanzwandler schon in ein formschönes, handgefertigtes Holzgehäuse (an dieser Stelle vielen Dank an Patrick und seinen Onkel für das Bauen des Holzgehäuses) eingebaut. IMAG1371Nun konnte ein erster Funktionstest des Verstärkers stattfinden. Jetzt musste ich provisorisch die Spannungsversorgungen für das Röhrensystem herstellen. Für die 6.3V Heizspannung der Röhren war ein DC Labornetzgerät ausreichend. Die Anodenspannung erzeugte ich mit dem einstellbaren Trenntransformator, den ich für den ersten Versuch auf ca 170VACeff einstellte. Das ergibt eine Gleichspannung von ca 240VDC an den Anoden. Ein kleiner 8Ohm Lautsprecher an der Sekundärseite des Impedanzwandlers sollte dann für den Hörgenuss sorgen… Die Audioquelle war einfach der Kopfhörerausgang des Mobiltelefons… Und siehe da, es tönte aus dem Lautsprecher und sogar gar nicht so schlecht…

Jetzt, oder zumindest wenn die Zeit es wieder erlaubt, sind folgende Punkte zu lösen bzw. zu bauen:

  • Stromversorgung (Anode und Heizung) … habe hier noch keine andere Lösung als selbst wieder einen Trafo zu wickeln, der zwei Sekundärwicklungen hat … (wird aber viel Kupfer)
  • Das Empfängermodul (hier habe ich geplant mit dem TDA7000 IC und einer Schaltung mit Kapazitätsdiode im Parallelschwingkreis die Senderabstimmung zu machen, um mit einem Poti die Sender einzustellen) Danke an Matthias für die Spende der TDA7000er
  • Eine Anzeigeeinheit für die Frequenz (hier stelle ich mir einen Punktearray aus Leds vor … )

 

Singbox – UKW Radio aus Fernost

Loading

DSC_4912Ein nettes kleines Teil für gerade einmal dreizehn Euro ist mir diesmal untergekommen.Es nennt sich „SINGBOX“ und ist ein UKW-Radioempfänger der in Fernost verkauft wird  und auch über online-shops hier zu bekommen ist. Das Teil hat die Abmessungen von 12 x 7 x 3 cm und wiegt knapp 220 Gramm. Eine kleine Teleskopantenne mit drei Segmenten sorgt für einen vernünftigen UKW – Empfang. Das Gerät ist aber nicht nur ein Radioempfänger, nein – es kann auch MP3. Ein seitlich eingebauter Micro-SD Kartenslot kann MicroSD Karten bis 16GB Kapazität lesen und darauf befindliche MP3-Dateien abspielen. Der kleine Lautsprecher kann mit seinen 2Watt ordentlich Lärm machen. Die Energie bezieht der Empfänger aus einer LiIon Batterie mit 3.7V/800mAh die sehr stark an die in Chinahandys verbauten Akkus erinnert. Die Batterie kann über die eingebaute Mini USB-Buchse geladen werden.

DSC_4916Im Bild ist die 3.7V / 0.8Ah Batterie zu sehen. Sie kann, wie auch bei vielen Handys aus China üblich, einfach entnommen und getauscht werden.

DSC_4917
Batterie ins Gerät eingelegt

Auf der Frontseite des Gerätes befindet sich ein LC-Display, das Rot beleuchtet ist und an die 7-Segment Led-Anzeigen aus früheren Zeiten erinnert. Das Display zeigt die UKW-Frequenz, Play/Pause von MP3 und den Batterieladezustand an.

DSC_4920Über die sechs Tasten, können die Sender gesucht, bzw. weitergeschaltet werden. Die Betriebsmodi (Radio/Player) werden über „Mode“ umgeschaltet . Play/Pause ist selbsterklärend.

DSC_4918Seitlich findet man einen AUS/EIN Schiebeschalter, der den Batteriestromkreis vollständig trennt. Die Lautstärke wird über ein klassisches Drehpotentiometer eingestellt. An die3.5mm Klinkenbuchse kann ein Kopfhörer angeschlossen werden. Die USB-Buchse dient zum Laden des Akku und der MicroSD-Slot nimmt Datenträger mit MP3 files auf (die SD-Karte muss FAT oder FAT32 formatiert sein).

DSC_4914Die technischen Daten:

Hersteller Singbox
Model SV-936
Type Portable
Farbe Rot
Material ABS
Interner Speicher
keiner
Speichersystem
MicroSD
Max. Speicherkapazität
16GB
Media Format MP3
Maximale Leistung
2W
Impedanz 4ohm
Signal to Noise Ratio(SNR) 80dB
Interface 3.5mm jack / 1 x Mini USB / 1 x TF card slot
Radio FM Radio
FM Frequenz 70~108MHz
Batterie External 800mAh

Die Verarbeitung ist von mäßiger Qualität, der ABS-Kunststoff wirkt billig. Die Gehäuseteile sind nicht sehr präzise gefertigt, sodass das Gerät schnell umkippt. Technisch jedoch funktioniert es aber anstandslos und kann vor allem im Outdoorbereich am See, oder beim Lagerfeuergrill als Hintergrunduntermalung genutzt werden. Mehr kann man sich für 13 Euro ja auch nicht erwarten.

 

Dimmen ohne Triac

Loading

HINWEIS: In diesem Blogbeitrag werden Schaltungen beschrieben, in denen mit Netzspannung und Netzpotentialen gearbeitet wird. Arbeiten mit Netzspannungen sind LEBENSGEFÄHRLICH und dürfen nur mit entsprechenden Kenntnissen und Befugnissen durchgeführt werden!

DSC_4883Als klassische Variante, einen ohmschen Netzverbraucher (z.Bsp. Glühlampen) in ihrer Helligkeit zu steuern, wird üblicherweise ein Triac in einer Phasenanschnitt- oder Phasenabschnittsteuerung verwendet. Diese Schaltung ist einfach aufzubauen, kostet wenig und man kann durch Änderung der Zeitkonstante eines RC-Gliedes (durch Ändern des Widerstandes mit Hilfe eines Potentiometers) die Spannungsform an der Last beeinflussen. Dies geschieht durch „An- oder Abschneiden“ der „Sinuswelle“ zu einem gewünschten Zeitpunkt. Die daraus resultierende, verbleibende „Wellenform“ versorgt die Last mit Energie. Da die „Sinuswelle“ nun jedoch nicht mehr „vollständig“ ist, ist auch die effektiv übertragene Energie zur Last kleiner. Das bedeutet weniger Spannung liegt an der Lampe an. Somit sinkt auch die Lampenhelligkeit. Hierzu findet man reichlich Informationen im Netz. Will man eine solche Phasenanschnittsteuerung nun jedoch nicht mit einem Potentiometer steuern, sondern mit einem Microcontroller oder einer externen analogen Spannung von zum Beispiel 0-5V, so ist hier ein erweiterter Schaltungsaufwand notwendig.

Auf eine ganz andere Weise ist die hier dargestellte Schaltung aufgebaut. Hier wird nicht mit einem Triac die negative bzw. positive Halbwelle angeschnitten, sondern mit einem FET der Pfad in einem Brückengleichrichter durchgeschaltet. Der FET selbst wird per PWM (PulsWeitenModulation) angesteuert. Die PWM wiederum erzeugt der Einfachheit halber ein Atmega Microcontroller. Durch die frei wählbaren PWM Grundfrequenzen sind hier sehr schnelle und somit auch flackerfreie Schaltvorgänge realisierbar.

_20151123_104151Die Skizze soll die simple Funktionsweise veranschaulichen: Im Bild ist der Stromkreis dargestellt. Der Verbraucher liegt in Serie mit dem Brückengleichrichter an der Phase L und dem Neutralleiter N. Im Querpfad des Brückengleichrichters befindet sich ein Schalter (in der realen Anwendung ein angesteuerter Mosfet). Wird der Schalter S nun nicht betätigt, bleibt also offen, kann durch die Dioden kein Strom fließen. Weder die positive noch die negative Halbwelle finden einen geschlossenen Stromkreis.  Anders sieht es jedoch aus wenn der Schalter S geschlossen wird. Dies ist in der rechten Skizze dargestellt. Der Strompfad einer Halbwelle ist in Rot, der der anderen Halbwelle in blau dargestellt. Der Strom fließt und die Lampe leuchtet. Das Besondere daran ist es nun, verfolgt man die Stromrichtung beider Halbwellen durch den Schalter, so kann man erkennen, dass bei beiden Halbwellen dieselbe Stromrichtung vorliegt. Damit ist es nun möglich mit einem Transistor oder FET, eine Wechselspannungsquelle zu schalten. Das Ein/Aus Verhältnis (also PWM) des Schaltsignals, kann somit wieder die effektive Spannung an der Last beeinflussen.

dimmerUnd genau eine solche Schaltung habe ich hier aufgebaut. Der Atmega-Microcontroller erzeugt ein PWM Signal, das über einen Optokoppler den Mosfet ansteuert. Somit sind ganz einfach per Software alle möglichen Schalt- und Dimm-Szenarien realisierbar. (z.Bsp. Steuerung der Lampenhelligkeit über eine Analogspannung am ADC des µC …)

DSC_4882Im Bild rechts ist ein Testaufbau des Dimmers (Laststellers) dargestellt. Die Versorgungsspannung des µC wird hier noch durch einen AC/DC Converter realisiert, um eingangsseitig eine galvanische!! Trennung vom Netz herzustellen.