CCS Compiler Tutorial mit Beispielen

CCS Compiler Tutorial mit Beispielen Mit diesem Tutorial werden Sie den CCS Compiler kennenlernen, um mit ihm Projekte selbstständig erstellen zu können. Es werden zugleich die Programmierung und die Grundlagen eines PIC-Controller behandelt. Für das Tutorial wird folgendes benötigt: CCS Compiler Version ( IDE ), PIC-Brenner ( z.b. PIC-START oder GALEP ), Experimentierboard, Grundkenntnisse in der Programmiersprache C. Meiner Meinung nach sollte am Experimentierboard nicht gespart werden, weil man auf diesem Board mehrere Projekte realisieren kann. Es ist nicht notwendig mehrere Boards zu erstellen oder zu kaufen, um verschiedene Projekte zu entwickeln. Ich empfehle deswegen das PIC Millenium Board von Bluebird Electronics oder Experimentierboards von MikroElektronika, weil dort fast alle Anwendungen realisiert werden können. Das Board kostet etwas mehr als andere, es hat dafür aber viel mehr zu bieten. Das Tutorial ist in mehrere Kapitel unterteilt und wird sehr ausführlich beschrieben : Kapitel 1 : Projekt erstellen und am Ausgang eine LED blinken lassen Kapitel 2 : Interrupt-Routine erstellen und Eingangssignal bestimmen Kapitel 3 : Timer 0 Interrupt Kapitel 4 : 6-LED Lauflicht

Kapitel 1 Projekt erstellen und am Ausgang eine LED blinken lassen Zuerst wird ein Projekt erstellt. Dafür wählt man das Menü "Project->New->PIC Wizard" im CCS Compiler an. Danach können Sie das Verzeichnis sowie den Namen des Projektes angeben. Mit dem PIC Wizard kann das Grundgerüst eines C-Programmes sehr leicht erstellt werden. Wenn Fragen über die einzelnen Punkte im PIC Wizard auftauchen sollten, finden Sie hier eine ausführliche Beschreibung des PIC Wizard. Wählen Sie nun den PIC16F84 aus, geben 4.000.000 Hz (4 MHz) ein und wählen Sie die Oszillatoroption XT aus. Schalten Sie im nächsten Reiter die Option RS232 aus und drücken Sie auf "OK". Wenn Sie auf "OK" gedrückt haben, wird das Grundgerüst mit angegebenen Information vom Compiler aufgebaut, und Sie sehen dann die C-Datei (Hauptprogramm). Öffnen Sie nun auch die Header-Datei ( "<Projektname>.h") des Projektes. Diese beiden Dateien wurden vom Compiler mit Ihren angegebenen Daten erstellt. Die Oszillatoroption, Taktfrequenz und der PIC-Typ (Header-Datei für diesen PIC) sind in der Headerdatei angegeben: #include <16F84.h> #use delay(clock=4000000) #fuses XT,NOWDT Mit dem Präprozessorbefehl #include kann Quellcode, der sich in einer anderen Datei befindet eingebunden werden. Mit <> sucht der Compiler die angegebene Datei im Systemverzeichnis oder im aktuellen Verzeichnis, und mit " " kann der direkte Pfad der Datei angegeben werden. Mit #use delay wird die Controllergeschwindigkeit bestimmt. Diese Angabe braucht der Compiler für interne Funktionen (delay_ms und delay_us), die ein bestimmtes Timing ermöglichen. Der Präprozessorbefehl #fuses erzeugt das Konfigurationswort. Die Optionen sind bei jeden PIC- Typ anders. Für mehr Informationen über diese Optionen klicken Sie hier. Die Headerdatei für den jeweiligen PIC befindet sich in der Standardkonfiguration unter dem Verzeichnis "DEVICES" im Hauptverzeichnis des CCS Compilers.

