예제 #1
0
    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)
예제 #2
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)
예제 #3
0
 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
예제 #4
0
파일: session.py 프로젝트: PinkInk/upylib
    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()
예제 #5
0
 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)
예제 #6
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
예제 #7
0
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))
예제 #8
0
    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)
예제 #9
0
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))
예제 #10
0
파일: session.py 프로젝트: PinkInk/upylib
    def __init__(self, conn, w, h, name):
        self.conn, self.addr = conn
        self.w = w
        self.h = h
        self.bpp = 32
        self.depth = 24
        self.big = True
        self.true = True
        channel_mask = 2**(self.depth//3)-1
        self.masks = (channel_mask, channel_mask, channel_mask)
        self.shifts = (16,8,0)
        self.name = name
        self._security = 1 # None/No Security
        self.encodings = [] # sent post init by client

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

        # Security
        self.send( pack('>L', self.security) )
        # ignore instruction to disconnect other clients
        if self.recv(True)[0] not in (0,1):
            raise RfbSessionRejected('no security')

        # ServerInit
        self.send(
            pack('>2H', w, h) \
            + ServerSetPixelFormat(
                self.bpp, self.depth, 
                self.big, self.true,
                self.masks, self.shifts
            ) \
            + pack('>L', len(name)) \
            + name
        )

        # we *may* be sent encodings and pixel format
        # we *must* process these messages before
        # sending any rectangles, otherwise we don't
        # know what encodings or pixel format client
        # accepts
        self.service_msg_queue()
예제 #11
0
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)
예제 #12
0
파일: encodings.py 프로젝트: PinkInk/upylib
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
            )
예제 #13
0
파일: session.py 프로젝트: PinkInk/upylib
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
예제 #14
0
 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
예제 #15
0
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)
예제 #16
0
파일: encodings.py 프로젝트: PinkInk/upylib
 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
예제 #17
0
파일: encodings.py 프로젝트: PinkInk/upylib
 def to_bytes(self):
     # non-standard encoding ... don't call super()
     return colour_to_pixel(
                 self.colour, 
                 self.bpp, self.depth, 
                 self.big, self.true, 
                 self.masks, self.shifts
            ) \
            + pack('>4H', 
                   self.x, self.y,
                   self.w, self.h
            )
예제 #18
0
 def register(self, fd, eventmask=EPOLLIN|EPOLLPRI|EPOLLOUT, retval=None):
     "retval is extension to stdlib, value to use in results from .poll()."
     if retval is None:
         retval = fd
     s = struct.pack(epoll_event, eventmask, retval)
     r = epoll_ctl(self.epfd, EPOLL_CTL_ADD, fd, s)
     if r == -1 and os.errno_.get() == errno.EEXIST:
         r = epoll_ctl(self.epfd, EPOLL_CTL_MOD, fd, s)
     os.check_error(r)
     # We must keep reference to retval, or it may be GCed. And we must
     # keep mapping from fd to retval to be able to get rid of this retval
     # reference later.
     self.registry[fd] = retval
예제 #19
0
파일: blynk.py 프로젝트: jantje/badge
 def _server_alive(self):
     c_time = int(time.time())
     if self._m_time != c_time:
         self._m_time = c_time
         self._tx_count = 0
         if self._wdt:
             self._wdt.feed()
         if self._last_hb_id != 0 and c_time - self._hb_time >= MAX_SOCK_TO:
             return False
         if c_time - self._hb_time >= HB_PERIOD and self.state == AUTHENTICATED:
             self._hb_time = c_time
             self._last_hb_id = self._new_msg_id()
             self._send(struct.pack(HDR_FMT, MSG_PING, self._last_hb_id, 0), True)
     return True
