prremote 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b55c090d4bddcdac18b7a1166429af025eeecc0416e31dedf51f248b4d2cd975
-  data.tar.gz: c81096a50e22d31064a8f721daca2de89dcfc5ccbb6e6c9d2d3fb58973c85ac0
+  metadata.gz: c370f33a2cd268d2ab4eba26c7123d195e71fc5a927c386d561e55ad5a2adb0e
+  data.tar.gz: 181302d7b8d2cd6e78f3a76b98171bddd5fb4c9d66f8c0aacd925f4911cb4920
 SHA512:
-  metadata.gz: 8d959c616f0205f2e63f9ba8eba7d96f66943822e1e59be4dc41cb58aed070fabe816ff1473a6cbee7057bdc19533274dbf8c0c2a5e04924d354bcaae54653db
-  data.tar.gz: 9a1fd33542e02a7a97f0e0a9d9626e3f688d80cf3027ff975de58e2159defc90fa3880a9611cb35b125359c7fc8d36ed3708e517673e16795ac3e8cb6a1d566a
+  metadata.gz: f411813a2aa5c91a59bb7ce05b74a1bbd6f85bfb4b8329f7a1df146d8a014eb65ee6750643c63d2bdb3d09ec8bd0b3943e28e14d48a459cb3d3f645bf6206a68
+  data.tar.gz: 47f84f1d2277a04b1739f7c72f3565d9c3e8f6ba2700abc38142370d90ef928e577eb931d3ec8a8dafc5019b0ac15bd5da857cc33a1c400f4ca3ae28f59109d4

data/README.md

@@ -2,7 +2,7 @@
 
 > ⚠️ This project is in early development. APIs and commands are subject to change.
 
-**prremote** is a command-line tool for deploying and running Ruby scripts on a Raspberry Pi Pico W over USB serial. It ships a minimal [mruby/c](https://github.com/mrubyc/mrubyc) runtime firmware and lets you compile and send `.rb` files from your Mac or Linux machine directly to the device.
+**prremote** is a command-line tool for deploying and running Ruby scripts on a Raspberry Pi Pico W or ESP32 (e.g. M5Stack) over USB serial. It ships a minimal [mruby/c](https://github.com/mrubyc/mrubyc) runtime firmware and lets you compile and send `.rb` files from your Mac or Linux machine directly to the device.
 
 Inspired by [mpremote](https://docs.micropython.org/en/latest/reference/mpremote.html) for MicroPython.
 
@@ -17,7 +17,9 @@ Inspired by [mpremote](https://docs.micropython.org/en/latest/reference/mpremote
 ## Requirements
 
 - Ruby 3.4 or later
-- Raspberry Pi Pico W
+- A supported board:
+  - Raspberry Pi Pico W / Pico
+  - ESP32 (classic) — e.g. M5GO / M5Stack Core gen1, generic dev boards
 - `mrbc` (mruby 4.x) for `run`, `deploy`, and `eval`
   - macOS: `brew install mruby`
   - Linux: build from source — [github.com/mruby/mruby/releases](https://github.com/mruby/mruby/releases)
@@ -54,18 +56,21 @@ prremote run app.rb
 
 ### `install`
 
-Flash the prremote runtime firmware to a Pico W or Pico.
+Flash the prremote runtime firmware to a Pico W, Pico, or ESP32.
 
 ```bash
 prremote install                          # Pico W (default)
 prremote install --board pico             # Pico (no wireless)
+prremote install --board esp32            # ESP32 (M5GO / M5Stack Core, etc.)
 prremote install --version 0.1.1          # specify a runtime version
 prremote install --board pico --version 0.1.1
 ```
 
 The firmware is downloaded from GitHub Releases on first use and cached in `~/.prremote/runtime/`. Subsequent installs use the cache.
 
-Put the device into BOOTSEL mode (hold BOOTSEL, connect USB, release) when prompted.
+Pico boards: put the device into BOOTSEL mode (hold BOOTSEL, connect USB, release) when prompted.
+
+ESP32 boards: no button dance and no extra tools needed — the firmware is written over the serial port by prremote's pure-Ruby implementation of the Espressif bootloader protocol (the chip is reset into its boot ROM automatically, and the write is verified with an on-chip MD5). Reflashing the runtime does not erase a deployed script.
 
 ---
 
@@ -163,8 +168,8 @@ Show the gem version, mrbc version, and the connected device's runtime version.
 
 ```bash
 prremote version
-# prremote: 0.1.7
-# runtime:  0.1.7 (/dev/tty.usbmodem101)
+# prremote: 0.2.0
+# runtime:  0.2.0 (/dev/tty.usbmodem101)
 # mrbc: mruby 4.0.0 (2026-04-20) (/opt/homebrew/bin/mrbc)
 ```
 
@@ -209,7 +214,7 @@ prremote flashes a minimal C firmware (built on mruby/c) onto the Pico W. The fi
    - `DPLY` + `.mrb` bytecode → save to flash and confirm with `DEPLOYED` (`deploy`)
 3. Waits for the next command
 
-Scripts saved via `deploy` are stored in flash and run automatically on every boot. GPIO and WiFi (CYW43) C bindings are available in Ruby code running on the device.
+Scripts saved via `deploy` are stored in flash and run automatically on every boot. GPIO / ADC / PWM / I2C / SPI bindings are available on all boards; WiFi (CYW43) on the Pico W; an `LCD` class (ILI9342C) on ESP32 / M5Stack.
 
 ---
 
@@ -232,11 +237,29 @@ git submodule update --init --recursive
 
 ### Build the runtime firmware
 
-Requires the ARM cross-compiler (`arm-none-eabi-gcc`) and CMake.
+Pico boards require the ARM cross-compiler (`arm-none-eabi-gcc`) and CMake.
+
+```bash
+cd runtime/
+rake build   # UF2 for pico and picow
+```
+
+The ESP32 runtime requires ESP-IDF v5.3, which is not vendored (it is several
+GB and installs its own toolchains). One-time setup:
+
+```bash
+mkdir -p ~/sources/esp
+git clone -b v5.3.2 --recursive --shallow-submodules \
+    https://github.com/espressif/esp-idf.git ~/sources/esp/esp-idf
+cd ~/sources/esp/esp-idf && ./install.sh esp32
+```
+
+Then (set `IDF_PATH` if you installed somewhere else):
 
 ```bash
 cd runtime/
-rake cache   # build UF2 for pico and picow → ~/.prremote/runtime/
+rake build:esp32   # merged .bin for esp32
+rake cache         # build all boards → ~/.prremote/runtime/
 ```
 
 ### Run the tests

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.2.0

data/lib/prremote/cli.rb

@@ -3,6 +3,7 @@ require 'rubyserial'
 require_relative 'version'
 require_relative 'detector'
 require_relative 'mrbc'
+require_relative 'esp_flasher'
 require_relative 'runtime_manager'
 require_relative 'commands/install'
 require_relative 'commands/deploy'
@@ -23,9 +24,9 @@ module Prremote
 
     remove_command :tree
 
-    desc 'install', 'Flash prremote runtime firmware to Pico W or Pico'
+    desc 'install', 'Flash prremote runtime firmware to Pico W, Pico, or ESP32'
     option :version, type: :string, desc: "Firmware version to install (default: #{VERSION})"
-    option :board, type: :string, desc: 'Board type: pico or picow (default: picow)'
+    option :board, type: :string, desc: 'Board type: picow, pico, or esp32 (default: picow)'
     def install
       version = options[:version] || VERSION
       board = options[:board] || 'picow'
@@ -33,7 +34,7 @@ module Prremote
         raise Thor::Error, "Unknown board '#{board}'. Valid values: #{RuntimeManager::BOARDS.join(', ')}"
       end
 
-      Commands::Install.new(version: version, board: board).call
+      Commands::Install.new(version: version, board: board, port: options[:port]).call
     rescue StandardError => e
       raise Thor::Error, e.message
     end

data/lib/prremote/commands/install.rb

@@ -3,12 +3,15 @@ require 'fileutils'
 module Prremote
   module Commands
     class Install
-      def initialize(version: VERSION, board: 'picow')
+      def initialize(version: VERSION, board: 'picow', port: nil)
         @version = version
         @board = board
+        @port = port
       end
 
       def call
+        return install_esp32 if @board == 'esp32'
+
         uf2_path = RuntimeManager.fetch(@version, @board)
 
         device_label = @board == 'picow' ? 'Pico W' : 'Pico'
@@ -31,6 +34,18 @@ module Prremote
 
       private
 
+      # No BOOTSEL dance on ESP32: the flasher toggles DTR/RTS to enter the
+      # boot ROM by itself, so flashing works over the normal serial port.
+      def install_esp32
+        image = RuntimeManager.fetch(@version, @board)
+        port  = @port || Detector.find_device
+        raise 'No serial device found. Connect the board or pass --port.' unless port
+
+        puts "Flashing #{File.basename(image)} to #{port}..."
+        EspFlasher.flash(port: port, image_path: image)
+        puts "Done. Runtime #{@version} installed."
+      end
+
       def volume_paths
         [
           '/Volumes/RPI-RP2',

data/lib/prremote/commands/serial_helpers.rb

@@ -5,11 +5,15 @@ module Prremote
         # On macOS, USB CDC TX buffers can be dropped when the host reopens the port,
         # leaving the device stuck in getchar() without re-sending READY.
         # Sending Ctrl+C forces the device to restart its READY loop.
+        # Resent every second: ESP32 boards reset when the port opens (DTR/RTS
+        # auto-reset circuit) and a Ctrl+C sent while they are still booting
+        # is lost. Harmless on Pico — 0x03 while idle just re-prints READY.
         sleep 0.1
         serial.write("\x03") rescue nil
 
         buf = +''
-        deadline = Time.now + 10
+        deadline  = Time.now + 10
+        next_ctrl = Time.now + 1
         loop do
           buf << normalize(safe_read(serial, 256))
           if buf.include?('READY ')
@@ -18,6 +22,10 @@ module Prremote
           end
           raise 'Timeout waiting for device. Run `prremote reset` if a script is running.' if Time.now > deadline
 
+          if Time.now > next_ctrl
+            serial.write("\x03") rescue nil
+            next_ctrl = Time.now + 1
+          end
           sleep 0.05
         end
       end

data/lib/prremote/detector.rb

@@ -2,7 +2,16 @@ require 'rbconfig'
 
 module Prremote
   class Detector
-    R2P2_VENDOR_IDS = %w[2e8a].freeze # Raspberry Pi USB VID
+    # Known USB vendor IDs → device label and the macOS port-name pattern.
+    # Pico exposes native USB CDC (usbmodem); ESP32 boards sit behind a
+    # USB-UART bridge (usbserial): CP210x on M5GO/M5Stack, CH910x on newer
+    # revisions.
+    KNOWN_VENDORS = {
+      '2e8a' => { label: 'Pico (prremote/R2P2)', macos: /usbmodem/ },
+      '10c4' => { label: 'ESP32 (CP210x)',       macos: /usbserial/ },
+      '1a86' => { label: 'ESP32 (CH910x)',       macos: /usbserial/ }
+    }.freeze
+    R2P2_VENDOR_IDS = %w[2e8a].freeze # Raspberry Pi USB VID (kept for compat)
 
     def self.find_device
       new.find_device
@@ -12,14 +21,13 @@ module Prremote
       candidates = serial_ports
       return candidates.first if candidates.size == 1
 
-      r2p2 = candidates.select { |p| r2p2_port?(p) }
-      r2p2.first || candidates.first
+      known = candidates.select { |p| known_port?(p) }
+      known.first || candidates.first
     end
 
     def list_devices
       serial_ports.map do |port|
-        label = r2p2_port?(port) ? 'R2P2/PicoRuby' : 'unknown'
-        { port: port, label: label }
+        { port: port, label: port_label(port) || 'unknown' }
       end
     end
 
@@ -45,23 +53,37 @@ module Prremote
       end
     end
 
-    def r2p2_port?(port)
-      # On macOS/Linux, check sysfs or ioreg for the Raspberry Pi VID
+    def known_port?(port)
+      !port_label(port).nil?
+    end
+
+    def port_label(port)
+      # On macOS/Linux, check ioreg or sysfs for a known vendor ID
       case RbConfig::CONFIG['host_os']
       when /darwin/
-        ioreg_output = `ioreg -p IOUSB -l 2>/dev/null`
-        R2P2_VENDOR_IDS.any? { |vid| ioreg_output.include?(vid) } &&
-          port.match?(/usbmodem/)
+        KNOWN_VENDORS.each do |vid, info|
+          return info[:label] if usb_vendor_ids.include?(vid) && port.match?(info[:macos])
+        end
+        nil
       when /linux/
         port_name = File.basename(port)
         vid_path = "/sys/class/tty/#{port_name}/device/../../../idVendor"
-        return false unless File.exist?(vid_path)
+        return nil unless File.exist?(vid_path)
 
         vid = File.read(vid_path).strip.downcase
-        R2P2_VENDOR_IDS.include?(vid)
-      else
-        false
+        KNOWN_VENDORS.dig(vid, :label)
       end
     end
+
+    # Vendor IDs of all connected USB devices as 4-digit hex strings.
+    # ioreg prints idVendor in decimal (e.g. 4292 for 0x10c4).
+    def usb_vendor_ids
+      @usb_vendor_ids ||= ioreg_usb.scan(/"idVendor" = (\d+)/)
+                                   .map { |(dec)| format('%04x', dec.to_i) }
+    end
+
+    def ioreg_usb
+      @ioreg_usb ||= `ioreg -p IOUSB -l 2>/dev/null`
+    end
   end
 end

data/lib/prremote/esp_flasher.rb

@@ -0,0 +1,288 @@
+require 'rubyserial'
+require 'digest'
+require 'rbconfig'
+
+module Prremote
+  # Pure-Ruby ESP32 flasher — speaks the Espressif serial bootloader protocol
+  # directly so `install --board esp32` needs no esptool / Python.
+  #
+  # Talks to the ESP32 (classic) ROM loader only (no stub upload): SYNC,
+  # SPI_ATTACH, SPI_SET_PARAMS, CHANGE_BAUDRATE, FLASH_BEGIN/DATA/END and
+  # SPI_FLASH_MD5 — enough to write a merged image at offset 0x0 and verify it.
+  # Protocol reference:
+  # https://docs.espressif.com/projects/esptool/en/latest/esp32/advanced-topics/serial-protocol.html
+  #
+  # The chip is put into (and out of) the boot ROM by toggling DTR/RTS through
+  # the USB-UART bridge's auto-reset circuit, via ioctl on the serial fd —
+  # macOS and Linux only.
+  class EspFlasher
+    # Command opcodes (ROM loader subset)
+    FLASH_BEGIN    = 0x02
+    FLASH_DATA     = 0x03
+    FLASH_END      = 0x04
+    SYNC           = 0x08
+    SPI_SET_PARAMS = 0x0B
+    SPI_ATTACH     = 0x0D
+    CHANGE_BAUD    = 0x0F
+    SPI_FLASH_MD5  = 0x13
+
+    FLASH_WRITE_SIZE = 0x400 # ROM loader max data per FLASH_DATA packet
+    STATUS_BYTES     = 4     # ESP32 ROM appends 4 status bytes to responses
+    CHECKSUM_SEED    = 0xEF
+
+    ROM_BAUD = 115_200
+
+    # ioctl modem-control constants
+    TIOCM_DTR = 0x0002
+    TIOCM_RTS = 0x0004
+    DARWIN    = RbConfig::CONFIG['host_os'] =~ /darwin/ ? true : false
+    TIOCMGET  = DARWIN ? 0x4004746A : 0x5415
+    TIOCMSET  = DARWIN ? 0x8004746D : 0x5418
+
+    class Error < RuntimeError; end
+
+    # Flashes `image_path` at offset 0x0 and verifies it with an on-chip MD5.
+    # The transfer runs at `baud` when rubyserial supports it locally
+    # (macOS termios caps out at 230400), otherwise at the ROM's 115200.
+    def self.flash(port:, image_path:, baud: 230_400)
+      unless RbConfig::CONFIG['host_os'] =~ /darwin|linux/
+        raise Error, 'pure-Ruby flashing supports macOS/Linux only; ' \
+                     'on other systems flash with esptool: ' \
+                     "esptool write_flash 0x0 #{image_path}"
+      end
+
+      image  = File.binread(image_path)
+      serial = Serial.new(port, ROM_BAUD)
+      flasher = new(serial, fd: serial.instance_variable_get(:@fd))
+      begin
+        flasher.enter_bootloader
+        flasher.sync!
+        serial = flasher.upgrade_baud(port, baud) if baud != ROM_BAUD && baud_supported?(baud)
+        flasher.write_flash(image, offset: 0)
+        # Verify before FLASH_END: the ROM loader has been seen going quiet
+        # after that command, while MD5 right after the last block is reliable.
+        flasher.verify_md5(image, offset: 0)
+        flasher.finish_flash
+        flasher.hard_reset
+      ensure
+        serial.close
+      end
+    end
+
+    # The local termios layer must support the baud before CHANGE_BAUDRATE is
+    # sent to the chip — once the chip switches, there is no way back without
+    # a re-sync, so never request a speed we cannot reopen at.
+    def self.baud_supported?(baud)
+      RubySerial::Posix::BAUDE_RATES.key?(baud)
+    rescue NameError
+      false
+    end
+
+    # `serial` needs #read/#write; `fd` enables DTR/RTS control and may be
+    # nil in tests.
+    def initialize(serial, fd: nil)
+      @serial = serial
+      @fd     = fd
+      @rxbuf  = +''.b
+    end
+
+    # ── chip reset control (DTR/RTS via the auto-download circuit) ────────
+
+    def enter_bootloader
+      # esptool's "classic reset": hold EN low, release it with IO0 low so
+      # the chip starts the ROM loader, then release IO0.
+      set_lines(dtr: false, rts: true)
+      sleep 0.1
+      set_lines(dtr: true, rts: false)
+      sleep 0.05
+      set_lines(dtr: false, rts: false)
+    end
+
+    def hard_reset
+      set_lines(dtr: false, rts: true)
+      sleep 0.1
+      set_lines(dtr: false, rts: false)
+    end
+
+    # ── protocol steps ─────────────────────────────────────────────────────
+
+    def sync!
+      payload = [0x07, 0x07, 0x12, 0x20].pack('C4') + ([0x55] * 32).pack('C32')
+      synced = 8.times.any? do
+        @rxbuf.clear
+        begin
+          command(SYNC, payload, timeout: 0.5)
+          drain_responses
+          true
+        rescue Error
+          false
+        end
+      end
+      raise Error, 'could not sync with the ESP32 boot ROM' unless synced
+    end
+
+    # CHANGE_BAUDRATE, then reopen the port at the new speed. Plain open does
+    # not touch DTR/RTS (verified with rubyserial), so the chip stays in the
+    # bootloader across the reopen.
+    def upgrade_baud(port, baud)
+      command(CHANGE_BAUD, [baud, 0].pack('V2'))
+      @serial.close
+      sleep 0.05
+      serial = Serial.new(port, baud)
+      @serial = serial
+      @fd     = serial.instance_variable_get(:@fd)
+      @rxbuf.clear
+      serial
+    end
+
+    def write_flash(image, offset: 0)
+      command(SPI_ATTACH, [0, 0].pack('V2'))
+      # id, total size, block size, sector size, page size, status mask
+      command(SPI_SET_PARAMS,
+              [0, 4 * 1024 * 1024, 64 * 1024, 4096, 256, 0xFFFF].pack('V6'))
+
+      blocks = (image.bytesize + FLASH_WRITE_SIZE - 1) / FLASH_WRITE_SIZE
+      # The ROM erases the region inside FLASH_BEGIN; allow ~30 s per MB.
+      erase_timeout = 30 * (1 + (image.bytesize / (1024 * 1024)))
+      command(FLASH_BEGIN,
+              [image.bytesize, blocks, FLASH_WRITE_SIZE, offset].pack('V4'),
+              timeout: erase_timeout)
+      stream_blocks(image, blocks)
+    end
+
+    # Every block is already committed once its FLASH_DATA is acked, so
+    # FLASH_END is only a courtesy "done" (we leave the loader via hard_reset
+    # anyway). The ESP32 ROM has been seen answering it with error 0x06 —
+    # ignore it; the MD5 check is the source of truth.
+    def finish_flash
+      command(FLASH_END, [1].pack('V')) # 1 = stay in the loader
+    rescue Error
+      nil
+    end
+
+    def verify_md5(image, offset: 0)
+      timeout = 8 * (1 + (image.bytesize / (1024 * 1024)))
+      _value, data = command(SPI_FLASH_MD5,
+                             [offset, image.bytesize, 0, 0].pack('V4'),
+                             timeout: timeout)
+      device_md5 = data[0, 32] # the ROM loader answers as 32 hex chars
+      local_md5  = Digest::MD5.hexdigest(image)
+      return if device_md5 == local_md5
+
+      raise Error, "MD5 mismatch after flashing (device #{device_md5}, local #{local_md5})"
+    end
+
+    # ── request/response plumbing ──────────────────────────────────────────
+
+    # Sends one command packet and waits for its response.
+    # Returns [value, data] from the response (status bytes stripped).
+    def command(op, payload, checksum: 0, timeout: 3)
+      packet = [0x00, op, payload.bytesize].pack('CCv') +
+               [checksum].pack('V') + payload
+      @serial.write(slip_encode(packet))
+
+      deadline = Time.now + timeout
+      loop do
+        frame = read_frame(deadline)
+        raise Error, format('timeout waiting for response to 0x%<op>02x', op: op) if frame.nil?
+
+        result = parse_response(frame, op)
+        return result if result
+      end
+    end
+
+    def checksum(data)
+      data.bytes.reduce(CHECKSUM_SEED) { |acc, b| acc ^ b }
+    end
+
+    def slip_encode(packet)
+      escaped = packet.gsub("\xDB".b, "\xDB\xDD".b).gsub("\xC0".b, "\xDB\xDC".b)
+      "\xC0".b + escaped + "\xC0".b
+    end
+
+    def slip_decode(frame)
+      frame.gsub("\xDB\xDC".b, "\xC0".b).gsub("\xDB\xDD".b, "\xDB".b)
+    end
+
+    private
+
+    def stream_blocks(image, blocks)
+      blocks.times do |seq|
+        block = image.byteslice(seq * FLASH_WRITE_SIZE, FLASH_WRITE_SIZE)
+        block += "\xFF".b * (FLASH_WRITE_SIZE - block.bytesize)
+        command(FLASH_DATA,
+                [block.bytesize, seq, 0, 0].pack('V4') + block,
+                checksum: checksum(block), timeout: 5)
+        progress(seq + 1, blocks)
+      end
+      $stderr.print "\n"
+    end
+
+    # Returns [value, data] when the frame is the response to `op`, raises on
+    # an error status, and returns nil for unrelated frames (stale responses).
+    def parse_response(frame, op)
+      return nil if frame.bytesize < 8 + STATUS_BYTES || frame.getbyte(0) != 0x01 ||
+                    frame.getbyte(1) != op
+
+      value  = frame.byteslice(4, 4).unpack1('V')
+      body   = frame.byteslice(8..)
+      status = body.byteslice(-STATUS_BYTES, STATUS_BYTES)
+      if status.getbyte(0) != 0
+        raise Error, format('command 0x%<op>02x failed (error 0x%<err>02x)',
+                            op: op, err: status.getbyte(1))
+      end
+
+      [value, body.byteslice(0...-STATUS_BYTES)]
+    end
+
+    # Reads from the serial port until a complete 0xC0 ... 0xC0 frame is
+    # available or the deadline passes. Returns the decoded frame or nil.
+    def read_frame(deadline)
+      loop do
+        start = @rxbuf.index("\xC0".b)
+        if start
+          stop = @rxbuf.index("\xC0".b, start + 1)
+          if stop
+            frame = @rxbuf.byteslice((start + 1)...stop)
+            @rxbuf = @rxbuf.byteslice((stop + 1)..) || +''.b
+            next if frame.empty? # back-to-back C0 markers
+
+            return slip_decode(frame)
+          end
+        end
+        return nil if Time.now > deadline
+
+        chunk = @serial.read(256) || ''
+        chunk.empty? ? sleep(0.01) : @rxbuf << chunk.b
+      end
+    end
+
+    # The ROM answers a successful SYNC with a burst of identical responses;
+    # swallow them so they are not mistaken for the next command's reply.
+    def drain_responses
+      deadline = Time.now + 0.3
+      loop { break if read_frame(deadline).nil? }
+    end
+
+    def set_lines(dtr:, rts:)
+      return if @fd.nil?
+
+      io = IO.for_fd(@fd, autoclose: false)
+      buf = [0].pack('L')
+      io.ioctl(TIOCMGET, buf)
+      bits = buf.unpack1('L')
+      bits = dtr ? (bits | TIOCM_DTR) : (bits & ~TIOCM_DTR)
+      bits = rts ? (bits | TIOCM_RTS) : (bits & ~TIOCM_RTS)
+      io.ioctl(TIOCMSET, [bits].pack('L'))
+    end
+
+    def progress(done, total)
+      pct = done * 100 / total
+      return if pct == @last_pct
+
+      @last_pct = pct
+      $stderr.print format("\rWriting %<pct>3d%% (%<done>d/%<total>d)",
+                           pct: pct, done: done, total: total)
+    end
+  end
+end

data/lib/prremote/runtime_manager.rb

@@ -4,14 +4,18 @@ require 'fileutils'
 
 module Prremote
   module RuntimeManager
-    BOARDS = %w[pico picow].freeze
-
-    def self.uf2_filename(version, board)
-      "prremote-#{board}-runtime-#{version}.uf2"
+    BOARDS = %w[pico picow esp32].freeze
+
+    # Pico boards ship as UF2 (copied to the BOOTSEL drive); ESP32 ships as a
+    # single merged .bin (bootloader + partition table + app) flashed at 0x0
+    # with esptool.
+    def self.artifact_filename(version, board)
+      ext = board == 'esp32' ? 'bin' : 'uf2'
+      "prremote-#{board}-runtime-#{version}.#{ext}"
     end
 
     def self.release_url(version, board)
-      "https://github.com/lumbermill/prremote/releases/download/runtime-#{version}/#{uf2_filename(version, board)}"
+      "https://github.com/lumbermill/prremote/releases/download/runtime-#{version}/#{artifact_filename(version, board)}"
     end
 
     def self.cache_dir
@@ -19,7 +23,7 @@ module Prremote
     end
 
     def self.cached_path(version, board)
-      File.join(cache_dir, uf2_filename(version, board))
+      File.join(cache_dir, artifact_filename(version, board))
     end
 
     def self.fetch(version, board)
@@ -27,7 +31,7 @@ module Prremote
       return path if File.exist?(path)
 
       FileUtils.mkdir_p(cache_dir)
-      $stderr.print "Downloading #{uf2_filename(version, board)}..."
+      $stderr.print "Downloading #{artifact_filename(version, board)}..."
       $stderr.flush
       download(release_url(version, board), path)
       warn ' done.'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prremote
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - ITO Yosei
@@ -116,6 +116,7 @@ files:
 - lib/prremote/commands/undeploy.rb
 - lib/prremote/commands/watch.rb
 - lib/prremote/detector.rb
+- lib/prremote/esp_flasher.rb
 - lib/prremote/mrbc.rb
 - lib/prremote/runtime_manager.rb
 - lib/prremote/version.rb