// Unser erstes Programm

/*Einbinden einer Headerdatei*/
#include <xc.h>

/*Beginn der main-Routine*/
void main (void)
{
   /*Aufruf eines Unterprogramms*/
   LED_Blinken();
}  /*Ende der Funktion*/

// Unser erstes Programm

/*So könnt Ihr
ruhig in mehreren Zeilen schreiben*/

#include <xc.h>

#include <xc.h>

#define LED_EIN LATAbits.LATA0=1;
#define LED_AUS LATAbits.LATA0=0;
...
LED_EIN /*Anwendung des Makros*/
...
LED_AUS
...

#define DEBUG 1
#define LEDEIN LATBbits.LATB3=1;
...

if(TEMPOVER)
{
   #if DEBUG
      LEDEIN
   #endif
   ...
}

void main(void)

void main(void)
{
   /* Hier können sämtliche Initialisierungen 
      durchgeführt werden (PIC, Display, usw.) */

   while(1)
   {
      /* Hier kommt der Algorithmus/ die Algorithmen hinein,
         jedoch keine Initialisierungen! */
   }
}

#include <p18cxxx.h>

void main (void) {LED_Blinken(); }

Das ist schlicht und einfach unübersichtlich. Es mag bei diesem Beispiel noch nicht so dramatisch sein, doch wenn das Programm umfangreicher wird, dann verliert man sehr schnell den Überblick. Rein programmtechnisch würde die Schreibweise aber so auch arbeiten. Es ist aber einfach nicht Zweckdienlich. Und außerdem wird Euch jeder Mensch dieser Erde bei einer solchen Programmierung seine Hilfe verweigern, mit Sicherheit! Daher gewöhnen wir uns ein paar Schreibregeln an. Wir schreiben Grundsätzlich nur einen Befehl pro Zeile gefolgt von einem Kommentar. Und wenn eine Funktion eingeleitet wird, dann wird der Code zwischen den geschweiften Klammern eingerückt geschrieben, so erkennt man sofort wo eine Funktion beginnt, wo sie endet und welche Abschnitte zu ihr gehören. Was wir uns nicht aussuchen können ist, dass eine Anweisung immer mit einem Semikolon “;” beendet werden muss. Ein PIC kann nicht mehrere Operationen gleichzeitig ausführen, sondern arbeitet eine Operation nach der anderen sequenziell ab. Das ist nicht weiter schlimm, weil er dies einerseits sehr schnell macht und anderseits kann er durch Interrupts an eine andere Programmstelle springen, dort etwas abarbeiten und anschließend mit der ursprünglichen Arbeit fortfahren.

Variablen

Um überhaupt mit dem Arbeitsspeicher des PIC zu arbeiten brauchen wir Variablen in die wir Daten schreiben und bei Bedarf wieder auslesen können. Bei Variablen unterscheidet man in C zwischen verschiedenen Typen. Grundsätzlich gilt aber, dass man mit dem Speicherplatz sparsam umgehen soll. Braucht man z.B. nur eine Speicherzelle, die eine maximale Speicherkapazität von 256 haben muss, macht es keinen Sinn eine Variable mit dem Fassungsvermögen von 65536 zu verwenden! Bitte denkt daran, die Speicherkapazität in einem Mikrocontroller ist begrenzt. Anders als in einem gängigen PC verfügt ein Mikrocontroller nicht über GByte an Speicher. Wir befinden uns eher im Bereich von KByte.

Folgend die verschiedenen Typen aufgeführt:

Ich würde Euch empfehlen die Headerdatei stdint zu verwenden.

#include <stdint.h>

Nach der Einbindung könnt Ihr dann Standard-Integer verwenden. Das hat de Vorteil, das diese Typen immer gleich sind. Egal ob Ihr nun auf dem PIC oder auf einem x86 Prozessor programmiert. Es ist sofort ersichtlich um was für einen Typ es sich handelt. Oft verwendet werden folgende:

uint8_t a;    // 8 Bit, vorzeichenlos
uint16_t b;   // 16 Bit, vorzeichenlos

Variablen Deklaration

Jetzt haben wir schon die verschiedenen Variablen Typen kennen gelernt aber wie wendet man diese an? Bei der “Variablen Deklaration” wird der Variablen Typ, der Name und eventuell ein Anfangswert festgelegt. Schauen wir uns das einmal anhand eines Beispiels an:

Typ Variablenname = Anfangswert;

Folglich schreibt man:

unsigned char speicher = 0;

Programmierstil: Variablen beginnen immer mit Kleinbuchstaben!

Somit hätten wir eine Variable des Typ unsigned char mit dem Namen speicher deklariert. In diese Variable können wir nun Daten speichern. Um eine Variable zu beschreiben schreiben wir folgendes:

speicher = 100;                    //oder..
speicher = 100+100;                //oder..
speicher = speicher2 + speicher3;

Es lassen sich Variablen natürlich auch über Operationen beschreiben wie in dem Beispiel oben, dabei spielt es keine Rolle ob die Operation mit Zahlen oder anderen Variablen durchgeführt wird. Man muss natürich darauf aufpassen, dass man immer die entsprechenden Variablen-Typen benutzt. Denn eine Addition von 200+200 ergäbe 400 und wäre somit nicht geeignet für eine unsigned char. Es gäbe keinen Fehler beim Kompilieren jedoch erzeugt die Addition in diesem Fall einen Überlauf was zu schwerwiegenden Problemen führen kann. Interessanter Beitrag hierzu im Focus 

Weitere Beispiele:

speicher1 = 100;
speicher2 = 50;
speicher3 = speicher1/speicher2;
speicher4 = 2*speicher3;
//Der Inhalt von speicher4 ist 4

Speicherklassen

Es sind in C noch diverse Speicherklassen vorhanden mit denen zum Beispiel Variablen versehen werden können. Wozu das nützlich sein kann möchte ich Euch in den nächsten Abschnitten zeigen.

extern

Mit dem Keyword extern könnt Ihr Variablen in anderen Modulen bekannt machen (unter Anwendung von Headerdateien). Ein Beispiel: In der Datei main.c gibt es eine globale* Variable:

* überall gültig, sofern bekannt

unsigned char versionUID;

Die kann nun innerhalb einer Headerdatei, die in einer weiteren C-Datei eingebunden wird bekannt gemacht werden:

extern unsigned char versionUID;

Somit ist die globale Variable nicht nur in der C-Datei verwendbar, in der sie deklariert wurde, sondern auch in der C-Datei die die Headerdatei mit der extern Anweisung einbindet.

volatile

Durch das voranstellen von volatile an eine Variable, kann dem Compiler mitgeteilt werden, dass ein Zugriff von außerhalb auf dieses Element möglich sein soll. Ein Zugriff kann zum Beispiel durch eine ISR (Interrupt service routine) erfolgen. Der Compiler wird an dieser Variable keine Optimierung vornehmen.

volatile int count;

const

Durch const wird eine Variable zu einer Konstanten. Der Wert der Variable ist danach nicht mehr veränderbar!

