def to_binary(self): req = pack('!L', self.num) for i in xrange(self.num): req += add_str_to_binary(self.field[i]) req += pack('!B', self.flag[i]) req += add_str_to_binary(self.value[i]) return req
def add_str_to_binary(s): if s: es = s.encode("GBK") return pack('!L', len(es) + 1) + pack(str(len(es)) + 's', es) + '\x00' #for c string else: return pack('!L', 0)
def __shake_hands(self, read_code, write_code): shake_hands = TDHS_HEAD wbuf = shake_hands wbuf += pack('!L', TDHS_VERSION_BINARY) wbuf += pack('!L', self.time_out) wbuf += add_str_to_binary(read_code) wbuf += add_str_to_binary(write_code) self.send(pack(FMT, MAGIC_CODE, REQUEST_TYPE_SHAKE_HANDS, self.getid(), 0, len(wbuf)) + wbuf)
def to_binary(self): if not self.is_vaild(): raise request_exception("insert is not valid!") req = self.table_info.to_binary() req += pack('!L', self.num) for i in xrange(self.num): req += pack('!B', self.flag[i]) req += add_str_to_binary(self.value[i]) return req
def to_binary(self): if not self.is_vaild(): raise request_exception("get is not valid!") req = self.table_info.to_binary() req += add_array_to_binary(self.key) req += pack('!B', self.find_flag) req += pack('!L', self.start) req += pack('!L', self.limit) req += self.filter.to_binary() return req
def __shake_hands(self, read_code, write_code): shake_hands = TDHS_HEAD wbuf = shake_hands wbuf += pack('!L', TDHS_VERSION_BINARY) wbuf += pack('!L', self.time_out) wbuf += add_str_to_binary(read_code) wbuf += add_str_to_binary(write_code) self.send( pack(FMT, MAGIC_CODE, REQUEST_TYPE_SHAKE_HANDS, self.getid(), 0, len(wbuf)) + wbuf)
def encode(self, mode, msg): if mode == 0: #return stc.pack("HHHH", mode, int(msg[0]), int(msg[1]), int(msg[2])) #return stc.pack("<fff", mode, msg[0], msg[1], msg[2]) self.ser.write(stc.pack("H", mode)) self.ser.write((str(msg[0]) + " ").encode("utf-8")) self.ser.write((str(msg[1]) + " ").encode("utf-8")) self.ser.write(str(msg[2]).encode("utf-8")) elif mode == 1: return stc.pack("H", mode)
def add_array_to_binary(array): v = pack('!L', len(array)) for a in array: if isinstance(a, list) or isinstance(a, tuple): v += add_array_to_binary(a) else: v += add_str_to_binary(a) return v
def main(n): import _struct as struct import array a = array.array('B', struct.pack('i', 42)) i = 0 while i < n: i += 1 struct.unpack('i', a) # ID: unpack return i
def test_struct_bool(): import _struct for prefix in tuple("<>!=")+('',): format = str(prefix + '?') packed = _struct.pack(format, {}) unpacked = _struct.unpack(format, packed) AreEqual(len(unpacked), 1) AssertFalse(unpacked[0])
def main(n): import _struct as struct import array a = array.array('c', struct.pack('i', 42)) i = 0 while i < n: i += 1 struct.unpack('<i', a) # ID: unpack return i
def to_binary(self): if not self.is_vaild(): raise request_exception("table_info is not valid!") req = add_str_to_binary(self.db) req += add_str_to_binary(self.table) if self.index: req += add_str_to_binary(self.index) else: req += pack('!L', 0) req += add_array_to_binary(self.fields) return req
def save_traffic(self, traffic, path): self.file = open(path + '/simulation_traffic_data.bin', 'wb') for veh in traffic: self.file.write( struct.pack( '6f', *[ traffic[veh][64], traffic[veh][66][0], traffic[veh][66][1], traffic[veh][67], traffic[veh][68], traffic[veh][77] ])) # print(fmt), name_length = len(traffic[veh][79]) fmt = 'i' self.file.write(struct.pack(fmt, *[name_length])) # print(fmt), fmt = str(name_length) + 's' self.file.write(struct.pack(fmt, *[traffic[veh][79].encode()])) # print(fmt), name_length = len(traffic[veh][87]) fmt = 'i' self.file.write(struct.pack(fmt, *[name_length])) # print(name_length), for route in traffic[veh][87]: name_length = len(route) fmt = 'i' self.file.write(struct.pack(fmt, *[name_length])) # print(fmt), fmt = str(name_length) + 's' self.file.write(struct.pack(fmt, *[route.encode()])) # print(fmt), self.file.close()
def encode(self): assert self.position == 0, 'Do not call encode twice' repeats = self.find_repeats() total_size = len(self.file_bytes) self.encoded_bytes.extend(pack('>L', total_size)) for repeat in repeats: repeat_start, repeat_len, fill_byte = repeat # check if copy is needed if repeat_start > self.position: self._copy(repeat_start) self._fill(repeat_len, fill_byte) if total_size > self.position: self._copy(total_size) assert self.position == total_size, 'file could not parsed completely'
def digest(self): """Terminate the message-digest computation and return digest. Return the digest of the strings passed to the update() method so far. This is a 16-byte string which may contain non-ASCII characters, including null bytes. """ A = self.A B = self.B C = self.C D = self.D input = [] + self.input count = [] + self.count index = (self.count[0] >> 3) & 0x3f if index < 56: padLen = 56 - index else: padLen = 120 - index padding = [b'\200'] + [b'\000'] * 63 self.update(padding[:padLen]) # Append length (before padding). bits = _bytelist2long(self.input[:56]) + count self._transform(bits) # Store state in digest. digest = struct.pack("<IIII", self.A, self.B, self.C, self.D) self.A = A self.B = B self.C = C self.D = D self.input = input self.count = count return digest
def _test_float_point_number(self, type, byteorder): float_value = uniform(-3.1415926535, 3.1415926535) can_data = [0, 0] configs = [{ "key": type + "Var", "is_ts": True, "type": type, "start": len(can_data), "length": 4 if type[0] == "f" else 8, "byteorder": byteorder }] can_data.extend( _struct.pack((">" if byteorder[0] == "b" else "<") + type[0], float_value)) tb_data = self.converter.convert(configs, can_data) self.assertTrue( isclose(tb_data["telemetry"][type + "Var"], float_value, rel_tol=1e-05))
def packInt32(self, val): return _struct.pack('<I', val)
def pack(self, data): size = len(data) data = struct.pack('!I%ss' % size, size, data) return data
from _socket import * if len(sys.argv) != 2: print('-' * 30) print("tips:") print("python xxx.py 192.168.1.1") print('-' * 30) exit() else: ip = sys.argv[1] # 创建udp套接字 udpSocket = socket(AF_INET, SOCK_DGRAM) # 构造下载请求数据 sendData = _struct.pack("!H8sb5sb", 1, "test.jpg", 0, "octet", 0) # 发送下载文件请求数据到指定服务器 sendAddr = (ip, 69) udpSocket.sendto(sendData, sendAddr) p_num = 0 recvFile = '' while True: recvData, recvAddr = udpSocket.recvfrom(1024) recvDataLen = len(recvData) cmdTuple = _struct.unpack("!HH", recvData[:4])
def length_to_bits(size): count = how_many_bytes(size) bin_size = pack('>L', size)[-count:] assert len(bin_size) == count return (count, bin_size)
def packInt16(self, val): if val < 0: val = 0x10000 + val return _struct.pack('<H', val)
#msg2 = stc.pack("HHHH", mode, angle1, angle2, angle3) print(msg1) ser.write(encoding_tests) if __name__ == "__main__": mode = 0 angle1 = 45 angle2 = 50 angle3 = 55 msg2 = stc.pack("HHHH", mode, angle1, angle2, angle3) ser = serial.Serial('COM3', 115200, timeout=1) ser.flush() print("connected") print(stc.unpack("HHHH", msg2)) ser.write(msg2) print("sent") while True: if ser.in_waiting > 0: line = ser.readline() line = line.decode("utf-8").rstrip()
# Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import _struct as struct # struct test A = 0x67452301 B = 0xefcdab89 C = 0x98badcfe D = 0x10325476 expected = '\x01#Eg\x89\xab\xcd\xef\xfe\xdc\xba\x98vT2\x10' assert struct.pack("<IIII", A, B, C, D) == expected