Chat app update, EspNow v2 & GPS Info

Author: Shadowtrance

Documentation/chat.md

@@ -0,0 +1,130 @@
+# Chat App
+
+ESP-NOW based chat application with channel-based messaging. Devices with the same encryption key can communicate in real-time without requiring a WiFi access point or internet connection.
+
+## Features
+
+- **Channel-based messaging**: Join named channels (e.g. `#general`, `#random`) to organize conversations
+- **Broadcast support**: Messages with empty target are visible in all channels
+- **Configurable nickname**: Identify yourself with a custom name (max 23 characters)
+- **Encryption key**: Optional shared key for private group communication
+- **Persistent settings**: Nickname, key, and current chat channel are saved across reboots
+
+## Requirements
+
+- ESP32 with WiFi support (not available on ESP32-P4)
+- ESP-NOW service enabled
+
+## UI Layout
+
+```
++------------------------------------------+
+| [Back] Chat: #general    [List] [Gear]   |
++------------------------------------------+
+|  alice: hello everyone                   |
+|  bob: hey alice!                         |
+|  You: hi there                           |
+|  (scrollable message list)               |
++------------------------------------------+
+| [____input textarea____] [Send]          |
++------------------------------------------+
+```
+
+- **Toolbar title**: Shows `Chat: <channel>` with the current channel name
+- **List icon**: Opens channel selector to switch channels
+- **Gear icon**: Opens settings panel (nickname, encryption key)
+- **Message list**: Shows messages matching the current channel or broadcast messages
+- **Input bar**: Type and send messages to the current channel
+
+## Channel Selector
+
+Tap the list icon to change channels. Enter a channel name (e.g. `#general`, `#team1`) and press OK. The message list refreshes to show only messages matching the new channel.
+
+Messages are sent with the current channel as the target. Only devices viewing the same channel will display the message. Broadcast messages (empty target) appear in all channels.
+
+## First Launch
+
+On first launch (when no settings file exists), the settings panel opens automatically so users can configure their nickname before chatting.
+
+## Settings
+
+Tap the gear icon to configure:
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| Nickname | Your display name (max 23 chars) | `Device` |
+| Key | Encryption key as 32 hex characters (16 bytes) | All zeros (empty field) |
+
+Settings are stored in `/data/settings/chat.properties`. The encryption key is stored encrypted using AES-256-CBC.
+
+When the key field is left empty, the default all-zeros key is used. All devices using the default key can communicate without configuration.
+
+Changing the encryption key causes ESP-NOW to restart with the new configuration.
+
+## Wire Protocol
+
+Variable-length packed struct broadcast over ESP-NOW (ESP-NOW v2.0):
+
+```
+Offset  Size   Field
+------  ----   -----
+0       4      header (magic: 0x31544354 "TCT1")
+4       1      protocol_version (0x01)
+5       24     sender_name (null-terminated, zero-padded)
+29      24     target (null-terminated, zero-padded)
+53      1-1417 message (null-terminated, variable length)
+```
+
+- **Minimum packet**: 54 bytes (header + 1 byte message)
+- **Maximum packet**: 1470 bytes (ESP-NOW v2.0 limit)
+- **v1.0 compatibility**: Messages < 250 bytes work with ESP-NOW v1.0 devices
+
+Messages with incorrect magic/version or invalid length are silently discarded.
+
+### Target Field Semantics
+
+| Target Value | Meaning |
+|-------------|---------|
+| `""` (empty) | Broadcast - visible in all channels |
+| `#channel` | Channel message - visible only when viewing that channel |
+| `username` | Direct message |
+
+## Architecture
+
+```
+ChatApp         - App lifecycle, ESP-NOW send/receive, settings management
+ChatState       - Message storage (deque, max 100), channel filtering, mutex-protected
+ChatView        - LVGL UI: toolbar, message list, input bar, settings/channel panels
+ChatProtocol    - Variable-length Message struct, serialize/deserialize (v2.0 support)
+ChatSettings    - Properties file load/save with encrypted key storage
+```
+
+All files are guarded with `#if defined(CONFIG_SOC_WIFI_SUPPORTED) && !defined(CONFIG_SLAVE_SOC_WIFI_SUPPORTED)` to exclude from P4 builds.
+
+## Message Flow
+
+### Sending
+
+1. User types message and taps Send
+2. Message serialized into `Message` struct with current nickname and channel as target
+3. Broadcast via ESP-NOW to nearby devices
+4. Own message stored and displayed locally
+
+### Receiving
+
+1. ESP-NOW callback fires with raw data
+2. Validate: size within valid range (54-1470 bytes), magic and version must match
+3. Copy into aligned local struct (avoids unaligned access on embedded platforms)
+4. Extract sender name, target, and message as strings
+5. Store in message deque
+6. Display if target matches current channel or is broadcast (empty)
+
+## Limitations
+
+- Maximum 100 stored messages (oldest discarded when full)
+- Nickname: 23 characters max
+- Channel name: 23 characters max
+- Message text: 1416 characters max (ESP-NOW v2.0)
+- No message persistence across app restarts (messages are in-memory only)
+- All communication is broadcast; channel filtering is client-side only
+- Messages > 250 bytes only received by devices running ESP-NOW v2.0

