IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Embarqué Discussion :

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


Sujet :

Embarqué

  1. #1
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    Février 2011
    Messages
    6 346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : Février 2011
    Messages : 6 346
    Points : 18 958
    Points
    18 958
    Par défaut 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 :



    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  2. #2
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    12 579
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 12 579
    Points : 56 602
    Points
    56 602
    Billets dans le blog
    40
    Par défaut
    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).
    Nom : esp32-devkitc-v2-functional-overview.png
Affichages : 2854
Taille : 93,4 Ko

  3. #3
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    Février 2011
    Messages
    6 346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : Février 2011
    Messages : 6 346
    Points : 18 958
    Points
    18 958
    Par défaut
    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  4. #4
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    12 579
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 12 579
    Points : 56 602
    Points
    56 602
    Billets dans le blog
    40
    Par défaut
    Oula, tu en as des questions 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.


    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)

    à+

  5. #5
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    12 579
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 12 579
    Points : 56 602
    Points
    56 602
    Billets dans le blog
    40
    Par défaut
    Citation Envoyé par Artemus24 Voir le message
    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 :
    Nom : param.jpg
Affichages : 2769
Taille : 36,4 Ko

    À l'intérieur le SoC ESP32-DOWD-V3 dont voici l'architecture :
    Nom : param (1).jpg
Affichages : 2754
Taille : 36,7 Ko

  6. #6
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    Février 2011
    Messages
    6 346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : Février 2011
    Messages : 6 346
    Points : 18 958
    Points
    18 958
    Par défaut
    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 )

    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  7. #7
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    12 579
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 12 579
    Points : 56 602
    Points
    56 602
    Billets dans le blog
    40
    Par défaut
    Citation Envoyé par Artemus24 Voir le message
    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...

  8. #8
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    Février 2011
    Messages
    6 346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : Février 2011
    Messages : 6 346
    Points : 18 958
    Points
    18 958
    Par défaut
    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  9. #9
    Expert éminent sénior Avatar de Artemus24
    Homme Profil pro
    Agent secret au service du président Ulysses S. Grant !
    Inscrit en
    Février 2011
    Messages
    6 346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Agent secret au service du président Ulysses S. Grant !
    Secteur : Finance

    Informations forums :
    Inscription : Février 2011
    Messages : 6 346
    Points : 18 958
    Points
    18 958
    Par défaut
    Salut f-leb.

    Si je prends le compte-rendu d'un téléversement, j'ai ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.
    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Quel est le type de mon retour ?
    Par jpclabaux dans le forum Débuter avec Java
    Réponses: 2
    Dernier message: 21/05/2010, 16h31
  2. Quel est le type de RAM de mon pc?
    Par toitonline dans le forum Composants
    Réponses: 10
    Dernier message: 29/11/2007, 19h45
  3. Réponses: 5
    Dernier message: 03/03/2006, 16h17
  4. Quel est le type retourné ?
    Par Rupella dans le forum C
    Réponses: 4
    Dernier message: 30/11/2005, 15h01
  5. [langage] "@$" Quel est ce type de variable?
    Par YanK dans le forum Langage
    Réponses: 4
    Dernier message: 21/04/2005, 19h07

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo