rubyduino 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ec4285a969c2afed1449f750c1674b63f1ba5cb5b454994cfdb9356173595cb
-  data.tar.gz: 8e1dba9b348672d0aa96f4eb7645242da1e111fa36595c1f601ab9a1fa45acdf
+  metadata.gz: 9bac40289b8f10c729347c460ccc402d7d9a71ccf15d63c4a217df8ed2cb891e
+  data.tar.gz: 6c8d145cae88d496fc392506001430677be1398fc68ef3ce5b3fc8b2727a42d9
 SHA512:
-  metadata.gz: 736ec9d0f9c5665ba2f88f647c36d0dcd1010a3e4d405d1a49a6032d1eaefaa60aecbd64a2d9e103796f9bf7443a8163370dc5951fdcd14bb589938452cc5ca7
-  data.tar.gz: 203d97b5aed491505f46e681d04aa4128dce2349ac93513d8cf307f1b8e96ddeaaa31478788c5f9aa919a028fe276cbab1b10a6c54466b69cf7ee17f2a1abc35
+  metadata.gz: b6e8ce8ea4b76b564b733561a6d9da5d839c6b1dfe05ef5755556ea00da2329bc390233eb99cf5bed6feac4d3d20172a282e62694e13471d1eaeea17452cb5ea
+  data.tar.gz: 813c746cbd24ea22e419da265e213e43427e7330ff26214ebffbbe184f06bc690f6e889345ad029781a586e56aeaf7fbafa4970cc340084358d0590d5fddd964

data/.gitmodules

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

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.2.1] - 2026-08-19
+
+- Update vendored Spinel to `b80ba94b` from the compatible `self-host` branch
+- Adapt Arduino code generation to Spinel's separate analysis and codegen pipeline
+- Add the `sp_Class` value type and integer arithmetic helpers required by the updated code generator to the AVR runtime
+
+## [0.2.0] - 2026-05-08
+
+- Expand the ArduinoUNO API with PWM, microsecond delays, millis/micros timing, pulse measurement, serial I/O, shift helpers, and interrupt control
+- Add special code generation for `serial_print` and `serial_println` so string and integer values map to the correct runtime functions
+- Add an HC-SR04 ultrasonic distance sensor example
+
 ## [0.1.3] - 2026-05-08
 
 - Add the built-in `ArduinoUNO` prelude with FFI-backed GPIO, analog read, and millisecond delay bindings

data/README.md

@@ -1,7 +1,6 @@
 <div align="center">
 
-# Rubyduino 
-[Experimental]
+# Rubyduino
 
 <img width="250" height="250" alt="image copy" src="https://github.com/user-attachments/assets/156c7d41-ed42-43f3-a720-ed2e9c12b52c" />
 

data/examples/hc_sr04.rb

@@ -0,0 +1,39 @@
+trig_pin = 9
+echo_pin = 10
+led_pin = 13
+
+pin_mode(trig_pin, ArduinoUNO::OUTPUT)
+pin_mode(echo_pin, ArduinoUNO::INPUT)
+pin_mode(led_pin, ArduinoUNO::OUTPUT)
+
+serial_begin(9600)
+
+loop do
+  digital_write(trig_pin, ArduinoUNO::LOW)
+  delay_us(2)
+
+  digital_write(trig_pin, ArduinoUNO::HIGH)
+  delay_us(10)
+  digital_write(trig_pin, ArduinoUNO::LOW)
+
+  duration = pulse_in(echo_pin, ArduinoUNO::HIGH)
+  distance = duration * 34 / 2000
+
+  serial_print("Distance: ")
+  serial_print(distance)
+  serial_println(" cm")
+
+  blink_delay = 700
+
+  if distance < 10
+    blink_delay = 100
+  elsif distance < 30
+    blink_delay = 300
+  end
+
+  digital_write(led_pin, ArduinoUNO::HIGH)
+  delay_ms(blink_delay)
+
+  digital_write(led_pin, ArduinoUNO::LOW)
+  delay_ms(blink_delay)
+end

data/lib/rubyduino/arduino_uno.rb

@@ -14,12 +14,32 @@ module ArduinoUNO
   A5 = 19
 
   LED_BUILTIN = 13
