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 #8083 from ARMmbed/release-candidate 

Release candidate for mbed-os-5.10.0-rc2
pull/8162/head mbed-os-5.10.0-rc2
Anna Bridge 2018-09-12 11:35:24 +01:00 committed by GitHub
parent 3fb5781af1 4599726f1f
commit dd2d159796
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
77 changed files with 2364 additions and 446 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1666
TESTS/netsocket/README.md Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
TESTS/netsocket/eth_environment.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 139 KiB

BIN
TESTS/netsocket/wifi_environment.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 126 KiB

8
TEST_APPS/readme.md
View File

@ -21,8 +21,8 @@ You need Icetea and mbed-cli that supports Icetea, installed.
Depending on a device, there might be a default network interface type defined in the mbed-os/targets/targets.json, which is used to locate a test-config file by default.
If there is not, or you want to use a different interface than the default, you need to provide a relevant test-config -file to the mbed test with --test-config option.
The test-config file contains the necessary information for the test application, there are some test-config files located under mbed-os/tools/test-configs.
Devices which have their network drivers residing inside mbed-os can use generic test-configs like HeapBlockDeviceAndEthernetInterface.json and HeapBlockDeviceAndWifiInterface.json. Otherwise you need to use a device specific test-config.
The test-config file contains the necessary information for the test application, there are some test-config files located under mbed-os/tools/test_configs.
Devices which have their network drivers residing inside mbed-os can use generic test_configs like HeapBlockDeviceAndEthernetInterface.json and HeapBlockDeviceAndWifiInterface.json. Otherwise you need to use a device specific test-config.
### Running the tests
@ -42,10 +42,10 @@ Some devices may offer multiple network interfaces to operate with. For example,
The tests can be run for either one of those using already existing test-config -files.
To run the tests with Wi-Fi interface:
`>mbed test -m UBLOX_EVK_ODIN_W2 -t <toolchain> --icetea --test-config tools/test-configs/HeapBlockDeviceAndWifiInterface.json`
`>mbed test -m UBLOX_EVK_ODIN_W2 -t <toolchain> --icetea --test-config tools/test_configs/HeapBlockDeviceAndWifiInterface.json`
To run the tests with ethernet interface:
`>mbed test -m UBLOX_EVK_ODIN_W2 -t <toolchain> --icetea --test-config tools/test-configs/HeapBlockDeviceAndEthernetInterface.json`
`>mbed test -m UBLOX_EVK_ODIN_W2 -t <toolchain> --icetea --test-config tools/test_configs/HeapBlockDeviceAndEthernetInterface.json`
#### Providing Wi-Fi access point information

12
UNITTESTS/README.md
View File

@ -69,17 +69,17 @@ pip install "gcovr>=4.1"
> In case of running into problems see [troubleshooting](#troubleshooting) section.
`UNITTESTS/mbed_unittest.py` contains testing scripts for Mbed OS unit testing. Mbed CLI supports unit testing through `mbed unittest` command with the same arguments.
`UNITTESTS/mbed_unittest.py` contains testing scripts for Mbed OS unit testing. Mbed CLI supports unit testing through `mbed test --unittests` command with the same arguments.
### Testing with Mbed CLI
```
mbed unittest
mbed test --unittests
```
A subset of tests can be run by providing `-r` flag for the tool which runs tests matching a regular expression.
e.g. `mbed unittest --run -r features_netsocket`
e.g. `mbed test --unittests --run -r features_netsocket`
### Build manually without Python tools
@ -144,7 +144,7 @@ Run ctest dashboard test and create test results:
Python tools use gcovr to build code coverage reports. Generate html report `UNITTESTS/build/coverage/index.html` with:
```
mbed unittest --coverage html
mbed test --unittests --coverage html
```
To get coverage for a single test suite, run gcovr separately for suite coverage data directory. See [gcovr documentation](https://gcovr.com/guide.html#filter-options) for more information.
@ -211,10 +211,10 @@ A unit test definition file `unittest.cmake` requires variables to be set for a
#### Creating unit tests files with Mbed CLI
```
mbed unittest --new <FILEPATH>
mbed test --unittests --new <FILEPATH>
```
E.g. `mbed unittest --new rtos/Semaphore.cpp`
E.g. `mbed test --unittests --new rtos/Semaphore.cpp`
The generator script only creates the files required for a unit test. It does not write unit tests automatically nor does it handle source dependencies.

7
UNITTESTS/stubs/Mutex_stub.cpp
View File

@ -27,7 +27,12 @@ rtos::Mutex::~Mutex()
return;
}
osStatus rtos::Mutex::lock(unsigned int)
osStatus rtos::Mutex::lock(void)
{
return osOK;
}
osStatus rtos::Mutex::lock(uint32_t millisec)
{
return osOK;
}

8
drivers/MbedCRC.cpp
View File

@ -34,6 +34,14 @@ MbedCRC<POLY_32BIT_ANSI, 32>::MbedCRC():
mbed_crc_ctor();
}
template<>
MbedCRC<POLY_32BIT_REV_ANSI, 32>::MbedCRC():
_initial_value(~(0x0)), _final_xor(~(0x0)), _reflect_data(false), _reflect_remainder(false),
_crc_table((uint32_t *)Table_CRC_32bit_Rev_ANSI)
{
mbed_crc_ctor();
}
template<>
MbedCRC<POLY_16BIT_IBM, 16>::MbedCRC():
_initial_value(0), _final_xor(0), _reflect_data(true), _reflect_remainder(true),

27
drivers/MbedCRC.h
View File

