Quel est le type de modèle de mon ESP32 ?

Version imprimable

31/10/2022, 01h50
Artemus24

Quel est le type de modèle de mon ESP32 ?

Salut à tous.

J'ai un problème de compréhension (avec exactitude sinon cela ne serait pas problématique) sur l'identification de mon ESP32.

Je l'ai acheté chez Gotronic dont le nom de présentation est "Module NodeMcu ESP32 de JoyIt".

Voici le module :

https://joy-it.net/files/files/Produ...U-ESP32-02.png

On peut lire sur la puce ESP32 :
--> WIFI ESP-WroomM-32
--> CE
--> R 211-161007
--> FCC ID:2AC7Z-ESPWROOM32

On dos, on peut lire :
--> joy-it
--> SBC-NodeMCU-ESP32
--> Simac electr.H.Gmbh
--> Pascalstr.8
--> D-47506 NK-Vluyn
--> www.joy-it.net

Je précise qu'aux dos de mes modules, je n'ai pas "ESP32 DevKitV1" qui apparait, comme chez Amazon.

Tout ce que je découvre sur ce module est son nom commercial et le type de la puce ESP32, rien de plus.

Je fais un croquis qui appelle la fonction "ESP.getChipModel();" et qui m'indique : "ESP32-D0WDQ6".
Or ça ne correspond pas du tout à mon ESP-WrooM-32.
Dois-je comprendre que c'est une erreur d'identification ?

Cordialement.
Artemus24.
@+
31/10/2022, 09h15
f-leb

1 pièce(s) jointe(s)

Salut,

Il n'y a pas d'erreur. ESP-WROOM-32 est le module soudé sur la carte (cadre rouge), ESP32-D0WDQ6 est la référence de la puce qui est à l'intérieur (cadre vert).
Pièce jointe 628086
31/10/2022, 12h10
Artemus24

Salut F-leb.

D'accord, nous sommes dans les poupées gigognes ou matriochkas et ca ne va pas être simple.
Je suis complètement largué par ces modules qui portent tous le même nom (ESP-WrooM-32) et ne sont pas tous pareils.
J'ai aussi un problème de langage afin de nommer correctement tous ces composants.

a) Le ESP32 est un nom générique pour désigner un type de microcontrôleur.
Le ESP32 est une évolution du ESP8266 qui lui-même est aussi un autre type de microcontrôleur.

b) la carte électronique (board in english) est ce qui va recevoir tous les composants et ce microcontrôleur.
Il existe plusieurs modèles commercialisées par des constructeurs.
Des grandes, des petites, des allongées, comme j'ai pu le voir, avec ou sans psram ...
Chaque constructeur dispose les composants à leur convenance.
C'est pourquoi, nous avons un nombre et une disposition différentes des broches.

c) ma première difficulté est de comprendre ce que l'on nomme ESP-WrooM-32.
Et c'est là que je découvre qu'il existe une autre famille ESP-WroveR-32.
Et pour compliquer le tout, j'ai vu qu'il existe aussi des ESP32-WrooM-32 et des ESP32-WroveR-32.
Là, je n'y comprends plus rien.

Le ESP32-WrooM-32, est-il différent du ESP-WrooM-32 ? Est-ce un changement de nomenclature ?

d) le NodeMcu est un firmware opensource.
Mais on présente la carte électronique comme un NodeMcu ?
Si j'ai bien compris, on nomme NodeMcu quand la carte possède les modules Wifi et Bluetooth.
Or toutes les cartes électroniques ESP32 qui contiennent les modules Wifi et Bluetooth ne sont pas des NodeMcu.
La aussi, je n'y comprends rien.

e) un soc est un système sur puce. C'est le gros carré métallique gris, là où il y a le nom "ESP-WrooM-32".
Nous trouvons dans ce soc, ce esp32-dowdq6 dont je ne sais pas trop ce que c'est, ainsi que le wifi, le bluetooth/ble, la ram, la rom, la mémoire flash, et tous ce qui concerne les i/o, comme l'uart, l'adc, pwm, spi, i2c ...

