IDLabs-IoT Le site dédié aux objets connectés

Un site des laboratoires pédagogiques de l'école CampusID

Mois : novembre 2018

La technologie Arduino

Posted on 11 novembre 2018  in Non classé

 

La technologie Arduino

 

Sommaire

  1. Création de Arduino
  2. Motif du développement de la technologie
  3. Description de Arduino
  4. Les différents types de carte Arduino
  5. Où se procurer cette technologie ?
  6. Exemples d’application
  7. Phase d’expérimentation

 

 

  1. Création de l’Arduino

 

 

L’arduino est une marque fabriquant des cartes sur lesquelles se trouvent un microcontrôleur (d’abord des ATmega168, ATmega1280 ou ATmega8 pour les plus anciennes et des ATmega328, ATmega32u4 ou ATmega2560 pour les plus récentes versions), ainsi qu’un logiciel permettant de créer des programmes sous langage C et C++.

Il a été mis au point en Italie par Massimo Banzi et ses co-concepteurs, le nom vient du bar où ils avaient l’habitude de se réunir le Bar di Re Arduino.

En 2011, ils vendaient des versions à monter de la carte (avec le mode d’emploi) et au fil du temps ils ont fini par les envoyer directement assembler.

 

 

 

 

2 . Motif du développement de Arduino

 

 

L’Arduino a été développé dans le but de pouvoir permettre à n’importe quel type de particulier (que ce soit des programmeurs, scientifiques, professionnels, artistes ou même des amateurs et des étudiants) de pouvoir avoir une plateforme de développement pour mener à bien différents types de projet (scolaire, professionnel ou même pour le plaisir).

Avec ses prix abordables, sa facilité d’installation et d’utilisation, Arduino est une plateforme qui se veut être accessible pour tous.

 

 

  1. Description de l’Arduino

 

 

L’Arduino se divise en deux parties : une partie logiciel servant de plateforme de programmation et une partie hardware où l’on utilise une carte avec un microcontrôleur. La plateforme est basée sur une interface d’entrée et de sortie.

La carte possède un port permettant de pouvoir la connecter à un ordinateur, une prise pour l’alimentation, plusieurs pins (une partie analogique et une autre numérique) qui peuvent servir pour des manipulations en électronique et un microcontrôleur de type Atmega.

Le logiciel de programmation est assez basique en soit (voir l’image ci-dessous), le programme se note dans la partie blanche, une fois qu’il est fait dans les réglages on vérifie que le logiciel est connecté sur le bon port correspondant à la carte connecté à l’ordinateur et enfin on peut vérifier que le programme est bien écrit et le compiler pour le mettre en œuvre.

 

 

 

  1. Les différents types de cartes Arduino

 

L’Arduino Uno qui a été montré précédemment.

L’Arduino Nano qui est une version plus petite du Uno

L’Arduino Mega qui est plus grand que le Uno avec beaucoup plus de pins

L’Arduino Yún qui va servir pour les projets IoT

 

 

  1. Comment se procurer un Arduino ?

 

Pour se procurer une carte Arduino ou le logiciel tout se fait sur le site, il y a un onglet « store » pour les cartes.

Et un autre « software » pour télécharger le logiciel (disponible sur Windows, Linux et Mac) ou bien de l’utiliser en ligne si vous êtes inscrit sur le site.

 

  1. Exemples d’applications

 

On peut se servir d’Arduino pour plusieurs buts, par exemple le plus basique serait pour le pilotage de leds (en allumer et éteindre une ou plusieurs, faire un chenillard, les allumer pendant une durée déterminée), mais on peut aussi piloter des moteurs à courant continu ou pas à pas.

Durant mes TP j’ai programmé une carte Arduino pour pouvoir utiliser un luxmètre et un autre où avec deux capteurs de mouvements j’ai fait un « radar » qui pouvait mesurer la vitesse de déplacement d’un objet. Et pendant mon projet de terminale j’ai utilisé Arduino pour prendre les mesures venant d’un anémomètre et d’une girouette.

 

  1. Phase d’expérimentation

 

 

Description du cas d’étude :

Pour cette étude je vais écrire un programme sous langage C avec le logiciel Arduino pour piloter deux moteurs à courant continu.

Pour cela il me faut deux moteurs CC, des fils pour les souder sur l’entrée d’alimentation et la masse des moteurs, une plaquette de test, une carte de commande de moteur, un générateur, un Arduino Uno et un ordinateur avec le logiciel Arduino.

 

Résultat attendu :

Le résultat de l’expérience serait de pouvoir faire pivoter les deux moteurs dans le même sens ou dans des sens contraires en fonction des pins choisit dans le programme et sur la carte.

 

Codage :

// Pont en H L298N

//Ports de commande du moteur B
int motorPin1 = 8;
int motorPin2 = 9;
int enablePin = 5;

// Vitesse du moteur
int state = 0;

void setup() {
// Configuration des ports en mode "sortie"
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(enablePin, OUTPUT);

// Initialisation du port série
Serial.begin(9600);
}

void loop() {
if (Serial.available() > 0)
{
// Lecture de l'entier passé au port série
state = Serial.parseInt();

//
// Sens du mouvement
//
if (state > 0) // avant
{
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
Serial.print("Avant ");
Serial.println(state);
}
else if (state < 0) // arrière
{
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
Serial.print("Arriere ");
Serial.println(state);
}
else // Stop (freinage)
{
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, HIGH);
Serial.println("Stop");
}

//
// Vitesse du mouvement
//
analogWrite(enablePin, abs(state));
}
delay(100);
}

Résultat :

Avec le programme et le bon branchement entre la carte Arduino et les moteurs, ils tournent selon le sens où ont été placé les fils selon les pins réglé (s’ils sont inversés les moteurs vont tourner dans l’autre sens), mais si les deux moteurs sont tout les deux à l’état haut le programme les fera s’arrêter totalement (commande enable).

 

 

 

 

Source :

Wikipédia

Arduino

Arduino.BlaisePascal

 

[Top]

Mois : novembre 2018

Programmation d’un afficheur LCD sur Arduino

Posted on 11 novembre 2018  in Non classé

1 - Présentation générale de la technologie étudiée : 

 

a - qui a mis au point cette technologie ?

 

Il y a toujours des débats sur qui est l'inventeur des afficheurs à cristaux liquides mais  on sait que leurs premières utilisations concrètes remonte à 1985 ou Matsushita (aujourd'hui Panasonic) propose des écrans plat d’une taille et d'une résolution suffisante pour être utilisable sur des micro-ordinateurs, cependant on pourra voir l'apparition d'afficheurs LCD en couleur tout droit sorti des laboratoires de Thomson (Technicolor aujourd'hui) dès 1984.

Ce n'est qu'à partir de 1990 que les afficheurs LCD verrons leur utilisation proliférer dans une très large gamme d'électronique en tout genre et de toutes les formes, des téléphones portables en passant par les ordinateurs personnels jusqu'à la montre de poignet.

 

b - pour quelle raison cette technologie a été mise au point ? (quel était le besoin ?)

 

A l'aube des années 1900 l'électronique s'impose dans la vie de tout les jours et pour toutes les utilisations, l'air du tout digital est au coin de la rue et requière une façon plus compact pour afficher des digits, plusieurs technologies d'afficheurs compacts on vu le jour comme les afficheurs électroluminescent (afficheur LED), les afficheurs fluorescents, et bien sûr les afficheurs à cristaux liquides,

