der runde würfel

31. März 2011

Netduino Kapitel 1, Abschnitt 2

Kategorie: Computer,Haus,Privat — Schlagwörter: , , , , , , , , , , , , — bigfoot @ 23:34

Kapitel 1, Abschnitt 2

Nachdem hoffentlich schönen Erfolgserlebnisses, wollen wir uns nun der dazugehörigen trockenen Theorie widmen. Wems gefällt, kann ja während dessen die blaue Leuchtdiode weiter blinken lassen. Nur nicht verückt machen lassen.

Für den einen oder anderen gehen die Informationen an dieser Stelle nicht tief genug. Ich bin jedoch der Meinung, dass das tiefergehende Wissen im Laufe des Programmierens automatisch kommt, bzw. erwähnt und erklärt werden muss. Wie auch im Abschnitt zuvor, geht es mir erstmal darum, überhaupt ein Ergebnis zu bekommen. Die Erklärung nach dem praktischen Beispiel, erschliesst sich einem viel einfacher, wenn man grob verstanden hat, was passiert ist.

Widmen wir uns nun dem Programm, wie zuvor bereits erfolgreich ausgeführt, Program.cs.

Im ersten Teil werden die entsprechenden Bibilotheken eingebunden (Englisch Librarys), in denen detailierte Informationen stehen, wie der Prozessor die Befehle interpretieren soll. Dann der Prozessor kennt einen Befehl wie “Thread.Sleep(100)” nicht. Diese Bibliotheken verweisen also auf Routinen, die es dem Prozessor ermöglichen, den geschriebenen Quellcode zu verstehen. Hierbei weiss also das Visual Studio, wie es das geschriebene Programm übersetzen soll. Das nennt man dann Compilen.

In diesen beiden Librarys, stehen Grundlagen zu den Ein- und Ausgaben; ebenso wird hier dem Prozessor Informationen gegeben, wie die einzelnen Abläufe sich verhalten sollen. Denn wie in unserem Beispiel, soll das Licht 100ms an sein und die selbe Zeit aus sein. Woher soll also der Prozessor wissen, wie lange 100ms sind? Der Prozessor kann mit den unterschiedlichsten Frequenzen arbeiten. Als Maximum ist für den AT91SAM7X-512 55Mhz angegeben. Doch was bedeutet das?

Wenn Ihr Euch in Eurem Zimmer vor den Lichtschalter stellt und den Lichtschalter 55.000.000 Mal pro Sekunde Ein- und wieder Ausschaltet, wird einem Bewusst, wie kurz die Lebensdauer eines solchen Schalters ist. Er ist vermutlich nach einer tausendstel Sekunde kaputt. Aber zurück zum Ernst der Sache. Wenn das Licht leuchtet, fliesst Strom. Hierbei ist das Leuchten der Deckenlampe, mit der logischen “1″ gleichzusetzen. Das Gegenteil davon, ist “0″, gleichbedeutend mit Licht aus. Im Prozessor passiert nichts anderes, ausser das die Spannung nicht 230V beträgt, sondern Beträgt bis zu 5V. Auf die verschiedenen Spannungen, Betriebsspannung 1.8V-3.3V und den weiteren Spannungen. Hier fallen dann oft Begriffe wie “CMOS” oder “TTL”. Das führt jedoch an dieser Stelle zu weit. Zu diesen Begrifflichkeiten kommen wir später zurück. Der Prozessor kann also erstmal gar nicht Wissen, was Zeit ist, geschweige denn 100ms. Denn man kann den Prozessor ja auch mit 8Mhz laufen lassen. Ausserdem ist der Lichtschalter in dem Prozessor ein Transistor, der tatsächlich 55 Millionen mal pro Sekunde Schalten kann.

using System;
using System.Threading;
In den Microsoft Librarys stehen die erforderlichen Referenzen zum .NET micro Framework. Hierzu kommen wir später, wenn wir aus diesen Librarys etwas brauchen.

using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
Hier stehen nun endlich die Netduinospezifischen Informationen:

using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

Aus diesen Bibliotheken erfährt das Visual Studio, was denn alles so machbar ist und vor allem, wie die Dinge denn beim Namen genannt werden.

