esptool 4.9.dev1__tar.gz → 4.9.dev2__tar.gz

{esptool-4.9.dev1/esptool.egg-info → esptool-4.9.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esptool
-Version: 4.9.dev1
+Version: 4.9.dev2
 Summary: A serial utility to communicate & flash code to Espressif chips.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+

{esptool-4.9.dev1 → esptool-4.9.dev2}/esp_rfc2217_server/__init__.py

@@ -64,8 +64,7 @@ def main():
     level = (logging.WARNING, logging.INFO, logging.DEBUG, logging.NOTSET)[
         args.verbosity
     ]
-    logging.basicConfig(level=logging.INFO)
-    # logging.getLogger('root').setLevel(logging.INFO)
+    logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.INFO)
     logging.getLogger("rfc2217").setLevel(level)
 
     # connect to serial port
@@ -75,26 +74,42 @@ def main():
     ser.dtr = False
     ser.rts = False
 
-    logging.info(" RFC 2217 TCP/IP to Serial redirector - type Ctrl-C / BREAK to quit")
+    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(" Could not open serial port {}: {}".format(ser.name, e))
+        logging.error(f"Could not open serial port {ser.name}: {e}")
         sys.exit(1)
 
-    logging.info(" Serving serial port: {}".format(ser.name))
+    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(" TCP/IP port: {}".format(args.localport))
+    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:
-            client_socket, addr = srv.accept()
-            logging.info("Connected by {}:{}".format(addr[0], addr[1]))
+            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

{esptool-4.9.dev1 → esptool-4.9.dev2}/espefuse/efuse_defs/esp32s3.yaml

@@ -47,7 +47,7 @@ EFUSES:
   SECURE_BOOT_AGGRESSIVE_REVOKE    : {show: y, blk : 0, word: 3, pos: 21, len  : 1, start: 117, type      : bool, wr_dis  : 16, rd_dis: null, alt                            : '', dict             : '', desc: Set this bit to enable revoking aggressive secure boot, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[21]', bloc: 'B14[5]'}
   DIS_USB_JTAG                     : {show: y, blk : 0, word: 3, pos: 22, len  : 1, start: 118, type      : bool, wr_dis   : 2, rd_dis: null, alt                            : '', dict             : '', desc: Set this bit to disable function of usb switch to jtag in module of usb device, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[22]', bloc: 'B14[6]'}
   DIS_USB_SERIAL_JTAG              : {show: y, blk : 0, word: 3, pos: 23, len  : 1, start: 119, type      : bool, wr_dis   : 2, rd_dis: null, alt                : DIS_USB_DEVICE, dict             : '', desc: Set this bit to disable usb device, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[23]', bloc: 'B14[7]'}
-  STRAP_JTAG_SEL                   : {show: y, blk : 0, word: 3, pos: 24, len  : 1, start: 120, type      : bool, wr_dis   : 2, rd_dis: null, alt                            : '', dict             : '', desc: Set this bit to enable selection between usb_to_jtag and pad_to_jtag through strapping gpio10 when both reg_dis_usb_jtag and reg_dis_pad_jtag are equal to 0, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[24]', bloc: 'B15[0]'}
+  STRAP_JTAG_SEL                   : {show: y, blk : 0, word: 3, pos: 24, len  : 1, start: 120, type      : bool, wr_dis   : 2, rd_dis: null, alt                            : '', dict             : '', desc: Set this bit to enable selection between usb_to_jtag and pad_to_jtag through strapping gpio3 when both reg_dis_usb_jtag and reg_dis_pad_jtag are equal to 0, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[24]', bloc: 'B15[0]'}
   USB_PHY_SEL                      : {show: y, blk : 0, word: 3, pos: 25, len  : 1, start: 121, type      : bool, wr_dis   : 2, rd_dis: null, alt                            : '', dict: '{0: "internal PHY is assigned to USB Device while external PHY is assigned to USB OTG", 1: "internal PHY is assigned to USB OTG while external PHY is assigned to USB Device"}', desc: This bit is used to switch internal PHY and external PHY for USB OTG and USB Device, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[25]', bloc: 'B15[1]'}
   POWER_GLITCH_DSENSE              : {show: n, blk : 0, word: 3, pos: 26, len  : 2, start: 122, type  : 'uint:2', wr_dis  : 17, rd_dis: null, alt                            : '', dict             : '', desc: Sample delay configuration of power glitch, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[27:26]', bloc: 'B15[3:2]'}
   FLASH_TPUW                       : {show: y, blk : 0, word: 3, pos: 28, len  : 4, start: 124, type  : 'uint:4', wr_dis  : 18, rd_dis: null, alt                            : '', dict             : '', desc: Configures flash waiting time after power-up; in unit of ms. If the value is less than 15; the waiting time is the configurable value.  Otherwise; the waiting time is twice the configurable value, rloc: 'EFUSE_RD_REPEAT_DATA2_REG[31:28]', bloc: 'B15[7:4]'}

{esptool-4.9.dev1 → esptool-4.9.dev2}/esptool/__init__.py

@@ -29,7 +29,7 @@ __all__ = [
     "write_mem",
 ]
 
-__version__ = "4.9.dev1"
+__version__ = "4.9.dev2"
 
 import argparse
 import inspect

{esptool-4.9.dev1 → esptool-4.9.dev2}/esptool/bin_image.py

@@ -115,11 +115,10 @@ class ImageSegment(object):
     """Wrapper class for a segment in an ESP image
     (very similar to a section in an ELFImage also)"""
 
-    def __init__(self, addr, data, file_offs=None, flags=0):
+    def __init__(self, addr, data, file_offs=None):
         self.addr = addr
         self.data = data
         self.file_offs = file_offs
-        self.flags = flags
         self.include_in_checksum = True
         if self.addr != 0:
             self.pad_to_alignment(
@@ -168,8 +167,8 @@ class ELFSection(ImageSegment):
     """Wrapper class for a section in an ELF image, has a section
     name as well as the common properties of an ImageSegment."""
 
-    def __init__(self, name, addr, data, flags):
-        super(ELFSection, self).__init__(addr, data, flags=flags)
+    def __init__(self, name, addr, data):
+        super(ELFSection, self).__init__(addr, data)
         self.name = name.decode("utf-8")
 
     def __repr__(self):
@@ -179,9 +178,6 @@ class ELFSection(ImageSegment):
 class BaseFirmwareImage(object):
     SEG_HEADER_LEN = 8
     SHA256_DIGEST_LEN = 32
-    ELF_FLAG_WRITE = 0x1
-    ELF_FLAG_READ = 0x2
-    ELF_FLAG_EXEC = 0x4
 
     """ Base class with common firmware image functions """
 
@@ -377,8 +373,6 @@ class BaseFirmwareImage(object):
                     elem.get_memory_type(self) == next_elem.get_memory_type(self),
                     elem.include_in_checksum == next_elem.include_in_checksum,
                     next_elem.addr == elem.addr + len(elem.data),
-                    next_elem.flags & self.ELF_FLAG_EXEC
-                    == elem.flags & self.ELF_FLAG_EXEC,
                 )
             ):
                 # Merge any segment that ends where the next one starts,
@@ -1285,7 +1279,7 @@ class ELFFile(object):
             name_offs, sec_type, _flags, lma, sec_offs, size = struct.unpack_from(
                 "<LLLLLL", section_header[offs:]
             )
-            return (name_offs, sec_type, lma, size, sec_offs, _flags)
+            return (name_offs, sec_type, lma, size, sec_offs)
 
         all_sections = [read_section_header(offs) for offs in section_header_offsets]
         prog_sections = [s for s in all_sections if s[1] in ELFFile.PROG_SEC_TYPES]
@@ -1294,7 +1288,7 @@ class ELFFile(object):
         # search for the string table section
         if (shstrndx * self.LEN_SEC_HEADER) not in section_header_offsets:
             raise FatalError("ELF file has no STRTAB section at shstrndx %d" % shstrndx)
-        _, sec_type, _, sec_size, sec_offs, _ = read_section_header(
+        _, sec_type, _, sec_size, sec_offs = read_section_header(
             shstrndx * self.LEN_SEC_HEADER
         )
         if sec_type != ELFFile.SEC_TYPE_STRTAB:
@@ -1316,14 +1310,14 @@ class ELFFile(object):
             return f.read(size)
 
         prog_sections = [
-            ELFSection(lookup_string(n_offs), lma, read_data(offs, size), flags=_flags)
-            for (n_offs, _type, lma, size, offs, _flags) in prog_sections
+            ELFSection(lookup_string(n_offs), lma, read_data(offs, size))
+            for (n_offs, _type, lma, size, offs) in prog_sections
             if lma != 0 and size > 0
         ]
         self.sections = prog_sections
         self.nobits_sections = [
-            ELFSection(lookup_string(n_offs), lma, b"", flags=_flags)
-            for (n_offs, _type, lma, size, offs, _flags) in nobits_secitons
+            ELFSection(lookup_string(n_offs), lma, b"")
+            for (n_offs, _type, lma, size, offs) in nobits_secitons
             if lma != 0 and size > 0
         ]
 
@@ -1356,7 +1350,7 @@ class ELFFile(object):
                 _flags,
                 _align,
             ) = struct.unpack_from("<LLLLLLLL", segment_header[offs:])
-            return (seg_type, lma, size, seg_offs, _flags)
+            return (seg_type, lma, size, seg_offs)
 
         all_segments = [read_segment_header(offs) for offs in segment_header_offsets]
         prog_segments = [s for s in all_segments if s[0] == ELFFile.SEG_TYPE_LOAD]
@@ -1366,8 +1360,8 @@ class ELFFile(object):
             return f.read(size)
 
         prog_segments = [
-            ELFSection(b"PHDR", lma, read_data(offs, size), flags=_flags)
-            for (_type, lma, size, offs, _flags) in prog_segments
+            ELFSection(b"PHDR", lma, read_data(offs, size))
+            for (_type, lma, size, offs) in prog_segments
             if lma != 0 and size > 0
         ]
         self.segments = prog_segments

{esptool-4.9.dev1 → esptool-4.9.dev2}/esptool/cmds.py

@@ -724,7 +724,7 @@ def write_flash(esp, args):
                     print("Flash md5: %s" % res)
                     print(
                         "MD5 of 0xFF is %s"
-                        % (hashlib.md5(b"\xff" * uncsize).hexdigest())
+                        % (hashlib.md5(b"\xFF" * uncsize).hexdigest())
                     )
                     raise FatalError("MD5 of file does not match data in flash!")
                 else:
@@ -1457,7 +1457,7 @@ def merge_bin(args):
 
             def pad_to(flash_offs):
                 # account for output file offset if there is any
-                of.write(b"\xff" * (flash_offs - args.target_offset - of.tell()))
+                of.write(b"\xFF" * (flash_offs - args.target_offset - of.tell()))
 
             for addr, argfile in input_files:
                 pad_to(addr)

{esptool-4.9.dev1 → esptool-4.9.dev2}/esptool/targets/esp32c5.py

@@ -54,8 +54,8 @@ class ESP32C5ROM(ESP32C6ROM):
 
     UARTDEV_BUF_NO = 0x4085F51C  # Variable in ROM .bss which indicates the port in use
 
-    # Magic value for ESP32C5
-    CHIP_DETECT_MAGIC_VALUE = [0x1101406F]
+    # Magic values for ESP32C5 ECO0 and ECO1, respectively
+    CHIP_DETECT_MAGIC_VALUE = [0x1101406F, 0x63E1406F]
 
     FLASH_FREQUENCY = {
         "80m": 0xF,

{esptool-4.9.dev1 → esptool-4.9.dev2}/esptool/targets/esp32c6.py

@@ -6,6 +6,7 @@
 import struct
 
 from .esp32c3 import ESP32C3ROM
+from ..loader import ESPLoader
 from ..util import FatalError, NotImplementedInROMError
 
 
@@ -194,6 +195,11 @@ class ESP32C6ROM(ESP32C3ROM):
                 "consider using other pins for SPI flash connection."
             )
 
+    def hard_reset(self):
+        # Bug in the USB-Serial/JTAG controller can cause the port to disappear
+        # if the chip is reset with RTC WDT, do a classic reset
+        ESPLoader.hard_reset(self)
+
 
 class ESP32C6StubLoader(ESP32C6ROM):
     """Access class for ESP32C6 stub loader, runs on top of ROM.

{esptool-4.9.dev1 → esptool-4.9.dev2}/esptool/targets/esp32h2.py

@@ -80,6 +80,7 @@ class ESP32H2ROM(ESP32C6ROM):
         return 32
 
     def hard_reset(self):
+        # RTC WDT reset not available, do a classic reset
         ESPLoader.hard_reset(self)
 
     def check_spi_connection(self, spi_connection):

{esptool-4.9.dev1 → esptool-4.9.dev2/esptool.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esptool
-Version: 4.9.dev1
+Version: 4.9.dev2
 Summary: A serial utility to communicate & flash code to Espressif chips.
 Author: Fredrik Ahlberg (themadinventor), Angus Gratton (projectgus), Espressif Systems
 License: GPLv2+