| /* |
| * Copyright (c) 2016, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** |
| * @file |
| * This file implements the CLI server on the UART service. |
| */ |
| |
| #include <openthread/config.h> |
| |
| #include "cli_uart.hpp" |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "utils/wrap_string.h" |
| |
| #include <openthread/cli.h> |
| #include <openthread/platform/logging.h> |
| #include <openthread/platform/uart.h> |
| |
| #include "cli/cli.hpp" |
| #include "common/code_utils.hpp" |
| #include "common/encoding.hpp" |
| #include "common/new.hpp" |
| #include "common/tasklet.hpp" |
| |
| namespace ot { |
| namespace Cli { |
| |
| static const char sCommandPrompt[] = {'>', ' '}; |
| static const char sEraseString[] = {'\b', ' ', '\b'}; |
| static const char CRNL[] = {'\r', '\n'}; |
| Uart *Uart::sUartServer; |
| |
| static otDEFINE_ALIGNED_VAR(sCliUartRaw, sizeof(Uart), uint64_t); |
| |
| extern "C" void otCliUartInit(otInstance *aInstance) |
| { |
| Uart::sUartServer = new(&sCliUartRaw) Uart(aInstance); |
| } |
| |
| Uart::Uart(otInstance *aInstance): |
| mInterpreter(aInstance) |
| { |
| mRxLength = 0; |
| mTxHead = 0; |
| mTxLength = 0; |
| mSendLength = 0; |
| |
| otPlatUartEnable(); |
| } |
| |
| extern "C" void otPlatUartReceived(const uint8_t *aBuf, uint16_t aBufLength) |
| { |
| Uart::sUartServer->ReceiveTask(aBuf, aBufLength); |
| } |
| |
| void Uart::ReceiveTask(const uint8_t *aBuf, uint16_t aBufLength) |
| { |
| const uint8_t *end; |
| |
| end = aBuf + aBufLength; |
| |
| for (; aBuf < end; aBuf++) |
| { |
| switch (*aBuf) |
| { |
| case '\r': |
| case '\n': |
| Output(CRNL, sizeof(CRNL)); |
| |
| if (mRxLength > 0) |
| { |
| mRxBuffer[mRxLength] = '\0'; |
| ProcessCommand(); |
| } |
| |
| Output(sCommandPrompt, sizeof(sCommandPrompt)); |
| |
| break; |
| |
| #ifdef OPENTHREAD_EXAMPLES_POSIX |
| |
| case 0x03: // ASCII for Ctrl-C |
| exit(EXIT_SUCCESS); |
| break; |
| #endif |
| |
| case '\b': |
| case 127: |
| if (mRxLength > 0) |
| { |
| Output(sEraseString, sizeof(sEraseString)); |
| mRxBuffer[--mRxLength] = '\0'; |
| } |
| |
| break; |
| |
| default: |
| if (mRxLength < kRxBufferSize) |
| { |
| Output(reinterpret_cast<const char *>(aBuf), 1); |
| mRxBuffer[mRxLength++] = static_cast<char>(*aBuf); |
| } |
| |
| break; |
| } |
| } |
| } |
| |
| otError Uart::ProcessCommand(void) |
| { |
| otError error = OT_ERROR_NONE; |
| |
| if (mRxBuffer[mRxLength - 1] == '\n') |
| { |
| mRxBuffer[--mRxLength] = '\0'; |
| } |
| |
| if (mRxBuffer[mRxLength - 1] == '\r') |
| { |
| mRxBuffer[--mRxLength] = '\0'; |
| } |
| |
| mInterpreter.ProcessLine(mRxBuffer, mRxLength, *this); |
| |
| mRxLength = 0; |
| |
| return error; |
| } |
| |
| int Uart::Output(const char *aBuf, uint16_t aBufLength) |
| { |
| uint16_t remaining = kTxBufferSize - mTxLength; |
| uint16_t tail; |
| |
| if (aBufLength > remaining) |
| { |
| aBufLength = remaining; |
| } |
| |
| for (int i = 0; i < aBufLength; i++) |
| { |
| tail = (mTxHead + mTxLength) % kTxBufferSize; |
| mTxBuffer[tail] = *aBuf++; |
| mTxLength++; |
| } |
| |
| Send(); |
| |
| return aBufLength; |
| } |
| |
| int Uart::OutputFormat(const char *fmt, ...) |
| { |
| char buf[kMaxLineLength]; |
| va_list ap; |
| |
| va_start(ap, fmt); |
| vsnprintf(buf, sizeof(buf), fmt, ap); |
| va_end(ap); |
| |
| return Output(buf, static_cast<uint16_t>(strlen(buf))); |
| } |
| |
| int Uart::OutputFormatV(const char *aFmt, va_list aAp) |
| { |
| char buf[kMaxLineLength]; |
| |
| vsnprintf(buf, sizeof(buf), aFmt, aAp); |
| |
| return Output(buf, static_cast<uint16_t>(strlen(buf))); |
| } |
| |
| void Uart::Send(void) |
| { |
| VerifyOrExit(mSendLength == 0); |
| |
| if (mTxLength > kTxBufferSize - mTxHead) |
| { |
| mSendLength = kTxBufferSize - mTxHead; |
| } |
| else |
| { |
| mSendLength = mTxLength; |
| } |
| |
| if (mSendLength > 0) |
| { |
| otPlatUartSend(reinterpret_cast<uint8_t *>(mTxBuffer + mTxHead), mSendLength); |
| } |
| |
| exit: |
| return; |
| } |
| |
| extern "C" void otPlatUartSendDone(void) |
| { |
| Uart::sUartServer->SendDoneTask(); |
| } |
| |
| void Uart::SendDoneTask(void) |
| { |
| mTxHead = (mTxHead + mSendLength) % kTxBufferSize; |
| mTxLength -= mSendLength; |
| mSendLength = 0; |
| |
| Send(); |
| } |
| |
| #if OPENTHREAD_CONFIG_ENABLE_DEFAULT_LOG_OUTPUT |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| void otPlatLog(otLogLevel aLogLevel, otLogRegion aLogRegion, const char *aFormat, ...) |
| { |
| if (NULL == Uart::sUartServer) |
| { |
| return; |
| } |
| |
| va_list args; |
| va_start(args, aFormat); |
| Uart::sUartServer->OutputFormatV(aFormat, args); |
| Uart::sUartServer->OutputFormat("\r\n"); |
| va_end(args); |
| |
| OT_UNUSED_VARIABLE(aLogLevel); |
| OT_UNUSED_VARIABLE(aLogRegion); |
| } |
| #ifdef __cplusplus |
| } // extern "C" |
| #endif |
| #endif // OPENTHREAD_CONFIG_ENABLE_DEFAULT_LOG_OUTPUT |
| |
| } // namespace Cli |
| } // namespace ot |