Inhaltsverzeichnis
LunaAVR
Luna ist eine objektbasierte, moderne Basic-ähnliche Programmiersprache, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen wie z.Bsp. RealStudio® orientiert. Sie ist mit einer einfach zu erlernenden Syntax ausgestattet und eignet sich für die effiziente und zeitsparende Entwicklung von kleinen bis großen Softwareprojekten für AVR Mikrocontroller.
Luna erhebt nicht den Anspruch andere Programmiersprachen zu ersetzen. Vielmehr soll das Angebot an freien Entwicklungswerkzeugen bereichert werden. Luna ist ein privat initiiertes Projekt und kostenlos.
Luna besteht aus integrierter Entwicklungsumgebung, einem Präprozessor, Compiler und Assembler. Software kann wahlweise in der IDE oder in einem normalen Texteditor geschrieben werden.
Die IDE bietet hierbei zusätzlich zu den allgemein wünschenswerten Funktionen wie Syntaxfärbung, automatischer Einrückung, Strukturierung von Bedingungen inklusive Ein- und Ausklappfunktion eine direkte Unterstützung der in Luna abgebildeten Hardware und Software-Objekte bzw. -Klassen der einzelnen AVR Controller.
Das erzeugte Binary und die Ausführungsgeschwindigkeit sind von der Größe her vergleichbar mit existierenden Hochsprachen wie z.Bsp. C/C++. Es gibt keine Beschränkung bei der Tiefe von Ausdrücken wie z.Bsp. in BASCOM. Zudem bietet es eine hochoptimierte dynamische Speicherverwaltung (dynamische Strings oder Speicherblöcke), Speicherstrukturen, dynamische Objekte, selbst erstellbare Klassen und Datenstrukturen.
Status des Projekts
Programme
Bibliotheken
- Typkonvertierungen
- Integer<>Single
- Integer<>String
- Single<>String
- Speicherverwaltung
- dynamische Objekte
- Strukturen
- Variablen
- Arrays
- Eeprom
- Strukturen
- Variablen
- Arrays
- Flash (Data)
- Strukturen
- Konstanten
- Math
- Integer 8-32 Bit
- Addition
- Subtraktion
- Multiplikation
- Division
- Fast Increment
- Fast Decrement
- Integer 8-32 Bit
- Floating Point (Single)
- Addition
- Subtraktion
- Multiplikation
- Division
- Fast Increment
- Fast Decrement
- Floating Point (Single)
- String
- Instr()
- Left()
- Right()
- Mid()
- Upper()
- Lower()
- Spc()
- StrFill()
- Chr()
- Mkb()
- Mki()
- Mkw()
- Mkl()
- Mks()
- Bin()
- Hex()
- Str()
- UART
- Konfiguration
- Eingabe
- Ausgabe
- Standardfunktionen
Aufbau und Struktur
Luna ist eine objektbasierte Programmiersprache.
Sie unterstützt mit Einschränkungen:
Vererbung Datenkapselung Polymorphie
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
Aufbau und Struktur
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.
Jeder AVR-Mikrocontroller ist intern als eine sogenannte „Klasse“ (die Basisklasse) implementiert. Diese beschreibt, welche Objekte (z.Bsp.: Ports, Timer, Wandler, Schnittstellen, ..) und Eigenschaften (Größe des Arbeitsspeichers, Eeprom-Größe, Taktrate, Baudrate, ..) der Controller besitzt. Die davon abgebildeten Objekte 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.
Hinweis: In Luna sind die gebräuchlichsten Hardware-Controllerfunktionen bzw. -Schnittstellen als Objekte abgebildet. Nicht implementierte Abbildungen als Objekt 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. Dies vereinfacht den Zugriff auf die Hardware, minimiert die Fehlerrate, dient der Übersichtlichkeit im Programmcode. Dies erleichtert den Weg zur effizienten und zügigen Softwareentwicklung.
Die grundlegende Programmstruktur ist im Allgemeinen Folgende:
- Controllerdefinition
- Konfiguration
- Deklarationen
- Hauptprogramm
- Unterprogramme
- Datenstrukturen
Weblinks
BeispielSource: helloworld.luna
avr.device = attiny2313 avr.clock = 20000000 ' Quarzfrequenz avr.stack = 16 ' Bytes Programmstack (Vorgabe: 16) uart.baud = 19200 ' Baudrate uart.Recv.enable ' Senden aktivieren uart.Send.enable ' Empfangen aktivieren print "Hallo Welt" Do Loop
Beispielsource: loops.luna
const Quartzfrequenz = 20000000 const prescaler = 256 avr.device = atmega32 avr.clock = 20000000 ' Quarzfrequenz avr.stack = 32 ' Bytes Programmstack (Vorgabe: 16) uart.baud = 19200 ' Baudrate uart.Recv.enable ' Senden aktivieren uart.Send.enable ' Empfangen aktivieren dim i as byte print 27 ; "[21" ; 27 ; "[2J" ; 27 ; "c" ; print "******* test source *************" print "* loops" print print "for i=0 to 9 ... next (prints 0-9)" for i=0 to 9 print str(i)+" "; next print print "for i=9 downto 0 ... next (prints 9-0)" for i=9 downto 0 print str(i)+" "; next print print "while i<10 ... wend (prints 0-9)" i=0 while i<10 print str(i)+" "; incr i wend print print "do .. loop until i<10 (prints 10-1)" do print str(i)+" "; decr i loop until i=0 print do Loop
Beispielsource: Blinksteuerung/Blinkmodul Auto & Motorrad
'--------------------------------------------------------------
' 2010 rgf software
'--------------------------------------------------------------
' Simple Blinksteuerung für Harley-Armaturen (Taster, kein Schalter)
' mit Antippfunktion (nur 3x Blinken bei kurzer Betätigung),
' automatischer Rückstellung und Warnblinklicht.
'--------------------------------------------------------------
avr.device = attiny85
avr.clock = 8000000
dim i,blinkmode,BlinkCount,KurzBlinken,LastPressed as byte
dim tcount,ticks,t as integer
const TasterState = 0
const DauerBlinkZeit = 300
portb.1.mode = Output, pulldown
portb.2.mode = Output, pulldown
portb.4.mode = Input, pulldown
portb.5.mode = Input, pulldown
Timer0.clock = 1024
Timer0.isr = BlinkTimer
Timer0.Enable
avr.interrupts.enable
define TasterLinks as PINB.4
define TasterRechts as PINB.3
define BlinkerLinks as PORTB.1
define BlinkerRechts as PORTB.2
do
if TasterLinks = TasterState then
waitms 25 ' debounce
if TasterLinks = TasterState then
if blinkmode > 0 then
call BlinkerOff
else
blinkmode = 1
KurzBlinken = 1
BlinkCount = 0
tcount = 0
call BlinkerToggle
waitms DauerBlinkZeit
if TasterLinks = TasterState then ' prüfen ob Taster immernoch gedrückt
KurzBlinken = 0
end if
if TasterRechts = TasterState then
waitms 25 ' debounce
if TasterRechts = TasterState then ' Beide gedrückt?
call BlinkerOff
blinkmode = 3
KurzBlinken = 0
end if
end if
end if
call TasterWait
end if
end if
if TasterRechts = TasterState then
waitms 25 ' debounce
if TasterRechts = TasterState then
if blinkmode > 0 then
call BlinkerOff
else
blinkmode = 2
KurzBlinken = 1
BlinkCount = 0
tcount = 0
call BlinkerToggle
waitms DauerBlinkZeit
if TasterRechts = TasterState then ' prüfen ob Taster immernoch gedrückt
KurzBlinken = 0
end if
if TasterLinks = TasterState then
waitms 25 ' debounce
if TasterLinks = TasterState then ' Beide gedrückt?
call BlinkerOff
blinkmode = 3
KurzBlinken = 0
end if
end if
end if
call TasterWait
end if
end if
loop
label TasterWait
do
waitms 25
loop until TasterLinks = 1 and TasterRechts = 1
endlabel
isr BlinkTimer
incr tcount
if tcount = 12 then ' 1,5 Hz
call BlinkerToggle
tcount = 0
incr BlinkCount
if KurzBlinken = 1 and BlinkCount >= 6 then ' 3 x blinken und aus
call BlinkerOff
elseif BlinkCount >= 200 then ' 100 x blinken und aus (wenn vergessen automatische Rückstellung)
if blinkmode < 3 then
call BlinkerOff
end if
end if
end if
endisr
label BlinkerOff
blinkmode = 0
BlinkerLinks = 0
BlinkerRechts = 0
endlabel
label BlinkerToggle
if blinkmode=1 or blinkmode=3 then
toggle BlinkerLinks
end if
if blinkmode=2 or blinkmode=3 then
toggle BlinkerRechts
end if
endlabel
