Dieses Blog durchsuchen

Freitag, 22. Februar 2013

[Projekt] Raspberry Pi und der Atmel - Teil 2 - Serielle Verbindung

Erster Teil: Raspberry Pi und der Atmel - Teil1

Hallo.

Aufbauend auf der Schaltung aus dem ersten Teil möchte ich mich nun der seriellen Verbinung des Raspberry Pi mit dem Mega8 witmen.
Die Grundlagen hierfür sind zum einen die Schaltung aus dem ersten Teil und zum anderen das wir die serielle Schnittstelle der kleinen Himbeere frei gemacht haben. Wie dies funktioniert erfahrt ihr in meinem Post Raspberry Pi UART und der Asuro im Teil "UART Freimachen".
Solltet ihr diesen Abschnitt erfolgreich hinter euch gebracht haben, so könnt ihr die serielle Schnittstelle für unsere weiteren Schritte nutzen.

Logikpegel konvertieren

 

Unsere Himbeere verfügt über eine serielle Schnittstelle welche leider nicht 5V tolerant ist. Nimmt man sich jedoch einen Standard Mikrocontroller, wie den Mega8 in unserem Fall, so arbeiten wir mit einem 5V Logikpegel. Um nun den Pi nicht gleich den Funktionsumfang eines Backsteines zu geben müssen wir den 5V Logikpegel in einen für den Pi freundlichen 3,3V Logikpegel wandeln. Dabei sollten wir jedoch einiges beachten. Da unser Mikrocontroller über eine eigene Spannungsquelle verfügt ist es ratsam die Schaltung des Controllers vom Pi zu trennen. Natürlich wäre eine Pegelwandlung auch über einen handelsüblichen Pegelwandler wie den MAX3232 möglich oder sogar mit Standard Transistoren wie den BC547 realisierbar. Da wir nicht mit einem Baudratenquarz sondern mit einem ganzzahligen Quarz arbeiten ist mit der Geschwindigkeit bei 38400 sowieso Schluss, da der Fehler danach zu groß wird um eine vernünftige Verbindung hinzubekommen. Die theoretischen Gundlagen dazu findet ihr hier. 

Ich möchte hier in diesem Tutorial die Schaltung des Controllers galvanisch von der des Pi's trennen. Da wir im weiteren Verlauf mit dem Controller eventuell etwas messen wollen, bietet sich dieses an, da wir im schlimmsten Fall nur die Schaltung des Mikrocontrollers zerstören und nicht gleich den Pi mit. Zur Trennung und Konvertierung der Pegel nutze ich einen Liteon LTV 847 Optokoppler. Die zugehörige Schaltung sieht nun folgendermaßen aus.


Es sieht erstmal komplizierter aus als es ist.  Der Optokoppler verfügt intern eigentlich über 4 Optokopple,r wobei jeder aus einer LED (Eingang) und einem Fototransistor (Ausgang) besteht. Ein Blick in das Datenblatt gibt uns Auskunft über die benötigte Spannung und den benötigten Strom der LED. Hier können wir einen Vorwiderstand von 330 Ohm (R1;R2;R3;R5) verwenden. Diesen sollten sowohl im 5V und im 3,3V Logikpegel die LED's ordentlich versorgen ohne das wir an die Grenze beim Pi kommen. Die Widerstände R4 und R5 sind einfache 10 kOhm Pullup-widerstände an den Ausgängen.
Wie ihr seht nutze ich für beide Richtungen jeweils 2 Optokoppler. Würden wir nur einen Koppler nutzen würde unser Signal invertiert beim Pi oder beim Atmel ankommen. Aus einer "1" wird wozusagen eine "0" und umgekehrt. Um den entgegenzuwirken nutzen wir einfach einen zweiten Koppler, da uns ja sowieso 4 zur Verfügung stehen. Ihr könnt die Invertierung natürlich auch mit Transistoren oder softwareseitig realisieren. Aufgebaut sieht unsere Schaltung nun wie folgt aus.




Der erste Kontakt

 

Damit unser Pi mit dem Atmel auch Kontakt aufnehmen kann müssen wir den Controller nun dazu bringen empfangen und senden zu können. Die Grundlagen für die Serielle Schnittstelle findet ihr im Tutorial auf mikrocontroller.net, sodass ich diese hier nur anschneiden werde. Schauen wir uns dazu das folgende Programm an.

/*
 * mega8pi1.c
 *
 * Created: 17.02.2013 14:50:45
 *  Author: Kai Mildner
 */
//Festlegen der Frequenz (Quarz) und der Baudrate
#define F_CPU 16000000UL
#define BAUD 38400UL

//Berechnen der Register für die UART und des Fehlers bei gewählter Baudrate
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD)

//Überprüfen des Fehlers und eventueller Abbruch wenn Fehler > 1%
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif

#include <avr/io.h>
#include <util/delay.h>

//Initialisierung der UART
void uart_init(void)
{
    UBRRH = UBRR_VAL >> 8;
    UBRRL = UBRR_VAL & 0xFF;
    UCSRB |= (1<<TXEN);
    UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
}

//Einzelnes Zeichen via UART senden
int uart_putc(unsigned char c)
{
    while (!(UCSRA & (1<<UDRE)))
    {
    }
    UDR = c;
    return 0;
}

//Zeichenkette via UART senden
void uart_puts (char *s)
{
    while (*s)
    {
        uart_putc(*s);
        s++;
    }
}

int main(void)
{
    uart_init();
    while(1)
    {
        uart_puts("Hallo hier ist dein Mega8\n");
        _delay_ms(100);
        //TODO:: Please write your application code
    }
}


Als erstes Betrachten wir den Abschnitt

//Festlegen der Frequenz (Quarz) und der Baudrate
#define F_CPU 16000000UL
#define BAUD 38400UL


Wie im Kommentar beschrieben legen wir hier unsere Taktfrequenz des Controllers sowie die von uns verwendete Baudrate fest. Ich empfehle dies am Anfang des Programmes zu erledigen, da zum Beispiel die Taktrate auch von der "delay.h" benötigt wird.


