def create_objects(self): ## DEFINE PARAMETERS ########### self.CharSet = 'lowerCaseLiterals' self.CharactersPerMessage = 5 self.SourceEncodeMethod = 'basic' self.errorCorrection = 'HardHamming' self.FEC_Size = 7 self.FEC_msg = 4 # Choose frequencies matching those on the sender side exactly from set: # [23.26, 23.81, 24.39, 25, 25.64, 26.36, 27.03, 27.78, 28.57, 29.41, 30.30, 31.25, 32.26, 33.33, # 34.48, 35.71, 37.04, 38.46 ] self.TransmissionFrequenciesIdeal = [ 23.26, 25, 26.36, 27.78, 28.57, 30.30, 31.25, 33.33 ] self.TimePerSymbolSeconds = 4 self.ChannelSource = 'Emokit' self.FlushBuffer = True self.Electrodes = ['O1', 'O2', 'P7', 'P8'] self.DetectionMethod = 'PSDA' self.DecisionType = 'HARD' self.syncMethod = 'HeaderV2' #'HeaderV2' self.FileWrite = False self.readFileName = '20171009-182912.csv' ########################### self.TransmissionFrequenciesActual = FD.mapToClosestFrequencies( self.TransmissionFrequenciesIdeal, 128 * self.TimePerSymbolSeconds) print(self.TransmissionFrequenciesActual) self.EEGChannel = CH.Channel(self.ChannelSource, self.Electrodes, WriteToFile=self.FileWrite, ReadFile=self.readFileName, useHeader=False, holdFreq=28.57, headerFreq=30.30, startThreshold=300, startThresholdRelative=0.8, crossoverThresholdRelative=0.5) self.Detector = RL.DetectionObject(self.DetectionMethod, self.TransmissionFrequenciesActual, None, self.Electrodes, self.TimePerSymbolSeconds, self.DecisionType) self.CharSet = RL.loadCharacterSet(self.CharSet) self.CD = RL.ChannelDecoder(self.errorCorrection, 'HARD', self.FEC_Size, self.FEC_msg) self.SD = RL.sourceDecoder(self.CharSet, self.SourceEncodeMethod) self.recordTime = RL.calculateRecvTime( self.TimePerSymbolSeconds, len(self.TransmissionFrequenciesActual), self.FEC_Size, self.FEC_msg, self.CharactersPerMessage, len(self.CharSet)) print(self.recordTime) self.recordTime = int(self.recordTime)
def test_doubleFunctionality(self): message = 'helloworld' chars = IL.loadCharacterSet('lowerCaseLiterals') srcEncoder = IL.SrcEncoder(chars, 'basic') srcDecoder = RL.sourceDecoder(chars, 'basic') binMessage = srcEncoder.EncodeData(message) symbols = IL.SymbolMapping(binMessage, 4) recBin = RL.Demapper(symbols, 4, 'HARD') recvMessage = srcDecoder.Decode(recBin) self.assertEqual(message, recvMessage)
def create_objects(self): self.CharSet = 'lowerCaseLiterals' self.CharactersPerMessage = 7 self.SourceEncodeMethod = 'basic' self.errorCorrection = 'HardHamming' self.FEC_blockSize = 15 self.FEC_msgSize = 11 ########################### self.ValidDictionary = IL.loadCharacterSet(self.CharSet) self.InputValidationObject = IL.InputValidation(self.ValidDictionary,self.CharactersPerMessage) self.SrcEncoder = IL.SrcEncoder(self.ValidDictionary , self.SourceEncodeMethod) self.FEC = IL.ChannelEncoder(self.errorCorrection, self.FEC_blockSize , self.FEC_msgSize) ################################ self.CharSet = RL.loadCharacterSet(self.CharSet) self.CD = RL.ChannelDecoder(self.errorCorrection,'HARD', self.FEC_blockSize, self.FEC_msgSize) self.SD = RL.sourceDecoder(self.CharSet, self.SourceEncodeMethod)
def test_calculate_no_FEC(self): Sym_Period = 4 Num_Symbols = 4 FEC_blockSize = 1 FEC_msgSize = 1 Num_Characters = 4 AlpaLength = 26 calcTime = RL.calculateRecvTime(Sym_Period, Num_Symbols, FEC_blockSize, FEC_msgSize, Num_Characters, AlpaLength) self.assertEqual(calcTime, 40.0) Num_Symbols = 16 calcTime = RL.calculateRecvTime(Sym_Period, Num_Symbols, FEC_blockSize, FEC_msgSize, Num_Characters, AlpaLength) self.assertEqual(calcTime, 20.0)
def test_calcualte_with_FEC(self): Sym_Period = 4 Num_Symbols = 4 FEC_blockSize = 2 FEC_msgSize = 1 Num_Characters = 4 AlpaLength = 26 calcTime = RL.calculateRecvTime(Sym_Period, Num_Symbols, FEC_blockSize, FEC_msgSize, Num_Characters, AlpaLength) self.assertEqual(calcTime, 80.0) FEC_blockSize = 15 FEC_msgSize = 9 calcTime = RL.calculateRecvTime(Sym_Period, Num_Symbols, FEC_blockSize, FEC_msgSize, Num_Characters, AlpaLength) self.assertEqual(calcTime, 92.0)
def run_receiver(self): fig = plt.figure(figsize=(3, 3)) ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) canvas = FigureCanvasTkAgg(fig, master=self.main_class) canvas.get_tk_widget().grid(row=8, column=0) canvas.show() time.sleep(1) x_axis = numpy.linspace(0, 64, (128 * self.TimePerSymbolSeconds) / 2 + 1) numBatches = int(self.recordTime / self.TimePerSymbolSeconds) Data = numpy.zeros([self.recordTime * 128, len(self.Electrodes)]) self.main_class.update() if self.syncMethod == 'HeaderV2': if self.EEGChannel.gaze_detect(): self.set_gaze_detected() self.main_class.update() if self.EEGChannel.threshold_detect(): self.set_threshold_detect() self.main_class.update() else: self.EEGChannel.waitForStart(self.syncMethod) self.main_class.update() self.EEGChannel.flushBuffer() for i in range(numBatches): newData = self.EEGChannel.getDataBlock(self.TimePerSymbolSeconds, False) Data = dataUpdate(Data, newData) dataToPlot = getFFTs(newData) ax.clear() ax.plot(x_axis, dataToPlot[:, 0]) canvas.draw() time.sleep(0.001) self.main_class.update() print(time.time()) print 'DATA: ', Data Symbols = self.Detector.getSymbols(Data) print(Symbols) self.recv_symbols.insert(0.0, Symbols) Encoded = RL.Demapper(Symbols, len(self.TransmissionFrequenciesActual), self.DecisionType) DeIntBits = self.CD.de_interleave(Encoded) print(DeIntBits) Decoded = self.CD.Decode(DeIntBits) self.dec_msg.insert(0.0, Decoded) String = self.SD.Decode(Decoded) self.dec_str.insert(0.0, String) print(String) self.restart_button.grid(row=8, column=0) #pack(pady=10, padx=20) self.main_class.update()
def run_receiver(self): #while 1: sendString = self.InputValidationObject.getInput() SendBits = self.SrcEncoder.EncodeData(sendString) #print 'Sendbits: ', SendBits EncBits = self.FEC.EncodeData(SendBits) #print 'EncBits:', (EncBits) IntBits = self.FEC.interleave(EncBits) #print 'IntBITS: ', (IntBits) NoisyBits = '' for i in range(0, len(IntBits)): if i == 2: NoisyBits += '1' else: NoisyBits += IntBits[i] print 'NoisyBits: ', NoisyBits #wait for bool to change colour #if waitforStart: self.set_gaze_detected() self.set_threshold_detect() Symbols = IL.SymbolMapping(NoisyBits, 4) print 'Symbols: ', (Symbols) Encoded = RL.Demapper(Symbols,4, 'HARD') print 'Encoded: ', (Encoded) self.encoded = Encoded self.recv_symbols.insert(0.0,Encoded) DeintBits = self.CD.de_interleave(Encoded) print 'DEint Bits: ',(DeintBits) Decoded = self.CD.Decode(DeintBits) print 'Decoded: ', Decoded String = self.SD.Decode(Decoded) print 'String: ', String self.restart_button.grid(row=8,column=0) #pack(pady=10, padx=20)
FrequencySet = [ 23.26, 23.81, 24.39, 25, 25.64, 26.36, 27.03, 27.78, 28.57, 29.41, 30.30, 31.25, 32.26, 33.33, 34.48, 35.71, 37.04, 38.46 ] SymbolVector = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] ElectrodesForCCA = ['O1', 'O2', 'P7', 'P8'] NumRuns = 4 # how many detection loops should be performed # ================= ######### #===Collect Data ====== TransmissionFrequencies4s = FD.mapToClosestFrequencies(FrequencySet, 512) Sender = SendLib.Channel('FixedFrequencyAndDuty', None, None) Receiver = Channel.Channel('Emokit', ElectrodesForCCA, False, False) CCADetector4s = RecvLib.DetectionObject('CCA', TransmissionFrequencies4s, None, ElectrodesForCCA, 4, 'HARD') PSDADetector4s = RecvLib.DetectionObject('PSDA', TransmissionFrequencies4s, None, ['O1'], 4, 'HARD') CombinedDetector4s = RecvLib.DetectionObject('Combined', TransmissionFrequencies4s, None, ElectrodesForCCA, 4, 'HARD') ResultsCCA4s = numpy.zeros([len(SymbolVector), NumRuns]) ResultsPSDA4s = numpy.zeros([len(SymbolVector), NumRuns]) ResultsCombined4s = numpy.zeros([len(SymbolVector), NumRuns]) time.sleep(2) Receiver.flushBuffer() for i in range(NumRuns): Data4Seconds = numpy.zeros( [len(SymbolVector) * 512, len(ElectrodesForCCA)])
CharactersPerMessage = 5 SourceEncodeMethod = 'basic' errorCorrection = 'HardHamming' FEC_Size = 7 FEC_msg = 4 TransmissionFrequenciesIdeal = [ 23.26, 25, 26.36, 27.78, 28.57, 30.30, 31.25, 33.33 ] TimePerSymbolSeconds = 4 ChannelSource = 'Emokit' flushBuffer = True Electrodes = ['O1', 'O2', 'P7', 'P8'] DecisionType = 'HARD' syncMethod = 'HeaderV2' fileWrite = True CharSet = RL.loadCharacterSet(CharSet) actualFrequencies = FD.mapToClosestFrequencies( TransmissionFrequenciesIdeal, 512) Channel = CH.Channel(ChannelSource, Electrodes, fileWrite, useHeader=True, holdFreq=28.57, headerFreq=30.30, startThreshold=300, startThresholdRelative=0.8, crossoverThresholdRelative=0.5) DetectorCCA = RL.DetectionObject('CCA', actualFrequencies, None, Electrodes, TimePerSymbolSeconds, DecisionType)
def test_DisregardAdditionalBits(self): # any bits added by the FEC will be disregarded # unless they can create a full character chars = IL.loadCharacterSet('lowerCaseLiterals') SrcDec = RL.sourceDecoder(chars, 'basic') self.assertEqual('yj', SrcDec.Decode('11001010100000'))
def test_DecodeShortMessage(self): chars = IL.loadCharacterSet('lowerCaseLiterals') SrcDec = RL.sourceDecoder(chars, 'basic') self.assertEqual('yj', SrcDec.Decode('1100101010'))
def RunReciever( data_file, results_file , config_parameters, test_option ): # function which will execute a run of the emotiv reciever channel = Channel.Channel(config_parameters["CHANNEL_SOURCE"], config_parameters["ELECTRODES"], config_parameters["FILE_WRITE"],\ holdFreq= HOLD_FREQUENCY, headerFreq = HEADER_FREQUENCY ,startThreshold= START_THRESHOLD ,\ startThresholdRelative= START_THRESHOLD_RELATIVE,\ crossoverThresholdRelative= CROSSOVER_THRESHOLD_RELATIVE ) detectorCCA = Reciever.DetectionObject("CCA", config_parameters["TRANSMISSION_FREQUENCIES"], None, config_parameters["ELECTRODES"], config_parameters["TIME_PER_SYMBOL"],config_parameters["DECISION_TYPE"]) detectorPSDA = Reciever.DetectionObject("PSDA", config_parameters["TRANSMISSION_FREQUENCIES"], None, config_parameters["ELECTRODES"][0], config_parameters["TIME_PER_SYMBOL"],config_parameters["DECISION_TYPE"]) channelDecoder = Reciever.ChannelDecoder(config_parameters["ERROR_CORRECTION"],"HARD",\ config_parameters["FEC_BLOCK_SIZE"], config_parameters["FEC_MESSAGE_SIZE"]) characterSet = Reciever.loadCharacterSet(config_parameters["CHARACTER_SET"]) sourceDecoder = Reciever.sourceDecoder(characterSet,config_parameters["SOURCE_ENCODER"]) #calculate the record time recordTime = Reciever.calculateRecvTime(config_parameters["TIME_PER_SYMBOL"],\ len( config_parameters["TRANSMISSION_FREQUENCIES"] ),\ config_parameters["FEC_BLOCK_SIZE"],\ config_parameters["FEC_MESSAGE_SIZE"],\ config_parameters["CHARACTERS_PER_MESSAGE"],\ len(characterSet)) print('calculated record time is: '+ str(recordTime)) # need to now do the actual recording here # channel.setFileName(data_file) raw_input("ready ... press Enter to Start") if config_parameters["SYNC_METHOD"] == 'HeaderV2': print('--- DETECTING GAZE ----') channel.gaze_detect() print('--- GAZE DETECTED ----') channel.threshold_detect() print('--- THRESHOLD DETECTED ----') else: channel.waitForStart(config_parameters["SYNC_METHOD"]) recordStartTime = time.time() symbolsToCapture = int(float(recordTime)/float(config_parameters["TIME_PER_SYMBOL"])) print("--- DATA RECORDING STARTED --- " + str(recordStartTime)) channel.flushBuffer() symbolsCCA = [] symbolsPSDA = [] Data = numpy.zeros((0, len(config_parameters["ELECTRODES"]))) for symbol in range(symbolsToCapture): print("Getting Symbol "+str(symbol)+'. . . .') DataBlock = channel.getDataBlock(int(config_parameters["TIME_PER_SYMBOL"]),False) Data = numpy.concatenate([Data, DataBlock]) print( 'Number of samples collected: ' + str(len(DataBlock))) symbolsPSDA.append(detectorPSDA.getSymbols(DataBlock)[0]) symbolsCCA.append(detectorCCA.getSymbols(DataBlock)[0]) print('psda symbol vector :' + str(symbolsPSDA)) print('cca symbol vector :' + str(symbolsCCA)) if int(recordTime) != 0: intCCA = Reciever.Demapper(symbolsCCA, len(config_parameters["TRANSMISSION_FREQUENCIES"] ),'HARD') intPSDA = Reciever.Demapper(symbolsPSDA,len(config_parameters["TRANSMISSION_FREQUENCIES"] ),'HARD') encodedCCA = channelDecoder.de_interleave(intCCA) encodedPSDA =channelDecoder.de_interleave(intPSDA) binaryCCA = channelDecoder.Decode(encodedCCA) binaryPSDA = channelDecoder.Decode(encodedPSDA) StringCCA = sourceDecoder.Decode(binaryCCA) StringPSDA = sourceDecoder.Decode(binaryPSDA) print('Message Recieved from the CCA reciever '+StringCCA) print('Message Recieved from the PSDA reciever '+StringPSDA) successful = raw_input("Was this a successful run (Y/n): ") comments = raw_input("Provide any comments on the trial here: \n") results = {} results["SUCCESSFUL"] = successful results["COMMENTS"] = comments results["CONFIGURATION"] = config_parameters results["RECORD_START_TIME"] = recordStartTime if test_option != 'protocol_only': results["INTERLEAVED_CCA"]= intCCA results["INTERLEAVED_PSDA"]= intPSDA results["ENCODED_CCA"]= encodedCCA results["ENCODED_PSDA"]= encodedPSDA results["BINARY_CCA"]= binaryCCA results["BINARY_PSDA"]= binaryPSDA results["STRING_PSDA"]= StringPSDA results["STRING_CCA"]= StringCCA print(results) with open(results_file, 'w') as outfile: json.dump(results, outfile) with open(data_file,'w') as outfile: outfile.write(Data) data_file = open(data_file,'w') writer = csv.writer(data_file) for i in range(len(Data)): writer.writerow(Data[i]) data_file.close()