MCHobby - Wiki - Contributions de l’utilisateur [fr]

ENG-CANSAT-PICO-THONNY

2026-04-25T22:44:43Z

Admin : /* Connect your PymateIO */

{{ENG-CANSAT-PICO-NAV}}

== Abstract ==
There is no need for a specific development environment to work with a MicroPython plateforms.

A simple text editor is quite enough to write python scripts.

Command line utility like {{fname|mpremote}} can be used to copy/run python scripts on the board.

== Thonny editor ==
By the way, a enhanced tool like [https://thonny.org/ Thonny IDE] can definitively improve the user experience and interaction with the Pico.

[[Fichier:ENG-CANSAT-PICO-THONNY-00.png|480px]]

Thonny is multi-plateform editor running on Linux, Windows, Mac.

The beauty about Thonny Python Script editor is that Thonny is written in Python.

[https://thonny.org/ Thonny IDE] is a great python script editor can also be used with MicroPython Microcontrolers:
* Raspberry-Pi Pico
* RP2040 base MicroPython board (like PYBStick RP2040 or MicroMod-RP2040, etc)
* ESP32 under MicroPython
* ESP8266 under MicroPython
* etc

Thonny offers great features for MicroPython microconroler:
* transfer script to MicroPython microcontroler.
* manage files on the MicroPython microcontroler.
* run script against MicroPython microcontroler.
* using the micropython interactive command line (named REPL)
* generating graphical data (an awesome feature)

== Install Thonny IDE ==

{{ambox|text=It is important to have a recent version of thonny and plug-ins to use it with MicroPython boards.}}

[https://thonny.org/ Thonny website] contains the required instruction to install Thonny IDE.

=== On Raspberry-Pi ===
Just open a terminal and execute the following command line:

<nowiki>$ sudo apt update && sudo apt upgrade -y</nowiki>

This will upgrade the operating system and install the latest version of Thonny IDE.

=== On Linux ===
Python3 is available on almost every Linux operating system. So Thonny (which is written in Python) is installed with the {{fname|pip3}} ''Python Install Package'' software.

<nowiki>$ pip3 install thonny</nowiki>

=== Windows & Mac ===
Refer to the official [https://thonny.org/ Thonny.org] documentation.

== Working with Thonny ==

The Thonny environment look very sober at first sight.

Don't be fooled by this simplicity, Thonny do have everything you need under the hood.

[[Fichier:ENG-CANSAT-PICO-THONNY-00.png|480px]]

From top to bottom:
* The Menubar,
* The Toolbar (with icones),
* Text/code editor is the main part
* A Shell interface (at the bottom) used to quickly test Python code.

=== Thonny and MicroPython ===

By default, Thonny use the computer's Python interpreter in the "Shell" section.

So to work with a MicroPython board, the user must inform Thonny to use the appropriate shell.

For instance the REPL shell exposed by the MicroPython microcontroler on its serial interface.

Just click and the "shell selection" popup at the bottom-right corner of the screen. In the popup menu selects the "MicroPython" entry attached to the MicroPython board.

[[Fichier:ENG-CANSAT-PICO-THONNY-01.png|480px]]

Once the entry selected, Thonny does establish a connection with the MicroPython command line interpreter (REPL) running on the MicroPython board.

If the connection fails then you can press the "stop" button on the toolbar to make a new connection attempt.

The image here below MicroPython shell (REPL, as it is executed on the microcontroler). This would work the same for any of the RP2040 based microcontroler (like the MicroMod-RP2040, PYBStick RP2040, etc).

[[Fichier:ENG-CANSAT-PICO-THONNY-02.png|480px]]

=== LED Blinking ===
Now that we have selected the MicroPython REPL as interactive shell, can use it to control the Pico onboard LED.

The Pico onboard LED is attached to the pin GP25.

[[Fichier:ENG-CANSAT-PICO-THONNY-03.png|640px]]

It can be controled with few lines of codes, just key-in them directly in the REPL session

<syntaxhighlight lang="python">
from machine import Pin
led = Pin(25, Pin.OUT)
led.value(1) # allume la LED
led.value(0) # éteint la LED
</syntaxhighlight>

The following screen capture just show the results of entering the command lines.

[[Fichier:ENG-CANSAT-PICO-THONNY-04.png|480px]]

by entering {{fname|led.value()}} without parameter, you can query the current pin state (1 for High level, 0 for Low level).

=== Run & Stop a file ===
With Thonny you can also write Python code inside a file and execute it at once on the target MicroPython board.

In the following example, the status LED (GP25) is pulsed by controling the output pin with PWM signal.

PWM stand for ''Pulse Width Modulation'', see this [https://www.electronicwings.com/pic/pic18f4550-pwm animation on ElectronicWings clearly show a PWM signal with its duty cycle and results on a LED].

Under MicroPython, the duty cycle is set with {{fname|duty_16( value )}} where value is a number from 0 to 65534 (for duty cycle from 0 to 100% .

Key-in the following code into the main's Thonny section (the code editor):

<syntaxhighlight lang="python">
import time
led = PWM( Pin(25 ))
counter = 0
while True:
print( counter )
counter += 1
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*i/100) )
time.sleep_ms( 50 )
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*(100-i)/100) )
time.sleep_ms( 50 )
</syntaxhighlight>

Then save the file under the name "demo.py" either on the computer, either on the microcontroler board.

No matter where it is saved (computer or microcontroler), it can be executed against the microcontroler and shows the results into the REPL/shell session.

To execute the script, you can either:
* Press the "Start" button [[Fichier:ENG-CANSAT-PICO-THONNY-05.png]] of the toolbar
* Select the menu "'''Run | Run current script'''"
* Press the "F5" key

[[Fichier:ENG-CANSAT-PICO-THONNY-06.png|480px]]

The script execution will displays the {{fname|print()}} messages into the Shell section of Thonny.

As you may guess, the onboard status LED is also pulsing.

To stop the script (since it run infinitly), you can either:
* press the "Stop" button on the toolbar
* Press the "Ctrl+C" combination into the shell section

=== Use the plotter ===
The plotter is a graphical tool displaying script outputs generated with {{fname|print()}} as graphics.

The graphics is updated each time a new information appears in the output.

The Plotter can be activated with the "'''View | Plotter'''" menu.

That action displays a graphical tool aside the shell section.

[[Fichier:ENG-CANSAT-PICO-THONNY-10.png|480px]]

The Plotter catch the numeric values sends/print in the REPL/Shell and displays it in the chart.

Only lines containing numeric values are used by the plotter.

On the following example, named {{fname|demo2.py}}, we do use the gamma function to make the LED pulsing in a more natural way. Indeed, a progressive PWM signal increase would not offers a proportional luminosity increase on the LED (voir livre [https://www.editions-eni.fr/livre/micropython-et-pyboard-python-sur-microcontroleur-de-la-prise-en-main-a-l-utilisation-avancee-9782409022906 MicroPython et Pyboard, Edition ENI], in French).

We do use the {{fname|gamma()}} function to rectify the apparent proportionality between the PWM and emitted light.

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))

def gamma( pc ):
return pow(pc/100,2.2)*100

while True:
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )</nowiki>
</syntaxhighlight>

Which produce the following results in Thonny and activated Plotter.

[[Fichier:ENG-CANSAT-PICO-THONNY-11.png|480px]]

'''{{underline|Drawing several curves}}'''

By modifying the script, we can return the PWM value and the gamma corrected value by using a [https://www.w3schools.com/python/python_tuples.asp Python tuple]. Then the plotter will draw several curves.

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))

def gamma( pc ):
return pow(pc/100,2.2)*100

while True:
for i in range( 0, 100, 5 ):
pwm = int( i*65534/100 )
pwm_gamma = int(gamma(i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm = int((100-i)*65534/100)
pwm_gamma = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
</syntaxhighlight>

Which produce the following results in Thonny.

[[Fichier:ENG-CANSAT-PICO-THONNY-12.png|480px]]

As seen in the REPL/Shell output, the data are return under the format (pwm, pwm_gamma) . The first value is the proportional curve and the second value the gamma fixed value.

The plotter does show the curve correspondence between tuple value position and drawed curve (see to bottom right corner).

== System Shell - Pure REPL ==
It is also possible to start a Pure REPL session inside an external terminal. By using a external terminal, the user escape from the Thonny shell panel and being directly connected to the microcontroler via an USB serial connection.

The "'''Tools | Open System Shell..'''" menu will open the terminal Window.

[[Fichier:ENG-CANSAT-PICO-THONNY-20.png|640px]]

{{underline|Notes:}}
* Thonny must be connected to the target plateform to be able to open the External Terminal.
* The file manager can helps to check, whether or not, when Thonny is connected to the MicroPython board.
* It is not possible to open two terminal session (at the same time) to the MicroPython microcontroler.

== File manager ==

It is common to copy library/libraries on the board.

This will requires to '''transfer one (or several) files to the MicroPython board'''.

Such '''libraries''' are usually python scripts (eg: ce [https://raw.githubusercontent.com/mchobby/esp8266-upy/master/bme280-bmp280/bme280.py bme280.py file]) coded for target sensors (eg: [https://github.com/mchobby/esp8266-upy/tree/master/bme280-bmp280 BME280 atmospheric & temperature I2C sensor]).

Thank to Thonny you also have a dedicated "file manager" tool used to transfert files between the computer and the MicroPython board.

The file manager is available via the "'''View | Files'''" menu.

[[Fichier:ENG-CANSAT-PICO-THONNY-30.png|480px]]

Which would display the Thonny file manager.

[[Fichier:ENG-CANSAT-PICO-THONNY-31.png|480px]]

To transfer a file from the computer to the MicroPython board, you will need to :
* Select the file into the "Computer" pane
* Activate the contextual menu (mouse right click)
* Select the option "Upload to" in the menu

{{ambox|text=The "/" drawed into the menu match the root folder on the target (the microcontroler in this case).}}

[[Fichier:ENG-CANSAT-PICO-THONNY-32.png|480px]]

It would be easy to identify the features and behavior of the file manager by exploring and testing the various entries in the contextual menu. Please note that contectual menu are different in the board pane and computer pane.

{{ENG-CANSAT-PICO-TRAILER}}

ENG-CANSAT-PICO-THONNY

2026-04-25T22:43:19Z

Admin : /* Connect your PymateIO */

{{ENG-CANSAT-PICO-NAV}}

== Abstract ==
There is no need for a specific development environment to work with a MicroPython plateforms.

A simple text editor is quite enough to write python scripts.

Command line utility like {{fname|mpremote}} can be used to copy/run python scripts on the board.

== Thonny editor ==
By the way, a enhanced tool like [https://thonny.org/ Thonny IDE] can definitively improve the user experience and interaction with the Pico.

[[Fichier:ENG-CANSAT-PICO-THONNY-00.png|480px]]

Thonny is multi-plateform editor running on Linux, Windows, Mac.

The beauty about Thonny Python Script editor is that Thonny is written in Python.

[https://thonny.org/ Thonny IDE] is a great python script editor can also be used with MicroPython Microcontrolers:
* Raspberry-Pi Pico
* RP2040 base MicroPython board (like PYBStick RP2040 or MicroMod-RP2040, etc)
* ESP32 under MicroPython
* ESP8266 under MicroPython
* etc

Thonny offers great features for MicroPython microconroler:
* transfer script to MicroPython microcontroler.
* manage files on the MicroPython microcontroler.
* run script against MicroPython microcontroler.
* using the micropython interactive command line (named REPL)
* generating graphical data (an awesome feature)

== Install Thonny IDE ==

{{ambox|text=It is important to have a recent version of thonny and plug-ins to use it with MicroPython boards.}}

[https://thonny.org/ Thonny website] contains the required instruction to install Thonny IDE.

=== On Raspberry-Pi ===
Just open a terminal and execute the following command line:

<nowiki>$ sudo apt update && sudo apt upgrade -y</nowiki>

This will upgrade the operating system and install the latest version of Thonny IDE.

=== On Linux ===
Python3 is available on almost every Linux operating system. So Thonny (which is written in Python) is installed with the {{fname|pip3}} ''Python Install Package'' software.

<nowiki>$ pip3 install thonny</nowiki>

=== Windows & Mac ===
Refer to the official [https://thonny.org/ Thonny.org] documentation.

== Working with Thonny ==

The Thonny environment look very sober at first sight.

Don't be fooled by this simplicity, Thonny do have everything you need under the hood.

[[Fichier:ENG-CANSAT-PICO-THONNY-00.png|480px]]

From top to bottom:
* The Menubar,
* The Toolbar (with icones),
* Text/code editor is the main part
* A Shell interface (at the bottom) used to quickly test Python code.

=== Connect your PymateIO ===

First think first: The PymateIO must be connected to the computer prior to establish a connection between Thonny IDE and PymateIO.

Few seconds after USB connexion, the PymateIO shows its internal filesystem as PymateIO drive.

=== Thonny and MicroPython ===

By default, Thonny use the computer's Python interpreter in the "Shell" section.

So to work with a MicroPython board, the user must inform Thonny to use the appropriate shell.

For instance the REPL shell exposed by the MicroPython microcontroler on its serial interface.

Just click and the "shell selection" popup at the bottom-right corner of the screen. In the popup menu selects the "MicroPython" entry attached to the MicroPython board.

[[Fichier:ENG-CANSAT-PICO-THONNY-01.png|480px]]

Once the entry selected, Thonny does establish a connection with the MicroPython command line interpreter (REPL) running on the MicroPython board.

If the connection fails then you can press the "stop" button on the toolbar to make a new connection attempt.

The image here below MicroPython shell (REPL, as it is executed on the microcontroler). This would work the same for any of the RP2040 based microcontroler (like the MicroMod-RP2040, PYBStick RP2040, etc).

[[Fichier:ENG-CANSAT-PICO-THONNY-02.png|480px]]

=== LED Blinking ===
Now that we have selected the MicroPython REPL as interactive shell, can use it to control the Pico onboard LED.

The Pico onboard LED is attached to the pin GP25.

[[Fichier:ENG-CANSAT-PICO-THONNY-03.png|640px]]

It can be controled with few lines of codes, just key-in them directly in the REPL session

<syntaxhighlight lang="python">
from machine import Pin
led = Pin(25, Pin.OUT)
led.value(1) # allume la LED
led.value(0) # éteint la LED
</syntaxhighlight>

The following screen capture just show the results of entering the command lines.

[[Fichier:ENG-CANSAT-PICO-THONNY-04.png|480px]]

by entering {{fname|led.value()}} without parameter, you can query the current pin state (1 for High level, 0 for Low level).

=== Run & Stop a file ===
With Thonny you can also write Python code inside a file and execute it at once on the target MicroPython board.

In the following example, the status LED (GP25) is pulsed by controling the output pin with PWM signal.

PWM stand for ''Pulse Width Modulation'', see this [https://www.electronicwings.com/pic/pic18f4550-pwm animation on ElectronicWings clearly show a PWM signal with its duty cycle and results on a LED].

Under MicroPython, the duty cycle is set with {{fname|duty_16( value )}} where value is a number from 0 to 65534 (for duty cycle from 0 to 100% .

Key-in the following code into the main's Thonny section (the code editor):

<syntaxhighlight lang="python">
import time
led = PWM( Pin(25 ))
counter = 0
while True:
print( counter )
counter += 1
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*i/100) )
time.sleep_ms( 50 )
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*(100-i)/100) )
time.sleep_ms( 50 )
</syntaxhighlight>

Then save the file under the name "demo.py" either on the computer, either on the microcontroler board.

No matter where it is saved (computer or microcontroler), it can be executed against the microcontroler and shows the results into the REPL/shell session.

To execute the script, you can either:
* Press the "Start" button [[Fichier:ENG-CANSAT-PICO-THONNY-05.png]] of the toolbar
* Select the menu "'''Run | Run current script'''"
* Press the "F5" key

[[Fichier:ENG-CANSAT-PICO-THONNY-06.png|480px]]

The script execution will displays the {{fname|print()}} messages into the Shell section of Thonny.

As you may guess, the onboard status LED is also pulsing.

To stop the script (since it run infinitly), you can either:
* press the "Stop" button on the toolbar
* Press the "Ctrl+C" combination into the shell section

=== Use the plotter ===
The plotter is a graphical tool displaying script outputs generated with {{fname|print()}} as graphics.

The graphics is updated each time a new information appears in the output.

The Plotter can be activated with the "'''View | Plotter'''" menu.

That action displays a graphical tool aside the shell section.

[[Fichier:ENG-CANSAT-PICO-THONNY-10.png|480px]]

The Plotter catch the numeric values sends/print in the REPL/Shell and displays it in the chart.

Only lines containing numeric values are used by the plotter.

On the following example, named {{fname|demo2.py}}, we do use the gamma function to make the LED pulsing in a more natural way. Indeed, a progressive PWM signal increase would not offers a proportional luminosity increase on the LED (voir livre [https://www.editions-eni.fr/livre/micropython-et-pyboard-python-sur-microcontroleur-de-la-prise-en-main-a-l-utilisation-avancee-9782409022906 MicroPython et Pyboard, Edition ENI], in French).

We do use the {{fname|gamma()}} function to rectify the apparent proportionality between the PWM and emitted light.

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))

def gamma( pc ):
return pow(pc/100,2.2)*100

while True:
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )</nowiki>
</syntaxhighlight>

Which produce the following results in Thonny and activated Plotter.

[[Fichier:ENG-CANSAT-PICO-THONNY-11.png|480px]]

'''{{underline|Drawing several curves}}'''

By modifying the script, we can return the PWM value and the gamma corrected value by using a [https://www.w3schools.com/python/python_tuples.asp Python tuple]. Then the plotter will draw several curves.

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))

def gamma( pc ):
return pow(pc/100,2.2)*100

while True:
for i in range( 0, 100, 5 ):
pwm = int( i*65534/100 )
pwm_gamma = int(gamma(i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm = int((100-i)*65534/100)
pwm_gamma = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
</syntaxhighlight>

Which produce the following results in Thonny.

[[Fichier:ENG-CANSAT-PICO-THONNY-12.png|480px]]

As seen in the REPL/Shell output, the data are return under the format (pwm, pwm_gamma) . The first value is the proportional curve and the second value the gamma fixed value.

The plotter does show the curve correspondence between tuple value position and drawed curve (see to bottom right corner).

== System Shell - Pure REPL ==
It is also possible to start a Pure REPL session inside an external terminal. By using a external terminal, the user escape from the Thonny shell panel and being directly connected to the microcontroler via an USB serial connection.

The "'''Tools | Open System Shell..'''" menu will open the terminal Window.

[[Fichier:ENG-CANSAT-PICO-THONNY-20.png|640px]]

{{underline|Notes:}}
* Thonny must be connected to the target plateform to be able to open the External Terminal.
* The file manager can helps to check, whether or not, when Thonny is connected to the MicroPython board.
* It is not possible to open two terminal session (at the same time) to the MicroPython microcontroler.

== File manager ==

It is common to copy library/libraries on the board.

This will requires to '''transfer one (or several) files to the MicroPython board'''.

Such '''libraries''' are usually python scripts (eg: ce [https://raw.githubusercontent.com/mchobby/esp8266-upy/master/bme280-bmp280/bme280.py bme280.py file]) coded for target sensors (eg: [https://github.com/mchobby/esp8266-upy/tree/master/bme280-bmp280 BME280 atmospheric & temperature I2C sensor]).

Thank to Thonny you also have a dedicated "file manager" tool used to transfert files between the computer and the MicroPython board.

The file manager is available via the "'''View | Files'''" menu.

[[Fichier:ENG-CANSAT-PICO-THONNY-30.png|480px]]

Which would display the Thonny file manager.

[[Fichier:ENG-CANSAT-PICO-THONNY-31.png|480px]]

To transfer a file from the computer to the MicroPython board, you will need to :
* Select the file into the "Computer" pane
* Activate the contextual menu (mouse right click)
* Select the option "Upload to" in the menu

{{ambox|text=The "/" drawed into the menu match the root folder on the target (the microcontroler in this case).}}

[[Fichier:ENG-CANSAT-PICO-THONNY-32.png|480px]]

It would be easy to identify the features and behavior of the file manager by exploring and testing the various entries in the contextual menu. Please note that contectual menu are different in the board pane and computer pane.

{{ENG-CANSAT-PICO-TRAILER}}

ENG-CANSAT-PICO-THONNY

2026-04-25T22:39:44Z

Admin : /* Thonny and MicroPython */

{{ENG-CANSAT-PICO-NAV}}

== Abstract ==
There is no need for a specific development environment to work with a MicroPython plateforms.

A simple text editor is quite enough to write python scripts.

Command line utility like {{fname|mpremote}} can be used to copy/run python scripts on the board.

== Thonny editor ==
By the way, a enhanced tool like [https://thonny.org/ Thonny IDE] can definitively improve the user experience and interaction with the Pico.

[[Fichier:ENG-CANSAT-PICO-THONNY-00.png|480px]]

Thonny is multi-plateform editor running on Linux, Windows, Mac.

The beauty about Thonny Python Script editor is that Thonny is written in Python.

[https://thonny.org/ Thonny IDE] is a great python script editor can also be used with MicroPython Microcontrolers:
* Raspberry-Pi Pico
* RP2040 base MicroPython board (like PYBStick RP2040 or MicroMod-RP2040, etc)
* ESP32 under MicroPython
* ESP8266 under MicroPython
* etc

Thonny offers great features for MicroPython microconroler:
* transfer script to MicroPython microcontroler.
* manage files on the MicroPython microcontroler.
* run script against MicroPython microcontroler.
* using the micropython interactive command line (named REPL)
* generating graphical data (an awesome feature)

== Install Thonny IDE ==

{{ambox|text=It is important to have a recent version of thonny and plug-ins to use it with MicroPython boards.}}

[https://thonny.org/ Thonny website] contains the required instruction to install Thonny IDE.

=== On Raspberry-Pi ===
Just open a terminal and execute the following command line:

<nowiki>$ sudo apt update && sudo apt upgrade -y</nowiki>

This will upgrade the operating system and install the latest version of Thonny IDE.

=== On Linux ===
Python3 is available on almost every Linux operating system. So Thonny (which is written in Python) is installed with the {{fname|pip3}} ''Python Install Package'' software.

<nowiki>$ pip3 install thonny</nowiki>

=== Windows & Mac ===
Refer to the official [https://thonny.org/ Thonny.org] documentation.

== Working with Thonny ==

The Thonny environment look very sober at first sight.

Don't be fooled by this simplicity, Thonny do have everything you need under the hood.

[[Fichier:ENG-CANSAT-PICO-THONNY-00.png|480px]]

From top to bottom:
* The Menubar,
* The Toolbar (with icones),
* Text/code editor is the main part
* A Shell interface (at the bottom) used to quickly test Python code.

=== Connect your PymateIO ===

First think first: prior to establish a connection between Thonny IDE and the PymateIO board, the board must be connected to the computer.

=== Thonny and MicroPython ===

By default, Thonny use the computer's Python interpreter in the "Shell" section.

So to work with a MicroPython board, the user must inform Thonny to use the appropriate shell.

For instance the REPL shell exposed by the MicroPython microcontroler on its serial interface.

Just click and the "shell selection" popup at the bottom-right corner of the screen. In the popup menu selects the "MicroPython" entry attached to the MicroPython board.

[[Fichier:ENG-CANSAT-PICO-THONNY-01.png|480px]]

Once the entry selected, Thonny does establish a connection with the MicroPython command line interpreter (REPL) running on the MicroPython board.

If the connection fails then you can press the "stop" button on the toolbar to make a new connection attempt.

The image here below MicroPython shell (REPL, as it is executed on the microcontroler). This would work the same for any of the RP2040 based microcontroler (like the MicroMod-RP2040, PYBStick RP2040, etc).

[[Fichier:ENG-CANSAT-PICO-THONNY-02.png|480px]]

=== LED Blinking ===
Now that we have selected the MicroPython REPL as interactive shell, can use it to control the Pico onboard LED.

The Pico onboard LED is attached to the pin GP25.

[[Fichier:ENG-CANSAT-PICO-THONNY-03.png|640px]]

It can be controled with few lines of codes, just key-in them directly in the REPL session

<syntaxhighlight lang="python">
from machine import Pin
led = Pin(25, Pin.OUT)
led.value(1) # allume la LED
led.value(0) # éteint la LED
</syntaxhighlight>

The following screen capture just show the results of entering the command lines.

[[Fichier:ENG-CANSAT-PICO-THONNY-04.png|480px]]

by entering {{fname|led.value()}} without parameter, you can query the current pin state (1 for High level, 0 for Low level).

=== Run & Stop a file ===
With Thonny you can also write Python code inside a file and execute it at once on the target MicroPython board.

In the following example, the status LED (GP25) is pulsed by controling the output pin with PWM signal.

PWM stand for ''Pulse Width Modulation'', see this [https://www.electronicwings.com/pic/pic18f4550-pwm animation on ElectronicWings clearly show a PWM signal with its duty cycle and results on a LED].

Under MicroPython, the duty cycle is set with {{fname|duty_16( value )}} where value is a number from 0 to 65534 (for duty cycle from 0 to 100% .

Key-in the following code into the main's Thonny section (the code editor):

<syntaxhighlight lang="python">
import time
led = PWM( Pin(25 ))
counter = 0
while True:
print( counter )
counter += 1
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*i/100) )
time.sleep_ms( 50 )
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*(100-i)/100) )
time.sleep_ms( 50 )
</syntaxhighlight>

Then save the file under the name "demo.py" either on the computer, either on the microcontroler board.

No matter where it is saved (computer or microcontroler), it can be executed against the microcontroler and shows the results into the REPL/shell session.

To execute the script, you can either:
* Press the "Start" button [[Fichier:ENG-CANSAT-PICO-THONNY-05.png]] of the toolbar
* Select the menu "'''Run | Run current script'''"
* Press the "F5" key

[[Fichier:ENG-CANSAT-PICO-THONNY-06.png|480px]]

The script execution will displays the {{fname|print()}} messages into the Shell section of Thonny.

As you may guess, the onboard status LED is also pulsing.

To stop the script (since it run infinitly), you can either:
* press the "Stop" button on the toolbar
* Press the "Ctrl+C" combination into the shell section

=== Use the plotter ===
The plotter is a graphical tool displaying script outputs generated with {{fname|print()}} as graphics.

The graphics is updated each time a new information appears in the output.

The Plotter can be activated with the "'''View | Plotter'''" menu.

That action displays a graphical tool aside the shell section.

[[Fichier:ENG-CANSAT-PICO-THONNY-10.png|480px]]

The Plotter catch the numeric values sends/print in the REPL/Shell and displays it in the chart.

Only lines containing numeric values are used by the plotter.

On the following example, named {{fname|demo2.py}}, we do use the gamma function to make the LED pulsing in a more natural way. Indeed, a progressive PWM signal increase would not offers a proportional luminosity increase on the LED (voir livre [https://www.editions-eni.fr/livre/micropython-et-pyboard-python-sur-microcontroleur-de-la-prise-en-main-a-l-utilisation-avancee-9782409022906 MicroPython et Pyboard, Edition ENI], in French).

We do use the {{fname|gamma()}} function to rectify the apparent proportionality between the PWM and emitted light.

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))

def gamma( pc ):
return pow(pc/100,2.2)*100

while True:
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )</nowiki>
</syntaxhighlight>

Which produce the following results in Thonny and activated Plotter.

[[Fichier:ENG-CANSAT-PICO-THONNY-11.png|480px]]

'''{{underline|Drawing several curves}}'''

By modifying the script, we can return the PWM value and the gamma corrected value by using a [https://www.w3schools.com/python/python_tuples.asp Python tuple]. Then the plotter will draw several curves.

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))

def gamma( pc ):
return pow(pc/100,2.2)*100

while True:
for i in range( 0, 100, 5 ):
pwm = int( i*65534/100 )
pwm_gamma = int(gamma(i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm = int((100-i)*65534/100)
pwm_gamma = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
</syntaxhighlight>

Which produce the following results in Thonny.

[[Fichier:ENG-CANSAT-PICO-THONNY-12.png|480px]]

As seen in the REPL/Shell output, the data are return under the format (pwm, pwm_gamma) . The first value is the proportional curve and the second value the gamma fixed value.

The plotter does show the curve correspondence between tuple value position and drawed curve (see to bottom right corner).

== System Shell - Pure REPL ==
It is also possible to start a Pure REPL session inside an external terminal. By using a external terminal, the user escape from the Thonny shell panel and being directly connected to the microcontroler via an USB serial connection.

The "'''Tools | Open System Shell..'''" menu will open the terminal Window.

[[Fichier:ENG-CANSAT-PICO-THONNY-20.png|640px]]

{{underline|Notes:}}
* Thonny must be connected to the target plateform to be able to open the External Terminal.
* The file manager can helps to check, whether or not, when Thonny is connected to the MicroPython board.
* It is not possible to open two terminal session (at the same time) to the MicroPython microcontroler.

== File manager ==

It is common to copy library/libraries on the board.

This will requires to '''transfer one (or several) files to the MicroPython board'''.

Such '''libraries''' are usually python scripts (eg: ce [https://raw.githubusercontent.com/mchobby/esp8266-upy/master/bme280-bmp280/bme280.py bme280.py file]) coded for target sensors (eg: [https://github.com/mchobby/esp8266-upy/tree/master/bme280-bmp280 BME280 atmospheric & temperature I2C sensor]).

Thank to Thonny you also have a dedicated "file manager" tool used to transfert files between the computer and the MicroPython board.

The file manager is available via the "'''View | Files'''" menu.

[[Fichier:ENG-CANSAT-PICO-THONNY-30.png|480px]]

Which would display the Thonny file manager.

[[Fichier:ENG-CANSAT-PICO-THONNY-31.png|480px]]

To transfer a file from the computer to the MicroPython board, you will need to :
* Select the file into the "Computer" pane
* Activate the contextual menu (mouse right click)
* Select the option "Upload to" in the menu

{{ambox|text=The "/" drawed into the menu match the root folder on the target (the microcontroler in this case).}}

[[Fichier:ENG-CANSAT-PICO-THONNY-32.png|480px]]

It would be easy to identify the features and behavior of the file manager by exploring and testing the various entries in the contextual menu. Please note that contectual menu are different in the board pane and computer pane.

{{ENG-CANSAT-PICO-TRAILER}}

ENG-CANSAT-PICO-BELGIUM

2026-04-25T20:50:33Z

Admin : /* Getting Started */

[[File:ENG-CANSAT-PYTHON.png|thumb|200px]] [[File:ENG-CANSAT-PICO-CONTENT-10.jpg|thumb|200px]]
{{infobox tuto
| image = ENG-CANSAT-PICO-CONTENT-10.jpg
| title = CanSat Pico Guide
| subtitle = A comprehensive technical guide to assemble, use and get the best of MicroPython on the Raspberry-Pi Pico for CanSat launch.
| version = 0.3
}}

== Cansat in Python ==
Thank to [http://micropython.org/ MicroPython], you can program your CanSat with Python.

[[Fichier:ENG-CANSAT-PYTHON-PICO.jpg|480px]]

Other solution [[ENG-CANSAT-BELGIUM|CanSat Arduino with Feather M0]]

== What is CanSat? ==
CanSat Contest simulates the fly of miniaturized satellites named CanSat (Can Satellite).

The CanSat is an autonomous devices enclosed within the volume of a soda can.

The volume of a CanSat has the following characteristics: 66mm diameter, 115mm height for a mass of 350gr.

As the CanSat have small volume and are very affordable, the CanSat contest is great for learning more about space technologies.

The CanSats are deployed from a rocket (the launch vehicle) at a height of about 3000m depending on the competition (see all the details in the contest rules).

The CanSats are not orbited and are always deployed in the athmosphere. So they always comes back to the earth.

The CanSat volume cannot increase until the CanSat is deployed out of the rocket.

This means that external antenna is allowed only after the CanSat left the rocket.

A parachute (that increase the volume of the CanSat) is usually used to limit damages. The aim is to reuse the CanSat for several missions.

In Europe, the CanSat contest includes two missions:
* Mission 1: mesure pressure and temperature and transmit data in real time.
* Mission 2: free choice mission (using Intertial Measurement Unit, GPS, MPX differential pressure sensor, etc).

== Getting Started ==

{{ttuto-begin}}

{{ttuto
|label=Hardware discovery
|descr=Discover the various items included within the V2 kit.
|img=tlogo-CANSAT-V2-content.jpg
|link=ENG-CANSAT-V2-CONTENT
}}

{{ttuto
|label=Kit Assembling
|descr=Assembling the Pico Cansat Kit is more easier than ever.
|img=tlogo-CANSAT-Pico-Assembly.jpg
|link=ENG-CANSAT-V2-ASSEMBLY
}}

{{ttuto
|label=Base Pinout
|descr=Discover the operation and pinout of the Cansat V2 Kit
|img=tlogo-CANSAT-C2-Pinout.jpg
|link=ENG-CANSAT-V2-PINOUT
}}

{{ttuto
|label=Thonny IDE
|descr=Prepare your Python IDE environment
|img=tlogo-CANSAT-Pico-IDE.jpg
|link=ENG-CANSAT-PICO-THONNY
}}

{{ttuto
|label=Pico User Guide
|descr=The Raspberry-Pi Pico user guide.
|img=tlogo-Pico.jpg
|link=ENG-CANSAT-PICO-USER-GUIDE
}}

{{ttuto
|label=MicroPython HowTo
|descr=Tips and tricks to write Python code for on MicroControler.
|img=tlogo-micropython-howto.png
|link=ENG-CANSAT-PICO-HowTo
}}

{{ttuto
|label=Data Logging
|descr=How to log data into a file (on MicroControler)
|img=tlogo-pico-data-logging.png
|link=ENG-CANSAT-PICO-LOG
}}

{{ttuto
|label=Schematics
|descr=Need to have a look on the board schematics?
|img=tlogo-pico-schema.jpg
|link=ENG-CANSAT-V2-SCHEMA
}}

{{ttuto
|label=Dimensions
|descr=Technical size and dimensions for the cansat
|img=tlogo-pico-size.png
|link=ENG-CANSAT-V2-DIMENSION
}}

{{ttuto-end}}

<div style="margin: 15px 0; background: rgba(0,192,240,.3); display: block; padding: 15px 15px 15px 15px; -webkit-border-radius: 2px; -moz-border-radius: 2px; border-radius: 2px; border: 1px solid #CCC;" >The Raspberry-Pi PICO can also been use with '''Arduino IDE''' and '''C/C++ compiler'''. It's means that you can also write '''Arduino alike C code''' on this microcontroler. This point is not covered in this tutorial series, we do MicroPython programming.</div>

== Test the devices ==
{{ttuto-begin}}

{{ttuto
|label=BMP280 sensor
|descr=Test the BMP280 pressure and elevation sensor.
|img=tlogo-bmp280-stemmaQt.png
|link=ENG-CANSAT-PICO-BMP280
}}

{{ttuto
|label=TMP36 sensor
|descr=Test the TMP36 analog temperature sensor
|img=tlogo-micropython-tmp36.png
|link=ENG-CANSAT-PICO-TMP36
}}

{{ttuto
|label=RFM69HCW radio
|descr=User guide for the RFM69HCW radio module.
|img=tlogo-CANSAT-RFM69HCW-user.png
|link=ENG-CANSAT-PICO-RFM69HCW
}}

{{ttuto
|label=RFM69HCW Testing
|descr=Testing the communication with RFM69HCW and sending data through the radio module.
|img=tlogo-CANSAT-RFM69HCW.png
|link=ENG-CANSAT-PICO-RFM69HCW-TEST
}}

{{ttuto
|label=GPS Tracking
|descr=Getting the position of the Cansat
|img=tlogo-CANSAT-GPS.png
|link=ENG-CANSAT-PICO-GPS
}}

{{ttuto-end}}

== Mission 1 ==
The team must build a CanSat and program it to accomplish the primary (mandatory) mission, as follows:

After release and during descent,
* the CanSat shall measure several parameters,
* the data should be transmitted as telemetry information to the ground station.
* the telemetry should, at least, be send once every second.

The following informations should be captured:
* Air temperature
* Air pressure

It must be possible for the team to analyse the data obtained (for example, make a calculation of altitude) and display it in graphs (for example, altitude vs. time and temperature vs. altitude).

<div style="margin: 15px 0; background: rgba(255,204,102,.3); display: block; padding: 15px 15px 15px 15px; -webkit-border-radius: 2px; -moz-border-radius: 2px; border-radius: 2px; border: 1px solid #ff9900;" >So, don't forget to also capture the time for each data collected. This information is as critical than pressure and temperature</div>

{{ttuto-begin}}

{{ttuto
|label=Frequency Plan
|descr=Be courteous, share the radio bandwidth.
|img=tlogo-CANSAT-FREQENCY-PLAN.png
|link=ENG-CANSAT-PICO-FREQUENCY-PLAN
}}

{{ttuto
|label=Mission 1: Emitter
|descr=Wiring sensors, capturing datas and sending over radio.
|img=tlogo-CANSAT-MISSION1.png
|link=ENG-CANSAT-PICO-MISSION1-CAPTURE
}}

{{ttuto
|label=Mission 1: Receiver
|descr=Receiving the transmitted data.
|img=tlogo-CANSAT-MISSION1-RECEIVER.png
|link=ENG-CANSAT-PICO-MISSION1-RECEIVE
}}

{{ttuto
|label=Mission 1: Going autonomous
|descr=Receiving the transmitted data.
|img=tlogo-CANSAT-MISSION1-RECEIVER-Lipo.png
|link=ENG-CANSAT-PICO-MISSION1-AUTONOMOUS
}}

{{ttuto-end}}

== Ressources ==

{{ttuto-begin}}

{{ttuto
|label=CanSat samples
|descr=CanSat models and ideas
|img=tlogo-CANSAT-BUILD.png
|link=ENG-CANSAT-SAMPLE
}}

{{ttuto
|label=Radio Antenna
|descr=A well designed Antenna can increase the communication distance.
|img=tlogo-CANSAT-antenna.png
|link=ENG-CANSAT-PICO-ANTENNA
}}

{{ttuto
|label=Parachute
|descr=Some reference to design the parachute
|img=tlogo-CANSAT-parachute.png
|link=ENG-CANSAT-PICO-PARACHUTE
}}

{{ttuto
|label=Shopping
|descr=Need to refill some parts?
|img=tlogo-shopping.png
|link=ENG-CANSAT-V2-PICO-SHOPPING
}}

{{ttuto-end}}

Optional: Adding a GPS module to transmit the CanSat position with the telemetry data would ease to positioning when back on the earth.

Other ressources:
* [https://en.wikipedia.org/wiki/CanSat#_Europe CanSat Europe] on WikiPedia - Lot of informations
* [https://df.mchobby.be/wiki-export/Eng-Cansat-Pico/Eng-Cansat-Pico.pdf This wiki as PDF] (''pdf'')
* [https://df.mchobby.be/wiki-export/Eng-Cansat/pico-rp2040-presentation.pdf Raspberry-Pi Pico RP2040 Presentation] (''pdf'')
* [https://df.mchobby.be/wiki-export/Eng-Cansat/cansat-pico-kit-presentation-v4.pdf CanSat Kit Presentation v4 (Belgium)] (''pdf, nov 2024'')
* [https://df.mchobby.be/wiki-export/Eng-Cansat/cansat-pico-kit-presentation-v3.pdf CanSat Kit Presentation v3 (Belgium)] (''pdf, nov 2023'')
* [https://df.mchobby.be/wiki-export/Eng-Cansat/cansat-pico-kit-presentation.pdf CanSat Kit Presentation v1 (Belgium)] (''pdf'')

== How to subscribe the contest? ==

In Europe, the CanSat competition is promoted by the ESA ([https://en.wikipedia.org/wiki/CanSat#_Europe source]).

* '''For Belgium''': the CanSat Belgium competition is promoted by '''InnovIris''' ([http://www.innoviris.be/fr/promotion/cansat-belgium CanSat Belgium NL], [http://www.innoviris.be/nl/promotie/cansat-belgium CanSat Belgium FR], [https://www.facebook.com/CanSat.Belgium?fref=ts CANSAT Belgium FaceBook] ).Innoviris is the Brussels Institute for the encouragement of scientific research and innovation.

* '''For Luxembourg''': the CanSat Luxembourg competition is promoted by [https://www.cansat.lu '''Esero Luxembourg''' (www.cansat.lu)] .

== About this Wiki ==

MC Hobby does promote, mainly in French, the Arduino Open-Source plateform, MicroPython, Raspberry-Pi, coding, electronics to made knowledge freely available de the mass.

This CanSat Belgium Wiki is one of the [https://shop.mchobby.be MC Hobby] [https://wiki.mchobby.be documentation project].

[[Fichier:ARDX-Intro-MCHobby.jpg|480px]]

{{ENG-CANSAT-PICO-TRAILER}}

Micropython-PIR-alarm

2026-01-12T17:36:18Z

Admin : /* Liste d'achat */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelque-uns de ces capteurs.

=== Capteur PIR-476 standard ===

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

=== Capteur PIR-460 ===

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476 (les borniers presque identiques, cfr polarité de l'alimentation)

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]
* [https://shop.mchobby.be/product.php?id_product=2892 PIR-SENSOR-460 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:36:00Z

Admin : /* Capteur PIR-460 */

Micropython-PIR-alarm

2026-01-12T17:35:44Z

Admin : /* Capteur PIR-476 standard */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelque-uns de ces capteurs.

=== Capteur PIR-476 standard ===

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476 (les borniers presque identiques, cfr polarité de l'alimentation)

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]
* [https://shop.mchobby.be/product.php?id_product=2891 PIR-SENSOR-460 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:35:32Z

Admin : /* Introduction */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelque-uns de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476 (les borniers presque identiques, cfr polarité de l'alimentation)

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]
* [https://shop.mchobby.be/product.php?id_product=2891 PIR-SENSOR-460 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:19:14Z

Admin : /* Connexion sur MicroContrôleur */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476 (les borniers presque identiques, cfr polarité de l'alimentation)

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]
* [https://shop.mchobby.be/product.php?id_product=2891 PIR-SENSOR-460 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:14:46Z

Admin : /* Liste d'achat */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476 (les borniers sont identiques)

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]
* [https://shop.mchobby.be/product.php?id_product=2891 PIR-SENSOR-460 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:14:10Z

Admin : /* Connexion sur MicroContrôleur */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476 (les borniers sont identiques)

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:11:41Z

Admin : /* Connexion sur MicroContrôleur */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

Le fonctionnement est identique pour les capteurs PIR-460, PIR-476.

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T17:07:49Z

Admin : /* Capteur PIR-460 */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|360px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]

Fichier:Micropython-PIR-alarm-16.jpg

2026-01-12T17:01:14Z

Admin :

Micropython-PIR-alarm

2026-01-12T17:00:53Z

Admin : /* Capteur PIR-460 */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-16.jpg|480px]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Relais''': Commun
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Relais''': Contact normalement fermé Peut-être reconfiguré en Normalement Ouver..
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage. Ouvert si couvercle retiré
|}

== Connexion sur MicroContrôleur ==

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]

Fichier:Micropython-PIR-alarm-15.jpg

2026-01-12T16:59:04Z

Admin :

Micropython-PIR-alarm

2026-01-12T16:57:54Z

Admin : /* Capteur PIR-460 */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme détecteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

Bien qui soit habituellement monté en hauteur et diriger vers le bas, rien n'empêche d'exploiter ce capteur dans d'autres configurations.

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Connexion sur MicroContrôleur ==

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]

Micropython-PIR-alarm

2026-01-12T16:55:32Z

Admin : /* Capteur PIR-476 standard */

== Introduction ==
Je ne sais pas pour vous? Mais personnellement, je me suis toujours demandé comment interfacer capteur d'alarme sur un projet microcontrôleur.

En tant que Maker, nous avons tous eu l'occasion de tester l'un ou l'autre capteur PIR... mais qu'en est il une fois que l'on est confronté à un modèle plus "professionnel" ?

Cet article concerne quelques un de ces capteurs.

== Capteur PIR-476 standard ==

Voici le capteur le plus commun, destiné à un usage en intérieur.

[[Fichier:Micropython-PIR-alarm-01.jpg|250px]] [[Fichier:Micropython-PIR-alarm-02.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur pour couvrir une surface de 10m x 10m avec un angle de détection de l'ordre de 90° (de 88° à 110°)

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Intérieur
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 10m x 10m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | ~90°
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA)
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | OptoCoupleur (NC=Normally Closed), 20V DC max, 100mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | 52mm x 60mm (Haut: 92mm)
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Capteur PIR-460 ==

Ce capteur est généralement utilisé comme capteur de passage (ex: au dessus d'une porte).

[[Fichier:Micropython-PIR-alarm-15.jpg|250px]]

Ce capteur PIR (Passive Infra Res) est utilisé en intérieur ou passage couvert par des systèmes de sécurité.

Il permet de détecter le passage (mode sécurité) ou la présence d'un individu à un endroit précis (mode card access).

{| class="wikitable" border="1"
|-
| align="center" | Caractéristique
| align="center" | Valeur
|- style="font-size: 90%"
| align="left" | Application
| align="left" | Détecteur de passage/Presence
|- style="font-size: 90%"
| align="left" | Couverture
| align="left" | 2.1x1.5m (mode card access) 6.6x4.5m
|- style="font-size: 90%"
| align="left" | Angle de détection
| align="left" | 0° (configurable 10°)
|- style="font-size: 90%"
| align="left" | Hauteur installation
| align="left" | 2.0 à 2.7m
|- style="font-size: 90%"
| align="left" | Alimentation
| align="left" | 9 à 16V DC (31mA) Configurable 20 à 27V DC
|- style="font-size: 90%"
| align="left" | Sortie
| align="left" | Micro-Relais (NC=Normalement Fermé), 28V DC max, 150mA)
|- style="font-size: 90%"
| align="left" | Température
| align="left" | -10°C à 50°C
|- style="font-size: 90%"
| align="left" | Dimensions
| align="left" | Triangle base 120mm x hauteur 100mm (épaisseur 40mm).
|- style="font-size: 90%"
| align="left" | Poids
| align="left" | 80 gr
|- style="font-size: 90%"
| align="left" | Autre
| align="left" | * Compensation de la température
|}

Fonctionnement de la sortie:
* Detection = LED Allumé = OptoCoupleur "Ouvert"
* Non detection = LED Eteinte = OptoCoupleur "Fermé"

De la sorte, si quelqu'un coupe le fil vers le détecteur alors le circuit s'ouvre, ce qui revient à une détection d'alarme.

[[Fichier:Micropython-PIR-alarm-05.png]]

{| class="wikitable" border="1"
|-
! Contact
! Description
|- style="font-size: 90%"
| align="left" | +
| align="left" | '''Alimentation''': 9 à 16V DC.
|- style="font-size: 90%"
| align="left" | -
| align="left" | '''Alimentation''': masse/GND.
|- style="font-size: 90%"
| align="left" | com
| align="left" | '''Optocoupleur''': Commun (son "émetteur")
|- style="font-size: 90%"
| align="left" | NC
| align="left" | '''Optocoupleur''': Contact normalement fermé (''Normally Closed'') lorsque le capteur ne détecte rien. "Collecteur" de l'optocoupleur.
|- style="font-size: 90%"
| align="left" | Tamper
| align="left" | Contacts de l'anti-sabotage (si présent).
|}

== Connexion sur MicroContrôleur ==

=== Raccordement Simple ===

L'exemple ci-dessous indique comment brancher le capteur sur un microcontrôleur 3.3V (comme Raspberry-Pi Pico).

{{dbox-gray| Le signal d'alarme passe par un opto-coupleur il est possible de dissocier la masse des capteurs de la masse du MicroControleur. C'est l'option employée dans la raccordement ci-dessous.}}

L'entrée GP2 passe au niveau haut lorsqu'un mouvement est détecté.

[[Fichier:Micropython-PIR-alarm-11.jpg|800px]]

L'entrée GP2 reste au niveau bas si rien n'est détecté.

[[Fichier:Micropython-PIR-alarm-10.jpg|800px]]

Le script pour lire l'état de l'entrée est relativement simple:

<syntaxhighlight lang="python">
import time
from machine import Pin
p = Pin( 2, Pin.IN )
while True:
print( "ALARM" if p.value() else "---" )
time.sleep(1)
</syntaxhighlight>

{{tmbox | type = speedy | text = Une tension de 3.3V est parfaite pour transporter le signal sur une courte distance. Cette tension reste cependant trop faible pour propager le signal d'alarme fiablement sur une longue distance (>1m). }}

=== Raccordement en cascade ===
Il est possible de brancher plusieurs capteurs sur une seule ligne en les branchant en série.

L'alarme est donc déclenchée lorsqu'un des capteurs détecte un mouvement.

[[Fichier:Micropython-PIR-alarm-20.jpg|800px]]

{{tmbox | type = speedy | text = L'inconvénient de cette configuration est qu'il n'est pas possible de savoir lequel des capteurs à provoqué le déclenchement de l'alarme (c'est donc une gestion par "zones"). }}

=== Raccordement analogique ===
Le raccordement en cascade ne permet pas d'identifier le capteur impliqué dans la détection.

J'ai d'abord pensé qu'une utilisation intelligente de résistances en pont diviseur de tension pourrait permettre l'identification du capteur.

Malheureusement, même avec 4 capteurs, il existe des cas il faut identifier une différence de 200mV. Ce qui n'est pas une situation fiable sur une installation filaire.

=== Augmenter la tension ===

Elever la tension du signal est une bonne façon de limiter l'impact des interférences sur ce même signal.

Cependant, cela implique une interface électronique du côté du microcontrôleur afin de ne pas dépasser la tension maximale autorisée sur les entrées.

Dans l'exemple ci-dessous, la tension d'alimentation des capteurs (9V) est également utilisée comme tension de signal. Un optocoupleur est utilisé côté microcontrôleur pour réduire le signal à 3.3V max.

[[Fichier:Micropython-PIR-alarm-30.jpg|960px]]

Dans le cas présent:
* Detection = LED Allumé = OptoCoupleur "Ouvert" => Opto-coupleur microcontroleur "Ouvert" => GP2 = LOW
* Non detection = LED Eteinte = OptoCoupleur "Fermé" => Opto-coupleur microcontroleur "Fermé => GP2 = HIGH

[[Fichier:Micropython-PIR-alarm-30a.jpg|960px]]

[[Fichier:Micropython-PIR-alarm-30b.jpg|960px]]

== Liste d'achat ==
* [https://shop.mchobby.be/product.php?id_product=2890 PIR-SENSOR-476 : capteur d'alarme PIR]

Fichier:Tlogo-PIR-alarm.png

2026-01-07T00:44:43Z

Admin :

MicroPython-Accueil

2026-01-07T00:33:56Z

Admin : /* Hacking électronique */

{{device-links}}

{| border="0"
|-
| align="left" width="360px" | [[Fichier:powered-by-micropython.png|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''Micro Python''' est une version optimisée et allégée de Python 3 pour système embarqué. '''PyBoard, Pico, ESP32, etc sont des cartes microcontrôleurs supportant MicroPython'''. Ces cartes électroniques exécutnt MicroPython en ''[http://en.wikipedia.org/wiki/Bare_machine bare metal]'' et vous offre un système d'exploitation Python de bas niveau permettant de contrôler toute sorte de projets électroniques. Trop fort... I Love It!!! La {{cl|56|gamme Micro Python est maintenant disponible}} chez [http://shop.mchobby.be MCHobby].
|}

= Pico / Pico2 (Raspberry-Pi) =
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-pico.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur Raspberry-Pi Pico''' et '''Pico Wireless'''. Reflasher un {{pl|2025|Pico}}, un {{pl|2036|Pico Header}} pour qu'il supporte MicroPython afin de réaliser des objets intelligents à prix imbattable!
|}

Cette section est dévolue à la plateforme {{pl|2025|Pico}} reflashé avec MicroPython.

Cette section est assortie:
* du [https://github.com/mchobby/esp8266-upy GitHub ESP8266-upy contenant des sources et exemples pour cartes MicroPython].
* du [https://github.com/mchobby/pyboard-driver/tree/master/Pico GitHub Pyboard-Driver contenant des ressource pour la carte Pico]

== Généralités ==
{{ttuto-begin}}

{{ttuto
|label=Python_SDK_FR
|descr=Un PDF pour découvrir le Raspberry-Pi Pico, son Brochage, Alimentation, Schéma, FAQ.
|img=tlogo-pico-python-sdk.jpg
|url=http://df.mchobby.be/RASPBERRY-PICO/Python_SDK_FR.pdf
}}

{{ttuto
|label=Brochage
|descr=Le brochage de référence du Pico sous MicroPython.
|img=tlogo-pico-pinout.jpg
|url=https://raw.githubusercontent.com/mchobby/pyboard-driver/master/Pico/docs/_static/Pico.png
}}

{{ttuto
|label=Thonny IDE
|descr=Utiliser Thonny IDE avec Pico et carte RP2040
|img=tlogo-thonny.jpg
|url=https://arduino103.blogspot.com/2022/01/micromod-rp2040-pico-utiliser-thonny.html
}}

{{ttuto
|label=Pico et Thonny
|descr=Utiliser l'IDE Thonny (recommandé par la fondation) avec votre Pico. Un bel article de Framboise314.
|img=tlogo-pico-thonny.jpg
|url=https://www.framboise314.fr/utiliser-le-raspberry-pi-pico-avec-thonny/
}}

{{ttuto
|label=Ressources
|descr=Diverses ressources pour le Pico sous MicroPython. Y Compris un Pico annoté
|img=tlogo-Github.jpg
|url=https://github.com/mchobby/pyboard-driver/tree/master/Pico
}}

{{ttuto
|label=Reset btn
|descr=Ajouter un bouton Reset à votre Pico.
|img=tlogo-pico-reset.jpg
|link=PICO-RESET-BUTTON
}}

{{ttuto
|label=Pico-W Intro
|descr=Découvrir le Raspberry-Pi Pico WIRELESS - WiFi et Bluetooth sur le Pico
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/06/raspberry-pi-pico-wireless-wifi-et.html
}}

{{ttuto
|label=Pico-W et MicroPython
|descr=Pico Wireless : installer le firmware MicroPython
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/06/pico-wireless-installer-le-firmware.html
}}

{{ttuto
|label=Pico-W et WiFi
|descr=Pico Wireless : MicroPython et le WiFi
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/07/pico-wireless-micropython-et-le-wifi.html
}}

{{ttuto
|label=Pico-W WebREPL
|descr=Pico Wireless: Comment utiliser WEBRepl
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/08/pico-wireless-comment-utiliser-webrepl.html
}}

{{ttuto
|label=Pico LED utilisateur
|descr=Pico Wireless: MicroPython et la LED utilisateur
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/07/pico-wireless-micropython-et-la-led.html
}}

{{ttuto
|label=TrinKey QT2040
|descr=Utiliser le TrinKey QT2040 (RP2040) avec MicroPython
|img=tlogo-pico-trinkey-QT2040.png
|link=TrinKey-QT2040
}}

{{ttuto
|label=Adafruit SeeSaw
|descr=Utiliser le SeeSaw (multi-interface via I2) avec MicroPython (et Pico)
|img=tlogo-seesaw.png
|url=https://github.com/mchobby/micropython-seesaw
}}

{{ttuto-end}}

== Hacking électronique ==
{{ttuto-begin}}

{{ttuto
|label=Pico CanSat
|descr=Control a CANSAT with MicroPython and Raspberry-Pi Pico
|img=tlogo-cansat-pico.jpg
|link=ENG-CANSAT-PICO-BELGIUM
}}

{{ttuto
|label=Pico-2-Explorer
|descr=Découvrir MicroPython avec le Raspberry-Pi Pico 2. Entrées/sorties, analogique, PWM, etc
|img=tlogo-pico-2-explorer.jpg
|link=Pico-2-Explorer-FR
}}

{{ttuto
|label=Shield Moteur
|descr=Utiliser un MotorShield ou Motor FeatherWing avec le Pico.
|img=tlogo-pico-motorshield.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/adfmotors
}}

{{ttuto
|label=Afficheur TFT ILI934x
|descr=Utiliser un TFT 2.4" FeatherWing (ILI9341) avec le Pico
|img=tlogo-pico-ili934x.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ili934x
}}

{{ttuto
|label=HAT-SENSE
|descr=Utiliser le Hat-Sense avec votre Pico
|img=tlogo-micropython-hat-sense.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=HAT-PiFace
|descr=Utiliser le PiFace Digital avec votre Pico
|img=tlogo-micropython-hat-piface.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=Pulse-In
|descr=Mesurer la longueur d'une impulsion Servo sur un récepteur RC
|img=tlogo-pico-pulse-in.jpg
|link=PICO-PULSE-IN-MICROPYTHON
}}

{{ttuto
|label=Pico<->Minitel
|descr=Brancher un Pico sur un Minitel, recevoir et envoyer des caractères
|img=tlogo-Minitel.jpg
|url=https://arduino103.blogspot.com/2022/04/minitel-branche-sur-mon-raspberry-pi.html
}}

{{ttuto
|label=Pico, Zumo Robot et MicroPython
|descr='''Ebook''' pour apprendre a utiliser votre Zumo Robot pour Arduino avec MicroPython.
|img=tlogo-Pico-Zumo-Robot-et-MicroPython.jpg
|link=Pico-Zumo-Robot-et-MicroPython
}}

{{ttuto
|label=Zumo Robot en Python
|descr='''GitHub''' Robot Zumo sous MicroPython avec le Pico ou la Pyboard
|img=tlogo-zumo-pico.jpg
|url=https://github.com/mchobby/micropython-zumo-robot
}}

{{ttuto
|label=MyDin
|descr=DIN Automation with MicroPython
|img=tlogo-mydin.jpg
|link=MyDin
}}

{{ttuto
|label=UniPi en Python
|descr=Créer un automate programmable avec UniPi et MicroPython
|img=tlogo-unipi-pico.jpg
|bad_url=https://github.com/mchobby/micropython-zumo-robot
|traduction=1
}}

{{ttuto
|label=Pico Buggy
|descr=Contôler le Buggy Kitronik avec MicroPython (traduction MCHobby)
|img=tlogo-pico-buggy.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Autonomous-Robotics-Platform-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Smart Air Quality
|descr=Mesurer la qualité d'air avec un Pico (traduction MCHobby)
|img=tlogo-pico-air-quality.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Smart-Air-Quality-Board-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Pico Contrôle Robotique
|descr=Carte de contrôle robotique pour Pico (traduction MCHobby)
|img=tlogo-pico-motor.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Robotics-Board-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Pico Contrôle Moteur
|descr=Carte de contrôle moteur pour Pico (traduction MCHobby)
|img=tlogo-pico-motor2.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Motor-Driver-Board-MicroPython
}}

{{ttuto
|label=Wifi-4-Relay
|descr=Commander un module 4 relais avec via Page WEB ou API REST.
|img=tlogo-wifi-4-relay.jpg
|url=https://github.com/mchobby/micropython-wifi-4-relais
}}

{{ttuto
|label=ArdBase
|descr=Découvrir le hacking électronique pour avec Kit ArdBase et MicroPython
|img=tlogo-pico-ardbase-micropython.png
|url=https://github.com/mchobby/KIT-SOUDURE-ARDBASE
}}

{{ttuto
|label=Tamagotchi
|descr=Créer un Tamagotchi sous MicroPython avec Raspberry-Pi Pico
|img=tlogo-pico-tamagotchi.jpg
|link=Pico-Tamagotchi-Intro
}}

{{ttuto
|label=Adafruit NeoTrellis
|descr=Utiliser un NeoTrellis d'Adafruit avec Raspberry-Pi Pico/Pico2.
|img=tlogo-micropython-neotrellis.png
|link=micropython-neotrellis-pico
}}

{{ttuto
|label=RoboEyes
|descr=Donnez de la personnalité à vos robot avec l'implémentation de RoboEyes pour MicroPython.
|img=tlogo-micropython-roboeyes.png
|url=https://github.com/mchobby/micropython-roboeyes
}}

{{ttuto
|label=Capteur Alarme
|descr=Comment utiliser des capteurs d'alarme PIR avec un microcontroleur
|img=tlogo-PIR-alarm.png
|link=micropython-PIR-alarm
}}

{{ttuto
|label=4G-Base-Station
|descr=Station de contrôle avec carte 4G équipée d'entrées et sorties... programmable en MicroPython.
|img=tlogo-4G-base-Station.png
|url=https://github.com/mchobby/micropython-4G-BASE-STATION
}}

{{ttuto-end}}

= EDI pour MicroPython =
Les outils et editeurs pouvant être utilisés avec MicroPython.

{{ttuto-begin}}
{{ttuto
|label=Thonny IDE
|descr=Utiliser Thonny IDE avec Pico et carte RP2040
|img=tlogo-thonny.jpg
|url=https://arduino103.blogspot.com/2022/01/micromod-rp2040-pico-utiliser-thonny.html
}}

{{ttuto
|label=Pico et Thonny
|descr=Utiliser l'IDE Thonny (recommandé par la fondation) avec votre Pico. Un bel article de Framboise314.
|img=tlogo-pico-thonny.jpg
|url=https://www.framboise314.fr/utiliser-le-raspberry-pi-pico-avec-thonny/
}}

{{ttuto
|label=MPRemote
|descr='''MicroPython Remote Control''' outil en ligne de commande qu'il ne faut surtout pas râter.
|img=tlogo-MPRemote.png
|url=https://github.com/mchobby/micropython-minishell
}}

{{ttuto
|label=MIP
|descr='''MicroPython Install Package''' une commande MPRemote pour installer facilement des bibliothèques
|img=tlogo-MPRemote-MIP.png
|url=https://arduino103.blogspot.com/2023/05/micropython-1200-mip-micropython.html
}}

{{ttuto
|label=MiniShell
|descr=MiniShell est un Shell type Linux pour MicroPython. Très pratique pour manipuler des fichiers via REPL.
|img=tlogo-minishell.jpg
|url=https://github.com/mchobby/micropython-minishell
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. WiPy et ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto
|label=Ampy
|descr=Outil simplifié de transfert de fichiers et de contrôlez de carte depuis une connexion série. ESP8266 compatible.
|img=tlogo-micropython-Debugger.jpg
|link=FEATHER-CHARGER-FICHIER-MICROPYTHON
}}

{{ttuto
|label=mem_info()
|descr=Surveiller la consommation RAM de vos script sous MicroPython
|img=tlogo-mem-info.jpg
|url=https://arduino103.blogspot.com/2023/03/micropython-surveiller-la-ram-avec.html
}}

{{ttuto-end}}

= Pilotes MicroPython =
Les pilotes MicroPythons sont des bibliothèques utilisées pour interagir avec des composants électroniques ou cartes breakouts.

Chez MC Hobby, nous développons des pilotes "Plateform Agnostic". Cela signifie que les bibliothèques s'appuient sur l'API {{fname|machine}} et peuvent être utilisés sur toutes les plateformes MicroPython.

Enfin, nous produisons une documentation aussi complète que possible (français/anglais) + scripts d'exemples. Tous cela stocké sur un dépôt en ligne.

{{ttuto-begin}}

{{ttuto
|label=ad9833
|descr=Créer un générateur de signal à l'aide de l AD9833.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ad9833
}}

{{ttuto
|label=adfmotors
|descr=Contrôler des moteurs continu, pas-à-pas ou servo-moteur avec le shield moteur Arduino d'Adafruit. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/adfmotors
}}

{{ttuto
|label=ads1015-ads1115
|descr=Convertisseur ADC (Analogique vers Digital) 4 canaux pour réaliser des lectures analogiques et lectures différentielles. L'ADS1115 dispose d'un amplificateur interne programmable, ce qui permet de lire des tensions très faibles. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ads1015-ads1115
}}

{{ttuto
|label=am2315
|descr=Capteur de température et humidité relative (0 à 100%) pour relevés en extérieur. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/am2315
}}

{{ttuto
|label=bme280-bmp280
|descr=Le BMP280 est un capteur de pression et température très populaire. Le BME280 est un capteur de pression, température et HUMIDITÉ relative. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/bme280-bmp280
}}

{{ttuto
|label=bmp180
|descr=Le BMP180 est un senseur de pression et température aujourd'hui remplacé par le BMP280. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/bmp180
}}

{{ttuto
|label=cardkb
|descr=CardKB - Mini-clavier QWERTY en I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/cardkb
}}

{{ttuto
|label=ccs811
|descr=CCS811 - Capteur qualité d'air - COV et eCO2 avec MicroPython. ADAFRUIT,OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ccs811
}}

{{ttuto
|label=COLORS
|descr=Bibliothèque de gestion de couleurs (et outils).
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/COLORS
}}

{{ttuto
|label=dht11
|descr=Le DHT11 est un senseur d'humidité (20 à 80%) et température très bon marché. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/dht11
}}

{{ttuto
|label=dotstar
|descr=Les DotStar / APA102 sont des LEDs digitales intelligentes pouvant être contrôlées indépendamment les unes des autres. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/dotstar
}}

{{ttuto
|label=drv8830
|descr=Le Mini I2C motor driver permet de contrôler 2 moteurs 5V par l'intermédiaire d'une interface I2C. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/drv8830
}}

{{ttuto
|label=ds18b20
|descr=Le DS18B20 est un senseur de température digital très populaire. Il utilise le bus 1-Wire permettant de brancher plusieurs senseurs 1-Wire sur un même bus. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ds18b20
}}

{{ttuto
|label=eeprom
|descr=Utiliser des EEPROM I2C pour stocker des informations. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/eeprom
}}

{{ttuto
|label=gps-ultimate
|descr=Pouvoir obtenir ou suivre votre position actuelle à l'aide d'un module GPS. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/gps-ultimate
}}

{{ttuto
|label=hat-joy-bonnet
|descr=Utiliser le HAT Joy Bonnet avec MicroPython NADHAT PYB405. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-joy-bonnet
}}

{{ttuto
|label=hat-piface
|descr=Utiliser le PiFace Digital avec MicroPython Pyboard, PYBStick.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-piface
}}

{{ttuto
|label=hat-sense
|descr=Utiliser le Sense HAT avec MicroPython Pyboard, PYBStick, PYB405.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=FBGFX
|descr=Bibliothèque graphique pour FrameBuffer.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/FBGFX
}}

{{ttuto
|label=grove-5-way-switch
|descr=Joystick 5 directions (et carte 6 DIP) via I2C - sous MicroPython. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/grove-5-way-switch
}}

{{ttuto
|label=ht0740-switch
|descr=HT0740 - 40V / 10A MosFet controlable via I2C - sous MicroPython. PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ht0740-switch
}}

{{ttuto
|label=ili934x
|descr=ILI934x - contrôleur afficheur TFT couleur 16 bits - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ili934x
}}

{{ttuto
|label=is31fl
|descr=IS31FL3731 - contrôleur CharliePlexing via I2C - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/is31fl
}}

{{ttuto
|label=lcdi2c
|descr=Afficheur à cristaux liquides (LCD) commandé via le bus I2C. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdi2c
}}

{{ttuto
|label=lcdmtrx
|descr=Afficheur LCD 2 lignes, 16 caractères, Arrière plan RGB. Interface USB + Série. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdmtrx
}}

{{ttuto
|label=lcdspi-lcd12864
|descr=Afficheur LCD graphique 128 x 64 pixels. Interface SPI (3 fils). DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdspi-lcd12864
}}

{{ttuto
|label=lsm303
|descr=Utiliser une boussole et accéléromètre LSM303D avec MicroPython. POLOLU.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lsm303
}}

{{ttuto
|label=m5stack-u087
|descr=Module Voltmetre I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u087
}}

{{ttuto
|label=m5stack-u097
|descr=Module 4 relais I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u097
}}

{{ttuto
|label=m5stack-u105
|descr=I2C DDS unit (Direct Digital Synthesis, AD9833, ), Grove. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u105
}}

{{ttuto
|label=max6675
|descr=MAX6675 Amplificateur Thermocouple Type-K - MOD-TC - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/max6675
}}

{{ttuto
|label=max31855
|descr=ThermoCouple Type-K + amplificateur MAX31855 - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/max31855
}}

{{ttuto
|label=mcp230xx
|descr=Le MCP23017 (et MCP2308) sont des GPIO Expander sur bus I2C ajoutant des entrées/sorties sur un microcontrôleur. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp230xx
}}

{{ttuto
|label=mcp23Sxx
|descr=Le MCP23S17 est un GPIO Expander sur bus SPI ajoutant des entrées/sorties sur un microcontrôleur. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp23Sxx
}}

{{ttuto
|label=mcp9808
|descr=Le MCP9808 (bus I2C) permettant de faire un relevé de température avec une précision de 0.25°C. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp9808
}}

{{ttuto
|label=mcp4725
|descr=Le MCP4725 (bus I2C) est un DAC -ou- une vraie sortie Analogique 12 bits (0 à 65535). ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp4725
}}

{{ttuto
|label=modenv
|descr=Capteur environnementale tout-en-un - BME280 + CCS811 - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modenv
}}

{{ttuto
|label=modio
|descr=MOD-IO est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de relais, d'entrée OptoCoupleur (24V) et entrées analogiques (0-3.3V). Cette carte est compatible avec le standard industriel en 24V. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modio
}}

{{ttuto
|label=modio2
|descr=MOD-IO est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de relais, de GPIO aux fonctions multiples (Input, Output, Analog, PWM; 0-3.3V). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modio2
}}

{{ttuto
|label=modirdaplus
|descr=MOD-IRDA+ est un module émetteur/récepteur Infrarouge I2C supportant les protocols RC5 (Philips) et SIRCS (Sony). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modirdaplus
}}

{{ttuto
|label=modirtemp
|descr=Mesure de température -70°C à 380°C Infrarouge sans contact (MXL90164). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modirtemp
}}

{{ttuto
|label=modlcd1x9
|descr=MOD-LCD1x9 est un afficheur 9 caractères alphanumérique I2C avec port de connexion UEXT. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modlcd1x9
}}

{{ttuto
|label=modlcd3310
|descr=MOD-LCD3310 est l'afficheur LCD du Nokia 3310 offrant 84 x 48 pixels et un port de connexion UEXT. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modlcd3310
}}

{{ttuto
|label=modled8x8
|descr=Un afficheur 8x8 LEDs RGB chaînable. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modled8x8
}}

{{ttuto
|label=modltr501
|descr=LTR-501ALS permet de faire une lecture de luminosité de 0.01 à 64.000 Lux (64K lux) et détection de proximité (jusqu'à 10cm). Le MOD-LTR-501ALS dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modltr501
}}

{{ttuto
|label=modmag
|descr=Le MAG3110 est un magénomètre digital 3 axes de NXP accessible via I2C. Le MOD-MAG dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modmag
}}

{{ttuto
|label=modoled128x64
|descr=Un afficheur OLED 128x64 / 128x32 / 64x48 avec contrôleur SSD1306 (I2C) et connecteur UEXT, Feather, Qwiic. OLIMEX,ADAFRUIT,SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modoled128x64
}}

{{ttuto
|label=modrfid
|descr=MOD-RFID1356 MIFARE : lecteur NFC / RFID Mifare via port série/usb-série/usb-hid. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrfid
}}

{{ttuto
|label=modrgb
|descr=MOD-RGB est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de MosFet de puissance pour commander des rubans LED RGB analogiques via I2C (ou DMX). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrgb
}}

{{ttuto
|label=modrs485iso
|descr=MOD-RS485-ISO est un adaptateur RS485 Full-Duplex/Half-Duplex avec isolation. La transmission de données se fait via UART (MODE_PASS) ou I2C (MODE_BRIDE). Expose une interface UEXT pour connexion rapide. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrs485iso
}}

{{ttuto
|label=modtc-mk2
|descr=MAX6MOD-TC-MK2 : Amplificateur Thermocouple Type-K (MAX31855) via I2C - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modtc-mk2
}}

{{ttuto
|label=modwii
|descr=La Wii NUNCHUCK est une manette de jeu super confortable et s'utilise sur le bus I2C. Ce controleur dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modwii
}}

{{ttuto
|label=mpr121
|descr=Créer des pastilles/entrées capacitives (tactiles) avec le MPR121. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mpr121
}}

{{ttuto
|label=mpx5700a
|descr=Utiliser un capteur de pression ANALOGIQUE MPX5700AP. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mpx5700a
}}

{{ttuto
|label=NCD
|descr=Connecter facilement une __mini carte I2C__ de NCD (National Control Device) sur une carte MicroPython grâce au connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Logique 5V. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/NCD
}}

{{ttuto
|label=ncd-mpl115a2
|descr=Le MPL115A2 est un capteur de pression et température I2C. La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD,ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-mpl115a2
}}

{{ttuto
|label=ncd-si7005
|descr=Le SI7005 est un capteur d'humidité relative et température I2C. La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-si7005
}}

{{ttuto
|label=ncd-water-detect
|descr=Détecteur de présence d'eau + Buzzer + 2 GPIOs (basé sur un PCA9536). La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-water-detect
}}

{{ttuto
|label=ncd-fet-solenoid
|descr=Contrôleur de sortie FET + GPIO (basé sur un MCP23008) pour charge résistive / inductive 12V (valve). La carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-fet-solenoid
}}

{{ttuto
|label=ncd-pecmac
|descr=Capteur de courant alternatif sur bus I2C (ou interface IoT). La carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-pecmac
}}

{{ttuto
|label=ncd-oled
|descr=Un afficheur OLED 128x64 avec contrôleur SSD1306 (I2C) et connecteur NCD. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-oled
}}

{{ttuto
|label=neopixel
|descr=Les NéoPixels sont des LEDs digitales intelligentes pouvant être contrôlées indépendamment les unes des autres. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/neopixel
}}

{{ttuto
|label=oled-ssd1306
|descr=Le SSD1306 est un contrôleur d'écran OLED. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/oled-ssd1306
}}

{{ttuto
|label=opt3101-fov
|descr=Capteur de distance Time-Of-Flight FoV 3 canaux OPT3101 (POL3412). POLOLU.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/opt3101-fov
}}

{{ttuto
|label=pca9536
|descr=Contrôleur GPIO 4 bits I2C. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pca9536
}}

{{ttuto
|label=pca9685
|descr=Controleur PWM-Driver à base de PCA9685 de NXP, 16 canaux, résolution 12 bits, pour commande des LEDs ou Servo. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pca9685
}}

{{ttuto
|label=pcf8523
|descr=Une Horloge temps réel RTC + alarme avec MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pcf8523
}}

{{ttuto
|label=pm25
|descr=Utiliser un capteur de particule fine PM2.5 (PMS5003) avec MicroPython. ADAFRUIT,PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pm25
}}

{{ttuto
|label=qwiic-joystick-i2c
|descr=Utiliser un joystick analogique I2C (Qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-joystick-i2c
}}

{{ttuto
|label=qwiic-keypad-i2c
|descr=Utiliser un clavier I2C 12 touches (Qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-keypad-i2c
}}

{{ttuto
|label=qwiic-relay-i2c
|descr=Utiliser un Relais-Simple/Quad-Relais/Quad-Relais-SSR I2C (qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-relay-i2c
}}

{{ttuto
|label=qwiic-vcnl4040-i2c
|descr=Utiliser un capteur de proximité VCNL4040 (Qwiic, I2C) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-vcnl4040-i2c
}}

{{ttuto
|label=rfm69
|descr=Utiliser module Packet Radio RFM69HCW (SPI) avec MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/rfm69
}}

{{ttuto
|label=sht3x
|descr=Exploiter un capteur d'humidité SHT3x avec MicroPython. DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/sht3x
}}

{{ttuto
|label=st7687s
|descr=Exploiter un TFT rond avec MicroPython. DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/st7687s
}}

{{ttuto
|label=stmpe610
|descr=Utiliser un capteur tactile résistif avec MicroPython.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/stmpe610
}}

{{ttuto
|label=tca9554a
|descr=Ajouter 8 entrées/sortie avec le TCA9554A.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tca9554a
}}

{{ttuto
|label=tcs34725
|descr=Capturer la couleur (rgb ou Kelvin) avec un capteur TCS34725 + LED + filtre IR. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tcs34725
}}

{{ttuto
|label=trackball
|descr=Ajouter un Trackball + LED RGBW sur votre projet MicroPython. PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/trackball
}}

{{ttuto
|label=tsl2561
|descr=Le TSL2561 est un senseur de luminosité en lumière visible ayant un réponse proche de l'oeil humain. Retourne une valeur en LUX. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tsl2561
}}

{{ttuto
|label=tsl2591
|descr=Le TSL2591 est un capteur de luminosité en lumière visible ayant un réponse proche de l'oeil humain. Retourne une valeur en LUX. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tsl2591
}}

{{ttuto
|label=umqtt
|descr=Exemples de communication MQTT avec un module ESP8266. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/umqtt
}}

{{ttuto
|label=UEXT
|descr=Connecteur UEXT en logique 3.3V est utilisé sur les cartes et capteurs d' Olimex. Il transporte les bus I2C, SPI, UART et alimentation 3.3V. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/UEXT
}}

{{ttuto-end}}

= PyBoard =
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-PyBoard.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''Micro Python''' est une carte Python 3 offrant 30 GPIO, 20 PWM, 1 RTC, des bus I2C, CAN, SPI, un accéléromètre, etc. la {{cl|56|gamme Micro Python est disponible}} chez [http://shop.mchobby.be MCHobby].
|}

== MicroPython, PyBoard et PYBStick ==

{{ttuto-begin}}

{{ttuto
|label=Micro Python & PyBoard Kaséko?!?
|descr=Venez découvrir le microcontrôleur programmable en Python. Plateforme, Boot, etc.
|img=tlogo-micropython-presentation.jpg
|link=MicroPython.présentation
}}

{{ttuto
|label=En vidéo
|descr=Quelques vidéos très intéressante.
|img=tlogo-micropython-video.jpg
|link=MicroPython.vidéo
}}

{{ttuto
|label=Tester en live
|descr=Un petit laboratoire avec une carte Micro Python connecté sur Internet pour la tester.
|img=tlogo-micropython-net.jpg
|link=MicroPython.Live
}}

{{ttuto
|label=Brochage et Schema
|descr=La carte Micro Python PyBoard, ses fonctionnalités, son brochage, ses schémas et composant Fritzing.
|img=tlogo-micropython-brochage-pyboard.jpg
|link=MicroPython.brochage.pyboard
}}

{{ttuto
|label=Généralités PyB
|descr=Boot Modes, Code d'erreur, système de fichier et réinitialisation. '''A lire avant de se lancer'''.
|img=tlogo-micropython-pyboard-Info.jpg
|link=MicroPython.pyboard.généralités
}}

{{ttuto
|label=Références
|descr=Liens, références et ressources Micro Python.
|img=tlogo-micropython-reference.jpg
|link=MicroPython.référence
}}

{{ttuto
|label=Doc officielle
|descr=L'excellente documentation officielle en anglais. Une importante source de précieuses informations.
|img=tlogo-micropython-docs.jpg
|link=MicroPython.r%C3%A9f%C3%A9rence#Documentation_Officielle
}}

{{ttuto
|label=Modèles de PyBoard.
|descr=Comparatif des différents modèles de la carte PyBoard.
|img=tlogo-micropython-modele.jpg
|link=MicroPython.Pyboard.modele
}}

{{ttuto
|label=Mise-à-jour FirmWare
|descr=Comment faire une mise-à-jour du Firmware de la Pyboard.
|img=tlogo-micropython-update.jpg
|link=MicroPython.Pyboard.mise-a-jour
}}

{{ttuto
|label=Pyboard Discovery Kit
|descr=Un kit et des tutos à thème pour découvrir la carte MicroPython PyBoard.
|img=tlogo-micropython-discovery.jpg
|link=MicroPython.Pyboard.Discovery
}}

{{ttuto
|label=upip
|descr=Télécharger une bibliothèque MicroPython en utilisant le ''Python Index Package''.
|img=tlogo-micropython-upip.jpg
|link=MicroPython-Hack-upip
}}

{{ttuto
|label=PYBStick STD Discovery
|descr=Des tutos à thème pour découvrir MicroPython et la PYBStick STD 26.
|img=tlogo-pybstick-discovery.jpg
|url=https://github.com/mchobby/pyboard-driver/tree/master/PYBStick
}}

{{ttuto
|label=PYBStick HAT-FACE
|descr=Une interface PYBStick vers Raspberry-Pi HAT.
|img=tlogo-pybstick-hat-face.jpg
|link=MicroPython.PYBStick.hat-face
}}

{{ttuto-end}}

== Hacking électronique avec MicroPython ==
ces scripts se penchent sur l'utilisation de MicroPython avec la Pyboard, la PYBStick.

{{ttuto-begin}}

{{ttuto
|label=Précautions & alimentations
|descr=Précautions d'usage avant de se lancer dans le hacking. Comment alimenter votre PyBoard.
|img=tlogo-micropython-prepare.jpg
|link=MicroPython-Hack-Prepare
}}

{{ttuto
|label=Premier script
|descr=Exécutez votre premier script et allumez une LED sur la carte.
|img=tlogo-micropython-firstscript.jpg
|link=MicroPython-Hack-first-script
}}

{{ttuto
|label=L'invite REPL
|descr=Obtenir l'invite '''en ligne de commande''' REPL et utilisez PyBoard en mode terminal.
|img=tlogo-micropython-REPL.jpg
|link=MicroPython-Hack-REPL
}}

{{ttuto
|label=LED et concepts
|descr=Allumer les LEDs de la carte PyBoard. Les concepts de base.
|img=tlogo-micropython-LED.jpg
|link=MicroPython-Hack-LED
}}

{{ttuto
|label=1 LED externe
|descr=Branchez votre première LED sur la PyBoard et contrôlez là.
|img=Tlogo-micropython-1led.png
|link=MicroPython-Hack-1LED
}}

{{ttuto
|label=8 LEDs
|descr=Contrôler plusieurs LEDs.
|img=Tlogo-micropython-8leds.png
|link=MicroPython-Hack-8LEDS
}}

{{ttuto
|label=Bouton
|descr=Bouton, '''callback''' et '''interruption'''.
|img=tlogo-micropython-button.jpg
|link=MicroPython-Hack-button
}}

{{ttuto
|label=L'accéléromètre
|descr=Utiliser l'accéléromètre de la carte.
|img=tlogo-micropython-accelerometre.jpg
|link=MicroPython-Hack-accelerometre
}}

{{ttuto
|label=Safe Mode & réinitialisation
|descr=Safe Mode et réinitialisation d'usine. Reprenez le contrôle de votre PyBoard
|img=tlogo-micropython-safemode.jpg
|link=MicroPython-Hack-safemode
}}

{{ttuto
|label=PyBoard = souris
|descr=Faire agir la PyBoard comme une souris. Réalisez vos propres interface homme-machine.
|img=tlogo-micropython-souris.jpg
|link=MicroPython-Hack-souris
}}

{{ttuto
|label=Les timers
|descr=Mesurer des durées, réaliser des synchronisations ou exécuter du code à intervalle régulier. Exploitez les 14 timers de votre PyBoard.
|img=tlogo-micropython-timer.jpg
|link=MicroPython-Hack-timers
}}

{{ttuto
|label=Assembleurs
|descr=Utiliser l'assembleur inline. Ajouter du code assembleur ARM au sein même de vos programmes.
|img=tlogo-micropython-assembleur.jpg
|link=MicroPython-Hack-assembleur
}}

{{ttuto
|label=Contrôle de puissance
|descr=Contrôler la consommation de votre PyBoard.
|img=tlogo-micropython-power.jpg
|link=MicroPython-Hack-power
}}

{{ttuto
|label=Servo-moteur
|descr=Contrôler des servo moteur en Micro Python. Quelques commandes pour positionner un axe sur un angle donné.
|img=tlogo-moteur-servo.jpg
|link=MicroPython-Hack-servo
}}

{{ttuto
|label=Luminosité d'une LED
|descr=Contrôler la luminosité d'une LED ou la faire pulser avec un signal PWM.
|img=tlogo-micropython-fading.jpg
|link=MicroPython-Hack-fading
}}

{{ttuto
|label=Déparasitage entrée
|descr=Comment déparasiter une entrée.
|img=tlogo-micropython-deparasitage.jpg
|link=MicroPython-Hack-deparasitage
}}

{{ttuto
|label=Lecture Analogique
|descr=Réaliser une lecture analogique sur le PyBoard.
|img=tlogo-micropython-analogique.png
|link=MicroPython-Hack-Analogique
}}

{{ttuto
|label=TMP36 = °C
|descr=Lire la température avec TMP36 un senseur de température analogique.
|img=tlogo-micropython-tmp36.png
|link=MicroPython-Hack-TMP36
}}

{{ttuto
|label=Photo-résistance
|descr=Utiliser une photorésistance, Ldr, Cds et une entrée analogique pour détecter la présence de la lumière.
|img=tlogo-micropython-LDR.png
|link=MicroPython-Hack-LDR
}}

{{ttuto
|label=Moteur
|descr=Utiliser un transistor pour commander un moteur.
|img=tlogo-micropython-moteur.png
|link=MicroPython-Hack-moteur
}}

{{ttuto
|label=Relais
|descr=Commander des charges plus importantes à l'aide d'un relais.
|img=tlogo-micropython-relais.png
|link=MicroPython-Hack-relais
}}

{{ttuto
|label=LED RGB
|descr=Contrôler une LED Rouge,Vert,Bleu pour créer n'importe quelle couleur
|img=tlogo-micropython-LedRGB.png
|link=MicroPython-Hack-led-RGB
}}

{{ttuto
|label=Piezo
|descr=Utiliser un piezo buzzer pour faire de la musique
|img=tlogo-micropython-Piezo.png
|link=MicroPython-Hack-piezo
}}

{{ttuto
|label=Déboguer
|descr=Quelques petits trucs pour vous aider à déboguer vos programmes.
|img=tlogo-micropython-Debugger.jpg
|link=MicroPython-Hack-Debug
}}

{{ttuto
|label=Outil dev
|descr=Quelques outils pour aider vos développement PyBoard.
|img=tlogo-micropython-Debugger.jpg
|link=MicroPython-Hack-Outil
}}

{{ttuto
|label=USB <-> UART
|descr=Envoyer les données de l'UART vers USB (et vice-versa).
|img=tlogo-micropython-USB-UART.jpg
|link=MicroPython-Hack-USB-UART
}}

{{ttuto-end}}

== Extensions Pyboard ==

{{ttuto-begin}}

{{ttuto
|label=Extension LCD
|descr=Utiliser l'extension LCD.
|img=tlogo-micropython-LCD.jpg
|link=MicroPython-LCD
}}

{{ttuto
|label=TFT 2.8"
|descr=Utiliser un TFT 2.8 avec contrôleur ILI9341 sur un PyBoard
|img=tlogo-micropython-ILI9341.jpg
|link=MicroPython-ILI9341
}}

{{ttuto
|label=Maîtriser I2C
|descr=Utiliser et maîtriser les bus I2C sous MicroPython.
|img=tlogo-micropython-I2C.jpg
|link=MicroPython-I2C
}}

{{ttuto
|label=Ultrason HC-SR04
|descr=Evaluer une distance de 2cm à 4m avec le HC-SR04. Il fonctionne comme un sonar.
|img=tlogo-HC-SR04.jpg
|link=MicroPython-HC-SR04
}}

{{ttuto
|label=Pont-H L293D
|descr=Double Pont-H pour contrôler deux moteurs (basse puissance)
|img=tlogo-micropython-l293.jpg
|link=hack-micropython-L293D
}}

{{ttuto
|label=Afficheur 4x7 I2C
|descr=Utilisation d'afficheur 4x7 segment sur le bus I2C de la PyBoard.
|img=tlogo-micropython-4x7.jpg
|link=MicroPython-4x7
}}

{{ttuto
|label=Contrôleur PWM
|descr=Utilisation du controleur PWM 16 canaux avec la PyBoard.
|img=tlogo-adf-pwm.jpg
|link=MicroPython-PWM-DRIVER
}}

{{ttuto
|label=Mosfet
|descr=Commander un MOSFET de puissance à partie d'un microcontrôleur 3.3V.
|img=tlogo-micropython-Mosfet.png
|link=MicroPython-Hack-Mosfet
}}

{{ttuto
|label=Bluetooth & REPL
|descr=Utiliser un module Bluetooth série avec PyBoard. Dupliquer REPL sur Bluetooth.
|img=tlogo-micropython-bluetooth.jpg
|link=MicroPython-bluetooth
}}

{{ttuto
|label=HAT-SENSE
|descr=Utiliser le Hat-Sense avec votre Pyboard
|img=tlogo-micropython-hat-sense.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=PYBD Butterfly
|descr=Assembler le Pyboard-D Butterfly
|img=tlogo-pybd-butterfly.jpg
|link=PYBD-Butterfly
}}



{{ttuto-end}}

== PyBoard Robotique ==

Voici quelques tutoriels pour réaliser une plateforme robotique à base de MicroPython PyBoard.

{{ttuto-begin}}

{{ttuto
|label=Robot 2 Roues
|descr=Commander un robot 2 roues maison avec MicroPython PyBoard et un L293D
|img=tlogo-micropython-Robot2Wheel.jpg
|link=hack-micropython-Robot2Wheel
}}

{{ttuto
|label=Robot Ultrason
|descr=Piloter le robot 2 roues avec un senseur Ultrason HC-SR04
|img=tlogo-micropython-Robot2Wheel-HC-SR04.jpg
|link=hack-micropython-Robot2Wheel-HC-SR04
}}

{{ttuto
|label=Motor-Skin
|descr=Contrôler facilement une plateforme robotique à deux moteurs avec le Motor-Skin pour PyBoard.
|img=tlogo-motorskin-00.jpg
|link=hack-MotorSkin
}}

{{ttuto
|label=ENG: Motor-Skin
|descr=Take the control of a 2 motors robotic plateform with the PyBoard's Motor-Skin.
|img=tlogo-motorskin-00.jpg
|link=hack-ENG-MotorSkin
|traduction=1
}}

{{ttuto
|label=Servo Robots
|descr=Apprenez à réaliser DOGGY et prendre le contrôle de Robots utilisant des servos moteurs pour se déplacer.
|img=tlogo-micropython-ServoRobot.jpg
|link=hack-micropython-ServoRobot
}}

{{ttuto
|label=Moteur DFRobot
|descr=Apprenez à contrôler les moteurs continu DFRobot avec un signal servo. Trop classe!
|img=tlogo-micropython-dfrobot-motor.jpg
|link=hack-micropython-dfrobot-motor
}}

{{ttuto-end}}

= Autres =
== ESP8266 en MicroPython ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-ESP8266.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur ESP8266'''. Reflasher un {{pl|846|Feather ESP8266}}, un {{deadpl|1221|Wemos D1 Mini}}, {{pl|668|ESP8266-EVB}} ou NodeMCU pour qu'il supporte MicroPython afin de réaliser des senseurs connectés à prix imbattable! Un minimum de savoir faire est cependant requis.
|}

Cette section est dévolue à la plateforme {{pl|846|Feather ESP8266 Huzza}}, {{deadpl|1221|Wemos ESP8266}}, NodeMCU reflashé pour MicroPython et extension comme {{cl|87|FeatherWing}}, {{cl|123|Wemos Extension}} (extension).

Cette section est assortie du [https://github.com/mchobby/esp8266-upy GitHub ESP8266-upy contenant des sources et exemples].

=== Généralités ===
{{ttuto-begin}}

{{ttuto
|label=Feather ESP8266
|descr=Découvrir le Feather ESP8266, son Brochage, Alimentation, Schéma, FAQ.
|img=tlogo-feather-esp8266.jpg
|link=FEATHER-ESP8266
}}

{{ttuto
|label=ESP8266-EVB
|descr=Découvrir l'ESP8266-EVB (evaluation board) et ESP8266-DEV (module ESP), son Brochage, Alimentation, Port UEXT, Schéma, FAQ.
|img=tlogo-esp8266-dev.jpg
|link=ESP8266-DEV
}}

{{ttuto
|label=ESP32-EVB
|descr=Commander les éléments de la carte '''ESP32'''-DEV d'Olimex.
|img=tlogo-esp32-evb.png
|link=MicroPython-esp32-evb
}}

{{ttuto
|label=Charger MicroPython
|descr=Apprenez comment charger le Firmware MicroPython sur une carte Pyboard, ESP32/ESP8266 (Feather, Wemos, NodeMcu), etc.
|img=tlogo-feather-load-upy.jpg
|link=FEATHER-CHARGER-MICROPYTHON
}}

{{ttuto
|label=Téléverser & Exécuter
|descr=Téléverser des fichiers et exécuter du code. Un flux simple de développement.
|img=tlogo-feather-load-file.jpg
|link=FEATHER-CHARGER-FICHIER-MICROPYTHON
}}

{{ttuto
|label=ESP8266 WebRepl
|descr=Accéder à la console Python via la connexion WiFi d'un ESP8266.
|img=tlogo-feather-WebRepl.jpg
|link=FEATHER-WEBREPL
}}

{{ttuto
|label=Charger un module
|descr=Charger des modules Python pour ajouter de nouvelle fonctionnalités à votre carte.
|img=tlogo-feather-charger-module.jpg
|link=FEATHER-CHARGER-MODULE
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto
|label=upip
|descr=Télécharger une bibliothèque MicroPython en utilisant le ''Python Index Package''.
|img=tlogo-micropython-upip.jpg
|link=MicroPython-Hack-upip
}}

{{ttuto-end}}

=== Hacking électronique ===
{{ttuto-begin}}

{{ttuto
|label=Entrée Analogique
|descr=Utilisation de l'entrée analogique du Feather ESP8266 sous MicroPython.
|img=tlogo-micropython-analogique.png
|link=FEATHER-MICROPYTHON-ADC
}}

{{ttuto
|label=AM2315 - Humidité
|descr=Mesure de '''température''' et '''humidité''' {{underline|en extérieur}} avec AM2315
|img=tlogo-feather-upy-am2315.jpg
|link=FEATHER-MICROPYTHON-AM2315
}}

{{ttuto
|label=DHT11 - Humidité
|descr=Mesure d' '''humidité''' et '''température''' avec le très économique DHT11.
|img=tlogo-feather-upy-dht11.jpg
|link=FEATHER-MICROPYTHON-DHT11
}}

{{ttuto
|label=TSL2561 - Luminosité
|descr=Mesure de la luminosité en Lux.
|img=tlogo-feather-upy-TSL2561.jpg
|link=FEATHER-MICROPYTHON-TSL2561
}}

{{ttuto
|label=BMP180 - pression
|descr=Mesurer la pression atmosphérique et normalisez là.
|img=tlogo-feather-upy-BMP180.jpg
|link=FEATHER-MICROPYTHON-BMP180
}}

{{ttuto
|label=BMP280 / BME280
|descr=Mesurer la pression atmosphérique, température avec BMP280 + humidité avec BME280.
|img=tlogo-feather-upy-BME280.jpg
|link=FEATHER-MICROPYTHON-BME280
}}

{{ttuto
|label=ADS1x15
|descr=Mesurer précisément une tension analogique avec un ADS1115 ou ADS1015.
|img=tlogo-feather-upy-ADS1115.jpg
|link=FEATHER-MICROPYTHON-ADS1115
}}

{{ttuto
|label=NeoPixel
|descr=Utiliser des NeoPixel (WS2812, SK6812) sur ESP avec MicroPython. Comment passer de 3.3V à 5V.
|img=tlogo-feather-upy-neopixel.jpg
|link=FEATHER-MICROPYTHON-NEOPIXEL
}}

{{ttuto
|label=GPIO Expander
|descr=Utiliser le MCP23017 pour ajouter des entrées/sorties sur ESP8266.
|img=tlogo-feather-upy-MCP23017.png
|link=FEATHER-MICROPYTHON-MCP23017
}}

{{ttuto
|label=OLED
|descr=Utiliser un écran OLED en MicroPython (ESP8266).
|img=tlogo-feather-upy-oled.jpg
|link=FEATHER-MICROPYTHON-OLED
}}

{{ttuto
|label=MOD-OLED [UEXT]
|descr=Un écran OLED 128x64 (I2C) utilisé sous MicroPython (via port UEXT).
|img=tlogo-mod-oled.png
|link=MICROPYTHON-MOD-OLED
}}

{{ttuto
|label=MOD-IO [UEXT]
|descr=Utiliser le module I2C '''MOD-IO''' sous MicroPython (via port UEXT).
|img=tlogo-mod-io.png
|link=MICROPYTHON-MOD-IO
}}

{{ttuto
|label=MOD-IO2 [UEXT]
|descr=Utiliser le module I2C '''MOD-IO2''' sous MicroPython (via port UEXT).
|img=tlogo-mod-io2.jpg
|link=MICROPYTHON-MOD-IO2
}}

{{ttuto
|label=MOD-RGB [UEXT]
|descr=Contrôler des rubans LEDs RGB / RVB avec le module I2C '''MOD-RGB''' sous MicroPython (via port UEXT).
|img=tlogo-mod-rgb.png
|link=MICROPYTHON-MOD-RGB
}}

{{ttuto
|label=MOD-LCD1x9 [UEXT]
|descr=Contrôler l'afficheur Alphanumérique à cristaux liquide avec le module I2C '''MOD-LCD1x9''' sous MicroPython (via port UEXT).
|img=tlogo-mod-lcd1x9.png
|link=MICROPYTHON-MOD-LCD1x9
}}

{{ttuto
|label=MOD-MAG3110 [UEXT]
|descr=Un magnétomètre 3 axes '''MAG3110''' de NXP avec le module I2C '''MOD-MAG3110''' sous MicroPython (via port UEXT).
|img=tlogo-mod-mag3110.png
|link=MICROPYTHON-MOD-MAG3110
}}

{{ttuto
|label=MOD-LTR501ALS [UEXT]
|descr=Senseur de luminosité et de proximité '''LTR-501ALS'''. Exploiter le module I2C sous MicroPython (via port UEXT).
|img=tlogo-mod-ltr501als.png
|link=MICROPYTHON-MOD-LTR501ALS
}}

{{ttuto
|label=MOD-Wii-Chuck [UEXT]
|descr=Contrôleur de jeu I2C Wii Nunchuck. Exploiter le sous MicroPython (via port UEXT).
|img=tlogo-mod-wii-nunchuck.png
|url=https://github.com/mchobby/esp8266-upy/tree/master/modwii
}}

{{ttuto
|label=DFR-Anemometer
|descr=Utiliser un anémomètre (SEN0170) à sortie analogique avec un ESP32 sous MicroPython.
|img=tlogo-anemometer.png
|link=MICROPYTHON-ANEMOMETER
}}

{{ttuto
|label=DFR-Girouette
|descr=Utiliser une Girouette un anémomètre RS485 (SEN0482) sous MicroPython avec l'aide d'un module MOD-RS485-ISO.
|img=tlogo-grouette.png
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrs485iso
}}

{{ttuto-end}}

== SAMD21 en MicroPython ==

{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-SAMD21.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur SAMD21'''. Reflasher un {{sl|M0|Feather M0}} ou {{sl|zero|Arduino Zero}} pour qu'il supporte MicroPython! Un minimum de savoir faire est cependant requis.
|}

Cette section est dévolue aux plateforme SAMD21 comme le {{sl|M0|Feather M0}} ou {{sl|zero|Arduino Zero}} reflashé pour MicroPython.

{{ttuto-begin}}

{{ttuto
|label=Compiler et charger MicroPython
|descr=Comment compiler MicroPython et le charger sur une carte SAMD21.
|img=tlogo-samd21-charger-micropython.jpg
|link=SAMD21-CHARGER-MICROPYTHON
|traduction=1
}}

{{ttuto
|label=Feather M0 Express
|descr=Carte Feather conçue pour Arduino IDE et CircuitPython (MicroPython)
|img=tlogo-feather-m0-express.jpg
|link=FEATHER-M0-EXPRESS
}}

{{ttuto-end}}

== WiPy ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-WiPy.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''WiPy''' est une plateforme de développement "Internet des Objets" qui fonctionne sous Python. WiPy à moins de GPIO, est moins rapide que la PyBoard MAIS inclus le support WiFi. la {{cl|68|gamme WiPy disponible}} chez [http://shop.mchobby.be MCHobby].
|}

Cette section est dévolue à la plateforme {{pl|737|MicroPython WiPy}}.

=== Découvrir WiPy ===
{{ttuto-begin}}

{{ttuto
|label=Généralités WiPy
|descr=Informations générales '''mais importantes''' à propos de WiPy.
|img=tlogo-micropython-pyboard-Info.jpg
|link=hack-wipy-generalite
}}

{{ttuto
|label=WiPy intro
|descr=Introduction à WiPy, en prendre soin, la carte d'extension et les tensions d'alimentation
|img=tlogo-wipy-intro.jpg
|link=hack-wipy-introduction
}}

{{ttuto
|label=Brochage WiPy
|descr=Le brochage du WiPy et les informations utiles sur les broches.
|img=tlogo-wipy-pinout.jpg
|link=hack-wipy-pinout
}}

{{ttuto
|label=WiPy REPL
|descr=Votre WiPy en ligne de commande avec le REPL. Envoyez des ordres à votre WiPy depuis votre réseau WiFi.
|img=Tlogo-micropython-REPL.jpg
|link=hack-wipy-repl
}}

{{ttuto
|label=WiPy et Blynk
|descr=Utilisez votre WiPy depuis votre smartphone à l'aide de Blynk
|img=tlogo-wipy-blynk.jpg
|link=hack-wipy-blynk
}}

{{ttuto
|label=Config WiFi/WLAN
|descr=Configuration de la connexion WiFi/WLAN de votre WiPy étape par étape.
|img=tlogo-wipy-intro.jpg
|link=hack-wipy-wlan
}}

{{ttuto
|label=Boot/Reset
|descr=Réinitialisation (Reset) et mode de démarrage (boot mode) de votre WiPy. Ne restez jamais bloqué avec votre WiPy.
|img=Tlogo-micropython-safemode.jpg
|link=hack-wipy-boot-mode
}}

{{ttuto
|label=Mise-à-jour
|descr=Comment réaliser la mise-à-jour du firmware.
|img=tlogo-micropython-update.jpg
|link=hack-wipy-upgrade-firmware
}}

{{ttuto
|label=Références
|descr=Liens, références et ressources concernant WiPy, LoPy.
|img=tlogo-micropython-reference.jpg
|link=hack-wipy-reference
}}

{{ttuto-end}}

=== Hacking electronic avec WiPy ===

{{ttuto-begin}}

{{ttuto
|label=Controler HeartBeat
|descr=Prenez le contrôle de votre première LED, la LED HeartBeat présent sur la carte.
|img=tlogo-hack-wipy-heatbeat.jpg
|link=hack-wipy-heartbeat
}}

{{ttuto
|label=LED Externe
|descr=Brancher et contrôler une LED. Apprenez ce que signifie ''Current Sink'' et et ''Current Source''
|img=Tlogo-micropython-1led.png
|link=hack-wipy-led
}}

{{ttuto
|label=Bouton
|descr=Utiliser une entrée pour lire l'état d'un bouton. Apprenez ce que signifie ''Résistance Pull Up'' et utiliser les '''interruptions''' et fonction '''callback'''.
|img=Tlogo-wipy-button.jpg
|link=hack-wipy-button
}}

{{ttuto
|label=Relais
|descr=Commandez un Relais avec votre WiPy.
|img=Tlogo-wipy-relais.png
|link=hack-wipy-Relais
|traduction=1
}}

{{ttuto
|label=Timer
|descr=Utiliser un Timer pour appeler régulièrement du code sur votre WiPy.
|img=Tlogo-wipy-timer.png
|link=hack-wipy-Timer
|traduction=1
}}
{{ttuto-end}}

== LoPy & WiPy 2 ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-Lopy.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''LoPy''' est une plateforme de développement "Internet des Objets" qui fonctionne sous Python. LoPy supporte 3 types de réseau sans fil: LoRa, WiFi et Bluetooth. la {{cl|68|gamme WiPy/Lopy est disponible}} chez [http://shop.mchobby.be MCHobby].
|}

Cette section est dévolue à la plateforme {{pl|737|MicroPython LoPy}}, {{pl|1039|MicroPython WiPy 2}} et la {{pl|1011|carte d'extension WiPy/LoPy}}. Les plateformes WiPy 2 et Lopy sont toutes deux basées sur un ESP_32, ce qui fait que cette section convient pour les deux plateformes.

{{ambox|text=19/02/2017: Le FirmWare du Lopy/Wipy est activement développé, des nouvelles et/ou firmwares sont disponibles toutes les semaines.

Tenez vous au courant en suivant les [https://forum.pycom.io/category/1/announcements-news annonces du forum Pycom.io] pour être tenu au courant.}}

=== Découvrir LoPy / WiPy 2 ===

LoPy et WiPy 2 sont tous les deux basés sur une plateforme ESP_32, de ce fait, les guides ci-dessous conviennent pour les deux plateformes.

Vous pouvez également vous inspirer des montages et exemples du WiPy 1 pour faire du prototypage électronique.

{{ttuto-begin}}

{{ttuto
|label=Démarrer
|descr=Démarrer rapidement avec LoPy ou WiPy 2 (plateforme ESP_32 de PyCom)
|img=tlogo-lopy-intro.jpg
|link=hack-pycom-esp_32
}}

{{ttuto
|label=Brochage WiPy2
|descr=Brochage du WiPy 2
|img=tlogo-wipy2-pinout.jpg
|link=hack-pycom-wipy2-pinout
}}

{{ttuto
|label=Brochage LoPy
|descr=Brochage du LoPy
|img=tlogo-lopy-pinout.jpg
|link=hack-pycom-lopy-pinout
}}

{{ttuto
|label=FTP/Telnet
|descr=Se connecter en FTP ou telnet sur le Lopy
|img=tlogo-lopy-ftp.jpg
|link=hack-pycom-lopy-ftp
}}

{{ttuto
|label=Pymakr IDE
|descr=Un éditeur qui se connecte en Telnet ou port série. Utiliser la LED du RGB du WiPy.
|img=tlogo-lopy-ide.jpg
|link=Hack-pycom-lopy-Pymakr
}}

{{ttuto
|label=Boîte à outils
|descr=Les modules, REPL, FTP, '''Boot mode''', Interruption... tout ce qu'il faut savoir
|img=tlogo-lopy-toolbix.jpg
|link=Hack-pycom-lopy-toolbox
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. WiPy et ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto-end}}

Micropython-PIR-alarm

2026-01-07T00:32:16Z

Admin : /* Augmenter la tension */

Fichier:Tlogo-4G-base-Station.png

2026-01-06T23:46:39Z

Admin :

MicroPython-Accueil

2026-01-06T23:43:03Z

Admin : /* Hacking électronique */

{{device-links}}

{| border="0"
|-
| align="left" width="360px" | [[Fichier:powered-by-micropython.png|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''Micro Python''' est une version optimisée et allégée de Python 3 pour système embarqué. '''PyBoard, Pico, ESP32, etc sont des cartes microcontrôleurs supportant MicroPython'''. Ces cartes électroniques exécutnt MicroPython en ''[http://en.wikipedia.org/wiki/Bare_machine bare metal]'' et vous offre un système d'exploitation Python de bas niveau permettant de contrôler toute sorte de projets électroniques. Trop fort... I Love It!!! La {{cl|56|gamme Micro Python est maintenant disponible}} chez [http://shop.mchobby.be MCHobby].
|}

= Pico / Pico2 (Raspberry-Pi) =
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-pico.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur Raspberry-Pi Pico''' et '''Pico Wireless'''. Reflasher un {{pl|2025|Pico}}, un {{pl|2036|Pico Header}} pour qu'il supporte MicroPython afin de réaliser des objets intelligents à prix imbattable!
|}

Cette section est dévolue à la plateforme {{pl|2025|Pico}} reflashé avec MicroPython.

Cette section est assortie:
* du [https://github.com/mchobby/esp8266-upy GitHub ESP8266-upy contenant des sources et exemples pour cartes MicroPython].
* du [https://github.com/mchobby/pyboard-driver/tree/master/Pico GitHub Pyboard-Driver contenant des ressource pour la carte Pico]

== Généralités ==
{{ttuto-begin}}

{{ttuto
|label=Python_SDK_FR
|descr=Un PDF pour découvrir le Raspberry-Pi Pico, son Brochage, Alimentation, Schéma, FAQ.
|img=tlogo-pico-python-sdk.jpg
|url=http://df.mchobby.be/RASPBERRY-PICO/Python_SDK_FR.pdf
}}

{{ttuto
|label=Brochage
|descr=Le brochage de référence du Pico sous MicroPython.
|img=tlogo-pico-pinout.jpg
|url=https://raw.githubusercontent.com/mchobby/pyboard-driver/master/Pico/docs/_static/Pico.png
}}

{{ttuto
|label=Thonny IDE
|descr=Utiliser Thonny IDE avec Pico et carte RP2040
|img=tlogo-thonny.jpg
|url=https://arduino103.blogspot.com/2022/01/micromod-rp2040-pico-utiliser-thonny.html
}}

{{ttuto
|label=Pico et Thonny
|descr=Utiliser l'IDE Thonny (recommandé par la fondation) avec votre Pico. Un bel article de Framboise314.
|img=tlogo-pico-thonny.jpg
|url=https://www.framboise314.fr/utiliser-le-raspberry-pi-pico-avec-thonny/
}}

{{ttuto
|label=Ressources
|descr=Diverses ressources pour le Pico sous MicroPython. Y Compris un Pico annoté
|img=tlogo-Github.jpg
|url=https://github.com/mchobby/pyboard-driver/tree/master/Pico
}}

{{ttuto
|label=Reset btn
|descr=Ajouter un bouton Reset à votre Pico.
|img=tlogo-pico-reset.jpg
|link=PICO-RESET-BUTTON
}}

{{ttuto
|label=Pico-W Intro
|descr=Découvrir le Raspberry-Pi Pico WIRELESS - WiFi et Bluetooth sur le Pico
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/06/raspberry-pi-pico-wireless-wifi-et.html
}}

{{ttuto
|label=Pico-W et MicroPython
|descr=Pico Wireless : installer le firmware MicroPython
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/06/pico-wireless-installer-le-firmware.html
}}

{{ttuto
|label=Pico-W et WiFi
|descr=Pico Wireless : MicroPython et le WiFi
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/07/pico-wireless-micropython-et-le-wifi.html
}}

{{ttuto
|label=Pico-W WebREPL
|descr=Pico Wireless: Comment utiliser WEBRepl
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/08/pico-wireless-comment-utiliser-webrepl.html
}}

{{ttuto
|label=Pico LED utilisateur
|descr=Pico Wireless: MicroPython et la LED utilisateur
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/07/pico-wireless-micropython-et-la-led.html
}}

{{ttuto
|label=TrinKey QT2040
|descr=Utiliser le TrinKey QT2040 (RP2040) avec MicroPython
|img=tlogo-pico-trinkey-QT2040.png
|link=TrinKey-QT2040
}}

{{ttuto
|label=Adafruit SeeSaw
|descr=Utiliser le SeeSaw (multi-interface via I2) avec MicroPython (et Pico)
|img=tlogo-seesaw.png
|url=https://github.com/mchobby/micropython-seesaw
}}

{{ttuto-end}}

== Hacking électronique ==
{{ttuto-begin}}

{{ttuto
|label=Pico CanSat
|descr=Control a CANSAT with MicroPython and Raspberry-Pi Pico
|img=tlogo-cansat-pico.jpg
|link=ENG-CANSAT-PICO-BELGIUM
}}

{{ttuto
|label=Pico-2-Explorer
|descr=Découvrir MicroPython avec le Raspberry-Pi Pico 2. Entrées/sorties, analogique, PWM, etc
|img=tlogo-pico-2-explorer.jpg
|link=Pico-2-Explorer-FR
}}

{{ttuto
|label=Shield Moteur
|descr=Utiliser un MotorShield ou Motor FeatherWing avec le Pico.
|img=tlogo-pico-motorshield.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/adfmotors
}}

{{ttuto
|label=Afficheur TFT ILI934x
|descr=Utiliser un TFT 2.4" FeatherWing (ILI9341) avec le Pico
|img=tlogo-pico-ili934x.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ili934x
}}

{{ttuto
|label=HAT-SENSE
|descr=Utiliser le Hat-Sense avec votre Pico
|img=tlogo-micropython-hat-sense.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=HAT-PiFace
|descr=Utiliser le PiFace Digital avec votre Pico
|img=tlogo-micropython-hat-piface.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=Pulse-In
|descr=Mesurer la longueur d'une impulsion Servo sur un récepteur RC
|img=tlogo-pico-pulse-in.jpg
|link=PICO-PULSE-IN-MICROPYTHON
}}

{{ttuto
|label=Pico<->Minitel
|descr=Brancher un Pico sur un Minitel, recevoir et envoyer des caractères
|img=tlogo-Minitel.jpg
|url=https://arduino103.blogspot.com/2022/04/minitel-branche-sur-mon-raspberry-pi.html
}}

{{ttuto
|label=Pico, Zumo Robot et MicroPython
|descr='''Ebook''' pour apprendre a utiliser votre Zumo Robot pour Arduino avec MicroPython.
|img=tlogo-Pico-Zumo-Robot-et-MicroPython.jpg
|link=Pico-Zumo-Robot-et-MicroPython
}}

{{ttuto
|label=Zumo Robot en Python
|descr='''GitHub''' Robot Zumo sous MicroPython avec le Pico ou la Pyboard
|img=tlogo-zumo-pico.jpg
|url=https://github.com/mchobby/micropython-zumo-robot
}}

{{ttuto
|label=MyDin
|descr=DIN Automation with MicroPython
|img=tlogo-mydin.jpg
|link=MyDin
}}

{{ttuto
|label=UniPi en Python
|descr=Créer un automate programmable avec UniPi et MicroPython
|img=tlogo-unipi-pico.jpg
|bad_url=https://github.com/mchobby/micropython-zumo-robot
|traduction=1
}}

{{ttuto
|label=Pico Buggy
|descr=Contôler le Buggy Kitronik avec MicroPython (traduction MCHobby)
|img=tlogo-pico-buggy.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Autonomous-Robotics-Platform-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Smart Air Quality
|descr=Mesurer la qualité d'air avec un Pico (traduction MCHobby)
|img=tlogo-pico-air-quality.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Smart-Air-Quality-Board-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Pico Contrôle Robotique
|descr=Carte de contrôle robotique pour Pico (traduction MCHobby)
|img=tlogo-pico-motor.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Robotics-Board-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Pico Contrôle Moteur
|descr=Carte de contrôle moteur pour Pico (traduction MCHobby)
|img=tlogo-pico-motor2.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Motor-Driver-Board-MicroPython
}}

{{ttuto
|label=Wifi-4-Relay
|descr=Commander un module 4 relais avec via Page WEB ou API REST.
|img=tlogo-wifi-4-relay.jpg
|url=https://github.com/mchobby/micropython-wifi-4-relais
}}

{{ttuto
|label=ArdBase
|descr=Découvrir le hacking électronique pour avec Kit ArdBase et MicroPython
|img=tlogo-pico-ardbase-micropython.png
|url=https://github.com/mchobby/KIT-SOUDURE-ARDBASE
}}

{{ttuto
|label=Tamagotchi
|descr=Créer un Tamagotchi sous MicroPython avec Raspberry-Pi Pico
|img=tlogo-pico-tamagotchi.jpg
|link=Pico-Tamagotchi-Intro
}}

{{ttuto
|label=Adafruit NeoTrellis
|descr=Utiliser un NeoTrellis d'Adafruit avec Raspberry-Pi Pico/Pico2.
|img=tlogo-micropython-neotrellis.png
|link=micropython-neotrellis-pico
}}

{{ttuto
|label=RoboEyes
|descr=Donnez de la personnalité à vos robot avec l'implémentation de RoboEyes pour MicroPython.
|img=tlogo-micropython-roboeyes.png
|url=https://github.com/mchobby/micropython-roboeyes
}}

{{ttuto
|label=Capteur Alarme
|descr=Comment utiliser des capteurs d'alarme PIR avec un microcontroleur
|img=tlogo-PIR-alarm.png
|link=micropython-PIR-alarm
|traduction=1
}}

{{ttuto
|label=4G-Base-Station
|descr=Station de contrôle avec carte 4G équipée d'entrées et sorties... programmable en MicroPython.
|img=tlogo-4G-base-Station.png
|url=https://github.com/mchobby/micropython-4G-BASE-STATION
}}

{{ttuto-end}}

= EDI pour MicroPython =
Les outils et editeurs pouvant être utilisés avec MicroPython.

{{ttuto-begin}}
{{ttuto
|label=Thonny IDE
|descr=Utiliser Thonny IDE avec Pico et carte RP2040
|img=tlogo-thonny.jpg
|url=https://arduino103.blogspot.com/2022/01/micromod-rp2040-pico-utiliser-thonny.html
}}

{{ttuto
|label=Pico et Thonny
|descr=Utiliser l'IDE Thonny (recommandé par la fondation) avec votre Pico. Un bel article de Framboise314.
|img=tlogo-pico-thonny.jpg
|url=https://www.framboise314.fr/utiliser-le-raspberry-pi-pico-avec-thonny/
}}

{{ttuto
|label=MPRemote
|descr='''MicroPython Remote Control''' outil en ligne de commande qu'il ne faut surtout pas râter.
|img=tlogo-MPRemote.png
|url=https://github.com/mchobby/micropython-minishell
}}

{{ttuto
|label=MIP
|descr='''MicroPython Install Package''' une commande MPRemote pour installer facilement des bibliothèques
|img=tlogo-MPRemote-MIP.png
|url=https://arduino103.blogspot.com/2023/05/micropython-1200-mip-micropython.html
}}

{{ttuto
|label=MiniShell
|descr=MiniShell est un Shell type Linux pour MicroPython. Très pratique pour manipuler des fichiers via REPL.
|img=tlogo-minishell.jpg
|url=https://github.com/mchobby/micropython-minishell
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. WiPy et ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto
|label=Ampy
|descr=Outil simplifié de transfert de fichiers et de contrôlez de carte depuis une connexion série. ESP8266 compatible.
|img=tlogo-micropython-Debugger.jpg
|link=FEATHER-CHARGER-FICHIER-MICROPYTHON
}}

{{ttuto
|label=mem_info()
|descr=Surveiller la consommation RAM de vos script sous MicroPython
|img=tlogo-mem-info.jpg
|url=https://arduino103.blogspot.com/2023/03/micropython-surveiller-la-ram-avec.html
}}

{{ttuto-end}}

= Pilotes MicroPython =
Les pilotes MicroPythons sont des bibliothèques utilisées pour interagir avec des composants électroniques ou cartes breakouts.

Chez MC Hobby, nous développons des pilotes "Plateform Agnostic". Cela signifie que les bibliothèques s'appuient sur l'API {{fname|machine}} et peuvent être utilisés sur toutes les plateformes MicroPython.

Enfin, nous produisons une documentation aussi complète que possible (français/anglais) + scripts d'exemples. Tous cela stocké sur un dépôt en ligne.

{{ttuto-begin}}

{{ttuto
|label=ad9833
|descr=Créer un générateur de signal à l'aide de l AD9833.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ad9833
}}

{{ttuto
|label=adfmotors
|descr=Contrôler des moteurs continu, pas-à-pas ou servo-moteur avec le shield moteur Arduino d'Adafruit. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/adfmotors
}}

{{ttuto
|label=ads1015-ads1115
|descr=Convertisseur ADC (Analogique vers Digital) 4 canaux pour réaliser des lectures analogiques et lectures différentielles. L'ADS1115 dispose d'un amplificateur interne programmable, ce qui permet de lire des tensions très faibles. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ads1015-ads1115
}}

{{ttuto
|label=am2315
|descr=Capteur de température et humidité relative (0 à 100%) pour relevés en extérieur. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/am2315
}}

{{ttuto
|label=bme280-bmp280
|descr=Le BMP280 est un capteur de pression et température très populaire. Le BME280 est un capteur de pression, température et HUMIDITÉ relative. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/bme280-bmp280
}}

{{ttuto
|label=bmp180
|descr=Le BMP180 est un senseur de pression et température aujourd'hui remplacé par le BMP280. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/bmp180
}}

{{ttuto
|label=cardkb
|descr=CardKB - Mini-clavier QWERTY en I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/cardkb
}}

{{ttuto
|label=ccs811
|descr=CCS811 - Capteur qualité d'air - COV et eCO2 avec MicroPython. ADAFRUIT,OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ccs811
}}

{{ttuto
|label=COLORS
|descr=Bibliothèque de gestion de couleurs (et outils).
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/COLORS
}}

{{ttuto
|label=dht11
|descr=Le DHT11 est un senseur d'humidité (20 à 80%) et température très bon marché. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/dht11
}}

{{ttuto
|label=dotstar
|descr=Les DotStar / APA102 sont des LEDs digitales intelligentes pouvant être contrôlées indépendamment les unes des autres. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/dotstar
}}

{{ttuto
|label=drv8830
|descr=Le Mini I2C motor driver permet de contrôler 2 moteurs 5V par l'intermédiaire d'une interface I2C. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/drv8830
}}

{{ttuto
|label=ds18b20
|descr=Le DS18B20 est un senseur de température digital très populaire. Il utilise le bus 1-Wire permettant de brancher plusieurs senseurs 1-Wire sur un même bus. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ds18b20
}}

{{ttuto
|label=eeprom
|descr=Utiliser des EEPROM I2C pour stocker des informations. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/eeprom
}}

{{ttuto
|label=gps-ultimate
|descr=Pouvoir obtenir ou suivre votre position actuelle à l'aide d'un module GPS. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/gps-ultimate
}}

{{ttuto
|label=hat-joy-bonnet
|descr=Utiliser le HAT Joy Bonnet avec MicroPython NADHAT PYB405. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-joy-bonnet
}}

{{ttuto
|label=hat-piface
|descr=Utiliser le PiFace Digital avec MicroPython Pyboard, PYBStick.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-piface
}}

{{ttuto
|label=hat-sense
|descr=Utiliser le Sense HAT avec MicroPython Pyboard, PYBStick, PYB405.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=FBGFX
|descr=Bibliothèque graphique pour FrameBuffer.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/FBGFX
}}

{{ttuto
|label=grove-5-way-switch
|descr=Joystick 5 directions (et carte 6 DIP) via I2C - sous MicroPython. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/grove-5-way-switch
}}

{{ttuto
|label=ht0740-switch
|descr=HT0740 - 40V / 10A MosFet controlable via I2C - sous MicroPython. PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ht0740-switch
}}

{{ttuto
|label=ili934x
|descr=ILI934x - contrôleur afficheur TFT couleur 16 bits - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ili934x
}}

{{ttuto
|label=is31fl
|descr=IS31FL3731 - contrôleur CharliePlexing via I2C - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/is31fl
}}

{{ttuto
|label=lcdi2c
|descr=Afficheur à cristaux liquides (LCD) commandé via le bus I2C. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdi2c
}}

{{ttuto
|label=lcdmtrx
|descr=Afficheur LCD 2 lignes, 16 caractères, Arrière plan RGB. Interface USB + Série. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdmtrx
}}

{{ttuto
|label=lcdspi-lcd12864
|descr=Afficheur LCD graphique 128 x 64 pixels. Interface SPI (3 fils). DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdspi-lcd12864
}}

{{ttuto
|label=lsm303
|descr=Utiliser une boussole et accéléromètre LSM303D avec MicroPython. POLOLU.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lsm303
}}

{{ttuto
|label=m5stack-u087
|descr=Module Voltmetre I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u087
}}

{{ttuto
|label=m5stack-u097
|descr=Module 4 relais I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u097
}}

{{ttuto
|label=m5stack-u105
|descr=I2C DDS unit (Direct Digital Synthesis, AD9833, ), Grove. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u105
}}

{{ttuto
|label=max6675
|descr=MAX6675 Amplificateur Thermocouple Type-K - MOD-TC - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/max6675
}}

{{ttuto
|label=max31855
|descr=ThermoCouple Type-K + amplificateur MAX31855 - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/max31855
}}

{{ttuto
|label=mcp230xx
|descr=Le MCP23017 (et MCP2308) sont des GPIO Expander sur bus I2C ajoutant des entrées/sorties sur un microcontrôleur. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp230xx
}}

{{ttuto
|label=mcp23Sxx
|descr=Le MCP23S17 est un GPIO Expander sur bus SPI ajoutant des entrées/sorties sur un microcontrôleur. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp23Sxx
}}

{{ttuto
|label=mcp9808
|descr=Le MCP9808 (bus I2C) permettant de faire un relevé de température avec une précision de 0.25°C. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp9808
}}

{{ttuto
|label=mcp4725
|descr=Le MCP4725 (bus I2C) est un DAC -ou- une vraie sortie Analogique 12 bits (0 à 65535). ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp4725
}}

{{ttuto
|label=modenv
|descr=Capteur environnementale tout-en-un - BME280 + CCS811 - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modenv
}}

{{ttuto
|label=modio
|descr=MOD-IO est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de relais, d'entrée OptoCoupleur (24V) et entrées analogiques (0-3.3V). Cette carte est compatible avec le standard industriel en 24V. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modio
}}

{{ttuto
|label=modio2
|descr=MOD-IO est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de relais, de GPIO aux fonctions multiples (Input, Output, Analog, PWM; 0-3.3V). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modio2
}}

{{ttuto
|label=modirdaplus
|descr=MOD-IRDA+ est un module émetteur/récepteur Infrarouge I2C supportant les protocols RC5 (Philips) et SIRCS (Sony). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modirdaplus
}}

{{ttuto
|label=modirtemp
|descr=Mesure de température -70°C à 380°C Infrarouge sans contact (MXL90164). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modirtemp
}}

{{ttuto
|label=modlcd1x9
|descr=MOD-LCD1x9 est un afficheur 9 caractères alphanumérique I2C avec port de connexion UEXT. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modlcd1x9
}}

{{ttuto
|label=modlcd3310
|descr=MOD-LCD3310 est l'afficheur LCD du Nokia 3310 offrant 84 x 48 pixels et un port de connexion UEXT. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modlcd3310
}}

{{ttuto
|label=modled8x8
|descr=Un afficheur 8x8 LEDs RGB chaînable. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modled8x8
}}

{{ttuto
|label=modltr501
|descr=LTR-501ALS permet de faire une lecture de luminosité de 0.01 à 64.000 Lux (64K lux) et détection de proximité (jusqu'à 10cm). Le MOD-LTR-501ALS dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modltr501
}}

{{ttuto
|label=modmag
|descr=Le MAG3110 est un magénomètre digital 3 axes de NXP accessible via I2C. Le MOD-MAG dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modmag
}}

{{ttuto
|label=modoled128x64
|descr=Un afficheur OLED 128x64 / 128x32 / 64x48 avec contrôleur SSD1306 (I2C) et connecteur UEXT, Feather, Qwiic. OLIMEX,ADAFRUIT,SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modoled128x64
}}

{{ttuto
|label=modrfid
|descr=MOD-RFID1356 MIFARE : lecteur NFC / RFID Mifare via port série/usb-série/usb-hid. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrfid
}}

{{ttuto
|label=modrgb
|descr=MOD-RGB est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de MosFet de puissance pour commander des rubans LED RGB analogiques via I2C (ou DMX). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrgb
}}

{{ttuto
|label=modrs485iso
|descr=MOD-RS485-ISO est un adaptateur RS485 Full-Duplex/Half-Duplex avec isolation. La transmission de données se fait via UART (MODE_PASS) ou I2C (MODE_BRIDE). Expose une interface UEXT pour connexion rapide. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrs485iso
}}

{{ttuto
|label=modtc-mk2
|descr=MAX6MOD-TC-MK2 : Amplificateur Thermocouple Type-K (MAX31855) via I2C - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modtc-mk2
}}

{{ttuto
|label=modwii
|descr=La Wii NUNCHUCK est une manette de jeu super confortable et s'utilise sur le bus I2C. Ce controleur dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modwii
}}

{{ttuto
|label=mpr121
|descr=Créer des pastilles/entrées capacitives (tactiles) avec le MPR121. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mpr121
}}

{{ttuto
|label=mpx5700a
|descr=Utiliser un capteur de pression ANALOGIQUE MPX5700AP. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mpx5700a
}}

{{ttuto
|label=NCD
|descr=Connecter facilement une __mini carte I2C__ de NCD (National Control Device) sur une carte MicroPython grâce au connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Logique 5V. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/NCD
}}

{{ttuto
|label=ncd-mpl115a2
|descr=Le MPL115A2 est un capteur de pression et température I2C. La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD,ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-mpl115a2
}}

{{ttuto
|label=ncd-si7005
|descr=Le SI7005 est un capteur d'humidité relative et température I2C. La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-si7005
}}

{{ttuto
|label=ncd-water-detect
|descr=Détecteur de présence d'eau + Buzzer + 2 GPIOs (basé sur un PCA9536). La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-water-detect
}}

{{ttuto
|label=ncd-fet-solenoid
|descr=Contrôleur de sortie FET + GPIO (basé sur un MCP23008) pour charge résistive / inductive 12V (valve). La carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-fet-solenoid
}}

{{ttuto
|label=ncd-pecmac
|descr=Capteur de courant alternatif sur bus I2C (ou interface IoT). La carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-pecmac
}}

{{ttuto
|label=ncd-oled
|descr=Un afficheur OLED 128x64 avec contrôleur SSD1306 (I2C) et connecteur NCD. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-oled
}}

{{ttuto
|label=neopixel
|descr=Les NéoPixels sont des LEDs digitales intelligentes pouvant être contrôlées indépendamment les unes des autres. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/neopixel
}}

{{ttuto
|label=oled-ssd1306
|descr=Le SSD1306 est un contrôleur d'écran OLED. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/oled-ssd1306
}}

{{ttuto
|label=opt3101-fov
|descr=Capteur de distance Time-Of-Flight FoV 3 canaux OPT3101 (POL3412). POLOLU.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/opt3101-fov
}}

{{ttuto
|label=pca9536
|descr=Contrôleur GPIO 4 bits I2C. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pca9536
}}

{{ttuto
|label=pca9685
|descr=Controleur PWM-Driver à base de PCA9685 de NXP, 16 canaux, résolution 12 bits, pour commande des LEDs ou Servo. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pca9685
}}

{{ttuto
|label=pcf8523
|descr=Une Horloge temps réel RTC + alarme avec MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pcf8523
}}

{{ttuto
|label=pm25
|descr=Utiliser un capteur de particule fine PM2.5 (PMS5003) avec MicroPython. ADAFRUIT,PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pm25
}}

{{ttuto
|label=qwiic-joystick-i2c
|descr=Utiliser un joystick analogique I2C (Qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-joystick-i2c
}}

{{ttuto
|label=qwiic-keypad-i2c
|descr=Utiliser un clavier I2C 12 touches (Qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-keypad-i2c
}}

{{ttuto
|label=qwiic-relay-i2c
|descr=Utiliser un Relais-Simple/Quad-Relais/Quad-Relais-SSR I2C (qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-relay-i2c
}}

{{ttuto
|label=qwiic-vcnl4040-i2c
|descr=Utiliser un capteur de proximité VCNL4040 (Qwiic, I2C) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-vcnl4040-i2c
}}

{{ttuto
|label=rfm69
|descr=Utiliser module Packet Radio RFM69HCW (SPI) avec MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/rfm69
}}

{{ttuto
|label=sht3x
|descr=Exploiter un capteur d'humidité SHT3x avec MicroPython. DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/sht3x
}}

{{ttuto
|label=st7687s
|descr=Exploiter un TFT rond avec MicroPython. DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/st7687s
}}

{{ttuto
|label=stmpe610
|descr=Utiliser un capteur tactile résistif avec MicroPython.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/stmpe610
}}

{{ttuto
|label=tca9554a
|descr=Ajouter 8 entrées/sortie avec le TCA9554A.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tca9554a
}}

{{ttuto
|label=tcs34725
|descr=Capturer la couleur (rgb ou Kelvin) avec un capteur TCS34725 + LED + filtre IR. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tcs34725
}}

{{ttuto
|label=trackball
|descr=Ajouter un Trackball + LED RGBW sur votre projet MicroPython. PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/trackball
}}

{{ttuto
|label=tsl2561
|descr=Le TSL2561 est un senseur de luminosité en lumière visible ayant un réponse proche de l'oeil humain. Retourne une valeur en LUX. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tsl2561
}}

{{ttuto
|label=tsl2591
|descr=Le TSL2591 est un capteur de luminosité en lumière visible ayant un réponse proche de l'oeil humain. Retourne une valeur en LUX. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tsl2591
}}

{{ttuto
|label=umqtt
|descr=Exemples de communication MQTT avec un module ESP8266. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/umqtt
}}

{{ttuto
|label=UEXT
|descr=Connecteur UEXT en logique 3.3V est utilisé sur les cartes et capteurs d' Olimex. Il transporte les bus I2C, SPI, UART et alimentation 3.3V. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/UEXT
}}

{{ttuto-end}}

= PyBoard =
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-PyBoard.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''Micro Python''' est une carte Python 3 offrant 30 GPIO, 20 PWM, 1 RTC, des bus I2C, CAN, SPI, un accéléromètre, etc. la {{cl|56|gamme Micro Python est disponible}} chez [http://shop.mchobby.be MCHobby].
|}

== MicroPython, PyBoard et PYBStick ==

{{ttuto-begin}}

{{ttuto
|label=Micro Python & PyBoard Kaséko?!?
|descr=Venez découvrir le microcontrôleur programmable en Python. Plateforme, Boot, etc.
|img=tlogo-micropython-presentation.jpg
|link=MicroPython.présentation
}}

{{ttuto
|label=En vidéo
|descr=Quelques vidéos très intéressante.
|img=tlogo-micropython-video.jpg
|link=MicroPython.vidéo
}}

{{ttuto
|label=Tester en live
|descr=Un petit laboratoire avec une carte Micro Python connecté sur Internet pour la tester.
|img=tlogo-micropython-net.jpg
|link=MicroPython.Live
}}

{{ttuto
|label=Brochage et Schema
|descr=La carte Micro Python PyBoard, ses fonctionnalités, son brochage, ses schémas et composant Fritzing.
|img=tlogo-micropython-brochage-pyboard.jpg
|link=MicroPython.brochage.pyboard
}}

{{ttuto
|label=Généralités PyB
|descr=Boot Modes, Code d'erreur, système de fichier et réinitialisation. '''A lire avant de se lancer'''.
|img=tlogo-micropython-pyboard-Info.jpg
|link=MicroPython.pyboard.généralités
}}

{{ttuto
|label=Références
|descr=Liens, références et ressources Micro Python.
|img=tlogo-micropython-reference.jpg
|link=MicroPython.référence
}}

{{ttuto
|label=Doc officielle
|descr=L'excellente documentation officielle en anglais. Une importante source de précieuses informations.
|img=tlogo-micropython-docs.jpg
|link=MicroPython.r%C3%A9f%C3%A9rence#Documentation_Officielle
}}

{{ttuto
|label=Modèles de PyBoard.
|descr=Comparatif des différents modèles de la carte PyBoard.
|img=tlogo-micropython-modele.jpg
|link=MicroPython.Pyboard.modele
}}

{{ttuto
|label=Mise-à-jour FirmWare
|descr=Comment faire une mise-à-jour du Firmware de la Pyboard.
|img=tlogo-micropython-update.jpg
|link=MicroPython.Pyboard.mise-a-jour
}}

{{ttuto
|label=Pyboard Discovery Kit
|descr=Un kit et des tutos à thème pour découvrir la carte MicroPython PyBoard.
|img=tlogo-micropython-discovery.jpg
|link=MicroPython.Pyboard.Discovery
}}

{{ttuto
|label=upip
|descr=Télécharger une bibliothèque MicroPython en utilisant le ''Python Index Package''.
|img=tlogo-micropython-upip.jpg
|link=MicroPython-Hack-upip
}}

{{ttuto
|label=PYBStick STD Discovery
|descr=Des tutos à thème pour découvrir MicroPython et la PYBStick STD 26.
|img=tlogo-pybstick-discovery.jpg
|url=https://github.com/mchobby/pyboard-driver/tree/master/PYBStick
}}

{{ttuto
|label=PYBStick HAT-FACE
|descr=Une interface PYBStick vers Raspberry-Pi HAT.
|img=tlogo-pybstick-hat-face.jpg
|link=MicroPython.PYBStick.hat-face
}}

{{ttuto-end}}

== Hacking électronique avec MicroPython ==
ces scripts se penchent sur l'utilisation de MicroPython avec la Pyboard, la PYBStick.

{{ttuto-begin}}

{{ttuto
|label=Précautions & alimentations
|descr=Précautions d'usage avant de se lancer dans le hacking. Comment alimenter votre PyBoard.
|img=tlogo-micropython-prepare.jpg
|link=MicroPython-Hack-Prepare
}}

{{ttuto
|label=Premier script
|descr=Exécutez votre premier script et allumez une LED sur la carte.
|img=tlogo-micropython-firstscript.jpg
|link=MicroPython-Hack-first-script
}}

{{ttuto
|label=L'invite REPL
|descr=Obtenir l'invite '''en ligne de commande''' REPL et utilisez PyBoard en mode terminal.
|img=tlogo-micropython-REPL.jpg
|link=MicroPython-Hack-REPL
}}

{{ttuto
|label=LED et concepts
|descr=Allumer les LEDs de la carte PyBoard. Les concepts de base.
|img=tlogo-micropython-LED.jpg
|link=MicroPython-Hack-LED
}}

{{ttuto
|label=1 LED externe
|descr=Branchez votre première LED sur la PyBoard et contrôlez là.
|img=Tlogo-micropython-1led.png
|link=MicroPython-Hack-1LED
}}

{{ttuto
|label=8 LEDs
|descr=Contrôler plusieurs LEDs.
|img=Tlogo-micropython-8leds.png
|link=MicroPython-Hack-8LEDS
}}

{{ttuto
|label=Bouton
|descr=Bouton, '''callback''' et '''interruption'''.
|img=tlogo-micropython-button.jpg
|link=MicroPython-Hack-button
}}

{{ttuto
|label=L'accéléromètre
|descr=Utiliser l'accéléromètre de la carte.
|img=tlogo-micropython-accelerometre.jpg
|link=MicroPython-Hack-accelerometre
}}

{{ttuto
|label=Safe Mode & réinitialisation
|descr=Safe Mode et réinitialisation d'usine. Reprenez le contrôle de votre PyBoard
|img=tlogo-micropython-safemode.jpg
|link=MicroPython-Hack-safemode
}}

{{ttuto
|label=PyBoard = souris
|descr=Faire agir la PyBoard comme une souris. Réalisez vos propres interface homme-machine.
|img=tlogo-micropython-souris.jpg
|link=MicroPython-Hack-souris
}}

{{ttuto
|label=Les timers
|descr=Mesurer des durées, réaliser des synchronisations ou exécuter du code à intervalle régulier. Exploitez les 14 timers de votre PyBoard.
|img=tlogo-micropython-timer.jpg
|link=MicroPython-Hack-timers
}}

{{ttuto
|label=Assembleurs
|descr=Utiliser l'assembleur inline. Ajouter du code assembleur ARM au sein même de vos programmes.
|img=tlogo-micropython-assembleur.jpg
|link=MicroPython-Hack-assembleur
}}

{{ttuto
|label=Contrôle de puissance
|descr=Contrôler la consommation de votre PyBoard.
|img=tlogo-micropython-power.jpg
|link=MicroPython-Hack-power
}}

{{ttuto
|label=Servo-moteur
|descr=Contrôler des servo moteur en Micro Python. Quelques commandes pour positionner un axe sur un angle donné.
|img=tlogo-moteur-servo.jpg
|link=MicroPython-Hack-servo
}}

{{ttuto
|label=Luminosité d'une LED
|descr=Contrôler la luminosité d'une LED ou la faire pulser avec un signal PWM.
|img=tlogo-micropython-fading.jpg
|link=MicroPython-Hack-fading
}}

{{ttuto
|label=Déparasitage entrée
|descr=Comment déparasiter une entrée.
|img=tlogo-micropython-deparasitage.jpg
|link=MicroPython-Hack-deparasitage
}}

{{ttuto
|label=Lecture Analogique
|descr=Réaliser une lecture analogique sur le PyBoard.
|img=tlogo-micropython-analogique.png
|link=MicroPython-Hack-Analogique
}}

{{ttuto
|label=TMP36 = °C
|descr=Lire la température avec TMP36 un senseur de température analogique.
|img=tlogo-micropython-tmp36.png
|link=MicroPython-Hack-TMP36
}}

{{ttuto
|label=Photo-résistance
|descr=Utiliser une photorésistance, Ldr, Cds et une entrée analogique pour détecter la présence de la lumière.
|img=tlogo-micropython-LDR.png
|link=MicroPython-Hack-LDR
}}

{{ttuto
|label=Moteur
|descr=Utiliser un transistor pour commander un moteur.
|img=tlogo-micropython-moteur.png
|link=MicroPython-Hack-moteur
}}

{{ttuto
|label=Relais
|descr=Commander des charges plus importantes à l'aide d'un relais.
|img=tlogo-micropython-relais.png
|link=MicroPython-Hack-relais
}}

{{ttuto
|label=LED RGB
|descr=Contrôler une LED Rouge,Vert,Bleu pour créer n'importe quelle couleur
|img=tlogo-micropython-LedRGB.png
|link=MicroPython-Hack-led-RGB
}}

{{ttuto
|label=Piezo
|descr=Utiliser un piezo buzzer pour faire de la musique
|img=tlogo-micropython-Piezo.png
|link=MicroPython-Hack-piezo
}}

{{ttuto
|label=Déboguer
|descr=Quelques petits trucs pour vous aider à déboguer vos programmes.
|img=tlogo-micropython-Debugger.jpg
|link=MicroPython-Hack-Debug
}}

{{ttuto
|label=Outil dev
|descr=Quelques outils pour aider vos développement PyBoard.
|img=tlogo-micropython-Debugger.jpg
|link=MicroPython-Hack-Outil
}}

{{ttuto
|label=USB <-> UART
|descr=Envoyer les données de l'UART vers USB (et vice-versa).
|img=tlogo-micropython-USB-UART.jpg
|link=MicroPython-Hack-USB-UART
}}

{{ttuto-end}}

== Extensions Pyboard ==

{{ttuto-begin}}

{{ttuto
|label=Extension LCD
|descr=Utiliser l'extension LCD.
|img=tlogo-micropython-LCD.jpg
|link=MicroPython-LCD
}}

{{ttuto
|label=TFT 2.8"
|descr=Utiliser un TFT 2.8 avec contrôleur ILI9341 sur un PyBoard
|img=tlogo-micropython-ILI9341.jpg
|link=MicroPython-ILI9341
}}

{{ttuto
|label=Maîtriser I2C
|descr=Utiliser et maîtriser les bus I2C sous MicroPython.
|img=tlogo-micropython-I2C.jpg
|link=MicroPython-I2C
}}

{{ttuto
|label=Ultrason HC-SR04
|descr=Evaluer une distance de 2cm à 4m avec le HC-SR04. Il fonctionne comme un sonar.
|img=tlogo-HC-SR04.jpg
|link=MicroPython-HC-SR04
}}

{{ttuto
|label=Pont-H L293D
|descr=Double Pont-H pour contrôler deux moteurs (basse puissance)
|img=tlogo-micropython-l293.jpg
|link=hack-micropython-L293D
}}

{{ttuto
|label=Afficheur 4x7 I2C
|descr=Utilisation d'afficheur 4x7 segment sur le bus I2C de la PyBoard.
|img=tlogo-micropython-4x7.jpg
|link=MicroPython-4x7
}}

{{ttuto
|label=Contrôleur PWM
|descr=Utilisation du controleur PWM 16 canaux avec la PyBoard.
|img=tlogo-adf-pwm.jpg
|link=MicroPython-PWM-DRIVER
}}

{{ttuto
|label=Mosfet
|descr=Commander un MOSFET de puissance à partie d'un microcontrôleur 3.3V.
|img=tlogo-micropython-Mosfet.png
|link=MicroPython-Hack-Mosfet
}}

{{ttuto
|label=Bluetooth & REPL
|descr=Utiliser un module Bluetooth série avec PyBoard. Dupliquer REPL sur Bluetooth.
|img=tlogo-micropython-bluetooth.jpg
|link=MicroPython-bluetooth
}}

{{ttuto
|label=HAT-SENSE
|descr=Utiliser le Hat-Sense avec votre Pyboard
|img=tlogo-micropython-hat-sense.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=PYBD Butterfly
|descr=Assembler le Pyboard-D Butterfly
|img=tlogo-pybd-butterfly.jpg
|link=PYBD-Butterfly
}}



{{ttuto-end}}

== PyBoard Robotique ==

Voici quelques tutoriels pour réaliser une plateforme robotique à base de MicroPython PyBoard.

{{ttuto-begin}}

{{ttuto
|label=Robot 2 Roues
|descr=Commander un robot 2 roues maison avec MicroPython PyBoard et un L293D
|img=tlogo-micropython-Robot2Wheel.jpg
|link=hack-micropython-Robot2Wheel
}}

{{ttuto
|label=Robot Ultrason
|descr=Piloter le robot 2 roues avec un senseur Ultrason HC-SR04
|img=tlogo-micropython-Robot2Wheel-HC-SR04.jpg
|link=hack-micropython-Robot2Wheel-HC-SR04
}}

{{ttuto
|label=Motor-Skin
|descr=Contrôler facilement une plateforme robotique à deux moteurs avec le Motor-Skin pour PyBoard.
|img=tlogo-motorskin-00.jpg
|link=hack-MotorSkin
}}

{{ttuto
|label=ENG: Motor-Skin
|descr=Take the control of a 2 motors robotic plateform with the PyBoard's Motor-Skin.
|img=tlogo-motorskin-00.jpg
|link=hack-ENG-MotorSkin
|traduction=1
}}

{{ttuto
|label=Servo Robots
|descr=Apprenez à réaliser DOGGY et prendre le contrôle de Robots utilisant des servos moteurs pour se déplacer.
|img=tlogo-micropython-ServoRobot.jpg
|link=hack-micropython-ServoRobot
}}

{{ttuto
|label=Moteur DFRobot
|descr=Apprenez à contrôler les moteurs continu DFRobot avec un signal servo. Trop classe!
|img=tlogo-micropython-dfrobot-motor.jpg
|link=hack-micropython-dfrobot-motor
}}

{{ttuto-end}}

= Autres =
== ESP8266 en MicroPython ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-ESP8266.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur ESP8266'''. Reflasher un {{pl|846|Feather ESP8266}}, un {{deadpl|1221|Wemos D1 Mini}}, {{pl|668|ESP8266-EVB}} ou NodeMCU pour qu'il supporte MicroPython afin de réaliser des senseurs connectés à prix imbattable! Un minimum de savoir faire est cependant requis.
|}

Cette section est dévolue à la plateforme {{pl|846|Feather ESP8266 Huzza}}, {{deadpl|1221|Wemos ESP8266}}, NodeMCU reflashé pour MicroPython et extension comme {{cl|87|FeatherWing}}, {{cl|123|Wemos Extension}} (extension).

Cette section est assortie du [https://github.com/mchobby/esp8266-upy GitHub ESP8266-upy contenant des sources et exemples].

=== Généralités ===
{{ttuto-begin}}

{{ttuto
|label=Feather ESP8266
|descr=Découvrir le Feather ESP8266, son Brochage, Alimentation, Schéma, FAQ.
|img=tlogo-feather-esp8266.jpg
|link=FEATHER-ESP8266
}}

{{ttuto
|label=ESP8266-EVB
|descr=Découvrir l'ESP8266-EVB (evaluation board) et ESP8266-DEV (module ESP), son Brochage, Alimentation, Port UEXT, Schéma, FAQ.
|img=tlogo-esp8266-dev.jpg
|link=ESP8266-DEV
}}

{{ttuto
|label=ESP32-EVB
|descr=Commander les éléments de la carte '''ESP32'''-DEV d'Olimex.
|img=tlogo-esp32-evb.png
|link=MicroPython-esp32-evb
}}

{{ttuto
|label=Charger MicroPython
|descr=Apprenez comment charger le Firmware MicroPython sur une carte Pyboard, ESP32/ESP8266 (Feather, Wemos, NodeMcu), etc.
|img=tlogo-feather-load-upy.jpg
|link=FEATHER-CHARGER-MICROPYTHON
}}

{{ttuto
|label=Téléverser & Exécuter
|descr=Téléverser des fichiers et exécuter du code. Un flux simple de développement.
|img=tlogo-feather-load-file.jpg
|link=FEATHER-CHARGER-FICHIER-MICROPYTHON
}}

{{ttuto
|label=ESP8266 WebRepl
|descr=Accéder à la console Python via la connexion WiFi d'un ESP8266.
|img=tlogo-feather-WebRepl.jpg
|link=FEATHER-WEBREPL
}}

{{ttuto
|label=Charger un module
|descr=Charger des modules Python pour ajouter de nouvelle fonctionnalités à votre carte.
|img=tlogo-feather-charger-module.jpg
|link=FEATHER-CHARGER-MODULE
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto
|label=upip
|descr=Télécharger une bibliothèque MicroPython en utilisant le ''Python Index Package''.
|img=tlogo-micropython-upip.jpg
|link=MicroPython-Hack-upip
}}

{{ttuto-end}}

=== Hacking électronique ===
{{ttuto-begin}}

{{ttuto
|label=Entrée Analogique
|descr=Utilisation de l'entrée analogique du Feather ESP8266 sous MicroPython.
|img=tlogo-micropython-analogique.png
|link=FEATHER-MICROPYTHON-ADC
}}

{{ttuto
|label=AM2315 - Humidité
|descr=Mesure de '''température''' et '''humidité''' {{underline|en extérieur}} avec AM2315
|img=tlogo-feather-upy-am2315.jpg
|link=FEATHER-MICROPYTHON-AM2315
}}

{{ttuto
|label=DHT11 - Humidité
|descr=Mesure d' '''humidité''' et '''température''' avec le très économique DHT11.
|img=tlogo-feather-upy-dht11.jpg
|link=FEATHER-MICROPYTHON-DHT11
}}

{{ttuto
|label=TSL2561 - Luminosité
|descr=Mesure de la luminosité en Lux.
|img=tlogo-feather-upy-TSL2561.jpg
|link=FEATHER-MICROPYTHON-TSL2561
}}

{{ttuto
|label=BMP180 - pression
|descr=Mesurer la pression atmosphérique et normalisez là.
|img=tlogo-feather-upy-BMP180.jpg
|link=FEATHER-MICROPYTHON-BMP180
}}

{{ttuto
|label=BMP280 / BME280
|descr=Mesurer la pression atmosphérique, température avec BMP280 + humidité avec BME280.
|img=tlogo-feather-upy-BME280.jpg
|link=FEATHER-MICROPYTHON-BME280
}}

{{ttuto
|label=ADS1x15
|descr=Mesurer précisément une tension analogique avec un ADS1115 ou ADS1015.
|img=tlogo-feather-upy-ADS1115.jpg
|link=FEATHER-MICROPYTHON-ADS1115
}}

{{ttuto
|label=NeoPixel
|descr=Utiliser des NeoPixel (WS2812, SK6812) sur ESP avec MicroPython. Comment passer de 3.3V à 5V.
|img=tlogo-feather-upy-neopixel.jpg
|link=FEATHER-MICROPYTHON-NEOPIXEL
}}

{{ttuto
|label=GPIO Expander
|descr=Utiliser le MCP23017 pour ajouter des entrées/sorties sur ESP8266.
|img=tlogo-feather-upy-MCP23017.png
|link=FEATHER-MICROPYTHON-MCP23017
}}

{{ttuto
|label=OLED
|descr=Utiliser un écran OLED en MicroPython (ESP8266).
|img=tlogo-feather-upy-oled.jpg
|link=FEATHER-MICROPYTHON-OLED
}}

{{ttuto
|label=MOD-OLED [UEXT]
|descr=Un écran OLED 128x64 (I2C) utilisé sous MicroPython (via port UEXT).
|img=tlogo-mod-oled.png
|link=MICROPYTHON-MOD-OLED
}}

{{ttuto
|label=MOD-IO [UEXT]
|descr=Utiliser le module I2C '''MOD-IO''' sous MicroPython (via port UEXT).
|img=tlogo-mod-io.png
|link=MICROPYTHON-MOD-IO
}}

{{ttuto
|label=MOD-IO2 [UEXT]
|descr=Utiliser le module I2C '''MOD-IO2''' sous MicroPython (via port UEXT).
|img=tlogo-mod-io2.jpg
|link=MICROPYTHON-MOD-IO2
}}

{{ttuto
|label=MOD-RGB [UEXT]
|descr=Contrôler des rubans LEDs RGB / RVB avec le module I2C '''MOD-RGB''' sous MicroPython (via port UEXT).
|img=tlogo-mod-rgb.png
|link=MICROPYTHON-MOD-RGB
}}

{{ttuto
|label=MOD-LCD1x9 [UEXT]
|descr=Contrôler l'afficheur Alphanumérique à cristaux liquide avec le module I2C '''MOD-LCD1x9''' sous MicroPython (via port UEXT).
|img=tlogo-mod-lcd1x9.png
|link=MICROPYTHON-MOD-LCD1x9
}}

{{ttuto
|label=MOD-MAG3110 [UEXT]
|descr=Un magnétomètre 3 axes '''MAG3110''' de NXP avec le module I2C '''MOD-MAG3110''' sous MicroPython (via port UEXT).
|img=tlogo-mod-mag3110.png
|link=MICROPYTHON-MOD-MAG3110
}}

{{ttuto
|label=MOD-LTR501ALS [UEXT]
|descr=Senseur de luminosité et de proximité '''LTR-501ALS'''. Exploiter le module I2C sous MicroPython (via port UEXT).
|img=tlogo-mod-ltr501als.png
|link=MICROPYTHON-MOD-LTR501ALS
}}

{{ttuto
|label=MOD-Wii-Chuck [UEXT]
|descr=Contrôleur de jeu I2C Wii Nunchuck. Exploiter le sous MicroPython (via port UEXT).
|img=tlogo-mod-wii-nunchuck.png
|url=https://github.com/mchobby/esp8266-upy/tree/master/modwii
}}

{{ttuto
|label=DFR-Anemometer
|descr=Utiliser un anémomètre (SEN0170) à sortie analogique avec un ESP32 sous MicroPython.
|img=tlogo-anemometer.png
|link=MICROPYTHON-ANEMOMETER
}}

{{ttuto
|label=DFR-Girouette
|descr=Utiliser une Girouette un anémomètre RS485 (SEN0482) sous MicroPython avec l'aide d'un module MOD-RS485-ISO.
|img=tlogo-grouette.png
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrs485iso
}}

{{ttuto-end}}

== SAMD21 en MicroPython ==

{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-SAMD21.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur SAMD21'''. Reflasher un {{sl|M0|Feather M0}} ou {{sl|zero|Arduino Zero}} pour qu'il supporte MicroPython! Un minimum de savoir faire est cependant requis.
|}

Cette section est dévolue aux plateforme SAMD21 comme le {{sl|M0|Feather M0}} ou {{sl|zero|Arduino Zero}} reflashé pour MicroPython.

{{ttuto-begin}}

{{ttuto
|label=Compiler et charger MicroPython
|descr=Comment compiler MicroPython et le charger sur une carte SAMD21.
|img=tlogo-samd21-charger-micropython.jpg
|link=SAMD21-CHARGER-MICROPYTHON
|traduction=1
}}

{{ttuto
|label=Feather M0 Express
|descr=Carte Feather conçue pour Arduino IDE et CircuitPython (MicroPython)
|img=tlogo-feather-m0-express.jpg
|link=FEATHER-M0-EXPRESS
}}

{{ttuto-end}}

== WiPy ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-WiPy.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''WiPy''' est une plateforme de développement "Internet des Objets" qui fonctionne sous Python. WiPy à moins de GPIO, est moins rapide que la PyBoard MAIS inclus le support WiFi. la {{cl|68|gamme WiPy disponible}} chez [http://shop.mchobby.be MCHobby].
|}

Cette section est dévolue à la plateforme {{pl|737|MicroPython WiPy}}.

=== Découvrir WiPy ===
{{ttuto-begin}}

{{ttuto
|label=Généralités WiPy
|descr=Informations générales '''mais importantes''' à propos de WiPy.
|img=tlogo-micropython-pyboard-Info.jpg
|link=hack-wipy-generalite
}}

{{ttuto
|label=WiPy intro
|descr=Introduction à WiPy, en prendre soin, la carte d'extension et les tensions d'alimentation
|img=tlogo-wipy-intro.jpg
|link=hack-wipy-introduction
}}

{{ttuto
|label=Brochage WiPy
|descr=Le brochage du WiPy et les informations utiles sur les broches.
|img=tlogo-wipy-pinout.jpg
|link=hack-wipy-pinout
}}

{{ttuto
|label=WiPy REPL
|descr=Votre WiPy en ligne de commande avec le REPL. Envoyez des ordres à votre WiPy depuis votre réseau WiFi.
|img=Tlogo-micropython-REPL.jpg
|link=hack-wipy-repl
}}

{{ttuto
|label=WiPy et Blynk
|descr=Utilisez votre WiPy depuis votre smartphone à l'aide de Blynk
|img=tlogo-wipy-blynk.jpg
|link=hack-wipy-blynk
}}

{{ttuto
|label=Config WiFi/WLAN
|descr=Configuration de la connexion WiFi/WLAN de votre WiPy étape par étape.
|img=tlogo-wipy-intro.jpg
|link=hack-wipy-wlan
}}

{{ttuto
|label=Boot/Reset
|descr=Réinitialisation (Reset) et mode de démarrage (boot mode) de votre WiPy. Ne restez jamais bloqué avec votre WiPy.
|img=Tlogo-micropython-safemode.jpg
|link=hack-wipy-boot-mode
}}

{{ttuto
|label=Mise-à-jour
|descr=Comment réaliser la mise-à-jour du firmware.
|img=tlogo-micropython-update.jpg
|link=hack-wipy-upgrade-firmware
}}

{{ttuto
|label=Références
|descr=Liens, références et ressources concernant WiPy, LoPy.
|img=tlogo-micropython-reference.jpg
|link=hack-wipy-reference
}}

{{ttuto-end}}

=== Hacking electronic avec WiPy ===

{{ttuto-begin}}

{{ttuto
|label=Controler HeartBeat
|descr=Prenez le contrôle de votre première LED, la LED HeartBeat présent sur la carte.
|img=tlogo-hack-wipy-heatbeat.jpg
|link=hack-wipy-heartbeat
}}

{{ttuto
|label=LED Externe
|descr=Brancher et contrôler une LED. Apprenez ce que signifie ''Current Sink'' et et ''Current Source''
|img=Tlogo-micropython-1led.png
|link=hack-wipy-led
}}

{{ttuto
|label=Bouton
|descr=Utiliser une entrée pour lire l'état d'un bouton. Apprenez ce que signifie ''Résistance Pull Up'' et utiliser les '''interruptions''' et fonction '''callback'''.
|img=Tlogo-wipy-button.jpg
|link=hack-wipy-button
}}

{{ttuto
|label=Relais
|descr=Commandez un Relais avec votre WiPy.
|img=Tlogo-wipy-relais.png
|link=hack-wipy-Relais
|traduction=1
}}

{{ttuto
|label=Timer
|descr=Utiliser un Timer pour appeler régulièrement du code sur votre WiPy.
|img=Tlogo-wipy-timer.png
|link=hack-wipy-Timer
|traduction=1
}}
{{ttuto-end}}

== LoPy & WiPy 2 ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-Lopy.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''LoPy''' est une plateforme de développement "Internet des Objets" qui fonctionne sous Python. LoPy supporte 3 types de réseau sans fil: LoRa, WiFi et Bluetooth. la {{cl|68|gamme WiPy/Lopy est disponible}} chez [http://shop.mchobby.be MCHobby].
|}

Cette section est dévolue à la plateforme {{pl|737|MicroPython LoPy}}, {{pl|1039|MicroPython WiPy 2}} et la {{pl|1011|carte d'extension WiPy/LoPy}}. Les plateformes WiPy 2 et Lopy sont toutes deux basées sur un ESP_32, ce qui fait que cette section convient pour les deux plateformes.

{{ambox|text=19/02/2017: Le FirmWare du Lopy/Wipy est activement développé, des nouvelles et/ou firmwares sont disponibles toutes les semaines.

Tenez vous au courant en suivant les [https://forum.pycom.io/category/1/announcements-news annonces du forum Pycom.io] pour être tenu au courant.}}

=== Découvrir LoPy / WiPy 2 ===

LoPy et WiPy 2 sont tous les deux basés sur une plateforme ESP_32, de ce fait, les guides ci-dessous conviennent pour les deux plateformes.

Vous pouvez également vous inspirer des montages et exemples du WiPy 1 pour faire du prototypage électronique.

{{ttuto-begin}}

{{ttuto
|label=Démarrer
|descr=Démarrer rapidement avec LoPy ou WiPy 2 (plateforme ESP_32 de PyCom)
|img=tlogo-lopy-intro.jpg
|link=hack-pycom-esp_32
}}

{{ttuto
|label=Brochage WiPy2
|descr=Brochage du WiPy 2
|img=tlogo-wipy2-pinout.jpg
|link=hack-pycom-wipy2-pinout
}}

{{ttuto
|label=Brochage LoPy
|descr=Brochage du LoPy
|img=tlogo-lopy-pinout.jpg
|link=hack-pycom-lopy-pinout
}}

{{ttuto
|label=FTP/Telnet
|descr=Se connecter en FTP ou telnet sur le Lopy
|img=tlogo-lopy-ftp.jpg
|link=hack-pycom-lopy-ftp
}}

{{ttuto
|label=Pymakr IDE
|descr=Un éditeur qui se connecte en Telnet ou port série. Utiliser la LED du RGB du WiPy.
|img=tlogo-lopy-ide.jpg
|link=Hack-pycom-lopy-Pymakr
}}

{{ttuto
|label=Boîte à outils
|descr=Les modules, REPL, FTP, '''Boot mode''', Interruption... tout ce qu'il faut savoir
|img=tlogo-lopy-toolbix.jpg
|link=Hack-pycom-lopy-toolbox
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. WiPy et ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto-end}}

MicroPython-Accueil

2026-01-06T23:22:51Z

Admin : /* Hacking électronique */

{{device-links}}

{| border="0"
|-
| align="left" width="360px" | [[Fichier:powered-by-micropython.png|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''Micro Python''' est une version optimisée et allégée de Python 3 pour système embarqué. '''PyBoard, Pico, ESP32, etc sont des cartes microcontrôleurs supportant MicroPython'''. Ces cartes électroniques exécutnt MicroPython en ''[http://en.wikipedia.org/wiki/Bare_machine bare metal]'' et vous offre un système d'exploitation Python de bas niveau permettant de contrôler toute sorte de projets électroniques. Trop fort... I Love It!!! La {{cl|56|gamme Micro Python est maintenant disponible}} chez [http://shop.mchobby.be MCHobby].
|}

= Pico / Pico2 (Raspberry-Pi) =
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-pico.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur Raspberry-Pi Pico''' et '''Pico Wireless'''. Reflasher un {{pl|2025|Pico}}, un {{pl|2036|Pico Header}} pour qu'il supporte MicroPython afin de réaliser des objets intelligents à prix imbattable!
|}

Cette section est dévolue à la plateforme {{pl|2025|Pico}} reflashé avec MicroPython.

Cette section est assortie:
* du [https://github.com/mchobby/esp8266-upy GitHub ESP8266-upy contenant des sources et exemples pour cartes MicroPython].
* du [https://github.com/mchobby/pyboard-driver/tree/master/Pico GitHub Pyboard-Driver contenant des ressource pour la carte Pico]

== Généralités ==
{{ttuto-begin}}

{{ttuto
|label=Python_SDK_FR
|descr=Un PDF pour découvrir le Raspberry-Pi Pico, son Brochage, Alimentation, Schéma, FAQ.
|img=tlogo-pico-python-sdk.jpg
|url=http://df.mchobby.be/RASPBERRY-PICO/Python_SDK_FR.pdf
}}

{{ttuto
|label=Brochage
|descr=Le brochage de référence du Pico sous MicroPython.
|img=tlogo-pico-pinout.jpg
|url=https://raw.githubusercontent.com/mchobby/pyboard-driver/master/Pico/docs/_static/Pico.png
}}

{{ttuto
|label=Thonny IDE
|descr=Utiliser Thonny IDE avec Pico et carte RP2040
|img=tlogo-thonny.jpg
|url=https://arduino103.blogspot.com/2022/01/micromod-rp2040-pico-utiliser-thonny.html
}}

{{ttuto
|label=Pico et Thonny
|descr=Utiliser l'IDE Thonny (recommandé par la fondation) avec votre Pico. Un bel article de Framboise314.
|img=tlogo-pico-thonny.jpg
|url=https://www.framboise314.fr/utiliser-le-raspberry-pi-pico-avec-thonny/
}}

{{ttuto
|label=Ressources
|descr=Diverses ressources pour le Pico sous MicroPython. Y Compris un Pico annoté
|img=tlogo-Github.jpg
|url=https://github.com/mchobby/pyboard-driver/tree/master/Pico
}}

{{ttuto
|label=Reset btn
|descr=Ajouter un bouton Reset à votre Pico.
|img=tlogo-pico-reset.jpg
|link=PICO-RESET-BUTTON
}}

{{ttuto
|label=Pico-W Intro
|descr=Découvrir le Raspberry-Pi Pico WIRELESS - WiFi et Bluetooth sur le Pico
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/06/raspberry-pi-pico-wireless-wifi-et.html
}}

{{ttuto
|label=Pico-W et MicroPython
|descr=Pico Wireless : installer le firmware MicroPython
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/06/pico-wireless-installer-le-firmware.html
}}

{{ttuto
|label=Pico-W et WiFi
|descr=Pico Wireless : MicroPython et le WiFi
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/07/pico-wireless-micropython-et-le-wifi.html
}}

{{ttuto
|label=Pico-W WebREPL
|descr=Pico Wireless: Comment utiliser WEBRepl
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/08/pico-wireless-comment-utiliser-webrepl.html
}}

{{ttuto
|label=Pico LED utilisateur
|descr=Pico Wireless: MicroPython et la LED utilisateur
|img=tlogo-pico-wireless.jpg
|url=https://arduino103.blogspot.com/2022/07/pico-wireless-micropython-et-la-led.html
}}

{{ttuto
|label=TrinKey QT2040
|descr=Utiliser le TrinKey QT2040 (RP2040) avec MicroPython
|img=tlogo-pico-trinkey-QT2040.png
|link=TrinKey-QT2040
}}

{{ttuto
|label=Adafruit SeeSaw
|descr=Utiliser le SeeSaw (multi-interface via I2) avec MicroPython (et Pico)
|img=tlogo-seesaw.png
|url=https://github.com/mchobby/micropython-seesaw
}}

{{ttuto-end}}

== Hacking électronique ==
{{ttuto-begin}}

{{ttuto
|label=Pico CanSat
|descr=Control a CANSAT with MicroPython and Raspberry-Pi Pico
|img=tlogo-cansat-pico.jpg
|link=ENG-CANSAT-PICO-BELGIUM
}}

{{ttuto
|label=Pico-2-Explorer
|descr=Découvrir MicroPython avec le Raspberry-Pi Pico 2. Entrées/sorties, analogique, PWM, etc
|img=tlogo-pico-2-explorer.jpg
|link=Pico-2-Explorer-FR
}}

{{ttuto
|label=Shield Moteur
|descr=Utiliser un MotorShield ou Motor FeatherWing avec le Pico.
|img=tlogo-pico-motorshield.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/adfmotors
}}

{{ttuto
|label=Afficheur TFT ILI934x
|descr=Utiliser un TFT 2.4" FeatherWing (ILI9341) avec le Pico
|img=tlogo-pico-ili934x.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ili934x
}}

{{ttuto
|label=HAT-SENSE
|descr=Utiliser le Hat-Sense avec votre Pico
|img=tlogo-micropython-hat-sense.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=HAT-PiFace
|descr=Utiliser le PiFace Digital avec votre Pico
|img=tlogo-micropython-hat-piface.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=Pulse-In
|descr=Mesurer la longueur d'une impulsion Servo sur un récepteur RC
|img=tlogo-pico-pulse-in.jpg
|link=PICO-PULSE-IN-MICROPYTHON
}}

{{ttuto
|label=Pico<->Minitel
|descr=Brancher un Pico sur un Minitel, recevoir et envoyer des caractères
|img=tlogo-Minitel.jpg
|url=https://arduino103.blogspot.com/2022/04/minitel-branche-sur-mon-raspberry-pi.html
}}

{{ttuto
|label=Pico, Zumo Robot et MicroPython
|descr='''Ebook''' pour apprendre a utiliser votre Zumo Robot pour Arduino avec MicroPython.
|img=tlogo-Pico-Zumo-Robot-et-MicroPython.jpg
|link=Pico-Zumo-Robot-et-MicroPython
}}

{{ttuto
|label=Zumo Robot en Python
|descr='''GitHub''' Robot Zumo sous MicroPython avec le Pico ou la Pyboard
|img=tlogo-zumo-pico.jpg
|url=https://github.com/mchobby/micropython-zumo-robot
}}

{{ttuto
|label=MyDin
|descr=DIN Automation with MicroPython
|img=tlogo-mydin.jpg
|link=MyDin
}}

{{ttuto
|label=UniPi en Python
|descr=Créer un automate programmable avec UniPi et MicroPython
|img=tlogo-unipi-pico.jpg
|bad_url=https://github.com/mchobby/micropython-zumo-robot
|traduction=1
}}

{{ttuto
|label=Pico Buggy
|descr=Contôler le Buggy Kitronik avec MicroPython (traduction MCHobby)
|img=tlogo-pico-buggy.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Autonomous-Robotics-Platform-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Smart Air Quality
|descr=Mesurer la qualité d'air avec un Pico (traduction MCHobby)
|img=tlogo-pico-air-quality.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Smart-Air-Quality-Board-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Pico Contrôle Robotique
|descr=Carte de contrôle robotique pour Pico (traduction MCHobby)
|img=tlogo-pico-motor.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Robotics-Board-MicroPython/blob/main/README_FR.md
}}

{{ttuto
|label=Pico Contrôle Moteur
|descr=Carte de contrôle moteur pour Pico (traduction MCHobby)
|img=tlogo-pico-motor2.jpg
|url=https://github.com/KitronikLtd/Kitronik-Pico-Motor-Driver-Board-MicroPython
}}

{{ttuto
|label=Wifi-4-Relay
|descr=Commander un module 4 relais avec via Page WEB ou API REST.
|img=tlogo-wifi-4-relay.jpg
|url=https://github.com/mchobby/micropython-wifi-4-relais
}}

{{ttuto
|label=ArdBase
|descr=Découvrir le hacking électronique pour avec Kit ArdBase et MicroPython
|img=tlogo-pico-ardbase-micropython.png
|url=https://github.com/mchobby/KIT-SOUDURE-ARDBASE
}}

{{ttuto
|label=Tamagotchi
|descr=Créer un Tamagotchi sous MicroPython avec Raspberry-Pi Pico
|img=tlogo-pico-tamagotchi.jpg
|link=Pico-Tamagotchi-Intro
}}

{{ttuto
|label=Adafruit NeoTrellis
|descr=Utiliser un NeoTrellis d'Adafruit avec Raspberry-Pi Pico/Pico2.
|img=tlogo-micropython-neotrellis.png
|link=micropython-neotrellis-pico
}}

{{ttuto
|label=RoboEyes
|descr=Donnez de la personnalité à vos robot avec l'implémentation de RoboEyes pour MicroPython.
|img=tlogo-micropython-roboeyes.png
|url=https://github.com/mchobby/micropython-roboeyes
}}

{{ttuto
|label=Capteur Alarme
|descr=Comment utiliser des capteurs d'alarme PIR avec un microcontroleur
|img=tlogo-PIR-alarm.png
|link=micropython-PIR-alarm
|traduction=1
}}

{{ttuto-end}}

= EDI pour MicroPython =
Les outils et editeurs pouvant être utilisés avec MicroPython.

{{ttuto-begin}}
{{ttuto
|label=Thonny IDE
|descr=Utiliser Thonny IDE avec Pico et carte RP2040
|img=tlogo-thonny.jpg
|url=https://arduino103.blogspot.com/2022/01/micromod-rp2040-pico-utiliser-thonny.html
}}

{{ttuto
|label=Pico et Thonny
|descr=Utiliser l'IDE Thonny (recommandé par la fondation) avec votre Pico. Un bel article de Framboise314.
|img=tlogo-pico-thonny.jpg
|url=https://www.framboise314.fr/utiliser-le-raspberry-pi-pico-avec-thonny/
}}

{{ttuto
|label=MPRemote
|descr='''MicroPython Remote Control''' outil en ligne de commande qu'il ne faut surtout pas râter.
|img=tlogo-MPRemote.png
|url=https://github.com/mchobby/micropython-minishell
}}

{{ttuto
|label=MIP
|descr='''MicroPython Install Package''' une commande MPRemote pour installer facilement des bibliothèques
|img=tlogo-MPRemote-MIP.png
|url=https://arduino103.blogspot.com/2023/05/micropython-1200-mip-micropython.html
}}

{{ttuto
|label=MiniShell
|descr=MiniShell est un Shell type Linux pour MicroPython. Très pratique pour manipuler des fichiers via REPL.
|img=tlogo-minishell.jpg
|url=https://github.com/mchobby/micropython-minishell
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. WiPy et ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto
|label=Ampy
|descr=Outil simplifié de transfert de fichiers et de contrôlez de carte depuis une connexion série. ESP8266 compatible.
|img=tlogo-micropython-Debugger.jpg
|link=FEATHER-CHARGER-FICHIER-MICROPYTHON
}}

{{ttuto
|label=mem_info()
|descr=Surveiller la consommation RAM de vos script sous MicroPython
|img=tlogo-mem-info.jpg
|url=https://arduino103.blogspot.com/2023/03/micropython-surveiller-la-ram-avec.html
}}

{{ttuto-end}}

= Pilotes MicroPython =
Les pilotes MicroPythons sont des bibliothèques utilisées pour interagir avec des composants électroniques ou cartes breakouts.

Chez MC Hobby, nous développons des pilotes "Plateform Agnostic". Cela signifie que les bibliothèques s'appuient sur l'API {{fname|machine}} et peuvent être utilisés sur toutes les plateformes MicroPython.

Enfin, nous produisons une documentation aussi complète que possible (français/anglais) + scripts d'exemples. Tous cela stocké sur un dépôt en ligne.

{{ttuto-begin}}

{{ttuto
|label=ad9833
|descr=Créer un générateur de signal à l'aide de l AD9833.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ad9833
}}

{{ttuto
|label=adfmotors
|descr=Contrôler des moteurs continu, pas-à-pas ou servo-moteur avec le shield moteur Arduino d'Adafruit. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/adfmotors
}}

{{ttuto
|label=ads1015-ads1115
|descr=Convertisseur ADC (Analogique vers Digital) 4 canaux pour réaliser des lectures analogiques et lectures différentielles. L'ADS1115 dispose d'un amplificateur interne programmable, ce qui permet de lire des tensions très faibles. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ads1015-ads1115
}}

{{ttuto
|label=am2315
|descr=Capteur de température et humidité relative (0 à 100%) pour relevés en extérieur. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/am2315
}}

{{ttuto
|label=bme280-bmp280
|descr=Le BMP280 est un capteur de pression et température très populaire. Le BME280 est un capteur de pression, température et HUMIDITÉ relative. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/bme280-bmp280
}}

{{ttuto
|label=bmp180
|descr=Le BMP180 est un senseur de pression et température aujourd'hui remplacé par le BMP280. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/bmp180
}}

{{ttuto
|label=cardkb
|descr=CardKB - Mini-clavier QWERTY en I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/cardkb
}}

{{ttuto
|label=ccs811
|descr=CCS811 - Capteur qualité d'air - COV et eCO2 avec MicroPython. ADAFRUIT,OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ccs811
}}

{{ttuto
|label=COLORS
|descr=Bibliothèque de gestion de couleurs (et outils).
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/COLORS
}}

{{ttuto
|label=dht11
|descr=Le DHT11 est un senseur d'humidité (20 à 80%) et température très bon marché. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/dht11
}}

{{ttuto
|label=dotstar
|descr=Les DotStar / APA102 sont des LEDs digitales intelligentes pouvant être contrôlées indépendamment les unes des autres. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/dotstar
}}

{{ttuto
|label=drv8830
|descr=Le Mini I2C motor driver permet de contrôler 2 moteurs 5V par l'intermédiaire d'une interface I2C. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/drv8830
}}

{{ttuto
|label=ds18b20
|descr=Le DS18B20 est un senseur de température digital très populaire. Il utilise le bus 1-Wire permettant de brancher plusieurs senseurs 1-Wire sur un même bus. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ds18b20
}}

{{ttuto
|label=eeprom
|descr=Utiliser des EEPROM I2C pour stocker des informations. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/eeprom
}}

{{ttuto
|label=gps-ultimate
|descr=Pouvoir obtenir ou suivre votre position actuelle à l'aide d'un module GPS. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/gps-ultimate
}}

{{ttuto
|label=hat-joy-bonnet
|descr=Utiliser le HAT Joy Bonnet avec MicroPython NADHAT PYB405. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-joy-bonnet
}}

{{ttuto
|label=hat-piface
|descr=Utiliser le PiFace Digital avec MicroPython Pyboard, PYBStick.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-piface
}}

{{ttuto
|label=hat-sense
|descr=Utiliser le Sense HAT avec MicroPython Pyboard, PYBStick, PYB405.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=FBGFX
|descr=Bibliothèque graphique pour FrameBuffer.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/FBGFX
}}

{{ttuto
|label=grove-5-way-switch
|descr=Joystick 5 directions (et carte 6 DIP) via I2C - sous MicroPython. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/grove-5-way-switch
}}

{{ttuto
|label=ht0740-switch
|descr=HT0740 - 40V / 10A MosFet controlable via I2C - sous MicroPython. PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ht0740-switch
}}

{{ttuto
|label=ili934x
|descr=ILI934x - contrôleur afficheur TFT couleur 16 bits - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ili934x
}}

{{ttuto
|label=is31fl
|descr=IS31FL3731 - contrôleur CharliePlexing via I2C - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/is31fl
}}

{{ttuto
|label=lcdi2c
|descr=Afficheur à cristaux liquides (LCD) commandé via le bus I2C. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdi2c
}}

{{ttuto
|label=lcdmtrx
|descr=Afficheur LCD 2 lignes, 16 caractères, Arrière plan RGB. Interface USB + Série. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdmtrx
}}

{{ttuto
|label=lcdspi-lcd12864
|descr=Afficheur LCD graphique 128 x 64 pixels. Interface SPI (3 fils). DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lcdspi-lcd12864
}}

{{ttuto
|label=lsm303
|descr=Utiliser une boussole et accéléromètre LSM303D avec MicroPython. POLOLU.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/lsm303
}}

{{ttuto
|label=m5stack-u087
|descr=Module Voltmetre I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u087
}}

{{ttuto
|label=m5stack-u097
|descr=Module 4 relais I2C. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u097
}}

{{ttuto
|label=m5stack-u105
|descr=I2C DDS unit (Direct Digital Synthesis, AD9833, ), Grove. M5STACK.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/m5stack-u105
}}

{{ttuto
|label=max6675
|descr=MAX6675 Amplificateur Thermocouple Type-K - MOD-TC - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/max6675
}}

{{ttuto
|label=max31855
|descr=ThermoCouple Type-K + amplificateur MAX31855 - sous MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/max31855
}}

{{ttuto
|label=mcp230xx
|descr=Le MCP23017 (et MCP2308) sont des GPIO Expander sur bus I2C ajoutant des entrées/sorties sur un microcontrôleur. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp230xx
}}

{{ttuto
|label=mcp23Sxx
|descr=Le MCP23S17 est un GPIO Expander sur bus SPI ajoutant des entrées/sorties sur un microcontrôleur. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp23Sxx
}}

{{ttuto
|label=mcp9808
|descr=Le MCP9808 (bus I2C) permettant de faire un relevé de température avec une précision de 0.25°C. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp9808
}}

{{ttuto
|label=mcp4725
|descr=Le MCP4725 (bus I2C) est un DAC -ou- une vraie sortie Analogique 12 bits (0 à 65535). ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mcp4725
}}

{{ttuto
|label=modenv
|descr=Capteur environnementale tout-en-un - BME280 + CCS811 - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modenv
}}

{{ttuto
|label=modio
|descr=MOD-IO est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de relais, d'entrée OptoCoupleur (24V) et entrées analogiques (0-3.3V). Cette carte est compatible avec le standard industriel en 24V. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modio
}}

{{ttuto
|label=modio2
|descr=MOD-IO est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de relais, de GPIO aux fonctions multiples (Input, Output, Analog, PWM; 0-3.3V). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modio2
}}

{{ttuto
|label=modirdaplus
|descr=MOD-IRDA+ est un module émetteur/récepteur Infrarouge I2C supportant les protocols RC5 (Philips) et SIRCS (Sony). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modirdaplus
}}

{{ttuto
|label=modirtemp
|descr=Mesure de température -70°C à 380°C Infrarouge sans contact (MXL90164). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modirtemp
}}

{{ttuto
|label=modlcd1x9
|descr=MOD-LCD1x9 est un afficheur 9 caractères alphanumérique I2C avec port de connexion UEXT. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modlcd1x9
}}

{{ttuto
|label=modlcd3310
|descr=MOD-LCD3310 est l'afficheur LCD du Nokia 3310 offrant 84 x 48 pixels et un port de connexion UEXT. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modlcd3310
}}

{{ttuto
|label=modled8x8
|descr=Un afficheur 8x8 LEDs RGB chaînable. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modled8x8
}}

{{ttuto
|label=modltr501
|descr=LTR-501ALS permet de faire une lecture de luminosité de 0.01 à 64.000 Lux (64K lux) et détection de proximité (jusqu'à 10cm). Le MOD-LTR-501ALS dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modltr501
}}

{{ttuto
|label=modmag
|descr=Le MAG3110 est un magénomètre digital 3 axes de NXP accessible via I2C. Le MOD-MAG dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modmag
}}

{{ttuto
|label=modoled128x64
|descr=Un afficheur OLED 128x64 / 128x32 / 64x48 avec contrôleur SSD1306 (I2C) et connecteur UEXT, Feather, Qwiic. OLIMEX,ADAFRUIT,SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modoled128x64
}}

{{ttuto
|label=modrfid
|descr=MOD-RFID1356 MIFARE : lecteur NFC / RFID Mifare via port série/usb-série/usb-hid. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrfid
}}

{{ttuto
|label=modrgb
|descr=MOD-RGB est une carte d'extension I2C avec port de connexion UEXT. Cette carte d'Olimex équipé de MosFet de puissance pour commander des rubans LED RGB analogiques via I2C (ou DMX). OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrgb
}}

{{ttuto
|label=modrs485iso
|descr=MOD-RS485-ISO est un adaptateur RS485 Full-Duplex/Half-Duplex avec isolation. La transmission de données se fait via UART (MODE_PASS) ou I2C (MODE_BRIDE). Expose une interface UEXT pour connexion rapide. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrs485iso
}}

{{ttuto
|label=modtc-mk2
|descr=MAX6MOD-TC-MK2 : Amplificateur Thermocouple Type-K (MAX31855) via I2C - sous MicroPython. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modtc-mk2
}}

{{ttuto
|label=modwii
|descr=La Wii NUNCHUCK est une manette de jeu super confortable et s'utilise sur le bus I2C. Ce controleur dispose d'une connexion UEXT facilitant les raccordements. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/modwii
}}

{{ttuto
|label=mpr121
|descr=Créer des pastilles/entrées capacitives (tactiles) avec le MPR121. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mpr121
}}

{{ttuto
|label=mpx5700a
|descr=Utiliser un capteur de pression ANALOGIQUE MPX5700AP. SEEEDSTUDIO.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/mpx5700a
}}

{{ttuto
|label=NCD
|descr=Connecter facilement une __mini carte I2C__ de NCD (National Control Device) sur une carte MicroPython grâce au connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Logique 5V. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/NCD
}}

{{ttuto
|label=ncd-mpl115a2
|descr=Le MPL115A2 est un capteur de pression et température I2C. La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD,ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-mpl115a2
}}

{{ttuto
|label=ncd-si7005
|descr=Le SI7005 est un capteur d'humidité relative et température I2C. La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-si7005
}}

{{ttuto
|label=ncd-water-detect
|descr=Détecteur de présence d'eau + Buzzer + 2 GPIOs (basé sur un PCA9536). La mini carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-water-detect
}}

{{ttuto
|label=ncd-fet-solenoid
|descr=Contrôleur de sortie FET + GPIO (basé sur un MCP23008) pour charge résistive / inductive 12V (valve). La carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-fet-solenoid
}}

{{ttuto
|label=ncd-pecmac
|descr=Capteur de courant alternatif sur bus I2C (ou interface IoT). La carte I2C de NCD propose un connecteur NCD qui facilite grandement les raccordements de périphérique I2C. Ce senseur est également disponible sous forme de breakout. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-pecmac
}}

{{ttuto
|label=ncd-oled
|descr=Un afficheur OLED 128x64 avec contrôleur SSD1306 (I2C) et connecteur NCD. NCD.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/ncd-oled
}}

{{ttuto
|label=neopixel
|descr=Les NéoPixels sont des LEDs digitales intelligentes pouvant être contrôlées indépendamment les unes des autres. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/neopixel
}}

{{ttuto
|label=oled-ssd1306
|descr=Le SSD1306 est un contrôleur d'écran OLED. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/oled-ssd1306
}}

{{ttuto
|label=opt3101-fov
|descr=Capteur de distance Time-Of-Flight FoV 3 canaux OPT3101 (POL3412). POLOLU.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/opt3101-fov
}}

{{ttuto
|label=pca9536
|descr=Contrôleur GPIO 4 bits I2C. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pca9536
}}

{{ttuto
|label=pca9685
|descr=Controleur PWM-Driver à base de PCA9685 de NXP, 16 canaux, résolution 12 bits, pour commande des LEDs ou Servo. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pca9685
}}

{{ttuto
|label=pcf8523
|descr=Une Horloge temps réel RTC + alarme avec MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pcf8523
}}

{{ttuto
|label=pm25
|descr=Utiliser un capteur de particule fine PM2.5 (PMS5003) avec MicroPython. ADAFRUIT,PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/pm25
}}

{{ttuto
|label=qwiic-joystick-i2c
|descr=Utiliser un joystick analogique I2C (Qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-joystick-i2c
}}

{{ttuto
|label=qwiic-keypad-i2c
|descr=Utiliser un clavier I2C 12 touches (Qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-keypad-i2c
}}

{{ttuto
|label=qwiic-relay-i2c
|descr=Utiliser un Relais-Simple/Quad-Relais/Quad-Relais-SSR I2C (qwiic) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-relay-i2c
}}

{{ttuto
|label=qwiic-vcnl4040-i2c
|descr=Utiliser un capteur de proximité VCNL4040 (Qwiic, I2C) avec MicroPython. SPARKFUN.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/qwiic-vcnl4040-i2c
}}

{{ttuto
|label=rfm69
|descr=Utiliser module Packet Radio RFM69HCW (SPI) avec MicroPython. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/rfm69
}}

{{ttuto
|label=sht3x
|descr=Exploiter un capteur d'humidité SHT3x avec MicroPython. DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/sht3x
}}

{{ttuto
|label=st7687s
|descr=Exploiter un TFT rond avec MicroPython. DFROBOT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/st7687s
}}

{{ttuto
|label=stmpe610
|descr=Utiliser un capteur tactile résistif avec MicroPython.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/stmpe610
}}

{{ttuto
|label=tca9554a
|descr=Ajouter 8 entrées/sortie avec le TCA9554A.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tca9554a
}}

{{ttuto
|label=tcs34725
|descr=Capturer la couleur (rgb ou Kelvin) avec un capteur TCS34725 + LED + filtre IR. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tcs34725
}}

{{ttuto
|label=trackball
|descr=Ajouter un Trackball + LED RGBW sur votre projet MicroPython. PIMORONI.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/trackball
}}

{{ttuto
|label=tsl2561
|descr=Le TSL2561 est un senseur de luminosité en lumière visible ayant un réponse proche de l'oeil humain. Retourne une valeur en LUX. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tsl2561
}}

{{ttuto
|label=tsl2591
|descr=Le TSL2591 est un capteur de luminosité en lumière visible ayant un réponse proche de l'oeil humain. Retourne une valeur en LUX. ADAFRUIT.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/tsl2591
}}

{{ttuto
|label=umqtt
|descr=Exemples de communication MQTT avec un module ESP8266. NONE.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/umqtt
}}

{{ttuto
|label=UEXT
|descr=Connecteur UEXT en logique 3.3V est utilisé sur les cartes et capteurs d' Olimex. Il transporte les bus I2C, SPI, UART et alimentation 3.3V. OLIMEX.
|img=tlogo-github.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/UEXT
}}

{{ttuto-end}}

= PyBoard =
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-PyBoard.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''Micro Python''' est une carte Python 3 offrant 30 GPIO, 20 PWM, 1 RTC, des bus I2C, CAN, SPI, un accéléromètre, etc. la {{cl|56|gamme Micro Python est disponible}} chez [http://shop.mchobby.be MCHobby].
|}

== MicroPython, PyBoard et PYBStick ==

{{ttuto-begin}}

{{ttuto
|label=Micro Python & PyBoard Kaséko?!?
|descr=Venez découvrir le microcontrôleur programmable en Python. Plateforme, Boot, etc.
|img=tlogo-micropython-presentation.jpg
|link=MicroPython.présentation
}}

{{ttuto
|label=En vidéo
|descr=Quelques vidéos très intéressante.
|img=tlogo-micropython-video.jpg
|link=MicroPython.vidéo
}}

{{ttuto
|label=Tester en live
|descr=Un petit laboratoire avec une carte Micro Python connecté sur Internet pour la tester.
|img=tlogo-micropython-net.jpg
|link=MicroPython.Live
}}

{{ttuto
|label=Brochage et Schema
|descr=La carte Micro Python PyBoard, ses fonctionnalités, son brochage, ses schémas et composant Fritzing.
|img=tlogo-micropython-brochage-pyboard.jpg
|link=MicroPython.brochage.pyboard
}}

{{ttuto
|label=Généralités PyB
|descr=Boot Modes, Code d'erreur, système de fichier et réinitialisation. '''A lire avant de se lancer'''.
|img=tlogo-micropython-pyboard-Info.jpg
|link=MicroPython.pyboard.généralités
}}

{{ttuto
|label=Références
|descr=Liens, références et ressources Micro Python.
|img=tlogo-micropython-reference.jpg
|link=MicroPython.référence
}}

{{ttuto
|label=Doc officielle
|descr=L'excellente documentation officielle en anglais. Une importante source de précieuses informations.
|img=tlogo-micropython-docs.jpg
|link=MicroPython.r%C3%A9f%C3%A9rence#Documentation_Officielle
}}

{{ttuto
|label=Modèles de PyBoard.
|descr=Comparatif des différents modèles de la carte PyBoard.
|img=tlogo-micropython-modele.jpg
|link=MicroPython.Pyboard.modele
}}

{{ttuto
|label=Mise-à-jour FirmWare
|descr=Comment faire une mise-à-jour du Firmware de la Pyboard.
|img=tlogo-micropython-update.jpg
|link=MicroPython.Pyboard.mise-a-jour
}}

{{ttuto
|label=Pyboard Discovery Kit
|descr=Un kit et des tutos à thème pour découvrir la carte MicroPython PyBoard.
|img=tlogo-micropython-discovery.jpg
|link=MicroPython.Pyboard.Discovery
}}

{{ttuto
|label=upip
|descr=Télécharger une bibliothèque MicroPython en utilisant le ''Python Index Package''.
|img=tlogo-micropython-upip.jpg
|link=MicroPython-Hack-upip
}}

{{ttuto
|label=PYBStick STD Discovery
|descr=Des tutos à thème pour découvrir MicroPython et la PYBStick STD 26.
|img=tlogo-pybstick-discovery.jpg
|url=https://github.com/mchobby/pyboard-driver/tree/master/PYBStick
}}

{{ttuto
|label=PYBStick HAT-FACE
|descr=Une interface PYBStick vers Raspberry-Pi HAT.
|img=tlogo-pybstick-hat-face.jpg
|link=MicroPython.PYBStick.hat-face
}}

{{ttuto-end}}

== Hacking électronique avec MicroPython ==
ces scripts se penchent sur l'utilisation de MicroPython avec la Pyboard, la PYBStick.

{{ttuto-begin}}

{{ttuto
|label=Précautions & alimentations
|descr=Précautions d'usage avant de se lancer dans le hacking. Comment alimenter votre PyBoard.
|img=tlogo-micropython-prepare.jpg
|link=MicroPython-Hack-Prepare
}}

{{ttuto
|label=Premier script
|descr=Exécutez votre premier script et allumez une LED sur la carte.
|img=tlogo-micropython-firstscript.jpg
|link=MicroPython-Hack-first-script
}}

{{ttuto
|label=L'invite REPL
|descr=Obtenir l'invite '''en ligne de commande''' REPL et utilisez PyBoard en mode terminal.
|img=tlogo-micropython-REPL.jpg
|link=MicroPython-Hack-REPL
}}

{{ttuto
|label=LED et concepts
|descr=Allumer les LEDs de la carte PyBoard. Les concepts de base.
|img=tlogo-micropython-LED.jpg
|link=MicroPython-Hack-LED
}}

{{ttuto
|label=1 LED externe
|descr=Branchez votre première LED sur la PyBoard et contrôlez là.
|img=Tlogo-micropython-1led.png
|link=MicroPython-Hack-1LED
}}

{{ttuto
|label=8 LEDs
|descr=Contrôler plusieurs LEDs.
|img=Tlogo-micropython-8leds.png
|link=MicroPython-Hack-8LEDS
}}

{{ttuto
|label=Bouton
|descr=Bouton, '''callback''' et '''interruption'''.
|img=tlogo-micropython-button.jpg
|link=MicroPython-Hack-button
}}

{{ttuto
|label=L'accéléromètre
|descr=Utiliser l'accéléromètre de la carte.
|img=tlogo-micropython-accelerometre.jpg
|link=MicroPython-Hack-accelerometre
}}

{{ttuto
|label=Safe Mode & réinitialisation
|descr=Safe Mode et réinitialisation d'usine. Reprenez le contrôle de votre PyBoard
|img=tlogo-micropython-safemode.jpg
|link=MicroPython-Hack-safemode
}}

{{ttuto
|label=PyBoard = souris
|descr=Faire agir la PyBoard comme une souris. Réalisez vos propres interface homme-machine.
|img=tlogo-micropython-souris.jpg
|link=MicroPython-Hack-souris
}}

{{ttuto
|label=Les timers
|descr=Mesurer des durées, réaliser des synchronisations ou exécuter du code à intervalle régulier. Exploitez les 14 timers de votre PyBoard.
|img=tlogo-micropython-timer.jpg
|link=MicroPython-Hack-timers
}}

{{ttuto
|label=Assembleurs
|descr=Utiliser l'assembleur inline. Ajouter du code assembleur ARM au sein même de vos programmes.
|img=tlogo-micropython-assembleur.jpg
|link=MicroPython-Hack-assembleur
}}

{{ttuto
|label=Contrôle de puissance
|descr=Contrôler la consommation de votre PyBoard.
|img=tlogo-micropython-power.jpg
|link=MicroPython-Hack-power
}}

{{ttuto
|label=Servo-moteur
|descr=Contrôler des servo moteur en Micro Python. Quelques commandes pour positionner un axe sur un angle donné.
|img=tlogo-moteur-servo.jpg
|link=MicroPython-Hack-servo
}}

{{ttuto
|label=Luminosité d'une LED
|descr=Contrôler la luminosité d'une LED ou la faire pulser avec un signal PWM.
|img=tlogo-micropython-fading.jpg
|link=MicroPython-Hack-fading
}}

{{ttuto
|label=Déparasitage entrée
|descr=Comment déparasiter une entrée.
|img=tlogo-micropython-deparasitage.jpg
|link=MicroPython-Hack-deparasitage
}}

{{ttuto
|label=Lecture Analogique
|descr=Réaliser une lecture analogique sur le PyBoard.
|img=tlogo-micropython-analogique.png
|link=MicroPython-Hack-Analogique
}}

{{ttuto
|label=TMP36 = °C
|descr=Lire la température avec TMP36 un senseur de température analogique.
|img=tlogo-micropython-tmp36.png
|link=MicroPython-Hack-TMP36
}}

{{ttuto
|label=Photo-résistance
|descr=Utiliser une photorésistance, Ldr, Cds et une entrée analogique pour détecter la présence de la lumière.
|img=tlogo-micropython-LDR.png
|link=MicroPython-Hack-LDR
}}

{{ttuto
|label=Moteur
|descr=Utiliser un transistor pour commander un moteur.
|img=tlogo-micropython-moteur.png
|link=MicroPython-Hack-moteur
}}

{{ttuto
|label=Relais
|descr=Commander des charges plus importantes à l'aide d'un relais.
|img=tlogo-micropython-relais.png
|link=MicroPython-Hack-relais
}}

{{ttuto
|label=LED RGB
|descr=Contrôler une LED Rouge,Vert,Bleu pour créer n'importe quelle couleur
|img=tlogo-micropython-LedRGB.png
|link=MicroPython-Hack-led-RGB
}}

{{ttuto
|label=Piezo
|descr=Utiliser un piezo buzzer pour faire de la musique
|img=tlogo-micropython-Piezo.png
|link=MicroPython-Hack-piezo
}}

{{ttuto
|label=Déboguer
|descr=Quelques petits trucs pour vous aider à déboguer vos programmes.
|img=tlogo-micropython-Debugger.jpg
|link=MicroPython-Hack-Debug
}}

{{ttuto
|label=Outil dev
|descr=Quelques outils pour aider vos développement PyBoard.
|img=tlogo-micropython-Debugger.jpg
|link=MicroPython-Hack-Outil
}}

{{ttuto
|label=USB <-> UART
|descr=Envoyer les données de l'UART vers USB (et vice-versa).
|img=tlogo-micropython-USB-UART.jpg
|link=MicroPython-Hack-USB-UART
}}

{{ttuto-end}}

== Extensions Pyboard ==

{{ttuto-begin}}

{{ttuto
|label=Extension LCD
|descr=Utiliser l'extension LCD.
|img=tlogo-micropython-LCD.jpg
|link=MicroPython-LCD
}}

{{ttuto
|label=TFT 2.8"
|descr=Utiliser un TFT 2.8 avec contrôleur ILI9341 sur un PyBoard
|img=tlogo-micropython-ILI9341.jpg
|link=MicroPython-ILI9341
}}

{{ttuto
|label=Maîtriser I2C
|descr=Utiliser et maîtriser les bus I2C sous MicroPython.
|img=tlogo-micropython-I2C.jpg
|link=MicroPython-I2C
}}

{{ttuto
|label=Ultrason HC-SR04
|descr=Evaluer une distance de 2cm à 4m avec le HC-SR04. Il fonctionne comme un sonar.
|img=tlogo-HC-SR04.jpg
|link=MicroPython-HC-SR04
}}

{{ttuto
|label=Pont-H L293D
|descr=Double Pont-H pour contrôler deux moteurs (basse puissance)
|img=tlogo-micropython-l293.jpg
|link=hack-micropython-L293D
}}

{{ttuto
|label=Afficheur 4x7 I2C
|descr=Utilisation d'afficheur 4x7 segment sur le bus I2C de la PyBoard.
|img=tlogo-micropython-4x7.jpg
|link=MicroPython-4x7
}}

{{ttuto
|label=Contrôleur PWM
|descr=Utilisation du controleur PWM 16 canaux avec la PyBoard.
|img=tlogo-adf-pwm.jpg
|link=MicroPython-PWM-DRIVER
}}

{{ttuto
|label=Mosfet
|descr=Commander un MOSFET de puissance à partie d'un microcontrôleur 3.3V.
|img=tlogo-micropython-Mosfet.png
|link=MicroPython-Hack-Mosfet
}}

{{ttuto
|label=Bluetooth & REPL
|descr=Utiliser un module Bluetooth série avec PyBoard. Dupliquer REPL sur Bluetooth.
|img=tlogo-micropython-bluetooth.jpg
|link=MicroPython-bluetooth
}}

{{ttuto
|label=HAT-SENSE
|descr=Utiliser le Hat-Sense avec votre Pyboard
|img=tlogo-micropython-hat-sense.jpg
|url=https://github.com/mchobby/esp8266-upy/tree/master/hat-sense
}}

{{ttuto
|label=PYBD Butterfly
|descr=Assembler le Pyboard-D Butterfly
|img=tlogo-pybd-butterfly.jpg
|link=PYBD-Butterfly
}}



{{ttuto-end}}

== PyBoard Robotique ==

Voici quelques tutoriels pour réaliser une plateforme robotique à base de MicroPython PyBoard.

{{ttuto-begin}}

{{ttuto
|label=Robot 2 Roues
|descr=Commander un robot 2 roues maison avec MicroPython PyBoard et un L293D
|img=tlogo-micropython-Robot2Wheel.jpg
|link=hack-micropython-Robot2Wheel
}}

{{ttuto
|label=Robot Ultrason
|descr=Piloter le robot 2 roues avec un senseur Ultrason HC-SR04
|img=tlogo-micropython-Robot2Wheel-HC-SR04.jpg
|link=hack-micropython-Robot2Wheel-HC-SR04
}}

{{ttuto
|label=Motor-Skin
|descr=Contrôler facilement une plateforme robotique à deux moteurs avec le Motor-Skin pour PyBoard.
|img=tlogo-motorskin-00.jpg
|link=hack-MotorSkin
}}

{{ttuto
|label=ENG: Motor-Skin
|descr=Take the control of a 2 motors robotic plateform with the PyBoard's Motor-Skin.
|img=tlogo-motorskin-00.jpg
|link=hack-ENG-MotorSkin
|traduction=1
}}

{{ttuto
|label=Servo Robots
|descr=Apprenez à réaliser DOGGY et prendre le contrôle de Robots utilisant des servos moteurs pour se déplacer.
|img=tlogo-micropython-ServoRobot.jpg
|link=hack-micropython-ServoRobot
}}

{{ttuto
|label=Moteur DFRobot
|descr=Apprenez à contrôler les moteurs continu DFRobot avec un signal servo. Trop classe!
|img=tlogo-micropython-dfrobot-motor.jpg
|link=hack-micropython-dfrobot-motor
}}

{{ttuto-end}}

= Autres =
== ESP8266 en MicroPython ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-ESP8266.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur ESP8266'''. Reflasher un {{pl|846|Feather ESP8266}}, un {{deadpl|1221|Wemos D1 Mini}}, {{pl|668|ESP8266-EVB}} ou NodeMCU pour qu'il supporte MicroPython afin de réaliser des senseurs connectés à prix imbattable! Un minimum de savoir faire est cependant requis.
|}

Cette section est dévolue à la plateforme {{pl|846|Feather ESP8266 Huzza}}, {{deadpl|1221|Wemos ESP8266}}, NodeMCU reflashé pour MicroPython et extension comme {{cl|87|FeatherWing}}, {{cl|123|Wemos Extension}} (extension).

Cette section est assortie du [https://github.com/mchobby/esp8266-upy GitHub ESP8266-upy contenant des sources et exemples].

=== Généralités ===
{{ttuto-begin}}

{{ttuto
|label=Feather ESP8266
|descr=Découvrir le Feather ESP8266, son Brochage, Alimentation, Schéma, FAQ.
|img=tlogo-feather-esp8266.jpg
|link=FEATHER-ESP8266
}}

{{ttuto
|label=ESP8266-EVB
|descr=Découvrir l'ESP8266-EVB (evaluation board) et ESP8266-DEV (module ESP), son Brochage, Alimentation, Port UEXT, Schéma, FAQ.
|img=tlogo-esp8266-dev.jpg
|link=ESP8266-DEV
}}

{{ttuto
|label=ESP32-EVB
|descr=Commander les éléments de la carte '''ESP32'''-DEV d'Olimex.
|img=tlogo-esp32-evb.png
|link=MicroPython-esp32-evb
}}

{{ttuto
|label=Charger MicroPython
|descr=Apprenez comment charger le Firmware MicroPython sur une carte Pyboard, ESP32/ESP8266 (Feather, Wemos, NodeMcu), etc.
|img=tlogo-feather-load-upy.jpg
|link=FEATHER-CHARGER-MICROPYTHON
}}

{{ttuto
|label=Téléverser & Exécuter
|descr=Téléverser des fichiers et exécuter du code. Un flux simple de développement.
|img=tlogo-feather-load-file.jpg
|link=FEATHER-CHARGER-FICHIER-MICROPYTHON
}}

{{ttuto
|label=ESP8266 WebRepl
|descr=Accéder à la console Python via la connexion WiFi d'un ESP8266.
|img=tlogo-feather-WebRepl.jpg
|link=FEATHER-WEBREPL
}}

{{ttuto
|label=Charger un module
|descr=Charger des modules Python pour ajouter de nouvelle fonctionnalités à votre carte.
|img=tlogo-feather-charger-module.jpg
|link=FEATHER-CHARGER-MODULE
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto
|label=upip
|descr=Télécharger une bibliothèque MicroPython en utilisant le ''Python Index Package''.
|img=tlogo-micropython-upip.jpg
|link=MicroPython-Hack-upip
}}

{{ttuto-end}}

=== Hacking électronique ===
{{ttuto-begin}}

{{ttuto
|label=Entrée Analogique
|descr=Utilisation de l'entrée analogique du Feather ESP8266 sous MicroPython.
|img=tlogo-micropython-analogique.png
|link=FEATHER-MICROPYTHON-ADC
}}

{{ttuto
|label=AM2315 - Humidité
|descr=Mesure de '''température''' et '''humidité''' {{underline|en extérieur}} avec AM2315
|img=tlogo-feather-upy-am2315.jpg
|link=FEATHER-MICROPYTHON-AM2315
}}

{{ttuto
|label=DHT11 - Humidité
|descr=Mesure d' '''humidité''' et '''température''' avec le très économique DHT11.
|img=tlogo-feather-upy-dht11.jpg
|link=FEATHER-MICROPYTHON-DHT11
}}

{{ttuto
|label=TSL2561 - Luminosité
|descr=Mesure de la luminosité en Lux.
|img=tlogo-feather-upy-TSL2561.jpg
|link=FEATHER-MICROPYTHON-TSL2561
}}

{{ttuto
|label=BMP180 - pression
|descr=Mesurer la pression atmosphérique et normalisez là.
|img=tlogo-feather-upy-BMP180.jpg
|link=FEATHER-MICROPYTHON-BMP180
}}

{{ttuto
|label=BMP280 / BME280
|descr=Mesurer la pression atmosphérique, température avec BMP280 + humidité avec BME280.
|img=tlogo-feather-upy-BME280.jpg
|link=FEATHER-MICROPYTHON-BME280
}}

{{ttuto
|label=ADS1x15
|descr=Mesurer précisément une tension analogique avec un ADS1115 ou ADS1015.
|img=tlogo-feather-upy-ADS1115.jpg
|link=FEATHER-MICROPYTHON-ADS1115
}}

{{ttuto
|label=NeoPixel
|descr=Utiliser des NeoPixel (WS2812, SK6812) sur ESP avec MicroPython. Comment passer de 3.3V à 5V.
|img=tlogo-feather-upy-neopixel.jpg
|link=FEATHER-MICROPYTHON-NEOPIXEL
}}

{{ttuto
|label=GPIO Expander
|descr=Utiliser le MCP23017 pour ajouter des entrées/sorties sur ESP8266.
|img=tlogo-feather-upy-MCP23017.png
|link=FEATHER-MICROPYTHON-MCP23017
}}

{{ttuto
|label=OLED
|descr=Utiliser un écran OLED en MicroPython (ESP8266).
|img=tlogo-feather-upy-oled.jpg
|link=FEATHER-MICROPYTHON-OLED
}}

{{ttuto
|label=MOD-OLED [UEXT]
|descr=Un écran OLED 128x64 (I2C) utilisé sous MicroPython (via port UEXT).
|img=tlogo-mod-oled.png
|link=MICROPYTHON-MOD-OLED
}}

{{ttuto
|label=MOD-IO [UEXT]
|descr=Utiliser le module I2C '''MOD-IO''' sous MicroPython (via port UEXT).
|img=tlogo-mod-io.png
|link=MICROPYTHON-MOD-IO
}}

{{ttuto
|label=MOD-IO2 [UEXT]
|descr=Utiliser le module I2C '''MOD-IO2''' sous MicroPython (via port UEXT).
|img=tlogo-mod-io2.jpg
|link=MICROPYTHON-MOD-IO2
}}

{{ttuto
|label=MOD-RGB [UEXT]
|descr=Contrôler des rubans LEDs RGB / RVB avec le module I2C '''MOD-RGB''' sous MicroPython (via port UEXT).
|img=tlogo-mod-rgb.png
|link=MICROPYTHON-MOD-RGB
}}

{{ttuto
|label=MOD-LCD1x9 [UEXT]
|descr=Contrôler l'afficheur Alphanumérique à cristaux liquide avec le module I2C '''MOD-LCD1x9''' sous MicroPython (via port UEXT).
|img=tlogo-mod-lcd1x9.png
|link=MICROPYTHON-MOD-LCD1x9
}}

{{ttuto
|label=MOD-MAG3110 [UEXT]
|descr=Un magnétomètre 3 axes '''MAG3110''' de NXP avec le module I2C '''MOD-MAG3110''' sous MicroPython (via port UEXT).
|img=tlogo-mod-mag3110.png
|link=MICROPYTHON-MOD-MAG3110
}}

{{ttuto
|label=MOD-LTR501ALS [UEXT]
|descr=Senseur de luminosité et de proximité '''LTR-501ALS'''. Exploiter le module I2C sous MicroPython (via port UEXT).
|img=tlogo-mod-ltr501als.png
|link=MICROPYTHON-MOD-LTR501ALS
}}

{{ttuto
|label=MOD-Wii-Chuck [UEXT]
|descr=Contrôleur de jeu I2C Wii Nunchuck. Exploiter le sous MicroPython (via port UEXT).
|img=tlogo-mod-wii-nunchuck.png
|url=https://github.com/mchobby/esp8266-upy/tree/master/modwii
}}

{{ttuto
|label=DFR-Anemometer
|descr=Utiliser un anémomètre (SEN0170) à sortie analogique avec un ESP32 sous MicroPython.
|img=tlogo-anemometer.png
|link=MICROPYTHON-ANEMOMETER
}}

{{ttuto
|label=DFR-Girouette
|descr=Utiliser une Girouette un anémomètre RS485 (SEN0482) sous MicroPython avec l'aide d'un module MOD-RS485-ISO.
|img=tlogo-grouette.png
|url=https://github.com/mchobby/esp8266-upy/tree/master/modrs485iso
}}

{{ttuto-end}}

== SAMD21 en MicroPython ==

{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-SAMD21.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
'''MicroPython sur SAMD21'''. Reflasher un {{sl|M0|Feather M0}} ou {{sl|zero|Arduino Zero}} pour qu'il supporte MicroPython! Un minimum de savoir faire est cependant requis.
|}

Cette section est dévolue aux plateforme SAMD21 comme le {{sl|M0|Feather M0}} ou {{sl|zero|Arduino Zero}} reflashé pour MicroPython.

{{ttuto-begin}}

{{ttuto
|label=Compiler et charger MicroPython
|descr=Comment compiler MicroPython et le charger sur une carte SAMD21.
|img=tlogo-samd21-charger-micropython.jpg
|link=SAMD21-CHARGER-MICROPYTHON
|traduction=1
}}

{{ttuto
|label=Feather M0 Express
|descr=Carte Feather conçue pour Arduino IDE et CircuitPython (MicroPython)
|img=tlogo-feather-m0-express.jpg
|link=FEATHER-M0-EXPRESS
}}

{{ttuto-end}}

== WiPy ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-WiPy.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''WiPy''' est une plateforme de développement "Internet des Objets" qui fonctionne sous Python. WiPy à moins de GPIO, est moins rapide que la PyBoard MAIS inclus le support WiFi. la {{cl|68|gamme WiPy disponible}} chez [http://shop.mchobby.be MCHobby].
|}

Cette section est dévolue à la plateforme {{pl|737|MicroPython WiPy}}.

=== Découvrir WiPy ===
{{ttuto-begin}}

{{ttuto
|label=Généralités WiPy
|descr=Informations générales '''mais importantes''' à propos de WiPy.
|img=tlogo-micropython-pyboard-Info.jpg
|link=hack-wipy-generalite
}}

{{ttuto
|label=WiPy intro
|descr=Introduction à WiPy, en prendre soin, la carte d'extension et les tensions d'alimentation
|img=tlogo-wipy-intro.jpg
|link=hack-wipy-introduction
}}

{{ttuto
|label=Brochage WiPy
|descr=Le brochage du WiPy et les informations utiles sur les broches.
|img=tlogo-wipy-pinout.jpg
|link=hack-wipy-pinout
}}

{{ttuto
|label=WiPy REPL
|descr=Votre WiPy en ligne de commande avec le REPL. Envoyez des ordres à votre WiPy depuis votre réseau WiFi.
|img=Tlogo-micropython-REPL.jpg
|link=hack-wipy-repl
}}

{{ttuto
|label=WiPy et Blynk
|descr=Utilisez votre WiPy depuis votre smartphone à l'aide de Blynk
|img=tlogo-wipy-blynk.jpg
|link=hack-wipy-blynk
}}

{{ttuto
|label=Config WiFi/WLAN
|descr=Configuration de la connexion WiFi/WLAN de votre WiPy étape par étape.
|img=tlogo-wipy-intro.jpg
|link=hack-wipy-wlan
}}

{{ttuto
|label=Boot/Reset
|descr=Réinitialisation (Reset) et mode de démarrage (boot mode) de votre WiPy. Ne restez jamais bloqué avec votre WiPy.
|img=Tlogo-micropython-safemode.jpg
|link=hack-wipy-boot-mode
}}

{{ttuto
|label=Mise-à-jour
|descr=Comment réaliser la mise-à-jour du firmware.
|img=tlogo-micropython-update.jpg
|link=hack-wipy-upgrade-firmware
}}

{{ttuto
|label=Références
|descr=Liens, références et ressources concernant WiPy, LoPy.
|img=tlogo-micropython-reference.jpg
|link=hack-wipy-reference
}}

{{ttuto-end}}

=== Hacking electronic avec WiPy ===

{{ttuto-begin}}

{{ttuto
|label=Controler HeartBeat
|descr=Prenez le contrôle de votre première LED, la LED HeartBeat présent sur la carte.
|img=tlogo-hack-wipy-heatbeat.jpg
|link=hack-wipy-heartbeat
}}

{{ttuto
|label=LED Externe
|descr=Brancher et contrôler une LED. Apprenez ce que signifie ''Current Sink'' et et ''Current Source''
|img=Tlogo-micropython-1led.png
|link=hack-wipy-led
}}

{{ttuto
|label=Bouton
|descr=Utiliser une entrée pour lire l'état d'un bouton. Apprenez ce que signifie ''Résistance Pull Up'' et utiliser les '''interruptions''' et fonction '''callback'''.
|img=Tlogo-wipy-button.jpg
|link=hack-wipy-button
}}

{{ttuto
|label=Relais
|descr=Commandez un Relais avec votre WiPy.
|img=Tlogo-wipy-relais.png
|link=hack-wipy-Relais
|traduction=1
}}

{{ttuto
|label=Timer
|descr=Utiliser un Timer pour appeler régulièrement du code sur votre WiPy.
|img=Tlogo-wipy-timer.png
|link=hack-wipy-Timer
|traduction=1
}}
{{ttuto-end}}

== LoPy & WiPy 2 ==
{| border="0"
|-
| align="left" width="360px" | [[Fichier:MicroPython-Lopy.jpg|320px]]
| align="Left" width="350px" valign="top" style="padding:10px" |
 '''LoPy''' est une plateforme de développement "Internet des Objets" qui fonctionne sous Python. LoPy supporte 3 types de réseau sans fil: LoRa, WiFi et Bluetooth. la {{cl|68|gamme WiPy/Lopy est disponible}} chez [http://shop.mchobby.be MCHobby].
|}

Cette section est dévolue à la plateforme {{pl|737|MicroPython LoPy}}, {{pl|1039|MicroPython WiPy 2}} et la {{pl|1011|carte d'extension WiPy/LoPy}}. Les plateformes WiPy 2 et Lopy sont toutes deux basées sur un ESP_32, ce qui fait que cette section convient pour les deux plateformes.

{{ambox|text=19/02/2017: Le FirmWare du Lopy/Wipy est activement développé, des nouvelles et/ou firmwares sont disponibles toutes les semaines.

Tenez vous au courant en suivant les [https://forum.pycom.io/category/1/announcements-news annonces du forum Pycom.io] pour être tenu au courant.}}

=== Découvrir LoPy / WiPy 2 ===

LoPy et WiPy 2 sont tous les deux basés sur une plateforme ESP_32, de ce fait, les guides ci-dessous conviennent pour les deux plateformes.

Vous pouvez également vous inspirer des montages et exemples du WiPy 1 pour faire du prototypage électronique.

{{ttuto-begin}}

{{ttuto
|label=Démarrer
|descr=Démarrer rapidement avec LoPy ou WiPy 2 (plateforme ESP_32 de PyCom)
|img=tlogo-lopy-intro.jpg
|link=hack-pycom-esp_32
}}

{{ttuto
|label=Brochage WiPy2
|descr=Brochage du WiPy 2
|img=tlogo-wipy2-pinout.jpg
|link=hack-pycom-wipy2-pinout
}}

{{ttuto
|label=Brochage LoPy
|descr=Brochage du LoPy
|img=tlogo-lopy-pinout.jpg
|link=hack-pycom-lopy-pinout
}}

{{ttuto
|label=FTP/Telnet
|descr=Se connecter en FTP ou telnet sur le Lopy
|img=tlogo-lopy-ftp.jpg
|link=hack-pycom-lopy-ftp
}}

{{ttuto
|label=Pymakr IDE
|descr=Un éditeur qui se connecte en Telnet ou port série. Utiliser la LED du RGB du WiPy.
|img=tlogo-lopy-ide.jpg
|link=Hack-pycom-lopy-Pymakr
}}

{{ttuto
|label=Boîte à outils
|descr=Les modules, REPL, FTP, '''Boot mode''', Interruption... tout ce qu'il faut savoir
|img=tlogo-lopy-toolbix.jpg
|link=Hack-pycom-lopy-toolbox
}}

{{ttuto
|label=RShell
|descr=Transférez des fichiers et contrôlez votre carte depuis une simple connexion série. WiPy et ESP8266 compatible.
|img=tlogo-micropython-RShell.jpg
|link=MicroPython-Hack-RShell
}}

{{ttuto-end}}

Fichier:Micropython-PIR-alarm-30b.jpg

2026-01-06T22:19:05Z

Admin :

Fichier:Micropython-PIR-alarm-30a.jpg

2026-01-06T22:18:41Z

Admin :

Micropython-PIR-alarm

2026-01-06T22:18:10Z

Admin : /* Augmenter la tension */

Micropython-PIR-alarm

2026-01-06T22:07:23Z

Admin : /* Augmenter la tension */

Micropython-PIR-alarm

2026-01-06T22:03:06Z

Admin : /* Augmenter la tension */

Fichier:Micropython-PIR-alarm-30.jpg

2026-01-06T22:01:31Z

Admin :

Micropython-PIR-alarm

2026-01-06T21:59:26Z

Admin : /* Augmenter la tension */

Micropython-PIR-alarm

2026-01-06T21:10:58Z

Admin : /* Augmenter la tension */

Micropython-PIR-alarm

2026-01-06T21:10:49Z

Admin : /* Augmenter la tension */

Micropython-PIR-alarm

2026-01-06T21:10:35Z

Admin : /* Raccordement analogique */

Micropython-PIR-alarm

2026-01-06T00:50:26Z

Admin : /* Raccordement analogique */

Micropython-PIR-alarm

2026-01-06T00:02:59Z

Admin : /* Raccordement analogique */

Micropython-PIR-alarm

2026-01-05T22:24:39Z

Admin : /* Raccordement en cascade */

Micropython-PIR-alarm

2026-01-05T22:24:18Z

Admin : /* Raccordement en cascade */

Micropython-PIR-alarm

2026-01-05T21:04:12Z

Admin : /* Raccordement en cascade */

Fichier:Micropython-PIR-alarm-20.jpg

2026-01-05T19:52:22Z

Admin :

Micropython-PIR-alarm

2026-01-05T19:50:56Z

Admin : /* Raccordement en cascade */

Micropython-PIR-alarm

2026-01-05T19:50:41Z

Admin : /* Raccordement Simple */

Micropython-PIR-alarm

2026-01-04T20:48:43Z

Admin : /* Raccordement Simple */

Micropython-PIR-alarm

2026-01-04T20:43:20Z

Admin : /* Raccordement Simple */

Micropython-PIR-alarm

2026-01-04T20:37:28Z

Admin : /* Connexion sur MicroContrôleur */

Micropython-PIR-alarm

2026-01-04T20:36:08Z

Admin : /* Connexion sur MicroContrôleur */

Micropython-PIR-alarm

2026-01-04T20:35:30Z

Admin : /* Connexion sur MicroContrôleur */

Micropython-PIR-alarm

2026-01-04T20:26:08Z

Admin : /* Connexion sur MicroContrôleur */

Fichier:Micropython-PIR-alarm-11.jpg

2026-01-04T20:24:25Z

Admin :

Fichier:Micropython-PIR-alarm-10.jpg

2026-01-04T20:24:03Z

Admin :