Bêta-test micro:bit v2.5.1 pour 83 Premium CE + drone Tello

[critor]

Depuis des années maintenant, Texas Instruments réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à tous et toutes. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets imaginables sans avoir à se concentrer sur des difficultés annexes.

Nous pouvions déjà citer l'interface TI-Innovator Hub, le robot pilotable TI-Innovator Rover, la grille programmable TI-RGB Array ou encore l'adaptateur TI-SensorLink pour capteurs analogiques Vernier.
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage Python des calculatrices concernées, faisant de l'écosystème Texas Instruments le seul Python connecté !

Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous partagent le même langage de programmation, notamment en SNT, spécialité NSI, SI et Physique-Chimie, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant !

Et depuis la rentrée 2020 dernière grande révolution en date, plus besoin de t'équiper en TI-Innovator pour bénéficier de ces formidables avantages. En effet, la TI-83 Premium CE Edition Python française s'est vu rajouter la gestion du nanoordinateur BBC micro:bit programmable en Python dont tu étais peut-être déjà équipé·e !

La carte micro:bit est initialement un projet lancé par la BBC (British Broadcasting Corporation), le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont ARM, Microsoft et Samsung. Elle fut distribuée gratuitement à un million d'élèves britanniques de 11 et 12 ans.

Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique BBC Micro des années 1980, l'équivalent britannique de par son adoption à nos microordinateurs Thomson MO5 et TO7 inondant écoles, collèges et lycées à la fin de cette décennie dans le cadre du plan IPT (Informatique Pour Tous).

Les cartes micro:bit utilisent un connecteur micro-USB et ta calculatrice un mini-USB.

Pour relier les deux une solution est d'adjoindre un adaptateur mini-USB.

Pour moins d'encombrement, tu as aussi la solution d'utiliser un câble direct, au choix :

• USB micro-B mâle ↔ USB mini-A mâle
• USB micro-B mâle ↔ USB mini-B OTG mâle

La carte micro:bit dans ses versions 1 est programmable en Python et présentait initialement les caractéristiques et capacités suivantes :

• processeur 32 bits ARM Cortex-M0 cadencé à 16 MHz
• mémoire de stockage Flash d'une capacité de 256 Kio
• mémoire de travail RAM d'une capacité de 16 Kio permettant un heap (tas) Python de 10,048 Ko
• un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
• nombre de capteurs intégrés :
  
  • capteur de luminosité (lié aux diodes)
  • capteur de température (sur le processeur)
  • 2 boutons poussoirs

    A

    et

    B

    programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez Nintendo
  • accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
  • boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
• connectivité Bluetooth 4.0 basse énergie 2,4 GHz maître/esclave

Depuis début 2021 est disponible la nouvelle carte micro:bit v2.

Elle utilise un tout nouveau microcontrôleur, le nRF52833, toujours de chez Nordic Semiconductor. Cette fois-ci nous avons des spécifications qui devraient nous permettre de respirer :

• processeur 32 bits ARM Cortex-M0 cadencé à 64 MHz au lieu de 16 MHz soit 4 fois plus rapide !
• mémoire de stockage Flash d'une capacité de 512 Kio au lieu de 256 Kio soit 2 fois plus grande !
• mémoire de travail RAM d'une capacité de 128 Kio au lieu de 16 Kio soit 8 fois plus grande, permettant un heap (tas) Python de 64,512 Ko !

Elle apporte sur cette même face plusieurs nouveautés ou changements :

• ajout d'un haut-parleur
• ajout d'un microphone MEMs
• bouton poussoir qui ne sert plus seulement à la réinitialisation (reset), mais permet désormais également d'éteindre la carte (appui long) et de la rallumer (appui court)
• l'antenne Bluetooth qui devient compatible BLE Bluetooth 5.0, contre seulement 4.0 auparavant

D'autres nouveautés ou changements sont également présents sur l'autre face :

• ajout d'une diode DEL indiquant l'état du microphone
• ajout d'un bouton tactile sur le logo micro:bit, voici pourquoi il perd sa couleur au profit de contacts métalliques

Expliquons brièvement la composition de la solution de connectivité BBC micro:bit de Texas Instruments, ainsi que son fonctionnement.

Le solution se compose d'une part d'un fichier TI-Runtime unique à copier sur la carte micro:bit v1 ou v2 et qui lui permet d'être pilotée par la calculatrice. La bonne installation du fichier est aisément vérifiable, puisque faisant afficher à la carte le logo Texas Instruments.

La solution a un principe de fonctionnement très simple, mais non moins ingénieux pour autant. La carte micro:bit étant justement programmable en Python, une fois le TI-Runtime installé elle se met alors à écouter les commandes Python envoyées depuis la calculatrice et à les exécuter.

Depuis ta calculatrice, tu peux envoyer n'importe quelle commande Python à ta carte micro:bit et profiter pleinement de ses capacités grâce à la fonction ti_hub.send(), à condition d'encadrer la commande des bons caractères de contrôle. Voici une fonction mb_run() en ce sens :

Code: Select all

from ti_hub import *

def mb_run(code):
  send('\x05') # enter paste mode (Ctrl-E)
  send(code)
  send('\x04') # exit paste mode (Ctrl-D)

Pour afficher par exemple Pac-Man, il te suffit d'appeler mb_run("display.show(Image.PACMAN)"), conformément à la documentation du Python micro:bit.

Toutefois en pratique dans le contexte scolaire, cette façon de faire n'était pas idéale. Elle rajoutait un niveau d'imbrication : tu devais produire du code Python qui lui-même devait construire le code Python à envoyer et exécuter par la carte micro:bit, une marche sans doute un peu haute pour bien des élèves débutants.

Et bien justement, Texas Instruments est loin de s'être arrêté là. Sa solution de connectivité comporte également des bibliothèques Python additionnelles à charger sur ta calculatrice, au choix en Français ou Anglais, et rajoutant alors des menus permettant de faire appel plus simplement aux éléments correspondants sur la carte micro:bit. 11 bibliothèques étaient disponibles dans la dernière version, facilitant ainsi l'utilisation de certaines bibliothèques du Python micro:bit :

• microbit (générale, permet d'accéder aux menus des autres bibliothèques)
• mb_audio → microbit.audio (effets sonores - accessible via le menu Audio)
• mb_butns → microbit.buttons (boutons A, B et tactile intégrés - accessible via le menu Buttons ou Boutons)
• mb_disp → microbit.display (afficheur à 5×5=25 LEDs rouges intégré - accessible via le menu Display ou Affichage)
• mb_grove (capteurs et actionneurs Grove à rajouter - accessible via le menu Grove Devices)
• mb_log (enregistrement de données - accessible via le menu Data logging ou Enregistrement de données)
• mb_mic microbit.microphone (micro intégré - accessible via le menu Microphone)
• mb_music → microbit.music (haut-parleur à rajouter sur micro:bit v1 ou intégré sur micro:bit v2 - accessible via le menu Music ou Musique)
• mb_neopx → microbit.neopixel (rubans de LEDs programmables à rajouter - accessible via le menu NeoPixel)
• mb_notes (notes de musique - accessible via le menu Music ou Musique)
• mb_pins (contacts programmables intégrés - accessible via le menu Input/output pins ou Broches entrée/sortie)
• mb_radio → microbit.radio (communication radio intégrée - accessible via le menu Radio)
• mb_sensr (capteurs intégrés : boussole, accéléromètre, température - accessible via le menu Sensors and gestures ou Capteurs et gestes)

Texas Instruments et l'espace, c'est une grande histoire qui ne date pas d'hier. Outre les calculatrices qui ont accompagné les missions spatiales, on peut citer une collaboration de longue date avec la Nasa, l'agence spatiale américaine, et nombre de projets et événements ont été conçus dans ce cadre.

Dès le début du siècle Texas Instruments nous faisait rêver de faire débarquer des rovers sur Mars et les piloter à l'aide de nos calculatrices.

Si nous avons enfin le TI-Innovator Rover pilotable par calculatrice aujourd'hui, fallait-il déjà commencer par décoller avant d'espérer pouvoir un jour atteindre Mars.

Or lors de la dernière mise à jour en fouillant le TI-Runtime 2.4.0, nous avions découvert des traces de fonctions destinées à la configuration d'un drone Tello.

Ces fonctions n'étaient toutefois pas exposées et n'étaient donc a priori pas utilisables depuis la calculatrice.

Et bien voici aujourd'hui le grand jour.

Texas Instruments te fait l'honneur de t'inviter à un bêta-test public de la prochaine mise à jour de sa solution micro:bit pour TI-83 Premium CE Edition Python et compatibles, avec support du drone Tello !

1. Eléments et versions
2. Changements TI-Runtime
3. Nouvelle bibliothèque TELLO et premier script
4. Matériel nécessaire et premiers branchements
5. Lancement et tutoriel de décollage
6. Conclusion et téléchargements

1) Eléments et versions

Go to top

Le pack d'aujourd'hui nous apporte deux éléments:

• D'une part, nous avons une mise à jour en version 2.5.1 du TI-Runtime pour les micro:bit v2. Toutefois en pratique, en interrogeant la carte micro:bit avec microbit.runtime_version() après mise à jour cette dernière continue à rétourner l'ancienne version 2.4.0.
  
  
• D'autre nous avons une nouvelle bibliothèques Python tello, en version 2.5.

Nous allons de suite creuser le nouveau TI-Runtime pour vérifier qu'il n'y a pas eu d'erreur, et ensuite te présenter la bibliothèque TELLO.

2) Changements TI-Runtime

Go to top

Ici pas de menu fouillable depuis la calculatrice pour connaître les fonctions utilisables, mais on peut procéder autrement. On peut en effet ouvrir directement le fichier sur https://python.microbit.org/v/2 pour pouvoir lire son code source :

2.4.0 2.5.1

Code: Select all

from microbit import *
from machine import freq, reset, time_pulse_us
from time import ticks_us, sleep_ms
from utime import sleep_us

# ------------------------------------------- Tello Drone -----------------------------------------------------------

#tello="TELLO-9EF498"
TX_pin = 'pin1' # yellow grove wire
RX_pin = 'pin15' # white grove wire
is_connected = False

def tello_read(cmd,TX=TX_pin,RX=RX_pin):
  try:
    uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
    uart.read()
    udp_len=len(cmd)
    uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n')
    sleep (100)
    uart.read()
    udp = bytes(cmd, 'utf-8')
    uart.write(udp+"\r\n")
    sleep(100)
    timeout = 1
    timer = 0
    while not(uart.any()):
        sleep(1)
        timer += .001
        if timer > timeout:
            status = 'Error: timeout'
            break
    msg = str(uart.read())
    start=msg.find(':')
    end = msg.find('\\r\\n',start)
    msg = msg[start+1:end]
    if msg.find('Non')!=-1:
        msg = '0'
    uart.init(baudrate=115200)
    return(msg)
  except:
    uart.init(baudrate=115200)
    return(False)

def tello_control(cmd,TX=TX_pin,RX=RX_pin):
  try:
    timeout = 10
    uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
    uart.read()
    udp_len=len(cmd)
    uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n')
    sleep(100)
    uart.read()
    udp = bytes(cmd, 'utf-8')
    uart.write(udp)
    timer = 0
    sleep(100)
    while not(uart.any()):
        sleep(1)
        timer += .001
        if timer > timeout:
            status ='Error: timeout'
            break
    msg = str(uart.read())
    if msg.find('SEND OK')==-1:
      uart.init(baudrate=115200)
      return (False)
    sleep(100)
    uart.read()
    timer = 0
    while not(uart.any()):
        sleep(1)
        timer += .001
        if timer > timeout:
            status = 'Error: timeout'
            break
    sleep(100)
    msg = str(uart.read())
    start=msg.find('\\r\\n+IPD')

    if msg.find('ok',start)!=-1:
        status = "ok"
    uart.init(baudrate=115200)
    #print("ok")
    #sleep(100)
    #print("ok")
    #sleep(100)
    return(status)
  except:
    uart.init(baudrate=115200)
    return(False)

