prremote 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a30a56541a311e708b79d18eb2f3a07b1007df6fe5c971d307ecbf069b64a78a
-  data.tar.gz: 75bd5a9439f0eacb9237e375010e7d65423c6f8c5556d82b352d946ba3702f88
+  metadata.gz: fa8044b474d22090a340385b2995d1e242b3aa44f820e0f7dbd3486b4b141a77
+  data.tar.gz: 9af86c303d859f714b0f566d1910f200d1e3c70a5e56b8b9e799d61299c10aa6
 SHA512:
-  metadata.gz: bb40ffda0d41b8fa8863eb330597e9f46d4dd0c963763f66a8e543e11fce491b5f969ce84a8986cc6564908f07a9d37951c5e9ed8d9a06591032e4eb7248b0bd
-  data.tar.gz: b740c328761c6c31f0a2bd400b0baf8a537bd4d5e04637223588b9e56e695f870d2d8557790d1a92794a71f3c6be1903f31cb84a0b13ba7e5829edbcc6893dc9
+  metadata.gz: ab718d4431f723ed4af6d17ad744654bf547cf167afa7f1e5bd60aebb96c2d7bd6470a14898a769c7660a5c959331dff5a71527297b4245e9418abe02511c727
+  data.tar.gz: 220d6bf77f25475dd25ecf84ffd09a06ae592469e6c2bc90e4af117086b44a5f408ae90a75666d3cd26a79b38b1fd9832f1470cccd838c9edd4bf54176786ec6

data/README.md

@@ -64,7 +64,8 @@ Flash the prremote runtime firmware to a supported board.
 prremote install                          # show supported boards
 prremote install -b picow                 # Pico W
 prremote install -b pico                  # Pico (no wireless)
-prremote install -b esp32                 # ESP32 (M5GO / M5Stack Core, M5StickC PLUS, etc.)
+prremote install -b esp32                 # ESP32 (M5GO / M5Stack Core, etc.)
+prremote install -b m5stickc_plus         # M5StickC PLUS (esp32 runtime + board library)
 prremote install -b esp32c6               # ESP32-C6 (e.g. XIAO ESP32C6)
 prremote install -b picow --version 0.1.1 # specify a runtime version
 ```
@@ -81,6 +82,8 @@ ESP32-C6: flashing is delegated to [esptool](https://docs.espressif.com/projects
 
 Reflashing the runtime does not erase a deployed script on either chip.
 
+Board names such as `m5stickc_plus` install the runtime image of their chip (esp32) and record the board name on the device, which the runtime then reports (`prremote version` shows `board=m5stickc_plus`). That name decides which [board libraries](#board-libraries) scripts can use; installing with the plain chip name (`-b esp32`) clears it.
+
 ---
 
 ### `run FILE [FILE ...]`
@@ -177,8 +180,8 @@ Show the gem version, mrbc version, and the connected device's runtime version.
 
 ```bash
 prremote version
