rubyduino 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aebef08a8012ff1994cfef5f943278222b9cc76c0147398d467d2a815121c37c
+  data.tar.gz: d48692b143f9248dcae3cddc6db3b823ce9386e0a28e693133c88d28a4fea72d
+SHA512:
+  metadata.gz: 3bbdc16bf822d3bc4ed389a64fbaa3fbc61d9dfa97604baf0c19d35a9ab0918040e1e2de5d1ccae958b2972338e18be6725eeefdd40291ab0b06fbeab067302b
+  data.tar.gz: 54625b52317c6de6607655e81cbb1e9b19f493c9b1eb669f50edfe080c06b6a863ed07ab72d29e55af1a626a23d760103aa7142843f81499cd6aa7fb9879e989

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/spinel"]
+	path = vendor/spinel
+	url = https://github.com/matz/spinel

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-05-08
+
+- Initial release
+
+## [0.1.1] - 2026-05-08
+
+- Fix avrdude discovery for installed command

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Joseph Schito
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+<div align="center">
+
+# Rubyduino
+
+<img width="250" height="250" alt="image copy" src="https://github.com/user-attachments/assets/156c7d41-ed42-43f3-a720-ed2e9c12b52c" />
+
+Rubyduino compiles Ruby sketches for Arduino boards and uploads the generated firmware.
+
+Under the hood it uses [Spinel](https://github.com/matz/spinel), a Ruby AOT compiler, vendored at a pinned revision.
+
+</div>
+
+## Example
+
+<img width="500" height="281" alt="IMG_0197" src="https://github.com/user-attachments/assets/d2b1cc69-647a-4f63-b090-31b13a21e5a8" />
+
+```ruby
+system("pin13:output")
+
+loop do
+  duration = 0.1
+  system("pin13:high")
+  sleep duration
+  system("pin13:low")
+  sleep duration
+end
+```
+
+Not bad, huh?
+
+## Installation
+
+```bash
+gem install rubyduino
+```
+
+The command expects the AVR toolchain to be available in `PATH`, including `avr-gcc`, `avr-objcopy`, and `avrdude`.
+
+On macOS, install the AVR tools with Homebrew:
+
+```bash
+brew tap osx-cross/avr
+brew install avr-gcc avrdude
+```
+
+On Debian/Ubuntu:
+
+```bash
+sudo apt install gcc-avr avr-libc avrdude
+```
+
+On Fedora:
+
+```bash
+sudo dnf install avr-gcc avr-libc avrdude
+```
+
+## Usage
+
+```bash
+rubyduino examples/hello.rb
+```
+
+Pass a serial port explicitly when auto-detection is not enough:
+
+```bash
+rubyduino -p /dev/cu.usbmodem11401 examples/hello.rb
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/bin/rubyduino

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "English"
+require "open3"
+require "rbconfig"
+require "tmpdir"
+
+def usage
+  warn "Usage: rubyduino [options] input.rb"
+  warn ""
+  warn "Options:"
+  warn "  -p PORT      Serial port, e.g. /dev/cu.usbmodem31401"
+  warn "  -o NAME      Output base path without extension"
+  warn "  --mcu MCU    AVR MCU, default: atmega328p"
+  warn "  --baud BAUD  Upload baud, default: 115200"
+  exit 1
+end
+
+def run!(*cmd, chdir: nil, env: {})
+  options = {}
+  options[:chdir] = chdir if chdir
+  ok = system(env, *cmd, **options)
+  return if ok
+
+  status = $CHILD_STATUS&.exitstatus
+  abort "rubyduino: command failed#{status ? " with exit #{status}" : ""}: #{cmd.join(" ")}"
+end
+
+def capture!(*cmd)
+  out, status = Open3.capture2e(*cmd)
+  return out.strip if status.success?
+
+  abort out.empty? ? "rubyduino: command failed: #{cmd.join(" ")}" : out
+end
+
+def command?(name)
+  !executable(name).nil?
+end
+
+def executable(name)
+  ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).filter_map do |dir|
+    path = File.join(dir, name)
+    path if File.file?(path) && File.executable?(path)
+  end.first
+end
+
+def runnable_executable?(path)
+  _output, status = Open3.capture2e(path, "-?")
+  status.success?
+rescue SystemCallError
+  false
+end
+
+def find_port
+  patterns = %w[
+    /dev/cu.usbmodem*
+    /dev/cu.usbserial*
+    /dev/ttyACM*
+    /dev/ttyUSB*
+  ]
+  patterns.lazy.flat_map { |pattern| Dir.glob(pattern) }.first
+end
+
+def find_avrdude
+  candidates = ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).filter_map do |dir|
+    path = File.join(dir, "avrdude")
+    path if File.file?(path) && File.executable?(path)
+  end
+
+  candidates.concat(
+    Dir.glob(
+      [
+        "/Applications/Arduino.app/Contents/**/bin/avrdude",
+        "/opt/homebrew/**/bin/avrdude",
+        "/usr/local/**/bin/avrdude"
+      ]
+    )
+  )
+
+  candidates.uniq.find { |path| runnable_executable?(path) }
+end
+
+def avrdude_conf_for(avrdude)
+  conf = File.expand_path("../etc/avrdude.conf", File.dirname(avrdude))
+  File.file?(conf) ? conf : nil
+end
+
+root_dir = File.expand_path("..", __dir__)
+unless Dir.exist?(File.join(root_dir, "vendor/spinel"))
+  require "rubyduino/spinel"
+  root_dir = File.expand_path("../..", Rubyduino::Spinel::ROOT)
+end
+
+spinel_dir = File.join(root_dir, "vendor/spinel")
+rubyduino_dir = File.join(root_dir, "lib/rubyduino")
+parse_bin = File.join(spinel_dir, "spinel_parse")
+codegen_rb = File.join(rubyduino_dir, "spinel_arduino_codegen.rb")
+entry_c = File.join(rubyduino_dir, "arduino_entry.c")
+
+mcu = "atmega328p"
+f_cpu = "16000000UL"
+baud = "115200"
+port = nil
+out = nil
+source = nil
+
+argv = ARGV.dup
+until argv.empty?
+  arg = argv.shift
+  case arg
+  when "-p"
+    usage if argv.empty?
+    port = argv.shift
+  when "-o"
+    usage if argv.empty?
+    out = argv.shift
+  when "--mcu"
+    usage if argv.empty?
+    mcu = argv.shift
+  when "--baud"
+    usage if argv.empty?
+    baud = argv.shift
+  when "-h", "--help"
+    usage
+  when /\.rb\z/
+    usage if source
+    source = arg
+  else
+    usage
+  end
+end
+
+usage unless source
+abort "rubyduino: #{source}: No such file" unless File.file?(source)
+abort "rubyduino: missing Spinel checkout at #{spinel_dir}" unless Dir.exist?(spinel_dir)
+abort "rubyduino: missing #{codegen_rb}" unless File.file?(codegen_rb)
+abort "rubyduino: missing #{entry_c}" unless File.file?(entry_c)
+abort "rubyduino: avr-gcc not found" unless command?("avr-gcc")
+abort "rubyduino: avr-objcopy not found" unless command?("avr-objcopy")
+
+unless File.executable?(parse_bin)
+  if command?("make")
+    warn "Spinel: building parser in #{spinel_dir}"
+    prism_header = File.join(spinel_dir, "vendor/prism/include/prism/diagnostic.h")
+    run!("make", "-C", spinel_dir, "deps") unless File.file?(prism_header)
+    run!("make", "-C", spinel_dir, "PRISM_DIR=vendor/prism", "parse")
+  end
+end
+abort "rubyduino: missing #{parse_bin}; run 'make -C #{spinel_dir} parse'" unless File.executable?(parse_bin)
+
+out ||= source.end_with?(".rb") ? source.delete_suffix(".rb") : source
+c_file = "#{out}.c"
+elf_file = "#{out}.elf"
+hex_file = "#{out}.hex"
+app_obj = "#{out}.o"
+entry_obj = "#{out}.entry.o"
+
+port ||= find_port
+abort "rubyduino: no Arduino serial port found; pass -p /dev/..." unless port
+
+avrdude = find_avrdude
+abort "rubyduino: avrdude not found" unless avrdude
+
+ast_tmp = File.join(Dir.tmpdir, "spinel_arduino_ast.#{$PROCESS_ID}.#{rand(1_000_000)}")
+begin
+  warn "Spinel: #{source} -> #{c_file}"
+  run!(parse_bin, source, ast_tmp)
+  run!(RbConfig.ruby, codegen_rb, ast_tmp, c_file)
+
+  warn "AVR: #{c_file} -> #{hex_file}"
+  compile_flags = ["-Os", "-DF_CPU=#{f_cpu}", "-mmcu=#{mcu}", "-I#{rubyduino_dir}", "-I#{File.join(spinel_dir, "lib")}"]
+  run!("avr-gcc", *compile_flags, "-Dmain=sp_arduino_user_main", "-c", c_file, "-o", app_obj)
+  run!("avr-gcc", *compile_flags, "-c", entry_c, "-o", entry_obj)
+  run!("avr-gcc", "-Os", "-DF_CPU=#{f_cpu}", "-mmcu=#{mcu}", app_obj, entry_obj, "-o", elf_file)
+  run!("avr-objcopy", "-O", "ihex", "-R", ".eeprom", elf_file, hex_file)
+  run!("avr-size", "--mcu=#{mcu}", "--format=avr", elf_file) if command?("avr-size")
+
+  warn "Flash: #{hex_file} -> #{port}"
+  conf = avrdude_conf_for(avrdude)
+  conf_args = conf ? ["-C#{conf}"] : []
+  run!(avrdude, *conf_args, "-p#{mcu}", "-carduino", "-P#{port}", "-b#{baud}", "-D", "-Uflash:w:#{hex_file}:i")
+ensure
+  FileUtils.rm_f(ast_tmp)
+end

data/examples/hello.rb

@@ -0,0 +1,9 @@
+system("pin13:output")
+
+loop do
+  duration = 0.1
+  system("pin13:high")
+  sleep duration
+  system("pin13:low")
+  sleep duration
+end

data/lib/rubyduino/arduino_entry.c

@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+int sp_arduino_user_main(int argc, char **argv);
+
+int main(void) {
+  char arg0[] = "sketch";
+  char *argv[] = { arg0, NULL };
+  return sp_arduino_user_main(1, argv);
+}

data/lib/rubyduino/sp_runtime.h

@@ -0,0 +1,159 @@
+#ifndef SP_ARDUINO_RUNTIME_H
+#define SP_ARDUINO_RUNTIME_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <avr/io.h>
+#include <util/delay.h>
+#include <util/delay_basic.h>
+
+typedef int32_t mrb_int;
+typedef double mrb_float;
+typedef mrb_int sp_sym;
+typedef uint8_t mrb_bool;
+
+typedef struct {
+  mrb_int first;
+  mrb_int last;
+} sp_Range;
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+static int sp_last_status = 0;
+
+#define time(value) ((mrb_int)1)
+
+#define SP_GC_SAVE() ((void)0)
+#define SP_GC_ROOT(value) ((void)0)
+#define SP_GC_RESTORE() ((void)0)
+
+typedef void (*sp_gc_scan_func)(void *);
+
+static void *sp_gc_alloc(size_t size, void (*free_func)(void *), sp_gc_scan_func scan_func) {
+  (void)free_func;
+  (void)scan_func;
+  return malloc(size);
+}
+
+static void sp_gc_mark(void *ptr) {
+  (void)ptr;
+}
+
+typedef struct {
+  mrb_int *data;
+  mrb_int len;
+  mrb_int cap;
+} sp_IntArray;
+
+typedef struct {
+  mrb_float *data;
+  mrb_int len;
+  mrb_int cap;
+} sp_FloatArray;
+
+static const char *sp_str_dup_external(const char *s) {
+  return s;
+}
+
+static sp_Range sp_range_new(mrb_int first, mrb_int last) {
+  sp_Range range;
+  range.first = first;
+  range.last = last;
+  return range;
+}
+
+static sp_IntArray *sp_IntArray_new(void) {
+  sp_IntArray *array = (sp_IntArray *)malloc(sizeof(sp_IntArray));
+  array->len = 0;
+  array->cap = 4;
+  array->data = (mrb_int *)malloc(sizeof(mrb_int) * array->cap);
+  return array;
+}
+
+static void sp_IntArray_push(sp_IntArray *array, mrb_int value) {
+  if (array->len >= array->cap) {
+    array->cap *= 2;
+    array->data = (mrb_int *)realloc(array->data, sizeof(mrb_int) * array->cap);
+  }
+  array->data[array->len] = value;
+  array->len++;
+}
+
+static mrb_int sp_IntArray_length(sp_IntArray *array) {
+  return array->len;
+}
+
+static mrb_int sp_IntArray_get(sp_IntArray *array, mrb_int index) {
+  return array->data[index];
+}
+
+static sp_FloatArray *sp_FloatArray_new(void) {
+  sp_FloatArray *array = (sp_FloatArray *)malloc(sizeof(sp_FloatArray));
+  array->len = 0;
+  array->cap = 4;
+  array->data = (mrb_float *)malloc(sizeof(mrb_float) * array->cap);
+  return array;
+}
+
+static void sp_FloatArray_push(sp_FloatArray *array, mrb_float value) {
+  if (array->len >= array->cap) {
+    array->cap *= 2;
+    array->data = (mrb_float *)realloc(array->data, sizeof(mrb_float) * array->cap);
+  }
+  array->data[array->len] = value;
+  array->len++;
+}
+
+static mrb_int sp_FloatArray_length(sp_FloatArray *array) {
+  return array->len;
+}
+
+static mrb_float sp_FloatArray_get(sp_FloatArray *array, mrb_int index) {
+  return array->data[index];
+}
+
+static int sp_streq(const char *a, const char *b) {
+  while (*a && *b && *a == *b) {
+    a++;
+    b++;
+  }
+  return *a == *b;
+}
+
+static int sp_arduino_system(const char *cmd) {
+  if (sp_streq(cmd, "pin13:output")) {
+    DDRB |= _BV(DDB5);
+    return 0;
+  }
+  if (sp_streq(cmd, "pin13:high")) {
+    PORTB |= _BV(PORTB5);
+    return 0;
+  }
+  if (sp_streq(cmd, "pin13:low")) {
+    PORTB &= (uint8_t)~_BV(PORTB5);
+    return 0;
+  }
+  return 1;
+}
+
+static void sp_arduino_delay_ms(unsigned long ms) {
+  while (ms > 0) {
+    _delay_loop_2((uint16_t)(F_CPU / 4000UL));
+    ms--;
+  }
+}
+
+static void sp_arduino_sleep_seconds(double seconds) {
+  sp_arduino_delay_ms((unsigned long)(seconds * 1000.0 + 0.5));
+}
+
+#define system(cmd) sp_arduino_system(cmd)
+#define sleep(seconds) sp_arduino_delay_ms((unsigned long)((seconds) * 1000.0 + 0.5))
+#define fflush(stream) ((void)0)
+
+#endif

data/lib/rubyduino/spinel.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rubyduino
+  module Spinel
+    COMMIT = "a70208094343b9d4cd306218c909d99781661c2f"
+    ROOT = File.expand_path("../../vendor/spinel", __dir__)
+  end
+end

data/lib/rubyduino/spinel_arduino_codegen.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# Arduino UNO codegen layer for Spinel.
+#
+# This file intentionally leaves spinel_codegen.rb unchanged. Spinel's codegen
+# file is CLI-oriented, so we load only its Compiler definition and keep the
+# same AST-file input/output-file flow as the upstream footer.
+
+ROOT = File.expand_path("../..", __dir__)
+SPINEL_ROOT = File.join(ROOT, "vendor/spinel")
+
+def load_spinel_compiler
+  path = File.join(SPINEL_ROOT, "spinel_codegen.rb")
+  source = File.read(path)
+  marker = "\n# ---- Main ----\n"
+  split_at = source.index(marker)
+  unless split_at
+    warn "spinel_arduino_codegen: cannot find codegen main marker"
+    exit(1)
+  end
+
+  TOPLEVEL_BINDING.eval(source[0...split_at], path)
+end
+
+load_spinel_compiler
+
+module SpinelArduinoCodegen
+  def compile_no_recv_call_expr(nid, mname)
+    case mname
+    when "sleep"
+      compile_arduino_sleep(nid)
+      "0"
+    when "rand"
+      arduino_rand = compile_arduino_rand(nid)
+      return arduino_rand if arduino_rand
+
+      super
+    else
+      super
+    end
+  end
+
+  private
+
+  def compile_arduino_sleep(nid)
+    args_id = @nd_arguments[nid]
+    return if args_id < 0
+
+    arg_ids = get_args(args_id)
+    return if arg_ids.empty?
+
+    arg = arg_ids.first
+    if numeric_literal_node?(arg)
+      emit_arduino_delay_literal(numeric_literal_value(arg))
+    else
+      emit("  sp_arduino_sleep_seconds(" + compile_expr(arg) + ");")
+    end
+  end
+
+  def compile_arduino_rand(nid)
+    args_id = @nd_arguments[nid]
+    return nil if args_id < 0
+
+    arg_ids = get_args(args_id)
+    return nil unless arg_ids.length == 1
+
+    arg = arg_ids.first
+    return nil unless @nd_type[arg] == "RangeNode"
+
+    left = @nd_left[arg]
+    right = @nd_right[arg]
+    return nil unless integer_literal_node?(left) && integer_literal_node?(right)
+
+    first = @nd_value[left].to_i
+    last = @nd_value[right].to_i
+    return "0" if last < first
+
+    @needs_rand = 1
+    span = last - first + 1
+    "((mrb_int)(#{first} + (rand() % #{span})))"
+  end
+
+  def emit_arduino_delay_literal(seconds)
+    ms = (seconds * 1000.0).round
+    parts = []
+    while ms >= 250
+      parts << "_delay_ms(250.0)"
+      ms -= 250
+    end
+    parts << "_delay_ms(#{ms}.0)" if ms > 0
+    emit("  " + parts.join("; ") + ";") unless parts.empty?
+  end
+
+  def integer_literal_node?(nid)
+    nid && nid >= 0 && @nd_type[nid] == "IntegerNode"
+  end
+
+  def numeric_literal_node?(nid)
+    nid && nid >= 0 && %w[IntegerNode FloatNode].include?(@nd_type[nid])
+  end
+
+  def numeric_literal_value(nid)
+    if @nd_type[nid] == "IntegerNode"
+      @nd_value[nid].to_f
+    else
+      @nd_content[nid].to_f
+    end
+  end
+end
+
+Compiler.prepend(SpinelArduinoCodegen)
+
+ast_file = ARGV[0]
+out_file = ARGV[1]
+
+if ast_file.nil?
+  warn "Usage: ruby spinel_arduino_codegen.rb ast.txt output.c"
+  exit(1)
+end
+
+compiler = Compiler.new
+compiler.read_text_ast(File.read(ast_file))
+compiler.compile
+
+result = compiler.build_output
+if out_file
+  File.write(out_file, result)
+else
+  print result
+end

data/lib/rubyduino/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rubyduino
+  VERSION = "0.1.1"
+end

data/lib/rubyduino.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "rubyduino/version"
+require_relative "rubyduino/spinel"
+
+module Rubyduino
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/rubyduino.rbs

@@ -0,0 +1,4 @@
+module Rubyduino
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/vendor/spinel/AUTHORS

@@ -0,0 +1 @@
+@matz (Yukihiro Matsumoto)

data/vendor/spinel/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024- Yukihiro Matsumoto (matz@ruby.or.jp)
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.