使用Amarino将数据结构从Arduino发送和接收到Android（反之亦然）

Question

I want to send data structs from the arduino to android and visa versa. I have made a convertion function in native c to put java in the struct (that is ac struct)data to a byte java array. Then i use the Amarino sendDataToArduino method to send the data array to the arduino. On the Arduino side is recieve the array with the amarino-arduino function getBuffer. Then i print the data but the recieved data on the Arduino is wrong. My question is it possible to send struct data from android to arduino and visa versa? Or are there any suggestions what the problem might be?

So in short i want to do the following:

java integers ->put in c struct and convert to java byte array -> send array to Arduino -> Recieve data on Arduino and print out.

The apprach that i used above worked for a usb communication project, so i'm wondering if the problem is in Amarino code(usage)? If more information is needed please say so.

Any suggestions are welcome!

Below is the used code, on the Android side:

The struct contains 7 integers and is defined as followes:

// ObjectInfo struct definition
     struct ObjectInfo {
      int32_t ObjectXCor;
      int32_t ObjectYCor;
      int32_t ObjectMass;
     };

     // ObjectInfo struct definition
     struct SensorDataStruct{
      int32_t PingData;
      int32_t IRData;
      int32_t ForceData;
      int32_t CompassData;
     };

     // ObjectInfo struct definition
     union PackedSend{
      struct CommStruct{
       ObjectInfo VisionData;
       SensorDataStruct SensorData;
      } CommData;
      unsigned char bytes[28];
     }SendData;

The data is first converted with ac function (using ndk) that returns a java byte array:

JNIEXPORT jbyteArray JNICALL Java_com_example_communicationmoduleBT_communicationmoduleBT_ConvertStructToCData(
  JNIEnv *env, jobject,
  jint ObjectXCor,
  jint ObjectYCor,
  jint ObjectMass,
  jint PingData,
     jint IRData,
        jint ForceData,
        jint CompassData)
 {
     // Array to fill with data
  jbyteArray Array;

  // Init  java byte array
  Array = env->NewByteArray(28);

  // Set data in SendData struct wihtch is a C struct.
  SendData.CommData.SensorData.PingData = PingData;
  SendData.CommData.SensorData.IRData = IRData;
  SendData.CommData.SensorData.ForceData = ForceData;
  SendData.CommData.SensorData.CompassData = CompassData;
  SendData.CommData.VisionData.ObjectXCor = ObjectXCor;
  SendData.CommData.VisionData.ObjectYCor = ObjectYCor;
  SendData.CommData.VisionData.ObjectMass = ObjectMass;

  // Now put the data in the java array, this array contains the C struct data
  // This way the Arduino can read out the data correctly
  env->SetByteArrayRegion(Array, 0, 28, (jbyte*)SendData.bytes);

  // Return java array
  return Array;
 }
}

The Send function that sends the structs:

    // Send struct function
public void Send(CommStruct Packet){    

    byte buffer[] = new byte[28];

    buffer = ConvertStructToCData(Packet.VisionData.ObjectXCor,
                              Packet.VisionData.ObjectYCor,
                              Packet.VisionData.ObjectMass,
                              Packet.SensorData.PingData,
                              Packet.SensorData.IRData,
                              Packet.SensorData.ForceData,
                              Packet.SensorData.CompassData);

    buffer = ConvertStructToCData(1, 2, 3, 4, 5, 6, 7);

    Amarino.sendDataToArduino(ActivityContext, DEVICE_ADDRESS, 'o', buffer);


}

And is send as followed with a onClick listner that uses the send function:

SendButton.setOnClickListener(new View.OnClickListener() {

             @Override
             public void onClick(View v) {

      // Dummy test data
      CMBT.SendPacket.SensorData.CompassData = 10;
      CMBT.SendPacket.SensorData.ForceData = 20;
      CMBT.SendPacket.SensorData.IRData = 30;
      CMBT.SendPacket.SensorData.PingData = 40;
      CMBT.SendPacket.VisionData.ObjectMass = 50;
      CMBT.SendPacket.VisionData.ObjectXCor = 60;
      CMBT.SendPacket.VisionData.ObjectYCor = 70;

      CMBT.Send(CMBT.SendPacket);
             } 
         });

On the Aruino side i recieve the data with the event handler function, using the amarino function getBuffer. And prints out the data. The eventhandler is triggerd but the data is wrong.

The eventhandler function is defined as followed:

void HandlerFunction(byte flag, byte numOfValues){
  Serial.println("In handler function!");

  meetAndroid.getBuffer(CM.RecieveData.bytes);

 Serial.println("Recieved data: ");
 Serial.print(CM.RecieveData.CommData.SensorData.PingData);
 Serial.println();
 Serial.print(CM.RecieveData.CommData.SensorData.IRData);
 Serial.println();
 Serial.print(CM.RecieveData.CommData.SensorData.ForceData);
 Serial.println();
 Serial.print(CM.RecieveData.CommData.SensorData.CompassData);
 Serial.println();
 Serial.print(CM.RecieveData.CommData.VisionData.ObjectXCor);
 Serial.println();
 Serial.print(CM.RecieveData.CommData.VisionData.ObjectYCor);
 Serial.println();
 Serial.print(CM.RecieveData.CommData.VisionData.ObjectMass);
 Serial.println();

 // Send data back
 //meetAndroid.send(Buffer);
 //meetAndroid.send(Buffer);
}

Answer 1

Turns out that the Amarino API has a send method that allows the Android to send a integer array to the Arduino. On the Arduino i recieve the integer array and put it in the recieve data struct.

On the Arduino side i send the data as a data sting to the Android. For this i have added a new function to the ArduinoMeetAndroid library (the Arduino part of the Amarino-tool kit). On the Android i recieve the data string and i have written a extraction and convertion function to extract the integer data from the sting and pasrse it in the Recieve struct. This is no a solution that i had in mind but it works and it is reliable.