-# prremote: 0.4.0
-# runtime:  0.4.0 (/dev/tty.usbmodem101)
+# prremote: 0.4.1
+# runtime:  0.4.1 board=picow (/dev/tty.usbmodem101)
 # mrbc: mruby 4.0.0 (2026-04-20) (/opt/homebrew/bin/mrbc)
 ```
 
@@ -213,6 +216,25 @@ prremote undeploy         # remove from flash
 
 ---
 
+## Board libraries
+
+Some boards come with a Ruby library for their built-in hardware. You don't load it yourself: when a script mentions one of its classes, `run` / `deploy` / `watch` / `eval` compile the library in ahead of your files (it prints `Adding board library: ...`). Scripts that don't mention it pay nothing on the device.
+
+| Board (`install -b`) | Classes | Covers |
+|---|---|---|
+| `m5stickc_plus` | `M5StickCPlus`, `BM8563` | AXP192 power-on, LCD preset per rotation, buttons A/B, red LED, buzzer, IR LED, BM8563 RTC (as `Time`) |
+
+```ruby
+stick = M5StickCPlus.new            # powers the LCD
+lcd = stick.lcd(rotation: 1)        # pins / size / RAM offset / color order preset
+lcd.text(4, 4, stick.rtc.time.to_s, scale: 1)
+stick.led.on if stick.button_a.pressed?
+```
+
+A board library is refused if the device reports a different board (e.g. `M5StickCPlus` on an esp32c6). Chip drivers such as `BM8563` work on any board. The library sources live in [lib/prremote/boards/](lib/prremote/boards/) and double as the reference for driving the hardware directly.
+
+---
+
 ## How It Works
 
 prremote flashes a minimal C firmware (built on mruby/c) onto the board. The firmware:

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/prremote/boards/bm8563.rb

@@ -0,0 +1,55 @@
+# BM8563 / PCF8563 real-time clock (I2C address 0x51).
+# Board library for prremote — compiled into the script by the host when it
+# references BM8563 (see lib/prremote/boards.rb); this file runs on the device.
+#
+#   rtc = BM8563.new(i2c)
+#   rtc.valid?                 # false until the time has been set (VL flag)
+#   puts rtc.time.to_s         # => "2026-09-28T08:30:42+9" (a Time)
+#   rtc.time = Time.new(offset: 9).sync("ntp.nict.jp")
+#
+# The chip holds local time; `time(offset:)` says which zone that is (JST by
+# default) and `time=` writes the given Time in its own offset.
+class BM8563
+  ADDR = 0x51
+
+  def initialize(i2c)
+    @i2c = i2c
+  end
+
+  # false while the VL (voltage-low) flag says the clock lost integrity —
+  # never set, or the backup battery ran out.
+  def valid?
+    r = @i2c.read(ADDR, 1, 0x02)
+    !r.nil? && r.getbyte(0) < 0x80
+  end
+
+  def time(offset: 9)
+    r = @i2c.read(ADDR, 7, 0x02).bytes
+    t = Time.new(offset: offset)
+    year = _dec(r[6]) + (r[5] < 0x80 ? 2000 : 1900) # month bit7 = century
+    days = t._days_since_epoch(year, _dec(r[5] & 0x1F), _dec(r[3] & 0x3F))
+    t._set_from_epoch((days * 86_400) + _seconds_of_day(r) - (offset * 3600))
+    t
+  end
+
+  # Also clears the VL flag and restarts the clock if it was stopped.
+  def time=(t)
+    wday = (((t.epoch + (t.utc_offset * 3600)) / 86_400) + 4) % 7 # 1970-01-01 = Thu
+    @i2c.write(ADDR, 0x00, 0x00, 0x00) # control 1/2: running, no alarm/timer IRQ
+    @i2c.write(ADDR, 0x02, _bcd(t.sec), _bcd(t.min), _bcd(t.hour), _bcd(t.day),
+               wday, _bcd(t.month), _bcd(t.year % 100))
+  end
+
+  # r: registers 0x02.. (sec, min, hour, ...)
+  def _seconds_of_day(r)
+    (_dec(r[2] & 0x3F) * 3600) + (_dec(r[1] & 0x7F) * 60) + _dec(r[0] & 0x7F)
+  end
+
+  def _dec(b)
+    ((b >> 4) * 10) + (b & 0x0F)
+  end
+
+  def _bcd(n)
+    ((n / 10) << 4) | (n % 10)
+  end
+end

data/lib/prremote/boards/m5stickc_plus.rb

@@ -0,0 +1,102 @@
+# M5StickC PLUS board support: power-on, LCD preset and built-in devices.
+# Board library for prremote — compiled into the script by the host when it
+# references M5StickCPlus (see lib/prremote/boards.rb); this file runs on the
+# device (esp32 runtime) together with bm8563.rb.
+#
+#   stick = M5StickCPlus.new         # powers the LCD via the AXP192 PMIC
+#   lcd = stick.lcd(rotation: 1)     # landscape; 0-3 all preset
+#   stick.button_a.pressed?          # front button; button_b = side button
+#   stick.led.on                     # red LED
+#   stick.tone(440, 0.2)             # passive buzzer
+#   stick.rtc.time.to_s              # BM8563 RTC (see bm8563.rb)
+#   stick.ir.send_nec(0x00, 0x45)    # IR LED
+#
+# Built-in devices share one I2C bus (SDA=21/SCL=22): AXP192 0x34, BM8563
+# 0x51, MPU6886 0x68 — use stick.i2c for anything else on it.
+class M5StickCPlus
+  AXP192 = 0x34
+
+  # ST7789v2 135x240 inside a 240x320 RAM window. Per rotation: MADCTL (the
+  # generic table minus its BGR bit — this panel is RGB) and the RAM offset
+  # of the 135-px side, which is 52 px from one edge and 53 from the other,
+  # so it changes when a rotation mirrors that axis.
+  LCD_MADCTL   = [0x00, 0x60, 0xC0, 0xA0]
+  LCD_OFFSET_X = [52, 53, 53, 52]
+
+  attr_reader :i2c
+
+  def initialize
+    @i2c = I2C.new(sda_pin: 21, scl_pin: 22)
+    @i2c.write(AXP192, 0x28, 0xCC)             # LDO2 (backlight) / LDO3 (panel) = 3.0V
+    cur = @i2c.read(AXP192, 1, 0x12).getbyte(0)
+    @i2c.write(AXP192, 0x12, cur | 0x4D)       # enable EXTEN (Grove 5V), LDO2, LDO3, DCDC1
+  end
+
+  # rotation: 0 = portrait (USB at the bottom), 1/3 = landscape, 2 = portrait
+  # upside down. Returns a plain LCD (see lcd_wrap.rb for drawing methods).
+  def lcd(rotation: 0)
+    r = rotation % 4
+    LCD.new(rotation: r, sck_pin: 13, mosi_pin: 15, miso_pin: -1, cs_pin: 5,
+            dc_pin: 23, rst_pin: 18, bl_pin: -1, invert: true,
+            madctl: LCD_MADCTL[r], width: 135, height: 240,
+            offset_x: LCD_OFFSET_X[r], offset_y: 40)
+  end
+
+  def rtc
+    @rtc ||= BM8563.new(@i2c)
+  end
+
+  # Front (big) button.
+  def button_a
+    @button_a ||= Button.new(37)
+  end
+
+  # Side button, opposite the power button.
+  def button_b
+    @button_b ||= Button.new(39)
+  end
+
+  def led
+    @led ||= LED.new(10)
+  end
+
+  # Plays `hz` on the passive buzzer (GPIO2) for `duration` seconds.
+  def tone(hz, duration)
+    @buzzer ||= PWM.new(2, frequency: hz, duty_u16: 0)
+    @buzzer.frequency = hz
+    @buzzer.duty_u16 = 32_768
+    sleep duration
+    @buzzer.duty_u16 = 0
+  end
+
+  def ir
+    @ir ||= IR.new(9)
+  end
+
+  # External pull-up on the board; pressed reads 0.
+  class Button
+    def initialize(pin)
+      @gpio = GPIO.new(pin, GPIO::IN)
+    end
+
+    def pressed?
+      @gpio.read == 0
+    end
+  end
+
+  # Active-low red LED.
+  class LED
+    def initialize(pin)
+      @gpio = GPIO.new(pin, GPIO::OUT)
+      off
+    end
+
+    def on
+      @gpio.write(0)
+    end
+
+    def off
+      @gpio.write(1)
+    end
+  end
+end

data/lib/prremote/boards.rb

@@ -0,0 +1,85 @@
+module Prremote
+  # Board support libraries: Ruby files under lib/prremote/boards/ that run on
+  # the device (not on the host). They are compiled into the user's script
+  # only when the script references one of their constants, so scripts that
+  # don't use them pay nothing in device heap / symbol table.
+  #
+  # A board name is what `install -b NAME` records on the device and what the
+  # runtime reports in its READY banner (`READY prremote-runtime/X board=NAME`).
+  # Several board names can share one runtime image (FIRMWARE).
+  module Boards
+    LIB_DIR = File.expand_path('boards', __dir__)
+
+    # Board name => runtime image it runs. Boards not listed here are their
+    # own image (pico, picow, esp32, esp32c6, ...).
+    FIRMWARE = {
+      'm5stickc_plus' => 'esp32'
+    }.freeze
+
+    # file:      path under LIB_DIR
+    # constants: referencing any of these pulls the library in
+    # boards:    board names it is written for (nil = any board)
+    # requires:  other library files it needs, compiled before it
+    Library = Struct.new(:file, :constants, :boards, :requires, keyword_init: true)
+
+    LIBRARIES = [
+      Library.new(file: 'bm8563.rb', constants: %w[BM8563], boards: nil, requires: []),
+      Library.new(file: 'm5stickc_plus.rb', constants: %w[M5StickCPlus],
+                  boards: %w[m5stickc_plus], requires: %w[bm8563.rb])
+    ].freeze
+
+    module_function
+
+    def firmware_for(board)
+      FIRMWARE.fetch(board, board)
+    end
+
+    # Board names `install` accepts on top of the plain runtime images.
+    def names
+      FIRMWARE.keys
+    end
+
+    # Libraries the sources reference directly.
+    def referenced(sources)
+      LIBRARIES.select { |lib| referenced?(lib, sources) }
+    end
+
+    # Library file paths to compile ahead of the user's sources, in dependency
+    # order. Depends only on the sources, so it can run before connecting.
+    def library_paths(sources)
+      files = []
+      referenced(sources).each { |lib| add_with_requires(lib.file, files) }
+      files.map { |f| File.join(LIB_DIR, f) }
+    end
+
+    # Raises if a referenced library is for another board than the device's
+    # (`board` is nil when the runtime is too old to report one).
+    def check!(sources, board)
+      referenced(sources).each { |lib| check_board!(lib, board) }
+    end
+
+    def referenced?(lib, sources)
+      lib.constants.any? { |c| sources.any? { |src| src.match?(/\b#{c}\b/) } }
+    end
+
+    # A board library also runs on a device that only reports its runtime
+    # image name (installed with the plain `-b esp32`, or a runtime older than
+    # board names), since the host cannot tell those boards apart.
+    def check_board!(lib, board)
+      return if lib.boards.nil? || board.nil?
+      return if lib.boards.include?(board)
+      return if lib.boards.any? { |b| firmware_for(b) == board }
+
+      raise "#{lib.constants.join('/')} is for #{lib.boards.join('/')}, " \
+            "but the device reports board=#{board}"
+    end
+
+    def add_with_requires(file, files)
+      return if files.include?(file)
+
+      lib = LIBRARIES.find { |l| l.file == file }
+      lib&.requires&.each { |dep| add_with_requires(dep, files) }
+      files << file
+    end
+  end
+end

data/lib/prremote/cli.rb

@@ -27,7 +27,7 @@ module Prremote
     desc 'install', 'Flash prremote runtime firmware to a supported board'
     option :version, type: :string, desc: "Firmware version to install (default: #{VERSION})"
     option :board, aliases: '-b', type: :string,
-                   desc: "Board type: #{RuntimeManager::BOARDS.join(', ')}"
+                   desc: "Board type: #{Commands::Install.board_names.join(', ')}"
     option :verbose, aliases: '-V', type: :boolean, default: false,
                      desc: 'Print step-by-step flash diagnostics'
     def install
@@ -36,14 +36,14 @@ module Prremote
 
       unless board
         puts "Specify a board with --board / -b. Supported boards:"
-        RuntimeManager::BOARDS.each { |b| puts "  #{b}" }
+        Commands::Install.board_names.each { |b| puts "  #{b}" }
         puts
         puts "Example: prremote install -b esp32c6"
         return
       end
 
-      unless RuntimeManager::BOARDS.include?(board)
-        raise Thor::Error, "Unknown board '#{board}'. Supported boards: #{RuntimeManager::BOARDS.join(', ')}"
+      unless Commands::Install.board_names.include?(board)
+        raise Thor::Error, "Unknown board '#{board}'. Supported boards: #{Commands::Install.board_names.join(', ')}"
       end
 
       Commands::Install.new(version: version, board: board, port: options[:port],
@@ -188,7 +188,8 @@ module Prremote
           next
         end
 
-        return "#{::Regexp.last_match(1)} (#{port})" if buf =~ %r{READY prremote-runtime/([\d.]+)}
+        ready = format_ready(buf, port)
+        return ready if ready
         return '(not responding)' if Time.now > deadline
 
         sleep 0.05
@@ -199,6 +200,16 @@ module Prremote
       serial&.close
     end
 
+    # "0.4.1 board=m5stickc_plus (/dev/...)" from a complete READY line, else
+    # nil. Runtimes older than board names omit the board= field.
+    def format_ready(buf, port)
+      m = buf.match(%r{READY prremote-runtime/([\d.]+)(?: board=(\S+))?\s*\n})
+      return nil unless m
+
+      board = m[2] ? " board=#{m[2]}" : ''
+      "#{m[1]}#{board} (#{port})"
+    end
+
     def resolve_port
       return options[:port] if options[:port]
 

data/lib/prremote/commands/deploy.rb

@@ -1,6 +1,3 @@
-require 'open3'
-require 'tempfile'
-require_relative '../mrbc'
 require_relative 'serial_helpers'
 
 module Prremote
@@ -20,29 +17,19 @@ module Prremote
         rb_paths.each { |f| raise "File not found: #{f}" unless File.exist?(f) }
 
         warn "Compiling #{rb_paths.map { |f| File.basename(f) }.join(', ')}..."
-        mrb_data = compile(*rb_paths)
+        mrb_data = compile_with_boards(rb_paths)
 
-        warn 'Deploying to flash...'
         deploy_to_device(mrb_data, rb_paths)
         warn 'Deployed. Script will run automatically on next boot.'
       end
 
       private
 
-      def compile(*rb_paths)
-        Mrbc.check_version!
-        tmp = Tempfile.new(['prremote', '.mrb'])
-        out, status = Open3.capture2e(Mrbc.bin, '-o', tmp.path, *rb_paths)
-        raise "mrbc failed:\n#{out.chomp}" unless status.success?
-
-        File.binread(tmp.path)
-      ensure
-        tmp&.close!
-      end
-
       def deploy_to_device(mrb_data, rb_paths)
         serial = Serial.new(@port, @baud)
-        wait_for_ready(serial)
+        check_board!(wait_for_ready(serial), rb_paths)
+
+        warn 'Deploying to flash...'
         write_chunked(serial, DEPLOY_MAGIC + build_meta_packet(rb_paths) + mrb_data)
         wait_for_deployed(serial)
       ensure

data/lib/prremote/commands/install.rb

@@ -1,17 +1,31 @@
 require 'fileutils'
+require_relative '../boards'
+require_relative 'serial_helpers'
 
 module Prremote
   module Commands
     class Install
+      include SerialHelpers
+
+      BOARD_MAGIC = 'BORD'.freeze
+
+      # board may be a runtime image name (esp32) or a board sharing one
+      # (m5stickc_plus → esp32 image); see Boards::FIRMWARE.
       def initialize(version: VERSION, board: 'picow', port: nil, verbose: false)
-        @version = version
-        @board   = board
-        @port    = port
-        @verbose = verbose
+        @version  = version
+        @board    = board
+        @firmware = Boards.firmware_for(board)
+        @port     = port
+        @verbose  = verbose
+      end
+
+      # Runtime images plus boards that share one (m5stickc_plus).
+      def self.board_names
+        RuntimeManager::BOARDS + Boards.names
       end
 
       def call
-        return install_esp32 if RuntimeManager::ESP32_BOARDS.include?(@board)
+        return install_esp32 if RuntimeManager::ESP32_BOARDS.include?(@firmware)
 
         uf2_path = RuntimeManager.fetch(@version, @board)
 
@@ -38,15 +52,48 @@ module Prremote
       # 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)
+        image = RuntimeManager.fetch(@version, @firmware)
         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, board: @board, verbose: @verbose)
+        EspFlasher.flash(port: port, image_path: image, board: @firmware, verbose: @verbose)
+        record_board(port)
         puts "Done. Runtime #{@version} installed."
       end
 
+      # One ESP32 image serves several boards, so tell the runtime which one
+      # this is (kept in NVS; reported as board= in READY, which picks the
+      # board libraries). Installing the plain image clears it.
+      def record_board(port)
+        name = @board == @firmware ? '' : @board
+        serial = Serial.new(port, 115_200)
+        wait_for_ready(serial)
+        serial.write(BOARD_MAGIC + [name.bytesize].pack('C') + name)
+        reply = wait_for_board_reply(serial)
+        if reply.nil?
+          warn "WARNING: runtime #{@version} does not record board names; board=#{@board} not set."
+        elsif !name.empty?
+          puts "Board: #{reply}"
+        end
+      ensure
+        serial&.close
+      end
+
+      # "BOARD <name>" on success; nil if the runtime predates the command.
+      def wait_for_board_reply(serial)
+        buf = +''
+        deadline = Time.now + 3
+        loop do
+          buf << normalize(safe_read(serial, 256))
+          return Regexp.last_match(1) if buf =~ /^BOARD (\S+)\n/
+          raise "Device rejected board name '#{@board}'" if buf.include?("ERROR board\n")
+          return nil if Time.now > deadline
+
+          sleep 0.05
+        end
+      end
+
       def volume_paths
         [
           '/Volumes/RPI-RP2',

data/lib/prremote/commands/run.rb

@@ -1,6 +1,3 @@
-require 'open3'
-require 'tempfile'
-require_relative '../mrbc'
 require_relative 'serial_helpers'
 
 module Prremote
@@ -17,31 +14,20 @@ module Prremote
         rb_paths.each { |f| raise "File not found: #{f}" unless File.exist?(f) }
 
         warn "Compiling #{rb_paths.map { |f| File.basename(f) }.join(', ')}..."
-        mrb_data = compile(*rb_paths)
+        mrb_data = compile_with_boards(rb_paths)
 
-        warn 'Running...'
-        run_on_device(mrb_data)
+        run_on_device(mrb_data, rb_paths)
       rescue Interrupt
         warn ''
       end
 
       private
 
-      def compile(*rb_paths)
-        Mrbc.check_version!
-        tmp = Tempfile.new(['prremote', '.mrb'])
-        out, status = Open3.capture2e(Mrbc.bin, '-o', tmp.path, *rb_paths)
-        raise "mrbc failed:\n#{out.chomp}" unless status.success?
-
-        File.binread(tmp.path)
-      ensure
-        tmp&.close!
-      end
-
-      def run_on_device(mrb_data)
+      def run_on_device(mrb_data, rb_paths)
         serial = Serial.new(@port, @baud)
-        wait_for_ready(serial)
+        check_board!(wait_for_ready(serial), rb_paths)
 
+        warn 'Running...'
         write_chunked(serial, mrb_data)
         debug "sent #{mrb_data.bytesize} bytes (first 4: #{mrb_data[0, 4].inspect})"
 

data/lib/prremote/commands/serial_helpers.rb

@@ -1,3 +1,6 @@
+require_relative '../boards'
+require_relative '../mrbc'
+
 module Prremote
   module Commands
     module SerialHelpers
@@ -16,9 +19,10 @@ module Prremote
         next_ctrl = Time.now + 1
         loop do
           buf << normalize(safe_read(serial, 256))
-          if buf.include?('READY ')
+          # Wait for the whole line: the board= field follows the version.
+          if buf.match?(/READY [^\n]*\n/)
             warn_if_runtime_outdated(buf)
-            return
+            return parse_ready(buf)
           end
           raise 'Timeout waiting for device. Run `prremote reset` if a script is running.' if Time.now > deadline
 
@@ -30,6 +34,32 @@ module Prremote
         end
       end
 
+      # READY banner fields. board is nil on runtimes older than board names.
+      Ready = Struct.new(:version, :board)
+
+      def parse_ready(buf)
+        m = buf.match(%r{READY prremote-runtime/(\S+)(?: board=(\S+))?})
+        m ? Ready.new(m[1], m[2]) : Ready.new(nil, nil)
+      end
+
+      # Compiles the user's files, prepending the board libraries they
+      # reference (see Boards). Done before connecting: an open ESP32 port can
+      # reset the chip, so the gap between READY and sending stays minimal.
+      def compile_with_boards(rb_paths)
+        libs = Boards.library_paths(sources_of(rb_paths))
+        warn "Adding board library: #{libs.map { |f| File.basename(f) }.join(', ')}" unless libs.empty?
+        Mrbc.compile(*libs, *rb_paths)
+      end
+
+      # After READY: refuse a board library meant for another board.
+      def check_board!(ready, rb_paths)
+        Boards.check!(sources_of(rb_paths), ready.board)
+      end
+
+      def sources_of(rb_paths)
+        rb_paths.map { |f| File.read(f, encoding: 'UTF-8') }
+      end
+
       def normalize(str)
         str.gsub("\r\n", "\n").gsub("\r", '')
       end

data/lib/prremote/mrbc.rb

@@ -1,4 +1,5 @@
 require 'open3'
+require 'tempfile'
 
 module Prremote
   # mrbc lookup order:
@@ -43,6 +44,18 @@ module Prremote
       @version_ok = true
     end
 
+    # Compiles the given .rb files (in order) into one .mrb; returns its bytes.
+    def self.compile(*rb_paths)
+      check_version!
+      tmp = Tempfile.new(['prremote', '.mrb'])
+      out, status = Open3.capture2e(bin, '-o', tmp.path, *rb_paths)
+      raise "mrbc failed:\n#{out.chomp}" unless status.success?
+
+      File.binread(tmp.path)
+    ensure
+      tmp&.close!
+    end
+
     private_class_method def self.path_candidates
       ENV['PATH'].split(File::PATH_SEPARATOR)
                  .grep_v(SHIMS_RE)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prremote
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - ITO Yosei
@@ -106,6 +106,9 @@ files:
 - VERSION
 - bin/prremote
 - lib/prremote.rb
+- lib/prremote/boards.rb
+- lib/prremote/boards/bm8563.rb
+- lib/prremote/boards/m5stickc_plus.rb
 - lib/prremote/cli.rb
 - lib/prremote/commands/deploy.rb
 - lib/prremote/commands/eval_cmd.rb