Im Hauptprogramm wird angegeben, wo sich die Headerdatei für dieses Projekt befindet. Der PIC- Wizard initialisiert alle vorhandenen Module des jeweiligen PIC's. Wir wollen nun ein Programm schreiben, das eine LED im 1s Intervall ein- und ausschaltet. Dafür benötigt man die Befehle "output_high()" und "output_low()". Mit output_high(pin) kann ein Ausgang (Pin) auf high gesetzt werden und mit output_low(pin) auf low. Um die Pausen zwischen dem Ein- und Auschalten der LED zu bekommen, verwenden wir hier den Befehl "delay_ms()". Durch die Syntax delay_ms( 500 ) wird eine Pause von 500ms ausgeführt. Es gibt auch den Befehl "delay_us()", der die Pause in µs (mikrosekunden) ausführt. In der Initialisierung sollten noch die Ports als Ein- oder Ausgänge definiert werden. Mit dem Befehl "set_tris_x()" können die einzelnen Ports konfiguriert werden. Das X steht für das jeweilige Port, z.b. set_tris_a() für Port A. Fast jeder Port (außer Port A, der eine unterschiedliche Anzahl von Pins hat) hat 8 Ein- oder Ausgänge (Pins). Wenn der bestimmte Pin als "1" definiert wird ist er als Eingang konfiguriert, bei "0" als Ausgang. In unserem Beispiel werden alle Pins als Ausgänge definiert und an Pin RB1 schließen wir direkt die LED an. Unbenutzte Eingangspins sollten niemals unbeschaltet bleiben, da sonst hohe Querströme von VDD nach VSS fließen können. Dadurch würde man den PIC eventuell zerstören. Deshalb werden die unbenutzen Pins als Ausgänge definiert. Schaltung für Tutorial 1 Kapitel 1 Damit das Ein- und Ausschalten der LED endlos läuft, verwenden wir eine Endlosschleife. Mit dem Befehl "" kann man eine Endlosschleife realisieren, denn der Befehl überprüft ob der Inhalt der Klammer wahr ist. Ist die Aussage, wie in diesem Falle, wahr, dann wird die Schleife immer durchlaufen.

In den folgenden Zeilen wird das komplette Programm angegeben, die fett markierten Zeilen müssen in das Grundgerüst des Projektes eingefügt werden. Hauptprogramm ( <Projektname>.c ) : #include "C:\Programme\PICC\Projekte\tutorial1.h" void main() set_tris_b(0); setup_counters(rtcc_internal,rtcc_div_2); output_high(pin_b1); output_low(pin_b1); Headerdatei ( <Projektname>.h ) : #include <16F84.h> #use delay(clock=4000000) #fuses XT,NOWDT Die Zeile "setup_counters(rtcc_internal,rtcc_div_2);" wird später näher erläutert. Tippen Sie nun die neuen Zeilen ein und kompilieren Sie das Programm. Wenn Sie Probleme beim Kompilieren haben, können Sie sich das Projekt auch hier downloaden. Um effektiv etwas zu lernen, sollten Sie aber nur im äußersten Notfall das Projekt herunterladen.

