Modifications

Sauter à la navigation Sauter à la recherche

Spark-Python-Call (voir la source)

Version du 24 octobre 2015 à 13:08

13 006 octets ajoutés ,  24 octobre 2015 à 13:08
aucun résumé de modification
Ligne 1 : Ligne 1 :  
{{MCH-Aider}}
 
{{MCH-Aider}}
   −
{{traduction}}
+
== introduction ==
 +
Python Call ou "Comment faire des appels sur votre Core à partir de Python".
 +
 
 +
Nous avons déjà abordé la lecture d'une entrée digitale sur le Core et la publication d'une variable sur le Cloud dans notre tutoriel [[Spark-Core-Bouton|Bouton & Compteur]].
 +
 
 +
Nous avons bien entendu complété nos tutoriels avec l'utilisation d'un contact reed/magnétique, lecture de température avec TMP36 ([[Spark.IO-Accueil|voir nos autres tutoriels Spark Core]] dans la page dédiée au Particle Core).
 +
 
 +
=== Utiliser un Spark Core avec Raspberry-Pi ===
 +
Ce qui nous tient à coeur depuis un petit moment, c'est de contacter et contrôler notre Spark Core par l'intermédiaire d'un Raspberry-Pi.
 +
 
 +
[[Fichier:Spark-Python-Call-00.jpg|800px]]
 +
 
 +
