Luna ist eine objektbasierte Programmiersprache.

Sie unterstützt mit Einschränkungen:

• Vererbung
• Datenkapselung
• Polymorphie

OpenBook: Objektorientierte Programmierung von Bernhard Lahres, Gregor Rayman

In der Programmierung gibt es verschiedene Begriffe, deren Bedeutung im Allgemeinen geläufig sind. Die objektorientierte Programmierung besitzt zudem weiterführende Begriffe und Bezeichnungen. Oft verwendete Begriffe sind:

• Variable
• Methode
• Objekt
• Klasse

Im Unterschied zur „normalen“ rein prozeduralen Programmierung, sind bei der objektbasierten/objektorientierten Programmierung sogutwie alle Elemente der Programmiersprache in bestimmte Strukturen zusammengefasst. Diese Struktur beeinflusst auch die Art und Weise der Syntax, also wie man eine gewünschte Funktionalität schriftlich ausdrückt.

Die Zugriffe und Schreibweisen der objektorientierten Programmierung sind der realen Welt nachempfunden. Zum Verständnis ein vereinfachtes Beispiel zu den Begriffen „Klasse“, „Objekt“, „Methode“ und „Eigenschaft“:

Wir haben ein Haus, in dem Haus befindet sich ein Schrank. Der Schrank hat Schubfächer und in den Schubfächern liegen Dokumente. In der Analogie zur objektorientierten Programmierung in Luna repräsentiert das Haus eine Klasse. Der Schrank der sich im Haus befindet ist ein Objekt. Möchte man nun ein Dokument aus dem Schrank im Haus holen, betritt man das Haus, geht zum Schrank, öffnet eine gewünschte Schublade und nimmt sich das Dokument. Eine Methode vom Objekt Schrank wäre hierfür öffneSchublade oder nimmDokument. Eine Eigenschaft wäre AnzahlSchubfächer.

Die Einzelnen Schritte unterteilt man durch einen Punkt, sodass der Aufruf aus obigem Beispiel so aussieht:

Ermitteln der Anzahl der Schubfächer vom Schrank:

• Anzahl = Haus.Schrank.anzahlSchubfächer

Holen eines Dokumentes:

• Haus.Schrank.nimmDokument( SchubfachNummer )

Jeder AVR-Mikrocontroller ist intern als eine sogenannte „Klasse“ (die Basisklasse) implementiert. Diese beschreibt, welche Objekte oder Interfaces (z.Bsp.: Ports, Timer, Wandler, Schnittstellen, ..) und Eigenschaften (Größe des Arbeitsspeichers, Eeprom-Größe, Taktrate, Baudrate, ..) der Controller besitzt. Die davon abgebildeten Objekte und Interfaces erben die Eigenschaften bzw. Attribute dieser Basisklasse, sodass beispielsweise bestimmte Methoden und Eigenschaften nur dann zugänglich sind, wenn sie in der übergeordneten Klasse (in diesem Fall der Controller) vorhanden sind.

In Luna sind die gebräuchlichsten Hardware-Controllerfunktionen bzw. -Schnittstellen als Objekte/Interfaces abgebildet. Nicht implementierte Abbildungen als Objekte/Interfaces sind normal über den Direktzugriff auf die Konfigurations- und Datenports des Controllers erreichbar. Die Konfiguration z.Bsp. einer Schnittstelle erfolgt dann anhand der Portnamen und Konfigurationsbits laut Datasheet.

   Avr
    |
    +-- Eigenschaften
    |        |
    |        + Controller-Typ
    |        + Stack-Size
    |        + Größe Arbeitsspeicher
    |        + Größe Eeprom
    |        + Taktrate
    |        + ..
    +-- Objekte
    |      |
    |      + UART
    |      |   |
    |      |   + Eigenschaften
    |      |   |      |
    |      |   |      + Baudrate
    |      |   |      + Daten bereit zum empfangen
    |      |   |      + Daten bereit zum senden
    |      |   + Methoden
    |      |   |    |
    |      |   |    + Senden
    |      |   |    + Empfangen
    |      |   + Events
    |      |        |
    |      |        + Daten empfangen
    |      |        + Daten gesendet
    |      + Ports
    |      |   |
    |      |   + Eigenschaften
    |      |          |
    |      |          + Wert
    |      |          + PortBit
    |      |               |
    |      |               + Eigenschaften
    |      |                      |
    |      |                      + Wert
    |      + Arbeitsspeicher
    |      |        |
    |      |        + Objekte
    |      |             |
    |      |             + Variablen
    |      |             |     |
    |      |             |     + ..
    |      |             + MemoryBlock
    |      |                   |
    |      |                   + Methoden
    |      |                        |
    |      |                        + ByteValue 
    |      |                        + IntegerValue 
    |      |                        + WordValue 
    |      |                        + LongValue 
    |      |                        + SingleValue 
    |      |                        + StringValue 
    |      + ..
    + Methoden
          |
          + ..

Man kann nun auf die Eigenschaften und Methoden der Objekte zugreifen um die gewünschten Ziele zu erreichen. Zudem können selbst erstellte Klassen im Sinne eines Moduls oder einer Bibliothek erstellt werden. Dies vereinfacht den Zugriff auf die Hardware, minimiert die Fehlerrate und dient der Übersichtlichkeit im Programmcode.

Die grundlegende Programmstruktur ist im Allgemeinen Folgende:

• Controllerdefinition
  • Konfiguration
    • Deklarationen
    • Hauptprogramm
      • Unterprogramme
    • Benutzerdefinierte Klassen
    • Datenstrukturen