+  LSBFIRST = 0
+  MSBFIRST = 1
 
   ffi_func :pin_mode, [:uint8, :uint8], :int
   ffi_func :digital_write, [:uint8, :uint8], :int
   ffi_func :digital_read, [:uint8], :int
   ffi_func :analog_read, [:uint8], :int
+  ffi_func :analog_write, [:uint8, :uint8], :int
   ffi_func :delay_ms, [:uint32], :void
+  ffi_func :delay_us, [:uint32], :void
+  ffi_func :millis, [], :uint32
+  ffi_func :micros, [], :uint32
+  ffi_func :pulse_in, [:uint8, :uint8], :uint32
+  ffi_func :pulse_in_timeout, [:uint8, :uint8, :uint32], :uint32
+  ffi_func :serial_begin, [:uint32], :void
+  ffi_func :serial_available, [], :int
+  ffi_func :serial_read, [], :int
+  ffi_func :serial_write, [:uint8], :void
+  ffi_func :serial_print_str, [:str], :void
+  ffi_func :serial_print_int, [:int], :void
+  ffi_func :serial_println_str, [:str], :void
+  ffi_func :serial_println_int, [:int], :void
+  ffi_func :shift_in, [:uint8, :uint8, :uint8], :uint8
+  ffi_func :shift_out, [:uint8, :uint8, :uint8, :uint8], :void
+  ffi_func :interrupts, [], :void
+  ffi_func :no_interrupts, [], :void
 end
 
 def pin_mode(pin, mode)
@@ -38,6 +58,62 @@ def analog_read(pin)
   ArduinoUNO.analog_read(pin)
 end
 
+def analog_write(pin, value)
+  ArduinoUNO.analog_write(pin, value)
+end
+
 def delay_ms(ms)
   ArduinoUNO.delay_ms(ms)
 end
+
+def delay_us(us)
+  ArduinoUNO.delay_us(us)
+end
+
+def millis
+  ArduinoUNO.millis
+end
+
+def micros
+  ArduinoUNO.micros
+end
+
+def pulse_in(pin, value)
+  ArduinoUNO.pulse_in(pin, value)
+end
+
+def pulse_in_timeout(pin, value, timeout_us)
+  ArduinoUNO.pulse_in_timeout(pin, value, timeout_us)
+end
+
+def serial_begin(baud)
+  ArduinoUNO.serial_begin(baud)
+end
+
+def serial_available
+  ArduinoUNO.serial_available
+end
+
+def serial_read
+  ArduinoUNO.serial_read
+end
+
+def serial_write(value)
+  ArduinoUNO.serial_write(value)
+end
+
+def shift_in(data_pin, clock_pin, bit_order)
+  ArduinoUNO.shift_in(data_pin, clock_pin, bit_order)
+end
+
+def shift_out(data_pin, clock_pin, bit_order, value)
+  ArduinoUNO.shift_out(data_pin, clock_pin, bit_order, value)
+end
+
+def interrupts
+  ArduinoUNO.interrupts
+end
+
+def no_interrupts
+  ArduinoUNO.no_interrupts
+end

data/lib/rubyduino/sp_runtime.h

@@ -4,6 +4,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <avr/interrupt.h>
 #include <avr/io.h>
 #include <util/delay.h>
 #include <util/delay_basic.h>
@@ -18,6 +19,15 @@ typedef struct {
   mrb_int last;
 } sp_Range;
 
+typedef struct {
+  mrb_int cls_id;
+} sp_Class;
+
+#define sp_int_add(a, b) ((mrb_int)((a) + (b)))
+#define sp_int_sub(a, b) ((mrb_int)((a) - (b)))
+#define sp_int_mul(a, b) ((mrb_int)((a) * (b)))
+#define sp_int_neg(a) ((mrb_int)(-(a)))
+
 #ifndef TRUE
 #define TRUE 1
 #endif
@@ -45,6 +55,23 @@ static void sp_gc_mark(void *ptr) {
   (void)ptr;
 }
 
+static inline mrb_int sp_idiv(mrb_int a, mrb_int b) {
+  mrb_int q;
+  mrb_int r;
+
+  if (b == 0) {
+    return 0;
+  }
+
+  q = a / b;
+  r = a % b;
+  if ((r != 0) && ((r ^ b) < 0)) {
+    q--;
+  }
+
+  return q;
+}
+
 typedef struct {
   mrb_int *data;
   mrb_int start;
@@ -120,6 +147,25 @@ static mrb_float sp_FloatArray_get(sp_FloatArray *array, mrb_int index) {
   return array->data[index];
 }
 
+static volatile uint32_t rd_uno_timer0_overflows = 0;
+static uint8_t rd_uno_timer0_ready = 0;
+
+ISR(TIMER0_OVF_vect) {
+  rd_uno_timer0_overflows++;
+}
+
+static void rd_uno_timer0_init(void) {
+  if (rd_uno_timer0_ready) {
+    return;
+  }
+
+  TCCR0A |= (uint8_t)((1 << WGM00) | (1 << WGM01));
+  TCCR0B = (uint8_t)((TCCR0B & (uint8_t)~((1 << CS02) | (1 << CS01) | (1 << CS00))) | (1 << CS01) | (1 << CS00));
+  TIMSK0 |= (uint8_t)(1 << TOIE0);
+  rd_uno_timer0_ready = 1;
+  sei();
+}
+
 static int rd_uno_valid_pin(uint8_t pin) {
   return pin <= 19;
 }
@@ -254,6 +300,60 @@ int analog_read(uint8_t pin) {
   return ADC;
 }
 
+int analog_write(uint8_t pin, uint8_t value) {
+  if (!rd_uno_valid_pin(pin)) {
+    return 1;
+  }
+
+  pin_mode(pin, 1);
+
+  if (value == 0) {
+    return digital_write(pin, 0);
+  }
+  if (value == 255) {
+    return digital_write(pin, 1);
+  }
+
+  if (pin == 5) {
+    rd_uno_timer0_init();
+    TCCR0A |= (uint8_t)(1 << COM0B1);
+    OCR0B = value;
+    return 0;
+  }
+  if (pin == 6) {
+    rd_uno_timer0_init();
+    TCCR0A |= (uint8_t)(1 << COM0A1);
+    OCR0A = value;
+    return 0;
+  }
+  if (pin == 9) {
+    TCCR1A |= (uint8_t)((1 << WGM10) | (1 << COM1A1));
+    TCCR1B = (uint8_t)((TCCR1B & (uint8_t)~((1 << CS12) | (1 << CS11) | (1 << CS10) | (1 << WGM13))) | (1 << WGM12) | (1 << CS11) | (1 << CS10));
+    OCR1A = value;
+    return 0;
+  }
+  if (pin == 10) {
+    TCCR1A |= (uint8_t)((1 << WGM10) | (1 << COM1B1));
+    TCCR1B = (uint8_t)((TCCR1B & (uint8_t)~((1 << CS12) | (1 << CS11) | (1 << CS10) | (1 << WGM13))) | (1 << WGM12) | (1 << CS11) | (1 << CS10));
+    OCR1B = value;
+    return 0;
+  }
+  if (pin == 3) {
+    TCCR2A |= (uint8_t)((1 << WGM20) | (1 << WGM21) | (1 << COM2B1));
+    TCCR2B = (uint8_t)((TCCR2B & (uint8_t)~((1 << CS22) | (1 << CS21) | (1 << CS20))) | (1 << CS22));
+    OCR2B = value;
+    return 0;
+  }
+  if (pin == 11) {
+    TCCR2A |= (uint8_t)((1 << WGM20) | (1 << WGM21) | (1 << COM2A1));
+    TCCR2B = (uint8_t)((TCCR2B & (uint8_t)~((1 << CS22) | (1 << CS21) | (1 << CS20))) | (1 << CS22));
+    OCR2A = value;
+    return 0;
+  }
+
+  return digital_write(pin, value < 128 ? 0 : 1);
+}
+
 static void sp_arduino_delay_ms(unsigned long ms) {
   while (ms > 0) {
     _delay_loop_2((uint16_t)(F_CPU / 4000UL));
@@ -265,6 +365,193 @@ void delay_ms(uint32_t ms) {
   sp_arduino_delay_ms(ms);
 }
 
+void delay_us(uint32_t us) {
+  while (us > 0) {
+    _delay_us(1.0);
+    us--;
+  }
+}
+
+uint32_t micros(void) {
+  uint32_t overflows;
+  uint8_t counter;
+  uint8_t flags;
+  uint8_t sreg;
+
+  rd_uno_timer0_init();
+
+  sreg = SREG;
+  cli();
+  overflows = rd_uno_timer0_overflows;
+  counter = TCNT0;
+  flags = TIFR0;
+  if ((flags & (uint8_t)(1 << TOV0)) && counter < 255) {
+    overflows++;
+  }
+  SREG = sreg;
+
+  return ((overflows << 8) + counter) * (uint32_t)(64UL / (F_CPU / 1000000UL));
+}
+
+uint32_t millis(void) {
+  return micros() / 1000UL;
+}
+
+uint32_t pulse_in_timeout(uint8_t pin, uint8_t value, uint32_t timeout_us) {
+  uint32_t start;
+  uint32_t pulse_start;
+  uint32_t width;
+
+  if (!rd_uno_valid_pin(pin)) {
+    return 0;
+  }
+
+  value = value ? 1 : 0;
+  start = micros();
+
+  while (digital_read(pin) == value) {
+    if ((micros() - start) >= timeout_us) {
+      return 0;
+    }
+  }
+
+  while (digital_read(pin) != value) {
+    if ((micros() - start) >= timeout_us) {
+      return 0;
+    }
+  }
+
+  pulse_start = micros();
+
+  while (digital_read(pin) == value) {
+    width = micros() - pulse_start;
+    if ((micros() - start) >= timeout_us) {
+      return 0;
+    }
+  }
+
+  return micros() - pulse_start;
+}
+
+uint32_t pulse_in(uint8_t pin, uint8_t value) {
+  return pulse_in_timeout(pin, value, 1000000UL);
+}
+
+void serial_begin(uint32_t baud) {
+  uint16_t ubrr;
+
+  if (baud == 0) {
+    return;
+  }
+
+  ubrr = (uint16_t)((F_CPU / 16UL / baud) - 1UL);
+  UBRR0H = (uint8_t)(ubrr >> 8);
+  UBRR0L = (uint8_t)ubrr;
+  UCSR0A = 0;
+  UCSR0B = (uint8_t)((1 << RXEN0) | (1 << TXEN0));
+  UCSR0C = (uint8_t)((1 << UCSZ01) | (1 << UCSZ00));
+}
+
+int serial_available(void) {
+  return (UCSR0A & (uint8_t)(1 << RXC0)) ? 1 : 0;
+}
+
+int serial_read(void) {
+  if (!serial_available()) {
+    return -1;
+  }
+  return UDR0;
+}
+
+void serial_write(uint8_t value) {
+  while (!(UCSR0A & (uint8_t)(1 << UDRE0))) {
+  }
+  UDR0 = value;
+}
+
+void serial_print_str(const char *value) {
+  while (*value) {
+    serial_write((uint8_t)*value);
+    value++;
+  }
+}
+
+void serial_print_int(int value) {
+  char buf[12];
+  char *p = &buf[11];
+  unsigned int n;
+
+  *p = '\0';
+  if (value < 0) {
+    serial_write((uint8_t)'-');
+    n = (unsigned int)(-value);
+  } else {
+    n = (unsigned int)value;
+  }
+
+  do {
+    p--;
+    *p = (char)('0' + (n % 10));
+    n /= 10;
+  } while (n > 0);
+
+  serial_print_str(p);
+}
+
+void serial_println_str(const char *value) {
+  serial_print_str(value);
+  serial_write((uint8_t)'\r');
+  serial_write((uint8_t)'\n');
+}
+
+void serial_println_int(int value) {
+  serial_print_int(value);
+  serial_write((uint8_t)'\r');
+  serial_write((uint8_t)'\n');
+}
+
+uint8_t shift_in(uint8_t data_pin, uint8_t clock_pin, uint8_t bit_order) {
+  uint8_t value = 0;
+  uint8_t i;
+
+  for (i = 0; i < 8; i++) {
+    digital_write(clock_pin, 1);
+    if (bit_order == 0) {
+      value |= (uint8_t)(digital_read(data_pin) << i);
+    } else {
+      value |= (uint8_t)(digital_read(data_pin) << (7 - i));
+    }
+    digital_write(clock_pin, 0);
+  }
+
+  return value;
+}
+
+void shift_out(uint8_t data_pin, uint8_t clock_pin, uint8_t bit_order, uint8_t value) {
+  uint8_t i;
+  uint8_t bit;
+
+  for (i = 0; i < 8; i++) {
+    if (bit_order == 0) {
+      bit = (uint8_t)((value >> i) & 1);
+    } else {
+      bit = (uint8_t)((value >> (7 - i)) & 1);
+    }
+
+    digital_write(data_pin, bit);
+    digital_write(clock_pin, 1);
+    digital_write(clock_pin, 0);
+  }
+}
+
+void interrupts(void) {
+  sei();
+}
+
+void no_interrupts(void) {
+  cli();
+}
+
 #define fflush(stream) ((void)0)
 
 #endif

data/lib/rubyduino/spinel.rb

@@ -2,7 +2,7 @@
 
 module Rubyduino
   module Spinel
-    COMMIT = "e7f714f213ca572912f7214f358a927f8e2152e5"
+    COMMIT = "b80ba94b7163e822b34758b1de1555a3da32374b"
     ROOT = File.expand_path("../../vendor/spinel", __dir__)
   end
 end

data/lib/rubyduino/spinel_arduino_codegen.rb

@@ -1,9 +1,12 @@
 #!/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.
+# This file intentionally leaves Spinel's analyzer and code generator unchanged.
+# It runs the upstream analysis phase, then loads only the Compiler definition
+# from the CLI-oriented code generator before applying the Arduino extensions.
+
+require "rbconfig"
+require "tempfile"
 
 ROOT = File.expand_path("../..", __dir__)
 SPINEL_ROOT = File.join(ROOT, "vendor/spinel")
@@ -11,7 +14,7 @@ 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"
+  marker = "\n# ---- Main (codegen) ----\n"
   split_at = source.index(marker)
   unless split_at
     warn "spinel_arduino_codegen: cannot find codegen main marker"
@@ -30,6 +33,16 @@ module SpinelArduinoCodegen
       arduino_rand = compile_arduino_rand(nid)
       return arduino_rand if arduino_rand
 
+      super
+    when "serial_print"
+      arduino_serial_print = compile_arduino_serial_print(nid, false)
+      return arduino_serial_print if arduino_serial_print
+
+      super
+    when "serial_println"
+      arduino_serial_print = compile_arduino_serial_print(nid, true)
+      return arduino_serial_print if arduino_serial_print
+
       super
     else
       super
@@ -38,6 +51,26 @@ module SpinelArduinoCodegen
 
   private
 
+  def compile_arduino_serial_print(nid, newline)
+    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
+    fn = arduino_serial_print_func(arg, newline)
+    "(" + fn + "(" + compile_expr(arg) + "), (mrb_int)0)"
+  end
+
+  def arduino_serial_print_func(arg, newline)
+    if infer_type(arg) == "string"
+      return newline ? "serial_println_str" : "serial_print_str"
+    end
+
+    newline ? "serial_println_int" : "serial_print_int"
+  end
+
   def compile_arduino_rand(nid)
     args_id = @nd_arguments[nid]
     return nil if args_id < 0
@@ -76,13 +109,20 @@ if ast_file.nil?
   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
+analyzer = File.join(SPINEL_ROOT, "spinel_analyze.rb")
+Tempfile.create(["spinel-analysis", ".ir"]) do |ir_file|
+  ir_file.close
+  abort "spinel_arduino_codegen: analysis failed" unless system(RbConfig.ruby, analyzer, ast_file, ir_file.path)
+
+  compiler = Compiler.new
+  compiler.read_text_ast(File.read(ast_file))
+  compiler.load_analysis_buf(File.read(ir_file.path))
+  compiler.generate_code
+
+  result = compiler.build_output
+  if out_file
+    File.write(out_file, result)
+  else
+    print result
+  end
 end

data/lib/rubyduino/version.rb

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