Porting guide¶
Implement low-level driver¶
Implementation of low-level driver is an essential part. It links middleware with actual hardware design of the device.
Its implementation must provide 4
functions:
To open/configure UART hardware
To set UART baudrate on the fly
To transmit/receive data over UART
To close/de-init UART hardware
After these functions have been implemented (check below for references),
driver must link these functions to single driver structure of type lwow_ll_drv_t
,
later used during instance initialization.
Tip
Check Low-level driver for function prototypes.
Implement system functions¶
System functions are required only if operating system mode is enabled, with LWOW_CFG_OS
.
Its implementation structure is not the same as for low-level driver,
customer needs to implement fixed functions, with pre-defined name, starting with ow_sys_
name.
System function must only support OS mutex management and has to provide:
ow_sys_mutex_create()
function to create new mutexow_sys_mutex_delete()
function to delete existing mutexow_sys_mutex_wait()
function to wait for mutex to be availableow_sys_mutex_release()
function to release (give) mutex back
Warning
Application must define LWOW_CFG_OS_MUTEX_HANDLE
for mutex type.
This shall be done in lwow_opts.h
file.
Tip
Check System functions for function prototypes.
Example: Low-level driver for WIN32¶
Example code for low-level porting on WIN32 platform. It uses native Windows features to open COM port and read/write from/to it.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | /**
* \file lwow_ll_win32.c
* \brief UART implementation for WIN32
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwOW - Lightweight onewire library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.0.0
*/
#include <stdio.h>
#include "lwow/lwow.h"
#include "windows.h"
#if !__DOXYGEN__
/* Function prototypes */
static uint8_t init(void* arg);
static uint8_t deinit(void* arg);
static uint8_t set_baudrate(uint32_t baud, void* arg);
static uint8_t transmit_receive(const uint8_t* tx, uint8_t* rx, size_t len, void* arg);
/* Win 32 LL driver for OW */
const lwow_ll_drv_t
lwow_ll_drv_win32 = {
.init = init,
.deinit = deinit,
.set_baudrate = set_baudrate,
.tx_rx = transmit_receive,
};
static HANDLE com_port;
static DCB dcb = { 0 };
static uint8_t
init(void* arg) {
dcb.DCBlength = sizeof(dcb);
/* Open virtual file as read/write */
com_port = CreateFile(L"\\\\.\\COM4",
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
0,
NULL
);
/* First read current values */
if (GetCommState(com_port, &dcb)) {
COMMTIMEOUTS timeouts;
dcb.BaudRate = 115200;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
/* Try to set com port data */
if (!SetCommState(com_port, &dcb)) {
printf("Cannot get COM port\r\n");
return 0;
}
if (GetCommTimeouts(com_port, &timeouts)) {
/* Set timeout to return immediatelly from ReadFile function */
timeouts.ReadIntervalTimeout = MAXDWORD;
timeouts.ReadTotalTimeoutConstant = 0;
timeouts.ReadTotalTimeoutMultiplier = 0;
if (!SetCommTimeouts(com_port, &timeouts)) {
printf("Cannot set COM PORT timeouts\r\n");
}
GetCommTimeouts(com_port, &timeouts);
}
} else {
printf("Cannot get COM port info\r\n");
}
return 1;
}
uint8_t
deinit(void* arg) {
/* Disable UART peripheral */
return 1;
}
uint8_t
set_baudrate(uint32_t baud, void* arg) {
/* Configure UART to selected baudrate */
dcb.BaudRate = baud;
/* Try to set com port data */
if (!SetCommState(com_port, &dcb)) {
printf("Cannot set COM port baudrate to %u bauds\r\n", (unsigned)baud);
return 0;
}
return 1;
}
uint8_t
transmit_receive(const uint8_t* tx, uint8_t* rx, size_t len, void* arg) {
/* Perform data exchange */
size_t read = 0;
DWORD br;
if (com_port != NULL) {
/*
* Flush any data in RX buffer.
* This helps to reset communication in case of on-the-fly device management
* if one-or-more device(s) are added or removed.
*
* Any noise on UART level could start byte and put it to Win buffer,
* preventing to read aligned data from it
*/
PurgeComm(com_port, PURGE_RXCLEAR | PURGE_RXABORT);
/* Write file and send data */
WriteFile(com_port, tx, len, &br, NULL);
FlushFileBuffers(com_port);
/* Read same amount of data as sent previously (loopback) */
do {
if (ReadFile(com_port, rx, (DWORD)(len - read), &br, NULL)) {
read += (size_t)br;
rx += (size_t)br;
}
} while (read < len);
}
return 1;
}
#endif /* !__DOXYGEN__ */
|
Example: Low-level driver for STM32¶
Example code for low-level porting on STM32 platform.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | /**
* \file lwow_ll_stm32.c
* \brief Generic UART implementation for STM32 MCUs
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwOW - Lightweight onewire library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.0.0
*/
/*
* How it works
*
* https://docs.majerle.eu/projects/lwow/en/latest/user-manual/hw_connection.html#
*/
#include "lwow/lwow.h"
#if !__DOXYGEN__
static uint8_t init(void* arg);
static uint8_t deinit(void* arg);
static uint8_t set_baudrate(uint32_t baud, void* arg);
static uint8_t transmit_receive(const uint8_t* tx, uint8_t* rx, size_t len, void* arg);
/* STM32 LL driver for OW */
const lwow_ll_drv_t
lwow_ll_drv_stm32 = {
.init = init,
.deinit = deinit,
.set_baudrate = set_baudrate,
.tx_rx = transmit_receive,
};
static LL_USART_InitTypeDef
usart_init;
static uint8_t
init(void* arg) {
LL_GPIO_InitTypeDef gpio_init;
/* Peripheral clock enable */
ONEWIRE_USART_CLK_EN;
ONEWIRE_TX_PORT_CLK_EN;
ONEWIRE_RX_PORT_CLK_EN;
/* Configure GPIO pins */
LL_GPIO_StructInit(&gpio_init);
gpio_init.Mode = LL_GPIO_MODE_ALTERNATE;
gpio_init.Speed = LL_GPIO_SPEED_FREQ_HIGH;
gpio_init.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
gpio_init.Pull = LL_GPIO_PULL_UP;
/* TX pin */
gpio_init.Alternate = ONEWIRE_TX_PIN_AF;
gpio_init.Pin = ONEWIRE_TX_PIN;
LL_GPIO_Init(ONEWIRE_TX_PORT, &gpio_init);
/* RX pin */
gpio_init.Alternate = ONEWIRE_RX_PIN_AF;
gpio_init.Pin = ONEWIRE_RX_PIN;
LL_GPIO_Init(ONEWIRE_RX_PORT, &gpio_init);
/* Configure UART peripherals */
LL_USART_DeInit(ONEWIRE_USART);
LL_USART_StructInit(&usart_init);
usart_init.BaudRate = 9600;
usart_init.DataWidth = LL_USART_DATAWIDTH_8B;
usart_init.StopBits = LL_USART_STOPBITS_1;
usart_init.Parity = LL_USART_PARITY_NONE;
usart_init.TransferDirection = LL_USART_DIRECTION_TX_RX;
usart_init.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
usart_init.OverSampling = LL_USART_OVERSAMPLING_16;
LL_USART_Init(ONEWIRE_USART, &usart_init);
LL_USART_ConfigAsyncMode(ONEWIRE_USART);
LWOW_UNUSED(arg);
return 1;
}
static uint8_t
deinit(void* arg) {
LL_USART_DeInit(ONEWIRE_USART);
LWOW_UNUSED(arg);
return 1;
}
static uint8_t
set_baudrate(uint32_t baud, void* arg) {
usart_init.BaudRate = baud;
LL_USART_Init(ONEWIRE_USART, &usart_init);
LL_USART_ConfigAsyncMode(ONEWIRE_USART);
LWOW_UNUSED(arg);
return 1;
}
static uint8_t
transmit_receive(const uint8_t* tx, uint8_t* rx, size_t len, void* arg) {
const uint8_t* t = tx;
uint8_t* r = rx;
/* Send byte with polling */
LL_USART_Enable(ONEWIRE_USART);
for (; len > 0; --len, ++t, ++r) {
LL_USART_TransmitData8(ONEWIRE_USART, *t);
while (!LL_USART_IsActiveFlag_TXE(ONEWIRE_USART));
while (!LL_USART_IsActiveFlag_RXNE(ONEWIRE_USART));
*r = LL_USART_ReceiveData8(ONEWIRE_USART);
}
while (!LL_USART_IsActiveFlag_TC(ONEWIRE_USART)) {}
LL_USART_Disable(ONEWIRE_USART);
LWOW_UNUSED(arg);
return 1;
}
#endif /* !__DOXYGEN__ */
|
Example: System functions for WIN32¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | /**
* \file lwow_sys_win32.c
* \brief System functions for WIN32
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwOW - Lightweight onewire library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.0.0
*/
#include "lwow/lwow.h"
#include "windows.h"
#if LWOW_CFG_OS && !__DOXYGEN__
uint8_t
lwow_sys_mutex_create(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
*mutex = CreateMutex(NULL, 0, NULL);
return 1;
}
uint8_t
lwow_sys_mutex_delete(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
CloseHandle(*mutex);
*mutex = NULL;
return 1;
}
uint8_t
lwow_sys_mutex_wait(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
return WaitForSingleObject(*mutex, INFINITE) == WAIT_OBJECT_0;
}
uint8_t
lwow_sys_mutex_release(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
return ReleaseMutex(*mutex);
}
#endif /* LWOW_CFG_OS && !__DOXYGEN__ */
|
Example: System functions for CMSIS-OS¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | /**
* \file lwow_sys_cmsis_os.c
* \brief System functions for CMSIS-OS based operating system
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwOW - Lightweight onewire library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.0.0
*/
#include "lwow/lwow.h"
#if LWOW_CFG_OS && !__DOXYGEN__
#include "cmsis_os.h"
uint8_t
lwow_sys_mutex_create(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
const osMutexAttr_t attr = {
.attr_bits = osMutexRecursive
};
*mutex = osMutexNew(&attr); /* Create new mutex */
LWOW_UNUSED(arg);
return 1;
}
uint8_t
lwow_sys_mutex_delete(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
LWOW_UNUSED(arg);
osMutexDelete(*mutex); /* Delete mutex */
return 1;
}
uint8_t
lwow_sys_mutex_wait(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
if (osMutexAcquire(*mutex, osWaitForever) != osOK) {
return 0;
}
LWOW_UNUSED(arg);
return 1;
}
uint8_t
lwow_sys_mutex_release(LWOW_CFG_OS_MUTEX_HANDLE* mutex, void* arg) {
if (osMutexRelease(*mutex) != osOK) {
return 0;
}
LWOW_UNUSED(arg);
return 1;
}
#endif /* LWOW_CFG_OS && !__DOXYGEN__ */
|
Low-Level driver for STM32 with STM32CubeMX¶
Specific low-level driver has been implemented for STM32 series of microcontrollers, to allow easy and simple link of LwOW library with projects generated with STM32CubeMX or STm32CubeIDE development tools.
Driver is based on HAL (Hardware Abstraction Layer) and it uses interrupt configuration to transmit/receive data. When customer starts a new project using CubeMX, it must:
Configure specific UART IP as async mode both directions
UART must have enabled global interrupts, to allow transmitting/receiving data using interrupts
Application must pass pointer to UART handle when calling
ow_init
function
Tip
Special example has been developed to demonstrate how can application use
multiple OneWire instances on multiple UART ports at the same time.
It uses custom argument to determine which UART handle shall be used for data transmit.
Check /examples/stm32/
folder for actual implementation.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | /**
* \file lwow_ll_stm32_hal.c
* \brief UART driver implementation for STM32 with HAL code
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwOW - Lightweight onewire library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.0.0
*/
/*
* How it works (general)
*
* https://docs.majerle.eu/projects/lwow/en/latest/user-manual/hw_connection.html#
*
* This specific driver is optimized for proejcts generated by STM32CubeMX or STM32CubeIDE with HAL drivers
* It can be used w/ or w/o operating system and it uses interrupts & polling for data receive and data transmit.
*
* Application must pass pointer to UART handle as argument to ow_init function in order
* to link OW instance with actual UART hardware used for OW instance.
*
* To use this driver, application must:
* - Enable interrupt in CubeMX to allow HAL_UART_Receive_IT functionality
* - Use pointer to UART handle when initializing ow with ow_init
*/
#include "lwow/lwow.h"
#include "main.h" /* Generated normally by CubeMX */
#if !__DOXYGEN__
static uint8_t init(void* arg);
static uint8_t deinit(void* arg);
static uint8_t set_baudrate(uint32_t baud, void* arg);
static uint8_t transmit_receive(const uint8_t* tx, uint8_t* rx, size_t len, void* arg);
/* STM32 LL driver for OW */
const lwow_ll_drv_t
lwow_ll_drv_stm32_hal = {
.init = init,
.deinit = deinit,
.set_baudrate = set_baudrate,
.tx_rx = transmit_receive,
};
static uint8_t
init(void* arg) {
UART_HandleTypeDef* huart = arg;
LWOW_ASSERT0("arg != NULL", arg != NULL);
/* Initialize UART */
HAL_UART_DeInit(huart);
return HAL_UART_Init(huart) == HAL_OK;
}
static uint8_t
deinit(void* arg) {
UART_HandleTypeDef* huart = arg;
LWOW_ASSERT0("arg != NULL", arg != NULL);
return HAL_UART_DeInit(huart);
}
static uint8_t
set_baudrate(uint32_t baud, void* arg) {
UART_HandleTypeDef* huart = arg;
LWOW_ASSERT0("arg != NULL", arg != NULL);
huart->Init.BaudRate = baud;
return init(huart);
}
static uint8_t
transmit_receive(const uint8_t* tx, uint8_t* rx, size_t len, void* arg) {
UART_HandleTypeDef* huart = arg;
uint32_t start;
LWOW_ASSERT0("arg != NULL", arg != NULL);
/* Get current HAL tick */
start = HAL_GetTick();
/* Start RX in interrupt mode */
HAL_UART_Receive_IT(huart, rx, len);
/* Process TX in polling mode */
HAL_UART_Transmit(huart, (void*)tx, len, 100);
/* Wait RX to finish */
while (huart->RxState != HAL_UART_STATE_READY) {
if (HAL_GetTick() - start > 100) {
return 0;
}
}
return 1;
}
#endif /* !__DOXYGEN__ */
|