Momentum-Apps/applications/main/subghz/views/subghz_test_packet.c

#include "subghz_test_packet.h"
#include "../subghz_i.h"
#include "../helpers/subghz_testing.h"

#include <math.h>
#include <furi.h>
#include <furi_hal.h>
#include <input/input.h>
#include <toolbox/level_duration.h>
#include <lib/subghz/protocols/princeton_for_testing.h>

#define SUBGHZ_TEST_PACKET_COUNT 500

struct SubGhzTestPacket {
    View* view;
    FuriTimer* timer;

    SubGhzDecoderPrinceton* decoder;
    SubGhzEncoderPrinceton* encoder;
    volatile size_t packet_rx;
    SubGhzTestPacketCallback callback;
    void* context;
};

typedef enum {
    SubGhzTestPacketModelStatusRx,
    SubGhzTestPacketModelStatusOnlyRx,
    SubGhzTestPacketModelStatusTx,
} SubGhzTestPacketModelStatus;

typedef struct {
    uint8_t frequency;
    uint32_t real_frequency;
    FuriHalSubGhzPath path;
    float rssi;
    size_t packets;
    SubGhzTestPacketModelStatus status;
} SubGhzTestPacketModel;

volatile bool subghz_test_packet_overrun = false;

void subghz_test_packet_set_callback(
    SubGhzTestPacket* subghz_test_packet,
    SubGhzTestPacketCallback callback,
    void* context) {
    furi_assert(subghz_test_packet);
    furi_assert(callback);
    subghz_test_packet->callback = callback;
    subghz_test_packet->context = context;
}

static void subghz_test_packet_rx_callback(bool level, uint32_t duration, void* context) {
    furi_assert(context);
    SubGhzTestPacket* instance = context;
    subghz_decoder_princeton_for_testing_parse(instance->decoder, level, duration);
}

//todo
static void subghz_test_packet_rx_pt_callback(SubGhzDecoderPrinceton* parser, void* context) {
    UNUSED(parser);
    furi_assert(context);
    SubGhzTestPacket* instance = context;
    instance->packet_rx++;
}

static void subghz_test_packet_rssi_timer_callback(void* context) {
    furi_assert(context);
    SubGhzTestPacket* instance = context;

    with_view_model(
        instance->view,
        SubGhzTestPacketModel * model,
        {
            if(model->status == SubGhzTestPacketModelStatusRx) {
                model->rssi = furi_hal_subghz_get_rssi();
                model->packets = instance->packet_rx;
            } else if(model->status == SubGhzTestPacketModelStatusTx) {
                model->packets =
                    SUBGHZ_TEST_PACKET_COUNT -
                    subghz_encoder_princeton_for_testing_get_repeat_left(instance->encoder);
            }
        },
        true);
}

static void subghz_test_packet_draw(Canvas* canvas, SubGhzTestPacketModel* model) {
    char buffer[64];

    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str(canvas, 0, 8, "CC1101 Packet Test");

    canvas_set_font(canvas, FontSecondary);
    // Frequency
    snprintf(
        buffer,
        sizeof(buffer),
        "Freq: %03ld.%03ld.%03ld Hz",
        model->real_frequency / 1000000 % 1000,
        model->real_frequency / 1000 % 1000,
        model->real_frequency % 1000);
    canvas_draw_str(canvas, 0, 20, buffer);
    // Path
    char* path_name = "Unknown";
    if(model->path == FuriHalSubGhzPathIsolate) {
        path_name = "isolate";
    } else if(model->path == FuriHalSubGhzPath433) {
        path_name = "433MHz";
    } else if(model->path == FuriHalSubGhzPath315) {
        path_name = "315MHz";
    } else if(model->path == FuriHalSubGhzPath868) {
        path_name = "868MHz";
    }
    snprintf(buffer, sizeof(buffer), "Path: %d - %s", model->path, path_name);
    canvas_draw_str(canvas, 0, 31, buffer);

    snprintf(buffer, sizeof(buffer), "Packets: %zu", model->packets);
    canvas_draw_str(canvas, 0, 42, buffer);

    if(model->status == SubGhzTestPacketModelStatusRx) {
        snprintf(
            buffer,
            sizeof(buffer),
            "RSSI: %ld.%ld dBm",
            (int32_t)(model->rssi),
            (int32_t)fabs(model->rssi * 10) % 10);
        canvas_draw_str(canvas, 0, 53, buffer);
    } else {
        canvas_draw_str(canvas, 0, 53, "TX");
    }
}