Der Namespace beinhaltet den Namen der Applikation, gefolgt von C# bedingten Formaten und Definitionen.

namespace NetduinoApplication5
{
    public class Program
    {
        public static void Main()
        {
Hier ist dann unser eigentliches Programm.
Zuerst wird die Leuchtdiode benannt und nach dem Gleichheitszeichen definiert. In den Klammern befinden sich nun die Netduino spezifischen Definitionen, sowie deren Default Status.

             OutputPort Led = new OutputPort(Pins.ONBOARD_LED, false);

Hier beginnt nun eine Endlosschleife.

             while (true)
              {
                Led.Write(true);
Der Led, wie oben definiert, wird nun der Wert “True” zugewiesen. Die Led geht an.

                Thread.Sleep(100);
Hier ist ein systemspezifischer Wert, wie im ersten “using” Block zugewiesen. 100ms soll nun an dieser Stelle des Programms gewartet werden.

                Led.Write(false);
                Thread.Sleep(100);
              }
Die geschweifte Klammer zu, zeigt an, wieviel Quellcode in der Schleife laufen soll.

        }
    }
}

Aufgabe:
Nun sollte es klar sein, wie man es schafft, das die Led 50ms leuchtet, 30ms aus ist und dann 30ms an und 50ms aus ist.

Und im nächsten Abschnitt, kommen wir zur Lösung der zuvor genannten Aufgabe, sowie zu weiteren Möglichkeiten der Programmierung.

Viel Spaß.

Der Einstieg – Netduino

Kategorie: Computer,Haus,Privat — Schlagwörter: , , , , , , , , , , , — bigfoot @ 00:52

Der Netduino

Vorwort

Diese kleine Anleitung, soll Schritt für Schritt den Weg anhand von nachvollziehbaren Beispielen zeigen, wie man einen Netduino programmiert. Dabei entstehen natürlich viele interessante Projekte, die Anregen sollen, selbstständig weiter zu machen. Ich für meinen Teil, brauche oftmals einen nachvollziehbaren Einstieg, damit ich mich Anhand des lauffähigen Beispiels, immer weiter in die Tiefen der Programmierung hinein arbeiten kann.

Grundlagen

Der Netduino basiert auf einem Atmel AT91SAM7X-512 Mikroprozessor. Dieser verfügt intern über 512 Kb nicht flüchtigen Programmspeicher und ebenfalls intern über 128 Kb Arbeitsspeicher, der nach dem entziehen der Stromversorgung, leer ist.
Der AT91SAM7X-512 ist auch in kleineren Varianten mit 128Kb/32Kb, sowie mit 256Kb/64Kb verfügbar. Es gibt noch eine weitere Modellvariante, die zu unterscheiden einfach ist. In der Typenbezeichnung findet sich vor der Speicherangabe, ein “C”. Das “C” steht nicht wie zu vermuten für die Programmiersprache, sondern viel eher für eine weitere Funktion. Diese Variante hat die Möglichkeit, über eine integrierte Hardwareengine, cryptologische Tätigkeiten auszuführen. Die Hardware lässt die Verschlüsselung nach AES und 3DES zu, ohne die Rechenleistung zu beeinflussen. Ich lasse die verschiedenen Bauformen aus, denn ich gehe davon aus, dass die wenigsten TFBGA Baugruppen zu Hause löten können.

Die Programmierung erfolgt mit dem Microsoft micro Framework .NET. Aktuell (April 2011) ist die Version 4.1 verfügbar und die Version 4.2 ist derzeit per Download in einer Beta Version erhältlich. Hierzu kann kostenfrei im Internet von Microsoft, das Visual Studio 2010 Express heruntergeladen werden. Nach der Installation muss noch das zuvor erwähnte micro Framework Installiert werden und das auf der Seite von Netduino verfügbare SDK. Nachdem nun alles Installiert ist und ein Netduino zur Hand ist, kann nach der Treiber Installation auf dem Computer, der Spass beginnen.

Kapitel 1

Was lässt sich nun mit Boardmitteln denn so anstellen? Wir sehen eine weiße und eine blaue Leuchtdiode, sowie einen Taster neben der blauen LED.
Als Erstes starten wir das Visual Studio 2010 und erstellen ein neues Projekt.


