from machine import time_pulse_us

# On met pin2 en mode INPUT    
pin2.read_digital()

# time_pulse_us attend que la broche passe à 1 puis
# renvoie la durée en µs pendant laquelle elle reste à 1
duree = time_pulse_us(pin2, 1)

x = pin2.read_analog()
print((x,)) # tuple 1 valeur

from microbit import *
while True:
    if button_a.was_pressed():
        display.show(Image.HAPPY)
    else:
        display.show(Image.SAD)
    sleep(500)

from microbit import *
import radio

radio.on()
radio.config(channel=19)  # Choisir un n° de channel (0-83)
radio.config(power=7)     # Règle la force du signal

message = "Hello NSI !"

# on appuiera sur Bouton A pour arrêter le programme
while not button_a.was_pressed():
    # on appuie sur bouton B pour envoyer le message
    if button_b.was_pressed():
        radio.send(message)
    msg_recu = radio.receive()
    if msg_recu is not None:
        display.show(msg_recu)
        print(msg_recu)
    sleep(500)
radio.off()

msg_recu = None
while msg_recu is None:
    msg_recu = radio.receive()
    sleep(500)

from microbit import *
from machine import time_pulse_us
import utime

################################
## 4-pin : avec ECHO et TRIG ###
################################

### Constantes
TRIG_PIN = pin1
ECHO_PIN = pin2

### Définition d'une fonction
def mesure_distance():
    ### On envoie une impulsion de 10 µs sur la broche TRIG
    ### pour démarrer une salve d'ultrasons
    TRIG_PIN.write_digital(1)
    utime.sleep_us(10) # on attend pendant 10 µs
    TRIG_PIN.write_digital(0)
    # fin de l'impulsion

    ### Lecture du résultat et calcul de la distance
    # configuration de la broche ECHO en mode INPUT
    ECHO_PIN.read_digital()
    # Puis time_pulse_us attend que la broche ECHO passe à 1 puis
    # renvoie la durée en µs pendant laquelle la broche est restée à 1
    duree = time_pulse_us(ECHO_PIN, 1)
    # Calcul la distance en cm
    distance = int(duree * 0.01715)
    return distance


### Programme principal
while True:
    # bouton A pour effectuer et afficher une mesure
    if button_a.was_pressed(): 
        d = mesure_distance()
        # affichage dans la console REPL de l'éditeur
        print(d)
        # affichage sur la carte micro:bit
        display.show(' '+str(d)+" # ", delay=500, loop=True, wait=False)

    # bouton B pour effacer
    if button_b.was_pressed():
        display.clear()

from microbit import *
from machine import time_pulse_us
##################################
## 3-pin : broche SIG sur pin2 ###
##################################
### Définition d'une fonction
def mesure_vitesse(distance):
    """ Calcule la vitesse du son en m/s
    sur une distance 'distance' exprimée en cm """
 
    # envoie une impulsion de 10 ms sur pin2 pour démarrer une salve US #
    pin2.write_digital(1)
    sleep(10)
    pin2.write_digital(0)
    # fin de l'impulsion

    # configuration de pin2 en INPUT
    pin2.read_digital()
    # attend que pin2 passe à 1 puis renvoie la durée 
    # en µs pendant laquelle pin2 reste à 1
    duree = time_pulse_us(pin2, 1)

    # calcul de la vitesse (cm/s) grâce à la duree aller-retour (µs) : 
    vitesse = 2 * distance / (duree/1000000)
    # conversion en m/s (et arrondie)
    vitesse = round(vitesse/100) 
    return vitesse

### Programme principal
# distance utilisée pour mesurer la vitesse du son .. en cm !
DISTANCE = 50 
while True:
    # bouton A pour effectuer une mesure
    if button_a.was_pressed():
        vitesse = mesure_vitesse(DISTANCE)
        # retour REPL dans la console de l'éditeur
        print(vitesse)
        display.show("v="+str(vitesse)+" ", delay=500, loop=True, wait=False)
    
    # bouton B pour effacer
    if button_b.was_pressed():
        display.show(" "+str(vitesse)+" ", delay=500, loop=True, wait=False)

from microbit import *

pin16.set_analog_period(20) # 20 ms est la période PWM d'un servo

# La fourchette 540-2400 sur 20000 du servo est transposée
# en l'intervalle 28-122 sur 1023 de write_analog ainsi :
#  28 =>  547µs => angle minimum (0°) (tourne vers droite) 
#  76 => 1485µs => angle central (90°) 
# 122 => 2385µs => angle maximum (180°) (tourne vers gauche) 

pin16.write_analog(28) # tout à gauche
sleep(1000) # donne le temps au servo de tourner (0.24s pour 60°)
pin16.write_analog(122) # tout à droite
sleep(1000) # donne le temps au servo de tourner
pin16.write_analog(76) # au milieu
sleep(1000) # donne le temps au servo de tourner

pin16.write_digital(0)  # éteint la broche

from microbit import *
class Servo:
    """
    Args:
        pin (pin0 .. pin3): The pin where servo is connected.
        freq (int): The frequency of the signal, in hertz.
        min_us (int): The minimum signal length supported by the servo.
        max_us (int): The maximum signal length supported by the servo.
        angle (int): The angle between minimum and maximum positions.
    Usage :
        sv1 = Servo(pin0)   # ou sv1 = Servo(pin0, min_us=1000, max_us=2000)
        sv1.write_angle(50) # turn servo to 50 degrees 
    """
    def __init__(self, pin, freq=50, min_us=600, max_us=2400, angle=180):
        self.min_us = min_us
        self.max_us = max_us
        self.us = 0
        self.freq = freq
        self.angle = angle
        self.analog_period = 0
        self.pin = pin
        analog_period = round(1000/self.freq)   # hertz to milliseconds
        self.pin.set_analog_period(analog_period)

    def write_us(self, us):
        us = min(self.max_us, max(self.min_us, us))
        duty = round(us * 1024 * self.freq // 1000000)
        self.pin.write_analog(duty)
        sleep(750)
        self.pin.write_digital(0)  # turn the pin off

    def write_angle(self, degrees=None):
        degrees = degrees % 360
        total_range = self.max_us - self.min_us
        us = self.min_us + total_range * degrees // self.angle
        self.write_us(us)

sv = Servo(pin1, min_us=750, max_us=2250)
t = 90
while True:
    if button_a.was_pressed():
        t = t + 5
        sv.write_angle(t)