Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-14 00:08:36 -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

13
applications/external/atomicdiceroller/application.fam vendored Normal file
View File

@@ -0,0 +1,13 @@
App(
appid="flipper_atomicdiceroller",
name="[J305] Atomic Dice Roller",
apptype=FlipperAppType.EXTERNAL,
entry_point="flipper_atomicdiceroller_app",
cdefines=["APP_ATOMICDICEROLLER"],
requires=[
"gui",
],
stack_size=2 * 1024,
fap_icon="atomicdiceroller.png",
fap_category="GPIO",
)

BIN
applications/external/atomicdiceroller/atomicdiceroller.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.2 KiB

349
applications/external/atomicdiceroller/flipper_atomicdiceroller.c vendored Normal file
View File

@@ -0,0 +1,349 @@
// CC0 1.0 Universal (CC0 1.0)
// Public Domain Dedication
// https://github.com/nmrr
#include <stdio.h>
#include <furi.h>
#include <gui/gui.h>
#include <input/input.h>
#include <notification/notification_messages.h>
#include <furi_hal_power.h>
#include <locale/locale.h>
#include <toolbox/crc32_calc.h>
#include <lib/toolbox/md5.h>
#define SCREEN_SIZE_X 128
#define SCREEN_SIZE_Y 64
typedef enum {
EventTypeInput,
ClockEventTypeTick,
ClockEventTypeTickPause,
EventGPIO,
} EventType;
typedef struct {
EventType type;
InputEvent input;
} EventApp;
#define lineArraySize 128
typedef struct {
FuriMutex* mutex;
uint32_t cps;
uint32_t diceAvailiable;
uint8_t dice;
uint8_t method;
uint8_t pause;
} mutexStruct;
static void draw_callback(Canvas* canvas, void* ctx) {
mutexStruct* mutexVal = ctx;
mutexStruct mutexDraw;
furi_mutex_acquire(mutexVal->mutex, FuriWaitForever);
memcpy(&mutexDraw, mutexVal, sizeof(mutexStruct));
furi_mutex_release(mutexVal->mutex);
canvas_set_font(canvas, FontPrimary);
char buffer[32];
snprintf(buffer, sizeof(buffer), "%ld cps", mutexDraw.cps);
canvas_draw_str_aligned(canvas, 0, 10, AlignLeft, AlignBottom, buffer);
snprintf(buffer, sizeof(buffer), "%lu/64", mutexDraw.diceAvailiable);
canvas_draw_str_aligned(canvas, SCREEN_SIZE_X, 10, AlignRight, AlignBottom, buffer);
if(mutexDraw.method == 0)
canvas_draw_str_aligned(canvas, 0, 20, AlignLeft, AlignBottom, "Hash: CRC32");
else
canvas_draw_str_aligned(canvas, 0, 20, AlignLeft, AlignBottom, "Hash: MD5");
if(mutexDraw.dice != 0 && mutexDraw.pause == 0) {
canvas_set_font(canvas, FontBigNumbers);
snprintf(buffer, sizeof(buffer), "%u", mutexDraw.dice);
canvas_draw_str_aligned(canvas, SCREEN_SIZE_X / 2, 50, AlignCenter, AlignBottom, buffer);
}
}
static void input_callback(InputEvent* input_event, void* ctx) {
furi_assert(ctx);
FuriMessageQueue* event_queue = ctx;
EventApp event = {.type = EventTypeInput, .input = *input_event};
furi_message_queue_put(event_queue, &event, FuriWaitForever);
}
static void clock_tick(void* ctx) {
furi_assert(ctx);
FuriMessageQueue* queue = ctx;
EventApp event = {.type = ClockEventTypeTick};
furi_message_queue_put(queue, &event, 0);
}
static void clock_tick_pause(void* ctx) {
furi_assert(ctx);
FuriMessageQueue* queue = ctx;
EventApp event = {.type = ClockEventTypeTickPause};
furi_message_queue_put(queue, &event, 0);
}
static void gpiocallback(void* ctx) {
furi_assert(ctx);
FuriMessageQueue* queue = ctx;
EventApp event = {.type = EventGPIO};
furi_message_queue_put(queue, &event, 0);
}
int32_t flipper_atomicdiceroller_app() {
furi_hal_bus_enable(FuriHalBusTIM2);
LL_TIM_SetCounterMode(TIM2, LL_TIM_COUNTERMODE_UP);
LL_TIM_SetClockDivision(TIM2, LL_TIM_CLOCKDIVISION_DIV1);
LL_TIM_SetPrescaler(TIM2, 0);
LL_TIM_SetAutoReload(TIM2, 0xFFFFFFFF);
LL_TIM_SetCounter(TIM2, 0);
LL_TIM_EnableCounter(TIM2);
EventApp event;
FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(EventApp));
furi_hal_gpio_init(&gpio_ext_pa7, GpioModeInterruptFall, GpioPullUp, GpioSpeedVeryHigh);
mutexStruct mutexVal;
mutexVal.cps = 0;
mutexVal.dice = 0;
mutexVal.diceAvailiable = 0;
mutexVal.method = 0;
uint32_t counter = 0;
mutexVal.mutex = furi_mutex_alloc(FuriMutexTypeNormal);
if(!mutexVal.mutex) {
furi_message_queue_free(event_queue);
return 255;
}
ViewPort* view_port = view_port_alloc();
view_port_draw_callback_set(view_port, draw_callback, &mutexVal.mutex);
view_port_input_callback_set(view_port, input_callback, event_queue);
furi_hal_gpio_add_int_callback(&gpio_ext_pa7, gpiocallback, event_queue);
Gui* gui = furi_record_open(RECORD_GUI);
gui_add_view_port(gui, view_port, GuiLayerFullscreen);
FuriTimer* timer = furi_timer_alloc(clock_tick, FuriTimerTypePeriodic, event_queue);
furi_timer_start(timer, 1000);
FuriTimer* timerPause = furi_timer_alloc(clock_tick_pause, FuriTimerTypePeriodic, event_queue);
// ENABLE 5V pin
uint8_t attempts = 0;
while(!furi_hal_power_is_otg_enabled() && attempts++ < 5) {
furi_hal_power_enable_otg();
furi_delay_ms(10);
}
uint8_t diceBuffer[64];
for(uint8_t i = 0; i < 64; i++) diceBuffer[i] = 0;
uint8_t diceBufferCounter = 0;
uint8_t diceBufferPositionWrite = 0;
uint8_t diceBufferPositionRead = 0;
uint8_t tickCounter = 0;
uint32_t CRC32 = 0;
uint8_t method = 0;
// MD5
md5_context* md5_ctx = malloc(sizeof(md5_context));
uint8_t* hash = malloc(sizeof(uint8_t) * 16);
uint8_t* bufferTim2 = malloc(4);
md5_starts(md5_ctx);
uint8_t pause = 0;
while(1) {
FuriStatus event_status = furi_message_queue_get(event_queue, &event, FuriWaitForever);
uint8_t screenRefresh = 0;
if(event_status == FuriStatusOk) {
if(event.type == EventTypeInput) {
if(event.input.key == InputKeyBack && event.input.type == InputTypeLong) {
break;
} else if(pause == 0) {
if(event.input.key == InputKeyOk && event.input.type == InputTypeShort) {
if(diceBufferCounter > 0) {
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.dice = diceBuffer[diceBufferPositionRead];
mutexVal.diceAvailiable = --diceBufferCounter;
mutexVal.pause = 1;
furi_mutex_release(mutexVal.mutex);
if(diceBufferPositionRead != 63)
diceBufferPositionRead++;
else
diceBufferPositionRead = 0;
pause = 1;
furi_timer_start(timerPause, 500);
screenRefresh = 1;
}
} else if(event.input.key == InputKeyLeft && event.input.type == InputTypeLong) {
if(method == 1) {
method = 0;
diceBufferPositionWrite = 0;
diceBufferPositionRead = 0;
diceBufferCounter = 0;
CRC32 = 0;
tickCounter = 0;
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.method = 0;
mutexVal.dice = 0;
mutexVal.diceAvailiable = 0;
furi_mutex_release(mutexVal.mutex);
screenRefresh = 1;
}
} else if(event.input.key == InputKeyRight && event.input.type == InputTypeLong) {
if(method == 0) {
method = 1;
diceBufferPositionWrite = 0;
diceBufferPositionRead = 0;
diceBufferCounter = 0;
md5_starts(md5_ctx);
tickCounter = 0;
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.method = 1;
mutexVal.dice = 0;
mutexVal.diceAvailiable = 0;
furi_mutex_release(mutexVal.mutex);
screenRefresh = 1;
}
}
}
} else if(event.type == ClockEventTypeTick) {
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.cps = counter;
furi_mutex_release(mutexVal.mutex);
counter = 0;
screenRefresh = 1;
} else if(event.type == ClockEventTypeTickPause) {
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.pause = 0;
furi_mutex_release(mutexVal.mutex);
furi_timer_stop(timerPause);
pause = 0;
screenRefresh = 1;
} else if(event.type == EventGPIO) {
if(diceBufferCounter < 64) {
// CRC32
if(method == 0) {
uint32_t TIM2Tick = TIM2->CNT;
bufferTim2[0] = (uint8_t)(TIM2Tick >> 24);
bufferTim2[1] = (uint8_t)(TIM2Tick >> 16);
bufferTim2[2] = (uint8_t)(TIM2Tick >> 8);
bufferTim2[3] = (uint8_t)TIM2Tick;
CRC32 = crc32_calc_buffer(CRC32, bufferTim2, 4);
tickCounter++;
if(tickCounter == 8) {
uint8_t localDice = CRC32 & 0b111;
if(localDice == 0 || localDice == 7) {
localDice = (diceBuffer[diceBufferPositionRead] >> 3) & 0b111;
}
if(localDice >= 1 && localDice <= 6) {
diceBuffer[diceBufferPositionWrite] = localDice;
diceBufferCounter++;
if(diceBufferPositionWrite != 63)
diceBufferPositionWrite++;
else
diceBufferPositionWrite = 0;
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.diceAvailiable = diceBufferCounter;
furi_mutex_release(mutexVal.mutex);
screenRefresh = 1;
}
CRC32 = 0;
tickCounter = 0;
}
}
// MD5
else {
uint32_t tick = TIM2->CNT;
bufferTim2[0] = (uint8_t)(tick >> 24);
bufferTim2[1] = (uint8_t)(tick >> 16);
bufferTim2[2] = (uint8_t)(tick >> 8);
bufferTim2[3] = (uint8_t)tick;
md5_update(md5_ctx, bufferTim2, 4);
tickCounter++;
if(tickCounter == 32) {
md5_finish(md5_ctx, hash);
uint8_t localDice = 0;
for(uint8_t i = 0; i < 16; i++) {
localDice = hash[i] & 0b111;
if(localDice >= 1 && localDice <= 6) {
diceBuffer[diceBufferPositionWrite] = localDice;
diceBufferCounter++;
if(diceBufferPositionWrite != 63)
diceBufferPositionWrite++;
else
diceBufferPositionWrite = 0;
furi_mutex_acquire(mutexVal.mutex, FuriWaitForever);
mutexVal.diceAvailiable = diceBufferCounter;
furi_mutex_release(mutexVal.mutex);
screenRefresh = 1;
break;
}
}
md5_starts(md5_ctx);
tickCounter = 0;
}
}
}
counter++;
}
}
if(screenRefresh == 1) view_port_update(view_port);
}
LL_TIM_DisableCounter(TIM2);
furi_hal_bus_disable(FuriHalBusTIM2);
free(md5_ctx);
free(bufferTim2);
free(hash);
furi_record_close(RECORD_NOTIFICATION);
// Disable 5v power
if(furi_hal_power_is_otg_enabled()) {
furi_hal_power_disable_otg();
}
furi_hal_gpio_disable_int_callback(&gpio_ext_pa7);
furi_hal_gpio_remove_int_callback(&gpio_ext_pa7);
furi_message_queue_free(event_queue);
furi_mutex_free(mutexVal.mutex);
gui_remove_view_port(gui, view_port);
view_port_free(view_port);
furi_timer_free(timer);
furi_timer_free(timerPause);
furi_record_close(RECORD_GUI);
return 0;
}