Das Programm aus Termin4-Aufgabe1.c soll übersetzt und getestet werden. Wie groß ist die gemessene Periodendauer TPA4? Verändert sich die Periodendauer bei Belastung der Waage.

• Die Periodendauer TPA4 beträgt bei unbelasteter Waage(0g) 1999,71001μs, also ungefähr 2ms.
• Bei einer Belastung der Waage um bspw. 50g steigt die Periodendauer von TPA4

#include "../h/pio.h"
#include "../h/tc.h"
#include "../h/pmc.h"

// für die Initialisierung der Zähler TC4 & TC5 // Define TC5_INIT aus Platzgründen gelöscht
#define TC4_INIT TC_CLKS_MCK2 | TC_LDBSTOP | TC_CAPT | TC_LDRA_RISING_EDGE | TC_LDRB_RISING_EDGE

int main(void)
{
volatile int captureRA1 = 0, captureRA2 = 0; volatile int captureRB1 = 0, captureRB2 = 0;
volatile int capturediff1 = 0, capturediff2 = 0; volatile float Periodendauer1 = 0, Periodendauer2 = 0;

StructPMC* pmcbase = PMC_BASE;
StructPIO* piobaseA = PIOA_BASE; StructPIO* piobaseB = PIOB_BASE;
StructTC* tcbase4 = TCB4_BASE; StructTC* tcbase5 = TCB5_BASE;

pmcbase->PMC_PCER = 0x06f80; // Clock PIOA, PIOB, Timer5, Timer4, Timer1 einschalten
piobaseB->PIO_PER = KEY3; // PIO kontrolliert SW2 // Key2
piobaseB->PIO_ODR = KEY3; // als Eingang

// Periodendauer der Waagensignale messen
// Signal aud TIOA4 ca. 16kHz entspricht ca. einer Periodendauer von 62,5us
// durch den Teiler von 32 ergeben sich ca. 2ms
// Zähler mit positiver Flanke starten

piobaseA->PIO_PDR = 0x090;
tcbase4->TC_CCR = TC_CLKDIS; tcbase5->TC_CCR = TC_CLKDIS;
tcbase4->TC_CMR = TC4_INIT; tcbase5->TC_CMR = TC5_INIT;
tcbase4->TC_CCR = TC_CLKEN; tcbase5->TC_CCR = TC_CLKEN;

while((piobaseB->PIO_PDSR & KEY3)) // Wenn KEY3 gedrückt wird
{
int temp = tcbase4->TC_SR & 0x40; // vor SWTRG beide Timer-Statusregister lesen
temp = tcbase5->TC_SR & 0x40;
tcbase4->TC_CCR = TC_SWTRG; tcbase5->TC_CCR = TC_SWTRG;
while (!( tcbase4->TC_SR & 0x40));
while (!( tcbase5->TC_SR & 0x40)); // Capture Register B wurde geladen -> Messung abgeschlossen
captureRA1 = tcbase4->TC_RA; captureRB1 = tcbase4->TC_RB; capturediff1 = abs(captureRB1) - abs(captureRA1);
Periodendauer1 = abs(capturediff1) / 12.5; // Zeit in us

captureRA2 = tcbase5->TC_RA; captureRB2 = tcbase5->TC_RB;
capturediff2 = abs(captureRB2) - abs(captureRA2);
Periodendauer2 = abs(capturediff2) / 12.5; // Zeit in us
Periodendauer2 = abs(capturediff2) / 12.5; // Zeit in us
}
return 0;
}

Aufgabe 2

Das Programm soll so erweitert werden, dass auch die Periodendauer TPA7 erfasst wird (Siehe Code auf Seite 1). Es soll getestet werden, ob sich auch hier die Periodendauer um die 2ms bewegt.

→ Der Test hat gezeigt, dass sich auch die Periodendauer von TPA7 um 2ms bewegt.

Aufgabe 3

Aus dem Verhältnis der Frequenzen fPA4 und fPA7 lässt sich mit der folgenden Gleichung die Masse m berechnen:

m = C1 * [(fPA7/ fPA4) -1] – C2

oder

m = C1 * [(TPA7/ TPA4) -1] – C2,

wobei C1, C2 = wägezellenspezifische Konstanten sind. Die Frequenz an PA4 wird mit zunehmendem Gewicht kleiner, während die Frequenz von PA7 mit zunehmendem Gewicht größer wird.

