The Flying Penguin

The Flying Penguin;

C - simple programs

---------------------------------------------------------------------------------

Captain Malgardi

Malgardis Crew

become a fan on Facebook : Malgardi Fan!

Der Computer

"Ein Computer besteht aus Silicium, Stahl und Kabeln."

António Damásio

"A computer consists of silicon, steel and cable."

António Damásio


C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

uController Regenwassernutzungsanlage (Beispielprogramm)

Das Programm

Dem μController wird mit Hilfe eines Programms gesagt was er zu tun hat. Dieses könnte man in verschiedenen Programmiersprachen schreiben.Neben den Schaltern und LEDs habe ich noch den Timer verwendet.

Die Aufgabe

Eine Steuerung von einer Regenwassernutzungsanlage soll realisiert werden.

Das Regenwasser durchläuft einen Grob- und Feinfilter, welcher mit einem Sensor ausgerüstet ist. Sollte Zu viel Dreck im Filter sein, wird der Sensor aktiviert. Dies bewirkt ein Aufleuchten einer bestimmten LED.

Ein Füllstandssensor misst den Tank Inhalt. Dieser Wert wird in Binärform an den μController überwiesen. Sollte der Tank über 84 % gefüllt werden Leuchtet das Überlauf LED auf.

Bei einem Füllstand von weniger als 11 % wird das Frischwasser LED angeschaltet bis der Tank wieder über 16 % Voll ist. Sollte weniger als 6 % Wasser im Tank sein, wird das Wassermangel LED eingeschaltet und es Blinkt eine Warnlampe.

Das Fehlerbit sollte mit einer Frequenz von 5 Hz und einem Impuls/Pausenverhältnis = ¹/₃ Blinken.

Durch einschalten des Betriebsschalters wird die Steuerung aktiviert und die Anzeige Betrieb leuchtet. Die Deaktivierung soll nach Ausschalten des Betriebsschalters unmittelbar erfolgen, alle Ausgänge sind auf Low zurückzusetzen.

 

Festlegung der Hardwarestruktur

Als erstes müssen die Ein- und Ausgänge definiert werden.

 

  

Die Definition der Ein- und Ausgänge erleichtert das spätere erstellen und Prüfen des Programms. Deshalb ist es sinnvoll Variablen Namen zu nehmen welche auch Sinn machen.

 

Analyse

Die meiste Arbeit beim erstellen eines Programms entfällt auf die Analyse des Problems. Um später zu Wissen was oder wie programmiert werden soll, macht man sich am besten vorher Gedanken darüber, was man Programmieren soll und wie. Am einfachsten geht das wenn man ein Struktogramm erstellt.

Programmierung

Nun da alle Vorbereitungen getroffen wurden kann man mit dem Eigentlichen Programmieren Anfangen. Dabei sollte man so Programmieren wie man es im Struktogramm vor gegeben hat.

Sollte das Struktogramm richtig sein, wäre die Grösste Arbeit schon erledigt. Andernfalls käme ein mühsamer Prozess des Debuggens dazu. Zu welchem die Zeit fehlt. Deshalb ist es wichtig sich genügend Zeit fürs Struktogramm zu nehmen.

Kopfzeile und Deklaration der Variabeln

Als erstes muss man die Verschiedensten Variabeln, Ein- und Ausgänge deklarieren. Auch hat ein Kurzer Steckbrief am Anfang des Programms nicht zu fehlen.

/*
                  o   ___          _   _         _   _             .    
       -`^'-      o  <_*_>        '\\-//`       '\\-//`        ,-_-|    
       (o o)      o  (o o)         (o o)         (o o)        ([o o])   
|--ooO--(_)--Ooo--8---(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo- -------|
|Titel:         Regenwassernutzung                                                     |
|File name:        regen.c                                                                  |
|Autor Name:    Jonathan Ernst                                                        |
|Datum:            30.01.2012                                                            |
|Hardware:         ucBrd35 (Mikrocontroller: Analog                                    |
|                   Devices ADuC832, www.analog.com)                                    |
|Software:        Keil (www.keil.com)                                                    |
|Beschreibung:    Regenwassernutzungs System.                                         |
|--------------------------------------------------------------------------------| 
*/
//-------| Deklaration der Variabeln |-------------------------------------------|
#include<ADuC832.h>

