esptool 4.8.dev5__tar.gz → 4.9.0__tar.gz

{esptool-4.8.dev5/esptool.egg-info → esptool-4.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: esptool
-Version: 4.8.dev5
+Version: 4.9.0
 Summary: A serial utility to communicate & flash code to Espressif chips.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+
@@ -24,11 +24,29 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bitstring!=4.2.0,>=3.1.6
+Requires-Dist: cryptography>=2.1.4
+Requires-Dist: ecdsa>=0.16.0
+Requires-Dist: pyserial>=3.3
+Requires-Dist: reedsolo<1.8,>=1.5.3
+Requires-Dist: PyYAML>=5.1
+Requires-Dist: intelhex
+Requires-Dist: argcomplete>=3; sys_platform != "win32"
 Provides-Extra: dev
+Requires-Dist: pyelftools; extra == "dev"
+Requires-Dist: coverage~=6.0; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-rerunfailures; extra == "dev"
+Requires-Dist: requests; extra == "dev"
+Requires-Dist: commitizen; extra == "dev"
 Provides-Extra: hsm
-License-File: LICENSE
+Requires-Dist: python-pkcs11; extra == "hsm"
+Dynamic: license-file
 
 # esptool.py
 

esptool-4.9.0/esp_rfc2217_server/__init__.py

@@ -0,0 +1,139 @@
+# SPDX-FileCopyrightText: 2009-2015 Chris Liechti
+# SPDX-FileContributor: 2020-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: BSD-3-Clause
+#
+# Redirect data from a TCP/IP connection to a serial port and vice versa using RFC 2217.
+
+###################################################################################
+# redirect data from a TCP/IP connection to a serial port and vice versa
+# using RFC 2217
+#
+# (C) 2009-2015 Chris Liechti <cliechti@gmx.net>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import logging
+import socket
+import sys
+import serial
+
+from esp_rfc2217_server.redirector import Redirector
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="RFC 2217 Serial to Network (TCP/IP) redirector.",
+        epilog="NOTE: no security measures are implemented. "
+        "Anyone can remotely connect to this service over the network.\n"
+        "Only one connection at once is supported. "
+        "When the connection is terminated it waits for the next connect.",
+    )
+
+    parser.add_argument("SERIALPORT")
+
+    parser.add_argument(
+        "-p",
+        "--localport",
+        type=int,
+        help="local TCP port, default: %(default)s",
+        metavar="TCPPORT",
+        default=2217,
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        dest="verbosity",
+        action="count",
+        help="print more diagnostic messages (option can be given multiple times)",
+        default=0,
+    )
+
+    parser.add_argument(
+        "--r0",
+        help="Use delays necessary for ESP32 revision 0 chips",
+        action="store_true",
+    )
+
+    args = parser.parse_args()
+
+    if args.verbosity > 3:
+        args.verbosity = 3
+    level = (logging.WARNING, logging.INFO, logging.DEBUG, logging.NOTSET)[
+        args.verbosity
+    ]
+    logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.INFO)
+    logging.getLogger("rfc2217").setLevel(level)
+
+    # connect to serial port
+    ser = serial.serial_for_url(args.SERIALPORT, do_not_open=True, exclusive=True)
+    ser.timeout = 3  # required so that the reader thread can exit
+    # reset control line as no _remote_ "terminal" has been connected yet
+    ser.dtr = False
+    ser.rts = False
+
+    logging.info("RFC 2217 TCP/IP to Serial redirector - type Ctrl-C / BREAK to quit")
+
+    try:
+        ser.open()
+    except serial.SerialException as e:
+        logging.error(f"Could not open serial port {ser.name}: {e}")
+        sys.exit(1)
+
+    logging.info(f"Serving serial port: {ser.name}")
+    settings = ser.get_settings()
+
+    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    srv.bind(("", args.localport))
+    srv.listen(1)
+    logging.info(f"TCP/IP port: {args.localport}")
+
+    host_ip = socket.gethostbyname(socket.gethostname())
+    wait_msg = f"Waiting for connection ... use the 'rfc2217://{host_ip}:{args.localport}?ign_set_control' as a PORT"
+    logging.info(wait_msg)
+
+    while True:
+        srv.settimeout(5)
+        client_socket = None
+        try:
+            while client_socket is None:
+                try:
+                    client_socket, addr = srv.accept()
+                except TimeoutError:
+                    print(".", end="", flush=True)
+        except KeyboardInterrupt:
+            print("")  # resetting inline print
+            logging.info("Exited with keyboard interrupt")
+            break
+        try:
+            logging.info(f"Connected by {addr[0]}:{addr[1]}")
+            client_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            ser.rts = True
+            ser.dtr = True
+            # enter network <-> serial loop
+            r = Redirector(ser, client_socket, args.verbosity > 0, args.r0)
+            try:
+                r.shortcircuit()
+            finally:
+                logging.info("Disconnected")
+                r.stop()
+                client_socket.close()
+                ser.dtr = False
+                ser.rts = False
+                # Restore port settings (may have been changed by RFC 2217
+                # capable client)
+                ser.apply_settings(settings)
+        except KeyboardInterrupt:
+            sys.stdout.write("\n")
+            break
+        except socket.error as msg:
+            logging.error(str(msg))
+
+    logging.info("--- exit ---")
+
+
+if __name__ == "__main__":
+    main()

