Catégorie : Robotique

Bonjour et EMOJI

Ce projet utilise la classe GUI de la bibliothèque UNIHIKER et la fonction draw_emoji() pour générer des emojis émotionnels.

Importe les bibliothèques :

from unihiker import GUI
import time 

Crée cet objet pour gérer les interfaces :

gui = GUI()

Instruction pour dessiner un cercle :

circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

• x et y position du centre du cercle sur l’écran
• r le rayon du cercle
• width et color la largeur et la couleur du dessin du cercle

Documentation draw_circle

Instruction pour créer un emoji

emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50) 

• emoji = type d’emoji
• origin = arrangement de l’emoji par rapport à sa position
• x, y = positionnement de l’emoji sur l’écran
• duration = durée de l’animation
• w = taille de l’emoji

Documentation draw_emoji

Instruction pour l’affichage du text :

Text = gui.draw_text(text='Hello , Patrick !',
                     x=15,y=260,
                     font_size=20)

• text = texte à afficher
• x,y = positionnement du texte à l’écran
• font_size = taille de la police de caractère

Documentation gui.draw_text

from unihiker import GUI
import time 

gui = GUI()

# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

# Création de l'emoji 
emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50) 

# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')

width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
while True:
    # Animation de l'emoji 
    time.sleep(0.3)
    width += delta_width
    radius += delta_radius
    circle.config(r=radius)
    emj.config(w = width) 
    if not (50 <= width <= 240):
        delta_width = -delta_width
        delta_radius = -delta_radius

Si tu veux une progression plus douce (effet oscillation)
Tu peux remplacer l’incrémentation linéaire par une fonction sinus :

from unihiker import GUI
import time, math

gui = GUI()

# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

# Création de l'emoji 
emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50) 

# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')

width = 50
radius = 30
delta_radius = 2.5
delta_width = 5

t = 0
while True:
    time.sleep(0.03)
    radius = 80 + 40 * math.sin(t)
    width = 120 + 60 * math.sin(t)
    circle.config(r=int(radius))
    emj.config(w=int(width))
    t += 0.1

Les différentes possibilité des emoji.

• Angry,
• Nerve,
• Peace,
• Shock,
• Sleep,
• Smile,
• Sweat,
• Think,
• Wink

Changement des EMOJI avec les boutons A ou B

from unihiker import GUI
from pinpong.extension.unihiker import *
import time, math

gui = GUI()

# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

emoji_table = ["Angry", "Nerve", "Peace", "Shock", "Sleep", "Smile", "Sweat", "Think", "Wink"]
index = 0
# Création de l'emoji 
emj = gui.draw_emoji(emoji = emoji_table[index], origin = "center", x=120, y=120, duration = 0.2, w=50) 

# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')

width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
import time, math

t = 0
while True:
    time.sleep(0.03)
    radius = 80 + 40 * math.sin(t)
    width = 120 + 60 * math.sin(t)
    circle.config(r=int(radius))
    emj.config(w=int(width))
    t += 0.1
    # Changement de l'emoji avec le bouton A ou B
    if (button_a.is_pressed()==True):
        index = index + 1 if index < 8 else 0
        emj.config(emoji = emoji_table[index])
    if (button_b.is_pressed()==True):
        index = index - 1 if index > 0 else 8
        emj.config(emoji = emoji_table[index])

Bouton A ou B lumineux

Les boutons A et B de l’UNIHIKER sont accessibles à l’utilisateur, ce qui permet de créer un projet impliquant une LED contrôlée par des boutons. Ce projet vérifie d’abord si les boutons A et B de l’UNIHIKER ont été enfoncés, puis contrôle l’allumage et l’extinction de la LED bleue située à l’arrière de l’UNIHIKER. La bibliothèque PinPong propose deux façons d’utiliser les boutons : la première consiste à lire directement la requête, la seconde à utiliser les rappels d’événements d’interruption. Voici un exemple de contrôle de l’allumage et de l’extinction de la LED à l’aide des boutons A et B.

Utilise ces librairies :

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI

Crée un objet pour les interfaces :

gui=GUI()

Initialise la carte du microcontrôleur :

Board().begin()

Instruction pour dessiner un cercle plein

ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")

Documentation fill_circle

Pour tester l’appui sur les boutons A ou B utilise cette instruction

if (button_a.is_pressed()==True):

Documentation sur la gestion des boutons

Test de l’appui de boutons dans le code :

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI

# Initialisation de l'interface et de la carte
gui=GUI()
Board().begin()