//Berechnen der Register für die UART und des Fehlers bei gewählter Baudrate
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD)


In diesem Abschnitt berechnen wir die einzelnen Werte welche wir für unsere gewählte Baudrate benötigen, sowie den Fehler bei selbiger.


//Überprüfen des Fehlers und eventueller Abbruch wenn Fehler > 1%
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif


Hier legen wir fest bis zu welcher Fehlerquote wir arbeiten. Liegt der berechnete Fehler über 1% so bricht die Compilierung des Programms an dieser Stelle ab.


//Initialisierung der UART
void uart_init(void)
{
    UBRRH = UBRR_VAL >> 8;
    UBRRL = UBRR_VAL & 0xFF;
    UCSRB |= (1<<TXEN);
    UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
}


Diese Funktion dient der Initialisierung der seriellen Schnittstelle und legt in unserem Fall folgendes Fest.
  1. Wir können senden, jedoch noch nicht empfangen.
  2. Wir senden mit einem 8Bit Frame

//Einzelnes Zeichen via UART senden
int uart_putc(unsigned char c)
{
    while (!(UCSRA & (1<<UDRE)))
    {
    }
    UDR = c;
    return 0;
}

//Zeichenkette via UART senden
void uart_puts (char *s)
{
    while (*s)
    {
        uart_putc(*s);
        s++;
    }
}


Diese zwei Funktionen dienen nun zum Senden einzelner Zeichen und Zeichenketten.


´int main(void)
{
    uart_init();
    while(1)
    {
        uart_puts("Hallo hier ist dein Mega8\n");
        _delay_ms(100);
        //TODO:: Please write your application code
    }
}



Dies ist unsere Hauptfunktion. Wir initialisieren mittels Funktionsaufruf "uart_init()" unsere Schnittstelle und lassen aller 100 Millisekunden den Text "Hallo hier ist dein Mega8" senden, wobei wir mit " \n" jedesmal einen Zeilenumbruch mitsenden. Schließen wir nun unsere Schaltung am Pi an und starten zum Beispiel "Cutecom" so sieht es mit eingestellten Werten (Baudrate, Datenbits, Stopbit) folgendermaßen aus.



Solltet ihr nun dauerhaft den Text empfangen können, so wisst ihr das zumindest der Sendeteil des Controllers und der Empfangsteil des Pi's klappt. Ihr seit nun in der Lage Werte vom Mikrocontroller an den Pi zu senden.

Da wir jedoch, am Pi, nicht nur empfangen Wollen sondern auch Befehle senden möchten so müssen wir unser Programm noch etwas überarbeiten. Wir brauchen also am Controller eine Ausgabe, damit wir überhaupt sehen können ob alles klappt. Weiterhin bietet es sich auch an am Controller ein bis zwei Eingabebauteile anzubringen, wenn wir sowieso schonmal am Bauen sind. Dazu habe ich einfach 2 Taster (S2;S3) und eine LED (LED1) gewählt. Die Schaltung des Controllers sieht nun wie folgt aus.



Nun können wir Eingaben und Ausgaben am Controller tätigen.
Um jedoch Befehle vom Pi zu senden müssen wir unser Programm noch etwas erweitern.
Dazu können wir natürlich wieder auf das Wissen aus den Tutorials von Microkontroller.net zurückgreifen und uns die Makros zur Tasterentprellung sowie die Interruptroutine für den UART guttenbergen. Ein fertig geschriebenes Programm für den Atmel könnte wie folgt ausschauen.

mega8pi.c

Hier das Atmel Studio Projekt

Mega8Pi.zip

Den Code im einzelnen durchzugehen würde jetzt an dieser stelle den Rahmen sprengen und ist meiner Meinung nach nicht nötig, da dies alles schon 1000mal im Netz gemacht wurde und man das Rad nicht neu erfinden muss. Außerdem empfehle ich euch selbst einen Weg zu suchen und diesen so oft wie möglich zu verwenden. Habt ihr ersteinmal das Grundgerüst so könnt ihr es jederzeit in anderen Projekten verwenden.
Hier noch ein kurzes Video wie die Schaltung der LED Ausschauen könnte. Der Code aus der mega8pi.c wurde dabei verwendet.


Sehr gute Tutorials zur Programmierung der UART auf dem Atmel findet ihr, wie schon so häufig erwähnt, auf mikrocontroller.net. Ich empfehle jeden sich in die Thematiken Interrupts, Timer, Taster Entprellung und UART einzulesen, da dieses das Grundwissen für die Arbeit mit den kleinen Controllern bietet.

Ich hoffe ihr konntet mir einigermaßen folgen und habt nun euren Controller mit dem Pi seriell verbunden. Ich würde mich freuen wenn ihr ab und zu wieder reinschaut.
Es sind noch einige Messaufgaben geplant, sowie eine Stromversorgung des Pi mit Batteriebackup, "An/Aus Taster" und automatischem herunterfahren bei Stromnetzverlust.
Wie ihr seht ist noch einiges in Arbeit. Schaut also einfach mal wieder rein.

MFG

Kai


Donnerstag, 14. Februar 2013

[Projekt] Raspberry Pi und der Atmel - Teil 1

Hi.

Heute möchte ich mit einem Projekt beginnen, welches sich an Anfänger im Bereich der Mikrocontroller und des Datentransfers vom Pi zum Controller richtet. Dabei soll es in diesem Teil erstmal um die Grundschaltung des Atmel gehen. Hier gilt es ein paar kleine Stolpersteine zu beachten. In den weiteren Teilen sind die serielle Anbindung zum Pi, die Ausgabe auf ein LCD-Display sowie einige Messaufgaben geplant.

Zuersteinmal möchte ich die Frage aufgreifen, welche sich einige stellen werden.

"Warum sollte ich einen Mikrocontroller mit dem Pi verbinden?"

 Die Antwort ist erstmal recht trivial.

Weil wir es können!