Mais là où les afficheurs électroluminescents étaient beaucoup trop coûteux en place, l'afficheur LCD s'est vu remporter la victoire face à l'afficheur LED dans son utilisation la plus rependue du fait de sa simplicité et l'absence de chaleur produite comparé au LED, mais surtout par son gain de place monumental ne prenant qu'à peine plus de place que affichage lui même.

 

c - description de la technologie

 

Description

Le Shield LCD KeyPad est un module développé pour pouvoir s’emboiter sur une carte Arduino et dispose même d’une bibliothèque avec certaines instructions de l’écran LCD sous forme de fonctions simplifiées pour la programmation. Il se compose d'un écran LCD 2x16 rétro éclairé bleu avec 1602 caractères blancs. Le clavier se compose de 5 touches : sélectionner, haut, droite, bas et gauche. Pour économiser les broches E / S numériques, l'interface du clavier utilise un seul canal CAN. La valeur de clé est lue à travers un diviseur de tension à 5 étages.

Fonctionnement

Le shield comprend un écran LCD  et 6 boutons poussoirs momentanés. Les broches 4, 5, 6, 7, 8, 9 et 10 sont utilisées pour l'interface avec l'écran LCD. La broche analogique 0 est utilisée pour lire les boutons poussoirs. L'écran LCD prend en charge le réglage du contraste et les fonctions d'activation / désactivation du rétro-éclairage. Il étend également les broches non utilisées autour de l’écran pour pouvoir les réutiliser.

 

 

d - où peut-on se procurer cette technologie ?

 

La programmation sur ces écrans ne requiers aucun pré requis, ici on utilisera un Shield LCD KeyPad Arduino mais les afficheurs doté des pins 1 à 7 du schéma ci-dessus peuvent marcher avec n'importe quel ordinateur/microcontrôleur.

Bien qu'étant fait avec utilisation d'un Arduino en tête, Arduino ne produisent pas leur modules mais il est possible de les trouver chez des revendeurs.

 

2 - Exemples d'applications

Pour cet exemple nous allons créer un programme simple qui va nous permettre d'afficher sur un lcd des menu navigable à l'aide de boutons.

Configuration des boutons

 

Comme dit précédemment, au lieu d’utiliser cinq pins digitaux, le Shield utilise uniquement le pin analogique A0, ce pin est équipé d’un CAN de type « Convertisseur à approximations successives ». Le CAN récupère un signale analogique de 0V à 5V et le convertis en un mot binaire de 0 à 1023. Le fonctionnement est simple, nous avons des boutons branché en parallèle avec une résistance différente à chaque entrée, quand on appuie sur un des boutons, on ferme le circuit et le 5V de l’Arduino va passer à travers toutes les résistances du circuit. De là, on utilisera un pont diviseur pour calculer la tentions de chaque boutons et avec ces valeurs il nous restera qu’à faire une règle de trois avec la valeur max du mot binaire (1023).

Chaque boutons aura donc une valeur différente ce qui nous permet d’avoir cinq boutons bien distinct les uns des autre et donc de pouvoir les programmer dans l’Arduino pour qu’il ait une fonction propre à eu même tout ça en utilisant qu’un seul pin.

Au niveau programme on pourra dire par exemple que : si le mot binaire est inférieur à 50, le bouton droit est pressé.

 

 

Écran LCD 16x2

C’est la partie principale du Shield LCD KeyPad, cet écran est de type « Cristaux liquides monochromes », ces écrans utilisent la polarisation de la lumière par des filtres polarisants dont on peut faire varier l’orientation en fonction du champ électrique. Du point de vue optique, l’écran à cristaux liquides est un dispositif passif : il n’émet pas de lumière, seule sa transparence varie, et il doit donc disposer d'un éclairage, le Shield dispose donc d’un panneau de DEL qui fournissent un éclairage rétro éclairé.

 

L’écran LCD dispose d’un contrôleur de points matriciel ST7066 de Sitronix qui contrôle chaque pixels de l’écran et qui permet la programmation de l’écran sur un microcontrôleur de 4 ou 8 bits, parmi ses fonctionnalités il nous est possible de d’afficher des caractères ascii, de créer de nouveau caractères, ou d’utiliser des instructions diverse comme du scrolling de texte, positionnement du curseur etc…

Charte des symboles Ascii 

La masse, le 5V et VO sont relié à un potentiomètre

Et ont ainsi pour fonction de contrôler le contraste de

L’écran, la broche RS « sélection de registre », permet

De changer entre le mode « instruction » et l’écriture

De symboles ascii et sera connecté au pin digital 8 de

L’Arduino, R/W nous permet de choisir entre envoyer

Des données au LCD ou d’en envoyer depuis l’écran,

Ce pin sera relié à la masse pour le maintenir en état

Bas ce qui correspond à uniquement envoyer des

Données au LCD, par la suite nous avons les pins de

Données que l’on passe à l’état HAUT ou BAS pour

Créer un mot binaire, ce mot binaire peut correspondre

À une instruction, ou à des symboles Ascii, pour le projet

On utilisera seulement quatre de ces pins la seule différence

Et qu’au lieu d’envoyer le mot binaire directement,

On enverra la première partie du mot puis

L’autre à la suite, le pin EN qui envoie le mot binaire à

L’écran afin de l’exécuter et qui sera relié au pin D9, et

Pour finir, les pins LED+ et LED- qui gèrent le rétro éclairage.

 

3 - Phase d'expérimentation 

a - description du cas d'étude et des résultats attendus

Au niveau programmation, les menus sont des fonctions contenues dans la boucle principale qui correspondent à différents écrans avec des instructions qui par la manipulation des boutons va rediriger la boucle d’un état à l’autre en incrémentant ou décrémentant une variable « menu » attaché à chacune des fonctions. De ce fait, si par exemple si l’utilisateur est dans le menu principal (menu=0), la pression du bouton droit peut avoir comme effet d’incrémenter la variable menu de 1 (menu=1) ainsi changeant d’écran, par exemple le mode manuel.

 

