You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ad...@apache.org on 2017/02/16 05:50:58 UTC
[2/5] incubator-mynewt-site git commit: Fully functioning ADC Tutorial
Fully functioning ADC Tutorial
Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/commit/03cd817d
Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/tree/03cd817d
Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/diff/03cd817d
Branch: refs/heads/develop
Commit: 03cd817d1d405c557d41547444c7644c6e46e092
Parents: 9183cab
Author: David G. Simmons <sa...@mac.com>
Authored: Wed Feb 8 15:22:46 2017 -0500
Committer: David G. Simmons <sa...@mac.com>
Committed: Wed Feb 8 15:22:46 2017 -0500
----------------------------------------------------------------------
docs/os/tutorials/nrf52_adc.md | 772 ++++++++++++++++++++++--------------
1 file changed, 471 insertions(+), 301 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/blob/03cd817d/docs/os/tutorials/nrf52_adc.md
----------------------------------------------------------------------
diff --git a/docs/os/tutorials/nrf52_adc.md b/docs/os/tutorials/nrf52_adc.md
index 4d3009b..d520b14 100644
--- a/docs/os/tutorials/nrf52_adc.md
+++ b/docs/os/tutorials/nrf52_adc.md
@@ -47,7 +47,7 @@ or just follow the commands below.
The board-specific libraries for the NRF52dk board are in an external repository at present, so
you'll need to include that remote repository and install it as well. If you're not familiar
with using repositories, see the section on [repositories](repo/add_repos.md) before
-continuiing. Or just copy and paste the following.
+continuing. Or just copy and paste the following.
In your `project.yml` file, add `- mynewt_nordic` to the `project.repositories` section, and
then add the proper repository definition. When you're done, your `project.yml` file
@@ -107,12 +107,54 @@ Note: The correct bsp must be chosen for the board you are using. </font>
* For the Nordic Dev Kit choose @apache-mynewt-core/hw/bsp/nrf52dk instead (in the highlighted lines)
* For the Rigado Eval Kit choose @apache-mynewt-core/hw/bsp/bmd300eval instead (in the highlighted lines)
+For the app itself we're going to extend the [bleprph](belpprph/bleprph-app.md) app so that we
+get the Bluetooth communications built in, so the first thing we'll need to do is copy that app
+into our own app directory:
+
+```no-highlight
+$ mkdir -p apps/nrf52_adc
+$ cp -Rp repos/apache-mynewt-core/apps/bleprph/* apps/nrf52_adc
+```
+
+Next, you'll modify the `pkg.yml` file for your app:
+
+```
+$ cat app/nrf52_adc/pkg.yml
+...
+pkg.name: apps/nrf52_adc
+pkg.type: app
+pkg.description: Simple BLE peripheral application for ADC Sensors.
+pkg.author: "Apache Mynewt <de...@mynewt.incubator.apache.org>"
+pkg.homepage: "http://mynewt.apache.org/"
+pkg.keywords:
+
+pkg.deps:
+ - boot/split
+ - kernel/os
+ - mgmt/newtmgr
+ - mgmt/newtmgr/transport/ble
+ - net/nimble/controller
+ - net/nimble/host
+ - net/nimble/host/services/ans
+ - net/nimble/host/services/gap
+ - net/nimble/host/services/gatt
+ - net/nimble/host/store/ram
+ - net/nimble/transport/ram
+ - sys/console/full
+ - sys/log/full
+ - sys/stats/full
+ - sys/sysinit
+ - sys/id
+```
+
+Great! We have our very own app so let's make sure we have all of our targets set
+correctly:
```hl_lines="3 8"
$ newt target create nrf52_adc
-$ newt target set nrf52_adc app=@apache-mynewt-core/apps/nrf52_adc
-Target targets/nrf52_adc successfully set target.app to @apache-mynewt-core/apps/nrf52_adc
-$ newt target set nrf52_adc_ bsp=@apache-mynewt-core/hw/bsp/nrf52dk
+$ newt target set nrf52_adc app=apps/nrf52_adc
+Target targets/nrf52_adc successfully set target.app to apps/nrf52_adc
+$ newt target set nrf52_adc bsp=@apache-mynewt-core/hw/bsp/nrf52dk
$ newt target set nrf52_adc build_profile=debug
$ newt target create nrf52_boot
@@ -122,7 +164,7 @@ $ newt target set nrf52_boot build_profile=optimized
$ newt target show
targets/nrf52_adc
- app=@apache-mynewt-core/apps/nrf52_adc
+ app=apps/nrf52_adc
bsp=@apache-mynewt-core/hw/bsp/nrf52dk
build_profile=debug
targets/nrf52_boot
@@ -183,8 +225,8 @@ Download the bootloader first and then the nrf52_adc executable to the target pl
Don't forget to reset the board if you don't see the LED blinking right away!
```
-$ newt -v load nrf52_boot
-$ newt -v load nrf52_adc
+$ newt load nrf52_boot
+$ newt load nrf52_adc
```
<br>
@@ -215,28 +257,388 @@ Erasing done.
J-Link>exit
$
```
+<br>
+
+So you have a BLE app, but really all you've done is change the name of the **bleprph** app to **nrf52_adc** and load that.
+Not all that impressive, and it certainly won't read an Analog Sensor right now. So let's do that next. In order to
+read an ADC sensor, and since the ADC package is in an external, licensed, repository, we'll create a driver for it
+here in our app that will leverage the existing driver in the external repository. It adds another layer of
+indirection, but it will also give us a look at building our own driver, so we'll do it this way.
+
+<br>
+
+### Building a Driver
+
+The first thing to do is to create the directory structure for your driver:
+
+```no-highlight
+[user@IsMyLaptop:~/src/air_quality]$ mkdir -p libs/my_drivers/myadc/include/myadc
+[user@IsMyLaptop:~/src/air_quality]$ mkdir -p libs/my_drivers/myadc/src
+```
+
+Now you can add the files you need. You'll need a pkg.yml to describe the driver, and then header stub followed by source stub.
+
+```no-highlight
+[user@IsMyLaptop:~/src/air_quality]$ cat libs/my_drivers/myadc/pkg.yml
+```
+
+```c
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+pkg.name: libs/my_drivers/myadc
+pkg.deps:
+ - "@apache-mynewt-core/hw/hal"
+ - "@mynewt-nordic/hw/drivers/adc/adc_nrf52"
+```
+
+First, let's create the required header file `myadc.h` in the includes directory.
+It's a pretty straightforward header file, since we only need to do 2 things:
+
+* Initialize the ADC device
+* Read ADC Values
+
+
+```c
+#ifndef _NRF52_ADC_H_
+#define _NRF52_ADC_H_
+
+void * adc_init(void);
+int adc_read(void *buffer, int buffer_len);
+
+#endif /* _NRF52_ADC_H_ */
+
+```
+
+Next we'll need a corresponding source file `myadc.c` in the src directory. This is where
+we'll implement the specifics of the driver:
+
+```c
+
+#include <assert.h>
+#include <os/os.h>
+/* ADC */
+#include "myadc/myadc.h"
+#include "nrf.h"
+#include "app_util_platform.h"
+#include "app_error.h"
+#include <adc/adc.h>
+#include <adc_nrf52/adc_nrf52.h>
+#include "nrf_drv_saadc.h"
+
+
+#define ADC_NUMBER_SAMPLES (2)
+#define ADC_NUMBER_CHANNELS (1)
+
+nrf_drv_saadc_config_t adc_config = NRF_DRV_SAADC_DEFAULT_CONFIG;
+
+struct adc_dev *adc;
+uint8_t *sample_buffer1;
+uint8_t *sample_buffer2;
+
+static struct adc_dev os_bsp_adc0;
+static nrf_drv_saadc_config_t os_bsp_adc0_config = {
+ .resolution = MYNEWT_VAL(ADC_0_RESOLUTION),
+ .oversample = MYNEWT_VAL(ADC_0_OVERSAMPLE),
+ .interrupt_priority = MYNEWT_VAL(ADC_0_INTERRUPT_PRIORITY),
+};
+void *
+adc_init(void)
+{
+ int rc = 0;
+
+ rc = os_dev_create((struct os_dev *) &os_bsp_adc0, "adc0",
+ OS_DEV_INIT_KERNEL, OS_DEV_INIT_PRIO_DEFAULT,
+ nrf52_adc_dev_init, &os_bsp_adc0_config);
+ assert(rc == 0);
+ nrf_saadc_channel_config_t cc = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1);
+ cc.gain = NRF_SAADC_GAIN1_6;
+ cc.reference = NRF_SAADC_REFERENCE_INTERNAL;
+ adc = (struct adc_dev *) os_dev_open("adc0", 0, &adc_config);
+ assert(adc != NULL);
+ adc_chan_config(adc, 0, &cc);
+ sample_buffer1 = malloc(adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ sample_buffer2 = malloc(adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ memset(sample_buffer1, 0, adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ memset(sample_buffer2, 0, adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ adc_buf_set(adc, sample_buffer1, sample_buffer2,
+ adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ return adc;
+}
+
+
+int
+adc_read(void *buffer, int buffer_len)
+{
+ int i;
+ int adc_result;
+ int my_result_mv = 0;
+ int rc;
+ for (i = 0; i < ADC_NUMBER_SAMPLES; i++) {
+ rc = adc_buf_read(adc, buffer, buffer_len, i, &adc_result);
+ if (rc != 0) {
+ goto err;
+ }
+ my_result_mv = adc_result_mv(adc, 0, adc_result);
+ }
+ adc_buf_release(adc, buffer, buffer_len);
+ return my_result_mv;
+err:
+ return (rc);
+}
+```
+There's a lot going on in here, so let's walk through it step by step.
+
+First, we define a default configuration, with the resolution, oversample and interrupt priority. You'll see
+that these are `MYNEWT_VAL` values, which means that we'll define them shortly in
+a `syscfg.yml` file to be passed to the compiler at build time.
+
+```c
+static struct adc_dev os_bsp_adc0;
+static nrf_drv_saadc_config_t os_bsp_adc0_config = {
+ .resolution = MYNEWT_VAL(ADC_0_RESOLUTION),
+ .oversample = MYNEWT_VAL(ADC_0_OVERSAMPLE),
+ .interrupt_priority = MYNEWT_VAL(ADC_0_INTERRUPT_PRIORITY),
+};
+```
+
+Next, in `adc_init()` , we need to tell the OS to create the device.
+
+```c
+void *
+adc_init(void)
+{
+ int rc = 0;
+
+ rc = os_dev_create((struct os_dev *) &os_bsp_adc0, "adc0",
+ OS_DEV_INIT_KERNEL, OS_DEV_INIT_PRIO_DEFAULT,
+ nrf52_adc_dev_init, &os_bsp_adc0_config);
+ assert(rc == 0);
+ nrf_saadc_channel_config_t cc = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1);
+ cc.gain = NRF_SAADC_GAIN1_6;
+ cc.reference = NRF_SAADC_REFERENCE_INTERNAL;
+ adc = (struct adc_dev *) os_dev_open("adc0", 0, &adc_config);
+ assert(adc != NULL);
+ adc_chan_config(adc, 0, &cc);
+ sample_buffer1 = malloc(adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ sample_buffer2 = malloc(adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ memset(sample_buffer1, 0, adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ memset(sample_buffer2, 0, adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ adc_buf_set(adc, sample_buffer1, sample_buffer2,
+ adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
+ return adc;
+}
+
+```
+A few things need to be said about this part, as it is the most confusing. First,
+we're using a **default** configuration for the ADC Channel via the `NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE`
+macro. The important part here is that we're actually using `AIN1`. I know what you're thinking, "But
+we want ADC-0!" and that's true. The board is actually labelled 'A0, A1, A2' etc., and the actual pin
+numbers are also listed on the board, which seems handy. At first. But it gets messy very quickly.
+
+If you try to use AIN0, and then go poke around in the registers while this is running,
+
+```
+(gdb) p/x {NRF_SAADC_Type}0x40007000
+...
+ CH = {{
+ PSELP = 0x1,
+ PSELN = 0x0,
+ CONFIG = 0x20000,
+ LIMIT = 0x7fff8000
+ },
+```
+
+You'll see that the pin for channel 0 is set to 1, which corresponds to AIN0, but that's **NOT**
+the same as A0 -- pin P0.03, the one we're using. For that, you use AIN1, which would set the
+pin value to 2. Messy. Someone, somewhere, thought this made sense.
+
+
+The only other thing to note here is that we're using the internal reference voltage, rather than
+setting our own. There's nothing wrong with that, but since we are, we'll have to crank up
+the gain a bit by using `NRF_SAADC_GAIN1_6`.
+
+Then, in `adc_read()` we will take readings, convert the raw readings to
+a millivolt equivalent, and return the result.
+
+```c
+int
+adc_read(void *buffer, int buffer_len)
+{
+ int i;
+ int adc_result;
+ int my_result_mv = 0;
+ int rc;
+ for (i = 0; i < ADC_NUMBER_SAMPLES; i++) {
+ rc = adc_buf_read(adc, buffer, buffer_len, i, &adc_result);
+ if (rc != 0) {
+ goto err;
+ }
+ my_result_mv = adc_result_mv(adc, 0, adc_result);
+ }
+ adc_buf_release(adc, buffer, buffer_len);
+ return my_result_mv;
+err:
+ return (rc);
+}
+```
+
+Finally, we'll need some settings for our driver, as mentioned earlier. In the `myadc` directory
+you'll need to add a `syscfg.yml` file:
+
+```no-highlight
+# Package: libs/my_driver/myadc
+
+syscfg.defs:
+ ADC_0:
+ description: 'TBD'
+ value: 1
+ ADC_0_RESOLUTION:
+ description: 'TBD'
+ value: 'SAADC_CONFIG_RESOLUTION'
+ ADC_0_OVERSAMPLE:
+ description: 'TBD'
+ value: 'SAADC_CONFIG_OVERSAMPLE'
+ ADC_0_INTERRUPT_PRIORITY:
+ description: 'TBD'
+ value: 'SAADC_CONFIG_IRQ_PRIORITY'
+```
+
+Once that's all done, you should have a working ADC Driver for your NRF52DK board.
+
+<br>
+
+### Creating the ADC Task
+
+Now that the driver is done, we'll need to add calls to the main app's `main.c` file, as well
+as a few other things. First, we'll need to update the includes, and add a task for our ADC
+sampling.
+
+
+```c
+#include "myadc/myadc.h"
+...
+/* ADC Task settings */
+#define ADC_TASK_PRIO 5
+#define ADC_STACK_SIZE (OS_STACK_ALIGN(336))
+struct os_eventq adc_evq;
+struct os_task adc_task;
+bssnz_t os_stack_t adc_stack[ADC_STACK_SIZE];
+```
+
+Next we'll need o initialize the task `event_q` so we'll add the following to `main()` :
+
+```c
+ /* Set the default device name. */
+ rc = ble_svc_gap_device_name_set("nimble-adc");
+ assert(rc == 0);
+
+ conf_load();
+
+ /* Initialize adc sensor task eventq */
+ os_eventq_init(&adc_evq);
+
+ /* Create the ADC reader task.
+ * All sensor operations are performed in this task.
+ */
+ os_task_init(&adc_task, "sensor", adc_task_handler,
+ NULL, ADC_TASK_PRIO, OS_WAIT_FOREVER,
+ adc_stack, ADC_STACK_SIZE);
+```
+We'll need that `adc_task_handler()` function to exist, and that's where we'll initialize the ADC Device
+and set the event handler. In the task's while() loop, we'll just make a call to `adc_sample()` to cause
+the ADC driver to sample the adc device.
+
+```c
+/**
+ * Event loop for the sensor task.
+ */
+static void
+adc_task_handler(void *unused)
+{
+ struct adc_dev *adc;
+ int rc;
+ /* ADC init */
+ adc = adc_init();
+ rc = adc_event_handler_set(adc, adc_read_event, (void *) NULL);
+ assert(rc == 0);
+
+ while (1) {
+ adc_sample(adc);
+ /* Wait 2 second */
+ os_time_delay(OS_TICKS_PER_SEC * 2);
+ }
+}
+```
+
+Finally, we'll need to handle those `adc_read_event()` calls:
+
+```c
+int
+adc_read_event(struct adc_dev *dev, void *arg, uint8_t etype,
+ void *buffer, int buffer_len)
+{
+ int value;
+ uint16_t chr_val_handle;
+ int rc;
+
+ value = adc_read(buffer, buffer_len);
+ if (value >= 0) {
+ console_printf("Got %d\n", value);
+ } else {
+ console_printf("Error while reading: %d\n", value);
+ goto err;
+ }
+ gatt_adc_val = value;
+ rc = ble_gatts_find_chr(&gatt_svr_svc_adc_uuid.u, BLE_UUID16_DECLARE(ADC_SNS_VAL), NULL, &chr_val_handle);
+ assert(rc == 0);
+ ble_gatts_chr_updated(chr_val_handle);
+ return (0);
+err:
+ return (rc);
+}
+```
+This is where we actually read the ADC value and then update the BLE Characteristic for that value.
+
+But wait, we haven't defined those BLE services and characteristics yet! Right, so don't try to build and run this
+app just yet or it will surely fail. Instead, move on to the next section and get all of those services
+defined.
<br>
### Building the BLE Services
-The nrf52_adc app is a Bluetooth-enabled sensor app that will allow you to read the value of the eTape Water Level Sensor
-via Bluetooth. So let's go through some of the code.
+If the nrf52_adc app is going to be a Bluetooth-enabled sensor app that will allow you to read the value of the eTape Water Level Sensor
+via Bluetooth we'll need to actually define those Services and Characteristics.
As with the [ble peripheral](bleprph/bleprph-app.md) app, we will advertise a couple of values from our app. The first is
-not strictly necessary, but it will help us build an iOS app later. We've defiined a service and the characteristics in
+not strictly necessary, but it will help us build an iOS app later. We've defined a service and the characteristics in
that service in `bleadc.h` as follows:
```c
/* Sensor Data */
/* e761d2af-1c15-4fa7-af80-b5729002b340 */
-static const uint8_t gatt_svr_svc_sns_uuid[16] = {
- 0x40, 0xb3, 0x20, 0x90, 0x72, 0xb5, 0x80, 0xaf,
- 0xa7, 0x4f, 0x15, 0x1c, 0xaf, 0xd2, 0x61, 0xe7 };
+static const ble_uuid128_t gatt_svr_svc_adc_uuid =
+ BLE_UUID128_INIT(0x40, 0xb3, 0x20, 0x90, 0x72, 0xb5, 0x80, 0xaf,
+ 0xa7, 0x4f, 0x15, 0x1c, 0xaf, 0xd2, 0x61, 0xe7);
#define ADC_SNS_TYPE 0xDEAD
-#define ADC_SNS_VAL 0xBEEF
-#define ADC_SNS_STRING "eTape Water Level Sensor"
-
+#define ADC_SNS_STRING "eTape Liquid Level Sensor"
+#define ADC_SNS_VAL 0xBEAD
uint16_t gatt_adc_val;
```
@@ -246,62 +648,57 @@ it will be a read-only characteristic. The second characteristic will be the sen
itself, and we will allow connected devices to 'subscribe' to it in order to get
constantly-updated values.
+
+**Note:** You can choose any valid Characteristic UUIDs to go here. We're using these values
+for illustrative purposes only.
+
The value that we'll be updating is also defined here as `gatt_adc_val`.
If we then go look at `gatt_srv.c` we can see the structure of the service and
characteristic offering that we set up:
```c
-
+static const struct ble_gatt_svc_def gatt_svr_svcs[] = {
{
- /*** Alert Notification Service. */
+ /*** Service: Security test. */
.type = BLE_GATT_SVC_TYPE_PRIMARY,
- .uuid128 = BLE_UUID16(GATT_SVR_SVC_ALERT_UUID),
+ .uuid = &gatt_svr_svc_sec_test_uuid.u,
.characteristics = (struct ble_gatt_chr_def[]) { {
- .uuid128 = BLE_UUID16(GATT_SVR_CHR_SUP_NEW_ALERT_CAT_UUID),
- .access_cb = gatt_svr_chr_access_alert,
- .flags = BLE_GATT_CHR_F_READ,
+ /*** Characteristic: Random number generator. */
+ .uuid = &gatt_svr_chr_sec_test_rand_uuid.u,
+ .access_cb = gatt_svr_chr_access_sec_test,
+ .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_READ_ENC,
}, {
- .uuid128 = BLE_UUID16(GATT_SVR_CHR_NEW_ALERT),
- .access_cb = gatt_svr_chr_access_alert,
- .flags = BLE_GATT_CHR_F_NOTIFY,
- }, {
- .uuid128 = BLE_UUID16(GATT_SVR_CHR_SUP_UNR_ALERT_CAT_UUID),
- .access_cb = gatt_svr_chr_access_alert,
- .flags = BLE_GATT_CHR_F_READ,
- }, {
- .uuid128 = BLE_UUID16(GATT_SVR_CHR_UNR_ALERT_STAT_UUID),
- .access_cb = gatt_svr_chr_access_alert,
- .flags = BLE_GATT_CHR_F_NOTIFY,
- }, {
- .uuid128 = BLE_UUID16(GATT_SVR_CHR_ALERT_NOT_CTRL_PT),
- .access_cb = gatt_svr_chr_access_alert,
- .flags = BLE_GATT_CHR_F_WRITE,
+ /*** Characteristic: Static value. */
+ .uuid = &gatt_svr_chr_sec_test_static_uuid.u,
+ .access_cb = gatt_svr_chr_access_sec_test,
+ .flags = BLE_GATT_CHR_F_READ |
+ BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_WRITE_ENC,
}, {
0, /* No more characteristics in this service. */
} },
},
{
- /*** Water Level Notification Service. */
+ /*** ADC Level Notification Service. */
.type = BLE_GATT_SVC_TYPE_PRIMARY,
- .uuid128 = gatt_svr_svc_sns_uuid,
+ .uuid = &gatt_svr_svc_adc_uuid.u,
.characteristics = (struct ble_gatt_chr_def[]) { {
- .uuid128 = BLE_UUID16(ADC_SNS_TYPE),
+ .uuid = BLE_UUID16_DECLARE(ADC_SNS_TYPE),
.access_cb = gatt_svr_sns_access,
.flags = BLE_GATT_CHR_F_READ,
}, {
- .uuid128 = BLE_UUID16(ADC_SNS_VAL),
+ .uuid = BLE_UUID16_DECLARE(ADC_SNS_VAL),
.access_cb = gatt_svr_sns_access,
.flags = BLE_GATT_CHR_F_NOTIFY,
}, {
0, /* No more characteristics in this service. */
} },
},
+
{
0, /* No more services. */
},
};
-
```
You should recognize the first services from the [BLE Peripheral](bleprph/bleprph-intro.md)
@@ -320,16 +717,15 @@ gatt_svr_sns_access(uint16_t conn_handle, uint16_t attr_handle,
uint16_t uuid16;
int rc;
- uuid16 = ble_uuid_128_to_16(ctxt->chr->uuid128);
- assert(uuid16 != 0);
+ uuid16 = ble_uuid_u16(ctxt->chr->uuid);
switch (uuid16) {
case ADC_SNS_TYPE:
assert(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
rc = os_mbuf_append(ctxt->om, ADC_SNS_STRING, sizeof ADC_SNS_STRING);
- BLEADC_LOG(INFO, "ADC SENSOR TYPE READ: %s\n", ADC_SNS_STRING);
+ BLEPRPH_LOG(INFO, "ADC SENSOR TYPE READ: %s\n", ADC_SNS_STRING);
return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
-
+
case ADC_SNS_VAL:
if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
rc = gatt_svr_chr_write(ctxt->om, 0,
@@ -342,169 +738,32 @@ gatt_svr_sns_access(uint16_t conn_handle, uint16_t attr_handle,
sizeof gatt_adc_val);
return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
}
+
default:
assert(0);
return BLE_ATT_ERR_UNLIKELY;
- }
+ }
}
+
```
-You can see that when the `ADC_SNS_TYPE` is read, we return the
-Sensor Type we defined earlier. If the `ADC_SNS_VAL` we'll return the
+You can see that when request is for the `ADC_SNS_TYPE`, we return the
+Sensor Type we defined earlier. If the request if for `ADC_SNS_VAL` we'll return the
`gatt_adc_val` value.
If you build, load and run this application now, you will see all those Services and Characteristics
advertised, and you will even be able to read the "Sensor Type" String via the ADC_SNS_TYPE
-Characteristic, but when you subscribe to the ADC_SNS_VALUE Characteristic, you
-aren't getting any data. That's because we haven't set up the ADC Sensor yet, or
-created a task to update the value.
-
-<br>
-
-### Creating the ADC Task
-
-In order for the application to send new sensor readings to a connected device, we'll need
-to create a new OS Task to gather values and update them. If you've worked through the
-[Add tasks](task_lesson.md) tutorial, this should look familiar to you at this point.
-
-First, in `main.c` we'll define all the ADC-related things we'll need:
-
-```c
-/* ADC */
-#include "nrf.h"
-#include "app_util_platform.h"
-#include "app_error.h"
-#include <adc/adc.h>
-#include <adc_nrf52/adc_nrf52.h>
-#include <adc_nrf52/adc_nrf52.h>
-#include "nrf_drv_saadc.h"
-
-nrf_drv_saadc_config_t adc_config = NRF_DRV_SAADC_DEFAULT_CONFIG;
-```
-
-Next we need to add the task-related requirements:
-
-```c
-/* ADC Task settings */
-#define ADC_TASK_PRIO 5
-#define ADC_STACK_SIZE (OS_STACK_ALIGN(336))
-struct os_task adc_task;
-bssnz_t os_stack_t adc_stack[ADC_STACK_SIZE];
-```
-
-We'll also need to define a task handler for that task:
-
-```c
-/**
- * Event loop for the ADC task.
- */
-static void
-adc_task_handler(void *unused)
-{
-
- gatt_adc_val = 0;
- int rc = 0;
-
- while (1) {
- gatt_adc_val++;
- uint16_t chr_val_handle;
-
- rc = ble_gatts_find_chr(gatt_svr_svc_sns_uuid,
- BLE_UUID16(ADC_SNS_VAL),
- NULL, &chr_val_handle);
- assert(rc == 0);
-
- ble_gatts_chr_updated(chr_val_handle);
-
- /* Wait 2 second */
- os_time_delay(OS_TICKS_PER_SEC*2);
-
- }
-}
-```
-
-At this point you'll notice that we are just incrementing a value, not sending any actual
-sensor data. Be patient, we'll get there. We're initializiing our 'sensor' data
-variable, `gatt_adc_val` and then heading into our task-loop.
-
-Once in the task loop, we use `ble_gatts_find_chr()` to get the handle for the
-characteristic we're updating. and then we let that characteristic know that
-we've updated it's value by calling ` ble_gatts_chr_updated()` with the
-handle for the characteristic.
-
-Finally we set the update frequency of the characteristic's data via a call to
-`os_time_delay()` though there are other meachanisms for doing this.
-
-Now that we have this all done, you can actually run this app and see the
-'sensor' value increase when you're subscribed to it.
+Characteristic.
<br>
-### Implementing an Analog to Digital Converter (ADC)
-
-So far we have a functioning BLE Peripheral device that will update a counter
-and send that counter's value to any connected device that asks for it. It's
-a lot, but it's still a far cry from useful. What we realy need is to add a
-real sensor! The sensor we're using, the eTape Liquid Level Sensor, is a
-pretty basic Analog Sensor. As the fluid level changes, the voltage output
-of the sensor changes. In order to read this value, we'll need to access
-the ADC on the nrf52dk, and that's going to take a bit of work.
-
-If we look at the configuration for the project by running `newt target config nrf52_adc`
-you'll see the configuration of the ADC:
-
-```no-highlight
-* PACKAGE: hw/bsp/nrf52dk
- * Setting: ADC_0
- * Description: TBD
- * Value: 1
- * Setting: ADC_0_INTERRUPT_PRIORITY
- * Description: TBD
- * Value: SAADC_CONFIG_IRQ_PRIORITY
- * Setting: ADC_0_OVERSAMPLE
- * Description: TBD
- * Value: SAADC_CONFIG_OVERSAMPLE
- * Setting: ADC_0_RESOLUTION
- * Description: TBD
- * Value: SAADC_CONFIG_RESOLUTION
- * Setting: BSP_NRF52
- * Description: TBD
- * Value: 1
-```
-
-Next we can look in `hw/bsp/nrf52dk/src/hal_bsp.c`
-and make sure the proper device-creation takes place:
-
-```c
-#if MYNEWT_VAL(ADC_0)
-static struct adc_dev os_bsp_adc0;
-static nrf_drv_saadc_config_t os_bsp_adc0_config = {
- .resolution = MYNEWT_VAL(ADC_0_RESOLUTION),
- .oversample = MYNEWT_VAL(ADC_0_OVERSAMPLE),
- .interrupt_priority = MYNEWT_VAL(ADC_0_INTERRUPT_PRIORITY),
-};
-#endif
-```
-
-And also make sure that it gets properly initialized in the
-`hal_bsp_init()` function:
-
-```
-#if MYNEWT_VAL(ADC_0)
- rc = os_dev_create((struct os_dev *) &os_bsp_adc0, "adc0",
- OS_DEV_INIT_KERNEL, OS_DEV_INIT_PRIO_DEFAULT,
- nrf52_adc_dev_init, &os_bsp_adc0_config);
- assert(rc == 0);
-#endif
-```
-
### Adding the eTape Water Sensor
Now that we have a fully functioning BLE App that we can subscribe to sensor
-values from, it's time to turn that incrementing-counter into an actual sensor value!
+values from, it's time to actually wire up the sensor!
-As previous;y mentioned, we're going to be using an eTape Water Level Sensor. You can
+As previously mentioned, we're going to be using an eTape Water Level Sensor. You can
get one from [Adafruit](https://www.adafruit.com/products/1786).
We're going to use the sensor as a resistive sensor, and the setup is very simple.
@@ -512,135 +771,31 @@ I'll be using a 'breadboard` to put this all together for illustrative purposes.
First, attach a jumper-wire from Vdd on the board to the breadboard.
Next, attach a jumper wire from pin P0.03 on the board to the breadboard. This will be
our ADC-in. The sensor should have come with a 560 ohm resistor, so plug that
-into the baord between Vdd and ADC-in holes. Finally, attach a jumper from
+into the board between Vdd and ADC-in holes. Finally, attach a jumper from
GND on the board to your breadboard. At this point, your breadboard should look
like this:
-Now attach one of the middle 2 leads from the sensor to ground on the breadboad and
+Now attach one of the middle 2 leads from the sensor to ground on the breadboard and
the other middle lead to the ADC-in on the breadboard. Your breadboard should now look
like this:
-And yhour eTape Sensor should look like this (at least if you have it mounted in a
+And your eTape Sensor should look like this (at least if you have it mounted in a
graduated cylinder as I do).
That concludes the hardware portion. Easy!
-<br>
-
-### Reading the eTape Water Sensor Values
-
-This is the meat of the application. We've got our BLE application broadcasting and we can connect
-to it and get notified when sensor values change. And we've got our sensor all wired
-up correctly. So let's now make sure the correct values get sent.
-
-First we'll make some changes to the `adc_task_handler()` function to properly initialize
-the ADC.
-
-```c
- struct adc_dev *adc;
- nrf_saadc_channel_config_t cc =
- NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1);
- cc.gain = NRF_SAADC_GAIN1_6;
- cc.reference = NRF_SAADC_REFERENCE_INTERNAL;
- adc = (struct adc_dev *) os_dev_open("adc0", 0, &adc_config);
- assert(adc != NULL);
-
- adc_chan_config(adc, 0, &cc);
-
- sample_buffer1 = malloc(adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
- sample_buffer2 = malloc(adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
- memset(sample_buffer1, 0, adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
- memset(sample_buffer2, 0, adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
-
- adc_buf_set(adc, sample_buffer1, sample_buffer2,
- adc_buf_size(adc, ADC_NUMBER_CHANNELS, ADC_NUMBER_SAMPLES));
- adc_event_handler_set(adc, adc_read_event, (void *) NULL);
-```
-
-A few things need to be said about this part, as it is the most confusing. First,
-we're using a **default** configuration for the ADC Channel via the `NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE`
-macro. The important part here is that we're actually using `AIN1`. I know what you're thinking, "But
-we want ADC-0!" and that's true. The board is actually labelled 'A0, A1, A2' etc., and the actual pin
-numbers are also listed on the board, which seems handy. At first. But it gets messy very
-quickly.
-
-If you try to use AIN0, and then go poke around in the registers while this is running,
-
-```
-(gdb) p/x {NRF_SAADC_Type}0x40007000
-...
- CH = {{
- PSELP = 0x1,
- PSELN = 0x0,
- CONFIG = 0x20000,
- LIMIT = 0x7fff8000
- },
-```
-
-You'll see that the pin for channel 0 is set to 1, which corresponts to AIN0, but that's **NOT**
-the same as A0 -- pin P0.03, the one we're using. For that, you use AIN1, which would set the
-pin value to 2. Messy.
-
-
-The only other thing to note here is that we're using the internal reference voltage, rather than
-setting our own. There's nothing wrong with that, but since we are, we'll have to crank up
-the gain a bit by using `NRF_SAADC_GAIN1_6`.
-
-So, since that's all clear, our task-loop in the `adc_task_handler()` function is extremely simple:
-
-```c
-while (1) {
- adc_sample(adc);
- /* Wait 2 second */
- os_time_delay(OS_TICKS_PER_SEC * 2);
-}
-```
-
-We'll just sample the ADC every 2 seconds or so.
-
-If you noticed above the call to `adc_event_handler_set()` then you'll also know that we'd
-better define that callback function we set `adc_read_event()`
-
-```c
-int
-adc_read_event(struct adc_dev *dev, void *arg, uint8_t etype,
- void *buffer, int buffer_len)
-{
- int i;
- int adc_result;
- uint16_t chr_val_handle;
- int rc;
- for (i = 0; i < ADC_NUMBER_SAMPLES; i++) {
- rc = adc_buf_read(dev, buffer, buffer_len, i, &adc_result);
- if (rc != 0) {
- goto err;
- }
-
- gatt_adc_val = adc_result_mv(dev, 0, adc_result);
- rc = ble_gatts_find_chr(gatt_svr_svc_sns_uuid, BLE_UUID16(ADC_SNS_VAL), NULL, &chr_val_handle);
- assert(rc == 0);
- ble_gatts_chr_updated(chr_val_handle);
- }
-
- adc_buf_release(dev, buffer, buffer_len);
- return (0);
-err:
- return (rc);
-}
-```
-
-Whenever the ADC has a sample for us in its buffer, we'll run through the samples available, convert them
-to millivolts, and then update the NOTIFY value so that any connected devices get the updated
-sensor values.
+At this point you should be able to build, create-image and load your application and see it properly
+sending readings.
<br>
+
### Conclusion
Congratulations, you've now completed both a hardware project and a software project by connecting a
@@ -652,6 +807,21 @@ appropriate mailing lists on our [Community Page](../../community.md).
Keep on hacking and sensing!
+<br>
+
+### Note
+
+If you're wondering how to actually view these sensor readings via Bluetooth, you have a couple of
+options. On Mac OS or iOS you can download the [LightBlue app](https://itunes.apple.com/us/app/lightblue-explorer-bluetooth/id557428110?mt=8).
+This app lets you connect to, and interrogate, BLE devices like the one you just built.
+
+If you used the BLE Service and Characteristic UUIDs used in this tutorial, you can also download
+and use a Mac OS [MyNewt Sensor Reader App](https://dragonflyiot.com/MyNewtSensorReader.zip) (Zip Archive) that allows
+you to graph your data, etc. An iOS version is in Beta testing and should be available soon.
+
+
+
+Enjoy!