Dieses Blog durchsuchen

Wird geladen...

Montag, 20. Mai 2013

[Tutorial] Active Directory Domain Controller on Raspberry Pi



Hallo

In den letzten Tagen hatte ich wiedermal ein wenig Zeit mich meiner kleinen Himbeere zu widmen. Ich habe deshalb ein wenig herumprobiert wie man am effektivsten  einen "Active Directory Domain Controller" aus unserem kleinen Alleskönner machen könnte. Herausgekommen ist das folgende Tutorial welches ihr euch hier herunterladen könnt.

 PDF: Samba 4 Active Directory on Raspberry Pi

Ich habe wie immer versucht das ganze von Beginn an zu erläutern. So fängt es bei der Installation des Raspian Betriebssystemes an und endet mit der Konfiguration der Benutzerordner und Profile in Active Directory.

Ich würde euch bitten mir ein Feedback dazu zu geben.

Ich würde gerne wissen ob alles so wie ich es beschrieben, und auch bei mir getestet, habe auch bei euch funktioniert. Auch das melden von Tippfehlern und falscher Rechtschreibung ist erwünscht.

Eine Webversion des Dokuments wird in den nächsten Tagen hier in meinem Blog erscheinen. Jedoch hatte ich mein Hauptinteresse erst einmal darauf gelegt eine Druckbare Version zu verfassen.

MFG

Kai

Sonntag, 17. März 2013

[Projekt] DIY PiPower Netzteil

Hallo.

Da ich mich seit einiger Zeit mit der kleinen Himbeere befasse ist es mir etliche Male passiert das ich vergessen habe das Kabel aus dem Pi zu ziehen. Jedesmal habe ich mich dann früh morgens geärgert wenn der kleine wieder die ganze Nacht unter Strom stand obwohl ich ihn am Abend heruntergefahren habe. Darum habe ich ihn an eine Schaltbare Steckdose gehängt. Das hatte aber wieder zur Folge das ich einige Male den Schalter betätigt habe obwohl der Pi noch arbeitete.
Na gut, selber Schuld, aber ich hatte einfach vergessen das der kleine ebenfalls an der Steckdose hängt.

Deshalb habe ich nach einer Möglichkeit gesucht den Pi automatisch auszuschalten und gegen Stromausfälle zu sichern. Meine Lösung möchte ich euch nun hier vorstellen.


Aufbau auf einer Lochstreifenplatine

 

Das Pipower Netzteil 


Die von mir entwickelte Schaltung ist im Grunde kein richtiges Netzteil, da man zum betreiben noch ein normales Steckernetzteil mit mindestens 9V bei 1,5A braucht.
Der Grund ist ganzeinfach:

Dieser Block hier richtet sich vorallem an Anfänger und ich möchte keinem Anfänger raten irgendetwas mit 230V zu bauen!!!

Jeder der das Wissen und die Fähigkeiten dazu hat, wird diese Schaltung selbständig zu einem Vollwertigem 230V Netzteil erweitern können.

Im Grunde bietet diese Schaltung folgende Möglichkeiten:
  • Ein und ausschalten des Pi's über einen Taster (mit vorherigem automatischen Herunterfahren)
  • Auto-off nach Herunterfahren
  • Sicherung vor Stromausfällen über ein Akkupack
  • Die Möglichkeit die Batteriespannung zu überwachen
  • Die Möglichkeit die Netzspannung zu überwachen

Durch die Überwachung der Batterie- und Netzspannung ist es möglich den Pi sicher herunterzufahren, sollte 1. Der Netzstrom ausfallen, oder 2. Die Batteriespannung beim Batteriebetrieb zu gering werden um einen sicheren Betrieb des Pi's zu gewährleisten.


Die Bauteile


Die Schaltung basiert auf einem Atmel Mega8, einem L4940V5 Low-Drop-Spannungsregler sowie einem IRZL34N Mosfet.

Folgende Bauteile werden benötigt:
  • 1x DC-Jack zum Anschluss des eigentlichen Netzteils
  • 1x USB-A-Buchse zum Anschluss des Pi's
  • 1x ELKO 20V 1000uF
  • 1x ELKO 10V 100uF
  • 4x 100nF Keramik- oder Folienkondensator
  • 1x 47nF Keramikkondenstor
  • 2x 22pF Keramikkondensator
  • 4x 1N4001 Gleichrichterdioden
  • 1x L4940V5 Spannungregler
  • 1x Atmel Mega8
  • 1x Pinleiste min. 1x10 Pins
  • 1x LTV847 Optokoppler
  • 1x Schwingquarz 4-16MHZ
  • 1x IRLZ34N N-Kanal-Mosfet (HEXFET)
  • 4x 10kOhm Widerstand
  • 4x 330Ohm Widerstand
  • 2x 1MOhm Widerstand
  • 2x 630kOhm Widerstand
  • 2x Taster
  • 2x Kühlkörper

 

