Python ustruct.pack函数代码示例

    def _send_connect(self, keepalive):
        print("_send_connect")

        remaining_length = 2+6+1+1+2+2+len(self._client_id)
        #remaining_length = 2+len(protocol) + 1+1+2 + 2+len(self._client_id)
        connect_flags = 0
        connect_flags = connect_flags | 0x02

        if self._username:
            remaining_length = remaining_length + 2+len(self._username)
            connect_flags = connect_flags | 0x80
            if self._password:
                connect_flags = connect_flags | 0x40
                remaining_length = remaining_length + 2+len(self._password)

        command = CONNECT
        packet = bytearray()
        packet.extend(struct.pack("!B", command))

        self._pack_remaining_length(packet, remaining_length)
        #packet.extend(struct.pack("!H"+str(len(protocol))+"sBBH", len(protocol), protocol, proto_ver, connect_flags, keepalive))
        packet.extend(struct.pack("!H"+"6"+"sBBH", 6, b"MQIsdp", 3, connect_flags, keepalive))

        self._pack_str16(packet, self._client_id)

        if self._username:
            self._pack_str16(packet, self._username)

            if self._password:
                self._pack_str16(packet, self._password)

        self._keepalive = keepalive
        return self._packet_queue(command, packet, 0, 0)

    def _send_subscribe(self, dup, topics):
        print("_send_subscribe")
        remaining_length = 2

        #topic_qos_list = [(topic.encode('utf-8'), qos)] - > [('test', 0)]
        #remaining_length = 2 + 2+ len('test') +1 --> 9
        for t in topics:
            remaining_length = remaining_length + 2+len(t[0])+1

        #SUBSCRIBE = const(0x80) - > 0b10000000
        # According to spec the fixed header is 0b10000010 
        # According to spec the second byte is the remaining length = 2 bytes of varialbe header + payload
        # If QoS is zero the variable header is 0,0 or if > 1 would be some unique identifier
        # dup = 0 (I think)
        # 1<<1 -> 0b00000010
        command = SUBSCRIBE | (dup<<3) | (1<<1)
        packet = bytearray()
        packet.extend(struct.pack("!B", command))
        self._pack_remaining_length(packet, remaining_length) #operates on packet and extends it
        local_mid = self._mid_generate()
        packet.extend(struct.pack("!H", local_mid))
        for t in topics:
            self._pack_str16(packet, t[0])
            packet.extend(struct.pack("B", t[1]))
        return (self._packet_queue(command, packet, local_mid, 1), local_mid)

 def _pack_str16(self, packet, data):
     print("_pack_str16")
     if isinstance(data, bytearray) or isinstance(data, bytes):
         packet.extend(struct.pack("!H", len(data)))
         packet.extend(data)
     elif isinstance(data, str):
         udata = data.encode('utf-8')
         pack_format = "!H" + str(len(udata)) + "s"
         packet.extend(struct.pack(pack_format, len(udata), udata))
     else:
         raise TypeError

    def __init__(self, conn, w, h, name):
        self.conn = conn[0]
        self.w = w
        self.h = h
        self.bpp = 32
        self.depth = 24
        self.big = True
        self.true = True
        self.masks = (255, 255, 255)
        self.shifts = (16, 8, 0)

        # HandShake
        self.send(b"RFB 003.003\n")
        if self.recv(True) != b"RFB 003.003\n":
            raise Exception("RFB rejected version proposal")

        # Security
        self.send(b"\x00\x00\x00\x01")

        # ignore instruction to disconnect other clients
        if self.recv(True)[0] not in (0, 1):
            print("2b")
            raise Exception("RFB rejected security none")

        # ServerInit
        self.send(
            pack(
                ">2H4B3H3B",
                w,
                h,
                self.bpp,
                self.depth,
                self.big,
                self.true,
                self.masks[0],
                self.masks[0],
                self.masks[0],
                self.shifts[0],
                self.shifts[1],
                self.shifts[2],
            )
            + bytes(3)
            + pack(">L", len(name))
            + name
        )

        # we *may* be sent encodings (ignorred) and pixel format
        self.service_msg_queue()

 def SetWriteWindow(self, PageStart, PageStop, ColStart, ColStop):
     if (PageStart < 0) or (PageStop > 7) or (PageStart > PageStop):
        return(-1)
     if (ColStart < 0) or (ColStop > 127) or (ColStart > ColStop):
        return(-1)
     self.SendCommand(pack("6B", 0x21, ColStart, ColStop, 0x22, PageStart, PageStop))
     return(0)

	def __start( self, addr ):
		""" Start a SPI transaction @ addr """
		# Start new transaction
		self.ssel.value( 1 )
		#sleep_ms( 1 ) # 1 Ms between SPI transaction seems right
		sleep_us( 10 )
		self.ssel.value( 0 )
		self.spi.write( ustruct.pack( '>H', addr) ) # Convert address in MSB and LSB

