根据DemoKit草图，Arduino上的ADK AndroidAccessory Read函数应该得到一些东西？

我使用的是Freeduino（Arduino-Uno兼容），三星Galaxy Tab 10.1运行ICS（4），我已经成功地将Arduino写入Android，但我无法从Arduino草图中读取Android

以下是USB附件的Android类：

package com.kegui.test;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.util.ArrayList;

import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;

import com.kegui.test.Scripto;

import android.app.Activity;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class USBAccess extends Activity implements Runnable, OnClickListener {
    private static final String ACTION_USB_PERMISSION = "com.google.android.DemoKit.action.USB_PERMISSION";

    protected static final String TAG = "KegUI";

    private UsbManager mUsbManager;
    private PendingIntent mPermissionIntent;
    private boolean mPermissionRequestPending;

    private TextView debugtext = null;
        private Button button1 = null;
        private Button button2 = null;
        private boolean button2visible = false;



    UsbAccessory mAccessory;
    ParcelFileDescriptor mFileDescriptor;
    FileInputStream mInputStream;
    FileOutputStream mOutputStream;

    private static final int MESSAGE_BUTTON_PRESSED = 1;


    private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            Log.i("KegApp", "***********************Received*************************");
            if (ACTION_USB_PERMISSION.equals(action)) {
                synchronized (this) {
                    UsbAccessory accessory = (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
                    if (intent.getBooleanExtra(
                            UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                        openAccessory(accessory);
                    } else {
                        Log.d(TAG, "permission denied for accessory "
                                + accessory);
                    }
                    mPermissionRequestPending = false;
                }
            } else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) {
                UsbAccessory accessory = (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
                if (accessory != null && accessory.equals(mAccessory)) {
                    closeAccessory();
                }
            }
        }
    };


    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
        mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(
                    ACTION_USB_PERMISSION), 0);
        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
        filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);

        setContentView(R.layout.main);
        final Button button = (Button) findViewById(R.id.button1);
        button.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                // Perform action on click

                new TempUpdateTask().execute("testing");
            }
        });
        registerReceiver(mUsbReceiver, filter);

        Log.d(TAG,"on Create'd");
    }

    @Override
    public void onResume() {
        super.onResume();

        if (mInputStream != null && mOutputStream != null) {
            return;
        }

        UsbAccessory[] accessories = mUsbManager.getAccessoryList();
        UsbAccessory accessory = (accessories == null ? null : accessories[0]);
        if (accessory != null) {
            if (mUsbManager.hasPermission(accessory)) {
                openAccessory(accessory);
            } else {
                synchronized (mUsbReceiver) {
                    if (!mPermissionRequestPending) {
                        mUsbManager.requestPermission(accessory,
                                mPermissionIntent);
                        mPermissionRequestPending = true;
                    }
                }
            }
        } else {
            Log.d(TAG, "mAccessory is null");
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        closeAccessory();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        unregisterReceiver(mUsbReceiver);

    }

    private void openAccessory(UsbAccessory accessory) {
        mFileDescriptor = mUsbManager.openAccessory(accessory);
        if (mFileDescriptor != null) {
            mAccessory = accessory;
            FileDescriptor fd = mFileDescriptor.getFileDescriptor();
            mInputStream = new FileInputStream(fd);
            mOutputStream = new FileOutputStream(fd);
            Thread thread = new Thread(null, this, "KegApp");
            thread.start();




            //enableControls(true);
        } else {
            Log.d(TAG, "accessory open fail");
        }
    }


    public void run() { 
        int ret = 0;
        byte[] buffer = new byte[16384];
        int i;
        Log.i("KegApp", "***********************in run*************************");
        while (ret >= 0) {
            try {
                ret = mInputStream.read(buffer); // this will be always positive, as long as the stream is not closed
            } catch (IOException e) {
                break;
            }

            i = 0;
            while (i < ret) {
                Message m = Message.obtain(messageHandler, MESSAGE_BUTTON_PRESSED);
                m.obj = buffer[i];
                messageHandler.sendMessage(m);
                i++;
            }

        }

    }



    private void closeAccessory() {
        //enableControls(false);

        try {
            if (mFileDescriptor != null) {
                mFileDescriptor.close();
            }
        } catch (IOException e) {
        } finally {
            mFileDescriptor = null;
            mAccessory = null;
        }
    }

    public void sendCommand(FileOutputStream mStream) { 
        BufferedOutputStream bo = new BufferedOutputStream(mStream);

    //  if (mStream != null && message.length > 0) {
            try {
                Log.i("KegApp", "***********************sending command now*************************");
                bo.write(1); //message, 0, 3);
            } catch (IOException e) {
                Log.e(TAG, "write failed", e);
            }
    //  }
    }

    @Override
    public void onClick(View v) {
        // Send some message to Arduino board, e.g. "13"
        Log.e(TAG, "write failed");
    }

    // Instantiating the Handler associated with the main thread.
      private Handler messageHandler = new Handler() {

          @Override
          public void handleMessage(Message msg) { 
              Log.i("KegApp", "***********************message handler before " + msg.what +  "************************");
                try {  
                    String load = msg.obj.toString();
                    Log.i("KegApp", "***********************in message handler*************************");
                    /*
                    if (button2visible==false) {
                        debugtext.setText("Received message: "+String.valueOf(load));
                        button2.setVisibility(View.VISIBLE);
                        button2visible = true;
                    } else {
                        debugtext.setText("");
                        button2.setVisibility(View.GONE);
                        button2visible = false;
                    }
                    */
                    new TempUpdateTask().execute(load);

                } catch (Exception e) {
                    Log.e(TAG, "message failed", e);
                }
          }

      };

// UpdateData Asynchronously sends the value received from ADK Main Board.
// This is triggered by onReceive()
class TempUpdateTask extends AsyncTask<String, String, String> {

    // Called to initiate the background activity
    protected String doInBackground(String... sensorValue) {
            try {
                Log.i("KegApp", "***********************calling sendcommand*********************");
                sendCommand(mOutputStream);

                Log.i("KegApp", "*********************incoming-sensorValue*********************" );
                ArduinoMessage arduinoMessage = new ArduinoMessage(sensorValue[0]);


            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            String returnString = String.valueOf(sensorValue[0]);//String.valueOf(sensorValue[0]) + " F";
            publishProgress(String.valueOf(sensorValue[0]));
            return (returnString); // This goes to result

    }

    // Called when there's a status to be updated
    @Override
    protected void onProgressUpdate(String... values) {
        // Init TextView Widget to display ADC sensor value in numeric.
        TextView tvAdcvalue = (TextView) findViewById(R.id.tvTemp);
        tvAdcvalue.setText(String.valueOf(values[0]));

        // Not used in this case
    }

    // Called once the background activity has completed
    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        closeAccessory();
    }

}
}

