Installation du système et usage d'objets connectés pour l'enseignement et l'éducation (INTEL Edison)

Motivations

le projet Météo Climat tremplin pour l'enseignement des sciences s'est intéressé aux instruments de mesure des paramètres météorologiques et à l'exploitation des données mesurées ainsi qu'au traitement des données météorologiques et climatologiques fournies par Météofrance. Cet intérêt a croisé la volonté institutionnelle d'enseigner le codage. Cette intersection s'est matérialisée pour nous autour des nano-ordinateurs comme le RaspBerryPI et des objets connectés comme l'Edison qui pour une somme abordable pour un établissement d'enseignement (de 90 € à 150 € suivant l'appareil et les équipements choisis) permet de disposer d'un vrai ordinateur multi-coeurs de la taille d'un ticket de métro pour l'un et d'une boîte d'allumettes pour l'autre. L'Edison permet autant de créer une interface de mesure avec des capteurs, que de traiter et afficher des données ou encore d'écrire des programmes dans à peu près n'importe quel langage qui peuvent être interfacés avec un smartphone une tablette ou tout autre ordinateur.

De simple consommateur de technologie l'élève et son enseignant deviennent acteurs et producteurs de ressources ou d'applications.

Toutefois l'accès direct au bas niveau de la machine et le terrain vierge qui est fourni par les constructeurs requièrent un travail préliminaire d'installation / configuration, avant que chacun puisse exprimer ses compétences techniques scientifiques ou de design. C'est cette première étape qui est exposée ici avec un Edison afin d'aider ceux qui attendent que ça marche et accompagner ceux qui aiment savoir "comment ça marche".


Sommaire

  1. L'intel Edison
    1.1. Présentation

    1.2. Installation du système d'exploitation

    1.3. Installation de python 3.6.1 et Jupyterhub

    1.4 Extensions et administration

  2. Mise en route de l'Edison en fonctionnement standard

    2.1 Trouver mon Edison sur le réseau

    2.2 Calmer son impatience en allumant quelques diodes

    2.3 Les autres ressources disponibles


Téléchargements

  1. Page des pointeurs vers les téléchargements utiles pour installer ou interagir avec l'Edison
  2. setup Intel
  3. lApplication à installer sur l'ordinateur pour interagir avec l'Edison (version linux)
  4. Image à installer
  5. Logiciel de flash du système d'exploitation sur l'Edison (déprécié)

1. L'intel Edison

L'intel Edison fait partie de la famille des SOC : System on Chip (Système sur une puce). Il s'agit du coeur complet d'un ordinateur de taille 1,7 cm par 2,7 cm sur 3mm d'épaisseur.

1.1 Présentation

Ce coeur est construit autour d'un processeur x86 atom, il dispose du WIFI et du blue-tooth, d'une mémoire d'1 Go et de 4 Go de stockage. Il dispose d'un connecteur permettant de l'insérer sur une carte d'extension qui fournit différentes ressources. A minima l'Edison dispose de deux connecteurs micro-USB qui fournissent l'alimentation et une console (c'est le cas de la version Sparkfun qu'on peut acheter sur le net). Intel propose d'une part une extension "Arduino" reproduisant la configuration d'une carte Arduino qui permet soit d'utiliser cette extension et l'Edison comme un microcontrolleur Arduino (ce qui au passage est une sacrée régression ;-)) soit de piloter directement les ressources de l'Arduino depuis l'Edison; d'autre part une extension dite mini-breakout proposant les mêmes ressources que l'arduino sous un format plus compact et sans émulation du microcontroleur Arduino. De nombreux fabricants proposent des dispositifs adaptables au connecteur Edison ce qui permet une variété quasi infinie de configurations de capteurs et de périphériques sur le bus GPIO, I2c et SPI.

1.2 Installation du système d'exploitation

L'Edison est livré "vide" c'est à dire qu'il n'y a pas de système d'exploitation installé sur sa mémoire. Cela peut paraître normal aux utilisateurs de microcontroleurs qui pour chaque usage "chargent" dans le microcontroleur le fichier exécutable qui va être mis en oeuvre. Nous avons à faire ici à un objet qui est extrêmement proche d'un vrai ordinateur et qui permet donc d'avoir un système d'exploitation résident, de vraies bibliothèques de programmes embarquées.

La beauté de ce dispositif repose sur le fait qu'il est possible de lui fournir à peu près n'importe quel système compatible avec le processeur (un X86 qui est très courant, de la même famille que ceux qui font fonctionner la quasi-totalité des PC) et de construire ce système à la demande en fonction des usages qui sont envisagés. Nous n'aborderons pas ce point ici mais il est bon de l'avoir en tête lors de la conception de dispositifs innovants. Le site Yocto fournit toutes les informations nécessaires avec en particulier l'outil BitBake.

Pour installer le système d'exploitation nous avons besoin :

  • d'un ordinateur disposant de deux connecteurs USB (dans mon cas un portable sous linux Debian stretch (testing))
  • d'un Edison monté sur l'un des dispositifs d'extension (Arduino ou Mini extension board) portant les deux connecteurs micro-USB
  • de deux cables USB de très bonne qualité ce point est crucial car il existe dans le commerce des connecteurs qui ne transmettent que l'alimentation (chargeurs de portable) ou des connecteurs de mauvaise qualité qui ne permettent pas une bonne communication entre ordinateur et Edison; ce peut être une source de dysfonctionnement aléatoire particulièrement difficile à identifier et extrêmement frustrante.
  • d'unlogiciel de copie du système d'exploitation. Intel propose un outil de setup et il existe plusieurs logiciels suivant l'OS de l'ordinateur hôte et même sa version, on proposera ici l'utilisation du setup Intel recommandé par défaut, on expliquera l'utilisation de PlatformFlashToolLite qui est probablement devenue obsolète car le setup a acquis la stabilité nécessaire , on démontrea enfin l'utilisation "manuelle" du logiciel dfu-util installé sur l'ordinateur hôte, il peut s'avérer utile en cas de problème en permettant une installation pas à pas en ligne de commande
  • du fichier binaire du système d'exploitation Yocto proposé par défaut par Intel appelé image,
  • d'un peu de patience et d'attention car même si elle est automatisée cette étape reste un peu longue et délicate.

Attention - Attention - Alimentation de l'Edison

Il est important que l'Edison soit alimenté par une prise USB d'ordinateur fournissant assez d'énergie, certains ulta portables (la plupart de ceux que nous avons testés) ne fournissent pas assez d'énergie et le comportement de l'Edison est assez cahotique parfoirs il démarre de façon incomplète, parfois il ne démarre pas et boucle sans fin avec des clignotements successifs des seux LED vertes. Le résultat est que l'installation est quasi-systématiquement compromise dans cette configuration....

Trois méthodes ont été testées et sont présentées ici, Elles coorrespondent à des stades de maturité différents des outils proposés par INTEL, la première est la plus récente et la mieux adaptée, les deux autres sont conservées car elles resent possibles et permettent éventuellement de débugguer des dysfonctionnements de la méthode standard

1.2.1 Méthode 1 : Utilisation du logiciel de setup d'Intel

Cette méthode est recommandée par Intel quelle que soit la plateforme utilisée (OsX, Linux, Windows) la méthode expliquée ici se réfère à Linux mais les outils sont comparables entre les différents Os.

Télécharger le logiciel de setup, décompresser et exécuter :

curl -o Intel_Edison_Setup_Lin_2016.2.002.tar.gz https://downloadmirror.intel.com/26028/eng/Intel_Edison_Setup_Lin_2016.2.002.tar.gz
cd Intel_Edison_Setup_Lin_2016.2.002
sudo ./install_GUI.sh

Outil d'installation de l'image Intel

Répondre aux questions et bien suivre les instructions éventuelles de branchement débranchement de l'Edison.

  • nous vous conseillons d'intaller en root via sudo (option 2)
  • accepter les termes de la licence
  • ne pas s'inquiéter si on utilise autre chose qu'un ubuntu (à condition d'être dans la même famille de dérivés de Debian, le risque de dysfonctionnement est extrêmement faible)
  • le dernier écran permet de faire les trois opérations principales d'installation (installation de l'image, mise en place de la sécurité, connection au réseau) faire ces trois opérations.
  • retenir l'adresse IP acquise par l'Edison elle sera utilisée pour se connecter ultérieurement

Dans l'image ci-dessous un mini-breakout est connecté pour la procédure de chargement de l'image, une connection directe à l'alimentation externe permet de renforcer la puissance fournie à l'Edison

Edison connecté pour le chargement de l'image

une fois l'installation terminée

1.2.2 Méthode 2 : Utilisation du logiciel dédié de flash d'image

Télécharger le logiciel de flash :

wget https://download.01.org/android-ia/tools/platformflashtool-lite/5.5.2.0/platformflashtoollite_5.5.2.0_linux_x86_64.deb

Il existe une version un plus ancienne au cas où des problèmes apparaîtraient en utilisant la dernière version. Comme l'installeur est indépendant du noyau installé, la version de l'installeur importe peu pourvu qu'il fonctionne! Installer le paquet Debian :

sudo dpkg -i platformflashtoollite_5.5.2.0_linux_x86_64.deb

Télécharger l'image Yocto à installer :

wget https://software.intel.com/edison-image/latest
iot-devkit-prof-dev-image-edison-20160606.zip

Connecter le cordon USB à l'Edison :

Mini Breakout alimentation externe et USB

Lancer le programme d'installation en mode administrateur ou alors ajouter l'utilidateur qui fait l'installation au groupe adm. Avec l'outil de parcours des fichiers du logiciel platformflashtoollite choisir l'image téléchargée iot-devkit-prof-dev-image-edison-20160315.zip. Automatiquement le fichier est décompressé et le fichier qui va être flashé est proposé, vérifier que la configuration correspond bien à la plateforme de travail (linux dans cet exemple) .

sudo platformflashtoollite

Outil de copie de l'image flashtool

Cliquer sur le bouton start flash à gauche et suivre scrupuleusement toute les instructions à l'écran. Cette opération est entièrementautomatisée et la progression de l'installation est affichée. Parfois il peut se produire des incidents de transfert ou d'écriture. Pas de panique il n'y a pas de risque de desctruction ou de dommage. Si quelque chose s'est mal passé il n'y a pas besoin de fermer et réouvrir le logiciel il suffit de relancer la procédure de flash en déconnectant reconnectant l'Edison comme cela est demandé Une fois la procédure terminée un message de succès apparaît, il faut attendre quelques minutes que l'Edison ait rebooté une fois avant de le déconnecter, à priori une fois qu'il a rebooté le disque "Edison" apparait. Normalement on dispose alors d'un Edison opérationnel qu'on va pouvoir configurer selon nos besoins.

Transfert en cours avec l'util de copie de l'image

Fermer le logiciel de flash, débrancher le conecteurs USB puis brancher les deux USB afin de faire démarrer l'Edison pour la première fois.

1.2.3 Méthode 3 : Utilisation du logiciel dfu-util

Cette procédure manuelle est à utiliser en dernier ressort si les autres méthodes n'ont pas fonctionné, elle est plus robuste et permet dans les cas extrêmes de débugguer la situation. Installer le logiciel dfu-util avant d'entamer les manipulations sur l'image. Télécharger l'image Yocto à installer :

wget https://software.intel.com/edison-image/latest

créer un répertoire et y dézipper l'image

 unzip ../iot-devkit-prof-dev-image-edison-20160606.zip 
Archive:  ../iot-devkit-prof-dev-image-edison-20160606.zip
  inflating: edison_dnx_fwr.bin      
  inflating: edison_dnx_osr.bin      
  inflating: edison_ifwi-dbg-00.bin  
  inflating: edison_ifwi-dbg-00-dfu.bin  
  inflating: edison_ifwi-dbg-01.bin  
  inflating: edison_ifwi-dbg-01-dfu.bin  
  inflating: edison_ifwi-dbg-02.bin  
  inflating: edison_ifwi-dbg-02-dfu.bin  
  inflating: edison_ifwi-dbg-03.bin  
  inflating: edison_ifwi-dbg-03-dfu.bin  
  inflating: edison_ifwi-dbg-04.bin  
  inflating: edison_ifwi-dbg-04-dfu.bin  
  inflating: edison_ifwi-dbg-05.bin  
  inflating: edison_ifwi-dbg-05-dfu.bin  
  inflating: edison_ifwi-dbg-06.bin  
  inflating: edison_ifwi-dbg-06-dfu.bin  
  inflating: edison-image-edison.ext4  
  inflating: edison-image-edison.hddimg  
  inflating: filter-dfu-out.js       
  inflating: flashall.bat            
  inflating: flashall.sh             
  inflating: FlashEdison.json        
   creating: helper/
  inflating: helper/helper.html      
   creating: helper/images/
  inflating: helper/images/Edison-arduino-blink-led.png  
  inflating: helper/images/Edison-arduino.png  
  inflating: helper/images/Edison-breakout-board.png  
  inflating: ota_update.scr          
  inflating: package-list.txt        
  inflating: u-boot-edison.bin       
  inflating: u-boot-edison.img       
   creating: u-boot-envs/
  inflating: u-boot-envs/edison-prod.bin  
  inflating: u-boot-envs/edison-blankrndis.bin  
  inflating: u-boot-envs/edison-blankcdc.bin  
  inflating: u-boot-envs/edison-ifwi.bin  

Lancer l'installation avec la commande flashall.sh puis brancher les 2 USB de l'Edison.

./flashall.sh
Using U-Boot target: edison-blankcdc
Now waiting for dfu device 8087:0a99
Please plug and reboot the board
Flashing IFWI
Download    [=========================] 100%      4194304 bytes
Download    [=========================] 100%      4194304 bytes
Flashing U-Boot
Download    [=========================] 100%       237568 bytes
Flashing U-Boot Environment
Download    [=========================] 100%        65536 bytes
Flashing U-Boot Environment Backup
Download    [=========================] 100%        65536 bytes
Rebooting to apply partition changes
Now waiting for dfu device 8087:0a99
Flashing boot partition (kernel)
Download    [=========================] 100%      6144000 bytes
Flashing rootfs, (it can take up to 5 minutes... Please be patient)
Download    [=========================] 100%   1373149184 bytes
Rebooting
U-boot & Kernel System Flash Success...
Your board needs to reboot to complete the flashing procedure, please do not unplug it for 2 minutes.

Attendre que l'Edison reboote il démarre pour la première fois avec la nouvelle image.

1.2.4 Suite de la procédure

Si l'on a débranché l'Edison, au rebranchement les leds de couleur sur l'extension doivent s'allumer clignoter puis se stabiliser allumées, de plus un disque dur appelé "Edison" est monté automatiquement et apparaît dans les disques externes, c'est une manifestation "visible" du fonctionnement de l'Edison. Pour se connecter à l'Edison si les trois opérations d'installation se sont bien passées l'Edison est connecté au réseau wifi et a donné son adresse IP pendant la procédure on peut se connecter directement en ssh :

ssh root@XXX.XXX.XXX.XXX

