| Fonction | Action |
| makeGPanel() | Crée une fenêtre de graphiques GPanel avec un système de coordonnées où x et y varient entre 0 et 1. Le curseur graphique est placé sur l’origine (0, 0) au coin inférieur gauche de la fenêtre |
| makeGPanel(xmin, xmax, ymin, ymax) | Crée une fenêtre GPanel avec les coordonnées flottantes indiquées. Le curseur graphique est placé en (0,0) |
| makeGPanel(xmin, xmax, ymin, ymax, False) | Idem, mais en cachant la fenêtre (pour la rendre visible, appeler visible(True)) |
| makeGPanel(Size(width, height)) | Idem que makeGPanel(), mais en spécifiant la taille de la fenêtre (en pixels) |
| getScreenWidth() | Retourne la largeur de l’écran (en pixels) |
| getScreenHeight() | Retourne la hauteur de l’écran (en pixels) |
| window(xmin, xmax, ymin, ymax) | Change la plage de coordonnées utilisées pour la fenêtre |
| drawGrid(x, y) | Dessiner une grille pour le système de coordonnées avec un marqueur tous les x pour l’axe horizontal et tous les y pour l’axe vertical. Les étiquettes des marqueurs sont déterminées par le type des paramètres x et y : int ou float |
| drawGrid(x, y, color) | Idem, en spécifiant la couleur color de la grille |
| drawGrid(x1, x2, y1, y2) | Idem, en indiquant la plage de coordonnées x1..x2, y1..y2 sur laquelle s’étend la grille |
| drawGrid(x1, x2, y1, y2, color) | Idem, en spécifiant la couleur color de la grille |
| drawGrid(x1, x2, y1, y2, x3, y3) | Idem, en spécifiant les unités utilisées pour la grille avec x3, y3 sur l’axe horizontal, respectivement vertical |
| drawGrid(x1, x2, y1, y2, x3, y3, color) | Idem, en spécifiant la couleur color de la grille |
| drawGrid(p, ...) | Idem que drawGrid() en utilisant le GPanel référencé par la variable p. Utile lors de l’utilisation conjointe de plusieurs panels |
| visible(isVisible) | Affiche / Cache la fenêtre |
| resizeable(isResizeable) | Spécifie si la fenêtre est redimensionnable. Valeur par défaut : non |
| dispose() | Ferme la fenêtre et libère les ressources utilisées pour le dessin |
| isDisposed() | Retourne True si la fenêtre est fermée par le bouton « fermer » de la barre de titre ou suite à l’appel de la fonction dispose() |
| bgColor(color) | Règle la couleur d’arrière-plan. Le paramètre color est une chaîne de couleur X11 ou un objet couleur retourné par le constructeur makeColor() |
| title(text) | Affiche text dans la barre de titre de la fenêtre |
| makeColor(colorStr) | Retourne un objet de type couleur correspondant à la chaine de couleur X11 passée en paramètre |
| windowPosition(ulx, uly) | Règle la position de la fenêtre par rapport aux coordonnées de l’écran (en pixels) |
| windowCenter() | Centre la fenêtre au milieu de l’écran |
| storeGraphis() | Stocke le graphique courant dans une mémoire tampon graphique |
| recallGraphics() | Effectue le rendu du contenu de la mémoire tampon dans le canevas GPanel |
| clearStore(color) | Efface la mémoire tampon graphique en y peignant avec la couleur indiquée |
| delay(time) | Met le programme en pause pour l’intervalle de temps indiqué par time (en ms) |
| getDividingPoint(pt1, pt2, ratio) | Retourne les coordonnées du point qui sépare le segment reliant les points p1 et p2 avec le rapport ratio. Le rapport peut être négatif ou supérieur à 1 |
| getDividingPoint(c1, c2, ratio) | Idem, en utilisant les nombres complexes c1 et c2
|
| clear() | Réinitialise la fenêtre graphique en effaçant son contenu et en replaçant le curseur graphique à l’origine (0, 0) |
| erase() | Efface le contenu de la fenêtre graphique sans réinitialiser la position du curseur graphique |
| putSleep() | Met le programme en pause jusqu’à l’appel ultérieur de la fonction wakeUp() |
| wakeUp() | Remet le programme en route suite à une mise en pause avec putSleep() |
| linfit(X, Y) | Effectue une régression linéaire y = a*x + b sur la base des données contenues dans les listes X et Y et retourne les coefficients de la droite sous la forme du tuple (a, b) |
| addExitListener(onExit) | Enregistre une fonction de rappel onExit() qui est applée à un clique sur fermeture de fenêtre. Pour fermet la fenêtre, appeler dispose() |
| lineWidth(width) | Règle la largeur des lignes (en pixels) |
| setColor(color) | Règle la couleur de dessin à color (chaîne de couleur X11 ou objet de type Color) |
| move(x, y) | Place le curseur graphique à la position (x, y) sans dessiner de ligne |
| move(liste) | Idem, en spécifiant les coordonnées dans la liste coord_list=[x, y] |
| move(c) | Idem, en utilisant le nombre complexe c pour spécifier les coordonnées |
| getPosX() | Retourne la coordonnée x de la position du curseur |
| getPosY() | Retourne la coordonnée y de la position du curseur |
| getPos() | Retourne les coordonnées de la position du curseur sous forme de liste |
| draw(x, y), lineTo(x, y), lineto(x, y) | Dessine une ligne depuis la position actuelle jusqu’au point (x, y) et met à jour la position du curseur avec (x, y) |
| draw(list), lineTo(coord_list), lineto(coord_list) | Idem, en spécifiant les coordonnées dans une liste de la forme [x, y] |
| draw(c), lineTo(c), lineto(c) | Idem, en spécifiant les coordonnées par le nombre complexe c |
| line(x1, y1, x2, y2) | Dessine une ligne de (x1, y1) vers (x2, y2) sans modifier la position actuelle du curseur |
| line(pt1, pt2) | Idem, en spécifiant les coordonnées des points de départ et d’arrivée de la ligne avec les listes pt1 = [x1, y1] et pt2 = [x2, y2] |
| line(c1, c2) | Idem, en spécifiant les coordonnées des points de départ et d’arrivée de la ligne par les nombres complexes c1 et c2 |
| line(li[p0, p1, ..]) | Dessine le trajet partant du point p0 de tous les points de la liste (ou tuple) |
| circle(radius) | Dessine un cercle de rayon radius centré à la position actuelle du curseur graphique |
| fillCircle(radius) | Dessine un disque plein de rayon radius centré à la position actuelle du curseur graphique. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
| ellipse(a, b) | Dessine une ellipse vide d’axes a et b centrée à la position actuelle du curseur graphique |
| fillEllipse(a, b) | Dessine une ellipse pleine d’axes a et b centrée à la position actuelle du curseur graphique. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
| rectangle(a, b) | Dessine un rectangle de côtés a et b centré à la position actuelle du curseur graphique |
| rectangle(x1, y1, x2, y2) | Idem, en spécifiant le point supérieur gauche (x1, y1) et le point inférieur droit (x2, y2) |
| rectangle(pt1, pt2) | Idem, en spécifiant les points de la diagonale par les listes à deux éléments p1 et p2 |
| rectangle(c1, c2) | Idem, en utilisant les nombres complexes c1 et c2 pour spécifier les coordonnées |
| fillRectangle(a, b) | Dessine un rectangle plein de côtés a et b centré à la position actuelle du curseur graphique. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
| fillRrectangle(x1, y1, x2, y2) | Idem, en spécifiant le point supérieur gauche (x1, y1) et le point inférieur droit (x2, y2) |
| fillRectangle(pt1, pt2) | Idem, en spécifiant les points de la diagonale par les listes à deux éléments p1 et p2 |
| fillRrectangle(c1, c2) | Idem, en utilisant les nombres complexes c1 et c2 pour spécifier les coordonnées |
| arc(radius, startAngle, extendAngle) | Dessine un arc de cercle de rayon radius centré à la position du curseur et d’angle au centre extendAngle. startAngle indique l’angle du point de départ par rapport à l’horizontale. Le sens positif est le sens contraire des aiguilles de la montre |
| fillArc(radius, startAngle, extendAngle) | Idem, mais en dessinant un secteur circulaire plein. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
| polygon(x-list, y-list) | Dessine le polygone dont les coordonnées des sommets sont spécifiées par les listes x_list, respectivement y_list |
| polygon((li[pt1, pt2,..) | Idem en spécifiant les sommets dans une liste de points pti représentés par des listes de deux éléments [x,y] |
| polygon(li[c1, c2, c3,...]) | Idem, en utilisant une liste de nombres complexes c1, c2, c3, … pour spécifier les coordonnées des sommets. |
| fillPolygon(x-list, y-list) | Dessine le polygone dont les coordonnées des sommets sont spécifiées par les listes x_list, respectivement y_list. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
| fillPolygon((li[pt1, pt2,..) | Idem en spécifiant les sommets dans une liste de points pti représentés par des listes de deux éléments [x,y] |
| fillPolygon(li[c1, c2, c3,...]) | Idem, en utilisant une liste de nombres complexes c1, c2, c3, … pour spécifier les coordonnées des sommets |
| lowerPath, upperPath, hull = getHull(li[pt1, pt2,...]) | Retourne tuples lowerPath, upperPath et hull de la coque convexe des points pt1, pt2,... |
| quadraticBezier(x1, y1, xc, yc, x1, y2) | Dessiner la courbe de Bézier quadratique définie par les points extrémaux (x1, y1) et (x2, y2) ainsi que le point de contrôle (xc, yc) |
| quadraticBezier(pt1, pc, pt2) | Idem en spécifiant les points avec des listes de deux éléments |
| quadraticBezier(c1, cc, c2) | Idem en spécifiant les points avec des nombres complexes |
| cubicBezier(x1, y1, xc1, yc1, xc2, yc2, x2, y2) | Dessiner la courbe de Bézier cubique définie par les points extrémaux (x1, y1) et (x2, y2) ainsi que les deux points de contrôle (xc1, yc1) et (yc2, yc2) |
| cubicBezier(pt1, ptc1, ptc2, pt2) | Idem en spécifiant les points avec des listes de deux éléments |
| cubicBezier(c1, cc1, cc2, c2) | Idem en spécifiant les points avec des nombres complexes |
| triangle(x1, y1, x2, y2, x3, y3) | Dessine un triangle de sommets (x1, y1), (x2, y2), (x3, y3) |
| triangle(pt1, pt2, pt3) | Idem en spécifiant les sommets avec des listes de deux éléments |
| triangle(c1, c2, c3) | Idem en spécifiant les sommets avec des nombres complexes |
| fillTriangle(x1, y1, x2, y2, x3, y3) | Dessine un triangle plein dont les sommets sont spécifiés par les points (x1, y1), (x2, y2), (x3, y3). La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
| fillTriangle(pt1, pt2, pt3) | Idem en spécifiant les sommets avec des listes de deux éléments |
| fillTriangle(c1, c2, c3) | Idem en spécifiant les sommets avec des nombres complexes |
| point(x, y) | Dessine un point isolé (pixel) à la position (x, y) |
| point(pt) | Idem en spécifiant les coordonnées par une liste de deux éléments |
| point(complex) | Idem en spécifiant les coordonnées par un nombre complexe |
| fill(x, y, color, replacementColor) | Remplit la surface fermée contenant le point (x, y) en remplaçant tous les pixels actuellement de couleur color par un pixel de couleur replacementColor |
| fill(pt, color, replacementColor) | Idem, en spécifiant les coordonnées du point par la liste de deux éléments pt |
| fill(complex, color,replacementColor) | Idem, en spécifiant les coordonnées du point par le nombre complexe complex |
| image(path, x, y) | Insère l’image au format GIF, PNG ou JPEG stockée dans le fichier de chemin path. Place son coin inférieur gauche en (x,y). Le chemin path peut être relatif au dossier TigerJython, être contenu dans le dossier sprites de l’archive JAR de la distribution TigerJython ou être une URL débutant par http:// |
| image(path, pt) | Idem, en spécifiant les coordonnées du coin inférieur gauche par la liste de deux éléments pt |
| image(path, complex) | Idem, en spécifiant les coordonnées du coin inférieur gauche par le nombre complexe complex |
| imageHeighpath) | Retourne la hauteur de l’image présente dans le fichier path (en pixels) |
| imageWidth(path) | Retourne la largeur de l’image présente dans le fichier path (en pixels) |
| enableRepaint(boolean) | Active/désactive le rendu automatique du tampon graphique. Valeur par défaut : True = activé |
| repaint() | Effectue le rendu du tampon graphique à l’écran. Nécessaire si le rendu automatique est désactivé |
| setPaintMode() | Active le mode de dessin standard qui dessine par-dessus l’arrière-plan |
| setXORMode(color) | Active le mode de dessin XOR qui effectue une combinaison XOR entre les pixels de l’arrière-plan et la couleur de dessin color. Deux dessins successifs identiques en mode XOR s’annulent pour redonner la couleur d’arrière-plan initiale |
| getPixelColor(x, y) | Retourne la couleur du pixel situé aux coordonnées (x, y) comme un objet de type Color |
| getPixelColor(x, y).red | Retourne la rouge composante de couleur du pixel situé aux coordonnées (x, y) |
| getPixelColor(x, y).green | Retourne la verte composante de couleur du pixel situé aux coordonnées (x, y) |
| getPixelColor(x, y).blue | Retourne la bleue composante de couleur du pixel situé aux coordonnées (x, y) |
| getPixelColor(pt) | Idem, pour le point dont les coordonnées sont indiquées dans la liste à deux éléments pt |
| getPixelColor(complex) | Idem, pour le point dont les coordonnées sont indiquées par le nombre complexe complex |
| getPixelColorStr(x, y) | Retourne la couleur du pixel situé aux coordonnées (x, y) comme une chaîne de couleur X11 |
| getPixelColorStr(pt) | Idem, pour le point dont les coordonnées sont indiquées dans la liste à deux éléments pt |
| getPixelColorStr(complex) | Idem, pour le point dont les coordonnées sont indiquées par le nombre complexe complex |
| text(string) | Insère le texte contenu dans la chaîne string à partir de la position actuelle du curseur graphique |
| text(x, y, string) | Idem, en écrivant à partir du point de coordonnées (x, y) |
| text(pt, string) | Idem en spécifiant les coordonnées du point de départ par une liste de deux éléments |
| text(complex, string) | Idem en spécifiant les coordonnées du point de départ par un nombre complexe |
| text(x, y, string, font, textColor, bgColor) | Affiche le texte contenu dans string à partir de la position (x, y) en utilisant la police font, la couleur de texte textColor et la couleur d’arrière-fond bgColor |
| text(pt, string, font, textColor, bgColor) | Idem en spécifiant les coordonnées du point de départ par une liste de deux éléments |
| text(complex,string, font, textColor, bgColor) | Idem en spécifiant les coordonnées du point de départ par un nombre complexe |
| font(font) | Sélectionne une autre police pour les appels subséquents à text() |
makeGPanel(mouseNNN = onMouseNNN)
auch mehrere, durch Komma getrennt |
Enregistre une fonction de rappel onMouseNNN(x,y) qui est appelée à chaque fois qu’un événement souris survient. Les valeurs possibles pour NNN sont: Pressed, Released, Clicked, Dragged, Moved, Entered, Exited, SingleClicked, DoubleClicked |
| isLeftMouseButton(), isRightMouseButton() |
Retourne True si le dernier événement souris a été généré par un clique gauche, respectivement droit |
makeGPanel(keyPressed = onKeyPressed) |
Enregistre la fonction de rappel onKeyPressed(keyCode) qui est appelée |
| getKeyModifiers() | Retourne un nombre entier lorsque des touches spéciales du clavier sont enfoncées (Ctrl, Majuscule, Alt). Il est également possible d’obtenir ainsi les combinaisons de touches spéciales, par exemple Ctrl + Maj |
| makeGPanel(closeClicked = onCloseClicked) | Enregistre la fonction de rappel onCloseClicked() qui est appelée lorsque le bouton « fermer » de la barre des tâches est cliqué. On peut fermer la fenêtre à l’aide de l’appel dispose() |
| showSimulationBar(NNN = onNNN) |
shows a dialog window with buttons 'Step', 'Run'/'Pause', 'Reset' and a slider to adjust the simulation period. The following callbacks can be registered: start, pause, step, reset, change(parameter: simulationPeriod), loop, exit (close button hit). loop is invoked in every simulation cycle by the simulation thread |
| showSimulationBar(ulx, uly, initPeriod, NNN = onNNN) | same, but with dialog screen position (upper left corner) and simulation period (default: 100) |
| hideSimulationBar() | closes the dialog and frees all resources |
| getKey() | Retourne, sous forme de chaîne de caractères, le caractère correspondant à la dernière touche du clavier enfoncée |
| getKeyCode() | Retourne le code (nombre entier) de la dernière touche du clavier enfoncée |
| getKeyWait() | Met le programme en pause jusqu’à ce qu’une touche du clavier soit actionnée et retourne le caractère en question sous forme de chaine de caractères
|
| getKeyCodeWait() | Idem, en retournant le code de la dernière touche enfoncée sous forme de nombre entier |
| kbhit() | Retourne True si une touche du clavier a été pressée depuis le dernier appel à getKey() ou getKeyCode() |
| add(component) | Insère un composant GUI vers le bord supérieur de la fenêtre |
| validate() | Redessine la fenêtre (et son contenu) après qu’un composant graphique a été rajouté avec add() |
| addStatusBar(height) | Ajoute au bas de la fenêtre une barre d’état dont la hauteur est donnée par height (en pixels) |
| setStatusText(text) | Affiche le texte text dans la barre d’état. Le texte qui y figurait est supprimé |
| setStatusText(text, font, color) | Idem en indiquant la police et la couleur de texte à utiliser |
| Font(name, style, size) | Crée un nouvel objet de type police de caractères utilisant la police nommée name, dans le style style et la taille de caractères size. Les différents paramètres ainsi que leur type sont décrits dans les trois lignes ci-dessous |
| name | Chaîne de caractères décrivant une police de caractères installée sur le système, comme par exemple "Times New Roman", "Arial" ou "Courier" |
| style | Nombre entier parmi les constantes suivantes: Font.PLAIN, Font.BOLD, Font.ITALIC. Ces constantes peuvent être combinées par addition, comme par exemple: Font.BOLD + Font.ITALIC |
| size | Nombre entier correspondant à une taille disponible pour la police de caractères choisie, par exemple 12, 16, 72 |
| msgDlg(message) | Ouvre une boîte de dialogue modale comportant un bouton OK et le message message |
| msgDlg(message, title = title_text) | Idem, avec une barre de titre comportant le texte title_text |
| inputInt(prompt) |
Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne le nombre entier saisi lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer ». Si aucune valeur n’était présente lors de la validation ou s’il ne s’agissait pas d’un nombre entier, la boîte de dialogue réapparaît |
| inputInt(prompt, False) |
Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
| inputFloat(prompt) | Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne le nombre flottant saisi lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer ». Si aucune valeur n’était présente lors de la validation ou s’il ne s’agissait pas d’un nombre flottant, la boîte de dialogue réapparaît |
| inputFloat(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
| inputString(prompt) | Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne la chaine de caractères saisie lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer » |
| inputString(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
| input(prompt) | Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne le nombre entier, le flottant ou, à défaut, la chaine de caractères saisie lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer » |
| input(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
| askYesNo(prompt) |
Ouvre une boîte de dialogue modale comportant les boutons oui/non. Le bouton « oui » retourne True et le bouton « non » retourne False. Le bouton « annuler » ou « fermer » terminent le programme |
| askYesNo(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
| Function | Action |
| polynomfit(xdata, ydata, n) | fits a polynom of order n and returns the fitted values in ydata. Return value: list with n + 1 polynom coefficients |
| splinefit(xdata, ydata, nbKnots) | fits a spline function that passes through nbKnots aequidistant data points. Returns the fitted data in ydata |
| functionfit(func, derivatives, initialGuess, xdata, ydata) | fits the function func(x, param) with n parameters in list param. derivatives(x, param) returns a list with the values of the partial derivatives to the n parameters. initGuess is a list with n guessed values for the n parameters |
| functionfit(func, derivatives, initialGuess, xdata, ydata, weights) | same but with a list weights that determines the relative weights of the data points |
| toAequidistant(xrawdata, yrawdata, deltax) | returns two lists xdata, ydata with aequidistant values separated by deltax (linear interpolation) |
| server = TCPServer(port, stateChanged, isVerbose = False) | creates a TCP socket server that listens on TCP port for a connecting client. State changes invoke the callback stateChanged(). For isVerbose = True, debug messages are written to the console |
| stateChanged(state, msg) |
Callback called at state change events. |
| server.isConnected() | True, if a client is connected to the server |
| server.disconnect() | closes the connection with the client and enters the the LISTENING state |
| server.terminate() | closes the connection and terminates the LISTENNG state. Releases the IP port |
| server.isTerminated() | True, if the server is in TERMINATED state |
| server.sendMessage(msg) | sends the information msg to the client (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed) |
| TCPServer.getVersion() | returns the module version as string |
| client = TCPClient(ipAddress, port, stateChanged, isVerbose = False) |
creates a TCP socket client prepared for a connection with a TCPServer at given address (string) and port (integer). State changes invoke the callback stateChanged(). For isVerbose = True, debug messages are written to the console |
| stateChanged(state, msg) | Callback called at state change events. state: TCPClient.CONNECTING, msg: IP address of server state: TCPClient.CONNECTION_FAILED, msg: IP address of server state: TCPClient.CONNECTED, msg: IP address of server state: TCPClient.DISCONNECTED, msg: empty state: TCPClient.MESSAGE, msg: message received from server (string) |
| client.connect() | creates a connection to the server (blocking until timeout). Returns True, if the connection is established; otherwise returns False |
| client.connect(timeout) | same, but with timeout (in s) to establish the connection |
| client.isConnecting() | True during a connection trial |
| client.isConnected() | True, if the client is connected to a server |
| client.disconnect() | closes the connection with the server |
| client.sendMessage(msg, responseTime) | sends the information msg to the server (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed). For responseTime > 0 the method blocks and waits for maximum responseTime seconds for a server reply. Returns the message or None, if a timeout occured |
| TCPClient.getVersion() | returns the module version as string |
| server = BTServer(serviceName, stateChanged, isVerbose = False) | creates a Bluetooth server that exposes the RFCOMM service with name serviceName. State changes are notified by the callback stateChanged(). For isVerbose = True, debug messages are written to the output window |
| stateChanged(state, msg) | Callback called at state change events. |
| server.disconnect() | closes the connection with the client and enters the LISTENING state |
| server.isConnected() | True, if a client is connected to the server |
| server.terminate() | closes the connection and terminates the LISTENING state. Releases internal resources |
| server.isTerminated() | True, if the server has been terminated |
| server.sendMessage(msg) | sends the information msg to the client (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed) |
| BTServer.getVersion() | returns the module version as string |
| client = BTClient(stateChanged, isVerbose = False) | creates a Bluetooth client prepared for a connection with a |
| client.findServer(serverName, timeout) | performs a device inquiry for the given server Bluetooth name. Returns the tuple serverInfo: ("nn:nn:nn:nn:nn:nn", channel) , e.g. ("B8:27:EB:04:A6:7E", 1). If the server is not found, None is returned. The search is repeated until the timeout (in s) is reached |
| client.findService(serviceName, timeout) | performs a service inquiry for a Bluetooth server exposing the given RFCOMM service. Returns the tuple serverInfo: ("nn:nn:nn:nn:nn:nn", channel) , e.g. ("B8:27:EB:04:A6:7E", 1). If the service is not found, None is returned. The search is repeated until the timeout (in s) is reached |
| stateChanged(state, msg) | Callback called at state change events. state: "CONNECTING" , msg: server info (MAC address, Bluetooth channel) state: "CONNECTED" , msg: server info state: "CONNECTION_FAILED", msg: sever info state: "DISCONNECTED", msg: empty state: "MESSAGE", msg: message received |
| client.connect(serverInfo, timeout) | Performs a connection trial to the server with given serverInfo. If the connection trial fails, it is repeated until the timeout (in s) is reached. Returns True, if the connection is established; otherwise False is returned. serverInfo is a tuple with the MAC address and channel number ("nn:nn:nn:nn:nn:nn", channel) , e.g. ("B8:27:EB:04:A6:7E", 1) |
| client.isConnecting() | returns True during the connection trial |
| client.isConnected() | returns True, |
| client.disconnect() | beendet 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() | returns the module version as string |
| server = HTTPServer(requestHandler, serverName = "PYSERVER", port = 80, isVerbose = False) | Creates a HTTPServer (Web server, inherited from TCPServer) that listens for a connecting client on given port
(default = 80). Starts a thread that handles and returns HTTP GET requests. requestHandler() is a callback function called when a GET request is received. If stateHandler = None, nothing is done. The function may include longer lasting server actions or a wait time, if sensors are not immediately ready for a new measuremen. |
| getClientIP() | Returns the dotted IP of a connected client. If no client is connected, returns empty string |
| getServerIP() | Returns the server's IP address (static method) |
| (all methods of TCPServer) |
| client = MQTTClient(messageReceived = None, username = "", password = "") | creates a MQTTClient that publishes and/or subcribes MQTT topics. The client does not yet connect to a MQTT broker. |
| client.connect(host, port = 1883, keepalive = 60) | starts a connection trial to the given MQTT broker at given port. host is the broker's IP address and port its IP port where it is listening (default: 1883). |
| client.disconnect() | disconnects the client from the broker |
| client.publish(topic, payload, qos = 0, retain = False) | sends a message with given topic and payload to the broker. payload is a string (if an int or float is given, it is converted to a string). qos is the quality of service level (number 0, 1, 2, default: 0). retain determines, if the message is the “last known good”/retained message for the topic (default: False) |
| client.subscribe(topic, qos = 0) | subscribes the client to one or more topics. topic is a string or a list of tuples of format (topic, qos). qos is the quality of service level (number 0, 1, 2. default: 0); not used, if topic is a list of tuples' |
| client.setVerbose(verbose) | enables/disables logger information printed at stdout |
class GameClient
| client = GameClient(stateChanged, messageReceived, topic = "/ch/aplu/mqtt/gameclient") | creates a GameClient instance to handle game state information and message exchange. |
| client.connect(host, port = 1883) | enganges a connection trial to the MQTT broker with the given IP address and port (default: 1883) |
| client.sendMessage(text) | sends a text information to the partner |
| client.disconnect() | disconnects the client from the broker |
| client.getState() | returns the current state of the GameClient. (One of 'IDLE', 'CONNECTING', 'CONNECTED', 'READY', 'DISCONNECTED' |