[英]Android and Bluetooth Low Energy (BLE)
I'm struggling to read/send data from/to a custom bluetooth low energy device. 我正在努力从自定义蓝牙低能耗设备读取/发送数据。 I am using a Microchip RN4020 bluetooth module. 我正在使用Microchip RN4020蓝牙模块。
Every tutorial or example I found explained how to connect your mobile application to the device but I didn't find how to actually interact with it. 我发现的每个教程或示例都说明了如何将您的移动应用程序连接到设备,但没有找到与之实际交互的方法。 As a result that is exactly what I can and can't do with my application. 结果,这正是我可以和不能使用我的应用程序执行的操作。
for every characteristic present I did the following: 对于存在的每个特征,我都执行以下操作:
gatt.readCharacteristic(services.get(i).getCharacteristics().get(j));
this was the result when I printed the values: 这是我打印值时的结果:
getStringValue= Mobi_F934��
getStringValue= null
getStringValue= ����d���
getStringValue= 001EC030F934
getStringValue= 2.1
getStringValue= 1.10
getStringValue= 1.10
getStringValue= Microchip
getStringValue= RN4020
getStringValue=
getStringValue=
I don't know if this is important or not... 我不知道这是否重要...
How can I read the data send from my BLE device? 如何读取从BLE设备发送的数据?
EDIT: My android code 编辑:我的Android代码
@TargetApi(21)
public class MainActivity extends ActionBarActivity {
private BluetoothAdapter mBluetoothAdapter;
private int REQUEST_ENABLE_BT = 1;
private Handler mHandler;
private static final long SCAN_PERIOD = 10000;
private BluetoothLeScanner mLEScanner;
private ScanSettings settings;
private List<ScanFilter> filters;
private BluetoothGatt mGatt;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandler = new Handler();
if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
Toast.makeText(this, "BLE Not Supported",
Toast.LENGTH_SHORT).show();
finish();
}
// Initializes Bluetooth adapter
final BluetoothManager bluetoothManager =
(BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter = bluetoothManager.getAdapter();
}
@Override
protected void onResume() {
super.onResume();
// Ensures Bluetooth is available on the device and it is enabled. If not,
// displays a dialog requesting user permission to enable Bluetooth.
if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
} else {
if (Build.VERSION.SDK_INT >= 21) {
mLEScanner = mBluetoothAdapter.getBluetoothLeScanner();
settings = new ScanSettings.Builder()
.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
.build();
filters = new ArrayList<ScanFilter>();
}
scanLeDevice(true);
}
}
@Override
protected void onPause() {
super.onPause();
if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled()) {
scanLeDevice(false);
}
}
@Override
protected void onDestroy() {
if (mGatt == null) {
return;
}
mGatt.close();
mGatt = null;
super.onDestroy();
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_ENABLE_BT) {
if (resultCode == Activity.RESULT_CANCELED) {
//Bluetooth not enabled.
finish();
return;
}
}
super.onActivityResult(requestCode, resultCode, data);
}
private void scanLeDevice(final boolean enable) {
if (enable) {
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.stopLeScan(mLeScanCallback);
} else {
mLEScanner.stopScan(mScanCallback);
}
}
}, SCAN_PERIOD);
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.startLeScan(mLeScanCallback);
} else {
mLEScanner.startScan(filters, settings, mScanCallback);
}
} else {
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.stopLeScan(mLeScanCallback);
} else {
mLEScanner.stopScan(mScanCallback);
}
}
}
private ScanCallback mScanCallback = new ScanCallback() {
@Override
public void onScanResult(int callbackType, ScanResult result) {
Log.e("callbackType", "MAX " + String.valueOf(callbackType));
Log.e("result", "MAX " + result.toString());
BluetoothDevice btDevice = result.getDevice();
connectToDevice(btDevice);
}
@Override
public void onBatchScanResults(List<ScanResult> results) {
for (ScanResult sr : results) {
Log.e("ScanResult - Results", "MAX " + sr.toString());
}
}
@Override
public void onScanFailed(int errorCode) {
Log.e("Scan Failed", "MAX " + "Error Code: " + errorCode);
}
};
private BluetoothAdapter.LeScanCallback mLeScanCallback =
new BluetoothAdapter.LeScanCallback() {
@Override
public void onLeScan(final BluetoothDevice device, int rssi,
byte[] scanRecord) {
runOnUiThread(new Runnable() {
@Override
public void run() {
Log.e("onLeScan", "MAX " + device.toString());
connectToDevice(device);
}
});
}
};
public void connectToDevice(BluetoothDevice device) {
if (mGatt == null) {
mGatt = device.connectGatt(this, false, gattCallback);
scanLeDevice(false);// will stop after first device detection
}
}
private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
Log.e("onConnectionStateChange", "MAX " + "Status: " + status);
switch (newState) {
case BluetoothProfile.STATE_CONNECTED:
Log.e("gattCallback", "MAX " + "STATE_CONNECTED");
gatt.discoverServices();
break;
case BluetoothProfile.STATE_DISCONNECTED:
Log.e("gattCallback", "MAX " + "STATE_DISCONNECTED");
break;
default:
Log.e("gattCallback", "MAX " + "STATE_OTHER");
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
List<BluetoothGattService> services = gatt.getServices();
Log.e("onServicesDiscovered", "MAX " + services.toString());
/*
for(int i = 0; i < services.size(); i++){
for (int j = 0; j < services.get(i).getCharacteristics().size(); j++){
Log.e("MAX", "i= " + i + " j= " + j);
gatt.readCharacteristic(services.get(i).getCharacteristics().get
(j));
}
}
*/
gatt.readCharacteristic(services.get(0).getCharacteristics().get(0));
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt,
BluetoothGattCharacteristic
characteristic, int status) {
Log.e("onCharacteristicRead", "MAX " + characteristic.toString());
Log.e("onCharacteristicRead", "MAX " +characteristic.getStringValue(0));
//gatt.disconnect();
}
};
}
EDIT 2: My arduino code 编辑2:我的arduino代码
#include <SoftwareSerial.h>
/* Set up BT to arduino uno
BT RN4020 Arduino Uno
------------------------------------------------
Red 3.3V
Green GND
Yellow(RX) TX (digital pin 1)
Orange(TX) RX (digital pin 0)
White PIN 8 (!) This is not GND (!)
Blue 3.3V (Ioref can also be used)
*/
/*
-----------------------------------------------------------------------------
-----EXPLANATION PROGRAM-----------------------------------------------------
----------------------------
Eerst wordt de BT module geïnitialiseerd door verschillende commando's door te
sturen. Bij elk commando wordt gecheckt of de BT module het juiste antwoord
heeft teruggestuurd.
De initialisatie moet gebeuren in CMD mode, de CMD/MLDP pin moet laag zijn. Na
de initialisatie checken we tot de BT module is geconnecteerd met het device.
Als de BT module geconnecteerd is zetten we deze uit CMD mode en in MLDP mode
om het verzenden en ontvangen van data te ondersteunen. Daarna zenden we om de
seconde de string 'test' door.
Dit gebeurt zolang het device geconnecteerd is met de BT module.
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-----------------------------
*/
int CMD_MLD_pin = 8; // IO pin for CMD/MLDP pin (LOW --> CMD, HIGH --> MLDP)
void setup() // Initialising BT RN4020
{
pinMode(CMD_MLD_pin, OUTPUT);
digitalWrite(CMD_MLD_pin, LOW); // put CMD/MLDP pin LOW for CMD mode
delay(5000);
/* Initialize Bluetooth */
Serial.begin(115200); // Set up serial connection with required baud rate of
// 115200
delay(1500);
Serial.println("R,1"); //Reboot
while(!Serial.find("Reboot")){} // Waiting until BT RN4020 responds the
required string
while(!Serial.find("CMD")){}
//delay(2000);
Serial.println("SF,1"); // Factory reset
while(!Serial.find("AOK")){}
//delay(1500);
Serial.println("SR,32000000"); // Set device as peripheral
while(!Serial.find("AOK")){}
Serial.println("S-, Mobi"); // Change name of BT
while(!Serial.find("AOK")){}
//delay(1500);
Serial.println("R,1"); // Reboot to make changes effective
while(!Serial.find("Reboot")){}
while(!Serial.find("CMD")){}
//delay(2000);
}
void loop()
{
// Wait until the device responds it is connected
// If the device is connected we will send every second the string 'test'
while(!Serial.find("Connected")){} // Wait until BT RN4020 is connected to a
// device
digitalWrite(CMD_MLD_pin, HIGH); // Go to MLDP to support data stream
while(!Serial.find("MLDP")){} // Wait until BT RN4020 is effectively in MLDP
// mode
delay(500);
while (!Serial.find("Connection End")) // Send string to BTRN4020 while the
// BT RN4020 is conected to a device
{
Serial.println("test");
delay(1000);
}
}
I managed to solve my problem a few months after asking the question. 问了问题几个月后,我设法解决了我的问题。 I forgot to share my solution back then. 那时我忘了分享我的解决方案。 Anyhow, better late than never! 无论如何,迟到总比没有好!
This is some code I wrote while testing the android - TI sensortag communication over BLE. 这是我在测试android-通过BLE的TI sensortag通信时编写的一些代码。
A full example is available at https://github.com/maxhelskens/SmergyBicycle 完整示例参见https://github.com/maxhelskens/SmergyBicycle
package com.example.max.smergy;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.ProgressDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanSettings;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.util.SparseArray;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@TargetApi(21)
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private static final String DEVICE_NAME = "SensorTag";
/* Humidity Service */
private static final UUID HUMIDITY_SERVICE = UUID.fromString("F000AA20-0451-4000-B000-000000000000");
private static final UUID HUMIDITY_DATA_CHAR = UUID.fromString("f000aa21-0451-4000-b000-000000000000");
private static final UUID HUMIDITY_CONFIG_CHAR = UUID.fromString("f000aa22-0451-4000-b000-000000000000");
/* magneto Service */
private static final UUID MAGNETO_SERVICE = UUID.fromString("F000AA80-0451-4000-B000-000000000000");
private static final UUID MAGNETO_DATA_CHAR = UUID.fromString("f000aa81-0451-4000-b000-000000000000");
private static final UUID MAGNETO_CONFIG_CHAR = UUID.fromString("f000aa82-0451-4000-b000-000000000000");
/* Barometric Pressure Service */
private static final UUID PRESSURE_SERVICE = UUID.fromString("f000aa40-0451-4000-b000-000000000000");
private static final UUID PRESSURE_DATA_CHAR = UUID.fromString("f000aa41-0451-4000-b000-000000000000");
private static final UUID PRESSURE_CONFIG_CHAR = UUID.fromString("f000aa42-0451-4000-b000-000000000000");
private static final UUID PRESSURE_CAL_CHAR = UUID.fromString("f000aa43-0451-4000-b000-000000000000");
/* Client Configuration Descriptor */
private static final UUID CONFIG_DESCRIPTOR = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
private BluetoothAdapter mBluetoothAdapter;
private SparseArray<BluetoothDevice> mDevices;
private BluetoothGatt mGatt;
private TextView mTemperature, mHumidity, mPressure;
private ProgressDialog mProgress;
private int REQUEST_ENABLE_BT = 1;
private BluetoothLeScanner mLEScanner;
private ScanSettings settings;
private List<ScanFilter> filters;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
setProgressBarIndeterminate(true);
// Find the toolbar view inside the activity layout
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
// Sets the Toolbar to act as the ActionBar for this Activity window.
// Make sure the toolbar exists in the activity and is not null
setSupportActionBar(toolbar);
/*
* We are going to display the results in some text fields
*/
mTemperature = (TextView) findViewById(R.id.text_temperature);
mHumidity = (TextView) findViewById(R.id.text_humidity);
mPressure = (TextView) findViewById(R.id.text_pressure);
//Check if BLE is supported
if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
Toast.makeText(this, "BLE Not Supported",
Toast.LENGTH_SHORT).show();
finish();
}
final BluetoothManager bluetoothManager =
(BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter = bluetoothManager.getAdapter();
mDevices = new SparseArray<BluetoothDevice>();
/*
* A progress dialog will be needed while the connection process is
* taking place
*/
mProgress = new ProgressDialog(this);
mProgress.setIndeterminate(true);
mProgress.setCancelable(false);
}
@Override
protected void onResume() {
super.onResume();
if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
} else {
if (Build.VERSION.SDK_INT >= 21) {
mLEScanner = mBluetoothAdapter.getBluetoothLeScanner();
settings = new ScanSettings.Builder()
.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
.build();
filters = new ArrayList<ScanFilter>();
}
}
clearDisplayValues();
}
@Override
protected void onPause() {
super.onPause();
//Make sure dialog is hidden
mProgress.dismiss();
//Cancel any scans in progress
mHandler.removeCallbacks(mStopRunnable);
mHandler.removeCallbacks(mStartRunnable);
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.stopLeScan(mLeScanCallback);
} else {
mLEScanner.stopScan(mScanCallback);
}
}
@Override
protected void onStop() {
super.onStop();
//Disconnect from any active tag connection
if (mGatt != null) {
mGatt.close();
mGatt = null;
}
}
@Override
protected void onDestroy() {
if (mGatt == null) {
return;
}
mGatt.close();
mGatt = null;
super.onDestroy();
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_ENABLE_BT) {
if (resultCode == Activity.RESULT_CANCELED) {
//Bluetooth not enabled.
finish();
return;
}
}
super.onActivityResult(requestCode, resultCode, data);
}
// Menu icons are inflated just as they were with actionbar
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
//Add any device elements we've discovered to the overflow menu
for (int i=0; i < mDevices.size(); i++) {
BluetoothDevice device = mDevices.valueAt(i);
menu.add(0, mDevices.keyAt(i), 0, device.getName());
}
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.bluetoothSearch:
mDevices.clear();
startScan();
//scanLeDevice(true);
return true;
default:
//Obtain the discovered device to connect with
BluetoothDevice device = mDevices.get(item.getItemId());
Log.i(TAG, "Connecting to " + device.getName());
/*
* Make a connection with the device
*/
connectToDevice(device);
//Display progress UI
mHandler.sendMessage(Message.obtain(null, MSG_PROGRESS, "Connecting to " + device.getName() + "..."));
return super.onOptionsItemSelected(item);
}
}
private void clearDisplayValues() {
mTemperature.setText("---");
mHumidity.setText("---");
mPressure.setText("---");
}
private Runnable mStopRunnable = new Runnable() {
@Override
public void run() {
stopScan();
}
};
private Runnable mStartRunnable = new Runnable() {
@Override
public void run() {
startScan();
}
};
private void startScan() {
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.startLeScan(mLeScanCallback);
} else {
mLEScanner.startScan(filters, settings, mScanCallback);
}
setProgressBarIndeterminateVisibility(true);
mHandler.postDelayed(mStopRunnable, 2500);
}
private void stopScan() {
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.stopLeScan(mLeScanCallback);
} else {
mLEScanner.stopScan(mScanCallback);
}
setProgressBarIndeterminateVisibility(false);
}
private BluetoothAdapter.LeScanCallback mLeScanCallback =
new BluetoothAdapter.LeScanCallback() {
@Override
public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
Log.i("onLeScan", device.toString());
mDevices.put(device.hashCode(), device);
//Update the overflow menu
invalidateOptionsMenu();
}
};
/*
private void scanLeDevice(final boolean enable) {
if (enable) {
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.stopLeScan(mLeScanCallback);
} else {
mLEScanner.stopScan(mScanCallback);
}
}
}, SCAN_PERIOD);
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.startLeScan(mLeScanCallback);
} else {
mLEScanner.startScan(filters, settings, mScanCallback);
}
} else {
if (Build.VERSION.SDK_INT < 21) {
mBluetoothAdapter.stopLeScan(mLeScanCallback);
} else {
mLEScanner.stopScan(mScanCallback);
}
}
}
*/
private ScanCallback mScanCallback = new ScanCallback() {
@Override
public void onScanResult(int callbackType, ScanResult result) {
Log.i("callbackType", String.valueOf(callbackType));
Log.i("result", result.toString());
BluetoothDevice btDevice = result.getDevice();
mDevices.put(btDevice.hashCode(), btDevice);
//Update the overflow menu
invalidateOptionsMenu();
}
@Override
public void onBatchScanResults(List<ScanResult> results) {
for (ScanResult sr : results) {
Log.i("ScanResult - Results", sr.toString());
}
}
@Override
public void onScanFailed(int errorCode) {
Log.e("Scan Failed", "Error Code: " + errorCode);
}
};
public void connectToDevice(BluetoothDevice device) {
if (mGatt == null) {
mGatt = device.connectGatt(this, false, gattCallback);
stopScan();
}
}
/*
* In this callback, we've created a bit of a state machine to enforce that only
* one characteristic be read or written at a time until all of our sensors
* are enabled and we are registered to get notifications.
*/
private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
/* State Machine Tracking */
private int mState = 0;
private void reset() { mState = 0; }
private void advance() { mState++; }
/*
* Send an enable command to each sensor by writing a configuration
* characteristic. This is specific to the SensorTag to keep power
* low by disabling sensors you aren't using.
*/
private void enableNextSensor(BluetoothGatt gatt) {
BluetoothGattCharacteristic characteristic;
switch (mState) {
/*
case 0:
Log.d(TAG, "Enabling pressure cal");
characteristic = gatt.getService(PRESSURE_SERVICE)
.getCharacteristic(PRESSURE_CONFIG_CHAR);
characteristic.setValue(new byte[] {0x02});
break;
case 1:
Log.d(TAG, "Enabling pressure");
characteristic = gatt.getService(PRESSURE_SERVICE)
.getCharacteristic(PRESSURE_CONFIG_CHAR);
characteristic.setValue(new byte[] {0x01});
break; */
case 0:
Log.d(TAG, "Enabling humidity");
characteristic = gatt.getService(HUMIDITY_SERVICE)
.getCharacteristic(HUMIDITY_CONFIG_CHAR);
characteristic.setValue(new byte[] {0x01});
break;
case 1:
Log.d(TAG, "Enabling magneto");
characteristic = gatt.getService(MAGNETO_SERVICE)
.getCharacteristic(MAGNETO_CONFIG_CHAR);
characteristic.setValue(new byte[] {(byte)0x7F, (byte)0x00});
break;
default:
mHandler.sendEmptyMessage(MSG_DISMISS);
Log.i(TAG, "All Sensors Enabled");
return;
}
gatt.writeCharacteristic(characteristic);
}
/*
* Read the data characteristic's value for each sensor explicitly
*/
private void readNextSensor(BluetoothGatt gatt) {
BluetoothGattCharacteristic characteristic;
switch (mState) {
/*
case 0:
Log.d(TAG, "Reading pressure cal");
characteristic = gatt.getService(PRESSURE_SERVICE)
.getCharacteristic(PRESSURE_CAL_CHAR);
break;
case 1:
Log.d(TAG, "Reading pressure");
characteristic = gatt.getService(PRESSURE_SERVICE)
.getCharacteristic(PRESSURE_DATA_CHAR);
break;*/
case 0:
Log.d(TAG, "Reading humidity");
characteristic = gatt.getService(HUMIDITY_SERVICE)
.getCharacteristic(HUMIDITY_DATA_CHAR);
break;
case 1:
Log.d(TAG, "Reading magneto");
characteristic = gatt.getService(MAGNETO_SERVICE)
.getCharacteristic(MAGNETO_DATA_CHAR);
break;
default:
mHandler.sendEmptyMessage(MSG_DISMISS);
Log.i(TAG, "All Sensors Enabled");
return;
}
gatt.readCharacteristic(characteristic);
}
/*
* Enable notification of changes on the data characteristic for each sensor
* by writing the ENABLE_NOTIFICATION_VALUE flag to that characteristic's
* configuration descriptor.
*/
private void setNotifyNextSensor(BluetoothGatt gatt) {
BluetoothGattCharacteristic characteristic;
switch (mState) {
/*
case 0:
Log.d(TAG, "Set notify pressure cal");
characteristic = gatt.getService(PRESSURE_SERVICE)
.getCharacteristic(PRESSURE_CAL_CHAR);
break;
case 1:
Log.d(TAG, "Set notify pressure");
characteristic = gatt.getService(PRESSURE_SERVICE)
.getCharacteristic(PRESSURE_DATA_CHAR);
break;*/
case 0:
Log.d(TAG, "Set notify humidity");
characteristic = gatt.getService(HUMIDITY_SERVICE)
.getCharacteristic(HUMIDITY_DATA_CHAR);
break;
case 1:
Log.d(TAG, "Set notify magneto");
characteristic = gatt.getService(MAGNETO_SERVICE)
.getCharacteristic(MAGNETO_DATA_CHAR);
break;
default:
mHandler.sendEmptyMessage(MSG_DISMISS);
Log.i(TAG, "All Sensors Enabled");
return;
}
//Enable local notifications
gatt.setCharacteristicNotification(characteristic, true);
//Enabled remote notifications
BluetoothGattDescriptor desc = characteristic.getDescriptor(CONFIG_DESCRIPTOR);
desc.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
gatt.writeDescriptor(desc);
}
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
Log.i("onConnectionStateChange", "Status: " + status);
if (status == BluetoothGatt.GATT_SUCCESS && newState == BluetoothProfile.STATE_CONNECTED) {
/*
* Once successfully connected, we must next discover all the services on the
* device before we can read and write their characteristics.
*/
gatt.discoverServices();
mHandler.sendMessage(Message.obtain(null, MSG_PROGRESS, "Discovering Services..."));
} else if (status == BluetoothGatt.GATT_SUCCESS && newState == BluetoothProfile.STATE_DISCONNECTED) {
/*
* If at any point we disconnect, send a message to clear the weather values
* out of the UI
*/
mHandler.sendEmptyMessage(MSG_CLEAR);
} else if (status != BluetoothGatt.GATT_SUCCESS) {
/*
* If there is a failure at any stage, simply disconnect
*/
gatt.close();
}
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
List<BluetoothGattService> services = gatt.getServices();
Log.i("onServicesDiscovered", services.toString());
mHandler.sendMessage(Message.obtain(null, MSG_PROGRESS, "Enabling Sensors..."));
/*
* With services discovered, we are going to reset our state machine and start
* working through the sensors we need to enable
*/
reset();
enableNextSensor(gatt);
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
Log.i("onCharacteristicRead", characteristic.toString());
//For each read, pass the data up to the UI thread to update the display
if (HUMIDITY_DATA_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_HUMIDITY, characteristic));
}
if (MAGNETO_DATA_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_MAGNETO, characteristic));
}
if (PRESSURE_DATA_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_PRESSURE, characteristic));
}
if (PRESSURE_CAL_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_PRESSURE_CAL, characteristic));
}
//After reading the initial value, next we enable notifications
setNotifyNextSensor(gatt);
}
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
//After writing the enable flag, next we read the initial value
readNextSensor(gatt);
}
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
/*
* After notifications are enabled, all updates from the device on characteristic
* value changes will be posted here. Similar to read, we hand these up to the
* UI thread to update the display.
*/
if (HUMIDITY_DATA_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_HUMIDITY, characteristic));
}
if (MAGNETO_DATA_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_MAGNETO, characteristic));
}
if (PRESSURE_DATA_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_PRESSURE, characteristic));
}
if (PRESSURE_CAL_CHAR.equals(characteristic.getUuid())) {
mHandler.sendMessage(Message.obtain(null, MSG_PRESSURE_CAL, characteristic));
}
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
//Once notifications are enabled, we move to the next sensor and start over with enable
advance();
enableNextSensor(gatt);
}
@Override
public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
Log.d(TAG, "Remote RSSI: " + rssi);
}
private String connectionState(int status) {
switch (status) {
case BluetoothProfile.STATE_CONNECTED:
return "Connected";
case BluetoothProfile.STATE_DISCONNECTED:
return "Disconnected";
case BluetoothProfile.STATE_CONNECTING:
return "Connecting";
case BluetoothProfile.STATE_DISCONNECTING:
return "Disconnecting";
default:
return String.valueOf(status);
}
}
};
/*
* We have a Handler to process event results on the main thread
*/
private static final int MSG_HUMIDITY = 101;
private static final int MSG_PRESSURE = 102;
private static final int MSG_PRESSURE_CAL = 103;
private static final int MSG_MAGNETO = 104;
private static final int MSG_PROGRESS = 201;
private static final int MSG_DISMISS = 202;
private static final int MSG_CLEAR = 301;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
BluetoothGattCharacteristic characteristic;
switch (msg.what) {
case MSG_HUMIDITY:
characteristic = (BluetoothGattCharacteristic) msg.obj;
if (characteristic.getValue() == null) {
Log.w(TAG, "Error obtaining humidity value");
return;
}
updateHumidityValues(characteristic);
break;
case MSG_MAGNETO:
characteristic = (BluetoothGattCharacteristic) msg.obj;
if (characteristic.getValue() == null) {
Log.w(TAG, "Error obtaining magneto value");
return;
}
updateMagnetoValues(characteristic);
break;
case MSG_PRESSURE:
characteristic = (BluetoothGattCharacteristic) msg.obj;
if (characteristic.getValue() == null) {
Log.w(TAG, "Error obtaining pressure value");
return;
}
updatePressureValue(characteristic);
break;
case MSG_PRESSURE_CAL:
characteristic = (BluetoothGattCharacteristic) msg.obj;
if (characteristic.getValue() == null) {
Log.w(TAG, "Error obtaining cal value");
return;
}
updatePressureCals(characteristic);
break;
case MSG_PROGRESS:
mProgress.setMessage((String) msg.obj);
if (!mProgress.isShowing()) {
mProgress.show();
}
break;
case MSG_DISMISS:
mProgress.hide();
break;
case MSG_CLEAR:
clearDisplayValues();
break;
}
}
};
/* Methods to extract sensor data and update the UI */
private void updateHumidityValues(BluetoothGattCharacteristic characteristic) {
double humidity = SensorTagData.extractHumidity(characteristic);
mHumidity.setText(String.format("%.0f%%", humidity));
}
ArrayList<Double> magnets = new ArrayList<>();
double average = 0;
int count = -1;
int wait5 = 0;
private void updateMagnetoValues(BluetoothGattCharacteristic characteristic) {
double magnet = SensorTagData.extractMagnetoX(characteristic);
Log.e("MAGNETO", "" + magnet);
magnet = Math.abs(magnet);
if (wait5 == 0) {
if (magnet > average + 300 || magnet < average - 300) {
wait5 = 6;
count ++;
mPressure.setText("" + count);
}
}
else {
wait5 --;
}
if (magnets.size() >= 5) {
magnets.remove(0);
}
magnets.add(magnet);
double sum = 0;
for (int i = 0; i < magnets.size(); i++) {
sum += magnets.get(i);
}
average = sum/magnets.size();
average = magnets.get(2);
//mHumidity.setText(String.format("%.0f%%", humidity));
}
private int[] mPressureCals;
private void updatePressureCals(BluetoothGattCharacteristic characteristic) {
mPressureCals = SensorTagData.extractCalibrationCoefficients(characteristic);
}
private void updatePressureValue(BluetoothGattCharacteristic characteristic) {
if (mPressureCals == null) return;
double pressure = SensorTagData.extractBarometer(characteristic, mPressureCals);
double temp = SensorTagData.extractBarTemperature(characteristic, mPressureCals);
mTemperature.setText(String.format("%.1f\u00B0C", temp));
mPressure.setText(String.format("%.2f", pressure));
}
}
Well I think you should do a bit more reading on how to use the characteristics. 好吧,我认为您应该对如何使用这些特性做更多的阅读。 Your chip has a bunch of characteristics by default which contain information from the chip mostly. 默认情况下,您的芯片具有许多特性,其中大部分包含来自芯片的信息。 In order to send and receive data, you have to program your chip first to send data through a specific characteristic and receive data through another specific characteristic. 为了发送和接收数据,您必须先对芯片进行编程,以通过特定特性发送数据并通过另一个特定特性接收数据。
Some chips have default Rx and Tx characteristics which you should use to send and receive data on. 某些芯片具有默认的Rx和Tx特性,应使用这些特性来发送和接收数据。 These characteristics act as pipelines between BLE and the Tx and Rx pins on your chip and will simply echo all the data through. 这些特性充当BLE与芯片上的Tx和Rx引脚之间的流水线,并将简单地回显所有数据。
Alternatively, you can create your own characteristics on the BLE service and program your own send and receive protocols. 或者,您可以在BLE服务上创建自己的特征,并编写自己的发送和接收协议。
Let me give you a simple example: 让我举一个简单的例子:
Let's say that you are using the default characteristic of your chip to send data. 假设您正在使用芯片的默认特性来发送数据。 This data has to be sent in small chunks, for example 20 bytes. 必须以小块(例如20个字节)发送此数据。 To read this data on Android, you have to first get the descriptor for that characteristic and enable notification. 要在Android上读取此数据,您必须首先获取该特征的描述符并启用通知。 This will tell Android to listen to that characteristic and monitor changes. 这将告诉Android聆听该特性并监视更改。
characteristic = gatt.getService(UUID.fromString(SERVICE_UUID)).getCharacteristic(UUID.fromString(CHARACTERISTIC_UUID)); //Find you characteristic
mGatt.setCharacteristicNotification(characteristic, true); //Tell you gatt client that you want to listen to that characteristic
List<BluetoothGattDescriptor> descriptors = characteristic.getDescriptors(); //find the descriptors on the characteristic
BluetoothGattDescriptor descriptor = descriptors.get(1); //get the right descriptor for setting notifications
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mGatt.writeDescriptor(descriptor); //apply these changes to the ble chip to tell it we are ready for the data
After doing this, you will be able to use the onCharacteristicChanged method to read the data: 完成此操作后,您将能够使用onCharacteristicChanged方法读取数据:
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
super.onCharacteristicChanged(gatt, characteristic);
String data = characteristic.getStringValue(0);
}
Sending data would be a bit simpler. 发送数据会更简单。 Once you find the characteristic, you just have to write your data in chunks to that characteristic: 找到特征后,只需将数据分块写入该特征:
byte[] value = new byte[1];
value[0] = (byte) (21 & 0xFF); //your data
characteristic.setValue(value); //assign the new data value to the characteristic
boolean success = mBluetoothGatt.writeCharacteristic(charac); //write to the chip
Once written, the chip will flush the characteristic and send the data to the chip's Tx pin. 写入后,芯片将刷新特性并将数据发送到芯片的Tx引脚。
EDIT: 编辑:
Going through the user manual for RN4020 , you can see that the chip has a default battery service and some characteristics for the model, software version, etc, but no default Rx and Tx characteristics. 浏览RN4020的用户手册 ,您会看到该芯片具有默认的电池服务以及型号,软件版本等的某些特性,但没有默认的Rx和Tx特性。
In this case, the characteristics that you found in your code were just device information and practically useless. 在这种情况下,您在代码中发现的特征只是设备信息,几乎没有用。 You have to define your own private service and characteristics on the chip first. 您必须首先在芯片上定义自己的专用服务和特性。 Look at Example 3-1 in the manual . 请参见手册中的示例3-1。 Once you define the private service and characteristic using unique UUIDs, you can write your data to that, and read it on android using the same UUID. 使用唯一的UUID定义私有服务和特征后,您可以将其写入数据,并使用相同的UUID在Android上读取数据。
I got the RN4020 working in processing.org in combination with the arduino platform. 我在arduino平台上结合了Processing.org中的RN4020。 If you're still interesting let me know. 如果您仍然很感兴趣,请告诉我。
Do you have the SW-wake and HW wake pin connected to vcc 3.3v? 您是否将SW-wake和HW唤醒引脚连接到vcc 3.3v? You don't have to go to CMD everythime you start. 您不必在开始时就参加CMD。
I just connectecd CDM directly to VCC. 我只是将CDM直接连接到VCC。 Once you give the reboot command it goes directly to MLDP. 输入重新启动命令后,它将直接进入MLDP。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.