NXP Semiconductors IoT Instruction Manual

© 2019 NXP B.V.
PRELIMINARY
NXP IoT –Weather Station Developer Guide
1. Introduction
NXP’s Rapid IoT prototyping kit is a comprehensive,
secure and optimized IoT end node solution with a
user-friendly development environment that enables
anyone to quickly take their idea to a proof-of-concept.
Its architecture is built upon two controllers:
• Kinetis K64F for the main application, powered by
an ARM® Cortex®-M4 core
• Kinetis KW41Z for wireless connectivity, powered
by an ARM® Cortex®-M0+ core
It includes:
• 10-axis motion sensing, thanks to a combo
accelerometer / magneto-meter
• Gyroscope
• Pressure sensor for altitude measurement
• Environmental sensing via temperature/humidity,
ambient light and air quality sensors
• Display capabilities with low-power color screen
• Authentication, identification
• User interfaces with LEDs, buzzer and touch plus
push buttons
• Additional memory for data storage
• Rechargeable battery
The factory application includes USB and
Bluetooth/Thread bootloaders to program your own
firmware without external tool, and several IoT
NXP Semiconductors
Weather station –Developer
Guide
Rev. 0
1,
1/2019
Contents
1. Introduction .....................................................................1
2. Mobile applications..........................................................3
Development setup ...............................................4
Applications architecture......................................4
Implementation of the main functional blocks......5
3. Cloud application...........................................................27
Development setup .............................................27
Application architecture......................................28
How to add a new measurement to the database.40
Plotting measurements in graphs ........................42
4. Broker application..........................................................43
JSON structure....................................................46
How to process a measurement and store it in the
database46
Revision history.....................................................................51

Introduction
NXP IoT –Weather Station Developer Guide
2PRELIMINARY NXP Semiconductors
application use-cases leveraging components on
board.
In order to allow any user to evaluate this product, NXP has created the “NXP IoT – Weather station”
applications. This is a set of applications consisting of a mobile application (available in Android and
iOS), a cloud application and a demo FW for the Rapid IoT device.
The usage of the mobile and cloud applications is described in detail in the User Guide document. The
main purpose of this document is to guide a developer through the mobile and cloud applications in
order to being able to retrieve data from the sensors, sent it to the cloud application, process and plot it
in graphs.
Before using the Rapid IoT devices with the provided applications, it is necessary to flash them with the
corresponding firmware. The instructions to flash are:
- Connect one end of the provided USB cable to the computer and the other end to the micro USB
type-B connector of the SLN-RPK-NODE
- Keep SW3 button pressed while briefly pushing SW5/Reset button,
- Wait 1-2s for RGB LED to blink Green then release SW3 button
Figure 1. Instructions for USB Mass Storage Device Programming

Mobile applications
NXP IoT –Weather Station Developer Guide
NXP Semiconductors PRELIMINARY 3
RGB LED will blink green and your computer will detect a new Mass Storage drive and automatically
install the appropriate drivers.
- From yourcomputer file explorer, drag-n-drop or copy-paste into theMass Storage drive theWeather
station demo binary file.
Figure 2. Instructions for pushing a new application through USB
Bootloader will automatically identify the MCU target to reprogram, thanks to the binary file signature.
RGB LED will blink purple during download and blink blue during serial flash programming.
RGB LED will blink green during K64F internal flash (re)programming with the new application (read
from Serial Flash memory) and automatically reset, when ready.
Figure 3. USB Programming LED
Table 1. K64F USB Programming LED
Sequence
More information about the Rapid IoT kit can be found in NXP’s website:
https://www.nxp.com/support/developer-resources/rapid-prototyping/nxp-rapid-iot-prototyping-kit:IOT-
PROTOTYPING
2.Mobile applications
The Weather Station platform relies on a mobile application that can be used to connect to the
RapidIoT kit, extract the data and post it to the Cloud. This application is developed for mobile phones

