""" Scales timeouts which are size-specific """

result = seconds_per_mb * (size_bytes / 1e6)

if result < DEFAULT_TIMEOUT:

return DEFAULT_TIMEOUT

"""

def inner(*args, **kwargs):

obj = args[0]

if check_func(obj):

return func(*args, **kwargs)

else:

raise NotImplementedInROMError(obj, func)

""" Base class providing access to ESP ROM & softtware stub bootloaders.

CHIP_NAME = "Espressif device"

IS_STUB = False

DEFAULT_PORT = "/dev/ttyUSB0"

# Commands supported by ESP8266 ROM bootloader

ESP_FLASH_BEGIN = 0x02

ESP_FLASH_DATA = 0x03

ESP_FLASH_END = 0x04

ESP_MEM_BEGIN = 0x05

ESP_MEM_END = 0x06

ESP_MEM_DATA = 0x07

ESP_SYNC = 0x08

ESP_WRITE_REG = 0x09

ESP_READ_REG = 0x0a

# Some comands supported by ESP32 ROM bootloader (or -8266 w/ stub)

ESP_SPI_SET_PARAMS = 0x0B

ESP_SPI_ATTACH = 0x0D

ESP_CHANGE_BAUDRATE = 0x0F

ESP_FLASH_DEFL_BEGIN = 0x10

ESP_FLASH_DEFL_DATA = 0x11

ESP_FLASH_DEFL_END = 0x12

ESP_SPI_FLASH_MD5 = 0x13

# Some commands supported by stub only

ESP_ERASE_FLASH = 0xD0

ESP_ERASE_REGION = 0xD1

ESP_READ_FLASH = 0xD2

ESP_RUN_USER_CODE = 0xD3

# Maximum block sized for RAM and Flash writes, respectively.

ESP_RAM_BLOCK = 0x1800

FLASH_WRITE_SIZE = 0x400

# Default baudrate. The ROM auto-bauds, so we can use more or less whatever we want.

ESP_ROM_BAUD = 115200

# First byte of the application image

ESP_IMAGE_MAGIC = 0xe9

# Initial state for the checksum routine

ESP_CHECKSUM_MAGIC = 0xef

# Flash sector size, minimum unit of erase.

FLASH_SECTOR_SIZE = 0x1000

UART_DATA_REG_ADDR = 0x60000078

# Memory addresses

IROM_MAP_START = 0x40200000

IROM_MAP_END = 0x40300000

# The number of bytes in the UART response that signify command status

STATUS_BYTES_LENGTH = 2

def __init__(self, port=DEFAULT_PORT, baud=ESP_ROM_BAUD, trace_enabled=False):

"""Base constructor for ESPLoader bootloader interaction

if isinstance(port, serial.Serial):

self._port = port

else:

self._port = serial.serial_for_url(port)

self._slip_reader = slip_reader(self._port, self.trace)

# setting baud rate in a separate step is a workaround for

# CH341 driver on some Linux versions (this opens at 9600 then

# sets), shouldn't matter for other platforms/drivers. See

# https://github.com/espressif/esptool/issues/44#issuecomment-107094446

self._set_port_baudrate(baud)

self._trace_enabled = trace_enabled

def _set_port_baudrate(self, baud):

try:

self._port.baudrate = baud

except IOError:

raise FatalError("Failed to set baud rate %d. The driver may not support this rate." % baud)

@staticmethod

def detect_chip(port=DEFAULT_PORT, baud=ESP_ROM_BAUD, connect_mode='default_reset', trace_enabled=False):

""" Use serial access to detect the chip type.

detect_port = ESPLoader(port, baud, trace_enabled=trace_enabled)

detect_port.connect(connect_mode)

print('Detecting chip type...', end='')

sys.stdout.flush()

date_reg = detect_port.read_reg(ESPLoader.UART_DATA_REG_ADDR)

for cls in [ESP8266ROM, ESP32ROM]:

if date_reg == cls.DATE_REG_VALUE:

# don't connect a second time

