Skip to content

Roadmap

Jump to bottom
vickash edited this page May 27, 2025 · 52 revisions

For v0.15.0

  • Temperature/Humidity/Pressure Sensors

    • Standardize handling of CRC failures

  • AnalogIO

    • Add tests for smoothing.

  • Motor

    • Rename Motor::L298 to better represent the class of full bridge motor drivers
    • Class for continuous servos separate to positional
    • Class for electronic speed controllers with same PWM style. Maybe use continuous servo class?

Examples

  • Complete coverage of instance methods for each peripheral
  • Diagrams for all examples
  • Add more practical projects to the examples/advanced folder.
  • Explain callbacks happen in one thread per Board. Don't stay long in them. Use other threads for long operations.

Broken Hardware

  • ESP32 USB-CDC broken on all variants. Needs to be fixed in Arduino core.

Feature Improvement

  • Use multiple hardware SPI and I2C interfaces on a board, specified by index, similar to how UART works
  • Allow PWM frequency selection on boards that support it
  • Handle open-drain input modes, like mruby gem
  • Handle both pullup and pulldown resistors enabled at same time, like mruby gem
  • Handle inverted logic for Digital:IO peripherals
  • Reuse, or reimplement in Ruby, IR protocols from Arduino-IRremote dependency. Don't include in sketch.
  • Make register listeners in the sketch not send a message for every read, only changes, like digital listeners.
  • ESP32 (original only) has input-only pins (34,35,36,39). They also have no pull resistors. Should prevent output on them. Also a general solution to handle other such cases?

New Boards

  • STM32 Support
    • The mega (default) firmware compiles and runs on the Nucleo 64 F446RE. Blinking LED from Ruby works
    • Need validation of all the other features
    • Some lower-end chips won't have enough flash storage. Need to reduce features in build.
    • Some lower-end chips won't have enough timers for IR and Servo libraries to coexist.
    • Need to figure out how to make pin maps for arduino-yaml-board-maps. Pinout diagrams with GPIO integers are available, but documentation and tutorials tend to prefer symbols in the PA_0 style.
    • There are A LOT of variants

New Interfaces

  • MIDI support (doable in Ruby with existing UART support, and a Ruby MIDI gem?)
  • CAN/TWAI support
  • I2S support
  • SD card and filesystem support

New Transports

  • HTTP
  • MQTT ❓
  • ESP-NOW for ESP32/8266 ❓
  • Bluetooth Serial on ESP32 original or other classic Bluetooth boards ❓
  • BLE ❓

Performance (Arduino)

  • Different boards have different size serial receive buffers. Write performance to the board is best when: the Transport in Ruby knows the buffer size, and tries to fill it, but the (physical) board is acknowledging every half buffer size bytes.
    • Use macros in Arduino to change the acknowledgement threshold per board. Or set as part of pin map?
    • Use macros in Arduino to tell the Ruby Board the full serial buffer size (probably within handshake)
    • Ruby Board should tell its Transport the buffer size. Right now it's set with a constant.
    • This shouldn't apply to TCP. This type of flow control should probably be disabled totally for TCP.
    • Handle the error case where the acknowledge threshold in Arduino is higher than the total buffer size in Ruby. Can happen if handshake goes wrong. Ruby just stops sending data. Should Arduino send a keep-alive Rx acknowledgement every few seconds?

Ideas for Major Changes

  • Make all data transmission binary

    • Right now, commands, pin numbers, and small pieces of data are ASCII, with larger data blocks (like SPI bytes) in binary. The receiving parser on each ends unescapes \ and \n. Dino::Message escapes for PC->Board, and each function on the board handles its own escaping for Board->PC.

  • Let the board tell us which functions it implements

    • This would allow better optimization on different hardware. For example, one board might implement a parallel_write function for 8 pins of an HD44780 LCD, packed into one byte, reducing transmission, but other boards can fall back to 8x digital_write.
    • This also gives better error messages in Ruby, since unimplemented commands won't fail silently.

  • Let the board tell us pin/peripheral symbols defined by the Arduino framework

    • This would either replace or augment arduino-yaml-board-maps, and look something like: 
      #ifdef A0
  // Tell Ruby what integer pin "A0" maps to.
#endif
    • This would also make it easier to check the number of usable I2C/SPI/UART etc, since the cores generally want to be compatible with libraries, so they standardize symbol definitions for those.

Clone this wiki locally