π
<-

News 2024
Juin (5)
Mai (14)
Avril (16)
Mars (7)
Janvier (20)

News 2023
Octobre (19)
Août (14)
Juillet (13)
Juin (21)
Mai (29)
Avril (24)
Mars (24)
Janvier (24)

News 2022
Octobre (23)
Août (14)
Juillet (15)
Juin (17)
Mai (31)
Avril (27)
Mars (28)
Janvier (34)

News 2021
Octobre (24)
Août (37)
Juillet (50)
Juin (32)
Mai (48)
Avril (61)
Mars (35)
Janvier (34)

News 2020
Octobre (17)
Août (43)
Juillet (43)
Juin (45)
Mai (60)
Avril (78)
Mars (36)
Janvier (39)

News 2019
Octobre (13)
Août (18)
Juillet (23)
Juin (28)
Mai (31)
Avril (26)
Mars (38)
Janvier (37)

News 2018
Octobre (13)
Août (32)
Juillet (23)
Juin (64)
Mai (63)
Avril (45)
Mars (43)
Janvier (45)

News 2017
Octobre (26)
Août (39)
Juillet (52)
Juin (88)
Mai (51)
Avril (43)
Mars (37)
Janvier (33)

News 2016
Octobre (25)
Août (42)
Juillet (34)
Juin (109)
Mai (55)
Avril (34)
Mars (37)
Janvier (24)

News 2015
Octobre (22)
Août (56)
Juillet (22)
Juin (94)
Mai (56)
Avril (32)
Mars (40)
Janvier (21)

News 2014
Octobre (26)
Août (18)
Juillet (23)
Juin (101)
Mai (57)
Avril (59)
Mars (54)
Janvier (31)

News 2013
Octobre (67)
Août (50)
Juillet (43)
Juin (193)
Mai (93)
Avril (102)
Mars (45)
Janvier (50)

News 2012
Octobre (64)
Août (63)
Juillet (53)
Juin (132)
Mai (88)
Avril (73)
Mars (57)
Janvier (58)

News 2011
Octobre (56)
Août (31)
Juillet (27)
Juin (71)
Mai (61)
Avril (32)
Mars (36)
Janvier (24)

News 2010
Octobre (11)
Août (8)
Juillet (14)
Juin (10)
Mai (3)
Avril (3)
Mars (1)

News 2009
Août (3)
Juin (2)
Mai (1)
Avril (2)
Mars (1)

Tableau périodique alternatif thème sombre TI-83 Premium CE

Nouveau messagede critor » 14 Avr 2022, 10:51

Ta calculatrice TI-83 Premium CE ou TI-84 Plus CE dispose d'une application de tableau périodique des éléments appelée Periodic.

Periodic est normalement préinstallé en usine, et est ensuite mis à jour ou réinstallé avec les fichiers de packs de mises à jour diffusés par Texas Instruments chaque année. L'application est alors accessible via la combinaison
2nde
résol
sur TI-83 Premium CE ou via la touche
apps
sur TI-84 Plus CE. Sur TI-83 Premium CE, cette application a même le gros avantage de rester disponible en mode examen, contrairement aux modèles concurrents de chez Casio.

La dernière version de Periodic est la 5.5.0.0038 compilée le 12 mai 2020, et accompagne donc les packs de mises à jour depuis la mise à jour système 5.5 de rentrée 2020.

C'est une très belle application, disposant d'une superbe interface justement en forme de tableau périodique et tirant profit de l'écran couleur pour distinguer différentes familles d'éléments. :favorite:

Mais c'est loin d'être tout. Pour accéder à un élément ciblé, tu as le choix entre parcourir le tableau périodique évoqué ou bien une liste d'éléments. Pour te faciliter les choses cette liste peut justement être triée aussi bien par numéro atomique que nom ou symbole. :D

Rajoutons la possibilité d'exporter les valeurs numériques de propriétés d'élément pour les réutiliser hors de l'application, ainsi que celle de construire des diagrammes qui pourront entre autres mettre en évidence le caractère périodique des propriétés chimiques ! :bj:


Nous en sommes donc à bientôt 2 ans sans mise à jour de l'application Periodic.

Et Texas Instruments ferait peut-être mieux de se méfier car le concurrent français NumWorks a annoncé fin 2021 être en train de travailler sur une application de tableau péridodique pour une future mise à jour, un des plus gros manques de sa calculatrice, et a l'habitude pour chaque nouveauté d'innover grandement sur l'interface...

Frédéric Desautels alias mr womp womp vient donc de sauter sur l'occasion et de te programmer en langage C sa propre vision d'un tableau périodique amélioré pour TI-83 Premium CE et compatibles.