def tello_connect(ssid,pswd="",TX=TX_pin,RX=RX_pin):
  #display.show(ti)
  try:
    timeout = 30
    global TX_pin
    global RX_pin
    TX_pin=locals()[TX]
    RX_pin=locals()[RX]
    uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
    #uart.write('AT+CWQAP\r\n')
    uart.write('AT+RST\r\n')
    #uart.write('AT+RESTORE\r\n')
    uart.write('AT+RFPOWER=30\r\n')
    uart.write('AT+CWMODE=3\r\n')
    uart.read()
    #sleep(100)
    the_ap ='AT+CWJAP=' + '"' + ssid +'"' + "," + '"' + pswd +'"\r\n'
    uart.write(the_ap + '\r\n')
    is_connected = False
    timer = 0
    sleep(100)
    while is_connected == False:
      timer = 0
      while not(uart.any()):
        sleep(1)
        timer += .002
        if timer > timeout:
            tello_AT('AT+RST\r\n')
            reset()
      msg = str(uart.read())
      if msg.find("WIFI GOT IP") !=-1:
        is_connected = True
    uart.write('AT+CIFSR\r\n')
    sleep(100)
    timer = 0
    while not(uart.any()):
      sleep(1)
      timer >.002
      if timer == timeout:
          tello_AT('AT+RST')
          reset()
    msg = str(uart.read())
    if msg.find("192.168.10") !=-1:
        status = 'got IP'
    uart.write('AT+CIPMUX=1\r\n')
    sleep(100)
    msg = uart.read()
    uart.write('AT+CIPSTART=0,"UDP","192.168.10.1",8889,8889,2\r\n')
    sleep(100)
    msg = uart.read()
    sleep(100)
    cmd='command'
    udp_len=len(cmd)
    uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n')
    sleep(200)
    uart.read()
    udp = bytes(cmd, 'utf-8')
    uart.write(udp)
    msg = str(uart.read())
    if msg.find('SEND OK')==-1 and status =='got IP':
        status = "Tello Connected"
        display.show(Image.HAPPY)
    else:
        status = "Tello not responding"
        display.show(Image.SAD)
        uart.init(baudrate=115200)
        return (False)
    uart.init(baudrate=115200)
    #print(status)
    return(status)
  except:
    uart.init(baudrate=115200)
    display.show(Image.SAD)
    return(False)

def discover_tello(TX_pin,RX_pin):
  count = 0
  uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
  uart.write('AT+CWLAPOPT=1,2\r\n')
  while count < 15:
    uart.write('AT+CWLAP\r\n')
    while not(uart.any()):
      sleep(10)
    uart.read()     
    sleep(1000)
    msg = str(uart.read())
    start=msg.find('TELLO')
    if start != -1:
      end = msg.find('"',start)
      msg = msg[start:end]
      uart.init(baudrate=115200)
      return(msg)
    else:
      count += 1
  uart.init(baudrate=115200)
  return(False)
 
def write_tello_setup(ssid,tx,rx,number):
  try:
    cfg=open('tello.cfg','w')
    cfg.write(ssid + "@" + tx + "$" + rx + "%" +  number)
    cfg.close()
    return(True)
  except:
    print (False)

def read_tello_setup():
  cfg=open('tello.cfg','r')
  msg = cfg.read()
  d1 = msg.find('@')
  d2 = msg.find('$')
  d3 = msg.find('%')
  ssid = msg[:d1]
  tx = msg[d1+1:d2]
  rx = msg[d2+1:d3]
  number = msg[d3+1:]
  display.show(number)
  return ssid, tx,rx, number
 
# ------------------------------------------- ultrasonic ranger -----------------------------------------------------------

def ranger(pin=pin0,time = True):
  timeout_us=30000     
  pin.write_digital(0)
  sleep_us(2)
  pin.write_digital(1)
  sleep_us(10)
  pin.write_digital(0)
  pin.read_digital()
  duration = time_pulse_us(pin, 1, timeout_us)/1e6 # t_echo in seconds 
  distance = 343 * duration/2 * 100
  if time:
    return duration
  else:
    return distance

# ------------------------------------------- pulse timer ----------------------------------------------------------------
def time_pulses(pin,pulses):
    try:
        pin.read_digital()
        # wait for one trigger pulse
        while not pin.read_digital():
            pass
        while pin.read_digital():
            pass
        while not pin.read_digital():
            pass
        # begin timing pulses
        t0=ticks_us()
        for n in range(pulses-1):
            while (not pin.read_digital()):
                pass
            while pin.read_digital():
                pass
        tf=ticks_us()
        pulses_time = (tf-t0)/1000000
        return(str(pulses_time))
    except:
        pass

def time_H_to_L(pin):
        pin.read_digital()
        while (pin.read_digital()):
            pass
        t0=ticks_us()
        while not (pin.read_digital()):
            pass
        tf=ticks_us()
        pulse_time = (tf-t0)/1000000
        return(str(pulse_time))

def time_L_to_H(pin):
        pin.read_digital()
        while not (pin0.read_digital()):
            pass
        t0=ticks_us()
        while (pin.read_digital()):
            pass
        tf=ticks_us()
        pulse_time = (tf-t0)/1000000
        return(str(pulse_time))
       