Übrigens speichert der Compiler diese Daten im Flash und nicht im RAM! Der RAM dient, wie auf dem normalen PC zum Arbeiten. Daher der Name Arbeitsspeicher. Da eine Konstante nicht verändert werden kann wird sie im Flash Speicher abgelegt. So wird der wenige RAM Speicher nicht belastet.

Arrays können nur zu einer begrenzten Größe im RAM des PIC gespeichert werden. Der RAM ist in diverse Bereiche unterteilt. Wenn das Array die Größe eines solchen Bereiches überschreitet, so gibt der Compiler eine Fehlermeldung.

So deklariert Ihr eine Konstante:

const int freq_Hz = 32768;

static

Wird eine Variable mit dem Keyword static ausgestattet, so wird diese Variable global. Jedoch nur in dem Modul indem es initialisiert wurde: Ist eine Variable in einer Funktion als static gekennzeichnet, so wird es diese Variable unverändert bei erneuten Aufruf dieser Funktion geben.

static int x;

Funktionen

Jetzt kommen wir zu den Funktionen. Ihr werdet sie beim Programmieren immer wieder benötigen. Sie sind uns eine große Hilfe beim Strukturieren des Programms bzw. dessen Ablaufs. Schauen wir uns zunächst einmal wieder ein Beispiel an:

void Funktion_A(void)
{
  LATAbits.LATA5 = 1;
}

void Funktion_B(void)
{
  LATAbits.LATA5 = 0;
}

int main(void)
{
  Funktion_A();
  Funktion_B();
  Funktion_A();
  Funktion_B();
}

Was wir ja bereits wissen ist, dass ein PIC immer bei der Funktion main beginnt. Nun schauen wir uns an was dort als erstes auf den PIC wartet. In der Zeile 13 wartet die erste Anweisung auf den PIC, welche ihm mitteilt, dass er die Funktion Funktion_A aufrufen soll. Also wird er in die Funktion springen und landet dann bei dieser Anweisung:

LATAbits.LATA5 = 1;

Dies ist ein neuer Befehl, welchen ich hier nur ganz kurz ansprechen möchte (wird später noch genauer erklärt). Durch diesen Befehl wird das Bit 5 des PORTA auf High gesetzt. Wir nehmen an, dass dort evtl. einer Treiberschaltung (Transistor als Schalter) mit einer LED sitzt. Also würde die LED in der Funktion_A eingeschaltet werden. Nachdem der PIC die Funktion_A komplett abgearbeitet hat (in diesem Fall lediglich eine Anweisung) kehrt er dorthin zurück von wo aus er die Funktion aufgerufen hat und geht einen Schritt vorwärts. Also würde er nun Zeile 14 aufrufen, was zur Folge hätte, dass die LED ausgeschaltet wird. Und so weiter… Und so fort… Fazit: Die LED würde also blinken? Jein, denn die LED würde so schnell blinken, dass wir es gar nicht wahrnehmen würden, denn der PIC arbeitet so schnell, dass unser Auge das Schalten nicht wahrnehmen kann. Aber ohnehin ist das Programm sinnlos, es dient ja nur dem Zweck, dass wir es als Lehrbeispiel verwenden können.

Ein weiteres Beispiel:

int main(void)
{
  Funktion_A();
  Funktion_B();
  Funktion_A();
  Funktion_B();
}

void Funktion_A(void)
{
  LATAbits.LATA5 = 1;
}
void Funktion_B(void)
{
  LATAbits.LATA5 = 0;
}

Nun schauen Sie sich das Programm einmal genau an, dann werden Sie feststellen, dass sich eigentlich zum vorherigen Beispiel nicht viel verändert hat. Es steht jetzt lediglich die main Funktion über den anderen Funktionen. Also das selbe oder? Falsch! Dieses Beispiel würde so nicht funktionieren und der Compiler würde eine Fehlermeldung ausgeben, welche ungefähr heißen würde: “Unbekannte Funktion: Funktion_A“. Das liegt daran, dass eine Funktion immer vor der main Funktion stehen muss oder die Funktion, wenn sie unter der main Funktion steht einmalig angemeldet (Prototypen schreiben) werden muss. Folgendes Beispiel würde wieder funktionieren:

void Funktion_A(void);
void Funktion_B(void);

int main(void)
{
  Funktion_A();
  Funktion_B();
  Funktion_A();
  Funktion_B();
}

void Funktion_A(void)
{
  LATAbits.LATA5 = 1;
}

void Funktion_B(void)
{
  LATAbits.LATA5 = 0;
}

Dieses Programm würde funktionieren, da wir die Funktionen vor main angemeldet haben. Dies geschieht einfach indem man die Funktionsköpfe einmal aufführt. Man nennt das auch Prototypen.

Übergabeparameter

Als nächstes geht es um die “void”, die wir bisher nicht angesprochen haben. Funktionen haben in C noch einen kleinen aber feinen Vorteil, denn man kann ihnen Parameter übergeben. Das bedeutet, dass wenn man eine Funktion aufruft ihr einen Wert mitgeben kann und wenn die Funktion zu Ende ist, kann somit ein Wert zurück gegeben werden. Sehen wir uns dazu mal ein Beispiel an:

void Funktion_A(void);
void Funktion_B(void);

int main(void)
{
  Funktion_A(5);
}

void Funktion_A(unsigned char A)
{
  if (A==5)
  {
    LATAbits.LATA5 = 1;
  }
  else
  {
    LATAbits.LATA5 = 0;
  }
}

Hier würde der PIC in der Zeile 6 die Funktion Funktion_A aufrufen und würde den Wert “5” mit übergeben. Da nun in der Funktion_A der Übergabeparameter als “unsigned char A” deklariert wurden ist, steht die “5” nun in “A” (“A” ist nun auch eine normale Variable und kann innerhalb der Funktion als solche genutzt werden). Jetzt wird die Funktion Funktion_A abgearbeitet und beginnt also in der Zeile 11, wo etwas steht, was wir noch nicht kennen (Erklärung folgt) aber uns evtl. erschließen können. Es steht “if(Wenn) (A==5)”, dass bedeutet, wenn die Speicherzelle oder Variable “A” den Wert “5” beinhaltet, dann führe aus, was in den folgenden geschweiften Klammern {} steht… else(Ansonsten), wenn nicht (oder Ansonsten) führe aus was in den Nachfolgenden geschweiften Klammern {} steht. Da “A” ja nun den Wert “5” tatsächlich beinhaltet würde die LED bei diesem Programm immer eingeschaltet sein. Würde die Variable “A” einen von “5” unterschiedlichen Wert annehmen (im Beispielprogramm nicht möglich), würde die else Routine durchlaufen werden und die LED wäre aus. Das (A==5) ist eine so genannte Bedingung, wenn diese Bedingung wahr ist, wird die if-Routine ausgeführt.

Merke: 5 == 5 ist eine wahre Bedingung, während 5 == 4 eine falsche Bedingung ist. Und ganz wichtig: Nicht “==” mit “=” verwechseln! 