Documentation/espnow-v2.md

@@ -0,0 +1,92 @@
+# ESP-NOW v2.0 Support & Chat App Enhancements
+
+## Summary
+
+- Add ESP-NOW v2.0 support with version detection and larger payload capability
+- Update Chat app to use variable-length messages (up to 1416 characters)
+- Maintain backwards compatibility with ESP-NOW v1.0 devices
+
+## ESP-NOW Service Changes
+
+### New API
+
+```cpp
+// Get the ESP-NOW protocol version (1 or 2)
+uint32_t espnow::getVersion();
+
+// Get max payload size for current version (250 or 1470 bytes)
+size_t espnow::getMaxDataLength();
+
+// Constants
+constexpr size_t MAX_DATA_LEN_V1 = 250;
+constexpr size_t MAX_DATA_LEN_V2 = 1470;
+```
+
+### Version Detection
+
+ESP-NOW version is queried on initialization and logged:
+```
+I (15620) ESPNOW: espnow [version: 2.0] init
+I [EspNowService] ESP-NOW version: 2.0
+```
+
+### Files Modified
+
+| File | Change |
+|------|--------|
+| `Tactility/Include/Tactility/service/espnow/EspNow.h` | Added constants and `getVersion()`, `getMaxDataLength()` |
+| `Tactility/Source/service/espnow/EspNow.cpp` | Implemented new functions |
+| `Tactility/Private/Tactility/service/espnow/EspNowService.h` | Added `espnowVersion` member |
+| `Tactility/Source/service/espnow/EspNowService.cpp` | Query version after init |
+
+## Chat App Changes
+
+### Larger Messages
+
+- Message size increased from **127 to 1416 characters**
+- Variable-length packet transmission (only sends actual message length)
+- Backwards compatible: messages < 197 chars still work with v1.0 devices
+
+### Wire Protocol
+
+```
+Offset  Size   Field
+------  ----   -----
+0       4      header (magic: 0x31544354)
+4       1      protocol_version (0x01)
+5       24     sender_name
+29      24     target
+53      1-1417 message (variable length)
+```
+
+- **Min packet**: 54 bytes
+- **Max packet**: 1470 bytes (v2.0 limit)
+
+### Files Modified
+
+| File | Change |
+|------|--------|
+| `Tactility/Private/Tactility/app/chat/ChatProtocol.h` | `MESSAGE_SIZE` = 1417, added header constants |
+| `Tactility/Source/app/chat/ChatProtocol.cpp` | Variable-length serialize/deserialize |
+| `Tactility/Source/app/chat/ChatApp.cpp` | Send actual packet size |
+| `Tactility/Source/app/chat/ChatView.cpp` | Input field max length = 1416 |
+| `Documentation/chat.md` | Updated protocol documentation |
+
+## Compatibility
+
+| Scenario | Result |
+|----------|--------|
+| v2.0 device sends short message (< 250 bytes) | v1.0 and v2.0 devices receive |
+| v2.0 device sends long message (> 250 bytes) | Only v2.0 devices receive |
+| v1.0 device sends message | v1.0 and v2.0 devices receive |
+
+## Requirements
+
+- ESP-IDF v5.4 or later (for ESP-NOW v2.0 support)
+
+## Test Plan
+
+- [ ] Verify "ESP-NOW version: 2.0" appears in logs on startup
+- [ ] Send short message between two v2.0 devices
+- [ ] Send long message (> 200 chars) between two v2.0 devices
+- [ ] Verify `espnow::getMaxDataLength()` returns 1470

Tactility/Include/Tactility/service/espnow/EspNow.h

