Introduction aux ChatBots et l’ANI : Artificial Narrow Intelligence

Definition

L’Artificial Narrow Intelligence est une intelligence artificielle qui se concentre sur une seule tâche contrairement à l’AI (Artificial Intelligence) qui est une machine avec la capacité d’appliquer l’intelligence à n’importe quel problème, plutôt qu’un problème spécifique.

Siri est un bon exemple d’ANI. Siri opère dans une gamme limitée prédéfinie, il n’y a pas d’intelligence véritable, pas de conscience de soi.

Les chatbots, ou agents conversationnels, sont les interfaces permettant d’exploiter une ANI.

Principes de fonctionnement

Les chatbots sont souvent utilisés dans un but ou une tâche précise. Ils ont « préformatés » et n’ont pas (ou rarement) de fonctionnalité de machine learning. Un moyen fréquent pour faire fonctionner un chatbot est d’utiliser des fichiers AIML (Artificial Intelligence Markup Language). C’est un format dérivé du XML qui défini quoi répondre à quelle question.

Le problème de l’utilisation de AIML est la non possibilité d’avoir des bots très sophistiqués. Néanmoins, le projet A.L.I.C.E qui utilise ce procédé est arrivé second  au concours Loebner de 2010. Notez qu’aujourd’hui les avancées en AI et machine learning ont largement évolué et qu’on est loin de pouvoir passé un test de Turing avec AIML.

Pour la plupart des chatbots, qui ont a accomplir un nombre restreint de tâches c’est suffisant. Que ce soit en marketing, e-commerce ou autre, les possibilités offertes par cette technique offrent un large panel de services que nous allons parcourir dans cet article.

On l’a vu, le principe de fonctionnement d’un chatbot est relativement simple. On peut le diviser en 3 grandes étapes : demande, traitement, réponse.

 

Mise en œuvre technique

Théoriquement, on peut faire un chatbot avec n’importe quel langage, mais certains sont plus adaptés que d’autre du fait de librairies disponibles. Par exemple, Python a un package pyAIML qui permet de manipuler facilement les fichiers AIML. Si vous préférez le PHP, le projet Program O est une solution.

Dans tous les cas, l’utilisation de AIML est toujours la même. On utilise des patterns et des templates.

Les patterns

Les patterns (ou motifs en français) sont des chaines de caractères qui sont destinées à répondre à une entrée utilisateur. Ces patterns peuvent contenir des jokers pour répondre à un large nombre d’entrées.

Pattern "fermé" : Quel est votre nom

Pattern "large" : Quel est votre *

Le pattern fermé aura qu’une seule réponse possible : un nom. Le pattern large peut répondre à plusieurs questions :

  • quel est votre âge
  • quel est votre nom
  • quel est votre travail

Afin de simplifier le travail de l’interpréteur AIML, on peut ajouter des fonctions de prétraitement pour gérer la casse, les fautes, les abréviations etc.

Les templates

Un template (ou modèle) est une réponse à un pattern. Un template peut être aussi simple qu’un texte littéral brut comme « Bonjour je suis votre bot ». On peut également faire appel à l’utilisation de variables pour personnaliser :

 Bonjour, mon nom est <bot name="name"/>.

Dans cet exemple, on remplace la variable  <bot name= »name »/> par le nom du Bot. On peut également utiliser des variables ayant comme valeur une saisie utilisateur. Par exemple, pour demander le nom ou l’âge de l’utilisateur.

On peut également utiliser des réponses conditionnelles (if / then / else) ou des réponses aléatoires. Les templates peuvent également faire appel à d’autres templates (selon la thématique par exemple) en utilisant des éléments « srai ». Voici un exemple de formatage correct de fichier AIML :

<category>
  <pattern>QUEL EST VOTRE NOM</pattern>
  <template><![CDATA[Mon nom est <bot name="name"/>.]]></template>
</category>
<category>
  <pattern>Comment t'appelles-tu</pattern>
  <template>
    <srai>Quel est votre nom</srai>
  </template>
</category>