Mobile applications
NXP IoT –Weather Station Developer Guide
4PRELIMINARY NXP Semiconductors
supporting both Android and iOS operative systems. In the present section we will explain how these
applications were implemented and describe the relevant parts of the code so other developers can use
it as a guide to help them build their systems based in the RapidIoT.
The source code of both versions of the mobile application can be found in the following links:
- Android app: https://bitbucket.org/mobileknowledge/weather_station_demo-
androidapp/src/master/
- iOS app: https://bitbucket.org/mobileknowledge/weather_station_demo-iosapp/src/master/
Development setup
2.1.1. Android application
For the Android application development, Android studio version 3.2.1 has been used as IDE. This IDE
is widely used for Android development and has extensive documentation available in the official
Android website. Link for download: https://developer.android.com/studio/ (latest version 3.2.1 at the
time this developer guide was written).
The application is programmed in Java programming language.
2.1.2. iOS application
For the iOS application development, XCode version 10.1 has been used as IDE. In order to download
this IDE, please go to App Store in MAC OS and type “XCode”. The iOS application has been created
using Swift 4 as programming language.
Applications architecture
2.2.1. Android and iOS application
The mobile applications are built in a layered structure, following the “Model-Business-Presentation”
design pattern. A simple diagram of the relationship between layers can be found in Figure 4.

Mobile applications
NXP IoT –Weather Station Developer Guide
NXP Semiconductors PRELIMINARY 5
Figure 4. Mobile applications architecture
In order to have a consistent structure for the Android and iOS source codes, the packages structure in
both applications should be the following:
- Presentation: This package contains the files related to the UI, i.e., Activities (Android) and View
Controllers (iOS).
- Business Logic: This package contains the files related to the application logic: BLE connectivity,
Internet connectivity, JSON generation, Data validation, etc.
- Data model: This package contains the files related to the data model, i.e., Device class or
Measurement class.
- Persistent: This package will contain the files related to the persistent data storage, i.e., shared
preferences (Android), UserDefaults (iOS).
Implementation of the main functional blocks
For the sake of a clear structure and a practical use of the present document, we will analyze the
applications code from a functional point of view. This way, we will address the operations that should
be interesting for a developer willing to implement an application to obtain data from the RapidIoT
device and use it in a backend system.
2.3.1. Connecting to the RapidIoT
RapidIoT BLE configuration
The RapidIoT BLE interface is configured to provide the user with a set of BLE services and
characteristics to ease access to the information retrieved from the sensors integrated in the device.
Each sensor in the device has its own BLE characteristic where the microcontroller posts the
information, so the user can filter the information he will be notified about.

