Notebook

Parcours 2 : des objets qui mémorisent¶

Rendez-vous à l'adresse : https://amazon.quick-pi.org/ pour apprendre à programmer vos objets connectés en Python en réalisant les activités du Parcours 2.

Copier ci-dessous le code d'accès personnel que vous avez obtenu :

.........

Lisez la présentation pour programmer en Python , écrire, tester puis valider votre programme avec l'interface de FranceIOI.

Au fur et à mesure que vous expérimentez et validez vos programmes par simulation pour chaque cdcf, recopier votre script dans les cellules de code vides ci-dessous...

Sommeil agréable :¶

Lisez la présentation du thermomètre, du Capteur de luminosité, du Microphone, des opérateurs de comparaison, des opérateurs logiques, de la boucle infinie, de l'instruction if/else, des LEDs et de la gestion du temps.

Écrire un programme qui toutes les 50ms, allume la LED verte si la température est entre 16 et 18 degrés inclus, et la LED rouge sinon. L'autre LED doit être éteinte.

Votre programme ne peut contenir qu'une seule fois l'instruction if.

In [ ]:

from quickpi import *

Écrire un programme qui toutes les 50ms, allume la LED verte si :

la température est entre 16 et 18 degrés inclus
la luminosité est inférieure ou égale à 10%

Il doit allumer la LED bleue si un seul des deux critères est validé, et la LED rouge si aucun ne l'est.

Votre programme ne peut contenir que deux fois l'instruction if.

In [ ]:

from quickpi import *

Écrire un programme qui toutes les 50ms, allume la LED verte si :

la température est entre 16 et 18 degrés inclus
la luminosité est inférieure ou égale à 10%
le volume de bruit est inférieur ou égal à 20

Il doit allumer la LED bleue si deux des trois critères sont validés, et la LED rouge si un seul ou aucun ne l'est.

Votre programme ne peut contenir que deux fois l'instruction if.

In [ ]:

from quickpi import *

Réveil matin :¶

Lisez la présentation du Capteur de luminosité, de la boucle répéter tant que ou jusqu'à avec l'instruction while, du buzzer, du bouton poussoir, de la manette et de la gestion du temps.

Écrire un programme qui teste la luminosité toutes les 50ms.

Dès qu'il fait jour, soit 15% de luminosité ou plus, il doit allumer le buzzer et se terminer.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour que le buzzer s'éteigne lorsque l'on appuie sur le bouton.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente, pour qu'à chaque fois que l'on éteint le buzzer, il se rallume 2 secondes après l'appui sur le bouton.

Le programme doit cependant se terminer en laissant le buzzer éteint, si au moment de rallumer celui-ci, le bouton et le centre du stick sont tous deux enfoncés.

Astuce : commencer un clic sur le bouton, se déplacer et relâcher le clic nettement plus loin permet de le laisser bloqué en position enfoncée.

In [ ]:

from quickpi import *

Secousses¶

Lisez la présentation des variables, de l'accéléromètre, de l'instruction if,, des opérateurs logiques, de la boucle infinie, du bouton poussoir, de la manette, de l'écran et de la gestion du temps.

Écrire un programme qui met une variable nombreSecousses à 0 au départ puis toutes les 50ms, teste si l'accélération en z dépasse 30m/s², et ajoute 1 à nombreSecousses. Le programme doit afficher la valeur de nombreSecousses juste après chaque modification.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour qu'il compte aussi une secousse dans l'autre sens, donc si l'accélération en z passe en dessous de -30m/s².

Le programme doit aussi remettre nombreSecousses à zéro lorsque l'on appuie sur le bouton.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour que le programme n'ajoute 1 à nombreSecousses que s'il l'accélération en z a d'abord dépassé 30m/s², avant de passer en dessous de -30m/s².

Le bouton de remise à zéro doit continuer à fonctionner à tout moment.

In [ ]:

from quickpi import *

Détecteur de mouvements :¶