Wenn wir etwas weiter überlegen kommen uns dann doch Anwendungsgebiete in den Sinn, welche unsere kleine Himbeere nicht so ohne weiteres übernehmen kann und wo es Sinnvoll ist diese Aufgaben auf einen Controller zu übertragen. Diese Anwendungsgebiete umfassen zum Großteil Aufgaben welche recht Zeitkritisch sind. Das kann zum einen das sofortige Auslösen eines Events, als Reaktion auf ein anderes sein, oder zum anderen das Messen von Impulsen ........... Allein das Ansteuern und Auswerten eines Ultraschall-Sonars kann auf dem Pi eine echte Herausforderung werden. Dazu kommen wir aber in einem anderem Teil.
Heute soll es erstmal um den Grundaufbau gehen, welchen wir in den nächsten Wochen benötigen werden.

Grundaufbau 


Spannungsquelle

Die Grundschaltung eines Mikrocontrollers ist vom Prinzip her recht simpel. Als erstes benötigen wir eine Spannungsquelle, welchen unseren Controller mit Strom versorgt. Die Bauteile, welche wir benötigen sind im folgenden

  • Steckbrett
  • Kabel
  • Batteriehalter für min 5 AAA Batterien, einen 9V Block oder eine Buchse für ein Netzteil welches mindestens 7,5V liefert.
  • 1x  LM7805 Linearer  positiv Gleichspannungsregler.
  • 1x Gleichrichterdiode, z.B. 1N4001
  • 1x Elektrolytkondensator min. 10µF
  • 2x Keramikkondensator 100nF
  • 1x LED mit Vorwiderstand (Optional)

Ihr seht also das der Materialaufwand für die Spannungsversorgung recht gering ausfällt. Demnach ist der Aufbau auch sehr schnell erledigt. Bauen wir uns nun die Schaltung nach folgendem Schaltplan auf.

Spannungsregler

Zu beachten ist hierbei das die 2 Keramikkondensatoren ganz nah am 7805 positioniert werden, da diese ein mögliches Schwingen des IC unterdrücken sollen. Für unsere Anwendungen können wir auf eine Kühlung des Spannungsreglers verzichten. Solltet ihr jedoch größere Lasten anschließen wollen, so solltet ihr dem IC eine Kühlung spendieren. Bitte beachtet hierbei das die "kleine Fahne" an welcher ihr die Kühlung anbringt intern mit Masse verbunden ist. Euer Kühlkörper sollte also keine anderen Bauteile berühren. Aufgebaut sieht das ganze dann so aus.

Spannungsregler auf Lochstreifenplatine

Wie ihr seht ist die Schaltung recht einfach aufgebaut. Ich habe sie mir hier vor einiger Zeit auf eine alte Lochstreifenplatine gebaut und sie tut immernoch ihren Dienst. Das Kabel am Eingang habe ich, wie ihr sehen könnt, aus nem alten PC-Gehäuse ;)
Da der von mir verwendete 7805 1,5 Ampere bringt könnte man über diese Schaltung sogar unseren Raspberry Pi betreiben. Als Eingangsspannung könnt ihr zum Beispiel eine 9V Batterie verwenden. Jedoch soll gesagt sein das der 7805 einen recht schlechten Wirkungsgrad hat und die Batterie somit recht schnell aufgebraucht ist. Meine hielt ungefähr eine Woche lang. Inzwischen betreibe ich das Ganze an einem Trafo mit Gleichrichter. Die optional eingebaute LED gibt vom Prinzip nur aus ob die Schaltung gerade an der Versorgungsspannung angeschlossen ist. Sie wird einfach mit einem passenden Vorwiderstand zwischen +5V und Masse geschalten.
Zur Kennzeichnung von Pins auf einem Raster von 2,54cm eignet sich die Schriftgröße 6,1 hervorragend.

Mikrocontroller

Kommen wir nun zum eigentlichen Punkt auf der Tagesordnung. Dem Aufau des Mikrocontrollers. Dazu benötigen wir folgende Bautteile.


  • Steckbrett
  • Kabel
  • 1x Mikrocontroller Atmel Mega8 oder Pinkompatibel (wer schlau ist kauft mehrere)
  • Schwingquarz 16 MHZ
  • 2x Keramikkondensatoren 22pF
  • 3x Keramikkondensatoren 100nF oder größer.
  • 1x Keramikkondensator 47nF
  • 1x Widerstand 10 kOhm
  • Pinleiste (Optional)
  • IC Sockel 28Pin (Optional)
  • Stück Lochrasterplatine (Optional)

Der Aufbau ist vom Prinzip her recht einfach. schauen wir uns einfach folgende Schaltung an.

Grundaufbau

Sieht auf den ersten Blick erstmal komplizierter aus als es tatsächlich ist. Die 3 Keramikkondensator C1-C3 sind immer zwischen den 5V Versorgungspins des Controllers und Masse geschaltet um eventuelle Störungen in der Spannungsversorgung abzufangen. Sie sollten so nah wie möglich am Controller platziert werden um ihre Wirkung entfalten zu können. Der Widerstand R1 hält den Reseteingang standardmäßig auf High damit der Controller arbeiten kann. Wenn der Controller programmiert wird dann zieht das Programmiergerät den Reseteingang auf Masse. Das gleiche erledigt auch unser Taster T1. Er dient uns zum resetten des Mikrocontrollers, sollten wir in der Programmierung einen Fehler haben, der ihn zum Beispiel in einer Endlosschleife hält. Die Beiden Kondensatoren C4 und C5 dienen dem Betrieb mit dem Schwingquarz Q1. Solltet ihr andere Taktgeber verwenden, wie zum Beispiel einen Keramikresonator entfallen diese.
Stecken wir nun unsere Schaltung auf dem Steckbrett. Dies könnte folgendermaßen ausschauen.

Grundaufbau auf einem Steckbrett
Nahaufnahme