static bool subghz_test_packet_input(InputEvent* event, void* context) {
    furi_assert(context);
    SubGhzTestPacket* instance = context;

    if(event->key == InputKeyBack || event->type != InputTypeShort) {
        return false;
    }

    with_view_model(
        instance->view,
        SubGhzTestPacketModel * model,
        {
            if(model->status == SubGhzTestPacketModelStatusRx) {
                furi_hal_subghz_stop_async_rx();
            } else if(model->status == SubGhzTestPacketModelStatusTx) {
                subghz_encoder_princeton_for_testing_stop(instance->encoder, furi_get_tick());
                furi_hal_subghz_stop_async_tx();
            }

            if(event->key == InputKeyLeft) {
                if(model->frequency > 0) model->frequency--;
            } else if(event->key == InputKeyRight) {
                if(model->frequency < subghz_frequencies_count_testing - 1) model->frequency++;
            } else if(event->key == InputKeyDown) {
                if(model->path > 0) model->path--;
            } else if(event->key == InputKeyUp) {
                if(model->path < FuriHalSubGhzPath868) model->path++;
            } else if(event->key == InputKeyOk) {
                if(model->status == SubGhzTestPacketModelStatusRx) {
                    model->status = SubGhzTestPacketModelStatusTx;
                } else {
                    model->status = SubGhzTestPacketModelStatusRx;
                }
            }

            model->real_frequency =
                furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
            furi_hal_subghz_set_path(model->path);

            if(model->status == SubGhzTestPacketModelStatusRx) {
                furi_hal_subghz_start_async_rx(subghz_test_packet_rx_callback, instance);
            } else {
                subghz_encoder_princeton_for_testing_set(
                    instance->encoder,
                    0x00AABBCC,
                    SUBGHZ_TEST_PACKET_COUNT,
                    subghz_frequencies_testing[model->frequency]);
                if(!furi_hal_subghz_start_async_tx(
                       subghz_encoder_princeton_for_testing_yield, instance->encoder)) {
                    model->status = SubGhzTestPacketModelStatusOnlyRx;
                    instance->callback(SubGhzTestPacketEventOnlyRx, instance->context);
                }
            }
        },
        true);

    return true;
}

void subghz_test_packet_enter(void* context) {
    furi_assert(context);
    SubGhzTestPacket* instance = context;

    furi_hal_subghz_reset();
    furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);

    with_view_model(
        instance->view,
        SubGhzTestPacketModel * model,
        {
            model->frequency = subghz_frequencies_433_92_testing;
            model->real_frequency =
                furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
            model->path = FuriHalSubGhzPathIsolate; // isolate
            model->rssi = 0.0f;
            model->status = SubGhzTestPacketModelStatusRx;
        },
        true);

    furi_hal_subghz_start_async_rx(subghz_test_packet_rx_callback, instance);

    furi_timer_start(instance->timer, furi_kernel_get_tick_frequency() / 4);
}

void subghz_test_packet_exit(void* context) {
    furi_assert(context);
    SubGhzTestPacket* instance = context;

    furi_timer_stop(instance->timer);

    // Reinitialize IC to default state
    with_view_model(
        instance->view,
        SubGhzTestPacketModel * model,
        {
            if(model->status == SubGhzTestPacketModelStatusRx) {
                furi_hal_subghz_stop_async_rx();
            } else if(model->status == SubGhzTestPacketModelStatusTx) {
                subghz_encoder_princeton_for_testing_stop(instance->encoder, furi_get_tick());
                furi_hal_subghz_stop_async_tx();
            }
        },
        true);
    furi_hal_subghz_sleep();
}

SubGhzTestPacket* subghz_test_packet_alloc() {
    SubGhzTestPacket* instance = malloc(sizeof(SubGhzTestPacket));

    // View allocation and configuration
    instance->view = view_alloc();
    view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubGhzTestPacketModel));
    view_set_context(instance->view, instance);
    view_set_draw_callback(instance->view, (ViewDrawCallback)subghz_test_packet_draw);
    view_set_input_callback(instance->view, subghz_test_packet_input);
    view_set_enter_callback(instance->view, subghz_test_packet_enter);
    view_set_exit_callback(instance->view, subghz_test_packet_exit);

    instance->timer =
        furi_timer_alloc(subghz_test_packet_rssi_timer_callback, FuriTimerTypePeriodic, instance);

    instance->decoder = subghz_decoder_princeton_for_testing_alloc();
    subghz_decoder_princeton_for_testing_set_callback(
        instance->decoder, subghz_test_packet_rx_pt_callback, instance);
    instance->encoder = subghz_encoder_princeton_for_testing_alloc();

    return instance;
}

void subghz_test_packet_free(SubGhzTestPacket* instance) {
    furi_assert(instance);

    subghz_decoder_princeton_for_testing_free(instance->decoder);
    subghz_encoder_princeton_for_testing_free(instance->encoder);

    furi_timer_free(instance->timer);
    view_free(instance->view);
    free(instance);
}

View* subghz_test_packet_get_view(SubGhzTestPacket* instance) {
    furi_assert(instance);
    return instance->view;
}