Cet exemple, pris sur Wikipédia, met en oeuvre tout ce dont nous venons de voir. « comment t’appelles-tu » est semblable à « quel est votre nom ». On utilise donc un élément srai pour « rediriger » vers la réponse adéquate. L’élément CDATA permet d’éviter les caractères d’échappement liés au XML.

 

Chatbot sans coder, quelques solutions

La mise en oeuvre technique peut être fastidieuse ou compliquée. Il existe des solutions pour mettre en route des chabots sans programmation.

Chatfuel

Ce service permet de créer un chatbot Facebook Messenger pour votre fanpage. Vous créez des scenarios et vous pouvez obtenir quelque chose d’assez puissant en quelques minutes.

Il suffit de créer des blocs avec des mots-clés et de définir une réponse appropriée : réponse texte, lien, card (bloc d’information avec liens, images etc.). C’est un excellent départ et ce service est utilisé par de grands sites.

Site : https://chatfuel.com/

Plugin WordPress

Un plugin wordpress utilisant le script Program O et permettant de mettre en place facilement un chatbot sur votre CMS préféré. Il porte le nom Elizaibots et est disponible gratuitement.

Site : https://en-gb.wordpress.org/plugins/elizaibot-chatbots/

Il existe également un certain nombre de projet, la plupart du temps open source, qui permettent de déployer rapidement un chatbot.

Quelques services à l’internaute

Le plus classique et facile à mettre en place, c’est certainement la FAQ. L’internaute pose une question et on puise dans la base de connaissance pour répondre par un lien direct vers la question / solution dans la FAQ.

On rencontre également régulièrement des chatbots qui deviennent ensuite de véritable chat avec un opérateur commercial ou technique. Le chatbot étant présent en début de chaine pour évaluer le besoin de l’internaute. Charge à l’humain ensuite de prendre le relais et de répondre aux attentes.

Google Allo, propose de chater avec ses amis tout en pouvant poser des questions. Google se sert alors de son moteur de recherche pour apporter des réponses : definition, map, etc.

Conclusions

AIML est une excellente solution pour démarrer avec les chatbots et l’ANI. Cela à néanmoins ses limites puisqu’il est difficile de maintenir à jour un code qui va répondre à énormément de questions ou de pouvoir répondre à des questions complexes.

 

Lancement du Raspberry Pi Zero W : wifi et bluetooth intégrés

La fondation Raspberry a lancé fin février, 5 ans après la sortie du premier modèle Pi, une version « wireless » du Pi Zero. Il se nomme Zero W, avec vous l’avez deviné, W qui signifie Wireless. En effet, cette nouvelle mouture embarque la connectivité wifi et bluetooth nativement. La puissance reste la même que sa version précédente. Le tout pour £9 seulement.

Principales caractéristiques

  • 802.11 b/g/n wireless LAN
  • Bluetooth 4.1
  • Bluetooth Low Energy (BLE)
  • 1GHz, CPU simple coeur
  • 512MB RAM
  • Mini HDMI et USB On-The-Go ports
  • alimentation par Micro USB
  • HAT-compatible 40-pin header
  • Composite video
  • connecteur caméra CSI

Avec ceci, de nouveaux boitiers officiels sont également disponibles. Ils offrent différentes ouvertures sur le couvercle selon l’utilisation que vous désirez faire de votre nano ordinateur.

Ce nouveau modèle promet donc de facilité encore un peu plus la mise en oeuvre de projets IoT ou domotique. Le tout encore une fois pour un coup très maitrisé.

En bonus, voici un comparatif de la consommation électrique de chaque modèle de la famille Raspberry (tests réalisés par RaspiTV) :

 

Reconnaissance d’objets avec TensorFlow

TensorFlow est une librairie pour le machine learning et l’intelligence logiciel. Nous allons aujourd’hui l’utiliser avec le language Python mais vous pouvez également l’utiliser en C.

Vidéo de présentation :

Je suis sous Mac, et pour installer la librairie j’ai utilisé les commandes suivantes :

$ sudo easy_install pip

$ sudo easy_install --upgrade six

Ensuite, il faut choisir la bonne version à installer :

# Ubuntu/Linux 64-bit, CPU only, Python 2.7 $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.10.0-cp27-none-linux_x86_64.whl # Ubuntu/Linux 64-bit, GPU enabled, Python 2.7
# Requires CUDA toolkit 7.5 and CuDNN v5. For other versions, see "Install from sources" below. $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.10.0-cp27-none-linux_x86_64.whl
# Mac OS X, CPU only, Python 2.7: $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.10.0-py2-none-any.whl
# Mac OS X, GPU enabled, Python 2.7: $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow-0.10.0-py2-none-any.whl
# Ubuntu/Linux 64-bit, CPU only, Python 3.4 $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.10.0-cp34-cp34m-linux_x86_64.whl
# Ubuntu/Linux 64-bit, GPU enabled, Python 3.4
# Requires CUDA toolkit 7.5 and CuDNN v5. For other versions, see "Install from sources" below. $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.10.0-cp34-cp34m-linux_x86_64.whl
# Ubuntu/Linux 64-bit, CPU only, Python 3.5 $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.10.0-cp35-cp35m-linux_x86_64.whl
# Ubuntu/Linux 64-bit, GPU enabled, Python 3.5
# Requires CUDA toolkit 7.5 and CuDNN v5. For other versions, see "Install from sources" below. $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.10.0-cp35-cp35m-linux_x86_64.whl
# Mac OS X, CPU only, Python 3.4 or 3.5: $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.10.0-py3-none-any.whl
# Mac OS X, GPU enabled, Python 3.4 or 3.5: $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow-0.10.0-py3-none-any.whl

Il ne reste plus qu’à installer. Selon que vous êtes sous Python 2 ou 3, voici les commandes :

# Python 2 $ sudo pip install --upgrade $TF_BINARY_URL

# Python 3 $ sudo pip3 install --upgrade $TF_BINARY_URL

Nous sommes maintenant prêts pour faire un premier test avec une photo ou une image que vous aurez trouvé sur internet.

Allons dans le répertoire ou la librairie est installée. Dans mon cas, elle se situe ici (sous Mac) :

/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/tensorflow/

Vous pouvez situer l’emplacement en utilisant la commande suivante :

locate tensorflow

Cette commande, qui fonctionne aussi sous Mac ou Linux, vous liste les emplacements ou « tensorflow » est trouvé. Déplacez vous jusqu’au bon répertoire. Tapez ensuite cette commande pour faire un test :

sudo python classify_image.py

Vous devriez obtenir le résultat suivant :

giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca (score = 0.88493) indri, indris, Indri indri, Indri brevicaudatus (score = 0.00878) lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens (score = 0.00317) custard apple (score = 0.00149) earthstar (score = 0.00127)

Par défaut, c’est une image de panda qui est identifiée. Nous allons pouvoir maintenant tester avec nos propres photos. J’ai pris une photo chez moi. Il s’agit d’une guitare et la photo est de qualité plutôt moyenne.

La voici :

guitare

C’est assez sombre, et franchement je ne m’attendais pas à ce que le script puisse reconnaitre un objet sur cette photo. Et pourtant …

En tapant la commande qui suit, Tensorflow a su reconnaitre l’objet principal de la photo :

sudo python classify_image.py --image_file /Users/maxduke/Desktop/test.jpg

test.jpg est évidemment le fichier jpeg de ma photo. Le script m’a renvoyé le résultat suivant :

electric guitar (score = 0.96822)

acoustic guitar (score = 0.00692)

stage (score = 0.00334)

pick, plectrum, plectron (score = 0.00106)

microphone, mike (score = 0.00057)

Comme vous pouvez le constater, le script est certain à 96% qu’il s’agit d’une guitare électrique. C’est presque incroyable mais ça fonctionne. J’ai fait une cinquantaine de tests, et TensorFlow a retrouvé 2 fois sur 3 le bon objet 🙂

Ca laisse beaucoup de place à l’imagination. Comment se servir d’un tel script ? Je suis en ce moment en train de concevoir un robot avec un Raspberry, et ça me donne pas mal d’idées … Et si mon robot pouvait reconnaitre mon chat et ainsi pouvoir interagir avec lui ?

