Erste Schritte

Die erste praktische Übung soll darin bestehen, dass ein XMC-Projekt angelegt und ein einfaches Programmgerüst erstellt wird. Danach schauen wir uns den Quellcode etwas näher an, übersetzen diesen und übertragen ihn in den Programmspeicher des XMC. Dazu muss SiSy XMC gestartet werden und die Experimentierhardware angeschlossen sein. Legen Sie ein neues Projekt mit dem Namen XMC_Tutorial an.

Wählen Sie das ARM Vorgehensmodell aus. Damit sind alle wichtigen Einstellungen für das Projekt und die darin enthaltenen Übungen als Default-Werte gesetzt.

Nach Auswahl des Vorgehensmodells öffnet SiSy LibStore und bietet vorhandene Vorlagen für die weitere Arbeit an. Wir brauchen für die ersten Schritte noch keine UML Bibliotheken. Damit können wir die Frage nach den Projektvorlagen mit „keine Vorlage verwenden“ beantworten oder den Dialog einfach mit der Schaltfläche Abbrechen beenden. Sie erhalten somit ein leeres Projekt. Die typische Aufteilung der SiSy-Oberfläche besteht aus Navigator, Explorer, Assistent, Diagrammfenster und Editor. Die Aufteilung zwischen Diagrammfenster und Editor können Sie sich je nach Bedarf anpassen.

Legen Sie Ihr erstes kleines Programm an, indem Sie das entsprechende Objekt aus der Objektbibliothek per Drag & Drop in das Diagrammfenster ziehen. Geben Sie dem Programm den Namen Beispiel1 und überprüfen Sie, ob die Zielsprache auf ARM C++ eingestellt ist.

Im nächsten Schritt wird die Hardware ausgewählt. Wir benutzen ein Entwickler-board von Infineon, das XMC4500 Relax (Lite) Kit, und den Programmer „J-Link“.

Bevor wir uns dem Stress aussetzen fast 40 Zeilen Programmcode abzutippen, benutzen wir lieber eines der Features von SiSy, die Programmgerüste. Wählen Sie im Dialog Definiere des kleinen Programms den Tabulator Programmgerüste. Selektieren Sie das Grundgerüst für ein ARM C++ Programm und laden Sie die Struktur über die Schaltfäche Struktur laden. Aber Achtung, bitte nicht mehrfach ausführen. SiSy fügt die ausgewählten Programmstrukturen jeweils an das Ende des bestehenden Quellcodes an.

Das nächste Dialogfeld mit Code-Wizzard überspringen Sie und wählen die Schaltfläche „Fertig stellen“. Sie gelangen wieder in das Diagrammfenster von SiSy; im Editorfenster wird der geladene Quellcode angezeigt.

Die Kontrolle bzw. Korrektur aller Einstellungen kann über den Definieren-Dialog erfolgen. Dafür wird im Diagrammfenster das Objekt markiert, mit der rechten Maustaste das Kontextmenü geöffnet und „Definieren…“ aktiviert. Unter den einzelnen Registerkarten können die Eintragungen kontrolliert, ggf. korrigiert, werden.

Grundstruktur einer einfachen ARM Anwendung

