utiliser le module radio - UTILISER LES ENTREES/SORTIES DE LA CARTE - ANALOGIQUE ET OU NUMERIQUE
COMMENT ENVOYER UN MESSAGE ENTRE 2 CARTES PAR RADIO ? Message SNT
PROGRAMME :
Comment envoyer le message SNT entre 2 cartes ?
VOIR : send.mp4
VOIR : receive.mp4
Le module radio permet d'envoyer ou de recevoir des message vers ou depuis une ou plusieurs cartes microbit.
La communication se fait sans fil sur une fréquence entre 2,4GHz et 2,5Ghz selon le canal (numéroté entre 0 et 83) choisi.
Les messages ont une taille maxi de 251 caractères. Par défaut, la taille est fixée à 32 caractères.
Pour utiliser la radio, vous devez avoir 2 cartes microbit.
La communication radio est très simple à mettre en oeuvre comme vous pourrez le voir.
Attention cependant, les communications ne sont pas chiffrées, évitez de transmettre des informations sensibles ! !
commencer par importer le module radio
import radio
puis activez la radio qui par défaut est désactivée pour des raisons d'économie d'énergie
radio.on()
La transmission peut alors s'établir entre plusieurs cartes
Pour envoyer un message sous forme d'une chaîne de caractères, utiliser
radio.send(message)
pour recevoir, utiliser
radio.receive()
Programme PYTHON EMETTEUR :
from microbit import *
import radio
radio.on()
while True:
if button_a.was_pressed():
radio.send("SNT")
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
EMETTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
from microbit import *
import radio
radio.on()
while True:
incoming = radio.receive()
if incoming:
display.scroll(incoming)
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
RECEPTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
Comment envoyer le message SNT entre 2 cartes ?
VOIR : send.mp4
VOIR : receive.mp4
Le module radio permet d'envoyer ou de recevoir des message vers ou depuis une ou plusieurs cartes microbit.
La communication se fait sans fil sur une fréquence entre 2,4GHz et 2,5Ghz selon le canal (numéroté entre 0 et 83) choisi.
Les messages ont une taille maxi de 251 caractères. Par défaut, la taille est fixée à 32 caractères.
Pour utiliser la radio, vous devez avoir 2 cartes microbit.
La communication radio est très simple à mettre en oeuvre comme vous pourrez le voir.
Attention cependant, les communications ne sont pas chiffrées, évitez de transmettre des informations sensibles ! !
commencer par importer le module radio
import radio
puis activez la radio qui par défaut est désactivée pour des raisons d'économie d'énergie
radio.on()
La transmission peut alors s'établir entre plusieurs cartes
Pour envoyer un message sous forme d'une chaîne de caractères, utiliser
radio.send(message)
pour recevoir, utiliser
radio.receive()
Programme PYTHON EMETTEUR :
from microbit import *
import radio
radio.on()
while True:
if button_a.was_pressed():
radio.send("SNT")
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
EMETTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
from microbit import *
import radio
radio.on()
while True:
incoming = radio.receive()
if incoming:
display.scroll(incoming)
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
RECEPTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
COMMENT ENVOYER LA TEMPERATURE ENTRE 2 CARTES PAR RADIO ?
PROGRAMME :
Comment envoyer la temperature entre 2 cartes ?
VOIR : temp send.mp4
Configuration de la fréquence :
radio.config(channel=XX)
où XX est un numéro entre 0 et 83. Ce paramètre détermine la fréquence d'émission.
Configuration du groupe :
Au sein d'une même adresse, 256 groupes numérotés de 0 à 255 peuvent cohabiter :
radio.config(group=7)
seules les cartes possédant la même adresse et le même numéro de groupe communiqueront.
Comme vous le voyez, il est tout à fait possible de faire communiquer plusieurs groupes de personnes sans risquer d'interférences.
Programme PYTHON EMETTEUR :
from microbit import *
import radio
radio.on()
radio.config(channel=1)
radio.config(power=7)
while True:
temp = str(temperature())
radio.send(temp)
sleep(1000)
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
EMETTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
from microbit import *
import radio
radio.on()
radio.config(channel=1)
radio.config(power=7)
while True:
message = radio.receive()
if message is not None:
display.scroll(message)
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
RECEPTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
Comment envoyer la temperature entre 2 cartes ?
VOIR : temp send.mp4
Configuration de la fréquence :
radio.config(channel=XX)
où XX est un numéro entre 0 et 83. Ce paramètre détermine la fréquence d'émission.
Configuration du groupe :
Au sein d'une même adresse, 256 groupes numérotés de 0 à 255 peuvent cohabiter :
radio.config(group=7)
seules les cartes possédant la même adresse et le même numéro de groupe communiqueront.
Comme vous le voyez, il est tout à fait possible de faire communiquer plusieurs groupes de personnes sans risquer d'interférences.
Programme PYTHON EMETTEUR :
from microbit import *
import radio
radio.on()
radio.config(channel=1)
radio.config(power=7)
while True:
temp = str(temperature())
radio.send(temp)
sleep(1000)
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
EMETTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
from microbit import *
import radio
radio.on()
radio.config(channel=1)
radio.config(power=7)
while True:
message = radio.receive()
if message is not None:
display.scroll(message)
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
RECEPTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
COMMENT ALLUMER LA MATRICE A LED PAR RADIO ?
Comment allumer la matrice LED par radio ?
VOIR : send a ou b.mp4
Programme PYTHON EMETTEUR :
from microbit import *
import radio
radio.on()
radio.config(group=1)
while True:
if button_a.was_pressed():
radio.send('A')
elif button_b.was_pressed():
radio.send('B')
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
EMETTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
from microbit import *
import radio
radio.on()
radio.config(group=1)
image_on = Image("99999:"
"99999:"
"99999:"
"99999:"
"99999:")
while True:
donnee_recue = radio.receive()
if donnee_recue == 'A':
display.show(image_on)
elif donnee_recue == 'B':
display.clear()
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
RECEPTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
VOIR : send a ou b.mp4
Programme PYTHON EMETTEUR :
from microbit import *
import radio
radio.on()
radio.config(group=1)
while True:
if button_a.was_pressed():
radio.send('A')
elif button_b.was_pressed():
radio.send('B')
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
EMETTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
from microbit import *
import radio
radio.on()
radio.config(group=1)
image_on = Image("99999:"
"99999:"
"99999:"
"99999:"
"99999:")
while True:
donnee_recue = radio.receive()
if donnee_recue == 'A':
display.show(image_on)
elif donnee_recue == 'B':
display.clear()
------------------------------------------------------------
PROGRAMME DANS CREATE WITH CODE :
RECEPTEUR DANS CREATE WITH CODE
LE PROGRAMME MU .py
LE PROGRAMME HEX . hex
COMMENT REALISER UNE ALARME DE PORTE ?
PROGRAMME :
Comment réaliser une alarme de porte ?
VOIR : send alarme.mp4
receive alarme.mp4
Autres fonctions du magnétomètre
La méthode compass.get_field_strength() renvoie la force du champ magnétique. Cela permet de détecter la présence d'un aimant.
Cette force peut être décomposée selon les axes x, y et z : compass.get_x() compass.get_y() et compass.get_z().
compass.get_field_strength()
Programme PYTHON EMETTEUR :
Programme py
from microbit import *
import radio
radio.config(group=17)
compass.calibrate()
radio.on()
while True:
if button_a.was_pressed():
display.scroll(compass.get_field_strength())
if compass.get_field_strength() < 100000:
display.show(Image.DIAMOND_SMALL)
radio.send('OUVERT')
else:
display.clear()
radio.send('FERME')
sleep(2000)
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
Programme py
from microbit import *
import music
import radio
radio.config(group=17)
radio.on()
while True:
message = radio.receive()
if message:
if message == 'OUVERT':
display.show(Image.NO)
music.play(["C4:4"])
if message == 'FERME':
display.show(Image.YES)
Comment réaliser une alarme de porte ?
VOIR : send alarme.mp4
receive alarme.mp4
Autres fonctions du magnétomètre
La méthode compass.get_field_strength() renvoie la force du champ magnétique. Cela permet de détecter la présence d'un aimant.
Cette force peut être décomposée selon les axes x, y et z : compass.get_x() compass.get_y() et compass.get_z().
compass.get_field_strength()
Programme PYTHON EMETTEUR :
Programme py
from microbit import *
import radio
radio.config(group=17)
compass.calibrate()
radio.on()
while True:
if button_a.was_pressed():
display.scroll(compass.get_field_strength())
if compass.get_field_strength() < 100000:
display.show(Image.DIAMOND_SMALL)
radio.send('OUVERT')
else:
display.clear()
radio.send('FERME')
sleep(2000)
------------------------------------------------------------
Programme PYTHON RECEPTEUR :
Programme py
from microbit import *
import music
import radio
radio.config(group=17)
radio.on()
while True:
message = radio.receive()
if message:
if message == 'OUVERT':
display.show(Image.NO)
music.play(["C4:4"])
if message == 'FERME':
display.show(Image.YES)
PILOTER UNE SORTIE NUMERIQUE
PROGRAMME :
Comment piloter les sorties ?
Il y a des bandes de métal sur le côté bas du BBC micro:bit qui lui font des sortes de dents.
Ce sont les pin d’entrée/sortie (ou pin E/S pour faire court)
VOIR : sortie numérique.mp4
Certains de ces pins sont plus gros que d’autres donc il est possible d’y accrocher des pinces crocodiles.
Ce sont numérotés 0, 1, 2, 3V et GND (les ordinateurs comptent toujours à partir de zéro). Si tu branches une carte dédiée à ton micro:bit, il est également possible de relier des câbles aux autres pins (plus petits).
Chaque pin sur le BBC micro:bit est représenté par un objet appelé pinN où N est le numéro du pin.
Donc, par exemple, pour faire quelque chose avec le pin numéroté 0 (zéro), on utilise l’objet appelé pin0.
------------------------------------------------------------
Programme PYTHON :
# Appel de la bibliothèque "microbit"
from microbit import *
# Boucle infinie
while True:
# Feu rouge allumé
pin0.write_digital(1)
# Attendre 2 secondes
sleep(2000)
# Feu rouge éteint
pin0.write_digital(0)
# Attendre 2 secondes
sleep(2000)
Comment piloter les sorties ?
Il y a des bandes de métal sur le côté bas du BBC micro:bit qui lui font des sortes de dents.
Ce sont les pin d’entrée/sortie (ou pin E/S pour faire court)
VOIR : sortie numérique.mp4
Certains de ces pins sont plus gros que d’autres donc il est possible d’y accrocher des pinces crocodiles.
Ce sont numérotés 0, 1, 2, 3V et GND (les ordinateurs comptent toujours à partir de zéro). Si tu branches une carte dédiée à ton micro:bit, il est également possible de relier des câbles aux autres pins (plus petits).
Chaque pin sur le BBC micro:bit est représenté par un objet appelé pinN où N est le numéro du pin.
Donc, par exemple, pour faire quelque chose avec le pin numéroté 0 (zéro), on utilise l’objet appelé pin0.
------------------------------------------------------------
Programme PYTHON :
# Appel de la bibliothèque "microbit"
from microbit import *
# Boucle infinie
while True:
# Feu rouge allumé
pin0.write_digital(1)
# Attendre 2 secondes
sleep(2000)
# Feu rouge éteint
pin0.write_digital(0)
# Attendre 2 secondes
sleep(2000)
EXEMPLE D'UNE BOITE AU LETTRE CONNECTEE
COMMENT REALISER SIMPLEMENT UNE BOITE AUX LETTRES CONNECTEE ? :
ASSOCIER 3 CAPTEURS SUR LE SHIELD MICROBIT :
Les expressions avec un opérateur logique sont évaluées à "True" ou "False".
X or Y : OU logique.
Si X est évalué à True, alors l'expression est True et Y n'est pas évalué.
Sinon, l'expression est évaluée à la valeur booléenne de Y.
X and Y : ET logique.
Si X est évalué à False, alors l'expression est False et Y n'est pas évalué.
Sinon, l'expression est évaluée à la valeur booléenne de Y.
not X : NON logique.
Evalué à la valeur booléenne opposée de X.
------------------------------------------------------------
Programme Emetteur : 3 CAPTEURS NUMERIQUE DANS LA BOITE AUX LETTRES
programme py
programme hex
from microbit import *
import radio
radio.config(group=73)
radio.on()
while True:
if pin0.read_digital() or pin1.read_digital() or pin2.read_digital():
radio.send('courrier')
display.show(Image.STICKFIGURE)
sleep(1000)
else:
radio.send('rien')
display.clear()
------------------------------------------------------------
Programme récepteur : ON AFFICHE UNE IMAGE – ON ALLUME UNE LED ROUGE
programme py
programme hex
from microbit import *
import radio
radio.config(group=73)
radio.on()
while True:
message = radio.receive()
if message:
if message == 'courrier':
display.show(Image.STICKFIGURE)
pin0.write_digital(1)
if message == 'rien':
pin0.write_digital(0)
display.clear()
ASSOCIER 3 CAPTEURS SUR LE SHIELD MICROBIT :
Les expressions avec un opérateur logique sont évaluées à "True" ou "False".
X or Y : OU logique.
Si X est évalué à True, alors l'expression est True et Y n'est pas évalué.
Sinon, l'expression est évaluée à la valeur booléenne de Y.
X and Y : ET logique.
Si X est évalué à False, alors l'expression est False et Y n'est pas évalué.
Sinon, l'expression est évaluée à la valeur booléenne de Y.
not X : NON logique.
Evalué à la valeur booléenne opposée de X.
------------------------------------------------------------
Programme Emetteur : 3 CAPTEURS NUMERIQUE DANS LA BOITE AUX LETTRES
programme py
programme hex
from microbit import *
import radio
radio.config(group=73)
radio.on()
while True:
if pin0.read_digital() or pin1.read_digital() or pin2.read_digital():
radio.send('courrier')
display.show(Image.STICKFIGURE)
sleep(1000)
else:
radio.send('rien')
display.clear()
------------------------------------------------------------
Programme récepteur : ON AFFICHE UNE IMAGE – ON ALLUME UNE LED ROUGE
programme py
programme hex
from microbit import *
import radio
radio.config(group=73)
radio.on()
while True:
message = radio.receive()
if message:
if message == 'courrier':
display.show(Image.STICKFIGURE)
pin0.write_digital(1)
if message == 'rien':
pin0.write_digital(0)
display.clear()
PILOTER UNE ENTREE NUMERIQUE ET UNE SORTIE NUMERIQUE
Programme py
Programme hex
LES VIDEOS EXEMPLES :
Video 1 - ils et LED
Video 2 - infrarouge et buzzer
Video 3 - infrarouge et relais 1
Video 4 - infrarouge et relais 2
Video 5 - poussoir et led
Video 6 - touch et led
PROGRAMME : UN CAPTEUR NUMERIQUE EN ENTREE P0 – UN ACTIONNEUR NUMERIQUE EN SORTIE P2
from microbit import *
while True:
if pin0.read_digital():
pin2.write_digital(1)
sleep(500)
else:
pin2.write_digital(0)
sleep(500)
Les entrées numériques :
Pour configurer la broche 1 en entrée numérique avec résistance de PULL_UP, on utilise les commandes suivantes :
>>> pin1.set_pull(pin1.PULL_UP)
les autres options de PULL sont PULL_DOWN et NO_PULL
On peut ensuite lire la broche en faisant
>>> pin1.read_digital()
qui renvoie 1 si la broche est à l'état haut, ou 0 à l'état bas.
Comment savoir si les broches sont en entrées ou en sortie :
Pour savoir si une broche est configurée en entrée (INPUT) ou en sortie (OUTPUT), on peut taper
>>>pin1.get_mode()
renvoie par exemple 'read_digital' ou 'write_digital'
La configuration des broches en INPUT ou OUTPUT se fait automatiquement selon qu'on fait un read_digital() ou un write_digital().
Par défaut les broches sont configurées en sortie.
Essayez les commandes suivantes dans le REPL :
>>> pin1.get_mode()
'write_digital'
>>> pin1.read_digital()
>>> pin1.get_mode()
'read_digital'
>>> pin1.write_digital(0)
>>> pin1.get_mode()
'write_digital'
Programme hex
LES VIDEOS EXEMPLES :
Video 1 - ils et LED
Video 2 - infrarouge et buzzer
Video 3 - infrarouge et relais 1
Video 4 - infrarouge et relais 2
Video 5 - poussoir et led
Video 6 - touch et led
PROGRAMME : UN CAPTEUR NUMERIQUE EN ENTREE P0 – UN ACTIONNEUR NUMERIQUE EN SORTIE P2
from microbit import *
while True:
if pin0.read_digital():
pin2.write_digital(1)
sleep(500)
else:
pin2.write_digital(0)
sleep(500)
Les entrées numériques :
Pour configurer la broche 1 en entrée numérique avec résistance de PULL_UP, on utilise les commandes suivantes :
>>> pin1.set_pull(pin1.PULL_UP)
les autres options de PULL sont PULL_DOWN et NO_PULL
On peut ensuite lire la broche en faisant
>>> pin1.read_digital()
qui renvoie 1 si la broche est à l'état haut, ou 0 à l'état bas.
Comment savoir si les broches sont en entrées ou en sortie :
Pour savoir si une broche est configurée en entrée (INPUT) ou en sortie (OUTPUT), on peut taper
>>>pin1.get_mode()
renvoie par exemple 'read_digital' ou 'write_digital'
La configuration des broches en INPUT ou OUTPUT se fait automatiquement selon qu'on fait un read_digital() ou un write_digital().
Par défaut les broches sont configurées en sortie.
Essayez les commandes suivantes dans le REPL :
>>> pin1.get_mode()
'write_digital'
>>> pin1.read_digital()
>>> pin1.get_mode()
'read_digital'
>>> pin1.write_digital(0)
>>> pin1.get_mode()
'write_digital'
PILOTER LES SORTIES EN PWM
PROGRAMME 1 :
ALLUMER ET ETEINDRE UNE LED EN P0 AVEC PWM
programme py
programme hex
from microbit import *
while True:
pin0.write_analog(0)
sleep(1000)
pin0.write_analog(1023)
sleep(1000)
PROGRAMME 2 :
ALLUMER UNE LED EN P0 AVEC PWM AVEC 4 SEUILS
programme py
programme hex
from microbit import *
while True:
pin0.write_analog(0)
sleep(1000)
pin0.write_analog(256)
sleep(1000)
pin0.write_analog(512)
sleep(1000)
pin0.write_analog(768)
sleep(1000)
pin0.write_analog(1023)
sleep(1000)
Les sorties Analogiques : Pulse-Width-Modulation (PWM) : Modulation en largeur d'impulsion
En mode « analogique », les broches du Micro:Bit sont capables de prendre 1024 valeurs intermédiaires entre 0 et 3,3 V.
Voilà quelques exemples :
0 correspond à 0 V (0%)
255 correspond à 3,3 / 1024 x 255 = 0,82 V (25%)
511 correspond à 3,3 / 1024 x 511 = 1,65 V (50%)
767 correspond à 3,3 / 1024 x 767 = 2,47 V (75%)
1023 correspond à environ 3,3 V (100%
Les broches ne savent délivrer que 0 ou 3,3V. Si on souhaite diminuer la luminosité d'une LED ou ralentir un moteur commandé par une broche de la microbit il est utile d'avoir recours au PWM afin de définir quel pourcentage de temps la broche sera à l'état haut.
La méthode permettant le PWM est write_analog et s'utilise ainsi :
>>> pin1.write_analog(512)
>>> pin1.get_mode()
'write_analog'
Les valeurs acceptées sont sur 10 bits donc de 0 (toujours à 0) à 1023 (toujours à 1).
L'exemple ci-dessus montre un rapport cyclique de 50% dont haut la moitié du temps sur une période donnée.
ALLUMER ET ETEINDRE UNE LED EN P0 AVEC PWM
programme py
programme hex
from microbit import *
while True:
pin0.write_analog(0)
sleep(1000)
pin0.write_analog(1023)
sleep(1000)
PROGRAMME 2 :
ALLUMER UNE LED EN P0 AVEC PWM AVEC 4 SEUILS
programme py
programme hex
from microbit import *
while True:
pin0.write_analog(0)
sleep(1000)
pin0.write_analog(256)
sleep(1000)
pin0.write_analog(512)
sleep(1000)
pin0.write_analog(768)
sleep(1000)
pin0.write_analog(1023)
sleep(1000)
Les sorties Analogiques : Pulse-Width-Modulation (PWM) : Modulation en largeur d'impulsion
En mode « analogique », les broches du Micro:Bit sont capables de prendre 1024 valeurs intermédiaires entre 0 et 3,3 V.
Voilà quelques exemples :
0 correspond à 0 V (0%)
255 correspond à 3,3 / 1024 x 255 = 0,82 V (25%)
511 correspond à 3,3 / 1024 x 511 = 1,65 V (50%)
767 correspond à 3,3 / 1024 x 767 = 2,47 V (75%)
1023 correspond à environ 3,3 V (100%
Les broches ne savent délivrer que 0 ou 3,3V. Si on souhaite diminuer la luminosité d'une LED ou ralentir un moteur commandé par une broche de la microbit il est utile d'avoir recours au PWM afin de définir quel pourcentage de temps la broche sera à l'état haut.
La méthode permettant le PWM est write_analog et s'utilise ainsi :
>>> pin1.write_analog(512)
>>> pin1.get_mode()
'write_analog'
Les valeurs acceptées sont sur 10 bits donc de 0 (toujours à 0) à 1023 (toujours à 1).
L'exemple ci-dessus montre un rapport cyclique de 50% dont haut la moitié du temps sur une période donnée.
LIRE UNE ENTREE ANALOGIQUE
PROGRAMME LIRE UNE ENTREE ANALOGIQUE :
programme py
programme hex
read_analog()
Read the voltage applied to the pin, and return it as an integer between 0 (meaning 0V) and 1023 (meaning 3.3V).
POTENTIOMETRE GROVE
OU SONORE GROVE
OU LDR GROVE OU TEMPERATURE GROVE
from microbit import *
while True:
val = pin0.read_analog() # Renvoie le niveau analogique sur P0
display.scroll(val) # Affiche la valeur sur la matrice LED
sleep(1000)
programme py
programme hex
read_analog()
Read the voltage applied to the pin, and return it as an integer between 0 (meaning 0V) and 1023 (meaning 3.3V).
POTENTIOMETRE GROVE
OU SONORE GROVE
OU LDR GROVE OU TEMPERATURE GROVE
from microbit import *
while True:
val = pin0.read_analog() # Renvoie le niveau analogique sur P0
display.scroll(val) # Affiche la valeur sur la matrice LED
sleep(1000)
REALISER UN REGULATEUR DE LUMIERE
COMMENT REGULER LA LUMIERE ?
ENTREE P0 – POTENTIOMETRE ET SORTIE ANALOGIQUE PWM LED P2
Les expressions avec un opérateur logique sont évaluées à "True" ou "False".
X and Y : ET logique.
Si X est évalué à False, alors l'expression est False et Y n'est pas évalué.
Sinon, l'expression est évaluée à la valeur booléenne de Y.
------------------------------------------------------------
PROGRAMME : REGULATION DE LUMIERE – continu
Programme py
Programme hex
from microbit import *
while True:
val = pin0.read_analog()
pin2.write_analog(val)
-----------------------------------------------------------
PROGRAMME : REGULATION DE LUMIERE – 5 SEUILS
Programme py
Programme hex
from microbit import *
while True:
val = pin0.read_analog()
if val < 100 and val > 0:
pin2.write_analog(0)
if val < 256 and val > 100:
pin2.write_analog(256)
if val < 512 and val > 256:
pin2.write_analog(512)
if val < 768 and val > 512:
pin2.write_analog(768)
if val < 1024 and val > 768:
pin2.write_analog(1023)
ENTREE P0 – POTENTIOMETRE ET SORTIE ANALOGIQUE PWM LED P2
Les expressions avec un opérateur logique sont évaluées à "True" ou "False".
X and Y : ET logique.
Si X est évalué à False, alors l'expression est False et Y n'est pas évalué.
Sinon, l'expression est évaluée à la valeur booléenne de Y.
------------------------------------------------------------
PROGRAMME : REGULATION DE LUMIERE – continu
Programme py
Programme hex
from microbit import *
while True:
val = pin0.read_analog()
pin2.write_analog(val)
-----------------------------------------------------------
PROGRAMME : REGULATION DE LUMIERE – 5 SEUILS
Programme py
Programme hex
from microbit import *
while True:
val = pin0.read_analog()
if val < 100 and val > 0:
pin2.write_analog(0)
if val < 256 and val > 100:
pin2.write_analog(256)
if val < 512 and val > 256:
pin2.write_analog(512)
if val < 768 and val > 512:
pin2.write_analog(768)
if val < 1024 and val > 768:
pin2.write_analog(1023)
REALISER UN CLAP LUMIERE
COMMENT DECLENCHER LA LUMIERE AVEC UN CLAP DE MAIN ?
CAPTEUR ANALOGIQUE EN P0 – GROVE SON ET ACTIONNEUR NUMERIQUE P2 LED
------------------------------------------------------------
PROGRAMME : NIVEAU SONORE SUR MATRICE LED DE 1 A 10 – AU DESSOUS DE 7 ON ALLUME LA LAMPE LED P2
Programme py
Programme hex
from microbit import *
while True:
val = int(pin0.read_analog() / 100)
display.show(val)
if val < 7:
pin2.write_digital(1)
sleep(2000)
if val > 7:
pin2.write_digital(0)
sleep(2000)
CAPTEUR ANALOGIQUE EN P0 – GROVE SON ET ACTIONNEUR NUMERIQUE P2 LED
------------------------------------------------------------
PROGRAMME : NIVEAU SONORE SUR MATRICE LED DE 1 A 10 – AU DESSOUS DE 7 ON ALLUME LA LAMPE LED P2
Programme py
Programme hex
from microbit import *
while True:
val = int(pin0.read_analog() / 100)
display.show(val)
if val < 7:
pin2.write_digital(1)
sleep(2000)
if val > 7:
pin2.write_digital(0)
sleep(2000)
COMMENT MESURER LE TEMPS ?
Pour mesurer l'écoulement d'un temps :
On utilise la fonction ticks_ms() qui donne le nombre de millisecondes écoulées depuis la mise sous tension
il existe aussi ticks_us() pour un délai en microsecondes.
------------------------------------------------------------
PROGRAMME 1 : TEMPS ECOULE
from microbit import *
from time import ticks_ms # on importe ticks_ms
debut = ticks_ms() # on note l'heure actuelle dans la variable debut
sleep(2000)
fin = ticks_ms()
duree = fin - debut # calcul du temps écoulé en millisecondes
display.scroll(duree) # affichage du temps sur la matrice à LED
------------------------------------------------------------
PROGRAMME 2 : TEMPS ECOULE + REMISE A ZERO AVEC B
from microbit import *
t0 = running_time()
while True:
t1 = running_time()
duree = t1-t0
if button_a.was_pressed():
duree = duree / 1000
display.scroll(int(duree))
if button_b.was_pressed():
t0 = running_time()
t1 = 0
------------------------------------------------------------
Pour faire une pause d’une certaine durée, il n’est parfois pas recommandé d’utiliser la commande sleep.
En effet, sleep empêche l’exécution de toutes les autres directives du programme durant cette pause.
Exemple : sleep(1000)
Il est préférable de déterminer une durée depuis un temps de référence et de tester, à chaque boucle d’itération la durée écoulée.
Pour cela, il faudra utiliser la commande runing_time()
------------------------------------------------------------
PROGRAMME 3 : REALISER UN CHRONOMETRE
BOUTON A – DECLENCEMENT DU CHRONO
BOUTON B – AFFICHAGE DU TEMPS EN SECONDES
BOUTON A ET B – REMISE A ZERO DU CHRONO
from microbit import *
while True:
if button_a.was_pressed():
t0 = running_time()
if button_b.was_pressed():
t1 = running_time()
duree = t1-t0
duree = duree / 1000
display.scroll(int(duree))
if button_a.was_pressed() and button_b.was_pressed():
t0 = running_time()
t1 = 0
On utilise la fonction ticks_ms() qui donne le nombre de millisecondes écoulées depuis la mise sous tension
il existe aussi ticks_us() pour un délai en microsecondes.
------------------------------------------------------------
PROGRAMME 1 : TEMPS ECOULE
from microbit import *
from time import ticks_ms # on importe ticks_ms
debut = ticks_ms() # on note l'heure actuelle dans la variable debut
sleep(2000)
fin = ticks_ms()
duree = fin - debut # calcul du temps écoulé en millisecondes
display.scroll(duree) # affichage du temps sur la matrice à LED
------------------------------------------------------------
PROGRAMME 2 : TEMPS ECOULE + REMISE A ZERO AVEC B
from microbit import *
t0 = running_time()
while True:
t1 = running_time()
duree = t1-t0
if button_a.was_pressed():
duree = duree / 1000
display.scroll(int(duree))
if button_b.was_pressed():
t0 = running_time()
t1 = 0
------------------------------------------------------------
Pour faire une pause d’une certaine durée, il n’est parfois pas recommandé d’utiliser la commande sleep.
En effet, sleep empêche l’exécution de toutes les autres directives du programme durant cette pause.
Exemple : sleep(1000)
Il est préférable de déterminer une durée depuis un temps de référence et de tester, à chaque boucle d’itération la durée écoulée.
Pour cela, il faudra utiliser la commande runing_time()
------------------------------------------------------------
PROGRAMME 3 : REALISER UN CHRONOMETRE
BOUTON A – DECLENCEMENT DU CHRONO
BOUTON B – AFFICHAGE DU TEMPS EN SECONDES
BOUTON A ET B – REMISE A ZERO DU CHRONO
from microbit import *
while True:
if button_a.was_pressed():
t0 = running_time()
if button_b.was_pressed():
t1 = running_time()
duree = t1-t0
duree = duree / 1000
display.scroll(int(duree))
if button_a.was_pressed() and button_b.was_pressed():
t0 = running_time()
t1 = 0