We have a school project where we want to build a CanSat using some of the sensors found on an Android device, such as accelerometer data and GPS-coordinates, together with some on an Arduino board (pressure, temperature and a geiger counter). We bought the Sony Tipo ST21i and Arduino Mega ADK, and learned that the Tipo only supports ADB mode. 

We don't have much programming experience, but found many great tutorials online and source codes from other projects which we tried to merge together. Unfortunately the USB communication between the Tipo and the Arduino doesn't work in this code. We don't know wether the problem lies on the Android or the Arduino side, but here are both codes:

(Android code is to collect accelerometer data and GPS coordinates and send them using ADB)

2. 
   
3. public final byte COMMAND_SEND_TRUE = 1;    // Allow data transfer
4. 
   
5. import java.io.IOException;
6. import android.util.Log;
7. 
   
8. // Imports
9. import android.content.Context;
10. import android.location.Location;
11. import android.location.LocationManager;
12. import android.location.LocationListener;
13. import android.location.GpsStatus.Listener;
14. import android.os.Bundle;
15. 
    
16. AccelerometerManager accel;
17. float ax, ay, az;
18. 
    
19. 
    
20. String[] fontList;
21. PFont androidFont;
22. 
    
23. LocationManager locationManager;
24. MyLocationListener locationListener;
25. 
    
26. // Variables to hold the current GPS data
27. float currentLatitude  = 0;
28. float currentLongitude = 0;
29. float currentAccuracy  = 0;
30. String currentProvider = "";
31. 
    
32. 
    
33. 
    
34. 
    
35. private Server server;
36. private int sensorValue;
37. 
    
38. void setup()
39. {    
40.   
41.   accel = new AccelerometerManager(this);
42.   orientation(PORTRAIT);
43.   size(displayWidth, displayHeight);
44.   fontList = PFont.list();
45.   androidFont = createFont(fontList[4], 35, true);
46.   textFont(androidFont);
47.   noLoop();
48.   
49.   // Create TCP server
50.   server = null;
51.   try
52.   {
53.     server = new Server(4567);
54.     server.start();
55.   } 
56.   catch (IOException e)
57.   {
58.     println(e.toString());
59.   } 
60. 
    
61.   this.server.addListener(new AbstractServerListener() {
62. 
    
63.     @Override
64.       public void onReceive(Client client, byte[] data)
65.     {
66. 
    
67.       if (data.length<2) return;
68. 
    
69.       sensorValue = (data[0] & 0xff) | ((data[1] & 0xff) << 8);
70.     };
71.   }
72.   );
73. }
74. 
    
75. void draw() 
76. {
77.   background(0);
78.  fill(255);
79.   textSize(20);
80.   
81.   textAlign(CENTER, BOTTOM);
82.   
83.   text("x: " + nf(ax, 1, 2) + "\n" + 
84.        "y: " + nf(ay, 1, 2) + "\n" + 
85.        "z: " + nf(az, 1, 2), 160, 180);
86.        
87.   textAlign(CENTER, TOP);
88.   
89.   text("Latitude: "+(currentLatitude) + "\n" +
90.        "Longitude: "+(currentLongitude) + "\n" +
91.        "Accuracy: "+(currentAccuracy) + "\n" +
92.        "Provider: "+(currentProvider), 160, 300);
93.     
94. }
95. 
    
96.   byte ux = byte(ax);
97.   byte uy = byte(ay);
98.   byte uz = byte(az);
99.  
100.  public void send() { 
101.    try {
102.  server.send(new byte[] {
103.        (byte) (ux)
104.        ,(byte) (uy)
105.        ,(byte) (uz)
106.  }
107.  );
108.  }
109.       catch (IOException e)
110.     {
111.       println("We got problems");
112.     }
113.     
114.     try {
115.       Thread.sleep(500);
116. } 
117.     catch(InterruptedException ex) {
118.       println("Oh no");
119. }
120. 
     
121.    }
122.      
123. 
     