Mobile applications
NXP IoT –Weather Station Developer Guide
6PRELIMINARY NXP Semiconductors
The RapidIoT follow the UUID characteristics convention for the main Bluetooth sensor types that are
included in the Bluetooth specifications. In the following table, you can find the UUID used for the
service and characteristics used.
Name
UUID
Properties
Service
0ab5b670-c2ce-c4ab-e711-6ccbaa65c888
Pressure characteristic
00002A6D-0000-1000-8000-00805F9B34FB
NOTIFY, READ
Temperature characteristic
00002A1C-0000-1000-8000-00805F9B34FB
NOTIFY, READ
Humidity characteristic
00002A6F-0000-1000-8000-00805F9B34FB
NOTIFY, READ
Light characteristic
0ab5b672-c2ce-c4ab-e711-6ccbaa65c888
NOTIFY, READ
MAC Address characteristic
0e1bb826-612e-aca9-0e49-88f712ec1cb7
READ
The pressure, temperature and humidity data use the UUIDs defined in the Bluetooth specifications
while the light sensor information is posted to a non-standard UUID. The sensors characteristics have
Notify and Read properties so the user can read one data asynchronously or ‘subscribe’ to the
characteristic and receive updates with the sensor information. The RapidIoT kit also includes a
characteristic to obtain the device MAC address.
2.3.2. Collecting data from the sensors
Implementation in Android
The Android application implements a Singleton class called WSDBleManager to manage the
connection to the RapidIoT device. This class includes methods to scan for devices in range, trigger the
connection/disconnection to a certain device, or the definition of the BleManager callbacks for Android.
The WSDBleManager makes use of a third party library that is included in the dependencies section
from the build.gradle file of the app. This way, the WSDBleManager extends the BleManager and
BleManagerCallbacks from this library:
public class WSDBleManager extends BleManager<BleManagerCallbacks> {
Figure 5. ‘WSDBleManager’ class header in Android app
The ‘BleManagerCallbacks’includes methods that are called depending on the state that the
connection goes through. We can highlight the following methods:

Mobile applications
NXP IoT –Weather Station Developer Guide
NXP Semiconductors PRELIMINARY 7
void onDeviceConnected(final BluetoothDevice device);
void onDeviceDisconnected(final BluetoothDevice device);
void onDeviceReady(final BluetoothDevice device);
void onBondingRequired(final BluetoothDevice device);
void onBonded(final BluetoothDevice device);
Figure 6. ‘BLEManagerCallbacks’ in Android app
The ‘BleManagerCallbacks’can be overwritten at any moment by using the method ‘setGattCallbacks’
from the ‘BleManager’class.
Scanning for devices
The method used to start scanning for devices is called ‘scanAvailableDevices’. This method is present
in the ‘WSDBleManager’and requires as input an object that implements the ‘WSDBleScanListerner’
interface. This interface defines two methods: the ‘onDeviceScanned’and the ‘onDeviceScanTimeout’.
The first will be called when a new device is discovered and the second when the scanning has
reached its timeout. They are used in the main activity to show the newly discovered devices to the
user.
public void scanAvailableDevices(WSDBleScanListener wsdBleScanListener) {..}
Figure 7. ‘scanAvailableDevices’ method in Android
In the ‘scanAvailableDevices’method we configure the settings that we are going to use for the
scanning and include a filter so we will only look for devices with our Service UUID:
final ScanSettings scanSettings = new ScanSettings.Builder()
.setScanMode(ScanSettings.SCAN_MODE_BALANCED)
// Refresh the devices list continuously
.setReportDelay(0)
// Hardware filtering has some issues on selected devices
.setUseHardwareBatchingIfSupported(false)
.build();
ScanFilter scanFilterDES = new ScanFilter.Builder()
.setServiceUuid(ParcelUuid.fromString(WSDemoUUID.toString()))
.build();
Figure 8. Set scan settings in Android app
Once the settings and filter are configured, it starts scanning:
bluetoothLeScanner.startScan(filterList, scanSettings, scanCallback);
Figure 9. Start scan in Android app

Mobile applications
NXP IoT –Weather Station Developer Guide
8PRELIMINARY NXP Semiconductors
The ‘WSDBleManager’holds a list with the devices that have been scanned in the ArrayList
‘scanListDevices’. Whenever a device is scanned, we check that it has not been discovered previously
and then process it as a new one, calling the ‘onDeviceScanned’method from the
‘WSDBleScanListerner’.
Connecting to a device
When the user selects one of the devices from the list, we trigger the connection to that device by
calling the ‘initConnection’from the ‘WSDBleManager’:
showConnectingDialog();
getBLEManager().initConnection (deviceClicked);
getBLEManager().stopScan();
Figure 10. Start a connection to a device in the Android app
The ‘initConnection’method needs as input an object of the ‘DeviceModel’type. This object holds
information that will be used by the underlying library to identify the device we want to connect to.
public void initConnection(DeviceModel bleDevice) {
List<ParcelUuid> serviceUuidList = bleDevice.getServiceUuidList();
mDevice = bleDevice;
for(int i=0; i< serviceUuidList.size(); i++){
if(serviceUuidList.get(i).getUuid().equals(WSDemoUUID)){
mDevice.setDeviceType("WSDDemoUUID");
}
}
connect(mDevice.getDevice());
}
Figure 11. ‘initConnection’ in Android app
In the ‘initConnection’method, before starting the connection, we check that the UUID from the
RapidIoT service is among the ones available in the specified device.
When the connection to the device is successfully established, the method ‘onDeviceReady’is called. It
is important to remark that the first time a phone is connected to a RapidIoT kit, it might ask for a PIN to
verify the connection. The process is called bonding. In this case, the ‘onBondingRequired’method is
called. You can use this method to display a message to the user saying that he needs to introduce the
PIN to finish the connection. Once the user correctly introduces the PIN, the ‘onBonded’method is
called.
Below we can see the ‘onBondingRequired’, ‘onBonded’and ‘onDeviceReady’methods from the
application:
@Override
public void onBondingRequired(BluetoothDevice device) {
super.onBondingRequired(device);
bondingRequired = true;
Toast.makeText(getApplicationContext(), "Please follow pairing instructions in
Notification Bar", Toast.LENGTH_LONG).show();
}

Mobile applications
NXP IoT –Weather Station Developer Guide
NXP Semiconductors PRELIMINARY 9
Figure 12. ‘onBondingRequired’ method in Android app
@Override
public void onBonded(BluetoothDevice device) {
super.onBonded(device);
//If the connecting dialog is shown we close it
if(connectingDialog.isShowing()) {
connectingDialog.dismiss();
}
getBLEManager().generateSessionID(); // We generate a sessionID
if(bondingRequired) {
if(MeasurementManager.getInstance().isCloudPostingEnabled(ctx))
MeasurementManager.getInstance().startPostDataService(ctx);
goToDataDisplayActivity(); // we move to the DataDisplay screen
}
}
Figure 13. ‘onBonded’ method in Android app
@Override
public void onDeviceReady(BluetoothDevice device) {
super.onDeviceReady(device);
getBLEManager().generateSessionID(); // We generate a sessionID
if(connectingDialog.isShowing()) {
connectingDialog.dismiss();
}
if(!bondingRequired) {
if(MeasurementManager.getInstance().isCloudPostingEnabled(ctx))
MeasurementManager.getInstance().startPostDataService(ctx);
goToDataDisplayActivity();
}
else{
bondingRequired = false;
}
}
Figure 14. ‘onDeviceReady’ method in Android app
If the bonding procedure is required, we set the Boolean ‘bondingRequired’to true. In that case, we will
redirect the user to the next screen (data display screen) when the device is bonded. In case the
RapidIoT device is already known by the app and no bonding is needed, we will redirect when the
‘onDeviceReady’method is called.
After the connection is successfully achieved, the ‘BleManager’executes the ‘initGatt’method from the
‘BleManagerGattCallback’. This method should be overwritten with all requests needed to initialize the
profile. In our case, we will use it to request the ‘subscription’ to all notifications from the sensors
characteristics:

Mobile applications
NXP IoT –Weather Station Developer Guide
10 PRELIMINARY NXP Semiconductors
private final BleManagerGattCallback mGattCallback = new BleManagerGattCallback()
{
@Override
protected Deque<Request> initGatt(final BluetoothGatt gatt) {
final LinkedList<Request> requests = new LinkedList<>();
// We enqueue the notification request for every sensor characteristic
requests.push(Request.newEnableNotificationsRequest(
mPressureCharacteristic));
requests.push(Request.newEnableNotificationsRequest(
mHumidityCharacteristic));
requests.push(Request.newEnableNotificationsRequest(
mTemperatureCharacteristic));
requests.push(Request.newEnableNotificationsRequest(
mLightCharacteristic));
return requests;
}
[..]
}
Figure 15. ‘initGatt’ method in Android app
Processing data from the sensors
Once we have requested notifications from a sensor characteristic, we will receive a message every
time the RapidIoT delivers a new measurement from that sensor. This message is received through the
‘onCharacteristicNotified’method from the ‘BleManagerGattCallback’. As an example, we will look at
the case of a measurement coming from the Pressure sensor:
@Override
public void onCharacteristicNotified(final BluetoothGatt gatt,
final BluetoothGattCharacteristic characteristic){
if(characteristic.getUuid().equals(PressureUUID)){
byte[] rawpressure = characteristic.getValue();
MeasurementModel measurement = new MeasurementModel(
MeasurementUtils.getPressureMeasurement(rawpressure));
if(fitsRefreshRate(MeasurementManager.TYPE_PRESSURE)){
getMeasurementManager().addPressure(measurement);
}
}
[..]
}
Figure 16. Read characteristic value and process it in Android app
As can be seen from the snippet above, we check the characteristic of the notification received to
identify the sensor it comes from. Once we know the type of measurement we need to convert the data
to float and create with it a ‘MeasurementModel’type object:
byte[] rawpressure = characteristic.getValue();
MeasurementModel measurement = new MeasurementModel(
MeasurementUtils.getPressureMeasurement(rawpressure));