b - programmation

 

  • #include <LiquidCrystal.h> // Utilise la bibliotech LiquidCrystal
  • #include <RotaryEncoder.h>
  • LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

 

  • // Selectionne les pins utilisées pour le LCD (rs, enable, d4, d5, d6, d7

 

  • #define encoder0PinA 18 // Pin de l'encodeur n°1 horaire AttachInterrupt
  • #define encoder0PinB 19 // Pin de l'encodeur n°1 anti-horaire
  • #define encoder0PinC 20 // Pin de l'encodeur n°2 AttachInterrupt
  • #define encoder0PinD 21  // Pin de l'encodeur n°2 anti-horaire
  • #define btnRIGHT 0                   // Mappage des boutons
  • #define btnUP 1
  • #define btnDOWN 2
  • #define btnLEFT 3
  • #define btnSELECT 4
  • #define btnNONE 5
  • #define in1 24                             // Moteur n°1
  • #define in2 26                             // Moteur n°1
  • #define in3 28                             // Moteur n°2
  • #define in4 30                             // Moteur n°2
  • int menu = 0;                            // Var ref pour changement de menu
  • int adc_key_in = 0;                       // Lire les valeurs du CAN
  • int lcd_key = 0;                           // Défini des valeurs utilisé par le LCD et le keypad
  • int degreeSp = 0;                        // Map de L'azimut
  • int degreeSp1 = 0;                       // Map de L'elevation
  • long encoder0Pos = 0;                   // Incrementation de l'encodeur n°1
  • long encoder0Pos1 = 0;                 // Incrementation de l'encodeur n°2

 

  • int read_LCD_buttons() // Lit les boutons du shield keypad
  • {
  • adc_key_in = analogRead(0);  // Lit les valeurs du snignal analogique
  • if (adc_key_in > 1000) return btnNONE; // Attribue des tentions à des bp
  • if (adc_key_in < 50) return btnRIGHT;
  • if (adc_key_in < 250) return btnUP;
  • if (adc_key_in < 450) return btnDOWN;
  • if (adc_key_in < 650) return btnLEFT;
  • if (adc_key_in < 850) return btnSELECT;
  • return btnNONE; // Si aucun bp n'est pressé renvoie none
  • }

 

  • ////////////////////////////////////Au lancement /////////////////////////////////////////////
  • void setup()
  • {
  • begin(16, 2);                                              // Initialise l'écran LCD à 16 colonnes et 2 lignes
  • createChar(0, upArrow);                     // Crée le byte pour 4 nouveaux caractères
  • createChar(1, downArrow);
  • createChar(2, rightArrow);
  • createChar(3, leftArrow);
  • clear();
  • setCursor(3,0);                                // Définit la position du curseur
  • print("Bienvenue");
  • delay(2500);
  • clear();
  • pinMode(in1, OUTPUT);                            // Initialization des pins
  • pinMode(in2, OUTPUT);
  • pinMode(in3, OUTPUT);
  • pinMode(in4, OUTPUT);
  • pinMode(encoder0PinA, INPUT_PULLUP);
  • pinMode(encoder0PinB, INPUT_PULLUP);
  • attachInterrupt(3, doEncoder, RISING);
  • pinMode(encoder0PinC, INPUT_PULLUP);
  • pinMode(encoder0PinD, INPUT_PULLUP);
  • attachInterrupt(5, doEncoder1, RISING);
  • }

 

 

  • /////////////////////////////////////Chaine principale /////////////////////////////////////////
  • void loop()
  • {
  • if (menu==0)
  • {
  • setCursor(0,0);            // placer le curseur à la première ligne, première position
  • print("Elevation/Azimut"); // texte à afficher
  • setCursor(2,1);            // placer le curseur au début de la seconde ligne
  • print("Auto  Manuel");
  • setCursor(0,1);
  • write(byte(3));            // Affiche à l'écran le caractère 3
  • setCursor(15,1);
  • write(byte(2));            // Affiche à l'écran le caractère 2
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • switch (lcd_key) // selon le bouton appuyé ...
  • {
  • case btnRIGHT:
  • {
  • menu=menu+2;
  • clear();
  • print("//MODE: MANUEL//");
  • setCursor(0,1);                          // placer le curseur au début de la seconde ligne
  • print("////////////////");
  • delay(1500);
  • clear();
  • setCursor(0,0);
  • print("Ajust. Manuel");
  • break;
  • }
  • case btnLEFT:
  •               {
  • menu=menu+1;
  • clear();
  • print("///MODE: AUTO///");
  • setCursor(0,1);
  • print("////////////////");
  • delay(1500);
  •  clear();
  • break;
  • }
  • }
  • }

 

  • if (menu==1)
  • {
  • setCursor(0,0);
  • print("Elevation/Azimut");
  • setCursor(0,1);                    // placer le curseur au début de la seconde ligne
  • print("Ajust. Auto");         // texte d'accueil
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • switch (lcd_key) // selon le bouton appuyé ...
  • {
  • case btnSELECT:
  • {
  • menu=menu+2;
  • clear();
  • break;
  • }
  • }
  • }

 

  • if (menu==3)
  • {
  •  print("Quit.Ajust.Auto?");
  • setCursor(3,1);            // placer le curseur au début de la seconde ligne
  • print("OUI    NON");
  • setCursor(0,1);
  • write(byte(3));
  • setCursor(15,1);
  • write(byte(2));
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • switch (lcd_key)
  • {
  • case btnLEFT:
  • {
  • menu=menu-3;
  • delay(500);
  • clear();
  • break;
  • }
  • case btnRIGHT:
  • {
  • menu=menu-2;
  • clear();
  • break;
  • }
  • }
  • }

 

  • if (menu==2)
  • {
  • setCursor(0,1);
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • write(byte(3));
  • write(byte(2));
  • setCursor(3,1);
  • print(degreeSp);
  • print(" ");
  • setCursor(8,1);
  • write(byte(1));
  • write(byte(0));
  • setCursor(11,1);
  • print(degreeSp1);
  • print(" ");
  • switch (lcd_key)               // selon le bouton appuyé ...
  • {
  • case btnUP:
  • {
  • digitalWrite(in1, LOW);
  • digitalWrite(in2, HIGH);
  • break;
  • }
  • case btnDOWN:
  • {
  • digitalWrite(in1, HIGH);
  • digitalWrite(in2, LOW);
  • break;
  • }
  • case btnLEFT:
  • {
  • digitalWrite(in3, LOW);
  • digitalWrite(in4, HIGH);
  • break;
  • }
  • case btnRIGHT:
  • {
  • digitalWrite(in3, HIGH);
  • digitalWrite(in4, LOW);
  • break;
  • }
  • case btnSELECT:
  • {
  • menu=menu-2;
  • clear();
  • break;
  • }
  • case btnNONE:
  • {
  • digitalWrite(in1, LOW);
  • digitalWrite(in2, LOW);
  • digitalWrite(in3, LOW);
  • digitalWrite(in4, LOW);
  • break;
  • }
  • }
  • }
  • }

[Top]

Mois : novembre 2018

La carte Arduino UNO

Posted on 11 novembre 2018  in Non classé

 

Sommaire :

 

1) Présentation générale de la technologie étudiée

 

2.1) Pour quelle raison cette technologie a été mise au point ?    (Quel était le besoin) ?

2.3) Où peut-on se procurer cette technologie ?

2.2) Description de la technologie (éléments mis en œuvre et principe de fonctionnement)

 

3) Exemples d'applications

3.1) Phases d’expérimentation

 

4) Codage

5) Présentation des résultats

6) Conclusion

 

 

 

1) Présentation générale de la technologie

 

Arduino est une marque de cartes électronique, ce sont des cartes open source équipés de :

 

  • Un microcontrôleur fabriqué par Atmel,
  • Un port USB,
  • Des connecteurs d'entrés/sortie

 

Le projet Arduino a débuté en 2003 en tant que programme destiné aux étudiants de l’Interaction Design Institute Ivrée situé à Ivrée, en Italie, dans le but de fournir aux novices et aux professionnels un moyen simple et peu coûteux de créer des dispositifs qui interagissent avec leur environnement à l’aide de capteurs et d’actionneurs.

 

Le microcontrôleur permet, à partir d'événements détectés par des capteurs, de programmer et commander des actionneurs. La carte Arduino est donc une interface programmable.

 

 

 

 

La carte Arduino la plus utilisé et la plus accessible pour les débutants est la carte Arduino UNO, ce sera notre sujet principal

La conception matérielle (schémas électroniques et typons) est distribuée sous licence Creative Commons Attribution Share-Alike 2.5

Le code source de l'environnement de programmation et les bibliothèques embarquées sont disponibles sous licence LGPL.

 

