Riccardokhm

Most recent activity

• BLE connection from my windows pc to the bangle js 2

  @Riccardokhm started

  • 19 comments
  • 1,398 views

  @Gordon replied
• BLE connection from my windows pc to the bangle js 2

  in Bangle.js • 1 year, 1 month

  

  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?

• HRM monitoring

  in Bangle.js • 1 year, 2 months

  

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

• HRM monitoring

  @Riccardokhm started

  • 4 comments
  • 448 views

  @Riccardokhm replied
• HRM monitoring

  in Bangle.js • 1 year, 2 months

  

  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.

• Uncaught InternalError: BLE task completed that wasn't scheduled (3/4)

  in Puck.js, Pixl.js and MDBT42 • 1 year, 2 months

  

  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!

• Uncaught InternalError: BLE task completed that wasn't scheduled (3/4)

  in Puck.js, Pixl.js and MDBT42 • 1 year, 2 months

  

  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");
                          }
                      }
  
                  }
                  
              }
  
          }
  
  

• Uncaught InternalError: BLE task completed that wasn't scheduled (3/4)

  in Puck.js, Pixl.js and MDBT42 • 1 year, 2 months

  

  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.

• Uncaught InternalError: BLE task completed that wasn't scheduled (3/4)

  in Puck.js, Pixl.js and MDBT42 • 1 year, 2 months

  

  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

• Uncaught InternalError: BLE task completed that wasn't scheduled (3/4)

  in Puck.js, Pixl.js and MDBT42 • 1 year, 2 months

  

  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.