L'utilisation de MicroPython est un excellent moyen de tirer le meilleur parti de votre carte ESP32. vice versa, la puce ESP32 est une excellente plate-forme pour utiliser MicroPython. Le didacticiel vous guidera dans la configuration de MicroPython, l'obtention d'une invite et l'utilisation WebREPL, connexion au réseau et communication avec Internet, en utilisant les périphériques matériels et le contrôle de certains composants externes.
C'est parti !
La première chose dont vous avez besoin est une carte avec une puce ESP32. Le MicroPython Le logiciel prend en charge la puce ESP32 elle-même et n'importe quelle carte devrait fonctionner. la caractéristique d'une carte est la façon dont les broches GPIO sont connectées à l'extérieur monde, et s'il comprend un convertisseur USB-série intégré pour rendre le UART disponible sur votre PC.
Les noms des broches seront donnés dans ce tutoriel en utilisant les noms des puces (par exemple GPIO2) et il devrait être simple de trouver à quelle broche cela correspond sur votre conseil particulier.
Si votre carte est équipée d'un connecteur USB, il est fort probable qu'elle soit alimentée par ceci lorsqu'il est connecté à votre PC. Sinon, vous devrez l'alimenter directement. Veuillez vous référer à la documentation de votre carte pour plus de détails.
La première chose à faire est de télécharger le firmware MicroPython le plus récent .bin à charger sur votre appareil ESP32. Vous pouvez le télécharger à partir du Page de téléchargement de MicroPython À partir de là, vous avez 3 choix principaux :
Si vous débutez avec MicroPython, le mieux est d'opter pour la version Stable versions de firmware. Si vous êtes un utilisateur avancé et expérimenté de MicroPython ESP32 qui aimerait suivre de près le développement et aider à tester de nouveaux fonctionnalités, il y a des builds quotidiennes. Si votre carte prend en charge SPIRAM, vous pouvez utilisez soit le firmware standard, soit le firmware avec support SPIRAM, et dans dans ce dernier cas, vous aurez accès à plus de RAM pour les objets Python.
Une fois que vous avez le firmware MicroPython, vous devez le charger sur votre appareil ESP32. Il y a deux étapes principales pour ce faire : vous devez d'abord mettre votre appareil en mode bootloader, et deuxièmement, vous devez copier le firmware. Le mode exact la procédure pour ces étapes dépend fortement de la carte en question et vous il faut se référer à sa documentation pour plus de détails.
Heureusement, la plupart des cartes disposent d'un connecteur USB, d'un convertisseur USB-série et du DTR et les broches RTS câblées d'une manière spéciale, le déploiement du firmware devrait être aussi simple que toutes les étapes peuvent être effectuées automatiquement. Les cartes qui ont de telles fonctionnalités incluent les Adafruit Feather HUZZAH32, M5Stack, Wemos LOLIN32 et TinyPICO cartes, ainsi que les kits de développement Espressif DevKitC, PICO-KIT, WROVER-KIT.
Pour de meilleurs résultats, il est recommandé d'effacer d'abord l'intégralité du flash de votre appareil avant d'installer le nouveau firmware MicroPython.
Actuellement, nous ne prenons en charge que la copie d'esptool.py dans le firmware. Vous pouvez trouver cet outil ici
en utilisant pip::
pip installe esptool
Les versions commençant par 1.3 prennent en charge Python 2.7 et Python 3.4 (ou plus récent). Une version plus ancienne (au moins 1.2.1 est nécessaire) fonctionne bien mais nécessitera Python 2.7.
En utilisant esptool.py, vous pouvez effacer le flash avec la commande :
esptool.py --port /dev/ttyUSB0 effacer_flash
Et puis déployez le nouveau firmware en utilisant ::
esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 esp32-20180511-v1.9.4.bin
Remarques :
`-fm dio` dans la commande)Si les commandes ci-dessus s'exécutent sans erreur, MicroPython doit être installé sur votre planche !
Une fois que vous avez le firmware sur l'appareil, vous pouvez accéder au REPL (invite Python) via UART0 (GPIO1=TX, GPIO3=RX), qui peut être connecté à un port USB-série convertisseur, selon votre carte. Le débit en bauds est de 115200.
À partir de là, vous pouvez maintenant suivre le tutoriel ESP8266, car ces deux puces Espressif
sont très similaires lorsqu'il s'agit d'utiliser MicroPython sur eux. Le tutoriel ESP8266
se trouve dans :ref:esp8266_tutorial (mais ignorez la section Introduction).
Si vous rencontrez des problèmes lors du flashage ou de l'exécution immédiate du firmware après cela, voici des recommandations de dépannage :
Soyez attentif et essayez d'exclure les problèmes matériels. Il existe 2 problèmes courants Problèmes : mauvaise qualité de la source d'alimentation et FlashROM usée/défectueuse. En parlant de source d'alimentation, non seulement l'ampérage brut est important, mais aussi son faible ondulation et bruit/EMI en général. L'alimentation la plus fiable et la plus pratique la source est un port USB.
Les instructions de clignotement ci-dessus utilisent une vitesse de clignotement de 460800 bauds, ce qui est bon compromis entre vitesse et stabilité. Cependant, selon votre module/carte, convertisseur USB-UART, câbles, système d'exploitation hôte, etc., le débit ci-dessus Le débit peut être trop élevé et entraîner des erreurs. Essayez un débit plus courant de 115 200 bauds. Dans de tels cas, il est préférable d'utiliser un tarif plus élevé.
Pour détecter un contenu flash incorrect (par exemple provenant d'un secteur défectueux sur une puce), ajoutez le commutateur « --verify » aux commandes ci-dessus.
Si vous rencontrez toujours des problèmes lors du flashage du firmware, veuillez se référer à la page du projet esptool.py pour une documentation supplémentaire et un outil de suivi des bogues où vous pouvez signaler les problèmes.
Si vous parvenez à flasher le firmware mais que l'option `--verify` renvoie
des erreurs même après plusieurs tentatives peuvent survenir, vous avez peut-être une puce FlashROM défectueuse.
La modulation de largeur d'impulsion (PWM) est un moyen d'obtenir une sortie analogique artificielle sur un broche numérique. Cela se fait en basculant rapidement la broche de bas en haut. Il y a deux paramètres associés à cela : la fréquence du basculement, et le cycle de service. Le cycle de service est défini comme la durée pendant laquelle la broche est haute par rapport à la durée d'une seule période (temps bas et temps haut). Maximum le cycle de service est lorsque la broche est haute tout le temps, et le minimum est lorsqu'elle est bas tout le temps.
Exemple plus complet avec les 16 canaux PWM et les 8 temporisateurs ::
à partir de l'importation de la machine Pin, PWM essayer:
f = 100 # Hz
d = 1024 // 16 # 6,25%
broches = (15, 2, 4, 16, 18, 19, 22, 23, 25, 26, 27, 14, 12, 13, 32, 33)
pwms = []
pour i, épingle dans enumerate(pins) :
pwms.append(PWM(Pin(pin), freq=f * (i // 2 + 1), duty= 1023 si i==15 sinon d * (i + 1)))
imprimer(pwms[i])
enfin:
pour pwm dans pwms :
essayer:
pwm.deinit()
sauf:
passer
La sortie est :
* PWM (Pin (15), fréquence = 100, service = 64, résolution = 10, mode = 0, canal = 0, minuterie = 0)
from time import sleep from machine import Pin, PWM
DUTY_MAX = 2**16 - 1
duty_u16 = 0 delta_d = 16
p = PWM(Pin(5), 1000, duty_u16=duty_u16) print(p)
while True:
p.duty_u16(duty_u16)
sleep(1 / 1000)
duty_u16 += delta_d
if duty_u16 >= DUTY_MAX:
duty_u16 = DUTY_MAX
delta_d = -delta_d
elif duty_u16 <= 0:
duty_u16 = 0
delta_d = -delta_d
Voir l'onde PWM sur la broche (5) avec un oscilloscope.
Remarque : il n'est pas nécessaire de spécifier le mode Pin.OUT. Le canal est initialisé en mode PWM en interne une fois pour chaque broche transmise au constructeur PWM.
Le code suivant est erroné ::
pwm = PWM(Pin(5, Pin.OUT), freq=1000, duty=512) # Pin(5) en mode PWM ici pwm = PWM(Pin(5, Pin.OUT), freq=500, duty=256) # Pin(5) en mode OUT ici, PWM est désactivé
Utilisez plutôt ce code ::
pwm = PWM(Pin(5), freq=1000, duty=512) pwm.init(fréquence=500, service=256)