Inhaltsverzeichnis€¦ · Computertechnik J1 Mikrocontroller 1.5 Programm eingeben Doppelkick auf main.c des aktiven Projekts. Die Liste der Hilfsfunktionen in XMC1100-Lib finden

Computertechnik J1 Mikrocontroller

Inhaltsverzeichnis1 Eintwicklungsumgebung Dave4 Einführung.................................................................................3

1.1 Projekt anlegen......................................................................................................................31.2 Dateien zum Projekt hinzufügen............................................................................................51.3 Projekt mit neuem Namen kopieren.......................................................................................51.4 Aktives Projekt.......................................................................................................................51.5 Programm eingeben..............................................................................................................61.6 Compilieren (Übersetzen von C in Maschinensprache).........................................................71.7 Download...............................................................................................................................71.8 Debuggen..............................................................................................................................8

2 C lernen mit Programmbeispielen................................................................................................92.1 Lauflicht mit Schiebebefehl....................................................................................................92.2 Struktogramm........................................................................................................................92.3 Zählschleife mit FOR: Anzahl der Verschiebungen festlegen..............................................102.4 Tasterabfrage......................................................................................................................122.5 Verzweigung mit if und else.................................................................................................142.6 Bitabfragen und Verzweigungen bei der Waschmaschinensteuerung.................................142.7 Ampelsteuerung...................................................................................................................162.8 Externer Interrupt.................................................................................................................182.9 Schrittmotorsteuerung..........................................................................................................192.10 Analog-Digital-Converter....................................................................................................232.11 Spannungsmessung mit LCD-Ausgabe und sprintf-Funktion.............................................242.12 Gleitende Mittelwertbildung................................................................................................252.13 PWM-Signal mit FOR-Schleife und if.................................................................................272.14 PWM mit internen Timern und Hilfsfunktionen...................................................................282.15 I(U)-LED-Kennlinienschreiber............................................................................................29

3 Projekte......................................................................................................................................303.1 Leistungsmessung und Modell eines MPP-Trackers...........................................................303.2 Einstrahlungsmessgerät mit Solarzelle................................................................................323.3 1-Achs-Nachführung eines Solarpanels...............................................................................363.4 RGB-LEDs mit PWM steuern...............................................................................................393.5 Wandler Gleichspannung in Wechselspannung mit PWM...................................................403.6 Reaktionstester mit Timer-Zeitmessung...............................................................................453.7 Ultraschall-Abstandsmessung mit Modul SFR04.................................................................463.8 Drehzahlmessung mit Timer und ext. Interrupt....................................................................483.9 Schrittmotor als Sekundenanzeige mit Timerinterrupt..........................................................493.10 Kommunikation über den I2C-Bus: Port-Expander.............................................................523.11 Temperaturmessung mit dem I2C-Sensor DS1621............................................................543.12 Sinusausgabe über I²C-DAC PCF 8591.............................................................................573.13 Datenübertragung COM-Schnittstelle................................................................................59

4 Formelsammlung C/C++............................................................................................................614.1 Datentypen..........................................................................................................................614.2 Operatoren...........................................................................................................................614.3 Aufbau eines C-Programms.................................................................................................624.4 Schleifen..............................................................................................................................634.5 Programmverzweigungen....................................................................................................644.6 Verzweigung mit if................................................................................................................644.7 Fallauswahl mit switch.........................................................................................................654.8 Funktionen...........................................................................................................................66

5 Funktionsbibliothek für den Controller XMC1100........................................................................675.1 Verzögerungsfunktionen......................................................................................................675.2 Bit- und Byte Ein-/Ausgabe..................................................................................................67

C_Scipt_XMC1100.odt Seite 1Otto Bubbers

Technisches GymnasiumProfil Umwelttechnik


5.3 Analog-Digital Konverter......................................................................................................675.4 Pulsweitenmodulation PWM................................................................................................685.5 Externer Interrupt ................................................................................................................695.6 Timer...................................................................................................................................705.7 Funktionen für die LCD Anzeige..........................................................................................715.8 Funktionen zur Kommunikation............................................................................................71

6 XMC1100-Trainer.......................................................................................................................726.1 Pinbelegungen.....................................................................................................................726.2 Blockschaltbild.....................................................................................................................73

Vielen Dank an Reinhold Birk, Gottlieb-Daimler-Schule 2 für die Bereitstellung der Experimentierplatine und der Bibliothek XMC1100-Lib sowie das Expertenwissen in jeder Situation.




1 Eintwicklungsumgebung Dave4 Einführung

1.1 Projekt anlegenDie aktuelle Version DAVE4.x.x eignet sich gut für alle Aufgaben mit den XMC – Controllern. DAVE besteht aus einem frei verfügbaren GNU C-Compiler, eingebettet in eine „Eclipse“ Oberfläche.

Ein Download der jeweils aktuellen Version ist von der Webseite „www.infineon.com/dave“ möglich.

Beim Start des Programmesmuss zuerst ein „Workspace“angegeben werden. Dies ist einOrdner auf Ihrem PC, worinanschließend alle Programme,Bibliotheken … abgelegtwerden. Legen sie für denWorkspace einen Ordner an,welcher nicht über dasNetzwerk erreichbar ist, dieserhöht die Arbeits-geschwindigkeit.

In der Schule: Ordner TGUJ1auf dem Desktop. Nach derStunde auf eigenen Stickkopieren!

Nach der Angabe des„Workspace“ muss mit File → New → Dave-Project ein neues Projekt angelegtwerden. Wir arbeiten zuerst mit „Simple Main Project“ d.h. ohne Unterstützung von„DAVE-App’s“

Geben Sie einen sinnvollenProjektnamen z.B. mit Nummeran.

Achtung: keine Umlaute Ä,Ü

→ Next → Auswahl des Controllertyps :XMC1100 Series, in der Serie 2. von oben

→ Finish




Es wir ein Projekt erzeugt mit wichtigen Voreinstellungen und Bibliotheken und einem leeren Hauptprogramm main.c:

Wir arbeiten zunächst mit Hilfsfunktionen, da für den Anfänger der Zugriff auf die Komponenten des Controller (z.B. die Ports) „unanschaulich“ ist.

Diese Hilfsfunktionen sind in der Bibliothek XMC1100-Lib zusmmengefasst.



Endlosschleife

DoppelklickKurzbeschreibung einfügen

Nach dem Importieren der Bibliotheken mit File → Import:


1.2 Dateien zum Projekt hinzufügen

Links auf den Projektnamen klicken, dann:

File → Import → General → File System

→ Next

→ Browse

→ Ordner mit den hinzuzufügenden Dateien suchen

→ hinzuzufügende Dateien auswählen

XMC1100-Lib.c

XMC1100-Lib.h

→ Finish

Nun gehören die Hilfsfunktionen in der Bibliothek XMC1100.c

zum Projekt hinzu.

Im Programm kann man nach #include <XMC1100.h> darauf zugreifen.

1.3 Projekt mit neuem Namen kopieren

Rechtsklick auf Projektname → CopyRechtsklick auf freie Fläche unter den Projekten → Paste, neuen Projektnamen angeben

1.4 Aktives Projekt

Nur ein Projekt ist immer aktiv und wird übersetzt und downgeloadet.Rechtsklick auf den Projektname → Set Active Project




1.5 Programm eingeben

Doppelkick auf main.c des aktiven Projekts.

Die Liste der Hilfsfunktionen in XMC1100-Lib finden Sie z.B. duch Doppleklick auf XMC1100.h im Projekt.

Wenn Sie einen Teil der Funktion eingegeben haben, z.B.„port“ und dann <STRG><LEER> drücken, erhalten Sieeine Auswahl aller zur Verfügung stehenden Funktionen => auswählen durch Doppelklick => einzugebende Parameter werden angezeigt

Sobald Sie die Funktionen im Editor eingegeben haben und mit der Maus über den Text fahren, wird Ihnen die in der Datei XMC1100-Lib.c angegebene Erklärung angezeigt:




1.6 Compilieren (Übersetzen von C in Maschinensprache)

Compiler-Aufruf mit

Falls ein Fehler auftritt, wird dieser durch ein kleines, rotes Kreuz und einer Wellenlinie in der entsprechenden Zeile angezeigt. Wenn Sie mit der Maus über das Kreuz fahren, erscheint eine Fehlererklärung. Diese und alle weiteren Fehler sehen Sie auch im Consolen-Fenster unten.

Hier war Outp klein statt OUTP groß geschrieben.

1.7 Download!!Vor dem Download immer erst compilieren!!

Beim ersten Download des Programms mit

müssen Sie mit Doppelklick auf GDBSegger J-Link Debugging die Art desDownloads wählen, nichts weiter eintragen→ Run

Fall der Download auch nach USB-Steckerziehen und wieder verbinden underneutem Download nicht funktionierensollten, gehen Sie folgendermaßen vor:

Dieses Fenster erhalten sie jederzeit überden kleinen Pfeil neben grünen Pfeil →Run Configurations

Rechtsklick auf den Projektnamen unterGDB Segger J-Link → Delete

Dann wieder Doppelklick auf GDB SeggerJ-Link → Run




1.8 Debuggen

Debugger öffnen mit

Beim ersten Mal öffnet sich wie beim Download ein Fester, bei dem die Kommunikationsart gewählte werden muss mit Doppelklick auf GDB Segger J-Link Debugging.

Die Fenster werden nun im Debugger-Modus angeordnet.

Wichtig: Vor erneutem Download und bei Programmänderung: Debugger immer beenden

Zur Änderung des Programms vom Debugger in die IDE wechseln:



Step into (F5)Einzelne

Schritte der Funktion

ausführen

Step over (F6)Funktion in

einem Schritt ausführen

Debugger beenden

Normale Programm-ausführung

starten Programm-ausführung

anhalten

Stop Return (F7)

Aus Funktion heraus-

springen, dann stopp

Breakpoints überspringen

Pfeil links und farblich hinterlegte Zeile: Dieser Befehl wird als nächstes ausgeführt.Stoppstelle einfügen: Rechtsklick auf linken Rand → Toggle Breakpoint

Muster ausgeben

Startmuster festlegen

Zeitverzögerung

Muster links schieben

Ausgabeport initialisieren


2 C lernen mit Programmbeispielen

2.1 Lauflicht mit Schiebebefehl2.1.1 Konzept

Eine leuchtende LED an P0 „soll von rechts nach links geschoben werden“, 1 = leuchtende LED.0000 0000 0000 0001 → 0000 0000 0000 0010 → 0000 0000 0000 0100 → usw. Dazu wird eine Variable „muster“ definiert, in der das aktuelle Ausgabemuster gespeichert wird.unit16_t muster;Zu Beginn muß das gewünschte Ausgabemuster in die Variable geschrieben werden:muster = 1; // als Dualzahl 0000 0000 0000 0001Nach der Ausgabe wird dieses Muster um eine Stelle nach links verschobenmuster << 1; Allein dieser Befehl reicht nicht, denn das um eine Stelle verschobene Muster muss anschließend wieder gespeichert werden:muster = muster << 1; // nach dem ersten Schieben steht nun 0000 0000 0000 0010 in der

// Variablen, nach dem nächsten Ausführung 0000 0000 0000 0100 usw.

2.1.2 Programm Lauflicht#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint16_t muster; // Speichervariable für Lauflichtmusterint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren muster = 1; // als Dualzahl 0000 0000 0000 0001(an LEDs sichtbar) while(1U) // Endlosschleife, immer bei Controllern {

port_write(P0,muster); // Muster an Port0 ausgeben delay_ms (100); // Zeitverzoegerung 500ms muster = muster << 1; // Muster um 1 Stelle nach links schieben // 0000 0000 0000 0010 // 0000 0000 0000 0100 usw. //muster = ((muster&0x8000)>>15)|(muster<<1); // Ringschieben

}//while}//main

2.2 StruktogrammEine grafische Beschreibung bietet das Struktogramm, in dem dieStruktur des Programms deutlich wird. Die Aktionen werden imKlartext angegeben. Hier werden keine einzelnen Befehlebeschrieben, sondern die Wirkungsweise des Programms erklärt.Die rot gepunkte Linie gehört nicht zum Struktogramm, Sie sollzeigen, in welcher Reihenfolge das Programm abgearbeitet wirdund wie das Struktogramm zu lesen ist.

Das höchstwertigste, linke Bit „geht beim Schiebevorgangverloren“. Dies hat zur Folge, dass nach 16 mal schieben diegesamte Information einer 16-Bit-Variablen „herausgeschoben“wurde und verloren geht. Alle LEDs sind dann aus.Von rechts wird immer eine 0 „nachgeschoben“.

Mit folgender Befehlsfolge können wir das Bit, das links „rausfällt“, rechts „wieder reinschieben“: muster = ((muster & 0x8000)>>15) | (muster<<1)

Diese Befehlsfolge können wir erst später verstehen. (&, | sind bitweise logische Verknüpfungen.)



Endlosschleife



2.3 Zählschleife mit FOR: Anzahl der Verschiebungen festlegen2.3.1 Aufgabe und Konzept

Das Lauflichtmuster soll periodisch 10 mal nach links undanschließend 10 mal nach rechts geschoben werden. Dazu isteine Zählschleife nowendig.

Jede Zählschleife benötigt eine Zählvariable, die zuvor definiertwerden muss:uint16_t z; // Zählvariable

Die Zählvariable wird z genannt und ist vom Typ vorzeichenloseganze Zahl mit 16 Bit: uint16_t

Die Zählschleife ist folgendermaßen aufgebaut:for (z=0; z<10; z++)

Dabei bedeuten die Angaben folgendes: z beginnt bei 0 zu zählen(z=0) und wird solange die Bedingung z<10 erfüllt ist bei jedemSchleifendurchlauf um eins erhöht (z++).

Rückwärts zählen wird so angegeben werden: for (z=10; z>0; z--)

Die Befehle, die in der Schleife auszuführen sind, werden mit { }eingeschlossen.

for (z=0;z<10;z++) // 10 mal schieben { port_write(P0,muster); // Muster an Port0 ausgeben delay_ms (100); // Zeitverzoegerung 100ms muster = muster << 1; // Muster um 1 Stelle nach links }

2.3.2 Gesamtes Programm/* Lauflicht mit 1 LED, FOR-Befehl kennen lernen */#include <XMC1100-Lib.h>// Hilfsfunktionen fuer XMC1100

uint16_t z,muster; // Laufvariable, Speichervariable für Lauflichtmusterint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren muster = 1; // als Dualzahl 0000 0000 0000 0001 while(1U) // Endlosschleife, immer bei Controllern { for (z=0;z<10;z++) // 10 mal schieben { port_write(P0,muster); // Muster an Port0 ausgeben delay_ms (100); // Zeitverzoegerung 100ms muster=muster<<1; // Muster um 1 Stelle nach links } for (z=0;z<10;z++) // 10 mal schieben { port_write(P0,muster); // Muster an Port0 ausgeben delay_ms (100); // Zeitverzoegerung 100ms muster=muster>>1; // Muster um 1 Stelle nach rechts } }//while}//main




Muster ausgeben

Zeitverzögerung


Zähle von 0 bis 9

Muster ausgeben

Zeitverzögerung

Muster rechts schieben

Zähle von 0 bis 9

Zähle von 0 bis 9

Endlosschleife



2.3.3 Variablenwert der Zählschleife anzeigen

Statt des Lauflichtmusters soll nun der Wert der Zählschleifeangezeigt werden. Setzen Sie das Struktogramm in einC-Programm um und testen Sie es.

/* Zaehlvariable ausgeben, FOR-Befehl kennen lernen */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint16_t z; // Zaehlvariableint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren while(1U) // Endlosschleife, immer bei Controllern {

for (z=0;z<15;z++) // Zaehle aufwaerts von 0 bis 14 { port_write(P0,z); // Zaehlvariable an Port0 ausgeben delay_ms (500); // Zeitverzoegerung 500ms } for (z=15;z>0;z--) // Zaehle abwaerts von 15 bis 1 { port_write(P0,z); // Muster an Port0 ausgeben delay_ms (500); // Zeitverzoegerung 500ms }

}//while}//main

Erklären Sie, welche Wirkung erzeugt wird, wenn aufwärts von 0 bis 14 und abwärts von 15 bis 1 gezählt wird.



Zählerstand ausgeben

Zeitverzögerung

Zähle von 0 bis 14

Zählerstand ausgeben

Zeitverzögerung

Zähle von 15 bis 1

Endlosschleife


2.4 TasterabfrageMöchte man einen Taster oder Sensor abfragen, so muss der entsprechende Pin als Eingang deklariert werden mit void bit_init(uint8_t port, uint8_t bitnr, uint8_t direction) Beispiel: bit_init(P2, 2, INP);

Die Abfrage (Einlesen) eines einzelnen Pins erfolgt mit uint8_t bit_read(uint8_t port, uint8_t bitnr) Beispiel: wert = bit_read (P2, 2);

Die Deklaration eines Pins als Ausgang erfolgt wieder mitvoid bit_init(uint8_t port, uint8_t bitnr, uint8_t direction) Beispiel: bit_init(P0, 2, OUTP);

Die Ausgabe an ein einzelnes Pin ermöglichtvoid bit_write(uint8_t port, uint8_t bitnr, uint8_t value) Beispiel: bit_write(P0, 2, 1);

2.4.1 Programmbeispiel Tasterzustand kopieren und anzeigen

/* Tasterabfrage, Bitein- und Ausgabe kennen lernen * P2.9 (Taster) wird nach P0.1 kopiert */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint8_t taster; // Zustand Taster merkenint main(void) // Hauptprogramm{ bit_init(P2, 9, INP); // P2.9 (Taster) auf Eingabe bit_init(P0, 1, OUTP); // P0.1 (Anzeige) auf Ausgabe while(1U) // Endlosschleife, immer bei Controllern {

taster = bit_read(P2,9); // (lowaktiver) Taster P2.9 bit_write (P0,1,taster); // nach P0.1 kopieren

}//while}//main

2.4.2 Vereinfachung

Wenn der Zustand des Tasters nicht in der Variablen taster gespeichert werden braucht, kann manden mit der Funktion bit_read gelesenen Wert direkt mit bit_write ausgeben:

bit_write (P0,1,bit_read(P2,9)); // Taster P2.9 nach P0.1 kopieren

Der Taster ist lowaktiv angeschlossen, was bedeutet, dass bei Tastendruck ein low (0) erzeugt wird und der ungedrückte Taster ein high (1) liefert. Soll bei Tastendruck die LED an P0.1 leuchten, so muss der Zustand des Tasters invertiert werden:

bit_write (P0,1,~bit_read(P2,9)); // Taster P2.9 invertiert nach P0.1 kopieren




Muster ausgeben

Zeitverzögerung


Zähle von 0 bis 9

Muster ausgeben

Zeitverzögerung

Muster rechts schieben

Zähle von 0 bis 9

Zähle von 0 bis 9


Solange gedrückt

Solange gedrückt

Endlosschleife


2.4.3 Lauflicht unterbrechen wenn Taster gedrückt

Das Lauflicht 2.3.2 soll abgeändert werden.Solange der Taster P2.9 gedrückt ist, soll das Lauflicht anhalten.

/* Tasterabfrage, Eingabe-Befehl kennen lernen */#define gedrueckt 0#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint16_t z,muster; // Laufvariable, Speichervariable für Lauflichtmusteruint8_t taster;int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren bit_init(P2, 9, INP); // P2.2 auf Eingabe bit_init(P1, 0, OUTP); // P1.0 auf Ausgabe muster = 1; // als Dualzahl 0000 0000 0000 0001(an LEDs sichtbar) while(1U) // Endlosschleife, immer bei Controllern { for (z=0;z<10;z++) // 10 mal schieben { port_write(P0,muster); // Muster an Port0 ausgeben delay_ms (100); // Zeitverzoegerung 100ms muster=muster<<1; // Muster um 1 Stelle nach links do taster = bit_read (P2,9);// Taster links while (taster == gedrueckt); // nichts tun solange Taster gedrückt } for (z=0;z<10;z++) // 10 mal schieben { port_write(P0,muster); // Muster an Port0 ausgeben delay_ms (100); // Zeitverzoegerung 100ms muster=muster>>1; // Muster um 1 Stelle nach rechts do taster = bit_read (P2,9); // Taster links while (taster == gedrueckt); // nichts tun solange Taster gedrückt } }//while




2.5 Verzweigung mit if und elseWenn der Taster P2.2 gedrückt ist, sollen alle 14 LEDs anP0 an gehen. Wenn man den Taster wieder loslässt, gehendie LEDs wieder aus.

Das Programm muss also je nach Zustand des Tasters zweiverschiedene Dinge tun, dies nennt man eine Verzweigung,die man mit if und else programmiert.

/* Verzweigung mit if, alle LEDs P0 mit Taster P2.2 einschalten */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100#define gedrueckt 0int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren bit_init(P2,2,INP); while(1U) // Endlosschleife, immer bei Controllern { if (bit_read(P2,2) == gedrueckt) port_write(P0,0x3FFF);

// Taster gedrückt -> 14 LEDs an else port_write(P0,0); // sonst LEDs aus }//while}//main

2.6 Bitabfragen und Verzweigungen bei der Waschmaschinensteuerung

Die folgenden Aufgaben simulieren Teile des Ablaufs eines Waschmaschinenprogramms. Skizzieren Sie zuerst immer den Programmablauf mit Hilfe eines Struktogramms. Zur sensorabhängigen Steuerung werden die Melder des Modells wie Schalter, Temperaturmelder .... eingelesen mit bit_read() und je nach Zustand eine Aktion mit einem bit_write ()-Befehl ausgelöst. Verwenden Sie Abkürzungen, z.B. #define Grad60 5, damit das Programm besser lesbar wird, z.Bif (bit_read (P0,Grad60) == an) Heizung = aus;



Initialisierungen 14 LEDs, Taster

EndlosschleifeTaster gedrückt?

Alle LEDs an Alle LEDs aus

ja nein

P0.11 P0.10 P0.9 P0.8 P0.7 P0.6 P0.5 P0.4 P0.3 P0.2 P0.1 P0.0P H Mschnell M Y S6 S5 S4 S3 S2 S1

Pumpe Heizung Mschnell Motor Zulauf Grad60 Grad90 Fuelloben Fuellunten Tempwahl Schaltein


2.6.1 Temperaturregelung

Schreiben Sie ein Programm, das die Regelung der Temperatur nachbildet. Die Heizung wird solange mit log. 1 angesteuert, bis am Modell der Temperatursensor 60° meldet. Ist die Temperatur erreicht, soll die Heizung wieder abgeschaltet werden. Die Heizung bleibt solange abgeschaltet, bis die Temperatur unter 60° fällt (S6).

2.6.2 Temperaturregelung für 2 Waschprogramme

Der Auswahlschalter 60° / 90° (S2) soll zusätzlich abgefragt werden (log. 1 bei 90°C). Je nach Einstellung soll die Temperatur auf 60° oder auf 90° geregelt werden.

2.6.3 Ein-Aus-Funktion

3. Bauen Sie die Funktion EIN/AUS (S1) ein. Schalten Sie bei “AUS“ alle Ausgänge auf 0. 4. Vor Beginn der Heizungsregelung soll der Wasserzulauf bis zu dem Pegel (S3) gesteuert werden. Mit der Temperaturregelung soll auch der Motor (M) aktiviert werden.Dieser darf aber mit der Temperaturregelung nicht ständig aus- und eingeschaltet werden.

Programme folgen in Kürze




2.7 Ampelsteuerung2.7.1 Einfaches Programm nur mit Ausgabebefehlen und Zeitverzögerungen

Die obenstehende Ampel soll so programmiert werden, dass sich ein Zyklus für Hauptstraße (H2), Nebenstraße (H1) und Fußgängerampel ergibt.Schließen Sie die Ampel wie folgt an und beginnensie mit der Ampelphase „H2 grün“.

Verwenden Sie zunächst Port-Ausgabe-Befehle und die Zeitverzögerung delay_ms(). Unsere Entwicklungsumgebung lässt die Angabe von Bitkombinationen als Binärzahl zu. Dadurch können Sie sehr leicht die Ampelmuster erkennen: port_write(P0,0b10001100);

2.7.2 Ampelphasen abgelegt in einer Tabelle



Ampelphasen

Nr H3R H3G H2R H2Y H2G H1R H1Y H1G0 1 0 0 0 1 1 0 0 , 0b10001100,1 1 0 0 1 0 1 0 0 , 0b10010100,2 1 0 1 0 0 1 0 0 , 0b10100100,3 1 0 1 0 0 1 0 0 , 0b10100100,4 0 1 1 0 0 1 0 0 , 0b01100100,5 0 1 1 0 0 1 1 0 , 0b01100110,6 0 1 1 0 0 0 0 1 , 0b01100001,7 0 1 1 0 0 0 0 1 , 0b01100001,8 0 0 0 0 0 0 0 0 , 0b00000000,9 0 0 0 0 0 0 0 0 , 0b00000000,

10 0 0 0 0 0 0 0 0 , 0b00000000,11 0 0 0 0 0 0 0 0 , 0b00000000,12 0 0 0 0 0 0 0 0 , 0b00000000,13 0 0 0 0 0 0 0 0 , 0b00000000,14 0 0 0 0 0 0 0 0 , 0b00000000,15 0 0 0 0 0 0 0 0 , 0b00000000,

=VERKETTEN("0b";E4;F4;G4;H4;I4;J4;K4;L4;M4)

P0.7 P0.6 P0.5 P0.4 P0.3 P0.2 P0.1 P0.0H3R H3G H2R H2Y H2G H1R H1Y H1G


Nach Doppelklick auf die Tabelle, können Sie Ampelphasen eintragen. In der rechten Spalte wird automatisch die entsprechende binäre Darstellung erzeugt. Jede Zeile dauert 1s, damit muß nach 16s ein Zyklus beendet sein. Im C-Programm holen Sie dann jede Sekunde eine neue Zeile aus der Tabelle und geben diese an die Ampel aus.

Eine solche Tabelle heißt in C „Array“ und wird folgendermaßen definiert: uint16_t ampel[16];

Wenn Sie, wie bei der Ampel, feste Werte in das Array schreiben wollen, geben sie diese bei der Initialisierung an: uint16_t ampel [ ] = {2,9,4,6};

In unserem Fall ist es sinnvoll, die Werte untereinander zu schreiben, kopieren Sie dazu einfach die rechte Spalte der ausgefüllten Tabelle (vorhergehende Seite) in ihr Programm:

uint16_t ampel [ ] = { // Tabelle der Ampel-Anzeigen0b10001100,usw.0b10001100};

Der Zugriff auf die einzelnen Werte erfolgt durch wert = ampel [0]); Die Zahl in der eckigen Klammer gibt an, auf welchen Wert (welche Zeile) der tabelle sie zugreifen möchten.

In Ihrem Ampelprogramm verwenden Sie nun eine For-Schleife, in der Sie nacheinander die Ampel-Bitmuster aus der Tabelle holen und ausgeben port_write (P0, ampel [i]);

Jede Ausgabe erfolgt gleich lang delay_ms (1000); // 1 Sekunde

2.7.3 Ampelphasen in einer Tabelle mit Angabe der Zeitdauer

Nun soll die Zeitdauer einer Ampelphase nicht durch mehrere Zeilen mit gleichem Bitmuster erfolgen, sondern jedes Bitmuster kommt nur einmal vor, gefolgt von der Zeitdauer dieser Phase.

uint16_t ampel [ ] = { // Tabelle Ampel-Anzeigen mit Zeitdauer0b10001100,1, // Phase 00b10010100,1, // Phase 1

Diese Tabelle erzeugt Ihnen wieder die kopierfähige rechte Spalte für das C-Programm.

2.7.4 Grünanforderung

Die Integration einer Grünanforderung durch Tastendruck eines Fußgängers oder die Induktionsschleife in der Straße unter einem Auto gestaltet sich schwierig aus folgenden Gründen.Die Abarbeitung der bisher erstellten Programme befindet sich aus Controllersicht zu 99% innerhalb einer Zeitschleife. Wenn diese abgearbeitet wird, kann nicht gleichzeitig mit bit_read() abgefragt werden, ob eine Grünanforderung vorliegt. Die Grünanforderung wird nicht gespeichert und kann daher verloren gehen, z.B. wenn der Fußgänger die Taste wieder loslässt, bevor das Programm die Zeitschleife verlassen hat. Darum wählen wir ein anderes Konzept:



AmpelphasenP0.7 P0.6 P0.5 P0.4 P0.3 P0.2 P0.1 P0.0

Nr H3R H3G H2R H2Y H2G H1R H1Y H1G Zeit in s0 1 0 0 0 1 1 0 0 , 1 , // Phase 0 0b10001100,1, // Phase 01 0 0 0 0 0 0 0 0 , 1 , // Phase 1 0b00000000,1, // Phase 12 0 0 0 0 0 0 0 0 , 1 , // Phase 2 0b00000000,1, // Phase 23 0 0 0 0 0 0 0 0 , 1 , // Phase 3 0b00000000,1, // Phase 34 0 0 0 0 0 0 0 0 , 1 , // Phase 4 0b00000000,1, // Phase 45 0 0 0 0 0 0 0 0 , 1 , // Phase 5 0b00000000,1, // Phase 56 0 0 0 0 0 0 0 0 , 1 , // Phase 6 0b00000000,1, // Phase 67 0 0 0 0 0 0 0 0 , 1 , // Phase 7 0b00000000,1, // Phase 78 0 0 0 0 0 0 0 0 , 1 , // Phase 8 0b00000000,1, // Phase 89 0 0 0 0 0 0 0 0 , 1 , // Phase 9 0b00000000,1, // Phase 9

10 0 0 0 0 0 0 0 0 , 1 , // Phase 10 0b00000000,1, // Phase 10

=VERKETTEN("0b";E4;F4;G4;H4;I4;J4;K4;L4;M4)


2.8 Externer Interrupt2.8.1 Prinzip

Wenn der Interrupt freigegeben ist,löst ein Ereignis (hier steigendeFlanke an P2.) einen Interrupt aus.Das Hauptprogramm main() wirddann unterbrochen und einespezielle Funktion wird bearbeitet.Diese nennt man Interrupt-Service-Routine, bei unseremController sind dies vordefinierte Interrupt-Request-Handler (IRQHandler). Nach Beendigung dieser Funktion wird das Hauptprogramm an der unterbrochenen Stelle fortgesetzt.

Auf unserer Platine löst ein Signalwechsel von 0 nach 1 (steigende Flanke) an P2.9 einen Interruptaus und ERU0_3_IRQHandler wird bearbeitet. Da die Taster lowaktiv sind, wird der Interrupt beimLoslassen der Taste ausgelöst.

Ein Signalwechsel von 1 nach 0 (abfallende Flanke) an P2.10 (Taster drücken) löst auch einen Interrupt aus und ERU0_2_IRQHandler wird bearbeitet.

2.8.2 Testprogramm/* Test externer Interrupt * abfallende Flanke Taster P2.9 (Taster drücken, weil lowaktiv) → binär aufwärts zählen * ansteigende flanke Taster P2.10 (Taster loslassen, weil lowaktiv) → binär abwärts zählen */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100

uint8_t zaehler;

int main(void) // Hauptprogramm{ ext_interrupt_init(); // externe Interrupts initialisiseren ext_interrupt_enable1 (); // Int. an P2.9 freigeben ext_interrupt_enable2 (); // Int an P2.10 freigeben port_init(P0,OUTP); // LEDs an P0 -> Ausgabe while(1) // Endlos {

port_write(P0,zaehler); // dualer Zählerstand an LEDs }//while}//main

// Interrupt-Service-Routinen ( ISR)void ERU0_3_IRQHandler (void ) // P2.9 steigende Flanke{ zaehler++;}void ERU0_2_IRQHandler(void) // P2.10 fallende Flanke{ zaehler--;}

2.8.3 Grün-Anforderung durch Fußgänger oder Induktionsschleife der Nebenstraße

Kopieren Sie das Programm 2.7.3 in ein neues Projekt und ergänzen Sie es durch eine interruptgesteuerte Grünanforderungen durch Fußgänger und Autos der Nebenstraße.

Lösungshinweis: Solange keine Anforderung vorliegt, bleibt das Programm bei Ampelphase 0 stehen. In den Interrupt-Routinen wird eine Variable uint8_t anforderung zu 1 gesetzt. Dann laufen die Ampelphasen ab. Zeigen Sie die Anforderung durch die LED P1.4 an.



while (1u) //Hauptprogrammschleife { }

// Initialisierungen// Interruptfreigabe

void ERU0_3_IRQHandler (void ) { }

P2.9

Interruptfreigabe


2.9 Schrittmotorsteuerung2.9.1 Funktionsweise

Aufbau: Rotor (Läufer) mit Permanent-Magneten, Spulen L0 bis L3 (4 Stränge) erzeugen Magnetfelder in den Polpaaren, externe Transistoren zur Stromverstärkung notwendig

Erzeugung der Drehbewegung im Vollschrittbetrieb durch 4 Bitkombinationen:

Halbschrittbetrieb: Die Zwischenschritte werden durch Abschalten einer Spule erzeugt.



+Ub

+Ub

S

N

1

1

S

N

NS

1 0 0 1

Position1

L0

L1L0L3 L2 L1

L3L2

1

RechtsdrehungRechtsdrehung

+Ub

+Ub

NS

1

S

N

S

N

1

S

N

Position2

L0

L1L0L3 L2 L1

1 0 0 1

L2 L3

1 0 1 0

21


+Ub

+Ub

S

N1

S

N

1

N S

S

N

0 1 1 0

L0

L1L0L3 L2 L1

1 0 0 1

L2 L3

1 0 1 0

Position3

3

1 2


+Ub

+Ub1

N S

S

N

0 1 1 0

L0

L1L0L3 L2 L1

1 0 0 1

L2 L3

1 0 1 0

Position4

3

1 2

S

N

1

4

0 1 0 1

S

N


+Ub

+Ub

1

S

N

NS

1 0 0 1

Position1

L0

L1L0L3 L2 L1

L3L2

1

Halbschritt-BetriebHalbschritt-BetriebH

1 0 0 0

SN+Ub

+Ub

S

N

1

1

S

N

NS

1 0 0 1

Position1

L0

L1L0L3 L2 L1

L3L2

1



Die Änderung der Drehrichtung erfolgt durch die Änderung der Reihenfolge der Bitkombinationen:

2.9.2 Anschluss des Schrittmotors

2.9.3 Testprogramm/* Schrittmotorsteuerung Anschluss an P0.4 bis P0.7 damit P0.0 bis P0.3 (Dip-Schalter) frei bleibt*/

#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren while(1U) // Hauptprogramm-Endlosschleife {

port_write (P0,0b01010000); // Rechtsdrehung delay_ms (50); port_write (P0,0b01100000); // durch 4 Bitkombinationen delay_ms (50); port_write (P0,0b10100000); // delay_ms (50); port_write (P0,0b10010000); // delay_ms (50);

}//while}//main



0 1 0 1

0 1 1 0

L0L3 L2 L1

1 0 0 1

1 0 1 01 0 0 0

0 0 1 0

0 1 0 0

0 1 0 1

Halbschritt-BetriebHalbschritt-BetriebVollschritt-BetriebVollschritt-Betrieb

0 1 0 1

0 1 1 0

L0L3 L2 L1

1 0 0 1

1 0 1 0R

ech

tsd

reh

un

g

Lin

ksd

reh

un

g


2.9.4 Schrittmotorsteuerung mit Umschaltung Rechts-/Linkslauf

/* Schrittmotorsteuerung mit Starttaster P2.2 und Linkslauf P2.9 Anschluss an P0.4 bis P0.7 damit P0.0 bis P0.3 (Dip-Schalter) frei bleibt */

