def add_msdu(self, msdu, msdu_len=-1): # Default msdu len if msdu_len == -1: msdu_len = len(msdu) mpdu_len = msdu_len + len(self.dot11hdr) + 4 # msdu + mac80211 + FCS if mpdu_len % 4 != 0: padding = "\x00" * (4 - (mpdu_len % 4)) # Align to 4 octets else: padding = "" mpdu_len <<= 4 crc_fun = crcmod.mkCrcFun(0b100000111, rev=True, initCrc=0x00, xorOut=0xFF) crc = crc_fun(struct.pack('<H', mpdu_len)) maccrc = dot11crc(str(self.dot11hdr / msdu)) delim_sig = 0x4E #print('a-mpdu: len %d crc %02x delim %02x' % (mpdu_len >> 4, crc, delim_sig)) #hexdump(maccrc) ampdu_header = struct.pack('<HBB', mpdu_len, crc, delim_sig) #hexdump(ampdu_header) self.data = self.data / ampdu_header / self.dot11hdr / msdu / maccrc / padding self.num_subframes += 1
def probe_response(): rt = RadioTap(len=18, present='Flags+Rate+Channel+dBm_AntSignal+Antenna', notdecoded='\x00\x6c' + get_frequency(CHANNEL) + '\xc0\x00\xc0\x01\x00\x00') beacon_packet = Dot11(subtype=5, addr1='ff:ff:ff:ff:ff:ff', addr2="be:da:de:ad:be:ef", addr3="be:da:de:ad:be:ef", SC=0x3060) \ / Dot11ProbeResp(timestamp=time.time(), beacon_interval=0x0064, cap=0x2104) \ / Dot11Elt(ID='SSID', info="injected SSID") \ / Dot11Elt(ID='Rates', info=AP_RATES) \ / Dot11Elt(ID='DSset', info=chr(1)) # Update sequence number beacon_packet.SC = 0x3060 mpdu_len = len(beacon_packet) + 4 if mpdu_len % 4 != 0: padding = "\x00" * (4 - (mpdu_len % 4)) # Align to 4 octets else: padding = "" mpdu_len <<= 4 crc_fun = crcmod.mkCrcFun(0b100000111, rev=True, initCrc=0x00, xorOut=0xFF) crc = crc_fun(struct.pack('<H', mpdu_len)) maccrc = dot11crc(str(beacon_packet)) delim_sig = 0x4E #print('a-mpdu: len %d crc %02x delim %02x' % (mpdu_len >> 4, crc, delim_sig)) #hexdump(maccrc) ampdu_header = struct.pack('<HBB', mpdu_len, crc, delim_sig) #hexdump(ampdu_header) data = ampdu_header / beacon_packet / maccrc / padding data /= "\x00\x00\x20\x4e" * 8 data = str(data) return data
def read(self, length): preamble = ["\xFF", "\xFA"] input = [0x00, 0x00] input[1] = self.ser.read(1) while True: if input == preamble: break else: input[0] = input[1] input[1] = self.ser.read(1) while self.ser.inWaiting() < length + 2: pass # Get data data = self.ser.read(length) # Get checksum input = self.ser.read(2) checksum = struct.unpack("H", input)[0] # Verify checksum crc16 = crcmod.mkCrcFun(0x11021, 0xFFFF, True) calcChecksum = crc16(data) calcChecksum = (~calcChecksum) % 2 ** 16 # convert to uint16_t if checksum != calcChecksum: print "Failed checksum." return return data
def create_object_id_no_ctx(enterprise_number, local_id_length=8): """ Facility function that works without an application context.""" # I agree that the following is ugly and quite probably not as fast # as I would like it. Goal is to create a random string with a length # of exactly local_id_length. local_id_format = ''.join(['%0', str(local_id_length), 'x']) local_obj_id = local_id_format % random.randrange(16**local_id_length) crc_val = 0 id_length = str(unichr(8 + len(local_obj_id))) # the poly given in the CDMI 1.0.2 spec ()x8005) is wrong, # CRC-16 is specified as below crc_func = crcmod.mkCrcFun(0x18005, initCrc=0x0000, xorOut=0x0000) struct_id = struct.Struct('!cxhccH%ds' % local_id_length) packed_id_no_crc = struct_id.pack('\0', enterprise_number, '\0', id_length, 0, local_obj_id) crc_val = crc_func(packed_id_no_crc) packed_id = struct_id.pack('\0', enterprise_number, '\0', id_length, crc_val, local_obj_id) return packed_id
def __init__(self): Thread.__init__(self) self._dev = None self.crc16 = crcmod.mkCrcFun(0x18005, 0x0000, True) self._queue = b"" self._cmdcond = CmdConditions() self._stopev = False
def PackPacket(self): # Packet Shape # Start flag : 1100 # LEDCommands Flag : 2 bit # Light Intenisty Flag : 4 bit # OptoKineticFlag : 2 bit # Directionality Flag : 8 bit # Parachute Flag : 2 bit # CRC : # End Flag : 0011 self.cpacket = 0b1100 self.cpacket = self.cpacket << 2 self.cpacket = self.cpacket + self.Commands.LEDCommand self.cpacket = self.cpacket << 4 self.cpacket = self.cpacket + self.Commands.LEDIntensity self.cpacket = self.cpacket << 2 self.cpacket = self.cpacket + self.Commands.OptoKinetic self.cpacket = self.cpacket << 8 self.cpacket = self.cpacket + self.Commands.Directionality self.cpacket = self.cpacket << 2 self.cpacket = self.cpacket + self.Commands.ParachuteCommand # Generate CRC data = 0b0000111111111111111111 crc32_func = crcmod.mkCrcFun(0x104C11DB7, initCrc=0, xorOut=0xFFFFFFFF) crc = crc32_func(str(data)) self.cpacket = self.cpacket << 32 self.cpacket = self.cpacket + crc self.cpacket = self.cpacket << 4 self.cpacket = self.cpacket + 0b0011
def __init__(self, bus_nb = 2, addr = 0x07): self.__i2c_fd ={ "in": open("/dev/i2c-"+str(bus_nb), 'rb', buffering=0), "out": open("/dev/i2c-"+str(bus_nb), 'wb', buffering=0) } for fd in self.__i2c_fd.values(): fcntl.ioctl(fd, TrexIO.__I2C_TENBIT, 0) if fcntl.ioctl(fd, TrexIO.__I2C_SLAVE, 7) < 0: raise IOError( "Can not find a T-rex at address %d on bus %d"%(addr, bus_nb) ) self.__reset_bytes = (0,0,0,0) # this list will be used as a "pointer of pointers" to speed up # the dict updates self.__status = dict( zip( TrexIO.__status_dict_strings, [0]*len(TrexIO.__status_dict_strings) ) ) self.compute_crc = crcmod.mkCrcFun(0x131, initCrc=0) #Dallas polynom self.reset()
def __init__(self, port): try: import termios fd = open(port) tmp = termios.tcgetattr(fd.fileno()) termios.tcsetattr(fd.fileno(), termios.TCSADRAIN, tmp) fd.close() except (ImportError, IOError, termios.error): pass self._msg = FWRTSSMessage() self._ser = None self._buf = [] self._crc = crcmod.mkCrcFun(0x104c11db7, initCrc=0xFFFFFFFF, xorOut=0, rev=False) try: self._ser = serial.Serial(port, 115200) self._ser.flush() self._ser.flushInput() self._ser.flushOutput() self._ser.timeout = 0.2 except serial.serialutil.SerialException, e: raise FWRTSSError(str(e))
def read(self,length): preamble = ['\xFF','\xFA']; input = [0x00,0x00] input[1] = self.ser.read(1) while ( True ): if ( input == preamble ): break else: input[0] = input[1] input[1] = self.ser.read(1) while ( self.ser.inWaiting() < length + 2 ): pass #Get data data = self.ser.read(length) #Get checksum input = self.ser.read(2) checksum = struct.unpack('H',input)[0] #Verify checksum crc16 = crcmod.mkCrcFun(0x11021,0xFFFF,True) #crc16 = crcmod.mkCrcFun(0x11021,0xFFFF,False) # xmodem calcChecksum = crc16(data) calcChecksum = (~calcChecksum) % 2**16 # convert to uint16_t #calcChecksum = (calcChecksum) % 2**16 # xmodem if ( checksum != calcChecksum ): print "Failed checksum." return return data
def __init__(self, countchannel, triggerchannel, binwidth, roistart, roistop, filename=None, parent = None, FPGASerial="A6VTOYBO"): QThread.__init__(self, parent) self.channel = countchannel self.triggerchannel = triggerchannel self.binwidth = binwidth self.roistart = roistart self.roistop = roistop self.numberOfBins = (roistop-roistart)/binwidth+1 self.histogram = numpy.zeros(self.numberOfBins) self.exiting = False self.crc8 = crcmod.mkCrcFun(poly=0x107, initCrc=0xff, xorOut=0x00, rev=False) self.Connection = ftd2xx.openEx(FPGASerial); self.Connection.setBaudRate(3000000) self.Connection.setDataCharacteristics(8, 0, 0) self.Connection.setFlowControl(0, 0, 0) self.Connection.setTimeouts(500, 500) self.Connection.resetDevice() self.Connection.purge() self.integration_time = 100.0; command = struct.pack('>BBBI', 0x10, 0, 0x11, int(500*50000 ) ) self.Connection.write(command) command = struct.pack('>BB', 0x12, 0x0 ) self.Connection.write(command) self.Mutex = QMutex() self.filename = filename self.binfile = None if self.filename is not None: self.binfile = open(self.filename, 'wb') self.clearStatus() self.maxPretriggerPhotons = 1000000
def __init__(self, bus_nb = 2, addr = 0x07): self.bus=smbus.SMBus(bus_nb) self.addr = addr self.cmd_left = 0 self.cmd_right = 0 self.use_pid = 0 self.compute_crc = crcmod.mkCrcFun(0x131, initCrc=0) #Dallas polynom self.stop()
def test_known_answers(self): for crcfun_params, v in self.known_answers: crcfun = mkCrcFun(*crcfun_params) self.assertEqual(crcfun('',0), 0, "Wrong answer for CRC parameters %s, input ''" % (crcfun_params,)) for i, msg in enumerate(self.test_messages): self.assertEqual(crcfun(msg), v[i], "Wrong answer for CRC parameters %s, input '%s'" % (crcfun_params,msg)) self.assertEqual(crcfun(msg[4:], crcfun(msg[:4])), v[i], "Wrong answer for CRC parameters %s, input '%s'" % (crcfun_params,msg)) self.assertEqual(crcfun(msg[-1:], crcfun(msg[:-1])), v[i], "Wrong answer for CRC parameters %s, input '%s'" % (crcfun_params,msg))
def encodeTransfer(formatString,values): header = '\xFF\xFA' data = struct.pack(formatString,*values) crc16 = crcmod.mkCrcFun(0x11021,0xFFFF,True) calcChecksum = crc16(data) calcChecksum = (~calcChecksum) % 2**16 # convert to uint16_t return header + data + struct.pack('H',calcChecksum)
def crc8(polynomial, init): check_fn = crcmod.mkCrcFun(0x100 | polynomial, initCrc=init, rev=False) def crc8_fn(data, check): data_s = ''.join(map(chr, data)) calculated = check_fn(data_s) return calculated == check return crc8_fn
def test_compare_poly(self): """Compare various CRCs of this crcmod module to a pure polynomial-based implementation.""" for crcfun_params, crc_poly_fun in self.test_poly_crcs: # The following function should produce the same result as # the associated polynomial CRC function. crcfun = mkCrcFun(*crcfun_params) for msg in self.test_messages: self.assertEqual(crcfun(msg), crc_poly_fun(msg))
def test_compare_crc32(self): """The binascii module has a 32-bit CRC function that is used in a wide range of applications including the checksum used in the ZIP file format. This test compares the CRC-32 implementation of this crcmod module to that of binascii.crc32.""" # The following function should produce the same result as # self.reference_crc32 which is derived from binascii.crc32. crc32 = mkCrcFun(g32,0,1,0xFFFFFFFF) for msg in self.test_messages: self.assertEqual(crc32(msg), self.reference_crc32(msg))
def _crccomp32(): """Internal function used by crc32()""" try: from crcmod import mkCrcFun except ImportError: raise AssertionError("Python crcmod module not installed") crc_polynomial = 0x104C11DB7 crc_initial = 0xFFFFFFFFL crc = mkCrcFun(crc_polynomial, crc_initial, False) while True: yield crc
def __init__(self, device=None, device_id=None): self.devid = device self.serial_mode = None self.dev = None if device_id is not None: self.device_id = device_id self.dev = pylibftdi.serial_device.SerialDevice(self.device_id) else: self.dev = pylibftdi.serial_device.SerialDevice() #TODO fix device id self.dev.baudrate = 117200 self.crcfunc = crcmod.mkCrcFun(0x104c11db7, initCrc=0, xorOut=0xFFFFFFFF)
def caculate_crc( _data ): try: hexData = binascii.a2b_hex(_data) xorOut_ty=0x0000 rev_ty=False initCrc_ty=0xffff xmodem_crc_func = crcmod.mkCrcFun(0x11021, rev=rev_ty, initCrc=initCrc_ty, xorOut=xorOut_ty) return [ True,hex(xmodem_crc_func(hexData)) ] except Exception,e: print Exception,":",e traceback.print_exc() return [ False, None]
def __init__(self, serial_name, file_name): self.crc_fun=crcmod.mkCrcFun(0x104C11DB7, 0xFFFFFFFF, rev=False) try: self.serial = serial.Serial(serial_name, 1200, inter_byte_timeout=self.TIMEOUT_S) except serial.SerialException: error("Cannot open COM port " + serial_name) print("Open serial port " + self.serial.name) if file_name: try: self.file = open(file_name,"rb") except IOError: error("Cannot open file " + file_name) print("Open file " + file_name)
def __init__(self, input_file, output_file, max_rec_size, fill_space, header_loc, in_valid_mask): self.mot_filename = input_file self.out_filename = output_file self.max_block_size = max_rec_size self.max_fill_space = fill_space self.header_location = header_loc self.input_valid_mask = in_valid_mask self.header_bytes_left = self.FL_LI_STRUCT_SIZE self.fileheader = "" self.filesize = 0 #Used for CRC - CCITT - x^16 + x^12 + x^5 + 1 self.g16 = 0x11021 self.crc_init = 0x1D0F #CRC used for the entire file - Image CRC self.file_crc = crcmod.Crc(self.g16, self.crc_init, 0) #CRC used for each block self.crc = crcmod.mkCrcFun(self.g16,self.crc_init,0)
def __init__(self, micromodem, dest,rate = 1, timeout=60,pad='\x1a',ymodem_enabled = True,unified_log=None,log_path=None, ): assert isinstance(micromodem, Micromodem), "micromodem object isn't a Micromodem: %r" & micromodem assert rate in range(0,6), "Invalid Rate: %d" & rate assert dest != micromodem.id, "Can't send file to self." self.pad = pad self.rate = Rates[rate] self.micromodem = micromodem self.micromodem.set_config('RXP',1) self.micromodem.set_config('MOD',1) #use CRC-8/CDMA2000 instead of CRC-16 CCITT Unreflected. self.calc_crc = crcmod.mkCrcFun(0x19b, rev=False, initCrc=0xff, xorOut=0x00) if unified_log is None: unified_log = UnifiedLog(log_path=log_path) self.log = unified_log.getLogger("xmodem.{0}".format(micromodem.name)) self.target_id = dest self.timeout = timeout self.ymodem_mode = True
def decodeTransfer(queue,formatString): length = struct.calcsize(formatString) if ( queue.empty() ): return preamble = ['\xFF','\xFA']; input = [0x00,0x00] input[1] = queue.get(0,0) print input[1] while ( True ): if ( input == preamble ): break else: if ( queue.empty() ): return input[0] = input[1] input[1] = queue.get(0,0) if queue.qsize() < length + 2: return #Get data data = '' for i in range(length): data += queue.get() #Get checksum input = queue.get() input += queue.get() checksum = struct.unpack('H',input)[0] #Verify checksum crc16 = crcmod.mkCrcFun(0x11021,0xFFFF,True) calcChecksum = crc16(data) calcChecksum = (~calcChecksum) % 2**16 # convert to uint16_t if ( checksum != calcChecksum ): print "Failed checksum." return return struct.unpack(formatString,data)
def __init__(self, path, baud): self.fp = Serial( port = path, baudrate = baud, bytesize = serial.EIGHTBITS, parity = serial.PARITY_NONE, stopbits = serial.STOPBITS_ONE ) # CRC-16 with generator polynomial X^16 + X^12 + X^5 + 1. self.crc = crcmod.mkCrcFun(0b10001000000100001, 0, False) self.recv_cbs = [] self.cb_lock = threading.Lock() self.decode_pos = 0 self.discard_stat = 0 self.recv_buf = bytearray() self.read_th = rt = threading.Thread(target=self.reader()) rt.daemon = True rt.start()
def _main(argv): parser = argparse.ArgumentParser(argv) parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true") parser.add_argument("-i", "--infile", help="file to read", required=True) parser.add_argument("-o", "--outfile", help="file to write", required=True) args = parser.parse_args() with open(args.infile, mode='rb') as infile, open( args.outfile, mode='wb') as outfile: dvb_crc32 = crcmod.mkCrcFun(0x104c11db7, rev=False, initCrc=0xFFFFFFFF, xorOut=0) blocks = [bytearray() for i in range(8192)] max_block = 0 for block_number, block_data, crc in ( read_block(infile, dvb_crc32, args.verbose)): if crc == 0: if block_number > max_block: max_block = block_number blocks[block_number] = block_data for index, block in enumerate(blocks): if index > max_block: break if len(block) == 0: print "Missing block: %u" % index break else: outfile.write(block)
def __init__(self, domain): """Loads data to memory. Creates index directory if needed and raises DistutilsFileError if failed. Raises IdexFingerpringException domain - index storage ID """ try: POLYNOMIAL = 0x1AABBCCDDFFEEDDCC # must be 65 bit long self._debug = 0 self._hashes = set() self._crc_fun = crcmod.mkCrcFun(POLYNOMIAL, initCrc=0) # When run from the unit test, index directory path will be tweaked in Config file_path =Config.value(mirror0.SECTION_COMMON, "index_directory") dir_util.mkpath(file_path) file_name = domain + ".crc64" self._file_path = os.path.join(file_path, file_name) with open(self._file_path, "a+b") as f: data = f.read() if len(data) % CRC_LEN: raise IndexFingerprintException("%s is corrupt!" % file_name) count = len(data) / CRC_LEN for i in range(0, count): string_val = data[i*CRC_LEN : (i + 1)*CRC_LEN] int_val = Index._string_long(string_val) self._hashes.update([int_val]) log("Read %i hashes from %s" % (count, file_name)) file_name = domain + ".log" self._log_file_path = os.path.join(file_path, file_name) # Rewrite through centralized logging with open(self._log_file_path, "a") as f: f.write("\n\nSTARTED %s\n" % time.strftime("%d %b %Y %H:%M:%S")) except IndexFingerprintException as e: format_exc(self, "__init__", e) log(self._file_path, ERROR) raise
def __init__(self, *, domain): """Loads data to memory. Creates index directory if needed and raises DistutilsFileError, OSError Raises IdexFingerpringException domain - index storage ID """ POLYNOMIAL = 0x1AABBCCDDFFEEDDCC # must be 65 bit long self._hashes = set() self._crc_fun = crcmod.mkCrcFun(POLYNOMIAL, initCrc=0) try: # When run from the unit test, index directory path will be tweaked in Config file_path =Config.value(mirror0.SECTION_COMMON, "index_directory") mkpath(file_path) file_name = domain + ".crc64" self._file_path = os.path.join(file_path, file_name) with open(self._file_path, "rb") as f: data = f.read() except (OSError, DistutilsFileError) as e: format_exc(self, "Index init failed", e) raise if len(data) % CRC_LEN: msg = "{} is corrupt!".format(self._file_path) log(msg, ERROR) raise IndexFingerprintException(msg) count = len(data) // CRC_LEN for i in range(0, count): string_val = data[i*CRC_LEN : (i + 1)*CRC_LEN] int_val = _bytes_to_long(string_val) self._hashes.update([int_val]) log("Read {} hashes from {}".format(count, file_name)) file_name = domain + ".log" self._log_file_path = os.path.join(file_path, file_name) self.index_log("\n\nSTARTED {}\n".format(time.strftime("%d %b %Y %H:%M:%S")))
def ukhas_format(datum): callsign = "UBSEDS9" # Time time_str = "{:02}:{:02}:{:02}".format( datum['time'].hour, datum['time'].minute, datum['time'].second) # Location coords = datum['coords'] location_str = "{:.6f},{:.6f},{}".format( coords[0], coords[1], int(round(coords[2]))) # Everything ukhas_str = "{},{},{},{},{},{},{},-1".format( callsign, time_str, location_str, datum['satellites'], datum['battery'], datum['solar'], datum['temperature']); # Checksum crc16 = crcmod.mkCrcFun(0x11021, 0xFFFF, False, 0x0000) checksum = "{:04X}".format(crc16(ukhas_str)) return "$${}*{}".format(ukhas_str, checksum)
def __init__(self, socketPath, debug=False, F=160E6): self.__socketPath = socketPath self.__socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) self.__socket.connect(self.__socketPath) self.__crcFunc = crcmod.mkCrcFun(0x104C11DB7, rev=False, initCrc=0x0A1CB27F) self.__lastSN = randrange(0, 2**15-1) self.__pendingReplies = 0 self.__recvBuffer = bytearray([]); self.__debug = debug self.__dataFramesIndexes = [] self.__sync0 = 0 self.__lastSync = 0 self.__frameLength = 1024.0 / F shmName, s0, p1, s1 = self.__getSharedMemoryInfo() self.__dshm = DSHM.SHM(shmName) #self.__shmParams = (s0, p1, s1) #self.__shm = SharedMemory(shmName) #self.__shmmap = mmap.mmap(self.__shm.fd, self.__shm.size) #os.close(self.__shm.fd) self.config = None self.__activeAsics = [ False for x in range(64) ] self.__asicType = [ None for x in range(64) ] return None
def __init__(self): self.__crc = crcmod.mkCrcFun(0x11021, 0xffff, False, 0x0000)
import binascii import crcmod from enum import Enum from Chameleon.MFDESFire import MFDESFireDecode from Chameleon.utils import TrafficSource # Parameters for CRC_A CRC_INIT = 0x6363 POLY = 0x11021 CRC_A_func = crcmod.mkCrcFun(POLY, initCrc=CRC_INIT, xorOut=0) class ReaderCMD(Enum): NONE = 0 SELECT = 1 RATS = 2 PPS = 3 readerCMD = ReaderCMD.NONE # Map card types string to decoder def DummyCardDecoder(data, source): return "" CardTypesMap = { "None": { "ApplicationDecoder": DummyCardDecoder
import crcmod # https://tools.ietf.org/html/rfc3533#section-6 # http://www.onicos.com/staff/iz/formats/ogg.html # https://en.wikipedia.org/wiki/Ogg#Page_structure OGG_FIRST_PAGE_HEADER = struct.Struct("<4sBBQLLLB") OGG_FIRST_PAGE_HEADER_CRC_OFFSET = 22 OGG_FIRST_PAGE_HEADER_CRC = struct.Struct("<L") # https://tools.ietf.org/html/rfc7845#section-5.1 OGG_OPUS_ID_HEADER = struct.Struct("<8sBBHLhB") OGG_OPUS_ID_HEADER_GAIN_OFFSET = 16 OGG_OPUS_ID_HEADER_GAIN = struct.Struct("<h") ogg_page_crc = crcmod.mkCrcFun(0x104C11DB7, initCrc=0, rev=False) def parse_oggopus_output_gain(file: BinaryIO) -> int: # noqa: D200 """ Parse an OggOpus file headers, read and return its output gain, and set file seek position to start of Opus header. """ # # Ogg header # # check fields of Ogg page header chunk = file.read(OGG_FIRST_PAGE_HEADER.size) first_ogg_page = bytearray() first_ogg_page.extend(chunk)
class USBSniffer(OVPacketHandler): """ USB Sniffer packet sink -- receives sniffed packets from the OpenVizsla. """ HANDLED_PACKET_NUMBERS = [0xac, 0xad, 0xa0] USB_PACKET_REPORT = 0xa0 data_crc = staticmethod(crcmod.mkCrcFun(0x18005)) def bytes_necessary_to_determine_size(self, packet_number): if packet_number == 0xa0: return 5 return 1 def __init__(self, write_handler, high_speed=False): """ Set up our core USB Sniffer sink, which accepts wrapped USB events and passes them to our event sinks. """ self.high_speed = high_speed self.got_start = False # Start off with an empty array of packet sinks -- sinks should be registered by calling ``.register_sink`. self._sinks = [] # Call the super-constructor. super().__init__(write_handler) def _packet_size(self, buf): """ Return the packet size for our core USB events. """ if buf[0] != self.USB_PACKET_REPORT: return 2 else: return (buf[4] << 8 | buf[3]) + 8 def register_sink(self, sink): """ Registers a USBEventSink to receive any USB events. """ self._sinks.append(sink) def emit_usb_packet(self, ts, buf, flags): for sink in self._sinks: sink.handle_usb_packet(ts, buf, flags) @staticmethod def decode_flags(flags): ret = "" ret += "Error " if flags & USBEventFlags.ERROR else "" ret += "Overflow" if flags & USBEventFlags.OVERFLOW else "" ret += "Clipped " if flags & USBEventFlags.CLIPPED else "" ret += "Truncated " if flags & USBEventFlags.TRUNCATED else "" ret += "First " if flags & USBEventFlags.FIRST else "" ret += "Last " if flags & USBEventFlags.LAST else "" return ret.rstrip() def handle_packet(self, buf): """ Separates the input flags from the core meta-data extracted from the OV USB packet. """ if buf[0] == self.USB_PACKET_REPORT: # Parse the flags and timeout from our buffer. # TODO: replace with a call to struct.unpack flags = buf[1] | buf[2] << 8 ts = buf[5] | buf[6] << 8 | buf[7] << 16 # TODO: validate packet size (buf[3] and buf[4])? # TODO: get rid of me? if flags != 0 and flags != USBEventFlags.FIRST and flags != USBEventFlags.LAST: print("PERR: %04X (%s)" % (flags, self.decode_flags(flags))) if flags & USBEventFlags.FIRST: self.got_start = True if self.got_start: self.emit_usb_packet(ts, buf[8:], flags) if flags & USBEventFlags.LAST: self.got_start = False else: print("got interesting packet {}".format(buf[0]))
codetext = text.encode('utf-8') #len 9218,str类型 #去除最后的空格 msg = codetext[:-1] #去除CRC数值 msg = codetext[:-6] #去除CRC数值及前一个空格 msg = codetext[:-7] #去除整行CRC= msg = codetext[:-12] #去除整行CRC=及前一个回车 msg = codetext[:-13] #去除Note以后 msg = codetext[:-78] #遍历所有组合,0x10000-0x1FFFF,65536-131071 p = range(0b10000000000000001, 0b11111111111111111, 2) result = [] for i in p: crc16_func = crcmod.mkCrcFun(i, initCrc=0xFFFF, xorOut=0) crc_value = crc16_func(msg) if crc_value == 0: result.append(i) #初始值为全0或全1,均找不到匹配的结果
def mkPredefinedCrcFun(crc_name): definition = _get_definition_by_name(crc_name) return crcmod.mkCrcFun(poly=definition['poly'], initCrc=definition['init'], rev=definition['reverse'], xorOut=definition['xor_out'])
import copy import crcmod from selfdrive.car.nissan.values import CAR nissan_checksum = crcmod.mkCrcFun(0x11d, initCrc=0x00, rev=False, xorOut=0xff) def create_steering_control(packer, car_fingerprint, apply_steer, frame, steer_on, lkas_max_torque): if car_fingerprint == CAR.XTRAIL: idx = (frame % 16) values = { "DESIRED_ANGLE": apply_steer, "SET_0x80_2": 0x80, "SET_0x80": 0x80, "MAX_TORQUE": lkas_max_torque if steer_on else 0, "COUNTER": idx, "LKA_ACTIVE": steer_on, } dat = packer.make_can_msg("LKAS", 0, values)[2] values["CRC"] = nissan_checksum(dat[:7]) return packer.make_can_msg("LKAS", 0, values) def create_acc_cancel_cmd(packer, cruise_throttle_msg, frame): values = copy.copy(cruise_throttle_msg) values["CANCEL_BUTTON"] = 1
#from BadNet0 import * #from BadNet1 import * #from BadNet2 import * from BadNet5 import * #from BadNet4 import * #from BadNet5 import * #main serverIP = '127.0.0.1' blksz = 1024 #Bulk size for receiving file in chunks RUPHeaderFormat = 'I I H H H' RUPHeaderSize = 14 #CRC16 for Checksum crc16_func = crcmod.mkCrcFun(0x11021, initCrc=0, rev=True, xorOut=0xFFFF) checksum_correct = 1 if len(sys.argv) < 2: print('Server Port No. missing in command line arguments') serverPort = raw_input('Enter Server Port No.: ') else: serverPort = sys.argv[1] serverPort = int(serverPort) #Creating server socket for control connection serverSocket = socket(AF_INET, SOCK_DGRAM) serverSocket.bind((serverIP, serverPort)) #**********************************************************
def __init__(self, magicbyte="\x31\x78"): super(HS304, self).__init__("HS304") self.magicbyte = magicbyte self.CRC16 = crcmod.mkCrcFun(0x11021, initCrc=0x422e, rev=False, xorOut=0x0000) self.CRC8 = crcmod.mkCrcFun(0x101, initCrc=0x1d, rev=False, xorOut=0x00) # Lookup table for payload byte 0 (Keyboard HID byte 2) self.LUT0 = [[ 0xa1, 0x21, 0xe1, 0x61, 0x81, 0x01, 0xc1, 0x41, 0xb1, 0x31, 0xf1, 0x71, 0x91, 0x11, 0xd1, 0x51, 0xa9, 0x29, 0xe9, 0x69, 0x89, 0x09, 0xc9, 0x49, 0xb9, 0x39, 0xf9, 0x79, 0x99, 0x19, 0xd9, 0x59, 0xa5, 0x25, 0xe5, 0x65, 0x85, 0x05, 0xc5, 0x45, 0xb5, 0x35, 0xf5, 0x75, 0x95, 0x15, 0xd5, 0x55, 0xad, 0x2d, 0xed, 0x6d, 0x8d, 0x0d, 0xcd, 0x4d, 0xbd, 0x3d, 0xfd, 0x7d, 0x9d, 0x1d, 0xdd, 0x5d, 0xa3, 0x23, 0xe3, 0x63, 0x83, 0x03, 0xc3, 0x43, 0xb3, 0x33, 0xf3, 0x73, 0x93, 0x13, 0xd3, 0x53, 0xab, 0x2b, 0xeb, 0x6b, 0x8b, 0x0b, 0xcb, 0x4b, 0xbb, 0x3b, 0xfb, 0x7b, 0x9b, 0x1b, 0xdb, 0x5b, 0xa7, 0x27, 0xe7, 0x67, 0x87, 0x07, 0xc7, 0x47, 0xb7, 0x37, 0xf7, 0x77, 0x97, 0x17, 0xd7, 0x57, 0xaf, 0x2f, 0xef, 0x6f, 0x8f, 0x0f, 0xcf, 0x4f, 0xbf, 0x3f, 0xff, 0x7f, 0x9f, 0x1f, 0xdf, 0x5f, 0xa0, 0x20, 0xe0, 0x60, 0x80, 0x00, 0xc0, 0x40, 0xb0, 0x30, 0xf0, 0x70, 0x90, 0x10, 0xd0, 0x50, 0xa8, 0x28, 0xe8, 0x68, 0x88, 0x08, 0xc8, 0x48, 0xb8, 0x38, 0xf8, 0x78, 0x98, 0x18, 0xd8, 0x58, 0xa4, 0x24, 0xe4, 0x64, 0x84, 0x04, 0xc4, 0x44, 0xb4, 0x34, 0xf4, 0x74, 0x94, 0x14, 0xd4, 0x54, 0xac, 0x2c, 0xec, 0x6c, 0x8c, 0x0c, 0xcc, 0x4c, 0xbc, 0x3c, 0xfc, 0x7c, 0x9c, 0x1c, 0xdc, 0x5c, 0xa2, 0x22, 0xe2, 0x62, 0x82, 0x02, 0xc2, 0x42, 0xb2, 0x32, 0xf2, 0x72, 0x92, 0x12, 0xd2, 0x52, 0xaa, 0x2a, 0xea, 0x6a, 0x8a, 0x0a, 0xca, 0x4a, 0xba, 0x3a, 0xfa, 0x7a, 0x9a, 0x1a, 0xda, 0x5a, 0xa6, 0x26, 0xe6, 0x66, 0x86, 0x06, 0xc6, 0x46, 0xb6, 0x36, 0xf6, 0x76, 0x96, 0x16, 0xd6, 0x56, 0xae, 0x2e, 0xee, 0x6e, 0x8e, 0x0e, 0xce, 0x4e, 0xbe, 0x3e, 0xfe, 0x7e, 0x9e, 0x1e, 0xde, 0x5e ].index(x) for x in range(256)] # Lookup table for payload byte 3 (Mouse HID byte 0) self.LUT3 = [[ 0x66, 0xe6, 0x26, 0xa6, 0x46, 0xc6, 0x06, 0x86, 0x76, 0xf6, 0x36, 0xb6, 0x56, 0xd6, 0x16, 0x96, 0x6e, 0xee, 0x2e, 0xae, 0x4e, 0xce, 0x0e, 0x8e, 0x7e, 0xfe, 0x3e, 0xbe, 0x5e, 0xde, 0x1e, 0x9e, 0x62, 0xe2, 0x22, 0xa2, 0x42, 0xc2, 0x02, 0x82, 0x72, 0xf2, 0x32, 0xb2, 0x52, 0xd2, 0x12, 0x92, 0x6a, 0xea, 0x2a, 0xaa, 0x4a, 0xca, 0x0a, 0x8a, 0x7a, 0xfa, 0x3a, 0xba, 0x5a, 0xda, 0x1a, 0x9a, 0x64, 0xe4, 0x24, 0xa4, 0x44, 0xc4, 0x04, 0x84, 0x74, 0xf4, 0x34, 0xb4, 0x54, 0xd4, 0x14, 0x94, 0x6c, 0xec, 0x2c, 0xac, 0x4c, 0xcc, 0x0c, 0x8c, 0x7c, 0xfc, 0x3c, 0xbc, 0x5c, 0xdc, 0x1c, 0x9c, 0x60, 0xe0, 0x20, 0xa0, 0x40, 0xc0, 0x00, 0x80, 0x70, 0xf0, 0x30, 0xb0, 0x50, 0xd0, 0x10, 0x90, 0x68, 0xe8, 0x28, 0xa8, 0x48, 0xc8, 0x08, 0x88, 0x78, 0xf8, 0x38, 0xb8, 0x58, 0xd8, 0x18, 0x98, 0x67, 0xe7, 0x27, 0xa7, 0x47, 0xc7, 0x07, 0x87, 0x77, 0xf7, 0x37, 0xb7, 0x57, 0xd7, 0x17, 0x97, 0x6f, 0xef, 0x2f, 0xaf, 0x4f, 0xcf, 0x0f, 0x8f, 0x7f, 0xff, 0x3f, 0xbf, 0x5f, 0xdf, 0x1f, 0x9f, 0x63, 0xe3, 0x23, 0xa3, 0x43, 0xc3, 0x03, 0x83, 0x73, 0xf3, 0x33, 0xb3, 0x53, 0xd3, 0x13, 0x93, 0x6b, 0xeb, 0x2b, 0xab, 0x4b, 0xcb, 0x0b, 0x8b, 0x7b, 0xfb, 0x3b, 0xbb, 0x5b, 0xdb, 0x1b, 0x9b, 0x65, 0xe5, 0x25, 0xa5, 0x45, 0xc5, 0x05, 0x85, 0x75, 0xf5, 0x35, 0xb5, 0x55, 0xd5, 0x15, 0x95, 0x6d, 0xed, 0x2d, 0xad, 0x4d, 0xcd, 0x0d, 0x8d, 0x7d, 0xfd, 0x3d, 0xbd, 0x5d, 0xdd, 0x1d, 0x9d, 0x61, 0xe1, 0x21, 0xa1, 0x41, 0xc1, 0x01, 0x81, 0x71, 0xf1, 0x31, 0xb1, 0x51, 0xd1, 0x11, 0x91, 0x69, 0xe9, 0x29, 0xa9, 0x49, 0xc9, 0x09, 0x89, 0x79, 0xf9, 0x39, 0xb9, 0x59, 0xd9, 0x19, 0x99 ].index(x) for x in range(256)] # Lookup table for payload byte 4 (Mouse HID byte 1) self.LUT4 = [[ 0xb1, 0x31, 0xf1, 0x71, 0x91, 0x11, 0xd1, 0x51, 0xa1, 0x21, 0xe1, 0x61, 0x81, 0x00, 0xc1, 0x41, 0xb9, 0x39, 0xf9, 0x79, 0x99, 0x19, 0xd9, 0x59, 0xa9, 0x29, 0xe9, 0x69, 0x89, 0x09, 0xc9, 0x49, 0xb5, 0x35, 0xf5, 0x75, 0x95, 0x15, 0xd5, 0x55, 0xa5, 0x25, 0xe5, 0x65, 0x85, 0x05, 0xc5, 0x45, 0xbd, 0x3d, 0xfd, 0x7d, 0x9d, 0x1d, 0xdd, 0x5d, 0xad, 0x2d, 0xed, 0x6d, 0x8d, 0x0d, 0xcd, 0x4d, 0xb3, 0x33, 0xf3, 0x73, 0x93, 0x13, 0xd3, 0x53, 0xa3, 0x23, 0xe3, 0x63, 0x83, 0x03, 0xc3, 0x43, 0xbb, 0x3b, 0xfb, 0x7b, 0x9b, 0x1b, 0xdb, 0x5b, 0xab, 0x2b, 0xeb, 0x6b, 0x8b, 0x0b, 0xcb, 0x4b, 0xb7, 0x37, 0xf7, 0x77, 0x97, 0x17, 0xd7, 0x57, 0xa7, 0x27, 0xe7, 0x67, 0x87, 0x07, 0xc7, 0x47, 0xbf, 0x3f, 0xff, 0x7f, 0x9f, 0x1f, 0xdf, 0x5f, 0xaf, 0x2f, 0xef, 0x6f, 0x8f, 0x0f, 0xcf, 0x4f, 0xb0, 0x30, 0xf0, 0x70, 0x90, 0x10, 0xd0, 0x50, 0xa0, 0x20, 0xe0, 0x60, 0x80, 0x01, 0xc0, 0x40, 0xb8, 0x38, 0xf8, 0x78, 0x98, 0x18, 0xd8, 0x58, 0xa8, 0x28, 0xe8, 0x68, 0x88, 0x08, 0xc8, 0x48, 0xb4, 0x34, 0xf4, 0x74, 0x94, 0x14, 0xd4, 0x54, 0xa4, 0x24, 0xe4, 0x64, 0x84, 0x04, 0xc4, 0x44, 0xbc, 0x3c, 0xfc, 0x7c, 0x9c, 0x1c, 0xdc, 0x5c, 0xac, 0x2c, 0xec, 0x6c, 0x8c, 0x0c, 0xcc, 0x4c, 0xb2, 0x32, 0xf2, 0x72, 0x92, 0x12, 0xd2, 0x52, 0xa2, 0x22, 0xe2, 0x62, 0x82, 0x02, 0xc2, 0x42, 0xba, 0x3a, 0xfa, 0x7a, 0x9a, 0x1a, 0xda, 0x5a, 0xaa, 0x2a, 0xea, 0x6a, 0x8a, 0x0a, 0xca, 0x4a, 0xb6, 0x36, 0xf6, 0x76, 0x96, 0x16, 0xd6, 0x56, 0xa6, 0x26, 0xe6, 0x66, 0x86, 0x06, 0xc6, 0x46, 0xbe, 0x3e, 0xfe, 0x7e, 0x9e, 0x1e, 0xde, 0x5e, 0xae, 0x2e, 0xee, 0x6e, 0x8e, 0x0e, 0xce, 0x4e ].index(x) for x in range(256)] # Lookup table for payload byte 5 (Mouse HID byte 2) self.LUT5 = [[ 0x75, 0xf5, 0x35, 0xb5, 0x55, 0xd5, 0x15, 0x95, 0x65, 0xe5, 0x25, 0xa5, 0x45, 0xc5, 0x05, 0x85, 0x7d, 0xfd, 0x3d, 0xbd, 0x5d, 0xdd, 0x1d, 0x9d, 0x6d, 0xed, 0x2d, 0xad, 0x4d, 0xcd, 0x0d, 0x8d, 0x71, 0xf1, 0x31, 0xb1, 0x51, 0xd1, 0x11, 0x91, 0x61, 0xe1, 0x21, 0xa1, 0x41, 0xc1, 0x01, 0x81, 0x79, 0xf9, 0x39, 0xb9, 0x59, 0xd9, 0x19, 0x99, 0x69, 0xe9, 0x29, 0xa9, 0x49, 0xc9, 0x09, 0x89, 0x77, 0xf7, 0x37, 0xb7, 0x57, 0xd7, 0x17, 0x97, 0x67, 0xe7, 0x27, 0xa7, 0x47, 0xc7, 0x07, 0x87, 0x7f, 0xff, 0x3f, 0xbf, 0x5f, 0xdf, 0x1f, 0x9f, 0x6f, 0xef, 0x2f, 0xaf, 0x4f, 0xcf, 0x0f, 0x8f, 0x73, 0xf3, 0x33, 0xb3, 0x53, 0xd3, 0x13, 0x93, 0x63, 0xe3, 0x23, 0xa3, 0x43, 0xc3, 0x03, 0x83, 0x7b, 0xfb, 0x3b, 0xbb, 0x5b, 0xdb, 0x1b, 0x9b, 0x6b, 0xeb, 0x2b, 0xab, 0x4b, 0xcb, 0x0b, 0x8b, 0x74, 0xf4, 0x34, 0xb4, 0x54, 0xd4, 0x14, 0x94, 0x64, 0xe4, 0x24, 0xa4, 0x44, 0xc4, 0x04, 0x84, 0x7c, 0xfc, 0x3c, 0xbc, 0x5c, 0xdc, 0x1c, 0x9c, 0x6c, 0xec, 0x2c, 0xac, 0x4c, 0xcc, 0x0c, 0x8c, 0x70, 0xf0, 0x30, 0xb0, 0x50, 0xd0, 0x10, 0x90, 0x60, 0xe0, 0x20, 0xa0, 0x40, 0xc0, 0x00, 0x80, 0x78, 0xf8, 0x38, 0xb8, 0x58, 0xd8, 0x18, 0x98, 0x68, 0xe8, 0x28, 0xa8, 0x48, 0xc8, 0x08, 0x88, 0x76, 0xf6, 0x36, 0xb6, 0x56, 0xd6, 0x16, 0x96, 0x66, 0xe6, 0x26, 0xa6, 0x46, 0xc6, 0x06, 0x86, 0x7e, 0xfe, 0x3e, 0xbe, 0x5e, 0xde, 0x1e, 0x9e, 0x6e, 0xee, 0x2e, 0xae, 0x4e, 0xce, 0x0e, 0x8e, 0x72, 0xf2, 0x32, 0xb2, 0x52, 0xd2, 0x12, 0x92, 0x62, 0xe2, 0x22, 0xa2, 0x42, 0xc2, 0x02, 0x82, 0x7a, 0xfa, 0x3a, 0xba, 0x5a, 0xda, 0x1a, 0x9a, 0x6a, 0xea, 0x2a, 0xaa, 0x4a, 0xca, 0x0a, 0x8a ].index(x) for x in range(256)] # Lookup table for payload byte 6 (Keyboard HID byte 1) self.LUT6 = [[ 0x31, 0xb1, 0x71, 0xf1, 0x11, 0x91, 0x51, 0xd1, 0x21, 0xa1, 0x61, 0xe1, 0x01, 0x81, 0x41, 0xc1, 0x39, 0xb9, 0x79, 0xf9, 0x19, 0x99, 0x59, 0xd9, 0x29, 0xa9, 0x69, 0xe9, 0x09, 0x89, 0x49, 0xc9, 0x35, 0xb5, 0x75, 0xf5, 0x15, 0x95, 0x55, 0xd5, 0x25, 0xa5, 0x65, 0xe5, 0x05, 0x85, 0x45, 0xc5, 0x3d, 0xbd, 0x7d, 0xfd, 0x1d, 0x9d, 0x5d, 0xdd, 0x2d, 0xad, 0x6d, 0xed, 0x0d, 0x8d, 0x4d, 0xcd, 0x33, 0xb3, 0x73, 0xf3, 0x13, 0x93, 0x53, 0xd3, 0x23, 0xa3, 0x63, 0xe3, 0x03, 0x83, 0x43, 0xc3, 0x3b, 0xbb, 0x7b, 0xfb, 0x1b, 0x9b, 0x5b, 0xdb, 0x2b, 0xab, 0x6b, 0xeb, 0x0b, 0x8b, 0x4b, 0xcb, 0x37, 0xb7, 0x77, 0xf7, 0x17, 0x97, 0x57, 0xd7, 0x27, 0xa7, 0x67, 0xe7, 0x07, 0x87, 0x47, 0xc7, 0x3f, 0xbf, 0x7f, 0xff, 0x1f, 0x9f, 0x5f, 0xdf, 0x2f, 0xaf, 0x6f, 0xef, 0x0f, 0x8f, 0x4f, 0xcf, 0x30, 0xb0, 0x70, 0xf0, 0x10, 0x90, 0x50, 0xd0, 0x20, 0xa0, 0x60, 0xe0, 0x00, 0x80, 0x40, 0xc0, 0x38, 0xb8, 0x78, 0xf8, 0x18, 0x98, 0x58, 0xd8, 0x28, 0xa8, 0x68, 0xe8, 0x08, 0x88, 0x48, 0xc8, 0x34, 0xb4, 0x74, 0xf4, 0x14, 0x94, 0x54, 0xd4, 0x24, 0xa4, 0x64, 0xe4, 0x04, 0x84, 0x44, 0xc4, 0x3c, 0xbc, 0x7c, 0xfc, 0x1c, 0x9c, 0x5c, 0xdc, 0x2c, 0xac, 0x6c, 0xec, 0x0c, 0x8c, 0x4c, 0xcc, 0x32, 0xb2, 0x72, 0xf2, 0x12, 0x92, 0x52, 0xd2, 0x22, 0xa2, 0x62, 0xe2, 0x02, 0x82, 0x42, 0xc2, 0x3a, 0xba, 0x7a, 0xfa, 0x1a, 0x9a, 0x5a, 0xda, 0x2a, 0xaa, 0x6a, 0xea, 0x0a, 0x8a, 0x4a, 0xca, 0x36, 0xb6, 0x76, 0xf6, 0x16, 0x96, 0x56, 0xd6, 0x26, 0xa6, 0x66, 0xe6, 0x06, 0x86, 0x46, 0xc6, 0x3e, 0xbe, 0x7e, 0xfe, 0x1e, 0x9e, 0x5e, 0xde, 0x2e, 0xae, 0x6e, 0xee, 0x0e, 0x8e, 0x4e, 0xce ].index(x) for x in range(256)]
import crcmod # pip -[--proxy <addr>] install crcmod from intelhex import IntelHex # pip [--proxy <addr>] install intelhex, needs latest version import struct import textwrap import sys import math import ntpath from collections import namedtuple #tool version number tool_version = "1.0" #CRC related data # CRC Polynomial used by OAD for CC254x #crc16 = crcmod.mkCrcFun(0x18005, rev=False, initCrc=0x0000, xorOut=0x0000) # CRC Poly used by OAD for CC26xx crc16 = crcmod.mkCrcFun(0x11021, rev=False, initCrc=0x0000, xorOut=0x0000) OAD_HDR_FMT = 'HHHH4sHBB' OadHdr = namedtuple('OadImgHdr', 'crc crcShdw imgVer imgLen usrId imgAddr imgType status') #the below dictionary contains the mapping from imgType string to an integeer imgTypes = {'app': 1, 'stack': 2, 'np': 3, 'production': 4} #Meta data status field measures success as 0xFF META_STATUS_SUCCESS = 0xFF META_STATUS_PREPENDED = 0XFE #External flash layout (this info is in ext_flash_layout.h) EXT_FL_SECTOR_1_SECTOR = "APP: 0x00000 - 0x1FFFF" EXT_FL_SECTOR_2_SECTOR = "STACK/NP: 0x20000 - 0x3FFFF" EXT_FL_SECTOR_3_SECTOR = "Factory: 0x40000 - 0x5FFFF" EXT_FL_PG_SIZE = 4096
def SerialSend(cmd2): sreturn = C.create_string_buffer(30) sendsize = C.c_uint32(30) rsize = C.c_uint32(30) stimeout = C.c_uint32(50) crc16 = crcmod.mkCrcFun(0x1755b, rev=False, initCrc=0xFFFF, xorOut=0x0000) cmd = cmd2 cmd = cmd.replace('\x5c','\x5c\x5c').replace('\xff','\x5c\xff') cmd = '\xff' + cmd cmd = '\x00' + cmd print cmd2 print map(hex,cmd) crccalc = bytes(cmd[0:]) print crccalc[0] a = crc16(crccalc[0]) print(a) crccalc = bytes(cmd[1:]) for d in crccalc: a = crc16(d,a) print(map(str,crccalc)) print(a) crc = "".join(map(chr,divmod((a ^ 0xFFFF),256 ))) crc = crc.replace('\x5c','\x5c\x5c') cmd = cmd + crc cmd = cmd.replace('\x3e','\x5c\x3e') cmd = '\x3e' + cmd + '\x3e' print "crc is:" print crc print map(str,crc) print "cmd is:" print map(hex,cmd) print map(str,cmd) print(str(cmd)) print(bytes(cmd)) print cmd print("Command to send to serial:", map(hex,cmd)) print str(cmd) print len(cmd) sendcmd = C.create_string_buffer(bytes(cmd)) sendsize.value = len(cmd) rval = imaq.imgSessionSerialFlush(sid) imaq.imgShowError(rval, text) print("buffer flushed: " + (text.value)) if rval != 0: print("Not connected to Scicam") rval = imaq.imgSessionSerialWrite(sid, C.byref(sendcmd), C.byref(sendsize), stimeout) imaq.imgShowError(rval, text) print("Sent: " + (text.value)) rval = imaq.imgSessionSerialReadBytes(sid, C.byref(sreturn), C.byref(rsize), stimeout) imaq.imgShowError(rval, text) print("Received: " + (text.value)) rsizeval = rsize.value ret = sreturn.raw if ret[0] == '\x3e' and ret[rsizeval-1] == '\x3e': if ret[1] == '\xa0' or ret[1] == '\x20' or ret[1] == '\x00': crccalc = bytes(ret[1:rsizeval-3]) a = crc16(crccalc[0]) crccalc = str(ret[2:rsizeval-3]).replace('\x5c\x5c','\x5c').replace('\x5c\x3e','\x3e').replace('\x5c\xff','\xff') for d in crccalc: a = crc16(d,a) #print d, hex(a), hex(a ^ 0xFFFF) crc = "".join(map(chr,divmod((a ^ 0xFFFF),256 ))) crcret = bytes(ret[rsizeval-3:rsizeval-1]) #print crc, crcret if crc == crcret: print "good CRC" serial_ret = str(map("{0:>02x}".format,map(ord,crccalc[1:]))).translate(None,"[]',") print serial_ret return serial_ret else: print "bad CRC" return -3 else: print "bad ack/nak/null" return -2 else: print "incomplete packet?" return -1
def crccreate(b, length): crc16_func = crcmod.mkCrcFun(0x18005, initCrc=0xFFFF, rev=True, xorOut=0x0000) return crc16_func(b[0:length])
def crccheck(b,length): print('传过来的b,和lenght',b,' ',length) crc16_func = crcmod.mkCrcFun(0x18005, initCrc=0xFFFF, rev=True, xorOut=0x0000) return crc16_func(b[0:length]) == bytesToInt(b[length], b[length + 1])
def run(self): try: global recvFlag while True: crc16_ibm = crcmod.mkCrcFun(0x18005, rev=True, initCrc=0x0000, xorOut=0x0000) print 'start recv' msg = self.socket.recv() print 'finish recv' if len(msg) < 6: print 'warning: length of msg is less than 6! Ignore this msg' continue LENGTH = struct.unpack('!I', msg[1:5])[0] if LENGTH != (len(msg) - 5): print "warning0: the length of msg is not equal to LENGTH! Ignore this msg" continue HEADER = msg[0] CODE = msg[5:6] DATA = msg[6:-2] CRC16 = struct.unpack('!H', msg[-2:])[0] if (HEADER != '\xBB'): print 'Do not handle the msg begin with %s! Ignore this msg' % ( HEADER, ) continue if (CODE != '\x08'): print 'Do not handle the msg with code %s! Ignore this msg' % ( CODE, ) continue if crc16_ibm(msg[5:-2]) != CRC16: print 'CRC check fail!' continue if len(DATA) < 36: print "warning: the length of msg is less than 36! Ignore this msg" continue num_samp = struct.unpack('!l', DATA[24:28])[0] if len(DATA) != num_samp * 8 + 36: print "warning1: the length of msg is not equal to LENGTH! Ignore this msg" continue print 'writing a iq msg' freq = struct.unpack("!d", DATA[0:8])[0] samp_rate = struct.unpack('!d', DATA[8:16])[0] gain = struct.unpack('!d', DATA[16:24])[0] bandwidth = struct.unpack('!d', DATA[28:36])[0] real_part = struct.unpack('!%s' % ('f' * num_samp, ), DATA[36:36 + num_samp * 4]) imag_part = struct.unpack( '!%s' % ('f' * num_samp, ), DATA[36 + num_samp * 4:36 + num_samp * 8]) # self.q.put("recvd") local_time1 = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time())) self.path = r'D:\postgraduate_program\usrp_recvfiles\auto_recognize\oc_%s.dat' % ( local_time1) f = open(self.path, 'w+') f.write( str(freq) + ' ' + str(bandwidth) + ' ' + str(samp_rate) + ' ') for i in range(len(real_part)): f.write(str(real_part[i]) + ' ') f.write('\n') f.close() print len(real_part) print 'write worked' recvFlag = 1 # flag = 1 # if flag == 1: # break except KeyboardInterrupt: pass print 'end collect_recv at:', ctime()
def run(self): print 'start scan_recv at:', ctime() try: while True: crc16_ibm = crcmod.mkCrcFun(0x18005, rev=True, initCrc=0x0000, xorOut=0x0000) # print 'before socket.recv' msg = self.socket.recv() # print 'recved' if len(msg) < 6: print 'warning: length of msg is less than 6! Ignore this msg' continue LENGTH = struct.unpack('!I', msg[1:5])[0] if LENGTH != (len(msg) - 5): print "warning0: the length of msg is not equal to LENGTH! Ignore this msg" continue HEADER = msg[0] CODE = msg[5:6] DATA = msg[6:-2] CRC16 = struct.unpack('!H', msg[-2:])[0] if (HEADER != '\xBB'): print 'Do not handle the msg begin with %s! Ignore this msg' % ( HEADER, ) continue if (CODE != '\x06'): print 'Do not handle the msg with code %s! Ignore this msg' % ( CODE, ) continue if crc16_ibm(msg[5:-2]) != CRC16: print 'CRC check fail!' continue if len(DATA) < 12: print "warning1: the length of msg is less than 12! Ignore this msg" continue freq_resolution = struct.unpack('!d', DATA[0:8])[0] n_freq = struct.unpack('!I', DATA[8:12])[0] if len(DATA) != n_freq * (4 + 8) + 12: print "warning1: the length of msg is not equal to LENGTH! Ignore this msg" continue # print 'receiving a spectrum msg!' bins = struct.unpack('!%s' % ('f' * n_freq, ), DATA[12:12 + n_freq * 4]) freq_list = struct.unpack( '!%s' % ('d' * n_freq, ), DATA[12 + n_freq * 4:12 + n_freq * (4 + 8)]) # Do what you want to do, here is a example. bins = [c + 4 for c in bins] filename = self.path % self.localtime f = open(filename, 'w+') print filename for i in range(len(freq_list)): f.write(str(freq_list[i]) + ' ') f.write('\n') for i in range(len(bins)): f.write(str(bins[i]) + ' ') f.write('\n') f.close() # print 'written!', ctime() break self.q.put("recvd") except KeyboardInterrupt: pass print 'end scan_recv at:', ctime()
def __init__(self, callback): self.state = WAITING self.pkt = b"" self.b = bytearray() self.crc_func = crcmod.mkCrcFun(0x11021, rev=True, initCrc=0xffff, xorOut=0x0000) self.callback = callback
#try: h = pi.i2c_open(I2C_BUS, I2C_SLAVE) #except: # eprint("i2c open failed") # exit(1) #def i2cOpen(): # global h # try: # h = pi.i2c_open(I2C_BUS, I2C_SLAVE) # except: # eprint("i2c open failed") # exit(1) f_crc8 = crcmod.mkCrcFun(0x131, 0xFF, False, 0x00) def calcCRC(TwoBdataArray): byteData = ''.join(chr(x) for x in TwoBdataArray) return f_crc8(byteData) # print(hex(calcCRC([0xBE,0xEF]))) def readNBytes(n): try: (count, data) = pi.i2c_read_device(h, n) except: eprint("error: i2c_read failed")
spacing - spacing in mm timestamp - milliseconds since 1970 """ try: data = np.asarray(image) except Exception as e: _print('ERROR, INVALID IMAGE. \n' + str(e)) self._valid_message = False return data = data.reshape(dim) ImageMessage.__init__(self, data, spacing, timestamp) # http://slicer-devel.65872.n3.nabble.com/OpenIGTLinkIF-and-CRC-td4031360.html CRC64 = crcmod.mkCrcFun(0x142F0E1EBA9EA3693, rev=False, initCrc=0x0000000000000000, xorOut=0x0000000000000000) # https://github.com/openigtlink/OpenIGTLink/blob/cf9619e2fece63be0d30d039f57b1eb4d43b1a75/Source/igtlutil/igtl_util.c#L168 def _igtl_nanosec_to_frac(nanosec): base = 1000000000 # 10^9 mask = 0x80000000 r = 0x00000000 while mask: base += 1 base >>= 1 if (nanosec >= base): r |= mask nanosec = nanosec - base mask >>= 1
def upload(): # Identify all the sbd files again for root, dirs, files in os.walk("."): #if root != ".": # Ignore files in this directory - only process subdirectories #if root == ".": # Ignore subdirectories - only process this directory if len(files) > 0: # Find filenames with the correct format (imei-momsn.bin) valid_files = [ afile for afile in files if ((afile[-4:] == '.bin') and (afile[15:16] == '-')) ] else: valid_files = [] if len(valid_files) > 0: for filename in sorted_nicely(valid_files): longfilename = os.path.join(root, filename) msnum = filename[16:-4] # Get the momsn imei = filename[0:15] # Get the imei ignore_me = False # Should we ignore this file? # Check if this file is in the list # If it isn't then this must be a new SBD file so try and process it try: index = sbd.index(longfilename) except: index = -1 if index == -1: sbd.append( longfilename ) # Add new filename to list so even if invalid we don't process it again # Read the sbd file and unpack the data using numpy loadtxt try: # Messages without RockBLOCK destination gpstime,latitude,longitude,altitude,speed,heading,pressure,humidity,temperature,battery = \ np.loadtxt(longfilename, delimiter=',', unpack=True, \ usecols=(0,1,2,3,4,5,8,9,10), converters={0:mdates.strpdate2num('%Y%m%d%H%M%S')}) except: # Messages with RockBLOCK destination try: gpstime,latitude,longitude,altitude,speed,heading,pressure,humidity,temperature,battery = \ np.loadtxt(longfilename, delimiter=',', unpack=True, \ usecols=(1,2,3,4,5,6,9,10,11), converters={1:mdates.strpdate2num('%Y%m%d%H%M%S')}) except: print 'Ignoring', filename ignore_me = True if (ignore_me == False): if upload_this_IMEI == "": upload_this_IMEI = imei print 'Uploading messages from IMEI', imei if (imei == upload_this_IMEI): print 'Found new SBD file from beacon IMEI', imei, 'with MOMSN', msnum pressure = int( round(pressure)) # Convert pressure to integer time_str = mdates.num2date(gpstime).strftime( '%H:%M:%S,%y%m%d' ) # Time string (HH:MM:SS,YYMMDD) location_str = "{:.6f},{:.6f},{}".format( latitude, longitude, int(round(altitude))) # Location # Assemble the UKHAS format string ukhas_str = "{},{},{},{:.2f},{:.1f},{},{},{},{},{}".format( \ callsign, time_str, location_str, speed, heading, pressure, humidity, temperature, battery, msnum) # Calculate checksum crc16 = crcmod.mkCrcFun(0x11021, 0xFFFF, False, 0x0000) checksum = "{:04X}".format(crc16(ukhas_str)) # Append the checksum ukhas_str = "$${}*{}".format(ukhas_str, checksum) print 'Uploading:', ukhas_str # Packet ID packet_base64 = base64.standard_b64encode( ukhas_str + "\n") packet_sha256 = hashlib.sha256( packet_base64).hexdigest() # Time Created = backlog time time_created = mdates.num2date(gpstime).strftime( '%Y-%m-%dT%H:%M:%S+00:00') # Time Uploaded = now now = datetime.utcnow() time_uploaded = now.replace( microsecond=0).isoformat() + "+00:00"
'NET', 'CST', 'CO', 'SO', 'TO', 'SAVE', 'BAUD', 'NODEADR', 'GNODEADR', 'GADV', 'EN', 'DI', 'GTIMEOUT', 'TIMEOUT', 'UPTIME', 'SADV' ] from crcmod.predefined import mkCrcFun as mkCrcFunPre from crcmod import mkCrcFun crcfuncs = {} crcnames = [ 'crc-8', 'crc-8-darc', 'crc-8-i-code', 'crc-8-itu', 'crc-8-maxim', 'crc-8-rohc', 'crc-8-wcdma' ] for crc_name in crcnames: crcfuncs[crc_name] = mkCrcFunPre(crc_name) crcfuncs['CRC-13-BBC'] = mkCrcFun(0x1CF5) cmds = {} for cmd in FMCC: cmds[cmd] = {} for crc_name, crc_func in crcfuncs.items(): cmds[cmd][crc_name] = crc_func(bytes(cmd, 'ascii')) crccount = {} for crc_name in crcnames: crccount[crc_name] = [0] * 256 for cmd, value in cmds.items(): crccount[crc_name][value[crc_name]] += 1 from collections import Counter import operator
return cls.msg("00", flag) @classmethod def msg(cls, resType, flag): result = [resType, flagEncode(flag), "01"] result.extend(timeEncode(True)) # 当前时间 result.append("00") # 开店时间闭店时间 result.append("00") # 开店时间闭店时间 result.append("17") # 开店时间闭店时间 result.append("3B") # 开店时间闭店时间 crc = getCrC(result) result.append(crc) return "".join(result) crc16 = crcmod.mkCrcFun(0x18005, rev=True, initCrc=0xFFFF, xorOut=0x0000) def getCrC(msgs: list): msg = b"" for m in msgs: msg = msg + int(m, 16).to_bytes(int(len(m) / 2), "big") return crc16(msg).to_bytes(2, "big").hex().upper() def timeEncode(week=False): """ 格式化时间 将时间转为16进制字符形式 :return [year,month,day,hour,minute,second] """ now = datetime.now()
class SCD30I2CInterface: i2c_addr = 0x61 def __init__(self, interface, logger): self.lower = interface self._logger = logger self._level = logging.DEBUG if self._logger.name == __name__ else logging.TRACE def _log(self, message, *args): self._logger.log(self._level, "SCD30: " + message, *args) _crc = staticmethod(crcmod.mkCrcFun(0x131, initCrc=0xff, rev=False)) async def _read_raw(self, addr, length=0): assert length % 2 == 0 acked = await self.lower.write(self.i2c_addr, struct.pack(">H", addr), stop=True) if acked is False: raise SCD30Error("SCD30 did not acknowledge address write") crc_data = await self.lower.read(self.i2c_addr, length // 2 * 3, stop=True) if crc_data is None: raise SCD30Error("SCD30 did not acknowledge data read") self._log("addr=%#06x data=<%s>", addr, dump_hex(crc_data)) data = bytearray() for index, (chunk, crc) in enumerate(struct.iter_unpack(">2sB", crc_data)): if self._crc(chunk) != crc: raise SCD30Error("CRC failed on word {}".format(index)) data += chunk return data async def _write_raw(self, cmd, data=b""): assert len(data) % 2 == 0 crc_data = bytearray() for chunk, in struct.iter_unpack(">2s", data): crc_data += chunk crc_data.append(self._crc(chunk)) self._log("cmd=%#06x args=<%s>", cmd, dump_hex(crc_data)) acked = await self.lower.write(self.i2c_addr, struct.pack(">H", cmd) + crc_data, stop=True) if acked is False: raise SCD30Error("SCD30 did not acknowledge command write") async def _read(self, addr, format): return struct.unpack( format, await self._read_raw(addr, struct.calcsize(format))) async def _write(self, cmd, format="", *args): await self._write_raw(cmd, struct.pack(format, *args)) async def soft_reset(self): self._log("soft reset") await self._write(CMD_SOFT_RESET) async def firmware_version(self): major, minor = await self._read(CMD_FIRMWARE_VER, ">BB") self._log("firmware major=%d minor=%d", major, minor) return major, minor async def is_data_ready(self): ready, = await self._read(CMD_DATA_READY, ">H") self._log("data ready=%d", ready) return bool(ready) async def start_measurement(self, pressure_mbar=None): assert pressure_mbar is None or pressure_mbar in range(700, 1200) if pressure_mbar is None: self._log("start measurement") else: self._log("start measurement pressure=%d [mbar]", pressure_mbar) await self._write(CMD_START_MEASURE, ">H", pressure_mbar or 0) async def stop_measurement(self): self._log("stop measurement") await self._write(CMD_STOP_MEASURE) async def read_measurement(self): co2_ppm, temp_degC, rh_pct = \ await self._read(CMD_READ_MEASURE, ">fff") self._log("measured CO₂=%.2f [ppm] T=%.2f [°C] RH=%.2f [%%]", co2_ppm, temp_degC, rh_pct) return SCD30Measurement(co2_ppm, temp_degC, rh_pct) async def get_measurement_interval(self): interval_s, = await self._read(CMD_INTERVAL, ">H") self._log("measurement interval get=%d [s]", interval_s) return interval_s async def set_measurement_interval(self, interval_s): assert 2 <= interval_s <= 1800 self._log("measurement interval set=%d [s]", interval_s) await self._write(CMD_INTERVAL, ">H", interval_s) async def get_auto_self_calibration(self): enabled, = await self._read(CMD_AUTO_SELF_CAL, ">H") self._log("auto calibration status=%d", enabled) return bool(enabled) async def set_auto_self_calibration(self, enabled): self._log("auto calibration %s", "enable" if enabled else "disable") await self._write(CMD_AUTO_SELF_CAL, ">H", bool(enabled)) async def get_forced_calibration(self): co2_ppm, = await self._read(CMD_FORCE_RECAL, ">H") self._log("forced calibration get=%d [ppm]", co2_ppm) return co2_ppm async def set_forced_calibration(self, co2_ppm): assert 400 <= co2_ppm <= 2000 self._log("forced calibration set=%d [ppm]", co2_ppm) await self._write(CMD_FORCE_RECAL, ">H", co2_ppm) async def get_temperature_offset(self): temp_degC_100ths, = await self._read(CMD_TEMP_OFFSET, ">H") temp_degC = temp_degC_100ths / 100 self._log("temperature offset get=%.2f [°C]", temp_degC) return temp_degC async def set_temperature_offset(self, temp_degC): assert 0.0 <= temp_degC self._log("temperature offset set=%.2f [°C]", temp_degC) temp_degC_100ths = int(temp_degC * 100) await self._write(CMD_TEMP_OFFSET, ">H", temp_degC_100ths) async def get_altitude_compensation(self): altitude_m, = await self._read(CMD_ALTITUDE_COMP, ">H") self._log("altitude compensation get=%d [m]", altitude_m) return altitude_m async def set_altitude_compensation(self, altitude_m): self._log("altitude compensation set=%d [m]", altitude_m) await self._write(CMD_ALTITUDE_COMP, ">H", altitude_m)
def init_crc(): POLYNOMIAL = 0x1d5 # 0xd5 + leading 1 crc = crcmod.mkCrcFun(poly=POLYNOMIAL, initCrc=0, rev=False) return crc
def crc(inBytes, init=0x00000000): return crcmod.mkCrcFun(0x104C11DB7, initCrc=init, rev=True, xorOut=0x00000000)(inBytes)
import crcmod from common.op_params import opParams from selfdrive.car.hyundai.values import CAR, CHECKSUM hyundai_checksum = crcmod.mkCrcFun(0x11D, initCrc=0xFD, rev=False, xorOut=0xdf) def create_lkas11(packer, frame, car_fingerprint, apply_steer, steer_req, lkas11, sys_warning, sys_state, enabled, left_lane, right_lane, left_lane_depart, right_lane_depart, lfa_available, bus): values = lkas11 values["CF_Lkas_LdwsSysState"] = 3 if steer_req else sys_state values["CF_Lkas_SysWarning"] = sys_warning values["CF_Lkas_LdwsLHWarning"] = left_lane_depart values["CF_Lkas_LdwsRHWarning"] = right_lane_depart values["CR_Lkas_StrToqReq"] = apply_steer values["CF_Lkas_ActToi"] = steer_req values["CF_Lkas_ToiFlt"] = 0 values["CF_Lkas_MsgCount"] = frame % 0x10 values["CF_Lkas_Chksum"] = 0 if values["CF_Lkas_LdwsOpt_USM"] == 4: values["CF_Lkas_LdwsOpt_USM"] = 3 if lfa_available: values["CF_Lkas_LdwsActivemode"] = int(left_lane) + ( int(right_lane) << 1) values["CF_Lkas_LdwsOpt_USM"] = 2
class MemoryFloppyAppletTool(GlasgowAppletTool, applet=MemoryFloppyApplet): help = "manipulate raw disk images captured from IBM/Shugart floppy drives" description = """ Dissect raw disk images (i.e. RDATA samples) and extract MFM-encoded sectors into linear disk images. Any errors during extraction are logged, the linear image is filled and padded to the necessary geometry, and all areas that were not recovered from the raw image are filled with the following repeating byte patterns: * <FA11> for sectors completely missing from the raw image; * <DEAD> for sectors whose header was found but data was corrupted; * <BAAD> for sectors that were marked as "deleted" (i.e. bad blocks) in the raw image, and no decoding was attempted. ("Deleted" sectors are not currently recognized.) """ @classmethod def add_arguments(cls, parser): p_operation = parser.add_subparsers(dest="operation", metavar="OPERATION") p_index = p_operation.add_parser( "index", help="discover and verify raw disk image contents and MFM sectors") p_index.add_argument( "-n", "--no-decode", action="store_true", default=False, help= "do not attempt to decode track data, just index tracks (much faster)" ) p_index.add_argument("file", metavar="RAW-FILE", type=argparse.FileType("rb"), help="read raw disk image from RAW-FILE") p_raw2img = p_operation.add_parser( "raw2img", help="extract raw disk images into linear disk images") p_raw2img.add_argument( "-s", "--sector-size", metavar="BYTES", type=int, default=512, help="amount of bytes per sector (~always the default: %(default)s)" ) p_raw2img.add_argument( "-t", "--sectors-per-track", metavar="COUNT", type=int, required=True, help="amount of sectors per track (9 for DD, 18 for HD, ...)") p_raw2img.add_argument("raw_file", metavar="RAW-FILE", type=argparse.FileType("rb"), help="read raw disk image from RAW-FILE") p_raw2img.add_argument("linear_file", metavar="LINEAR-FILE", type=argparse.FileType("wb"), help="write linear disk image to LINEAR-FILE") crc_mfm = staticmethod(crcmod.mkCrcFun(0x11021, initCrc=0xffff, rev=False)) def iter_tracks(self, file): while True: header = file.read(struct.calcsize(">BBL")) if header == b"": break head, track, size = struct.unpack(">BBL", header) yield track, head, file.read(size) def iter_mfm_sectors(self, symbstream, verbose=False): state = "IDLE" count = 0 data = bytearray() header = None size = None for offset, (comma, symbol) in enumerate(symbstream): self.logger.trace("state=%s sym=%s.%02X", state, "K" if comma else "D", symbol) if comma and symbol == 0xA1: if state == "IDLE": data.clear() count = 1 state = "SYNC" elif state == "SYNC": count += 1 else: self.logger.warning("desync sym-off=%d state=%s sym=K.A1", offset, state) data.clear() count = 1 state = "SYNC" data.append(symbol) continue data.append(symbol) if state == "IDLE": continue elif state == "SYNC": if count < 3: self.logger.warning("early data sym-off=%d sync-n=%d", offset, count) if symbol == 0xFE: count = 6 # CYL+HD+SEC+NO+CRCH/L state = "FORMAT" elif symbol == 0xFB: if header is None: self.logger.warning("spurious sector sym-off=%d", offset) else: count = 2 + size # DATA+CRCH/L state = "SECTOR" else: self.logger.warning("unknown mark sym-off=%d type=%02X", offset, symbol) state = "IDLE" continue if state in ("FORMAT", "SECTOR"): count -= 1 if count == 0 and self.crc_mfm(data) != 0: self.logger.warning( "wrong checksum sym-off=%d state=%s type=%02X", offset, state, data[2]) state = "IDLE" continue if count == 0 and state == "FORMAT": cyl, hd, sec, no = struct.unpack(">BBBB", data[4:-2]) size = 1 << (7 + no) header = cyl, hd, sec self.logger.log(logging.INFO if verbose else logging.DEBUG, " header cyl=%2d hd=%d sec=%2d size=%d", *header, size) if count == 0 and state == "SECTOR": yield (header, data[4:-2]) header = None if count == 0: state = "IDLE" async def run(self, args): if args.operation == "index": for head, track, bytestream in self.iter_tracks(args.file): self.logger.info("track %d head %d: %d samples captured", head, track, len(bytestream) * 8) if args.no_decode: continue mfm = SoftwareMFMDecoder(self.logger) symbstream = mfm.demodulate(mfm.lock(mfm.bits(bytestream))) for _ in self.iter_mfm_sectors(symbstream, verbose=True): pass if args.operation == "raw2img": image = bytearray() next_lba = 0 missing = 0 try: curr_lba = 0 for head, track, bytestream in self.iter_tracks(args.raw_file): self.logger.info("processing track %d head %d", head, track) mfm = SoftwareMFMDecoder(self.logger) symbstream = mfm.demodulate(mfm.lock(mfm.bits(bytestream))) sectors = {} seen = set() for (cyl, hd, sec), data in self.iter_mfm_sectors(symbstream): if sec not in range(1, 1 + args.sectors_per_track): self.logger.error( "sector at C/H/S %d/%d/%d overflows track geometry " "(%d sectors per track)", cyl, hd, sec, args.sectors_per_track) continue if sec in seen: # Due to read redundancy, seeing this is not an error in general, # though this could be a sign of a strange invalid track. We do not # currently aim to handle these cases, so just ignore them. self.logger.debug( "duplicate sector at C/H/S %d/%d/%d", cyl, hd, sec) continue else: seen.add(sec) lba = ((cyl << 1) + hd) * args.sectors_per_track + ( sec - 1) self.logger.info(" mapping C/H/S %d/%d/%d to LBA %d", cyl, hd, sec, lba) if len(data) != args.sector_size: self.logger.error( "sector at LBA %d has size %d (%d expected)", lba, len(data), args.sector_size) elif lba in sectors: self.logger.error("duplicate sector at LBA %d", lba) else: sectors[lba] = data if len(seen) == args.sectors_per_track: self.logger.debug( "found all sectors on this track") break last_lba = curr_lba + args.sectors_per_track while curr_lba < last_lba: if curr_lba in sectors: args.linear_file.seek(curr_lba * args.sector_size) args.linear_file.write(sectors[curr_lba]) else: missing += 1 args.linear_file.seek(curr_lba * args.sector_size) args.linear_file.write(b"\xFA\x11" * (args.sector_size // 2)) self.logger.error("sector at LBA %d missing", curr_lba) curr_lba += 1 finally: self.logger.info("%d/%d sectors missing", missing, last_lba)
def crccheckhole(b,length): crc16_func = crcmod.mkCrcFun(0x18005, initCrc=0xFFFF, rev=True, xorOut=0x0000) return hex(crc16_func(b[0:length]))==bytesToHex(b[length],b[length+1])
class USBSimplePrintSink(USBEventSink): """ Most basic sink for USB events: report them directly to the console. """ import crcmod data_crc = staticmethod(crcmod.mkCrcFun(0x18005)) def __init__(self, highspeed): self.frameno = None self.subframe = 0 self.highspeed = highspeed self.last_ts_frame = 0 self.last_ts_print = 0 self.last_ts_pkt = 0 self.ts_base = 0 self.ts_roll_cyc = 2**24 def handle_usb_packet(self, ts, buf, flags): CRC_BAD = 1 CRC_GOOD = 2 CRC_NONE = 3 crc_check = CRC_NONE ts_delta_pkt = ts - self.last_ts_pkt self.last_ts_pkt = ts if ts_delta_pkt < 0: self.ts_base += self.ts_roll_cyc ts += self.ts_base suppress = False msg = "" if len(buf) != 0: pid = buf[0] & 0xF if (buf[0] >> 4) ^ 0xF != pid: msg += "Err - bad PID of %02x" % pid elif pid == 0x5: if len(buf) < 3: msg += "RUNT frame" else: frameno = buf[1] | (buf[2] << 8) & 0x7 if self.frameno == None: self.subframe = None else: if self.subframe == None: if frameno == (self.frameno + 1) & 0xFF: self.subframe = 0 if self.highspeed else None else: self.subframe += 1 if self.subframe == 8: if frameno == (self.frameno + 1) & 0xFF: self.subframe = 0 else: msg += "WTF Subframe %d" % self.frameno self.subframe = None elif self.frameno != frameno: msg += "WTF frameno %d" % self.frameno self.subframe = None self.frameno = frameno self.last_ts_frame = ts suppress = True msg += "Frame %d.%c" % (frameno, '?' if self.subframe == None else "%d" % self.subframe) elif pid in [0x3, 0xB, 0x7]: n = {3: 0, 0xB: 1, 0x7: 2}[pid] msg += "DATA%d: %s" % (n, hd(buf[1:])) if len(buf) > 2: calc_check = self.data_crc(buf[1:-2]) ^ 0xFFFF pkt_check = buf[-2] | buf[-1] << 8 if calc_check != pkt_check: msg += "\tUnexpected ERR CRC" elif pid == 0xF: msg += "MDATA: %s" % hd(buf[1:]) elif pid in [0x01, 0x09, 0x0D, 0x04]: if pid == 1: name = "OUT" elif pid == 9: name = "IN" elif pid == 0xD: name = "SETUP" elif pid == 0x04: name = "PING" if len(buf) < 3: msg += "RUNT: %s %s" % (name, " ".join("%02x" % i for i in buf)) else: addr = buf[1] & 0x7F endp = (buf[2] & 0x7) << 1 | buf[1] >> 7 msg += "%-5s: %d.%d" % (name, addr, endp) elif pid == 2: msg += "ACK" elif pid == 0xA: msg += "NAK" elif pid == 0xE: msg += "STALL" elif pid == 0x6: msg += "NYET" elif pid == 0xC: msg += "PRE-ERR" pass elif pid == 0x8: msg += "SPLIT" pass else: msg += "WUT" if not suppress: crc_char_d = {CRC_BAD: '!', CRC_GOOD: 'C', CRC_NONE: ' '} flag_field = "[ %s%s%s%s%s%s]" % ( 'L' if flags & 0x20 else ' ', 'F' if flags & 0x10 else ' ', 'T' if flags & 0x08 else ' ', 'C' if flags & 0x04 else ' ', 'O' if flags & 0x02 else ' ', 'E' if flags & 0x01 else ' ') delta_subframe = ts - self.last_ts_frame delta_print = ts - self.last_ts_print self.last_ts_print = ts RATE = 60.0e6 subf_print = '' frame_print = '' if self.frameno != None: frame_print = "%3d" % self.frameno if self.subframe != None: subf_print = ".%d" % self.subframe print("%s %10.6f d=%10.6f [%3s%2s +%7.3f] [%3d] %s " % (flag_field, ts / RATE, (delta_print) / RATE, frame_print, subf_print, delta_subframe / RATE * 1E6, len(buf), msg))
def hash(module, function, bits=13, print_hash=True): crc32_func = crcmod.mkCrcFun(0x11EDC6F41, initCrc=0, xorOut=0) h = crc32_func(unicode(module) + function + "\x00") print "[+] 0x%08X = %s!%s" % (h, module.lower(), function) return h
from uvscada.util import hexdump from collections import namedtuple import struct import serial import random import crcmod # Forward CRC-16-CCITT crcf = crcmod.mkCrcFun(poly=0x11021, initCrc=0x0000, rev=False, xorOut=0x0000) # namedtuple PCmd = namedtuple('PCmd', 'res0 seq sum res3') PCMD_FMT = 'BBB6s' ''' Volt: mV Amp: mA Resistance: mOhm ''' fields = '''\ res1 res2 Application Version Product Code Input Voltage[1] Operation Mode[1] Operation Status[1] Cycle Number[1] Minute[1]
import crcmod import collections import random from pwn import * Entry = collections.namedtuple("Entry", ["bits", "delta", "bit_len", "lookahead"]) crc16 = crcmod.mkCrcFun(0x18005, initCrc=0, xorOut=0) crc32 = crcmod.mkCrcFun(0x11EDC6F41, initCrc=0, xorOut=0xFFFFFFFF) crc64 = crcmod.mkCrcFun(0x142F0E1EBA9EA3693, initCrc=0, xorOut=0xFFFFFFFFFFFFFFFF) # Retry until you don't get "Cannot choose from an empty sequence" error N = 512 DECAY = 0.9 LOOKAHEAD_BITS = 8 OTHER_LEVEL = 0.4 RANDOM = 1 / 100 def bits_to_s(num): s = b"" for i in range(N): if (num >> i) & 1: s += b"A" else: s += b"a" return s