Kapitel 2 Interrupt-Routine erstellen und Eingangssignal bestimmen Wenn Sie alle Schritte aus Kapitel 1 erledigt haben, können Sie nun ein eigenes Projekt erstellen. Wir wollen nun eine Interrupt-Routine programmieren. Ein Interrupt bedeutet, das eine bestimmte Hardware im Mikrocontroller ein oder auch mehrere Eingangssignale überwacht. Wenn sich dieses Eingangssignal verändert, tritt ein Ereignis auf und der Mikrocontroller unterbricht seine normale Arbeit und springt zur speziellen Interrupt-Routine. Diese Routine wird ausgeführt, dann springt der Mikrocontroler wieder zur letzten Anweisungen, die er bei seiner normalen Arbeit verrichtet hat und arbeitet dann die folgenden Anweisungen weiter. Folgende Interrupts kann ein PIC-Mikrocontroller besitzen: Signal an Pin RB0, Flankenwechsel an den Pins RB4 bis RB7, Überlauf der Timer0 (RTCC), Timer1, Timer2, A/D-Wandler ist mit der Wandlung fertig, CCP Interrupt, SSP Interrupt, Paralleler-Slave-Port Interrupt, RS232 Receive Data Interrupt, RS232 Transmit Buffer Interrupt, Bus collision Interrupt ( I2C ), EEPROM Schreiben abgeschlossen, Low Voltage Detect Interrupt ( PIC18 ), Komparator Detect Interrupt ( PIC18 ), usw. In diesem Tutorial werden nur eine Interruptsmöglichkeiten ausführlich beschrieben. Wir werden aber erstmal den Interrupt an RB0 einsetzen. Dort wird ein Signal durch ein Taster erzeugt und die LED, die in Kapitel 1 angeschlossen wurde, soll dann für 500ms eingeschaltet, danach wieder ausgeschaltet werden. Wir öffnen zuerst das Projekt von Kapitel 1 und löschen den Inhalt der Endlosschleife ( While(1) ) : #include "C:\Programme\PICC\Projekte\tutorial1.h" void main() set_tris_b(0); setup_counters(rtcc_internal,rtcc_div_2); output_high(pin_b1); output_low(pin_b1); Der Interrupt an RB0 wird im CCS Compiler mit der Bezeichnung "INT_EXT" abgekürzt. In der Initialisierung muss zuerst angegeben werden mit welchem Signal der Interrupt an RB0 ausgelöst wird. Mit dem Befehl "ext_in_edge()" wird diese Option definiert. Wenn der Interrupt bei einer steigenden Flanke ( von LOW zu HIGH ) ausgelöst werden soll, dann muss der Befehl

"ext_in_edge(l_to_h);" lauten, bei einer fallenden Flanke ( von HIGH zu LOW ) "ext_in_edge(h_to_l);". Damit auch ein Ereignis an diesem Interrupt auftreten kann, muss er aktiviert werden. Dies geschieht mit dem Befehl "enable_interrupts()". In unserem Fall lautet der Befehl "enable_interrupts(ext_int);" ( Mit diesem Befehl wird das INTE-Bit im INTCON-Register des PIC- Controllers gesetzt). Jedoch reicht dieser Befehl allein nicht aus, um die Interrupts zu aktivieren, denn es gibt eine Art von "Hauptschalter" für alle Interrupts. Dieser nennt sich "GLOBAL" und wird mit dem Befehl "enable_interrupts(global);" eingeschaltet (Hier wird das GIE-Bit im INTCON-Register gesetzt). Schließlich muss noch RB0 als Eingang definiert werden, damit dieser Interrupt die Eingangssignale interpretieren kann. Folgende fett markierten Zeilen werden im Hauptprogramm eingesetzt oder verändert: #include "C:\Programme\PICC\Projekte\tutorial1.h" void main() set_tris_b(1); // RB0 wird als Eingang definiert setup_counters(rtcc_internal,rtcc_div_2); ext_in_edge(l_to_h); // steigende Flanke enable_interrupts(int_ext); // RB0 Interrupt wird aktiviert enable_interrupts(global); // Globaler Interrupt wird aktiviert Damit beim Eintreten eines Ereignisses zur bestimmten Interrupt-Routine gesprungen werden kann, muss diese Funktion vor der Main-Funktion geschrieben werden. #int_ext // Interrupt-Routine für RB0 void LED_AUSGEBEN() output_high(led); Der PIC-Controller löscht automatisch beim Eintreten einer Interrupt-Routine das GIE-Bit, also den globalen Interrupt (Hauptschalter), damit keine weiterer Interrupt ausgelöst wird. Beim Austreten der Interrupt-Routine wird es wieder automatisch gesetzt. In der Interrupt-Routine muss auch nicht das Flag des jeweiligen Interrupt gelöscht werden, damit sich der Interrupt sich immer wieder selbst aufrufen kann. Denn der CCS Compiler löscht diesen Interruptflag immer selber, sodass man nicht darauf achten muss. Zusätzlich müssen alle Interrupt-Routinen vor MAIN (Hauptprogramm) geschrieben werden. In unserem Beispiel wird beim Auslösen des Interrupts RB0 eine LED an RB1 für 500ms eingeschaltet.

Mit dem Befehl #define kann eine Textsubstitution realisiert werden, die wir hier für PIN_B1 anwenden. In der Endlosschleife schalten wir diese LED wieder aus. Hier folgt nun das komplette Hauptprogramm, mit den fett markierten Zeilen, die hinzugefügt oder verändert werden: #include "C:\Programme\PICC\Projekte\tutorial1.h" #define LED PIN_B1 #int_ext // Interrupt-Routine für RB0 void LED_AUSGEBEN() output_high(led); //LED wird auf HIGH gesetzt void main() set_tris_b(1); // RB0 wird als Eingang definiert setup_counters(rtcc_internal,rtcc_div_2); ext_in_edge(l_to_h); // steigende Flanke enable_interrupts(int_ext); // RB0 Interrupt wird aktiviert enable_interrupts(global); // Globaler Interrupt wird aktiviert output_low(led); //LED wird auf LOW gesetzt An der Hardware von Kapitel 1 wurde nur ein Taster an RB0 hinzugefügt. Die Schaltung für dieses Beispiel sieht folgendermaßen aus: Schaltung für Tutorial 1 Kapitel 2 Tippen Sie nun die neuen Zeilen ein und kompilieren Sie das Programm. Wenn Sie Probleme beim Kompilieren haben das können Sie sich das Projekt auch hier downloaden. Um effektiv etwas zu lernen sollten Sie nur im äußersten Notfall das Projekt herunterladen.

Kapitel 3 Timer0 Interrupt Durch die Schritte der vorherigen Kapitel können Sie nun ein Projekt mit einer Interrupt-Routine erstellen. In diesem Kapitel wird ein Interrupt von Timer0 erzeugt, wenn ein bestimmter Schalter eingeschaltet wird. Wenn der Schalter eingeschaltet ist, leuchtet die LED verzögert auf und wenn der Schalter danach ausgeschaltet leuchtet die LED nach einer Weile nicht mehr. Im Hauptprogramm wird permanent ein Eingang abgefragt. Wenn dieser sich geändert hat wird Timer0 gestartet, der danach ein Interrupt auslöst. Folgende fett markieten Zeilen müssen für dieses Tutorial im Hauptprogramm entfernt werden: #include "C:\Programme\PICC\Projekte\tutorial1.h" #define LED PIN_B1 #int_ext // Interrupt-Routine für RB0 LED_AUSGEBEN() output_high(led); //LED wird auf HIGH gesetzt void main() set_tris_b(1); // RB0 wird als Eingang definiert setup_counters(rtcc_internal,rtcc_div_2); ext_in_edge(l_to_h); // steigende Flanke enable_interrupts(int_ext); // RB0 Interrupt wird aktiviert enable_interrupts(global); // Globaler Interrupt wird aktiviert output_low(led); //LED wird auf LOW gesetzt Das Aktivieren des Timer0-Interrupts geschieht mit dem Befehl "enable_interrupts(int_rtcc);". Wenn Timer0 gestartet wird und dem Zähler eine bestimmte 8-Bit Zahl zugewiesen wurde, beginnt er in einem angegeben Intervall den Zähler hochzuzählen. Wenn ein Overflow auftritt, dann setzt der Timer0 ein Ereignisbit und springt zum Timer0-Interrupt. Der Intervall für das Hochzählen der Zählers von Timer0 kann mit dem Befehl "setup_counters()" eingestellt werden. Wenn dem Timer0 den Befehl "setup_counters(rtcc_internal,rtcc_div_256);" zugewiesen wird, dann wird alle 65,5 ms ein Overflow verursacht. Mit der Option RTCC_DIV_256 wird der Vorteiler von Timer0 auf 1:256 gesetzt. Mit der folgenden Formel kann die Zeit bei einem Timer-Overflow berechnet werden: time = ( 1/Frequenz ) * 4 * Timerwert * Vorteiler time = ( 1 / (4*10^6) ) * 4 * 256 * 256 = 65,5 ms