Der Pinheader für die den ISP-Programmer kann man einfach aus einem Stück Lochstreifenplatine sowie ein Paar Pins bauen. Dieser Passt wunderbar auf ein handelsübliches Steckbrett. Dazu kennzeichnet ihr euch mit einem Edding einfach die zu durchtrennenden Leiterbahnen und durchtrennt sie anschließen mit einem Cuttermesser.

Oberseite
Unterseite

Solltet ihr euren Aufbau des Öfteren ändern, abbauen und aufbauen wollen, so bietet es sich an den Mikrocontroller in einem IC-Sockel unterzubringen. Die kleinen Beinschen des Controllers sind sonst sehr schnell verbogen. Dazu verfahren wir auf die selbe Weise wie beim Pinheader für den ISP-Programmer.




Nun könnt ihr den Aufbau einfach besser ändern ohne das ihr den Mikrocontroller zerstört.

Programmierung

Hier möchte ich euch als erstes auf die Seite Mikrokontroller.net verweisen. Dort gibt es für den Anfang eine recht umfangreiche Sammlung von Tutorials. Wir werden hier in den nächsten Teilen hauptsächlich C nutzen. Ich möchte jetzt zu diesem Zeitpunkt auch kein neues Tutorial schreiben, da es davon auf der Seite wunderbare Tutorials gibt, welche gerade für Anfänger geeignet sind.
Hier möchte ich jetzt ersteinmal den Controller dazubringen das er auf die externe Taktquelle reagiert.

Als erstes benötigen wir allerdings ein Programm um dies zu tun. Da wir in nächster Zeit einiges für den Controller programmieren werden bietet es sich an das ganze nicht über einen gewöhnlichen Editor zu machen, sondern über eine IDE welche für unsere Aufgabe geeignet ist. Dazu gibt es schon eine fertige Lösung namens "AVR Studio." Dieses könnt ihr euch kostenfrei herunterladen. Lasst euch am Anfang nicht von der Funktionsvielfallt abschrecken. Wenn ihr erstmal damit arbeitet erklärt sich alles von selbst. Ihr müsst lediglich euren Programmer einstellen, sofern dieser vom AVR Studio unterstützt wird. Ich verwende den MySmart USB Light von MyAVR. Dieser ist recht günstig und für unsere Zwecke absolut ausreichend. Da er standardmäßig als STK500 Programmer erkannt wird ist die Einrichtung im Studio ganz einfach. Ihr findet die Einrichtung unter "Tools->Add STK500..." Dort wählt ihr einfach die Schnittstelle aus an der euer Programmer angeschlossen ist.


Damit der Controller nun auf die den externen Taktgeber hört müssen wir unter "Tools-Device Programming" die Fuses so einstellen das wir den externe Quarz verwenden. Dazu wählt ihr einfach euren Programmer, gebt den Controller an und bestätigt mit "Apply"


Nun könnt ihr unter "Fuses->SUT_CKSEL" den Externen Taktgeber einstellen. Verwendet ihr wie hier beschrieben einen Quarz, so wählt ihr "EXTHIFXTALRES_16KCK_64MS" und bestätigt das ganze mit "Program."


Solltet ihr eventuell die Fehlermeldung erhalten das die Lesespannung außerhalb der Reichweite ist, so könnt ihr dies einfach ignorieren und mit "yes" übergehen. Dies liegt daran das einige STK500 Clone die Übergabe der Lesespannung einfach nicht unterstützen. Das sollte aber kein Problem darstellen.

Nun sollte der Controller auf die externe Taktquelle reagieren. Ihr könnt nun gerne eure ersten versuche unternehmen und ein paar kleine Programme schreiben. Nutzt das Tutorial auf Mikrokontroller.net und nutzt das Ganze um euch für die nächsten Teile meines Projektes mit dem AVR Studio und dem Mikrocontroller vertraut zu machen.

Ich hoffe ihr konntet den Schritten hier erfolgreich folgen und habt nun den Grundaufbau für die kommenden Teile fertig.


Anmerkung: Ich wurde des Öfteren gefragt warum ich nicht einfach einen Arduino nutze. Dazu möchte ich sagen, dass ich es einfach nicht mag fertige Module zu nutzen. Bei einigen Dingen lässt es sich nicht vermeiden (LCD-Display, Ultraschallsonar). Ich möchte die Dinge, die ich nutze, verstehen. Der Arduino ist ein feines kleines Modul, jedoch ist es ein Fertigmodul an dem ich nichts ändern kann. Ich möchte die Dinge so weit wie es geht von Anfang an selbst bauen und verstehen. Hinzu kommt das wir, wenn wir statt dem Mega8 einen Mega328 nutzen, mittels des Arduino Bootloaders einen vollwertigen Arduinoersatz haben.

Sonntag, 10. Februar 2013

[Projekt] Raspberry Pi UART und der Asuro

 Erforderliche Grundlagen: Console öffnen, Editor bedienen, Elektronik stecken können.

Hi.

Heute werden wir uns dem Thema UART des Raspberry Pi zuwenden. Ich habe hier seit einiger Zeit den Asuro von Arexx herumliegen und hatte, bis ich den Pi hatte, leider keine Verwendung dafür. Ich hatte ganz einfach das Problem, dass ich die Version mit dem RS-232 IR Transceiver habe. Leider hat mein PC, wie die meisten heutzutage, keinen RS-232 Anschluss mehr. Somit hätte ich zwar auf anderen Weg eine Schnittstelle wählen können (USB-UART Bridge), doch irgendwie hatte ich bisher keinen Antrieb. Dies änderte sich als ich den Pi in den Händen hielt. Endlich ergab alles einen Sinn ;) Ich verwende einfach die UART des Pi!

RS232 Modul des Asuro

Dazu müssen wir  uns ersteinmal der Seriellen Schnittstelle des Raspberry Pi zuwenden. Diese können wir nämlich nicht einfach benutzen wie wir es wollen.
Unsere kleine Himbeere ist ziemlich kontaktfreudig konfiguriert und gibt somit den gesammten Bootvorgang auch seriell aus. Weiterhin ist es möglich sich auf dem Pi über die serielle Verbindung anzumelden. Dies stört uns natürlich wenn wir den kleinen mit dem Asuro verbinden wollen. Also heist es erstmal:

