der runde würfel

4. September 2011

High-Tech Legierungen

Auch bei den ultraleichten Legierungen aus Aluminium, Magnesium und Titan, gibt es immer neue Mischungen.

AMT hat da beeindruckende Legierungen im Portfolio. Vermutlich sind das aber Materialien, an die man als normalsterblicher gar nicht ran kommt. Aber für den Modellbau oder das Tuning, erschließen sich mit solchen Materialien ganz neue Dimensionen.

Ultraleichte Bauteile die höhere Festigkeiten bereitstellen, als die vergleichbaren “Standardbauteile”.

2. September 2011

Adieu STM32?!

Kategorie: Computer,Privat — Schlagwörter: , , , , , , , , , , , , — bigfoot @ 20:48

Nachdem ich mich in der Vergangenheit immer mehr den FPGA’s und den Atmel’s (Netduino und Co.) gewidmet habe, denke ich, dass ich mich von den STM32 CPU’s trennen werde und die komplette Development Umgebung verkaufen werde.
Es ist einfach zu viel und ich muss da einfach einen Fokus legen. Daher und Tschüß STM32.

3. April 2011

Netduino Kapitel 1 Abschnitt 3

Bevor wir im nächsten Abschnitt zur Lösung für die verschiedenen Taktraten der LED kommen, widmen wir uns nun der A/D Wandler.
Der AT91SAM verfügt über einen 10-Bit Wandler. Was bedeutet das?
10 Bit entspricht 2^10 oder 1024. Also kann der Wandler eine bestimmte differenz, in 1024 Schritte unterteilen. Wenn wir also von einer Spannung von 0-3.3V ausgehen, sind es überschlagen also alle 3mV 1 Schritt. Wenn wir ein Potentiometer anschliessen, welches zwischen 0 Ohm, also Durchgang, und ~ Ohm, also offen, regelt, entspräche 0 Ohm 1023 und offen, 0. Also würden 1.65V einen Wert von 512 entsprechen, +- 1.5mV. Also recht genau.

Wenn man nun von ARef, das steht für Analoge Referenz Spannung, einen Draht nach Analog In 0 stecken würde, würde die Software einen Wert von 1023 ausgeben. Nun stellt sich einigen bestimmt die Frage, wieso 1023 und nicht 1024?!? Ganz einfach, man muss die “0″ mitzählen, denn 0V ist der erste Wert und der wiederum entspricht 0. Wenn nun also von 0 ausgehend bis 1024 gezählt wird, kommen wir bis 1023. 1024 ist bereits der erste Wert im 11 Bit Segment, welches bis 2047 geht.

Wie sich diese Werte ergeben, ist ganz einfach:
1 Bit steht für 0 oder 1, also 2 Werte
2 Bit steht für 00, 01,10,11, also 4 Werte
3 Bit stehen für 000, 001, 010, 011, 100, 101, 110 und 111, also schon 8 Werte

Dem aufmerksamen Leser fällt auf, das es sich bei der Aufzählung um Zweierpotenzen handelt. Also 2^0 = 1 da dieses aber ein Sonderfall ist, kommt dieser in der Entwicklung nicht zum Tragen.
2^1 = 2; 2²= 4, 2³ = 8, 2^4 = 16, 2^5 = 32, 2^6 = 64, 2^7 = 128, 2^8 = 256, 2^9 = 512, 2^10 = 1024, 2^11 = 2048, 2^12 = 4096 und so weiter und so fort.

Im Normalfall werden in der Praxis 12 oder 14 Bit A/D Wandler eingesetzt. Sonderfälle gibt es aber auch hier, denn bestimmte Applikationen tasten das Signal mit 24 Bit ab. Diese Einkanal A/D Wandler, sind jedoch sauteuer und werden auch nur seltenst benötigt

Zurück zu unserem Eingang Analog 0. Wenn wir nun das Kabel von Aref herausziehen und es in GND stecken, kommt der Wert 0 an. Sollten nun jedoch Spannungen erfasst werden, die die 3.3 V überschreiten, so muss mit einem Spannungsteiler gearbeitet werden. Das ist ein zweiter Widerstand, über dem ein Großteil der Spannung “verbraten” wird, so daß an unserem Poti nur noch die Resteverwertung erfolgt. Hierzu sind jedoch einige Berechnungen erforderlich. Als Stichwort für den kommenden Teil sei gesagt, URI; Nicht die RegEx (Regular Expression) sondern U steht für Spannung, R für Wiederstand und I für den Strom. U = R x I oder R = U/I oder I = U/R.

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

Ältere Einträge »

powered by wordpress; my content © 2009 - 2016