@ -275,7 +275,7 @@ public:
p_crc = (uint32_t)(p_crc << (8 - width));
}
// Optimized algorithm for 32BitANSI does not need additional reflect_remainder
if ((TABLE == _mode) && (POLY_32BIT_ANSI == polynomial)) {
if ((TABLE == _mode) && (POLY_32BIT_REV_ANSI == polynomial)) {
*crc = (p_crc ^ _final_xor) & get_crc_mask();
} else {
*crc = (reflect_remainder(p_crc) ^ _final_xor) & get_crc_mask();
@ -415,7 +415,6 @@ private:
int32_t bitwise_compute_partial(const void *buffer, crc_data_size_t size, uint32_t *crc) const
{
MBED_ASSERT(crc != NULL);
MBED_ASSERT(buffer != NULL);
const uint8_t *data = static_cast<const uint8_t *>(buffer);
uint32_t p_crc = *crc;
@ -460,7 +459,6 @@ private:
int32_t table_compute_partial(const void *buffer, crc_data_size_t size, uint32_t *crc) const
{
MBED_ASSERT(crc != NULL);
MBED_ASSERT(buffer != NULL);
const uint8_t *data = static_cast<const uint8_t *>(buffer);
uint32_t p_crc = *crc;
@ -480,9 +478,17 @@ private:
}
} else {
uint32_t *crc_table = (uint32_t *)_crc_table;
for (crc_data_size_t i = 0; i < size; i++) {
p_crc = (p_crc >> 4) ^ crc_table[(p_crc ^ (data[i] >> 0)) & 0xf];
p_crc = (p_crc >> 4) ^ crc_table[(p_crc ^ (data[i] >> 4)) & 0xf];
if (POLY_32BIT_REV_ANSI == polynomial) {
for (crc_data_size_t i = 0; i < size; i++) {
p_crc = (p_crc >> 4) ^ crc_table[(p_crc ^ (data[i] >> 0)) & 0xf];
p_crc = (p_crc >> 4) ^ crc_table[(p_crc ^ (data[i] >> 4)) & 0xf];
}
}
else {
for (crc_data_size_t byte = 0; byte < size; byte++) {
data_byte = reflect_bytes(data[byte]) ^ (p_crc >> (width - 8));
p_crc = crc_table[data_byte] ^ (p_crc << 8);
}
}
}
*crc = p_crc & get_crc_mask();
@ -497,6 +503,11 @@ private:
MBED_STATIC_ASSERT(width <= 32, "Max 32-bit CRC supported");
#ifdef DEVICE_CRC
if (POLY_32BIT_REV_ANSI == polynomial) {
_crc_table = (uint32_t *)Table_CRC_32bit_Rev_ANSI;
_mode = TABLE;
return;
}
crc_mbed_config_t config;
config.polynomial = polynomial;
config.width = width;
@ -510,10 +521,14 @@ private:
return;
}
#endif
switch (polynomial) {
case POLY_32BIT_ANSI:
_crc_table = (uint32_t *)Table_CRC_32bit_ANSI;
break;
case POLY_32BIT_REV_ANSI:
_crc_table = (uint32_t *)Table_CRC_32bit_Rev_ANSI;
break;
case POLY_8BIT_CCITT:
_crc_table = (uint32_t *)Table_CRC_8bit_CCITT;
break;

10
drivers/QSPI.cpp
View File

@ -91,7 +91,7 @@ qspi_status_t QSPI::set_frequency(int hz)
return ret_status;
}
qspi_status_t QSPI::read(unsigned int address, char *rx_buffer, size_t *rx_length)
qspi_status_t QSPI::read(int address, char *rx_buffer, size_t *rx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
@ -115,7 +115,7 @@ qspi_status_t QSPI::read(unsigned int address, char *rx_buffer, size_t *rx_lengt
return ret_status;
}
qspi_status_t QSPI::write(unsigned int address, const char *tx_buffer, size_t *tx_length)
qspi_status_t QSPI::write(int address, const char *tx_buffer, size_t *tx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
@ -139,7 +139,7 @@ qspi_status_t QSPI::write(unsigned int address, const char *tx_buffer, size_t *t
return ret_status;
}
qspi_status_t QSPI::read(unsigned int instruction, unsigned int alt, unsigned int address, char *rx_buffer, size_t *rx_length)
qspi_status_t QSPI::read(int instruction, int alt, int address, char *rx_buffer, size_t *rx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
@ -163,7 +163,7 @@ qspi_status_t QSPI::read(unsigned int instruction, unsigned int alt, unsigned in
return ret_status;
}
qspi_status_t QSPI::write(unsigned int instruction, unsigned int alt, unsigned int address, const char *tx_buffer, size_t *tx_length)
qspi_status_t QSPI::write(int instruction, int alt, int address, const char *tx_buffer, size_t *tx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
@ -187,7 +187,7 @@ qspi_status_t QSPI::write(unsigned int instruction, unsigned int alt, unsigned i
return ret_status;
}
qspi_status_t QSPI::command_transfer(unsigned int instruction, int address, const char *tx_buffer, size_t tx_length, const char *rx_buffer, size_t rx_length)
qspi_status_t QSPI::command_transfer(int instruction, int address, const char *tx_buffer, size_t tx_length, const char *rx_buffer, size_t rx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;

34
drivers/QSPI.h
View File

@ -44,8 +44,12 @@ namespace mbed {
*
* #include "mbed.h"
*
* #define CMD_WRITE 0x02
* #define CMD_READ 0x03
* #define ADDRESS 0x1000
*
* // hardware ssel (where applicable)
* QSPI qspi_device(QSPI_PIN_IO0, QSPI_PIN_IO1, QSPI_PIN_IO2, QSPI_PIN_IO3, QSPI_PIN_SCK, QSPI_PIN_CSN); // io0, io1, io2, io3, sclk, ssel
* QSPI qspi_device(QSPI_FLASH1_IO0, QSPI_FLASH1_IO1, QSPI_FLASH1_IO2, QSPI_FLASH1_IO3, QSPI_FLASH1_SCK, QSPI_FLASH1_CSN); // io0, io1, io2, io3, sclk, ssel
*
*
* int main() {
@ -53,10 +57,14 @@ namespace mbed {
* char rx_buf[4];
* int buf_len = sizeof(tx_buf);
*
* int result = qspi_device.write( 0x12 , 0x100000 , 0 , tx_buf, &buf_len );
* if( !result ) printf("Write failed");
* int result = qspi_device.read( 0x13 , 0x100000 , 0 , rx_buf, &buf_len );
* if( !result ) printf("Read failed");
* qspi_status_t result = qspi_device.write(CMD_WRITE, 0, ADDRESS, tx_buf, &buf_len);
* if (result != QSPI_STATUS_OK) {
* printf("Write failed");
* }
* result = qspi_device.read(CMD_READ, 0, ADDRESS, rx_buf, &buf_len);
* if (result != QSPI_STATUS_OK) {
* printf("Read failed");
* }
*
* }
* @endcode
@ -118,7 +126,7 @@ public:
* @returns
* Returns QSPI_STATUS_SUCCESS on successful reads and QSPI_STATUS_ERROR on failed reads.
*/
qspi_status_t read(unsigned int address, char *rx_buffer, size_t *rx_length);
qspi_status_t read(int address, char *rx_buffer, size_t *rx_length);
/** Write to QSPI peripheral using custom write instruction
*
@ -129,12 +137,12 @@ public:
* @returns
* Returns QSPI_STATUS_SUCCESS on successful reads and QSPI_STATUS_ERROR on failed reads.
*/
qspi_status_t write(unsigned int address, const char *tx_buffer, size_t *tx_length);
qspi_status_t write(int address, const char *tx_buffer, size_t *tx_length);
/** Read from QSPI peripheral using custom read instruction, alt values
*
* @param instruction Instruction value to be used in instruction phase
* @param alt Alt value to be used in instruction phase
* @param alt Alt value to be used in Alternate-byte phase. Use -1 for ignoring Alternate-byte phase
* @param address Address to be accessed in QSPI peripheral
* @param rx_buffer Buffer for data to be read from the peripheral
* @param rx_length Pointer to a variable containing the length of rx_buffer, and on return this variable will be updated with the actual number of bytes read
@ -142,12 +150,12 @@ public:
* @returns
* Returns QSPI_STATUS_SUCCESS on successful reads and QSPI_STATUS_ERROR on failed reads.
*/
qspi_status_t read(unsigned int instruction, unsigned int alt, unsigned int address, char *rx_buffer, size_t *rx_length);
qspi_status_t read(int instruction, int alt, int address, char *rx_buffer, size_t *rx_length);
/** Write to QSPI peripheral using custom write instruction, alt values
*
* @param instruction Instruction value to be used in instruction phase
* @param alt Alt value to be used in instruction phase
* @param alt Alt value to be used in Alternate-byte phase. Use -1 for ignoring Alternate-byte phase
* @param address Address to be accessed in QSPI peripheral
* @param tx_buffer Buffer containing data to be sent to peripheral
* @param tx_length Pointer to a variable containing the length of data to be transmitted, and on return this variable will be updated with the actual number of bytes written
@ -155,12 +163,12 @@ public:
* @returns
* Returns QSPI_STATUS_SUCCESS on successful reads and QSPI_STATUS_ERROR on failed reads.
*/
qspi_status_t write(unsigned int instruction, unsigned int alt, unsigned int address, const char *tx_buffer, size_t *tx_length);
qspi_status_t write(int instruction, int alt, int address, const char *tx_buffer, size_t *tx_length);
/** Perform a transaction to write to an address(a control register) and get the status results
*
* @param instruction Instruction value to be used in instruction phase
* @param address Some instruction might require address. Use -1 for ignoring the address value
* @param address Some instruction might require address. Use -1 if no address
* @param tx_buffer Buffer containing data to be sent to peripheral
* @param tx_length Pointer to a variable containing the length of data to be transmitted, and on return this variable will be updated with the actual number of bytes written
* @param rx_buffer Buffer for data to be read from the peripheral
@ -169,7 +177,7 @@ public:
* @returns
* Returns QSPI_STATUS_SUCCESS on successful reads and QSPI_STATUS_ERROR on failed reads.
*/
qspi_status_t command_transfer(unsigned int instruction, int address, const char *tx_buffer, size_t tx_length, const char *rx_buffer, size_t rx_length);
qspi_status_t command_transfer(int instruction, int address, const char *tx_buffer, size_t tx_length, const char *rx_buffer, size_t rx_length);
protected:
/** Acquire exclusive access to this SPI bus

38
drivers/TableCRC.cpp
View File

@ -108,12 +108,48 @@ extern const uint16_t Table_CRC_16bit_IBM[MBED_CRC_TABLE_SIZE] = {
0x220, 0x8225, 0x822f, 0x22a, 0x823b, 0x23e, 0x234, 0x8231, 0x8213, 0x216, 0x21c, 0x8219
};
extern const uint32_t Table_CRC_32bit_ANSI[MBED_OPTIMIZED_CRC_TABLE_SIZE] = {
extern const uint32_t Table_CRC_32bit_ANSI[MBED_CRC_TABLE_SIZE] = {
0x0, 0x4c11db7, 0x9823b6e, 0xd4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x18aeb13, 0x54bf6a4, 0x808d07d, 0xcc9cdca,
0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
0x315d626, 0x7d4cb91, 0xa97ed48, 0xe56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x29f3d35, 0x65e2082, 0xb1d065b, 0xfdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
extern const uint32_t Table_CRC_32bit_Rev_ANSI[MBED_OPTIMIZED_CRC_TABLE_SIZE] = {
0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
};
/** @}*/
} // namespace mbed

3
drivers/TableCRC.h
View File

@ -30,7 +30,8 @@ extern const uint8_t Table_CRC_7Bit_SD[MBED_CRC_TABLE_SIZE];
extern const uint8_t Table_CRC_8bit_CCITT[MBED_CRC_TABLE_SIZE];
extern const uint16_t Table_CRC_16bit_CCITT[MBED_CRC_TABLE_SIZE];
extern const uint16_t Table_CRC_16bit_IBM[MBED_CRC_TABLE_SIZE];
extern const uint32_t Table_CRC_32bit_ANSI[MBED_OPTIMIZED_CRC_TABLE_SIZE];
extern const uint32_t Table_CRC_32bit_ANSI[MBED_CRC_TABLE_SIZE];
extern const uint32_t Table_CRC_32bit_Rev_ANSI[MBED_OPTIMIZED_CRC_TABLE_SIZE];
/** @}*/
} // namespace mbed

7
features/frameworks/mbed-coap/CHANGELOG.md
View File

@ -1,5 +1,12 @@
# Change Log
## [v4.6.3](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.6.3)
- Bug fix: Remove timed out blockwise message from resend queue. If blockwise message was timed out message was still kept in the resend queue which causes unnecessary reconnections on client side.
- Documentation: Document all the available macros.
-[Full Changelog](https://github.com/ARMmbed/mbed-coap/compare/v4.6.2...v4.6.3)
## [v4.6.2](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.6.2)
Do not clear block2 in subsequent block request.

91
features/frameworks/mbed-coap/mbed-coap/sn_config.h
View File

@ -36,7 +36,6 @@
/**
* \def SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE
*
* \brief For Message blockwising
* Init value for the maximum payload size to be sent and received at one blockwise message
* Setting of this value to 0 with SN_COAP_BLOCKWISE_ENABLED will disable this feature, and
@ -45,19 +44,8 @@
*/
#undef SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE /* 0 */ // < Must be 2^x and x is at least 4. Suitable values: 0, 16, 32, 64, 128, 256, 512 and 1024
/**
* \def COAP_DISABLE_OBS_FEATURE
*
* \brief Disables CoAP 'obs' sending feature
* as part of registration message, this might be
* needed to be enabled for some strict LWM2M server implementation.
* By default, this feature is disabled.
*/
#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.
@ -66,15 +54,20 @@
/**
* \def SN_COAP_RESENDING_QUEUE_SIZE_MSGS
*
* \brief Sets the number of messages stored
* in the resending queue. Default is 2
*/
#undef SN_COAP_RESENDING_QUEUE_SIZE_MSGS /* 2 */ // < Default re-sending queue size - defines how many messages can be stored. Setting this to 0 disables feature
/**
* \def DEFAULT_RESPONSE_TIMEOUT
* \brief Sets the CoAP re-send interval in seconds.
* By default is 10 seconds.
*/
#undef DEFAULT_RESPONSE_TIMEOUT
/**
* \def SN_COAP_RESENDING_QUEUE_SIZE_BYTES
*
* \brief Sets the size of the re-sending buffer.
* Setting this to 0 disables this feature.
* By default, this feature is disabled.
@ -83,7 +76,6 @@
/**
* \def SN_COAP_MAX_INCOMING_MESSAGE_SIZE
*
* \brief Sets the maximum size (in bytes) that
* mbed Client will allow to be handled while
* receiving big payload in blockwise mode.
@ -115,6 +107,75 @@
*/
#undef SN_COAP_BLOCKWISE_ENABLED /* 0 */
/**
* \def SN_COAP_RESENDING_MAX_COUNT
* \brief Defines how many times CoAP library tries to re-send the CoAP packet.
* By default value is 3.
*/
#undef SN_COAP_RESENDING_MAX_COUNT /* 3 */
/**
* \def SN_COAP_MAX_ALLOWED_RESENDING_COUNT
* \brief Maximum allowed count of re-sending that can be set at runtime via
* 'sn_coap_protocol_set_retransmission_parameters()' API.
* By default value is 6.
*/
#undef SN_COAP_MAX_ALLOWED_RESENDING_COUNT /* 6 */
/**
* \def SN_COAP_MAX_ALLOWED_RESPONSE_TIMEOUT
* \brief Maximum allowed re-send interval in seconds that can be set at runtime via
* 'sn_coap_protocol_set_retransmission_parameters()' API.
* By default value is 40.
*/
#undef SN_COAP_MAX_ALLOWED_RESPONSE_TIMEOUT /* 40 */
/**
* \def SN_COAP_MAX_ALLOWED_RESENDING_BUFF_SIZE_MSGS
* \brief Maximum allowed count of messages that can be stored into resend buffer at runtime via
* 'sn_coap_protocol_set_retransmission_buffer()' API.
* By default value is 6.
*/
#undef SN_COAP_MAX_ALLOWED_RESENDING_BUFF_SIZE_MSGS /* 6 */
/**
* \def SN_COAP_MAX_ALLOWED_RESENDING_BUFF_SIZE_BYTES
* \brief Maximum size of messages in bytes that can be stored into resend buffer at runtime via
* 'sn_coap_protocol_set_retransmission_buffer()' API.
* By default value is 512.
*/
#undef SN_COAP_MAX_ALLOWED_RESENDING_BUFF_SIZE_BYTES /* 512 */
/**
* \def SN_COAP_MAX_ALLOWED_DUPLICATION_MESSAGE_COUNT
* \brief Maximum allowed number of saved messages for message duplicate searching
* that can be set via 'sn_coap_protocol_set_duplicate_buffer_size' API.
* By default value is 6.
*/
#undef SN_COAP_MAX_ALLOWED_DUPLICATION_MESSAGE_COUNT
/**
* \def SN_COAP_DUPLICATION_MAX_TIME_MSGS_STORED
* \brief Maximum time in seconds howe long message is kept for duplicate detection.
* By default 60 seconds.
*/
#undef SN_COAP_DUPLICATION_MAX_TIME_MSGS_STORED
/**
* \def SN_COAP_BLOCKWISE_MAX_TIME_DATA_STORED
* \brief Maximum time in seconds how long (messages and payload) are be stored for blockwising.
* Longer time will increase the memory consumption in lossy networks.
* By default 60 seconds.
*/
#undef SN_COAP_BLOCKWISE_MAX_TIME_DATA_STORED
/**
* \def SN_COAP_MAX_INCOMING_BLOCK_MESSAGE_SIZE
* \brief Maximum size of blockwise message that can be received.
* By default 65535 bytes.
*/
#undef SN_COAP_MAX_INCOMING_BLOCK_MESSAGE_SIZE
#ifdef MBED_CLIENT_USER_CONFIG_FILE
#include MBED_CLIENT_USER_CONFIG_FILE
#endif

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

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

1
features/frameworks/mbed-coap/source/sn_coap_protocol.c
View File

@ -1559,6 +1559,7 @@ static void sn_coap_protocol_handle_blockwise_timout(struct coap_s *handle)
/* Notify the application about the time out */
removed_blocwise_msg_ptr->coap_msg_ptr->coap_status = COAP_STATUS_BUILDER_BLOCK_SENDING_FAILED;
removed_blocwise_msg_ptr->coap_msg_ptr->msg_id = removed_blocwise_msg_ptr->msg_id;
sn_coap_protocol_delete_retransmission(handle, removed_blocwise_msg_ptr->msg_id);
handle->sn_coap_rx_callback(removed_blocwise_msg_ptr->coap_msg_ptr, NULL, removed_blocwise_msg_ptr->param);
}

11
features/lorawan/lorawan_types.h
View File

@ -242,10 +242,6 @@ typedef enum lora_events {
* 'link_check_resp' callback. The result is thus transported to the application
* via callback function provided.
*
* As can be seen from declaration, mbed::Callback<void(uint8_t, uint8_t)> *link_check_resp)
* carries two parameters. First one is Demodulation Margin and the second one
* is number of gateways involved in the path to network server.
*
* 'battery_level' callback goes in the down direction, i.e., it informs
* the stack about the battery level by calling a function provided
* by the upper layers.
@ -257,11 +253,16 @@ typedef struct {
mbed::Callback<void(lorawan_event_t)> events;
/**
* Optional
* This callback is optional
*
* The first parameter to the callback function is the demodulation margin, and the second
* parameter is the number of gateways that successfully received the last request.
*/
mbed::Callback<void(uint8_t, uint8_t)> link_check_resp;
/**
* This callback is optional. If the callback is not set, the stack returns 255 to gateway.
*
* Battery level return value must follow the specification
* for DevStatusAns MAC command:
*

2
features/mbedtls/VERSION.txt
View File

@ -1 +1 @@
mbedtls-2.13.0
mbedtls-2.13.1

2
features/mbedtls/importer/Makefile
View File

@ -27,7 +27,7 @@
#
# Set the mbed TLS release to import (this can/should be edited before import)
MBED_TLS_RELEASE ?= mbedtls-2.13.0
MBED_TLS_RELEASE ?= mbedtls-2.13.1
# Translate between mbed TLS namespace and mbed namespace
TARGET_PREFIX:=../

30
features/mbedtls/inc/mbedtls/config.h
View File

@ -152,12 +152,21 @@
/**
* \def MBEDTLS_HAVE_TIME_DATE
*
* System has time.h and time(), gmtime() and the clock is correct.
* System has time.h, time(), and an implementation for
* mbedtls_platform_gmtime_r() (see below).
* The time needs to be correct (not necesarily very accurate, but at least
* the date should be correct). This is used to verify the validity period of
* X.509 certificates.
*
* Comment if your system does not have a correct clock.
*
* \note mbedtls_platform_gmtime_r() is an abstraction in platform_util.h that
* behaves similarly to the gmtime_r() function from the C standard. Refer to
* the documentation for mbedtls_platform_gmtime_r() for more information.
*
* \note It is possible to configure an implementation for
* mbedtls_platform_gmtime_r() at compile-time by using the macro
* MBEDTLS_PLATFORM_GMTIME_R_ALT.
*/
//#define MBEDTLS_HAVE_TIME_DATE
@ -3115,6 +3124,25 @@
*/
//#define MBEDTLS_PLATFORM_ZEROIZE_ALT
/**
* Uncomment the macro to let Mbed TLS use your alternate implementation of
* mbedtls_platform_gmtime_r(). This replaces the default implementation in
* platform_util.c.
*
* gmtime() is not a thread-safe function as defined in the C standard. The
* library will try to use safer implementations of this function, such as
* gmtime_r() when available. However, if Mbed TLS cannot identify the target
* system, the implementation of mbedtls_platform_gmtime_r() will default to
* using the standard gmtime(). In this case, calls from the library to
* gmtime() will be guarded by the global mutex mbedtls_threading_gmtime_mutex
* if MBEDTLS_THREADING_C is enabled. We recommend that calls from outside the
* library are also guarded with this mutex to avoid race conditions. However,
* if the macro MBEDTLS_PLATFORM_GMTIME_R_ALT is defined, Mbed TLS will
* unconditionally use the implementation for mbedtls_platform_gmtime_r()
* supplied at compile time.
*/
//#define MBEDTLS_PLATFORM_GMTIME_R_ALT
/* \} name SECTION: Customisation configuration options */
/* Target and application specific configurations */

41
features/mbedtls/inc/mbedtls/platform_util.h
View File

@ -25,7 +25,17 @@
#ifndef MBEDTLS_PLATFORM_UTIL_H
#define MBEDTLS_PLATFORM_UTIL_H
#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
#include MBEDTLS_CONFIG_FILE
#endif
#include <stddef.h>
#if defined(MBEDTLS_HAVE_TIME_DATE)
#include "mbedtls/platform_time.h"
#include <time.h>
#endif /* MBEDTLS_HAVE_TIME_DATE */
#ifdef __cplusplus
extern "C" {
@ -55,6 +65,37 @@ extern "C" {
*/
void mbedtls_platform_zeroize( void *buf, size_t len );
#if defined(MBEDTLS_HAVE_TIME_DATE)
/**
* \brief Platform-specific implementation of gmtime_r()
*
* The function is a thread-safe abstraction that behaves
* similarly to the gmtime_r() function from Unix/POSIX.
*
* Mbed TLS will try to identify the underlying platform and
* make use of an appropriate underlying implementation (e.g.
* gmtime_r() for POSIX and gmtime_s() for Windows). If this is
* not possible, then gmtime() will be used. In this case, calls
* from the library to gmtime() will be guarded by the mutex
* mbedtls_threading_gmtime_mutex if MBEDTLS_THREADING_C is
* enabled. It is recommended that calls from outside the library
* are also guarded by this mutex.
*
* If MBEDTLS_PLATFORM_GMTIME_R_ALT is defined, then Mbed TLS will
* unconditionally use the alternative implementation for
* mbedtls_platform_gmtime_r() supplied by the user at compile time.
*
* \param tt Pointer to an object containing time (in seconds) since the
* epoch to be converted
* \param tm_buf Pointer to an object where the results will be stored
*
* \return Pointer to an object of type struct tm on success, otherwise
* NULL
*/
struct tm *mbedtls_platform_gmtime_r( const mbedtls_time_t *tt,
struct tm *tm_buf );
#endif /* MBEDTLS_HAVE_TIME_DATE */
#ifdef __cplusplus
}
#endif

11
features/mbedtls/inc/mbedtls/threading.h
View File

@ -99,6 +99,17 @@ extern int (*mbedtls_mutex_unlock)( mbedtls_threading_mutex_t *mutex );
#if defined(MBEDTLS_FS_IO)
extern mbedtls_threading_mutex_t mbedtls_threading_readdir_mutex;
#endif
#if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
/* This mutex may or may not be used in the default definition of
* mbedtls_platform_gmtime_r(), but in order to determine that,
* we need to check POSIX features, hence modify _POSIX_C_SOURCE.
* With the current approach, this declaration is orphaned, lacking
* an accompanying definition, in case mbedtls_platform_gmtime_r()
* doesn't need it, but that's not a problem. */
extern mbedtls_threading_mutex_t mbedtls_threading_gmtime_mutex;
#endif /* MBEDTLS_HAVE_TIME_DATE && !MBEDTLS_PLATFORM_GMTIME_R_ALT */
#endif /* MBEDTLS_THREADING_C */
#ifdef __cplusplus

8
features/mbedtls/inc/mbedtls/version.h
View File

@ -40,16 +40,16 @@
*/
#define MBEDTLS_VERSION_MAJOR 2
#define MBEDTLS_VERSION_MINOR 13
#define MBEDTLS_VERSION_PATCH 0
#define MBEDTLS_VERSION_PATCH 1
/**
* The single version number has the following structure:
* MMNNPP00
* Major version | Minor version | Patch version
*/
#define MBEDTLS_VERSION_NUMBER 0x020D0000
#define MBEDTLS_VERSION_STRING "2.13.0"
#define MBEDTLS_VERSION_STRING_FULL "mbed TLS 2.13.0"
#define MBEDTLS_VERSION_NUMBER 0x020D0100
#define MBEDTLS_VERSION_STRING "2.13.1"
#define MBEDTLS_VERSION_STRING_FULL "mbed TLS 2.13.1"
#if defined(MBEDTLS_VERSION_C)

68
features/mbedtls/src/platform_util.c
View File

@ -20,6 +20,14 @@
* This file is part of Mbed TLS (https://tls.mbed.org)
*/
/*
* Ensure gmtime_r is available even with -std=c99; must be defined before
* config.h, which pulls in glibc's features.h. Harmless on other platforms.
*/
#if !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE 200112L
#endif
#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
@ -27,6 +35,7 @@
#endif
#include "mbedtls/platform_util.h"
#include "mbedtls/threading.h"
#include <stddef.h>
#include <string.h>
@ -65,3 +74,62 @@ void mbedtls_platform_zeroize( void *buf, size_t len )
memset_func( buf, 0, len );
}
#endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
#if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
#include <time.h>
#if !defined(_WIN32) && (defined(unix) || \
defined(__unix) || defined(__unix__) || (defined(__APPLE__) && \
defined(__MACH__)))
#include <unistd.h>
#endif /* !_WIN32 && (unix || __unix || __unix__ ||
* (__APPLE__ && __MACH__)) */
#if !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) || \
( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) && \
_POSIX_THREAD_SAFE_FUNCTIONS >= 20112L ) )
/*
* This is a convenience shorthand macro to avoid checking the long
* preprocessor conditions above. Ideally, we could expose this macro in
* platform_util.h and simply use it in platform_util.c, threading.c and
* threading.h. However, this macro is not part of the Mbed TLS public API, so
* we keep it private by only defining it in this file
*/
#if ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) )
#define PLATFORM_UTIL_USE_GMTIME
#endif /* ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) ) */
#endif /* !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) || \
( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) && \
_POSIX_THREAD_SAFE_FUNCTIONS >= 20112L ) ) */
struct tm *mbedtls_platform_gmtime_r( const mbedtls_time_t *tt,
struct tm *tm_buf )
{
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
return( ( gmtime_s( tm_buf, tt ) == 0 ) ? tm_buf : NULL );
#elif !defined(PLATFORM_UTIL_USE_GMTIME)
return( gmtime_r( tt, tm_buf ) );
#else
struct tm *lt;
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_lock( &mbedtls_threading_gmtime_mutex ) != 0 )
return( NULL );
#endif /* MBEDTLS_THREADING_C */
lt = gmtime( tt );
if( lt != NULL )
{
memcpy( tm_buf, lt, sizeof( struct tm ) );
}
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &mbedtls_threading_gmtime_mutex ) != 0 )
return( NULL );
#endif /* MBEDTLS_THREADING_C */
return( ( lt == NULL ) ? NULL : tm_buf );
#endif /* _WIN32 && !EFIX64 && !EFI32 */
}
#endif /* MBEDTLS_HAVE_TIME_DATE && MBEDTLS_PLATFORM_GMTIME_R_ALT */