Rückgabeparameter

Nun kann man natürlich nicht nur einen Wert übergeben, sondern kann auch Werte zurückgeben. Das sind dann die so genannten Rückgabeparameter und sind im Prinzip nichts groß anderes. Schauen wir uns hierzu doch wieder ein Beispiel an:

void Funktion_A(void);
void Funktion_B(void);

unsigned char c;

int main(void)
{
  c = Funktion_A(13,17);
}

unsigned char Funktion_A(unsigned char A, unsigned char B)
{
  return(A+B)
}

Dieses Programm würde der Variable c den Summand der Zahlen 13 und 17 zuweisen (30). Dies würde folgendermaßen ablaufen: Das Programm will der Variable c einen Wert zuweisen, findet dann jedoch einen Aufruf zu einer Funktion vor. In dieser Funktion werden nun die ihr übergebenden Werte (13 und 17) in die Variablen (A und B) geschrieben. Anschließend wird die Funktion durch den Befehl return wieder verlassen mit dem Rückgabewert (A+B). Also wird die “30” zurück gegeben (Die “30” steht nun in de Variablen c!

Vielleicht stellt Ihr euch gerade die Frage was man machen kann, wenn man mal mehr als einen Rückgabewert benötigt. Dafür müssen wir uns erst mit Zeigern beschäftigen. Also noch etwas Geduld.

Mathematische Operationen

Wir haben ja im Laufe dieses Tutorials bereits Variablen kennen gelernt und im Umgang mit Mikrocontrollern dreht sich im Endeffekt ja alles um Zahlen, daher bietet uns die Sprache C eine Reihe an Rechenoperationen an, die wir benutzen können um einen Ausdruck zu bilden. Ein Ausdruck ist eine Operanden (also den Zahlen) und Operatoren (Rechenzeichen: Plus Minus, …). Es stehen folgende Operationen zur Verfügung:

Arithmetische Operationen

Symbol          Beschreibung 
+               Addition 
-               Subtraktion 
*               Multiplikation 
/               Division 
%               Modulo

Bis auf die Rechenart “Modulo” sollten eigentlich alle anderen Arten klar sein. Die Rechenoperation Modulo teilt eine Zahl durch eine andere Zahl und gibt des Rest aus. Hier ein Beispiel:

A = 11%5  11/5=2 (Rest=1) 
A würde den Wert "1" annehmen

B = 5%3  5/3=1 (Rest=2) 
B würde den Wert "2" annehmen

Logische Operationen

Symbol         Funktion 
&&             UND 
||             ODER 
!              NICHT

Diese Operationen beziehen sich auf die ganze Variable! Nicht Bitweise!

// Beispiele für logische Operationen
A = 10; B = 20; C = 0;
if( (A == 10) && (B < 20) || (C < 5) )
{
/* Wird ausgeführt wenn A den Wert
10 hat UND B kleiner als 20 ist
ODER wenn C kleiner als 5 ist */
}

Relationale Operationen

Ich denke zu den folgenden Operationen brauche ich nicht viel zu sagen. Wobei eine Sache vielleicht erwähnt werden sollte:

Vergleiche zwischen Operanden sollten immer nur dann durchgeführt werden, wenn die Operanden vom selben Typ sind. Vor allem aber nicht signed und unsigned vergleichen. Das kann ähnlich wie das Überlaufen von Variablen zu Problemen führen!

Symbol         Beschreibung 
>              größer 
>=             größer oder gleich 
<              kleiner 
<=             kleiner oder gleich 
==             gleich 
!=             ungleich

 Bitweise Logische Funktionen

Symbol         Operation 
&              bitweises UND 
|              bitweises ODER 
^              bitweises Exklusiv-ODER 
~              Einerkomplement 
>>             bitweises Verschieben nach rechts 
<<             bitweises Verschieben nach link

Hinweis: Die Verschiebeoperationen >> und << sind das selbe wie eine Division bzw. eine Multiplikation mit 2.

Diese Operationen beziehen sich auf jedes einzelne Bit einer Variable! Und so arbeiten sie:

A='10101010' , B='01010101' --> A&B='00000000'
A='10101010' , B='10101010' --> A&B='10101010'

Inkrement / Dekrement

Selbstverständlich sind auch die gängigen Operationen wie das Inkrementieren (+1) oder Dekrementieren (-1) einer Variablen möglich. Man unterscheidet verschiedene Schreibweisen:

A = A+1; A++; ++A;
// A wird bei allen Anweisungen um 1 erhöht
B = B-1; B--; --B;
// B wird bei allen um 1 vermindert

Verarbeitungsreihenfolge

Eine ganz wichtige Regel bei der Verwendung von Operationen ist zu wissen in welcher Reihenfolge diese ausgeführt werden, wenn denn mehrere in einer Zeile/Anweisung stehen. Hier eine Übersicht:

Bei den Operatoren +, -, * und & im Rang 2 handelt es sich um die unären Varianten (positives und negatives Vorzeichen, Verweis- und Adressoperator).

Bitmanipulation

Oftmals ist es notwendig in einem Byte nur ein einzelnes Bit zu verändern. Stellt Euch zum Beispiel vor, dass Ihr in euremProgramm viele Flags habt, die das auftreten eines wichtigen Ereignisses wieder spiegeln. Dann ist es auf dem PC vielleicht “in Ordnung” dafür 8 einzelne Variablen zu definieren doch auf dem Mikrocontroller müssen wir Speicher bewusst arbeiten. Also versuchen wir das effizienter zu lösen. Wir benötigen für 8 Flags nicht 8 Variablen sondern lediglich 1 Variable des Typs char (auch wenn wir keine Buchstaben hier hinein speichern). Dies ist möglich indem wir jedes Bit des Bytes (eine char Variable = 8 Bit = 1 Byte) als einzelnes Flag betrachten. Zum Beispiel ist das Bit 0 für das Auftreten eines Alarms und Bit 1 für eine Schwellwerterkennung …

Wir schaffen uns also eine Variable vom Typ char und initialisieren sie mit null:

unsigned char flags = 0;

Das auftreten eines Alarms (zum Beispiel wenn Bit 0 == 1), können wir nun wie folgt prüfen:

if(flags&0x01) //Wenn Bit 0 eine 1 ist, dann..
{
   // ...
}

Diese if-Anweisung wird nur durchlaufen, wenn das Bit 0 der Variable flags eine 1 ist (siehe Logische Operationen). Die 1 an dieser Stelle muss natürlich auch irgendwie entstehen und zwar ohne die anderen Bits dabei zu verändern und das macht man so:

// Bit 0 setzen, alle anderen nicht ändern
flags = flags | 0x01;
// Verkürzte Schreibweise
flags |= 0x01;

In analogie dazu können wir folgendermaßen ein bestimmtes Bit löschen (hier Bit 0):

// Bit 0 löschen, alle anderen nicht ändern
flags=flags & 0xFE;
// Verkürzte Schreibweise(n)
flags &= 0xFE;
flags &= ~0x01;

Vektoren / Arrays und Strings

Vektoren / Arrays

Wir erinnern uns, dass wir Variablen deklarieren können und in diesen genau einen Wert speichern können. Doch was macht man, wenn man mal mehrere Werte automatisiert speichern will? Dafür benutzen wir sogenannte Vektoren oder mehrdimensional Arrays. Ein Vektor besteht aus einer bestimmten Anzahl von Variablen mit dem selben Typ. Sehen wir uns einmal an wie ein Vektor deklariert werden kann.

Das Muster sieht so aus:

Typ vektorname [Anzahl] = {1, 10, 4, ...};

Int vektor[5] = {0, 3, 4, 9, 10};

Das direkte Zuweisen von Werten ist nur optional!

Somit hätten wir unseren ersten Vektor erstellt. Dieses besteht nun aus fünf Integer Variablen (0-4) mit dem Namen Vektor. Beschreiben können wir den Vektor wie folgt:

vektor[0] = 50;
//Somit steht eine "50" in der ersten Variable
vektor[1] = 50+50;
//Somit steht eine "100" in der zweiten Variable

Ihr seht schon man kann mit dieser Schreibweise Platz sparen, doch bis hier hin würde das auch nicht viel bringen, doch wenn wir uns den nächsten Schritt anschauen, werden wir schnell den Vorteil eines Vektors erkennen:

unsigned char i;
int vektor[5];

for (i=0;i<5;i++)
{
  vektor[i]=5*i;
}

In diesem Beispielprogramm wird in der Zeile 1 erst einmal eine Variable mit dem Namen i deklariert. Gefolgt von einer Deklaration für einen Vektor Namens vektor mit 5 Speicherplätzen*. Dann kommt in der Zeile 4 etwas, das wir bisher noch nicht kennen. Das soll uns aber erst einmal nicht weiter stören (wird später erklärt). Man spricht von einer for-Schleife, diese wird solange wiederholt, bis der Ausdruck i<5 (hier) nicht mehr wahr ist! Durch die Initialisierungsanweisung i=0 wird die Variable i zu Beginn auf 0 gesetzt. Die Schleifenanweisung i++ wird nach jeder durchlaufenden Schleife ausgeführt. Wir errinern uns, dass i++; gleich der Erhöhung von i um 1 ist. Somit wird also die Variable von i hoch gezählt. Also würde diese Schleife genau 5 mal durchlaufen werden. Die for-Schleife wird wie erwähnt noch einmal näher erklärt. Wir gehen also davon aus, dass i seinen Wert nach jeder Schleife um 1 erhöht. So würde sich folgender Inhalt in dem Vektor ergeben:

* Wir zählen die “0” immer mit, daher hat ein Vektor mit [5] auch 5 Speicherplätze ( 0-4 ).

Durchgang 0 --> vektor[0] Inhalt: 0
Durchgang 1 --> vektor[1] Inhalt: 5
Durchgang 2 --> vektor[2] Inhalt: 10
Durchgang 3 --> vektor[3] Inhalt: 15
Durchgang 4 --> vektor[4] Inhalt: 20

Und genau dadurch lassen sich später Datenbanken leichter und vor allem mit weniger Schreibarbeit erstellen, als wenn wir jeder Variablen einen Wert einzeln zuordnen müssen und somit auch für jede Variable eine eigene Rechnung haben müssten. Ein Vektor wird zwar ähnlich wie eine Variable deklariert muss aber immer mit einem Index angesprochen werden. Wir haben diesen Index bereits verwendet. In unserem Beispiel war es die Variable “i”. Folglich gilt:

vektor_A = vektor_B;
//Diese Operation kann nicht funktionieren!
for (i=0; i<5; i++) {vektor_A[i] = vektor_B[i];}  //So würde es funktionieren!

Mehrdimensionale Vektoren bzw. Arrays

Bisher haben wir nur über die eindimensionalen Vektoren gesprochen es gibt aber auch noch mehrdimensionale Vektoren. Diese bezeichnet man dann als Arrays. Sie können sich mehrdimensionale Arrays wie eine Tabelle vorstellen.

unsigned char Array_A[5];
//Eindimensional = 5 Zeilen
unsigned char Array_A[5][5];
//Zweidimensional = 5 Zeilen und 5 Spalte

Man kann Arrays auch direkt bei der Deklaration Werte zu weisen. Dies würde wie folgt aussehen:

unsigned char Array_ED [5] = {0,1,2,3,4};
unsigned char Array_MD [4][4] = {0,1,...,14,15};

Strings

Strings sind im Grunde genommen nichts neues. Es sind Vektoren, welche aus dem Typ char gebildet werden und werden dafür benutzt Text zu speichern. Wenn wir einen String deklarieren…

char text[10];

…können in diesem String (nur) 9 Zeichen stehen, nicht 10! Denn es muss immer Platz für das Abschluss-Zeichen die 0 sein. Der Text könnte ja auch bloß 5 Zeichen lang sein und wie sollte der PIC dann wissen wo Schluss ist? Somit wird immer eine abschließende 0 angehängt um das Ende des Textes zu markieren.

Bedingungen

Bedingungen sind sehr wichtig für die Programmsteuerung. Mit ihnen entsteht eigentlich erst ein logischer Zusammenhang. Wir können mit den if/else Bedingungen sehr genaue Steuerung erarbeiten. Wir können mit den Bedingungen Werte überprüfen und in Abhängigkeit Operationen durchführen, Texte ausgeben oder es ggf. nicht machen. Schauen wir uns einmal ein Beispiel an:

int Batterie_Volt;
Batterie_Volt = 500;

if (Batterie_Volt < 1000)
{
  LCD_Write_String("Warnung Akku");
}

Bei dieser if Bedingung würd in Zeile 5 geprüft werden ob der Wert in der Variable Batterie_Volt kleiner ist als “1000”. Wenn diese Aussage wahr ist, also Batterie_Volt kleiner ist als 1000, würde der if Anweisungsblock {} ausgeführt werden. Nun ist dieses Beispiel sinnlos, da wir die Variable Batterie_Volt ja oben immer mit “500” beschreiben. Es würde also immer die if-Funktion ausgeführt werden. (Es ist ja nur ein Beispiel!) Angenommen die Variable nimmt nun einen Wert an, der größer ist als “1000”, dann würde die Warnung nicht gelöscht werden und die if-Funktion würde nicht mehr ausgeführt. Also müssen wir das Programm bearbeiten:

int Batterie_Volt;
Batterie_Volt = 500;

if (Batterie_Volt<1000)
{
  LCD_Write_String("Warnung Batt");
}
else
{
  LCD_Write_String("Batt OK");
}

Nun würde, wenn sich der Wert von Batterie_Volt ändert und größer 1000 wird, die else-Funktion einschalten und durcharbeitet werden. Dadurch hätten wir eine zweiseitige Bedingung. Nur mit der if Abfrage allein, wäre es eine einseitige Abfrage. Wir wissen, dass die Variable Batterie_Volt in diesem Programm immer den Wert “500” behalten wird, es dient ja nur um die Funktionen if, else zu verstehen. Später in richtigen Programmen könnte die Variable zum Beispiel mit dem gemessenen Analogwert (umgewandelt in digital durch den Analog-Digital-Umsetzter des PIC) gefüllt werden und somit wäre das Programm eine Art Batterie-Wächter.

Eine if-Bedingung hat also immer mindestens folgende Ausführung: (einseitig)

if (Ausdruck)
{
   // Anweisungen
}

Eine if-Bedingung kann folgende Ausführung haben (zweiseitig):

if ( X )
{
   // Anweisungen Y
}
else
{
   // Anweisungen Z
}

Vereinfacht gesagt: Wenn X, dann Y ansonsten Z

Folgende Ausdrücke können für die Bedingung benutzt werden:

x == y   logischer Vergleich auf Gleichheit 
x != y   ... Vergleich auf Ungleichheit 
x <  y   ... Vergleich auf "kleiner" 
x <= y   ... Vergleich auf "kleiner oder gleich" 
x >  y   ... Vergleich auf "größer"  
x >= y   ... Vergleich auf "größer oder gleich"

Es können natürlich auch mehrere Bedingungen verknüpfen werden

x && y   wahr, wenn x wahr und y wahr sind 
x || y   wahr, wenn x wahr und/oder y wahr 
!x       wahr, wenn x nicht wahr ist

Ich denke die einzelnen Vergleichsoperatoren dürften klar sein. Für die Bedingungs-Verknüpfung möchte ich hier nochmal ein Beispiel zeiegn, damit das Prinzip klar wird:

if ( (A < B) && (A > 80) || (A == 11) )
{
  // Anweisungen
}

Diese if-Funktion würde nur ausgeführt werden, wenn A kleiner ist als B und A größer ist als 80 oder A gleich 11 ist. So lassen sich mehrere Bedingungen in einer zusammenfassen.

Switch Case

Es wird Euch öfter mal passieren, dass Variablen auf viele verschiedene Zahlenwerte überprüft werden müssen. Nun könnt Ihr das natürlich mit diversen if-Funktionen erledigen, wesentlich eleganter geht dies allerdings mit der Switch-Case-Funktion. Sehen wir uns auch dazu ein Beispiel an:

void Read_ADC(unsigned char channel)
{
  switch(channel)
    {
    case 0:
      ADCON0bits.CHS0=0;
      ADCON0bits.CHS1=0;
      ADCON0bits.CHS2=0;
      ADCON0bits.CHS3=0;
      break;
    case 1:
      ADCON0bits.CHS0=1;
      ADCON0bits.CHS1=0;
      ADCON0bits.CHS2=0;
      ADCON0bits.CHS3=0;
      break;
    case 2:
      ADCON0bits.CHS0=0;
      ADCON0bits.CHS1=1;
      ADCON0bits.CHS2=0;
      ADCON0bits.CHS3=0;
      break;
    default:
      break;
    }
}

Stellt Euch vor, der PIC bewegt sich in main Funktion und bekommt nun die Anweisung in die Funktion Read_ADC zu springen. Bei dieser Anweisung würde der PIC einen Übergabeparameter mitgeben. Wir gehen davon aus, dass der Übergabewert eine “1” ist. Beim erreichen der Funktion wird diese “1” zunächst einmal in die Variable channel geschrieben. Jetzt startet der Anweisungsblock wo direkt die Switch-Case Anweisung wartet. Hier steht nun switch(channel), dass heißt, der PIC würde nun (1 in channel) zu dem Case “1” springen und da arbeiten. Wichtig ist an dieser Stelle auch das break; Denn wenn diese Anweisung am Ende einer case Anweisung nicht stehen würde, dann würden alle anderen Case Anweisungen da drunter auch noch abgearbeitet werden (es sei denn das ist gewollt). Das break kann bei der letzten Case-Anweisung natürlich entfallen, denn da drunter kommt ja ohnehin nichts mehr.

Schleifen

Jetzt haben wir ja schon eine ganze Menge angeschaut aber es gibt selbstverständlich noch mehr. Schleifen! Sie werden immer dann benötigt, wenn ein Anweisungsblock {} mehrfach wiederholt werden soll/muss. Hier mal direkt ein Beispiel:

 while-Schleife

while(1)
{
   // Anweisungen
}

Dieses Beispiel zeigt die Endlos-Schleife, sie muss in jedem C Programm (für µC) vorhanden sein, denn ein PIC arbeitet seinen Programmcode immer durch, wieder und wieder. Eine while Schleife wird solange durchlaufen, wie ihr Ausdruck “wahr” (unterschiedlich zu 0) ist. Da in der Klammer eine 1 steht, ist der Ausdruck immer 1 (=wahr) und die Schleife wird nie verlassen. Es sei denn, die Betriebsspannung wird entfernt. Nachfolgend die Grundschreibweise für eine While-Schleife:

while (Ausdruck)
{
   // Anweisungen
}

Man kann die Anweisung natürlich auch anders gestalten, sodass sich bedingte Schleifen ergeben. Zum Beispiel:

while (i <= 10)
{
   // Anweisungen
}

Diese while Schleife würde solange wiederholt werden, wie der Wert von “i” kleiner/gleich 10. Anders ausgedrückt, die while Schleife würde beendet werden, wenn “i” den Wert 10 überschreitet. Man kann die Bedingung im while Kopf, genau wie bei den if-Funktionen, beliebig erweitern.

for-Schleife

Die for-Schleife haben wir oben in Beispielen schon angesprochen. Ich möchte sie hier aber dennoch noch einmal genau erklären. Eine for-Schleife ist ähnlich wie eine while-Schleife nur dass man im Schleifen-Kopf mehr einbringen kann. Dazu schauen wir uns wieder ein Beispielcode an:

unsigned char i;
int array_01[5];

for (i = 0; i < 5; i++)
{
  array_01[i]=5*i;
}

In einer for-Schleife gibt es immer eine Variablen Initialisierung eine Abbruchbedingung und eine Schleifenanweisung. In dem obigen Beispiel ist die Variablen Initialisierung das: i=0; Somit ist festgelegt, dass die Variable “i” zu Beginn den Inhalt “0” hat. Die Abbruchbedingung ist: i<5; Also sobald diese Bedingung nicht wahr ist, wird die For-Schleife beendet. Die Abbruchbedingung wird immer beim Start überprüft. Zum Schluss noch die Variablen Veränderung, diese ist in dem Beispiel: i++; Also wird nach jeder durchlaufenden Schleife die Avriable “i” um 1 erhöht (inkrementiert). Somit können wir sagen, diese Schleife würde 5 mal durchlaufen werden.

do While-Schleife

Die do while Schleife ist wie eine ganz normale while Schleife, bloß dass diese mindestens einmal durchlaufen wird. Am Ende der Schleife wird dann die Bedingung überprüft, wenn dieser Ausdurck von 0 verschieden ist (wahr), dann wird die Schleife wiederholt, ist der Wert 0 (falsch), dann wird die Schleife beendet!

do
{
} while(i <= 10);

Weitere Steuerungen (break, continue, …)

break Anweisung

Die break Anweisung beendet einen gerade laufenden Programmblock. Hinweis: Es wird die Schleife komplett beendet! Siehe hierzu auch das Beispiel bei Switch Case.

continue Anweisung

Ist ähnlich wie die Break Anweisung. Wenn in einer Schleife die continue Anweisung erscheint, wird der Rest der Schleife nicht mehr durchlaufen sondern der PIC springt sofort zu Schleifenabfrage vor. Also wird nicht wie bei der Break Anweisung die Schleife ganz beendet sondern nur der aktuelle Durchlauf!

return Anweisung

Dir return Anweisung wird hauptsächlich dafür verwendet, wenn Werte aus einer Funktion zurück gegeben werden sollen.

Zeiger (Pointer)

Allgemeines

Ein Zeiger (engl. Pointer) ist eine Variable, welche auf eine Stelle im Speicher zeigt. Die Zeiger haben zu den Vektoren (Arrays) in C eine besondere Verwandtschaft so lässt sich ihre Syntax gegenseitig verwenden. Man benutzt Zeiger zum Beispiel dann, wenn man in einer Funktion eine große Menge an Daten verarbeiten muss, welche hinterher auch z.B. in der main Funktion wieder zur Verfügung stehen müssen. Jetzt hat man mit den Zeigern eine sehr elegante Methode die Verwendung von globalen Variablen zu vermeiden. Man nennt dieses Verfahren dann call by reference, was soviel bedeutet wie: Funktionsaufruf mit einer entsprechenden (Start)Adresse. Man könnte sich vorstellen, dass in einer Funktion ein Datensatz nach dem Alphabet sortiert werden muss. Es steht z.B. ein Vektor mit 500 Elementen zur Verfügung, welche in sich wiederum 20 Elemente für Vornamen, 20 für Nachnamen, 20 für Matrikelnummer,… enthält. Nun wäre es nicht sinnvoll diesen Vektor global zu deklarieren. Er wird lokal in main deklariert und der Funktion, welche sortieren soll, wird lediglich die Adresse des Vektors übergeben. Die Funktion kann nun direkt auf den Inhalt zugreifen und die Variablen verändern ohne, dass der gesamte Inhalt an die Funktion übergeben werden musste (call by value). Aber selbst bei dieser beschriebenen Version gibt es noch Schwächen. Noch eleganter wäre es die 500 Elemente nur mit einer Indizierung zu sortieren, so müssten die ganzen folge Informationen nicht mit verschoben werden, was eine Menge an Rechenzeit spart.

Deklarierung

Ein Zeiger wird wie folgt deklariert:

unsigned char *pText;

Hierbei gilt es zu beachten, dass ein Zeiger immer vom selben Datentyp sein muss, wie das Element auf das er zeigt!

Initialisierung

Um mit einem Zeiger arbeiten zu können muss dem Zeiger eine Adresse zugewiesen werden. Wir deklarieren zunächst eine char Variable indem wir ein Zeichen speichern. Anschließend wird die Adresse dieser Variable in den Zeiger geschrieben. Der Zeiger zeigt nun auf die Adresse im Speicher an dem der Inhalt von der Variable Text steht:

unsigned char text = 'H';
unsigned char *pText = &text;

In der ersten Zeile wird eine Variable des Typ char angelegt und mit dem Wert ‘H’ beschrieben. In der zweiten Zeile folgt ein Zeiger, welche auf den Datentyp char zeigt. Dieser wird auch gleich mit der Adresse der Variable text gefüllt. Das Kaufmanns-Und “&” ist der Adressoperator.

Wir halten also fest, dass der Operator * (Stern) einen Zeiger ankündigt. Ein Zeiger lässt sich auch, wie andere Variablen, direkt bei der Deklarierung initialisieren. Wie das geht seht ihr hier.

Arbeiten mit Zeigern

Wir können mit dem Zeiger nun auch direkt den Wert der Variable ausgeben oder bearbeiten. Durch das Zeichen * vor dem Namen wird angegeben, dass man tatsächlich das erhält, was in der Speicherzelle steht auf die der Zeiger zeigt. Ohne das * wird die Adresse des Zeigers geändert auf die er zeigen soll:

pText = &text; // Adresszuweisung
*pText = 'A'; // Wertzuweisung

Nach der zweiten Zeile steht in der Variable text nicht mehr das ‘H’ sondern ein ‘A’, da wir über den * Operator auf den Inhalt der Speicherzelle zugreifen auf das der Zeiger zeigt.

Vektoren und Zeiger

Wie im Deutschen üblich beschreibt der vordere Teil eines Wortes nur das eigentliche. So ist das folgende (Zeigervektor) eigentlich ein Vektor, welcher aber aus Zeigern besteht. Hier ein kleines Beispiel eines Zeigervektors:

unsigned char *pText[5];

Wir haben nun einen Vektor mit 5 Elementen (0-4) gebildet, welche jeweils ein Zeiger auf den Datentyp unsinged char sind. Ein Zeiger besteht grundsätzlich aus vier Byte, egal auf was er zeigt! Das ist, wenn man mal etwas genauer darüber nachdenkt, auch logisch, da die Adresse nicht länger als 4 Byte ist auch wenn das Element, welches an dieser Stelle steht die nachfolgenden 8 Byte belegt! Mit dem Zeigervektor kann nun wie gewohnt gearbeitet werden, wie wir es von Vektoren kennen:

// Anlegen von Strings
char a[] = "Meier";
char b[] = "Schulze";
char c[] = "Musterman";

// Anlegen eines Zeigervektor
char *pName[3];

// Zuweisung von Adressen
pName[0] = &a[0];
pName[1] = &b[0];
pName[2] = &c[0];

Die Adresszuweisungen könnte man auch anders schreiben, da der Name eines Vektors die Startadresse von diesem ist!

// Zuweisung von Adressen (alternativ)
pName[0] = a;
pName[1] = b;
pName[2] = c;

Weitere Beispiele zum Umgang mit Zeigern:

// Anlegen von zwei Variablen
int a = 4, b;

// Ein Vektor mit 6 Variablen
int z[6];

// Zeiger auf Typ int
int *pInt;

// Jetzt zeigt pInt auf a
pInt = &a;

// Jetzt hat b den Wert 4
b = *pInt;

// Jetzt hat a den Wert 7
*pInt = 7;

// Nun zeigt pInt auf z[2]
pInt = &z[2];

// Jetzt hat z[2] den Wert 9
*pInt = 9;

// Und jetzt zeigt pInt auf z[3]
pInt++;

Erläuterung zu Zeile 26: Da der Compiler aus Zeile 3 weiß, dass es sich um einen Zeiger auf den Datentyp Integer handelt, wird er automatisch die Anzahl der Bytes entsprechend im Adressbereich weiter gehen um auf die nächste Integer Variable zu zeigen. Daher ist es so wichtig, dass der Compiler weiß um welchen Datentypen es sich handelt!

Strukturen mit struct

In C werden Strukturen dafür verwendet verschiedene Elemente (meistens unterschiedlicher) Datentypen zusammenzufassen. Vorstellbar wäre zum Beispiel eine Struktur, welche in einem Projekt diverse Informationen für den Anwender bereit hält wie: Uhrzeit, Datum, Wochentag, Temperatur…

Deklaration

Im folgenden seht ihr ein Beispiel einer einfachen Struktur, welche drei Elemente eines Daums (Tag, Monat und Jahr) zu einer Struktur bündelt. Zur direkten Ausgabe ist der Monat als Text gespeichert:

struct sDatum
{
   int Tag;
   char Monat[10];
   int Jahr;
};

Eine Struktur erstellt Ihr mit dem Schlüsselwort struct. Danach wird der ausgewählte Name für diese Struktur geschrieben. Damit es ersichtlich ist, dass es sich hierbei um eine Struktur handelt bietet es sich an vor den Namen ein kleines “s” zu setzten. In die geschweiften Klammern kommen die Elemente hinein, welche durch die Struktur zusammen gefasst werden sollen. Der Speicherbedarf dieser Struktur läge bei (2+10+2) 14 Byte auf einem System mit 8 Bit Datenbreite (PIC10-PIC18).

Ein struct ist übrigens ein kleiner Wink in Richtung C++ bzw. objektorientierter Programmierung.

Üblicherweise wird die deklariert bzw. definiert man eine Struktur in einer Headerdatei. Die Deklaration an sich belegt noch keinen Speicher. Sie ist quasi nur der Stempel. Eine erzeugte bwz. später definierte Struktur ist dann sozusagen das Abbild des Stempels und benötigt Speicher.

Definition

Mit der Deklaration der Variablen haben wir nun die Möglichkeit geschaffen eine solche Struktur zu erstellen (definieren). Im folgenden ein Beispiel wie eine Struktur nun definiert werden kann:

struct sDatum Datum;

Die Initialisierung erfolgt ahnlich wie bei Vektoren mit geschweiften Klammern hinter der Definition:

struct sDatum Datum = {15, "August", 2012};

Die Deklaration und Definition kann aber auch kombiniert werden, so folgt:

struct sDatum
{
        int Tag;
        char Monat [10];
        int Jahr;
} Datum;

Es können auch Zeiger auf Strukturen und Vektoren von Strukturen gebildet werden:

struct sDatum Fussball[7], *pDatum;

Anwendung

Um mit einer erstellten Struktur arbeiten zu können muss man wissen wie man nun auf die einzelnen Elemente einer Struktur zugreifen kann. Nun, das ist recht einfach hier wird der Punkt Operator verwendet “.”. Hier ein kleines Beispiel:

Datum.Tag = 13;

Und schon ist der Variable Tag in der Struktur Datum der Wert 13 zugewiesen worden. Ein Unterschied zu Vektoren besteht darin, dass man sie in einem einfachen Rutsch (komplett) kopieren kann:

struct sDatum original, kopie;
// ...
kopie = original;

Jetzt stellt euch vor Ihr erstellt die Struktur für euer Projekt in der Funktion main. In eurer Struktur können sich beliebig viele Elemente befinden hier gibt es keine Begrenzung. Nun habt ihr euer Projekt schön auf verschiedene Funktionen aufgeteilt benötigt aber in den Funktionen ebenfalls die Struktur, da zum Beispiel eine Datum Funktion das aktuelle Datum in dieser Struktur abspeichern soll. Die Lösung hierfür lautet call by reference. Ihr könnt nun dieser Funktion, welche Information in eurer Struktur abspeichern soll , die Adresse der in main erstellten Struktur übergeben indem ihr den Adressoperator verwendet. Hier ein Beispiel:

void main (void)
{
   struct sDatum info;

   // ...
   getDatum(&info);
   // ..
}

Nun hat die Funktion getDatum die Adresse der Struktur erhalten, sie weiß also wo im Speicher sich der Inhalt der Struktur aus main befindet. Der große Vorteil ist hierbei, dass man keine Rückgabewerte braucht (was ja an sich schon Unsinn ist, da eine Funktion nur einen Rückgabewert besitzen kann. Man müsste die Funktion also mehrfach aufrufen um alle Daten zu bekommen. Das am besten sofort wieder vergessen!). Ein weiterer Vorteil ist die Geschwindigkeit, denn es wird nun un getDatum mit den original Speicherzellen aus main gearbeitet und es ist nicht notwendig eine Kopie der gesamten Struktur zu erstellen. Dadurch wird das Programm schneller.

Wie aber greifen wir jetzt auf die Inhalte in der Funktion getDatum auf die Struktur zu, da wir ja nun nicht mehr die Struktur selber sondern “nur” einen Zeiger auf diese haben. Nun hierfür gibt es zwei Möglichkeiten wobei nur eine wirklich Verwendung findet: Man kann nun entweder in der Zeigerdenkweise bleiben und es so machen:

void getDatum (struct sDatum *pInfo)
{
   (*pInfo).Tag=11;
}

Oder aber und das ist die übliche Methode: Man verwendet den Pfeil Operator, welcher genau das selbe bewirkt:

void getDatum (struct sDatum *pInfo)
{
   pInfo->Tag=11;
}

void getDatum (struct sDatum *pInfo)

Nun wir möchten der Funktion die Adresse der Struktur aus main übergeben. Nun ist es ja üblich der Funktion im Kopf mitzuteilen welche Daten die Funktion bekommen wird. Und in diesem Fall ist es eine Adresse auf den Datentyp struct Datum.

Eigene Datentypen mit typedef

Mit der Anweisung typedef ist es möglich eigene Datentypen zu erstellen. Zunächst ein Beispiel:

struct sDatum
{
        int Tag;
        char Monat [10];
        int Jahr;
} Datum;

typedef struct sDatum tDatum;

Hier wurde nun ein eigener Datentyp erschaffen. Hinter diesem Datentypen tDatum (Das kleine “t” soll hier wieder der Anschaulichkeit dienen, signalisiert einen eigenen Datentypen) verbirgt sich die Struktur aus einem Kapitel zuvor. Nun lässt sich eine Struktur Beispielsweise einfach erstellen als vorher:

tDatum info;

Man könnte auch direkt beim Definieren einer Struktur den Datentypen erstellen. Wie das geht seht ihr hier:

typedef struct
{
   int Tag;
   char Monat [10];
   int Jahr;
} tDatum;

Aufzählungen mit enum

Mit der Anweisung enum hat man die Möglichkeit in einer Variablen eine begrenzte Anzahl an Möglichkeiten zu speichern. Man könnte sich ja zum Beispiel vorstellen man möchte eine Variable haben, welche einem die Jahreszeit angibt. So benötigt diese Variable vier verschiedene Zustände (Frühling, Sommer, Herbst und Winter). Natürlich wäre es hier auch einfach möglich eine unsigned char Variable zu verwenden aber man möchte sein Programm ja doch so gestalten, dass man die maximale Übersichtlichkeit erhält. Zu besseren Lesbarkeit könnte man auch mit#define arbeiten:

#define FRUEHL 0
#define SOMMER 1
#define HERBST 2
#define WINTER 3

Für solche Aufzählungen bietet C einen besonderen Datentypen: enum:

enum eJahreszeit
{
   Fruehl,
   Sommer,
   Herbst,
   Winter
};

enum eJahreszeit Jahreszeit;

Hier hat Fruehl den Wert 0, Sommer 1,… Man kann die Reihenfolge auch beeinflussen:

enum eJahreszeit
{
   Fruehl=1,
   Sommer,
   Herbst=6,
   Winter
};

Somit hätte Fruehl den Wert 1, Sommer 2, dann geht es bei Herbst mit 6 weiter und folglich hat Winter die 7.

Anwendung

Hier ein kleines Beispiel wie man mit enum arbeiten kann:

enum eJahreszeit
{
   Fruehl,
   Sommer,
   Herbst,
   Winter
};

enum eJahreszeit Jahreszeit;

//...

Jahreszeit = Sommer;

if(Jahreeszeit == Sommer)
{
   // ...
}

Speziell für PIC

Konfiguration

Selbstverständlich müssen in C genauso wie in Assembler (ASM) die Konfiguration für den PIC bestimmt werden. Wenn dies vergessen wird, wird der PIC nichts machen! Nun unterscheidet sich die Einstellung der einzelnen Einheiten etwas. Hier ein beispiel wie Ihr in C, die Konfiguration für einen PIC vornehmen könnt:

#pragma config FOSC=HS   // Taktbereich
#pragma config PWRT=ON   // Power on timer
#pragma config BOR=OFF   // Brown out reset
#pragma config WDT=OFF   // Watchdog timer
#pragma config LVP=OFF   // Low voltage progr.
#pragma config MCLRE=ON  // Master clear reset

Durch die Einleitung #pragma weiß der PIC, dass es sich um Konfigurationsinformationen handelt. Natürlich könnt Ihr die Konfigurationsbits, wie in Assembler, auch manuell einstellen.

So werden die Konfigurationsbits mit MPLABX erstellt:

Eingänge / Ausgänge

Hier ein Beispiel, wie Ihr in der Sprache C Zustände von Port Pins einlesen und wie Ihr Pins (Ausgang) setzten oder löschen können:

// Ausgang löschen
LATAbits.LATA4 = 0;

// Ausgang setzten
LATBbits.LATB0 = 1;

// Wahl Ausgang(0)/Eingang(1)
TRISB = 0x80;

// Abfrage eines Ports (Eingang)
if (PORTB == 0xFF);

// Abfrage eines einzelnen Pins
if (PORTBbits.RB0 == 0);

TRISB = 0x80;

Also Schreibregel beim Setzten/Löschen von Ausgängen:

LATXbits.LXY = Z;
X: Hier wird der Port eingetragen (A, B,..).
Y: Hier kommt das Bit hinein (0-7) des Ports.
Z: Der Zustand den der Port-Pin annehmen soll.

Dabei darf man natürlich nicht vergessen die TRIS Bits dementsprechend einzustellen! Wir erinnern uns: Eine “1” im TRIS Register schaltet den jeweiligen Port-Pin als Eingang, eine “0” als Ausgang. Im obigen Beispiel seht Ihr ebenfalls wie Ihr die TRIS-Register beschreiben könnt.

Schreibregel beim Lesen von Eingängen:

if (PORTXbits.RXY == 0) {...} else {...}
X: Hier wird der Port eingetragen (A, B,..).
Y: Pin eintragen der gelesen werden soll (0-7)

Dies ist ein Beispiel, wie man in Abhängigkeit vom Zustand eines Einganges den Programmablauf steuern kann!

Wann PORT und wann LAT?

Ein weiterer wichtiger Punkt ist zu wissen, wann man mit PORT und wann mit LAT abeiten muss. Ganz kurz und knapp: LAT bei Ausgängen und PORT bei Eingängen.

Wer sich noch etwas mehr mit den Vorteilen der LAT-Register beschäften möchte kann mal >> hier rein schauen. Sehr interessant!

Interrupts

PIC Mikrocontroller unterscheiden zwei Interrupt Prioritäten. High und low. Wenn Ihr einen Interrupt programmiert habt und ein entsprechendes Event diesen auslöst, so wird der PIC in die so genannte Interrupt-Service-Routine springen. Im Grunde genommen ist das eine Art Funktion. Nur wird diese nicht vom Programmierer aufgerufen sondern vom PIC selber wenn ein entsprechendes Ereignis eintritt.

int tick_count;

void interrupt tc_int(void)
{
   if (TMR0IE && TMR0IF)
   {
      TMR0IF=0;
      ++tick_count;
      return;
   }
   // ...
}

/* Beziehungsweise ein Interrupt mit niedriger Priorität */

void interrupt low_priority tc_clr(void)
{
   if (TMR1IE && TMR1IF)
   {
      TMR1IF=0;
      tick_count = 0;
      return;
   }
   // ...
}

Häufige Fehler

Hier entsteht eine Sammlung von Fragen mit Antworten, welche sehr häufig gestellt werden. Außerdem wird eine Liste mit Fehlern erstellt, welche immer wieder vorkommen.

GLEICH = ist nicht gleich GLEICH ==

Ein Fehler der immer wieder gern gemacht wird ist, dass man bei einem Vergleich das falsche Zeichen wählt. Ein einfaches geschriebenes “=” Zeichen ist dafür da um z.B. Variablen einen Wert zu zuweisen aber nicht als Vergleichsoperator, dies würde einen Syntax Fehler nach sich ziehen und das Compilieren beenden. Siehe:

Falsch

if (A=B) {..} else {..}

Richtig

if (A==B) {..} else {..}

Funktion aufrufen

Wenn man eine Funktion aufrufen möchte die Assembler Leute kennen dies besser unter dem Namen Unterprogramm, dann sollte man doch auf die korrekte Schreibweise achten.(Am besten gleich den nächsten Punkt in diesem Kapitel lesen!) Siehe:

Falsch

void Funktion();
Funktion()
Funktion;

Richtig

Funktion();

Funktion anmelden

Dieser Fehler wird sehr häufig gemacht und dann wundert man sich warum beim Compilieren so ein seltsamer Fehler kommt. Bevor man eine Funktion innerhalb main-Routine aufrufen kann, muss man sie vorher angemeldet haben. Dafür gibt es zwei Möglichkeiten: Entweder man schreibt die Funktion oberhalb main-Routine oder aber man meldet sie vorher an. Siehe:

Falsch

void main (void)
{
  FunktionA();
}

void FunktionA (void) {..}

Richtig

void FunktionA (void) {..}
void main (void)
{
  FunktionA();
}

Oder aber man meldet Sie vorher an:

Richtig

void FunktionA (void);

void main (void)
{
  FunktionA();
}

void FunktionA (void) {..}