esptool-4.9.0/esp_rfc2217_server/__main__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2014-2024 Fredrik Ahlberg, Angus Gratton,
+# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import esp_rfc2217_server
+
+if __name__ == "__main__":
+    esp_rfc2217_server.main()

esptool-4.9.0/esp_rfc2217_server/esp_port_manager.py

@@ -0,0 +1,101 @@
+# SPDX-FileCopyrightText: 2014-2024 Fredrik Ahlberg, Angus Gratton,
+# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+import os
+import threading
+from esptool.reset import (
+    ClassicReset,
+    CustomReset,
+    DEFAULT_RESET_DELAY,
+    HardReset,
+    UnixTightReset,
+)
+import serial
+import serial.rfc2217
+from serial.rfc2217 import (
+    COM_PORT_OPTION,
+    SET_CONTROL,
+    SET_CONTROL_DTR_OFF,
+    SET_CONTROL_DTR_ON,
+    SET_CONTROL_RTS_OFF,
+    SET_CONTROL_RTS_ON,
+)
+
+from esptool.config import load_config_file
+
+cfg, _ = load_config_file(verbose=True)
+cfg = cfg["esptool"]
+
+
+class EspPortManager(serial.rfc2217.PortManager):
+    """
+    The beginning of the reset sequence is detected and the proper reset sequence
+    is applied in a thread. The rest of the reset sequence received is just ignored
+    and not sent to the serial port.
+    """
+
+    def __init__(self, serial_port, connection, esp32r0_delay, logger=None):
+        self.esp32r0_delay = esp32r0_delay
+        self.is_download_mode = False
+        super(EspPortManager, self).__init__(serial_port, connection, logger)
+
+    def _telnet_process_subnegotiation(self, suboption):
+        if suboption[0:1] == COM_PORT_OPTION and suboption[1:2] == SET_CONTROL:
+            if suboption[2:3] == SET_CONTROL_DTR_OFF:
+                self.is_download_mode = False
+                self.serial.dtr = False
+                return
+            elif suboption[2:3] == SET_CONTROL_RTS_OFF and not self.is_download_mode:
+                reset_thread = threading.Thread(target=self._hard_reset_thread)
+                reset_thread.daemon = True
+                reset_thread.name = "hard_reset_thread"
+                reset_thread.start()
+                return
+            elif suboption[2:3] == SET_CONTROL_DTR_ON and not self.is_download_mode:
+                self.is_download_mode = True
+                reset_thread = threading.Thread(target=self._reset_thread)
+                reset_thread.daemon = True
+                reset_thread.name = "reset_thread"
+                reset_thread.start()
+                return
+            elif suboption[2:3] in [
+                SET_CONTROL_DTR_ON,
+                SET_CONTROL_RTS_ON,
+                SET_CONTROL_RTS_OFF,
+            ]:
+                return
+        # only in cases not handled above do the original implementation in PortManager
+        super(EspPortManager, self)._telnet_process_subnegotiation(suboption)
+
+    def _hard_reset_thread(self):
+        """
+        The reset logic used for hard resetting the chip.
+        """
+        if self.logger:
+            self.logger.info("Activating hard reset in thread")
+        cfg_custom_hard_reset_sequence = cfg.get("custom_hard_reset_sequence")
+        if cfg_custom_hard_reset_sequence is not None:
+            CustomReset(self.serial, cfg_custom_hard_reset_sequence)()
+        else:
+            HardReset(self.serial)()
+
+    def _reset_thread(self):
+        """
+        The reset logic is used from esptool.py because the RTS and DTR signals
+        cannot be retransmitted through RFC 2217 with proper timing.
+        """
+        if self.logger:
+            self.logger.info("Activating reset in thread")
+
+        delay = DEFAULT_RESET_DELAY
+        if self.esp32r0_delay:
+            delay += 0.5
+
+        cfg_custom_reset_sequence = cfg.get("custom_reset_sequence")
+        if cfg_custom_reset_sequence is not None:
+            CustomReset(self.serial, cfg_custom_reset_sequence)()
+        elif os.name != "nt":
+            UnixTightReset(self.serial, delay)()
+        else:
+            ClassicReset(self.serial, delay)()

esptool-4.9.0/esp_rfc2217_server/redirector.py

@@ -0,0 +1,89 @@
+# SPDX-FileCopyrightText: 2014-2024 Fredrik Ahlberg, Angus Gratton,
+# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+import threading
+import time
+import logging
+import socket
+
+from esp_rfc2217_server.esp_port_manager import EspPortManager
+
+
+class Redirector(object):
+    def __init__(self, serial_instance, socket, debug=False, esp32r0delay=False):
+        self.serial = serial_instance
+        self.socket = socket
+        self._write_lock = threading.Lock()
+        self.rfc2217 = EspPortManager(
+            self.serial,
+            self,
+            esp32r0delay,
+            logger=logging.getLogger("rfc2217.server") if debug else None,
+        )
+        self.log = logging.getLogger("redirector")
+        self.force_exit = False
+
+    def statusline_poller(self):
+        self.log.debug("status line poll thread started")
+        while self.alive:
+            time.sleep(1)
+            self.rfc2217.check_modem_lines()
+        self.log.debug("status line poll thread terminated")
+
+    def shortcircuit(self):
+        """connect the serial port to the TCP port by copying everything
+        from one side to the other"""
+        self.alive = True
+        self.thread_read = threading.Thread(target=self.reader)
+        self.thread_read.daemon = True
+        self.thread_read.name = "serial->socket"
+        self.thread_read.start()
+        self.thread_poll = threading.Thread(target=self.statusline_poller)
+        self.thread_poll.daemon = True
+        self.thread_poll.name = "status line poll"
+        self.thread_poll.start()
+        self.writer()
+
+    def reader(self):
+        """loop forever and copy serial->socket"""
+        self.log.debug("reader thread started")
+        while self.alive:
+            try:
+                data = self.serial.read(self.serial.in_waiting or 1)
+                if data:
+                    # escape outgoing data when needed (Telnet IAC (0xff) character)
+                    self.write(b"".join(self.rfc2217.escape(data)))
+            except socket.error as msg:
+                self.log.error("{}".format(msg))
+                # probably got disconnected
+                break
+        self.alive = False
+        self.log.debug("reader thread terminated")
+
+    def write(self, data):
+        """thread safe socket write with no data escaping. used to send telnet stuff"""
+        with self._write_lock:
+            self.socket.sendall(data)
+
+    def writer(self):
+        """loop forever and copy socket->serial"""
+        while self.alive:
+            try:
+                data = self.socket.recv(1024)
+                if not data:
+                    break
+                self.serial.write(b"".join(self.rfc2217.filter(data)))
+            except socket.error as msg:
+                self.log.error("{}".format(msg))
+                # probably got disconnected
+                break
+        self.stop()
+
+    def stop(self):
+        """Stop copying"""
+        self.log.debug("stopping")
+        if self.alive:
+            self.alive = False
+            self.thread_read.join()
+            self.thread_poll.join()

esptool-4.9.0/esp_rfc2217_server.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+#
+# SPDX-FileCopyrightText: 2014-2024 Fredrik Ahlberg, Angus Gratton,
+# Espressif Systems (Shanghai) CO LTD, other contributors as noted.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+# This executable script is a thin wrapper around the main functionality
+# in the esp_rfc2217_server Python package
+
+# When updating this script, please also update esptool.py, espefuse.py and espsecure.py
+
+###################################################################################
+# Redirect data from a TCP/IP connection to a serial port and vice versa using RFC 2217.
+#
+# This is a modified version of rfc2217_server.py provided by the pyserial package
+# (pythonhosted.org/pyserial/examples.html#single-port-tcp-ip-serial-bridge-rfc-2217).
+# It uses a custom PortManager to properly apply the RTS & DTR signals
+# for resetting ESP chips.
+#
+# Run the following command on the server side to make
+# connection between /dev/ttyUSB1 and TCP port 4000:
+#
+#   python esp_rfc2217_server.py -p 4000 /dev/ttyUSB1
+#
+# Esptool can connect to the ESP device through that server as it is
+# demonstrated in the following example:
+#
+#   esptool.py --port rfc2217://localhost:4000?ign_set_control flash_id
+#
+
+import contextlib
+import os
+import sys
+
+if os.name != "nt":
+    # Linux/macOS: remove current script directory to avoid importing this file
+    # as a module; we want to import the installed esp_rfc2217_server module instead
+    with contextlib.suppress(ValueError):
+        executable_dir = os.path.dirname(sys.executable)
+        sys.path = [
+            path
+            for path in sys.path
+            if not path.endswith(("/bin", "/sbin")) and path != executable_dir
+        ]
+
+    # Linux/macOS: delete imported module entry to force Python to load
+    # the module from scratch; this enables importing esp_rfc2217_server module in
+    # other Python scripts
+    with contextlib.suppress(KeyError):
+        del sys.modules["esp_rfc2217_server"]
+
+import esp_rfc2217_server
+
+if __name__ == "__main__":
+    esp_rfc2217_server.main()

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/__init__.py

@@ -17,7 +17,9 @@ import espefuse.efuse.esp32c5beta3 as esp32c5beta3_efuse
 import espefuse.efuse.esp32c6 as esp32c6_efuse
 import espefuse.efuse.esp32c61 as esp32c61_efuse
 import espefuse.efuse.esp32h2 as esp32h2_efuse
+import espefuse.efuse.esp32h21 as esp32h21_efuse
 import espefuse.efuse.esp32h2beta1 as esp32h2beta1_efuse
+import espefuse.efuse.esp32h4 as esp32h4_efuse
 import espefuse.efuse.esp32p4 as esp32p4_efuse
 import espefuse.efuse.esp32s2 as esp32s2_efuse
 import espefuse.efuse.esp32s3 as esp32s3_efuse
@@ -61,6 +63,8 @@ SUPPORTED_CHIPS = {
         "ESP32-C5(beta3)", esp32c5beta3_efuse, esptool.targets.ESP32C5BETA3ROM
     ),
     "esp32h2": DefChip("ESP32-H2", esp32h2_efuse, esptool.targets.ESP32H2ROM),
+    "esp32h21": DefChip("ESP32-H21", esp32h21_efuse, esptool.targets.ESP32H21ROM),
+    "esp32h4": DefChip("ESP32-H4", esp32h4_efuse, esptool.targets.ESP32H4ROM),
     "esp32p4": DefChip("ESP32-P4", esp32p4_efuse, esptool.targets.ESP32P4ROM),
     "esp32h2beta1": DefChip(
         "ESP32-H2(beta1)", esp32h2beta1_efuse, esptool.targets.ESP32H2BETA1ROM

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/base_fields.py

@@ -653,6 +653,42 @@ class EspEfusesBase(object):
         # Overwrite this function for a specific target if you want to check if a certain eFuse(s) can be burned.
         return False
 
+    def get_major_chip_version(self):
+        try:
+            return self["WAFER_VERSION_MAJOR"].get()
+        except KeyError:
+            return 0
+
+    def get_minor_chip_version(self):
+        try:
+            return self["WAFER_VERSION_MINOR"].get()
+        except KeyError:
+            return 0
+
+    def get_chip_version(self):
+        return self.get_major_chip_version() * 100 + self.get_minor_chip_version()
+
+    def get_major_block_version(self):
+        try:
+            return self["BLK_VERSION_MAJOR"].get()
+        except KeyError:
+            return 0
+
+    def get_minor_block_version(self):
+        try:
+            return self["BLK_VERSION_MINOR"].get()
+        except KeyError:
+            return 0
+
+    def get_block_version(self):
+        return self.get_major_block_version() * 100 + self.get_minor_block_version()
+
+    def get_pkg_version(self):
+        try:
+            return self["PKG_VERSION"].get()
+        except KeyError:
+            return 0
+
 
 class EfuseFieldBase(EfuseProtectBase):
     def __init__(self, parent, param):

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32/operations.py

@@ -157,22 +157,27 @@ def set_flash_voltage(esp, efuses, args):
         )
 
     if args.voltage == "OFF":
-        msg = "Disable internal flash voltage regulator (VDD_SDIO). "
-        "SPI flash will need to be powered from an external source.\n"
-        "The following efuse is burned: XPD_SDIO_FORCE.\n"
-        "It is possible to later re-enable the internal regulator (%s) " % (
-            "to 3.3V" if sdio_tieh.get() != 0 else "to 1.8V or 3.3V"
+        print(
+            "Disable internal flash voltage regulator (VDD_SDIO). "
+            "SPI flash will need to be powered from an external source.\n"
+            "The following eFuse is burned: XPD_SDIO_FORCE.\n"
+            "It is possible to later re-enable the internal regulator"
+            f"{'to 3.3V' if sdio_tieh.get() != 0 else 'to 1.8V or 3.3V'}"
+            "by burning an additional eFuse"
         )
-        "by burning an additional efuse"
     elif args.voltage == "1.8V":
-        msg = "Set internal flash voltage regulator (VDD_SDIO) to 1.8V.\n"
-        "The following efuses are burned: XPD_SDIO_FORCE, XPD_SDIO_REG.\n"
-        "It is possible to later increase the voltage to 3.3V (permanently) "
-        "by burning additional efuse XPD_SDIO_TIEH"
+        print(
+            "Set internal flash voltage regulator (VDD_SDIO) to 1.8V.\n"
+            "The following eFuses are burned: XPD_SDIO_FORCE, XPD_SDIO_REG.\n"
+            "It is possible to later increase the voltage to 3.3V (permanently) "
+            "by burning additional eFuse XPD_SDIO_TIEH"
+        )
     elif args.voltage == "3.3V":
-        msg = "Enable internal flash voltage regulator (VDD_SDIO) to 3.3V.\n"
-        "The following efuses are burned: XPD_SDIO_FORCE, XPD_SDIO_REG, XPD_SDIO_TIEH."
-    print(msg)
+        print(
+            "Enable internal flash voltage regulator (VDD_SDIO) to 3.3V.\n"
+            "The following eFuses are burned: XPD_SDIO_FORCE, XPD_SDIO_REG, XPD_SDIO_TIEH."
+        )
+
     sdio_force.save(1)  # Disable GPIO12
     if args.voltage != "OFF":
         sdio_reg.save(1)  # Enable internal regulator
@@ -271,8 +276,10 @@ def burn_key(esp, efuses, args):
             "The key block will left readable and writeable (due to --no-protect-key)"
         )
     else:
-        msg += "The key block will be read and write protected "
-        "(no further changes or readback)"
+        msg += (
+            "The key block will be read and write protected "
+            "(no further changes or readback)"
+        )
     print(msg, "\n")
     if not efuses.burn_all(check_batch_mode=True):
         return

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32c2/fields.py

@@ -102,7 +102,7 @@ class EspEfuses(base_fields.EspEfusesBase):
                 for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
             ]
         else:
-            if self["BLK_VERSION_MINOR"].get() == 1:
+            if self.get_block_version() >= 1:
                 self.efuses += [
                     EfuseField.convert(self, efuse)
                     for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32c2/mem_definition.py

@@ -97,10 +97,7 @@ class EfuseDefineFields(EfuseFieldsBase):
     def __init__(self, extend_efuse_table) -> None:
         # List of efuse fields from TRM the chapter eFuse Controller.
         self.EFUSES = []
-
         self.KEYBLOCKS = []
-
-        # if BLK_VERSION_MINOR is 1, these efuse fields are in BLOCK2
         self.BLOCK2_CALIBRATION_EFUSES = []
 
         dir_name = os.path.dirname(os.path.abspath(__file__))

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32c2/operations.py

@@ -150,9 +150,9 @@ def set_flash_voltage(esp, efuses, args):
 
 
 def adc_info(esp, efuses, args):
-    print("")
     # fmt: off
-    if efuses["BLK_VERSION_MINOR"].get() == 1:
+    print("Block version:", efuses.get_block_version())
+    if efuses.get_block_version() >= 1:
         print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get()))
         print("ADC OCode        = ", efuses["OCODE"].get())
         print("ADC1:")
@@ -160,8 +160,6 @@ def adc_info(esp, efuses, args):
         print("INIT_CODE_ATTEN3 = ", efuses["ADC1_INIT_CODE_ATTEN3"].get())
         print("CAL_VOL_ATTEN0   = ", efuses["ADC1_CAL_VOL_ATTEN0"].get())
         print("CAL_VOL_ATTEN3   = ", efuses["ADC1_CAL_VOL_ATTEN3"].get())
-    else:
-        print("BLK_VERSION_MINOR = {}".format(efuses["BLK_VERSION_MINOR"].get_meaning()))
     # fmt: on
 
 

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32c3/fields.py

@@ -102,7 +102,7 @@ class EspEfuses(base_fields.EspEfusesBase):
                 for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
             ]
         else:
-            if self["BLK_VERSION_MAJOR"].get() == 1:
+            if self.get_block_version() >= 100:
                 self.efuses += [
                     EfuseField.convert(self, efuse)
                     for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32c3/mem_definition.py

@@ -130,12 +130,8 @@ class EfuseDefineFields(EfuseFieldsBase):
     def __init__(self, extend_efuse_table) -> None:
         # List of efuse fields from TRM the chapter eFuse Controller.
         self.EFUSES = []
-
         self.KEYBLOCKS = []
-
-        # if BLK_VERSION_MAJOR is 1, these efuse fields are in BLOCK2
         self.BLOCK2_CALIBRATION_EFUSES = []
-
         self.CALC = []
 
         dir_name = os.path.dirname(os.path.abspath(__file__))

{esptool-4.8.dev5 → esptool-4.9.0}/espefuse/efuse/esp32c3/operations.py

@@ -192,9 +192,9 @@ def set_flash_voltage(esp, efuses, args):
 
 
 def adc_info(esp, efuses, args):
-    print("")
     # fmt: off
-    if efuses["BLK_VERSION_MAJOR"].get() == 1:
+    print("Block version:", efuses.get_block_version())
+    if efuses.get_block_version() >= 100:
         print("Temperature Sensor Calibration = {}C".format(efuses["TEMP_CALIB"].get()))
         print("ADC OCode        = ", efuses["OCODE"].get())
         print("ADC1:")
@@ -206,8 +206,6 @@ def adc_info(esp, efuses, args):
         print("CAL_VOL_ATTEN1   = ", efuses["ADC1_CAL_VOL_ATTEN1"].get())
         print("CAL_VOL_ATTEN2   = ", efuses["ADC1_CAL_VOL_ATTEN2"].get())
         print("CAL_VOL_ATTEN3   = ", efuses["ADC1_CAL_VOL_ATTEN3"].get())
-    else:
-        print("BLK_VERSION_MAJOR = {}".format(efuses["BLK_VERSION_MAJOR"].get_meaning()))
     # fmt: on