Momentum-Apps/app.c

/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
 * See the LICENSE file for information about the license. */

#include <furi.h>
#include <furi_hal.h>
#include <lib/flipper_format/flipper_format.h>
#include <input/input.h>
#include <gui/gui.h>
#include <stdlib.h>
#include "app.h"
#include "app_buffer.h"

RawSamplesBuffer *RawSamples, *DetectedSamples;
extern const SubGhzProtocolRegistry protoview_protocol_registry;

/* Render the received signal.
 *
 * The screen of the flipper is 128 x 64. Even using 4 pixels per line
 * (where low level signal is one pixel high, high level is 4 pixels
 * high) and 4 pixels of spacing between the different lines, we can
 * plot comfortably 8 lines.
 *
 * The 'idx' argument is the first sample to render in the circular
 * buffer. */
void render_signal(ProtoViewApp *app, Canvas *const canvas, RawSamplesBuffer *buf, uint32_t idx) {
    canvas_set_color(canvas, ColorBlack);

    int rows = 8;
    uint32_t time_per_pixel = app->us_scale;
    bool level = 0;
    uint32_t dur = 0, sample_num = 0;
    for (int row = 0; row < rows ; row++) {
        for (int x = 0; x < 128; x++) {
            int y = 3 + row*8;
            if (dur < time_per_pixel/2) {
                /* Get more data. */
                raw_samples_get(buf, idx++, &level, &dur);
                sample_num++;
            }

            canvas_draw_line(canvas, x,y,x,y-(level*3));

            /* Write a small triangle under the last sample detected. */
            if (app->signal_bestlen != 0 &&
                sample_num == app->signal_bestlen+1)
            {
                canvas_draw_dot(canvas,x,y+2);
                canvas_draw_dot(canvas,x-1,y+3);
                canvas_draw_dot(canvas,x,y+3);
                canvas_draw_dot(canvas,x+1,y+3);
                sample_num++; /* Make sure we don't mark the next, too. */
            }

            /* Remove from the current level duration the time we
             * just plot. */
            if (dur > time_per_pixel)
                dur -= time_per_pixel;
            else
                dur = 0;
        }
    }
}

/* Return the time difference between a and b, always >= 0 since
 * the absolute value is returned. */
uint32_t duration_delta(uint32_t a, uint32_t b) {
    return a > b ? a - b : b - a;
}

/* This function starts scanning samples at offset idx looking for the
 * longest run of pulses, either high or low, that are among 10%
 * of each other, for a maximum of three classes. The classes are
 * counted separtely for high and low signals (RF on / off) because
 * many devices tend to have different pulse lenghts depending on
 * the level of the pulse.
 *
 * For instance Oregon2 sensors, in the case of protocol 2.1 will send
 * pulses of ~400us (RF on) VS ~580us (RF off). */
#define SEARCH_CLASSES 3
uint32_t search_coherent_signal(RawSamplesBuffer *s, uint32_t idx) {
    struct {
        uint32_t dur[2];     /* dur[0] = low, dur[1] = high */
        uint32_t count[2];   /* Associated observed frequency. */
    } classes[SEARCH_CLASSES];

    memset(classes,0,sizeof(classes));
    uint32_t minlen = 40, maxlen = 4000; /* Depends on data rate, here we
                                            allow for high and low. */
    uint32_t len = 0; /* Observed len of coherent samples. */
    s->short_pulse_dur = 0;
    for (uint32_t j = idx; j < idx+500; j++) {
        bool level;
        uint32_t dur;
        raw_samples_get(s, j, &level, &dur);
        if (dur < minlen || dur > maxlen) break; /* return. */

        /* Let's see if it matches a class we already have or if we
         * can populate a new (yet empty) class. */
        uint32_t k;
        for (k = 0; k < SEARCH_CLASSES; k++) {
            if (classes[k].count[level] == 0) {
                classes[k].dur[level] = dur;
                classes[k].count[level] = 1;
                break; /* Sample accepted. */
            } else {
                uint32_t classavg = classes[k].dur[level];
                uint32_t count = classes[k].count[level];
                uint32_t delta = duration_delta(dur,classavg);
                if (delta < classavg/10) {
                    /* It is useful to compute the average of the class
                     * we are observing. We know how many samples we got so
                     * far, so we can recompute the average easily.
                     * By always having a better estimate of the pulse len
                     * we can avoid missing next samples in case the first
                     * observed samples are too off. */
                    classavg = ((classavg * count) + dur) / (count+1);
                    classes[k].dur[level] = classavg;
                    classes[k].count[level]++;
                    break; /* Sample accepted. */
                }
            }
        }

        if (k == SEARCH_CLASSES) break; /* No match, return. */

        /* If we are here, we accepted this sample. Try with the next
         * one. */
        len++;
    }

    /* Update the buffer setting the shortest pulse we found
     * among the three classes. This will be used when scaling
     * for visualization. */
    for (int j = 0; j < SEARCH_CLASSES; j++) {
        for (int level = 0; level < 2; level++) {
            if (classes[j].dur[level] == 0) continue;
            if (classes[j].count[level] < 3) continue;
            if (s->short_pulse_dur == 0 ||
                s->short_pulse_dur > classes[j].dur[level])
            {
                s->short_pulse_dur = classes[j].dur[level];
            }
        }
    }
    return len;
}

