API de UCUq#

API de la bibliothèque Python UCUq (voir la section dédiée pour l’installation’).

Fonctions#

  • ucuq.sleep(delay) : le microcontrôleur attend <delay> secondes avant d’exécuter la prochaine instruction ;
  • ucuq.sleepStart() : lance un minuteur (à utiliser en conjonction avec sleepWait(…)) ;
  • ucuq.sleepWait(<delay>) : le microcontrôleur attend que <delay> secondes se soient écoulées depuis le lancement du dernier sleepStart() avant d’exécuter l’instruction qui suit.

Classes#

ucuq.GPIO#

Gestion d’une sortie correspondant à une broche du microcontrôleur.

  • ucuq.GPIO(<pin>) (constructeur) : retourne un objet gérant la broche identifiée par <pin> ;
  • GPIO.high() : met la broche à l’état haut ;
  • GPIO.low() : met la broche à l’état bas.

ucuq.WS2812#

Gestion de DELs de type WS2812.

  • ucuq.WS2812(<count>,<pin>) (constructeur) : retourne un objet gérant <count> DELs WS2812 connectées à la broche <pin> ;
  • WS2812.setValue(<index>, <value>) : met dans le tampon la DEL d’index <index> (débutant à 0) à la couleur <value> (une liste ou un tuple au format R,V,B de 0 à 255) ;
  • WS2812.fill(<value>) : met dans le tampon toutes les DELs à la couleur <value> ;
  • WS2812.write() : envoie le contenu du tampon aux DELs.

ucuq.I2C#

Gestion du protocole I2C.

  • ucuq.I2C(<sda>,<scl>) (constructeur) : retourne un objet gérant un composant connecté aux broches du microcontrôleur identifiées par <sda> et <scl> et prenant en charge le protocole I2C.

ucuq.SoftI2C#

Même chose que la classe ucuq.I2C, mais géré par logiciel, <sda> et <scl> pouvant ainsi être n’importe quelle broche GPIO du microcontrôleur.

ucuq.HT16K33#

Gestion d’un composant de type HT16K33.

  • ucuq.HT16K33(<i2c>) (constructeur) : retourne un objet gérant un composant HT16K33 au travers de <i2c>, qui doit être une instance de I2C ou SoftI2C ;
  • HT16K33.setBlinkRate(<rate>) : définit comme <rate> le nombre de fois par seconde que l’affichage clignote (valeurs autorisée : 0, 0.5, 1 et 2) ;
  • HT16K33.setBrightness(<brightness>) : définit <brightness> comme intensité lumineuse de l’afficheur (de 0 et 15) ;
  • HT16K33.clear() : vide le tampon de l’afficheur ;
  • HT16K33.draw(<motif>) : met <motif>, qui doit ête une séquence de caractères hexadécimaux représentant chacun 4 pixels horizontaux, dans le tampon de l’afficheur ;
  • HT16K33.plot(<x>,<y>,<ink>) : allume si <ink> est à 1 ou éteint si <ink> est à 0 le pixel à la position <x>, <y> dans le tampon de l’afficheur ;
  • HT16K33.show() : envoie le contenu du tampon à l’afficheur.

ucuq.PWM#

Gestion d’une sortie de type PWM.

  • ucuq.PWM(<pin>,<freq>,*,ns=<ns>,u16=<u16>) (constructeur) : retourne un objet générant un signal de fréquence <freq> Hz, avec une largeur d’impulsion de <ns> nanosecondes ou d’un ratio de <u16> / 65536, sur une sortie de type PWM identifiée par <pin> (<ns> et <u16> ne peuvent pas être définis simultanément) ;
  • PWM.setU16(<u16>) : génère un signal avec une largeur d’impulsion d’un ratio de <u16> / 65536 ;
  • PWM.setNS(<ns>) : génère un signal avec une largeur d’impulsion de <ns> nanosecondes ;
  • PWM.setFreq(<freq>) : génère un signal d’une fréquence de <freq> Hertz.

ucuq.HD44780_I2C#