f) qu'est-ce que la puce nommé ESP32-DOWDQ6 ?
J'ai compris que l'ESP32-DOWQ6 correspond au ESP-WrooM-32 et l'ESP32-DOWD correspond au ESP-WrooM-32D, ainsi que le ESP-WroveR-IB.

Le D après le -32 signifie "dual core" et le S pour "single core". Or mon NodeMcu ESP32 est un dual core, il devrait normalement se nommer ESP-WrooM-32D. Or ce D signifie aussi qu'il a une antenne MIFA, ou un U (U.FL) pour une prise d'antenne. J'adore cette nomenclature qui manque de rigueur.

Il me faut de l'aide pour débroussailler cette terminologie et à quoi correspond mon module.
J'aimerai savoir quand il a été créé et quelle est sa durée de vie.

Cordialement.
Artemus24.
@+
31/10/2022, 12h44
f-leb

Oula, tu en as des questions:mouarf: Je ne suis pas sûr de pouvoir répondre à tout...

Tu devrais commencer par regarder l'ESP Product Selector d'Espressif pour voir les différentes cartes de développement (avec les modules soudés dessus, et le SoC qui est dans le module). Tu as des descriptions et des schémas très clairs. Tu peux même sélectionner deux modules ou deux SoC et cliquer sur le bouton [comparison] pour voir les différences.

Citation:

J'aimerai savoir quand il a été créé et quelle est sa durée de vie.

Tu verras notamment dans le sélecteur que l'ESP32-DOWDQ6 a déjà le statut NRND (Not Recommended for New Designs) (mais un engagement pour une longévité de 12 ans minimum apparemment, à partir de 2016 pour les premiers ESP32)

à+
31/10/2022, 23h37
f-leb

2 pièce(s) jointe(s)

Citation:

Envoyé par Artemus24

e) un soc est un système sur puce. C'est le gros carré métallique gris, là où il y a le nom "ESP-WrooM-32".
Nous trouvons dans ce soc, ce esp32-dowdq6 dont je ne sais pas trop ce que c'est, ainsi que le wifi, le bluetooth/ble, la ram, la rom, la mémoire flash, et tous ce qui concerne les i/o, comme l'uart, l'adc, pwm, spi, i2c ...

Non, le gros carré métallique gris avec ESP-WROOM-32 est le module.
La puce ESP32-DOWDQ6 qui est à l'intérieur du module est le SoC, qui comprend notamment le/les cœur(s) de processeur.

Exemple : schéma-bloc du module ESP32-WROOM-32E :
Pièce jointe 628142

À l'intérieur le SoC ESP32-DOWD-V3 dont voici l'architecture :
Pièce jointe 628143

Salut à tous.

Pourquoi mon sujet ? (j'aurai dû commencer par préciser la raison)
En faisant une recherche sur le net, j'ai cherché chez Espressif à quelle carte correspondait mon NodeMcu ESP32 de chez Joy-it.
Or je n'ai pas trouvé de correspondance parce que mon NodeMcu ESP32 est propre à Joy-it.
Mais en cherchant par mes moyens à l'identifier, je suis tombé sur ce "ESP32-D0WDQ6" dont je ne savais pas ce que c'était.

Citation:

Envoyé par F-leb

Oula, tu en as des questions. Je ne suis pas sûr de pouvoir répondre à tout...

Tu fais comme tu l'entends. Il n'y a aucun problème si tu ne sais pas répondre. Je pense que tu es bien plus expérimenté que moi en ce domaine.

Je précise à nouveau les questions précédentes :

a) les ESP32 et ESP8266, sont-ils une marqué de microcontrôleurs déposée par Espressif ?

b) n'est pas une question.

c) est de comprendre cette nomenclature de chez Espressif, mais aussi des autres constructeurs. En faisant une recherche sur le net, je constate que d'autres se posent aussi les mêmes interrogations.