#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100#define motor P0 // Motorport#define schritt1 0b01010000 // Bitkombinationen#define schritt2 0b01100000#define schritt3 0b10100000#define schritt4 0b10010000#define zeitkonst 50 // Zeitverzögerung für Drehgeschwindigkeit#define taster P2 // Tasterport#define start 2 // P2.2 ganz rechts für Start#define linkslauf 9 // P2.9 ganz links für Linkslauf#define gedrueckt 0 // lowaktive Taster

int main(void) // Hauptprogramm{ port_init(motor,OUTP); // Motorport auf Ausgabe programmieren bit_init(taster,start,INP); // Tasterpin auf Eingabe bit_init(taster,linkslauf,INP); // Tasterpin auf Eingabe while(1U) // Hauptprogramm-Endlosschleife {

while (bit_read (taster,start) != gedrueckt); // warten auf Startif (bit_read (taster,linkslauf) == gedrueckt) //{ port_write (motor,schritt4); // Linkssdrehung delay_ms (zeitkonst); port_write (motor,schritt3); // durch 4 Bitkombinationen delay_ms (zeitkonst); port_write (motor,schritt2); // delay_ms (zeitkonst); port_write (motor,schritt1); // delay_ms (zeitkonst);}//ifelse // Taster Linkslauf nicht gedrückt{ port_write (motor,schritt1); // Rechtsdrehung delay_ms (zeitkonst); port_write (motor,schritt2); // durch 4 Bitkombinationen delay_ms (zeitkonst); port_write (motor,schritt3); // delay_ms (zeitkonst); port_write (motor,schritt4); // delay_ms (zeitkonst);}//else

}//while}//main




2.9.5 Schrittmotorsteuerung mit Tabelle

//Deklaration der Variablenuint8_t schritt [ ] = {schritt1,schritt2,schritt3,schritt4};

// Array, globale Variable für die 4 Schritteuint8_t z=0; // globale Zählvariable für die Schritte

//Schleife im Hauptprogramm für Rechtsdrehung, 4 Schritte ausgeben

for (z=0;z<4;z++) { port_write (motor,schritt [z]); // Rechtsdrehung delay_ms (50); } // for

Die 8-Bit-Variable schritt [ ] ist ein Array. Man kann sich dies vorstellenals „einen Schrank mit mehreren Schubladen“, die durchnummeriertsind. Der Zugriff auf die einzelnen Schubladen geschieht durch denVariablennamen, gefolgt von der „Schubladennummer“ in eckigenKlammern, z.B. schritt [2].Mit schritt [ ] = {schritt1,schritt2,schritt3,schritt4} werden die unter #define schritt1 0b01010000 usw. definierten Zahlen in die „Schubladen“ geschrieben. In ein Array kann man mehrere Werte in einer Schleife abspeichern oder zurückholen.

Mit dem %-Operator ist es einfach möglich, eineArt Zähler von 0 bis 4 zu erstellen: während ndurch den ++ Operator von 0 bis 255 zählt, kanndas Ergebnis n % 4 nacheinander nur die 4Werte 0, 1, 2, 3 annehmen.

//Verbesserung: nun ist die Ausgabe von beliebig vielen Schritten möglichwhile(1U) // Hauptprogramm-Endlosschleife {

while (bit_read (taster,start) != gedrueckt); // warten auf Startif (bit_read (taster,linkslauf) == gedrueckt) z--; else z++; //port_write (motor,schritt [z % 4]); // Bitkombination für Schritt ausgeben// Anmerkung: z % 4 ist der Rest, der bei z/4 entsteht, also 0 oder 1 oder 2 oder 3delay_ms (zeitkonst);

}//whileNun soll eine eigene Funktion definiert werden, die dann im Hauptprogramm aufgerufen werden kann: motordrehung (links,20,zeitkonst); // 20 Schritte nach links

void motordrehung (uint8_t richtung, uint8_t schrittzahl, uint8_t geschwindigkeit)



nRechnung

n / 4

Ergebnis mit Ganzzahl und Rest

C-Berechnungn / 4

→ GanzahligesErgebnis

C-Berechnungn % 4

→ Rest

0 0 / 4 = 0 Rest 0 0 / 4 → 0 0 % 4 → 0

1 1 / 4 = 0 Rest 1 1 / 4 → 0 1 % 4 → 1

2 2 / 4 = 0 Rest 2 2 / 4 → 0 2 % 4 → 2

3 3 / 4 = 0 Rest 3 3 / 4 → 0 3 % 4 → 3

4 4 / 4 = 1 Rest 0 4 / 4 → 1 4 % 4 → 0

5 5 / 4 = 1 Rest 1 5 / 4 → 1 5 % 4 → 1

6 6 / 4 = 1 Rest 2 6 / 4 → 1 6 % 4 → 2

7 7 / 4 = 1 Rest 3 7 / 4 → 1 7 % 4 → 3

8 8 / 4 = 2 Rest 0 8 / 4 → 2 8 % 4 → 0

9 9 / 4 = 2 Rest 1 9 / 4 → 2 9 % 4 → 1

... ... ... ... ...

254 254 / 4 = 63 Rest 0 254 / 4 → 63 254 % 4 → 2

255 254 / 4 = 63 Rest 1 254 / 4 → 63 255 % 4 → 3

schritt 1schritt 2

schritt 4schritt 3

Nr 0Nr 1Nr 2Nr 3

[0]


2.10 Analog-Digital-Converter2.10.1 Prinzip

Mit der Funktion adc_init(); werden die Analog-Digital-Converter im Contoller initialisiert.

Die Funktion adc_wert = adc_in(0) holt einen convertierten 12-Bit-Wert vom Analog-Eingang 0.

Mit port_write (P0,adc_wert) wird dieser Wert an den LEDs an P0 angezeigt.

Am Eingang AN0 ist ein Poti angeschlossen, das analoge Werte zwischen 0V und 5V liefern sollte.Ist das Poti in der Stellung <ganz links>, sollte es 0V liefern und alle 12 LEDs sollten aus sein. Dreht man das Poti langsam, so steigt die Spannung und der angezeigte Zahlenwert ebenfalls. Es sieht so aus, als ob die LEDs „dual hochzählen“. Bei der Stellung <ganz rechts> sollte das Poti 5V liefern. Die 5V entstammen der USB-Schnittstelle und werden nicht ganz erreicht. Bei 5V würde man die Zahl 212 -1= 4095 dez = 1111 1111 1111 dual, also 12 leuchtende LEDs sehen.

Beim Programmtest sieht man, dass weder die 0V noch die 5V-Grenze erreicht wird.

/* Analog-Digital-Converter Poti an A0 liefert Wert zwischen fast 0V und fast 5V */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint16_t adc_wert; // Wert vom AD-Converter 16 Bit unsignedint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren adc_init(); // Analog-Digital-Converter initialisieren while(1U) // Endlosschleife, immer bei Controllern {

//adc_wert = adc_in(0); // 12-Bit-Wert von linkem Poti an A0 holen adc_wert = adc_in(0)>>4; // 8-Bit-Wert von linkem Poti an A0 holen

port_write (P0,adc_wert); // ausgeben an LEDs }//while}//mainOft benötigt man nur eine Auflösung des ADC von 8-Bit statt 12-Bit. Dann kann man einfach den adc-Wert um 4 Stellen nach rechts verschieben: Der 12-Bit-Wert 1111 1111 1111 um 4 nach rechts verschoben ergibt den 8-Bit-Wert 1111 1111: adc_wert = adc_in(0)>>4;

2.10.2 LCD-Anzeige mit Hilfsfunktionen/* ADC-Test mit LED und LCD-Ausgabe */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100

uint16_t adc_wert; // Wert vom AD-Converter 16 Bit unsignedint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe adc_init(); // Analog-Digital-Converter initialisieren lcd_init(); // LC-Display initialisieren while(1U) // Endlosschleife, immer bei Controllern {

adc_wert = adc_in(0); // Wert vom ADC port_write(P0,adc_wert); // ADC-Wert an LEDs ausgeben lcd_setcursor (2,3); // 2. Zeile, 3. Spalte lcd_print ("ADC:"); lcd_int(adc_wert); // AD-Wert anzeigen lcd_print ("dez"); delay_ms (200); // ruhigere Anzeige

}//while}//main




2.11 Spannungsmessung mit LCD-Ausgabe und sprintf-Funktion2.11.1 12-Bit-Auflösung

Der Analog-Digital-Converter hat eine Auflösung von 12 Bit, daher liefert er Zahlen zwischen 0 und212-1, also 212 = 4096 Werte. Der größtmögliche Spannungswert 5V entspricht der Zahl 4096. Dies wird bei der Umrechnung des ADC-Werts in eine Spannung berücksichtigt: u = adc_wert * 5.0/4096;Die Variable u muss eine Kommazahl sein, C-Typ float.

Achtung: Wenn Sie u = adc_wert * 5/4096; schreiben, rechnet C auf der rechten Seite mit ganzen Zahlen und weist diese u zu. Sie sehen also 0.000 oder 1.000 oder 2.000 oder…Auf der rechten Seite muss also eine float-Zahl stehen, z.B. u = adc_wert * 5.0/4096; oder Siegeben explizit an, dass bitte in float gerechnet werden soll: u = (float) adc_wert * 5/4096;

2.11.2 Formatierte Textausgaben mit sprintf

Mit der Funktion sprintf können Sie Variablentypen formatieren und Werte in Texte einfügen um sieanschließend mit lcd_print an das LC-Dispaly auszugeben.

sprintf (lcdtext,"U = %4.3f V",u); // Text erzeugen, Spannung mit 4 Stellen, 3 Nachkommast. lcd_print (lcdtext); // anzeigen

Anzeigebeispiel: U = 4.123 V

Bedeutung: An der Stelle im Text, an der % erscheint, wird dieVariable hinter dem Komma, hier u, eingefügt. Hinter % stehenFormatierungsanweisungen: 4 Stellen, 3 Nachkommastellen, float.

2.11.3 Programm/* sprintf verwenden zur Anzeige von Float-Werten auf dem LC-Display * Bei der Projekterstellung muss ein Haken bei sprintf-Funktionen einbinden gemacht werden!!! */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // sprintf steht in dieser Bibliothek

uint16_t adc_wert; // Wert vom AD-Converterchar lcdtext [20]; // Anzeigetext 20 Zeichen// bei Deklaration mit uint8_t (auch int8_t ???) kommt ein Warning, da sprintf gerne in (signed) char schreiben möchtefloat u; // Spannung in Voltint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe adc_init(); // Analog-Digital-Converter initialisieren delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren while(1U) // Endlosschleife Hauptprogramm { adc_wert = adc_in(0); // Messwert vom ADC holen port_write(P0,adc_wert); // Wert an LEDs dual anzeigen u = adc_wert * 5.0/4096; // Normierung auf 5V lcd_setcursor (2,3); // 2. Zeile, 3. Spalte sprintf (lcdtext,"U = %4.3f V",u); // Text erzeugen, Spannung mit 4 Stellen, 3 Nachkommast. lcd_print (lcdtext); // anzeigen delay_ms (500); // ruhigere Anzeige }//while}//main



Weitere Formatierungen:%d %i Decimal signed integer.%o Octal integer.%x %X Hex integer.%u Unsigned integer.%c Character.%s String. siehe unten.%f double%e %E double.%g %G double.%p zeiger.%n Anzahl Zeichen %% %. No argument expected.%#x %#X 0x Präfix wird bei Werten ungleich Null eingefügt.


2.12 Gleitende Mittelwertbildung2.12.1 Sinn der gleitenden Mittelwertbildung

Messwerte, die man über den ADC einliest, schwanken oft. Dies liegt häufig nicht an der schwankenden Messgröße, sondern an der ungenauen Messeinrichtung, deren Spannungsversorgung z.B. schwankt. Wenn man Steuerungen in Abhängigkeit von Messwerten programmiert, stören schwankende Messwerte sehr.

Beispiel: Der Abstand eines Objekts, das 4,8cm entfernt ist, soll gemessen werden. Ein Ultraschall-Abstandsmesser liefert die im Diagramm gezeigten Werte (X). Die Anzeige würde nun stark schwanken und wäre praktisch unbrauchbar ,weil nicht ablesbar. Nun wird immer von 10 aufeinander folgenden Werten der Mittelwert gebildet. Immer wenn ein neuer Messwert

hinzukommt, wird der älteste verworfen. Also erhält man immer den Mittelwert der letzten 10 Messwerte. Dieses Verfahren nennt man gleitende Mittelwertbildung. Wie man sieht, liefert dieses Verfahren rechts stabile Werte, die man z.B. anzeigen kann.

Noch viel wichtiger sind stabile Messwerte bei einer Steuerung oder Regelung, Beispiel: „Bewege ein Fahrzeug so vor- und zurück, dass es einen Abstand von 4,8cm von einer Wand hat“.

Ohne Mittelwertbildung würde das Fahrzeug dauernd vor- und zurückbewegt werden, weil die Steuerung denkt, das Fahrzeug bewegt sich, obwohl nur die Messwerte schwanken. Mit Mittelwertbildung würde die Regelung das Fahrzeug wahrscheinlich nicht oder kaum bewegen, weil der Abstand stimmt.

Einen Nachteil besitzt die Mittelwertbildung jedoch auch: Schnelle Änderungen der Messgröße (zum Beispiel am Anfang 0→ 4,8) können nicht berücksichtigt werden bzw. führen zu einer sich erst langsam dem Endwert annähernden Änderung des Mittelwerts.



5 10 15 20 25 30 35 40 45 500

1

2

3

4

5

6

Prinzip Gleitender Mittelwert

yGleitender Mittelw. (5 Werte)

Gleitender Mittelw. (10 Werte)

Anzahl Werte bzw. Zeit

Messwerte

„Fenster 10 Werte“

„Fenster 10 Werte“


2.12.2 Umsetzung in C

Zur Umsetzung der gleitenden Mittelwertbildung von „Anzahl“ Werten in ein Programm werden die Werte in einem Array gespeichert. Immer wenn ein neuer Wert vorliegt, wird dieser ins Array aufgenommen und der älteste gespeicherte Wert verworfen: Durchzuführende Schritte:

1) Array mit Anzahl Speicherstelleninitialisieren.

2) Vor dem Einlesen eines neuen Wertsalle Werte um 1 Stelle „nach unten“verschieben.

3) Neuesten Wert „oben einlesen“.

4) Alle Werte addieren (Vorsicht: Summebenötigt mehr Bit als die Werte)

5) Mittelwert =SummeAnzahl

/* Funktion Mittelwertbildung von anzahl ADC-Werten des Poti links */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // für sprintf#define adc_kanal 0 // 0 für Verwendung Poti#define anzahlwerte 20 // Anzahl der Werteuint16_t werte[anzahlwerte]; // Speicherung der Werte für Mittelwertbildunguint16_t mittelw; // Ergebnisspeicher für Mittelwertchar lcdtext[20]; // für sprintf und LCD-Ausgabeuint16_t adcwert; // vom ADC engelesene Wertefloat spannung; // Spannung in V als Gleitkommazahl//-------------------- Funktion zur Mittelwertberechnung ------------------------------------------------// Übergabe: Array der Werte, von denen der Mittelwert berechnet werden soll und Anzahl der Werte// Achtung Ergebnis ist eine ganze Zahl!uint16_t mittelwert (uint16_t *arr, uint8_t anzahl,uint16_t aktualwert){

uint8_t i; // Zähleruint32_t sum=0; // Summe Achtung "größere" Variable notwendig!!!for (i=0;i<anzahl-1;++i) arr[i]= arr[i+1]; // alte Messwerte um 1 Stelle im Speicher verschiebenarr[anzahl-1] = aktualwert; // neuester Messwert in den Speicherfor (i=0;i<anzahl;++i) sum += arr[i]; // letzte <anzahl> Messwerte aufaddierenreturn sum / anzahl; // geteilt durch Anzahl ist Mittelwert = Rückgabewert

//-------------------- Hauptprogramm -----------------------------------------------------------------------int main(void){ uint8_t i; // Zählvariable nur für main adc_init(); // Analoge Eingänge initialisieren adcwert = adc_in(adc_kanal); for (i=0;i<anzahlwerte;i++) werte[i]=adcwert; // Messwert-Array initialisieren, delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren while(1U) // Endlosschleife Hauptprogramm {

adcwert = adc_in(adc_kanal); mittelw = mittelwert (werte,anzahlwerte,adcwert); // gleitenden Mittelwert berechnen spannung = 5.0/4096 * mittelw; // Spannung berechnen sprintf (lcdtext,"U = %4.3f V ",spannung); // Ausgabetext erzeugen lcd_setcursor (1,1); lcd_print (lcdtext); // anzeigen delay_ms(50);

}//while}//main



Anzahl Werte0,1,2 … anz-1

neuen Werteinlesen

Array Wert [anz]

Werte um 1 Stelle nach unten verschieben

Wert [0]

Wert [1]

Wert [2]

Wert [anz-2]

Wert [anz-1]


2.13 PWM-Signal mit FOR-Schleife und ifEin PWM-Signal schaltet einen angeschlossenen Verbraucher, z.B. eine LED sehr schnell ein und aus. Der Beobachter sieht das Schalten nicht, sondern nimmt eine Art Mittelwert war. Je nachdem,wie lange ein- bzw. ausgeschaltet wird, ist dieser Mittelwert und damit z.B. die Helligkeit der LED größer oder kleiner. Der Tastgrad (duty-cycle) ist gleich dem Verhältnis von Einschaltzeit ti zu Periodendauer T des Signals und kann zwischen 0% (Aus) und 100% (An) liegen.

Mit Hilfe einer einfachen FOR-Schleife soll ein PWM-Signal erzeugt werden, dessen Tastgrad mit dem Poti an A0 verändert werden kann.

Das Poti-Stellung stellt einen 8-Bit-ADC-Wert zwischen 0 bis 255 ein. Eine FOR-Schleife zählt mit ivon 0 bis 255. In der Schleife wird das PWM-Signal erzeugt: Ist i kleiner als der ADC-Wert, so ist das PWM-Signal 1, anderfalls ist es 0.

/* PWM mit FOR-Schleife, IF... ELSE und Poti */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint16_t i; // Laufvariableuint16_t adc_wert; // Wert vom AD-Converter 16 Bit unsignedint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe programmieren adc_init(); // Analog-Digital-Converter initialisieren while(1U) // Endlosschleife, immer bei Controllern { for (i=0;i!=255;i++) // Schleife für PWM-Signal { adc_wert = adc_in(0)>>4; // 8-Bit-Wert vom ADC port_write (P0,adc_wert<<2); // ausgeben um 2 Bits nach links verschoben if (i < adc_wert) bit_write (P0,0,1); // PWM-Signal mit Tastgrad ADC-Wert erzeugen else bit_write (P0,0,0); } }//while}//main



0

adc_wert

255

PWM-Signal01

For-Schleife zählt

For-Schleife zählt

tiT


2.14 PWM mit internen Timern und HilfsfunktionenDa PWM-Signale sehr häufig verwendet werden, besitzt der Controller eine einfache Möglichkeit, drei unabhängige PWM-Signale „im Hintergrund“ zu erzeugen, ohne dass Zählschleifen in einem Programm benötigt werden. Das Zählen übernehmen Hardware-Timer, deren Periodendauer programmiert werden kann und die jederzeit einen neuen Vergleichswert zur Einstellung des Tastgrads erhalten können.

Die Ausgabe der PWM-Signale erfolgt auf festgelegte Ausgabe-Pins, diese sind: PWM1 → P0.6, PWM2 → P0.7, PWM3 →P0.8

Sechs selbst erklärende Funktionen vereinfachen die Anwendung:

pwm1_init(); pwm2_init(); pwm3_init();

pwm1_start(); pwm2_start(); usw.

pwm1_start_interrupt(void); usw. //mit Interrupt bei jeder Periode

pwm1_duty_cycle(uint8_t compare); usw.

pwm1_duty_cycle_period (uint8_t compare, uint8_t period); usw.

pwm1_stop; usw.

/* PWM-Tastgrad mit Poti A0 einstellen Ausgabe PWM an P0.6 */

#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 -> Ausgabe, nicht notwendig für PWM pwm1_init(); // PWM1 initialisieren (an P0.6) pwm1_start(); // PWM-Ausgabe starten adc_init(); // ADC initialisieren (Poti links) while(1U) // Endlosschleife, immer bei Controllern {

pwm1_duty_cycle(adc_in(0)>>4); // 8 Bit des 12-Bit-ADU-Wertes für Tastgrad }//while}//main

2.14.1 Aufgabe1

Schreiben Sie ein Programm, das die Helligkeit einer LED automatisch von <aus> bis <hell> und umgekehrt ändert. Verwenden Sie die PWM-Hilfsfunktionen und Zählschleifen zur automatischen Änderung des Tastgrads.

2.14.2 Aufgabe2

Erweitern Sie Ihr Programm zur automatischen Farbenänderung einer RGB-LED. Verwenden Sie 3 PWM-Kanäle für die 3 Farben R,G,B.




2.15 I(U)-LED-Kennlinienschreiber

Der Mikrocontroller erzeugt ein PWM-Signal, dessenTastgrad sich linear von 0 bis 100% ändert. Nach derGlättung mit einem Kondensator ergibt sich einesägezahnförmige Spannung. Diese wird an eine Schaltungaus Widerstand und LED angeschlossen. Mit einemOszilloskop im XY-Betrieb kann so die Kennlinie der Diodedargestellt werden.

/* Sägezahnspannung (Rampe) mit PWM erzeugen an P0.6 * für LED-Kennlinienschreiber R=1kOhm, C=1µF an P0.6*/

#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100uint8_t z; // Zählvariable

int main(void) // Hauptprogramm{ pwm1_init(); // PWM Kanal 0 initialisieren pwm1_start(); // Ausgabe starten while(1U) // Endlosschleife { pwm1_duty_cycle(0); // 0V ausgeben delay_ms(100); // warten bis Kondens. entladen for (z=0; z<255;z++) // Spannung 0...5V erhöhen

{ pwm1_duty_cycle(z); // dazu PWM-Tastgrade ändern delay_ms(10); // legt Steilheit Sägezahn fest }

}//while}//main

2.15.1 Oszillogramm im XY-Modus

Die Spannung am Vorwiderstand der LED ist proportionaldem Strom I durch die LED und wird in Y-Richtungdargestellt. Maßstab: I = U / 2,2kΩ. Damit beträgt dermaximale LED-Strom 1 mA.Die Spannung an der LED wird x-Richtung dargestellt.Die LED-Spannung bei I = 1 mA beträgt U = 1,8V.



VorwiderstandR = 2,2kΩ

USaegezahn

UR~ I

UD

MessobjektDiode oder

ultrahelle LED

IG R = 1kΩ

U(t)

In+

In-

Glättung Messschaltung Oszilloskopam PC

EingY

In+

In-EingX

XY-Betrieb

PWM-Generator

PWM-Ausgang

GND

Sägezahngenerator

C = 1µF

P0.6

Mikrocontroller

Sägezahnam Ausgang des RC-Filters

Vergrößerung

Vergrößerung

rot: PWM-Signalblau: Ausgang Filter

rot: PWM-Signalblau: Ausgang Filter


3 Projekte

3.1 Leistungsmessung und Modell eines MPP-Trackers

Der MPP (Maximum Power Point) einer Solarzelle kann nur durch Messungbestimmt werden. Die Funktionsweise des MPP-Trackers in einemWechselrichter kann man sich so vorstellen: Der Verbraucherstrom wirdsolange geändert, bis das Produkt aus gemessener Spannung undgemessenem Strom maximal wird. Vereinfacht stellen wir uns vor, dass dazuder Widerstand R des Wechselrichters verändert wird.

In unserem „mechanischen“ MPP-Tracker wird ein Motorpotenziometerverwendet. Der Mikrocontroller steuert den Motor an und verändert dadurchden Widerstand RVerbraucher solange, bis UR * I maximal wird.Wir verwenden einen Schrittmotor und die im Kapitel 2.9.5 Seite 22(Schrittmotorsteuerung mit Tabelle) entwickelten C-Funktionen zurRechts-Links-Steuerung.

Der Controller berechnet die Leistung PVerbr = UVerbr⋅IVerbr . Die analogen Eingänge haben eine Auflösung von 12 Bit und abeiten mit einemSpannungsbereich von 0 V bis 5 V.

UVerbr =5 V212 ⋅(adcin 4)

Als Verbraucher wird hier der Widerstand desPotis plus der Shunt bezeichnet.

Wie auch bei allen Multimetern kann der Stromnur indirekt durch Spannungsabfall aneinem Messwiderstand (Shunt)ermittelt werden.

IVerbr =UShunt

RShunt

UShunt =5V212 ⋅adcin3



Solarzellen

R

A

V

I

U

Verbraucher

0,0 0,2 0,4 0,6 0,8 1,0 1,2 1,4 1,6 1,8

0,00

0,02

0,04

0,06

0,08

0,10

0,12

0,14

0,16

0,00

0,02

0,04

0,06

0,08

0,10

0,12

0,14

0,16

Kennlinie Solarzelle I(U) bei 200 W/m²und daraus berechnete Leistung P(U)

I in A

P in W

U in V

I in A P in W

ISC

UOC

MPPIMPP

UMPP

Solarzellen

Rpoti

= 0 bis 100Ω

I

UR

M

Rshunt

1,8Ω

Ushunt

~ I

adc_in(4) P2.11

adc_in(3) P2.10

GND

GND

Transistorenzur Strom-Verstärkung

Mikrocontroller-Steuerung

veränderbarer Verbraucherwiderstandmit Shunt zur Strommessung

5


3.1.1 Programm Leistungsmessung Solarzelle mit gleitender Mittelwertbildung/* U,I,P-Messung Solarzellen * Rlast = 22 Ohm und 100 Ohm-Poti und 1,8 Ohm-Strommesswiderstand in Reihe * Solarzelle auf Holzbrett GDS2 C=1000µF parallel zur Solarzelle * Bei der Projekterstellung muss ein Haken bei sprintf-Funktionen einbinden gemacht werden!!!*/#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // für sprintf#define kanal_u 4 // normal 4 -> P2.11, für Programmtest mit Poti nehme 0#define kanal_i 3 // normal 3 -> P2.10, für Programmtest mit Poti nehme 1#define anzahlwerte 20 // Anzahl der Werte (max.6 wegen LC-Anzeige der einzelnen Werte)#define r_shunt 1.8 // Strommesswiderstanduint16_t u_werte[anzahlwerte]; // Array für Spannungswerteuint16_t i_werte[anzahlwerte]; // Array für Stromwerteuint16_t mw_u,mw_i; // Ergebnisspeicher für Mittelwertechar lcdtext[20]; // für sprintf und LCD-Ausgabeuint16_t adc_u,adc_i; // von den ADC engelesene Wertefloat u_float, i_float, p_float; // Messwerte in V, A, W

//-------------------- Funktion zur Mittelwertberechnung ------------------------------------------------// Übergabe: Array der Werte, von denen der Mittelwert berechnet werden soll und Anzahl der Werte// Achtung Ergebnis ist eine ganze Zahl!uint16_t mittelwert (uint16_t *arr, uint8_t anzahl,uint16_t aktualwert){

uint8_t i; // Zähleruint32_t sum=0; // Summe Achtung "größere" Variable notwendig!!!uint32_t mw; // Mittelwertfor (i=0;i<anzahl-1;++i) arr[i]= arr[i+1]; // alte Messwerte um 1 Stelle im Speicher verschieben,

// ältester Messwert entfälltarr[anzahl-1] = aktualwert; // neuester Messwert in den Speicherfor (i=0;i<anzahl;++i) sum += arr[i]; // letzte <anzahl> Messwerte aufaddierenmw = sum / anzahl; // geteilt durch Anzahl ist Mittelwertreturn (uint16_t) mw; // Rückgabewert umwandeln in 16-Bit

}//-------------------- Hauptprogramm -----------------------------------------------------------------------int main(void){ uint8_t i; port_init(P0,OUTP); // Port0 auf Ausgabe adc_init(); // Analoge Eingänge initialisieren adc_u = adc_in(kanal_u); for (i=0;i<anzahlwerte;i++) u_werte[i]=adc_u; // Messwert-Arrays initialisieren, adc_i = adc_in(kanal_i); for (i=0;i<anzahlwerte;i++) i_werte[i]=adc_i; // delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren while(1U) // Endlosschleife Hauptprogramm {

adc_u = adc_in(kanal_u); mw_u = mittelwert (u_werte,anzahlwerte,adc_u); // gleitenden Mittelwert berechnen u_float = 5.0/4096 * mw_u; // Spannung berechnen sprintf (lcdtext,"U = %4.3f V ",u_float); // Ausgabetext erzeugen lcd_setcursor (1,1); lcd_print (lcdtext); // anzeigen adc_i = adc_in(kanal_i); mw_i = mittelwert (i_werte,anzahlwerte,adc_i); // gleitenden Mittelwert berechnen i_float = 5.0/4096 * mw_i/r_shunt; // normieren auf 5V und i berechnen sprintf (lcdtext,"I = %4.3f A ",i_float); lcd_setcursor (2,1); lcd_print (lcdtext); // anzeigen p_float = u_float * i_float; // Leistung der Mittelwerte berechnen sprintf (lcdtext,"P = %4.3f W ",p_float); lcd_setcursor (3,1); lcd_print (lcdtext); // anzeigen delay_ms(50); // Bestimmt die Geschwindigkeit der Messungen

}//while}//main




3.1.2 Programm Leistungsmessung Solarzelle mit MPP-Tracker durch Motorpoti

Porgramm folgt

3.2 Einstrahlungsmessgerät mit Solarzelle

Das Einstrahlungsmessgerät (Solar Power Meter) zeigt die Einstrahlung E in W / m² an.

Die Funktion dieses Gerätes soll mit einer Solarzelle und dem Mikrocontroller mit LCD-Anzeige „nachgebaut“ werden. Der Zusammenhang zwischen Spannung U der Solarzelle und Einstrahlungsstärke E wird mit durch viele Messungen bei unterschiedlichen Bestrahlungsstärken ermittelt: Messtabelle mit E undU anlegen, E(U)-Diagramm mit Excel erzeugen und Trendlinieeinfügen (Typ: wahrscheinlich polynomisch). Die gefundeneFunktion E(U) wird dann in den Mikrocontroller programmiert.

In Vorversuchen ist zu klären, bei welchem Widerstandswert Rsich die Spannung bei unterschiedlichen Beleuchtungsstärkenbesonders stark ändert.



Solarzellen

RVU

Verbraucher

Abbildung 3.1: Solarmodul mit 11 in Reihe geschalteten Solarzellen


3.2.1 Theoretischer Hintergrund

An dem unten stehenden Kennlinienfeld sollen grundlegende Abhängigkeiten erklärt werden. Achtung: die abgildeten Kennlinien sind nicht identisch mit den verwendeten Modulen, sondern sollen nur beispielhaft verwendet werden.

Der Kurzschlusstrom (Schnittpunkte I(U)-Kennlinien mit der I-Achse) ist proportional zur Bestrahlungsstärke E (Angabe in W/m²).

Die Leerlaufspannung (Schnittpunkte I(U) mit der U-Achse) sind nicht proportional zur Bestrahlungsstärke. Daher messen wir nicht die Leerlaufspannung UOC um daraus die Bestrahlungsstärke zu berechnen.

Wenn man die Solarzellen mit einem festen Widerstand belastet, ergibt sich als „Arbeitspunkt“ der Schnittpunkt aus I/U-Kennlinie der Solarzelle und I/U-Kennlinie des Widerstands. Die dann fließenden Ströme und anleigenden Spannungen kann man direkt dem Kennlinienfeld entnehmen.

Man sieht, dass bei Verwendung des Widerstands R2 die (gemeinsame) Spannung am Widerstand/ an der Solarzelle nicht proportional zur Bestrahlungsstärke ist.

Bei Verwendung des Widerstands R1, dessen Kennlinie die 1000 W/m²-Kennlinie der Solarzelle im „flachen Bereich“ weit „links“ vom MPP schneidet, ist eine lineare Abhängigkeit zwischen U und E zu erkennen: E = 200 W/m² → U = 5V. 5-fache Einstrahlung (E = 1000 W/m²) → 5-fache Spannung (U = 25 V).

Der verwendete Widerstand beträgt: R =UI

=25 V5 A

= 5Ω

Die sich ergebene Zusammenhang zwischen E und U wäre in diesem Fall:

E =1000 W/m²

25 V⋅U → E = 40

Wm²⋅V

⋅U nur bei R = 5 Ω!



0 5 10 15 20 25 30 35 40 450

1

2

3

4

5

6

0

20

40

60

80

100

120

140

160

180

Beispiel-Kennlinien I(U) und P(U) bei verschiedenen Bestrahlungstärken

U in V

I in A

1000 W/m²

800 W/m²

600 W/m²

400 W/m²

200 W/m²

100 W/m²

Kennlinie W

iders

tand R

1

Kennlinie Widerstand R2

MPP

P in W


3.2.2 Messungen zur Bestimmung der Abhängigkeit U(E)

Wie auf der letzten Seite erklärt,entsteht eine lineare Abhängigkeitzwischen Einstrahlung E undSpannung U an dem mit einemgeeigeneten Widerstand belastetenSolarmodul.

Für die eingefügte Trendlinie ergibtsich die Funktion E = 185,1 * U. Diesewird im Programm zur Emittlung der Einstrahlung bei gemessener Spannung verwendet.

3.2.3 C-Programm Bestimmung der Einstrahlung aus der Spannung/* Einstrahlungsmessung über die Spannung eines mit Widerstand belastetem Solarmodul * Rlast = 100 Ohm an Mini-Solarmodul mit 11 Zellen * Bei der Projekterstellung muss ein Haken bei sprintf-Funktionen einbinden gemacht werden!!!*/

#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h>

uint16_t adc_wert; // Wert vom AD-Converter 16 Bit unsignedfloat u,e;char buf [20];int main(void) // Hauptprogramm{ delay_ms(1000); // wg. lcd-Display port_init(P0,OUTP); // Port0 auf Ausgabe adc_init(); // Analog-Digital-Converter initialisieren lcd_init(); // LC-Display initialisieren while(1U) // Endlosschleife, immer bei Controllern {

adc_wert = adc_in(2); // Wert vom ADC -> Zeitverzoegerung port_write(P0,adc_wert); // ADC-Wert an LEDs ausgeben u = adc_wert * 5.0/4096; // Spannung in Volt e = 185.1 * u; // Einstrahlung in W/m² lcd_setcursor (1,3); // 1. Zeile, 3. Spalte sprintf(buf,"U = %1.3fV",u); lcd_print (buf); lcd_setcursor (2,3); // 2. Zeile, 3. Spalte sprintf(buf,"E = %4.1fW/m2",e); lcd_print (buf); delay_ms (200); // ruhigere Anzeige

}//while}//main



0 0,5 1 1,5 2 2,50

50

100

150

200

250

300

350

400

450

500

f(x) = 185,0711596145x

Diagramm E(U) zur Programmierung eines Einstrahlungsmessgeräts

Modul 11 Solarzellen, Lastwiderstand 100 Ohm

U in V

E in W/m²

Mini-Solarmodul mit 11 Zellen und Lastwiderstand R= 100 Ohm (gemessen)

U in V E in W/m² E/U0,02 1 Lampe aus0,31 56 Lampe Stufe 1 180,61,44 261 Lampe Stufe 2 181,32,38 444 Lampe Stufe 3 186,6

E gemessen mit Amprobe Solar-100Lampe ca 27cm von Solarmodul entfernt


3.2.4 C-Programm mit gleitender Mittelwertbildung/* Messung Solarzellen für Einstrahlungsmessung * Rlast = 100 Ohm an Mini-Solarmodul mit 11 Zellen * Bei der Projekterstellung muss ein Haken bei sprintf-Funktionen einbinden gemacht werden!!!*/#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // für sprintf

#define kanal_u 2 // normal 2 -> P2.9, für Programmtest mit Poti nehme 0#define anzahlwerte 20 // Anzahl der Werte (max.6 wegen LC-Anzeige der einzelnen Werte)uint16_t u_werte[anzahlwerte]; // Array für Spannungswerteuint16_t mw_u; // Ergebnisspeicher für Mittelwertchar lcdtext[20]; // für sprintf und LCD-Ausgabeuint16_t adc_u; // von den ADC engelesene Wertefloat u_float,e_float;

//-------------------- Funktion _floatzur Mittelwertberechnung ------------------------------------------------// Übergabe: Array der Werte, von denen der Mittelwert berechnet werden soll und Anzahl der Werte// Achtung Ergebnis ist eine ganze Zahl!uint16_t mittelwert (uint16_t *arr, uint8_t anzahl,uint16_t aktualwert){



}//-------------------- Hauptprogramm -----------------------------------------------------------------------int main(void){ uint8_t i; port_init(P0,OUTP); // Port0 auf Ausgabe adc_init(); // Analoge Eingänge initialisieren adc_u = adc_in(kanal_u); for (i=0;i<anzahlwerte;i++) u_werte[i]=adc_u; // Messwert-Arrays initialisieren, delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren while(1U) // Endlosschleife Hauptprogramm {

adc_u = adc_in(kanal_u); mw_u = mittelwert (u_werte,anzahlwerte,adc_u); // gleitenden Mittelwert berechnen u_float = 5.0/4096 * mw_u; // Spannung berechnen sprintf (lcdtext,"U = %4.3f V ",u_float); // Ausgabetext erzeugen lcd_setcursor (1,1); lcd_print (lcdtext); // anzeigen e_float = u_float * 185.1; // Einstrahlung berechnen sprintf (lcdtext,"E = %4.0f W/m2 ",e_float); lcd_setcursor (2,1); lcd_print (lcdtext); // anzeigen delay_ms(100); // Bestimmt die Geschwindigkeit der Messungen

}//while}//main




3.3 1-Achs-Nachführung eines Solarpanels3.3.1 Aufbau

3.3.2 Beschreibung

Auf ein Solarmodul sollen die Sonnenstrahlen möglichst senkrecht einfallen. Dazu wird das Modul mit einem Schrittmotor nach dem Sonnenstand ausgerichtet.

2 kleine, senkrecht zum großen Solarmodul und senkrecht zur Sonne ausgerichtete Solarzellen dienen der Richtungserkennung. Wenn beide Module die gleiche Spannung liefern, ist das große Modul optimal zur Sonne ausgerichtet.

Der Mikrocontroller muss daher nur die Spannungen der kleinen Module messen, vergleichen und folgende Steuerung ausführen: z.B. U1 > U2 → Rechtsdrehung, U2 > U1 → Linksdrehung. Beide Spannungen ungefähr gleich → keine Drehung.




3.3.3 C-Programm/* Nachführung Solarmodul durch Auswertung zweier Solarzellen, die senkrecht Richtung * Sonne und sekrecht zum Solarmodul stehen * Steuerung mit Schrittmotor, ohne Endschalter * Mit gleitender Mittelwertbildung der ADC-Werte von den Richtungssolarzellen */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // für sprintf#define motor P0 // Motorport#define schritt1 0b01010000 // Bitkombinationen#define schritt2 0b01100000#define schritt3 0b10100000#define schritt4 0b10010000#define aus 0 // Motor aus#define rechts 1 // Richtung rechts#define links 2 // Richtung linksuint8_t schritt [] = {schritt1,schritt2,schritt3,schritt4};

// Array, globale Variable für die 4 Schritteuint8_t z=0; // globale Zählvariable für die Schritte#define zeitkonstante 50 // für Messgeschwindigkeit und Motordrehzahl verantwortlich#define kanal_re 4 // P2.11 orange Leitg Richtungssolarzelle#define kanal_li 3 // P2.10 rote Leitg Richtungssolarzelle#define anzahlwerte 20 // Anzahl der Werte für glieitende Mittelwertbildunguint16_t re_werte[anzahlwerte]; // die ersten Werte werden später vom Poti links geliefertuint16_t li_werte[anzahlwerte]; // die zweiten Werte werden später vom Poti rechts geliefertuint16_t mw_re,mw_li; // Ergebnisspeicher für Mittelwertechar lcdtext[20]; // für sprintf und LCD-Ausgabeuint16_t adc_re,adc_li; // von den ADC engelesene Werte#define delta_u 5 // Hysterese der ADC-Messwerte rechts/links

//-------------------- Funktion zur Mittelwertberechnung ------------------------------------------------// Übergabe: Array der Werte, von denen der Mittelwert berechnet werden soll und Anzahl der Werte// Achtung Ergebnis ist eine ganze Zahl!uint16_t mittelwert (uint16_t *arr, uint8_t anzahl,uint16_t aktualwert){



}

// -------------- Schrittmotordrehung ---------------------------------------void motordrehung_1schritt (uint8_t richtung){

if (richtung == aus) port_write (motor,0); // Motor aus, Energie sparen else {

if (richtung == rechts) z++; else z--; // nächste Bitkombination port_write (motor,schritt [z % 4]); // für Schritt ausgeben

} // Anmerkung: z % 4 ist der Rest, der bei z/4 entsteht, also 0 oder 1 oder 2 oder 3}// motordrehung Ende




//-------------------- Hauptprogramm -----------------------------------------------------------------------int main(void){ uint8_t i; port_init(motor,OUTP); // Motorport auf Ausgabe programmieren adc_init(); // Analoge Eingänge initialisieren adc_re = adc_in(kanal_re); for (i=0;i<anzahlwerte;i++) re_werte[i]=adc_re; // Messwert-Arrays initialisieren, adc_li = adc_in(kanal_li); for (i=0;i<anzahlwerte;i++) li_werte[i]=adc_li; // delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren lcd_setcursor (1,1); lcd_print ("Solarz-rechts:"); // Texte anzeigen lcd_setcursor (2,1); lcd_print ("Solarz-links:"); while(1U) // Endlosschleife Hauptprogramm {

adc_re = adc_in(kanal_re); // Spannung Richtungssolarzelle rechts mw_re = mittelwert (re_werte,anzahlwerte,adc_re); // gleitenden Mittelwert berechnen adc_li = adc_in(kanal_li); // Spannung Richtungssolarzelle links mw_li = mittelwert (li_werte,anzahlwerte,adc_li); // gleitenden Mittelwert berechnen if (mw_re > (mw_li+delta_u)) motordrehung_1schritt (links); // Entscheidung else if (mw_li > (mw_re+delta_u)) motordrehung_1schritt (rechts); // Links- Rechtsdrehung else motordrehung_1schritt(aus); // oder Motor aus lcd_setcursor (1,15); lcd_int (mw_re); // Wert Richtungssolarzelle anzeigen lcd_setcursor (2,15); lcd_int (mw_li); delay_ms(zeitkonstante); // bestimmt Schrittmotordrehzahl

}//while}//main




3.4 RGB-LEDs mit PWM steuernDas nachfolgende Programm erzeugt automatische Farbübergänge bei einer RGB-LED mittels dreier PWM-Signale.

/*RGB-LED mit PWM steuern R an P0.0 (Tastgrad mit Poti0) G an P0.1 (Tastgrad mit Poti1) B an P0.2 (automatische Erhöhung und Erniedrigung des Tastgrads)*/

#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100uint8_t z; // Zählvariable

void RGBout (uint8_t tgr,uint8_t tgg,uint8_t tgb){

pwm1_duty_cycle(~tgr); // Tastgrade pwm2_duty_cycle(~tgg); pwm3_duty_cycle(~tgb);

}

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe, nicht notwendig für PWM pwm1_init(); // PWM Kanal 0 initialisieren pwm2_init(); // PWM Kanal 1 initialisieren pwm3_init(); // PWM Kanal 1 initialisieren pwm1_start(); // Ausgabe starten pwm2_start(); // Ausgabe starten pwm3_start(); // Ausgabe starten while(1U) // Endlosschleife, immer bei Controllern { for (z=0;z!=255;z++) {RGBout (z,0,0);delay_ms(10);} for (z=0;z!=255;z++) {RGBout (255,z,0);delay_ms(10);} for (z=0;z!=255;z++) {RGBout (~z,255,z);delay_ms(10);} }//while}//main

Für den nachfolgenden Hauptprogrammausschnitt soll nun eine Funktion RGBuebergang() geschrieben werden.

while(1U) { // R G B zeit

RGBuebergang ( heller, aus, aus, 10) ;RGBuebergang ( an, heller, aus, 10) ;RGBuebergang ( dunkler,an, heller, 10) ;RGBuebergang ( aus, dunkler,an, 10) ;RGBuebergang ( heller, heller, dunkler,10) ;RGBuebergang ( dunkler,dunkler,aus, 10) ;

}//while




3.5 Wandler Gleichspannung in Wechselspannung mit PWMIn jedem PV-Wechselrichter wird aus der Gleichspannung, welche die Solarmodule liefern, eine Wechselspannung erzeugt, mit der die Energie ins Netz eingespeist werden kann. Diese Wandlung erfolgt mit schaltenden Transistoren, die mit einer PWM angesteuert werden, deren Tastgrad sich sinusförmig ändert. Auch in den meisten Elektroantrieben werden die Motoren auf diese Weise angesteuert.Mithilfe einers Energiespeichers (Spule,Kondensator) erhält man aus der ein- undausschaltenden Spannung einensinusförmigen Verlauf der Spannung oderdes Stromes. Oft reichen die Induktivitätender Motorspulen aus, um aus dergeschalteten Spannung mit sinusförmig sichänderndem Tastgrad einen annäherndsinusförmigen Strom zu machen.

3.5.1 C-Programm Sinus mit PWM erzeugen ohne Interrupt/* Sinus mit PWM erzeugen an P0.6 */

#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100// in XMC1100-Lib.c definiert: #define periode 2550 fuer PWM-Frequenz ca. 1.5 kHzuint8_t z; // Zählvariableuint8_t sinus [ ]= {

128,136,145,154,163,171,180,188,195,203,210,216,223,228,234,238,243,246,249,252,254,255,255,255,255,254,252,249,246,243,238,234,228,223,216,210,203,195,188,180,171,163,154,145,136,128,119,110,101,92,84,75,67,60,52,45,39,32,27,21,17,12,9,6,3,1,0,0,0,0,1,3,6,9,12,17,21,27,32,39,45,52,60,67,75,84,92,101,110,119};// Werte siehe Exceltabelle

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe-> LEDs aus pwm1_init(); // PWM Kanal 0 initialisieren pwm1_start(); // Ausgabe starten while(1U) // Endlosschleife, immer bei Controllern {

for (z=0; z<89;z++) { pwm1_duty_cycle(sinus[z]); // Tastgrade delay_100us(1); }

}//while}//main



Abb 3.2 sinusförmige Änderung des Tastgrads


3.5.2 C-Programm Sinus erzeugen mit PWM, Interrupt nach jeder Periode

/* Sinus mit PWM erzeugen an P0.6, Interrupt nach jeder Periode */

#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100// in XMC1100-Lib.c: #define periode 2550 fuer PWM-Frequenz ca. 1.5 kHzuint8_t z; // Zählvariableuint8_t sinus []= {

128,136,145,154,163,171,180,188,195,203,210,216,223,228,234,238,243,246,249,252,254,255,255,255,255,254,252,249,246,243,238,234,228,223,216,210,203,195,188,180,171,163,154,145,136,128,119,110,101,92,84,75,67,60,52,45,39,32,27,21,17,12,9,6,3,1,0,0,0,0,1,3,6,9,12,17,21,27,32,39,45,52,60,67,75,84,92,101,110,119};

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe-> LEDs aus pwm1_init(); // PWM Kanal 0 initialisieren pwm1_start_interrupt(); // Ausgabe starten while(1U) // Endlosschleife, immer bei Controllern {

// warten auf Interrupts }//while}//main

void CCU40_0_IRQHandler (void){

if (z < 89) z++; else z = 0; // Tabelle abarbeitenpwm1_duty_cycle (sinus[z]); // neuen Tastgrad aus Tabelle holen

}

R=1kΩ, C = 1µF




R=2,2kΩ, C = 1µF

3.5.3 C-Programm Sinus mit PWM, Amplitude und Frequenz veränderbar

/* Sinus mit PWM erzeugen an P0.6 mit Amplitudeneinstellung am Poti links * und Periodendauer am Poti rechts */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100uint8_t z; // Zählvariableuint16_t sinus [ ]= { // wegen Multiplikation unten 16Bit

128,136,145,154,163,171,180,188,195,203,210,216,223,228,234,238,243,246,249,252,254,255,255,255,255,254,252,249,246,243,238,234,228,223,216,210,203,195,188,180,171,163,154,145,136,128,119,110,101,92,84,75,67,60,52,45,39,32,27,21,17,12,9,6,3,1,0,0,0,0,1,3,6,9,12,17,21,27,32,39,45,52,60,67,75,84,92,101,110,119};

uint16_t ampl,periode; // wegen Multiplikation unten 16Bitint main(void) // Hauptprogramm{ delay_ms(500); // Auf LC-Display-Bereitschaft warten lcd_init(); lcd_setcursor ( 1,1 ); // 1.Zeile, 1. Spalte lcd_print ( "Amplitu: links"); lcd_setcursor ( 2,1 ); // 2.Zeile, 1. Spalte lcd_print ("Periode: rechts"); lcd_setcursor ( 3,1 ); // 3.Zeile, 1. Spalte lcd_print ("PWM an P0.6"); lcd_setcursor ( 4,1 ); // 4.Zeile, 1. Spalte lcd_print ("R=1kOhm,C=1uF->Sinus"); port_init(P0,OUTP); // Port0 auf Ausgabe-> LEDs aus adc_init(); // Analog-Digital-Converter pwm1_init(); // PWM Kanal 0 initialisieren pwm1_start_interrupt(); // Ausgabe starten mit Interrupt nach jeder Periode while(1U) // Endlosschleife, immer bei Controllern {

ampl = adc_in(0)>>4; // 8-Bit-wert von Poti links -> Amplitude periode = adc_in(1)>>4; // 8-Bit-Wert von Poti rechts -> Periodendauer lcd_setcursor ( 1,10 ); // 1.Zeile, 10. Spalte lcd_byte ( ampl ); // Wert Poti -> Amplitude 0 ... 255 lcd_setcursor ( 2,10 ); // 1.Zeile, 10. Spalte lcd_byte ( periode ); // Wert Poti-> Periodendauer 0 ... 255

}//while




}//main

void CCU40_0_IRQHandler (void) // Interrupt-Service-Routine{

if (z < 89) z++; else z = 0; // Tabelle abarbeiten// Sinus hat negativsten Wert immer bei 0, //Offset verschieb sich nach oben mit steigender Amplitude:pwm1_duty_cycle_period (ampl*sinus[z]/255*periode/255,periode);// Amplitudewert auf Größe max 255 normieren // mal periode/255 damit Amplitude sich mit mit Periode ändert

}Amlitude = 255, Periode = 255, R = 1kΩ, C=1µF

Amlitude = 125, Periode = 255






void CCU40_0_IRQHandler (void) // Interrupt-Service-Routine{

if (z < 89) z++; else z = 0; // Tabelle abarbeiten// Sinus hat Mittelwert immer bei 2,5V:pwm1_duty_cycle_period (periode/2+ampl*(sinus[z]-127)*periode/255/255,periode);//-127 -> "nach unten" schieben, Werte werden auch negativ// mal Amplit, auf max 255 normieren, mal periode/255, damit Amplit unabhängig änderbar// und wieder um periode/2 nach oben oben verschieben (Offset des Sinus)

}Amlitude = 255, Periode = 255, R = 1kΩ, C=1µF






3.6 Reaktionstester mit Timer-Zeitmessung

/* Reaktionstester und Testen der Ganzzahl-/Floatberechnungen * Start mit P2.9 Stopp mit P2.2 * Wichtig: bei der Erstellung des Simple Main Projekts Haken bei include sprintf!!!!! */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // für sprintf#define gedrueckt 0 // lowaktive Tasteruint16_t timer_wert,zeit;char lcdtext [20]; // Anzeigetext 20 Zeichen

int main(void) // Hauptprogramm{ bit_init(P2,9,INP); // Start-Taster bit_init(P2,2,INP); // Stopp-Taster delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren timer_init(0xC,0xFFFF); // 16 uSek Timertakt -> 4,2 Sek Periode max!!! lcd_print ("Zeit = ms int"); lcd_setcursor (3,1); // lcd_print ("P2.9 Start P2.2 Stop"); while(1U) // Endlosschleife Hauptprogramm {

timer_reset(); // Timer vor dem Start rücksetzen while (bit_read(P2,9)!= gedrueckt); // warten start gedrückt timer_start(); // Timer starten while (bit_read(P2,2)!= gedrueckt); // warten stopp gedrückt timer_stop(); // Timer anhalten timer_wert = timer_value(); // Timer Wert auslesen zeit = timer_wert*64/1000; // Zeit in ms lcd_setcursor (1,7); // lcd_int(zeit); // Zeit anzeigen in ms als ganze Zahl lcd_setcursor (2,1); // sprintf (lcdtext,"Zeit = %4.0f ms float",timer_wert*64.0/1000);

// Anzeigetext mit float-Zahl erzeugen lcd_print (lcdtext); // anzeigen

}//while}//main



Start/Stopp

timer_init (vorteiler,periode);

gleichInterrupt

Reset

Vorteiler0,1,2,4...215

16-Bit-Timerwert

Vergleicher

Periode

Takt64MHz

Freigabe

timer_start ( );

timer_stop ( );

timer_start_interrupt ( );

wert = timer_value ( );

timer1ms_init ( ); // wie timer_init (1,32000);

Vereinfachte Timer-Darstellung

Funktionen

timer_reset ( );

Reset


3.7 Ultraschall-Abstandsmessung mit Modul SFR043.7.1 Funktionsweise des Moduls

Um eine Messung zu starten, wird ein Impuls (TTL-Pegel, mind. 10us) an den Triggereingang gelegt. Der Wandler wird von der Ablaufsteuerung auf dem Modul für 200μs (8 Zyklen, 40kHz) getaktet und der Echo-Ausgang des Moduls auf High gelegt. Das erste hereinkommende Echo schaltet den Echo-Ausgang wieder auf Low, so dass ein direkt zur Entfernung des Objektes proportionaler Impuls entsteht. Der Triggerimpuls sollte nach Möglichkeit nicht länger als 200μs, muss aber auf jeden Fall vor Ende des Echo-(Mess-) Impulses wieder Low sein. Die Entfernung ergibt sich rechnerisch als Produkt aus Schallgeschwindigkeit (344m/s in Luft bei 21°C) und der Länge des Echo-Impulses. Da die Strecke vom Schall doppelt zurückgelegt wird, ist das Ergebnis durch 2 zu dividieren: s = 344m/s * ti/ 2 , s in Meter, ti in Sekunden

Je nach Genauigkeit und Zielsystem sind Vereinfachungen und Optimierungen möglich und sinnvoll, um z.B. mit Ganzzahlarithmetik auszukommen. z.B.: len[cm] = 172 * t[μs] / 10000

Steht Floatingpoint Arithmetik auf dem Zielsystem zur Verfügung, liefert die Gleichung len[cm] = t [μs]/ 58,066 [μs/cm] sehr gute Ergebnisse. Bei Auswertung der Entfernung über die Formel nimmt der Messfehler bei kürzeren Entfernungen zu. Das hängt damit zusammen, dass derEchoimpuls und damit die Zeitmessung erst nach dem 200us langen 40kHz Burst startet. Bei kurzen Entfernungen erreicht das Echo schon den Empfänger, bevor dieser überhaupt aktiv wird Hier bietet sich bei entsprechenden Genauigkeitsanforderungen die Umrechnung über eine Tabelle an.

Da der Spannungswandler für den Ultraschall-Sender während des Echo-Empfanges abgeschaltetwird, muss nach Ende des Echo-Pulses noch mindestens 10ms bis zum nächsten Triggerimpuls gewartet werden, damit sich die Arbeitspunkte wieder stabilisieren.

3.7.2 Timing-Diagramm

3.7.3 Kennwerte des Moduls




3.7.4 Programm

Prinzip: 1) Triggerimpuls von 100µs ausgeben: 1 ausgeben, 100µs warten, 0 ausgebenDann Länge des Echoimpulses messen: 2) warten bis Echo auf 1 geht, Zeitmessung starten,3) warten bis Echo auf 0 geht, Zeitmessung stoppen4) Wert der Zeitmessung aus Timer auslesen5) und umrechnen in zurückgelegten Weg.

/* sprintf verwenden zur Anzeige von Float-Werten auf dem LC-Display * Wichtig: bei der Erstellung des Simple Main Projekts Haken bei include sprintf!!!!! */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#include <stdio.h> // für sprintf

uint16_t adc_wert; // Wert vom AD-Converteruint16_t timer_wert;char lcdtext [20]; // Anzeigetext 20 Zeichen// bei Deklaration mit uint8_t (auch int8_t ???) kommt ein Warning, // da sprintf gerne in (signed) char schreiben möchtefloat entfernung; // Entfernung in m

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe Pulse bit_init(P1,0,OUTP); // Trigger bit_init(P1,1,INP); // Echo delay_ms(500); // warten bis LC bereit lcd_init(); // LC-Display initialisieren timer_init(6,0xFFFF); // 1,024 uSek Timertakt-> 67.1 mSek Periode max while(1U) // Endlosschleife Hauptprogramm {

timer_reset(); // Timer vor dem Start rücksetzen bit_write(P1,0,1); // Triggerimpuls delay_100us(1); // 100µs High bit_write(P1,0,0);

while (bit_read(P1,1)==0); // warten bis Modul antwortet und Echopuls beginnt timer_start(); // Timer starten

while (bit_read(P1,1)==1); // warten bis Modul Ende des Echoimpulses meldet timer_stop(); // Timer wieder stoppen timer_wert = timer_value( ); // Timer Wert auslesen port_write(P0,timer_wert); // Wert an LEDs dual anzeigen entfernung = timer_wert/58.066; // Entfernung in cm berechnen lcd_setcursor (2,3); // 2. Zeile, 3. Spalte// Anzeigetext erzeugen, Entfernung mit 4 Stellen, 3 Nachkommastellen: sprintf (lcdtext,"Entf = %3.0f cm",entfernung); lcd_print (lcdtext); // anzeigen delay_ms (100); // ruhigere Anzeige

}//while}//main




3.8 Drehzahlmessung mit Timer und ext. Interrupt

/* Drehzahlmessung mit Impulscheibe * Scheibe liefert 120 Imp pro Umdrehung * 100ms sind vorbei, wenn Timer_1ms 100 malaufgerufen wurde * Impulsmessung mit ext. Interrupt */

#include <XMC1100-Lib.h> //Hilfsfunktionen für XMC1100uint16_t timer1ms_zaehler=0; // zählt ms bei jedem Timerinterruptuint16_t impulszaehler=0; // zählt die Impulse der Impulsscheibe (120 pro Umdrehung)uint16_t impulse_in100ms=0; // Zwischenspeicher für Anzahl Impulse in 100msuint16_t drehzahl=0; // Drehzahl pro Minute

int main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe-> LEDs aus ext_interrupt_init(); ext_interrupt_enable1(); // Int an P2.9 timer1ms_init(); // Timer -Interrupt alle 1ms initialisieren timer_start(); lcd_init(); lcd_setcursor(1,1); lcd_print("Impulse/100ms: "); // lcd_setcursor(2,1); lcd_print("Umdr/min: "); while(1U) // Endlosschleife ------------------------------------------- {

port_write (P0,impulse_in100ms); // Impulse/100ms an LEDs anzeigen lcd_setcursor(1,15); lcd_int(impulse_in100ms); //Impulse/100ms an LCD anzeigen drehzahl = impulse_in100ms*5; // imp/min = 10*60/120 * imp/100ms lcd_setcursor(2,15); lcd_int(drehzahl);

}//while}//main

void CCU40_3_IRQHandler (void) // Timer-Interrupt jede 1 ms -----------------------------{

timer1ms_zaehler++; // Zähler 100msif (timer1ms_zaehler == 100){ impulse_in100ms = impulszaehler; // Wert merken

impulszaehler = 0; // Impulszähler zurücksetzentimer1ms_zaehler = 0; // 100ms-Zähler zurücksetzen

} }

void ERU0_3_IRQHandler(void) // ext. Int bei steigender Flanke an P2.9 ------------{

impulszaehler++; // Interrupt-Servie-Routine Impulse zählen}




3.9 Schrittmotor als Sekundenanzeige mit Timerinterrupt3.9.1 Prinzip Timerprogrammierung

Der verwendete Schrittmotor besitzt ein Getriebeund benötigt daher 2018 Schritte für eineUmdrehung.

Der Motor soll eine genaue analogeSekundenanzeige verwendet werden. Die Ausgabeeines einzelnen Schritts erfolgt in der Timer-Interrupt-Routine. Dazu wird der Timer soprogrammiert, dass die Scheibe auf dem Motor(siehe Abb. Rechts) in 60 Sekunden genau eineUmdrehung vollzieht. Daher muss die Interrupt-Service-Routine genau alle

60 s2048 Schritte

= 0,029296875 s

aufgerufen werden.

Berechnen Sie die Werte für den Vorteiler und diePeriode des 16-Bit-Timers entsprechend.

T =2vorteiler

⋅Periode64 MHz

Wertebereich Vorteiler 0,1,2,3,...15, Wertebereich Periode 1...65536

z.B. Periode =64 MHz⋅0,029296875

25 = 58593,75 → keine genaue Uhr möglich

→ In der ISR ist ein weiterer Frequenzteiler möglich:

Nur bei jedem 100. Aufruf der ISR darf der Schrittmotor sich drehen:

Periode =64 MHz⋅0,029296875

100⋅21 = 9375

Nur bei jedem 10. Aufruf der ISR darf der Schrittmotor sich drehen:

Periode =64 MHz⋅0,029296875

10⋅22 = 46875

→ timer_init (2,46875);

und in der Interrupt-Service-Routine:

intz++; // Interrupts zählen if (intz==10) // Motor ansteuern nur jeden 10. Interrupt

{ intz=0; // Interruptzähler null motordrehung1Schritt(); // Motor um 1 Schritt drehen

}



02048

1920

1792

1664

1536

1408

1280

1152

1024

896

768

640

512

384

256

128

0 22,545

90

135

180

225

270

315

Start/Stopp

timer_init (vorteiler,period);

gleichInterrupt

Reset


16-Bit-Timerwert

Vergleicher

Periode

Takt64MHz

Freigabe



Funktionen

timer_stop ( );


3.9.2 C-Programm Schrittmotor als Sekundenanzeige/* Schrittmotor als Sekundenanzeige mit Starttaster P2.2 Anschluss an P0.4 bis P0.7 damit P0.0 bis P0.3 (Dip-Schalter) frei bleibt Schrittmotor mit 2048 Schritten pro Umdrehung anschließen */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100#define motor P0 // Motorport#define schritt1 0b01010000 // Bitkombinationen#define schritt2 0b01100000#define schritt3 0b10100000#define schritt4 0b10010000#define taster P2 // Tasterport#define Tstart 2 // P2.2 ganz rechts für Start#define Sstart 0 // alternativ P0.0 Schalter Start#define San 1 // Schalter Stellung an#define Tgedrueckt 0 // lowaktiver Tasteruint8_t schritt [] = {schritt1,schritt2,schritt3,schritt4}; // Array, globale Variable für die 4 Schritteuint16_t z=0,intz; // globale Zählvariable für die Schritteuint8_t motorlauf; // Merker Zustand Motor#define motor_an 1#define motor_aus 0

//--------------- Hauptprogramm ---------------------------------------------------int main(void) // Hauptprogramm{ port_init(motor,OUTP); // Motorport auf Ausgabe programmieren port_write (motor,motor_aus); // Motor aus motorlauf = motor_aus; // Merker Zustand Motor timer_init(2,46875); // Interrupt alle 60s/2048 Schritte // damit bei einem Schrittmotorumlauf 60s vergehen bit_init(taster,Tstart,INP); // Tasterpin auf Eingabe //bit_init(motor,Sstart,INP); // Alternativ Schalter lcd_init(); // Anzeige Anzahl Schritt seit letztem Stopp lcd_print("Schrittzahl: "); lcd_setcursor(2,1); lcd_print("Start-Stopp: P2.2"); while(1U) // Hauptprogramm-Endlosschleife {//if (bit_read(motor,Sstart)==San) timer_start_interrupt(); else timer_stop(); //Start-Stopp mit Schalter

if (bit_read (taster,Tstart) == Tgedrueckt) // Start-Stopp mit Taster{

while(bit_read (taster,Tstart) == Tgedrueckt); // warten bis Taster losgelassenif (motorlauf == motor_aus) // An-Aus toggeln{

motorlauf = motor_an; // Zustand merkentimer_start_interrupt(); // Timer starten mit Interrupt

}else{

motorlauf = motor_aus; // Zustand merkentimer_stop(); // Timer stoppport_write (motor,motor_aus); // Motor aus wg. Stromz=0; // Schrittzähler null setzen

}// delay_ms(100); // ggfs Entprellung

}//if (bit_read)lcd_setcursor(1,14); //lcd_int(z); // Schrittzahl ausgeben

}//while}//main




void CCU40_3_IRQHandler (void) // --------------- Timer-Interrupt jede Periode ---------------------{ // Interrupt-Servie-Routine intz++; // Interrupts zählen if (intz==10) // Motor ansteuern nur jeden 10. Interrupt

{ intz=0; // Interruptzähler null port_write (motor,schritt [z % 4]); // Bitkombination für Schritt ausgeben z++; // Schrittzähler zur Abarbeitung Tabelle, Anzeige }

// Anmerkung: z % 4 ist der Rest, der bei z/4 entsteht, also 0 oder 1 oder 2 oder 3 }




3.10 Kommunikation über den I2C-Bus: Port-Expander3.10.1 Prinzip und Protokoll am Beispiel Port-Expander

Der I²C-Bus arbeitet nach dem Master-Slave-Prinzip.Ein Datentransfer wird immer durch einen Masterbegonnen. Der über eine Adresse angesprocheneSlave reagiert darauf. I²C benötigt ein Taktleitung (SCL) und eineDatenleitung (SDA), beide werden durchWiderstände auf +Versorgungsspannung gezogen.OV wird durch Schalten von Transistoren auf GNDim jeweils senden Baustein erreicht. Logisch 1 (High) entspricht hier +5V, logisch 0 (Low) 0V.

Jeder Baustein besitzt eine Adresse, dies wird als erstes Byte vom Master gesendet, wobei 4 Bit vom Hersteller festgelegt werden und 3 Bit durch Anschlussleitungen auf der Platine. Das achte Bit(R/W-Bit) teilt dem Slave mit, ob er Daten vom Master empfangen soll (LOW) oder Daten zum Master übertragen soll (HIGH).

Die Übertragung beginnt mit einer speziellen Signalkombination an den Leitungen, sie wird Startbedingung genannt. Dann überträgt der Master die Adresse und das R/W-Bit. Der angesproche Slave zieht anschließend die Leitung auf 0V und bestätigt damit den Empfang. Dies nennt man ACK-Bit. Je nachdem, ob der Slave senden oder empfangen soll, schickt nun der Master oder der slave weitere Daten. Die Taktleitung wird immer vom Master geschalten. Falls sich kein Slave angesprochen gefühlt hat, bleibt das ACK-Bit high, dies nennt man NACK. Immer nach einem Datenbyte sendet der Empänger ein ACK. Wenn der Master das letzte Byte von einemSlave gelesen hat, kündigt er das Übertragungsende mit einem NACK an. Die Übertragung endet mit der Stoppbedingung. Es wird immer das niederwertigste Bit zuerst gesendet.



MasterµC

SlaveI/O

SlaveDAC

SlaveTemp

SlaveUhr

5V

SDASCL

01

StartbedingungSCL=1 und

abfallende Flanke an SDA

StoppbedingungSCL=1 und

ansteigende Flanke an SDA

Daten auf SDA gültig während SCL = 1

D7 D0W0 1 1 1 A2 A1 A0ACK ACK

Start StopD6 D5 D4 D3 D2 D1Master → Slave Slave → Master

Beispiel: Übertragung der Daten 00000011 an den IO-Expander PCF8574A (Herstelleradresse 0111, IC-Adresse 001)

Hersteller-Adresse auf der Platine festgelegt

0→sc

hrei

ben

0→em

pfan

gen

Beispiel: Falsche Adresse (0111000) → ACK = 1 → „NACK“


3.10.2 Platine I2C-Bus-Trainer mit I2C-Adressen

3.10.3 C-Programm I/O-Portexpander

/* I2C-Bus Portexpander mit lowaktiven LEDs SDA -> P1.0, SCL -> P1.1 */


#define schalter4 p0 // 4 Schalter P0.0 bis P0.3#define sendetaster 2 // P2.2#define ack_anzeige 4 // P1.4uint8_t ack_bit; // Ack-Bit Empfangen-> 0

int main(void) // Hauptprogramm{

port_init(P0,INP); // später 4 Schaltern einleseni2c_init(); // I2C initialisierenbit_init(P2,sendetaster,INP); // für spätere Ausgabe an I2C-Bus nach Tastendruck P2.2bit_init(P1,ack_anzeige,OUTP); // ACK anzeigen an LED: ACK LED aus, NACK LED anbit_write(P1,ack_anzeige,1); // zuerst NACK

while(1U) // Endlosschleife {

while(bit_read(P2,sendetaster)==1); //warten auf Tastendruck P2.2i2c_start(); // Startbedingungack_bit = i2c_write(0b01110010); // PortExpander TypA Adr 001if (ack_bit==0) ack_bit=i2c_write(port_read(P0)); // 8 Bit P0 kopieren an Portexpander

// LEDs dort sind lowaktiv!!i2c_stop(); // Stopbedingungbit_write(P1,ack_anzeige,ack_bit); // ACK / NACK anzeigen an LED

}//while}//main



8 Bit I/O-ExpanderPCF 8574A Adr.001Lowaktive LEDs

8 Bit DA/AD-ConverterPCF 8591 Adr.011

9 Bit TemperaturfühlerDS1621 Adr.101

Realtime ClockPCF 8593

EEPROM 8kx8 M24C64 Adr.100

Hersteller-Adressen:IO-Expander PCF 8574A 0111001xIO-Expander PCF 8574 0100001xDA/AD-Converter PCF 8591 1001011xTemperaturfühler DS1621 1001101xRealtime Clock PCF 8593 1010001xEEPROM M24C64 1010100x

x=0: Master schreibtx=1: Master liest


3.11 Temperaturmessung mit dem I2C-Sensor DS16213.11.1 Protokoll Sensor DS1621

Der Sensor DS1621 kann kann bei Überschreiten einer frei programmierbaren Maximaltemperatur oder Unterschreiten einer Minimaltemparatur „Alarm“ geben. Wir verwenden nur die Temperaturmessfunktion, die in Schritten von 0,5°C im Bereich -55°C bis +125°C gemessen werden kann. Die Wandlungszeit des internen Analog-Digital-Converter beträgt max 750ms.

