At the moment, there's only one developer on the project, me, so the development plan is more like a rough idea of what I plan on doing and in what order. If the development team grows, I will make the development plan more concrete.
The purpose of Rhyduino is to create a thick wrapper for the Firmata protocol that can be used by managed code (.NET) developers as a PC to Arduino communication and control library. All functionality enabled by the StandardFirmata sketch will be implemented.
We are/I am targeting the StandardFirmata sketch that ships with the Arduino IDE v18.
For a log of recent activity, please see the
Status Archive page.
I have been focusing on creating unit and functional tests. The goal of the tests is to demonstrate that the Rhyduino library provides equivalent StandardFirmata functionality and that it operates correctly. I had hoped to develop a system for having one Arduino
verify the correct functioning of another, allowing me to automate all of the functional tests, but this turned out to be more difficult than expected. I suspect that I had a problem isolating the circuitry of the observer because I believe it was causing
side effects in the Arduino being observed. Therefore, all functional tests are interactive. In other words, I need to build a circuit, plug it in to the Arduino, and then confirm that it functions as expected manually.
I am about 80% done with all testing tasks.
For version 2, I'd like to add support for I2C communication. I'm not familiar with I2C communication, but I have a feeling that I'll want to handle that differently than the current Arduino implementation. I think it might need another layer of
abstraction over it to make it more easily programmable (for users of the library).
Unfortunately, the Arduino implementation of I2C communication is not part of the StandardFirmata sketch. An implementation is provided, however, it's just separate. I'm much more comfortable programming in C#, so I can't anticipate the challenges
I might have trying to merge the StandardFirmata and I2C sketches. Anyone with Wiring/Processing background would probably be able to handle this task much more easily than I could.
Another likely candidate feature for v2 is a modification to the Arduino sketch that caches its state in EEPROM so that when the Arduino is rebooted it could load the state from EEPROM and pick up where it left off.
The other, and final, thing that I think would be important for me to start to consider Rhyduino a completed project, is the implementation of a feature allows reading and writing the device memory. I've already implemented this in other projects but the
communication protocol used was totally unlike Firmata. Additionally, Firmata doesn't describe how to support read/write memory access. Therefore, I'll need to write the protocol and then propose it as a Firmata extension.
At some point, I'd like to bring this project back to its roots and wrap Rhyduino in a Microsoft Robotics Developer Studio service.