d) je n'ai pas compris ce qu'est un NodeMcu vis-à-vis de la carte électronique.

Citation:

Envoyé par F-leb

(avec les modules soudés dessus, et le SoC qui est dans le module).

Tu as répondu à ma question f). Le soc, c'est le ESP32-DOWDQ6.

Citation:

Envoyé par F-leb

Tu verras notamment dans le sélecteur que l'ESP32-D0WDQ6 a déjà le statut NRND (Not Recommended for New Designs) (mais un engagement pour une longévité de 12 ans minimum apparemment, à partir de 2016 pour les premiers ESP32)

J'ai déjà vu cela, sans bien comprendre de quel module parlait-on. Il est indiqué, en haut à droite, "ESP 32 series, 12 years from 1 jan, 2016". Je veux bien, mais entre tous ces séries 32, 32-S et 32-C, je ne sais pas à quoi ce réfère mon NodeMcu ESP 32. Dois-je comprendre que mon NodeMcu est une série 32 de la première génération ? En fait, non.

Citation:

Envoyé par F-leb

Non, le gros carré métallique gris avec ESP-WROOM-32 est le module.

Tu as répondu à ma question e). Nous avons en premier la carte, qui contient le module et lui-même contient le soc.

Si je comprends bien, je dois partir de la fonction "ESP.getChipModel()" qui m'a retourné "ESP32-D0WDQ6".
A partir de cette information, j'identifie le datasheet qui se nomme "ESP32 Series" où il m'indique les SOC suivants :
--> ESP32-D0WD-V3
--> ESP32-D0WDQ6-V3
--> ESP32-D0WD
--> ESP32-D0WDQ6
--> ESP32-D2WD
--> ESP32-S0WD
--> ESP32-U4WDH

J'ai deux liens dans ce datasheet, l'un concernant le "ESP32-WrooM-32" et l'autre le "ESP32-WroveR".
Ils sont tous les deux marqués : "(not recommended for new designs (NRND)." (un vrai jeu de piste :mrgreen:)

Nouvelle question (c'est la dernière et pas des moindres) :

g) dois-je comprendre que l'identification de mon SOC se trouve dans la mémoire eFuse ?
Je suis parti de la fonction "ESP.GetChipModel()" afin de savoir comment identifier ma carte.
J'ai trouvé ceci et voici le code correspondant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 const char * EspClass::getChipModel(void) { #if CONFIG_IDF_TARGET_ESP32 uint32_t chip_ver = REG_GET_FIELD(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_VER_PKG); uint32_t pkg_ver = chip_ver & 0x7; switch (pkg_ver) { case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6 : return "ESP32-D0WDQ6"; case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5 : return "ESP32-D0WDQ5"; case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5 : return "ESP32-D2WDQ5"; case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2 : return "ESP32-PICO-D2"; case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4 : return "ESP32-PICO-D4"; case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302 : return "ESP32-PICO-V3-02"; default: return "Unknown"; } #elif CONFIG_IDF_TARGET_ESP32S2 uint32_t pkg_ver = REG_GET_FIELD(EFUSE_RD_MAC_SPI_SYS_3_REG, EFUSE_PKG_VERSION); switch (pkg_ver) { case 0: return "ESP32-S2"; case 1: return "ESP32-S2FH16"; case 2: return "ESP32-S2FH32"; default: return "ESP32-S2 (Unknown)"; } #elif CONFIG_IDF_TARGET_ESP32S3 return "ESP32-S3"; #elif CONFIG_IDF_TARGET_ESP32C3 return "ESP32-C3"; #endif }
Je découvre que les "CONFIG_IDF_TARGET_ESP..." sont dans un fichier local à mon ordinateur.
Il s'agit de : "C:\Users\Patron\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\tools\sdk\sdkconfig".
Code:

1 2 3 4 # # ESP32-specific # CONFIG_IDF_TARGET_ESP32=y
Je n'ai trouvé que cette référence. Ca limite le choix du résultat de la fonction "ESP.getChipModel()".
Ce paramètre est lié à mon "IDE Arduino" quand j'ai installé le package "carte ESP32".
Par contre, ce paramètre n'est pas lié à ma carte ??? Il est toujours renseigné à "yes".
J'ai changé de carte, mais le fichier "sdkconfig" n'est pas modifié.
La date de modification correspond à l'installation de l'IDE Arduino.

Je n'ai aucune référence aux "CONFIG_IDF_TARGET_ESP32S2", "CONFIG_IDF_TARGET_ESP32S3", et "CONFIG_IDF_TARGET_ESP32C3.
Le pire est que le seul modèle valide est le "ESP32-D0WNDQ6".
Où sont passé les "ESP32-D0WD-V3", "ESP32-D0WDQ6-V3", "ESP32-D0WD", "ESP32-D2WD", "ESP32-S0WD", "ESP32-U4WDH" ?
C'est à croire que cette fonction n'est pas à jour.

Cordialement.
Artemus24.
@+

01/11/2022, 18h27
f-leb

Citation:

Envoyé par Artemus24

Il s'agit de : "C:\Users\Patron\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\tools\sdk\sdkconfig".

Sur mon poste, j'ai la version 2.0.5, ceci explique peut-être cela...
02/11/2022, 03h43
Artemus24

Salut F-leb.

Je suis revenu à la version IDE Arduino 1.8.19 à cause de "ESP32 Sketch Data Upload".
Je possédais déjà mes NodeMcu ESP32 bien avant l'apparition de l'IDE Arduino 2.0.0".
Donc non, cela n'explique en rien l'identification du modèle de mon ESP32.

Le code que j'ai donné vis-à-vis de la version 1.8.19 possède une option de plus, celle-ci : "ESP32-PICO-V3-02'.
Il n'y a que six modèles pour l'ESP32. Que sont devenu les autres modèles que l'on trouve dans le datasheet() ?
Le modèle est codifié sur trois bits, soit huit possibilités.
Je ne dis pas que c'est une erreur, je trouve cela bizarre. Je m'attendais à plus de modèles.

Je vais devoir mettre mon nez dans les eFuse afin de récupérer les informations qui s'y trouvent.

Cordialement.
Artemus24.
@+

Salut f-leb.