def gmtime(t=None):
    if t is None:
        t = time()

    t = int(t)
    a = ustruct.pack('i', t)
    tm_p = gmtime_(a)
    return _c_tm_to_tuple(uctypes.bytearray_at(tm_p, 36))

    def _addSensorData(self, packet):
        #BinaryPayloadContainer ???
        if self.getContainerId() == 17:
            packet.extend(self.getValue())
            return
            
        if self.getValueType == "boolean":
            packet.append(0x01) if self.sensorValue["value"] == True else packet.append(0x00)
            return
        else:
            packet.append(0x00)
            
            
        
        if self.data['booleanMeterValue']:
            packet.append(0x01)
        else:
            packet.append(0x00)
        
        if not self.data['booleanMeterValue'] is None:
            return
        
        #ATT LIBRARY USING 'SHORT' where mentioning 'INT' !!!!!
        if self.data['integerMeterValue']:
            packet.append(0x01)
            packet.extend(pack('>h',self.data['integerMeterValue']))
            return
        else:
            packet.append(0x00)

        if self.data['doubleMeterValue']:
            packet.append(0x01)
            packet.extend(pack('>f',self.data['doubleMeterValue']))
            return
        elif self.data['accelerometerMeterValue']:
            packet.append(0x03)
            packet.extend(pack('>fff',self.data['accelerometerMeterValue']['x'], self.data['accelerometerMeterValue']['y'], self.data['accelerometerMeterValue']['z']))
            return
        elif self.data['gpsMeterValue']:
            packet.append(0x04)
            packet.extend(pack('>ffff',self.data['gpsMeterValue']['latitude'], self.data['gpsMeterValue']['longitude'], self.data['gpsMeterValue']['altitude'], self.data['gpsMeterValue']['timestamp']))
            return
        else:
            #Nothing left for now ... so shouldn't really be getting here.
            packet.append(0x00)

def master():
    csn = Pin(cfg['csn'], mode=Pin.OUT, value=1)
    ce = Pin(cfg['ce'], mode=Pin.OUT, value=0)
    if cfg['spi'] == -1:
        spi = SPI(-1, sck=Pin(cfg['sck']), mosi=Pin(cfg['mosi']), miso=Pin(cfg['miso']))
        nrf = NRF24L01(spi, csn, ce, payload_size=8)
    else:
        nrf = NRF24L01(SPI(cfg['spi']), csn, ce, payload_size=8)

    nrf.open_tx_pipe(pipes[0])
    nrf.open_rx_pipe(1, pipes[1])
    nrf.start_listening()

    num_needed = 16
    num_successes = 0
    num_failures = 0
    led_state = 0

    print('NRF24L01 master mode, sending %d packets...' % num_needed)

    while num_successes < num_needed and num_failures < num_needed:
        # stop listening and send packet
        nrf.stop_listening()
        millis = utime.ticks_ms()
        led_state = max(1, (led_state << 1) & 0x0f)
        print('sending:', millis, led_state)
        try:
            nrf.send(struct.pack('ii', millis, led_state))
        except OSError:
            pass

        # start listening again
        nrf.start_listening()

        # wait for response, with 250ms timeout
        start_time = utime.ticks_ms()
        timeout = False
        while not nrf.any() and not timeout:
            if utime.ticks_diff(utime.ticks_ms(), start_time) > 250:
                timeout = True

        if timeout:
            print('failed, response timed out')
            num_failures += 1

        else:
            # recv packet
            got_millis, = struct.unpack('i', nrf.recv())

            # print response and round-trip delay
            print('got response:', got_millis, '(delay', utime.ticks_diff(utime.ticks_ms(), got_millis), 'ms)')
            num_successes += 1

        # delay then loop
        utime.sleep_ms(250)

    print('master finished sending; successes=%d, failures=%d' % (num_successes, num_failures))

def colour_to_pixel(colour, bpp, depth, big, true, masks, shifts):
    if true:
        v = 0
        for channel, mask, shift in zip(colour, masks, shifts):
            v += (channel & mask)<<shift
        return pack(
                    ('>' if big else '<') + \
                    ('L' if bpp==32 else ('H' if bpp==16 else 'B')),
                    v<<(bpp-depth) if big else v
            )

def pack_blob(b, encoding='utf-8'):
    """Pack a bytes, bytearray or tuple/list of ints into a binary OSC blob."""
    if isinstance(b, (tuple, list)):
        b = bytearray(b)
    elif isinstance(b, str):
        b = bytes(b, encoding)

    blen = len(b)
    b = pack('>I', blen) + b
    return b + b'\0' * (((blen + 3) & ~0x03) - blen)

 def _check_keepalive(self):
     print("_check_keepalive")
     now = time.time()
     print("_check_keepalive: self._last_msg = ", self._last_msg)
     last_msg = self._last_msg
     if (self._sock is not None) and (now - last_msg >= self._keepalive):
         print("_check_keepalive: self._state =", self._state)
         if self._ping_t == 0:
             #self._send_pingreq()
             packet = struct.pack('!BB', PINGREQ, 0)
             self._packet_queue(PINGREQ, packet, 0, 0)
             self._last_msg = now

def pack_bundle(bundle):
    """Return bundle data packed into a binary string."""
    data = []
    for msg in bundle:
        if isinstance(msg, Bundle):
            msg = pack_bundle(msg)
        elif isinstance(msg, tuple):
            msg = create_message(*msg)

        data.append(pack('>I', len(msg)) + msg)

    return b'#bundle\0' + pack_timetag(bundle.timetag) + b''.join(data)

def ServerFrameBufferUpdate(rectangles):
    if rectangles:  # empty list is False
        buffer = bytes()
        for idx, rect in enumerate(rectangles):
            b = rect.to_bytes()
            if b is None:  # done with this rectangle
                del (rectangles[idx])
            elif b is False:
                pass  # no update required
            else:
                buffer += b
        return b"\x00\x00" + pack(">H", len(rectangles)) + buffer

 def to_bytes(self):
     b = b''
     for rect in self.subrectangles:
         b += rect.to_bytes()
     return super().to_bytes() \
            + pack('>L',len(self.subrectangles)) \
            + colour_to_pixel(
                 self.bgcolour, 
                 self.bpp, self.depth, 
                 self.big, self.true, 
                 self.masks, self.shifts
            ) + b