Befehl | Aktion |
makeGPanel() | erzeugt ein (globales) GPanel-Grafikfenster mit Koordinaten (0, 1, 0, 1). Cursor auf (0, 0) |
makeGPanel(xmin, xmax, ymin, ymax) | erzeugt ein (globales) GPanel-Grafikfenster mit angegebenen Koordinaten. Cursor auf (0, 0) |
makeGPanel(xmin, xmax, ymin, ymax, False) | dasselbe, aber mit unsichtbarem Fenster (sichtbar machen mit visible(True)) |
makeGPanel(Size(width, height)) | dasselbe wie makeGPanel(), aber Fenstergrösse wählbar (in Pixels) |
getScreenWidth() | gibt Bildschirmbreite zurück (in Pixels) |
getScreenHeight() | gibt Bildschirmhöhe zurück (in Pixels) |
window(xmin, xmax, ymin, ymax) | setzt ein neues Koordinatensystem |
getWindow() | liefert Referenz des GWindow (JFrame) |
drawGrid(x, y) | zeichnet Gitter mit 10 Ticks im Bereich 0..x, 0..y. Anschrift abhängig, ob x,y int oder float |
drawGrid(x, y, color) | dasselbe mit Angabe der Farbe |
drawGrid(x1, x2, y1, y2) | dasselbe im Bereich x1..x2, y1..y2 |
drawGrid(x1, x2, y1, y2, color) | dasselbe mit Angabe der Farbe |
drawGrid(x1, x2, y1, y2, x3, y3) | dasselbe mit Angabe der Anzahl der Anzahl Ticks x3, y3 in x- und y-Richtung |
drawGrid(x1, x2, y1, y2, x3, y3, color) | dasselbe mit Angabe der Farbe |
drawPanelGrid(p, ...) | wie drawGrid(...) mit Angabe der GPanel-Referenz (für mehrere GPanels) |
visible(isVisible) | macht Fenster sichtbar/unsichtbar |
resizeable(isResizeable) | aktiviert, deaktiviert das Zoomen des Fensters |
dispose() | schliesst das Fenster |
isDisposed() | gibt True zurück, falls das Fenster geschlossen ist |
bgColor(color) | setzt die Hintergrundfarbe (X11-Farbstring oder Color type, zurückgegeben von makeColor()) |
title(text) | setzt den Text in der Titelzeile |
makeColor(colorStr) | gibt Farbe als Color type zum gegebenen X11-Farbstring zurück |
windowPosition(ulx, uly) | setzt das Fenster an die gegebene Bildschirmposition |
windowCenter() | setzt das Fenster in Bildschirmmitte |
storeGraphis() | speichert die Grafik in einem internen Buffer |
recallGraphics() | rendert die Grafik aus dem internen Buffer |
clearStore(color) | löscht den internen Buffer (überschreibt mit Farbe) |
delay(time) | Programm um Zeit time (Millisekunden) anhalten |
getDividingPoint(pt1, pt2, ratio) | liefert den Teilpunkt der Strecke mit Punktlisten pt1, pt2, der sie im Teilverhältnis ratio teilt |
getDividingPoint(c1, c2, ratio) | liefert den Teilpunkt der Strecke mit complex c1, c2, der sie im Teilverhältnis ratio teilt |
toUser(winX, winY), toUserHeight(winHeight), toUserWidth(winWidth), toUserX(winX), toUserY(winY) | Transformationen von Float- auf Pixelkoordinaten |
toWindow(userX, userY), toWindowHeight(userHeight), toWindowWidth(userWidth), toWindowX(userX), toWindowY(userY) | Transformationen von Pixel- auf Floatkoordinaten |
clear() | löscht Fensterinhalt (füllt mit Hintergrundfarbe) und setzt Cursor auf (0, 0) |
erase() | löscht Fensterinhalt (füllt mit Hintergrundfarbe) ohne Veränderung des Cursors |
putSleep() |
hält den Programmablauf an, bis wakeUp() aufgerufen wird |
wakeUp() | führt angehaltenen Programmablauf weiter |
linfit(X, Y) | führt eine lineare Regression y = a*x+b mit Daten in X- und Y-Liste aus und gibt (a, b) zurück |
addExitListener(onExit) | registriert die Callbackfunktion onExit(), die beim Click des Close-Buttons aufgerufen wird. Damit Fenster schliesst, muss dispose() aufgerufen werden |
lineWidth(width) | setzt die Stiftdicke (in Pixel) |
getLineWidth() | liefert aktuelle Stiftdicke (in Pixel) |
setColor(color) | setzt die Stiftfarbe (X11-Farbstring oder Colortype) |
move(x, y) | setzt Cursor auf (x, y) ohne zu zeichnen |
move(coord_list) | setzt Cursor auf Punktliste = [x, y] ohne zu zeichnen |
move(c) | setzt Cursor auf complex(x, y) ohne zu zeichnen |
getPosX() | liefert x-Koordinate des Cursors |
getPosY() | liefert y-Koordinate des Cursors |
getPos() | liefert Cursorposition als Punktliste |
draw(x, y), lineTo(x, y), lineto(x, y) | zeichnet Linie zu neuem Punkt (x, y) und ändert Cursor |
draw(coord_list), lineTo(coord_list), lineto(coor_list) | zeichnet Linie zu Punktliste = [x, y] und ändert Cursor |
draw(c), lineTo(c), lineto(c) | zeichnet Linie zu complex(x, y) und ändert Cursor |
line(x1, y1, x2, y2) | zeichnet Linie von (x1, y1) zu (x2, y2) ohne Änderung des Cursors |
line(pt1, pt2) | zeichnet Linie von pt1 = [x1, y1] zu pt2 = [x2, y2] ohne Änderung des Cursors |
line(c1, c2) | zeichnet Linie von complex(x1, y1) zu complex(x2, y2) ohne Änderung des Cursors |
line(li[p0, p1,...]) | zeichnet Linienzug der Punkte in der Liste (auch Tupel) |
arrow(x1, y1, x2, y2, size) | zeichnet Pfeil von (x1, y1) zu (x2, y2). size ist die Grösse der Pfeilspitze (falls weggelassen, size = 15) |
arrow(pt1, pt2, size) | zeichnet Pfeil von pt1 = [x1, y1] zu pt2 = [x2, y2]. size ist die Grösse der Pfeilspitze (falls weggelassen, size = 10) |
arrow(c1, c2, size) | zeichnet Pfeil von complex(x1, y1) zu complex(x2, y2). size ist die Grösse der Pfeilspitze (falls weggelassen, size = 10) |
doubleArrow(x1, y1, x2, y2, size) | zeichnet Doppelpfeil von (x1, y1) zu (x2, y2). size ist die Grösse der Pfeilspitze (falls weggelassen, size = 10) |
doubleArrow(pt1, pt2, size) | zeichnet Doppelpfeil von pt1 = [x1, y1] zu pt2 = [x2, y2]. size ist die Grösse der Pfeilspitze (falls weggelassen, size = 10) |
doubleArrow(c1, c2, size) | zeichnet Doppelpfeil von complex(x1, y1) zu complex(x2, y2). size ist die Grösse der Pfeilspitze (falls weggelassen, size = 10) |
circle(radius) | zeichnet Kreis mit Mitte bei Cursor und gegebenem Radius (in x-Koordinateneinheit) |
circle(x, y, radius), circle(center, radius) | dasselbe, aber mit gegebenem Mittelpunkt (center: Liste oder complex) |
fillCircle(radius) | zeichnet gefüllten Kreis (Füllfarbe = Stiftfarbe) |
fillCircle(x, y, radius), circle(center, radius) | dasselbe, aber mit gegebenem Mittelpunkt (center: Liste oder complex) |
ellipse(a, b) | zeichnet Ellipse mit Mitte bei Cursor und Halbachsen |
ellipse(x, y, a, b), ellipse(center, a, b) | dasselbe, aber mit gegebenem Mittelpunkt (center: Liste oder complex) |
fillEllipse(a, b) | zeichnet gefüllte Ellipse (Füllfarbe = Stiftfarbe) |
fillEllipse(x, y, a, b), fillEllipse(center, a, b) | dasselbe, aber mit gegebenem Mittelpunkt (center: Liste oder complex) |
rectangle(a, b) | zeichnet Rechteck mit Zentrum bei Cursor und Seiten |
rectangle(x1, y1, x2, y2) | zeichnet Rechteck mit gegenüberliegenden Eckpunkten |
rectangle(pt1, pt2) | zeichnet Rechteck mit gegenüberliegenden Punktlisten |
rectangle(c1, c2) | zeichnet Rechteck mit gegenüberliegenden complex |
fillRectangle(a, b) | zeichnet gefülltes Rechteck (Füllfarbe = Stiftfarbe) |
fillRectangle(x1, y1, x2, y2) | zeichnet gefülltes Rechteck (Füllfarbe = Stiftfarbe) |
fillRectangle(pt1, pt2) | zeichnet gefülltes Rechteck (Füllfarbe = Stiftfarbe) |
fillRectangle(c1, c2) | zeichnet gefülltes Rechteck (Füllfarbe = Stiftfarbe) |
arc(radius, startAngle, extendAngle) | zeichnet Kreisbogen mit Zentrum bei Cursor, Radius und Start- und Sektorwinkel (0 nach Osten, positiv im Gegenuhrzeigersinn) |
fillArc(radius, startAngle, extendAngle) | zeichnet gefüllten Kreisbogen (Füllfarbe = Stiftfarbe) |
polygon(x_list, y_list) | zeichnet Polygon mit Eckpunkten mit x-Koordinaten aus der Liste x_list und y-Koordinaten aus y_list |
polygon((li[pt1, pt2,..]) | zeichnet Polygon mit Liste aus Eckpunktlisten pt1, pt2,... |
polygon(li[c1, c2, c3,...]) | zeichnet Polygon mit Liste aus Eckpunktcomplex c1, c2,... |
fillPolygon(x_list, y_list) | zeichnet gefülltes Polygon (Füllfarbe = Stiftfarbe) |
fillPolygon((li[pt1, pt2,..]) | zeichnet gefülltes Polygon (Füllfarbe = Stiftfarbe) |
fillPolygon(li[c1, c2, c3,...]) | zeichnet gefülltes Polygon (Füllfarbe = Stiftfarbe) |
lowerPath, upperPath, hull = getHull(li[pt1, pt2,..]) | liefert Punkttupels lowerPath, upperPath und hull der konvexen Hülle der Punkte pt1, pt2,... |
quadraticBezier(x1, y1, xc, yc, x2, y2) | zeichnet quadratische Bezier-Kurve mit 2 Punkten (x1, y1), (x2, y2) und Kontrollpunkt (xc, yc) |
quadraticBezier(pt1, pc, pt2) | zeichnet quadratische Bezier-Kurve mit 3 Punktlisten |
quadraticBezier(c1, cc, c2) | zeichnet quadratische Bezier-Kurve mit 3 complex |
cubicBezier(x1, y1, xc1, yc1, xc2, yc2, x2, y2) | zeichnet kubische Bezier-Kurve mit 2 Punkten (x1, y1), (x2, y2) und 2 Kontrollpunkten (xc1, yc1), (xc2, yc2) |
cubicBezier(pt1, ptc1, ptc2, pt2) | zeichnet kubische Bezier-Kurve mit 2 Punktlisten und 2 Kontrollpunktlisten |
cubicBezier(c1, cc1, cc2, c2) | zeichnet kubische Bezier-Kurve mit 4 complex |
triangle(x1, y1, x2, y2, x3, y3) | zeichnet Dreieck mit Eckpunkten |
triangle(pt1, pt2, pt3) | zeichnet Dreieck mit Eckpunktlisten |
triangle(c1, c2, c3) | zeichnet Dreieck mit complex |
triangle(li[pt1, pt2, pt3]) | zeichnet Dreieck mit Liste der Eckpunkte |
fillTriangle(x1, y1, x2, y2, x3, y3) | zeichnet gefülltes Dreieck (Füllfarbe = Stiftfarbe) |
fillTriangle(pt1, pt2, pt3) | zeichnet gefülltes Dreieck (Füllfarbe = Stiftfarbe) |
fillTriangle(c1, c2, c3) | zeichnet gefülltes Dreieck (Füllfarbe = Stiftfarbe) |
fillTriangle(li[pt1, pt2, pt3]) | zeichnet gefülltes Dreieck (Füllfarbe = Stiftfarbe) |
point(x, y) | zeichnet 1-Pixel-Punkt bei (x, y) |
point(pt) | zeichnet 1-Pixel-Punkt bei Punktliste pt = [x,y] |
point(complex) | zeichnet 1-Pixel-Punkt bei complex(x, y) |
fill(x, y, color, replacementColor) | füllt geschlossenes Gebiet um Punkt (x, y). color wird durch replacementColor ersetzt (floodfill) |
fill(pt, color,replacementColor) | füllt geschlossenes Gebiet um Punkt pt. color wird durch replacementColor ersetzt (floodfill) |
fill(complex, color,replacementColor) | füllt geschlossenes Gebiet um complex(x, y). color wird durch replacementColor ersetzt (floodfill) |
image(path, x, y) | fügt eine Bild im GIF- , PNG- oder JPG-Format mit unterer linker Ecke bei (x, y) ein. Pfad zur Bilddatei: Relativ zum Verzeichnis von TigerJython, im Distributions-JAR (Verzeichnis sprites) oder mit http:// vom Internet. |
image(path, pt) | dasselbe mit Punktliste |
image(path, complex) | dasselbe mit complex |
image(bm, x, y) | fügt GBitmap bm im GIF- , PNG- oder JPG-Format mit unterer linker Ecke bei (x, y) ein |
image(bm, pt) | dasselbe mit Punktliste |
image(bm, complex) | dasselbe mit complex |
imageHeighpath) | gibt die Bildhöhe zurück |
imageWidth(path) | gibt die Bildbreite zurück |
enableRepaint(boolean) | aktiviert/deaktiviert das automatische Rendern des Offscreen-Buffers (Standard: aktiviert) |
repaint() | rendert den Offscreen-Buffer (nötig, wenn das automatische Rendern deaktiviert ist) |
setPaintMode() | wählt den normalen Zeichnungsmodus |
setXORMode(color) | wählt den XOR-Zeichnungsmodus mit gegebener Farbe. Zweimaliges Zeichnen löscht |
getPixelColor(x, y) | gibt Farbe am Punkt (x, y) als Colortyp zurück |
getPixelColor(x, y).red | gibt die rote Komponente der Farbe im Punkt (x, y) zurück |
getPixelColor(x, y).green | gibt die grüne Komponente der Farbe im Punkt (x, y) zurück |
getPixelColor(x, y).blue | gibt die blaue Komponente der Farbe im Punkt (x, y) zurück |
getPixelColor(pt) | gibt Farbe an Punktliste pt = [x, y] als Colortyp zurück |
getPixelColor(complex) | gibt Farbe an complex(x, y) als Colortyp zurück |
getPixelColorStr(x, y) | gibt Farbe am Punkt (x, y) als X11-Farbstring zurück |
getPixelColorStr(pt) | gibt Farbe an Punktliste als X11-Farbstring zurück |
getPixelColorStr(complex) | gibt Farbe an complex als X11-Farbstring zurück |
makeColor(value) | erzeugt eine Farbe. Beispiele für value: ("Aqua-Marine"), ("7FFED4"), , (0x7FFED4), (8388564), (0.5, 1.0, 0.83), (128, 255, 212), ("rainbow", n) mit n = 0..1, Lichtspektrum |
makeColor(color, alpha) | erzeugt eine transparente Farbe für alpha zwische 0 und 1 (makeColor("red", 0.25) ) |
Node(center, text, size, borderSize, borderColor, textColor, bgColor, font) | erzeugt und zeichnet ein Bild mit einem (gefüllten) Kreis und dem gegebenen mittenzentrierten Text. Defaults: size = 50, borderSize = 1, borderColor = "black", textColor = "black", bgColor = "white", font = Font("Courier", Font.PLAIN, 14). Gibt die Referenz von Node zurück |
Edge(node1, node2, lineWidth, color) | erzeugt und zeichnet eine ungerichtete Kante zwischen den beiden Knoten. Defaults: lineWidth = 1, color = "black" |
DirectedEdge(node1, node2, lineWidth, color, headSize) | erzeugt und zeichnet eine gerichtete Kantel von Knoten node1 zu node2. Defaults: lineWidth = 1, color = "black", headSize = 10 (Seitenlänge des Pfeildreiecks in Pixel) |
DoubleDirectedEdge(node1, node2, lineWidth, color, headSize) | erzeugt und zeichnet eine doppelt gerichtete Kante zwischen Knoten node1 und node2. Defaults: lineWidth = 1, color = "black", headSize = 10 (Seitenlänge des Pfeildreiecks in Pixel) |
text(string) | schreibt Text mit Beginn beim aktuellen Cursor |
text(x, y, string) | schreibt Text mit Beginn bei Punkt (x, y) |
text(pt, string) | schreibt Text mit Beginn bei Punktliste pt = [x, y] |
text(complex, string) | schreibt Text mit Beginn bei complex(x, y) |
text(x, y, string, font, textColor, bgColor) | schreibt Text mit Beginn bei (x, y) mit Font, Textfarbe und Hintergrundfarbe |
text(pt, string, font, textColor, bgColor) | schreibt Text mit Beginn bei Punkliste mit Font, Textfarbe und Hintergrundfarbe |
text(complex,string, font, textColor, bgColor) | schreibt Text mit Beginn bei complex(x, y) mit Font, Textfarbe und Hintergrundfarbe |
font(font) | setzt ein neues Standardfont |
makeGPanel(mouseNNN = onMouseNNN) auch mehrere, durch Komma getrennt |
registriert die Callbackfunktion onMouseNNN(x, y), die beim Mausevent aufgerufen wird. Werte für NNN: Pressed, Released, Clicked, Dragged, Moved, Entered, Exited, SingleClicked, DoubleClicked |
isLeftMouseButton(), |
gibt True zurück, falls beim Event die linke bzw. rechte Maustaste verwendet wurde |
makeGPanel(keyPressed = onKeyPressed) | registriert die Callbackfunktion onKeyPressed(keyCode), die beim Drücken einer Tastaturtaste aufgerufen wird. keyCode ist ein für die Taste eindeutiger integer Code |
getKeyModifiers() |
liefert nach einem Tastaturevent einen Code für Spezialtasten (Shift, Ctrl, usw., auch kombiniert) |
makeGPanel(closeClicked = onCloseClicked) | registriert die Callbackfunktion onCloseClicked(), die beim Klick des Close-Buttons der Titelzeile aufgerufen wird. Das Fenster muss mit dispose() geschlossen werden |
showSimulationBar(NNN = onNNN) | zeigt ein Dialogfenster mit den Button 'Step', 'Run'/'Pause', 'Reset' und einem Slider zum Einstellen der Simulationsperiode. Folgende Callbacks NNN können registiert werden: start, pause, step, reset, change(Parameter: simulationPeriod), loop, exit (close button gedrückt). loop wird in jedem Simulationszyklus vom Simulationsthread aufgerufen |
showSimulationBar(ulx, uly, initPeriod, NNN = onNNN) | wie oben, aber mit Positionierung des Dialogfensters (obere linke Ecke) und Anfangswert der Simulationsperiode (default: 100) |
hideSimulationBar() | schliesst das Dialogfenster und gibt alle Ressourcen frei |
getKey() | holt den letzten Tastendruck ab und liefert String zurück (leer, falls illegale Taste) |
getKeyCode() | holt den letzten Tastendruck ab und liefert Code zurück |
getKeyWait() | wartet bis Taste gedrückt und liefert String zurück (leer, falls illegale Taste) |
getKeyCodeWait() | wartet bis Taste gedrückt und liefert Code zurück |
getModifiers() | liefert einen Spezialcode beim Drücken von Ctrl/Alt/Shift |
getModifiersText() | liefert einen Bezeichner beim Drücken von Ctrl/Alt/Shift |
kbhit() | liefert True, falls ein Tastendruck noch nicht mit getKey() od. getKeyCode() abgeholt ist |
add(component) | fügt component in einer Zeile am oberen Rand hinzu |
validate() | baut das Fenster mit hinzugefügten Komponenten neu auf |
addStatusBar(height) | fügt eine Statusbar mit gegebener Höhe in Pixels hinzu |
setStatusText(text) | schreibt Text in Statusbar |
setStatusText(text, font, color) | schreibt Text mit Font und Textfarbe in Statusbar |
Font(name, style, size) | erzeugt eine neues Font mit gegebenen Namen, Stil und Grösse |
name | ein String mit einem dem System bekannten Fontnamen, z.B.. "Times New Roman", "Arial", "Courier" |
style | einer der Konstanten: Font.PLAIN, Font.BOLD, Font.ITALIC oder einen Kombination davon: Font.BOLD + Font.ITALIC |
size | ein Integer mit einer auf dem System verfügbaren Font-Grösse (in pixels), z.B. 12, 16, 72 |
msgDlg(message) | öffnet einen modalen Dialog mit einem OK-Button und gegebenem Mitteilungstext |
msgDlg(message, title = title_text) | dasselbe mit Titelangabe |
inputInt(prompt) | öffnet einen modalen Dialog mit OK/Abbrechen-Buttons. OK gibt den eingegebenen Integer zurück (falls kein Integer, wird Dialog neu angezeigt). Abbrechen od. Schliessen beendet das Programm. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
inputInt(prompt, False) | dasselbe, aber Abbrechen/Schliessen beendet das Programm nicht, sondern gibt None zurück. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
inputFloat(prompt) | öffnet einen modalen Dialog mit OK/Abbrechen-Buttons. OK gibt den eingegebenen Float zurück (falls kein Float, wird Dialog neu angezeigt). Abbrechen od. Schliessen beendet das Programm. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
inputFloat(prompt, False) | dasselbe, aber Abbrechen/Schliessen beendet das Programm nicht, sondern gibt None zurück. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
inputString(prompt) | öffnet einen modalen Dialog mit OK/Abbrechen-Buttons. OK gibt den eingegeben String zurück. Abbrechen od. Schliessen beendet das Programm. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
inputString(prompt, False) | dasselbe, aber Abbrechen/Schliessen beendet das Programm nicht, sondern gibt None zurück. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
input(prompt) | öffnet einen modalen Dialog mit OK/Abbrechen-Buttons. OK gibt Eingabe als Integer, Float oder String zurück. Abbrechen od. Schliessen beendet das Programm. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
input(prompt, False) | dasselbe, aber Abbrechen/Schliessen beendet das Programm nicht, sondern gibt None zurück. Mit dem benannten Parameter init kann ein Initialisierungswert gesetzt werden |
askYesNo(prompt) | öffnet einen modalen Dialog mit Ja/Nein-Buttons. Ja gibt True, Nein gibt False zurück. Schliessen beendet das Programm |
askYesNo(prompt, False) | dasselbe, aber Schliessen beendet das Programm nicht, sondern gibt None zurück |
bm = GBitmap(width, height) | erzeugt eine (leere) Bitmap mit geg. Anzahl horizontaler und vertikaler Pixels |
bm = getImage(filename) | erzeugt eine Bitmap mit der Grösse des Bildes und lädt das Bild von der Bilddatei (Formate: jpg, bmp, png, gif) |
bm = getBitmap() | gibt eine Kopie der Bitmap des aktuellen GPanels zurück |
bm.getWidth() | gibt die Breite der Bitmap zurück (in Pixels) |
bm.getHeight() | gibt die Höhe der Bitmap zurück (in Pixels) |
bm.getPixelColor(x, y) | gibt Farbe am Punkt (x, y) als Colortyp zurück |
bm.getPixelColor(pt) | gibt Farbe an Punktliste pt = [x, y] als Colortyp zurück |
bm.getPixelColorStr(x, y) | gibt Farbe am Punkt (x, y) als X11-Farbstring zurück |
bm.getPixelColorStr(pt) | gibt Farbe an Punktliste pt = [x, y] als X11-Farbstring zurück |
bm.setPixelColor(x, y, color) | setzt Farbe am Punkt (x, y). color als Farbtyp |
bm.setPixelColor(pt, color) | setzt Farbe an Punktliste pt = [x, y]. color als Farbtyp |
bm.setPixelColorStr(x, y, color) | setzt Farbe am Punkt (x, y). color als X11-Farbstring |
bm.setPixelColorStr(pt, color) | setzt Farbe an Punktliste pt = [x, y]. color als X11-Farbstring |
bm = readImage(data) | konvertiert binären Bilddatenstrom (als String im jpg, gif, bmp und png Format) in Bitmap |
s = imageToString(bm, type) | konvertiert Bitmap zu binärem Datenstrom (als String) (type = "bmp", "gif", "jpg", "png) |
save(bm, filename, type) | speichert Bitmap in Datei (type = "bmp", "gif", "jpg", "png) in Datei |
saveData(data, filename) | speichert binären Datenstrom (als String) in Datei |
bm1 = paste(bm, bmReplace, x, y) | ersetzt Teil des Bildes an der Stelle x, y mit bmReplace und gibt neue Bitmap zurück |
bm1 = crop(bm, x1, y1, x2, y2) | gibt den Teil des Bildes im Rechteck x1, y1, x2, y2 zurück |
bm1 = scale(bm, factor, angle) | skaliert das Bild mit dem Vergrösserungsfaktor factor und dreht es um den Winkel angle (in Grad im Uhrzeigersinn). Gibt das neue Bild zurück |
bm1 = floodFill(bm, x, y, oldColor, newColor) | füllt das geschlossenes Gebiet um den Punkt (x, y), das die einheitliche Farbe oldColor hat mit newColor und gibt das neue Bild zurück |
playTone(freq) | spielt Ton mit geg. Frequenz (in Hz) und Dauer 1000 ms (blockierende Funktion) |
playTone(freq, blocking = False) | dasselbe, aber nicht-blockierende Funktion (um mehrere Töne fast gleichzeitig abzuspielen) |
playTone(freq, duration) | spielt Ton mit geg. Frequenz und geg. Dauer (in ms) |
playTone([f1, f2, ...]) | spielt hintereinander mehrere Töne mit geg. Frequenzen und Dauer 1000 ms |
playTone([(f1, d1), (f2, d2), ...]) | spielt hintereinander mehrere Töne mit geg. Frequenzen und geg. Dauer |
playTone([("c", 700), ("e", 1500), ...]) | spielt hintereinander mehrere Töne mit geg. Tonbezeichnungen und geg. Dauer. Erlaubt sind: Grosse Oktave, ein-, zwei- und dreigetrichene Oktave, also der Bereich von C, C#,..., h''' |
playTone([("c", 700), ("e", 1500), ...], instrument = "piano") | wie vorher, aber mit gewähltem Instrument (piano, guitar, harp, trumpet, xylophone, organ, violin, panflute, bird, seashore, ... (gemäss MIDI-Spezifikation) |
playTone([("c", 700), ("e", 1500), ...], instrument = "piano", volume = 10) | wie vorher, aber mit gewählter Lautstärke (0..100) |
Befehl | Aktion |
samples = getWavMono(filename) |
liefert Liste mit ganzzahligen Abtastwerten der angegeben monauralen Sounddatei. Angabe "wav/xxx.wav" lädt vom wav-Verzeichnis in tigerjython2.jar |
samples = getWavStereo(filename) | liefert Liste mit ganzzahligen Abtastwerten der angegeben binauralen Sounddatei. Angabe "wav/xxx.wav" lädt vom wav-Verzeichnis in tigerjython2.jar |
getWavInfo(file) | liefert String mit Information über Abtastrate, usw. |
openSoundPlayer(filename) | öffnet einen Soundplayer mit der angegebenen Sounddatei. Nachher kann sie mit den folgenden Player-Funktionen abgespielt werden. Angabe "wav/xxx.wav" lädt vom wav-Verzeichnis in tigerjython2.jar |
openSoundPlayer(buffer) | wie oben, aber lädt die Soundsamples im WAV-Format von einem Bytearray (Typ array.array) |
openMonoPlayer(samples, sampleRate) |
erstellt einen monauralen Sound-Player, um die Liste samples mit Integer-Werten mit der gegebenen Abtastrate abzuspielen. Der Sound wird mit play() einmal abgespielt |
openStereoPlayer(samples, sampleRate) | erstellt einen binauralen Sound-Player, um die Liste samples mit Integer-Werten mit der gegebenen Abtastrate abzuspielen. Der Sound wird mit play() einmal abgespielt |
openSoundPlayerMP3(filename) | wie openSoundPlayer(), aber für MP3-Datei |
openMonoPlayerMP3(filename) | wie openMonotPlayer(), aber für MP3-Datei |
openStereoPlayerMP3(filename) | wie openStereoPlayer(), aber für MP3-Datei |
play() | spielt Sound von der aktuellen Position an und kehrt sofort zurück |
blockingPlay() | spielt Sound von der aktuellen Position an und wartet, bis er fertig gespielt ist |
advanceFrames(n) | schiebt die aktuelle Position um die Anzahl Abtastwerte nach vorne |
advanceTime(t) | schiebt die aktuelle Position um die angegebene Zeit nach vorne |
getCurrentPos() | gibt die aktuelle Position zurück |
getCurrentTime() | gibt die aktuelle Spielzeit zurück |
rewindFrames(n) | schiebt die aktuelle Position um die angegebene Anzahl Abtastwerte zurück |
rewindTime(t) | schiebt die aktuelle Position um die angegebene Zeit zurück |
stop() | hält das Abspielen an und setzt die aktuelle Abspielposition an den Anfang |
setVolume(v) | setzt die Lautstärke (v = 0..100) |
isPlaying() | gibt True zurück, falls noch nicht zu Ende gespielt ist |
mute(bool) | schaltet mit True auf stumm, mit False wieder auf hörbar |
playLoop() | wiederholt das Abspielen endlos |
replay() | wiederholt das Abspielen einmal |
delay(time) | hält Programm um time (Millisekunden) an (zum Einfügen von Pausen) |
Filename | Abtastrate (Hz) | Beschreibung |
wav/bird.wav | 22050 | Kurzes Vogelgezwitscher |
wav/boing.wav | 22050 | Aufschlag |
wav/cat.wav | 22050 | Miauen |
wav/click.wav | 22050 | Klicken |
wav/dog.wav | 22050 | Bellen |
wav/dummy.wav | 40000 | Sinus-Schwinung mit 500 Hz und 1500 Hz (halbe Amplitude) |
wav/explode.wav | 22050 | Explosion |
wav/fade.wav | 22050 | Ausblendung |
wav/flute.wav | 20000 | Flöte spielt G2 (352 Hz) |
wav/harris.wav | 20000 | Stimme spricht "harris" |
wav/mmm.wav | 22050 | Kurzes "mmm" für gutes Essen |
wav/notify.wav | 22050 | Kurzes Anmeldungssignet |
wav/oboe.wav | 20000 | Oboe spielt G2 (352 Hz) |
ping.wav | 22050 | Kurzes Klingelzeichen |
openMonoRecorder() | öffnet einen monauralen Soundrecorder |
openStereoRecorder() | öffnet einen binauralen Soundrecorder |
capture() | beginnt mit der Aufnahme |
stopCapture() | beendet die Aufnahme |
getCapturedBytes() | liefert die aufgenommenen Samples byteweise zurück (als Liste) |
getCapturedSound() | liefert die aufgenommenen Samples als integer Listenwerte zurück (binaural: Kanäle abwechselnd) |
writeWavFile(samples, filename) | schreibt die Samples in eine WAV-Datei |
fft(samples, n) | transformiert die ersten n Werte der übergebenen Liste mit Abtastwerten (floats). Rückgabe einer Liste mit n // 2 äquidistanten Spektralwerten (floats). Bei einer Abtastrate von fs reichen diese von 0 bis fs/2 im Abstand fs / n (Auflösung) |
fft_db(samples, n) | dasselbe, aber liefert die Spektralwerte in Dezibel 20*log(v) zurück |
fft_filter(ydata, cutoff, isLowpass) | Filterung der Werte durch Fouriertransformation und Nullen des oberen (isLowPass = True) oder unteren Teils (isLowpoass = False) des Spektrums und Rücktransformation mit einer inversion Fouriertransformation in den Zeitbereich. cutoff im Bereich 0...len(ydata) bestimmt die Cutoff-Frequenz fc. Für cutoff = len(ydata) the Cutoff-Frequenz ist fs / 2 (fs: Abtastrate) |
toAequidistant(xrawdata, yrawdata, deltax) | gibt zwei Listen xdata, ydata mit äquidistanten Werten in x-Abständen deltax zurück (lineare Interpolation) |
sine(A, f, t) | Sinusschwingung mit Amplitude A und Frequenz f (Phase 0) für jeden Float-Wert t |
square(A, f, t) | Rechteckschwingung mit Amplitude A und Frequenz f (Phase 0) für jeden Float-Wert t |
sawtooth(A, f, t) | Sägezahnschwingung mit Amplitude A und Frequenz f (Phase 0) für jeden Float-Wert t |
triangle(A, f, t) | Dreieckschwingung mit Amplitude A und Frequenz f (Phase 0) für jeden Float-Wert t |
chirp(A, f, t) | Sinusschwingung mit Amplitude A und zeitlinear ansteigender Frequenz (Startwert f) für jeden Float-Wert t |
Befehl | Aktion |
coeffs = polynomfit(xdata, ydata, n) | fittet mit einem Polynom der Ordnung n und liefert in ydata die gefitteten Werte. Rückgabewert: Liste mit den n + 1 Polynom-Koeffizienten |
spline = splinefit(xdata, ydata) | fittet mit einer Splinefunktion spline(x), die durch die äquidistanten Datenpunkte geht. Liefert spline mit dem Definitionsintervall min(xdata)...max(xdata). Ausserhalb gibt spline null zurück. |
fft_filter(ydata, cutoff, isLowPass) | wendet eine Tief- oder Hochpassfilterung auf die äquidistaten Datenpunkte an. cutoff muss im Bereich 0..n liegen, wo n = len(ydata). Rückgabe in ydata |
functionfit(func, derivatives, initialGuess, xdata, ydata) | fittet die Funktion func(x, param) mit n Parametern in der Liste param. derivatives(x, param) gibt eine Liste mit den Werten der n partiellen Ableitungen nach den Parametern zurück. initGuess ist eine Liste mit n Lösungsvorschlägen der Parameter |
functionfit(func, derivatives, initialGuess, xdata, ydata, weights) | dasselbe unter Angabe einer Liste weights von relativen Gewichten der Datenpunkte |
xdata, ydata = toAequidistant(xrawdata, yrawdata, deltax) |
gibt zwei Listen xdata, ydata mit äquidistanten Werten in x-Abständen deltax zurück (lineare Interpolation) |
server = TCPServer(port, stateChanged, isVerbose = False) | erzeugt einen TCP-Socket-Server, der auf dem TCP-Port port auf Clients hört. Zustandsänderungen rufen stateChanged() auf. Für isVerbose = True werden Debug-Mitteilungen im Ausgabefenster ausgeschrieben |
stateChanged(state, msg) |
Callback, der bei Zustandsänderungen aufgerufen wird. |
server.disconnect() | beendet die Verbindung mit dem Client und geht in den LISTENING-Zustand |
server.isConnected() | gibt True zurück, falls ein Client mit dem Server verbunden ist |
server.terminate() | beendet die Verbindung und den LISTENNG-Zustand, gibt den IP-Port frei |
server.isTerminated() | gibt True zurück, falls der Server terminiert wurde |
server.sendMessage(msg) | sendet die Information msg zum Client (als String, das Zeichen \0 (ASCII 0) dient als Endzeichen, automatisch transparent hinzugefügt und wieder entfernt) |
TCPServer.getVersion() | gibt die Version des Moduls als String zurück |
client = TCPClient(ipAddress, port, stateChanged, isVerbose = False) |
erzeugt einen TCP-Socket-Client, der für eine Verbindung mit einem TCPServer mit der IP-Adresse ipAddress (String) und dem TCP-Port port vorbereitet ist. Zustandsänderungen rufen stateChanged() auf. Für isVerbose = True werden Debug-Messages im Ausgabefenster ausgeschrieben |
stateChanged(state, msg) | Callback, der bei Zustandsänderungen aufgerufen wird. state: TCPClient.CONNECTING, msg: IP Adresse:Port des Servers state: TCPClient.CONNECTION_FAILED, msg: IP Adresse:Port des Servers state: TCPClient.CONNECTED, msg: IP Adresse:Port des Servers state: TCPClient.SERVER_OCCUPIED, msg: IP Adresse:Port des Servers state: TCPClient.DISCONNECTED, msg: leer state: TCPClient.MESSAGE, msg: vom Server erhaltene Message (String) |
client.connect() | erstellt eine Verbindung zum Server (blockierend bis Timeout). Gibt True zurück, falls die Verbindung zustande gekommen ist, sonst wird False zurückgegeben |
client.connect(timeout) | dasselbe, aber Angabe des Timeouts (in s) für den Verbindungsversuch |
client.isConnecting() | gibt True zurück, während der Client einen Verbindungsversuch unternimmt |
client.isConnected() | gibt True zurück, falls der Client mit einem Server verbunden ist |
client.disconnect() | beendet die Verbindung mit dem Server |
client.sendMessage(msg, responseTime) | sendet die Information msg zum Server (als String, das Zeichen \0 (ASCII 0) dient als Endzeichen, automatisch transparent hinzugefügt und wieder entfernt). Für responseTime > 0 ist die Methode blockierend und erwartet innerhalb von responseTime (in s) eine Antwort. Die Antwort wird als Rückgabewert geliefert. Falls die Antwort nicht ankommt, wird None zurückgegeben |
TCPClient.getVersion() | gibt die Version des Moduls als String zurück |
server = HTTPServer(requestHandler, serverName = "PYSERVER", port = 80, isVerbose = False) |
erzeugt einen HTTPServer (Webserver, abgeleitet aus TCPServer), der auf dem gegebenen port (default: 80) auf einen Client wartet. Startet einen Thread, der an kommende HTTP GET requests abarbeitet und einen HTTP response erzeugt. Dieser verwendet im Header den gegebenen Servernamen (default: "PYSERVER"). Es werden nur Textresponses unterstützt requestHandler() ist eine Callbackfunktion, die bei einem GET request aufgerufen wird. Für stateHandler = None wird nichts gemacht. Die Funktion kann länger dauernde Aktionen umfassen oder eine Wartezeit enthalten, damit keine neuen Requests mehr angenommen werden, bis ein Sensor wieder bereits ist, diese zu verarbeiten. Um den Server zu stoppen und den Port wieder freizugeben, sollte terminate() aufgerufen werden |
server.getClientIP() | gibt die gepunktete IP-Adresse des Clients zurück (leerer String, falls kein Client verbunden ist) |
HTTPServer.getServerIP() | gibt die gepunktete IP-Adresse des Servers zurück (statische Methode) |
(alle Methoden von TCPServer) |
Klasse HTTPClient
Funktion | Aktion |
HTTPClient.getRequest(url, data = None) |
sendet einen GET-Request an den Server. url ist entweder "http://serveraddress?key1=value1&key2=value2..." oder nur "http://serveraddress" und data eine Directory {key1: value1, key2: value2, ..}. In diesem Fall werden automatisch key und value URL-codiert. Für SSL (Port: 443) wird http: durch https: ersetzt. |
HTTPClient.postRequest(url, data = None) | sendet einen POST-Request an den Server . url ist entweder "http://serveraddress?key1=value1&key2=value2..." oder nur "http://serveraddress" und data eine Directory {key1: value1, key2: value2, ..}. In diesem Fall werden automatisch key und value URL-codiert. Für SSL (Port: 443) wird http: durch https: ersetzt. Der Rückgabewert ist der HTTP-Response (ohne Header). Falls ein Fehler auftritt, wird die Fehlerbeschreibung zurückgegeben |
HTTPClient.deletetRequest(url, data = "") | sendet einen DELETE-Request an den Server . url ist "http://serveraddress" und data ein String mit dem Dateipfad der zu löschenden Datei Für SSL (Port: 443) wird http: durch https: ersetzt. Der Rückgabewert ist der HTTP-Response (ohne Header). Falls ein Fehler auftritt, wird die Fehlerbeschreibung zurückgegeben |
HTTPClient.pushover(token_key, user_key, title, message) |
sendet einen Push-Request an den Pushover-Server api.pushover.net mit gegebenen token key, user key, title und message. Für verbose = True werden Debug-Informationen ausgeschrieben. Der Rückgabewert ist der HTTP-Response (ohne Header). Falls ein Fehler auftritt, wird die Fehlerbeschreibung zurückgegeben |
Funktion | Aktion |
chn = ThingSpeakChannel(channelId, readKey, writeKey, userKey, verbose = False) | erzeugt eine Instanz der Klasse ThinkSpeakChannel für die Kommunikation mit einem eingerichteten Channel auf dem Cloudserver www.thingspeak.com. Die Parameter entsprechen den bei der Channel-Definition vom Server erhaltenenen Werten. Mit verbose = True werden Debuginformationen ausgeschrieben. userKey ist dem Konto und nicht dem Channel zugeordnet (User API Key) |
chn.getData(nbEntries = -1, includeDate = True) | liefert die letzten nbEntries Datensätze als Liste von Dictionaries [{fieldId: value}...] (fieldId = 1..8). Für nbEntries = -1 werden alle Datensätze zurückgegeben. Für includeDate = True wird auch das Feld 'data' zurückgegeben, das die Datumszeit der Erzeugung des Datensatzes enthält. Alle Werte sind Strings. Im Fehlerfall wird None zurückgegeben |
chn.getTable(nbEntries = -1, includeDate = True) | dasselbe, aber liefert eine Instanz von DbTable mit den Tabellenwerten (als Strings) zurück. Im Fehlerfall wird eine leere Tabelle zurückgegeben |
chn.show(nbEntries = -1, includeDate = True) | dasselbe, aber schreibt den Tabelleninhalt in der Konsole aus |
chn.getLastValue(fieldId = 1) | gibt den Wert (String) des letzten Datensatz mit gegebener fieldId (1..8) zurück. Im Fehlerfall oder falls die Tabelle leer ist, wird None zurückgegeben |
chn.getFields() | gibt ein Dictionary mit den im Channel definierten Feldern und ihren Namen: {'field1': <field name 1>, 'field2':, <field name 2>..}. Im Fehlerfall wird None zurückgegeben |
chn.insert(data, timeout = 20) | macht einen Tabelleneintrag und gibt bei Erfolg True zurück. data ist entweder ein Einzelwert (Zahl oder String) oder ein Dictionary {fieldId: wert, ...} für den Eintrag in mehrere Felder. Felder, die keinen Wert erhalten, werden auf None gesetzt. Für Gratiskonten ist nur alle 15 s ein neuer Eintrag erlaubt; ist der Server noch nicht bereit, so wird der Versuch alle Sekunden wiederholt, bis die Zeit timeout (in s) erreicht ist. Dann wird False zurückgegeben |
chn.clear() |
löscht alle Tabelleneinträge und gibt bei Erfolg True zurück |
server = BTServer(serviceName, stateChanged, isVerbose = False) | erzeugt einen Bluetooth-Server, der den RFCOMM-Service mit dem Namen serviceName anbietet. Zustandsänderungen rufen stateChanged() auf. Für isVerbose = True werden Debug-Mitteilungen im Ausgabefenster ausgeschrieben |
stateChanged(state, msg) |
Callback, der bei Zustandsänderungen aufgerufen wird. |
server.disconnect() | beendet die Verbindung mit dem Client und geht in den LISTENING-Zustand |
server.isConnected() | gibt True zurück, falls ein Client mit dem Server verbunden ist |
server.terminate() | beendet den LISTENING-Zustand und gibt interne Ressourcen frei |
server.isTerminated() | gibt True zurück, falls der Server terminiert wurde |
server.sendMessage(msg) | sendet die Information msg zum Client (als String, das Zeichen \0 (ASCII 0) dient als Endzeichen, automatisch transparent hinzugefügt und wieder entfernt). |
BTServer.getVersion() | gibt die Version des Moduls als String zurück |
client = BTClient(stateChanged, isVerbose = False) |
erzeugt einen Bluetooth-Client, der für eine Verbindung mit einem BTServer vorbereitet ist. Zustandsänderungen rufen stateChanged() auf. Für isVerbose = True werden Debug-Messages im Ausgabefenster ausgeschrieben |
client.findServer(serverName, timeout) | führt eine Bluetooth-Inquiry durch, um den Server mit dem gegebenen Bluetooth-Namen zu finden. Gibt das Tupel serverInfo zurück: ("nn:nn:nn:nn:nn:nn", channel) , z.B. ("B8:27:EB:04:A6:7E", 1). Falls der Server nicht antwortet, wird None zurückgegeben. Die Suche wird bis zum Erreichen des timeout (in s) wiederholt |
client.findService(serviceName, timeout) | führt eine Bluetooth-Inquiry durch, um einen Bluetooth-Server mit dem gegebenen RFCOMM-Servicenamen zu finden. Gibt das Tupel serverInfo zurück: ("nn:nn:nn:nn:nn:nn", channel) , z.B. ("B8:27:EB:04:A6:7E", 1). Falls der server nicht antwortet, wird None zurückgegeben. Die Suche wird bis zum Erreichen des timeout (in s) wiederholt |
stateChanged(state, msg) | Callback, der bei Zustandsänderungen aufgerufen wird. state: "CONNECTING" , msg: server info (MAC-Adresse, Bluetooth-Kanal) state: "CONNECTED" , msg: server info state: "CONNECTION_FAILED", msg: sever info state: "DISCONNECTED", msg: leer state: "MESSAGE", msg: erhaltene Message |
client.connect(serverInfo, timeout) | erstellt eine Verbindung zum Server (blockierend bis maximal timeout in s). Gibt True zurück, falls die Verbindung zustande gekommen ist, sonst wird False zurückgegeben. serverInfo ist ein Tupel mit MAC-Adresse und Kanal ("nn:nn:nn:nn:nn:nn", channel) , z.B. ("B8:27:EB:04:A6:7E", 1) |
client.isConnecting() | gibt True zurück, während der Client einen Verbindungsversuch unternimmt |
client.isConnected() | gibt True zurück, falls der Client mit einem Server verbunden ist |
client.disconnect() | schliesst die Verbindung mit dem Server |
client.sendMessage(msg,) | sendet die Information msg zum Server (als String, das Zeichen \0 (ASCII 0) dient als Endzeichen, automatisch transparent hinzugefügt und wieder entfernt). |
BTClient.getVersion() | gibt die Version des Moduls als String zurück |
client = MQTTClient(messageReceived = None, username = "", password = "") |
erzeugt eine MQTTClient Instanz, die Topics publiziert (publish) und/oder abonniert (subscribe). Der Client erstellt noch keine Verbindung zu einem Broker. Der Client führt Ping Requests and Reconnection automatisch durch. |
client.connect(host, port = 1883, keepalive = 60) |
startet einen Verbindungsaufbau zum gegebenen Broker auf dem gegebenen IP port (default: 1883).
keepalive ist die maximale Periode (in s) zwischen zwei Kommunikationen mit dem Broker (default: 60 s) Falls keine anderen Messages ausgetauscht werden, handelt es sich um das Zeitintervall zwischen bei Ping-Messages. Gibt True zurück, falls die Verbindung zustande gekommen ist; sonst wird False zurück gegeben |
client.disconnect() | beendet die Verbindung zum Broker |
client.publish(topic, payload, qos = 0, retain = False) | sendet eine Message mit gegebenen Topic und Payload zum Broker. payload ist ein String (bei einem int oder float, wird dieser zuerst in einen String konvertiert). qos ist die Qualitätsstufe (quality of service level, Zahl 0, 1, 2, default: 0). retain bestimmt, ob die Message als “last known good”/retained message für dieses Topic betrachtet wird (default: False) |
client.subscribe(topic, qos = 0) | abonniert (subscribes) den Client auf eines oder mehrere Topics. topic ist ein String oder eine Liste mit Tupels im Format (topic, qos). qos ist die Qualitätsstufe (quality of service level, Zahl 0, 1, 2, default: 0); wird nicht verwendet, falls topic eine Liste ist |
client.setVerbose(verbose) | schaltet das Ausschreiben von Log-Informationen ein/aus |
Es steht auch das Modul paho-mqtt zur Verfügung. API-Reference.
Beispiel:
import paho.mqtt.client as mqtt
client = mqtt.Client()
client = GameClient(stateChanged, messageReceived, topic = "/ch/aplu/mqtt/gameclient") |
erzeugt eine GameClient Instanz zur Rückgabe von Statusinformationen und dem Austausch von Informationen für Zweipersonen-Spiele.
stateChanged(state) ist eine Callbackfunktion, da bei der Änderng des Game-Zustands aufgerufen wird. Statuswert: 'CONNECTING' (während des Verbindungsaufbaus zum Broker), 'CONNECTED' (falls im dem Broker verbunden, aber noch auf den Spielpartner wartend), 'READY' (beide Spieler sind spielbereit), 'DISCONNECTED' (der Spielpartner ist nicht mehr verbunden). messageReceived(msg) ist eine Callbackfunktion, die beim Empfang von Informationen aufgerufen wird.
topic ist das MQTT Topic, das für den Datenaustausch verwendet wird (default: /ch/aplu/mqtt/gameclient) |
client.setName(name) | setzt den Spielernamen, der beim Übergang auf READY dem Partner mitgeteilt wird |
client.connect(host, port = 1883) |
startet einen Verbindungsaufbau zum MQTT Broker mit gegebenen IP Adresse und IP Port (default: 1883) |
client.sendMessage(text) | sendet eine Textinformation zum Partner |
client.disconnect() | beendet die Verbindung zum Broker |
client.getState() | gibt den aktuellen Zustand zurück (ein Wert aus 'IDLE', 'CONNECTING', 'CONNECTED', 'READY', 'DISCONNECTED') |
client.getPartnerName() | gibt den Namen des Mitspielers zurück, der beim Übergang aur READY vom Partner mitgeteilt wurde (leer, falls noch nicht READY) |
client.getPartnerAddress() | gibt die IP-Adresse des Mitspielers zurück, der beim Übergang aur READY vom Partner mitgeteilt wurde (leer, falls noch nicht READY) |
Funktion | Aktion | ||||||||||||||||||||
info = weather.request(city, key = defaultKey, lang = "en") |
macht einen Wetterdaten-Request bei http://openweathermap.org für den gegebenen Ort. Dabei wird der gegebene Authorisierungsschlüssel verwendet. Dieser kann man man kostenfrei auf diesem Host beziehen. (Wird der Parameter weggelassen, so wird ein Standardschlüssel verwendet, der maximal 60 Anfragen / min für alle Nutzer erlaubt.) Rückgabewert: Dictionary mit den Feldern:
|