Klagarge/MSE-SoftwEng
1
0
Fork 0
Code Issues Pull Requests Releases Activity

doc: renamed project

Browse Source
This commit is contained in:
SylvanArnold
2025-04-29 13:52:54 +02:00
committed by Sylvan Arnold
parent 244e516bd8
commit 32618389d1
985 changed files with 1 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

500
pico-sensor/McuLib/src/McuShellUart.c Normal file
View File

@@ -0,0 +1,500 @@
/*!
* Copyright (c) 2020-2024, Erich Styger
*
* SPDX-License-Identifier: BSD-3-Clause
* \file
* \brief \brief Implementation of the McuShellUart module.
*/
#include "McuShellUartconfig.h"
#if McuShellUart_CONFIG_UART!=McuShellUart_CONFIG_UART_NONE
#include "McuShellUart.h"
#include "McuShell.h"
#if McuShellUart_CONFIG_USE_FREERTOS
#include "McuRTOS.h"
#else
#include "McuRB.h"
#endif
#if McuLib_CONFIG_CPU_IS_RPxxxx
#include "hardware/uart.h"
#include "hardware/irq.h"
#include "hardware/gpio.h"
#endif
#include "McuLog.h"
#if McuShellUart_CONFIG_USE_FREERTOS
static QueueHandle_t uartRxQueue;
#else
static McuRB_Handle_t rxRingBuffer;
#endif
/*********************************************************************************************************/
/* Shell interface */
/*********************************************************************************************************/
static void McuShellUart_SendChar(unsigned char ch) {
McuShellUart_CONFIG_UART_WRITE_BLOCKING(McuShellUart_CONFIG_UART_DEVICE, &ch, 1);
}
static void McuShellUart_ReadChar(uint8_t *c) {
uint8_t ch;
#if McuShellUart_CONFIG_USE_FREERTOS
if (xQueueReceive(uartRxQueue, &ch, 0)==pdPASS ) {
*c = ch; /* return received character */
} else {
*c = '\0'; /* nothing received */
}
#else
if (McuRB_Get(rxRingBuffer, &ch)!=ERR_OK) {
*c = '\0'; /* nothing received */
} else {
*c = ch; /* return received character */
}
#endif
}
static bool McuShellUart_CharPresent(void) {
#if McuShellUart_CONFIG_USE_FREERTOS
return uxQueueMessagesWaiting(uartRxQueue)!=0;
#else
return McuRB_NofElements(rxRingBuffer)!=0;
#endif
}
McuShell_ConstStdIOType McuShellUart_stdio = {
.stdIn = (McuShell_StdIO_In_FctType)McuShellUart_ReadChar,
.stdOut = (McuShell_StdIO_OutErr_FctType)McuShellUart_SendChar,
.stdErr = (McuShell_StdIO_OutErr_FctType)McuShellUart_SendChar,
.keyPressed = McuShellUart_CharPresent, /* if input is not empty */
#if McuShell_CONFIG_ECHO_ENABLED
.echoEnabled = false,
#endif
};
McuShell_ConstStdIOTypePtr McuShellUart_GetStdio(void) {
return &McuShellUart_stdio;
}
uint8_t McuShellUart_DefaultShellBuffer[McuShell_DEFAULT_SHELL_BUFFER_SIZE]; /* default buffer which can be used by the application */
/*********************************************************************************************************/
#if McuLib_CONFIG_CPU_IS_RPxxxx
/* nothing needed */
#else
void McuShellUart_CONFIG_UART_IRQ_HANDLER(void) {
uint8_t data;
uint32_t flags;
#if McuShellUart_CONFIG_USE_FREERTOS
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
#endif
uint8_t count;
flags = McuShellUart_CONFIG_UART_GET_FLAGS(McuShellUart_CONFIG_UART_DEVICE);
#if McuShellUart_CONFIG_HAS_FIFO
if (flags&kUART_RxFifoOverflowFlag) {
count = 0; /* statement to allow debugger to set a breakpoint here */
}
#endif
/* If new data arrived. */
if (flags&McuShellUart_CONFIG_UART_HW_RX_READY_FLAGS) {
#if McuShellUart_CONFIG_HAS_FIFO
count = McuShellUart_CONFIG_UART_DEVICE->RCFIFO;
#else
count = 1;
#endif
while(count!=0) {
data = McuShellUart_CONFIG_UART_READ_BYTE(McuShellUart_CONFIG_UART_DEVICE);
#if McuShellUart_CONFIG_USE_FREERTOS
(void)xQueueSendFromISR(uartRxQueue, &data, &xHigherPriorityTaskWoken);
#else
McuRB_Put(rxRingBuffer, &data);
#endif
count--;
}
}
McuShellUART_CONFIG_CLEAR_STATUS_FLAGS(McuShellUart_CONFIG_UART_DEVICE, flags|McuShellUART_CONFIG_CLEAR_EXTRA_STATUS_FLAGS);
#if McuShellUart_CONFIG_USE_FREERTOS
if (xHigherPriorityTaskWoken != pdFALSE) {
vPortYieldFromISR();
}
#endif
#if McuLib_CONFIG_CPU_IS_ARM_CORTEX_M && ((McuLib_CONFIG_CORTEX_M==4) || (McuLib_CONFIG_CORTEX_M==7))
/* ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping exception return operation might vector to incorrect interrupt.
* For Cortex-M7, if core speed much faster than peripheral register write speed, the peripheral interrupt flags may be still set after exiting ISR, this results to
* the same error similar with errata 83869. */
__DSB();
#endif
}
#endif
void McuShellUart_MuxUartPins(int uart) {
switch(uart) {
#if McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FN
case McuShellUart_CONFIG_UART_K22FN512_LPUART0_C3_C4: /* PTC3, PTC4 */
CLOCK_EnableClock(kCLOCK_PortC);
/* PORTC3 (pin 46) is configured as LPUART0_RX */
PORT_SetPinMux(PORTC, 3U, kPORT_MuxAlt7);
PORTC->PCR[3] = ((PORTC->PCR[3] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding PE field is set. */
| (uint32_t)(kPORT_PullUp));
/* PORTC4 (pin 49) is configured as LPUART0_TX */
PORT_SetPinMux(PORTC, 4U, kPORT_MuxAlt7);
PORTC->PCR[4] = ((PORTC->PCR[4] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding PE field is set. */
| (uint32_t)(kPORT_PullUp));
break;
case McuShellUart_CONFIG_UART_K22FN512_UART0_B16_B17: /* PTB16, PTB17 */
CLOCK_EnableClock(kCLOCK_PortB);
/* PORTB16 (pin 39) is configured as UART0_RX */
PORT_SetPinMux(PORTB, 16, kPORT_MuxAlt3);
PORTB->PCR[16] = ((PORTB->PCR[16] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding PE field is set. */
| (uint32_t)(kPORT_PullUp));
/* PORTB17 (pin 40) is configured as UART0_TX */
PORT_SetPinMux(PORTB, 17, kPORT_MuxAlt3);
PORTB->PCR[17] = ((PORTB->PCR[17] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding PE field is set. */
| (uint32_t)(kPORT_PullUp));
#define SOPT5_UART0TXSRC_UART_TX 0x00u /*!<@brief UART 0 transmit data source select: UART0_TX pin */
SIM->SOPT5 = ((SIM->SOPT5 &
/* Mask bits to zero which are setting */
(~(SIM_SOPT5_UART0TXSRC_MASK)))
/* UART 0 transmit data source select: UART0_TX pin. */
| SIM_SOPT5_UART0TXSRC(SOPT5_UART0TXSRC_UART_TX));
break;
case McuShellUart_CONFIG_UART_K22FN512_UART1_E1_E0:
CLOCK_EnableClock(kCLOCK_PortE);
/* PORTE0 (pin 1) is configured as UART1_TX */
PORT_SetPinMux(PORTE, 0U, kPORT_MuxAlt3);
PORTE->PCR[0] = ((PORTE->PCR[0] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding PE field is set. */
| (uint32_t)(kPORT_PullUp));
/* PORTE1 (pin 2) is configured as UART1_RX */
PORT_SetPinMux(PORTE, 1U, kPORT_MuxAlt3);
PORTE->PCR[1] = ((PORTE->PCR[1] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding PE field is set. */
| (uint32_t)(kPORT_PullUp));
#define SOPT5_UART1TXSRC_UART_TX 0x00u /*!<@brief UART 1 transmit data source select: UART1_TX pin */
SIM->SOPT5 = ((SIM->SOPT5 &
/* Mask bits to zero which are setting */
(~(SIM_SOPT5_UART0TXSRC_MASK | SIM_SOPT5_UART1TXSRC_MASK)))
/* UART 1 transmit data source select: UART1_TX pin. */
| SIM_SOPT5_UART1TXSRC(SOPT5_UART1TXSRC_UART_TX));
break;
#elif McuLib_CONFIG_CPU_VARIANT==McuLib_CONFIG_CPU_VARIANT_NXP_K22FX
#define SOPT5_UART0TXSRC_UART_TX 0x00u /*!<@brief UART 0 transmit data source select: UART0_TX pin */
#define SOPT5_UART1TXSRC_UART_TX 0x00u /*!<@brief UART 1 transmit data source select: UART1_TX pin */
case McuShellUart_CONFIG_UART_K22FX512_UART0_A1_A2:
/* PORTA1 (pin 27) is configured as UART0_RX */
PORT_SetPinMux(PORTA, 1U, kPORT_MuxAlt2);
/* PORTA2 (pin 28) is configured as UART0_TX */
PORT_SetPinMux(PORTA, 2U, kPORT_MuxAlt2);
SIM->SOPT5 = ((SIM->SOPT5 &
/* Mask bits to zero which are setting */
(~(SIM_SOPT5_UART0TXSRC_MASK | SIM_SOPT5_UART1TXSRC_MASK)))
/* UART 0 transmit data source select: UART0_TX pin. */
| SIM_SOPT5_UART0TXSRC(SOPT5_UART0TXSRC_UART_TX));
break;
case McuShellUart_CONFIG_UART_K22FX512_UART1_E1_E0:
CLOCK_EnableClock(kCLOCK_PortE);
/* PORTE0 (pin 1) is configured as UART1_TX */
PORT_SetPinMux(PORTE, 0U, kPORT_MuxAlt3);
PORTE->PCR[0] = ((PORTE->PCR[0] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding Port Pull Enable field is set. */
| (uint32_t)(kPORT_PullUp));
/* PORTE1 (pin 2) is configured as UART1_RX */
PORT_SetPinMux(PORTE, 1U, kPORT_MuxAlt3);
PORTE->PCR[1] = ((PORTE->PCR[1] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding Port Pull Enable field is set. */
| (uint32_t)(kPORT_PullUp));
SIM->SOPT5 = ((SIM->SOPT5 &
/* Mask bits to zero which are setting */
(~(SIM_SOPT5_UART0TXSRC_MASK | SIM_SOPT5_UART1TXSRC_MASK)))
/* UART 1 transmit data source select: UART1_TX pin. */
| SIM_SOPT5_UART1TXSRC(SOPT5_UART1TXSRC_UART_TX));
break;
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_K64FN1M_UART0_B16_B17
case McuShellUart_CONFIG_UART_K64FN1M_UART0_B16_B17:
/* UART0 Rx and Tx */
/* PORTB16 (pin 62) is configured as UART0_RX */
PORT_SetPinMux(PORTB, 16U, kPORT_MuxAlt3);
#define SOPT5_UART0TXSRC_UART_TX 0x00u /*!<@brief UART 0 transmit data source select: UART0_TX pin */
/* PORTB17 (pin 63) is configured as UART0_TX */
PORT_SetPinMux(PORTB, 1U, kPORT_MuxAlt3);
SIM->SOPT5 = ((SIM->SOPT5 &
/* Mask bits to zero which are setting */
(~(SIM_SOPT5_UART0TXSRC_MASK)))
/* UART 0 transmit data source select: UART0_TX pin. */
| SIM_SOPT5_UART0TXSRC(SOPT5_UART0TXSRC_UART_TX));
break;
#elif McuLib_CONFIG_CPU_IS_RPxxxx
case McuShellUart_CONFIG_UART_RP2040_UART1_GPIO4_GPIO5:
gpio_set_function(McuShellUart_CONFIG_UART_TX_PIN, GPIO_FUNC_UART);
gpio_set_function(McuShellUart_CONFIG_UART_RX_PIN, GPIO_FUNC_UART);
break;
#endif /* McuLib_CONFIG_CPU_VARIANT_NXP_K22FN */
default:
for(;;) { /* error */ }
} /* switch */
}
#if McuShellUart_CONFIG_DO_PIN_MUXING
static void InitUartMuxing(void) {
#if McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_LPC845_USART0
/* Enables clock for switch matrix.: enable */
CLOCK_EnableClock(kCLOCK_Swm);
/* USART0_TXD connect to P0_25 */
SWM_SetMovablePinSelect(SWM0, kSWM_USART0_TXD, kSWM_PortPin_P0_25);
/* USART0_RXD connect to P0_24 */
SWM_SetMovablePinSelect(SWM0, kSWM_USART0_RXD, kSWM_PortPin_P0_24);
/* Disable clock for switch matrix. */
CLOCK_DisableClock(kCLOCK_Swm);
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_K22FX512_UART0
#define SOPT5_UART0TXSRC_UART_TX 0x00u /*!<@brief UART 0 transmit data source select: UART0_TX pin */
#define SOPT5_UART1TXSRC_UART_TX 0x00u /*!<@brief UART 1 transmit data source select: UART1_TX pin */
/* PORTA1 (pin 27) is configured as UART0_RX */
PORT_SetPinMux(PORTA, 1U, kPORT_MuxAlt2);
/* PORTA2 (pin 28) is configured as UART0_TX */
PORT_SetPinMux(PORTA, 2U, kPORT_MuxAlt2);
/* PORTE0 (pin 1) is configured as UART1_TX */
PORT_SetPinMux(PORTE, 0U, kPORT_MuxAlt3);
PORTE->PCR[0] = ((PORTE->PCR[0] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding Port Pull Enable field is set. */
| (uint32_t)(kPORT_PullUp));
/* PORTE1 (pin 2) is configured as UART1_RX */
PORT_SetPinMux(PORTE, 1U, kPORT_MuxAlt3);
PORTE->PCR[1] = ((PORTE->PCR[1] &
/* Mask bits to zero which are setting */
(~(PORT_PCR_PS_MASK | PORT_PCR_PE_MASK | PORT_PCR_ISF_MASK)))
/* Pull Select: Internal pullup resistor is enabled on the corresponding pin, if the
* corresponding Port Pull Enable field is set. */
| (uint32_t)(kPORT_PullUp));
SIM->SOPT5 = ((SIM->SOPT5 &
/* Mask bits to zero which are setting */
(~(SIM_SOPT5_UART0TXSRC_MASK | SIM_SOPT5_UART1TXSRC_MASK)))
/* UART 0 transmit data source select: UART0_TX pin. */
| SIM_SOPT5_UART0TXSRC(SOPT5_UART0TXSRC_UART_TX)
/* UART 1 transmit data source select: UART1_TX pin. */
| SIM_SOPT5_UART1TXSRC(SOPT5_UART1TXSRC_UART_TX));
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_K22FN512_LPUART0_C3_C4
McuShellUart_MuxUartPins(McuShellUart_CONFIG_UART_K22FN512_LPUART0_C3_C4);
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_K22FN512_UART0_B16_B17
McuShellUart_MuxUartPins(McuShellUart_CONFIG_UART_K22FN512_UART0_B16_B17);
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_K22FN512_UART1_E1_E0
McuShellUart_MuxUartPins(McuShellUart_CONFIG_UART_K22FN512_UART1_E1_E0);
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_K64FN1M_UART0_B16_B17
McuShellUart_MuxUartPins(McuShellUart_CONFIG_UART_K64FN1M_UART0_B16_B17);
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_LPC55S16_USART0
#define IOCON_PIO_FUNC1 0x01u
#define IOCON_PIO_INV_DI 0x00u
#define IOCON_PIO_MODE_INACT 0x00u
#define IOCON_PIO_SLEW_STANDARD 0x00u
#define IOCON_PIO_OPENDRAIN_DI 0x00u
#define IOCON_PIO_DIGITAL_EN 0x0100u
#define PIO0_3_FUNC_ALT1 0x01u
#define PIO0_3_DIGIMODE_DIGITAL 0x01u
const uint32_t port0_pin29_config = (/* Pin is configured as FC0_RXD_SDA_MOSI_DATA */
IOCON_PIO_FUNC1 |
/* No addition pin function */
IOCON_PIO_MODE_INACT |
/* Standard mode, output slew rate control is enabled */
IOCON_PIO_SLEW_STANDARD |
/* Input function is not inverted */
IOCON_PIO_INV_DI |
/* Enables digital function */
IOCON_PIO_DIGITAL_EN |
/* Open drain is disabled */
IOCON_PIO_OPENDRAIN_DI);
/* PORT0 PIN29 (coords: 92) is configured as FC0_RXD_SDA_MOSI_DATA */
IOCON_PinMuxSet(IOCON, 0U, 29U, port0_pin29_config);
IOCON->PIO[0][3] = ((IOCON->PIO[0][3] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT03 (pin 83) is configured as FC3_RXD_SDA_MOSI_DATA. */
| IOCON_PIO_FUNC(PIO0_3_FUNC_ALT1)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_3_DIGIMODE_DIGITAL));
const uint32_t port0_pin30_config = (/* Pin is configured as FC0_TXD_SCL_MISO_WS */
IOCON_PIO_FUNC1 |
/* No addition pin function */
IOCON_PIO_MODE_INACT |
/* Standard mode, output slew rate control is enabled */
IOCON_PIO_SLEW_STANDARD |
/* Input function is not inverted */
IOCON_PIO_INV_DI |
/* Enables digital function */
IOCON_PIO_DIGITAL_EN |
/* Open drain is disabled */
IOCON_PIO_OPENDRAIN_DI);
/* PORT0 PIN30 (coords: 94) is configured as FC0_TXD_SCL_MISO_WS */
IOCON_PinMuxSet(IOCON, 0U, 30U, port0_pin30_config);
#elif McuShellUart_CONFIG_UART==McuShellUart_CONFIG_UART_LPC55S16_USART2
#define PIO0_27_FUNC_ALT1 0x01u
#define PIO1_24_FUNC_ALT1 0x01u
#define PIO0_27_DIGIMODE_DIGITAL 0x01u
#define PIO1_24_DIGIMODE_DIGITAL 0x01u
IOCON->PIO[0][27] = ((IOCON->PIO[0][27] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT027 (pin 27) is configured as FC2_TXD_SCL_MISO_WS. */
| IOCON_PIO_FUNC(PIO0_27_FUNC_ALT1)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_27_DIGIMODE_DIGITAL));
IOCON->PIO[1][24] = ((IOCON->PIO[1][24] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT124 (pin 3) is configured as FC2_RXD_SDA_MOSI_DATA. */
| IOCON_PIO_FUNC(PIO1_24_FUNC_ALT1)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO1_24_DIGIMODE_DIGITAL));
#endif
}
#endif /* McuShellUart_CONFIG_DO_PIN_MUXING */
static void InitUart(void) {
#if McuLib_CONFIG_CPU_IS_RPxxxx
/* nothing needed */
#else
McuShellUart_CONFIG_UART_CONFIG_STRUCT config;
status_t status;
#if McuShellUart_CONFIG_DO_PIN_MUXING
InitUartMuxing(); /* NOTE: Clocking of the UART needs still to be done in the clocks tool for the MCUXpresso SDK! */
#endif
McuShellUart_CONFIG_UART_SET_UART_CLOCK();
McuShellUart_CONFIG_UART_GET_DEFAULT_CONFIG(&config);
config.baudRate_Bps = McuShellUart_CONFIG_UART_BAUDRATE;
config.enableRx = true;
config.enableTx = true;
/* Initialize the USART with configuration. */
status = McuShellUart_CONFIG_UART_INIT(McuShellUart_CONFIG_UART_DEVICE, &config, CLOCK_GetFreq(McuShellUart_CONFIG_UART_GET_CLOCK_FREQ_SELECT));
if (status!=kStatus_Success) {
McuLog_error("failed initializing UART");
for(;;) {/* error */}
}
McuShellUart_CONFIG_UART_ENABLE_INTERRUPTS(McuShellUart_CONFIG_UART_DEVICE, McuShellUart_CONFIG_UART_ENABLE_INTERRUPT_FLAGS);
#if McuShellUart_CONFIG_USE_FREERTOS
NVIC_SetPriority(McuShellUart_CONFIG_UART_IRQ_NUMBER, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY);
#endif
EnableIRQ(McuShellUart_CONFIG_UART_IRQ_NUMBER);
#endif
}
int McuShellUart_PollChar(void) {
uint8_t ch = McuShellUart_CONFIG_UART_READ_BYTE(McuShellUart_CONFIG_UART_DEVICE);
return ch;
}
void McuShellUart_Deinit(void) {
#if McuShellUart_CONFIG_USE_FREERTOS
vQueueDelete(uartRxQueue);
uartRxQueue = NULL;
#else
McuRB_DeinitRB(rxRingBuffer);
rxRingBuffer = NULL;
#endif
}
void McuShellUart_Init(void) {
#if McuShellUart_CONFIG_USE_FREERTOS
uartRxQueue = xQueueCreate(McuShellUart_CONFIG_UART_RX_QUEUE_LENGTH, sizeof(uint8_t));
if (uartRxQueue==NULL) {
for(;;){} /* out of memory? */
}
vQueueAddToRegistry(uartRxQueue, "UartRxQueue");
#else
McuRB_Config_t config;
McuRB_GetDefaultconfig(&config);
config.elementSize = sizeof(uint8_t);
config.nofElements = McuShellUart_CONFIG_UART_RX_QUEUE_LENGTH;
rxRingBuffer = McuRB_InitRB(&config);
if (rxRingBuffer==NULL) {
for(;;) {/* error */}
}
#endif
InitUart();
}
#endif /* McuShellUart_CONFIG_UART!=McuShellUart_CONFIG_UART_NONE*/