Changeset 05e2bb8 in orbit for android


Ignore:
Timestamp:
12/11/13 16:41:07 (6 years ago)
Author:
Steve Castellotti <sc@…>
Branches:
master, Servo
Children:
e537bac
Parents:
9769326
Message:
  • updated to use com.example.usb.EmotivDongle? (hard-coded to native library)
Location:
android/src/info/puzzlebox/orbit
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • android/src/info/puzzlebox/orbit/FragmentTabFlightEmotiv.java

    r9769326 r05e2bb8  
    22package info.puzzlebox.orbit; 
    33 
     4import java.util.ArrayList; 
     5 
     6import com.emotiv.bEdk.Edk; 
     7import com.emotiv.bEdk.EdkErrorCode; 
     8import com.emotiv.bEdk.EmoStateDLL; 
     9import com.emotiv.bEdk.Edk.EE_CognitivEvent_t; 
     10import com.emotiv.bEdk.Edk.EE_CognitivTrainingControl_t; 
     11import com.emotiv.bEdk.Edk.EE_Event_t; 
     12import com.emotiv.bEdk.EmoStateDLL.EE_CognitivAction_t; 
     13//import com.emotiv.usb.EmotivDongle; 
     14import com.example.usb.EmotivDongle; 
     15 
    416import info.puzzlebox.orbit.OrbitTabActivity; 
    517 
     18import android.app.AlertDialog; 
     19import android.content.DialogInterface; 
    620import android.content.res.Configuration; 
    721import android.graphics.Color; 
     
    1024import android.graphics.drawable.shapes.RoundRectShape; 
    1125import android.os.Bundle; 
     26import android.os.Environment; 
     27import android.os.Handler; 
    1228import android.os.Message; 
    1329import android.util.Log; 
     
    1733import android.view.View.OnClickListener; 
    1834import android.view.ViewGroup; 
     35import android.widget.AdapterView; 
     36import android.widget.ArrayAdapter; 
    1937import android.widget.Button; 
    2038import android.widget.ImageView; 
     
    2240import android.widget.ProgressBar; 
    2341import android.widget.SeekBar; 
     42import android.widget.Spinner; 
     43import android.widget.TextView; 
     44import android.widget.Toast; 
    2445 
    2546//import android.app.Fragment; 
     
    5475        boolean eegConnecting = false; 
    5576        boolean demoFlightMode = false; 
    56 //      Number[] rawEEG = new Number[512]; 
     77        //      Number[] rawEEG = new Number[512]; 
    5778        int arrayIndex = 0; 
    5879 
     
    7293        ImageView imageViewStatus; 
    7394 
     95        private Spinner spinnerAction; 
     96        private Button startTraining; 
     97        private TextView DetectionStatus, CurrentAction, text; 
     98 
    7499        int[] thresholdValuesCognitiv = new int[101]; 
    75100        int minimumPower = 0; // minimum power for the helicopter throttle 
     
    98123        String TAG = "FragmentFlight"; 
    99124 
     125 
     126        /** 
     127         * Emotiv 
     128         */ 
     129        /** 
     130         * Emotiv EPOC Device 
     131         */ 
     132        private EE_CognitivAction_t _cognitivAction; 
     133        private int _currentAction; 
     134        private float _currentPower; 
     135 
     136        private static final int userid = 1; 
     137        private boolean _running = false; 
     138 
     139        private String[] ListAction = new String[] { "NEUTRAL", "PUSH", "PULL", 
     140                        "LIFT", "DROP" }; 
     141 
     142        public static int[] cognitivActionList = { 
     143                EE_CognitivAction_t.COG_NEUTRAL.ToInt(), 
     144                EE_CognitivAction_t.COG_PUSH.ToInt(), 
     145                EE_CognitivAction_t.COG_PULL.ToInt(), 
     146                EE_CognitivAction_t.COG_LIFT.ToInt(), 
     147                EE_CognitivAction_t.COG_DROP.ToInt(), 
     148                EE_CognitivAction_t.COG_LEFT.ToInt(), 
     149                EE_CognitivAction_t.COG_RIGHT.ToInt(), 
     150                EE_CognitivAction_t.COG_ROTATE_LEFT.ToInt(), 
     151                EE_CognitivAction_t.COG_ROTATE_RIGHT.ToInt(), 
     152                EE_CognitivAction_t.COG_ROTATE_CLOCKWISE.ToInt(), 
     153                EE_CognitivAction_t.COG_ROTATE_COUNTER_CLOCKWISE.ToInt(), 
     154                EE_CognitivAction_t.COG_ROTATE_FORWARDS.ToInt(), 
     155                EE_CognitivAction_t.COG_ROTATE_REVERSE.ToInt(), 
     156                EE_CognitivAction_t.COG_DISAPPEAR.ToInt() }; 
     157        public Boolean[] cognitivActionsEnabled = new Boolean[cognitivActionList.length]; 
    100158 
    101159        OnClickListener Flight_enterOnClickListener 
     
    177235 
    178236                /** 
     237                 * Emotiv 
     238                 */ 
     239                spinnerAction = (Spinner) v.findViewById(R.id.spinnerAction); 
     240                startTraining = (Button) v.findViewById(R.id.buttonStartTraining); 
     241                DetectionStatus = (TextView) v.findViewById(R.id.DetectionStatus); 
     242                CurrentAction = (TextView) v.findViewById(R.id.CurrentAction); 
     243                text = (TextView) v.findViewById(R.id.text); 
     244 
     245                text.setText(""); 
     246                text.setSingleLine(false); 
     247 
     248 
     249 
     250 
     251 
     252                 
     253 
     254 
     255//              EmotivDongle.init(this); 
     256                EmotivDongle.init(((OrbitTabActivity)getActivity())); 
     257                 
     258                String _profileLocation= Environment.getExternalStorageDirectory().getAbsolutePath() 
     259                                + "/EmoProFile/"; 
     260                Edk.EmoEngineConnect(_profileLocation); 
     261 
     262 
     263                cognitivActionsEnabled[0] = true; 
     264                for (int i = 1; i < cognitivActionList.length; i++) { 
     265                        cognitivActionsEnabled[i] = false; 
     266                } 
     267 
     268 
     269                final ArrayList<String> list = new ArrayList<String>(); 
     270                for (int i = 0; i < ListAction.length; ++i) { 
     271                        list.add(ListAction[i]); 
     272                } 
     273 
     274//              ArrayAdapter<String> SpinnerAdapter = new ArrayAdapter<String>(this, 
     275//                              android.R.layout.simple_spinner_item, list); 
     276                ArrayAdapter<String> SpinnerAdapter = new ArrayAdapter<String>(((OrbitTabActivity)getActivity()), 
     277                                android.R.layout.simple_spinner_item, list); 
     278                SpinnerAdapter 
     279                .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); 
     280 
     281                spinnerAction.setAdapter(SpinnerAdapter); 
     282 
     283                spinnerAction 
     284                .setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { 
     285 
     286                        public void onItemSelected(AdapterView<?> arg0, View arg1, 
     287                                        int arg2, long arg3) { 
     288 
     289                                String action = arg0.getItemAtPosition(arg2).toString(); 
     290                                if (action.equals("NEUTRAL")) { 
     291                                        _cognitivAction = EE_CognitivAction_t.COG_NEUTRAL; 
     292 
     293                                } else if (action.equals("PUSH")) { 
     294 
     295                                        _cognitivAction = EE_CognitivAction_t.COG_PUSH; 
     296 
     297                                } else if (action.equals("PULL")) { 
     298 
     299                                        _cognitivAction = EE_CognitivAction_t.COG_PULL; 
     300 
     301                                } else if (action.equals("LIFT")) { 
     302 
     303                                        _cognitivAction = EE_CognitivAction_t.COG_LIFT; 
     304 
     305                                } else if (action.equals("DROP")) { 
     306 
     307                                        _cognitivAction = EE_CognitivAction_t.COG_DROP; 
     308 
     309                                } 
     310 
     311                        } 
     312 
     313                        public void onNothingSelected(AdapterView<?> arg0) { 
     314                                // TODO Auto-generated method stub 
     315 
     316                        } 
     317                }); 
     318 
     319                startTraining.setOnClickListener(new View.OnClickListener() { 
     320 
     321                        public void onClick(View v) { 
     322                                // TODO Auto-generated method stub 
     323                                if (startTraining.getText().equals("Start Training")) { 
     324 
     325                                        if (_cognitivAction == EE_CognitivAction_t.COG_NEUTRAL) { 
     326                                                StartTrainingCognitiv(_cognitivAction); 
     327                                        } else { 
     328                                                EnableCognitivAction(_cognitivAction, true); 
     329                                                EnableCognitivActionsList(); 
     330                                                StartTrainingCognitiv(_cognitivAction); 
     331                                        } 
     332 
     333                                } else { 
     334                                        if (Edk.EECognitivSetTrainingControl(userid, 
     335                                                        EE_CognitivTrainingControl_t.COG_RESET.getType()) == EdkErrorCode.EDK_OK 
     336                                                        .ToInt()) { 
     337                                                startTraining.setText("Start Training"); 
     338 
     339                                        } else 
     340                                                //                                              Toast.makeText( 
     341                                                //                                                              MainActivity.this, 
     342                                                //                                                              "Fail to start training. Algorithm is deactivated due to optimization.", 
     343                                                //                                                              Toast.LENGTH_SHORT).show(); 
     344                                                Log.v(TAG, "Fail to start training. Algorithm is deactivated due to optimization."); 
     345                                } 
     346 
     347                        } 
     348                }); 
     349 
     350                Thread processingThread=new Thread() 
     351                { 
     352                        @Override 
     353                        public void run() { 
     354                                // TODO Auto-generated method stub 
     355                                super.run(); 
     356                                while(true) 
     357                                { 
     358                                        try 
     359                                        { 
     360                                                handler.sendEmptyMessage(0); 
     361                                                Thread.sleep(40); 
     362                                        } 
     363 
     364                                        catch (Exception ex) 
     365                                        { 
     366                                                ex.printStackTrace(); 
     367                                        } 
     368                                } 
     369                        } 
     370                };               
     371                processingThread.start(); 
     372 
     373 
     374                /** 
    179375                 * Update settings according to default UI 
    180376                 */ 
     
    189385 
    190386 
     387        } // onCreateView 
     388 
     389 
     390        // ################################################################ 
     391 
     392        Handler handler = new Handler() { 
     393                public void handleMessage(Message msg) { 
     394                        switch (msg.what) { 
     395 
     396                        case 0: 
     397 
     398                                long[] result = Edk.EECognitivGetTrainedSignatureActions(1); 
     399 
     400                                if (result[0] == 0) { 
     401                                        long _currentTrainedActions = result[1]; 
     402                                        long y = _currentTrainedActions 
     403                                                        & (long) EE_CognitivAction_t.COG_NEUTRAL.ToInt(); 
     404                                        if (y == 1) { 
     405                                                DetectionStatus.setText("Active"); 
     406                                                DetectionStatus.setTextColor(Color.BLUE); 
     407                                        } else { 
     408                                                DetectionStatus.setText("Not Active"); 
     409                                                DetectionStatus.setTextColor(Color.RED); 
     410                                        } 
     411                                } 
     412 
     413                                int state = Edk.EEEngineGetNextEvent(); 
     414                                if (state == EdkErrorCode.EDK_OK.ToInt()) { 
     415                                        int eventType = Edk.EEEmoEngineEventGetType(); 
     416                                        if (eventType == EE_Event_t.EE_EmoStateUpdated.ToInt()) { 
     417 
     418                                                _currentAction = EmoStateDLL 
     419                                                                .ESCognitivGetCurrentAction(); 
     420                                                _currentPower = EmoStateDLL.ESCognitivGetCurrentActionPower(); 
     421 
     422                                                if (_currentAction == EE_CognitivAction_t.COG_NEUTRAL 
     423                                                                .ToInt()) { 
     424                                                        CurrentAction.setText("Neutral"); 
     425                                                        CurrentAction.setTextColor(Color.GREEN); 
     426                                                } else if (_currentAction == EE_CognitivAction_t.COG_PUSH 
     427                                                                .ToInt()) { 
     428                                                        CurrentAction.setText("Push"); 
     429                                                        CurrentAction.setTextColor(Color.BLUE); 
     430                                                        // 
     431                                                } 
     432 
     433                                                else if (_currentAction == EE_CognitivAction_t.COG_PULL 
     434                                                                .ToInt()) { 
     435                                                        CurrentAction.setText("Pull"); 
     436                                                        CurrentAction.setTextColor(Color.BLUE); 
     437                                                } 
     438 
     439                                                else if (_currentAction == EE_CognitivAction_t.COG_LIFT 
     440                                                                .ToInt()) { 
     441 
     442                                                        CurrentAction.setText("Lift"); 
     443                                                        CurrentAction.setTextColor(Color.BLUE); 
     444                                                } else if (_currentAction == EE_CognitivAction_t.COG_DROP 
     445                                                                .ToInt()) { 
     446                                                        CurrentAction.setText("Drop"); 
     447                                                        CurrentAction.setTextColor(Color.BLUE); 
     448                                                } 
     449 
     450                                                if(_currentPower!=0) 
     451                                                { 
     452                                                        text.append("Action : " + CurrentAction.getText().toString() + " ; Power : "  +String.valueOf(_currentPower) + "\n"); 
     453                                                } 
     454                                        } else if (eventType == EE_Event_t.EE_CognitivEvent.ToInt()) { 
     455                                                int cogType = Edk.EECognitivEventGetType(); 
     456 
     457                                                if (cogType == EE_CognitivEvent_t.EE_CognitivTrainingStarted 
     458                                                                .getType()) { 
     459 
     460                                                        //                                              Toast.makeText(MainActivity.this, "Start Training", 
     461                                                        //                                                              Toast.LENGTH_SHORT).show(); 
     462                                                        Log.v(TAG, "Start Training"); 
     463 
     464 
     465                                                } 
     466                                                if (cogType == EE_CognitivEvent_t.EE_CognitivTrainingCompleted 
     467                                                                .getType()) { 
     468                                                        //                                              Toast.makeText(MainActivity.this, "Training Completed", 
     469                                                        //                                                              Toast.LENGTH_SHORT).show(); 
     470                                                        Log.v(TAG, "Training Completed"); 
     471 
     472                                                } 
     473                                                if (cogType == EE_CognitivEvent_t.EE_CognitivTrainingSucceeded 
     474                                                                .getType()) { 
     475 
     476                                                        startTraining.setText("Start Training"); 
     477 
     478                                                        //                                              Toast.makeText(MainActivity.this, "Training Succeeded", 
     479                                                        //                                                              Toast.LENGTH_SHORT).show(); 
     480                                                        Log.v(TAG, "Training Succeeded"); 
     481 
     482                                                         
     483//                                                      AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder( 
     484//                                                                      MainActivity.this); 
     485                                                        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder( 
     486                                                                        ((OrbitTabActivity)getActivity())); 
     487                                                        // set title 
     488                                                        alertDialogBuilder.setTitle("Training Completed"); 
     489 
     490                                                        // set dialog message 
     491                                                        alertDialogBuilder 
     492                                                        .setMessage( 
     493                                                                        "Training is completed.Accept this training") 
     494                                                                        .setCancelable(false) 
     495                                                                        .setIcon(R.drawable.ic_launcher) 
     496                                                                        .setPositiveButton( 
     497                                                                                        "Yes", 
     498                                                                                        new DialogInterface.OnClickListener() { 
     499 
     500                                                                                                public void onClick( 
     501                                                                                                                DialogInterface dialog, 
     502                                                                                                                int which) { 
     503 
     504                                                                                                        if (Edk.EECognitivSetTrainingControl( 
     505                                                                                                                        userid, 
     506                                                                                                                        EE_CognitivTrainingControl_t.COG_ACCEPT 
     507                                                                                                                        .getType()) == EdkErrorCode.EDK_OK 
     508                                                                                                                        .ToInt()) { 
     509 
     510                                                                                                                //                                                                                                              Toast.makeText( 
     511                                                                                                                //                                                                                                                              MainActivity.this, 
     512                                                                                                                //                                                                                                                              "accept ok", 
     513                                                                                                                //                                                                                                                              Toast.LENGTH_SHORT) 
     514                                                                                                                //                                                                                                                              .show(); 
     515                                                                                                                Log.v(TAG, "accept ok"); 
     516 
     517                                                                                                        } else 
     518                                                                                                                //                                                                                                              Toast.makeText( 
     519                                                                                                                //                                                                                                                              MainActivity.this, 
     520                                                                                                                //                                                                                                                              "accept error", 
     521                                                                                                                //                                                                                                                              Toast.LENGTH_SHORT) 
     522                                                                                                                //                                                                                                                              .show(); 
     523                                                                                                                Log.v(TAG, "accept error"); 
     524                                                                                                } 
     525                                                                                        }) 
     526                                                                                        .setNegativeButton( 
     527                                                                                                        "No", 
     528                                                                                                        new DialogInterface.OnClickListener() { 
     529                                                                                                                public void onClick( 
     530                                                                                                                                DialogInterface dialog, 
     531                                                                                                                                int id) { 
     532 
     533                                                                                                                        if (Edk.EECognitivSetTrainingControl( 
     534                                                                                                                                        userid, 
     535                                                                                                                                        EE_CognitivTrainingControl_t.COG_REJECT 
     536                                                                                                                                        .getType()) == EdkErrorCode.EDK_OK 
     537                                                                                                                                        .ToInt()) { 
     538 
     539                                                                                                                                //                                                                                                                              Toast.makeText( 
     540                                                                                                                                //                                                                                                                                              MainActivity.this, 
     541                                                                                                                                //                                                                                                                                              "reject ok", 
     542                                                                                                                                //                                                                                                                                              Toast.LENGTH_SHORT) 
     543                                                                                                                                //                                                                                                                                              .show(); 
     544                                                                                                                                Log.v(TAG, "reject ok"); 
     545 
     546                                                                                                                        } else 
     547                                                                                                                                //                                                                                                                              Toast.makeText( 
     548                                                                                                                                //                                                                                                                                              MainActivity.this, 
     549                                                                                                                                //                                                                                                                                              "reject error", 
     550                                                                                                                                //                                                                                                                                              Toast.LENGTH_SHORT) 
     551                                                                                                                                //                                                                                                                                              .show(); 
     552                                                                                                                                Log.v(TAG, "reject error"); 
     553 
     554                                                                                                                } 
     555                                                                                                        }); 
     556 
     557                                                        AlertDialog alertDialog = alertDialogBuilder 
     558                                                                        .create(); 
     559                                                        alertDialog.show(); 
     560 
     561                                                } 
     562                                                if (cogType == Edk.EE_CognitivEvent_t.EE_CognitivTrainingFailed 
     563                                                                .getType()) { 
     564                                                        //                                                      Toast.makeText(MainActivity.this, "Training Failed", 
     565                                                        //                                                                      Toast.LENGTH_SHORT).show(); 
     566                                                        Log.v(TAG, "Training Failed"); 
     567                                                } 
     568                                                if (cogType == Edk.EE_CognitivEvent_t.EE_CognitivTrainingRejected 
     569                                                                .getType()) { 
     570                                                        //                                                      Toast.makeText(MainActivity.this, "Training Rejected", 
     571                                                        //                                                                      Toast.LENGTH_SHORT).show(); 
     572                                                        Log.v(TAG, "Training Rejected"); 
     573                                                } 
     574                                        } 
     575 
     576                                } 
     577 
     578                                break;                   
     579                        } 
     580                } 
     581        }; 
     582 
     583 
     584        public void EnableCognitivAction(EE_CognitivAction_t cognitivAction, 
     585                        Boolean iBool) { 
     586                for (int i = 1; i < cognitivActionList.length; i++) { 
     587                        if (cognitivAction.ToInt() == cognitivActionList[i]) { 
     588                                cognitivActionsEnabled[i] = iBool; 
     589 
     590                        } 
     591                } 
     592 
    191593        } 
     594 
     595        public void EnableCognitivActionsList() { 
     596                long cognitivActions = 0x0000; 
     597                for (int i = 1; i < cognitivActionList.length; i++) { 
     598                        if (cognitivActionsEnabled[i]) { 
     599                                cognitivActions = cognitivActions 
     600                                                | ((long) cognitivActionList[i]); 
     601 
     602                        } 
     603                } 
     604                Edk.EECognitivSetActiveActions(userid, cognitivActions); 
     605 
     606        } 
     607 
     608        public void StartTrainingCognitiv(EE_CognitivAction_t cognitivAction) { 
     609 
     610                if (cognitivAction == EE_CognitivAction_t.COG_NEUTRAL) { 
     611                        if (Edk.EECognitivSetTrainingAction(userid, cognitivAction.ToInt()) == EdkErrorCode.EDK_OK 
     612                                        .ToInt()) { 
     613                                if (Edk.EECognitivSetTrainingControl(userid, 
     614                                                EE_CognitivTrainingControl_t.COG_START.getType()) == EdkErrorCode.EDK_OK 
     615                                                .ToInt()) { 
     616                                        startTraining.setText("Abort Training"); 
     617                                } else 
     618                                        //                                      Toast.makeText( 
     619                                        //                                                      MainActivity.this, 
     620                                        //                                                      "Fail to start training. Algorithm is deactivated due to optimization.", 
     621                                        //                                                      Toast.LENGTH_SHORT).show(); 
     622                                        Log.v(TAG, "Fail to start training. Algorithm is deactivated due to optimization."); 
     623 
     624                        } else 
     625                                //                              Toast.makeText( 
     626                                //                                              MainActivity.this, 
     627                                //                                              "Fail to start training. Algorithm is deactivated due to optimization.", 
     628                                //                                              Toast.LENGTH_SHORT).show(); 
     629                                Log.v(TAG, "Fail to start training. Algorithm is deactivated due to optimization."); 
     630                } else 
     631                        for (int i = 1; i < cognitivActionList.length; i++) { 
     632                                if (cognitivAction.ToInt() == cognitivActionList[i]) { 
     633 
     634                                        if (cognitivActionsEnabled[i]) { 
     635 
     636                                                if (Edk.EECognitivSetTrainingAction(userid, 
     637                                                                cognitivAction.ToInt()) == EdkErrorCode.EDK_OK 
     638                                                                .ToInt()) { 
     639                                                        if (Edk.EECognitivSetTrainingControl(userid, 
     640                                                                        EE_CognitivTrainingControl_t.COG_START 
     641                                                                        .getType()) == EdkErrorCode.EDK_OK 
     642                                                                        .ToInt()) { 
     643                                                                startTraining.setText("Abort Training"); 
     644                                                                //                                                              Toast.makeText(MainActivity.this, 
     645                                                                //                                                                              "Start Training", Toast.LENGTH_SHORT) 
     646                                                                //                                                                              .show(); 
     647                                                                Log.v(TAG, "Start Training"); 
     648 
     649                                                        } else 
     650                                                                //                                                              Toast.makeText( 
     651                                                                //                                                                              MainActivity.this, 
     652                                                                //                                                                              "Fail to start training. Algorithm is deactivated due to optimization.", 
     653                                                                //                                                                              Toast.LENGTH_SHORT).show(); 
     654                                                                Log.v(TAG, "Fail to start training. Algorithm is deactivated due to optimization."); 
     655 
     656                                                } else 
     657                                                        //                                                      Toast.makeText( 
     658                                                        //                                                                      MainActivity.this, 
     659                                                        //                                                                      "Fail to start training. Algorithm is deactivated due to optimization.", 
     660                                                        //                                                                      Toast.LENGTH_SHORT).show(); 
     661                                                        Log.v(TAG, "Fail to start training. Algorithm is deactivated due to optimization."); 
     662                                        } 
     663 
     664                                } 
     665                        } 
     666 
     667        } 
     668 
     669        @Override 
     670        public void onStart() { 
     671                super.onStart();             
     672        } 
     673        @Override 
     674        public void onStop() { 
     675                super.onStop();   
     676                Edk.EngineDisconnect(); 
     677        } 
     678 
    192679 
    193680 
     
    381868        public void parseEEG(Message msg) { 
    382869 
    383 //              switch (msg.what) { 
    384 // 
    385 //              case TGDevice.MSG_STATE_CHANGE: 
    386 // 
    387 //                      switch (msg.arg1) { 
    388 //                      case TGDevice.STATE_IDLE: 
    389 //                              break; 
    390 //                      case TGDevice.STATE_CONNECTING: 
    391 //                              eegConnecting = true; 
    392 //                              eegConnected = false; 
    393 //                              updateStatusImage(); 
    394 //                              break; 
    395 //                      case TGDevice.STATE_CONNECTED: 
    396 //                              setButtonText(R.id.buttonConnect, "Disconnect"); 
    397 //                              eegConnecting = false; 
    398 //                              eegConnected = true; 
    399 //                              updateStatusImage(); 
    400 //                              break; 
    401 //                      case TGDevice.STATE_NOT_FOUND: 
    402 //                              eegConnecting = false; 
    403 //                              eegConnected = false; 
    404 //                              updateStatusImage(); 
    405 //                              break; 
    406 //                      case TGDevice.STATE_NOT_PAIRED: 
    407 //                              eegConnecting = false; 
    408 //                              eegConnected = false; 
    409 //                              updateStatusImage(); 
    410 //                              break; 
    411 //                      case TGDevice.STATE_DISCONNECTED: 
    412 //                              eegConnecting = false; 
    413 //                              eegConnected = false; 
    414 //                              updateStatusImage(); 
    415 //                              break; 
    416 //                      } 
    417 // 
    418 //                      break; 
    419 // 
    420 //              case TGDevice.MSG_POOR_SIGNAL: 
    421 //                      eegSignal = calculateSignal(msg.arg1); 
    422 //                      //                              appendDebugConsole("\nPoorSignal: " + msg.arg1 + "\n"); 
    423 //                      progressBarSignal.setProgress(eegSignal); 
    424 //                      updateStatusImage(); 
    425 //                      break; 
    426 //              case TGDevice.MSG_RAW_DATA: 
    427 // 
    428 //                      //                      rawEEG[arrayIndex] = msg.arg1; 
    429 //                      //                      arrayIndex = arrayIndex + 1; 
    430 // 
    431 //                      //                      if (arrayIndex == EEG_RAW_HISTORY_SIZE - 1) 
    432 //                      //                              updateEEGRawHistory(); 
    433 // 
    434 //                      break; 
    435 //              case TGDevice.MSG_HEART_RATE: 
    436 //                      //                              appendDebugConsole("Heart rate: " + msg.arg1 + "\n"); 
    437 //                      break; 
    438 //              case TGDevice.MSG_ATTENTION: 
    439 //                      //                      eegAttention = msg.arg1; 
    440 //                      //                      //                              appendDebugConsole("Attention: " + eegAttention + "\n"); 
    441 //                      //                      progressBarAttention.setProgress(eegAttention); 
    442 //                      //                      updatePower(); 
    443 // 
    444 //                      break; 
    445 //              case TGDevice.MSG_MEDITATION: 
    446 //                      //                      eegMeditation = msg.arg1; 
    447 //                      //                      if (DEBUG) 
    448 //                      //                              Log.v(TAG, "Meditation: " + eegMeditation); 
    449 //                      //                      //                              appendDebugConsole("Meditation: " + eegMeditation + "\n"); 
    450 //                      //                      progressBarMeditation.setProgress(eegMeditation); 
    451 //                      //                      updatePower(); 
    452 // 
    453 //                      break; 
    454 //              case TGDevice.MSG_BLINK: 
    455 //                      //tv.append("Blink: " + msg.arg1 + "\n"); 
    456 //                      break; 
    457 //              case TGDevice.MSG_RAW_COUNT: 
    458 //                      //tv.append("Raw Count: " + msg.arg1 + "\n"); 
    459 //                      break; 
    460 //              case TGDevice.MSG_LOW_BATTERY: 
    461 //                      //                              Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show(); 
    462 //                      break; 
    463 //              case TGDevice.MSG_RAW_MULTI: 
    464 //                      //TGRawMulti rawM = (TGRawMulti)msg.obj; 
    465 //                      //tv.append("Raw1: " + rawM.ch1 + "\nRaw2: " + rawM.ch2); 
    466 //              default: 
    467 //                      break; 
    468 //              } 
     870                //              switch (msg.what) { 
     871                // 
     872                //              case TGDevice.MSG_STATE_CHANGE: 
     873                // 
     874                //                      switch (msg.arg1) { 
     875                //                      case TGDevice.STATE_IDLE: 
     876                //                              break; 
     877                //                      case TGDevice.STATE_CONNECTING: 
     878                //                              eegConnecting = true; 
     879                //                              eegConnected = false; 
     880                //                              updateStatusImage(); 
     881                //                              break; 
     882                //                      case TGDevice.STATE_CONNECTED: 
     883                //                              setButtonText(R.id.buttonConnect, "Disconnect"); 
     884                //                              eegConnecting = false; 
     885                //                              eegConnected = true; 
     886                //                              updateStatusImage(); 
     887                //                              break; 
     888                //                      case TGDevice.STATE_NOT_FOUND: 
     889                //                              eegConnecting = false; 
     890                //                              eegConnected = false; 
     891                //                              updateStatusImage(); 
     892                //                              break; 
     893                //                      case TGDevice.STATE_NOT_PAIRED: 
     894                //                              eegConnecting = false; 
     895                //                              eegConnected = false; 
     896                //                              updateStatusImage(); 
     897                //                              break; 
     898                //                      case TGDevice.STATE_DISCONNECTED: 
     899                //                              eegConnecting = false; 
     900                //                              eegConnected = false; 
     901                //                              updateStatusImage(); 
     902                //                              break; 
     903                //                      } 
     904                // 
     905                //                      break; 
     906                // 
     907                //              case TGDevice.MSG_POOR_SIGNAL: 
     908                //                      eegSignal = calculateSignal(msg.arg1); 
     909                //                      //                              appendDebugConsole("\nPoorSignal: " + msg.arg1 + "\n"); 
     910                //                      progressBarSignal.setProgress(eegSignal); 
     911                //                      updateStatusImage(); 
     912                //                      break; 
     913                //              case TGDevice.MSG_RAW_DATA: 
     914                // 
     915                //                      //                      rawEEG[arrayIndex] = msg.arg1; 
     916                //                      //                      arrayIndex = arrayIndex + 1; 
     917                // 
     918                //                      //                      if (arrayIndex == EEG_RAW_HISTORY_SIZE - 1) 
     919                //                      //                              updateEEGRawHistory(); 
     920                // 
     921                //                      break; 
     922                //              case TGDevice.MSG_HEART_RATE: 
     923                //                      //                              appendDebugConsole("Heart rate: " + msg.arg1 + "\n"); 
     924                //                      break; 
     925                //              case TGDevice.MSG_ATTENTION: 
     926                //                      //                      eegAttention = msg.arg1; 
     927                //                      //                      //                              appendDebugConsole("Attention: " + eegAttention + "\n"); 
     928                //                      //                      progressBarAttention.setProgress(eegAttention); 
     929                //                      //                      updatePower(); 
     930                // 
     931                //                      break; 
     932                //              case TGDevice.MSG_MEDITATION: 
     933                //                      //                      eegMeditation = msg.arg1; 
     934                //                      //                      if (DEBUG) 
     935                //                      //                              Log.v(TAG, "Meditation: " + eegMeditation); 
     936                //                      //                      //                              appendDebugConsole("Meditation: " + eegMeditation + "\n"); 
     937                //                      //                      progressBarMeditation.setProgress(eegMeditation); 
     938                //                      //                      updatePower(); 
     939                // 
     940                //                      break; 
     941                //              case TGDevice.MSG_BLINK: 
     942                //                      //tv.append("Blink: " + msg.arg1 + "\n"); 
     943                //                      break; 
     944                //              case TGDevice.MSG_RAW_COUNT: 
     945                //                      //tv.append("Raw Count: " + msg.arg1 + "\n"); 
     946                //                      break; 
     947                //              case TGDevice.MSG_LOW_BATTERY: 
     948                //                      //                              Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show(); 
     949                //                      break; 
     950                //              case TGDevice.MSG_RAW_MULTI: 
     951                //                      //TGRawMulti rawM = (TGRawMulti)msg.obj; 
     952                //                      //tv.append("Raw1: " + rawM.ch1 + "\nRaw2: " + rawM.ch2); 
     953                //              default: 
     954                //                      break; 
     955                //              } 
    469956 
    470957        } // handleMessage 
  • android/src/info/puzzlebox/orbit/OrbitTabActivity.java

    r490c673 r05e2bb8  
    6060import com.neurosky.thinkgear.TGDevice; 
    6161 
     62//import com.emotiv.usb.EmotivDongle; 
     63import com.example.usb.EmotivDongle; 
    6264 
    6365public class OrbitTabActivity extends FragmentActivity implements SeekBar.OnSeekBarChangeListener { 
     
    161163        final boolean rawEnabled = true; 
    162164 
     165         
     166//      /** 
     167//       * Emotiv EPOC Device 
     168//       */ 
     169//      private EE_CognitivAction_t _cognitivAction; 
     170//      private int _currentAction; 
     171//      private float _currentPower; 
     172// 
     173//      private static final int userid = 1; 
     174//      private boolean _running = false; 
     175// 
     176//      private String[] ListAction = new String[] { "NEUTRAL", "PUSH", "PULL", 
     177//                      "LIFT", "DROP" }; 
     178// 
     179//      public static int[] cognitivActionList = { 
     180//                      EE_CognitivAction_t.COG_NEUTRAL.ToInt(), 
     181//                      EE_CognitivAction_t.COG_PUSH.ToInt(), 
     182//                      EE_CognitivAction_t.COG_PULL.ToInt(), 
     183//                      EE_CognitivAction_t.COG_LIFT.ToInt(), 
     184//                      EE_CognitivAction_t.COG_DROP.ToInt(), 
     185//                      EE_CognitivAction_t.COG_LEFT.ToInt(), 
     186//                      EE_CognitivAction_t.COG_RIGHT.ToInt(), 
     187//                      EE_CognitivAction_t.COG_ROTATE_LEFT.ToInt(), 
     188//                      EE_CognitivAction_t.COG_ROTATE_RIGHT.ToInt(), 
     189//                      EE_CognitivAction_t.COG_ROTATE_CLOCKWISE.ToInt(), 
     190//                      EE_CognitivAction_t.COG_ROTATE_COUNTER_CLOCKWISE.ToInt(), 
     191//                      EE_CognitivAction_t.COG_ROTATE_FORWARDS.ToInt(), 
     192//                      EE_CognitivAction_t.COG_ROTATE_REVERSE.ToInt(), 
     193//                      EE_CognitivAction_t.COG_DISAPPEAR.ToInt() }; 
     194//      public Boolean[] cognitivActionsEnabled = new Boolean[cognitivActionList.length]; 
    163195 
    164196        public void initializeSingleScreen() { 
     
    185217 
    186218                super.onCreate(savedInstanceState); 
     219                 
     220//              EmotivDongle.init(this); 
    187221 
    188222                // If necessary support isn't detect, replace current activity with the single-screen version 
Note: See TracChangeset for help on using the changeset viewer.