Si quelque chose s'est mal passé et que l'Edison ne s'est pas connecté convenablement au réseau, il est tout de même possible de le joindre via la console. Ouvrir un terminal sur l'ordinateur et taper la commande ci-dessous qui initie une connection en "mode console". Ce mode de fonctionnement est dégradé mais efficace pour un traitement manuel des anomalies, lorsque l'invite apparaît taper root, s'il n'y a pas (encore) de mot de passe la connection s'établit si le mot de passe a été configuré l'utiliser. Nous sommes authentifiés comme administrateur de notre objet connecté et nous pouvons compléter la configuration si elle ne s'est pas correctement passée ou si nous souhaitons modifier certains paramètres.

sudo screen /dev/ttyUSB0 115200

Poky (Yocto Project Reference Distro) 1.7.2 edison ttyMFD2

edison login: root
root@edison:~# 

Nous sommes authentifiés comme administrateur (root) sur un objet s'appelant edison, nous allons pouvoir configurer ce nouveau venu et appliquer quelques règles de sécurité élémentaires. La première commande permet de modifier les informations générales de notre objet

root@edison:~# configure_edison --setup

Configure Edison: Device Password

Enter a new password (leave empty to abort)
This will be used to connect to the access point and login to the device.
Password: 

Configure Edison: Device Name

Give this Edison a unique name.
This will be used for the access point SSID and mDNS address.
Make it at least five characters long (leave empty to skip): 
Is delorean correct? [Y or N]: Y

Do you want to set up wifi? [Y or N]: 

Configure Edison: WiFi Connection

Scanning: 1 seconds left  

0 :     Rescan for networks
1 :     Exit WiFi Setup
2 :     Manually input a hidden SSID
3 :     eduspot
4 :     invites
5 :     eduroam


Enter 0 to rescan for networks.
Enter 1 to exit.
Enter 2 to input a hidden network SSID.
Enter a number between 3 to 5 to choose one of the listed network SSIDs: 

Enter a number between 3 to 5 to choose one of the listed network SSIDs: 5
Is ********* correct? [Y or N]: Y
Please enter the network username: vidal@ens-lyon.fr
What is the network password?: ***************
Initiating connection to eduroam. Please wait...

Attempting to enable network access, please check 'wpa_cli status' after a minute to confirm.
Done. Please connect your laptop or PC to the same network as this device and go to http://140.77.***.*** or http://*******.local in your browser.

La configuration de base est maintenant achevée.

1.3 Installation de python 3.6.1 et Jupyterhub

Installer python 3.6.1

L'Edison propose python 33 dont lz verdion est insuffisante pour installer Jupyterhub nous allons donc installer la version 3.6.1 de python (la plus récente à ce jour 17-05-24). Nous proposons de le réaliser directement sur l'Edison mais il est possible pour ceux qui le maîtrisent re réaliser une compilation croisée à partie d'un PC.

télécharger les sources de python :

cd
mkdir -p Logiciels/Python3
cd  Logiciels/Python3
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvfJ Python-3.6.1.tar.xz
cd Python-3.6.1

Il est nécessaire ici de modifier la configuration des modules qui seront inclus par défaut pour disposer de pip3, venv et quelques autres modules extrêmement utiles. La compilation de ces modules est assez délicate et dépend ds paquets installés dans le système ainsi que de la configuration de ce dernier. Il est difficile et fastidieux de reprendre tout le fichier de configuration option par option c'est pourquoi je propose ici la ersion que j'ai testée avec succès sans qu'elle convienne forcément aux besoins de chacun et sans que je puisse garantir qu'elle soit optimale.

Pour modifier les modules compilés d'orgine et inclus dans la version produite éditer le fichier Modules/Setup la version ci-dessous est celle qui a fonctionné en fournissant les utilitaires nécessaires pour l'étape suivante, il est fourni à titre d'exemple et pas de modèle :

# -*- makefile -*-
# The file Setup is used by the makesetup script to construct the files
# Makefile and config.c, from Makefile.pre and config.c.in,
# respectively.  The file Setup itself is initially copied from
# Setup.dist; once it exists it will not be overwritten, so you can edit
# Setup to your heart's content.  Note that Makefile.pre is created
# from Makefile.pre.in by the toplevel configure script.

# (VPATH notes: Setup and Makefile.pre are in the build directory, as
# are Makefile and config.c; the *.in and *.dist files are in the source
# directory.)

# Each line in this file describes one or more optional modules.
# Modules enabled here will not be compiled by the setup.py script,
# so the file can be used to override setup.py's behavior.

# Lines have the following structure:
#
# <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
#
# <sourcefile> is anything ending in .c (.C, .cc, .c++ are C++ files)
# <cpparg> is anything starting with -I, -D, -U or -C
# <library> is anything ending in .a or beginning with -l or -L
# <module> is anything else but should be a valid Python
# identifier (letters, digits, underscores, beginning with non-digit)
#
# (As the makesetup script changes, it may recognize some other
# arguments as well, e.g. *.so and *.sl as libraries.  See the big
# case statement in the makesetup script.)
#
# Lines can also have the form
#
# <name> = <value>
#
# which defines a Make variable definition inserted into Makefile.in
#
# Finally, if a line contains just the word "*shared*" (without the
# quotes but with the stars), then the following modules will not be
# built statically.  The build process works like this:
#
# 1. Build all modules that are declared as static in Modules/Setup,
#    combine them into libpythonxy.a, combine that into python.
# 2. Build all modules that are listed as shared in Modules/Setup.
# 3. Invoke setup.py. That builds all modules that
#    a) are not builtin, and
#    b) are not listed in Modules/Setup, and
#    c) can be build on the target
#
# Therefore, modules declared to be shared will not be
# included in the config.c file, nor in the list of objects to be
# added to the library archive, and their linker options won't be
# added to the linker options. Rules to create their .o files and
# their shared libraries will still be added to the Makefile, and
# their names will be collected in the Make variable SHAREDMODS.  This
# is used to build modules as shared libraries.  (They can be
# installed using "make sharedinstall", which is implied by the
# toplevel "make install" target.)  (For compatibility,
# *noconfig* has the same effect as *shared*.)
#
# In addition, *static* explicitly declares the following modules to
# be static.  Lines containing "*static*" and "*shared*" may thus
# alternate throughout this file.

# NOTE: As a standard policy, as many modules as can be supported by a
# platform should be present.  The distribution comes with all modules
# enabled that are supported by most platforms and don't require you
# to ftp sources from elsewhere.


# Some special rules to define PYTHONPATH.
# Edit the definitions below to indicate which options you are using.
# Don't add any whitespace or comments!

# Directories where library files get installed.
# DESTLIB is for Python modules; MACHDESTLIB for shared libraries.
DESTLIB=$(LIBDEST)
MACHDESTLIB=$(BINLIBDEST)

# NOTE: all the paths are now relative to the prefix that is computed
# at run time!

# Standard path -- don't edit.
# No leading colon since this is the first entry.
# Empty since this is now just the runtime prefix.
DESTPATH=

# Site specific path components -- should begin with : if non-empty
SITEPATH=

# Standard path components for test modules
TESTPATH=

# Path components for machine- or system-dependent modules and shared libraries
MACHDEPPATH=:$(PLATDIR)
EXTRAMACHDEPPATH=

COREPYTHONPATH=$(DESTPATH)$(SITEPATH)$(TESTPATH)$(MACHDEPPATH)$(EXTRAMACHDEPPATH)
PYTHONPATH=$(COREPYTHONPATH)


# The modules listed here can't be built as shared libraries for
# various reasons; therefore they are listed here instead of in the
# normal order.

# This only contains the minimal set of modules required to run the
# setup.py script in the root of the Python source tree.

posix posixmodule.c     # posix (UNIX) system calls
errno errnomodule.c     # posix (UNIX) errno values
pwd pwdmodule.c         # this is needed to find out the user's home dir
                # if $HOME is not set
_sre _sre.c         # Fredrik Lundh's new regular expressions
_codecs _codecsmodule.c     # access to the builtin codecs and codec registry
_weakref _weakref.c     # weak references
_functools _functoolsmodule.c   # Tools for working with functions and callable objects
_operator _operator.c           # operator.add() and similar goodies
_collections _collectionsmodule.c # Container types
itertools itertoolsmodule.c    # Functions creating iterators for efficient looping
atexit atexitmodule.c      # Register functions to be run at interpreter-shutdown
_signal signalmodule.c
_stat _stat.c           # stat.h interface
time timemodule.c   # -lm # time operations and variables

# access to ISO C locale support
_locale _localemodule.c  # -lintl

# Standard I/O baseline
_io -I$(srcdir)/Modules/_io _io/_iomodule.c _io/iobase.c _io/fileio.c _io/bytesio.c _io/bufferedio.c _io/textio.c _io/stringio.c

# The zipimport module is always imported at startup. Having it as a
# builtin module avoids some bootstrapping problems and reduces overhead.
zipimport zipimport.c

# faulthandler module
faulthandler faulthandler.c

# debug tool to trace memory blocks allocated by Python
_tracemalloc _tracemalloc.c hashtable.c

# The rest of the modules listed in this file are all commented out by
# default.  Usually they can be detected and built as dynamically
# loaded modules by the new setup.py script added in Python 2.1.  If
# you're on a platform that doesn't support dynamic loading, want to
# compile modules statically into the Python binary, or need to
# specify some odd set of compiler switches, you can uncomment the
# appropriate lines below.

# ======================================================================

# The Python symtable module depends on .h files that setup.py doesn't track
_symtable symtablemodule.c

# Uncommenting the following line tells makesetup that all following
# modules are to be built as shared libraries (see above for more
# detail; also note that *static* reverses this effect):

#*shared*

# GNU readline.  Unlike previous Python incarnations, GNU readline is
# now incorporated in an optional module, configured in the Setup file
# instead of by a configure script switch.  You may have to insert a
# -L option pointing to the directory where libreadline.* lives,
# and you may have to change -ltermcap to -ltermlib or perhaps remove
# it, depending on your system -- see the GNU readline instructions.
# It's okay for this to be a shared library, too.

#readline readline.c -lreadline -ltermcap


# Modules that should always be present (non UNIX dependent):

array arraymodule.c # array objects
cmath cmathmodule.c _math.c # -lm # complex math library functions
#math mathmodule.c _math.c # -lm # math library functions, e.g. sin()
_struct _struct.c   # binary structure packing/unpacking
#_weakref _weakref.c    # basic weak reference support
_testcapi _testcapimodule.c    # Python C API test module
_random _randommodule.c # Random number generator
_elementtree -I$(srcdir)/Modules/expat -DHAVE_EXPAT_CONFIG_H -DUSE_PYEXPAT_CAPI _elementtree.c  # elementtree accelerator
_pickle _pickle.c   # pickle accelerator
_datetime _datetimemodule.c # datetime accelerator
_bisect _bisectmodule.c # Bisection algorithms
_heapq _heapqmodule.c   # Heap queue algorithm
_asyncio _asynciomodule.c  # Fast asyncio Future

#unicodedata unicodedata.c    # static Unicode character database


# Modules with some UNIX dependencies -- on by default:
# (If you have a really backward UNIX, select and socket may not be
# supported...)

fcntl fcntlmodule.c # fcntl(2) and ioctl(2)
spwd spwdmodule.c       # spwd(3)
grp grpmodule.c     # grp(3)
select selectmodule.c   # select(2); not on ancient System V

# Memory-mapped files (also works on Win32).
mmap mmapmodule.c

# CSV file helper
_csv _csv.c

# Socket module helper for socket(2)
_socket socketmodule.c

# Socket module helper for SSL support; you must comment out the other
# socket line above, and possibly edit the SSL variable:
#SSL=/usr/local/ssl
_ssl _ssl.c \
    -DUSE_SSL -I$(SSL)/include -I$(SSL)/include/openssl \
    -L$(SSL)/lib -lssl -lcrypto

# The crypt module is now disabled by default because it breaks builds
# on many systems (where -lcrypt is needed), e.g. Linux (I believe).
#
# First, look at Setup.config; configure may have set this for you.

#_crypt _cryptmodule.c # -lcrypt    # crypt(3); needs -lcrypt on some systems


# Some more UNIX dependent modules -- off by default, since these
# are not supported by all UNIX systems:

#nis nismodule.c -lnsl  # Sun yellow pages -- not everywhere
#termios termios.c  # Steen Lumholt's termios module
#resource resource.c    # Jeremy Hylton's rlimit interface

_posixsubprocess _posixsubprocess.c  # POSIX subprocess module helper

# Multimedia modules -- off by default.
# These don't work for 64-bit platforms!!!
# #993173 says audioop works on 64-bit platforms, though.
# These represent audio samples or images as strings:

#audioop audioop.c  # Operations on audio samples


# Note that the _md5 and _sha modules are normally only built if the
# system does not have the OpenSSL libs containing an optimized version.

# The _md5 module implements the RSA Data Security, Inc. MD5
# Message-Digest Algorithm, described in RFC 1321.

#_md5 md5module.c


# The _sha module implements the SHA checksum algorithms.
# (NIST's Secure Hash Algorithms.)
#_sha1 sha1module.c
#_sha256 sha256module.c
#_sha512 sha512module.c

# _blake module
#_blake2 _blake2/blake2module.c _blake2/blake2b_impl.c _blake2/blake2s_impl.c

# The _tkinter module.
#
# The command for _tkinter is long and site specific.  Please
# uncomment and/or edit those parts as indicated.  If you don't have a
# specific extension (e.g. Tix or BLT), leave the corresponding line
# commented out.  (Leave the trailing backslashes in!  If you
# experience strange errors, you may want to join all uncommented
# lines and remove the backslashes -- the backslash interpretation is
# done by the shell's "read" command and it may not be implemented on
# every system.

# *** Always uncomment this (leave the leading underscore in!):
# _tkinter _tkinter.c tkappinit.c -DWITH_APPINIT \
# *** Uncomment and edit to reflect where your Tcl/Tk libraries are:
#   -L/usr/local/lib \
# *** Uncomment and edit to reflect where your Tcl/Tk headers are:
#   -I/usr/local/include/tcl8.6.1/ \
# *** Uncomment and edit to reflect where your X11 header files are:
#   -I/usr/X11R6/include \
# *** Or uncomment this for Solaris:
#   -I/usr/openwin/include \
# *** Uncomment and edit for Tix extension only:
#   -DWITH_TIX -ltix8.1.8.2 \
# *** Uncomment and edit for BLT extension only:
#   -DWITH_BLT -I/usr/local/blt/blt8.0-unoff/include -lBLT8.0 \
# *** Uncomment and edit for PIL (TkImaging) extension only:
#     (See http://www.pythonware.com/products/pil/ for more info)
#   -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
# *** Uncomment and edit for TOGL extension only:
#   -DWITH_TOGL togl.c \
# *** Uncomment and edit to reflect your Tcl/Tk versions:
#   -ltk8.2 -ltcl8.2 \
# *** Uncomment and edit to reflect where your X11 libraries are:
#   -L/usr/X11R6/lib \
# *** Or uncomment this for Solaris:
#   -L/usr/openwin/lib \
# *** Uncomment these for TOGL extension only:
#   -lGL -lGLU -lXext -lXmu \
# *** Uncomment for AIX:
#   -lld \
# *** Always uncomment this; X11 libraries to link with:
    -lX11

