Informationstechnik I Praktikum (SS 2021

Institut für Technik der Informationsverarbeitung (ITIV)

KIT – Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu

Informationstechnik I Praktikum (SS 2021)

Einführungsveranstaltung 2M.Sc. Martin Sommer


TIVAWARE™ UND CCS

21.05.2021 IT I Praktikum – Einführungsveranstaltung 2

M.Sc. Martin Sommer


Was ist TivaWare™?

Register konfigurieren den Mikrocontroller (siehe letzte EV)

Adressierung der Register mühselig und fehleranfällig

Lösung: Nutzen einer Software-Bibliothek: TivaWare™ API

Konfigurierung der Module mittels Funktionsaufrufen

Manipulieren der Register entfällt

TivaWare™ hat Konstanten definiert, welche für die entsprechenden Einstellungen in

den Registern des Mikrocontrollers stehen (Hex-Adressen) und leicht verständlich sind

Beispiel: GPIO_PORTA_BASE = 0x40004000


M.Sc. Martin Sommer


Beispiel: GPIODirModeSetvoid

GPIODirModeSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32PinIO)

{

ASSERT(_GPIOBaseValid(ui32Port));

ASSERT((ui32PinIO == GPIO_DIR_MODE_IN) ||

(ui32PinIO == GPIO_DIR_MODE_OUT) ||

(ui32PinIO == GPIO_DIR_MODE_HW));

HWREG(ui32Port + GPIO_O_DIR) = ((ui32PinIO & 1) ?

(HWREG(ui32Port + GPIO_O_DIR) | ui8Pins) :

(HWREG(ui32Port + GPIO_O_DIR) & ~(ui8Pins)

HWREG(ui32Port + GPIO_O_AFSEL) = ((ui32PinIO & 2) ?

(HWREG(ui32Port + GPIO_O_AFSEL) | ui8Pins) :

(HWREG(ui32Port + GPIO_O_AFSEL) & ~(ui8Pins)));

}


M.Sc. Martin Sommer

Funktionsdefinition in

TivaWare™

(wird beim Benutzen der API

angegeben)

Registerzugriffe

(werden beim Benutzen der

API automatisch gesetzt)


Vergleich: Register und TivaWare™


M.Sc. Martin Sommer

RGB blink code mit Registern

RGB blink code mit der TivaWare™ API


Editor

Editor

Editor

Vom Editor zur ausführbaren DateiDie Entwicklung großer Programme und

Programmpakete, die aus vielen einzelnen

Quelltext-Dateien bestehen und Abhängigkeiten

zu separaten Bibliotheken besitzen, ist ohne

„Hilfsmittel“ kaum mehr denkbar.


M.Sc. Martin Sommer


Editor

Editor

Editor

Programm-EditorErmöglicht „sauberes“ Schreiben von Code

Auto-Formatierer

Syntax Highlighting

Auto-Completion

Integration

Versionierung

Syntax-Checker


M.Sc. Martin Sommer


Editor

Editor

Editor

CompilerZiel-Plattformspezifisch

Übersetzt Programmiersprache

(Hochsprache) in Assembler-Code


M.Sc. Martin Sommer


Editor

Editor

Editor

AssemblerEin Übersetzer zur Übertragung von

Assembler-Quellprogrammen in

Maschinensprache wird als Assembler oder

Assemblierer bezeichnet

Erzeugt aus einzelnen Programmquellen

Objektdateien

In diesen Objektdateien sind noch nicht alle

Sprungbefehle und Funktionsaufrufe

aufgelöst

das erledigt der Linker


M.Sc. Martin Sommer


Editor

Editor

Editor

LinkerVerknüpft Objektdateien

Bettet aus Bibliotheken verwendete

Funktionen ein

Dynamic Binding: Verweis auf ladbare

Bibliotheken

Bildet ausführbare Datei


M.Sc. Martin Sommer


Editor

Editor

Editor

DebuggerArbeitet mit fertigem Objektcode

Instrumentalisiert Programmcode

Fängt Fehler im Programmablauf ab und

liefert Informationen darüber, wo diese

auftraten

Kann mit eingebetteter Debugging-

Information betroffene Codezeile bestimmen


M.Sc. Martin Sommer


Editor

Editor

Editor

Coding TippsErst denken, dann programmieren

So einfach wie möglich

„Keep it simple, stupid“ (KISS)

Struktur führt zu Ordnung

führt zu Fehlervermeidung

Ein funktionierendes, langsames Programm

ist mehr wert, als ein schnelles, fehlerhaftes

Programm.

Sofort kommentieren, nicht nachträglich

Lesbarkeit führt zu Wartbarkeit

Interpretierbarkeit bei Namen (Variablen,

Funktionen, etc.) führt zu Verständlichkeit


M.Sc. Martin Sommer


Zusammenfassung

Tool Aufgabe

Editor Programmcode meist reines Textdokument; daher Verwendung eines Klartexteditor

(erstellt Quelltextdatei).

Compiler Versteht die Programmiersprache und übersetzt den Quellcode in Assembler- bzw.

Maschinen- oder Pseudocode (übersetzt in Objektdatei).

Linker Verbindet die einzelnen Objektdateien des Programmierers mit den

Bibliotheksfunktionen, so dass die Verweise und Sprungbefehle in der resultierenden

ausführbaren Datei korrekt sind.

Debugger Unterstützt den Entwickler bei der Fehlersuche, in dem er Einblick in den

Programmzustand zur Laufzeit gewährt

Bibliotheken Stellen Funktionalität zur Verfügung, die dem Programmierer das Erstellen von

Software ermöglicht, ohne jedesmal das Rad neu zu erfinden


M.Sc. Martin Sommer


CCS: funktionale Übersicht

Integrated Development Environment (IDE) basierend auf Eclipse

Enthält alle Entwicklungswerkzeuge:

Compiler, Assembler, Linker, Debugger, BIOS und Simulator

Ref: Getting Started With the Tiva C Series TM4C123G LaunchPad Workshop


M.Sc. Martin Sommer


PROGRAMMUMGEBUNG IT1

PRAKTIKUM21.05.2021 IT I Praktikum – Einführungsveranstaltung 2

M.Sc. Martin Sommer


Klassenaufbau im IT I Praktikum


M.Sc. Martin Sommer

Hardware

TivaWare™ API

ADC Timer PWM GPIOSystem

Steering Segway Controller

Hardware

unabhängige

Klassen

Low-Level

Klassen

Register

Manipulation

Physische

Komponenten

MPU6050


Aufgaben und Methoden der Klassen (1)

ADC, Timer und PWM (Ihre Aufgabe)

Freischaltung und Konfiguration der Hardware

Abstraktion der Benutzung (aber auch Einschränkung)

Ausführliche Beschreibung jeder Klasse im Handbuch

GPIO-Klasse (gegeben)

Ausführliche Erklärung folgt später in der Einführungsveranstaltung

MPU6050-Klasse (gegeben)

Kommunikation über I2C (digitales, serielles Protokoll) liefert Beschleunigungsdaten

System-Klasse (gegeben)

Konfiguriert Mikrocontroller

Abfrage der Einstellungen (z.B. Taktfrequenz)

Ermöglicht Debugging über Arduino IDE und System::error


M.Sc. Martin Sommer


Aufgaben und Methoden der Klassen (2)

Segway-Klasse (teilweise gegeben)

Liefert Daten an Controller-Klasse

Übernimmt Überwachungsaufgaben im Hintergrund (z.B. Batteriespannung)

Controller-Klasse (gegeben)

Regelalgorithmus zum Fahren des TivSeg™ (bzw. MiniSeg™)

Steering-Klasse (Ihre Aufgabe)

Liefert normierte Lenkdaten an Segway-Klasse


M.Sc. Martin Sommer


Ordnerstruktur PIT

Zu jeder Hardwareklasse gehört ein Testprogramm

Jedes Testprogramm (main.cpp etc.) in eigenem Ordner (xxx_Class_Test)

Alle Klassen in gemeinsamen Ordner (Common_Classes)

Segway_Test enthält das eigentliche Segway Programm, das das Fahren auf dem TivSeg™ ermöglicht

Besonderheiten

Mehrere Projektdateien, teilen sich die gleichen Quell- und Headerdateien

Dateien aus Common_Classes werden nur in die Testprojekte verlinkt

Änderungen an einer Datei (außer main.cpp) ändern die Datei in allen Projekten!

Nur Einsatz von leeren Default Konstruktoren und Destruktoren (erspart weiterführende C++ Kenntnisse)

init-Methode ersetzt den Konstruktor


M.Sc. Martin Sommer


Testprogramme

Testprogramme erlauben das unabhängige Testen einzelner Klassen (main.cpp im

entsprechenden Projekt)

GPIO (bereits vorhanden)

ADC

PWM

Timer

Funktion der Testprogramme ist sehr trivial, überprüft aber (fast) alle Funktionalitäten der Klasse

Bsp: Taster auslesen, LED einschalten, Spannung auslesen

Debugging mit den Testprogrammen ist meistens einfacher, als mit dem kompletten Segway Programm!

Beispiele für die Testprogramme sind im Handbuch beschrieben

Eigene Ideen/Umsetzungen aber erlaubt und erwünscht (außer beim Timer)


M.Sc. Martin Sommer


Klassenbibliotheken (1)

Von uns erstellte Softwarebibliotheken mit Musterlösung für alle zu schreibenden Klassen

Quellcode ist in der Bibliothek bereits kompiliert → Sie können Sie benutzen, aber nicht deren

Inhalt sehen!

Einbinden über #define USE_xxx_LIBRARY

Beispiel ADC-Klasse (ADC.cpp):

//#define USE_ADC_LIBRARY → Ihre ADC-Klasse wird kompiliert und verwendet

#define USE_ADC_LIBRARY → Die Musterlösung wird verwendet, Ihr Code wird nicht

beachtet


M.Sc. Martin Sommer

// Uncomment following #define to use the precompiled ADC library instead of

// the code in this file.

//#define USE_ADC_LIBRARY


Klassenbibliotheken (2)

Nutzung der Musterlösung in folgenden Situationen erlaubt und sinnvoll

Sie arbeiten alleine oder zu zweit (siehe Prüfungskriterien)

Die fehlenden Klassen werden durch die Bibliothek ersetzt

So können Sie trotzdem am Segway Programm (z.B. Lenkung) arbeiten

Beim Testen des geschriebenen Codes

Einbinden der Bibliothek um herauszufinden, ob der Fehler in der Klasse oder im Testprogramm

liegt


M.Sc. Martin Sommer


Einrichtung von CCS und TivaWare™

Gemeinsames Einrichten im Hörsaal

CCS sollten Sie bereits installiert haben

TivaWare™ wird mit GitHub Desktop aus „Dokumente und Infos“ gepullt

Verzeichnis: „Aufgabenstellung und Unterlagen“ → „TivaWare_C_Series-2.1.4.178”

Bevor Sie an Ihrem Quellcode arbeiten können, müssen Sie Ihr Gruppenrepository

ebenfalls mit GitHub Desktop klonen

Schritt-für-Schritt Anleitung im „Handbuch IT1 Praktikum“ verfügbar

Unbedingt 1:1 befolgen, falls Sie CCS nicht in der Einführungsveranstaltung eingerichtet

haben!


M.Sc. Martin Sommer


LENKUNG TIVSEG™Einschub


M.Sc. Martin Sommer


Auslesen der Lenkdaten


M.Sc. Martin Sommer

Lenkstange ist mechanisch mit einem Potentiometer gekoppelt

Liefert positionsabhängige Spannung (0-3,3V) am ADC Eingang (PE1)

Problem: nur kleiner Lenkausschlag, Spannungsbereiche

konstruktionsbedingt bei jedem TivSeg™ unterschiedlich

Bsp: TivSeg™ 1: 2,0V-2,4V

TivSeg™ 2: 2,5V-3,0V

Lösung: Entwickeln einer Steering-Klasse, die den Wertebereich des

verwendeten TivSeg™ ermittelt und die Spannung auf den Bereich -1…+1

normiert

Die normierten Daten werden vom Regler (Controller-Klasse) verarbeitet 3,3V

GND

Potentiometer


Verarbeitung der Lenkdaten (1)


M.Sc. Martin Sommer

Spannung am ADC

Ausgabe der Steering-Klasse


Verarbeitung der Lenkdaten (2)

Ausgelesene Werte beispielhaft für ein TivSeg™ mit Arduino IDE:


M.Sc. Martin Sommer

Spannung am ADC: 2,5V…3V

Ausgabe der Steering-Klasse: -1…+1

-1: Lenkstange nach rechts ausgeschlagen

0: Lenkstange in Mittenposition

+1: Lenkstange nach links ausgeschlagen


LAUNCHPAD


M.Sc. Martin Sommer

Aufbau und Nutzung


Module des LaunchPads

Alle Funktionen sind in Modulen organisiert

Manche sind mehrfach vorhanden


M.Sc. Martin Sommer


Verwenden der Module

Alle Module werden auf die gleiche Art aktiviert und konfiguriert

1) Freischalten mit SysCtlPeripheralEnable(…)

2) Konfigurieren (gewünschte Funktionsweise festlegen) mit MODULConfigure(…)

