Hello
I had a PM from a user who couldnt reply to my original topic, due to the forum change I suspect, my original thread was here
http://arduino.cc/forum/index.php/topic,45445.0.html
He asked me how you would go about sending an array of 6 floats over I2C.
I havent done it before, only to the extent of what the post shows, 2 single floats, using two unions, sending the bytes etc.
I attempted to write him some code to try, but he said it didnt work.
Code is as follows. It compiled, but I did not test it. He said the following was received:
Float 1 Value: 740733.56
Float 2 Value: 1234.12
Float 3 Value: 12345.56
Float 4 Value: 0.00
Float 5 Value: 0.00
Float 6 Value: 0.00
Master Arduino:
#include <Wire.h>
byte data[24];
float floatData[6];
long lastSerialPrint = 0;
void setup()
{
Serial.begin(9600);
Wire.begin();
}
void loop()
{
Wire.beginTransmission(2);
Wire.requestFrom(2, 24); // request 24 bytes from slave device #2
if(Wire.available())
{
int i = 0;
while(Wire.available()) // slave may send less than requested
{
data[i] = Wire.read(); // receive a byte as character
i = i + 1;
}
//A union datatypes makes the byte and float elements share the same piece of memory, which enables conversion from a byte array to a float possible
union Float1_tag {byte Float1_b[4]; float Float1_fval;} Float1_Union; //Float 1
Float1_Union.Float1_b[0] = data[0];
Float1_Union.Float1_b[1] = data[1];
Float1_Union.Float1_b[2] = data[2];
Float1_Union.Float1_b[3] = data[3];
floatData[0] = Float1_Union.Float1_fval * 60;
union Float2_tag {byte Float2_b[4]; float Float2_fval;} Float2_Union; //Float 2
Float2_Union.Float2_b[0] = data[4];
Float2_Union.Float2_b[1] = data[5];
Float2_Union.Float2_b[2] = data[6];
Float2_Union.Float2_b[3] = data[7];
floatData[1] = Float2_Union.Float2_fval;
union Float3_tag {byte Float3_b[4]; float Float3_fval;} Float3_Union; //Float 3
Float3_Union.Float3_b[0] = data[8];
Float3_Union.Float3_b[1] = data[9];
Float3_Union.Float3_b[2] = data[10];
Float3_Union.Float3_b[3] = data[11];
floatData[2] = Float3_Union.Float3_fval;
union Float4_tag {byte Float4_b[4]; float Float4_fval;} Float4_Union; //Float 4
Float4_Union.Float4_b[0] = data[12];
Float4_Union.Float4_b[1] = data[13];
Float4_Union.Float4_b[2] = data[14];
Float4_Union.Float4_b[3] = data[15];
floatData[3] = Float4_Union.Float4_fval;
union Float5_tag {byte Float5_b[4]; float Float5_fval;} Float5_Union; //Float 5
Float5_Union.Float5_b[0] = data[16];
Float5_Union.Float5_b[1] = data[17];
Float5_Union.Float5_b[2] = data[18];
Float5_Union.Float5_b[3] = data[19];
floatData[4] = Float5_Union.Float5_fval;
union Float6_tag {byte Float6_b[4]; float Float6_fval;} Float6_Union; //Float 6
Float6_Union.Float6_b[0] = data[20];
Float6_Union.Float6_b[1] = data[21];
Float6_Union.Float6_b[2] = data[22];
Float6_Union.Float6_b[3] = data[23];
floatData[5] = Float6_Union.Float6_fval;
}
Wire.endTransmission();
if(millis() > lastSerialPrint + 1000) //Like the Blink without delay example, true once a second
{
Serial.print("Float 1 Value: ");
Serial.println(floatData[0]);
Serial.print("Float 2 Value: ");
Serial.println(floatData[1]);
Serial.print("Float 3 Value: ");
Serial.println(floatData[2]);
Serial.print("Float 4 Value: ");
Serial.println(floatData[3]);
Serial.print("Float 5 Value: ");
Serial.println(floatData[4]);
Serial.print("Float 6 Value: ");
Serial.println(floatData[5]);
lastSerialPrint = millis(); //Snapshot of when this happened, in milli seconds
}
}
Slave Arduino:
#include <Wire.h>
volatile byte* Float1ArrayPtr; //Float 1 Array Pointer (series of bytes, 4 bytes each float)
volatile byte* Float2ArrayPtr; //Float 2 Array Pointer (series of bytes, 4 bytes each float)
volatile byte* Float3ArrayPtr; //Float 3 Array Pointer (series of bytes, 4 bytes each float)
volatile byte* Float4ArrayPtr; //Float 4 Array Pointer (series of bytes, 4 bytes each float)
volatile byte* Float5ArrayPtr; //Float 5 Array Pointer (series of bytes, 4 bytes each float)
volatile byte* Float6ArrayPtr; //Float 6 Array Pointer (series of bytes, 4 bytes each float)
int Address = 2; //This slave is address number 2
float floatData[6]; //Your float array
void setup()
{
Wire.begin(Address);
Wire.onRequest(requestEvent); // register event
}
void loop()
{
//Your code with putting values into your float array
floatData[0] = 12345.56; //your code here
floatData[1] = 1234.12; //your code here
floatData[2] = 12345.56; //your code here
floatData[3] = 1234.12; //your code here
floatData[4] = 12345.56; //your code here
floatData[5] = 1234.12; //your code here
}
// function that executes whenever data is requested by master
// this function is registered as an event, see setup()
void requestEvent()
{
byte* Data;
Float1ArrayPtr = (byte*) &floatData[0];
Data[0] = Float1ArrayPtr[0];
Data[1] = Float1ArrayPtr[1];
Data[2] = Float1ArrayPtr[2];
Data[3] = Float1ArrayPtr[3];
Float2ArrayPtr = (byte*) &floatData[1];
Data[4] = Float2ArrayPtr[0];
Data[5] = Float2ArrayPtr[1];
Data[6] = Float2ArrayPtr[2];
Data[7] = Float2ArrayPtr[3];
Float3ArrayPtr = (byte*) &floatData[2];
Data[8] = Float3ArrayPtr[0];
Data[9] = Float3ArrayPtr[1];
Data[10] = Float3ArrayPtr[2];
Data[11] = Float3ArrayPtr[3];
Float4ArrayPtr = (byte*) &floatData[3];
Data[12] = Float4ArrayPtr[0];
Data[13] = Float4ArrayPtr[1];
Data[14] = Float4ArrayPtr[2];
Data[15] = Float4ArrayPtr[3];
Float5ArrayPtr = (byte*) &floatData[4];
Data[16] = Float5ArrayPtr[0];
Data[17] = Float5ArrayPtr[1];
Data[18] = Float5ArrayPtr[2];
Data[19] = Float5ArrayPtr[3];
Float6ArrayPtr = (byte*) &floatData[5];
Data[20] = Float6ArrayPtr[0];
Data[21] = Float6ArrayPtr[1];
Data[22] = Float6ArrayPtr[2];
Data[23] = Float6ArrayPtr[3];
Wire.write(Data,24); //Send the 24 bytes (6 floats)
}
If anyone has any advice to help him, it would be appreciated. I have PM'ed him back with the link to this thread.
Im not suggesting the way I wrote it is the best method by any means, but was the only way I knew that I had tried and had worked, but never to the extent of sending 6 floats.
Cheers
J