text: 
  var obnizNoble =  require('./index');
  var noble = obnizNoble("54371148");
  
  
  console.log('noble');
  
  noble.on('stateChange', function(state) {
    console.log('on -> stateChange: ' + state);
  
    if (state === 'poweredOn') {
      noble.startScanning();
    } else {
      noble.stopScanning();
    }
  });
  
  noble.on('scanStart', function() {
    console.log('on -> scanStart');
  });
  
  noble.on('scanStop', function() {
    console.log('on -> scanStop');
  });
  
  
  
  noble.on('discover', function(peripheral) {
    console.log('on -> discover: ' + peripheral);
    if(!peripheral.advertisement.localName
        || !peripheral.advertisement.localName.startsWith("MESH-100LE1002073")){
      return;
    }
    console.log("find");
  
    noble.stopScanning();
  
    peripheral.connect(function(err) {
      //
      // Once the peripheral has been connected, then discover the
      // services and characteristics of interest.
      //
      peripheral.discoverServices(["72C90001-57A9-4D40-B746-534E22EC9F9E"], function(err, services) {
        services.forEach(function(service) {
          //
          // This must be the service we were looking for.
          //
          console.log('found service:', service.uuid);
  
          //
          // So, discover its characteristics.
          //
          service.discoverCharacteristics(["72C90002-57A9-4D40-B746-534E22EC9F9E"], function(err, characteristics) {
  
            characteristics.forEach(function(characteristic) {
              //
              // Loop through each characteristic and match them to the
              // UUIDs that we know about.
              //
              console.log('found characteristic:', characteristic.uuid);
              characteristic.write(Buffer.from([0x01 ,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x64,0x00,0x64,0x00,0x00,0x00,0x01,0xee]));
  
              // if (pizzaCrustCharacteristicUuid == characteristic.uuid) {
              //   pizzaCrustCharacteristic = characteristic;
              // }
              // else if (pizzaToppingsCharacteristicUuid == characteristic.uuid) {
              //   pizzaToppingsCharacteristic = characteristic;
              // }
              // else if (pizzaBakeCharacteristicUuid == characteristic.uuid) {
              //   pizzaBakeCharacteristic = characteristic;
              // }
            })
  
            //
            // Check to see if we found all of our characteristics.
            //
            if (pizzaCrustCharacteristic &&
                pizzaToppingsCharacteristic &&
                pizzaBakeCharacteristic) {
              //
              // We did, so bake a pizza!
              //
              bakePizza();
            }
            else {
              console.log('missing characteristics');
            }
          })
        })
      })
    })
  
  
    //
    // peripheral.on('connect', function() {
    //   console.log('on -> connect');
    //   this.updateRssi();
    //   // this.discoverServices();
    // });
  
    peripheral.on('disconnect', function() {
      console.log('on -> disconnect');
    });
  
    peripheral.on('rssiUpdate', function(rssi) {
      console.log('on -> RSSI update ' + rssi);
      this.discoverServices();
    });
  
    peripheral.on('servicesDiscover', function(services) {
      console.log('on -> peripheral services discovered ' + services);
  
      var serviceIndex = 0;
  
      services[serviceIndex].on('includedServicesDiscover', function(includedServiceUuids) {
        console.log('on -> service included services discovered ' + includedServiceUuids);
        this.discoverCharacteristics();
      });
  
      services[serviceIndex].on('characteristicsDiscover', function(characteristics) {
        console.log('on -> service characteristics discovered ' + characteristics);
  
        var characteristicIndex = 0;
  
        characteristics[characteristicIndex].on('read', function(data, isNotification) {
          console.log('on -> characteristic read ' + data + ' ' + isNotification);
          console.log(data);
  
          peripheral.disconnect();
        });
  
        characteristics[characteristicIndex].on('write', function() {
          console.log('on -> characteristic write ');
  
          peripheral.disconnect();
        });
  
        characteristics[characteristicIndex].on('broadcast', function(state) {
          console.log('on -> characteristic broadcast ' + state);
  
          peripheral.disconnect();
        });
  
        characteristics[characteristicIndex].on('notify', function(state) {
          console.log('on -> characteristic notify ' + state);
  
          peripheral.disconnect();
        });
  
        characteristics[characteristicIndex].on('descriptorsDiscover', function(descriptors) {
          console.log('on -> descriptors discover ' + descriptors);
  
          var descriptorIndex = 0;
  
          descriptors[descriptorIndex].on('valueRead', function(data) {
            console.log('on -> descriptor value read ' + data);
            console.log(data);
            peripheral.disconnect();
          });
  
          descriptors[descriptorIndex].on('valueWrite', function() {
            console.log('on -> descriptor value write ');
            peripheral.disconnect();
          });
  
          descriptors[descriptorIndex].readValue();
          //descriptors[descriptorIndex].writeValue(new Buffer([0]));
        });
  
  
        // characteristics[characteristicIndex].read();
        // characteristics[characteristicIndex].write(new Buffer([01:00:0c:00:0c:00:0c:64:00:64:00:00:00:01:ee]));
        //characteristics[characteristicIndex].broadcast(true);
        //characteristics[characteristicIndex].notify(true);
        // characteristics[characteristicIndex].discoverDescriptors();
      });
  
  
      services[serviceIndex].discoverIncludedServices();
    });
  
    peripheral.connect();
  });
  
  