124.  
125. public void resume() {
126.   if (accel != null) {
127.     accel.resume();
128.   }
129. }
130. 
     
131.     
132. public void pause() {
133.   if (accel != null) {
134.     accel.pause();
135.   }
136. }
137. 
     
138. 
     
139. public void shakeEvent(float force) {
140.   println("shake : " + force);
141. }
142. 
     
143. 
     
144. public void accelerationEvent(float x, float y, float z) {
145. //  println("acceleration: " + x + ", " + y + ", " + z);
146.   ax = x;
147.   ay = y;
148.   az = z;
149.   redraw();
150. }
151. 
     
152. void onResume() {
153.   super.onResume();
154.   // Build Listener
155.   locationListener = new MyLocationListener();
156.   // Acquire a reference to the system Location Manager
157.   locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
158.   // Register the listener with the Location Manager to receive location updates
159.   locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
160. }
161. 
     
162. void onPause() {
163.   super.onPause();
164. }
165. 
     
166. //-----------------------------------------------------------------------------------------
167. 
     
168. // Define a listener that responds to location updates
169. class MyLocationListener implements LocationListener {
170.    void onLocationChanged(Location location) {
171.       // Called when a new location is found by the network location provider.
172.       currentLatitude  = (float)location.getLatitude();
173.       currentLongitude = (float)location.getLongitude();
174.       currentAccuracy  = (float)location.getAccuracy();
175.       currentProvider  = location.getProvider();
176.     }
177.     void onProviderDisabled (String provider) { 
178.       currentProvider = "";
179.     }
180. 
     
181.     void onProviderEnabled (String provider) { 
182.       currentProvider = provider;
183.     }
184. 
     
185.     void onStatusChanged (String provider, int status, Bundle extras) {
186.       // Nothing yet...
187.     }
188.     
189. }

(The Arduino code is to receive the data sent from the Tipo, and write it to serial monitor)

2. 
   
3. 
   
4. #include <SoftModem.h>
5. #include <ctype.h>
6. #include <Wire.h>
7. #include <LiquidCrystal.h>
8. 
   
9. #include <SPI.h>
10. 
    
11. #include <Adb.h>
12. #define MAX_RESET 8
13. 
    
14. 
    
15. #define BMP085_ADDRESS 0x77  // I2C address of BMP085
16. 
    
17. // Threshold values for the led bar
18. #define TH1 45
19. #define TH2 95
20. #define TH3 200
21. #define TH4 400
22. #define TH5 600
23. 
    
24. // Conversion factor - CPM to uSV/h
25. #define CONV_FACTOR 0.00812
26. 
    
27. // initialize the library with the numbers of the interface pins
28. LiquidCrystal lcd(3,4,5,6,7,8);
29. 
    
30. const unsigned char OSS = 0;  // Oversampling Setting
31. 
    
32. // Add these to the top of your program
33. const float p0 = 101860;     // Pressure at sea level (Pa)
34. float altitude;
35. 
    
36. // Calibration values
37. int ac1;
38. int ac2; 
39. int ac3; 
40. unsigned int ac4;
41. unsigned int ac5;
42. unsigned int ac6;
43. int b1; 
44. int b2;
45. int mb;
46. int mc;
47. int md;
48. 
    
49. // Variables
50. int ledArray [] = {10,11,12,13,9};
51. int geiger_input = 2;
52. long count = 0;
53. long countPerSecond = 0;
54. long timePrevious = 0;
55. long timePreviousMeassure = 0;
56. long time = 0;
57. long countPrevious = 0;
58. float radiationValue = 0.0;
59. 
    
60. // b5 is calculated in bmp085GetTemperature(...), this variable is also used in bmp085GetPressure(...)
61. // so ...Temperature(...) must be called before ...Pressure(...).
62. long b5; 
63. 
    
64. short temperature;
65. long pressure;
66. 
    
67. SoftModem modem;
68. 
    
69. Connection * connection;
70. 
    
