RN-Wissen.de - Benutzerbeiträge [de]

LunaAVR

2012-12-03T12:32:23Z

Rgf:

=LunaAVR=

[[Bild:r8s01.jpg|thumb|Luna-IDE]]
[[Bild:r8s02.jpg|thumb|Disassembler]]
[[Bild:r8s03.jpg|thumb|LCD-Zeichenditor]]
[[Bild:r8s04.jpg|thumb|GLCD-Pictureeditor]]
[[Bild:r8s05.jpg|thumb|GLCD-Fonteditor]]

Luna ist eine objektbasierte, moderne Basic- oder Pascal-ähnliche Programmiersprache, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen orientiert. Sie ist mit einer durchdachten und verständlichen Syntax ausgestattet, bietet jedoch im Gegensatz zu einfacheren Basic-Sprachen wie z.Bsp. BASCOM, wesentlich komplexere Möglichkeiten auf technischer Augenhöhe mit Pascal und C/C++. Sie eignet sich damit für die effiziente und zeitsparende Entwicklung von kleinen bis hin zu großen, anspruchsvollen Softwareprojekten für AVR Mikrocontroller.

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. Zusätzlich sind ein Bibliothekseditor, Verzeichnis der Controller-Defines und weitere nützliche Werkzeuge vorhanden.

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.

Die AVR-spezifischen Code-Teile sind quelloffen und vollständig in Assembler geschrieben.

==Status des Projekts==

Luna bietet eine vollwertige, kostenlose Entwicklungsumgebung mit Compiler, Präprozessor, Assembler und Disassembler. Zusätzlich ist ein Library-Browser/Editor integriert, mit dem man die Standardbbliotheksfunktionen des Compilers einsehen und editieren kann (Assembler). Luna ist zudem für Windows, Linux und Mac-OS verfügbar.

Es sind sehr umfangreiche Befehle und Funktionen zur Stringmanipulation, Speicherverwaltung, Bitmanipulation, Arithmetik (inklusive einer Fließkommaarithmetik) uvm. implementiert.