inst = cls(detect_port._port, baud, trace_enabled=trace_enabled)

print(' %s' % inst.CHIP_NAME)

return inst

print('')

raise FatalError("Unexpected UART datecode value 0x%08x. Failed to autodetect chip type." % date_reg)

""" Read a SLIP packet from the serial port """

def read(self):

return next(self._slip_reader)

""" Write bytes to the serial port while performing SLIP escaping """

def write(self, packet):

buf = b'\xc0' \

+ (packet.replace(b'\xdb',b'\xdb\xdd').replace(b'\xc0',b'\xdb\xdc')) \

+ b'\xc0'

self.trace("Write %d bytes: %r", len(buf), buf)

self._port.write(buf)

def trace(self, message, *format_args):

if self._trace_enabled:

now = time.time()

try:

delta = now - self._last_trace

except AttributeError:

delta = 0.0

self._last_trace = now

prefix = "TRACE +%.3f " % delta

print(prefix + (message % format_args))

""" Calculate checksum of a blob, as it is defined by the ROM """

@staticmethod

def checksum(data, state=ESP_CHECKSUM_MAGIC):

for b in data:

if type(b) is int: # python 2/3 compat

state ^= b

else:

state ^= ord(b)

return state

""" Send a request and read the response """

def command(self, op=None, data=b"", chk=0, wait_response=True, timeout=DEFAULT_TIMEOUT):

if op is not None:

self.trace("command op=0x%02x data len=%s wait_response=%d timeout=%.3f data=%r",

op, len(data), 1 if wait_response else 0, timeout, data)

pkt = struct.pack(b'<BBHI', 0x00, op, len(data), chk) + data

self.write(pkt)

if not wait_response:

return

saved_timeout = self._port.timeout

self._port.timeout = min(timeout, MAX_TIMEOUT)

try:

# tries to get a response until that response has the

# same operation as the request or a retries limit has

# exceeded. This is needed for some esp8266s that

# reply with more sync responses than expected.

for retry in range(100):

p = self.read()

if len(p) < 8:

continue

(resp, op_ret, len_ret, val) = struct.unpack('<BBHI', p[:8])

if resp != 1:

continue

data = p[8:]

if op is None or op_ret == op:

return val, data

finally:

self._port.timeout = saved_timeout

raise FatalError("Response doesn't match request")

def check_command(self, op_description, op=None, data=b'', chk=0, timeout=DEFAULT_TIMEOUT):

"""

val, data = self.command(op, data, chk, timeout=timeout)

# things are a bit weird here, bear with us

# the status bytes are the last 2/4 bytes in the data (depending on chip)

if len(data) < self.STATUS_BYTES_LENGTH:

raise FatalError("Failed to %s. Only got %d byte status response." % (op_description, len(data)))

status_bytes = data[-self.STATUS_BYTES_LENGTH:]

# we only care if the first one is non-zero. If it is, the second byte is a reason.

if byte(status_bytes, 0) != 0:

raise FatalError.WithResult('Failed to %s' % op_description, status_bytes)

# if we had more data than just the status bytes, return it as the result

# (this is used by the md5sum command, maybe other commands?)

if len(data) > self.STATUS_BYTES_LENGTH:

return data[:-self.STATUS_BYTES_LENGTH]

else: # otherwise, just return the 'val' field which comes from the reply header (this is used by read_reg)

return val

def flush_input(self):

self._port.flushInput()

self._slip_reader = slip_reader(self._port, self.trace)

def sync(self):

self.command(self.ESP_SYNC, b'\x07\x07\x12\x20' + 32 * b'\x55',

timeout=SYNC_TIMEOUT)

for i in range(7):

self.command()

def _connect_attempt(self, mode='default_reset', esp32r0_delay=False):

""" A single connection attempt, with esp32r0 workaround options """

# esp32r0_delay is a workaround for bugs with the most common auto reset

# circuit and Windows, if the EN pin on the dev board does not have

# enough capacitance.

#

# Newer dev boards shouldn't have this problem (higher value capacitor

# on the EN pin), and ESP32 revision 1 can't use this workaround as it

# relies on a silicon bug.

#

# Details: https://github.com/espressif/esptool/issues/136

last_error = None

# issue reset-to-bootloader:

# RTS = either CH_PD/EN or nRESET (both active low = chip in reset

# DTR = GPIO0 (active low = boot to flasher)

#

# DTR & RTS are active low signals,

# ie True = pin @ 0V, False = pin @ VCC.

if mode != 'no_reset':

self._port.setDTR(False) # IO0=HIGH

self._port.setRTS(True) # EN=LOW, chip in reset

time.sleep(0.1)

if esp32r0_delay:

# Some chips are more likely to trigger the esp32r0

# watchdog reset silicon bug if they're held with EN=LOW

# for a longer period

time.sleep(1.2)

self._port.setDTR(True) # IO0=LOW

self._port.setRTS(False) # EN=HIGH, chip out of reset

if esp32r0_delay:

# Sleep longer after reset.

# This workaround only works on revision 0 ESP32 chips,

# it exploits a silicon bug spurious watchdog reset.

time.sleep(0.4) # allow watchdog reset to occur

time.sleep(0.05)

self._port.setDTR(False) # IO0=HIGH, done

for _ in range(5):

try:

self.flush_input()

self._port.flushOutput()

self.sync()

return None

except FatalError as e:

if esp32r0_delay:

print('_', end='')

else:

print('.', end='')

sys.stdout.flush()

time.sleep(0.05)

last_error = e

return last_error

def connect(self, mode='default_reset'):

""" Try connecting repeatedly until successful, or giving up """

print('Connecting...', end='')

sys.stdout.flush()

last_error = None

try:

for _ in range(10):

last_error = self._connect_attempt(mode=mode, esp32r0_delay=False)

if last_error is None:

return

last_error = self._connect_attempt(mode=mode, esp32r0_delay=True)

if last_error is None:

return

finally:

print('') # end 'Connecting...' line

raise FatalError('Failed to connect to %s: %s' % (self.CHIP_NAME, last_error))

""" Read memory address in target """

def read_reg(self, addr):

# we don't call check_command here because read_reg() function is called

# when detecting chip type, and the way we check for success (STATUS_BYTES_LENGTH) is different

# for different chip types (!)

val, data = self.command(self.ESP_READ_REG, struct.pack('<I', addr))

if byte(data, 0) != 0:

raise FatalError.WithResult("Failed to read register address %08x" % addr, data)

return val

""" Write to memory address in target """

def write_reg(self, addr, value, mask=0xFFFFFFFF, delay_us=0):

return self.check_command("write target memory", self.ESP_WRITE_REG,

struct.pack('<IIII', addr, value, mask, delay_us))

""" Start downloading an application image to RAM """

def mem_begin(self, size, blocks, blocksize, offset):

return self.check_command("enter RAM download mode", self.ESP_MEM_BEGIN,

struct.pack('<IIII', size, blocks, blocksize, offset))

""" Send a block of an image to RAM """

def mem_block(self, data, seq):

return self.check_command("write to target RAM", self.ESP_MEM_DATA,

struct.pack('<IIII', len(data), seq, 0, 0) + data,

self.checksum(data))

""" Leave download mode and run the application """

def mem_finish(self, entrypoint=0):

return self.check_command("leave RAM download mode", self.ESP_MEM_END,

struct.pack('<II', int(entrypoint == 0), entrypoint))

""" Start downloading to Flash (performs an erase)

def flash_begin(self, size, offset):

num_blocks = (size + self.FLASH_WRITE_SIZE - 1) // self.FLASH_WRITE_SIZE

erase_size = self.get_erase_size(offset, size)

t = time.time()

if self.IS_STUB:

timeout = DEFAULT_TIMEOUT

else:

timeout = timeout_per_mb(ERASE_REGION_TIMEOUT_PER_MB, size) # ROM performs the erase up front

self.check_command("enter Flash download mode", self.ESP_FLASH_BEGIN,

struct.pack('<IIII', erase_size, num_blocks, self.FLASH_WRITE_SIZE, offset),

timeout=timeout)

if size != 0 and not self.IS_STUB:

print("Took %.2fs to erase flash block" % (time.time() - t))

return num_blocks

""" Write block to flash """

def flash_block(self, data, seq, timeout=DEFAULT_TIMEOUT):

self.check_command("write to target Flash after seq %d" % seq,

self.ESP_FLASH_DATA,

struct.pack('<IIII', len(data), seq, 0, 0) + data,

self.checksum(data),

timeout=timeout)

""" Leave flash mode and run/reboot """

def flash_finish(self, reboot=False):

pkt = struct.pack('<I', int(not reboot))

# stub sends a reply to this command

self.check_command("leave Flash mode", self.ESP_FLASH_END, pkt)

""" Run application code in flash """

def run(self, reboot=False):

# Fake flash begin immediately followed by flash end

self.flash_begin(0, 0)

self.flash_finish(reboot)

""" Read SPI flash manufacturer and device id """

def flash_id(self):

SPIFLASH_RDID = 0x9F

return self.run_spiflash_command(SPIFLASH_RDID, b"", 24)

def parse_flash_size_arg(self, arg):

try:

return self.FLASH_SIZES[arg]

except KeyError:

raise FatalError("Flash size '%s' is not supported by this chip type. Supported sizes: %s"

% (arg, ", ".join(self.FLASH_SIZES.keys())))

def run_stub(self, stub=None):

if stub is None:

if self.IS_STUB:

raise FatalError("Not possible for a stub to load another stub (memory likely to overlap.)")

stub = self.STUB_CODE

# Upload

print("Uploading stub...")

for field in ['text', 'data']:

if field in stub:

offs = stub[field + "_start"]

length = len(stub[field])

blocks = (length + self.ESP_RAM_BLOCK - 1) // self.ESP_RAM_BLOCK

self.mem_begin(length, blocks, self.ESP_RAM_BLOCK, offs)

for seq in range(blocks):

from_offs = seq * self.ESP_RAM_BLOCK

to_offs = from_offs + self.ESP_RAM_BLOCK

self.mem_block(stub[field][from_offs:to_offs], seq)

print("Running stub...")

self.mem_finish(stub['entry'])

p = self.read()

if p != b'OHAI':

raise FatalError("Failed to start stub. Unexpected response: %s" % p)

print("Stub running...")

return self.STUB_CLASS(self)

@stub_and_esp32_function_only

def flash_defl_begin(self, size, compsize, offset):

