Klassenhirarchie für Mikrocontroller Programmierung

[gizno82]

Hallo Leute,

Ich bin gerade dabei eine Klassenbibliothek für Mikrocontroller zu erstellen.
Es handelt sich dabei um Atmel avr 8 Bit Mikrocontroller.

Ich habe folgende Überlegung angestellt ein Mikrocontroller besteht zunächst ein mal aus Registern, bei den AVRs gibt es 8-Bit Register und 16-Bit Register.
Des weiteren besitzt ein Mikrocontroller noch verschiedene Schnittstellen wie z.b. :
- UART
- SPI
- GPIO
- ADC

Bis jetzt habe ich eine Superklasse namens register geschrieben diese beinhaltet ein Bitfeld um ein 8-Bit Register abzubilden und eine union um ein 16-Bit Register abzubilden.
Zu dem enthält die Klasse register noch einige rein - virtuelle Methoden mit denen man bits setzen bzw. löschen kann.

Die Hirarchie soll folgendermaßen aussehen:
Die Superklasse register steht in der Hirarchie ganz oben, direkt unter der Superklasse befinden sich die Klassen, die Perepherie Klassen (UART, SPI, GPIO, ADC, TIMER, etc.).

Polymorphismus bedeutet ja, dass man eine Superklasse definiert die alles allgemein abbildet und man nach unten hin spezialisiert.
Da man jetzt z.b. den UART nur über bestimmte Register steuern kann ist mir jetzt nicht ganz klar, wie man es realisiert, dass für die UART Klasse zwar die das 8-Bit Bitfeld von der superklasse register nutzt aber die Register sollen in der UART klasse spezialisiert werden.

Das gleiche gillt auch für Methoden es soll zwar setBit bzw. clearBit aus der Superklasse register genutzt werden, aber die Metthoden sollen in der UART Klasse anderst heißen, z.b. enableUartTransmitter.

Kann mir bitte jemand ein paar Tips geben ?

Anbei mal die register Klasse

gruß gizno

Code: Alles auswählen

#ifndef M32_H
#define M32_H

#include "types.h" // -> word = uint16_t, byte = uint8_t


class register
{
  protected:
   
    struct register8Bit
    {
      byte bit0:1;
      byte bit1:1;
      byte bit2:1;
      byte bit3:1;
      byte bit4:1;
      byte bit5:1;
      byte bit6:1;
      byte bit7:1;
    }
    
    union register16Bit
    {
      word sizeOfUnion16Bit;	//groeße der union festlegen
      struct
      {
	byte hiByte;
	byte lowByte;
      };
    };
    
    virtual void setBit(byte registerName, byte bitName) const = 0;
    virtual void clearBit(byte registerName, byte bitName) const = 0;
    virtual bool isBitSet(byte registerName, byte bitName) const = 0;
    virtual bool isBitClear(byte registerName, byte bitName) const = 0;
    virtual void setByte(byte registerName, byte bitName) const = 0;
    virtual void clearByte(byte registerName, byte bitName) const = 0;
  
};

#endif

[cloidnerux]

soweit mir bekannt ist, musst du die funktionsnamen beibehalten. du könntest aber wrapper funktionen schreiben.
zudem musst du die performance von deinem code beachten, denn du hast nur sehr begrenzt Leistung. Auch war es bisher immer so, dass ich hardware 1 mal initialisiert habe, also die Register mit 8 bzw 16 bit werten inialisiert habe und dann nicht wieder.


P.S bin grade auf meinem smartphone. ist also etwas umständlich mehr zu schreiben

[gizno82]

Danke erst mal cloidnerux.

Das mit der wrapper funktion habe ich mir auch schon überlegt.
Wie mappt man das 8-Bit Bitfeld bzw. die union aus der Superklasse auf ein spezielles Register in einer unterklasse ?

Gruß gizno

[cloidnerux]

Wie mappt man das 8-Bit Bitfeld bzw. die union aus der Superklasse auf ein spezielles Register in einer unterklasse ?

Also direkt wüsste ich keinen Weg, da du ja das Register erreichen musst, dass normalerweise nur in assembler erreichbar ist. Man könnte aber mit winavr einfach deren Registerdefinitionen nutzen und dort den wert zuweisen. Beachten musst du aber, das unterschiedliche AVRs unterschiedliche Register haben, selbst bei den Timern. Timer 1 auf nem Atmega8 ist nochmal ein ganzes Stück anders als das auf einem Atmega48. Von daher müsstest du für jeden AVR eine eigene Klasse schreiben.
Man kann aber auch statt jedes Bit einzeln zu setzten ein enum nutzen und dann die Werte per Binär-oder verknüpfen:

Code: Alles auswählen

setRegister(m8.CS10| m8.WGM10 | m8.WGM11);

Dann stellt sich aber wieder die frage, in wie fern das einfacher wäre gegenüber der Zeile:

Code: Alles auswählen

TCCR1 = (1 << CS10) | (1 << WGM10) | (1 << WGM11);

Und nach meinen Erfahrungen sind die Hardware-Interrupts mit Klassen eine Qual und ganz schlecht sinnvoll zu implementieren, was dich aber nicht abschrecken soll. Nur ich programmiere AVRs lieber in C.

MfG cloidnerux.

[gizno82]

Ich habe für den ATMEGA 16/32 schon mal eine Klasse für den USART geschrieben.
Ich finde es halt z.b. zwecks Widerverwendbarkeit besser.

Hab mir folgendes überlegt, ich könnte doch eine Headerdatei namens Register anlegen in der alle Resgister des ATMEGA32 als Bitfelder implementiert sind. Dabei habe ich aber ein Problem, im Register Summary im Datenblatt sind ja alle Register mit den entsprechenden Adressen hinterlegt, wie realisiert man nun das eine Bitfeld, dass das PORTD Register abbildet auch tatsächlich an der Adresse des PORTD Registers liegt ?

erzeugt man einen Zeiger vom Typ der PORTD - Struktur, und initialisiert diesen Zeiger mit der PORTD Register Adresse aus dem Register Summary ?

Gruß Gizno