qsethuk/carpibord
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update code and add flipper zero integration

Browse Source
This commit is contained in:
Alexander Poletaev
2026-01-29 23:36:36 +03:00
parent d4ffce28d5
commit a96328d4e6
11 changed files with 2307 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
flip_monitor/README.md Normal file
View File

@@ -0,0 +1,278 @@
# CAN Monitor for Flipper Zero
Dynamic multi-page monitor application for Raspberry Pi 5 via UART.
## Features
- **Dynamic Page System** - Pages are fully controlled by RPi5
- **Multiple Page Types**:
- **Info** - Read-only status display
- **Menu** - Selectable action items
- **Confirm** - Yes/No confirmation dialogs
- **Real-time Updates** - Content refreshes every second
- **Bidirectional Communication** - Send commands back to RPi5
- **Result Notifications** - Action results displayed as overlay
## Default Pages
When connected to the CAN Sniffer system:
| Page | Type | Description |
|------|------|-------------|
| CAN Statistics | Info | Frame counts, queue status, per-interface stats |
| UPS Status | Info | Battery level, voltage, charging state (X120x) |
| System Info | Info | CPU temperature, power consumption, fan RPM |
| Actions | Menu | Shutdown, Reboot, Cancel shutdown |
## Screen Layout
```
128x64 pixels (Flipper Zero display)
+----------------------------------+
| [1/4] Page Title (*) | <- Header: page indicator, title, connection dot
+----------------------------------+
| |
| Content Line 1 | <- Content area: 4-5 lines
| Content Line 2 |
| Content Line 3 |
| Content Line 4 |
| |
+----------------------------------+
| < Hint Text > | <- Footer: nav arrows, action hint
+----------------------------------+
```
## Controls
| Key | Info Page | Menu Page | Confirm Page |
|-----|-----------|-----------|--------------|
| **Left/Right** | Navigate pages | Navigate pages | Navigate pages |
| **Up/Down** | - | Select item | Switch Yes/No |
| **OK** | - | Execute action | Confirm selection |
| **Back** | Disconnect (pg 0) / Prev page | Same | Cancel dialog |
## Protocol
### RPi5 -> Flipper
```
PAGE:<idx>/<total>|<type>|<title>|<lines>|<actions>|<selected>
ACK:<device>,ip=<ip>
RESULT:<OK|ERROR>|<message>
```
**Examples:**
```
PAGE:0/4|info|CAN Statistics|Total: 12.3K;Processed: 12.1K;Queue: 142||0
PAGE:1/4|info|UPS Status|Bat: 85.2% [====];Voltage: 4.12V;Status: Charging||0
PAGE:2/4|info|System Info|CPU Temp: 52.1C;Power: 4.2W;Fan: 3200 RPM||0
PAGE:3/4|menu|Actions|Shutdown;Reboot;Cancel Shutdown||0
PAGE:3/4|confirm|Confirm Shutdown?|Are you sure?|Yes;No|1
ACK:rpi5,ip=192.168.1.100
RESULT:OK|Shutdown in 1 min
```
### Flipper -> RPi5
```
INIT:flipper - Start handshake
STOP:flipper - Disconnect
CMD:NAV:next - Next page
CMD:NAV:prev - Previous page
CMD:SELECT:<index> - Select menu item
CMD:CONFIRM - Confirm action
CMD:CANCEL - Cancel action
CMD:REFRESH - Request page update
```
## Hardware Connection
### Wiring Diagram
```
Flipper Zero Raspberry Pi 5
----------- ---------------
Pin 13 (TX) ----> GPIO 15 (RX) - Pin 10
Pin 14 (RX) <---- GPIO 14 (TX) - Pin 8
Pin 8/11/18 (GND) ---- GND - Pin 6
```
**Note:** Cross TX/RX connections (Flipper TX -> RPi RX)
### Flipper Zero GPIO Pinout
```
Pin 13 = TX (USART)
Pin 14 = RX (USART)
Pin 8/11/18 = GND
```
### RPI5 GPIO (using /dev/ttyAMA0)
```
GPIO 14 = TX (Pin 8)
GPIO 15 = RX (Pin 10)
GND = Pin 6, 9, 14, 20, 25, 30, 34, 39
```
## Building the Application
### Prerequisites
1. Clone Flipper Zero firmware:
```bash
git clone --recursive https://github.com/DarkFlippers/unleashed-firmware.git
cd unleashed-firmware
```
2. Copy the `flip_monitor` folder to `applications_user/`:
```bash
cp -r /path/to/carpibord/flip_monitor applications_user/can_monitor
```
### Build
```bash
# Build the FAP
./fbt fap_can_monitor
# Or build all external apps
./fbt fap_dist
```
The compiled `.fap` file will be in `build/f7-firmware-D/.extapps/can_monitor.fap`
### Install
Copy the `.fap` file to your Flipper Zero SD card:
```
SD Card/apps/GPIO/can_monitor.fap
```
## RPI5 Configuration
### 1. Enable UART
Add to `/boot/firmware/config.txt`:
```
enable_uart=1
dtoverlay=uart0
```
Disable serial console:
```bash
sudo raspi-config
# Interface Options -> Serial Port -> No (login shell) -> Yes (hardware)
```
Reboot after changes.
### 2. Install Dependencies
```bash
pip install pyserial smbus2 gpiozero
```
### 3. Configure CAN Sniffer
Add to `can_sniffer/src/config.json`:
```json
{
"flipper": {
"enabled": true,
"device": "/dev/ttyAMA0",
"baudrate": 115200,
"send_interval": 1.0
}
}
```
Or use environment variables:
```bash
export CAN_SNIFFER_FLIPPER__ENABLED=true
export CAN_SNIFFER_FLIPPER__DEVICE=/dev/ttyAMA0
```
### 4. Run CAN Sniffer
```bash
cd can_sniffer/src
python main.py
```
## Adding Custom Pages
On RPi5 side, create a new page class:
```python
from flipper.pages.base import InfoPage
class MyCustomPage(InfoPage):
def __init__(self):
super().__init__(
name="my_page",
title="My Page",
icon="custom"
)
def get_lines(self) -> list[str]:
return [
"Custom line 1",
"Custom line 2",
f"Value: {self.get_value()}"
]
```
Register in FlipperHandler:
```python
# In flipper_handler.py
from flipper.pages.my_custom import MyCustomPage
# In _setup_pages():
self._page_manager.register_page(MyCustomPage())
```
## Troubleshooting
### No connection
1. Check wiring (TX/RX crossed correctly)
2. Verify UART is enabled on RPI5: `ls -la /dev/ttyAMA0`
3. Check config: `flipper.enabled = true`
4. Test UART manually:
```bash
# On RPI5
echo "ACK:rpi5,ip=test" > /dev/ttyAMA0
```
### Permission denied on /dev/ttyAMA0
Add user to dialout group:
```bash
sudo usermod -a -G dialout $USER
# Then logout and login again
```
### Flipper shows "Waiting for data..."
- Data is sent every 1 second (configurable)
- Connection timeout is 5 seconds
- Check if CAN sniffer is running
- Check UART logs: `CAN_SNIFFER_LOGGING__LEVEL=DEBUG python main.py`
### UPS page shows "not available"
- X120x UPS must be connected via I2C
- Install smbus2: `pip install smbus2`
- Check I2C: `i2cdetect -y 1` (should show device at 0x36)
## Version History
- **v2.0** - Dynamic page system, bidirectional commands, UPS/System pages
- **v1.0** - Basic CAN statistics display
## License
MIT License

11
flip_monitor/application.fam Normal file
View File

@@ -0,0 +1,11 @@
App(
appid="can_monitor",
name="CAN Monitor",
apptype=FlipperAppType.EXTERNAL,
entry_point="can_monitor_app",
stack_size=4 * 1024,
fap_category="GPIO",
fap_author="carpibord",
fap_version="2.0",
fap_description="Dynamic multi-page RPI5 monitor with CAN stats, UPS, system info and actions",
)

895
flip_monitor/can_monitor.c Normal file
View File

@@ -0,0 +1,895 @@
/**
* CAN Monitor for Flipper Zero - Dynamic UI Version
*
* Multi-page application with dynamic content from RPI5.
*
* Protocol:
* RPi -> Flipper:
* PAGE:<idx>/<total>|<type>|<title>|<lines>|<actions>|<selected>
* ACK:<device>,ip=<ip>
* RESULT:<status>|<message>
*
* Flipper -> RPi:
* INIT:flipper
* STOP:flipper
* CMD:NAV:next / CMD:NAV:prev
* CMD:SELECT:<index>
* CMD:CONFIRM / CMD:CANCEL
* CMD:REFRESH
*
* Wiring:
* RPI5 TX (GPIO14, Pin 8) -> Flipper RX (Pin 14)
* RPI5 RX (GPIO15, Pin 10) <- Flipper TX (Pin 13)
* RPI5 GND (Pin 6) -> Flipper GND (Pin 8/11/18)
*/
#include <furi.h>
#include <furi_hal.h>
#include <gui/gui.h>
#include <gui/view_port.h>
#include <gui/elements.h>
#include <expansion/expansion.h>
#include <stdlib.h>
#include <string.h>
#define TAG "CANMonitor"
#define UART_BAUD 115200
#define RX_BUFFER_SIZE 512
#define MAX_LINES 5
#define MAX_ACTIONS 4
#define MAX_LINE_LENGTH 32
#define MAX_TITLE_LENGTH 24
// Connection state
typedef enum {
StateDisconnected,
StateConnecting,
StateConnected,
} ConnectionState;
// Page types
typedef enum {
PageTypeInfo,
PageTypeMenu,
PageTypeConfirm,
} PageType;
// Page content received from RPi
typedef struct {
uint8_t page_index;
uint8_t total_pages;
PageType page_type;
char title[MAX_TITLE_LENGTH];
char lines[MAX_LINES][MAX_LINE_LENGTH];
uint8_t line_count;
char actions[MAX_ACTIONS][MAX_LINE_LENGTH];
uint8_t action_count;
uint8_t selected_index;
bool data_valid;
uint32_t last_update_tick;
} PageContent;
// Result message
typedef struct {
bool has_result;
bool success;
char message[MAX_LINE_LENGTH];
uint32_t show_until_tick;
} ResultMessage;
// App context
typedef struct {
Gui* gui;
ViewPort* view_port;
FuriMutex* mutex;
FuriHalSerialHandle* serial;
FuriStreamBuffer* rx_stream;
FuriThread* worker_thread;
PageContent page;
ResultMessage result;
ConnectionState conn_state;
char ip_address[32];
uint32_t connecting_start_tick; // Time when INIT was sent or ACK received
volatile bool running;
volatile bool send_init;
} CanMonitorApp;
// Forward declarations
static void draw_callback(Canvas* canvas, void* ctx);
static void input_callback(InputEvent* event, void* ctx);
// Send data via UART
static void uart_send(CanMonitorApp* app, const char* data) {
if(app->serial) {
furi_hal_serial_tx(app->serial, (uint8_t*)data, strlen(data));
FURI_LOG_I(TAG, "TX: %s", data);
}
}
// Clear page content
static void clear_page_content(PageContent* page) {
page->page_index = 0;
page->total_pages = 0;
page->page_type = PageTypeInfo;
page->title[0] = '\0';
page->line_count = 0;
page->action_count = 0;
page->selected_index = 0;
page->data_valid = false;
for(int i = 0; i < MAX_LINES; i++) {
page->lines[i][0] = '\0';
}
for(int i = 0; i < MAX_ACTIONS; i++) {
page->actions[i][0] = '\0';
}
}
// Parse semicolon-separated items into array
static uint8_t parse_items(const char* str, char items[][MAX_LINE_LENGTH], uint8_t max_items) {
uint8_t count = 0;
if(!str || str[0] == '\0') {
return 0;
}
const char* start = str;
const char* end;
while(count < max_items && start && *start) {
end = strchr(start, ';');
size_t len;
if(end) {
len = end - start;
} else {
len = strlen(start);
}
if(len >= MAX_LINE_LENGTH) {
len = MAX_LINE_LENGTH - 1;
}
if(len > 0) {
memcpy(items[count], start, len);
items[count][len] = '\0';
count++;
}
if(end) {
start = end + 1;
} else {
break;
}
}
return count;
}
// Parse PAGE message
// Format: PAGE:<idx>/<total>|<type>|<title>|<lines>|<actions>|<selected>
// Returns true if page changed (different page_index or page_type)
static bool parse_page(const char* line, PageContent* page, bool* page_changed) {
if(strncmp(line, "PAGE:", 5) != 0) {
return false;
}
const char* p = line + 5;
char* end;
// Save old values to detect page change
uint8_t old_page_index = page->page_index;
PageType old_page_type = page->page_type;
bool was_valid = page->data_valid;
// Parse page index and total
page->page_index = (uint8_t)strtoul(p, &end, 10);
if(*end != '/') return false;
p = end + 1;
page->total_pages = (uint8_t)strtoul(p, &end, 10);
if(*end != '|') return false;
p = end + 1;
// Parse page type
const char* type_end = strchr(p, '|');
if(!type_end) return false;
PageType new_page_type;
if(strncmp(p, "info", type_end - p) == 0) {
new_page_type = PageTypeInfo;
} else if(strncmp(p, "menu", type_end - p) == 0) {
new_page_type = PageTypeMenu;
} else if(strncmp(p, "confirm", type_end - p) == 0) {
new_page_type = PageTypeConfirm;
} else {
new_page_type = PageTypeInfo;
}
page->page_type = new_page_type;
p = type_end + 1;
// Detect if page changed (index OR type changed)
bool is_page_change = !was_valid ||
(page->page_index != old_page_index) ||
(new_page_type != old_page_type);
if(page_changed) {
*page_changed = is_page_change;
}
// Parse title
const char* title_end = strchr(p, '|');
if(!title_end) return false;
size_t title_len = title_end - p;
if(title_len >= MAX_TITLE_LENGTH) {
title_len = MAX_TITLE_LENGTH - 1;
}
memcpy(page->title, p, title_len);
page->title[title_len] = '\0';
p = title_end + 1;
// Parse lines
const char* lines_end = strchr(p, '|');
if(!lines_end) return false;
char lines_buf[256];
size_t lines_len = lines_end - p;
if(lines_len >= sizeof(lines_buf)) {
lines_len = sizeof(lines_buf) - 1;
}
memcpy(lines_buf, p, lines_len);
lines_buf[lines_len] = '\0';
page->line_count = parse_items(lines_buf, page->lines, MAX_LINES);
p = lines_end + 1;
// Parse actions
const char* actions_end = strchr(p, '|');
if(!actions_end) return false;
char actions_buf[128];
size_t actions_len = actions_end - p;
if(actions_len >= sizeof(actions_buf)) {
actions_len = sizeof(actions_buf) - 1;
}
memcpy(actions_buf, p, actions_len);
actions_buf[actions_len] = '\0';
page->action_count = parse_items(actions_buf, page->actions, MAX_ACTIONS);
p = actions_end + 1;
// Parse selected index from server
uint8_t server_selected = (uint8_t)strtoul(p, NULL, 10);
// IMPORTANT: Only update selected_index on page change
// For menu/confirm pages, preserve local selection during updates
if(is_page_change) {
page->selected_index = server_selected;
} else if(page->page_type == PageTypeInfo) {
// Info pages don't have selection, always use server value
page->selected_index = server_selected;
}
// For menu/confirm on same page: keep old_selected (local user choice)
page->data_valid = true;
page->last_update_tick = furi_get_tick();
return true;
}
// Parse ACK message
static bool parse_ack(const char* line, char* ip_out, size_t ip_size) {
if(strncmp(line, "ACK:", 4) != 0) {
return false;
}
const char* ip = strstr(line, "ip=");
if(ip) {
ip += 3;
size_t len = 0;
while(ip[len] && ip[len] != ',' && ip[len] != '\n' && ip[len] != '\r') {
len++;
}
if(len > 0 && len < ip_size) {
memcpy(ip_out, ip, len);
ip_out[len] = '\0';
}
}
return true;
}
// Parse RESULT message
static bool parse_result(const char* line, ResultMessage* result) {
if(strncmp(line, "RESULT:", 7) != 0) {
return false;
}
const char* p = line + 7;
// Parse status
if(strncmp(p, "OK|", 3) == 0) {
result->success = true;
p += 3;
} else if(strncmp(p, "ERROR|", 6) == 0) {
result->success = false;
p += 6;
} else {
return false;
}
// Parse message
size_t len = strlen(p);
if(len >= MAX_LINE_LENGTH) {
len = MAX_LINE_LENGTH - 1;
}
memcpy(result->message, p, len);
result->message[len] = '\0';
result->has_result = true;
result->show_until_tick = furi_get_tick() + 3000; // Show for 3 seconds
return true;
}
// Process received line
static void process_line(CanMonitorApp* app, const char* line) {
FURI_LOG_I(TAG, "RX: %s", line);
furi_mutex_acquire(app->mutex, FuriWaitForever);
if(app->conn_state == StateConnecting) {
// Waiting for ACK
if(parse_ack(line, app->ip_address, sizeof(app->ip_address))) {
FURI_LOG_I(TAG, "ACK received, IP: %s", app->ip_address);
app->conn_state = StateConnected;
// Reset tick for data waiting timeout
app->connecting_start_tick = furi_get_tick();
}
} else if(app->conn_state == StateConnected) {
// Parse PAGE or RESULT
if(line[0] == 'P') {
bool page_changed = false;
parse_page(line, &app->page, &page_changed);
if(page_changed) {
FURI_LOG_I(TAG, "Page changed to %d", app->page.page_index);
}
} else if(line[0] == 'R') {
parse_result(line, &app->result);
}
}
furi_mutex_release(app->mutex);
view_port_update(app->view_port);
}
// UART RX callback
static void uart_callback(FuriHalSerialHandle* handle, FuriHalSerialRxEvent event, void* ctx) {
CanMonitorApp* app = ctx;
if(event == FuriHalSerialRxEventData) {
uint8_t byte = furi_hal_serial_async_rx(handle);
furi_stream_buffer_send(app->rx_stream, &byte, 1, 0);
}
}
// Worker thread
static int32_t worker_thread(void* ctx) {
CanMonitorApp* app = ctx;
char buffer[RX_BUFFER_SIZE];
size_t idx = 0;
uint32_t last_rx_tick = 0;
FURI_LOG_I(TAG, "Worker started");
while(app->running) {
// Check if we need to send INIT
if(app->send_init) {
app->send_init = false;
uart_send(app, "INIT:flipper\n");
furi_mutex_acquire(app->mutex, FuriWaitForever);
app->conn_state = StateConnecting;
app->connecting_start_tick = furi_get_tick();
clear_page_content(&app->page);
furi_mutex_release(app->mutex);
view_port_update(app->view_port);
}
// Receive data
uint8_t byte;
size_t len = furi_stream_buffer_receive(app->rx_stream, &byte, 1, 50);
if(len > 0) {
last_rx_tick = furi_get_tick();
if(byte == '\n' || byte == '\r') {
if(idx > 0) {
buffer[idx] = '\0';
process_line(app, buffer);
idx = 0;
}
} else if(idx < RX_BUFFER_SIZE - 1) {
buffer[idx++] = byte;
}
} else {
// Timeout: parse partial data after 500ms
if(idx > 0 && (furi_get_tick() - last_rx_tick) > 500) {
buffer[idx] = '\0';
process_line(app, buffer);
idx = 0;
}
}
// Check data timeout (5 sec) - only when connected
furi_mutex_acquire(app->mutex, FuriWaitForever);
if(app->conn_state == StateConnected && app->page.data_valid) {
if((furi_get_tick() - app->page.last_update_tick) > 5000) {
// Data timeout - RPi likely restarted, go back to disconnected state
// This allows user to reconnect by pressing OK
FURI_LOG_W(TAG, "Data timeout, disconnecting");
app->conn_state = StateDisconnected;
app->page.data_valid = false;
clear_page_content(&app->page);
view_port_update(app->view_port);
}
}
// Check connecting timeout (3 sec) - ACK not received
if(app->conn_state == StateConnecting) {
if((furi_get_tick() - app->connecting_start_tick) > 3000) {
// Connection timeout - RPi not responding, go back to disconnected
FURI_LOG_W(TAG, "Connection timeout, no ACK received");
app->conn_state = StateDisconnected;
view_port_update(app->view_port);
}
}
// Check initial data timeout (5 sec) - ACK received but no PAGE data yet
if(app->conn_state == StateConnected && !app->page.data_valid) {
if((furi_get_tick() - app->connecting_start_tick) > 5000) {
// No data received after ACK - RPi not sending data
FURI_LOG_W(TAG, "Data wait timeout, no PAGE received after ACK");
app->conn_state = StateDisconnected;
view_port_update(app->view_port);
}
}
// Clear result message after timeout
if(app->result.has_result && furi_get_tick() > app->result.show_until_tick) {
app->result.has_result = false;
view_port_update(app->view_port);
}
furi_mutex_release(app->mutex);
}
FURI_LOG_I(TAG, "Worker stopped");
return 0;
}
// Draw header with page indicator
static void draw_header(Canvas* canvas, CanMonitorApp* app) {
// Page indicator
char page_str[16];
snprintf(
page_str,
sizeof(page_str),
"[%d/%d]",
app->page.page_index + 1,
app->page.total_pages);
canvas_draw_str(canvas, 0, 8, page_str);
// Title (centered)
uint16_t title_width = canvas_string_width(canvas, app->page.title);
uint16_t title_x = (128 - title_width) / 2;
canvas_draw_str(canvas, title_x, 8, app->page.title);
// Connection indicator (right side)
if(app->page.data_valid) {
canvas_draw_disc(canvas, 122, 4, 3);
} else {
canvas_draw_circle(canvas, 122, 4, 3);
}
// Separator line
canvas_draw_line(canvas, 0, 11, 128, 11);
}
// Draw footer with navigation hints
static void draw_footer(Canvas* canvas, PageType page_type, uint8_t total_pages, uint8_t current_page) {
canvas_draw_line(canvas, 0, 54, 128, 54);
canvas_set_font(canvas, FontSecondary);
// Left arrow (if not first page)
if(current_page > 0) {
canvas_draw_str(canvas, 2, 63, "<");
}
// Center action hint
const char* hint = "";
switch(page_type) {
case PageTypeInfo:
hint = "Up/Dn=Scroll";
break;
case PageTypeMenu:
hint = "Up/Dn OK=Select";
break;
case PageTypeConfirm:
hint = "Up/Dn OK Back=No";
break;
}
uint16_t hint_width = canvas_string_width(canvas, hint);
canvas_draw_str(canvas, (128 - hint_width) / 2, 63, hint);
// Right arrow (if not last page)
if(current_page < total_pages - 1) {
canvas_draw_str(canvas, 122, 63, ">");
}
}
// Draw info page
static void draw_info_page(Canvas* canvas, CanMonitorApp* app) {
canvas_set_font(canvas, FontSecondary);
uint8_t y = 22;
for(uint8_t i = 0; i < app->page.line_count && i < MAX_LINES; i++) {
canvas_draw_str(canvas, 2, y, app->page.lines[i]);
y += 10;
}
}
// Draw menu page
static void draw_menu_page(Canvas* canvas, CanMonitorApp* app) {
canvas_set_font(canvas, FontSecondary);
uint8_t y = 22;
for(uint8_t i = 0; i < app->page.action_count && i < MAX_ACTIONS; i++) {
// Selection indicator
if(i == app->page.selected_index) {
canvas_draw_box(canvas, 0, y - 8, 128, 10);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_str(canvas, 4, y, app->page.actions[i]);
if(i == app->page.selected_index) {
canvas_set_color(canvas, ColorBlack);
}
y += 10;
}
}
// Draw confirm page
static void draw_confirm_page(Canvas* canvas, CanMonitorApp* app) {
canvas_set_font(canvas, FontSecondary);
// Message (centered)
if(app->page.line_count > 0) {
uint16_t msg_width = canvas_string_width(canvas, app->page.lines[0]);
canvas_draw_str(canvas, (128 - msg_width) / 2, 30, app->page.lines[0]);
}
// Yes/No options
uint8_t btn_y = 44;
uint8_t yes_x = 32;
uint8_t no_x = 80;
// Draw Yes
if(app->page.selected_index == 0) {
canvas_draw_box(canvas, yes_x - 2, btn_y - 8, 24, 12);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_str(canvas, yes_x, btn_y, "Yes");
if(app->page.selected_index == 0) {
canvas_set_color(canvas, ColorBlack);
}
// Draw No
if(app->page.selected_index == 1) {
canvas_draw_box(canvas, no_x - 2, btn_y - 8, 20, 12);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_str(canvas, no_x, btn_y, "No");
if(app->page.selected_index == 1) {
canvas_set_color(canvas, ColorBlack);
}
}
// Draw result overlay
static void draw_result_overlay(Canvas* canvas, ResultMessage* result) {
// Semi-transparent background
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, 10, 20, 108, 28);
canvas_set_color(canvas, ColorBlack);
canvas_draw_frame(canvas, 10, 20, 108, 28);
canvas_set_font(canvas, FontPrimary);
const char* status = result->success ? "OK" : "Error";
canvas_draw_str(canvas, 14, 32, status);
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 14, 44, result->message);
}
// Draw welcome/connecting screen
static void draw_welcome(Canvas* canvas, CanMonitorApp* app) {
canvas_clear(canvas);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignCenter, "CAN Monitor");
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(canvas, 64, 22, AlignCenter, AlignCenter, "RPI5 Dynamic UI");
furi_mutex_acquire(app->mutex, FuriWaitForever);
ConnectionState state = app->conn_state;
char ip_buf[32];
strncpy(ip_buf, app->ip_address, sizeof(ip_buf));
furi_mutex_release(app->mutex);
switch(state) {
case StateDisconnected:
canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, "Press OK to connect");
canvas_draw_str_aligned(canvas, 64, 50, AlignCenter, AlignCenter, "[OK]");
break;
case StateConnecting:
canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, "Connecting...");
canvas_draw_str_aligned(canvas, 64, 50, AlignCenter, AlignCenter, "Waiting for RPI5");
break;
case StateConnected:
canvas_draw_str_aligned(canvas, 64, 34, AlignCenter, AlignCenter, "Connected!");
if(strlen(ip_buf) > 0) {
char buf[48];
snprintf(buf, sizeof(buf), "RPI5: %s", ip_buf);
canvas_draw_str_aligned(canvas, 64, 46, AlignCenter, AlignCenter, buf);
}
canvas_draw_str_aligned(canvas, 64, 58, AlignCenter, AlignCenter, "Waiting for data...");
break;
}
}
// Draw callback
static void draw_callback(Canvas* canvas, void* ctx) {
CanMonitorApp* app = ctx;
furi_mutex_acquire(app->mutex, FuriWaitForever);
// Check if we should show welcome screen
if(app->conn_state != StateConnected || !app->page.data_valid) {
furi_mutex_release(app->mutex);
draw_welcome(canvas, app);
return;
}
canvas_clear(canvas);
canvas_set_font(canvas, FontPrimary);
// Draw header
draw_header(canvas, app);
// Draw content based on page type
switch(app->page.page_type) {
case PageTypeInfo:
draw_info_page(canvas, app);
break;
case PageTypeMenu:
draw_menu_page(canvas, app);
break;
case PageTypeConfirm:
draw_confirm_page(canvas, app);
break;
}
// Draw footer
draw_footer(canvas, app->page.page_type, app->page.total_pages, app->page.page_index);
// Draw result overlay if present
if(app->result.has_result) {
draw_result_overlay(canvas, &app->result);
}
furi_mutex_release(app->mutex);
}
// Input callback
static void input_callback(InputEvent* event, void* ctx) {
CanMonitorApp* app = ctx;
if(event->type != InputTypeShort && event->type != InputTypeRepeat) {
return;
}
furi_mutex_acquire(app->mutex, FuriWaitForever);
// Handle welcome screen input
if(app->conn_state == StateDisconnected) {
if(event->key == InputKeyOk) {
app->send_init = true;
} else if(event->key == InputKeyBack) {
app->running = false;
}
furi_mutex_release(app->mutex);
return;
}
// Handle connected state input
if(app->conn_state == StateConnected && app->page.data_valid) {
switch(event->key) {
case InputKeyUp:
if(app->page.page_type == PageTypeInfo) {
// Scroll up on info pages
uart_send(app, "CMD:SCROLL:up\n");
} else if(app->page.page_type == PageTypeMenu && app->page.selected_index > 0) {
app->page.selected_index--;
view_port_update(app->view_port);
} else if(app->page.page_type == PageTypeConfirm) {
app->page.selected_index = 0; // Yes
view_port_update(app->view_port);
}
break;
case InputKeyDown:
if(app->page.page_type == PageTypeInfo) {
// Scroll down on info pages
uart_send(app, "CMD:SCROLL:down\n");
} else if(app->page.page_type == PageTypeMenu &&
app->page.selected_index < app->page.action_count - 1) {
app->page.selected_index++;
view_port_update(app->view_port);
} else if(app->page.page_type == PageTypeConfirm) {
app->page.selected_index = 1; // No
view_port_update(app->view_port);
}
break;
case InputKeyLeft:
// Navigate to previous page
uart_send(app, "CMD:NAV:prev\n");
break;
case InputKeyRight:
// Navigate to next page
uart_send(app, "CMD:NAV:next\n");
break;
case InputKeyOk:
if(app->page.page_type == PageTypeMenu) {
// Send selection
char cmd[32];
snprintf(cmd, sizeof(cmd), "CMD:SELECT:%d\n", app->page.selected_index);
uart_send(app, cmd);
} else if(app->page.page_type == PageTypeConfirm) {
if(app->page.selected_index == 0) {
uart_send(app, "CMD:CONFIRM\n");
} else {
uart_send(app, "CMD:CANCEL\n");
}
}
break;
case InputKeyBack:
if(app->page.page_type == PageTypeConfirm) {
// Cancel confirmation
uart_send(app, "CMD:CANCEL\n");
} else if(app->page.page_index == 0) {
// On first page, disconnect
uart_send(app, "STOP:flipper\n");
app->conn_state = StateDisconnected;
clear_page_content(&app->page);
view_port_update(app->view_port);
} else {
// Go to previous page
uart_send(app, "CMD:NAV:prev\n");
}
break;
default:
break;
}
} else if(event->key == InputKeyBack) {
// Disconnect and exit
if(app->conn_state != StateDisconnected) {
uart_send(app, "STOP:flipper\n");
}
app->running = false;
}
furi_mutex_release(app->mutex);
}
// Main entry point
int32_t can_monitor_app(void* p) {
UNUSED(p);
FURI_LOG_I(TAG, "Starting CAN Monitor (Dynamic UI)");
// Allocate app
CanMonitorApp* app = malloc(sizeof(CanMonitorApp));
memset(app, 0, sizeof(CanMonitorApp));
app->running = true;
app->conn_state = StateDisconnected;
app->send_init = false;
clear_page_content(&app->page);
// Mutex
app->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
// Disable expansion protocol
Expansion* expansion = furi_record_open(RECORD_EXPANSION);
expansion_disable(expansion);
furi_record_close(RECORD_EXPANSION);
FURI_LOG_I(TAG, "Expansion disabled");
// Init UART
app->rx_stream = furi_stream_buffer_alloc(RX_BUFFER_SIZE, 1);
app->serial = furi_hal_serial_control_acquire(FuriHalSerialIdUsart);
if(app->serial) {
furi_hal_serial_init(app->serial, UART_BAUD);
furi_hal_serial_async_rx_start(app->serial, uart_callback, app, false);
FURI_LOG_I(TAG, "UART initialized at %d baud", UART_BAUD);
} else {
FURI_LOG_E(TAG, "Failed to acquire UART");
}
// Start worker
app->worker_thread = furi_thread_alloc_ex("CanMonitorWorker", 2048, worker_thread, app);
furi_thread_start(app->worker_thread);
// Init GUI
app->gui = furi_record_open(RECORD_GUI);
app->view_port = view_port_alloc();
view_port_draw_callback_set(app->view_port, draw_callback, app);
view_port_input_callback_set(app->view_port, input_callback, app);
gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen);
FURI_LOG_I(TAG, "GUI initialized");
// Main loop
while(app->running) {
furi_delay_ms(100);
}
FURI_LOG_I(TAG, "Shutting down");
// Send disconnect signal
if(app->conn_state != StateDisconnected) {
uart_send(app, "STOP:flipper\n");
}
// Cleanup
furi_thread_join(app->worker_thread);
furi_thread_free(app->worker_thread);
if(app->serial) {
furi_hal_serial_async_rx_stop(app->serial);
furi_hal_serial_deinit(app->serial);
furi_hal_serial_control_release(app->serial);
}
furi_stream_buffer_free(app->rx_stream);
// Re-enable expansion
expansion = furi_record_open(RECORD_EXPANSION);
expansion_enable(expansion);
furi_record_close(RECORD_EXPANSION);
view_port_enabled_set(app->view_port, false);
gui_remove_view_port(app->gui, app->view_port);
view_port_free(app->view_port);
furi_record_close(RECORD_GUI);
furi_mutex_free(app->mutex);
free(app);
FURI_LOG_I(TAG, "Bye!");
return 0;
}