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()