• robStacks

    Where do I put in the CHPROPS?
    Should I put it in sitepackages and import it in the beginning of the code?
    Keep getting “CHPROPS” is not defined no matter where in the code I put it in.

    Thx again for the help!

    posted in Pythonista read more
  • robStacks

    Ok thx for your help I get the full readout now
    Listing all services and characteristics
    Now I want to get the raw values of all the sensors and print them.
    You talked about setting up a semafore system?
    I am totally new to this can you explain more in-depth please?

    The code till now:

    
    import cb
    import time
    
    class HexiwearManager (object):
        def __init__(self):
            self.peripheral = None
    
        def did_discover_peripheral(self, p):
            if p.name and 'HEXIWEAR' in p.name and not self.peripheral:
                self.peripheral = p
                print('Connecting to Hexiwear...')
                cb.connect_peripheral(p)
    
        def did_connect_peripheral(self, p):
            print('Connected:', p.name)
            print('Discovering services...')
            p.discover_services()
    
        def did_discover_services(self, p, error):
            print('did_discover_services({})'.format(p.name))
            cb.get_state()
            print("Name:", p.name)
            print("UUID:", p.uuid)
            try:
                state = 'Disconnected Connecting Connected'.split()[p.state]
            except IndexError:
                state = 'Invalid state ({})'.format(p.state)
            print("STAT: ", state)
            time.sleep(0.4)
            print("AUTH:", cb.CH_PROP_AUTHENTICATED_SIGNED_WRITES)
            time.sleep(0.4)
            print("Properties:", cb.CH_PROP_EXTENDED_PROPERTIES)
            time.sleep(0.4)
            print("Indicate:", cb.CH_PROP_INDICATE)
            time.sleep(0.4)
            print("Encryption:", cb.CH_PROP_NOTIFY_ENCRYPTION_REQUIRED)
            time.sleep(0.4)
            print("{} Services:".format(len(p.services)))
            for s in p.services:
                print("-" + str(s.uuid))
                p.discover_characteristics(s)
    
        def did_discover_characteristics(self, s, error):
            
            print("{} Characteristics:".format(len(s.characteristics)))
            for c in s.characteristics:
                print("-" + str(c.uuid))
                
    
        def did_fail_to_connect_peripheral(self, p, error):
            print('Failed to connect: %s' % (error,))
    
        def did_disconnect_peripheral(self, p, error):
            print('Disconnected, error: %s' % (error,))
            self.peripheral = None
            
         
    mngr = HexiwearManager()
    cb.set_central_delegate(mngr)
    print('Scanning for Hexiwear...')
    cb.scan_for_peripherals()
    
    try:
        while True: pass
    except KeyboardInterrupt:
        cb.reset() ```

    posted in Pythonista read more
  • robStacks

    Well almost now I am getting just the first characteristic of each service but getting closer.

    Thx a bunch!

    posted in Pythonista read more
  • robStacks

    Great thx that’s it thx allot!

    posted in Pythonista read more
  • robStacks

    Need some help with access to BLE services & characteristics with the Hexiwear dev platformpje !?

    from __future__ import print_function
    import cb
    import sound
    import time
    import struct
    import console
    
    console.set_color(0, 0, 1)
    print("""
      _  _             _____ _
     | || |___ _  _ * | __  | |_ _ ___
     | -- | -_| \/  | | __ -| | | | -_|
     |_||_|___|_/\__|_ _____|_|___|___|
     
    """)
    console.set_color()
    
    
    class HeartRateManager (object):
        def __init__(self):
            self.peripheral = None
    
        def did_discover_peripheral(self, p):
            if p.name and 'HEXIWEAR' in p.name and not self.peripheral:
                self.peripheral = p
                print('Connecting to Hexiwear...')
                cb.connect_peripheral(p)
    
        def did_connect_peripheral(self, p):
            print('Connected:', p.name)
            print('Discovering services...')
            p.discover_services()
    
        def did_discover_services(self, p, error):
            print('did_discover_services({})'.format(p.name))
            cb.get_state()
            print("Name:", p.name)
            print("UUID:", p.uuid)
            try:
                state = 'Disconnected Connecting Connected'.split()[p.state]
            except IndexError:
                state = 'Invalid state ({})'.format(p.state)
            print("STAT: ", state)
            time.sleep(0.4)
            print("AUTH:", cb.CH_PROP_AUTHENTICATED_SIGNED_WRITES)
            time.sleep(0.4)
            print("Properties:", cb.CH_PROP_EXTENDED_PROPERTIES)
            time.sleep(0.4)
            print("Indicate:", cb.CH_PROP_INDICATE)
            time.sleep(0.4)
            print("Encryption:", cb.CH_PROP_NOTIFY_ENCRYPTION_REQUIRED)
            time.sleep(0.4)
            print("{} Services:".format(len(p.services)))
            for s in p.services:
                print("-" + str(s.uuid))
            p.discover_characteristics(s)
    
        def did_discover_characteristics(self, s, error):
            print("Characteristics:")
            for c in s.characteristics:
                print("-" + str(c.uuid))
                # s.set_notify_value(c, True)
                s.read_characteristic_value(c)
                data = s.read_characteristic_value(c)
                print(c.value, data)
    
        def did_write_value(self, c, error):
            print(self.peripheral.properties)
            time.sleep(0.5)
    
        def did_update_value(self, c, error):
            time.sleep(0.5)
    
        def did_fail_to_connect_peripheral(self, p, error):
            print('Failed to connect: %s' % (error,))
    
        def did_disconnect_peripheral(self, p, error):
            print('Disconnected, error: %s' % (error,))
            self.peripheral = None
    
    
    mngr = HeartRateManager()
    cb.set_central_delegate(mngr)
    print('Scanning for Hexiwear...')
    cb.scan_for_peripherals()
    
    try:
        while True: pass
    except KeyboardInterrupt:
        cb.reset()
    

    Can’t get access to all characteristics need some pointers!?

    Thx in advance

    posted in Pythonista read more
  • robStacks

    @mikael Yes thx for pointing that out to me did so and is so much better👍🏻

    posted in Pythonista read more
  • robStacks

    How can i prefill a textfield with strings and variables combined?
    This code gets me an expected string error:

    if delta.degrees < 0:
                sometext = ('B:', int(delta.degrees + 360), 'D:', int(delta.magnitude))
            else:
                sometext = ('B:', int(delta.degrees), 'D:', int(delta.magnitude))
    
            tv['textfield1'].text = sometext
    

    What am i doing wrong?

    posted in Pythonista read more
  • robStacks

    @ccc
    Ok thx for pointing that out to me i will chance it.👍🏻

    posted in Pythonista read more
  • robStacks

    Ok no worries Bumbo i am also a beginner in python and it is a great code language.
    Its easy to read and understand and with a great communitie very helpfull.
    I managed to create something awesome and usefull in a short time thx to that.
    I'll show you my progress so you can see:

    import math
    import ui
    import console
    import photos
    import matplotlib.pyplot as plt
    import numpy as np
    from io import BytesIO
    
    class Vector(list):
        abs_tol = 1e-10
    
        def __init__(self, *args, **kwargs):
            x = kwargs.pop('x', None)
            y = kwargs.pop('y', None)
    
            if x and y:
                self.append(x)
                self.append(y)
            elif len(args) == 2:
                self.append(args[0])
                self.append(args[1])
            else:
                super().__init__(*args, **kwargs)
    
        @property
        def x(self):
            ''' x component of the vector. '''
            return self[0]
    
        @x.setter
        def x(self, value):
            self[0] = value
    
        @property
        def y(self):
            ''' y component of the vector. '''
            return self[1]
    
        @y.setter
        def y(self, value):
            self[1] = value
    
        def __eq__(self, other):
            return math.isclose(
                self[0], other[0], abs_tol=self.abs_tol) and math.isclose(
                    self[1], other[1], abs_tol=self.abs_tol)
    
        def __ne__(self, other):
            return not self.__eq__(other)
    
        def __abs__(self):
            return type(self)(abs(self.x), abs(self.y))
    
        def __int__(self):
            return type(self)(int(self.x), int(self.y))
    
        def __add__(self, other):
            return type(self)(self.x + other.x, self.y + other.y)
    
        def __iadd__(self, other):
            self.x += other.x
            self.y += other.y
            return self
    
        def __sub__(self, other):
            return type(self)(self.x - other.x, self.y - other.y)
    
        def __mul__(self, other):
            return type(self)(self.x * other, self.y * other)
    
        def __truediv__(self, other):
            return type(self)(self.x / other, self.y / other)
    
        def __len__(self):
            return self.magnitude
    
        def __round__(self):
            return type(self)(round(self.x), round(self.y))
    
        def dot_product(self, other):
            ''' Sum of multiplying x and y components with the x and y components of another vector. '''
            return self.x * other.x + self.y * other.y
    
        def distance_to(self, other):
            ''' Linear distance between this vector and another. '''
            return (Vector(other) - self).magnitude
    
        @property
        def magnitude(self):
            ''' Length of the vector, or distance from (0,0) to (x,y). '''
            return math.hypot(self.x, self.y)
    
        @magnitude.setter
        def magnitude(self, m):
            r = self.radians
            self.polar(r, m)
    
        @property
        def radians(self):
            ''' Angle between the positive x axis and this vector, in radians. '''
            #return round(math.atan2(self.y, self.x), 10)
            return math.atan2(self.y, self.x)
    
        @radians.setter
        def radians(self, r):
            m = self.magnitude
            self.polar(r, m)
    
        def polar(self, r, m):
            ''' Set vector in polar coordinates. `r` is the angle in radians, `m` is vector magnitude or "length". '''
            self.y = math.sin(r) * m
            self.x = math.cos(r) * m
    
        @property
        def degrees(self):
            ''' Angle between the positive x axis and this vector, in degrees. '''
            return math.degrees(self.radians)
    
        @degrees.setter
        def degrees(self, d):
            self.radians = math.radians(d)
    
        def steps_to(self, other, step_magnitude=1.0):
            """ Generator that returns points on the line between this and the other point, with each step separated by `step_magnitude`. Does not include the starting point. """
            if self == other:
                yield other
            else:
                step_vector = other - self
                steps = math.floor(step_vector.magnitude / step_magnitude)
                step_vector.magnitude = step_magnitude
                current_position = Vector(self)
                for _ in range(steps):
                    current_position += step_vector
                    yield Vector(current_position)
                if current_position != other:
                    yield other
    
        def rounded_steps_to(self, other, step_magnitude=1.0):
            ''' As `steps_to`, but returns points rounded to the nearest integer. '''
            for step in self.steps_to(other):
                yield round(step)
    
    bearingblue = int(input("Bearing blue: "))
    rangeblue = int(input("Range blue:   "))
    
    bearingred = int(input("Bearing red:  "))
    rangered = int(input("Range red:    "))
    
    blue = Vector(rangeblue, 0)
    blue.degrees = bearingblue
    
    red = Vector(rangered, 0)
    red.degrees = bearingred
    
    delta = red - blue
    
    way = np.loadtxt('waypoints.txt')
    ways = way[:, 0]
    r = way[:, 1]
    
    if delta.degrees < 0:
        print('Bearing: ', int(delta.degrees + 360))
        print('Distance:', int(delta.magnitude))
    else:
        print('Bearing: ', int(delta.degrees))
        print('Distance:', int(delta.magnitude))
    
    thetablue= np.deg2rad(bearingblue)
    thetared= np.deg2rad(bearingred)
    thetawayp= np.deg2rad(ways)
    
    class PathView(ui.View):
        def __init__(self, frame):
            self.frame = frame
            self.flex = 'WH'
            self.path = None
            self.action = None
    
        def touch_began(self, touch):
            x, y = touch.location
            self.path = ui.Path()
            self.path.line_width = 1
            self.path.line_join_style = ui.LINE_JOIN_ROUND
            self.path.line_cap_style = ui.LINE_CAP_ROUND
            self.path.move_to(x, y)
    
        def touch_moved(self, touch):
            x, y = touch.location
            self.path.line_to(x, y)
            self.set_needs_display()
    
        def touch_ended(self, touch):
            # Send the current path to the SketchView:
            if callable(self.action):
                self.action(self)
            # Clear the view (the path has now been rendered
            # into the SketchView's image view):
            self.path = None
            self.set_needs_display()
    
        def draw(self):
            if self.path:
                self.path.stroke()
    
    ax = plt.subplot(111, projection='polar')
    plt.polar(thetawayp, r)
    plt.polar(thetawayp, r, 'k.', zorder=3)
    ax.scatter(thetablue,rangeblue)
    ax.scatter(thetared,rangered, color='r')
    ax.set_theta_direction(-1)
    ax.set_rmax(120)
    ax.set_theta_zero_location('N')
    ax.set_title("N ", va='bottom')
    ax.grid(True)
    b = BytesIO()
    
    plt.savefig(b)
    
    
    class SketchView(ui.View):
        def __init__(self, width=768, height=768):
            self.bg_color = '#ffffff'
            iv = ui.ImageView(frame=(0, 0, width, height))
            bg = ui.Image.from_data(b.getvalue())
            iv.image = bg
            iv.content_mode = ui.CONTENT_SCALE_ASPECT_FILL
            image_view = ui.ImageView()
            image_view.image = ui.Image.named('Bullseye.png')
            image_view.present()
            pv = PathView(frame=self.bounds)
            pv.action = self.path_action
            self.add_subview(iv)
            self.add_subview(pv)
            blue_button = ui.ButtonItem()
            blue_button.title = 'Bluebulls'
            blue_button.action = self.bluebulls_action
            red_button = ui.ButtonItem()
            red_button.title = 'Redbulls'
            red_button.tint_color = '#990000'
            red_button.action = self.redbulls_action 
            maps_button = ui.ButtonItem()
            maps_button.title = 'Maps'
            maps_button.tint_color = '#000d99'
            maps_button.action = self.map_action
            save_button = ui.ButtonItem()
            save_button.title = 'Save Image'
            save_button.action = self.save_action
            plot_button = ui.ButtonItem()
            plot_button.title = 'Plot'
            plot_button.tint_color = '#000d99'
            plot_button.action = self.plot_action
            clear_button = ui.ButtonItem()
            clear_button.title = 'Clear'
            clear_button.tint_color = '#af0000'
            clear_button.action = self.clear_action
            self.right_button_items = [save_button, plot_button, red_button]
            self.left_button_items = [clear_button, maps_button, blue_button]
            self.image_view = iv
    
        
        def map_action(self, sender):
    # Show an image picker dialog (allowing multiple selection) and print the result
            assets = photos.pick_asset(title='Pick a Map', multi=True)
            
    
        def path_action(self, sender):
            path = sender.path
            old_img = self.image_view.image
            width, height = 768, 768
    
            with ui.ImageContext(width, height) as ctx:
                if old_img:
                    old_img.draw()
                path.stroke()
                self.image_view.image = ctx.get_image()
                            
        def redbulls_action(self, sender):
            m=1
        def bluebulls_action(self, sender):
            m=1
        def plot_action(self, sender):
            self.image_view.image = ui.Image.from_data(b.getvalue())
    
        def clear_action(self, sender):
            self.image_view.image = None
    
        def save_action(self, sender):
            if self.image_view.image:
                # We draw a new image here, so that it has the current
                # orientation (the canvas is quadratic).
                with ui.ImageContext(self.width, self.height) as ctx:
                    self.image_view.image.draw()
                    img = ctx.get_image()
                    photos.save_image(img)
                    console.hud_alert('Saved')
            else:
                console.hud_alert('No Image', 'error')
    
    
    sv = SketchView()
    sv.name = 'BullseyePad'
    sv.present()
    
    

    Its starting to look like an useable app already👍🏻

    I am looking into API's right Now not so hard to use and lots of them look it up.
    Maybe you can find a nice project for u with the use of API's

    Goodluck finding a Nice project!

    posted in Pythonista read more

Internal error.

Oops! Looks like something went wrong!