Add Adafuit Macropad serial connection article
This commit is contained in:
parent
4345e877fa
commit
eff6e3b6e5
7 changed files with 627 additions and 0 deletions
|
|
@ -0,0 +1,47 @@
|
|||
from adafruit_macropad import MacroPad
|
||||
import usb_cdc
|
||||
import time
|
||||
|
||||
macropad = MacroPad()
|
||||
serial = usb_cdc.data
|
||||
|
||||
def exec_command (data):
|
||||
global timer
|
||||
try:
|
||||
command,option = data.split()
|
||||
except:
|
||||
command = ""
|
||||
option = ""
|
||||
print("cmd: {} | opt: {}".format(command, option))
|
||||
if command == 'time':
|
||||
timer = float(option)
|
||||
print("new timer: {}".format(timer))
|
||||
response = "nouveau timer : {}\r\n".format(option)
|
||||
buffer = bytearray(response)
|
||||
serial.write(buffer)
|
||||
|
||||
def blink(led, light):
|
||||
print('light: {}'.format(light))
|
||||
if light:
|
||||
macropad.pixels[led] = (33, 45, 230)
|
||||
else:
|
||||
macropad.pixels[led] = (0, 0, 0)
|
||||
print('c: {}'.format(macropad.pixels[led]))
|
||||
return False if light else True
|
||||
|
||||
timer=2
|
||||
light=False
|
||||
in_data=bytearray()
|
||||
|
||||
while True:
|
||||
light = blink(1, light)
|
||||
time.sleep(timer)
|
||||
|
||||
if serial.in_waiting > 0:
|
||||
while(serial.in_waiting>0):
|
||||
byte = serial.read(1)
|
||||
if byte == b'\r':
|
||||
exec_command(in_data.decode("utf-8"))
|
||||
in_data = bytearray()
|
||||
else:
|
||||
in_data += byte
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
import usb_cdc
|
||||
try:
|
||||
usb_cdc.enable(console=True, data=True) # Enable console and data# Write your code here :-)
|
||||
except Exception as e:
|
||||
print(e)
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
from adafruit_macropad import MacroPad
|
||||
import usb_cdc
|
||||
import time
|
||||
|
||||
macropad = MacroPad()
|
||||
serial = usb_cdc.data
|
||||
|
||||
def exec_command (data):
|
||||
global timer
|
||||
try:
|
||||
command,option = data.split()
|
||||
except:
|
||||
command = ""
|
||||
option = ""
|
||||
print("cmd: {} | opt: {}".format(command, option))
|
||||
if command == 'time':
|
||||
timer = float(option)
|
||||
print("new timer: {}".format(timer))
|
||||
|
||||
def blink(led, light):
|
||||
print('light: {}'.format(light))
|
||||
if light:
|
||||
macropad.pixels[led] = (33, 45, 230)
|
||||
else:
|
||||
macropad.pixels[led] = (0, 0, 0)
|
||||
print('c: {}'.format(macropad.pixels[led]))
|
||||
return False if light else True
|
||||
|
||||
timer=2
|
||||
light=False
|
||||
in_data=bytearray()
|
||||
|
||||
while True:
|
||||
light = blink(1, light)
|
||||
time.sleep(timer)
|
||||
|
||||
if serial.in_waiting > 0:
|
||||
while(serial.in_waiting>0):
|
||||
byte = serial.read(1)
|
||||
if byte == b'\r':
|
||||
exec_command(in_data.decode("utf-8"))
|
||||
in_data = bytearray()
|
||||
else:
|
||||
in_data += byte
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
from adafruit_macropad import MacroPad
|
||||
import usb_cdc
|
||||
import time
|
||||
|
||||
macropad = MacroPad()
|
||||
serial = usb_cdc.data
|
||||
|
||||
def exec_command (data):
|
||||
global muted
|
||||
try:
|
||||
print(data)
|
||||
command,option = data.split()
|
||||
except:
|
||||
command = ""
|
||||
option = ""
|
||||
print("cmd: {} | opt: {}".format(command, option))
|
||||
if command == 'mute':
|
||||
muted = True if option == 'yes' else False
|
||||
print('muted: {}'.format(muted))
|
||||
|
||||
timer=2
|
||||
in_data=bytearray()
|
||||
muted=False
|
||||
|
||||
while True:
|
||||
key_event = macropad.keys.events.get()
|
||||
if muted:
|
||||
macropad.pixels[1] = (255,0,0)
|
||||
else:
|
||||
macropad.pixels[1] = (0,255,0)
|
||||
|
||||
if key_event:
|
||||
if key_event.pressed:
|
||||
if key_event.key_number == 1:
|
||||
print('get key 1')
|
||||
serial.write(bytearray('mute\r\n'))
|
||||
|
||||
if serial.in_waiting > 0:
|
||||
while(serial.in_waiting > 0):
|
||||
byte = serial.read(1)
|
||||
if byte == b'\r':
|
||||
exec_command(in_data.decode("utf-8"))
|
||||
in_data = bytearray()
|
||||
else:
|
||||
in_data += byte
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#!/usr/bin/env python
|
||||
import serial
|
||||
import subprocess
|
||||
|
||||
ser = serial.Serial(port='/dev/ttyACM1')
|
||||
|
||||
ser.flushInput()
|
||||
print('Begin loop')
|
||||
while True:
|
||||
line = ser.readline()
|
||||
try:
|
||||
command = (line.decode()).split()
|
||||
print('command received: {}'.format(command[0]))
|
||||
except:
|
||||
print('no valid command received')
|
||||
command = ""
|
||||
|
||||
try:
|
||||
if command[0] == "mute":
|
||||
# First subprocess for toggle mote the microphone
|
||||
subprocess.run(
|
||||
['pactl', 'set-source-mute', '@DEFAULT_SOURCE@', 'toggle'],
|
||||
)
|
||||
|
||||
# Second one for check the states of microphone
|
||||
result = subprocess.run(
|
||||
['pactl', 'get-source-mute', '@DEFAULT_SOURCE@'],
|
||||
capture_output=True
|
||||
)
|
||||
message = "mute {}\r".format(result.stdout.split()[1].decode())
|
||||
ser.write(message.encode())
|
||||
print('command sent: {}'.format(message))
|
||||
except Error as e:
|
||||
print('Error in command: {}'.format(e))
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 169 KiB |
452
content/articles/2023/adafruit_macropad_conn_serie/index.md
Normal file
452
content/articles/2023/adafruit_macropad_conn_serie/index.md
Normal file
|
|
@ -0,0 +1,452 @@
|
|||
Title: Jouer avec le Macropad Adafruit! mais en série
|
||||
Category: linux
|
||||
Tags: Adafruit, CircuitPython, Python
|
||||
Date: 2023-02-26 18:10
|
||||
status: hidden
|
||||
|
||||
Le Macropad Adafruit est un petit clavier de 12 touches rétroéclairées avec un
|
||||
écran OLED et un sélecteur. Il est motorisé par un Raspberry Pi RP2040.
|
||||
|
||||
Dans cet article, nous allons voir comment utiliser ce clavier et communiquer
|
||||
avec via l'utilisation du port série.
|
||||
|
||||
## Circuitpython
|
||||
|
||||
Comme beaucoup de carte électronique à base de micro controlleurs, ce clavier
|
||||
est compatible avec l'écosystème Arduino, il est donc possible de le programmer
|
||||
en C. Il existe aussi un firmware embarqant [CircuitPython][l_circuitp], couplé
|
||||
aux diférentes bibliothèques [fournies par Adafuit][l_circuitp_ada], il est
|
||||
possible d'utiliser *Python* pour le programmer. C'est **ce que nous allons
|
||||
utiliser ici**.
|
||||
|
||||
La documentation sur l'installation du firmware *CyrcuitPython* pour le Macropad
|
||||
est disponible sur le site [d'Adafuit][l_ada_macropad]
|
||||
|
||||
[l_circuitp]:https://circuitpython.org/
|
||||
[l_circuitp_ada]:https://github.com/adafruit/Adafruit_CircuitPython_MacroPad
|
||||
[l_ada_macropad]:https://learn.adafruit.com/adafruit-macropad-rp2040/circuitpython
|
||||
|
||||
## Préparer l'environnement
|
||||
|
||||
Sur notre ordinateur nous allons préparer un *environnement virtuel Python* pour
|
||||
y installer `circup`, module Python permettant d'installer le nécessaire **sur
|
||||
le Macropad**:
|
||||
|
||||
```
|
||||
python -m venv ~/venv_circup
|
||||
source ~/venv_circup/bin/activate
|
||||
```
|
||||
|
||||
Puis après avoir branché le Macropad et monté l'espace de stockage :
|
||||
|
||||
```
|
||||
circup install adafruit_macropad
|
||||
```
|
||||
|
||||
## Installer minicom
|
||||
|
||||
Nous allons maintenant prépare notre système pour tester la connexion série .
|
||||
Tout d'abord installons un logiciel pour communiquer via le port série pour
|
||||
Interagir avec le Macropad. Personnellement j'ai choisi [*minicom*][l_minicom]
|
||||
disponible dans les dépôts Debian, Archlinux et sûrement d'autres distributions:
|
||||
|
||||
```
|
||||
pacman -S minicom
|
||||
```
|
||||
|
||||
Il est aussi nécessaire d'ajouter votre utilisateur dans le groupe `uucp` en
|
||||
utilisant la commande suivante (avec `root` ou `sudo`):
|
||||
|
||||
```
|
||||
gpasswd -a ephase uucp
|
||||
```
|
||||
|
||||
[l_minicom]:https://salsa.debian.org/minicom-team/minicom
|
||||
|
||||
## Initialiser un périphérique série sur la Macropad
|
||||
|
||||
Afin d'initialiser un périphérique série sur le Macropad, il est nécessaire de
|
||||
créer un fichier `boot.py` à la racine de votre lecteur CIRCUITPY et d'y ajouter
|
||||
le code suivant:
|
||||
|
||||
```python
|
||||
import usb_cdc
|
||||
try:
|
||||
"""
|
||||
Initialisation du port série pour la console REPL mais
|
||||
aussi pour un périphérique série, Sous Linux il sera
|
||||
disponible dans /dev/ttyACM
|
||||
"""
|
||||
usb_cdc.enable(console=True, data=True)
|
||||
except Exception as e:
|
||||
print(e)
|
||||
```
|
||||
|
||||
Lors de l'enregistrement du fichier, le Macropad devrait se relancer et prendre
|
||||
en compte les modifications. Plus besoin de toucher à ce fichier, on le laissera
|
||||
tranquille tout au long de cet article. Nous modifierons maintenant le fichier
|
||||
`code.py` toujours à la racine de notre lecteur `CIRCUITPY`.
|
||||
|
||||
## Premier script, faire clignoter une DEL
|
||||
|
||||
Nous allons maintenant tester notre premier code. Celui-ci va simplement faire
|
||||
clignoter une DEL sous une touche de notre clavier. Nous **pourrons changer la
|
||||
fréquence en envoyant la commande `time` via une connexion série**. Voici le
|
||||
code en question:
|
||||
|
||||
```python
|
||||
from adafruit_macropad import MacroPad
|
||||
import usb_cdc
|
||||
import time
|
||||
|
||||
macropad = MacroPad()
|
||||
serial = usb_cdc.data
|
||||
|
||||
def exec_command (data):
|
||||
global timer
|
||||
command,option = data.split()
|
||||
print("cmd: {} | opt: {}".format(command, option))
|
||||
if command == 'time':
|
||||
timer = float(option)
|
||||
print("new timer: {}".format(timer))
|
||||
|
||||
def blink(led, light):
|
||||
print('light: {}'.format(light))
|
||||
if light:
|
||||
macropad.pixels[led] = (33, 45, 230)
|
||||
else:
|
||||
macropad.pixels[led] = (0, 0, 0)
|
||||
print('c: {}'.format(macropad.pixels[led]))
|
||||
return False if light else True
|
||||
|
||||
timer=2
|
||||
light=False
|
||||
in_data=bytearray()
|
||||
|
||||
while True:
|
||||
light = blink(1, light)
|
||||
time.sleep(timer)
|
||||
|
||||
if serial.in_waiting > 0:
|
||||
while(serial.in_waiting>0):
|
||||
byte = serial.read(1)
|
||||
if byte == b'\r':
|
||||
exec_command(in_data.decode("utf-8"))
|
||||
in_data = bytearray()
|
||||
else:
|
||||
in_data += byte
|
||||
```
|
||||
|
||||
Le code est plutôt simple, nous initialisons notre Macropad et la connexion
|
||||
série avec le début de notre fichier:
|
||||
|
||||
```python
|
||||
from adafruit_macropad import MacroPad
|
||||
import usb_cdc
|
||||
import time
|
||||
|
||||
macropad = MacroPad()
|
||||
serial = usb_cdc.data
|
||||
```
|
||||
|
||||
Ensuite nous définissons notre fonction `exec_command` chargée d'interpréter les
|
||||
commandes envoyées depuis la connexion série puis notre fonction `blink` changer
|
||||
de faire clignoter notre DEL.
|
||||
|
||||
Après avoir initialiser les variables `timer` `light` et `in_data` -- cette
|
||||
dernière recevra les données de la connexion série le programme commence. La
|
||||
partie la plus intéressante démarre avec `if serial.is_wainting`.
|
||||
|
||||
À ce moment, si des données sont en attente sur le port série, alors nous les
|
||||
ajoutons à notre variable `in_data`. Lors de la réception d'un retour chariot
|
||||
`\r`, alors nous passons les données reçues à notre fonction `exec_command`.
|
||||
|
||||
### Test de notre code
|
||||
|
||||
Le Test démarre une fois le fichier `code.py` écrit sur notre Macropad.
|
||||
Vous devriez voir la DEL sous la touche 2 clignoter toute les deux secondes.
|
||||
L'écran du Macropad affiche aussi les informations données par les instructions
|
||||
`print` de notre code.
|
||||
|
||||
À partir de de moment nous allons pouvoir utiliser `minicon` pour se connecter à
|
||||
la partie REPL du Macropad et ainsi visualiser aussi les `print`. Ici la console
|
||||
REPL est accessible sous le périphérique `/dev/ttyACM0` :
|
||||
|
||||
```shell
|
||||
$ minicom -D /dev/ttyACM0
|
||||
Welcome to minicom 2.8
|
||||
|
||||
OPTIONS: I18n
|
||||
Compiled on Jan 9 2021, 12:42:45.
|
||||
Port /dev/ttyACM0, 18:28:08
|
||||
|
||||
Press CTRL-A Z for help on special keys
|
||||
|
||||
light: False
|
||||
c: (0, 0, 0)
|
||||
light: True
|
||||
c: (33, 45, 230)
|
||||
```
|
||||
|
||||
La connexion série initiée par notre code est disponible sur le périphérique
|
||||
`/dev/ttyACM1`. Pour modifier le timer, alors nous pouvons entrer la commande
|
||||
suivante depuis un autre terminal:
|
||||
|
||||
```shell
|
||||
printf "time 10\r" > /dev/ttyACM1
|
||||
```
|
||||
|
||||
Sur notre terminal de contrôle avec `minicom`, vous voyons apparaitre alors:
|
||||
|
||||
```
|
||||
light: True
|
||||
c: (33, 45, 230)
|
||||
cmd: time | opt: 10
|
||||
new timer: 10.0
|
||||
light: False
|
||||
c: (0, 0, 0)
|
||||
```
|
||||
|
||||
Notre timer est bien pris en compte et le clignotement se fait maintenant toutes
|
||||
les dix secondes.
|
||||
|
||||
Ce code est bien rudimentaire : il n'y a aucun contrôle et un rien -- comme
|
||||
juste envoyer `time toto` avec notre `printf` -- le fait planter. Pas de panique
|
||||
: le Macropad redémarrera alors tout seul.
|
||||
|
||||
Autre problème, il faut attendre que notre instruction `time.sleep(timer)` soit
|
||||
finie avant que la modification de notre `timer` soit prise en compte. Il est
|
||||
possible d'utiliser la librairie `asyncio` pour contourner ce problème, mais
|
||||
nous ne traiterons pas de ce cas dans cet article.
|
||||
|
||||
## Envoyer des données depuis le Macroad
|
||||
|
||||
Maintenant que nous avons réussi à envoyer des données depuis notre ordinateur
|
||||
vers le Macropad, nous allons en envoyer en sens inverse. Nous allons modifier
|
||||
le fichier `code.py`, plus précisément la fonction `exec_command` comme
|
||||
ci-dessous:
|
||||
|
||||
```python
|
||||
# [...]
|
||||
def exec_command (data):
|
||||
global timer
|
||||
try:
|
||||
command,option = data.split()
|
||||
except:
|
||||
command = ""
|
||||
option = ""
|
||||
print("cmd: {} | opt: {}".format(command, option))
|
||||
if command == 'time':
|
||||
timer = float(option)
|
||||
print("new timer: {}".format(timer))
|
||||
response = "nouveau timer : {}\r\n".format(option)
|
||||
buffer = bytearray(response)
|
||||
serial.write(buffer)
|
||||
# [...]
|
||||
```
|
||||
|
||||
La modification est relativement simple et tient en 3 instructions. Pour tester
|
||||
son fonctionnement, nous allons ouvrir deux terminaux avec `minicom` :
|
||||
|
||||
1. sur notre périphérique `/dev/ttyACM0` afin d'avoir un accès à la console du
|
||||
Macropad;
|
||||
2. sur `/dev/ttyACM1` afin d'interagir avec notre programme dans le Macropad;
|
||||
|
||||
Sur cette dernière fenêtre de terminal, nous allons lancer *minicom* avec la
|
||||
commande `minicom -D /dev/ttyACM1 -c on` puis une fois lancé nous allons
|
||||
activer l'affichage des commandes que l'on saisit avec `Ctrl + X` puis `E`. Cette
|
||||
étape est facultative mais *il est plus agréable de voir ce que nous saisissons*.
|
||||
|
||||
À partir de là nous pouvons changer la fréquence de clignotement avec la
|
||||
commande `time` saisie directement dans *minicom*, notre Macropad nous répond
|
||||
alors directement en envoyant la confirmation via la connexion série:
|
||||
|
||||
```
|
||||
Welcome to minicom 2.8
|
||||
|
||||
OPTIONS: I18n
|
||||
Compiled on Jan 9 2021, 12:42:45
|
||||
Port /dev/ttyACM1, 17:16:49
|
||||
|
||||
Press CTRL-A Z for help on special keys
|
||||
|
||||
|
||||
time 1
|
||||
nouveau timer : 1
|
||||
time 2
|
||||
nouveau timer : 2
|
||||
time 4
|
||||
nouveau timer : 4
|
||||
time 1
|
||||
nouveau timer : 1
|
||||
```
|
||||
|
||||
|
||||
|
||||
Vous devriez obtenir un fonctionnement similaire à ce que montre la capture
|
||||
d'écran ci-dessus.
|
||||
|
||||
Nous avons maintenant obtenu une **communication série bidirectionnelle** entre
|
||||
notre Macropad et notre ordinateur. Mais cet exemple est plutôt succinct, que
|
||||
pouvons nous en faire **concrètement**?
|
||||
|
||||
## Un (début) d'exemple "réel"
|
||||
|
||||
Nous allons utiliser ce que nous avons vu jusqu'ici pour mettre en place un
|
||||
bouton du clavier pour mettre en sourdine le microphone de notre ordinateur.
|
||||
|
||||
Nous allons programmer le bouton N°1 du Macropad pur envoyer une instruction
|
||||
*mute*. Sa DEL sera rouge si le microphone est coupé et verte s'il est actif. Un
|
||||
script *Python* sur notre ordinateur se chargera de recevoir les ordres les
|
||||
exécutera et enverra l'état du microphone en retour.
|
||||
|
||||
### Sur le Macripad
|
||||
|
||||
Voici le code à mettre dans `code.py`:
|
||||
|
||||
```python
|
||||
from adafruit_macropad import MacroPad
|
||||
import usb_cdc
|
||||
import time
|
||||
|
||||
macropad = MacroPad()
|
||||
serial = usb_cdc.data
|
||||
|
||||
def exec_command (data):
|
||||
global muted
|
||||
try:
|
||||
command,option = data.split()
|
||||
except:
|
||||
command = ""
|
||||
option = ""
|
||||
print("cmd: {} | opt: {}".format(command, option))
|
||||
if command == 'mute':
|
||||
muted = True if option == 'yes' else False
|
||||
|
||||
timer=2
|
||||
in_data=bytearray()
|
||||
muted=False
|
||||
|
||||
while True:
|
||||
# Define muted button color
|
||||
if muted:
|
||||
macropad.pixels[1] = (255,0,0)
|
||||
else:
|
||||
macropad.pixels[1] = (0,255,0)
|
||||
|
||||
# Get key event
|
||||
key_event = macropad.keys.events.get()
|
||||
if key_event:
|
||||
if key_event.pressed:
|
||||
if key_event.key_number == 1:
|
||||
serial.write(bytearray('mute\r\n'))
|
||||
|
||||
# Receive serial data
|
||||
if serial.in_waiting > 0:
|
||||
while(serial.in_waiting > 0):
|
||||
byte = serial.read(1)
|
||||
if byte == b'\r':
|
||||
exec_command(in_data.decode("utf-8"))
|
||||
in_data = bytearray()
|
||||
else:
|
||||
in_data += byte
|
||||
```
|
||||
|
||||
Comme vous pouvez le constater nous utilisons largement le code présent dans les
|
||||
deux premières parties.
|
||||
|
||||
### Le script Python sur notre ordinateur
|
||||
|
||||
Il utilise `pactl` pour piloter le micro et obtenir son état. Voici le code à
|
||||
mettre dans le fichier `serial_daemon.py`:
|
||||
|
||||
```python
|
||||
#!/usr/bin/env python
|
||||
import serial
|
||||
import subprocess
|
||||
|
||||
ser = serial.Serial(port='/dev/ttyACM1')
|
||||
|
||||
ser.flushInput()
|
||||
print('Begin loop')
|
||||
while True:
|
||||
line = ser.readline()
|
||||
try:
|
||||
command = (line.decode()).split()
|
||||
print('command received: {}'.format(command[0]))
|
||||
except:
|
||||
print('no valid command received')
|
||||
command = ""
|
||||
|
||||
try:
|
||||
if command[0] == "mute":
|
||||
# First subprocess for toggle mote the microphone
|
||||
subprocess.run(
|
||||
['pactl', 'set-source-mute', '@DEFAULT_SOURCE@', 'toggle'],
|
||||
)
|
||||
|
||||
# Second one for check the states of microphone
|
||||
result = subprocess.run(
|
||||
['pactl', 'get-source-mute', '@DEFAULT_SOURCE@'],
|
||||
capture_output=True
|
||||
)
|
||||
message = "mute {}\r".format(result.stdout.split()[1].decode())
|
||||
ser.write(message.encode())
|
||||
print('command sent: {}'.format(message))
|
||||
except Error as e:
|
||||
print('Error in command: {}'.format(e))
|
||||
```
|
||||
|
||||
Le script commence par initialiser le périphérique série, puis vide l'ensemble
|
||||
des données présente dans le buffer du port série avec `ser.flushInput()` afin
|
||||
de repartie de zéro. Commence ensuite une bouble infinie (notre script reste
|
||||
résident en mémoire).
|
||||
|
||||
`line = ser.readline()` permet de mettre notre processus en attente passive tant
|
||||
qu'une fin de ligne de type `\n\r` n'a pas été reçue. A partir de là le script
|
||||
traite la linge reçue.
|
||||
|
||||
Le script lance la commande pour changer l'état du microphone puis la commande
|
||||
pour en vérifier l'état. L'instruction `ser.write()` transmet l'état de ce
|
||||
dernier au Macropad qui **agira en conséquence**.
|
||||
|
||||
Ici encore le script reste minimal, il suffit maintenant de le lancer et
|
||||
d'observer les différents messages ainsi que l'état di microphone :
|
||||
|
||||
```shell
|
||||
chmod +x serial_daemon.py
|
||||
./serial_daemon.py
|
||||
```
|
||||
|
||||
En appuyant sur le bouton adéquat du clavier, notre script `serial_daemon`
|
||||
devrait réagir comme ci-dessous dans la console:
|
||||
|
||||
```
|
||||
Begin loop
|
||||
command received: mute
|
||||
command sent: mute yes
|
||||
command received: mute
|
||||
command sent: mute no
|
||||
command received: mute
|
||||
command sent: mute yes
|
||||
```
|
||||
|
||||
Et la lumière sous la touche devrait changer de couleur en fonction de
|
||||
l'activation de la sourdine.
|
||||
|
||||
## En conclusion
|
||||
|
||||
Nous avons donc vu comment utiliser les ports série -- que se soir pour la
|
||||
connexion REPL ou pour les données -- sur notre *Macropad Adafruit*.
|
||||
Personnellement j'adore ce petit périphérique qui permet une infinité de
|
||||
possibilité et se programme relativement facilement grâce à *CircuitPython*.
|
||||
|
||||
Bien sût cet article n'a pas pour vocation d'aller en profondeur, que se soit
|
||||
dans les paramétrages des connexions séries que dans les possibilités offertes.
|
||||
Mais su le sujet vous intéresse une petite recherche sur les Internets vous
|
||||
donnera de quoi faire. Je ne peux cependant que vous conseiller l'excellent article
|
||||
de [Carlos Olmos] qui a utilisé le Macropad pour se créer un jukebox. Je m'en
|
||||
suis inspiré pour l'écriture de cet article.
|
||||
|
||||
[Carlos Olmos]:https://carlosolmos.dev/posts/the-macropad-jukebox/
|
||||
Loading…
Add table
Add a link
Reference in a new issue