[http://avr.myluna.de/doku.php?id=de:befehlsuebersicht Der Befehlssatz von Luna]

== Aufbau und Struktur ==

Luna ist eine objektbasierte Programmiersprache.

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.

Luna unterstützt [http://de.wikipedia.org/wiki/Klasse_%28Programmierung%29 Klassen], womit Module und in sich geschlossene Codebereiche erstellt werden können.

==Weblinks==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Version]
* [http://avr.myluna.de/doku.php?id=de:beispiel-sourcen Beispiel-Sourcen]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

LunaAVR

2012-12-03T12:30:40Z

Rgf:

=LunaAVR=

[[Bild:r8s01.jpg|thumb|Luna-IDE]]
[[Bild:r8s02.jpg|thumb|Disassembler]]
[[Bild:r8s03.jpg|thumb|LCD-Zeichenditor]]
[[Bild:r8s04.jpg|thumb|GLCD-Pictureeditor]]
[[Bild:r8s05.jpg|thumb|GLCD-Fonteditor]]

Luna ist eine objektbasierte, moderne Basic- oder Pascal-ähnliche Programmiersprache, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen orientiert. Sie ist mit einer durchdachten und verständlichen Syntax ausgestattet, bietet jedoch im Gegensatz zu einfacheren Basic-Sprachen wie z.Bsp. BASCOM, wesentlich komplexere Möglichkeiten auf technischer Augenhöhe mit Pascal und C/C++. Sie eignet sich damit für die effiziente und zeitsparende Entwicklung von kleinen bis hin zu großen, anspruchsvollen Softwareprojekten für AVR Mikrocontroller.

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. Zusätzlich sind ein Bibliothekseditor, Verzeichnis der Controller-Defines und weitere nützliche Werkzeuge vorhanden.

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.

Die AVR-spezifischen Code-Teile sind quelloffen und vollständig in Assembler geschrieben.

==Status des Projekts==

Luna bietet eine vollwertige, kostenlose Entwicklungsumgebung mit Compiler, Präprozessor, Assembler und Disassembler. Zusätzlich ist ein Library-Browser/Editor integriert, mit dem man die Standardbbliotheksfunktionen des Compilers einsehen und editieren kann (Assembler). Luna ist zudem für Windows, Linux und Mac-OS verfügbar.

Es sind sehr umfangreiche Befehle und Funktionen zur Stringmanipulation, Speicherverwaltung, Bitmanipulation, Arithmetik (inklusive einer Fließkommaarithmetik) uvm. implementiert.

[http://avr.myluna.de/doku.php?id=de:befehlsuebersicht Der Befehlssatz von Luna]

== Aufbau und Struktur ==

Luna ist eine objektbasierte Programmiersprache.

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.

Luna unterstützt damit das [http://de.wikipedia.org/wiki/Klasse_%28Programmierung%29], womit Module und in sich geschlossene Codebereiche erstellt werden können.

==Weblinks==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Version]
* [http://avr.myluna.de/doku.php?id=de:beispiel-sourcen Beispiel-Sourcen]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

LunaAVR

2012-12-03T12:27:45Z

Rgf:

=LunaAVR=

[[Bild:r8s01.jpg|thumb|Luna-IDE]]
[[Bild:r8s02.jpg|thumb|Disassembler]]
[[Bild:r8s03.jpg|thumb|LCD-Zeichenditor]]
[[Bild:r8s04.jpg|thumb|GLCD-Pictureeditor]]
[[Bild:r8s05.jpg|thumb|GLCD-Fonteditor]]

Luna ist eine objektbasierte, moderne Basic- oder Pascal-ähnliche Programmiersprache, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen orientiert. Sie ist mit einer durchdachten und verständlichen Syntax ausgestattet, bietet jedoch im Gegensatz zu einfacheren Basic-Sprachen wie z.Bsp. BASCOM, wesentlich komplexere Möglichkeiten auf technischer Augenhöhe mit Pascal und C/C++. Sie eignet sich damit für die effiziente und zeitsparende Entwicklung von kleinen bis hin zu großen, anspruchsvollen Softwareprojekten für AVR Mikrocontroller.

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. Zusätzlich sind ein Bibliothekseditor, Verzeichnis der Controller-Defines und weitere nützliche Werkzeuge vorhanden.

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.

Die AVR-spezifischen Code-Teile sind quelloffen und vollständig in Assembler geschrieben.

==Status des Projekts==

Luna bietet eine vollwertige, kostenlose Entwicklungsumgebung mit Compiler, Präprozessor, Assembler und Disassembler. Zusätzlich ist ein Library-Browser/Editor integriert, mit dem man die Standardbbliotheksfunktionen des Compilers einsehen und editieren kann (Assembler). Luna ist zudem für Windows, Linux und Mac-OS verfügbar.

Es sind sehr umfangreiche Befehle und Funktionen zur Stringmanipulation, Speicherverwaltung, Bitmanipulation, Arithmetik (inklusive einer Fließkommaarithmetik) uvm. implementiert.

[http://avr.myluna.de/doku.php?id=de:befehlsuebersicht Der Befehlssatz von Luna]

== Aufbau und Struktur ==

Luna ist eine objektbasierte Programmiersprache.

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.

Luna unterstützt damit das [[Klassenmodell]], womit Module und in sich geschlossene Codebereiche erstellt werden können.

==Weblinks==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Version]
* [http://avr.myluna.de/doku.php?id=de:beispiel-sourcen Beispiel-Sourcen]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

LunaAVR

2012-12-03T12:25:20Z

Rgf:

=LunaAVR=

[[Bild:r8s01.jpg|thumb|Luna-IDE]]
[[Bild:r8s02.jpg|thumb|Disassembler]]
[[Bild:r8s03.jpg|thumb|LCD-Zeichenditor]]
[[Bild:r8s04.jpg|thumb|GLCD-Pictureeditor]]
[[Bild:r8s05.jpg|thumb|GLCD-Fonteditor]]

Luna ist eine objektbasierte, moderne Basic- oder Pascal-ähnliche Programmiersprache, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen orientiert. Sie ist mit einer durchdachten und verständlichen Syntax ausgestattet, bietet jedoch im Gegensatz zu einfacheren Basic-Sprachen wie z.Bsp. BASCOM, wesentlich komplexere Möglichkeiten auf technischer Augenhöhe mit Pascal und C/C++. Sie eignet sich damit für die effiziente und zeitsparende Entwicklung von kleinen bis hin zu großen, anspruchsvollen Softwareprojekten für AVR Mikrocontroller.

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. Zusätzlich sind ein Bibliothekseditor, Verzeichnis der Controller-Defines und weitere nützliche Werkzeuge vorhanden.

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.

Die AVR-spezifischen Code-Teile sind quelloffen und vollständig in Assembler geschrieben.

==Status des Projekts==

Luna bietet eine vollwertige, kostenlose Entwicklungsumgebung mit Compiler, Präprozessor, Assembler und Disassembler. Zusätzlich ist ein Library-Browser/Editor integriert, mit dem man die Standardbbliotheksfunktionen des Compilers einsehen und editieren kann (Assembler). Luna ist zudem für Windows, Linux und Mac-OS verfügbar.

Es sind sehr umfangreiche Befehle und Funktionen zur Stringmanipulation, Speicherverwaltung, Bitmanipulation, Arithmetik (inklusive einer Fließkommaarithmetik) uvm. implementiert.

== Aufbau und Struktur ==

Luna ist eine objektbasierte Programmiersprache.

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.

Luna unterstützt damit das [[Klassenmodell]], womit Module und in sich geschlossene Codebereiche erstellt werden können.

==Weblinks==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Version]
* [http://avr.myluna.de/doku.php?id=de:beispiel-sourcen Beispiel-Sourcen]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

LunaAVR

2012-12-03T12:24:20Z

Rgf:

=LunaAVR=

[[Bild:r8s01.jpg|thumb|Luna-IDE]]
[[Bild:r8s02.jpg|thumb|Disassembler]]
[[Bild:r8s03.jpg|thumb|LCD-Zeichenditor]]
[[Bild:r8s04.jpg|thumb|GLCD-Pictureeditor]]
[[Bild:r8s05.jpg|thumb|GLCD-Fonteditor]]

Luna ist eine objektbasierte, moderne Basic- oder Pascal-ähnliche Programmiersprache, deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen orientiert. Sie ist mit einer durchdachten und verständlichen Syntax ausgestattet, bietet jedoch im Gegensatz zu einfacheren Basic-Sprachen wie z.Bsp. BASCOM, **wesentlich** komplexere Möglichkeiten auf technischer Augenhöhe mit Pascal und C/C++. Sie eignet sich damit für die effiziente und zeitsparende Entwicklung von kleinen bis hin zu großen, anspruchsvollen Softwareprojekten für AVR Mikrocontroller.

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. Zusätzlich sind ein Bibliothekseditor, Verzeichnis der Controller-Defines und weitere nützliche Werkzeuge vorhanden.

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.

Die AVR-spezifischen Code-Teile sind quelloffen und vollständig in Assembler geschrieben.

==Status des Projekts==

Luna bietet eine vollwertige, kostenlose Entwicklungsumgebung mit Compiler, Präprozessor, Assembler und Disassembler. Zusätzlich ist ein Library-Browser/Editor integriert, mit dem man die Standardbbliotheksfunktionen des Compilers einsehen und editieren kann (Assembler). Luna ist zudem für Windows, Linux und Mac-OS verfügbar.

Es sind sehr umfangreiche Befehle und Funktionen zur Stringmanipulation, Speicherverwaltung, Bitmanipulation, Arithmetik (inklusive einer Fließkommaarithmetik) uvm. implementiert.

== Aufbau und Struktur ==

Luna ist eine objektbasierte Programmiersprache.

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.

Luna unterstützt damit das [[Klassenmodell]], womit Module und in sich geschlossene Codebereiche erstellt werden können.

==Weblinks==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Version]
* [http://avr.myluna.de/doku.php?id=de:beispiel-sourcen Beispiel-Sourcen]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

Datei:R8s05.jpg

2012-12-03T12:14:57Z

Rgf:

Datei:R8s04.jpg

2012-12-03T12:14:37Z

Rgf:

Datei:R8s03.jpg

2012-12-03T12:14:00Z

Rgf:

Datei:R8s02.jpg

2012-12-03T12:13:30Z

Rgf: LunaAVR Disassembler

LunaAVR Disassembler

Datei:R8s01.jpg

2012-12-03T12:12:31Z

Rgf: LunaAVR IDE

LunaAVR IDE

LunaAVR

2012-12-03T12:11:23Z

Rgf:

=LunaAVR=

[[Bild:r8s01.jpg|thumb|Luna-IDE]]
[[Bild:r8s02.jpg|thumb|Disassembler]]
[[Bild:r8s03.jpg|thumb|LCD-Zeichenditor]]
[[Bild:r8s04.jpg|thumb|GLCD-Pictureeditor]]
[[Bild:r8s05.jpg|thumb|GLCD-Fonteditor]]

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.

Die AVR-spezifischen Code-Teile sind quelloffen und vollständig in Assembler geschrieben.

==Status des Projekts==

Luna bietet eine vollwertige Entwicklungsumgebung mit Compiler, präprozessore, Assembler und Disassembler. Zusätzlich ist ein Library-Browser/Editor integriert, mit dem man die Standardbbliotheksfunktionen des Compilers einsehen und editieren kann (Assembler).

== Aufbau und Struktur ==

Luna ist eine objektbasierte Programmiersprache.

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.

==Weblinks==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Version]
* [http://avr.myluna.de/doku.php?id=de:beispiel-sourcen Beispiel-Sourcen]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

HEX-Datei

2012-12-03T11:44:57Z

Rgf:

Die sogenannte '''Hex-Datei''' (auch Intel-Hex-Format) wird von einigen [[Compiler]]n als Ausgabedatei erzeugt (z.B. [[Bascom|Bascom Basic]]). Die HEX-Datei enthält das compilierte Programm in binärer Form und wird verwendet, wenn es in den [[Mikrocontroller]] übertragen werden soll.

In diesem Artikel soll hauptsächlich auf die für die Mikrocontrollerprogrammierung (davon für [[AVR]]) wichtigen Infos eingegangen werden.

=== Was hat es damit auf sich? ===

* Wird von der Programmiersoftware verwendet zum Übertragen des Codes in den Controller (flashen)
* Hex steht als Abkürzung für Hexadezimal
* In der Datei kommen nur die druckbaren (ASCII-)Zeichen 0-9, A-F, : und Leerzeichen vor und könnte deshalb mit jedem Texteditor geöffnet und bearbeitet werden
* In jeder Zeile ist eine Prüfsumme angefügt zum einfachen Erkennen von Übertragungsfehlern

== Historisches ==

Ein von Intel eingeführtes Dateiformat zum besseren Verarbeiten binärer Daten.
Ursprünglich war das Format wegen des 16Bit-Adressraumes bis max. 64 KByte Daten ausgelegt. Erst später wurde durch Hinzufügen weiterer ''[[#Datensatz-Typen|Datensatz-Typen]]'' der Adressraum erweitert.
Unter Anlehnung an die Struktur der Intel-CPUs wurden die zusätzlichen Datensatz-Typen für 20-Bit- und 32-Bit-Adressierung aufgebaut.

Da nur lesbare Zeichen zur Darstellung verwendet werden, können binäre Daten auf Bildschirm und Drucker ausgegeben werden, was bei Einführung dieses Formats (19xx, wenig bis gar keine el. Massenspeicher) noch von Bedeutung war.

== Internes ==

Wer eine Hex-Datei schon einmal mit einem Texteditor geöffnet hat, sieht eine Zeile wie diese:

:1000B000526F626F7465726E65747A2E646520206B

Eine Zeile wird als Record (Datensatz) bezeichnet.

Jedes Byte wird in hexadezimaler Schreibweise dargestellt.

Bedeutung:

<div align="center">
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Start || Anzahl || Adresse || Typ || Daten || Prüfsumme
|- align="center"
|:||10||00 B0||00||52 6F 62 6F 74 65 72 6E 65 74 7A 2E 64 65 20 20||6B
|}
</div>

=== Start ===

Es steht immer ein ":" (Doppelpunkt) am Zeilenanfang.

=== Anzahl ===

Gibt die Anzahl der effektiven Datenbytes an, kann von 0 - 255 (0x00 - 0xFF) Bytes enthalten

=== Adresse ===

Adresse im 16-Bit Format an der die folgenden Daten gespeichert werden sollen. Mit 16 Bit können max. 64KByte an Daten Adressiert werden. Wer einen [[ATmega128]] (oder größer) voll ausnutzt, wird auch weitere Datensatztypen als üblich in der Hex-Datei finden.

=== Datensatz-Typen ===

==== 00 - Daten ====
:Ein Ausschnitt der Beispielzeile von oben:

:1000B0'''00'''52....6B

:Die Zeile enthält 0x10 (dez 16) Bytes an Nutzdaten, diese sollen ab Adresse 0x00B0 (dez 176) gespeichert werden.

==== 01 - letzte Zeile ====
:Die letzte Zeile sieht so aus:

:000000'''01'''FF

:Danach folgt entweder das Dateiende, oder die Übertragung wird abgeschlossen.

==== 02 - erweiterte Segment-Adresse ====
:Eine "erweiterte Segment-Adress"-Zeile kann so aussehen:

:020000'''02'''1000EC

:Sie wird benötigt, wenn die Daten den Adressraum von 64KByte überschreiten (ab [[ATmega128]]).
:Im Datenbereich wird der oberer Teil (Bits 4-19) einer 20-Bit-Adresse im 16-Bit-Format angegeben. Zu dieser muss dann die Offset-Adresse jeder Zeile hinzuaddiert werden, um die eigentliche Adresse zu erhalten.

==== 03 - Start Segment-Adresse ====
:Eine "Start Segment-Adress"-Zeile kann so aussehen:

:040000'''03'''20000000D9

:Sie wird benötigt, wenn die Daten an einer Adresse abgelegt werden sollen, die außerhalb eines 64KByte-Adressraums liegt.
:Im Datenbereich wird die Adresse im 2×16-Bit-Format (Segment und Adresse) angegeben. Ergibt eine 20-Bit Adresse. Ist für die Struktur der Intel-CPUs ausgelegt.

==== 04 - erweiterte Linear-Adresse ====
:Eine "erweiterte Linear-Adress"-Zeile kann so aussehen:

:020000'''04'''3000CA

:Im Datenbereich wird der obere Teil (Bits 16-31) einer 32-Bit-Adresse im 16-Bit-Format angegeben.

==== 05 - Start Linear-Adresse ====
:Eine "Start Linear-Adress"-Zeile kann so aussehen:

:040000'''05'''00100000E7

:Im Datenbereich wird die Adresse im 32-Bit-Format angegeben.

=== Daten/Info ===

Die eigentlichen Daten, bzw. Infos je nach Datensatztyp, max. 255 Byte pro Zeile

=== Prüfsumme ===

In die Prüfsumme fließen alle Bytes der Zeile ein, incl. der Anzahl, Adresse und Typ, aber nicht die Startmarkierung.

==== erzeugen ====

:Zum Erzeugen der Prüfsumme werden alle Bytes der Zeile als Zweier-Komplement summiert, sieht mit den Daten der Beispielzeile in verständlicher Schreibweise so aus:

'''0x00''' - 0x10 - 0x00 - 0xB0 - 0x00 - 0x52 - 0x6F - 0x62 - 0x6F - 0x74 - 0x65 - 0x72 - 0x6E -
0x65 - 0x74 - 0x7A - 0x2E - 0x64 - 0x65 - 0x20 - 0x20 = 0xF9'''6B'''
:Da nur das Low-Byte als Prüfsumme angegeben wird (Modulo-256-Summe), wird der Wert <tt>0x6B</tt> angehängt.

==== überprüfen ====

:Zum Überprüfen der Daten muss die Summe aller Bytes, incl. der Prüfsumme, das (Modulo-256)-Ergebnis <tt>0x00</tt> ergeben.

:Die Beispielzeile wird so berechnet:
0x10 + 0x00 + 0xB0 + 0x00 + 0x52 + 0x6F + 0x62 + 0x6F + 0x74 + 0x65 + 0x72 + 0x6E +
0x65 + 0x74 + 0x7A + 0x2E + 0x64 + 0x65 + 0x20 + 0x20 + 0x'''6B''' = 0x7'''00'''
:Da nur das Low-Byte überprüft wird (Modulo-256), dieses hier <tt>0x00</tt> ist, kann die Zeile als erfolgreich übertragen angesehen werden.

== Anwendungen ==
Software zum Umgang mit Hex-Dateien:

=== avr-objcopy ===

Wer die Tools zur AVR-Programmierung installiert hat (unter Windows [[WinAVR]]), hat Zugriff auf das Consolen-Tool ''avr-objcopy''.

Damit ist es möglich, diverse Dateiformate, u.a. Hex-Dateien, in andere Formate zu übertragen.

Mit der folgenden Anweisung wird die Datei "test.bin", welche im Format ''binary'' (<tt>-I</tt>) vorliegt, im Format ''ihex'' (<tt>-O</tt>) gespeichert, unter dem neuen Dateinamen "test.hex".

avr-objcopy -O ihex -I binary test.bin test.hex

In die andere Richtung geht das natürlich auch, (Hex-Datei in Binär-Datei übertragen):

avr-objcopy -I ihex -O binary test.hex test.bin

Beim Compilieren eines C-Quellcodes wird dieses Tool üblicherweise über das [[Makefile]] aufgerufen, so dass die Hex-Datei bei "make all" automatisch erstellt wird.

=== BinHex ===

Unter den Tools von [[LunaAVR]] gibt es das Consolen-Tool ''binhex''.

Damit ist es möglich, Rohdaten in das Hex-Format zu wandeln. Optional können dabei auch bestimmte Speichergrenzen angegeben werden. Das Tool speichert auch Binärdaten korrekt die größer als 64k sind.

Mit der folgenden Anweisung wird die Datei "test.bin", welche im Format ''binary'' vorliegt, im Format ''ihex'' mit der Dateiendung ".hex" gespeichert (die Zieldatei ist automatisch der Originaldateiname mit Dateiendung ".hex", wenn keine extra Zieldatei angegeben wurde). Andere Dateinamen oder Dateipfade können mit der Option (<tt>-d</tt>) angegeben werden.

binhex -v test.bin

=== Bascom-Programmer ===

[[Bild:BascomOptionsHexFile.jpg|thumb|Compiler/Output]]
Für das Bascom-interne Programmiertool ist die Hex-Datei nicht zwingend notwendig, da dies mit der Binärdatei auskommt. Falls aber eine andere Anwendung dafür eingesetzt werden muss, gibt es in den Optionen (unter Compiler/Output) ein Auswahlfeld, das beim Compilieren eine Hex-Datei erzeugen lässt (standardmäßig schon ausgewählt). Andersherum, lassen sich mit dem Bascom Programmiertool auch anders erstellte HEX-Dateien zum µC übertragen.

Mit dem Bascom Programmiertool können vom AVR ausgelesene Daten als Binär- oder Hex-Datei gespeichert werden. <small>(Das scheint aber z.Zt. einen kleinen Bug zu haben, denn ab 64KByte stimmt die Adresse nicht mehr :-)</small>

== Siehe auch ==

* [[Programmer]]
* [[HEX Beispiel-Dateien für AVR]]
* [[Bascom - Erstes Programm in den AVR Controller übertragen]]

== Quellen ==

* [http://www.google.de/search?hl=de&q=intelhex] u.a. :-)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]

LCD-Modul am AVR

2012-09-15T17:14:27Z

Rgf:

[[Bild:lcdmodul_2.jpg|right|thumb|350px|LCD-Modul]]

==Einleitung==

LCD ist eine Abkürzung und bedeutet '''''L'''iquid '''C'''rystal '''D'''isplay''. Übersetzt bedeutet dies Flüssigkristall-Anzeige. Flüssigkristalle sind organische Verbindungen, die Eigenschaften von Flüssigkeiten und Festkörpern besitzen. Zwischen zwei Glasplatten mit Polarisationsfiltern schwimmen die Flüssigkristalle. Durch Anlegen einer Wechselspannung ändert sich die Polarisationsebene der Flüssigkristalle und damit, ob das einfallende Licht reflektiert oder absorbiert wird.

Bei einem LCD-Modul befindet sich neben dem LCD auch ein Controller zur Ansteuerung des LCDs.

==Text-Displays==

Text-Displays kommen wegen der problemlosen Anbindung in Mikrocontroller Projekten wie Robotern am häufigsten zum Einsatz. Bei Text-LCDs kommen meistens der HD44780 von Hitachi oder ein kompatibler Controller zum Einsatz. Dieser Controller unterstützt Displays mit bis zu 80 Zeichen. Gängige Displaygrößen sind: 8 × 1, 8 × 2, 16 × 1, 16 × 2, 20 × 2, 20 × 4, 40 × 2 Zeichen Displays (Spalten × Zeilen). Hat das Display mehr als 80 Zeichen, dann benötigt das Display 2 Controller und verhält sich nach außen zur Ansteuerung, wie 2 Displays (zusätzliche Enable Leitung)

===Anschlußbelegung für ≤80 Zeichen Displays===

Text-Displays verfügen über genormte 14 Anschluss Pins (LCD-Module mit Backlight über 16 Pins). Lediglich bei der Backlight Versorgungsspannung und Polung kann es Unterschiede geben. Im Zweifelsfall hilft hier der Blick ins Datenblatt. Entweder sind die Anschlüsse in einer Reihe (1 × 14(16)) oder zweireihig (2 × 7(8)) herausgeführt.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Pin'''
|'''Bezeichnung'''
|'''Beschreibung'''
|-
|1
|GND
|Masse
|---
|2
|VCC
|Spannungsversorgung +5V
|---
|3
|VEE
|Kontrast Poti 0..0,5V
|---
|4
|RS
|Register Select, 1=Daten schreiben / 0=Kommando senden.
|---
|5
|R/W
|1=Read / 0=Write zum lesen / schreiben in das Display RAM
|---
|6
|Enable
|Fallende Flanke -> Übertragen des Kommandos oder der Daten, H-Pegel -> Lesen von Daten aus dem Display
|---
|7
|DB0
|Datenbus Bit0 LSB
|---
|8
|DB1
|Datenbus Bit1
|---
|9
|DB2
|Datenbus Bit2
|---
|10
|DB3
|Datenbus Bit3
|---
|11
|DB4
|Datenbus Bit4
|---
|12
|DB5
|Datenbus Bit5
|---
|13
|DB6
|Datenbus Bit6
|---
|14
|DB7
|Datenbus Bit7 MSB
|}

===HD44780 kompatibler LCD Controller===

Der HD44780 LCD Controller besitzt 3 Speicher. Den DDRAM (Display Data RAM) Darin werden die anzuzeigenden Daten geschrieben.
Der CGROM (Character Generator ROM) enthält die Zeichen in Form von 5x8 oder 5x10 Punktmatrizen.
Im CGRAM (Character Generator RAM) können acht benutzerdefinierte Zeichen 5x8 Pixel oder vier 5x10 Pixel abgelegt werden.

====Befehlsübersicht====

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Befehl'''
| '''RS'''
| '''R/W'''
| '''DB7'''
| '''DB6'''
| '''DB5'''
| '''DB4'''
| '''DB3'''
| '''DB2'''
| '''DB1'''
| '''DB0'''
| '''Beschreibung'''
| '''Ausführungszeit bei f<sub>osc</sub>=250kHz'''
|-
|Clear Display
|0
|0
|0
|0
|0
|0
|0
|0
|0
|1
|Löscht das Display und setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0).
|1.64mS
|-
|Cursor Home
|0
|0
|0
|0
|0
|0
|0
|0
|1
|*
|setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0)
|1.64mS
|-
|Entry mode set
|0
|0
|0
|0
|0
|0
|0
|1
|I/D
|S
|Setzt die Cursor Bewegungsrichtung (I/D), spezifiziert das Display zu schieben (S). Diese Operationen werden während des Daten lesen/schreiben durchgeführt.
|40uS
|-
|Display on/off Control
|0
|0
|0
|0
|0
|0
|1
|D
|C
|B
|Schaltet an/aus: das gesamte Display (D), Den Cursor (C) Cursor blinken (B).
|40uS
|-
|Cursor/Display shift
|0
|0
|0
|0
|0
|1
|S/C
|R/L
|*
|*
|Setzt Cursor Bewegung oder Display Bewegung (S/C), Bewegungsrichtung (R/L)
|40uS
|-
|Function set
|0
|0
|0
|0
|1
|DL
|N
|F
|*
|*
|Einstellen der Schnittstellen Datenlänge (DL), Anzahl Display Zeilen (N) und Zeichen Font (F).
|40uS
|-
|Set CGRAM Address
|0
|0
|0
|1
|colspan=6 |CGRAM Adresse
|Setzen der CGRAM Adresse. CGRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Set DDRAM Address
|0
|0
|1
|colspan=7 |DDRAM Adresse
|Setzen der DDRAM Adresse. DDRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Read busy-flag and address counter
|0
|1
|BF
|colspan=7 |CGRAM / DDRAM Adresse
|Liest das Busy-flag (BF), welches anzeigt das interne Operationen ausgeführt werden, und liest den CGRAM oder DDRAM Adress Zeiger Inhalt.
|0uS
|-
|Write to CGRAM or DDRAM
|1
|0
|colspan=8 |Schreib Daten
|Schreibt Daten zum CGRAM oder DDRAM.
|40uS
|-
|read from CGRAM or DDRAM
|1
|1
|colspan=8 |Lese Daten
|Liest Daten vom CGRAM oder DDRAM.
|40uS
|}

Anmerkungen:
* DDRAM = Display Data RAM.
* CGRAM = Character Generator RAM.
* DDRAM Adresse entspricht der Cursor Position.
* * = egal.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Bit Name'''
|'''Einstellung / Status'''
|
|-
|I/D
|0 = Erniedrige Cursor Position
|1 = Erhöhe Cursor Position
|-
|S
|0 = Display nicht schieben
|1 = Display schieben
|-
|D
|0 = Display aus
|1 = Display an
|-
|C
|0 = Cursor aus
|1 = Cursor an
|-
|B
|0 = Cursor blinken aus
|1 = Cursor blinken an
|-
|S/C
|0 = Bewege Cursor
|1 = Schiebe Display
|-
|R/L
|0 = Schiebe nach links
|1 = Schiebe nach rechts
|-
|DL
|0 = 4-bit Interface
|1 = 8-bit Interface
|-
|N
|0 = 1/8 oder 1/11 Duty (1 Zeile)
|1 = 1/16 Duty (2 Zeilen)
|-
|F
|0 = 5x7 Punkte
|1 = 5x10 Punkte
|-
|BF
|0 = Befehle werden akzeptiert
|1 = Interne Operation wird ausgeführt
|}

===8-Bit Ansteuerung (Busmode)===

Die "8-Bit Busmode"-Ansteuerung funktioniert nur bei AVR Prozessoren mit externem Bus Interface. Diesen Mode unterstützen allerdings nur die wenigsten Atmel AVR Prozessoren, z.B. der AT90S8515 und ATmega128. Der Busmode empfiehlt sich, wenn man in der Applikation auch externen Speicher verwendet.

[[Bild:lcdmodul_8bit_schem.png|center|thumb|600px|8-Bit Ansteuerung. Quelle: Peter Fleury]]

====BASCOM-AVR Programm====
Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode.
<pre>
$regfile = "8515def.dat"
$crystal = 4000000
$lcd = &HC000 'Adresse LCD Daten
$lcdrs = &H8000 'Adresse LCD Register select

Config Lcdbus = 8 'LCD im 8-Bit Bus Mode
Config Lcd = 16 * 2 'wir verwenden ein 16 x 2 Zeichen Display

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 4000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 2 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 16 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 0 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
...
#elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || \
defined(__AVR_ATmega8515__)|| defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || \
defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__)
/*
* memory mapped mode is only supported when the device has an external data memory interface
*/
#define LCD_IO_DATA 0xC000 /* A15=E=1, A14=RS=1 */
#define LCD_IO_FUNCTION 0x8000 /* A15=E=1, A14=RS=0 */
#define LCD_IO_READ 0x0100 /* A8 =R/W=1 (R/W: 1=Read, 0=Write */
#else
#error "external data memory interface not available for this device, use 4-bit IO port mode"

#endif

...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung mit Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 7 Prozessor Ports benötigt. Die Abfrage des Busy Flags ist durch die Verdrahtung des R/W Pins möglich.

[[Bild:lcdmodul_4bitbusy_schem.png|center|thumb|600px|4-Bit Ansteuerung mit Busy]]
Anmerkung: Unbenutzte Pins des Datenports vom LCD sollten auf GND gelegt werden, da sie ansonsten auf keinen definierten Pegel liegen und Störsignale empfangen.

Hier ein [http://picasaweb.google.de/lh/photo/7xU12-9CwCJUXh5XCC7LsQ?authkey=Gv1sRgCI3H2aul1-TmNg&feat=directlink Beispielaufbau] auf einem Steckboard.

====LUNA-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit-Mode mit dem internen [http://avr.myluna.de/doku.php?id=de:lcd LCD-Interface] von [http://avr.myluna.de LunaAVR]. Die einzelnen Pins müssen nicht am gleichen Port betrieben werden. Das Beispiel zeigt zusätzlich das Setzen und Verwenden von selbst erstellten Zeichen auf dem Display.
<pre>
'***************************************************************************
' Title : lcd example (internal interface)
' Last updated: 24.08.2012
' Target : LCD HD44780 ?x2 (16x2, 20x2, ..)
' Compiler : LunaAVR 2012.r7.beta build 3390 or newer
'***************************************************************************

const F_CPU = 16000000
avr.device = attiny2313
avr.clock = F_CPU
avr.stack = 16

dim i as byte

' Die Signale können an *beliebigen* Port-Pins des Controllers
' angeschlossen werden. Sie müssen *nicht* einer Portgruppe
' angehören (PortA, PortB, ..).
lcd.PinDB4 = portb.0
lcd.PinDB5 = portb.1
lcd.PinDB6 = portb.2
lcd.PinDB7 = portb.3
lcd.PinEN = portb.4
lcd.PinRS = portb.5

'Initialisierung durchführen
lcd.init
'Cursor einschalten und blinken lassen
lcd.cursor.enable
lcd.cursor.blink.enable
delay()
delay()
delay()

'blinken abschalten (deaktiviert auch den Cursor, Herstellerabhängig)
lcd.cursor.blink.disable
lcd.cursor.enable

'Einzelnes Zeichen ausgeben "A"
lcd.char 65
delay()

'Cursor sichtbar versetzen
for i=0 to 3
delay()
lcd.cursor.right
next
'Formatierte Zahlen ausgeben "00" bis "99" (zur Vermeidung von str() bei kleineren Controllern)
lcd.number 23
delay()
lcd.char asc(":")
delay()
lcd.cursor.set 1,9
lcd.number 1
delay()

lcd.DefChar smily,0 ' Eigenes Sonderzeichen definieren (0-7 möglich)
lcd.DefChar heart,1 ' Eigenes Sonderzeichen definieren (0-7 möglich)

lcd.cursor.set 2,1 ' Cursor positionieren
lcd.textd "Hallo Lcd "+chr(0)+chr(1) ' Text und eigenes Sonderzeichen ausgeben
delay()
delay()

'Gesamten Anzeigebereich verschieben
for i=0 to 3
lcd.screen.left
delay()
next
delay()
for i=0 to 3
lcd.screen.right
delay()
next

'Ende des Beispiels
do
loop

' Erstellt mit Lcd Zeicheneditor in der LunaIDE
data smily
.db &b00000
.db &b01010
.db &b00000
.db &b00100
.db &b10001
.db &b01110
.db &b00000
.db &b00000
enddata

data heart
.db &b00000
.db &b00000
.db &b01010
.db &b11111
.db &b11111
.db &b01110
.db &b00100
.db &b00000
enddata

procedure delay()
waitms 250
endproc
</pre>

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode benötigt einer spezielle LCD Bibliothek, die 'lcd4busy.lib'. Leider müssen bei der Verwendung dieser Bibliothek alle Pins des LCD Modul an den selben Prozessor Port angeschlossen werden.
<pre>
$lib "lcd4busy.lib" 'ersetzt die Standard LCD Bibliothek
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
Const _lcdport = Portc
Const _lcdddr = Ddrc
Const _lcdin = Pinc
Const _lcd_e = 1
Const _lcd_rw = 2
Const _lcd_rs = 3

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
/**
* @name Definitions for 4-bit IO mode
* Change LCD_PORT if you want to use a different port for the LCD pins.
*
* The four LCD data lines and the three control lines RS, RW, E can be on the
* same port or on different ports.
* Change LCD_RS_PORT, LCD_RW_PORT, LCD_E_PORT if you want the control lines on
* different ports.
*
* Normally the four data lines should be mapped to bit 0..3 on one port, but it
* is possible to connect these data lines in different order or even on different
* ports by adapting the LCD_DATAx_PORT and LCD_DATAx_PIN definitions.
*
*/
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 4 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 5 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 6 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 7 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 3 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 2 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 1 /**< pin for Enable line */
...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung ohne Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 6 Prozessor Ports benötigt. Die R/W Leitung des Displays kann man dabei einfach auf GND legen, dann ist aber keine Busy-Bit Abfrage möglich.

[[Bild:lcdmodul_4bit_schem.png|center|thumb|600px|4-Bit Ansteuerung]]

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode.
<pre>
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
' Im I/O Mode wird jeder Prozessor Pin einzeln angegeben
Config Lcdpin = Pin , Db4 = Portc.0 , Db5 = Portc.1 , Db6 = Portc.2 , Db7 = Portc.3 , E = Portc.5 , Rs = Portc.4

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über Porterweiterung===

Mit einem Porterweiterungs Baustein wie dem 74HC595 lassen sich weitere Prozessor-Ports einsparen. Diese Lösung kommt mit 4 Prozessor Ports aus, läßt man die Abfrage des Busy-Bits (PC5) weg, sogar nur mit 3 Prozessor Ports. Trotzdem wird das Display im 8-Bit Mode betrieben.

[[Bild:lcdmodul_portexp_schem.png|center|thumb|600px|Ansteuerung über Porterweiterung]]

====BASCOM-AVR Programm====

Das BASCOM Programm für diese Ansteuerung ist nicht ganz so einfach, da es nicht von der BASCOM Library unterstützt wird. Die Routinen zum Ansprechen des Displays muß man selbst coden.

<pre>

TODO....

</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über I²C===

Nur 2 Prozessor Ports benötigt man bei der I²C-Ansteuerung. Dazu wird als I²C Porterweiterungs IC der PCF8574P benötigt. Ein Projekt mit Schaltplan und Layout dazu gibts im Artikel [http://www.rn-wissen.de/index.php/LCD_an_I2C_Huckepack_auf_RN-Miniplatine LCD an I2C Huckepack auf RN-Miniplatine].

[[Bild:lcdmodul_i2c_schem.png|center|thumb|600px|I²C-Ansteuerung]]

====BASCOM-AVR Programm====
Diese Ansteuerung basiert auf der Application Note AN#118 von MCS electronics. Dazu gibt es auch eine fertige Library zu BASCOM-AVR, die die Standard LCD Library ersetzt. Dadurch können die gleichen Befehle zur Ansteuerung verwendet werden wie bei der Standard LCD Library. Das BASCOM-AVR Programm, um das LCD-Modul über I²C anzusprechen, sieht dann so aus.
<pre>
$lib "Lcd_i2c.lib" 'ersetzt die Standard LCD Library
$regfile = "m32def.dat"
$crystal = 16000000

Const Pcf8574_lcd = &H40 'I2C Adresse
Config Scl = Portc.0 'I2C SCL Pin
Config Sda = Portc.1 'I2C SDA Pin
Dim _lcd_e As Byte
_lcd_e = 128 'LCD im 4-Bit Mode betreiben

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

====Ansteuerung über I²C mit PCA9555====

Eine weitere Möglichkeit der I²C-Ansteuerung besteht in der Nutzug des PCA9555 (16 Bit I²C I/O Expander) von Philips. Das Display wird im 8-Bit Mode betrieben.

[[Bild:Lcdmodul_i2c_pca9555_schem.png|center|thumb|600px|I²C-Ansteuerung mit PCA9555 8-Bit mit Busy]]

====AVR-GCC Programm mit PCA9555====

Programm ist hardwarenah umgesetzt und mit einem ATMEGA8 mit 2x16 Displaytyp getestet. Verwendet wird die twi-library von Peter Fleury. Der Programmentwurf beinhaltet keine Prüfung auf das Zeilenende bzw. Zeilenvorschub. Die Schreibadresse im DD-RAM des Displays wird fortlaufend beschrieben. Die Anzeigeadressen DD-RAM des getesteten Displays liegen bei 00h..0Fh erste Zeile und 40h..4Fh zweite Zeile.

<pre>
...
#include <avr/io.h>
#include "twimaster.c" //TWI-Routinen von Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury
#include "pausems.c" //Einbindung einfache Pausenfunktion für ca. 1 ms

#define PCA9555 0x40 //device address of Portexpander PCA9555

//********************************************************************
// Funktion fragt Buys-Flag des Displays ab ob Bereitschaft
// für die Datenübernahme gegeben ist
//********************************************************************

void WaitForBusy (void)
{
//wenn notwendig, dann umsetzen
}

//********************************************************************
// Funktion führt Erstinitialisierung des Display durch
// laut Herstellerempfehlung + Initialisierung Grundfunktion
//********************************************************************

void InitDisplay (void)
{
i2c_init(); // init I2C interface
i2c_start (PCA9555+I2C_WRITE); // set device address and write mode
i2c_write (0b00000110); //Command Byte PCA9555
i2c_write (0b00000000); //PCA9555 Reg6 als Ausgang setzen
i2c_write (0b00000000); //PCA9555 Reg7 als Ausgang setzen
i2c_stop ();

i2c_start_wait (PCA9555+I2C_WRITE); //Schreibzugriff 1 auf Display
i2c_write (0b00000011); //Command Byte PCA9555 Register 3

i2c_write (0b00000001); //PCA9555 Reg3 - 001h (E-Bit)
i2c_write (0b00110000); //PCA9555 Reg2 - Systemset 30h
i2c_write (0b00000000); //PCA9555 Reg3 - 000h E-Bit auf Null zur Übernahme
pause_ms (10);

i2c_write (0b00000001); //PCA9555 Reg3 - 001h
i2c_write (0b00110000); //PCA9555 Reg2 - Systemset 30h
i2c_write (0b00000000); //PCA9555 Reg3 - 000h E-Bit auf Null zur Übernahme
pause_ms (3);

i2c_write (0b00000001); //PCA9555 Reg3 - 001h
i2c_write (0b00110000); //PCA9555 Reg2 - Systemset 30h
i2c_write (0b00000000); //PCA9555 Reg3 - 000h E-Bit auf Null zur Übernahme
pause_ms (3);
i2c_stop (); //ab hier Display bereit zum Schreiben

// WaitForBusy(); wenn notwendig

i2c_start (PCA9555+I2C_WRITE);
i2c_write(0b00000011);
i2c_write(0b00000001);
i2c_write(0b00111000); //PCA9555 Reg2 - Systemset 38h (8 Bit Modus, 2 Zeilen, 5x8 Punkte)
i2c_write(0b00000000); //PCA9555 Reg3 - 000h E-Bit auf Null zur Übernahme
i2c_stop ();
}

//********************************************************************
// Funktion schaltet Display ein
//********************************************************************

void DisplayOnOff (uint8_t conf)
{
// WaitForBusy(); wenn notwendig
i2c_start (PCA9555+I2C_WRITE); //set device address and write mode
i2c_write(0b00000011); //Command Byte PCA9555
i2c_write(0b00000001); //PCA9555 Reg3 - 001h
i2c_write(conf); //PCA9555 Reg2 - B3=Display e/a + B2=Cursor e/a + B1=blink. Cursor e/a
i2c_write(0b00000000); //PCA9555 Reg3 - 000h E-Bit auf Null zur Übernahme
i2c_stop ();
}

//********************************************************************
// Funktion löscht Displayinhalt
//********************************************************************

void ClearDisplay (void)
{
// WaitForBusy(); wenn notwendig
i2c_start (PCA9555+I2C_WRITE); //set device address and write mode
i2c_write(0b00000011); //Command Byte PCA9555
i2c_write(0b00000001); //PCA9555 Reg3 - 001h
i2c_write(0b00000001); //PCA9555 Reg2 - Display löschen
i2c_write(0b00000000); //PCA9555 Reg3 - 000h E-Bit auf Null zur Übernahme
i2c_stop ();
}

//********************************************************************
// Funktion setzt Display-Modus
//********************************************************************

void SetEntryMode (void)
{
// WaitForBusy(); wenn notwendig
i2c_start (PCA9555+I2C_WRITE); //set device address and write mode
i2c_write(0b00000011); //Command Byte PCA9555
i2c_write(0b00000001); //PCA9555 Reg3 - 001h
i2c_write(0b00000110); //PCA9555 Reg2 - DDRAM inkrementieren, Display schieben aus
i2c_write(0b00000000); //PCA9555 Reg3 - 000h E-Bit
i2c_stop ();
}

//********************************************************************
// Funktion schreibt ein Byte Daten ins Display
//********************************************************************

void WriteDisplayChar (uint8_t data)
{
// WaitForBusy(); wenn notwendig
i2c_start (PCA9555+I2C_WRITE); //set device address and write mode
i2c_write(0b00000011); //Command Byte PCA9555
i2c_write(0b00000101);
i2c_write(data); //PCA9555 Reg2 - Daten ins Display schreiben
i2c_write(0b00000100); //PCA9555 Reg3 - 000h E-Bit
i2c_stop ();
}

//********************************************************************
// Funktion setzt Cursorposition
//********************************************************************

void SetCorsorXY (uint8_t data1, uint8_t data2)
{
if ((data1 < 16) & (data2 < 2))
{
if (data2 < 1)
data2 = 0x00;
else
data2 = 0x40;
// WaitForBusy(); wenn notwendig
i2c_start (PCA9555+I2C_WRITE); //set device address and write mode
i2c_write(0b00000011); //Command Byte PCA9555
i2c_write(0b00000001); //PCA9555 Reg3 - 001h
i2c_write(0b10000000 | data1 | data2); //PCA9555 Reg2 - Position setzen
i2c_write(0b00000000); //PCA9555 Reg3 - 000h E-Bit
i2c_stop ();
}
}

//********************************************************************
// Funktion schreibt Text-Daten (nullterminierter String) ins Display
//********************************************************************

void WriteDisplayText (const char *data)
{
do
{
if (*data != 0)
WriteDisplayChar (*data);
}
while (*data++);
}

//********************************************************************
// Funktion initialisiert alle wichtigen Funktionen auf einmal
//********************************************************************

void InitDisplayAll(void)
{
InitDisplay();
DisplayOnOff(0b00001100);
ClearDisplay();
SetEntryMode();
}

//********************************************************************
// Hauptprogramm - 2x Ausgabe "Hallo Welt!"
//********************************************************************

int main(void)
{
InitDisplay();
DisplayOnOff(0b00001100); //PCA9555 Reg2 - Display ein + Cursor ein + blink. Cursor aus
ClearDisplay();
SetEntryMode();

//oder: InitDisplayAll();

SetCorsorXY(2,0);
WriteDisplayTextData("Hallo Welt!");
SetCorsorXY(5,1);
WriteDisplayTextData("Hallo Welt!");
}
</pre>

===Ansteuerung über RS232===

Ebenfalls nur 2 Pins zur Ansteuerung benötigt die Lösung. Allerdings ist die serielle Schnittstelle bei Mikrocontrollern oft schon mit anderen Aufgaben belegt. Deshalb befindet sich meistens noch zusätzlich eine I²C-Bus Schnittstelle zur Ansteuerung auf dem Modul.

==Graphik-Displays==

In Mikrocontroller-Anwendungen werden seit neuestem, einhergehend mit der größeren Verbreitung von Controllern mit mehr Speicherplatz, auch immer öfter Grafik-Displays und Farb-TFTs eingesetzt. Der Aufwand an Software und Hardware ist hier allerdings um einiges höher (jedes Pixel ist einzeln anzusteuern).

==LCD über RN LCD Adapter Std an RN-Control==

Hierbei handelt es sich um eine Beispielansteuerung eines LCD über RN LCD Adapter Std an RN-Control in C.

Komfortabel lässt sich ein LCD in C mit der LCD Library von Peter Fleury ansteuern (LCD Controller HD44780 & KS0073).
Die Library selbst sowie deren Online Dokumentation und weiterführende informationen sind von [http://jump.to/fleury Peter Fleury's Home Page]zu entnehmen.

Im hier aufgeführten Beispiel wird ein Crystalfontz 20x4 LCD verwendet (CFAH2004A-YYH-JPE).

Pinbelegung nach [http://www.crystalfontz.com/product/CFAH2004AYYHJPE.html Datenblatt]
<pre>
Pin No. Symbol Level Description
1 VSS 0V Ground
2 VDD 5.0V Supply Voltage for logic
3 VO (Variable) Operating voltage for LCD
4 RS H/L H: DATA, L: Instruction code
5 R/W H/L H: Read(MPU?Module) L: Write(MPU?Module)
6 E H,H?L Chip enable signal
7 DB0 H/L Data bit 0
8 DB1 H/L Data bit 1
9 DB2 H/L Data bit 2
10 DB3 H/L Data bit 3
11 DB4 H/L Data bit 4
12 DB5 H/L Data bit 5
13 DB6 H/L Data bit 6
14 DB7 H/L Data bit 7
15 A - LED +
16 K - LED -
</pre>

Pinbelegung des LCD Adapters nach [http://www.robotikhardware.de/download/rn_LCD_adapter_std.pdf Datenblatt]
<pre>
Pin 1 LCD DB7
Pin 2 LCD DB6
Pin 3 LCD DB5
Pin 4 LCD DB4
Pin 5 Licht ein/aus per Port (da EN2 hier nicht benötigt wird)
Pin 6 LCD EN
Pin 7 LCD R/W
Pin 8 LCD RS
Pin 9 GND LCD GND und Licht Kathode
Pin 10 +5V LCD VCC und Licht Anode
</pre>

Berücksichtigt man die folgenden Tatsachen:
* ATMega32 auf dem RN-Control stellt kein "external memory interface" zur Verfügung, daher ist ohne Weiteres keine 8-Bit Ansteuerung des LCD möglich. Es wird 4-Bit I/O verwendet
* die Zählweise der Pins beginnt in lcd.h bei 0, nicht bei 1
* der LCD Adapter ist mit PORTC des RN Control verbunden (Vorteil: an den LEDs von PORTC kann erkannt werden, ob überhaupt Daten an das LCD gesendet werden)
* der Controler im LCD ist ein SPLC780D, welcher mit dem in lcd.h genutzten HD44780 kompatibel ist
müssen die nachfolgenden Zeilen in lcd.h entsprechend angepasst werden.

<pre>
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */
</pre>
Die DDRAM Adressen der einzelnen Zeilen sind im Datenblatt hinterlegt. Zeile 1 und 3 sowie 2 und 4 bilden intern je eine Zeile.
Der manuelle Zeilenumbruch am Ende des Codeblocks bleibt Geschmacksache.
<pre>
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 1 /**< 0: no wrap, 1: wrap at end of visibile line */
</pre>
4-Bit I/O Mode wird verwendet.
<pre>
#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
</pre>
Wie oben angedeutet werden die Pins von 0 an gezählt. "LCD_DATA3_PIN 0" ist somit Pin 1 des LCD Adapters.
<pre>
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 3 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 2 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 1 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 0 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 7 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 6 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 5 /**< pin for Enable line */
</pre>

Testprogramm:
<pre>
#include <stdlib.h>
#include <avr/io.h>
#include <lcd.c>

int main(void)
{

lcd_init(LCD_DISP_ON_CURSOR_BLINK);
lcd_clrscr();
lcd_puts("test");

return 0;
}
</pre>

==Siehe auch==

* [[Bascom_und_LCD%27s|BASCOM und LCD's]]
* [[Portexpander_am_AVR|Portexpander am AVR]]
* [[AVR]]
* [[I2C|I²C-Bus]]
* [[LCD an I2C Huckepack auf RN-Miniplatine]]

==Weblinks==

* [http://www.mcselec.com/index.php?option=com_content&task=view&id=82&Itemid=57 MCS electronics AN #118] - I²C LCD and Keyboard library
* [http://jump.to/fleury Peter Fleury's Homepage] - Interfacing a HD44780 Based LCD to an AVR, LCD library for HD44870 based LCD's

==Autore(en)==

[[Benutzer:m_a_r_v_i_n|m a r v i n]]

[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Quellcode_Bascom]]
[[Kategorie:Quellcode_C]]

LunaAVR

2012-04-16T20:44:44Z

Rgf:

LunaAVR

2012-04-16T20:41:08Z

Rgf:

=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===
* [http://avr.myluna.de]

===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()
** 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.

<pre>
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
|
+ ..
</pre>
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==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Testversion]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

'''Beispielsource: loops.luna'''
<pre>
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
</pre>

'''Beispielsource: Blinksteuerung/Blinkmodul Auto & Motorrad'''
<pre>
'--------------------------------------------------------------
' 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
</pre>

LunaAVR

2011-12-01T17:10:22Z

Rgf:

=LunaAVR=

LunaAVR ist eine neue objektbasierte Programmiersprache für [http://www.atmel.com Atmel® AVR® Mikrocontroller], deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen wie [http://www.realsoftware.com RealStudio®] oder [http://www.java.com 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 [http://winavr.sourceforge.net|C/C++]. 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===
* [http://avr.myluna.de Editor] (speziell angepasster Editor, Basis für IDE)
* [http://avr.myluna.de 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 [http://de.wikipedia.org/wiki/Atmel_AVR AVR Mikrocontrollern] wird der [http://de.wikipedia.org/wiki/Maschinencode 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.
<pre>
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
|
+ ..
</pre>
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==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Testversion]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

'''Beispielsource: loops.luna'''
<pre>
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
</pre>

'''Beispielsource: Blinksteuerung/Blinkmodul Auto & Motorrad'''
<pre>
'--------------------------------------------------------------
' 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
</pre>

LunaAVR

2011-12-01T17:09:12Z

Rgf:

=LunaAVR=

LunaAVR ist eine neue objektbasierte Programmiersprache für [http://www.atmel.com Atmel® AVR® Mikrocontroller], deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen wie [http://www.realsoftware.com RealStudio®] oder [http://www.java.com 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 [http://winavr.sourceforge.net|C/C++]. 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)
* [http://avr.myluna.de 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 [http://de.wikipedia.org/wiki/Atmel_AVR AVR Mikrocontrollern] wird der [http://de.wikipedia.org/wiki/Maschinencode 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.
<pre>
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
|
+ ..
</pre>
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==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Testversion]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: helloworld.luna'''
<pre>
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
</pre>

'''Beispielsource: loops.luna'''
<pre>
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
</pre>

'''Beispielsource: Blinksteuerung/Blinkmodul Auto & Motorrad'''
<pre>
'--------------------------------------------------------------
' 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
</pre>

LunaAVR

2011-11-14T23:11:37Z

Rgf: /* Weblinks */

=LunaAVR=

LunaAVR ist eine neue objektbasierte Programmiersprache für [http://www.atmel.com Atmel® AVR® Mikrocontroller], deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen wie [http://www.realsoftware.com RealStudio®] oder [http://www.java.com 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 [http://winavr.sourceforge.net|C/C++]. 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.1.64_alpha (derzeit noch nicht veröffentlicht)

====ausstehend====
* IDE
* Assembler

===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 [http://de.wikipedia.org/wiki/Atmel_AVR AVR Mikrocontrollern] wird der [http://de.wikipedia.org/wiki/Maschinencode 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.
<pre>
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
|
+ ..
</pre>
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==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]
* [http://avr.myluna.de/doku.php?id=de:download Download aktuelle Testversion]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: Terminal'''
<pre>
avr.device = attiny2313
avr.clock = 20000000 ' Quarzfrequenz
avr.stack = 32 ' Bytes Programmstack (Vorgabe: 16)
uart.baud = 19200 ' Baudrate
uart.Recv.Enable
uart.Send.Enable

dim chars as string

print 27 ; "[21" ; 27 ; "[2J" ; chr(27) ; "c" ; 27 ; "[?6l"; ' Terminal setup (VT100 clear)

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'''
<pre>
avr.device = atmega32
avr.clock = 20000000 ' Quarzfrequenz
avr.stack = 32 ' Bytes Programmstack (Vorgabe: 16)
uart.baud = 19200 ' Baudrate
uart.Recv.Enable
uart.Send.Enable

dim chars as string
dim m,m1 as memory

print 27 ; "[21" ; 27 ; "[2J" ; chr(27) ; "c" ; 27 ; "[?6l"; ' Terminal setup

Do
inpstr " test > ",chars
call ausgabe(chars)
select case chars
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 "s = "+s
print "chars = "+chars
endproc

Exception OutOfSpaceMemory
print "*** Exception OutOfSpaceMemory ***"
EndException
Exception OutOfBoundsMemory
print "*** Exception OutOfBoundsMemory ***"
EndException
Exception NilObjectException
print "*** Exception NilObjectException ***"
EndException

</pre>

'''Beispielsource: Blinksteuerung/Blinkmodul Auto & Motorrad'''
<pre>
'--------------------------------------------------------------
' 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
</pre>

LunaAVR

2011-11-11T22:09:21Z

Rgf:

=LunaAVR=

LunaAVR ist eine neue objektbasierte Programmiersprache für [http://www.atmel.com Atmel® AVR® Mikrocontroller], deren Aufbau und Syntax sich an aktuellen Entwicklungswerkzeugen wie [http://www.realsoftware.com RealStudio®] oder [http://www.java.com 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 [http://winavr.sourceforge.net|C/C++]. 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.1.64_alpha (derzeit noch nicht veröffentlicht)

====ausstehend====
* IDE
* Assembler

===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 [http://de.wikipedia.org/wiki/Atmel_AVR AVR Mikrocontrollern] wird der [http://de.wikipedia.org/wiki/Maschinencode 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.
<pre>
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
|
+ ..
</pre>
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==
* [http://avr.myluna.de Offizielle Dokumentationsseite vom LunaAVR-Projekt]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode LunaAVR]]

'''BeispielSource: Terminal'''
<pre>
avr.device = attiny2313
avr.clock = 20000000 ' Quarzfrequenz
avr.stack = 32 ' Bytes Programmstack (Vorgabe: 16)
uart.baud = 19200 ' Baudrate
uart.Recv.Enable
uart.Send.Enable

dim chars as string

print 27 ; "[21" ; 27 ; "[2J" ; chr(27) ; "c" ; 27 ; "[?6l"; ' Terminal setup (VT100 clear)

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'''
<pre>
avr.device = atmega32
avr.clock = 20000000 ' Quarzfrequenz
avr.stack = 32 ' Bytes Programmstack (Vorgabe: 16)
uart.baud = 19200 ' Baudrate
uart.Recv.Enable
uart.Send.Enable

dim chars as string
dim m,m1 as memory

print 27 ; "[21" ; 27 ; "[2J" ; chr(27) ; "c" ; 27 ; "[?6l"; ' Terminal setup

Do
inpstr " test > ",chars
call ausgabe(chars)
select case chars
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 "s = "+s
print "chars = "+chars
endproc

Exception OutOfSpaceMemory
print "*** Exception OutOfSpaceMemory ***"
EndException
Exception OutOfBoundsMemory
print "*** Exception OutOfBoundsMemory ***"
EndException
Exception NilObjectException
print "*** Exception NilObjectException ***"
EndException

</pre>

'''Beispielsource: Blinksteuerung/Blinkmodul Auto & Motorrad'''
<pre>
'--------------------------------------------------------------
' 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
</pre>

LunaAVR

2011-11-05T21:07:55Z

Rgf:

LunaAVR

2011-11-05T21:05:48Z

Rgf: