Catégories
UNIHIKER

UNIHIKER premiers pas

BONjour emoji
Bouton A ou B lumineux
Détecteur de luminosité
Piano musical
Détecteur de luminosité
compteur de sauts

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.

Catégories
PAGES MEMBRES

Protégé : ADA LOVELACE

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
MICRO PYTHON MICRO:BIT

Bataille navale Micro:bit

🚀 Mission : Détruire les navires ennemis et rester le dernier survivant !

Principe du jeu
exemple en mode bloc
exemple en python

Principe du jeu

Votre objectif ? Couler les navires adverses et être le dernier joueur encore en lice ! Chaque micro:bit représente un champ de bataille : à vous de viser juste.

Comment ça marche ?

  • Un navire caché : Dès que vous allumez votre micro:bit, un navire apparaît aléatoirement sur la grille de LEDs (reconnaissable à sa lumière plus faible).
  • Un missile à guider : La LED la plus brillante, c’est votre missile ! Inclinez votre micro:bit (avant/arrière, gauche/droite) pour le déplacer et viser l’ennemi.
  • Prêt à tirer ?
    • Bouton A : Figez la position de votre missile pour ajuster votre tir.
    • Bouton B : FEU ! Envoyez votre missile vers les adversaires.
  • Touché ! Si votre missile atteint un navire, la micro:bit de la victime joue une musique de défaite… mais attention, elle reviendra en jeu après un délai ! À vous de la neutraliser à nouveau.

💻 À vous de coder ! Pour créer ce jeu, voici les fonctionnalités clés à programmer :

  1. Communication radio : Envoyez et recevez les coordonnées (ligne/colonne) des tirs entre toutes les micro:bits du jeu.
  2. Contrôle du missile : Utilisez l’accéléromètre pour déplacer le missile en inclinant la carte.
  3. Gestion des tirs :
    • Bouton A : Verrouillez la position du missile.
    • Bouton B : Lancez le tir et transmettez les coordonnées aux autres joueurs.
  4. Position aléatoire du navire : À chaque début de partie, le navire apparaît à un endroit aléatoire.
  5. Détection de collision : Si un missile touche un navire, affichez une croix et déclenchez une musique de défaite.
  6. Temps de réapparition : Un navire touché réapparaît après quelques secondes : soyez prêt à recommencer !

💡 Pourquoi c’est génial ?

  • Un jeu multijoueur : Affrontez vos amis en temps réel !
  • De la stratégie : Mémorisez les tirs et neutralisez vos adversaires.
  • Un projet complet : Codez la logique, l’affichage des LEDs, les sons et la communication entre cartes.

🛠️ Prêt à relever le défi ? Avec la micro:bit, vous allez apprendre à : ✔ Utiliser des capteurs (accéléromètre, boutons). ✔ Programmer l’affichage des LEDs et des sons. ✔ Faire communiquer plusieurs cartes entre elles.

À vos micro:bits ! Qui sera le dernier survivant ? 🎮💥

Le champ de bataille :

Ton navire : LED reconnaissable à sa lumière plus faible.

Ton missile : la LED la plus brillante

Déplace ton missile penche à droite/gauche

En avant / en arrière

Bouton A : fige le tir

Bouton B : Lance le missile

Touché

Programme en mode bloc

sous vittascience : https://fr.vittascience.com/microbit

Un exemple de programmation pour émettre les coordonnées x, y du missile et les recevoir :

Pour tester si le bouton B est relâché :

Pour gérer le roulis (droite/gauche) :

Pour gérer le tangage (avant/arrière) :

Pour gérer l’affichage de la position du missile :

Pour gérer l’affichage aléatoire du navire :

Puis dans Répéter indéfiniment :

Si touché :

Pour figer la cible avec le bouton A, avec une variable emettre :

  • emettre = 0 : réglage de la cible
  • emettre = 1 : cible figée

Le bouton A fige la position du tir :

Programme en python

Librairie à importer :

from microbit import *
import radio
import random
import math
import music

Pour configurer la radio :

radio.on()
radio.config(channel = 83, power = 6, length = 32, group=5)

Fonction pour émettre les coordonnées pour correspondre au programme en mode bloc :

def radio_sendValue(name, value):
    radio.send("&&&" + "int:" + "[" + name + ";" + str(value) + "]&&&")

Fonction pour recevoir les coordonnées pour correspondre au programme en mode bloc :

def radio_receiveValue():
    data = radio.receive()

    if data:
        print("receive", data)
        parseData = data[8:-4].split(';')
        return parseData[0], int(parseData[1])
    else:
        return None, None

Pour afficher une image de LEDs :

led_image = Image('00000:00000:00000:00000:00000')
display.show(led_image)

Affichage d’une LED :

 display.set_pixel(x, y, 9)
 display.set_pixel(x_cible, y_cible, 4)

pour générer un nombre aléatoire :

x_cible = random.randint(0, 4)
y_cible = random.randint(0, 4)

Affichage d’une croix :

display.show(Image.NO)

Affichage signe envoyé :

display.show(Image.YES)

Gestion des boutons A et B :

if button_a.is_pressed():
    while not (not button_a.is_pressed()):
        pass

Gestion de l’accéléromètre :

if (
   math.atan2(
       accelerometer.get_x(),
       math.sqrt(accelerometer.get_y()**2 + accelerometer.get_z()**2)
       ) * 180.0 / math.pi > 30
   ):
   x = 4

if (
   math.atan2(
       accelerometer.get_y(), -accelerometer.get_z()) *
       180.0 / math.pi > 30
   ):
   y = 4

Lancement de la musique :

music.play(music.JUMP_DOWN, loop=False)
Catégories
PAGES MEMBRES

Protégé : ZAYD NASIRI

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
PAGES MEMBRES

Protégé : YASSINE BAH

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
PAGES MEMBRES

Protégé : THOMAS LASSERE

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
PAGES MEMBRES

Protégé : THIBAUT COMBES

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
PAGES MEMBRES

Protégé : LEOPOLD ARMAND

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
PAGES MEMBRES

Protégé : AUGUSTIN DAYRES

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Catégories
PAGES MEMBRES

Protégé : ARTHUR RINDEL

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :