Voir la source de MICROPYTHON-MOD-IO2

== Introduction ==
[[Fichier:MICROPYTHON-MOD-IO2-01.jpg|320px]]

{{pl|1409|MOD-IO2}} est une carte de développement permettant d'ajouter des relais, entrées analogiques et digitales, PWM sur n'importe quelles cartes disposant d'un connecteur UEXT ou Bus I2C. Si vous avez besoin de plus d'entrée/sortie (ou entrée analogiques) sur votre projet alors cette carte est le produit qu'il vous faut.

Le connecteur UEXT facilite grandement le raccordement et permet de disposer de 2 relais (5v 250V) et 7 GPIOs (3.3v Max). 

Les cartes MOD-IO2 sont chaînables et adressables. Cela signifie que vous pouvez connecter plusieurs cartes MOD-IO & MOD-IO2 ensembles (après avoir modifié leurs adresses I2C) et vous pourrez toutes les commander indépendamment les unes des autres. Au final, cela fait plein de relais, d'entées/sortie et entrées analogiques! MOD-IO2 est propulsé par un microcontrôleur PIC16F1503 et le firmware est disponible en Open-Source chez le fabriquant.

[[Fichier:MICROPYTHON-MOD-IO2-02.png|480px]]

Caractéristiques de la carte:
* Microcontrôleur PIC16F1503
* Préchargé avec le firmware opensource d'Olimex.<br />Permet un interfaçage facile depuis MicroPython, Arduino et les machines Linux.
* Bornier 9 connexion pour les 7 GPIOs, 3.3V et GND
* Jack d'alimentation (12 VDC)
* 7 GPIOs qui peuvent implémenter différentes fonctionnalités comme I/O, PWM, ANALOG IN out-of-the-box. (vous pouvez modifier le firmware pour implémenter un bus I2C ou SPI).
* 2 sorties elais 10A 250VAC. Relais avec bornier à vis et LEDs de statut
* Dimensions 61x52mm

Voyez {{pl|1409|notre fiche produit pour plus d'informations}}, schéma, utilisation OlinuXino, etc.

== Matériel utilisé ==
Pour réaliser ce test, nous avons utilisé:

{{parts-begin}}

{{parts-item
  |name=ESP8266-EVB
  |descr=ESP8266 Evaluation Board d'Olimex
  |img=ESP8266-EVB.png
  |link=http://shop.mchobby.be/product.php?id_product=668
  |qty=1
}}

{{parts-item
  |name=MOD-IO2
  |descr=Carte MOD-IO2 d'Olimex
  |img=MOD-IO2.png
  |link=http://shop.mchobby.be/product.php?id_product=1409
  |qty=1
}}

{{parts-item
  |name=UEXT-SPLITTER
  |descr=Multiplicateur de port UEXT. Permettra de brancher la carte + Interface USB-Serie
  |img=UEXT-SPLITTER.png
  |link=http://shop.mchobby.be/product.php?id_product=1412
  |qty=1
}}

{{parts-item
  |name=USB-SERIE-TTL
  |descr=Un cable console pour pouvoir communiquer avec l'ESP8266
  |img=USB-SERIE-TTL.png
  |link=http://shop.mchobby.be/product.php?id_product=144
  |qty=1
}}

{{parts-end}}

== Raccordements ==
Les raccordements sont effectués comme suit:

[[Fichier:MICROPYTHON-MOD-IO2-20.png]]

* Un potentiomètre de 10K est branché sur le GPIO 5, il servira a contrôler le générateur PWM sur le GPIO 6.
* Les relais 1 et 2 (sur les 2 relais à disposition) sont activés à tour de rôle par le code Python.

{{ambox-stop|text=Attention: ne pas appliquer plus de 5V sur la carte d'évaluation ESP8266-EVB}}

Le raccordement du '''convertisseur USB-Série''' est identique à celui décrit dans le [[ESP8266-DEV|tutoriel ESP8266-DEV sous MicroPython]].

Etant donné que le l'ESP8266-DEV (et donc ESP8266-EVB) ne disposent pas de convertisseur USB-Série, il sera donc nécessaire d'utiliser {{pl|144|un câble console}} (USB-Série-TTL) pour communiquer avec la carte ESP8266. 

[[Fichier:UEXT-SERIAL-wiring.jpg|360px]]

== Flasher MicroPython ==
Pour flasher MicroPython sur l'ESP8266-DEV (module ESP8266) qui équipe la carte d'évaluation d'Olimex (ESP8266-EVB), nous vous proposons les lectures suivantes:

{{ESP8266-MICROPYTHON-SUBTUTO}}

== Bibliothèque modio2 ==
Avant d'utiliser le script d'exemple, il est nécessaire de transférer la '''bibliothèque modio2''' sur votre carte MicroPython.

La [https://github.com/mchobby/esp8266-upy/tree/master/modio2 bibliothèque '''modio2''' et sa documentation] sont disponibles dans le [https://github.com/mchobby/esp8266-upy GitHub esp8266-uPy].

{{download-box|Télécharger la bibliothèque ESP8266-uPy|https://github.com/mchobby/esp8266-upy/archive/master.zip}}

Puis:
* Copier le fichier {{fname|modio2.py}} sur la carte micropython.

Vous pouvez également transférer le script de test {{fname|test2.py}} et {{fname|test2pwm.py}} sur la carte MicroPython.

== Code ==
=== BUS I2C ===
La carte MOD-IO2 utilise le bus I2C (adresse par défaut est 0x21) pour communiquer avec le MicroContrôleur.

Ce bus I2C est disponible sur le connecteur UEXT de notre ESP8266-EVB comme le montre le tableau suivant.

[[Fichier:ESP8266-DEV-12.jpg|480px]]

En adaptant le code (et les raccordements du bus I2C), vous pourriez tout aussi facilement faire fonctionner des cartes ESP8266 comme {{pl|67|Feather ESP8266 Huzza}} ou {{cl|121|Wemos D1}}.

=== Fonctions GPIOs du MOD-IO2 ===
Voici les différentes fonctionnalités possibles sur le GPIO du MOD-IO2

[[Fichier:MICROPYTHON-MOD-IO2-GPIO.png|320px]]

=== Fonctionnalités du MOD-IO2 ===
Voici l'exemple commenté en Français.

<syntaxhighlight lang="python">
# Utilisation du MOD-IO2 d'Olimex avec un ESP8266 sous MicroPython
#
# Shop: [UEXT Expandable Input/Output board (MOD-IO2)](http://shop.mchobby.be/product.php?id_product=1409)
# GitHub: https://github.com/mchobby/esp8266-upy/tree/master/modio2

from machine import I2C, Pin
from time import sleep_ms
from modio2 import MODIO2

i2c = I2C( sda=Pin(2), scl=Pin(4) )
brd = MODIO2( i2c ) # Adresse par défaut=0x21

# === Manipuler les GPIOs =============================
print( "Afficher le mode des broches")
print( brd.gpios.pin_modes )
# Devrait retourner: ['IN', 'IN', 'IN', 'IN', 'IN', 'IN', 'IN']

print( "GPIO 5 - Lecture analogique")
brd.gpios.pin_mode( 5, Pin.IN )
for i in range(10):
    volt = brd.gpios.analog(5)
    print( "GPIO 5 (AN7) = %s v" % volt )
    val  = brd.gpios.analog(5, raw=True )
    print( "GPIO 5 (AN7) = %s / 1023" % val )
    sleep_ms( 1000 )

print( "GPIO 0 - en sortie OUT (allumé puis éteind)" )
brd.gpios.pin_mode( 0, Pin.OUT )
brd.gpios[0] = True
sleep_ms( 2000 )
brd.gpios[0] = False

print( "GPIO 1,2,3 - en entrée IN" )
brd.gpios.pin_mode( 1, Pin.IN )
brd.gpios.pin_mode( 2, Pin.IN )
brd.gpios.pin_mode( 3, Pin.IN, Pin.PULL_UP ) # la pull up est obligatoire sur pin 3
print( "Afficher le mode des broches")
print( brd.gpios.pin_modes )
# Doit afficher ['OUT', 'IN', 'IN', 'IN', 'IN', 'IN', 'IN']

print( "Afficher l'état de toutes les I/O (1/0)" )
print( brd.gpios.states )
# doit afficher [False, False, True, False, False, True, False]

# === RELAIS ======================================
# Modifier les états des relais REL1 et REL2.
# Les relais sont indexés à partir de 0
print( 'Modif. relais par index' )
brd.relais[0] = True
brd.relais[1] = False
print( 'Etat Relais[0..1] : %s' % brd.relais.states )
# Doit afficher Relais[0..1] states : [True, False]  
sleep_ms( 2000 )

# Eteindre tous les relais
brd.relais.states = False 

print( 'Manipuler 1 relais à la fois')
for irelay in range( 2 ):
    print( '   relais %s' % (irelay+1) )
    brd.relais[irelay] = True # Allumer
    sleep_ms( 1000 )
    brd.relais[irelay] = False # Eteindre
    sleep_ms( 500 )

print( 'Manipuler plusieurs relais' )
brd.relais.states = [False, True]
sleep_ms( 2000 )
print( 'Activer tous les relais' )
brd.relais.states = True
sleep_ms( 2000 )
print( 'Eteindre tous les relais' )
brd.relais.states = False

print( "That's the end folks")
</syntaxhighlight>

=== Exemple PWM ===
PWM est uniquement disponible sur les GPIO GPIO 5 & 6.

Dans l'exemple ci-dessous, un potentiomètre de 10 KOhms permet de fournir une valeur analogique sur le GPIO 5 (lecture en RAW, 0 à 1024).

Cette valeur est ensuite utilisée pour fixer le cycle utile PWM du GPIO 6 (0 à 255).

Comme la lecture analogique fournit un résultat entre 0 et 1024, il faut diviser celle-ci par 4 pour fixer le cycle utile PWM.

Le script s'arrête lorsque le signal PWM atteind 100% du cycle utile.


<syntaxhighlight lang="python">
# Test PWM sur le MOD-IO2 d'Olimex avec un ESP8266 sous MicroPython
#
# Shop: http://shop.mchobby.be/product.php?id_product=1409
# GitHub: https://github.com/mchobby/esp8266-upy/tree/master/modio2

from machine import I2C, Pin
from time import sleep_ms
from modio2 import MODIO2

i2c = I2C( sda=Pin(2), scl=Pin(4) )
brd = MODIO2( i2c ) # Adresse par défaut=0x21

print( "GPIO 5 - IN")
brd.gpios.pin_mode( 5, Pin.IN )

print( "GPIO 6 - PWM" )
brd.gpios.pwm( gpio=6, cycle=0 )

cycle=0
while cycle<255:
    val = brd.gpios.analog( 5, raw = True )
    cycle = val // 4   # de 0..1023 a 0..254
    if cycle >= 254:   # Assure 100% du cycle utile
        cycle = 255
    brd.gpios.pwm( 6, cycle )
    print( "val=%s -> cycle=%s" %(val,cycle) )
    sleep_ms( 1000 )

print( "That's the end folks")
</syntaxhighlight>

Ce qui affiche le résultat suivant à l'écran pendant que l'on exécute le script:
<syntaxhighlight lang="python">
MicroPython v1.9.4-8-ga9a3caad0 on 2018-05-11; ESP module with ESP8266
Type "help()" for more information.
>>> 
>>> import test2pwm
GPIO 5 - IN
GPIO 6 - PWM
val=698 -> cycle=174
val=698 -> cycle=174
val=620 -> cycle=155
val=614 -> cycle=153
val=597 -> cycle=149
val=496 -> cycle=124
val=494 -> cycle=123
val=701 -> cycle=175
val=880 -> cycle=220
val=978 -> cycle=244
val=979 -> cycle=244
val=982 -> cycle=245
val=1023 -> cycle=255
That's the end folks
>>>  
</syntaxhighlight>

=== Changer l'adresse I2C de la carte ===
Les cartes MOD-IO sont conçues pour être chaînable. Il faut donc que chacune d'entre-elles aient une adresse différente sur le bus I2C.

Si vous voulez utiliser plusieurs cartes, il faudra configurer une adresse I2C différente pour chacune d'entre-elles (adresse qu'il fait configurer en connectant une seule carte à la fois).

{{ambox-stop|text=Il faut maintenir le bouton BUT enfoncé pendant l'exécution de la commande {{fname|change_address()}} .}}

<syntaxhighlight lang="python">
# Modifier l'adresse de MOD-IO2 d'Olimex vers 0x22
#
# Shop: http://shop.mchobby.be/product.php?id_product=1408
# GitHub: https://github.com/mchobby/esp8266-upy/tree/master/modio2

from machine import I2C, Pin
from modio2 import MODIO2

i2c = I2C( sda=Pin(2), scl=Pin(4) )
brd = MODIO2( i2c, addr=0x21 )
brd.change_address( 0x22 )
</syntaxhighlight>

== Où acheter ==
* Le {{pl|668|ESP8266-EVB}} utilisé dans ce tutoriel pour faciliter le raccordement. Pourrait fonctionner avec un {{pl|846|Feather ESP8266}} avec le raccordement adéquat. 
* Le {{pl|667|ESP8266-DEV}} module équipant la carte ESP8266-EVB.
* Le {{pl|1409|module MOD-IO2}}
* Le {{pl|1412|module UEXT Splitter}}
* La {{cl|67|La gamme IoT/ESP8266}} disponible chez MC Hobby
* Un {{pl|144|Convertisseur USB-Série TLL}}

<hr />
<small>Tutoriel réaliser par Meurisse D. pour [http://shop.mchobby.be MC Hobby SPRL]</small>

{{MCH-Accord}}