PSYCHICDOLL

forked:0
favorite:4
lines:292
license : MIT License
modified : 2011-05-27 17:27:25

Embed: Tweet

package
{
    import com.bit101.components.HUISlider;
    import com.bit101.components.TextArea;
    import flash.display.Sprite;
    import flash.events.ErrorEvent;
    import flash.events.Event;
    import funnel.*;
    import funnel.gui.*;
    import funnel.ui.*;
    
    /**
     * PSYCHICDOLL (LEDOLL + MindSet + Gainer)
     * 
     * LEDOLL  http://www.youtube.com/watch?v=q8tBX0x_R7U
     * MindSet http://neurosky.com/
     * Gainer  http://gainer.cc/
     * 
     * @author Yukiya Okuda<alumican.net>
     */
    [SWF(backgroundColor=0xffffff, frameRate=60)]
    public class Main extends Sprite
    {
        //Arduino
        private var _arduino:Arduino;
        private var _attLED:LED;
        private var _medLED:LED;
        
        //MindSet
        private var _mindSet:MindSet;
        
        //Interface
        private var _attentionSlider:HUISlider;
        private var _meditationSlider:HUISlider;
        
        private var _socketLog:TextArea;
        private var _rawEegLog:TextArea;
        private var _signalLog:TextArea;
        private var _eyeBlinkLog:TextArea;
        
        private var _minSlider:HUISlider;
        private var _maxSlider:HUISlider;
        
        private var _minValue:Number = 0.3;
        private var _maxValue:Number = 0.7;
        
        //Constructor
        public function Main():void
        {
            _setupArduino();
            _setupMindSet();
            _setupInterface();
        }
        
        private function _setupArduino():void
        {
            var config:Configuration = Arduino.FIRMATA;
            config.setDigitalPinMode(10, PWM);
            config.setDigitalPinMode(11, PWM);
            _arduino = new Arduino(config);
            _attLED = new LED(_arduino.digitalPin(10));
            _medLED = new LED(_arduino.digitalPin(11));
        }
        
        private function _setupMindSet():void
        {
            _mindSet = new MindSet();
            _mindSet.addEventListener(MindSet.SOCKET_CONNECT, _mindSetSocketConnectHandler);
            _mindSet.addEventListener(MindSet.SOCKET_ERROR, _mindSetSocketErrorHandler);
            _mindSet.addEventListener(MindSet.DATA_SIGNAL, _mindSetDataSignalHandler);
            _mindSet.addEventListener(MindSet.DATA_EEG_RAW, _mindSetDataEegRawHandler);
            _mindSet.addEventListener(MindSet.DATA_EYE_BLINK, _mindSetDataEyeBlinkHandler);
            _mindSet.connect();
        }
        
        private function _setupInterface():void
        {
            //----------------------------------------
            _attentionSlider = new HUISlider(this, 14, 10, "ATTENTION", null);
            _attentionSlider.width = 300;
            
            _meditationSlider = new HUISlider(this, 10, 30, "MEDITATION", null);
            _meditationSlider.width = 300;
            
            _rawEegLog = new TextArea(this);
            _rawEegLog.x      = 10;
            _rawEegLog.y      = 60;
            _rawEegLog.width  = 220;
            _rawEegLog.height = 50;
            
            _eyeBlinkLog = new TextArea(this);
            _eyeBlinkLog.x      = 10;
            _eyeBlinkLog.y      = 130;
            _eyeBlinkLog.width  = 220;
            _eyeBlinkLog.height = 50;
            
            _signalLog = new TextArea(this);
            _signalLog.x      = 10;
            _signalLog.y      = 200;
            _signalLog.width  = 220;
            _signalLog.height = 150;
            
            _minSlider = new HUISlider(this, 300, 10, "MIN", function(e:Event):void
            {
                _minValue = _minSlider.value;
            });
            _minSlider.width -= 30;
            _minSlider.minimum = 0;
            _minSlider.maximum = 1;
            _minSlider.value = 0.3;
            
            _maxSlider = new HUISlider(this, 300, 30, "MAX", function(e:Event):void
            {
                _maxValue = _maxSlider.value;
            });
            _maxSlider.width -= 30;
            _maxSlider.minimum = 0;
            _maxSlider.maximum = 1;
            _maxSlider.value = 0.6;
            
            //----------------------------------------
            _arduino.gui = addChild( new ArduinoGUI() ) as ArduinoGUI;
        }
        
        private function _mindSetSocketConnectHandler(e:Event):void
        {
            trace("connect");
        }
        
        private function _mindSetSocketErrorHandler(e:ErrorEvent):void
        {
            trace("error : ", e.text);
        }
        
        private function _mindSetDataSignalHandler(e:Event):void 
        {
            trace("attention  : ", _mindSet.attention);
            trace("meditation : ", _mindSet.meditation, "\n");
            
            //----------------------------------------
            _attentionSlider.value = 100 * _mindSet.attention;
            _meditationSlider.value = 100 * _mindSet.meditation;
            
            _log("----------SIGNAL----------\n"
                + "Signal Level : " + _mindSet.signalLevel + "\n\n"
                + "Alpha (Low)  : " + _mindSet.lowAlpha + "\n"
                + "Alpha (High) : " + _mindSet.highAlpha + "\n"
                + "Beta (Low)   : " + _mindSet.lowBeta + "\n"
                + "Beta (High)  : " + _mindSet.highBeta + "\n"
                + "Gamma (Low)  : " + _mindSet.lowGamma + "\n"
                + "Gamma (High) : " + _mindSet.highGamma + "\n"
                + "Delta        : " + _mindSet.delta + "\n"
                + "Theta        : " + _mindSet.theta
            , _signalLog);
            
            //----------------------------------------
            
          //  /*
            if (_mindSet.attention > _mindSet.meditation)
            {
                _attLED.intensity = _adjustValue(Math.abs(_mindSet.attention - _mindSet.meditation));
                _medLED.intensity = 0;
            }
            else
            {
                _attLED.intensity = 0;
                _medLED.intensity = _adjustValue(Math.abs(_mindSet.attention - _mindSet.meditation));
            }
          //  */

/*
            _attLED.intensity = _adjustValue(_mindSet.attention);
            _medLED.intensity = _adjustValue(_mindSet.meditation);
            */
        }
        
        private function _adjustValue(value:Number):Number
        {
            return (value <= _minValue) ? 0 : 
                   (value >= _maxValue) ? 1 : ((value - _minValue) / (_maxValue - _minValue));
        }
        
        private function _mindSetDataEegRawHandler(e:Event):void 
        {
            _log("----------RAW EEG----------\n"
                + "Raw Eeg : " + _mindSet.rawEeg
            , _rawEegLog);
        }
        
        private function _mindSetDataEyeBlinkHandler(e:Event):void 
        {
            _log("----------EYE BLINK----------\n"
                + "Blink Strength : " + _mindSet.blinkStrength
            , _eyeBlinkLog);
        }
        
        private function _log(m:*, target:TextArea = null):void
        {
            if (target)
            {
                target.text = String(m);
            }
            else
            {
                trace(String(m));
            }
        }
    }
}