Wenn Sie näheres über Timer wissen möchten, dann klicken Sie hier. Wie definieren jetzt RB0 als Eingang und schließen dort einen Taster an. Dieser wird im Hauptprogramm permanent abgefragt. Das Abfragen eines Pins geschieht mit dem Befehl "input()". Mit dem Befehl "if (input(pin_b0))" wird nun überprüft, ob der Eingang RB0 auf HIGH gesetzt ist. Die Timer0 Interrupt-Routine wird beim Aktivieren des Tasters alle 65,5 ms aufgerufen. Um die Verzögerung mit dem bloßen Auge erkennen zu können, wird die Interrupt-Routine 20mal durchlaufen, dann wird die LED ein- oder ausgeschaltet. Dadurch bekommen wir eine Verzögerung von insgesamt 1,31 s. Wenn der Taster aktiviert ist, wird die LED nach einer Verzögerung eingeschaltet und beim nicht aktivierten Zustand mit der gleichen Verzögerung ausgeschaltet. Zum Schluss wird noch der Pin RB0 als Eingang definiert. Hier möchte ich eine Erleichterung der Zuweisung von Ein- und Ausgängen hinzufügen. Denn wie in vielen anderen Programmen werden die Pinbelegung eines Ports in Binär oder Hexadezimal angegeben. Mit dem folgenden Befehl enum BITSTELLE Bit0=1,BIT1=2,BIT2=4,BIT3=8,BIT4=16,BIT5=32,BIT6=64,BIT7=128 ; weise ich den einzelnen Bitstelle den entsprechenden dezimalen Wert zu. Die Anweisung enum ist mit der #define Präprozessoranweisung verwandt. Man kann damit eine Aliasliste mit mehreren Integerzahlen erzeugen. Durch die enum-anweisung kann nun Port B folgendermaßen initialisiert werden: set_tris_b(bit0); Mit dieser Anweisung gebe ich an, das Pin RB0 als Eingang definiert wird. Dadurch werden die Pinbelegungen überschaubarer und man sieht sofort, welche Pins als Ein- und Ausgang definiert werden. Folgende fett markierten Zeilen werden im Hauptprogramm schließlich hinzugefügt oder verändert: #include "C:\Programme\PICC\Projekte\tutorial1.h" #define TASTER PIN_B0 #define LED PIN_B1 int1 LED_SOLL_BLINKEN; char hilfsvariable; enum BITSTELLE Bit0=1,BIT1=2,BIT2=4,BIT3=8,BIT4=16,BIT5=32,BIT6=64,BIT7=128 ; #int_rtcc // Interrupt-Routine für RB0 void Timer0_Handler() if ( ( hilfsvariable==20 ) && ( LED_SOLL_AN==1 ) ) hilfsvariable=0; output_high(led); disable_interrupts(int_rtcc); if ( ( hilfsvariable==20 ) && ( LED_SOLL_AN==0 ) ) hilfsvariable=0;

output_low(led); disable_interrupts(int_rtcc); hilfsvariable++; void main() set_tris_b(bit0); // RB0 wird als Eingang definiert setup_counters(rtcc_internal,rtcc_div_256); ext_in_edge(l_to_h); enable_interrupts(global); hilfsvariable=0; LED_SOLL_AN=0; if ( input(taster) && LED_SOLL_AN==0) LED_SOLL_AN=1; set_timer0 ( 0 ); enable_interrupts(int_rtcc); else if ( (!INPUT(TASTER)) && (LED_SOLL_AN==1) ) LED_SOLL_AN=0; set_timer0 ( 0 ); enable_interrupts(int_rtcc); Die Schaltung für dieses Beispiel sind folgendermaßen aus: Tippen Sie nun die neuen Zeilen ein und kompilieren Sie das Programm. Wenn Sie Probleme beim Kompilieren haben, können Sie sich das Projekt auch hier downloaden. Um effektiv etwas zu lernen, sollten Sie aber nur im äußersten Notfall das Projekt herunterladen.