2.1) Pour quelle raison cette technologie a été mise au point ? (Quel était le besoin) ?

 

La gamme de carte Arduino a était conçue pour le domaine des objets connectés, les possibilités d’utilisation sont très grandes, on peut :

Détecter un ou plusieurs événements (variation de température, mouvement, présence, distance …) et en fonction de ces événements, agir sur le monde réel à l'aide d'actionneurs (résistances chauffantes, moteurs ...), alors on peut presque tout faire :

 

  • Bras de robot,
  • Régulation de température,
  • Effets lumineux,
  • Instruments de musique,
  • Systèmes d'alarmes,
  • Et encore plus…

 

De nombreuses cartes additionnelles « Shields » ont été créées afin d'enrichir les potentielles applications, les seules limites sont notre imagination, le temps, et le budget (quelques dizaines d'euros suffisent au départ pour s'équiper) ce qui permet donc aux personnes débutantes qui ne connaissent rien au domaine des objets connectés, de ce lancer dedans.

2.3) Où peut-on se procurer cette technologie ?

 

On peut se procurer des cartes Arduino soit sur le site officiel, soit sur plusieurs sites de ventes de produits électroniques, qui vendent aussi des Shields et autres extensions pour les cartes Arduino. Les prix sont à peu près vers les 20 euros.

 

2.2) Description de la technologie (éléments mis en œuvre et principe de fonctionnement)

 

 

Voici la carte Arduino UNO avec la description de ses composants, nous allons nous intéresser aux entrées et sorties numériques/analogiques.

 

Numérique :

Chacun des broches D0 à D13 peut être configuré par programmation en entrée ou en sortie, nous pouvons donc avoir par exemple les connecteurs 2 et 3 configurés comme des entrées et les connecteurs 7, 8 et 9 configurés comme des sorties. Il est par conséquent possible de connecter côte à côte des capteurs logiques (interrupteurs par exemple) aux connecteurs 2 et 3 et des actionneurs aux connecteurs 7, 8 et 9. Les signaux véhiculés par ces connecteurs sont des signaux logiques, c'est-à-dire qu'ils ne peuvent prendre que deux états : HAUT (5 Volts) ou BAS (0 Volt), par rapport au connecteur de masse GND, qui lui est toujours, par définition, à 0 Volt.

 

 

 

 

 

Analogique :

Contrairement aux entrées/sorties numériques qui ne peuvent prendre que deux états HAUT et BAS, ces six entrées peuvent admettre un millier de valeurs (1024 exactement) analogiques comprises entre 0 et 5 Volts. Nous pourrons donc avoir des valeurs de tension précises à 5 mV près (≈ 5V/1024)

 

 

 

 

 

 

 

3) Exemples d’applications

Nous allons voir comment faire clignoter une LED avec une carte Arduino Uno, pour ce faire on va avoir besoin :

  • De la carte Arduino Uno
  • Une LED
  • Une résistance
  • Une plaque Labtec

Voici le câblage ci-dessous :

 

 

 

L’anode de la LED est reliée à la broche 8 (par exemple comme sur l’image) de la carte qui est configuré en sortie, ce qui nous permettra de modifier l’état de la LED, On relie aussi la cathode de la LED à la broche GND (masse).

 

3.1) Phase d’expérimentation :

 

Pour connaître la valeur de la résistance pour notre câblage, on se base sur les données suivantes :

 

  • VCC = 5V
  • VLed = 3V
  • ILed = 20mA
  • Calcul de la résistance : (5-3)/0.02 = 100 Ohms, il nous faudra une résistance de 100 ohms.

 

Avec ce montage, on sera capable de faire clignoter la LED, bien sûr la carte ne se contente pas uniquement de cela, on se contentera ce cet exemple.

 

4) Codage

 

Pour mettre du code dans la carte, on utilisera le logiciel officiel d’Arduino.

Voici à quoi ressemble le logiciel :

 

 

Le void setup() permet d’initialiser les broches en entrée ou en sortie, c’est une fonction qui tourne qu’une seule fois.

Le void loop() est la ou se trouve le programme principal, c’est ici que l’on va mettre les instructions pour faire clignoter la LED.

 

 

Voici le programme en complet, les instructions en gris précédé par un « // » indique que se sont des commentaires, très pratiques pour savoir ce que fais une ou plusieurs lignes de code, ou pour une autre utilisation.

On peut aussi modifier le programme pour avoir plusieurs LED qui s’allume les unes après les autres, mettre des conditions pour dire que si la LED 1 est allumé, on allume la LED 2 ect…

 

5) Présentation des résultats

 

Pour obtenir le résultat et le visualiser, il faut téléverser le programme vers la carte, pour ce faire il faut s’assurer que la carte est bien branchée en USB à l’ordinateur, il faut ensuite cliquer sur le bouton téléverser.

 

 

6) Conclusion

 

Si vous voulez découvrir le monde des objets connectés pour un bon rapport qualité/prix, la carte Arduino UNO est excellente car elle apporte de nombreuses possibilités dans ce domaine, et la communauté est extrêmement active et donne beaucoup de conseils et d’aide pour les personnes en besoin, il y’a aussi beaucoup de tutos pour les programmes et les datasheet de la carte pour comprendre mieux la comprendre.

 

Annexes :

 

Arduino uno Datasheet

 

[Top]

Mois : novembre 2018

le Raspberry Pi-GPIO

Posted on 11 novembre 2018  in Non classé

Le Raspberry Pi 

 

 

 

 

 

 

 

Sommaire 

 

  • présentation générale de la technologie étudiée 

 

  • qui a mis au point cette technologie ? 
  • pour quelle raison cette technologie a été mise au point ? (quel était le besoin ?) 
  • description de la technologie (éléments mis en œuvre et principe de fonctionnement) 
  • où peut-on se procurer cette technologie ?
     

 

 

  • phase d'expérimentation  

 

  • description du cas d'étude et des résultats attendus 
  • codage 
  • présentation des résultats 

 

 

 

 

 

 

 

 

 

 

 

Présentation générale de la technologie  

 

Qui a mis au point cette technologie ? 

 

Le Raspberry Pi est un nano-ordinateur monocarte à processeur ARM conçu par le créateur de jeux vidéo David Braben, dans le cadre de sa fondation Raspberry Pi. 

 

David Braben est un programmeur britannique de jeux vidéo connu pour avoir conçu le jeu vidéo Elite ainsi que ses suites. 

 

Pour quelle raison cette technologie a été mise au point ? 

 

Le but a été de concevoir une nouvelle plate-forme informatique accessible à tous autant par sa forme, que par son prix, et ses fonctionnalités. L’idée du Raspberry Pi est née et le produit fini a été lancé le 29 février 2012. 

 

 

 

 

 

 

 

 

 

 

 

Description de la technologie 

Spécification techniques : 

 

 

