Archiv der Kategorie: Arduino

Arduino, Elektronikbastler

Arduino mit Matlab … Der Sensor

Ein Kommentar

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
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
%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

 

 
temperaturgraph
So sieht der Graph mit dem Temperaturlog danach aus…
Arduino, Elektronikbastler

Arduino mit Matlab … Startschwierigkeiten

Schreibe einen Kommentar

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…

 

Arduino, Elektronikbastler

Dimmen ohne Triac

20 Kommentare

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.

Arduino, Elektronikbastler

Arduino als USB-Joystick

2 Kommentare

Loading

IMAG1861
Arduino als USB-Joystickinterface

Die große Welt der kleinen Microcontroller und vor allem der sehr günstigen Microcontroller und deren Vielfältigkeit, hat mich beim folgenden ‚Projektchen‘ wieder motiviert sie zu verwenden. Für die eher weniger outdoorlastigen kalten Wintertage habe ich mir ein Projekt vorgenommen, dass das Thema Retrocomputer betrifft. Zum einen habe geplant, die Website um die Rubrik der alten Computer zu erweitern (zumindest sollen die paar wenigen aus meiner Sammlung vorgestellt und in Betrieb genommen werden…) und zum anderen will ich mir eine Arcade-Station bauen, deren Kern das neue RaspBerry2 Modell ist . Auf dem soll die Emulatorplattform Retropie aus dem gleichnamigen Projekt zu Einsatz kommen. Die ersten Versuche mit den Images aus dem Projekt sehen sehr gut aus. Die alten 8-Bit und 16-Bit Computer laufen in der Emulation ausgezeichnet (C64, Atari, Amiga usw…). Was die Anbindung von Eingabegeräten betrifft, kann man natürlich Maus und Keyboard vom PC an den Raspberry anschliessen und alles steuern. Die Jungs aus dem Projekt haben auch selbst einige Boards entwickelt, die die Anbindung von Joysticks und co an des Raspberry ermöglichen. (zB. den GPIO Adapter). Aber da ich ein paar Arduino Unos herumliegen habe, dachte ich mir, warum nicht diese verwenden. Da es beim Arduino möglich ist, den Mega 16U2 zu flashen (der Chip wird als Programmer für den Atmega 328 auf dem Uno – Board verwendet) und aus dem Uno-Board so zum Beispiel ein USB-HID (Human Interface Device) zu machen -sprich Keyboard, Mouse, was auch immer, bot sich der als ideale Plattform an.

Tutorials, den Arduino zu einem HID-Interface zu flashen, gibt es mittlerweile schon sehr viele. Zum Beispiel findet man hier eine schöne Anleitung. Je nach dem welche Arduino-Uno Boardversion man hat, kann man sich den zusätzlichen Widerstand fürs DFU-Flashen sparen. (z.Bsp. bei meinen Boardversionen R3 ist der Widerstand nicht nötig.) Auf den neuen Boards ist auch nicht mehr der Atmega 8U2 verbaut, sondern der 16U2. Man muß einfach im Atmega Flash-Tool „ATMEL-FLIP“ den entsprechenden Chip auswählen. Die entsprechenden Firmwarefiles findet man im Netz…

Arduino-keyboard-0.3.hex
Arduino-mouse-0.1.hex

Ist der Arduino dann geflasht, so wird er beim Anschluss an den PC eben als Keyboard oder Maus erkannt. Jetzt braucht man nur mehr den gewünschten Code in den Atmega328 zu schreiben und die Arduino UNO Eingänge führen z.Bsp. Tastaturbefehle aus. Um die Firmware jetzt nicht jedes Mal zwischen Programmer und USB-HID zu ändern, verwende ich einfach einen zweiten UNO der als Programmer dient und stecke einfach den geflashten Chip immer um (ist viel einfacher beim Testen).

Da das Interface jetzt soweit passt, habe ich mich mit dem HID-Codetable beschäftigt und die entsprechenden Tasten, die die Joystickbewegungen an den PC senden sollen herausgesucht.

Hier der sehr einfache Code der momentan die alten Commodore Joystickbewegungen umsetzt:)

/* HID Joystickinterface für Arduino UNO im HID Modus
 Jun2015 by I.Bihlo
 Die Tasten brauch i  Taste/Hexcode/Dec-Code  
  KEY_LEFT_CTRL    0x01  //01 
  KEY_LEFT_SHIFT    0x02  //02 
  KEY_LEFT_ALT    0x04  //04 
  KEY_LEFT_GUI    0x08  //08 
  KEY_RIGHT_CTRL    0x10  //16 
  KEY_RIGHT_SHIFT 0x20  //32 
  KEY_RIGHT_ALT   0x40  //64 
  KEY_RIGHT_GUI   0x80  //128 

  KEY_RIGHT_ARROW 0x4F  //79 
  KEY_LEFT_ARROW  0x50  //80 
  KEY_DOWN_ARROW  0x51  //81 
  KEY_UP_ARROW    0x52  //82 
  KEY_TAB         0x2B  //43 
  KEY_ENTER       0x28  //40 
  KEY_SPC         0x2C  //44 
 */ 
     uint8_t keyNone[8] = { 0, 0, 0, 0, 0, 0, 0 }; 
     uint8_t keyA[8] = { 0, 0, 4, 0, 0, 0, 0 };  //left 
     uint8_t keyD[8] = { 0, 0, 7, 0, 0, 0, 0 }; //right 
     uint8_t keyW[8] = { 0, 0, 26, 0, 0, 0, 0 }; //up 
     uint8_t keyS[8] = { 0, 0, 22, 0, 0, 0, 0 }; //down 
     uint8_t keySPACE[8] = { 0, 0, 44, 0, 0, 0, 0 }; //space 
      
     uint8_t keyLEFT[8] = { 0, 0, 80, 0, 0, 0, 0 };  //left 
     uint8_t keyRIGHT[8] = { 0, 0, 79, 0, 0, 0, 0 }; //right 
     uint8_t keyUP[8] = { 0, 0, 82, 0, 0, 0, 0 }; //up 
     uint8_t keyDOWN[8] = { 0, 0, 81, 0, 0, 0, 0 }; //down 
     uint8_t keyENTER[8] = { 0, 0, 40, 0, 0, 0, 0 }; //enter 
      
 // DEFINE inputs 
 const int UPA = 12; 
 const int DOWNA = 13; 
 const int LEFTA = 2; 
 const int RIGHTA = 3; 

 const int UPB = 4; 
 const int DOWNB = 5; 
 const int LEFTB = 6; 
 const int RIGHTB = 7; 

 int out=0; //fürs Testen am Serial Monitor im Programmermodus 

 void setup() { 
    
   // Die Pins als Eingang definieren (Intern PullUP setzen - ist bei mir nötig da actice Low geschaltet wird 
   pinMode(UPA, INPUT_PULLUP); pinMode(DOWNA, INPUT_PULLUP); pinMode(LEFTA, INPUT_PULLUP); pinMode(RIGHTA, INPUT_PULLUP);  
   pinMode(A0, INPUT); 
   pinMode(UPB, INPUT_PULLUP); pinMode(DOWNB, INPUT_PULLUP); pinMode(LEFTB, INPUT_PULLUP); pinMode(RIGHTB, INPUT_PULLUP);  
   pinMode(A1, INPUT);    
    
   Serial.begin(9600); 
    
 } 

  void loop() { 
     
    // Joystickbewegungen abfragen und senden 
    // Da das Interface einen Invert-Schmitt Trigger verpasst bekommen hat, werden die Ausgänge auf active LOW abgefragt - wenn nix passiert sind alles Eingänge HIGH 
     
    if (digitalRead(UPA)==LOW) {out=120; Serial.write(keyW, 8);}   
      
    if (digitalRead(DOWNA)==LOW) {out=121; Serial.write(keyS, 8);}   
      
    if (digitalRead(LEFTA)==LOW) {out=122; Serial.write(keyA, 8);}  
      
    if (digitalRead(RIGHTA)==LOW) {out=123; Serial.write(keyD, 8);}  
     
    if (digitalRead(A0)==LOW) {out=124; Serial.write(keySPACE, 8);}  
      
     
    if (digitalRead(UPB)==LOW) {out=130; Serial.write(keyUP, 8);}  
      
    if (digitalRead(DOWNB)==LOW) {out=131; Serial.write(keyDOWN, 8);}  
       
    if (digitalRead(LEFTB)==LOW) {out=132; Serial.write(keyLEFT, 8);}  
       
    if (digitalRead(RIGHTB)==LOW) {out=133; Serial.write(keyRIGHT, 8);}  
       
    if (digitalRead(A1)==LOW) {out=134; Serial.write(keyENTER, 8);}  
      
  delay(20);   
  //Serial.println(out); //des is nur fürs debuggen im serial monitor 
  Serial.write(keyNone, 8); // den Tastendruck beenden 

 delay(20); 
}
IMAG1858
Lochrasterplatine am Arduino

Als nächstes habe ich ein Interfaceboard (eine einfache Lochrasterplatine) mit zwei 9-poligen SUB-D-Buchsen für den Anschluss der Joysticks gebastelt. Da der Arduino genügend Ports besitzt, habe ich auf ein Multiplexen oder Matrixverschalten der insgesamt zehn Steuerleitungen verzichtet und jeden Joystickkontakt direkt auf einen Port gelegt. Das funktioniert schon einmal ganz gut. Aber das Prellen der Federkontakte und Microtaster in den Joysticks muss natürlich softwaremäßig entfernt werden. Um jetzt nicht in jeder Softwareversion einen debounce-code mitzuführen entschloss ich mich das Entprellen in der Hardware zu machen. Einfach ein RC-Glied (10k – 1uF) an einen Schmitt-Trigger und gut ist´s. Also schnell ein Board gelayoutet (das geht schneller als am Lochrasterprint zu löten), geätzt und bestückt… und heraus kam das Board hier:

IMAG1870
Board geätzt und gebohrt
IMAG1871
fertig bestückt am Arduino

Der Funktionstest verlief positiv. Die Bewegungen des Sticks werden sauber umgesetzt. Ein schneller Test mit WinVice ließ sofort das Zockergefühl von vor 30 Jahren aufkommen 😉

Arduino, Elektronikbastler

Radio im Retrolook – Das Finale

Schreibe einen Kommentar

Loading

IMAG1299
Das Holzgehäuse ist lackiert

Nachdem jetzt die Frontplatte gefräst ist, kann sie gereinigt und die Gravuren mit schwarzem Lack versehen werden. Nach dem Antrocknen des Lacks in den Vertiefungen der Gravur, wird die überstehende Farbe mit Lösungsmittel entfernt. Nun konnte die gesamte Platte mit Klarlack lackiert werden.

Während die Lackierung der Frontplatte trocknet, ist wieder das Holzgehäuse an der Reihe. Die Montagelöcher für die Platinen, Lautsprecher usw. wurden gebohrt und anschliessend das Holz mit einer etwas dunkleren Holzbeize eingelassen. Nach dem Trocknen derselben bekommt auch das Holzgehäuse einen Klarlacküberzug.

Im nächsten Schritt werden die Bedienelemente (Schalter und Drehimpulsgeber), sowie das LC-Display an der Frontplatte angebracht. Die ausgefrästen Stege für die Lautsprecherverkleidung werden mit schwarzem Stoff hinterlegt. (Für den Stoff musste ein T-Shirt herhalten).

IMAG1307
Bedienelemente an der Frontplatte

 

Die Lackierung des Gehäuses trocknete cirka einen Tag. Nun kann mit dem Montieren der Lautsprecher und der Platine begonnen werden.

IMAG1301
Einbau der Lautsprecher

 

Die Platine wird mit Abstandhaltern am Gehäuseboden verschraubt.

IMAG1302
Montage der Platine

 

Jetzt fehlt noch eine geeignete Stromversorgung. Hierzu wurde ein kleines Netzteil gebaut, das lediglich aus einem Eisenkerntransformator mit anschließender Gleichrichtung, Glättung und Spannungsstabilisierung mit einem LM7809, also 9V DC, besteht. Dafür wurde eine kleine Platine gefertigt (ca. 5x8cm) und ebenfalls in das Gehäuse mit Abstandhaltern eingebaut.