Je reviendrais certainement avec d’autres articles sur le sujet. En attendant, amusez-vous bien.

C.H.I.P : nano ordinateur complet à 9 dollars

Les nano ordinateurs ont le vent en poupe. Les plus connus et les plus vendus sont les Arduino et Raspberry Pi. Un petit nouveau nommé C.H.I.P devrait connaitre le succès avec son prix de vente à 9 dollars. Presque le double du Pi Zero me direz-vous … et c’est vrai. Mais vous avez beaucoup plus. Dans à peine 4cm x 6 cm vous aurez :

  • Processeur 1 Ghz
  • Processeur graphique Mali 400
  • 512Mo de RAM DDR3
  • 4Go de stockage interne
  • Wifi / Bluetooth 4.0
  • Port USB
  • Sorties aux normes I2C, SPI, UART et GPIO

Il vous faudra ajouter une petite carte d’extension pour un port HDMI (15 dollars) ou VGA (10 dollars). Une protection plastique vous coutera 2 dollars. Le tout prêt à fonctionner car le système d’exploitation est déjà installé. Il s’agit d’un noyau linux optimisé pour le Chip. Vous pouvez le pré-commandé dès aujourd’hui, sa livraison est prévue pour novembre 2016.

 

 

Construire son robot à base de Raspberry Pi – étape 2 : les moteurs

Etape 1 : construire le châssis
Etape 2 : les moteurs

On l’a vu dans un premier article, construire le châssis du robot est une chose aisée. Voyons maintenant comment faire fonctionner les quatre moteurs. Deux solutions s’offrent à nous.

Faire fonctionner les moteurs

La première, c’est l’utilisation des ports GPIO sans carte de contrôle de moteurs. On branche directement les moteurs sur les ports. Ça fonctionne mais ça limite l’utilisation qu’on peut faire de notre robot. C’est parfait pour faire quelques tests et se faire la main avec le code. On peut en effet facilement démarrer soit en bash soit en python avec la librairie RPi.GPIO.

raspberry-pi-zero-gpio

Si vous avez déjà lu un article sur comment allumer une LED avec votre Raspberry, c’est exactement la même chose. Le problème est que tel quel, vous ne pourrez pas gérer le sens de rotation des moteurs électriques. En effet, les moteurs classiques DC (à courant continu) peuvent fonctionner dans les deux sens de rotation. Il n’ont pourtant que deux fils pour la plupart. Il font donc ajouter en plus du branchement au ports GPIO, un montage électronique pour pouvoir gérer le sens de rotation. Sans ça, votre robot n’ira qu’en marche avant …

Principe de fonctionnement d’un moteur à courant continu :

moteur-courant-continu

Sur ce type de moteur, en inversant les polarités, on inverse également le sens de rotation. Facile 🙂

ZeroBorg : la carte de contrôle tout en un

zeroborg-piborgLa seconde option est d’utiliser une carte de contrôle. Vous en trouverez à tous les prix mais mon choix s’est porté sur le ZeroBorg de PiBorg. Le modèle KS1 pour être précis. Pour à peine plus de 20 euros, il vous permet de contrôler jusqu’à 4 moteurs DC ou 2 moteurs pas à pas. Ca tombe bien, j’ai quatre moteurs à faire fonctionner. Le grand plus, c’est une librairie python avec plusieurs scripts d’exemples qui sont disponibles. Vous les trouverez à cette adresse : https://github.com/piborg/zeroborg

La voici branchée sur mon robot :

robot-complet-dessus

Nous allons maintenant voir comment procéder, depuis l’activation du bus I2C aux premiers tours de roues 🙂

Tout d’abord, il faut savoir que la ZeroBorg utilise le Bus I2C des ports GPIO. Il faut donc l’activer si ce n’est pas déjà fait (par défaut c’est désactivé). Pour faire la manipulation, taper dans un terminal les commandes suivantes (on commence par avoir un système à jour) :

sudo apt-get update
sudo apt-get upgrade

Accessoirement, installer les outils de contrôle de fonctionnement I2C :

