print('R_%s = %s' % (i, R[i].bin)) # R_fin = np.array(R[16]) # L_fin = np.array(L[16]) output_pre_permutation = np.concatenate( (split_bitarray(R[16], 4), split_bitarray(L[16], 4)), axis=0) output = do_permutation( BitArray(flatten_list(output_pre_permutation.tolist())), vals.ip_inv) if debug: print('Ciphertext before inverse permutation: ') for element in output_pre_permutation: print(BitArray(element).bin) return BitArray(flatten_list(output)) # The below can be used to validate the functionality of DES_encrypt() as described in # http://page.math.tu-berlin.de/~kant/teaching/hess/krypto-ws2006/des.htm # x = BitArray('0b 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111') # K = BitArray('0b 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001') # y = DES_encrypt(x, K, debug=True) # print('\nCiphertext:' + str(y.hex)) # Initialize given values x = BitArray( '0b 00100101 01100111 11001101 10110011 11111101 11001110 01111110 00101010' ) K = BitArray( '0b 11100101 01100111 11001101 10110011 11111101 11001110 01111111 00101010' ) y = DES_encrypt(x, K) print('Ciphertext: %s' % y.hex)
def displayPrecision(num): binum = BitArray(float=num, length=64) sign = int(binum[0]) exponent = binum[1:12].bin mantissa = binum[12:].bin return sign, exponent, mantissa
def convert_to_bitstring(self, new_data): if isinstance(new_data, BitArray): return new_data else: return BitArray(bytes=new_data, length=len(new_data) * 8)
class TinyCompressor: """This class holds data and methods for a data compressor using LEC Algorithm""" table = {} decode_table = {} eof = 0 __first_data = [] __previous_data = [] __data = [] __data_ns = [] __decimal_places = [] __strings_table = {} __compressed_data = BitArray() __compressed_data_string = "" __data_length = 0 data_frequencies = {} __d_values = [] codec = 0 def __init__(self, decimal_places): self.__decimal_places = decimal_places[:] def set_strings_table(self, new_strings_table): self.__strings_table = new_strings_table def get_n(self, d_value): if d_value == 0: return 0 return int(floor(log(abs(d_value),2))) + 1 def get_a(self,d_value,n_value): if d_value == 0: return "" if d_value < 0: return BitArray(int=d_value-1, length=20).bin[(-1)*n_value:] if d_value > 0: return BitArray(int=d_value, length=20).bin[(-1)*n_value:] def generate_data_list(self,inputfilename): first = True self.__first_data = [] self.__previous_data = [] self.__data_ns = [] self.__data = [] self.data_frequencies = {} with open(inputfilename) as inputfile: for line in inputfile: linedata = line.split(",") self.__data_length = len(linedata) if (len(linedata) != len(self.__decimal_places)): print "Length of decimal places different than length of data" return #Should return an exception if first: for i in range(len(linedata)): self.__first_data.append(float(linedata[i])) self.__previous_data = self.__first_data[:] first = False else: for i in range(len(linedata)): value = (int(float(linedata[i]) * 10**self.__decimal_places[i]) - int(float(self.__previous_data[i]) * 10**self.__decimal_places[i])) """if (i == 2): print "Value =", value""" self.__data.append(value) self.__data_ns.append(self.get_n(value)) self.__previous_data = linedata[:] print "Data len =", len(self.__data) print "adding range MAX_DATA_N" self.__data_ns += range(MAX_DATA_N) def generate_table(self,inputfilename): self.generate_data_list(inputfilename) self.codec = HuffmanCodec.from_data(self.__data_ns) self.table = self.codec.get_code_table() self.__strings_table = {} for symbol in self.table.keys(): if not type(symbol) is int: self.eof = symbol bitsize, value = self.table[symbol] self.__strings_table[symbol] = bin(value)[2:].rjust(bitsize, '0') def encode_data(self, inputfilename, outputfilename): self.generate_data_list(inputfilename) self.__compressed_data_string = "" try: for i in range(len(self.__data)): self.__compressed_data_string += \ self.__strings_table[self.__data_ns[i]] + \ self.get_a(self.__data[i], self.__data_ns[i]) except KeyError: print "Not possible to encode data[{}] = {}".format(i, self.__data[i]) return #Add EOF self.__compressed_data_string += self.__strings_table[self.eof] self.__compressed_data = BitArray(bin=self.__compressed_data_string) #print "Compressed data to file:", self.__compressed_data.bin def to_file(self): with open(outputfilename, 'wb') as outputfile: self.__compressed_data.tofile(outputfile) def build_values(self,inputfilename): print "Building values from", inputfilename compressed_bitarray = 0 with open(inputfilename, 'rb') as compressedfile: compressed_bitarray = BitArray(compressedfile) #print "Compressed data from file:", compressed_bitarray.bin for k in self.__strings_table.keys(): if (type(k) is int): self.decode_table[self.__strings_table[k]] = k possible_codes = set(self.decode_table.keys()) #print "Decode table =", self.decode_table self.__d_values = [] time_to_stop = False iteration = 0 start_s = 0 end_s = 1 start_a = end_s end_a = 3 n = 0 s = 0 a = 0 while( not time_to_stop): if compressed_bitarray[start_s:end_s].bin in possible_codes: s = compressed_bitarray[start_s:end_s] n = self.decode_table[s.bin] start_a = end_s end_a = start_a + n # +1 ? if n == 0: #a = 0 self.__d_values.append(0) else: a = compressed_bitarray[start_a:end_a] if a[0]: self.__d_values.append((OFFSET_ZERO+ a).int) else: self.__d_values.append((OFFSET_ONE+ a).int +1) start_s = end_a else: end_s += 1 if end_s >= len(compressed_bitarray.bin): time_to_stop = True def decode_data(self,first_values, inputfilename, outputfilename): self.build_values(inputfilename) self.__values = [] accumulator = first_values[:] print "len __d_values =", len(self.__d_values) """print "Data encoded =", self.__data print "Data decoded =", self.__d_values print "First values =", first_values""" """for i in range(len(self.__d_values)/len(accumulator)): self.__values.append(accumulator[:]) for j in range(i, i*len(accumulator)+ len(accumulator)): print "(i,j) =",j-i*len(accumulator),j accumulator[j-i*len(accumulator)] += self.__d_values[j]""" self.__values.append(accumulator[:]) for i in range(len(self.__d_values)): """if (i == 2): print "Value =", self.__d_values[i]""" """if((i%len(accumulator) == 1)): print self.__d_values[i]""" if self.__decimal_places[i%len(accumulator)] == 0: accumulator[i%len(accumulator)] += self.__d_values[i] else: accumulator[i%len(accumulator)] += float(self.__d_values[i]) \ / 10**self.__decimal_places[i%len(accumulator)] if ((i%len(accumulator)) == (len(accumulator)-1)): self.__values.append(accumulator[:]) with open(outputfilename, 'wb') as outputfile: for value in self.__values: line = ",".join( [("{:."+str(self.__decimal_places[i]) +"f}").format(float(value[i])) for i in range(len(value))]) outputfile.write(line + '\n')
def to_bytes(self): bytes_name = name_to_bytes(self.qname)[0] bits_packet = BitArray(length=32) bits_packet[0:16] = pack('uint: 16', self.qtype) bits_packet[16:32] = pack('uint: 16', self.qclass) return bytes_name + bits_packet.tobytes()
def prepareUInt16as2Bytes(self, i): word = BitArray(uint=i, length=16) lb = word[0:8].hex.encode('utf-8') + b' ' ub = word[8:16].hex.encode('utf-8') + b' ' return ub + lb
def set_vlan(self, vlan): if vlan < MIN_VLAN_ID or vlan > MAX_VLAN_ID: return if not self.vlan_bit_map: self.vlan_bit_map = BitArray(MAX_VLAN_ID + 1) self.vlan_bit_map[vlan] = 1
[30, 22, 84, 3], [36, 92, 113, 46], [37, 50, 98, 81], [33, 125, 13, 122], [10, 5, 62, 6], [61, 21, 82, 38], [102, 43, 42, 45], [95, 114, 110, 4], [89, 9, 94, 117], [87, 105, 79, 27], [88, 85, 72, 18], [51, 48, 108, 119], [16, 23, 1, 73], [75, 101, 26, 71], [126, 93, 7, 118], [31, 97, 104, 74], [96, 103, 99, 91], [29, 100, 69, 83], [6, 88, 75, 19], [101, 68, 20, 98], [107, 45, 28, 121], [87, 26, 59, 34], [44, 35, 12, 127], [42, 40, 56, 9], [47, 80, 16, 89], [78, 21, 14, 100], [1, 110, 65, 115], [90, 113, 8, 15], [85, 70, 66, 83], [32, 67, 108, 73], [53, 76, 41, 111], [109, 13, 17, 91], [95, 31, 122, 82], [119, 99, 120, 7], [123, 71, 86, 69], [77, 50, 97, 22], [5, 126, 43, 125], [118, 52, 38, 102], [48, 55, 29, 116], [27, 24, 103, 94], [23, 106, 18, 61], [33, 92, 93, 81], [0, 79, 25, 4], [96, 63, 3, 72], [49, 84, 74, 114], [57, 51, 60, 39], [37, 112, 36, 62], [11, 64, 54, 104], [58, 46, 10, 124], [117, 30, 105, 2]] w = BitArray( '0b01101111110010111001011111001001111111111100101011111000001011111111000110000101010000011011110110100001011101000011001110001010' ) x = encode(K, P, w) assert x == BitArray( '0b011011111100101110010111110010011111111111001010111110000010111111110001100001010100000110111101101000010111010000110011100010101111101110010011110111011101000000000000010100111111000100111101110110001111010100101010011111111100000110011000001111100001001110100110010001100001010010001010100010011100001001100110011010010100001110000111011101110111011011001010111010011101101011011110' ) y = BitArray( '0b000011011100101100000011100000011101101010001000110010000010010111000000000000000000000100001100000000010000000000100001000000100111100110000011010111011001000000000000000000110001000000111101000010001001010000000010000101111000000010011000001110100000000000100100010000000000000000000000000010011100000001000110010000010000000010000011000001000101000011000010000010001001101001001010' ) q = BitArray( '0b111100100011000011011100010011000010010101110110001100000001101000111111101111011110010011110011101110100111111101010010110110001000011001111000101000000100011100001001111110001110000100000010110100100110001110101001111010000111111100000100100001000111011110011011101111110001111010011010110100000011011100101001001010001101111100101100011110110010011000101001111101010110000010010100' ) hat_y = decode(K, P, y, q) assert hat_y is not None hat_w = hat_y[:K] assert hat_w == w
def hamming_distance(s1, s2): ba1 = BitArray(hex=s1.encode('hex')) ba2 = BitArray(hex=s2.encode('hex')) return (ba1 ^ ba2).count(1)
def __init__(self): # TODO Support for command line argument self.main_program_instr_cnt = 100 # count of main_prog self.sub_program_instr_cnt = [] # count of sub_prog self.debug_program_instr_cnt = 0 # count of debug_rom self.debug_sub_program_instr_cnt = [] # count of debug sub_progrms self.max_directed_instr_stream_seq = 20 # Commenting out for now # self.data_page_pattern = list( # map(lambda dta_pg: dta_pg.name, data_pattern_t)) # dicts for exception_cause_t & interrupt_cause_t Enum classes self.m_mode_exception_delegation = {} self.s_mode_exception_delegation = {} self.m_mode_interrupt_delegation = {} self.s_mode_interrupt_delegation = {} # init_privileged_mode default to MACHINE_MODE self.init_privileged_mode = privileged_mode_t.MACHINE_MODE self.mstatus = BitArray(bin(0b0), length=rcs.XLEN - 1) self.mie = BitArray(bin(0b0), length=rcs.XLEN - 1) self.sstatus = BitArray(bin(0b0), length=rcs.XLEN - 1) self.sie = BitArray(bin(0b0), length=rcs.XLEN - 1) self.ustatus = BitArray(bin(0b0), length=rcs.XLEN - 1) self.uie = BitArray(bin(0b0), length=rcs.XLEN - 1) self.mstatus_mprv = 0 self.mstatus_mxr = 0 self.mstatus_sum = 0 self.mstatus_tvm = 0 self.mstatus_fs = BitArray(bin(0b0), length=2) self.mstatus_vs = BitArray(bin(0b0), length=2) self.mtvec_mode = vsc.rand_enum_t(mtvec_mode_t) self.argv = self.parse_args() self.args_dict = vars(self.argv) self.tvec_alignment = self.argv.tvec_alignment self.fcsr_rm = list(map(lambda csr_rm: csr_rm.name, f_rounding_mode_t)) self.enable_sfence = 0 self.gpr = [] # Helper fields for gpr self.gpr0 = vsc.rand_enum_t(riscv_reg_t) self.gpr1 = vsc.rand_enum_t(riscv_reg_t) self.gpr2 = vsc.rand_enum_t(riscv_reg_t) self.gpr3 = vsc.rand_enum_t(riscv_reg_t) self.scratch_reg = vsc.rand_enum_t(riscv_reg_t) self.pmp_reg = vsc.rand_enum_t(riscv_reg_t) self.sp = vsc.rand_enum_t(riscv_reg_t) self.tp = vsc.rand_enum_t(riscv_reg_t) self.ra = vsc.rand_enum_t(riscv_reg_t) self.check_misa_init_val = 0 self.check_xstatus = 1 self.virtual_addr_translation_on = 0 # Commenting out for now # vector_cfg = riscv_vector_cfg # TODO # pmp_cfg = riscv_pmp_cfg # TODO # self.mem_region = [] # TODO # Self.amo_region = [] # TODO self.stack_len = 5000 # Self.s_mem_region = [] # TODO self.kernel_stack_len = 4000 self.kernel_program_instr_cnt = 400 # list of main implemented CSRs self.invalid_priv_mode_csrs = [] self.num_of_sub_program = self.argv.num_of_sub_program self.instr_cnt = self.argv.instr_cnt self.num_of_tests = self.argv.num_of_tests self.no_data_page = self.argv.no_data_page self.no_branch_jump = self.argv.no_branch_jump self.no_load_store = self.argv.no_load_store self.no_csr_instr = self.argv.no_csr_instr self.no_ebreak = self.argv.no_ebreak self.no_dret = self.argv.no_dret self.no_fence = self.argv.no_fence self.no_wfi = self.argv.no_wfi self.enable_unaligned_load_store = self.argv.enable_unaligned_load_store self.illegal_instr_ratio = self.argv.illegal_instr_ratio self.hint_instr_ratio = self.argv.hint_instr_ratio self.num_of_harts = self.argv.num_of_harts self.fix_sp = self.argv.fix_sp self.use_push_data_section = self.argv.use_push_data_section self.boot_mode_opts = self.argv.boot_mode if self.boot_mode_opts: logging.info("Got boot mode option - %0s", self.boot_mode_opts) if self.boot_mode_opts == "m": self.init_privileged_mode = privileged_mode_t.MACHINE_MODE elif self.boot_mode_opts == "s": self.init_privileged_mode = privileged_mode_t.SUPERVISOR_MODE elif self.boot_mode_opts == "u": self.init_privileged_mode = privileged_mode_t.USER_MODE else: logging.error("Illegal boot mode option - %0s", self.boot_mode_opts) self.enable_page_table_exception = self.argv.enable_page_table_exception self.no_directed_instr = self.argv.no_directed_instr self.asm_test_suffix = self.argv.asm_test_suffix self.enable_interrupt = self.argv.enable_interrupt self.enable_nested_interrupt = self.argv.enable_nested_interrupt self.enable_timer_irq = self.argv.enable_timer_irq self.bare_program_mode = self.argv.bare_program_mode self.enable_illegal_csr_instruction = self.argv.enable_illegal_csr_instruction self.enable_access_invalid_csr_level = self.argv.enable_access_invalid_csr_level self.enable_misaligned_instr = self.argv.enable_misaligned_instr self.enable_dummy_csr_write = self.argv.enable_dummy_csr_write self.randomize_csr = self.argv.randomize_csr self.allow_sfence_exception = self.argv.allow_sfence_exception self.no_delegation = self.argv.no_delegation self.force_m_delegation = self.argv.force_m_delegation self.force_s_delegation = self.argv.force_s_delegation self.support_supervisor_mode = 0 self.disable_compressed_instr = self.argv.disable_compressed_instr self.require_signature_addr = self.argv.require_signature_addr if (self.require_signature_addr): self.signature_addr = int(self.argv.signature_addr, 16) else: self.signature_addr = 0xdeadbeef self.gen_debug_section = self.argv.gen_debug_section self.enable_ebreak_in_debug_rom = self.argv.enable_ebreak_in_debug_rom self.set_dcsr_ebreak = self.argv.set_dcsr_ebreak self.num_debug_sub_program = self.argv.num_debug_sub_program self.enable_debug_single_step = self.argv.enable_debug_single_step self.single_step_iterations = 0 self.set_mstatus_tw = self.argv.set_mstatus_tw self.set_mstatus_mprv = self.argv.set_mstatus_mprv self.min_stack_len_per_program = 10 * (rcs.XLEN / 8) self.max_stack_len_per_program = 16 * (rcs.XLEN / 8) self.max_branch_step = 20 self.reserved_regs = vsc.list_t(vsc.enum_t(riscv_reg_t)) self.enable_floating_point = self.argv.enable_floating_point self.enable_vector_extension = self.argv.enable_vector_extension self.enable_b_extension = self.argv.enable_b_extension self.enable_bitmanip_groups = self.argv.enable_bitmanip_groups self.dist_control_mode = 0 self.category_dist = {} self.march_isa = self.argv.march_isa if (len(self.march_isa) != 0): rcs.supported_isa = self.march_isa if (rcs.supported_isa != 'RV32C'): self.disable_compressed_instr = 1
#### PROB_THRESHOLD = .7 COUNT_THRESH = 3 #pre-amble and access code data # PREA_AND_ADDR = [PREA_AND_ADDR_STR[st:st+2] for st in range(len(PREA_AND_ADDR_STR)) if st%2==0] # PREA_AND_ADDR_LEN = len(PREA_AND_ADDR); # packet of interest PACKET_BODY_STR = "d373803183ab10953e489039dd3b36236a29f0b0c6f8ba00b9" PACKET_BODY = [ PACKET_BODY_STR[st:st + 2] for st in range(len(PACKET_BODY_STR)) if st % 2 == 0 ] PACKET_BUFFER = BitArray(hex=PACKET_BODY_STR).bin #PARKED_PACKET PACKET_BODY_LEN = len(PACKET_BODY) ##hamming distance map characters = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" ] #CHAR_DISTS = {(i,j):bin(int(i,16)^int(j,16)).count('1') for i in characters for j in characters} ##################### ##################### ''' debug and control functions '''
def encrypt(self, input_bits): assert(len(input_bits) == BS_BITS) return BitArray(aes.encrypt256(input_bits.bytes))
def rx_bitfield(self): if self._receiver: bits = BitArray(bytes=self._current_buf[1:self._bytes_received]) self._receiver.rx_bitfield(bits)
def main(): # logging.basicConfig(format='%(asctime)s %(filename)s %(funcName)s %(levelname)s %(message)s', # datefmt='%m/%d/%Y %I:%M:%S %p',filename=r'logs/app.log',level=logging.INFO, filemode='w') logging.basicConfig( format= '%(asctime)s %(filename)s %(funcName)s %(levelname)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p', level=logging.INFO) logging.info('App started.') parser = argparse.ArgumentParser( description='DNA secret sharing app client') parser.add_argument('-f', help='the full path of the DNA file', required=True, dest='file_name') parser.add_argument('-s', help='server 2 IP - #.#.#.#', required=True, dest='server_ips', nargs=2) parser.add_argument('-d', help='max distance off of the client DNA', dest='dist', required=False, type=int) args = vars(parser.parse_args()) dna = load_file(args['file_name']) try: Client = DNA_App_Client(dna) if args['dist'] is not None: logging.info("Building distance tree") secret_share_tree, seed0, seed1 = Client.build_d_distance_trees( args['dist']) else: logging.info("Building the tree") secret_share_tree, seed0, seed1 = Client.build_secret_share_trees() logging.info("Done building tree") except InvalidDNAException: logging.error( "The input DNA string is invalid, please check DNA string in file") # send server 1 list of tree object, seed, t bit and sec param - thread # send server 2 list of tree object, seed, t bit and sec param - thread # listen to response - should be serialized list of results - both threads # add corresponding items in each thread # try: logging.info("Sending data to servers") comm_client_1 = Comm_client(args['server_ips'][0], tree_root=secret_share_tree, seed=seed0, tbit='0', sec_param=constant.SEC_PARAM) comm_client_2 = Comm_client(args['server_ips'][1], tree_root=secret_share_tree, seed=seed1, tbit='1', sec_param=constant.SEC_PARAM) comm_client_1.start() # comm_client_1.run() # comm_client_2.run() comm_client_2.start() comm_client_1.join() comm_client_2.join() server1_analysis = comm_client_1.analysis server2_analysis = comm_client_2.analysis logging.info("Analyzing results") analysis = (BitArray(bin=server1_analysis) ^ BitArray(bin=server2_analysis)).int if analysis == 0: print "No disease found." else: analysis = log(analysis, 2) print 'The client DNA matches disease # : %d' % (analysis) # for key, index in zip(server1_analysis,range(0,len(server1_analysis))): # analysis1 = BitArray(bin=server1_analysis[key]) # analysis2 = BitArray(bin=server2_analysis[key]) # # print "The risk of being ill of illness # %d is: %d percent. " %(index + 1,(analysis1 ^ analysis2).int) # print analysis1.int # except Exception as e: # logging.error("Something went wrong while communicating with servers") # print sys.exc_info()[0] logging.info('App done.')
def prepareInt8as4bits(self, i): word = BitArray(uint=i, length=4) b = word[0:4].hex.encode('utf-8') + b'' return b
from bitstring import BitArray char_string = "71 -119 -99 84 71 -115 -99 84 71 9 -99 84 71 -115 -99 92 71 -119 -99 84 71 -115 -99 84 71 11 -99 84 71 -115 -99 92 71 -120 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 92 71 -119 -99 84 71 -115 -99 84 71 11 -99 -44 71 -115 -99 92 71 -119 -99 84 71 -115 -99 -44 71 9 -99 84 68 -115 -99 92 71 -119 -99 84 79 -115 -100 84 71 10 -99 84 71 -115 -99 88 71 -120 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 94 71 -119 21 84 71 -115 -99 84 71 11 -99 -44 71 -115 -99 88 71 -119 -103 84 71 -115 -99 84 71 9 -99 84 71 -115 -107 92 71 -119 -115 84 71 -115 -99 84 71 11 -99 84 71 -115 -99 92 71 -120 -115 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 92 71 -119 -99 84 -57 13 -97 84 71 11 -99 -44 71 -115 -99 92 71 -103 -99 84 71 -115 -99 84 69 -119 -99 84 68 -115 -99 92 71 -119 -115 84 79 -115 -100 84 71 -118 -99 84 71 13 -99 88 71 -120 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 94 71 -119 21 85 71 -123 -67 84 71 11 -99 -42 71 -115 -99 90 71 -103 -97 84 71 -115 -99 92 71 9 -99 92 71 -115 -99 92 71 -55 -99 84 71 -115 -99 84 71 11 -35 84 71 -115 -103 94 79 -120 -99 84 71 -115 -99 84 71 9 -115 84 79 -99 -99 94 71 -119 -99 84 69 -115 -99 84 71 11 -99 -44 71 -115 -99 92 71 -119 -99 84 7 -115 -99 -44 71 9 -100 84 68 -115 -99 92 71 -119 -99 84 79 -115 -100 84 71 10 -99 84 71 -115 -99 89 71 -120 -99 84 71 -115 -103 84 71 9 -115 84 71 -99 -103 94 71 -119 -75 84 71 13 -99 92 71 11 -99 -44 7 -115 -99 88 71 -119 -103 84 71 -115 -99 92 71 9 -99 84 71 -115 -107 92 71 -119 -115 116 71 -83 -35 84 71 11 -99 84 71 -115 -35 92 71 -120 -115 84 71 -115 -99 84 69 9 -115 84 71 -99 -99 92 71 -119 -107 84 -57 9 -65 84 71 11 -99 -44 87 -115 -35 92 71 -103 -99 84 103 -115 -99 84 69 -119 -99 84 68 -115 -67 92 79 -119 -115 84 79 -115 -100 84 71 -118 -99 84 71 13 -99 88 71 -120 -99 84 71 -116 -99 84 71 9 -113 84 71 -99 -99 94 71 -119 21 85 71 -91 -3 84 71 -117 -99 -42 71 -115 -99 122 71 -119 -99 84 71 -115 -99 84 71 9 -97 84 71 -115 -99 92 71 -119 -99 84 71 -115 -99 84 71 11 -107 84 71 -115 -99 92 71 -120 -99 84 71 -115 -99 80 71 9 -115 84 71 -99 -99 92 7 -119 -99 84 71 -115 -99 84 71 11 -99 -44 71 -115 -99 92 71 -119 -97 84 -57 -115 -99 -44 67 9 -99 84 68 -115 -99 88 71 9 -99 84 79 -115 -100 84 71 10 -99 84 71 -115 -99 88 71 -120 -99 84 68 -115 -99 86 71 9 -113 84 71 -35 -99 95 71 -119 21 84 71 -115 -67 84 71 11 -99 -44 71 -115 29 88 71 -119 -103 84 71 -115 -99 84 71 9 -99 20 71 -115 -107 92 71 -119 -123 84 71 -115 -99 84 71 11 -99 84 71 -115 -99 92 71 -120 -115 84 71 -115 -99 28 71 9 -115 84 71 -99 -99 92 71 -119 -99 84 -57 13 -97 84 71 11 -99 -44 71 -115 -99 92 69 -103 -99 -44 71 -115 -99 84 69 -119 -99 84 68 -115 -99 92 71 -71 -115 92 79 -115 -100 84 71 -118 -99 84 71 13 -67 88 71 -120 -99 84 71 -115 -99 84 71 1 -115 84 71 -99 -99 94 70 -119 29 85 71 -123 -67 84 71 15 -97 -42 71 -115 -99 90 71 -104 -97 84 71 -115 29 92 71 9 29 92 71 -115 -35 92 71 -55 -99 84 71 -115 -99 84 71 11 -35 84 71 -115 -103 94 79 -116 -99 -44 71 -115 -99 84 71 9 -115 84 79 -99 -99 94 71 -119 -99 84 69 -115 -99 84 71 11 -99 -44 71 -115 -99 92 71 -119 -99 84 7 -83 -99 -44 15 9 -100 84 68 -115 -99 92 71 -119 -99 21 79 9 -100 84 71 10 -99 84 71 -115 -99 89 71 -120 -99 84 71 -115 -101 84 71 9 -115 84 71 -99 -103 92 71 -119 -75 84 103 13 -99 92 71 9 -99 -44 3 -115 -99 88 71 -119 -103 84 71 -115 -99 92 71 9 -99 84 71 -115 -108 92 71 -119 -115 116 71 -81 -35 84 71 11 -99 84 71 -115 -99 92 71 -120 -115 84 71 -99 -99 84 69 9 -115 85 71 -99 -99 92 79 -119 -107 84 -57 9 -65 84 71 11 -99 -44 87 -115 -35 92 67 -103 -103 84 103 -115 -99 84 69 -119 -97 84 68 -115 -67 92 79 -119 -103 84 79 -115 -100 84 71 -118 -115 84 7 13 -99 88 71 -120 -99 84 71 -116 -99 68 71 9 -113 84 103 -99 -99 94 71 -119 21 81 71 37 -3 84 71 -117 -99 -42 67 -115 -99 122 79 -116 -99 84 71 -115 -99 84 71 9 -99 84 71 -119 29 92 79 -119 -99 84 71 -115 -99 68 69 11 -99 84 71 -115 -99 92 71 13 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 92 71 -115 -35 84 67 12 -99 84 71 11 -99 -44 71 -115 -99 92 71 -119 -35 84 71 -115 -99 -44 -57 9 -99 84 68 -99 -99 92 67 -119 -100 80 79 -115 -100 84 71 10 -99 84 71 -115 -99 88 71 -120 -99 84 71 -115 -99 84 71 9 -115 92 71 -99 -99 95 71 -119 21 92 87 -115 -99 84 71 41 -99 -44 71 -115 -99 88 71 -119 -103 85 71 -115 -99 84 71 9 -99 84 79 -115 -107 92 71 -127 -115 84 71 -113 -99 92 71 11 -99 84 71 -115 -99 92 71 -120 13 84 71 -115 -99 84 71 9 -123 84 71 -99 -123 92 71 -119 -99 84 -49 77 -97 84 71 11 -115 -44 7 -115 -99 92 71 -103 -99 84 -57 -115 -99 84 69 -119 -99 84 68 -115 -99 88 71 -119 -119 84 79 -115 -100 84 7 -118 -99 84 71 13 -99 88 71 -120 -99 84 71 -115 -99 84 71 1 -115 84 71 -99 29 94 71 -119 21 85 71 -123 -67 84 71 11 -99 -42 71 -115 -99 90 71 -103 -97 84 71 -115 -99 92 71 9 -99 92 71 -115 -99 92 71 -55 -99 84 7 -115 -99 84 71 11 -35 84 71 -115 -103 94 79 -120 29 80 71 -113 -99 70 71 9 -115 84 79 -99 -97 94 71 -119 -100 84 69 -115 -99 84 71 11 -99 -44 71 -115 -99 92 71 -119 -99 84 6 -115 -99 -44 71 9 -100 84 68 -115 -99 92 71 -117 -99 84 -49 -115 -100 84 77 10 -99 84 71 -115 -99 89 71 -116 -115 85 71 -115 -103 84 71 9 -115 84 71 -99 -103 94 71 -119 -75 84 71 13 -99 93 71 11 -107 -44 7 -115 -99 88 71 -119 -103 84 71 -55 -99 92 71 9 -99 84 71 -115 -107 92 71 -119 -115 116 71 -83 -39 84 103 11 -99 84 71 -115 -35 92 71 -120 -115 84 71 -115 -99 84 69 9 -115 80 71 -99 -99 92 71 -119 -111 84 -57 9 -65 84 71 11 -99 -44 87 -115 -35 92 71 -103 -99 84 103 -115 -99 84 101 -119 -99 80 68 -51 -67 -36 15 -119 -115 84 79 -115 -100 84 71 -118 -99 84 71 45 -99 88 71 -120 -99 84 71 -116 -99 84 69 9 -49 84 71 -107 -99 94 103 -119 21 85 71 -91 -3 84 71 -101 -99 -42 71 -115 -99 58 67 -119 -99 84 71 -115 -99 86 87 9 -97 84 71 -115 -99 92 71 -119 -99 84 71 -115 -99 84 71 13 -107 84 71 -115 -99 92 70 -120 -99 84 71 -115 -99 80 71 9 -115 84 71 29 -99 92 7 -119 -99 116 119 -115 -97 84 -57 11 -99 -43 79 -115 -67 28 71 -119 -97 80 -57 -115 -99 -44 67 9 -99 68 68 -115 -99 24 103 9 -99 84 79 -115 -100 84 71 10 -99 84 71 -115 -99 90 -57 -120 -99 84 68 -115 -99 86 71 9 -113 84 71 -35 -99 95 71 9 21 84 71 -115 -67 84 71 -118 -99 -44 71 -115 -99 88 71 -119 -103 84 71 -115 -99 84 71 9 -99 20 71 -115 -107 92 71 25 -123 84 70 -115 -99 84 71 11 -99 84 71 -115 -99 -36 71 -120 -124 84 71 -115 -99 28 71 9 -115 84 71 -99 -115 92 87 -119 -99 -44 -57 13 -97 84 71 11 -99 -44 71 -115 -99 92 69 -103 -99 -44 71 -115 -99 84 69 -119 -99 84 68 -115 -99 92 71 -69 -115 92 79 -115 -100 84 71 -118 -99 84 71 13 -67 80 71 -120 -67 84 71 -115 -99 84 71 1 -115 92 71 -99 -99 94 70 -119 29 85 79 -123 -67 68 71 15 -98 -42 71 -115 -99 90 71 -104 -97 84 71 -115 29 92 71 9 29 92 71 -115 -35 92 71 -55 -99 84 71 -115 -99 84 71 11 -35 84 71 -115 -103 94 75 -116 -99 -44 67 -115 -99 84 7 9 -115 84 79 -99 -67 94 71 -119 -99 84 69 -51 -99 84 71 11 -99 -44 71 -55 -99 92 79 -119 -35 84 7 -83 -99 -44 14 9 -100 84 68 -115 -99 28 71 -55 -99 21 78 10 -100 84 71 42 -99 68 71 -115 -99 89 71 -120 -99 84 71 -115 -101 84 71 9 -123 84 71 -99 -103 92 71 -119 53 84 103 13 -99 92 71 9 -107 -44 3 -115 -99 88 71 -115 -103 84 71 -115 -99 124 71 9 -99 20 71 13 -108 93 71 -119 -115 116 71 -81 -35 84 71 91 -99 84 71 -116 -107 92 71 -120 -115 84 71 -99 -115 84 69 9 -115 85 71 -107 -99 92 79 -119 -107 84 -57 9 -97 84 71 11 -99 -44 87 -115 93 92 67 -103 -103 84 103 -115 -99 84 69 -119 -97 116 68 -115 -75 92 79 -119 57 84 79 -119 -100 84 71 -118 -115 84 7 13 -107 88 71 -120 -67 84 71 -116 -99 68 79 9 -113 84 103 -99 -99 94 71 -119 21 83 71 37 -3 84 71 -117 61 -42 65 -100 -99 122 71 -119 -35 84 71 -115 -99 84 71 9 -35 84 7 -115 -99 92 71 -119 -99 84 71 -99 -99 52 71 11 -99 84 71 -115 -99 92 71 -119 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 92 87 -119 -99 84 71 -115 -115 85 71 11 -99 -44 71 -83 -99 92 71 -119 -99 84 71 -113 -99 -44 71 25 -99 84 68 -115 -99 84 71 -119 -99 84 79 -115 -100 84 103 10 -99 84 71 -119 -99 88 71 -120 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 29 94 71 -119 21 116 71 -115 -107 84 71 11 -99 -44 71 -115 -99 88 71 -119 -103 84 71 -115 -99 84 -57 13 -99 84 71 -115 -107 93 71 -119 -115 84 71 -123 -99 84 87 11 25 84 71 -115 -97 92 71 -120 -115 84 71 -115 -67 -44 71 9 -115 84 79 -99 -99 92 71 -119 -107 84 -61 13 -97 84 71 11 -100 -44 -57 -115 -99 92 71 -103 -99 86 71 -115 -99 68 69 -119 -99 84 68 -115 -99 92 71 -119 -115 84 79 -115 -100 84 71 -118 -107 84 71 13 -99 -40 71 -120 -99 84 71 -115 -99 84 71 9 -115 84 71 -99 -99 94 71 -119 21 85 71 -123 -67 84 69 11 -99 -42 71 -115 -107 90 71 -111 -97 84 71 13 -99 92 71 9 -107 84 71 -115 -99 92 71 -55 -99 80 71 -115 -99 84 7 11 -35 84 87 -115 -103 94 79 -120 29 84 71 -115 -115 84 103 9 -115 84 79 -103 -99 -34 71 -119 -99 84 69 -115 -99 84 79 11 -115 -44 67 -115 -99 28 71 -119 -103 20 7 -51 -99 -44 71 25 -100 64 68 -115 -99 92 71 -119 -99 84 79 -115 -100 84 103 10 -99 84 71 -115 -99 89 71 -120 -99 84 71 -115 -103 84 71 9 -115 84 71 -99 -71 94 71 -119 -75 20 71 13 -99 92 71 27 -99 -44 7 -115 -99 88 71 -119 -103 84 71 -115 -99 92 71 9 -99 84 71 -115 -107 92 71 -119 -115 116 71 -83 -35 80 71 11 -99 84 71 -115 -35 92 71 -120 13 84 71 -115 -99 84 69 9 -119 84 71 -99 -107 93 71 -119 -107 84 -57 9 63 84 71 11 -99 -12 87 -115 -35 92 71 -103 -99 84 103 -51 29 84 69 -117 -99 84 69 -115 -67 92 79 -127 -115 68 95 -115 -116 84 71 -118 -97 84 71 13 -99 88 71 -120 -99 84 71 -116 -99 84 71 9 -117 84 71 -99 -99 94 71 -119 21 85 71 -91 -11 84 71 -101 -99 -42 71 -115 -99 122 71 -87 -99 84 71 -115 -99 84 71 9 -97 84 71 -115 -99 92 71 -119 -99 84 71 -115 -99 84 71 9 -107 84 71 -115 -105 88 71 -56 -99 68 71 -115 -99 112 71 9 -115 84 103 -99 -99 92 7 -119 -99 84 67 -115 -99 84 71 11 -99 -44 69 -115 -99 92 71 -119 -97 84 71 -115 -99 -44 71 9 29 84 68 -115 -99 88 71 11 -99 84 79 -115 -100 -44 71 10 -99 84 71 -115 -99 88 71 -120 -99 84 68 -115 -99 70 69 9 -113 84 71 -35 -99 91 71 -119 85 84 103 -99 -68 84 71 11 -99 -44 71 -115 29 88 71 9 -103 84 71 -115 -99 84 71 9 -35 20 71 -83 -99 92 71 -119 -123 84 71 -115 -99 84 71 11 -99 84 71 -115 -99 93 67 -120 -51 84 71 -115 -99 28 71 9 -115 84 71 -67 -99 92 71 -119 -99 85 -57 13 -97 84 71 11 -99 -44 71 -115 -99 92 77 -119 -99 -44 71 -115 -99 84 5 -119 -99 84 68 -115 -115 92 71 -67 -119 92 79 13 -100 84 71 -114 -98 68 71 13 -83 72 71 -120 -99 84 71 -115 -99 84 71 1 -115 84 103 -99 -99 94 6 -119 29 85 71 -123 -67 84 71 15 -97 -42 71 -99 -99 26 71 -104 -98 84 71 -115 29 92 71 9 29 92 71 -115 -35 92 71 -55 -99 84 70 -115 -99 -44 71 11 -35 84 71 -119 -103 94 79 -116 -103 -60 71 -115 -99 84 79 9 -115 84 71 -67 -99 94 71 -119 -99 81 69 -115 -99 84 -57 11 -99 -44 71 -115 -99 92 71 -119 -99 84 23 -83 -99 -44 15 9 -100 84 68 -115 -99 92 71 -87 -99 21 95 9 -100 84 71 10 -99 84 71 -115 -99 89 71 -120 -99 84 77 -115 -101 84 71 25 -115 84 71 -107 -119 92 71 -119 -75 84 103 13 -100 92 71 9 -99 -44 3 -115 -99 -40 -57 -119 -103 84 71 -115 -99 92 71 9 -99 84 71 -115 -108 92 71 -119 -115 116 -57 -81 -35 84 71 11 -99 84 71 -116 -99 92 71 8 -115 84 71 -99 -99 84 69 9 -115 85 79 -99 -99 124 79 -119 -107 86 -57 9 -65 84 71 11 -99 -44 87 -83 -35 92 67 -43 -103 84 103 -115 -99 84 5 -119 -97 84 68 -115 -67 92 79 -119 -103 84 79 -116 -100 84 71 -82 -115 84 7 13 -99 88 87 -120 -99 81 71 -116 -99 68 71 41 -113 84 103 -99 -99 90 71 -115 -107 81 71 33 -3 84 71 -117 -99 -42 67 -99 -97 122 79 -84 -99 84 71 -114 -99 84 71 9 -99 84 71 -119 29 92 79 -119 -99 84 71 -115 -99 68 69 11 -99 80 71 -115 -99 92 71 13 -99 84 71 -115 -99 116 71 9 -115 84 71 -99 -99 28 71 -115 -35 84 67 12 -99 84 71 11 -99 -44 71 -115 -67 92 71 -119 -35 84 71 -115 -115 -44 -57 9 -99 92 68 -99 -99 92 67 -119 -100 80 79 -115 -98 84 71 10 -99 84 71 -115 -99 88 71 -120 -99 92 71 -115 -99 84 71 9 -115 92 71 -99 -103 95 71 -119 -107 28 87 -115 -99 84 71 41 -99 -60 71 -115 -99 89 71 -119 -103 85 71 -115 -99 84 71 9 -99 84 79 -115 -107 92 71 -127 -115 84 71 -117 -99 88 71 11 -99 84 71 -83 -115 92 71 -120 13 84 71 -115 -99 84 71 9 -123 84 71 -99 -123 92 66 -119 -100 84 -49 109 -97 84 71 11 -115 -44 7 -115 -99 92 71 -103 -99 84 -57 -115 -99 20 69 -56 -99 84 68 -115 -99 88 71 -119 -119 20 79 -115 -108 84 7 -118 -99 84 71 13 -99 88 71 -120 -97 84 71 -115 -99 84 71 1 -115 84 79 -99 29 94 71 -119 21 85 71 -123 -67 84 71 11 -99 -42 71 -115 -99 74 71 -39 -97 84 71 -115 -35 92 71 9 -99 80 71 -115 -99 28 71 -55 -99 84 7 -115 -99 84 71 11 -35 84 70 -115 -104 94 79 -120 29 80 103 -113 -99 70 71 9 -115 84 79 -99 -97 90 87 -119 -100 84 69 -115 -99 84 69 11 -99 -44 71 -115 -99 92 71 -119 -99 84 6 -115 -99 -44 6 9 -100 84 68 -115 -99 92 71 -117 -99 112 -49 -115 -100 84 77 10 -99 68 71 -115 -99 89 71 -116 -115 85 71 -115 -103 84 71 9 -115 84 71 -99 -79 94 71 -119 -75 84 71 13 -99 93 71 11 -105 -44 7 -115 -99 88 71 -119 -103 84 71 -55 -99 93 71 9 -99 84 71 -115 -107 94 -57 -119 -115 116 71 -83 89 84 103 11 -99 92 71 -115 -35 92 71 -120 -115 84 69 -115 -99 84 85 9 -115 -48 79 -99 -99 94 71 -119 -107 84 -57 9 -65 84 -57 11 -99 -44 87 -115 -35 92 87 -103 -99 84 103 -115 -99 84 101 -119 -99 88 68 -51 -67 -36 15 -119 -115 84 71 -115 -99 84 71 -114 -99 80 71 45 -99 88 71 -120 -99 84 71 -116 -67 84 69 9 -49 84 71 -107 -99 94 103 -119 21 85 79 -91 -3 84 71 -101 -99 -42 71 -115 -99 58 67 -119 -99 84 -57 -115 -115 86 87 9 -97 84 71 -115 -99 92 -57 -87 -97 84 71 -115 -99 84 67 13 -107 84 71 -115 -99 92 102 -120 -99 84 71 -115 -99 88 71 9 -116 84 71 29 -35 92 7 -119 -99 116 119 -115 -97 84 -57 11 -99 -43 79 -115 -67 28 71 -119 -97 80 -57 13 -99 -48 67 9 -99 68 68 -115 -99 24 102 9 -99 86 79 -115 -100 84 71 10 -99 20 71 -115 -99 90 -57 -120 -99 84 68 -115 -99 86 71 9 -113 -44 71 -35 -103 95 71 9 5 84 -57 -115 -67 84 87 -118 -99 -44 71 -115 -99 88 71 -120 -103 84 71 -115 -99 84 71 9 -99 20 71 -83 -107 92 71 25 -123 20 70 -115 -99 84 71 11 -115 20 71 -115 -99 -36 71 -120 -124 84 71 -115 -99 28 71 9 -115 84 71 -99 -83 92 71 -119 -99 -44 -57 13 -97 84 71 11 -99 -108 103 -115 -99 92 69 -103 -35 -44 71 -115 -99 84 69 -103 -99 80 68 -115 -99 92 71 -69 -115 92 79 -115 -104 84 71 -118 -99 84 78 13 -67 80 71 -116 -67 84 71 -116 -99 84 71 1 -115 92 71 -99 -99 94 70 -119 73 85 71 -59 -67 68 7 15 -98 -42 71 -115 -99 90 71 -104 -97 84 71 -115 29 92 69 9 29 92 71 -115 -35 92 71 -55 -99 84 71 13 -99 84 71 11 -35 84 71 -99 -103 90 75 -116 -99 -44 67 -115 -99 84 7 9 -115 84 79 -99 -67 94 70 -119 93 84 69 -51 -99 84 71 43 -99 -44 7 -55 -99 92 79 -119 -36 84 7 -83 -103 -44 14 9 29 84 68 -115 -99 28 71 -23 -99 21 106 10 -98 84 71 42 -108 68 71 -115 -115 89 71 -120 -107 84 71 -115 -101 84 71 9 -123 92 -57 -99 -103 92 71 -119 53 84 99 13 -99 93 103 9 -105 -48 11 -115 -99 88 71 -115 -103 84 71 -115 -103 124 71 9 -99 20 7 13 -107 93 71 -119 -115 116 71 47 -35 92 71 91 -99 92 71 -116 -107 92 71 -120 -115 84 71 -99 -115 84 65 9 -115 85 71 -123 -99 92 71 -119 -107 84 -57 9 -33 84 71 11 -99 -44 87 -115 93 92 75 -103 -103 116 103 -115 -99 84 85 -119 -97 116 68 -115 -75 92 79 -119 57 84 79 -119 -100 84 71 -118 -115 84 7 13 -107 88 71 -120 -67 84 71 -116 -99 68 79 9 -113 84 103 -99 -99 94 71 -119 21 83 6 37 -19 84 87 -117 61 -41 67 -100 -103 122" char_array = char_string.split(' ') genome = [] genome_str = "" print len(char_array) for char in char_array: bitrep = BitArray('int:8=' + char).bin print "char:", char, bitrep genome_str += (str(bitrep)) for ch in genome_str: genome.append(int(ch)) # positive = int(char) + 256 # bin_str = str(bin(positive)[2:]) # over = len(bin_str) -8 # for ch in bin_str: # genome.append(int(ch)) print "length", len(genome) op_file = open("miguel_parsed.txt", "w") op_file.write(str(genome)) op_file.close()
def prepareInt8as1Bytes(self, i): """Converts i to a hex encoded('utf-8') byte string with a b' ' appended to the end.""" word = BitArray(int=i, length=8) b = word[0:8].hex.encode('utf-8') + b' ' return b
class MainWindow(tk.Tk): def __init__(self, mcu): tk.Tk.__init__(self) self.frame = tk.Frame(self) self.mcu = mcu self.reg_frame = tk.Frame(self.frame) self.regs = self.get_regs(self.reg_frame) self.consol = self.Consol(self.mcu, self.frame, self) self.buttons = self.Connector(self.mcu, self.frame) self.fileholder = self.FileHolder(self.mcu, self.frame) self.queue = queue.Queue() self.reg_frame.pack() self.frame.pack() self.task_running = False def get_regs(self, frame): regs = [] for reg in range(0x17): regs.append(self.Register(reg, frame)) return regs def read_regs(self): self._new_task(self._read_regs) def read_files(self): self._new_task(self.fileholder.read_files) def _task_done(self): if not self.queue.empty(): self.queue.get().start() else: self.task_running = False def _new_task(self, function): task = threading.Thread(target=function, args=(self._task_done, )) if self.queue.empty() and not self.task_running: self.task_running = True task.start() else: self.queue.put(task) def _read_regs(self, cb): for reg in self.regs: value = self.mcu.write('nrf._read_reg(%s)' % reg.reg) reg.set_val(int(value)) cb() from bitstring import BitArray BitArray(length=8) class Connector: def __init__(self, mcu, frame): self.frame = tk.Frame(frame) self.connect = tk.Button(self.frame, text="Connect", command=self._connect) self.disconnect = tk.Button(self.frame, text="Disconnect", command=self._disconnect) self.reset = tk.Button(self.frame, text="Reset", command=self._reset) self.ping = tk.Button(self.frame, text="Ping", command=self._ping) self.connect.grid(row=0, column=0) self.disconnect.grid(row=0, column=1) self.reset.grid(row=0, column=2) self.ping.grid(row=0, column=3) self.frame.pack() def _connect(self): pass def _disconnect(self): pass def _reset(self): pass def _ping(self): pass class FileHolder: def __init__(self, mcu, frame): self.mcu = mcu self.frame = tk.Frame(frame) self.title = tk.Label(self.frame, text='Files') self.title.pack() self.frame.pack(side='left') def read_files(self, cb): self.files = [] self.mcu.write('import os') dirs = self.mcu.write('os.listdir()') dirs = dirs[1:-1].split(',') for file_ in dirs: label = tk.Label(self.frame, text=file_.replace("'", '')) label.pack() self.files.append(label) cb() class Consol: def __init__(self, mcu, frame, root): self.mcu = mcu self.frame = tk.Frame(frame) self.c = tk.Entry(self.frame, width=60) self.btn = tk.Button(self.frame, text="Send", command=self._send) self.output = tk.Text(self.frame, width=80, height=10) self.c.grid(row=0, column=0) self.btn.grid(row=0, column=1) self.output.grid(row=1, columnspan=2) self.frame.pack() self.c.bind('<Control-KeyRelease-a>', self._mark) self.c.bind('<Return>', self._send) self.c.focus_set() def _mark(self, event): # select text event.widget.select_range(0, 'end') # move cursor to the end event.widget.icursor('end') def _send(self, *e): command = self._parse_cmd(self.c.get()) if command == 'clear': self.output.delete('1.0', 'end') else: res = self.mcu.write(command) self.output.insert('end', '\n' + res) self.c.delete(0, 'end') def _parse_cmd(self, data): return data class Register(): def __init__(self, reg, frame): self.reg = reg self.frame = tk.Frame(frame) self.label = tk.Label(self.frame, text='Reg %s' % hex(reg), width=10) self.int = tk.Label(self.frame, width=10) self.entry = tk.Entry(self.frame, width=20) self.label.grid(column=0, row=0) self.int.grid(column=1, row=0) self.entry.grid(column=2, row=0) self.frame.pack() def set_val(self, value): self.entry.delete(0, 'end') formated = str(bin(value))[2:].zfill(8) self.entry.insert('end', formated) self.int.config(text=str(value))
def getgps(old_dt): # k = sub.find('0x851200',bytealigned = True) # if len(k) == 0: # gps = 'N/A' # return gps try: sub.find('0x85000004', bytealigned=True) sub.pos += 32 #read 0x850000 - GPS Ver gpsver = sub.read(4 * 8) sub.pos += 32 #read 0x8501 - Latitude Ref (N or S) latref = BitArray(sub.read(8)) latref = latref.tobytes().decode('utf-8') sub.pos += 32 # read 0x8502 - latiture (6 chunks) l1 = sub.read(4 * 8).uint l2 = sub.read(4 * 8).uint l3 = sub.read(4 * 8).uint l4 = sub.read(4 * 8).uint l5 = sub.read(4 * 8).uint l6 = sub.read(4 * 8).uint if (l2 == 0 or l4 == 0 or l6 == 0): gps = 'N/A' return gps #write latitute string for text output lat = str(l1 / l2) + '°' + str(l3 / l4) + "'" + str( float(l5) / float(l6)) + '"' latdd = round((float(l1) / float(l2) + (float(l3) / float(l4)) / 60 + (float(l5) / float(l6) / (60 * 60)) * (-1 if latref in ['W', 'S'] else 1)), 7) sub.pos += 32 #read 0x8503 - longtitude ref (E or W) lonref = BitArray(sub.read(8)) lonref = lonref.tobytes().decode('utf-8') # read 0x8504 - lontgiture (6 chunks) sub.pos += 32 l1 = sub.read(4 * 8).uint l2 = sub.read(4 * 8).uint l3 = sub.read(4 * 8).uint l4 = sub.read(4 * 8).uint l5 = sub.read(4 * 8).uint l6 = sub.read(4 * 8).uint if (l2 == 0 or l4 == 0 or l6 == 0): gps = 'N/A' return gps #write latitute string for text output lon = str(float(l1) / float(l2)) + '°' + str( float(l3) / float(l4)) + "'" + str(float(l5) / float(l6)) + '"' londd = round((float(l1) / float(l2) + float(l3) / float(l4) / 60 + (float(l5) / float(l6) / (60 * 60)) * (-1 if lonref in ['W', 'S'] else 1)), 7) k = sub.find('0x85050001', bytealigned=True) if len(k) != 0: sub.pos += 32 #read 0x8505 - 1 bytes = AltitudeRef (0 = above sea level, 1 = below sea level) x8505 = sub.read(8).uint sub.pos += 32 #read 0x8506 - 8 bytes ([4]/[4]) - Altitude x8506_1 = sub.read(4 * 8).uint x8506_2 = sub.read(4 * 8).uint x8506 = str(float(x8506_1) / float(x8506_2)) else: x8505 = None sub.pos += 32 # read 0x8507 - timestamp (6 chunks) l1 = sub.read(4 * 8).uint l2 = sub.read(4 * 8).uint l3 = sub.read(4 * 8).uint l4 = sub.read(4 * 8).uint l5 = sub.read(4 * 8).uint l6 = sub.read(4 * 8).uint if (l2 == 0 or l4 == 0 or l6 == 0): gps = 'N/A' return gps #write timestamp for text output (hh:mm:ss.xxx) gpsts = str(int(float(l1) / float(l2))).zfill(2) + ':' + str( int(float(l3) / float(l4))).zfill(2) + ":" + str( int(float(l5) / float(l6))).zfill(2) #print (gpsts) sub.pos += 32 #read 0x8509 - GPS fix STATUS (not used yet) gpsfix = BitArray(sub.read(8)) gpsfix = gpsfix.tobytes().decode('utf-8') sub.pos += 32 # read 0x850a - GPS Measure mode (2 = 2D, 3 = 3D) - not used yet gpsmeasure = BitArray(sub.read(8)) gpsmeasure = gpsmeasure.tobytes().decode('utf-8') sub.pos += 32 #read 0x850b - 8 bytes ([4]/[4]) -- DOP -not used yet x850b_1 = sub.read(4 * 8).uint x850b_2 = sub.read(4 * 8).uint x850b = str(float(x850b_1) / float(x850b_2)) if sub.read(4 * 8) == '0x850c0001': #read 0x850c - 1 byte - SpeedRef (K = km/h, M = mph, N = knots) x850c = BitArray(sub.read(8)) x850c = x850c.tobytes().decode('utf-8') sub.pos += 32 #read 0x850d - 8 bytes ([4]/[4]???) - SPEED x850d_1 = sub.read(4 * 8).uint x850d_2 = sub.read(4 * 8).uint x850d = round(float(x850d_1) / float(x850d_2), 2) else: x850d = 'N/A' if sub.read(4 * 8) == '0x850e0001': #read 0x850e - 1 byte - TrackRef (Direction Reference, T = True direction, M = Magnetic direction) x850e = BitArray(sub.read(8)) x850e = x850e.tobytes().decode('utf-8') sub.pos += 32 #read 0x850f - Course 8 bytes ([4]/[4]) (degrees from 0.0 to 359.99) x850f_1 = sub.read(4 * 8).uint x850f_2 = sub.read(4 * 8).uint x850f = round(float(x850f_1) / float(x850f_2), 2) else: x850f = 'N/A' #write full lat + lon + timestamp for text output if latref == None or lonref == None: gps = 'N/A' else: gps = lat + str(latref) + ' ' + lon + str(lonref) + ' ' + gpsts # debug #gps = gps + '\n' +str(x8505) + ' ' + str(x8506) + ' ' + str(gpsfix) + ' ' + str(gpsmeasure) + ' ' + str(x850b) + ' ' + str(x850c) + ' ' + str(x850d) + ' ' + str(x850e) + ' ' + str(x850f) if x850d != 'N/A' or x850f != 'N/A': gps = gps + '\n' 'Speed: ' + str(x850d) + 'km/h Course: ' + str( x850f) k = sub.find('0x851d000a', bytealigned=True) sub.pos += 32 gpxdate = BitArray(sub.read(8 * 10)) gpxdate = gpxdate.tobytes().decode('utf-8') gpxdate = gpxdate.replace(':', '-') gpxdate = gpxdate + 'T' + gpsts + 'Z' dt = datetime.strptime(gpxdate, '%Y-%m-%dT%H:%M:%SZ') #print (lat,lon, x850d, x850f) #write GPX. if (args.gpx and 'ExifGPS'.encode() in exifchk) and old_dt < dt.timestamp(): if x8505 != None: gpx_point = gpxpy.gpx.GPXTrackPoint( latdd, londd, position_dilution=x850b, type_of_gpx_fix=(gpsmeasure + 'd'), elevation=(float(x8506) * (-1 if x8505 == 1 else 1)), time=datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)) else: gpx_point = gpxpy.gpx.GPXTrackPoint( latdd, londd, position_dilution=x850b, type_of_gpx_fix=(gpsmeasure + 'd'), time=datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)) gpx_segment.points.append(gpx_point) #GPX EXT TEST AREA namespace = '{gpxtx}' nsmap = {'gpxtpx': namespace[1:-1]} # root = mod_etree.Element(namespace + 'TrackPointExtension') subnode1 = mod_etree.SubElement(root, namespace + 'speed') subnode2 = mod_etree.SubElement(root, namespace + 'course') if x850d != 'N/A' and x850c == 'K': subnode1.text = str(round(x850d_1 / x850d_2 / 3.6, 2)) elif x850d != 'N/A' and x850c == 'M': subnode1.text = str(round(x850d_1 / x850d_2 / 2.23694, 2)) elif x850d != 'N/A' and x850c == 'N': subnode1.text = str(round(x850d_1 / x850d_2 / 1.94384, 2)) if x850f != 'N/A': subnode2.text = str(x850f) gpx.nsmap = nsmap if x850d != 'N/A' or x850f != 'N/A': gpx_point.extensions.append(root) old_dt = dt.timestamp() except (bitstring.ReadError, UnicodeDecodeError): return 'N/A' return gps, old_dt
rects = axes.bar(index,dataset,bar_width) plt.xticks(index + bar_width/2.0, ("A", "B", "A'", "B'", "C4", "C5", "C6", "C7")) s = serial.Serial("COM1",19200,bytesize=serial.SEVENBITS,stopbits=serial.STOPBITS_ONE) buffer = [] count = 0 alldata = np.zeros([8,10]) while True: index = count%10 count += 1 print "index = ", index try: data = s.read() if data == "\x7f": bits = BitArray(bytes=buffer) # test length: if bits.length == 8*40: time.sleep(0.1) a, b, c, d, c4, c5, c6, c7 = bits.unpack('uintle:40,uintle:40,uintle:40,uintle:40,uintle:40,uintle:40,uintle:40,uintle:40') #print a, b, c, d, c4, c5, c6, c7 newdata = np.array((a, b, c, d, c4, c5, c6, c7)) alldata[:,index] = newdata if index == 0: print alldata # update plot every 10 shots for rect, h in zip(rects, alldata.mean(axis=1)): rect.set_height(h) axes.relim() axes.autoscale_view(True,True,True)
from dahuffman import HuffmanCodec from bitstring import BitArray from math import ceil, floor, log import cPickle as pickle OFFSET_ZERO = BitArray(bin='0') OFFSET_ONE = BitArray(bin='1') MAX_DATA_N = 15 def get_decimal_places(d): r = d.split(".") if len(r) > 1: return len(r[1]) return 0 class TinyCompressor: """This class holds data and methods for a data compressor using LEC Algorithm""" table = {} decode_table = {} eof = 0 __first_data = [] __previous_data = [] __data = [] __data_ns = [] __decimal_places = [] __strings_table = {}
import numpy as np import struct import pandas as pd import beacontools from beacontools import parse_packet from converters import BinToFloat, BinToInt from numpy import dtype from bitstring import BitArray test = b"5\x01\'\x02\xfd\x02/\x02e\x01%\xfd8\xc8Xn<\xc3" print(BitArray(test).bin[:1]) def chunker(seq, size): return (seq[pos:pos + size] for pos in range(0, len(seq), size)) def test_bin_float_converstion(): val = 100 test = struct.pack(">f", val) binary = float_to_bin(val) print(binary) print(BinToFloat().process(test)) print(struct.unpack(">f", test)) print(BinToFloat().process(test, True)) print(struct.unpack("f", test)) def test_bin_int_converstion(): print()
def parse_domain_link(data, position): length = int(BitArray(position).bin[2:], 2) domain, count = parse_domain(data, length) return 1, domain
def is_full(board): t_board = board[0:area] o_board = board[area:2 * area] return t_board | o_board == BitArray('0b1') * area
import tensorflow as tf import numpy as np import pandas as pd import matplotlib.pyplot as plt from bitstring import BitArray with tf.Graph().as_default(): with tf.Session() as sess: map_string = "484_561_459_322_64_158_41_315_384_437_192_510_504_534_308_334_487_128_207" region_ids = [int(x) for x in map_string.split("_")] print(region_ids) fn = 'binary_arrays/' + str(region_ids[0]) + '.txt' with open(fn, 'r') as bits: bits_string = bits.read() map_bin = BitArray(bin=bits_string) all_or = map_bin for i in region_ids: fn = 'binary_arrays/' + str(i) + '.txt' with open(fn, 'r') as bits: bits_string = bits.read() bit_array = BitArray(bin=bits_string) all_or = all_or | bit_array print(all_or.count("1")) bit_array = [int(x) for x in list(str(all_or.bin))]
def bytes_to_board(data): a = BitArray() a.bytes = data.encode('ISO-8859-1') return a
def parse(cls, address, data): '''Used to parse data received from RuuviTag. Currently supports versions 3 and 5 of the protocol. Arguments: address (str): MAC address of RuuviTag. data (bytes): received data in bytes. ''' b = BitArray(bytes=data) # Try to find protocol version 3 # https://github.com/ruuvi/ruuvi-sensor-protocols#data-format-3-protocol-specification if b.find('0xFF990403'): # If it's found, parse data b = list(b.split('0xFF990403', count=2))[-1] _, humidity, temperature, temperature_fraction, pressure, \ accel_x, accel_y, accel_z, battery_voltage = b.unpack( # Ignore the packet type and manufacturer specs, # as they've been handled before 'uint:32,' + # Parse the actual payload 'uint:8, int:8, uint:8, uint:16,' + 'int:16, int:16, int:16, uint:16') # ... and return an instance of the calling class return cls(address, 3, temperature=float(temperature) + temperature_fraction / 100.0, humidity=humidity / 2.0, pressure=(pressure + 50000) / 100.0, acceleration_x=accel_x / 1000.0, acceleration_y=accel_y / 1000.0, acceleration_z=accel_z / 1000.0, battery_voltage=battery_voltage / 1000.0) # Try to find protocol version 5 # https://github.com/ruuvi/ruuvi-sensor-protocols#data-format-5-protocol-specification if b.find('0xFF990405'): # If it's found, parse data b = list(b.split('0xFF990405', count=2))[-1] _, temperature, humidity, pressure, \ accel_x, accel_y, accel_z, \ battery_voltage, tx_power, \ movement_counter, measurement_sequence, mac = b.unpack( # Ignore the packet type and manufacturer specs, # as they've been handled before 'uint:32,' + # Parse the actual payload 'int:16, uint:16, uint:16,' + 'int:16, int:16, int:16,' + 'uint:11, uint:5,' + 'uint:8, uint:16, uint:48') # Not sure what to do with MAC at the moment? # Maybe compare it to the one received by btle and # raise an exception if doesn't match? mac = '%x' % mac mac = ':'.join(mac[i:i + 2] for i in range(0, 12, 2)) # ... and return an instance of the calling class return cls(address, 5, temperature=float(temperature) * 0.005, humidity=humidity * 0.0025, pressure=(pressure + 50000) / 100.0, acceleration_x=accel_x / 1000.0, acceleration_y=accel_y / 1000.0, acceleration_z=accel_z / 1000.0, battery_voltage=(battery_voltage + 1600) / 1000.0, tx_power=-40 + tx_power, movement_counter=movement_counter, measurement_sequence=measurement_sequence)
def direct_mapping(self, address, write=0, value=-1, bytes_=4, unsigned_=0): address = BitArray(int=address, length=32).bin index = address[self.tag_bits:self.tag_bits + self.block_bits] if (write == 1): # if index in self.cache_list.keys() and (self.cache_list[index][0] == address[0:self.tag_bits]): self.cache_list[index][ 1 + int(address[self.tag_bits + self.block_bits:30])] = self.to_be_written(value) self.memory_object.writeWord(int(address, 2), value) return if index in self.cache_list.keys(): if (self.cache_list[index][0] == address[0:self.tag_bits] ): #tag field print('cache hit') return self.cache_list[index][1 + int(address[self.tag_bits + self.block_bits:30])] else: print('cache miss') self.cache_list[index][0] = address[0:self.tag_bits] zero = '' for i in range(self.word_bits + 2): zero += '0' temp_address = int(address[:self.tag_bits + self.block_bits] + zero) for i in range(self.block_size): value = self.memory_object.readWord(temp_address) self.cache_list[index][1 + i] = self.to_be_written(value) temp_address += 4 return self.return_value( self.cache_list[index][1 + int(address[self.tag_bits + self.block_bits:30])], bytes_, unsigned_) else: self.cache_list[index] = [] self.cache_list[index].append(address[0:self.tag_bits]) zero = '' for i in range(self.word_bits + 2): zero += '0' temp_address = int( address[:self.tag_bits + self.block_bits] + zero, 2) for i in range(self.block_size): value = self.memory_object.readWord(temp_address) self.cache_list[index].append(self.to_be_written(value)) temp_address += 4 return self.return_value( self.cache_list[index][1 + int(address[self.tag_bits + self.block_bits:30])], bytes_, unsigned_)
def alu(self,operation): print("\n|--------- (ALU Part)Execution of the instruction----------|\n") print("OP:",operation) if operation == "add": if self.muxB == 0: self.RZ = self.RA + self.RB #add if self.muxB == 1: self.RZ = self.RA + self.imm #addi elif operation == "mul": self.RZ = self.RA * self.RB elif operation == "sub": self.RZ = self.RA - self.RB elif operation == "or": if self.muxB == 0: self.RZ = self.RA | self.RB #or elif self.muxB == 1: self.RZ = self.RA | self.imm #ori elif operation == "rem": self.RZ = self.RA % self.RB elif operation == "xor": self.RZ = self.RA ^ self.RB elif operation == "div": self.RZ = self.RA // self.RB elif operation == "srl": self.RZ = BitArray(int=self.RA, length=32) >> self.RB self.RZ = self.RZ.int elif operation == "sra": self.RZ = self.RA >> self.RB elif operation == "and": if self.muxB == 0: self.RZ = self.RA & self.RB #and elif self.muxB == 1: self.RZ = self.RA & self.imm #andi elif operation == "sll": self.RZ = BitArray(int=self.RA, length=32) << self.RB self.RZ = self.RZ.int elif operation == "slt": if self.RA < self.RB : self.RZ = 1 else : self.RZ = 0 elif operation == "jalr": self.PC_temp = self.PC self.PC = self.RA + self.imm elif operation == "beq": if self.RA == self.RB: self.PC = self.PC - 4 + self.imm elif operation == "bge": if self.RA >= self.RB: self.PC = self.PC - 4 + self.imm elif operation == "blt": if self.RA < self.RB: self.PC = self.PC - 4 + self.imm elif operation == "bne": if self.RA != self.RB: self.PC = self.PC - 4 + self.imm elif operation == "auipc": self.RZ = self.PC - 4 + self.imm elif operation == "jal": self.PC_temp = self.PC self.PC = self.PC - 4 + self.imm else : print("no operation found in the AlU part") self.memoryAccess()
def __init__(self, x, y, height, weight, rocky): self.x = BitArray('0b' + bin(x).lstrip('0b').zfill(8)) self.y = BitArray('0b' + bin(y).lstrip('0b').zfill(8)) self.height = BitArray('0b' + bin(height).lstrip('0b').zfill(4)) self.weight = BitArray('0b' + bin(weight).lstrip('0b').zfill(4)) self.rocky = BitArray('0b' + bin(rocky).lstrip('0b').zfill(4))