Lisez la présentation des variables, de l'instruction if/else, des opérateurs logiques, de la boucle infinie, des LEDs, du capteur de distance, de la manette, de l'écran et de la gestion du temps.

Écrire un programme qui mesure la distance toutes les 500ms, et allume la LED si la distance mesurée est différente de la précédente distance.

La LED doit être éteinte juste avant la mesure suivante.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour que la LED ne s'allume que si la différence entre la nouvelle distance et la précédente est d'au moins 20cm, dans un sens ou dans l'autre.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour que l'on puisse régler et afficher la différence à partir de laquelle la LED s'allume.

Elle doit être à 20 au départ, augmenter de 1 si l'on appuie sur le bouton du haut, et diminuer de 1 si l'on appuie sur le bouton du bas, sans jamais passer en dessous de 1 ou au dessus de 100.

L'état des boutons doit être lu toutes les 500ms, au même moment que la distance.

In [ ]:

from quickpi import *

Sirène :¶

Lisez la présentation des variables, de l'instruction if/else, des opérateurs logiques, de la boucle infinie, de la boucle répéter tant que ou jusqu'à avec l'instruction while, du buzzer et de la gestion du temps.

Ecrire un programme qui joue une sirène : il commence par jouer une note à la fréquence 100Hz, puis joue des notes de plus en plus aigues, en augmentant de 100Hz toutes les 20ms.

Le programme doit repartir à la fréquence 100Hz après avoir atteint 1000Hz.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour qu'une fois la fréquence 1000Hz atteinte, on change de sens et diminue de 100Hz toutes les 20ms. Lorsque l'on atteint 100Hz, le programme reprend au début.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour que la durée des notes commence à 500ms, puis diminue de 10ms après chaque note.

La première note dure 500ms, la deuxième 490ms, etc. Après être arrivé à un délai de 10ms, on repart à 500ms.

In [ ]:

from quickpi import *

Applaudimètre :¶

Lisez la présentation du Microphone, de l'écran, des variables, de l'instruction if, de la boucle de répétition avec l'instruction for, de la boucle infinie et de la gestion du temps.

Écrire un programme qui toutes les 50ms, mesure le volume sonore, efface l'écran puis affiche un rectangle qui couvre toute la hauteur de l'écran (y de 0 à 32), et va du bord gauche x = 0, jusqu'à la position x = volume sonore.

Tracez également une ligne verticale sur toute la hauteur de l'écran, à la position x égale à la valeur de x la plus grande atteinte depuis le lancement du programme.

Par exemple si le volume sonore actuel est de 43, et que le volume maximum mesuré depuis le début du programme est 70, l'affichage doit être comme ceci :

6-applaudimetre/example_easy.png

In [ ]:

from quickpi import *

Écrire un programme qui effectue 128 étapes numérotées de 0 à 127, séparées de 50ms.

À chaque étape, il mesure le volume sonore et trace une ligne verticale, à x = numéro de l'étape, qui part du bas de l'écran (y=31) et a une hauteur égale à un tiers du volume sonore.

Une fois toutes les étapes effectuées, il doit tracer une ligne horizontale de x = 0 à x = 127, à la hauteur la plus haute atteinte parmi les étapes.

Ci-dessous à gauche, un exemple d'affichage pendant l'exécution, et à droite, un exemple à la fin de l'exécution.

In [ ]:

from quickpi import *

Modifier le programme pour qu'il affiche une ligne horizontale supplémentaire, de x = 0 à x = 127, à la hauteur correspondant à la moyenne des hauteurs atteintes parmi toutes les étapes.

Il s'agit de la somme des hauteurs divisée par le nombre d'étapes.

In [ ]:

from quickpi import *

Binaire :¶

Lisez la présentation du capteur de luminosité, de l'écran, du bouton poussoir, des variables, de l'instruction if/else, de la boucle de répétition avec l'instruction for, de la boucle infinie et de la gestion du temps.