UART Freimachen


In den Standardeinstellungen bekommt ihr folgendes Bild wenn ihr euch über die Serielle Verbindung mit dem Pi verbindet.



Pi konfigurieren


Dazu müssen wir uns nur zwei Dateien zuwenden.

/boot/cmdline.txt
/etc/inittab

CMDLine.txt
 
Wenden wir uns nun der ersten Datei zu. Die Datei /boot/cmdline.txt regelt den Bootvorgang des Pi und gibt ihm beim Booten die Optionen wo er zum Beispiel das Root Verzeichniss findet.
Unbearbeitet schaut die Datei folgendermaßen aus.

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Diese Optionen sagen dem Pi beim Bootvorgang nun das er auf der Console "ttyAMA0" die Bootlogs ausgeben soll. Die Option "root=....." sagt ihm wo er das root Verzeichniss findet. Wir müssen also nur den Bereich mit der Seriellen Schnittstelle bearbeiten. Dazu ändern wir

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1

in

dwc_otg.lpm_enable=0 console=tty1

ACHTUNG!!!

Die Einträge hinter "console=tty1" müssen alle bestehen bleiben!!! Sonst findet euer kleiner beim Hochfahren das root-Verzeichniss nichtmehr und bleibt beim Booten mit ner Kernel Panic hängen!!!

Somit schaut unsere cmdline.txt nun folgendermaßen aus.

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Wie aus nano gewohnt speichern wir die Datei mit "strg+o" und schliesen sie mit "strg+x"

Inittab 
 
Nun ist die Datei "/etc/inittab" an der Reihe. In ihr ist geregelt das die Serielle Schnittstelle zum Einloggen benutzt werden kann. Dazu Öffnen wir wieder die Datei und ändern den Eintrag:


#Spawn a getty on Raspberry Pi serial line
T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

in

#Spawn a getty on Raspberry Pi serial line
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100


 Wir kommentieren die Zweite Zeile also einfach aus.
Wenn wir den Pi nun neustarten können wir die serielle Schnittstelle nach unseren Belieben nutzen.

Logik-Level-kovertieren


Um unsere Serielles modul nutzen zu können müssen wir natürlich ersteinmal das 3V3 Logiklevel unseres Pi's in ein für das Modul nutzbares konvertieren. Hierzu gibt es mehrer Ansätze. Zum einen kann man natürlich einen MAX3232 Levelshifter nehmen, oder man schaut sich ersteinmal die Anleitung des Asuro mit beiligender Schematik an.

Daraus wird ersichtlich das sowieso nur mit positiven logikpegeln gearbeitet wird und wir mit ein Paar kleinen änderungen 5V nutzen können. Da wir hier mit einem NE555 Timer arbeiten und dieser ziemlich tollerant ist, was die Versorgungsspannung betrifft, so können wir ihn einfach ohne Änderungen mit 5V betrteiben. Anders verhält es sich mit dem SFH5110-36. Dieser arbeitet grundsätzlich nur mit 4V5-5V5. Da R3 nun aber einen Widerstand von 470 Ohm hat würde bei 5V Betriebsspannung nicht mehr genug für den SFH übrigbleiben. Rein von der Theorie könnten wir ihn einfach Brücken. Wer sich mein Foto des RS-Moduls oben genauer anschaut wird den kleinen Widerstand an der Linken Seite entdecken. Dieser ist nicht Standard dort ;) Dabei handelt es sich um einen 68 Ohm Widerstand welcher zu R3 parallel geschaltet ist. Dadurch ergibt sich ein Gesamtwiderstand von rund 59 Ohm.


68 Ohm Widerstand paralell zu R3

Nun kann unser IR empfänger arbeiten.
Leider sind die GPIO-Pins des Pi nicht 5V tollerant, sodass wir uns etwas überlegen müssen.
Laut der Anleitung des Asuro sollen wir die Baudrate der Seriellen Schnittstelle auf 2400 Baud stellen. Das ist ziemlich langsam, sodass wir hier einfache Transistoren nutzen können um der Levelkonvertierung vorzumehmen. Die Schaltung hat außerdem den Vorteil das wir keine Logik negation brauchen, wie sie im PC vorgenommen wird. Bauen wir uns also folgende Schaltung.

Pegelwandler Schema
Gesteckt sieht dies dann in etwa so aus.
Ausschnitt

Gesteckter Pegelwandler

Wie ihr seht habe ich einfach ein Kabel aus einem altem PC-Gehäuse genommen.

Test


Schauen wir uns nun an ob alles funktioniert. Wir öffnen "Cutecom" und schauen ob wir die Zeichen die wir senden auch wieder vernünftig empfangen. Dazu einfach wie in der Asuro Anleitung beschrieben ein weißes Blatt mit etwas Abstand über das RS232 Modul halten. Sollte Cutecom bei euch noch nicht installiert sein so könnt ihr dies einfach mit

sudo apt-get install cutecom

erledigen.
Im Cutecom Fenster könnt ihr nun die Einstellungen für die Datenübertragung einstellen. Die Angaben entnehmt ihr einfach der Anleitung des Asuro. Wenn ihr nun im unteren Eingabefenster etwas eingebt so wird dies im Ausgabefenster oben erscheinen.


Betrachtet man das ganze mit einem Logik-Analysator sieht das ganze so aus.


Das wars auch schon. Wir sind nun in der Lage mit unserem Asuro zu kommonizieren und ihn vom Pi aus zu flashen.

MFG

Kai







Samstag, 9. Februar 2013

[Aktuell] Raspberry Pi als Medienserver für Smart-TV's

Hi.

Aus aktuellem Anlass möchte ich jetzt mal auf die Lösung eines kleinen Problemes eingehen welches mich die letzten Tage erreichte.