IMAG1328
Netzteil 240V AC auf 9V DC bei max. 350mA

 

Nachdem nun alles zusammengebaut ist, werden die Verstärkersymetrien und Pegel nochmals mit Signalgenerator und Oszilloskop eingestellt und optimiert.

IMAG1332
Einstellarbeiten

 

Der fertige Radioempfänger sieht nun von der Frontseite so aus…

IMAG1308
Radio von vorne

 

und die Geräterückseite ist im nächsten Bild dargestellt:

IMAG1333
Rückseite

In dem kurzen Video ist das Radio im Betrieb zu sehen:

Arduino, Elektronikbastler

Radio im Retrolook – Update: Das Gehäuse

Schreibe einen Kommentar

Loading

IMG-20150130-WA0000-2Es ist soweit! Das erste Bild des absolut echten Holzgehäuses für die Radioelektronik ist da. Ein wunderschön gefertigtes, aus geleimten Elementen aufgebautes Gehäuse. Dieses Werk stammt aus Gebhard’s  Händen, einem Meistertischler aus dem Oberkärntner Raum 😉

IMAG1272
Gehäuse mit Bohrungen für die Lautsprecher

Jetzt kann das Nostalgie-Radioprojekt wieder einen Riesenschritt nach vorne machen.

frontpanel
Das wird die Aluminiumfrontplatte

Das Gehäuse steht bei uns auf dem Tisch. Zuerst wurden die Löcher für die Lautsprecher gebohrt. Später sollen diese von einer gefrästen Aluminiumblende abgedeckt sein. Also ist der nächste Schritt das Konstruieren der Fräsdaten für die Frontblende. Hier wird wiederum mit dem Layouttool „Eagle“ gearbeitet. Die Daten können einfach als „.dxf“ Datei exportiert  und in die Fräsbohrplottersoftware importiert werden.

 

UPDATE:
Kaum einige Minuten Zeit, machte ich mich auf zum Fräsbohrplotter, importierte die Produktionsdaten, spannte den „Zweischneiderfräser“ ein, natürlich auch den Aluminiumrohling und schon ging’s los.

Die Drehzahl für den 1mm Fräser habe ich mit 60000 U/min gewählt und die Vorschubgeschwindigkeit auf 1,5mm/s in beiden Achsen eingestellt. Gekühlt und geschmiert wurde übrigens mit Spiritus.

Ein nicht zu vernachlässigender Arbeitsaufwand ist übrigens die Reinigung der Anlage nach der erledigten Arbeit… 🙂IMAG1281

 

Arduino, Elektronikbastler

Radio im Retrolook – KnowHow für den Lehrling – 2.Teil

Schreibe einen Kommentar

Loading

…um die Lautstärkensteuerung über den Microcontroller zu realisieren, kam einfach ein „digitales Potentiometer“ X9C102 zum Einsatz. Es wird direkt vom Controller mit einem „Richtungseingang Up/Down“ und einem „Zähl-Eingang“ angesteuert.  Dieses IC besteht intern aus 100 in Reihe geschalteten Widerständen dessen „Abgriff“  mittels Zähleingang bestimmt wird. Also eine einfache Angelegenheit um den Signalpegel des Vorverstärkers in 100 Schritten zu steuern….

 

Fortsetzung von Radio Teil 1
Die Bedienung des Controllers sollte nun über ein Drück-/Drehrad (Drehimpulsgeber mit Taster) erfolgen. Um bei Drehimpulsgebern auch die Drehrichtung auswerten zu können, ist ein zweiter Impulsausgang erforderlich. Die beiden Impulsausgänge müssen in ihrer Reihenfolge drehrichtungsabhängig verschoben sein (Phasenverschiebung). Um die Impulsfolge in ein Richtungssignal und ein Taktsignal umwandeln zu können, haben wir mithilfe eines JK-Flip/Flops und einem Schmitt-Trigger/Inverter eine kleine Decoderlogik aufgebaut…

Drehgeberdecoder

Die Ausgänge der Decoderlogik werden nun direkt an drei Microcontrollereingänge weitergegeben. Somit kann nun ein geeignetes Programm erstellt werden, das ein einfaches menuegesteuertes Userinterface bereitstellt. Die Parameter werden auf einem zweizeiligen LC-Display angezeigt. Die Ausgänge des Controllers wiederum steuern die „digitalen Potentiometer“ für die Lautstärkeneinstellung und natürlich den I²C Bus, der die Befehle an das FM-Modul sendet. Ein zusätzlicher Ausgang ermöglicht das Schalten eines Relais, mit dem zum Beispiel der Audioeingang vom Verstärker zwischen FM-Modul und einer externen Signalquelle umgeschaltet werden kann. Das LC-Display wird im 4Bit Modus an den Controller angebunden und die Hintergrundbeleuchtung des Displays wird ebenfalls vom Controller geschaltet.

 
Platine frisch von der Fertigung

Nachdem alle diese Funktionalitäten festgelegt waren, gings ans Übertragen dieser Informationen in das Layout Tool, bzw. in den Schaltplan. 
Schlussendlich wurde ein Layout gezeichnet und gefertigt. In weiterer Folge konnten wir mit der Bestückung des Boards beginnen und danach die erste Inbetriebnahme durchführen. Nach dem Abgleich der Verstärkerruheströme ging’s ans Entwickeln des Arduinocodes. Hier wird einem die Arbeit extrem erleichert, da es hier sehr viele fertige Libraries gibt, die man direkt für seine Zwecke verwenden kann. So zum Bespiel besteht die einizige Herausforderung, ein LC-Display in Betrieb zu nehmen, darin, die paar Drähte an den uC (Microcontroller) anzuschließen und die Pins im Code richtig anzugeben. Alles andere erledigt die Library. Mit dieser Vereinfachung sind die Funktionen dann schnell realisiert und der erste Probelauf kann beginnen.

Das fertig bestückte Board

In weiterer Folge wird die Software noch verbessert – vielleicht ein Speichern mehrer Stationen implementiert usw. Aber der nächste Schritt wird sein, das Board in ein Gehäuse einzubauen, das den Radioempfängern aus den alten Röhrenzeiten nachempfunden ist. Es soll aus massivem Holz gefertigt werden. Die Bedien- und Anzeigeelemente sollen in einer auf die Frontseite des Gehäuses aufgesetzten Aluminiumplatte eingebaut werden… (Ein weiterer Post in diesem Blog wird folgen.)

Der erste Funktionstest ist im Video unten zu sehen…


Arduino, Elektronikbastler

Radio im Retrolook – KnowHow für den Lehrling – 1.Teil

Schreibe einen Kommentar

Loading

DIE PROJEKTIDEE
Eine Projektidee, die mir als ideales Lehrlingsprojekt in den Sinn gekommen war, ist es, einen Radioempfänger zu planen und zu bauen. Mit diesem Projekt soll unser Lehrling die bisher erworbenen Fähigkeiten praxisnah anwenden und nach Vorgabe der zu verwendenden Komponenten einen UKW Radioempfänger aufbauen.
Dabei wurde schrittweise vorgegangen. Ich habe mir das Konzept in folgenden Teilen ausgedacht:

DER VERSTÄRKER
Zuerst sollte ein simpler Klasse A – Audioverstärker aufgebaut werden. Der Lehrling sollte den Verstärker nach vorgegebener Schaltung am Steckbrett aufbauen, messtechnisch untersuchen und vorallem verstehen. Im nächsten Schritt wurde aus dem Class-A Verstärker ein  Class -AB Verstärker. Auch hier war die Aufgabe des Lehrlings, die Funktionsweise zu verstehen und das Steckbrettfunktionsmuster so zu optimieren, dass ein (nicht messtechnisch) zumindest einigermaßen „gutes“ akustisches Ergebnis erreicht wurde.

Erstes Funktionsmuster der „Leistungsendstufe“