예제 #20
0
    def _pack_remaining_length(self, packet, remaining_length):
        print("_pack_remaining_length")
        #from _send_subscribe and _send_connect
        #remaining_bytes = [] ? not used for anything
        while True:
            byte = remaining_length % 128
            remaining_length = remaining_length // 128
            # If there are more digits to encode, set the top bit of this digit
            if remaining_length > 0:
                byte = byte | 0x80

            #remaining_bytes.append(byte)
            packet.extend(struct.pack("!B", byte))
            if remaining_length == 0:
                # FIXME - this doesn't deal with incorrectly large payloads
                return packet
예제 #21
0
def slave():
    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[1])
    nrf.open_rx_pipe(1, pipes[0])
    nrf.start_listening()

    print('NRF24L01 slave mode, waiting for packets... (ctrl-C to stop)')

    while True:
        if nrf.any():
            while nrf.any():
                buf = nrf.recv()
                millis, led_state = struct.unpack('ii', buf)
                print('received:', millis, led_state)
                for led in leds:
                    if led_state & 1:
                        led.on()
                    else:
                        led.off()
                    led_state >>= 1
                utime.sleep_ms(_RX_POLL_DELAY)

            # Give master time to get into receive mode.
            utime.sleep_ms(_SLAVE_SEND_DELAY)
            nrf.stop_listening()
            try:
                nrf.send(struct.pack('i', millis))
            except OSError:
                pass
            print('sent response')
            nrf.start_listening()
예제 #22
0
 def SendData(self, Data):
     Msg = pack("BB", self.Addr<<1, 0x40) + Data
     self.Bus.start()
     self.Bus.write(Msg)
     self.Bus.stop()
예제 #23
0
 def pwm(self, index, on=None, off=None):
     if on is None or off is None:
         data = self.i2c.mem_read(self.address, 0x06 + 4 * index, 4)
         return ustruct.unpack('<HH', data)
     data = ustruct.pack('<HH', on, off)
     self.i2c.mem_write(data, self.address, 0x06 + 4 * index)
예제 #24
0
except:
    try:
        import struct
    except ImportError:
        print("SKIP")
        raise SystemExit

print(struct.calcsize("<bI"))
print(struct.unpack("<bI", b"\x80\0\0\x01\0"))
print(struct.calcsize(">bI"))
print(struct.unpack(">bI", b"\x80\0\0\x01\0"))

# 32-bit little-endian specific
#print(struct.unpack("bI", b"\x80\xaa\x55\xaa\0\0\x01\0"))

print(struct.pack("<l", 1))
print(struct.pack(">l", 1))
print(struct.pack("<i", 1))
print(struct.pack(">i", 1))
print(struct.pack("<h", 1))
print(struct.pack(">h", 1))
print(struct.pack("<b", 1))
print(struct.pack(">b", 1))

print(struct.pack("<bI", -128, 256))
print(struct.pack(">bI", -128, 256))

print(struct.calcsize("100sI"))
print(struct.calcsize("97sI"))
print(struct.unpack("<6sH", b"foo\0\0\0\x12\x34"))
print(struct.pack("<6sH", b"foo", 10000))
예제 #25
0
 def encode(self, value):
     return pack("<f", value)
예제 #26
0
파일: mesh.py 프로젝트: indietyp/IoP
 def ip32bit(self, target):
     import ustruct
     return ustruct.pack('4B', *(int(x) for x in target.split('.')))
예제 #27
0
    def add_environmental_sensor_service(self):
        env_service_uuid = bytes(
            reversed([0x42, 0x82, 0x1a, 0x40, 0xe4, 0x77, 0x11, 0xe2,
                      0x82, 0xd0, 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b]))
        temp_char_uuid = bytes(
            reversed([0xa3, 0x2e, 0x55, 0x20, 0xe4, 0x77, 0x11, 0xe2,
                      0xa9, 0xe3, 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b]))
        press_char_uuid = bytes(
            reversed([0xcd, 0x20, 0xc4, 0x80, 0xe4, 0x8b, 0x11, 0xe2,
                      0x84, 0x0b, 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b]))
        humidity_char_uuid = bytes(
            reversed([0x01, 0xc5, 0x0b, 0x60, 0xe4, 0x8c, 0x11, 0xe2,
                      0xa0, 0x73, 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b]))

        char_format_struct = "<BBHBH"
        char_format_size = ustruct.calcsize(char_format_struct)

        max_attr_records = 6
        result = self.aci_gatt_add_serv(
            service_uuid_type=UUID_TYPE_128,
            service_uuid=env_service_uuid,
            service_type=PRIMARY_SERVICE,
            max_attr_records=(1+3*max_attr_records)).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_serv status: {:02x}".format(
                result.status))
        log.info("#env_serv_handle %04x", result.handle)
        self.env_serv_handle = result.handle

        # Temperature Characteristic
        result = self.aci_gatt_add_char(
            service_handle=self.env_serv_handle,
            char_uuid_type=UUID_TYPE_128,
            char_uuid=temp_char_uuid,
            char_value_len=2,
            char_properties=CHAR_PROP_NOTIFY|CHAR_PROP_READ,
            sec_permissions=ATTR_PERMISSION_NONE,
            gatt_evt_mask=GATT_NOTIFY_READ_REQ_AND_WAIT_FOR_APPL_RESP,
            encry_key_size=MAX_ENCRY_KEY_SIZE,
            is_variable=False).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_char status: {:02x}".format(
                result.status))
        self.temp_char_handle = result.handle
        log.info("#temp_char_handle: %04x", self.temp_char_handle)

        uuid16 = ustruct.pack(
            "<H",
            CHAR_FORMAT_DESC_UUID)

        char_format = ustruct.pack(
            char_format_struct,
            FORMAT_SINT16, -1, UNIT_TEMP_CELSIUS, 0, 0)

        result = self.aci_gatt_add_char_desc(
            service_handle=self.env_serv_handle,
            char_handle=self.temp_char_handle,
            desc_uuid_type=UUID_TYPE_16,
            uuid=uuid16,
            desc_value_max_len=char_format_size,
            desc_value_len=char_format_size,
            desc_value=char_format,
            sec_permissions=ATTR_PERMISSION_NONE,
            acc_permissions=ATTR_ACCESS_READ_ONLY,
            gatt_evt_mask=GATT_DONT_NOTIFY_EVENTS,
            encry_key_size=MAX_ENCRY_KEY_SIZE,
            is_variable=False).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_char_desc status: {:02x}".format(
                result.status))
        log.debug("aci_gatt_add_char_desc %02x", result.status)

        # Pressure Characteristic
        result = self.aci_gatt_add_char(
            service_handle=self.env_serv_handle,
            char_uuid_type=UUID_TYPE_128,
            char_uuid=press_char_uuid,
            char_value_len=2,
            char_properties=CHAR_PROP_NOTIFY|CHAR_PROP_READ,
            sec_permissions=ATTR_PERMISSION_NONE,
            gatt_evt_mask=GATT_NOTIFY_READ_REQ_AND_WAIT_FOR_APPL_RESP,
            encry_key_size=MAX_ENCRY_KEY_SIZE,
            is_variable=False).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_char status: {:02x}".format(
                result.status))
        self.press_char_handle = result.handle
        log.info("#press_char_handle: %04x", self.press_char_handle)

        char_format = ustruct.pack(
            char_format_struct,
            FORMAT_SINT24, -5, UNIT_PRESSURE_BAR, 0, 0)

        result = self.aci_gatt_add_char_desc(
            service_handle=self.env_serv_handle,
            char_handle=self.press_char_handle,
            desc_uuid_type=UUID_TYPE_16,
            uuid=uuid16,
            desc_value_max_len=char_format_size,
            desc_value_len=char_format_size,
            desc_value=char_format,
            sec_permissions=ATTR_PERMISSION_NONE,
            acc_permissions=ATTR_ACCESS_READ_ONLY,
            gatt_evt_mask=GATT_DONT_NOTIFY_EVENTS,
            encry_key_size=MAX_ENCRY_KEY_SIZE,
            is_variable=False).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_char_desc status: {:02x}".format(
                result.status))
        log.debug("aci_gatt_add_char_desc %02x", result.status)

        # Humidity Characteristic
        result = self.aci_gatt_add_char(
            service_handle=self.env_serv_handle,
            char_uuid_type=UUID_TYPE_128,
            char_uuid=humidity_char_uuid,
            char_value_len=2,
            char_properties=CHAR_PROP_NOTIFY|CHAR_PROP_READ,
            sec_permissions=ATTR_PERMISSION_NONE,
            gatt_evt_mask=GATT_NOTIFY_READ_REQ_AND_WAIT_FOR_APPL_RESP,
            encry_key_size=MAX_ENCRY_KEY_SIZE,
            is_variable=False).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_char status: {:02x}".format(
                result.status))
        self.humidity_char_handle = result.handle
        log.info("#humidity_char_handle: %04x", self.humidity_char_handle)

        char_format = ustruct.pack(
            char_format_struct,
            FORMAT_UINT16, -1, UNIT_UNITLESS, 0, 0)

        result = self.aci_gatt_add_char_desc(
            service_handle=self.env_serv_handle,
            char_handle=self.humidity_char_handle,
            desc_uuid_type=UUID_TYPE_16,
            uuid=uuid16,
            desc_value_max_len=char_format_size,
            desc_value_len=char_format_size,
            desc_value=char_format,
            sec_permissions=ATTR_PERMISSION_NONE,
            acc_permissions=ATTR_ACCESS_READ_ONLY,
            gatt_evt_mask=GATT_DONT_NOTIFY_EVENTS,
            encry_key_size=MAX_ENCRY_KEY_SIZE,
            is_variable=False).response_struct
        if result.status != BLE_STATUS_SUCCESS:
            raise ValueError("aci_gatt_add_char_desc status: {:02x}".format(
                result.status))
        log.debug("aci_gatt_add_char_desc %02x", result.status)
