Changeset 60b4520 in orbit for android/src

Timestamp:

11/15/12 18:57:06 (10 years ago)

Author:

Steve Castellotti <sc@…>

Branches:

master, RawEEG, Raw_EEG_Plot, Servo, Tab_Interface, pyramid

Children:

41c4762

Parents:

8a0fa760

Message:

• First working version (source ported from Puzzlebox Brainstorms Helicopter)

Location:

android/src/info/puzzlebox/orbit

Files:

• MainActivity.java (modified) (1 diff)
• SerialDevice.java (added)

android/src/info/puzzlebox/orbit/MainActivity.java

@@ -1 +1 @@
 package info.puzzlebox.orbit;
 
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.hoho.android.usbserial.driver.UsbSerialDriver;
+import com.hoho.android.usbserial.driver.UsbSerialProber;
+import com.hoho.android.usbserial.util.SerialInputOutputManager;
+import com.neurosky.thinkgear.TGDevice;
+
 import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.annotation.SuppressLint;
 import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.drawable.ClipDrawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RoundRectShape;
+import android.hardware.usb.UsbManager;
+import android.view.Gravity;
 import android.view.Menu;
 import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.ProgressBar;
+import android.widget.SeekBar;
+import android.widget.TextView;
+import android.widget.Toast;
 import android.support.v4.app.NavUtils;
-
-public class MainActivity extends Activity {
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_main);
-        getActionBar().setDisplayHomeAsUpEnabled(true);
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        getMenuInflater().inflate(R.menu.activity_main, menu);
-        return true;
-    }
-
-    
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        switch (item.getItemId()) {
-            case android.R.id.home:
-                NavUtils.navigateUpFromSameTask(this);
-                return true;
-        }
-        return super.onOptionsItemSelected(item);
-    }
+import android.text.Layout;
+import android.text.method.ScrollingMovementMethod;
+
+public class MainActivity extends Activity implements SeekBar.OnSeekBarChangeListener {
+
+//    @Override
+//    public void onCreate(Bundle savedInstanceState) {
+//        super.onCreate(savedInstanceState);
+//        setContentView(R.layout.activity_main);
+//        getActionBar().setDisplayHomeAsUpEnabled(true);
+//    }
+//
+//    @Override
+//    public boolean onCreateOptionsMenu(Menu menu) {
+//        getMenuInflater().inflate(R.menu.activity_main, menu);
+//        return true;
+//    }
+//
+//    
+//    @Override
+//    public boolean onOptionsItemSelected(MenuItem item) {
+//        switch (item.getItemId()) {
+//            case android.R.id.home:
+//                NavUtils.navigateUpFromSameTask(this);
+//                return true;
+//        }
+//        return super.onOptionsItemSelected(item);
+//    }
+        
+        BluetoothAdapter bluetoothAdapter;
+
+        ProgressBar progressBarAttention;
+        ProgressBar progressBarMeditation;
+        ProgressBar progressBarSignal;
+        ProgressBar progressBarPower;
+        SeekBar seekBarAttention;
+        SeekBar seekBarMeditation;
+        TextView tv;
+        Button b;
+
+        int tgSignal = 0;
+        int[] thresholdValuesAttention = new int[101];
+        int[] thresholdValuesMeditation = new int[101];
+        //      int minimumPower = 60; // minimum power to which the flame effect can be set
+        int minimumPower = 0; // minimum power to which the flame effect can be set
+        int maximumPower = 100;
+
+        SerialDevice serial;
+        //      int serialBaudRate = 9600;
+        int serialBaudRate = 133333;
+
+
+        TGDevice tgDevice;
+        final boolean rawEnabled = false;
+
+
+        private static final String MAC_ADDRESS = "D0:DF:9A:69:5D:42"; // MindWave Mobile Dev (p1-dev-60-01)
+        //private static final String MAC_ADDRESS = "00:16:53:09:0B:B9";
+
+        /**
+         * The device currently in use, or {@code null}.
+         */
+        private UsbSerialDriver mSerialDevice;
+
+        /**
+         * The system's USB service.
+         */
+        private UsbManager mUsbManager;
+
+
+        private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
+
+        private SerialInputOutputManager mSerialIoManager;
+
+        private final SerialInputOutputManager.Listener mListener =
+                        new SerialInputOutputManager.Listener() {
+
+                public void onRunError(Exception e) {
+                        //            Log.d(TAG, "Runner stopped.");
+                }
+
+                public void onNewData(final byte[] data) {
+                        //              PuzzleboxBrainstormsHelicopter.this.runOnUiThread(new Runnable() {
+                        //                @Override
+                        //                public void run() {
+                        //                      PuzzleboxBrainstormsHelicopter.this.updateReceivedData(data);
+                        //                }
+                        //            });
+                }
+        };
+
+
+        @SuppressWarnings("deprecation")
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+                /** Called when the activity is first created. */
+                super.onCreate(savedInstanceState);
+                //              setContentView(R.layout.main);
+                setContentView(R.layout.activity_main);
+
+                mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
+
+                progressBarAttention = (ProgressBar)findViewById(R.id.progressBarAttention);
+                final float[] roundedCorners = new float[] { 5, 5, 5, 5, 5, 5, 5, 5 };
+                ShapeDrawable progressBarAttentionDrawable = new ShapeDrawable(new RoundRectShape(roundedCorners, null,null));
+                String progressBarAttentionColor = "#FF0000";
+                progressBarAttentionDrawable.getPaint().setColor(Color.parseColor(progressBarAttentionColor));
+                ClipDrawable progressAttention = new ClipDrawable(progressBarAttentionDrawable, Gravity.LEFT, ClipDrawable.HORIZONTAL);
+                progressBarAttention.setProgressDrawable(progressAttention);   
+                progressBarAttention.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.progress_horizontal));
+                //              progressBarAttention.setProgress(80);
+
+                progressBarMeditation = (ProgressBar)findViewById(R.id.progressBarMeditation);
+                ShapeDrawable progressBarMeditationDrawable = new ShapeDrawable(new RoundRectShape(roundedCorners, null,null));
+                String progressBarMeditationColor = "#0000FF";
+                progressBarMeditationDrawable.getPaint().setColor(Color.parseColor(progressBarMeditationColor));
+                ClipDrawable progressMeditation = new ClipDrawable(progressBarMeditationDrawable, Gravity.LEFT, ClipDrawable.HORIZONTAL);
+                progressBarMeditation.setProgressDrawable(progressMeditation);   
+                progressBarMeditation.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.progress_horizontal));
+                //              progressBarMeditation.setProgress(60);
+
+                progressBarSignal = (ProgressBar)findViewById(R.id.progressBarSignal);
+                ShapeDrawable progressBarSignalDrawable = new ShapeDrawable(new RoundRectShape(roundedCorners, null,null));
+                String progressBarSignalColor = "#00FF00";
+                progressBarSignalDrawable.getPaint().setColor(Color.parseColor(progressBarSignalColor));
+                ClipDrawable progressSignal = new ClipDrawable(progressBarSignalDrawable, Gravity.LEFT, ClipDrawable.HORIZONTAL);
+                progressBarSignal.setProgressDrawable(progressSignal);
+                progressBarSignal.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.progress_horizontal));
+                //              progressBarSignal.setProgress(40);
+                progressBarSignal.setProgress(tgSignal);
+
+                progressBarPower = (ProgressBar)findViewById(R.id.progressBarPower);
+                ShapeDrawable progressBarPowerDrawable = new ShapeDrawable(new RoundRectShape(roundedCorners, null,null));
+                String progressBarPowerColor = "#FFFF00";
+                progressBarPowerDrawable.getPaint().setColor(Color.parseColor(progressBarPowerColor));
+                ClipDrawable progressPower = new ClipDrawable(progressBarPowerDrawable, Gravity.LEFT, ClipDrawable.HORIZONTAL);
+                progressBarPower.setProgressDrawable(progressPower);   
+                progressBarPower.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.progress_horizontal));
+                //progressBarPower.setProgress(20);
+
+                //tv = (TextView)findViewById(R.id.textViewDebugConsole);
+                //tv.setText("");
+                //tv.append("Android version: " + Integer.valueOf(android.os.Build.VERSION.SDK) + "\n" );
+
+                seekBarAttention = (SeekBar)findViewById(R.id.seekBarAttention);
+                seekBarAttention.setOnSeekBarChangeListener(this);
+                seekBarMeditation = (SeekBar)findViewById(R.id.seekBarMeditation);
+                seekBarMeditation.setOnSeekBarChangeListener(this);
+
+
+                updatePowerThresholds();
+                //              updateNXTPower();
+                updatePower();
+
+
+                tv = (TextView)findViewById(R.id.textViewDebugConsole);
+                tv.setMovementMethod(new ScrollingMovementMethod());
+                tv.setText("");
+                appendTextAndScroll("Android version: " + Integer.valueOf(android.os.Build.VERSION.SDK) + "\n" );
+
+
+                bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+                if(bluetoothAdapter == null) {
+                        // Alert user that Bluetooth is not available
+                        Toast.makeText(this, "Bluetooth not available", Toast.LENGTH_LONG).show();
+                        finish();
+                        return;
+                }else {
+                        /* create the TGDevice */
+                        tgDevice = new TGDevice(bluetoothAdapter, handler);
+                }
+
+
+                serial = new SerialDevice();
+                serial.setSerialDevice(mSerialDevice);
+
+
+        } // onCreate
+
+
+        @Override
+        protected void onResume() {
+                super.onResume();
+                mSerialDevice = UsbSerialProber.acquire(mUsbManager);
+                //        Log.d(TAG, "Resumed, mSerialDevice=" + mSerialDevice);
+                if (mSerialDevice == null) {
+                        //          mTitleTextView.setText("No serial device.");
+                        //            tv.setText("No serial device.\n");
+                        appendTextAndScroll("No serial device.\n");
+                } else {
+                        try {
+                                mSerialDevice.open();
+                                mSerialDevice.setBaudRate(serialBaudRate);
+                                serial.setSerialDevice(mSerialDevice);
+                                serial.execute(new String[] {""} );
+                        } catch (IOException e) {
+                                //                Log.e(TAG, "Error setting up device: " + e.getMessage(), e);
+                                //              mTitleTextView.setText("Error opening device: " + e.getMessage());
+                                //                tv.setText("Error opening device: " + e.getMessage() + "\n");
+                                appendTextAndScroll("Error opening device: " + e.getMessage() + "\n");
+
+                                try {
+                                        mSerialDevice.close();
+                                } catch (IOException e2) {
+                                        // Ignore.
+                                }
+                                mSerialDevice = null;
+                                serial.setSerialDevice(null);
+                                return;
+                        }
+                        appendTextAndScroll("Serial device: " + mSerialDevice + "\n");
+                }
+                onDeviceStateChange();
+        }
+
+
+        @Override
+        public void onDestroy() {
+                tgDevice.close();
+                if (mSerialDevice != null) {
+                        try {
+                                mSerialDevice.close();
+                        } catch (IOException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+                super.onDestroy();
+        }
+
+
+        private final Handler handler = new Handler() {
+
+                /**
+                 * Handles messages from TGDevice
+                 */
+
+                @SuppressLint({ "HandlerLeak", "HandlerLeak" })
+                @Override
+                public void handleMessage(Message msg) {
+                        switch (msg.what) {
+                        case TGDevice.MSG_STATE_CHANGE:
+
+                                switch (msg.arg1) {
+                                case TGDevice.STATE_IDLE:
+                                        break;
+                                case TGDevice.STATE_CONNECTING:
+                                        appendTextAndScroll("Connecting: " + MAC_ADDRESS + "\n");
+                                        break;
+                                case TGDevice.STATE_CONNECTED:
+                                        appendTextAndScroll("Connected.\n");
+                                        tgDevice.start();
+                                        break;
+                                case TGDevice.STATE_NOT_FOUND:
+                                        appendTextAndScroll("Can't find\n");
+                                        break;
+                                case TGDevice.STATE_NOT_PAIRED:
+                                        appendTextAndScroll("not paired\n");
+                                        break;
+                                case TGDevice.STATE_DISCONNECTED:
+                                        appendTextAndScroll("Disconnected mang\n");
+                                        break;
+                                }
+
+                                break;
+
+                        case TGDevice.MSG_POOR_SIGNAL:
+                                tgSignal = calculateSignal(msg.arg1);
+                                //signal = msg.arg1;
+                                //              tv.append("PoorSignal: " + msg.arg1 + "\n");
+                                appendTextAndScroll("\nPoorSignal: " + msg.arg1 + "\n");
+                                progressBarSignal.setProgress(tgSignal);
+
+
+                                //                              updateNXTPower();
+                                updatePower();
+
+
+                                break;
+                        case TGDevice.MSG_RAW_DATA:
+                                //raw1 = msg.arg1;
+                                //tv.append("Got raw: " + msg.arg1 + "\n");
+                                break;
+                        case TGDevice.MSG_HEART_RATE:
+                                //                      tv.append("Heart rate: " + msg.arg1 + "\n");
+                                appendTextAndScroll("Heart rate: " + msg.arg1 + "\n");
+                                break;
+                        case TGDevice.MSG_ATTENTION:
+                                //att = msg.arg1;
+                                //              tv.append("Attention: " + msg.arg1 + "\n");
+                                appendTextAndScroll("Attention: " + msg.arg1 + "\n");
+                                progressBarAttention.setProgress(msg.arg1);
+                                //Log.v("HelloA", "Attention: " + att + "\n");
+
+                                //                              updateNXTPower();
+                                updatePower();
+
+                                break;
+                        case TGDevice.MSG_MEDITATION:
+                                //                      tv.append("Meditation: " + msg.arg1 + "\n");
+                                appendTextAndScroll("Meditation: " + msg.arg1 + "\n");
+                                progressBarMeditation.setProgress(msg.arg1);
+
+                                //                              updateNXTPower();
+                                updatePower();
+
+                                break;
+                        case TGDevice.MSG_BLINK:
+                                //tv.append("Blink: " + msg.arg1 + "\n");
+                                break;
+                        case TGDevice.MSG_RAW_COUNT:
+                                //tv.append("Raw Count: " + msg.arg1 + "\n");
+                                break;
+                        case TGDevice.MSG_LOW_BATTERY:
+                                Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show();
+                                break;
+                        case TGDevice.MSG_RAW_MULTI:
+                                //TGRawMulti rawM = (TGRawMulti)msg.obj;
+                                //tv.append("Raw1: " + rawM.ch1 + "\nRaw2: " + rawM.ch2);
+                        default:
+                                break;
+                        }
+                }
+        };
+
+
+        public void connectHeadset(View view) {
+
+                if(tgDevice.getState() != TGDevice.STATE_CONNECTING && tgDevice.getState() != TGDevice.STATE_CONNECTED)
+                        tgDevice.connect(rawEnabled);
+
+
+        }
+
+
+        public int calculateSignal(int signal) {
+                int value;
+
+                switch (signal) {
+                case 200:
+                        value = 0;
+                case 0:
+                        value = 100;
+                default:
+                        value = (int)(100 - ((signal / 200.0) * 100));
+                }
+                return(value);
+        } // calculateSignal
+
+
+        private void appendTextAndScroll(String text) {
+                if (tv != null) {
+                        //              tv.append(text + "\n");
+                        tv.append(text);
+                        final Layout layout = tv.getLayout();
+                        if (layout != null) {
+                                int scrollDelta = layout.getLineBottom(tv.getLineCount() - 1) 
+                                                - tv.getScrollY() - tv.getHeight();
+                                if (scrollDelta > 0)
+                                        tv.scrollBy(0, scrollDelta);
+                        }
+                }
+        } // appendTextAndScroll
+
+
+        public void onProgressChanged(SeekBar seekBar, int progress, boolean fromTouch) {
+                //appendTextAndScroll(progress + " " + 
+                //getString(R.string.seekbar_from_touch) + "=" + fromTouch);
+
+                updatePowerThresholds();
+                updatePower();
+
+        }
+
+
+        public void onStartTrackingTouch(SeekBar seekBar) {
+                //appendTextAndScroll(getString(R.string.seekbar_tracking_on));
+        }
+
+
+        public void onStopTrackingTouch(SeekBar seekBar) {
+                //appendTextAndScroll(getString(R.string.seekbar_tracking_off));
+        }
+
+
+        public void updatePowerThresholds() {
+
+                int power;
+                int attentionSeekValue;
+                int meditationSeekValue;
+                float percentOfMaxPower;
+
+                // Reset all values to zero
+                for (int i = 0; i < thresholdValuesAttention.length; i++) {
+                        thresholdValuesAttention[i] = 0;
+                        thresholdValuesMeditation[i] = 0;
+                }
+
+                attentionSeekValue = seekBarAttention.getProgress();
+                if (attentionSeekValue > 0) {
+                        for (int i = attentionSeekValue; i < thresholdValuesAttention.length; i++) {
+
+                                // Slider @ 70
+                                // Attention @ 70
+                                // Percentage = 0% ((100-70) - (100-70)) / (100-70)
+                                // Power = 60 (minimumPower)
+
+                                // Slider @ 70
+                                // Attention @ 80
+                                // Percentage = 33% ((100-70) - (100-80)) / (100-70)
+                                // Power = 73
+
+                                // Slider @ 70
+                                // Attention @ 90
+                                // Percentage = 66% ((100-70) - (100-90)) / (100-70)
+                                // Power = 86
+
+                                // Slider @ 70
+                                // Attention @ 100
+                                // Percentage = 100% ((100-70) - (100-100)) / (100-70)
+                                // Power = 100
+
+                                percentOfMaxPower = (float)( ((100 - attentionSeekValue) - (100 - i)) / (float)(100 - attentionSeekValue) );
+                                power = thresholdValuesAttention[i] + (int)( minimumPower + ((maximumPower - minimumPower) * percentOfMaxPower) );
+                                thresholdValuesAttention[i] = power;
+
+                                //                              appendTextAndScroll(i + ":" + power + " ");
+                        }
+                }
+
+                meditationSeekValue = seekBarMeditation.getProgress();
+                if (meditationSeekValue > 0) {
+                        for (int i = meditationSeekValue; i < thresholdValuesMeditation.length; i++) {
+                                percentOfMaxPower = (float)( ((100 - meditationSeekValue) - (100 - i)) / (float)(100 - meditationSeekValue) );
+                                power = thresholdValuesMeditation[i] + (int)( minimumPower + ((maximumPower - minimumPower) * percentOfMaxPower) );
+                                thresholdValuesMeditation[i] = power;
+                        }
+                }
+
+        }
+
+
+        public void updatePower() {
+
+                int new_speed = calculateSpeed();
+                String command;
+                progressBarPower.setProgress(new_speed);
+
+                if (new_speed > 0) {
+                        command = "hover";
+                } else {
+                        command = "neutral";
+                }
+
+                appendTextAndScroll("Command: " + command + "\n");
+
+                //              String command = getPowerCommand(new_speed);
+
+                //              writeCommand(command);
+
+                if (mSerialDevice != null) {
+                        serial.setCommand(command);
+                }
+
+        }
+
+
+        public String getPowerCommand(int speed) {
+
+                String command = "%";
+
+                if (speed >= 100)
+                        command = "%100";
+                else if (speed >= 10)
+                        command = "%0" + speed;
+                else if (speed >= 0)
+                        command = "%00" + speed;
+                else
+                        command = "%000";
+
+                appendTextAndScroll("Command for serial device: " + command + "\n");
+
+                return(command);
+
+        }
+
+
+        public void demoMode(View view) {
+
+                String command = "neutral";
+                
+                appendTextAndScroll("Command for serial device: " + command + "\n");
+                serial.setCommand(command);
+
+                try {
+                        Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+
+                command = "hover";
+                appendTextAndScroll("Command for serial device: " + command + "\n");
+                serial.setCommand(command);
+
+                try {
+                        Thread.sleep(2500);
+                } catch (InterruptedException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }               
+
+
+                command = "neutral";
+                appendTextAndScroll("Command for serial device: " + command + "\n");
+                serial.setCommand(command);
+
+
+        } // demoMode
+
+
+        public int calculateSpeed() {
+
+                int attention = progressBarAttention.getProgress();
+                int meditation = progressBarMeditation.getProgress();
+                int attentionSeekValue = seekBarAttention.getProgress();
+                int meditationSeekValue = seekBarMeditation.getProgress();
+
+                int speed = 0;
+
+                if (attention > attentionSeekValue)
+                        speed = thresholdValuesAttention[attention];
+                if (meditation > meditationSeekValue)
+                        speed = speed + thresholdValuesMeditation[meditation];
+
+                if (speed > maximumPower)
+                        speed = maximumPower;
+                if (speed < minimumPower)
+                        speed = 0;
+
+                return(speed);
+
+        }
+
+
+        private void stopIoManager() {
+                if (mSerialIoManager != null) {
+                        //            Log.i(TAG, "Stopping io manager ..");
+                        mSerialIoManager.stop();
+                        mSerialIoManager = null;
+                }
+        }
+
+
+        private void startIoManager() {
+                if (mSerialDevice != null) {
+                        //            Log.i(TAG, "Starting io manager ..");
+                        mSerialIoManager = new SerialInputOutputManager(mSerialDevice, mListener);
+                        mExecutor.submit(mSerialIoManager);
+                }
+        }
+
+
+        private void onDeviceStateChange() {
+                stopIoManager();
+                startIoManager();
+        }
 
 }