Voici leurs spécifications :  

  • Taille : 85.60 mm × 53.98 mm ; 
  • Poids : 45 g ; 
  • Processeur : 700 MHz ARM1176JZF-S core (ARM11) ; 
  • Système sur puce (Soc) : Broadcom BCM2835 ; 
  • Processeur graphique (GPU) : décodeur Broadcom VideoCore IV, API logicielle vidéo OpenGL ES 2.0, MPEG-2 et VC-1, décodage vidéo 1080p30 h.264/MPEG-4 AVC ; 
  • Mémoire (SDRAM) : 256 Mo [Modèle A] ou 512 Mo [Modèle B] partagée avec le processeur graphique ; 
  • Ports USB 2.0 : 1 [Modèle A] ou 2 [Modèle B]] ; 
  • Sortie vidéo : RCA Composite (PAL et NTSC) et HDMI (rev 1.3 & 1.4) 
  • Sortie audio : 3.5 mm jack, HDMI 
  • Unité de lecture-écriture de carte mémoire : SDHC / MMC / SDIO ; 
  • Réseau : 1 port réseau Fast Ethernet (10/100 Mbits/s) sur le [Modèle B]] uniquement ; 
  • Périphériques bas niveau : 8 × GPIO, UART, bus I²C, bus SPI ; 
  • Besoin en alimentation : 5 volt via MicroUSB ou GPIO ; 300 mA (1.5 W) [Modèle A] ou 700 mA (3.5 W) [Modèle B]. 

 

 

 

 

Ce qu'on peut y ajouter : 

De base, le Raspberry Pi est fourni sans boîtier, alimentation, clavier, souris ni écran. Ceci dans le but de minimiser les côuts et de pouvoir recycler d'autres matériels.  

Des boîtiers adaptés à la carte mère (dont certains sont originaux) sont disponibles sur la plupart des sites commercialisant le Raspberry Pi.  

Un chargeur de smartphone (micro-USB vers USB) convient parfaitement pour alimenter la carte.  

En utilisant la prise USB, on peut connecter de nombreux périphériques : disques durs externes, lecteur Blue-ray, clef wifi, webcam, imprimante...  

Pour les bidouilleurs, les ports d'entrées sorties série peuvent permettre l'interfaçage avec d'autres circuits électroniques (robots...).  

 

Ce que l’on peut faire : 

 

Même si à la base le Raspberry Pi est un gadget, il a suffisamment de capacités (512 Mo de mémoire, circuit graphique BMC Videocore 4) et de sorties (ports USB, ethernet) pour convenir à différentes utilisations : serveur, pare-feu... Certains l'ont même transformé en Super Nitendo, en alarme, émetteur radio FM, en liseur vocal de texte ou carrément en mini-hélicoptère.  

Il pourrait convenir pour petite machine bureautique, mais même s'il permet de lire correctement des vidéos, il n'est pas ultra rapide et surtout certains packages potentiellement utiles (flash...) pour le web ne sont pas forcément bien portés sous ARM.  

 

 

 

 

 

 

 

 

 

 

Système d’exploitation 

 

La fondation Raspberry Pi recommande d'utiliser Raspbian, une distribution GNU/Linux optimisée pour le matériel du Raspberry Pi. Raspbian est basée sur Debian, embarquant l'environnement de bureau LXDE et le navigateur web Midori.  

D'autre distributions GNU/Linux ont été testées avec succès avec le Raspberry Pi. C'est le cas de Slackware, Arch et Gentoo dans leur version destinée au processeurs ARM. Red Hat recommande d'utiliser Raspberry Pi Fedora Remix et les debianeux s'orienteront vers Raspbian.  

Android fonctionne également sur le Raspberry Pi. 

 

Où peut-on se procurer cette technologie ? 

Le prix sont approximativement de 25 euros pour le modèle A et de 35 euros pour le modèle B. Le fondation Raspberry Pi ne vend pas elle même son joujou mais passe par des partenaires commerciaux. Un des principal est Farnell, qui commercialise également sous les noms Element14 et Newark. Farnell distribue également grâce à un réseau de revendeurs tels que Kubii (France), Minifo (Belgique) ou Digitec (Suisse).  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Phase d'expérimentation 

 

L’experimention que j’ai choisis de montrer est l’allumage d’une lampe LED  l’aide des entrées et sorties GPIO du raspberry et d’un programme en pyhon. 

 

1) Prérequis : 

Pour faire clignoter une LED à l'aide d'un Raspberry Pi, il vous faut : 

  • Un Raspberry 
  • Des leds 
  • Des resistances 
  • Des cables 

 

2) Branchement d'une LED au Raspberry 

Pour relier la LED au Raspberry Pi, on va avoir besoin d'une résistance. En effet, les LEDs fonctionnent avec une tension et une intensité donnée par le constructeur. Voici donc comment bien choisir sa résistance.  

 

 

 

 

 

 

 

 

 

 

 

 

Pour savoir quelle valeur optimale de résistance choisir, il suffit d'appliquer les lois des mailles et d'ohm comme sur le schéma ci-contre. 

 

 

Pour une led fonctionnant en 2V, 20mA, il faudra donc :
R = (5-2.3)/0.03
= 90Ω
Si la valeur de résistance calculée n'existe pas, prendre la résistance qui a la valeur la plus proche  

 

 

 

 

 

 

 

 

Schéma de cablage:  

 

 

 

3) Création du fichier Python .py 

 

Une fois que tout est branché, vous pouvez démarrer votre Raspberry Pi, et vous connecter avec un clavier/souris ou par SSH pour écrire votre premier programme en Python sur le Raspberry Pi.
Commençons par créer un fichier. Le système Raspbian étant une distribution de Linux, les commandes entrées sont des commandes Linux que vous connaissez peut-être déjà Utilisez simplement la commande : 

sudo nano nomFichier.extension 

On peut par exemple appeler le programme comme suit : 

sudo nano led.py 

Cette commande crée le fichier led.py dans le répertoire principal(/home/pi par défaut) et l'ouvre dans un éditeur de texte. 

 

 

 

 

 

 

 

4) Ecriture du programme python 

 

5) Enregistrement du programme écrit 

 

Une fois que nous avons fini l'édition du fichier, on doit l'enregistrer et quitter l'éditeur. Pour se faire, on appuie sur Ctrl+X, sur y (pour yes) (et o si le Raspberyr Pi est en français) et enfin sur la touche enter du clavier. On retourne donc dans l'invite de commande et nous avons fermé l'éditeur de texte. 

 

6) Exécution du programme Python 

 

Pour lancer le programme que nous avons créé, il suffit d'entrer : 

sudo python led.py 

Par conséquent, la commande générale pour lancer un programme Python est : 

sudo python nomFichier.py 

 

 

Source: 

  • lea-linux.org 
  • Wikipedia 
  • espace-raspberry-francais.fr 

 

 

 

     

[Top]

Mois : novembre 2018

GPS-Arduino

Posted on 9 novembre 2018  in Non classé

Présentation du GPS

La Société qui a mis au point le GPS EM-506 est la Société SiRF Technology, Inc. qui a été un pionnier dans l'utilisation commerciale de la technologie GPS pour les applications grand public. La société a été fondée en 1995 et son siège se trouvait à San Jose, en Californie. La société britannique CSR plc fait l'acquisition de la société en 2009, qui a ensuite été rachetée par la société américaine Qualcomm le 13 août 2015.

 

1 - Qui a créer ce GPS?

SiRF a fabriqué une gamme de jeux de puces GPS et de logiciels brevetés pour les appareils et systèmes de navigation grand public. Les pucessont basées sur des contrôleurs ARM intégrés à des récepteurs radio à faible bruit pour décoder les signaux GPS à des niveaux de signal très faibles (généralement-160 dBm). Les puces SiRF prennent également en charge SBAS pour permettre des positions corrigées de manière différentielle.

 

 