Um die Messwerte des Programms zu verifizieren, soll die Masse m, die auf der Waage liegt, zur Kontrolle berechnet werden (WaSim: C1 = 2000, C2 = 0).

Aufgabe 4

void Timer_Init(void)
{
StructTC* tcbase4 = TCB4_BASE; StructTC* tcbase5 = TCB5_BASE;
StructPIO* piobaseA = PIOA_BASE;
// Periodendauer der Waagensignale messen
// Signal aud TIOA4 ca. 16kHz entspricht ca. einer Periodendauer von 62,5us
// durch den Teiler von 32 ergeben sich ca. 2ms
// Zähler mit positiver Flanke starten
piobaseA->PIO_PDR = 0x090;
tcbase4->TC_CCR = TC_CLKDIS; tcbase5->TC_CCR = TC_CLKDIS;
tcbase4->TC_CMR = TC4_INIT; tcbase5->TC_CMR = TC5_INIT;
tcbase4->TC_CCR = TC_CLKEN; tcbase5->TC_CCR = TC_CLKEN;
}

int MessungderMasse(void)
{
StructPMC* pmcbase = PMC_BASE;
StructPIO* piobaseA = PIOA_BASE; StructPIO* piobaseB = PIOB_BASE;
StructTC* tcbase4 = TCB4_BASE; StructTC* tcbase5 = TCB5_BASE;
volatile int captureRA1 = 0, captureRA2 = 0; volatile int captureRB1 = 0, captureRB2 = 0;
volatile int capturediff1 = 0, capturediff2 = 0;
volatile float Periodendauer1 = 0, Periodendauer2 = 0;
volatile int C1 = 2000; volatile int C2 = 0;
volatile float m; // Masse

while((piobaseB->PIO_PDSR & KEY3)) // Wenn KEY3 gedrückt wird
{
volatile int temp = tcbase4->TC_SR & 0x40; // vor SWTRG beide Timer-Register lesen
temp = tcbase5->TC_SR & 0x40;
tcbase4->TC_CCR = TC_SWTRG;
tcbase5->TC_CCR = TC_SWTRG;
while (!( tcbase4->TC_SR & 0x40));
while (!( tcbase5->TC_SR & 0x40)); // Capture Register B wurde geladen Messung abgeschlossen
captureRA1 = tcbase4->TC_RA; // captureRB1 = tcbase4->TC_RB;
capturediff1 = abs(captureRB1) - abs(captureRA1);
Periodendauer1 = abs(capturediff1) / 12.5; // Zeit in us

captureRA2 = tcbase5->TC_RA; // captureRB2 = tcbase5->TC_RB;
capturediff2 = abs(captureRB2) - abs(captureRA2);
Periodendauer2 = abs(capturediff2) / 12.5; // Zeit in us
Periodendauer2 = abs(capturediff2) / 12.5; // Zeit in us

m = C1*((Periodendauer1/Periodendauer2)-1)-C2;
return m; }
}

int main(void)
{
StructPMC* pmcbase = PMC_BASE;
StructPIO* piobaseA = PIOA_BASE;
StructPIO* piobaseB = PIOB_BASE;
volatile int Masse;
PIO_Init();
Timer_Init();

while(!(piobaseA->PIO_ODSR & KEY3))
{
Masse = MessungderMasse();
}
return 0;
}

Es soll eine Funktion int MessungderMasse(void) zur Ermittlung der Masse in Gramm erstellt werden.

Hinweis: Es sollte der Mittelwert aus mehreren Messungen gebildet werden um die Masse möglichst genau bestimmen zu können.

Der Beitrag Mikroprozessorsysteme (Praktikum 4) erschien zuerst auf Maximilian Krieg.

• Es soll eine Kolbenhubpumpe, welche über PA1/TIOA3 angesteuert wird, betrieben werden.
• Die Pumpe benötigt ein symmetrisches Rechtecksignal mit einer Frequenz von ca. 50Hz. Sie könnten eine Zeitschleife programmieren. Hiermit würden Sie aber den Prozessor blockieren (Erinnerung an Termin 2). Besser ist es, Sie initialisieren einen Timer (Timer3) so, dass dieser selbstständig das Signal für die Pumpe erzeugt.
• Vervollständigen Sie die das gegebene Programm Termin3Aufgabe1.c entsprechend. Ergänzen Sie auch die noch fehlenden Kommentare.

