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 , le robot pilotable , la grille programmable 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 ! 
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 programmable en Python
dont tu étais peut-être déjà équipé·e ! 


micro:bit
est initialement un projet lancé par la BBC
(
, le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont B
ritish B
roadcasting C
orporation)ARM
Microsoft
Samsung
Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique
BBC Micro
Thomson MO5
TO7
IPT
(
.I
nformatique P
our T
ous)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
.- USB micro-Bmâle ↔USB mini-Amâle
- USB micro-Bmâle ↔USB mini-B OTGmâle
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-M0cadencé à16 MHz
- mémoire de stockage Flashd'une capacité de256 Kio
- mémoire de travail RAMd'une capacité de16 Kiopermettant unheap (tas)Pythonde10,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
etB
programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chezNintendo - 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
- capteur de luminosité
- connectivité Bluetooth 4.0basse énergie 2,4 GHz maître/esclave
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-M0cadencé à64 MHzau lieu desoit 4 fois plus rapide !16 MHz
- mémoire de stockage Flashd'une capacité de512 Kioau lieu desoit 2 fois plus grande !256 Kio
- mémoire de travail RAMd'une capacité de128 Kioau lieu desoit 8 fois plus grande, permettant un16 Kioheap (tas)Pythonde64,512 Ko!

- 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 Bluetoothqui devient compatibleBLE Bluetooth 5.0, contre seulementauparavant4.0
- 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
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 .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.

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 :- microbit(générale, permet d'accéder aux menus des autres bibliothèques)
- mb_audio→(effets sonores - accessible via le menuAudio)
- mb_butns→(boutonsA,Bet tactile intégrés - accessible via le menuButtonsouBoutons)
- mb_disp→(afficheur à 5×5=25 LEDs rouges intégré - accessible via le menuDisplayouAffichage)
- mb_grove(capteurs et actionneursGroveà rajouter - accessible via le menuGrove Devices)
- mb_log(enregistrement de données - accessible via le menuData loggingouEnregistrement de données)
- mb_mic(micro intégré - accessible via le menuMicrophone)
- mb_music→(haut-parleur à rajouter surmicro:bit v1ou intégré surmicro:bit v2- accessible via le menuMusicouMusique)
- mb_neopx→(rubans de LEDs programmables à rajouter - accessible via le menuNeoPixel)
- mb_notes(notes de musique - accessible via le menuMusicouMusique)
- mb_pins(contacts programmables intégrés - accessible via le menuInput/output pinsouBroches entrée/sortie)
- mb_radio→(communication radio intégrée - accessible via le menuRadio)
- mb_sensr(capteurs intégrés : boussole, accéléromètre, température - accessible via le menuSensors and gesturesouCapteurs 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 pilotable par calculatrice aujourd'hui, fallait-il déjà commencer par décoller avant d'espérer pouvoir un jour atteindre
Mars
.
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
Go to top
- D'une part, nous avons une mise à jour en version 2.5.1duTI-Runtimepour lesmicro:bit v2. Toutefois en pratique, en interrogeant la cartemicro:bitavec
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 Pythontello, en version2.5.
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 topIci 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 pour pouvoir lire son code source :
L'on constate en effet que la quasi totalité des changements concernent le support du drone
- 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


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 :
- Flypour tout ce qui concerne les contrôles dans le cadre d'un vol
- Datapour interroger les capteurs intégrés au droneTello
- Maneuverpour quelques figures acrobatiques
- EDUpour les plans de vol
- Settingspour 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
Tello
?- nanoordinateur BBC micro:bit v2
- câble mini/micro-USBdirect pourBBC micro:bit v2et calculatrice
- carte d'extension Groveoubitmaker
- module GroveWiFi+ cableGrove
- batterie externe USB+ câblemicro-USB
- drone Tello

Commençons par enregistrer ton drone
Tello
si c'est sa première utilisation, étape qui ne peut se faire avec la calculatrice :- Télécharge l'application de vol Tellosur ton téléphone.
- Allume ton drone Tello.
- Sur ton téléphone, recherche les points d'accès WiFi.
- Connecte-toi au point d'accès Telloqui devrait apparaître.
- Ouvre l'application et accepte l'enregistrement.
- 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)

- Insère le nanoordinateur micro:bit v2dans la carte d'extension, en faisant attention au sens.
- Connecte la batterie USBà la carte d'extension.
- Connecte le module Grove WiFiau portP1de la carte d'extension.
- Assure-toi que la batterie USBest chargée et allumée si disposant d'un bouton.
- Allume la carte d'extension si disposant d'un bouton.(les DELs sur lesmicro:bit, carte d'extension et moduleWiFidoivent s'allumer)
- Connecte enfin la micro:bità la calculatrice, puis allume cette dernière si nécessaire.
- Assure-toi que le drone Telloest 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

tello
, la calculatrice n'est pas capable de détecter la carte d'extension utilisée 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 topDé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-Runtime2.5.1pourBBC microbit v2
- bibliothèque Pythoncomplémentaire
Source
: