Vorläufige
Referenz zu
espScript32**
Juni 24
powered by
mmiscool’s ESP8266Basic
---
H. Berndt, 2024 (BT24)
LED = 4
While True
PinOut LED,1
Pause 500
PinOut LED,0
Pause 500
Wend
___
Diese Skriptsprache basiert auf dem von Michael Moulinari (mmiscool) auf esp8266basic.com veröffentlichten und beschriebenen Original und ist dazu in hohem Maße kompatibel. Dateien zum Hochladen dieser Sprache auf ESP32, ESP32-S2, ESP32-C3 und ESP32-S3 stehen über Links auf hjberndt.de/esp32 zur Verfügung. Mit * gekennzeichnete Aufrufe verhalten sich anders als im Original oder sind neu hinzugekommen. Alle Funktionen, die sich noch im experimentellen Status befinden, sind mit ** gekennzeichnet. Seit 2023 existiert ein Pendant für den RP Pico W mit RP2040.
Erstellt und erweitert von H. Berndt ab 2024 (BT24) mittels Arduino IDE 2.1.0 und ESP-Core 2.0.11 und den weiter unten angegebenen eingebundenen Bibliotheken.
Bedingung für die Erstellung dieses Betriebssystems sind 4MB Flash, WiFi4, sowie die Kompatibilität der Hardware mit der Arduino IDE 2. Dies gilt zurzeit für den ESP8266, den Raspberry Pi PicoW und folgende ESP32:
|
Peripheriegerät |
ESP32 |
ESP32S2 |
ESP32C3 |
ESP32S3 |
|
ADC |
x |
x |
x |
x |
|
Bluetooth |
x |
|||
|
BLE |
x |
x |
x |
|
|
DAC |
x |
x |
||
|
GPIO |
x |
x |
x |
x |
|
Hall-Sensor |
x |
|||
|
I2C |
x |
x |
x |
x |
|
I2S |
x |
x |
x |
x |
|
LEDC |
x |
x |
x |
x |
|
SPI |
x |
x |
x |
x |
|
Temperatursensor |
x |
x |
x |
x |
|
UART |
x |
x |
x |
x |
|
USB |
x |
x |
x |
|
|
WLAN |
x |
x |
x |
x |
Durch die gleichzeitige Verfügbarkeit verschiedener Bibliotheken und unterschiedlicher Hardware weichen ESP32-Varianten in ihrem Befehlssatz teilweise entsprechend ab. Z. B. gilt
· Bluetooth Classic (Serial) nur auf ESP32
· Bluetooth BLE Keyboard/Mouse/Multimeter nicht auf ESP32, ESP32-S2
· DAC auf ESP32 und ESP-S2, zusätzliches Sampling und Generator nur ESP32
· USB-Keyboard/Mouse nicht auf ESP32
Ausnahmen bestätigen die Regel.
Hinweis: Wegen der Vielzahl eingebundener
Bibliotheken steht allgemein wenig RAM-Speicher zur Verfügung. Dadurch kann es
zu Abstürzen bzw. Neustarts kommen, wenn Variablen und Funktionen viel
Speicherplatz benötigen, die an der seriellen Schnittstelle vom ESP die Worte
Panic oder Heap mit auf den Weg bekommen. Bei schwacher WiFi-Verbindung zeigt
sich die Kommunikation zwischen Browser und ESP träge oder sie friert ganz ein.
Übersicht
Serielles Interface Serial 1 und 2
Event-Branches Zusammenfassung
Verschiedenes zur ESP32-Version
Inhalt
INPUT {optionaler String oder var zur Eingabeaufforderung}, {Variable}
map*(Wert,WertMin,WertMax,NeuMin,NeuMax):
timeset*(yyyy, mm, dd, hr, min, sec)
timeset*(yyyy, mm, dd, hr, min, sec, isDst)
timestamp*(yyyy, mm, dd, hr, min, sec)
timediff*(endTimePickerString, startTimePickerString)
Vergleichsoperatoren für Strings und Zahlen:
WPrint mit der Funktion htmlvar():
pwmOut**{pin},{wert},{duration}:
echo** {outPin, freq, duration,inPin}
ainMean**(Analog-Eingang[,offset]): Uar*(Analog-Eingang[,offset]):
ainRMS**(Analog-Eingang): Ueff*(Analog-Eingang[,offset]):
capture.begin*([{adc_channel}]):
Serielles Interface Serial 1 und 2
input {optionaler String oder var zur Eingabeaufforderung}, {value oder var}
serial2begin {Baudrate},{TX_pin},{RX_pin},{*}
serial2println {Wert oder var}
i2c.begin({Geräteadresse als Zahl oder Variable})
i2c.write({Wert oder Variable für Daten})
i2c.requestfrom({Geräte-ID},{Anzahl der anzufordernden Bytes})
spi.setup*({Geschwindigkeit}, {MODE}, {MSB_FIRST})
msgbranch {branch label} onServer*{newlabel}
msgreturn {Variablenname oder String für Rückgabe}
udpbeginmulticast {multicast_ip}, {localport}
udpwrite {ip_address}, {port}, {message}
udpwritemulticast {ip_address}, {port}, {message}
udpBranch {label} onUDP*{newlabel}
SendTS({API-Schlüssel},{Feldnummer},{Feldinhalt})
ReadTS({API-Schlüssel},{Kanal-ID},{Feld-Nummer)
SetupEmail**{server}, {port}, {benutzername}, {passwort}
Email**{String To email}, {String From Email}, {String Subject}, {String Body}
mqtt.subscribe(SubscriptionString)
mqtt.publish(KanalString, DatenString)
Tg.begin(TokenString, ChatIDString)
Dallas Temperatur Sensor DS18B20
neo({LED#},{R},{G},{B},{optional: 1, um das automatische Schreiben zu deaktivieren})
neo.stripcolor({Startpixel},{Endepixel},{R},{G},B})
neo.shift({Startpixel},{Endpixel},{Richtung, 1 für vorwärts, -1 für rückwärts.})
neo.hex({Pixeldaten],{Startpixel],int{Position in Pixeldaten},{Anzahl Pixel},{Helligkeit 0-100})
neo.rainbow*({Anfangswert},{Farbintensität},{Helligkeit})
stepper.setup*(steps, pin1A, pin2A, pin3A,pin4A)
oled.color({1 oder 0 für weiß oder schwarz})
oled.print({String},{optional x},{optional y})
oled*.progress(x, y, w, h, Wert in Prozent)
LCDprint {String oder var}, {x Position}, {y Position}
LCDsend {Wert oder Variable als Kommando-Byte}, {Wert oder Variable für Modus}
ads.read(Eingang als Zahl oder Variable)
ads.range(Zahl oder Variable von 1 bis 6 )
matrix.brightness(Helligkeitswert)
matrix.print(text, delay, x-position)
SPI MCP410xx Digital Potentiometer
SPI AD9833 Functions-Generator
LoRaPrint String* LoRaWrite* String LoRaSend* String
tft.rect.round(x,y,w,h,rad,col)
tft.rect.round.fill(x,y,w,h,rad,col)
tft.rect.fill.H*(x,y,w,h,col1,col2)
tft.rect.fill.V*(x,y,w,h,col1,col2)
tft.bmp*(Dateiname, x, y, Hintergrundfarbe)
tft.caption*(text) tftCaption*
tft.needle*(percent) tftNeedle*
tft.linear*(number, percent) tftLinear*
tft.obj.button(label, x, y, width, height, text_size, fore_color, back_color)
tft.obj.label(label, x, y, width, height, text_size, fore_color, back_color)
tft.obj.checkbox(label, x, y, height, checked, text_size, fore_color, back_color)
tft.obj.radio(label, x, y, height, checked, text_size, fore_color, back_color)
tft.obj.bar(label, x, y, height, width, text_size, fore_color, back_color)
tft.obj.toggle(icon1, icon2, x, y[, checked})
tft.obj.setlabel(obj_ident, label)
tft.obj.setvalue(obj_ident, value)
tft.obj.setchecked(obj_ident, check)
tft.obj.getvalue(obj_ident, value)
tft.obj.getchecked(obj_ident, check)
touchbranch [label] onTouch* label
Event-Branches Zusammenfassung
Verschiedenes zur ESP32-Version
WebSockChangeBranch onChange**
mouseMove* x,y,w mouse.move*(x,y,w)
BLE Digital Multimeter BTMETER BT-90EPD und Kompatible
Meterbranch** [Label] onMeter** Label
mouseBLEmove* x,y,w mouseBLE.move*(x,y,w)
Diese Skriptsprache und Referenz basiert auf dem von Michel Moulinari (mmiscool) auf esp8266basic.com veröffentlichten Original und ist dazu in hohem Maße kompatibel.
Basis-Befehlssatz
Gibt einen Text oder eine Variable über die serielle Schnittstelle und im Browser mit einer neuen Zeile aus. print {wert oder var}
INPUT {optionaler String oder var zur Eingabeaufforderung}, {Variable}
Fordert Eingaben über die serielle Schnittstelle (USB) vom Benutzer an und speichert sie in einer Variablen. Die Variable muss vor der Abfrage nicht deklariert werden. Serialtimeout legt die Wartezeit in ms fest. Die Voreinstellung ist 0 und bedeutet unendliche Wartezeit (siehe auch watchdog)
serialtimeout 10000 ' 10 Sekunden für die Antwort
serialprintln "Input-Test...10 Sekunden-Fenster!"
input "Hi, I'm Eliza. Tell me about your problem.", a
if a = "" then print "Looser" else print a
Die Eingabe im Browserfenster ist vorzuziehen. (siehe auch TextBox/Button)
FOR...NEXT
Eine for...next-Schleife wird x-mal durchlaufen.
For x = 1 to 5
Print x
Next x
Eine for...next-Schleife mit optionalem Schrittwert.
For x = 1 to 5 step 2
Print x
Next x
Der Schritt kann negativ sein und ist nicht auf eine ganze Zahl beschränkt.
For x = 5 to 0 step -0.1
Print x
Next
Die Variable nach next ist optional.
DO...LOOP
Ermöglicht es, eine Schleife zu erstellen, die entweder unendlich lange läuft oder nur, wenn bestimmte Bedingungen erfüllt sind.
DO
...
LOOP {WHILE/UNTIL} {Bedingung}
Wenn die Schleife unendlich sein soll:
Do
Print "Looping for eternity"
Loop until 0
Do-Schleife mit until-Bedingung:
Do
bla = bla + 1
Print bla
loop until bla > 5
Do-Schleife mit while-Bedingung:
Do
Bla = bla + 1
Print bla
Loop while bla < 5
WHILE*…WEND
Ermöglicht es, eine Schleife zu erstellen, die entweder unendlich lange läuft oder nur, wenn bestimmte Bedingungen erfüllt sind. Die Bedingung wird vor Eintritt in die Schleife abgefragt, so dass diese, im Gegensatz zu DO, nicht durchlaufen werden muss (abweisende Schleife).
While True
' Endlosschleife
Wend
Anders programmier mit IF/THEN/GOTO:
Solange: ' While
IF … THEN
' Schleifenkörper
GOTO Solange
ENDIF ' Wend
IF…THEN…ELSE…:
Mit dem Befehl if then werden 2 Werte oder Variablen verglichen. Um zu prüfen, ob Zeichenketten gleich sind, verwenden Sie '==', für Zahlen verwenden Sie '='.
if {var oder Wert} {=, ==,>,<,<>,>=,<=}, {var oder Wert} then {Auszuführende Anweisung, wenn wahr} {else} {Anweisung, wenn falsch}
aldo = 6
dummerSack = 2*3
If aldo = dummerSack then Print "ganz genau!" else Print "ach was"
If then-Anweisungen können auf mehrere Zeilen aufgeteilt werden. Das unten gezeigte Format kann Verwendung finden:
If bla = 5 then
Print "Bla is 5"
Else
Print "bla is not 5"
Endif
If kann wie folgt verschachtelt werden:
if a > b then
print "a > b"
if b >c then
print "b > c"
else
print "b < c"
endif
else
print "a < b"
endif
LET:
Let führt mathematische oder String-Operationen mit einer Reihe von Werten oder Variablen durch und legt das Ergebnis in einer Variablen ab. Um Zeichenketten zu addieren, muss das Symbol '&' anstelle des '+' verwenden werden. Kann auch zur Auswertung logischer Operationen wie in der if then-Anweisung verwendet werden. Wenn das Ergebnis wahr ist, wird -1 zurückgegeben, andernfalls eine 0.
let {Ergebnis var} = {Wert oder var} {Operator *,/,+,-,^,&} {Wert oder var}
let {Ergebnis var} = {Wert oder var} {=, ==,>,<,<>,<=,>=} {Wert oder var}
Kann auch ohne die LET-Anweisung verwendet werden
bla = 5 + 5
INC:
Erhöhung einer numerischen Variablen um eins. Kurz für x = x + 1: INC x
DEC:
Verringerung einer numerischen Variablen um eins. Kurz für x = x - 1 zu: DEC x
Vergleichsoperatoren:
= Gleich für Zahlen und für Zeichenketten
> größer als
< kleiner als
<> ungleich
>= größer gleich
<= kleiner gleich
Mathematische Operatoren:
+ Addition (nur Zahlen)
- Subtraktion
* Multiplikation
/ Division
^ Potenz
& Addition (Text)
% Modulo
DIM:
Dimensioniert ein Array. Arrays, die ohne $ dimensioniert sind, werden als numerisch definiert. Arrays, die mit einem $ definiert werden, werden als String definiert. Arrays, die ohne das $ definiert werden, können als String definiert werden, indem man 'as string' am Ende der Zeile hinzufügt. Können wie andere Variablen verwendet werden. Kann nicht für GUI-Widgets verwendet werden.
dim arraynumeric( {Variable oder numerischer Wert} )
dim arraystring$( {variabler oder numerischer Wert} )
dim arraystring( {variabler oder numerischer Wert} ) as string
UNDIM:
Gibt den von einem Array verwendeten Speicher frei
undim arraystring$
READ*, DATA* & RESTORE*:
Eine weitere klassische Methode der Variablenzuweisung. Die Data-Zeilen dürfen über das ganze Programm verteilt sein.
MEMCLEAR: CLEAR*:
Löscht alle Variablen, die
in einem Basic-Programm verwendet werden, aus dem Speicher.
memclear
GOTO:
Springt zur
Verzweigungsbezeichnung nach Wahl
goto {label} goto
[test3] goto
test3*
GOSUB UND RETURN:
Springt zur Verzweigungsmarke nach Wahl und ermöglicht es, zu der Stelle zurückzukehren, von der aus der gosub-Befehl aufgerufen wurde, und den Code nach der Ausführung des return-Befehls weiter auszuführen. Der gosub-Befehl hat einen Stapel von 255 Rücksprungpunkten, so dass es möglich ist, innerhalb eines gosubs zu weitere Unterprogramme aufzurufen.
gosub {label} gosub label*
return
Beispiel:
Print "Some text"
Gosub [mySub]
Print "Some more text"
end
[mySub]
Print "Text from in the gosub"
return
Oder in dieser Version für den ESP32:
Print "Some text"
Gosub mySub
Print "Some more text"
End
mySub:
Print "Text from in the gosub"
return
BRANCH LABELS:
Eine Verzweigungsbezeichnung (label) ermöglicht es, von einem Teil des Programms zu einem anderen zu springen. Sie kann aus einer einzigen Zeichenkette ohne Leerzeichen bestehen. Die [ und ] sind ursprünglich erforderlich, um eine Verzweigung zu definieren. [label] (Verzweigungs-Bezeichnungen wie in qbasic) In der esp32-Version können die Label mit schwer zugänglichen ][ durch einen Doppelpunkt ersetzt werden: Timer 500,label und label:
Timer:
Mit dem Befehl Timer können Sie periodisch eine Verzweigung ausführen. Die Verzweigung muss mit dem Befehl wait beendet werden. Wenn Sie den Timer auf 0 setzen, wird er deaktiviert. Um Timer zu setzen: timer {Wert oder var für Wartezeit in Millisekunden}, {Zweigbezeichnung}. Um timer zu deaktivieren: timer 0
Das folgende Beispiel prüft den Status des Pins gpio 0 und gibt jedes Mal eine Nachricht an das serielle Terminal aus, wenn der Pin high ist. Wenn die Taste gedrückt wird und der Pin auf low gezogen wird, wird der Timer deaktiviert und die Meldung angezeigt, dass der Timer deaktiviert wurde.
Print "timer example"
Timer 1000, [test]
Wait
[test]
If io(pi,0) = 0 then
Timer 0
serialPrintln "timer has been disabled"
Else
serialPrintln "Button connected to gpio 0 is high"
Endif
wait
TimerCB:
Mit dem TimerCB-Befehl (Call Branch) kann periodisch eine Unterprogramm aufgerufen werden. Sobald der Timercb-Befehl ausgeführt wurde, wird das Programm mit der Codezeile fortgesetzt, bei der er zuletzt war, so dass eine Unterprogramm ausgeführt werden kann, selbst wenn sich das Programm in einer Schleife befindet. Die Verzweigung muss mit dem Return-Befehl abgeschlossen werden. Wird der TimerCB auf 0 gesetzt, wird er deaktiviert. Um den Timer zu setzen:
timercb {Wert oder var für Wartezeit in Millisekunden}, {Verzweigungsbezeichnung}
Um den Timer zu deaktivieren: timercb 0
Das folgende Beispiel prüft den Status des Pins Gpio 0 und gibt jedes Mal eine Nachricht an das serielle Terminal aus, wenn der Pin high ist. Wenn die Taste gedrückt wird und der Pin auf low gezogen wird, wird der Timer deaktiviert und die Meldung angezeigt, dass der TimerCB deaktiviert wurde.
Print "timer example"
Timercb 1000, [test]
Wait
[test]
If io(pi,0) = 0 then
Timercb 0
serialPrintln "timer has been disabled"
Else
serialPrintln "Button connected to gpio 0 is high"
Endif
Return '(!)
INTERRUPT:
Führt einen bestimmten Programmteil aus, wenn sich der Status eines
Pins ändert. Die Interrupt-Abfrage findet nur statt, wenn der ESP wartet und
ist nützlich für Dinge, wie das Auslösen von Ereignissen durch Drucktasten oder
Rotary-Encodern. Der Programmteil muss mit dem Befehl wait enden. Jedem als
Eingangs-GPIO verfügbarer Pin kann ein Interrupt zugeordnet werden.
Interrupt {Pin Nr.}, {Sprungmarke}
interrupt 3,[change]
wait
[change]
if io(laststat,3) = 1 then print "Pin put high" else print "Pin
put low"
wait
Read():
Mit der Lesefunktion können Daten abgerufen werden, die dauerhaft im Flash-Speicher (/data) des ESP-Moduls gespeichert sind. Die Funktion liefert eine Zeichenkette zurück.
Bla = read({Dateiname})
Read.Val():
Mit dieser Lesefunktion können Daten abrufen werden, die dauerhaft im Flash-Speicher des ESP-Moduls gespeichert sind. Es wird ein numerischer Wert zurückgegeben.
Bla = read.val({Einzelteilname})
Write():
Der Schreibbefehl ermöglicht das dauerhafte Speichern einer Zeichenkette als Datenelement im Flash-Speicher (/data). Längere Texte oder Messwerte können mit chr(10) oder mit Kommata getrennt sein: write({Dateiname},{zu schreibende Zeichenkette})
Del.Dat():
Ermöglicht das Löschen eines Elements im /data-Verzeichnis, das in den Flash-Speicher geschrieben wurde. Verwenden Sie denselben Namen, den Sie beim Schreibbefehl verwendet haben.
del.dat({Dateiname})
Rename*(AlterName,NeuerName):
Umbenennen einer Datei im Flash-Verzeichnis.
Load:
Lädt ein anderes Basic-Programm in den Speicher. Nützlich, um Programme miteinander zu verketten. Das Programm wird von Anfang an ausgeführt. Alle zuvor verwendeten Variablen bleiben im Speicher und sind für das geladene Programm verfügbar. Nützlich, um ein Programm-Projekt aufzuteilen. Programm liegen üblicherweise im Wurzelverzeichnis „/“.
load {Programmname}
LOAD "/myscript.bas" oder LOAD "/uploads/myscript.bas"
Exists(Dateiname)
Liefert -1, wenn der angegebene Dateiname existiert, sonst 0.
End:
Beendet das aktuell
laufende Programm.
end
Zeichenketten Funktionen
Funktionen können anstelle von Variablen aufgerufen werden und geben normalerweise einen Wert zurück. Bei Funktionsnamen wird nicht zwischen Groß- und Kleinschreibung unterschieden, d.h. LeN() und len() sind beide gültig
len():
Gibt die Länge der Zeichenkette zurück. Bla = len({String oder Variable})
instr():
Gibt die Position einer Teilzeichenkette innerhalb einer Zeichenkette zurück. Ein 3. optionales Argument erlaubt es, die Startposition für jede Suche festzulegen. Wird es weggelassen, beginnt die Suche an der ersten Zeichenposition. Bla = instr({Originalzeichenkette},{zu suchende Zeichenkette},{optionaler Start})
instrrev():
Gibt die Position des ersten Vorkommens einer Zeichenkette innerhalb einer anderen Zeichenkette zurück, ausgehend von der rechten Seite der Zeichenkette. Ein drittes optionales Argument erlaubt die Festlegung der Startposition für jede Suche, beginnend von der linken Seite der Zeichenkette. Wenn Start weggelassen wird, wird -1 verwendet, d.h. die Suche beginnt an der letzten Zeichenposition. Die Suche geht dann von rechts nach links vor. Bla = instrrev({Zeichenfolge oder Variablenname},{Zeichenfolge oder Variablenname zu suchen},{Start})
mid():
Gibt die Zeichenkette von der Startposition bis zur Endposition innerhalb der Eingabezeichenkette zurück. Bla = mid({zeichenkette oder Variable},{Startposition},{Anzahl der Zeichen})
left():
Gibt eine Zeichenkette zurück, die eine bestimmte Anzahl von Zeichen von der linken Seite einer Zeichenkette enthält. Bla = left({String oder Variable },{Länge})
right():
Gibt eine Zeichenkette zurück, die eine bestimmte Anzahl von Zeichen auf der rechten Seite einer Zeichenkette enthält. Bla = right({Zeichenfolge oder Variablenname},{Länge})
trim():
Gibt eine Zeichenkette zurück, bei der führende und nachfolgende Leerzeichen abgeschnitten sind. Bla = trim({String oder Variable })
str():
Gibt die String-Darstellung einer Zahl zurück. Bla = str({Zahl oder Variable})
replace():
Gibt eine Zeichenkette zurück, nachdem der Suchtext durch den Ersatztext ersetzt wurde.Bla = replace({String oder Variable},{String, nach dem gesucht wird},{Ersatz-String})
chr():
Gibt ein Zeichen für die angegebene Zahl zurück. Bla = chr({Zeichenfolge oder Variable})
asc():
Gibt eine Zahl für das erste
Zeichen in einer Zeichenkette zurück.
Bla = asc({String
oder Variable })
upper():
Gibt die übergebene Zeichenkette in GROSSBUCHSTABEN zurück. Bla = upper({String oder Variable })
lower():
Gibt die übergebene Zeichenkette in Kleinbuchstaben zurück. Bla = lower({String oder var name})
word():
Diese Funktion gibt das n-te Wort in der Zeichenkette, der String-Variablen oder dem String-Ausdruck zurück. Das Trennzeichen für die Zeichenkette ist optional. Wenn es nicht verwendet wird, dient das Leerzeichen als Trennzeichen. Bla = word( {Originalzeichenkette}, {Zahl}, {optionales Trennzeichen, Standard ist Leerzeichen} ) Beispiel: word("Der schlaue braune Fuchs sprang über den faulen Hund", 5) gibt "sprang" zurück
format*():
Liefert formatierte Zeichenketten numerischer Variablen in Anlehnung an
die printf()-Funktion in C.
format({String
oder var name},{num(s) or var(s)}. Bis zu vier Variablen werden berücksichtigt.
Beispiel: print
format("%5.2f",3.1415)
Numerische Funktionen
Funktionen können anstelle von Variablen aufgerufen werden und geben in der Regel einen Wert zurück. Bei Funktionsnamen wird nicht zwischen Groß- und Kleinschreibung unterschieden, d. h. Sqr() und sqr() sind beide gültig. In der Regel folgen dem Funktionsnamen Klammern.
sqr():
Gibt die Quadratwurzel zurück. sqr({Wert oder Variablenname})
sin():
Gibt den Sinus eines Winkels zurück. sin({Wert oder var name})
cos():
Gibt den Kosinus eines Winkels zurück. cos({Wert oder Vari-Name})
tan():
Gibt den Tangens eines Winkels zurück. tan({Wert oder var name})
log():
Gibt den Logarithmus des angegebenen Wertes zurück. log({Wert oder Vari-Name})
rnd():
Gibt eine Zufallszahl bis zu dem angegebenen Wert zurück. rnd({Wert oder var name})
millis():
Gibt die Anzahl der Millisekunden seit dem Bootvorgang zurück. millis()
int():
Gibt einen Integer-Wert zurück. int({String oder var name})
val*():
Gibt einen Wert aus einer Zeichenkette zurück. Funktioniert auch mit "&h", "0x" und "0b". val({String oder var name}), Beispiel: print val("0b10101010“)
oct():
Gibt den oct-Wert einer Ganzzahl zurück. oct({String oder var name})
hex():
Gibt den Hex-Wert einer ganzen Zahl zurück. Ein optionales 2. Argument definiert die Anzahl der Ziffern. hex({string oder var name},{nb_of_digits})
print hex(12) -> c
print hex(12, 2) -> 0c
print hex(2170) -> 87a
print hex(2170, 4) -> 087a
print hex(2170, 6) -> 00087a
hextoint():
Gibt einen Integer-Wert aus einem Hex-Wert zurück. hextoint({String oder var name})
bintoint*():
Gibt einen Integer-Wert aus einem Binär-Wert zurück. bintoint({String oder var name})
ramfree():
Gibt die Menge des freien Speichers in Bytes zurück. ramfree()
flashfree():
Gibt die Menge an freiem Flash in Bytes zurück. Dies gilt nur für Flash, das für das Dateisystem vorgesehen ist. flashfree()
map*(Wert,WertMin,WertMax,NeuMin,NeuMax):
Entspricht der Arduino-Funktion und liefert den verhältnisgleichen NeuWert aus dem übergebenen Wert zurück. Nützlich bei Dreisatzproblemen: y = map(127, 0, 255, 0, 5) -> 2.5
min*(Wert1,Wert2):
Liefert den Kleineren von zwei Werten zurück.
max*(Wert1,Wert2):
Liefert den Größeren von zwei Werten zurück.
Vom Parser geerbte Funktion (C++-Stil)
pow(x,y):
Gibt x hochgezählt als Potenz von y zurück.
exp(x):
Gibt den Wert von e in der x-ten Potenz zurück.
asin(x):
Gibt den Arcussinus von x im Bogenmaß zurück.
acos(x):
Gibt den Arcus-Cosinus von x im Bogenmaß zurück.
atan(x):
Gibt den Arcustangens von x im Bogenmaß zurück.
atan2(x, y):
Gibt den Arcustangens von y/x im Bogenmaß zurück, wobei die Vorzeichen beider Werte zur Bestimmung des richtigen Quadranten herangezogen werden.
abs(x):
Gibt den absoluten Wert von x umgewandelt in Ganzzahl zurück.
fabs(x):
Gibt den absoluten Wert von x zurück.
floor(x):
Gibt den größten ganzzahligen Wert zurück, der kleiner oder gleich x ist.
ceil(x):
Gibt den kleinsten ganzzahligen Wert zurück, der größer oder gleich x ist.
round(x):
Gibt den ganzzahligen Wert zurück, der x am nächsten liegt, wobei in der Hälfte der Fälle von Null abgerundet wird, unabhängig von der aktuellen Rundungsrichtung.
pi():
Gibt den Wert der Zahl Pi zrück (nur esp32x)
Regressionen*
reglin*(x,y):
Gibt das Ergebnis für eine linerare Funktion als String zurück
reglog*(x,y):
Gibt das Ergebnis für eine Log-Funktion als String zurück
regpot*(x,y):
Gibt das Ergebnis für eine Pot-Funktion als String zurück
regexp*(x,y):
Gibt das Ergebnis für eine Exp-Funktion als String zurück
Zeit Funktionen und Kommandos
time()
Gibt das Datum und die Uhrzeit als String zurück. Optional kann das Format angegeben werden, in dem das Ergebnis zurückgegeben werden soll. Optionen: Monat, Tag, Stunde, Min, Sek, Jahr, Dow (Wochentag, z. B. fri): Print time("time") 'time("hour:min:sec")
unixtime()
Erlaubt die Umwandlung von Datum/Uhrzeit vom Unix-Format (eine Zahl) in Text. Gibt das Datum und die Uhrzeit als String zurück. Optional kann das Format angegeben werden, das zurückgegeben werden soll. Optionen: month, date, hour, min, sec, year, dow (Wochentag, z.B. fri)
unixtime({Zahl} , {Optionale Angabe des Formats}).
Print unixtime(1459681200, "year")
time.setup()
Richtet die Zeitzone und das Sommerzeitattribut ein.
time.setup({Zahl oder var für Zeitzone},{Zahl oder var für dst},{optional server})
millis()
Gibt die Anzahl der Millisekunden seit dem Start zurück: Print millis()
timer:
Mit dem Befehl Timer ist es möglich, periodisch eine Verzweigung auszuführen. Die Verzweigung muss mit dem Befehl wait beendet werden. Wird der Timer auf 0 gesetzt, ist er deaktiviert. Um Timer zu setzen: timer {Wert oder var für Wartezeit in Millisekunden}, {Sprungmarke}. Um den Timer zu deaktivieren: timer 0.
timerCB
Mit dem Befehl TimerCB (Call Branch) kann man regelmäßig ein Unterprogramm (Gosub) ausführen und den aktuell laufenden Code unterbrechen. Sobald die TimerCB-Routine ausgeführt wurde, wird sie mit der letzten Codezeile fortgesetzt, so dass eine Unterverzweigung ausgeführt werden kann, auch wenn sich das Programm in einer Schleife befindet. Die Verzweigung muss mit dem Return-Befehl abgeschlossen werden. Wird der TimerCB auf 0 gesetzt, ist er deaktiviert. Um den Timer zu setzen: timercb {Wert oder var für Wartezeit in Millisekunden}, {Verzweigungsbezeichnung}. Um den Timer zu deaktivieren: timercb 0.
timezone*(TimeZoneString)
Initialisiert die Zeit durch setzten der Zeitzone. ZeitzoneStrings entsprechen der Tabelle unter https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv#L374. Die Nummer L374 gilt für Mitteleuropa und lautet . Timezone stellt die neue Zeitzone sofort ein, speichert sie und legt sie zusätzlich in den Optionen ab. Sie bleibt auch nach einem Reset erhalten.
timezone*()
Liefert die aktuell wirkende Zeitzone als Zeichenkette (String).
timeinit*(TimeZoneString)
Initialisiert die Zeit durch setzten der Zeitzone und Synchronisation mit pool.ntp.org. Ohne Zeitzone gilt CET, sie kann mit timezone() abgerufen werden.
timestr*(FormatString)
Liefert lesbare Zeitangaben entsprechend der c-Funktion strftime. Die angegebene Tabelle stammt von https://cplusplus.com/reference/ctime/strftime/
|
Spec |
Replaced by |
Example |
|
%a |
Abbreviated weekday name * |
Thu |
|
%A |
Full weekday name * |
Thursday |
|
%b |
Abbreviated month name * |
Aug |
|
%B |
Full month name * |
August |
|
%c |
Date and time representation * |
Thu Aug 23 14:55:02 2001 |
|
%C |
Year divided by 100 and truncated to integer (00-99) |
20 |
|
%d |
Day of the month, zero-padded (01-31) |
23 |
|
%D |
Short MM/DD/YY date, equivalent to %m/%d/%y |
08/23/01 |
|
%e |
Day of the month, space-padded ( 1-31) |
23 |
|
%F |
Short YYYY-MM-DD date, equivalent to %Y-%m-%d |
2001-08-23 |
|
%g |
Week-based year, last two digits (00-99) |
01 |
|
%G |
Week-based year |
2001 |
|
%h |
Abbreviated month name * (same as %b) |
Aug |
|
%H |
Hour in 24h format (00-23) |
14 |
|
%I |
Hour in 12h format (01-12) |
02 |
|
%j |
Day of the year (001-366) |
235 |
|
%m |
Month as a decimal number (01-12) |
08 |
|
%M |
Minute (00-59) |
55 |
|
%n |
New-line character ('\n') |
|
|
%p |
AM or PM designation |
PM |
|
%r |
12-hour clock time * |
02:55:02 pm |
|
%R |
24-hour HH:MM time, equivalent to %H:%M |
14:55 |
|
%S |
Second (00-61) |
02 |
|
%t |
Horizontal-tab character ('\t') |
|
|
%T |
ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S |
14:55:02 |
|
%u |
ISO 8601 weekday as number with Monday as 1 (1-7) |
4 |
|
%U |
Week number with the first Sunday as the first day of week one (00-53) |
33 |
|
%V |
ISO 8601 week number (01-53) |
34 |
|
%w |
Weekday as a decimal number with Sunday as 0 (0-6) |
4 |
|
%W |
Week number with the first Monday as the first day of week one (00-53) |
34 |
|
%x |
Date representation * |
08/23/01 |
|
%X |
Time representation * |
14:55:02 |
|
%y |
Year, last two digits (00-99) |
01 |
|
%Y |
Year |
2001 |
|
%z |
ISO 8601 offset from UTC in timezone (1 minute=1, 1 hour=100) |
+100 |
|
%Z |
Timezone name or abbreviation * |
CDT |
|
%% |
A % sign |
% |
timeset*(yyyy, mm, dd, hr, min, sec)
Stellt die interne Uhr, falls kein Internet-Zugang verfügbar ist. Bei Internet-Zugang stellt synchronisiert die Uhr nach einer Weile mit dem Time-Server
timeset*(yyyy, mm, dd, hr, min, sec, isDst)
Stellt die Uhr wie oben mit Berücksichtigung einer möglichen Sommerzeit
timeset*(TimePickerString)
Setzt Datum und Uhrzeit entsprechend der Zeichenkette "2024-04-08T10:13:24"
datetimepicker dt
button "ok",ende
wait
ende:
print dt
timestamp*()
Liefert den UNIX-Zeitstempel
timestamp*(yyyy, mm, dd, hr, min, sec)
Liefert den UNIX-Zeitstempel des angegebenen Datums
timestamp*(TimePickerString)
Liefert den UNIX-Zeitstempel entsprechend der Zeichenkette "2024-04-08T10:13:24"
timediff*(endTimePickerString, startTimePickerString)
Liefert die Differenz in Sekunden von Zeichenketten der Art "2024-04-08T10:13:24". Die auf timestamp basierende Funktion liefert bis 2038 entsprechende Ergebnisse
pause* ms
Das Kommando wartet für ms Millisekunden und erlaubt während der Wartezeit die Darstellung neuer GUI-Elemente im Browser-Fenster. Auch nützlich zur Darstellung von Print-Ausgaben vor längeren Aktionen. Vergleichbar mit doEvents() in VBA. Der Browser bleibt ansprechbar im Gegensatz zu delay ms. Pause kann nicht zusammen mit Timer verwendet werden.
sleep(seconds)
Schaltet den ESP für eine bestimmte Anzahl von Sekunden in den Ruhezustand. Dies spart Strom und ermöglicht eine längere Nutzung bei Batteriebetrieb. Zu beachten: Der Ruhemodus führt zu einem vollständigen Neustart des ESP (reboot). Das Gerät führt das Standardprogramm von Anfang an aus. Es dauert 30 Sekunden, bevor das Gerät nach dem Neustart das Standardprogramm default.bas startet.
print "testing sleep in 5 seconds for 10 seconds"
timer 5000,[tm]
wait
[tm]
sleep 10
wait
sleepext*(gpio,level)
Schaltet das Gerät in den Ruhezustand. Es kann nur durch ein externes Signal erneut starten. Dies spart Strom und ermöglicht eine längere Nutzung im Batteriebetrieb. Zu beachten: Der Ruhemodus führt beim Erwachen durch ein Spannungspegel level am gpio zu einem vollständigen Neustart des Geräts. Das Standardprogramm wird von Anfang an ausgefürt. Es dauert 30 Sekunden, bevor das Gerät nach dem Neustart das Standardprogramm default.bas startet. Nicht alle gpio sind erlaubt. Sleep.info?
print "Sleep External"
sleepext 30,1
print "hi"
end
Oder mit PRG-Taster an GPIO 0 des ESP32-S3:
print "Sleep External"
sleepext 0,0
Parser Spezifikationen
String-Literale:
Es ist möglich, ein " oder ein | als String-Literale zu verwenden; dies erlaubt es, das " oder | in einen String einzuschließen;
A = |dies ist eine Zeichenkette|
B = "dies ist eine Zeichenkette"
Vergleichsoperatoren für Strings und Zahlen:
Das '=' oder '==' liefert das gleiche Ergebnis für String und Zahlen. Die Zeichenkette kann auch mit >, <, etc. verglichen werden.
Boolsche Binäroperatoren
Die klassischen "einfachen" binären Operatoren sind verfügbar:
and, or, xor, not
Beispiel:
print 255 and 15;
let a = 255 xor 15;
let b = not 15;
let c = a or b
Verschiebe-Operatoren
Es gibt die Operatoren '<<' und '>>' zum Verschieben nach
links und rechts. Beispiel:
print 15 <<
3;
let c = a >> 4
Modulo-Operator (%)
Der Modulo-Operator '%' ist verfügbar. Beispiel: print 10 % 3
Boolesche Operatoren in 'if'
Alle booleschen Operatoren können in dem Befehl 'if' verwendet werden:
If a = b and c<>d then .....
Alle Vergleiche können in Ausdrücken verwendet werden. Wenn das Ergebnis true ist, wird der Wert -1 sein, 0 ist false. Beispiel
let a = 5 <> 3 '⇒ -1
print 5+3 = 8 '⇒ -1
print 5-4 = 2 '⇒ 0
Leerzeichen sind irrelevant:
A = 5 + 3 ist dasselbe wie a=5+3
Browser Interface
Cls:
Löscht den Bildschirm (Browser) und den GUI-Puffer: cls
WPrint: oder HTML:
Druckt Text nur in den Web-Browser. Der Text wird nach dem Wartebefehl wait an den Browser gesendet. Es erfolgt kein Zeilenvorschub. Ein "<br>" erfüllt diesen Zweck, ein "<hr>" fügt zusätzlich eine horizontale Linie ein. Auch alle PRINT-Ausgabe erscheinen erst nach einem wait im Browser-Fenster. Abhilfe schafft der Befehl Pause. wprint {value oder var}: Html "Hallo Welt<hr>"
Html |Hallo Welt<br>Neue Zeile|
WPrint mit der Funktion htmlvar():
Um eine dynamische Variable zu platzieren, die bei jeder Aktualisierung der Seite mit dem aktuellen Inhalt dieser Variable aktualisiert wird, verwenden man die Funktion htmlvar. Jedes Mal, wenn der Browser aktualisiert wird, wird der aktuelle Inhalt der Variablen in die Seite eingefügt. wprint htmlvar({var name}).
a = 2*4
wprint " Variable a ist: " & htmlvar(a)
Image:
Fügt ein Bild in die Web-Seite ein. Die Bilddatei sollte mit dem Dateimanager auf das Gerät hochgeladen worden sein. Wenn der Bilddateiname mit http:// oder https//* beginnt, können Sie auf ein Bild verweisen, das auf einem Webserver gespeichert ist, um Platz im ESP-Dateisystem zu sparen. Image {Bilddateiname}
image "http://hjberndt.de/book/200PICOW.jpg"
Button:
Funktioniert wie ein goto-Befehl. Wird bei einem wait-Befehl an den Browser gesendet. Springt zur Verzweigungsbezeichnung, wenn er im Browser angeklickt wird.
Button {Wert oder var}, {Verzweigungsbezeichnung}
1 Print "Bowser-Input-Test...<hr>"
2 Print "Hi, I'm Eliza. Tell me about your problem.<form>"
3 a = "I'm so tired."
4 textbox a
5 button "Enter", ok, focus
6 html "</form>" ' Eingabe-Taste
7 wait
8 ok:
9 if a = "" then print "Looser" else print a
ImageButton:
Funktioniert wie ein goto-Befehl Wird bei einem wait-Befehl an den Browser gesendet. Springt zur Verzweigungsbezeichnung, wenn er im Browser angeklickt wird. Die Bilddatei muss mit dem Dateimanager auf das Gerät hochgeladen worden sein, kann aber auch wie ein Image direkt aus dem Netz kommen*. ImageButton {Bilddateiname}, {Verzweigungsbezeichnung}. Beispiel für eine spektakulär aussehende Bild-Schaltfläche:
url ="https://www.galeriemode.de/wp-content/uploads/2019/03/94f01d51b31b.jpg"
imagebutton url, go
wait
go:
cls
end
Textbox:
Der Text innerhalb der Texteingabe wird mit dem Inhalt der Variablen
gefüllt. Wird im Browser beim wait-Befehl oder pause-Befehl angezeigt.
textbox {var
name}
a = pi()
textbox a
pause 3000
end
PasswordBox:
Der Text in der Passworteingabe
wird mit dem Inhalt der Variablen gefüllt. Wird beim wait-Befehl oder pause-Befehl im
Browser angezeigt.
passwortbox
{var name}
Slider:
Der Schieberegler wird mit einem
Höchst- und einem Mindestwert erstellt.
slider {Var
name}, {min Wert}, {max Wert}
a = 5
slider a, 0, 10
Dropdown:
Das ausgewählte Element wird der angegebene Variablen
zugewiesen.
dropdown
{Var name}, {Elementliste durch Kommas getrennt}
Beispiel: dropdown
bla, "Eins, Zwei, Drei"
bla = "Zwei"
dropdown bla, "Eins, Zwei, Drei"
pause 4000
print bla
Listbox:
Das ausgewählte Element wird der angegebenen Variablen zugewiesen.
listbox {var
name}, {Elementliste durch Kommas getrennt}, {Höhe in Elementen}
Beispiel: listbox bla, "Eins,Zwei,Drei", 5
bla = "Zwei"
listbox bla, "Eins,Zwei,Drei", 5
onchange change
wait
change:
print bla
end
Meter:
Fügt ein HTML-Meter-Element in die Seite ein. Wird aktualisiert, wenn
die Variable geändert wird. meter
{var name}, {min Wert}, {max Wert} [, {low* Wert}, {high* Wert}, {optimum*
Wert}]
x = 50
Meter x, 0, 100
CheckBox*:
Fügt ein HTML-Checkbox-Element in die Seite ein. Wird aktualisiert, wenn die Variable geändert wird. checkbox {var name}
c = 1
checkbox c
print c
onchange changed
wait
changed:
print c
end
Fügt ein HTML-Radio-Button-Element in die Seite ein. Es wird aktualisiert, wenn die Variable geändert wird. radio {var name}
c = 0
radio c
print c
onchange changed
wait
changed:
print c
end
Timepicker*:
Fügt ein HTML-Timepicker-Element in die Seite ein.
timepicker
{var name}
DateTimepicker*:
Fügt ein HTML Datetime-Element in die Seite ein. Wird aktualisiert, wenn der Picker geändert wird. datetimepicker {var name}
Filepicker*:
Fügt ein HTML Filepicker-Element in die Seite ein. Wird aktualisiert,
wenn die Variable geändert wird.
Colorpicker*:
Fügt ein HTML Colorpicker-Element in die Seite ein. Wird aktualisiert,
wenn die Variable geändert wird.
colorpicker c
textbox c
wait
OnLoad:
Optionale Verzweigung, die jedes Mal ausgeführt wird, wenn eine Seite geladen
wird. Dieser Code wird ausgeführt, bevor die Seite zurückgegeben wird, aber
nach allen Verzweigungen für Schaltflächen. Die Verzweigung muss mit dem Befehl
wait
abgeschlossen werden.
onload
{Verzweigungsbezeichnung}
Wait:
Sendet alle aufgelaufenen Befehle der Benutzeroberfläche an
den Browser. Der Browser wird angezeigt, sobald dieser Befehl ausgeführt wird.
Der ESP wird in einen Wartezustand versetzt, damit Benutzerinteraktionen wie
das Drücken von Schaltflächen im Browser oder Pin-Interrupt-Funktionen
ausgeführt werden können. Das Programm hält an, wenn eine Benutzerinteraktion
stattfindet.
wait
ReturnGUI:
Sendet alle gesammelten GUI-Befehle an den Browser. Der Browser-Inhalt wird angezeigt, sobald dieser Befehl ausgeführt wurde. Das Programm fährt mit der Ausführung der nächsten Zeilen nach diesem Befehl fort. Dieser Befehl aktualisiert den gesamten Inhalt des Browser-Fensters mit allen Aktualisierungen oder Änderungen, die mit der Funktion htmlvar() an Variablen vorgenommen wurden: returngui
HTMLID():
Die Funktion html_id() gibt die zufällig generierte ID für das zuletzt erstellte GUI-Objekt zurück. Nützlich für Javascript-Interaktionsmöglichkeiten: id = htmlid()
GUIOFF:
Guioff löscht den Html-Speicher und verhindert, dass zusätzliche Daten mit Gui-Befehlen wie print, wprint, html, button ect. hinzugefügt werden. Deaktiviert auch die Web-Sockets. Gut für Programme, die sehr schnelle Antworten von Interrupts etc. benötigen: GUIoff
GUION:
Schaltet die GUI-Funktionen wieder ein, wenn sie mit GUIOFF deaktiviert wurden: GUIon
CSSID:
Der Befehl cssid wendet css auf das gewünschte Element nach der ID an. Er sollte unmittelbar nach der Erstellung eines GUI-Objekts ausgeführt werden: cssid htmlid(), "background-color: yellow"
CSSCLASS:
Der Befehl cssclass wendet CSS auf die gewünschte Klasse von
GUI-Objekten an. Alle Schaltflächen werden auf die Farbe Gelb gesetzt: cssclass
"button", "background-color: yellow;"
JAVASCRIPT:
Ermöglicht es, Javascript-Dateien in einer Seite einzubinden. Die Datei muss
mit dem Dateimanager zuvor hochgeladen worden sein.
javascript
{Dateiname}
CSS:
Ermöglicht es, CSS-Dateien in die Seite einzubinden. Die Datei muss mit dem
Dateimanager zuvor hochgeladen worden sein.
css {Dateiname}
JSCALL:
Ermöglicht die Ausführung von Javascript im Webbrowser, um eine Funktion
aufzurufen, die in einer Javascript-Datei (Flash) enthalten ist, die mit dem
Befehl javascript aufgerufen wird.
jscall
{Funktionsname}, Beispiel:
Javascript "beep.js" 'schließt die js-Datei in die Webseite ein
Jscall "beep" 'Aufruf der Beep-Funktion aus dem in die Seite geladenen Javascript.
SVG: WEB-GRAFIK-BEFEHLE
Farben sind optional. Wenn keine Farbe angegeben wird, ist
die Standardfarbe Schwarz. Beispiele finden Sie unter /graphics-example.html
und /graphic-clock-example.html.
Farbpalette
0 = Schwarz
1 = Marineblau
2 = Grün
3 = Türkis
4 = Kastanienbraun
5 = Violett
6 = Olivgrün
7 = Silber
8 = Grau
9 = Blau
10 = Limette
11 = Wasserfarben
12 = Rot
13 = Fuchsie
14 = Gelb
15 = Weiß
Graphics:
Fügt der Seite ein grafisches Element hinzu. Jeder Parameter
kann eine Variable oder ein Wert sein.
graphics
{Breite}, {Höhe}
Gcls:
Löscht den Grafikpuffer.
gcls
Line:
Erzeugt eine Linie als Grafikelement. Jeder Parameter kann
eine Variable oder ein Wert sein.
line {x1}, {y1}, {x2}, {y2}, {color}
Circle:
Erzeugt einen Kreis als
Grafikelement. Jeder Parameter kann eine Variable oder ein Wert sein.
circle {x1},
{y1}, {Radius}, {Farbe}
Ellipse:
Erzeugt eine Ellipse als
Grafikelement. Jeder Parameter kann eine Variable oder ein Wert sein.
ellipse {x1},
{y1}, {radiusX}, {radiusY}, {Farbe}
Rect:
Erzeugt ein Rechteck als Grafikelement. Jeder Parameter kann
eine Variable oder ein Wert sein.
rect
{x1}, {y1}, {radiusX}, {radiusY}, {Farbe}
Text:
Erzeugt Text als Grafikelement. Jeder Parameter kann eine Variable oder
ein Wert sein.
text {x1},
{y1}, {Anzuzeigender Text}, {Winkel}, {Farbe}
WEB Interface
Internet-Funktionen:
wget():
Holt den HTML-Inhalt einer Webseite und gibt ihn als String zurück. Kein "http://" vor der URL. Standardmäßig wird Port 80 verwendet, wenn keiner angegeben wird.
wget({String oder var name für url},{Optionale Portnummer})
wgets*():
Holt den HTML-Inhalt einer (kleinen!) https-Webseite und gibt ihn als String zurück. Kein "https://" vor die URL. Beispiel: print len(wgets("www.jogis-roehrenbude.de/"))
wgets({String oder var name für url})
ping():
Gibt eine 1 zurück, wenn der Endpunkt erreichbar ist, und eine 0, wenn nicht.
Bla = ping("192.168.1.1")
Bla = ping("google.com")
ip():
Gibt die IP-Adresse des Geräts als String zurück.
ip()
I/O Interface GPIO
Michael Moulinari entwickelte ein UniversalPinIO-System indem alle einfachen Pin-Ein- und Ausgaben zentral über die io()-Funktion stattfinden. Alternative* Aufrufe bewirken Gleiches.
Digital I/O
io(po,{pin},{wert}):
Po (port out) erlaubt es, den Gpio-Pin auf high oder low zu setzen. Vgl. digitalWrite: Beispiel: io(po,2,1)
pinOut*{pin},{wert}:
PinOut erlaubt es, den Gpio-Pin auf high oder low zu setzen. Beispiel: pinout 2,1 ruft intern io(po,2,1) auf.
io(pi,{pin}):
Pi (port in) liefert den Zustand eines Gpio Pins pin als 0 oder 1. Beispiel: x = io(pi,0)
Nützlich zum Lesen von Drucktasten und anderen digitalen Eingängen.
io*(pu,{pin}):
Pu (port in pulldown) liefert den Zustand eines Gpio Pins pin als 0 oder 1. Der Eingang wird mit einem PullUp-Widerstand initialisiert, so dass offene Eingänge eine 1 liefern. Beispiel: x = io(pu,0)
Nützlich zum Lesen von Drucktasten und anderen digitalen Eingängen.
pinIn*({pin}):
PinIn liefert den Zustand eines Gpio Pins pin als 0 oder 1 entsprechend x = io(pu,0): x = PinIn(0)
io*(pd,{pin}):
Pd (port in pulldown) liefert den Zustand eines Gpio Pins pin als 0 oder 1. Der Eingang wird mit einem PullDown-Widerstand initialisiert, so dass offene Eingänge eine 0 liefern. Beispiel: x = io(pd,0)
Nützlich zum Lesen von Drucktasten und anderen digitalen Eingängen.
dout*{Wert}:
Digital Out gibt einen Wert (Byte) an den mit dout anfang, anzahl festgelegten Digitalausgängen parallel aus (üblicherweise bis 8 Pins). Nützlich für Digitalzähler und Lauflichter mit LED oder zum Aufbau eines eigenen DAC: dout 7
dout* {Anfangs-Pin},{Anzahl}:
Legt den Anfangs-GPIO zur parallelen Ausgabe fest. Der zweite Wert legt die Anzahl fest: dout 1,4
din*():
Liefert einen Wert (Byte) an den mit din anfang, anzahl festgelegten parallelen Digitaleingängen. Aufruf als Funktion: x = din()
din* {Anfangs-Pin},{Anzahl}:
Legt den Anfangs-Gpio zur parallelen Eingabe fest. Der zweite Wert legt die Anzahl fest: din 5,4
Digital PWM I/O
io(pwo,{pin},{wert}):
Pwo (PWM Out) legt ein PWM-Signal an den angegebenen Pin: io(pwo,3,127)
pwmOut*{pin},{wert}:
PWMOut ist eine alternative Schreibweise für PWM-Ausgaben. Beispiel: pwmOut 2,127 ruft intern io(pwo,2,127) auf.
pwmOut**{pin},{wert},{duration}:
PWMOut** ist ein experimentelles pulseOut: Duration in
Mikrosekunden. Mit pwmfreq
40000, sendet pwmout 13,127,200 theoretisch 8 Perioden aus
(Ultraschall).
io(pwi,{pin}):
Liefert den PWM-Wert des
angegebenen Pins:
io(pwo,6,100) 'Pin6
mit Pin7 verbunden
print io(pwi,7) '-> 99
pwmfreq {freq}
Legt die Frequenz des PWM-Signals fest. Voreinstellung ist 1 kHz: pwmFreq 1000
pwmrange* {range}
Legt die Bereich des PWM-Signals fest. Voreinstellung ist 255: pwmRange 1024
pwmres* {bits}
Legt die Auflösung in Bit des PWM-Signals fest. Voreinstellung ist 8: pwmRes 10
tone* {pin, freq, duration}
Erzeugt einen PWM-Ton am Pin mit Frequenz und Dauer: tone 4,1000,100
notone* {pin}
Beendet sofort die Tonausgabe am Pin: notone 4
pulseIN* {pin,up,[timeout]}
Liefert die Impulsdauer am Pin in Mikrosekunden. Warten auf eine abfallende Flanke ab Pin 3: us = pulseIN(3,0). Das Default-Timeout ist 5 Sekunden, wie: us = PulseIN(2,0,5e6)
pulseTI* {pin}
Liefert die Impulsdauer am Pin in Mikrosekunden. Kurzform von PulseIN(pin,1,5e6).
pulseTP* {pin}
Liefert die Impulsdauer am Pin in Mikrosekunden. Kurzform von PulseIN(pin,0,5e6).
counter* {pin,[timegate]}
Liefert die Anzahl der Impulse am Pin, die Während der Tor-Zeit auftreten. Ohne Angaben beträgt die Tor-Zeit eine Sekunde (1e6) in Mikrosekunden: N = Counter(2).
echo** {outPin, freq, duration,inPin}
Startet einen Timer und erzeugt einen PWM-Ton am outPin mit Frequenz/Hz und Dauer/ms, wie tone. Dann wird mit pulseIn gewartet, bis am inPin eine positive Flanke auftaucht. Die Zeitdifferenz wird in Mikrosekunden zurück geliefert. dt = echo(22,40000,25,27) ' CYD
io(servo,{Pin},{Winkel}):
Setzt den Winkel eines an den GPIO-Pin angeschlossenen 180°-Servos. Der Winkel muss zwischen 0 und 180 liegen. Servo-Speisespannung beachten. Alternativ als Funktion aufrufbar: io(servo,2,90)
Servo* {pin},{winkel}:
Setzt den Winkel eines an den GPIO-pin angeschlossenen Servos. Der Winkel muss zwischen 0 und 180 liegen. Servo 2,90 ; Alternativer Befehl zu: io(servo,2,90)
io(laststat,{pin}):
Diese Funktion liefert den zuletzt gesetzten Status eines Pins, z. B. eines Interrupts, und behält den Wert bei, bis er sich bei einem anderen Abfrageereignis erneut ändert. Außerdem kann man damit den letzten Wert überprüfen, der an einen Pin für Servo, Pwm oder Po gesendet wurde. Insbesondere nützlich bei Steuerungen über das Internet: x = io(laststat,5)
Analog I/O
io(ai):
Fragt den ersten Analogeingang des ESP-Chips ab. Nützlich zum Abrufen von Analogwerten von Fotowiderständen und anderen Gleichspannungsgebern: adc = io(ai)
adc.info*()
Liefert eine Zeichenkette mit den GPIO von unterstützten Analogeingängen der jeweiligen ESP-Variante.
io*(an):
Fragt weitere vier Analogeingänge (n = 0…4) des ESP-Chips ab. Die Pins sind dem jeweiligen Pinout des verwendeten Boards zu entnehmen. Nützlich zum Abrufen von Analogwerten von Fotowiderständen und anderen Gleichspannungsgebern: a = io(a4)
touch*({touchpin}):
Liefert Zahlenwerte eines kapazitiven Touch-Sensors. t = touch(2)
ain*(Analog-Eingang):
Alternativer Aufruf von io(an) mit n von 0 bis 4: d = ain(0)
vin*(Analog-Eingang):
Liefert den Spannungswert in Volt entsprechend ain bezogen auf 3,3 V: u = vin(0)
ainMean**(Analog-Eingang[,offset]): Uar*(Analog-Eingang[,offset]):
Liefert den Arithmetischen
Mittelwert am angegebenen Eingang: u = uar(1)
Optional kann ein Offset übergeben werden zur Verschiebung der
‚Nullinie‘.
ainRMS**(Analog-Eingang): Ueff*(Analog-Eingang[,offset]):
Liefert den Effektiv-Wert (True
RMS) am angegebenen Eingang: u
= ueff(1)
Optional kann ein Offset übergeben werden zur Verschiebung der
‚Nullinie‘.
Integrierte DAC in ESP32 und ESP32-S2:
io*(dac,{Wert}):
Gibt eine reine Analogspannung am ersten DAC eines ESP mit integriertem DAC aus: io(dac,127)
io*(dac1,{Wert}):
Gibt eine reine Analogspannung am ersten DAC eines ESP mit integriertem DAC aus: io(dac1,127)
io*(dac2,{Wert}):
Gibt eine reine Analogspannung am zweiten DAC eines ESP mit integriertem DAC aus: io(dac2,127)
Nur ESP32
io*(hall):
Liefert Zahlenwerte des in einem ESP32 verbauten Hall-Sensors. Der Hall Señor wird nur vom Ur-ESP32 unterstützt. h = io(hall)
capture.begin*([{adc_channel}]):
Initialisiert das Sampling-Modul. Voreingestellt ist ADC0. Ein ADC_Channel entspricht nicht immer dem Analogeingang ADC, hier GPIO 35 des CYD: capture.begin(7)
capture.end*():
Deaktiviert das Sampling-Modul: capture.end()
capture**():
Liefert 100 Samples des Analogeingangs bei eingestallter Sampling-Rate in einem String. Die Werte sind durch Komma getrennt: a = capture()
capture.rate**({SampleRate}):
Legt die Messungen pro Sekunde fest: capture.rate(10000)
capture.level*(level):
Legt die Triggerschwelle der Messdaten fest. Level 0 schaltet die Triggerung aus: capture.level(128)
capture.min**():
Liefert den niedrigsten Wert der Sampledaten: min = capture.min()
capture.max**():
Liefert den höchsten Wert der Sampledaten: max = capture.max()
DACgen** Frequenz
Generiert am internen 8-Bit-DAC2 eine Sinusschwingung in Bereich 135 bis 135000 Hz. Am CYD-ESP32-Board liegt DAC2 am Verstärker-Eingang. Das Wechselspannungs-Signal kann verstärkt am Lautsprecher-Anschluss abgegriffen werden: DacGen 1000
DACamp** Faktor
Stellt die Amplitude in Teilen der DAC-Schwingung ein: Werte 1, 2, 4, 8. (8 -> 1/8 usw.)
Serielles Interface Serial 1 und 2
serialprint {wert oder var}
Gibt nur Text oder eine Variable auf der seriellen Schnittstelle aus. Es wird kein Zeilevorschub oder Wagenrücklauf hinzugefügt.
serialprintln {Wert oder var}
Gibt nur Text oder eine Variable über die serielle Schnittstelle aus. Endet mit einem Zeilenvorschub.
baudrate {wert oder var}
Setzt die Baudrate für die serielle Kommunikation.
input {optionaler String oder var zur Eingabeaufforderung}, {value oder var}
Fordert Eingaben über die serielle Schnittstelle vom Benutzer an und speichert sie in einer Variablen. Die Variable muss vor der Abfrage nicht deklariert werden.
serialinput {Variable}
Liefert alle über die serielle Schnittstelle empfangenen Daten in die Variable. Nützlich in Kombination mit dem Befehl serialbranch (siehe Beispiel unten)
serialflush
Löscht den seriellen Eingabepuffer. Verwirft alle im Puffer gespeicherten Zeichen.
serialtimeout {Wert oder var}
Bewirkt, dass der Eingabebefehl den gesamten Inhalt des seriellen Puffers zurückgibt, auch wenn kein CR LF vorhanden ist. Die Angabe eines Wertes von 0 deaktiviert den seriellen Timeout. Jeder Wert ungleich Null ist die Anzahl der Millisekunden, die gewartet wird, bevor ein Eingabebefehl ausgelöst wird. Voreinstellung ist 0 (deaktiviert!)
serial.read.int()
Gibt ein einzelnes Zeichen aus dem seriellen Puffer als Ganzzahl zurück. Nächstes Zeichen wird bei jeder Verwendung erfasst: Bla = serial.read.int()
serial.read.chr()
Gibt ein einzelnes Zeichen aus dem seriellen Puffer als String zurück. Greift bei jeder Verwendung das nächste Zeichen: Bla = serial.read.chr()
serial.available()
Gibt die Anzahl der Zeichen im Puffer zurück: Bla = serial.available()
SERIELLER ANSCHLUSS 2:
Ein vollständiger serieller Port #2 ist neben USB-Serial verfügbar. Der Port verwendet vorgegebene RX/TX Anschlüsse des jeweiligen Boards, die meist auch geändert werden können. Die Geschwindigkeit kann ein beliebiger Wert bis zu 115200 sein. Das Format ist auf 8N1 festgelegt.
serial2begin {Baudrate},{TX_pin},{RX_pin},{*}
Öffnet die serielle Schnittstelle 2 mit 8N1 der festgelegten Baudrate. Es ist optional möglich, die mit TX und RX verbundenen Pins zu definieren: serial2begin 115200,5,4
Ein letzter Parameter kann die Übertragungsart festlegen, so wie bei der RP2040 Variante: Serial2Begin kennt noch einen vierten Parameter als Konfiguration, der Parität, Anzahl der Bits und Länge der Stoppbits festlegt. Die Implementierung ist experimentell und verwendet folgend hexadezimale Tabelle.
|
DATA_5 0x100 |
STOP_BIT_1 0x10 |
PARITY_EVEN 0x1 |
|
DATA_6 0x200 |
STOP_BIT_1_5 0x20 |
PARITY_ODD 0x2 |
|
DATA_7 0x300 |
STOP_BIT_2 0x30 |
PARITY_NONE 0x3 |
|
DATA_8 0x400 |
|
PARITY_MARK 0x4 |
|
|
|
PARITY_SPACE 0x5 |
Die drei Hex-Zahlen werden addiert und als Wert übergeben. Standard ist
8N1 mit 0x413. Soll die Übertragung mit 1200,7,N,2 laufen, so führt Serial2begin
1200, RX, TX, Val("0x333“) zum Ziel.
serial2end
Schließt die serielle Schnittstelle 2.
serial2print {wert oder var}
Gibt nur Text oder eine Variable auf der seriellen Schnittstelle aus. Es wird kein Zeilevorschub oder Wagenrücklauf hinzugefügt.
serial2println {Wert oder var}
Gibt nur Text oder eine Variable über die serielle Schnittstelle aus. Endet mit einem Zeilenvorschub.
serial2input {Variable}
Liefert alle von der seriellen Schnittstelle 2 empfangenen Daten an die Variable.
Nützlich in Kombination mit dem Befehl serial2branch.
serialbranch [branchLabel]
Definiert eine Verzweigung, die ausgeführt wird, wenn eine serielle Eingabe empfangen wird: serialbranch [serialin]
wait
[serialin]
serialinput zz$
serialprint "empfangen:"
serialprintln zz$
return
serial2branch [branchLabel]
Definiert eine Verzweigung, die ausgeführt wird, wenn eine serielle Eingabe an Anschluss Nr. 2 empfangen wird:
serial2branch [serial2in]
wait
[serial2in]
serial2input zz$
serial2print "empfangen:"
serial2println zz$
return
I2C Interface
i2c.info*()
Liefert eine Zeichenkette mit Informationen zu den i2c-Anschlüssen.
i2c.begin({Geräteadresse als Zahl oder Variable})
Beginnt die Übertragung an das I2C-Gerät mit der gewünschten Adresse.
i2c.setup({SDA}, {SCL})
Ändert die Standard-Pins für die I2C-Schnittstelle.
i2c.write({Wert oder Variable für Daten})
Sendet ein einzelnes Zeichen bzw. Wert (1 Byte) an das I2C-Gerät.
i2c.end()
Beendet die i2c-Kommunikation mit einem bestimmten Gerät.
i2c.requestfrom({Geräte-ID},{Anzahl der anzufordernden Bytes})
Fordert eine Anzahl von Bytes vom Gerät an.
i2c.available()
Gibt die Anzahl der Bytes zurück, die zum Abruf mit i2c.read() zur Verfügung stehen.
i2c.read()
Gibt ein einzelnes Zeichen als Ganzzahl zurück. Das zurückgegebene Zeichen ist das nächste aus dem Puffer.
i2c.scan*()
Liefert eine Zeichenkette mit Dezimal-Adressen angeschlossener Geräte an den Pins SCL/SDA
i2c.is*({Geräte-ID})
Liefert einen Wert ungleich 0, wenn ein Gerät an der angegebenen Adresse (ID) reagiert.
SDA*
Konstante mit voreingestelltem I2c-Pin des verwendeten Chips.
SCL*
Konstante mit voreingestelltem I2c-Pin des verwendeten Chips.
SPI Interface
Verwendet wird der erste SPI-Anschluss des jeweiligen Chips. Über die Konstanten der SPI-Schnittstelle lassen sich die vorgegebenen Anschlüsse erfragen.
spi.info*()
Liefert eine Zeichenkette mit Informationen zu den SPI-Anschlüssen.
MOSI*
Konstante des Daten-Ausgangs (Master-Ausgang, Slave-Eingang)
MISO*
Konstante des Daten-Eingangs (Master Input, Slave Output)
SCK*
Konstante des Pins für den SPI-Takt (Clock)
CS*
Konstante für den voreingestellten Chip-Select-Pin des jeweiligen Chips. Der CS-Pin kann auch ein beliebiger Pin sein. (gesteuert durch das Benutzerprogramm)
spi.setup*({Geschwindigkeit}, {MODE}, {MSB_FIRST})
Öffnet den SPI-Port und stellt die Geschwindigkeit ein. Es ist möglich,
optional den SPI_MODE und die Bitfolge zu definieren. Standardmäßig sind diese
Werte SPI_MODE0 und MSB_FIRST.
spi.setup()* ->
Voreinstellungen werden benutzt
spi.setup(1000000) -> 1Mbit/sec, Modus 0, MSB_FIRST
spi.setup(500000, 1, 1) -> 500Kb/sec, Modus 1, MSB_FIRST
spi.setup(100000, 1, 0) -> 100Kb/sec, Modus 1, LSB_FIRST
spi.byte({Sendevariable})
Schreiben und Empfangen von Bytes zur gleichen Zeit (die Argumente sind Zahlen)
Der empfangene und der gesendete Wert sind Zahlen (Byte). Kann als Befehl verwendet werden, wenn das empfangene Argument nicht benötigt wird. Register nur lesen:
spi.byte(register)
datum = spi.byte(0)
spi.string({String}, {len})
Schreiben und Empfangen einer Zeichenkette mit len Zeichen: dat$ = spi.string("Hallo Welt!", 12)
spi.hex({hex_string}, {len})
Schreiben und Empfangen eines Strings mit einer hexadezimalen Nachricht, die len Bytes entspricht: dat$ = spi.hex("a1b2c3d4e5f6", 6) -> 6 Bytes senden (Folge von a1, b2, c3, d1, e5, f6) und in dat$ empfangen.
spi.setmode({MODE})
Ermöglicht das Ändern von spi-MODE (0/1/2/3) im laufenden Betrieb, nachdem die spi.setup-Funktion verwendet wurde.
spi.setmsb*({MODE})
Ermöglicht das Ändern von spi-LSB/MSB (0/1) im laufenden Betrieb, nachdem die spi.setup-Funktion verwendet wurde.
spi.setfrequency({FREQUENCY})
Ermöglicht die fliegende Änderung der spi-Frequenz, nachdem die spi.setup-Funktion verwendet wurde.
1 PRINT SPI.info()
2 PinOut CS,1
3 spi.setup(500000,0,1) 'spi.setup()
4 PinOut CS,0
5 spi.byte(val("0x42")) 'REGISTER SX1278
6 id = spi.byte(0) 'ID readonly
7 PinOut CS,1
8 PRINT "0x" & hex(id)
Default GPIO: MISO 13 MOSI 11 SS 10 SCK 12
0x12
Done.
WiFi Interface
WIFI.CONNECT():
Verbindet mit dem WLAN-Netzwerk (Router) unter Verwendung der SSID
und des Passworts. Optional können die IP-Adresse, das Gateway und die
Subnetzmaske für eine statische IP angeben werden.
Nur SSID: wifi.connect(
{SSID} )
SSID und PASSWORT: wifi.connect( {SSID}, {Passwort})
Statische IP: wifi.connect( {SSID}, {Passwort}, {ip}, {gateway}, {netmask} )
WIFI.AP():
Erstellt einen Zugangspunkt (Access Point, HotSpot) mit dem angegebenen
Namen und Passwort. Wenn das Passwort nicht angegeben wird, handelt es sich um
ein offenes Netzwerk.
Offenes Netzwerk: wifi.ap(
{SSID} )
SSID und PASSWORT: wifi.ap( {SSID}, {Passwort})
WIFIOFF:
Schaltet das gesamte Netzwerk für den STA- und AP-Modus aus.
Der WiFioff-Befehl kann aufgerufen werden, um das gesamte Netzwerk zu
deaktivieren. Der Befehl AP oder CONNECT, wenn er nach WiFioff
ausgeführt wird, aktiviert den jeweiligen WiFi-Modus. Mit jedem dieser Befehle lassen
sich beide Modi jederzeit wieder einschalten.
Wifioff
WIFIAPSTA:
Ermöglicht die gleichzeitige
Verwendung der Befehle connect und ap, um eine Verbindung zu
einem Netzwerk herzustellen und gleichzeitig einen Zugangspunkt zu erstellen.
wifiapsta
WIFI.SCAN():
Gibt die Anzahl der verfügbaren Wifi-Netzwerke zurück. NumberOfNetworks = wifi.scan()
WIFI.SSID():
Gibt den Netzwerknamen für das
ausgewählte Netzwerk zurück. Muss zuerst einen wifi.scan() ausführen.
wifi.ssid({Var
für Netzwerknummer})
WIFI.RSSI():
Gibt die Signalstärke für das
ausgewählte Netzwerk zurück. Muss zuerst einen wifi.scan() ausführen.
wifi.rssi({Var
für Netzwerknummer})
WIFI.BSSID():
Gibt die Mac-Adresse für das
ausgewählte Netzwerk zurück. Muss zuerst einen wifi.scan() ausführen.
wifi.bssid({Var
für Netzwerknummer})
WIFI.STATUS*(): status*()
Gibt den Status der Netzwerkverbindung als numerischen Wert zurück.
x = wifi.status()
HTTP Interface (WiFi)
Msg-Handler-Ereignisse werden nur übergeben, wenn eine Anfrage an die URL http://device ip/msg? verwendet wird. Siehe Beispiel https://www.esp8266basic.com/examples.html für weitere Informationen.
msgbranch {branch label} onServer*{newlabel}
Legt den Zweig für die Behandlung von msg input urls fest. Dieser Zweig wird ausgeführt, wenn die URL "http://device ip/msg?" aufgerufen wird. Alternative: onServer*
msgget({url arg})
Ruft ein Url-Argument ab und legt es in einer Variablen ab. Beispiel: Ruft das URL-Argument "color" ab und platziert es in myColorVar. Verwenden Sie die Adresszeile im Browser, um auf "ip/msg?farbe=blau" zuzugreifen: myColorVar = msgget("farbe")
msgreturn {Variablenname oder String für Rückgabe}
Setzt den Text, der vom Server zurückgegeben werden soll. Es wird kein zusätzliches HTML bereitgestellt, nur Text. Überschreibt den vorherigen Rückgabetext, wenn er mehr als einmal aufgerufen wird. Der Text wird zurückgegeben, wenn der Interpreter auf den Befehl wait stößt.
UDP-Interface (WiFi)
udpbegin {localport}
Startet einen UDP-Server, der auf dem angegebenen Port lauscht. Localport ist eine Nummer (z.B. 1234): udpbegin 4300
udpstop
Stoppt den UDP-Server. Funktioniert für UdpBegin und UdpBeginMulticast
udpbeginmulticast {multicast_ip}, {localport}
Startet einen UDP-Server-Multicast, der an der angegebenen Adresse und dem angegebenen Port lauscht. Die Multicast-IP muss im Bereich 224.0.0.0 bis 239.255.255.255 liegen: udpbeginmulticast "224.0.0.67", 4567
udpwrite {ip_address}, {port}, {message}
Schreiben eines Strings an eine entfernte IP und einen Port. ip_address ist eine Zeichenkette (z.B. "192.168.1.123"), message ist eine Zeichenkette (z.B.: "Dies ist eine gültige Nachricht"), udpwrite {ip_address}, {port}, {message}, port ist eine Zahl (z.B.: 5000): udpwrite "192.168.1.12", 3000, "Nachricht OK"
udpwritemulticast {ip_address}, {port}, {message}
Schreiben eines Strings an eine Multicast-IP und einen Port, ip_address ist eine Zeichenkette (z.B.: "224.0.0.50"), message ist eine Zeichenkette (z.B.: "Dies ist eine gültige Nachricht"), port ist eine Zahl (z.B.: 6000): udpwritemulticast "224.0.0.55", 3100, "Nachricht NICHT zugestellt!"
udpreply {Nachricht}
Sendet eine UDP-Nachricht zurück an den ursprünglichen Sender. Erlaubt eine direkte Antwort ohne Angabe der IP und des Ports. Nachricht ist eine Zeichenkette (z. B.: "Dies ist eine gültige Nachricht"): udpreply "Nachricht erhalten"
udpread()
Liest eine empfangene UDP-Nachricht vom Client. Um zu funktionieren, muss der UDP-Server geöffnet sein (Befehle UdpBegin oder UdpBeginMultiCast): let rec = udpread()
udpremote()
Lesen der IP-Adresse und des Ports der empfangenen Nachricht. Um zu funktionieren, muss der UDP-Server geöffnet sein (Befehle udpBegin oder udpBeginMultiCast): let rem = udpremote()
Das Ergebnis wird in Form von IP:Port ausgegeben: Beispiel (192.200.150.7:4568)
udpBranch {label} onUDP*{newlabel}
Definition einer Verzweigungsbezeichnung, die den Ort festlegt, an dem das Programm fortgesetzt wird, sobald eine UDP-Nachricht empfangen wird. Sobald der Return-Befehl gefunden wird, wird das Programm an der unterbrochenen Stelle fortgesetzt. Um zu funktionieren, muss der UDP-Server geöffnet sein (Befehle udpBegin oder udpBeginMultiCast): Beispiel:
udpbegin 4567
udpBranch [udp.received]
wait
[udp.received]
let rec = udpread()
let rem = udpremote()
Serialprint "Nachricht erhalten " & rec & " von " & rem
udpreply "OK"
return
Server-Beispiel für ersten ESP:
1 port = 8080
2 print "UDP-Server "&ip()&":"&port
3 udpbegin port
4 udpbranch client
5 textbox clientmsg
6 wait
7 client:
8 clientmsg = udpread() & " (" & word(udpremote(),1,":") & ")"
9 udpreply "OK"
10 return
Client-Beispiel für zweiten ESP:
1 serverIP = "192.168.178.65"
2 port = 8080
3 print "Client for " & serverIP & " on Port " & port
4 textbox msg
5 button "send", send
6 wait
7 send:
8 udpwrite serverIP, port, msg & chr(10)
9 wait
Telnet-Interface (WiFi)
TELNET.CLIENT.CONNECT():
Richtet einen Telnet-Client mit der angegebenen IP-Adresse und dem Port
ein. Wenn kein Port angegeben wird, ist der Standardwert 23. Gibt bei Erfolg
eine 1 zurück, andernfalls eine 0.
Bla =
telnet.client.connect({ip address of server}, {optional port no})
Bla = telnet.client.connect("192.168.1.100", 1234)
Bla = telnet.client.connect("192.168.1.100") 'defaults to port 23
TELNET.CLIENT.AVAILABLE():
Gibt die Anzahl der im Puffer empfangenen Zeichen zurück. Bla = telnet.client.available()
TELNET.CLIENT.READ.CHR():
Liest ein einzelnes Zeichen aus dem Puffer. Bla = telnet.client.read.chr()
TELNET.CLIENT.READ.STR():
Liest den gesamten Inhalt des
Puffers in eine Zeichenkette ein.
Bla =
telnet.client.read.str()
TELNET.CLIENT.WRITE():
Sendet eine Zeichenkette an den Server. Liefert eine 1 für Erfolg, 0 für Misserfolg: telnet.client.write({String to send}) : Bla = telnet.client.write("Hello world")
TELNET.CLIENT.STOP():
Trennt die Verbindung zum Server: telnet.client.stop()
TELNETBRANCH:
Gibt eine Verzweigung an, die gestartet wird, wenn der ESP Zeichen vom
Server empfängt. Der Zweig muss mit dem Befehl wait enden. Telnetbranch [branch]
Libraries/Bibliotheken
Einige Bibliotheken wurden zur Zeit der Kompilierung des Interpreters fest eingebunden und stehen somit dem Anwender sofort zur Verfügung. Insbesondere einige bekannte Sensoren und Anzeigen erweitern die Anwendungsmöglichkeit dieser Skriptsprache auf einem ESP32 und erlauben besonders kurze und einfache Programme.
Thingspeak, E-Mail, Openweather, Mqtt, Telegram, Dallas DS18B20, DHTxx, NeoPixel, Remote IR, OLED-1306, LCD-1602, TFT-ILI9341, BME-280, ADS-1115, MCP-4725, MAX-7218, SD-Card, MCP-410xx, AD9833, USB-Key/Mouse, BLE-Key/Mouse/Multimeter und LoRa.
Software Bibliotheken
THINGSPEAK
(MathWorks Library)
Um mit Thingspeak zu beginnen, besucht man die Website https://thingspeak.com/. Es muss ein Konto und einen Kanal/Api-Schlüssel eingerichtet werden. Diese Funktionen funktionieren nur, wenn der esp mit einem Netzwerk mit Internetanschluss verbunden ist.
SendTS({API-Schlüssel},{Feldnummer},{Feldinhalt})
Sendet den Inhalt der Felder an den Thingspeak-Dienst. Es müssen der Thingspeak-Schlüssel und die Feldnummer verwendet werden.
ReadTS({API-Schlüssel},{Kanal-ID},{Feld-Nummer)
Gibt den zuletzt veröffentlichten Wert für das gewünschte Feld zurück. Muss den Thingspeak-Schlüssel, die Kanal-ID und die Feld-Nummer verwenden.
OPENWEATHER
Die OpenWeather-Funktion readopenweather() aus dem Original ist nicht mehr enthalten. Mit Hilfe der Funktionen wget() und json() lassen sich auf einfache Weise diese Wetterdaten lesen.
SMTP E-MAIL**
Man benötigt einen SMTP-Server wie z. B. http://www.smtp2go.com/, SMTP-Server: mail.smtp2go.com, Port: 2525. Für den Versand von SMS-Nachrichten an Telefone suchen Sie das SMS-Gateway Ihres Anbieters: http://martinfitzpatrick.name/list-of-email-to-sms-gateways/
SetupEmail**{server}, {port}, {benutzername}, {passwort}
Konfiguriert den E-Mail-Server. Benötigt den Server, den Port, den Benutzernamen und das Passwort.
Email**{String To email}, {String From Email}, {String Subject}, {String Body}
Versendet eine E-Mail unter Verwendung der Absender- und Empfängeradresse sowie des Betreffs und des Textes.
**) not implemented or tested for a reason
MQTT
(Nick O'Leary, PubSubClient Library)
mqtt.setup(BrokerURLString)
Begin der Verbindung mit einem Broker.
mqtt.subscribe(SubscriptionString)
Subcription öffnen.
mqtt.msg()
Liefert Mqtt Meldung als Zeichenkette (Branch).
mqtt.publish(KanalString, DatenString)
Daten hochladen.
mqtt.end()
Mqtt beenden.
mqttBranch Label
Mqtt-Ereignis Sprung festlegen.
TELEGRAM Messenger
(Brian Lough. Universal Telegram Bot Library)
Tg.begin(TokenString, ChatIDString)
Initialisierung und Anmeldung bei Telegram. Alternativ: Telegram TokenString, ChatIDString**
Tg.send(MessageText)
Senden einer Textmeldung. Alternativer Befehl: TelegramSend MessageText**
Tg.available()
Liefert Zahl vorliegender Meldungen.
Tg.read(n)
Liefert die empfangene Textmeldung Nummer n.
Tg.name()
Liefert den Absendernamen.
Tg.id()
Liefert die AbsendrID.
memclear
'tg.begin("xxxxx:xxxxx-xxxxx-xxxx","12345678","This is espScript32 on " & cpu.type())
tg.begin("xxxxx:xxxxx-xxxxx-xxxx","12345678")
textbox in
textbox out
button "send", send
timer 1000,rec
rec:
n = tg.available()
if n > 0 then in = tg.read(0)
wait
send:
tg.send(eval(out))
wait
Hardware Bibliotheken
Dallas Temperatur Sensor DS18B20
(Miles Burton, Rob Tillaart, DallasTemperature Library)
temp({ID}):
Ruft Temperatursensorwerte oder Sensor-ROM-Codes von bestimmten
1-Draht-Geräten ab, die an Pin 2 angeschlossen sind. Ohne Argumente werden alle
angeschlossenen ROM-Codes als durch Leerzeichen getrennter String
zurückgegeben. Wenn das Argument numerisch ist, wird der Messwert vom N-ten
angeschlossenen Gerät zurückgegeben. Ist das Argument ein 16-stelliger
ROM-Code (als String), wird ein Messwert von diesem Sensor zurückgegeben:
Print
temp(0) -> 23.787
Romcode = temp()
Als Widerstand kann auch der interne PullUp von Pin 2 dienen mit vorher: io(pu,2)
DHT-Sensor
(Adafruit Library)
Funktionen zur Verbindung mit dem DHT Temp/Humidity-Modul.
DHT.setup({Modell}, {Pin})
Ermöglicht die Angabe des Modells (11, 21, 22) und des Pins für den DHT-Sensor: dht.setup(22,1)
DHT.temp()
Gibt den Temperaturwert in Celsius vom Sensor zurück: Print dht.temp()
DHT.hum()
Liefert die Luftfeuchtigkeit in Prozent: Print dht.hum()
DHT.heatindex()
Berechnet die „gefühlte“ Temperatur in Celsius: Print dht.heatindex()
NeoPixel WS2812
(Adafruit NeoPixel Library)
Um NEO-Pixelstreifen zu verwenden, wird das Signal als Voreinstellung an GPIO 21 eingestellt, da bei einem ESP32-S3 Zero dort die RGB-LED angeschlossen ist.
neo.setup*({GPIO},{swapRG})
Konfiguriert den Ausgangs-Pin auf einen anderen als den Standard-Pin. Ist ein zweiter Parameter nicht 0, so wird Rot und Grün getauscht: neo.setup(1)
neo({LED#},{R},{G},{B},{optional: 1, um das automatische Schreiben zu deaktivieren})
Setzt die gewünschte Pixel-LED# auf die mit einem RGB-Wert (Rot,
Grün, Blau) angegebene Farbe. Man kann optional das sofortige
Schreiben an den Neo-Pixel deaktivieren, indem man eine 1 im letzten Parameter
verwendet. Dadurch können viele Pixel auf einmal geändert werden. Andernfalls
wird die Funktion sofort ausgeführt.
neo(0,250,250,250) '
sofortiges Schreiben in Pixel 0
neo(0,250,250,250,1) ' Hinzufügen zum Puffer, der an die Neopixel gesendet wird.
neo.cls()
Schaltet alle Leds auf dem Streifen aus.
neo.stripcolor({Startpixel},{Endepixel},{R},{G},B})
Setzt einen Bereich von Leds auf die gewünschte Farbe.
neo.shift({Startpixel},{Endpixel},{Richtung, 1 für vorwärts, -1 für rückwärts.})
Zeigt einen Verschiebungseffekt an. Verschiebt alle Pixel von 0 bis 20 um eins nach oben. Dies ermöglicht einige nette Scrolling-Animationen mit sehr wenig Aufwand.
neo.hex({Pixeldaten],{Startpixel],int{Position in Pixeldaten},{Anzahl Pixel},{Helligkeit 0-100})
Das Beispiel verwendet die Zeichenkette, beginnt am Anfang der Zeichenkette und kopiert sie an den Anfang der Neopixelanzeige, kopiert 2 Pixel, bei 10% Helligkeit: neo.hex("400fff",0,0,2,10)
neo.rainbow*({Anfangswert},{Farbintensität},{Helligkeit})
Zeigt einen Regenbogeneffekt aus der NeoPixel-Bibliothek für alle Pixel am Ausgang. Ein ESP32-S3-Zero mit seiner RGB-LED an Pin 21: neo.rainbow(0,255,64) nach neo.setup(21)
while truefor firstPixelHue = 0 to 65536 step 512 neo.rainbow(firstPixelHue,255,128) pause 20nextwend
Remote IR Infrarot
(SensorsIot, Definitive-Guide-to-IR Library)
IR-EMPFÄNGER:
Mehrere Kodierungen werden unterstützt; siehe die Bibliothek
für weitere Details. Der Empfänger kann ein VS1838B oder ähnlich sein; dies ist
sehr preiswert Ein gehackter IR-Empfänger kann in einem TV, alten
Videorekorder, etc…
irbranch [label]
Gibt eine Verzweigung an, die ausgeführt werden soll, wenn ein Infrarot-Code erkannt wird. Die Verzweigung muss mit dem Return-Befehl enden.
ir.recv.setup(pin)
Setzt den Pin, der für den IR-Empfang verwendet wird (IR-Empfänger an den Pin angeschlossen): ir.recv.setup(5) 'setze den Pin 5
ir.recv.get()
Liefert den empfangenen Code; der Code ist ein String im Hex-Format: let r = ir.recv.get() -> 4907d8c5
ir.recv.full()
Liefert den empfangenen Code und das Format Und Anzahl der verwendeten Bits. Dies ist nützlich, um die Art der Fernsteuerung zu identifizieren und die Größe der Nachricht: let r = ir.recv.full() -> 4907d8c5:NEC:32
ir.recv.dump()
Ruft den empfangenen Code ab, die empfangene Nachricht wird über die serielle Schnittstelle ausführlich ausgegeben. Wahrscheinlich ist dies während der Fehlersuche nützlicher: let r = ir.recv.dump()
IR-SENDER
Sony- und NEC-Kodierung werden für die Übertragung unterstützt.
ir.send.setup(pin)
Setzt den Pin, der für die IR-Übertragung verwendet wird (IR-LED evtl. über einen Widerstand mit GND verbunden): ir.send.setup(4) 'setzt den Pin 4
ir.send.nec(code, nb_bits)
Sendet den Code (String), der aus nb_bits Bits besteht: ir.send.nec("4907d8c5", 32)
ir.send.sony(code, nb_bits)
Den Code (String) senden, der aus nb_bits Bits besteht: ir.send.sony("910", 12)
Servo Motor
(Kevin Harrington, John K. Bennett, ESP32Servo Library)
Die Ansteuerung von Servomotoren ist entsprechend dem Original Bestandteil des UniversalPinIO-Systems und ist dort wie folgt aufgeführt:
io(servo,{pin},{winkel}):
Setzt den Winkel eines an den gpio-Pin angeschlossenen Servos. Der Winkel muss zwischen 0 und 180 liegen. Alternativ als Funktion: io(servo,2,90)
Stepper Motor
(Arduino, Stepper Library)
Die Routinen steuern mittels Treiber-IC L293D (Quadruple-Half-Bridge) einen Schrittmotor an, der an den Anschlüssen 1Y, 2Y, 3Y und 4 Y des Treibers angeschlossen ist.
stepper.setup*(steps, pin1A, pin2A, pin3A,pin4A)
Legt die Schritte pro Umdrehung fest, sowie die GPIO für die Treiber-Eingänge.
stepper.step*(steps)
Steuert den Motor mit steps Schritten. Das Vorzeichen gibt die Richtung an.
stepper.speed*(speed)
Bestimmt die Geschwindigkeit des Motors
stepper.info()
Liefert eine Zeichenkette mit den Voreinstellungen für die jeweilige ESP32-Variante
while true
stepper.step(200)
pause 500
stepper.step(-200)
pause 500
wend
I2C OLED 1306 (0x3C)
(Daniel Eichhorn, Fabrice Weinberg SSD1306Wire-Library)
Ein OLED-Display mit 128x64-Auflösung an der voreingestellten I2C-Schnittstelle mit SDA/SCL. Siehe auch i2c.setup und oled.setup.
oled.color({1 oder 0 für weiß oder schwarz})
Setzt die Farbe für das nächste Element, das auf dem Bildschirm erstellt wird.
oled.cls()
Löscht den Bildschirm auf dem oled-Display
oled.line(x1,y1,x2,y2)
Zeichnet eine Linie vom Punkt (x1,y1) zum Punkt (x2,y2): oled.line(10,10,20,20)
oled.rect(x,y,w,h)
Zeichnet ein Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h': oled.rect(10,10,20,20)
oled.rect.fill(x,y,w,h)
Zeichnet ein gefülltes Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h': oled.rect.fill(10,10,20,20)
oled.circle(x,y,rad)
Zeichnet einen Kreis mit Zentrum in (x,y), Radius 'rad': oled.circle(50,120,20)
oled.circle.fill(x,y,rad)
Zeichnet einen gefüllten Kreis mit Zentrum in (x,y), Radius 'rad': oled.circle.fill(50,50,20)
oled.font({size})
Setzt die Schriftgröße auf 10, 16 oder 24. Alternativ kann size 0, 1, 2 sein.
oled.print({String},{optional x},{optional y})
Schreibt Text auf dem Display an der angegebenen Stelle: oled.print("Hallo Welt", 1,1)
oled*.setup(sda-pin, scl-pin)
Legt die GPIO für das OLED-Display mit einer Adresse 0x3C fest. Ein Heltec-WiFi-Kit V 1 verwendet GPIO 4 und 15, sowie GPIO 16 als Reset:
i2c.setup(4,15) 'HELTEC WiFi Kit 32 V1.0
io(po,16,0)
delay 50
io(po,16,1)
oled.setup(4,15)
oled*.showon()
Modus direkte Ausgabe wird eingeschaltet (default): oled.showon()
oled*.showoff()
Modus direkte Ausgabe wird ausgeschaltet. Auf dem Display erscheinen keine Änderungen mehr bis ddie Anweisung oled.show() erfolgt. Damit sind quasi gepufferte Ausgaben möglich: oled.showoff()
oled*.show()
Aktualisiert die OLED-Anzeige im Modus oled.showoff(): oled.show()
oled*.align(1 oder 2 oder 3)
Textausrichtung Links, Mitte, Rechts: oled.align(2)
oled*.wrap(x, y, Text)
Gibt
unmgebrochenen Text an der Position x,y aus:
oled.wrap (0,0,"Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
sed diam nonumy eirmod tempor invidunt ut labore.")
oled*.progress(x, y, w, h, Wert in Prozent)
Stellt einen Fortschrittsbalken dar in der angegebenen Position und Ausdehnung. Die Anzeigewerte sin 0 bis 100. Um flackerfreie Anzeigen zu erhalten kann die oled.show*()-Option Verwendung finden: oled.Progress(0, 32, 120, 10, 25)
oled.brightness*(b)
Helligkeitswert als Byte.
oled.updown*()
Vertauscht die vertikale Darstellung.
oled.mirror*()
Vertauscht die horizontale Darstellung.
oled.reset*()
Stellt Orientierung wieder her.
I2C LCD 1602-Display 0x27
(Matthias Hertel, LiquidCrystal_PCF8574 Library)
An der voreingestellten I2C-Schnittstelle mit SDA/SCL erfolgen Ausgaben auf einem solchen preiswerten Display mit den folgenden Kommandos. Siehe auch i2c.setup.
LCDprint {String oder var}, {x Position}, {y Position}
Druckt auf das OLED-Display an der angegebenen Position. Die X-Position für den Rand des Displays kann bei einigen Modellen abweichen.
LCDcls
Löscht das Display.
LCDbl {Wert oder Variable}
Schaltet die Hintergrundbeleuchtung (backlight) ein oder aus. 1 für an, 0 für aus.
LCDsend {Wert oder Variable als Kommando-Byte}, {Wert oder Variable für Modus}
Sendet ein Kommando-Byte an das Display. Siehe LCD-Display-Befehlsdokumentation in der Spezifikation des Herstellers: MODUS: 0 = BEFEHL, 1 = DATEN, 2 =
LCD*blink
Aufruf der Funktion Blink.
LCDbl* {Wert oder Variable}
Schaltet die Hintergrundbeleuchtung (backlight) ein oder aus. 1 für an, 0 für aus.
LCDcursor*
Schaltet den Cursor an.
LCDsetcursor*(x ,y)
Positioniert den Cursor.
LCDcursoroff*
Schaltet den Cursor aus.
LCDoff*
Schaltet das Display ab.
LCDon*
Schaltet das Display ein.
LCDleft*
Scrollt die Anzeige nach links.
LCDright*
Scrollt die Anzeige nach rechts.
I2C BME280 Bosch Sensor 0x76
(Adafruit BME280 Library)
An der voreingestellten I2C-Schnittstelle mit SDA/SCL. Siehe auch i2c.setup.
bme.read()
Liefert eine Zeichenkette mit Temperatur, Rel. Luftfeuchte und Luftdruck, sowie die barorometrische Höhe: Print bme.read()
bme.temp()
Liefert die Temperatur in Celsius als numerischen Wert: Print bme.temp()
bme.hum()
Liefert die Rel. Luftfeuchte in Prozent als numerischen Wert: Print bme.hum()
bme.pres()
Liefert den Luftdruck in mPa als numerischen Wert: Print bme.pres()
bme.alt()
Liefert eine Höhe basierend auf dem Normaldruck in Metern als numerischen Wert: Print bme.alt()
I2C ADS1115 ADC 16 Bit (0x48)
(RobTillaart, ADS1X15 Library)
Der Analog-Digital-Wandler an der voreingestellten I2C-Schnittstelle mit SDA/SCL. Siehe auch i2c.setup.
ads.read()
Liefert den Messwert an Eingang A0.
ads.read(Eingang als Zahl oder Variable)
Liefert den Messwert an Eingang A0 bis A4 (0,1,2,3) oder (4,5,6,7) für Differenz-Messungen: Print ads.read(2)
ads.gain(Zahl oder Variable)
Stellt den Verstärkungsfaktor direkt ein nach Datenblatt (0,1,2,4,8,16).
ads.range(Zahl oder Variable von 1 bis 6 )
Stellt den Verstärkungsfaktor als Bereich ein.
I2C MCP4725 DAC 12 Bit (0x60)
(Adafruit, MCP4725 Library)
Der Digital-Analog-Wandler an der voreingestellten I2C-Schnittstelle mit SDA/SCL. Siehe auch i2c.setup.
dac.setup(i2c_adr)
Erlaubt den Betrieb mit alternativer Adresse. Voreingestellt ist 0x60.
dac.set(Zahl oder Variable)
Setzt den Wandlerwert für die Ausgangsspannung entsprechen im Bereich 0 bis 4095: dac.set(2048)
I2C BH1750 Lux-Meter (0x23)
(Christopher Laws, BH1750 Library)
Der Baustein liefert die in Lux angegebene Lichtgröße über die voreingestellte I2C-Schnittstelle mit SDA/SCL. ADDR ist nicht angeschlossen oder an GND. Siehe auch i2c.setup.
lux.begin()*
Initialisiert den Sensor.
lux.read()*
Liefert den numerischen Lichtwert.
lux.end()*
Beendet den Sensor und gibt Speicher frei.
1 i2c.setup(6,5) ' ESP32-S3-Zero
2 print "0x" & hex(val(i2c.scan()))
3 lux.begin()
4 textbox lux
5 pause 1000
6 lux = lux.read()
SPI MAX7219 LED MATRIX 8x8
(Electro707, Simple-LED-Matrix-Library)
An der ersten SPI-Schnittstelle eines ESP32 kann eine Matrix mit vier Segmenten als Anzeige und Laufschrift fungieren. Der Aufruf spi.info() liefert die jeweiligen GPIO des ESP. Auch die Konstanten MOSI, MISO, SCK und CS sind abrufbar und je nach Chip unterschiedlich.
matrix.setup(cs_pin, rotate)
Setzt einen anderen als den voreingestellten CS-Pin und erlaubt die Anpassung der Orientierung: matrix.setup(4,1)
matrix.brightness(Helligkeitswert)
Stellt die Helligkeit der gesamten Matrix ein: matrix.brightness(5)
matrix.plot(x, y)
Setzt einen Punkt bzw. schaltet eine einzelne LED an Position x,y: matrix.plot(4,4)
matrix.uplot(x, y)
Schaltet eine einzelne LED an Position x,y aus: matrix.unplot(4,4)
matrix.cls()
Schaltet alle LED aus: matrix.cls()
matrix.fill()
Schaltet alle LED an: matrix.fill()
matrix.print(text, delay, x-position)
Zeigt Text auf unterschiedliche Art. Ist delay nicht 0, scrollt der Text entsprechend dem Vorzeichen und der Zeit in ms: matrix.print("Hallo Welt",-20,16)
SPI SD-Card-Reader
(SD; Arduino, SparkFun Library)
An der ersten SPI-Schnittstelle eines ESP32 kann ein SD-Card-Reader angeschlossen sein. Der Aufruf spi.info() liefert die jeweiligen GPIO des ESP. Auch die Konstanten MOSI, MISO, SCK und CS sind abrufbar und je nach Chip unterschiedlich voreingestellt.
sd.read(Dateiname)
Liefert den Inhalt einer Datei als Zeichenkette: a = sd.read("readme.txt")
sd.write(Dateiname, Variable)
Speichert die Zeichenkette in der Variablen unter dem Dateinamen sd.write("test.txt", a)
sd.cs(GPIO)
Setzt einen anderen als den vorgegebenen CS-Pin für den Reader: sd.cs(5)
SPI MCP410xx Digital Potentiometer
(sleemanj, MCP41_Simple Library)
An der ersten SPI-Schnittstelle eines ESP32 kann ein Digital-Potentiometer der Reihe MCP410xx angeschlossen sein. Der Aufruf spi.info() liefert die jeweiligen GPIO des ESP. Auch die Konstanten MOSI, MISO, SCK und CS sind abrufbar und je nach Chip unterschiedlich voreingestellt.
pot.setup(GPIO)
Setzt einen anderen als den vorgegebenen CS-Pin für das Potentiometer: pot.setup(5)
pot.set (Digitalwert)
Setzt der Wiper auf den angegebenen Digitalwert: pot.set(3.5/10*255)
SPI AD9833 Functions-Generator
(Billwilliams1952, AD9833 Library)
An der ersten SPI-Schnittstelle eines ESP32 kann ein Funktionsgenerator AD9833 mit MCP41010 Potentiometer angeschlossen sein. Der Aufruf spi.info() liefert die jeweiligen GPIO des ESP. Auch die Konstanten MOSI, MISO, SCK und CS sind abrufbar und je nach Chip unterschiedlich voreingestellt.
gen.setup(GPIO)
Setzt einen anderen als den vorgegebenen CS-Pin: gen.setup(4)
gen.set (Frequenz [,Form])
Stellt Frequenz und optional eine von vier Schwingungsform ein: gen.set(5000,1)
SPI SX12xx Lora
(Sandeep Mistry, LoRa Library)
Getestet mit SX1278 auf 433 MHz*
LoRa* Frequenz
Sendefrequenz in Hertz: LoRa 433000000 LoRa 433E6
LoRa 0*
Schaltet LoRa aus.
LoRaPrint String* LoRaWrite* String LoRaSend* String
Sendet eine Zeichenkette: LoRaPrint "Hallo"
LoRaBranch Label*
Ereignis gesteuerter Unterprogrammaufruf am Label zum Empfang: LoRaBranch [rx]
LoraPins SS, RST, DIO0*
Setzten neuer GPIO für das Lora-Board mit numerischen Werten.
LoRaGain Wert*
Stellt die Verstärkung des LNA ein bei Empfang: LoRaRain 2
LoRaPower Wert*
Stellt die Sendeleistung ein als numerischen Wert: LorRaPower 1 'default
LoRaSF Wert*
Stellt den Spreading-Factor ein als numerischen Wert: LorRaSF 7 'default
LoRaBW Wert*
Stellt die Bandbreite ein als numerischen Wert: LorRaBW 125000 'default
Lora.info()*
Liefert eine Zeichenkette mit den eingestellten GPIO.
LoRa.Read()*
Liefert die Zeichenkette des letzten Empfangs: message = LoRaRead()
LoRa.RSSI()*
Liefert die Signalstärke als numerischen Wert: rssi = LorRa.RSSI()
LoRa.SNR()*
Liefert die Signalqualität als numerischen Wert: snr = LorRa.SNR()
LoRa.SF()*
Liefert den eingestellten Spreading-Factor als numerischen Wert: sf = LorRa.SF()
LoRa.BW()*
Liefert die eingestellte Bandbreite als numerischen Wert: bw = LorRa.BW()
1 LoRa 433000000
2 TextBox s
3 TextBox r
4 LoRaBranch [rx]
5 Wait
6 [rx]
7 s = LoRa.Read()
8 r = LoRa.RSSI() & " dB"
9 Return
SPI TFT DISPLAY
(Bodmer, TFT_eSPI Library)
An der ersten SPI-Schnittstelle eines ESP32 kann ein TFT IL9341 SPI-Display angeschlossen werden. Dieses Display hat eine Auflösung von 320x240 mit 16bits Farbe. Das Display benötigt mindestens 5 Pins: 4 für SPI mit vorgegebenem CS und einen weiteren Pin für D/C. Der Aufruf tft.info() liefert die jeweiligen GPIO des verwendeten ESP. Es kann zurzeit dieser Niederschrift aufgrund der verwendeten Bibliothek keine andere Pinbelegung gewählt werden.
tft.info()*
Liefert eine Zeichenkette mit der jeweiligen Pinbelegung des verwendeten ESP-Chips: tft.info()
tft.setup(0, 0, 0)*
Initialisierung der Anzeige. Alle Parameter werden ignoriert. Der Aufruf bewirkt nichts und dient nur der Rückwärtskompatibilität zum Original.
tft.rgb(rot, grün, blau)
liefert die 16-Bit-Konvertierung der Farben Rot, Grün und Blau. Rot, Grün und Blau liegen im Bereich 0 – 255: let col = tft.rgb(255,0,0)
tft.fill(color)
Füllt den Bildschirm mit der Farbe color.
tft.fill(0) ' füllt den
Bildschirm mit Schwarz
tft.fill(color) ' Füllen des Bildschirms mit der Farbe;
tft.fill(tft.rgb(0,255,0)) ' füllt den Bildschirm mit Grün
tft.cls()
Löscht den Bildschirm des TFT-Displays.
tft.copy()
Kopiert den Bildschirminhalt in die Datei /screenshot.bmp
tft.line(x1,y1,x2,y2,col)
Zeichnet eine Linie vom Punkt (x1,y1) zum Punkt (x2,y2) mit der Farbe 'col': tft.line(10,10,20,20,tft.rgb(255,0,0))
tft.rect(x,y,w,h,col)
Zeichnet ein Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h' mit der Farbe 'col': tft.rect(10,10,20,20,tft.rgb(0,0,255))
tft.rect.fill(x,y,w,h,col)
Zeichnet ein gefülltes Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h' mit der Farbe 'col': tft.rect.fill(10,10,20,20,tft.rgb(0,0,255))
tft.rect.round(x,y,w,h,rad,col)
Zeichnet ein abgerundetes Rechteck vom Punkt (x,y) mit Breite 'w' und Höhe 'h', Radius 'rad' und mit Farbe 'col': tft.rect.round(10,10,100,100,5,tft.rgb(0,0,255))
tft.rect.round.fill(x,y,w,h,rad,col)
Zeichnett ein abgerundetes gefülltes Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h', dem Radius 'rad' und der Farbe 'col': tft.rect.round.fill(10,10,100,100,5,tft.rgb(0,0,255))
tft.rect.fill.H*(x,y,w,h,col1,col2)
Zeichnet ein Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h' mit einem horizontalen Farbverlauf von Farbe 'col1' zu 'col2': tft.rect.fill.H(10,10,20,20,0,tft.rgb(0,0,255))
tft.rect.fill.V*(x,y,w,h,col1,col2)
Zeichnet ein Rechteck vom Punkt (x,y) mit der Breite 'w' und der Höhe 'h' mit einem vertikalen Farbverlauf von Farbe 'col1' zu 'col2': tft.rect.fill.V(10,10,20,20,0,tft.rgb(0,0,255))
tft.circle(x,y,rad,col)
Zeichnet einen Kreis mit Mittelpunkt (x,y), Radius 'rad' und Farbe 'col': tft.circle(160,120,50,65535)
tft.circle.fill(x,y,rad,col)
Zeichne einen gefüllten Kreis mit Zentrum in (x,y), Radius 'rad' und Farbe 'col': tft.circle.fill(160,120,50,65535)
tft.readcolor(x,y)
Liefert den TFT-Farbwert der angegebenen Koordinate.
tft.text.color(col[,back])
Definiert die Farbe für den Text und optional die Hintergrundfarbe.
tft.text.cursor(x,y)
Definiert die Position des Cursors, an der der Text ausgegeben werden soll.
tft.text.size(size)
Legt die Größe des Textes fest; sie kann zwischen 1 und 8 liegen (die Schriftart ist immer dieselbe).
tft.text.width*(String)
Liefert die Breite des Textes in Pixel des aktuellen Zeichensatzes.
tft.text.height()
Liefert die Höhe des aktuellen Zeichensatzes.
tft.print(text)
Gibt den Text auf dem Bildschirm aus mit der Farbe, Position und Größe, die mit den vorherigen Befehlen festgelegt wurden.
tft.println(txt)
Wie tft.print() mit nachfolgendem Zeilenvorschub:
tft.text.color(tft.rgb(255,255,0))
tft.text.cursor(0,50)
tft.text.size(2)
tft.print("This is
")
tft.println("print
")
tft.println("second
line")
tft.println("third
line")
tft.text.font*(fontnumber)
Auswahl der Schriftart, die für den Befehl print on TFT verwendet werden soll. Die Schriftartnummer kann sein:
0 : Standardschriftart mit fester Größe 5x7
1 : Standardschriftart mit fester Größe 5x7
2 : Standardschriftart 12 Punkt
3 : Antialiasing fixed 15 Punkt falls im Flash (/uploads/NotoSansBold15.vlw)
4 : Free Serif Bold 24 Punkt
5 : Antialiasing fixed 36 Punkt falls im Flash /uploads/NotoSansBold36.vlw)
tft.text.font(1)
tft.bmp*(Dateiname, x, y, Hintergrundfarbe)
Zeigt eine Bitmap auf dem TFT-Bildschirm an. Vor der Verwendung muss die Datei über das Menü [File] hochgeladen werden. Es können nur Dateien der Endung *.bmp und *.jpg verwendet werden (kein gif, kein png). Die Größe des Bildes muss kleiner oder gleich der Größe des Bildschirms sein (die maximal zulässige Größe ist 320 x 240). Wenn x und y nicht definiert sind, beginnt die Position des Bildes bei 0,0: tft.bmp("/uploads/hund.bmp") oder tft.bmp("/uploads/d.jpg", 50,50, 0)
tft.tty.begin*() tftTTYbegin*
Schaltet in den Terminal-Modus für die Textausgabe.
tft.tty*(text) tftTTY Text*
Gibt den Text im TTY-Modus aus. Es wird automatsch gescrollt.
tft.meter*() tftMeter*
Zeigt ein analoges Messwerk der Bibliothek mit sechs weiteren linearen Anzeigen an.
tft.caption*(text) tftCaption*
Legt den Text im Messwerk fest.
tft.needle*(percent) tftNeedle*
Bewegt den analogen Zeiger auf die angegebene Position.
tft.linear*(number, percent) tftLinear*
Stellt die lineare Anzeige nummer (0..5) auf den Wert percent.
SPI-TFT GUI OBJECTS
Übersetzung aus dem Original.
Es ist möglich, einige GUI-Objekte auf dem TFT zu implementieren. Diese Objekte werden direkt vom Interpreter verwaltet und können mit nur wenigen Zeilen Code definiert und verändert werden. Sie können auch mit den Touchscreen-Ereignissen verknüpft werden. Alle Objekte haben einen gemeinsamen Satz von Eigenschaften:
X, Y: Bildschirmposition
Width, Height: Breite und Höhe des Objekts
Forecolor: Vordergrundfarbe, Voreinstellung: tft.rgb(255,255,0) - Gelb -
Backcolor: Hintergrundfarbe, Voreinstelleung: tft.rgb(100,100,100) - Grau -
Label: Text, der dem Objekt zugeordnet ist
Textsize: Größe des Textes (Multiplikator der Standardschrift): 1 bedeutet normale Größe, 2 doppelte Größe, und so weiter ...
Checked: Eigenschaft, die mit Schaltflächen/Radio/Kontrollkästchen verbunden ist. Kann wahr oder unwahr sein
Value: Eigenschaft, die dem Bar zugeordnet ist. Es ist ein numerischer Wert, der von 0 bis 100 reichen kann
Icon1, icon2: Eigenschaften, die mit dem Toggle-Objekt verbunden sind. Definieren Sie die Dateinamen der Bilder, die mit dem Objekt verbunden sind. Icon1 definiert das Bild, wenn die Eigenschaft Checked false ist, Icon2 definiert das Bild, wenn die Eigenschaft Checked true ist
Scale: Eigenschaft, die mit dem Toggle-Objekt verbunden ist. Definieren Sie die Skalierung (Zoom) der Icons. 1 bedeutet normale Größe, 2 doppelte Größe und so weiter ...
Die Objekte werden einfach mit Funktionen wie folgt erstellt:
but1 = tft.obj.button("PUSH", 5,5,120,50,3,-1,0)
Alle Funktionen geben die Kennung des erstellten Objekts zurück (in diesem Beispiel but1). Diese Kennung ist nützlich, wenn die Eigenschaften des Objekts geändert werden oder wenn es im Touchscreen-Ereignis identifiziert wird.
tft.obj.button(label, x, y, width, height, text_size, fore_color, back_color)
Zeichnet eine Schaltfläche auf dem TFT. Die Funktion gibt die
Bezeichnung des Objekts zurück:
but2 =
tft.obj.button("Zahl2", 155,5,100,50)
tft.obj.label(label, x, y, width, height, text_size, fore_color, back_color)
Zeichnet ein Label auf dem TFT.
Die Funktion gibt die Bezeichnung des Objekts zurück.
lab2 = tft.obj.label("19:41:16",218,220,100,18,
2, tft.rgb(0,255,0))
tft.obj.checkbox(label, x, y, height, checked, text_size, fore_color, back_color)
Zeichnet ein Kontrollkästchen auf dem TFT. Die Funktion gibt den Ident
des Objekts zurück.
chk1 =
tft.obj.checkbox("Check Me", 5,60,40,1, 3, 65535, 0)
Die Eigenschaft checked (1 in diesem Beispiel) definiert den Zustand der Checkbox.
tft.obj.radio(label, x, y, height, checked, text_size, fore_color, back_color)
Zeichnet ein Radio-Button auf dem TFT. Die Funktion gibt die
Bezeichnung des Objekts zurück.
rad1 =
tft.obj.radio("Radio", 5,110,40,1, 3)
Die Eigenschaft checked (1 in diesem Beispiel) definiert den Zustand
des Radio-Buttons.
tft.obj.bar(label, x, y, height, width, text_size, fore_color, back_color)
Zeichnet einen Balken auf dem TFT. Die Funktion gibt die
Bezeichnung des Objekts zurück. Der Balken (Fortschrittsbalken) ist ein Objekt,
das einen farbigen Balken in einem rechteckigen Rahmen anzeigt, dessen Größe
von der Eigenschaft 'Wert' abhängt. Der Wert kann von 0 bis 100 gehen.
bar1 =
tft.obj.bar("Analog",150,100,160,30, 2, 65535, tft.rgb(0,25,255))
Bei der Erstellung ist der Wert des Balkens immer 0.
tft.obj.toggle(icon1, icon2, x, y[, checked})
Zeichnet ein Toggle-Element auf dem TFT. Die Funktion gibt den Ident des Objekts zurück. Das Toggle ist ein Objekt, das 2 Icons enthält, eines für den Status an und ein anderes für den Status aus. tog2 = tft.obj.toggle("/uploads/powgreen.bmp", "/uploads/powred.bmp", 100,170, 1)
Die Eigenschaft checked (1 in diesem Beispiel) definiert den Zustand des Toggles. Auch Bilder mit der Endung* .jpg werden erkannt.
Ändern Sie die Eigenschaften der TFT-GUI-Objekte:
Nach der Erstellung von Objekten können deren Eigenschaften mit den folgenden Funktionen geändert werden:
tft.obj.setlabel(obj_ident, label)
Ändert das Label eines beliebigen
Objekts. Der obj_ident ist der Wert, der von den Erzeugungsfunktionen
zurückgegeben wird.
tft.obj.setlabel(lab2,
mid(time(),12,8))
tft.obj.setvalue(obj_ident, value)
Ändern Sie den Wert der Balkenobjekte. Der obj_ident ist der
Wert, der von den Erstellungsfunktionen zurückgegeben wird. Der Wert kann
zwischen 0 und 100 liegen.
tft.obj.setvalue(bar1,
io(ai)/10)
tft.obj.setchecked(obj_ident, check)
Ändert die Eigenschaft checked der Objekte. Der obj_ident
ist der Wert, der von den Objekterstellungsfunktionen zurückgegeben wird.
tft.obj.setchecked(but2,
1) -> setzt den Button in den gedrückten Zustand
tft.obj.setchecked(tog2, 0) -> setzt den Toggle in den Zustand false
tft.obj.invert(obj_ident)
Invertiert die Eigenschaft checked der Objekte. Der
obj_ident ist der Wert, der von den Objekterstellungsfunktionen zurückgegeben
wird.
tft.obj.invert(but2)
-> invertiert den Zustand der Schaltfläche
tft.obj.invert(tog2) -> invertiert den Zustand des Schalters
tft.obj.getlabel(obj_ident)
Gibt die Label-Eigenschaft eines beliebigen Objekts zurück.
Der obj_ident ist der Wert, der von den Objekterstellungsfunktionen
zurückgegeben wird.
l =
tft.obj.getlabel(lab2)
tft.obj.getvalue(obj_ident, value)
Gibt den Wert der Balkenobjekte zurück. Der obj_ident ist
der Wert, der von den Erstellungsfunktionen zurückgegeben wird. Der Wert kann
zwischen 0 und 100 liegen.
v =
tft.obj.getvalue(bar1)
tft.obj.getchecked(obj_ident, check)
Gibt die checked Eigenschaft der Objekte zurück. Der
obj_ident ist der Wert, der von den Objekterstellungsfunktionen zurückgegeben
wird.
C =
tft.obj.setchecked(but2)
SPI-TFT-Touch – CYD only
Es besteht die Möglichkeit, den im ILI9341 TT enthaltenen Touchscreen-Controller zu aktivieren. Dieser Controller basiert auf dem Chip XPT2046 und verwendet SPI zur Kommunikation mit dem ESP-Modul. Der Touchscreen-Controller ist im CYD fest verschaltet und verwendet VSPI mit den Pins 36, 32, 39, 25 und 33.
tft.touch.info()*
Liefert eine Zeichenkette mit der jeweiligen Pinbelegung des verwendeten ESP-Chips.
tft.touch.setup(T_CS-Pin)*
Aktiviert die Touchscreen-Funktionalität. Die T_CS-Pin-Angabe wird beim CYD ignoriert, kann auch entfallen: tft.touch.setup(33)
tft.touchx()
Gibt die X-Position der berührten Stelle auf dem TFT-Bildschirm zurück: X = tft.touchx()
tft.touchy()
Gibt die Y-Position der berührten Stelle auf dem TFT-Bildschirm zurück: Y = tft.touchy()
tft.touchz*()
Gibt die Z-Position (Druck) der berührten Stelle auf dem TFT-Bildschirm zurück: Z = tft.touchz()
tft.touchxy*(x,y,w,h)
Gibt ein True (-1) zurück, wenn der aktuelle Touch (touchbranch) innerhalb des angegebenen Rechtecks liegt.
tft.checktouch()
Liefert die Kennung des GUI-Objekts, das berührt wurde. Wenn die berührte Position nicht innerhalb eines definierten Objekts liegt, ist das Ergebnis -1. Diese Funktion ist sehr nützlich in Kombination mit dem Befehl touchbranch: t = tft.checktouch()
touchbranch [label] onTouch* label
Definiert eine Verzweigung zu einem Unterprogramm, welches ausgeführt wird, wenn der Bildschirm berührt wird. Der aufgerufene Programmteil muss mit dem Befehl return beendet werden: touchbranch [touchme]
tft.touched*()
Liefert -1 oder 0 zurück als logischen Wert: if(tft.touched())then end
tft.touchxraw*()
Gibt die Rohdaten der X-Position der berührten Stelle auf dem TFT-Bildschirm zurück.
tft.touchxraw*()
Gibt die Rohdaten der Y-Position der berührten Stelle auf dem TFT-Bildschirm zurück.
Beispiel:
tft.setup(16, 4, 3)
tft.touch.setup(15)
but1 = tft.obj.button("PUSH", 5,5,120,50,2)
chk1 = tft.obj.checkbox("Check Me", 5,100,40,1,2)
lab1 = tft.obj.label("press", 0,190,200,24,2)
touchbranch [touchme]
wait
[touchme]
touch_obj = tft.checktouch()
serialprintln "checktouch " & touch_obj
if touch_obj = but1 then
tft.obj.invert(but1)
tft.obj.setlabel(lab1, "button")
endif
if touch_obj = chk1 then
tft.obj.setlabel(lab1, "checkbox")
tft.obj.invert(chk1)
endif
return
Event-Branches Zusammenfassung
Ereignisse, deren Zeitpunkt des Eintreffens unbekannt ist, müssen nicht dauernd von Programmierenden abgefragt werden, dies erledigen die sogenannten Branches oder Verzweigungen. Es sind Programmteile, die aufgerufen werden, sobald das Ereignis eintritt. Sie sind vergleichbar mit Interrupt-Routinen anderer Programmiersprachen. Diese Branches werden mit einem entsprechenden Befehl festgelegt, dessen zweiter Parameter ein Label bzw. eine Sprungmarke ist. Diese Programmteile werden wie Unterprogramme behandelt und enden in der Regel mit einem Return. Ein Ereignis wird nur verfolgt, wenn es den entsprechenden Befehl mit einer Sprungmarke gibt. Für den Messenger Telegram ist kein Branch vorgesehen.
· SerialBranch (onSerial)*
· Serial2Branch (onSerial2)*
· SerialBTBranch (onSertialBT)**
· UDPBranch (onUDP)*
· TelnetBranch (onTelnet)* -> Wait!
· MSGBranch (onServer)*
· IRBranch (onIR)*
· MeterBranch (onMeter)*
· MQTTBranch (onMQTT)*
· TimerCB (onTimerCB)*
· WebSockChangeBranch (onChange)**
· WebSockEventBranch (onEvent)**
· TouchBranch (onTouch)**
· LoRaBranch (onLoRa)**
· Interrupt (onInterrupt)**
· Timer (onTimer)* -> Wait!
**) not implemented or tested, *) alternative
Verschiedenes zur ESP32-Version
eval (Ausdruck)*
Liefert eine Zeichenkette mit dem Ergebnis des internen Expression-Evaluators. Die Übergebene Zeichenkette wird ausgewertet wie bei Funktionen. Nützlich, um z. B. aus der Ferne Funktionen wie io(po,pin,pegel) aufzurufen, oder die Temperatur zu ermitteln: eval("17+4“) -> 21, eval("cpu.temp()")
basic (Ausdruck)*
Interpretiert den angegebenen Ausdruck wie eine Programmzeile: basic(Print „Hallo“)
cpu.type()*
Liefert eine Zeichenkette mit dem gefundenen Prozessor. Print cpu.type() -> ESP32-S3
cpu.temp()*
Liefert die Kern-Temperatur in Celsius.
cpu.freq()*
Liefert die Taktfrequenz in MHz.
cpu.id()*
Liefert eine Zeichenkette mit der ID des Chips (mac)
reason()*
Liefert einen Zahlenwert zur Reboot-Reason.
Reset = "UNKNOWN,POWERON,EXT,SW,PANIC,WDT,TASK_WDT,RST_WDT,DEEPSLEEP,BROWNOUT,SDIO"
Print "Last Reset Reason: " & Word(Reset,reason()+1,",")
wakeup()*
Liefert einen Zahlenwert zur Wakeup-Reason von sleep und sleepgpio.
watchdog timeout*
Aktiviert den 'Wachhund' des ESP. Wird innerhalb von timeout kein watchdog ohne Parameter aufgerufen (Kommando), startet das System neu. Timeout kann bis zu 60 Sekunden betragen. Der Wachhund bleibt auch nach einem Programm-Stop aktiv. Nur watchdog 0 schaltet ihn ab.
watchdog*
Resettet den Wachhund bis zum nächsten timeout. Üblicherweise gehört der Aufruf in eine Schleife, um ein Reset zu vermeiden. Der Programmierer ist dafür verantwortlich den Wachhund nach Unterbrechung eines Programmlaufs zu deaktivieren!
watchdog 0*
Deaktiviert den Wachhund.
console Wert**
Erlaubt den Zugriff (0, 1) der seriellen Konsole während der Laufzeit.
WebSockChangeBranch onChange**
Setzt den Sprung (Label) für ein Unterprogramm, welches auf Änderungen von Web-Objekten reagieren kann.
debug.getchange()**
Liefert das auf der Browser-Seite (GUI) geänderten JavaScript-Elemente (WebSockChangeBranch bzw. onChange) in einer CSV-Zeichenkette: name, value, id. Das Unterprogramm endet mit Return!
dir()*
Liefert eine Zeichenkette mit den vorhandenen Dateien des Flash-Datei-Systems.
dir*
Gibt die vorhandenen Dateien des Flash-Datei-Systems aus.
list*
Listing des aktuellen Programms mit Zeilennummern im Direktmodus.
serialdir*
Gibt alle(!) vorhandenen Dateien des Wurzelverzeichnisses und deren Inhalt über die serielle Schnittstelle als Text aus. Erlaubt das schnelle Sichern aller Listings in einer Log-Datei eines seriellen Terminalprogramms.
remove Dateiname*
Lösch die angegebene Datei aus dem Flash-Dateisystem, falls sie nicht gerade editiert wird.
USB Keyboard
Nur für ESP32-Varianten mit USB-HID-Funktion
keyboardbegin*
Aktiviert den ESP als USB-HID-Keyboard.
keyboardprint* String
Gibt die angegeben Zeichenkette als Tastenanschläge aus.
keyboardprintln* String
Gibt die angegeben Zeichenkette als Tastenanschläge mit abschließendem Zeilenvorschub aus.
keyboardwrite* NumWert
Gibt den angegeben Tastaturcode aus.
keyboardpress* NumWert
Gibt den angegeben Tastaturcode als gedrückte Taste aus (Steuerungstasten).
keyboardrelease* NumWert
Das Gegenstück zu press (Steuerungstasten).
keyboardrelaeseall*
Gibt alle Tasten als unbestätigt an.
keyboardend*
Beendet den USB-Tastatur-Modus des ESP.
USB Mouse
Nur für ESP32-Varianten mit USB-HID-Funktion
mouseBegin*
Aktiviert den ESP als USB-HID-Mouse.
mouseClick*Taste(n)
Führt einen Maus-Klick aus. Taste 1, 2, 4: L/R/M oder kombiniert.
mousePress* Taste(n)
Betätigt eine Maus-Taste; 1, 2, 4: L/R/M oder kombiniert.
mouseRelease* Taste(n)
Bewirkt das Loslassen einer Maus-Taste; 1, 2, 4: L/R/M oder kombiniert.
mouseMove* x,y,w mouse.move*(x,y,w)
Relative Bewegung und Maus-Rad (wheel).
mouseEnd*
Deaktiviert die USB-Maus.
BLE Digital Multimeter BTMETER BT-90EPD und Kompatible
Setzt ESP32-Variante mit Bluetooth Low Energy voraus
dmm.begin*()
Aktiviert den Bluetooth Low Energie Client im ESP und leitet den Scann-Modus ein. Ergebnisse über USB-Serial, falls von Interesse. Die Verbindung erfolgt automatisch und funktioniert am einfachsten, wenn das Messgerät vor dem Aufruf eingeschaltet ist.
dmm.end*()
Deaktiviert den Bluetooth Low Energie Client im ESP und beendet den Scann-Modus.
dmm.connected*()
Liefert einen numerischen Wert zum Verbindungsstatus.
dmm.read*()
Liefert die Anzeige als Zeichenkette.
dmm.num*()
Liefert den reinen numerischen Zahlenwert des Messwertes.
Meterbranch** [Label] onMeter** Label
Setzt die Sprungmarke für eine Meter-Event-Routine.
BLE Keyboard
Nur für ESP32-Varianten mit Bluetooth Low Energy
keyboardblebegin*
Aktiviert den ESP als BLE-HID-Keyboard.
keyboardbleprint* String
Gibt die angegeben Zeichenkette als Tastenanschläge aus.
keyboardbleprintln* String
Gibt die angegeben Zeichenkette als Tastenanschläge mit abschließendem Zeilenvorschub aus.
keyboardblewrite* NumWert
Gibt den angegeben Tastaturcode aus.
keyboardblepress* NumWert
Gibt den angegeben Tastaturcode als gedrückte Taste aus (Steuerungstasten).
keyboardblerelease* NumWert
Das Gegenstück zu press (Steuerungstasten).
keyboardblerelaeseall*
Gibt alle Tasten als unbetätigt an.
keyboardbleend*
Beendet den USB-Tastatur-Modus des ESP.
keyboardblebattery* NumWert
Gibt den prozentualen Ladezustand (Akku) der BLE-Tastatur an.
BLE Mouse
Nur für ESP32-Varianten mit Bluetooth Low Energy
mouseBLEbegin*
Aktiviert den ESP als BLE-HID-Mouse.
mouseBLEclick*Taste(n)
Führt einen Maus-Klick aus. Taste 1, 2, 4: L/R/M oder kombiniert.
mouseBLEpress* Taste(n)
Betätigt eine Maus-Taste; 1, 2, 4: L/R/M oder kombiniert.
mouseBLErelease* Taste(n)
Loslassen einer Maus-Taste; 1, 2, 4: L/R/M oder kombiniert.
mouseBLEmove* x,y,w mouseBLE.move*(x,y,w)
Relative Bewegung und Maus-Rad (wheel).
mouseBLEbattery* NumWert
Gibt den prozentualen Ladezustand (Akku) der BLE-Maus an.
10.06.2024