I2C-Adresse: 1 0 0 1 A2 A1 A0 R/W wobei A2=1, A1=0, A0=1 auf der Platine festgelegt ist.

Zugriff: Nach der Übertragung der Adresse wird mit dem Kommando 0xEE die kontinuierliche Wandlung gestartet.

Danach werden 2 Bytes aus dem 16-Bit-Temperaturregister gelesen. Nur 9 Bit sind von Bedeutung.

Das LSB stellt die 0,5°C-Nachkommastelle dar. Die vorderen 8 Bit stellen die Temperatur in Grad als int8_t dar, also von -128 bis +127, wobei der messbereich des Sensors nur von -55 bis +125 reicht.



INSTRUCTION DESCRIPTION

PROTOCOL

2-WIRE BUS DATA AFTER ISSUING

PROTOCOL

NOTES TEMPERATURE CONVERSION COMMANDS

Read Temperature Read last converted temperature value from temperature register.

AAh <read 2 bytes data>

Read Counter Reads value of Count_Remain A8h <read data> Read Slope Reads value of the

Count_Per_C A9h <read data>

Start Convert T Initiates temperature conversion.

EEh idle 1

Stop Convert T Halts temperature conversion. 22h idle 1

TEMPERATURE DIGITAL OUTPUT (Binary)

DIGITAL OUTPUT (Hex)

+125°C 01111101 00000000 7D00h +25°C 00011001 00000000 1900h +½°C 00000000 10000000 0080h +0°C 00000000 00000000 0000h -½°C 11111111 10000000 FF80h -25°C 11100111 00000000 E700h -55°C 11001001 00000000 C900h

T = -25°C

1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0

MSB LSB

0x9A 0xEE


Temperatur lesen

3.11.2 C-Programm Temperaturmessung mit DS1621/* I2C-Bus Temperaturmessung SDA -> P1.0, SCL -> P1.1 */#include <XMC1100-Lib.h> // Hilfsfunktionen für XMC1100#define ack_anzeige 4uint8_t ack_bit; // Ack-Bit Empfangen-> 0uint8_t tempL,temp; // Temperaturspeicher

int main(void) // Hauptprogramm{

delay_ms(1000); // warten bis LCD-Controller gestartetlcd_init(); // LCD initialisiereni2c_init(); // I2C initialisierenbit_init(P1,ack_anzeige,OUTP); // ACK LED aus, NACK LED anbit_write(P1,ack_anzeige,1); // zuerst NACKi2c_start(); // Startbedingungi2c_write(0x9A); // Adresse, R/W=0i2c_write(0xEE); // kontinuierliche Wandlungi2c_stop(); // Stoppbedingunglcd_print ( "Temperatur" ); // Textausgabe LCD

while(1U) // Endlosschleife {

i2c_start(); // Startbedingung i2c_write(0x9A); // Adresse R/W=0 i2c_write(0xAA); // Command_ Temperatur lesen , R/W=0 i2c_start(); // repeatet Start ack_bit=i2c_write(0x9B); // Adresse und R/W=1 temp=i2c_read(ACK); // Temp in Grad lesen tempL=i2c_read(NACK); // Temp 0,5 Grad, letztes Lesebyte i2c_stop(); // Stoppbedingung lcd_setcursor ( 2,1 ); // Cursorposition LCD 2. Zeile lcd_byte ( temp ); // Temperatur anzeigen lcd_char ('.'); // Komma if (tempL==0) lcd_char ('0'); else lcd_char ('5'); // Nachkommastelle lcd_char('°');lcd_char('C'); // Grad C bit_write(P1,ack_anzeige,ack_bit); // Ack-Bit IC angesprochen?

}//while}//main



0x9A 0xAA 0x9B

Temperatur in 1°C D7→ 0,5°CACK!! NACK!!

FortsetzungSCL

SDA


3.11.3 Beobachteter Datenaustausch

Initialisierung

Temperatur lesen

übertragener Temperaturwert: hex18 → 24°, hex80 → +0,5° => Temperatur = 24,5°C

3.11.4 Aufgabe: Abfrage AD-Wandlung fertig?

Nach dem Einschalten wird zuerst eine falsche Temperatur (196°) angezeigt. Dies liegt daran, dass der AD-Converter noch nicht fertig ist. Daher soll das Programm so abgeändert werden, dasserst dann eine Temperatur gelesen wird, wenn der ADC die Wandlung beendet hat. Dazu muss das configuration/status-Register abgefragt werden:

configuration/status register:

DONE = Conversion Done bit. “1” = Conversion complete, “0” = Conversion in progress

Access Config [ACh]

If R/ W is “0” this command writes to the configuration register. After issuing this command, the next data byte is the value to be written into the configuration register. If R/W is “1” the next data byte read is the value stored in the configuration register.



0x9A 0xAC 0x9B Config/Status


3.12 Sinusausgabe über I²C-DAC PCF 8591Adresse: 1001011R/WR/W=0 schreiben R/W=1 lesen

Control-Byte siehe rechts.

Protokoll DACStartbedingungAdresse schreibenControl-Byte schreibenbeliebig viele Datenbytes an den DACStoppbedingung

Immer mit dem Schreiben des Datenbytes wirddas vorhergehende ausgegeben.

3.12.1 Aufgabe

Aus einer Tabelle werden 90 Sinuswerte nacheinander an den DAC ausgeben.

Am Ausgang des DAC entsteht eine sinusförmige Spannung.Die Ausgabe soll mit dem Druck auf den taster P2.2 unterbrochen werden.




3.12.2 C-Programm Sinus mit I²C-DAC/* I2C-Bus DA-Converter SDA -> P1.0, SCL -> P1.1 * Sinus aus 90 Werten ausgeben*/


uint8_t z=0; // Zählvariableuint8_t sinus [ ]= {

128,136,145,154,163,171,180,188,195,203,210,216,223,228,234,238,243,246,249,252,254,255,255,255,255,254,252,249,246,243,238,234,228,223,216,210,203,195,188,180,171,163,154,145,136,128,119,110,101,92,84,75,67,60,52,45,39,32,27,21,17,12,9,6,3,1,0,0,0,0,1,3,6,9,12,17,21,27,32,39,45,52,60,67,75,84,92,101,110,119};

int main(void) // Hauptprogramm{ i2c_init(); // I2C initialisieren bit_init(P2,2,INP); while(1U) // Endlosschleife {

i2c_start(); // Startbedingung i2c_write(0x96); // Adresse, Master schreibt R/W=0 i2c_write(0x40); // Controlbyte DAC-Ausgang freigeben while (bit_read(P2,2)==1) // ausgeben bis Taste gedrückt {

i2c_write(sinus[z]); // Wert ausgeben if (z < 89) z++; else z = 0; // Tabelle abarbeiten

}// while (bit-read) i2c_stop(); // Stoppbedingung

}//while}//main

3.12.3 Erweiterungen

• Amplitude über Poti änderbar




3.13 Datenübertragung COM-Schnittstelle3.13.1 Ascii „A“ dauernd senden, 1Byte empfangen und binär und als Ascii darstellen/* Test serielle Kommunikation, Am PC HTerm starten mit 9600Baud und Connect drücken */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

uint8_t sendebyte,empfbyte;int main(void) // Hauptprogramm{ delay_ms(500); // Start LCD-controller rs232_init(); // Com-Schnittstelle initialisieren lcd_init(); // LCD initialisieren port_init(P0,OUTP); // Port0 auf Ausgabe while(1U) // Endlosschleife {

sendebyte = 'A'; // Code vom Ascii-Zeichen A bestimmen //sendebyte = 0x41; // alternativ als Hexzahl rs232_put ( sendebyte ); // senden //rs232_print ( char *text ) empfbyte = rs232_get(); // 1 Byte abholen if (empfbyte != 0)

{ port_write(P0,empfbyte); // und als Dualzahl an LEDs ausgeben lcd_setcursor(1,1); // links oben lcd_char(empfbyte); // anzeigen }

delay_ms (100); // Zeitverzoegerung }//while}//main

3.13.2 Oszillogramm

Grundzustand 1, dann Startbit 0, dann 10000010, dann Stoppbit=Grundzustand der LeitungLinks steht das zuerst empfangene, LSB → Binär 01000001 = hex 41 = Ascii „A“

Beim Controller wird dies über die USB-Schnittstelle und über P1.2 übertragen, dort kann man oszilloskopieren.

3.13.3 Hterm-Programm

Empfangene Zeichen werden als Ascii-Zeichen dargestellt: AAAA…Protokoll: 9600 Bit/s, 8 Datenbit, 1 Sopbit, kein ParitätsbitUSB-Verbindung der Entwicklungsumgebung Dave wird für die Datenübertragung verwendet um am PC als COM6 für die Com-Verbindung verwendet.




3.13.4 Fernsteuerung einer RGB-LED-Lichterkette am Controller über Labview am PC

• C-Programm (unten) amController starten.

• Labview am PC starten• Schnittstelle wählen.• Farbe der RGB-LED mit

Schiebereglern oder ober dasFarbfeld einstellen.

• Die Kommunikation erfolgt überdie COM-Schnittstelle. 3 Bytesübertragen die Tastgrade derPWM-Signale, die der Controllererzeugt.

/* Serielle Kommunikation: Labview-Programm steuert RGB-LED am Controller */#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100uint8_t r_byte, g_byte, b_byte;int main(void) // Hauptprogramm{ pwm1_init(); // PWM Kanal 0 initialisieren pwm2_init(); // PWM Kanal 1 initialisieren pwm3_init(); // PWM Kanal 1 initialisieren pwm1_start(); // Ausgabe starten pwm2_start(); // Ausgabe starten pwm3_start(); // Ausgabe starten pwm1_duty_cycle(0); // Tastgrade pwm2_duty_cycle(0); pwm3_duty_cycle(0); rs232_init(); while(1U) // Endlosschleife { if (rs232_char_received()!=0){

r_byte = rs232_wait_get(); // Tastgrad für Rot vom PC holen g_byte = rs232_wait_get(); // Tastgrad für Gruen vom PC holen b_byte = rs232_wait_get(); // Tastgrad für Blau vom PC holen

}// if pwm1_duty_cycle(~r_byte); // Tastgrade pwm2_duty_cycle(~g_byte); // Invertierung bei lowaktiver RGB-LED pwm3_duty_cycle(~b_byte);

}//while}//main




4 Formelsammlung C/C++

4.1 DatentypenDatentyp stdint.h type Bits Sign Wertebereich

(unsigned) char uint8_t 8 Unsigned 0 .. 255

signed char int8_t 8 Signed -128 .. 127

unsigned short uint16_t 16 Unsigned 0 .. 65.535

short int16_t 16 Signed -32.768 .. 32.767

unsigned int uint32_t 32 Unsigned 0 .. 4.294.967.295

(signed) int int32_t 32 Signed -2.147.483.648 .. 2.147.483.647

unsigned long long uint64_t 64 Unsigned 0 .. 18.446.744.073.709.551.615

long long int64_t 64 Signed -9.223.372.036.854.775.808 .. 9.223.372.036.854.775.807

Datentyp IEE754 Name Bits Wertebereich

float Single Precision 32 -3,4E38 .. 3,4E38

double Double Precision 64 -1,7E308 .. 1,7E308

pointer 32 Adresse einer Variablen

4.2 OperatorenDa Gleichheitszeichen ist in C ein Zuweisungsoperator, d.h. einer Variablen einen Wert zuweisen, z.B. x = 10;

Mathematische Operatoren Priotität Verhältnis- und logische Operatoren

++ Inkrement Höchste ! NOT

– Dekrement

- Vorzeichen > Größer

>= Größer gleich

< Kleiner

<= Kleiner gleich

* Multiplikation==!=

GleichUngleich

/ Division

% Modulo, Rest der Division

+ Plus && AND

- Minus

niedrigste || OR

+= x += 3; wie x = x + 3

-= x -= 3; wie x = x - 3;

*= x *=5; wie x = x * 5;

/= x /= 7; wie x = x / 7;

Bitweise Operatoren Beispiele Ergebnisse

& UND X = 10;

| ODER Y=++X; Y=11

^ EXOR Y=X++; Y=10

~ Einerkomplement Y=0x11;

<< Nach links schieben Y=Y<<1; Y=0x22

>> Nach rechts schieben (bitweise um 1 nach links schieben)




4.3 Aufbau eines C-ProgrammsC unterscheidet zwischen Groß- und Kleinschreibung!

4.3.1 Kommentareingabe

// Kommentar für eine Zeile/* Kommentar für einen Block von eineroder mehreren Zeilen */

4.3.2 Befehlsblock

{ // Anfang eines zusammengehörigen Befehlsblocks (begin)} // Ende eines zusammengehörigen Befehlsblocks (end)

4.3.3 Compileranweisung über zusätzliche Quellcodes mit Funktionen und Deklarationen:

#include <XMC1100-Lib.h> // Hilfsfunktionen fuer XMC1100

4.3.4 Konstantendeklaration

#define muster1 0x0F // LED-Bitmuster 1 untere 4 LEDs an

4.3.5 Deklaration von globalen Variablen (vor main!)

uint16_t adc_wert; // Wert vom AD-Converter 16 Bit unsigned

4.3.6 Deklaration von Funktionen

Siehe Funktionen

4.3.7 Hauptprogramm (Hauptfunktion)

int main(void) // Hauptprogramm{}

4.3.8 Beispiel

// Projectname: 1_Blinklicht_Zeit_veraenderbar// Blinklicht mit druch Poti veraenderbarer Zeitverzoegerung

#include <XMC1100-Lib.h> // Bibliothek fuer XMC1100#define muster1 0x0F // LED-Bitmuster 1 unter 4 LEDs#define muster2 0xF0 // LED-Bitmuster 2 obere 4 LEDs

uint16_t adc_wert; // Wert vom AD-Converter 16 Bit unsignedint main(void) // Hauptprogramm{ port_init(P0,OUTP); // Port0 auf Ausgabe adc_init(); // Analog-Digital-Converter initialisieren while(1U) // Endlosschleife, immer bei Controllern {

port_write(P0,muster1); // Muster1 an Port0 ausgeben adc_wert = adc_in(0); // Wert vom ADC -> Zeitverzoegerung delay_ms (adc_wert); // Zeitverzoegerung port_write(P0,muster2); // Muster2 an Port0 ausgeben delay_ms (adc_wert); // Zeitverzoegerung

}//while}//main




4.4 Schleifen 4.4.1 For-Schleife (zählergesteuerte Schleife)

Erzwingt eine genau berechenbare Zahl der Wiederholungen

