mirror of
https://github.com/UberGuidoZ/Flipper.git
synced 2024-12-23 15:00:13 +00:00
446 lines
13 KiB
C
446 lines
13 KiB
C
#include <furi.h>
|
|
#include <gui/gui.h>
|
|
#include <input/input.h>
|
|
#include <stdlib.h>
|
|
#include <dolphin/dolphin.h>
|
|
#include <notification/notification.h>
|
|
#include <notification/notification_messages.h>
|
|
|
|
#include "dcf77_app.h"
|
|
|
|
uint8_t get_dcf_message_bit(uint8_t* message, uint8_t bit)
|
|
{
|
|
if (bit == 59 || bit == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
uint8_t byte_ = bit / 8;
|
|
uint8_t bit_ = bit % 8;
|
|
|
|
uint8_t bit_value = *(message+byte_) & (1 << (7-bit_));
|
|
|
|
if (!!bit_value)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// should it still be const?
|
|
static void update_dcf77_message_from_rtc(AppFSM* app_fsm)
|
|
{
|
|
FuriHalRtcDateTime dt;
|
|
furi_hal_rtc_get_datetime(&dt);
|
|
app_fsm->bit_number = dt.second;
|
|
app_fsm->next_message = malloc(8);
|
|
/*
|
|
set_dcf_message(app_fsm->next_message, dt.minute, dt.hour,
|
|
dt.day, dt.month, (uint8_t)(dt.year % 100), dt.weekday,
|
|
false, false, false, false, 0x0000);
|
|
*/
|
|
|
|
//set_dcf_message(app_fsm->next_message, 41, 17, 27, 12, 22, 2, false, false, false, false, 0x0000);
|
|
|
|
app_fsm->tx_hour = 17;
|
|
app_fsm->tx_minute = 41;
|
|
app_fsm->tx_day = 27;
|
|
app_fsm->tx_month = 12;
|
|
app_fsm->tx_year = 22;
|
|
app_fsm->tx_dow = 2;
|
|
|
|
|
|
app_fsm->tx_hour = dt.hour;
|
|
app_fsm->tx_minute = dt.minute;
|
|
app_fsm->tx_day = dt.day;
|
|
app_fsm->tx_month = dt.month;
|
|
app_fsm->tx_year = dt.year % 100;
|
|
app_fsm->tx_dow = dt.weekday;
|
|
|
|
set_dcf_message(app_fsm->next_message, app_fsm->tx_minute, app_fsm->tx_hour, app_fsm->tx_day, app_fsm->tx_month,
|
|
app_fsm->tx_year, app_fsm->tx_dow, false, false, false, false, 0x0000);
|
|
app_fsm->buffer_swap_pending = true;
|
|
}
|
|
|
|
static void set_outputs(bool status, AppFSM* app_fsm)
|
|
{
|
|
UNUSED(app_fsm);
|
|
static bool last;
|
|
if (last != status)
|
|
{
|
|
if (status)
|
|
{
|
|
furi_hal_light_set(LightRed, 0xFF);
|
|
furi_hal_light_set(LightGreen, 0x1F);
|
|
// furi_hal_speaker_start(50, 1);
|
|
|
|
}
|
|
else
|
|
{
|
|
furi_hal_light_set(LightRed | LightGreen | LightBlue, 0);
|
|
// furi_hal_speaker_stop();
|
|
}
|
|
}
|
|
last = status;
|
|
}
|
|
|
|
static void comparator_trigger_callback(bool level, void *comp_ctx) {
|
|
UNUSED(comp_ctx);
|
|
furi_hal_gpio_write(&gpio_ext_pa7, !level);
|
|
}
|
|
|
|
|
|
void gpio_init()
|
|
{
|
|
furi_hal_gpio_write(OUTPUT_PIN, false);
|
|
furi_hal_gpio_init(OUTPUT_PIN, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
|
|
}
|
|
|
|
void gpio_mark()
|
|
{
|
|
furi_hal_gpio_write(OUTPUT_PIN, true);
|
|
}
|
|
|
|
|
|
void gpio_space()
|
|
{
|
|
furi_hal_gpio_write(OUTPUT_PIN, false);
|
|
}
|
|
|
|
void gpio_deinit()
|
|
{
|
|
furi_hal_gpio_init(OUTPUT_PIN, GpioModeAnalog, GpioPullNo, GpioSpeedVeryHigh);
|
|
}
|
|
|
|
void dcf77_lf_init(int freq, AppFSM* app_fsm)
|
|
{
|
|
/* // this ends up doing
|
|
// LL_TIM_SetAutoReload(FURI_HAL_RFID_READ_TIMER, period);
|
|
// LL_TIM_OC_SetCompareCH1(FURI_HAL_RFID_READ_TIMER, period*duty_cycle);
|
|
*/
|
|
|
|
furi_hal_rfid_tim_reset();
|
|
furi_hal_gpio_init_simple(&gpio_ext_pa7, GpioModeOutputPushPull);
|
|
furi_hal_rfid_comp_set_callback(comparator_trigger_callback, app_fsm);
|
|
furi_hal_rfid_pins_read();
|
|
furi_hal_rfid_tim_read(freq, 0.5);
|
|
}
|
|
|
|
void dcf77_mark(int freq)
|
|
{
|
|
furi_hal_rfid_tim_reset();
|
|
furi_hal_rfid_tim_read(freq, 0.5);
|
|
furi_hal_rfid_comp_start();
|
|
furi_hal_rfid_tim_read_start();
|
|
/* --- */
|
|
furi_hal_rfid_comp_stop();
|
|
furi_hal_rfid_tim_read_stop();
|
|
}
|
|
|
|
void dcf77_space()
|
|
{
|
|
furi_hal_rfid_comp_stop();
|
|
furi_hal_rfid_tim_read_stop();
|
|
}
|
|
|
|
void dcf77_deinit()
|
|
{
|
|
dcf77_space();
|
|
furi_hal_rfid_comp_stop();
|
|
furi_hal_rfid_comp_set_callback(NULL, NULL);
|
|
furi_hal_gpio_init_simple(&gpio_ext_pa7, GpioModeAnalog);
|
|
furi_hal_rfid_tim_read_stop();
|
|
furi_hal_rfid_tim_reset();
|
|
furi_hal_rfid_pins_reset();
|
|
}
|
|
|
|
static void render_callback(Canvas* const canvas, void* ctx)
|
|
{
|
|
// const AppFSM* app_fsm = acquire_mutex((ValueMutex*)ctx, 25);
|
|
AppFSM* app_fsm = acquire_mutex((ValueMutex*)ctx, 25);
|
|
if(app_fsm == NULL) {
|
|
return;
|
|
}
|
|
|
|
char buffer[64];
|
|
uint8_t yoffset = 9;
|
|
uint8_t bit_number = app_fsm->bit_number;
|
|
uint8_t bit_value = app_fsm->bit_value;
|
|
uint8_t underline_x = (bit_number/8) * 12 + 16;
|
|
uint8_t byte_ = app_fsm->dcf77_message[bit_number/8];
|
|
char display_bits[9] = "00000000";
|
|
|
|
if (app_fsm->buffer_swap_pending)
|
|
{
|
|
memcpy(app_fsm->dcf77_message, app_fsm->next_message, 8);
|
|
canvas_draw_str_aligned(canvas, 112, 10, AlignCenter, AlignBottom, "*");
|
|
app_fsm->buffer_swap_pending = false;
|
|
}
|
|
|
|
|
|
canvas_draw_frame(canvas, 0, 0, 128, 64);
|
|
canvas_set_font(canvas, FontPrimary);
|
|
snprintf(buffer, 64, "%1x.%1x=%01x", bit_number/8, (bit_number%8), bit_value);
|
|
FuriHalRtcDateTime dt;
|
|
furi_hal_rtc_get_datetime(&dt);
|
|
//canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignBottom, "DCF77 emulator");
|
|
snprintf(buffer, 64, "%02d:%02d %02d.%02d.%02d", app_fsm->tx_hour, app_fsm->tx_minute, app_fsm->tx_day, app_fsm->tx_month,
|
|
app_fsm->tx_year);
|
|
canvas_draw_str_aligned(canvas, 64, 10, AlignCenter, AlignBottom, buffer);
|
|
|
|
if (app_fsm->debug_flag)
|
|
{
|
|
canvas_draw_str_aligned(canvas, 8, 10, AlignCenter, AlignBottom, "D");
|
|
}
|
|
|
|
snprintf(buffer, 64, "%1x.%1x=%01x", bit_number/8, (bit_number%8), bit_value);
|
|
canvas_set_font(canvas, FontSecondary);
|
|
canvas_draw_str_aligned(canvas, 64, 24 + (9 - yoffset), AlignCenter, AlignBottom, buffer);
|
|
|
|
snprintf(buffer, 64, "%s (bit %d)", dcf77_bitnames[bit_number], bit_value);
|
|
canvas_set_font(canvas, FontSecondary);
|
|
canvas_draw_str_aligned(canvas, 64, 34 + (9 - yoffset), AlignCenter, AlignBottom, buffer);
|
|
|
|
|
|
|
|
snprintf(buffer, 64, "%02x%02x%02x%02x%02x%02x%02x%02x",
|
|
app_fsm->dcf77_message[0], app_fsm->dcf77_message[1], app_fsm->dcf77_message[2], app_fsm->dcf77_message[3],
|
|
app_fsm->dcf77_message[4], app_fsm->dcf77_message[5], app_fsm->dcf77_message[6], app_fsm->dcf77_message[7] );
|
|
canvas_set_font(canvas, FontKeyboard);
|
|
canvas_draw_str_aligned(canvas, 64, 44 + (9 - yoffset), AlignCenter, AlignBottom, buffer);
|
|
|
|
|
|
canvas_draw_line(canvas, underline_x, 45, underline_x+10, 45);
|
|
for(int i = 0; i < 8; i++)
|
|
{
|
|
if ((byte_ & (1 << (7-i))) != 0)
|
|
{
|
|
display_bits[i] = '1';
|
|
}
|
|
}
|
|
|
|
canvas_set_font(canvas, FontKeyboard);
|
|
snprintf(buffer, 64, "%02x=%s", byte_, display_bits);
|
|
canvas_draw_str_aligned(canvas, 64, 54 + (9 - yoffset), AlignCenter, AlignBottom, buffer); // whole message
|
|
underline_x = (bit_number%8) * 6 + 49;
|
|
canvas_draw_line(canvas, underline_x, 55, underline_x+4, 55); // current byte
|
|
|
|
release_mutex((ValueMutex*)ctx, app_fsm);
|
|
}
|
|
|
|
static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
|
|
furi_assert(event_queue);
|
|
|
|
AppEvent event = {.type = EventKeyPress, .input = *input_event};
|
|
furi_message_queue_put(event_queue, &event, FuriWaitForever);
|
|
}
|
|
|
|
static void timer_tick_callback(FuriMessageQueue* event_queue) {
|
|
furi_assert(event_queue);
|
|
|
|
AppEvent event = {.type = EventTimerTick};
|
|
furi_message_queue_put(event_queue, &event, 0);
|
|
}
|
|
|
|
static void app_init(AppFSM* const app_fsm, FuriMessageQueue* event_queue) {
|
|
|
|
app_fsm->counter = 0;
|
|
app_fsm->dcf77_message = &dcf77_message_buffer[0];
|
|
app_fsm->next_message = &dcf77_next_buffer[0];
|
|
|
|
dcf77_lf_init(LF_FREQ, app_fsm);
|
|
gpio_init();
|
|
|
|
app_fsm->dcf77_message = malloc(8); // message had 60 bits since 1959 and is unlikely to change
|
|
// app_fsm->next_message = malloc(8);
|
|
update_dcf77_message_from_rtc(app_fsm);
|
|
app_fsm->baseband_counter = 0;
|
|
|
|
app_fsm->_event_queue = event_queue;
|
|
FuriTimer* timer = furi_timer_alloc(timer_tick_callback, FuriTimerTypePeriodic, app_fsm->_event_queue);
|
|
furi_timer_start(timer, furi_kernel_get_tick_frequency() / TIMER_HZ);
|
|
app_fsm->_timer = timer;
|
|
}
|
|
|
|
static void app_deinit(AppFSM* const app_fsm) {
|
|
dcf77_deinit();
|
|
gpio_deinit();
|
|
app_fsm->buffer_swap_pending = false;
|
|
free(app_fsm->dcf77_message);
|
|
furi_timer_free(app_fsm->_timer);
|
|
}
|
|
|
|
static void on_timer_tick(AppFSM* app_fsm)
|
|
{
|
|
static uint8_t last_second = 61;
|
|
static bool last_output = false;
|
|
bool output = true;
|
|
|
|
FuriHalRtcDateTime dt;
|
|
furi_hal_rtc_get_datetime(&dt);
|
|
app_fsm->bit_number = dt.second;
|
|
app_fsm->bit_value = get_dcf_message_bit(app_fsm->dcf77_message, app_fsm->bit_number);
|
|
|
|
if (dt.second != last_second)
|
|
{
|
|
app_fsm->baseband_counter = 0;
|
|
output = true;
|
|
}
|
|
else
|
|
{
|
|
app_fsm->baseband_counter++;
|
|
}
|
|
|
|
/*
|
|
if (app_fsm->baseband_counter < 8)
|
|
{
|
|
app_fsm->debug_flag = true;
|
|
}
|
|
else
|
|
{
|
|
app_fsm->debug_flag = false;
|
|
}*/
|
|
|
|
if (dt.second == 0 && app_fsm->baseband_counter == 3)
|
|
{
|
|
update_dcf77_message_from_rtc(app_fsm);
|
|
}
|
|
|
|
if (dt.second == 59)
|
|
{
|
|
output = true;
|
|
}
|
|
else
|
|
{
|
|
if (app_fsm->baseband_counter > TIME_ZERO && app_fsm->bit_value == 0)
|
|
{
|
|
output = false;
|
|
|
|
}
|
|
else if (app_fsm->baseband_counter > TIME_ONE && app_fsm->bit_value == 1)
|
|
{
|
|
output = false;
|
|
}
|
|
}
|
|
|
|
|
|
if (last_output != output)
|
|
{
|
|
set_outputs(output, app_fsm);
|
|
if (!output)
|
|
{
|
|
dcf77_space();
|
|
gpio_space();
|
|
}
|
|
else
|
|
{
|
|
dcf77_mark(LF_FREQ);
|
|
gpio_mark();
|
|
}
|
|
}
|
|
|
|
last_second = dt.second;
|
|
last_output = output;
|
|
}
|
|
|
|
|
|
int32_t dcf77_app_main(void* p) {
|
|
UNUSED(p);
|
|
|
|
FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(AppEvent));
|
|
AppFSM* app_fsm = malloc(sizeof(AppFSM));
|
|
app_init(app_fsm, event_queue);
|
|
|
|
ValueMutex state_mutex;
|
|
if(!init_mutex(&state_mutex, app_fsm, sizeof(AppFSM))) {
|
|
FURI_LOG_E(TAG, "cannot create mutex\r\n");
|
|
free(app_fsm);
|
|
return 255;
|
|
}
|
|
|
|
ViewPort* view_port = view_port_alloc();
|
|
view_port_draw_callback_set(view_port, render_callback, &state_mutex);
|
|
view_port_input_callback_set(view_port, input_callback, event_queue);
|
|
|
|
// Open GUI and register view_port
|
|
Gui* gui = furi_record_open(RECORD_GUI);
|
|
gui_add_view_port(gui, view_port, GuiLayerFullscreen);
|
|
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
|
|
notification_message_block(notification, &sequence_display_backlight_enforce_on);
|
|
|
|
|
|
if (furi_hal_speaker_acquire(500))
|
|
{
|
|
;
|
|
}
|
|
|
|
|
|
DOLPHIN_DEED(DolphinDeedPluginGameStart);
|
|
|
|
AppEvent event;
|
|
for(bool processing = true; processing;) {
|
|
FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
|
|
|
|
AppFSM* app_fsm = (AppFSM*)acquire_mutex_block(&state_mutex);
|
|
|
|
if(event_status == FuriStatusOk) {
|
|
// kepress events
|
|
if(event.type == EventKeyPress) {
|
|
if(event.input.type == InputTypePress) {
|
|
switch(event.input.key) {
|
|
case InputKeyUp:
|
|
app_fsm->last_key = KeyUp;
|
|
break;
|
|
case InputKeyDown:
|
|
app_fsm->last_key = KeyDown;
|
|
break;
|
|
case InputKeyRight:
|
|
app_fsm->last_key = KeyRight;
|
|
break;
|
|
case InputKeyLeft:
|
|
app_fsm->last_key = KeyLeft;
|
|
break;
|
|
case InputKeyOk:
|
|
app_fsm->last_key = KeyOK;
|
|
app_fsm->counter = -5;
|
|
break;
|
|
case InputKeyBack:
|
|
processing = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// user events
|
|
} else if(event.type == EventTimerTick) {
|
|
FURI_CRITICAL_ENTER();
|
|
on_timer_tick(app_fsm);
|
|
FURI_CRITICAL_EXIT();
|
|
}
|
|
} else {
|
|
// event timeout
|
|
}
|
|
|
|
view_port_update(view_port);
|
|
release_mutex(&state_mutex, app_fsm);
|
|
}
|
|
furi_hal_speaker_release();
|
|
notification_message_block(notification, &seq_c_minor);
|
|
|
|
// Wait for all notifications to be played and return backlight to normal state
|
|
app_deinit(app_fsm);
|
|
|
|
notification_message_block(notification, &sequence_display_backlight_enforce_auto);
|
|
|
|
view_port_enabled_set(view_port, false);
|
|
gui_remove_view_port(gui, view_port);
|
|
furi_record_close(RECORD_GUI);
|
|
furi_record_close(RECORD_NOTIFICATION);
|
|
view_port_free(view_port);
|
|
furi_message_queue_free(event_queue);
|
|
delete_mutex(&state_mutex);
|
|
free(app_fsm);
|
|
|
|
return 0;
|
|
}
|