ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #6461 from ARMmbed/release-candidate 

Release candidate for mbed-os-5.8.1
pull/6414/merge mbed-os-5.8.1
Martin Kojtal 2018-03-27 17:41:03 +02:00 committed by GitHub
parent ad284b2806 a48b62d1a6
commit addec7ba10
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
289 changed files with 24718 additions and 21735 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.github/pull_request_template.md vendored
View File

@ -11,11 +11,17 @@
<!--
Required
Please tick one of the following types
Please tick only one of the following types. Do not tick more or change the layout.
[X] Fix
[ ] Refactor
[ ] New target
[ ] Feature
[ ] Breaking change
-->
- [ ] Fix
- [ ] Refactor
- [ ] New target
- [ ] Feature
- [ ] Breaking change
[ ] Fix
[ ] Refactor
[ ] New target
[ ] Feature
[ ] Breaking change

54
.travis.yml
View File

@ -31,7 +31,7 @@ before_install:
# Setup ppa to make sure arm-none-eabi-gcc is correct version
- sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
# Loop until update succeeds (timeouts can occur)
- while [ -n "$(sudo apt-get update 2>&1 |grep Failed)" ]; do :; done
- travis_retry $(! sudo apt-get update 2>&1 |grep Failed)
after_success:
- bash -c "$STATUS" success "Local $NAME testing has passed"
@ -115,6 +115,24 @@ matrix:
- python tools/make.py -t GCC_ARM -m DISCO_F401VC --source=. --build=BUILD/DISCO_F401VC/GCC_ARM -j0
# Run local equeue tests
- make -C $EVENTS/equeue test
# Run profiling tests
- make -C $EVENTS/equeue prof | tee prof
after_success:
# update status if we succeeded, compare with master if possible
- |
CURR=$(grep -o '[0-9]\+ cycles' prof | awk '{sum += $1} END {print sum}')
PREV=$(curl https://api.github.com/repos/$TRAVIS_REPO_SLUG/status/master \
| jq -re "select(.sha != \"$TRAVIS_COMMIT\")
| .statuses[] | select(.context == \"travis-ci/$NAME\").description
| capture(\"runtime is (?<runtime>[0-9]+)\").runtime" \
|| echo 0)
STATUSM="Passed, runtime is ${CURR} cycles"
if [ "$PREV" -ne 0 ]
then
STATUSM="$STATUSM ($(python -c "print '%+d' % ($CURR-$PREV)") cycles)"
fi
- bash -c "$STATUS" success "$STATUSM"
- env:
- NAME=littlefs
@ -187,37 +205,3 @@ matrix:
STATUSM="$STATUSM ($(python -c "print '%+.2f' % (100*($CURR-$PREV)/$PREV.0)")%)"
fi
- bash -c "$STATUS" success "$STATUSM"
- &mbed-2
env: NAME=mbed2-NXP
install:
# Install dependencies
- export GCC_DIR=$HOME/gcc-arm-none-eabi-6-2017-q2-update
- export GCC_ARCHIVE=$HOME/gcc-arm-none-eabi-6-2017-q2-update-linux.tar.bz2
- export GCC_URL=https://developer.arm.com/-/media/Files/downloads/gnu-rm/6-2017q2/gcc-arm-none-eabi-6-2017-q2-update-linux.tar.bz2?revision=2cc92fb5-3e0e-402d-9197-bdfc8224d8a5?product=GNU%20Arm%20Embedded%20Toolchain,64-bit,,Linux,6-2017-q2-update
- if [ ! -e $GCC_DIR/bin/arm-none-eabi-gcc ]; then wget $GCC_URL -O $GCC_ARCHIVE; tar xfj $GCC_ARCHIVE -C $HOME; fi
- export PATH=$PATH:$GCC_DIR/bin
- pip install -r requirements.txt
# Print versions we use
- arm-none-eabi-gcc --version
- python --version
before_script:
# Create BUILD directory for tests
- mkdir BUILD
script:
# Run local mbed 2 testing
- python -u tools/build_travis.py --vendor "${NAME#mbed2-}"
- <<: *mbed-2
env: NAME=mbed2-STM
- <<: *mbed-2
env: NAME=mbed2-NORDIC
- <<: *mbed-2
env: NAME=mbed2-SILICON_LABS
- <<: *mbed-2
env: NAME=mbed2-MAXIM
- <<: *mbed-2
env: NAME=mbed2-ATMEL
- <<: *mbed-2
env: NAME=mbed2-NUVOTON
- <<: *mbed-2
env: NAME=mbed2-RENESAS

163
TESTS/mbed_drivers/lp_timeout/main.cpp
View File

@ -18,135 +18,76 @@
#error [NOT_SUPPORTED] Low power timer not supported for this target
#endif
#include "mbed.h"
#include "greentea-client/test_env.h"
#include "utest/utest.h"
#include "unity/unity.h"
#include "greentea-client/test_env.h"
#include "mbed.h"
#include "../timeout/timeout_tests.h"
using namespace utest::v1;
volatile static bool complete;
static LowPowerTimeout lpt;
/* Timeouts are quite arbitrary due to large number of boards with varying level of accuracy */
#define LONG_TIMEOUT (100000)
#define SHORT_TIMEOUT (600)
void cb_done() {
complete = true;
}
#if DEVICE_SLEEP
void lp_timeout_1s_deepsleep(void)
utest::v1::status_t greentea_failure_handler(const Case * const source, const failure_t reason)
{
complete = false;
LowPowerTimer timer;
/*
* Since deepsleep() may shut down the UART peripheral, we wait for 10ms
* to allow for hardware serial buffers to completely flush.
* This should be replaced with a better function that checks if the
* hardware buffers are empty. However, such an API does not exist now,
* so we'll use the wait_ms() function for now.
*/
wait_ms(10);
/*
* We use here the low power timer instead of microsecond timer for start and
* end because the microseconds timer might be disable during deepsleep.
*/
timer.start();
lpt.attach(&cb_done, 1);
/* Make sure deepsleep is allowed, to go to deepsleep */
bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");
sleep();
while (!complete);
/* It takes longer to wake up from deep sleep */
TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, timer.read_us());
TEST_ASSERT_TRUE(complete);
}
void lp_timeout_1s_sleep(void)
{
complete = false;
Timer timer;
timer.start();
sleep_manager_lock_deep_sleep();
lpt.attach(&cb_done, 1);
bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
TEST_ASSERT_FALSE_MESSAGE(deep_sleep_allowed, "Deep sleep should be disallowed");
sleep();
while (!complete);
sleep_manager_unlock_deep_sleep();
TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, timer.read_us());
TEST_ASSERT_TRUE(complete);
}
#endif /* DEVICE_SLEEP */
void lp_timeout_us(uint32_t delay_us, uint32_t tolerance)
{
complete = false;
Timer timer;
timer.start();
lpt.attach_us(&cb_done, delay_us);
while (!complete);
/* Using RTC which is less accurate */
TEST_ASSERT_UINT32_WITHIN(tolerance, delay_us, timer.read_us());
TEST_ASSERT_TRUE(complete);
}
void lp_timeout_5s(void)
{
lp_timeout_us(5000000, LONG_TIMEOUT);
}
void lp_timeout_1s(void)
{
lp_timeout_us(1000000, LONG_TIMEOUT);
}
void lp_timeout_1ms(void)
{
lp_timeout_us(1000, SHORT_TIMEOUT);
}
void lp_timeout_500us(void)
{
lp_timeout_us(500, SHORT_TIMEOUT);
}
utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
greentea_case_failure_abort_handler(source, reason);
return STATUS_CONTINUE;
}
Case cases[] = {
Case("500us LowPowerTimeout", lp_timeout_500us, greentea_failure_handler),
Case("1ms LowPowerTimeout", lp_timeout_1ms, greentea_failure_handler),
Case("1sec LowPowerTimeout", lp_timeout_1s, greentea_failure_handler),
Case("5sec LowPowerTimeout", lp_timeout_5s, greentea_failure_handler),
Case("Callback called once (attach)", test_single_call<AttachTester<LowPowerTimeout> >),
Case("Callback called once (attach_us)", test_single_call<AttachUSTester<LowPowerTimeout> >),
Case("Callback not called when cancelled (attach)", test_cancel<AttachTester<LowPowerTimeout> >),
Case("Callback not called when cancelled (attach_us)", test_cancel<AttachUSTester<LowPowerTimeout> >),
Case("Callback override (attach)", test_override<AttachTester<LowPowerTimeout> >),
Case("Callback override (attach_us)", test_override<AttachUSTester<LowPowerTimeout> >),
Case("Multiple timeouts running in parallel (attach)", test_multiple<AttachTester<LowPowerTimeout> >),
Case("Multiple timeouts running in parallel (attach_us)", test_multiple<AttachUSTester<LowPowerTimeout> >),
Case("Zero delay (attach)", test_no_wait<AttachTester<LowPowerTimeout> >),
Case("Zero delay (attach_us)", test_no_wait<AttachUSTester<LowPowerTimeout> >),
Case("10 ms delay accuracy (attach)", test_delay_accuracy<AttachTester<LowPowerTimeout>, 10000, SHORT_DELTA_US>,
greentea_failure_handler),
Case("10 ms delay accuracy (attach_us)", test_delay_accuracy<AttachUSTester<LowPowerTimeout>, 10000, SHORT_DELTA_US>,
greentea_failure_handler),
Case("1 s delay accuracy (attach)", test_delay_accuracy<AttachTester<LowPowerTimeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("1 s delay accuracy (attach_us)", test_delay_accuracy<AttachUSTester<LowPowerTimeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("5 s delay accuracy (attach)", test_delay_accuracy<AttachTester<LowPowerTimeout>, 5000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("5 s delay accuracy (attach_us)", test_delay_accuracy<AttachUSTester<LowPowerTimeout>, 5000000, LONG_DELTA_US>,
greentea_failure_handler),
#if DEVICE_SLEEP
Case("1sec LowPowerTimeout from sleep", lp_timeout_1s_sleep, greentea_failure_handler),
Case("1sec LowPowerTimeout from deepsleep", lp_timeout_1s_deepsleep, greentea_failure_handler),
#endif /* DEVICE_SLEEP */
Case("1 s delay during sleep (attach)", test_sleep<AttachTester<LowPowerTimeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("1 s delay during sleep (attach_us)", test_sleep<AttachUSTester<LowPowerTimeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("1 s delay during deepsleep (attach)", test_deepsleep<AttachTester<LowPowerTimeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("1 s delay during deepsleep (attach_us)", test_deepsleep<AttachUSTester<LowPowerTimeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
#endif
Case("Timing drift (attach)", test_drift<AttachTester<LowPowerTimeout> >),
Case("Timing drift (attach_us)", test_drift<AttachUSTester<LowPowerTimeout> >),
};
utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {
GREENTEA_SETUP(20, "default_auto");
utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(240, "timing_drift_auto");
return greentea_test_setup_handler(number_of_cases);
}
Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
int main() {
int main()
{
Harness::run(specification);
}

106
TESTS/mbed_drivers/timeout/main.cpp
View File

@ -1,91 +1,83 @@
/*
* Copyright (c) 2013-2016, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
/* mbed Microcontroller Library
* Copyright (c) 2017 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* Licensed 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.
* 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.
*/
/*
* Tests is to measure the accuracy of Timeout over a period of time
*
*
* 1) DUT would start to update callback_trigger_count every milli sec
* 2) Host would query what is current count base_time, Device responds by the callback_trigger_count
* 3) Host after waiting for measurement stretch. It will query for device time again final_time.
* 4) Host computes the drift considering base_time, final_time, transport delay and measurement stretch
* 5) Finally host send the results back to device pass/fail based on tolerance.
* 6) More details on tests can be found in timing_drift_auto.py
*
*/
#include "mbed.h"
#include "greentea-client/test_env.h"
#include "utest/utest.h"
#include "unity/unity.h"
#include "timeout_tests.h"
using namespace utest::v1;
#define PERIOD_US 10000
volatile int ticker_count = 0;
volatile uint32_t callback_trigger_count = 0;
static const int test_timeout = 240;
Timeout timeout;
void set_incremeant_count() {
timeout.attach_us(set_incremeant_count, PERIOD_US);
++callback_trigger_count;
utest::v1::status_t greentea_failure_handler(const Case * const source, const failure_t reason)
{
greentea_case_failure_abort_handler(source, reason);
return STATUS_CONTINUE;
}
void test_case_timeout() {
Case cases[] = {
Case("Callback called once (attach)", test_single_call<AttachTester<Timeout> >),
Case("Callback called once (attach_us)", test_single_call<AttachUSTester<Timeout> >),
char _key[11] = { };
char _value[128] = { };
int expected_key = 1;
uint8_t results_size = 0;
Case("Callback not called when cancelled (attach)", test_cancel<AttachTester<Timeout> >),
Case("Callback not called when cancelled (attach_us)", test_cancel<AttachUSTester<Timeout> >),
greentea_send_kv("timing_drift_check_start", 0);
timeout.attach_us(set_incremeant_count, PERIOD_US);
Case("Callback override (attach)", test_override<AttachTester<Timeout> >),
Case("Callback override (attach_us)", test_override<AttachUSTester<Timeout> >),
// wait for 1st signal from host
do {
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
expected_key = strcmp(_key, "base_time");
} while (expected_key);
Case("Multiple timeouts running in parallel (attach)", test_multiple<AttachTester<Timeout> >),
Case("Multiple timeouts running in parallel (attach_us)", test_multiple<AttachUSTester<Timeout> >),
greentea_send_kv(_key, callback_trigger_count * PERIOD_US);
Case("Zero delay (attach)", test_no_wait<AttachTester<Timeout> >),
Case("Zero delay (attach_us)", test_no_wait<AttachUSTester<Timeout> >),
// wait for 2nd signal from host
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
greentea_send_kv(_key, callback_trigger_count * PERIOD_US);
Case("10 ms delay accuracy (attach)", test_delay_accuracy<AttachTester<Timeout>, 10000, SHORT_DELTA_US>,
greentea_failure_handler),
Case("10 ms delay accuracy (attach_us)", test_delay_accuracy<AttachUSTester<Timeout>, 10000, SHORT_DELTA_US>,
greentea_failure_handler),
//get the results from host
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
Case("1 s delay accuracy (attach)", test_delay_accuracy<AttachTester<Timeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("1 s delay accuracy (attach_us)", test_delay_accuracy<AttachUSTester<Timeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
TEST_ASSERT_EQUAL_STRING_MESSAGE("pass", _key,"Host side script reported a fail...");
}
Case("5 s delay accuracy (attach)", test_delay_accuracy<AttachTester<Timeout>, 5000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("5 s delay accuracy (attach_us)", test_delay_accuracy<AttachUSTester<Timeout>, 5000000, LONG_DELTA_US>,
greentea_failure_handler),
// Test casess
Case cases[] = { Case("Timers: toggle on/off", test_case_timeout), };
#if DEVICE_SLEEP
Case("1 s delay during sleep (attach)", test_sleep<AttachTester<Timeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
Case("1 s delay during sleep (attach_us)", test_sleep<AttachUSTester<Timeout>, 1000000, LONG_DELTA_US>,
greentea_failure_handler),
#endif
utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {
GREENTEA_SETUP(test_timeout, "timing_drift_auto");
Case("Timing drift (attach)", test_drift<AttachTester<Timeout> >),
Case("Timing drift (attach_us)", test_drift<AttachUSTester<Timeout> >),
};
utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(240, "timing_drift_auto");
return greentea_test_setup_handler(number_of_cases);
}
Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
int main() {
int main()
{
Harness::run(specification);
}

415
TESTS/mbed_drivers/timeout/timeout_tests.h Normal file
View File

@ -0,0 +1,415 @@
/* mbed Microcontroller Library
* Copyright (c) 2017 ARM Limited
*
* Licensed 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.
*/
#ifndef MBED_TIMEOUT_TESTS_H
#define MBED_TIMEOUT_TESTS_H
#include "mbed.h"
#include "unity/unity.h"
#define NUM_TIMEOUTS 16
#define DRIFT_TEST_PERIOD_US 10000
const float TEST_DELAY_S = 0.01;
const uint32_t TEST_DELAY_MS = 1000.0F * TEST_DELAY_S;
const us_timestamp_t TEST_DELAY_US = 1000000.0F * TEST_DELAY_S;
/* Timeouts are quite arbitrary due to large number of boards with varying level of accuracy */
#define LONG_DELTA_US (100000)
#define SHORT_DELTA_US (2000)
void sem_callback(Semaphore *sem)
{
sem->release();
}
void cnt_callback(volatile uint32_t *cnt)
{
(*cnt)++;
}
template<typename TimeoutType>
class AttachTester: public TimeoutType {
public:
void attach_callback(Callback<void()> func, us_timestamp_t delay_us)
{
TimeoutType::attach(func, (float) delay_us / 1000000.0f);
}
};
template<typename TimeoutType>
class AttachUSTester: public TimeoutType {
public:
void attach_callback(Callback<void()> func, us_timestamp_t delay_us)
{
TimeoutType::attach_us(func, delay_us);
}
};
/** Template for tests: callback called once
*
* Test callback called once
* Given a Timeout object with a callback attached with @a attach()
* When given time elapses
* Then the callback is called exactly one time
*
* Test callback called once
* Given a Timeout object with a callback attached with @a attach_us()
* When given time elapses
* Then the callback is called exactly one time
*/
template<typename T>
void test_single_call(void)
{
Semaphore sem(0, 1);
T timeout;
timeout.attach_callback(mbed::callback(sem_callback, &sem), TEST_DELAY_US);
int32_t sem_slots = sem.wait(0);
TEST_ASSERT_EQUAL(0, sem_slots);
sem_slots = sem.wait(TEST_DELAY_MS + 1);
TEST_ASSERT_EQUAL(1, sem_slots);
sem_slots = sem.wait(TEST_DELAY_MS + 1);
TEST_ASSERT_EQUAL(0, sem_slots);
timeout.detach();
}
/** Template for tests: callback not called when cancelled
*
* Test callback not called when cancelled
* Given a Timeout object with a callback attached with @a attach()
* When the callback is detached before being called
* Then the callback is never called
*
* Test callback not called when cancelled
* Given a Timeout object with a callback attached with @a attach_us()
* When the callback is detached before being called
* Then the callback is never called
*/
template<typename T>
void test_cancel(void)
{
Semaphore sem(0, 1);
T timeout;
timeout.attach_callback(mbed::callback(sem_callback, &sem), 2.0f * TEST_DELAY_US);
int32_t sem_slots = sem.wait(TEST_DELAY_MS);
TEST_ASSERT_EQUAL(0, sem_slots);
timeout.detach();
sem_slots = sem.wait(TEST_DELAY_MS + 1);
TEST_ASSERT_EQUAL(0, sem_slots);
}
/** Template for tests: callback override
*
* Test callback override
* Given a Timeout object with a callback attached with @a attach()
* When another callback is attached before first one is called
* and second callback's delay elapses
* Then the second callback is called
* and the first callback is never called
*
* Test callback override
* Given a Timeout object with a callback attached with @a attach_us()
* When another callback is attached before first one is called
* and second callback's delay elapses
* Then the second callback is called
* and the first callback is never called
*/
template<typename T>
void test_override(void)
{
Semaphore sem1(0, 1);
Semaphore sem2(0, 1);
T timeout;
timeout.attach_callback(mbed::callback(sem_callback, &sem1), 2.0f * TEST_DELAY_US);
int32_t sem_slots = sem1.wait(TEST_DELAY_MS);
TEST_ASSERT_EQUAL(0, sem_slots);
timeout.attach_callback(mbed::callback(sem_callback, &sem2), 2.0f * TEST_DELAY_US);
sem_slots = sem2.wait(2 * TEST_DELAY_MS + 1);
TEST_ASSERT_EQUAL(1, sem_slots);
sem_slots = sem1.wait(0);
TEST_ASSERT_EQUAL(0, sem_slots);
timeout.detach();
}
/** Template for tests: multiple Timeouts
*
* Test multiple Timeouts
* Given multiple separate Timeout objects
* When a callback is attached to all of these Timeout objects with @a attach()
* and delay for every Timeout elapses
* Then all callbacks are called
*
* Test multiple Timeouts
* Given multiple separate Timeout objects
* When a callback is attached to all of these Timeout objects with @a attach_us()
* and delay for every Timeout elapses
* Then all callbacks are called
*/
template<typename T>
void test_multiple(void)
{
volatile uint32_t callback_count = 0;
T timeouts[NUM_TIMEOUTS];
for (size_t i = 0; i < NUM_TIMEOUTS; i++) {
timeouts[i].attach_callback(mbed::callback(cnt_callback, &callback_count), TEST_DELAY_US);
}
Thread::wait(TEST_DELAY_MS + 1);
TEST_ASSERT_EQUAL(NUM_TIMEOUTS, callback_count);
}
/** Template for tests: zero delay
*
* Test zero delay
* Given a Timeout object
* When a callback is attached with 0.0 s delay, with @a attach()
* Then the callback is called instantly
*
* Test zero delay
* Given a Timeout object
* When a callback is attached with 0.0 s delay, with @a attach_us()
* Then the callback is called instantly
*/
template<typename T>
void test_no_wait(void)
{
Semaphore sem(0, 1);
T timeout;
timeout.attach_callback(mbed::callback(sem_callback, &sem), 0ULL);
int32_t sem_slots = sem.wait(0);
TEST_ASSERT_EQUAL(1, sem_slots);
timeout.detach();
}
/** Template for tests: accuracy of timeout delay
*
* Test delay accuracy
* Given a Timeout object with a callback attached with @a attach()
* When the callback is called
* Then elapsed time matches given delay
*
* Test delay accuracy
* Given a Timeout object with a callback attached with @a attach_us()
* When the callback is called
* Then elapsed time matches given delay
*/
template<typename T, us_timestamp_t delay_us, us_timestamp_t delta_us>
void test_delay_accuracy(void)
{
Semaphore sem(0, 1);
T timeout;
Timer timer;
timer.start();
timeout.attach_callback(mbed::callback(sem_callback, &sem), delay_us);
int32_t sem_slots = sem.wait(osWaitForever);
timer.stop();
TEST_ASSERT_EQUAL(1, sem_slots);
TEST_ASSERT_UINT64_WITHIN(delta_us, delay_us, timer.read_high_resolution_us());
timeout.detach();
}
#if DEVICE_SLEEP
/** Template for tests: timeout during sleep
*
* Test timeout during sleep
* Given a Timeout object with a callback attached with @a attach()
* and the uC in a sleep mode
* When given delay elapses
* Then the callback is called
* and elapsed time matches given delay
*
* Test timeout during sleep
* Given a Timeout object with a callback attached with @a attach_us()
* and the uC in a sleep mode
* When given delay elapses
* Then the callback is called
* and elapsed time matches given delay
*/
template<typename T, us_timestamp_t delay_us, us_timestamp_t delta_us>
void test_sleep(void)
{
Semaphore sem(0, 1);
T timeout;
Timer timer;
sleep_manager_lock_deep_sleep();
timer.start();
timeout.attach_callback(mbed::callback(sem_callback, &sem), delay_us);
bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
TEST_ASSERT_FALSE_MESSAGE(deep_sleep_allowed, "Deep sleep should be disallowed");
while (sem.wait(0) != 1) {
sleep();
}
timer.stop();
sleep_manager_unlock_deep_sleep();
TEST_ASSERT_UINT64_WITHIN(delta_us, delay_us, timer.read_high_resolution_us());
timeout.detach();
}
#if DEVICE_LOWPOWERTIMER
/** Template for tests: timeout during deepsleep
*
* Test timeout during deepsleep
* Given a LowPowerTimeout object with a callback attached with @a attach()
* and the uC in a deepsleep mode
* When given delay elapses
* Then the callback is called
* and elapsed time matches given delay
*
* Test timeout during deepsleep
* Given a LowPowerTimeout object with a callback attached with @a attach_us()
* and the uC in a deepsleep mode
* When given delay elapses
* Then the callback is called
* and elapsed time matches given delay
*/
template<typename T, us_timestamp_t delay_us, us_timestamp_t delta_us>
void test_deepsleep(void)
{
Semaphore sem(0, 1);
T timeout;
/*
* We use here the low power timer instead of microsecond timer for start and
* end because the microseconds timer might be disabled during deepsleep.
*/
LowPowerTimer timer;
/*
* Since deepsleep() may shut down the UART peripheral, we wait for 10ms
* to allow for hardware serial buffers to completely flush.
* This should be replaced with a better function that checks if the
* hardware buffers are empty. However, such an API does not exist now,
* so we'll use the wait_ms() function for now.
*/
wait_ms(10);
timer.start();
timeout.attach_callback(mbed::callback(sem_callback, &sem), delay_us);
bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");
while (sem.wait(0) != 1) {
sleep();
}
timer.stop();
TEST_ASSERT_UINT64_WITHIN(delta_us, delay_us, timer.read_high_resolution_us());
timeout.detach();
}
#endif
#endif
template<typename TimeoutTesterType>
class TimeoutDriftTester {
public:
TimeoutDriftTester(us_timestamp_t period = 1000) :
_callback_count(0), _period(period), _timeout()
{
}
void reschedule_callback(void)
{
_timeout.attach_callback(mbed::callback(this, &TimeoutDriftTester::reschedule_callback), _period);
_callback_count++;
}
void detach_callback(void)
{
_timeout.detach();
}
uint32_t get_callback_count(void)
{
return _callback_count;
}
private:
volatile uint32_t _callback_count;
us_timestamp_t _period;
TimeoutTesterType _timeout;
};
/** Template for tests: accuracy of timeout delay scheduled repeatedly
*
* Test time drift -- device part
* Given a Timeout object with a callback repeatedly attached with @a attach()
* When the testing host computes test duration based on values received from uC
* Then computed time and actual time measured by host are equal within given tolerance
*
* Test time drift -- device part
* Given a Timeout object with a callback repeatedly attached with @a attach_us()
* When the testing host computes test duration based on values received from uC
* Then computed time and actual time measured by host are equal within given tolerance
*
* Original description:
* 1) DUT would start to update callback_trigger_count every milli sec
* 2) Host would query what is current count base_time, Device responds by the callback_trigger_count
* 3) Host after waiting for measurement stretch. It will query for device time again final_time.
* 4) Host computes the drift considering base_time, final_time, transport delay and measurement stretch
* 5) Finally host send the results back to device pass/fail based on tolerance.
* 6) More details on tests can be found in timing_drift_auto.py
*/
template<typename T>
void test_drift(void)
{
char _key[11] = { };
char _value[128] = { };
int expected_key = 1;
TimeoutDriftTester<T> timeout(DRIFT_TEST_PERIOD_US);
greentea_send_kv("timing_drift_check_start", 0);
timeout.reschedule_callback();
// wait for 1st signal from host
do {
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
expected_key = strcmp(_key, "base_time");
} while (expected_key);
greentea_send_kv(_key, timeout.get_callback_count() * DRIFT_TEST_PERIOD_US);
// wait for 2nd signal from host
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
greentea_send_kv(_key, timeout.get_callback_count() * DRIFT_TEST_PERIOD_US);
timeout.detach_callback();
//get the results from host
greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
TEST_ASSERT_EQUAL_STRING_MESSAGE("pass", _key, "Host script reported a failure");
}
#endif

2
TESTS/mbed_hal/flash/functional_tests/main.cpp
View File

@ -279,7 +279,9 @@ Case cases[] = {
Case("Flash - erase sector", flash_erase_sector_test),
Case("Flash - program page", flash_program_page_test),
Case("Flash - buffer alignment test", flash_buffer_alignment_test),
#ifndef MCU_NRF52
Case("Flash - clock and cache test", flash_clock_and_cache_test),
#endif
};
utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {

2
TESTS/mbedmicro-mbed/static_assert/test_c.c
View File

@ -2,7 +2,7 @@
#define THE_ANSWER 42
// Tests for static asserts in different contexts
// multiple asserts are used to garuntee no conflicts occur in generated labels
// multiple asserts are used to guarantee no conflicts occur in generated labels
// Test for static asserts in global context
MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),

2
TESTS/mbedmicro-mbed/static_assert/test_cpp.cpp
View File

@ -2,7 +2,7 @@
#define THE_ANSWER 42
// Tests for static asserts in different contexts
// multiple asserts are used to garuntee no conflicts occur in generated labels
// multiple asserts are used to guarantee no conflicts occur in generated labels
// Test for static asserts in global context
MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),

2
TESTS/netsocket/host_tests/udp_shotgun.py
View File

@ -34,7 +34,7 @@ class UDPEchoClientHandler(BaseRequestHandler):
data, sock = self.request
pattern = [ord(d) << 4 for d in data]
# Each byte in request indicates size of packet to recieve
# Each byte in request indicates size of packet to receive
# Each packet size is shifted over by 4 to fit in a byte, which
# avoids any issues with endianess or decoding
for packet in pattern:

2
TESTS/netsocket/tcp_packet_pressure/main.cpp
View File

@ -226,7 +226,7 @@ void test_tcp_packet_pressure()
}
}
// Verify recieved data
// Verify received data
while (rx_count < size) {
int rd = sock.recv(buffer, buffer_size);
TEST_ASSERT(rd > 0 || rd == NSAPI_ERROR_WOULD_BLOCK);

2
TESTS/netsocket/tcp_packet_pressure_parallel/main.cpp
View File

@ -232,7 +232,7 @@ public:
}
}
// Verify recieved data
// Verify received data
while (rx_count < size) {
int rd = sock.recv(buffer, buffer_size);
TEST_ASSERT(rd > 0 || rd == NSAPI_ERROR_WOULD_BLOCK);

2
TESTS/netsocket/udp_packet_pressure/main.cpp
View File

@ -222,7 +222,7 @@ void test_udp_packet_pressure()
}
}
// Prioritize recieving over sending packets to avoid flooding
// Prioritize receiving over sending packets to avoid flooding
// the network while handling erronous packets
while (rx_count < size) {
int rd = sock.recvfrom(NULL, buffer, buffer_size);

2
TESTS/netsocket/udp_packet_pressure_parallel/main.cpp
View File

@ -229,7 +229,7 @@ public:
}
}
// Prioritize recieving over sending packets to avoid flooding
// Prioritize receiving over sending packets to avoid flooding
// the network while handling erronous packets
while (rx_count < size) {
int rd = sock.recvfrom(NULL, buffer, buffer_size);

1
doxyfile_options
View File

@ -2070,6 +2070,7 @@ PREDEFINED = DOXYGEN_ONLY \
DEVICE_I2CSLAVE \
DEVICE_I2C_ASYNCH \
DEVICE_INTERRUPTIN \
DEVICE_ITM \
DEVICE_LOWPOWERTIMER \
DEVICE_PORTIN \
DEVICE_PORTINOUT \

2
doxygen_options.json
View File

@ -6,7 +6,7 @@
"SEARCH_INCLUDES": "YES",
"INCLUDE_PATH": "",
"INCLUDE_FILE_PATTERNS": "",
"PREDEFINED": "DOXYGEN_ONLY DEVICE_ANALOGIN DEVICE_ANALOGOUT DEVICE_CAN DEVICE_ETHERNET DEVICE_EMAC DEVICE_FLASH DEVICE_I2C DEVICE_I2CSLAVE DEVICE_I2C_ASYNCH DEVICE_INTERRUPTIN DEVICE_LOWPOWERTIMER DEVICE_PORTIN DEVICE_PORTINOUT DEVICE_PORTOUT DEVICE_PWMOUT DEVICE_RTC DEVICE_TRNG DEVICE_SERIAL DEVICE_SERIAL_ASYNCH DEVICE_SERIAL_FC DEVICE_SLEEP DEVICE_SPI DEVICE_SPI_ASYNCH DEVICE_SPISLAVE DEVICE_STORAGE \"MBED_DEPRECATED_SINCE(f, g)=\" \"MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M)=\" \"MBED_DEPRECATED(s)=\"",
"PREDEFINED": "DOXYGEN_ONLY DEVICE_ANALOGIN DEVICE_ANALOGOUT DEVICE_CAN DEVICE_ETHERNET DEVICE_EMAC DEVICE_FLASH DEVICE_I2C DEVICE_I2CSLAVE DEVICE_I2C_ASYNCH DEVICE_INTERRUPTIN DEVICE_ITM DEVICE_LOWPOWERTIMER DEVICE_PORTIN DEVICE_PORTINOUT DEVICE_PORTOUT DEVICE_PWMOUT DEVICE_RTC DEVICE_TRNG DEVICE_SERIAL DEVICE_SERIAL_ASYNCH DEVICE_SERIAL_FC DEVICE_SLEEP DEVICE_SPI DEVICE_SPI_ASYNCH DEVICE_SPISLAVE DEVICE_STORAGE \"MBED_DEPRECATED_SINCE(f, g)=\" \"MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M)=\" \"MBED_DEPRECATED(s)=\"",
"EXPAND_AS_DEFINED": "",
"SKIP_FUNCTION_MACROS": "NO",
"EXCLUDE_PATTERNS": "*/tools/* */targets/* */features/mbedtls/* */features/storage/* */features/unsupported/* */BUILD/* */rtos/TARGET_CORTEX/rtx*/* */cmsis/* */features/FEATURE_COMMON_PAL/* */features/FEATURE_LWIP/* */features/FEATURE_UVISOR/* */features/nanostack/* */ble/generic/* */ble/pal/*"

10
drivers/Ethernet.h
View File

@ -98,7 +98,7 @@ public:
*/
int send();
/** Recevies an arrived ethernet packet.
/** Receives an arrived ethernet packet.
*
* Receiving an ethernet packet will drop the last received ethernet packet
* and make a new ethernet packet ready to read.
@ -110,7 +110,7 @@ public:
*/
int receive();
/** Read from an recevied ethernet packet.
/** Read from an received ethernet packet.
*
* After receive returned a number bigger than 0 it is
* possible to read bytes from this packet.
@ -131,11 +131,11 @@ public:
*/
void address(char *mac);
/** Returns if an ethernet link is pressent or not. It takes a wile after Ethernet initializion to show up.
/** Returns if an ethernet link is present or not. It takes a while after Ethernet initialization to show up.
*
* @returns
* 0 if no ethernet link is pressent,
* 1 if an ethernet link is pressent.
* 0 if no ethernet link is present,
* 1 if an ethernet link is present.
*
* Example:
* @code

2
drivers/I2C.cpp
View File

@ -81,7 +81,7 @@ int I2C::write(int data) {
return ret;
}
// read - Master Reciever Mode
// read - Master Receiver Mode
int I2C::read(int address, char* data, int length, bool repeated) {
lock();
aquire();

4
drivers/I2C.h
View File

@ -159,9 +159,9 @@ public:
/** Start non-blocking I2C transfer.
*
* This function locks the deep sleep until any event has occured
* This function locks the deep sleep until any event has occurred
*
* @param address 8/10 bit I2c slave address
* @param address 8/10 bit I2C slave address
* @param tx_buffer The TX buffer with data to be transfered
* @param tx_length The length of TX buffer in bytes
* @param rx_buffer The RX buffer which is used for received data

2
drivers/RawSerial.h
View File

@ -68,7 +68,7 @@ public:
*
* @param c The char to write
*
* @returns The written char or -1 if an error occured
* @returns The written char or -1 if an error occurred
*/
int putc(int c);

12
drivers/SPI.cpp
View File

@ -49,8 +49,8 @@ void SPI::format(int bits, int mode) {
lock();
_bits = bits;
_mode = mode;
// If changing format while you are the owner than just
// update format, but if owner is changed than even frequency should be
// If changing format while you are the owner then just
// update format, but if owner is changed then even frequency should be
// updated which is done by acquire.
if (_owner == this) {
spi_format(&_spi, _bits, _mode, 0);
@ -63,8 +63,8 @@ void SPI::format(int bits, int mode) {
void SPI::frequency(int hz) {
lock();
_hz = hz;
// If changing format while you are the owner than just
// update frequency, but if owner is changed than even frequency should be
// If changing format while you are the owner then just
// update frequency, but if owner is changed then even frequency should be
// updated which is done by acquire.
if (_owner == this) {
spi_frequency(&_spi, _hz);
@ -77,7 +77,7 @@ void SPI::frequency(int hz) {
SPI* SPI::_owner = NULL;
SingletonPtr<PlatformMutex> SPI::_mutex;
// ignore the fact there are multiple physical spis, and always update if it wasnt us last
// ignore the fact there are multiple physical spis, and always update if it wasn't us last
void SPI::aquire() {
lock();
if (_owner != this) {
@ -252,7 +252,7 @@ void SPI::irq_handler_asynch(void)
}
#if TRANSACTION_QUEUE_SIZE_SPI
if (event & (SPI_EVENT_ALL | SPI_EVENT_INTERNAL_TRANSFER_COMPLETE)) {
// SPI peripheral is free (event happend), dequeue transaction
// SPI peripheral is free (event happened), dequeue transaction
dequeue_transaction();
}
#endif

6
drivers/SPI.h
View File

@ -79,7 +79,7 @@ public:
/** Create a SPI master connected to the specified pins
*
* mosi or miso can be specfied as NC if not used
* mosi or miso can be specified as NC if not used
*
* @param mosi SPI Master Out, Slave In pin
* @param miso SPI Master In, Slave Out pin
@ -121,7 +121,7 @@ public:
/** Write to the SPI Slave and obtain the response
*
* The total number of bytes sent and recieved will be the maximum of
* The total number of bytes sent and received will be the maximum of
* tx_length and rx_length. The bytes written will be padded with the
* value 0xff.
*
@ -156,7 +156,7 @@ public:
/** Start non-blocking SPI transfer using 8bit buffers.
*
* This function locks the deep sleep until any event has occured
* This function locks the deep sleep until any event has occurred
*
* @param tx_buffer The TX buffer with data to be transfered. If NULL is passed,
* the default SPI value is sent

2
drivers/SPISlave.h
View File

@ -59,7 +59,7 @@ public:
/** Create a SPI slave connected to the specified pins
*
* mosi or miso can be specfied as NC if not used
* mosi or miso can be specified as NC if not used
*
* @param mosi SPI Master Out, Slave In pin
* @param miso SPI Master In, Slave Out pin

8
drivers/SerialBase.h
View File

@ -167,7 +167,7 @@ public:
/** Begin asynchronous write using 8bit buffer. The completition invokes registered TX event callback
*
* This function locks the deep sleep until any event has occured
* This function locks the deep sleep until any event has occurred
*
* @param buffer The buffer where received data will be stored
* @param length The buffer length in bytes
@ -178,7 +178,7 @@ public:
/** Begin asynchronous write using 16bit buffer. The completition invokes registered TX event callback
*
* This function locks the deep sleep until any event has occured
* This function locks the deep sleep until any event has occurred
*
* @param buffer The buffer where received data will be stored
* @param length The buffer length in bytes
@ -193,7 +193,7 @@ public:
/** Begin asynchronous reading using 8bit buffer. The completition invokes registred RX event callback.
*
* This function locks the deep sleep until any event has occured
* This function locks the deep sleep until any event has occurred
*
* @param buffer The buffer where received data will be stored
* @param length The buffer length in bytes
@ -205,7 +205,7 @@ public:
/** Begin asynchronous reading using 16bit buffer. The completition invokes registred RX event callback.
*
* This function locks the deep sleep until any event has occured
* This function locks the deep sleep until any event has occurred
*
* @param buffer The buffer where received data will be stored
* @param length The buffer length in bytes

12
events/Event.h
View File

@ -172,7 +172,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*/
void cancel() const {
@ -590,7 +590,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*/
void cancel() const {
@ -1008,7 +1008,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*/
void cancel() const {
@ -1426,7 +1426,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*/
void cancel() const {
@ -1844,7 +1844,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*/
void cancel() const {
@ -2262,7 +2262,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*/
void cancel() const {

5
events/EventQueue.h
View File

@ -117,7 +117,7 @@ public:
* The cancel function is irq safe.
*
* If called while the event queue's dispatch loop is active, the cancel
* function does not garuntee that the event will not execute after it
* function does not guarantee that the event will not execute after it
* returns, as the event may have already begun executing.
*
* @param id Unique id of the event
@ -701,6 +701,9 @@ public:
}
/** Calls an event on the queue periodically
*
* @note The first call_every event occurs after the specified delay.
* To create a periodic event that fires immediately, @see Event.
*
* The specified callback will be executed in the context of the event
* queue's dispatch loop.

2
events/README.md
View File

@ -113,7 +113,7 @@ queue.dispatch();
// Events can also pass arguments to the underlying callback when both
// initially constructed and posted.
Event<void(int, int)> event(&queue, printf, "recieved %d and %d\n");
Event<void(int, int)> event(&queue, printf, "received %d and %d\n");
// Events can be posted multiple times and enqueue gracefully until
// the dispatch function is called.

2
events/equeue/equeue.c
View File

@ -37,7 +37,7 @@ static inline int equeue_clampdiff(unsigned a, unsigned b) {
// Increment the unique id in an event, hiding the event from cancel
static inline void equeue_incid(equeue_t *q, struct equeue_event *e) {
e->id += 1;
if (!(e->id << q->npw2)) {
if ((e->id << q->npw2) == 0) {
e->id = 1;
}
}

4
features/FEATURE_BLE/targets/TARGET_CORDIO/README.md
View File

@ -1,10 +1,10 @@
# BLE API Cordio Implementation
The BLE API Cordio implementation allows Cordio licensee to easily deliver a
complete and up to date implementation of mbed BLE to their custommers using
complete and up to date implementation of mbed BLE to their customers using
mbed OS.
To deliver a BLE port, vendors simply have to provide an HCI driver taillored
To deliver a BLE port, vendors simply have to provide an HCI driver tailored
for the BLE module present on the board they want to support.
## Source Organization

2
features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_MCU_NRF51822/sdk/README.md
View File

@ -8,7 +8,7 @@ The files are kept the same as much as possible to the Nordic SDK. Modifications
## Porting new versions of Nordic SDK
A list of files currently requierd by mbed is maintained in [script/required_files.txt](https://github.com/ARMmbed/nrf51-sdk/blob/master/script/required_files.txt). [A python script](https://github.com/ARMmbed/nrf51-sdk/blob/master/script/pick_nrf51_files.py) is written to help porting from nordic sdk releases. **required_files.txt** is parsed to find a list of filenames. The script searches for these filenames in the sdk folder, and copy then into the yotta module mirroring the folder structure in the sdk. **extraIncludes** is automatically added to module.json to allow direct inclusion of noridc headers with just the filename.
A list of files currently required by mbed is maintained in [script/required_files.txt](https://github.com/ARMmbed/nrf51-sdk/blob/master/script/required_files.txt). [A python script](https://github.com/ARMmbed/nrf51-sdk/blob/master/script/pick_nrf51_files.py) is written to help porting from nordic sdk releases. **required_files.txt** is parsed to find a list of filenames. The script searches for these filenames in the sdk folder, and copy then into the yotta module mirroring the folder structure in the sdk. **extraIncludes** is automatically added to module.json to allow direct inclusion of noridc headers with just the filename.
### Script usage
```

13
features/FEATURE_COMMON_PAL/mbed-coap/CHANGELOG.md
View File

@ -1,5 +1,18 @@
# Change Log
## [v4.4.0](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.4.0)
**New feature:**
- Make sn_coap_protocol_send_rst as public needed for CoAP ping sending
- Allow disabling resendings by defining SN_COAP_DISABLE_RESENDINGS
-[Full Changelog](https://github.com/ARMmbed/mbed-coap/compare/v4.3.0...v4.4.0)
## [v4.3.0](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.3.0)
**New feature:**
- Add new API which clears the whole sent blockwise message list
-[Full Changelog](https://github.com/ARMmbed/mbed-coap/compare/v4.2.0...v4.3.0)
## [v4.2.0](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.2.0)
**New feature:**
- Add new API to remove sent blockwise message from the linked list

21
features/FEATURE_COMMON_PAL/mbed-coap/mbed-coap/sn_coap_protocol.h
View File

@ -247,6 +247,27 @@ extern int8_t sn_coap_convert_block_size(uint16_t block_size);
*/
extern int8_t sn_coap_protocol_handle_block2_response_internally(struct coap_s *handle, uint8_t handle_response);
/**
* \fn void sn_coap_protocol_clear_sent_blockwise_messages(struct coap_s *handle)
*
* \brief This function clears all the sent blockwise messages from the linked list.
*
* \param *handle Pointer to CoAP library handle
*/
extern void sn_coap_protocol_clear_sent_blockwise_messages(struct coap_s *handle);
/**
* \fn void sn_coap_protocol_send_rst(struct coap_s *handle, uint16_t msg_id, sn_nsdl_addr_s *addr_ptr, void *param)
*
* \brief This function sends a RESET message.
*
* \param *handle Pointer to CoAP library handle
* \param msg_id Message id.
* \param addr_ptr Pointer to destination address where CoAP message will be sent
* \param param Pointer that will be passed to tx function callback
*/
extern void sn_coap_protocol_send_rst(struct coap_s *handle, uint16_t msg_id, sn_nsdl_addr_s *addr_ptr, void *param);
#endif /* SN_COAP_PROTOCOL_H_ */
#ifdef __cplusplus

9
features/FEATURE_COMMON_PAL/mbed-coap/mbed-coap/sn_config.h
View File

@ -54,6 +54,15 @@
*/
#undef COAP_DISABLE_OBS_FEATURE
/**
* \def SN_COAP_DISABLE_RESENDINGS
*
* \brief Disables resending feature. Resending feature should not be needed
* when using CoAP with TCP transport for example. By default resendings are
* enabled. Set to 1 to disable.
*/
#undef SN_COAP_DISABLE_RESENDINGS /* 0 */ // < Default re-sending are not disabled. Set to 1 to disable re-sendings
/**
* \def SN_COAP_RESENDING_QUEUE_SIZE_MSGS
*

2
features/FEATURE_COMMON_PAL/mbed-coap/module.json
View File

@ -1,6 +1,6 @@
{
"name": "mbed-coap",
"version": "4.2.0",
"version": "4.4.0",
"description": "COAP library",
"keywords": [
"coap",

4
features/FEATURE_COMMON_PAL/mbed-coap/source/include/sn_coap_protocol_internal.h
View File

@ -39,7 +39,11 @@ struct sn_coap_hdr_;
/* * * * * * * * * * * */
/* * For Message resending * */
#ifdef SN_COAP_DISABLE_RESENDINGS
#define ENABLE_RESENDINGS 0 /* Disable resendings */
#else
#define ENABLE_RESENDINGS 1 /**< Enable / Disable resending from library in building */
#endif
#define SN_COAP_RESENDING_MAX_COUNT 3 /**< Default number of re-sendings */

26
features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_protocol.c
View File

@ -47,7 +47,6 @@
/* * * * LOCAL FUNCTION PROTOTYPES * * * */
/* * * * * * * * * * * * * * * * * * * * */
static void sn_coap_protocol_send_rst(struct coap_s *handle, uint16_t msg_id, sn_nsdl_addr_s *addr_ptr, void *param);
#if SN_COAP_DUPLICATION_MAX_MSGS_COUNT/* If Message duplication detection is not used at all, this part of code will not be compiled */
static void sn_coap_protocol_linked_list_duplication_info_store(struct coap_s *handle, sn_nsdl_addr_s *src_addr_ptr, uint16_t msg_id, void *param);
static coap_duplication_info_s *sn_coap_protocol_linked_list_duplication_info_search(struct coap_s *handle, sn_nsdl_addr_s *scr_addr_ptr, uint16_t msg_id);
@ -256,6 +255,27 @@ int8_t sn_coap_protocol_set_block_size(struct coap_s *handle, uint16_t block_siz
}
void sn_coap_protocol_clear_sent_blockwise_messages(struct coap_s *handle)
{
(void) handle;
#if SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE
if (handle == NULL) {
return;
}
/* Loop all stored Blockwise messages in Linked list */
ns_list_foreach_safe(coap_blockwise_msg_s, removed_blocwise_msg_ptr, &handle->linked_list_blockwise_sent_msgs) {
if (removed_blocwise_msg_ptr->coap_msg_ptr) {
handle->sn_coap_protocol_free(removed_blocwise_msg_ptr->coap_msg_ptr->payload_ptr);
removed_blocwise_msg_ptr->coap_msg_ptr->payload_ptr = 0;
sn_coap_parser_release_allocated_coap_msg_mem(handle, removed_blocwise_msg_ptr->coap_msg_ptr);
removed_blocwise_msg_ptr->coap_msg_ptr = 0;
}
sn_coap_protocol_linked_list_blockwise_msg_remove(handle, removed_blocwise_msg_ptr);
}
#endif
}
int8_t sn_coap_protocol_set_duplicate_buffer_size(struct coap_s *handle, uint8_t message_count)
{
(void) handle;
@ -646,6 +666,8 @@ sn_coap_hdr_s *sn_coap_protocol_parse(struct coap_s *handle, sn_nsdl_addr_s *src
/* Check if there is no room to store message for duplication detection purposes */
if (stored_duplication_msgs_count >= handle->sn_coap_duplication_buffer_size) {
tr_debug("sn_coap_protocol_parse - duplicate list full, dropping oldest");
/* Get oldest stored duplication message */
coap_duplication_info_s *stored_duplication_info_ptr = ns_list_get_first(&handle->linked_list_duplication_msgs);
@ -1007,7 +1029,7 @@ uint32_t sn_coap_calculate_new_resend_time(const uint32_t current_time, const ui
#endif /* ENABLE_RESENDINGS */
static void sn_coap_protocol_send_rst(struct coap_s *handle, uint16_t msg_id, sn_nsdl_addr_s *addr_ptr, void *param)
void sn_coap_protocol_send_rst(struct coap_s *handle, uint16_t msg_id, sn_nsdl_addr_s *addr_ptr, void *param)
{
uint8_t packet_ptr[4];

8
features/FEATURE_LWIP/lwip-interface/lwip_stack.c
View File

@ -1145,6 +1145,7 @@ static nsapi_error_t mbed_lwip_socket_bind(nsapi_stack_t *stack, nsapi_socket_t
static nsapi_error_t mbed_lwip_socket_listen(nsapi_stack_t *stack, nsapi_socket_t handle, int backlog)
{
#if LWIP_TCP
struct lwip_socket *s = (struct lwip_socket *)handle;
if (s->conn->pcb.tcp->local_port == 0) {
@ -1153,6 +1154,9 @@ static nsapi_error_t mbed_lwip_socket_listen(nsapi_stack_t *stack, nsapi_socket_
err_t err = netconn_listen_with_backlog(s->conn, backlog);
return mbed_lwip_err_remap(err);
#else
return NSAPI_ERROR_UNSUPPORTED;
#endif
}
static nsapi_error_t mbed_lwip_socket_connect(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port)
@ -1173,6 +1177,7 @@ static nsapi_error_t mbed_lwip_socket_connect(nsapi_stack_t *stack, nsapi_socket
static nsapi_error_t mbed_lwip_socket_accept(nsapi_stack_t *stack, nsapi_socket_t server, nsapi_socket_t *handle, nsapi_addr_t *addr, uint16_t *port)
{
#if LWIP_TCP
struct lwip_socket *s = (struct lwip_socket *)server;
struct lwip_socket *ns = mbed_lwip_arena_alloc();
if (!ns) {
@ -1199,6 +1204,9 @@ static nsapi_error_t mbed_lwip_socket_accept(nsapi_stack_t *stack, nsapi_socket_
netconn_set_nonblocking(ns->conn, true);
return 0;
#else
return NSAPI_ERROR_UNSUPPORTED;
#endif
}
static nsapi_size_or_error_t mbed_lwip_socket_send(nsapi_stack_t *stack, nsapi_socket_t handle, const void *data, nsapi_size_t size)

19
features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp
View File

@ -68,38 +68,37 @@ void Test_AT_CellularSMS::test_AT_CellularSMS_send_sms()
ATHandler at(&fh1, que, 0, ",");
AT_CellularSMS sms(at);
CHECK(NSAPI_ERROR_PARAMETER == sms.send_sms(NULL, "2", 1));
LONGS_EQUAL(NSAPI_ERROR_PARAMETER, sms.send_sms(NULL, "2", 1));
sms.initialize(CellularSMS::CellularSMSMmodeText);
ATHandler_stub::size_value = 1;
CHECK(1 == sms.send_sms("1", "22", 2));
LONGS_EQUAL(1, sms.send_sms("1", "22", 2));
ATHandler_stub::size_value = 2;
CHECK(2 == sms.send_sms("1", "22", 2));
LONGS_EQUAL(2, sms.send_sms("1", "22", 2));
ATHandler_stub::return_given_size = true; // PDU mode write is much longer than than msg len
sms.initialize(CellularSMS::CellularSMSMmodePDU);
CHECK(2 == sms.send_sms("1", "23", 2));
LONGS_EQUAL(2, sms.send_sms("1", "23", 2));;
ATHandler_stub::nsapi_error_ok_counter = 1;
ATHandler_stub::size_value = 32;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.send_sms("1", "23232323", 8));
LONGS_EQUAL(NSAPI_ERROR_AUTH_FAILURE, sms.send_sms("1", "23232323", 8));
ATHandler_stub::nsapi_error_ok_counter = 2;
ATHandler_stub::size_value = 32;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.send_sms("1", "23232323", 8));
LONGS_EQUAL(NSAPI_ERROR_AUTH_FAILURE, sms.send_sms("1", "23232323", 8));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
char table[] = "232323232323232323232323232323232323232323232323232323\
232323232323232323232323232323232323232323232323232323\
232323232323232323232323232323232323232323232323232323\
23232323232323232323232323232323232323\0";
ATHandler_stub::size_value = 0;
ATHandler_stub::return_given_size = true;
CHECK(218 == sms.send_sms("1", table, strlen(table)));
CHECK(218 == sms.send_sms("12", table, strlen(table)));
LONGS_EQUAL(strlen(table), sms.send_sms("1", table, strlen(table)));
LONGS_EQUAL(strlen(table), sms.send_sms("12", table, strlen(table)));
}

41
features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp
View File

@ -35,6 +35,7 @@ public:
bool max_sock_value;
nsapi_error_t create_error;
int max_packet_size;
CellularSocket socket;
MyStack(ATHandler &atr, int cid, nsapi_ip_stack_t typ) : AT_CellularStack(atr, cid, typ)
{
@ -143,14 +144,14 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_open()
st.bool_value = true;
st.max_sock_value = 0;
nsapi_socket_t sock;
nsapi_socket_t sock = &st.socket;
CHECK(NSAPI_ERROR_NO_SOCKET == st.socket_open(&sock, NSAPI_TCP));
MyStack st2(at, 0, IPV6_STACK);
st2.bool_value = true;
st2.max_sock_value = 1;
nsapi_socket_t sock2;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock2, NSAPI_TCP));
sock = &st2.socket;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock, NSAPI_TCP));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_close()
@ -160,12 +161,11 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_close()
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t soc = NULL;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(soc));
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(&st.socket));
nsapi_socket_t sock = &st.socket;
st.bool_value = true;
st.max_sock_value = 1;
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_OK == st.socket_open(&sock, NSAPI_TCP));
st.max_sock_value = 0;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(sock));
@ -173,9 +173,9 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_close()
MyStack st2(at, 0, IPV6_STACK);
st2.max_sock_value = 1;
st2.bool_value = true;
nsapi_socket_t sock2;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock2, NSAPI_TCP));
CHECK(NSAPI_ERROR_OK == st2.socket_close(sock2));
sock = &st2.socket;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock, NSAPI_TCP));
CHECK(NSAPI_ERROR_OK == st2.socket_close(sock));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_bind()
@ -185,12 +185,11 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_bind()
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
SocketAddress addr;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_ALREADY;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_bind(NULL, addr));
CHECK(NSAPI_ERROR_ALREADY == st.socket_bind(sock, addr));
CHECK(NSAPI_ERROR_ALREADY == st.socket_bind(&st.socket, addr));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_listen()
@ -200,8 +199,7 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_listen()
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
CHECK(0 == st.socket_listen(sock, 4));
CHECK(NSAPI_ERROR_UNSUPPORTED == st.socket_listen(&st.socket, 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_connect()
@ -214,8 +212,7 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_connect()
SocketAddress addr;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_connect(NULL, addr));
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_OK == st.socket_connect(sock, addr));
CHECK(NSAPI_ERROR_OK == st.socket_connect(&st.socket, addr));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_accept()
@ -225,8 +222,8 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_accept()
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
CHECK(0 == st.socket_accept(NULL, &sock));
nsapi_socket_t sock = &st.socket;
CHECK(NSAPI_ERROR_UNSUPPORTED == st.socket_accept(NULL, &sock));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_send()
@ -238,12 +235,12 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_send()
MyStack st(at, 0, IPV6_STACK);
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(NULL, "addr", 4));
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(sock, "addr", 4));
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(&st.socket, "addr", 4));
SocketAddress addr;
st.max_sock_value = 1;
st.bool_value = true;
nsapi_socket_t sock = &st.socket;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(sock, "addr", 4));
@ -257,12 +254,12 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_sendto()
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
SocketAddress addr;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_sendto(NULL, addr, "addr", 4));
st.max_sock_value = 1;
st.bool_value = true;
nsapi_socket_t sock = &st.socket;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
st.create_error = NSAPI_ERROR_CONNECTION_LOST;
@ -294,10 +291,10 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_recvfrom()
char table[4];
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_recvfrom(NULL, NULL, table, 4));
nsapi_socket_t sock;
SocketAddress addr;
st.max_sock_value = 1;
st.bool_value = true;
nsapi_socket_t sock = &st.socket;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
st.create_error = NSAPI_ERROR_CONNECTION_LOST;
@ -317,9 +314,9 @@ void Test_AT_CellularStack::test_AT_CellularStack_socket_attach()
MyStack st(at, 0, IPV6_STACK);
st.socket_attach(NULL, NULL, NULL);
nsapi_socket_t sock;
st.max_sock_value = 1;
st.bool_value = true;
nsapi_socket_t sock = &st.socket;
st.socket_open(&sock, NSAPI_TCP);
st.socket_attach(sock, NULL, NULL);
}

17
features/cellular/UNITTESTS/target_h/platform/mbed_power_mgmt.h Normal file
View File

@ -0,0 +1,17 @@
/*
* Copyright (c) , Arm Limited and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* Licensed 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.
*/

0
features/netsocket/cellular/utils/APN_db.h → features/cellular/easy_cellular/APN_db.h
View File

20
features/cellular/easy_cellular/EasyCellularConnection.cpp
View File

@ -29,9 +29,9 @@
#include "CellularLog.h"
#include "mbed_wait_api.h"
#if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if USE_APN_LOOKUP
#include "APN_db.h"
#endif //MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#endif //USE_APN_LOOKUP
namespace mbed {
@ -59,9 +59,9 @@ EasyCellularConnection::EasyCellularConnection(bool debug) :
NSAPI_ERROR_OK)
{
tr_info("EasyCellularConnection()");
#if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if USE_APN_LOOKUP
_credentials_set = false;
#endif // #if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#endif // #if USE_APN_LOOKUP
modem_debug_on(debug);
}
@ -102,11 +102,11 @@ void EasyCellularConnection::set_credentials(const char *apn, const char *uname,
CellularNetwork * network = _cellularConnectionFSM.get_network();
if (network) {
_credentials_err = network->set_credentials(apn, uname, pwd);
#if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if USE_APN_LOOKUP
if (_credentials_err == NSAPI_ERROR_OK) {
_credentials_set = true;
}
#endif // #if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#endif // #if USE_APN_LOOKUP
} else {
tr_error("NO Network...");
}
@ -163,7 +163,7 @@ nsapi_error_t EasyCellularConnection::connect()
if (err) {
return err;
}
#if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if USE_APN_LOOKUP
if (!_credentials_set) {
_target_state = CellularConnectionFSM::STATE_SIM_PIN;
err = _cellularConnectionFSM.continue_to_state(_target_state);
@ -193,7 +193,7 @@ nsapi_error_t EasyCellularConnection::connect()
return err;
}
}
#endif // MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#endif // USE_APN_LOOKUP
_target_state = CellularConnectionFSM::STATE_CONNECTED;
err = _cellularConnectionFSM.continue_to_state(_target_state);
@ -212,9 +212,9 @@ nsapi_error_t EasyCellularConnection::disconnect()
{
_credentials_err = NSAPI_ERROR_OK;
_is_connected = false;
#if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if USE_APN_LOOKUP
_credentials_set = false;
#endif // #if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#endif // #if USE_APN_LOOKUP
if (!_cellularConnectionFSM.get_network()) {
return NSAPI_ERROR_NO_CONNECTION;
}

6
features/cellular/easy_cellular/EasyCellularConnection.h
View File

@ -24,6 +24,8 @@
#include "netsocket/CellularBase.h"
#define USE_APN_LOOKUP (MBED_CONF_CELLULAR_USE_APN_LOOKUP || (NSAPI_PPP_AVAILABLE && MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP))
namespace mbed
{
@ -145,9 +147,9 @@ private:
bool _is_connected;
bool _is_initialized;
#if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if USE_APN_LOOKUP
bool _credentials_set;
#endif // #if MBED_CONF_CELLULAR_USE_APN_LOOKUP || MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#endif // #if USE_APN_LOOKUP
CellularConnectionFSM::CellularState _target_state;
UARTSerial _cellularSerial;

25
features/cellular/framework/API/CellularNetwork.h
View File

@ -18,7 +18,6 @@
#ifndef CELLULAR_NETWORK_H_
#define CELLULAR_NETWORK_H_
#include "CellularInterface.h"
#include "NetworkInterface.h"
#include "CellularList.h"
@ -381,6 +380,30 @@ public:
* @return NSAPI_ERROR_OK on success, negative error code on failure
*/
virtual nsapi_error_t get_operator_params(int &format, operator_t &operator_params) = 0;
/** Register callback for status reporting
*
* The specified status callback function will be called on status changes
* on the network. The parameters on the callback are the event type and
* event-type dependent reason parameter.
*
* @param status_cb The callback for status changes
*/
virtual void attach(mbed::Callback<void(nsapi_event_t, intptr_t)> status_cb) = 0;
/** Get the connection status
*
* @return The connection status according to ConnectionStatusType
*/
virtual nsapi_connection_status_t get_connection_status() const = 0;
/** Set blocking status of connect() which by default should be blocking
*
* @param blocking true if connect is blocking
* @return 0 on success, negative error code on failure
*/
virtual nsapi_error_t set_blocking(bool blocking) = 0;
};
} // namespace mbed

65
features/cellular/framework/AT/ATHandler.cpp
View File

@ -314,7 +314,7 @@ void ATHandler::fill_buffer()
} while ((uint32_t)timer.read_ms() < _at_timeout);
set_error(NSAPI_ERROR_DEVICE_ERROR);
tr_error("AT TIMEOUT, scope: %d timeout: %lu", _current_scope, _at_timeout);
tr_debug("AT TIMEOUT, scope: %d timeout: %lu", _current_scope, _at_timeout);
}
int ATHandler::get_char()
@ -846,7 +846,7 @@ bool ATHandler::consume_to_tag(const char *tag, bool consume_tag)
match_pos = 0;
}
}
tr_error("consume_to_tag not found");
tr_debug("consume_to_tag not found");
return false;
}
@ -862,7 +862,7 @@ bool ATHandler::consume_to_stop_tag()
return true;
}
tr_error("consume_to_stop_tag not found");
tr_debug("consume_to_stop_tag not found");
set_error(NSAPI_ERROR_DEVICE_ERROR);
return false;
}
@ -942,13 +942,7 @@ void ATHandler::cmd_start(const char* cmd)
return;
}
// write command
for (size_t i = 0; i < strlen(cmd); i++) {
if (write_char(cmd[i]) == false) {
// writing failed ---> write_char have set the last error, return...
return;
}
}
(void)write(cmd, strlen(cmd));
_cmd_start = true;
}
@ -966,12 +960,7 @@ void ATHandler::write_int(int32_t param)
char number_string[str_len];
int32_t result = sprintf(number_string, "%ld", param);
if (result > 0 && result < str_len) {
for (size_t i = 0; number_string[i]; i++) {
if (write_char(number_string[i]) == false) {
// writing failed ---> write_char have set the last error, break out
break;
}
}
(void)write(number_string, strlen(number_string));
}
}
@ -984,20 +973,15 @@ void ATHandler::write_string(const char* param, bool useQuotations)
}
// we are writing string, surround it with quotes
if (useQuotations && write_char('\"') == false) {
if (useQuotations && write("\"", 1) != 1) {
return;
}
for (size_t i = 0; i < strlen(param); i++) {
if (write_char(param[i]) == false) {
// writing failed ---> write_char have set the last error, return
break;
}
}
(void)write(param, strlen(param));
if (useQuotations) {
// we are writing string, surround it with quotes
write_char('\"');
(void)write("\"", 1);
}
}
@ -1007,11 +991,7 @@ void ATHandler::cmd_stop()
return;
}
// Finish with CR
for (size_t i = 0; i < _output_delimiter_length; i++) {
if (write_char(_output_delimiter[i]) == false) {
break;
}
}
(void)write(_output_delimiter, _output_delimiter_length);
}
size_t ATHandler::write_bytes(const uint8_t *data, size_t len)
@ -1020,36 +1000,27 @@ size_t ATHandler::write_bytes(const uint8_t *data, size_t len)
return 0;
}
size_t i = 0;
for (; i < len; i++) {
if (write_char(data[i]) == false) {
// writing failed ---> write_char have set the last error, return
break;
}
ssize_t write_len = write(data, len);
return write_len < 0 ? 0 : (size_t)write_len;
}
return i;
}
bool ATHandler::write_char(char c)
ssize_t ATHandler::write(const void *data, size_t len)
{
pollfh fhs;
fhs.fh = _fileHandle;
fhs.events = POLLOUT;
bool retVal = true;
ssize_t write_len = -1;
int count = poll(&fhs, 1, _at_timeout);
if (count > 0 && (fhs.revents & POLLOUT)) {
retVal = _fileHandle->write(&c, 1) == 1 ? true : false;
} else {
retVal = false;
write_len = _fileHandle->write(data, len);
}
if (retVal == false) {
if (write_len < 0 || (size_t)write_len != len) {
set_error(NSAPI_ERROR_DEVICE_ERROR);
}
return retVal;
return write_len;
}
// do common checks before sending subparameters
@ -1063,8 +1034,8 @@ bool ATHandler::check_cmd_send()
if (_cmd_start) {
_cmd_start = false;
} else {
if (write_char(_delimiter) == false) {
// writing of delimiter failed, return. write_char already have set the _last_err
if (write(&_delimiter, 1) != 1) {
// writing of delimiter failed, return. write() already have set the _last_err
return false;
}
}

2
features/cellular/framework/AT/ATHandler.h
View File

@ -446,7 +446,7 @@ private:
void set_3gpp_error(int err, DeviceErrorType error_type);
bool check_cmd_send();
bool write_char(char c);
ssize_t write(const void *data, size_t len);
/** Copy content of one char buffer to another buffer and sets NULL terminator
*

22
features/cellular/framework/AT/AT_CellularNetwork.cpp
View File

@ -133,6 +133,7 @@ nsapi_error_t AT_CellularNetwork::connect(const char *apn,
nsapi_error_t AT_CellularNetwork::delete_current_context()
{
tr_info("Delete context %d", _cid);
_at.clear_error();
_at.cmd_start("AT+CGDCONT=");
_at.write_int(_cid);
@ -236,12 +237,14 @@ nsapi_error_t AT_CellularNetwork::open_data_channel()
int context_activation_state = _at.read_int();
if (context_id == _cid && context_activation_state == 1) {
is_context_active = true;
tr_debug("PDP context %d is active.", _cid);
break;
}
}
_at.resp_stop();
if (!is_context_active) {
tr_info("Activate PDP context");
tr_info("Activate PDP context %d", _cid);
_at.cmd_start("AT+CGACT=1,");
_at.write_int(_cid);
_at.cmd_stop();
@ -401,6 +404,7 @@ bool AT_CellularNetwork::set_new_context(int cid)
_ip_stack_type = tmp_stack;
_cid = cid;
_new_context_set = true;
tr_info("New PDP context id %d was created", _cid);
}
return success;
@ -408,6 +412,12 @@ bool AT_CellularNetwork::set_new_context(int cid)
bool AT_CellularNetwork::get_context()
{
if (_apn) {
tr_debug("APN in use: %s", _apn);
} else {
tr_debug("NO APN");
}
_at.cmd_start("AT+CGDCONT?");
_at.cmd_stop();
_at.resp_start("+CGDCONT:");
@ -429,7 +439,7 @@ bool AT_CellularNetwork::get_context()
if (pdp_type_len > 0) {
apn_len = _at.read_string(apn, sizeof(apn) - 1);
if (apn_len >= 0) {
if (_apn && strcmp(apn, _apn) != 0 ) {
if (_apn && (strcmp(apn, _apn) != 0) ) {
continue;
}
nsapi_ip_stack_t pdp_stack = string_to_stack_type(pdp_type_from_context);
@ -546,10 +556,18 @@ nsapi_error_t AT_CellularNetwork::set_registration(const char *plmn)
if (!plmn) {
tr_debug("Automatic network registration");
_at.cmd_start("AT+COPS?");
_at.cmd_stop();
_at.resp_start("AT+COPS:");
int mode = _at.read_int();
_at.resp_stop();
if (mode != 0) {
_at.clear_error();
_at.cmd_start("AT+COPS=0");
_at.cmd_stop();
_at.resp_start();
_at.resp_stop();
}
} else {
tr_debug("Manual network registration to %s", plmn);
_at.cmd_start("AT+COPS=4,2,");

31
features/cellular/framework/targets/QUECTEL/BC95/QUECTEL_BC95.cpp
View File

@ -17,6 +17,7 @@
#include "QUECTEL_BC95_CellularNetwork.h"
#include "QUECTEL_BC95_CellularPower.h"
#include "QUECTEL_BC95_CellularSIM.h"
#include "QUECTEL_BC95.h"
@ -41,7 +42,13 @@ QUECTEL_BC95::~QUECTEL_BC95()
CellularNetwork *QUECTEL_BC95::open_network(FileHandle *fh)
{
if (!_network) {
_network = new QUECTEL_BC95_CellularNetwork(*get_at_handler(fh));
ATHandler *atHandler = get_at_handler(fh);
if (atHandler) {
_network = new QUECTEL_BC95_CellularNetwork(*atHandler);
if (!_network) {
release_at_handler(atHandler);
}
}
}
return _network;
}
@ -49,7 +56,27 @@ CellularNetwork *QUECTEL_BC95::open_network(FileHandle *fh)
CellularPower *QUECTEL_BC95::open_power(FileHandle *fh)
{
if (!_power) {
_power = new QUECTEL_BC95_CellularPower(*get_at_handler(fh));
ATHandler *atHandler = get_at_handler(fh);
if (atHandler) {
_power = new QUECTEL_BC95_CellularPower(*atHandler);
if (!_power) {
release_at_handler(atHandler);
}
}
}
return _power;
}
CellularSIM *QUECTEL_BC95::open_sim(FileHandle *fh)
{
if (!_sim) {
ATHandler *atHandler = get_at_handler(fh);
if (atHandler) {
_sim = new QUECTEL_BC95_CellularSIM(*atHandler);
if (!_sim) {
release_at_handler(atHandler);
}
}
}
return _sim;
}

1
features/cellular/framework/targets/QUECTEL/BC95/QUECTEL_BC95.h
View File

@ -32,6 +32,7 @@ public:
public: // CellularDevice
virtual CellularNetwork *open_network(FileHandle *fh);
virtual CellularPower *open_power(FileHandle *fh);
virtual CellularSIM *open_sim(FileHandle *fh);
public: // NetworkInterface
void handle_urc(FileHandle *fh);

6
features/cellular/framework/targets/QUECTEL/BC95/QUECTEL_BC95_CellularPower.h
View File

@ -15,8 +15,8 @@
* limitations under the License.
*/
#ifndef TELIT_HE910_CELLULAR_POWER_H_
#define TELIT_HE910_CELLULAR_POWER_H_
#ifndef QUECTEL_BC95_CELLULAR_POWER_H_
#define QUECTEL_BC95_CELLULAR_POWER_H_
#include "AT_CellularPower.h"
@ -36,4 +36,4 @@ public: //from CellularPower
} // namespace mbed
#endif // TELIT_HE910_CELLULAR_POWER_H_
#endif // QUECTEL_BC95_CELLULAR_POWER_H_

49
features/cellular/framework/targets/QUECTEL/BC95/QUECTEL_BC95_CellularSIM.cpp Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright (c) 2017, Arm Limited and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* Licensed 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.
*/
#include "QUECTEL_BC95_CellularSIM.h"
#include "CellularLog.h"
using namespace mbed;
QUECTEL_BC95_CellularSIM::QUECTEL_BC95_CellularSIM(ATHandler &atHandler) : AT_CellularSIM(atHandler)
{
}
QUECTEL_BC95_CellularSIM::~QUECTEL_BC95_CellularSIM()
{
}
nsapi_error_t QUECTEL_BC95_CellularSIM::get_sim_state(SimState &state)
{
_at.lock();
_at.flush();
_at.cmd_start("AT+NCCID?");
_at.cmd_stop();
_at.resp_start("+NCCID:");
if (_at.info_resp()) {
state = SimStateReady;
} else {
tr_warn("SIM not readable.");
state = SimStateUnknown; // SIM may not be ready yet
}
_at.resp_stop();
return _at.unlock_return_error();
}

37
features/cellular/framework/targets/QUECTEL/BC95/QUECTEL_BC95_CellularSIM.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2017, Arm Limited and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* Licensed 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.
*/
#ifndef QUECTEL_BC95_CELLULAR_SIM_H_
#define QUECTEL_BC95_CELLULAR_SIM_H_
#include "AT_CellularSIM.h"
namespace mbed {
class QUECTEL_BC95_CellularSIM : public AT_CellularSIM
{
public:
QUECTEL_BC95_CellularSIM(ATHandler &atHandler);
virtual ~QUECTEL_BC95_CellularSIM();
public: //from CellularSIM
virtual nsapi_error_t get_sim_state(SimState &state);
};
} // namespace mbed
#endif // QUECTEL_BC95_CELLULAR_SIM_H_

4
features/cellular/framework/targets/QUECTEL/BC95/QUECTEL_BC95_CellularStack.cpp
View File

@ -150,7 +150,8 @@ nsapi_size_or_error_t QUECTEL_BC95_CellularStack::socket_sendto_impl(CellularSoc
_at.write_string(hexstr, false);
_at.cmd_stop();
_at.resp_start();
socket->id = _at.read_int();
// skip socket id
_at.skip_param();
sent_len = _at.read_int();
_at.resp_stop();
@ -182,6 +183,7 @@ nsapi_size_or_error_t QUECTEL_BC95_CellularStack::socket_recvfrom_impl(CellularS
_at.read_string(hexstr, sizeof(hexstr));
// remaining length
_at.skip_param();
_at.resp_stop();
if (!recv_len || (recv_len == -1) || (_at.get_last_error() != NSAPI_ERROR_OK)) {
return NSAPI_ERROR_WOULD_BLOCK;

8
features/cellular/framework/targets/QUECTEL/BG96/QUECTEL_BG96.cpp
View File

@ -40,7 +40,13 @@ QUECTEL_BG96::~QUECTEL_BG96()
CellularNetwork *QUECTEL_BG96::open_network(FileHandle *fh)
{
if (!_network) {
_network = new QUECTEL_BG96_CellularNetwork(*get_at_handler(fh));
ATHandler *atHandler = get_at_handler(fh);
if (atHandler) {
_network = new QUECTEL_BG96_CellularNetwork(*atHandler);
if (!_network) {
release_at_handler(atHandler);
}
}
}
return _network;
}

4
features/filesystem/bd/BlockDevice.h
View File

@ -128,9 +128,9 @@ public:
*/
virtual bd_size_t get_read_size() const = 0;
/** Get the size of a programable block
/** Get the size of a programmable block
*
* @return Size of a programable block in bytes
* @return Size of a programmable block in bytes
* @note Must be a multiple of the read size
*/
virtual bd_size_t get_program_size() const = 0;

4
features/filesystem/bd/ChainingBlockDevice.h
View File

@ -128,9 +128,9 @@ public:
*/
virtual bd_size_t get_read_size() const;
/** Get the size of a programable block
/** Get the size of a programmable block
*
* @return Size of a programable block in bytes
* @return Size of a programmable block in bytes
* @note Must be a multiple of the read size
*/
virtual bd_size_t get_program_size() const;

4
features/filesystem/bd/HeapBlockDevice.h
View File

@ -118,9 +118,9 @@ public:
*/
virtual bd_size_t get_read_size() const;
/** Get the size of a programable block
/** Get the size of a programmable block
*
* @return Size of a programable block in bytes
* @return Size of a programmable block in bytes
*/
virtual bd_size_t get_program_size() const;

4
features/filesystem/bd/MBRBlockDevice.h
View File

@ -187,9 +187,9 @@ public:
*/
virtual bd_size_t get_read_size() const;
/** Get the size of a programable block
/** Get the size of a programmable block
*
* @return Size of a programable block in bytes
* @return Size of a programmable block in bytes
* @note Must be a multiple of the read size
*/
virtual bd_size_t get_program_size() const;

4
features/filesystem/bd/ProfilingBlockDevice.h
View File

@ -114,9 +114,9 @@ public:
*/
virtual bd_size_t get_read_size() const;
/** Get the size of a programable block
/** Get the size of a programmable block
*
* @return Size of a programable block in bytes
* @return Size of a programmable block in bytes
* @note Must be a multiple of the read size
*/
virtual bd_size_t get_program_size() const;

4
features/filesystem/bd/SlicingBlockDevice.h
View File

@ -120,9 +120,9 @@ public:
*/
virtual bd_size_t get_read_size() const;
/** Get the size of a programable block
/** Get the size of a programmable block
*
* @return Size of a programable block in bytes
* @return Size of a programmable block in bytes
* @note Must be a multiple of the read size
*/
virtual bd_size_t get_program_size() const;

1
features/filesystem/fat/FATFileSystem.cpp
View File

@ -724,6 +724,7 @@ void FATFileSystem::dir_seek(fs_dir_t dir, off_t offset)
FRESULT res;
res = f_readdir(dh, &finfo);
dptr = dh->dptr;
if (res != FR_OK) {
break;
} else if (finfo.fname[0] == 0) {

20
features/filesystem/littlefs/littlefs/lfs.c
View File

@ -658,17 +658,17 @@ static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
// we need to allocate a new dir block
if (!(0x80000000 & dir->d.size)) {
lfs_dir_t newdir;
int err = lfs_dir_alloc(lfs, &newdir);
lfs_dir_t olddir = *dir;
int err = lfs_dir_alloc(lfs, dir);
if (err) {
return err;
}
newdir.d.tail[0] = dir->d.tail[0];
newdir.d.tail[1] = dir->d.tail[1];
entry->off = newdir.d.size - 4;
dir->d.tail[0] = olddir.d.tail[0];
dir->d.tail[1] = olddir.d.tail[1];
entry->off = dir->d.size - 4;
lfs_entry_tole32(&entry->d);
err = lfs_dir_commit(lfs, &newdir, (struct lfs_region[]){
err = lfs_dir_commit(lfs, dir, (struct lfs_region[]){
{entry->off, 0, &entry->d, sizeof(entry->d)},
{entry->off, 0, data, entry->d.nlen}
}, 2);
@ -677,10 +677,10 @@ static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
return err;
}
dir->d.size |= 0x80000000;
dir->d.tail[0] = newdir.pair[0];
dir->d.tail[1] = newdir.pair[1];
return lfs_dir_commit(lfs, dir, NULL, 0);
olddir.d.size |= 0x80000000;
olddir.d.tail[0] = dir->pair[0];
olddir.d.tail[1] = dir->pair[1];
return lfs_dir_commit(lfs, &olddir, NULL, 0);
}
int err = lfs_dir_fetch(lfs, dir, dir->d.tail);

4
features/filesystem/littlefs/littlefs/lfs.h
View File

@ -94,7 +94,7 @@ enum lfs_open_flags {
LFS_F_DIRTY = 0x10000, // File does not match storage
LFS_F_WRITING = 0x20000, // File has been written since last flush
LFS_F_READING = 0x40000, // File has been read since last flush
LFS_F_ERRED = 0x80000, // An error occured during write
LFS_F_ERRED = 0x80000, // An error occurred during write
};
// File seek flags
@ -465,7 +465,7 @@ int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
// Returns a negative error code on failure.
int lfs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
// Prunes any recoverable errors that may have occured in the filesystem
// Prunes any recoverable errors that may have occurred in the filesystem
//
// Not needed to be called by user unless an operation is interrupted
// but the filesystem is still mounted. This is already called on first

66
features/filesystem/littlefs/littlefs/tests/test_dirs.sh
View File

@ -118,6 +118,7 @@ tests/test.py << TEST
sprintf((char*)buffer, "test%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
info.type => LFS_TYPE_DIR;
}
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
@ -355,5 +356,70 @@ tests/test.py << TEST
lfs_unmount(&lfs) => 0;
TEST
echo "--- Multi-block directory with files ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "prickly-pear") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/test%d", i);
lfs_file_open(&lfs, &file[0], (char*)buffer,
LFS_O_WRONLY | LFS_O_CREAT) => 0;
size = 6;
memcpy(wbuffer, "Hello", size);
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
lfs_file_close(&lfs, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "test%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
info.type => LFS_TYPE_REG;
info.size => 6;
}
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
TEST
echo "--- Multi-block remove with files ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/test%d", i);
lfs_remove(&lfs, (char*)buffer) => 0;
}
lfs_remove(&lfs, "prickly-pear") => 0;
lfs_unmount(&lfs) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
TEST
echo "--- Results ---"
tests/stats.py

19
features/filesystem/littlefs/littlefs/tests/test_files.sh
View File

@ -135,5 +135,24 @@ tests/test.py << TEST
lfs_unmount(&lfs) => 0;
TEST
echo "--- Many file test ---"
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
TEST
tests/test.py << TEST
// Create 300 files of 6 bytes
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "directory") => 0;
for (unsigned i = 0; i < 300; i++) {
snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_WRONLY | LFS_O_CREAT) => 0;
size = 6;
memcpy(wbuffer, "Hello", size);
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
lfs_file_close(&lfs, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
TEST
echo "--- Results ---"
tests/stats.py

4
features/lorawan/lorastack/phy/LoRaPHY.cpp
View File

@ -657,11 +657,11 @@ bool LoRaPHY::verify(verification_params_t* verify, phy_attributes_t phy_attribu
if (phy_params.dl_dwell_time_setting == 0) {
return val_in_range(verify->datarate,
phy_params.min_rx_datarate,
phy_params.min_rx_datarate);
phy_params.max_rx_datarate);
} else {
return val_in_range(verify->datarate,
phy_params.dwell_limit_datarate,
phy_params.min_rx_datarate );
phy_params.max_rx_datarate);
}
}
case PHY_DEF_TX_POWER:

2
features/lorawan/lorastack/phy/LoRaPHYAS923.cpp
View File

@ -280,7 +280,7 @@ LoRaPHYAS923::LoRaPHYAS923(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payload_table;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.table = (void *) max_payload_table_with_repeater;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.size = 8;
// dwell time setting, 400 ms
phy_params.ul_dwell_time_setting = 1;

2
features/lorawan/lorastack/phy/LoRaPHYAU915.cpp
View File

@ -279,7 +279,7 @@ LoRaPHYAU915::LoRaPHYAU915(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payload_AU915;
phy_params.payloads.size = 16;
phy_params.payloads_with_repeater.table = (void *) max_payload_with_repeater_AU915;
phy_params.payloads.size = 16;
phy_params.payloads_with_repeater.size = 16;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYCN470.cpp
View File

@ -252,7 +252,7 @@ LoRaPHYCN470::LoRaPHYCN470(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_CN470;
phy_params.payloads.size = 6;
phy_params.payloads_with_repeater.table = (void *)max_payloads_with_repeater_CN470;
phy_params.payloads.size = 6;
phy_params.payloads_with_repeater.size = 6;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYCN779.cpp
View File

@ -268,7 +268,7 @@ LoRaPHYCN779::LoRaPHYCN779(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_CN779;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.table = (void *) max_payloads_with_repeater_CN779;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.size = 8;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYEU433.cpp
View File

@ -269,7 +269,7 @@ LoRaPHYEU433::LoRaPHYEU433(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_EU433;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.table = (void *) max_payloads_with_repeater_EU433;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.size = 8;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYEU868.cpp
View File

@ -299,7 +299,7 @@ LoRaPHYEU868::LoRaPHYEU868(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_EU868;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.table = (void *) max_payloads_repeater_EU868;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.size = 8;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYIN865.cpp
View File

@ -270,7 +270,7 @@ LoRaPHYIN865::LoRaPHYIN865(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_IN865;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.table = (void *) max_payloads_with_repeater;
phy_params.payloads.size = 8;
phy_params.payloads_with_repeater.size = 8;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYKR920.cpp
View File

@ -279,7 +279,7 @@ LoRaPHYKR920::LoRaPHYKR920(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_KR920;
phy_params.payloads.size = 6;
phy_params.payloads_with_repeater.table = (void *) max_payloads_with_repeater_KR920;
phy_params.payloads.size = 6;
phy_params.payloads_with_repeater.size = 6;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYUS915.cpp
View File

@ -271,7 +271,7 @@ LoRaPHYUS915::LoRaPHYUS915(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_US915;
phy_params.payloads.size = 16;
phy_params.payloads_with_repeater.table = (void *) max_payloads_with_repeater_US915;
phy_params.payloads.size = 16;
phy_params.payloads_with_repeater.size = 16;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/lorawan/lorastack/phy/LoRaPHYUS915Hybrid.cpp
View File

@ -269,7 +269,7 @@ LoRaPHYUS915Hybrid::LoRaPHYUS915Hybrid(LoRaWANTimeHandler &lora_time)
phy_params.payloads.table = (void *) max_payloads_US915_HYBRID;
phy_params.payloads.size = 16;
phy_params.payloads_with_repeater.table = (void *) max_payloads_with_repeater_US915_HYBRID;
phy_params.payloads.size = 16;
phy_params.payloads_with_repeater.size = 16;
// dwell time setting
phy_params.ul_dwell_time_setting = 0;

2
features/mbedtls/README.md
View File

@ -10,7 +10,7 @@ This edition of mbed TLS has been adapted for mbed OS and imported from its stan
Getting Help and Support
------------------------
The [mbed TLS website](https://tls.mbed.org/) contains fulll documentation for the library, including function by function descriptions, knowledgebase articles, blogs and a support forum for questions to the community.
The [mbed TLS website](https://tls.mbed.org/) contains full documentation for the library, including function by function descriptions, knowledgebase articles, blogs and a support forum for questions to the community.
Contributing to the Project

125
features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed_lib.json
View File

@ -1,30 +1,105 @@
{
"name": "mbed-mesh-api",
"config": {
"heap-size": 32500,
"use-malloc-for-heap": false,
"6lowpan-nd-channel-mask": "0x7fff800",
"6lowpan-nd-channel-page": 0,
"6lowpan-nd-channel": 0,
"6lowpan-nd-panid-filter": "0xffff",
"6lowpan-nd-security-mode": "NONE",
"6lowpan-nd-psk-key-id": 1,
"6lowpan-nd-psk-key": "{0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf}",
"6lowpan-nd-sec-level": 5,
"6lowpan-nd-device-type": "NET_6LOWPAN_ROUTER",
"thread-pskd": "\"ABCDEFGH\"",
"thread-use-static-link-config": true,
"thread-config-channel-mask": "0x7fff800",
"thread-config-channel-page": 0,
"thread-config-channel": 22,
"thread-config-panid": "0x0700",
"thread-config-network-name": "\"Thread Network\"",
"thread-config-commissioning-dataset-timestamp": "0x10000",
"thread-config-extended-panid": "{0xf1, 0xb5, 0xa1, 0xb2,0xc4, 0xd5, 0xa1, 0xbd }",
"thread-master-key": "{0x10, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}",
"thread-config-ml-prefix": "{0xfd, 0x0, 0x0d, 0xb8, 0x0, 0x0, 0x0, 0x0}",
"thread-config-pskc": "{0xc8, 0xa6, 0x2e, 0xae, 0xf3, 0x68, 0xf3, 0x46, 0xa9, 0x9e, 0x57, 0x85, 0x98, 0x9d, 0x1c, 0xd0}",
"thread-device-type": "MESH_DEVICE_TYPE_THREAD_ROUTER",
"thread-security-policy": 255
"heap-size": {
"help": "Nanostack's heap size (bytes: 0-65534)",
"value": 32500
},
"use-malloc-for-heap": {
"help": "Use `malloc()` for reserving the internal heap.",
"value": false
},
"6lowpan-nd-channel-mask": {
"help": "Channel mask, bit mask of channels to use.",
"value": "0x7fff800"
},
"6lowpan-nd-channel-page": {
"help": "0 for 2.4 GHz and 2 for sub-GHz radios.",
"value": 0
},
"6lowpan-nd-channel": {
"help": "RF channel to use when `channel_mask` is not defined (0-26).",
"value": 0
},
"6lowpan-nd-panid-filter": {
"help": "Beacon PAN ID filter, 0xffff means no filtering.",
"value": "0xffff"
},
"6lowpan-nd-security-mode": {
"help": "NONE or PSK to use either no security, or pre-shared network key.",
"value": "NONE"
},
"6lowpan-nd-psk-key-id": {
"help": "PSK key ID when PSK is enabled.",
"value": 1
},
"6lowpan-nd-psk-key": {
"help": "Pre-shared network key.",
"value": "{0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf}"
},
"6lowpan-nd-sec-level": {
"help": "Network security level (1-7). Use default `5`.",
"value": 5
},
"6lowpan-nd-device-type": {
"help": "Device mode (NET_6LOWPAN_ROUTER or NET_6LOWPAN_HOST). Router is routing packets from other device, creating a mesh network.",
"value": "NET_6LOWPAN_ROUTER"
},
"thread-pskd": {
"help": "Human-scaled commissioning credentials. Uppercase alphanumeric string (0-9, A-Y excluding I, O, Q and Z), 6-32 characters.",
"value": "\"ABCDEFGH\""
},
"thread-use-static-link-config": {
"help": "True: Use the below link config, False: Use commissioning, ignore the below link config.",
"value": true
},
"thread-config-channel-mask": {
"help": "Channel mask, 0x7ffff800 scans all channels.",
"value": "0x7fff800"
},
"thread-config-channel-page": {
"help": "Channel page, 0 for 2.4 GHz radio.",
"value": 0
},
"thread-config-channel": {
"help": "RF channel to use. (11-26)",
"value": 22
},
"thread-config-panid": {
"help": "Network identifier (0-0xFFFF)",
"value": "0x0700"
},
"thread-config-network-name": {
"help": "Network name (max 16 characters)",
"value": "\"Thread Network\""
},
"thread-config-commissioning-dataset-timestamp": {
"help": "[48 bit timestamp seconds]-[15 bit timestamp ticks]-[U bit] (0-0xFFFFFFFFFFFFFFFF)",
"value": "0x10000"
},
"thread-config-extended-panid": {
"help": "Extended PAN ID.",
"value": "{0xf1, 0xb5, 0xa1, 0xb2,0xc4, 0xd5, 0xa1, 0xbd }"
},
"thread-master-key": {
"help": "Network master key.",
"value": "{0x10, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}"
},
"thread-config-ml-prefix": {
"help": "Mesh Local prefix.",
"value": "{0xfd, 0x0, 0x0d, 0xb8, 0x0, 0x0, 0x0, 0x0}"
},
"thread-config-pskc": {
"help": "Pre-Shared Key for the Commissioner.",
"value": "{0xc8, 0xa6, 0x2e, 0xae, 0xf3, 0x68, 0xf3, 0x46, 0xa9, 0x9e, 0x57, 0x85, 0x98, 0x9d, 0x1c, 0xd0}"
},
"thread-device-type": {
"help": "Supported device operating modes: MESH_DEVICE_TYPE_THREAD_ROUTER, MESH_DEVICE_TYPE_THREAD_SLEEPY_END_DEVICE, MESH_DEVICE_TYPE_THREAD_MINIMAL_END_DEVICE",
"value": "MESH_DEVICE_TYPE_THREAD_ROUTER"
},
"thread-security-policy": {
"help": "Commissioning security policy bits (0-0xFF)",
"value": 255
}
}
}

6
features/netsocket/CellularInterface.h
View File

@ -19,7 +19,6 @@
#include "netsocket/NetworkInterface.h"
/** CellularInterface class
*
* Common interface that is shared between ethernet hardware
@ -30,6 +29,7 @@ class CellularInterface : public NetworkInterface
public:
/** CellularInterface lifetime
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularNetwork.h instead.")
virtual ~CellularInterface() {};
/** Set the cellular network APN and credentials
@ -39,6 +39,7 @@ public:
* @param password Optional password fot the APN
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularNetwork.h instead.")
virtual nsapi_error_t set_credentials(const char *apn,
const char *username = 0, const char *password = 0) = 0;
@ -49,6 +50,7 @@ public:
* @param password Optional password for your APN
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularNetwork.h instead.")
virtual nsapi_error_t connect(const char *apn,
const char *username = 0, const char *password = 0) = 0;
@ -58,12 +60,14 @@ public:
*
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularNetwork.h instead.")
virtual nsapi_error_t connect() = 0;
/** Stop the interface
*
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularNetwork.h instead.")
virtual nsapi_error_t disconnect() = 0;
};

6
features/netsocket/NetworkInterface.h
View File

@ -51,21 +51,21 @@ public:
/** Get the local IP address
*
* @return Null-terminated representation of the local IP address
* or null if no IP address has been recieved
* or null if no IP address has been received
*/
virtual const char *get_ip_address();
/** Get the local network mask
*
* @return Null-terminated representation of the local network mask
* or null if no network mask has been recieved
* or null if no network mask has been received
*/
virtual const char *get_netmask();
/** Get the local gateway
*
* @return Null-terminated representation of the local gateway
* or null if no network mask has been recieved
* or null if no network mask has been received
*/
virtual const char *get_gateway();

2
features/netsocket/NetworkStack.h
View File

@ -130,7 +130,7 @@ protected:
/** Bind a specific address to a socket
*
* Binding a socket specifies the address and port on which to recieve
* Binding a socket specifies the address and port on which to receive
* data. If the IP address is zeroed, only the port is bound.
*
* @param handle Socket handle

6
features/netsocket/Socket.h
View File

@ -78,7 +78,7 @@ public:
/** Bind a specific address to a socket
*
* Binding a socket specifies the address and port on which to recieve
* Binding a socket specifies the address and port on which to receive
* data.
*
* @param port Local port to bind
@ -88,7 +88,7 @@ public:
/** Bind a specific address to a socket
*
* Binding a socket specifies the address and port on which to recieve
* Binding a socket specifies the address and port on which to receive
* data. If the IP address is zeroed, only the port is bound.
*
* @param address Null-terminated local address to bind
@ -99,7 +99,7 @@ public:
/** Bind a specific address to a socket
*
* Binding a socket specifies the address and port on which to recieve
* Binding a socket specifies the address and port on which to receive
* data. If the IP address is zeroed, only the port is bound.
*
* @param address Local address to bind

2
features/netsocket/cellular/generic_modem_driver/OnboardCellularInterface.cpp
View File

@ -23,7 +23,9 @@
/**
* OnboardCellularInterface is an on-board specific implementation.
*
*/
OnboardCellularInterface::OnboardCellularInterface(bool debug) :
UARTCellularInterface(MDMTXD, MDMRXD, MDMDCD, MDMRTS,
MDMCTS, MDMRI, MDMDTR, MDMDSR,

7
features/netsocket/cellular/generic_modem_driver/OnboardCellularInterface.h
View File

@ -32,12 +32,15 @@ typedef mbed::EasyCellularConnection OnboardCellularInterface;
* could be derived from different implementation classes.
* Portable applications should only rely on it being a CellularBase.
*/
class OnboardCellularInterface : public UARTCellularInterface {
public:
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularPower.h instead.")
OnboardCellularInterface(bool debug = false);
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularPower.h instead.")
virtual ~OnboardCellularInterface();
protected:
@ -46,6 +49,7 @@ protected:
* modem_init() is equivalent to plugging in the device, for example, attaching power and serial port.
* Uses onboard_modem_api.h where the target provides the implementation of onboard_modem_api.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularPower.h instead.")
virtual void modem_init();
/** Sets the modem in unplugged state
@ -54,6 +58,7 @@ protected:
* and serial port. This puts the modem in lowest power state.
* Uses onboard_modem_api.h where the target provides the implementation of onboard_modem_api.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularPower.h instead.")
virtual void modem_deinit();
/** Powers up the modem
@ -62,6 +67,7 @@ protected:
* The driver may repeat this if the modem is not responsive to AT commands.
* Uses onboard_modem_api.h where the target provides the implementation of onboard_modem_api.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularPower.h instead.")
virtual void modem_power_up();
/** Powers down the modem
@ -69,6 +75,7 @@ protected:
* modem_power_down() is equivalent to turning off the modem by button press.
* Uses onboard_modem_api.h where the target provides the implementation of onboard_modem_api.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/framework/API/CellularPower.h instead.")
virtual void modem_power_down();
};

2
features/netsocket/cellular/generic_modem_driver/PPPCellularInterface.cpp
View File

@ -19,7 +19,7 @@
#include <string.h>
#include "nsapi_ppp.h"
#if MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#include "utils/APN_db.h"
#include "APN_db.h"
#endif //MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP
#if defined(FEATURE_COMMON_PAL)
#include "mbed_trace.h"

24
features/netsocket/cellular/generic_modem_driver/PPPCellularInterface.h
View File

@ -99,6 +99,7 @@ typedef struct {
* derived from in order to provide forms for specific interfaces, as well as
* adding extra power and reset controls alongside the FileHandle.
*/
class PPPCellularInterface : public CellularBase {
public:
@ -108,8 +109,10 @@ public:
* The file handle pointer is not accessed within the constructor, only recorded for later
* use - this permits a derived class to pass a pointer to a not-yet-constructed member object.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
PPPCellularInterface(FileHandle *fh, bool debug = false);
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual ~PPPCellularInterface();
/** Set the Cellular network credentials
@ -120,6 +123,7 @@ public:
* @param uname optionally, Username
* @param pwd optionally, password
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual void set_credentials(const char *apn, const char *uname = 0,
const char *pwd = 0);
@ -127,6 +131,7 @@ public:
*
* @param sim_pin PIN for the SIM card
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual void set_sim_pin(const char *sim_pin);
/** Start the interface
@ -144,6 +149,7 @@ public:
* @param pwd optionally, password
* @return NSAPI_ERROR_OK on success, or negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual nsapi_error_t connect(const char *sim_pin, const char *apn = 0,
const char *uname = 0, const char *pwd = 0);
@ -167,6 +173,7 @@ public:
* Preferred method is to setup APN using 'set_credentials()' API.
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual nsapi_error_t connect();
/** Attempt to disconnect from the network
@ -176,6 +183,7 @@ public:
*
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual nsapi_error_t disconnect();
/** Adds or removes a SIM facility lock
@ -188,6 +196,7 @@ public:
* @param set can be set to true if the SIM pin check is supposed to be enabled
* and vice versa.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
void set_sim_pin_check(bool set);
/** Change the pin for the SIM card
@ -198,6 +207,7 @@ public:
*
* @param new_pin new pin to be used in string format
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
void set_new_sim_pin(const char *new_pin);
/** Check if the connection is currently established or not
@ -206,27 +216,31 @@ public:
* connected to an external packet data network using PPP, isConnected()
* API returns true and false otherwise.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual bool is_connected();
/** Get the local IP address
*
* @return Null-terminated representation of the local IP address
* or null if no IP address has been recieved
* or null if no IP address has been received
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual const char *get_ip_address();
/** Get the local network mask
*
* @return Null-terminated representation of the local network mask
* or null if no network mask has been recieved
* or null if no network mask has been received
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual const char *get_netmask();
/** Get the local gateways
*
* @return Null-terminated representation of the local gateway
* or null if no network mask has been recieved
* or null if no network mask has been received
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual const char *get_gateway();
@ -234,18 +248,21 @@ public:
*
* @param on set true to enable debug traces
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
void modem_debug_on(bool on);
/** Register callback for status reporting
*
* @param status_cb The callback for status changes
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual void attach(Callback<void(nsapi_event_t, intptr_t)> status_cb);
/** Get the connection status
*
* @return The connection status according to nsapi_connection_status_t
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual nsapi_connection_status_t get_connection_status() const;
/** Set blocking status of connect() which by default should be blocking
@ -253,6 +270,7 @@ public:
* @param blocking true if connect is blocking
* @return 0 on success, negative error code on failure
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual nsapi_error_t set_blocking(bool blocking);
private:

1
features/netsocket/cellular/generic_modem_driver/UARTCellularInterface.cpp
View File

@ -14,6 +14,7 @@
*/
#include "UARTCellularInterface.h"
#if NSAPI_PPP_AVAILABLE
UARTCellularInterface::UARTCellularInterface(PinName txd, PinName rxd, PinName dcd, PinName rts, PinName cts, PinName ri,

4
features/netsocket/cellular/generic_modem_driver/UARTCellularInterface.h
View File

@ -29,15 +29,18 @@
* It constructs a FileHandle and passes it back to its base class as well as overrides
* enable_hup() in the base class.
*/
class UARTCellularInterface : public PPPCellularInterface {
public:
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
UARTCellularInterface(PinName tx, PinName rx, PinName dcd = NC, PinName rts = NC, PinName cts = NC, PinName ri = NC,
PinName dtr = NC, PinName dsr = NC, int baud = MBED_CONF_PPP_CELL_IFACE_BAUD_RATE,
bool active_high = false,
bool debug = false);
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual ~UARTCellularInterface();
private:
@ -53,6 +56,7 @@ protected:
* signaling is not desired. enable_hup() controls whether this function should be
* active.
*/
MBED_DEPRECATED_SINCE("mbed-os-5.9", "This API will be deprecated, use mbed-os/features/cellular/easy_cellular/EasyCellularConnection.h instead.")
virtual void enable_hup(bool enable);
};

2
features/netsocket/nsapi.h
View File

@ -33,7 +33,7 @@
#include "netsocket/NetworkInterface.h"
#include "netsocket/EthInterface.h"
#include "netsocket/WiFiInterface.h"
#include "netsocket/CellularInterface.h"
#include "netsocket/CellularBase.h"
#include "netsocket/MeshInterface.h"
#include "netsocket/Socket.h"

2
features/netsocket/nsapi_types.h
View File

@ -403,7 +403,7 @@ typedef struct nsapi_stack_api
/** Bind a specific address to a socket
*
* Binding a socket specifies the address and port on which to recieve
* Binding a socket specifies the address and port on which to receive
* data. If the IP address is zeroed, only the port is bound.
*
* @param stack Stack handle

2
features/nvstore/README.md
View File

@ -33,7 +33,7 @@ Each item is kept in an entry containing a header and data, where the header hol
### Enabling NVStore and configuring it for your board
NVStore is enabled by default for all devices with the internal flash driver (have "FLASH" in the device_has attribute).
One can disable it by setting its "enabled" attribute to false.
Unless specifically configured by the user, NVStore selects the last two flash sectors as its areas, with the mininum size of 4KBs,
Unless specifically configured by the user, NVStore selects the last two flash sectors as its areas, with the minimum size of 4KBs,
meaning that if the sectors are smaller, few continuous ones will be used for each area.
The user can override this by setting the addresses and sizes of both areas in` mbed_lib.json` on a per board basis.
In this case, all following four attributes need to be set:

6
features/nvstore/source/nvstore.h
View File

@ -50,6 +50,11 @@ typedef enum {
// defines 2 areas - active and nonactive, not configurable
#define NVSTORE_NUM_AREAS 2
/** NVStore class
*
* Class for storing data by keys in the internal flash
*/
class NVStore : private mbed::NonCopyable<NVStore> {
public:
@ -399,6 +404,7 @@ private:
int do_set(uint16_t key, uint16_t buf_size, const void *buf, uint16_t flags);
};
/** @}*/
#endif // NVSTORE_ENABLED

4
features/storage/FEATURE_STORAGE/cfstore/doc/design/configuration_store_hld.md
View File

@ -936,7 +936,7 @@ The following provides general notes on the handling of errors:
- Supported backends may include non-volatile storage (flash) and SRAM.
- For example. if a non-volatile storage (flash) backend is supported, then the flushing of data to the NV store must be atomic.
This may require that flushing of data to flash is commited using an atomic write operation e.g. of a CRC32 value for the
commit data. If power loss occured during the atomic write then the CRC32 would be invalid, the previously written data would
commit data. If power loss occurred during the atomic write then the CRC32 would be invalid, the previously written data would
not be valid, and the system would have to revert to a previous version of the data that has successfully commited the correct CRC32
value.
@ -1080,7 +1080,7 @@ split the writing of the value into M writes, where N/M is smaller than availabl
In the case the the Write() call fails with return code `ARM_CFSTORE_DRIVER_ERROR_OUT_OF_MEMORY`
then the client may retry the write transaction with a smaller length (less bytes).
Further, a client of the Write() function should alway check the returned value of the
Further, a client of the Write() function should always check the returned value of the
len argment as this records the actual number of bytes written. CFSTORE may be able to
write a number of bytes less that the total number in the data buffer supplied by the
client. The unwritten bytes should be supplied to a second call to Write().

4
features/storage/FEATURE_STORAGE/cfstore/source/configuration_store.c
View File

@ -1555,7 +1555,7 @@ static int32_t cfstore_flash_map_error(int32_t flash_journal_status_code)
* In flash journal async mode, when:
* - a FlashJournal_xxx() function has been invoked, and
* - before the async completion has been received and processed
* the application context code should alway co-ordinate access to
* the application context code should always coordinate access to
* context variables modified by interrupt and application context
* by use of the critical_section_xxx.
*/
@ -3497,7 +3497,7 @@ static int32_t cfstore_create(const char* key_name, ARM_CFSTORE_SIZE value_len,
ret = cfstore_recreate(key_name, value_len, hkey, &hkvt);
goto out1;
}
/* not a valid hkvt implying the key_name wasnt found */
/* not a valid hkvt implying the key_name wasn't found */
/* create new key */
ret = cfstore_validate_key_desc(kdesc);

6
features/unsupported/USBDevice/targets/TARGET_STM/USBHAL_IP_OTGFSHS.h
View File

@ -202,6 +202,12 @@ USBHAL::USBHAL(void) {
__HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_CLK_ENABLE();
#elif defined(TARGET_STEVAL_3DP001V1)
__HAL_RCC_GPIOB_CLK_ENABLE();
pin_function(PA_11, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); // DM
pin_function(PA_12, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); // DP
__HAL_RCC_USB_OTG_FS_CLK_ENABLE();
#else
#error "USB pins are not configured !"
#endif

1
features/unsupported/USBDevice/targets/TARGET_STM/USBHAL_STM32.h
View File

@ -20,6 +20,7 @@
#if defined(TARGET_NUCLEO_F207ZG) || \
defined(TARGET_NUCLEO_F401RE) || \
defined(TARGET_STEVAL_3DP001V1) || \
defined(TARGET_NUCLEO_F411RE) || \
defined(TARGET_NUCLEO_F412ZG) || \
defined(TARGET_NUCLEO_F413ZH) || \

5
features/unsupported/USBHost/targets/TARGET_STM/USBHALHost_STM.h
View File

@ -259,6 +259,11 @@ USBHALHost::USBHALHost()
pin_function(PA_10, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_PULLUP, GPIO_AF10_OTG_FS)); // ID
pin_function(PC_11, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); // VBUS
#elif defined(TARGET_STEVAL_3DP001V1)
__HAL_RCC_GPIOA_CLK_ENABLE();
pin_function(PA_11, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); // DM
pin_function(PA_12, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); // DP
#else
#error "USB pins are not configured !"
#endif

2
hal/ethernet_api.h
View File

@ -40,7 +40,7 @@ int ethernet_write(const char *data, int size);
// send ethernet write buffer, returning the packet size sent
int ethernet_send(void);
// recieve from ethernet buffer, returning packet size, or 0 if no packet
// receive from ethernet buffer, returning packet size, or 0 if no packet
int ethernet_receive(void);
// read size bytes in to data, return actual num bytes read (0..size)

14
hal/itm_api.h
View File

@ -1,3 +1,5 @@
/** \addtogroup hal */
/** @{*/
/* mbed Microcontroller Library
* Copyright (c) 2017 ARM Limited
*
@ -26,8 +28,7 @@ extern "C" {
#endif
/**
* @defgroup hal_itm_port ITM Stimulus Ports
*
* \defgroup itm_hal Instrumented Trace Macrocell HAL API
* @{
*/
@ -35,13 +36,6 @@ enum {
ITM_PORT_SWO = 0
};
/**@}*/
/**
* \defgroup itm_hal Instrumented Trace Macrocell HAL API
* @{
*/
/**
* @brief Target specific initialization function.
* This function is responsible for initializing and configuring
@ -89,3 +83,5 @@ uint32_t mbed_itm_send(uint32_t port, uint32_t data);
#endif
#endif /* MBED_ITM_API_H */
/**@}*/

55
hal/mbed_sleep_manager.c
View File

@ -30,44 +30,20 @@ static uint16_t deep_sleep_lock = 0U;
#ifdef MBED_SLEEP_TRACING_ENABLED
// Length of the identifier extracted from the driver name to store for logging.
#define IDENTIFIER_WIDTH 15
// Number of drivers that can be stored in the structure
#define STATISTIC_COUNT 10
typedef struct sleep_statistic {
char identifier[IDENTIFIER_WIDTH];
const char* identifier;
uint8_t count;
} sleep_statistic_t;
static sleep_statistic_t sleep_stats[STATISTIC_COUNT];
static const char* strip_path(const char* const filename)
{
char *output = strrchr(filename, '/');
if (output != NULL) {
return output + 1;
}
output = strrchr(filename, '\\');
if (output != NULL) {
return output + 1;
}
return filename;
}
static sleep_statistic_t* sleep_tracker_find(const char *const filename)
{
char temp[IDENTIFIER_WIDTH];
strncpy(temp, filename, IDENTIFIER_WIDTH);
temp[IDENTIFIER_WIDTH - 1] = '\0';
// Search for the a driver matching the current name and return it's index
for (int i = 0; i < STATISTIC_COUNT; ++i) {
if (strcmp(sleep_stats[i].identifier, temp) == 0) {
if (sleep_stats[i].identifier == filename) {
return &sleep_stats[i];
}
}
@ -77,15 +53,9 @@ static sleep_statistic_t* sleep_tracker_find(const char *const filename)
static sleep_statistic_t* sleep_tracker_add(const char* const filename)
{
char temp[IDENTIFIER_WIDTH];
strncpy(temp, filename, IDENTIFIER_WIDTH);
temp[IDENTIFIER_WIDTH - 1] = '\0';
for (int i = 0; i < STATISTIC_COUNT; ++i) {
if (sleep_stats[i].identifier[0] == '\0') {
core_util_critical_section_enter();
strncpy(sleep_stats[i].identifier, temp, sizeof(temp));
core_util_critical_section_exit();
if (sleep_stats[i].identifier == NULL) {
sleep_stats[i].identifier = filename;
return &sleep_stats[i];
}
@ -104,7 +74,7 @@ static void sleep_tracker_print_stats(void)
continue;
}
if (sleep_stats[i].identifier[0] == '\0') {
if (sleep_stats[i].identifier == NULL) {
return;
}
@ -115,34 +85,31 @@ static void sleep_tracker_print_stats(void)
void sleep_tracker_lock(const char* const filename, int line)
{
const char* const stripped_path = strip_path(filename);
sleep_statistic_t* stat = sleep_tracker_find(stripped_path);
sleep_statistic_t *stat = sleep_tracker_find(filename);
// Entry for this driver does not exist, create one.
if (stat == NULL) {
stat = sleep_tracker_add(stripped_path);
stat = sleep_tracker_add(filename);
}
core_util_atomic_incr_u8(&stat->count, 1);
debug("LOCK: %s, ln: %i, lock count: %u\r\n", stripped_path, line, deep_sleep_lock);
debug("LOCK: %s, ln: %i, lock count: %u\r\n", filename, line, deep_sleep_lock);
}
void sleep_tracker_unlock(const char* const filename, int line)
{
const char* const stripped_path = strip_path(filename);
sleep_statistic_t* stat = sleep_tracker_find(stripped_path);
sleep_statistic_t *stat = sleep_tracker_find(filename);
// Entry for this driver does not exist, something went wrong.
if (stat == NULL) {
debug("Unlocking sleep for driver that was not previously locked: %s, ln: %i\r\n", stripped_path, line);
debug("Unlocking sleep for driver that was not previously locked: %s, ln: %i\r\n", filename, line);
return;
}
core_util_atomic_decr_u8(&stat->count, 1);
debug("UNLOCK: %s, ln: %i, lock count: %u\r\n", stripped_path, line, deep_sleep_lock);
debug("UNLOCK: %s, ln: %i, lock count: %u\r\n", filename, line, deep_sleep_lock);
}
#endif // MBED_SLEEP_TRACING_ENABLED

2
hal/spi_api.h
View File

@ -119,7 +119,7 @@ int spi_master_write(spi_t *obj, int value);
/** Write a block out in master mode and receive a value
*
* The total number of bytes sent and recieved will be the maximum of
* The total number of bytes sent and received will be the maximum of
* tx_length and rx_length. The bytes written will be padded with the
* value 0xff.
*

Some files were not shown because too many files have changed in this diff Show More