def flash(port, firmware_file, erase_flash):
# Initialize parameters
args = Args()
args.port = port
args.baud = 460800
# Initialize device
initial_baud = min(ESP_ROM_BAUD, args.baud)
esp = esptool.ESPROM(args.port, initial_baud)
if erase_flash:
# Connect to the device
esp.connect()
# Erase flash
esptool.erase_flash(esp, None)
# Wait for flash erase
for i in xrange(10):
print ".",
sleep(1)
print "\nDone erasing flash."
# Reconnect
esp.connect()
# Prepare arguments for writing flash
address = 0
args.flash_size = "8m"
args.addr_filename = [(address, open(firmware_file, "rb"))]
# Write flash
esptool.write_flash(esp, args)
print "Done writing new firmware."
def _firmware_upload_task(self):
firmware = (
'0x1000', os.path.join(gm_firmware_dir(),'bootloader.bin'),
'0x10000', os.path.join(gm_firmware_dir(), 'NodeMCU.bin'),
'0x8000', os.path.join(gm_firmware_dir(), 'partitions_singleapp.bin')
)
args = FirmwareUploadArgs(self.serial_monitor.port,firmware)
initial_baud = min(ESPLoader.ESP_ROM_BAUD, args.baud)
try:
self.serial_monitor.stop(log=False)
self.panel_writeln('Firmware Start Update ...')
esp_set_log(self.panel_writeln)
esp = ESPLoader.detect_chip(args.port, initial_baud, args.before)
self.panel_writeln("Chip is %s" % (esp.get_chip_description()))
esp = esp.run_stub()
if args.baud > initial_baud:
try:
esp.change_baud(args.baud)
except NotImplementedInROMError:
self.panel_writeln("WARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %d" % initial_baud)
if hasattr(args, "flash_size"):
self.panel_writeln("Configuring flash size...")
detect_flash_size(esp, args)
esp.flash_set_parameters(flash_size_bytes(args.flash_size))
write_flash(esp, args)
esp.hard_reset()
esp._port.close()
self.serial_monitor.start()
except Exception as e:
self.panel_writeln(str(e))
finally:
self.serial_monitor.start(log=False)
def flash_nvs_partition(bin_path, addr, esp):
esp.connect()
print(bin_path)
abs_bin_path = os.path.dirname(os.path.abspath(__file__)) + '/' + bin_path
print(abs_bin_path)
if (os.path.exists(abs_bin_path) is False):
print("NVS partition not found")
sys.exit(-1)
with open(bin_path, 'rb') as nvs_file:
flash_file = [(addr, nvs_file)]
flash_args = DefineArgs({
'flash_size': '4MB',
'flash_mode': 'qio',
'flash_freq': '80m',
'addr_filename': flash_file,
'no_stub': False,
'compress': False,
'verify': False,
'encrypt': False,
'erase_all': False,
})
esp.change_baud(baud=921600)
esptool.write_flash(esp, flash_args)
def write_firmware(esp, platform, firmware, flash=None):
t = time.time()
click.secho('Flashing firmware (Please wait)...', fg="green")
# Detect flash size
if flash is None:
click.secho('Auto dectect flash size', fg="yellow")
flash_id = esp.flash_id()
flid_lowbyte = (flash_id >> 16) & 0xFF
flash_size = esptool.DETECTED_FLASH_SIZES.get(flid_lowbyte)
if flash_size is None:
flash_size = DEFAULT_FLASH_SIZE[platform]
click.secho('Size detection failed, set to default: %s'%(flash_size), fg="yellow")
else:
click.secho('Size detection successfull: %s'%(flash_size), fg="green")
else:
flash_size = flash
# Set flash paraneters
esp.flash_set_parameters(esptool.flash_size_bytes(flash_size))
# Write
with open(firmware, 'rb') as file:
esptool.write_flash(esp, get_flash_params(platform, flash_size, file))
click.secho('Hard reset...', fg="green")
# Rest
esp.hard_reset()
click.secho('Flash completed successfully in %.1fs' % (time.time() - t), fg="green")
def flash(port, firmware_file, erase_flash):
# Initialize parameters
args = Args()
args.port = port
args.baud = 460800
# Initialize device
initial_baud = min(ESP_ROM_BAUD, args.baud)
esp = esptool.ESPROM(args.port, initial_baud)
if erase_flash:
# Connect to the device
esp.connect()
# Erase flash
esptool.erase_flash(esp, args)
if not firmware_file:
return
# Reconnect
esp.connect()
# Prepare arguments for writing flash
address = 0
args.flash_size = "detect"
args.addr_filename = [(address, open(firmware_file, "rb"))]
# Write flash
esptool.write_flash(esp, args)
print "Done writing new firmware."
def flash(port, firmware_file, erase_flash):
# Initialize parameters
args = Args()
args.port = port
args.baud = 460800
# Initialize device
initial_baud = min(ESP_ROM_BAUD, args.baud)
esp = esptool.ESPROM(args.port, initial_baud)
if erase_flash:
# Connect to the device
esp.connect()
# Erase flash
esptool.erase_flash(esp, args)
if not firmware_file:
return
# Reconnect
esp.connect()
# Prepare arguments for writing flash
address = 0
args.flash_size = "detect"
args.addr_filename = [(address, open(firmware_file, "rb"))]
# Write flash
esptool.write_flash(esp, args)
print("Done writing new firmware.")
def write_flash_data(self,
esp,
flash_files=None,
encrypt_files=None,
ignore_flash_encryption_efuse_setting=True,
encrypt=False):
"""
Try flashing at a particular baud rate.
Structured this way so @_uses_esptool will reconnect each time
:return: None
"""
last_error = None
for baud_rate in [921600, 115200]:
try:
# fake flasher args object, this is a hack until
# esptool Python API is improved
class FlashArgs(object):
def __init__(self, attributes):
for key, value in attributes.items():
self.__setattr__(key, value)
# write_flash expects the parameter encrypt_files to be None and not
# an empty list, so perform the check here
flash_args = FlashArgs({
'flash_size':
self.app.flash_settings['flash_size'],
'flash_mode':
self.app.flash_settings['flash_mode'],
'flash_freq':
self.app.flash_settings['flash_freq'],
'addr_filename':
flash_files or None,
'encrypt_files':
encrypt_files or None,
'no_stub':
self.secure_boot_en,
'compress':
not self.secure_boot_en,
'verify':
False,
'encrypt':
encrypt,
'ignore_flash_encryption_efuse_setting':
ignore_flash_encryption_efuse_setting,
'erase_all':
False,
'after':
'no_reset',
})
esp.change_baud(baud_rate)
esptool.detect_flash_size(esp, flash_args)
esptool.write_flash(esp, flash_args)
break
except RuntimeError as e:
last_error = e
else:
raise last_error
def _try_flash(self, esp, erase_nvs, baud_rate):
"""
Called by start_app() to try flashing at a particular baud rate.
Structured this way so @_uses_esptool will reconnect each time
"""
flash_files = []
try:
# note: opening here prevents us from having to seek back to 0 each time
flash_files = [(offs, open(path, "rb"))
for (offs, path) in self.app.flash_files]
if erase_nvs:
address = self.app.partition_table["nvs"]["offset"]
size = self.app.partition_table["nvs"]["size"]
nvs_file = tempfile.TemporaryFile()
nvs_file.write(b'\xff' * size)
nvs_file.seek(0)
if not isinstance(address, int):
address = int(address, 0)
flash_files.append((address, nvs_file))
# fake flasher args object, this is a hack until
# esptool Python API is improved
class FlashArgs(object):
def __init__(self, attributes):
for key, value in attributes.items():
self.__setattr__(key, value)
flash_args = FlashArgs({
'flash_size':
self.app.flash_settings["flash_size"],
'flash_mode':
self.app.flash_settings["flash_mode"],
'flash_freq':
self.app.flash_settings["flash_freq"],
'addr_filename':
flash_files,
'no_stub':
False,
'compress':
True,
'verify':
False,
'encrypt':
self.app.flash_settings.get("encrypt", False),
'erase_all':
False,
})
esp.change_baud(baud_rate)
esptool.detect_flash_size(esp, flash_args)
esptool.write_flash(esp, flash_args)
finally:
for (_, f) in flash_files:
f.close()
def flash(self, addr_filename=[]):
"""
Flash firmware to the board using esptool
"""
self.on_data.emit("Preparing to flash memory. This can take a while.")
# Esptool is a command line tool and expects arguments that can be
# emulated by creating manually a `Namespace` object
args = Namespace()
args.flash_freq = "40m"
args.flash_mode = "dio"
args.flash_size = "detect"
args.no_progress = False
args.compress = False
args.no_stub = False
args.trace = False
args.verify = False
# This is the most important bit: It must be an list of tuples each
# tuple containing the memory address and an file object. Generate
# this list with `get_addr_filename`
args.addr_filename = addr_filename
try:
# Detects which board is being used. We already know what bard we
# are flashing (ESP32) but this will also does a lot of other
# setup automatically for us
esp32loader = esptool.ESPLoader.detect_chip(
self.port, 115200, False)
# Loads the program bootloader to ESP32 internal RAM
esp = esp32loader.run_stub()
# Change baudrate to flash the board faster
esp.change_baud(921600)
# We already know the flash size but asking esptool to autodetect
# it will save us some more setup
esptool.detect_flash_size(esp, args)
esp.flash_set_parameters(esptool.flash_size_bytes(args.flash_size))
# Erase the current flash memory first
self.on_data.emit('Erasing flash memory.')
esptool.erase_flash(esp, args)
self.on_data.emit('Writing on flash memory.')
# Intercept what esptool prints out by replacing the `sys.stdout`
# by
old_stdout = sys.stdout
sys.stdout = WritingProgressStdout(self.on_progress)
# Write to flash memory
esptool.write_flash(esp, args)
# Restore old `sys.stdout`
sys.stdout = old_stdout
# Reset the board so we don't have to turn the Pixel Kit on and off
# again using its terrible power switch that looks like a button
esp.hard_reset()
except Exception as ex:
logging.error(ex)
self.on_flash_fail.emit("Could not write to flash memory.")
def run(self):
try:
print("esptool.py v%s" % esptool.__version__)
initial_baud = min(ESPLoader.ESP_ROM_BAUD, self._config.baud)
if self._config.port.startswith(__auto_select__):
esp = self.connect_to_esp(initial_baud)
else:
esp = ESPLoader.detect_chip(self._config.port, initial_baud)
print("Chip is %s" % (esp.get_chip_description()))
print("Features: %s" % ", ".join(esp.get_chip_features()))
esptool.read_mac(esp, Namespace())
esp = esp.run_stub()
if self._config.baud > initial_baud:
try:
esp.change_baud(self._config.baud)
except NotImplementedInROMError:
print(
"WARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %d."
% initial_baud)
args = Namespace()
args.flash_size = "detect"
args.flash_mode = self._config.mode
args.flash_freq = "40m"
args.no_progress = False
args.no_stub = False
args.verify = False # TRUE is deprecated
args.compress = True
args.addr_filename = [[
int("0x00000", 0),
open(self._config.firmware_path, 'rb')
]]
print("Configuring flash size...")
esptool.detect_flash_size(esp, args)
esp.flash_set_parameters(esptool.flash_size_bytes(args.flash_size))
if self._config.erase_before_flash:
esptool.erase_flash(esp, args)
esptool.write_flash(esp, args)
# The last line printed by esptool is "Leaving..." -> some indication that the process is done is needed
print("\nDone. Unplug/replug or reset device.")
esp._port.close()
except SerialException as e:
self._parent.report_error(e.strerror)
raise e
def write(self, offset, contents):
args = Args()
args.flash_size = 'detect'
args.flash_mode = 'dio'
args.flash_freq = '80m'
args.compress = True
args.verify = False
args.no_stub = False
fmap = cStringIO.StringIO(contents)
args.addr_filename = [[offset, fmap]]
esptool.write_flash(self.esp, args)
fmap.close()
def flash_bin(self, dest_and_file_pairs):
args = Args()
args.flash_size = 'detect'
args.flash_mode = 'dio'
args.flash_freq = '80m'
args.compress = True
args.verify = True
dest_and_file = list(dest_and_file_pairs)
for i, el in enumerate(dest_and_file):
dest_and_file[i][1] = open(el[1], "rb")
args.addr_filename = dest_and_file
esptool.write_flash(self.esp, args)
def run(self):
try:
initial_baud = min(ESPLoader.ESP_ROM_BAUD, self._config.baud)
esp = ESPLoader.detect_chip(self._config.port, initial_baud)
print("Chip is %s" % (esp.get_chip_description()))
esp = esp.run_stub()
if self._config.baud > initial_baud:
try:
esp.change_baud(self._config.baud)
except NotImplementedInROMError:
print(
"WARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %d"
% initial_baud)
args = Namespace()
args.flash_size = "detect"
args.flash_mode = self._config.mode
args.flash_freq = "40m"
args.no_progress = False
args.no_stub = False
args.verify = False # TRUE is deprecated
args.compress = True
args.addr_filename = [[
int("0x00000", 0),
open(self._config.firmware_path, 'rb')
]]
print("Configuring flash size...")
esptool.detect_flash_size(esp, args)
esp.flash_set_parameters(esptool.flash_size_bytes(args.flash_size))
if self._config.erase_before_flash:
esptool.erase_flash(esp, args)
esptool.write_flash(esp, args)
self._parent.log_message(
"Hard resetting...") # replicate behavior from esptool.py:2111
esp.hard_reset()
except SerialException as e:
self._parent.report_error(e.strerror)
raise e
def _try_flash(self, esp, erase_nvs, baud_rate):
"""
Called by start_app() to try flashing at a particular baud rate.
Structured this way so @_uses_esptool will reconnect each time
"""
try:
# note: opening here prevents us from having to seek back to 0 each time
flash_files = [(offs, open(path, "rb")) for (offs, path) in self.app.flash_files]
if erase_nvs:
address = self.app.partition_table["nvs"]["offset"]
size = self.app.partition_table["nvs"]["size"]
nvs_file = tempfile.TemporaryFile()
nvs_file.write(b'\xff' * size)
nvs_file.seek(0)
flash_files.append((int(address, 0), nvs_file))
# fake flasher args object, this is a hack until
# esptool Python API is improved
class FlashArgs(object):
def __init__(self, attributes):
for key, value in attributes.items():
self.__setattr__(key, value)
flash_args = FlashArgs({
'flash_size': self.app.flash_settings["flash_size"],
'flash_mode': self.app.flash_settings["flash_mode"],
'flash_freq': self.app.flash_settings["flash_freq"],
'addr_filename': flash_files,
'no_stub': False,
'compress': True,
'verify': False,
'encrypt': False,
'erase_all': False,
})
esp.change_baud(baud_rate)
esptool.detect_flash_size(esp, flash_args)
esptool.write_flash(esp, flash_args)
finally:
for (_, f) in flash_files:
f.close()
def run(self):
esp = ESPROM(port=self._config.port)
args = Namespace()
args.flash_size = "detect"
args.flash_mode = self._config.mode
args.flash_freq = "40m"
args.no_progress = False
args.verify = True
args.baud = self._config.baud
args.addr_filename = [[
int("0x00000", 0),
open(self._config.firmware_path, 'rb')
]]
# needs connect() before each operation, see https://github.com/espressif/esptool/issues/157
if self._config.erase_before_flash:
esp.connect()
esptool.erase_flash(esp, args)
esp.connect()
esptool.write_flash(esp, args)
def run(self):
try:
initial_baud = min(ESPLoader.ESP_ROM_BAUD, self._config.baud)
esp = ESPLoader.detect_chip(self._config.port, initial_baud)
print("芯片类型: %s" % (esp.get_chip_description()))
esp = esp.run_stub()
if self._config.baud > initial_baud:
try:
esp.change_baud(self._config.baud)
except NotImplementedInROMError:
print("警告: ROM 不支持改变波特率. 请保持初始波特率 %d." % initial_baud)
args = Namespace()
args.flash_size = "detect"
args.flash_mode = self._config.mode
args.flash_freq = "40m"
args.no_progress = False
args.no_stub = False
args.verify = False # TRUE is deprecated
args.compress = True
args.addr_filename = [[
int("0x00000", 0),
open(self._config.firmware_path, 'rb')
]]
print("Configuring flash size...")
esptool.detect_flash_size(esp, args)
esp.flash_set_parameters(esptool.flash_size_bytes(args.flash_size))
if self._config.erase_before_flash:
esptool.erase_flash(esp, args)
esptool.write_flash(esp, args)
# The last line printed by esptool is "Leaving..." -> some indication that the process is done is needed
print("\nDone.")
except SerialException as e:
self._parent.report_error(e.strerror)
raise e
def _try_flash(self, esp, erase_nvs, baud_rate):
"""
Called by start_app() to try flashing at a particular baud rate.
Structured this way so @_uses_esptool will reconnect each time
"""
try:
# note: opening here prevents us from having to seek back to 0 each time
flash_files = [(offs, open(path, "rb"))
for (offs, path) in self.app.flash_files]
if erase_nvs:
address = self.app.partition_table["nvs"]["offset"]
size = self.app.partition_table["nvs"]["size"]
nvs_file = tempfile.TemporaryFile()
nvs_file.write(b'\xff' * size)
nvs_file.seek(0)
flash_files.append((int(address, 0), nvs_file))
# fake flasher args object, this is a hack until
# esptool Python API is improved
Flash_Args = namedtuple('write_flash_args', [
'flash_size', 'flash_mode', 'flash_freq', 'addr_filename',
'no_stub', 'compress', 'verify', 'encrypt'
])
flash_args = Flash_Args(self.app.flash_settings["flash_size"],
self.app.flash_settings["flash_mode"],
self.app.flash_settings["flash_freq"],
flash_files, False, True, False, False)
esp.change_baud(baud_rate)
esptool.write_flash(esp, flash_args)
finally:
for (_, f) in flash_files:
f.close()
def writeFirmware(self, address, filename):
device = self.connect()
class argsStub():
def __init__(self, address, filename):
self.flash_mode = 'qio'
self.flash_size = '4m'
self.flash_freq = '40m'
self.baud = 115200
self.no_progress = False
self.operation = 'write_flash'
self.verify = False
self.addr_filename = []
argfile = open(filename, 'rb')
self.addr_filename.append((address, argfile))
args = argsStub(address, filename)
return esptool.write_flash(device, args)
def writeFirmware(self, address, filename): device = self.connect() class argsStub(): def __init__(self, address, filename): self.flash_mode = 'qio' self.flash_size = '4m' self.flash_freq='40m' self.baud=115200 self.no_progress=False self.operation='write_flash' self.verify=False self.addr_filename = [] argfile = open(filename, 'rb') self.addr_filename.append((address,argfile)) args = argsStub(address, filename) return esptool.write_flash(device, args)
def _try_flash(self, esp, erase_nvs, baud_rate):
"""
Called by start_app() to try flashing at a particular baud rate.
Structured this way so @_uses_esptool will reconnect each time
"""
flash_files = []
encrypt_files = []
try:
# Open the files here to prevents us from having to seek back to 0
# each time. Before opening them, we have to organize the lists the
# way esptool.write_flash needs:
# If encrypt is provided, flash_files contains all the files to
# flash.
# Else, flash_files contains the files to be flashed as plain text
# and encrypt_files contains the ones to flash encrypted.
flash_files = self.app.flash_files
encrypt_files = self.app.encrypt_files
encrypt = self.app.flash_settings.get("encrypt", False)
if encrypt:
flash_files = encrypt_files
encrypt_files = []
else:
flash_files = [
entry for entry in flash_files
if entry not in encrypt_files
]
flash_files = [(offs, open(path, "rb"))
for (offs, path) in flash_files]
encrypt_files = [(offs, open(path, "rb"))
for (offs, path) in encrypt_files]
if erase_nvs:
address = self.app.partition_table["nvs"]["offset"]
size = self.app.partition_table["nvs"]["size"]
nvs_file = tempfile.TemporaryFile()
nvs_file.write(b'\xff' * size)
nvs_file.seek(0)
if not isinstance(address, int):
address = int(address, 0)
# We have to check whether this file needs to be added to
# flash_files list or encrypt_files.
# Get the CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT macro
# value. If it is set to True, then NVS is always encrypted.
sdkconfig_dict = self.app.get_sdkconfig()
macro_encryption = "CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT" in sdkconfig_dict
# If the macro is not enabled (plain text flash) or all files
# must be encrypted, add NVS to flash_files.
if not macro_encryption or encrypt:
flash_files.append((address, nvs_file))
else:
encrypt_files.append((address, nvs_file))
# fake flasher args object, this is a hack until
# esptool Python API is improved
class FlashArgs(object):
def __init__(self, attributes):
for key, value in attributes.items():
self.__setattr__(key, value)
# write_flash expects the parameter encrypt_files to be None and not
# an empty list, so perform the check here
flash_args = FlashArgs({
'flash_size':
self.app.flash_settings["flash_size"],
'flash_mode':
self.app.flash_settings["flash_mode"],
'flash_freq':
self.app.flash_settings["flash_freq"],
'addr_filename':
flash_files,
'encrypt_files':
encrypt_files or None,
'no_stub':
False,
'compress':
True,
'verify':
False,
'encrypt':
encrypt,
'ignore_flash_encryption_efuse_setting':
False,
'erase_all':
False,
})
esp.change_baud(baud_rate)
esptool.detect_flash_size(esp, flash_args)
esptool.write_flash(esp, flash_args)
finally:
for (_, f) in flash_files:
f.close()
for (_, f) in encrypt_files:
f.close()
def run(self):
esp = None
args = None
vargs = None
ok = False
try:
# build the args namespace esptool expects
args = Namespace()
# copy all enties from setup file
for a in self.setup:
setattr(args, a, self.setup[a])
# We only verify the app portion as the other portions incl
# nvm and may/will change during runtime. So we need a special copy
# of args for verify.
# verify only if we have a single image that starts at 0x1000
if len(self.setup["files"]
) == 1 and self.setup["files"][0]["addr"] == 0x1000:
vargs = Namespace()
for a in self.setup:
setattr(vargs, a, self.setup[a])
# map files to addr_filename tuples
args.addr_filename = []
for f in self.setup["files"]:
# load file into ram as older python version cannot
# seek within zip files but esptool expects to be
# able to seek
# read "source" if present, otherwise read "filename"
if "source" in f: fname = f["source"]
else: fname = f["filename"]
with self.setup["open"](fname, "rb") as fh:
data = fh.read()
fh = io.BytesIO(data)
setattr(fh, "name", fname)
args.addr_filename.append((f["addr"], fh))
# for verify create a ram copy of the firmware which skips to 0x10000
if vargs:
vargs.addr_filename = []
f = self.setup["files"][0]
if "source" in f: fname = f["source"]
else: fname = f["filename"]
with self.setup["open"](fname, "rb") as fh:
# get access to full image data but skip the first
# (0x10000 - addr) = 0xf000 bytes
data = args.addr_filename[0][1].getbuffer()[0x10000 -
f["addr"]:]
dio = io.BytesIO(data)
setattr(dio, "name", "app area of {}".format(fname))
vargs.addr_filename.append((0x10000, dio))
esp = esptool.get_default_connected_device(
serial_list=[self.port],
port=self.port,
initial_baud=ESPROM_BAUD,
chip=args.chip,
connect_attempts=args.connect_attempts)
print("Chip is %s" % (esp.get_chip_description()))
print("Features: %s" % ", ".join(esp.get_chip_features()))
print("Crystal is %dMHz" % esp.get_crystal_freq())
esptool.read_mac(esp, args)
esp = esp.run_stub()
if args.baud > ESPROM_BAUD:
esp.change_baud(args.baud)
esptool.detect_flash_size(esp, args)
if args.flash_size != 'keep':
esp.flash_set_parameters(
esptool.flash_size_bytes(args.flash_size))
do_write = True
if vargs:
try:
esptool.verify_flash(esp, vargs)
do_write = False # verify successful, no need to write
except:
pass
if do_write:
esptool.write_flash(esp, args)
else:
print("Firmware verified successfully, skipping flash")
esp.hard_reset()
esp._port.close()
ok = True
except IOException as e:
self.alert.emit({
"title":
"esptool",
"message":
"Esptool error",
"info":
"Exception when accessing\n" + str(self.port),
"detail":
str(e)
})
if esp:
esp._port.close()
# since the files are now stored in memory we don't have to
# close them here anymore
self.done.emit(ok)
def run_esphomeflasher(argv):
args = parse_args(argv)
port = select_port(args)
if args.show_logs:
serial_port = serial.Serial(port, baudrate=921600)
show_logs(serial_port)
return
print("Starting firmware upgrade...")
print("Getting latest firmware from fujinet.online..")
print(fujinet_version_info(), end='')
firmware = open_downloadable_binary(ESP32_DEFAULT_FIRMWARE)
chip = detect_chip(port, args.esp8266, args.esp32)
info = read_chip_info(chip)
print()
print("Chip Info:")
print(" - Chip Family: {}".format(info.family))
print(" - Chip Model: {}".format(info.model))
if isinstance(info, ESP32ChipInfo):
print(" - Number of Cores: {}".format(info.num_cores))
print(" - Max CPU Frequency: {}".format(info.cpu_frequency))
print(" - Has Bluetooth: {}".format(
'YES' if info.has_bluetooth else 'NO'))
print(" - Has Embedded Flash: {}".format(
'YES' if info.has_embedded_flash else 'NO'))
print(" - Has Factory-Calibrated ADC: {}".format(
'YES' if info.has_factory_calibrated_adc else 'NO'))
else:
print(" - Chip ID: {:08X}".format(info.chip_id))
print(" - MAC Address: {}".format(info.mac))
stub_chip = chip_run_stub(chip)
if args.upload_baud_rate != 115200:
try:
stub_chip.change_baud(args.upload_baud_rate)
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error changing ESP upload baud rate: {}".format(err))
flash_size = detect_flash_size(stub_chip)
print(" - Flash Size: {}".format(flash_size))
mock_args = configure_write_flash_args(info, firmware, flash_size,
args.bootloader, args.partitions,
args.otadata, args.spiffs)
print(" - Flash Mode: {}".format(mock_args.flash_mode))
print(" - Flash Frequency: {}Hz".format(mock_args.flash_freq.upper()))
try:
stub_chip.flash_set_parameters(esptool.flash_size_bytes(flash_size))
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error setting flash parameters: {}".format(err))
if not args.no_erase:
try:
esptool.erase_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error while erasing flash: {}".format(err))
try:
esptool.write_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError("Error while writing flash: {}".format(err))
print("Hard Resetting...")
stub_chip.hard_reset()
print("Done! Flashing is complete!")
print()
if args.upload_baud_rate != 921600:
stub_chip._port.baudrate = 921600
time.sleep(0.05) # get rid of crap sent during baud rate change
stub_chip._port.flushInput()
show_logs(stub_chip._port)
def run_esphomeflasher(argv):
args = parse_args(argv)
try:
firmware = open(args.binary, 'rb')
except IOError as err:
raise EsphomeflasherError("Error opening binary: {}".format(err))
port = select_port(args)
chip = detect_chip(port, args.esp8266, args.esp32)
info = read_chip_info(chip)
print()
print("Chip Info:")
print(" - Chip Family: {}".format(info.family))
print(" - Chip Model: {}".format(info.model))
if isinstance(info, ESP32ChipInfo):
print(" - Number of Cores: {}".format(info.num_cores))
print(" - Max CPU Frequency: {}".format(info.cpu_frequency))
print(" - Has Bluetooth: {}".format('YES' if info.has_bluetooth else 'NO'))
print(" - Has Embedded Flash: {}".format('YES' if info.has_embedded_flash else 'NO'))
print(" - Has Factory-Calibrated ADC: {}".format(
'YES' if info.has_factory_calibrated_adc else 'NO'))
else:
print(" - Chip ID: {:08X}".format(info.chip_id))
print(" - MAC Address: {}".format(info.mac))
stub_chip = chip_run_stub(chip)
flash_size = detect_flash_size(stub_chip)
print(" - Flash Size: {}".format(flash_size))
mock_args = configure_write_flash_args(info, firmware, flash_size,
args.bootloader, args.partitions,
args.otadata)
print(" - Flash Mode: {}".format(mock_args.flash_mode))
print(" - Flash Frequency: {}Hz".format(mock_args.flash_freq.upper()))
try:
stub_chip.flash_set_parameters(esptool.flash_size_bytes(flash_size))
except esptool.FatalError as err:
raise EsphomeflasherError("Error setting flash parameters: {}".format(err))
if not args.no_erase:
try:
esptool.erase_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError("Error while erasing flash: {}".format(err))
try:
esptool.write_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError("Error while writing flash: {}".format(err))
print("Hard Resetting...")
stub_chip.hard_reset()
print("Done! Flashing is complete!")
print()
print("Showing logs:")
with stub_chip._port as ser:
while True:
try:
raw = ser.readline()
except serial.SerialException:
print("Serial port closed!")
return
text = raw.decode(errors='ignore')
text = ANSI_REGEX.sub('', text)
line = text.replace('\r', '').replace('\n', '')
time = datetime.now().time().strftime('[%H:%M:%S]')
message = time + line
try:
print(message)
except UnicodeEncodeError:
print(message.encode('ascii', 'backslashreplace'))
def run_esphomeflasher(argv):
args = parse_args(argv)
port = select_port(args)
if args.show_logs:
serial_port = serial.Serial(port, baudrate=115200)
show_logs(serial_port)
return
try:
firmware = open(args.binary, 'rb')
except IOError as err:
raise EsphomeflasherError("Error opening binary: {}".format(err))
chip = detect_chip(port, args.esp8266, args.esp32)
info = read_chip_info(chip)
print()
print("Chip Info:")
print(" - Chip Family: {}".format(info.family))
print(" - Chip Model: {}".format(info.model))
if isinstance(info, ESP32ChipInfo):
print(" - Number of Cores: {}".format(info.num_cores))
print(" - Max CPU Frequency: {}".format(info.cpu_frequency))
print(" - Has Bluetooth: {}".format(
'YES' if info.has_bluetooth else 'NO'))
print(" - Has Embedded Flash: {}".format(
'YES' if info.has_embedded_flash else 'NO'))
print(" - Has Factory-Calibrated ADC: {}".format(
'YES' if info.has_factory_calibrated_adc else 'NO'))
else:
print(" - Chip ID: {:08X}".format(info.chip_id))
print(" - MAC Address: {}".format(info.mac))
stub_chip = chip_run_stub(chip)
flash_size = detect_flash_size(stub_chip)
print(" - Flash Size: {}".format(flash_size))
mock_args = configure_write_flash_args(info, firmware, flash_size,
args.bootloader, args.partitions,
args.otadata)
print(" - Flash Mode: {}".format(mock_args.flash_mode))
print(" - Flash Frequency: {}Hz".format(mock_args.flash_freq.upper()))
try:
stub_chip.flash_set_parameters(esptool.flash_size_bytes(flash_size))
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error setting flash parameters: {}".format(err))
if not args.no_erase:
try:
esptool.erase_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error while erasing flash: {}".format(err))
try:
esptool.write_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError("Error while writing flash: {}".format(err))
print("Hard Resetting...")
stub_chip.hard_reset()
print("Done! Flashing is complete!")
print()
show_logs(stub_chip._port)
def uart_upload(port, filename, baudrate, key=None, target=""):
print_header("=================== FIRMWARE UPLOAD ===================")
print_log(" Bin file '%s'" % filename)
print_log(" Port %s @ %s" % (port, baudrate))
cmd_reboot_to_bootloader = bootloader.get_init_seq('CRSF', key)
if not os.path.exists(filename):
msg = "[FAILED] file '%s' does not exist" % filename
raise SystemExit(msg)
detected_baud = baudrate
chip_type, esp = esp_read_chip_id(port, detected_baud)
if not chip_type:
# Init Betaflight passthrough
try:
detected_baud = BFinitPassthrough.bf_passthrough_init(port, None)
if detected_baud is None:
detected_baud = baudrate
except BFinitPassthrough.PassthroughEnabled as info:
print_warning(" Warning: '%s'" % info)
except BFinitPassthrough.PassthroughFailed as failed:
raise SystemExit(failed)
# Reset into bootloader
bootloader.reset_to_bootloader(port, detected_baud,
cmd_reboot_to_bootloader, target)
# send_training_to_esp_rom(port, detected_baud)
chip_type, esp = esp_read_chip_id(port, detected_baud)
if not esp:
raise SystemExit("Cannot connect to ESP")
# Prepare to upload
print_header("======== UPLOADING ========")
if esp:
_binary = open(os.path.abspath(filename), 'rb')
class TempArgs():
compress = None
no_compress = True
no_stub = False
encrypt = False
flash_size = "keep"
flash_mode = "keep"
flash_freq = "keep"
addr_filename = []
erase_all = False
verify = False
args = TempArgs()
args.addr_filename.append((0, _binary))
try:
esptool.write_flash(esp, args)
# flash_finish will trigger a soft reset
esp.soft_reset(False)
finally:
_binary.close()
esp._port.close()
return
# --------------------
chip_type = ["auto", "esp8266"][chip_type.startswith("ESP82")]
args = [
"-b",
str(detected_baud), "-p", port, "-c", chip_type, "--before",
"no_reset", "--after", "soft_reset", "write_flash", "0x0",
os.path.abspath(filename)
]
cmd = " ".join(args)
print_log(" Using command: '%s'\n" % cmd)
esptool.main(args)
def run_esphomeflasher(argv):
args = parse_args(argv)
port = select_port(args)
if args.show_logs:
serial_port = serial.Serial(port, baudrate=115200)
show_logs(serial_port)
return
try:
firmware = open(args.binary, 'rb')
except IOError as err:
raise EsphomeflasherError("Error opening binary: {}".format(err))
chip = detect_chip(port, args.esp8266, args.esp32)
info = read_chip_info(chip)
print()
print("Chip Info:")
print(" - Chip Family: {}".format(info.family))
print(" - Chip Model: {}".format(info.model))
if isinstance(info, ESP32ChipInfo):
print(" - Number of Cores: {}".format(info.num_cores))
print(" - Max CPU Frequency: {}".format(info.cpu_frequency))
print(" - Has Bluetooth: {}".format(
'YES' if info.has_bluetooth else 'NO'))
print(" - Has Embedded Flash: {}".format(
'YES' if info.has_embedded_flash else 'NO'))
print(" - Has Factory-Calibrated ADC: {}".format(
'YES' if info.has_factory_calibrated_adc else 'NO'))
else:
print(" - Chip ID: {:08X}".format(info.chip_id))
print(" - MAC Address: {}".format(info.mac))
stub_chip = chip_run_stub(chip)
flash_size = None
if args.upload_baud_rate != 115200:
try:
stub_chip.change_baud(args.upload_baud_rate)
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error changing ESP upload baud rate: {}".format(err))
# Check if the higher baud rate works
try:
flash_size = detect_flash_size(stub_chip)
except esptool.FatalError as err:
# Go back to old baud rate by recreating chip instance
print("Chip does not support baud rate {}, changing to 115200".
format(args.upload_baud_Rate))
stub_chip._port.close()
chip = detect_chip(port, args.esp8266, args.esp32)
stub_chip = chip_run_stub(chip)
if flash_size is None:
flash_size = detect_flash_size(stub_chip)
print(" - Flash Size: {}".format(flash_size))
mock_args = configure_write_flash_args(info, firmware, flash_size,
args.bootloader, args.partitions,
args.otadata)
print(" - Flash Mode: {}".format(mock_args.flash_mode))
print(" - Flash Frequency: {}Hz".format(mock_args.flash_freq.upper()))
try:
stub_chip.flash_set_parameters(esptool.flash_size_bytes(flash_size))
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error setting flash parameters: {}".format(err))
if not args.no_erase:
try:
esptool.erase_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError(
"Error while erasing flash: {}".format(err))
try:
esptool.write_flash(stub_chip, mock_args)
except esptool.FatalError as err:
raise EsphomeflasherError("Error while writing flash: {}".format(err))
print("Hard Resetting...")
stub_chip.hard_reset()
print("Done! Flashing is complete!")
print()
if args.upload_baud_rate != 115200:
stub_chip._port.baudrate = 115200
time.sleep(0.05) # get rid of crap sent during baud rate change
stub_chip._port.flushInput()
show_logs(stub_chip._port)
def _write_flash(self):
#1.Setup widgets
self._status_color = 'blue'
self.style.configure('write.TLabel', foreground='blue')
self._write['state'] = 'disable'
self.update_status('Preprocessing....')
#2. Create agrs
if not self._create_args():
print("\nFlashFirmware: Failed to create args.")
#3. Setup esp
args = self.args
if not self.device.esp:
self.device._connect_esp()
esp = self.device.esp
else:
esp = self.device.esp
esp.flush_input()
#esp.connect()
#esp._slip_reader = esptool.slip_reader(esp._port, esp.trace)
if not args.no_stub:
print('if not args.no_stub:')
esp = esp.run_stub()
if args.baud != esptool.ESPLoader.ESP_ROM_BAUD:
try:
esp.change_baud(args.baud)
except NotImplementedInROMError:
print(
"WARNING: ROM doesn't support changing baud rate. Keeping initial baud rate %d"
% initial_baud)
# override common SPI flash parameter stuff if configured to do so
if hasattr(args, "spi_connection") and args.spi_connection is not None:
if esp.CHIP_NAME != "ESP32":
raise FatalError(
"Chip %s does not support --spi-connection option." %
esp.CHIP_NAME)
print("Configuring SPI flash mode...")
esp.flash_spi_attach(args.spi_connection)
elif args.no_stub:
print("Enabling default SPI flash mode...")
# ROM loader doesn't enable flash unless we explicitly do it
esp.flash_spi_attach(0)
if hasattr(args, "flash_size"):
print("Configuring flash size...")
esptool.detect_flash_size(esp, args)
esp.flash_set_parameters(esptool.flash_size_bytes(args.flash_size))
print('\nargs = ')
pprint(args.__dict__)
print('\nesp = ')
pprint(esp.__dict__)
print('\nesp._port = ')
pprint(esp._port.__dict__)
#4. Start writing
self._writing = True
self._completed = False
self.update_status('Writing....')
try:
esptool.write_flash(esp, args)
except esptool.FatalError:
raise
else:
print('Hard resetting via RTS pin...')
esp.hard_reset()
finally:
try: # Clean up AddrFilenamePairAction files
for address, argfile in args.addr_filename:
argfile.close()
except AttributeError:
pass
#esp._port.close()
#5. Post writing setups
self.update_status('Written Firmware to Flash.')
self._writing = False
self._completed = True
self._write['state'] = 'normal'
