class Player(object): auth_timeout = 5 def __init__(self, socket, address): self.transport = Transport(socket, address) self.host = address[0] self.port = address[1] self.health = 100 def close(self): self.transport.send(Message.exit().pack()) self.transport.close() def auth(self): recv = None with Timeout(Player.auth_timeout, PlayerError("Authentication timed out")): try: msg = self.transport.receive() except PlayerError as e: print("error on receive") print(e) return False try: msg = Message.parse(msg) except MessageError: print("bad message") return False if msg.type == "nick": self.name = msg.payload self.transport.send(Message.auth_success().pack()) return True return False def listen(self): return self.transport.receive() def send(self, msg): self.transport.send(msg)
class Player(object): auth_timeout = 5 def __init__(self, socket, address): self.transport = Transport(socket, address) self.host = address[0] self.port = address[1] self.health = 100 def close(self): self.transport.send(Message.exit().pack()) self.transport.close() def auth(self): recv = None with Timeout(Player.auth_timeout, PlayerError("Authentication timed out")): try: msg = self.transport.receive() except PlayerError as e: print("error on receive") print(e) return False try: msg = Message.parse(msg) except MessageError: print("bad message") return False if msg.type == "nick": self.name = msg.payload self.transport.send(Message.auth_success().pack()) return True return False def listen(self): return self.transport.receive() def send(self, msg): self.transport.send(msg)
class Client(Greenlet): def __init__(self, host, port, nick): Greenlet.__init__(self) self.host = host self.port = port self.name = nick def _run(self): self.connect() if not self.auth(): self.exit("Could not connect to server") print("Auth successful") self.opponent = self.opponent_wait() self.start_wait() self.play() def wait(self, msg_type): """ Waits for a specific message type, then returns the received message """ while True: rec = self.transport.receive() try: msg = Message.parse(rec) except MessageError: continue if msg.type == msg_type: return msg def opponent_wait(self): msg = self.wait('opponent') return msg.payload def start_wait(self): while True: msg = self.wait('game') if msg.payload == 'start': break def play(self): sensor = gevent.spawn(self.handle_punch) sensor.join() def handle_punch(self): while True: gevent.sleep(7) #print "sending punch" self.transport.send(Message.punch().pack()) def exit(self, msg): print(msg) raise GreenletExit def connect(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.host, self.port)) print dir(sock) self.transport = Transport(sock, (self.host, self.port)) def auth(self): self.transport.send(Message.nick(self.name).pack()) data = self.transport.receive() try: msg = Message.parse(data) except MessageError: return False if msg.type == 'auth' and msg.payload == 'success': return True else: return False
class Client(Greenlet): def __init__(self, host, port, nick): Greenlet.__init__(self) self.host = host self.port = port self.name = nick def _run(self): self.connect() if not self.auth(): self.exit("Could not connect to server") print("Auth successful") self.opponent = self.opponent_wait() self.start_wait() self.play() def wait(self, msg_type): """ Waits for a specific message type, then returns the received message """ while True: rec = self.transport.receive() try: msg = Message.parse(rec) except MessageError: continue if msg.type == msg_type: return msg def opponent_wait(self): msg = self.wait('opponent') return msg.payload def start_wait(self): while True: msg = self.wait('game') if msg.payload == 'start': break def play(self): sensor = gevent.spawn(self.handle_punch) sensor.join() def handle_punch(self): while True: gevent.sleep(2) """ Record a few seconds of audio and save to a WAVE file. """ from scipy.io.wavfile import read, write from scipy.fftpack import rfft, irfft from scipy import * from pylab import * import numpy as np import pyaudio import matplotlib.pyplot as plt import wave import sys last = 0. last2 = 0. cal = [] mean = 0. std = 0. hit = 0 chunk = 1024 FORMAT = pyaudio.paInt16 CHANNELS = 1 RATE = 44100 #RECORD_SECONDS = 0.1 WAVE_FILENAME = '/tmp/ashfs/output.wav' p = pyaudio.PyAudio() stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, output=True, frames_per_buffer=chunk) init = True while True: #print "* recording" all = [] #for i in range(0, RATE / chunk * RECORD_SECONDS): i = 0 while i < 5: # ~120ms try: data = stream.read(chunk) all.append(data) i = i + 1 except: pass #print "* done recording" #print data[0] #print type(data[0]) #print "%d" % ord(data[0]) #audio = numpy.fromstring(data) #print type(audio) #audio.shape = (audio.shape[0], 1) #print audio.shape #f = scipy.fft(audio[:,0]) # write data to WAVE file data = ''.join(all) wf = wave.open(WAVE_FILENAME, 'wb') wf.setnchannels(CHANNELS) wf.setsampwidth(p.get_sample_size(FORMAT)) wf.setframerate(RATE) wf.writeframes(data) wf.close() rate, input = read(WAVE_FILENAME) input_max = max(input) input = input / float(input_max) fmax = rate / 2 input_len = len(input) input_time = float(input_len) / float(rate) #print "%d samples @ %dHz, duration = %f seconds" % (input_len, rate, input_time) t = linspace(0, input_time, input_len) ft = rfft(input) mgft = abs(ft) df = fmax / float(input_len / 2) f = linspace(0, fmax, input_len / 2 + 1) if init: plt.ion() fig = plt.figure() ax = fig.add_subplot(211) title('Time-Domain of Signal') tplot, = ax.plot(t, input) bx = fig.add_subplot(212) title('Fourier-Domain Magnitude of Signal') fplot, = bx.plot(f, mgft[0:input_len / 2 + 1]) init = False #plot(t, input) tplot.set_ydata(input) fplot.set_ydata(mgft[0:input_len / 2 + 1]) fig.canvas.draw() #show() sum = 0. # @50 22000, 25000 # @5 2200, 2500 # @4 1300, 1500 #print f[1300] #print f[1500] #print f[1800] #print f[2200] #print f[2500] sum_d = 0. for i in range(2200, 2500): sum += mgft[i] if i > 2300: sum_d += mgft[i] hitstr = """ # # ### ####### # # # # # # # # ####### # # # # # # # # # # # # ### # """ ratio = sum_d / sum #print sum if sum > 200: #print "ratio: %f, sum: %f" % (ratio * 100 , sum) last = ratio * 100 delta = last - last2 print "%f" % (delta) last2 = last #delta = ratio - last if abs(delta) > 6: hit = hit + 1 print hitstr print "Hits = %d" % (hit) print "Sending punch" self.transport.send(Message.punch().pack()) #if ratio > 7: #print sum #delta = last - sum; #if len(cal) < 21: # cal.append(sum) # print "Calibrating Delta = %f..." %(delta) # if len(cal) == 21: # mean = np.average(cal) # std = np.std(cal) # print "Done calibrating! STD=%f, MEAN=%f" % (std, mean) # print cal #else: # print "STD: %f" % (float(sum - mean)/std) #print "Delta (%f%%) : %f" % (sum/last * 100, delta); #if sum > 60000000: #last = sum #print sum #print sum2 #print "stability: %f, delta: %f, sum: %f" % (ratio * 100, ratio_d * 100, sum) stream.close() p.terminate() print "sending punch" # self.transport.send(Message.punch().pack()) def exit(self, msg): print(msg) raise GreenletExit def connect(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.host, self.port)) print dir(sock) self.transport = Transport(sock, (self.host, self.port)) def auth(self): self.transport.send(Message.nick(self.name).pack()) data = self.transport.receive() try: msg = Message.parse(data) except MessageError: return False if msg.type == 'auth' and msg.payload == 'success': return True else: return False
class Client(Greenlet): def __init__(self, host, port, nick): Greenlet.__init__(self) self.host = host self.port = port self.name = nick def _run(self): self.connect() if not self.auth(): self.exit("Could not connect to server") print("Auth successful") self.opponent = self.opponent_wait() self.start_wait() self.play() def wait(self, msg_type): """ Waits for a specific message type, then returns the received message """ while True: rec = self.transport.receive() try: msg = Message.parse(rec) except MessageError: continue if msg.type == msg_type: return msg def opponent_wait(self): msg = self.wait('opponent') return msg.payload def start_wait(self): while True: msg = self.wait('game') if msg.payload == 'start': break def play(self): sensor = gevent.spawn(self.handle_punch) sensor.join() def handle_punch(self): while True: gevent.sleep(7) #print "sending punch" self.transport.send(Message.punch().pack()) def exit(self, msg): print(msg) raise GreenletExit def connect(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.host, self.port)) print dir(sock) self.transport = Transport(sock, (self.host, self.port)) def auth(self): self.transport.send(Message.nick(self.name).pack()) data = self.transport.receive() try: msg = Message.parse(data) except MessageError: return False if msg.type == 'auth' and msg.payload == 'success': return True else: return False
def main(): # Setup logging. logging.basicConfig(format='%(levelname)s: %(message)s', level=LOGGING_LEVEL) # Start a transport. transport = Transport( nodes_count=NODE_COUNT, max_distance=MAX_DISTANCE, lost_messages_percentage=LOST_MESSAGES_PERCENTAGE, delay_multiplier=DELAY_MULTIPLIER, ) # Generate nodes. nodes: List[Node] = [] for i in range(NODE_COUNT): Node( nodes=nodes, node_id=i, transport=transport, chain=[], keep_excessive_messages=KEEP_EXCESSIVE_MESSAGES, blank_block_timeout=BLANK_BLOCK_TIMEOUT, chain_update_timeout=CHAIN_UPDATE_TIMEOUT, ) # Main loop. nodes_print = [] nodes_with_required_number_of_blocks = 0 cycles = 0 with output(output_type="list", initial_len=NODE_COUNT, interval=int(VISUAL_OUTPUT_REFRESH_RATE*1000)) as nodes_print: while True: cycles += 1 # Print current status. for i in range(len(nodes)): nodes_print[i] = str(nodes[i]) # IDs of all the nodes that need to be ran. nodes_to_run = {i for i in range(NODE_COUNT)} # Get possible message. messages_to_deliver = transport.receive() # Deliver the messages. for message, to_node_id in messages_to_deliver: # Run the node and deliver it's message. nodes[to_node_id].run(message) # Remove ID of the nodes that have been ran. try: nodes_to_run.remove(to_node_id) except KeyError: pass # Run the rest of the nodes that did not get a message. for i in nodes_to_run: nodes[i].run() # Exit the main loop if GENERATE_BLOCKS was forged on the majority of the nodes. nodes_with_required_number_of_blocks = 0 for i in range(NODE_COUNT): if len(nodes[i].chain) >= GENERATE_BLOCKS: nodes_with_required_number_of_blocks += 1 if nodes_with_required_number_of_blocks > NODE_COUNT/2.0: logging.info("--- All the blocks we requested were forged, stopping gracefully. ---") break if cycles > MAX_LOOP_ITERATIONS: logging.error("--- Premature termination. We ran out of allowed cycles by MAX_LOOP_ITERATIONS. ---") break # Gather stats on generated blocks. blocks_generated = {} for i in range(NODE_COUNT): for block in nodes[i].chain: try: blocks_generated[block.block_id].append(i) except KeyError: blocks_generated[block.block_id] = [i] # Log the generated blocks stats. for block_id, nodes_confirmed in blocks_generated.items(): logging.info("B{} confirmed by {}/{} nodes.".format(block_id, len(nodes_confirmed), NODE_COUNT)) if not blocks_generated: logging.error("No blocks were generated.") logging.info("{} cycles were executed.".format(cycles))
class Client(Greenlet): def __init__(self, host, port, nick): Greenlet.__init__(self) self.host = host self.port = port self.name = nick def _run(self): self.connect() if not self.auth(): self.exit("Could not connect to server") print("Auth successful") self.opponent = self.opponent_wait() self.start_wait() self.play() def wait(self, msg_type): """ Waits for a specific message type, then returns the received message """ while True: rec = self.transport.receive() try: msg = Message.parse(rec) except MessageError: continue if msg.type == msg_type: return msg def opponent_wait(self): msg = self.wait('opponent') return msg.payload def start_wait(self): while True: msg = self.wait('game') if msg.payload == 'start': break def play(self): sensor = gevent.spawn(self.handle_punch) sensor.join() def handle_punch(self): while True: gevent.sleep(2) """ Record a few seconds of audio and save to a WAVE file. """ from scipy.io.wavfile import read, write from scipy.fftpack import rfft, irfft from scipy import * from pylab import * import numpy as np import pyaudio import matplotlib.pyplot as plt import wave import sys last = 0. last2 = 0. cal = [] mean = 0. std = 0. hit = 0 chunk = 1024 FORMAT = pyaudio.paInt16 CHANNELS = 1 RATE = 44100 #RECORD_SECONDS = 0.1 WAVE_FILENAME = '/tmp/ashfs/output.wav' p = pyaudio.PyAudio() stream = p.open(format = FORMAT, channels = CHANNELS, rate = RATE, input = True, output = True, frames_per_buffer = chunk) init = True while True: #print "* recording" all = [] #for i in range(0, RATE / chunk * RECORD_SECONDS): i = 0 while i < 5: # ~120ms try: data = stream.read(chunk) all.append(data) i = i + 1 except: pass #print "* done recording" #print data[0] #print type(data[0]) #print "%d" % ord(data[0]) #audio = numpy.fromstring(data) #print type(audio) #audio.shape = (audio.shape[0], 1) #print audio.shape #f = scipy.fft(audio[:,0]) # write data to WAVE file data = ''.join(all) wf = wave.open(WAVE_FILENAME, 'wb') wf.setnchannels(CHANNELS) wf.setsampwidth(p.get_sample_size(FORMAT)) wf.setframerate(RATE) wf.writeframes(data) wf.close() rate, input = read(WAVE_FILENAME) input_max = max(input) input = input / float(input_max) fmax = rate / 2 input_len = len(input) input_time = float(input_len) / float(rate) #print "%d samples @ %dHz, duration = %f seconds" % (input_len, rate, input_time) t = linspace(0, input_time, input_len); ft = rfft(input) mgft = abs(ft) df = fmax/float(input_len/2) f = linspace(0, fmax, input_len/2 + 1) if init: plt.ion() fig = plt.figure() ax = fig.add_subplot(211) title('Time-Domain of Signal') tplot, = ax.plot(t, input) bx = fig.add_subplot(212) title('Fourier-Domain Magnitude of Signal') fplot, = bx.plot(f, mgft[0:input_len/2+1]) init = False #plot(t, input) tplot.set_ydata(input) fplot.set_ydata(mgft[0:input_len/2+1]) fig.canvas.draw() #show() sum = 0. # @50 22000, 25000 # @5 2200, 2500 # @4 1300, 1500 #print f[1300] #print f[1500] #print f[1800] #print f[2200] #print f[2500] sum_d = 0. for i in range(2200, 2500): sum += mgft[i] if i > 2300: sum_d += mgft[i] hitstr=""" # # ### ####### # # # # # # # # ####### # # # # # # # # # # # # ### # """ ratio = sum_d/sum #print sum if sum > 200: #print "ratio: %f, sum: %f" % (ratio * 100 , sum) last = ratio * 100 delta = last - last2 print "%f" % (delta) last2 = last #delta = ratio - last if abs(delta) > 6: hit = hit + 1 print hitstr print "Hits = %d" % (hit) print "Sending punch" self.transport.send(Message.punch().pack()) #if ratio > 7: #print sum #delta = last - sum; #if len(cal) < 21: # cal.append(sum) # print "Calibrating Delta = %f..." %(delta) # if len(cal) == 21: # mean = np.average(cal) # std = np.std(cal) # print "Done calibrating! STD=%f, MEAN=%f" % (std, mean) # print cal #else: # print "STD: %f" % (float(sum - mean)/std) #print "Delta (%f%%) : %f" % (sum/last * 100, delta); #if sum > 60000000: #last = sum #print sum #print sum2 #print "stability: %f, delta: %f, sum: %f" % (ratio * 100, ratio_d * 100, sum) stream.close() p.terminate() print "sending punch" # self.transport.send(Message.punch().pack()) def exit(self, msg): print(msg) raise GreenletExit def connect(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.host, self.port)) print dir(sock) self.transport = Transport(sock, (self.host, self.port)) def auth(self): self.transport.send(Message.nick(self.name).pack()) data = self.transport.receive() try: msg = Message.parse(data) except MessageError: return False if msg.type == 'auth' and msg.payload == 'success': return True else: return False