Kapitel 4 6-LED Lauflicht Nach Bearbeitung der vorherigen Kapitel können Sie nun ein Projekt und Interrupt-Routinen erstellen. Desweiteren besitzen Sie einige Kenntnisse von der Initialisierung eines PICs, sowie vom Auswerten von Ein- und Ausgängen. In diesem Kapitel wird nun ein Lauflicht mit 6 LEDs erzeugt. Dafür muss ein neues Projekt erstellt werden. Die Einstellung im PIC-Wizard sind folgende: PIC16F84 4 MHz Taktfrequenz Oszillator-Option XT RS232 ausschalten WDT ausschalten Die 6 LEDs werden am Port B ( RB2 bis RB7 ) angeschlossen. Um das Lauflicht erzeugen zu können, müßten die einzelnen Pins immer auf High oder Low gesetzt werden. Jedoch führt die Methode mit "output_high()" und "output_low()" dazu, dass das Programm sehr groß und zu dem nicht effizient wird. Es gibt einen kleinen Trick um dieses zu vermeiden. Mit dem Befehl "struct" kann man Variablen verschiedenen Datentyps zu einer Einheit zusammenfassen. Zum Beispiel kann ein Port mit seinen Pins folgendermaßen zusammengefasst werden: struct port_b_layout // Port B int1 unused1; // unbenutzt int1 unused2; // unbenutzt int8 led:6; // RB2-RB7 6LEDs portb; // Zuweisung der Datentyp zur Einheit portb Mit dieser Anweisung wird eine Struktur mit der Bezeichnung portb definiert, die 3 Variablen ( unused1, unused2, led ) enthält. Die Variablen unused1 und unused2 werden als boolische Variablen definiert und led als Integer. Die Struktur als Ganzes kann mit portb angesprochen werden, eine Komponete mit Hilfe einer Punktnotation portb.led. Der Strukturbezeichnung "portb" weisen wir noch die Adresse des Port B am PIC-Mikrocontroller zu: #byte portb = 0x06 Um jetzt ein Lauflicht erzeugen zu können, muss eine Hilfsvariable "x" immer nach links bitweise verschoben werden. Dies geschieht mit dem Befehl "<<" ( nach rechts bitweise verschieben mit ">>" ). x = 1; x = x << 1; // bitweise nach links verschieben um 1 Stelle if ( x == 0b01000000 ) x = 1; Mit diesen Anweisung wird in der Initialisierung zuerst die Hilsvariable auf 1 gesetzt und danach in der Endlosschleife bis zur 6. Bitstelle nach links verschoben. Danach wird die Hilfsvariable erneut auf 1 gesetzt, um die Prozedur zu wiederholen.

Folgende Schaltung muss dafür erstellt werden: Die Betriebsspannung für PIC16F84 wird genau so angeschlossen, wie in den vorherigen Tutorials. Die Widerstände haben ein Wert von 1KOhm. Nach der Projekterstellung müssen folgende Zeilen im Hauptprogramm (C-Datei) hinzugefügt werden: void main() set_tris_b(0); // RB0 wird als Eingang definiert setup_counters(rtcc_internal,rtcc_div_2); x = 1; portb.led = x; // LEDs werden ausgegeben an Port B x = x << 1; // bitweise nach links verschieben um 1 Stelle if ( x == 0b01000000 ) x = 1; // 7. Bit wird überprüft delay_ms(200); // Pause von 200ms In die Headerdatei sollten meiner Meinung nach immer die Variablendeklaration und Unterprogramme geschrieben werden, damit ein gewißer Überblick über das Projekt erhalten bleibt. In die Headerdatei muss folgendes noch hinzugefügt werden: char x; struct port_b_layout // Port B short unused1; // unbenutzt short unused2; // unbenutzt int led:6; // RB2-RB7 6LEDs portb; // Zuweisung der Datentyp zur Einheit portb #byte portb = 6 Tippen Sie nun die neuen Zeilen ein und kompilieren Sie das Programm. Wenn Sie Probleme beim Kompilieren haben, können Sie sich das Projekt auch hier downloaden. Um effektiv etwas lernen zu können, sollten Sie sich jedoch nur im äußersten Notfall das Projekt herunterladen.