Remove old HAL components and refactored GPS-related code (#583)
- Added generic GPS/GNSS support with device detection, configuration, and persistent settings. - Improved device and module lifecycle management. - Added flexible filesystem locking support for displays and storage. - Improved display-idle and keyboard backlight handling. - Updated architecture, driver, module, testing, and licensing documentation. - Removed old HAL device and related code.
This commit is contained in:
Ken Van Hoeylandt
committed by
GitHub
GitHub
parent
29e80cfd65
commit
2a2558b29a
@@ -1,23 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
bool tt_gps_has_coordinates();
|
||||
|
||||
bool tt_gps_get_coordinates(
|
||||
float* longitude,
|
||||
float* latitude,
|
||||
float* speed,
|
||||
float* course,
|
||||
int* day,
|
||||
int* month,
|
||||
int* year
|
||||
);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,34 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
DEVICE_TYPE_I2C,
|
||||
DEVICE_TYPE_DISPLAY,
|
||||
DEVICE_TYPE_TOUCH,
|
||||
DEVICE_TYPE_SDCARD,
|
||||
DEVICE_TYPE_KEYBOARD,
|
||||
DEVICE_TYPE_POWER,
|
||||
DEVICE_TYPE_GPS
|
||||
} TtDeviceType;
|
||||
|
||||
typedef uint32_t DeviceId;
|
||||
|
||||
/**
|
||||
* Find one or more devices of a certain type.
|
||||
* @param[in] type the type to look for
|
||||
* @param[inout] deviceIds the output ids, which should fit at least maxCount amount of devices
|
||||
* @param[out] count the resulting number of device ids that were returned
|
||||
* @param[in] maxCount the maximum number of items that the "deviceIds" output can contain (minimum value is 1)
|
||||
* @return true if one or more devices were found
|
||||
*/
|
||||
bool tt_hal_device_find(TtDeviceType type, DeviceId* deviceIds, uint16_t* count, uint16_t maxCount);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,100 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <tt_hal_device.h>
|
||||
#include <stdbool.h>
|
||||
#include <freertos/FreeRTOS.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void* DisplayDriverHandle;
|
||||
|
||||
typedef enum {
|
||||
COLOR_FORMAT_MONOCHROME, // 1 bpp
|
||||
COLOR_FORMAT_BGR565,
|
||||
COLOR_FORMAT_BGR565_SWAPPED,
|
||||
COLOR_FORMAT_RGB565,
|
||||
COLOR_FORMAT_RGB565_SWAPPED,
|
||||
COLOR_FORMAT_RGB888
|
||||
} ColorFormat;
|
||||
|
||||
/**
|
||||
* Check if the display driver interface is supported for this device.
|
||||
* @param[in] displayId the identifier of the display device
|
||||
* @return true if the driver is supported.
|
||||
*/
|
||||
bool tt_hal_display_driver_supported(DeviceId displayId);
|
||||
|
||||
/**
|
||||
* Allocate a driver object for the specified displayId.
|
||||
* @warning check whether the driver is supported by calling tt_hal_display_driver_supported() first
|
||||
* @param[in] displayId the identifier of the display device
|
||||
* @return the driver handle
|
||||
*/
|
||||
DisplayDriverHandle tt_hal_display_driver_alloc(DeviceId displayId);
|
||||
|
||||
/**
|
||||
* Free the memory for the display driver.
|
||||
* @param[in] handle the display driver handle
|
||||
*/
|
||||
void tt_hal_display_driver_free(DisplayDriverHandle handle);
|
||||
|
||||
/**
|
||||
* Lock the display device. Call this function before doing any draw calls.
|
||||
* Certain display devices are on a shared bus (e.g. SPI) so they must run
|
||||
* mutually exclusive with other devices on the same bus (e.g. SD card)
|
||||
* @param[in] handle the display driver handle
|
||||
* @param[in] timeout the maximum amount of ticks to wait for getting a lock
|
||||
* @return true if the lock was acquired
|
||||
*/
|
||||
bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType_t timeout);
|
||||
|
||||
/**
|
||||
* Unlock the display device. Must be called exactly once after locking.
|
||||
* @param[in] handle the display driver handle
|
||||
*/
|
||||
void tt_hal_display_driver_unlock(DisplayDriverHandle handle);
|
||||
|
||||
/**
|
||||
* @param[in] handle the display driver handle
|
||||
* @return the native color format for this display
|
||||
*/
|
||||
ColorFormat tt_hal_display_driver_get_colorformat(DisplayDriverHandle handle);
|
||||
|
||||
/**
|
||||
* @param[in] handle the display driver handle
|
||||
* @return the horizontal resolution of the display
|
||||
*/
|
||||
uint16_t tt_hal_display_driver_get_pixel_width(DisplayDriverHandle handle);
|
||||
|
||||
/**
|
||||
* @param[in] handle the display driver handle
|
||||
* @return the vertical resolution of the display
|
||||
*/
|
||||
uint16_t tt_hal_display_driver_get_pixel_height(DisplayDriverHandle handle);
|
||||
|
||||
/**
|
||||
* Draw pixels on the screen. Make sure to call the lock function first and unlock afterwards.
|
||||
* Many draw calls can be done inbetween a single lock and unlock.
|
||||
* @param[in] handle the display driver handle
|
||||
* @param[in] xStart the starting x coordinate for rendering the pixel data
|
||||
* @param[in] yStart the starting y coordinate for rendering the pixel data
|
||||
* @param[in] xEnd the last x coordinate for rendering the pixel data (absolute pixel value, not relative to xStart!)
|
||||
* @param[in] yEnd the last y coordinate for rendering the pixel data (absolute pixel value, not relative to yStart!)
|
||||
* @param[in] pixelData a buffer of pixels. the data is placed as "RowRowRowRow". The size depends on the ColorFormat
|
||||
*/
|
||||
void tt_hal_display_driver_draw_bitmap(DisplayDriverHandle handle, int xStart, int yStart, int xEnd, int yEnd, const void* pixelData);
|
||||
|
||||
/**
|
||||
* Get direct pointers to the display's hardware frame buffer(s), if supported.
|
||||
* Only available for panels with direct CPU-addressable frame buffers (e.g. MIPI-DSI/DPI).
|
||||
* @param[in] handle the display driver handle
|
||||
* @param[out] outBuffers receives up to 2 frame buffer pointers
|
||||
* @return number of buffers written to outBuffers (0 if unsupported)
|
||||
*/
|
||||
uint8_t tt_hal_display_driver_get_frame_buffers(DisplayDriverHandle handle, void* outBuffers[2]);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,24 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** @deprecated NON-FUNCTIONAL - WILL BE REMOVED SOON */
|
||||
typedef unsigned int GpioPin;
|
||||
|
||||
/** @deprecated NON-FUNCTIONAL - WILL BE REMOVED SOON */
|
||||
#define GPIO_NO_PIN -1
|
||||
|
||||
/** @deprecated NON-FUNCTIONAL - WILL BE REMOVED SOON */
|
||||
bool tt_hal_gpio_get_level(GpioPin pin);
|
||||
|
||||
/** @deprecated NON-FUNCTIONAL - WILL BE REMOVED SOON */
|
||||
int tt_hal_gpio_get_pin_count();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,48 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "tt_hal_device.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void* TouchDriverHandle;
|
||||
/**
|
||||
* Check if the touch driver interface is supported for this device.
|
||||
* @param[in] touchDeviceId the identifier of the touch device
|
||||
* @return true if the driver is supported.
|
||||
*/
|
||||
bool tt_hal_touch_driver_supported(DeviceId touchDeviceId);
|
||||
|
||||
/**
|
||||
* Allocate a driver object for the specified touchDeviceId.
|
||||
* @warning check whether the driver is supported by calling tt_hal_touch_driver_supported() first
|
||||
* @param[in] touchDeviceId the identifier of the touch device
|
||||
* @return the driver handle
|
||||
*/
|
||||
TouchDriverHandle tt_hal_touch_driver_alloc(DeviceId touchDeviceId);
|
||||
|
||||
/**
|
||||
* Free the memory for the touch driver.
|
||||
* @param[in] handle the touch driver handle
|
||||
*/
|
||||
void tt_hal_touch_driver_free(TouchDriverHandle handle);
|
||||
|
||||
/**
|
||||
* Get the coordinates for the currently touched points on the screen.
|
||||
*
|
||||
* @param[in] handle the touch driver handle
|
||||
* @param[in] x array of X coordinates
|
||||
* @param[in] y array of Y coordinates
|
||||
* @param[in] strength array of strengths (with the minimum size of maxPointCount) or NULL
|
||||
* @param[in] pointCount the number of points currently touched on the screen
|
||||
* @param[in] maxPointCount the maximum number of points that can be touched at once
|
||||
*
|
||||
* @return true when touched and coordinates are available
|
||||
*/
|
||||
bool tt_hal_touch_driver_get_touched_points(TouchDriverHandle handle, uint16_t* x, uint16_t* y, uint16_t* strength, uint8_t* pointCount, uint8_t maxPointCount);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,159 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <freertos/FreeRTOS.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
* WARNING: THIS API IS NON-FUNCTIONAL AND DEPRECATED.
|
||||
* IT WILL BE REMOVED IN A FUTURE RELEASE ONCE OFFICIAL APPS ARE MIGRATED.
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file tt_hal_uart.h
|
||||
* @brief C HAL interface for UART devices used by Tactility C modules.
|
||||
*
|
||||
* This header exposes a minimal, C-compatible UART API that mirrors the higher-level
|
||||
* C++ UART interface (see Tactility/hal/uart).
|
||||
*
|
||||
* General notes:
|
||||
* - Start the UART before I/O using tt_hal_uart_start(); stop it with tt_hal_uart_stop().
|
||||
*/
|
||||
|
||||
typedef void* UartHandle; /**< Opaque handle to an underlying UART instance. */
|
||||
|
||||
/**
|
||||
* @brief Get the number of UART devices available on this platform.
|
||||
* @return Count of discoverable UARTs (0 if none).
|
||||
*/
|
||||
size_t tt_hal_uart_get_count();
|
||||
|
||||
/**
|
||||
* @brief Get the user-friendly name of a UART by index.
|
||||
* @param index Zero-based UART index in the range [0, tt_hal_uart_get_count()).
|
||||
* @param[out] name Destination buffer to receive a null-terminated name.
|
||||
* @param nameSizeLimit Size in bytes of the destination buffer. The name will be
|
||||
* truncated to fit and always null-terminated if the size
|
||||
* is greater than 0.
|
||||
* @return true if a name was written to the buffer; false if the index is out of range
|
||||
* or on other failure.
|
||||
*/
|
||||
bool tt_hal_uart_get_name(size_t index, char* name, size_t nameSizeLimit);
|
||||
|
||||
/**
|
||||
* @brief Allocate an opaque UART handle by index.
|
||||
*
|
||||
* Allocation does not start the hardware; call tt_hal_uart_start() to begin I/O.
|
||||
*
|
||||
* @param index Zero-based UART index.
|
||||
* @return A valid UartHandle on success; NULL on failure (e.g., invalid index or already in use).
|
||||
*/
|
||||
UartHandle tt_hal_uart_alloc(size_t index);
|
||||
|
||||
/**
|
||||
* @brief Release a previously allocated UART handle and any associated resources.
|
||||
* @param handle Handle returned by tt_hal_uart_alloc()
|
||||
*/
|
||||
void tt_hal_uart_free(UartHandle handle);
|
||||
|
||||
/**
|
||||
* @brief Start the UART so it can perform I/O.
|
||||
* @param handle A valid UART handle.
|
||||
* @return true on success; false on failure.
|
||||
*/
|
||||
bool tt_hal_uart_start(UartHandle handle);
|
||||
|
||||
/**
|
||||
* @brief Query whether the UART has been started.
|
||||
* @param handle A valid UART handle.
|
||||
* @return true if started; false otherwise.
|
||||
*/
|
||||
bool tt_hal_uart_is_started(UartHandle handle);
|
||||
|
||||
/**
|
||||
* @brief Stop the UART
|
||||
* @param handle A valid UART handle.
|
||||
* @return true on success; false on failure.
|
||||
*/
|
||||
bool tt_hal_uart_stop(UartHandle handle);
|
||||
|
||||
/**
|
||||
* @brief Read up to bufferSize bytes into buffer.
|
||||
*
|
||||
* This call may block up to timeout ticks waiting for data. It returns the actual
|
||||
* number of bytes placed into the buffer, which can be less than bufferSize if
|
||||
* fewer bytes became available before the timeout expired.
|
||||
*
|
||||
* @param handle A valid UART handle.
|
||||
* @param[out] buffer Destination buffer.
|
||||
* @param bufferSize Capacity of the destination buffer in bytes.
|
||||
* @param timeout Maximum time to wait in ticks. Use 0 for non-blocking; use TT_MAX_TICKS
|
||||
* to wait indefinitely.
|
||||
* @return The number of bytes read (0 on timeout with no data). Never exceeds bufferSize.
|
||||
*/
|
||||
size_t tt_hal_uart_read_bytes(UartHandle handle, char* buffer, size_t bufferSize, TickType_t timeout);
|
||||
|
||||
/**
|
||||
* @brief Read a single byte.
|
||||
*
|
||||
* @param handle A valid UART handle.
|
||||
* @param[out] output Where to store the read byte.
|
||||
* @param timeout Maximum time to wait in ticks. Use 0 for non-blocking; use TT_MAX_TICKS
|
||||
* to wait indefinitely.
|
||||
* @return true if a byte was read and stored in output; false on timeout or failure.
|
||||
*/
|
||||
bool tt_hal_uart_read_byte(UartHandle handle, char* output, TickType_t timeout);
|
||||
|
||||
/**
|
||||
* @brief Write up to bufferSize bytes from buffer.
|
||||
*
|
||||
* This call may block up to timeout ticks waiting for transmit queue space. It returns
|
||||
* the number of bytes accepted for transmission.
|
||||
*
|
||||
* @param handle A valid UART handle.
|
||||
* @param[in] buffer Source buffer containing bytes to write.
|
||||
* @param bufferSize Number of bytes to write from buffer.
|
||||
* @param timeout Maximum time to wait in ticks. Use 0 for non-blocking; use TT_MAX_TICKS
|
||||
* to wait indefinitely.
|
||||
* @return The number of bytes written (may be less than bufferSize on timeout).
|
||||
*/
|
||||
size_t tt_hal_uart_write_bytes(UartHandle handle, const char* buffer, size_t bufferSize, TickType_t timeout);
|
||||
|
||||
/**
|
||||
* @brief Get the number of bytes currently available to read without blocking.
|
||||
* @param handle A valid UART handle.
|
||||
* @return The count of bytes available in the receive buffer.
|
||||
*/
|
||||
size_t tt_hal_uart_available(UartHandle handle);
|
||||
|
||||
/**
|
||||
* @brief Set the UART baud rate.
|
||||
* @param handle A valid UART handle.
|
||||
* @param baud_rate Desired baud rate in bits per second (e.g., 115200).
|
||||
* @return true on success; false if the rate is unsupported or on error.
|
||||
*/
|
||||
bool tt_hal_uart_set_baud_rate(UartHandle handle, size_t baud_rate);
|
||||
|
||||
/**
|
||||
* @brief Get the current UART baud rate.
|
||||
* @param handle A valid UART handle.
|
||||
* @return The configured baud rate in bits per second.
|
||||
*/
|
||||
uint32_t tt_hal_uart_get_baud_rate(UartHandle handle);
|
||||
|
||||
/**
|
||||
* @brief Flush the UART input (receive) buffer, discarding any unread data.
|
||||
* @param handle A valid UART handle.
|
||||
*/
|
||||
void tt_hal_uart_flush_input(UartHandle handle);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,29 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <freertos/FreeRTOS.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define TT_LVGL_DEFAULT_LOCK_TIME 500 // 500 ticks = 500 ms
|
||||
|
||||
/** @return true if LVGL is started and active */
|
||||
bool tt_lvgl_is_started();
|
||||
|
||||
/** Start LVGL and related background services */
|
||||
void tt_lvgl_start();
|
||||
|
||||
/** Stop LVGL and related background services */
|
||||
void tt_lvgl_stop();
|
||||
|
||||
/** Lock the LVGL context. Call this before doing LVGL-related operations from a non-LVLG thread */
|
||||
bool tt_lvgl_lock(TickType_t timeout);
|
||||
|
||||
/** Unlock the LVGL context */
|
||||
void tt_lvgl_unlock();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user