3) Ggf. Pins zuweisen mit GPIOPinConfigure(…)

4) Pins für gewünschte Funktion konfigurieren mit GPIOPinTypeFUNCTION(…)

5) Modul verwenden


M.Sc. Martin Sommer


GPIO-KLASSE

Programmierbeispiel


M.Sc. Martin Sommer


Aufbau der Klasse

Klasse ermöglicht die Konfiguration und Verwendung eines beliebigen GPIO Pins

Klassenmethoden:

init: Initialisierung des Pins und Ports, wird einmalig ausgeführt

read: Pin auslesen und Wert zurückliefern (true oder false)

write: Schreiben des Pins mit übergebenem Wert

getCurrent: Eingestellten Maximalstrom auslesen und zurückliefern

setCurrent: Übergebenen Maximalstrom einstellen

setPullup: Eingebauten Pull-up-Widerstand aktivieren oder deaktivieren

setPulldown: Eingebauten Pull-down-Widerstand aktivieren oder deaktivieren

Sämtliche Klassenmethoden sind im „Handbuch IT1 Praktikum“ beschrieben, angegeben sind:

Rückgabewert und -typ

Übergabeparameter mit Beispielwerten

Funktion/Umsetzung (Was soll die Methode tun?)


M.Sc. Martin Sommer