예제 #28
0
def swab32(n):
    # endian swap: 32 bits
    return ustruct.unpack('>I', ustruct.pack('<I', n))[0]
예제 #29
0
 def scroll(self, dy):
     self._scroll = (self._scroll + dy) % self.height
     self._write(_VSCRSADD, ustruct.pack(">H", self._scroll))
예제 #30
0
 def _readblock(self, x0, y0, x1, y1):
     self._write(_CASET, ustruct.pack(">HH", x0, x1))
     self._write(_PASET, ustruct.pack(">HH", y0, y1))
     if data is None:
         return self._read(_RAMRD, (x1 - x0 + 1) * (y1 - y0 + 1) * 3)
예제 #31
0
 def _writeblock(self, x0, y0, x1, y1, data=None):
     self._write(_CASET, ustruct.pack(">HH", x0, x1))
     self._write(_PASET, ustruct.pack(">HH", y0, y1))
     self._write(_RAMWR, data)
예제 #32
0
    def hash143_preimage_hash(self, txi: TxInputType,
                              pubkeyhash: bytes) -> bytes:
        h_preimage = HashWriter(
            blake2b(
                outlen=32,
                personal=b"ZcashSigHash" +
                struct.pack("<I", self.tx.branch_id),
            ))

        # 1. nVersion | fOverwintered
        write_uint32(h_preimage, self.tx.version | OVERWINTERED)
        # 2. nVersionGroupId
        write_uint32(h_preimage, self.tx.version_group_id)
        # 3. hashPrevouts
        write_bytes_fixed(h_preimage, get_tx_hash(self.h_prevouts),
                          TX_HASH_SIZE)
        # 4. hashSequence
        write_bytes_fixed(h_preimage, get_tx_hash(self.h_sequence),
                          TX_HASH_SIZE)
        # 5. hashOutputs
        write_bytes_fixed(h_preimage, get_tx_hash(self.h_outputs),
                          TX_HASH_SIZE)

        if self.tx.version == 3:
            # 6. hashJoinSplits
            write_bytes_fixed(h_preimage, b"\x00" * TX_HASH_SIZE, TX_HASH_SIZE)
            # 7. nLockTime
            write_uint32(h_preimage, self.tx.lock_time)
            # 8. expiryHeight
            write_uint32(h_preimage, self.tx.expiry)
            # 9. nHashType
            write_uint32(h_preimage, self.get_hash_type())
        elif self.tx.version == 4:
            zero_hash = b"\x00" * TX_HASH_SIZE
            # 6. hashJoinSplits
            write_bytes_fixed(h_preimage, zero_hash, TX_HASH_SIZE)
            # 7. hashShieldedSpends
            write_bytes_fixed(h_preimage, zero_hash, TX_HASH_SIZE)
            # 8. hashShieldedOutputs
            write_bytes_fixed(h_preimage, zero_hash, TX_HASH_SIZE)
            # 9. nLockTime
            write_uint32(h_preimage, self.tx.lock_time)
            # 10. expiryHeight
            write_uint32(h_preimage, self.tx.expiry)
            # 11. valueBalance
            write_uint64(h_preimage, 0)
            # 12. nHashType
            write_uint32(h_preimage, self.get_hash_type())
        else:
            raise wire.DataError(
                "Unsupported version for overwintered transaction")

        # 10a /13a. outpoint
        write_bytes_reversed(h_preimage, txi.prev_hash, TX_HASH_SIZE)
        write_uint32(h_preimage, txi.prev_index)

        # 10b / 13b. scriptCode
        script_code = derive_script_code(txi, pubkeyhash)
        write_bytes_prefixed(h_preimage, script_code)

        # 10c / 13c. value
        write_uint64(h_preimage, txi.amount)

        # 10d / 13d. nSequence
        write_uint32(h_preimage, txi.sequence)

        return get_tx_hash(h_preimage)