# Initialisation de la LED
ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
led = Pin(Pin.P25, Pin.OUT)

while True:
    # Bouton A appuyé
    if (button_a.is_pressed()==True):
        led.write_digital(1)
        ledUI.config(color="#0000FF")

    # Bouton B appuyé
    if (button_b.is_pressed()==True):
        led.write_digital(0)
        ledUI.config(color="#FF0000")

Fonctions d’interception de l’événement de l’appui sur le bouton A ou B

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI

# Controle de l'appui du bouton A
def on_buttona_click_callback():
    led.write_digital(1)
    ledUI.config(color="#0000FF")

# Controle de l'appui du bouton B
def on_buttonb_click_callback():
    led.write_digital(0)
    ledUI.config(color="#FF0000")

# Initialisation de l'interface et de la carte
gui=GUI()
Board().begin()

ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")

# Eteindre la LED
led = Pin(Pin.P25, Pin.OUT)

# Intercpetion des boutons A et B
gui.on_a_click(on_buttona_click_callback)
gui.on_b_click(on_buttonb_click_callback)


while True:
    pass

LED externe sur le port 22

led = Pin(Pin.P22, Pin.OUT)

Détecteur de luminosité

UNIHIKER est équipé d’un capteur de lumière placé au-dessus de l’écran frontal, permettant de détecter l’intensité lumineuse ambiante. Grâce à cette fonctionnalité, un détecteur de luminosité peut être développé. Ce projet consiste à afficher la valeur lumineuse détectée par le capteur sur l’écran.

Documentation sur le dispositif light sensor

from unihiker import GUI
import time

from pinpong.board import Board 
from pinpong.extension.unihiker import *

# # initialization
Board().begin()

# Instantiate a GUI object
gui = GUI()
img = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
value = gui.draw_text(x=145, y=28, text='0', font_size=18)

while True :
    # Update the displayed light value
    Light = light.read()
    value.config(text = Light)

    # Light value level
    if Light < 600:
        img.config(color="#FF6600")
    elif 600 <= Light < 1024:
        img.config(color="#FF9900")
    elif 1024 <= Light < 2048:
        img.config(color="#FFCC33")
    elif 2048 <= Light < 3072:
        img.config(color="#FFFF99")
    else:
        img.config(color="#FFFF00")

    time.sleep(1)

Dans cet exemple, UNIHIKER est initialisé avec Board().begin(). Ensuite, un objet GUI est instancié et un objet image et un objet texte sont créés à l’aide des méthodes draw_image() et draw_text(), respectivement. Dans la boucle principale, l’intensité lumineuse ambiante est obtenue grâce à la méthode light.read() de la bibliothèque PinPong, et la valeur lumineuse est affichée à l’écran grâce à la méthode draw_text() de la bibliothèque GUI.

L’intensité lumineuse ambiante est divisée en cinq niveaux en moyenne, et différents niveaux de luminosité sont représentés par des cercles de couleurs différentes, selon les conditions d’éclairage.

Piano musical

L’UNIHIKER est équipé d’un buzzer capable d’émettre différentes tonalités en réglant différentes fréquences. Cette fonctionnalité permet de créer un piano électronique. Ce projet propose une interface utilisateur simple permettant aux utilisateurs de jouer différentes notes en appuyant sur des boutons à l’écran. Voici un exemple de piano électronique :

Documentation pour dessiner les touches du clavier

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
import time

# Gestion des touches du piano
def button_click1():
    buzzer.pitch(262,1)
    text.config(text="C4")
def button_click2():
    buzzer.pitch(294,1)
    text.config(text="D4")
def button_click3():
    buzzer.pitch(330,1)
    text.config(text="E4")
def button_click4():
    buzzer.pitch(349,1)
    text.config(text="F4")
def button_click5():
    buzzer.pitch(392,1)
    text.config(text="G4")
def button_click6():
    buzzer.pitch(440,1)
    text.config(text="A4")
def button_click7():
    buzzer.pitch(494,1)
    text.config(text="B4")
def button_click8():
    buzzer.pitch(277,1)
    text.config(text="C#4")
def button_click9():
    buzzer.pitch(311,1)
    text.config(text="D#4")
def button_click10():
    buzzer.pitch(370,1)
    text.config(text="F#4")
def button_click11():
    buzzer.pitch(415,1)
    text.config(text="G#4")
def button_click12():
    buzzer.pitch(466,1)
    text.config(text="A#4")

# Initialisation de l'interface et de la carte
u_gui=GUI()
Board().begin()
# Affichage du titre
bg=u_gui.fill_rect(x=0,y=0,w=240,h=320,color="#CCCCFF")
text = u_gui.draw_text(x=185,y=160,text="Clavier musical",origin="center",font_size=28,angle=270)

# Zones sensibles du clavier musical (touches blanches)
do=u_gui.fill_rect(x=0,y=3,w=130,h=43,color="#FFFFFF",onclick=button_click1)
re=u_gui.fill_rect(x=0,y=48,w=130,h=43,color="#FFFFFF",onclick=button_click2)
mi=u_gui.fill_rect(x=0,y=93,w=130,h=43,color="#FFFFFF",onclick=button_click3)
fa=u_gui.fill_rect(x=0,y=138,w=130,h=43,color="#FFFFFF",onclick=button_click4)
so=u_gui.fill_rect(x=0,y=183,w=130,h=43,color="#FFFFFF",onclick=button_click5)
la=u_gui.fill_rect(x=0,y=228,w=130,h=43,color="#FFFFFF",onclick=button_click6)
xi=u_gui.fill_rect(x=0,y=273,w=130,h=43,color="#FFFFFF",onclick=button_click7)

# Zones sensibles du clavier musical (touches noires)
bian1=u_gui.fill_rect(x=50,y=32,w=80,h=30,color="#000000",onclick=button_click8)
bian2=u_gui.fill_rect(x=50,y=77,w=80,h=30,color="#000000",onclick=button_click9)
bian3=u_gui.fill_rect(x=50,y=167,w=80,h=30,color="#000000",onclick=button_click10)
bian4=u_gui.fill_rect(x=50,y=212,w=80,h=30,color="#000000",onclick=button_click11)
bian5=u_gui.fill_rect(x=50,y=257,w=80,h=30,color="#000000",onclick=button_click12)

while True:
    time.sleep(0.1)

Dans cet exemple, UNIHIKER est initialisé avec Board().begin().

Ensuite, un objet GUI est instancié, sur un fond bleu plusieurs rectangles noirs et blancs (représentant différentes touches de piano) sont créés à l’aide de la fonction fill_rect().

Ensuite, une série de fonctions d’événements sur le click de chaque touche sont définies, chacune correspondant à une note de musique.

Dans les fonctions appelées par un click sur la touche, le buzzer est contrôlé pour émettre un son d’une fréquence et d’une durée spécifiques à l’aide de la fonction buzzer.pitch (frequency, duration).

Chaque note de musique est liée à une touche de piano, et lorsque la touche est enfoncée, la fonction de rappel correspondante est exécutée et le buzzer joue la note correspondante.

De plus, une zone de texte affiche le nom de la note jouée, permettant ainsi à l’utilisateur d’identifier la note jouée.

Sonde sonore

L’UNIHIKER est également équipé d’un microphone capable de capter l’intensité du bruit ambiant. Cette fonctionnalité permet de créer un dispositif de surveillance du bruit, affichant l’intensité du bruit ambiant à l’écran. De plus, un seuil de bruit peut être défini ; lorsqu’il est dépassé, un signal sonore retentit pour vous avertir. Voici un exemple de dispositif de surveillance du bruit :

Documentation sur la sonde sonore

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import Audio
from unihiker import GUI

Board().begin()

# Instantiation des objets audio et interface
audio = Audio()
gui = GUI()
# Titre du dispositif
gui.draw_text(text="Sonde sonore",x=120,y=50,font_size=20, color="#0000FF", origin="center")
# Affichage du niveau sonore
sound_text = gui.draw_text(text="",x=120,y=170,font_size=55, color="#0000FF", origin="center")

while True:
    # Récupération du niveau sonore et son affichage
    sound_value = audio.sound_level()
    sound_text.config(text=sound_value, color="#0000FF")

    # Déctection du niveau sonore
    if (sound_value > 50):
        # Alerte visuelle et sonore
        sound_text.config(color="#FF0000")
        buzzer.pitch(392)
        time.sleep(0.1)
        buzzer.stop()
        # On laisse le niveau sonore retomber avant de le mesurer à nouveau
        time.sleep(1)

Dans cet exemple, l’UNIHIKER est initialisé avec la fonction Board().begin().

Ensuite, un objet Audio et un objet GUI sont instanciés, et deux objets texte sont créés avec la fonction draw_text(). Ces objets texte affichent respectivement la surveillance du bruit et les valeurs de bruit correspondantes.