Viele nutzen ihren Raspberry Pi als Fileserver, da dieser wunderbar dafür geeignet ist. Er ist klein, leise und stromsparend. Geradezu perfekt für diese Anwendng im Heimbereich. Jedoch sei gesagt das er auch etwas unterdimensioniert ist wenn es Dinge wie Raid 1 geht. Somit ist der Pi für Datensicherungen ungeeignet.

Darum soll es hier aber auch garnicht gehen. Wir schauen uns mal an in wieweit wir die kleine Himbeere dazu bekommen unsere Filme an den Fernseher zu schicken.

Als erstes vorweg: Jeder Hersteller hat für die Einbindung ins Nezt einen eigenen Namen. Bei Samsumg heist es zum Beispiel "Samsung Allshare." Dahinter verbirgt sich nichts weiteres als DLNA. Was DLNA bedeutet und woher es kommt soll uns hier erstmal nicht interessieren. Heute geht es rein um die Anwendung auf dem Pi.

Um den Pi DLNA fähig zu machen bedarf es als Grundlage erstmal nicht viel. Wir brauchen das Betriebssystem und ein Netzwerk in welches wir den Pi hängen. Ob wired oder wireless ist im Grunde egal.

Als Betriebssystem habe ich mich für das standard System Raspian "Wheezy" entschieden, da es alles zur Verfügung stellt was man so braucht. Netzwerktechnisch hängt mein Pi ganz simpel per Kabel am Router.


Kommen wir nun dazu die kleine Himbeere DLN fähig zu machen.

Dazu verwenden wir den kleinen Serverdienst "MiniDLNA" Diesen können wir rein aus dem Terminal installieren und konfigurieren.

Wir Installieren ihn einfach mittels.

sudo apt-get install minidlna

und bestätigen die folgende Nachfrage mit "yes"


1. Die Konfiguration

Nachdem wir nun den Serverdienst installiert haben müssen wir ihn konfigurieren. Dazu dient die Datei "/etc/minidlna.conf" Diese öffnen wir als root.

sudo nano /etc/minidlna.conf

Nicht erschrecken. Sehr viel von der Konfigurationsdatei ist einfach nur Text zur Dokumentation.
Für uns sind folgende Einträge wichtig.

media_dir=
network_interface=
friendly_name=
inotify= 


Die anderen Einträge wie IP-Adresse sind optional und dienen der erweiterten Konfiguration und werden von uns erstmal nicht beachtet. Wenn ihr allerdings den Ort der Datenbank selber festlegen wollt oder festlegen wollt das der Server nur auf eine bestimmte IP hört sind diese Optionen für euch interessant.

Wenden wir uns aber nun dem ersten Konfigurationspunkt zu. Dem festlegen der Ordner.
Sicherlich habt ihr eure Videos, Musik und Fotos auf einer externen Festplatte am Pi angeschlossen. Dabei ist jetzt wichtig wohin ihr diese Platte gemountet habt. Wir nehmen hier mal folgendes an.
  • Die Platte hat eine Partition: SDA1
  • Auf der Platte befinden sich die Ordner: Musik, Videos, Fotos
  • Die Partition ist in "/media/USB" gemountet
Wenn wir dem Server nun sagen wollen wo er welche Dateien findet stehen uns 3 Optionen zur Verfügung.
  • "V" für Video
  • "A" für Audio
  • "P" für Fotos
Demnach bearbeiten wir die Konfigurationsdatei folgendermaßen. Den Eintrag

media_dir=/opt

ändern wir in

media_dir=V,/media/USB/Videos

Danach ergänzen wir die anderen Ordner auf die gleiche Weise, sodass unsere Konfiguration folgendermaßen ausschaut.

media_dir=V,/media/USB/Videos
media_dir=A,/media/USB/Musik
media_dir=P,/media/USB/Fotos


Jetzt weiß unser Server wo er nach den Dateien suchen muss. Damit er dies auch regelmäßig tut verwenden wir die Option

inotify=

ein einfaches "yes" hinter das "=" und schon sucht er automatisch nach neuen Daten.
Noch ist unser Server aber nicht von außen erreichbar. Dem Wenden wir uns jetzt zu.
Die Option

network_interface=

bearbeiten wir indem wir ihr einfach unsere Netzwerkschnittstelle angeben. Standardmäßig ist das "eth0", wer WLan benutzt sollte vorher mit

ifconfig

nachschauen wie sein WLan interface genannt wird. Meist ist dies jedoch "wlan0"
Unsere Option sieht nun folgendermasen aus.

network_interface=eth0

Jetzt weiß unser Server das er auf alles hören soll, was an unserer Netzwerkkarte ankommt.
Mit der Option

friendly_name=

legen wir lediglich den Namen des Servers fest. Solltet ihr den Pi bereits als Fileserver mit Samba verwenden empfiehlt sich den dort verwendeten Namen zu benutzen. Ansonsten sind eurer Phantasie keine Grenzen gesetzt. Bei mir sieht die Option nun so aus.

friendly_name=PiDLNA

Nun sind wir auch schon mit der Konfiguration fertig und können sie mittels "strg+o" Speichern und mit "strg+x" schliesen.


2. Der erste Start

Lesen wir nun unsere Dateien ein erstes mal ein. Dies geschieht ganz einfach mit

sudo -u minidlna minidlna -R

Je nach anzahl der Dateien kann das ne ganze Weile dauern.
Ist der kleine damit fertig starten wir den Serverdienst ein erstes mal mittels

sudo service minidlna start

Das stoppen erfolgt auf gleiche Art nur halt mit "stop"


3. Autostart

Das Automatische Starten könnt ihr auf unterschiedlichste Arten erledigen, sodass ich hier nur eine nennen will.
Ihr erstellt eine Datei namens "minidlna.conf" im Verzeichniss "/etc/init/"

sudo nano /etc/init/minidlna.conf

und kopiert folgendes Script hinein.

# DLNA Service

description "minidlna"

#change IFACE to the right interface, see /etc/minidlna.conf
start on net-device-up IFACE=eth0
stop on runlevel [!2345]

#respawn the process if it crashes
respawn

# tell upstart we're creating a daemon
# upstart manages PID creation for you.
expect fork

env ARGS='-f /etc/minidlna.conf'
env MINIDLNA='/usr/sbin/minidlna'

exec $MINIDLNA $ARGS 

Natürlich müsste ihr die Netzwerkschnittstelle "IFACE" auf eure Konfiguratiopn anpassen. Für unser Beispiel hier ist "eth0" aber genau richtig.


4. Testen

Wenn wir nun auf unserem Hauptrechner unsere Netzwerkumgebung öffnen sehen wir den neuen Server in unserem Netzwerk unter "Multimedia"

Öffnen wir diesen nun so öffnent sich nicht der Explorer sondern der Window Media Player und wir können den Server in der Linken Spalte auswählen und in Ruhe durch unsere Filme,Musik und Fotos suchen.



Funktioniert dies, so steht der anwendung am TV nichts mehr im Wege. Natürlich kann ich euch jetzt nicht erklären wie ihr euren TV einrichtet. Dazu müsst ihr immernoch die anleitung lesen oder es rein intuitiv machen ;)

Ich hoffe ich konnte euch ein wenig weiterhelfen und freue mich mit euch wenn es bei euch klappt.

MFG

Kai

Vorbereitungen

Hi.

Heute soll es erstmal um das Thema "Vorbereitungen" gehen. Es nützt ja absolut nichts wenn man ein Projekt im Kopf hat und nicht weiß wo man das ganze verwirklichen kann. Ich selbst wohne in ner 4-Raum-Wohnung mit einem kleinen Keller (ohne Strom) und nem 2 Jährigen Sohn. Ihr könnt euch sicherlich vorstellen das größere Projekte da schon etwas schwierig zu realisieren sind. Am Anfang ging es noch das ich Schaltungen auf dem Wohnzimmertisch zusammenbastelte und sie nach getaner Arbeit einfach wieder wegräumte. Sobald die kleinen aber laufen können wird die Sache schon kritischer ;)

Also musste ein Arbeitsplatz her der unter meiner Kontrolle stand. Meine Anforderungen waren dabei folgende.

Kriterien für einen Arbeitsplatz
  1. Abschliesbar!
    Kein Arbeitsplatz zu Hause bringt etwas wenn einfach jeder hingehen kann und daran rumfummeln kann. Somit kann man sein Projekt auch mal über Wochen stehen lassen. Denn ihr kennt das sicherlich. Man nimmt sich was vor, ist halb fertig und hat plötzlich keine Zeit mehr. Nichts ist schlimmer als alles wieder abbauen und wegräumen zu müssen.

  2. Stromanschluss verfügbar!
    Klar ist das Grundlage für alles. Damit viel unser Keller jedoch aus der Wahl raus.

  3. Ausreichend beleuchtet!
    Schaltungen zu löten ist bei gedimmten Licht einfach eine Qual. Es strengt ungemein an und macht auch nicht wirklich Spaß. Fündig wurde ich bei Ikea. Die hatten ne recht günstige Arbeitsplatzlampe für 13€ namens "Tertial" Ich kann die in Verbindung mit ner Halogen Glühbirne nur empfehlen. Nutzt ja keine Energiesparlampen die ewig brauchen um Hell zu werden oder am Ende nur warmes Gelbes Licht abgeben. Die sind schön für das Wohnzimmer, an nem Arbeitsplatz haben sie allerdings nichts verloren!

  4.  Zugang zu Informationen!
    Jeder der sich jetzt denkt "Ich mach mir was im Keller. Da ist es Ruhig, ich hab Strom und kann alles stehen lassen." sollte gewarnt sein. Vergewissert euch das ihr Zugang zu euren Informationen habt. Solltet ihr WLan im Keller haben so ist es sicherlich in Ordnung diesen Platz zu wählen und eventuell mit nem Tablett nach Infos zu suchen. Es gibt aber nichts schlimmeres als ständig Hoch und Runter rennen zu müssen um etwas nachzulesen oder nachzuschauen.

  5. Die Möglichkeit Dinge zu verstauen!
    Klar ist ein großer Arbeitsplatz schön, aber er nützt nichts wenn einfach alles auf ihm Rumliegt. Schafft euch Platz indem ihr euch ein Ordnungssystem überlegt.

  6. Zerstörbarkeit!
    Nein, nicht das ihr jetzt Denkt "Im Notfall muss ich es in die Luft sprengen können" ;) (Außer ihr googelt zu oft nach ner Bezugsquelle für Plutonium) Es soll einfach nur heißen das ihr den Arbeitsplatz so wählt das ihr euch keine Sorgen machen müsst wenn mal ein Kratzer auf der Tischplatte entsteht oder ihr den Lötkolben mal fallen lasst. Muttis schöner Esstisch fällt damit weg ;)

  7. Ausreichend Platz!
    Klar am Anfang kann man die ersten kleinen Schaltungen noch am Schreibtisch vorm PC zusammenstecken. Sobald ihr aber Schaltungen bauen wollt die über mehre Tage bestehen sollen, dann wird es am PC-Schreibtisch schon eng. Zumal ihr ja sowieso den Zugang zum PC braucht.
So unseren Platz haben wir nun gefunden. Doch uns fehlt noch so Einiges um endlich Anfangen zu können.

Werkzeug

Wenden wir uns nun dem Wichtigsten zu was wir haben sollten. Dem Werkzeug! Da wir uns im Anfängerbereich bewegen sind Großanschaffungen wie ne 900€ Lötstation natürlich komplett übertrieben. Dennoch sollte man nicht einfach den nächsten Billiglötkolben für 5€ bei Ebay kaufen. Ich möchte hier auch keinen Anspruch auf Vollständigkeit erheben.