Die Schaltung


Die Schaltung ist vom Prinzip her in 3 Blöcke geteilt. Zum ersten in die Spannungsversorgung mit schaltbarer USB-Buchse für den Pi, zum Zweiten in die Atmeg8 Steuerung und zum dritten in die Pegelwandlung mit galvanischer Trennung der seriellen Verbindung.

Schauen wir uns aber zuersteinmal die Gesamte Schaltung an. ACHTUNG!!! PIN 1 und PIN 4 der ISP sind vertauscht. Pin 1 muss natürlich an MISO und Pin 4 an MOSI!!!

Hier könnt ihr die drei Blöcke erkennen.

Der erste Teil (Spannungsversorgung)

Spannungsteil
Dieser Teil dient nur der Spannungsversorgung des Pi's und des Atmels.

X1 ist dabei unsere Buchse für das Netzteil. Bat1 Ist der anschluss für die Batterien, welche Parallel zu X1 Geschalten werden. Für die Batterien solltet ihr min 9V und 2500mAh einplanen, damit euer Pi auch eine Weile mittels Batterie laufen kann. Als Netzanschluss nutze ich ein 12V/2A Universalnetzteil. Ihr solltet außerdem darauf achten das die Spannung vom Netzteil über der der Batterien liegt, da ihr sonst auch die Batterien entladet wenn das Netzteil angeschlossen ist.
Weiterhin könnt ihr eine 12V Zener Diode zwischen den positiven Anschluss des Netzteils und Masse schalten um eine Überspannung abzufangen.

Die Anschlüsse "NET_CHECK" und "BAT_CHECK" dienen zum Überprüfen der Netzteil- bzw. Batteriespannung.
Der Anschluss "PCTRL" dient zum Ansteuern des n-Kanal-Mosfets. Da Mosfets nicht über den Strom sondern über die angelegte Spannung gesteuert werden, müssen wir ihn so wählen das er bei 5V voll durchsteuert. Dies bietet uns der Gewählte IRLZ34N.
Der Kondensator C1 dient zum Abfangen von Spannungseinbrüchen sollte die Spannung vom Netzteil einbrechen (Stromausfall).
Die Rücklaufdiode D5 schützt unseren Spannungsregler sollte die Spannung im 5V Spannungsteil größer werden als im Eingangteil.
Ihr solltet dem L4940V5 und dem IRLZ34N jeweils einen passenden Kühlkörper spendieren. Der Mosfet wird zwar kaum Warm, sicherer ist es jedoch trotzdem, solltet ihr zum Beispiel vorhaben, nicht den Pi, sondern etwas anderes, z.B. über PWM, zu steuern.

Der zweite Teil (Controller Schaltung)

Controller Teil
ACHTUNG!!! PIN 1 und PIN 4 der ISP sind vertauscht. Pin 1 muss natürlich an MISO und Pin 4 an MOSI!!!

Dieser Teil der Schaltung beruht auf der Grundbeschaltung eines Atmel Mega8 wie ihr sie aus dem Tutorial "Raspberry Pi und der Atmel - Teil 1" kennen solltet.

Zusätzlich wurde an den ADC-Eingängen ein Spannungsteiler angebracht welcher uns die Eingangspannungen von Netzteil und Batterie im Verhältniss ~1:2,58 teilt. Aus einer 12V Spannung wird somit eine Spannung von ~4,65V, welche wir Problemlos über den Analog-Digital-Wandler des Atmels messen können. Aus 9V wird natürlich dann verhältnissmäßig weniger.

Über den Taster S2 wird unser Pi dann später geschaltet.
S1 ist wie immer Reset um die ganze Schaltung zu Resetten. Hierbei wird auch die Spannung für den Pi abgeschalten!!! Ihr könnt dies nutzen wenn euer Pi hängen sollte.

Der dritte Teil (Serielle Verbindung)

Serielle Verbindung
Diese Schaltung solltet ihr schon aus dem Tutorial "Raspberry Pi und der Atmel - Teil 2 - Serielle Verbindung" kennen. Deshalb werde ich hier nur Kurz darauf eingehen.

Ich habe die Methode über einen Optokoppler gewählt, da somit gewährleistet ist das der Strom nicht über die Masse an den den GPIO-Pins des Pi abfließt, sondern über den USB Anschluss des Spannungsteils.


