Mikrocontroller.net - Benutzerbeiträge [de]

NIC

2017-06-20T13:35:27Z

Klause: Vorhandene Alternativen würden aufgezeigt

Von '''Frank M. ([http://www.mikrocontroller.net/user/show/ukw ukw])'''

'''Dies ist eine vorläufige und höchst unvollständige Beschreibung einer Software, die noch in Entwicklung, d.h. im Alpha-Stadium ist. Ein entsprechender Thread über NIC wird im Forum "Projekte & Code" eröffnet, sobald eine Beta-Version des NIC-Interpreters verfügbar ist. Details können sich durchaus noch ändern, daher ist diese Dokumentation zur Zeit noch rein als PRELIMINARY zu sehen.'''

NIC ist eine einfache strukturierte Programmiersprache, welche speziell für die Mikrocontroller-Familie STM32 entwickelt wurde. Da der NIC-Interpreter in C geschrieben ist, kann dieser auch auf andere 32-Bit-Mikrocontroller portiert werden.

Ebenso sind NIC-Programme auch unter Linux und Windows lauffähig, wobei dies eher der Entwicklung und des Debuggings des NIC-Interpreters dient. Ein in NIC geschriebenes Programm wird zunächst von dem NIC-Compiler "nicc" auf dem Host in einen Metacode übersetzt, welcher durch den NIC-Interpreter "nici" auf dem Mikrocontroller-System sehr effizient abgearbeitet werden kann. Die üblichen Übersetzungsdauern liegen meist unter einer Sekunde, die Geschwindigkeit, mit der die Befehle dann von nici ausgeführt werden, liegen bei ca. 100.000 bis 250.000 Befehlen pro Sekunde - je nach verwendetem STM32. Als Host zum Compilieren von NIC-Programmen dient zur Zeit ein PC-System mit Linux oder Windows, später wird dies auch ein vorgeschalteter µC wie ein ESP8266 sein, der gleichzeitig ein Filesystem (SPIFFS) bietet, um die Compilate zu speichern und damit permanent vorzuhalten. Zudem erweitert dieser dann das NIC-Laufzeitsystem um Netzwerkfunktionalitäten.

Motivationen zur Entwicklung eines solchen Interpreters gibt es einige: Zum einen wird Einsteigern ein sehr einfaches System geboten, sich in die Welt von 32-Bit-Mikrocontrollern einzuarbeiten, zum anderen schrecken viele Umsteiger von 8-Bit-Systemen auf 32-Bit-Systeme vor der Komplexität der 32-Bitter zurück. Genau diese Komplexität wird in die NIC-Bibliotheksfunktionen verlegt, so dass man sich als NIC-Programmierer nicht damit im Detail befassen muss. Ein erfahrener Programmierer jedoch kann die NIC-Laufzeitbibliothek durch eigene C-Module erweitern, um diese dann im NIC-Programm unter Nutzung der NIC-API zu nutzen. So ist es dann zum Beispiel auf einfache Art und Weise möglich, eine Kette von WS2812-LEDs per DMA zu steuern, ohne sich im Detail mit der Programmierung einer DMA auseinandersetzen zu müssen.

NIC als strukturierte Programmiersprache ähnelt in manchen Teilen C, PHP, Pascal oder auch Basic. Datentypen müssen jedoch zum Beispiel im Gegensatz zu PHP stets angegeben werden. Trotzdem ist stets eine implizite Typumwandlung (zum Beispiel von Integer-Werten in Strings oder umgekehrt) möglich, die klaren Regeln unterworfen ist. Casts wie in C sind dabei nicht notwendig.

Natürlich ist NIC als Interpretersprache nicht so schnell wie ein C-Programm, kann sich aber trotzdem bezüglich Ausführungsgeschwindigkeit durchaus sehen lassen. Ein erfahrener C-Programmierer kann zeitkritische Programmteile in C erstellen, um sie dann als NIC-Bibliotheksfunktionen komfortabel zu nutzen. Der NIC-Interpreter ist ca. doppelt so schnell wie ein adäquates PHP-Programm und meist 3-5 mal schneller als vergleichbare Python-Programme, siehe auch [[NIC#Benchmarks|Benchmarks]].

Wozu einen schnellen ARM erst programmier-freundlich abbremsen wenn man dann gleich einen AVR verwenden kann! Die Einarbeitung in ARM und diese Xte neue Programmier-Sprache ist damit auch gespart!

Wozu einen schnellen ARM erst programmier-freundlich abbremsen wenn man dann gleich einen AVR verwenden kann! Die Einarbeitung in ARM und eine Xte neue Programmier-Sprache ist damit auch gespart!

= Compiler nicc =

Der Compiler nicc ist für Windows und Linux verfügbar.

=== Aufruf unter Windows ===

Wozu einen schnellen ARM erst programmier-freundlich abbremsen wenn man dann gleich einen AVR verwenden kann! Die Einarbeitung in ARM und eine Xte neue Programmier-Sprache ist damit auch gespart!

nicc [-v] [-u COMx] datei.nic

Die in eckigen Klammern angegebenen Parameter sind optional.

Optionen:
-v : Verbose, gibt Statistiken, wie zum Beispiel Optimierungen von Ausdrücken aus
-u COMx: Upload der compilierten Datei über die seriellen Schnittstelle COMx

Der NIC-Quelltext wird dabei in einen optimierten, maschinenunabhängigen Objekt-Code übersetzt. Das Kompilat legt nicc in der Datei datei.nico ab, welche (zur Zeit noch) eine ASCII-Datei ist. Gibt man per Upload-Parameter die serielle Schnittstelle an, wird das Kompilat direkt auf den µC geladen. Der Interpreter legt den Objekt-Code dann als binäre Datenstrukturen im RAM ab, um diese dann effizient abzuarbeiten.

Beispiel:
nicc -u com5 lauflicht1.nic

=== Aufruf unter Linux ===
nicc [-v] datei.nic

Hier fehlt (noch) die Upload-Funktion. Dafür ist es aber möglich, das Kompilat direkt unter Linux zu starten, siehe nächstes [[NIC#Interpreter_nici|Kapitel]].

=== Optimierungen ===

Der NIC-Compiler bringt sämtliche arithmetische Ausdrücke wie "3 * 4 + x + 1 << 6" nach den Prioritätenregeln (Punkt- vor Strichrechnung usw.) in die UPN-Notation - auch Postfix genannt. Dabei werden konstante Teilausdrücke wie "3 * 4" direkt durch das Ergebnis "12" zur Compilezeit ersetzt. Dadurch muss der Interpreter sich nicht mehr um solche Regeln kümmern, sondern braucht nur noch einen Stack abzuarbeiten, auf dem alle Operanden und Operatoren schon fix und fertig in der richtigen Reihenfolge vorliegen.

Desweiteren werden zur Compilezeit sämtliche Sprungadressen, die durch Schleifen wie loop, repeat, for, while, break und continue entstehen, vorher ausgerechnet, so dass der Interpreter je nach Bedingung nur noch Sprungadressen laden muss. Desweiteren sind bei Aufruf von Bibliotheksfunktion (wie zum Beispiel [[NIC#Bibliothek_gpio|GPIO]]) die zu übergebenden Daten direkt zum Bedienen der API für Bibliotheksfunktionen vorbereitet. Diese können damit schnell und effektiv bedient werden.

Häufig vorkommende Konstrukte wie "n = n + 1" werden in spezielle Increment- und Decrement-Befehle gewandelt, die vom NIC-Interpreter ohne Evaluierung des arithmetischen Ausdrucks rechts vom Gleichheitszeichen direkt intern auf den Variableninhalt wirken.

= Interpreter nici =

Der NIC-Interpreter nici wird im Flash des STM32 installiert (HEX-Datei). Dieser wartet dann auf dem UARTx auf das übersetzte NIC-Programm, um es direkt nach dem Upload auszuführen.

Für Entwickler:

Man kann den Interpreter unter Linux und Windows direkt von der Kommandozeile aus starten.

Übersetzen:
nicc datei.nic
Ausführen:
nici datei.nico

STM32-spezifische Funktionen wie gpio.toggle() laufen dabei auf eine Stub-Funktion geleitet, welche die Laufzeitparameter als Info ausgeben. Alle anderen Funktionen werden jedoch ordnungsgemäß ausgeführt. Trotzdem ist der Interpreter nicc unter Linux bzw. Windows eher zur Weiterentwicklung und Debugging des Compilers und des Interpreters gedacht und nicht dafür, Programme für Linux/Windows in der Programmiersprache NIC zu entwickeln - auch wenn das so möglich wäre.

= main-Funktion =

Jedes NIC-Programm muss eine Funktion namens "main()" definieren. Das ist der Startpunkt eines jeden NIC-Programms. Die Funktion main() liefert stets keinen Rückgabewert zurück und muss daher immer mit dem Funktionstyp "void" angegeben werden. Außerdem erhält sie keine Parameter, daher ist der Inhalt zwischen den Klammern "(" und ")" leer.

Damit ergibt sich als Funktionsrumpf:

<syntaxhighlight lang=pas>
function void main ()
...
endfunction
</syntaxhighlight>

== Hello World ==

Ale Einstiegsprogramm einer Programmiersprache wird oft ein einfaches Hello-World-Programm angegeben, welches die Zeichenkette "Hello, World" ausgibt. Für Mikrocontroller jedoch ist es oft das Blinken einer an den Mikrocontroller angeschlossenen LED.

Das folgende NIC-Programm lässt die LED auf einem Nucleo-Board blinken:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT)
loop
gpio.set (GPIOA, 5)
time.delay (500)
gpio.reset (GPIOA, 5)
time.delay (500)
endloop
endfunction
</syntaxhighlight>

Die LED wird dabei für 500msec ein- und dann für 500msec wieder abgeschaltet. Durch die Kontrollstruktur "loop" läuft das Programm in einer Endlosschleife und kann nur durch Drücken der RESET-Taste gestoppt werden. Hier werden drei interne Bibliotheksfunktionen der Familie '''[[NIC#Bibliothek_gpio|gpio]]''' aufgerufen, nämlich [[NIC#gpio.init_.28.29|gpio.init()]], [[NIC#gpio.set_.28.29|gpio.set()]] und [[NIC#gpio.reset_.28.29|gpio.reset()]]. Die erste Funktion [[NIC#gpio.init_.28.29|gpio.init()]] initialisiert den Pin A5 des STM32 als Ausgabe-Pin durch Angabe des Schlüsselwortes "OUTPUT", die Funktion [[NIC#gpio.set_.28.29|gpio.set()]] setzt dann den Pin auf HIGH-Pegel, die Funktion [[NIC#gpio.reset_.28.29|gpio.reset()]] wieder auf LOW-Pegel. Die Bibliotheksfunktion time.delay() lässt den Mikrocontroller eine bestimmte Anzahl von Millisekunden warten - hier 500msec.

Am Pin A5 ist bei den Nucleo-Boards eine board-interne grüne LED angeschlossen. Diese blinkt dann bei der Ausführung des Programms. Um die board-interne blaue LED eines STM32F103-Mini-Development-Boards anzusprechen, muss der Port GPIOA durch GPIOC ersetzt und die Pinnummer auf 13 geändert werden, denn hier ist die LED an Pin C13 angeschlossen.

Durch Anwendung der Funktion [[NIC#gpio.toggle_.28.29|gpio.toggle()]] kann der Code noch vereinfacht werden:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT)
loop
gpio.toggle (GPIOA, 5)
time.delay (500)
endloop
endfunction
</syntaxhighlight>

Hier wechselt die Funktion [[NIC#gpio.toggle_.28.29|gpio.toggle()]] automatisch den jeweiligen LOW- bzw. HIGH-Pegel und lässt die LED mit einer Frequenz von einem Hertz blinken.

Wie wir später noch sehen werden, kann das Blinken der LED auch timergesteuert ausgeführt werden. Dann macht der NIC-Interpreter das "nebenbei", d.h. wir haben in der Hauptschleife Zeit für andere Dinge.

Hier schon mal das Programm, erklärt wird es dann später unten (alarm-Funktionen):

<syntaxhighlight lang=pas>
function void blink ()
gpio.toggle (GPIOA, 5)
endfunction

function void main ()
gpio.init (GPIOA, 5, OUTPUT)
alarm.set (500, function.blink) // blink() alle 500msec automatisch aufrufen lassen

loop
// ... // Hier koennen nun komplett andere Aufgaben erledigt werden!
endloop
endfunction
</syntaxhighlight>

Wie schnell ist nun der NIC-Interpreter? Wir können nun durch Entfernen des delay-Aufrufs die LED mit maximaler Geschwindigkeit blinken lassen und dann die Zeiten messen:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103-Mini-Board: LED=C13
repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat
endfunction
</syntaxhighlight>

Die Endlosschleife '''[[NIC#loop|loop]]''' wurde hier durch ein '''[[NIC#repeat|repeat]]''' ersetzt. Hier können wir angeben, wie oft eine Schleife durchlaufen wird. In unserem Beispiel sind es 1.000.000 mal. Das Blinken selbst wird man aufgrund der Geschwindigkeit nicht mehr erkennen können, jedoch leuchtet die LED weiterhin deutlich sichtbar - bis das Programm nach einer Million Schleifendurchläufen beendet wird. Man wird dabei mit der Stoppuhr auf einem STM32F411RE-Nucleo-Board ungefähr 4 Sekunden messen.

Der Messvorgang geht aber auch genauer:

<syntaxhighlight lang=pas>
function void main ()
int start
int stop
int diff

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

stop = time.millis ()
diff = stop - start
console.println (diff)
endfunction
</syntaxhighlight>

Hier werden nun erstmals Variablen namens "start" und "stop" verwendet. Sie entsprechen der internen "Uhrzeit" des Mikrocontrollers seit dem letzten Boot in Millisekunden. Durch die Funktion [[NIC#time.millis_.28.29|time.millis()]] können wir jederzeit die interne Zeit des Mikrocontrollers abrufen und in einer Variablen speichern. Deshalb wird jemals einmal vor und nach dem Schleifendurchlauf die Zeit gestoppt. Die Differenz wird in der Variablen "diff" gespeichert und dann mittels der Funktion [[NIC#console.println_.28.29|console.println()]] in Millisekunden auf der Console ausgegeben. Die Console ist dabei die serielle UART-Schnittstelle, die bei jedem Nucleo on-board dabei ist. Bei einem STM32F103-Mini-Development-Board muss ein zusätzlicher UART-Adapter angeschlossen werden, siehe entsprechendes Kapitel weiter unten. Bei einem mit 100MHz getakteten STM32F411RE sind dies ca. 3900msec. Das Programm schafft also ungefähr 255.000 Schleifendurchläufe pro Sekunde. Bei einem mit 85MHz getakteten STM32F401RE sind es noch knapp 200.000 Schleifendurchläufe, beim STM32F103 mit 72MHz-Takt ca. 180.000 Durchläufe.

Das Programm kann aber noch stärker vereinfacht werden. Zunächst eliminieren wir die Variable "diff", indem wir die Differenz der Werte "stop" und "start" direkt der Funktion [[NIC#console.println_.28.29|console.println()]] übergeben:

<syntaxhighlight lang=pas>
function void main ()
int start
int stop

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

stop = time.millis ()
console.println (stop - start)
endfunction
</syntaxhighlight>

Also: Funktionen können nicht nur einfache Werte, sondern auch algebraische Ausdrücke direkt übergeben werden.

Aber es geht noch einfacher. Jetzt verzichten wir auch noch auf die Variable "stop":

<syntaxhighlight lang=pas>
function void main ()
int start

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

console.println (time.millis () - start)
endfunction
</syntaxhighlight>

Als Funktionsparameter können also auch Rückgabewerte anderer Funktionen oder noch komplexere Ausdrücke angegeben werden.

Der Vollständigkeit halber noch das Hello-World-Programm im klassischen Sinne:

<syntaxhighlight lang=pas>
function void main ()
console.println ("Hello, World!")
endfunction
</syntaxhighlight>

Das sieht jetzt - nachdem wir bereits eine LED auf mehrere Art und Weise haben blinken lassen - doch viel zu einfach aus ;-)

= Kommentare =

Kommentare werden durch einen doppelten Schrägstrich eingeleitet, also durch '//'. Alle danach aufgeführten Zeichen gelten als Kommentar und werden vom NIC-Compiler nicc ignoriert.

Beispiel:
<syntaxhighlight lang=pas>
gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
</syntaxhighlight>

= Datentypen =

Die Datentypen von Funktionen und Variablen müssen stets angegeben werden. Eine implizite Definition durch einfache Aufführung eines einer Funktion, eines Funktionsparameters oder einer Variablen wie in PHP oder Python ist nicht möglich.

Die Datentypen von Variablen und Funktionen sind Integer, Byte oder String, evtl. später auch noch "Float". Bei Funktionen ist zusätzlich der Datentyp "void" möglich, um anzugeben, dass die Funktion '''keinen''' Funktionswert zurückliefert.

* '''int''' - Datentyp Integer, Breite 32 Bit, vorzeichenbehaftet
* '''byte''' - Datentyp Byte, Breite 8 Bit, vorzeichenlos
* '''string''' - Datentyp Zeichenkette
* '''void''' - kein Returnwert (nur Funktionen)

Funktionen können als Rückgabewerte nicht nur die oben aufgeführten Typen zurückliefern, sondern auch vom Typ '''void''' sein, um anzuzeigen, dass sie '''keinen''' Rückgabewert liefern.

Beispiel:

<syntaxhighlight lang=pas>
function void errormessage (string message)
console.println ("error: " : message)
endfunction
</syntaxhighlight>

Bei allen anderen Datentypen muss eine Funktion einen Wert per return-Befehl zurückgeben.

= Konstanten =

=== Integer-Konstanten ===

Integer-Konstanten sind einfache Zahlenfolgen wie 1234 oder -1234. Ohne entsprechendes Prefix sind dies Dezimalzahlen. Möchte man einen numerischen Wert in hexadezimal angeben, ist 0x voranzustellen, also zum Beispiel 0x1234. Zahlen können auch im Binärsystem angegeben werden. In diesem Fall ist 0b voranzustellen, z.B. 0b10011100.

Beispiele:

* 1234 ist eine Dezimalzahl
* 0x23AF ist eine Hexadezimalzahl
* 0b01010101 ist eine Binärzahl

=== String-Konstanten ===

String-Konstanten werden in Anführungszeichen angegeben.

Beispiel:

* "Das ist eine String-Konstante"

= Variablen =

Variablen werden definiert durch die Angabe des Datentyps und des Namens.

Beispiel:

<syntaxhighlight lang=pas>
int nummer
byte data
string zeichenkette
</syntaxhighlight>

Es gibt lediglich drei verschiedene Datentypen: '''int''' oder '''byte''' oder '''string'''.

Der Datentyp int definiert einen 32-Bit-Integer, ist also vorzeichenbehaftet. Der Datentyp byte entspricht dem Byte, kennt also keinerlei Vorzeichen und ist 8 Bit breit. Der Typ string ist eine Zeichenkette.

=== Globale Variablen ===

Wird eine Variable außerhalb von Funktionen definiert, ist sie eine globale Variable. Auf globale Variablen kann funktionsübergreifend zugegriffen werden - und zwar ab der Zeile, wo sie definiert wird. Eine globale Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang des Quelltextes geschehen, jedoch spätestens dann, wenn auch auf sie zugegegriffen werden soll.

Beispiel:
<syntaxhighlight lang=pas>
int maxleds

function void main ()
maxleds = 30
console.println (maxleds) // Ausgabe: 30
endfunction
</syntaxhighlight>

Globale Variablen können auch direkt bei der Definition initialisiert werden. Dies muss dann - je nach Typ - eine numerische Konstante oder eine Stringkonstante sein.

Beispiel:
<syntaxhighlight lang=pas>
int maxleds = 30

function void main ()
console.println (maxleds) // Ausgabe: 30
maxleds = 40
console.println (maxleds) // Ausgabe: 40
endfunction
</syntaxhighlight>

=== Lokale Variablen ===

Wird eine Variable innerhalb einer Funktion definiert, dann gilt sie nur innerhalb dieser Funktion. Bei jedem Funktionsaufruf werden die lokalen Variablen neu erzeugt und (im Gegensatz z.B. zu C) neu mit 0 (für int) bzw. Leerstring "" (für string) initialisiert. Ruft die Funktion sich selbst rekursiv auf, wird jedesmal ein neuer lokaler Variablensatz erzeugt. Lokale Variablen werden nach dem Verlassen der jeweiligen Funktion wieder zerstört und sind dann nicht mehr verfügbar.

Eine lokale Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang einer Funktion stehen. Jedoch kann sie überall innerhalb der Funktion verwendet werden - frühestens aber unterhalb der erfolgen Definition.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
int var
var = 3 * 2
console.println (var)
endfunction
</syntaxhighlight>

Auch lokale Variablen können direkt bei der Definition initialisiert werden. Dies muss dann - je nach Typ - eine numerische Konstante oder eine Stringkonstante sein.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
int var = 3
string message = "Die Variable hat den Inhalt "
console.println (message : var)
endfunction
</syntaxhighlight>

Arithmetische Ausdrücke sind zur Zeit nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden Integer-Variablen mit 0, String-Variablen mit "" (Leerstring) initialisiert.

=== Statische Variablen ===

Wird eine Variable innerhalb einer Funktion statisch definiert, dann gilt für sie erst einmal dasselbe wie für lokale Variablen. Der einzige Unterschied: Sie wird nur einmal beim Start des Programms erzeugt und beim Verlassen der Funktion auch nicht zerstört. Das heisst: Die Variable (und deren Inhalt) "lebt" während der ganzen Laufzeit des Programms. Außerhalb der Funktion, wo sie definiert wird, kann auf sie mit dem Namen "function.variable" zugegriffen werden, wenn es unbedingt nötig ist, siehe untenstehendes Beispiel.

Werden statische Variablen direkt bei der Definition initialisiert, so haben sie diesen Wert bereits beim Start des Programms.

Eine statische Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang einer Funktion stehen. Jedoch kann sie überall innerhalb der Funktion verwendet werden - frühestens unterhalb der erfolgen Definition.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
static int var = 4
var = 3 * var
console.println (var) // Ausgabe: 12
endfunction

function void main ()
console.println (foo.var) // Ausgabe: 4
foo ()
console.println (foo.var) // Ausgabe: 12
endfunction
</syntaxhighlight>

Statische Variablen können auch außerhalb einer Funktion definiert werden. Da diese Definition semantisch keinen Unterschied zu der Definition einer globalen Variablen macht, werden globale statische Variaben identisch zu globalen Variablen behandelt.

Beim Compilieren erscheint dann eine Warnung:

warning line 1: keyword 'static' takes no effect here.

Beispiel:
<syntaxhighlight lang=pas>
static int var = 3
function void main ()
string message = "Die Variable hat den Inhalt "
console.println (message : var)
</syntaxhighlight>

Arithmetische Ausdrücke sind ebenso wie bei den nicht-statischen Variaben nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden Integer-Variablen mit 0, String-Variablen mit "" (Leerstring) initialisiert.

=== Konstante Variablen ===

"Konstante Variablen" sind auf den ersten Blick ein Widerspruch in sich. Wie kann eine Konstante variabel sein?

Die Antwort: Eine konstante Variable wird von der Semantik wie eine normale Variable behandelt. Allerdings kann deren Wert nicht geändert werden. Daher sollte man direkt bei der Definition solche Variablen auch initialisieren. Unterlässt man dies, haben sie halt den Wert 0 bzw. "" (Leerstring) - je nach Typ.

Konstante Variablen sollte man nach Konvention ausschließlich in Großbuchstaben schreiben. Sie ähneln nämlich den Preprozessor-Konstanten in C. Mit der Großschreibung deutet man an: Dies ist eine Konstante!

Der Inhalt der Variablen wird auch nicht erst zur Laufzeit in arithmetischen Ausdrücken ermittelt, sondern bereits während des Compilierens in die entsprechenden Ausdrücke eingesetzt.

const-Variablen müssen vom Typ int oder string sein. byte ist hier nicht erlaubt - was aber keine Einschränkung bedeutet.

Beispiel:
<syntaxhighlight lang=pas>
const int MAXLEDS = 30 // 30 LEDs

function void foo ()
int var = 4
var = MAXLEDS * var
console.println (var) // Ausgabe: 120
endfunction

function void main ()
foo ()
console.println (MAXLEDS) // Ausgabe: 30
endfunction
</syntaxhighlight>

Arithmetische Ausdrücke sind ebenso wie bei den nicht-statischen Variaben nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden konstante Variablen mit 0 bzw. mit "" (Leerstring) - je nach Typ - initialisiert.

Der Versuch, einer konstante Variablen später im Programm einen anderen Wert zuzuweisen, wird bereits beim Compilieren mit einer Fehlermeldung quittiert.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30 // 30 LEDs

function void main ()
MAXLEDS = 40
console.println (MAXLEDS)
endfunction
</syntaxhighlight>

Die Fehlermeldung lautet dann:

error line 4: variable 'MAXLEDS' is of type 'const'.

= Arrays =

Variablen können auch als Arrays verwendet werden. Dabei wird bei der Definition die Größe des Arrays in eckigen Klammern angegeben. Diese Größe muss entweder durch eine Zahl oder den Inhalt einer "konstanten Integer-Variablen" (const int) angegeben werden. Arrays beginnen immer mit dem Index 0 und enden bei der Arraygröße minus 1. Zugriffe außerhalb dieses Bereichs werden zur Laufzeit abgefangen. In diesem Fall wird eine entsprechende Fehlermeldung auf der Console ausgegeben und das Programm beendet.

Arrays können sowohl global als auch lokal angelegt werden. Auch static Arrays sind möglich. Konstante Arrays gibt es jedoch nicht.

Beispiel:

<syntaxhighlight lang=pas>
const int SIZE = 5
int nummer[7]

function void main ()
string zeichenkette[SIZE]
int i

for i = 0 to 7 - 1
nummer[i] = 2 * i
endfor

console.println (nummer[5]) // Ausgabe: 10

for i = 0 to SIZE - 1
zeichenkette[i] = "Hello " : i
endfor

console.println (zeichenkette[3]) // Ausgabe: "Hello 3"
endfunction
</syntaxhighlight>

= Funktionen =

=== Bibliotheksfunktionen ===

=== Eigene NIC-Funktionen ===

Eine Funktion wird definiert durch folgenden Block:
<syntaxhighlight lang=pas>
function TYPE FUNCTIONNAME (TYP PARAMETER1, TYP PARAMETER2, ...)
...
endfunction
</syntaxhighlight>

Dabei kann TYPE '''int''', '''string''' oder '''void''' sein. FUNCTIONNAME ist einfach der Funktionsname. PARAMETER1 bis PARAMETERn sind die optionalen Funktionsparameter.

Der einfachste Fall ist die main-Funktion, die immer vorhanden sein muss:

<syntaxhighlight lang=pas>
function void main ()
...
endfunction
</syntaxhighlight>

Möchte man das oben angegebene Blink-Programm als eigene Funktion einbauen, dann wäre das folgende Programm eine Lösung:

<syntaxhighlight lang=pas>
function void blink (int factor, int delay)
repeat factor
gpio.toggle (GPIOA, 5)
time.delay (delay)
endloop
endfunction

function void main ()
gpio.init (GPIOA, 5, OUTPUT)
blink (20, 200)
blink (10, 500)
endfunction
</syntaxhighlight>

Der erste Aufruf von blink() lässt die LED 20 mal schnell den Zustand wechseln (Verzögerungszeit 200 msec), der zweite Aufruf lässt die LED lediglich 10 mal den Zustand wechseln, dafür aber langsamer (Verzögerungszeit 500 msec).

=== Eigene NIC-Klassen ===

Später.

= Typumwandlungen =

=== String to Integer ===

Wird einer Integer-Variablen ein String zugewiesen, wird lediglich deren numerischer Inhalt zu Anfang des Strings als Integer-Wert übernommen. Enthält der String überhaupt keinen numerischen Wert zu Anfang, ist der Integer-Wert des Strings 0.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = "1234abc"
console.println (zahl)
endfunction
</syntaxhighlight>

Die Variable Zahl enthält nach der Zuweisung den numerischen Wert 1234.

Dasselbe gilt für Funktionen, die einen Integer-Wert als Parameter erwarten, hier jedoch ein String übergeben wird.

Beispiel:

<syntaxhighlight lang=pas>
function int mult (int a, int b)
return a * b
endfunction

function void main ()
int ergebnis
ergebnis = mult ("2", 3)
console.println (ergebnis)
endfunction
</syntaxhighlight>

=== Integer to String ===

Wird einer String-Variablen ein Integer-Wert zugewiesen, wird dieser automatisch in einen String umgewandelt. Dasselbe gilt für Funktionsparameter, wenn die Funktion einen String als Parameter erwartet.

<syntaxhighlight lang=pas>
function void main ()
string zeichenkette
zeichenkette = 1234
console.println (zeichenkette)
endfunction
</syntaxhighlight>

Ebenso gilt dies für den String-Operator ':', welcher zwei Strings zu einem String zusammensetzt:

<syntaxhighlight lang=pas>
function int mult (int a, int b)
return a * b
endfunction

function void main ()
int ergebnis
string meldung
ergebnis = mult ("2", 3)
meldung = "Das Ergebnis ist " : ergebnis
console.println (meldung)
endfunction
</syntaxhighlight>

Bei dem String-Operator ':' können auch rein numerische Operanden zu einem String zusammengesetzt werden:

<syntaxhighlight lang=pas>
function void main ()
string meldung
meldung = 123 : 456
console.println (meldung)
endfunction
</syntaxhighlight>

Hier wird dann der String "123456" auf der Console ausgegeben.

Kombiniert man beide Typwandlungen (Integer->String und String->Integer), kann man den String-Operator auch auf rein numerische Ausdrücke anwenden, wobei die Zuweisungsvariable auch wieder eine Integer-Variable ist:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 123 : 456
console.println (zahl)
endfunction
</syntaxhighlight>

Hier werden die Zahlen 123 und 456 zunächst in Strings umgewandelt, dann zu einem String zusammengesetzt und bei der Zuweisung wieder zurück in einen Integer-Wert gewandelt. Die Variable 'zahl' enthält nach der Zuweisung den Integer-Wert 123456.

= Kontrollstrukturen =

=== Zuweisung ===

Syntax: VARIABLE = AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
string zeichenkette
int ergebnis

zeichenkette = "Das Ergebnis lautet: "
ergebnis = 1234 * 2
console.println (zeichenkette : ergebnis)
endfunction
</syntaxhighlight>

=== if ===

Syntax:

<syntaxhighlight lang=pas>
if BEDINGUNG1
...
elseif BEDINGUNG2
...
elseif BEDINGUNG3
...
else
...
endif
</syntaxhighlight>

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int zahl

zahl = 33

if zahl < 10
console.println ("Die Zahl is kleiner 10")
elseif zahl < 100
console.println ("Die Zahl is kleiner 100")
elseif zahl > 100
console.println ("Die Zahl is groesser 100")
else
console.println ("Die Zahl is gleich 100")
endif
</syntaxhighlight>

=== loop ===

loop beginnt eine Endlosschleife. Diese kann lediglich mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Endlosschleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
loop
...
endloop
</syntaxhighlight>

Vorzeitiger Abbruch:

<syntaxhighlight lang=pas>
loop
...
break
...
endloop
</syntaxhighlight>

Vorzeitiger Sprung zum Anfang der Schleife

<syntaxhighlight lang=pas>
loop
...
continue
...
endloop
</syntaxhighlight>

Beispiel:

Das folgende Programm lässt die Board-LED auf einem Nucleo-Board leuchten, bis der User-Button gedrückt wird.

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // set pin C13 (user button) to input, has extern pullup
gpio.init (GPIOA, 5, OUTPUT) // board LED = A5
gpio.set (GPIOA, 5) // switch LED on

loop
if gpio.get (GPIOC, 13) = LOW // button pressed?
gpio.set (GPIOA, 5) // switch LED off
break // break loop
endif
endloop
endfunction
</syntaxhighlight>

=== repeat ===

repeat beginnt eine Schleife, welche genau N-mal durchlaufen wird. Die repeat-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
repeat N
...
endrepeat
</syntaxhighlight>

N kann dabei ein beliebiger arithmetischer Ausdruck sein.

Beispiel:

Das folgende Programm gibt die Zahlen 1 bis 9 auf der Console aus.

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 1
repeat 9
console.println (zahl)
zahl = zahl + 1
endrepeat
endfunction
</syntaxhighlight>

=== while ===

Die while-Schleife wird durchlaufen, solange die angegebene Bedingung gegeben ist. Arithmeische Ausdrücke innerhalb der Bedingung werden bei jedem Schleifendurchlauf neu berechnet. Die while-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
while BEDINGUNG
...
endwhile
</syntaxhighlight>

Beispiel:

Das folgende Programm gibt die Zahlen 1 bis 9 auf der Console aus.

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 1
while zahl < 10
console.println (zahl)
zahl = zahl + 1
endwhile
endfunction
</syntaxhighlight>

=== for ===

Die for-Schleife wird für eine anzugebene Schleifenvariable solange durchlaufen, bis der angegebene Stopwert überschritten wird. Optional kann eine Schrittgröße für die Schleifenvariable angegeben werden. Standardmäßig ist diese 1, d.h. die Schleifenvariable wird mit jedem neuen Durchlauf inkrementiert. Ist der Stopwert kleiner als der Startwert, wird die Schleifenvariable mit jedem Durchlauf dekrementiert.

Die for-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
for VARIABLE = STARTWERT to STOPWERT [STEP x]
...
endfor
</syntaxhighlight>

VARIABLE muss eine Integer-Variable sein, STARTWERT und STOPWERT ein beliebiger arithmetischer Ausdruck. Im Gegensatz zur while-Schleife, in welcher die Schleifen-Bedingung und damit die arithmetische Ausdrücke jeweils immer neu evaluiert werden, wird bei der for-Schleife STARTWERT und STOPWERT nur einmal berechnet, nämlich unmittelbar vor dem Betreten der Schleife.

Wird kein Step-Wert angegeben, wird die Laufvariable nach jedem Schleifendurchlauf um 1 erhöht. Wird ein abweichender Step-Wert angegeben, wird die Laufvariable um den angegebenen Wert erhöht. Ist der Step-Wert negativ, wird die Variable um den angegebenen Wert erniedrigt.

Beispiel:

Das folgende Programm gibt zunächst die Zahlen 1 bis 9 auf der Console aus. Anschließend werden die Werte von 9 bis 1 rückwärts zählend ausgegeben:

<syntaxhighlight lang=pas>
function void main ()
int zahl
for zahl = 1 to 9
console.println (zahl)
endfor
for zahl = 9 to 1 step -1
console.println (zahl)
endfor
endfunction
</syntaxhighlight>

=== switch ===

* switch, break

=== return ===

* return

= Vergleichsoperatoren =

=== Vergleichsoperator 'equal' ===

* gleich: =

=== Vergleichsoperator 'not equal' ===

* ungleich: !=

=== Vergleichsoperator 'less' ===

* kleiner: <
* kleiner oder gleich: <=

=== Vergleichsoperator 'greater' ===

* größer: >
* größer oder gleich: >=

= Operatoren =

=== Grundrechenarten ===

==== Addition ====

Syntax: AUSDRUCK + AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 3 + 5
console.println (ergebnis)
</syntaxhighlight>

==== Subtraktion ====

Syntax: AUSDRUCK - AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 - 3
console.println (ergebnis)
</syntaxhighlight>

==== Multiplikation ====

Syntax: AUSDRUCK * AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 * 3
console.println (ergebnis)
</syntaxhighlight>

==== Division ====

Die Integer-Division behandelt nur den ganzzahligen Anteil der Division. Für den entstandenen Rest einer Division siehe '''Modulo'''.

Syntax: AUSDRUCK / AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 / 3
console.println (ergebnis) // Ausdruck ist 1
</syntaxhighlight>

'''Bei den Grundrechenarten gilt die Punkt-vor-Strich-Rechnung.'''

=== Modulo-Operator ===

Der Modulo-Operator berechnet den Rest einer Integer-Division.

Syntax: AUSDRUCK % AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 % 3
console.println (ergebnis) // Ausdruck ist 2
</syntaxhighlight>

'''Der Modulo-Operator bindet (im Gegensatz zu anderen Programmiersprachen!) stärker als die Grundrechenarten.''' Das Ergebnis von
<syntaxhighlight lang=pas>
ergebnis = 2 * 5 % 3
</syntaxhighlight>

ist identisch mit:

<syntaxhighlight lang=pas>
ergebnis = 2 * (5 % 3)
</syntaxhighlight>

Daher ist das Ergebnis hier 2 * 2 = 4.

=== Shift-Operatoren ===

==== Shift Left ====

Der Shift-Operator '<<' verschiebt die Bits einer Zahl nach links.

Syntax: AUSDRUCK << ANZAHL_BITS

Beispiel:
<syntaxhighlight lang=pas>
int zahl
int ergebnis
zahl = 2
ergebnis = zahl << 4 // Verschieben der Zahl 2 um 4 Stellen nach links
console.println (ergebnis) // Ausdruck ist 32
</syntaxhighlight>

==== Shift Left ====

Der Shift-Operator '>>' verschiebt die Bits einer Zahl nach rechts.

Syntax: AUSDRUCK << ANZAHL_BITS

Beispiel:
<syntaxhighlight lang=pas>
int zahl
int ergebnis
zahl = 32
ergebnis = zahl >> 4 // Verschieben der Zahl 32 um 4 Stellen nach rechts
console.println (ergebnis) // Ausdruck ist 2
</syntaxhighlight>

'''Die Shift-Operatoren binden stärker als die Grundrechenarten und der Modulo-Operator.''' Das Ergebnis von
<syntaxhighlight lang=pas>
3 * 1 << 4
</syntaxhighlight>
ist also 3 * 16 = 48.

Wichtig: Beim Verschieben werden die Ausdrücke immer als unsigned-Werte angesehen, d.h. Vorzeichenbits werden nicht besonders behandelt.

=== Bitmask-Operatoren ===

==== Bitwise OR ====

Syntax: AUSDRUCK | AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0x0F | 0xF0, HEX, 2) // Ausdruck ist FF
</syntaxhighlight>

==== Bitwise AND ====

Syntax: AUSDRUCK & AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0xFFFF & 0x00F0, HEX, 4) // Ausdruck ist 00F0
</syntaxhighlight>

==== Bitwise XOR ====

Syntax: AUSDRUCK ^ AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0xFFFF ^ 0x00F0, HEX, 4) // Ausdruck ist FF0F
</syntaxhighlight>

==== Bitwise Inversion ====

Syntax: ~AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (~0xFF00, HEX, 4) // Ausdruck ist FFFF00FF
console.println (~0xFF00 & 0xFFFF, HEX, 4) // Ausdruck ist 00FF
</syntaxhighlight>

'''Der And-Operator bindet stärker als der OR-Operator. Die Invertierung wirkt unmittelbar auf den nachfolgenden Ausdruck. Sämtliche Bitmask-Operatoren binden stärker als die vorangegangenen Operatoren.'''

=== Klammern ===

Um die obigen Prioritätenregelungen zu durchbrechen, können in den Ausdrücken Klammern gesetzt werden.

Beispiel:
<syntaxhighlight lang=pas>
console.println (3 + 2 * 4) // Ausdruck ist 3 + 8 = 11
console.println ((3 + 2) * 4) // Ausdruck ist 5 * 4 = 20
console.println (3 + 2 << 2) // Ausdruck ist 3 + 8 = 11
console.println ((3 + 2) << 2) // Ausdruck ist 5 << 2 = 20
</syntaxhighlight>

=== String-Operator ===

Der String-Operator fasst zwei Zeichenketten zu einer Zeichenkette zusammen.

Syntax: STRING1 : STRING2

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
string str1
string str2
string str3
str1 = "Hello, "
str2 = "World"
str3 = str1 : str2
console.println (str3) // Ausgabe: "Hello, World"
endfunction
</syntaxhighlight>

Oder auch kürzer:
<syntaxhighlight lang=pas>
function void main ()
string str
str1 = "Hello, "
console.println (str : "World")
endfunction
</syntaxhighlight>

Oder noch kürzer:
<syntaxhighlight lang=pas>
function void main ()
console.println ("Hello, " : "World")
endfunction
</syntaxhighlight>

Der String-Operator wandelt numerische Ausdrücke automatisch in Strings.

Somit führt der Programmabschnitt:
<syntaxhighlight lang=pas>
string str
str = (3 * 5) : " ist das Ergebnis."
console.println (str)
</syntaxhighlight>

zu einem Ausdruck von "15 ist das Ergebnis.".

Wichtig: '''Der String-Operator bindet stärker als alle anderen nicht-unären Operatoren.'''

Fehlende Klammern in Abschnitt:
<syntaxhighlight lang=pas>
string str
str = 3 * 5 : " ist das Ergebnis."
console.println (str)
</syntaxhighlight>
führen also zum Ausdruck von lediglich "15", da der zwischendurch entstehende Ausdruck "5 ist das Ergebnis" für die Multiplikation in einen Integer gewandelt wird. Übrig bleibt daher lediglich 3 * 5. Das Ergebnis wird wegen der Zuweisung wieder zurück in einen String gewandelt. Übrig bleibt "15".

= Bibliotheken =

=== Bibliothek string ===

==== string.length () ====

Die length-Funktion gibt die Länge eines Strings zurück.

Syntax: int string.length (string str)

Parameter:

* string: Die Eingabezeichenkette

Rückgabewert: Länge des Strings

Beispiel:

<syntaxhighlight lang=pas>
int len
len = string.length ("abcdef"); // gibt 6 zurück
</syntaxhighlight>

==== string.substring () ====

Die substring-Funktion kann beliebige Zeichenketten aus einem String extrahieren.

Syntax: string string.substring (string str, int start [, int length ])

Parameter:

* string: Die Eingabezeichenkette
* start: Die Startposition innerhalb des Strings
* length: Die Länge des zu extrahierenden Strings. Der Parameter ist optional.

Die Startposition wird ab 0 gezählt. Ist der Startwert positiv oder 0, wird die Startposition innerhalb des Eingabestrings von links gezählt, anderenfalls von rechts.

Beispiel:

<syntaxhighlight lang=pas>
string rest
rest = string.substring ("abcdef", -1); // gibt "f" zurück
rest = string.substring ("abcdef", -2); // gibt "ef" zurück
rest = string.substring ("abcdef", -3, 1); // gibt "d" zurück
</syntaxhighlight>

Ist length angegeben und positiv, enthält der zurückgegebene String höchstens length Zeichen ab start (abhängig von der Länge von string).

Ist length angegeben und negativ, werden genau so viele Zeichen vom Ende von string abgeschnitten (nachdem die Startposition ermittelt wurde, sollte start negativ sein). Gibt start die Position des abzuschneidenden Teiles oder dahinter an, wird ein leerer String zurückgegeben.

Beispiel:

<syntaxhighlight lang=pas>
rest = string.substring ("abcdef", 0, -1); // gibt "abcde" zurück
rest = string.substring ("abcdef", 2, -1); // gibt "cde" zurück
rest = string.substring ("abcdef", 4, -4); // gibt "" zurück
rest = string.substring ("abcdef", -3, -1); // gibt "de" zurück
</syntaxhighlight>

Die aus Basic bekannten Funktionen 'left', 'right' und 'mid' können alle mit der substring-Funktion abgebildet werden:

<syntaxhighlight lang=pas>
function string left (string str, int l)
return string.substring (str, 0, l)
endfunction

function string right (string str, int l)
return string.substring (str, -l)
endfunction

function string mid (string str, int s, int l)
return string.substring (str, s, l)
endfunction

function void main ()
string x
x = "abcdef"

console.println (left (x, 3)) // gibt "abc" aus
console.println (right (x, 3)) // gibt "def" aus
console.println (mid (x, 2, 2)) // gibt "cd" aus
endfunction
</syntaxhighlight>

=== Bibliothek time ===

==== time.millis () ====

Der Rückgabewert von time.millis() entsprecht der internen "Uhrzeit" des Mikrocontrollers seit dem letzten Boot in Millisekunden.

Syntax: int time.millis ()

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit: " : time)
endfunction
</syntaxhighlight>

==== time.reset () ====

time.reset setzt die interne "Uhrzeit" des Mikrocontrollers zurück auf 0.

Syntax: void time.reset ()

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Reset: " : time)
time.reset ()
time = time.millis ()
console.println ("Zeit nach Reset: " : time)
endfunction
</syntaxhighlight>

==== time.set () ====

time.set setzt die interne "Uhrzeit" des Mikrocontrollers auf den angegebenen Wert

Syntax: void time.reset (int millis)

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Set: " : time)
time.set (1000)
time = time.millis ()
console.println ("Zeit nach Set: " : time)
endfunction
</syntaxhighlight>

==== time.delay () ====

time.delay() wartet die angegebene Zeit in Millisekunden.

Syntax: void time.delay (int msec)

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Delay: " : time)
time.delay (500)
time = time.millis ()
console.println ("Zeit nach Delay: " : time)
endfunction
</syntaxhighlight>

=== Bibliothek console ===

==== console.print () ====

Syntax:
int console.print (int/string EXPRESSION)
oder:
int console.print (int/string EXPRESSION, const TYPE)
oder:
int console.print (int/string EXPRESSION, const TYPE, int WIDTH)

Wird nur das erste Argument übergeben, wird anhand des Parameter-Typs entschieden, ob ein String oder ein Integer-Wert auf der Console ausgedruckt wird. Man kann aber auch steuern, wie der übergebene Parameter behandelt werden soll. Dabei kann TYPE die folgenden Werte haben:

* STR - Der Parameter wird als String behandelt
* DEC - Der Parameter wird als Dezimalzahl gedruckt
* DEC0 - Der Parameter wird als Dezimalzahl gedruckt, jedoch wird das Ausgabefeld mit führenden Nullen aufgefüllt.
* HEX - Der Parameter wird als Hexadezimalzahl gedruckt
* BIN - Der Parameter wird als Binärzahl gedruckt

Mit einem weiteren numerischen Parameter WIDTH kann gesteuert werden, wie breit das Ausgabefeld sein soll. Dann wird der ausgegebene Text auf mindestens diese Anzahl von Zeichen tabuliert, das heißt mit Leerzeichen aufgefüllt. Ist WIDTH positiv, werden Leerzeichen von links beginnend eingefügt, ist WIDTH negativ, werden entsprechend viele Leerzeichen rechts angefügt, um auf die gewünschte Breite zu kommen. Eine Besonderheit ist das Drucken von HEX- oder BIN-Zahlen: Bei positivem Wert von WIDTH wird das Feld mit Nullen statt Leerzeichen aufgefüllt. Bei Dezimalzahlen geht dieses über den Typ DEC0.

Rückgabewert: Anzahl der gedruckten Zeichen.

Beispiele siehe console.println ().

==== console.println () ====

Syntax:
int console.println (int/string EXPRESSION)
oder:
int console.println (int/string EXPRESSION, const TYPE)
oder:
int console.println (int/string EXPRESSION, const TYPE, int WIDTH)

Das Verhalten entspricht exakt der Funktion console.print(). Jedoch wird noch nach dem Ausdruck ein CRNL-Paar angefügt, um eine neue Zeile zu beginnen.

Beispiele:

<syntaxhighlight lang=pas>
function void main ()
int i

i = 4711
console.println (i) // 4711
console.println (i, DEC) // 4711
console.println (i, HEX) // 1267
console.println (i, BIN) // 1001001100111

i = 0xFFFFFFFF
console.println (i, HEX) // FFFFFFFF
console.println (i >> 1, HEX) // 7FFFFFFF

i = 0xFFFF
console.println (i, HEX) // FFFF
console.println (i, HEX, 8) // 0000FFFF
console.println (i >> 1, HEX, 8) // 7FFF

i = 0xFF
console.println (i, HEX, 2) // FF
console.println (i >> 1, HEX, 2) // 7F
console.println (i >> 1, BIN, 16) // 0000000001111111

console.println (0xAA, BIN, 8) // 10101010
console.println (1, BIN, 32) // 00000000000000000000000000000001

console.println ("Hallo, Welt") // Hallo, Welt
console.println ("42 Hallo, Welt") // 42 Hallo, Welt
console.println ("42 Hallo, Welt", DEC) // 42
console.println ("42 Hallo, Welt", BIN) // 101010
endfunction
</syntaxhighlight>

=== Bibliothek gpio ===

==== gpio.init () ====

Initialisiert General Purpose I/O für einen Pin.

Syntax:
void gpio.init (PORT, BIT, INPUT [, NOPULL | PULLDOWN | PULLUP ])
oder
void gpio.init (PORT, BIT, OUTPUT [, PUSHPULL | OPENDRAIN ])

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 
Für die Datenrichtung muss entweder die Konstante INPUT oder die Konstante OUTPUT vorgegeben werden. 

Bei Verwendung des Pins als INPUT können folgende Alternativen eingestellt werden:

* '''NOPULL (Default):''' Der Eingang wird nicht durch einen internen Pullup oder Pulldown beeinflusst
* '''PULLDOWN:''' Es wird der interne Pulldown-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel LOW.
* '''PULLUP:''' Es wird der interne Pullup-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel HIGH.

Bei Verwendung des Pins als OUTPUT können folgende Alternativen eingestellt werden:

* '''PUSHPULL (Default):''' Der Ausgang wird möglichst niederohmig geschaltet.
* '''OPENDRAIN:''' Der Low-Pegel wird möglichst niederohmig geschaltet, der High-Pegel ist hochohmig.

Der letzte Parameter von gpio.init() ist optional. Wird er weggelassen, wird der jeweilige Standardwert (Default) eingestellt.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // C13 als Input, kein Pulldown/Pullup
gpio.init (GPIOC, 13, INPUT, PULLUP) // C13 als Input mit Pullup
endfunction
</syntaxhighlight>

==== gpio.set () ====

Setzt den ausgewählten Pin auf High-Pegel.

Syntax: void gpio.set (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
gpio.set (GPIOA, 5) // Pin auf HIGH
endfunction
</syntaxhighlight>

==== gpio.reset () ====

Setzt den ausgewählten Pin auf Low-Pegel.

Syntax: void gpio.reset (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
gpio.reset (GPIOA, 5) // Pin auf Low
endfunction
</syntaxhighlight>

==== gpio.toggle () ====

Invertiert den Zustand des ausgewählten Pins.

Syntax: void gpio.toggle (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
loop
gpio.toggle (GPIOA, 5) // A5 invertieren
time.delay (500) // eine halbe Sekunde warten
endloop
endfunction
</syntaxhighlight>

==== gpio.get () ====

Liest den Zustand des ausgewählten Pins.

Syntax: int gpio.get (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Der Rückgabewert ist entweder LOW oder HIGH.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // set pin C13 (user button) to input, has extern pullup
gpio.init (GPIOA, 5, OUTPUT) // board LED = A5
gpio.set (GPIOA, 5) // switch LED on

loop
if gpio.get (GPIOC, 13) = LOW // button pressed?
gpio.set (GPIOA, 5) // switch LED off
break // break loop
endif
endloop
endfunction
</syntaxhighlight>

=== Bibliothek bit ===

==== bit.set () ====

bit.set() setzt ein Bit.

Syntax: int bit.set (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = bit.set (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00100000
endfunction
</syntaxhighlight>

Alternativ kann man auch den Operator '|' nutzen, um ein Bit zu setzen:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = zahl | (1<<5)
console.println (zahl, BIN) // Ausgabe: 00100000
endfunction
</syntaxhighlight>

==== bit.reset () ====

bit.reset() setzt ein Bit zurück.

Syntax: int bit.reset (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b11111111
zahl = bit.reset (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 11011111
endfunction
</syntaxhighlight>

Alternativ kann man auch den Operator '&' zusammen mit '~' nutzen, um ein Bit zu zurückzusetzen:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b11111111
zahl = zahl & ~(1<<5)
console.println (zahl, BIN) // Ausgabe: 11011111
endfunction
</syntaxhighlight>

==== bit.toggle () ====

bit.toggle() wechselt den Zustand eines Bits.

Syntax: int bit.toggle (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = bit.toggle (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00100000
zahl = bit.toggle (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00000000
endfunction
</syntaxhighlight>

==== bit.isset () ====

bit.isset() gibt den Zustand eines Bits zurück

Syntax: int bit.isset (int value, int bit)

Rückgabewert: TRUE, wenn das Bit gesetzt ist, sonst FALSE.

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int bit
bit = bit.isset (0b11111111, 5)
if bit = TRUE
else
console.println ("bit is set")
endif
console.println ("bit is not set")
endfunction
</syntaxhighlight>

=== Bibliothek button ===

==== button.init () ====

Definiert einen GPIO-Pin als Tastereingang. Der Taster wird automatisch vom NIC-Laufzeitsystem per Software entprellt.

Syntax:
int button.init (PORT, BIT, MODE)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Bei Verwendung des Tastereingangs können folgende Alternativen für MODE eingestellt werden:

* '''PULLDOWN:''' Es wird der interne Pulldown-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel LOW.
* '''PULLUP:''' Es wird der interne Pullup-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel HIGH.
* '''NOPULLDOWN:''' Für den Tastereingang ist die Hinzuschaltung des internen Pulldowns nicht notwendig, Taster ist active high.
* '''NOPULLUP:''' Für den Tastereingang ist die Hinzuschaltung des internen Pullups nicht notwendig, Taster ist active high.

Daraus ergibt sich, dass bei Einstellung PULLDOWN der Schalter gegen Vcc, bei Einstellung PULLUP der Schalter gegen GND schalten muss. Dasselbe gibt für NOPULLDOWN bzw. NOPULLUP. Hier muss die externe Beschaltung selbst für einen definierten Pegel sorgen, zum Beispiel bei NOPULLUP durch Anschluss eines '''externen''' Pullups.

Das NIC-Laufzeitsystem vergibt eine interne Tastennummer größer Null, die bei Abfragen durch button.pressed() dann angegeben werden muss. Bis zu 8 solcher Tasten können mittels button.init() definiert werden. Wenn button.init() eine 0 zurückliefert, sind bereits alle 8 Tasten definiert.

Beispiel:

Beim Nucleo hängt der blaue User-Taster an PC13 und schaltet gegen GND. Da hier bereits ein externer Pullup-Widerstand vorgesehen ist, muss '''kein interner Pullup-Widerstand''' aktiviert werden.

<syntaxhighlight lang=pas>
function void main ()
int button

button = button.init (GPIOC, 13, NOPULLUP) // C13 als Input, kein interner Pullup nötig, active low
...
endfunction
</syntaxhighlight>

Beim STM32F103 Mini-Development-Board gibt es bis auf den RESET-Taster keinen weiteren Taster auf dem Board. Wir können aber zum Beispiel einen Taster an PA6 anschließen, so dass er gegen GND schaltet. Den externen Pullup sparen wir uns und verwenden dafür den internen Pullup am Pin:

<syntaxhighlight lang=pas>
function void main ()
int button

button = button.init (GPIOA, 6, PULLUP) // PA6 als Input mit internem Pullup, active low
...
endfunction
</syntaxhighlight>

==== button.pressed () ====

Abfrage des Tasters.

Syntax:
int button.pressed (int button)

button ist dabei die Taster-Nummer, die von button.init() zurückgegeben wurde.

Rückgabewerte:

TRUE: Taste ist gedrückt
FALSE: Taste wurde nicht gedrückt.

Beispiel:

Einschalten der Board-LED, sobald die blaue User-Taste gedrückt wird, sonst ausschalten.

<syntaxhighlight lang=pas>
function void main ()
int button
gpio.init (GPIOA, 5, OUTPUT) // LED als Output
gpio.reset (GPIOA, 5) // Pegel low: LED ist aus

button = button.init (GPIOC, 13, NOPULLUP) // C13 als Input, kein interner Pullup nötig, active low

loop
if button.pressed (button) = TRUE // Taste gedrückt?
gpio.set (GPIOA, 5) // ja, LED einschalten
else
gpio.reset (GPIOA, 5) // nein, LED ausschalten
endif
endloop
endfunction
</syntaxhighlight>

Beim STM32F103 Mini-Development-Board gibt es eine blaue LED auf dem Board. Sie ist an PC13 angeschlossen. Allerdings muss diese gegen GND geschaltet werden, damit sie leuchtet. Sie ist also "active low" - im Gegensatz zur Nucleo-LED. Die Set- und Reset-Befehl werden hier daher ausgetauscht:

<syntaxhighlight lang=pas>
function void main ()
int button
gpio.init (GPIOC, 13, OUTPUT) // LED als Output
gpio.set (GPIOC, 13) // Pegel high: LED ist aus

button = button.init (GPIOA, 6, PULLUP) // PA6 als Input mit internem Pullup, active low

loop
if button.pressed (button) = TRUE // Taste gedrückt?
gpio.reset (GPIOC, 13) // ja, LED einschalten
else
gpio.set (GPIOC, 13) // nein, LED ausschalten
endif
endloop
endfunction
</syntaxhighlight>

=== Bibliothek ws2812 ===

==== ws2812.init () ====

Mit ws2812.init() wird die WS2812-LED-Bibliothek initialisiert.

Syntax:

void ws2812.init (int nleds)

Als Argument ist die maximale Anzahl der verwendeten LEDs in der Kette anzugeben.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
ws2812.init (30) // 30 LEDs auf dem Stripe
...
endfunction
</syntaxhighlight>

==== ws2812.set () ====

Damit wird die Farbe einer oder aller WS2812-LEDs gesetzt.

Syntax:

void ws2812.set (int led, int red, int green, int blue)

led gibt die Nummer der LED an - beginnend mit 0. Wird als Nummer die Anzahl der verwendeten LEDs angegeben, werden die Farben sämtlicher verwendeter LEDs gesetzt. Die Farben können Werte zwischen 0 (aus) und 255 (volle Helligkeit) haben.

Der Set-Befehl setzt die angebenen Farben erst einmal nur im RAM. Erst mit dem ws2812.refresh()-Befehl werden dann sämtliche gesetzten Farben an die LEDs übertragen.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30

function void main ()
int i

ws2812.init (MAXLEDS) // 30 LEDs auf dem Stripe
ws2812.set (MAXLEDS, 128, 128, 128) // Alle LEDs auf weiß, halbe Helligkeit

for i = 0 to MAXLEDS
ws2812.set (i, 0, 128, 128) // Eine LEDs auf türkis, halbe Helligkeit
ws2812.refresh (MAXLEDS) // Ausgabe
delay (200) // 0,2 Sekunden warten
endfor
endfunction
</syntaxhighlight>

==== ws2812.refresh () ====

ws2812.refresh() überträgt sämtliche zuvor gesetzte Farben an die LEDs.

Syntax:

void ws2812.refresh (nleds)

Das Argument nleds bestimmt, wieviele der LEDs aktualisiert werden sollen. Der Maximalwert ist derjenige, der bei ws2812.init() angegeben wurde. Dann werden alle LEDs aktualisiert.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30

function void main ()
ws2812.init (MAXLEDS) // 30 LEDs auf dem Stripe
...
ws2812.refresh (MAXLEDS) // Ausgabe: Alle LEDs aktualisieren
...
endfunction
</syntaxhighlight>

Konkreteres Beispiel siehe oben: [[NIC#ws2812.set_.28.29|ws2812.set()]].

=== Bibliothek irmp ===

==== irmp.init () ====
==== irmp.get () ====

=== Bibliothek irsnd ===

==== irsnd.init () ====
==== irsnd.send () ====

=== Bibliothek i2c ===

==== i2c.init () ====

i2c.init () initialisiert die jeweils gewünschte I2C-Schnittstelle.

Syntax:

void i2c.init (int channel, int alternate, int clockspeed)

Parameter:

* channel: I2C-Channel. Erlaubte Werte: I2C1, I2C2 oder I2C3. Welche Werte davon möglich sind, ist prozessorabhängig.
* alternate: Flag, ob die alternative Pinkonfiguration verwendet werden soll, siehe Tabelle.
* clockspeed: Taktgeschwindigkeit. Standard ist 100000 (100k), möglich ist aber auch 400000 (400k) für schnelle Peripherie

{| {{Tabelle}}
|+ '''Mögliche I2C-Channel'''
|- style="background-color:#eeeeee"
! Channel || ALT || STM32F4x1 Nucleo || STM32F103C8T6
|-
| I2C1 || 0 || SCL=PB6, SDA=PB7|| SCL=PB6, SDA=PB7
|-
| I2C2 || 0 || SCL=PB10, SDA=PB3 ||
|-
| I2C3 || 0 || SCL=PA8, SDA=PB4 ||
|-
| I2C1 || 1 || SCL=PB8, SDA=PB9 || SCL=PB8, SDA=PB9
|-
| I2C2 || 1 || ||
|-
| I2C3 || 1 || SCL=PA8, SDA=PC9 ||
|-
|}

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k
...
endfunction
</syntaxhighlight>

==== i2c.write () ====

i2c.write() schreibt einen Datenpuffer auf die gewählte I2C-Schnittstelle.

Syntax:

int i2c.write (int channel, int address, int startaddress, int flag, byte buffer[], int length)

Parameter:

* channel: I2C-Channel, siehe i2c.init()
* address: I2C-Adresse des anzusprechenden Moduls
* startaddress: Start-Adresse für die Daten
* flag: Flag, ob die Start-Adresse ein 8- oder 16-Bit-Wert ist: TRUE: 16-Bit, FALSE: 8-Bit
* buffer: Datenpuffer
* length: Länge der Daten

Beispiel:

Schreiben des Datums "2017-06-10 16:32:12" in eine DS3231 Real Time Clock:

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// write date/time to DS3231
//-----------------------------------------------------------------------------------
const int RTC = 0xD0 // I2C address of DS3231 RTC

int year = 2017
int mon = 6
int mday = 10
int hour = 16
int min = 32
int sec = 12

//-----------------------------------------------------------------------------------
// convert decimal number into BCD format
//-----------------------------------------------------------------------------------
function int dec2bcd (int i)
i = ((i / 10) << 4) | (i % 10)
return i
endfunction

//-----------------------------------------------------------------------------------
// main function: set date/time to 2017-06-10 16:32:12
//-----------------------------------------------------------------------------------
function void main ()
byte buf[7] // Data buffer

i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k

year = year % 100 // 2000 - 2099 -> 00 - 99

buf[0] = dec2bcd (sec) // seconds (0-59)
buf[1] = dec2bcd (min) // minutes (0-59)
buf[2] = dec2bcd (hour) // hours (0-24)
buf[3] = 0 // wday (unknown) (0-6)
buf[4] = dec2bcd (mday) // day of month (0-31)
buf[5] = dec2bcd (mon) // month (1-12)
buf[6] = dec2bcd (year) // year (00-99)

rtc = i2c.write (I2C1, RTC, 0x00, FALSE, buf, 7) // write to RTC
endfunction
</syntaxhighlight>

Die RTC erwartet lediglich 8-Bit-Startadressen. Deshalb wird hier das Flag beim Aufruf von i2c.write() auf FALSE gesetzt.

==== i2c.read () ====

i2c.read() liest Daten von der gewählten I2C-Schnittstelle.

Syntax:

int i2c.read (int channel, int address, int startaddress, int flag, byte buffer[], int length)

Parameter:

* channel: I2C-Channel, siehe i2c.init()
* address: I2C-Adresse des anzusprechenden Moduls
* startaddress: Start-Adresse für die Daten
* flag: Flag, ob die Start-Adresse ein 8- oder 16-Bit-Wert ist: TRUE: 16-Bit, FALSE: 8-Bit
* buffer: Datenpuffer
* length: Länge der Daten

Beispiel:

Lesen von Datum/Uhrzeit aus DS3231 Real Time Clock und Ausgabe auf der Console:

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// read date/time from DS3231 RTC
//-----------------------------------------------------------------------------------
const int RTC = 0xD0 // I2C address of DS3231 RTC

int year
int mon
int mday
int hour
int min
int sec

//-----------------------------------------------------------------------------------
// convert BCD format into decimal number
//-----------------------------------------------------------------------------------
function int bcd2dec (byte i)
i = 10 * ((i & 0xF0) >> 4) + (i & 0x0F)
return i
endfunction

//-----------------------------------------------------------------------------------
// main function: get date/time from RTC
//-----------------------------------------------------------------------------------
function void main ()
byte buf[7] // Data buffer
int rtc

i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k

rtc = i2c.read (I2C1, RTC, 0x00, FALSE, buf, 7) // read from RTC

if rtc = TRUE
sec = bcd2dec (buf[0]) // seconds (0-59)
min = bcd2dec (buf[1]) // minutes (0-59)
hour = bcd2dec (buf[2]) // hours (0-24)
mday = bcd2dec (buf[4]) // day of month (0-31)
mon = bcd2dec (buf[5]) // month (1-12)
year = bcd2dec (buf[6]) // year (00-99)
year = year + 2000 // 00 - 99 -> 2000 - 2099

console.print (year, DEC0, 4) // print YYYY-DD-MM hh:mm:ss
console.print ("-")
console.print (mon, DEC0, 2)
console.print ("-")
console.print (mday, DEC0, 2)
console.print (" ")
console.print (hour, DEC0, 2)
console.print (":")
console.print (min, DEC0, 2)
console.print (":")
console.print (sec, DEC0, 2)
console.println ("")
endif
endfunction
</syntaxhighlight>

Die RTC erwartet lediglich 8-Bit-Startadressen. Deshalb wird hier das Flag auf FALSE gesetzt.

'''Weiteres Beispiel: Lesen/Schreiben eines EEPROMs:'''

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// main function: write some values into EEPROM, read them from EEPROM again
//-----------------------------------------------------------------------------------
function void main ()
byte buffer1[8]
byte buffer2[8]
int rtc
int i

for i = 0 to 7
buffer1[i] = i
endfor

rtc = i2c.write (I2C1, EEPROM, 0x0000, TRUE, buffer1, 8) // write buffer1 to EEPROM

if rtc = FALSE
console.println ("i2c write error!")
endif

rtc = i2c.read (I2C1, EEPROM, 0x0000, TRUE, buffer2, 8) // read buffer2 from EEPROM

if rtc = FALSE
console.println ("i2c read error!")
endif

for i = 0 to 7
console.println (buffer2[i])
endfor
endfunction
</syntaxhighlight>

Da das EEPROM 16-Bit-Startadressen erwartet, wird hier das Flag auf TRUE gesetzt.

=== Bibliothek rtc ===

==== rtc.read () ====
==== rtc.write () ====

=== Bibliothek eeprom ===

==== eeprom.read () ====
==== eeprom.write () ====

=== Bibliothek onewire ===

==== onewire.init () ====
==== onewire.read () ====

=== Bibliothek ds1820 ===

==== ds1820.init () ====
==== ds1820.read () ====

=== Bibliothek lcd ===

==== lcd.init () ====
==== lcd.move () ====
==== lcd.print () ====

=== Bibliothek spi ===

==== spi.init () ====
==== spi.read () ====
==== spi.write () ====

= Beispielprojekt - Lauflicht mit WS2812 =

Im folgenden wird ein Lauflicht mit 30 WS2812-LEDs realisiert. Die erste Variante läuft noch mit der delay-Funktion, welche keinen Spielraum mehr lässt für andere Sachen, die eventuell auch noch abgearbeitet werden sollen.

Die zweite Variante ist da schon wesentlich eleganter. Sie wird nur aktiv, wenn auch Änderungen auf unserem LED-Streifen vonnöten sind.

Die dritte Variante dagegen überlässt dem NIC-Laufzeitsystem die Zeitmessung bis zum nächsten LED-Update, so dass man sich darum nicht mehr kümmern muss. Desweiteren kann man bis zu 8 solcher Alarm-Timer gleichzeitig aktivieren, so dass man hier auch ganz verschiedene Aufgaben mit unterschiedlichen Aktivierungszeiten implementieren kann. Hier wird der Alarm-Timer noch gepollt, d.h. explizit abgefragt.

In der letzten und vierten Variante wird auch dieses noch dem NIC-Runtime-System überlassen. Hier geben wir einfach eine NIC-Funktion an, welche automatisch aufgerufen werden soll, wenn der Alarm eintrifft.

=== Lauflicht mit Delay ===

Die erste Variante arbeitet mit einem Delay, welches den Prozessor warten lässt. Währenddessen kann man keine anderen Aktionen im Programm ausführen.

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED

ws2812.init (MAX_LEDS) // Initialisierung

loop
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
time.delay (500) // Eine halbe Sekunde warten
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Millis-Timer ===

Diese Variante ermittelt mittels time.millis(), wann es aktiv werden soll und kann währenddessen noch andere Aufgaben erledigen. Allerdings wird hier der millis-Timer verwendet, so dass dieser nicht mehr für andere Dinge zur Verfügung steht.

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED

ws2812.init (MAX_LEDS) // Initialisierung
time.reset () // Setze "Uhrzeit" zurueck

loop
if time.millis() > 500 // Eine halbe Sekunde erreicht?
time.reset () // Ja, Zeit wieder zuruecksetzen
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
else
// ... // Hier koennen nun andere Aufgaben erledigt werden!
endif
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Alarm ===

Die dritte Variante verwendet einen von acht Alarm-Timern. Das ist damit die Luxusversion. Der millis-Timer wird nicht verwendet. Neben diesem können noch sieben weitere Alarm-Timer für andere Aufgaben benutzt werden:

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED
int timer1 // alarm-timer

ws2812.init (MAX_LEDS) // Initialisierung
timer1 = alarm.set (500) // Alarm initialisieren

loop
if alarm (timer1) = TRUE // Alarm gesetzt?
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
else
// ... // Hier koennen nun andere Aufgaben erledigt werden!
endif
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Alarm als Interrupt ===

In der letzten und vierten Variante wird das Pollen des Alarm-Timers dem NIC-Runtime-System überlassen. Hier geben wir einfach eine NIC-Funktion an, welche aufgerufen werden soll, wenn der Alarm eintrifft:

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void lauflicht ()
static int red = 128 // Rot
static int green = 0 // Gruen
static int blue = 0 // Blau
static int led // Aktive LED

ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
endfunction

function void main ()
ws2812.init (MAX_LEDS) // Initialisierung
alarm.set (500, function.lauflicht) // lauflicht() alle 500msec automatisch aufrufen lassen

loop
// ... // Hier koennen nun komplett andere Aufgaben erledigt werden!
endloop
endfunction
</syntaxhighlight>

Die Variablen led, red, green und blue sind nun alle in die Funktion lauflicht() gewandert. Die Definition als static-Variable lassen sie über die ganze Laufzeit des Programms "leben", d.h. sie verlieren nicht ihren Wert, wenn die Funktion wieder verlassen wird. Alternativ können sie auch einfach als globale Variablen definiert werden. Der Vorteil der static-Definition ist jedoch, dass sie ausschließlich in der Funktion lauflicht() manipuliert werden können.

= Beispielprojekt - Knight Rider mit WS2812 =

= Beispielprojekt - Equinox-Uhr mit WS2812 =

= Erstellung eigener NIC-Bibliotheksfunktionen =

= Benchmarks =

=== Sieb des Eratosthenes ===

Es geht um die Ermittlung sämtlicher Primzahlen bis 100.000.

Sieb des Eratosthenes in NIC:
<syntaxhighlight lang=pas>
function void main ()
int limit = 100000
int zahl
int zaehler
int primzahl
int letzte_primzahl

for zahl = 2 to limit
primzahl = TRUE

for zaehler = 2 to zahl / 2
if zahl % zaehler = 0
primzahl = FALSE
break
endif
endfor

if primzahl = TRUE
// console.println (zahl : " ist eine Primzahl")
letzte_primzahl = zahl
endif
endfor
console.println ("Die hoechste ermittelte Primzahl ist " : letzte_primzahl)
endfunction
</syntaxhighlight>

Sieb des Eratosthenes in PHP:
<syntaxhighlight lang=php>
<?php
$limit = 100000;

for ($zahl = 2; $zahl <= $limit; $zahl++)
{
$primzahl = true;

for ($zaehler = 2; $zaehler <= $zahl / 2; $zaehler++)
{
if ($zahl % $zaehler == 0)
{
$primzahl = false;
break;
}
}

if ($primzahl)
{
// print ("" . $zahl . " ist eine Primzahl\n");
$letzte_primzahl = $zahl;
}
}
print ("Die hoechste ermittelte Primzahl ist " . $letzte_primzahl . "\n");
?>
</syntaxhighlight>

Sieb des Eratosthenes in Python:
<syntaxhighlight lang=python>
def main():
limit = 100000

for zahl in range (2, limit):
primzahl = True

for zaehler in range (2, zahl / 2):
if zahl % zaehler == 0:
primzahl = False
break

if primzahl == True:
letzte_primzahl = zahl
print "Die hoechste ermittelte Primzahl ist %d" % (letzte_primzahl)
return 0

if __name__ == '__main__':
main()
</syntaxhighlight>

Sieb des Eratosthenes in Lua:
<syntaxhighlight lang=lua>
local limit = 100000
local zahl
local zaehler
local primzahl
local letzte_primzahl

for zahl = 2, limit do
primzahl = true

for zaehler = 2, zahl / 2 do
if zahl % zaehler == 0 then
primzahl = false
break
end
end

if primzahl == true then
-- print (zahl, "ist eine Primzahl")
letzte_primzahl = zahl
end
end
print ("Die hoechste ermittelte Primzahl ist ", letzte_primzahl)
</syntaxhighlight>

Die Umsetzung in PHP, Python und Lua wurde durch 1:1-Ersetzung jeder Zeile durch die adäquate Formulierung in der jeweiligen Programmiersprache vorgenommen. Die Programme sind damit direkt vergleichbar.

Ausführungszeiten:

{| {{Tabelle}}
|+ '''Ergebnisse: Sieb des Eratosthenes'''
|- style="background-color:#eeeeee"
! Programmiersprache || Version || i7-2600 CPU @ 3.40GHz || Intel T6500 @ 2.10GHz
|-
| '''NIC''' || 0.9 || 5,3 sec || 17,3 sec
|-
| '''PHP''' || 5.6.23 || 10,4 sec ||
|-
| '''Python''' || 2.7 || 25,6 sec || 118 sec
|-
| '''Lua''' || 5.2 || 6,1 sec ||
|}

Es empfiehlt sich nicht, obiges Programm auf dem STM32 mit dem oben verwendeten Startwert 100000 laufen zu lassen. Dabei muss man schon seeeehr lange warten, da der STM32 doch um einiges langsamer ist als ein moderner Intel-Prozessor. Für eigene Messungen auf dem STM32 empfiehlt sich ein Startwert von 10000, also eine Größenordnung geringer.

= Anhang =

=== Compiler-Warnungen ===

'''function 'foo' not used.'''

Die Funktion namens foo ist zwar definiert, wird aber nicht aufgerufen.

'''variable 'foo' not used.'''

Die Variable 'foo' wird zwar definiert, aber nicht verwendet.

'''variable 'foo' set but not used.'''

Die Variable 'foo' wird zwar zwischenzeitlich gesetzt, aber sonst nicht weiter verwendet.

'''local variable 'foo' shadows global variable 'foo' defined in line NN.'''

Die lokale Variable 'foo' überdeckt die globale gleichnamige Variable. Dies kann je nach Kontext zu unerwünschten Effekten führen: In der Funktion, wo die lokale Variable definiert wurde, wird dann der Wert dieser lokalen Variablen verwendet, in allen anderen Funktionen jedoch der Wert der globalen Variablen.

=== Compiler-Fehlermeldungen ===

'''return with a value, in function returning void.'''

Die definierte void-Funktion liefert unzulässigerweise einen Return-Wert zurück.

'''return with no value, in function returning non-void.'''

Die definierte Funktion mit Datentyp als Rückgabewert liefert unzulässigerweise keinen Return-Wert zurück.

'''keyword 'foo' unexpected.'''

Das Schlüsselwort 'foo' ist an der angegebenen Stelle unerwartet und damit falsch.

'''Variable 'foo' already defined.'''

Die Variable 'foo' wurde bereits definiert.

'''break stack overflow.'''

Die Schachtelungstiefe von Schleifen ist zu tief und somit kann die aktuelle Schleife nicht mehr durch einen Break-Befehl unterbrochen werden.

'''continue stack overflow.'''

Die Schachtelungstiefe von Schleifen ist zu tief und somit kann die aktuelle Schleife nicht mehr durch einen Continue-Befehl am Anfang der Schleife fortgesetzt werden.

'''double negation not allowed.'''

Eine doppelte Negation eines numerischen Wertes ist nicht erlaubt.

'''empty expression.'''

Der erwartete arithmetische Ausdruck ist leer.

'''invalid argument type 'foo' in function 'bar', argument #NN.'''

Der angegebene Parameter an NN-ter Stelle hat einen ungültigen Datentyp.

'''main must be defined as function returning void.'''

Die main-Funktion muss stets vom Datentyp void definiert werden.

'''no main function found.'''

Ein NIC-Programm muss immer eine main-Funktion als Startpunkt enthalten.

'''function 'foo' already defined.'''

Die Funktion namens 'foo' wurde bereits definiert.

'''function 'foo' returns void.'''

Es wird versucht, den Rückgabewert einer Funktion 'foo' weiterzuverwenden, obwohl der Datentyp dieser Funktion 'void' ist.

'''function 'foo' undefined.'''

Die aufgerufene Funktion 'foo' ist nicht definiert.

'''unterminated string.'''

Die angegebene Zeichenkette wurde nicht mit dem Anführungszeichen terminiert.

'''missing 'endfoo' at end of file.'''

Ein geöffneter Kontrollblock wurde nicht geschlossen.

'''missing arguments for function 'foo'.'''

Es wurden keine Parameter für die Funktion foo angegeben.

'''missing closing bracket.'''

Eine geöffnete Klammer wurde nicht geschlossen.

'''no matching ')' found.'''

Zu einer geschlossenen Klammer wurde die dazugehörende geöffnete Klammer nicht gefunden.

'''missing return before 'endfunction'.'''

Das Return-Statement unmittelbar vor dem Ende der Funktion fehlt.

'''no compare operator found.'''

Es wurde kein Vergleichsoperator im Ausdruck angegeben.

'''number of arguments wrong for call of function 'foo', expected NN.'''

Die Anzahl der Parameter für den Aufruf der Funktion 'foo' ist falsch, richtig ist NN.

'''syntax error. Use brackets around negative expression.'''

Ein Ausdruck mit einem negativen Operanden (wie z.B. "3 * -2") bedeutet einen Syntax-Error. In diesem Fall muss der zu negierende Operand geklammert werden, also: "3 * (-2)".

'''too many arguments for function 'foo'.'''

Zu viele Parameter für den Aufruf der Funktion namens 'foo'.

'''too many closing brackets.'''

Der Ausdruck enthält zu viele geschlossene Klammern.

'''too many open brackets.'''

Der Ausdruck enthält zu viele geöffnete Klammern.

'''too many expressions.'''

Der Ausdruck ist zu komplex.

'''variable 'foo' already defined.'''

Die Variable 'foo' wurde bereits definiert.

'''variable 'foo' not defined.'''

Die Variable 'foo' wurde vorher nicht definiert.

NIC

2017-06-20T13:33:33Z

Klause: Lang lebe Easy AVR

Von '''Frank M. ([http://www.mikrocontroller.net/user/show/ukw ukw])'''

'''Dies ist eine vorläufige und höchst unvollständige Beschreibung einer Software, die noch in Entwicklung, d.h. im Alpha-Stadium ist. Ein entsprechender Thread über NIC wird im Forum "Projekte & Code" eröffnet, sobald eine Beta-Version des NIC-Interpreters verfügbar ist. Details können sich durchaus noch ändern, daher ist diese Dokumentation zur Zeit noch rein als PRELIMINARY zu sehen.'''

NIC ist eine einfache strukturierte Programmiersprache, welche speziell für die Mikrocontroller-Familie STM32 entwickelt wurde. Da der NIC-Interpreter in C geschrieben ist, kann dieser auch auf andere 32-Bit-Mikrocontroller portiert werden.

Ebenso sind NIC-Programme auch unter Linux und Windows lauffähig, wobei dies eher der Entwicklung und des Debuggings des NIC-Interpreters dient. Ein in NIC geschriebenes Programm wird zunächst von dem NIC-Compiler "nicc" auf dem Host in einen Metacode übersetzt, welcher durch den NIC-Interpreter "nici" auf dem Mikrocontroller-System sehr effizient abgearbeitet werden kann. Die üblichen Übersetzungsdauern liegen meist unter einer Sekunde, die Geschwindigkeit, mit der die Befehle dann von nici ausgeführt werden, liegen bei ca. 100.000 bis 250.000 Befehlen pro Sekunde - je nach verwendetem STM32. Als Host zum Compilieren von NIC-Programmen dient zur Zeit ein PC-System mit Linux oder Windows, später wird dies auch ein vorgeschalteter µC wie ein ESP8266 sein, der gleichzeitig ein Filesystem (SPIFFS) bietet, um die Compilate zu speichern und damit permanent vorzuhalten. Zudem erweitert dieser dann das NIC-Laufzeitsystem um Netzwerkfunktionalitäten.

Motivationen zur Entwicklung eines solchen Interpreters gibt es einige: Zum einen wird Einsteigern ein sehr einfaches System geboten, sich in die Welt von 32-Bit-Mikrocontrollern einzuarbeiten, zum anderen schrecken viele Umsteiger von 8-Bit-Systemen auf 32-Bit-Systeme vor der Komplexität der 32-Bitter zurück. Genau diese Komplexität wird in die NIC-Bibliotheksfunktionen verlegt, so dass man sich als NIC-Programmierer nicht damit im Detail befassen muss. Ein erfahrener Programmierer jedoch kann die NIC-Laufzeitbibliothek durch eigene C-Module erweitern, um diese dann im NIC-Programm unter Nutzung der NIC-API zu nutzen. So ist es dann zum Beispiel auf einfache Art und Weise möglich, eine Kette von WS2812-LEDs per DMA zu steuern, ohne sich im Detail mit der Programmierung einer DMA auseinandersetzen zu müssen.

NIC als strukturierte Programmiersprache ähnelt in manchen Teilen C, PHP, Pascal oder auch Basic. Datentypen müssen jedoch zum Beispiel im Gegensatz zu PHP stets angegeben werden. Trotzdem ist stets eine implizite Typumwandlung (zum Beispiel von Integer-Werten in Strings oder umgekehrt) möglich, die klaren Regeln unterworfen ist. Casts wie in C sind dabei nicht notwendig.

Natürlich ist NIC als Interpretersprache nicht so schnell wie ein C-Programm, kann sich aber trotzdem bezüglich Ausführungsgeschwindigkeit durchaus sehen lassen. Ein erfahrener C-Programmierer kann zeitkritische Programmteile in C erstellen, um sie dann als NIC-Bibliotheksfunktionen komfortabel zu nutzen. Der NIC-Interpreter ist ca. doppelt so schnell wie ein adäquates PHP-Programm und meist 3-5 mal schneller als vergleichbare Python-Programme, siehe auch [[NIC#Benchmarks|Benchmarks]].

Wozu einen schnellen ARM erst programmier-freundlich abbremsen wenn man dann gleich einen AVR verwenden kann! Die Einarbeitung in ARM und diese Xte neue Programmier-Sprache ist damit auch gespart!

Wozu einen schnellen ARM erst programmier-freundlich abbremsen wenn man dann gleich einen AVR verwenden kann! Die Einarbeitung in ARM und eine Xte neue Programmier-Sprache ist damit auch gespart!

= Compiler nicc =

Der Compiler nicc ist für Windows und Linux verfügbar.

=== Aufruf unter Windows ===
nicc [-v] [-u COMx] datei.nic

Die in eckigen Klammern angegebenen Parameter sind optional.

Optionen:
-v : Verbose, gibt Statistiken, wie zum Beispiel Optimierungen von Ausdrücken aus
-u COMx: Upload der compilierten Datei über die seriellen Schnittstelle COMx

Der NIC-Quelltext wird dabei in einen optimierten, maschinenunabhängigen Objekt-Code übersetzt. Das Kompilat legt nicc in der Datei datei.nico ab, welche (zur Zeit noch) eine ASCII-Datei ist. Gibt man per Upload-Parameter die serielle Schnittstelle an, wird das Kompilat direkt auf den µC geladen. Der Interpreter legt den Objekt-Code dann als binäre Datenstrukturen im RAM ab, um diese dann effizient abzuarbeiten.

Beispiel:
nicc -u com5 lauflicht1.nic

=== Aufruf unter Linux ===
nicc [-v] datei.nic

Hier fehlt (noch) die Upload-Funktion. Dafür ist es aber möglich, das Kompilat direkt unter Linux zu starten, siehe nächstes [[NIC#Interpreter_nici|Kapitel]].

=== Optimierungen ===

Der NIC-Compiler bringt sämtliche arithmetische Ausdrücke wie "3 * 4 + x + 1 << 6" nach den Prioritätenregeln (Punkt- vor Strichrechnung usw.) in die UPN-Notation - auch Postfix genannt. Dabei werden konstante Teilausdrücke wie "3 * 4" direkt durch das Ergebnis "12" zur Compilezeit ersetzt. Dadurch muss der Interpreter sich nicht mehr um solche Regeln kümmern, sondern braucht nur noch einen Stack abzuarbeiten, auf dem alle Operanden und Operatoren schon fix und fertig in der richtigen Reihenfolge vorliegen.

Desweiteren werden zur Compilezeit sämtliche Sprungadressen, die durch Schleifen wie loop, repeat, for, while, break und continue entstehen, vorher ausgerechnet, so dass der Interpreter je nach Bedingung nur noch Sprungadressen laden muss. Desweiteren sind bei Aufruf von Bibliotheksfunktion (wie zum Beispiel [[NIC#Bibliothek_gpio|GPIO]]) die zu übergebenden Daten direkt zum Bedienen der API für Bibliotheksfunktionen vorbereitet. Diese können damit schnell und effektiv bedient werden.

Häufig vorkommende Konstrukte wie "n = n + 1" werden in spezielle Increment- und Decrement-Befehle gewandelt, die vom NIC-Interpreter ohne Evaluierung des arithmetischen Ausdrucks rechts vom Gleichheitszeichen direkt intern auf den Variableninhalt wirken.

= Interpreter nici =

Der NIC-Interpreter nici wird im Flash des STM32 installiert (HEX-Datei). Dieser wartet dann auf dem UARTx auf das übersetzte NIC-Programm, um es direkt nach dem Upload auszuführen.

Für Entwickler:

Man kann den Interpreter unter Linux und Windows direkt von der Kommandozeile aus starten.

Übersetzen:
nicc datei.nic
Ausführen:
nici datei.nico

STM32-spezifische Funktionen wie gpio.toggle() laufen dabei auf eine Stub-Funktion geleitet, welche die Laufzeitparameter als Info ausgeben. Alle anderen Funktionen werden jedoch ordnungsgemäß ausgeführt. Trotzdem ist der Interpreter nicc unter Linux bzw. Windows eher zur Weiterentwicklung und Debugging des Compilers und des Interpreters gedacht und nicht dafür, Programme für Linux/Windows in der Programmiersprache NIC zu entwickeln - auch wenn das so möglich wäre.

= main-Funktion =

Jedes NIC-Programm muss eine Funktion namens "main()" definieren. Das ist der Startpunkt eines jeden NIC-Programms. Die Funktion main() liefert stets keinen Rückgabewert zurück und muss daher immer mit dem Funktionstyp "void" angegeben werden. Außerdem erhält sie keine Parameter, daher ist der Inhalt zwischen den Klammern "(" und ")" leer.

Damit ergibt sich als Funktionsrumpf:

<syntaxhighlight lang=pas>
function void main ()
...
endfunction
</syntaxhighlight>

== Hello World ==

Ale Einstiegsprogramm einer Programmiersprache wird oft ein einfaches Hello-World-Programm angegeben, welches die Zeichenkette "Hello, World" ausgibt. Für Mikrocontroller jedoch ist es oft das Blinken einer an den Mikrocontroller angeschlossenen LED.

Das folgende NIC-Programm lässt die LED auf einem Nucleo-Board blinken:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT)
loop
gpio.set (GPIOA, 5)
time.delay (500)
gpio.reset (GPIOA, 5)
time.delay (500)
endloop
endfunction
</syntaxhighlight>

Die LED wird dabei für 500msec ein- und dann für 500msec wieder abgeschaltet. Durch die Kontrollstruktur "loop" läuft das Programm in einer Endlosschleife und kann nur durch Drücken der RESET-Taste gestoppt werden. Hier werden drei interne Bibliotheksfunktionen der Familie '''[[NIC#Bibliothek_gpio|gpio]]''' aufgerufen, nämlich [[NIC#gpio.init_.28.29|gpio.init()]], [[NIC#gpio.set_.28.29|gpio.set()]] und [[NIC#gpio.reset_.28.29|gpio.reset()]]. Die erste Funktion [[NIC#gpio.init_.28.29|gpio.init()]] initialisiert den Pin A5 des STM32 als Ausgabe-Pin durch Angabe des Schlüsselwortes "OUTPUT", die Funktion [[NIC#gpio.set_.28.29|gpio.set()]] setzt dann den Pin auf HIGH-Pegel, die Funktion [[NIC#gpio.reset_.28.29|gpio.reset()]] wieder auf LOW-Pegel. Die Bibliotheksfunktion time.delay() lässt den Mikrocontroller eine bestimmte Anzahl von Millisekunden warten - hier 500msec.

Am Pin A5 ist bei den Nucleo-Boards eine board-interne grüne LED angeschlossen. Diese blinkt dann bei der Ausführung des Programms. Um die board-interne blaue LED eines STM32F103-Mini-Development-Boards anzusprechen, muss der Port GPIOA durch GPIOC ersetzt und die Pinnummer auf 13 geändert werden, denn hier ist die LED an Pin C13 angeschlossen.

Durch Anwendung der Funktion [[NIC#gpio.toggle_.28.29|gpio.toggle()]] kann der Code noch vereinfacht werden:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT)
loop
gpio.toggle (GPIOA, 5)
time.delay (500)
endloop
endfunction
</syntaxhighlight>

Hier wechselt die Funktion [[NIC#gpio.toggle_.28.29|gpio.toggle()]] automatisch den jeweiligen LOW- bzw. HIGH-Pegel und lässt die LED mit einer Frequenz von einem Hertz blinken.

Wie wir später noch sehen werden, kann das Blinken der LED auch timergesteuert ausgeführt werden. Dann macht der NIC-Interpreter das "nebenbei", d.h. wir haben in der Hauptschleife Zeit für andere Dinge.

Hier schon mal das Programm, erklärt wird es dann später unten (alarm-Funktionen):

<syntaxhighlight lang=pas>
function void blink ()
gpio.toggle (GPIOA, 5)
endfunction

function void main ()
gpio.init (GPIOA, 5, OUTPUT)
alarm.set (500, function.blink) // blink() alle 500msec automatisch aufrufen lassen

loop
// ... // Hier koennen nun komplett andere Aufgaben erledigt werden!
endloop
endfunction
</syntaxhighlight>

Wie schnell ist nun der NIC-Interpreter? Wir können nun durch Entfernen des delay-Aufrufs die LED mit maximaler Geschwindigkeit blinken lassen und dann die Zeiten messen:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103-Mini-Board: LED=C13
repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat
endfunction
</syntaxhighlight>

Die Endlosschleife '''[[NIC#loop|loop]]''' wurde hier durch ein '''[[NIC#repeat|repeat]]''' ersetzt. Hier können wir angeben, wie oft eine Schleife durchlaufen wird. In unserem Beispiel sind es 1.000.000 mal. Das Blinken selbst wird man aufgrund der Geschwindigkeit nicht mehr erkennen können, jedoch leuchtet die LED weiterhin deutlich sichtbar - bis das Programm nach einer Million Schleifendurchläufen beendet wird. Man wird dabei mit der Stoppuhr auf einem STM32F411RE-Nucleo-Board ungefähr 4 Sekunden messen.

Der Messvorgang geht aber auch genauer:

<syntaxhighlight lang=pas>
function void main ()
int start
int stop
int diff

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

stop = time.millis ()
diff = stop - start
console.println (diff)
endfunction
</syntaxhighlight>

Hier werden nun erstmals Variablen namens "start" und "stop" verwendet. Sie entsprechen der internen "Uhrzeit" des Mikrocontrollers seit dem letzten Boot in Millisekunden. Durch die Funktion [[NIC#time.millis_.28.29|time.millis()]] können wir jederzeit die interne Zeit des Mikrocontrollers abrufen und in einer Variablen speichern. Deshalb wird jemals einmal vor und nach dem Schleifendurchlauf die Zeit gestoppt. Die Differenz wird in der Variablen "diff" gespeichert und dann mittels der Funktion [[NIC#console.println_.28.29|console.println()]] in Millisekunden auf der Console ausgegeben. Die Console ist dabei die serielle UART-Schnittstelle, die bei jedem Nucleo on-board dabei ist. Bei einem STM32F103-Mini-Development-Board muss ein zusätzlicher UART-Adapter angeschlossen werden, siehe entsprechendes Kapitel weiter unten. Bei einem mit 100MHz getakteten STM32F411RE sind dies ca. 3900msec. Das Programm schafft also ungefähr 255.000 Schleifendurchläufe pro Sekunde. Bei einem mit 85MHz getakteten STM32F401RE sind es noch knapp 200.000 Schleifendurchläufe, beim STM32F103 mit 72MHz-Takt ca. 180.000 Durchläufe.

Das Programm kann aber noch stärker vereinfacht werden. Zunächst eliminieren wir die Variable "diff", indem wir die Differenz der Werte "stop" und "start" direkt der Funktion [[NIC#console.println_.28.29|console.println()]] übergeben:

<syntaxhighlight lang=pas>
function void main ()
int start
int stop

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

stop = time.millis ()
console.println (stop - start)
endfunction
</syntaxhighlight>

Also: Funktionen können nicht nur einfache Werte, sondern auch algebraische Ausdrücke direkt übergeben werden.

Aber es geht noch einfacher. Jetzt verzichten wir auch noch auf die Variable "stop":

<syntaxhighlight lang=pas>
function void main ()
int start

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

console.println (time.millis () - start)
endfunction
</syntaxhighlight>

Als Funktionsparameter können also auch Rückgabewerte anderer Funktionen oder noch komplexere Ausdrücke angegeben werden.

Der Vollständigkeit halber noch das Hello-World-Programm im klassischen Sinne:

<syntaxhighlight lang=pas>
function void main ()
console.println ("Hello, World!")
endfunction
</syntaxhighlight>

Das sieht jetzt - nachdem wir bereits eine LED auf mehrere Art und Weise haben blinken lassen - doch viel zu einfach aus ;-)

= Kommentare =

Kommentare werden durch einen doppelten Schrägstrich eingeleitet, also durch '//'. Alle danach aufgeführten Zeichen gelten als Kommentar und werden vom NIC-Compiler nicc ignoriert.

Beispiel:
<syntaxhighlight lang=pas>
gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
</syntaxhighlight>

= Datentypen =

Die Datentypen von Funktionen und Variablen müssen stets angegeben werden. Eine implizite Definition durch einfache Aufführung eines einer Funktion, eines Funktionsparameters oder einer Variablen wie in PHP oder Python ist nicht möglich.

Die Datentypen von Variablen und Funktionen sind Integer, Byte oder String, evtl. später auch noch "Float". Bei Funktionen ist zusätzlich der Datentyp "void" möglich, um anzugeben, dass die Funktion '''keinen''' Funktionswert zurückliefert.

* '''int''' - Datentyp Integer, Breite 32 Bit, vorzeichenbehaftet
* '''byte''' - Datentyp Byte, Breite 8 Bit, vorzeichenlos
* '''string''' - Datentyp Zeichenkette
* '''void''' - kein Returnwert (nur Funktionen)

Funktionen können als Rückgabewerte nicht nur die oben aufgeführten Typen zurückliefern, sondern auch vom Typ '''void''' sein, um anzuzeigen, dass sie '''keinen''' Rückgabewert liefern.

Beispiel:

<syntaxhighlight lang=pas>
function void errormessage (string message)
console.println ("error: " : message)
endfunction
</syntaxhighlight>

Bei allen anderen Datentypen muss eine Funktion einen Wert per return-Befehl zurückgeben.

= Konstanten =

=== Integer-Konstanten ===

Integer-Konstanten sind einfache Zahlenfolgen wie 1234 oder -1234. Ohne entsprechendes Prefix sind dies Dezimalzahlen. Möchte man einen numerischen Wert in hexadezimal angeben, ist 0x voranzustellen, also zum Beispiel 0x1234. Zahlen können auch im Binärsystem angegeben werden. In diesem Fall ist 0b voranzustellen, z.B. 0b10011100.

Beispiele:

* 1234 ist eine Dezimalzahl
* 0x23AF ist eine Hexadezimalzahl
* 0b01010101 ist eine Binärzahl

=== String-Konstanten ===

String-Konstanten werden in Anführungszeichen angegeben.

Beispiel:

* "Das ist eine String-Konstante"

= Variablen =

Variablen werden definiert durch die Angabe des Datentyps und des Namens.

Beispiel:

<syntaxhighlight lang=pas>
int nummer
byte data
string zeichenkette
</syntaxhighlight>

Es gibt lediglich drei verschiedene Datentypen: '''int''' oder '''byte''' oder '''string'''.

Der Datentyp int definiert einen 32-Bit-Integer, ist also vorzeichenbehaftet. Der Datentyp byte entspricht dem Byte, kennt also keinerlei Vorzeichen und ist 8 Bit breit. Der Typ string ist eine Zeichenkette.

=== Globale Variablen ===

Wird eine Variable außerhalb von Funktionen definiert, ist sie eine globale Variable. Auf globale Variablen kann funktionsübergreifend zugegriffen werden - und zwar ab der Zeile, wo sie definiert wird. Eine globale Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang des Quelltextes geschehen, jedoch spätestens dann, wenn auch auf sie zugegegriffen werden soll.

Beispiel:
<syntaxhighlight lang=pas>
int maxleds

function void main ()
maxleds = 30
console.println (maxleds) // Ausgabe: 30
endfunction
</syntaxhighlight>

Globale Variablen können auch direkt bei der Definition initialisiert werden. Dies muss dann - je nach Typ - eine numerische Konstante oder eine Stringkonstante sein.

Beispiel:
<syntaxhighlight lang=pas>
int maxleds = 30

function void main ()
console.println (maxleds) // Ausgabe: 30
maxleds = 40
console.println (maxleds) // Ausgabe: 40
endfunction
</syntaxhighlight>

=== Lokale Variablen ===

Wird eine Variable innerhalb einer Funktion definiert, dann gilt sie nur innerhalb dieser Funktion. Bei jedem Funktionsaufruf werden die lokalen Variablen neu erzeugt und (im Gegensatz z.B. zu C) neu mit 0 (für int) bzw. Leerstring "" (für string) initialisiert. Ruft die Funktion sich selbst rekursiv auf, wird jedesmal ein neuer lokaler Variablensatz erzeugt. Lokale Variablen werden nach dem Verlassen der jeweiligen Funktion wieder zerstört und sind dann nicht mehr verfügbar.

Eine lokale Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang einer Funktion stehen. Jedoch kann sie überall innerhalb der Funktion verwendet werden - frühestens aber unterhalb der erfolgen Definition.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
int var
var = 3 * 2
console.println (var)
endfunction
</syntaxhighlight>

Auch lokale Variablen können direkt bei der Definition initialisiert werden. Dies muss dann - je nach Typ - eine numerische Konstante oder eine Stringkonstante sein.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
int var = 3
string message = "Die Variable hat den Inhalt "
console.println (message : var)
endfunction
</syntaxhighlight>

Arithmetische Ausdrücke sind zur Zeit nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden Integer-Variablen mit 0, String-Variablen mit "" (Leerstring) initialisiert.

=== Statische Variablen ===

Wird eine Variable innerhalb einer Funktion statisch definiert, dann gilt für sie erst einmal dasselbe wie für lokale Variablen. Der einzige Unterschied: Sie wird nur einmal beim Start des Programms erzeugt und beim Verlassen der Funktion auch nicht zerstört. Das heisst: Die Variable (und deren Inhalt) "lebt" während der ganzen Laufzeit des Programms. Außerhalb der Funktion, wo sie definiert wird, kann auf sie mit dem Namen "function.variable" zugegriffen werden, wenn es unbedingt nötig ist, siehe untenstehendes Beispiel.

Werden statische Variablen direkt bei der Definition initialisiert, so haben sie diesen Wert bereits beim Start des Programms.

Eine statische Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang einer Funktion stehen. Jedoch kann sie überall innerhalb der Funktion verwendet werden - frühestens unterhalb der erfolgen Definition.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
static int var = 4
var = 3 * var
console.println (var) // Ausgabe: 12
endfunction

function void main ()
console.println (foo.var) // Ausgabe: 4
foo ()
console.println (foo.var) // Ausgabe: 12
endfunction
</syntaxhighlight>

Statische Variablen können auch außerhalb einer Funktion definiert werden. Da diese Definition semantisch keinen Unterschied zu der Definition einer globalen Variablen macht, werden globale statische Variaben identisch zu globalen Variablen behandelt.

Beim Compilieren erscheint dann eine Warnung:

warning line 1: keyword 'static' takes no effect here.

Beispiel:
<syntaxhighlight lang=pas>
static int var = 3
function void main ()
string message = "Die Variable hat den Inhalt "
console.println (message : var)
</syntaxhighlight>

Arithmetische Ausdrücke sind ebenso wie bei den nicht-statischen Variaben nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden Integer-Variablen mit 0, String-Variablen mit "" (Leerstring) initialisiert.

=== Konstante Variablen ===

"Konstante Variablen" sind auf den ersten Blick ein Widerspruch in sich. Wie kann eine Konstante variabel sein?

Die Antwort: Eine konstante Variable wird von der Semantik wie eine normale Variable behandelt. Allerdings kann deren Wert nicht geändert werden. Daher sollte man direkt bei der Definition solche Variablen auch initialisieren. Unterlässt man dies, haben sie halt den Wert 0 bzw. "" (Leerstring) - je nach Typ.

Konstante Variablen sollte man nach Konvention ausschließlich in Großbuchstaben schreiben. Sie ähneln nämlich den Preprozessor-Konstanten in C. Mit der Großschreibung deutet man an: Dies ist eine Konstante!

Der Inhalt der Variablen wird auch nicht erst zur Laufzeit in arithmetischen Ausdrücken ermittelt, sondern bereits während des Compilierens in die entsprechenden Ausdrücke eingesetzt.

const-Variablen müssen vom Typ int oder string sein. byte ist hier nicht erlaubt - was aber keine Einschränkung bedeutet.

Beispiel:
<syntaxhighlight lang=pas>
const int MAXLEDS = 30 // 30 LEDs

function void foo ()
int var = 4
var = MAXLEDS * var
console.println (var) // Ausgabe: 120
endfunction

function void main ()
foo ()
console.println (MAXLEDS) // Ausgabe: 30
endfunction
</syntaxhighlight>

Arithmetische Ausdrücke sind ebenso wie bei den nicht-statischen Variaben nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden konstante Variablen mit 0 bzw. mit "" (Leerstring) - je nach Typ - initialisiert.

Der Versuch, einer konstante Variablen später im Programm einen anderen Wert zuzuweisen, wird bereits beim Compilieren mit einer Fehlermeldung quittiert.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30 // 30 LEDs

function void main ()
MAXLEDS = 40
console.println (MAXLEDS)
endfunction
</syntaxhighlight>

Die Fehlermeldung lautet dann:

error line 4: variable 'MAXLEDS' is of type 'const'.

= Arrays =

Variablen können auch als Arrays verwendet werden. Dabei wird bei der Definition die Größe des Arrays in eckigen Klammern angegeben. Diese Größe muss entweder durch eine Zahl oder den Inhalt einer "konstanten Integer-Variablen" (const int) angegeben werden. Arrays beginnen immer mit dem Index 0 und enden bei der Arraygröße minus 1. Zugriffe außerhalb dieses Bereichs werden zur Laufzeit abgefangen. In diesem Fall wird eine entsprechende Fehlermeldung auf der Console ausgegeben und das Programm beendet.

Arrays können sowohl global als auch lokal angelegt werden. Auch static Arrays sind möglich. Konstante Arrays gibt es jedoch nicht.

Beispiel:

<syntaxhighlight lang=pas>
const int SIZE = 5
int nummer[7]

function void main ()
string zeichenkette[SIZE]
int i

for i = 0 to 7 - 1
nummer[i] = 2 * i
endfor

console.println (nummer[5]) // Ausgabe: 10

for i = 0 to SIZE - 1
zeichenkette[i] = "Hello " : i
endfor

console.println (zeichenkette[3]) // Ausgabe: "Hello 3"
endfunction
</syntaxhighlight>

= Funktionen =

=== Bibliotheksfunktionen ===

=== Eigene NIC-Funktionen ===

Eine Funktion wird definiert durch folgenden Block:
<syntaxhighlight lang=pas>
function TYPE FUNCTIONNAME (TYP PARAMETER1, TYP PARAMETER2, ...)
...
endfunction
</syntaxhighlight>

Dabei kann TYPE '''int''', '''string''' oder '''void''' sein. FUNCTIONNAME ist einfach der Funktionsname. PARAMETER1 bis PARAMETERn sind die optionalen Funktionsparameter.

Der einfachste Fall ist die main-Funktion, die immer vorhanden sein muss:

<syntaxhighlight lang=pas>
function void main ()
...
endfunction
</syntaxhighlight>

Möchte man das oben angegebene Blink-Programm als eigene Funktion einbauen, dann wäre das folgende Programm eine Lösung:

<syntaxhighlight lang=pas>
function void blink (int factor, int delay)
repeat factor
gpio.toggle (GPIOA, 5)
time.delay (delay)
endloop
endfunction

function void main ()
gpio.init (GPIOA, 5, OUTPUT)
blink (20, 200)
blink (10, 500)
endfunction
</syntaxhighlight>

Der erste Aufruf von blink() lässt die LED 20 mal schnell den Zustand wechseln (Verzögerungszeit 200 msec), der zweite Aufruf lässt die LED lediglich 10 mal den Zustand wechseln, dafür aber langsamer (Verzögerungszeit 500 msec).

=== Eigene NIC-Klassen ===

Später.

= Typumwandlungen =

=== String to Integer ===

Wird einer Integer-Variablen ein String zugewiesen, wird lediglich deren numerischer Inhalt zu Anfang des Strings als Integer-Wert übernommen. Enthält der String überhaupt keinen numerischen Wert zu Anfang, ist der Integer-Wert des Strings 0.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = "1234abc"
console.println (zahl)
endfunction
</syntaxhighlight>

Die Variable Zahl enthält nach der Zuweisung den numerischen Wert 1234.

Dasselbe gilt für Funktionen, die einen Integer-Wert als Parameter erwarten, hier jedoch ein String übergeben wird.

Beispiel:

<syntaxhighlight lang=pas>
function int mult (int a, int b)
return a * b
endfunction

function void main ()
int ergebnis
ergebnis = mult ("2", 3)
console.println (ergebnis)
endfunction
</syntaxhighlight>

=== Integer to String ===

Wird einer String-Variablen ein Integer-Wert zugewiesen, wird dieser automatisch in einen String umgewandelt. Dasselbe gilt für Funktionsparameter, wenn die Funktion einen String als Parameter erwartet.

<syntaxhighlight lang=pas>
function void main ()
string zeichenkette
zeichenkette = 1234
console.println (zeichenkette)
endfunction
</syntaxhighlight>

Ebenso gilt dies für den String-Operator ':', welcher zwei Strings zu einem String zusammensetzt:

<syntaxhighlight lang=pas>
function int mult (int a, int b)
return a * b
endfunction

function void main ()
int ergebnis
string meldung
ergebnis = mult ("2", 3)
meldung = "Das Ergebnis ist " : ergebnis
console.println (meldung)
endfunction
</syntaxhighlight>

Bei dem String-Operator ':' können auch rein numerische Operanden zu einem String zusammengesetzt werden:

<syntaxhighlight lang=pas>
function void main ()
string meldung
meldung = 123 : 456
console.println (meldung)
endfunction
</syntaxhighlight>

Hier wird dann der String "123456" auf der Console ausgegeben.

Kombiniert man beide Typwandlungen (Integer->String und String->Integer), kann man den String-Operator auch auf rein numerische Ausdrücke anwenden, wobei die Zuweisungsvariable auch wieder eine Integer-Variable ist:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 123 : 456
console.println (zahl)
endfunction
</syntaxhighlight>

Hier werden die Zahlen 123 und 456 zunächst in Strings umgewandelt, dann zu einem String zusammengesetzt und bei der Zuweisung wieder zurück in einen Integer-Wert gewandelt. Die Variable 'zahl' enthält nach der Zuweisung den Integer-Wert 123456.

= Kontrollstrukturen =

=== Zuweisung ===

Syntax: VARIABLE = AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
string zeichenkette
int ergebnis

zeichenkette = "Das Ergebnis lautet: "
ergebnis = 1234 * 2
console.println (zeichenkette : ergebnis)
endfunction
</syntaxhighlight>

=== if ===

Syntax:

<syntaxhighlight lang=pas>
if BEDINGUNG1
...
elseif BEDINGUNG2
...
elseif BEDINGUNG3
...
else
...
endif
</syntaxhighlight>

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int zahl

zahl = 33

if zahl < 10
console.println ("Die Zahl is kleiner 10")
elseif zahl < 100
console.println ("Die Zahl is kleiner 100")
elseif zahl > 100
console.println ("Die Zahl is groesser 100")
else
console.println ("Die Zahl is gleich 100")
endif
</syntaxhighlight>

=== loop ===

loop beginnt eine Endlosschleife. Diese kann lediglich mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Endlosschleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
loop
...
endloop
</syntaxhighlight>

Vorzeitiger Abbruch:

<syntaxhighlight lang=pas>
loop
...
break
...
endloop
</syntaxhighlight>

Vorzeitiger Sprung zum Anfang der Schleife

<syntaxhighlight lang=pas>
loop
...
continue
...
endloop
</syntaxhighlight>

Beispiel:

Das folgende Programm lässt die Board-LED auf einem Nucleo-Board leuchten, bis der User-Button gedrückt wird.

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // set pin C13 (user button) to input, has extern pullup
gpio.init (GPIOA, 5, OUTPUT) // board LED = A5
gpio.set (GPIOA, 5) // switch LED on

loop
if gpio.get (GPIOC, 13) = LOW // button pressed?
gpio.set (GPIOA, 5) // switch LED off
break // break loop
endif
endloop
endfunction
</syntaxhighlight>

=== repeat ===

repeat beginnt eine Schleife, welche genau N-mal durchlaufen wird. Die repeat-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
repeat N
...
endrepeat
</syntaxhighlight>

N kann dabei ein beliebiger arithmetischer Ausdruck sein.

Beispiel:

Das folgende Programm gibt die Zahlen 1 bis 9 auf der Console aus.

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 1
repeat 9
console.println (zahl)
zahl = zahl + 1
endrepeat
endfunction
</syntaxhighlight>

=== while ===

Die while-Schleife wird durchlaufen, solange die angegebene Bedingung gegeben ist. Arithmeische Ausdrücke innerhalb der Bedingung werden bei jedem Schleifendurchlauf neu berechnet. Die while-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
while BEDINGUNG
...
endwhile
</syntaxhighlight>

Beispiel:

Das folgende Programm gibt die Zahlen 1 bis 9 auf der Console aus.

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 1
while zahl < 10
console.println (zahl)
zahl = zahl + 1
endwhile
endfunction
</syntaxhighlight>

=== for ===

Die for-Schleife wird für eine anzugebene Schleifenvariable solange durchlaufen, bis der angegebene Stopwert überschritten wird. Optional kann eine Schrittgröße für die Schleifenvariable angegeben werden. Standardmäßig ist diese 1, d.h. die Schleifenvariable wird mit jedem neuen Durchlauf inkrementiert. Ist der Stopwert kleiner als der Startwert, wird die Schleifenvariable mit jedem Durchlauf dekrementiert.

Die for-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
for VARIABLE = STARTWERT to STOPWERT [STEP x]
...
endfor
</syntaxhighlight>

VARIABLE muss eine Integer-Variable sein, STARTWERT und STOPWERT ein beliebiger arithmetischer Ausdruck. Im Gegensatz zur while-Schleife, in welcher die Schleifen-Bedingung und damit die arithmetische Ausdrücke jeweils immer neu evaluiert werden, wird bei der for-Schleife STARTWERT und STOPWERT nur einmal berechnet, nämlich unmittelbar vor dem Betreten der Schleife.

Wird kein Step-Wert angegeben, wird die Laufvariable nach jedem Schleifendurchlauf um 1 erhöht. Wird ein abweichender Step-Wert angegeben, wird die Laufvariable um den angegebenen Wert erhöht. Ist der Step-Wert negativ, wird die Variable um den angegebenen Wert erniedrigt.

Beispiel:

Das folgende Programm gibt zunächst die Zahlen 1 bis 9 auf der Console aus. Anschließend werden die Werte von 9 bis 1 rückwärts zählend ausgegeben:

<syntaxhighlight lang=pas>
function void main ()
int zahl
for zahl = 1 to 9
console.println (zahl)
endfor
for zahl = 9 to 1 step -1
console.println (zahl)
endfor
endfunction
</syntaxhighlight>

=== switch ===

* switch, break

=== return ===

* return

= Vergleichsoperatoren =

=== Vergleichsoperator 'equal' ===

* gleich: =

=== Vergleichsoperator 'not equal' ===

* ungleich: !=

=== Vergleichsoperator 'less' ===

* kleiner: <
* kleiner oder gleich: <=

=== Vergleichsoperator 'greater' ===

* größer: >
* größer oder gleich: >=

= Operatoren =

=== Grundrechenarten ===

==== Addition ====

Syntax: AUSDRUCK + AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 3 + 5
console.println (ergebnis)
</syntaxhighlight>

==== Subtraktion ====

Syntax: AUSDRUCK - AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 - 3
console.println (ergebnis)
</syntaxhighlight>

==== Multiplikation ====

Syntax: AUSDRUCK * AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 * 3
console.println (ergebnis)
</syntaxhighlight>

==== Division ====

Die Integer-Division behandelt nur den ganzzahligen Anteil der Division. Für den entstandenen Rest einer Division siehe '''Modulo'''.

Syntax: AUSDRUCK / AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 / 3
console.println (ergebnis) // Ausdruck ist 1
</syntaxhighlight>

'''Bei den Grundrechenarten gilt die Punkt-vor-Strich-Rechnung.'''

=== Modulo-Operator ===

Der Modulo-Operator berechnet den Rest einer Integer-Division.

Syntax: AUSDRUCK % AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 % 3
console.println (ergebnis) // Ausdruck ist 2
</syntaxhighlight>

'''Der Modulo-Operator bindet (im Gegensatz zu anderen Programmiersprachen!) stärker als die Grundrechenarten.''' Das Ergebnis von
<syntaxhighlight lang=pas>
ergebnis = 2 * 5 % 3
</syntaxhighlight>

ist identisch mit:

<syntaxhighlight lang=pas>
ergebnis = 2 * (5 % 3)
</syntaxhighlight>

Daher ist das Ergebnis hier 2 * 2 = 4.

=== Shift-Operatoren ===

==== Shift Left ====

Der Shift-Operator '<<' verschiebt die Bits einer Zahl nach links.

Syntax: AUSDRUCK << ANZAHL_BITS

Beispiel:
<syntaxhighlight lang=pas>
int zahl
int ergebnis
zahl = 2
ergebnis = zahl << 4 // Verschieben der Zahl 2 um 4 Stellen nach links
console.println (ergebnis) // Ausdruck ist 32
</syntaxhighlight>

==== Shift Left ====

Der Shift-Operator '>>' verschiebt die Bits einer Zahl nach rechts.

Syntax: AUSDRUCK << ANZAHL_BITS

Beispiel:
<syntaxhighlight lang=pas>
int zahl
int ergebnis
zahl = 32
ergebnis = zahl >> 4 // Verschieben der Zahl 32 um 4 Stellen nach rechts
console.println (ergebnis) // Ausdruck ist 2
</syntaxhighlight>

'''Die Shift-Operatoren binden stärker als die Grundrechenarten und der Modulo-Operator.''' Das Ergebnis von
<syntaxhighlight lang=pas>
3 * 1 << 4
</syntaxhighlight>
ist also 3 * 16 = 48.

Wichtig: Beim Verschieben werden die Ausdrücke immer als unsigned-Werte angesehen, d.h. Vorzeichenbits werden nicht besonders behandelt.

=== Bitmask-Operatoren ===

==== Bitwise OR ====

Syntax: AUSDRUCK | AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0x0F | 0xF0, HEX, 2) // Ausdruck ist FF
</syntaxhighlight>

==== Bitwise AND ====

Syntax: AUSDRUCK & AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0xFFFF & 0x00F0, HEX, 4) // Ausdruck ist 00F0
</syntaxhighlight>

==== Bitwise XOR ====

Syntax: AUSDRUCK ^ AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0xFFFF ^ 0x00F0, HEX, 4) // Ausdruck ist FF0F
</syntaxhighlight>

==== Bitwise Inversion ====

Syntax: ~AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (~0xFF00, HEX, 4) // Ausdruck ist FFFF00FF
console.println (~0xFF00 & 0xFFFF, HEX, 4) // Ausdruck ist 00FF
</syntaxhighlight>

'''Der And-Operator bindet stärker als der OR-Operator. Die Invertierung wirkt unmittelbar auf den nachfolgenden Ausdruck. Sämtliche Bitmask-Operatoren binden stärker als die vorangegangenen Operatoren.'''

=== Klammern ===

Um die obigen Prioritätenregelungen zu durchbrechen, können in den Ausdrücken Klammern gesetzt werden.

Beispiel:
<syntaxhighlight lang=pas>
console.println (3 + 2 * 4) // Ausdruck ist 3 + 8 = 11
console.println ((3 + 2) * 4) // Ausdruck ist 5 * 4 = 20
console.println (3 + 2 << 2) // Ausdruck ist 3 + 8 = 11
console.println ((3 + 2) << 2) // Ausdruck ist 5 << 2 = 20
</syntaxhighlight>

=== String-Operator ===

Der String-Operator fasst zwei Zeichenketten zu einer Zeichenkette zusammen.

Syntax: STRING1 : STRING2

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
string str1
string str2
string str3
str1 = "Hello, "
str2 = "World"
str3 = str1 : str2
console.println (str3) // Ausgabe: "Hello, World"
endfunction
</syntaxhighlight>

Oder auch kürzer:
<syntaxhighlight lang=pas>
function void main ()
string str
str1 = "Hello, "
console.println (str : "World")
endfunction
</syntaxhighlight>

Oder noch kürzer:
<syntaxhighlight lang=pas>
function void main ()
console.println ("Hello, " : "World")
endfunction
</syntaxhighlight>

Der String-Operator wandelt numerische Ausdrücke automatisch in Strings.

Somit führt der Programmabschnitt:
<syntaxhighlight lang=pas>
string str
str = (3 * 5) : " ist das Ergebnis."
console.println (str)
</syntaxhighlight>

zu einem Ausdruck von "15 ist das Ergebnis.".

Wichtig: '''Der String-Operator bindet stärker als alle anderen nicht-unären Operatoren.'''

Fehlende Klammern in Abschnitt:
<syntaxhighlight lang=pas>
string str
str = 3 * 5 : " ist das Ergebnis."
console.println (str)
</syntaxhighlight>
führen also zum Ausdruck von lediglich "15", da der zwischendurch entstehende Ausdruck "5 ist das Ergebnis" für die Multiplikation in einen Integer gewandelt wird. Übrig bleibt daher lediglich 3 * 5. Das Ergebnis wird wegen der Zuweisung wieder zurück in einen String gewandelt. Übrig bleibt "15".

= Bibliotheken =

=== Bibliothek string ===

==== string.length () ====

Die length-Funktion gibt die Länge eines Strings zurück.

Syntax: int string.length (string str)

Parameter:

* string: Die Eingabezeichenkette

Rückgabewert: Länge des Strings

Beispiel:

<syntaxhighlight lang=pas>
int len
len = string.length ("abcdef"); // gibt 6 zurück
</syntaxhighlight>

==== string.substring () ====

Die substring-Funktion kann beliebige Zeichenketten aus einem String extrahieren.

Syntax: string string.substring (string str, int start [, int length ])

Parameter:

* string: Die Eingabezeichenkette
* start: Die Startposition innerhalb des Strings
* length: Die Länge des zu extrahierenden Strings. Der Parameter ist optional.

Die Startposition wird ab 0 gezählt. Ist der Startwert positiv oder 0, wird die Startposition innerhalb des Eingabestrings von links gezählt, anderenfalls von rechts.

Beispiel:

<syntaxhighlight lang=pas>
string rest
rest = string.substring ("abcdef", -1); // gibt "f" zurück
rest = string.substring ("abcdef", -2); // gibt "ef" zurück
rest = string.substring ("abcdef", -3, 1); // gibt "d" zurück
</syntaxhighlight>

Ist length angegeben und positiv, enthält der zurückgegebene String höchstens length Zeichen ab start (abhängig von der Länge von string).

Ist length angegeben und negativ, werden genau so viele Zeichen vom Ende von string abgeschnitten (nachdem die Startposition ermittelt wurde, sollte start negativ sein). Gibt start die Position des abzuschneidenden Teiles oder dahinter an, wird ein leerer String zurückgegeben.

Beispiel:

<syntaxhighlight lang=pas>
rest = string.substring ("abcdef", 0, -1); // gibt "abcde" zurück
rest = string.substring ("abcdef", 2, -1); // gibt "cde" zurück
rest = string.substring ("abcdef", 4, -4); // gibt "" zurück
rest = string.substring ("abcdef", -3, -1); // gibt "de" zurück
</syntaxhighlight>

Die aus Basic bekannten Funktionen 'left', 'right' und 'mid' können alle mit der substring-Funktion abgebildet werden:

<syntaxhighlight lang=pas>
function string left (string str, int l)
return string.substring (str, 0, l)
endfunction

function string right (string str, int l)
return string.substring (str, -l)
endfunction

function string mid (string str, int s, int l)
return string.substring (str, s, l)
endfunction

function void main ()
string x
x = "abcdef"

console.println (left (x, 3)) // gibt "abc" aus
console.println (right (x, 3)) // gibt "def" aus
console.println (mid (x, 2, 2)) // gibt "cd" aus
endfunction
</syntaxhighlight>

=== Bibliothek time ===

==== time.millis () ====

Der Rückgabewert von time.millis() entsprecht der internen "Uhrzeit" des Mikrocontrollers seit dem letzten Boot in Millisekunden.

Syntax: int time.millis ()

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit: " : time)
endfunction
</syntaxhighlight>

==== time.reset () ====

time.reset setzt die interne "Uhrzeit" des Mikrocontrollers zurück auf 0.

Syntax: void time.reset ()

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Reset: " : time)
time.reset ()
time = time.millis ()
console.println ("Zeit nach Reset: " : time)
endfunction
</syntaxhighlight>

==== time.set () ====

time.set setzt die interne "Uhrzeit" des Mikrocontrollers auf den angegebenen Wert

Syntax: void time.reset (int millis)

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Set: " : time)
time.set (1000)
time = time.millis ()
console.println ("Zeit nach Set: " : time)
endfunction
</syntaxhighlight>

==== time.delay () ====

time.delay() wartet die angegebene Zeit in Millisekunden.

Syntax: void time.delay (int msec)

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Delay: " : time)
time.delay (500)
time = time.millis ()
console.println ("Zeit nach Delay: " : time)
endfunction
</syntaxhighlight>

=== Bibliothek console ===

==== console.print () ====

Syntax:
int console.print (int/string EXPRESSION)
oder:
int console.print (int/string EXPRESSION, const TYPE)
oder:
int console.print (int/string EXPRESSION, const TYPE, int WIDTH)

Wird nur das erste Argument übergeben, wird anhand des Parameter-Typs entschieden, ob ein String oder ein Integer-Wert auf der Console ausgedruckt wird. Man kann aber auch steuern, wie der übergebene Parameter behandelt werden soll. Dabei kann TYPE die folgenden Werte haben:

* STR - Der Parameter wird als String behandelt
* DEC - Der Parameter wird als Dezimalzahl gedruckt
* DEC0 - Der Parameter wird als Dezimalzahl gedruckt, jedoch wird das Ausgabefeld mit führenden Nullen aufgefüllt.
* HEX - Der Parameter wird als Hexadezimalzahl gedruckt
* BIN - Der Parameter wird als Binärzahl gedruckt

Mit einem weiteren numerischen Parameter WIDTH kann gesteuert werden, wie breit das Ausgabefeld sein soll. Dann wird der ausgegebene Text auf mindestens diese Anzahl von Zeichen tabuliert, das heißt mit Leerzeichen aufgefüllt. Ist WIDTH positiv, werden Leerzeichen von links beginnend eingefügt, ist WIDTH negativ, werden entsprechend viele Leerzeichen rechts angefügt, um auf die gewünschte Breite zu kommen. Eine Besonderheit ist das Drucken von HEX- oder BIN-Zahlen: Bei positivem Wert von WIDTH wird das Feld mit Nullen statt Leerzeichen aufgefüllt. Bei Dezimalzahlen geht dieses über den Typ DEC0.

Rückgabewert: Anzahl der gedruckten Zeichen.

Beispiele siehe console.println ().

==== console.println () ====

Syntax:
int console.println (int/string EXPRESSION)
oder:
int console.println (int/string EXPRESSION, const TYPE)
oder:
int console.println (int/string EXPRESSION, const TYPE, int WIDTH)

Das Verhalten entspricht exakt der Funktion console.print(). Jedoch wird noch nach dem Ausdruck ein CRNL-Paar angefügt, um eine neue Zeile zu beginnen.

Beispiele:

<syntaxhighlight lang=pas>
function void main ()
int i

i = 4711
console.println (i) // 4711
console.println (i, DEC) // 4711
console.println (i, HEX) // 1267
console.println (i, BIN) // 1001001100111

i = 0xFFFFFFFF
console.println (i, HEX) // FFFFFFFF
console.println (i >> 1, HEX) // 7FFFFFFF

i = 0xFFFF
console.println (i, HEX) // FFFF
console.println (i, HEX, 8) // 0000FFFF
console.println (i >> 1, HEX, 8) // 7FFF

i = 0xFF
console.println (i, HEX, 2) // FF
console.println (i >> 1, HEX, 2) // 7F
console.println (i >> 1, BIN, 16) // 0000000001111111

console.println (0xAA, BIN, 8) // 10101010
console.println (1, BIN, 32) // 00000000000000000000000000000001

console.println ("Hallo, Welt") // Hallo, Welt
console.println ("42 Hallo, Welt") // 42 Hallo, Welt
console.println ("42 Hallo, Welt", DEC) // 42
console.println ("42 Hallo, Welt", BIN) // 101010
endfunction
</syntaxhighlight>

=== Bibliothek gpio ===

==== gpio.init () ====

Initialisiert General Purpose I/O für einen Pin.

Syntax:
void gpio.init (PORT, BIT, INPUT [, NOPULL | PULLDOWN | PULLUP ])
oder
void gpio.init (PORT, BIT, OUTPUT [, PUSHPULL | OPENDRAIN ])

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 
Für die Datenrichtung muss entweder die Konstante INPUT oder die Konstante OUTPUT vorgegeben werden. 

Bei Verwendung des Pins als INPUT können folgende Alternativen eingestellt werden:

* '''NOPULL (Default):''' Der Eingang wird nicht durch einen internen Pullup oder Pulldown beeinflusst
* '''PULLDOWN:''' Es wird der interne Pulldown-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel LOW.
* '''PULLUP:''' Es wird der interne Pullup-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel HIGH.

Bei Verwendung des Pins als OUTPUT können folgende Alternativen eingestellt werden:

* '''PUSHPULL (Default):''' Der Ausgang wird möglichst niederohmig geschaltet.
* '''OPENDRAIN:''' Der Low-Pegel wird möglichst niederohmig geschaltet, der High-Pegel ist hochohmig.

Der letzte Parameter von gpio.init() ist optional. Wird er weggelassen, wird der jeweilige Standardwert (Default) eingestellt.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // C13 als Input, kein Pulldown/Pullup
gpio.init (GPIOC, 13, INPUT, PULLUP) // C13 als Input mit Pullup
endfunction
</syntaxhighlight>

==== gpio.set () ====

Setzt den ausgewählten Pin auf High-Pegel.

Syntax: void gpio.set (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
gpio.set (GPIOA, 5) // Pin auf HIGH
endfunction
</syntaxhighlight>

==== gpio.reset () ====

Setzt den ausgewählten Pin auf Low-Pegel.

Syntax: void gpio.reset (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
gpio.reset (GPIOA, 5) // Pin auf Low
endfunction
</syntaxhighlight>

==== gpio.toggle () ====

Invertiert den Zustand des ausgewählten Pins.

Syntax: void gpio.toggle (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
loop
gpio.toggle (GPIOA, 5) // A5 invertieren
time.delay (500) // eine halbe Sekunde warten
endloop
endfunction
</syntaxhighlight>

==== gpio.get () ====

Liest den Zustand des ausgewählten Pins.

Syntax: int gpio.get (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Der Rückgabewert ist entweder LOW oder HIGH.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // set pin C13 (user button) to input, has extern pullup
gpio.init (GPIOA, 5, OUTPUT) // board LED = A5
gpio.set (GPIOA, 5) // switch LED on

loop
if gpio.get (GPIOC, 13) = LOW // button pressed?
gpio.set (GPIOA, 5) // switch LED off
break // break loop
endif
endloop
endfunction
</syntaxhighlight>

=== Bibliothek bit ===

==== bit.set () ====

bit.set() setzt ein Bit.

Syntax: int bit.set (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = bit.set (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00100000
endfunction
</syntaxhighlight>

Alternativ kann man auch den Operator '|' nutzen, um ein Bit zu setzen:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = zahl | (1<<5)
console.println (zahl, BIN) // Ausgabe: 00100000
endfunction
</syntaxhighlight>

==== bit.reset () ====

bit.reset() setzt ein Bit zurück.

Syntax: int bit.reset (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b11111111
zahl = bit.reset (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 11011111
endfunction
</syntaxhighlight>

Alternativ kann man auch den Operator '&' zusammen mit '~' nutzen, um ein Bit zu zurückzusetzen:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b11111111
zahl = zahl & ~(1<<5)
console.println (zahl, BIN) // Ausgabe: 11011111
endfunction
</syntaxhighlight>

==== bit.toggle () ====

bit.toggle() wechselt den Zustand eines Bits.

Syntax: int bit.toggle (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = bit.toggle (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00100000
zahl = bit.toggle (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00000000
endfunction
</syntaxhighlight>

==== bit.isset () ====

bit.isset() gibt den Zustand eines Bits zurück

Syntax: int bit.isset (int value, int bit)

Rückgabewert: TRUE, wenn das Bit gesetzt ist, sonst FALSE.

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int bit
bit = bit.isset (0b11111111, 5)
if bit = TRUE
else
console.println ("bit is set")
endif
console.println ("bit is not set")
endfunction
</syntaxhighlight>

=== Bibliothek button ===

==== button.init () ====

Definiert einen GPIO-Pin als Tastereingang. Der Taster wird automatisch vom NIC-Laufzeitsystem per Software entprellt.

Syntax:
int button.init (PORT, BIT, MODE)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Bei Verwendung des Tastereingangs können folgende Alternativen für MODE eingestellt werden:

* '''PULLDOWN:''' Es wird der interne Pulldown-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel LOW.
* '''PULLUP:''' Es wird der interne Pullup-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel HIGH.
* '''NOPULLDOWN:''' Für den Tastereingang ist die Hinzuschaltung des internen Pulldowns nicht notwendig, Taster ist active high.
* '''NOPULLUP:''' Für den Tastereingang ist die Hinzuschaltung des internen Pullups nicht notwendig, Taster ist active high.

Daraus ergibt sich, dass bei Einstellung PULLDOWN der Schalter gegen Vcc, bei Einstellung PULLUP der Schalter gegen GND schalten muss. Dasselbe gibt für NOPULLDOWN bzw. NOPULLUP. Hier muss die externe Beschaltung selbst für einen definierten Pegel sorgen, zum Beispiel bei NOPULLUP durch Anschluss eines '''externen''' Pullups.

Das NIC-Laufzeitsystem vergibt eine interne Tastennummer größer Null, die bei Abfragen durch button.pressed() dann angegeben werden muss. Bis zu 8 solcher Tasten können mittels button.init() definiert werden. Wenn button.init() eine 0 zurückliefert, sind bereits alle 8 Tasten definiert.

Beispiel:

Beim Nucleo hängt der blaue User-Taster an PC13 und schaltet gegen GND. Da hier bereits ein externer Pullup-Widerstand vorgesehen ist, muss '''kein interner Pullup-Widerstand''' aktiviert werden.

<syntaxhighlight lang=pas>
function void main ()
int button

button = button.init (GPIOC, 13, NOPULLUP) // C13 als Input, kein interner Pullup nötig, active low
...
endfunction
</syntaxhighlight>

Beim STM32F103 Mini-Development-Board gibt es bis auf den RESET-Taster keinen weiteren Taster auf dem Board. Wir können aber zum Beispiel einen Taster an PA6 anschließen, so dass er gegen GND schaltet. Den externen Pullup sparen wir uns und verwenden dafür den internen Pullup am Pin:

<syntaxhighlight lang=pas>
function void main ()
int button

button = button.init (GPIOA, 6, PULLUP) // PA6 als Input mit internem Pullup, active low
...
endfunction
</syntaxhighlight>

==== button.pressed () ====

Abfrage des Tasters.

Syntax:
int button.pressed (int button)

button ist dabei die Taster-Nummer, die von button.init() zurückgegeben wurde.

Rückgabewerte:

TRUE: Taste ist gedrückt
FALSE: Taste wurde nicht gedrückt.

Beispiel:

Einschalten der Board-LED, sobald die blaue User-Taste gedrückt wird, sonst ausschalten.

<syntaxhighlight lang=pas>
function void main ()
int button
gpio.init (GPIOA, 5, OUTPUT) // LED als Output
gpio.reset (GPIOA, 5) // Pegel low: LED ist aus

button = button.init (GPIOC, 13, NOPULLUP) // C13 als Input, kein interner Pullup nötig, active low

loop
if button.pressed (button) = TRUE // Taste gedrückt?
gpio.set (GPIOA, 5) // ja, LED einschalten
else
gpio.reset (GPIOA, 5) // nein, LED ausschalten
endif
endloop
endfunction
</syntaxhighlight>

Beim STM32F103 Mini-Development-Board gibt es eine blaue LED auf dem Board. Sie ist an PC13 angeschlossen. Allerdings muss diese gegen GND geschaltet werden, damit sie leuchtet. Sie ist also "active low" - im Gegensatz zur Nucleo-LED. Die Set- und Reset-Befehl werden hier daher ausgetauscht:

<syntaxhighlight lang=pas>
function void main ()
int button
gpio.init (GPIOC, 13, OUTPUT) // LED als Output
gpio.set (GPIOC, 13) // Pegel high: LED ist aus

button = button.init (GPIOA, 6, PULLUP) // PA6 als Input mit internem Pullup, active low

loop
if button.pressed (button) = TRUE // Taste gedrückt?
gpio.reset (GPIOC, 13) // ja, LED einschalten
else
gpio.set (GPIOC, 13) // nein, LED ausschalten
endif
endloop
endfunction
</syntaxhighlight>

=== Bibliothek ws2812 ===

==== ws2812.init () ====

Mit ws2812.init() wird die WS2812-LED-Bibliothek initialisiert.

Syntax:

void ws2812.init (int nleds)

Als Argument ist die maximale Anzahl der verwendeten LEDs in der Kette anzugeben.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
ws2812.init (30) // 30 LEDs auf dem Stripe
...
endfunction
</syntaxhighlight>

==== ws2812.set () ====

Damit wird die Farbe einer oder aller WS2812-LEDs gesetzt.

Syntax:

void ws2812.set (int led, int red, int green, int blue)

led gibt die Nummer der LED an - beginnend mit 0. Wird als Nummer die Anzahl der verwendeten LEDs angegeben, werden die Farben sämtlicher verwendeter LEDs gesetzt. Die Farben können Werte zwischen 0 (aus) und 255 (volle Helligkeit) haben.

Der Set-Befehl setzt die angebenen Farben erst einmal nur im RAM. Erst mit dem ws2812.refresh()-Befehl werden dann sämtliche gesetzten Farben an die LEDs übertragen.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30

function void main ()
int i

ws2812.init (MAXLEDS) // 30 LEDs auf dem Stripe
ws2812.set (MAXLEDS, 128, 128, 128) // Alle LEDs auf weiß, halbe Helligkeit

for i = 0 to MAXLEDS
ws2812.set (i, 0, 128, 128) // Eine LEDs auf türkis, halbe Helligkeit
ws2812.refresh (MAXLEDS) // Ausgabe
delay (200) // 0,2 Sekunden warten
endfor
endfunction
</syntaxhighlight>

==== ws2812.refresh () ====

ws2812.refresh() überträgt sämtliche zuvor gesetzte Farben an die LEDs.

Syntax:

void ws2812.refresh (nleds)

Das Argument nleds bestimmt, wieviele der LEDs aktualisiert werden sollen. Der Maximalwert ist derjenige, der bei ws2812.init() angegeben wurde. Dann werden alle LEDs aktualisiert.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30

function void main ()
ws2812.init (MAXLEDS) // 30 LEDs auf dem Stripe
...
ws2812.refresh (MAXLEDS) // Ausgabe: Alle LEDs aktualisieren
...
endfunction
</syntaxhighlight>

Konkreteres Beispiel siehe oben: [[NIC#ws2812.set_.28.29|ws2812.set()]].

=== Bibliothek irmp ===

==== irmp.init () ====
==== irmp.get () ====

=== Bibliothek irsnd ===

==== irsnd.init () ====
==== irsnd.send () ====

=== Bibliothek i2c ===

==== i2c.init () ====

i2c.init () initialisiert die jeweils gewünschte I2C-Schnittstelle.

Syntax:

void i2c.init (int channel, int alternate, int clockspeed)

Parameter:

* channel: I2C-Channel. Erlaubte Werte: I2C1, I2C2 oder I2C3. Welche Werte davon möglich sind, ist prozessorabhängig.
* alternate: Flag, ob die alternative Pinkonfiguration verwendet werden soll, siehe Tabelle.
* clockspeed: Taktgeschwindigkeit. Standard ist 100000 (100k), möglich ist aber auch 400000 (400k) für schnelle Peripherie

{| {{Tabelle}}
|+ '''Mögliche I2C-Channel'''
|- style="background-color:#eeeeee"
! Channel || ALT || STM32F4x1 Nucleo || STM32F103C8T6
|-
| I2C1 || 0 || SCL=PB6, SDA=PB7|| SCL=PB6, SDA=PB7
|-
| I2C2 || 0 || SCL=PB10, SDA=PB3 ||
|-
| I2C3 || 0 || SCL=PA8, SDA=PB4 ||
|-
| I2C1 || 1 || SCL=PB8, SDA=PB9 || SCL=PB8, SDA=PB9
|-
| I2C2 || 1 || ||
|-
| I2C3 || 1 || SCL=PA8, SDA=PC9 ||
|-
|}

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k
...
endfunction
</syntaxhighlight>

==== i2c.write () ====

i2c.write() schreibt einen Datenpuffer auf die gewählte I2C-Schnittstelle.

Syntax:

int i2c.write (int channel, int address, int startaddress, int flag, byte buffer[], int length)

Parameter:

* channel: I2C-Channel, siehe i2c.init()
* address: I2C-Adresse des anzusprechenden Moduls
* startaddress: Start-Adresse für die Daten
* flag: Flag, ob die Start-Adresse ein 8- oder 16-Bit-Wert ist: TRUE: 16-Bit, FALSE: 8-Bit
* buffer: Datenpuffer
* length: Länge der Daten

Beispiel:

Schreiben des Datums "2017-06-10 16:32:12" in eine DS3231 Real Time Clock:

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// write date/time to DS3231
//-----------------------------------------------------------------------------------
const int RTC = 0xD0 // I2C address of DS3231 RTC

int year = 2017
int mon = 6
int mday = 10
int hour = 16
int min = 32
int sec = 12

//-----------------------------------------------------------------------------------
// convert decimal number into BCD format
//-----------------------------------------------------------------------------------
function int dec2bcd (int i)
i = ((i / 10) << 4) | (i % 10)
return i
endfunction

//-----------------------------------------------------------------------------------
// main function: set date/time to 2017-06-10 16:32:12
//-----------------------------------------------------------------------------------
function void main ()
byte buf[7] // Data buffer

i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k

year = year % 100 // 2000 - 2099 -> 00 - 99

buf[0] = dec2bcd (sec) // seconds (0-59)
buf[1] = dec2bcd (min) // minutes (0-59)
buf[2] = dec2bcd (hour) // hours (0-24)
buf[3] = 0 // wday (unknown) (0-6)
buf[4] = dec2bcd (mday) // day of month (0-31)
buf[5] = dec2bcd (mon) // month (1-12)
buf[6] = dec2bcd (year) // year (00-99)

rtc = i2c.write (I2C1, RTC, 0x00, FALSE, buf, 7) // write to RTC
endfunction
</syntaxhighlight>

Die RTC erwartet lediglich 8-Bit-Startadressen. Deshalb wird hier das Flag beim Aufruf von i2c.write() auf FALSE gesetzt.

==== i2c.read () ====

i2c.read() liest Daten von der gewählten I2C-Schnittstelle.

Syntax:

int i2c.read (int channel, int address, int startaddress, int flag, byte buffer[], int length)

Parameter:

* channel: I2C-Channel, siehe i2c.init()
* address: I2C-Adresse des anzusprechenden Moduls
* startaddress: Start-Adresse für die Daten
* flag: Flag, ob die Start-Adresse ein 8- oder 16-Bit-Wert ist: TRUE: 16-Bit, FALSE: 8-Bit
* buffer: Datenpuffer
* length: Länge der Daten

Beispiel:

Lesen von Datum/Uhrzeit aus DS3231 Real Time Clock und Ausgabe auf der Console:

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// read date/time from DS3231 RTC
//-----------------------------------------------------------------------------------
const int RTC = 0xD0 // I2C address of DS3231 RTC

int year
int mon
int mday
int hour
int min
int sec

//-----------------------------------------------------------------------------------
// convert BCD format into decimal number
//-----------------------------------------------------------------------------------
function int bcd2dec (byte i)
i = 10 * ((i & 0xF0) >> 4) + (i & 0x0F)
return i
endfunction

//-----------------------------------------------------------------------------------
// main function: get date/time from RTC
//-----------------------------------------------------------------------------------
function void main ()
byte buf[7] // Data buffer
int rtc

i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k

rtc = i2c.read (I2C1, RTC, 0x00, FALSE, buf, 7) // read from RTC

if rtc = TRUE
sec = bcd2dec (buf[0]) // seconds (0-59)
min = bcd2dec (buf[1]) // minutes (0-59)
hour = bcd2dec (buf[2]) // hours (0-24)
mday = bcd2dec (buf[4]) // day of month (0-31)
mon = bcd2dec (buf[5]) // month (1-12)
year = bcd2dec (buf[6]) // year (00-99)
year = year + 2000 // 00 - 99 -> 2000 - 2099

console.print (year, DEC0, 4) // print YYYY-DD-MM hh:mm:ss
console.print ("-")
console.print (mon, DEC0, 2)
console.print ("-")
console.print (mday, DEC0, 2)
console.print (" ")
console.print (hour, DEC0, 2)
console.print (":")
console.print (min, DEC0, 2)
console.print (":")
console.print (sec, DEC0, 2)
console.println ("")
endif
endfunction
</syntaxhighlight>

Die RTC erwartet lediglich 8-Bit-Startadressen. Deshalb wird hier das Flag auf FALSE gesetzt.

'''Weiteres Beispiel: Lesen/Schreiben eines EEPROMs:'''

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// main function: write some values into EEPROM, read them from EEPROM again
//-----------------------------------------------------------------------------------
function void main ()
byte buffer1[8]
byte buffer2[8]
int rtc
int i

for i = 0 to 7
buffer1[i] = i
endfor

rtc = i2c.write (I2C1, EEPROM, 0x0000, TRUE, buffer1, 8) // write buffer1 to EEPROM

if rtc = FALSE
console.println ("i2c write error!")
endif

rtc = i2c.read (I2C1, EEPROM, 0x0000, TRUE, buffer2, 8) // read buffer2 from EEPROM

if rtc = FALSE
console.println ("i2c read error!")
endif

for i = 0 to 7
console.println (buffer2[i])
endfor
endfunction
</syntaxhighlight>

Da das EEPROM 16-Bit-Startadressen erwartet, wird hier das Flag auf TRUE gesetzt.

=== Bibliothek rtc ===

==== rtc.read () ====
==== rtc.write () ====

=== Bibliothek eeprom ===

==== eeprom.read () ====
==== eeprom.write () ====

=== Bibliothek onewire ===

==== onewire.init () ====
==== onewire.read () ====

=== Bibliothek ds1820 ===

==== ds1820.init () ====
==== ds1820.read () ====

=== Bibliothek lcd ===

==== lcd.init () ====
==== lcd.move () ====
==== lcd.print () ====

=== Bibliothek spi ===

==== spi.init () ====
==== spi.read () ====
==== spi.write () ====

= Beispielprojekt - Lauflicht mit WS2812 =

Im folgenden wird ein Lauflicht mit 30 WS2812-LEDs realisiert. Die erste Variante läuft noch mit der delay-Funktion, welche keinen Spielraum mehr lässt für andere Sachen, die eventuell auch noch abgearbeitet werden sollen.

Die zweite Variante ist da schon wesentlich eleganter. Sie wird nur aktiv, wenn auch Änderungen auf unserem LED-Streifen vonnöten sind.

Die dritte Variante dagegen überlässt dem NIC-Laufzeitsystem die Zeitmessung bis zum nächsten LED-Update, so dass man sich darum nicht mehr kümmern muss. Desweiteren kann man bis zu 8 solcher Alarm-Timer gleichzeitig aktivieren, so dass man hier auch ganz verschiedene Aufgaben mit unterschiedlichen Aktivierungszeiten implementieren kann. Hier wird der Alarm-Timer noch gepollt, d.h. explizit abgefragt.

In der letzten und vierten Variante wird auch dieses noch dem NIC-Runtime-System überlassen. Hier geben wir einfach eine NIC-Funktion an, welche automatisch aufgerufen werden soll, wenn der Alarm eintrifft.

=== Lauflicht mit Delay ===

Die erste Variante arbeitet mit einem Delay, welches den Prozessor warten lässt. Währenddessen kann man keine anderen Aktionen im Programm ausführen.

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED

ws2812.init (MAX_LEDS) // Initialisierung

loop
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
time.delay (500) // Eine halbe Sekunde warten
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Millis-Timer ===

Diese Variante ermittelt mittels time.millis(), wann es aktiv werden soll und kann währenddessen noch andere Aufgaben erledigen. Allerdings wird hier der millis-Timer verwendet, so dass dieser nicht mehr für andere Dinge zur Verfügung steht.

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED

ws2812.init (MAX_LEDS) // Initialisierung
time.reset () // Setze "Uhrzeit" zurueck

loop
if time.millis() > 500 // Eine halbe Sekunde erreicht?
time.reset () // Ja, Zeit wieder zuruecksetzen
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
else
// ... // Hier koennen nun andere Aufgaben erledigt werden!
endif
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Alarm ===

Die dritte Variante verwendet einen von acht Alarm-Timern. Das ist damit die Luxusversion. Der millis-Timer wird nicht verwendet. Neben diesem können noch sieben weitere Alarm-Timer für andere Aufgaben benutzt werden:

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED
int timer1 // alarm-timer

ws2812.init (MAX_LEDS) // Initialisierung
timer1 = alarm.set (500) // Alarm initialisieren

loop
if alarm (timer1) = TRUE // Alarm gesetzt?
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
else
// ... // Hier koennen nun andere Aufgaben erledigt werden!
endif
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Alarm als Interrupt ===

In der letzten und vierten Variante wird das Pollen des Alarm-Timers dem NIC-Runtime-System überlassen. Hier geben wir einfach eine NIC-Funktion an, welche aufgerufen werden soll, wenn der Alarm eintrifft:

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void lauflicht ()
static int red = 128 // Rot
static int green = 0 // Gruen
static int blue = 0 // Blau
static int led // Aktive LED

ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
endfunction

function void main ()
ws2812.init (MAX_LEDS) // Initialisierung
alarm.set (500, function.lauflicht) // lauflicht() alle 500msec automatisch aufrufen lassen

loop
// ... // Hier koennen nun komplett andere Aufgaben erledigt werden!
endloop
endfunction
</syntaxhighlight>

Die Variablen led, red, green und blue sind nun alle in die Funktion lauflicht() gewandert. Die Definition als static-Variable lassen sie über die ganze Laufzeit des Programms "leben", d.h. sie verlieren nicht ihren Wert, wenn die Funktion wieder verlassen wird. Alternativ können sie auch einfach als globale Variablen definiert werden. Der Vorteil der static-Definition ist jedoch, dass sie ausschließlich in der Funktion lauflicht() manipuliert werden können.

= Beispielprojekt - Knight Rider mit WS2812 =

= Beispielprojekt - Equinox-Uhr mit WS2812 =

= Erstellung eigener NIC-Bibliotheksfunktionen =

= Benchmarks =

=== Sieb des Eratosthenes ===

Es geht um die Ermittlung sämtlicher Primzahlen bis 100.000.

Sieb des Eratosthenes in NIC:
<syntaxhighlight lang=pas>
function void main ()
int limit = 100000
int zahl
int zaehler
int primzahl
int letzte_primzahl

for zahl = 2 to limit
primzahl = TRUE

for zaehler = 2 to zahl / 2
if zahl % zaehler = 0
primzahl = FALSE
break
endif
endfor

if primzahl = TRUE
// console.println (zahl : " ist eine Primzahl")
letzte_primzahl = zahl
endif
endfor
console.println ("Die hoechste ermittelte Primzahl ist " : letzte_primzahl)
endfunction
</syntaxhighlight>

Sieb des Eratosthenes in PHP:
<syntaxhighlight lang=php>
<?php
$limit = 100000;

for ($zahl = 2; $zahl <= $limit; $zahl++)
{
$primzahl = true;

for ($zaehler = 2; $zaehler <= $zahl / 2; $zaehler++)
{
if ($zahl % $zaehler == 0)
{
$primzahl = false;
break;
}
}

if ($primzahl)
{
// print ("" . $zahl . " ist eine Primzahl\n");
$letzte_primzahl = $zahl;
}
}
print ("Die hoechste ermittelte Primzahl ist " . $letzte_primzahl . "\n");
?>
</syntaxhighlight>

Sieb des Eratosthenes in Python:
<syntaxhighlight lang=python>
def main():
limit = 100000

for zahl in range (2, limit):
primzahl = True

for zaehler in range (2, zahl / 2):
if zahl % zaehler == 0:
primzahl = False
break

if primzahl == True:
letzte_primzahl = zahl
print "Die hoechste ermittelte Primzahl ist %d" % (letzte_primzahl)
return 0

if __name__ == '__main__':
main()
</syntaxhighlight>

Sieb des Eratosthenes in Lua:
<syntaxhighlight lang=lua>
local limit = 100000
local zahl
local zaehler
local primzahl
local letzte_primzahl

for zahl = 2, limit do
primzahl = true

for zaehler = 2, zahl / 2 do
if zahl % zaehler == 0 then
primzahl = false
break
end
end

if primzahl == true then
-- print (zahl, "ist eine Primzahl")
letzte_primzahl = zahl
end
end
print ("Die hoechste ermittelte Primzahl ist ", letzte_primzahl)
</syntaxhighlight>

Die Umsetzung in PHP, Python und Lua wurde durch 1:1-Ersetzung jeder Zeile durch die adäquate Formulierung in der jeweiligen Programmiersprache vorgenommen. Die Programme sind damit direkt vergleichbar.

Ausführungszeiten:

{| {{Tabelle}}
|+ '''Ergebnisse: Sieb des Eratosthenes'''
|- style="background-color:#eeeeee"
! Programmiersprache || Version || i7-2600 CPU @ 3.40GHz || Intel T6500 @ 2.10GHz
|-
| '''NIC''' || 0.9 || 5,3 sec || 17,3 sec
|-
| '''PHP''' || 5.6.23 || 10,4 sec ||
|-
| '''Python''' || 2.7 || 25,6 sec || 118 sec
|-
| '''Lua''' || 5.2 || 6,1 sec ||
|}

Es empfiehlt sich nicht, obiges Programm auf dem STM32 mit dem oben verwendeten Startwert 100000 laufen zu lassen. Dabei muss man schon seeeehr lange warten, da der STM32 doch um einiges langsamer ist als ein moderner Intel-Prozessor. Für eigene Messungen auf dem STM32 empfiehlt sich ein Startwert von 10000, also eine Größenordnung geringer.

= Anhang =

=== Compiler-Warnungen ===

'''function 'foo' not used.'''

Die Funktion namens foo ist zwar definiert, wird aber nicht aufgerufen.

'''variable 'foo' not used.'''

Die Variable 'foo' wird zwar definiert, aber nicht verwendet.

'''variable 'foo' set but not used.'''

Die Variable 'foo' wird zwar zwischenzeitlich gesetzt, aber sonst nicht weiter verwendet.

'''local variable 'foo' shadows global variable 'foo' defined in line NN.'''

Die lokale Variable 'foo' überdeckt die globale gleichnamige Variable. Dies kann je nach Kontext zu unerwünschten Effekten führen: In der Funktion, wo die lokale Variable definiert wurde, wird dann der Wert dieser lokalen Variablen verwendet, in allen anderen Funktionen jedoch der Wert der globalen Variablen.

=== Compiler-Fehlermeldungen ===

'''return with a value, in function returning void.'''

Die definierte void-Funktion liefert unzulässigerweise einen Return-Wert zurück.

'''return with no value, in function returning non-void.'''

Die definierte Funktion mit Datentyp als Rückgabewert liefert unzulässigerweise keinen Return-Wert zurück.

'''keyword 'foo' unexpected.'''

Das Schlüsselwort 'foo' ist an der angegebenen Stelle unerwartet und damit falsch.

'''Variable 'foo' already defined.'''

Die Variable 'foo' wurde bereits definiert.

'''break stack overflow.'''

Die Schachtelungstiefe von Schleifen ist zu tief und somit kann die aktuelle Schleife nicht mehr durch einen Break-Befehl unterbrochen werden.

'''continue stack overflow.'''

Die Schachtelungstiefe von Schleifen ist zu tief und somit kann die aktuelle Schleife nicht mehr durch einen Continue-Befehl am Anfang der Schleife fortgesetzt werden.

'''double negation not allowed.'''

Eine doppelte Negation eines numerischen Wertes ist nicht erlaubt.

'''empty expression.'''

Der erwartete arithmetische Ausdruck ist leer.

'''invalid argument type 'foo' in function 'bar', argument #NN.'''

Der angegebene Parameter an NN-ter Stelle hat einen ungültigen Datentyp.

'''main must be defined as function returning void.'''

Die main-Funktion muss stets vom Datentyp void definiert werden.

'''no main function found.'''

Ein NIC-Programm muss immer eine main-Funktion als Startpunkt enthalten.

'''function 'foo' already defined.'''

Die Funktion namens 'foo' wurde bereits definiert.

'''function 'foo' returns void.'''

Es wird versucht, den Rückgabewert einer Funktion 'foo' weiterzuverwenden, obwohl der Datentyp dieser Funktion 'void' ist.

'''function 'foo' undefined.'''

Die aufgerufene Funktion 'foo' ist nicht definiert.

'''unterminated string.'''

Die angegebene Zeichenkette wurde nicht mit dem Anführungszeichen terminiert.

'''missing 'endfoo' at end of file.'''

Ein geöffneter Kontrollblock wurde nicht geschlossen.

'''missing arguments for function 'foo'.'''

Es wurden keine Parameter für die Funktion foo angegeben.

'''missing closing bracket.'''

Eine geöffnete Klammer wurde nicht geschlossen.

'''no matching ')' found.'''

Zu einer geschlossenen Klammer wurde die dazugehörende geöffnete Klammer nicht gefunden.

'''missing return before 'endfunction'.'''

Das Return-Statement unmittelbar vor dem Ende der Funktion fehlt.

'''no compare operator found.'''

Es wurde kein Vergleichsoperator im Ausdruck angegeben.

'''number of arguments wrong for call of function 'foo', expected NN.'''

Die Anzahl der Parameter für den Aufruf der Funktion 'foo' ist falsch, richtig ist NN.

'''syntax error. Use brackets around negative expression.'''

Ein Ausdruck mit einem negativen Operanden (wie z.B. "3 * -2") bedeutet einen Syntax-Error. In diesem Fall muss der zu negierende Operand geklammert werden, also: "3 * (-2)".

'''too many arguments for function 'foo'.'''

Zu viele Parameter für den Aufruf der Funktion namens 'foo'.

'''too many closing brackets.'''

Der Ausdruck enthält zu viele geschlossene Klammern.

'''too many open brackets.'''

Der Ausdruck enthält zu viele geöffnete Klammern.

'''too many expressions.'''

Der Ausdruck ist zu komplex.

'''variable 'foo' already defined.'''

Die Variable 'foo' wurde bereits definiert.

'''variable 'foo' not defined.'''

Die Variable 'foo' wurde vorher nicht definiert.

NIC

2017-06-20T13:28:45Z

Klause: /* Compiler nicc */

Von '''Frank M. ([http://www.mikrocontroller.net/user/show/ukw ukw])'''

'''Dies ist eine vorläufige und höchst unvollständige Beschreibung einer Software, die noch in Entwicklung, d.h. im Alpha-Stadium ist. Ein entsprechender Thread über NIC wird im Forum "Projekte & Code" eröffnet, sobald eine Beta-Version des NIC-Interpreters verfügbar ist. Details können sich durchaus noch ändern, daher ist diese Dokumentation zur Zeit noch rein als PRELIMINARY zu sehen.'''

NIC ist eine einfache strukturierte Programmiersprache, welche speziell für die Mikrocontroller-Familie STM32 entwickelt wurde. Da der NIC-Interpreter in C geschrieben ist, kann dieser auch auf andere 32-Bit-Mikrocontroller portiert werden.

Ebenso sind NIC-Programme auch unter Linux und Windows lauffähig, wobei dies eher der Entwicklung und des Debuggings des NIC-Interpreters dient. Ein in NIC geschriebenes Programm wird zunächst von dem NIC-Compiler "nicc" auf dem Host in einen Metacode übersetzt, welcher durch den NIC-Interpreter "nici" auf dem Mikrocontroller-System sehr effizient abgearbeitet werden kann. Die üblichen Übersetzungsdauern liegen meist unter einer Sekunde, die Geschwindigkeit, mit der die Befehle dann von nici ausgeführt werden, liegen bei ca. 100.000 bis 250.000 Befehlen pro Sekunde - je nach verwendetem STM32. Als Host zum Compilieren von NIC-Programmen dient zur Zeit ein PC-System mit Linux oder Windows, später wird dies auch ein vorgeschalteter µC wie ein ESP8266 sein, der gleichzeitig ein Filesystem (SPIFFS) bietet, um die Compilate zu speichern und damit permanent vorzuhalten. Zudem erweitert dieser dann das NIC-Laufzeitsystem um Netzwerkfunktionalitäten.

Motivationen zur Entwicklung eines solchen Interpreters gibt es einige: Zum einen wird Einsteigern ein sehr einfaches System geboten, sich in die Welt von 32-Bit-Mikrocontrollern einzuarbeiten, zum anderen schrecken viele Umsteiger von 8-Bit-Systemen auf 32-Bit-Systeme vor der Komplexität der 32-Bitter zurück. Genau diese Komplexität wird in die NIC-Bibliotheksfunktionen verlegt, so dass man sich als NIC-Programmierer nicht damit im Detail befassen muss. Ein erfahrener Programmierer jedoch kann die NIC-Laufzeitbibliothek durch eigene C-Module erweitern, um diese dann im NIC-Programm unter Nutzung der NIC-API zu nutzen. So ist es dann zum Beispiel auf einfache Art und Weise möglich, eine Kette von WS2812-LEDs per DMA zu steuern, ohne sich im Detail mit der Programmierung einer DMA auseinandersetzen zu müssen.

NIC als strukturierte Programmiersprache ähnelt in manchen Teilen C, PHP, Pascal oder auch Basic. Datentypen müssen jedoch zum Beispiel im Gegensatz zu PHP stets angegeben werden. Trotzdem ist stets eine implizite Typumwandlung (zum Beispiel von Integer-Werten in Strings oder umgekehrt) möglich, die klaren Regeln unterworfen ist. Casts wie in C sind dabei nicht notwendig.

Natürlich ist NIC als Interpretersprache nicht so schnell wie ein C-Programm, kann sich aber trotzdem bezüglich Ausführungsgeschwindigkeit durchaus sehen lassen. Ein erfahrener C-Programmierer kann zeitkritische Programmteile in C erstellen, um sie dann als NIC-Bibliotheksfunktionen komfortabel zu nutzen. Der NIC-Interpreter ist ca. doppelt so schnell wie ein adäquates PHP-Programm und meist 3-5 mal schneller als vergleichbare Python-Programme, siehe auch [[NIC#Benchmarks|Benchmarks]].

Wozu einen schnellen ARM erst programmier-freundlich abbremsen wenn man dann gleich einen AVR verwenden kann! Die Einarbeitung in ARM und diese Xte neue Programmier-Sprache ist damit auch gespart!

= Compiler nicc =

Der Compiler nicc ist für Windows und Linux verfügbar.

=== Aufruf unter Windows ===
nicc [-v] [-u COMx] datei.nic

Die in eckigen Klammern angegebenen Parameter sind optional.

Optionen:
-v : Verbose, gibt Statistiken, wie zum Beispiel Optimierungen von Ausdrücken aus
-u COMx: Upload der compilierten Datei über die seriellen Schnittstelle COMx

Der NIC-Quelltext wird dabei in einen optimierten, maschinenunabhängigen Objekt-Code übersetzt. Das Kompilat legt nicc in der Datei datei.nico ab, welche (zur Zeit noch) eine ASCII-Datei ist. Gibt man per Upload-Parameter die serielle Schnittstelle an, wird das Kompilat direkt auf den µC geladen. Der Interpreter legt den Objekt-Code dann als binäre Datenstrukturen im RAM ab, um diese dann effizient abzuarbeiten.

Beispiel:
nicc -u com5 lauflicht1.nic

=== Aufruf unter Linux ===
nicc [-v] datei.nic

Hier fehlt (noch) die Upload-Funktion. Dafür ist es aber möglich, das Kompilat direkt unter Linux zu starten, siehe nächstes [[NIC#Interpreter_nici|Kapitel]].

=== Optimierungen ===

Der NIC-Compiler bringt sämtliche arithmetische Ausdrücke wie "3 * 4 + x + 1 << 6" nach den Prioritätenregeln (Punkt- vor Strichrechnung usw.) in die UPN-Notation - auch Postfix genannt. Dabei werden konstante Teilausdrücke wie "3 * 4" direkt durch das Ergebnis "12" zur Compilezeit ersetzt. Dadurch muss der Interpreter sich nicht mehr um solche Regeln kümmern, sondern braucht nur noch einen Stack abzuarbeiten, auf dem alle Operanden und Operatoren schon fix und fertig in der richtigen Reihenfolge vorliegen.

Desweiteren werden zur Compilezeit sämtliche Sprungadressen, die durch Schleifen wie loop, repeat, for, while, break und continue entstehen, vorher ausgerechnet, so dass der Interpreter je nach Bedingung nur noch Sprungadressen laden muss. Desweiteren sind bei Aufruf von Bibliotheksfunktion (wie zum Beispiel [[NIC#Bibliothek_gpio|GPIO]]) die zu übergebenden Daten direkt zum Bedienen der API für Bibliotheksfunktionen vorbereitet. Diese können damit schnell und effektiv bedient werden.

Häufig vorkommende Konstrukte wie "n = n + 1" werden in spezielle Increment- und Decrement-Befehle gewandelt, die vom NIC-Interpreter ohne Evaluierung des arithmetischen Ausdrucks rechts vom Gleichheitszeichen direkt intern auf den Variableninhalt wirken.

= Interpreter nici =

Der NIC-Interpreter nici wird im Flash des STM32 installiert (HEX-Datei). Dieser wartet dann auf dem UARTx auf das übersetzte NIC-Programm, um es direkt nach dem Upload auszuführen.

Für Entwickler:

Man kann den Interpreter unter Linux und Windows direkt von der Kommandozeile aus starten.

Übersetzen:
nicc datei.nic
Ausführen:
nici datei.nico

STM32-spezifische Funktionen wie gpio.toggle() laufen dabei auf eine Stub-Funktion geleitet, welche die Laufzeitparameter als Info ausgeben. Alle anderen Funktionen werden jedoch ordnungsgemäß ausgeführt. Trotzdem ist der Interpreter nicc unter Linux bzw. Windows eher zur Weiterentwicklung und Debugging des Compilers und des Interpreters gedacht und nicht dafür, Programme für Linux/Windows in der Programmiersprache NIC zu entwickeln - auch wenn das so möglich wäre.

= main-Funktion =

Jedes NIC-Programm muss eine Funktion namens "main()" definieren. Das ist der Startpunkt eines jeden NIC-Programms. Die Funktion main() liefert stets keinen Rückgabewert zurück und muss daher immer mit dem Funktionstyp "void" angegeben werden. Außerdem erhält sie keine Parameter, daher ist der Inhalt zwischen den Klammern "(" und ")" leer.

Damit ergibt sich als Funktionsrumpf:

<syntaxhighlight lang=pas>
function void main ()
...
endfunction
</syntaxhighlight>

== Hello World ==

Ale Einstiegsprogramm einer Programmiersprache wird oft ein einfaches Hello-World-Programm angegeben, welches die Zeichenkette "Hello, World" ausgibt. Für Mikrocontroller jedoch ist es oft das Blinken einer an den Mikrocontroller angeschlossenen LED.

Das folgende NIC-Programm lässt die LED auf einem Nucleo-Board blinken:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT)
loop
gpio.set (GPIOA, 5)
time.delay (500)
gpio.reset (GPIOA, 5)
time.delay (500)
endloop
endfunction
</syntaxhighlight>

Die LED wird dabei für 500msec ein- und dann für 500msec wieder abgeschaltet. Durch die Kontrollstruktur "loop" läuft das Programm in einer Endlosschleife und kann nur durch Drücken der RESET-Taste gestoppt werden. Hier werden drei interne Bibliotheksfunktionen der Familie '''[[NIC#Bibliothek_gpio|gpio]]''' aufgerufen, nämlich [[NIC#gpio.init_.28.29|gpio.init()]], [[NIC#gpio.set_.28.29|gpio.set()]] und [[NIC#gpio.reset_.28.29|gpio.reset()]]. Die erste Funktion [[NIC#gpio.init_.28.29|gpio.init()]] initialisiert den Pin A5 des STM32 als Ausgabe-Pin durch Angabe des Schlüsselwortes "OUTPUT", die Funktion [[NIC#gpio.set_.28.29|gpio.set()]] setzt dann den Pin auf HIGH-Pegel, die Funktion [[NIC#gpio.reset_.28.29|gpio.reset()]] wieder auf LOW-Pegel. Die Bibliotheksfunktion time.delay() lässt den Mikrocontroller eine bestimmte Anzahl von Millisekunden warten - hier 500msec.

Am Pin A5 ist bei den Nucleo-Boards eine board-interne grüne LED angeschlossen. Diese blinkt dann bei der Ausführung des Programms. Um die board-interne blaue LED eines STM32F103-Mini-Development-Boards anzusprechen, muss der Port GPIOA durch GPIOC ersetzt und die Pinnummer auf 13 geändert werden, denn hier ist die LED an Pin C13 angeschlossen.

Durch Anwendung der Funktion [[NIC#gpio.toggle_.28.29|gpio.toggle()]] kann der Code noch vereinfacht werden:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT)
loop
gpio.toggle (GPIOA, 5)
time.delay (500)
endloop
endfunction
</syntaxhighlight>

Hier wechselt die Funktion [[NIC#gpio.toggle_.28.29|gpio.toggle()]] automatisch den jeweiligen LOW- bzw. HIGH-Pegel und lässt die LED mit einer Frequenz von einem Hertz blinken.

Wie wir später noch sehen werden, kann das Blinken der LED auch timergesteuert ausgeführt werden. Dann macht der NIC-Interpreter das "nebenbei", d.h. wir haben in der Hauptschleife Zeit für andere Dinge.

Hier schon mal das Programm, erklärt wird es dann später unten (alarm-Funktionen):

<syntaxhighlight lang=pas>
function void blink ()
gpio.toggle (GPIOA, 5)
endfunction

function void main ()
gpio.init (GPIOA, 5, OUTPUT)
alarm.set (500, function.blink) // blink() alle 500msec automatisch aufrufen lassen

loop
// ... // Hier koennen nun komplett andere Aufgaben erledigt werden!
endloop
endfunction
</syntaxhighlight>

Wie schnell ist nun der NIC-Interpreter? Wir können nun durch Entfernen des delay-Aufrufs die LED mit maximaler Geschwindigkeit blinken lassen und dann die Zeiten messen:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103-Mini-Board: LED=C13
repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat
endfunction
</syntaxhighlight>

Die Endlosschleife '''[[NIC#loop|loop]]''' wurde hier durch ein '''[[NIC#repeat|repeat]]''' ersetzt. Hier können wir angeben, wie oft eine Schleife durchlaufen wird. In unserem Beispiel sind es 1.000.000 mal. Das Blinken selbst wird man aufgrund der Geschwindigkeit nicht mehr erkennen können, jedoch leuchtet die LED weiterhin deutlich sichtbar - bis das Programm nach einer Million Schleifendurchläufen beendet wird. Man wird dabei mit der Stoppuhr auf einem STM32F411RE-Nucleo-Board ungefähr 4 Sekunden messen.

Der Messvorgang geht aber auch genauer:

<syntaxhighlight lang=pas>
function void main ()
int start
int stop
int diff

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

stop = time.millis ()
diff = stop - start
console.println (diff)
endfunction
</syntaxhighlight>

Hier werden nun erstmals Variablen namens "start" und "stop" verwendet. Sie entsprechen der internen "Uhrzeit" des Mikrocontrollers seit dem letzten Boot in Millisekunden. Durch die Funktion [[NIC#time.millis_.28.29|time.millis()]] können wir jederzeit die interne Zeit des Mikrocontrollers abrufen und in einer Variablen speichern. Deshalb wird jemals einmal vor und nach dem Schleifendurchlauf die Zeit gestoppt. Die Differenz wird in der Variablen "diff" gespeichert und dann mittels der Funktion [[NIC#console.println_.28.29|console.println()]] in Millisekunden auf der Console ausgegeben. Die Console ist dabei die serielle UART-Schnittstelle, die bei jedem Nucleo on-board dabei ist. Bei einem STM32F103-Mini-Development-Board muss ein zusätzlicher UART-Adapter angeschlossen werden, siehe entsprechendes Kapitel weiter unten. Bei einem mit 100MHz getakteten STM32F411RE sind dies ca. 3900msec. Das Programm schafft also ungefähr 255.000 Schleifendurchläufe pro Sekunde. Bei einem mit 85MHz getakteten STM32F401RE sind es noch knapp 200.000 Schleifendurchläufe, beim STM32F103 mit 72MHz-Takt ca. 180.000 Durchläufe.

Das Programm kann aber noch stärker vereinfacht werden. Zunächst eliminieren wir die Variable "diff", indem wir die Differenz der Werte "stop" und "start" direkt der Funktion [[NIC#console.println_.28.29|console.println()]] übergeben:

<syntaxhighlight lang=pas>
function void main ()
int start
int stop

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

stop = time.millis ()
console.println (stop - start)
endfunction
</syntaxhighlight>

Also: Funktionen können nicht nur einfache Werte, sondern auch algebraische Ausdrücke direkt übergeben werden.

Aber es geht noch einfacher. Jetzt verzichten wir auch noch auf die Variable "stop":

<syntaxhighlight lang=pas>
function void main ()
int start

gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
start = time.millis ()

repeat 1000000
gpio.toggle (GPIOA, 5)
endrepeat

console.println (time.millis () - start)
endfunction
</syntaxhighlight>

Als Funktionsparameter können also auch Rückgabewerte anderer Funktionen oder noch komplexere Ausdrücke angegeben werden.

Der Vollständigkeit halber noch das Hello-World-Programm im klassischen Sinne:

<syntaxhighlight lang=pas>
function void main ()
console.println ("Hello, World!")
endfunction
</syntaxhighlight>

Das sieht jetzt - nachdem wir bereits eine LED auf mehrere Art und Weise haben blinken lassen - doch viel zu einfach aus ;-)

= Kommentare =

Kommentare werden durch einen doppelten Schrägstrich eingeleitet, also durch '//'. Alle danach aufgeführten Zeichen gelten als Kommentar und werden vom NIC-Compiler nicc ignoriert.

Beispiel:
<syntaxhighlight lang=pas>
gpio.init (GPIOA, 5, OUTPUT) // Nucleo STM32F4xx: LED=A5, STM32F103 Mini-Dev-Board: LED=C13
</syntaxhighlight>

= Datentypen =

Die Datentypen von Funktionen und Variablen müssen stets angegeben werden. Eine implizite Definition durch einfache Aufführung eines einer Funktion, eines Funktionsparameters oder einer Variablen wie in PHP oder Python ist nicht möglich.

Die Datentypen von Variablen und Funktionen sind Integer, Byte oder String, evtl. später auch noch "Float". Bei Funktionen ist zusätzlich der Datentyp "void" möglich, um anzugeben, dass die Funktion '''keinen''' Funktionswert zurückliefert.

* '''int''' - Datentyp Integer, Breite 32 Bit, vorzeichenbehaftet
* '''byte''' - Datentyp Byte, Breite 8 Bit, vorzeichenlos
* '''string''' - Datentyp Zeichenkette
* '''void''' - kein Returnwert (nur Funktionen)

Funktionen können als Rückgabewerte nicht nur die oben aufgeführten Typen zurückliefern, sondern auch vom Typ '''void''' sein, um anzuzeigen, dass sie '''keinen''' Rückgabewert liefern.

Beispiel:

<syntaxhighlight lang=pas>
function void errormessage (string message)
console.println ("error: " : message)
endfunction
</syntaxhighlight>

Bei allen anderen Datentypen muss eine Funktion einen Wert per return-Befehl zurückgeben.

= Konstanten =

=== Integer-Konstanten ===

Integer-Konstanten sind einfache Zahlenfolgen wie 1234 oder -1234. Ohne entsprechendes Prefix sind dies Dezimalzahlen. Möchte man einen numerischen Wert in hexadezimal angeben, ist 0x voranzustellen, also zum Beispiel 0x1234. Zahlen können auch im Binärsystem angegeben werden. In diesem Fall ist 0b voranzustellen, z.B. 0b10011100.

Beispiele:

* 1234 ist eine Dezimalzahl
* 0x23AF ist eine Hexadezimalzahl
* 0b01010101 ist eine Binärzahl

=== String-Konstanten ===

String-Konstanten werden in Anführungszeichen angegeben.

Beispiel:

* "Das ist eine String-Konstante"

= Variablen =

Variablen werden definiert durch die Angabe des Datentyps und des Namens.

Beispiel:

<syntaxhighlight lang=pas>
int nummer
byte data
string zeichenkette
</syntaxhighlight>

Es gibt lediglich drei verschiedene Datentypen: '''int''' oder '''byte''' oder '''string'''.

Der Datentyp int definiert einen 32-Bit-Integer, ist also vorzeichenbehaftet. Der Datentyp byte entspricht dem Byte, kennt also keinerlei Vorzeichen und ist 8 Bit breit. Der Typ string ist eine Zeichenkette.

=== Globale Variablen ===

Wird eine Variable außerhalb von Funktionen definiert, ist sie eine globale Variable. Auf globale Variablen kann funktionsübergreifend zugegriffen werden - und zwar ab der Zeile, wo sie definiert wird. Eine globale Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang des Quelltextes geschehen, jedoch spätestens dann, wenn auch auf sie zugegegriffen werden soll.

Beispiel:
<syntaxhighlight lang=pas>
int maxleds

function void main ()
maxleds = 30
console.println (maxleds) // Ausgabe: 30
endfunction
</syntaxhighlight>

Globale Variablen können auch direkt bei der Definition initialisiert werden. Dies muss dann - je nach Typ - eine numerische Konstante oder eine Stringkonstante sein.

Beispiel:
<syntaxhighlight lang=pas>
int maxleds = 30

function void main ()
console.println (maxleds) // Ausgabe: 30
maxleds = 40
console.println (maxleds) // Ausgabe: 40
endfunction
</syntaxhighlight>

=== Lokale Variablen ===

Wird eine Variable innerhalb einer Funktion definiert, dann gilt sie nur innerhalb dieser Funktion. Bei jedem Funktionsaufruf werden die lokalen Variablen neu erzeugt und (im Gegensatz z.B. zu C) neu mit 0 (für int) bzw. Leerstring "" (für string) initialisiert. Ruft die Funktion sich selbst rekursiv auf, wird jedesmal ein neuer lokaler Variablensatz erzeugt. Lokale Variablen werden nach dem Verlassen der jeweiligen Funktion wieder zerstört und sind dann nicht mehr verfügbar.

Eine lokale Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang einer Funktion stehen. Jedoch kann sie überall innerhalb der Funktion verwendet werden - frühestens aber unterhalb der erfolgen Definition.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
int var
var = 3 * 2
console.println (var)
endfunction
</syntaxhighlight>

Auch lokale Variablen können direkt bei der Definition initialisiert werden. Dies muss dann - je nach Typ - eine numerische Konstante oder eine Stringkonstante sein.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
int var = 3
string message = "Die Variable hat den Inhalt "
console.println (message : var)
endfunction
</syntaxhighlight>

Arithmetische Ausdrücke sind zur Zeit nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden Integer-Variablen mit 0, String-Variablen mit "" (Leerstring) initialisiert.

=== Statische Variablen ===

Wird eine Variable innerhalb einer Funktion statisch definiert, dann gilt für sie erst einmal dasselbe wie für lokale Variablen. Der einzige Unterschied: Sie wird nur einmal beim Start des Programms erzeugt und beim Verlassen der Funktion auch nicht zerstört. Das heisst: Die Variable (und deren Inhalt) "lebt" während der ganzen Laufzeit des Programms. Außerhalb der Funktion, wo sie definiert wird, kann auf sie mit dem Namen "function.variable" zugegriffen werden, wenn es unbedingt nötig ist, siehe untenstehendes Beispiel.

Werden statische Variablen direkt bei der Definition initialisiert, so haben sie diesen Wert bereits beim Start des Programms.

Eine statische Variable kann jederzeit definiert werden, d.h. die Definition muss keinesfalls am Anfang einer Funktion stehen. Jedoch kann sie überall innerhalb der Funktion verwendet werden - frühestens unterhalb der erfolgen Definition.

Beispiel:
<syntaxhighlight lang=pas>
function void foo ()
static int var = 4
var = 3 * var
console.println (var) // Ausgabe: 12
endfunction

function void main ()
console.println (foo.var) // Ausgabe: 4
foo ()
console.println (foo.var) // Ausgabe: 12
endfunction
</syntaxhighlight>

Statische Variablen können auch außerhalb einer Funktion definiert werden. Da diese Definition semantisch keinen Unterschied zu der Definition einer globalen Variablen macht, werden globale statische Variaben identisch zu globalen Variablen behandelt.

Beim Compilieren erscheint dann eine Warnung:

warning line 1: keyword 'static' takes no effect here.

Beispiel:
<syntaxhighlight lang=pas>
static int var = 3
function void main ()
string message = "Die Variable hat den Inhalt "
console.println (message : var)
</syntaxhighlight>

Arithmetische Ausdrücke sind ebenso wie bei den nicht-statischen Variaben nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden Integer-Variablen mit 0, String-Variablen mit "" (Leerstring) initialisiert.

=== Konstante Variablen ===

"Konstante Variablen" sind auf den ersten Blick ein Widerspruch in sich. Wie kann eine Konstante variabel sein?

Die Antwort: Eine konstante Variable wird von der Semantik wie eine normale Variable behandelt. Allerdings kann deren Wert nicht geändert werden. Daher sollte man direkt bei der Definition solche Variablen auch initialisieren. Unterlässt man dies, haben sie halt den Wert 0 bzw. "" (Leerstring) - je nach Typ.

Konstante Variablen sollte man nach Konvention ausschließlich in Großbuchstaben schreiben. Sie ähneln nämlich den Preprozessor-Konstanten in C. Mit der Großschreibung deutet man an: Dies ist eine Konstante!

Der Inhalt der Variablen wird auch nicht erst zur Laufzeit in arithmetischen Ausdrücken ermittelt, sondern bereits während des Compilierens in die entsprechenden Ausdrücke eingesetzt.

const-Variablen müssen vom Typ int oder string sein. byte ist hier nicht erlaubt - was aber keine Einschränkung bedeutet.

Beispiel:
<syntaxhighlight lang=pas>
const int MAXLEDS = 30 // 30 LEDs

function void foo ()
int var = 4
var = MAXLEDS * var
console.println (var) // Ausgabe: 120
endfunction

function void main ()
foo ()
console.println (MAXLEDS) // Ausgabe: 30
endfunction
</syntaxhighlight>

Arithmetische Ausdrücke sind ebenso wie bei den nicht-statischen Variaben nicht erlaubt, die Initialisierungen müssen mit Konstanten vorgenommen werden. Wird die Initialisierung weggelassen, werden konstante Variablen mit 0 bzw. mit "" (Leerstring) - je nach Typ - initialisiert.

Der Versuch, einer konstante Variablen später im Programm einen anderen Wert zuzuweisen, wird bereits beim Compilieren mit einer Fehlermeldung quittiert.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30 // 30 LEDs

function void main ()
MAXLEDS = 40
console.println (MAXLEDS)
endfunction
</syntaxhighlight>

Die Fehlermeldung lautet dann:

error line 4: variable 'MAXLEDS' is of type 'const'.

= Arrays =

Variablen können auch als Arrays verwendet werden. Dabei wird bei der Definition die Größe des Arrays in eckigen Klammern angegeben. Diese Größe muss entweder durch eine Zahl oder den Inhalt einer "konstanten Integer-Variablen" (const int) angegeben werden. Arrays beginnen immer mit dem Index 0 und enden bei der Arraygröße minus 1. Zugriffe außerhalb dieses Bereichs werden zur Laufzeit abgefangen. In diesem Fall wird eine entsprechende Fehlermeldung auf der Console ausgegeben und das Programm beendet.

Arrays können sowohl global als auch lokal angelegt werden. Auch static Arrays sind möglich. Konstante Arrays gibt es jedoch nicht.

Beispiel:

<syntaxhighlight lang=pas>
const int SIZE = 5
int nummer[7]

function void main ()
string zeichenkette[SIZE]
int i

for i = 0 to 7 - 1
nummer[i] = 2 * i
endfor

console.println (nummer[5]) // Ausgabe: 10

for i = 0 to SIZE - 1
zeichenkette[i] = "Hello " : i
endfor

console.println (zeichenkette[3]) // Ausgabe: "Hello 3"
endfunction
</syntaxhighlight>

= Funktionen =

=== Bibliotheksfunktionen ===

=== Eigene NIC-Funktionen ===

Eine Funktion wird definiert durch folgenden Block:
<syntaxhighlight lang=pas>
function TYPE FUNCTIONNAME (TYP PARAMETER1, TYP PARAMETER2, ...)
...
endfunction
</syntaxhighlight>

Dabei kann TYPE '''int''', '''string''' oder '''void''' sein. FUNCTIONNAME ist einfach der Funktionsname. PARAMETER1 bis PARAMETERn sind die optionalen Funktionsparameter.

Der einfachste Fall ist die main-Funktion, die immer vorhanden sein muss:

<syntaxhighlight lang=pas>
function void main ()
...
endfunction
</syntaxhighlight>

Möchte man das oben angegebene Blink-Programm als eigene Funktion einbauen, dann wäre das folgende Programm eine Lösung:

<syntaxhighlight lang=pas>
function void blink (int factor, int delay)
repeat factor
gpio.toggle (GPIOA, 5)
time.delay (delay)
endloop
endfunction

function void main ()
gpio.init (GPIOA, 5, OUTPUT)
blink (20, 200)
blink (10, 500)
endfunction
</syntaxhighlight>

Der erste Aufruf von blink() lässt die LED 20 mal schnell den Zustand wechseln (Verzögerungszeit 200 msec), der zweite Aufruf lässt die LED lediglich 10 mal den Zustand wechseln, dafür aber langsamer (Verzögerungszeit 500 msec).

=== Eigene NIC-Klassen ===

Später.

= Typumwandlungen =

=== String to Integer ===

Wird einer Integer-Variablen ein String zugewiesen, wird lediglich deren numerischer Inhalt zu Anfang des Strings als Integer-Wert übernommen. Enthält der String überhaupt keinen numerischen Wert zu Anfang, ist der Integer-Wert des Strings 0.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = "1234abc"
console.println (zahl)
endfunction
</syntaxhighlight>

Die Variable Zahl enthält nach der Zuweisung den numerischen Wert 1234.

Dasselbe gilt für Funktionen, die einen Integer-Wert als Parameter erwarten, hier jedoch ein String übergeben wird.

Beispiel:

<syntaxhighlight lang=pas>
function int mult (int a, int b)
return a * b
endfunction

function void main ()
int ergebnis
ergebnis = mult ("2", 3)
console.println (ergebnis)
endfunction
</syntaxhighlight>

=== Integer to String ===

Wird einer String-Variablen ein Integer-Wert zugewiesen, wird dieser automatisch in einen String umgewandelt. Dasselbe gilt für Funktionsparameter, wenn die Funktion einen String als Parameter erwartet.

<syntaxhighlight lang=pas>
function void main ()
string zeichenkette
zeichenkette = 1234
console.println (zeichenkette)
endfunction
</syntaxhighlight>

Ebenso gilt dies für den String-Operator ':', welcher zwei Strings zu einem String zusammensetzt:

<syntaxhighlight lang=pas>
function int mult (int a, int b)
return a * b
endfunction

function void main ()
int ergebnis
string meldung
ergebnis = mult ("2", 3)
meldung = "Das Ergebnis ist " : ergebnis
console.println (meldung)
endfunction
</syntaxhighlight>

Bei dem String-Operator ':' können auch rein numerische Operanden zu einem String zusammengesetzt werden:

<syntaxhighlight lang=pas>
function void main ()
string meldung
meldung = 123 : 456
console.println (meldung)
endfunction
</syntaxhighlight>

Hier wird dann der String "123456" auf der Console ausgegeben.

Kombiniert man beide Typwandlungen (Integer->String und String->Integer), kann man den String-Operator auch auf rein numerische Ausdrücke anwenden, wobei die Zuweisungsvariable auch wieder eine Integer-Variable ist:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 123 : 456
console.println (zahl)
endfunction
</syntaxhighlight>

Hier werden die Zahlen 123 und 456 zunächst in Strings umgewandelt, dann zu einem String zusammengesetzt und bei der Zuweisung wieder zurück in einen Integer-Wert gewandelt. Die Variable 'zahl' enthält nach der Zuweisung den Integer-Wert 123456.

= Kontrollstrukturen =

=== Zuweisung ===

Syntax: VARIABLE = AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
string zeichenkette
int ergebnis

zeichenkette = "Das Ergebnis lautet: "
ergebnis = 1234 * 2
console.println (zeichenkette : ergebnis)
endfunction
</syntaxhighlight>

=== if ===

Syntax:

<syntaxhighlight lang=pas>
if BEDINGUNG1
...
elseif BEDINGUNG2
...
elseif BEDINGUNG3
...
else
...
endif
</syntaxhighlight>

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int zahl

zahl = 33

if zahl < 10
console.println ("Die Zahl is kleiner 10")
elseif zahl < 100
console.println ("Die Zahl is kleiner 100")
elseif zahl > 100
console.println ("Die Zahl is groesser 100")
else
console.println ("Die Zahl is gleich 100")
endif
</syntaxhighlight>

=== loop ===

loop beginnt eine Endlosschleife. Diese kann lediglich mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Endlosschleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
loop
...
endloop
</syntaxhighlight>

Vorzeitiger Abbruch:

<syntaxhighlight lang=pas>
loop
...
break
...
endloop
</syntaxhighlight>

Vorzeitiger Sprung zum Anfang der Schleife

<syntaxhighlight lang=pas>
loop
...
continue
...
endloop
</syntaxhighlight>

Beispiel:

Das folgende Programm lässt die Board-LED auf einem Nucleo-Board leuchten, bis der User-Button gedrückt wird.

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // set pin C13 (user button) to input, has extern pullup
gpio.init (GPIOA, 5, OUTPUT) // board LED = A5
gpio.set (GPIOA, 5) // switch LED on

loop
if gpio.get (GPIOC, 13) = LOW // button pressed?
gpio.set (GPIOA, 5) // switch LED off
break // break loop
endif
endloop
endfunction
</syntaxhighlight>

=== repeat ===

repeat beginnt eine Schleife, welche genau N-mal durchlaufen wird. Die repeat-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
repeat N
...
endrepeat
</syntaxhighlight>

N kann dabei ein beliebiger arithmetischer Ausdruck sein.

Beispiel:

Das folgende Programm gibt die Zahlen 1 bis 9 auf der Console aus.

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 1
repeat 9
console.println (zahl)
zahl = zahl + 1
endrepeat
endfunction
</syntaxhighlight>

=== while ===

Die while-Schleife wird durchlaufen, solange die angegebene Bedingung gegeben ist. Arithmeische Ausdrücke innerhalb der Bedingung werden bei jedem Schleifendurchlauf neu berechnet. Die while-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
while BEDINGUNG
...
endwhile
</syntaxhighlight>

Beispiel:

Das folgende Programm gibt die Zahlen 1 bis 9 auf der Console aus.

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 1
while zahl < 10
console.println (zahl)
zahl = zahl + 1
endwhile
endfunction
</syntaxhighlight>

=== for ===

Die for-Schleife wird für eine anzugebene Schleifenvariable solange durchlaufen, bis der angegebene Stopwert überschritten wird. Optional kann eine Schrittgröße für die Schleifenvariable angegeben werden. Standardmäßig ist diese 1, d.h. die Schleifenvariable wird mit jedem neuen Durchlauf inkrementiert. Ist der Stopwert kleiner als der Startwert, wird die Schleifenvariable mit jedem Durchlauf dekrementiert.

Die for-Schleife kann vorzeitig mit dem Befehl 'break' abgebrochen werden. Der Befehl 'continue' innerhalb der Schleife führt zu einem vorzeitigem Sprung zum Anfang der Schleife.

Syntax:

<syntaxhighlight lang=pas>
for VARIABLE = STARTWERT to STOPWERT [STEP x]
...
endfor
</syntaxhighlight>

VARIABLE muss eine Integer-Variable sein, STARTWERT und STOPWERT ein beliebiger arithmetischer Ausdruck. Im Gegensatz zur while-Schleife, in welcher die Schleifen-Bedingung und damit die arithmetische Ausdrücke jeweils immer neu evaluiert werden, wird bei der for-Schleife STARTWERT und STOPWERT nur einmal berechnet, nämlich unmittelbar vor dem Betreten der Schleife.

Wird kein Step-Wert angegeben, wird die Laufvariable nach jedem Schleifendurchlauf um 1 erhöht. Wird ein abweichender Step-Wert angegeben, wird die Laufvariable um den angegebenen Wert erhöht. Ist der Step-Wert negativ, wird die Variable um den angegebenen Wert erniedrigt.

Beispiel:

Das folgende Programm gibt zunächst die Zahlen 1 bis 9 auf der Console aus. Anschließend werden die Werte von 9 bis 1 rückwärts zählend ausgegeben:

<syntaxhighlight lang=pas>
function void main ()
int zahl
for zahl = 1 to 9
console.println (zahl)
endfor
for zahl = 9 to 1 step -1
console.println (zahl)
endfor
endfunction
</syntaxhighlight>

=== switch ===

* switch, break

=== return ===

* return

= Vergleichsoperatoren =

=== Vergleichsoperator 'equal' ===

* gleich: =

=== Vergleichsoperator 'not equal' ===

* ungleich: !=

=== Vergleichsoperator 'less' ===

* kleiner: <
* kleiner oder gleich: <=

=== Vergleichsoperator 'greater' ===

* größer: >
* größer oder gleich: >=

= Operatoren =

=== Grundrechenarten ===

==== Addition ====

Syntax: AUSDRUCK + AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 3 + 5
console.println (ergebnis)
</syntaxhighlight>

==== Subtraktion ====

Syntax: AUSDRUCK - AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 - 3
console.println (ergebnis)
</syntaxhighlight>

==== Multiplikation ====

Syntax: AUSDRUCK * AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 * 3
console.println (ergebnis)
</syntaxhighlight>

==== Division ====

Die Integer-Division behandelt nur den ganzzahligen Anteil der Division. Für den entstandenen Rest einer Division siehe '''Modulo'''.

Syntax: AUSDRUCK / AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 / 3
console.println (ergebnis) // Ausdruck ist 1
</syntaxhighlight>

'''Bei den Grundrechenarten gilt die Punkt-vor-Strich-Rechnung.'''

=== Modulo-Operator ===

Der Modulo-Operator berechnet den Rest einer Integer-Division.

Syntax: AUSDRUCK % AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
int ergebnis
ergebnis = 5 % 3
console.println (ergebnis) // Ausdruck ist 2
</syntaxhighlight>

'''Der Modulo-Operator bindet (im Gegensatz zu anderen Programmiersprachen!) stärker als die Grundrechenarten.''' Das Ergebnis von
<syntaxhighlight lang=pas>
ergebnis = 2 * 5 % 3
</syntaxhighlight>

ist identisch mit:

<syntaxhighlight lang=pas>
ergebnis = 2 * (5 % 3)
</syntaxhighlight>

Daher ist das Ergebnis hier 2 * 2 = 4.

=== Shift-Operatoren ===

==== Shift Left ====

Der Shift-Operator '<<' verschiebt die Bits einer Zahl nach links.

Syntax: AUSDRUCK << ANZAHL_BITS

Beispiel:
<syntaxhighlight lang=pas>
int zahl
int ergebnis
zahl = 2
ergebnis = zahl << 4 // Verschieben der Zahl 2 um 4 Stellen nach links
console.println (ergebnis) // Ausdruck ist 32
</syntaxhighlight>

==== Shift Left ====

Der Shift-Operator '>>' verschiebt die Bits einer Zahl nach rechts.

Syntax: AUSDRUCK << ANZAHL_BITS

Beispiel:
<syntaxhighlight lang=pas>
int zahl
int ergebnis
zahl = 32
ergebnis = zahl >> 4 // Verschieben der Zahl 32 um 4 Stellen nach rechts
console.println (ergebnis) // Ausdruck ist 2
</syntaxhighlight>

'''Die Shift-Operatoren binden stärker als die Grundrechenarten und der Modulo-Operator.''' Das Ergebnis von
<syntaxhighlight lang=pas>
3 * 1 << 4
</syntaxhighlight>
ist also 3 * 16 = 48.

Wichtig: Beim Verschieben werden die Ausdrücke immer als unsigned-Werte angesehen, d.h. Vorzeichenbits werden nicht besonders behandelt.

=== Bitmask-Operatoren ===

==== Bitwise OR ====

Syntax: AUSDRUCK | AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0x0F | 0xF0, HEX, 2) // Ausdruck ist FF
</syntaxhighlight>

==== Bitwise AND ====

Syntax: AUSDRUCK & AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0xFFFF & 0x00F0, HEX, 4) // Ausdruck ist 00F0
</syntaxhighlight>

==== Bitwise XOR ====

Syntax: AUSDRUCK ^ AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (0xFFFF ^ 0x00F0, HEX, 4) // Ausdruck ist FF0F
</syntaxhighlight>

==== Bitwise Inversion ====

Syntax: ~AUSDRUCK

Beispiel:
<syntaxhighlight lang=pas>
console.println (~0xFF00, HEX, 4) // Ausdruck ist FFFF00FF
console.println (~0xFF00 & 0xFFFF, HEX, 4) // Ausdruck ist 00FF
</syntaxhighlight>

'''Der And-Operator bindet stärker als der OR-Operator. Die Invertierung wirkt unmittelbar auf den nachfolgenden Ausdruck. Sämtliche Bitmask-Operatoren binden stärker als die vorangegangenen Operatoren.'''

=== Klammern ===

Um die obigen Prioritätenregelungen zu durchbrechen, können in den Ausdrücken Klammern gesetzt werden.

Beispiel:
<syntaxhighlight lang=pas>
console.println (3 + 2 * 4) // Ausdruck ist 3 + 8 = 11
console.println ((3 + 2) * 4) // Ausdruck ist 5 * 4 = 20
console.println (3 + 2 << 2) // Ausdruck ist 3 + 8 = 11
console.println ((3 + 2) << 2) // Ausdruck ist 5 << 2 = 20
</syntaxhighlight>

=== String-Operator ===

Der String-Operator fasst zwei Zeichenketten zu einer Zeichenkette zusammen.

Syntax: STRING1 : STRING2

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
string str1
string str2
string str3
str1 = "Hello, "
str2 = "World"
str3 = str1 : str2
console.println (str3) // Ausgabe: "Hello, World"
endfunction
</syntaxhighlight>

Oder auch kürzer:
<syntaxhighlight lang=pas>
function void main ()
string str
str1 = "Hello, "
console.println (str : "World")
endfunction
</syntaxhighlight>

Oder noch kürzer:
<syntaxhighlight lang=pas>
function void main ()
console.println ("Hello, " : "World")
endfunction
</syntaxhighlight>

Der String-Operator wandelt numerische Ausdrücke automatisch in Strings.

Somit führt der Programmabschnitt:
<syntaxhighlight lang=pas>
string str
str = (3 * 5) : " ist das Ergebnis."
console.println (str)
</syntaxhighlight>

zu einem Ausdruck von "15 ist das Ergebnis.".

Wichtig: '''Der String-Operator bindet stärker als alle anderen nicht-unären Operatoren.'''

Fehlende Klammern in Abschnitt:
<syntaxhighlight lang=pas>
string str
str = 3 * 5 : " ist das Ergebnis."
console.println (str)
</syntaxhighlight>
führen also zum Ausdruck von lediglich "15", da der zwischendurch entstehende Ausdruck "5 ist das Ergebnis" für die Multiplikation in einen Integer gewandelt wird. Übrig bleibt daher lediglich 3 * 5. Das Ergebnis wird wegen der Zuweisung wieder zurück in einen String gewandelt. Übrig bleibt "15".

= Bibliotheken =

=== Bibliothek string ===

==== string.length () ====

Die length-Funktion gibt die Länge eines Strings zurück.

Syntax: int string.length (string str)

Parameter:

* string: Die Eingabezeichenkette

Rückgabewert: Länge des Strings

Beispiel:

<syntaxhighlight lang=pas>
int len
len = string.length ("abcdef"); // gibt 6 zurück
</syntaxhighlight>

==== string.substring () ====

Die substring-Funktion kann beliebige Zeichenketten aus einem String extrahieren.

Syntax: string string.substring (string str, int start [, int length ])

Parameter:

* string: Die Eingabezeichenkette
* start: Die Startposition innerhalb des Strings
* length: Die Länge des zu extrahierenden Strings. Der Parameter ist optional.

Die Startposition wird ab 0 gezählt. Ist der Startwert positiv oder 0, wird die Startposition innerhalb des Eingabestrings von links gezählt, anderenfalls von rechts.

Beispiel:

<syntaxhighlight lang=pas>
string rest
rest = string.substring ("abcdef", -1); // gibt "f" zurück
rest = string.substring ("abcdef", -2); // gibt "ef" zurück
rest = string.substring ("abcdef", -3, 1); // gibt "d" zurück
</syntaxhighlight>

Ist length angegeben und positiv, enthält der zurückgegebene String höchstens length Zeichen ab start (abhängig von der Länge von string).

Ist length angegeben und negativ, werden genau so viele Zeichen vom Ende von string abgeschnitten (nachdem die Startposition ermittelt wurde, sollte start negativ sein). Gibt start die Position des abzuschneidenden Teiles oder dahinter an, wird ein leerer String zurückgegeben.

Beispiel:

<syntaxhighlight lang=pas>
rest = string.substring ("abcdef", 0, -1); // gibt "abcde" zurück
rest = string.substring ("abcdef", 2, -1); // gibt "cde" zurück
rest = string.substring ("abcdef", 4, -4); // gibt "" zurück
rest = string.substring ("abcdef", -3, -1); // gibt "de" zurück
</syntaxhighlight>

Die aus Basic bekannten Funktionen 'left', 'right' und 'mid' können alle mit der substring-Funktion abgebildet werden:

<syntaxhighlight lang=pas>
function string left (string str, int l)
return string.substring (str, 0, l)
endfunction

function string right (string str, int l)
return string.substring (str, -l)
endfunction

function string mid (string str, int s, int l)
return string.substring (str, s, l)
endfunction

function void main ()
string x
x = "abcdef"

console.println (left (x, 3)) // gibt "abc" aus
console.println (right (x, 3)) // gibt "def" aus
console.println (mid (x, 2, 2)) // gibt "cd" aus
endfunction
</syntaxhighlight>

=== Bibliothek time ===

==== time.millis () ====

Der Rückgabewert von time.millis() entsprecht der internen "Uhrzeit" des Mikrocontrollers seit dem letzten Boot in Millisekunden.

Syntax: int time.millis ()

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit: " : time)
endfunction
</syntaxhighlight>

==== time.reset () ====

time.reset setzt die interne "Uhrzeit" des Mikrocontrollers zurück auf 0.

Syntax: void time.reset ()

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Reset: " : time)
time.reset ()
time = time.millis ()
console.println ("Zeit nach Reset: " : time)
endfunction
</syntaxhighlight>

==== time.set () ====

time.set setzt die interne "Uhrzeit" des Mikrocontrollers auf den angegebenen Wert

Syntax: void time.reset (int millis)

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Set: " : time)
time.set (1000)
time = time.millis ()
console.println ("Zeit nach Set: " : time)
endfunction
</syntaxhighlight>

==== time.delay () ====

time.delay() wartet die angegebene Zeit in Millisekunden.

Syntax: void time.delay (int msec)

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
int time
time = time.millis ()
console.println ("Zeit vor Delay: " : time)
time.delay (500)
time = time.millis ()
console.println ("Zeit nach Delay: " : time)
endfunction
</syntaxhighlight>

=== Bibliothek console ===

==== console.print () ====

Syntax:
int console.print (int/string EXPRESSION)
oder:
int console.print (int/string EXPRESSION, const TYPE)
oder:
int console.print (int/string EXPRESSION, const TYPE, int WIDTH)

Wird nur das erste Argument übergeben, wird anhand des Parameter-Typs entschieden, ob ein String oder ein Integer-Wert auf der Console ausgedruckt wird. Man kann aber auch steuern, wie der übergebene Parameter behandelt werden soll. Dabei kann TYPE die folgenden Werte haben:

* STR - Der Parameter wird als String behandelt
* DEC - Der Parameter wird als Dezimalzahl gedruckt
* DEC0 - Der Parameter wird als Dezimalzahl gedruckt, jedoch wird das Ausgabefeld mit führenden Nullen aufgefüllt.
* HEX - Der Parameter wird als Hexadezimalzahl gedruckt
* BIN - Der Parameter wird als Binärzahl gedruckt

Mit einem weiteren numerischen Parameter WIDTH kann gesteuert werden, wie breit das Ausgabefeld sein soll. Dann wird der ausgegebene Text auf mindestens diese Anzahl von Zeichen tabuliert, das heißt mit Leerzeichen aufgefüllt. Ist WIDTH positiv, werden Leerzeichen von links beginnend eingefügt, ist WIDTH negativ, werden entsprechend viele Leerzeichen rechts angefügt, um auf die gewünschte Breite zu kommen. Eine Besonderheit ist das Drucken von HEX- oder BIN-Zahlen: Bei positivem Wert von WIDTH wird das Feld mit Nullen statt Leerzeichen aufgefüllt. Bei Dezimalzahlen geht dieses über den Typ DEC0.

Rückgabewert: Anzahl der gedruckten Zeichen.

Beispiele siehe console.println ().

==== console.println () ====

Syntax:
int console.println (int/string EXPRESSION)
oder:
int console.println (int/string EXPRESSION, const TYPE)
oder:
int console.println (int/string EXPRESSION, const TYPE, int WIDTH)

Das Verhalten entspricht exakt der Funktion console.print(). Jedoch wird noch nach dem Ausdruck ein CRNL-Paar angefügt, um eine neue Zeile zu beginnen.

Beispiele:

<syntaxhighlight lang=pas>
function void main ()
int i

i = 4711
console.println (i) // 4711
console.println (i, DEC) // 4711
console.println (i, HEX) // 1267
console.println (i, BIN) // 1001001100111

i = 0xFFFFFFFF
console.println (i, HEX) // FFFFFFFF
console.println (i >> 1, HEX) // 7FFFFFFF

i = 0xFFFF
console.println (i, HEX) // FFFF
console.println (i, HEX, 8) // 0000FFFF
console.println (i >> 1, HEX, 8) // 7FFF

i = 0xFF
console.println (i, HEX, 2) // FF
console.println (i >> 1, HEX, 2) // 7F
console.println (i >> 1, BIN, 16) // 0000000001111111

console.println (0xAA, BIN, 8) // 10101010
console.println (1, BIN, 32) // 00000000000000000000000000000001

console.println ("Hallo, Welt") // Hallo, Welt
console.println ("42 Hallo, Welt") // 42 Hallo, Welt
console.println ("42 Hallo, Welt", DEC) // 42
console.println ("42 Hallo, Welt", BIN) // 101010
endfunction
</syntaxhighlight>

=== Bibliothek gpio ===

==== gpio.init () ====

Initialisiert General Purpose I/O für einen Pin.

Syntax:
void gpio.init (PORT, BIT, INPUT [, NOPULL | PULLDOWN | PULLUP ])
oder
void gpio.init (PORT, BIT, OUTPUT [, PUSHPULL | OPENDRAIN ])

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 
Für die Datenrichtung muss entweder die Konstante INPUT oder die Konstante OUTPUT vorgegeben werden. 

Bei Verwendung des Pins als INPUT können folgende Alternativen eingestellt werden:

* '''NOPULL (Default):''' Der Eingang wird nicht durch einen internen Pullup oder Pulldown beeinflusst
* '''PULLDOWN:''' Es wird der interne Pulldown-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel LOW.
* '''PULLUP:''' Es wird der interne Pullup-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel HIGH.

Bei Verwendung des Pins als OUTPUT können folgende Alternativen eingestellt werden:

* '''PUSHPULL (Default):''' Der Ausgang wird möglichst niederohmig geschaltet.
* '''OPENDRAIN:''' Der Low-Pegel wird möglichst niederohmig geschaltet, der High-Pegel ist hochohmig.

Der letzte Parameter von gpio.init() ist optional. Wird er weggelassen, wird der jeweilige Standardwert (Default) eingestellt.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // C13 als Input, kein Pulldown/Pullup
gpio.init (GPIOC, 13, INPUT, PULLUP) // C13 als Input mit Pullup
endfunction
</syntaxhighlight>

==== gpio.set () ====

Setzt den ausgewählten Pin auf High-Pegel.

Syntax: void gpio.set (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
gpio.set (GPIOA, 5) // Pin auf HIGH
endfunction
</syntaxhighlight>

==== gpio.reset () ====

Setzt den ausgewählten Pin auf Low-Pegel.

Syntax: void gpio.reset (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
gpio.reset (GPIOA, 5) // Pin auf Low
endfunction
</syntaxhighlight>

==== gpio.toggle () ====

Invertiert den Zustand des ausgewählten Pins.

Syntax: void gpio.toggle (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOA, 5, OUTPUT) // A5 als Output
loop
gpio.toggle (GPIOA, 5) // A5 invertieren
time.delay (500) // eine halbe Sekunde warten
endloop
endfunction
</syntaxhighlight>

==== gpio.get () ====

Liest den Zustand des ausgewählten Pins.

Syntax: int gpio.get (PORT, BIT)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Der Rückgabewert ist entweder LOW oder HIGH.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
gpio.init (GPIOC, 13, INPUT) // set pin C13 (user button) to input, has extern pullup
gpio.init (GPIOA, 5, OUTPUT) // board LED = A5
gpio.set (GPIOA, 5) // switch LED on

loop
if gpio.get (GPIOC, 13) = LOW // button pressed?
gpio.set (GPIOA, 5) // switch LED off
break // break loop
endif
endloop
endfunction
</syntaxhighlight>

=== Bibliothek bit ===

==== bit.set () ====

bit.set() setzt ein Bit.

Syntax: int bit.set (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = bit.set (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00100000
endfunction
</syntaxhighlight>

Alternativ kann man auch den Operator '|' nutzen, um ein Bit zu setzen:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = zahl | (1<<5)
console.println (zahl, BIN) // Ausgabe: 00100000
endfunction
</syntaxhighlight>

==== bit.reset () ====

bit.reset() setzt ein Bit zurück.

Syntax: int bit.reset (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b11111111
zahl = bit.reset (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 11011111
endfunction
</syntaxhighlight>

Alternativ kann man auch den Operator '&' zusammen mit '~' nutzen, um ein Bit zu zurückzusetzen:

<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b11111111
zahl = zahl & ~(1<<5)
console.println (zahl, BIN) // Ausgabe: 11011111
endfunction
</syntaxhighlight>

==== bit.toggle () ====

bit.toggle() wechselt den Zustand eines Bits.

Syntax: int bit.toggle (int value, int bit)

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int zahl
zahl = 0b00000000
zahl = bit.toggle (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00100000
zahl = bit.toggle (zahl, 5)
console.println (zahl, BIN) // Ausgabe: 00000000
endfunction
</syntaxhighlight>

==== bit.isset () ====

bit.isset() gibt den Zustand eines Bits zurück

Syntax: int bit.isset (int value, int bit)

Rückgabewert: TRUE, wenn das Bit gesetzt ist, sonst FALSE.

Beispiel:
<syntaxhighlight lang=pas>
function void main ()
int bit
bit = bit.isset (0b11111111, 5)
if bit = TRUE
else
console.println ("bit is set")
endif
console.println ("bit is not set")
endfunction
</syntaxhighlight>

=== Bibliothek button ===

==== button.init () ====

Definiert einen GPIO-Pin als Tastereingang. Der Taster wird automatisch vom NIC-Laufzeitsystem per Software entprellt.

Syntax:
int button.init (PORT, BIT, MODE)

Als PORT kann GPIOA, GPIOB, GPIOC usw. gewählt werden. 
BIT ist das jeweilige Bit am I/O-Port, beim STM32 also ein Wert von 0 bis 15. 

Bei Verwendung des Tastereingangs können folgende Alternativen für MODE eingestellt werden:

* '''PULLDOWN:''' Es wird der interne Pulldown-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel LOW.
* '''PULLUP:''' Es wird der interne Pullup-Widerstand hinzugeschaltet, d.h. bei offenem Eingang ist der Pegel HIGH.
* '''NOPULLDOWN:''' Für den Tastereingang ist die Hinzuschaltung des internen Pulldowns nicht notwendig, Taster ist active high.
* '''NOPULLUP:''' Für den Tastereingang ist die Hinzuschaltung des internen Pullups nicht notwendig, Taster ist active high.

Daraus ergibt sich, dass bei Einstellung PULLDOWN der Schalter gegen Vcc, bei Einstellung PULLUP der Schalter gegen GND schalten muss. Dasselbe gibt für NOPULLDOWN bzw. NOPULLUP. Hier muss die externe Beschaltung selbst für einen definierten Pegel sorgen, zum Beispiel bei NOPULLUP durch Anschluss eines '''externen''' Pullups.

Das NIC-Laufzeitsystem vergibt eine interne Tastennummer größer Null, die bei Abfragen durch button.pressed() dann angegeben werden muss. Bis zu 8 solcher Tasten können mittels button.init() definiert werden. Wenn button.init() eine 0 zurückliefert, sind bereits alle 8 Tasten definiert.

Beispiel:

Beim Nucleo hängt der blaue User-Taster an PC13 und schaltet gegen GND. Da hier bereits ein externer Pullup-Widerstand vorgesehen ist, muss '''kein interner Pullup-Widerstand''' aktiviert werden.

<syntaxhighlight lang=pas>
function void main ()
int button

button = button.init (GPIOC, 13, NOPULLUP) // C13 als Input, kein interner Pullup nötig, active low
...
endfunction
</syntaxhighlight>

Beim STM32F103 Mini-Development-Board gibt es bis auf den RESET-Taster keinen weiteren Taster auf dem Board. Wir können aber zum Beispiel einen Taster an PA6 anschließen, so dass er gegen GND schaltet. Den externen Pullup sparen wir uns und verwenden dafür den internen Pullup am Pin:

<syntaxhighlight lang=pas>
function void main ()
int button

button = button.init (GPIOA, 6, PULLUP) // PA6 als Input mit internem Pullup, active low
...
endfunction
</syntaxhighlight>

==== button.pressed () ====

Abfrage des Tasters.

Syntax:
int button.pressed (int button)

button ist dabei die Taster-Nummer, die von button.init() zurückgegeben wurde.

Rückgabewerte:

TRUE: Taste ist gedrückt
FALSE: Taste wurde nicht gedrückt.

Beispiel:

Einschalten der Board-LED, sobald die blaue User-Taste gedrückt wird, sonst ausschalten.

<syntaxhighlight lang=pas>
function void main ()
int button
gpio.init (GPIOA, 5, OUTPUT) // LED als Output
gpio.reset (GPIOA, 5) // Pegel low: LED ist aus

button = button.init (GPIOC, 13, NOPULLUP) // C13 als Input, kein interner Pullup nötig, active low

loop
if button.pressed (button) = TRUE // Taste gedrückt?
gpio.set (GPIOA, 5) // ja, LED einschalten
else
gpio.reset (GPIOA, 5) // nein, LED ausschalten
endif
endloop
endfunction
</syntaxhighlight>

Beim STM32F103 Mini-Development-Board gibt es eine blaue LED auf dem Board. Sie ist an PC13 angeschlossen. Allerdings muss diese gegen GND geschaltet werden, damit sie leuchtet. Sie ist also "active low" - im Gegensatz zur Nucleo-LED. Die Set- und Reset-Befehl werden hier daher ausgetauscht:

<syntaxhighlight lang=pas>
function void main ()
int button
gpio.init (GPIOC, 13, OUTPUT) // LED als Output
gpio.set (GPIOC, 13) // Pegel high: LED ist aus

button = button.init (GPIOA, 6, PULLUP) // PA6 als Input mit internem Pullup, active low

loop
if button.pressed (button) = TRUE // Taste gedrückt?
gpio.reset (GPIOC, 13) // ja, LED einschalten
else
gpio.set (GPIOC, 13) // nein, LED ausschalten
endif
endloop
endfunction
</syntaxhighlight>

=== Bibliothek ws2812 ===

==== ws2812.init () ====

Mit ws2812.init() wird die WS2812-LED-Bibliothek initialisiert.

Syntax:

void ws2812.init (int nleds)

Als Argument ist die maximale Anzahl der verwendeten LEDs in der Kette anzugeben.

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
ws2812.init (30) // 30 LEDs auf dem Stripe
...
endfunction
</syntaxhighlight>

==== ws2812.set () ====

Damit wird die Farbe einer oder aller WS2812-LEDs gesetzt.

Syntax:

void ws2812.set (int led, int red, int green, int blue)

led gibt die Nummer der LED an - beginnend mit 0. Wird als Nummer die Anzahl der verwendeten LEDs angegeben, werden die Farben sämtlicher verwendeter LEDs gesetzt. Die Farben können Werte zwischen 0 (aus) und 255 (volle Helligkeit) haben.

Der Set-Befehl setzt die angebenen Farben erst einmal nur im RAM. Erst mit dem ws2812.refresh()-Befehl werden dann sämtliche gesetzten Farben an die LEDs übertragen.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30

function void main ()
int i

ws2812.init (MAXLEDS) // 30 LEDs auf dem Stripe
ws2812.set (MAXLEDS, 128, 128, 128) // Alle LEDs auf weiß, halbe Helligkeit

for i = 0 to MAXLEDS
ws2812.set (i, 0, 128, 128) // Eine LEDs auf türkis, halbe Helligkeit
ws2812.refresh (MAXLEDS) // Ausgabe
delay (200) // 0,2 Sekunden warten
endfor
endfunction
</syntaxhighlight>

==== ws2812.refresh () ====

ws2812.refresh() überträgt sämtliche zuvor gesetzte Farben an die LEDs.

Syntax:

void ws2812.refresh (nleds)

Das Argument nleds bestimmt, wieviele der LEDs aktualisiert werden sollen. Der Maximalwert ist derjenige, der bei ws2812.init() angegeben wurde. Dann werden alle LEDs aktualisiert.

Beispiel:

<syntaxhighlight lang=pas>
const int MAXLEDS = 30

function void main ()
ws2812.init (MAXLEDS) // 30 LEDs auf dem Stripe
...
ws2812.refresh (MAXLEDS) // Ausgabe: Alle LEDs aktualisieren
...
endfunction
</syntaxhighlight>

Konkreteres Beispiel siehe oben: [[NIC#ws2812.set_.28.29|ws2812.set()]].

=== Bibliothek irmp ===

==== irmp.init () ====
==== irmp.get () ====

=== Bibliothek irsnd ===

==== irsnd.init () ====
==== irsnd.send () ====

=== Bibliothek i2c ===

==== i2c.init () ====

i2c.init () initialisiert die jeweils gewünschte I2C-Schnittstelle.

Syntax:

void i2c.init (int channel, int alternate, int clockspeed)

Parameter:

* channel: I2C-Channel. Erlaubte Werte: I2C1, I2C2 oder I2C3. Welche Werte davon möglich sind, ist prozessorabhängig.
* alternate: Flag, ob die alternative Pinkonfiguration verwendet werden soll, siehe Tabelle.
* clockspeed: Taktgeschwindigkeit. Standard ist 100000 (100k), möglich ist aber auch 400000 (400k) für schnelle Peripherie

{| {{Tabelle}}
|+ '''Mögliche I2C-Channel'''
|- style="background-color:#eeeeee"
! Channel || ALT || STM32F4x1 Nucleo || STM32F103C8T6
|-
| I2C1 || 0 || SCL=PB6, SDA=PB7|| SCL=PB6, SDA=PB7
|-
| I2C2 || 0 || SCL=PB10, SDA=PB3 ||
|-
| I2C3 || 0 || SCL=PA8, SDA=PB4 ||
|-
| I2C1 || 1 || SCL=PB8, SDA=PB9 || SCL=PB8, SDA=PB9
|-
| I2C2 || 1 || ||
|-
| I2C3 || 1 || SCL=PA8, SDA=PC9 ||
|-
|}

Beispiel:

<syntaxhighlight lang=pas>
function void main ()
i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k
...
endfunction
</syntaxhighlight>

==== i2c.write () ====

i2c.write() schreibt einen Datenpuffer auf die gewählte I2C-Schnittstelle.

Syntax:

int i2c.write (int channel, int address, int startaddress, int flag, byte buffer[], int length)

Parameter:

* channel: I2C-Channel, siehe i2c.init()
* address: I2C-Adresse des anzusprechenden Moduls
* startaddress: Start-Adresse für die Daten
* flag: Flag, ob die Start-Adresse ein 8- oder 16-Bit-Wert ist: TRUE: 16-Bit, FALSE: 8-Bit
* buffer: Datenpuffer
* length: Länge der Daten

Beispiel:

Schreiben des Datums "2017-06-10 16:32:12" in eine DS3231 Real Time Clock:

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// write date/time to DS3231
//-----------------------------------------------------------------------------------
const int RTC = 0xD0 // I2C address of DS3231 RTC

int year = 2017
int mon = 6
int mday = 10
int hour = 16
int min = 32
int sec = 12

//-----------------------------------------------------------------------------------
// convert decimal number into BCD format
//-----------------------------------------------------------------------------------
function int dec2bcd (int i)
i = ((i / 10) << 4) | (i % 10)
return i
endfunction

//-----------------------------------------------------------------------------------
// main function: set date/time to 2017-06-10 16:32:12
//-----------------------------------------------------------------------------------
function void main ()
byte buf[7] // Data buffer

i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k

year = year % 100 // 2000 - 2099 -> 00 - 99

buf[0] = dec2bcd (sec) // seconds (0-59)
buf[1] = dec2bcd (min) // minutes (0-59)
buf[2] = dec2bcd (hour) // hours (0-24)
buf[3] = 0 // wday (unknown) (0-6)
buf[4] = dec2bcd (mday) // day of month (0-31)
buf[5] = dec2bcd (mon) // month (1-12)
buf[6] = dec2bcd (year) // year (00-99)

rtc = i2c.write (I2C1, RTC, 0x00, FALSE, buf, 7) // write to RTC
endfunction
</syntaxhighlight>

Die RTC erwartet lediglich 8-Bit-Startadressen. Deshalb wird hier das Flag beim Aufruf von i2c.write() auf FALSE gesetzt.

==== i2c.read () ====

i2c.read() liest Daten von der gewählten I2C-Schnittstelle.

Syntax:

int i2c.read (int channel, int address, int startaddress, int flag, byte buffer[], int length)

Parameter:

* channel: I2C-Channel, siehe i2c.init()
* address: I2C-Adresse des anzusprechenden Moduls
* startaddress: Start-Adresse für die Daten
* flag: Flag, ob die Start-Adresse ein 8- oder 16-Bit-Wert ist: TRUE: 16-Bit, FALSE: 8-Bit
* buffer: Datenpuffer
* length: Länge der Daten

Beispiel:

Lesen von Datum/Uhrzeit aus DS3231 Real Time Clock und Ausgabe auf der Console:

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// read date/time from DS3231 RTC
//-----------------------------------------------------------------------------------
const int RTC = 0xD0 // I2C address of DS3231 RTC

int year
int mon
int mday
int hour
int min
int sec

//-----------------------------------------------------------------------------------
// convert BCD format into decimal number
//-----------------------------------------------------------------------------------
function int bcd2dec (byte i)
i = 10 * ((i & 0xF0) >> 4) + (i & 0x0F)
return i
endfunction

//-----------------------------------------------------------------------------------
// main function: get date/time from RTC
//-----------------------------------------------------------------------------------
function void main ()
byte buf[7] // Data buffer
int rtc

i2c.init (I2C1, FALSE, 100000) // Channel 1, SCL=PB6, SDA=PB7, 100k

rtc = i2c.read (I2C1, RTC, 0x00, FALSE, buf, 7) // read from RTC

if rtc = TRUE
sec = bcd2dec (buf[0]) // seconds (0-59)
min = bcd2dec (buf[1]) // minutes (0-59)
hour = bcd2dec (buf[2]) // hours (0-24)
mday = bcd2dec (buf[4]) // day of month (0-31)
mon = bcd2dec (buf[5]) // month (1-12)
year = bcd2dec (buf[6]) // year (00-99)
year = year + 2000 // 00 - 99 -> 2000 - 2099

console.print (year, DEC0, 4) // print YYYY-DD-MM hh:mm:ss
console.print ("-")
console.print (mon, DEC0, 2)
console.print ("-")
console.print (mday, DEC0, 2)
console.print (" ")
console.print (hour, DEC0, 2)
console.print (":")
console.print (min, DEC0, 2)
console.print (":")
console.print (sec, DEC0, 2)
console.println ("")
endif
endfunction
</syntaxhighlight>

Die RTC erwartet lediglich 8-Bit-Startadressen. Deshalb wird hier das Flag auf FALSE gesetzt.

'''Weiteres Beispiel: Lesen/Schreiben eines EEPROMs:'''

<syntaxhighlight lang=pas>
//-----------------------------------------------------------------------------------
// main function: write some values into EEPROM, read them from EEPROM again
//-----------------------------------------------------------------------------------
function void main ()
byte buffer1[8]
byte buffer2[8]
int rtc
int i

for i = 0 to 7
buffer1[i] = i
endfor

rtc = i2c.write (I2C1, EEPROM, 0x0000, TRUE, buffer1, 8) // write buffer1 to EEPROM

if rtc = FALSE
console.println ("i2c write error!")
endif

rtc = i2c.read (I2C1, EEPROM, 0x0000, TRUE, buffer2, 8) // read buffer2 from EEPROM

if rtc = FALSE
console.println ("i2c read error!")
endif

for i = 0 to 7
console.println (buffer2[i])
endfor
endfunction
</syntaxhighlight>

Da das EEPROM 16-Bit-Startadressen erwartet, wird hier das Flag auf TRUE gesetzt.

=== Bibliothek rtc ===

==== rtc.read () ====
==== rtc.write () ====

=== Bibliothek eeprom ===

==== eeprom.read () ====
==== eeprom.write () ====

=== Bibliothek onewire ===

==== onewire.init () ====
==== onewire.read () ====

=== Bibliothek ds1820 ===

==== ds1820.init () ====
==== ds1820.read () ====

=== Bibliothek lcd ===

==== lcd.init () ====
==== lcd.move () ====
==== lcd.print () ====

=== Bibliothek spi ===

==== spi.init () ====
==== spi.read () ====
==== spi.write () ====

= Beispielprojekt - Lauflicht mit WS2812 =

Im folgenden wird ein Lauflicht mit 30 WS2812-LEDs realisiert. Die erste Variante läuft noch mit der delay-Funktion, welche keinen Spielraum mehr lässt für andere Sachen, die eventuell auch noch abgearbeitet werden sollen.

Die zweite Variante ist da schon wesentlich eleganter. Sie wird nur aktiv, wenn auch Änderungen auf unserem LED-Streifen vonnöten sind.

Die dritte Variante dagegen überlässt dem NIC-Laufzeitsystem die Zeitmessung bis zum nächsten LED-Update, so dass man sich darum nicht mehr kümmern muss. Desweiteren kann man bis zu 8 solcher Alarm-Timer gleichzeitig aktivieren, so dass man hier auch ganz verschiedene Aufgaben mit unterschiedlichen Aktivierungszeiten implementieren kann. Hier wird der Alarm-Timer noch gepollt, d.h. explizit abgefragt.

In der letzten und vierten Variante wird auch dieses noch dem NIC-Runtime-System überlassen. Hier geben wir einfach eine NIC-Funktion an, welche automatisch aufgerufen werden soll, wenn der Alarm eintrifft.

=== Lauflicht mit Delay ===

Die erste Variante arbeitet mit einem Delay, welches den Prozessor warten lässt. Währenddessen kann man keine anderen Aktionen im Programm ausführen.

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED

ws2812.init (MAX_LEDS) // Initialisierung

loop
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
time.delay (500) // Eine halbe Sekunde warten
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Millis-Timer ===

Diese Variante ermittelt mittels time.millis(), wann es aktiv werden soll und kann währenddessen noch andere Aufgaben erledigen. Allerdings wird hier der millis-Timer verwendet, so dass dieser nicht mehr für andere Dinge zur Verfügung steht.

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED

ws2812.init (MAX_LEDS) // Initialisierung
time.reset () // Setze "Uhrzeit" zurueck

loop
if time.millis() > 500 // Eine halbe Sekunde erreicht?
time.reset () // Ja, Zeit wieder zuruecksetzen
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
else
// ... // Hier koennen nun andere Aufgaben erledigt werden!
endif
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Alarm ===

Die dritte Variante verwendet einen von acht Alarm-Timern. Das ist damit die Luxusversion. Der millis-Timer wird nicht verwendet. Neben diesem können noch sieben weitere Alarm-Timer für andere Aufgaben benutzt werden:

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void main ()
int red = 128 // Rot auf halbe Helligkeit
int green = 0 // Gruen aus
int blue = 0 // Blau aus
int led // Aktive LED
int timer1 // alarm-timer

ws2812.init (MAX_LEDS) // Initialisierung
timer1 = alarm.set (500) // Alarm initialisieren

loop
if alarm (timer1) = TRUE // Alarm gesetzt?
ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
else
// ... // Hier koennen nun andere Aufgaben erledigt werden!
endif
endloop
endfunction
</syntaxhighlight>

=== Lauflicht mit Alarm als Interrupt ===

In der letzten und vierten Variante wird das Pollen des Alarm-Timers dem NIC-Runtime-System überlassen. Hier geben wir einfach eine NIC-Funktion an, welche aufgerufen werden soll, wenn der Alarm eintrifft:

<syntaxhighlight lang=pas>
int MAX_LEDS = 30 // Anzahl der benutzten LEDs

function void lauflicht ()
static int red = 128 // Rot
static int green = 0 // Gruen
static int blue = 0 // Blau
static int led // Aktive LED

ws2812.set (MAX_LEDS, 0, 0, 0) // Alle LEDs aus
ws2812.set (led, red, green, blue) // Eine LED leuchten lassen
ws2812.refresh (MAX_LEDS) // Zustand aktualisieren
led = led + 1 // Naechste LED
if led >= MAX_LEDS // Ende erreicht?
led = 0 // Ja, zurueck zum Anfang
endif
endfunction

function void main ()
ws2812.init (MAX_LEDS) // Initialisierung
alarm.set (500, function.lauflicht) // lauflicht() alle 500msec automatisch aufrufen lassen

loop
// ... // Hier koennen nun komplett andere Aufgaben erledigt werden!
endloop
endfunction
</syntaxhighlight>

Die Variablen led, red, green und blue sind nun alle in die Funktion lauflicht() gewandert. Die Definition als static-Variable lassen sie über die ganze Laufzeit des Programms "leben", d.h. sie verlieren nicht ihren Wert, wenn die Funktion wieder verlassen wird. Alternativ können sie auch einfach als globale Variablen definiert werden. Der Vorteil der static-Definition ist jedoch, dass sie ausschließlich in der Funktion lauflicht() manipuliert werden können.

= Beispielprojekt - Knight Rider mit WS2812 =

= Beispielprojekt - Equinox-Uhr mit WS2812 =

= Erstellung eigener NIC-Bibliotheksfunktionen =

= Benchmarks =

=== Sieb des Eratosthenes ===

Es geht um die Ermittlung sämtlicher Primzahlen bis 100.000.

Sieb des Eratosthenes in NIC:
<syntaxhighlight lang=pas>
function void main ()
int limit = 100000
int zahl
int zaehler
int primzahl
int letzte_primzahl

for zahl = 2 to limit
primzahl = TRUE

for zaehler = 2 to zahl / 2
if zahl % zaehler = 0
primzahl = FALSE
break
endif
endfor

if primzahl = TRUE
// console.println (zahl : " ist eine Primzahl")
letzte_primzahl = zahl
endif
endfor
console.println ("Die hoechste ermittelte Primzahl ist " : letzte_primzahl)
endfunction
</syntaxhighlight>

Sieb des Eratosthenes in PHP:
<syntaxhighlight lang=php>
<?php
$limit = 100000;

for ($zahl = 2; $zahl <= $limit; $zahl++)
{
$primzahl = true;

for ($zaehler = 2; $zaehler <= $zahl / 2; $zaehler++)
{
if ($zahl % $zaehler == 0)
{
$primzahl = false;
break;
}
}

if ($primzahl)
{
// print ("" . $zahl . " ist eine Primzahl\n");
$letzte_primzahl = $zahl;
}
}
print ("Die hoechste ermittelte Primzahl ist " . $letzte_primzahl . "\n");
?>
</syntaxhighlight>

Sieb des Eratosthenes in Python:
<syntaxhighlight lang=python>
def main():
limit = 100000

for zahl in range (2, limit):
primzahl = True

for zaehler in range (2, zahl / 2):
if zahl % zaehler == 0:
primzahl = False
break

if primzahl == True:
letzte_primzahl = zahl
print "Die hoechste ermittelte Primzahl ist %d" % (letzte_primzahl)
return 0

if __name__ == '__main__':
main()
</syntaxhighlight>

Sieb des Eratosthenes in Lua:
<syntaxhighlight lang=lua>
local limit = 100000
local zahl
local zaehler
local primzahl
local letzte_primzahl

for zahl = 2, limit do
primzahl = true

for zaehler = 2, zahl / 2 do
if zahl % zaehler == 0 then
primzahl = false
break
end
end

if primzahl == true then
-- print (zahl, "ist eine Primzahl")
letzte_primzahl = zahl
end
end
print ("Die hoechste ermittelte Primzahl ist ", letzte_primzahl)
</syntaxhighlight>

Die Umsetzung in PHP, Python und Lua wurde durch 1:1-Ersetzung jeder Zeile durch die adäquate Formulierung in der jeweiligen Programmiersprache vorgenommen. Die Programme sind damit direkt vergleichbar.

Ausführungszeiten:

{| {{Tabelle}}
|+ '''Ergebnisse: Sieb des Eratosthenes'''
|- style="background-color:#eeeeee"
! Programmiersprache || Version || i7-2600 CPU @ 3.40GHz || Intel T6500 @ 2.10GHz
|-
| '''NIC''' || 0.9 || 5,3 sec || 17,3 sec
|-
| '''PHP''' || 5.6.23 || 10,4 sec ||
|-
| '''Python''' || 2.7 || 25,6 sec || 118 sec
|-
| '''Lua''' || 5.2 || 6,1 sec ||
|}

Es empfiehlt sich nicht, obiges Programm auf dem STM32 mit dem oben verwendeten Startwert 100000 laufen zu lassen. Dabei muss man schon seeeehr lange warten, da der STM32 doch um einiges langsamer ist als ein moderner Intel-Prozessor. Für eigene Messungen auf dem STM32 empfiehlt sich ein Startwert von 10000, also eine Größenordnung geringer.

= Anhang =

=== Compiler-Warnungen ===

'''function 'foo' not used.'''

Die Funktion namens foo ist zwar definiert, wird aber nicht aufgerufen.

'''variable 'foo' not used.'''

Die Variable 'foo' wird zwar definiert, aber nicht verwendet.

'''variable 'foo' set but not used.'''

Die Variable 'foo' wird zwar zwischenzeitlich gesetzt, aber sonst nicht weiter verwendet.

'''local variable 'foo' shadows global variable 'foo' defined in line NN.'''

Die lokale Variable 'foo' überdeckt die globale gleichnamige Variable. Dies kann je nach Kontext zu unerwünschten Effekten führen: In der Funktion, wo die lokale Variable definiert wurde, wird dann der Wert dieser lokalen Variablen verwendet, in allen anderen Funktionen jedoch der Wert der globalen Variablen.

=== Compiler-Fehlermeldungen ===

'''return with a value, in function returning void.'''

Die definierte void-Funktion liefert unzulässigerweise einen Return-Wert zurück.

'''return with no value, in function returning non-void.'''

Die definierte Funktion mit Datentyp als Rückgabewert liefert unzulässigerweise keinen Return-Wert zurück.

'''keyword 'foo' unexpected.'''

Das Schlüsselwort 'foo' ist an der angegebenen Stelle unerwartet und damit falsch.

'''Variable 'foo' already defined.'''

Die Variable 'foo' wurde bereits definiert.

'''break stack overflow.'''

Die Schachtelungstiefe von Schleifen ist zu tief und somit kann die aktuelle Schleife nicht mehr durch einen Break-Befehl unterbrochen werden.

'''continue stack overflow.'''

Die Schachtelungstiefe von Schleifen ist zu tief und somit kann die aktuelle Schleife nicht mehr durch einen Continue-Befehl am Anfang der Schleife fortgesetzt werden.

'''double negation not allowed.'''

Eine doppelte Negation eines numerischen Wertes ist nicht erlaubt.

'''empty expression.'''

Der erwartete arithmetische Ausdruck ist leer.

'''invalid argument type 'foo' in function 'bar', argument #NN.'''

Der angegebene Parameter an NN-ter Stelle hat einen ungültigen Datentyp.

'''main must be defined as function returning void.'''

Die main-Funktion muss stets vom Datentyp void definiert werden.

'''no main function found.'''

Ein NIC-Programm muss immer eine main-Funktion als Startpunkt enthalten.

'''function 'foo' already defined.'''

Die Funktion namens 'foo' wurde bereits definiert.

'''function 'foo' returns void.'''

Es wird versucht, den Rückgabewert einer Funktion 'foo' weiterzuverwenden, obwohl der Datentyp dieser Funktion 'void' ist.

'''function 'foo' undefined.'''

Die aufgerufene Funktion 'foo' ist nicht definiert.

'''unterminated string.'''

Die angegebene Zeichenkette wurde nicht mit dem Anführungszeichen terminiert.

'''missing 'endfoo' at end of file.'''

Ein geöffneter Kontrollblock wurde nicht geschlossen.

'''missing arguments for function 'foo'.'''

Es wurden keine Parameter für die Funktion foo angegeben.

'''missing closing bracket.'''

Eine geöffnete Klammer wurde nicht geschlossen.

'''no matching ')' found.'''

Zu einer geschlossenen Klammer wurde die dazugehörende geöffnete Klammer nicht gefunden.

'''missing return before 'endfunction'.'''

Das Return-Statement unmittelbar vor dem Ende der Funktion fehlt.

'''no compare operator found.'''

Es wurde kein Vergleichsoperator im Ausdruck angegeben.

'''number of arguments wrong for call of function 'foo', expected NN.'''

Die Anzahl der Parameter für den Aufruf der Funktion 'foo' ist falsch, richtig ist NN.

'''syntax error. Use brackets around negative expression.'''

Ein Ausdruck mit einem negativen Operanden (wie z.B. "3 * -2") bedeutet einen Syntax-Error. In diesem Fall muss der zu negierende Operand geklammert werden, also: "3 * (-2)".

'''too many arguments for function 'foo'.'''

Zu viele Parameter für den Aufruf der Funktion namens 'foo'.

'''too many closing brackets.'''

Der Ausdruck enthält zu viele geschlossene Klammern.

'''too many open brackets.'''

Der Ausdruck enthält zu viele geöffnete Klammern.

'''too many expressions.'''

Der Ausdruck ist zu komplex.

'''variable 'foo' already defined.'''

Die Variable 'foo' wurde bereits definiert.

'''variable 'foo' not defined.'''

Die Variable 'foo' wurde vorher nicht definiert.