71. word ttemp;
72. word ttrykk;
73. word hhoyde;
74. word ccps;
75. 
    
76. long uusb;
77. 
    
78. // Elapsed time for ADC sampling
79. long lastTime;
80. boolean r = true;
81. 
    
82. 
    
83. void setup()
84. {
85.   Serial.begin(9600);
86.   Wire.begin();
87.   bmp085Calibration();
88.   
89.   pinMode(geiger_input, INPUT);
90.   digitalWrite(geiger_input,HIGH);
91.   for (int i=0;i<5;i++){
92.     pinMode(ledArray[i],OUTPUT);
93.   
94.   modem.begin();
95.   
96.   pinMode(3,OUTPUT);
97.   pinMode(3, HIGH);
98.   
99.    // Note start time
100.   lastTime = millis();
101. 
     
102. 
     
103.   // Initialise the ADB subsystem.  
104.   ADB::init();
105. 
     
106.   // Open an ADB stream to the phone's shell. Auto-reconnect
107.   connection = ADB::addConnection("tcp:4567", true, adbEventHandler);  
108. }
109. 
     
110.   lcd.begin(16, 2);
111.   lcd.clear();
112.   lcd.setCursor(0, 0);
113.   lcd.print("Prosjekt Andoya");
114.   lcd.setCursor(0,1);
115.   lcd.print("Oh yeah!");  
116.   delay(500);
117. 
     
118.   lcd.clear();  
119.   lcd.setCursor(0, 0);
120.   lcd.print("CPS=");
121.   lcd.setCursor(4,0);
122.   lcd.print(6*count);
123.   lcd.setCursor(0,1);
124.   lcd.print(radiationValue);
125. 
     
126.   attachInterrupt(0,countPulse,FALLING);
127. 
     
128. }
129. 
     
130. // Event handler for the shell connection. 
131. void adbEventHandler(Connection * connection, adb_eventType event, uint16_t length, uint8_t * data)
132. {
133.   byte i;
134. 
     
135.   switch (event)
136.         {
137.         case (ADB_CONNECTION_RECEIVE):
138.           Serial.println(data[i]);
139. 
     
140.         default:
141.            break;
142.         }
143. 
     
144. }
145.  
146. 
     
147. 
     
148. void loop()
149. {
150.   unsigned long uusb = Serial.read();
151. 
     
152.   temperature = bmp085GetTemperature(bmp085ReadUT());
153.   pressure = bmp085GetPressure(bmp085ReadUP());
154.   altitude = (float)44330 * (1 - pow(((float) pressure/p0), 0.190295));
155.   
156.   /*
157.   Serial.print("Temperatur: ");
158.   Serial.print(temperature, DEC);
159.   Serial.println(" *0.1 deg C");
160.   Serial.print("Lufttrykk: ");
161.   Serial.print(pressure, DEC);
162.   Serial.println(" Pa");
163.   // Add this into loop(), after you've calculated the pressure
164.   Serial.print("Moh.: ");
165.   Serial.print(altitude, 2);
166.   Serial.println();
167.   Serial.println(uusb);
168.   delay(3000);
169.   Serial.println();
170.   */
171.   
172.   if (millis()-timePreviousMeassure > 1000){
173.     countPerSecond = count;
174.     /*
175.     radiationValue = countPerMinute * CONV_FACTOR;
176.     */
177.     timePreviousMeassure = millis();
178.     Serial.print("cps = "); 
179.     Serial.println(countPerSecond,DEC);
180.     /*
181.     Serial.print(" - ");
182.     Serial.print("uSv/h = ");
183.     Serial.println(radiationValue,4); 
184. */    
185.     lcd.clear();    
186.     lcd.setCursor(0, 0);
187.     lcd.print("CPS=");
188.     lcd.setCursor(4,0);
189.     lcd.print(countPerSecond);
190.     lcd.setCursor(7,0);
191.     lcd.print("p=");
192.     lcd.setCursor(9,0);
193.     lcd.print(pressure, DEC);
194.     lcd.setCursor(0,1);
195.     lcd.print("a=");
196.     lcd.setCursor(2,1);
197.     lcd.print(altitude, 2);
198.     lcd.setCursor(10,1);
199.     lcd.print("t=");
200.     lcd.setCursor(12,1);
201.     lcd.print(temperature, DEC);
202.     /*
203.     lcd.setCursor(0,1);
204.     lcd.print(radiationValue,4);
205.     lcd.setCursor(6,1);
206.     lcd.print(" uSv/h");
207.     */
208.     ttrykk = pressure;
209.     ttemp = temperature;
210.     hhoyde = altitude;
211.     ccps = countPerSecond;
212.     
213.     modem.write(ttrykk);
214.     modem.write(ttemp);
215.     modem.write(hhoyde);
216.     modem.write(ccps);
217.     modem.write(uusb);
218. 
     
219.     //led var setting  
220.     if(countPerSecond <= TH1) ledVar(0);
221.     if((countPerSecond <= TH2)&&(countPerSecond>TH1)) ledVar(1);
222.     if((countPerSecond <= TH3)&&(countPerSecond>TH2)) ledVar(2);
223.     if((countPerSecond <= TH4)&&(countPerSecond>TH3)) ledVar(3);
224.     if((countPerSecond <= TH5)&&(countPerSecond>TH4)) ledVar(4);
225.     if(countPerSecond>TH5) ledVar(5);
226. 
     
227.     count = 0;
228.   }
229.     ADB::poll();
230.   
231. }
232. 
     
