swees.2.3: HAL ---> Hardware Abstraktion Flashcards
Sie sollen eine portierbare Software für zwei verschiedene Mikrocontroller schreiben. Die Eigenschaften der beiden Mikrocontroller sind im Folgenden beschrieben.
Mikrocontroller 1 Mikrocontroller 2
unsigned int 16 Bit, big endian 32 Bit, little endian unsigned long int 32 Bit, big endian 64 Bit, little endian
char 8 Bit 8 Bit
unsigned char 8 Bit 8 Bit
uart_1
- Konfigurationsregister 0x0001 0x0002
- Datenregister (Tx) 0x0100 0x0200
- Datenregister (Rx) 0x0101 0x0201
- Interrupt Vector (on Rx) 0x0001 0x0002
(a) Beschreiben Sie die notwendigen Dateien, die Sie (typischerweise) für den Aufbau eines Hardware Abstraction Layer (HAL) anlegen würden!
typedef. h
uart. c
uart. h
isr. c
isr. h
(c)
Beschreiben Sie die Typendefinitionen unter Verwendung von einem Include-Guard
- für 32 Bit lange vorzeichenfreie ganzzahlige Variable UINT32!
- für 8 Bit lange vorzeichenbehaftete ganzzahlige Variable INT8!
- für 8 Bit lange vorzeichenfreie ganzzahlige Variable UINT8!
MCU1 typedef.h #ifndef UINT32 typedef unsigned long int UINT32; #endif #ifndef INT8 typedef char INT8; #endif #ifndef UINT8 typedef unsigned char UINT8; #endif
MCU2 typedef.h #ifndef UINT32 typedef unsigned int UINT32; #endif #ifndef INT8 typedef char INT8; #endif #ifndef UINT8 typedef unsigned char UINT8; #endif
(d)
Beschreiben Sie die Prototypen der Funktionen, die Sie für das Schreiben eines Bytes über die UART-Schnittstelle benötigen!
Welche Variablen werden übergeben, bzw. zurück gegeben?
Der UART benötigt Angaben zu Baudrate (9600 bis 115200), Länge des StoppBit (1, 1.5 oder 2 Bit) und Parity (kein Parity, gerade, ungerade).
Alle Funktionen sollen mindestens einen Rückgabewert besitzen, der über den erfolgreichen Abschluss der Bearbeitung informiert
-1 ein Fehler ist aufgetreten
1 kein Fehler ist aufgetreten; Abarbeitung komplett abgeschlossen
0 kein Fehler ist aufgetreten; Abarbeitung noch nicht abgeschlossen.
Hinweis: Für Rückgabewerte, wie auch für Iterator-Variable können auch die normalen Typen wie „int“ etc. verwendet werden, da hier (in allen praktischen Fällen) eine einheitliche Behandlung durch den Compiler erfolgen kann und dieser auf diese Weise am besten optimieren kann. Es handelt sich aber hier durchaus um eine „Geschmacksfrage“.
Hinweis: Ohne const wird von vielen Compilern eine Warnung geworfen („passing argument … discards qualifiers from pointer target type“)
INT8 uart_init(UINT32 baudrate, UINT8 stop, UINT8 parity); // baudrate – baud rate in bps // stop – 10 for 1,0 stoppbit // - 15 for 1,5 stoppbits // - 20 for 2,0 stoppbits // parity - 0 for no parity // - 1 for even parity // - 2 for odd parity INT8 uart_write(const UINT8 *write_var); // const supports the call of the function with constants, like // uart_write(´a´) INT8 uart_read(UINT8 *read_var); isr *UINT8 uart_recv(void);
(e)
Realisieren Sie die Funktion uart_write32 zum Schreiben von UINT32-Variablen über die UART-Schnittstelle unter Nutzung der oben beschriebenen Funktion uart_write
Folgende Anforderungen seien hierbei zu erfüllen:
- über die Schnittstelle soll das Big-Endian-Format verwendet werden!
- Der Rückgabewert soll dem Aufgabenteil (d) entsprechen. Es soll bereits dann eine „-1“ zurück gegeben werden, wenn ein Byte nicht erfolgreich übertragen werden kann.
uart.c für MCU1
INT8 uart_write32(const UINT32 *write_var32)
{
UINT8* write_value;
INT8 return_value = -1;
INT8 return_value1 = 0;
*write_value = (UINT8)((*write_var32 & 0xFF000000)>>24);
while(return_value1 == 0) return_value1 = uart_write(write_value);
return_value = return_value1;
*write_value = (UINT8)((*write_var32 & 0x00FF0000)>>16);
return_value1 = 0;
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
*write_value = (UINT8)((*write_var32 & 0x0000FF00)>>8);
return_value1 = 0;
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
*write_value = (UINT8)((*write_var32 & 0x000000FF));
return_value1 = 0;
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return return_value;
}
uart.c für MCU2
INT8 uart_write32(UINT32 *write_var32)
{
INT8* write_value;
UINT8 return_value = -1;
UINT8 return_value1 = 0;
*write_value = (UINT8)((*write_var & 0x000000FF));
while(return_value1 == 0) return_value1 = uart_write(write_value);
return_value = uart_write(write_value);
return_value1 = 0;
*write_value = (UINT8)((*write_var & 0x0000FF00)>>8);
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return_value1 = 0;
*write_value = (UINT8)((*write_var & 0x00FF0000)>>16);
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return_value1 = 0;
write_value = (UINT8)((*write_var & 0xFF000000)>>24);
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return return_value;
}
uart.c für in kombiniertem Code
#ifndef MCU1
#define MCU1
#endif
// #ifndef MCU2
// #define MCU2
// #endif
INT8 uart_write32(UINT32 *write_var32)
{
INT8* write_value;
UINT8 return_value = -1;
UINT8 return_value1 = 0;
#if MCU1
*write_value = (UINT8)((*write_var & 0x000000FF));
#elif MCU2
*write_value = (UINT8)((*write_var32 & 0xFF000000)>>24);
#endif
while(return_value1 == 0) return_value1 = uart_write(write_value);
return_value = uart_write(write_value);
return_value1 = 0;
#if MCU1
*write_value = (UINT8)((*write_var & 0x0000FF00)>>8);
#elif MCU2
*write_value = (UINT8)((*write_var32 & 0x00FF0000)>>16);
#endif
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return_value1 = 0;
#if MCU1
*write_value = (UINT8)((*write_var & 0x00FF0000)>>16);
#elif MCU2
*write_value = (UINT8)((*write_var32 & 0x0000FF00)>>8);
#endif
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return_value1 = 0;
#if MCU1
write_value = (UINT8)((*write_var & 0xFF000000)>>24);
#elif MCU2
*write_value = (UINT8)(*write_var32 & 0x000000FF);
#endif
while(return_value1 == 0) return_value1 = uart_write(write_value);
if (return_value1 == -1) return_value = -1;
return return_value;
}
(f)
Ist es sinnvoll, diese Funktion uart_write32 in die HAL zu integrieren?
Oder würden Sie diese als Bestandteil des Anwendungsprogramms sehen?
Diskutieren Sie die Vor- und die Nachteile!
??????