/* Search the buffer with the stored signal (last N samples received)
 * in order to find a coherent signal. If a signal that does not appear to
 * be just noise is found, it is set in DetectedSamples global signal
 * buffer, that is what is rendered on the screen. */
void scan_for_signal(ProtoViewApp *app) {
    /* We need to work on a copy: the RawSamples buffer is populated
     * by the background thread receiving data. */
    RawSamplesBuffer *copy = raw_samples_alloc();
    raw_samples_copy(copy,RawSamples);

    /* Try to seek on data that looks to have a regular high low high low
     * pattern. */
    uint32_t minlen = 13;           /* Min run of coherent samples. Up to
                                       12 samples it's very easy to mistake
                                       noise for signal. */

    uint32_t i = 0;
    while (i < copy->total-1) {
        uint32_t thislen = search_coherent_signal(copy,i);
        if (thislen > minlen && thislen > app->signal_bestlen) {
            app->signal_bestlen = thislen;
            raw_samples_copy(DetectedSamples,copy);
            DetectedSamples->idx = (DetectedSamples->idx+i)%
                                   DetectedSamples->total;
            FURI_LOG_E(TAG, "Displayed sample updated (%d samples)",
                (int)thislen);
        }
        i += thislen ? thislen : 1;
    }
    raw_samples_free(copy);
}

/* Draw some text with a border. If the outside color is black and the inside
 * color is white, it just writes the border of the text, but the function can
 * also be used to write a bold variation of the font setting both the
 * colors to black, or alternatively to write a black text with a white
 * border so that it is visible if there are black stuff on the background. */
void canvas_draw_str_with_border(Canvas* canvas, uint8_t x, uint8_t y, const char* str, Color text_color, Color border_color)
{
    struct {
        uint8_t x; uint8_t y;
    } dir[8] = {
        {-1,-1},
        {0,-1},
        {1,-1},
        {1,0},
        {1,1},
        {0,1},
        {-1,1},
        {-1,0}
    };

    /* Rotate in all the directions writing the same string to create a
     * border, then write the actual string in the other color in the
     * middle. */
    canvas_set_color(canvas, border_color);
    for (int j = 0; j < 8; j++)
        canvas_draw_str(canvas,x+dir[j].x,y+dir[j].y,str);
    canvas_set_color(canvas, text_color);
    canvas_draw_str(canvas,x,y,str);
    canvas_set_color(canvas, ColorBlack);
}

/* Raw pulses rendering. This is our default view. */
void render_view_raw_pulses(Canvas *const canvas, ProtoViewApp *app) {
    /* Show signal. */
    render_signal(app, canvas, DetectedSamples, 0);

    /* Show signal information. */
    char buf[64];
    snprintf(buf,sizeof(buf),"%luus",
        (unsigned long)DetectedSamples->short_pulse_dur);
    canvas_set_font(canvas, FontSecondary);
    canvas_draw_str_with_border(canvas, 97, 63, buf, ColorWhite, ColorBlack);
}

/* Renders a single view with frequency and modulation setting. However
 * this are logically two different views, and only one of the settings
 * will be highlighted. */
void render_view_settings(Canvas *const canvas, ProtoViewApp *app) {
    UNUSED(app);
    canvas_set_font(canvas, FontPrimary);
    if (app->current_view == ViewFrequencySettings)
        canvas_draw_str_with_border(canvas,1,10,"Frequency",ColorWhite,ColorBlack);
    else
        canvas_draw_str(canvas,1,10,"Frequency");

    if (app->current_view == ViewModulationSettings)
        canvas_draw_str_with_border(canvas,70,10,"Modulation",ColorWhite,ColorBlack);
    else
        canvas_draw_str(canvas,70,10,"Modulation");
    canvas_set_font(canvas, FontSecondary);
    canvas_draw_str(canvas,10,61,"Use up and down to modify");

    /* Show frequency. We can use big numbers font since it's just a number. */
    if (app->current_view == ViewFrequencySettings) {
        char buf[16];
        snprintf(buf,sizeof(buf),"%.2f",(double)app->frequency/1000000);
        canvas_set_font(canvas, FontBigNumbers);
        canvas_draw_str(canvas, 30, 40, buf);
    } else if (app->current_view == ViewModulationSettings) {
        int current = app->modulation;
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 33, 39, ProtoViewModulations[current].name);
    }
}

/* The callback actually just passes the control to the actual active
 * view callback, after setting up basic stuff like cleaning the screen
 * and setting color to black. */
static void render_callback(Canvas *const canvas, void *ctx) {
    ProtoViewApp *app = ctx;

    /* Clear screen. */
    canvas_set_color(canvas, ColorWhite);
    canvas_draw_box(canvas, 0, 0, 127, 63);
    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);

    /* Call who is in charge right now. */
    switch(app->current_view) {
    case ViewRawPulses: render_view_raw_pulses(canvas,app); break;
    case ViewFrequencySettings:
    case ViewModulationSettings:
        render_view_settings(canvas,app); break;
    case ViewLast: furi_crash(TAG " ViewLast selected"); break;
    }
}

/* Here all we do is putting the events into the queue that will be handled
 * in the while() loop of the app entry point function. */
static void input_callback(InputEvent* input_event, void* ctx)
{
    ProtoViewApp *app = ctx;

    if (input_event->type == InputTypePress) {
        furi_message_queue_put(app->event_queue,input_event,FuriWaitForever);
        FURI_LOG_E(TAG, "INPUT CALLBACK %d", (int)input_event->key);
    }
}

/* Allocate the application state and initialize a number of stuff.
 * This is called in the entry point to create the application state. */
ProtoViewApp* protoview_app_alloc() {
    ProtoViewApp *app = malloc(sizeof(ProtoViewApp));

    // Init shared data structures
    RawSamples = raw_samples_alloc();
    DetectedSamples = raw_samples_alloc();

    //init setting
    app->setting = subghz_setting_alloc();
    subghz_setting_load(app->setting, EXT_PATH("protoview/settings.txt"));

    // GUI
    app->gui = furi_record_open(RECORD_GUI);
    app->view_port = view_port_alloc();
    view_port_draw_callback_set(app->view_port, render_callback, app);
    view_port_input_callback_set(app->view_port, input_callback, app);
    gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen);
    app->event_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
    app->current_view = ViewRawPulses;

    // Signal found and visualization defaults
    app->signal_bestlen = 0;
    app->us_scale = 100;

    //init Worker & Protocol
    app->txrx = malloc(sizeof(ProtoViewTxRx));

    /* Setup rx worker and environment. */
    app->txrx->worker = subghz_worker_alloc();
    app->txrx->environment = subghz_environment_alloc();
    subghz_environment_set_protocol_registry(
        app->txrx->environment, (void*)&protoview_protocol_registry);
    app->txrx->receiver = subghz_receiver_alloc_init(app->txrx->environment);

    subghz_receiver_set_filter(app->txrx->receiver, SubGhzProtocolFlag_Decodable);
    subghz_worker_set_overrun_callback(
        app->txrx->worker, (SubGhzWorkerOverrunCallback)subghz_receiver_reset);
    subghz_worker_set_pair_callback(
        app->txrx->worker, (SubGhzWorkerPairCallback)subghz_receiver_decode);
    subghz_worker_set_context(app->txrx->worker, app->txrx->receiver);
    
    app->frequency = subghz_setting_get_default_frequency(app->setting);
    app->modulation = 0; /* Defaults to ProtoViewModulations[0]. */

    furi_hal_power_suppress_charge_enter();
    app->running = 1;

    return app;
}

/* Free what the application allocated. It is not clear to me if the
 * Flipper OS, once the application exits, will be able to reclaim space
 * even if we forget to free something here. */
void protoview_app_free(ProtoViewApp *app) {
    furi_assert(app);

    // Put CC1101 on sleep.
    radio_sleep(app);

    // View related.
    view_port_enabled_set(app->view_port, false);
    gui_remove_view_port(app->gui, app->view_port);
    view_port_free(app->view_port);
    furi_record_close(RECORD_GUI);
    furi_message_queue_free(app->event_queue);
    app->gui = NULL;

    // Frequency setting.
    subghz_setting_free(app->setting);

    // Worker stuff.
    subghz_receiver_free(app->txrx->receiver);
    subghz_environment_free(app->txrx->environment);
    subghz_worker_free(app->txrx->worker);
    free(app->txrx);

    // Raw samples buffers.
    raw_samples_free(RawSamples);
    raw_samples_free(DetectedSamples);
    furi_hal_power_suppress_charge_exit();

    free(app);
}

/* Called periodically. Do signal processing here. Data we process here
 * will be later displayed by the render callback. The side effect of this
 * function is to scan for signals and set DetectedSamples. */
static void timer_callback(void *ctx) {
    ProtoViewApp *app = ctx;
    scan_for_signal(app);
}