예제 #33
0
def dumps_float(val):
    return ustruct.pack("!Bd", _CBOR_FLOAT64, val)
예제 #34
0
 def __init__(self, scl, sda, addr):
     self.Bus = I2C(scl=Pin(scl), sda=Pin(sda), freq=400000)
     self.Addr = addr
     self.SendCommand(pack("26B",  0xAE,0xD5,0x80,0xA8,0x3F,0xD3,0x00,0x40,0x8D,0x14,0x20,0x01,0xA1,0xC8,0xDA,0x12,0x81,0xCF,0xD9,0xF1,0xDB,0x40,0x2E,0xA4,0xA6,0xAF))
# I2C with the Arduino as the master device and the OpenMV Cam as the slave.
#
# Please wire up your OpenMV Cam to your Arduino like this:
#
# OpenMV Cam Master I2C Data  (P5) - Arduino Uno Data  (A4)
# OpenMV Cam Master I2C Clock (P4) - Arduino Uno Clock (A5)
# OpenMV Cam Ground                - Arduino Ground

import pyb, ustruct

text = "Hello World!\n"
data = ustruct.pack("<%ds" % len(text), text)
# Use "ustruct" to build data packets to send.
# "<" puts the data in the struct in little endian order.
# "%ds" puts a string in the data stream. E.g. "13s" for "Hello World!\n" (13 chars).
# See https://docs.python.org/3/library/struct.html

# READ ME!!!
#
# Please understand that when your OpenMV Cam is not the I2C master it may miss responding to
# sending data as a I2C slave no matter if you call "i2c.send()" in an interupt callback or in the
# main loop below. When this happens the Arduino will get a NAK and have to try reading from the
# OpenMV Cam again. Note that both the Arduino and OpenMV Cam I2C drivers are not good at getting
# unstuck after encountering any I2C errors. On the OpenMV Cam and Arduino you can recover by
# de-initing and then re-initing the I2C peripherals.