Gère un afficheur LCD basé sur le contrôleur HD44780 et contrôlé avec le protocole I2C.

  • ucuq.HD44780_I2C(<columns>,<lines>,<i2c>) (constructeur) : retourne un objet gérant, au travers de <i2c>, qui doit être une instance de I2C ou de SoftI2C, un contrôleur HD44780 connecté à un afficheur LCD de <lines> lignes et <columns> colonnes ;
  • HD44780_I2C.moveTo(x,y) : positionne le curseur à la colonne <x> et la ligne <y> ;
  • HD44780_I2C.putString(<string>) : affiche la chaîne de caractères <string> ;
  • HD44780_I2C.clear() : efface l’afficheur ;
  • HD44780_I2C.hideCursor() : cache le curseur ;
  • HD44780_I2C.showCursor() : affiche le curseur ;
  • HD44780_I2C.blinkCursorOff() : désactive le clignotement du curseur ;
  • HD44780_I2C.blinkCursorOn() : active le clignotement du curseur ;
  • HD44780_I2C.backlightOff() : désactive le rétro-éclairage ;
  • HD44780_I2C.backlightOn() : active le rétro-éclairage ;
  • HD44780_I2C.ttyWrite(<text>, <delay>=.2, <hideCursorOnEnd>=True) : écrit <text>, caractère après caractère, avec un délai de <delay> secondes d’attente entre chaque caractère, et cache le curseur après affichage du dernier caractère si <hideCursorOnEnd> est à True ;
  • HD44780_I2C.createChar(<location>, <charmap>) : définit le caractère personnalisable à la position <location> (entier de 0 à 7) avec <charmap>, qui est un tableau de 8 entiers (un par ligne, de haut en bas) dont les 5 bits de poids faible définissent la couleur du pixel correspondant ;
  • HD44780_I2C.uploadUpwardGaugeChars() : définit les caractères personnalisables de manière à pouvoir afficher une jauge verticale de bas en haut ;
  • HD44780_I2C.putUpwardGauges(<position>, <gauges>) : affiche les jauges verticales <gauges> de bas en haut à la position <position> ; nécessite un appel préalable à HD44780_I2C.uploadUpwardGaugeChars() ;
  • HD44780_I2C.uploadDownwardGaugeChars() : définit les caractères personnalisables de manière à pouvoir afficher une jauge verticale de haut en bas ;
  • HD44780_I2C.putDownwardGauges(<position>, <gauges>) : affiche la liste de jauges verticales <gauges> de haut en bas à la position <position> ;nécessite un appel préalable à HD44780_I2C.uploadDownwardGaugeChars() ;
  • HD44780_I2C.uploadForwardGaugeChars() : définit les caractères personnalisables de manière à pouvoir afficher une jauge horizontale de gauche à droite ;
  • HD44780_I2C.getForwardGauge(<gauge>) : retourne une chaîne de caractères correspondant à une jauge horizontale de gauche à droite de valeur <gauge> ; nécessite un appel préalable à HD44780_I2C.uploadForwardGaugeChars() ;
  • HD44780_I2C.uploadBackwardGaugeChars() : définit les caractères personnalisables de manière à pouvoir afficher une jauge horizontale de droite à gauche ;
  • HD44780_I2C.getBackwardGauge(<gauge>, <max>) : retourne une chaîne de caractères correspondant à une jauge horizontale de droite à gauche de valeur gauge avec max comme valeur maximale ; nécessite un appel préalable à HD44780_I2C.uploadBackwardGaugeChars() ;
  • HD44780_I2C.uploadVPeakChars() : définit les caractères personnalisables de manière à pouvoir afficher un niveau crête verticale ;
  • HD44780_I2C.putUpwardPeaks(<position>, <peaks>) : affiche une liste de niveau de crêtes verticales <peaks> de bas en haut à la position <position> ; nécessite un appel préalable à HD44780_I2C.uploadVPeakChars() ;
  • HD44780_I2C.putDownwardPeaks(<position>, <peaks>) : affiche une liste de niveau de crêtes verticales <peaks> de haut en bas à la position <position> ; nécessite un appel préalable à HD44780_I2C.uploadVPeakChars() ;
  • HD44780_I2C.uploadHPeakChars() : définit les caractères personnalisables de manière à pouvoir afficher un niveau crête horizontal ;
  • HD44780_I2C.getForwardPeak(<peak>, <max>) : retourne une chaîne de caractères correspondant au niveau de crête horizontal <peak> de gauche à droite de valeur maximale <max> ; nécessite un appel préalable à HD44780_I2C.uploadHPeakChars() ;
  • HD44780_I2C.getBackwardPeak(<peak>, <max>) : retourne une chaîne de caractères correspondant au niveau de crête horizontal <peak> de droite à gauche et ayant <max> comme valeur maximale ; nécessite un appel préalable à HD44780_I2C.uploadHPeakChars().