Im linken Fenster des sich geöffneten Fensters, befindet sich nach der korrekten Installation, der Punkt Micro Framework. Nach dem Anwählen, ist nun rechts eine Reihe von Unterkategorien sichtbar. Hier wählt man nun den Netduino aus, der sich via USB am Computer befindet.

Nun ist das Program.cs zu sehen. Hier steht der Quellcode, der nun zu Schreiben ist, um ihn dann in den Netduino zu übertragen.


using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

namespace NetduinoApplication5
{
    public class Program
    {
        public static void Main()
        {
             OutputPort Led = new OutputPort(Pins.ONBOARD_LED, false);
             while (true)
              {
                Led.Write(true);
                Thread.Sleep(100);
                Led.Write(false);
                Thread.Sleep(100);
         }
    }
}

}

Nun im rechten Bereich mit der rechten Maustaste auf den Programmnamen gehen (NetduinoApplication5) und “Eigenschaften” auswählen. Das müsste nun wie folgt aussehen:

Nun unter dem Punkt “.NET Micro Framework” für Transport “USB” auswählen (Normalerweise steht hier “Emulator”), wodurch im Drop Down Menü der Netduino erscheint.

Und Schwupp, mit der Auswahl unter “Debuggen-> Debuggen starten”, alternativ kann man auch <F5> drücken, wird das Programm in den Netduino übertragen. Nach kurzer Zeit sollte die blaue LED im 100ms Takt anfangen zu Blinken.

Nun zum Schluss nochmals der Vergleich des Program.cs:

Herzlichen Glückwunsch, das erste Programm funktioniert. Demnächst folgt der zweite Teil. Ich würde mich über rege Teilnahme freuen.

Viele Grüße und viel Spaß beim Programmieren und Experimentieren.

Video MP4 (1.93 MB): Netduino-Kapitel-1

30. März 2011

Entwicklerkit Part 5

Kategorie: Computer,Haus,Privat — Schlagwörter: , , , , , , , , , , , , — bigfoot @ 21:05

Atmel, ich hatte es ja schon gesagt, ist irgendwie mein Favorit geworden. Anfangs schwärmte ich von den STM32 CPU’s. Aber Mittlerweile ist mir die AVR Familie näher ans Herz gerückt.
Passend dazu kam natürlich auch ein Atmel STK500 ins Haus. Doch oh Schreck, es gibt ja auch TQFP CPU’s. Also noch die passenden Adaptersockel STK501 und STK503 bestellt.
Jetzt bin ich definitiv für fast alles gewappnet, was man sop tun kann.

Und hier die passenden steckbaren Adapter:

Entwicklerkit Part 4

Kategorie: Computer,Haus,Privat — Schlagwörter: , , , , , , , , , — bigfoot @ 02:08

Auch zum STM32 hab ich was da. Denn wie soll ich schliesslich genau herausfinden, mit welcher CPU ich besser zurecht komme? Hier habe ich mir den STM32 Performance Stick von Hitex gekauft. Rechts zu sehen ein JTAG Interface von “NoName”. Funktioniert aber gut.
Vom EtTeam habe ich mir dann noch zwei weitere Boards kommen lassen. Versuch macht klug. So recht warm bin ich mit den Boards nicht geworden. Naja, aml sehen was ich mit dem STM32 Mini V2.0 und den ET-STM32F103 mache. Vergammeln tut das Zeug ja wenigstens nicht.


Hier das Mini Board V2.0 mit einem STM32F103RBT6:

Und hier das ET-STM32F103 ebenfalls mit einem STM32F103RBT6:

29. März 2011

Entwicklerkit Part 3

Kategorie: Computer,Haus,Privat — Schlagwörter: , , , , , , — bigfoot @ 01:31

Von Atmel hab ich ein wenig mehr. Denn dort gibt es praktisch für jeden Zweck, die passende Antwort. Also hab ich mir da mal so ein Development Kit bestellt. Es dreht sich hierbei um ein Board für den AT91SAM7SE. Das Kit ist das AT91SAM7SE-EK.

Ältere Einträge »

powered by wordpress; my content © 2009 - 2016