Momentum-Apps/zeitraffer.c

#include <stdio.h>
#include <furi.h>
#include <gui/gui.h>
#include <input/input.h>
#include <notification/notification_messages.h>
#include <flipper_format/flipper_format.h>

#include "gpio_item.h"
#include "zeitraffer_icons.h"

#define CONFIG_FILE_DIRECTORY_PATH "/ext/apps_data/zeitraffer"
#define CONFIG_FILE_PATH CONFIG_FILE_DIRECTORY_PATH "/zeitraffer.conf"

// Часть кода покрадена из https://github.com/zmactep/flipperzero-hello-world

int32_t Time = 10; // Таймер
int32_t Count = 10; // Количество кадров
int32_t WorkTime = 0; // Счётчик таймера
int32_t WorkCount = 0; // Счётчик кадров
bool InfiniteShot = false; // Бесконечная съёмка
bool Bulb = false; // Режим BULB
int32_t Backlight = 0; // Подсветка: вкл/выкл/авто
int32_t Delay = 3; // Задержка на отскочить
bool Work = false;

const NotificationSequence sequence_click = {
    &message_note_c7,
    &message_delay_50,
    &message_sound_off,
    NULL,
};

typedef enum {
    EventTypeTick,
    EventTypeInput,
} EventType;

typedef struct {
    EventType type;
    InputEvent input;
} ZeitrafferEvent;

static void draw_callback(Canvas* canvas, void* ctx) {
    UNUSED(ctx);
	char temp_str[36];
    canvas_clear(canvas);
    canvas_set_font(canvas, FontPrimary);
    switch (Count) {
	case -1:
		snprintf(temp_str,sizeof(temp_str),"Set: BULB %li sec",Time);
		break;
	case 0:
		snprintf(temp_str,sizeof(temp_str),"Set: infinite, %li sec",Time);
		break;
	default:
		snprintf(temp_str,sizeof(temp_str),"Set: %li frames, %li sec",Count,Time);
	}
	canvas_draw_str(canvas, 3, 15, temp_str);
	snprintf(temp_str,sizeof(temp_str),"Left: %li frames, %li sec",WorkCount,WorkTime);
	canvas_draw_str(canvas, 3, 35, temp_str);

    switch (Backlight) {
	case 1:
		canvas_draw_str(canvas, 13, 55, "ON");
		break;
	case 2:
		canvas_draw_str(canvas, 13, 55, "OFF");
		break;
	default:
		canvas_draw_str(canvas, 13, 55, "AUTO");
	}

	if(Work){
		canvas_draw_icon(canvas, 85, 41, &I_ButtonUpHollow_7x4);
		canvas_draw_icon(canvas, 85, 57, &I_ButtonDownHollow_7x4);
		canvas_draw_icon(canvas, 59, 48, &I_ButtonLeftHollow_4x7);
		canvas_draw_icon(canvas, 72, 48, &I_ButtonRightHollow_4x7);
	}
	else
	{
		canvas_draw_icon(canvas, 85, 41, &I_ButtonUp_7x4);
		canvas_draw_icon(canvas, 85, 57, &I_ButtonDown_7x4);
		canvas_draw_icon(canvas, 59, 48, &I_ButtonLeft_4x7);
		canvas_draw_icon(canvas, 72, 48, &I_ButtonRight_4x7);
	}
	
	canvas_draw_icon(canvas, 3, 48, &I_Pin_star_7x7);
	
	canvas_set_font(canvas, FontPrimary);
	canvas_draw_str(canvas, 65, 55, "F");

	canvas_set_font(canvas, FontPrimary);
	canvas_draw_str(canvas, 85, 55, "S");


	//canvas_draw_icon(canvas, 59, 48, &I_ButtonLeft_4x7);
	//canvas_draw_icon(canvas, 72, 48, &I_ButtonRight_4x7);

	if(Work) {canvas_draw_icon(canvas, 106, 46, &I_loading_10px);}

}

static void input_callback(InputEvent* input_event, void* ctx) {
    // Проверяем, что контекст не нулевой
    furi_assert(ctx);
    FuriMessageQueue* event_queue = ctx;

    ZeitrafferEvent event = {.type = EventTypeInput, .input = *input_event};
    furi_message_queue_put(event_queue, &event, FuriWaitForever);
}

static void timer_callback(FuriMessageQueue* event_queue) {
    // Проверяем, что контекст не нулевой
    furi_assert(event_queue);

    ZeitrafferEvent event = {.type = EventTypeTick};
    furi_message_queue_put(event_queue, &event, 0);
}

int32_t zeitraffer_app(void* p) {
    UNUSED(p);
	
    // Текущее событие типа кастомного типа ZeitrafferEvent
    ZeitrafferEvent event;
    // Очередь событий на 8 элементов размера ZeitrafferEvent
    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(ZeitrafferEvent));

    // Создаем новый view port
    ViewPort* view_port = view_port_alloc();
    // Создаем callback отрисовки, без контекста
    view_port_draw_callback_set(view_port, draw_callback, NULL);
    // Создаем callback нажатий на клавиши, в качестве контекста передаем
    // нашу очередь сообщений, чтоб запихивать в неё эти события
    view_port_input_callback_set(view_port, input_callback, event_queue);

    // Создаем GUI приложения
    Gui* gui = furi_record_open(RECORD_GUI);
    // Подключаем view port к GUI в полноэкранном режиме
    gui_add_view_port(gui, view_port, GuiLayerFullscreen);
	
	// Конфигурим пины
	gpio_item_configure_all_pins(GpioModeOutputPushPull);

    // Создаем периодический таймер с коллбэком, куда в качестве
    // контекста будет передаваться наша очередь событий
    FuriTimer* timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, event_queue);
    // Запускаем таймер
    //furi_timer_start(timer, 1500);

    // Включаем нотификации
    NotificationApp* notifications = furi_record_open(RECORD_NOTIFICATION);
	
	
	Storage* storage = furi_record_open(RECORD_STORAGE);
	
	// Загружаем настройки
	FlipperFormat* load = flipper_format_file_alloc(storage);
  
	do {
		if(!storage_simply_mkdir(storage, CONFIG_FILE_DIRECTORY_PATH)) {notification_message(notifications, &sequence_error); break;}
		if(!flipper_format_file_open_existing(load, CONFIG_FILE_PATH)) {notification_message(notifications, &sequence_error); break;}
		if(!flipper_format_read_int32(load, "Time", &Time, 1)) {notification_message(notifications, &sequence_error); break;}
		if(!flipper_format_read_int32(load, "Count", &Count, 1)) {notification_message(notifications, &sequence_error); break;}
		if(!flipper_format_read_int32(load, "Backlight", &Backlight, 1)) {notification_message(notifications, &sequence_error); break;}
		if(!flipper_format_read_int32(load, "Delay", &Delay, 1)) {notification_message(notifications, &sequence_error); break;}
		notification_message(notifications, &sequence_success);
		
	} while(0);
 
	flipper_format_free(load);
	
    // Бесконечный цикл обработки очереди событий
    while(1) {
        // Выбираем событие из очереди в переменную event (ждем бесконечно долго, если очередь пуста)
        // и проверяем, что у нас получилось это сделать
        furi_check(furi_message_queue_get(event_queue, &event, FuriWaitForever) == FuriStatusOk);

       // Наше событие — это нажатие кнопки
		if(event.type == EventTypeInput) {
			if(event.input.type == InputTypeShort) { // Короткие нажатия
	
				if(event.input.key == InputKeyBack) {
					if(Work) { // Если таймер запущен - нефиг мацать кнопки!
						notification_message(notifications, &sequence_error);
					}
					else {
						WorkCount = Count;
						WorkTime = 3;
						if (Count == 0) {
							InfiniteShot = true; 
							WorkCount = 1;
						} 
						else 
							InfiniteShot = false;
					
						notification_message(notifications, &sequence_success); 
					}
				}
				if(event.input.key == InputKeyRight) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 			
						Count++;
						notification_message(notifications, &sequence_click);
					}
				}
				if(event.input.key == InputKeyLeft) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Count--;
					notification_message(notifications, &sequence_click);
					}
				}
				if(event.input.key == InputKeyUp) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Time++;
						notification_message(notifications, &sequence_click);
					}
				}
				if(event.input.key == InputKeyDown) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Time--;
						notification_message(notifications, &sequence_click);
					}
				}
				if(event.input.key == InputKeyOk) {
			
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_click);
						furi_timer_stop(timer); 
						Work = false;
					}
					else { 
						furi_timer_start(timer, 1000);
						Work = true;
					
						if (WorkCount == 0) 
							WorkCount = Count;
					
						if (WorkTime == 0) 
							WorkTime = Delay;
						
						if (Count == 1)
							WorkTime = Time;  
						
						if (Count == 0) {
							InfiniteShot = true; 
							WorkCount = 1;
						} 
						else 
							InfiniteShot = false;
					
						if (Count == -1) {
							gpio_item_set_pin(4, true); 
							gpio_item_set_pin(5, true); 
							Bulb = true; 
							WorkCount = 1; 
							WorkTime = Time;
							} 
							else 
								Bulb = false;
					
						notification_message(notifications, &sequence_success);
					}
				}
			}
			if(event.input.type == InputTypeLong) { // Длинные нажатия
				// Если нажата кнопка "назад", то выходим из цикла, а следовательно и из приложения
				if(event.input.key == InputKeyBack) {
					if(furi_timer_is_running(timer)) { // А если работает таймер - не выходим :D
						notification_message(notifications, &sequence_error);
					}
					else {
						notification_message(notifications, &sequence_click);
						gpio_item_set_all_pins(false);
						furi_timer_stop(timer);
						notification_message(notifications, &sequence_display_backlight_enforce_auto);
						break;
					}
				}
				if(event.input.key == InputKeyOk) {
					// Нам ваша подсветка и нахой не нужна! Или нужна?
					Backlight++;
					if (Backlight > 2) Backlight = 0;
					}

			}

			if(event.input.type == InputTypeRepeat) { // Зажатые кнопки
				if(event.input.key == InputKeyRight) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Count = Count+10;
					}
				}
				if(event.input.key == InputKeyLeft) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Count = Count-10;
					}
				}
				if(event.input.key == InputKeyUp) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Time = Time+10;
					}
				}
				if(event.input.key == InputKeyDown) {
					if(furi_timer_is_running(timer)) {
						notification_message(notifications, &sequence_error);
					}
					else { 
						Time = Time-10;
					}
				}
			}
        }
		
        // Наше событие — это сработавший таймер
		else if(event.type == EventTypeTick) {
            
			WorkTime--;
			
			if( WorkTime < 1 ) { // фоткаем
				notification_message(notifications, &sequence_blink_white_100);
				if (Bulb) {
					gpio_item_set_all_pins(false); WorkCount = 0;
				}
				else {
					WorkCount--;
					view_port_update(view_port);
					notification_message(notifications, &sequence_click);
					// Дрыгаем ногами
					//gpio_item_set_all_pins(true);
					gpio_item_set_pin(4, true);
					gpio_item_set_pin(5, true);
					furi_delay_ms(400); // На короткие нажатия фотик плохо реагирует
					gpio_item_set_pin(4, false);
					gpio_item_set_pin(5, false);
					//gpio_item_set_all_pins(false);

					if (InfiniteShot) WorkCount++;
				
					WorkTime = Time;
					view_port_update(view_port);
				}
			}
			else {
				// Отправляем нотификацию мигания синим светодиодом
				notification_message(notifications, &sequence_blink_blue_100);
			}
			
			if( WorkCount < 1 ) { // закончили
				Work = false;
				gpio_item_set_all_pins(false);
				furi_timer_stop(timer); 
				notification_message(notifications, &sequence_audiovisual_alert);
				WorkTime = 3;
				WorkCount = 0;
			}
			
			switch (Backlight) { // чо по подсветке?
				case 1:
					notification_message(notifications, &sequence_display_backlight_on);
					break;
				case 2: 
					notification_message(notifications, &sequence_display_backlight_off);
					break;
				default:
					notification_message(notifications, &sequence_display_backlight_enforce_auto);
			}
			
        }
		if (Time < 1) Time = 1; // Не даём открутить таймер меньше единицы
		if (Count < -1) Count = 0; // А тут даём, бо 0 кадров это бесконечная съёмка, а -1 кадров - BULB
	}


	// Схороняем настройки
	FlipperFormat* save = flipper_format_file_alloc(storage);

	do {

     if(!flipper_format_file_open_always(save, CONFIG_FILE_PATH)) {notification_message(notifications, &sequence_error); break;}
     if(!flipper_format_write_header_cstr(save, "Zeitraffer", 1)) {notification_message(notifications, &sequence_error); break;}
     if(!flipper_format_write_comment_cstr(save, "Zeitraffer app settings: № of frames, interval time, backlight type, Delay")) {notification_message(notifications, &sequence_error); break;}     
     if(!flipper_format_write_int32(save, "Time", &Time, 1)) {notification_message(notifications, &sequence_error); break;}
     if(!flipper_format_write_int32(save, "Count", &Count, 1)) {notification_message(notifications, &sequence_error); break;}
     if(!flipper_format_write_int32(save, "Backlight", &Backlight, 1)) {notification_message(notifications, &sequence_error); break;}
	 if(!flipper_format_write_int32(save, "Delay", &Delay, 1)) {notification_message(notifications, &sequence_error); break;}
	 
	} while(0);

	flipper_format_free(save);

	furi_record_close(RECORD_STORAGE);

    // Очищаем таймер
    furi_timer_free(timer);

    // Специальная очистка памяти, занимаемой очередью
    furi_message_queue_free(event_queue);

    // Чистим созданные объекты, связанные с интерфейсом
    gui_remove_view_port(gui, view_port);
    view_port_free(view_port);
    furi_record_close(RECORD_GUI);

    // Очищаем нотификации
    furi_record_close(RECORD_NOTIFICATION);

    return 0;
}