Dans la boucle principale, la méthode sound_level() de l’objet Audio permet d’obtenir l’intensité sonore ambiante, puis la méthode config() de l’objet texte permet de mettre à jour la valeur de luminosité à l’écran. Parallèlement, l’intensité sonore est vérifiée pour vérifier si elle dépasse le seuil défini. Si tel est le cas, la fonction buzzer.pitch(frequency) émet une alarme sonore, puis la fonction buzzer.stop() désactive le buzzer.

Compteur de sauts

L’UNIHIKER est également équipé d’un accéléromètre et d’un gyroscope 6 axes, capables de lire les valeurs x, y et z de l’accéléromètre et du gyroscope individuellement. Cette fonctionnalité permet de créer un compteur de saut : les valeurs de l’accéléromètre et du gyroscope s’affichent à l’écran, et le nombre de saut est calculé et affiché en fonction de l’intensité de l’accélération.

Documentation sur l’accéléromètre et le gyroscope

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
import time

# Chronomètre du temps du jeu
chrono = 0
# Compteur de sauts
value = 0

# Réinitialisation des compteurs avec le bouton A
def on_buttona_click_callback():
    global chrono
    global value
    chrono = 0
    value = 0

# Initialisation de la carte et de l'interface
Board().begin()
gui = GUI()

# Affichage des données
gui.draw_text(text="Accéléromètre",x=10,y=5,font_size=16, color="#0000FF")
gui.draw_text(text="Gyroscope",x=10,y=105,font_size=16, color="#0000FF")
gui.draw_text(text="Compteur de sauts",x=10,y=210,font_size=16, color="#0000FF")
accelerometer_x = gui.draw_text(text="X：",x=30,y=35,font_size=12, color="#000000")
accelerometer_y = gui.draw_text(text="Y：",x=30,y=60,font_size=12, color="#000000")
accelerometer_z = gui.draw_text(text="Z：",x=30,y=85,font_size=12, color="#000000")
gyroscope_x = gui.draw_text(text="X：",x=30,y=135,font_size=12, color="#000000")
gyroscope_y = gui.draw_text(text="Y：",x=30,y=160,font_size=12, color="#000000")
gyroscope_z = gui.draw_text(text="Z：",x=30,y=185,font_size=12, color="#000000")
pedometer=gui.draw_text(text=value,x=30,y=230,font_size=45, color="#000000")

# Attente appui bouton A pour commmencer
gui.wait_a_click()

# Initialisation pour interception l'appui sur le bouton A
gui.on_a_click(on_buttona_click_callback)

while True:
    # Récupération des mouvements par l'accéléromètre et le gyroscope
    accelerometer_x.config(text=(str("X：") + str(accelerometer.get_x())))
    accelerometer_y.config(text=(str("Y：") + str(accelerometer.get_y())))
    accelerometer_z.config(text=(str("Z：") + str(accelerometer.get_z())))
    gyroscope_x.config(text=(str("X：") + str(gyroscope.get_x())))
    gyroscope_y.config(text=(str("Y：") + str(gyroscope.get_y())))
    gyroscope_z.config(text=(str("Z：") + str(gyroscope.get_z())))

    # Comptage de sauts
    if (accelerometer.get_strength() > 1.5):
        value = (value + 1)
    
    # Affichage des sauts et du chronomètre
    pedometer.config(text=str(value) + "/" + str(int(chrono)))
    time.sleep(0.1)
    chrono +=0.1

Dans cet exemple, l’UNIHIKER est initialisé avec la fonction Board().begin() et un objet GUI est instancié.
Ensuite, grâce à la méthode draw_text(), plusieurs objets texte sont créés pour afficher les valeurs d’accélération, de gyroscope et de nombre de pas, ainsi que leurs valeurs correspondantes.

Le programme principal utilise accelerometer.get_x(), accelerometer.get_y() et accelerometer.get_z() pour obtenir les valeurs x, y et z de l’accélération, et gyroscope.get_x(), gyroscope.get_y() et gyroscope.get_z() pour les valeurs x, y et z du gyroscope. Ces valeurs sont ensuite affichées à l’écran grâce à la méthode config() de l’objet texte.

De plus, le nombre de saut est calculé à l’aide de la fonction accelerometer.get_strength() et incrémenté de 1 lorsque l’intensité d’accélération dépasse 1,5.

Le nombre de sauts est affiché à l’écran avec le chronomètre via la méthode config() de l’objet texte.