Message Definition

Message Direction	Method Name	Parameters
<  from Arduino to PC >  from PC to Arduino	This will be the fuinction name called	Parameters can be of a variety of types. If the type is not specified then it is of type "byte" range is 0 to 255
example : >	neoPixelSetAnimation	/deviceId/animation/red/green/blue/b16 speed

 

Schema Datatypes

Schema	Arduino	Java	Range
	byte	int	1 byte - 0 to 255
bool	bool	boolean	1 byte - 0 to 1
b16	int	int	2 bytes -32,768 to 32,767
b32	long	long	4 bytes -2,147,483,648 to 2,147,483, 647
bu32	unsigned long	long	0 to 4,294,967,295
str	byte[ ]	String	variable length
[ ]	byte[ ]	int [ ]	variable length

 

Example 1.  Arduino --to--> MrlComm
 

Given this Schema entry - > i2cWrite/deviceId/deviceAddress/[ ] data

 

This method is an i2cWrite function which writes to an I2C device on MrlComm.  It requires a deviceId of the appropriate MrlComm device, and a device address on the I2C bus with the "data" to be written.

The following code is generated in the Msg.cpp class.  A case where the message is identified will cause the Msg class to call the MrlComm's "expected" function signature with the correct parameters.

 

case I2C_WRITE: { // i2cWrite
        mrlComm->i2cWrite(ioCmd[1], /*deviceId*/ ioCmd[2], /*deviceAddress*/ ioCmd[3] /*dataSize*/, (byte*)(ioCmd+4) /*data*/);
        break;
    }

 

The header of Msg.h & MrlComm.h is also generated.

 

void i2cWrite(const byte& deviceId, const byte& deviceAddress, const byte& dataSize, const byte*data);

 

So a corresponding i2cWrite with an appropriate parameter signature "must" be implemented in MrlComm.cpp

 

Example 2.

 

In the other direction  < publishSensorData/deviceId/[] data

the following code is generated.

 

void Msg::publishSensorData(const byte deviceId, const byte* data, const byte dataSize) {
  write(MAGIC_NUMBER);
  write(1 + 1 + (1 + dataSize)); // size
  write(PUBLISH_SENSOR_DATA); // msgType = 28
  write(deviceId);
  write((byte*)data, dataSize);
  flush();
}

 

The generated code makes no intermediate objects, instead it maintains the Msg functions to appropriately serialize and de-serialize the messages

 

Here is example of some of the contents of the One File Which Rules Them All
 

< publishMRLCommError/str errorMsg

> getBoardInfo

< publishBoardInfo/version/boardType

> analogWrite/pin/value

> controllerAttach/serialPort

> customMsg/[] msg

> deviceAttach/deviceType/str name/[] config

> deviceDetach/deviceId

> digitalWrite/pin/value

> disableBoardStatus

> disablePin/pin

> disablePins

> enableBoardStatus

> enableHeartbeat/bool enabled

 

Benefits of code generation

• Less time to develop - we only write the interesting parts of functions - not the boring mundane and error prone serialization/deserialization code
• Less errors - parsers are always one of the most difficult to make and maintain correctly
• Less code - less code = less bugs !
• More structured - more structure means its easier to quickly understand 
• Easier testing

This is the "exact" set of methods from PC->Arduino and all their method signatures which makes it easy to understand and test.

   void getBoardInfo();
    void controllerAttach(const byte& serialPort);
    void customMsg(const byte& msgSize, const byte*msg);
    void deviceAttach(const byte& deviceType, const byte& nameSize, const byte*name, const byte& configSize, const byte*config);
    void deviceDetach(const byte& deviceId);
    void disableBoardStatus();
    void disablePin(const byte& pin);
    void disablePins();
    void enableBoardStatus();
    void enableHeartbeat(const bool& enabled);
    void enablePin(const byte& pin);
    void heartbeat();
    void i2cRead(const byte& deviceId, const byte& deviceAddress, const byte& size);
    void i2cWrite(const byte& deviceId, const byte& deviceAddress, const byte& dataSize, const byte*data);
    void i2cWriteRead(const byte& deviceId, const byte& deviceAddress, const byte& readSize, const byte& writeValue);
    void neoPixelSetAnimation(const byte& size, const byte& animation, const byte& red, const byte& green, const byte& blue, const int& speed);
    void neoPixelWriteMatrix(const byte& deviceId, const byte& bufferSize, const byte*buffer);
    void sensorPollingStart(const byte& deviceId);
    void sensorPollingStop(const byte& deviceId);
    void servoDetach(const byte& deviceId);
    void servoSetMaxVelocity(const byte& deviceId, const int& maxVelocity);
    void servoSetVelocity(const byte& deviceId, const int& velocity);
    void servoSweepStart(const byte& deviceId, const byte& min, const byte& max, const byte& step);
    void servoSweepStop(const byte& deviceId);
    void servoWrite(const byte& deviceId, const byte& target);
    void servoWriteMicroseconds(const byte& deviceId, const int& ms);
    void setSerialRate(const long& rate);
    void softReset();