@@ -16,6 +16,10 @@ namespace tt::service::espnow {
 typedef int ReceiverSubscription;
 constexpr ReceiverSubscription NO_SUBSCRIPTION = -1;
 
+// ESP-NOW version payload limits
+constexpr size_t MAX_DATA_LEN_V1 = 250;   // ESP-NOW v1.0 max payload
+constexpr size_t MAX_DATA_LEN_V2 = 1470;  // ESP-NOW v2.0 max payload (requires ESP-IDF v5.4+)
+
 enum class Mode {
     Station,
     AccessPoint
@@ -54,6 +58,12 @@ ReceiverSubscription subscribeReceiver(std::function<void(const esp_now_recv_inf
 
 void unsubscribeReceiver(ReceiverSubscription subscription);
 
+/** Get the ESP-NOW protocol version (1 for v1.0, 2 for v2.0). Returns 0 if service not running. */
+uint32_t getVersion();
+
+/** Get the maximum data length for current ESP-NOW version (250 for v1.0, 1470 for v2.0). */
+size_t getMaxDataLength();
+
 }
 
 #endif // CONFIG_SOC_WIFI_SUPPORTED && !CONFIG_SLAVE_SOC_WIFI_SUPPORTED

Tactility/Include/Tactility/service/gps/GpsService.h

@@ -21,6 +21,9 @@ class GpsService final : public Service {
     minmea_sentence_rmc rmcRecord;
     TickType_t rmcTime = 0;
 
+    minmea_sentence_gga ggaRecord;
+    TickType_t ggaTime = 0;
+
     RecursiveMutex mutex;
     Mutex stateMutex;
     std::vector<GpsDeviceRecord> deviceRecords;
@@ -58,6 +61,7 @@ class GpsService final : public Service {
 
     bool hasCoordinates() const;
     bool getCoordinates(minmea_sentence_rmc& rmc) const;
+    bool getGga(minmea_sentence_gga& gga) const;
 
     /** @return GPS service pubsub that broadcasts State* objects */
     std::shared_ptr<PubSub<State>> getStatePubsub() const { return statePubSub; }

Tactility/Private/Tactility/app/chat/ChatAppPrivate.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#ifdef ESP_PLATFORM
+#include <sdkconfig.h>
+#endif
+
+#if defined(CONFIG_SOC_WIFI_SUPPORTED) && !defined(CONFIG_SLAVE_SOC_WIFI_SUPPORTED)
+
+#include "ChatState.h"
+#include "ChatView.h"
+#include "ChatSettings.h"
+
+#include <Tactility/app/App.h>
+#include <Tactility/service/espnow/EspNow.h>
+
+namespace tt::app::chat {
+
+class ChatApp final : public App {
+
+    ChatState state;
+    ChatView view = ChatView(this, &state);
+    service::espnow::ReceiverSubscription receiveSubscription = -1;
+    ChatSettingsData settings;
+    bool isFirstLaunch = false;
+
+    void onReceive(const esp_now_recv_info_t* receiveInfo, const uint8_t* data, int length);
+    void enableEspNow();
+    void disableEspNow();
+
+public:
+    void onCreate(AppContext& appContext) override;
+    void onDestroy(AppContext& appContext) override;
+    void onShow(AppContext& context, lv_obj_t* parent) override;
+
+    void sendMessage(const std::string& text);
+    void applySettings(const std::string& nickname, const std::string& keyHex);
+    void switchChannel(const std::string& chatChannel);
+
+    const ChatSettingsData& getSettings() const { return settings; }
+
+    ~ChatApp() override = default;
+};
+
+} // namespace tt::app::chat
+
+#endif // CONFIG_SOC_WIFI_SUPPORTED && !CONFIG_SLAVE_SOC_WIFI_SUPPORTED

Tactility/Private/Tactility/app/chat/ChatProtocol.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#ifdef ESP_PLATFORM
+#include <sdkconfig.h>
+#endif
+
+#if defined(CONFIG_SOC_WIFI_SUPPORTED) && !defined(CONFIG_SLAVE_SOC_WIFI_SUPPORTED)
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace tt::app::chat {
+
+constexpr uint32_t CHAT_MAGIC_HEADER = 0x31544354; // "TCT1"
+constexpr uint8_t PROTOCOL_VERSION = 0x01;
+constexpr size_t SENDER_NAME_SIZE = 24;
+constexpr size_t TARGET_SIZE = 24;
+constexpr size_t MESSAGE_SIZE = 1417;  // Max for ESP-NOW v2.0 (1470 - 53 header bytes)
+
+// Header size = offset to message field (header + version + sender_name + target)
+constexpr size_t MESSAGE_HEADER_SIZE = 4 + 1 + SENDER_NAME_SIZE + TARGET_SIZE;  // 53 bytes
+constexpr size_t MIN_PACKET_SIZE = MESSAGE_HEADER_SIZE + 1;  // At least 1 byte of message
+
+struct __attribute__((packed)) Message {
+    uint32_t header;
+    uint8_t protocol_version;
+    char sender_name[SENDER_NAME_SIZE];
+    char target[TARGET_SIZE];   // empty=broadcast, "#channel" or "username"
+    char message[MESSAGE_SIZE];
+};
+
+static_assert(sizeof(Message) == 1470, "Message struct must be exactly ESP-NOW v2.0 max payload");
+static_assert(MESSAGE_HEADER_SIZE == offsetof(Message, message), "Header size calculation mismatch");
+
+struct ParsedMessage {
+    std::string senderName;
+    std::string target;
+    std::string message;
+};
+
+/** Serialize fields into the wire format.
+ * Returns the actual packet size to send (variable length), or 0 on failure.
+ * Short messages (< 250 bytes total) are compatible with ESP-NOW v1.0 devices. */
+size_t serializeMessage(const std::string& senderName, const std::string& target,
+                        const std::string& message, Message& out);
+
+/** Deserialize a received buffer into a ParsedMessage.
+ * Returns true if valid (correct magic, version, and minimum length). */
+bool deserializeMessage(const uint8_t* data, int length, ParsedMessage& out);
+
+} // namespace tt::app::chat
+
+#endif // CONFIG_SOC_WIFI_SUPPORTED && !CONFIG_SLAVE_SOC_WIFI_SUPPORTED