Son programme est bien évidemment loin d'égaler l'application officielle. On peut déplorer :
  • l'impossibilité d'accéder aux éléments par liste
  • l'impossibilité d'exporter ou représenter graphiquement les propriétés numériques
  • la précision décimale inférieure à l'affichage des propriétés numériques
  • la non prise en compte de la langue de la calculatrice, l'affichage étant ici toujours en Anglais
  • un tout petit peu moins de propriétés que Texas Instruments, 13 au lieu de 15

Mais ce qui nous intéresse aujourd'hui ce ne sont pas les manques, mais les différences. Frédéric nous offre en effet quelques évolutions sur l'interface qu'il a tout particulièrement soignée, avec :
  • les symboles des éléments directement affichés sur le tableau périodique et facilitant donc d'une part au plus grand nombre la recherche sur cette interface, et permettant de plus de lister rapidement les éléments appartenant à une même famille ou période :bj:
  • un thème sombre moins agressif pour les yeux :bj:
  • un affichage des propriétés en petite police permettant de tout faire rentrer sur un même écran, au lieu d'avoir à faire défiler sur 3 écrans comme avec Texas Instruments :bj:
  • sur l'affichage des propriétés, possibilité de passer directement à l'élément suivante/précédent avec les touches fléchées sans avoir à repasser par la vue en tableau :bj:

Mais bien sûr à la différence de l'application officielle, ce programme ne restera malheureusement pas disponible en mode examen, les réglementation et spécifications associées semblant avoir été conçues de façon trop complaisante avec les constructeurs ; ce genre de programme parfaitement légitime en France n'aurait jamais dû être bloqué par le mode examen en France. :'(
Donc pour t'en servir en évaluation, pas d'autre choix qu'attendre que Texas Instruments accepte de faire quelque chose de similaire, ou à défaut un de ses concurrents.

Attention, ce programme rentre dans la catégorie des programmes en langage machine dits ASM.

Or, suite à un acte hautement maladroit d'un enseignant de Mathématiques français avec ses gesticulations certes compréhensibles mais maladroites et à courte vue dans le contexte de la réforme du lycée, Texas Instruments a réagi en supprimant la gestion de tels programmes depuis la mise à jour 5.5.1.

