You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by an...@apache.org on 2019/06/12 02:46:19 UTC
[mynewt-nimble] branch master updated (4fd4644 -> d3b7373)
This is an automated email from the ASF dual-hosted git repository.
andk pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git.
from 4fd4644 nimble/mesh: Reset the SAR timer also on SAR_CONT
new 149af0a apps/btshell: Add time parsing function
new d3b7373 apps/btshell: Use nice time conversions where possible
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
apps/btshell/src/cmd.c | 122 ++++++++++++++++++++++++-----------------------
apps/btshell/src/cmd.h | 1 +
apps/btshell/src/parse.c | 85 +++++++++++++++++++++++++++++++++
3 files changed, 148 insertions(+), 60 deletions(-)
[mynewt-nimble] 01/02: apps/btshell: Add time parsing function
Posted by an...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit 149af0a9c146c037fa05ccadaba5b1f18b424bb4
Author: Andrzej Kaczmarek <an...@codecoup.pl>
AuthorDate: Tue Jun 11 11:31:03 2019 +0200
apps/btshell: Add time parsing function
New API allows to parse time strings which allow to specify values like
intervals, periods, timeouts etc. in an easy way instead of using units
which are always "I do not remember, need to check spec and calculate".
Time string is converted to microseconds and returned value is divided
by step value so it can be directly passed to various APIs.
Accepted time string format is "XXX.YYYuuu" where:
- XXX is integral part of value
- YYY is fractional part of value
- uuu is one of time units: "us", "ms" or "s"
XXX and YYY (and also separating ".") can be skipped and will be thus
set to 0.
An error is returned if format is invalid (in particular, if uuu is not
present) so this allows to fall back to standard integer conversion if
necessary.
---
apps/btshell/src/cmd.h | 1 +
apps/btshell/src/parse.c | 85 ++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 86 insertions(+)
diff --git a/apps/btshell/src/cmd.h b/apps/btshell/src/cmd.h
index a3620c0..a3b6feb 100644
--- a/apps/btshell/src/cmd.h
+++ b/apps/btshell/src/cmd.h
@@ -28,6 +28,7 @@ struct kv_pair {
int val;
};
+uint32_t parse_arg_time_dflt(char *name, int step, uint32_t dflt, int *out_status);
const struct kv_pair *parse_kv_find(const struct kv_pair *kvs, char *name);
int parse_arg_find_idx(const char *key);
char *parse_arg_extract(const char *key);
diff --git a/apps/btshell/src/parse.c b/apps/btshell/src/parse.c
index 66db9d7..37e065c 100644
--- a/apps/btshell/src/parse.c
+++ b/apps/btshell/src/parse.c
@@ -23,6 +23,7 @@
#include <stdarg.h>
#include <errno.h>
#include <assert.h>
+#include <ctype.h>
#include "console/console.h"
#include "host/ble_hs.h"
#include "host/ble_uuid.h"
@@ -278,6 +279,90 @@ parse_arg_uint32_dflt(char *name, uint32_t dflt, int *out_status)
return val;
}
+static uint32_t
+parse_time_unit_mult(const char *str)
+{
+ if (!strcasecmp(str, "us")) {
+ return 1;
+ } else if (!strcasecmp(str, "ms")) {
+ return 1000;
+ } else if (!strcasecmp(str, "s")) {
+ return 1000000;
+ }
+
+ return 0;
+}
+
+static uint32_t
+parse_time_us(const char *str, int *out_status)
+{
+ uint32_t val = 0;
+ uint32_t val_div = 1;
+ uint32_t val_mult = 1;
+ uint32_t val_us;
+
+ while (isdigit(*str)) {
+ val *= 10;
+ val += *str - '0';
+ str++;
+ }
+
+ if (*str == '.') {
+ str++;
+ while (isdigit(*str)) {
+ val *= 10;
+ val += *str - '0';
+ val_div *= 10;
+ str++;
+ }
+ }
+
+ val_mult = parse_time_unit_mult(str);
+ if (val_mult == 0) {
+ *out_status = EINVAL;
+ return 0;
+ }
+
+ if (val_mult > val_div) {
+ val_us = val * (val_mult / val_div);
+ } else {
+ val_us = val * (val_div / val_mult);
+ }
+
+ *out_status = 0;
+
+ return val_us;
+}
+
+uint32_t
+parse_arg_time_dflt(char *name, int step_us, uint32_t dflt, int *out_status)
+{
+ const char *arg;
+ uint32_t val;
+ int rc;
+
+ arg = parse_arg_peek(name);
+ if (!arg) {
+ *out_status = 0;
+ return dflt;
+ }
+
+ val = parse_time_us(arg, &rc);
+ if (rc) {
+ val = parse_arg_uint32(name, &rc);
+ if (rc == ENOENT) {
+ *out_status = 0;
+ return dflt;
+ }
+ } else {
+ val /= step_us;
+ parse_arg_extract(name);
+ }
+
+ *out_status = rc;
+ return val;
+}
+
const struct kv_pair *
parse_kv_find(const struct kv_pair *kvs, char *name)
{
[mynewt-nimble] 02/02: apps/btshell: Use nice time conversions
where possible
Posted by an...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit d3b7373a4ec7a4bbf6e1c5b5bf6d3d53a80e3112
Author: Andrzej Kaczmarek <an...@codecoup.pl>
AuthorDate: Tue Jun 11 11:38:41 2019 +0200
apps/btshell: Use nice time conversions where possible
---
apps/btshell/src/cmd.c | 122 +++++++++++++++++++++++++------------------------
1 file changed, 62 insertions(+), 60 deletions(-)
diff --git a/apps/btshell/src/cmd.c b/apps/btshell/src/cmd.c
index de27151..0702544 100644
--- a/apps/btshell/src/cmd.c
+++ b/apps/btshell/src/cmd.c
@@ -238,13 +238,13 @@ cmd_advertise_configure(int argc, char **argv)
return rc;
}
- params.itvl_min = parse_arg_uint32_dflt("interval_min", 0, &rc);
+ params.itvl_min = parse_arg_time_dflt("interval_min", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'interval_min' parameter\n");
return rc;
}
- params.itvl_max = parse_arg_uint32_dflt("interval_max", 0, &rc);
+ params.itvl_max = parse_arg_time_dflt("interval_max", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'interval_max' parameter\n");
return rc;
@@ -624,13 +624,13 @@ cmd_advertise(int argc, char **argv)
return rc;
}
- params.itvl_min = parse_arg_uint16_dflt("interval_min", 0, &rc);
+ params.itvl_min = parse_arg_time_dflt("interval_min", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'interval_min' parameter\n");
return rc;
}
- params.itvl_max = parse_arg_uint16_dflt("interval_max", 0, &rc);
+ params.itvl_max = parse_arg_time_dflt("interval_max", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'interval_max' parameter\n");
return rc;
@@ -766,19 +766,19 @@ cmd_connect(int argc, char **argv)
return rc;
}
- phy_1M_params.scan_itvl = parse_arg_uint16_dflt("scan_interval", 0x0010, &rc);
+ phy_1M_params.scan_itvl = parse_arg_time_dflt("scan_interval", 625, 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'scan_interval' parameter\n");
return rc;
}
- phy_1M_params.scan_window = parse_arg_uint16_dflt("scan_window", 0x0010, &rc);
+ phy_1M_params.scan_window = parse_arg_time_dflt("scan_window", 625, 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'scan_window' parameter\n");
return rc;
}
- phy_1M_params.itvl_min = parse_arg_uint16_dflt("interval_min",
+ phy_1M_params.itvl_min = parse_arg_time_dflt("interval_min", 1250,
BLE_GAP_INITIAL_CONN_ITVL_MIN,
&rc);
if (rc != 0) {
@@ -786,7 +786,7 @@ cmd_connect(int argc, char **argv)
return rc;
}
- phy_1M_params.itvl_max = parse_arg_uint16_dflt("interval_max",
+ phy_1M_params.itvl_max = parse_arg_time_dflt("interval_max", 1250,
BLE_GAP_INITIAL_CONN_ITVL_MAX,
&rc);
if (rc != 0) {
@@ -800,21 +800,22 @@ cmd_connect(int argc, char **argv)
return rc;
}
- phy_1M_params.supervision_timeout = parse_arg_uint16_dflt("timeout", 0x0100, &rc);
+ phy_1M_params.supervision_timeout = parse_arg_time_dflt("timeout", 10000,
+ 0x0100, &rc);
if (rc != 0) {
console_printf("invalid 'timeout' parameter\n");
return rc;
}
- phy_1M_params.min_ce_len = parse_arg_uint16_dflt("min_conn_event_len",
- 0x0010, &rc);
+ phy_1M_params.min_ce_len = parse_arg_time_dflt("min_conn_event_len", 625,
+ 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'min_conn_event_len' parameter\n");
return rc;
}
- phy_1M_params.max_ce_len = parse_arg_uint16_dflt("max_conn_event_len",
- 0x0300, &rc);
+ phy_1M_params.max_ce_len = parse_arg_time_dflt("max_conn_event_len", 625,
+ 0x0300, &rc);
if (rc != 0) {
console_printf("invalid 'max_conn_event_len' parameter\n");
return rc;
@@ -840,31 +841,31 @@ cmd_connect(int argc, char **argv)
}
/* Get coded params */
- phy_coded_params.scan_itvl = parse_arg_uint16_dflt("coded_scan_interval",
- 0x0010, &rc);
+ phy_coded_params.scan_itvl = parse_arg_time_dflt("coded_scan_interval",
+ 625, 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'coded_scan_interval' parameter\n");
return rc;
}
- phy_coded_params.scan_window = parse_arg_uint16_dflt("coded_scan_window",
- 0x0010, &rc);
+ phy_coded_params.scan_window = parse_arg_time_dflt("coded_scan_window",
+ 625, 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'coded_scan_window' parameter\n");
return rc;
}
- phy_coded_params.itvl_min = parse_arg_uint16_dflt("coded_interval_min",
- BLE_GAP_INITIAL_CONN_ITVL_MIN,
- &rc);
+ phy_coded_params.itvl_min = parse_arg_time_dflt("coded_interval_min", 1250,
+ BLE_GAP_INITIAL_CONN_ITVL_MIN,
+ &rc);
if (rc != 0) {
console_printf("invalid 'coded_interval_min' parameter\n");
return rc;
}
- phy_coded_params.itvl_max = parse_arg_uint16_dflt("coded_interval_max",
- BLE_GAP_INITIAL_CONN_ITVL_MAX,
- &rc);
+ phy_coded_params.itvl_max = parse_arg_time_dflt("coded_interval_max", 1250,
+ BLE_GAP_INITIAL_CONN_ITVL_MAX,
+ &rc);
if (rc != 0) {
console_printf("invalid 'coded_interval_max' parameter\n");
return rc;
@@ -878,7 +879,7 @@ cmd_connect(int argc, char **argv)
}
phy_coded_params.supervision_timeout =
- parse_arg_uint16_dflt("coded_timeout", 0x0100, &rc);
+ parse_arg_time_dflt("coded_timeout", 10000, 0x0100, &rc);
if (rc != 0) {
console_printf("invalid 'coded_timeout' parameter\n");
@@ -886,30 +887,30 @@ cmd_connect(int argc, char **argv)
}
phy_coded_params.min_ce_len =
- parse_arg_uint16_dflt("coded_min_conn_event", 0x0010, &rc);
+ parse_arg_time_dflt("coded_min_conn_event", 625, 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'coded_min_conn_event' parameter\n");
return rc;
}
- phy_coded_params.max_ce_len = parse_arg_uint16_dflt("coded_max_conn_event",
- 0x0300, &rc);
+ phy_coded_params.max_ce_len = parse_arg_time_dflt("coded_max_conn_event",
+ 625, 0x0300, &rc);
if (rc != 0) {
console_printf("invalid 'coded_max_conn_event' parameter\n");
return rc;
}
/* Get 2M params */
- phy_2M_params.itvl_min = parse_arg_uint16_dflt("2M_interval_min",
- BLE_GAP_INITIAL_CONN_ITVL_MIN,
- &rc);
+ phy_2M_params.itvl_min = parse_arg_time_dflt("2M_interval_min", 1250,
+ BLE_GAP_INITIAL_CONN_ITVL_MIN,
+ &rc);
if (rc != 0) {
console_printf("invalid '2M_interval_min' parameter\n");
return rc;
}
- phy_2M_params.itvl_max = parse_arg_uint16_dflt("2M_interval_max",
- BLE_GAP_INITIAL_CONN_ITVL_MAX, &rc);
+ phy_2M_params.itvl_max = parse_arg_time_dflt("2M_interval_max", 1250,
+ BLE_GAP_INITIAL_CONN_ITVL_MAX, &rc);
if (rc != 0) {
console_printf("invalid '2M_interval_max' parameter\n");
return rc;
@@ -922,23 +923,23 @@ cmd_connect(int argc, char **argv)
return rc;
}
- phy_2M_params.supervision_timeout = parse_arg_uint16_dflt("2M_timeout",
- 0x0100, &rc);
+ phy_2M_params.supervision_timeout = parse_arg_time_dflt("2M_timeout", 10000,
+ 0x0100, &rc);
if (rc != 0) {
console_printf("invalid '2M_timeout' parameter\n");
return rc;
}
- phy_2M_params.min_ce_len = parse_arg_uint16_dflt("2M_min_conn_event", 0x0010,
- &rc);
+ phy_2M_params.min_ce_len = parse_arg_time_dflt("2M_min_conn_event", 625,
+ 0x0010, &rc);
if (rc != 0) {
console_printf("invalid '2M_min_conn_event' parameter\n");
return rc;
}
- phy_2M_params.max_ce_len = parse_arg_uint16_dflt("2M_max_conn_event",
- 0x0300, &rc);
+ phy_2M_params.max_ce_len = parse_arg_time_dflt("2M_max_conn_event", 625,
+ 0x0300, &rc);
if (rc != 0) {
console_printf("invalid '2M_max_conn_event' parameter\n");
return rc;
@@ -1211,8 +1212,7 @@ cmd_scan(int argc, char **argv)
return rc;
}
- duration_ms = parse_arg_long_bounds_dflt("duration", 1, INT32_MAX,
- BLE_HS_FOREVER, &rc);
+ duration_ms = parse_arg_time_dflt("duration", 10000, BLE_HS_FOREVER, &rc);
if (rc != 0) {
console_printf("invalid 'duration' parameter\n");
return rc;
@@ -1230,13 +1230,13 @@ cmd_scan(int argc, char **argv)
return rc;
}
- params.itvl = parse_arg_uint16_dflt("interval", 0, &rc);
+ params.itvl = parse_arg_time_dflt("interval", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'interval' parameter\n");
return rc;
}
- params.window = parse_arg_uint16_dflt("window", 0, &rc);
+ params.window = parse_arg_time_dflt("window", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'window' parameter\n");
return rc;
@@ -1277,25 +1277,25 @@ cmd_scan(int argc, char **argv)
uncoded.itvl = params.itvl;
uncoded.window = params.window;
- duration = parse_arg_uint16_dflt("extended_duration", 0, &rc);
+ duration = parse_arg_time_dflt("extended_duration", 10000, 0, &rc);
if (rc != 0) {
console_printf("invalid 'extended_duration' parameter\n");
return rc;
}
- period = parse_arg_uint16_dflt("extended_period", 0, &rc);
+ period = parse_arg_time_dflt("extended_period", 1280000, 0, &rc);
if (rc != 0) {
console_printf("invalid 'extended_period' parameter\n");
return rc;
}
- coded.itvl = parse_arg_uint16_dflt("longrange_interval", 0, &rc);
+ coded.itvl = parse_arg_time_dflt("longrange_interval", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'longrange_interval' parameter\n");
return rc;
}
- coded.window = parse_arg_uint16_dflt("longrange_window", 0, &rc);
+ coded.window = parse_arg_time_dflt("longrange_window", 625, 0, &rc);
if (rc != 0) {
console_printf("invalid 'longrange_window' parameter\n");
return rc;
@@ -2109,17 +2109,17 @@ cmd_conn_update_params(int argc, char **argv)
return rc;
}
- params.itvl_min = parse_arg_uint16_dflt("interval_min",
- BLE_GAP_INITIAL_CONN_ITVL_MIN,
- &rc);
+ params.itvl_min = parse_arg_time_dflt("interval_min", 1250,
+ BLE_GAP_INITIAL_CONN_ITVL_MIN,
+ &rc);
if (rc != 0) {
console_printf("invalid 'interval_min' parameter\n");
return rc;
}
- params.itvl_max = parse_arg_uint16_dflt("interval_max",
- BLE_GAP_INITIAL_CONN_ITVL_MAX,
- &rc);
+ params.itvl_max = parse_arg_time_dflt("interval_max", 1250,
+ BLE_GAP_INITIAL_CONN_ITVL_MAX,
+ &rc);
if (rc != 0) {
console_printf("invalid 'interval_max' parameter\n");
return rc;
@@ -2131,21 +2131,22 @@ cmd_conn_update_params(int argc, char **argv)
return rc;
}
- params.supervision_timeout = parse_arg_uint16_dflt("timeout", 0x0100, &rc);
+ params.supervision_timeout = parse_arg_time_dflt("timeout", 10000, 0x0100,
+ &rc);
if (rc != 0) {
console_printf("invalid 'timeout' parameter\n");
return rc;
}
- params.min_ce_len = parse_arg_uint16_dflt("min_conn_event_len",
- 0x0010, &rc);
+ params.min_ce_len = parse_arg_time_dflt("min_conn_event_len", 625,
+ 0x0010, &rc);
if (rc != 0) {
console_printf("invalid 'min_conn_event_len' parameter\n");
return rc;
}
- params.max_ce_len = parse_arg_uint16_dflt("max_conn_event_len",
- 0x0300, &rc);
+ params.max_ce_len = parse_arg_time_dflt("max_conn_event_len", 625,
+ 0x0300, &rc);
if (rc != 0) {
console_printf("invalid 'max_conn_event_len' parameter\n");
return rc;
@@ -3617,13 +3618,14 @@ cmd_periodic_configure(int argc, char **argv)
return rc;
}
- params.itvl_min = parse_arg_uint32_dflt("interval_min", 0, &rc);
+ params.itvl_min = parse_arg_time_dflt("interval_min", 1250, 0, &rc);
if (rc != 0) {
console_printf("invalid 'interval_min' parameter\n");
return rc;
}
- params.itvl_max = parse_arg_uint32_dflt("interval_max", params.itvl_min, &rc);
+ params.itvl_max = parse_arg_time_dflt("interval_max", 1250, params.itvl_min,
+ &rc);
if (rc != 0) {
console_printf("invalid 'interval_max' parameter\n");
return rc;
@@ -3789,7 +3791,7 @@ cmd_sync_create(int argc, char **argv)
return rc;
}
- params.sync_timeout = parse_arg_uint16_dflt("sync_timeout", 10, &rc);
+ params.sync_timeout = parse_arg_time_dflt("sync_timeout", 10000, 10, &rc);
if (rc != 0) {
console_printf("invalid 'sync_timeout' parameter\n");
return rc;