flipperzero-firmware/applications/dolphin/dolphin_state.c

135 lines
3.9 KiB
C
Raw Normal View History

#include "dolphin_state.h"
[FL-140] Core api dynamic records (#296) * SYSTEM: tickless mode with deep sleep. * Move FreeRTOS ticks to lptim2 * API: move all sumbodules init routines to one place. Timebase: working lptim2 at tick source. * API Timebase: lp-timer routines, timer access safe zones prediction and synchronization. FreeRTOS: adjust configuration for tickless mode. * NFC: support for tickless mode. * API Timebase: improve tick error handling in IRQ. Apploader: use insomnia mode to run applications. * BLE: prevent sleep while core2 starting * HAL: nap while in insomnia mode * init records work * try to implement record delete * tests and flapp * flapp subsystem * new core functions to get app stat, simplify core code * fix thread termination * add strdup to core * fix tests * Refactoring: remove all unusued parts, update API usage, aggreagate API sources and headers, new record storage * Refactoring: update furi record api usage, cleanup code * Fix broken merge for freertos apps * Core, Target: fix compilation warnings * Drop firmware target local * HAL Timebase, Power, Clock: semaphore guarded access to clock and power modes, better sleep mode. * SD-Filesystem: wait for all deps to arrive before adding widget. Core, BLE: disable debug dump to serial. * delete old app example-ipc * delete old app fatfs list * fix strobe app, add input header * delete old display driver * comment old app qr-code * fix sd-card test, add forced widget update * remove unused new core test * increase heap to 128k * comment and assert old core tests * fix syntax Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
2021-01-20 16:09:26 +00:00
#include <furi.h>
#include <api-hal.h>
#include <math.h>
typedef struct {
uint8_t magic;
uint8_t version;
uint8_t checksum;
uint8_t flags;
uint32_t timestamp;
} DolphinDataHeader;
#define DOLPHIN_DATA_PAGE 0xC0
#define DOLPHIN_DATA_HEADER_ADDRESS 0x080C0000U
#define DOLPHIN_DATA_DATA_ADDRESS (DOLPHIN_DATA_HEADER_ADDRESS + sizeof(DolphinDataHeader))
#define DOLPHIN_DATA_HEADER_MAGIC 0xD0
#define DOLPHIN_DATA_HEADER_VERSION 0x01
#define DOLPHIN_LVL_THRESHOLD 20.0f
typedef struct {
uint32_t limit_ibutton;
uint32_t limit_nfc;
uint32_t limit_ir;
uint32_t limit_rfid;
uint32_t flags;
uint32_t icounter;
uint32_t butthurt;
} DolphinData;
struct DolphinState {
DolphinData data;
};
DolphinState* dolphin_state_alloc() {
DolphinState* dolphin_state = furi_alloc(sizeof(DolphinState));
return dolphin_state;
}
void dolphin_state_release(DolphinState* dolphin_state) {
free(dolphin_state);
}
bool dolphin_state_save(DolphinState* dolphin_state) {
if(!api_hal_flash_erase(DOLPHIN_DATA_PAGE, 1)) {
return false;
}
uint8_t* source = (uint8_t*)&dolphin_state->data;
uint8_t checksum = 0;
for(size_t i = 0; i < sizeof(DolphinData); i++) {
checksum += source[i];
}
DolphinDataHeader header;
header.magic = DOLPHIN_DATA_HEADER_MAGIC;
header.version = DOLPHIN_DATA_HEADER_VERSION;
header.checksum = checksum;
header.flags = 0;
header.timestamp = 0;
if(!api_hal_flash_write_dword(DOLPHIN_DATA_HEADER_ADDRESS, *(uint64_t*)&header)) {
return false;
}
uint8_t destination[sizeof(uint64_t)];
size_t block_count = sizeof(DolphinData) / sizeof(uint64_t) + 1;
size_t offset = 0;
for(size_t i = 0; i < block_count; i++) {
for(size_t n = 0; n < sizeof(uint64_t); n++) {
if(offset < sizeof(DolphinData)) {
destination[n] = source[offset];
} else {
destination[n] = 0;
}
offset++;
}
if(!api_hal_flash_write_dword(
DOLPHIN_DATA_DATA_ADDRESS + i * sizeof(uint64_t), *(uint64_t*)destination)) {
return false;
}
}
return true;
}
bool dolphin_state_load(DolphinState* dolphin_state) {
const DolphinDataHeader* header = (const DolphinDataHeader*)DOLPHIN_DATA_HEADER_ADDRESS;
if(header->magic == DOLPHIN_DATA_HEADER_MAGIC &&
header->version == DOLPHIN_DATA_HEADER_VERSION) {
uint8_t checksum = 0;
const uint8_t* source = (const uint8_t*)DOLPHIN_DATA_DATA_ADDRESS;
for(size_t i = 0; i < sizeof(DolphinData); i++) {
checksum += source[i];
}
if(header->checksum == checksum) {
memcpy(
&dolphin_state->data, (const void*)DOLPHIN_DATA_DATA_ADDRESS, sizeof(DolphinData));
return true;
}
}
return false;
}
void dolphin_state_clear(DolphinState* dolphin_state) {
memset(&dolphin_state->data, 0, sizeof(DolphinData));
}
void dolphin_state_on_deed(DolphinState* dolphin_state, DolphinDeed deed) {
const DolphinDeedWeight* deed_weight = dolphin_deed_weight(deed);
int32_t icounter = dolphin_state->data.icounter + deed_weight->icounter;
if(icounter >= 0) {
dolphin_state->data.icounter = icounter;
}
}
uint32_t dolphin_state_get_icounter(DolphinState* dolphin_state) {
return dolphin_state->data.icounter;
}
uint32_t dolphin_state_get_butthurt(DolphinState* dolphin_state) {
return dolphin_state->data.butthurt;
}
uint32_t dolphin_state_get_level(DolphinState* dolphin_state) {
return 0.5f +
sqrtf(1.0f + 8.0f * ((float)dolphin_state->data.icounter / DOLPHIN_LVL_THRESHOLD)) /
2.0f;
}
uint32_t dolphin_state_xp_to_levelup(DolphinState* dolphin_state, uint32_t level, bool remaining) {
return (DOLPHIN_LVL_THRESHOLD * level * (level + 1) / 2) -
(remaining ? dolphin_state->data.icounter : 0);
}