/ Aufgabe 1
// von:
// vom:
//

#include "../h/pmc.h"
#include "../h/tc.h"
#include "../h/pio.h"
#include "../h/aic.h"

// Timer3 initialisieren
void Timer3_init( void )
{
StructTC* timerbase3 = TCB3_BASE; // Basisadressse TC Block 1
StructPIO* piobaseA = PIOA_BASE; // Basisadresse PIO B

timerbase3->TC_CCR = TC_CLKDIS; // Disable Clock
// Initialize the mode of the timer 3
timerbase3->TC_CMR =
TC_ACPC_CLEAR_OUTPUT | //ACPC : Register C clear TIOA
TC_ACPA_SET_OUTPUT | //ACPA : Register A set TIOA
TC_WAVE | //WAVE : Waveform mode
TC_CPCTRG | //CPCTRG : Register C compare trigger enable
TC_CLKS_MCK8; //TCCLKS : MCKI / 8

// Initialize the counter:
timerbase3->TC_RA = 31250; //Flanke hoch
timerbase3->TC_RC = 62500; //Flanke runter

// Start the timer :
timerbase3->TC_CCR = TC_CLKEN ; //Clock enable
timerbase3->TC_CCR = TC_SWTRG ; //Enable Software Trigger
piobaseA->PIO_PER = (1<<PIOTIOA3) ; // PIO A kontrolliert Timer3
piobaseA->PIO_OER = (1<<PIOTIOA3) ; // als Ausgang
piobaseA->PIO_CODR = (1<<PIOTIOA3) ; // einschalten
}

int main(void)
{

StructPMC* pmcbase = PMC_BASE; // Basisadresse des PMC
StructPIO* piobaseA = PIOA_BASE; // Basisadresse PIO A
StructPIO* piobaseB = PIOB_BASE; // Basisadresse PIO B

pmcbase->PMC_PCER = 0x6200; // Peripheral Clocks einschalten für PIOA,PIOB,TC3

// ab hier entsprechend der Aufgabestellung ergänzen
//**************************************************

Timer3_init(); // Timer3 initialisieren

while(1)
{

}

return 0;
}

• Notizen:

Power Management

• Man darf nicht vergessen sowohl PIO A, als auch PIO B und den Timer 3 am Peripheral Clock Enable Register einzuschalten, wenn man Timer als auch Tasten verwenden möchte ( bezieht sich auf Aufgabe 2 ) Hierbei ergibt sich folgende binäre Aktivierung: 110001000000000 ( bzw.: 0x6200 ).

Berechnung der Zähler RA und RC:

• Bei der Berechnung der Werte für die Register RA und RC sind mehrere Lösungen möglich.
• RA steht hierbei für den Zeitpunkt einer steigenden Flanke und RC steht für den Zeitpunkt der fallenden Flanke und dem Neubeginn des Taktzyklus.
• Um die Frequenz so präzise wie möglich zu berechnen wird mittels TC_CLKS_MCKX die Taktrate skaliert ( CPU / X ) , damit der Wert des Registers RC nicht bereits vor dem Ende der eigentlichen Taktzeit erreicht wird. ( X steht für 2/8/32/128/1024 → TC_CLKS_MCK8 ). 
• Würde man die Skalierung mit 2 wählen, so wäre ein Überlauf bereits nach 0,00262144 Sekunden erreicht, wir haben mit 50Hz aber eine Laufzeit von 0,02097152 Sekunden.
• Je kleiner der Nenner, desto exakter ist der berechnete Wert. Um Rundungsfehler zu vermeiden, sollte die Skalierung so gewählt werden, dass nur ganzzahlige Integer-Werte ( und keine Double-Werte ) verwendet werden.

Aufgabe 2

• Entwickeln Sie eine Funktion, mit der Sie die Tasten SW1 – SW3 der auf dem Board befindlichen Tasten abfragen können.
• Mit der Taste SW2 soll die Pumpe eingeschaltet und mit der Taste SW1 soll die Pumpe abgeschaltet werden können.

// Lösung zu Termin3
// Aufgabe 1
// von:
// vom:
//

#include "../h/pmc.h"
#include "../h/tc.h"
#include "../h/pio.h"
#include "../h/aic.h"

void taste_irq_handler (void) __attribute__ ((interrupt));