De quoi faciliter la réalisation de projet Domotique par les Makers, voici une idée à base de [http://shop.mchobby.be/product.php?id_product=468 Raspberry-Pi B+] et un [http://shop.mchobby.be/product.php?id_product=549|écran 5 pouce tactile (en HDMI)].
 +
 
 +
Comme le langage de prédilection sur le Pi est Python, nous nous sommes mis en tête d'écrire une bibliothèque pour faciliter les accès à votre Core par l'intermédiaire de l'API du Particle Cloud. Voila, '''PyCall''' (Python Call) est né.
 +
 
 +
== Projet PyCall ==
 +
PyCall est le code Python que nous avons publié sur GitHub.
 +
 
 +
PyCall, ce sont des exemples utilisant la classe Python '''SparkApi''' pour accéder à l'API de Particle Cloud et la classe '''SparkCore''' pour adresser directement un core.
 +
 
 +
Voir notre dépôt GitHub:
 +
 
 +
https://github.com/mchobby/SparkCoreTuto
 +
 
 +
Nous avons bardé le répertoire d'exemple python exploitant les classes et démontrant qu'il est simple de prendre le contrôle de votre Spark Core depuis un Raspberry-Pi (ou n'importe quel OS capable d'exécuter du code Python).
 +
 
 +
Nous avons également placé une copie des programmes "Arduino/Wiring" utilisés sur le Particle Core... puisque c'est a ces programmes que nos scripts Python vont s'adresser.
 +
 
 +
Nous avons également un script python '''core-tinkering.py''' spécifique pour contrôler le Core avec son programme par défaut (Tinker, celui installé en usine) mais nous y reviendrons plus tard.
 +
 
 +
=== Comment installer ===
 +
Pour commencer, il faut prendre une copie du code depuis le dépôt GitHub.
 +
 
 +
Pour cela, nous allons utiliser le programme git en ligne de commande.
 +
 
 +
<nowiki>git clone  https://github.com/mchobby/SparkCoreTuto.git
 +
cd SparkCoreTuto
 +
cd PyCall
 +
cp sparkini-sample.ini sparkapi.ini</nowiki>
 +
 
 +
Vous devez éditer le fichier sparkapi.ini pour y indiquer votre access_token et core_id ([[Spark-Python-Call#SparkApi.ini|voyez plus bas dans ce tuto]]).
 +
 
 +
nano sparkapi.ini
 +
 
 +
Ensuite, vous pouvez simplement tester les différents scripts pythons.
 +
Pourquoi ne pas commencer par celui qui liste vos cores et leur interfaces.
 +
 
 +
./cores-list.py
 +
 
 +
=== Les exemples Python ===
 +
Les scripts Python fonctionne avec des programmes Core correspondant (fichier '.ino'), fichier également publiés sur le dépôt GitHub.
 +
* '''netled.py''' - fait des appels de fonction sur le core pour controler des LED sur le core via le programme netled.ino
 +
* '''lecture-tmp36.py''' - fait des lectures de variable sur le core pour lire la valeur du senseur de température tmp36. Voir le programme lecture-tmp36.ino
 +
* '''buttoncounter.py''' - fait des appels sur un core faisant fonctionner le programme buttoncounter.ino.
 +
* '''magneticswitch.py''' - fait des appels sur un core faisant fonctionner le programme magneticswitch.ino
 +
* '''core-info.py''' - Obtenir plus d'information sur un core. Les fonctions et les variables publiées.
 +
* '''core-tinkering.py''' - Comment définir une classe SparkCoreTinker et utiliser ses méthodes pour faciliter les appel sur l'API publié par le Particle Core. Exemple basé sur Tinker de PARTICLE :-) Vous pouvez donc contrôler directement Tinker depuis Python :-)
 +
 
 +
Les scripts plus orienté vers la gestion du compte Particle Core
 +
* <font color="green">'''sparkapi-inifile-tls.py'''</font> Outils d'aide: collecte les infos pour sparkapi.ini
 +
* '''cores-list.py''' - Lister les Cores associé à votre compte Particle Cloud
 +
* '''access-tokens-list.py''' - S'adresse à l' API pour lister tous les access token liés à votre compte Particle Cloud.
 +
* '''access-token-create.py''' - Crée/ajoute un access_token lié à votre compte Particle Cloud. Utilise le client_id 'xytest'
 +
* '''access-token-delete.py''' - efface les access_token client_id 'xytest' lié à votre compte Particle Cloud. Note: Ne sais pas effacer la dernière entrée créée!
 +
 
 +
=== SparkApi.ini ===
 +
Pour vous connecter sur l'API du Particle Cloud, vous avez besoin d'un access_token. Et pour vous connecter sur votre Core, vous aurez besoin de son Core ID.
 +
 
 +
Plutôt que de hardcoder ces valeurs ([http://shop.mchobby.be celles de MCHobby]) dans les exemples et les programmes, j'ai opté pour un fichier de configuration (SparkApi.ini) dans lequel vous devrez placer les valeurs adéquates (les vôtres bien entendu).
 +
 
 +
Ce fichier est lu à l'aide d'une simple classe Config créée dans ce but.
 +
 
 +
Bien entendu, Je n'ai pas publié mon fichier SparkApi.ini.
 +
Vous devez donc créer ce fichier SparkApi.ini à partir de sparkapi-sample.ini (disponibles dans les sources) et y encoder les paramètres de votre PROPRE compte Spark Cloud et le CORE_ID de votre propre Particle Core.
 +
 
 +
Voici une copie du fichier sparkapi-sample.ini, il reprend les informations nécessaires pour trouver votre access_token et core_id.
 +
 
 +
{{ambox|text=Nous avons également créé le script [https://github.com/mchobby/SparkCoreTuto/blob/master/PyCall/sparkapi-inifile-tls.py sparkapi-inifile-tls.py] qui se connecte sur votre compte Particle pour y collecter l'access_token et les core_id disponibles}}
 +
 
 +
<nowiki># Copiez le contenu de ce fichier dans sparkapi.ini et
 +
# adaptez les valeur access_token et core0 en fonction de votre propre
 +
# compte Particle Cloud :-)
 +
 
 +
[SPARK-API]
 +
# votre access token lié à votre compte Particle Cloud voir notre tuto
 +
# http://wiki.mchobby.be/index.php?title=Spark-Core-NetLED#Faire_une_requ.C3.AAte_sur_l.27API
 +
# pour identifier votre core_id et access_token
 +
access_token=123412341234
 +
 
 +
[CORES]
 +
# Liste de un ou plusieurs de vos particle cores ici
 +
# Vos cores sont lié à votre compte Particle Cloud (et donc votre access_token).
 +
# Voyez notre tuto pour identifier les core_id
 +
# http://wiki.mchobby.be/index.php?title=Spark-Core-NetLED#Faire_une_requ.C3.AAte_sur_l.27API
 +
core0=0123456789abcdef</nowiki>
 +
 
 +
Une fois votre fichier sparkapi.ini créé, vous devez avoir une structure semblable à ceci.
 +
 
 +
[[Fichier:Spark-Python-Call-10.jpg]]
 +
 
 +
== Les éléments clés ==
 +
Bien qu'un peu plus de code soit nécessaire pour rendre vos scripts Python fonctionnels, l'essentiel se concentre en deux lignes.
 +
 
 +
Ceci dit, la bibliothèque va bien au-delà de ces deux appels. N'hésitez pas à consulter les différents exemples et la bibliotèque, le code est abondamment documenté ;-)
 +
 
 +
=== Lecture de variable ===
 +
Pour lire la valeur d'une variable publiée par un Core, il suffit d'appeler
 +
 
 +
value = core.value_of( 'counter' )
 +
 
 +
=== Appel de fonction ===
 +
Et pour faire l'appel d'une fonction publiée sur le core, il suffit d'appeler
 +
 
 +
<nowiki>result = core.call( 'reset' )
 +
result = core.call( 'ma_fonction', parametres_string )</nowiki>
 +
 
 +
== Exemples ==
 +
Il y a de nombreux exemples dans notre projet... mais nous allons nous pencher sur quelques cas plus intéressant.
 +
 
 +
=== buttoncounter.py ===
 +
En guise d'exemple, nous allons nous pencher sur le contrôle du progamme buttoncounter.ino (voyez notre tutoriel [[Spark-Core-Bouton|Bouton & Compteur]]).
 +
 
 +
[[Fichier:SPARK-BUTTON-00.jpg|320px]]<small><br />Voyez notre tutoriel [[Spark-Core-Bouton|Bouton & Compteur]] pour programmer votre Core</small>
 +
 
 +
Le script buttoncounter.py permet d'accéder à la variable "counter" et la fonction "reset" publié le core (''buttoncounter.ino'') sur Particle Cloud.
 +
 
 +
Le [https://github.com/mchobby/SparkCoreTuto/blob/master/PyCall/buttoncounter.py script dans le dépôt] est très abondamment (trop) documenté pour faciliter la prise en main. Je vais donc en proposer une version allégée pour se concentrer sur l'essentiel.
 +
 
 +
<nowiki>#!/usr/bin/env python
 +
# -*- coding: utf-8 -*-
 +
#
 +
"""buttoncounter.py
 +
 
 +
Version épurée du script. Merci de vous rapporter à la version
 +
GitHub pour les infos et licence applicable.
 +
  https://github.com/mchobby/SparkCoreTuto/blob/master/PyCall/buttoncounter.py
 +
 
 +
Voir tutoriel:
 +
  http://wiki.mchobby.be/index.php?title=Spark-Core-Bouton
 +
   
 +
Ou acheter Particle Core -- et soutenir nos travaux --
 +
  http://shop.mchobby.be/category.php?id_category=54
 +
""" 
 +
 
 +
from sparkapi.sparkapi import SparkApi
 +
from sparkapi.config import Config
 +
 
 +
# Ouvre le fichier sparkapi.ini
 +
config = Config()
 +
 
 +
 
 +
def main():
 +
api = SparkApi( access_token = config.access_token, debug = False )
 +
 
 +
# Créer un objet Core à partir du core_id
 +
core = api.get_core( config.cores['core0'] )
 +
 +
# Lire la variable 'counter' sur le core. Retourne un tuple (connected, valeur)
 +
value = core.value_of( 'counter' )
 +
 +
if( value[0] == False ):
 +
  print( 'le Core n est pas connecté' )
 +
else:
 +
  print( 'compteur = %i' % value[1] )
 +
 +
 +
# Appeler la fonction "reset" publier sur Particle Cloud
 +
result = core.call( 'reset' )
 +
if( result[0] == False ):
 +
  print( 'le Core n est pas connecté' )
 +
else:
 +
  print( 'La fonction à répondu %i' % result[1] )
 +
 +
return 0
 +
 
 +
if __name__ == '__main__':
 +
main()</nowiki>
 +
 
 +
Ce qui produit le résultat suivant:
 +
 
 +
[[Fichier:Spark-Python-Call-20.jpg]]
 +
 
 +
=== core-tinkering.py ===
 +
Lorsque vous avez découvert votre core la première fois, ce dernier était programmé d'usine avec le programme '''tinker'''.
 +
 
 +
Ce programme qui permettait à votre Smart Phone de lire/activer les entrées/sorties via votre SmartPhone.
 +
 
 +
{{SPARKImage|Spark.IO-Core-demarrer-04.jpg|250px}}
 +
 
 +
Si tinker n'est plus installé sur votre Core, vous pouvez le réinstaller:
 +
* [[Spark.IO-Démarrer#les_boutons|En faisant un reset d'usine de votre Core]]
 +
* [[Spark.IO-CLI-BlinkLed|En utilisant la commande "spark flash nom_du_core tinker" dans Particle CLI]]
 +
* [http://docs.spark.io/tinker/#tinkering-with-tinker-the-tinker-firmware En suivant ces instructions] (''spark.io, anglais'')
 +
 
 +
'''Le programme core-tinkering.py permet de contrôler votre Core lorsque celui-ci est programmé avec le programme tinker.'''
 +
 
 +
Ce programme montre également comment créer votre propre sous-classe dérivée SparkCore (SparkCoreTinker en l'occurence) pour faciliter l'implémentation de vos fonctionnalités.
 +
 
 +
Dans notre cas, SparkCoreTinker expose les méthodes suivantes:
 +
* digitalread
 +
* digitalwrite
 +
* analogread
 +
* analogwrite
 +
 
 +
Le [https://github.com/mchobby/SparkCoreTuto/blob/master/PyCall/core-tinkering.py script dans le dépôt] est très abondamment (trop) documenté pour faciliter la prise en main. Je vais donc en proposer une version allégée pour se concentrer sur l'essentiel.
 +
 
 +
<nowiki>#!/usr/bin/env python
 +
# -*- coding: utf-8 -*-
 +
#
 +
"""core-tinkering.py
 +
  Version épurée du script. Merci de vous rapporter à la version
 +
  GitHub pour les infos et licence applicable.
 +
    https://github.com/mchobby/SparkCoreTuto/blob/master/PyCall/core-tinkering.py
 +
 
 +
  Appel d'API sur un Particle Core faisant fonctionner le programme tinker.
 +
 
 +
  Voir tutoriel:
 +
    http://wiki.mchobby.be/index.php?title=Spark-Python-Call
 +
   
 +
  Ou acheter Particle Core -- et soutenir nos travaux --
 +
 
 +
  http://shop.mchobby.be/category.php?id_category=54
 +
""" 
 +
from sparkapi.sparkapi import SparkApi
 +
from sparkapi.sparkapi import SparkCoreTinker
 +
from sparkapi.config import Config
 +
import time
 +
 
 +
# Ouvre le fichier sparkapi.ini
 +
config = Config()
 +
 
 +
def main():
 +
api = SparkApi( access_token = config.access_token, debug = False )
 +
 +
# Créer un objet SparkCoreTinker pour un core_id donné
 +
core = api.get_core_by_class( config.cores['core0'], SparkCoreTinker )
 +
 +
print( '--- Utilisation de la classe SparkCoreTinker ---' )
 +
# Lire l'état de la broche 4
 +
print( "digitalread D4 = %i" % core.digitalread( 'D4' ) )
 +
 +
# Active la broche D0 pendant une seconde puis la désactiver
 +
print( "digitalwrite D1 HIGH = %i" % core.digitalwrite( 'D0', True ) )
 +
time.sleep( 1 )
 +
print( "digitalwrite D1 LOW = %i" % core.digitalwrite( 'D0', False ) )
 +
 +
# Lecture d'une broche analogique
 +
print( "analogread A0 = %i" % core.analogread( 'A0' ) )
 +
print( "analogread A0 = %f volts" % core.analogread_voltage( 'A0' ) )
 +
 +
# PWM de la broche D0 par pas increment de 25
 +
for iPwm in range( 0, 255, 50): # de 0 à 250 (inclus) par pas de 50
 +
print( 'PWM D0 a %i. analogwrite = %i' % ( iPwm, core.analogwrite( 'D0', iPwm ) ) )
 +
time.sleep( 2 ) # attendre 2 secondes
 +
# eteindre la broche D0
 +
print( 'Extinction D0. digitalwrite D0 LOW = %i' % core.digitalwrite( 'D0', False ) )
 +
 +
return 0
 +
 
 +
if __name__ == '__main__':
 +
main()
 +
</nowiki>
 +
 
 +
Code assez lisible n'est-ce pas.
 +
Il produit le résultat suivant:
 +
 
 +
[[Fichier:Spark-Python-Call-30.jpg]]
 +
 
 +
{{Spark-Python-Call-TRAILER}}
Admin
Bureaucrates, Administrateurs
29 915

modifications

Récupérée de « https://wiki.mchobby.be/index.php?title=Spécial:MobileDiff/13467...16281 »

Menu de navigation