MTWristbandKit Documentation

This SDK only supports Bluetooth bracelet devices produced by Minew. The SDK can help developers handle everything between mobile phones and bracelets, including: scanning devices, broadcasting data, connecting devices, writing data to devices, receiving data from devices, etc.

Preliminary Work

Overall framework: MinewWristbandManager is a device management class, which is always a singleton when the APP is running. WristbandModule is a device instance class. This suite will generate an instance for each device, which will be used after scanning and connection. It contains device broadcast data, which will be updated as the device keeps broadcasting.

MinewWristbandManager: Device management class, you can scan the surrounding Wristband devices, and you can connect them, verify them, etc.

WristbandModule: The device instance obtained during scanning, corresponding to the wristband device, will be used after scanning and connection.

StaticInfoFrame: static information frame.

ConfigFrame: configuration frame.

CombinedFrame: Combined frame.

TemperatureHistory:Temperature history data entity class.

WristbandHistory:Contact historical data entity class.

The bracelet is not always broadcasting. Built-in acceleration sensor, it will broadcast for a period of time when there is movement, during which you can scan the device through SDK. It should be noted that the bracelet cannot be connected immediately during the broadcast phase, and it needs to be judged that it has been woken up before it can be connected.

Import to project

  1. Development environment

    The SDK supports Android 5.0 at a minimum, and the corresponding API Level is 21. Set minSdkVersion to 21or above in module's build.gradle

    android {
    
        defaultConfig {
            applicationId "com.xxx.xxx"
            minSdkVersion 21
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
  2. Add MinewWristbandKit.jar to the libs folder of the module, and add the following statement in build.gradle of the module (add dependencies directly):

    implementation files('libs/MinewWristbandKit.jar')
    implementation 'org.lucee:bcprov-jdk15on:1.52.0'
    
    1
    2

Or right click on the jar file and select Add as Library to add to the current module.

  1. The following permissions are required in AndroidManifest.xml. If targetSdkVersion is greater than 23, you need to do Permission Management to obtain permissions.

    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
    
    1
    2
    3
    4

Usage

The sdk is divided into three stages: scan, wake up and connect.

Scan

Start scan

For Android 6.0 and above, BLE scanning is only possible after applying for positioning permission, and the positioning switch must be turned on!

MinewWristbandManager manager = MinewWristbandManager.getInstance(getApplicationContext());
manager.startScan(new OnScanWristbandResultListener() {
    @Override
    public void onScanWristbandResult(ArrayList<WristbandModule> result) {
		//scan result
    }
});
1
2
3
4
5
6
7

The sdk does not process the Bluetooth scan duration, but the scan is a power-consuming operation. Generally, the scan can be stopped in 90 seconds. If you still need to continue the scan, you can provide refresh and other operations to continue the scan.

Take out the data

During the scan, the broadcast data obtained by the SDK is stored in the broadcast frame, and part of the data will be used after the connection. The frame types currently needed are: StaticInfoFrame and ConfigFrame.

StaticInfoFrame

Name Type Description
power int Battery percentage
firmwareVersion String Firmware version

ConfigFrame

Name Type Description
openStorage boolean Whether the storage switch has been turned on, false is off, otherwise it has been turned on
recordNum int Number of historical records
versionCode int Firmware version number.
After scanning ConfigFrame, the possible values are 2 or 3.
Details will be explained separately below the table
hasTemperatureSensor boolean Whether the bracelet has a temperature sensor, true means there is a temperature sensor, otherwise there is no.
temperatureRecordNum int Number of temperature alarm records. This value is valid only when versionCode is 3 and hasTemperatureSensor is true.

Note: In ConfigFrame, a new versionCode property is added, which represents the firmware version number. When ConfigFrame is scanned, the possible value is 2 or 3.

  • If it is 2, it means that the current bracelet has only: shutdown, storage switch off or on, and firmware upgrade functions;
  • If it is 3, further subdivide whether there is a temperature sensor (judged according to the hasTemperatureSensor attribute)
    • No temperature sensor: Add the function of restoring factory settings to the basic function of 2.
    • With temperature sensor: have all the above functions, and add: alarm distance reading and writing, alarm temperature reading and writing, temperature measurement interval time reading and writing functions, etc.

CombinedFrame

Name Type Description
temperature float Temperature, current temperature, the current temperature will be broadcast after pressing the button

To retrieve internal data, you first need to obtain the corresponding broadcast frame object, and then obtain the firmware version. Note that because it exists in the broadcast frame object, and when scanning, it is not guaranteed that the specified broadcast frame will be received immediately, so you need to do a non-empty judgment!

StaticInfoFrame staticInfoFrame = (StaticInfoFrame) getMinewFrame(ScanRecordFrameType.Static_Info_Frame);
if (staticInfoFrame != null) {
    //Get firmware version
    String version =  staticInfoFrame.getFirmwareVersion();
    //Get battery percentage
    int power = staticInfoFrame.getPower();
} 

ConfigFrame configFrame = (ConfigFrame) getMinewFrame(ScanRecordFrameType.Config_Frame);
if (configFrame != null) {
    //Get the number of history records
    int recordNum =  configFrame.getRecordNum();
    //Whether the storage switch has been turned on
    boolean isOpenStorage = configFrame.isOpenStorage();
    //Number of temperature alarm history records
    int tempRecordNum = configFrame.getTemperatureRecordNum();
    //Whether the wristband has a temperature sensor
    boolean hasTemperatureSensor = configFrame.hasTemperatureSensor()();
    //version number
    int versionCode = configFrame.getVersionCode();
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

SDK provides a more concise way to obtain device information, but when the broadcast frame is not received, the obtained value is "Unknown" or "-1", depending on the value, depending on whether their type.

//Get firmware version
String version =  wristbandModule.getFirmwareVersion();
//Get battery percentage
int power = wristbandModule.getPower();
//Get the number of history records
int recordNum =  wristbandModule.getTotalRecord();
//Whether the storage switch has been turned on
boolean isOpenStorage = wristbandModule.isOpenStorage();
//Get the number of temperature alarm history records
int tempRecordNum = wristbandModule.getTotalTemperatureRecord();
//Get the real-time temperature of the device
float temperature = wristbandModule.getTemperature();
//Whether the bracelet has a temperature sensor
boolean hasTemperaturSensor = wristbandModule.hasTemperatureSensor();
//Device version number. For the effect of this value, please see Scan-Get Data-ConfigFrame Part
int versionCode = wristbandModule.getFirmwareVersionCode();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Wake up

After the device scans the wristband device, it needs to wake up to connect. After waking up, you can connect within one minute; after a minute, you need to wake up again. You can judge whether the specified bracelet has been awakened by WristbandModule.isAwakened().

//Whether the current mobile phone system supports waking up the bracelet, if it is false, it will not wake up
boolean isSupport = manager.isSupportAdvertisement();
//activateState is true to indicate that the bracelet has been awakened, otherwise it is not awakened
boolean activateState = wristbandModule.isAwakened();
if (isSupport && !activateState) {  
	//The phone supports waking up the bracelet, and the current bracelet is not awakened, just go to wake up the bracelet   
	manager.startAwaken(macAddress);
}
1
2
3
4
5
6
7
8

requires attention:

  1. The scan cannot be stopped before being awakened. Otherwise, the wake-up state will not be obtained!
  2. In the activated-inactive state transition. If you do not disconnect within 1 minute after waking up and become inactive, you can only restart the scan.

The SDK uses startAwaken(String macAddress) to wake up the specified device. Now it adds a mechanism to actively stop the device from waking up. This is different from before. It used to be automatically stopped until the wake-up is successful. Now it is to set the wake-up time after the wake-up starts. After the wake-up time has elapsed, it will automatically stop waking up, and stop waking up without notification.

The SDK adds a method to set the wake-up time: setAwakenTime(long timeMillis), the default is 10 seconds, and the adjustable range is 5 seconds to 15 seconds. Since the SDK lacks the ability to actively stop waking up within the wake-up time range, the APP needs to stop waking up when it finds that the device has been awakened, namely stopAwaken().

connect

You generally need to stop scanning before connecting.

if (!device.isAwakened()) {
    //The device is not awake and cannot be connected.
    Toast.makeText(this,"not_activate",Toast.LENGTH_SHORT).show();
    return
}
//stop scan
manager.stopScan();
//connect device
manager.connect(context, module);
//disconnect
manager.disConnect(macAddress);
1
2
3
4
5
6
7
8
9
10
11

There will be status monitoring in the SDK for the connection process and device disconnection.

manager.setOnConnStateListener(new OnConnStateListener() {
    
    /*
     * Status callback during connection
     *
     * @param macAddress      device mac
     * @param connectionState status
     */
    @Override
    public void onUpdateConnState(String address, ConnectionState connectionState) {
        switch (connectionState) {
            case Disconnect:
				//If the connection fails or the device is disconnected, it will be called back, and the active disconnection will not call back this state.

                break;
            case Power_Off:
				//Shutdown, the device sends a shutdown command, the state will be called back after success, and the Disconnect state will not
                break;
            case Inactivated:
				//Not awakened. As shown above, if you connect without detecting that the device has woken up, this state will be recalled

                break;
            case Verify_Password:
				//Password verification, after calling back this state, the device needs to write a password, write it through sendPassword
                manager.sendPassword(address, "minew123")
                break;
            case PasswordError:
				//If the password is incorrect, the device will be disconnected and the Disconnect status will not be recalled
                break;
            
            case Firmware_Upgrade_Successfully:
				//The firmware upgrade is successful and the Disconnect status will not be recalled
                break;

            case Connect_Complete:
				//The connection is complete, and the device can read and write at this time
                break;
            case Reset_Device:
                //Restore the factory settings, the state will be called back after success, and the Disconnect state will not be called back
                break;
            default:
                break;
        }
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

During the connection process, the SDK will return multiple connection states to the app, and the app needs to handle it:

  • ConnectionState.Inactivated: If before and after the connection to determine whether the bracelet has been activated, generally will not call back this state. However, the activation time of the bracelet is only one minute, and if it is connected after one minute, although the SDK returns to the activated state at this time, the activation state will not be updated in reality. Need to restart scanning to change;
  • ConnectionState.Verify_Password: Wristband connection requires password verification. Once this status is recalled, the password needs to be written through manager.sendPassword(address, "minew123"). Note that the password length is 8 digits;
  • ConnectionState.PasswordError: Wrong password, the wristband will disconnect, and will not return ConnectionState.Disconnect state;
  • ConnectionState.Connect_Complete: Return to this state, indicating that the wristband has been successfully connected, and you can read and write operations, such as reading history records, etc;
  • ConnectionState.Power_Off: Shut down. Through the shutdown command, the bracelet can be shut down and the state can be recalled. In addition, the connection will also be disconnected, and the ConnectionState.Disconnect state will not be called back;
  • ConnectionState.Firmware_Upgrade_Successfully: When the firmware is upgraded, the SDK will give another callback method, and the status will be called back after the upgrade is successful, the connection will be disconnected, and the ConnectionState.Disconnect state will not be called back;
  • ConnectionState.Disconnect: If the connection fails or the device is disconnected, it will be called back, and the active disconnection will not call back this state. That is, calling manager.disConnect(macAddress); will not call back this state. Note: This status will be called back if the upgrade fails;
  • ConnectionState.Reset_Device: The factory setting is restored successfully, and the state is called back. In addition, the connection will be disconnected, and the ConnectionState.Disconnect state will not be called back.

API summary

Before connect

  1. startScan(): Start scanning. Each start scan will clear all the results of the last scan

  2. stopScan(): stop scanning

  3. setAwakenTime(long timeMillis): Set the wake-up time, the default is 10 seconds, the setting will take effect before startAwaken(String macAddress) is called

  4. getAwakenTime(): Get the wake-up duration previously set

  5. startAwaken(String macAddress): Start to wake up the device

  6. stopAwaken(): Stop to wake up

  7. isAwakened(): Whether to wake up the device

  8. connect(Context context, WristbandModule module): connect the device

  9. disConnect(String macAddress): Disconnect

  10. setOnConnStateListener(OnConnStateListener listener): Set the connection state, this must be called

  11. sendPassword(String macAddress, String password): Write password

    //macAddress is the wristband mac, password is the password to be written
    manager.sendPassword(macAddress, password);
    
    1
    2

After connect

**Note: After connection, during the connection period, for the same device, whether it is reading or writing, you need to wait until the previous operation is completed before proceeding to the next operation, otherwise the program will have problems. **For example, the bracelet has 20,000 historical records, and it takes a few minutes to read. At this time, turning off the storage switch will cause program problems, which may be data disorder, or more serious program crashes.

Also please note: Reading the history records may cause packet loss during the communication process! If you are more sensitive to historical data, you can judge the number of historical data after reading it. If the number is inconsistent with the expected result, you can read it again.

The available methods after connection are as follows:

  1. Read historical data;

    The historical data is read through the index, and the index starts from 0. If the first seven items are read, 0 and 6 are passed. It should be noted that each reading cannot exceed 7 items. If 0 and 25 are passed in, 0 to 6 are read by default, ie the first 7 are read.

    //Pass in the wristband object, start index and end index and listener respectively
    manager.readHistoryData(module, 0, 6, 
                            new OnReadHistoryDataListener<WristbandHistory>() {
        
        /**
         * mac is the device mac
         * data is the historical data obtained by this read operation
         */
        @Override
        public void receiverDataCompletely(String macAddress, 
                                           ArrayList<WristbandHistory> list) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
  2. Read all historical data;

    manager.readAllHistoryData(module, 
                               new OnReadAllHistoryDataListener<WristbandHistory>() {
        
        /**
         * mac is the device mac
         * process is the progress of reading all historical data
         */                            
        @Override
        public void receiverDataProgress(String macAddress, float process) {
    
        }
    
        /**
         * mac is the device mac
         * data is the historical data obtained by this read operation
         */                           
        @Override
        public void receiverDataCompletely(String macAddress, 
                                           ArrayList<WristbandHistory> allData) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
  3. Read historical temperature alarm data;

    Reading the historical data of temperature alarms is read through the index. The index starts from 0. If the first seven items are read, 0 and 6 are passed in. It should be noted that each reading cannot exceed 14. If 0 and 25 are passed in, 0 to 6 are read by default, that is, the first 14 items are read.

    //Pass in the wristband object, start index and end index and listener respectively
    manager.readTemperatureHistory(module, 0, 6, 
                                   new OnReadHistoryDataListener<TemperatureHistory>() {
        /**
         * mac is the device mac
         * data is the historical data obtained by this read operation
         */                                
        @Override
        public void receiverDataCompletely(String macAddress, 
                                           ArrayList<TemperatureHistory> allData) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
  4. Read all historical temperature alarm data;

    manager.readAllTemperatureHistory(
        module, 
        new OnReadAllHistoryDataListener<TemperatureHistory>() {
            /**
             * mac is the device mac
             * process is the progress of reading all historical data
             */  
            @Override
            public void receiverDataProgress(String macAddress, float process) {
    
            }
    
            /**
             * mac is the device mac
             * data is the historical data obtained by this read operation
             */  
            @Override
            public void receiverDataCompletely(String macAddress, 
                                               ArrayList<TemperatureHistory> allData) {
    
            }
        });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
  5. Storage switch settings

    /**
     * Storage switch settings
     *
     * @param macAddress device mac
     * @param isOpen whether to open
     * @param listener listener
     */
    manager.storageSwitch(mac, true, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean b) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
  6. Power off

    /**
     * power off
     *
     * @param macAddress device mac
     */
    manager.powerOff(mac, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean b) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
  7. Firmware upgrade

    /**
     * Firmware upgrade
     *
     * @param macAddress device mac
     * @param upgradeData upgrade package data
     * @param listener listener
     */
    manager.firmwareUpgrade(mac, upgradeData, new OnFirmwareUpgradeListener() {
        
        /**
         * Update package data writing progress
         */
        @Override
        public void updateProgress(int progress) {
    
        }
    
        /**
         * Successful upgrade will trigger OnConnStateListener callback and return
         * ConnectionState.Firmware_Upgrade_Successfully state
         */
        @Override
        public void upgradeSuccess() {
    
        }
        
        /**
         * Upgrade failed. Failure to upgrade will disconnect the connection, trigger OnConnStateListener callback, return
          * ConnectionState.Disconnect state
         */
        @Override
        public void upgradeFailed() {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
  8. reset. It can be used when ConfigFrame.versionCode is 3;

    manager.resetDevice(module, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean value) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  9. Read the temperature measurement interval. It can be used when ConfigFrame.versionCode is 3 and WristbandModule.hasTemperatureSensor() returns true. The measurement interval read is in the range of 0 to 7200 seconds. Note that the unit is second;

    manager.readTempeMeasureInterval(module, new OnReadValueListener<Integer>() {
        @Override
        public void onReadValue(Integer integer) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  10. Set the temperature measurement interval. It can be used when ConfigFrame.versionCode is 3 and WristbandModule.hasTemperatureSensor() returns true. The measurement interval supported by the bracelet ranges from 0 to 7200 seconds. Note that the unit is seconds;

    manager.setTempMeasureInterval(module, 8, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean result) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  11. Read the temperature alarm value. It can be used when ConfigFrame.versionCode is 3 WristbandModule.hasTemperatureSensor() returns true. The read value range should be between 30.0℃ ~ 42.0℃ in the setting range;

    manager.readTempAlarmValue(module, new OnReadValueListener<Float>() {
        @Override
        public void onReadValue(Float value) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  12. Set the temperature alarm value. It can be used when ConfigFrame.versionCode is 3 WristbandModule.hasTemperatureSensor() returns true. The written value range should be between 30.0℃ ~ 42.0℃ in the setting range;

    manager.setTempAlarmValue(module, 20, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean result) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  13. Read the alarm distance gear. It can be used when WristbandModule.getFirmwareVersionCode() returns 3. The value read is 0 to 4;

    manager.readAlarmGear(module, new OnReadValueListener<Integer>() {
        @Override
        public void onReadValue(Integer value) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  14. Write the alarm distance gear. It can be used when WristbandModule.getFirmwareVersionCode() returns 3. The value written is 0 to 4.

    manager.setAlarmGear(module, 2, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean result) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  15. Read the temperature alarm vibration value. The written value range should be between 30.0°C ~ 42.0°C in the setting range. It can be used only if the following conditions are met:

    • WristbandModule.getFirmwareVersionCode() returns 3

    • WristbandModule.hasTemperatureSensor() returns true

    • The firmware version is 3.2.5 and above.

    manager.readAlarmVibrationValue(module, new OnReadValueListener<Integer>() {
        @Override
        public void onReadValue(Integer value) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  16. Set the temperature alarm vibration value. The written value range should be between 30.0°C ~ 42.0°C in the setting range. It can be used only if the following conditions are met:

    • WristbandModule.getFirmwareVersionCode() returns 3

    • WristbandModule.hasTemperatureSensor() returns true

    • The firmware version is 3.2.5 and above.

    manager.setAlarmVibrationValue(module, 33F, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean result) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  17. To read the temperature alarm vibration switch value, the following conditions must be met before it can be used:

    • WristbandModule.getFirmwareVersionCode() returns 3

    • WristbandModule.hasTemperatureSensor() returns true

    • The firmware version is 3.2.5 and above.

    manager.readVibrationSwitch(module, new OnReadValueListener<Boolean>() {
        @Override
        public void onReadValue(Boolean value) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  18. Set the temperature alarm vibration switch value. It can be used only if the following conditions are met:

    • WristbandModule.getFirmwareVersionCode() returns 3

    • WristbandModule.hasTemperatureSensor() returns true

    • The firmware version is 3.2.5 and above.

    manager.setVibrationSwitch(module, true, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean result) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  19. Read the close-range alarm vibration switch value. It can be used only if the following conditions are met:

    • WristbandModule.getFirmwareVersionCode() returns 2 or 3
    • The firmware version is 3.2.5 and above.
    manager.readCrAlarmVibrationSwitch(module, new OnReadValueListener<Boolean>() {
        @Override
        public void onReadValue(Boolean value) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6
  20. Set the close-range alarm vibration switch value. It can be used only if the following conditions are met:

    • WristbandModule.getFirmwareVersionCode() returns 2 or 3
    • The firmware version is 3.2.5 and above.
    manager.setCrAlarmVibrationSwitch(module, true, new OnChangeListener() {
        @Override
        public void onModifyResult(boolean result) {
    
        }
    });
    
    1
    2
    3
    4
    5
    6

Schedule

Here is a description of the properties of some classes.

TemperatureHistory(Temperature history data entity class):

Name Type Description
macAddress String Current device mac
time long Timestamp, indicating the time of recording
temperature float Temperature

WristbandHistory(Contact historical data entity class):

Name Type Description
macAddress String Device mac
time long Timestamp, indicating the time of recording
rssi float Signal strength

Update history

2020/07/06

  1. Add sdk support system version description;
  2. In the addition of reading historical data, the length of a single reading cannot exceed 7, and the index starts from 0.

2020/08/11

  1. Modify the minimum sdk support version to 21, add the isSupportAdvertisement() method to determine whether the system supports waking up the bracelet;
  2. Added resetDevice(), readTempeMeasureInterval(), setTempMeasureInterval(), readTempAlarmValue(), setTempAlarmValue(), readAlarmGear(), setAlarmGear() and other methods. Since the SDK is compatible with previous bracelet devices, you need to make some judgments when calling these methods. Check this document specifically

2020/08/26

  1. Modify the setting gear from 0 to 4;
  2. Add the following methods:
    • setAwakenTime()
    • getAwakenTime()

2020/09/01

Modify the maximum number of temperature history data that can be read at a time from 7 to 14. The affected method is: readTemperatureHistory().

2020/09/16

Modify the range of setting and reading temperature alarm value to 30.0°C ~ 42.0°C;

2020/10/10

  1. Added description of TemperatureHistory and WristbandHistory properties;
  2. In the process of reading historical data (contact data and temperature data), packet loss may occur. If you are more sensitive to historical data, you can judge the number of historical data after reading it. If the number is inconsistent with the expected result, you can read it again.

2021/04/02

Added read and write data functions, these functions are located in the 15th to 20th items of the function list after connection. In addition, please be sure to note that some new functions are added to the new firmware. Before using these functions, they need to be used on the basis of firmware and hardware. See the demo for details.

In addition, the function list after the connection is supplemented with conditional judgments under which versions these functions can be used.

Last Updated:: 4/6/2021, 5:09:38 PM