233. 
     
234. 
     
235. void countPulse(){
236.   detachInterrupt(0);
237.   count++;
238.   while(digitalRead(2)==0){
239.   }
240.   attachInterrupt(0,countPulse,FALLING);
241. }
242. 
     
243. void ledVar(int value){
244.   if (value > 0){
245.     for(int i=0;i<=value;i++){
246.       digitalWrite(ledArray[i],HIGH);
247.     }
248.     for(int i=5;i>value;i--){
249.       digitalWrite(ledArray[i],LOW);
250.     }
251.   }
252.   else {
253.     for(int i=5;i>=0;i--){
254.       digitalWrite(ledArray[i],LOW);
255.     }
256.   }
257. }
258. 
     
259. 
     
260. // Stores all of the bmp085's calibration values into global variables
261. // Calibration values are required to calculate temp and pressure
262. // This function should be called at the beginning of the program
263. void bmp085Calibration()
264. {
265.   ac1 = bmp085ReadInt(0xAA);
266.   ac2 = bmp085ReadInt(0xAC);
267.   ac3 = bmp085ReadInt(0xAE);
268.   ac4 = bmp085ReadInt(0xB0);
269.   ac5 = bmp085ReadInt(0xB2);
270.   ac6 = bmp085ReadInt(0xB4);
271.   b1 = bmp085ReadInt(0xB6);
272.   b2 = bmp085ReadInt(0xB8);
273.   mb = bmp085ReadInt(0xBA);
274.   mc = bmp085ReadInt(0xBC);
275.   md = bmp085ReadInt(0xBE);
276. }
277. 
     
278. // Calculate temperature given ut.
279. // Value returned will be in units of 0.1 deg C
280. short bmp085GetTemperature(unsigned int ut)
281. {
282.   long x1, x2;
283.   
284.   x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
285.   x2 = ((long)mc << 11)/(x1 + md);
286.   b5 = x1 + x2;
287. 
     
288.   return ((b5 + 8)>>4);  
289. }
290. 
     