Das Controller Programm

Auf jedes Detail einzugehen würde hier den Rahmen sprengen. Solltet ihr interesse daran haben, so könnt ihr gerne mit mir Kontakt aufnehmen.

Zum Wichtigsten sei gesagt das sämtliche Einstellungen die ihr vornehmt in dem im Code gekennzeichnetten Block vorgenommen werden. In den einzellnen Funktionen braucht ihr im Grunde nichts zu ändern.

Das vollständige Programm  für den Atmel könnt ihr euch hier herunterladen:

PiPower.c

 

 

Konfiguration



//Festlegen der Controllerfrequenz und Baudrate

#define F_CPU   4000000UL
#define BAUD    19200UL


Sollte aus den Zwei vorhergehenden Tutorials klar sein.

//Ports festlegen
#define TASTER_1        PD2
#define POWER           PD3




Hier legt ihr den Anschluss des Tasters und des Mosfets fest. Solltet ihr die Beschaltung wie oben gewählt haben braucht ihr hier nichts zu ändern.

//Festlegen der Befehle
#define Pi_on_cmd "on"
#define Pi_off_cmd "off"
#define Bat_check_cmd "check_bat"
#define Net_check_cmd "check_net"
#define Shutdown_cmd "shutdown"

Hier legt ihr die Befehle fest welche ihr über die serielle Verbindung vom Pi zum Atmel senden wollt. Ihr könnt dabei die 5 Verschiedenen Befehle frei wählen, damit ihr sie in euer Programm auf dem Pi übernehmen könnt.
"Shutdown_cmd" ist das Commando welches der Controller an den Pi sendet wenn ihr den Taster S2 drückt.

//Festlegen der ADC Ports
#define Net_port 0
#define Bat_port 1

 Hier legt ihr Fest an welchen Port des Ananlog-Digital-Converters ihr die Spannungsteiler angeschlossen habt.

//Festlegen der Ausschaltverzögerung
#define sd_delay 120 

Hier legt ihr die Zeit in Sekunden fest die ihr dem Pi zum herunterfahren gebt, bevor der Atmel den Pi abschaltet.

 

Grundfunktion

Im Grunde ist das ganze noch rechts simpel aufgebaut.

1. Ihr schaltet den Pi mittels Taster S2 ein

Wärend des laufenden Betriebes könnt ihr die Netz- und die Batteriespannung mit einem Script oder Programm über die Serielle Verbindung abfragen. Ihr sendet dazu einfach die unter "Bat_check_cmd" und "Net_check_cmd" festgelegten Befehle und erhaltet ein "ACK".."\n".."xxxx" "\n" zurück.
Das "ACK" steht dafür das der Controller euren Befehl erkannt hat.
Das "\n" dient als Trennzeichen.
Das "xxxx" ist der Wert des ADC.
Sollte der Controller euren befehl nicht kennen erhaltet ihr ein "NAK" zurück.

 2. Ihr betätigt den Taster S2 wärend der Pi eingeschalten ist.

Der Atmel sendet nun den unter "Shutdown_cmd" festgelegten befehl an den Pi. Euer Script/Programm reagiert darauf indem es den Pi herunterfährt und den unter "Pi_off_cmd" festgelegten Befehl an den Controller sendet. Der Controller wartet daraufhin die unter "sd_delay" festgelegte Zeit ab und schaltet den Pi dann aus.

Das wars auch schon. mehr braucht ihr nicht.

Ein Beispielscript (Python) für den Pi findet ihr hier:

Shutdwonscript
Klasse für das shutdwonscript

Steckt einfach beides in einen Ordner und führt das Shutdownscript aus.

(Es wird Pyserial benötigt)


Erweiterte Funktionen (Anregung)


Ihr könnt euer Script/Programm auf dem Pi auch so schreiben das es alle x Sekunden die Spannung der Batterie und des Netzanschlusses liest. Wird das Netzteil nun abgeschalten, z.B. durch einen Stromausfall, könnt ihr den Pi automatisch herunterfahren lassen. Gleiches gilt auch wenn die Batteriespannung einen gewissen Wert unterschreitet.

Das war es für heute ersteinmal. Ich hoffe ihr konntet meinen Ausführungen folgen. Was noch folgt ist eine kurze Übersicht was ich mit dieser Schaltung noch vor habe.
  • Ausgabe der BatterieSpannung/Netzspannung via LCD
  • Ausgabe der IP-Adresse des Pi via LCD
  • Einige Scripte/Programme für die Schaltung
 

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