""" Start downloading compressed data to Flash (performs an erase)

num_blocks = (compsize + self.FLASH_WRITE_SIZE - 1) // self.FLASH_WRITE_SIZE

erase_blocks = (size + self.FLASH_WRITE_SIZE - 1) // self.FLASH_WRITE_SIZE

t = time.time()

if self.IS_STUB:

write_size = size # stub expects number of bytes here, manages erasing internally

timeout = DEFAULT_TIMEOUT

else:

write_size = erase_blocks * self.FLASH_WRITE_SIZE # ROM expects rounded up to erase block size

timeout = timeout_per_mb(ERASE_REGION_TIMEOUT_PER_MB, write_size) # ROM performs the erase up front

print("Compressed %d bytes to %d..." % (size, compsize))

self.check_command("enter compressed flash mode", self.ESP_FLASH_DEFL_BEGIN,

struct.pack('<IIII', write_size, num_blocks, self.FLASH_WRITE_SIZE, offset),

timeout=timeout)

if size != 0 and not self.IS_STUB:

# (stub erases as it writes, but ROM loaders erase on begin)

print("Took %.2fs to erase flash block" % (time.time() - t))

return num_blocks

""" Write block to flash, send compressed """

@stub_and_esp32_function_only

def flash_defl_block(self, data, seq, timeout=DEFAULT_TIMEOUT):

self.check_command("write compressed data to flash after seq %d" % seq,

self.ESP_FLASH_DEFL_DATA, struct.pack('<IIII', len(data), seq, 0, 0) + data, self.checksum(data), timeout=timeout)

""" Leave compressed flash mode and run/reboot """

@stub_and_esp32_function_only

def flash_defl_finish(self, reboot=False):

if not reboot and not self.IS_STUB:

# skip sending flash_finish to ROM loader, as this

# exits the bootloader. Stub doesn't do this.

return

pkt = struct.pack('<I', int(not reboot))

self.check_command("leave compressed flash mode", self.ESP_FLASH_DEFL_END, pkt)

self.in_bootloader = False

@stub_and_esp32_function_only

def flash_md5sum(self, addr, size):

# the MD5 command returns additional bytes in the standard

# command reply slot

timeout = timeout_per_mb(MD5_TIMEOUT_PER_MB, size)

res = self.check_command('calculate md5sum', self.ESP_SPI_FLASH_MD5, struct.pack('<IIII', addr, size, 0, 0),

timeout=timeout)

if len(res) == 32:

return res.decode("utf-8") # already hex formatted

elif len(res) == 16:

return hexify(res).lower()

else:

raise FatalError("MD5Sum command returned unexpected result: %r" % res)

@stub_and_esp32_function_only

def change_baud(self, baud):

print("Changing baud rate to %d" % baud)

# stub takes the new baud rate and the old one

second_arg = self._port.baudrate if self.IS_STUB else 0

self.command(self.ESP_CHANGE_BAUDRATE, struct.pack('<II', baud, second_arg))

print("Changed.")

self._set_port_baudrate(baud)

time.sleep(0.05) # get rid of crap sent during baud rate change

self.flush_input()

@stub_function_only

def erase_flash(self):

# depending on flash chip model the erase may take this long (maybe longer!)

self.check_command("erase flash", self.ESP_ERASE_FLASH,

timeout=CHIP_ERASE_TIMEOUT)

@stub_function_only

def erase_region(self, offset, size):

if offset % self.FLASH_SECTOR_SIZE != 0:

raise FatalError("Offset to erase from must be a multiple of 4096")

if size % self.FLASH_SECTOR_SIZE != 0:

raise FatalError("Size of data to erase must be a multiple of 4096")

timeout = timeout_per_mb(ERASE_REGION_TIMEOUT_PER_MB, size)

self.check_command("erase region", self.ESP_ERASE_REGION, struct.pack('<II', offset, size), timeout=timeout)

@stub_function_only

def read_flash(self, offset, length, progress_fn=None):

# issue a standard bootloader command to trigger the read

self.check_command("read flash", self.ESP_READ_FLASH,

struct.pack('<IIII',

offset,

length,

self.FLASH_SECTOR_SIZE,

64))

# now we expect (length // block_size) SLIP frames with the data

data = b''

while len(data) < length:

p = self.read()

data += p

self.write(struct.pack('<I', len(data)))

if progress_fn and (len(data) % 1024 == 0 or len(data) == length):

progress_fn(len(data), length)

if progress_fn:

progress_fn(len(data), length)

if len(data) > length:

raise FatalError('Read more than expected')

digest_frame = self.read()

if len(digest_frame) != 16:

raise FatalError('Expected digest, got: %s' % hexify(digest_frame))

expected_digest = hexify(digest_frame).upper()

digest = hashlib.md5(data).hexdigest().upper()

if digest != expected_digest:

raise FatalError('Digest mismatch: expected %s, got %s' % (expected_digest, digest))

return data

def flash_spi_attach(self, hspi_arg):

"""Send SPI attach command to enable the SPI flash pins

# last 3 bytes in ESP_SPI_ATTACH argument are reserved values

arg = struct.pack('<I', hspi_arg)

if not self.IS_STUB:

# ESP32 ROM loader takes additional 'is legacy' arg, which is not

# currently supported in the stub loader or esptool.py (as it's not usually needed.)

is_legacy = 0