Si je prends le compte-rendu d'un téléversement, j'ai ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Le croquis utilise 205134 octets (15%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 13416 octets (4%) de mémoire dynamique, ce qui laisse 314264 octets pour les variables locales. Le maximum est de 327680 octets.
esptool.py v3.0-dev
Serial port COM6
Connecting.......
Chip is ESP32-D0WDQ6 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: 94:b9:7e:ea:77:ac
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 921600
Changed.
Configuring flash size...
Auto-detected Flash size: 4MB
Compressed 8192 bytes to 47...
Writing at 0x0000e000... (100 %)
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.0 seconds (effective 1394.4 kbit/s)...
Hash of data verified.
Compressed 17120 bytes to 11164...
Writing at 0x00001000... (100 %)
Wrote 17120 bytes (11164 compressed) at 0x00001000 in 0.2 seconds (effective 877.9 kbit/s)...
Hash of data verified.
Compressed 205248 bytes to 106558...
Writing at 0x00010000... (14 %)
Writing at 0x00014000... (28 %)
Writing at 0x00018000... (42 %)
Writing at 0x0001c000... (57 %)
Writing at 0x00020000... (71 %)
Writing at 0x00024000... (85 %)
Writing at 0x00028000... (100 %)
Wrote 205248 bytes (106558 compressed) at 0x00010000 in 1.7 seconds (effective 954.6 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 128...
Writing at 0x00008000... (100 %)
Wrote 3072 bytes (128 compressed) at 0x00008000 in 0.0 seconds (effective 512.0 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Je me suis demandé comme obtenir la révision ainsi que le modèle. Voici mon sketch qui permet de les récupérer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/******************************/
/*                            */
/*     Efuse de mes ESP32     */
/*                            */
/******************************/

#include "soc/efuse_reg.h"

/*********************/
/*                   */
/*     Démarrage     */
/*                   */
/*********************/

void setup(void)
{
	Serial.begin(115200);
	delay(1000);

	Serial.write(12);		/* Clear Screen */
	Serial.println("\e[1;31m+--------------------+\e[0m");
	Serial.println("\e[1;31m| EFUSE de mes ESP32 |\e[0m");
	Serial.println("\e[1;31m+--------------------+\e[0m\n");

	Serial.print("REG_READ(EFUSE_BLK0_RDATA3_REG) > ");
	Serial.print(REG_READ(EFUSE_BLK0_RDATA3_REG),BIN);
	Serial.println(" <");

	Serial.println();

	Serial.print("EFUSE_RD_CHIP_VER_REV1_S .......> ");
	Serial.print(EFUSE_RD_CHIP_VER_REV1_S,BIN);
	Serial.println(" <");

	Serial.print("EFUSE_RD_CHIP_VER_REV1_V .......> ");
	Serial.print(EFUSE_RD_CHIP_VER_REV1_V,BIN);
	Serial.println(" <");

	unsigned int _rev = (REG_READ(EFUSE_BLK0_RDATA3_REG) >> EFUSE_RD_CHIP_VER_REV1_S) & EFUSE_RD_CHIP_VER_REV1_V;

	Serial.print("Revision .......................> ");
	Serial.print(_rev,BIN);
	Serial.println(" <");

	Serial.println();

	Serial.print("EFUSE_RD_CHIP_VER_PKG_S ........> ");
	Serial.print(EFUSE_RD_CHIP_VER_PKG_S,BIN);
	Serial.println(" <");

	Serial.print("EFUSE_RD_CHIP_VER_PKG_V ........> ");
	Serial.print(EFUSE_RD_CHIP_VER_PKG_V,BIN);
	Serial.println(" <");

	unsigned int _pkg = (REG_READ(EFUSE_BLK0_RDATA3_REG) >> EFUSE_RD_CHIP_VER_PKG_S) & EFUSE_RD_CHIP_VER_PKG_V;

	Serial.print("Package ........................> ");
	Serial.print(_pkg,BIN);
	Serial.println(" <\r\n");

	Serial.print("Model ..........................: ");

	switch (_pkg)
	{
		case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6:		Serial.println("ESP32-D0WDQ6");		break;
		case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5:		Serial.println("ESP32-D0WDQ5");		break;
		case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5:		Serial.println("ESP32-D2WDQ5");		break;
		case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2:		Serial.println("ESP32-PICOD2");		break;
		case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4:		Serial.println("ESP32-PICOD4");		break;
		default:					Serial.println("Unknown");		break;
	}
}

/*****************************/
/*                           */
/*     Boucle Répétitive     */
/*                           */
/*****************************/

void loop(void)
{
}

Et à l'exécution, cela donne ce résultat :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
+--------------------+
| EFUSE de mes ESP32 |
+--------------------+

REG_READ(EFUSE_BLK0_RDATA3_REG) > 1010000000000000 <

EFUSE_RD_CHIP_VER_REV1_S .......> 1111 <
EFUSE_RD_CHIP_VER_REV1_V .......> 1 <
Revision .......................> 1 <

EFUSE_RD_CHIP_VER_PKG_S ........> 1001 <
EFUSE_RD_CHIP_VER_PKG_V ........> 111 <
Package ........................> 0 <

Model ..........................: ESP32-D0WDQ6

Le EFUSE du bloc 0 se lit de droite à gauche.
Je mets en rouge ci-après ce que je dois récupérer.

Pour la révision, il faut récupérer la position 15 sur une longueur de 1.
Soit "1010000000000000", ce qui donne 1.

Pour le package (ou modèle), il faut récupérer la position 9 sur une longueur de 3.
Soit "1010000000000000", ce qui donne 0.

J'affiche le modèle à partir de ce résultat qui est "ESP32-D0WDQ6".

Cordialement.
Artemus24.
@+