public void DeinitializeBluetooth() { BluetoothLEHardwareInterface.DeInitialize(() => { Debug.Log("Bluetooth has shut down."); }); }
// NOTE: The button that triggers this is for when you are running this code in the macOS // Unity Editor and have the experimental bluetooth support turned on. This is because I // how found it crashes less often when you deinitialize first. You must still use caution // and save your work often as it could still have issues. // MacOS editor support is experimental. I am working on trying to make it work better in // the editor. public void OnDeinitializeButton() { BluetoothLEHardwareInterface.DeInitialize(() => { StatusMessage = "Deinitialize"; }); }
private void ResetState(Action afterResetAction) { if (_peripheralParams.HasValue) { if (_connected) { logger.DebugLog("Disconnecting from peripheral with device address: " + _deviceAddress); BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { logger.DebugLog("De-initializing bluetooth hardware interface"); BluetoothLEHardwareInterface.DeInitialize(() => { ResetStateVars(); afterResetAction(); }); }); } else { logger.DebugLog("De-initializing bluetooth hardware interface"); BluetoothLEHardwareInterface.DeInitialize(() => { ResetStateVars(); afterResetAction(); }); } } else { ResetStateVars(); afterResetAction(); } }
public void StartScan(Callback Success, Callback Error) { m_ScanAndConnectSuccess = Success; m_ScanAndConnectError = Error; m_ConnectCharacteristicUUID = new Dictionary <string, bool>(); for (int i = 0; i < CharacteristicUUID.Length; i++) { m_ConnectCharacteristicUUID[CharacteristicUUID[i]] = false; } //Reset(); BluetoothLEHardwareInterface.Initialize(true, false, () => { SetMode(eMode.ScanDevice); }, (error) => { BluetoothLEHardwareInterface.Log("Error during initialize: " + error); if (error == "Bluetooth LE Not Enabled") { BluetoothLEHardwareInterface.DeInitialize(() => { BluetoothLEHardwareInterface.BluetoothEnable(true); if (m_ScanAndConnectError != null) { m_ScanAndConnectError(); } }); } }); }
/// <summary> /// DeInitializes the BLE Service, so you can start once again. This will be called once application quits. /// </summary> private static void DeInitialize() { CheckIfInitialized(); BluetoothLEHardwareInterface.DeInitialize(() => { IsInitialized = false; }); }
public void OnBack() { if (_scanning) { OnScan(); // this will stop scanning } BluetoothLEHardwareInterface.DeInitialize(() => { }); }
private void OnApplicationQuit() { BluetoothLEHardwareInterface.StopScan(); BluetoothLEHardwareInterface.DisconnectAll(); BluetoothLEHardwareInterface.DeInitialize(() => { Debug.Log("Bluetooth has shut down on application quit."); }); }
public override void DisconnectDevice() { //need to disconnect and deinitialize and then finish it otherwise it won't be disconnected the right way. BluetoothLEHardwareInterface.DisconnectAll(); ConnectDevice(adressFinal); BluetoothLEHardwareInterface.DeInitialize(() => { }); BluetoothLEHardwareInterface.FinishDeInitialize(); isConnected = false; }
protected override void OnButtonClick(Button btn) { base.OnButtonClick(btn); switch (btn.name) { case "Bluetooth2StartFrameBtn": GuiController.Instance.SwitchWrapperWithScale(GuiFrameID.StartFrame, false); break; case "BluetoothCentralBtn": InitializeBluetooth(true); break; case "BluetoothPeripheralBtn": InitializeBluetooth(false); break; case "BackFromContentBtn": scaning = false; BluetoothLEHardwareInterface.RemoveCharacteristics(); BluetoothLEHardwareInterface.RemoveServices(); BluetoothLEHardwareInterface.DeInitialize(() => { MyDebug.LogGreen("DeInitialize Success!"); }); CommonTool.GuiHorizontalMove(bluetoothCategoryContent, Screen.width, MoveID.RightOrUp, canvasGroup, false); break; case "BackFromScanResultBtn": case "BluetoothAdvertisingStopBtn": bluetoothPeripheralDetailBg.SetActive(false); bluetoothConnectWaiting.SetActive(false); bluetoothAdvertisingStopBtn.SetActive(false); StopScan(); break; case "BluetoothScanBtn": StartScan(); break; case "ConnectCancelBtn": bluetoothPeripheralDetailBg.SetActive(false); break; case "BluetoothReScanBtn": ReScan(); break; default: MyDebug.LogYellow("Can not find Button: " + btn.name); break; } }
//deinitialize the bluetooth system when the script is destroyed private void OnDestroy() { if (_connectedAddress != null) {//disconnect from a connected device if there is any BluetoothLEHardwareInterface.DisconnectPeripheral(_connectedAddress, null); _connectedAddress = null; _connected = false; _connecting = false; } BluetoothLEHardwareInterface.DeInitialize(null); }
public void OnBack() { RemovePeripherals(); if (_scanning) { OnScan(); // this will stop scanning } BluetoothLEHardwareInterface.DeInitialize(() => { BLETestScript.Show(PanelTypeSelection); }); }
private void OnDestroy() { BluetoothLEHardwareInterface.DeInitialize(null); BluetoothLE.connecting = false; BluetoothLE.connectDataState = false; BluetoothLE.connectState = false; if (this.debugOutput) { Debug.Log("BluetoothLE.OnDestroy called"); } }
IEnumerator disConnectProcess() { BluetoothLEHardwareInterface.StopScan(); yield return(new WaitForSeconds(0.2f)); BluetoothLEHardwareInterface.DisconnectAll(); yield return(new WaitForSeconds(0.2f)); BluetoothLEHardwareInterface.DeInitialize(() => { SetState(BtStates.None); }); }
void disconnectToDevice() { if (_connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(_JDY16, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { _connected = false; _state = States.None; }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { _state = States.None; }); } }
void StartProcess() { Alert.Show("Bluetooth initialization will fail if Bluetooth settings are not initialized", null, false); BluetoothLEHardwareInterface.Initialize(true, false, () => { SetState(States.Scan, 0.2f); }, (error) => { // Console.Write ("蓝牙初始化失败: " + error + ",等待重试"); Alert.Show("Initialize Faild, Please open the Bluetooth", (_value) => { BluetoothLEHardwareInterface.DeInitialize(null); SetState(States.Init, 0.2f); }); }); }
void InitBluetooth(DeviceName[] _supportedDevices) { Debug.Log("Bluetooth Initializing..."); BluetoothDeviceScript receiver = BluetoothLEHardwareInterface.Initialize(true, false, () => { Debug.Log("Bluetooth Initialized."); Scan(_supportedDevices); }, (err) => { Debug.Log("Bluetooth Error: " + err); if ("Bluetooth LE Not Enabled" == err) { BluetoothLEHardwareInterface.FinishDeInitialize(); BluetoothLEHardwareInterface.DeInitialize(() => { StartCoroutine(ReInitBluetooth(_supportedDevices)); }); } }); DontDestroyOnLoad(receiver.gameObject); }
private void ConnectDevice(string addr) { BluetoothLEHardwareInterface.ConnectToPeripheral(addr, (address) => { }, (address, serviceUUID) => { }, (address, serviceUUID, characteristicUUID) => { if (IsEqual(serviceUUID, _serviceUUID)) { _connectedID = address; isConnected = true; if (IsEqual(characteristicUUID, _readCharacteristicUUID)) { _readFound = true; } if (IsEqual(characteristicUUID, _writeCharacteristicUUID)) { _writeFound = true; } adressFinal = addr; Debug.Log("BLE Spiro Connected"); BluetoothLEHardwareInterface.StopScan(); } }, (address) => { // this will get called when the device disconnects // be aware that this will also get called when the disconnect // is called above. both methods get call for the same action // this is for backwards compatibility Debug.Log("Connection Lost"); isConnected = false; //we first need to disconnect and deinitialize before we can connect again to the Air next otherwise we can't reconnect. BluetoothLEHardwareInterface.DisconnectAll(); BluetoothLEHardwareInterface.DeInitialize(() => { }); BluetoothLEHardwareInterface.FinishDeInitialize(); DeviceManager.Instance.MakeSpiroControllerNull(); }); }
void SetMode(eMode Mode) { DebugLog("BLEMgr:" + Mode.ToString()); m_Mode = Mode; m_ModeTimer = 0; switch (m_Mode) { case eMode.ScanDevice: ExecScanDevice(); break; case eMode.Connect: ExecConnect(); break; case eMode.ConnectOK: if (m_ScanAndConnectSuccess != null) { m_ScanAndConnectSuccess(); } m_ScanAndConnectSuccess = null; m_ScanAndConnectError = null; m_StatusChangedCallback(Hot2gEnumerations.EnumHot2gDriverCommStsEvent.Connected, m_DeviceAddress); break; case eMode.Error: BluetoothLEHardwareInterface.StopScan(); BluetoothLEHardwareInterface.DeInitialize(() => { if (m_ScanAndConnectError != null) { m_ScanAndConnectError(); } }); break; case eMode.DisConnect: BluetoothLEHardwareInterface.DeInitialize(() => { m_StatusChangedCallback(Hot2gEnumerations.EnumHot2gDriverCommStsEvent.Disconnected, m_DeviceAddress); }); break; } }
private void OnDestroy() { Debug.Log("BluetoothManager - OnDestroy()"); if (Instance == this) { try { BluetoothLEHardwareInterface.StopScan(); BluetoothLEHardwareInterface.DisconnectAll(); BluetoothLEHardwareInterface.DeInitialize(() => { Debug.Log("Bluetooth has shut down on destroy."); }); } catch (Exception e) { Debug.Log("Bluetooth has already shut down: " + e.Message); } } }
void ForceDisconnect() { if (_connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { is_quit_ok = true; _connected = false; _state = States.None; }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { _state = States.None; is_quit_ok = true; }); } Reset(); }
public void OnBluetoothFightFinish() { MyDebug.LogGreen("OnBluetoothFightFinish"); if (isCentral) { MyDebug.LogGreen("OnBluetoothFightFinish:Central"); BluetoothLEHardwareInterface.UnSubscribeCharacteristic(CurPeripheralInstance.address, ServiceUUID, ReadUUID, (characteristic) => { MyDebug.LogGreen("UnSubscribeCharacteristic Success :" + characteristic); }); BluetoothLEHardwareInterface.DisconnectPeripheral(CurPeripheralInstance.address, (disconnectAddress) => { MyDebug.LogGreen("DisconnectPeripheral Success:" + disconnectAddress); }); } else { MyDebug.LogGreen("OnBluetoothFightFinish:Peripheral"); BluetoothLEHardwareInterface.StopAdvertising(() => { MyDebug.LogGreen("Stop Advertising!"); }); } BluetoothLEHardwareInterface.RemoveCharacteristics(); BluetoothLEHardwareInterface.RemoveServices(); BluetoothLEHardwareInterface.DeInitialize(() => { MyDebug.LogGreen("DeInitialize Success!"); }); BluetoothLEHardwareInterface.BluetoothEnable(false); }
// Update is called once per frame void Update() { if (_timeout > 0f) { _timeout -= Time.deltaTime; if (_timeout <= 0f) { _timeout = 0f; switch (_state) { case machineState.None: break; case machineState.Scan: BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { // if your device does not advertise the rssi and manufacturer specific data // then you must use this callback because the next callback only gets called // if you have manufacturer specific data Debug.Log("Found Device : " + address + " / Name : " + name); if (name.Contains(DeviceName)) { BluetoothLEHardwareInterface.StopScan(); state = State.DeviceFound; device_name = name; // found a device with the name we want // this example does not deal with finding more than one _deviceAddress = address; SetState(machineState.Connect, 0.5f); } }, (address, name, rssi, bytes) => { // APIdou does not broadcast manufacturer specific data } ); break; case machineState.Connect: // set these flags _foundAccel = false; _foundGyro = false; _foundTouch = false; // note that the first parameter is the address, not the name. I have not fixed this because // of backwards compatiblity. // also note that I am note using the first 2 callbacks. If you are not looking for specific characteristics you can use one of // the first 2, but keep in mind that the device will enumerate everything and so you will want to have a timeout // large enough that it will be finished enumerating before you try to subscribe or do any other operations. BluetoothLEHardwareInterface.ConnectToPeripheral(_deviceAddress, null, null, (address, foundServiceUUID, foundCharUUID) => { if (IsEqual(foundServiceUUID, ServiceUUID)) { _foundAccel = _foundAccel || IsEqual(foundCharUUID, AccelUUID); _foundGyro = _foundGyro || IsEqual(foundCharUUID, GyroUUID); _foundTouch = _foundTouch || IsEqual(foundCharUUID, TouchUUID); // if we have found all characteristics that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe if (_foundAccel && _foundGyro && _foundTouch) { Debug.Log("Connected"); state = State.Connected; SetState(machineState.Subscribe, 3f); } } }); break; case machineState.Subscribe: BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_deviceAddress, FullUUID(ServiceUUID), FullUUID(TouchUUID), null, onNotification); System.Threading.Thread.Sleep(500); BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_deviceAddress, FullUUID(ServiceUUID), FullUUID(AccelUUID), null, onNotification); System.Threading.Thread.Sleep(500); BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_deviceAddress, FullUUID(ServiceUUID), FullUUID(GyroUUID), null, onNotification); break; case machineState.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(_deviceAddress, ServiceUUID, AccelUUID, null); SetState(machineState.Disconnect, 4f); break; case machineState.Disconnect: BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { _state = machineState.None; }); }); break; } } } }
// Update is called once per frame void Update() { if (_timeout > 0f) { _timeout -= Time.deltaTime; if (_timeout <= 0f) { _timeout = 0f; switch (_state) { case States.None: break; case States.Scan: BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { // if your device does not advertise the rssi and manufacturer specific data // then you must use this callback because the next callback only gets called // if you have manufacturer specific data if (name.Contains(DeviceName)) { BluetoothLEHardwareInterface.StopScan(); // found a device with the name we want // this example does not deal with finding more than one _deviceAddress = address; SetState(States.Connect, 0.5f); } }, (address, name, rssi, bytes) => { // use this one if the device responses with manufacturer specific data and the rssi }); break; case States.Connect: // set these flags _foundSubscribeID = false; _foundWriteID = false; // note that the first parameter is the address, not the name. I have not fixed this because // of backwards compatiblity. // also note that I am note using the first 2 callbacks. If you are not looking for specific characteristics you can use one of // the first 2, but keep in mind that the device will enumerate everything and so you will want to have a timeout // large enough that it will be finished enumerating before you try to subscribe or do any other operations. BluetoothLEHardwareInterface.ConnectToPeripheral(_deviceAddress, null, null, (address, serviceUUID, characteristicUUID) => { if (IsEqual(serviceUUID, ServiceUUID)) { _foundSubscribeID = _foundSubscribeID || IsEqual(characteristicUUID, SubscribeCharacteristic); _foundWriteID = _foundWriteID || IsEqual(characteristicUUID, WriteCharacteristic); // if we have found both characteristics that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe if (_foundSubscribeID && _foundWriteID) { _connected = true; SetState(States.Subscribe, 2f); } } }); break; case States.Subscribe: BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_deviceAddress, ServiceUUID, SubscribeCharacteristic, null, (address, characteristicUUID, bytes) => { // we don't have a great way to set the state other than waiting until we actually got // some data back. For this demo with the rfduino that means pressing the button // on the rfduino at least once before the GUI will update. _state = States.None; // we received some data from the device _dataBytes = bytes; }); break; case States.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(_deviceAddress, ServiceUUID, SubscribeCharacteristic, null); SetState(States.Disconnect, 4f); break; case States.Disconnect: BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { BluetoothLEHardwareInterface.Log("1"); BluetoothLEHardwareInterface.DeInitialize(() => { _connected = false; _state = States.None; }); }); break; } } } }
void Update() { RotatePlayer(); if (_timeout > 0f) { _timeout -= Time.deltaTime; if (_timeout <= 0f) { _timeout = 0f; switch (_state) { case States.None: break; case States.Scan: HM10_Status.text = "Scanning for HM10 devices..."; BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { if (name.Contains(DeviceName)) { _workingFoundDevice = true; BluetoothLEHardwareInterface.StopScan(); // stop scanning while you connect to a device _hm10 = address; // add it to the list and set to connect to it HM10_Status.text = "Found HM10"; SetState(States.Connect, 0.5f); _workingFoundDevice = false; } }, null, false, false); break; case States.Connect: HM10_Status.text = "Connecting to HM10"; BluetoothLEHardwareInterface.ConnectToPeripheral(_hm10, null, null, (address, serviceUUID, characteristicUUID) => { if (IsEqual(serviceUUID, ServiceUUID)) { if (IsEqual(characteristicUUID, Characteristic)) { _connected = true; SetState(States.Subscribe, 2f); } } }, (disconnectedAddress) => { BluetoothLEHardwareInterface.Log("Device disconnected: " + disconnectedAddress); HM10_Status.text = "Disconnected"; }); break; case States.Subscribe: HM10_Status.text = "Connected to HM10"; enabled = true; BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_hm10, ServiceUUID, Characteristic, null, (address, characteristicUUID, bytes) => {}); _state = States.None; // set to the none state and the user can start sending and receiving data break; case States.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(_hm10, ServiceUUID, Characteristic, null); SetState(States.Disconnect, 4f); break; case States.Disconnect: if (_connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(_hm10, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { _connected = false; _state = States.None; }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { _state = States.None; }); enabled = false; } break; } } } }
/// <summary> /// Update /// </summary> void Update() { if (_timeout > 0f) { _timeout -= Time.deltaTime; if (_timeout > 0f) { return; } _timeout = 0f; switch (_state) { //None case States.None: break; //Scan case States.Scan: BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { // if your device does not advertise the rssi and manufacturer specific data // then you must use this callback because the next callback only gets called // if you have manufacturer specific data // デバイスがrssiおよびメーカー固有のデータをアドバタイズしない場合、次のコールバックはメーカー固有のデータがある場合にのみ呼び出されるため、このコールバックを使用する必要があります。 _deviceName += string.Format(",{0} ", name); if (!_rssiOnly) { if (name.Contains(DeviceName)) { _deviceName += string.Format("[FIND]-{0}\n", _deviceAddress); BluetoothLEHardwareInterface.StopScan(); // found a device with the name we want // this example does not deal with finding more than one _deviceAddress = address; SetState(States.Connect, 0.5f); } else { _deviceName += "\n"; } } if (LogText != null) { LogText.text = _deviceName; } }, (address, name, rssi, bytes) => { // use this one if the device responses with manufacturer specific data and the rssi // デバイスがメーカー固有のデータとrssiで応答する場合、これを使用します if (name.Contains(DeviceName)) { if (_rssiOnly) { _rssi = rssi; } else { BluetoothLEHardwareInterface.StopScan(); // found a device with the name we want // this example does not deal with finding more than one _deviceAddress = address; SetState(States.Connect, 0.5f); } } }, _rssiOnly); // this last setting allows RFduino to send RSSI without having manufacturer data if (_rssiOnly) { SetState(States.ScanRSSI, 0.5f); } break; //ScanRSSI case States.ScanRSSI: break; //Connect case States.Connect: // set these flags _foundSubscribeID = false; _foundWriteID = false; // note that the first parameter is the address, not the name. I have not fixed this because // of backwards compatiblity. // also note that I am note using the first 2 callbacks. If you are not looking for specific characteristics you can use one of // the first 2, but keep in mind that the device will enumerate everything and so you will want to have a timeout // large enough that it will be finished enumerating before you try to subscribe or do any other operations. // 最初のパラメータは名前ではなくアドレスであることに注意してください。後方互換性のため、これは修正していません。 // また、最初の2つのコールバックを使用していることに注意してください。特定の特性を探していない場合は、最初の2つのいずれかを使用できますが、 // デバイスはすべてを列挙するので、サブスクライブする前に列挙が完了するまでタイムアウトを大きくする必要があることに注意してください。他の操作を行います。 BluetoothLEHardwareInterface.ConnectToPeripheral(_deviceAddress, null, null, (address, serviceUUID, characteristicUUID) => { _serviceName += string.Format("{0} ", serviceUUID); if (IsEqual(serviceUUID, ServiceUUID)) { _serviceName += string.Format("[FIND]-{0}\n", _deviceAddress); _foundSubscribeID = _foundSubscribeID || IsEqual(characteristicUUID, SubscribeCharacteristic); _foundWriteID = _foundWriteID || IsEqual(characteristicUUID, WriteCharacteristic); _serviceName += string.Format("<{0}>,{1},{2}\n", characteristicUUID, _foundSubscribeID, _foundWriteID); // if we have found both characteristics that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe //if (_foundSubscribeID && _foundWriteID) if (_foundSubscribeID) { _connected = true; SetState(States.Subscribe, 2f); } } else { _serviceName += "\n"; } if (Log2Text != null) { Log2Text.text = _serviceName; } }); break; // Subscribe case States.Subscribe: BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_deviceAddress, ServiceUUID, SubscribeCharacteristic, null, (address, characteristicUUID, bytes) => { // we don't have a great way to set the state other than waiting until we actually got // some data back. For this demo with the rfduino that means pressing the button // on the rfduino at least once before the GUI will update. // 実際にデータが返されるまで待つ以外に、状態を設定する優れた方法はありません。このrfduinoのデモでは、GUIが更新される前にrfduinoのボタンを少なくとも1回押すことを意味します。 _state = States.None; // we received some data from the device _dataBytes = bytes; }); break; // Unsubscribe case States.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(_deviceAddress, ServiceUUID, SubscribeCharacteristic, null); SetState(States.Disconnect, 4f); break; // Disconnect case States.Disconnect: if (_connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { _connected = false; _state = States.None; }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { _state = States.None; }); } break; } } }
public void OnButton() { BluetoothLEHardwareInterface.DeInitialize(() => Debug.Log("Deinitialized")); }
// Update is called once per frame void Update() { if (_timeout > 0f) { _timeout -= Time.deltaTime; if (_timeout <= 0f) { _timeout = 0f; switch (_state) { case States.None: break; case States.Scan: StatusMessage = "Scanning for " + DeviceName; BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { // if your device does not advertise the rssi and manufacturer specific data // then you must use this callback because the next callback only gets called // if you have manufacturer specific data if (!_rssiOnly) { if (name.Contains(DeviceName)) { StatusMessage = "Found " + name; BluetoothLEHardwareInterface.StopScan(); // found a device with the name we want // this example does not deal with finding more than one _deviceAddress = address; SetState(States.Connect, 0.5f); } } }, (address, name, rssi, bytes) => { // use this one if the device responses with manufacturer specific data and the rssi if (name.Contains(DeviceName)) { StatusMessage = "Found " + name; if (_rssiOnly) { _rssi = rssi; } else { BluetoothLEHardwareInterface.StopScan(); // found a device with the name we want // this example does not deal with finding more than one _deviceAddress = address; SetState(States.Connect, 0.5f); } } }, _rssiOnly); // this last setting allows RFduino to send RSSI without having manufacturer data if (_rssiOnly) { SetState(States.ScanRSSI, 0.5f); } break; case States.ScanRSSI: break; case States.Connect: StatusMessage = "Connecting..."; // set these flags _foundButtonUUID = false; _foundLedUUID = false; // note that the first parameter is the address, not the name. I have not fixed this because // of backwards compatiblity. // also note that I am note using the first 2 callbacks. If you are not looking for specific characteristics you can use one of // the first 2, but keep in mind that the device will enumerate everything and so you will want to have a timeout // large enough that it will be finished enumerating before you try to subscribe or do any other operations. BluetoothLEHardwareInterface.ConnectToPeripheral(_deviceAddress, null, null, (address, serviceUUID, characteristicUUID) => { StatusMessage = "Connected..."; if (IsEqual(serviceUUID, ServiceUUID)) { StatusMessage = "Found Service UUID"; _foundButtonUUID = _foundButtonUUID || IsEqual(characteristicUUID, ButtonUUID); _foundLedUUID = _foundLedUUID || IsEqual(characteristicUUID, LedUUID); // if we have found both characteristics that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe if (_foundButtonUUID && _foundLedUUID) { _connected = true; SetState(States.Subscribe, 2f); } } }); break; case States.Subscribe: StatusMessage = "Subscribing to characteristics..."; BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(_deviceAddress, ServiceUUID, ButtonUUID, (notifyAddress, notifyCharacteristic) => { StatusMessage = "Waiting for user action (1)..."; _state = States.None; // read the initial state of the button BluetoothLEHardwareInterface.ReadCharacteristic(_deviceAddress, ServiceUUID, ButtonUUID, (characteristic, bytes) => { ProcessButton(bytes); }); }, (address, characteristicUUID, bytes) => { if (_state != States.None) { // some devices do not properly send the notification state change which calls // the lambda just above this one so in those cases we don't have a great way to // set the state other than waiting until we actually got some data back. // The esp32 sends the notification above, but if yuor device doesn't you would have // to send data like pressing the button on the esp32 as the sketch for this demo // would then send data to trigger this. StatusMessage = "Waiting for user action (2)..."; _state = States.None; } // we received some data from the device ProcessButton(bytes); }); break; case States.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(_deviceAddress, ServiceUUID, ButtonUUID, null); SetState(States.Disconnect, 4f); break; case States.Disconnect: StatusMessage = "Commanded disconnect."; if (_connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { StatusMessage = "Device disconnected"; BluetoothLEHardwareInterface.DeInitialize(() => { _connected = false; _state = States.None; }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { _state = States.None; }); } break; } } } }
void OnApplicationQuit() { BluetoothLEHardwareInterface.DeInitialize(null); }
void Bluetooth_Baglan() { if (Bluetooth_Bilgileri.State_Timeout > 0f) { Bluetooth_Bilgileri.State_Timeout -= Time.deltaTime; if (Bluetooth_Bilgileri.State_Timeout <= 0f) { Bluetooth_Bilgileri.State_Timeout = 0f; switch (Bluetooth_Bilgileri.State) { case Bluetooth_States.None: break; case Bluetooth_States.Scan: Status_Update(Bluetooth_DeviceName + " aranıyor..."); BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { // we only want to look at devices that have the name we are looking for // this is the best way to filter out devices if (name.Contains(Bluetooth_DeviceName)) { // it is always a good idea to stop scanning while you connect to a device // and get things set up BluetoothLEHardwareInterface.StopScan(); Status_Update(Bluetooth_DeviceName + " bulundu..."); // add it to the list and set to connect to it Bluetooth_Bilgileri.Device_Address = address; SetState(Bluetooth_States.Connect, 0.5f); } }, null, false, false); break; case Bluetooth_States.Connect: // set these flags Status_Update(Bluetooth_DeviceName + " cihazına bağlanılıyor..."); // note that the first parameter is the address, not the name. I have not fixed this because // of backwards compatiblity. // also note that I am note using the first 2 callbacks. If you are not looking for specific characteristics you can use one of // the first 2, but keep in mind that the device will enumerate everything and so you will want to have a timeout // large enough that it will be finished enumerating before you try to subscribe or do any other operations. BluetoothLEHardwareInterface.ConnectToPeripheral(Bluetooth_Bilgileri.Device_Address, null, null, (address, serviceUUID, characteristicUUID) => { if (UUIDIsEqual(serviceUUID, Bluetooth_ServiceUUID)) { // if we have found the characteristic that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe if (UUIDIsEqual(characteristicUUID, Bluetooth_Characteristic)) { Bluetooth_Bilgileri.Connected = true; SetState(Bluetooth_States.Subscribe, 2f); Status_Update(Bluetooth_DeviceName + " cihazına bağlanıldı."); } } }, (disconnectedAddress) => { BluetoothLEHardwareInterface.Log("Device disconnected: " + disconnectedAddress); Status_Update(Bluetooth_DeviceName + " cihazı ile bağlantı kesildi!"); }); break; case Bluetooth_States.Subscribe: Status_Update("Veri alımına kaydolunuyor..."); BluetoothLEHardwareInterface.SubscribeCharacteristicWithDeviceAddress(Bluetooth_Bilgileri.Device_Address, Bluetooth_ServiceUUID, Bluetooth_Characteristic, null, (address, characteristicUUID, bytes) => { Bluetooth_Bilgileri.Receive_Count++; BluetoothLEHardwareInterface.Log("Alinan: " + Encoding.UTF8.GetString(bytes)); Status_Update("Alınan veri: " + Encoding.UTF8.GetString(bytes)); Bluetooth_Verilerini_Isle(bytes); }); // set to the none state and the user can start sending and receiving data SetState(Bluetooth_States.None, 0); Status_Update("Veri bekleniyor..."); break; case Bluetooth_States.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(Bluetooth_Bilgileri.Device_Address, Bluetooth_ServiceUUID, Bluetooth_Characteristic, null); SetState(Bluetooth_States.Disconnect, 4f); break; case Bluetooth_States.Disconnect: if (Bluetooth_Bilgileri.Connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(Bluetooth_Bilgileri.Device_Address, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { Bluetooth_Bilgileri.Connected = false; SetState(Bluetooth_States.None, 0); }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { SetState(Bluetooth_States.None, 0); }); } break; } } } }
// Update is called once per frame void Update() { if (_timeout > 0f) { _timeout -= Time.deltaTime; if (_timeout <= 0f) { _timeout = 0f; switch (_state) { case States.None: break; case States.Scan: BluetoothLEHardwareInterface.ScanForPeripheralsWithServices(null, (address, name) => { if (name == "SmartInsoleL") { device_left.Name = name; device_left.Address = address; device_left.State = DEVICE_STATE.FOUND; } else if (name == "SmartInsoleR") { device_right.Name = name; device_right.Address = address; device_right.State = DEVICE_STATE.FOUND; } if (device_right.State == DEVICE_STATE.FOUND && device_left.State == DEVICE_STATE.FOUND) { BluetoothLEHardwareInterface.StopScan(); SetState(States.Connect, 0.5f); } }, null); break; case States.Connect: BluetoothLEHardwareInterface.ConnectToPeripheral(device_left.Address, null, null, (address, serviceUUID, characteristicUUID) => { if (IsEqual(serviceUUID, ServiceUUID)) { device_left.FoundSubscribeID = device_left.FoundSubscribeID || IsEqual(characteristicUUID, SubscribeCharacteristic); device_left.FoundWriteID = device_left.FoundWriteID || IsEqual(characteristicUUID, WriteCharacteristic); // if we have found both characteristics that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe if (device_left.FoundSubscribeID && device_left.FoundWriteID) { device_left.State = DEVICE_STATE.CONNECTED; SetState(States.Subscribe, 0.5f); } } }); BluetoothLEHardwareInterface.ConnectToPeripheral(device_right.Address, null, null, (address, serviceUUID, characteristicUUID) => { if (IsEqual(serviceUUID, ServiceUUID)) { device_right.FoundSubscribeID = device_right.FoundSubscribeID || IsEqual(characteristicUUID, SubscribeCharacteristic); device_right.FoundWriteID = device_right.FoundWriteID || IsEqual(characteristicUUID, WriteCharacteristic); // if we have found both characteristics that we are waiting for // set the state. make sure there is enough timeout that if the // device is still enumerating other characteristics it finishes // before we try to subscribe if (device_right.FoundSubscribeID && device_right.FoundWriteID) { device_right.State = DEVICE_STATE.CONNECTED; SetState(States.Subscribe, 0.5f); } } }); break; case States.Subscribe: BluetoothLEHardwareInterface.SubscribeCharacteristic(device_left.Address, FullUUID(ServiceUUID), FullUUID(SubscribeCharacteristic), null, (characteristic, bytes) => { //string s = ASCIIEncoding.UTF8.GetString(bytes); //left_foot_data.text = s; device_left.DataBytes = ASCIIEncoding.UTF8.GetString(bytes); device_left.State = DEVICE_STATE.SUBSCRIBED; device_left.NewData = true; SetState(States.None, 2f); }); BluetoothLEHardwareInterface.SubscribeCharacteristic(device_right.Address, FullUUID(ServiceUUID), FullUUID(SubscribeCharacteristic), null, (characteristic, bytes) => { //string s = ASCIIEncoding.UTF8.GetString(bytes); //right_foot_data.text = s; device_right.DataBytes = ASCIIEncoding.UTF8.GetString(bytes); device_right.State = DEVICE_STATE.SUBSCRIBED; device_right.NewData = true; SetState(States.None, 2f); }); _connected = true; break; case States.Unsubscribe: BluetoothLEHardwareInterface.UnSubscribeCharacteristic(_deviceAddress, ServiceUUID, SubscribeCharacteristic, null); SetState(States.Disconnect, 4f); break; case States.Disconnect: if (_connected) { BluetoothLEHardwareInterface.DisconnectPeripheral(_deviceAddress, (address) => { BluetoothLEHardwareInterface.DeInitialize(() => { _connected = false; _state = States.None; }); }); } else { BluetoothLEHardwareInterface.DeInitialize(() => { _state = States.None; }); } break; } } } }