rubyduino 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06e43dd1d4e9f5f4d9dbfda78f6954733999175a658f50b5d76186e6c51fc544
-  data.tar.gz: 62a7ba189c79f9741001a6724af58026c7870aaa9da5775dcf54c824afcf53d3
+  metadata.gz: bac10de4fac724a35791684086ec7ac0ab440f2e3272e75d665f58a1b0d94f8d
+  data.tar.gz: f0c542257835047dda8edcfdd6d1c1480c27b1f2dd596f3e9e0f32303df06c81
 SHA512:
-  metadata.gz: 9a83433f8069a0e13757f47666c6913307185d66f388eb014fa68bc54a9afd0117e4c7155bf2f8199ffa5a73c4e7de415096f8cdce2a0965f4679cd567cbf7a1
-  data.tar.gz: deb4d7cc643e4d93c172a525677fb7944fbc6fb2bab93fe2b48f7893ca2e0886153879fedd42ee7bf06605e4dc0ac5413cb16c767bd59a0ede37cde188dbf0c4
+  metadata.gz: c544a3120274e0a8dc7cd53d24438c17fe4a72e6abab2c35d6130b0d1568e4f0d95d40490415fbd0a60303a89a25d9334b4f3e5f8e510b07f1046cce0193a3ac
+  data.tar.gz: 5ffcf8876947fa43e4d7cc9a15b6329df635230b9f397ed807cf58466e0d142e5c2ab2aa1fa1490914e848f5fc5db2e0f9d1cec54f72bd3b2468cf3b6bd636f6

data/CHANGELOG.md

@@ -1,13 +1,25 @@
 ## [Unreleased]
 
-## [0.1.0] - 2026-05-08
+## [0.2.0] - 2026-05-08
 
-- Initial release
+- 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.1] - 2026-05-08
+## [0.1.3] - 2026-05-08
 
-- Fix avrdude discovery for installed command
+- Add the built-in `ArduinoUNO` prelude with FFI-backed GPIO, analog read, and millisecond delay bindings
+- Replace the legacy `system("pin13:*")` sketch API with top-level helpers like `pin_mode`, `digital_write`, and `delay_ms`
+- Update the default hello example to use the new ArduinoUNO API
 
 ## [0.1.2] - 2026-05-08
 
 - Update vendored Spinel revision
+
+## [0.1.1] - 2026-05-08
+
+- Fix avrdude discovery for installed command
+
+## [0.1.0] - 2026-05-08
+
+- Initial release

data/README.md

@@ -1,6 +1,7 @@
 <div align="center">
 
-# Rubyduino
+# Rubyduino 
+[Experimental]
 
 <img width="250" height="250" alt="image copy" src="https://github.com/user-attachments/assets/156c7d41-ed42-43f3-a720-ed2e9c12b52c" />
 
@@ -15,14 +16,13 @@ Under the hood it uses [Spinel](https://github.com/matz/spinel), a Ruby AOT comp
 <img width="500" height="281" alt="IMG_0197" src="https://github.com/user-attachments/assets/d2b1cc69-647a-4f63-b090-31b13a21e5a8" />
 
 ```ruby
-system("pin13:output")
+pin_mode(ArduinoUNO::LED_BUILTIN, ArduinoUNO::OUTPUT)
 
 loop do
-  duration = 0.1
-  system("pin13:high")
-  sleep duration
-  system("pin13:low")
-  sleep duration
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::HIGH)
+  delay_ms(100)
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::LOW)
+  delay_ms(100)
 end
 ```
 

data/bin/rubyduino

@@ -98,6 +98,7 @@ 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")
+arduino_uno_rb = File.join(rubyduino_dir, "arduino_uno.rb")
 
 mcu = "atmega328p"
 f_cpu = "16000000UL"
@@ -137,6 +138,7 @@ 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: missing #{arduino_uno_rb}" unless File.file?(arduino_uno_rb)
 abort "rubyduino: avr-gcc not found" unless command?("avr-gcc")
 abort "rubyduino: avr-objcopy not found" unless command?("avr-objcopy")
 
@@ -164,9 +166,11 @@ 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)}")
+source_tmp = File.join(Dir.tmpdir, "rubyduino_source.#{$PROCESS_ID}.#{rand(1_000_000)}.rb")
 begin
   warn "Spinel: #{source} -> #{c_file}"
-  run!(parse_bin, source, ast_tmp)
+  File.write(source_tmp, "#{File.read(arduino_uno_rb)}\n#{File.read(source)}")
+  run!(parse_bin, source_tmp, ast_tmp)
   run!(RbConfig.ruby, codegen_rb, ast_tmp, c_file)
 
   warn "AVR: #{c_file} -> #{hex_file}"
@@ -183,4 +187,5 @@ begin
   run!(avrdude, *conf_args, "-p#{mcu}", "-carduino", "-P#{port}", "-b#{baud}", "-D", "-Uflash:w:#{hex_file}:i")
 ensure
   FileUtils.rm_f(ast_tmp)
+  FileUtils.rm_f(source_tmp)
 end

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/examples/hello.rb

@@ -1,9 +1,8 @@
-system("pin13:output")
+pin_mode(ArduinoUNO::LED_BUILTIN, ArduinoUNO::OUTPUT)
 
 loop do
-  duration = 0.1
-  system("pin13:high")
-  sleep duration
-  system("pin13:low")
-  sleep duration
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::HIGH)
+  delay_ms(100)
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::LOW)
+  delay_ms(100)
 end

data/lib/rubyduino/arduino_uno.rb

@@ -0,0 +1,119 @@
+module ArduinoUNO
+  LOW = 0
+  HIGH = 1
+
+  INPUT = 0
+  OUTPUT = 1
+  INPUT_PULLUP = 2
+
+  A0 = 14
+  A1 = 15
+  A2 = 16
+  A3 = 17
+  A4 = 18
+  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)
+  ArduinoUNO.pin_mode(pin, mode)
+end
+
+def digital_write(pin, value)
+  ArduinoUNO.digital_write(pin, value)
+end
+
+def digital_read(pin)
+  ArduinoUNO.digital_read(pin)
+end
+
+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

@@ -3,6 +3,8 @@
 
 #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>
@@ -44,8 +46,26 @@ 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;
   mrb_int len;
   mrb_int cap;
 } sp_IntArray;
@@ -69,6 +89,7 @@ static sp_Range sp_range_new(mrb_int first, mrb_int last) {
 
 static sp_IntArray *sp_IntArray_new(void) {
   sp_IntArray *array = (sp_IntArray *)malloc(sizeof(sp_IntArray));
+  array->start = 0;
   array->len = 0;
   array->cap = 4;
   array->data = (mrb_int *)malloc(sizeof(mrb_int) * array->cap);
@@ -80,7 +101,7 @@ static void sp_IntArray_push(sp_IntArray *array, mrb_int value) {
     array->cap *= 2;
     array->data = (mrb_int *)realloc(array->data, sizeof(mrb_int) * array->cap);
   }
-  array->data[array->len] = value;
+  array->data[array->start + array->len] = value;
   array->len++;
 }
 
@@ -89,7 +110,7 @@ static mrb_int sp_IntArray_length(sp_IntArray *array) {
 }
 
 static mrb_int sp_IntArray_get(sp_IntArray *array, mrb_int index) {
-  return array->data[index];
+  return array->data[array->start + index];
 }
 
 static sp_FloatArray *sp_FloatArray_new(void) {
@@ -117,30 +138,213 @@ 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++;
+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;
   }
-  return *a == *b;
+
+  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;
 }
 
-static int sp_arduino_system(const char *cmd) {
-  if (sp_streq(cmd, "pin13:output")) {
-    DDRB |= _BV(DDB5);
+static volatile uint8_t *rd_uno_ddr(uint8_t pin) {
+  if (pin <= 7) {
+    return &DDRD;
+  }
+  if (pin <= 13) {
+    return &DDRB;
+  }
+  if (pin <= 19) {
+    return &DDRC;
+  }
+  return NULL;
+}
+
+static volatile uint8_t *rd_uno_port(uint8_t pin) {
+  if (pin <= 7) {
+    return &PORTD;
+  }
+  if (pin <= 13) {
+    return &PORTB;
+  }
+  if (pin <= 19) {
+    return &PORTC;
+  }
+  return NULL;
+}
+
+static volatile uint8_t *rd_uno_pin_reg(uint8_t pin) {
+  if (pin <= 7) {
+    return &PIND;
+  }
+  if (pin <= 13) {
+    return &PINB;
+  }
+  if (pin <= 19) {
+    return &PINC;
+  }
+  return NULL;
+}
+
+static uint8_t rd_uno_bit(uint8_t pin) {
+  if (pin <= 7) {
+    return pin;
+  }
+  if (pin <= 13) {
+    return pin - 8;
+  }
+  return pin - 14;
+}
+
+int pin_mode(uint8_t pin, uint8_t mode) {
+  volatile uint8_t *ddr = rd_uno_ddr(pin);
+  volatile uint8_t *port = rd_uno_port(pin);
+  uint8_t mask;
+
+  if (!ddr || !port) {
+    return 1;
+  }
+
+  mask = (uint8_t)(1 << rd_uno_bit(pin));
+
+  if (mode == 1) {
+    *ddr |= mask;
     return 0;
   }
-  if (sp_streq(cmd, "pin13:high")) {
-    PORTB |= _BV(PORTB5);
+
+  if (mode == 0) {
+    *ddr &= (uint8_t)~mask;
+    *port &= (uint8_t)~mask;
     return 0;
   }
-  if (sp_streq(cmd, "pin13:low")) {
-    PORTB &= (uint8_t)~_BV(PORTB5);
+
+  if (mode == 2) {
+    *ddr &= (uint8_t)~mask;
+    *port |= mask;
     return 0;
   }
+
   return 1;
 }
 
+int digital_write(uint8_t pin, uint8_t value) {
+  volatile uint8_t *port = rd_uno_port(pin);
+  uint8_t mask;
+
+  if (!port) {
+    return 1;
+  }
+
+  mask = (uint8_t)(1 << rd_uno_bit(pin));
+
+  if (value) {
+    *port |= mask;
+  } else {
+    *port &= (uint8_t)~mask;
+  }
+
+  return 0;
+}
+
+int digital_read(uint8_t pin) {
+  volatile uint8_t *reg = rd_uno_pin_reg(pin);
+
+  if (!reg) {
+    return -1;
+  }
+
+  return ((*reg & (uint8_t)(1 << rd_uno_bit(pin))) != 0) ? 1 : 0;
+}
+
+int analog_read(uint8_t pin) {
+  uint8_t channel = pin;
+
+  if (pin >= 14 && pin <= 19) {
+    channel = pin - 14;
+  }
+
+  if (channel > 5 || !rd_uno_valid_pin(pin)) {
+    return -1;
+  }
+
+  ADMUX = (uint8_t)((1 << REFS0) | channel);
+  ADCSRA = (uint8_t)((1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0));
+  ADCSRA |= (uint8_t)(1 << ADSC);
+
+  while (ADCSRA & (uint8_t)(1 << ADSC)) {
+  }
+
+  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));
@@ -148,12 +352,197 @@ static void sp_arduino_delay_ms(unsigned long ms) {
   }
 }
 
-static void sp_arduino_sleep_seconds(double seconds) {
-  sp_arduino_delay_ms((unsigned long)(seconds * 1000.0 + 0.5));
+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 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_arduino_codegen.rb

@@ -26,13 +26,20 @@ 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
+    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
@@ -41,19 +48,24 @@ module SpinelArduinoCodegen
 
   private
 
-  def compile_arduino_sleep(nid)
+  def compile_arduino_serial_print(nid, newline)
     args_id = @nd_arguments[nid]
-    return if args_id < 0
+    return nil if args_id < 0
 
     arg_ids = get_args(args_id)
-    return if arg_ids.empty?
+    return nil unless arg_ids.length == 1
 
     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) + ");")
+    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)
@@ -79,32 +91,9 @@ module SpinelArduinoCodegen
     "((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)

data/lib/rubyduino/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyduino
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Joseph Schito
@@ -24,9 +24,11 @@ files:
 - README.md
 - Rakefile
 - bin/rubyduino
+- examples/hc_sr04.rb
 - examples/hello.rb
 - lib/rubyduino.rb
 - lib/rubyduino/arduino_entry.c
+- lib/rubyduino/arduino_uno.rb
 - lib/rubyduino/sp_runtime.h
 - lib/rubyduino/spinel.rb
 - lib/rubyduino/spinel_arduino_codegen.rb