cs_UartHandler.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Sep 20, 2020
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
 
#pragma once
 
#include <encryption/cs_AES.h>
#include <events/cs_EventListener.h>
#include <protocol/cs_UartProtocol.h>
#include <uart/cs_UartCommandHandler.h>
 
#define UART_RX_BUFFER_SIZE 192
#define UART_TX_BUFFER_SIZE 300
#define UART_TX_ENCRYPTION_BUFFER_SIZE AES_BLOCK_SIZE
//#define UART_TX_MAX_PAYLOAD_SIZE       500
 
class UartHandler : EventListener {
public:
    static UartHandler& getInstance() {
        static UartHandler instance;
        return instance;
    }
 
    void init(serial_enable_t serialEnabled);
 
    ret_code_t writeMsg(
            UartOpcodeTx opCode,
            uint8_t* data,
            uint16_t size,
            UartProtocol::Encrypt encrypt = UartProtocol::ENCRYPT_ACCORDING_TO_TYPE);
 
    ret_code_t writeMsg(UartOpcodeTx opCode);
 
    ret_code_t writeMsgStart(
            UartOpcodeTx opCode,
            uint16_t size,
            UartProtocol::Encrypt encrypt = UartProtocol::ENCRYPT_ACCORDING_TO_TYPE);
 
    ret_code_t writeMsgPart(
            UartOpcodeTx opCode,
            const uint8_t* const data,
            uint16_t size,
            UartProtocol::Encrypt encrypt = UartProtocol::ENCRYPT_ACCORDING_TO_TYPE);
 
    ret_code_t writeMsgEnd(
            UartOpcodeTx opCode, UartProtocol::Encrypt encrypt = UartProtocol::ENCRYPT_ACCORDING_TO_TYPE);
 
    void onRead(uint8_t val);
 
    void handleMsg(cs_data_t* msgData);
 
private:
    UartHandler()                      = default;
 
    UartHandler(UartHandler const&)    = delete;
 
    void operator=(UartHandler const&) = delete;
 
    // Keep up the state
    bool _initialized                  = false;
 
    UartCommandHandler _commandHandler;
 
 
    uint8_t* _readBuffer             = nullptr;
 
    uint16_t _readBufferIdx          = 0;
 
    bool _startedReading             = false;
 
    bool _escapeNextByte             = false;
 
    uint16_t _sizeToRead             = 0;
 
    bool _readBusy                   = false;
 
 
    uint8_t* _writeBuffer            = nullptr;
 
    uint8_t* _encryptionBuffer       = nullptr;
 
    uint8_t _encryptionBufferWritten = 0;
 
    uint8_t _encryptionBlocksWritten = 0;
 
    encryption_nonce_t _writeNonce;
 
    uint16_t _crc;
 
    TYPIFY(CONFIG_CROWNSTONE_ID) _stoneId = 0;
 
    cs_ret_code_t writeStartByte();
 
    cs_ret_code_t writeBytes(cs_data_t data, bool updateCrc);
 
    cs_ret_code_t writeWrapperStart(UartMsgType msgType, uint16_t payloadSize);
 
    bool mustEncrypt(UartProtocol::Encrypt encrypt, UartOpcodeTx opCode);
 
    bool mustBeEncrypted(UartOpcodeRx opCode);
 
    cs_buffer_size_t getEncryptedBufferSize(cs_buffer_size_t uartMsgSize);
 
    cs_ret_code_t writeEncryptedStart(cs_buffer_size_t uartMsgSize);
 
    cs_ret_code_t writeEncryptedPart(cs_data_t data);
 
    cs_ret_code_t writeEncryptedEnd();
 
    cs_ret_code_t writeEncryptedBlock(cs_data_t key);
 
    void writeErrorReplyStatus();
 
    void handleMsg(uint8_t* data, uint16_t size);
 
    void handleEncryptedUartMsg(uint8_t* data, uint16_t size);
 
    void handleUartMsg(uint8_t* data, uint16_t size, EncryptionAccessLevel accessLevel);
 
    void resetReadBuf();
 
    void handleEvent(event_t& event);
};