CSR plc : CSR plc (anciennement Cambridge SiliconRadio) situ au Royaume-Uni. Ses principaux produits étaient la connectivité, l'audio, l'imagerie et les puces de localisation. CSR faisait partie de l’indice FTSE 250 jusqu'à son acquisition par Qualcomm en août 2015.

 

 

Qualcomm : Qualcomm Incorporated est une multinationale américaine spécialisée dans les équipements de semi-conducteurs et de télécommunications qui conçoit et commercialise des produits et des services de télécommunications sans fil.

 

 

ARM : ARM, anciennement Advanced RISC Machine, à l'origine Acorn RISC Machine, est une famille d'architectures RISC (Réduit Instruction Set Computing) pour processeurs informatiques, configurées pour différents environnements.

 

 

SBAS : L'augmentation d'un système global de navigation par satellite (GNSS) est une méthode permettant d'améliorer les attributs du système de navigation, tels que la précision, la fiabilité et la disponibilité, grâce à l'intégration d'informations externes dans le processus de calcul. Il existe de nombreux systèmes de ce type et ils sont généralement nommés ou décrits en fonction de la manière dont le capteur GNSS reçoit les informations externes.

 

 

 

 

2-Pour quoi créer ce genre de GPS ? Description du GPS.

 

Ce système a été mis au point pour pouvoir être utiliser avec un carte Arduino, qui permet au novice de s’exercer à la programmation, et ainsi pouvoir géolocaliser l’appareil qui contient la carte Arduino.

Le GPS EM-506

 

Le GPS basée sur le chipset SiRF spectaculaire StarIII. Il possède une régulation de la tension intégrée, un indicateur d'état à LED, une RAM sauvegardée sur batterie et une antenne patch intégrée et un câble d'interface à 6 broches inclus.

SiRF Technology, Inc : été un pionnier dans l'utilisation commerciale de la technologie GPS pour les applications grand public.

Chipset :  est un jeu de composants électroniques inclus dans un circuit intégré préprogrammé permettant de gérer les flux de données numériques entre le ou les processeur(s), la mémoire et les périphériques.

 

Le GPS EM-506 est un appareil ou composant qui possède une faiblesse mais qui est aussi son point fort c’est la sensibilité. Il consomme une faible énergie qui est de 3.3V. Ce GPS permet de faire beaucoup de chose n’importe où, tout ça grâce a la sensibilité que possède cet appareil. On peut connaitre notre position dans une ville à forte onde, dans un environnement avec peu de signal et beaucoup de végétations. Grâce à la technologie SiRF CGEE (Client Generated Extended Ephemeris) le GPS peut prédire la position des satellites jusqu’à trois jours et un temps de démarrage CGEE inférieur à 15 secondes dans la plupart des conditions, sans assistance réseau.

 

 

3 - Caractéristiques du GPS EM-506

 

Le GPS possède un câble a six broches qui lui permet de se connecter à une carte qui possède un port adapter, une carte tel que la SparkFun. Les 6 broches représentent le ground, la puissance, le RX et le TX, un ground et une directive.

 

Les broches RX et TX : Ces broches permettent d’exécuter le programme et transmet ces consignes de l’Arduino à la carte SparkFun.

La puissance : Permet de transmettre l’énergie que le GPS a besoin (3.3V).

 

 

Le GPS possédé une certaine résistance aux températures ainsi que les condition météorologique : La carte SparkFun est une carte créer pour le GPS en question, elle possède un port pour y branche le GPS.

 

 

 

 

4 - Branchement des Composants

Pour brancher le GPS à la carte SparkFun il suffit juste de relier le câble du GPS au port adapte sur la carte SparkFun. Par la suite il existe deux sortes de branchement possible entre la carte GPS et la carte Arduino, elles sont :

 

 

 

 

1ère solution : On peut utiliser une plaquette et des fils pour avoir la possibilité de voir ce qu’il se passe si l’on débranche un des fils lors de l’exécution du programme.

 

 

 

2ème solution : on peut directement brancher la carte GPS a la carte Arduino en la pluggant grâce aux broches que la carte GPS possède car elles sont faites pour correspondre aux broches de l’Arduino.

 

 

 

 

 

 

 

 

5 - Création du GPS ?

 

Création d’un GPS :

 

 

Il faut donc commencer la création d’un système de localisation en latitude et longitude.

Mais avant sa petite parenthèse :

Les pins 2 et 3 de l’Arduino pour les ports RX et TX car les pins 1 et 2 sont utiliser pour l’exécution du programme.TinyGPS est une librairie qui possède des méthodes pour extraire la position, la date, l’heure, la vitesse facile à utiliser.Mais TinyGPS++ est beaucoup plus simple à utiliser que TinyGPS. Elle possède une librairie qui permet d’extraire les données prioritaires et arbitraires.

 

6 -Création d’une horloge

 

 

Par la suite il faut créer une horloge dans le GPS pour éviter d’utiliser un composant RTC. Cette horloge affiche désormais l’heure et la date.Puis, il faut concevoir un moyen qui permet de prévenir si le programme ne reçoit aucune information du GPS.

 

 

 

 

 

Le GPS affiche de nouvelles infos à chaque donnée reçue.Si le GPS ne reçoit pas de données pendant 5000 millisecondes il envoie, qu’il ne détecte aucun module GPS. Il enverra qu’il ne détecte pas le GPS.

 

 

 

Et après avoir lancé le programme le GPS affiche les résultats dans le moniteur série :

                              

 

 

Conclusion :

Si vous êtes intéresser par ce GPS pour vos futur projets, il est facile de le trouver sur internet, ainsi que ces datasheet. Ce GPS est très utile pour les débutants en programmation, Il est assez puissant pour être utiliser pour des projets comme un ballon sonde ou autres.

 

[Top]

Mois : novembre 2018

Le Voice Kit d’AIYproject et recast.ai

Posted on 4 novembre 2018  in Non classé

“ Do-it-yourself intelligent speaker ”

Introduction

 

            Depuis leurs sorties sur le marché en 2016 pour la plupart, les assistants vocaux font parler d’eux. Que l’on soit enthousiaste à leur propos ou très réticent à l’idée de faire entrer ces objets dans son domicile, on ne peut pas passer à côté. De nombreuses entreprises ont sorti leur propre assistant, le choix entre le Google Assistant, Siri d’Apple, Alexa d’Amazon ou encore Cortana de Microsoft est large en prenant en compte que ces derniers ne sont pas si différents lorsque l’on se penche sur leurs capacités.

On remarque très rapidement que les fonctionnalités sont plutôt limitées. Il faudra presque obligatoirement relier son assistant à des plateformes de streaming par exemple ou ajouter d’autres fonctionnalités développées par des particulier pour s’en servir pleinement et non seulement pour connaître la météo et les nouvelles du matin.

Dans ce cas, pourquoi ne pas faire son propre chatbot vocal ? Contrairement à ce que l’on peut penser, c’est une technologie assez accessible, il y a même plusieurs possibilités si on souhaite se lancer dans ce projet d’assistant personnel.

Après quelques recherches, on peut trouver une dizaine de solutions, gratuites ou non mais surtout parfois livrées clé en main. Nous nous intéresserons à ce dernier type ici.

Dans un premier temps, nous porterons notre attention sur le AIY Voice Kit de Google à construire soit même en quelques heures seulement. Nous verrons d’abord ce que propose Google, en quoi consiste ce kit et s’il est intéressant pour quelqu’un qui souhaiterait fabriquer et développer son propre assistant.