291. // Calculate pressure given up
292. // calibration values must be known
293. // b5 is also required so bmp085GetTemperature(...) must be called first.
294. // Value returned will be pressure in units of Pa.
295. long bmp085GetPressure(unsigned long up)
296. {
297.   long x1, x2, x3, b3, b6, p;
298.   unsigned long b4, b7;
299.   
300.   b6 = b5 - 4000;
301.   // Calculate B3
302.   x1 = (b2 * (b6 * b6)>>12)>>11;
303.   x2 = (ac2 * b6)>>11;
304.   x3 = x1 + x2;
305.   b3 = (((((long)ac1)*4 + x3)<<OSS) + 2)>>2;
306.   
307.   // Calculate B4
308.   x1 = (ac3 * b6)>>13;
309.   x2 = (b1 * ((b6 * b6)>>12))>>16;
310.   x3 = ((x1 + x2) + 2)>>2;
311.   b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
312.   
313.   b7 = ((unsigned long)(up - b3) * (50000>>OSS));
314.   if (b7 < 0x80000000)
315.     p = (b7<<1)/b4;
316.   else
317.     p = (b7/b4)<<1;
318.     
319.   x1 = (p>>8) * (p>>8);
320.   x1 = (x1 * 3038)>>16;
321.   x2 = (-7357 * p)>>16;
322.   p += (x1 + x2 + 3791)>>4;
323.   
324.   return p;
325. }
326. 
     
327. // Read 1 byte from the BMP085 at 'address'
328. char bmp085Read(unsigned char address)
329. {
330.   unsigned char data;
331.   
332.   Wire.beginTransmission(BMP085_ADDRESS);
333.   Wire.write(address);
334.   Wire.endTransmission();
335.   
336.   Wire.requestFrom(BMP085_ADDRESS, 1);
337.   while(!Wire.available())
338.     ;
339.     
340.   return Wire.read();
341. }
342. 
     
343. // Read 2 bytes from the BMP085
344. // First byte will be from 'address'
345. // Second byte will be from 'address'+1
346. int bmp085ReadInt(unsigned char address)
347. {
348.   unsigned char msb, lsb;
349.   
350.   Wire.beginTransmission(BMP085_ADDRESS);
351.   Wire.write(address);
352.   Wire.endTransmission();
353.   
354.   Wire.requestFrom(BMP085_ADDRESS, 2);
355.   while(Wire.available()<2)
356.     ;
357.   msb = Wire.read();
358.   lsb = Wire.read();
359.   
360.   return (int) msb<<8 | lsb;
361. }
362. 
     
363. // Read the uncompensated temperature value
364. unsigned int bmp085ReadUT()
365. {
366.   unsigned int ut;
367.   
368.   // Write 0x2E into Register 0xF4
369.   // This requests a temperature reading
370.   Wire.beginTransmission(BMP085_ADDRESS);
371.   Wire.write(0xF4);
372.   Wire.write(0x2E);
373.   Wire.endTransmission();
374.   
375.   // Wait at least 4.5ms
376.   delay(5);
377.   
378.   // Read two bytes from registers 0xF6 and 0xF7
379.   ut = bmp085ReadInt(0xF6);
380.   return ut;
381. }
382. 
     
383. // Read the uncompensated pressure value
384. unsigned long bmp085ReadUP()
385. {
386.   unsigned char msb, lsb, xlsb;
387.   unsigned long up = 0;
388.   
389.   // Write 0x34+(OSS<<6) into register 0xF4
390.   // Request a pressure reading w/ oversampling setting
391.   Wire.beginTransmission(BMP085_ADDRESS);
392.   Wire.write(0xF4);
393.   Wire.write(0x34 + (OSS<<6));
394.   Wire.endTransmission();
395.   
396.   // Wait for conversion, delay time dependent on OSS
397.   delay(2 + (3<<OSS));
398.   
399.   // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB)
400.   Wire.beginTransmission(BMP085_ADDRESS);
401.   Wire.write(0xF6);
402.   Wire.endTransmission();
403.   Wire.requestFrom(BMP085_ADDRESS, 3);
404.   
405.   // Wait for data to become available
406.   while(Wire.available() < 3)
407.     ;
408.   msb = Wire.read();
409.   lsb = Wire.read();
410.   xlsb = Wire.read();
411.   
412.   up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS);
413.   
414.   return up;
415. }

Got any suggestions?..