ESP32-WATG-32D
Manuel d'utilisation
Version préliminaire 0.1
Systèmes Espressif
Droits d'auteur © 2019
À propos de ce guide
Ce document est destiné à aider les utilisateurs à configurer l'environnement de développement logiciel de base pour développer des applications utilisant du matériel basé sur le module ESP32WATG-32D.
Notes de mise à jour
| Date | Version | Notes de version |
| 2019.12 | V0.1 | Libération préliminaire. |
Introduction à ESP32-WATG-32D
ESP32-WATG-32D
ESP32-WATG-32D est un module MCU WiFi-BT-BLE personnalisé pour donner la "fonction de connectivité" aux différents produits du client, y compris le chauffe-eau et les systèmes de chauffage de confort.
Le tableau 1 fournit les spécifications de l'ESP32-WATG-32D.
Tableau 1 : Spécifications ESP32-WATG-32D
| Catégories | Articles | Caractéristiques |
| Wifi | Protocoles | 802.t1 b/g/n (802.t1n jusqu'à 150 Mbit/s) |
| Agrégation A-MPDU et A-MSDU et prise en charge de l'intervalle de garde de 0.4 µs | ||
| Gamme de fréquences | 2400 MHz – 2483.5 MHz | |
| Bluetooth | Protocoles | Bluetoothv4.2 BRJEDR et chat spécifique BLE activé |
| Radio | Récepteur NZIF avec une sensibilité de -97 dBm | |
| Émetteur de classe 1, classe 2 et classe 3 | ||
| AFH | ||
| Audio | CVSD et SBC | |
| Matériel | Interfaces de modules | UART, ré. EBUS2,JTAG,GPIO |
| Capteur sur puce | Capteur à effet Hall | |
| Cristal intégré | Cristal 40 MHz | |
| Flash SPI intégré | 8 Mo | |
| Convertisseur DCDC intégré Vol de fonct.tage!Alimentation |
3.3 V, 1.2 A | |
| 12 V / 24 V | ||
| Courant maximal délivré par l'alimentation | 300 mA | |
| Plage de température de fonctionnement recommandée | -40'C + 85'C | |
| Dimensions des modules | (18.00±0.15) mm x (31.00±0.15) mm x (3.10±0.15) mm |
ESP32-WATG-32D a 35 broches qui sont décrites dans le tableau 2.
Description de la broche
Figure 1 : Disposition des broches
Tableau 2 : Définitions des broches
| Nom | Non. | Taper | Fonction |
| RÉINITIALISER | 1 | I | Signal d'activation du module (pull-up interne par défaut). Haut actif. |
| I36 | 2 | I | GPIO36, ADC1_CH0, RTC_GPIO0 |
| I37 | 3 | I | GPIO37, ADC1_CH1, RTC_GPIO1 |
| I38 | 4 | I | GPI38, ADC1_CH2, RTC_GPIO2 |
| I39 | 5 | I | GPIO39, ADC1_CH3, RTC_GPIO3 |
| I34 | 6 | I | GPIO34, ADC1_CH6, RTC_GPIO4 |
| I35 | 7 | I | GPIO35, ADC1_CH7, RTC_GPIO5 |
| IO32 | 8 | E/S | GPIO32, XTAL_32K_P (entrée d'oscillateur à cristal 32.768 kHz), ADC1_CH4, TOUCH9, RTC_GPIO9 |
| IO33 | 9 | E/S | GPIO33, XTAL_32K_N (sortie d'oscillateur à cristal 32.768 kHz), ADC1_CH5, TOUCH8, RTC_GPIO8 |
| IO25 | 10 | E/S | GPIO25, DAC_1, ADC2_CH8, RTC_GPIO6 |
| I2C_SDA | 11 | E/S | GPIO26, I2C_SDA |
| I2C_SCL | 12 | I | GPIO27, I2C_SCL |
| TMS | 13 | E/S | GPIO14, MTMS |
| TDI | 14 | E/S | GPIO12, MTDI |
| +5 V | 15 | PI | Entrée d'alimentation 5 V |
| Terre | 16 17 | PI | Sol |
| NIV | 18 | E/S | Entrée d'alimentation 12 V / 24 V |
| TCK | 19 | E/S | GPIO13, MTCK |
| TDO | 20 | E/S | GPIO15, MTDO |
| EBUS2 | 21 35 | E/S | GPIO19/GPIO22, EBUS2 |
| IO2 | 22 | E/S | GPIO2, ADC2_CH2, TOUCH2, RTC_GPIO12, HSPIWP, HS2_DATA0 |
| IO0_FLASH | 23 | E/S | Démarrage du téléchargement : 0 ; Démarrage SPI : 1 (par défaut). |
| IO4 | 24 | E/S | GPIO4, ADC2_CH0, TOUCH0, RTC_GPIO10, HSPIHD, HS2_DATA1 |
| IO16 | 25 | E/S | GPIO16, HS1_DATA4 |
| 5V_UART1_TXD | 27 | I | GPIO18, réception de données UART 5 V |
| 5V_UART1_RXD | 28 | – | GPIO17, HS1_DATA5 |
| IO17 | 28 | – | GPIO17, HS1_DATA5 |
| IO5 | 29 | E/S | GPIO5, VSPICS0, HS1_DATA6 |
| U0RXD | 31 | E/S | GPIO3, U0RXD |
| U0TXD | 30 | E/S | GPIO1, U0TXD |
| IO21 | 32 | E/S | GPIO21, VSPIHD |
| Terre | 33 | PI | EPAD, sol |
| +3.3 V | 34 | PO | Sortie d'alimentation 3.3V |
Préparation du matériel
Préparation du matériel
- Module ESP32-WATG-32D
- Carte de test RF Espressif (Carrier Board)
- Un dongle USB vers UART
- PC, Windows 7 recommandé
- Câble micro-USB
Connexion matérielle
- Souder ESP32-WATG-32D à la carte porteuse, comme le montre la figure 2.
- Connectez le dongle USB à UART à la carte porteuse via TXD, RXD et GND.
- Connectez le dongle USB à UART au PC via le câble micro-USB.
- Connectez la carte porteuse à l'adaptateur 24 V pour l'alimentation électrique.
- Pendant le téléchargement, court-circuitez IO0 à GND via un cavalier. Ensuite, allumez la carte.
- Téléchargez le micrologiciel dans le flash à l'aide de l'outil de téléchargement ESP32.
- Après le téléchargement, retirez le cavalier sur IO0 et GND.
- Remettez la carte porteuse sous tension. ESP32-WATG-32D passera en mode de fonctionnement.
La puce lira les programmes de la mémoire flash lors de l'initialisation.
Remarques :
- IO0 est logiquement haut en interne.
- Pour plus d'informations sur ESP32-WATG-32D, veuillez vous référer à la fiche technique ESP32-WATG-32D.
Premiers pas avec ESP32 WATG-32D
ESP-IDF
L'Espressif IoT Development Framework (ESP-IDF en abrégé) est un cadre de développement d'applications basé sur l'Espressif ESP32. Les utilisateurs peuvent développer des applications avec ESP32 sous Windows/Linux/MacOS basées sur ESP-IDF.
Configurer les outils
Outre ESP-IDF, vous devez également installer les outils utilisés par ESP-IDF, tels que le compilateur, le débogueur, les packages Python, etc.
Configuration standard de Toolchain pour Windows
Le moyen le plus rapide consiste à télécharger la chaîne d'outils et le zip MSYS2 à partir de dl.espressif.com: https://dl.espressif.com/dl/esp32_win32_msys2_environment_and_toolchain-20181001.zip
Vérification
Exécutez C:\msys32\mingw32.exe pour ouvrir un terminal MSYS2. Exécutez : mkdir -p ~/esp
Entrez cd ~/esp pour entrer dans le nouveau répertoire.
Mise à jour de l'environnement
Lorsque IDF est mis à jour, de nouvelles chaînes d'outils sont parfois requises ou de nouvelles exigences sont ajoutées à l'environnement Windows MSYS2. Pour déplacer des données d'une ancienne version de l'environnement précompilé vers une nouvelle :
Prenez l'ancien environnement MSYS2 (c'est-à-dire C:\msys32) et déplacez/renommez-le dans un autre répertoire (c'est-à-dire C:\msys32_old).
Téléchargez le nouvel environnement précompilé en suivant les étapes ci-dessus.
Décompressez le nouvel environnement MSYS2 dans C:\msys32 (ou un autre emplacement).
Trouvez l'ancien répertoire C:\msys32_old\home et déplacez-le dans C:\msys32.
Vous pouvez maintenant supprimer le répertoire C:\msys32_old si vous n'en avez plus besoin.
Vous pouvez avoir différents environnements MSYS2 indépendants sur votre système, tant qu'ils se trouvent dans des répertoires différents.
Configuration standard de Toolchain pour Linux
Installer les prérequis
CentOS 7 :
sudo yum install gcc git wget make ncurses-devel flex bison gperf python pyserial python-pyelftools
sudo apt-get install gcc git wget make libncurses-dev flex bison gperf python pythonpip python-setuptools python-serial python-cryptographie python-future python-pyparsing python-pyelftools
Cambre:
sudo pacman -S – nécessaire gcc git make ncurses flex bison gperf python2-pyserial python2cryptography python2-future python2-pyparsing python2-pyelftools
Configurer la chaîne d'outils
Linux 64 bits：https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-esp32-2019r1-8.2.0.tar.gz
Linux 32 bits：https://dl.espressif.com/dl/xtensa-esp32-elf-linux32-esp32-2019r1-8.2.0.tar.gz
1. Décompressez le fichier dans le répertoire ~/esp :
Linux 64 bits：mkdir -p ~/esp cd ~/esp tar -xzf ~/Downloads/xtensa-esp32-elf-linux64-esp32-2019r1-8.2.0.tar.gz
Linux 32 bits : mkdir -p ~/espcd ~/esp tar -xzf ~/Downloads/xtensa-esp32-elf-linux32-esp32-2019r1-8.2.0.tar.gz
2. La chaîne d'outils sera décompressée dans le répertoire ~/esp/xtensa-esp32-elf/. Ajoutez ce qui suit à ~/.profile:
export PATH=”$HOME/esp/xtensa-esp32-elf/bin:$PATH”
Ajoutez éventuellement ce qui suit à ~/.profile:
alias get_esp32='export PATH=”$HOME/esp/xtensa-esp32-elf/bin:$PATH”'
3. Reconnectez-vous pour valider .profile. Exécutez ce qui suit pour vérifier PATH : printenv PATH
$ printenv CHEMIN
/home/nom-utilisateur/esp/xtensa-esp32-elf/bin:/home/nom-utilisateur/bin:/home/nom-utilisateur/.local/bin:/usr/local/sbin:/usr/local/bin: /usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
Problèmes d'autorisation /dev/ttyUSB0
Avec certaines distributions Linux, vous pouvez obtenir le message d'erreur Échec de l'ouverture du port /dev/ttyUSB0 lors du flashage de l'ESP32. Cela peut être résolu en ajoutant l'utilisateur actuel au groupe de numérotation.
Utilisateurs d'Arch Linux
Pour exécuter le gdb précompilé (xtensa-esp32-elf-gdb) dans Arch Linux, il faut ncurses 5, mais Arch utilise ncurses 6.
Des bibliothèques de rétrocompatibilité sont disponibles dans AUR pour les configurations natives et lib32 :
https://aur.archlinux.org/packages/ncurses5-compat-libs/
https://aur.archlinux.org/packages/lib32-ncurses5-compat-libs/
Avant d'installer ces packages, vous devrez peut-être ajouter la clé publique de l'auteur à votre trousseau de clés, comme décrit dans la section "Commentaires" des liens ci-dessus.
Vous pouvez également utiliser crosstool-NG pour compiler un gdb lié à ncurses 6.
Configuration standard de Toolchain pour Mac OS
Installer pip :
sudo easy_install pip
Installer la chaîne d'outils :
https://github.com/espressif/esp-idf/blob/master/docs/en/get-started/macossetup.rst#id1
Décompressez le fichier dans le répertoire ~/esp.
La chaîne d'outils sera décompressée dans le chemin ~/esp/xtensa-esp32-elf/.
Ajoutez ce qui suit à ~/.profile:
export PATH=$HOME/esp/xtensa-esp32-elf/bin:$PATH
Facultativement, ajoutez ce qui suit à 〜/ .profile:
alias get_esp32=”export PATH=$HOME/esp/xtensa-esp32-elf/bin:$PATH”
Entrez get_esp322 pour ajouter la chaîne d'outils à PATH.
Obtenir ESP-IDF
Une fois que vous avez installé la chaîne d'outils (qui contient des programmes pour compiler et construire l'application), vous avez également besoin d'API/de bibliothèques spécifiques à ESP32. Ils sont fournis par Espressif dans le référentiel ESP-IDF. Pour l'obtenir, ouvrez le terminal, accédez au répertoire dans lequel vous souhaitez placer ESP-IDF et clonez-le à l'aide de la commande git clone :
git clone –récursif https://github.com/espressif/esp-idf.git
ESP-IDF sera téléchargé dans ~/esp/esp-idf.
Note:
Ne manquez pas l'option –recursive. Si vous avez déjà cloné ESP-IDF sans cette option, exécutez une autre commande pour obtenir tous les sous-modules :
cd ~/esp/esp-idf
mise à jour du sous-module git -init
Ajouter IDF_PATH au profil utilisateur
Pour conserver le réglage de la variable d'environnement IDF_PATH entre les redémarrages du système, ajoutez-la au profil utilisateur, en suivant les instructions ci-dessous.
Fenêtres
Rechercher “Edit Environment Variables” on Windows 10.
Cliquez sur Nouveau… et ajoutez une nouvelle variable système IDF_PATH. La configuration doit inclure un répertoire ESP-IDF, tel que C:\Users\user-name\esp\esp-idf.
Ajoutez ;%IDF_PATH%\tools à la variable Path pour exécuter idf.py et d'autres outils.
Linux et Mac OS
Ajoutez ce qui suit à ~/.profile:
exporter IDF_PATH=~/esp/esp-idf
export PATH=”$IDF_PATH/tools:$PATH”
Exécutez la commande suivante pour vérifier IDF_PATH :
printenvIDF_PATH
Exécutez la commande suivante pour vérifier si idf.py est inclus dans PAT :
quel idf.py
Il imprimera un chemin similaire à ${IDF_PATH}/tools/idf.py.
Vous pouvez également saisir ce qui suit si vous ne souhaitez pas modifier IDF_PATH ou PATH :
exporter IDF_PATH=~/esp/esp-idf
export PATH=”$IDF_PATH/tools:$PATH”
Établir une connexion série avec ESP32-WATG-32D
Cette section explique comment établir une connexion série entre l'ESP32WATG-32D et le PC.
Connectez ESP32-WATG-32D au PC
Soudez le module ESP32-WATG-32D à la carte porteuse et connectez la carte porteuse au PC à l'aide du dongle USB vers UART. Si le pilote de périphérique ne s'installe pas automatiquement, identifiez la puce du convertisseur USB vers série sur votre dongle externe USB vers UART, recherchez les pilotes sur Internet et installez-les.
Vous trouverez ci-dessous les liens vers les pilotes pouvant être utilisés.
CP210x Pont USB vers UART Pilotes VCP Pilotes de port COM virtuel FTDI
Les pilotes ci-dessus sont principalement à titre de référence. Dans des circonstances normales, les pilotes doivent être fournis avec un système d'exploitation et installés automatiquement lors de la connexion du dongle USB à UART au PC.
Vérifier le port sous Windows
Vérifiez la liste des ports COM identifiés dans le gestionnaire de périphériques Windows. Déconnectez le dongle USB vers UART et reconnectez-le pour vérifier quel port disparaît de la liste, puis réapparaît.
Figure 4-1. Pont USB vers UART du dongle USB vers UART dans le Gestionnaire de périphériques Windows
Illustration 4-2. Deux ports série USB du dongle USB vers UART dans le Gestionnaire de périphériques Windows
Vérifier le port sous Linux et MacOS
Pour vérifier le nom de périphérique du port série de votre dongle USB vers UART, exécutez cette commande deux fois, d'abord avec le dongle débranché, puis branché. Le port qui apparaît la deuxième fois est celui dont vous avez besoin :
Linux
ls /dev/tty*
MacOS
ls /dev/cu.*
Ajouter un utilisateur au dialout sous Linux
L'utilisateur actuellement connecté doit avoir un accès en lecture et en écriture au port série via USB.
Sur la plupart des distributions Linux, cela se fait en ajoutant l'utilisateur au groupe dialout avec la commande suivante :
sudo usermod -a -G numérotation $USER
sur Arch Linux, cela se fait en ajoutant l'utilisateur au groupe uucp avec la commande suivante :
sudo usermod -a -G uucp $USER
Assurez-vous de vous reconnecter pour activer les autorisations de lecture et d'écriture pour le port série.
Vérifier la connexion série
Vérifiez maintenant que la connexion série est opérationnelle. Vous pouvez le faire en utilisant un programme de terminal série. Dans cet example nous utiliserons PuTTY SSH Client qui est disponible pour Windows et Linux. Vous pouvez utiliser un autre programme série et définir les paramètres de communication comme ci-dessous.
Exécutez le terminal, définissez le port série identifié, le débit en bauds = 115200, les bits de données = 8, les bits d'arrêt = 1 et la parité = N. Ci-dessous sont example captures d'écran de réglage du port et de ces paramètres de transmission (en bref décrit comme 115200-8-1-N) sous Windows et Linux. N'oubliez pas de sélectionner exactement le même port série que vous avez identifié dans les étapes ci-dessus.
Figure 4-3. Configuration de la communication série dans PuTTY sous Windows
Illustration 4-4. Configuration de la communication série dans PuTTY sous Linux
Ouvrez ensuite le port série dans le terminal et vérifiez si vous voyez un journal imprimé par ESP32.
Le contenu du journal dépendra de l'application chargée sur ESP32.
Remarques :
- Pour certaines configurations de câblage de port série, les broches série RTS et DTR doivent être désactivées dans le programme du terminal avant que l'ESP32 ne démarre et ne produise une sortie série. Cela dépend du matériel lui-même, la plupart des cartes de développement (y compris toutes les cartes Espressif) n'ont pas ce problème. Le problème est présent si RTS et DTR sont câblés directement aux broches EN et GPIO0. Voir la documentation esptool pour plus de détails.
- Fermez le terminal série après avoir vérifié que la communication fonctionne. Dans l'étape suivante, nous allons utiliser une application différente pour télécharger un nouveau micrologiciel sur
ESP32. Cette application ne pourra pas accéder au port série tant qu'il est ouvert dans le terminal.
Configurer
Entrez dans le répertoire hello_world et exécutez menuconfig.
Linux et Mac OS
cd ~/esp/hello_world
idf.py -DIDF_TARGET=configuration du menu esp32
Vous devrez peut-être exécuter python2 idf.py sur Python 3.0.
Fenêtres
cd %utilisateurprofile%\esp\hello_world idf.py -DIDF_TARGET=esp32 menuconfig
Le programme d'installation de Python 2.7 tentera de configurer Windows pour associer un fichier .py à Python 2. Si d'autres programmes (tels que les outils Visual Studio Python) ont été associés à d'autres versions de Python, idf.py peut ne pas fonctionner correctement (le fichier ouvrir dans Visual Studio). Dans ce cas, vous pouvez choisir d'exécuter C:\Python27\python idf.py à chaque fois ou de modifier les paramètres du fichier associé à Windows .py.
Construire et Flasher
Vous pouvez maintenant compiler et flasher l'application. Cours:
construction idf.py
Cela compilera l'application et tous les composants ESP-IDF, générera le chargeur de démarrage, la table de partition et les binaires d'application, et flashera ces binaires sur votre carte ESP32.
$ idf.py construire
Exécution de cmake dans le répertoire /path/to/hello_world/build Exécution de "cmake -G Ninja -warn-uninitialized /path/to/hello_world"… Avertit des valeurs non initialisées.
- Git trouvé : /usr/bin/git (version trouvée « 2.17.0 »)
- Création d'un composant aws_iot vide en raison de la configuration
- Noms des composants : …
- Chemins des composants : … … (plus de lignes de sortie du système de construction)
Construction du projet terminée. Pour flasher, exécutez cette commande :
../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash -flash_mode dio –flash_size detect –flash_freq 40m 0x10000 build/hello-world.bin build 0x1000 build/bootloader/ bootloader.bin 0x8000 build/partition_table/partitiontable.bin ou exécutez 'idf.py -p PORT flash'
S'il n'y a pas de problèmes, à la fin du processus de construction, vous devriez voir les fichiers .bin générés.
Flash sur l'appareil
Flashez les binaires que vous venez de construire sur votre carte ESP32 en exécutant :
idf.py -p PORT [-b BAUD] clignote
Remplacez PORT par le nom du port série de votre carte ESP32. Vous pouvez également modifier le débit en bauds clignotant en remplaçant BAUD par le débit en bauds dont vous avez besoin. Le débit en bauds par défaut est 460800.
Exécution de esptool.py dans le répertoire […]/esp/hello_world Exécution de « python […]/esp-idf/components/esptool_py/esptool/esptool.py -b 460800 write_flash @flash_project_args »… esptool.py -b 460800 write_flash –flash_mode dio –flash_size detect –flash_freq 40m 0x1000 bootloader/bootloader.bin 0x8000 partition_table/partition-table.bin 0x10000 hello-world.bin esptool.py v2.3.1 Connexion…. Détection du type de puce… La puce ESP32 est ESP32D0WDQ6 (révision 1)
Caractéristiques : WiFi, BT, Dual Core Uploading stub… Stub en cours d'exécution… Stub en cours d'exécution… Modification du débit en bauds à 460800 Changé. Configuration de la taille de la mémoire flash… Taille de la mémoire flash détectée automatiquement : 4 Mo Paramètres de la mémoire flash définis sur 0x0220 Compressé 22992 octets à 13019… Écrit 22992 octets (13019 compressés) à 0x00001000 en 0.3 seconde (effectif 558.9 kbit/s)… Hachage des données vérifié. Compressé 3072 octets à 82… Ecrit 3072 octets (82 compressés) à 0x00008000 en 0.0 seconde (effectif 5789.3 kbit/s)… Hachage des données vérifié. Compressé 136672 octets à 67544… Écrit 136672 octets (67544 compressés) à 0x00010000 en 1.9 secondes (effectif 567.5 kbit/s)… Hachage des données vérifié. Quitter… Réinitialisation matérielle via la broche RTS…
S'il n'y a pas de problèmes à la fin du processus de flash, le module sera réinitialisé et l'application "hello_world" sera en cours d'exécution.
Moniteur IDF
Pour vérifier si "hello_world" est bien en cours d'exécution, tapez idf.py -p PORT monitor (n'oubliez pas de remplacer PORT par le nom de votre port série).
Cette commande lance l'application moniteur :
$ idf.py -p /dev/ttyUSB0 monitor Exécution de idf_monitor dans le répertoire […]/esp/hello_world/build Exécution de « python […]/esp-idf/tools/idf_monitor.py -b 115200 […]/esp/hello_world / build/hello-world.elf”… — idf_monitor sur /dev/ttyUSB0 115200 — — Quitter : Ctrl+] | Menu : Ctrl+T | Aide : Ctrl+T suivi de Ctrl+H — ets 8 juin 2016 00:22:57 rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) ets 8 juin 2016 00:22:57 …
Après le défilement des journaux de démarrage et de diagnostic, vous devriez voir « Hello world ! » imprimé par l'application.
… Bonjour le monde! Redémarrage dans 10 secondes… I (211) cpu_start : Démarrage du planificateur sur APP CPU. Redémarrage en 9 secondes… Redémarrage en 8 secondes… Redémarrage en 7 secondes…
Pour quitter le moniteur IDF, utilisez le raccourci Ctrl+].
Si le moniteur IDF échoue peu de temps après le téléchargement, ou si au lieu des messages ci-dessus, vous voyez des déchets aléatoires similaires à ceux indiqués ci-dessous, votre carte utilise probablement un cristal de 26 MHz. La plupart des conceptions de cartes de développement utilisent 40 MHz, donc ESP-IDF utilise cette fréquence comme valeur par défaut.
Examples
Pour ESP-IDF examples, s'il vous plaît allez à ESP-IDF GitHub.
L'équipe Espressif IdO
www.espressif.com
Avis de non-responsabilité et de droit d'auteur
Les informations contenues dans ce document, y compris URL références, est sujet à changement sans préavis.
CE DOCUMENT EST FOURNI TEL QUEL SANS AUCUNE GARANTIE, Y COMPRIS TOUTE GARANTIE DE QUALITÉ MARCHANDE, D'ABSENCE DE CONTREFAÇON, D'ADÉQUATION À UN USAGE PARTICULIER,
OU TOUTE GARANTIE DÉCOULANT AUTREMENT DE TOUTE PROPOSITION, SPÉCIFICATION OU SAMPLE.
Toute responsabilité, y compris la responsabilité pour violation de tout droit de propriété, relative à l'utilisation des informations contenues dans ce document est déclinée. Aucune licence expresse ou implicite, par préclusion ou autrement, sur des droits de propriété intellectuelle n'est concédée aux présentes.
Le logo Wi-Fi Alliance Member est une marque commerciale de Wi-Fi Alliance. Le logo Bluetooth est une marque déposée de Bluetooth SIG. Tous les noms commerciaux, marques de commerce et marques déposées mentionnés dans ce document sont la propriété de leurs propriétaires respectifs et sont reconnus par la présente.
Copyright © 2019 Espressif Inc. Tous droits réservés.
Documents / Ressources
 |
Module MCU WiFi-BT-BLE personnalisé ESPRESSIF ESP32-WATG-32D [pdf] Manuel de l'utilisateur ESP32WATG32D, 2AC7Z-ESP32WATG32D, 2AC7ZESP32WATG32D, ESP32-WATG-32D, Module MCU WiFi-BT-BLE personnalisé, Module MCU WiFi-BT-BLE, Module MCU, ESP32-WATG-32D, Module |
