user57682: i'm trying to send multiple commands to multiple slaves controlling motors. Slave Controller(Arduino Nano) will receive the command, and returns the current position of the motors to the Master(Arduino Mega). 
What data type would be best to use in this scenario. I am considering, string or byte data type.  

user38721: Strings (aka byte arrays of arbitrary length) are perfect for asynchronous and full duplex protocols like UART, essentially because those are no master-slave protocols. Here, both master and slave can transmit a byte stream independent of each other at any time and with any length.
But using strings on I2C is quite uncommon. As I2C is a master-slave bus where any communication (read and write) is initiated by the master generating the bus clock, using strings has the big disadvantage, that the master has to know the number of bytes the slave has to transmit. Of course you could implement it, but as long as you don't need the data to be human-readable, I suggest the more efficient way of transmitting bytes.
Usually, an i2c read transmission is done by

addressing the slave in write mode
Writing the target value's register address
Addressing the slave in read mode
Reading an arbitrary number of bytes (e.g. four bytes for float values)

A write transmission is a bit simpler:

addressing the slave in write mode
Writing the target value's register address
Writing an arbitrary number of bytes (e.g. four bytes for float values)

This is the standard protocol that e.g. I2C sensors use and it's convenient to implement the same behaviour in the ISR when using a microcontroller (you could think of "register addresses" as "variable IDs").
To prepare values of any datatype for transmission (e.g. float to byte[4]) you can use a union.

user16780: I2C works with fixed size byte arrays.
Single bytes for commands should be sufficient. For positions you might need int16_t or even bigger numbers. Unsigned positions relative to (above) zero might make things easier, eventually (?)
As you have the same architecture on both sides, mapping of byte arrays to bigger numbers via union will work well.

57682: <p>i'm trying to send multiple commands to multiple slaves controlling motors. Slave Controller(Arduino Nano) will receive the command, and returns the current position of the motors to the Master(Arduino Mega). </p>

<p>What data type would be best to use in this scenario. I am considering, string or byte data type.  </p>
 38721: <p>Strings (aka byte arrays of arbitrary length) are perfect for asynchronous and full duplex protocols like UART, essentially because those are no master-slave protocols. Here, both master and slave can transmit a byte stream independent of each other at any time and with any length.</p>

<p>But using strings on I2C is quite uncommon. As I2C is a master-slave bus where <strong>any</strong> communication (read and write) is initiated by the master generating the bus clock, using strings has the big disadvantage, that the master has to know the number of bytes the slave has to transmit. Of course you could implement it, but as long as you don't need the data to be human-readable, I suggest the more efficient way of transmitting bytes.
Usually, an i2c read transmission is done by</p>

<ol>
<li>addressing the slave in write mode</li>
<li>Writing the target value's register address</li>
<li>Addressing the slave in read mode</li>
<li>Reading an arbitrary number of bytes (e.g. four bytes for float values)</li>
</ol>

<p>A write transmission is a bit simpler:</p>

<ol>
<li>addressing the slave in write mode</li>
<li>Writing the target value's register address</li>
<li>Writing an arbitrary number of bytes (e.g. four bytes for float values)</li>
</ol>

<p>This is the standard protocol that e.g. I2C sensors use and it's convenient to implement the same behaviour in the ISR when using a microcontroller (you could think of "register addresses" as "variable IDs").</p>

<p>To prepare values of any datatype for transmission (e.g. float to byte[4]) you can use a <code>union</code>.</p>
 16780: <p>I2C works with fixed size byte arrays.</p>

<p>Single bytes for commands should be sufficient. For positions you might need int16_t or even bigger numbers. Unsigned positions relative to (above) zero might make things easier, eventually (?)</p>

<p>As you have the same architecture on both sides, mapping of byte arrays to bigger numbers via <code>union</code> will work well.</p>