arg += struct.pack('BBBB', is_legacy, 0, 0, 0)

self.check_command("configure SPI flash pins", ESP32ROM.ESP_SPI_ATTACH, arg)

def flash_set_parameters(self, size):

"""Tell the ESP bootloader the parameters of the chip

fl_id = 0

total_size = size

block_size = 64 * 1024

sector_size = 4 * 1024

page_size = 256

status_mask = 0xffff

self.check_command("set SPI params", ESP32ROM.ESP_SPI_SET_PARAMS,

struct.pack('<IIIIII', fl_id, total_size, block_size, sector_size, page_size, status_mask))

def run_spiflash_command(self, spiflash_command, data=b"", read_bits=0):

"""Run an arbitrary SPI flash command.

# SPI_USR register flags

SPI_USR_COMMAND = (1 << 31)

SPI_USR_MISO = (1 << 28)

SPI_USR_MOSI = (1 << 27)

# SPI registers, base address differs ESP32 vs 8266

base = self.SPI_REG_BASE

SPI_CMD_REG = base + 0x00

SPI_USR_REG = base + 0x1C

SPI_USR1_REG = base + 0x20

SPI_USR2_REG = base + 0x24

SPI_W0_REG = base + self.SPI_W0_OFFS

# following two registers are ESP32 only

if self.SPI_HAS_MOSI_DLEN_REG:

# ESP32 has a more sophisticated wayto set up "user" commands

def set_data_lengths(mosi_bits, miso_bits):

SPI_MOSI_DLEN_REG = base + 0x28

SPI_MISO_DLEN_REG = base + 0x2C

if mosi_bits > 0:

self.write_reg(SPI_MOSI_DLEN_REG, mosi_bits - 1)

if miso_bits > 0:

self.write_reg(SPI_MISO_DLEN_REG, miso_bits - 1)

else:

def set_data_lengths(mosi_bits, miso_bits):

SPI_DATA_LEN_REG = SPI_USR1_REG

SPI_MOSI_BITLEN_S = 17

SPI_MISO_BITLEN_S = 8

mosi_mask = 0 if (mosi_bits == 0) else (mosi_bits - 1)

miso_mask = 0 if (miso_bits == 0) else (miso_bits - 1)

self.write_reg(SPI_DATA_LEN_REG,

(miso_mask << SPI_MISO_BITLEN_S) | (

mosi_mask << SPI_MOSI_BITLEN_S))

# SPI peripheral "command" bitmasks for SPI_CMD_REG

SPI_CMD_USR = (1 << 18)

# shift values

SPI_USR2_DLEN_SHIFT = 28

if read_bits > 32:

raise FatalError("Reading more than 32 bits back from a SPI flash operation is unsupported")

if len(data) > 64:

raise FatalError("Writing more than 64 bytes of data with one SPI command is unsupported")

data_bits = len(data) * 8

old_spi_usr = self.read_reg(SPI_USR_REG)

old_spi_usr2 = self.read_reg(SPI_USR2_REG)

flags = SPI_USR_COMMAND

if read_bits > 0:

flags |= SPI_USR_MISO

if data_bits > 0:

flags |= SPI_USR_MOSI

set_data_lengths(data_bits, read_bits)

self.write_reg(SPI_USR_REG, flags)

self.write_reg(SPI_USR2_REG,

(7 << SPI_USR2_DLEN_SHIFT) | spiflash_command)

if data_bits == 0:

self.write_reg(SPI_W0_REG, 0) # clear data register before we read it

else:

data = pad_to(data, 4, b'\00') # pad to 32-bit multiple