Was brauchen wir für den Anfang?

  • Steckbrett:
    Jeder der seine Schaltung vernünftig testen will sollte so was haben. Die Angebotspalette ist riesig sodass es schwer fällt einen Favoriten zu sagen. Ich persönlich Arbeite gerne mit unterschiedlichen Größen. So muss man für ne kleine Schaltung mit LED und Widerstand nicht gleich das 830 Kontakte Breadboard bemühen.

  • Zangen:
    Eine kleine Auswahl sollte man schon haben. Da wir mit Kleinteilen arbeiten versteht sich von selbst das wir mit der 5" Rohrzange nicht weit kommen. Eine Auswahl findet man aber in jedem Baumarkt für rund 10€. Ein Seitenschneider ist meist auch mit dabei.

  • Pinzette:
    Sollte in keinem Fall fehlen

  • Messgerät:
    Für den Anfang reicht ein handelsübliches Multimeter vollkommen aus. Sollte man allerdings digitale Signale analysieren wollen, was recht schnell der Fall sein wird, so kommt man um einen Logik Analysator nicht drumrum. Angebote gibt es viele, wie zum Beispiel den Open Bench Logic Sniffer, den Bus Pirate sowie kommerzielle Produkte wie den Saleae Logic 16. Ich persönlich besitze noch nen älteren 8 Port von Saleae welcher wirklich gut funktioniert und für meine Zwecke absolut ausreichend ist. Gebraucht bekommt man die schon günstig bei Ebay. Ob sich ein Nachbau aus Vernost lohnt muss jeder für sich selbst entscheiden. Ein Oszilloskop ist für den Anfang noch nicht von Nöten, aber "nice to have."

  • Kabel für das Steckbrett:
    Kabelsortimente für Steckbretter gibt es einige, jedoch sind die meiner Meinung nach übertrieben teuer. 10m Schaltdraht aus dem Baumarkt mit den maximalen Querschnitt von 0,6mm² verrichten die gleiche Arbeit und sind dabei Flexibler in der Anwendung. Das einzige worauf ihr achten müsst ist das ihr keine Litze kauft. Eine gute Quelle für Jumperkabel mit weiblichen Steckern sind zum Beispiel alte PC Gehäuse. Dort finden sie Verwendung um LED's, USB oder Audioausgänge anzuschließen.

  • Schraubendreher:
    Sollte sowieso in jedem Haushalt vorhanden sein.

  • Lötkolben:
    Hier sollte man auf jeden Fall darauf achten das die Temperatur regelbar ist. Der 150W Lötkolben aus der Klemptner-Abteilung ist garantiert nicht geeignet. Eine günstige Lötstation für den Anfang ist zum Beispiel die ZD-99. Die ist für den Einsteiger absolut ausreichend.

  • ISP-Programmer:
    Sobald man sich mit Mikrocontrollern beschäftigt kommt natürlich der Wunsch auf diese selbst zu Programmieren. Dazu braucht man allerdings einen ISP-Programmer. Ich verwende derzeit einfach den MySmart USB light von MyAVR. Bisher lief er absolut zuverlässig und verrichtet seine Arbeit ohne Probleme. Leider habe ich schon einiges anderes gehört. Wie gesagtm für mich passt er. Wer auf Nummer sicher gehen will ist mit dem AVRISP Mk2 auf der sicheren Seite. Auch wenn er meiner Meinung nach vom Preis überdimensioniert ist ;)

  • Kleinteileregister:
    Zum Ordnung halten absolut unverzichtbar. Nichts nervt mehr als den richtigen Widerstand zwischen 1000en rauszusuchen und nochmal 1000 Kondensatoren dazu. Ihr wisst was ich Meine.

  • Dritte Hand:
    Platienenhalter, dritte Hände oder wie die ganzen Ständer heisen gibt es genug. Hier sollte man auf jedenfall darauf achten das er einen festen Stand hat (schwerer Standfuß) und das die Gelenke wirklich fest gestellt werden können. Es ist nerfig wenn sich alles immer lockert. Eine Lupe sowie Beleuchtung sind auch nicht verkehrt.

  • Messer und Schere:
    Ein scharfes Messer sowie eine robuste Schere verstehen sich von selbst. Ein Cuttermesser sowie eine Auswahl an Skalpellen sollte auch nicht fehlen.
 So ich hoffe ihr konntet einen ersten Überblick gewinnen was es alles braucht um mit einem Projekt als Anfänger starten zu können. Natürlich ist mir bewusst das die Ansprüche wachsen werden, deshalb soll das erstmal als eine Liste der Grundausstattung herhalten. Mit erfolgreichem Abschluss eines Projektes wächst natürlich auch die Lust was Besseres, Größeres und Leistungsfähigeres zu bauen. Das erfordert dann natürlich mehr Werkzeug, einen größeren Arbeitsplatz und und und....... Ihr werdet es schnell merken ;)

MFG

Kai


Der erste Blog-Post

Hallo.

Dies hier ist mein erster Blog und ich freue mich darauf meine Erfahrungen mit euch teilen zu können. Ihr fragt euch jetzt sicherlich:

"Worum gehts in dem Blog?"

Also zu Allererst soll dieser Blog Themen aus dem Bereich der Technik und Informatik aufgreifen die mich aktuell interessieren. Dabei möchte ich die Schwerpunkte auf den Raspberry Pi legen, sowie auf den Einstieg in die Arbeit mit Mikrokontrollern und der Entwicklung eigener Schaltungen und Programme.

Was dieser Blog nicht leisten kann ist die eigene Denkarbeit sowie vollständig jeden Aspekt der Einzelnen Themen zu berücksichtigen.

Ich hoffe ihr konntet einen ersten Eindruck gewinnen und würde mich freuen wenn ihr meine Projekte verfolgt, ab und zu über Fehler hinwegseht ;) und vorallem Kommentare hinterlasst.  Ich bin Kritikfähig, das heist das ihr gerne auch Anregungen hinterlassen könnt. dies ist sogar erwünscht, denn keiner ist Vollkommen.

So nun genug des Bla Bla. Lassen wir taten folgen.

MFG

Kai