# The hardware I2C bus for your OpenMV Cam is always I2C bus 2.
bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=0x12)
bus.deinit() # Fully reset I2C device...
bus = pyb.I2C(2, pyb.I2C.SLAVE, addr=0x12)
print("Waiting for Arduino...")
예제 #36
0
def xfp2str(xfp):
    # Standardized way to show an xpub's fingerprint... it's a 4-byte string
    # and not really an integer. Used to show as '0x%08x' but that's wrong endian.
    return b2a_hex(ustruct.pack('<I', xfp)).decode().upper()
예제 #37
0
def _decode_single(single):
    return ustruct.unpack("!f", ustruct.pack("!I", single))[0]
예제 #38
0
 def _encode_pos(self, x, y):
     """Encode a postion into bytes."""
     return struct.pack(_ENCODE_POS, x, y)
예제 #39
0
 def set_memory_pointer(self, x, y):
     self._command(SET_RAM_X_ADDRESS_COUNTER)
     # x point must be the multiple of 8 or the last 3 bits will be ignored
     self._data(bytearray([(x >> 3) & 0xFF]))
     self._command(SET_RAM_Y_ADDRESS_COUNTER, ustruct.pack("<H", y))
     self.wait_until_idle()
예제 #40
0
Important:
    This script should be copied to the OpenMV Cam as `main.py`.

Source:
    https://github.com/openmv/openmv/blob/master/scripts/examples/02-Board-Control/usb_vcp.py

