13d7e84ef3
- Implemented new app: Serial Console - `Uart::writeString()`: fixed 2 mutex bugs - `AlertDialog::start()` with default "OK" button added - Created `tt::lvgl::defaultLockTime` for re-use - Removed various usages of deprecated `lvgl::obj_set_style_no_padding()` - Implemented `hal::uart::getNames()` to list all interface names
127 lines
3.8 KiB
C++
127 lines
3.8 KiB
C++
#pragma once
|
|
|
|
#include <Tactility/RtosCompat.h>
|
|
|
|
#include "../Gpio.h"
|
|
#include "Tactility/Lock.h"
|
|
#include "UartCompat.h"
|
|
#include "Tactility/hal/uart/Configuration.h"
|
|
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace tt::hal::uart {
|
|
|
|
constexpr TickType_t defaultTimeout = 10 / portTICK_PERIOD_MS;
|
|
|
|
enum class InitMode {
|
|
ByTactility, // Tactility will initialize it in the correct bootup phase
|
|
ByExternal, // The device is already initialized and Tactility should assume it works
|
|
Disabled // Not initialized by default
|
|
};
|
|
|
|
enum class Status {
|
|
Started,
|
|
Stopped,
|
|
Unknown
|
|
};
|
|
|
|
class Uart {
|
|
|
|
private:
|
|
|
|
uint32_t id;
|
|
|
|
public:
|
|
|
|
Uart();
|
|
virtual ~Uart();
|
|
|
|
inline uint32_t getId() const { return id; }
|
|
|
|
virtual bool start() = 0;
|
|
virtual bool isStarted() const = 0;
|
|
|
|
virtual bool stop() = 0;
|
|
|
|
/**
|
|
* Read up to a specified amount of bytes
|
|
* @param[out] buffer
|
|
* @param[in] bufferSize
|
|
* @param[in] timeout
|
|
* @return the amount of bytes that were read
|
|
*/
|
|
virtual size_t readBytes(std::byte* buffer, size_t bufferSize, TickType_t timeout = defaultTimeout) = 0;
|
|
|
|
size_t readBytes(std::uint8_t* buffer, size_t bufferSize, TickType_t timeout = defaultTimeout) {
|
|
return readBytes(reinterpret_cast<std::byte*>(buffer), bufferSize, timeout);
|
|
}
|
|
|
|
/** Read a single byte */
|
|
virtual bool readByte(std::byte* output, TickType_t timeout = defaultTimeout) = 0;
|
|
|
|
inline bool readByte(char* output, TickType_t timeout = defaultTimeout) {
|
|
return readByte(reinterpret_cast<std::byte*>(output), timeout);
|
|
}
|
|
|
|
inline bool readByte(uint8_t* output, TickType_t timeout = defaultTimeout) {
|
|
return readByte(reinterpret_cast<std::byte*>(output), timeout);
|
|
}
|
|
|
|
/**
|
|
* Read up to a specified amount of bytes
|
|
* @param[in] buffer
|
|
* @param[in] bufferSize
|
|
* @param[in] timeout
|
|
* @return the amount of bytes that were read
|
|
*/
|
|
virtual size_t writeBytes(const std::byte* buffer, size_t bufferSize, TickType_t timeout = defaultTimeout) = 0;
|
|
|
|
inline size_t writeBytes(const std::uint8_t* buffer, size_t bufferSize, TickType_t timeout = defaultTimeout) {
|
|
return writeBytes(reinterpret_cast<const std::byte*>(buffer), bufferSize, timeout);
|
|
}
|
|
|
|
/** @return the amount of bytes available for reading */
|
|
virtual size_t available(TickType_t timeout = defaultTimeout) = 0;
|
|
|
|
/** Set the baud rate for the specified port */
|
|
virtual bool setBaudRate(uint32_t baudRate, TickType_t timeout = defaultTimeout) = 0;
|
|
|
|
/** Get the baud rate for the specified port */
|
|
virtual uint32_t getBaudRate() = 0;
|
|
|
|
/** Flush input buffers */
|
|
virtual void flushInput() = 0;
|
|
|
|
/**
|
|
* Write a string (excluding null terminator character)
|
|
* @param[in] buffer
|
|
* @param[in] timeout
|
|
* @return the amount of bytes that were written
|
|
*/
|
|
bool writeString(const char* buffer, TickType_t timeout = defaultTimeout);
|
|
|
|
/**
|
|
* Read a buffer as a string until the specified character (the "untilChar" is included in the result)
|
|
* @warning if the input data doesn't return "untilByte" then the device goes out of memory
|
|
*/
|
|
std::string readStringUntil(char untilChar, TickType_t timeout = defaultTimeout);
|
|
|
|
/**
|
|
* Read a buffer as a byte array until the specified character (the "untilChar" is included in the result)
|
|
* @return the amount of bytes read from UART
|
|
*/
|
|
size_t readUntil(std::byte* buffer, size_t bufferSize, uint8_t untilByte, TickType_t timeout = defaultTimeout, bool addNullTerminator = true);
|
|
};
|
|
|
|
/**
|
|
* Opens a UART.
|
|
* @param[in] name the UART name as specified in the board configuration.
|
|
* @return the UART when it was successfully opened, or nullptr when it is in use.
|
|
*/
|
|
std::unique_ptr<Uart> open(std::string name);
|
|
|
|
std::vector<std::string> getNames();
|
|
|
|
} // namespace tt::hal::uart
|