Si tu es sur une des versions ainsi bridées, tu peux quand même jouer sans trop d'efforts. Il te faut :
  1. installer arTIfiCE pour remettre la possibilité de lancer des programmes ASM
  2. ensuite de préférence installer Cesium pour pouvoir lancer les programmes ASM plus facilement, ou même AsmHook pour pouvoir les lancer comme avant
  3. installer les bibliothèques C nécessaires au fonctionnement de certains jeux dont celui-ci (mais rien de compliqué, juste à transférer le fichier et c'est tout)

Téléchargements :
Lien vers le sujet sur le forum: Tableau périodique alternatif thème sombre TI-83 Premium CE (Commentaires: 3)

Upsilon : bootloader conforme France + multiboot Epsilon

Nouveau messagede Admin » 14 Avr 2022, 20:51

La NumWorks était originellement un merveilleux projet de calculatrice graphique ouverte, rompant radicalement avec les usages des constructeurs historiques.

Le développement tiers a pu s'y hisser à un niveau jamais atteint sur la concurrence et permettre l'émergence d'un projet formidable, Omega par Quentin Guidee et ses non moins illustres collaborateurs.

Il s'agissait d'un firmware alternatif pour ta calculatrice NumWorks. Basé sur le code source du firmware officiel Epsilon comme la licence libre l'autorisait à l'époque, Omega avait pour but de regrouper et mettre en avant les meilleures contributions au code d'Epsilon, en incluant cette fois-ci celles laissées de côté par le constructeur.

Difficile de tout citer ici mais voici déjà par exemple quelques-uns des fantastiques ajouts d'Omega. La NumWorks travaille en interne sur des arbres de calcul, mais les bridait donc artificiellement pour n'accepter que des valeurs numériques. Omega ré-autorisait à nouveau ces arbres à utiliser des lettres / inconnues, ce qui nous redonnait ainsi un moteur de calcul littéral. De quoi même dériver, du jamais vu à seulement 80€ ! :bj:
On peut aussi citer un tableau périodique des éléments, ou encore la possibilité d'avoir une bibliothèque de constantes physiques avec unités bien avant que ce ne soit disponible dans le firmware officiel.

12024Outre ce qu'il intégrait, Omega offrait également l'avantage de pouvoir installer à chaud des applications, fonctionnalité jusqu'alors absente du firmware officiel Epsilon. Plusieurs applications de très haute facture furent développées, on peut citer entre autres : :D
  • KhiCAS, une formidable application intégrée de Mathématiques et de Sciences par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une HP Prime. L'application intégrait le moteur de calcul formel GIAC développé pour le logiciel Xcas du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur ainsi qu'un un tableau périodique des éléments (deux applications faisant toujours à ce jour cruellement défaut au firmware officiel Epsilon), ainsi qu'une bibliothèque de constantes physiques, un convertisseur d'unités, et bien d'autres choses encore. Le tout était en prime programmable en Python, avec une collection de bibliothèques importables bien plus étoffée que celle de l'application du firmware officiel, et surtout ici de façon intégrée, tes scripts Python pouvant même ici faire appel au moteur de calcul formel GIAC par l'intermédiaire de la bibliothèquecas.
  • Nofrendo, un émulateur de console de jeux Nintendo NES par zardam
  • Peanut-GB, un émulateur de console de jeux Nintendo GameBoy par M4x1m3
  • Periodic, un autre tableau périodique des éléments par M4x1m3
Un gros avantage de plus était ici que KhiCAS et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités ne sont pas des données et venaient de plus directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés. :bj:
14500Mais voilà, pour la rentrée 2021 la mise à jour 16.3 d'Epsilon, le firmware officiel des calculatrices NumWorks, a introduit un verrouillage des modèles N0110.

Toute N0110 mise à jour ou venant préchargée d'une version 16.3 ou supérieure, comprend un chargeur de démarrage censé être non effaçable, et empêchant entre autres :
  • l'installation de tout firmware non correctement signé par le constructeur, c'est-à-dire entre autres de tout firmware antérieur à la version 16 ainsi que de tout firmware non officiel dont Omega
  • l'installation d'applications persistantes en mémoire Flash (logiciel intégré de Mathématiques avec moteur ce calcul formel KhiCAS, émulateurs Nintendo Game Boy et NES, tableau périodique des éléments, ...)
NumWorks a de plus profité de l'occasion pour révoquer sa licence libre, et interdire ainsi la réutilisation de tout code introduit à partir de la version 16 dans des firmwares non officiels ; Omega ne pouvait donc plus intégrer les dernières nouveautés. :'(

La mort dans l'âme, nous t'annoncions donc à la rentrée 2021 l'abandon en conséquence du projet de firmware Omega.
Toutefois 2 forks en ont par la suite émergé successivement, les firmwares Khi par Bernard Parisse, puis Upsilon.

Les utilisateurs informés qui avaient la chance d'avoir entre leurs mains des calculatrices non encore verrouillées avaient certes le choix mais restaient face à un très cruel dilemme :
  • soit mettre à jour vers le firmware Epsilon pour bénéficier de toutes les dernières nouveautés officielles, mais en contrepartie renoncer définitivement aux formidables ajouts des firmwares tiers
  • soit utiliser un firmware tiers, mais en contrepartie se priver des nouveautés officielles apportées à ce jour avec les versions 16, 17 puis 18

15413Dans une actualité précédente, nous t'annoncions la sortie de Phi par M4x1m3, un des anciens de l'équipe de développement Omega. Phi est un chargeur de démarrage avec lequel il suffit d'écraser le chargeur officiel, grâce à une faille présente dans les firmwares Epsilon officiels jusqu'à la version 18.2.0.

Après plus de 6 mois d'attente Phi te permettait donc enfin de déverrouiller ta calculatrice. Mieux que ça, le nouveau chargeur de démarrage Phi était ensuite capable de lancer aussi bien les firmwares officiels Epsilon (à partir de la version 16) que les firmware tiers, à la seule condition que ces derniers aient été mis à jour pour supporter ce nouvel amorçage.

Le projet Omega profita justement de l'occasion pour renaître de ses cendres avec une mise à jour compatible en version 2.

Encore mieux que ça, avec Phi tu n'avais même pas à choisir entre fonctionnalités officielles et tierces, tu peux avoir les deux en même temps ! :bj:
Phi rajoute un raccourci reset+
4
permet de consulter l'état de la mémoire Flash et de mettre la calculatrice dans un mode de mise à jour protégé car interdisant la réécriture du chargeur de démarrage. Rappelons que depuis le verrouillage la mémoire Flash des N0110 est partitionnée en deux moitiés égales de 4 Mio et pouvant chacune accueillir un firmware. Justement à cet écran Phi présente la mémoire Flash comme découpée en 2 slots A et B de 4 Mio chacun. Les nouveaux raccourcis reset+
1
et reset+
2
te permettent alors de basculer entre l'amorçage des deux firmwares présents dans chacun de ces 2 slots. Du multiboot sur une calculatrice, c'est absolument sensationnel ! :#tritop#:

Sauf qu'il y avait deux problèmes majeurs avec Phi et Omega 2.

D'une part, le découpage de la mémoire Flash en 2 slots égaux de 4 Mio faisait qu'il n'était pas possible de profiter à la fois :
  • de la possibilité d'avoir 2 firmwares entre lesquels basculer au choix
  • et de la formidable application KhiCAS, cette dernière occupant trop de place et débordant donc sur le 2ème slot

D'autre part, et là c'était extrêmement grave, Phi n'est pas conforme à la réglementation française du mode examen et est donc strictement interdit d'utilisation à tout examen exigeant l'activation de ce mode en France. :#non#:
Le problème est que les raccourcis reset+
1
et reset+
2
permettant de basculer entre les deux firmwares présents en mémoire désactivent le mode examen. Or c'est strictement interdit par les spécifications officielles du mode examen français ; le mode examen ne doit pas pouvoir être désactivé de façon autonome par les candidats, c'est-à-dire que la désactivation doit nécessiter un outil extérieur non présent sur leur table de composition car interdit en examen (2ème calculatrice, ordinateur, etc.).
Un outil interdit étant frauduleux, si tu introduis Phi dans une salle d'examen en France et te fais prendre (parce que tu auras basculé entre deux firmwares pendant l'épreuve et peut-être même oublié de réactiver immédiatement le mode examen), tu risquais l'ensemble des désagréments possiblement dramatiques (non fixé sur ta réussite à l'examen à la veille de l'été comme les camarades et donc rien à fêter avec eux, le jugement nécessitant du temps alors qu'en prime les rectorats sont fermés une bonne partie de l'été risque de perdre ton inscription dans l'enseignement supérieur et donc une année, jusqu'à 5 ans d'interdiction de passer tout examen y compris le permis de conduire de quoi bien te gâcher la vie, ...).