sudo apt-get install python-smbus
sudo apt-get install i2c-tools

Maintenant, on peut passer à l’activation du bus :

sudo raspi-config

Vous arrivez sur la fameuse fenêtre bleue :

raspi-config-advanced_options

A l’aide des flèches, descendez jusqu’à l’option 8 « Advanced Options » et appuyez sur entrée.

La fenêtre des options avancées s’ouvre, sélectionnez « A7 I2C » :

raspi-config-i2c

On vous demande alors si vous souhaitez activez I2C. On répond « yes » !

raspi-config-enable_i2c

On vous demande ensuite si le module doit être chargé lors du boot. Encore une fois on répond « yes ».

raspi-config-load_i2c_module_at_boot

Vous revenez ensuite au menu principal, utiliser la touche tabulation pour quitter. Vous devez maintenant rebooter pour que les changements soit pris en compte. On maintenant prêt à installer et utiliser notre ZeroBorg.

Branchements électriques de la carte

Le branchement au Raspberry est facile. Soit on utilise 6 câbles femelle/femelle soit on soude via les PINS le ZeroBorg sous le Raspberry. Personnellement, j’ai choisi le câblage. Voilà notre carte branchée au ports du bus I2C.

zeroborg-branchement

Il reste à l’alimenter. On peut y faire passer entre 2,7 et 10,8 volts. C’est parfait. On va utiliser la sortie 3,3 volts GPIO (broche 17, voir schéma tout en haut de page).

Broche 17 : 3,3 volts
Broche 20 : GND (masse)

zeroborg-alimentation

Nous voilà désormais complètement câblé … non, il reste les moteurs ! Prenez votre petit tournevis plat, il y en a pour 1 minute.

Il suffit de suivre l’exemple de la photo ci-dessous :

zeroborg-cablage-moteurs

Ce coup ci on est prêt. Nous pouvons passer au code 🙂

Comme expliqué en début d’article, le ZeroBorg a une libraire Python créée spécialement pour. Cela facilite grandement la prise en main puisqu’on faire tourner un moteur en quelques lignes de code et en moins de 5 minutes.

Pour ce faire, enchainez les commandes suivantes dans votre terminal :

sudo mkdir /zeroborg
cd /zeroborg
sudo wget http://www.piborg.org/downloads/zeroborg/examples.zip
sudo unzip examples.zip
sudo chmod +x install.sh
./install.sh

Passons au code, en créant un script de test :

sudo nano test.py

Copiez / coller ensuite ce code :

import ZeroBorg
import time
ZB = ZeroBorg.ZeroBorg()
ZB.Init()
ZB.SetMotor1(0.5)
time.sleep(4)
ZB.SetMotor1(0)
exit()

Le code ci-dessus fait fonctionner le moteur 1 à 50% de sa vitesse maximale pendant 4 secondes avant de se couper. Vous l’aurez compris, en ajoutant ZB.SetMotor2(1), le second moteur tournera à 100%.

Une valeur négative le fera tourner en sens inverse. Par exemple pour faire tourner les moteurs 1 et 2 en sens inverse, le code sera :

import ZeroBorg
import time
ZB = ZeroBorg.ZeroBorg()
ZB.Init()
ZB.SetMotor1(-1)    # rotation inverse moteur 1
ZB.SetMotor2(-1)    # rotation inverse moteur 2
time.sleep(4)
ZB.SetMotor1(0)     # arret moteur 1
ZB.SetMotor2(0)     # arret moteur 2
exit()

Facile non ? et bien voilà, nous savons faire tourner nos moteurs en quelques lignes de code. A vous de jouer maintenant 🙂 Utilisez les quatre moteurs, marche avant, marche arrière.

Toutes les fonctions disponibles sont expliquées ici : https://www.piborg.org/zeroborg/examples#api

Pour stopper l’ensemble des moteurs en une ligne :

ZB.MotorsOff()

Pour tourner à droite ou à gauche, il suffit de faire fonctionner les deux moteurs d’un même côté. Par exemple, pour tourner à droite, on fera tourner uniquement les deux moteurs situés sur la droite. Inversement pour tourner à gauche.