ucuq.SSD1306_I2C#

Gère un écran OLED via le protocole I2C.

  • ucuq.SSD1306_I2C(<width>,<height>,<i2c>) : retourne un objet gérant un afficheur OLED de dimensions <width> par <height> au travers de <i2c>, qui doit être une instance de I2C ou de SoftI2C ;
  • SSD1306_I2C.ellipse(x, y, rx, ry, col, fill=False, quad=15) : trace une ellipse centrée sur <x>, <y>, de rayon <rx>, <ry> et de couleur <col>, remplie si fill est à True, et uniquement les quadrants dont les bits dans <quad> sont à 1 ;
  • SSD1306_I2C.fill(<col>) : remplit le tampon de la couleur <col> ;
  • SSD1306_I2C.line(x1, y1, x2, y2, col) : trace une ligne de couleur <col> de la position <x1>, <y1> à la position <x2>, <y2> ;
  • SSD1306_I2C.pixel(<x>,<y>,<col>) : met le pixel à la position <x>, <y> dans le tampon à la couleur <col> ;
  • SSD1306_I2C.scroll(<dx>,<dy>) : déplace le motif dans le tampon de <dx>, <dy> pixels ;
  • SSD1306_I2C.rect(<x>,<y>,<w>,<h>,fill=<fill> : place un rectangle de largeur <w> et de hauteur <h> à la position <x>, <y> dans le tampon et le remplit si <fill> et à True (valeur par défaut) ;
  • SSD1306_I2C.text(<text>,<x>,<y>) : place la chaîne de caractères <text> dans le tampon à la position <x>, <y> ;
  • SSD1306_I2C.draw(<pattern>, <width>, <ox>=0, <oy>=0, <mul>=1) : place le contenu de <pattern> (chaîne de caractères constituée de chiffres hexadécimaux reflétant chacun la couleur de 4 pixel horizontaux) d’une largeur de width (entier positif multiple de 4) pixels, à la position <ox>, <oy> (entiers positifs) avec un coefficient multiplicateur de <mul> (entier positif).
  • SSD1306_I2C.show() : envoie le contenu du tampon à l’afficheur.

ucuq.SH1106_I2C#

Même chose que ucuq.SSD1306_I2C, mais pour le modèle d’afficheur SH1106.

ucuq.Buzzer#

Gère un buzzer passif.

  • ucuq.Buzzer(pwm) : (constructeur) retourne un objet gèrant un buzzer passif au travers de <pwm>, qui doit être une instance de PWM ;
  • Buzzer.on(freq) : émet un son d’une fréquence de <freq> Hertz ;
  • Buzzer.play(note) : émet un son de la fréquence correspondant à la note MIDI <note> ;
  • Buzzer.off() : coupe le son ;
  • Buzzer.ratio(<ratio>) : (flottant compris entre 0 et 1 inclus) devient le ratio entre le niveau haut et le niveau bas du signal rectangulaire pilotant le buzzer (avec une valeur de 0.5, le signal est carré) ; retourne l’ancien ratio ;
  • Buzzer.ratio() retourne le ration du buzzer.
Backward Installation UCUq Utilisation du simulateur Wokwi - UCUq Forward