Changeset 411

Timestamp:

01/27/16 01:10:35 (5 years ago)

Author:

sc

Message:

• exportTrainingDataToCSV() added
• collectProcessedData() added
• Training debug output added to Protocol

Location:

trunk/Puzzlebox/Synapse

Files:

• Session.py (modified) (3 diffs)
• ThinkGear/Protocol.py (modified) (10 diffs)

trunk/Puzzlebox/Synapse/Session.py

@@ -7 +7 @@
 
 __changelog__ = """\
-Last Update: 2014.02.23
+Last Update: 2016.01.26
 """
 
@@ -446 +446 @@
         
         
+                # TODO
+                print "here"
+                export_csv_training = True
+                if export_csv_training:
+                        
+                        output_file = output_file.replace('.csv', '-trainingEeg.csv')
+                        
+                        if self.DEBUG:
+                                print "Writing file:",
+                                print output_file
+                        
+                        outputData = self.exportTrainingDataToCSV(parent=parent, source=source, target=target)
+                        
+                        if outputData != None:
+                                
+                                file = open(str(output_file), 'w')
+                                file.write(outputData)
+                                file.close()
+        
+        
         ##################################################################
         
@@ -704 +724 @@
                 return(output)
         
+        
+        ##################################################################
+        
+        def exportTrainingDataToCSV(self, parent=None, source=None, target=None):
+                
+                # handle importing class from multiple sources
+                if parent == None:
+                        if self.parent == None:
+                                parent = self
+                        else:
+                                parent = self.parent
+                
+                if source == None:
+                        if self.parent == None:
+                                source = self
+                        else:
+                                source = self.parent
+                
+                if target == None:
+                        if self.parent == None:
+                                target = self
+                        else:
+                                target = self.parent
+                
+                
+                try:
+                        truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE
+                except:
+                        truncate_csv_timezone = False
+                
+                
+                if source.packets['rawEeg'] == []:
+                        if self.DEBUG:
+                                print "WARNING: No raw EEG packets"
+                        return(None)
+                else:
+                        if self.DEBUG:
+                                print "INFO: Raw EEG packets:",
+                                print len(source.packets['rawEeg'])
+                
+                
+                #headers = 'Date,Time,Raw EEG'
+                #headers = headers + '\n'
+                
+                
+                headers = 'Date,Time'
+                
+                
+                customDataHeaders = []
+                for header in parent.customDataHeaders:
+                        customDataHeaders.append(header)
+                for plugin in parent.activePlugins:
+                        #print plugin.name
+                        for header in plugin.customDataHeaders:
+                                customDataHeaders.append(header)
+                
+                for each in customDataHeaders:
+                        headers = headers + ',%s' % each
+                        
+                        
+                headers = headers +',%s' % 'Raw EEG'
+                        
+                
+                headers = headers + '\n'
+                
+                
+                csv = {}
+                
+                for packet in source.packets['rawEeg']:
+                        
+                        # NOTE: Move this to ThinkGear Server object
+                        if 'rawEeg' in packet.keys():
+                                
+                                if packet['timestamp'] not in csv.keys():
+                                        
+                                        
+                                        timestamp = packet['timestamp']
+                                        
+                                        (date, localtime) = source.parseTimeStamp(timestamp, \
+                                                            truncate_time_zone=truncate_csv_timezone)
+                                        
+                                        csv[timestamp] = {}
+                                        csv[timestamp]['Date'] = date
+                                        csv[timestamp]['Time'] = localtime
+                                        csv[timestamp]['rawEeg'] = packet['rawEeg']
+                                        
+                                        
+                                        csv[timestamp].update(self.collectProcessedData(parent, source, timestamp))
+                
+                
+                output = headers
+                
+                timestamps = csv.keys()
+                
+                # Don't sort timestamps in order to better preserve the original raw signal
+                #timestamps.sort()
+                
+                for timestamp in timestamps:
+                        
+                        row = '%s,%s,%s' % \
+                              (csv[timestamp]['Date'], \
+                               csv[timestamp]['Time'], \
+                               csv[timestamp]['rawEeg'])
+                                
+                                
+                                
+                        for header in customDataHeaders:
+                                if header in csv[timestamp].keys():
+                                        row = row + ',%s' % csv[timestamp][header]
+                                else:
+                                        #row = row + ','
+                                        row = ''
+                                        if self.DEBUG > 1:
+                                                print "WARN: empty signals packet:",
+                                                print csv[timestamp]
+                                        break
+                                
+                                
+                                
+                        
+                        row = row + '\n'
+                        
+                        output = output + row
+                
+                
+                return(output)
+        
+        
+        #################################################################
+        
+        def collectProcessedData(self, parent, source, match_timestamp):
+                
+                # Return processed and custom data fields for this timestamp
+                
+                
+                if self.DEBUG:
+                        print "Match Timestamp:",
+                        print match_timestamp
+                
+                
+                packet_timestamps = []
+                for packet in source.packets['signals']:
+                        
+                        if 'blinkStrength' in packet.keys():
+                                # Skip any blink packets from log
+                                continue
+                        
+                        packet_timestamps.append(packet['timestamp'])
+                
+                
+                packet_timestamps.sort()
+                
+                
+                #found = {}
+                
+                for timestamp in packet_timestamps:
+                        
+                        if self.DEBUG:
+                                print "--> Search Timestamp:",
+                                print match_timestamp
+                        
+                        #if (found == {}):
+                                #found = packet
+                                #continue
+                        
+                        # Keep searching until 
+                        if (match_timestamp > timestamp):
+                                continue
+                        
+                        #found = packet
+                
+                        if self.DEBUG:
+                                print "Matched Timestamp:",
+                                print timestamp
+                
+                
+                packet = {}
+                
+                for each in source.packets['signals']:
+                        if each['timestamp'] == timestamp:
+                                #if self.DEBUG:
+                                        #print "INFO: Packet Found:",
+                                        #print each
+                                packet = each
+                
+                
+                data = {}
+                        
+                for plugin in parent.activePlugins:
+                        if plugin.customDataHeaders != []:
+                                if self.DEBUG > 2:
+                                        print "INFO: [Synapse:Session] Exporting:",
+                                        print plugin.name
+                                try:
+                                        data = plugin.processPacketForExport(packet=packet, output=data)
+                                        if self.DEBUG > 2:
+                                                print "INFO [Synapse:Session]: Export Successful"
+                                                print plugin.name
+                                except Exception, e:
+                                        if self.DEBUG:
+                                                print "ERROR: [Synapse:Session] Exception calling processPacketForExport on",
+                                                print plugin.name
+                
+                
+                #print "INFO: data",
+                #print data
+                
+                return data
+                
+                
+                #for header in customDataHeaders:
+                        
+                        #if 'custom' in packet.keys() and \
+                                #header in packet['custom'].keys():
+                                
+                                #timestamp = packet['timestamp']
+                                #(date, localtime) = source.parseTimeStamp(timestamp, \
+                                                                                                #truncate_time_zone=truncate_csv_timezone)
+                                
+                                #if timestamp not in csv.keys():
+                                        #data = {}
+                                        #data['Date'] = date
+                                        #data['Time'] = localtime
+                                        #if self.DEBUG:
+                                                #print "WARN: Unmatched custom packet:",
+                                                #print packet
+                                
+                                #data[header] = packet['custom'][header]
+
+                
+                
+                
+                #for packet in source.packets['signals']:
+                        
+                        
+                        ## NOTE: Move this to ThinkGear Server object
+                        ##if 'rawEeg' in packet.keys():
+                                ##continue
+                        
+                        
+                        #if 'timestamp' not in packet.keys() and len(packet.keys()) == 1:
+                                #if self.DEBUG:
+                                        #print "WARN: Skipping empty packet:",
+                                        #print packet
+                                ## skip empty packets
+                                #continue
+                        
+                        
+                        #print "packet:",
+                        #print packet
+                        
+                        #timestamp = packet['timestamp']
+                        ##(date, localtime) = self.parseTimeStamp(timestamp, \
+                                                                                ##truncate_time_zone=truncate_csv_timezone)
+                        #(date, localtime) = source.parseTimeStamp(timestamp, \
+                                                                                #truncate_time_zone=truncate_csv_timezone)
+                        
+                        #if timestamp not in csv.keys():
+                                
+
+                                
+                                
+                                ##timestamp = packet['timestamp']
+                                ###(date, localtime) = self.parseTimeStamp(timestamp, \
+                                                    ###truncate_time_zone=truncate_csv_timezone)
+                                ##(date, localtime) = source.parseTimeStamp(timestamp, \
+                                                    ##truncate_time_zone=truncate_csv_timezone)
+                                
+                                #csv[timestamp] = {}
+                                #csv[timestamp]['Date'] = date
+                                #csv[timestamp]['Time'] = localtime
+                        
+                        
+                        #for plugin in parent.activePlugins:
+                                #if plugin.customDataHeaders != []:
+                                        #if self.DEBUG > 2:
+                                                #print "INFO: [Synapse:Session] Exporting:",
+                                                #print plugin.name
+                                        #try:
+                                                #csv[timestamp] = plugin.processPacketForExport(packet=packet, output=csv[timestamp])
+                                                #if self.DEBUG > 2:
+                                                        #print "INFO [Synapse:Session]: Export Successful"
+                                                        #print plugin.name
+                                        #except Exception, e:
+                                                #if self.DEBUG:
+                                                        #print "ERROR: [Synapse:Session] Exception calling processPacketForExport on",
+                                                        #print plugin.name
+                        
+                        
+                        #for header in customDataHeaders:
+                                
+                                #if 'custom' in packet.keys() and \
+                                   #header in packet['custom'].keys():
+                                        
+                                        #timestamp = packet['timestamp']
+                                        #(date, localtime) = source.parseTimeStamp(timestamp, \
+                                                               #truncate_time_zone=truncate_csv_timezone)
+                                        
+                                        #if timestamp not in csv.keys():
+                                                #csv[timestamp] = {}
+                                                #csv[timestamp]['Date'] = date
+                                                #csv[timestamp]['Time'] = localtime
+                                                #if self.DEBUG:
+                                                        #print "WARN: Unmatched custom packet:",
+                                                        #print packet
+                                        
+                                        #csv[timestamp][header] = packet['custom'][header]
+
         
         #################################################################

trunk/Puzzlebox/Synapse/ThinkGear/Protocol.py

@@ -86 +86 @@
 import signal
 import serial
+import copy
 
 if ((sys.platform != 'win32') and \
@@ -154 +155 @@
 DEBUG_PACKET_COUNT = 1024
 
+
+#CURRENT_SIGNAL = 0
+#CURRENT_ATTENTION = 0
+#CURRENT_MEDITATION = 0
+
 #####################################################################
 # Classes
@@ -185 +191 @@
                 self.data_packet['eegPower'] = {}
                 self.data_packet['eSense'] = {}
+                
+                self.current_signal = 200
+                self.current_attention = 0
+                self.current_meditaiton = 0
+                self.detection_threshold = 70
+                self.current_detection = 0
                 
                 #self.packet_count = 0
@@ -367 +379 @@
                 if (raw >= 32768):
                         raw = raw - 65536
+                
+                
+                
+                #print "%s,%s,%s,%s,%s" % (time.time(),
+                        #CURRENT_SIGNAL,
+                        #CURRENT_ATTENTION,
+                        #CURRENT_MEDITATION,
+                        #raw)
+                
+                if (self.current_signal == 0):
+                        print "%s,%i,%i,%i,%s,%i" % (time.time(),
+                                                self.current_signal,
+                                                self.current_attention,
+                                                self.current_meditaiton,
+                                                raw,
+                                                self.current_detection)
                 
                 
@@ -477 +505 @@
                                         print poor_signal_quality
                                 
+                                self.current_signal = copy.copy(poor_signal_quality)
+                                
                                 packet_update['poorSignalLevel'] = poor_signal_quality
+                                
+                                self.current_signal = poor_signal_quality
                         
                         
@@ -486 +518 @@
                                         print attention
                                 
+                                self.current_attention = copy.copy(attention)
+                                
+                                if (attention > self.detection_threshold):
+                                        self.current_detection = 1
+                                else:
+                                        self.current_detection = 0
+                                
                                 packet_update['eSense'] = {}
                                 packet_update['eSense']['attention'] = attention
@@ -495 +534 @@
                                         print "meditation:",
                                         print meditation
+                                
+                                self.current_meditaiton = copy.copy(meditation)
                                 
                                 packet_update['eSense'] = {}
@@ -521 +562 @@
                                 
                                 packet_update['rawEeg'] = raw_eeg_value
+                                
+                                #print "%s,%i,%i,%i,%s" % (time.time(),
+                                                                                #self.current_signal,
+                                                                                #self.current_attention,
+                                                                                #self.current_meditaiton,
+                                                                                #raw_eeg_value)
                         
                         
@@ -892 +939 @@
         def run(self):
                 
-                self.resetSession()
+                try:
+                        self.resetSession()
+                except Exception, e:
+                        if self.DEBUG:
+                                print "ERROR: self.resetSession():",
+                                print e
                 
                 if self.device != None and self.device.device != None:
@@ -1234 +1286 @@
                                         self.buffer += byte
                         
-                        except:
+                        except Exception, e:
                                 if self.DEBUG:
-                                        print "ERROR: failed to read from serial device"
+                                        print "ERROR: failed to read from serial device:",
+                                        print e
                                 break