unsigned char xdata xswitch _at_ 0xA000;    //Adresse für Schalter bestimmen
unsigned char xdata xled _at_ 0x9000;        //Adresse für LED bestimmen
unsigned char schalter;
#define OnOff (~xswitch&0x01)                    //Schalter ein Maskieren
#define filter (~xswitch&0x02)                    //Schalter temp Maskieren
#define wstand ((~xswitch&0x7C)>>2)                //Schalter frei Maskieren
#define ein (xled|0x01)                    //LED standby Maskieren
#define voll (xled|0x02)                //LED warnung Maskieren
#define fehler (xled|0x04)                    //LED spruhen maskieren
#define leer (xled|0x08)                        //LED pressluft Maskieren
#define frisch (xled|0x10)                        //LED pressluft Maskieren
#define filterLED (xled|0x20)                        //LED pressluft Maskieren
int x=0;

Die Unterprogramme

Die Unterprogramme Schreibt man Normalerweise vor dem Hauptprogramm. Den beim Compilieren wird der Code von oben nach Unten übersetzt, und dadurch muss er das Unterprogramm schon kennen bevor er es ausführen kann.

Dies ist ein Unterprogramm welches eine Verzögerung bewirkt.

//-------| Unterprogramm Verzögerung |------------------------------------------|

void delay (int y)                                     
{
                                    
RCAP2H = 0xBB;                                     //Einstellungen Timer
RCAP2L = 0xBC;                                     //für 100mSek.
TR2 = 1;                                         //Timer Starten
do { 
if (TF2 == 1){                                     //Timer x mal durchführen
    y--;                                             
    }
  } while (y>0);
}

Das Unterprogramm blink, Generiert ein Blinklicht.

//-------| Unterprogramm Blinklicht |------------------------------------------|
                                               
void blink (void)                          
{
    xled = (fehler&0xFB);           // LED ausschalten
    delay(1500);                       // Verzögerung
    xled = fehler;                   // LED Bereit einschalten.
    delay(500);                   // Verzögerung
}

Mit diesem Unterprogramm werden Die Schalterwerte am Schalter sensor verarbeitet.

//-------| Unterprogramm filter |------------------------------------------|

void sensor (void)                    //Unterprogramm sensor
{
if (filter == 2) {                   //überprüft schalter filter, um bei 
    xled = filterLED;  }           //betätigung die LED filter einzuschalten
else{
    xled = (filterLED&0xDF);}       //oder auszuschalten wenn er nicht 
}                                    //betätiggt wurde.           

Das Hauptprogramm

Das Hauptprogramm ist, wie der Name schon sagt, der Hauptteil des Programms. Ohne Hauptprogramm, genannt main, ist ein Programm in C nicht Funktionsfähig.

//-------| Hauptprogramm |----------------------------------------------------|

void main (void)                            
{
xled = 0;                             //Alle LED's auschalten
while (1){                             //Endlosschlaufe
    xled = xled&0x20;                 //LED's ausser filter LED ausschalten                   
     sensor();                         //Aufruf Unterprogramm Sensor
    while (OnOff == 1)  {             //wenn schalter OnOFF eingeschaltet wird
        xled = ein;                      //wird das LED On Off eingeschaltet
        sensor();                     //Aufruf Unterprogramm Sensor
         if (wstand <= 3) {             //wenn wasserstand unter 15 % ist.
              xled= frisch&0xE1;         //werden alle wasserzustands LED's = 0,
             if (wstand <= 2){         //wenn Wasserstand unter 10 % ist.
                 xled=frisch;         //wird das LED frischwasser eingestellt
                if (wstand <=1){     //wenn wasserstand unter 5% ist
                    xled = leer;     //leuchtet zusätzlich Wassermangel LED
                    blink();}         //und die Wahrn LED blinkt
                           }
                            }         
                          
          else {                           //wenn Wasserstand über 85% ist 
          if (wstand >=0x11){xled=voll;} //leuchted Überlauf LED 
          else{xled= frisch&0xE1;}          //ansonsten werden die
             }                               //wasserzustands LED's =0
      }}
    }