package com.kegui.test；
导入java.io.BufferedOutputStream；
导入java.io.BufferedReader；
导入java.io.ByteArrayOutputStream；
导入java.io.FileDescriptor；
导入java.io.FileInputStream；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.io.StringWriter；
导入java.io.Writer；
导入java.nio.ByteBuffer；
导入java.nio.CharBuffer；
导入java.util.ArrayList；
导入org.apache.http.NameValuePair；
导入org.apache.http.message.BasicNameValuePair；
导入com.kegui.test.Scripto；
导入android.app.Activity；
导入android.app.pendingent；
导入android.content.BroadcastReceiver；
导入android.content.Context；
导入android.content.Intent；
导入android.content.IntentFilter；
导入android.hardware.usb.UsbAccessory；
导入android.hardware.usb.UsbManager；
导入android.os.AsyncTask；
导入android.os.Bundle；
导入android.os.Handler；
导入android.os.Message；
导入android.os.ParcelFileDescriptor；
导入android.util.Log；
导入android.view.view；
导入android.view.view.OnClickListener；
导入android.widget.Button；
导入android.widget.TextView；
公共类USBAccess扩展活动实现可运行的OnClickListener{
私有静态最终字符串ACTION\u USB\u PERMISSION=“com.google.android.DemoKit.ACTION.USB\u PERMISSION”；
受保护的静态最终字符串标记=“KegUI”；
私人UsbManager mUsbManager；
私人悬而未决的侵权意图；
私有布尔mPermissionRequestPending；
private TextView debugtext=null；
私有按钮button1=null；
私有按钮2=空；
私有布尔按钮n2visible=false；
美国特许经营权；
ParcelFileDescriptor mFileDescriptor；
FileInputStream mInputStream；
FileOutputStream mOutputStream；
私有静态最终int消息按钮按下=1；
专用最终广播接收器mUsbReceiver=新广播接收器（）{
@凌驾
公共void onReceive（上下文、意图）{
String action=intent.getAction（）；
Log.i（“KegApp”，“收到****************************************************************”；
if（动作\u USB\u权限等于（动作））{
已同步（此）{
UsbAccessory附件=（UsbAccessory）intent.getParcelableExtra（UsbManager.EXTRA_附件）；
if（intent.getBooleanExtra）(
UsbManager.EXTRA_权限（已授予，错误））{
开放式附件（附件）；
}否则{
日志d（标签“附件权限被拒绝”
+附件）；
}
mPermissionRequestPending=false；
}
}否则如果（UsbManager.ACTION_USB_附件_DETACHED.equals（ACTION））{
UsbAccessory附件=（UsbAccessory）intent.getParcelableExtra（UsbManager.EXTRA_附件）；
if（附件！=null&附件等于（mAccessory））{
关闭附件（）；
}
}
}
};
/**在首次创建活动时调用*/
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
mUsbManager=（UsbManager）getSystemService（Context.USB_服务）；
mPermissionIntent=PendingIntent.getBroadcast（此，0，新Intent(
操作（USB权限），0）；
IntentFilter筛选器=新建IntentFilter（操作\u USB\u权限）；
filter.addAction（UsbManager.ACTION_USB_附件_分离）；
setContentView（R.layout.main）；
最终按钮按钮=（按钮）findViewById（R.id.button1）；
setOnClickListener（新视图.OnClickListener（）{
公共void onClick（视图v）{
//单击后执行操作
新的TempUpdateTask（）。执行（“测试”）；
}
});
寄存器接收器（mUsbReceiver，过滤器）；
Log.d（标记“on Create'd”）；
}
@凌驾
恢复时公开作废（）{
super.onResume（）；
if（mInputStream！=null&&mOutputStream！=null）{
返回；
}
UsbAccessory[]附件=mUsbManager.getAccessoryList（）；
usb附件=（附件==null？null:附件[0]）；
如果（附件！=null）{
if（mUsbManager.hasPermission（附件））{
开放式附件（附件）；
}否则{
已同步（mUsbReceiver）{
如果（！mPermissionRequestPending）{
mUsbManager.requestPermission（附件、，
mPermissionIntent）；
mPermissionRequestPending=true；
}
}
}
}否则{
Log.d（标记“mAccessory为null”）；
}
}
@凌驾
公共无效暂停（）{
super.onPause（）；
关闭附件（）；
}
@凌驾
公共空间{
super.ondestory（）；
未注册接收人（mUsbReceiver）；
}
私人配件（美国特许配件）{
mFileDescriptor=mUsbManager.openAccessory（附件）；
if（mFileDescriptor！=null）{
maccestory=附件；
FileDescriptor fd=mFileDescriptor.getFileDescriptor（）；
mInputStream=新文件输入流（fd）；
mOutputStream=新文件输出流（fd）；
Thread Thread=新线程（null，这是“KegApp
#include <FHB.h>
#include <Max3421e.h>
#include <Max3421e_constants.h>
#include <Max_LCD.h>
#include <Usb.h>


//FREEDUINO ONLY------------------------------------

//END FREEDUINO ONLY------------------------------------
int pin_light_sensor_1=A0;
int pin_output_sensor=9;
int currLightLevel=0;
//int prevLightLevel=0;
//int lightStableRange=90;
int delayTime=3000;
int loopCtr=0;
char cSTX=char(2);
char cSOH=char(1);
char cEOT=char(4);
char cGS=char(29);
char cRS=char(30);
char cCR=char(13);
char cLF=char(10);

//FREEDUINO ONLY------------------------------------
AndroidAccessory acc("Company Inc.",
             "Kegbot5K datawriter",
             "Kegbot 5000 data writer",
             "1.0",
             "http://companyinc.com",
             "0000000012345678");
//END FREEDUINO ONLY------------------------------------
void setup()
{
  pinMode(pin_light_sensor_1, INPUT);
  pinMode(pin_output_sensor, OUTPUT);
  Serial.begin(57600);
//FREEDUINO ONLY------------------------------------  
  Serial.println("pre-power");
  acc.powerOn();
  Serial.println("post-power");
//END FREEDUINO ONLY------------------------------------
}

void loop()
{
byte msg[3];
if (acc.isConnected()) {
  currLightLevel = analogRead(pin_light_sensor_1);

     //sysPrint(delayTime*loopCtr);
     //sysPrint(",");
     //sysPrint(currLightLevel);
     writeDataMessage("LGH01", currLightLevel);

 }

 delay(1000);
 if (acc.isConnected()) {
    int len = acc.read(msg, sizeof(msg), 1);
    Serial.println(len);
      if (len > 0){
     for (int index=0; index < len; index++){
        digitalWrite(pin_output_sensor, 1);
                delay(500);
        digitalWrite(pin_output_sensor, 0);
     }
      }
 }
  loopCtr++;
  delay(delayTime);
}

void writeHeader(String msgType)
{
  sysPrint(cSTX);
  sysPrint(cSTX);
  sysPrint(cSOH);
  sysPrint(msgType);
  sysPrint(cGS);
}

void writeFooter()
  {
  sysPrint(cEOT);
  sysPrintLn(cEOT);
  }

void writeDataMessage(String sensorID, int value)
  {
  writeHeader("DATA");
  sysPrint(sensorID);
  sysPrint(cRS);
  sysPrint(value);
  writeFooter();
  }

void writeAlarmMessage(String sensorID, String message)
//Do we need to enforce the 5 char sensorID here? I don't think so...
  {
  writeHeader("ALRM");
  sysPrint(sensorID);
  sysPrint(cRS);
  sysPrint(message);
  writeFooter();
  }

void sysPrint(String whatToWrite)
  {
    int len=whatToWrite.length();
  char str[len];
  whatToWrite.toCharArray(str, len);
  acc.write((void *)str, len);
 // acc.write(&whatToWrite, whatToWrite.length());
  }
void sysPrint(char whatToWrite)
  {
  acc.write((void *)whatToWrite, 1);
 // acc.write(&whatToWrite, 1);
  }
void sysPrint(int whatToWrite)
  {
  acc.write((void *)&whatToWrite, 1);
//  acc.write(&whatToWrite, 1);
  }

void sysPrintLn(String whatToWrite)
  {
  int len=whatToWrite.length();
  char str[len];
  whatToWrite.toCharArray(str, len);
  acc.write((void *)str, len);
  acc.write((void *)&cCR, 1);
  acc.write((void *)&cLF, 1);
 // acc.write(&whatToWrite, whatToWrite.length());
 // acc.write(&cCR, 1);
 // acc.write(&cLF, 1);
  }

void sysPrintLn(char whatToWrite)
  {
  acc.write((void *)whatToWrite, 1);
   acc.write((void *)&cCR, 1);
  acc.write((void *)&cLF, 1);
 // acc.write(&whatToWrite, 1);
 // acc.write(&cCR, 1);
 // acc.write(&cLF, 1);
  }

 <intent-filter>
        <action android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED" />
    </intent-filter>

    <meta-data android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED"
        android:resource="@xml/accessory_filter" />
        </activity>

    String getMessage()
    {
      String msg=""; //the message starts empty
      byte ch; // the character that you use to construct the Message 
      byte d='#';// the separating symbol 

      if(Serial.available())// checks if there is a new message;
      {
        while(Serial.available() && Serial.peek()!=d)// while the message did not finish
        {
          ch=Serial.read();// get the character
          msg+=(char)ch;//add the character to the message
          delay(1);//wait for the next character
        }
      ch=Serial.read();// pop the '#' from the buffer
      if(ch==d) // id finished
      return msg;
      else
      return "NA";
      }
    else
    return "NA"; // return "NA" if no message;
}