for(<startwert>;<Bedingung>;<Schrittweite>){ //Anweisungen}

startwert: Anfangswert der VariablenBedingung: Schleife wird solange durchlaufen wie die Bedingung wahr istSchrittweite: Anweisung zum Erhöhen oder Erniedrigen der Variablen// Beispiel Ausgang 10x invertierenfor (x=10; x!=0; x--)

{ausgang =~ausgang;

}// Beispiel Zeitverzögerunguint32_t x;

for (x=100000; x!=0; x--); // Zeitverzoegerung

4.4.2 While-Schleife (kopfgesteuerte Schleife)

Wird nur solange wiederholt, wie eine am Schleifenanfang stehende Bedingung erfüllt ist.

while(<Bedingung>){ //Anweisungen}

Wenn die am Schleifenanfang stehende Bedingung nicht gilt, dann wird die gesamte Schleife übersprungenSolange die am Schleifenanfang stehende Bedingung gilt, wird die Schleife wiederholt.Die Prüfbedingung steht vor den Anweisungen. Sie heißt deshalb “kopfgesteuerte Schleife”.

// Beispiel: Solange der lowaktive Taster an P2.9 gedrückt ist, wird der Ausgang invertiert.

while (bit_read (P2,9) == 0){

ausgang = ~ausgang;}

4.4.3 Do-While-Schleife (fußgesteuerte Schleife)

Die Schleife wird prinzipiell erst mal durchlaufen. Am Ende des Durchganges steht eine Prüfbedingung, die entscheidet, ob die Schleife wiederholt wird.

do{ //Anweisungen} while(<Bedingung>)

// Beispiel: Die Schleife wird maximal 100 mal und mindestens // 1 mal durchlaufen. Sie wird frühzeitig abgebrochen, wenn der Taster an P2.9 gedrückt (= 0) wird.X = 100;do{

x--;}while ((x > 0) && (bit_read (P2,9) == 1));



Führe ab der Anfangsbedingung die Zählanweisung aus solange Bedingung wahr

Anweisungen

Solange Ausdruck wahr

Anweisungen

Solange Ausdruck wahr

Anweisungen


4.5 Programmverzweigungen

4.6 Verzweigung mit ifif(<Bedingung>){ <Anweisung1>;

<Anweisung2>;...

}

Bei der “if” - Anweisung werden die folgende Anweisung (oder ein ganzer Anwendungsblock) nur dann ausgeführt, wenn die hinter ”if” stehende Bedingung wahr ist. // Beispiel: Wenn “taster1” gedrückt ist, soll “ausgang1” eins und „ausgang2“ null werden. // Drückt man dagegen “taster2”, wird nur “ausgang2” zu eins.

if (taster1 == 1){ // Block mit mehreren Anweisungen

ausgang1 = 1; // wird ausgeführt, wenn die Bedingungausgang2 = 0; // hinter if wahr ist

}

if (taster2 == 1) ausgang2 = 1; // nur eine Anweisung, keine { } nötig

Mit “if - else “ kann nur zwischen zwei Alternativen wählen.if(<Bedingung>){ <Anweisung1>;

<Anweisung2>;}else{ <Anweisung3>;

<Anweisung4>;}

// Beispiel: Wenn “taster1” gedrückt ist, soll “ausgang1” eins und „ausgang2“ null werden,// andernfalls soll “ausgang1” null und „ausgang2“ eins werden.

if (taster1 == 1){ // Block mit mehreren Anweisungen

ausgang1 = 1; // wird ausgeführt, wenn die Bedingungausgang2 = 0; // hinter if wahr ist

}else{ // Block mit mehreren Anweisungen

ausgang1 = 0; // wird ausgeführt, wenn die Bedingungausgang2 = 1; // hinter if nicht wahr ist

}

4.6.1 Mehrere if-Anweisungenif(<Bedingung1>){ <Anweisung1>;

...}else if((<Bedingung2>){ <Anweisung3>;

...}else{ <Anweisung4>;

...}




4.7 Fallauswahl mit switchswitch(<Vergleichswert>){ case <Wert1>:

<Anw.1>;<Anw.2>;...break;

case <Wert2>:<Anw.3>;<Anw.4>;...break;

...default://Anweisungen

}

Mit der “switch”- Anweisung kann aus einer Reihe von Alternativen ausgewählt werden. Es ist zulässig, dass mehrere Möglichkeiten gültig sind und dieselbe Wirkung haben.Sie werden einfach nacheinander aufgelistet.Passt keine der Möglichkeiten, dann wird die “default” - Einstellung ausgeführt.Achtung! Auf keinen Fall break vergessen!!!

// Beispiel: In der Variablen “ergebnis” ist ein Messergebnis oder eine Zahl gespeichert.// Abhängig vom genauen Wert sollen nun bestimmte Reaktionen erfolgen.

switch (ergebnis){

case 0x00:case 0x10:case 0x20:

ausgang1 = 1; break;

case 0x30: ausgang1 = 0; break;

case 0x40: ausgang1 = ~ ausgang1;

break;default:

ausgang2 = 1;break;

}Hinweise:Für die „switch-Variable“ darf man nur einfache Datentypen verwenden.

Hinter case müssen Konstanten stehen. Diese können mit #define am Anfang des Programms deklariert werden.

#define rechts 0x10 // ohne Semikolon!!#define links 0x20unsigned char richtung;....switch (richtung){

case rechts: motor = rechtskurve; break; case links: motor = linkskurve; break; default: motor = vorwaerts; break;}




4.8 Funktionen <Datentyp Rückgabewert> <funktionsname>(<Datentyp> Parameter1, <Datentyp> Parameter2,...);

// Beispiele:void pwm_init1 (void); // ohne Rückgabewert, ohne Parametervoid lcd_byte (uint8_t val); // ohne Rückgabewert, mit einem Parameteruint8_t adc_in (uint8_t kanal); // mit Rückgabewert, mit Parameter

4.8.1 Definition von Funktionen<Datentyp> funktionsname(Datentyp> <Parameter1, <Datentyp> Parameter2,...){ //Anweisungen

return <Rückgabewert>;}// Beispiel:int addieren( uint8_t z1, uint8_t z2){ uint16_t result; // lokale Variable

result = z1 + z2;return (result); // Rückgabewert

} Achtung: Wenn eine Funktion definiert wird, folgen direkt hinter dem Funktionsnamen nur zwei runde Klammern, dahinter aber nix mehr (also NIE ein Strichpunkt)!!

4.8.2 Funktionsaufruf<funktionsname>(<Paramter1>, Paramter2,...);

// Beispiel:int main(void){ ...

value1 = adc_in (1); // Wert von Kanal1 des ADC holen}

4.8.3 Funktion mit Übergabewert

void zeitms (uint32_t sec) // 32-Bit-Übergabevariable sec{

uint32_t t1,t2; // lokale Variable for (t1 = sec; t1 != 0; t1--) // äußere Schleife ms * 1Millisekunde {

for (t2 = 0xFFFFFF; t2 != 0; t2--); // Wert für 1ms noch testen!// erzeugt Zeitverzögerung ca. 1s

}}

void main (void){

. . . . // Programm zeitms (2); // Funktionsaufruf mit Werteübergabe // hier: 2ms Zeitverzögerung}




5 Funktionsbibliothek für den Controller XMC1100Alle Header-Dateien werden in der Datei „#include <xmc1100-lib.h> in ein richtlinienkonformes Projekt eingebunden.

5.1 Verzögerungsfunktionen

DelayVerzögert den Programmablauf für die angegebene Zeitdauer

delay_ms(uint16_t millisec); // millisec = 0…65535delay_100us(uint8_t microsec100); // microsec100 = 0…255delay_10us(uint8_t microsec10); // microsec10 = 0…255

5.2 Bit- und Byte Ein-/Ausgabe

bit_init ( uint8_t port, uint8_t bitnr, uint8_t direction )uint8_t value = bit_read ( uint8_t port, uint8_t bitnr )bit_write ( uint8_t port, uint8_t bitnr, uint8_t value )

port_init ( uint8_t port, uint8_t direction )uint16_t value = port_read ( uint8_t port )port_write ( uint8_t port, uint8_t value )

Pararameterliste :port : P0 , P1 ,P2

bitnr : 0…7direction : INP = 0, OUTP =1Achtung : P2 nur Input möglich

5.3 Analog-Digital KonverterSechs analoge Eingänge, je 12 Bit Auflösung

adc_init ( );uint16_t value = adc_in (kanal-nr )

kanal-nr : 0 = AN0 (Poti) → P2.61 = AN1 ( Poti) → P2.82 = AN2 ( Buchse) → P2.93 = AN3 ( Buchse) → P2.104 = AN4 ( Buchse) → P2.117 = AN7 ( Buchse) → P2.2

Rückgabewert :value : 0 … 4095 ( 12 Bit Auflösung)

Achtung : AN2 .. AN7 können alternativ als ext. Interrupt oder digitaler Input verwendet werden.



Bsp.: Bit-Ein-Ausgabe#include <xmc1100-lib.h>uint8_t temp; void main(void){ bit_init( P2, 11, INP ); // Taster bit_init( P0, 0, OUTP ); // LED while (1) { temp = bit_read(P2,11); bit_write(P0,0,temp ); }}

Bsp.: ADC#include <xmc1100-lib.h>uint16_t wert;void main(void){ adc_init( ); byte_init( PORT0, OUT );

while(1) { wert = adc_in(1);// ADC einlesen byte_write( P0, wert >> 4 );

// 8 Bit OUT }}


5.4 Pulsweitenmodulation PWMEin digitaler Ausgang (PWM Out) zur Ausgabe eines pulsweitenmodulierten Signals.(Timer CCU40_CC40 bis CCU40_CC42 werden als 8-Bit-Timer verwendet!

pwm1_init ( ) // Init für Tastgrad 50% , Ausgabe an P0.6pwm1_start ( )pwm1_start_interrupt ( ) // Interrupt nach jeder Periodepwm1_stop ( )pwm1_duty_cycle ( uint8_t value )pwm1_duty_cycle_period (uint8_t compare, uint8_t period)



Pararameterliste :value, compare : 0 … 255 (entspricht Tastgrad 0…100%) . Initialwert: 127period: 0 … 255 (entspricht Periodendauer, compare<period)



Bsp.: PWM#include <xmc1100-lib.h> void main(void){ pwm1_init( ); pwm1_duty_cycle(64);//Tastgrad 25% pwm1_start( ); delay_ms(5000); pwm1_stop( ); while(1);}

Start/Stopp

pwm1_init ( ); // Tastgrad 50%, ca. 1,5 KHz gleich Interrupt

Reset

Vorteiler8-Bit-

Timerwert

Vergleicher

Periode

Takt64MHz

Freigabe

pwm1_duty_cycle ( compare );

Vereinfachte Darstellung: Timer im 8-Bit-PWM-Betrieb

Funktionen

pwm1_start ( );

Vergleicher

compare

timer<compare => 1P0.6

timer>compare => 0

pwm1_duty_cycle_period (compare, period );

pwm1_start_interrupt ( );

pwm1_stop ( );

PWM-Ausgang

Compare-Werttim

er 0...2

55 255

0

timer 0

...255 255

0

PWM-Signal anP0.6

timer<compare

=> 1

timer>compare

=> 0

0


5.5 Externer Interrupt Zwei externe Interrupteingänge: P2.9

P2.10Achtung: werden ext. Interrupt benutzt können diese Eingänge nichtgleichzeitig Analogeingänge sein.// bei fallender Flanke an P2.10, steigende Flanke an P2.9:ext_interrupt_init (); // beide Interrupts initialisieren

// Flanken wählbar wenn einzeln initialisiert:// flanke=RE=1 Rising Edge ansteigende Flanke// flanke=FE=0 Falling Edge abfallende Flankeext_interrupt1_init ( uint8_t flanke ); ext_interrupt2_init ( uint8_t flanke );

// Interrupts freigeben und sperren:ext_interrupt1_enable (); // Int. an P2.9 freigebenext_interrupt2_enable (); // Int an P2.10 freigebenext_interrupt1_disable (); // Int. an P2.9 sperrenext_interrupt2_disable (); // Int an P2.10 sperren

// Interruptfunktionen : (ISR) void ERU0_3_IRQHandler(void) // P2.9 steigend Flanke{ }

void ERU0_2_IRQHandler(void) // P2.10 fallende Flanke{ }

Achtung: die Funktionsnamen. void ERU0_3_IRQHandler(void) und void ERU0_2_IRQHandler(void) sind so vom System vordefiniert.



Bsp.: ext. Interrupt

#include <xmc1100-lib.h>uint8_t zaehler;

void main(void){ ext_interrupt1_init(RE); ext_interrupt1_enable ( ); while(1); // Endlos}// steigende Flanke an P2.9:void ERU0_3_IRQHandler (void ){ zaehler++;}


5.6 Timer5.6.1 Blockschaltbildbenutzt wird CCU40_CC43

5.6.2 Funktionenvoid timer_init (uint8_t vorteiler, uint16_t periode); // Timer initialisieren

// vorteiler 0...15 ergibt Teilung mit 2vorteiler

// periode 1...65536, 64 Mhz-Taktvoid timer1ms_init ( void ); // Timer initialisieren für 1ms, wie timer_init (1,32000);void timer_start(void); // Timer ohne Interrupt startenvoid timer_start_interrupt(void) // Timer mit Interrupt startenvoid timer_stop(void) // Timer stoppen ohne Resetuint16_t timer_value(void); // Timerwert lesen void timer_reset(void); // Timer rücksetzen

// festgelegter ISR-Funktionsname:void CCU40_3_IRQHandler (void) // Timer ISR {}Hinweis: alle Interrupts haben gleiche Priorität!

5.6.3 Zeitmessung

Vorteiler gemäß Tabelle wählentimer_init (vorteiler, 0xFFFF); // initialisieren



Bsp.: Timer Messfunktion

#include <xmc1100-lib.h>#define gedrueckt 0 // lowaktive Tasteruint16_t timer_wert,zeit;

int main(void){bit_init(P2,9,INP); // Start-Tasterbit_init(P2,2,INP); // Stopp-Tastertimer_init(0xC,0xFFFF); // 16uSek Timertakt,

// 4,2 Sek Periode max!!!while(1) { timer_reset(); // rücksetzen while (bit_read(P2,9)!= gedrueckt); // warten start timer_start(); // Timer starten while (bit_read(P2,2)!= gedrueckt); // warten stopp timer_stop(); // Timer anhalten timer_wert = timer_value(); // Wert auslesen zeit = timer_wert*64/1000; // Zeit in ms }}

Bsp.: Zeitgeber mit Timer-Interrupt#include <xmc1100-lib.h>uint8_t zaehler;

void main(void){ timer1ms_init( ); timer_start_interrupt ( ); while(1); // Endlos}// jede Millisekunde:void CCU40_3_IRQHandler (void ){ zaehler++;}

Wert Takt nach Vorteiler Timertakt Periode max.0 64 MHz / 1 15,625 nSek 1, 024 mSek 1 64 MHz / 2 31,25 nSek 2,1 mSek2 64 MHz / 4 62,5 nSek 4,1 mSek3 64 MHz / 8 125 nSek 8,2 mSek4 64 MHz / 16 250nSek 16,4 mSek5 64 MHz / 32 500 nSek 32,8 mSek6 64 MHz / 64 1 uSek 64,5 mSek7 64 MHz / 128 2 uSek 134,2 mSek8 64 MHz / 256 4 uSek 268,4 mSek9 64 MHz / 512 8 uSek 536,9 mSek0xA 64 MHz / 1024 16 uSek 1,05 Sek0xB 64 MHz / 2048 32 uSek 2,1 Sek0xC 64 MHz / 4096 64 uSek 4,2 Sek0xD 64 MHz / 8192 128 uSek 8,4 Sek0xE 64 MHz / 16384 256 uSek 16,8 Sek0xF 64 MHz / 32768 512 uSek 33,6 Sek

Start/Stopp

timer_init (vorteiler,periode);

gleichInterrupt

Reset


16-Bit-Timerwert

Vergleicher

Periode

Takt64MHz

Freigabe

timer_start ( );

timer_stop ( );


wert = timer_value ( );

timer1ms_init ( ); // wie timer_init (1,32000);


Funktionen

timer_reset ( );

Reset


5.7 Funktionen für die LCD Anzeige

LC-DisplayRoutinen zur Ansteuerung eines Textdisplays

lcd_init ( )lcd_clear ( )lcd_setcursor ( uint8_t row, uint8_t column ) // row (zeile) = 1, 2, … ; // column (spalte) = 1, 2, …lcd_print ( uint8_t text[ ] ) // Bsp.: “Hallo Welt“lcd_char ( uint8_t value ) // ‘A’, ‘B’, ‘:’, ‘?’, ….lcd_byte ( uint8_t value ) // 0 … 255lcd_int ( uint16_t value ) // 0 … 65535

5.8 Funktionen zur Kommunikation 5.8.1 RS232Serielle Schnittstellenroutinen zur Kommunikation mit einem PC Es wird P1.3 RxD Controller

P1.2 TxD Controller verwendet

rs232_init ( ) // 9600 Baud, 1 Startbit, 8 Datenbit, 1 Stopbit

uint8_t value = rs232_get ( ) // Liefert \0, wenn kein Zeichen // empfangen

uint8_t value = rs232_wait_get ( ) // wartet solange, bis ein // Zeichen empfangen wurde // empfangen

uint8_t rs232_char_received ( ) // liefert 1 wenn Zeichen // empfangen, sonst 0

rs232_put ( uint8_t value ) // Ausgabe eines Bytesrs232_print ( uint8_t text[ ] ) // Ausgabe eines Strings

Pararameterliste :value: Byte (8 Bit)text [ ]: Zeichenkette

Bsp.: "Hallo Welt!"

5.8.2 I2C-BussystemSchnittstellenroutinen zur Kommunikation mit I2C-BusKomponenten , es wird P1.0 SDA

P1.1 SCL verwendeti2c_init ( )i2c_start ( )i2c_stop ( )uint8_t ack = i2c_write ( uint8_t value )uint8_t value = i2c_read ( uint8_t ack )

Pararameterliste :ack : ACK = 0, NACK =1value: Byte (8 Bit)



Bsp.: RS232#include <xmc1100-lib.h>uint8_t meinText[ ] = “Controller sind toll!”;

void main(void){ rs232_init( ); rs232_print(meinText); rs232_print(“…aber klar!\n”); while (rs232_get( ) == '\0'); // Warten auf Zeichen rs232_put('A');

while(1); // Endlos}

Bsp.: I2C#include <xmc1100-lib.h>#define ADDR_R 0x41 //#define ADDR_W 0x40

uint8_t wert = 0x34;

void main(void){ i2c_init( ); i2c_start( ) ; i2c_write(ADDR_W); i2c_write(wert); i2c_stop( );

while(1); // Endlos}

Bsp.: LCD#include <xmc1100-lib.h>uint8_t meinText[ ] = "Controller sind toll!";

void main(void){ lcd_init(); lcd_setcursor(1,1); lcd_print(meinText); lcd_setcursor(2,1); lcd_byte(155); lcd_char('V'); while(1); // Endlos}


6 XMC1100-Trainer

6.1 Pinbelegungen



Portbit Buchse beachte! Schalter /Taster Sonderfunktion Sonderfunktionen

P0.0 LED Digital IN / OUT <= Schalter auf 1! Schalter lowaktiv




P0.4 LED Digital IN / OUT


P0.6 LED Digital IN / OUT pwm1








P1.0 LED Digital IN / OUT SDA (I2C)

P1.1 LED Digital IN / OUT SCL (I2C)

P1.2 TxD Kommunikation über USB TxD (COM)

P1.3 RxD Kommunikation über USB RxD (COM)


P2.0 SCLK LCD

P2.1 SDI LCD

P2.2 Analog / Digital IN <=Taster nicht gedrückt Taster lowaktiv adcin(7)

P2.6 Poti A0 adcin(0)

P2.8 Poti A1 adcin(1)

P2.9 Analog / Digital IN <=Taster nicht gedrückt Taster lowaktiv adcin(2) ext_Interrupt_init2()

P2.10 Analog / Digital IN <=Taster nicht gedrückt Taster lowaktiv adcin(3) ext_Interrupt_init1()

P2.11 Analog / Digital IN <=Taster nicht gedrückt Taster lowaktiv adcin(4)


6.2 Blockschaltbild



P0.00

1

P0.10

1

P0.6pwm1()

P0.7pwm2()

P0.8pwm3()

P0.9

5V P2.6

adcin(0)Poti A0

5V P2.8

adcin(1)Poti A1

P0.20

1

P0.30

1

0

1

P2.9

adcin(2) ext_Interrupt_init2()

0

1

P2.10

adcin(7) ext_Interrupt_init1()

0

1

P2.11

adcin(4)

0

1

P2.2

adcin(7)

P0.5

P0.4

P0.10

P0.11

P0.12

P0.13

P1.0

P1.1

P1.2

P1.3

P1.4

SDA

SCL

TxD

RxDCOM

I2C

P2.0

P2.1

SCLK

SDI

LC-Display

Documents

Inhaltsverzeichnis€¦ · Computertechnik J1 Mikrocontroller 1.5 Programm eingeben Doppelkick auf main.c des aktiven Projekts. Die Liste der Hilfsfunktionen in XMC1100-Lib finden