MagicMirror² v2.8.0 is available! For more information about this release, check out this topic.

Toothbrush integration



  • I already had a look to the API provided by OralB. It’s quite disappointing.
    They will provide you with classes to develop tools for android or ios apps. Not what we are looking for right now. 😉
    But maybe the documentation could be usefull.

    I tried to find the forum page you mentioned. Found nothing usefull yet. Maybe you can have a look and help me out here.

    I made a first attempt with noble and got some pretty nice results by reading out the braodcasted information from my brush.

    I you wanna try on your own, do the following:

    1. Install noble in a directory of your choice, by following the instructions on the noble page:
    sudo apt-get install bluetooth bluez libbluetooth-dev libudev-dev
    
    sudo ln -s /usr/bin/nodejs /usr/bin/node
    
    npm install noble
    
    1. Move into the new node_modules/noble/ - folder and create a new file ‘toothbrush.js’ with the following content
    var async = require('async');
    var noble = require('./index');
    
    var OralB_manufacturerData = 'dc00010205030000000101';
    
    
    
    
    console.log('Lookinhg for OralB Toothbrushes with manufacturerData: "' + OralB_manufacturerData +'"');
    
    noble.on('stateChange', function(state) {
      if (state === 'poweredOn') {
        noble.startScanning();
      } else {
        noble.stopScanning();
      }
    });
    
    noble.on('discover', function(peripheral) {
      var advertisement = peripheral.advertisement;
      console.log('Found device with manufacturerData: "' + advertisement.manufacturerData.toString('hex') +'" localName: ' + advertisement.localName);
      if (advertisement.manufacturerData.toString('hex') === OralB_manufacturerData) {
        noble.stopScanning();
    
        console.log('peripheral with ID ' + peripheral.id + ' found');
    
    
        var localName = advertisement.localName;
        var txPowerLevel = advertisement.txPowerLevel;
        var manufacturerData = advertisement.manufacturerData;
        var serviceData = advertisement.serviceData;
        var serviceUuids = advertisement.serviceUuids;
    
        if (localName) {
          console.log('  Local Name        = ' + localName);
        }
    
        if (txPowerLevel) {
          console.log('  TX Power Level    = ' + txPowerLevel);
        }
    
        if (manufacturerData) {
          console.log('  Manufacturer Data = ' + manufacturerData.toString('hex'));
        }
    
        if (serviceData) {
          console.log('  Service Data      = ' + serviceData);
        }
    
        if (serviceUuids) {
          console.log('  Service UUIDs     = ' + serviceUuids);
        }
    
        console.log();
    
        explore(peripheral);
      }
    });
    
    function explore(peripheral) {
      console.log('services and characteristics:');
    
      peripheral.on('disconnect', function() {
        process.exit(0);
      });
    
      peripheral.connect(function(error) {
        peripheral.discoverServices([], function(error, services) {
          var serviceIndex = 0;
    
          async.whilst(
            function () {
              return (serviceIndex < services.length);
            },
            function(callback) {
              var service = services[serviceIndex];
              var serviceInfo = service.uuid;
    
              if (service.name) {
                serviceInfo += ' (' + service.name + ')';
              }
              console.log(serviceInfo);
    
              service.discoverCharacteristics([], function(error, characteristics) {
                var characteristicIndex = 0;
    
                async.whilst(
                  function () {
                    return (characteristicIndex < characteristics.length);
                  },
                  function(callback) {
                    var characteristic = characteristics[characteristicIndex];
                    var characteristicInfo = '  ' + characteristic.uuid;
    
                    if (characteristic.name) {
                      characteristicInfo += ' (' + characteristic.name + ')';
                    }
    
                    async.series([
                      function(callback) {
                        characteristic.discoverDescriptors(function(error, descriptors) {
                          async.detect(
                            descriptors,
                            function(descriptor, callback) {
                              return callback(descriptor.uuid === '2901');
                            },
                            function(userDescriptionDescriptor){
                              if (userDescriptionDescriptor) {
                                userDescriptionDescriptor.readValue(function(error, data) {
                                  if (data) {
                                    characteristicInfo += ' (' + data.toString() + ')';
                                  }
                                  callback();
                                });
                              } else {
                                callback();
                              }
                            }
                          );
                        });
                      },
                      function(callback) {
                            characteristicInfo += '\n    properties  ' + characteristic.properties.join(', ');
    
                        if (characteristic.properties.indexOf('read') !== -1) {
                          characteristic.read(function(error, data) {
                            if (data) {
                              var string = data.toString('ascii');
    
                              characteristicInfo += '\n    value       ' + data.toString('hex') + ' | \'' + string + '\'';
                            }
                            callback();
                          });
                        } else {
                          callback();
                        }
                      },
                      function() {
                        console.log(characteristicInfo);
                        characteristicIndex++;
                        callback();
                      }
                    ]);
                  },
                  function(error) {
                    serviceIndex++;
                    callback();
                  }
                );
              });
            },
            function (err) {
              peripheral.disconnect();
            }
          );
        });
      });
    }
    
    
    1. Start the script by with
    sudo node toothbrush.js
    

    Here is what I got:

    
    Lookinhg for OralB Toothbrushes with mac address:54:4a:16:21:20:9f
    peripheral with ID 544a1621209f found
      Manufacturer Data = dc00010205020000000101
      Service Data      =
      Service UUIDs     =
    
    services and characteristics:
    1800 (Generic Access)
      2a00 (Device Name)
        properties  read
        value       4f72616c2d4220546f6f74686272757368 | 'Oral-B Toothbrush'
      2a01 (Appearance)
        properties  read
        value       0000 | ''
      2a02 (Peripheral Privacy Flag)
        properties  read, write
        value       00 | ''
      2a03 (Reconnection Address)
        properties  read, write
        value       000000000000 | ''
      2a04 (Peripheral Preferred Connection Parameters)
        properties  read
        value       5000a0000000e803 | 'P h'
    1801 (Generic Attribute)
      2a05 (Service Changed)
        properties  indicate
    a0f0fff050474d5382084f72616c2d42
      a0f0fff150474d5382084f72616c2d42 (Command)
        properties  read, write, notify
        value       00 | ''
      a0f0fff250474d5382084f72616c2d42 (Data)
        properties  read, write
        value       00000000 | ''
      a0f0fff350474d5382084f72616c2d42 (Auth)
        properties  read, write
        value       00 | ''
      a0f0fff450474d5382084f72616c2d42 (Secret)
        properties  read, write
        value       00000000 | ''
    a0f0ff0050474d5382084f72616c2d42
      a0f0ff0150474d5382084f72616c2d42 (Handle ID)
        properties  read
        value       00000000 | ''
      a0f0ff0250474d5382084f72616c2d42 (Handle Type)
        properties  read
        value       02 | ''
      a0f0ff0350474d5382084f72616c2d42 (User Account)
        properties  read
        value       01 | ''
      a0f0ff0450474d5382084f72616c2d42 (Device State)
        properties  read, notify
        value       0200 | ''
      a0f0ff0550474d5382084f72616c2d42 (Battery Level)
        properties  read, notify
        value       63 | 'c'
      a0f0ff0650474d5382084f72616c2d42 (Button State)
        properties  read, notify
        value       00000000 | ''
      a0f0ff0750474d5382084f72616c2d42 (Brushing Mode)
        properties  read, notify
        value       01 | ''
      a0f0ff0850474d5382084f72616c2d42 (Brushing Time)
        properties  read, notify
        value       0000 | ''
      a0f0ff0950474d5382084f72616c2d42 (Quadrant)
        properties  read, notify
        value       00 | ''
      a0f0ff0a50474d5382084f72616c2d42 (Smiley)
        properties  read, notify
        value       00 | ''
      a0f0ff0b50474d5382084f72616c2d42 (Pressure Sensor)
        properties  read, notify
        value       00 | ''
      a0f0ff0c50474d5382084f72616c2d42 (Cache)
        properties  read, write, notify
        value        | ''
    a0f0ff2050474d5382084f72616c2d42
      a0f0ff2150474d5382084f72616c2d42 (Status)
        properties  read, write, notify
        value       8100 | ''
      a0f0ff2250474d5382084f72616c2d42 (RTC)
        properties  read, write
        value       97d81120 | 'X '
      a0f0ff2350474d5382084f72616c2d42 (Timezone)
        properties  read, write
    '   value       0d | '
      a0f0ff2450474d5382084f72616c2d42 (Brushing Timer)
        properties  read, write
        value       0f | ''
      a0f0ff2550474d5382084f72616c2d42 (Brushing Modes)
        properties  read, write
        value       0105020403000000 | ''
    PuTTY  a0f0ff2650474d5382084f72616c2d42 (Quadrant Times)
        properties  read, write
        value       1e001e001e001e000000000000000000 | ''
      a0f0ff2750474d5382084f72616c2d42 (Tongue Time)
        properties  read, write
        value       00 | ''
      a0f0ff2850474d5382084f72616c2d42 (Pressure)
        properties  read, write
        value       03 | ''
      a0f0ff2950474d5382084f72616c2d42 (Data)
        properties  read
        value       68d6fd1f7700010100000063d1e7fd1f | 'hV}wcQg}'
      a0f0ff2a50474d5382084f72616c2d42 (Flight Mode)
        properties  read, write
        value       00 | ''
    
    


  • try :

    cd ~/MagicMirror/modules/MMM-Button
    sudo npm rebuild --runtime=electron --target=1.4.6 --disturl=https://atom.io/download/atom-shell --abi=50
    


  • not in the mmmbutton folder of course



  • @dfuerst It worked! Thank you very much!!



  • exciting.
    you get everything needed for a really high quality piece of module.

    battery level
    brushing mode
    brushing time
    pressure
    quadrant
    smiley

    i am a bit concerned about the user readout. (Do you think it might be possible to determine which of eg. 3 brushes is presently used?)



  • Hey,
    I have bad news.

    The readable informations provided by the brush via bluetooth aren’t changing. Not while the toothbrush is running. I guess the characteristics we were able to readout, are used like placeholder for the sdk.

    Second try was to get notified if a broadcastd value (characteristic) is changing. Nothing here either.
    Every characteristic (like brushing time, battery level, etc) is using the same id and only provides a different name. So a notification service wasn’t possible.

    Seems like there is no way to get the information read out via bluetooth without using the sdk…

    I also tried to include the provided sdk into the MM-framework.
    Therefore I had a try with node-java, which allows to run java classes within nodejs. The files from the android sdk are java classes.

    It went pretty nice in the beginning. But then I ran into an error
    Expected stackmap frame at this location.’ which is caused by the compiling the sdk classes on another system (linux not android), I would assume.

    I was amazed that I wasn’t able to find any code snippets of frameworks from other developers to “hack the brush” when I first started. By now its seems obvious that it’s not that easy.

    If anybody else is gonna have a try, please don’t hesitate to ask if you need assistance.



  • should we go back to the “low level approach”?

    as i understand you can instantly determine if there is a certain brush(matching the macaddress via the config) within the bluetooth range upon activation of these.
    any interruption of brushing is detected, 20 sec or so too late of course i know, when the brush goes offline again.
    so can we start a stopwatch (let’s say at the center position) upon detection, stopping when not detecting the brush anymore and reseting to 00:00 after 2min followed by vanishing the stopwatch.
    i know that this wouldn’t be very accurate, but better then nothing. giving the user a feel for the time
    and for a pro like you i guess this would be very easy to develop.
    examples for start/stop/reset timers are quiet a lot available in the web.

    how do you think about



  • maybe contacting oralB via the developer program homepage ( https://developer.oralb.com/ ) could be helpful. there might be a support team helping developers creating new apps for their brush



  • Hey,
    guided by the idea of your simple approach I wrote a little script which tries to detect, if the brush is running or not.
    Caused by the bluetooth behavior of the brush it is very limited in guessing when the brush was stopped or resumed.
    Here are some details:

    • If the toothbrush is started bluetooth is activated for 3 Seconds.
    • If the brush is paused/stopped bluetooth is activated again for 32 Seconds.

    This leads to the following limited possiblities in tracking a brush session.

    • A start of a session is only trackable, if the programm/script has started with a (for 32 seconds) silent brush.
    • A stop is only trackable 3 seconds after start.
    • A stop/pause leads to a 32 Seconds “cooldown phase”, were no tracking is possible. This will reset the timer to 0:00.

    This is only helpfull if you do not interrupt you brushing session. 😄

    If you wanna try the current setup you can run the script by:

    1. Enter your module-directory: cd ~/MagicMirror/modules
    2. Clone repository : git clone https://github.com/SvenSommer/MMM-OralB
    3. Enter new directory: cd ~/MagicMirror/modules/MMM-OralB
    4. Install dependencies: sudo apt-get install bluetooth bluez libbluetooth-dev libudev-dev
    5. Install noble module: npm install noble
    6. Exceute helper programm to find your brushID (this is not the mac-address): sudo node findBrushId.js
      This should lead to a output like
    Searching for OralB Toothbrushes with manufacturerData: "dc00010205030000000101"...
    changed state to:poweredOn
    Found OralB Tootbrush with ID: 544a1621209f
    
    
    1. Copy and paste your ID into the brushTimer.js file: sudo nano brushTimer.js
      (Save and exit with STRG + O and STRG + X )
    "use strict";
    
    var NodeHelper = require("node_helper");
    var noble = require('noble');
    
    //Copy Paste your ID here 
    var toothbrush_uuid = '544a1621209f';
    
    1. Run script with sudo node brushTimer.js
      This should lead to an output like:
    scanning started...
    Toothbrush is running
    0:1
    0:2
    0:3
    0:4
    0:5
    0:6
    0:7
    0:8
    0:9
    0:10
    0:11
    0:12
    0:13
    0:14
    0:15
    0:16
    0:17
    0:18
    Toothbrush stopped. "Cool down" for 32 seconds needed!
    
    


  • Wow that was really fast!

    Testing your script brought me to 2 problems:

    testing brushTimer.js in the console worked for detecting the brush but did never stop, also not after 32 sec!

    including your module into the MM i got an error message upon activating the brush:

    “noble warning: unknown handle 64 disconnected!”
    “scanning was started. Everything is working fine.”

    this two message’s i get upon every activation, so the MM show always SEARCHING…

    any suggestions?