flipper-zero-tutorials/subghz/apps/genie-recorder/genie_send.c

#include "genie_send.h"

#include "genie_app.h"
#include "genie_submenu.h"
#include "genie_subghz_receive.h"
#include "genie_file.h"

#include <flipper_format/flipper_format_i.h>
#include <lib/subghz/transmitter.h>

#ifdef TAG
#undef TAG
#endif
#define TAG "GenieSend"

typedef struct GenieSend GenieSend;

struct GenieSend {
    View* view;
};

typedef struct {
    GenieApp* app;
    GenieFile* file;
    bool loaded;
} GenieRefs;

static void
    set_genie(FlipperFormat* flipper_format, uint32_t key_hi, uint32_t key_lo, uint32_t repeat) {
    FuriString* genie_settings = furi_string_alloc_printf(
        "Protocol: Genie\n"
        "Bit: 64\n"
        "Key: %02X %02X %02X %02X %02X %02X %02X %02X\n"
        "Increment: 0\n"
        "Repeat: %lu\n",
        (uint8_t)((key_hi >> 24) & 0xFFU),
        (uint8_t)((key_hi >> 16) & 0xFFU),
        (uint8_t)((key_hi >> 8) & 0xFFU),
        (uint8_t)((key_hi) & 0xFFU),
        (uint8_t)((key_lo >> 24) & 0xFFU),
        (uint8_t)((key_lo >> 16) & 0xFFU),
        (uint8_t)((key_lo >> 8) & 0xFFU),
        (uint8_t)((key_lo) & 0xFFU),
        repeat);
    Stream* stream = flipper_format_get_raw_stream(flipper_format);
    stream_clean(stream);
    stream_write_cstring(stream, furi_string_get_cstr(genie_settings));
    stream_seek(stream, 0, StreamOffsetFromStart);
    furi_string_free(genie_settings);
}

const SubGhzProtocol* send_subghz_protocol_registry_items[] = {
    &subghz_protocol_genie,
};

const SubGhzProtocolRegistry send_subghz_protocol_registry = {
    .items = send_subghz_protocol_registry_items,
    .size = COUNT_OF(send_subghz_protocol_registry_items)};

static void send_genie(uint32_t key_hi, uint32_t key_lo, uint32_t frequency) {
    uint32_t repeat = 5;
    const SubGhzDevice* device;

    subghz_devices_init();
    device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
    SubGhzEnvironment* environment = subghz_environment_alloc();
    subghz_environment_set_protocol_registry(environment, (void*)&send_subghz_protocol_registry);
    SubGhzTransmitter* transmitter = subghz_transmitter_alloc_init(environment, "Genie");
    FlipperFormat* flipper_format = flipper_format_string_alloc();
    set_genie(flipper_format, key_hi, key_lo, repeat);
    subghz_transmitter_deserialize(transmitter, flipper_format);
    subghz_devices_begin(device);
    subghz_devices_reset(device);
    subghz_devices_load_preset(device, FuriHalSubGhzPresetOok650Async, NULL);
    frequency = subghz_devices_set_frequency(device, frequency);

    // Send
    furi_hal_power_suppress_charge_enter();
    if(subghz_devices_start_async_tx(device, subghz_transmitter_yield, transmitter)) {
        while(!(subghz_devices_is_async_complete_tx(device))) {
            furi_delay_ms(100);
        }
        subghz_devices_stop_async_tx(device);
    }

    // Cleanup
    subghz_devices_sleep(device);
    subghz_devices_end(device);
    subghz_devices_deinit();
    furi_hal_power_suppress_charge_exit();
    flipper_format_free(flipper_format);
    subghz_transmitter_free(transmitter);
    subghz_environment_free(environment);
}

