der runde würfel

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.

28. April 2011

Netduino ADC

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

Ein normaler PTC Temperatursensor KTY81-110, an einem Netduino.

 

Code:

public
static void Main()
{
AnalogInput a0 = new AnalogInput(Pins.GPIO_PIN_A0);
//Thread.Sleep(300);
while (true)
{
String x = a0.Read().ToString();
//string s = a5.Read().ToString();
Thread.Sleep(300);
Debug.Print(“Value: “ + x);
}
}

23. April 2011

SPS S7 Backup Plan

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

Sollte mein ganzes Konzept für die Haussteuerung und Regelung nicht funktionieren, mit selbstentwickelten Modulen, dann werde ich auf “altmodische” Systeme zurückgreifen. Hierzu hab ich mir schon mal eine PCI Karte besorgt, um mit einer Siemens S7-300 SPS zu kommunizieren. Dann muss ich nur noch ein CPU Modul kaufen und die Module in entsprechender Anzahl für digitale Ein- und Ausgänge, sowie einige analgoge I/O’s.
Wenn dieser Plan dann ebenfalls nicht aufgeht und klappt, dann muss ich wohl auf das GIRA zurückgreifen. Das kostet zwar einen haufen Schotter, aber dafür sollte das auf jeden Fall funktionieren.

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ß.

Ältere Einträge »

powered by wordpress; my content © 2009 - 2016