Ensuite, nous verrons ce qu’est un chatbot plus en détail afin de mieux comprendre cette nouvelle technologie qui intéresse tant. Il s’agira aussi de démystifier ces assistants « intelligents ». Nous nous intéresserons d’ailleurs à Recast.ai, une plateforme qui permet de développer facilement des bots.

Enfin, nous nous pencherons sur la construction du kit, sa construction et son utilisation.

 

Le AIY Voice Kit

I - Ce que propose Google

 

 

            Google s’est fait une joie de penser aux personnes qui aiment encore bidouiller dans leur coin en plus de programmer en sortant un kit pour construire son propre Home Assistant. Le SDK (kit de développement logiciel ou software developpement kit en anglais) avait déjà été mis à disposition en open source tout comme Amazon avait ouvert son « Alexa Skills kit » aux développeurs.

Google propose un certain nombre de petits kits dans la série des « AIY Projects » presque sous forme de jouets pour enfant, livrés clé en main pour réaliser vos propre assistants domotiques, détecteur d’animaux ou même un « détecteur de joie » qui, en scannant le visage d’une personne, pourra déterminer si la personne est heureuse ou non. Si ces gadgets ne sont pas forcément indispensables, ils deviennent très intéressants lorsque l’on peut les construire et/ou programmer soit même.

Il existe donc deux kits chez Google, le vision kit qui permettra de détecter des images mais aussi de les analyser et le Voice Kit auquel nous nous intéresserons ici.

Dans la présentation du projet du produit, on nous promet une installation complète en une heure et demi, pas de matériel particulier à avoir si ce n’est une Rapsberry Pi et une utilisation qui n’a apparemment rien à envier à son grande frère le Google Home ou tout autre Home Assistant.

Comme dit précédemment, les chatbots sont une technologie d’avenir. Ils permettent d’automatisés toutes sortes de tâches ennuyeuses à effectuer, de déléguer une partie de son travail qui ne nécessite pas ou peu de réflexion. Il s’agira cependant d’utilisation les chatbots intelligemment puisque, contrairement à ce que l’on pourrait nous vendre, ces assistants sont tout sauf intelligents.

L’avantage en construisant son propre Home Assistant est qu’il sera entièrement personnalisé et personnalisable.

Effectivement, tout comme le Home Assistant classique, que ce soit Google ou non, notre home-mode assistant aura du mal à se suffire à lui-même. S’il n’est pas associé à d’autres objets connectés ou comptes de streaming, l’utilisateur aura vite fait le tour de ses possibilités.

On a aussi pu voir depuis de nombreux détournements du Voice Kit comme une machine à cocktails.

II – La découverte du kit

 

            Le Voice Kit semble à première vue plutôt succin, la Rapsberry Pi est à placée dans une boite en carton surplombée par un gros bouton très semblable à la boite du film « The Box » en moins inquiétante tout de même qui servira à communiquer avec l’Assistant. Contrairement aux Home Assistants classique qui écoutent en permanence en attendant de capter le « trigger word », par exemple « Ok Google ! » pour le Google Home. Une partie des plus réticents à l’idée d’être potentiellement espionnés en permanence seront peut-être plus convaincus par cet assistant home-made.

On peut déjà penser, si notre nouveau Home Assistant nous plait réellement, à remplacer la boite en carton pour un autre contenant imprimé grâce à une imprimante 3D par exemple.

Le Voice Kit se constitue de 1- un Voice HAT accessory board, 2- un Voice HAT microphone board, 3- des entretoises en plastique, 4- un haut parleur, 5- un bouton type Arcade, 6- des câbles fils pour le bouton, 7- des câbles 5 fils, 8- le boitier en carton, 9- un support interne en carton, 10- une led pour le bouton, 11- un interrupteur pour le bouton et 12- un support de la led du bouton.

Nous retrouverons tous ces éléments lorsque nous verrons la réalisation et la construction du kit.

 

I – Qu’est-ce qu’un chatbot ?

 

            Intéressons-nous un instant à ce qu’est un chatbot aussi appelé « agent conversationnel » qui n’est autre que la base de notre nouvel assistant. C’est un programme qui donne l’illusion à l’utilisateur qu’il a un dialogue intelligent avec une machine. Les agents conversationnels fonctionnent souvent à l’aide de mots déclencheurs (ou trigger warning), on connaît tous le « Ok Google ! » par exemple, mais aussi des expressions pour retrouver les réponses qu’attend l’utilisateur.

On se base par ailleurs souvent sur le test de Turing pour déterminer si on est en entrain d’interagir avec une machine ou une personne.

On peut aussi évoquer l’effet ELIZA c’est-à-dire la tendance à assimiler de manière inconsciente le comportement d’une machine à celui d’une personne. Par exemple, si un agent conversationnel dit « Merci ! » à la fin d’une phrase, l’utilisateur pensera que ce dernier exprimer de la gratitude alors qu’il exécute seulement le programme qu’on lui a assimilé. Aussi, on aura souvent tendance à remercie le chatbot lorsqu’il répond de manière positive à une demande.

D’autres programmes ont été inspiré d’ELIZA, on peut citer ECTOR et ALICE qui sont aussi des logiciels de robot parlant mais ne sont pas en mesure de passer le test de Turing.

Les chatbots ne sont pas capables d’émettre des émotions ou des pensées personnelles, cependant, les développeurs ajoutent souvent des phrases de réponses pour donner cette impression de réel et d’intelligence artificielle.

Par ailleurs, l’agent conversationnel n’a pas besoin de comprendre ce que l’utilisateur dit, il doit seulement analyser des mots clé. On peut cependant remarquer que certain chatbot vont plus loin en détectant aussi les intentions de l’utilisateur, en analysant cette fois-ci la façon dont est posée une question.

Aussi, un chatbot ne veut pas dire « intelligence artificielle », même avec un peu de machine learning et un mix de technologie, on est encore loin d’une machine intelligente. C’est d’ailleurs là tout le souci de publicité mensongère sur la vente de Home Assistant soi-disant intelligent.

Nous sommes loin de l’agent conversationnel que l’on peut voir dans le film Her de Spike Jonze par exemple. Dans cette comédie dramatique de science-fiction, Theodore, le personnage principal, fait l’acquisition d’un système d’exploitation qui n’est autre qu’une intelligence artificielle qui évoluera selon ses désirs, ses demandes mais qui est aussi conçue pour évoluer et s’adapter à toutes situations. Theodore développe peu à peu une relation romantique avec ce qui était seulement un assistant personnel.

 

 

II – Pourquoi utiliser un Voice Kit ?

 

 

            L’utilisation du Voice Kit par Google n’est pas obligatoire pour créer son propre chatbot, effectivement pour les plus débrouillards ce ne sera même pas essentiel. Précédemment, nous avons pu évoquer qu’il y a des dizaines de solutions plus ou moins accessibles et payantes ou non.

Si on n’a aucune connaissance en code, on pourra tout de même créer un chatbot pour facebook messenger avec Botsify ou Chatfuel par exemple.

Avec l’aide de nombreux tutoriels, un novice pourrait créer un chatbot quasiment sans taper une seule ligne de code.

On peut aussi se demander s’il est mieux de développer son chatbot en « stand-alone » ou grâce à un agrégateur de bot, Google Assistant par exemple. On pourrait choisir d’avoir sa propre application mobile cependant pour que le bot soit accessible aux utilisateurs.

On pourrait arriver au même résultat en utilisant seulement une Rapsberry Pi, là encore il n’y aura aucune intelligence artifice seulement un semblant d’assistant qui reformule nos demandes et ne dit que quelques réponses préprogrammées.

On remarquera ici que la mise en place se faire très rapidement, ce qui est un grand avantage pour commencer à s’intéresser aux chatbots. Rapidement on pourra par la suite ajouter d’autres fonctionnalités, utiliser des API à coupler avec notre Assistant pour le rendre plus performant par rapport à notre utilisation.

Nous nous intéresserons par la suite à une API simple à prendre en main qui permet de créer et développer des bots facilement.

 

 

Construire son propre chatbot vocal

 

I – La connexion

 

 

            Une fois la construction de la boite et l’ajout des différents éléments, le Voice Kit peut se connecter de plusieurs façons, nous nous intéresserons à la plus simple mais aussi celle qui est recommandée. Puisque nous sommes en possession d’un système clé en main, AIY Projects a bien fait les choses avec une application prévue pour la connexion. On utilise donc son smartphone pour se connecter au kit via la Wi-Fi mais aussi afficher une adresse IP pour faire communiquer le kit avec un ordinateur sans fil et SSH.

Bien évidemment lors de la connexion, l’ordinateur et le kit devront être sur le même réseau Wi-Fi. En passant par le terminal, par exemple Secure Shell, on démarre une session SSH en utilisant l’adresse IP de la Rapsberry Pi.

La partie audio va bien sûr être importante, il va être nécessaire de tester si celle-ci fonctionne en entrant d’abord une commande « /home/pi/AIY-projects-python/checkpoints/check_audio.py ». Celle-ci servira à chaque fois que l’utilisateur voudra vérifier le volume, si l’audio est fonctionnel etc.

Le Voice Kit va normalement commencer à parler. On communiquer avec le kit via le terminal en confirmant que l’on a pu entendre les informations. On enregistre ensuite sa propre voix et ainsi de suite pour calibrer le kit.

 

 

 

III – Le point Google

 

            Après que le kit ait été calibré, la suite se passera forcément sur Google qui va mettre ici son grain de sel et permettre d’utiliser au mieux son nouvel assistant. Comme dit plus tôt dans la présentation des chatbots, l’utilisation des API est recommandées, on citera les API Google Assistant et Cloud Speech. Pour se faire l’utilisateur devra s’identifier à la console de développeurs Google.

L’utilisateur passera par le Google Cloud Platform pour créer un nouveau projet qui sera relié au Voice Kit. Via ce projet, on pourra ajouter toutes les API que la personne jugera nécessaire à son utilisation mais surtout l’API Google Assistant qui donne accès au kit de développement (SDK) et qui sera essentielle au bon fonctionnement du Voice Kit.

Là encore, très peu de recherche à faire ou même de code à écrire, il suffira de naviguer dans la librairie de la Google Cloud Platform. A chaque fois, il faudra les fichiers via le terminal.

 

 

Recast.ai, une plateforme de création de bot

 

 

I – Utiliser une plateforme pour développer un bot

 

            Précédemment, nous avons évoqué la plateforme Recast.ai, un outil très complet pour créer et développer des bots sans trop de difficultés. Plusieurs de canaux de discussion comme Skype, Slack sont déjà intégrés ainsi que l’utilisation du traitement automatique du langage naturel. On le place par ailleurs parmi les outils qui gèrent le mieux la langue française.

Recast.ai se base d’abord sur du machine learning, c’est-à-dire que l’apprentissage se fera petit à petit comme grâce à un entraînement. Effectivement le bot devra distinguer l’intention de la phrase qu’il vient d’analyser, en fonction de sa construction, il pourr

a reconnaître la demande et y répondre correctement.

Il y aura donc ce que l’on apprendra au bot et ce qu’il est entraîné à reconnaître seul.

 

Le bot va analyser les mots essentiels pour répondre correctement à la demande de l’utilisateur. Ici la localisation « Paris » en jaune fait partie des mots qu’il reconnaît sans apprentissage de la part de son créateur, on les appelle aussi gold entities.

Grâce à Recast.ai on pourra aussi gérer les flux de conversation du bot c’est-à-dire comment il doit réagir et enchaîner les réponses selon une demande. Aussi si le bot ne peut accéder à la requête, il est préférable de lui enregistrer une phrase de réponse, une demande de reformulation par exemple. C’est ce que nous évoquions avec le programme ELIZA. On appelle ces skills les « floatings » qui rendent plus vivants le bot, grâce à eux le bot pourra répondre à un compliment ou une question auquel il n’est pas capable de répondre comme un choix de sa couleur préférée. Les « fallback » skills sont ceux qui seront déclenché si aucun skill n’est déclenché. Enfin les « business » skills qui correspondent au bon traitement de la requête.

Les entités jugées importantes seront transformées en gold entities, par exemple un prénom, c’est ainsi que le bot apprend.

L’une des parties les plus importantes dans la création de notre bot est l’ensemble des actions qu’il pourra effectuer. Ces dernières se déclinent en plusieurs catégories comme un renvoi de réponse en texte, l’enregistrement d’une donnée, le déclenchement d’une application etc.

 

Un élément important, Recast est une plateforme communautaire c’est-à-dire qu’il est possible de récupérer les fonctionnalités de bots déjà existant mais surtout de les faire apprendre plus rapidement. Lorsque l’on entraine son bot en lui enregistrant un certain nombre de phrases pour une même requête, on aura la possibilité de forker ces dernières et récupérer celle d’autres bots.

 

 

Sur la capture d’écran précédente, nous sommes dans le cas d’un enregistrement d’utilisateur. Le bot devra identifier le nom de la personne ainsi que son email. On remarque d’ailleurs que Recast a pu identifier immédiatement les emails, personnes et pronoms dans les phrases qui lui ont été enregistrer. Ici, « register-user » est notre première intention.

 

 

Voilà ce que l’on peut obtenir en testant notre bot via l’application. On peut enregistrer un certain nombre d’utilisateur en utilisant différentes formules.

On peut imaginer utiliser ce bot dans un chat au sein d’une entreprise par exemple, chacun pourrait enregistrer facilement ces préférences de contact.

 

 

Conclusion

 

 

 

            Si l’engouement autour des chatbots qui ne cesse d’augmenter vous intéresse, nous avons pu voir qu’il n’est pas si difficile de créer le sien à moindre coût, avec une interface seulement ou même un boitier physique pas si éloigné de ceux que l’on peut se procurer dans le commerce.

De nombreuses solutions apparaissent chaque jour et il suffit de trouver celle qui conviendra le mieux à l’utilisation personnel de chacun. De plus, un chatbot home-made sera bien plus adapté à la personne qui le créé puisqu’elle sera en mesure de le calibrer à sa convenance.

Le Voice Kit d’AIY Projects peut passer pour un gadget mais reste performant et adaptable. Les plus motivés et surtout ceux déjà équipés au moins d’une Raspberry Pi n’en auront cependant pas besoin.

Nous nous sommes aussi intéressés à la plateforme Recast.ai, l’une des plus efficaces pour créer un bot simple à implémenter dans un chat comme Slack, Messenger ou Discord.

Si les bots donnent une impression d’intelligence, c’est avant à son créateur de l’utiliser intelligemment afin de lui donner toutes les clés pour qu’il se développe rapidement et correctement.

[Top]