# Lance Ellinghaus's syslog module
#syslog syslogmodule.c      # syslog daemon interface


# Curses support, requiring the System V version of curses, often
# provided by the ncurses library.  e.g. on Linux, link with -lncurses
# instead of -lcurses).
#
# First, look at Setup.config; configure may have set this for you.

#_curses _cursesmodule.c -lcurses -ltermcap
# Wrapper for the panel library that's part of ncurses and SYSV curses.
#_curses_panel _curses_panel.c -lpanel -lncurses


# Modules that provide persistent dictionary-like semantics.  You will
# probably want to arrange for at least one of them to be available on
# your machine, though none are defined by default because of library
# dependencies.  The Python module dbm/__init__.py provides an
# implementation independent wrapper for these; dbm/dumb.py provides
# similar functionality (but slower of course) implemented in Python.

# The standard Unix dbm module has been moved to Setup.config so that
# it will be compiled as a shared library by default.  Compiling it as
# a built-in module causes conflicts with the pybsddb3 module since it
# creates a static dependency on an out-of-date version of db.so.
#
# First, look at Setup.config; configure may have set this for you.

#_dbm _dbmmodule.c  # dbm(3) may require -lndbm or similar

# Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
#
# First, look at Setup.config; configure may have set this for you.

#_gdbm _gdbmmodule.c -I/usr/local/include -L/usr/local/lib -lgdbm


# Helper module for various ascii-encoders
#binascii binascii.c

# Fred Drake's interface to the Python parser
#parser parsermodule.c


# Lee Busby's SIGFPE modules.
# The library to link fpectl with is platform specific.
# Choose *one* of the options below for fpectl:

# For SGI IRIX (tested on 5.3):
#fpectl fpectlmodule.c -lfpe

# For Solaris with SunPro compiler (tested on Solaris 2.5 with SunPro C 4.2):
# (Without the compiler you don't have -lsunmath.)
#fpectl fpectlmodule.c -R/opt/SUNWspro/lib -lsunmath -lm

# For other systems: see instructions in fpectlmodule.c.
#fpectl fpectlmodule.c ...

# Test module for fpectl.  No extra libraries needed.
#fpetest fpetestmodule.c

# Andrew Kuchling's zlib module.
# This require zlib 1.1.3 (or later).
# See http://www.gzip.org/zlib/
#zlib zlibmodule.c -I$(prefix)/include -L$(exec_prefix)/lib -lz

# Interface to the Expat XML parser
#
# Expat was written by James Clark and is now maintained by a group of
# developers on SourceForge; see www.libexpat.org for more
# information.  The pyexpat module was written by Paul Prescod after a
# prototype by Jack Jansen.  Source of Expat 1.95.2 is included in
# Modules/expat/.  Usage of a system shared libexpat.so/expat.dll is
# not advised.
#
# More information on Expat can be found at www.libexpat.org.
#
#pyexpat expat/xmlparse.c expat/xmlrole.c expat/xmltok.c pyexpat.c -I$(srcdir)/Modules/expat -DHAVE_EXPAT_CONFIG_H -DUSE_PYEXPAT_CAPI

# Hye-Shik Chang's CJKCodecs

# multibytecodec is required for all the other CJK codec modules
#_multibytecodec cjkcodecs/multibytecodec.c

#_codecs_cn cjkcodecs/_codecs_cn.c
#_codecs_hk cjkcodecs/_codecs_hk.c
#_codecs_iso2022 cjkcodecs/_codecs_iso2022.c
#_codecs_jp cjkcodecs/_codecs_jp.c
#_codecs_kr cjkcodecs/_codecs_kr.c
#_codecs_tw cjkcodecs/_codecs_tw.c

# Example -- included for reference only:
# xx xxmodule.c

# Another example -- the 'xxsubtype' module shows C-level subtyping in action
xxsubtype xxsubtype.c

Configurer la compilation, compiler et installer ce qui a été produit :

./configure
make
sudo make install

Si les choses ont bien fonctionné :

sudo make clean

Installation de Jupyterhub

Python et les alis de commande sont installés dans le /usr/local/bin de même les include , les share et les les lib dans la hiérarchie /usr/local. Il est maitenant possible d'installer un virtualenv qui contienne Jupyterhub, on l'obrtient avec les commandes suivantes :

cd
sudo opkg install libpng16-dev
sudo opkg install libfreetype-dev
python3.6 -m venv  --symlinks  VirtPy3
cd VirtPy3/
source bin/activate
pip3 install jupyter
pip3 install jupyterhub
pip3 install matplotlib

Jupyter, ipython et jupyterhub sont prêts à fonctionner.

1.4 Extensions et administration

Après cette installation basique nous allons procéder à quelques extensions et tâches d'administration pour améliorer notre environnement de travail. Pour éviter d'être administrateur en permanence qui est dangereux tant du point de vue de la sécurité que de ceui des conséquences irréversibles de fausses manips il est possible de créer tous les utilisateurs authentifiés que l'on souhaite :

root@edison:~# adduser vidal
Changing password for vidal
Enter the new password (minimum of 5 characters)
Please use a combination of upper and lower case letters and numbers.
New password: 
Re-enter new password: 
passwd: password changed.

Avant toute manipulation du contenu de notre image nous allons la mettre à jour pour intégrer les modifications des programmes faites après la date de construction du noyau en utilisant les commandes suivantes :

root@edison:~# opkg update
Downloading http://iotdk.intel.com/repos/2.0/intelgalactic/Packages.
Updated list of available packages in /var/lib/opkg/iotkit.
root@edison:~# opkg upgrade
Upgrading mraa from 0.8.0 to 0.9.0 on root.
Downloading http://iotdk.intel.com/repos/2.0/intelgalactic/mraa_0.9.0_i586.ipk.
Removing obsolete file /usr/lib/libmraa.so.0.8.0.
Removing obsolete file /usr/share/mraa/examples/python/uart.py.
Upgrading upm from 0.4.0 to 0.4.1 on root.
Downloading http://iotdk.intel.com/repos/2.0/intelgalactic/upm_0.4.1_i586.ipk.

.../... Une liste plus ou moins longue de fichier mis à jour est égrenée avant de restituer l'invite.

Il manquait dans la version précédente de Yocto un certain nombre de programmes usuels pour un linuxien de base et heureusement une grande partie de ces programmes figurent maintenant dans les dépôts standards proposés par Intel. Je propose seulement d'aller chercher dans des dépôts particuliers le programme sync qui permet de façon assez facile de synchroniser son travail avec un ordinateur tiers ou un cloud.

Éditer le fichier de configuration système base-feeds.confet lui ajouter les trois lignes suivantes :

nano /etc/opkg/base-feeds.conf 

src/gz all http://repo.opkg.net/edison/repo/all
src/gz edison http://repo.opkg.net/edison/repo/edison
src/gz core2-32 http://repo.opkg.net/edison/repo/core2-32

Refaire une actualisation des ressources pour prendre en compte les nouveaux dépôts, mais surtout ne pas faire une mise à jour complète car les changements induits par l'ajout du dépôt externe sont trop lourds et entraînent une erreur (dépassement de l'espace mémoire disponible) dont les conséquences sont aléatoires et souvent suffisamment importantes pour altérer le fonctionnement de l'Edison, entraînant la nécessité d'une réinstallation. Installez seulement les programmes dont vous avez besoin, dans le cas ci-dessous rsync.

opkg update
opkg install rsync
Downloading http://repo.opkg.net/edison/repo/all/Packages.gz.
Inflating http://repo.opkg.net/edison/repo/all/Packages.gz.
Updated list of available packages in /var/lib/opkg/all.
Downloading http://repo.opkg.net/edison/repo/edison/Packages.gz.
Inflating http://repo.opkg.net/edison/repo/edison/Packages.gz.
Updated list of available packages in /var/lib/opkg/edison.
Downloading http://repo.opkg.net/edison/repo/core2-32/Packages.gz.
Inflating http://repo.opkg.net/edison/repo/core2-32/Packages.gz.
Updated list of available packages in /var/lib/opkg/core2-32.
Downloading http://iotdk.intel.com/repos/2.0/intelgalactic/Packages.
Updated list of available packages in /var/lib/opkg/iotkit.
root@edison:~# opkg install rsync
Installing rsync (3.1.0-r0) on root.
Downloading http://repo.opkg.net/edison/repo/core2-32/rsync_3.1.0-r0_core2-32.ipk.
Configuring rsync.

Une fois ces installations effectuées il faut impérativement commenter les dépôts ajoutés (on les décommentera à nouveau ultérieurement en fonction des besoins) puis refaire une actualisation des dépôts disponibles.

nano /etc/opkg/base-feeds.conf 

#src/gz all http://repo.opkg.net/edison/repo/all
#src/gz edison http://repo.opkg.net/edison/repo/edison
#src/gz core2-32 http://repo.opkg.net/edison/repo/core2-32


root@edison:~# opkg update
Downloading http://iotdk.intel.com/repos/2.0/intelgalactic/Packages.
Updated list of available packages in /var/lib/opkg/iotkit.

Pour permettre aux utilisateurs privilégiés de faire des tâches d'administration ou des interventions sur le système il est nécessaire de mettre en oeuvre un groupe appelé sudo et d'activer ce groupe puis d'y ajouter les utilisateurs privilégiés. Pour cela éditer le fichier /etc/sudoers et décommenter la ligne concernant le sudo

nano /etc/sudoers


## Uncomment to allow members of group sudo to execute any command      
%sudo   ALL=(ALL) ALL  

Une fois le groupe sudo activé dans les "sudoers" il est nécessaire d'ajouter son nom au groupe ainsi que celui de tous les utilisateurs qui pourront avoir accès aux fonctions privilégiées. Éditer le fichier /etc/group et ajouter des noms séparés par des virgules après après "sudo:x:nn:".

nano /etc/group

sudo:x:27:vidal

Les premiers réglages effectués en mode "console" sont terminés, notre Edison est maintenant prêt à être utilisé en mode opérationnel. Le wifi est installé et configuré, il suffit donc de rallumer l'Edison dans un lieu disposant d'un wifi accessible et nous pourrons nous y connecter à distance. Ce mode de connexion souple et fonctionnel est l'un des avantages du SOC par rapport au microcontrolleur, (certes les derniers microcontrolleurs proposent du WIFI mais ils n'ont toujours pas de système).

Le wifi a été connecté en mode "managed" ce qui signifie que notre nano-ordinateur obtient une adresse IP via un serveur DHCP, ce qui est idéal pour s'insérer dans un milieu "connecté". L'Edison propose un autre mode de fonctionnement dit "hotspot" et dans ce cas il devient tête de réseau, serveur DHCP et propose un réseau WIFI privé. Les commandes suivantes permettent d'interroger l'Edison pour savoir quel mode est actif et éventuellement changer de mode, une option permet de rendre le mode persistant et lors d'un nouveau démarrage le WIFI sera proposé dans le mode acif lors de l'arrêt.

Avant de l'éteindre il est sage de récupérer l'adresse MAC de notre Edison nous verrons plus loin qu'elle est utile pour le retrouver sans périphérique connecté.... Pour cela utiliser l'instruction ifconfig.

ifconfig

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

usb0      Link encap:Ethernet  HWaddr zz:zz:zz:zz:zz:zz  
          inet addr:192.168.xxx.xxx  Bcast:192.168.xxx.xxx  Mask:255.255.255.0
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

wlan0     Link encap:Ethernet  HWaddr yy:yy:yy:yy:yy:yy  
          inet addr:192.168.xxx.xxx  Bcast:192.168.xxx.xxx  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:164 errors:0 dropped:0 overruns:0 frame:0
          TX packets:124 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:16218 (15.8 KiB)  TX bytes:16714 (16.3 KiB)

Relever et conserver l'adresse physique du wifi située après HWaddr et qui est de la forme yy:yy:yy:yy:yy:yy .

Pour teriner la configuration de la sécurité installer un dossier .ssh dans son home et déposer sa clef ssh publique puis recopier dans le fichier authorized_keys du dossier .ssh le contenu de sa clef publique.

Pour éteindre le plus proprement possible l'Edison utiliser la commande shutdown en étant root.

sudo su
passwd: 
shutdown -h now

2. Mise en route de l'Edison en fonctionnement standard

l'Edison est un nano-ordinateur de la famille des objets connectés, il est donc totalement autonome et ... connecté ! à condition d'être à proximité d'un serveur DHCP et de disposer d'une source d'énergie !

Suivant le type de carte d'extension utilisée avec l'Edison la situation diffère.

  • Dans le cas du breakout Arduino l'alimentation peut se faire soit via une alimentation classique "barillet" avec le + au centre délivrant entre 5 et 17v, soit via l'un des connecteurs USB, soit via l'une des broches marquées VIN.
  • Dans le cas du minibreakout le connecteur J21 à l'un des angles permet de proposer une alimentation 5-17v, ATTENTION le + est la broche la plus à l'intérieur de la carte; le connecteur J22 dans l'angle opposé permet de fournir 5v, il est possible d'utiliser un des USB comme pour l'Arduino et en plus le minibreakout peut être connecté à une batterie Li-Ion qu'il recharge lorsqu'il est en mode connecté à une source externe sur le connecteur J22.

  • Dans le cas du sparkfun breakout toutes les solutions énumérées ci-dessus sont possibles suivant la carte d'extension ajoutée, les connecteurs USB sont obligatoires sauf dans des cas extrêmement particuliers et on peut donc compter dessus; pour le reste tout est possible ! On notera qu'il existe une extension "batterie" faisant exactement la taille de la carte et proposant une longévité étonnante pour un si petit et si léger élément.

Emplacement des connecteurs J21 et J22

Chacun utilisera donc l'alimentation dont il dispose. Le reste de la présentation est effectué ici en utilisant une carte d'expansion Arduino qui présente le double avantage de la simplicité et de la fourniture d'une tension de 5v nécessaire et suffisante pour allumer des leds. ATTENTION les entrées-sorties du miniBreakout ne fonctionnent que sur 3.3v et 1.8v, les entrées sont exclusivement en 1.8v, pour travailler avec des capteurs en 3.3v ou en 5v il est alors nécessaire d'utiliser un pont pour ajuster les deux tensions.

2.1 Trouver mon Edison sur le réseau

Supposons que nous soyions dans des conditions optimales : Edison correctement alimenté et démarré à proximité du serveur DHCP qui a servi à le configurer. Notre Edison est démarré connecté au réseau mais comment y accéder ? La solution est simple, il suffit de chercher l'adresse IP du réseau associée à l'adresse physique de notre SOC. Depuis un ordinateur situé sur le même réseau que l'Edison taper la commande suivante :

sudo nmap -sP -n 192.168.xxx.0/yy | grep -e zz:zz:zz:zz:zz:zz -B 2
Mot de passe [sudo] de vidal :
Nmap scan report for 192.168.xxx.xxx
Host is up (0.051s latency).
MAC Address: zz:zz:zz:zz:zz:zz (Murata Manufacturing)

Depuis cet ordinateur il est maintenant possible de se connecter directement à l'Edison :

ssh 192.168.xxx.xxx
vidal[~] martymcfly.€ : 

Oui, oui; mon Edison s'appelle "Marty Mc Fly" (en route pour retourner vers le futur avec les objets connectés) et oui en tant qu'européen j'utilise € comme invite à la place du $ habituel dans une console bash....

2.2 Calmer son impatience en allumant quelques diodes

L'Univers que proposent les objets connectés est immense : il s'étend depuis la programmation d'un serveur (web par exemple mais pas seulement) jusqu'au pilotage d'un bus d'acquisition de mesures via des capteurs numériques ou analogiques, ou au pilotage de servomoteurs dans un univers de robotique. Un point d'entrée aisément compréhensible tout en étant riche est celui du pilotage de diodes électroluminescentes les LEDs. La photographie ci dessous illustre 5 montages plus ou moins simples permettant de contrôler des LEDs

Montage de diodes

les montages proposés et les programmes ci-dessous ne sont pas forcément les plus élgants ou les plus performants ils permettent d'illustrer le montage et le contrôle des LEDs en laissant de la place à l'imagination du lecteur pour améliorer les connexions ou les algorithmes. Les programmes s'exécutent en tapant sudo python nomcommande.py.

Ls numéros des connecteurs utilisés correspondent à ceux d'un mini-breakout ou d'un breakout arduino suivant les cas, chacun pourra choisir le connecteur qu'il veut parmi les connecteurs numériques de GPIO-13 à GPIO-2. Les résistances protègent les diodes en réduisant l'intensité du courant qui les parcourt.

Le mini breakout fournit trés peu d'énergie et une faible différence de potentien sur ses broches, utiliser des diodes basse tension ou un arduino breakout ou un montage avec transistors et alimentation externe des diodes

2.2.1 Gérer l'alimentation d'un circuit contenant une diode seulement

Une des pattes de la diode jaune est reliée à la massse et l'autre à l'un des connecteurs numériques qui peut prendre deux états : 1 ou 0. Si la cathode est reliée à la mase et l'anode au connecteur en position 1 la diode est allumée, elle s'éteint si le connecteur passe en position 0. Si la diode est branchée à l'envers elle ne s'allume jamais.

Le programme ci-dessous fait clignotter la diode; elle est allumée pendant 0.2 s puis éteinte pendant 0.3 s. Le connecteur 37 du minibreakout (J19-10) correspond au GPIO-40 et au connecteur 13 de l'arduino. Il faut noter que ce programme fonctionne aussi sans connecton de diode extérieure en faisant clignoter une des deux diodes de la carte.

Localisation du montage une seule diode

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import mraa
import thread, time

# Setup
x = mraa.Gpio(37)
x.dir(mraa.DIR_OUT)

def input_thread(CheckInput):
    check = raw_input()
    CheckInput.append(check)
    return

def blink1(x):
    CheckInput = []
    thread.start_new_thread(input_thread, (CheckInput,))
    print ('Type "stop" to stop blinking')
# Loop
    while True :
        if CheckInput == ['stop']  : break
        x.write(1)
        time.sleep(0.2)
        x.write(0)
        time.sleep(0.5)
    return

blink1(x)

2.2.2 Faire clignoter alternativement une diode rouge et une diode verte

Dans ce montage (petites diodes rouge et verte) les diodes sont montées en parallèle avec les pattes permuttées, chaque paire de pattes des deux diodes est reliée à un connecteur pouvant prendre la valeur 1 ou 0. Trois états sont utilisés :

  • connecteurA = 1 connecteurB = 0,
  • connecteurA = 0 connecteurB = 1,
  • connecteurA = 0 connecteurB = 0
  • qui correspondent à :

  • rouge allumée,

  • verte allumée,
  • les deux éteintes.

Dans ce programme l'une des diodes clignotte deux fois et l'autre une seule fois pendant plus longtemps.

Les connecteurs 38 et 50 corresondent à GPIO-43 / J19-11 / 11 et GPIO-42 / J20-9 / 12 respectivement.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import mraa
import thread, time

# Setup
x = mraa.Gpio(38)
y = mraa.Gpio(50)
x.dir(mraa.DIR_OUT)
y.dir(mraa.DIR_OUT)

# Configuration des pins 
def x_out_0(x):
    x.dir(mraa.DIR_OUT)
    x.write(0)
    return

def x_out_1(x):
    x.dir(mraa.DIR_OUT)
    x.write(1)
    return

def y_out_0(y):
    y.dir(mraa.DIR_OUT)
    y.write(0)
    return

def y_out_1(y):
    y.dir(mraa.DIR_OUT)
    y.write(1)
    return

# Configuration des paires de pins 
# X on
def fn10(x,y):
    x_out_1(x)
    y_out_0(y)
    time.sleep(0.2)
    return

# Y on
def fn01(x,y):
    x_out_0(x)
    y_out_1(y)
    time.sleep(0.6)
    return

# X Y off
def fn00(x,y):
    x_out_0(x)
    y_out_0(y)
    time.sleep(0.2)
    return


# veille sur l'input
def input_thread(CheckInput):
    check = raw_input()
    CheckInput = CheckInput.append(check)
    return

# Clignotement
def SimpleBlink(x,y):
    CheckInput = []
    thread.start_new_thread(input_thread, (CheckInput,))
    print ('Type "stop" to stop blinking')
# Loop
    while True :
        if CheckInput == ['stop']  : 
            fn00(x,y)
            break
        fn10(x,y)
        fn00(x,y)
        fn10(x,y)
        fn01(x,y)
    return

SimpleBlink(x,y)

2.2.3 Faire clignoter alternativement une diode rouge et une diode lorsque l'alimentation est faible

Ce montage un peu plus compliqué requiert deux transistors (2N3904) pour remonter l'intensité du courant dans le cas d'un minibreakout ou d'un breakout Sparkfun. Le montage est identique au précédent pour les diodes une alimentation supplémentaire est reliée à la base et l'émetteur est relié à la masse le collecteur est relié à la diode et au connecteur.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import mraa
import thread, time

# Setup
x = mraa.Gpio(31)
y = mraa.Gpio(45)
x.dir(mraa.DIR_OUT)
y.dir(mraa.DIR_OUT)

# Configuration des pins 
def p_out(x,val):
    x.dir(mraa.DIR_OUT)
    x.write(val)
    return

# Configuration des paires de pins 
# X on
def fnOut(x,valx,y,valy,dur):
    p_out(x,valx)
    p_out(y,valy)
    time.sleep(dur)
    return

# Y on
def fn01(x,y):
    p_out(x,0)
    p_out(y,1)
    time.sleep(0.6)
    return

# X Y off
def fn00(x,y):
    p_out_0(x)
    p_out_0(y)
    time.sleep(0.2)
    return


# veille sur l'input
def input_thread(CheckInput):
    check = raw_input()
    CheckInput = CheckInput.append(check)
    return

# Clignotement
def SimpleBlink(x,y):
    CheckInput = []
    thread.start_new_thread(input_thread, (CheckInput,))
    print ('Type "stop" to stop blinking')
# Loop
    while True :
        if CheckInput == ['stop']  : 
            fn00(x,y)
            break
        fnOut(x,1,y,0,0.2)
        fnOut(x,0,y,0,0.2)
        fnOut(x,1,y,0,0.2)
    fnOut(x,0,y,1,0.6)
    return

SimpleBlink(x,y)

2.2.4 Faire un jeu de lumière représentant un arc-en-ciel avec une diode RGB (Rouge-Vert-Bleu)

Ce montage utilise une diode 3 couleurs Rouge (R) Vert (G) Bleu (B). Les trois diodes ont en commun la cathode at chaque anode est reliée à un connecteur. La différence entre résistances s'expliques par les propriétés différentes des diodes, les valeurs différentes d'intensité dans le programme permettent de compenser la luminance des diodes. Les deux ajustements sont nécessaires pour obtenir toutes les couleurs de l'arc-en-ciel. En cas de déséquilibre certaines couleurs n'apparaissent jamais.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import mraa
import thread, time

# Setup
# Pour équilibrer l'intensité Valeurs différentes nécessaires'
# resistances rouge 2 vert 10 bleu 10
# xyz sens RBG
x = mraa.Pwm(0)
y = mraa.Pwm(20)
z = mraa.Pwm(21)
x.enable(False)
y.enable(False)
z.enable(False)

# Initialisation
def startPin(pin):
    pin.enable(True)
    return

# veille sur l'input
def input_thread(CheckInput):
    check = raw_input()
    CheckInput = CheckInput.append(check)
    return

# Clignotement
def modulColor():
    CheckInput = []
    thread.start_new_thread(input_thread, (CheckInput,))
    print ('Type "stop" to stop modulation')
    x.period_ms(5)
    y.period_ms(5)
    z.period_ms(5)
    stepr = 250
    maxr  = 5000
    stepg = stepr/5
    maxg = maxr/5
    stepb = stepr
    maxb = maxr
# Loop
    while True :
        startPin(x)
        x.pulsewidth_us(maxr)
        startPin(y)
        for value in xrange(0, maxg, stepg):
            y.pulsewidth_us(value)
            time.sleep(0.2)
        y.pulsewidth_us(maxg * 10)
        for value in xrange(0, maxr, stepr):
            value = maxr - value
            x.pulsewidth_us(value)          
            time.sleep(0.2)
        x.pulsewidth_ms(0)
        x.enable(False)             
        startPin(z)
        for value in xrange(0, maxb, stepb):
            z.pulsewidth_us(value)
            time.sleep(0.2)
        z.pulsewidth_us(maxb)
        for value in xrange(0, maxg, stepg):
            value = maxg -value
            y.pulsewidth_us(value)
            time.sleep(0.2)
        y.pulsewidth_ms(0)
        y.enable(False)
        startPin(x)
        for value in xrange(0, maxr, stepr):
            x.pulsewidth_us(value)
            time.sleep(0.2)
        x.pulsewidth_ms(maxr)
        for value in xrange(0, maxb, stepb):
            value = maxb -value
            z.pulsewidth_us(value)
            time.sleep(0.2)
        z.pulsewidth_ms(0)  

# Sortie de boucle infinie
            if CheckInput == ['stop']  : 
            x.enable(True)
            y.enable(True)
            z.enable(True)
                z.write(0.0)
                y.write(0.0)
                x.write(0.0)
                break
    return

modulColor()

2.2.5 Faire un montage permettant de réaliser un "chenillard" : le CharliePlexing

Le charlieplexing est abondamment renseigné sur le net, cette technique permet d'éclairer une diode parmi n*(n+1) en ne disposant que de n connecteurs. L'exemple proposé à 3 fils permet de n'allumer qu'une diode parmi 6. L'effet chenillard est obtenu en propageant le clignottement de coisine en voisine. Un grand nombre de combinaisons est possible.

pour obtenir l'effet arc-en-ciel on utilise les connecteurs PWM qui permettent de moduler l'intensit et de ne pas avoir seulement un état binaire pour les diodes.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import mraa
import thread, time

# Setup
#======
x = mraa.Gpio(10)
y = mraa.Gpio(11)
z = mraa.Gpio(12)
x.dir(mraa.DIR_OUT)
y.dir(mraa.DIR_OUT)
z.dir(mraa.DIR_OUT)

# Set pin status
#===============
def x_in_Z(x):
    x.write(0)
    x.dir(mraa.DIR_IN)
    return

def x_out_0(x):
    x.dir(mraa.DIR_OUT)
    x.write(0)
    return

def x_out_1(x):
    x.dir(mraa.DIR_OUT)
    x.write(1)
    return

def y_in_Z(y):
    y.write(0)
    y.dir(mraa.DIR_IN)
    return

def y_out_0(y):
    y.dir(mraa.DIR_OUT)
    y.write(0)
    return

def y_out_1(y):
    y.dir(mraa.DIR_OUT)
    y.write(1)
    return

def z_in_Z(z):
    z.write(0)
    z.dir(mraa.DIR_IN)
    return

def z_out_0(z):
    z.dir(mraa.DIR_OUT)
    z.write(0)
    return

def z_out_1(z):
    z.dir(mraa.DIR_OUT)
    z.write(1)
    return

# set LED status in xyz order
#============================
def fn10z(x,y,z):
    x_out_1(x)
    y_out_0(y)
    z_in_Z(z)
    time.sleep(0.1)
    return

def fn1z0(x,y,z):
    x_out_1(x)
    y_in_Z(y)
    z_out_0(z)
    time.sleep(0.1)
    return

def fnz10(x,y,z):
    x_in_Z(x)
    y_out_1(y)
    z_out_0(z)
    time.sleep(0.1)
    return

def fnz01(x,y,z):
    x_in_Z(x)
    y_out_0(y)
    z_out_1(z)
    time.sleep(0.1)
    return

def fn0z1(x,y,z):   
    x_out_0(x)
    y_in_Z(y)
    z_out_1(z)
    time.sleep(0.1)
    return

def fn01z(x,y,z):
    x_out_0(x)
    y_out_1(y)
    z_in_Z(z)
    time.sleep(0.1)
    return

def fn000(x,y,z):
    x_in_Z(x)
    y_in_Z(y)
    z_in_Z(z)
    time.sleep(0.05)
    return


def input_thread(CheckInput):
    check = raw_input()
    CheckInput = CheckInput.append(check)
    return

def CharlieBlink6(x,y,z):
    CheckInput = []
    thread.start_new_thread(input_thread, (CheckInput,))
    print ('Tapez "stop" pour arrêter le clignottement.')
# Loop
    while True :
        if CheckInput == ['stop']  : break
        fn10z(x,y,z)
        fn1z0(x,y,z)
        fnz10(x,y,z)
        fnz01(x,y,z)
        fn0z1(x,y,z)
        fn01z(x,y,z)
        fn000(x,y,z)
        fn01z(x,y,z)
        fn0z1(x,y,z)
        fnz01(x,y,z)
        fnz10(x,y,z)
        fn1z0(x,y,z)
        fn10z(x,y,z)
        fn000(x,y,z)
    return


CharlieBlink6(x,y,z)

2.3 Les autres ressources disponibles

Les Edison disposent de toutes les ressources du bus GPIO I2c et SPI, toutefois suivant les cartes d'extension tous les bus ne sont pas accessibles et les librairies mraa et upm ne supportent pas les capteurs "repeated start".

De nombreux capteurs sont disponibles : paramètres physiques, détecteurs de gaz et autres éléments etc, de nombreux projets pédagogiques peuvent être entrepris autour de ces éléments en s'appuyant sur des bases de codage simple.


Webographie

  1. Point d'entrée pour la familiarisation avec un INTEL Edison sur les sites Intel
  2. Procédure d'installation de l'image sur un Edison dans le monde linux
  3. Procédure d'installation de l'image sur un Edison dans le monde windows

Commentaires