// Interruptserviceroutine für die Tasten SW1 und SW2
void taste_irq_handler (void)
{
StructPIO* piobaseB = PIOB_BASE; // Basisadresse PIO B
StructAIC* aicbase = AIC_BASE; //Basisadresse AIC

// ab hier entsprechend der Aufgabestellung ergänzen
// *************************************************
StructPIO* piobaseA = PIOA_BASE;

// Einschalten
if(!(piobaseB->PIO_PDSR & 0x10)) { // Taste 2 zum einschalten
piobaseA->PIO_PDR = (1PIO_PER = (1PIO_ISR; // Interrupt beenden
}

// Timer3 initialisieren
void Timer3_init( void )
{
StructTC* timerbase3 = TCB3_BASE; // Basisadressse TC Block 1
StructPIO* piobaseA = PIOA_BASE; // Basisadresse PIO B

timerbase3->TC_CCR = TC_CLKDIS; // Disable Clock
// Initialize the mode of the timer 3
timerbase3->TC_CMR =
TC_ACPC_CLEAR_OUTPUT | //ACPC : Register C clear TIOA
TC_ACPA_SET_OUTPUT | //ACPA : Register A set TIOA
TC_WAVE | //WAVE : Waveform mode
TC_CPCTRG | //CPCTRG : Register C compare trigger enable
TC_CLKS_MCK8; //TCCLKS : MCKI / 8

// Initialize the counter:
timerbase3->TC_RA = 31250; //Flanke hoch
timerbase3->TC_RC = 62500; //Flanke runter

// Start the timer :
timerbase3->TC_CCR = TC_CLKEN ; //Clock enable
timerbase3->TC_CCR = TC_SWTRG ; //Enable Software Trigger
piobaseA->PIO_PER = (1AIC_ICCR= 1 << 14; // InterruptPIOB löschen aicbase->AIC_SVR[PIOB_ID] = (unsigned int)taste_irq_handler;
aicbase->AIC_SMR[PIOB_ID] = 0x7; // Priorität
aicbase->AIC_IECR= 1 << 14; // InterruptPIOB einschalten piobaseB->PIO_IER= KEY1|KEY2; // Interrupt innerhalb PIOB erlauben ////

pmcbase->PMC_PCER = 0x6200; // Peripheral Clocks einschalten für PIOA,PIOB,TC3

// ab hier entsprechend der Aufgabestellung ergänzen
//**************************************************

Timer3_init(); // Timer3 initialisieren

while(1)
{

}

return 0;
}

• Notizen:

Termin 6:

• Der Quellcode ist 1:1 portierbar auf das finale System im 6. Praktikumstermin. Der Wagensimulator ist eine identische Abbildung des physikalischen Systems, verwendet dabei die gleichen Adressen, Register und bietet die gleichen Funktionalitäten an.

Ausgabe des Signals: 

• Um das Signal von PIOA ( immer low ) an den WaSim zu übertragen, muss die Herrschaft des Ausgangs an PIOA übergeben werden. (Aus)
• Damit das Signal des Timers an den WaSim übermittelt wird, muss die Herrschaft des Ausgangs PIOA entzogen werden. ( Ein )
• Der Ausgang verhält sich hierbei gewissermaßen wie ein 2:1 Multiplexer.

Der Beitrag Mikroprozessorsysteme (Praktikum 3) erschien zuerst auf Maximilian Krieg.

• Es sollte immer auf eine Implementierung geachtet werden, die auf jeder Optimierungsstufe weiterhin ausführbar ist. Dabei ist auf die Verwendung von „volatil“ zu achten.
• Wenn es möglich ist, sollten bereits programmierte Aufgabenteile in die Gesamtlösung von Termin 6 integriert werden, aber nicht alles was im Voraus programmiert wurde, muss schlussendlich auch einen Platz in der Lösung von Termin 6 finden.
• „Je weniger Code, desto besser.“, d.h., dass eine Interrupt Service Routine oder das Beachten von Stromsparmodi für die Lösungen nicht zur notwendigen Implementierung gehören, sondern optional sind. Je mehr Code ein Programm besitzt, desto anfälliger für Fehler kann es werden.

Aufgabe 1

In eingebetteten Systemen und für Kartentreiber muss man oft auf Register zugreifen, die auf festen Adressen liegen. Wir werden uns zuerst mit den Registern der PIO des hier eingesetzten Mikrocontroller (AT91M63200) beschäftigen.

Legen Sie zunächst Zeigervariablen (PIOB_PER, PIOB_OER, ..) an und initialisieren Sie diese im Code auf die Adresse des Registers. Danach können Sie über diese Zeiger auf die Register zugreifen. Schreiben Sie zunächst den Wert 0x100 ins PIOB_PER und dann ins PIOB_OER. Danach schreiben Sie nacheinander den Wert 0x100 einige Male alternierend ins PIOB_SODR und PIOB_CODR. Dadurch sollte die LED DS1 auf dem Board AT91EB63 an und aus gehen. Testen Sie dieses mit Einzelschritten aus.

#define PIOB_PER ((volatile unsigned int*) 0xFFFF0000) // Port Enable Register
#define PIOB_OER ((volatile unsigned int*) 0xFFFF0010) // Output Enable Register
#define PIOB_SODR ((volatile unsigned int*) 0xFFFF0030) // Set Output Data Register (disable)
#define PIOB_CODR ((volatile unsigned int*) 0xFFFF0034) // Clear Output Data Register (enable)

int main(void)
{
*PIOB_PER = 0xE300; // LED's 1,2,6,7,8 an PIOB aktivieren
*PIOB_OER = 0xE300; // LED's 1, 2, 6, 7, 8 als Output definieren

*PIOB_SODR = 0xE300; // Set Output Data Register ausschalten

// Schleife zum Ein- und Ausschalten der LED 1
while(1)
{
*PIOB_SODR = 0x0100; // LED 1 ausschalten
*PIOB_CODR = 0x0100; // LED 1 einschalten
}

return 0;
}

Notizen: Während dem Start des Programmes haben die LEDs 2, 6, 7 und 8 gebrannt. Die Anpassungen zu Beginn des Codes dienen dazu, damit diese ausgeschaltet werden.

Aufgabe 2

Gut, wir können jetzt eine LED (DS1) kontrollieren. Schauen Sie sich die Dateien im Verzeichnis ~/mpsSS2012/h an. Sie können diese Header-Dateien in Ihren nächsten Programmen benutzen. Ändern und erweitern Sie Ihr Programm so, dass die LED DS1 durch drücken der Taste SW1 eingeschaltet und durch drücken der Taste SW2 ausgeschaltet wird. Sollte die Taste nicht funktionieren, so überprüfen Sie ob im Power Management Controller (PMC) der Clock für PIOB eingeschaltet ist. In welchem Register muss welches Bit gesetzt sein?

#include "../h/pmc.h"
#include "../h/pio.h"

int main(void)
{
StructPMC* pmcbase = PMC_BASE; // Basisadresse des PMC
StructPIO* piobaseB = PIOB_BASE; // Basisadresse PIO B
pmcbase->PMC_PCER = 0x4000; // Peripherial Clock einschalten für PIOB

piobaseB->PIO_PER = 0x0100; // PIO kontrolliert LED1 (0x100)
piobaseB->PIO_OER = 0x0100; // als Ausgang

piobaseB->PIO_PER = KEY1; // PIO kontrolliert SW1 bzw. Key 1
piobaseB->PIO_ODR = KEY1; // als Eingang ((!!!))

piobaseB->PIO_PER = KEY2; // PIO kontrolliert SW2 bzw. Key 2
piobaseB->PIO_ODR = KEY2; // als Eingang ((!!!))

// Schleife zum Ein- und Ausschalten der LED 1
while(1)
{
// Einschalten wenn Taste 1 gedrückt wird
if(!(piobaseB->PIO_PDSR & KEY1))
piobaseB->PIO_CODR = 0x0100;

// Ausschalten wenn Taste 2 gedrückt wird
if(!(piobaseB->PIO_PDSR & KEY2))
piobaseB->PIO_SODR = 0x0100;
}

return 0;
}

Notizen: Das Drücken der Taste SW1 erzeugt eine 0. Wenn die Taste SW1 nicht gedrückt wird, erzeugt sie als Signal eine 1. Deshalb müssen die IF-Abfragen innerhalb der Schleife mit negierten Bedinungen geprüft werden. Das & steht für die binäre Verknüpfung zwischen Status Register und Taste.

Aufgabe 3

Lassen Sie im nächsten Programm zusätzlich die LED DS2 mit ca. 0,5Hz (Zeitschleife programmieren) blinken. Wie reagieren Ihre Tastendrücke an SW1 und SW2?

#include "../h/pmc.h"
#include "../h/pio.h"

#define DELAY 500000 // Anzahl der Durchläufe für die Schleife

int main(void)
{

StructPMC* pmcbase = PMC_BASE; // Basisadresse des PMC
StructPIO* piobaseB = PIOB_BASE; // Basisadresse PIO B

pmcbase->PMC_PCER = 0x4000; // Peripherial Clock einschalten für PIOB (0x4200)

piobaseB->PIO_PER = 0x0100; // PIO kontrolliert LED1
piobaseB->PIO_OER = 0x0100; // als Ausgang

piobaseB->PIO_PER = 0x0200; // PIO kontrolliert LED2
piobaseB->PIO_OER = 0x0200; // als Ausgang

piobaseB->PIO_PER = 0x08; // PIO kontrolliert SW1 bzw. Key1
piobaseB->PIO_ODR = 0x08; // als Eingang

piobaseB->PIO_PER = 0x10; // PIO kontrolliert SW2 bzw. Key2
piobaseB->PIO_ODR = 0x10; // als Eingang

volatile int an = 1; // Variable zum Ein- und Ausschalten

// Schleife zum Ein- und Ausschalten der LED 1
while(1)
{
volatile int i=0; // Variable der Pausen-Schleife

// Einschalten
if(!(piobaseB->PIO_PDSR & 0x08))
piobaseB->PIO_CODR = 0x0100;

// Ausschalten
if(!(piobaseB->PIO_PDSR & 0x10))
piobaseB->PIO_SODR = 0x0100;

if(an==1){
piobaseB->PIO_CODR = 0x0200;
an=0;
}
else {
piobaseB->PIO_SODR = 0x0200;
an=1;
}
for(i = 0; i<DELAY;i++) {}

}

return 0;
}

Notizen: Um den Code zu optimieren, wurde anstelle zwei FOR-Schleifen einzusetzen, die Variante mit einer integer-Variablen „an“ gewählt, deren Wert bei jedem Durchlauf der WHILE-Schleife alterniert zwischen 1 (an=true) und 0 (an=false). Das Signal der Tasten wird während der Pausen-Schleife nicht angenommen, auch nachträglich wird das Signal nicht übertragen in die Register. Um die Taste zu setzen ist ein häufiges Drücken oder das permanente Drücken notwendig. Die Dauer der Schleife ist durch eine Programmierung in C stark von der Optimierungsstufe abhängig und sollte deshalb in Assembler geschrieben werden. Als weiteres Kriterium ist die Prozessor- und RAM-Taktrate und das Pipelining ausschlaggebend bei der Wahl der Durchläufe der Schleifen. Der Mikrocontroller im Labor arbeitet mit einer CPU-Taktrate von 25MHz, der interne RAM besitzt allerdings einen eigenen Takt, der noch durch Wait-States beeinflusst wird. Formel zur Berechnung der Durchläufe der Pausen-Schleife:

Prozessor-Geschwindigkeit = 25 MHz = 25.000.000 Hz Taktzeit = 1 / 25.000.000 Hz  Takte pro Durchlauf = 4 Frequenz = 0,5 Hz = 2s Durchläufe = Frequenz / ( Taktzeit * Takte pro Durchlauf ) = 12500000 ?

Aufgabe 4

Schreiben Sie für die Tasten SW1 und SW2 eine passende Interruptserviceroutine. Erklären Sie die Wechsel der ARM-Betriebsmodi. Wie reagieren nun Ihre Tastendrücke an SW1 und SW2? Welchen Einfluss hat das Bedienen der Tasten auf die Blinkfrequenz von DS2?

#include "../h/pmc.h"
#include "../h/pio.h"
#include "../h/aic.h"

// Anzahl der Durchläufe für die Schleife
#define DELAY 500000

// Compiler mitteilen, dass es sich um eine Interrupt Service Routine handelt
void irq_handler(void) __attribute__ ((interrupt));

// Interrupt-Service-Routine
void irq_handler( void)
{
StructPIO* piobaseB= PIOB_BASE; // Basisadr. PIO B
StructAIC* aicbase= AIC_BASE; // Basisadresse AIC

// Einschalten
if(!(piobaseB->PIO_PDSR & 0x08))
piobaseB->PIO_CODR = 0x0100;

// Ausschalten
if(!(piobaseB->PIO_PDSR & 0x10))
piobaseB->PIO_SODR = 0x0100;

// Interrupt-Status-Register lesen und in das
// End of InterruptCommandRegister (EOICR) schreiben
aicbase->AIC_EOICR= piobaseB->PIO_ISR;
}

int main(void)
{
StructAIC* aicbase = AIC_BASE; // Basisadresse AIC
StructPIO* piobaseB= PIOB_BASE; // Basisadr. PIO B

aicbase->AIC_IDCR = 1 << 14; // InterruptPIOB ausschalten
aicbase->AIC_ICCR= 1 << 14; // InterruptPIOB löschen

aicbase->AIC_SVR[PIOB_ID] = (unsigned int)irq_handler;
aicbase->AIC_SMR[PIOB_ID] = 0x7; // Priorität definieren

aicbase->AIC_IECR= 1 << 14; // InterruptPIOB einschalten
piobaseB->PIO_IER= KEY1|KEY2; // Interrupt innerhalb PIOB erlauben

piobaseB->PIO_PER = 0x0100; // PIO kontrolliert LED1
piobaseB->PIO_OER = 0x0100; // als Ausgang

piobaseB->PIO_PER = 0x0200; // PIO kontrolliert LED2
piobaseB->PIO_OER = 0x0200; // als Ausgang

piobaseB->PIO_PER = 0x08; // PIO kontrolliert SW1 // Key1
piobaseB->PIO_ODR = 0x08; // als Eingang

piobaseB->PIO_PER = 0x10; // PIO kontrolliert SW2 // Key2
piobaseB->PIO_ODR = 0x10; // als Eingang

int an = 1; // Variable zum Ein- und Ausschalten

while(1)
{
volatile int i=0;

if(an==1){
piobaseB->PIO_CODR = 0x0200;
an=0;
}
else {
piobaseB->PIO_SODR = 0x0200;
an=1;
}
for(i = 0; i<DELAY;i++) {}

}

aicbase->AIC_IDCR= 1 << 14; // InterruptPIOB ausschalten
aicbase->AIC_ICCR= 1 << 14; // InterruptPIOB löschen

return(0);
}

Notizen: Im Gegensatz zu der Implementierung ohne ISR nehmen die Tasten nun jederzeit und ohne direkte Verzögerung die Tastendrücke an. Die Blinkfrequenz von LED2 wird durch das Drücken der Tasten nicht gestört. Für die menschliche Wahrnehmung sind Tastendrücke ab einer Reaktionszeit von weniger als 20ms in „Echtzeit“. Unterschiedliche Optimierungsstufen können unterschiedliche Blinkzeiten bei den LEDs erzeugen. Deswegen ist darauf zu achten, dass der Code so gut wie möglich auf alle Optimierungsstufen angepasst zu sein. Dafür soll künftig der Timer in ARM programmiert werden.

Der Beitrag Mikroprozessorsysteme (Praktikum 2) erschien zuerst auf Maximilian Krieg.

• Praktika:
  • 6 Termine
  • Keine Testate für die einzelnen Termine mehr
  • Eigenverantwortung der Funktionsfähigkeit der Programme
  • Vorbereitung und Anwesenheit sind Pflicht für jeden Termin
  • Dokumentation in Form eines Pflichtenhefts müssen geführt werden
  • Die Dokumentation und das fertige Programm werden abgenommen.
  • Während der Abnahme hat man 10 Minuten Zeit den Prüfer zu überzeugen
• Änderungen:
  • 8. Juni auf den 11. Juni verschieben ( 3. Block )

Hardware

• Etablieren von Kommunikation zwischen:
  • Schnittstellen
  • Tasten
  • etc.
• Beherrscht kein C++, aber C ( bessere Performance )

Snavigator starten

1. In den Zielpfad wechseln
2. F4 drücken und ins integrierte Terminal wechseln
3. „snavigator“ eingeben und mit Enter bestätigen
4. New Project auswählen

Debugger

• Wechseln von arm-elf auf arm-eb63-elf 
• Im snavigator als Debugger „arm-eb63-elf-insight“ eintragen

Makefile

• Wurde nun mittels Variablen aufgebaut und erlaubt mehr Dynamik beim Wechseln der Compiler

Optimierungsstufen

• Im Praktikum sollte so viel wie möglich damit gespielt werden, um die Veränderungen zu beobachten.
• Mittels volatile kann man das „Wegoptimieren“ von Variablen verhindern

Verbinden mit dem Mikrocontroller

• Programmier-Schnittstelle befindet sich auf dem Adapter
• File → Target Settings → Remote/TCP → 141.100.52.14:2001
• Run → Connect to Target

Ziele

An ganz einfachen Programmen soll ermittelt werden, welchen Code ein Compiler erzeugt, wo welche Variablen abgefragt werden und wie ein call by value/ reference in ARM Assembler umgesetzt wird.

Aufgabe 1

In einer Tabelle sind die elementaren Datentypen auszufüllen.

Aufgabe 2

Anzugeben sind die folgenden Zahlen sowohl als int als auch als float.

Aufgabe 3

In einem C Programm werden zwei lokale Variablen angelegt, denen die Werte 0x1 und 0x2 zugewiesen werden. Das Programm soll übersetzt und der erzeugte Code dokumentiert werden.

49 int iLoc1 = 0x1; 
0x8304 <main+248>: mov r3, #1 ; 0x1 // Variable 1 den Wert 0x1 zuweisen
0x8308 <main+252>: str r3, [r11, #-24] // und auf den Stack schieben 
50 int iLoc2 = 0x2; 
0x830c <main+256>: mov r3, #2 ; 0x2 // Variable 2 den Wert 0x2 zuweisen 
0x8310 <main+260>: str r3, [r11, #-20] // und auf den Stack schieben 51 

Aufgabe 4

Anstelle von lokalen Variablen sollen nun globale Variablen benutzt werden und die Veränderung dokumentiert werden.

54 iGlob1 = 0x1; 
0x8314 <main+264>: ldr r2, [pc, #72] ; 0x8364 <main+344> 
0x8318 <main+268>: mov r3, #1 ; 0x1 
0x831c <main+272>: str r3, [r2] 
55 iGlob2 = 0x2; 
0x8320 <main+276>: ldr r2, [pc, #64] ; 0x8368 <main+348> 
0x8324 <main+280>: mov r3, #2 ; 0x2 
0x8328 <main+284>: str r3, [r2] 
56 

Notiz: Wie man sieht werden die global definierten Variablen zunächst aus der data section geholt, modifiziert und schließlich wieder zurück geschrieben. Die Adressen der globalen Variablen findet man über den Befehl arm-eb63-elf-mn heraus.

Aufgabe 5

Nun sollen zwei globale und zwei lokale Variablen angelegt und die Zuweisung „global=lokal“ gemacht werden.

58 iGlob1 = iLoc1; 
0x832c <main+288>: ldr r2, [pc, #72] ; 0x837c <main+368> 
0x8330 <main+292>: ldr r3, [r11, #-24] 
0x8334 <main+296>: str r3, [r2] 
59 iGlob2 = iLoc2; 
0x8338 <main+300>: ldr r2, [pc, #64] ; 
0x8380 <main+372> 
0x833c <main+304>: ldr r3, [r11, #-20] 
0x8340 <main+308>: str r3, [r2] 

Notiz: Die globale Variable wird aus der data section geladen, die lokale Variable aus dem Stack. Anschließend erfolgt die Zuweisung. Durch eine höhere Optimierungsstufe wird die globale Variable direkt mit dem Wert der lokalen Variable initialisiert.

Aufgabe 6

Es wird eine Funktion addition erstellt, die als Parameter zwei lokale und einer globale Variable übergeben kriegt.

63 addition(iLoc1,iLoc2,iGlob1); 
0x833c <main+304>: ldr r2, [r11, #-108] 
0x8340 <main+308>: ldr r1, [r11, #-112] 
0x8344 <main+312>: ldr r3, [pc, #92] ; 
0x83a8 <main+412> 
0x8348 <main+316>: ldr r3, [r3] 
0x834c <main+320>: mov r0, r2 
0x8350 <main+324>: mov r2, r3 
0x8354 <main+328>: bl 
0x83b0 <addition> 

Notiz: Es finden keine wesentlichen Änderungen im Vergleich zu Aufgabe 5 statt. Die höchste Optimierungsstufe lässt die Funktion vollständig verschwinden.

Der Beitrag Mikroprozessorsysteme (Praktikum 1) erschien zuerst auf Maximilian Krieg.