Schauen wir uns den geladenen Quellcode etwas genauer an. Dieser lässt sich in mehrere Bereiche unterteilen. Zum einen ist da der Programmkopf mit Dokumentation und Deklarationen. Hier werden unter anderem die Deklarationen, zum Beispiel die hardwarespezifischen Registernamen und die Funktionsdeklarationen des CMSIS sowie der Peripherietreiber für den XMC4500, aus externen Dateien in den Programmcode eingefügt (#include). Die stddef und stdlib sind exemplarisch eingefügte C-Standardbibliotheken.

//----------------------------------------------------------------------
// Titel     : Grundgerüst einer einfachen ARM C Anwendung in SiSy
//----------------------------------------------------------------------
// Funktion  : ...
// Schaltung : ...
//----------------------------------------------------------------------
// Hardware  : ...
// Takt      : ... MHz
// Sprache   : ARM C
// Datum     : ...
// Version   : ...
// Autor     : ...
//----------------------------------------------------------------------
#include <stddef.h>
#include <stdlib.h>
#include "hardware.h"

Die Dokumentation sollte immer gewissenhaft ausgefüllt werden. Vor allem die Beschreibungen von Funktion und Hardware sind sehr wichtig. Das richtige Programm zur falschen Schaltung oder umgekehrt kann verheerende Folgen haben. Es folgt der Definitionsteil. Hier finden sich globale Variablen oder eben Unterprogramme, besser gesagt Funktionen. Diese müssen vor dem ersten Benutzen deklariert sein. Das bedeutet in unserem Fall, dass die Funktion initApplication noch vor dem Hauptprogramm der Funktion main steht. Es gibt durchaus die Möglichkeit, dies auch anders zu tun, aber das ist dann doch eher Bestandteil eines reinen C/C++ Tutorials. Besonders der C-Neuling beachte den Funktionskopf, in dem Fall mit ohne Typ und Parametern sowie den Funktionskörper, begrenzt durch die geschweiften Klammern.

void initApplication()
{
	SysTick_Config(SystemCoreClock/100);
	// weitere Initialisierungen durchführen
}

Als vorgegebenen Funktionsaufruf finden wir dort die Initialisierung des SysTick-Timers. Dieser liefert uns schon mal ein regelmäßiges Timerereignis. In den Übungen werden wir dies recht schnell benötigen. An dieser Stelle können noch weitere Funktionen eingefügt werden. Es folgt jetzt das Hauptprogramm. Dies ist durch das Schlüsselwort main gekennzeichnet. Auch hier sehen wir wieder die Begrenzung des Funktionskörpers durch die geschweiften Klammern. Innerhalb des Hauptprogramms findet sich zuerst die Initialisierungssequenz. Dabei sollte als Erstes die Funktion SystemInit aufgerufen werden. Diese ist im Treiberfundus enthalten und übernimmt die Grundinitialisierungen des XMC Kerns. Die Funktion ist quellcodeoffen und kann bei Bedarf durch den Entwickler für ein Projekt angepasst werden. Als Einsteiger nehmen wir diese, wie sie vorgefertigt ist. Danach initialisieren wir die Peripherie. Das erfolgt durch Aufruf der bereits besprochenen Funktion initApplication.

int main(void)
{
	SystemInit();
	initApplication();
	do{
		// Eingabe
		// Verarbeitung
		// Ausgabe
	} while (true);
	return 0;
}

Zum Schluss folgen die Interrupt Service Routinen und Ereignishandler. Da diese nicht explizit zum Beispiel aus der main aufgerufen werden, sondern in der Regel an für unser Anwendungsprogramm quasi externe Hardware-Ereignisse gebunden sind und automatisch auslösen können, stehen sie hinter dem Hauptprogramm als Letztes .

extern "C" void SysTickFunction(void)
{
	// Application SysTick			
}

Bilden und Übertragen des Programms

Rekapitulieren wir kurz, was bisher getan wurde. Wir haben ein neues Projekt, ohne Vorlagen zu importieren, angelegt, ein kleines Programm in das Diagrammfenster gezogen und für die Zielsprache ARM C++ ein Grundgerüst geladen. Diesen Quellcode können wir jetzt übersetzen (kompilieren, linken) und in den Programmspeicher des Controllers (FLASH) übertragen (brennen).

Beachten Sie die korrekte Verbindung zum JLink:

Vergegenwärtigen Sie sich nochmals den Gesamtzusammenhang. Sie haben einen Quelltext in der Entwicklungsumgebung SiSy erstellt und zu einer lauffähigen Mikrocontrolleranwendung übersetzt. Dieses Programm (Firmware) wird über eine spezielle Programmierschnittstelle (J-Link) in den Programmspeicher (FLASH) des Mikrocontrollers übertragen. Beobachten Sie das Verhalten der Entwicklungsumgebung SiSy und der Hardware.

Während der Übertragung kann man die Status-LED des integrierten JLink flackern sehen. Der XMC „arbeitet“ jetzt. Da unser Programm selbst aber nur ein leeres Grundgerüst ist, läuft der Controller faktisch im Leerlauf. Es sind keine Bausteine bzw. keine Peripherie aktiv.

Videozusammenfassung

Geschaft, wir haben erfolgreich unser erstes XMC-Projekt angelegt ein kleines Programm „geschrieben“, übersetzt und auf den Controller übertragen. Unsere Entwicklungsumgebung, bestehend aus Software und Hardware, funktioniert. Und hier diesen Abschnitt als Videozusammenfassung zum nochmal drüberschauen.

Nächstes Thema

grundstruktur.txt · Zuletzt geändert: 2017/04/10 18:06 von huwaldt