words = struct.unpack("I" * (len(data) // 4), data)

next_reg = SPI_W0_REG

for word in words:

self.write_reg(next_reg, word)

next_reg += 4

self.write_reg(SPI_CMD_REG, SPI_CMD_USR)

def wait_done():

for _ in range(10):

if (self.read_reg(SPI_CMD_REG) & SPI_CMD_USR) == 0:

return

raise FatalError("SPI command did not complete in time")

wait_done()

status = self.read_reg(SPI_W0_REG)

# restore some SPI controller registers

self.write_reg(SPI_USR_REG, old_spi_usr)

self.write_reg(SPI_USR2_REG, old_spi_usr2)

return status

def read_status(self, num_bytes=2):

"""Read up to 24 bits (num_bytes) of SPI flash status register contents

SPIFLASH_RDSR = 0x05

SPIFLASH_RDSR2 = 0x35

SPIFLASH_RDSR3 = 0x15

status = 0

shift = 0

for cmd in [SPIFLASH_RDSR, SPIFLASH_RDSR2, SPIFLASH_RDSR3][0:num_bytes]:

status += self.run_spiflash_command(cmd, read_bits=8) << shift

shift += 8

return status

def write_status(self, new_status, num_bytes=2, set_non_volatile=False):

"""Write up to 24 bits (num_bytes) of new status register

SPIFLASH_WRSR = 0x01

SPIFLASH_WRSR2 = 0x31

SPIFLASH_WRSR3 = 0x11

SPIFLASH_WEVSR = 0x50

SPIFLASH_WREN = 0x06

SPIFLASH_WRDI = 0x04

enable_cmd = SPIFLASH_WREN if set_non_volatile else SPIFLASH_WEVSR

# try using a 16-bit WRSR (not supported by all chips)

# this may be redundant, but shouldn't hurt

if num_bytes == 2:

self.run_spiflash_command(enable_cmd)

self.run_spiflash_command(SPIFLASH_WRSR, struct.pack("<H", new_status))

# also try using individual commands (also not supported by all chips for num_bytes 2 & 3)

for cmd in [SPIFLASH_WRSR, SPIFLASH_WRSR2, SPIFLASH_WRSR3][0:num_bytes]:

self.run_spiflash_command(enable_cmd)

self.run_spiflash_command(cmd, struct.pack("B", new_status & 0xFF))

new_status >>= 8

self.run_spiflash_command(SPIFLASH_WRDI)

def hard_reset(self):

self._port.setRTS(True) # EN->LOW

time.sleep(0.1)

self._port.setRTS(False)

def soft_reset(self, stay_in_bootloader):

if not self.IS_STUB:

if stay_in_bootloader:

return # ROM bootloader is already in bootloader!

else:

# 'run user code' is as close to a soft reset as we can do

self.flash_begin(0, 0)

self.flash_finish(False)

else:

if stay_in_bootloader:

# soft resetting from the stub loader

# will re-load the ROM bootloader

self.flash_begin(0, 0)

self.flash_finish(True)

elif self.CHIP_NAME != "ESP8266":

raise FatalError("Soft resetting is currently only supported on ESP8266")

else:

# running user code from stub loader requires some hacks

# in the stub loader

""" Access class for ESP8266 ROM bootloader

CHIP_NAME = "ESP8266"

IS_STUB = False

DATE_REG_VALUE = 0x00062000

# OTP ROM addresses

ESP_OTP_MAC0 = 0x3ff00050

ESP_OTP_MAC1 = 0x3ff00054

ESP_OTP_MAC3 = 0x3ff0005c

SPI_REG_BASE = 0x60000200

SPI_W0_OFFS = 0x40

SPI_HAS_MOSI_DLEN_REG = False

FLASH_SIZES = {

'512KB':0x00,

'256KB':0x10,

'1MB':0x20,

'2MB':0x30,

'4MB':0x40,

'2MB-c1': 0x50,

'4MB-c1':0x60,

'8MB':0x80,

'16MB':0x90,

}

BOOTLOADER_FLASH_OFFSET = 0

def get_efuses(self):

# Return the 128 bits of ESP8266 efuse as a single Python integer

return (self.read_reg(0x3ff0005c) << 96 |

self.read_reg(0x3ff00058) << 64 |

self.read_reg(0x3ff00054) << 32 |

self.read_reg(0x3ff00050))

def get_chip_description(self):

efuses = self.get_efuses()

is_8285 = (efuses & ((1 << 4) | 1 << 80)) != 0 # One or the other efuse bit is set for ESP8285

return "ESP8285" if is_8285 else "ESP8266EX"

def flash_spi_attach(self, hspi_arg):

if self.IS_STUB:

super(ESP8266ROM, self).flash_spi_attach(hspi_arg)

else:

# ESP8266 ROM has no flash_spi_attach command in serial protocol,

# but flash_begin will do it

self.flash_begin(0, 0)

def flash_set_parameters(self, size):

# not implemented in ROM, but OK to silently skip for ROM

if self.IS_STUB:

super(ESP8266ROM, self).flash_set_parameters(size)

def chip_id(self):

""" Read Chip ID from OTP ROM - see http://esp8266-re.foogod.com/wiki/System_get_chip_id_%28IoT_RTOS_SDK_0.9.9%29 """

id0 = self.read_reg(self.ESP_OTP_MAC0)

id1 = self.read_reg(self.ESP_OTP_MAC1)

return (id0 >> 24) | ((id1 & MAX_UINT24) << 8)

def read_mac(self):

""" Read MAC from OTP ROM """

mac0 = self.read_reg(self.ESP_OTP_MAC0)

mac1 = self.read_reg(self.ESP_OTP_MAC1)

mac3 = self.read_reg(self.ESP_OTP_MAC3)

if (mac3 != 0):

oui = ((mac3 >> 16) & 0xff, (mac3 >> 8) & 0xff, mac3 & 0xff)

elif ((mac1 >> 16) & 0xff) == 0:

oui = (0x18, 0xfe, 0x34)

elif ((mac1 >> 16) & 0xff) == 1:

oui = (0xac, 0xd0, 0x74)

else:

raise FatalError("Unknown OUI")

return oui + ((mac1 >> 8) & 0xff, mac1 & 0xff, (mac0 >> 24) & 0xff)

def get_erase_size(self, offset, size):

""" Calculate an erase size given a specific size in bytes.

sectors_per_block = 16

sector_size = self.FLASH_SECTOR_SIZE

num_sectors = (size + sector_size - 1) // sector_size

start_sector = offset // sector_size

head_sectors = sectors_per_block - (start_sector % sectors_per_block)

if num_sectors < head_sectors:

head_sectors = num_sectors

if num_sectors < 2 * head_sectors:

return (num_sectors + 1) // 2 * sector_size

else:

""" Access class for ESP8266 stub loader, runs on top of ROM.

FLASH_WRITE_SIZE = 0x4000 # matches MAX_WRITE_BLOCK in stub_loader.c

IS_STUB = True

def __init__(self, rom_loader):

self._port = rom_loader._port

self._trace_enabled = rom_loader._trace_enabled

self.flush_input() # resets _slip_reader

def get_erase_size(self, offset, size):

"""Access class for ESP32 ROM bootloader

CHIP_NAME = "ESP32"

IS_STUB = False

DATE_REG_VALUE = 0x15122500

IROM_MAP_START = 0x400d0000

IROM_MAP_END = 0x40400000

DROM_MAP_START = 0x3F400000

DROM_MAP_END = 0x3F800000

# ESP32 uses a 4 byte status reply

STATUS_BYTES_LENGTH = 4

SPI_REG_BASE = 0x60002000

EFUSE_REG_BASE = 0x6001a000

SPI_W0_OFFS = 0x80

SPI_HAS_MOSI_DLEN_REG = True

FLASH_SIZES = {

'1MB':0x00,

'2MB':0x10,

'4MB':0x20,

'8MB':0x30,

'16MB':0x40

}

BOOTLOADER_FLASH_OFFSET = 0x1000

def get_chip_description(self):

blk3 = self.read_efuse(3)

chip_version = (blk3 >> 12) & 0xF

pkg_version = (blk3 >> 9) & 0x07

silicon_rev = {

0: "0",

8: "1"

}.get(chip_version, "(unknown 0x%x)" % chip_version)

chip_name = {

0: "ESP32D0WDQ6",