Écrire un programme qui à chaque fois que l'on appuie sur le bouton, commence par afficher le texte "Enregistrement", puis mesure l'intensité lumineuse toutes les 100ms pendant 1s, et calcule la moyenne.

Si cette moyenne est d'au moins 50%, il affiche alors 1, sinon 0.

In [ ]:

from quickpi import *

Modifier le programme précédent pour qu'après l'appui sur le bouton, il lise 8 valeurs 0 ou 1 de cette manière, et affiche le nombre de valeurs 1 lues parmi les 8.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente pour qu'au lieu de compter simplement le nombre de 1, il convertisse la séquence de 0 et 1 en un nombre entre 0 et 255 de la manière suivante :

si le premier chiffre est 1 on ajoute 128,
si le deuxième est 1 on ajoute 64, etc.
et si le dernier est 1, on ajoute 1.

Ainsi la séquence 01010010 vaut 64 + 16 + 2 = 82.

In [ ]:

from quickpi import *

Bille :¶

Lisez la présentation des variables, de la boucle de répétition avec l'instruction for, de l'instruction if/else, des opérateurs logiques, de l'accéléromètre, de l'écran, des LEDs, et de la gestion du temps.

Écrire un programme qui affiche une bille sous la forme d'un cercle de diamètre 6.

Au départ, le centre de la bille doit être à la position x = 10, y = 16.

Le programme doit afficher aussi une ligne verticale au mileu (x = 64, y de 0 à 31).

Voici ce que cela donne.

7-bille/example_easy.png

Le programme doit tester l'accéléromètre toutes les 50ms pendant 3s.

À chaque fois, si l'accélération en x est strictement supérieure à 30, la bille se déplace de 2 pixels vers la droite, et si elle est est strictement inférieure à 30, elle se déplace de 2 pixels vers la gauche (Le programme doit effacer l'écran puis redessiner la bille et la ligne verticale).

Au bout de 3 secondes, si le centre de la bille est au milieu de l'écran, avec x entre 62 et 66 inclus, la LED verte s'allume, sinon la LED rouge s'allume.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente, en ajoutant la notion de vitesse de la bille.

Au départ, la vitesse est de 0.

Toutes les 50ms, le programme teste l'accéléromètre :

si l'accélération en x est est strictement supérieure à 30, la vitesse augmente de 1 sans dépasser 3,
si elle est strictement inférieure à 30, elle diminue de 1, sans aller en dessous de -3.

Ensuite, la bille se déplace du nombre de pixels correspondant à la vitesse :

vers la gauche si la vitesse est négative,
et vers la droite si elle est positive.

In [ ]:

from quickpi import *

Modifier le programme de la version précédente, pour ajouter la dimension verticale : en plus de se déplacer horizontalement, la bille doit se déplacer verticalement selon les mêmes conditions, mais sur la base de l'accélération en y.

Au départ le centre de la bille doit être à la position x = 10, y = 10.

Le programme doit afficher aussi une ligne horizontale à avec x de 0 à 127 et y = 16.

Après 3 secondes, si x est entre 62 et 66 inclus, et y entre 14 et 18 inclus, la LED verte s'allume , sinon la LED rouge s'allume.

In [ ]:

from quickpi import *

Les instructions utiles en Python :¶

Programmation :¶

Python permet de créer des programmes à partir d'instructions.

Par exemple, l'instruction droite() peut faire déplacer un robot d'une case vers la droite.

Un programme formé d'instructions les unes en dessous des autres, exécute ces instructions l'une après l'autre.

from robot import *

droite()
haut()
droite()

Le programme ci-dessus fait déplacer le robot vers la droite, puis vers le haut, puis de nouveau vers la droite.

>>> Mélodie

l'instruction if :¶

Avec l'instruction if, on peut exécuter une instruction uniquement dans certaines conditions.

if caseMarquee():
    peindre()

