French translation issue microsoft#288 - Root folder translations & l…

…esson 2.1 (microsoft#297)

* - Added README.fr.md in the root folder
- Translated the whole leçon 2.1 <predict plant growth>

* just added the whole content

* small updates in root folder

* Unnecessary shields removed and some corrections have been made from Charles's review

* Translation of all lessons of the root README

* Translation of for-teachers.md

* Translation of hardware.md

* Translation of CODE_OF_CONDUCT.md

* Translation of CODE_OF_CONDUCT.md

* Implement suggested changes from the charles's PR review

* Implement suggested changes from the charles's PR review

* Implement suggested changes from the charles's PR review

* Implement suggested changes from the charles's PR review

* Changed the path to the translated README because they were not working from the translated ones

* Small change

* Resolved unworking links in hardware.fr.md

* Removed the shields where it was not necessary as Jim suggested

* small correction

* Removed the shields and comments as requested by Jim

* small update

Co-authored-by: Jim Bennett <[email protected]>

2-farm/lessons/1-predict-plant-growth/translations/assignment.fr.md

@@ -0,0 +1,43 @@
+# Visualiser les données DJC à l'aide d'un Jupyter Notebook
+
+## Instructions
+
+Dans cette leçon, vous avez recueilli des données DJC à l'aide d'un capteur IoT. Pour obtenir de bonnes données DJC, vous devez recueillir des données pendant plusieurs jours. Pour vous aider à visualiser les données de température et à calculer le DJC, vous pouvez utiliser des outils tels que [Jupyter Notebooks](https://jupyter.org) pour analyser les données.
+
+Commencez par recueillir des données pendant quelques jours. Vous devez vous assurer que le code de votre serveur fonctionne tout le temps que votre dispositif IoT est en marche, soit en ajustant vos paramètres de gestion de l'énergie, soit en exécutant quelque chose comme [ce script Python maintenant le système actif].(https://github.com/jaqsparow/keep-system-active).
+
+Une fois que vous avez les données de température, vous pouvez utiliser le Jupyter Notebook dans ce repo pour les visualiser et calculer le JDC. Les notebooks Jupyter mélangent du code et des instructions dans des blocs appelés *cellules*, souvent du code en Python. Vous pouvez lire les instructions, puis exécuter chaque bloc de code, bloc par bloc. Vous pouvez également modifier le code. Dans ce notebook par exemple, vous pouvez modifier la température de base utilisée pour calculer le JDC de votre installation.
+
+1. Créez un dossier `gdd-calcul` (GDD correspond à DJC en français)
+
+1. Téléchargez le fichier [gdd.ipynb](../code-notebook/gdd.ipynb) et copiez le dans le dossier`gdd-calcul`.
+
+1. Copiez le fichier `temperature.csv` créé par le serveur MQTT.
+
+1. Créez un nouvel environnement virtuel Python dans le dossier `gdd-calcul`.
+
+1. Installez quelques paquets pip pour les carnets Jupyter, ainsi que les bibliothèques nécessaires à la gestion et au tracé des données :
+
+    ```sh
+    pip install --upgrade pip
+    pip install pandas
+    pip install matplotlib
+    pip install jupyter
+    ```
+
+1. Exécutez le notebook dans Jupyter :
+
+    ```sh
+    jupyter notebook gdd.ipynb
+    ```
+
+    Jupyter démarre et ouvre le notebook dans votre navigateur. Suivez les instructions du carnet de notes pour visualiser les températures mesurées et calculer les degrés-jours de croissance.
+
+    ![Le jupyter notebook](../../../../images/gdd-jupyter-notebook.png)
+
+## Rubrique
+
+| Critère | Exemplaire | Adequat | À améliorer |
+| -------- | --------- | -------- | ----------------- |
+| Capture de données | Capture au moins deux journées de données | Capture au moins une journée de données | Capture des données |
+| Calcul du DJC | Exécute le notebook et calcul le DJC | Exécute le notebook | Incapable d'exécuter le notebook |

2-farm/lessons/1-predict-plant-growth/translations/pi-temp.fr.md

@@ -0,0 +1,111 @@
+# Mesure de temperature - Raspberry Pi
+
+Dans cette partie de la leçon, vous allez ajouter un capteur de température à votre Raspberry Pi.
+
+## Matériel
+
+La sonde que vous utiliserez est une [sonde d'humidité et de température DHT11](https://www.seeedstudio.com/Grove-Temperature-Humidity-Sensor-DHT11.html), combinant deux capteurs dans un même boîtier. Cette méthode est assez populaire, avec un certain nombre de capteurs disponibles dans le commerce combinant température, humidité et parfois pression atmosphérique. Le composant du capteur de température est une thermistance à coefficient de température négatif (CTN), une thermistance dont la résistance diminue lorsque la température augmente.
+
+Il s'agit d'un capteur numérique, qui dispose donc d'un ADC intégré pour créer un signal numérique contenant les données de température et d'humidité que le microcontrôleur peut lire.
+
+### Connecter le capteur de température
+
+Le capteur de température Grove peut être connecté au Raspberry Pi.
+
+#### Tâche
+
+Connecter le capteur de température
+
+![La sonde de température Grove](../../../../images/grove-dht11.png)
+
+1. Insérez une extrémité d'un câble Grove dans la prise du capteur d'humidité et de température. Il ne peut être inséré que dans un seul sens.
+
+1. Lorsque le Raspberry Pi est hors tension, connectez l'autre extrémité du câble Grove à la prise numérique marquée **D5** sur le chapeau de la base Grove fixé au Pi. Cette prise est la deuxième en partant de la gauche, sur la rangée de prises à côté des broches GPIO.
+
+![Le capteur de température de la rainure connecté à la broche A0](../../../../images/pi-temperature-sensor.png)
+
+## Programmez le capteur de température
+
+L'appareil peut maintenant être programmé pour utiliser la sonde de température jointe.
+
+### Tâche
+
+Programmer le Raspberry Pi.
+
+1. Brancher le Pi à l'alimentation et attendre la séquence de démarrage.
+
+1. Lancez VS Code, soit directement sur le Pi, soit en vous connectant via l'extension SSH à distance.
+
+    > ⚠️ Vous pouvez vous référer [aux instructions de configuration et de lancement de VS Code dans la leçon 1 si nécessaire].(../../../../1-getting-started/lessons/1-introduction-to-iot/pi.md).
+
+1. Depuis le terminal, créez un nouveau dossier dans le répertoire personnel de l'utilisateur `pi` appelé `temperature-sensor`. Créez un fichier dans ce dossier appelé `app.py` :
+
+    ```sh
+    mkdir temperature-sensor
+    cd temperature-sensor
+    touch app.py
+    ```
+
+1. Ouvrez ce dossier dans VS Code
+
+1. Pour utiliser le capteur de température et d'humidité, une librairie pip supplémentaire doit être installée. Depuis le Terminal dans VS Code, exécutez la commande suivante pour installer ce paquet Pip sur le Pi :
+
+    ```sh
+    pip3 install seeed-python-dht
+    ```
+
+1. Ajoutez le code suivant au fichier `app.py` pour importer les bibliothèques requises :
+
+    ```python
+    import time
+    from seeed_dht import DHT
+    ```
+
+    L'instruction `from seeed_dht import DHT` importe la classe de capteur `DHT` pour interagir avec un capteur de température Grove du module `seeed_dht`.
+
+1. Ajoutez le code suivant après le code ci-dessus pour créer une instance de la classe qui gère le capteur de température :
+
+    ```python
+    sensor = DHT("11", 5)
+    ```
+
+    Ceci déclare une instance de la classe `DHT` qui gère le capteur **D**igital **H**umidité et **T**température. Le premier paramètre indique au code que le capteur utilisé est le capteur *DHT11* - la bibliothèque que vous utilisez supporte d'autres variantes de ce capteur. Le deuxième paramètre indique au code que le capteur est connecté au port numérique `D5` du connecteur Grove de base.
+
+    > ✅ N'oubliez pas que toutes les prises ont un numéro de broche unique. Les broches 0, 2, 4 et 6 sont des broches analogiques, les broches 5, 16, 18, 22, 24 et 26 sont des broches numériques.
+
+1. Ajoutez une boucle infinie après le code ci-dessus pour interroger la valeur du capteur de température et l'imprimer sur la console :
+
+    ```python
+    while True:
+        _, temp = sensor.read()
+        print(f'Temperature {temp}°C')
+    ```
+
+    L'appel à `sensor.read()` renvoie un tuple d'humidité et de température. Vous n'avez besoin que de la valeur de la température, l'humidité est donc ignorée. La valeur de la température est ensuite imprimée sur la console.
+
+1. Ajoutez une petite mise en veille de dix secondes à la fin de la "boucle", car les niveaux de température n'ont pas besoin d'être vérifiés en permanence. Une mise en veille réduit la consommation d'énergie de l'appareil.
+
+    ```python
+    time.sleep(10)
+    ```
+
+1. Depuis le terminal VS Code, exécutez ce qui suit pour lancer votre application Python :
+
+    ```sh
+    python3 app.py
+    ```
+
+    Vous devriez voir des valeurs de température en sortie sur la console. Utilisez quelque chose pour réchauffer le capteur, par exemple en appuyant votre pouce dessus, ou en utilisant un ventilateur pour voir les valeurs changer :
+
+    ```output
+    pi@raspberrypi:~/temperature-sensor $ python3 app.py 
+    Temperature 26°C
+    Temperature 26°C
+    Temperature 28°C
+    Temperature 30°C
+    Temperature 32°C
+    ```
+
+> 💁 Vous pouvez trouver ce code dans le dossier [code-temperature/pi](../code-temperature/pi).
+
+😀 La réalisation de votre programme de capteur de température a été un succès !

2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.fr.md

@@ -0,0 +1,57 @@
+# Publier la température - Matériel virtuel IoT et Raspberry Pi
+
+Dans cette partie de la leçon, vous allez publier les valeurs de température détectées par le Raspberry Pi ou le dispositif IoT virtuel sur MQTT afin qu'elles puissent être utilisées ultérieurement pour calculer le DJC.
+
+## Publier la temperature
+
+Une fois la température lue, elle peut être publiée via MQTT vers un code "serveur" qui lira les valeurs et les stockera, prêtes à être utilisées pour un calcul de DJC.
+
+### Tâche - Publier la température
+
+Programmez l'appareil pour qu'il publie les données de température.
+
+1. Ouvrez le projet d'application `temperature-sensor` s'il ne l'est pas déjà.
+
+1. Répétez les étapes de la leçon 4 pour vous connecter à MQTT et envoyer la télémétrie. Vous utiliserez le même "broker" publique Mosquitto.
+
+    Les étapes sont:
+
+    - Ajout de la librairie pip de MQTT paho
+    - Ajouter le code afin de se conecter au broker MQTT
+    - Ajouter le code permettant de publier la télémètrie
+
+    > ⚠️ Consultez les [instructions pour la connexion à MQTT](../../../../1-getting-started/lessons/4-connect-internet/single-board-computer-mqtt.md) ainsi que les [instructions pour l'envoi de la télémétrie](../../../../1-getting-started/lessons/4-connect-internet/single-board-computer-telemetry.md) de la leçon 4 si nécessaire.
+
+1. Assurez-vous que le `client_name` reflète le nom de ce projet :
+
+    ```python
+    client_name = id + 'temperature_sensor_client'
+    ```
+
+1. Pour la télémétrie, au lieu d'envoyer une valeur de lumière, envoyez la valeur de température lue par le capteur DHT dans une propriété du document JSON appelée `temperature` :
+
+    ```python
+    _, temp = sensor.read()
+    telemetry = json.dumps({'temperature' : temp})
+    ```
+
+1. La valeur de la température n'a pas besoin d'être lue très souvent - elle ne changera pas beaucoup dans un court laps de temps, donc réglez le `time.sleep` à 10 minutes :
+
+    ```cpp
+    time.sleep(10 * 60);
+    ```
+
+    > 💁 La fonction `sleep` prend le temps en secondes, donc pour faciliter la lecture, la valeur est passée comme le résultat d'un calcul. 60s en une minute, donc 10 x (60s en une minute) donne un délai de 10 minutes.
+
+1. Exécutez le code de la même manière que vous avez exécuté le code de la partie précédente du devoir. Si vous utilisez un appareil IoT virtuel, assurez-vous que l'application CounterFit est en cours d'exécution et que les capteurs d'humidité et de température ont été créés sur les bonnes broches IO.
+
+    ```output
+    pi@raspberrypi:~/temperature-sensor $ python3 app.py
+    MQTT connected!
+    Sending telemetry  {"temperature": 25}
+    Sending telemetry  {"temperature": 25}
+    ```
+
+> 💁 Vous pouvez trouver ce code dans le dossier [code-publish-temperature/virtual-device].(../code-publish-temperature/virtual-device) ou encore [code-publish-temperature/pi](../code-publish-temperature/pi).
+
+😀 Vous avez publié avec succès la température en tant que télémétrie de votre appareil.

2-farm/lessons/1-predict-plant-growth/translations/virtual-device-temp.fr.md

@@ -0,0 +1,140 @@
+# Mesurer la température - Matériel virtuel IoT
+
+Dans cette partie de la leçon, vous allez ajouter un capteur de température à votre dispositif IoT virtuel.
+
+## Matériel virtuel
+
+Le dispositif IoT virtuel utilisera un capteur numérique d'humidité et de température Grove simulé. Ce laboratoire est donc identique à celui qui utilise un Raspberry Pi avec un capteur Grove DHT11 physique.
+
+Le capteur combine un **capteur de température** et un **capteur d'humidité**, mais dans ce laboratoire, vous n'êtes intéressé que par le composant capteur de température. Dans un dispositif IoT physique, le capteur de température serait une [thermistance] (https://wikipedia.org/wiki/Thermistor) qui mesure la température en détectant un changement de résistance lorsque la température change. Les capteurs de température sont généralement des capteurs numériques qui convertissent en interne la résistance mesurée en une température en degrés Celsius (ou Kelvin, ou Fahrenheit).
+
+### Ajouter les capteurs à CounterFit
+
+Pour utiliser un capteur d'humidité et de température virtuel, vous devez ajouter les deux capteurs à l'application CounterFit
+
+#### Tâche - ajouter les capteurs à CounterFit
+
+Ajoutez les capteurs d'humidité et de température à l'application CounterFit.
+
+1. Créez une nouvelle application Python sur votre ordinateur dans un dossier appelé `temperature-sensor` avec un seul fichier appelé `app.py` et un environnement virtuel Python, et ajoutez les librairies pip de CounterFit.
+
+    > ⚠️ Vous pouvez vous référer [aux instructions pour créer et configurer un projet Python CounterFit dans la leçon 1 si nécessaire](../../../../1-getting-started/lessons/1-introduction-to-iot/virtual-device.md).
+
+1. Installez une librairie pip supplémentaire afin d'installer une cale CounterFit pour le capteur DHT11. Assurez-vous que vous l'installez depuis un terminal avec l'environnement virtuel activé.
+
+    ```sh
+    pip install counterfit-shims-seeed-python-dht
+    ```
+
+1. Assurez-vous que l'application web CounterFit est en cours d'exécution.
+
+1. Créez un capteur d'humidité :
+
+    1. Dans la case *Create sensor* du volet *Sensors*, déroulez la case *Sensor type* et sélectionnez *Humidity*.
+
+    1. Laissez le paramètre *Units* à *Percentage*
+
+    1. Assurez vous que la variable *Pin* est à *5*
+
+    1. Sélectionnez le bouton **Add** pour créer le capteur d'humidité sur la broche 5
+
+    ![Paramètres du capteur d'humidité](../../../../images/counterfit-create-humidity-sensor.png)
+
+    Le capteur d'humidité sera créé et apparaîtra dans la liste des capteurs.
+
+    ![Le capteur d'humidité créé](../../../../images/counterfit-humidity-sensor.png)
+
+1. Créez un capteur de température :
+
+    1. Dans la case *Create sensor* du volet *Sensors*, déroulez la case *Sensor type* et sélectionnez *Temperature*
+
+    1. Laissez la variable *Units* à *Celsius*
+
+    1. Assurez vous que la variable *Pin* est à *6*
+
+    1. Sélectionnez le bouton **Add** pour créer le capteur de température sur la broche 6
+
+    ![Paramètres du capteur de température](../../../../images/counterfit-create-temperature-sensor.png)
+
+    Le capteur de température sera créé et apparaîtra dans la liste des capteurs
+
+    ![Création du capteur de température](../../../../images/counterfit-temperature-sensor.png)
+
+## Programmez l'application de la sonde de température
+
+L'application du capteur de température peut maintenant être programmée en utilisant les capteurs CounterFit.
+
+### Tâche - programmer l'application du capteur de température
+
+Programmez l'application du capteur de température.
+
+1. Assurez-vous que l'application `temperature-sensor` est ouverte dans VS Code.
+
+1. Ouvrez le fichier `app.py`.
+
+1. Ajoutez le code suivant au début de `app.py` pour connecter l'application à CounterFit :
+
+    ```python
+    from counterfit_connection import CounterFitConnection
+    CounterFitConnection.init('127.0.0.1', 5000)
+    ```
+
+1. Ajoutez le code suivant au fichier `app.py` pour importer les bibliothèques requises :
+
+    ```python
+    import time
+    from counterfit_shims_seeed_python_dht import DHT
+    ```
+
+    L'instruction `from seeed_dht import DHT` importe la classe de capteur `DHT` pour interagir avec un capteur de température Grove virtuel utilisant une shim du module `counterfit_shims_seeed_python_dht`.
+
+1. Ajoutez le code suivant après le code ci-dessus pour créer une instance de la classe qui gère le capteur virtuel d'humidité et de température :
+
+    ```python
+    sensor = DHT("11", 5)
+    ```
+
+    Ceci déclare une instance de la classe `DHT` qui gère le capteur virtuel **D**numérique **H**umidité et **T**température. Le premier paramètre indique au code que le capteur utilisé est un capteur virtuel *DHT11*. Le deuxième paramètre indique au code que le capteur est connecté au port `5`.
+
+    > 💁 CounterFit simule ce capteur combiné d'humidité et de température en se connectant à 2 capteurs, un capteur d'humidité sur la broche donnée lors de la création de la classe `DHT`, et un capteur de température qui se trouve sur la broche suivante. Si le capteur d'humidité est sur la broche 5, la cale s'attend à ce que le capteur de température soit sur la broche 6.
+
+1. Ajoutez une boucle infinie après le code ci-dessus pour interroger la valeur du capteur de température et l'imprimer sur la console :
+
+    ```python
+    while True:
+        _, temp = sensor.read()
+        print(f'Temperature {temp}°C')
+    ```
+
+    L'appel à `sensor.read()` renvoie un tuple d'humidité et de température. Vous n'avez besoin que de la valeur de la température, l'humidité est donc ignorée. La valeur de la température est ensuite imprimée sur la console.
+
+1. Ajoutez une petite mise en veille de dix secondes à la fin de la "boucle", car les niveaux de température n'ont pas besoin d'être vérifiés en permanence. Une mise en veille réduit la consommation d'énergie de l'appareil.
+
+    ```python
+    time.sleep(10)
+    ```
+
+1. À partir du terminal VS Code avec un environnement virtuel activé, exécutez ce qui suit pour lancer votre application Python :
+
+    ```sh
+    python app.py
+    ```
+
+1. Depuis l'application CounterFit, modifiez la valeur de la sonde de température qui sera lue par l'application. Vous pouvez le faire de deux façons :
+
+    * Entrez un nombre dans la case *Value* pour le capteur de température, puis sélectionnez le bouton **Set**. Le nombre que vous saisissez sera la valeur renvoyée par le capteur.
+
+    * Cochez la case *Random* et saisissez une valeur *Min* et *Max*, puis sélectionnez le bouton **Set**. Chaque fois que le capteur lit une valeur, il lit un nombre aléatoire entre *Min* et *Max*.
+
+    Vous devriez voir les valeurs que vous avez définies apparaître dans la console. Changez les paramètres *Value* ou *Random* pour voir la valeur changer.
+
+    ```output
+    (.venv) ➜  temperature-sensor python app.py
+    Temperature 28.25°C
+    Temperature 30.71°C
+    Temperature 25.17°C
+    ```
+
+> 💁 Vous pouvez trouver ce code dans le fichier [code-temperature/virtual-device](../code-temperature/virtual-device).
+
+😀 Votre programme de capteur de température a été un succès !