Als das nach einiger Zeit gelang, bekam er die Aufgabe, die ermittelte Schaltung in ein Layout-Tool zu übertragen und auf einen zweiten Kanal zu erweitern und dabei gleich auch ein Spannungsversorgungskonzept zu erstellen. Die Spannungsversorgung sollte nicht nur die Verstärker Endstufe versorgen, sondern auch für weitere Komponenten (wie Microcontroller, USB-Schnittstellen und was mir noch so in den Sinn kam) eine +5V und eine +3.3V DC Versorgung zur Verfügung stellen.
Nach vielen Layoutentwürfen legte er mir dann ein Layout vor, bei dem die Komponenten symetrisch und lagetechnisch vernünftig (Trimmpotis sollten zugänglich sein…) angeordnet waren. Also durfte er das Layout als Funktionsmuster fertigen. (die Platine ätzen, bestücken und versuchen, alles zum Laufen zu bekommen).

Der Lerneffekt war gigantisch :D, denn bei der Umsetzung von theoretischen Schaltungen zu einem einfachen Steckbrettaufbau und dann zur „gedruckten“ Schaltung am Print, birgt einiges an Fehlerquellen. Und diese wollen auch gefunden und behoben werden. Dabei konnte sich unser Azubi in Geduld und genauem Arbeiten üben.
Aber schlussendlich tönte das 440Hz Sinussignal des Frequenzgenerators aus beiden angeschlossenen Lautsprechern…

Nun war es an der Zeit, sich Gedanken über die Signalquelle, also den eigentlichen Empfänger zu machen.

DER UKW EMPFÄNGER

FM-Receivermodul

Bei einem chinesischen Onlineversand entdeckte ich ein UKW-Empfangsmodul mit einer sehr kompakten Bauform (ein Print mit ca. 12x12mm) auf dem ein kompletter Empfänger integriert ist. Das Modul nennt sich TEA5767 und nutzt den gleichnamigen Philips FM-Receiver Chip.
Die Anschlüsse zum Modul bestehen aus Spannungsversorgung, Audio L und R Ausgängen, sowie einem I²C Bus zur Ansteuerung bzw. Einstellung der Empfangsfrequenzen und einem Antennen- und Muteeingang. Also ideal, um damit eine Signalquelle für unseren Verstärker zu realisieren. Doch damit stellten sich weitere Fragen.
Wie sollte man die Steuersignale für den I²C Bus erzeugen, wie soll die Abstimmung der Sender erfolgen, wie soll das Gerät überhaupt vom User zu bedienen sein? Auf all diese Fragen gibts eine einfache Antwort: Man nehme einen Microcontroller. Und da der Lehrling gerne mit dem Arduino – UNO Board experimentiert, entschied ich mich für einen Atmega328, dem Arduino UNO Controller.

DAS HERZ DES RADIOS – DER CONTROLLER
Der Microcontroller sollte also das komplette Management des Radios übernehmen, also die folgenden Funktionen erfüllen:

  • die Sender einstellen (I²C Befehle erzeugen und zum Radiomodul senden)
  • die eingestellten Sender speichern (im internen EEPROM des Controllers)
  • sämtliche Informationen auf einem LC-Display anzeigen
  • die Lautstärkensteuerung übernehmen
  • die Bedienung über ein Drück-/Drehrad erzeugen (Inkrementalgeber mit Tastfunktion soll die gesamte Bedienung des Radios übernehmen)
 Folie1
Blockschaltbild

Also mussten wir die Schaltung um einige Komponenten erweitern. Der Audioausgang des FM-Moduls musste vorverstärkt werden. Dies erledigte ein kleiner AudioOPAmp. Um die Lautstärkensteuerung über den Microcontroller zu realisieren, kam einfach ein „digitales Potentiometer“ X9C102 zum Einsatz. Es wird direkt vom Controller mit einem „Richtungseingang Up/Down“ und einem „Zähl-Eingang“ angesteuert. Dieses IC besteht intern aus 100 in Reihe geschalteten Widerständen, dessen „Abgriff“ mittels Zähleingang bestimmt wird. Also eine einfache Angelegenheit um den Signalpegel des Vorverstärkers in 100 Schritten zu steuern.

weiter geht’s im nächsten Teil

Arduino, Elektronikbastler

Geigerzähler und Radioaktivität

Schreibe einen Kommentar

Loading

Ein Projekt, das schon lange einmal mein Interesse erweckte, war das Detektieren von radioaktiver Strahlung. Nach den Vorfällen in Japan wurde diese Idee wieder ins Gedächtnis gerufen. Ich konnte mich noch dunkel erinnern, irgendwo in meinem alten Werkstattkeller ein unbenutztes Zählrohr zu besitzen. – Nach einiger Suche ist es dann aufgetaucht :). Dank Internet und den Suchmaschinen war auch schnell ein Datenblatt gefunden. Es handelt sich bei dem Zählrohr um ein ZP1400. Ein selbstlöschendes Geiger-Müller-Zählrohr mit Glimmerfenster. Das Rohr ist lt. Datenblatt mit Neon und Argon als Löschgas gefüllt. Die Betriebsspannung liegt bei 400 bis 600V. Die Kapazität zwischen Anode und Kathode beträgt ca. 2pF. Mit diesen und weiteren Informationen aus dem Datenblatt lässt sich nun eine Schaltung basteln, um das Rohr in Betrieb zu nehmen. Dieses kleine Projekt habe ich herangezogen, um gleichzeitg unseren Lehrling im Betrieb in das Leiterplatten-Layout einzuführen und in weiteren Schritten auch mit der Erstellung von kleinen Programmen auf dem Arduino Uno Microcontrollerboard, vertraut zu machen. In diesem Post stelle ich aber nur die „altmodische“ Schaltung vor, wo lediglich das Auftreffen von ionisierender Strahlung auf den Zähldraht akustisch hörbar gemacht wird. (das typische Knacken). Diese Schaltung stellte dann die Grundlage für den Lehrling dar, die Zählung der Impulse mit dem Microcontroller zu realisieren und auf einem Zwei-Zeilen LCD zu visualisieren.

Schaltplan mit Hochspannungsversorgung und Impulsverstärker

Mit Hilfe der allbekannten Layoutsoftware Eagle, habe ich eine Schaltung gezeichnet, bei der wiederum die Hochspannung über einen geschalteten Transformator und anschließender Greinacher-Kaskade erzeugt wird. Die Ansteueung übernimmt diesmal kein 555er, sondern einfach ein rückgekoppelter Schmitt-Trigger. Die Zeitbasis wird über den Koppelwiderstand und den Kondensator eingestellt. Somit steht die Hochspannung für das Zählrohr zur Verfügung. Um nun die Impulse zählen zu können, werden zwei Faktoren sichergestellt. Der Impuls darf eine bestimmte Höhe nicht überschreiten. (Sonst stirbt möglicherweise die nachfolgende Elektronik), und die Impulse sollen hörbar gemacht (verstärkt) werden. Also werden die Peaks mit einer Zenerdiodenschaltung begrenzt und mit Schmitt-Triggern in eine „schöne“ Form gebracht und dann zu einem OP-Amp geführt. Am Ausgang des OP-Amp hängt dann vorerst ein kleiner Lautsprecher …

Anordnung der Bauteile auf dem PCB

Nach dem nun die Leiterplatte geätzt und bestückt wurde, ging’s ans Testen. Aber womit?  Ich benötigte irgendeine schwach strahlende Quelle. Ich hielt alle möglichen Gegenstände vor das Zählrohr, aber es änderte sich nicht viel. Vier bis acht mal in der Minute war ein Knacken aus dem Lautsprecher wahrzunehmen. Also begann ich wieder im Netz zu recherchieren. Und stieß auf den Begriff  „Radiumfarbe“. Es ist dies die selbst leuchtende Farbe, mit der die Ziffernblätter alter Uhren bemalt wurden, um auch in der Dunkelheit die Zeit ablesen zu können. Diese Information brachte mich auf eine Idee. Von meinem Großvater habe einmal einen Höhenmesser eines WW1 Flugzeugs bekommen (Hersteller LUFFT), dessen Ziffernblatt  könnte vielleicht auch mit leuchtender Farbe bemalt worden sein. Also raus damit aus der Vitrine und vor das Zählrohr gehalten… Das Ergebnis ist im Video zu sehen.