/* Handle input for the raw pulses view. */
void process_input_raw_pulses(ProtoViewApp *app, InputEvent input) {
    if (input.key == InputKeyOk) {
        /* Reset the current sample to capture the next. */
        app->signal_bestlen = 0;
        raw_samples_reset(DetectedSamples);
        raw_samples_reset(RawSamples);
    } else if (input.key == InputKeyDown) {
        /* Rescaling. The set becomes finer under 50us per pixel. */
        uint32_t scale_step = app->us_scale >= 50 ? 50 : 10;
        if (app->us_scale < 500) app->us_scale += scale_step;
    } else if (input.key == InputKeyUp) {
        uint32_t scale_step = app->us_scale > 50 ? 50 : 10;
        if (app->us_scale > 10) app->us_scale -= scale_step;
    }
}

/* Handle input for the settings view. */
void process_input_settings(ProtoViewApp *app, InputEvent input) {
    /* Here we handle only up and down. Avoid any work if the user
     * pressed something else. */
    if (input.key != InputKeyDown && input.key != InputKeyUp) return;

    if (app->current_view == ViewFrequencySettings) {
        size_t curidx = 0, i;
        size_t count = subghz_setting_get_frequency_count(app->setting);

        /* Scan the list of frequencies to check for the index of the
         * currently set frequency. */
        for(i = 0; i < count; i++) {
            uint32_t freq = subghz_setting_get_frequency(app->setting,i);
            if (freq == app->frequency) {
                curidx = i;
                break;
            }
        }
        if (i == count) return; /* Should never happen. */

        if (input.key == InputKeyUp) {
            curidx = (curidx+1) % count;
        } else if (input.key == InputKeyDown) {
            curidx = curidx == 0 ? count-1 : curidx-1;
        }
        app->frequency = subghz_setting_get_frequency(app->setting,curidx);
    } else if (app->current_view == ViewModulationSettings) {
        uint32_t count = 0;
        uint32_t modid = app->modulation;

        while(ProtoViewModulations[count].name != NULL) count++;
        if (input.key == InputKeyUp) {
            modid = (modid+1) % count;
        } else if (input.key == InputKeyDown) {
            modid = modid == 0 ? count-1 : modid-1;
        }
        app->modulation = modid;
    }

    /* Apply changes. */
    FURI_LOG_E(TAG, "Setting view, setting frequency/modulation to %lu %s", app->frequency, ProtoViewModulations[app->modulation].name);
    radio_rx_end(app);
    radio_begin(app);
    radio_rx(app);
}

int32_t protoview_app_entry(void* p) {
    UNUSED(p);
    ProtoViewApp *app = protoview_app_alloc();

    /* Create a timer. We do data analysis in the callback. */
    FuriTimer *timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, app);
    furi_timer_start(timer, furi_kernel_get_tick_frequency() / 4);

    /* Start listening to signals immediately. */
    radio_begin(app);
    radio_rx(app);

    /* This is the main event loop: here we get the events that are pushed
     * in the queue by input_callback(), and process them one after the
     * other. The timeout is 100 milliseconds, so if not input is received
     * before such time, we exit the queue_get() function and call
     * view_port_update() in order to refresh our screen content. */
    InputEvent input;
    while(app->running) {
        FuriStatus qstat = furi_message_queue_get(app->event_queue, &input, 100);
        if (qstat == FuriStatusOk) {
            FURI_LOG_E(TAG, "Main Loop - Input: %u", input.key);

            /* Handle navigation here. Then handle view-specific inputs
             * in the view specific handling function. */
            if (input.key == InputKeyBack) {
                /* Exit the app. */
                app->running = 0;
            } else if (input.key == InputKeyRight) {
                /* Go to the next view. */
                app->current_view++;
                if (app->current_view == ViewLast) app->current_view = 0;
            } else if (input.key == InputKeyLeft) {
                /* Go to the previous view. */
                if (app->current_view == 0)
                    app->current_view = ViewLast-1;
                else
                    app->current_view--;
            } else {
                switch(app->current_view) {
                case ViewRawPulses:
                    process_input_raw_pulses(app,input);
                    break;
                case ViewFrequencySettings:
                case ViewModulationSettings:
                    process_input_settings(app,input);
                    break;
                case ViewLast: furi_crash(TAG " ViewLast selected"); break;
                }
            }
        } else {
            static int c = 0;
            c++;
            if (!(c % 20)) FURI_LOG_E(TAG, "Loop timeout");
        }
        view_port_update(app->view_port);
    }

    /* App no longer running. Shut down and free. */
    if (app->txrx->txrx_state == TxRxStateRx) {
        FURI_LOG_E(TAG, "Putting CC1101 to sleep before exiting.");
        radio_rx_end(app);
        radio_sleep(app);
    }

    furi_timer_free(timer);
    protoview_app_free(app);
    return 0;
}