GPIO::init – Aufgabenstellung (1)

Rückgabewert/-typ

void

Übergabeparameter

System *sys: Zeiger auf die laufende Instanz der System-Klasse

uint32_t portBase: Basisadresse des GPIO Ports, z.B. GPIO_PORTA_BASE

uint32_t pin: Pin innerhalb des Ports, z.B. GPIO_PIN_0

uint32_t dir: Legt fest, ob es sich um einen Eingang oder einen Ausgang

handelt.

Kann GPIO_DIR_MODE_IN oder GPIO_DIR_MODE_OUT sein.

bool pullup: Optionale boolesche Variable, die angibt, ob der Pull-up-

Widerstand verwendet werden soll, oder nicht. DerStandardwert ist false.


M.Sc. Martin Sommer


class GPIO

{

public:

GPIO();

virtual ~GPIO();

void init(System *sys, uint32_t portBase, uint32_t pin, uint32_t dir,

bool pullup = false);

}

#include "GPIO.h"

GPIO::GPIO() {//Default empty constructor}

GPIO::~GPIO() {//Default empty destructor}

void GPIO::init(System* sys, uint32_t portBase, uint32_t pin, uint32_t dir,

bool pullup)

21.05.2021

GPIO::init – Methodenerstellung Header (GPIO.h)

IT I Praktikum – Einführungsveranstaltung 2

M.Sc. Martin Sommer

Quellcode (GPIO.cpp)

Übergabeparameter

Rückgabewert Standardwert



Funktion/Umsetzung

Die GPIO::init-Methode führt alle nötigen Schritte aus, damit der Pin verwendet

werden kann. Dazu gehört:

alle Pin-Eigenschaften als private Variablen im Objekt speichern

den Port freischalten

den Pin als Ein- bzw. Ausgang konfigurieren

ggf. den Pull-up-Widerstand aktivieren.


M.Sc. Martin Sommer



Funktion/Umsetzung

Die zu speichernden Eigenschaften sind:

uint32_t portBase: Die Basisadresse des Ports, z.B. GPIO_PORTF_BASE

uint32_t pin: Der Pin innerhalb des Ports, z.B. GPIO_PIN_3

uint32_t dir: Angabe, ob es sich um einen Ein- oder Ausgang handelt, z.B.

GPIO_DIR_MODE_IN

uint32_t current: Der aktuelle Maximalstrom in Form der API-Konstante, z.B.

GPIO_STRENGTH_2MA

uint32_t pinType: Der Pin-Typ, und somit ob Pull-up- oder Pull-down- Widerstände

aktiviert sind, z.B. GPIO_PIN_TYPE_STD

Es handelt sich dabei um private Variablen. Beachten Sie auch, dass manche API-Funktionen

Standardeinstellungen vornehmen. Aktualisieren Sie ggf. die zugehörigen Objektvariablen.


M.Sc. Martin Sommer


class GPIO {

public:

//(gekürzt)

private:

System *sys;

uint32_t portBase, pin, dir,

current, pinType;

}

//(gekürzt)

void GPIO::init(System* sys,

uint32_t portBase, uint32_t pin,

uint32_t dir, bool pullup)

{

//Save system port, pin and

direction

this->sys = sys;

this->base = portBase;

this->pin = pin;

this->dir = dir;

//Standardwerte (gpio.c Zeile 1552

-1614)

this->purrent = GPIO_STRENGTH_2MA;

this->pinType = GPIO_PIN_TYPE_STD;

}

21.05.2021

GPIO::init – Abspeichern der Variablen

IT I Praktikum – Einführungsveranstaltung 2

M.Sc. Martin Sommer

Definition privater VariablenPrivate Variable

dieses Objetes

Übergabewert aus

Funktionsaufruf

Header (GPIO.h) Quellcode (GPIO.cpp)

Aufgerufenes

Objekt



Funktion/Umsetzung








M.Sc. Martin Sommer


GPIO::init – Arbeiten mit den Unterlagen

Bisherige Schritte: nur Erstellung der Funktionen und Variablen, sowie deren Zuweisung

Ab jetzt: Nutzen der TivaWare™ API zur Konfiguration des GPIO Moduls

Dies passiert alles im Quellcode (GPIO.cpp)

Erste Aufgabe: Freischalten des Ports

Welche der unzähligen API Methoden ist hier hilfreich?

Am Ende jedes Kapitels in der „TivaWare™ Treiberbibliothek“ finden Sie ein Programmierbeispiel. Dies ist ein guter Ausgangspunkt, um sich mit der Funktionsweise eines Moduls vertraut zu machen.

Für GPIO: Kapitel 14.3, Seite 280


M.Sc. Martin Sommer


GPIO::init – Auszug aus Seite 280 TivaWare


M.Sc. Martin Sommer

Aktivieren von Port A

Abwarten, bis Port A aktiviert ist

Hier wird Port A freigeschaltet.

Wir müssen den Code an „unsere “ portBase anpassen


GPIO::init – Aktivierung


M.Sc. Martin Sommer

switch (portBase)

{

case GPIO_PORTA_BASE:

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

break;

case GPIO_PORTB_BASE:

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

break;

//(gekürzt, Fälle C-F)

default:

sys->error(GPIOWrongConfig, &portBase, &pin, &dir);

}

Quellcode (GPIO.cpp)

Im Fehlerfall die System::error betreten

GPIO_PORTA_BASE ist

eine hexadezimale

Adresse, also Integer


GPIO::init – Abwarten

Im Driverlib-Beispiel: Nutzen von

while(!SystCtlPeripheralReady(SYSCTL_PERIPH_GPIOA))

Dies ist umständlich, da wir das für jeden Port einzeln schreiben müssten

Wieso und wie lange muss gewartet werden?

SysCtlPeripheralEnable in der „TivaWare™ Treiberbibliothek“ nachschlagen (S. 502-503)

Lösung: Nach spätestens 5 Taktzyklen ist das Modul aktiviert

Abwarten mit System::delayCycles(cycles)

Nächste Zeile im Quellcode:


M.Sc. Martin Sommer

sys->delayCycles(5);

It takes five clock cycles after the write to enable a peripheral before the the peripheral is actually

enabled. During this time, attempts to access the peripheral result in a bus fault. Care should be taken toensure that the peripheral is not accessed during this brief time period.



Funktion/Umsetzung








M.Sc. Martin Sommer


GPIO::init – Ein- und Ausgang


M.Sc. Martin Sommer

Um einen Überblick über die Methoden der API zu erhalten, lohnt sich ein Blick auf die

ersten Seiten des Kapitels zum Modul in der Driverlib

Für GPIO: Kapitel 14.2, Seite 280

GPIODirModeSet erledigt genau das, was wir benötigen

Beschreibung der Methode durch Klick auf den Namen im PDF (Kapitel 14.2.3.4)

Nächste Zeilen im Quellcode:

//Als Input oder Output konfigurieren.

GPIODirModeSet(portBase, pin, dir);



Funktion/Umsetzung








M.Sc. Martin Sommer


Initialisierung – Aktivierung von PullUp

GPIO-Klasse enthält gesonderte setPullup-Methode. Diese Methode kann hier

verwendet werden.

In der init soll der Pullup-Widerstand automatisch aktiviert werden (nur falls

pullup=true)

Mit GPIO::setPullup kann der Widerstand später zu jedem Zeitpunkt (nach der

Initialisierung) aktiviert oder deaktiviert werden

Nächste Zeilen im Code:


M.Sc. Martin Sommer

// Rufe eigene setPullup–Methode auf um den Übergabewert zu setzen.

setPullup(pullup);


Ratschläge

Aufrufen von Klassenmethoden, die von der Aufgabenstellung gefordert sind erleichtert

einem die Arbeit

Beispiel: setPullup (vorherige Folie)

Bei sich wiederholenden Codeblöcken können auch eigene Methoden definiert

werden, um sich die Arbeit zu sparen, alles wieder abzutippen

Beispiel: refreshConfig (kommt später)


M.Sc. Martin Sommer



Funktion/Umsetzung






ggf. den Pull-up-Widerstand aktivieren

GPIO::init vollständig initialisiert!

Restliche Methoden im Selbststudium


M.Sc. Martin Sommer


Testprogramm – Aufgabenstellung

Das Testprogramm schaltet die rote LED auf dem TivaC™ LaunchPad um, wenn der

Taster SW1 gedrückt wird. Die LED wechselt also bei einem Tasterdruck von aus auf

an, bzw. wenn sie eingeschaltet war, von an auf aus.

Um Kontaktprellen zu vermeiden, können Sie auf folgenden Pseudo-Code zurückgreifen.


M.Sc. Martin Sommer

if (Taster gedrückt)

{

warte(50ms);

while (Taster gedrückt){};

// Eigentlicher Code

warte(50ms);

}


Testprogramm – Vorgehen (1)

Pins und Ports in den Datenblättern nachschlagen

Rote LED: Port F, Pin 1

Taster SW1: Port F, Pin 4

Benötigten Objekte erzeugen


M.Sc. Martin Sommer

int main(void)

{

// Construct all objects

System system;

GPIO redLed, sw1;

}

1 Objekt system der System-Klasse

2 Objekte redLed und sw1 der GPIO-Klasse



Objekte initialisieren


M.Sc. Martin Sommer

// Start system and run at 40 MHz.

system.init(40000000);

// Red LED on pin PF1

redLed.init(&system, GPIO_PORTF_BASE,

GPIO_PIN_1, GPIO_DIR_MODE_OUT);

// Switch SW1 on pin PF4

sw1.init(&system, GPIO_PORTF_BASE,

GPIO_PIN_4, GPIO_DIR_MODE_IN);

Beschreibung der System-Klasse: siehe

„Handbuch IT1 Praktikum“

LED: Port F, Pin 1, GPIO Ausgang

Taster: Port F, Pin 4, GPIO Eingang

GPIO::init, die wir vorhin selbst

implementiert haben



Pull-up bzw. Pull-down-Widerstände aktivieren

Widerstände werden nur bei Eingängen benötigt → nur bei sw1 (nicht redLED)

Onboard Taster auf dem LaunchPad™ werden beim Drücken auf Masse gelegt → sw1

benötigt Pull-up

In GPIO::init werden die Widerstände deaktiviert, falls pullup nicht übergeben wird →

Aktivierung notwendig


M.Sc. Martin Sommer

// Enable pull-up on SW1

sw1.setPullup(true);



Tasterzustände

Taster wird beim Drücken auf Masse gezogen

Abfrage mit sw1.read() liefert anliegende Spannung als bool

Taster nicht gedrückt → High Pegel wegen Pull-up Widerstand → sw1.read() liefert true

Taster gedrückt → Low Pegel → sw1.read() liefert false

Zusätzliche Invertierung (!) notwendig zur korrekten Abbildung

In jeder Abfrage: if(!sw1.read())


M.Sc. Martin Sommer



Taster auslesen und umschalten


M.Sc. Martin Sommer

while (1)

{

// Wait until button1 is pressed and released again.

if (!sw1.read())

{

system.delayUS(50000);

while (!sw1.read());

// Toggle redLed

redLed.write(!redLed.read());

system.delayUS(50000);

}

}

50000 μs = 50 ms warten

Taster gedrückt?

(siehe vorherige Folie)

Endlosschleife

Aktuellen Zustand der LED

auslesen

Negieren

Negierten Zustand ausgeben


Testprogramm – Einsatz

Testprogramm vollständig implementiert, nun folgt der eigentliche Test der Klasse

1. GPIO_Class_Test Projekt builden

Ggf. Compiler- und/oder Linkerfehler lokalisieren und beheben (in der Klasse und im

Testprogramm)

2. TivaC LaunchPad™ anschließen und das Projekt flashen

3. Taster SW1 betätigen und prüfen, ob die LED ein- und ausschaltet

4. Bei Problemen: Codezeilen nach Augenschein überprüfen und/oder Debugger nutzen


M.Sc. Martin Sommer

buildflashdebug


DEBUGGINGMÖGLICHKEITEN


M.Sc. Martin Sommer


Was ist Debugging?

Debugging ermöglicht es, Fehler (Bugs) in Ihrem Code zu detektieren

3 Möglichkeiten stehen im IT1 Praktikum zum Debugging zur Verfügung

1. Eingebauter Debugger in CCS

2. Debugging mit der Errorcodes.h in der System-Klasse

3. Grafische Anzeige ausgelesener Werte über die Arduino IDE

Voraussetzung: LaunchPad muss im Debug-Modus am Rechner angeschlossen sein


M.Sc. Martin Sommer

Schalter muss in der

rechten Position sein

(„Debug”)

Dieser Micro USB Port

muss genutzt werden


1. CCS Debugger (1)

Drücken des Käfers startet den Debugging Modus in CCS

Ansicht wechselt vom Edit Mode in den Debug Mode

Das Programm pausiert zunächst

Drücken von Resume lässt das Programm durchlaufen

Durch Breakpoints (Doppelkick auf Zeilennummer) wird festgelegt, in welchen Zeilen das

Programm erneut pausieren soll. Wichtig: Die entsprechende Zeile wird nicht mit

ausgeführt.


M.Sc. Martin Sommer

Debugging starten

BreakpointsResume

Suspend

Terminate

Step Into

Step Over

Step Return


1. CCS Debugger (2)

Händische Navigation im Programm

Step Over: Hauptprogramm ab dem Breakpoint Zeile für Zeile durchgehen,Funktionsaufrufe werden in einem Schritt abgearbeitet

Step Into: Wie bei step over, aber Funktionsaufrufe werden betreten und Zeile fürZeile abgearbeitet

Step Return: Aktuelle Funktion wird in einem Schritt abgearbeitet, dann pausiert derDebugger

Das Arbeiten mit dem Debugger erfordert eine gewisse Einarbeitung. Zum besseren Verständnis finden Sie im „Handbuch IT1 Praktikum“ zusätzliche Erklärungen.


M.Sc. Martin Sommer

Resume

Suspend

Terminate

Step Into

Step Over

Step Return


2. System::error (1)

Von uns entwickelte Methode, die bei der Fehlersuche mit dem CCS Debugger weiterhilft

Idee: Gehe bei einem Fehler in den Error-Modus, verbleibe dort und zeige dem Benutzer an, wie er dort gelandet ist

Aufruf dieser Funktion stoppt alle Interrupts und setzt den Code in Endlosschleife

Fehlercode und bis zu 3 Variablen können übergeben werden

Typ der Variablen ist nicht definiert (void-Pointer), muss zur korrekten Anzeige gecastet werden


M.Sc. Martin Sommer

void System::error(ErrorCodes errorCode, void *faultOrigin0,

void *faultOrigin1, void *faultOrigin2)


2. System::error (2)

ErrorCodes.h enthält die möglichen Fehlercodes

Weitere Fehlercodes können hinzugefügt werden

Auszug:

Beispiel: Falsche Konfiguration in der GPIO-Klasse


M.Sc. Martin Sommer

// Codes // Error parameters

UnknownError, // None

BatteryLow,

SysWrongFrequency, // uint32_t clk

GPIOWrongConfig, // uint32_t portBase, uint32_t pin, uint32_t dir

GPIOWrongCurrent, // uint32_t current

ADCWrongConfig,

sys->error(GPIOWrongConfig, &portBase, &pin, &dir);


3. Arduino IDE

Ermöglicht grafische Ansicht von Variablen im Zeitbereich

Besonders bei der Lenkung hilfreich

Kommunikation zwischen Mikrocontroller und Arduino IDE über serielle Schnittstelle

Anleitung zum Einrichten der IDE im „Handbuch IT1 Praktikum“, Vorgehen:

1. Aktivieren des Sendens der Debugging Werte mittels System::setDebugging(true)

2. Setzen der zu sendenden Werte mittels System::setDebugVal(Name, Val)

Bis zu 8 Werte können gesendet werden.

3. Erstellen eines Timers innerhalb der main.cpp des entsprechenden Projekts, der periodisch

die Werte sendet (in der Segway_Test existiert ein solcher Timer bereits)

4. Starten der Arduino IDE und auswählen des COM-Ports


M.Sc. Martin Sommer


Wie geht‘s weiter?

Machen Sie sich mit dem Handbuch vertraut

Zahlreiche Tipps und Tricks

Tauschen Sie sich in Ihrer Gruppe aus

Finden Sie Ihre Stärken

Verteilen Sie die Aufgaben

Bei Problemen helfen wir Ihnen gerne!

Via GitLab Issue

In der Sprechstunde

Viel Erfolg!


M.Sc. Martin Sommer

https://git.scc.kit.edu/pit/fragen/issues/

https://portal.wiwi.kit.edu/Termine/Instance

Documents

Informationstechnik I Praktikum (SS 2021