Par exemple, le programme ci-dessus teste le contenu de la case du robot, et ne la peint que si elle est marquée.

On peut aussi placer plusieurs instructions dans une instruction if, comme illustré ci-dessous :

if caseMarquee():
    peindre()
    droite()

>>> Secousses >>> Applaudimetre

l'instruction if/else¶

On peut utiliser une instruction if/else, pour effectuer des opérations différentes selon la situation. Par exemple :

if caseMarquee():
    peindre()
else:
    haut()

Dans le programme ci-dessus, si la case du robot est marquée, le robot la peint, sinon il ne la peint pas mais se déplace vers le haut.

>>> Sommeil agréable >>> Détecteur de mouvements >>> Sirène >>> Binaire >>> Bille

La boucle infinie :¶

On peut utiliser l'instruction while True : pour répéter sans fin une séquence d'instructions, comme dans l'exemple ci-dessous, qui allume et éteint une LED toutes les 500 millisecondes :

while True :
    allumerLED()
    attendre(1000)
    eteindreLED()
    attendre(1000)

L'instruction while True : exécute en boucle les instructions placées en dessous, indentées vers la droite, sans s'arrêter, jusqu'à ce que l'on interrompe l'exécution du programme.

Ce type de boucle est utile pour les programmes qui ne doivent jamais s'arrêter, par exemple le programme d'un système d'alarme, qui doit être actif en permanence.

>>> Sommeil agréable >>> Secousses >>> Détecteur de mouvements >>> Sirène >>> Applaudimetre >>> Binaire

Boucle de répétition avec l'instruction `for` :¶

Pour exécuter plusieurs fois la même instruction, on peut utiliser l'instruction for loop in range(...).

Par exemple, plutôt que de mettre 5 fois la même instruction :

droite()
droite()
droite()
droite()
droite()

On peut écrire la boucle suivante :

for loop in range(5):
    droite()

On peut aussi mettre plusieurs instructions dans une boucle :

for loop in range(5):
    droite()
    haut()

>>> Alternance >>> Show lumineux 1 >>> Avertisseur >>> Servo_chronométré >>> Applaudimetre >>> Binaire >>> Bille

Boucles imbriquées :¶

Il est possible d'utiliser des boucles imbriquées, c'est-à-dire que l'on peut mettre des boucles for, à l'intérieur d'autres boucles for.

Par exemple :

for loop in range(5):
    droite()
    for loop in range(3):
        haut()
    droite()

Ce programme répétera 5 fois un déplacement d'1 case vers la droite, 3 cases vers le haut et 1 case vers la droite.

>>> Show lumineux 2

Les opérateurs de comparaison :¶

Pour construire les conditions d’un test if, ou d’une boucle while, on peut utiliser des opérateurs de comparaison un peu comme en Mathématiques :

inférieur : a < b
supérieur : a > b
inférieur ou égal : a <= b
supérieur ou égal : a >= b
égal : a == b (attention, il faut deux signes =)
différent : a != b

Le résultat de telles comparaisons est un booléen True ou False.

Exemple d'un radar de recul :

from quickpi import *
while True :
    if readDistance("distance1") <= 50 :
        turnBuzzerOn()
    else :
        turnBuzzerOff()

A moins de 50 cm d'un obstacle le buzzer émet un son.

>>> Sommeil agréable

Les opérateurs logiques (booléens)¶

On peut tester deux conditions, et exécuter des instructions si l'une des deux est vraie, grâce à l'opérateur logique « ou ».

if ((colonne() < 0) or (colonne > 8)):
    peindre()

L'instruction au sein du bloc sera exécutée soit si la colonne est inférieure à 0, soit si elle est supérieure à 8.

Si l'on ne veut exécuter des instructions que si deux conditions sont vraies, on peut utiliser l'opérateur logique « et » avec le mot clé and.

Si l'on ne veut exécuter des instructions que si la conditions est fausse, on peut utiliser l'opérateur logique « non » avec le mot clé not.

>>> Sommeil agréable >>> Secousses >>> Détecteur de mouvements >>> Sirène >>> Bille

La boucle répéter tant que ou jusqu'à avec l'instruction `while` :¶

On peut utiliser une instruction while, comme dans l'exemple ci-dessous :

while not surTrou():
    droite()

L'instruction while exécute en boucle les instructions placés en dessous, indentées vers la droite, tant que la condition est vraie.

Si la condition est fausse dès le départ, les instructions ne sont jamais exécutées.

Ce type de boucle est utile lorsque l'on ne connaît pas à l'avance le nombre de répétitions.

Par exemple dans un cas comme ci-dessous, où l'on ne connaît pas le nombre de cases entre la bille et le trou où il faut la déposer.

>>> Réveil matin >>> Sirène

Variables :¶

Pour enregistrer une valeur à un moment du programme et l'utiliser plus tard, on utilise une « variable ». Il s'agit d'une zone dans mémoire de l'ordinateur, à laquelle on donne un nom, et dans laquelle on peut peut stocker une information pour l'utiliser plus tard.

On peut penser à une variable comme une boîte avec une étiquette, le nom de la variable.

Pour stocker une valeur dans cette variable, par exemple le nombre inscrit sur la case du robot, on fait comme ceci :

memoireRobot = nombreSurCase()

Plus tard, pour utiliser la valeur stockée dans cette variable, et par exemple l'écrire sur la case du robot, on fait comme ceci :

ecrireNombre(memoireRobot)

Après avoir enregistré une valeur dans une variable, on peut la modifier, par exemple, en lui ajoutant un nombre :

memoireRobot = memoireRobot + nombreSurCase()

>>> Secousses >>> Détecteur de mouvements >>> Sirène >>> Applaudimetre >>> Binaire >>> Bille

L'interface FranceIOI :¶

L'interface comporte deux onglets EXPÉRIMENTER et VALIDER, qui correspondent à deux modes d'utilisation différents.

>>> Mélodie

Ecrire un programme :¶

C'est à droite dans l'éditeur que vous allez écrire vos programmes en langage python.

Votre programme doit toujours commencer par la ligne from quickpi import *.

Cette ligne de code permet de pouvoir utiliser les fonctions spécialement définies pour le module QuickPi.

Les fonctions et mots clés disponibles sont répertoriés dans des listes déroulantes.

Ensuite, vous écrivez les instructions de votre programme les unes en-dessous des autres.

>>> Mélodie

Tester un programme :¶

L'onglet EXPÉRIMENTER est en quelque sotre un "bac à sable". Il vous permet de mener des expérimentations avec les composants et les fonctions disponibles dans l'interface.

Un ou des composants sont mis à votre disposition sur l'interface.

Vous pouvez tester ces composants en cliquant dessus pour changer leur état.

Exemple : cliquer sur une LED pour l'allumer.

Pour exécuter votre programme, cliquez sur le bouton en bas à gauche de l'écran.

N'importe quel programme que vous concevez est exécuté entièrement, avec une simulation visuelle ou auditive du fonctionnement des composants.

>>> Mélodie

Valider un programme :¶

Votre mission consiste à concevoir un programme qui permet d'effectuer la tâche demandée dans l'énoncé.

L'onglet VALIDER permet une validation automatique des programmes soumis : grâce à un test, le programme présent dans l'éditeur est automatiquement évalué.

Voici comment fonctionne ce test :

Une ligne du temps (en secondes) est présente pour chaque composant disponible.

Cette ligne du temps apparaît en gris lorsque le composant est activé pendant la période, sinon elle n'apparaît pas.

Au fur et à mesure de l'exécution du programme, un curseur se déplace horizontalement et vérifie que l'état des composants est conforme à ce qui est attendu.

Dans l'exemple, la LED doit être initialement éteinte (état OFF), puis allumée (état ON, ligne grise) entre les instants 0 et 3, puis à nouveau éteinte à l'instant 3.

>>> Mélodie

Les fonctions utiles des composants :¶

Gestion du temps :¶

sleep(milliseconds)

Cette fonction permet de stopper l'exécution du programme pendant une durée entrée en paramètre.

Cette durée est exprimée en millisecondes.

Exemple :

sleep(1000)

Pour stopper l'exécution du programme pendant une durée de 1 seconde.

>>> Sommeil agréable >>> Réveil matin >>> Secousses >>> Détecteur de mouvements >>> Sirène >>> Applaudimetre >>> Binaire >>> Bille

Buzzer :¶

Un buzzer est un composant qui produit un son lorsqu'il est soumis à un tension électrique.

Un buzzer possède deux états :

ON : le buzzer est soumis à une tension électrique, il sonne.

OFF : sans tension électrique, le buzzer reste silencieux.

Le son peut être toujours le même ou être paramétrable.

Fonctions disponibles :

turnBuzzerOn()

Cette fonction permet d'allumer le buzzer.
turnBuzzerOff()

Cette fonction permet d'éteindre le buzzer.
setBuzzerNote(buzzer, frequency)

Pour le buzzer entré en paramètre, cette fonction permet de produire un son à une fréquence donnée.

La fréquence est exprimée en Hertz.

Exemple :

setBuzzerNote("buzzer1", 264)

permet de jouer la note DO.

>>> Réveil matin >>> Sirène

LEDs ou diodes électroluminescentes :¶

Une LED est un composant qui émet de la lumière quand il est parcouru par un courant électrique.

Une LED possède deux états :

ON : le courant traverse la LED, elle est allumée :

OFF : il n'y a pas de courant, la LED est éteinte :

Une LED ne laisse passer le courant électrique que dans un seul sens.

On trouve des LEDs qui émettent de la lumière rouge ou de la lumière verte, ou d'autres couleurs encore.

Fonctions disponibles :

Les fonctions turnLedOn() et turnLedOff() permettent respectivement d'allumer et d'éteindre une LED.

Elles ne peuvent servir que lorsqu'il n'y a qu'une seule LED utilisée.
setLedState(led,state) :

Cette fonction permet d'allumer ou éteindre une LED.

Elle prend en paramètre le nom de la LED et l'état à considérer, True pour l'allumer, False pour l'éteindre.

Exemple :

setLedState("led1",True)

toggleLedState(led) :

Cette fonction permet d'inverser l'état de la LED entrée en paramètre sous forme de chaine de caractères.

Exemple :

toggleLedState("led1")

>>> Sommeil agréable >>> Détecteur de mouvements >>> Bille

Bouton poussoir¶

Un bouton poussoir est un élément qui possède deux états, relevé et enfoncé.

ON : le bouton est enfoncé :

OFF : le bouton est relevé :

Fonctions disponibles :

isButtonPressed()

Cette fonction renvoie True si le bouton est enfoncé, et False s'il est relevé.

Cette fonction est utilisée seulement lorsqu'il n'y a qu'un seul bouton pressoir sur le montage.

isButtonPressed(button)

Pour le bouton entré en paramètre sous forme de chaine de caractères, cette fonction renvoie True si le bouton est enfoncé, et False s'il est relevé.

Exemple :

isButtonPressed("button1")
```	

**>>> [Réveil matin](#reveil)  >>> [Secousses](#secousses)   >>> [Binaire](#binaire)**

Écran :¶

L'écran de ce module est un petit écran monochrome de (132 x 33) pixels qui permet d'afficher deux lignes de 16 caractères. Fonctions disponibles :

displayText(line1, line2)

Cette fonction permet d'afficher deux lignes de texte sur un écran.

Elle prend en paramètre une ou deux lignes à afficher, sous forme de chaines de caractères.

Le paramètre de la deuxième ligne est optionnel.

Exemple : avec le code

displayText("Hello", "World !")

on affiche Hello sur la première ligne, et World ! sur la deuxième ligne de l'écran.

drawRectangle(x0, y0, width, height)

Cette fonction permet de dessinner un rectangle plein dont :
- le coin du haut à gauche sera le pixel de coordonnées (x0, y0) ;
- et le coin du bas à droite sera le pixel de coordonnées (x0 + width, y0 + height).

drawLine(x0, y0, x1, y1)

Cette fonction permet de dessinner un segment entre le pixel de coordonnées (x0, y0) et le pixel de coordonnées(x1, y1).

clearScreen()

Cette fonction permet d'effacer l'écran.

drawCircle(x0, y0, diameter)

Cette fonction permet d'afficher un cercle sur l'écran.

Elle prend en paramètre les coordonnées (x0, y0) du centre du cercle et son diamètre en nombre entier de pixels.

>>> Secousses >>> Détecteur de mouvements >>> Applaudimetre >>> Binaire >>> Bille

Manette :¶

Une manette (stick en anglais) est un ensemble de 5 boutons, chacun correspondant à une direction : haut, droite, bas, gauche ou bien centre.

Il s'agit d'un seul composant, mais qui se programme comme 5 boutons différents :

"stick1.up" pour la direction haut de la manette "stick1"
"stick1.right" pour la direction droite
"stick1.down" pour la direction bas
"stick1.left" pour la direction gauche
"stick1.center" pour la direction centre

Par exemple pour tester si la direction haut est enfoncée, on utilise :

buttonState("stick1.up")

>>> Réveil matin >>> Secousses >>> Détecteur de mouvements

Capteur de distance :¶

Ce capteur permet de mesurer la distance sans contact à l'aide de transducteurs à ultrasons. Il a une portée de 3 centimètres à 5 mètres. Fonctions disponibles :

readDistance(range)

Cette fonction renvoie la distance captée par le capteur de distance entré en paramètre. Cette distance est exprimée en centimètres.

Exemple :

readDistance("range1")

>>> Instrument >>> Avertisseur >>> Détecteur de mouvements

Servomoteur :¶

Le Servomoteur est un petit moteur qui peut tourner précisément jusqu'à un angle donné, entre 0 et 180 degrés. On peut l'utiliser pour contrôler la direction des roues d'un petit véhicule, ou pour ouvrir ou fermer une barrière, etc.

Fonctions disponibles :

setServoAngle(servo, angle)

Cette fonction permet de modifier l'angle du servomoteur choisi. L'angle est exprimés en degrés, entre 0 et 180 degrés.

Exemple :

setServoAngle("servo1", 90)`

getServoAngle(servo)

Ce bloc permet de relire l'angle auquel on a réglé le servomoteur choisi. Ce n'est pas un capteur, mais simplement une mémorisation de la dernière valeur modifiée par une instruction.

On peut par exemple l'utiliser pour augmenter l'angle de 1 degré.

Exemple :

setServoAngle("servo1", getServoAngle("servo1") + 1)

>>> Servo_chronométré

Thermomètre :¶

Ce composant capte la température ambiante.

Il délivre un signal analogique en fonction de la température mesurée.

Fonctions disponibles :

readTemperature(thermometer)

Cette fonction renvoie la température captée par le thermomètre entré en paramètre.

Cette température est exprimée en degrés Celsius.

Exemple :

readTemperature("thermometer1")

Un curseur vous permet de simuler une température ambiante de 0°C à 60°C. Cliquez sur le thermomètre pour fairre apparaître le curseur à l'écran.

>>> Sommeil agréable

Capteur de luminosité :¶

Ce composant capte la quantité de lumière ambiante. Ce capteur basé sur une photo-résistance, compatible Grove, permet de détecter la présence de lumière. La tension de sortie analogique évolue de 0 à +Vcc suivant l'intensité lumineuse mesurée.

Fonctions disponibles :

readLightIntensity(lightSensor)

