Changeset 348

Timestamp:

03/28/12 17:31:44 (8 years ago)

Author:

sc

Message:

• Cython interface to Emotiv initial flight

Location:

trunk/project/PuzzleboxSynapseEmotiv/PuzzleboxSynapseEmotiv

Files:

• hello.pyx (modified) (1 diff)
• setup.py (modified) (1 diff)

trunk/project/PuzzleboxSynapseEmotiv/PuzzleboxSynapseEmotiv/hello.pyx

@@ -1 @@
-#include <string>
 
 cdef extern from "edk.h":
 #       int EE_EngineRemoteConnect(const char* szHost, unsigned short port)
-        int EE_EngineRemoteConnect(char* szHost, unsigned short port)
-#       int EE_EngineRemoteConnect(char* szHost, int port)
-#       int EE_EngineRemoteConnect()
+        ctypedef void* EmoEngineEventHandle
+        ctypedef void* EmoStateHandle
+        
+        #ctypedef enum EE_Event_enum {
+                #EE_UnknownEvent         = 0x0000,
+                #EE_EmulatorError        = 0x0001,
+                #EE_ReservedEvent        = 0x0002,
+                #EE_UserAdded            = 0x0010,
+                #EE_UserRemoved          = 0x0020,
+                #EE_EmoStateUpdated      = 0x0040,
+                #EE_ProfileEvent         = 0x0080,
+                #EE_CognitivEvent        = 0x0100,
+                #EE_ExpressivEvent       = 0x0200,
+                #EE_InternalStateChanged = 0x0400,
+                #EE_AllEvent             = EE_UserAdded | EE_UserRemoved | EE_EmoStateUpdated | EE_ProfileEvent | EE_CognitivEvent | EE_ExpressivEvent | EE_InternalStateChanged
+        #} EE_Event_t;
+        
+        cdef int EE_EngineRemoteConnect(char* szHost, unsigned short port)
+        cdef int EE_EngineGetNextEvent(EmoEngineEventHandle hEvent)
+        cdef EmoEngineEventHandle EE_EmoEngineEventCreate()
+        cdef EmoStateHandle EE_EmoStateCreate()
+        
+        #cdef EE_Event_t EE_EmoEngineEventGetType(EmoEngineEventHandle hEvent)
+        cdef int EE_EmoEngineEventGetUserId(EmoEngineEventHandle hEvent, unsigned int *pUserIdOut)
+        #cdef EE_EmoStateUpdated
+        cdef int EE_EmoEngineEventGetEmoState(EmoEngineEventHandle hEvent, EmoStateHandle hEmoState)
+        
+        cdef float ES_GetTimeFromStart(EmoStateHandle state)
+        cdef int ES_GetWirelessSignalStatus(EmoStateHandle state)
+        cdef int ES_GetHeadsetOn(EmoStateHandle state)
+        
+        cdef float ES_AffectivGetExcitementShortTermScore(EmoStateHandle state)
+        cdef float ES_AffectivGetExcitementLongTermScore(EmoStateHandle state)
+        cdef float ES_AffectivGetMeditationScore(EmoStateHandle state)
+        cdef float ES_AffectivGetFrustrationScore(EmoStateHandle state)
+        cdef float ES_AffectivGetEngagementBoredomScore(EmoStateHandle state)
+
+
+#cdef eEvent = EE_EmoEngineEventCreate()
+#cdef eState = EE_EmoStateCreate()
 
 def say_hello_to(name):
         print("Hello, %s" % name)
 
-#def emotiv():
-        #handle = EE_EngineRemoteConnect("127.0.0.1", 1726)
+HOST = "127.0.0.1"
+PORT = 1726
+
+#def emotiv_connect(host, port):
+def emotiv_connect():
+        handle = EE_EngineRemoteConnect(HOST, PORT)
         #print type(handle)
         #print handle