47
features/mbedtls/src/threading.c
View File

@ -19,6 +19,14 @@
* This file is part of mbed TLS (https://tls.mbed.org)
*/
/*
* Ensure gmtime_r is available even with -std=c99; must be defined before
* config.h, which pulls in glibc's features.h. Harmless on other platforms.
*/
#if !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE 200112L
#endif
#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
@ -29,6 +37,36 @@
#include "mbedtls/threading.h"
#if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
#if !defined(_WIN32) && (defined(unix) || \
defined(__unix) || defined(__unix__) || (defined(__APPLE__) && \
defined(__MACH__)))
#include <unistd.h>
#endif /* !_WIN32 && (unix || __unix || __unix__ ||
* (__APPLE__ && __MACH__)) */
#if !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) || \
( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) && \
_POSIX_THREAD_SAFE_FUNCTIONS >= 20112L ) )
/*
* This is a convenience shorthand macro to avoid checking the long
* preprocessor conditions above. Ideally, we could expose this macro in
* platform_util.h and simply use it in platform_util.c, threading.c and
* threading.h. However, this macro is not part of the Mbed TLS public API, so
* we keep it private by only defining it in this file
*/
#if ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) )
#define THREADING_USE_GMTIME
#endif /* ! ( defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) ) */
#endif /* !( ( defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L ) || \
( defined(_POSIX_THREAD_SAFE_FUNCTIONS ) && \
_POSIX_THREAD_SAFE_FUNCTIONS >= 20112L ) ) */
#endif /* MBEDTLS_HAVE_TIME_DATE && !MBEDTLS_PLATFORM_GMTIME_R_ALT */
#if defined(MBEDTLS_THREADING_PTHREAD)
static void threading_mutex_init_pthread( mbedtls_threading_mutex_t *mutex )
{
@ -114,6 +152,9 @@ void mbedtls_threading_set_alt( void (*mutex_init)( mbedtls_threading_mutex_t *
#if defined(MBEDTLS_FS_IO)
mbedtls_mutex_init( &mbedtls_threading_readdir_mutex );
#endif
#if defined(THREADING_USE_GMTIME)
mbedtls_mutex_init( &mbedtls_threading_gmtime_mutex );
#endif
}
/*
@ -124,6 +165,9 @@ void mbedtls_threading_free_alt( void )
#if defined(MBEDTLS_FS_IO)
mbedtls_mutex_free( &mbedtls_threading_readdir_mutex );
#endif
#if defined(THREADING_USE_GMTIME)
mbedtls_mutex_free( &mbedtls_threading_gmtime_mutex );
#endif
}
#endif /* MBEDTLS_THREADING_ALT */
@ -136,5 +180,8 @@ void mbedtls_threading_free_alt( void )
#if defined(MBEDTLS_FS_IO)
mbedtls_threading_mutex_t mbedtls_threading_readdir_mutex MUTEX_INIT;
#endif
#if defined(THREADING_USE_GMTIME)
mbedtls_threading_mutex_t mbedtls_threading_gmtime_mutex MUTEX_INIT;
#endif
#endif /* MBEDTLS_THREADING_C */

11
features/mbedtls/src/x509.c
View File

@ -29,10 +29,6 @@
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
*/
/* Ensure gmtime_r is available even with -std=c99; must be included before
* config.h, which pulls in glibc's features.h. Harmless on other platforms. */
#define _POSIX_C_SOURCE 200112L
#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
@ -67,6 +63,7 @@
#include "mbedtls/platform_time.h"
#endif
#if defined(MBEDTLS_HAVE_TIME_DATE)
#include "mbedtls/platform_util.h"
#include <time.h>
#endif
@ -901,11 +898,7 @@ static int x509_get_current_time( mbedtls_x509_time *now )
int ret = 0;
tt = mbedtls_time( NULL );
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
lt = gmtime_s( &tm_buf, &tt ) == 0 ? &tm_buf : NULL;
#else
lt = gmtime_r( &tt, &tm_buf );
#endif
lt = mbedtls_platform_gmtime_r( &tt, &tm_buf );
if( lt == NULL )
ret = -1;

1
features/nfc/source/nfc/NFCEEPROM.cpp
View File

@ -397,6 +397,7 @@ void NFCEEPROM::continue_read()
_driver->read_bytes(_eeprom_address, ac_buffer_builder_write_position(buffer_builder), _ndef_buffer_read_sz - _eeprom_address);
} else {
// Done, close session
_current_op = nfc_eeprom_read_end_session;
_operation_result = NFC_OK;
_driver->end_session();
}

394
features/storage/TESTS/filesystem/general_filesystem/main.cpp
View File

File diff suppressed because it is too large Load Diff

7
features/storage/filesystem/littlefs/LittleFileSystem.cpp
View File

@ -18,7 +18,14 @@
#include "errno.h"
#include "lfs.h"
#include "lfs_util.h"
#include "MbedCRC.h"
extern "C" void lfs_crc(uint32_t *crc, const void *buffer, size_t size)
{
uint32_t initial_xor = *crc;
MbedCRC<POLY_32BIT_REV_ANSI, 32> ct(initial_xor, 0x0, true, false);
ct.compute((void *)buffer, size, (uint32_t *) crc);
}
////// Conversion functions //////
static int lfs_toerror(int err)

9
features/storage/filesystem/littlefs/littlefs/lfs_util.c
View File

@ -6,11 +6,10 @@
*/
#include "lfs_util.h"
// Only compile if user does not provide custom config
#ifndef LFS_CONFIG
// Software CRC implementation with small lookup table
#ifndef __MBED__
void lfs_crc(uint32_t *restrict crc, const void *buffer, size_t size) {
static const uint32_t rtable[16] = {
0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
@ -20,12 +19,10 @@ void lfs_crc(uint32_t *restrict crc, const void *buffer, size_t size) {
};
const uint8_t *data = buffer;
for (size_t i = 0; i < size; i++) {
*crc = (*crc >> 4) ^ rtable[(*crc ^ (data[i] >> 0)) & 0xf];
*crc = (*crc >> 4) ^ rtable[(*crc ^ (data[i] >> 4)) & 0xf];
}
}
#endif
#endif

10
features/storage/system_storage/SystemStorage.cpp
View File

@ -80,15 +80,17 @@ MBED_WEAK FileSystem *FileSystem::get_default_instance()
{
#if COMPONENT_SPIF || COMPONENT_DATAFLASH
static LittleFileSystem default_fs("fs", BlockDevice::get_default_instance());
static LittleFileSystem flash("flash", BlockDevice::get_default_instance());
flash.set_as_default();
return &default_fs;
return &flash;
#elif COMPONENT_SD
static FATFileSystem default_fs("fs", BlockDevice::get_default_instance());
static FATFileSystem sdcard("sd", BlockDevice::get_default_instance());
sdcard.set_as_default();
return &default_fs;
return &sdcard;
#else

1
hal/crc_api.h
View File

@ -33,6 +33,7 @@ typedef enum crc_polynomial {
POLY_16BIT_CCITT = 0x1021, // x16+x12+x5+1
POLY_16BIT_IBM = 0x8005, // x16+x15+x2+1
POLY_32BIT_ANSI = 0x04C11DB7, // x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
POLY_32BIT_REV_ANSI = 0xEDB88320
} crc_polynomial_t;
typedef struct crc_mbed_config {

24
platform/FileBase.cpp
View File

@ -13,6 +13,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <cstring>
#include "platform/FileBase.h"
#include "platform/FileLike.h"
#include "platform/FileHandle.h"
@ -21,6 +23,7 @@ namespace mbed {
FileBase *FileBase::_head = NULL;
SingletonPtr<PlatformMutex> FileBase::_mutex;
FileBase *FileBase::_default = NULL;
FileBase::FileBase(const char *name, PathType t) : _next(NULL),
_name(name),
@ -52,26 +55,41 @@ FileBase::~FileBase()
p->_next = _next;
}
}
if (_default == this) {
_default == NULL;
}
_mutex->unlock();
if (getPathType() == FilePathType) {
extern void remove_filehandle(FileHandle * file);
remove_filehandle(static_cast<FileHandle *>(static_cast<FileLike *>(this)));
extern void remove_filehandle(FileHandle *file);
remove_filehandle(static_cast<FileLike *>(this));
}
}
void FileBase::set_as_default()
{
_mutex->lock();
_default = this;
_mutex->unlock();
}
FileBase *FileBase::lookup(const char *name, unsigned int len)
{
_mutex->lock();
FileBase *p = _head;
while (p != NULL) {
/* Check that p->_name matches name and is the correct length */
if (p->_name != NULL && std::strncmp(p->_name, name, len) == 0 && std::strlen(p->_name) == len) {
if (p->_name != NULL && len == std::strlen(p->_name) && std::memcmp(p->_name, name, len) == 0) {
_mutex->unlock();
return p;
}
p = p->_next;
}
if (len == (sizeof "default") - 1 && std::memcmp("default", name, len) == 0) {
return _default;
}
_mutex->unlock();
return NULL;
}

7
platform/FileBase.h
View File

@ -18,9 +18,6 @@
typedef int FILEHANDLE;
#include <cstdio>
#include <cstring>
#include "platform/platform.h"
#include "platform/SingletonPtr.h"
#include "platform/PlatformMutex.h"
@ -55,9 +52,11 @@ public:
static FileBase *get(int n);
/* disallow copy constructor and assignment operators */
void set_as_default();
private:
static FileBase *_head;
static FileBase *_default;
static SingletonPtr<PlatformMutex> _mutex;
FileBase *_next;

6
platform/mbed_version.h
View File

@ -29,21 +29,21 @@
*
* @note 99 is default value for development version (master branch)
*/
#define MBED_MAJOR_VERSION 5
#define MBED_MAJOR_VERSION 5
/** MBED_MINOR_VERSION
* Mbed OS minor version
*
* @note 99 is default value for development version (master branch)
*/
#define MBED_MINOR_VERSION 10
#define MBED_MINOR_VERSION 10
/** MBED_PATCH_VERSION
* Mbed OS patch version
*
* @note 99 is default value for development version (master branch)
*/
#define MBED_PATCH_VERSION 0
#define MBED_PATCH_VERSION 0
#define MBED_ENCODE_VERSION(major, minor, patch) ((major)*10000 + (minor)*100 + (patch))

5
targets/TARGET_Freescale/TARGET_K20XX/TARGET_K20D50M/PinNames.h
View File

@ -236,11 +236,6 @@ typedef enum {
TSI_ELEC0 = PTB16,
TSI_ELEC1 = PTB17,
SPI_MOSI = PTD2,
SPI_MISO = PTD3,
SPI_CLK = PTD1,
SPI_PERSISTENT_MEM_CS = PTC2,
// Not connected
NC = (int)0xFFFFFFFF

5
targets/TARGET_Freescale/TARGET_KLXX/TARGET_KL25Z/PinNames.h
View File

@ -236,11 +236,6 @@ typedef enum {
TSI_ELEC0 = PTB16,
TSI_ELEC1 = PTB17,
SPI_MOSI = PTD2,
SPI_MISO = PTD3,
SPI_SCK = PTD1,
SPI_PERSISTENT_MEM_CS = PTD0,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

5
targets/TARGET_Freescale/TARGET_KLXX/TARGET_KL46Z/PinNames.h
View File

@ -242,11 +242,6 @@ typedef enum {
TSI_ELEC0 = PTB16,
TSI_ELEC1 = PTB17,
SPI_MOSI = PTD6,
SPI_MISO = PTD7,
SPI_SCK = PTD5,
SPI_PERSISTENT_MEM_CS = PTD4,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

5
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_K66F/TARGET_FRDM/PinNames.h
View File

@ -242,11 +242,6 @@ typedef enum {
DAC0_OUT = 0xFEFE, /* DAC does not have Pin Name in RM */
SPI_MOSI = PTE3,
SPI_MISO = PTE1,
SPI_SCK = PTE2,
SPI_PERSISTENT_MEM_CS = PTE4,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

5
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_KL43Z/TARGET_FRDM/PinNames.h
View File

@ -134,11 +134,6 @@ typedef enum {
A4 = PTC2,
A5 = PTC1,
SPI_MOSI = PTD6,
SPI_MISO = PTD7,
SPI_SCK = PTD5,
SPI_PERSISTENT_MEM_CS = PTD4,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

5
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_MCU_K22F/TARGET_MCU_K22F512/TARGET_FRDM/PinNames.h
View File

@ -243,11 +243,6 @@ typedef enum {
DAC0_OUT = 0xFEFE, /* DAC does not have Pin Name in RM */
SPI_MOSI = PTD6,
SPI_MISO = PTD7,
SPI_SCK = PTD5,
SPI_PERSISTENT_MEM_CS = PTD4,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

10
targets/TARGET_NORDIC/TARGET_NRF5x/TARGET_NRF52/TARGET_MCU_NRF52832/device/TOOLCHAIN_ARM_STD/nRF52832.sct
View File

@ -9,13 +9,13 @@
#define MBED_APP_SIZE 0x80000
#endif
/* If app_start is 0, do not set aside space for the softdevice */
#if MBED_APP_START == 0
#define MBED_RAM_START 0x20000000
#define MBED_RAM_SIZE 0x10000
#else
/* If softdevice is present, set aside space for it */
#if defined(SOFTDEVICE_PRESENT)
#define MBED_RAM_START 0x200031D0
#define MBED_RAM_SIZE 0xCE30
#else
#define MBED_RAM_START 0x20000000
#define MBED_RAM_SIZE 0x10000
#endif
#define MBED_RAM0_START MBED_RAM_START

10
targets/TARGET_NORDIC/TARGET_NRF5x/TARGET_NRF52/TARGET_MCU_NRF52832/device/TOOLCHAIN_GCC_ARM/NRF52832.ld
View File

@ -25,13 +25,13 @@
#define MBED_APP_SIZE 0x80000
#endif
/* If app_start is 0, do not set aside space for the softdevice */
#if MBED_APP_START == 0
#define MBED_RAM_START 0x20000000
#define MBED_RAM_SIZE 0x10000
#else
/* If softdevice is present, set aside space for it */
#if defined(SOFTDEVICE_PRESENT)
#define MBED_RAM_START 0x200031D0
#define MBED_RAM_SIZE 0xCE30
#else
#define MBED_RAM_START 0x20000000
#define MBED_RAM_SIZE 0x10000
#endif
#define MBED_RAM0_START MBED_RAM_START

10
targets/TARGET_NORDIC/TARGET_NRF5x/TARGET_NRF52/TARGET_MCU_NRF52832/device/TOOLCHAIN_IAR/nRF52832.icf
View File

@ -11,13 +11,13 @@ if (!isdefinedsymbol(MBED_APP_SIZE)) {
define symbol MBED_APP_SIZE = 0x80000;
}
/* If app_start is 0, do not set aside space for the softdevice */
if (MBED_APP_START == 0) {
define symbol MBED_RAM_START = 0x20000000;
define symbol MBED_RAM_SIZE = 0x10000;
} else {
/* If softdevice is present, set aside space for it */
if (isdefinedsymbol(SOFTDEVICE_PRESENT)) {
define symbol MBED_RAM_START = 0x200031D0;
define symbol MBED_RAM_SIZE = 0xCE30;
} else {
define symbol MBED_RAM_START = 0x20000000;
define symbol MBED_RAM_SIZE = 0x10000;
}
define symbol MBED_RAM0_START = MBED_RAM_START;

5
targets/TARGET_NORDIC/TARGET_NRF5x/TARGET_NRF52/TARGET_MCU_NRF52840/TARGET_NRF52840_DK/PinNames.h
View File

@ -197,11 +197,6 @@ typedef enum {
SPIS_PSELMISO = P1_3,
SPIS_PSELSS = P1_1,
SPIS_PSELSCK = P1_4,
SPI_MOSI = p20,
SPI_MISO = p21,
SPI_SCK = p19,
SPI_PERSISTENT_MEM_CS = p17,
I2C_SDA0 = p26,
I2C_SCL0 = p27,

5
targets/TARGET_NUVOTON/TARGET_M451/PinNames.h
View File

@ -128,11 +128,6 @@ typedef enum {
SW2 = PA_15,
SW3 = PA_14,
SPI_MOSI = PD_13,
SPI_MISO = PD_14,
SPI_SCK = PD_15,
SPI_PERSISTENT_MEM_CS = PD_12,
} PinName;
#ifdef __cplusplus

5
targets/TARGET_NUVOTON/TARGET_M480/PinNames.h
View File

@ -128,11 +128,6 @@ typedef enum {
SW2 = PG_15,
SW3 = PF_11,
SPI_MOSI = D11,
SPI_MISO = D12,
SPI_SCK = D13,
SPI_PERSISTENT_MEM_CS = D10,
} PinName;
#ifdef __cplusplus

5
targets/TARGET_NUVOTON/TARGET_NUC472/PinNames.h
View File

@ -131,11 +131,6 @@ typedef enum {
SW1 = PC_12,
SW2 = PC_13,
SPI_MOSI = PF_0,
SPI_MISO = PD_15,
SPI_SCK = PD_14,
SPI_PERSISTENT_MEM_CS = PD_13,
} PinName;
#ifdef __cplusplus

5
targets/TARGET_NXP/TARGET_LPC11UXX/TARGET_LPC11U37H_401/PinNames.h
View File

@ -148,11 +148,6 @@ typedef enum {
SDSCLK = P1_29,
SDSSEL = P1_12,
SPI_MOSI = SDMOSI,
SPI_MISO = SDMISO,
SPI_SCK = SDSCLK,
SPI_PERSISTENT_MEM_CS = SDSSEL,
// Not connected
NC = (int)0xFFFFFFFF,
} PinName;

6
targets/TARGET_NXP/TARGET_LPC176X/TARGET_MBED_LPC1768/PinNames.h
View File

@ -149,12 +149,6 @@ typedef enum {
I2C_SDA2 = P0_10, // pin used by application board
I2C_SCL = I2C_SCL2,
I2C_SDA = I2C_SDA2,
SPI_MOSI = p5,
SPI_MISO = p6,
SPI_SCK = p7,
SPI_PERSISTENT_MEM_CS = p8
} PinName;
typedef enum {

5
targets/TARGET_NXP/TARGET_LPC176X/TARGET_XBED_LPC1768/PinNames.h
View File

@ -117,11 +117,6 @@ typedef enum {
I2C_SCL = D15,
I2C_SDA = D14,
SPI_MOSI = p5,
SPI_MISO = p6,
SPI_SCK = p7,
SPI_PERSISTENT_MEM_CS = p8,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

8
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC54114/TARGET_LPCXpresso/PinNames.h
View File

@ -128,13 +128,7 @@ typedef enum {
A2 = P1_8,
A3 = P1_10,
A4 = P1_4,
A5 = P1_5,
SPI_MOSI = P0_20,
SPI_MISO = P0_18,
SPI_SCK = P0_19,
SPI_PERSISTENT_MEM_CS = P1_2
A5 = P1_5
} PinName;

5
targets/TARGET_RENESAS/TARGET_RZ_A1XX/TARGET_GR_LYCHEE/PinNames.h
View File

@ -89,11 +89,6 @@ typedef enum {
// Standardized button names
BUTTON1 = USER_BUTTON0,
SPI_MOSI = P5_6,
SPI_MISO = P5_7,
SPI_SCK = P5_4,
SPI_PERSISTENT_MEM_CS = P5_5,
// Not connected
NC = (int)0xFFFFFFFF
} PinName;

4
targets/TARGET_Realtek/TARGET_AMEBA/TARGET_RTL8195A/PinNames.h
View File

@ -216,9 +216,7 @@ typedef enum {
D15 = PB_2,
D16 = PA_1,
D17 = PA_0,
D18 = PE_5,
SPI_PERSISTENT_MEM_CS = D9
D18 = PE_5
} PinName;

1
targets/TARGET_STM/TARGET_STM32F0/TARGET_DISCO_F051R8/PinNames.h
View File

@ -228,7 +228,6 @@ typedef enum {
SPI_MISO = PA_6,
SPI_SCK = PA_5,
SPI_CS = PB_6,
SPI_PERSISTENT_MEM_CS = PB_6,
PWM_OUT = PB_3,
/**** OSCILLATOR pins ****/

3
targets/TARGET_STM/TARGET_STM32F4/TARGET_MTB_MTS_DRAGONFLY/PinNames.h
View File

@ -186,12 +186,9 @@ typedef enum {
SPI_MOSI = SPI1_MOSI,
SPI_MISO = SPI1_MISO,
SPI_SCK = SPI1_SCK,
SPI_CS1 = PA_3, //LCD CS
SPI_CS2 = PA_15, //SD Card CS
SPI_PERSISTENT_MEM_CS = SPI_CS2,
SERIAL_TX = PA_2,
SERIAL_RX = PA_3,
SERIAL_RTS = PA_0,

1
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F412xG/TARGET_MTB_MXCHIP_EMW3166/PinNames.h
View File

@ -219,7 +219,6 @@ typedef enum {
SPI_MISO = P_7,
SPI_SCK = P_6,
SPI_CS = P_5,
SPI_PERSISTENT_MEM_CS = P_33,
// STDIO for console print
#ifdef MBED_CONF_TARGET_STDIO_UART_TX

1
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F412xG/TARGET_USI_WM_BN_BM_22/PinNames.h
View File

@ -271,7 +271,6 @@ typedef enum {
SPI_MISO = P_25,
SPI_SCK = P_24,
SPI_CS = P_22,
SPI_PERSISTENT_MEM_CS = P_36,
// STDIO for console print
#ifdef MBED_CONF_TARGET_STDIO_UART_TX

2
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F437xG/TARGET_UBLOX_C030/PinNames.h
View File

@ -151,8 +151,6 @@ typedef enum {
SPI_MISO = D12,
SPI_CLK = D13,
SPI_NSS = D10,
SPI_PERSISTENT_MEM_CS = SPI_NSS,
// STDIO for console print
#ifdef MBED_CONF_TARGET_STDIO_UART_TX

1
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F439xI/TARGET_MODULE_UBLOX_ODIN_W2/TARGET_MTB_UBLOX_ODIN_W2/PinNames.h
View File

@ -176,7 +176,6 @@ typedef enum {
SPI_MISO = SPI0_MISO,
SPI_SCK = SPI0_SCK,
SPI_CS = SPI0_CS,
SPI_PERSISTENT_MEM_CS = PG_4,
// STDIO for console print
#ifdef MBED_CONF_TARGET_STDIO_UART_TX

3
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F439xI/TARGET_MODULE_UBLOX_ODIN_W2/TARGET_UBLOX_EVK_ODIN_W2/PinNames.h
View File

@ -167,13 +167,12 @@ typedef enum {
SPI0_SCK = D13,
SPI0_CS = D10,
SPI1_CS = D9,
SPI_MOSI = SPI0_MOSI,
SPI_MISO = SPI0_MISO,
SPI_SCK = SPI0_SCK,
SPI_CS = SPI0_CS,
SPI_PERSISTENT_MEM_CS = SPI_CS,
// Standardized button names
BUTTON1 = SW0,

1
targets/TARGET_STM/TARGET_STM32L0/TARGET_NUCLEO_L031K6/PinNames.h
View File

@ -133,7 +133,6 @@ typedef enum {
SPI_MISO = PB_4,
SPI_SCK = PB_3,
SPI_CS = PA_11,
SPI_PERSISTENT_MEM_CS = PA_11,
PWM_OUT = PB_0,
/**** OSCILLATOR pins ****/

9
targets/TARGET_STM/TARGET_STM32L4/TARGET_STM32L475xG/TARGET_DISCO_L475VG_IOT01A/PinNames.h
View File

@ -239,16 +239,7 @@ typedef enum {
SPI_MISO = D12,
SPI_SCK = D13,
SPI_CS = D10,
SPI_PERSISTENT_MEM_CS = D10,
PWM_OUT = D9,
#ifdef DEVICE_QSPI
QSPI_PIN_IO0 = PE_12,
QSPI_PIN_IO1 = PE_13,
QSPI_PIN_IO2 = PE_14,
QSPI_PIN_IO3 = PE_15,
QSPI_PIN_SCK = PE_10,
QSPI_PIN_CSN = PE_11,
#endif
/**** USB pins ****/
USB_OTG_FS_DM = PA_11,

1
targets/TARGET_STM/TARGET_STM32L4/TARGET_STM32L476xG/TARGET_NUCLEO_L476RG/PinNames.h
View File

@ -208,7 +208,6 @@ typedef enum {
SPI_MISO = PA_6,
SPI_SCK = PA_5,
SPI_CS = PB_6,
SPI_PERSISTENT_MEM_CS = PB_6,
PWM_OUT = PB_3,
/**** USB pins ****/

3
targets/TARGET_STM/TARGET_STM32L4/TARGET_STM32L486xG/TARGET_MTB_ADV_WISE_1570/PinNames.h
View File

@ -124,8 +124,7 @@ typedef enum {
SPI_SCK = PA_5,
SPI_CS0 = PA_4,
SPI_CS = SPI_CS0,
SPI_PERSISTENT_MEM_CS = PB_12,
I2C1_SDA = PB_11,
I2C1_SCL = PB_10,

8
targets/TARGET_STM/TARGET_STM32L4/l4_retarget.c
View File

@ -38,8 +38,6 @@
extern uint32_t __mbed_sbrk_start;
extern uint32_t __mbed_krbs_start;
#define STM32L4_HEAP_ALIGN 32
#define STM32L4_ALIGN_UP(X, ALIGN) (((X) + (ALIGN) - 1) & ~((ALIGN) - 1))
/**
* The default implementation of _sbrk() (in platform/mbed_retarget.cpp) for GCC_ARM requires one-region model (heap and
* stack share one region), which doesn't fit two-region model (heap and stack are two distinct regions), for example,
@ -50,10 +48,10 @@ extern uint32_t __mbed_krbs_start;
void *__wrap__sbrk(int incr)
{
static uint32_t heap_ind = (uint32_t) &__mbed_sbrk_start;
uint32_t heap_ind_old = STM32L4_ALIGN_UP(heap_ind, STM32L4_HEAP_ALIGN);
uint32_t heap_ind_new = STM32L4_ALIGN_UP(heap_ind_old + incr, STM32L4_HEAP_ALIGN);
uint32_t heap_ind_old = heap_ind;
uint32_t heap_ind_new = heap_ind_old + incr;
if (heap_ind_new > &__mbed_krbs_start) {
if (heap_ind_new > (uint32_t)&__mbed_krbs_start) {
errno = ENOMEM;
return (void *) - 1;
}

8
targets/TARGET_Silicon_Labs/TARGET_EFM32/TARGET_EFR32MG12/TARGET_TB_SENSE_12/PinNames.h
View File

@ -74,13 +74,7 @@ typedef enum {
/* Board Controller */
STDIO_UART_TX = USBTX,
STDIO_UART_RX = USBRX,
SPI_MOSI = PC6,
SPI_MISO = PC7,
SPI_SCK = PC8,
SPI_PERSISTENT_MEM_CS = PC9
STDIO_UART_RX = USBRX
} PinName;
#ifdef __cplusplus

8
tools/build_api.py
View File

@ -1161,7 +1161,7 @@ def mcu_toolchain_matrix(verbose_html=False, platform_filter=None,
release_version - get the matrix for this major version number
"""
# Only use it in this function so building works without extra modules
from prettytable import PrettyTable
from prettytable import PrettyTable, HEADER
release_version = _lowercase_release_version(release_version)
version_release_targets = {}
version_release_target_names = {}
@ -1183,7 +1183,7 @@ def mcu_toolchain_matrix(verbose_html=False, platform_filter=None,
# All tests status table print
columns = prepend_columns + unique_supported_toolchains
table_printer = PrettyTable(columns)
table_printer = PrettyTable(columns, junction_char="|", hrules=HEADER)
# Align table
for col in columns:
table_printer.align[col] = "c"
@ -1271,10 +1271,10 @@ def print_build_memory_usage(report):
Positional arguments:
report - Report generated during build procedure.
"""
from prettytable import PrettyTable
from prettytable import PrettyTable, HEADER
columns_text = ['name', 'target', 'toolchain']
columns_int = ['static_ram', 'total_flash']
table = PrettyTable(columns_text + columns_int)
table = PrettyTable(columns_text + columns_int, junction_char="|", hrules=HEADER)
for col in columns_text:
table.align[col] = 'l'

4
tools/memap.py
View File

@ -19,7 +19,7 @@ import json
from argparse import ArgumentParser
from copy import deepcopy
from collections import defaultdict
from prettytable import PrettyTable
from prettytable import PrettyTable, HEADER
from jinja2 import FileSystemLoader, StrictUndefined
from jinja2.environment import Environment
@ -726,7 +726,7 @@ class MemapParser(object):
columns = ['Module']
columns.extend(self.print_sections)
table = PrettyTable(columns)
table = PrettyTable(columns, junction_char="|", hrules=HEADER)
table.align["Module"] = "l"
for col in self.print_sections:
table.align[col] = 'r'

2
tools/profiles/debug.json
View File

@ -23,7 +23,7 @@
"asm": [],
"c": ["-D__ASSERT_MSG", "-std=gnu99"],
"cxx": ["-fno-rtti", "-std=gnu++98"],
"ld": ["--verbose", "--remove", "--show_full_path"]
"ld": ["--verbose", "--remove", "--show_full_path", "--legacyalign"]
},
"ARM": {
"common": ["-c", "--gnu", "-Otime", "--split_sections",

2
tools/profiles/develop.json
View File

@ -22,7 +22,7 @@
"asm": [],
"c": ["-D__ASSERT_MSG", "-std=gnu99"],
"cxx": ["-fno-rtti", "-std=gnu++98"],
"ld": ["--show_full_path"]
"ld": ["--show_full_path", "--legacyalign"]
},
"ARM": {
"common": ["-c", "--gnu", "-Otime", "--split_sections",

2
tools/profiles/release.json
View File

@ -22,7 +22,7 @@
"asm": [],
"c": ["-D__ASSERT_MSG", "-std=gnu99"],
"cxx": ["-fno-rtti", "-std=gnu++98"],
"ld": ["--show_full_path"]
"ld": ["--show_full_path", "--legacyalign"]
},
"ARM": {
"common": ["-c", "--gnu", "-Ospace", "--split_sections",

16
tools/test_api.py
View File

@ -32,7 +32,7 @@ import threading
import ctypes
import functools
from colorama import Fore, Back, Style
from prettytable import PrettyTable
from prettytable import PrettyTable, HEADER
from copy import copy, deepcopy
from time import sleep, time
@ -766,7 +766,7 @@ class SingleTestRunner(object):
result_dict[test[TEST_INDEX]][test[TOOLCHAIN_INDEX]] = test[RESULT_INDEX]
pt_cols = ["Target", "Test ID", "Test Description"] + unique_target_toolchains
pt = PrettyTable(pt_cols)
pt = PrettyTable(pt_cols, junction_char="|", hrules=HEADER)
for col in pt_cols:
pt.align[col] = "l"
pt.padding_width = 1 # One space between column edges and contents (default)
@ -794,7 +794,7 @@ class SingleTestRunner(object):
result = "Test summary:\n"
# Pretty table package is used to print results
pt = PrettyTable(["Result", "Target", "Toolchain", "Test ID", "Test Description",
"Elapsed Time (sec)", "Timeout (sec)", "Loops"])
"Elapsed Time (sec)", "Timeout (sec)", "Loops"], junction_char="|", hrules=HEADER)
pt.align["Result"] = "l" # Left align
pt.align["Target"] = "l" # Left align
pt.align["Toolchain"] = "l" # Left align
@ -1328,7 +1328,7 @@ def print_muts_configuration_from_json(json_data, join_delim=", ", platform_filt
# Prepare pretty table object to display all MUTs
pt_cols = ["index"] + muts_info_cols
pt = PrettyTable(pt_cols)
pt = PrettyTable(pt_cols, junction_char="|", hrules=HEADER)
for col in pt_cols:
pt.align[col] = "l"
@ -1366,7 +1366,7 @@ def print_test_configuration_from_json(json_data, join_delim=", "):
# Prepare pretty table object to display test specification
pt_cols = ["mcu"] + sorted(toolchains_info_cols)
pt = PrettyTable(pt_cols)
pt = PrettyTable(pt_cols, junction_char="|", hrules=HEADER)
for col in pt_cols:
pt.align[col] = "l"
@ -1455,7 +1455,7 @@ def get_avail_tests_summary_table(cols=None, result_summary=True, join_delim=','
'duration'] if cols is None else cols
# All tests status table print
pt = PrettyTable(test_properties)
pt = PrettyTable(test_properties, junction_char="|", hrules=HEADER)
for col in test_properties:
pt.align[col] = "l"
pt.align['duration'] = "r"
@ -1495,7 +1495,7 @@ def get_avail_tests_summary_table(cols=None, result_summary=True, join_delim=','
if result_summary and not platform_filter:
# Automation result summary
test_id_cols = ['automated', 'all', 'percent [%]', 'progress']
pt = PrettyTable(test_id_cols)
pt = PrettyTable(test_id_cols, junction_char="|", hrules=HEADER)
pt.align['automated'] = "r"
pt.align['all'] = "r"
pt.align['percent [%]'] = "r"
@ -1509,7 +1509,7 @@ def get_avail_tests_summary_table(cols=None, result_summary=True, join_delim=','
# Test automation coverage table print
test_id_cols = ['id', 'automated', 'all', 'percent [%]', 'progress']
pt = PrettyTable(test_id_cols)
pt = PrettyTable(test_id_cols, junction_char="|", hrules=HEADER)
pt.align['id'] = "l"
pt.align['automated'] = "r"
pt.align['all'] = "r"

9
tools/toolchains/__init__.py
View File

@ -706,8 +706,8 @@ class mbedToolchain:
self._add_defines_from_region(region)
if region.active:
for define in [
("%s_START" % active_region_name, region.start),
("%s_SIZE" % active_region_name, region.size)
("%s_START" % active_region_name, "0x%x" % region.start),
("%s_SIZE" % active_region_name, "0x%x" % region.size)
]:
define_string = self.make_ld_define(*define)
self.ld.append(define_string)
@ -747,6 +747,11 @@ class mbedToolchain:
self.config_data = config_data
# new configuration data can change labels, so clear the cache
self.labels = None
# pass info about softdevice presence to linker (see NRF52)
if "SOFTDEVICE_PRESENT" in config_data[1]:
define_string = self.make_ld_define("SOFTDEVICE_PRESENT", config_data[1]["SOFTDEVICE_PRESENT"].macro_value)
self.ld.append(define_string)
self.flags["ld"].append(define_string)
self.add_regions()
# Creates the configuration header if needed:

4
tools/toolchains/arm.py
View File

@ -325,7 +325,7 @@ class ARM(mbedToolchain):
@staticmethod
def make_ld_define(name, value):
return "--predefine=\"-D%s=0x%x\"" % (name, value)
return "--predefine=\"-D%s=%s\"" % (name, value)
@staticmethod
def redirect_symbol(source, sync, build_dir):
@ -426,7 +426,7 @@ class ARMC6(ARM_STD):
self.flags["ld"] += ["--import_cmse_lib_out=%s" % secure_file]
# Add linking time preprocessor macro __DOMAIN_NS
if target.core == "Cortex-M23-NS" or self.target.core == "Cortex-M33-NS":
define_string = self.make_ld_define("__DOMAIN_NS", 1)
define_string = self.make_ld_define("__DOMAIN_NS", "0x1")
self.flags["ld"].append(define_string)
asm_cpu = {

2
tools/toolchains/gcc.py
View File

@ -293,7 +293,7 @@ class GCC(mbedToolchain):
@staticmethod
def make_ld_define(name, value):
return "-D%s=0x%x" % (name, value)
return "-D%s=%s" % (name, value)
@staticmethod
def redirect_symbol(source, sync, build_dir):

2
tools/toolchains/iar.py
View File

@ -273,7 +273,7 @@ class IAR(mbedToolchain):
@staticmethod
def make_ld_define(name, value):
return "--config_def %s=0x%x" % (name, value)
return "--config_def %s=%s" % (name, value)
@staticmethod
def redirect_symbol(source, sync, build_dir):