Cette fonction renvoie la luminosité captée par le capteur de lumière entré en paramètre.

Cette luminosité est exprimée en pourcentage de la luminosité maximale.

Exemple :

readLightIntensity("light1")

Un curseur vous permet de simuler une luminosité ambiante, de 0% (nuit complète) à 100% (luminosité maximale).

>>> Sommeil agréable >>> Réveil matin >>> Binaire

Microphone :¶

Ce composant permet de capter l'intensité sonore d'un bruit ambiant. Ce module détecteur de bruit compatible Grove est basé sur un micro électret amplifié par un LM358. Il peut être utilisé comme détecteur de niveau sonore ou comme micro.

Fonctions disponibles :

readSoundLevel(port)

Cette fonction renvoie le volume sonore capté par le microphone entré en paramètre.

Ce volume sonore est exprimé en décibels (dB).

Exemple :

readSoundLevel("mic1")

Un curseur vous permet de simuler un volume sonore ambiant, de 0 à 100 décibels (dB). Par exemple, 60dB peut correspondre au bruit d'une conversation.

>>> Applaudimetre

Accéléromètre :¶

Ce composant permet de capter l'accélération dont il fait l'objet dans un repère à 3 dimensions. Fonctions disponibles :

readAcceleration(axis)

Cette fonction renvoie l'accélération captée selon l'axe entré en paramètre.

Cette accélération est exprimée en m/s².

Exemple :

readAcceleration("z")

Trois curseurs vous permettent de simuler une accélération suivant les trois axes :

X : axe horizontal - abscisse
Y : axe horizontal - ordonnée
Z : axe vertical - cote

>>> Secousses >>> Bille

In [ ]:

Références aux programmes :¶

Contenus	Capacités attendues	Commentaires
Périphériques d’entrée et de sortie Interface HommeMachine (IHM)	Identifier le rôle des capteurs et actionneurs. Réaliser par programmation une IHM répondant à un cahier des charges donné.	Les activités peuvent être développées sur des objets connectés, des systèmes embarqués ou robots.

Contenus	Capacités attendues	Commentaires
Constructions élémentaires	Mettre en évidence un corpus de constructions élémentaires.	Séquences, affectation, conditionnelles, boucles bornées, boucles non bornées, appels de fonction.

Contenus	Capacités attendues	Commentaires
Utilisation de bibliothèques	Utiliser la documentation d’une bibliothèque.	Aucune connaissance exhaustive d’une bibliothèque particulière n’est exigible.

Ce document, basé sur du contenu de France-IOI, est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International.

Pour toute question, suggestion ou commentaire : eric.madec@ecmorlaix.fr

Parcours 2 : des objets qui mémorisent¶

Sommeil agréable :¶

Réveil matin :¶

Secousses¶

Détecteur de mouvements :¶

Sirène :¶

Applaudimètre :¶

Binaire :¶

Bille :¶

Les instructions utiles en Python :¶

Programmation :¶

l'instruction if :¶

l'instruction if/else¶

La boucle infinie :¶

Boucle de répétition avec l'instruction for :¶

Boucles imbriquées :¶

Les opérateurs de comparaison :¶

Les opérateurs logiques (booléens)¶

La boucle répéter tant que ou jusqu'à avec l'instruction while :¶

Variables :¶

L'interface FranceIOI :¶

Ecrire un programme :¶

Tester un programme :¶

Valider un programme :¶

Les fonctions utiles des composants :¶

Gestion du temps :¶

Buzzer :¶

LEDs ou diodes électroluminescentes :¶

Bouton poussoir¶

Écran :¶

Manette :¶

Capteur de distance :¶

Servomoteur :¶

Thermomètre :¶

Capteur de luminosité :¶

Microphone :¶

Accéléromètre :¶

Références aux programmes :¶

Boucle de répétition avec l'instruction `for` :¶

La boucle répéter tant que ou jusqu'à avec l'instruction `while` :¶