Avatar for Riccardokhm

Riccardokhm

Member since Sep 2022 • Last active Sep 2023
  • 6 conversations
  • 28 comments

Most recent activity

  • in Bangle.js
    Avatar for Riccardokhm

    Clear! Thanks you! What about if I'd like reading bytes or int16 data sent over ble to my bangle?
    The bangle encode the data in the ASCII format right? I then need to convert it in string right?

  • in Bangle.js
    Avatar for Riccardokhm

    Thanks guys for your continous support! I will go through the script you posted!

    • 4 comments
    • 447 views
  • in Bangle.js
    Avatar for Riccardokhm

    Hi guys,
    do you know if the value reported by the event 'hrm-raw' and in particular the ones in the Uint8Array
    vcRaw are referred to BPMs or something else? Is there any kind of documentation anywhere?
    Here attached a screenshot of the data printed to the console.

  • in Puck.js, Pixl.js and MDBT42
    Avatar for Riccardokhm

    Sorry for the spam, I didn't mean to change topic. I will go through Gordon's suggestions: I already test the BLE console and I am now working on a custom solution adapted to my needs. Anyway, thank you for your time!

  • in Puck.js, Pixl.js and MDBT42
    Avatar for Riccardokhm

    Clear, actually my laptop console application is connected to the Nordic UART service, so it should work. Unfortunately, by now, the bangle receives only the first data buffer: when I tried to send it again, no event is triggered.

        internal class Program
        {
            static DeviceInformation _device = null;
            private static string NORDIC_UART_SERVICE = "6e400001-b5a3-f393-e0a9-e50e24dcca9e";
            static DataFormat _dataFormat = DataFormat.UTF8;
    
            static GattCommunicationStatus result;
            static GattCharacteristic _characteristic;
            static GattLocalCharacteristic _readcharacteristic;
    
    
            static GattServiceProvider _serviceProvider;
            static Guid _serviceuuid= new Guid("F150E6C7-0DB4-4645-AE74-023C395983­72");
            static Guid _characteristicuuid = new Guid("B952F9C0-218D-42B6-8EE6-4AAB357539­22");
            static GattLocalCharacteristicParameters _characteristicparameter = new GattLocalCharacteristicParameters();
    
            static DataWriter writer = new DataWriter();
    
            static async Task Main(string[] args)
            {
                // Query for extra properties you want returned
                string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
    
                DeviceWatcher deviceWatcher =
                            DeviceInformation.CreateWatcher(
                                    BluetoothLEDevice.GetDeviceSelectorFromP­airingState(false),
                                    requestedProperties,
                                    DeviceInformationKind.AssociationEndpoin­t);
    
                // Register event handlers before starting the watcher.
                // Added, Updated and Removed are required to get all nearby devices
                deviceWatcher.Added += DeviceWatcher_Added;
                deviceWatcher.Updated += DeviceWatcher_Updated;
                deviceWatcher.Removed += DeviceWatcher_Removed;
                
    
                // EnumerationCompleted and Stopped are optional to implement.
                deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
                deviceWatcher.Stopped += DeviceWatcher_Stopped;
    
                // Start the watcher.
                deviceWatcher.Start();
    
                //STARTING CREATING SERVICE
    
                GattServiceProviderResult _result = await GattServiceProvider.CreateAsync(_service­uuid);
                Console.WriteLine("Creating new service");
    
                if (_result.Error == BluetoothError.Success)
                {
                    _serviceProvider = _result.ServiceProvider;
                    Console.WriteLine($"{_result.Error}");
                }
                byte[] value = new byte[] { 0x21 };
    
                _characteristicparameter.WriteProtection­Level = GattProtectionLevel.Plain;
                _characteristicparameter.ReadProtectionL­evel = GattProtectionLevel.Plain;
                _characteristicparameter.StaticValue = value.AsBuffer();
                _characteristicparameter.UserDescription­ = "Read Characteristic";
                _characteristicparameter.CharacteristicP­roperties = GattCharacteristicProperties.Read; 
                
    
                GattLocalCharacteristicResult characteristicResult = await _serviceProvider.Service.CreateCharacter­isticAsync(_characteristicuuid, _characteristicparameter);
    
                if (characteristicResult.Error != BluetoothError.Success)
                {
                    Console.WriteLine("Errore nella creazione della caratteristica di Read");
                    return;
                }
                _readcharacteristic = characteristicResult.Characteristic;
                Console.WriteLine("Characteristic " + _characteristicuuid + " is a " + _readcharacteristic.CharacteristicProper­ties + " characteristic");
                _readcharacteristic.ReadRequested += ReadRequested;
    
                GattServiceProviderAdvertisingParameters­ advParameters = new GattServiceProviderAdvertisingParameters­
                {         
                    IsDiscoverable = true,
                    IsConnectable = true
                };
                
                
                _serviceProvider.StartAdvertising(advPar­ameters);
                Console.WriteLine(_serviceProvider.Adver­tisementStatus.ToString());
                Console.WriteLine("The service started successfully and has " + _serviceProvider.Service.Characteristics­.Count + " characteristics");
    
                while (true)
                {
                    if (_device == null)
                    {
                        Thread.Sleep(200);
                    }
                    else
                    {
                        Console.WriteLine("Press any key to connect to the Bangle. Js");
                        Console.ReadKey();
                        BluetoothLEDevice bluetoothLEDevice = await BluetoothLEDevice.FromIdAsync(_device.Id­);
                        Console.WriteLine("Pairing with the device");
    
                        GattDeviceServicesResult servicesResult = await bluetoothLEDevice.GetGattServicesAsync()­;
    
                        if (servicesResult.Status == GattCommunicationStatus.Success)
                        {
                            Console.WriteLine("Pairing succeed");
                            var services = servicesResult.Services;
                            foreach (var service in services)
                            {
                                Console.WriteLine($"Service: {service.Uuid}");
                                Console.WriteLine("---------------------­--");
    
                                if (service.Uuid.ToString() == NORDIC_UART_SERVICE)
                                {
                                    Console.WriteLine("Connected to NUS Service");
                                    Console.WriteLine("---------------------­-------------");
    
                                    GattCharacteristicsResult characteristicsResult = await service.GetCharacteristicsAsync();
                                  
                                    if (characteristicsResult.Status == GattCommunicationStatus.Success)
                                    {
                                        var characteristics = characteristicsResult.Characteristics;
                                        foreach (var characteristic in characteristics)
                                        {
                                            Console.WriteLine($"Characteristic {characteristic.Uuid}");
                                            Console.WriteLine("---------------------­-----------");
                                            GattCharacteristicProperties properties = characteristic.CharacteristicProperties;­
    
                                            if (properties.HasFlag(GattCharacteristicPr­operties.Notify))
                                            {
                                                Console.WriteLine("Notify property found");
    
                                                GattCommunicationStatus status = await characteristic.WriteClientCharacteristic­ConfigurationDescriptorAsync(GattClientC­haracteristicConfigurationDescriptorValu­e.Notify);
                                                if (status == GattCommunicationStatus.Success)
                                                {
                                                    Console.WriteLine("Server has been informed of clients interest and has set the client in notify status");
                                                    characteristic.ValueChanged += Characteristic_ValueChanged;
                                                    _characteristic = characteristic;
                                                    
                                                }
                                            }
    
                                            else if (properties.HasFlag(GattCharacteristicPr­operties.Write))
                                            {
                                                Console.WriteLine($"\t \t Characteristic {characteristic.Uuid} has a write property ");
                                                Console.WriteLine("---------------------­----------- ");
                                                
                                                writer.WriteString("Data sent");
                                                                                           
                                                result = await characteristic.WriteValueAsync(writer.De­tachBuffer());
                                                if (result == GattCommunicationStatus.Success)
                                                {
                                                    Console.WriteLine("Data sent");  
                                                }
                                            }
                                            else if (properties.HasFlag(GattCharacteristicPr­operties.WriteWithoutResponse))
                                            {
                                                Console.WriteLine($"\t \t Characteristic {characteristic.Uuid} has a write withoutresponse property ");
                                                Console.WriteLine("---------------------­----------- ");
    
                                            }
                                        }
                                    }
                                }
                            }
                        }
    
                        Console.WriteLine("Press space to disconnect or q to exit");
    
                             
                        if (Console.ReadKey().Key == ConsoleKey.Spacebar)
                        {
                            bluetoothLEDevice.Dispose();
                            return;
                        }
                        else if (Console.ReadKey().Key == ConsoleKey.Q)
                        {
                            Console.WriteLine("Closing");
                            Thread.Sleep(1000);
                            break;
                        }
    
                        if (Console.ReadKey().Key == ConsoleKey.Enter)
                        {
                            writer.WriteByte(0x12);
    
                            result = await _characteristic.WriteValueAsync(writer.D­etachBuffer());
                            if (result == GattCommunicationStatus.Success)
                            {
                                Console.WriteLine("Data sent");
                            }
                        }
    
                    }
                    
                }
    
            }
    
    
  • in Puck.js, Pixl.js and MDBT42
    Avatar for Riccardokhm

    Yeah sorry, the first connect within the .on('Connect') was removed, actually the only one is the last on the bottom.
    Just a question: is the event handler for the 'data' event called each time the Bangle receives something , correct?

    Here is my final code:

    Bluetooth.on('data', function(d) { 
      g.clear();
      g.setFont("Vector", 20);
      g.setColor(0,255,0);
      f = require("Storage").open(name, 'a');
      f.write(d + "\n");
      setTimeout(() => (g.drawString("Data", g.getWidth()/2, g.getHeight()/2)), 1000);
      setTimeout(()=>g.clear(),1500); 
      });
    
    NRF.on('connect', function(addr) {
      g.clear();
      g.setFont("Vector",15);
      g.setColor(255,0,0);
      g.drawString(addr,g.getWidth()/2, g.getHeight()/2);
      g.setFont("Vector",25);
      setTimeout(()=>g.drawString("Connected",­ g.getWidth()/2, g.getHeight()/2), 500);
      setTimeout(()=>g.clear(),1000); 
      E.setConsole(null);
    });
    
    NRF.on('disconnect', function(reason) {
      g.clear();
      g.setColor(0,0,255);
      g.drawString("Disconnected", g.getWidth()/2, g.getHeight()/2);
      setTimeout(()=> g.clear(), 1000);
    });
    
    // Code
    
    g.setFontAlign(0,0); 
    g.setFont("Vector",25);
    delay = 5000;
    
    name = "MyFile";
    
    setInterval(function(){console.log(E.get­Temperature());}, 1000);
    

    The thing is that when I send something from my laptop, bangle does not seem to receive it.

  • in Puck.js, Pixl.js and MDBT42
    Avatar for Riccardokhm

    This is the part of code running after connection.

    function Connect(){
      NRF.connect(macaddress).then(function(g)­ {
        gatt = g;
        return gatt.startBonding(); 
        }).then(function(service) {
        try{
            console.log(gatt.getSecurityStatus());
            console.log("Connected");
            return setTimeout(() => (gatt.getPrimaryService(serviceUid).catc­h(onRejected)), 2000);
        }
        catch(exception){
          console.log(exception);
        }
          console.log("Service");
          return service.getCharacteristic(characteristcU­id).catch(onRejected);}).then(function(c­haracteristic) {
            console.log(characteristic);
            console.log("Got:", JSON.stringify(d.buffer));
            });
    }
    
    

    and this is what it is returned by the console:

    [
    BluetoothDevice: {

    "id": "5b:93:7d:91:e5:7c private-resolvable",
    "rssi": -39,
    "data": new Uint8Array([2, 1, 26, 3, 3, 10, 24, 17, 7, 114, 131, 89, 57, 60, 2, 116, 174, 69, 70, 180, 13, 199, 230, 80, 241]).buffer,
    "services": [
      "180a",
      "f150e6c7-0db4-4645-ae74-023c39598372"
     ]
    

    }
    ]
    { "connected": true, "encrypted": false, "mitm_protected": false, "bonded": true }
    Connected
    The code run into a problem: Not connected

  • in Puck.js, Pixl.js and MDBT42
    Avatar for Riccardokhm

    Yes the error is that, but in debugging it return that service is null actually. The C# console application successfully creates a service and the associated characteristic, which is connetable and discoverable, but the bangle seems not able to find the primary service. I even tried to get all the primary services after connecting to the laptop but null object is returned.

    As for the connect event handler, basically what I want to achieve is that whenever something connects to the bangle a message is display on the bangle screen, as it is already doing.

Actions