//-------| ENDE |-----------------------------------------------------------|

Der Test

Zum Schluss sollte das Programm getestet werden. Hierbei wird sich herausstellen ob die Strukturierung und Programmierung erfolgreich waren.

Dazu wird ein Test Protokoll verwendet. Dabei sollen alle Funktionen nachvollziehend aufgeführt werden. Sollten Fehler auftauchen kann man mögliche Massnahmen zur Fehlerbehebung hier festhalten.

Sollte das Programm Fehlerfrei funktionieren. So hat man die Aufgabe erfolgreich gelöst.

  Zusammenfassung

Kurzgefasst, wurde das Problem in vier Schritte aufgeteilt.

• Festlegung der Hardwarestruktur
• Analyse
• Programmierung
• Test

Die Aufgabe, den Regenwasser Haushalt eines Hauses zu steuern übernimmt nun unser μController. Das ganze wurde mit C geschrieben und hat nicht länger als 3 Stunden gedauert. Vergessen sollte man dennoch nicht dass ein gutes Struktogramm stets der beste und schnellste Weg zur Lösung sind.

C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

C und uController Einführung

Einleitung

µController werden heute in allen möglichen Maschinen und Geräten verwendet.
Zusammen mit der zusätzlichen Hardware, (I/O ports, timer, usw) bildet der Mikrocontroller die Grundlage um kleinere Aufgaben zu lösen, oder um Anwendungen zu Simulieren. Mehrere Beispiele wie man einen Mikrocontroller einsetzen kann finden sie in diesem Blog.

M-Controller & C-Compiler

Die Wikinger würden mit den µControllern ein Keilerei anfangen. Die alten Ägypter würde

n mit ihnen die Welt kontrollieren. Die Helvetier würden sie verkaufen weil sie denken dass niemand so etwas brauchen würde. So Absurd dies klingen mag so stark konnten diese Controller die Welt verändern.

Doch im grossen und ganzen ist das oben genannte gar nicht so weit von der Realität entfernt. Denn mit dem C-Compiler Keil, programmiere ich die µController welche einen kleinen Teil dieser Welt kontrollieren. Und wenn man nicht weiss wie das geht kann man sie für nichts brauchen. 

Keil uVision4

Keil μVision 4 ist ein C-Compiler welchen wir benützen um µController zu Programmieren.

Das Programm ist sehr umfangreich und trotzdem sehr übersichtlich. Der μVision Editor und Debugger sind in einer einzigen Anwendung integriert. Dies ermöglicht eine angenehme Arbeitsweise und ist sehr nützlich beim schreiben von Programmen.

 Mikro Controller

 Bis heute wurden unzählige μController entwickelt. Wir arbeiten im Moment mit zwei verschiedenen Controllern.

Mit dem

• Atmel AT89C51ED2.

und dem

• Analog Devices ADuC832

Atmel AT89C51ED2

 Der Atmel AT89C51ED2 ist ein High-Speed​​- μController welcher bis zu sechs 8-Bit I / O Ports ansteuern kann. Dazu ist ein 16-bit Timer / Counter eingebaut und er hat einen 64kB Flash Speicher. Dazu kommen noch verschiedenste weitere Features.

Atmel AT89C51ED2

 

Analog Devices ADuC832

Der ADuC832 μController ist ein voll integriertes 12-Bit-Datenerfassungssystem in einem Chip. Wie alle Analog Devices μController Produkten hat er präzise Analog/Digital & Digital/Analog-Wandler und einen Flash- μController auf einem kleinen Chip. (ca. 1cm x 1 cm)

Analog Devices ADuC832

 Weitere Infos : 

• http://www.keil.com/uvision/
• http://www.atmel.com/dyn/resources/prod_documents/doc4235.pdf
• http://www.analog.com/static/imported-files/data_sheets/ADUC832.pdf

C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!