# -------------------------------------------BME280 Barometric Pressure -----------------------------------------------------------
class BME280():
  def __init__(self):
    self.ready = False
    self.IDRegister  = 0xD0         
    self.CTRL_HUM    = 0xF2                 
    self.CTRL_MEAS   = 0xF4         
    self.CONFIG      = 0xF5       
    self.t_fine      = 0
    self.dig_T1      = 0
    self.dig_T2      = 0
    self.dig_T3      = 0
    self.dig_P1      = 0   
    self.dig_P2      = 0   
    self.dig_P3      = 0   
    self.dig_P4      = 0   
    self.dig_P5      = 0 
    self.dig_P6      = 0
    self.dig_P7      = 0 
    self.dig_P8      = 0
    self.dig_P9      = 0
    self.dig_H1      = 0                         
    self.dig_H2      = 0
    self.dig_H3      = 0
    self.dig_H4      = 0
    self.dig_H5      = 0
    self.dig_H6      = 0
    self.TRAW      = 0
    self.PRAW      = 0
    self.HRAW      = 0
    self.ConfigurationData           = bytearray(6)
    self.CalData00_25                = bytearray(25)
    self.CalData00_25BaseAddress     = bytearray(1)
    self.CalData00_25BaseAddress[0]  = 0x88
    self.CalData26_41                = bytearray(7)
    self.CalData26_41BaseAddress     = bytearray(1)
    self.CalData26_41BaseAddress[0]  = 0xE1
    self.RawSensorData               = bytearray(8)
    self.RawSensorDataBaseAddress    = bytearray(1)
    self.RawSensorDataBaseAddress[0] = 0xF7
   
  def init(self):
    try:
      IDAddress     = bytearray(1)
      IDAddress[0]  = self.IDRegister
      i2c.write(0x76, IDAddress, repeat = False)
      id = i2c.read(0x76, 1, repeat = False)
      i2c.write(0x76, self.CalData00_25BaseAddress, repeat = False)   
      self.CalData00_25 = i2c.read(0x76, 25, repeat = False)
      i2c.write(0x76, self.CalData26_41BaseAddress, repeat = False)   
      self.CalData26_41 = i2c.read(0x76, 7, repeat = False)
      self.dig_T1 = self.BuildU16(self.CalData00_25[1], self.CalData00_25[0])     
      self.dig_T2 = self.BuildS16(self.CalData00_25[3], self.CalData00_25[2])     
      self.dig_T3 = self.BuildS16(self.CalData00_25[5], self.CalData00_25[4])     
      self.dig_P1 = self.BuildU16(self.CalData00_25[7], self.CalData00_25[6])     
      self.dig_P2 = self.BuildS16(self.CalData00_25[9], self.CalData00_25[8])     
      self.dig_P3 = self.BuildS16(self.CalData00_25[11], self.CalData00_25[10])   
      self.dig_P4 = self.BuildS16(self.CalData00_25[13], self.CalData00_25[12])   
      self.dig_P5 = self.BuildS16(self.CalData00_25[15], self.CalData00_25[14])   
      self.dig_P6 = self.BuildS16(self.CalData00_25[17], self.CalData00_25[16])   
      self.dig_P7 = self.BuildS16(self.CalData00_25[19], self.CalData00_25[18])   
      self.dig_P8 = self.BuildS16(self.CalData00_25[21], self.CalData00_25[20])
      self.dig_P9 = self.BuildS16(self.CalData00_25[23], self.CalData00_25[22])
      self.dig_H1 = self.CalData00_25[24]                           
      self.dig_H2 = self.BuildS16(self.CalData26_41[1],self.CalData26_41[0])
      self.dig_H3 = self.CalData26_41[2]
      self.dig_H4 = (self.BuildS8(self.CalData26_41[3]) << 4) | (self.CalData26_41[4] & 0x0F)
      self.dig_H5 = (self.BuildS8(self.CalData26_41[5]) << 4) | ((self.CalData26_41[4] >> 4) & 0x0F)
      self.dig_H6 = self.BuildS8(self.CalData26_41[6])
      self.ConfigurationData[0] = self.CTRL_HUM       
      self.ConfigurationData[1] = 0b00000101     
      self.ConfigurationData[2] = self.CTRL_MEAS       
      self.ConfigurationData[3] = 0b10110111
      self.ConfigurationData[4] = self.CONFIG     
      self.ConfigurationData[5] = 0b01000000       
      i2c.write(0x76,self.ConfigurationData, repeat=False)
      sleep(100)
      self.ready = True
    except:
      pass

  def BuildS16(self,msb, lsb):
      sval = ((msb << 8) | lsb)
      if sval > 32767: 
          sval -= 65536
      return sval
         
  def BuildU16(self,msb, lsb):
      return ((msb << 8) |lsb)


  def BuildS8(self,b):
      if b > 127:
          return (b-256)
      else:
          return b
         
  def CalculateTemperature(self):   
      self.t_fine
      Traw = float(self.TRAW)
      v1 = (Traw/ 16384.0 - float(self.dig_T1) / 1024.0) * float(self.dig_T2)
      v2 = ((Traw / 131072.0 - float(self.dig_T1) / 8192.0) * (
      Traw / 131072.0 - float(self.dig_T1) / 8192.0)) * float(self.dig_T3)
      self.t_fine = int(v1 + v2)
      T = (v1 + v2) / 5120.0
      return T

  def CalculatePressure(self):
      Praw = float(self.PRAW)
      v1 = float(self.t_fine) / 2.0 - 64000.0
      v2 = v1 * v1 * float(self.dig_P6) / 32768.0
      v2 = v2 + v1 * float(self.dig_P5) * 2.0
      v2 = v2 / 4.0 + float(self.dig_P4) * 65536.0
      v1 = (float(self.dig_P3) * v1 * v1 / 524288.0 + float(self.dig_P2) * v1) / 524288.0
      v1 = (1.0 + v1 / 32768.0) * float(self.dig_P1)
      if v1 == 0:
          return 0
      p  = 1048576.0 - Praw
      p  = ((p - v2 / 4096.0) * 6250.0) / v1
      v1 = float(self.dig_P9) * p * p / 2147483648.0
      v2 = p * float(self.dig_P8) / 32768.0
      p  = p + (v1 + v2 + float(self.dig_P7)) / 16.0
      return p
     
  def CalculateHumidity(self):
      self.t_fine
      Hraw = float(self.HRAW)
      h = float(self.t_fine) - 76800.0
      h = (Hraw - (float(self.dig_H4) * 64.0 + float(self.dig_H5) / 16384.0 * h)) * (
          float(self.dig_H2) / 65536.0 * (1.0 + float(self.dig_H6) / 67108864.0 * h * (
          1.0 + float(self.dig_H3) / 67108864.0 * h)))
      h = h * (1.0 - float(self.dig_H1) * h / 524288.0)
      if h > 100:
          h = 100
      elif h < 0:
          h = 0
      return h

  def read(self):
    if self.ready:
      try:
        i2c.write(0x76, self.RawSensorDataBaseAddress, repeat = False)
        sleep(100)
        self.RawSensorData = i2c.read(0x76, 8, repeat = False)
        sleep(100)
        self.TRAW = ((self.RawSensorData[3] << 16) | (self.RawSensorData[4] << 8) | self.RawSensorData[5]) >> 4
        self.PRAW = ((self.RawSensorData[0] << 16) | (self.RawSensorData[1] << 8) | self.RawSensorData[2]) >> 4
        self.HRAW = (self.RawSensorData[6] << 8)   | self.RawSensorData[7]
        return self.CalculateTemperature(),self.CalculatePressure(),self.CalculateHumidity()
      except:
        pass
    else:
      self.init()
      if self.ready:
        return (self.read())
      else:
       return None
# -------------------------------------------DHT20 Temperature and Humidity -----------------------------------------------------------
       
class DHT20():
  def __init__(self):
    self.ready = False
   
  def init(self):
    try:
      i2c.write(0x38, bytes([0xa8,0x00,0x00]))
      sleep_ms(100)
      i2c.write(0x38, bytes([0xbe,0x08,0x00]))
      sleep(100)
      self.ready = True
    except:
      pass   
   
  def read(self):
    if self.ready:
      try:
        i2c.write(0x38, bytes([0xac,0x33,0x00]))
        sleep(100)
        raw = i2c.read(0x38, 7, True)
        sleep(100)
        data = []
        for i in raw[:]:
          data.append(i)
        temperature = 0
        temperature = (temperature | data[3]) << 8
        temperature = (temperature | data[4]) << 8
        temperature = temperature | data[5]
        temperature = temperature & 0xfffff
        temperature = (temperature * 200 * 10 / 1024 / 1024 - 500)/10
        humidity = 0
        humidity = (humidity | data[1]) << 8
        humidity = (humidity | data[2]) << 8
        humidity = humidity | data[3]
        humidity = humidity >> 4
        humidity = (humidity * 100 * 10 / 1024 / 1024)/10   
        return temperature, humidity
      except:
        pass
    else:
      self.init()
      if self.ready:
        return (self.read())
      else:
       return None


# -------------------------------------------SGP30 VOC and CO2 -----------------------------------------------------------

class SGP30:
  def __init__(self):
    self.ready = False
   
  def init(self):
    try:
      i2c.write(0x58,bytes([0x36, 0x82]))
      self.iaq_init()
      self.ready = True
    except:
      pass 
   
  def TVOC(self):
    return self.iaq_measure()[1]
   
  def baseline_TVOC(self):
    return self.get_iaq_baseline()[1]
   
  def eCO2(self):
    return self.iaq_measure()[0]
   
  def baseline_eCO2(self):
    return self.get_iaq_baseline()[0]
   
  def iaq_init(self):
    self.run(['iaq_init',[0x20,0x03],0,10])
   
  def iaq_measure(self):
    return self.run(['iaq_measure',[0x20,0x08],2,50])
   
  def get_iaq_baseline(self):
    return self.run(['iaq_get_baseline',[0x20,0x15],2,10])
   
  def set_iaq_baseline(self,eCO2,TVOC):
    if eCO2==0 and TVOC==0:raise RuntimeError('Invalid baseline')
    b=[]
    for i in [TVOC,eCO2]:
      a=[i>>8,i&0xFF]
      a.append(self.g_crc(a))
      b+=a
    self.run(['iaq_set_baseline',[0x20,0x1e]+b,0,10])
   
  def set_iaq_humidity(self,PM3):
    b=[]
    for i in [int(PM3*256)]:
      a=[i>>8,i&0xFF]
      a.append(self.g_crc(a))
      b+=a
    self.run(['iaq_set_humidity',[0x20,0x61]+b,0,10])
   
  def run(self,profile):
    n,cmd,s,d=profile
    return self.get(cmd,d,s)
   
  def get(self,cmd,d,rs):
    i2c.write(0x58,bytearray(cmd))
    sleep(d)
    if not rs:return None
    cr=i2c.read(0x58,rs*3)
    o=[]
    for i in range(rs):
      w=[cr[3*i],cr[3*i+1]]
      c=cr[3*i+2]
      if self.g_crc(w)!=c:raise RuntimeError('CRC Error')
      o.append(w[0]<<8|w[1])
    return o
   
  def g_crc(self,data):
    c=0xFF
    for byte in data:
      c^=byte
      for _ in range(8):
        if c&0x80:c=(c<<1)^0x31
        else:c<<=1
    return c&0xFF
 
  def read(self):
    if self.ready:
      try:
        return self.eCO2(), self.TVOC()
      except:
        pass
    else:
      self.init()
      if self.ready:
        return (self.read())
      else:
       return None

# ------------------------------------------- start up -----------------------------------------------------------

def ismb():
  return(True)
 
def get_version():
    print ("TI-Runtime Version 2.4.0")
   
bme280 = BME280()
dht20 = DHT20()
sgp30 = SGP30()
ti = Image("05500:""05595:""55555:""05550:""00500")
display.show(ti)

Code: Select all

from microbit import *
from machine import freq, reset, time_pulse_us
from time import ticks_us, sleep_ms
from utime import sleep_us

tello="TELLO-9EF498"
TX_pin = pin2 # white grove wire
RX_pin = pin1 # yellow grove wire
ssid = "3227 Ridge Road"
pswd="7209909589"

# ------------------------------------------- Tello Drone -----------------------------------------------------------


is_connected = False
 
def tello_read(cmd,TX=TX_pin,RX=RX_pin):
  try:
    uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
    uart.read()
    udp_len=len(cmd)
    uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n')
    sleep (100)
    uart.read()
    udp = bytes(cmd, 'utf-8')
    uart.write(udp+"\r\n")
    sleep(100)
    timeout = 1
    timer = 0
    while not(uart.any()):
        sleep(1)
        timer += .001
        if timer > timeout:
            status = 'Error: timeout'
            break
    msg = str(uart.read())
    start=msg.find(':')
    end = msg.find('\\r\\n',start)
    msg = msg[start+1:end]
    if msg.find('Non')!=-1:
        msg = '0'
    uart.init(baudrate=115200)
    return(msg)
  except:
    uart.init(baudrate=115200)
    return(False)

def tello_control(cmd,TX=TX_pin,RX=RX_pin):
  try:
    timeout = 10
    uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
    uart.read()
    udp_len=len(cmd)
    uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n')
    sleep(100)
    uart.read()
    udp = bytes(cmd, 'utf-8')
    uart.write(udp)
    timer = 0
    sleep(100)
    while not(uart.any()):
        sleep(1)
        timer += .001
        if timer > timeout:
            status ='Error: timeout'
            break
    msg = str(uart.read())
    if msg.find('SEND OK')==-1:
      uart.init(baudrate=115200)
      return (False)
    sleep(100)
    uart.read()
    timer = 0
    while not(uart.any()):
        sleep(1)
        timer += .001
        if timer > timeout:
            status = 'Error: timeout'
            break
    sleep(100)
    msg = str(uart.read())
    start=msg.find('\\r\\n+IPD')

    if msg.find('ok',start)!=-1:
        status = "ok"
    uart.init(baudrate=115200)
    #print("ok")
    #sleep(100)
    #print("ok")
    #sleep(100)
    return(status)
  except:
    uart.init(baudrate=115200)
    return(False)

def tello_connect(ssid,pswd="",TX=TX_pin,RX=RX_pin):
  #display.show(ti)
  # when the configuration is read, global TX and RX should be updated
  try:
    timeout = 30
    global TX_pin
    global RX_pin
    TX_pin=locals()[TX]
    RX_pin=locals()[RX]
    uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
    #uart.write('AT+CWQAP\r\n')
    uart.write('AT+RST\r\n')
    #uart.write('AT+RESTORE\r\n')
    uart.write('AT+RFPOWER=30\r\n')
    uart.write('AT+CWMODE=3\r\n')
    uart.read()
    #sleep(100)
    the_ap ='AT+CWJAP=' + '"' + ssid +'"' + "," + '"' + pswd +'"\r\n'
    uart.write(the_ap + '\r\n')
    is_connected = False
    timer = 0
    sleep(100)
    while is_connected == False:
      timer = 0
      while not(uart.any()):
        sleep(1)
        timer += .002
        if timer > timeout:
            tello_AT('AT+RST\r\n')
            reset()
      msg = str(uart.read())
      if msg.find("WIFI GOT IP") !=-1:
        is_connected = True
    uart.write('AT+CIFSR\r\n')
    sleep(100)
    timer = 0
    while not(uart.any()):
      sleep(1)
      timer >.002
      if timer == timeout:
          tello_AT('AT+RST')
          reset()
    msg = str(uart.read())
    if msg.find("192.168.10") !=-1:
        status = 'got IP'
    uart.write('AT+CIPMUX=1\r\n')
    sleep(100)
    msg = uart.read()
    uart.write('AT+CIPSTART=0,"UDP","192.168.10.1",8889,8889,2\r\n')
    sleep(100)
    msg = uart.read()
    sleep(100)
    cmd='command'
    udp_len=len(cmd)
    uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n')
    sleep(200)
    uart.read()
    udp = bytes(cmd, 'utf-8')
    uart.write(udp)
    msg = str(uart.read())
    if msg.find('SEND OK')==-1 and status =='got IP':
        status = "Tello Connected"
        display.show(Image.YES)
    else:
        status = "Tello not responding"
        display.show(Image.NO)
        uart.init(baudrate=115200)
        return (False)
    uart.init(baudrate=115200)
    #print(status)
    return(status)
  except:
    uart.init(baudrate=115200)
    display.show(Image.NO)
    return(False)

def discover_tello(TX_pin,RX_pin):
  count = 0
  uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin)
  uart.write('AT+CWLAPOPT=1,2\r\n')
  while count < 30:
    uart.write('AT+CWLAP\r\n')
    while not(uart.any()):
      sleep(10)
    uart.read()     
    sleep(1000)
    msg = str(uart.read())
    start=msg.find('TELLO')
    if start != -1:
      end = msg.find('"',start)
      msg = msg[start:end]
      uart.init(baudrate=115200)
      return(msg)
    else:
      count += 1
  uart.init(baudrate=115200)
  return(False)
 
def write_tello_setup(ssid,tx,rx,number):
  try:
    cfg=open('tello.cfg','w')
    cfg.write(ssid + "@" + tx + "$" + rx + "%" +  number)
    cfg.close()
    return(True)
  except:
    print (False)

def read_tello_setup():
  try:
    cfg=open('tello.cfg','r')
    msg = cfg.read()
    d1 = msg.find('@')
    d2 = msg.find('$')
    d3 = msg.find('%')
    ssid = msg[:d1]
    tx = msg[d1+1:d2]
    rx = msg[d2+1:d3]
    number = msg[d3+1:]
    display.show(number)
    return ssid, tx,rx, number
  except:
    return False


# ------------------------------------------- ultrasonic ranger -----------------------------------------------------------

def ranger(pin=pin0,time = True):
  timeout_us=30000     
  pin.write_digital(0)
  sleep_us(2)
  pin.write_digital(1)
  sleep_us(10)
  pin.write_digital(0)
  pin.read_digital()
  duration = time_pulse_us(pin, 1, timeout_us)/1e6 # t_echo in seconds 
  distance = 343 * duration/2 * 100
  if time:
    return duration
  else:
    return distance

# ------------------------------------------- pulse timer ----------------------------------------------------------------
def time_pulses(pin,pulses):
    try:
        pin.read_digital()
        # wait for one trigger pulse
        while not pin.read_digital():
            pass
        while pin.read_digital():
            pass
        while not pin.read_digital():
            pass
        # begin timing pulses
        t0=ticks_us()
        for n in range(pulses-1):
            while (not pin.read_digital()):
                pass
            while pin.read_digital():
                pass
        tf=ticks_us()
        pulses_time = (tf-t0)/1000000
        return(str(pulses_time))
    except:
        pass

def time_H_to_L(pin):
        pin.read_digital()
        while (pin.read_digital()):
            pass
        t0=ticks_us()
        while not (pin.read_digital()):
            pass
        tf=ticks_us()
        pulse_time = (tf-t0)/1000000
        return(str(pulse_time))

def time_L_to_H(pin):
        pin.read_digital()
        while not (pin0.read_digital()):
            pass
        t0=ticks_us()
        while (pin.read_digital()):
            pass
        tf=ticks_us()
        pulse_time = (tf-t0)/1000000
        return(str(pulse_time))
       

# -------------------------------------------BME280 Barometric Pressure -----------------------------------------------------------
class BME280():
  def __init__(self):
    self.ready = False
    self.IDRegister  = 0xD0         
    self.CTRL_HUM    = 0xF2                 
    self.CTRL_MEAS   = 0xF4         
    self.CONFIG      = 0xF5       
    self.t_fine      = 0
    self.dig_T1      = 0
    self.dig_T2      = 0
    self.dig_T3      = 0
    self.dig_P1      = 0   
    self.dig_P2      = 0   
    self.dig_P3      = 0   
    self.dig_P4      = 0   
    self.dig_P5      = 0 
    self.dig_P6      = 0
    self.dig_P7      = 0 
    self.dig_P8      = 0
    self.dig_P9      = 0
    self.dig_H1      = 0                         
    self.dig_H2      = 0
    self.dig_H3      = 0
    self.dig_H4      = 0
    self.dig_H5      = 0
    self.dig_H6      = 0
    self.TRAW      = 0
    self.PRAW      = 0
    self.HRAW      = 0
    self.ConfigurationData           = bytearray(6)
    self.CalData00_25                = bytearray(25)
    self.CalData00_25BaseAddress     = bytearray(1)
    self.CalData00_25BaseAddress[0]  = 0x88
    self.CalData26_41                = bytearray(7)
    self.CalData26_41BaseAddress     = bytearray(1)
    self.CalData26_41BaseAddress[0]  = 0xE1
    self.RawSensorData               = bytearray(8)
    self.RawSensorDataBaseAddress    = bytearray(1)
    self.RawSensorDataBaseAddress[0] = 0xF7
   
  def init(self):
    try:
      IDAddress     = bytearray(1)
      IDAddress[0]  = self.IDRegister
      i2c.write(0x76, IDAddress, repeat = False)
      id = i2c.read(0x76, 1, repeat = False)
      i2c.write(0x76, self.CalData00_25BaseAddress, repeat = False)   
      self.CalData00_25 = i2c.read(0x76, 25, repeat = False)
      i2c.write(0x76, self.CalData26_41BaseAddress, repeat = False)   
      self.CalData26_41 = i2c.read(0x76, 7, repeat = False)
      self.dig_T1 = self.BuildU16(self.CalData00_25[1], self.CalData00_25[0])     
      self.dig_T2 = self.BuildS16(self.CalData00_25[3], self.CalData00_25[2])     
      self.dig_T3 = self.BuildS16(self.CalData00_25[5], self.CalData00_25[4])     
      self.dig_P1 = self.BuildU16(self.CalData00_25[7], self.CalData00_25[6])     
      self.dig_P2 = self.BuildS16(self.CalData00_25[9], self.CalData00_25[8])     
      self.dig_P3 = self.BuildS16(self.CalData00_25[11], self.CalData00_25[10])   
      self.dig_P4 = self.BuildS16(self.CalData00_25[13], self.CalData00_25[12])   
      self.dig_P5 = self.BuildS16(self.CalData00_25[15], self.CalData00_25[14])   
      self.dig_P6 = self.BuildS16(self.CalData00_25[17], self.CalData00_25[16])   
      self.dig_P7 = self.BuildS16(self.CalData00_25[19], self.CalData00_25[18])   
      self.dig_P8 = self.BuildS16(self.CalData00_25[21], self.CalData00_25[20])
      self.dig_P9 = self.BuildS16(self.CalData00_25[23], self.CalData00_25[22])
      self.dig_H1 = self.CalData00_25[24]                           
      self.dig_H2 = self.BuildS16(self.CalData26_41[1],self.CalData26_41[0])
      self.dig_H3 = self.CalData26_41[2]
      self.dig_H4 = (self.BuildS8(self.CalData26_41[3]) << 4) | (self.CalData26_41[4] & 0x0F)
      self.dig_H5 = (self.BuildS8(self.CalData26_41[5]) << 4) | ((self.CalData26_41[4] >> 4) & 0x0F)
      self.dig_H6 = self.BuildS8(self.CalData26_41[6])
      self.ConfigurationData[0] = self.CTRL_HUM       
      self.ConfigurationData[1] = 0b00000101     
      self.ConfigurationData[2] = self.CTRL_MEAS       
      self.ConfigurationData[3] = 0b10110111
      self.ConfigurationData[4] = self.CONFIG     
      self.ConfigurationData[5] = 0b01000000       
      i2c.write(0x76,self.ConfigurationData, repeat=False)
      sleep(100)
      self.ready = True
    except:
      pass

  def BuildS16(self,msb, lsb):
      sval = ((msb << 8) | lsb)
      if sval > 32767: 
          sval -= 65536
      return sval
         
  def BuildU16(self,msb, lsb):
      return ((msb << 8) |lsb)


  def BuildS8(self,b):
      if b > 127:
          return (b-256)
      else:
          return b
         
  def CalculateTemperature(self):   
      self.t_fine
      Traw = float(self.TRAW)
      v1 = (Traw/ 16384.0 - float(self.dig_T1) / 1024.0) * float(self.dig_T2)
      v2 = ((Traw / 131072.0 - float(self.dig_T1) / 8192.0) * (
      Traw / 131072.0 - float(self.dig_T1) / 8192.0)) * float(self.dig_T3)
      self.t_fine = int(v1 + v2)
      T = (v1 + v2) / 5120.0
      return T

  def CalculatePressure(self):
      Praw = float(self.PRAW)
      v1 = float(self.t_fine) / 2.0 - 64000.0
      v2 = v1 * v1 * float(self.dig_P6) / 32768.0
      v2 = v2 + v1 * float(self.dig_P5) * 2.0
      v2 = v2 / 4.0 + float(self.dig_P4) * 65536.0
      v1 = (float(self.dig_P3) * v1 * v1 / 524288.0 + float(self.dig_P2) * v1) / 524288.0
      v1 = (1.0 + v1 / 32768.0) * float(self.dig_P1)
      if v1 == 0:
          return 0
      p  = 1048576.0 - Praw
      p  = ((p - v2 / 4096.0) * 6250.0) / v1
      v1 = float(self.dig_P9) * p * p / 2147483648.0
      v2 = p * float(self.dig_P8) / 32768.0
      p  = p + (v1 + v2 + float(self.dig_P7)) / 16.0
      return p
     
  def CalculateHumidity(self):
      self.t_fine
      Hraw = float(self.HRAW)
      h = float(self.t_fine) - 76800.0
      h = (Hraw - (float(self.dig_H4) * 64.0 + float(self.dig_H5) / 16384.0 * h)) * (
          float(self.dig_H2) / 65536.0 * (1.0 + float(self.dig_H6) / 67108864.0 * h * (
          1.0 + float(self.dig_H3) / 67108864.0 * h)))
      h = h * (1.0 - float(self.dig_H1) * h / 524288.0)
      if h > 100:
          h = 100
      elif h < 0:
          h = 0
      return h

  def read(self):
    if self.ready:
      try:
        i2c.write(0x76, self.RawSensorDataBaseAddress, repeat = False)
        sleep(100)
        self.RawSensorData = i2c.read(0x76, 8, repeat = False)
        sleep(100)
        self.TRAW = ((self.RawSensorData[3] << 16) | (self.RawSensorData[4] << 8) | self.RawSensorData[5]) >> 4
        self.PRAW = ((self.RawSensorData[0] << 16) | (self.RawSensorData[1] << 8) | self.RawSensorData[2]) >> 4
        self.HRAW = (self.RawSensorData[6] << 8)   | self.RawSensorData[7]
        return self.CalculateTemperature(),self.CalculatePressure(),self.CalculateHumidity()
      except:
        pass
    else:
      self.init()
      if self.ready:
        return (self.read())
      else:
       return None
# -------------------------------------------DHT20 Temperature and Humidity -----------------------------------------------------------
       
class DHT20():
  def __init__(self):
    self.ready = False
   
  def init(self):
    try:
      i2c.write(0x38, bytes([0xa8,0x00,0x00]))
      sleep_ms(100)
      i2c.write(0x38, bytes([0xbe,0x08,0x00]))
      sleep(100)
      self.ready = True
    except:
      pass   
   
  def read(self):
    if self.ready:
      try:
        i2c.write(0x38, bytes([0xac,0x33,0x00]))
        sleep(100)
        raw = i2c.read(0x38, 7, True)
        sleep(100)
        data = []
        for i in raw[:]:
          data.append(i)
        temperature = 0
        temperature = (temperature | data[3]) << 8
        temperature = (temperature | data[4]) << 8
        temperature = temperature | data[5]
        temperature = temperature & 0xfffff
        temperature = (temperature * 200 * 10 / 1024 / 1024 - 500)/10
        humidity = 0
        humidity = (humidity | data[1]) << 8
        humidity = (humidity | data[2]) << 8
        humidity = humidity | data[3]
        humidity = humidity >> 4
        humidity = (humidity * 100 * 10 / 1024 / 1024)/10   
        return temperature, humidity
      except:
        pass
    else:
      self.init()
      if self.ready:
        return (self.read())
      else:
       return None


# -------------------------------------------SGP30 VOC and CO2 -----------------------------------------------------------

class SGP30:
  def __init__(self):
    self.ready = False
   
  def init(self):
    try:
      i2c.write(0x58,bytes([0x36, 0x82]))
      self.iaq_init()
      self.ready = True
    except:
      pass 
   
  def TVOC(self):
    return self.iaq_measure()[1]
   
  def eCO2(self):
    return self.iaq_measure()[0]   

  def iaq_init(self):
    self.run(['iaq_init',[0x20,0x03],0,10])

  def iaq_measure(self):
    return self.run(['iaq_measure',[0x20,0x08],2,50])
     
  def baseline_TVOC(self):
    return self.get_iaq_baseline()[1]
       
  def baseline_eCO2(self):
    return self.get_iaq_baseline()[0]
   
  def get_iaq_baseline(self):
    return self.run(['iaq_get_baseline',[0x20,0x15],2,10])
   
  def set_iaq_baseline(self,eCO2,TVOC):
    if eCO2==0 and TVOC==0:raise RuntimeError('Invalid baseline')
    b=[]
    for i in [TVOC,eCO2]:
      a=[i>>8,i&0xFF]
      a.append(self.g_crc(a))
      b+=a
    self.run(['iaq_set_baseline',[0x20,0x1e]+b,0,10])
   
  def set_iaq_humidity(self,PM3):
    b=[]
    for i in [int(PM3*256)]:
      a=[i>>8,i&0xFF]
      a.append(self.g_crc(a))
      b+=a
    self.run(['iaq_set_humidity',[0x20,0x61]+b,0,10])

   
  def run(self,profile):
    n,cmd,s,d=profile
    return self.get(cmd,d,s)

 
  def get(self,cmd,d,rs):
    i2c.write(0x58,bytearray(cmd))
    sleep(d)
    if not rs:return None
    cr=i2c.read(0x58,rs*3)
    o=[]
    for i in range(rs):
      w=[cr[3*i],cr[3*i+1]]
      c=cr[3*i+2]
      if self.g_crc(w)!=c:raise RuntimeError('CRC Error')
      o.append(w[0]<<8|w[1])
    return o
   
  def g_crc(self,data):
    c=0xFF
    for byte in data:
      c^=byte
      for _ in range(8):
        if c&0x80:c=(c<<1)^0x31
        else:c<<=1
    return c&0xFF

 
  def read(self):
    if self.ready:
      try:
        return self.eCO2(), self.TVOC()
      except:
        pass
    else:
      self.init()
      if self.ready:
        return (self.read())
      else:
       return None


# ------------------------------------------- start up -----------------------------------------------------------

def ismb():
  return(True)
 
def get_version():
    print ("TI-Runtime Version 2.4.0")
   
bme280 = BME280()
dht20 = DHT20()
sgp30 = SGP30()
ti = Image("05500:""05595:""55555:""05550:""00500")
display.show(ti)

L'on constate en effet que la quasi totalité des changements concernent le support du drone Tello.

3) Nouvelle bibliothèque TELLO et premier script

Go to top

La bibliothèque TELLO une fois chargée sur ta calculatrice, est importable dans des scripts Python en passant par le menu des modules complémentaires. Cela t'active alors un nouveau menu tello drone.

Nous y retrouvons alors plusieurs onglets :

• Fly pour tout ce qui concerne les contrôles dans le cadre d'un vol
• Data pour interroger les capteurs intégrés au drone Tello
• Maneuver pour quelques figures acrobatiques
• EDU pour les plans de vol
• Settings pour les réglages

Cela a l'air super simple non, enfantin même ? Voici donc déjà un premier script :

Code: Select all

from tello import *
tello.takeoff()
tello.forward(50)
d=tello.altitude()
tello.turn_left(180)
tello.forward(50)
tello.land()

4) Matériel nécessaire et premiers branchements

Go to top

Bref outre la calculatrice, que te faut-il maintenant niveau matériel pour piloter un drone Tello ?

1. nanoordinateur BBC micro:bit v2
2. câble mini/micro-USB direct pour BBC micro:bit v2 et calculatrice
3. carte d'extension Grove ou bitmaker
4. module Grove WiFi + cable Grove
5. batterie externe USB + câble micro-USB
6. drone Tello

Tu as tout le matériel entre les mains ? C'est parti pour les manipulations :

Commençons par enregistrer ton drone Tello si c'est sa première utilisation, étape qui ne peut se faire avec la calculatrice :

1. Télécharge l'application de vol Tello sur ton téléphone.
2. Allume ton drone Tello.
3. Sur ton téléphone, recherche les points d'accès WiFi.
4. Connecte-toi au point d'accès Tello qui devrait apparaître.
5. Ouvre l'application et accepte l'enregistrement.
6. Ferme l'application et déconnecte ton téléphone du point d'accès Tello.
   (attention à ce que ton téléphone n'y reste pas connecté ou ne s'y reconnecte pas tout seul, ce qui risque de perturber la communication avec la calculatrice)

Voici maintenant pour les connexions :

1. Insère le nanoordinateur micro:bit v2 dans la carte d'extension, en faisant attention au sens.
2. Connecte la batterie USB à la carte d'extension.
3. Connecte le module Grove WiFi au port P1 de la carte d'extension.
4. Assure-toi que la batterie USB est chargée et allumée si disposant d'un bouton.
5. Allume la carte d'extension si disposant d'un bouton.
   (les DELs sur les micro:bit, carte d'extension et module WiFi doivent s'allumer)
6. Connecte enfin la micro:bit à la calculatrice, puis allume cette dernière si nécessaire.
7. Assure-toi que le drone Tello est chargé et allumé. Il va clignoter sous différentes couleurs puis se fixer sur du jaune clignotant lorsque prêt.

Et voilà, paré à décoller, tu peux enfin écrire et lancer ton premier script.

5) Lancement et tutoriel de décollage

Go to top

Dernière chose avant de te laisser voler de tes propres ailes, quand tu lances un script important le module tello, la calculatrice n'est pas capable de détecter la carte d'extension utilisée (Grove ou bitmaker) et va donc te demander de préciser.

Si tu préfères bricoler tes propres branchements, tu disposes également si tu préfères d'un écran de configuration avancé.

Si nécessaire, voici pour résumer tout cela un tuto-vidéo officiel en Anglais:

Téléchargements

Go to top

Décidément Texas Instruments, déjà leader incontesté des projets scientifiques sur calculatrices graphiques, se permet d'innover de façon encore plus formidable. En conséquence pour toi une toute nouvelle dimension à explorer pour des projets encore plus fantastiques !

Merci TI !

• TI-Runtime 2.5.1 pour BBC microbit v2
• bibliothèque Python complémentaire TELLO

Source : https://resources.t3europe.eu/t3europe- ... 50b9bcfffa

[mr womp womp]

[Adriweb]

Pas mal

J'ai vu aussi haha

[critor]

TI avance avec les drones.

Voici maintenant le tuto-vidéo officiel du montage :

[ggauny@live.fr]

Et bonne fête Critor !

[critor]

Tu y as pensé , merci !