Dans le prochain article, nous verrons comment contrôler notre robot avec les flèches du clavier et nous ajouterons des leds et un klaxon.

 

 

 

 

 

Construire son robot à base de Raspberry Pi – étape 1

Etape 1 : construire le châssis
Etape 2 : les moteurs

Depuis quelques temps, je suis pris de passion pour 2 choses : le Raspberry Pi et la robotique. Après plusieurs projets Raspberry basés sur la programmation, j’ai voulu expérimenter le côté plus hardware. Ça tombe bien, la robotique est un mélange de code et de matériel. Le Pi se prête parfaitement à ce sujet.

J’ai donc réfléchi à ce que je voulais faire. Vouloir fabriquer un robot complètement autonome qui me ferait mon petit déjeuner est utopique car trop complexe. Fabriquer un petit véhicule motorisé, piloté par un Pi Zero, et sur lequel je pourrais ajouter divers éléments (gestion des obstacles, caméra, etc..) au fur et à mesure m’a semblé être une bonne idée. Lire la suite de « Construire son robot à base de Raspberry Pi – étape 1 »

Envoyer un SMS avec votre Raspberry

Cet article vous présente comment envoyer un SMS sur un téléphone mobile avec un script Python. Personnellement, j’exploite le fantastique Raspberry mais vous pouvez utiliser ce script sur n’importe quel système.

Comment ça marche ?

Pour envoyer un SMS (Short Message Service), nous allons créer un script d’une dizaine de lignes de codes. Pour avoir si peu de code, vous vous doutez bien que nous allons utiliser une API. Il faut donc pour commencer, vous créer un compte gratuit sur le site Twilio : https://www.twilio.com

Le service est gratuit, avec un envoi de SMS quasi illimité, si vous n’enregistrer qu’un seul numéro de destinataire. Ce qui est largement suffisant pour faire du monitoring par exemple.

Une fois cotre compte créé, vous arrivez sur votre dashboard :

dashboard-twilio

Vous pouvez alors voir 2 informations importantes que nous allons réutiliser dans le script : account SID et auth token.

Account SID est votre identifiant Twilio tandis que auth token est votre clé d’utilisation de l’API.

Il faut maintenant créer un numéro de téléphone Twilio. Ce numéro est celui qui sert à envoyer les SMS et donc celui qui s’affiche lorsque vous recevez le message.

Rendez-vous sur l’onglet Phone Numbers > manage : https://www.twilio.com/user/account/phone-numbers/incoming

Choisissez bien un numéro qui peut servir à envoyer des SMS (certains ne peuvent servir qu’aux appels vocaux).

Notez ce numéro de téléphone (avec la notation internationale +33xxxx).

manage-numbers-twilio

 

Le script Python

Nous allons maintenant créer une script permettant d’exploiter l’API. Si vous n’avez pas encore installer la librairie, voici comment procéder :

sudo apt-get install python-dev

Si vous utiliser la distribution Raspbian, Python est normalement déjà installé.
Tapez maintenant :

sudo nano sendSMS.py

L’éditeur Nano s’ouvre, copier / coller les lignes suivantes :

# SCRIPT D'ENVOI DE SMS // API TWILIO
 import sys 
from twilio.rest import TwilioRestClient 

# configuration login 
account_sid = "xxxxxxxxx" 
auth_token = "xxxxxxxxx" 
client = TwilioRestClient(account_sid, auth_token) 

# Message a envoyer 
#message = "COUCOU C'EST LE RASPBERRY :)" 
#message = raw_input("Entrez votre message : ") 
message = (sys.argv[1]) 
message = client.messages.create(to="+33xxxxxx",from_="+33xxxxx", body=message) 
print message.sid 
print (sys.argv[1]) 
print (sys.argv[0]) 
print "API Twilio" print "OK!"

Veillez à bien compléter les informations suivantes :

account_sid : remplacer les « xxxx » par votre identifiant Twilio
auth_token : remplacer les « xxxx » par votre token Twilio

Deux numéros de téléphones sont nécessaire :
to = : remplacer par le numéro de téléphone qui reçoit les SMS (celui avec lequel vous avez créé votre compte Twilio)
from_ : le numéro de téléphone qui envoie les SMS. C’est celui que vous avez créé dans Twilio pour l’envoi de SMS.

Notez que j’ai mis 3 méthodes pour le contenu texte du message (2 sont mises en commentaire à l’aide d’un #)

1 – la méthode « en dur ». Le texte ne change pas, c’est toujours le même envoyé à chaque message message = « votre message ». C’est en dur directement dans le script.

2 – interaction durant l’exécution du script. Une fois le script Python exécuté, vous être invité à entrer le message a envoyé.

message = raw_input("Entrez votre message : ")

3 – ma méthode préférée, l’argument lors de l’appel du script :

message = (sys.argv[1])

Pour l’utiliser, on ajout le texte terrière l’appel du script, par exemple :

sudo python sendSMS.py "le message a envoyer"

Voilà, vous pouvez maintenant utiliser votre Raspberry pour envoyer des SMS. Que ce soit pour le monitoring, de la domotique ou tout autre chose, c’est bien pratique et gratuit.

 

Quelques projets intéressants avec un Raspberry Pi Zero

Le micro ordinateur dévoilé en début d’année par la fondation Raspberry est étonnant. Des dimensions record pour une puissance et un tarif plus que raisonnable.

raspberry-caracteristiques-ok

• processeur Broadcom BCM2835 avec 1GHz ARM11 core (40% plus rapide que le premier Raspberry Pi)
• 512Mo LPDDR2 SDRAM
• un slot pour carte micro-SD
• un port mini-HDMI (1080p60 video output)
• 2 ports Micro-USB pour l’alimentation et la data
• 40-pin GPIO (identiques aux modèles A+/B+/2/3)
• 1 sortie composite video (pin)
• dimensions : 65mm x 30mm x 5mm

Il tourne sous Raspbian et coute aux alentours de 5 dollars. Voici une sélection de projets réalisés avec cette fabuleuse petite machine.

Programmer son Pi Zero via USB depuis un autre ordinateur

pi-zero-usb

Andrew Mulholland vous propose une solution pour transformer votre Pi Zero en appareil USB. Il suffit ensuite de le brancher à une autre machine (PC, Mac, Linux, etc..) et vous pouvez le contrôler ou le programme. Simple, efficace et très pratique.
Lien : http://pi.gbaman.info/?p=699

Alimenter le Pi Zero avec deux piles AA

pi-zero-piles

ModMyPi propose un tutoriel très complet pour utiliser votre nano ordinateur avec simplement deux piles électriques type AA. Le mod est relativement simple et peu couteux. C’est idéal pour l’intégration dans un projet embarqué par exemple.
Lien : https://www.modmypi.com/blog/running-a-raspberry-pi-zero-from-an-aa-battery-pack

RetroPie : émulations des anciennes consoles de jeux

Retropie

Avec RetroPie, vous avez un système complet avec plus de 50 machines et consoles émulées. Vous pouvez ainsi créer votre borne d’arcade. Ajoutez des manettes type Nes ou Megadrive en USB voir pourquoi pas un stick d’arcade et le retour dans le passé est réussi. Il s’agit en fait d’une distribution modifiée. Vous mettez votre carte SD et au lancement, RetroPie est déjà prêt à fonctionner.
Lien : https://retropie.org.uk

Pi0Drone : un drone complet pour moins de 200€

pi-zero-drone

Ce projet vous permet de fabriquer grâce à un kit un drone que vous dirigez avec un controleur RC traditionnel ou via Wifi.
Lien : https://www.hackster.io/12590/pi0drone-a-200-smart-drone-with-the-pi-zero-4fec08

Streaming Audio

audio-streamer-pi-zero

Créez votre propre Streamer audio en ajoutant simplement le module PlainDAC I2S (environ 12 euros). Flashez votre carte SD avec une distribution orientée musique comme RaspyFi ou Pi MusicBox et le tour est joué.
Lien : https://polyvection.com/guides/raspberry-pi-zero-minimal-streamer/