+        
+        eEvent = EE_EmoEngineEventCreate()
+        eState = EE_EmoStateCreate()
+        
+        
+        while True:
+                result = EE_EngineGetNextEvent(eEvent)
+                
+                #processEmotivState(eEvent, eState)
+                #processEmotivState()
+        
+
+#def processEmotivState():
+        
+                result = EE_EmoEngineEventGetEmoState(eEvent, eState)
+                
+                # Headset Status
+                time_from_start = ES_GetTimeFromStart(eState)
+                wireless_signal_status = (ES_GetWirelessSignalStatus(eState))
+                headset_on = (ES_GetHeadsetOn(eState))
+
+                # Affectiv Suite results
+                excitement = ES_AffectivGetExcitementShortTermScore(eState)
+                excitement_long_term = ES_AffectivGetExcitementLongTermScore(eState)
+                meditation = ES_AffectivGetMeditationScore(eState)
+                frustration = ES_AffectivGetFrustrationScore(eState)
+                engagement_boredom = ES_AffectivGetEngagementBoredomScore(eState)
+
+                packet = {}
+                
+                packet['emotiv_status'] = {}
+                packet['emotiv_status']['time_from_start'] = time_from_start
+                packet['emotiv_status']['headset_on'] = headset_on
+                #packet['emotiv_status']['contact_number_of_quality_channels'] = contact_number_of_quality_channels
+                #packet['emotiv_status']['contact_quality_from_all_channels'] = contact_quality_from_all_channels
+                packet['emotiv_status']['wireless'] = wireless_signal_status
+                #packet['emotiv_status']['battery'] = battery
+                
+                
+                packet['affectiv'] = {}
+                #print dir(excitement)
+                packet['affectiv']['excitement'] = excitement
+                packet['affectiv']['long_term_excitement'] = excitement_long_term
+                packet['affectiv']['meditation'] = meditation
+                packet['affectiv']['frustration'] = frustration
+                packet['affectiv']['engagement_boredom'] = engagement_boredom
+                
+                
+                
+                print
+                print
+                print "INFO [Emotiv]: Packet Received:"
+                for group in packet.keys():
+                        for key in packet[group].keys():
+                                print '[%s][%s]:' % (group, key),
+                                #if type(packet[group][key]):
+                                        #print '%f' % packet[group][key]
+                                #else:
+                                print packet[group][key]
+        
+        
+
+
+#EmoEngineEventHandle eEvent            = EE_EmoEngineEventCreate();
+#EmoStateHandle eState                          = EE_EmoStateCreate();
+#unsigned int userID                                    = 0;
+                        
+        #int state = EE_EngineGetNextEvent(eEvent);
+
+        #// New event needs to be handled
+        #if (state == EDK_OK) {
+
+                #EE_Event_t eventType = EE_EmoEngineEventGetType(eEvent);
+                #EE_EmoEngineEventGetUserId(eEvent, &userID);
+
+                #// Log the EmoState if it has been updated
+                #if (eventType == EE_EmoStateUpdated) {
+
+                        #EE_EmoEngineEventGetEmoState(eEvent, eState);
+
+                        #// Headset Status
+                        #float time_from_start = ES_GetTimeFromStart(eState);
+                        #int wireless_signal_status = static_cast<int>(ES_GetWirelessSignalStatus(eState));
+                        #int headset_on = static_cast<int>(ES_GetHeadsetOn(eState));
+
+                        #// Affectiv Suite results
+                        #float excitement = ES_AffectivGetExcitementShortTermScore(eState);
+                        #float excitement_long_term = ES_AffectivGetExcitementLongTermScore(eState);
+                        #float meditation = ES_AffectivGetMeditationScore(eState);
+                        #float frustration = ES_AffectivGetFrustrationScore(eState);
+                        #float engagement_boredom = ES_AffectivGetEngagementBoredomScore(eState);
+                        
+                        
+                        
+        
+        #self.EmotivEngine = PyEpoc.PyEpoc.EpocHandler()
+        #self.engineeventhandle = self.EmotivEngine.EE_EmoEngineEventCreate()
+        #self.statehandle = self.EmotivEngine.EE_EmoStateCreate()
+        #self.EmotivEngine.ES_Init(self.statehandle)
+
+        
+                #state = self.EmotivEngine.EE_EngineGetNextEvent(self.engineeventhandle)
+                
+                #self.processEmotivState(state)
+
+        #if (state == PyEpoc.PyEpoc.ERRCODE['EDK_OK']):
+                
+                #event = self.EmotivEngine.EE_EmoEngineEventGetType(self.engineeventhandle)
+                #user = self.EmotivEngine.EE_EmoEngineEventGetUserId(self.engineeventhandle)[1]
+                
+                #if (event == PyEpoc.PyEpoc.EVENT['EE_EmoStateUpdated']):
+                        
+                        #self.EmotivEngine.EE_EmoEngineEventGetEmoState(self.engineeventhandle, self.statehandle)
+                        
+                        ## Emotiv Status
+                        #time_from_start = self.EmotivEngine.ES_GetTimeFromStart(self.statehandle)
+                        #headset_on = self.EmotivEngine.ES_GetHeadsetOn(self.statehandle)
+                        #contact_number_of_quality_channels = self.EmotivEngine.ES_GetNumContactQualityChannels(self.statehandle)

trunk/project/PuzzleboxSynapseEmotiv/PuzzleboxSynapseEmotiv/setup.py

@@ -5 +5 @@
 ext_modules = [Extension("hello", \
                         ["hello.pyx"], \
-                        language='c++')]
+                        language='c++', \
+                        libraries=['..\lib\edk'], \
+                        )]
 
 setup(