Version vom 1. Dezember 2011, 18:09 Uhr

Inhaltsverzeichnis

1 LunaAVR

LunaAVR

LunaAVR ist eine neue objektbasierte Programmiersprache für Atmel® AVR® Mikrocontroller, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen wie RealStudio® oder Java® 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.

LunaAVR ist ein junges Projekt, kostenlos und man kann an der Entwicklung der Sprache mitwirken.

Sämtliche Bibliotheksfunktionen auf die im Hintergrund zugegriffen werden, sind in Assembler geschrieben. Der erzeugte Code wird beim Kompiliervorgang wahlweise auf Länge oder Geschwindigkeit optimiert. Das erzeugte Binary ist von der Größe her vergleichbar mit existierenden Hochsprachen wie [1]. Die Geschwindigkeit liegt auf dem Level von C/C++ und ist damit bis zu 10x schneller als vergleichbarer Code aus BASCOM®. LunaAVR unterliegt wie auch C/C++ keiner Beschränkung bei der Tiefe von Ausdrücken. Zudem bietet es eine hochoptimierte dynamische Speicherverwaltung (z.Bsp. dynamische Strings oder Strukturen).

Status des Projekts

Programme

Editor (speziell angepasster Editor, Basis für IDE), Version 2.1.332 (derzeit noch nicht veröffentlicht)
Compiler Version 0.3.5_beta (Windows und Linux-Version verfügbar)

ausstehend

IDE

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

- Floating Point (Single)
  - Addition
  - Subtraktion
  - Multiplikation
  - Division
  - Fast Increment
  - Fast Decrement

String
- Instr()
- Left()
- Right()
- Mid()
- Upper()
- Lower()

UART
- Konfiguration
- Eingabe
- Ausgabe

Standardfunktionen

ausstehend

Math: Mul/Div 8-32 Bit Integer für Classic Core

Aufbau und Struktur

LunaAVR ist eine objektbasierte Programmiersprache und damit eine Zwischenform von prozeduraler und objektorientierter Programmiersprache.

Die Implementation der Objektbasierung richtet sich nach den Hardware-Gegebenheiten der AVR-Mikrocontroller. In AVR Mikrocontrollern wird der Maschinencode im Flashspeicher abgelegt, womit Programmteile nicht vererbt oder kopiert werden können, um sie an anderer Stelle auszuführen. Weiterhin sind die Ressourcen in Mikrocontrollern stark begrenzt.

Damit eine effiziente und speicherplatzsparende Programmierung möglich wird, ist die Objektbasierung in LunaAVR nicht überladen. Dem Programmierer soll unnötige Arbeit abgenommen und möglichst weitreichende Vorteile objektorientierter Programmierung bei gleichzeitigem vollen Zugriff auf alle Ressourcen zur Verfügung gestellt werden.

Jeder AVR-Mikrocontroller ist intern als eine sogenannte "Klasse" 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.

Darauf basierend werden Objekte abgeleitet, beispielsweise vom Arbeitsspeicher das Objekt "MemoryBlock" oder Variablen usw.

     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

@@ Zeile 11: / Zeile 11: @@
 ===Programme===
 * Editor (speziell angepasster Editor, Basis für IDE), Version 2.1.332 (derzeit noch nicht veröffentlicht)
-* Compiler Version 0.1.64_alpha (derzeit noch nicht veröffentlicht)
+* [http://avr.myluna.de Compiler Version 0.3.5_beta] (Windows und Linux-Version verfügbar)
 ====ausstehend====
 * IDE
-* Assembler
 ===Bibliotheken===
@@ Zeile 169: / Zeile 168: @@
 [[Kategorie:Quellcode LunaAVR]]
-'''BeispielSource: Terminal'''
+'''BeispielSource: helloworld.luna'''
 <pre>
 avr.device = attiny2313
-avr.clock = 20000000          ' Quarzfrequenz
+avr.clock = 20000000         ' Quarzfrequenz
-avr.stack = 32                ' Bytes Programmstack (Vorgabe: 16)
+avr.stack = 16               ' Bytes Programmstack (Vorgabe: 16)
-uart.baud = 19200             ' Baudrate
-uart.Recv.Enable
-uart.Send.Enable
-dim chars as string
+uart.baud = 19200            ' Baudrate
+uart.Recv.enable             ' Senden aktivieren
+uart.Send.enable             ' Empfangen aktivieren
-print 27 ; "[21" ; 27 ; "[2J" ; chr(27) ; "c" ;	27 ; "[?6l";	' Terminal setup (VT100 clear)
+print "Hallo Welt"
 Do
-  inpstr " terminal > ",chars
-  select case chars
-  case "hallo"
-    print "jenau, wie gehts?"
-  caseelse
-    print "Sie haben eingegeben: "+34+chars+34
-  endselect
 Loop
 </pre>
-'''Beispielsource: Exceptions'''
+'''Beispielsource: loops.luna'''
 <pre>
+const Quartzfrequenz = 20000000
+const prescaler = 256
 avr.device = atmega32
-avr.clock = 20000000          ' Quarzfrequenz
+avr.clock = 20000000         ' Quarzfrequenz
-avr.stack = 32                ' Bytes Programmstack (Vorgabe: 16)
+avr.stack = 32               ' Bytes Programmstack (Vorgabe: 16)
-uart.baud = 19200             ' Baudrate
-uart.Recv.Enable
-uart.Send.Enable
-dim chars as string
+uart.baud = 19200            ' Baudrate
-dim m,m1 as memory
+uart.Recv.enable             ' Senden aktivieren
+uart.Send.enable             ' Empfangen aktivieren
-print 27 ; "[21" ; 27 ; "[2J" ; chr(27) ; "c" ;	27 ; "[?6l";	' Terminal setup
+dim i as byte
-Do
+print 27 ; "[21" ; 27 ; "[2J" ; 27 ; "c" ;
-  inpstr " test > ",chars
+print "******* test source *************"
-  call ausgabe(chars)
+print "* loops"
-  select case chars
+print
-  case "m"      ' ständig neuen memoryblock anlegen bis Speicher voll
-    m = MemoryBlock(100)
-  case "v"
-    print "m.ByteValue(0)="+str(m.ByteValue(0)) ' aufruf vor zuweisung eines MemoryBlock führt zur Exception
-  endselect
-  print "SRAM: "+str(memory.space)+" Bytes frei"
-  print "--------------------------------------------------------"
-Loop
-procedure ausgabe(s as string)
+print "for i=0 to 9 ... next (prints 0-9)"
-  print "s = "+s
+for i=0 to 9
-  print "chars = "+chars
+print str(i)+" ";
-endproc
+next
+print
-Exception OutOfSpaceMemory
+print "for i=9 downto 0 ... next (prints 9-0)"
-  print "*** Exception OutOfSpaceMemory ***"
+for i=9 downto 0
-EndException
+print str(i)+" ";
-Exception OutOfBoundsMemory
+next
-  print "*** Exception OutOfBoundsMemory ***"
+print
-EndException
-Exception NilObjectException
-  print "*** Exception NilObjectException ***"
-EndException
+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
 </pre>

LunaAVR: Unterschied zwischen den Versionen

Ansichten

Version vom 1. Dezember 2011, 18:09 Uhr

Inhaltsverzeichnis

LunaAVR

Status des Projekts

Programme

ausstehend

Bibliotheken

ausstehend

Aufbau und Struktur

Weblinks

Navigationsmenü

Hauptthemen

Navigation

Suche

Werkzeuge

Meine Werkzeuge