rubyduino 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ec4285a969c2afed1449f750c1674b63f1ba5cb5b454994cfdb9356173595cb
-  data.tar.gz: 8e1dba9b348672d0aa96f4eb7645242da1e111fa36595c1f601ab9a1fa45acdf
+  metadata.gz: bac10de4fac724a35791684086ec7ac0ab440f2e3272e75d665f58a1b0d94f8d
+  data.tar.gz: f0c542257835047dda8edcfdd6d1c1480c27b1f2dd596f3e9e0f32303df06c81
 SHA512:
-  metadata.gz: 736ec9d0f9c5665ba2f88f647c36d0dcd1010a3e4d405d1a49a6032d1eaefaa60aecbd64a2d9e103796f9bf7443a8163370dc5951fdcd14bb589938452cc5ca7
-  data.tar.gz: 203d97b5aed491505f46e681d04aa4128dce2349ac93513d8cf307f1b8e96ddeaaa31478788c5f9aa919a028fe276cbab1b10a6c54466b69cf7ee17f2a1abc35
+  metadata.gz: c544a3120274e0a8dc7cd53d24438c17fe4a72e6abab2c35d6130b0d1568e4f0d95d40490415fbd0a60303a89a25d9334b4f3e5f8e510b07f1046cce0193a3ac
+  data.tar.gz: 5ffcf8876947fa43e4d7cc9a15b6329df635230b9f397ed807cf58466e0d142e5c2ab2aa1fa1490914e848f5fc5db2e0f9d1cec54f72bd3b2468cf3b6bd636f6

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [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/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>
@@ -45,6 +46,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 +138,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 +291,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 +356,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_arduino_codegen.rb

@@ -30,6 +30,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 +48,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

data/lib/rubyduino/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyduino
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Joseph Schito
@@ -24,6 +24,7 @@ files:
 - README.md
 - Rakefile
 - bin/rubyduino
+- examples/hc_sr04.rb
 - examples/hello.rb
 - lib/rubyduino.rb
 - lib/rubyduino/arduino_entry.c