Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-13 02:38:35 -07:00
Code Issues Packages Projects Releases Wiki Activity

Temporarily backport app updates from apps repo

Browse Source
This commit is contained in:
Willy-JL
2023-11-12 11:06:02 +00:00
parent 79e7f491fe
commit e309fa8a88
1498 changed files with 1325977 additions and 20227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

413
applications/external/camera_suite/views/camera_suite_view_camera.c vendored
View File

@@ -8,48 +8,39 @@
#include "../helpers/camera_suite_speaker.h"
#include "../helpers/camera_suite_led.h"
static CameraSuiteViewCamera* current_instance = NULL;
struct CameraSuiteViewCamera {
CameraSuiteViewCameraCallback callback;
FuriStreamBuffer* rx_stream;
FuriThread* worker_thread;
View* view;
void* context;
};
void camera_suite_view_camera_set_callback(
CameraSuiteViewCamera* instance,
CameraSuiteViewCameraCallback callback,
void* context) {
furi_assert(instance);
furi_assert(callback);
instance->callback = callback;
instance->context = context;
}
// Function to draw pixels on the canvas based on camera orientation
static void draw_pixel_by_orientation(Canvas* canvas, uint8_t x, uint8_t y, uint8_t orientation) {
furi_assert(canvas);
furi_assert(x);
furi_assert(y);
furi_assert(orientation);
switch(orientation) {
case 0: // Camera rotated 0 degrees (right side up, default)
default:
case 0: { // Camera rotated 0 degrees (right side up, default)
canvas_draw_dot(canvas, x, y);
break;
case 1: // Camera rotated 90 degrees
}
case 1: { // Camera rotated 90 degrees
canvas_draw_dot(canvas, y, FRAME_WIDTH - 1 - x);
break;
case 2: // Camera rotated 180 degrees (upside down)
}
case 2: { // Camera rotated 180 degrees (upside down)
canvas_draw_dot(canvas, FRAME_WIDTH - 1 - x, FRAME_HEIGHT - 1 - y);
break;
case 3: // Camera rotated 270 degrees
}
case 3: { // Camera rotated 270 degrees
canvas_draw_dot(canvas, FRAME_HEIGHT - 1 - y, x);
break;
default:
break;
}
}
}
static void camera_suite_view_camera_draw(Canvas* canvas, void* _model) {
UartDumpModel* model = _model;
static void camera_suite_view_camera_draw(Canvas* canvas, void* model) {
furi_assert(canvas);
furi_assert(model);
UartDumpModel* uartDumpModel = model;
// Clear the screen.
canvas_set_color(canvas, ColorBlack);
@@ -57,21 +48,19 @@ static void camera_suite_view_camera_draw(Canvas* canvas, void* _model) {
// Draw the frame.
canvas_draw_frame(canvas, 0, 0, FRAME_WIDTH, FRAME_HEIGHT);
CameraSuite* app = current_instance->context;
for(size_t p = 0; p < FRAME_BUFFER_LENGTH; ++p) {
uint8_t x = p % ROW_BUFFER_LENGTH; // 0 .. 15
uint8_t y = p / ROW_BUFFER_LENGTH; // 0 .. 63
for(uint8_t i = 0; i < 8; ++i) {
if((model->pixels[p] & (1 << (7 - i))) != 0) {
draw_pixel_by_orientation(canvas, (x * 8) + i, y, app->orientation);
if((uartDumpModel->pixels[p] & (1 << (7 - i))) != 0) {
draw_pixel_by_orientation(canvas, (x * 8) + i, y, uartDumpModel->orientation);
}
}
}
// Draw the guide if the camera is not initialized.
if(!model->initialized) {
if(!uartDumpModel->initialized) {
canvas_draw_icon(canvas, 74, 16, &I_DolphinCommon_56x48);
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 8, 12, "Connect the ESP32-CAM");
@@ -82,15 +71,106 @@ static void camera_suite_view_camera_draw(Canvas* canvas, void* _model) {
}
}
static void camera_suite_view_camera_model_init(UartDumpModel* const model) {
static void save_image(void* model) {
furi_assert(model);
UartDumpModel* uartDumpModel = model;
// This pointer is used to access the storage.
Storage* storage = furi_record_open(RECORD_STORAGE);
// This pointer is used to access the filesystem.
File* file = storage_file_alloc(storage);
// Store path in local variable.
const char* folderName = EXT_PATH("DCIM");
// Create the folder name for the image file if it does not exist.
if(storage_common_stat(storage, folderName, NULL) == FSE_NOT_EXIST) {
storage_simply_mkdir(storage, folderName);
}
// This pointer is used to access the file name.
FuriString* file_name = furi_string_alloc();
// Get the current date and time.
FuriHalRtcDateTime datetime = {0};
furi_hal_rtc_get_datetime(&datetime);
// Create the file name.
furi_string_printf(
file_name,
EXT_PATH("DCIM/%.4d%.2d%.2d-%.2d%.2d%.2d.bmp"),
datetime.year,
datetime.month,
datetime.day,
datetime.hour,
datetime.minute,
datetime.second);
// Open the file for writing. If the file does not exist (it shouldn't),
// create it.
bool result =
storage_file_open(file, furi_string_get_cstr(file_name), FSAM_WRITE, FSOM_OPEN_ALWAYS);
// Free the file name after use.
furi_string_free(file_name);
if(!uartDumpModel->inverted) {
for(size_t i = 0; i < FRAME_BUFFER_LENGTH; ++i) {
uartDumpModel->pixels[i] = ~uartDumpModel->pixels[i];
}
}
// If the file was opened successfully, write the bitmap header and the
// image data.
if(result) {
// Write BMP Header
storage_file_write(file, bitmap_header, BITMAP_HEADER_LENGTH);
// @todo - Add a function for saving the image directly from the
// ESP32-CAM to the Flipper Zero SD card.
// Write locally to the Flipper Zero SD card in the DCIM folder.
int8_t row_buffer[ROW_BUFFER_LENGTH];
// @todo - Save image based on orientation.
for(size_t i = 64; i > 0; --i) {
for(size_t j = 0; j < ROW_BUFFER_LENGTH; ++j) {
row_buffer[j] = uartDumpModel->pixels[((i - 1) * ROW_BUFFER_LENGTH) + j];
}
storage_file_write(file, row_buffer, ROW_BUFFER_LENGTH);
}
}
// Close the file.
storage_file_close(file);
// Free up memory.
storage_file_free(file);
}
static void
camera_suite_view_camera_model_init(UartDumpModel* const model, CameraSuite* instance_context) {
furi_assert(model);
furi_assert(instance_context);
for(size_t i = 0; i < FRAME_BUFFER_LENGTH; i++) {
model->pixels[i] = 0;
}
uint32_t orientation = instance_context->orientation;
model->flash = instance_context->flash;
model->inverted = false;
model->orientation = orientation;
}
static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
furi_assert(context);
furi_assert(event);
CameraSuiteViewCamera* instance = context;
if(event->type == InputTypeRelease) {
switch(event->key) {
default: // Stop all sounds, reset the LED.
@@ -106,13 +186,18 @@ static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
true);
break;
}
// Send `data` to the ESP32-CAM
} else if(event->type == InputTypePress) {
uint8_t data[1];
uint8_t data[1] = {'X'};
switch(event->key) {
case InputKeyBack:
// Stop the camera stream.
data[0] = 's';
// Camera: Stop stream.
case InputKeyBack: {
// Set the camera flash to off.
uint8_t flash_off = 'f';
furi_hal_uart_tx(UART_CH, &flash_off, 1);
furi_delay_ms(50);
// Stop camera stream.
uint8_t stop_camera = 's';
furi_hal_uart_tx(UART_CH, &stop_camera, 1);
// Go back to the main menu.
with_view_model(
instance->view,
@@ -123,9 +208,9 @@ static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
},
true);
break;
case InputKeyLeft:
// Camera: Invert.
data[0] = '<';
}
// Camera: Toggle invert on the ESP32-CAM.
case InputKeyLeft: {
with_view_model(
instance->view,
UartDumpModel * model,
@@ -134,12 +219,20 @@ static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
camera_suite_play_happy_bump(instance->context);
camera_suite_play_input_sound(instance->context);
camera_suite_led_set_rgb(instance->context, 0, 0, 255);
if(model->inverted) {
data[0] = 'i';
model->inverted = false;
} else {
data[0] = 'I';
model->inverted = true;
}
instance->callback(CameraSuiteCustomEventSceneCameraLeft, instance->context);
},
true);
break;
case InputKeyRight:
// Camera: Enable/disable dithering.
}
// Camera: Enable/disable dithering.
case InputKeyRight: {
data[0] = '>';
with_view_model(
instance->view,
@@ -153,8 +246,9 @@ static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
},
true);
break;
case InputKeyUp:
// Camera: Increase contrast.
}
// Camera: Increase contrast.
case InputKeyUp: {
data[0] = 'C';
with_view_model(
instance->view,
@@ -168,8 +262,9 @@ static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
},
true);
break;
case InputKeyDown:
// Camera: Reduce contrast.
}
// Camera: Reduce contrast.
case InputKeyDown: {
data[0] = 'c';
with_view_model(
instance->view,
@@ -183,58 +278,113 @@ static bool camera_suite_view_camera_input(InputEvent* event, void* context) {
},
true);
break;
case InputKeyOk:
// Switch dithering types.
data[0] = 'D';
}
// Camera: Take picture.
case InputKeyOk: {
with_view_model(
instance->view,
UartDumpModel * model,
{
UNUSED(model);
camera_suite_play_happy_bump(instance->context);
camera_suite_play_long_bump(instance->context);
camera_suite_play_input_sound(instance->context);
camera_suite_led_set_rgb(instance->context, 0, 0, 255);
// Save picture directly to ESP32-CAM.
// @todo - Add this functionality.
// data[0] = 'P';
// furi_hal_uart_tx(UART_CH, data, 1);
// if(model->flash) {
// data[0] = 'F';
// furi_hal_uart_tx(UART_CH, data, 1);
// furi_delay_ms(50);
// }
// Take a picture.
save_image(model);
// if(model->flash) {
// data[0] = 'f';
// }
instance->callback(CameraSuiteCustomEventSceneCameraOk, instance->context);
},
true);
break;
}
// Camera: Do nothing.
case InputKeyMAX:
default: {
break;
}
// Send `data` to the ESP32-CAM
furi_hal_uart_tx(UART_CH, data, 1);
}
if(data[0] != 'X') {
// Send `data` to the ESP32-CAM.
furi_hal_uart_tx(UART_CH, data, 1);
}
}
return true;
}
static void camera_suite_view_camera_exit(void* context) {
furi_assert(context);
UNUSED(context);
// Set the camera flash to off.
uint8_t flash_off = 'f';
furi_hal_uart_tx(UART_CH, &flash_off, 1);
furi_delay_ms(50);
// Stop camera stream.
uint8_t stop_camera = 's';
furi_hal_uart_tx(UART_CH, &stop_camera, 1);
furi_delay_ms(50);
}
static void camera_suite_view_camera_enter(void* context) {
// Check `context` for null. If it is null, abort program, else continue.
furi_assert(context);
// Cast `context` to `CameraSuiteViewCamera*` and store it in `instance`.
// Get the camera suite instance context.
CameraSuiteViewCamera* instance = (CameraSuiteViewCamera*)context;
// Assign the current instance to the global variable
current_instance = instance;
// Get the camera suite instance context.
CameraSuite* instance_context = instance->context;
uint8_t data[1];
data[0] = 'S'; // Uppercase `S` to start the camera
// Send `data` to the ESP32-CAM
furi_hal_uart_tx(UART_CH, data, 1);
// Start camera stream.
uint8_t start_camera = 'S';
furi_hal_uart_tx(UART_CH, &start_camera, 1);
furi_delay_ms(75);
// Get/set dither type.
uint8_t dither_type = instance_context->dither;
furi_hal_uart_tx(UART_CH, &dither_type, 1);
furi_delay_ms(75);
// Make sure the camera is not inverted.
uint8_t invert_camera = 'i';
furi_hal_uart_tx(UART_CH, &invert_camera, 1);
furi_delay_ms(75);
// Toggle flash on or off based on the current state. This will keep the
// flash on initially. However we're toggling it for now on input.
uint8_t flash_state = instance_context->flash ? 'F' : 'f';
furi_hal_uart_tx(UART_CH, &flash_state, 1);
furi_delay_ms(75);
// Make sure we start with the flash off.
// uint8_t flash_state = 'f';
// furi_hal_uart_tx(UART_CH, &flash_state, 1);
// furi_delay_ms(75);
with_view_model(
instance->view,
UartDumpModel * model,
{ camera_suite_view_camera_model_init(model); },
{ camera_suite_view_camera_model_init(model, instance_context); },
true);
}
static void camera_on_irq_cb(UartIrqEvent uartIrqEvent, uint8_t data, void* context) {
// Check `context` for null. If it is null, abort program, else continue.
furi_assert(uartIrqEvent);
furi_assert(data);
furi_assert(context);
// Cast `context` to `CameraSuiteViewCamera*` and store it in `instance`.
@@ -248,47 +398,57 @@ static void camera_on_irq_cb(UartIrqEvent uartIrqEvent, uint8_t data, void* cont
}
}
static void process_ringbuffer(UartDumpModel* model, uint8_t byte) {
// First char has to be 'Y' in the buffer.
if(model->ringbuffer_index == 0 && byte != 'Y') {
static void process_ringbuffer(UartDumpModel* model, uint8_t const byte) {
furi_assert(model);
furi_assert(byte);
// The first HEADER_LENGTH bytes are reserved for header information.
if(model->ringbuffer_index < HEADER_LENGTH) {
// Validate the start of row characters 'Y' and ':'.
if(model->ringbuffer_index == 0 && byte != 'Y') {
// Incorrect start of frame; reset.
return;
}
if(model->ringbuffer_index == 1 && byte != ':') {
// Incorrect start of frame; reset.
model->ringbuffer_index = 0;
return;
}
if(model->ringbuffer_index == 2) {
// Assign the third byte as the row identifier.
model->row_identifier = byte;
}
model->ringbuffer_index++; // Increment index for the next byte.
return;
}
// Second char has to be ':' in the buffer or reset.
if(model->ringbuffer_index == 1 && byte != ':') {
model->ringbuffer_index = 0;
process_ringbuffer(model, byte);
return;
}
// Store pixel value directly after the header.
model->row_ringbuffer[model->ringbuffer_index - HEADER_LENGTH] = byte;
model->ringbuffer_index++; // Increment index for the next byte.
// Assign current byte to the ringbuffer.
model->row_ringbuffer[model->ringbuffer_index] = byte;
// Increment the ringbuffer index.
++model->ringbuffer_index;
// Check whether the ring buffer is filled.
if(model->ringbuffer_index >= RING_BUFFER_LENGTH) {
model->ringbuffer_index = 0; // Reset the ring buffer index.
model->initialized = true; // Set the connection as successfully established.
// Let's wait 'till the buffer fills.
if(model->ringbuffer_index < RING_BUFFER_LENGTH) {
return;
}
// Compute the starting index for the row in the pixel buffer.
size_t row_start_index = model->row_identifier * ROW_BUFFER_LENGTH;
// Flush the ringbuffer to the framebuffer.
model->ringbuffer_index = 0; // Reset the ringbuffer
model->initialized = true; // Established the connection successfully.
size_t row_start_index =
model->row_ringbuffer[2] * ROW_BUFFER_LENGTH; // Third char will determine the row number
// Ensure the row start index is within the valid range.
if(row_start_index > LAST_ROW_INDEX) {
row_start_index = 0; // Reset to a safe value in case of an overflow.
}
if(row_start_index > LAST_ROW_INDEX) { // Failsafe
row_start_index = 0;
}
for(size_t i = 0; i < ROW_BUFFER_LENGTH; ++i) {
model->pixels[row_start_index + i] =
model->row_ringbuffer[i + 3]; // Writing the remaining 16 bytes into the frame buffer
// Flush the contents of the ring buffer to the pixel buffer.
for(size_t i = 0; i < ROW_BUFFER_LENGTH; ++i) {
model->pixels[row_start_index + i] = model->row_ringbuffer[i];
}
}
}
static int32_t camera_worker(void* context) {
furi_assert(context);
CameraSuiteViewCamera* instance = context;
while(1) {
@@ -328,36 +488,49 @@ static int32_t camera_worker(void* context) {
}
CameraSuiteViewCamera* camera_suite_view_camera_alloc() {
// Allocate memory for the instance
CameraSuiteViewCamera* instance = malloc(sizeof(CameraSuiteViewCamera));
// Allocate the view object
instance->view = view_alloc();
// Allocate a stream buffer
instance->rx_stream = furi_stream_buffer_alloc(2048, 1);
// Set up views
// Allocate model
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(UartDumpModel));
view_set_context(instance->view, instance); // furi_assert crashes in events without this
// Set context for the view
view_set_context(instance->view, instance);
// Set draw callback
view_set_draw_callback(instance->view, (ViewDrawCallback)camera_suite_view_camera_draw);
// Set input callback
view_set_input_callback(instance->view, camera_suite_view_camera_input);
// Set enter callback
view_set_enter_callback(instance->view, camera_suite_view_camera_enter);
// Set exit callback
view_set_exit_callback(instance->view, camera_suite_view_camera_exit);
with_view_model(
instance->view,
UartDumpModel * model,
{ camera_suite_view_camera_model_init(model); },
true);
instance->worker_thread = furi_thread_alloc_ex("UsbUartWorker", 2048, camera_worker, instance);
// Allocate a thread for this camera to run on.
FuriThread* thread = furi_thread_alloc_ex("UsbUartWorker", 2048, camera_worker, instance);
instance->worker_thread = thread;
furi_thread_start(instance->worker_thread);
// Enable uart listener
if(UART_CH == FuriHalUartIdUSART1) {
if(UART_CH == UART_CH) {
furi_hal_console_disable();
} else if(UART_CH == FuriHalUartIdLPUART1) {
furi_hal_uart_init(UART_CH, 230400);
}
// 115200 is the default baud rate for the ESP32-CAM.
furi_hal_uart_set_br(UART_CH, 230400);
// Enable UART1 and set the IRQ callback.
furi_hal_uart_set_irq_cb(UART_CH, camera_on_irq_cb, instance);
return instance;
@@ -366,21 +539,39 @@ CameraSuiteViewCamera* camera_suite_view_camera_alloc() {
void camera_suite_view_camera_free(CameraSuiteViewCamera* instance) {
furi_assert(instance);
with_view_model(
instance->view, UartDumpModel * model, { UNUSED(model); }, true);
view_free(instance->view);
free(instance);
// Remove the IRQ callback.
furi_hal_uart_set_irq_cb(UART_CH, NULL, NULL);
// Free the worker thread.
furi_thread_free(instance->worker_thread);
// Free the allocated stream buffer.
furi_stream_buffer_free(instance->rx_stream);
// Re-enable the console.
if(UART_CH == FuriHalUartIdLPUART1) {
furi_hal_uart_deinit(UART_CH);
} else {
furi_hal_console_enable();
}
with_view_model(
instance->view, UartDumpModel * model, { UNUSED(model); }, true);
view_free(instance->view);
free(instance);
}
View* camera_suite_view_camera_get_view(CameraSuiteViewCamera* instance) {
furi_assert(instance);
return instance->view;
}
void camera_suite_view_camera_set_callback(
CameraSuiteViewCamera* instance,
CameraSuiteViewCameraCallback callback,
void* context) {
furi_assert(instance);
furi_assert(callback);
instance->callback = callback;
instance->context = context;
}

82
applications/external/camera_suite/views/camera_suite_view_camera.h vendored
View File

@@ -1,3 +1,5 @@
#pragma once
#include "../helpers/camera_suite_custom_event.h"
#include <furi.h>
#include <furi_hal.h>
@@ -19,48 +21,60 @@
#define UART_CH \
(xtreme_settings.uart_esp_channel == UARTDefault ? FuriHalUartIdUSART1 : FuriHalUartIdLPUART1)
#pragma once
#define FRAME_WIDTH 128
#define FRAME_HEIGHT 64
#define BITMAP_HEADER_LENGTH 62
#define FRAME_BIT_DEPTH 1
#define FRAME_BUFFER_LENGTH 1024
#define ROW_BUFFER_LENGTH 16
#define RING_BUFFER_LENGTH 19
#define FRAME_HEIGHT 64
#define FRAME_WIDTH 128
#define HEADER_LENGTH 3 // 'Y', ':', and row identifier
#define LAST_ROW_INDEX 1008
#define RING_BUFFER_LENGTH 19
#define ROW_BUFFER_LENGTH 16
static const unsigned char bitmap_header[BITMAP_HEADER_LENGTH] = {
0x42, 0x4D, 0x3E, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00};
extern const Icon I_DolphinCommon_56x48;
typedef struct UartDumpModel UartDumpModel;
struct UartDumpModel {
bool initialized;
int rotation_angle;
uint8_t pixels[FRAME_BUFFER_LENGTH];
uint8_t ringbuffer_index;
uint8_t row_ringbuffer[RING_BUFFER_LENGTH];
};
typedef struct CameraSuiteViewCamera CameraSuiteViewCamera;
typedef void (*CameraSuiteViewCameraCallback)(CameraSuiteCustomEvent event, void* context);
void camera_suite_view_camera_set_callback(
CameraSuiteViewCamera* camera_suite_view_camera,
CameraSuiteViewCameraCallback callback,
void* context);
CameraSuiteViewCamera* camera_suite_view_camera_alloc();
void camera_suite_view_camera_free(CameraSuiteViewCamera* camera_suite_static);
View* camera_suite_view_camera_get_view(CameraSuiteViewCamera* camera_suite_static);
typedef enum {
// Reserved for StreamBuffer internal event
WorkerEventReserved = (1 << 0),
WorkerEventReserved = (1 << 0), // Reserved for StreamBuffer internal event
WorkerEventStop = (1 << 1),
WorkerEventRx = (1 << 2),
} WorkerEventFlags;
#define WORKER_EVENTS_MASK (WorkerEventStop | WorkerEventRx)
// Forward declaration
typedef void (*CameraSuiteViewCameraCallback)(CameraSuiteCustomEvent event, void* context);
typedef struct CameraSuiteViewCamera {
CameraSuiteViewCameraCallback callback;
FuriStreamBuffer* rx_stream;
FuriThread* worker_thread;
NotificationApp* notification;
View* view;
void* context;
} CameraSuiteViewCamera;
typedef struct UartDumpModel {
bool flash;
bool initialized;
bool inverted;
int rotation_angle;
uint32_t orientation;
uint8_t pixels[FRAME_BUFFER_LENGTH];
uint8_t ringbuffer_index;
uint8_t row_identifier;
uint8_t row_ringbuffer[RING_BUFFER_LENGTH];
} UartDumpModel;
// Function Prototypes
CameraSuiteViewCamera* camera_suite_view_camera_alloc();
View* camera_suite_view_camera_get_view(CameraSuiteViewCamera* camera_suite_static);
void camera_suite_view_camera_free(CameraSuiteViewCamera* camera_suite_static);
void camera_suite_view_camera_set_callback(
CameraSuiteViewCamera* camera_suite_view_camera,
CameraSuiteViewCameraCallback callback,
void* context);

11
applications/external/camera_suite/views/camera_suite_view_guide.c vendored
View File

@@ -32,12 +32,11 @@ void camera_suite_view_guide_draw(Canvas* canvas, CameraSuiteViewGuideModel* mod
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 0, 0, AlignLeft, AlignTop, "Guide");
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(canvas, 0, 12, AlignLeft, AlignTop, "Left = Toggle Invert");
canvas_draw_str_aligned(canvas, 0, 22, AlignLeft, AlignTop, "Right = Toggle Dithering");
canvas_draw_str_aligned(canvas, 0, 32, AlignLeft, AlignTop, "Up = Contrast Up");
canvas_draw_str_aligned(canvas, 0, 42, AlignLeft, AlignTop, "Down = Contrast Down");
// TODO: Possibly update to take picture instead.
canvas_draw_str_aligned(canvas, 0, 52, AlignLeft, AlignTop, "Center = Toggle Dither Type");
canvas_draw_str_aligned(canvas, 0, 12, AlignLeft, AlignTop, "Left = Toggle invert");
canvas_draw_str_aligned(canvas, 0, 22, AlignLeft, AlignTop, "Right = Toggle dithering");
canvas_draw_str_aligned(canvas, 0, 32, AlignLeft, AlignTop, "Up = Contrast up");
canvas_draw_str_aligned(canvas, 0, 42, AlignLeft, AlignTop, "Down = Contrast down");
canvas_draw_str_aligned(canvas, 0, 52, AlignLeft, AlignTop, "Center = Take picture");
}
static void camera_suite_view_guide_model_init(CameraSuiteViewGuideModel* const model) {