"""
import sensor
import ustruct
import pyb

usb_vcp = pyb.USB_VCP()
# Disable USB interrupt (CTRL-C by default) when sending raw data (i.e. images)
# See: https://docs.openmv.io/library/pyb.USB_VCP.html#pyb.USB_VCP.setinterrupt
usb_vcp.setinterrupt(-1)

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.VGA)
sensor.skip_frames(time=2000)  # wait for settings to take effect!

while True:

    command = usb_vcp.recv(4, timeout=5000)

    if command == b'snap':
        image = sensor.snapshot().compress()
        usb_vcp.send(ustruct.pack('<L', image.size()))
        usb_vcp.send(image)
예제 #41
0
 def _write_register(self, reg, f):
     global i2c
     n = self.round_total_digits(f)
     fd = bytearray(ustruct.pack("f", n))
     i2c.writeto_mem(self.address, reg, fd)
     time.sleep(10 / 1000.0)
예제 #42
0
def pack_temp(temp):
    """Temperature in 0.005 degrees as signed short"""
    temp_conv = round(round(temp, 2) / 0.005)
    return pack("!h", temp_conv)
예제 #43
0
파일: midi_out.py 프로젝트: hrgraf/pico
import machine
import time
import ustruct

pin = machine.Pin(25, machine.Pin.OUT)
uart = machine.UART(1, 31250)

notes = [60, 61, 62, 63, 64, 63, 62, 61]

while True:
    for x in notes:
        pin.value(1)
        uart.write(ustruct.pack("bbb", 0x90, x, 0x40))
        time.sleep(0.5)
        pin.value(0)
        time.sleep(0.5)
        uart.write(ustruct.pack("bbb", 0x90, x, 0x00))
예제 #44
0
def pack_humid(hum):
    """Humidity in 0.0025 percent as unsigned short"""
    hum_conv = round(round(hum, 2) / 0.0025)
    return pack("!H", hum_conv)
예제 #45
0
 def switch_channel(self, channel):
     self.bus.writeto(self.address, ustruct.pack('B', 1 << channel))
예제 #46
0
_CBOR_TAG_DECIMAL = const(4)  # [ 10^x exponent, number ]
_CBOR_TAG_BIGFLOAT = const(5)  # [ 2^x exponent, number ]
_CBOR_TAG_BASE64URL = const(21)
_CBOR_TAG_BASE64 = const(22)
_CBOR_TAG_BASE16 = const(23)
_CBOR_TAG_CBOR = const(24)  # following byte string is embedded CBOR data

_CBOR_TAG_URI = const(32)
_CBOR_TAG_BASE64URL_STR = const(33)
_CBOR_TAG_BASE64_STR = const(34)
_CBOR_TAG_REGEX = const(35)
_CBOR_TAG_MIME = const(
    36)  # following text is MIME message, headers, separators and all
_CBOR_TAG_CBOR_FILEHEADER = const(55799)  # can open a file with 0xd9d9f7

_CBOR_TAG_BIGNUM_BYTES = ustruct.pack('B', _CBOR_TAG | _CBOR_TAG_BIGNUM)
_CBOR_TAG_NEGBIGNUM_BYTES = ustruct.pack('B', _CBOR_TAG | _CBOR_TAG_NEGBIGNUM)

_MAX_DEPTH = const(100)


def dumps_int(val):
    "return bytes representing int val in CBOR"
    cbor_type = _CBOR_UINT
    cbor_tag = _CBOR_TAG_BIGNUM_BYTES
    if val < 0:
        val = -1 - val
        cbor_type = _CBOR_NEGINT
        cbor_tag = _CBOR_TAG_NEGBIGNUM_BYTES

    if val <= 0x0ffffffffffffffff:  #NOT BIGINT
예제 #47
0
 def SendCommand(self, Cmd):
     Msg = pack("BB", self.Addr<<1, 0x00) + Cmd
     self.Bus.start()
     self.Bus.write(Msg)
     self.Bus.stop()
예제 #48
0
 def encodeFixed(n, fmt='<f'):
     return struct.pack(fmt, n)
예제 #49
0
def swap16(i):
    return ustruct.unpack("<H", ustruct.pack(">H", i))[0]
예제 #50
0
def long_to_bytes(_int):  # signed int
    return pack(">q", _int)
예제 #51
0
# test ustruct with a count specified before the type

try:
    import ustruct as struct
except:
    try:
        import struct
    except ImportError:
        import sys
        print("SKIP")
        sys.exit()

print(struct.calcsize('0s'))
print(struct.unpack('0s', b''))
print(struct.pack('0s', b'123'))

print(struct.calcsize('2s'))
print(struct.unpack('2s', b'12'))
print(struct.pack('2s', b'123'))

print(struct.calcsize('2H'))
print(struct.unpack('<2H', b'1234'))
print(struct.pack('<2H', 258, 515))

print(struct.calcsize('0s1s0H2H'))
print(struct.unpack('<0s1s0H2H', b'01234'))
print(struct.pack('<0s1s0H2H', b'abc', b'abc', 258, 515))

# check that unknown types raise an exception
try:
    struct.unpack('z', b'1')
예제 #52
0
def short_to_bytes(_short):
    return pack('>b', _short)
예제 #53
0
파일: encodings.py 프로젝트: PinkInk/upylib
 def to_bytes(self):
     return pack('>4HL',
                 self.x, self.y,
                 self.w, self.h,
                 self.encoding
            )
예제 #54
0
def signedchar_to_bytes(_signedchar):
    return pack('>b', _signedchar)
예제 #55
0
 def _send_str(self, s):
     self.sock.write(struct.pack("!H", len(s)))
     self.sock.write(s)
예제 #56
0
def dumps_bool(b):
    return ustruct.pack('B', _CBOR_TRUE) if b else ustruct.pack(
        'B', _CBOR_FALSE)
예제 #57
0
 def _encode_pixel(self, color):
     """Encode a pixel color into bytes."""
     return struct.pack(_ENCODE_PIXEL, color)
예제 #58
0
def int_to_bytes(_int):  # signed int
    return pack(">i", _int)
예제 #59
0
 def _send_str(self, s):
     self.sock.write(struct.pack("!H", len(s)))
     self.sock.write(s)
예제 #60
0
 def pwm(self, index, on=None, off=None):
     if on is None or off is None:
         data = self.i2c.readfrom_mem(self.address, 0x06 + 4 * index, 4)
         return ustruct.unpack('<HH', data)
     data = ustruct.pack('<HH', on, off)
     self.i2c.writeto_mem(self.address, 0x06 + 4 * index, data)