home

Dokumentation GPanel

Module import: from gpanel import *

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


Zeichnen

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

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


Callbacks

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(),
isRightMouseButton()

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


Tastatur

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


GUI-Komponenten

add(component)   fügt component in einer Zeile am oberen Rand hinzu
validate()   baut das Fenster mit hinzugefügten Komponenten neu auf


Statusbar

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-Format

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

 

Dialoge

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

 

Klasse GBitmap

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

 

Dokumentation Sound

Sound

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)

 

Module import: from soundsystem import *

Wiedergabe

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)

 

Sound Dateien in der TigerJython Distribution:

(Format: WAV PCM 16 bit mono)
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

 

Aufnahme und speichern

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

 

Fast Fourier Transform (FFT)

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

 

Curve fitting

Module import: from fitter import *

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)

 

TCP Client/Server Library

Modul import: from tcpcom import *

Klasse TCPServer

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.
state: TCPServer.PORT_IN_USE, msg: port
state: TCPServer.CONNECTED, msg: IP Adresse des Clients
state: TCPServer.LISTENING, msg: port
state: TCPSever.TERMINATED, msg: leer
state: TCPServer.MESSAGE, msg: vom Client erhaltene Message (String)

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

 

Klasse TCPClient

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



Klasse HTTPServer (abgeleitet aus TCPServer)

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.
Signatur:
msg, stateHandler = requestHandler(clientIP, filename, params)
Parameter:
     clientIP: die IP-Adresse des Client (im gepunkteten Format)
     filename: der angeforderte Dateinamen mit einem vorgestellten '/'
     params: ein Tupel mit dem Format:
          ((param_key1, param_value1), (param_key2, param_value2), ...) (alles Strings)
Rückgabewert:
     msg: der HTTP Textresponse (der Header wird automatisch erzeugt)
     stateHandler: eine Callbackfunktion, die aufgerufen wird, nachdem der Response an den Client zurückgesendet ist.  

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.

Die TCP-Verbindung wird am Ende jedes Response vom Server geschlossen. Falls sich ein Client verbindet, aber keinen Request innerhalb von 5 s sendet, schliesst der Server die Verbindung.

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.
Der Rückgabewert ist der HTTP-Response (ohne Header). Falls ein Fehler auftritt, wird die Fehlerbeschreibung zurückgegeben

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

 

Klasse ThingSpeakChannel

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

 

Bluetooth Client/Server Library

Module import: from btcom import *

Klasse BTServer

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.
state: "LISTENING" , msg: leer
state: "CONNECTED", msg: Remote info: Bluetooth name (MAC-Adresse)
state: "TERMINATED", msg: leer
state: "MESSAGE", msg: erhaltene Message

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


Klasse BTClient

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

 

MQTT Client Library

Modul import: from mqttclient import *

Klasse MQTTClient

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.

messageReceived(topic, message) ist eine Callbackfunktion, die beim Empfang einer Message aufgerufen wird (und die in einem eigenen Thread läuft). Falls None, so werden keine Empfangsnotifikationen getriggert, beispielsweise bei einem Client, der ausschliesslich publiziert. username wird verwendet, um beim Broker einzuloggen (leer, falls der Broker keine Authentifizierung verlangt). password ist das Passwort, um beim Broker einzuloggen (leer, falls der Broker keine Authentiifizierung verlangt).

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()


Klasse GameClient

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)

 

Wetterdaten:

Modul import: import weather

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:

"status" "OK" oder Fehlerstring, der den Fehler beschreibt, z.B. "City not found" (string)
"temp" Temperatur in °C (float)
"pressure" Luftdruck in hPa (mbar) (float)
"humidity" Luftfeuchtigkeit in % (int)
"temp_min" Tagesminimum der Temperatur in °C (float)
"temp_max" Tagesmaximum der Temperatur in °C (float)
"description" Wetterlage in Worten (in der Sprache des Parameter lang) (string)
"sunrise" Sonnenaufgang in Universal Time (UTC) (string)
"sunset" Sonnenuntergang in Universal Time (UTC) (string)
"datetime" Datum - Uhrzeit der Wettererfassung (UTC) (string)

 

 


home