Malgré sa gravité et ses conséquences éventuelles hautement désagréables, ce problème rapidement signalé n'avait malheureusement pas fait l'objet de corrections de la part de l'équipe Omega. :'(

1543815437Nous t'annoncions par la suite une première mise à jour du firmware Khi dédié à KhiCAS par Bernard Parisse, compatible avec le nouveau amorçage via un chargeur de démarrage, et incluant sa propre version de ce dernier.

Bernard avait pris le soin de traiter les deux problèmes précédents :
  • d'une part, Khi était proposé dans une version allégée intégrant la seul application Paramètres, permettant de faire rentrer KhiCAS dans un unique slot et ainsi de profiter également en même temps d'un multiboot avec le firmware officiel Epsilon :bj:
  • d'autre part, le mode examen était ici conservé lors de la bascule entre deux firmwares, comportement enfin conforme aux textes réglementaires français :bj:

Si pour ta part tu préférais le firmware Upsilon, et bien c'est le grand jour pour toi ! :D

Dernier mais non le moindre, Upsilon vient en effet enfin d'être à son tour mis à jour dans une version avec un bootloader permettant le multiboot ! :bj:

En prime cette mise à reprend une des améliorations effectuées dans le cadre de la mise à jour de Khi : le mode examen sera conservé lorsque tu changeras de firmware conformément la réglementation française ! :bj:

Si tu es en France et as installé Phi ou Omega 2 sur ta machine, il est urgent pour toi de migrer vers une solution conforme à la réglementation des examens aussitôt que possible, c'est-à-dire à ce jour uniquement Khi ou Upsilon, et ce même si tu n'as pas d'examens cette année. En effet :
  • si tu attends à l'année prochaine tu risques d'oublier entre temps
  • et même si tu n'as pas du tout d'examen, tu pourrais très bien un jour prêter ou vendre ta calculatrice à quelqu'un qui serait concerné

Si tu souhaites installer ou migrer sur Khi, des mini-tutos sont inclus dans l'annonce associée.

Si tu souhaites installer ou migrer sur Upsilon, voici maintenant quelques mini-tutos à adapter selon ta situation.
Attention, contrairement à la solution précédente et comme déjà dit, le chargeur de démarrage Upsilon ne te permettra pas de profiter à la fois de l'application KhiCAS et de la possibilité d'avoir un multiboot.

Supposons que tu dispose déjà d'une machine sous Phi avec un multiboot Omega 2.0 et Epsilon, voici comment migrer.

Comme le site web d'Omega n'installe ce dernier que dans le slot A, c'est-à-dire que tu as normalement :
  1. Omega 2.0
  2. Epsilon

15448Pour remplacer Phi par le nouveau bootloader d'Upsilon c'est extrêmement simple. Il te faut :
  1. mettre la machine en mode de récupération autorisant la réécriture du bootloader avec le raccourci reset+
    6

    (raccourci à ne plus jamais utiliser sur le site officiel si tu ne veux pas te retrouver à nouveau coincé, et peut-être cette fois-ci sans retour possible :#non#:)
  2. te rendre sur le site d'Upsilon
  3. cliquer sur le bouton Recovery pour charger et lancer le logiciel de récupération
  4. rafraîchir la page pour utiliser alors le bouton Connect, suivre les instructions, et lorsque proposé bien effectuer une installation dans le slot A (choix par défaut à ce jour, et le slot B n'est pas proposé)

Si par contre tu pars d'une calculatrice ne disposant pas encore de Phi ou autre bootloader tiers, le plus simple est de commencer par l'installer pour ensuite suivre la procédure précédente de migration vers Upsilon.

Tutoriels d'installation :

Installation :
  1. Phi
  2. Khi ou Upsilon ou Omega
Lien vers le sujet sur le forum: Upsilon : bootloader conforme France + multiboot Epsilon (Commentaires: 1)

Stage Casio gratuit en ligne préparation BAC printemps 2022

Nouveau messagede critor » 16 Avr 2022, 20:26

Bientôt l'épreuve écrite de spécialité Mathématiques du Baccalauréat Général, très rapidement après le retour des vacances suite à la nouvelle organisation imposée par la réforme du lycée et du Baccalauréat.
Il faut donc préparer cela dès maintenant, et avec les vacances et le beau temps printanier qui arrivent simultanément, cela va peut-être être difficile.

Mais que tu sois lycéen(ne) ou enseignant(e), Casio se propose de t'aider en t'accompagner avec un stage de préparation en ligne, que nous t'avons déjà annoncé avant le départ de la première zone en vacances de printemps afin que le moins de personnes possible ratent l'information.
Et bien nous sommes enfin aujourd'hui à la veille du grand lancement de cet événement.

Entièrement gratuit, le stage adopte différents objectifs selon si tu es élève ou enseignant(e) :
  • pour les enseignants : comment aborder les différents thèmes mathématiques de manière simple et rapide à l’aide de la calculatrice
  • pour les élèves : se préparer avec l'aide d'un des professeurs de Mathématiques partenaires de Casio sur les principaux thèmes du programme, s'exercer avec des cas concrets issus des annales, et tu es bien évidemment bienvenu(e) peu importe ton équipement

Des journées ce mois d'avril vont être dédiées à chacun des thèmes, avec le déroulement suivant :
  • atelier pour les enseignants : 1 heure en fin de matinée, de 10h30 à 11h30
  • atelier pour les élèves : 1 heure en tout début d'après-midi de 13h30 à 14h30, afin de ne pas impacter ce que tu avais prévu pour ton après-midi

Afin de maximiser tes possibilités de participer, chaque thème sera de plus proposé sur 2 journées tombant sur différentes zones de vacances scolaires, du moins en Métropole. En voici le calendrier :
  • Fonctions & Probabilités :
    • Mardi 19 avril (zones A et B Métropole + Guyane + Saint-Martin + Saint-Barthélémy)
    • Mardi 26 avril (zones A et C Métropole + Guyane + Corse)
  • Programmation Python & Suites :
    • Jeudi 21 avril (zones A et B Métropole + Guyane + Saint-Martin + Saint-Barthélémy)
    • Jeudi 28 avril (zones A et C Métropole + Guyane + Corse)
  • Activation et désactivation du mode examen Casio : Mercredi 4 mai
Une organisation méticuleuse afin que tout-le-monde puisse participer, et que nous ne pouvons que féliciter ! :bj:

Le stage est sur inscription, mais précisons que tu n'as aucune obligation de suivre l'intégralité du stage : tu as toute liberté de sélectionner les journées auxquelles tu souhaites participer, même une seule si tu le veux ! :D

Merci Casio ! :favorite:


Inscription : élèves enseignants
Lien vers le sujet sur le forum: Stage Casio gratuit en ligne préparation BAC printemps 2022 (Commentaires: 0)

Mise à jour Phi + Omega 2.0.2 pour conformité mode examen

Nouveau messagede Admin » 17 Avr 2022, 17:49

La NumWorks était originellement un merveilleux projet de calculatrice graphique ouverte, rompant radicalement avec les usages des constructeurs historiques.

Le développement tiers a pu s'y hisser à un niveau jamais atteint sur la concurrence et permettre l'émergence d'un projet formidable, Omega par Quentin Guidee et ses non moins illustres collaborateurs.

Il s'agissait d'un firmware alternatif pour ta calculatrice NumWorks. Basé sur le code source du firmware officiel Epsilon comme la licence libre l'autorisait à l'époque, Omega avait pour but de regrouper et mettre en avant les meilleures contributions au code d'Epsilon, en incluant cette fois-ci celles laissées de côté par le constructeur.

Difficile de tout citer ici mais voici déjà par exemple quelques-uns des fantastiques ajouts d'Omega. La NumWorks travaille en interne sur des arbres de calcul, mais les bridait donc artificiellement pour n'accepter que des valeurs numériques. Omega ré-autorisait à nouveau ces arbres à utiliser des lettres / inconnues, ce qui nous redonnait ainsi un moteur de calcul littéral. De quoi même dériver, du jamais vu à seulement 80€ ! :bj:
On peut aussi citer un tableau périodique des éléments, ou encore la possibilité d'avoir une bibliothèque de constantes physiques avec unités bien avant que ce ne soit disponible dans le firmware officiel.

12024Outre ce qu'il intégrait, Omega offrait également l'avantage de pouvoir installer à chaud des applications, fonctionnalité jusqu'alors absente du firmware officiel Epsilon. Plusieurs applications de très haute facture furent développées, on peut citer entre autres : :D
  • KhiCAS, une formidable application intégrée de Mathématiques et de Sciences par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une HP Prime. L'application intégrait le moteur de calcul formel GIAC développé pour le logiciel Xcas du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur ainsi qu'un un tableau périodique des éléments (deux applications faisant toujours à ce jour cruellement défaut au firmware officiel Epsilon), ainsi qu'une bibliothèque de constantes physiques, un convertisseur d'unités, et bien d'autres choses encore. Le tout était en prime programmable en Python, avec une collection de bibliothèques importables bien plus étoffée que celle de l'application du firmware officiel, et surtout ici de façon intégrée, tes scripts Python pouvant même ici faire appel au moteur de calcul formel GIAC par l'intermédiaire de la bibliothèquecas.
  • Nofrendo, un émulateur de console de jeux Nintendo NES par zardam
  • Peanut-GB, un émulateur de console de jeux Nintendo GameBoy par M4x1m3
  • Periodic, un autre tableau périodique des éléments par M4x1m3
Un gros avantage de plus était ici que KhiCAS et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités ne sont pas des données et venaient de plus directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés. :bj:
14500Mais voilà, pour la rentrée 2021 la mise à jour 16.3 d'Epsilon, le firmware officiel des calculatrices NumWorks, a introduit un verrouillage des modèles N0110.

Toute N0110 mise à jour ou venant préchargée d'une version 16.3 ou supérieure, comprend un chargeur de démarrage censé être non effaçable, et empêchant entre autres :
  • l'installation de tout firmware non correctement signé par le constructeur, c'est-à-dire entre autres de tout firmware antérieur à la version 16 ainsi que de tout firmware non officiel dont Omega
  • l'installation d'applications persistantes en mémoire Flash (logiciel intégré de Mathématiques avec moteur ce calcul formel KhiCAS, émulateurs Nintendo Game Boy et NES, tableau périodique des éléments, ...)
NumWorks a de plus profité de l'occasion pour révoquer sa licence libre, et interdire ainsi la réutilisation de tout code introduit à partir de la version 16 dans des firmwares non officiels ; Omega ne pouvait donc plus intégrer les dernières nouveautés. :'(

La mort dans l'âme, nous t'annoncions donc à la rentrée 2021 l'abandon en conséquence du projet de firmware Omega.
Toutefois 2 forks en ont par la suite émergé successivement, les firmwares Khi par Bernard Parisse, puis Upsilon.

Les utilisateurs informés qui avaient la chance d'avoir entre leurs mains des calculatrices non encore verrouillées avaient certes le choix mais restaient face à un très cruel dilemme :
  • soit mettre à jour vers le firmware Epsilon pour bénéficier de toutes les dernières nouveautés officielles, mais en contrepartie renoncer définitivement aux formidables ajouts des firmwares tiers
  • soit utiliser un firmware tiers, mais en contrepartie se priver des nouveautés officielles apportées à ce jour avec les versions 16, 17 puis 18

15413Dans une actualité précédente, nous t'annoncions la sortie de Phi par M4x1m3, un des anciens de l'équipe de développement Omega. Phi est un chargeur de démarrage avec lequel il suffit d'écraser le chargeur officiel, grâce à une faille présente dans les firmwares Epsilon officiels jusqu'à la version 18.2.0.

Après plus de 6 mois d'attente Phi te permettait donc enfin de déverrouiller ta calculatrice. Mieux que ça, le nouveau chargeur de démarrage Phi était ensuite capable de lancer aussi bien les firmwares officiels Epsilon (à partir de la version 16) que les firmware tiers, à la seule condition que ces derniers aient été mis à jour pour supporter ce nouvel amorçage.

Le projet Omega profita justement de l'occasion pour renaître de ses cendres avec une mise à jour compatible en version 2.0.0.

Encore mieux que ça, avec Phi tu n'avais même pas à choisir entre fonctionnalités officielles et tierces, tu peux avoir les deux en même temps ! :bj:
Phi rajoute un raccourci reset+
4
permet de consulter l'état de la mémoire Flash et de mettre la calculatrice dans un mode de mise à jour protégé car interdisant la réécriture du chargeur de démarrage. Rappelons que depuis le verrouillage la mémoire Flash des N0110 est partitionnée en deux moitiés égales de 4 Mio et pouvant chacune accueillir un firmware. Justement à cet écran Phi présente la mémoire Flash comme découpée en 2 slots A et B de 4 Mio chacun. Les nouveaux raccourcis reset+
1
et reset+
2
te permettent alors de basculer entre l'amorçage des deux firmwares présents dans chacun de ces 2 slots. Du multiboot sur une calculatrice, c'est absolument sensationnel ! :#tritop#:

Sauf qu'il y avait un problème extrêmement grave avec Phi et Omega 2.0.0.

Phi n'était pas conforme à la réglementation française du mode examen et était donc strictement interdit d'utilisation à tout examen exigeant l'activation de ce mode en France. :#non#:
Le problème était que les raccourcis reset+
1
et reset+
2
permettant de basculer entre les deux firmwares présents en mémoire désactivaient le mode examen et éteignaient donc la diode examen, chose aisément et rapidement détectable par les surveillants.

Certes, cela ne permettait a priori pas de tricher, vu qu'il s'agissait d'un reset et que cela vidait donc le contenu mémoire. Le problème est ailleurs ; c'est strictement interdit par les spécifications officielles du mode examen français. En effet le mode examen ne doit pas pouvoir être désactivé de façon autonome par les candidats, c'est-à-dire que la désactivation doit obligatoirement nécessiter un outil extérieur non présent sur leur table de composition car interdit en examen (2ème calculatrice, ordinateur, smartphone, tablette, etc.).

Si tu introduisais Phi dans une salle d'examen en France et te faisais prendre (parce que tu auras basculé entre deux firmwares pendant l'épreuve et oublié de réactiver immédiatement le mode examen), tu risquais l'ensemble des désagréments possiblement dramatiques associés à une tentative de fraude (non fixé sur ta réussite à l'examen à la veille de l'été comme les camarades et donc rien à fêter avec eux, le jugement nécessitant du temps alors qu'en prime les rectorats sont fermés une bonne partie de l'été risque de perdre ton inscription dans l'enseignement supérieur et donc une année, jusqu'à 5 ans d'interdiction de passer tout examen y compris le permis de conduire de quoi bien te gâcher la vie, ...).

Les mises à jour suivantes de Khi puis Upsilon migrant vers ce nouveau mode de fonctionnement avec chargeur de démarrage, en ont profité pour traiter ce problème.

Le fonctionnement retenu était de dupliquer la configuration du mode examen dans les différents slots lors du basculement de firmware via les raccourcis reset+
1
et reset+
2
.

En théorie donc, le mode examen n'était donc plus désactivé et tu n'étais donc plus en danger.
En pratique toutefois ce n'était pas parfait.

D'une part ce n'était pas fiable à 100%. Il nous est arrivé que le mode examen se désactive lors d'une bascule entre les firmwares, plus précisément à la première activation suivant l'installation du bootloader associé. Pas réussi à date à reproduire le problème autrement ; mais comme les développeurs n'ont pas réussi à l'expliquer rien ne prouve que c'est impossible.

D'autre part, ce n'était pas gênant pour la France où seule le verrouillage du contenu mémoire préexistant est demandé en mode examen, mais dans d'autres pays le mode examen est également censé bloquer certaines fonctionnalités. Et là, la configuration dupliquée du mode examen n'était pas toujours comprise de la même façon lors du basculement entre les firmwares.

15451Aujourd'hui c'est enfin au tour du firmware Omega d'être mis à jour afin d'améliorer la conformité avec le mode examen, mais cette fois-ci aussi bien en France que dans le monde ! :bj:

La solution retenue avec Omega 2.0.2 diffère donc de celle de Khi et Upsilon.

15449Le bootloader est maintenant capable de détecter si l'un des firmwares installés a été passé en mode examen.

La solution est beaucoup plus radicale ; dans ce cas les raccourcis reset+
1
et reset+
2
deviennent sans effet : c'est obligatoirement le firmware passé en mode examen qui sera amorcé.

Tu ne peux donc plus, en mode examen, disposer à la fois :
  • des dernières fonctionnalités d'Epsilon
  • des fonctionnalités Omega
Il te faudra donc bien choisir en début d'épreuve dans quel firmware tu actives le mode examen.

Si tu as installé Phi + Omega 2.0.0 sur ta machine, dans ton propre intérêt ainsi qu'afin d'éviter toute mise en danger d'un utilisateur futur à qui tu vendrais/prêterais ta calculatrice, nous te conseillons très fortement d'accepter cette restriction en mode examen et de mettre à jour vers Omega 2.0.2, vu que de toutes façons la vulnérabilité corrigée ne permettait déjà pas de tricher.

Attention, la vulnérabilité faisant partie du bootloader, il te faut obligatoirement effectuer la mise à jour avec le mode de récupération accessible via le raccourci reset+
6
; les mini-tutos suivent ci-dessous.

Supposons que tu dispose déjà d'une machine faisant tourner Phi + Omega 2.0.0 ou encore les versions avec bootloader de Khi ou Upsilon.

C'est facile à vérifier ; il te suffit de faire reset+
4
. L'aspect visuel ainsi que le logo peuvent varier, mais dans tous les cas tu obtiens un écran te listant le contenu des différents slots.

15450Pour remplacer le bootloader par le nouveau c'est extrêmement simple. Il te faut :
  1. mettre la machine en mode de récupération autorisant la réécriture du bootloader avec le raccourci reset+
    6

    (raccourci à ne plus jamais utiliser sur le site officiel si tu ne veux pas te retrouver à nouveau coincé, et peut-être cette fois-ci sans retour possible :#non#:)
  2. te rendre sur le site d'Omega
  3. cliquer sur le bouton Recovery pour charger et lancer le logiciel de récupération
  4. normalement la calculatrice se rallume automatiquement après quelques secondes ; utiliser alors le bouton Install Omega

Si par contre tu pars d'une calculatrice ne disposant pas encore d'un bootloader tiers, il suffit d'installer Phi qui a également été mis à jour de façon similaire à Omega 2.0.2.

Tutoriels d'installation :

Installation :
  1. Phi
  2. Omega ou Khi ou Upsilon
Lien vers le sujet sur le forum: Mise à jour Phi + Omega 2.0.2 pour conformité mode examen (Commentaires: 0)

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

Nouveau messagede critor » 18 Avr 2022, 17:10

12212Depuis 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é ! :bj:

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 ! :D

129591295812957Et 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 ! :bj:

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).
12277Les 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.

1296512964Pour 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

1296212961La 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

134501296113451Depuis 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 ! :bj:
  • mémoire de stockage Flash d'une capacité de 512 Kio au lieu de 256 Kio soit 2 fois plus grande ! :bj:
  • 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 ! :bj:

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
1344912962D'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

13453Expliquons 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 :

14956
Code: Tout sélectionner
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_audiomicrobit.audio (effets sonores - accessible via le menu Audio)
  • mb_butnsmicrobit.buttons (boutons A, B et tactile intégrés - accessible via le menu Buttons ou Boutons)
  • mb_dispmicrobit.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_musicmicrobit.music (haut-parleur à rajouter sur micro:bit v1 ou intégré sur micro:bit v2 - accessible via le menu Music ou Musique)
  • mb_neopxmicrobit.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_radiomicrobit.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 ! :bj:








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 :
Code: Tout sélectionner
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: Tout sélectionner
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 : :D
Code: Tout sélectionner
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 ! :bj:

Merci TI ! :favorite:

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

Source : https://resources.t3europe.eu/t3europe- ... 50b9bcfffa
Lien vers le sujet sur le forum: Bêta-test micro:bit v2.5.1 pour 83 Premium CE + drone Tello (Commentaires: 5)

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
"1 calculatrice pour tous", le programme solidaire de Texas Instruments. Reçois gratuitement et sans aucune obligation d'achat, 5 calculatrices couleur programmables en Python à donner aux élèves les plus nécessiteux de ton lycée. Tu peux recevoir au choix 5 TI-82 Advanced Edition Python ou bien 5 TI-83 Premium CE Edition Python.
Enseignant(e), reçois gratuitement 1 exemplaire de test de la TI-82 Advanced Edition Python. À demander d'ici le 31 décembre 2024.
Offre de test des nouveautés de rentrée 2024 par Casio. Enseignant(e), reçois gratuitement 1 exemplaire, à ton choix, de la Graph Light ou bien de la Graph Math+
14€ remboursés par Casio sur l'achat de ta calculatrice Graph 35 d'ici le 31 Octobre 2024
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 90+E d'ici le 31 Décembre 2024
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 25 d'ici le 31 Décembre 2024
8€ remboursés par Casio sur l'achat de ta calculatrice Graph Math+ d'ici le 31 Octobre 2024
Reprise de ton ancienne fx-92 Collège ou Graph 25/35/90 à 3€ peu importe son état. Même non fonctionnelle et donc invendable, même ancienne Graph 35 non conforme aux programmes (pas de Python), même ancienne Graph 25/35 inutilisable aux examens (pas de mode examen) et donc invendable. Etiquette de retour fournie, pas de frais de port à payer.
3€ remboursés par Casio sur l'achat de ta calculatrice fx-92 Collège d'ici le 30 Septembre 2024
5€ de remise immédiate sur l'achat de ta calculatrice TI-83 Premium CE Edition Python chez les revendeurs partenaires
4€ de remise immédiate sur l'achat de ta calculatrice TI-82 Advanced Edition Python chez les revendeurs partenaires
3€ de remise immédiate sur l'achat de ta calculatrice TI-82 Advanced chez les revendeurs partenaires
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
1234567891011121314
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
869 utilisateurs:
>822 invités
>43 membres
>4 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)