/**
 * MindSet
 * @author Yukiya Okuda<alumican.net>
 */
import com.adobe.serialization.json.JSON;
import com.adobe.serialization.json.JSONParseError;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.net.Socket;

internal class MindSet extends EventDispatcher
{
    //Event
    static public const DATA_SIGNAL:String = "dataSignal";
    static public const DATA_EEG_RAW:String = "dataEegRaw";
    static public const DATA_EYE_BLINK:String = "dataEyeBlink";
    
    static public const SOCKET_CONNECT:String = "socketConnect";
    static public const SOCKET_ERROR:String = "socketError";
    static public const SOCKET_CLOSE:String = "socketClose";
    
    //Sensor Value
    public function get signalLevel():Number { return _signalLevel; }
    private var _signalLevel:Number;
    
    public function get attention():Number { return _attention; }
    private var _attention:Number;
    
    public function get meditation():Number { return _meditation; }
    private var _meditation:Number;
    
    public function get lowAlpha():Number { return _lowAlpha; }
    private var _lowAlpha:Number;
    
    public function get highAlpha():Number { return _highAlpha; }
    private var _highAlpha:Number;
    
    public function get lowBeta():Number { return _lowBeta; }
    private var _lowBeta:Number;
    
    public function get highBeta():Number { return _highBeta; }
    private var _highBeta:Number;
    
    public function get lowGamma():Number { return _lowGamma; }
    private var _lowGamma:Number;
    
    public function get highGamma():Number { return _highGamma; }
    private var _highGamma:Number;
    
    public function get delta():Number { return _delta; }
    private var _delta:Number;
    
    public function get theta():Number { return _theta; }
    private var _theta:Number;
    
    public function get rawEeg():Number { return _rawEeg; }
    private var _rawEeg:Number;
    
    public function get lowRawEeg():Number { return _lowRawEeg; }
    private var _lowRawEeg:Number;
    
    public function get highRawEeg():Number { return _highRawEeg; }
    private var _highRawEeg:Number;
    
    public function get blinkStrength():Number { return _blinkStrength; }
    private var _blinkStrength:Number;
    
    //Connector
    private var _socket:Socket;
    
    public function MindSet():void
    {
        _signalLevel = _attention = _meditation = _lowAlpha = _highAlpha = _lowBeta = _highBeta =
        _lowGamma = _highGamma = _delta = _theta = _rawEeg = _lowRawEeg = _highRawEeg = _blinkStrength = 0;
        
    }
    
    public function connect():void
    {
        close();
        _socket = new Socket();
        _socket.addEventListener(Event.CONNECT, _socketConnectHandler);
        _socket.addEventListener(ProgressEvent.SOCKET_DATA, _socketDataHandler);
        _socket.addEventListener(IOErrorEvent.IO_ERROR, _socketErrorHandler);
        _socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, _socketErrorHandler);
        _socket.addEventListener(Event.CLOSE, _socketCloseHandler);
        _socket.connect("127.0.0.1", 13854);
    }
    
    public function close():void
    {
        if (!_socket) return;
        _socket.removeEventListener(Event.CONNECT, _socketConnectHandler);
        _socket.removeEventListener(ProgressEvent.SOCKET_DATA, _socketDataHandler);
        _socket.removeEventListener(IOErrorEvent.IO_ERROR, _socketErrorHandler);
        _socket.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, _socketErrorHandler);
        _socket.removeEventListener(Event.CLOSE, _socketCloseHandler);
        try
        {
            _socket.close();
        }
        catch (erroe:Error) { }
        _socket = null;
    }
    
    //Socket Handler
    private function _socketConnectHandler(e:Event):void 
    {
        _socket.writeUTFBytes(JSON.encode( { enableRawOutput : true, format : "Json" } ));
        dispatchEvent(new Event(SOCKET_CONNECT));
    }
    
    private function _socketErrorHandler(e:ErrorEvent):void 
    {
        close();
        dispatchEvent(new ErrorEvent(SOCKET_ERROR, false, false, e.text));
    }
    
    private function _socketCloseHandler(e:Event):void 
    {
        close();
        dispatchEvent(new Event(SOCKET_CLOSE));
    }
    
    private function _socketDataHandler(e:ProgressEvent):void 
    {
        var packets:Array = _socket.readUTFBytes(_socket.bytesAvailable).split(/\r/);
        _socket.flush();
        
        for each (var packet:String in packets)
        {
            if (packet == "") continue;
            try
            {
                var data:Object = JSON.decode(packet);
                //----------------------------------------
                if (data["poorSignalLevel"] != null)
                {
                    _signalLevel = 1 - data["poorSignalLevel"] / 200; //[0, 1]
                    if(_signalLevel == 0) {
                        _attention = _meditation = _lowAlpha = _highAlpha = _lowBeta = 
                        _highBeta = _lowGamma = _highGamma = _delta = _theta = 0;
                    }
                    else
                    {
                        _attention = data["eSense"]["attention"] / 100; //[0, 1]
                        _meditation = data["eSense"]["meditation"] / 100; //[0, 1]
                        _lowAlpha = data["eegPower"]["lowAlpha"];
                        _highAlpha = data["eegPower"]["highAlpha"];
                        _lowBeta = data["eegPower"]["lowBeta"];
                        _highBeta = data["eegPower"]["highBeta"];
                        _lowGamma = data["eegPower"]["lowGamma"];
                        _highGamma = data["eegPower"]["highGamma"];
                        _delta = data["eegPower"]["delta"];
                        _theta = data["eegPower"]["theta"];
                    }
                    
                    dispatchEvent(new Event(DATA_SIGNAL));
                }
                //----------------------------------------
                if (data["blinkStrength"] != null)
                {
                    _blinkStrength = data["blinkStrength"];
                    dispatchEvent(new Event(DATA_EYE_BLINK));
                }
                //----------------------------------------
                if (data["rawEeg"] != null)
                {
                    _rawEeg = data["rawEeg"];
                    _lowRawEeg = (int(_rawEeg) >> 8) & 0xff;
                    _highRawEeg = int(_rawEeg) & 0xff;
                    dispatchEvent(new Event(DATA_EEG_RAW));
                }
            }
            catch (error:JSONParseError)
            {
            }                    
        }
    }
}

Code Fullscreen

Preview Fullscreen

Nyarineko

xor

linktale

mousepancyo :

funnel