static void genie_send_draw_callback(Canvas* canvas, void* model) {
    GenieRefs* refs = (GenieRefs*)model;
    GenieFile* file = refs->file;
    char buffer[36] = {0};

    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str(canvas, 5, 10, "Genie Sub-Ghz Sender!!!");
    canvas_set_font(canvas, FontSecondary);
    if(refs->loaded) {
        if(!file) {
            return;
        }
        snprintf(
            buffer,
            COUNT_OF(buffer),
            "KEY: %08lx %08lx",
            genie_file_get_key_hi(file),
            genie_file_get_key_lo(file));
        canvas_draw_str(canvas, 1, 23, buffer);

        if(genie_file_get_rec_count(file) < 0xFFFD) {
            snprintf(
                buffer,
                COUNT_OF(buffer),
                "Last sent: %d of %d",
                genie_file_get_last_sent(file),
                genie_file_get_rec_count(file));
            canvas_draw_str(canvas, 1, 33, buffer);

            snprintf(buffer, COUNT_OF(buffer), "Remote not fully captured!");
            canvas_draw_str(canvas, 1, 49, buffer);
        } else {
            snprintf(buffer, COUNT_OF(buffer), "Last sent: %d", genie_file_get_last_sent(file));
            canvas_draw_str(canvas, 1, 33, buffer);
        }

        // TODO: Is this off by 1?
        if(genie_file_get_last_sent(file) < genie_file_get_rec_count(file)) {
            canvas_draw_str(canvas, 1, 63, "Press OK to send next code.");
        } else {
            canvas_draw_str(canvas, 1, 61, "Long press OK to reset code.");
        }
    } else {
        canvas_draw_str(canvas, 20, 36, "NO .GNE FILE LOADED");
    }
}

static void genie_send_refresh_file(View* view) {
    with_view_model(
        view,
        GenieRefs * refs,
        {
            const char* path = genie_app_get_file_path(refs->app);
            if(refs->file) {
                genie_file_free(refs->file);
                refs->file = NULL;
            }
            refs->file = genie_file_load(path);
        },
        true);
}

static bool genie_send_input_callback(InputEvent* event, void* context) {
    View* view = (View*)context;
    genie_send_refresh_file(view);

    if(event->type == InputTypeShort) {
        if(event->key == InputKeyOk) {
            with_view_model(
                view,
                GenieRefs * refs,
                {
                    if(refs->file) {
                        if(genie_file_get_last_sent(refs->file) <
                           genie_file_get_rec_count(refs->file)) {
                            send_genie(
                                genie_file_get_key_hi(refs->file),
                                genie_file_get_key_lo(refs->file),
                                genie_app_get_frequency(refs->app));

                            genie_file_set_last_sent(
                                genie_app_get_file_path(refs->app),
                                genie_file_get_last_sent(refs->file) + 1);
                            genie_send_refresh_file(view);
                        }
                    }
                },
                false);
            return true;
        }
    } else if(event->type == InputTypeLong) {
        with_view_model(
            view,
            GenieRefs * refs,
            {
                if(refs->file) {
                    if(genie_file_get_last_sent(refs->file) >=
                       genie_file_get_rec_count(refs->file)) {
                        genie_file_set_last_sent(genie_app_get_file_path(refs->app), 0);
                        genie_send_refresh_file(view);
                    }
                }
            },
            true);
        return true;
    }

    return false;
}

static void genie_send_enter_callback(void* context) {
    View* view = (View*)context;

    with_view_model(
        view,
        GenieRefs * refs,
        {
            const char* path = genie_app_get_file_path(refs->app);
            refs->file = genie_file_load(path);
            refs->loaded = refs->file != NULL;
        },
        false);
}

GenieSend* genie_send_alloc(GenieApp* app) {
    UNUSED(app);
    GenieSend* genie_send = malloc(sizeof(GenieSend));
    View* view = view_alloc();
    genie_send->view = view;
    view_set_draw_callback(view, genie_send_draw_callback);
    view_set_input_callback(view, genie_send_input_callback);
    view_set_previous_callback(view, genie_navigation_submenu_callback);
    view_set_enter_callback(view, genie_send_enter_callback);
    view_set_context(view, view);
    view_allocate_model(view, ViewModelTypeLockFree, sizeof(GenieRefs));
    GenieRefs* refs = (GenieRefs*)view_get_model(view);
    refs->app = app;
    refs->file = NULL;
    refs->loaded = false;

    return genie_send;
}

void genie_send_free(GenieSend* genie_send) {
    furi_assert(genie_send);
    furi_assert(genie_send->view);
    with_view_model(
        genie_send->view,
        GenieRefs * refs,
        {
            genie_file_free(refs->file);
            refs->file = NULL;
        },
        false);
    view_free(genie_send->view);
    genie_send->view = NULL;
    free(genie_send);
}

View* genie_send_get_view(GenieSend* genie_send) {
    furi_assert(genie_send);
    furi_assert(genie_send->view);
    return genie_send->view;
}