diff --git a/applications/plugins/protoview/README.md b/applications/plugins/protoview/README.md index a12aec979..71083cdef 100644 --- a/applications/plugins/protoview/README.md +++ b/applications/plugins/protoview/README.md @@ -1,17 +1,15 @@ -ProtoView is a digital signal detection and visualization tool for the -[Flipper Zero](https://flipperzero.one/). The Flipper is able to identify -a great deal of RF protocols, however when the exact protocol is not -implemented (and there are many proprietary ones, such as the ones of -the car keys), the curious person is left wondering what the device is -sending at all. Using ProtoView she or he can visualize the high and low pulses -like in the example image below (showing a Volkswagen key in 2FSK): +ProtoView is a digital signal detection, visualization, editing and reply tool for the [Flipper Zero](https://flipperzero.one/). The Flipper default application, called Subghz, is able to identify certain RF protocols, but when the exact protocol is not implemented (and there are many undocumented and unimplemented ones, such as the ones in use in TPMS systems, car keys and many others), the curious person is left wondering what the device is sending at all. Using ProtoView she or he can visualize the high and low pulses like in the example image below (showing a TPMS signal produced by a Renault tire): ![ProtoView screenshot raw signal](/images/protoview_1.jpg) This is often enough to make an initial idea about the encoding used -and if the selected modulation is correct. +and if the selected modulation is correct. For example, in the signal above +you can see a set of regular pulses and gaps used for synchronization, and then +a sequence of bits encoded in [Manchester](https://en.wikipedia.org/wiki/Manchester_code) line code. If you study these things for five minutes, you'll find yourself able to decode the bits with naked eyes. -Other than that, ProtoView is able to decode a few interesting protocols: +## Decoding capabilities + +Other than showing the raw signal, ProtoView is able to decode a few interesting protocols: * TPMS sensors: Renault, Toyota, Schrader, Citroen, Ford. * Microchip HSC200/300/301 Keeloq protocol. @@ -23,25 +21,39 @@ Other than that, ProtoView is able to decode a few interesting protocols: The app implements a framework that makes adding and experimenting with new protocols very simple. Check the `protocols` directory to see how the -API works. +API works, or read the full documentation at the end of this `README` file. +The gist of it is that the decoder receives the signal already converted into +a bitmap, where each bit represents a short pulse duration. Then there are +functions to seek specific sync/preamble sequences inside the bitmap, to decode +from different line codes, to compute checksums and so forth. -The secondary goal of ProtoView is to provide a somewhat-documented application -for the Flipper (even if ProtoView is a pretty atypical application: doesn't make use of the standard widgets and other abstractions provded by the framework). -Many apps dealing with the *subghz subsystem* (the Flipper -abstraction to work with the [CC1101 chip](https://www.ti.com/product/CC1101)) -tend to be complicated and completely undocumented. This is unfortunately -true for the firmware of the device itself. It's a shame because especially -in the case of code that talks with hardware peripherals there are tons -of assumptions and hard-gained lessons that can [only be captured by comments and are in the code only implicitly](http://antirez.com/news/124). +## Signals transmission capabilities + +Once ProtoView decodes a given message, it is able to *resample* it +in pulses and gaps of the theoretical duration, and send the signal again +via the Flipper TX capabilities. The captured signal can be sent +to different frequencies and modulations than the ones it was captured +from. + +For selected protocols, that implement the message creation methods, +ProtoView is also able to edit the message received, modify fields, +and finally re-detect the new produced signal and resend it. Signals +can also be produced from scratch, by setting all the fields to appropriate +values. + +## A well-documented app for the Flipper + +The secondary goal of ProtoView is to provide a well-documented application for the Flipper (even if ProtoView is a pretty atypical application: it doesn't make use of the standard widgets and other abstractions provided by the framework). +Most apps dealing with the *subghz subsystem* of the Flipper (the abstraction used to work with the [CC1101 chip](https://www.ti.com/product/CC1101)) tend to be complicated and completely undocumented. +Unfortunately, this is also true for the firmware of the device. +It's a shame, because especially in the case of code that talks with hardware peripherals there are tons of assumptions and hard-gained lessons that can [only be captured by comments and are in the code only implicitly](http://antirez.com/news/124). However, the Flipper firmware source code is well written even if it -lacks comments and documentation, so it is possible to make some ideas of -how things work just grepping inside. +lacks comments and documentation (and sometimes makes use of abstractions more convoluted than needed), so it is possible to make some ideas of how things work just grepping inside. In order to develop this application, I ended reading most parts of the firmware of the device. -# Detection algorithm +## Detection algorithm -In order to show unknown signals, the application attempts to understand if -the samples obtained by the Flipper API (a series of pulses that are high +In order to detect and show unknown signals, the application attempts to understand if the samples obtained by the Flipper API (a series of pulses that are high or low, and with different duration in microseconds) look like belonging to a legitimate signal, and aren't just noise. @@ -49,25 +61,34 @@ We can't make assumptions about the encoding and the data rate of the communication, so we use a simple but relatively effective algorithm. As we check the signal, we try to detect long parts of it that are composed of pulses roughly classifiable into -a maximum of three different classes of lengths, plus or minus 10%. Most -encodings are somewhat self-clocked, so they tend to have just two or +a maximum of three different duration classes, plus or minus a given percentage. +Most encodings are somewhat self-clocked, so they tend to have just two or three classes of pulse lengths. -However often pulses of the same theoretical +However, often, pulses of the same theoretical length have slightly different lengths in the case of high and low level -(RF on or off), so we classify them separately for robustness. +(RF on or off), so the detector classifies them separately for robustness. + +Once the raw signal is detected, the registered protocol decoders are called +against it, in the hope some of the decoders will make sense of the signal. # Usage -The application shows the longest coherent signal detected so far. +In the main screen, the application shows the longest coherent signal detected so far. The user can switch to other views pressing the LEFT and RIGHT keys. The BACK key will return back to the main screen. Long pressing BACK will quit the application. -* The OK button resets the current signal. -* The UP and DOWN buttons change the scale. Default is 100us per pixel. -* The LEFT and RIGHT buttons switch to settings. +## Main raw signal screen + +* A long press of the OK button resets the current signal, in order to capture a new one. +* The UP and DOWN buttons change the scale. Default is 100us per pixel, but it will be adapted to the signal just captured. +* A long press of the LEFT and RIGHT keys will pan the signal, to see what was transmitted before/after the current shown range. +* A short press to OK will recenter the signal and set the scale back to the default for the specific pulse duration detected. Under the detected sequence, you will see a small triangle marking a specific sample. This mark means that the sequence looked coherent up -to that point, and starting from there it could be just noise. +to that point, and starting from there it could be just noise. However the +signal decoders will not get just up to this point, but will get more: +sometimes the low level detector can't make sense of a signal that the +protocol-specific decoder can understand fully. If the protocol is decoded, the bottom-left corner of the screen will show the name of the protocol, and going in the next screen @@ -81,12 +102,47 @@ and could actually be `1000000/this-number*N` with `N > 2` (here 1000000 is the number of microseconds in one second, and N is the number of clock cycles needed to represent a bit). -Things to investigate: +## Info screen + +If a signal was detected, the info view will show the details about the signal. If the signal has more data that a single screen can fit, pressing OK will show the next fields. Pressing DOWN will go to a sub-view with an oscilloscope-alike representation of the signal, from there you can: + +1. Resend the signal, by pressing OK. +2. Save the signal as `.sub` file, by long pressing OK. + +When resending, you can select a different frequency and modulation if you +wish. + +## Frequency and modulation screen + +In this view you can just set the frequency and modulation you want to use. +There are special modulations for TPMS signals: they need an higher data +rate. * Many cheap remotes (gate openers, remotes, ...) are on the 433.92Mhz or nearby and use OOK modulation. * Weather stations are often too in the 433.92Mhz OOK. * For car keys, try 433.92 OOK650 and 868.35 Mhz in OOK or 2FSK. -* For TPMS try 433.92 in TPMS modulation (FSK optimized for these signals). +* For TPMS try 433.92 in TPMS1 or TPMS2 modulations (FSK and OOK custom modulations optimized for these signals, that have a relatively high data rate). + +## Signal creator + +In this view, you can do two things: + +1. Select one of the protocols supporting message creation, and create a signal from scratch. +2. If there is already a detected signal, you can modify the signal. + +This is how it works: + +1. Select one of the protocols (the one of the currently detected signal will be already provided as default, if any, and if it supports message creation). +2. Fill the fields. Use LEFT and RIGHT to change the values of integers, or just press OK and enter the new value with the Fliper keyboard widget. +3. When you are done, long press OK to build the message. Then press BACK in order to see it. +4. Go to the INFO view, and then DOWN to the signal sending/saving subview in order to send or save it. + +## Direct sampling screen + +This final screen shows in real time the high and low level that the Flipper +RF chip, the CC1101, is receiving. This will makes very easy to understand +if a given frequency is targeted by something other than noise. This mode is +fun to watch, resembling an old CRT TV set. # Installing the app from source @@ -113,6 +169,107 @@ to use the Android (or other) application to upload the file, you can just take out the SD card, insert it in your computer, copy the fine into `apps/Tools`, and that's it. +# Protocols decoders API + +Writing a protocol decoder is not hard, and requires to write three +different methods. + +1. `decode()`. This is mandatory, and is used in order to turn a known signal into a set of fields containing certain informations. For instance for a thermometer sending data via RF, a raw message will be decoded into fields like temperature, humidity, station ID and so forth. +2. `get_fields()`. Optional, only needed if the protocol supports creating and editing signals. This method just returns the fields names, types and defaults. The app will use this list in order to allow the user to set values. The populated fields will be passed to the `build_message()` method later. +3. `build_message()`. This method gets a set of fields representing the parameters of the protocol, as set by the user, and will create a low level signal composed of pulses and gaps of specific durations. + +## `decode()` method + + bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info); + +The method gets a bitmap `bits` long `numbytes` bytes but actually containing `bumbits` valid bits. Each bit represents a pulse of gap of the duration of the shortest time detected in the protocol (this is often called *te*, in the RF protocols jargon). So, for instance, if a signal is composed of pulses and gaps of around 500 and 1000 microseconds, each bit in the bitmap will represent 500 microseconds. + +Continuing with the example above, if the received signal was composed of a 1000 microseconds gap, then a 500 microsecond pulse, then a 500 microsecond gap and finally a 1000 microseconds pulse, its bitmap representation will be: + + 001011 + +To access the bitmap, the decoder can use the following API: + + bool bitmap_get(uint8_t *b, uint32_t blen, uint32_t bitpos); + +The `blen` parameter will be set to what the decode method gets +as `numbytes`, and is used to prevent overflows. This way if `bitpos` +is out of range, nothing bad happens. + +There are function to match and seek specific patterns inside the signal: + + bool bitmap_match_bits(uint8_t *b, uint32_t blen, uint32_t bitpos, const char *bits); + uint32_t bitmap_seek_bits(uint8_t *b, uint32_t blen, uint32_t startpos, uint32_t maxbits, const char *bits); + +Finally, there are functions to convert from different line codes: + + uint32_t convert_from_line_code(uint8_t *buf, uint64_t buflen, uint8_t *bits, uint32_t len, uint32_t offset, const char *zero_pattern, const char *one_pattern); + uint32_t convert_from_diff_manchester(uint8_t *buf, uint64_t buflen, uint8_t *bits, uint32_t len, uint32_t off, bool previous); + +This method can also access the short pulse duration by inspecting the +`info->short_pulse_dur` field (in microseconds). + +Please check the `b4b1.c` file for an easy to understand example of the decoder implementation. + +If the decoder actually detected a message, it will return `true` and will return a set of fields, like thata: + + fieldset_add_bytes(info->fieldset,"id",d,5); + fieldset_add_uint(info->fieldset,"button",d[2]&0xf,4); + +## `get_fields()` method. + + static void get_fields(ProtoViewFieldSet *fieldset); + +This method will be basically a copy of the final part of `decode()`, as +it also needs to return the set of fields this protocol is composed of. +However instead of returning the values of an actual decoded message, it +will just provide their default values for the signal creator view. + +Note that the `build_message()` method is guaranteed to receive the +same exact fields in the same exact order. + +## `build_message()` method. + + void build_message(RawSamplesBuffer *samples, ProtoViewFieldSet *fs); + +This method is responsible of creating a signal from scratch, by +appending gaps and pulses of the specific duration into `samples` +using the following API: + + raw_samples_add(RawSamplesBuffer *samples, bool level, uint32_t duration); + +Level can be true (pules) or false (gap). Duration is in microseconds. +The method receives a set of fields in `fs`. Each field is accessible +directly accessing `fs->fields[... field index ...]`, where the field +index is 0, 1, 2, ... in the same order as `get_fields()` returned the +fields. + +For now, you can access the fields in the raw way, by getting the +values directly from the data structure representing each field: + +``` +typedef struct { + ProtoViewFieldType type; + uint32_t len; // Depends on type: + // Bits for integers (signed,unsigned,binary,hex). + // Number of characters for strings. + // Number of nibbles for bytes (1 for each 4 bits). + // Number of digits after dot for floats. + char *name; // Field name. + union { + char *str; // String type. + int64_t value; // Signed integer type. + uint64_t uvalue; // Unsigned integer type. + uint8_t *bytes; // Raw bytes type. + float fvalue; // Float type. + }; +} ProtoViewField; + +``` + +However later the app will likely provide a set of macros to do it +in a more future-proof way. + # License The code is released under the BSD license. diff --git a/applications/plugins/protoview/TODO b/applications/plugins/protoview/TODO deleted file mode 100644 index feb7b0743..000000000 --- a/applications/plugins/protoview/TODO +++ /dev/null @@ -1,14 +0,0 @@ -Core improvements -================= - -- Decoders should declare the short pulse duration range, so that - only matching decoders will be called. This may also be useful for - modulations. If a signal is only OOK, does not make much sense to - call it for samples obtained in FSK. -- More protocols, especially TPMS and other stuff not supported right now - by the Flipper. -- CC1101 synchronous mode with protocol hopping? -- Protocols decoded can register actions, for instance to generate - sub files with modified signal and so forth. -- Optimize memory usage storing raw samples in a bitfield: 15 bits - duration, 1 bit level. diff --git a/applications/plugins/protoview/app.c b/applications/plugins/protoview/app.c index ea4e366b8..f16457e55 100644 --- a/applications/plugins/protoview/app.c +++ b/applications/plugins/protoview/app.c @@ -57,8 +57,12 @@ static void render_callback(Canvas *const canvas, void *ctx) { case ViewModulationSettings: render_view_settings(canvas,app); break; case ViewDirectSampling: render_view_direct_sampling(canvas,app); break; - case ViewLast: furi_crash(TAG " ViewLast selected"); break; + case ViewBuildMessage: render_view_build_message(canvas,app); break; + default: furi_crash(TAG "Invalid view selected"); break; } + + /* Draw the alert box if set. */ + ui_draw_alert_if_needed(canvas, app); } /* Here all we do is putting the events into the queue that will be handled @@ -69,32 +73,53 @@ static void input_callback(InputEvent* input_event, void* ctx) furi_message_queue_put(app->event_queue,input_event,FuriWaitForever); } - /* Called to switch view (when left/right is pressed). Handles * changing the current view ID and calling the enter/exit view - * callbacks if needed. */ -static void app_switch_view(ProtoViewApp *app, SwitchViewDirection dir) { + * callbacks if needed. + * + * The 'switchto' parameter can be the identifier of a view, or the + * special views ViewGoNext and ViewGoPrev in order to move to + * the logical next/prev view. */ +static void app_switch_view(ProtoViewApp *app, ProtoViewCurrentView switchto) { + /* Switch to the specified view. */ ProtoViewCurrentView old = app->current_view; - if (dir == AppNextView) { + if (switchto == ViewGoNext) { app->current_view++; if (app->current_view == ViewLast) app->current_view = 0; - } else if (dir == AppPrevView) { + } else if (switchto == ViewGoPrev) { if (app->current_view == 0) app->current_view = ViewLast-1; else app->current_view--; + } else { + app->current_view = switchto; } ProtoViewCurrentView new = app->current_view; + /* Set the current subview of the view we just left to zero. This is + * the main subview of the old view. When re re-enter the view we are + * lefting, we want to see the main thing again. */ + app->current_subview[old] = 0; + + /* Reset the view private data each time, before calling the enter/exit + * callbacks that may want to setup some state. */ + memset(app->view_privdata,0,PROTOVIEW_VIEW_PRIVDATA_LEN); + /* Call the enter/exit view callbacks if needed. */ if (old == ViewDirectSampling) view_exit_direct_sampling(app); if (new == ViewDirectSampling) view_enter_direct_sampling(app); + if (old == ViewBuildMessage) view_exit_build_message(app); + if (new == ViewBuildMessage) view_enter_build_message(app); + if (old == ViewInfo) view_exit_info(app); + /* The frequency/modulation settings are actually a single view: * as long as the user stays between the two modes of this view we * don't need to call the exit-view callback. */ if ((old == ViewFrequencySettings && new != ViewModulationSettings) || (old == ViewModulationSettings && new != ViewFrequencySettings)) view_exit_settings(app); + + ui_dismiss_alert(app); } /* Allocate the application state and initialize a number of stuff. @@ -112,13 +137,21 @@ ProtoViewApp* protoview_app_alloc() { // GUI app->gui = furi_record_open(RECORD_GUI); + app->notification = furi_record_open(RECORD_NOTIFICATION); 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->view_dispatcher = NULL; + app->text_input = NULL; + app->show_text_input = false; + app->alert_dismiss_time = 0; app->current_view = ViewRawPulses; + for (int j = 0; j < ViewLast; j++) app->current_subview[j] = 0; app->direct_sampling_enabled = false; + app->view_privdata = malloc(PROTOVIEW_VIEW_PRIVDATA_LEN); + memset(app->view_privdata,0,PROTOVIEW_VIEW_PRIVDATA_LEN); // Signal found and visualization defaults app->signal_bestlen = 0; @@ -126,8 +159,9 @@ ProtoViewApp* protoview_app_alloc() { app->signal_decoded = false; app->us_scale = PROTOVIEW_RAW_VIEW_DEFAULT_SCALE; app->signal_offset = 0; + app->msg_info = NULL; - //init Worker & Protocol + // Init Worker & Protocol app->txrx = malloc(sizeof(ProtoViewTxRx)); /* Setup rx worker and environment. */ @@ -168,7 +202,7 @@ ProtoViewApp* protoview_app_alloc() { void protoview_app_free(ProtoViewApp *app) { furi_assert(app); - // Put CC1101 on sleep. + // Put CC1101 on sleep, this also restores charging. radio_sleep(app); // View related. @@ -176,6 +210,7 @@ void protoview_app_free(ProtoViewApp *app) { gui_remove_view_port(app->gui, app->view_port); view_port_free(app->view_port); furi_record_close(RECORD_GUI); + furi_record_close(RECORD_NOTIFICATION); furi_message_queue_free(app->event_queue); app->gui = NULL; @@ -217,9 +252,25 @@ static void timer_callback(void *ctx) { } if (delta < RawSamples->total/2) return; app->signal_last_scan_idx = RawSamples->idx; - scan_for_signal(app); + scan_for_signal(app,RawSamples); } +/* This is the navigation callback we use in the view dispatcher used + * to display the "text input" widget, that is the keyboard to get text. + * The text input view is implemented to ignore the "back" short press, + * so the event is not consumed and is handled by the view dispatcher. + * However the view dispatcher implementation has the strange behavior that + * if no navigation callback is set, it will not stop when handling back. + * + * We just need a dummy callback returning false. We believe the + * implementation should be changed and if no callback is set, it should be + * the same as returning false. */ +static bool keyboard_view_dispatcher_navigation_callback(void *ctx) { + UNUSED(ctx); + return false; +} + +/* App entry point, as specified in application.fam. */ int32_t protoview_app_entry(void* p) { UNUSED(p); ProtoViewApp *app = protoview_app_alloc(); @@ -249,18 +300,30 @@ int32_t protoview_app_entry(void* p) { if (input.type == InputTypeShort && input.key == InputKeyBack) { - /* Exit the app. */ + if (app->current_view != ViewRawPulses) { + /* If this is not the main app view, go there. */ + app_switch_view(app,ViewRawPulses); + } else { + /* If we are in the main app view, warn the user + * they needs to long press to really quit. */ + ui_show_alert(app,"Long press to exit",1000); + } + } else if (input.type == InputTypeLong && + input.key == InputKeyBack) + { app->running = 0; } else if (input.type == InputTypeShort && - input.key == InputKeyRight) + input.key == InputKeyRight && + ui_get_current_subview(app) == 0) { /* Go to the next view. */ - app_switch_view(app,AppNextView); + app_switch_view(app,ViewGoNext); } else if (input.type == InputTypeShort && - input.key == InputKeyLeft) + input.key == InputKeyLeft && + ui_get_current_subview(app) == 0) { /* Go to the previous view. */ - app_switch_view(app,AppPrevView); + app_switch_view(app,ViewGoPrev); } else { /* This is where we pass the control to the currently * active view input processing. */ @@ -278,7 +341,10 @@ int32_t protoview_app_entry(void* p) { case ViewDirectSampling: process_input_direct_sampling(app,input); break; - case ViewLast: furi_crash(TAG " ViewLast selected"); break; + case ViewBuildMessage: + process_input_build_message(app,input); + break; + default: furi_crash(TAG "Invalid view selected"); break; } } } else { @@ -289,7 +355,54 @@ int32_t protoview_app_entry(void* p) { if (!(c % 20)) FURI_LOG_E(TAG, "Loop timeout"); } } - view_port_update(app->view_port); + if (app->show_text_input) { + /* Remove our viewport: we need to use a view dispatcher + * in order to show the standard Flipper keyboard. */ + gui_remove_view_port(app->gui, app->view_port); + + /* Allocate a view dispatcher, add a text input view to it, + * and activate it. */ + app->view_dispatcher = view_dispatcher_alloc(); + view_dispatcher_enable_queue(app->view_dispatcher); + /* We need to set a navigation callback for the view dispatcher + * otherwise when the user presses back on the keyboard to + * abort, the dispatcher will not stop. */ + view_dispatcher_set_navigation_event_callback( + app->view_dispatcher, + keyboard_view_dispatcher_navigation_callback); + app->text_input = text_input_alloc(); + view_dispatcher_set_event_callback_context(app->view_dispatcher,app); + view_dispatcher_add_view(app->view_dispatcher, 0, text_input_get_view(app->text_input)); + view_dispatcher_switch_to_view(app->view_dispatcher, 0); + + /* Setup the text input view. The different parameters are set + * in the app structure by the view that wanted to show the + * input text. The callback, buffer and buffer len must be set. */ + text_input_set_header_text(app->text_input, "Save signal filename"); + text_input_set_result_callback( + app->text_input, + app->text_input_done_callback, + app, + app->text_input_buffer, + app->text_input_buffer_len, + false); + + /* Run the dispatcher with the keyboard. */ + view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen); + view_dispatcher_run(app->view_dispatcher); + + /* Undo all it: remove the view from the dispatcher, free it + * so that it removes itself from the current gui, finally + * restore our viewport. */ + view_dispatcher_remove_view(app->view_dispatcher, 0); + text_input_free(app->text_input); + view_dispatcher_free(app->view_dispatcher); + app->view_dispatcher = NULL; + gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen); + app->show_text_input = false; + } else { + view_port_update(app->view_port); + } } /* App no longer running. Shut down and free. */ diff --git a/applications/plugins/protoview/app.h b/applications/plugins/protoview/app.h index 52b0bff5b..33bd85eb4 100644 --- a/applications/plugins/protoview/app.h +++ b/applications/plugins/protoview/app.h @@ -14,26 +14,36 @@ #include #include #include +#include #include #include #include #include #include #include -#include "app_buffer.h" +#include "raw_samples.h" #define TAG "ProtoView" -#define PROTOVIEW_RAW_VIEW_DEFAULT_SCALE 100 -#define BITMAP_SEEK_NOT_FOUND UINT32_MAX +#define PROTOVIEW_RAW_VIEW_DEFAULT_SCALE 100 // 100us is 1 pixel by default +#define BITMAP_SEEK_NOT_FOUND UINT32_MAX // Returned by function as sentinel +#define PROTOVIEW_VIEW_PRIVDATA_LEN 64 // View specific private data len #define DEBUG_MSG 1 +/* Forward declarations. */ + typedef struct ProtoViewApp ProtoViewApp; +typedef struct ProtoViewMsgInfo ProtoViewMsgInfo; +typedef struct ProtoViewFieldSet ProtoViewFieldSet; +typedef struct ProtoViewDecoder ProtoViewDecoder; + +/* ============================== enumerations ============================== */ /* Subghz system state */ typedef enum { TxRxStateIDLE, TxRxStateRx, + TxRxStateTx, TxRxStateSleep, } TxRxState; @@ -43,20 +53,24 @@ typedef enum { ViewInfo, ViewFrequencySettings, ViewModulationSettings, + ViewBuildMessage, ViewDirectSampling, ViewLast, /* Just a sentinel to wrap around. */ + + /* The following are special views that are not iterated, but + * have meaning for the API. */ + ViewGoNext, + ViewGoPrev, } ProtoViewCurrentView; -/* Used by app_switch_view() */ -typedef enum { - AppNextView, - AppPrevView -} SwitchViewDirection; +/* ================================== RX/TX ================================= */ typedef struct { - const char *name; - FuriHalSubGhzPreset preset; - uint8_t *custom; + const char *name; // Name to show to the user. + const char *id; // Identifier in the Flipper API/file. + FuriHalSubGhzPreset preset; // The preset ID. + uint8_t *custom; // If not null, a set of registers for + // the CC1101, specifying a custom preset. } ProtoViewModulation; extern ProtoViewModulation ProtoViewModulations[]; /* In app_subghz.c */ @@ -84,30 +98,35 @@ struct ProtoViewTxRx { typedef struct ProtoViewTxRx ProtoViewTxRx; -/* This stucture is filled by the decoder for specific protocols with the - * informations about the message. ProtoView will display such information - * in the message info view. */ -#define PROTOVIEW_MSG_STR_LEN 32 -typedef struct ProtoViewMsgInfo { - char name[PROTOVIEW_MSG_STR_LEN]; /* Protocol name and version. */ - char raw[PROTOVIEW_MSG_STR_LEN]; /* Protocol specific raw representation.*/ - /* The following is what the decoder wants to show to user. Each decoder - * can use the number of fileds it needs. */ - char info1[PROTOVIEW_MSG_STR_LEN]; /* Protocol specific info line 1. */ - char info2[PROTOVIEW_MSG_STR_LEN]; /* Protocol specific info line 2. */ - char info3[PROTOVIEW_MSG_STR_LEN]; /* Protocol specific info line 3. */ - char info4[PROTOVIEW_MSG_STR_LEN]; /* Protocol specific info line 4. */ - uint64_t len; /* Bits consumed from the stream. */ -} ProtoViewMsgInfo; +/* ============================== Main app state ============================ */ +#define ALERT_MAX_LEN 32 struct ProtoViewApp { /* GUI */ Gui *gui; + NotificationApp *notification; ViewPort *view_port; /* We just use a raw viewport and we render everything into the low level canvas. */ - ProtoViewCurrentView current_view; /* Active view ID. */ + ProtoViewCurrentView current_view; /* Active left-right view ID. */ + int current_subview[ViewLast]; /* Active up-down subview ID. */ FuriMessageQueue *event_queue; /* Keypress events go here. */ + /* Input text state. */ + ViewDispatcher *view_dispatcher; /* Used only when we want to show + the text_input view for a moment. + Otherwise it is set to null. */ + TextInput *text_input; + bool show_text_input; + char *text_input_buffer; + uint32_t text_input_buffer_len; + void (*text_input_done_callback)(void*); + + /* Alert state. */ + uint32_t alert_dismiss_time; /* Millisecond when the alert will be + no longer shown. Or zero if the alert + is currently not set at all. */ + char alert_text[ALERT_MAX_LEN]; /* Alert content. */ + /* Radio related. */ ProtoViewTxRx *txrx; /* Radio state. */ SubGhzSetting *setting; /* A list of valid frequencies. */ @@ -118,9 +137,16 @@ struct ProtoViewApp { uint32_t signal_last_scan_idx; /* Index of the buffer last time we performed the scan. */ bool signal_decoded; /* Was the current signal decoded? */ - ProtoViewMsgInfo signal_info; /* Decoded message, if signal_decoded true. */ + ProtoViewMsgInfo *msg_info; /* Decoded message info if not NULL. */ bool direct_sampling_enabled; /* This special view needs an explicit acknowledge to work. */ + void *view_privdata; /* This is a piece of memory of total size + PROTOVIEW_VIEW_PRIVDATA_LEN that it is + initialized to zero when we switch to + a a new view. While the view we are using + is the same, it can be used by the view to + store any kind of info inside, just casting + the pointer to a few specific-data structure. */ /* Raw view apps state. */ uint32_t us_scale; /* microseconds per pixel. */ @@ -132,6 +158,64 @@ struct ProtoViewApp { ProtoViewModulations table. */ }; +/* =========================== Protocols decoders =========================== */ + +/* This stucture is filled by the decoder for specific protocols with the + * informations about the message. ProtoView will display such information + * in the message info view. */ +#define PROTOVIEW_MSG_STR_LEN 32 +typedef struct ProtoViewMsgInfo { + ProtoViewDecoder *decoder; /* The decoder that decoded the message. */ + ProtoViewFieldSet *fieldset; /* Decoded fields. */ + /* Low level information of the detected signal: the following are filled + * by the protocol decoding function: */ + uint32_t start_off; /* Pulses start offset in the bitmap. */ + uint32_t pulses_count; /* Number of pulses of the full message. */ + /* The following are passed already filled to the decoder. */ + uint32_t short_pulse_dur; /* Microseconds duration of the short pulse. */ + /* The following are filled by ProtoView core after the decoder returned + * success. */ + uint8_t *bits; /* Bitmap with the signal. */ + uint32_t bits_bytes; /* Number of full bytes in the bitmap, that + is 'pulses_count/8' rounded to the next + integer. */ +} ProtoViewMsgInfo; + +/* This structures describe a set of protocol fields. It is used by decoders + * supporting message building to receive and return information about the + * protocol. */ +typedef enum { + FieldTypeStr, + FieldTypeSignedInt, + FieldTypeUnsignedInt, + FieldTypeBinary, + FieldTypeHex, + FieldTypeBytes, + FieldTypeFloat, +} ProtoViewFieldType; + +typedef struct { + ProtoViewFieldType type; + uint32_t len; // Depends on type: + // Bits for integers (signed,unsigned,binary,hex). + // Number of characters for strings. + // Number of nibbles for bytes (1 for each 4 bits). + // Number of digits after dot for floats. + char *name; // Field name. + union { + char *str; // String type. + int64_t value; // Signed integer type. + uint64_t uvalue; // Unsigned integer type. + uint8_t *bytes; // Raw bytes type. + float fvalue; // Float type. + }; +} ProtoViewField; + +typedef struct ProtoViewFieldSet { + ProtoViewField **fields; + uint32_t numfields; +} ProtoViewFieldSet; + typedef struct ProtoViewDecoder { const char *name; /* Protocol name. */ /* The decode function takes a buffer that is actually a bitmap, with @@ -142,6 +226,14 @@ typedef struct ProtoViewDecoder { * functions that perform bit extraction with bound checking, such as * bitmap_get() and so forth. */ bool (*decode)(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info); + /* This method is used by the decoder to return the fields it needs + * in order to build a new message. This way the message builder view + * can ask the user to fill the right set of fields of the specified + * type. */ + void (*get_fields)(ProtoViewFieldSet *fields); + /* This method takes the fields supported by the decoder, and + * renders a message in 'samples'. */ + void (*build_message)(RawSamplesBuffer *samples, ProtoViewFieldSet *fields); } ProtoViewDecoder; extern RawSamplesBuffer *RawSamples, *DetectedSamples; @@ -154,19 +246,26 @@ void radio_rx_end(ProtoViewApp* app); void radio_sleep(ProtoViewApp* app); void raw_sampling_worker_start(ProtoViewApp *app); void raw_sampling_worker_stop(ProtoViewApp *app); +void radio_tx_signal(ProtoViewApp *app, FuriHalSubGhzAsyncTxCallback data_feeder, void *ctx); /* signal.c */ uint32_t duration_delta(uint32_t a, uint32_t b); void reset_current_signal(ProtoViewApp *app); -void scan_for_signal(ProtoViewApp *app); +void scan_for_signal(ProtoViewApp *app,RawSamplesBuffer *source); bool bitmap_get(uint8_t *b, uint32_t blen, uint32_t bitpos); void bitmap_set(uint8_t *b, uint32_t blen, uint32_t bitpos, bool val); -void bitmap_set_pattern(uint8_t *b, uint32_t blen, const char *pat); -void bitmap_reverse_bytes(uint8_t *p, uint32_t len); +void bitmap_copy(uint8_t *d, uint32_t dlen, uint32_t doff, uint8_t *s, uint32_t slen, uint32_t soff, uint32_t count); +void bitmap_set_pattern(uint8_t *b, uint32_t blen, uint32_t off, const char *pat); +void bitmap_reverse_bytes_bits(uint8_t *p, uint32_t len); bool bitmap_match_bits(uint8_t *b, uint32_t blen, uint32_t bitpos, const char *bits); uint32_t bitmap_seek_bits(uint8_t *b, uint32_t blen, uint32_t startpos, uint32_t maxbits, const char *bits); uint32_t convert_from_line_code(uint8_t *buf, uint64_t buflen, uint8_t *bits, uint32_t len, uint32_t offset, const char *zero_pattern, const char *one_pattern); uint32_t convert_from_diff_manchester(uint8_t *buf, uint64_t buflen, uint8_t *bits, uint32_t len, uint32_t off, bool previous); +void init_msg_info(ProtoViewMsgInfo *i, ProtoViewApp *app); +void free_msg_info(ProtoViewMsgInfo *i); + +/* signal_file.c */ +bool save_signal(ProtoViewApp *app, const char *filename); /* view_*.c */ void render_view_raw_pulses(Canvas *const canvas, ProtoViewApp *app); @@ -177,12 +276,44 @@ void render_view_info(Canvas *const canvas, ProtoViewApp *app); void process_input_info(ProtoViewApp *app, InputEvent input); void render_view_direct_sampling(Canvas *const canvas, ProtoViewApp *app); void process_input_direct_sampling(ProtoViewApp *app, InputEvent input); +void render_view_build_message(Canvas *const canvas, ProtoViewApp *app); +void process_input_build_message(ProtoViewApp *app, InputEvent input); +void view_enter_build_message(ProtoViewApp *app); +void view_exit_build_message(ProtoViewApp *app); void view_enter_direct_sampling(ProtoViewApp *app); void view_exit_direct_sampling(ProtoViewApp *app); void view_exit_settings(ProtoViewApp *app); +void view_exit_info(ProtoViewApp *app); +void adjust_raw_view_scale(ProtoViewApp *app, uint32_t short_pulse_dur); /* ui.c */ +int ui_get_current_subview(ProtoViewApp *app); +void ui_show_available_subviews(Canvas *canvas, ProtoViewApp *app, int last_subview); +bool ui_process_subview_updown(ProtoViewApp *app, InputEvent input, int last_subview); +void ui_show_keyboard(ProtoViewApp *app, char *buffer, uint32_t buflen, + void (*done_callback)(void*)); +void ui_dismiss_keyboard(ProtoViewApp *app); +void ui_show_alert(ProtoViewApp *app, const char *text, uint32_t ttl); +void ui_dismiss_alert(ProtoViewApp *app); +void ui_draw_alert_if_needed(Canvas *canvas, ProtoViewApp *app); void canvas_draw_str_with_border(Canvas* canvas, uint8_t x, uint8_t y, const char* str, Color text_color, Color border_color); +/* fields.c */ +void fieldset_free(ProtoViewFieldSet *fs); +ProtoViewFieldSet *fieldset_new(void); +void fieldset_add_int(ProtoViewFieldSet *fs, const char *name, int64_t val, uint8_t bits); +void fieldset_add_uint(ProtoViewFieldSet *fs, const char *name, uint64_t uval, uint8_t bits); +void fieldset_add_hex(ProtoViewFieldSet *fs, const char *name, uint64_t uval, uint8_t bits); +void fieldset_add_bin(ProtoViewFieldSet *fs, const char *name, uint64_t uval, uint8_t bits); +void fieldset_add_str(ProtoViewFieldSet *fs, const char *name, const char *s); +void fieldset_add_bytes(ProtoViewFieldSet *fs, const char *name, const uint8_t *bytes, uint32_t count); +void fieldset_add_float(ProtoViewFieldSet *fs, const char *name, float val, uint32_t digits_after_dot); +const char *field_get_type_name(ProtoViewField *f); +int field_to_string(char *buf, size_t len, ProtoViewField *f); +bool field_set_from_string(ProtoViewField *f, char *buf, size_t len); +bool field_incr_value(ProtoViewField *f, int incr); +void fieldset_copy_matching_fields(ProtoViewFieldSet *dst, ProtoViewFieldSet *src); +void field_set_from_field(ProtoViewField *dst, ProtoViewField *src); + /* crc.c */ uint8_t crc8(const uint8_t *data, size_t len, uint8_t init, uint8_t poly); diff --git a/applications/plugins/protoview/app_subghz.c b/applications/plugins/protoview/app_subghz.c index ec7724b13..55905e8a3 100644 --- a/applications/plugins/protoview/app_subghz.c +++ b/applications/plugins/protoview/app_subghz.c @@ -13,17 +13,19 @@ void raw_sampling_worker_start(ProtoViewApp *app); void raw_sampling_worker_stop(ProtoViewApp *app); ProtoViewModulation ProtoViewModulations[] = { - {"OOK 650Khz", FuriHalSubGhzPresetOok650Async, NULL}, - {"OOK 270Khz", FuriHalSubGhzPresetOok270Async, NULL}, - {"2FSK 2.38Khz", FuriHalSubGhzPreset2FSKDev238Async, NULL}, - {"2FSK 47.6Khz", FuriHalSubGhzPreset2FSKDev476Async, NULL}, - {"MSK", FuriHalSubGhzPresetMSK99_97KbAsync, NULL}, - {"GFSK", FuriHalSubGhzPresetGFSK9_99KbAsync, NULL}, - {"TPMS 1 (FSK)", 0, (uint8_t*)protoview_subghz_tpms1_fsk_async_regs}, - {"TPMS 2 (OOK)", 0, (uint8_t*)protoview_subghz_tpms2_ook_async_regs}, - {"TPMS 3 (FSK)", 0, (uint8_t*)protoview_subghz_tpms3_fsk_async_regs}, - {"TPMS 4 (FSK)", 0, (uint8_t*)protoview_subghz_tpms4_fsk_async_regs}, - {NULL, 0, NULL} /* End of list sentinel. */ + {"OOK 650Khz", "FuriHalSubGhzPresetOok650Async", + FuriHalSubGhzPresetOok650Async, NULL}, + {"OOK 270Khz", "FuriHalSubGhzPresetOok270Async", + FuriHalSubGhzPresetOok270Async, NULL}, + {"2FSK 2.38Khz", "FuriHalSubGhzPreset2FSKDev238Async", + FuriHalSubGhzPreset2FSKDev238Async, NULL}, + {"2FSK 47.6Khz", "FuriHalSubGhzPreset2FSKDev476Async", + FuriHalSubGhzPreset2FSKDev476Async, NULL}, + {"TPMS 1 (FSK)", NULL, 0, (uint8_t*)protoview_subghz_tpms1_fsk_async_regs}, + {"TPMS 2 (OOK)", NULL, 0, (uint8_t*)protoview_subghz_tpms2_ook_async_regs}, + {"TPMS 3 (FSK)", NULL, 0, (uint8_t*)protoview_subghz_tpms3_fsk_async_regs}, + {"TPMS 4 (FSK)", NULL, 0, (uint8_t*)protoview_subghz_tpms4_fsk_async_regs}, + {NULL, NULL, 0, NULL} /* End of list sentinel. */ }; /* Called after the application initialization in order to setup the @@ -35,17 +37,26 @@ void radio_begin(ProtoViewApp* app) { furi_hal_subghz_reset(); furi_hal_subghz_idle(); + /* Power circuits are noisy. Suppressing the charge while we use + * ProtoView will improve the RF performances. */ + furi_hal_power_suppress_charge_enter(); + /* The CC1101 preset can be either one of the standard presets, if * the modulation "custom" field is NULL, or a custom preset we * defined in custom_presets.h. */ - if (ProtoViewModulations[app->modulation].custom == NULL) - furi_hal_subghz_load_preset(ProtoViewModulations[app->modulation].preset); - else - furi_hal_subghz_load_custom_preset(ProtoViewModulations[app->modulation].custom); + if (ProtoViewModulations[app->modulation].custom == NULL) { + furi_hal_subghz_load_preset( + ProtoViewModulations[app->modulation].preset); + } else { + furi_hal_subghz_load_custom_preset( + ProtoViewModulations[app->modulation].custom); + } furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow); app->txrx->txrx_state = TxRxStateIDLE; } +/* ================================= Reception ============================== */ + /* Setup subghz to start receiving using a background worker. */ uint32_t radio_rx(ProtoViewApp* app) { furi_assert(app); @@ -76,6 +87,7 @@ uint32_t radio_rx(ProtoViewApp* app) { /* Stop subghz worker (if active), put radio on idle state. */ void radio_rx_end(ProtoViewApp* app) { furi_assert(app); + if (app->txrx->txrx_state == TxRxStateRx) { if (!app->txrx->debug_timer_sampling) { if(subghz_worker_is_running(app->txrx->worker)) { @@ -100,6 +112,33 @@ void radio_sleep(ProtoViewApp* app) { } furi_hal_subghz_sleep(); app->txrx->txrx_state = TxRxStateSleep; + furi_hal_power_suppress_charge_exit(); +} + +/* =============================== Transmission ============================= */ + +/* This function suspends the current RX state, switches to TX mode, + * transmits the signal provided by the callback data_feeder, and later + * restores the RX state if there was one. */ +void radio_tx_signal(ProtoViewApp *app, FuriHalSubGhzAsyncTxCallback data_feeder, void *ctx) { + TxRxState oldstate = app->txrx->txrx_state; + + if (oldstate == TxRxStateRx) radio_rx_end(app); + radio_begin(app); + + furi_hal_subghz_idle(); + uint32_t value = furi_hal_subghz_set_frequency_and_path(app->frequency); + FURI_LOG_E(TAG, "Switched to frequency: %lu", value); + furi_hal_gpio_write(&gpio_cc1101_g0, false); + furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow); + + furi_hal_subghz_start_async_tx(data_feeder, ctx); + while(!furi_hal_subghz_is_async_tx_complete()) furi_delay_ms(10); + furi_hal_subghz_stop_async_tx(); + furi_hal_subghz_idle(); + + radio_begin(app); + if (oldstate == TxRxStateRx) radio_rx(app); } /* ============================= Raw sampling mode ============================= diff --git a/applications/plugins/protoview/binaries/protoview.fap b/applications/plugins/protoview/binaries/protoview.fap index 696dc523e..77678f661 100644 Binary files a/applications/plugins/protoview/binaries/protoview.fap and b/applications/plugins/protoview/binaries/protoview.fap differ diff --git a/applications/plugins/protoview/custom_presets.h b/applications/plugins/protoview/custom_presets.h index 713827d22..cb9a421c6 100644 --- a/applications/plugins/protoview/custom_presets.h +++ b/applications/plugins/protoview/custom_presets.h @@ -104,6 +104,9 @@ static uint8_t protoview_subghz_tpms1_fsk_async_regs[][2] = { /* End */ {0, 0}, + + /* CC1101 2FSK PATABLE. */ + {0xC0, 0}, {0,0}, {0,0}, {0,0} }; /* This is like the default Flipper OOK 640Khz bandwidth preset, but @@ -125,8 +128,8 @@ static const uint8_t protoview_subghz_tpms2_ook_async_regs[][2] = { {CC1101_MDMCFG0, 0x00}, // Channel spacing is 25kHz {CC1101_MDMCFG1, 0x00}, // Channel spacing is 25kHz {CC1101_MDMCFG2, 0x30}, // Format ASK/OOK, No preamble/sync - {CC1101_MDMCFG3, 0x93}, // Data rate is 10kBaud - {CC1101_MDMCFG4, 0x18}, // Rx BW filter is 650.000kHz + {CC1101_MDMCFG3, /*0x93*/ 0x32}, // Data rate is 10kBaud + {CC1101_MDMCFG4, /*0x18*/ 0x17}, // Rx BW filter is 650.000kHz /* Main Radio Control State Machine */ {CC1101_MCSM0, 0x18}, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us) @@ -151,6 +154,9 @@ static const uint8_t protoview_subghz_tpms2_ook_async_regs[][2] = { /* End */ {0, 0}, + + /* CC1101 OOK PATABLE. */ + {0, 0xC0}, {0,0}, {0,0}, {0,0} }; /* 40 KBaud, 2FSK, 28 kHz deviation, 270 Khz bandwidth filter. */ @@ -196,6 +202,9 @@ static uint8_t protoview_subghz_tpms3_fsk_async_regs[][2] = { /* End */ {0, 0}, + + /* CC1101 2FSK PATABLE. */ + {0xC0, 0}, {0,0}, {0,0}, {0,0} }; /* FSK 19k dev, 325 Khz filter, 20kBaud. Works well with Toyota. */ @@ -239,6 +248,8 @@ static uint8_t protoview_subghz_tpms4_fsk_async_regs[][2] = { /* End */ {0, 0}, + + /* CC1101 2FSK PATABLE. */ + {0xC0, 0}, {0,0}, {0,0}, {0,0} }; - diff --git a/applications/plugins/protoview/data_feed.c b/applications/plugins/protoview/data_feed.c index c3387fc4c..a3bed238e 100644 --- a/applications/plugins/protoview/data_feed.c +++ b/applications/plugins/protoview/data_feed.c @@ -6,7 +6,7 @@ #include #include #include -#include "app_buffer.h" +#include "raw_samples.h" #define TAG "PROTOVIEW-protocol" diff --git a/applications/plugins/protoview/fields.c b/applications/plugins/protoview/fields.c new file mode 100644 index 000000000..bc62cda54 --- /dev/null +++ b/applications/plugins/protoview/fields.c @@ -0,0 +1,358 @@ +/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved + * See the LICENSE file for information about the license. + * + * Protocol fields implementation. */ + +#include "app.h" + +/* Create a new field of the specified type. Without populating its + * type-specific value. */ +static ProtoViewField *field_new(ProtoViewFieldType type, const char *name) { + ProtoViewField *f = malloc(sizeof(*f)); + f->type = type; + f->name = strdup(name); + return f; +} + +/* Free only the auxiliary data of a field, used to represent the + * current type. Name and type are not touched. */ +static void field_free_aux_data(ProtoViewField *f) { + switch(f->type) { + case FieldTypeStr: free(f->str); break; + case FieldTypeBytes: free(f->bytes); break; + default: break; // Nothing to free for other types. + } +} + +/* Free a field an associated data. */ +static void field_free(ProtoViewField *f) { + field_free_aux_data(f); + free(f->name); + free(f); +} + +/* Return the type of the field as string. */ +const char *field_get_type_name(ProtoViewField *f) { + switch(f->type) { + case FieldTypeStr: return "str"; + case FieldTypeSignedInt: return "int"; + case FieldTypeUnsignedInt: return "uint"; + case FieldTypeBinary: return "bin"; + case FieldTypeHex: return "hex"; + case FieldTypeBytes: return "bytes"; + case FieldTypeFloat: return "float"; + } + return "unknown"; +} + +/* Set a string representation of the specified field in buf. */ +int field_to_string(char *buf, size_t len, ProtoViewField *f) { + switch(f->type) { + case FieldTypeStr: + return snprintf(buf,len,"%s", f->str); + case FieldTypeSignedInt: + return snprintf(buf,len,"%lld", (long long) f->value); + case FieldTypeUnsignedInt: + return snprintf(buf,len,"%llu", (unsigned long long) f->uvalue); + case FieldTypeBinary: + { + uint64_t test_bit = (1 << (f->len-1)); + uint64_t idx = 0; + while(idx < len-1 && test_bit) { + buf[idx++] = (f->uvalue & test_bit) ? '1' : '0'; + test_bit >>= 1; + } + buf[idx] = 0; + return idx; + } + case FieldTypeHex: + return snprintf(buf, len, "%*llX", (int)(f->len+7)/8, f->uvalue); + case FieldTypeFloat: + return snprintf(buf, len, "%.*f", (int)f->len, (double)f->fvalue); + case FieldTypeBytes: + { + uint64_t idx = 0; + while(idx < len-1 && idx < f->len) { + const char *charset = "0123456789ABCDEF"; + uint32_t nibble = idx & 1 ? + (f->bytes[idx/2] & 0xf) : + (f->bytes[idx/2] >> 4); + buf[idx++] = charset[nibble]; + } + buf[idx] = 0; + return idx; + } + } + return 0; +} + +/* Set the field value from its string representation in 'buf'. + * The field type must already be set and the field should be valid. + * The string represenation 'buf' must be null termianted. Note that + * even when representing binary values containing zero, this values + * are taken as representations, so that would be the string "00" as + * the Bytes type representation. + * + * The function returns true if the filed was successfully set to the + * new value, otherwise if the specified value is invalid for the + * field type, false is returned. */ +bool field_set_from_string(ProtoViewField *f, char *buf, size_t len) { + // Initialize values to zero since the Flipper sscanf() implementation + // is fuzzy... may populate only part of the value. + long long val = 0; + unsigned long long uval = 0; + float fval = 0; + + switch(f->type) { + case FieldTypeStr: + free(f->str); + f->len = len; + f->str = malloc(len+1); + memcpy(f->str,buf,len+1); + break; + case FieldTypeSignedInt: + if (!sscanf(buf,"%lld",&val)) return false; + f->value = val; + break; + case FieldTypeUnsignedInt: + if (!sscanf(buf,"%llu",&uval)) return false; + f->uvalue = uval; + break; + case FieldTypeBinary: + { + uint64_t bit_to_set = (1 << (len-1)); + uint64_t idx = 0; + uval = 0; + while(buf[idx]) { + if (buf[idx] == '1') uval |= bit_to_set; + else if (buf[idx] != '0') return false; + bit_to_set >>= 1; + idx++; + } + f->uvalue = uval; + } + break; + case FieldTypeHex: + if (!sscanf(buf,"%llx",&uval) && + !sscanf(buf,"%llX",&uval)) return false; + f->uvalue = uval; + break; + case FieldTypeFloat: + if (!sscanf(buf,"%f",&fval)) return false; + f->fvalue = fval; + break; + case FieldTypeBytes: + { + if (len > f->len) return false; + uint64_t idx = 0; + while(buf[idx]) { + uint8_t nibble = 0; + char c = toupper(buf[idx]); + if (c >= '0' && c <= '9') nibble = c-'0'; + else if (c >= 'A' && c <= 'F') nibble = 10+(c-'A'); + else return false; + + if (idx & 1) { + f->bytes[idx/2] = + (f->bytes[idx/2] & 0xF0) | nibble; + } else { + f->bytes[idx/2] = + (f->bytes[idx/2] & 0x0F) | (nibble<<4); + } + idx++; + } + buf[idx] = 0; + } + break; + } + return true; +} + +/* Set the 'dst' field to contain a copy of the value of the 'src' + * field. The field name is not modified. */ +void field_set_from_field(ProtoViewField *dst, ProtoViewField *src) { + field_free_aux_data(dst); + dst->type = src->type; + dst->len = src->len; + switch(src->type) { + case FieldTypeStr: + dst->str = strdup(src->str); + break; + case FieldTypeBytes: + dst->bytes = malloc(src->len); + memcpy(dst->bytes,src->bytes,dst->len); + break; + case FieldTypeSignedInt: + dst->value = src->value; + break; + case FieldTypeUnsignedInt: + case FieldTypeBinary: + case FieldTypeHex: + dst->uvalue = src->uvalue; + break; + case FieldTypeFloat: + dst->fvalue = src->fvalue; + break; + } +} + +/* Increment the specified field value of 'incr'. If the field type + * does not support increments false is returned, otherwise the + * action is performed. */ +bool field_incr_value(ProtoViewField *f, int incr) { + switch(f->type) { + case FieldTypeStr: return false; + case FieldTypeSignedInt: { + /* Wrap around depending on the number of bits (f->len) + * the integer was declared to have. */ + int64_t max = (1ULL << (f->len-1))-1; + int64_t min = -max-1; + int64_t v = (int64_t)f->value + incr; + if (v > max) v = min+(v-max-1); + if (v < min) v = max+(v-min+1); + f->value = v; + break; + } + case FieldTypeBinary: + case FieldTypeHex: + case FieldTypeUnsignedInt: { + /* Wrap around like for the unsigned case, but here + * is simpler. */ + uint64_t max = (1ULL << f->len)-1; // Broken for 64 bits. + uint64_t uv = (uint64_t)f->value + incr; + if (uv > max) uv = uv & max; + f->uvalue = uv; + break; + } + case FieldTypeFloat: + f->fvalue += incr; + break; + case FieldTypeBytes: { + // For bytes we only support single unit increments. + if (incr != -1 && incr != 1) return false; + for (int j = f->len-1; j >= 0; j--) { + uint8_t nibble = (j&1) ? (f->bytes[j/2] & 0x0F) : + ((f->bytes[j/2] & 0xF0) >> 4); + + nibble += incr; + nibble &= 0x0F; + + f->bytes[j/2] = (j&1) ? ((f->bytes[j/2] & 0xF0) | nibble) : + ((f->bytes[j/2] & 0x0F) | (nibble<<4)); + + /* Propagate the operation on overflow of this nibble. */ + if ((incr == 1 && nibble == 0) || + (incr == -1 && nibble == 0xf)) + { + continue; + } + break; // Otherwise stop the loop here. + } + break; + } + } + return true; +} + + +/* Free a field set and its contained fields. */ +void fieldset_free(ProtoViewFieldSet *fs) { + for (uint32_t j = 0; j < fs->numfields; j++) + field_free(fs->fields[j]); + free(fs->fields); + free(fs); +} + +/* Allocate and init an empty field set. */ +ProtoViewFieldSet *fieldset_new(void) { + ProtoViewFieldSet *fs = malloc(sizeof(*fs)); + fs->numfields = 0; + fs->fields = NULL; + return fs; +} + +/* Append an already allocated field at the end of the specified field set. */ +static void fieldset_add_field(ProtoViewFieldSet *fs, ProtoViewField *field) { + fs->numfields++; + fs->fields = realloc(fs->fields,sizeof(ProtoViewField*)*fs->numfields); + fs->fields[fs->numfields-1] = field; +} + +/* Allocate and append an integer field. */ +void fieldset_add_int(ProtoViewFieldSet *fs, const char *name, int64_t val, uint8_t bits) { + ProtoViewField *f = field_new(FieldTypeSignedInt,name); + f->value = val; + f->len = bits; + fieldset_add_field(fs,f); +} + +/* Allocate and append an unsigned field. */ +void fieldset_add_uint(ProtoViewFieldSet *fs, const char *name, uint64_t uval, uint8_t bits) { + ProtoViewField *f = field_new(FieldTypeUnsignedInt,name); + f->uvalue = uval; + f->len = bits; + fieldset_add_field(fs,f); +} + +/* Allocate and append a hex field. This is an unsigned number but + * with an hex representation. */ +void fieldset_add_hex(ProtoViewFieldSet *fs, const char *name, uint64_t uval, uint8_t bits) { + ProtoViewField *f = field_new(FieldTypeHex,name); + f->uvalue = uval; + f->len = bits; + fieldset_add_field(fs,f); +} + +/* Allocate and append a bin field. This is an unsigned number but + * with a binary representation. */ +void fieldset_add_bin(ProtoViewFieldSet *fs, const char *name, uint64_t uval, uint8_t bits) { + ProtoViewField *f = field_new(FieldTypeBinary,name); + f->uvalue = uval; + f->len = bits; + fieldset_add_field(fs,f); +} + +/* Allocate and append a string field. */ +void fieldset_add_str(ProtoViewFieldSet *fs, const char *name, const char *s) { + ProtoViewField *f = field_new(FieldTypeStr,name); + f->str = strdup(s); + f->len = strlen(s); + fieldset_add_field(fs,f); +} + +/* Allocate and append a bytes field. Note that 'count' is specified in + * nibbles (bytes*2). */ +void fieldset_add_bytes(ProtoViewFieldSet *fs, const char *name, const uint8_t *bytes, uint32_t count_nibbles) { + uint32_t numbytes = (count_nibbles+count_nibbles%2)/2; + ProtoViewField *f = field_new(FieldTypeBytes,name); + f->bytes = malloc(numbytes); + memcpy(f->bytes,bytes,numbytes); + f->len = count_nibbles; + fieldset_add_field(fs,f); +} + +/* Allocate and append a float field. */ +void fieldset_add_float(ProtoViewFieldSet *fs, const char *name, float val, uint32_t digits_after_dot) { + ProtoViewField *f = field_new(FieldTypeFloat,name); + f->fvalue = val; + f->len = digits_after_dot; + fieldset_add_field(fs,f); +} + +/* For each field of the destination filedset 'dst', look for a matching + * field name/type in the source fieldset 'src', and if one is found copy + * its value into the 'dst' field. */ +void fieldset_copy_matching_fields(ProtoViewFieldSet *dst, + ProtoViewFieldSet *src) +{ + for (uint32_t j = 0; j < dst->numfields; j++) { + for (uint32_t i = 0; i < src->numfields; i++) { + if (dst->fields[j]->type == src->fields[i]->type && + !strcmp(dst->fields[j]->name,src->fields[i]->name)) + { + field_set_from_field(dst->fields[j], + src->fields[i]); + } + } + } +} diff --git a/applications/plugins/protoview/protocols/b4b1.c b/applications/plugins/protoview/protocols/b4b1.c index 2bed2ac32..7308d1211 100644 --- a/applications/plugins/protoview/protocols/b4b1.c +++ b/applications/plugins/protoview/protocols/b4b1.c @@ -25,6 +25,9 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView } if (off == BITMAP_SEEK_NOT_FOUND) return false; if (DEBUG_MSG) FURI_LOG_E(TAG, "B4B1 preamble at: %lu",off); + info->start_off = off; + + // Seek data setction. Why -1? Last bit is data. off += strlen(sync_patterns[j])-1; uint8_t d[3]; /* 24 bits of data. */ @@ -32,13 +35,54 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView convert_from_line_code(d,sizeof(d),bits,numbytes,off,"1000","1110"); if (DEBUG_MSG) FURI_LOG_E(TAG, "B4B1 decoded: %lu",decoded); - if (decoded != 24) return false; - snprintf(info->name,PROTOVIEW_MSG_STR_LEN,"PT/SC remote"); - snprintf(info->raw,PROTOVIEW_MSG_STR_LEN,"%02X%02X%02X",d[0],d[1],d[2]); - info->len = off+(4*24); + if (decoded < 24) return false; + + off += 24*4; // seek to end symbol offset to calculate the length. + off++; // In this protocol there is a final pulse as terminator. + info->pulses_count = off - info->start_off; + + fieldset_add_bytes(info->fieldset,"id",d,5); + fieldset_add_uint(info->fieldset,"button",d[2]&0xf,4); return true; } +/* Give fields and defaults for the signal creator. */ +static void get_fields(ProtoViewFieldSet *fieldset) { + uint8_t default_id[3]= {0xAB, 0xCD, 0xE0}; + fieldset_add_bytes(fieldset,"id",default_id,5); + fieldset_add_uint(fieldset,"button",1,4); +} + +/* Create a signal. */ +static void build_message(RawSamplesBuffer *samples, ProtoViewFieldSet *fs) +{ + uint32_t te = 334; // Short pulse duration in microseconds. + + // Sync: 1 te pulse, 31 te gap. + raw_samples_add(samples,true,te); + raw_samples_add(samples,false,te*31); + + // ID + button state + uint8_t data[3]; + memcpy(data,fs->fields[0]->bytes,3); + data[2] = (data[2]&0xF0) | (fs->fields[1]->uvalue & 0xF); + for (uint32_t j = 0; j < 24; j++) { + if (bitmap_get(data,sizeof(data),j)) { + raw_samples_add(samples,true,te*3); + raw_samples_add(samples,false,te); + } else { + raw_samples_add(samples,true,te); + raw_samples_add(samples,false,te*3); + } + } + + // Signal terminator. Just a single short pulse. + raw_samples_add(samples,true,te); +} + ProtoViewDecoder B4B1Decoder = { - "B4B1", decode + .name = "PT/SC remote", + .decode = decode, + .get_fields = get_fields, + .build_message = build_message }; diff --git a/applications/plugins/protoview/protocols/keeloq.c b/applications/plugins/protoview/protocols/keeloq.c index cf0b7682f..0741eac47 100644 --- a/applications/plugins/protoview/protocols/keeloq.c +++ b/applications/plugins/protoview/protocols/keeloq.c @@ -32,9 +32,11 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView const char *sync_pattern = "101010101010101010101010" "0000"; uint8_t sync_len = 24+4; if (numbits-sync_len+sync_len < 3*66) return false; - uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern); + uint32_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern); if (off == BITMAP_SEEK_NOT_FOUND) return false; - off += sync_len; + + info->start_off = off; + off += sync_len; // Seek start of message. /* Now there is half the gap left, but we allow from 3 to 7, instead of 5 * symbols of gap, to avoid missing the signal for a matter of wrong @@ -52,36 +54,72 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView convert_from_line_code(raw,sizeof(raw),bits,numbytes,off, "110","100"); /* Pulse width modulation. */ FURI_LOG_E(TAG, "Keeloq decoded bits: %lu", decoded); - if (decoded < 66) return false; /* Require the full 66 bits. */ - bitmap_reverse_bytes(raw,sizeof(raw)); /* Keeloq is LSB first. */ + + info->pulses_count = (off+66*3) - info->start_off; + + bitmap_reverse_bytes_bits(raw,sizeof(raw)); /* Keeloq is LSB first. */ int buttons = raw[7]>>4; - int s3 = (buttons&1) != 0; - int s0 = (buttons&2) != 0; - int s1 = (buttons&4) != 0; - int s2 = (buttons&8) != 0; + int lowbat = (raw[8]&0x1) == 0; // Actual bit meaning: good battery level + int alwaysone = (raw[8]&0x2) != 0; - int remote_id = ((raw[7]&0x0f) << 24) | - (raw[6] << 16) | - (raw[5] << 8) | - (raw[4] << 0); - int lowbat = raw[8]&0x80; - - snprintf(info->name,sizeof(info->name),"%s","Keeloq remote"); - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7],raw[8]); - snprintf(info->info1,sizeof(info->info1),"Encrpyted %02X%02X%02X%02X", - raw[3],raw[2],raw[1],raw[0]); - snprintf(info->info2,sizeof(info->info2),"ID %08X", remote_id); - snprintf(info->info3,sizeof(info->info3),"s0-s3: %d%d%d%d", - s0,s1,s2,s3); - snprintf(info->info4,sizeof(info->info4),"Low battery? %s", - lowbat ? "yes" : "no"); + fieldset_add_bytes(info->fieldset,"encr",raw,8); + raw[7] = raw[7]<<4; // Make ID bits contiguous + fieldset_add_bytes(info->fieldset,"id",raw+4,7); // 28 bits, 7 nibbles + fieldset_add_bin(info->fieldset,"s[2,1,0,3]",buttons,4); + fieldset_add_bin(info->fieldset,"low battery",lowbat,1); + fieldset_add_bin(info->fieldset,"always one",alwaysone,1); return true; } +static void get_fields(ProtoViewFieldSet *fieldset) { + uint8_t remote_id[4] = {0xab, 0xcd, 0xef, 0xa0}; + uint8_t encr[4] = {0xab, 0xab, 0xab, 0xab}; + fieldset_add_bytes(fieldset,"encr",encr,8); + fieldset_add_bytes(fieldset,"id",remote_id,7); + fieldset_add_bin(fieldset,"s[2,1,0,3]",2,4); + fieldset_add_bin(fieldset,"low battery",0,1); + fieldset_add_bin(fieldset,"always one",1,1); +} + +static void build_message(RawSamplesBuffer *samples, ProtoViewFieldSet *fieldset) +{ + uint32_t te = 380; // Short pulse duration in microseconds. + + // Sync: 12 pairs of pulse/gap + 9 times gap + for (int j = 0; j < 12; j++) { + raw_samples_add(samples,true,te); + raw_samples_add(samples,false,te); + } + raw_samples_add(samples,false,te*9); + + // Data, 66 bits. + uint8_t data[9] = {0}; + memcpy(data,fieldset->fields[0]->bytes,4); // Encrypted part. + memcpy(data+4,fieldset->fields[1]->bytes,4); // ID. + data[7] = data[7]>>4 | fieldset->fields[2]->uvalue << 4; // s[2,1,0,3] + int low_battery = fieldset->fields[3] != 0; + int always_one = fieldset->fields[4] != 0; + low_battery = !low_battery; // Bit real meaning is good battery level. + data[8] |= low_battery; + data[8] |= (always_one << 1); + bitmap_reverse_bytes_bits(data,sizeof(data)); /* Keeloq is LSB first. */ + + for (int j = 0; j < 66; j++) { + if (bitmap_get(data,9,j)) { + raw_samples_add(samples,true,te); + raw_samples_add(samples,false,te*2); + } else { + raw_samples_add(samples,true,te*2); + raw_samples_add(samples,false,te); + } + } +} + ProtoViewDecoder KeeloqDecoder = { - "Keeloq", decode + .name = "Keeloq", + .decode = decode, + .get_fields = get_fields, + .build_message = build_message }; diff --git a/applications/plugins/protoview/protocols/oregon2.c b/applications/plugins/protoview/protocols/oregon2.c index 3aa57c72d..1d909a504 100644 --- a/applications/plugins/protoview/protocols/oregon2.c +++ b/applications/plugins/protoview/protocols/oregon2.c @@ -13,6 +13,7 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (off == BITMAP_SEEK_NOT_FOUND) return false; FURI_LOG_E(TAG, "Oregon2 preamble+sync found"); + info->start_off = off; off += 32; /* Skip preamble. */ uint8_t buffer[8], raw[8] = {0}; @@ -21,8 +22,10 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView FURI_LOG_E(TAG, "Oregon2 decoded bits: %lu", decoded); if (decoded < 11*4) return false; /* Minimum len to extract some data. */ + info->pulses_count = (off+11*4*4) - info->start_off; - char temp[3] = {0}, deviceid[2] = {0}, hum[2] = {0}; + char temp[3] = {0}, hum[2] = {0}; + uint8_t deviceid[2]; for (int j = 0; j < 64; j += 4) { uint8_t nib[1]; nib[0] = (bitmap_get(buffer,8,j+0) | @@ -45,21 +48,20 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView } } - snprintf(info->name,sizeof(info->name),"%s","Oregon v2.1"); - /* The following line crashes the Flipper because of broken - * snprintf() implementation. */ - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7]); - snprintf(info->info1,sizeof(info->info1),"Sensor ID %02X%02X", - deviceid[0], deviceid[1]); - snprintf(info->info2,sizeof(info->info2),"Temperature %d%d.%d", - temp[0],temp[1],temp[2]); - snprintf(info->info3,sizeof(info->info3),"Humidity %d%d", - hum[0],hum[1]); + float tempval = ((temp[0]-'0')*10) + + (temp[1]-'0') + + ((float)(temp[2]-'0')*0.1); + int humval = (hum[0]-'0')*10 + (hum[1]-'0'); + + fieldset_add_bytes(info->fieldset,"Sensor ID",deviceid,4); + fieldset_add_float(info->fieldset,"Temperature",tempval,1); + fieldset_add_uint(info->fieldset,"Humidity",humval,7); return true; } ProtoViewDecoder Oregon2Decoder = { - "Oregon2", decode + .name = "Oregon2", + .decode = decode, + .get_fields = NULL, + .build_message = NULL }; diff --git a/applications/plugins/protoview/protocols/tpms/citroen.c b/applications/plugins/protoview/protocols/tpms/citroen.c index 809dc0a25..d8a1681e4 100644 --- a/applications/plugins/protoview/protocols/tpms/citroen.c +++ b/applications/plugins/protoview/protocols/tpms/citroen.c @@ -20,6 +20,7 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (off == BITMAP_SEEK_NOT_FOUND) return false; FURI_LOG_E(TAG, "Renault TPMS preamble+sync found"); + info->start_off = off; off += sync_len; /* Skip preamble + sync. */ uint8_t raw[10]; @@ -37,24 +38,24 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView for (int j = 1; j < 10; j++) crc ^= raw[j]; if (crc != 0) return false; /* Require sane checksum. */ + info->pulses_count = (off+8*10*2) - info->start_off; + int repeat = raw[5] & 0xf; float kpa = (float)raw[6]*1.364; int temp = raw[7]-50; int battery = raw[8]; /* This may be the battery. It's not clear. */ - snprintf(info->name,sizeof(info->name),"%s","Citroen TPMS"); - snprintf(info->raw,sizeof(info->raw), - "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7],raw[8],raw[9]); - snprintf(info->info1,sizeof(info->info1),"Tire ID %02X%02X%02X%02X", - raw[1],raw[2],raw[3],raw[4]); - snprintf(info->info2,sizeof(info->info2),"Pressure %.2f kpa", (double)kpa); - snprintf(info->info3,sizeof(info->info3),"Temperature %d C", temp); - snprintf(info->info4,sizeof(info->info4),"Repeat %d, Bat %d", repeat, battery); + fieldset_add_bytes(info->fieldset,"Tire ID",raw+1,4*2); + fieldset_add_float(info->fieldset,"Pressure kpa",kpa,2); + fieldset_add_int(info->fieldset,"Temperature C",temp,8); + fieldset_add_uint(info->fieldset,"Repeat",repeat,4); + fieldset_add_uint(info->fieldset,"Battery",battery,8); return true; } ProtoViewDecoder CitroenTPMSDecoder = { - "Citroen TPMS", decode + .name = "Citroen TPMS", + .decode = decode, + .get_fields = NULL, + .build_message = NULL }; diff --git a/applications/plugins/protoview/protocols/tpms/ford.c b/applications/plugins/protoview/protocols/tpms/ford.c index a9c687075..abdb692ee 100644 --- a/applications/plugins/protoview/protocols/tpms/ford.c +++ b/applications/plugins/protoview/protocols/tpms/ford.c @@ -20,6 +20,7 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (off == BITMAP_SEEK_NOT_FOUND) return false; FURI_LOG_E(TAG, "Fort TPMS preamble+sync found"); + info->start_off = off; off += sync_len; /* Skip preamble and sync. */ uint8_t raw[8]; @@ -35,6 +36,8 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView for (int j = 0; j < 7; j++) crc += raw[j]; if (crc != raw[7]) return false; /* Require sane CRC. */ + info->pulses_count = (off+8*8*2) - info->start_off; + float psi = 0.25 * (((raw[6]&0x20)<<3)|raw[4]); /* Temperature apperas to be valid only if the most significant @@ -44,21 +47,17 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView int flags = raw[5] & 0x7f; int car_moving = (raw[6] & 0x44) == 0x44; - snprintf(info->name,sizeof(info->name),"%s","Ford TPMS"); - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7]); - snprintf(info->info1,sizeof(info->info1),"Tire ID %02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3]); - snprintf(info->info2,sizeof(info->info2),"Pressure %.2f psi", (double)psi); - if (temp) - snprintf(info->info3,sizeof(info->info3),"Temperature %d C", temp); - else - snprintf(info->info3,sizeof(info->info3),"Flags %d", flags); - snprintf(info->info4,sizeof(info->info4),"Moving %s", car_moving ? "yes" : "no"); + fieldset_add_bytes(info->fieldset,"Tire ID",raw,4*2); + fieldset_add_float(info->fieldset,"Pressure psi",psi,2); + fieldset_add_int(info->fieldset,"Temperature C",temp,8); + fieldset_add_hex(info->fieldset,"Flags",flags,7); + fieldset_add_uint(info->fieldset,"Moving",car_moving,1); return true; } ProtoViewDecoder FordTPMSDecoder = { - "Ford TPMS", decode + .name = "Ford TPMS", + .decode = decode, + .get_fields = NULL, + .build_message = NULL }; diff --git a/applications/plugins/protoview/protocols/tpms/renault.c b/applications/plugins/protoview/protocols/tpms/renault.c index 4bbe55e42..09de77d17 100644 --- a/applications/plugins/protoview/protocols/tpms/renault.c +++ b/applications/plugins/protoview/protocols/tpms/renault.c @@ -25,7 +25,7 @@ static const char *test_vector = static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) { if (USE_TEST_VECTOR) { /* Test vector to check that decoding works. */ - bitmap_set_pattern(bits,numbytes,test_vector); + bitmap_set_pattern(bits,numbytes,0,test_vector); numbits = strlen(test_vector); } @@ -36,6 +36,7 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (off == BITMAP_SEEK_NOT_FOUND) return false; FURI_LOG_E(TAG, "Renault TPMS preamble+sync found"); + info->start_off = off; off += 20; /* Skip preamble. */ uint8_t raw[9]; @@ -47,20 +48,73 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (decoded < 8*9) return false; /* Require the full 9 bytes. */ if (crc8(raw,8,0,7) != raw[8]) return false; /* Require sane CRC. */ - float kpa = 0.75 *((uint32_t)((raw[0]&3)<<8) | raw[1]); + info->pulses_count = (off+8*9*2) - info->start_off; + + uint8_t flags = raw[0]>>2; + float kpa = 0.75 * ((uint32_t)((raw[0]&3)<<8) | raw[1]); int temp = raw[2]-30; - snprintf(info->name,sizeof(info->name),"%s","Renault TPMS"); - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7],raw[8]); - snprintf(info->info1,sizeof(info->info1),"Tire ID %02X%02X%02X", - raw[3],raw[4],raw[5]); - snprintf(info->info2,sizeof(info->info2),"Pressure %.2f kpa", (double)kpa); - snprintf(info->info3,sizeof(info->info3),"Temperature %d C", temp); + fieldset_add_bytes(info->fieldset,"Tire ID",raw+3,3*2); + fieldset_add_float(info->fieldset,"Pressure kpa",kpa,2); + fieldset_add_int(info->fieldset,"Temperature C",temp,8); + fieldset_add_hex(info->fieldset,"Flags",flags,6); + fieldset_add_bytes(info->fieldset,"Unknown1",raw+6,2); + fieldset_add_bytes(info->fieldset,"Unknown2",raw+7,2); return true; } +/* Give fields and defaults for the signal creator. */ +static void get_fields(ProtoViewFieldSet *fieldset) { + uint8_t default_id[3]= {0xAB, 0xCD, 0xEF}; + fieldset_add_bytes(fieldset,"Tire ID",default_id,3*2); + fieldset_add_float(fieldset,"Pressure kpa",123,2); + fieldset_add_int(fieldset,"Temperature C",20,8); + // We don't know what flags are, but 1B is a common value. + fieldset_add_hex(fieldset,"Flags",0x1b,6); + fieldset_add_bytes(fieldset,"Unknown1",(uint8_t*)"\xff",2); + fieldset_add_bytes(fieldset,"Unknown2",(uint8_t*)"\xff",2); +} + +/* Create a Renault TPMS signal, according to the fields provided. */ +static void build_message(RawSamplesBuffer *samples, ProtoViewFieldSet *fieldset) +{ + uint32_t te = 50; // Short pulse duration in microseconds. + + // Preamble + sync + const char *psync = "01010101010101010101010101010110"; + const char *p = psync; + while(*p) { + raw_samples_add_or_update(samples,*p == '1',te); + p++; + } + + // Data, 9 bytes + uint8_t data[9] = {0}; + unsigned int raw_pressure = fieldset->fields[1]->fvalue * 4 / 3; + data[0] = fieldset->fields[3]->uvalue << 2; // Flags + data[0] |= (raw_pressure >> 8) & 3; // Pressure kpa high 2 bits + data[1] = raw_pressure & 0xff; // Pressure kpa low 8 bits + data[2] = fieldset->fields[2]->value + 30; // Temperature C + memcpy(data+3,fieldset->fields[0]->bytes,6); // ID, 24 bits. + data[6] = fieldset->fields[4]->bytes[0]; // Unknown 1 + data[7] = fieldset->fields[5]->bytes[0]; // Unknown 2 + data[8] = crc8(data,8,0,7); + + // Generate Manchester code for each bit + for (uint32_t j = 0; j < 9*8; j++) { + if (bitmap_get(data,sizeof(data),j)) { + raw_samples_add_or_update(samples,true,te); + raw_samples_add_or_update(samples,false,te); + } else { + raw_samples_add_or_update(samples,false,te); + raw_samples_add_or_update(samples,true,te); + } + } +} + ProtoViewDecoder RenaultTPMSDecoder = { - "Renault TPMS", decode + .name = "Renault TPMS", + .decode = decode, + .get_fields = get_fields, + .build_message = build_message }; diff --git a/applications/plugins/protoview/protocols/tpms/schrader.c b/applications/plugins/protoview/protocols/tpms/schrader.c index ab65a92d3..ae25e39bb 100644 --- a/applications/plugins/protoview/protocols/tpms/schrader.c +++ b/applications/plugins/protoview/protocols/tpms/schrader.c @@ -16,7 +16,7 @@ static const char *test_vector = "0000001111010101010110100101100101101010010101 static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) { if (USE_TEST_VECTOR) { /* Test vector to check that decoding works. */ - bitmap_set_pattern(bits,numbytes,test_vector); + bitmap_set_pattern(bits,numbytes,0,test_vector); numbits = strlen(test_vector); } @@ -27,11 +27,13 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (off == BITMAP_SEEK_NOT_FOUND) return false; FURI_LOG_E(TAG, "Schrader TPMS gap+preamble found"); + info->start_off = off; off += 10; /* Skip just the long pulse and the first 3 bits of sync, so that we have the first byte of data with the sync nibble 0011 = 0x3. */ uint8_t raw[8]; + uint8_t id[4]; uint32_t decoded = convert_from_line_code(raw,sizeof(raw),bits,numbytes,off, "01","10"); /* Manchester code. */ @@ -46,20 +48,24 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView return false; } + info->pulses_count = (off+8*8*2) - info->start_off; + float kpa = (float)raw[5]*2.5; int temp = raw[6]-50; + id[0] = raw[1]&7; + id[1] = raw[2]; + id[2] = raw[3]; + id[3] = raw[4]; - snprintf(info->name,sizeof(info->name),"%s","Schrader TPMS"); - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7]); - snprintf(info->info1,sizeof(info->info1),"Tire ID %01X%02X%02X%02X", - raw[1]&7,raw[2],raw[3],raw[4]); /* Only 28 bits of ID, not 32. */ - snprintf(info->info2,sizeof(info->info2),"Pressure %.2f kpa", (double)kpa); - snprintf(info->info3,sizeof(info->info3),"Temperature %d C", temp); + fieldset_add_bytes(info->fieldset,"Tire ID",id,4*2); + fieldset_add_float(info->fieldset,"Pressure kpa",kpa,2); + fieldset_add_int(info->fieldset,"Temperature C",temp,8); return true; } ProtoViewDecoder SchraderTPMSDecoder = { - "Schrader TPMS", decode + .name = "Schrader TPMS", + .decode = decode, + .get_fields = NULL, + .build_message = NULL }; diff --git a/applications/plugins/protoview/protocols/tpms/schrader_eg53ma4.c b/applications/plugins/protoview/protocols/tpms/schrader_eg53ma4.c index 6fce40d64..0105010bd 100644 --- a/applications/plugins/protoview/protocols/tpms/schrader_eg53ma4.c +++ b/applications/plugins/protoview/protocols/tpms/schrader_eg53ma4.c @@ -25,6 +25,7 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (off == BITMAP_SEEK_NOT_FOUND) return false; FURI_LOG_E(TAG, "Schrader EG53MA4 TPMS preamble+sync found"); + info->start_off = off; off += sync_len-8; /* Skip preamble, not sync that is part of the data. */ uint8_t raw[10]; @@ -40,6 +41,8 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView for (int j = 0; j < 9; j++) crc += raw[j]; if (crc != raw[9]) return false; /* Require sane CRC. */ + info->pulses_count = (off+10*8*2) - info->start_off; + /* To convert the raw pressure to kPa, RTL433 uses 2.5, but is likely * wrong. Searching on Google for users experimenting with the value * reported, the value appears to be 2.75. */ @@ -47,17 +50,15 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView int temp_f = raw[8]; int temp_c = (temp_f-32)*5/9; /* Convert Fahrenheit to Celsius. */ - snprintf(info->name,sizeof(info->name),"%s","Schrader EG53MA4 TPMS"); - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7],raw[8],raw[9]); - snprintf(info->info1,sizeof(info->info1),"Tire ID %02X%02X%02X", - raw[4],raw[5],raw[6]); /* Only 28 bits of ID, not 32. */ - snprintf(info->info2,sizeof(info->info2),"Pressure %.2f kpa", (double)kpa); - snprintf(info->info3,sizeof(info->info3),"Temperature %d C", temp_c); + fieldset_add_bytes(info->fieldset,"Tire ID",raw+4,3*2); + fieldset_add_float(info->fieldset,"Pressure kpa",kpa,2); + fieldset_add_int(info->fieldset,"Temperature C",temp_c,8); return true; } ProtoViewDecoder SchraderEG53MA4TPMSDecoder = { - "Schrader EG53MA4 TPMS", decode + .name = "Schrader EG53MA4 TPMS", + .decode = decode, + .get_fields = NULL, + .build_message = NULL }; diff --git a/applications/plugins/protoview/protocols/tpms/toyota.c b/applications/plugins/protoview/protocols/tpms/toyota.c index b27353739..b9dd1d959 100644 --- a/applications/plugins/protoview/protocols/tpms/toyota.c +++ b/applications/plugins/protoview/protocols/tpms/toyota.c @@ -42,6 +42,7 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView for (j = 0; sync[j]; j++) { off = bitmap_seek_bits(bits,numbytes,0,numbits,sync[j]); if (off != BITMAP_SEEK_NOT_FOUND) { + info->start_off = off; off += strlen(sync[j])-2; break; } @@ -58,20 +59,31 @@ static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoView if (decoded < 8*9) return false; /* Require the full 8 bytes. */ if (crc8(raw,8,0x80,7) != raw[8]) return false; /* Require sane CRC. */ - float kpa = (float)((raw[4]&0x7f)<<1 | raw[5]>>7) * 0.25 - 7; + /* We detected a valid signal. However now info->start_off is actually + * pointing to the sync part, not the preamble of alternating 0 and 1. + * Protoview decoders get called with some space to the left, in order + * for the decoder itself to fix the signal if neeeded, so that its + * logical representation will be more accurate and better to save + * and retransmit. */ + if (info->start_off >= 12) { + info->start_off -= 12; + bitmap_set_pattern(bits,numbytes,info->start_off,"010101010101"); + } + + info->pulses_count = (off+8*9*2) - info->start_off; + + float psi = (float)((raw[4]&0x7f)<<1 | raw[5]>>7) * 0.25 - 7; int temp = ((raw[5]&0x7f)<<1 | raw[6]>>7) - 40; - snprintf(info->name,sizeof(info->name),"%s","Toyota TPMS"); - snprintf(info->raw,sizeof(info->raw),"%02X%02X%02X%02X%02X%02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3],raw[4],raw[5], - raw[6],raw[7],raw[8]); - snprintf(info->info1,sizeof(info->info1),"Tire ID %02X%02X%02X%02X", - raw[0],raw[1],raw[2],raw[3]); - snprintf(info->info1,sizeof(info->info1),"Pressure %.2f psi", (double)kpa); - snprintf(info->info2,sizeof(info->info2),"Temperature %d C", temp); + fieldset_add_bytes(info->fieldset,"Tire ID",raw,4*2); + fieldset_add_float(info->fieldset,"Pressure psi",psi,2); + fieldset_add_int(info->fieldset,"Temperature C",temp,8); return true; } ProtoViewDecoder ToyotaTPMSDecoder = { - "Toyota TPMS", decode + .name = "Toyota TPMS", + .decode = decode, + .get_fields = NULL, + .build_message = NULL }; diff --git a/applications/plugins/protoview/app_buffer.c b/applications/plugins/protoview/raw_samples.c similarity index 70% rename from applications/plugins/protoview/app_buffer.c rename to applications/plugins/protoview/raw_samples.c index 7c069fd91..f83cca361 100644 --- a/applications/plugins/protoview/app_buffer.c +++ b/applications/plugins/protoview/raw_samples.c @@ -5,7 +5,7 @@ #include #include #include -#include "app_buffer.h" +#include "raw_samples.h" /* Allocate and initialize a samples buffer. */ RawSamplesBuffer *raw_samples_alloc(void) { @@ -48,6 +48,31 @@ void raw_samples_add(RawSamplesBuffer *s, bool level, uint32_t dur) { furi_mutex_release(s->mutex); } +/* This is like raw_samples_add(), however in case a sample of the + * same level of the previous one is added, the duration of the last + * sample is updated instead. Needed mainly for the decoders build_message() + * methods: it is simpler to write an encoder of a signal like that, + * just creating messages piece by piece. + * + * This function is a bit slower so the internal data sampling should + * be performed with raw_samples_add(). */ +void raw_samples_add_or_update(RawSamplesBuffer *s, bool level, uint32_t dur) { + furi_mutex_acquire(s->mutex,FuriWaitForever); + uint32_t previdx = (s->idx-1) % RAW_SAMPLES_NUM; + if (s->samples[previdx].level == level && + s->samples[previdx].dur != 0) + { + /* Update the last sample: it has the same level. */ + s->samples[previdx].dur += dur; + } else { + /* Add a new sample. */ + s->samples[s->idx].level = level; + s->samples[s->idx].dur = dur; + s->idx = (s->idx+1) % RAW_SAMPLES_NUM; + } + furi_mutex_release(s->mutex); +} + /* Get the sample from the buffer. It is possible to use out of range indexes * as 'idx' because the modulo operation will rewind back from the start. */ void raw_samples_get(RawSamplesBuffer *s, uint32_t idx, bool *level, uint32_t *dur) diff --git a/applications/plugins/protoview/app_buffer.h b/applications/plugins/protoview/raw_samples.h similarity index 94% rename from applications/plugins/protoview/app_buffer.h rename to applications/plugins/protoview/raw_samples.h index 3a34d50f8..0b0422025 100644 --- a/applications/plugins/protoview/app_buffer.h +++ b/applications/plugins/protoview/raw_samples.h @@ -26,6 +26,7 @@ RawSamplesBuffer *raw_samples_alloc(void); void raw_samples_reset(RawSamplesBuffer *s); void raw_samples_center(RawSamplesBuffer *s, uint32_t offset); void raw_samples_add(RawSamplesBuffer *s, bool level, uint32_t dur); +void raw_samples_add_or_update(RawSamplesBuffer *s, bool level, uint32_t dur); void raw_samples_get(RawSamplesBuffer *s, uint32_t idx, bool *level, uint32_t *dur); void raw_samples_copy(RawSamplesBuffer *dst, RawSamplesBuffer *src); void raw_samples_free(RawSamplesBuffer *s); diff --git a/applications/plugins/protoview/signal.c b/applications/plugins/protoview/signal.c index 06e2197c2..f4c5ebedf 100644 --- a/applications/plugins/protoview/signal.c +++ b/applications/plugins/protoview/signal.c @@ -4,7 +4,6 @@ #include "app.h" bool decode_signal(RawSamplesBuffer *s, uint64_t len, ProtoViewMsgInfo *info); -void initialize_msg_info(ProtoViewMsgInfo *i); /* ============================================================================= * Raw signal detection @@ -23,6 +22,8 @@ void reset_current_signal(ProtoViewApp *app) { app->signal_decoded = false; raw_samples_reset(DetectedSamples); raw_samples_reset(RawSamples); + free_msg_info(app->msg_info); + app->msg_info = NULL; } /* This function starts scanning samples at offset idx looking for the @@ -119,15 +120,40 @@ uint32_t search_coherent_signal(RawSamplesBuffer *s, uint32_t idx) { return len; } -/* Search the buffer with the stored signal (last N samples received) +/* Called when we detect a message. Just blinks when the message was + * not decoded. Vibrates, too, when the message was correctly decoded. */ +void notify_signal_detected(ProtoViewApp *app, bool decoded) { + static const NotificationSequence decoded_seq = { + &message_vibro_on, + &message_green_255, + &message_delay_50, + &message_green_0, + &message_vibro_off, + NULL + }; + + static const NotificationSequence unknown_seq = { + &message_red_255, + &message_delay_50, + &message_red_0, + NULL + }; + + if (decoded) + notification_message(app->notification, &decoded_seq); + else + notification_message(app->notification, &unknown_seq); +} + +/* Search the source 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 +void scan_for_signal(ProtoViewApp *app, RawSamplesBuffer *source) { + /* We need to work on a copy: the source buffer may be populated * by the background thread receiving data. */ RawSamplesBuffer *copy = raw_samples_alloc(); - raw_samples_copy(copy,RawSamples); + raw_samples_copy(copy,source); /* Try to seek on data that looks to have a regular high low high low * pattern. */ @@ -135,7 +161,6 @@ void scan_for_signal(ProtoViewApp *app) { than a few samples it's very easy to mistake noise for signal. */ - ProtoViewMsgInfo *info = malloc(sizeof(ProtoViewMsgInfo)); uint32_t i = 0; while (i < copy->total-1) { @@ -143,10 +168,16 @@ void scan_for_signal(ProtoViewApp *app) { /* For messages that are long enough, attempt decoding. */ if (thislen > minlen) { - initialize_msg_info(info); + /* Allocate the message information that some decoder may + * fill, in case it is able to decode a message. */ + ProtoViewMsgInfo *info = malloc(sizeof(ProtoViewMsgInfo)); + init_msg_info(info,app); + info->short_pulse_dur = copy->short_pulse_dur; + uint32_t saved_idx = copy->idx; /* Save index, see later. */ + /* decode_signal() expects the detected signal to start - * from index .*/ + * from index zero .*/ raw_samples_center(copy,i); bool decoded = decode_signal(copy,thislen,info); copy->idx = saved_idx; /* Restore the index as we are scanning @@ -158,7 +189,8 @@ void scan_for_signal(ProtoViewApp *app) { if ((thislen > app->signal_bestlen && app->signal_decoded == false) || (app->signal_decoded == false && decoded)) { - app->signal_info = *info; + free_msg_info(app->msg_info); + app->msg_info = info; app->signal_bestlen = thislen; app->signal_decoded = decoded; raw_samples_copy(DetectedSamples,copy); @@ -166,18 +198,17 @@ void scan_for_signal(ProtoViewApp *app) { FURI_LOG_E(TAG, "===> Displayed sample updated (%d samples %lu us)", (int)thislen, DetectedSamples->short_pulse_dur); - /* Adjust raw view scale if the signal has an high - * data rate. */ - if (DetectedSamples->short_pulse_dur < 75) - app->us_scale = 10; - else if (DetectedSamples->short_pulse_dur < 145) - app->us_scale = 30; + adjust_raw_view_scale(app,DetectedSamples->short_pulse_dur); + notify_signal_detected(app,decoded); + } else { + /* If the structure was not filled, discard it. Otherwise + * now the owner is app->msg_info. */ + free_msg_info(info); } } i += thislen ? thislen : 1; } raw_samples_free(copy); - free(info); } /* ============================================================================= @@ -215,10 +246,104 @@ bool bitmap_get(uint8_t *b, uint32_t blen, uint32_t bitpos) { return (b[byte] & (1< 8 && didx < dlen && sidx < slen) { + d[didx++] = s[sidx++]; + count -= 8; + } + doff = didx * 8; + soff = sidx * 8; + /* Note that if we entered this path, the count at the end + * of the loop will be < 8. */ + } + + /* Copy the bits needed to reach an offset where we can copy + * two half bytes of src to a full byte of destination. */ + while(count > 8 && (doff&7) != 0) { + bool bit = bitmap_get(s,slen,soff++); + bitmap_set(d,dlen,doff++,bit); + count--; + } + + /* If we are here and count > 8, we have an offset that is byte aligned + * to the destination bitmap, but not aligned to the source bitmap. + * We can copy fast enough by shifting each two bytes of the original + * bitmap. + * + * This is how it works: + * + * dst: + * +--------+--------+--------+ + * | 0 | 1 | 2 | + * | | | | <- data to fill + * +--------+--------+--------+ + * ^ + * | + * doff = 8 + * + * src: + * +--------+--------+--------+ + * | 0 | 1 | 2 | + * |hellowor|ld!HELLO|WORLDS!!| <- data to copy + * +--------+--------+--------+ + * ^ + * | + * soff = 11 + * + * skew = 11%8 = 3 + * each destination byte in dst will receive: + * + * dst[doff/8] = (src[soff/8] << skew) | (src[soff/8+1] >> (8-skew)) + * + * dstbyte = doff/8 = 8/8 = 1 + * srcbyte = soff/8 = 11/8 = 1 + * + * so dst[1] will get: + * src[1] << 3, that is "ld!HELLO" << 3 = "HELLO..." + * xored with + * src[2] << 5, that is "WORLDS!!" >> 5 = ".....WOR" + * That is "HELLOWOR" + */ + if (count > 8) { + uint8_t skew = soff % 8; /* Don't worry, compiler will optimize. */ + uint32_t didx = doff/8; + uint32_t sidx = soff/8; + while(count > 8 && didx < dlen && sidx < slen) { + d[didx] = ((s[sidx] << skew) | + (s[sidx+1] >> (8-skew))); + sidx++; + didx++; + soff += 8; + doff += 8; + count -= 8; + } + } + + /* Here count is guaranteed to be < 8. + * Copy the final bits bit by bit. */ + while(count) { + bool bit = bitmap_get(s,slen,soff++); + bitmap_set(d,dlen,doff++,bit); + count--; + } +} + /* We decode bits assuming the first bit we receive is the MSB * (see bitmap_set/get functions). Certain devices send data * encoded in the reverse way. */ -void bitmap_reverse_bytes(uint8_t *p, uint32_t len) { +void bitmap_reverse_bytes_bits(uint8_t *p, uint32_t len) { for (uint32_t j = 0; j < len; j++) { uint32_t b = p[j]; /* Step 1: swap the two nibbles: 12345678 -> 56781234 */ @@ -259,15 +384,17 @@ uint32_t bitmap_seek_bits(uint8_t *b, uint32_t blen, uint32_t startpos, uint32_t return BITMAP_SEEK_NOT_FOUND; } -/* Set the pattern 'pat' into the bitmap 'b' of max length 'blen' bytes. +/* Set the pattern 'pat' into the bitmap 'b' of max length 'blen' bytes, + * starting from the specified offset. + * * The pattern is given as a string of 0s and 1s characters, like "01101001". * This function is useful in order to set the test vectors in the protocol * decoders, to see if the decoding works regardless of the fact we are able * to actually receive a given signal. */ -void bitmap_set_pattern(uint8_t *b, uint32_t blen, const char *pat) { +void bitmap_set_pattern(uint8_t *b, uint32_t blen, uint32_t off, const char *pat) { uint32_t i = 0; while(pat[i]) { - bitmap_set(b,blen,i,pat[i] == '1'); + bitmap_set(b,blen,i+off,pat[i] == '1'); i++; } } @@ -408,10 +535,21 @@ ProtoViewDecoder *Decoders[] = { NULL }; +/* Free the message info and allocated data. */ +void free_msg_info(ProtoViewMsgInfo *i) { + if (i == NULL) return; + fieldset_free(i->fieldset); + free(i->bits); + free(i); +} + /* Reset the message info structure before passing it to the decoding * functions. */ -void initialize_msg_info(ProtoViewMsgInfo *i) { +void init_msg_info(ProtoViewMsgInfo *i, ProtoViewApp *app) { + UNUSED(app); memset(i,0,sizeof(ProtoViewMsgInfo)); + i->bits = NULL; + i->fieldset = fieldset_new(); } /* This function is called when a new signal is detected. It converts it @@ -424,7 +562,7 @@ bool decode_signal(RawSamplesBuffer *s, uint64_t len, ProtoViewMsgInfo *info) { /* We call the decoders with an offset a few samples before the actual * signal detected and for a len of a few bits after its end. */ - uint32_t before_samples = 20; + uint32_t before_samples = 32; uint32_t after_samples = 100; uint8_t *bitmap = malloc(bitmap_size); @@ -451,14 +589,28 @@ bool decode_signal(RawSamplesBuffer *s, uint64_t len, ProtoViewMsgInfo *info) { uint32_t delta = furi_get_tick() - start_time; FURI_LOG_E(TAG, "Decoder %s took %lu ms", Decoders[j]->name, (unsigned long)delta); - if (decoded) break; + if (decoded) { + info->decoder = Decoders[j]; + break; + } j++; } if (!decoded) { FURI_LOG_E(TAG, "No decoding possible"); } else { - FURI_LOG_E(TAG, "Decoded %s, raw=%s info=[%s,%s,%s,%s]", info->name, info->raw, info->info1, info->info2, info->info3, info->info4); + FURI_LOG_E(TAG, "+++ Decoded %s", info->decoder->name); + /* The message was correctly decoded: fill the info structure + * with the decoded signal. The decoder may not implement offset/len + * filling of the structure. In such case we have no info and + * pulses_count will be set to zero. */ + if (info->pulses_count) { + info->bits_bytes = (info->pulses_count+7)/8; // Round to full byte. + info->bits = malloc(info->bits_bytes); + bitmap_copy(info->bits,info->bits_bytes,0, + bitmap,bitmap_size,info->start_off, + info->pulses_count); + } } free(bitmap); return decoded; diff --git a/applications/plugins/protoview/signal_file.c b/applications/plugins/protoview/signal_file.c new file mode 100644 index 000000000..31c8726fb --- /dev/null +++ b/applications/plugins/protoview/signal_file.c @@ -0,0 +1,141 @@ +/* Copyright (C) 2023 Salvatore Sanfilippo -- All Rights Reserved + * Copyright (C) 2023 Maciej Wojtasik -- All Rights Reserved + * See the LICENSE file for information about the license. */ + +#include "app.h" +#include +#include + +/* ========================= Signal file operations ========================= */ + +/* This function saves the current logical signal on disk. What is saved here + * is not the signal as level and duration as we received it from CC1101, + * but it's logical representation stored in the app->msg_info bitmap, where + * each 1 or 0 means a puls or gap for the specified short pulse duration time + * (te). */ +bool save_signal(ProtoViewApp *app, const char *filename) { + /* We have a message at all? */ + if (app->msg_info == NULL || app->msg_info->pulses_count == 0) return false; + + Storage *storage = furi_record_open(RECORD_STORAGE); + FlipperFormat *file = flipper_format_file_alloc(storage); + Stream *stream = flipper_format_get_raw_stream(file); + FuriString *file_content = NULL; + bool success = true; + + if (flipper_format_file_open_always(file, filename)) { + /* Write the file header. */ + FuriString *file_content = furi_string_alloc(); + const char *preset_id = ProtoViewModulations[app->modulation].id; + + furi_string_printf(file_content, + "Filetype: Flipper SubGhz RAW File\n" + "Version: 1\n" + "Frequency: %ld\n" + "Preset: %s\n", + app->frequency, + preset_id ? preset_id : "FuriHalSubGhzPresetCustom"); + + /* For custom modulations, we need to emit a set of registers. */ + if (preset_id == NULL) { + FuriString *custom = furi_string_alloc(); + uint8_t *regs = ProtoViewModulations[app->modulation].custom; + furi_string_printf(custom, + "Custom_preset_module: CC1101\n" + "Custom_preset_data: "); + for (int j = 0; regs[j]; j += 2) { + furi_string_cat_printf(custom, "%02X %02X ", + (int)regs[j], (int)regs[j+1]); + } + size_t len = furi_string_size(file_content); + furi_string_set_char(custom,len-1,'\n'); + furi_string_cat(file_content,custom); + furi_string_free(custom); + } + + /* We always save raw files. */ + furi_string_cat_printf(file_content, + "Protocol: RAW\n" + "RAW_Data: -10000\n"); // Start with 10 ms of gap + + /* Write header. */ + size_t len = furi_string_size(file_content); + if (stream_write(stream, + (uint8_t*) furi_string_get_cstr(file_content), len) + != len) + { + FURI_LOG_W(TAG, "Short write to file"); + success = false; + goto write_err; + } + furi_string_reset(file_content); + + /* Write raw data sections. The Flipper subghz parser can't handle + * too much data on a single line, so we generate a new one + * every few samples. */ + uint32_t this_line_samples = 0; + uint32_t max_line_samples = 100; + uint32_t idx = 0; // Iindex in the signal bitmap. + ProtoViewMsgInfo *i = app->msg_info; + while(idx < i->pulses_count) { + bool level = bitmap_get(i->bits,i->bits_bytes,idx); + uint32_t te_times = 1; + idx++; + /* Count the duration of the current pulse/gap. */ + while(idx < i->pulses_count && + bitmap_get(i->bits,i->bits_bytes,idx) == level) + { + te_times++; + idx++; + } + // Invariant: after the loop 'idx' is at the start of the + // next gap or pulse. + + int32_t dur = (int32_t)i->short_pulse_dur * te_times; + if (level == 0) dur = -dur; /* Negative is gap in raw files. */ + + /* Emit the sample. If this is the first sample of the line, + * also emit the RAW_Data: field. */ + if (this_line_samples == 0) + furi_string_cat_printf(file_content,"RAW_Data: "); + furi_string_cat_printf(file_content,"%d ",(int)dur); + this_line_samples++; + + /* Store the current set of samples on disk, when we reach a + * given number or the end of the signal. */ + bool end_reached = (idx == i->pulses_count); + if (this_line_samples == max_line_samples || end_reached) { + /* If that's the end, terminate the signal with a long + * gap. */ + if (end_reached) furi_string_cat_printf(file_content,"-10000 "); + + /* We always have a trailing space in the last sample. Make it + * a newline. */ + size_t len = furi_string_size(file_content); + furi_string_set_char(file_content,len-1,'\n'); + + if (stream_write(stream, + (uint8_t*) furi_string_get_cstr(file_content), + len) != len) + { + FURI_LOG_W(TAG, "Short write to file"); + success = false; + goto write_err; + } + + /* Prepare for next line. */ + furi_string_reset(file_content); + this_line_samples = 0; + } + } + } else { + success = false; + FURI_LOG_W(TAG, "Unable to open file"); + } + +write_err: + furi_record_close(RECORD_STORAGE); + flipper_format_free(file); + if (file_content != NULL) furi_string_free(file_content); + return success; +} diff --git a/applications/plugins/protoview/ui.c b/applications/plugins/protoview/ui.c index e22e4d57e..8badab5bf 100644 --- a/applications/plugins/protoview/ui.c +++ b/applications/plugins/protoview/ui.c @@ -3,6 +3,122 @@ #include "app.h" +/* =========================== Subview handling ================================ + * Note that these are not the Flipper subviews, but the subview system + * implemented inside ProtoView. + * ========================================================================== */ + +/* Return the ID of the currently selected subview, of the current + * view. */ +int ui_get_current_subview(ProtoViewApp *app) { + return app->current_subview[app->current_view]; +} + +/* Called by view rendering callback that has subviews, to show small triangles + * facing down/up if there are other subviews the user can access with up + * and down. */ +void ui_show_available_subviews(Canvas *canvas, ProtoViewApp *app, + int last_subview) +{ + int subview = ui_get_current_subview(app); + if (subview != 0) + canvas_draw_triangle(canvas,120,5,8,5,CanvasDirectionBottomToTop); + if (subview != last_subview-1) + canvas_draw_triangle(canvas,120,59,8,5,CanvasDirectionTopToBottom); +} + +/* Handle up/down keys when we are in a subview. If the function catched + * such keypress, it returns true, so that the actual view input callback + * knows it can just return ASAP without doing anything. */ +bool ui_process_subview_updown(ProtoViewApp *app, InputEvent input, int last_subview) { + int subview = ui_get_current_subview(app); + if (input.type == InputTypePress) { + if (input.key == InputKeyUp) { + if (subview != 0) + app->current_subview[app->current_view]--; + return true; + } else if (input.key == InputKeyDown) { + if (subview != last_subview-1) + app->current_subview[app->current_view]++; + return true; + } + } + return false; +} + +/* ============================= Text input ==================================== + * Normally we just use our own private UI widgets. However for the text input + * widget, that is quite complex, visualizes a keyboard and must be standardized + * for user coherent experience, we use the one provided by the Flipper + * framework. The following two functions allow to show the keyboard to get + * text and later dismiss it. + * ========================================================================== */ + +/* Show the keyboard, take the user input and store it into the specified + * 'buffer' of 'buflen' total bytes. When the user is done, the done_callback + * is called passing the application context to it. Such callback needs + * to do whatever it wants with the input buffer and dismissi the keyboard + * calling: dismiss_keyboard(app); + * + * Note: if the buffer is not a null-termined zero string, what it contains will + * be used as initial input for the user. */ +void ui_show_keyboard(ProtoViewApp *app, char *buffer, uint32_t buflen, + void (*done_callback)(void*)) +{ + app->show_text_input = true; + app->text_input_buffer = buffer; + app->text_input_buffer_len = buflen; + app->text_input_done_callback = done_callback; +} + +void ui_dismiss_keyboard(ProtoViewApp *app) { + view_dispatcher_stop(app->view_dispatcher); +} + +/* ================================= Alert ================================== */ + +/* Set an alert message to be shown over any currently active view, for + * the specified amount of time of 'ttl' milliseconds. */ +void ui_show_alert(ProtoViewApp *app, const char *text, uint32_t ttl) { + app->alert_dismiss_time = furi_get_tick() + furi_ms_to_ticks(ttl); + snprintf(app->alert_text,ALERT_MAX_LEN,"%s",text); +} + +/* Cancel the alert before its time has elapsed. */ +void ui_dismiss_alert(ProtoViewApp *app) { + app->alert_dismiss_time = 0; +} + +/* Show the alert if an alert is set. This is called after the currently + * active view displayed its stuff, so we overwrite the screen with the + * alert message. */ +void ui_draw_alert_if_needed(Canvas *canvas, ProtoViewApp *app) { + if (app->alert_dismiss_time == 0) { + /* No active alert. */ + return; + } else if (app->alert_dismiss_time < furi_get_tick()) { + /* Alert just expired. */ + ui_dismiss_alert(app); + return; + } + + /* Show the alert. A box with black border and a text inside. */ + canvas_set_font(canvas, FontPrimary); + uint8_t w = canvas_string_width(canvas, app->alert_text); + uint8_t h = 8; // Font height. + uint8_t text_x = 64-(w/2); + uint8_t text_y = 32+4; + uint8_t padding = 3; + canvas_set_color(canvas,ColorBlack); + canvas_draw_box(canvas,text_x-padding,text_y-padding-h,w+padding*2,h+padding*2); + canvas_set_color(canvas,ColorWhite); + canvas_draw_box(canvas,text_x-padding+1,text_y-padding-h+1,w+padding*2-2,h+padding*2-2); + canvas_set_color(canvas,ColorBlack); + canvas_draw_str(canvas,text_x,text_y,app->alert_text); +} + +/* =========================== Canvas extensions ============================ */ + void canvas_draw_str_with_border(Canvas* canvas, uint8_t x, uint8_t y, const char* str, Color text_color, Color border_color) { struct { diff --git a/applications/plugins/protoview/view_build.c b/applications/plugins/protoview/view_build.c new file mode 100644 index 000000000..fd276b61d --- /dev/null +++ b/applications/plugins/protoview/view_build.c @@ -0,0 +1,253 @@ +/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved + * See the LICENSE file for information about the license. */ + +#include "app.h" + +extern ProtoViewDecoder *Decoders[]; // Defined in signal.c. + +/* Our view private data. */ +#define USER_VALUE_LEN 64 +typedef struct { + ProtoViewDecoder *decoder; /* Decoder we are using to create a + message. */ + uint32_t cur_decoder; /* Decoder index when we are yet selecting + a decoder. Used when decoder is NULL. */ + ProtoViewFieldSet *fieldset; /* The fields to populate. */ + uint32_t cur_field; /* Field we are editing right now. This + is the index inside the 'fieldset' + fields. */ + char *user_value; /* Keyboard input to replace the current + field value goes here. */ +} BuildViewPrivData; + +/* Not all the decoders support message bulding, so we can't just + * increment / decrement the cur_decoder index here. */ +static void select_next_decoder(ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + do { + privdata->cur_decoder++; + if (Decoders[privdata->cur_decoder] == NULL) + privdata->cur_decoder = 0; + } while(Decoders[privdata->cur_decoder]->get_fields == NULL); +} + +/* Like select_next_decoder() but goes backward. */ +static void select_prev_decoder(ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + do { + if (privdata->cur_decoder == 0) { + /* Go one after the last one to wrap around. */ + while(Decoders[privdata->cur_decoder]) privdata->cur_decoder++; + } + privdata->cur_decoder--; + } while(Decoders[privdata->cur_decoder]->get_fields == NULL); +} + +/* Render the view to select the decoder, among the ones that + * support message building. */ +static void render_view_select_decoder(Canvas *const canvas, ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + canvas_set_font(canvas, FontPrimary); + canvas_draw_str(canvas, 0, 9, "Signal creator"); + canvas_set_font(canvas, FontSecondary); + canvas_draw_str(canvas, 0, 19, "up/down: select, ok: choose"); + + canvas_set_font(canvas, FontPrimary); + canvas_draw_str_aligned(canvas,64,38,AlignCenter,AlignCenter, + Decoders[privdata->cur_decoder]->name); +} + +/* Render the view that allows the user to populate the fields needed + * for the selected decoder to build a message. */ +static void render_view_set_fields(Canvas *const canvas, ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + char buf[32]; + snprintf(buf,sizeof(buf), "%s field %d/%d", + privdata->decoder->name, (int)privdata->cur_field+1, + (int)privdata->fieldset->numfields); + canvas_set_color(canvas,ColorBlack); + canvas_draw_box(canvas,0,0,128,21); + canvas_set_color(canvas,ColorWhite); + canvas_set_font(canvas, FontPrimary); + canvas_draw_str(canvas, 1, 9, buf); + canvas_set_font(canvas, FontSecondary); + canvas_draw_str(canvas, 1, 19, "up/down: next field, ok: edit"); + + /* Write the field name, type, current content. */ + canvas_set_color(canvas,ColorBlack); + ProtoViewField *field = privdata->fieldset->fields[privdata->cur_field]; + snprintf(buf,sizeof(buf), "%s %s:%d", field->name, + field_get_type_name(field), (int)field->len); + buf[0] = toupper(buf[0]); + canvas_set_font(canvas, FontPrimary); + canvas_draw_str_aligned(canvas,64,30,AlignCenter,AlignCenter,buf); + canvas_set_font(canvas, FontSecondary); + + /* Render the current value between "" */ + unsigned int written = (unsigned int) field_to_string(buf+1,sizeof(buf)-1,field); + buf[0] = '"'; + if (written+3 < sizeof(buf)) memcpy(buf+written+1,"\"\x00",2); + canvas_draw_str_aligned(canvas,63,45,AlignCenter,AlignCenter,buf); + + /* Footer instructions. */ + canvas_draw_str(canvas, 0, 62, "Long ok: create, < > incr/decr"); +} + +/* Render the build message view. */ +void render_view_build_message(Canvas *const canvas, ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + + if (privdata->decoder) + render_view_set_fields(canvas,app); + else + render_view_select_decoder(canvas,app); +} + +/* Handle input for the decoder selection. */ +static void process_input_select_decoder(ProtoViewApp *app, InputEvent input) { + BuildViewPrivData *privdata = app->view_privdata; + if (input.type == InputTypeShort) { + if (input.key == InputKeyOk) { + privdata->decoder = Decoders[privdata->cur_decoder]; + privdata->fieldset = fieldset_new(); + privdata->decoder->get_fields(privdata->fieldset); + + /* If the currently decoded message was produced with the + * same decoder the user selected, let's populate the + * defaults with the current values. So the user will + * actaully edit the current message. */ + if (app->signal_decoded && + app->msg_info->decoder == privdata->decoder) + { + fieldset_copy_matching_fields(privdata->fieldset, + app->msg_info->fieldset); + } + + /* Now we use the subview system in order to protect the + message editing mode from accidental < or > presses. + Since we are technically into a subview now, we'll have + control of < and >. */ + InputEvent ii = {.type = InputTypePress, .key = InputKeyDown}; + ui_process_subview_updown(app,ii,2); + } else if (input.key == InputKeyDown) { + select_next_decoder(app); + } else if (input.key == InputKeyUp) { + select_prev_decoder(app); + } + } +} + +/* Called after the user typed the new field value in the keyboard. + * Let's save it and remove the keyboard view. */ +static void text_input_done_callback(void* context) { + ProtoViewApp *app = context; + BuildViewPrivData *privdata = app->view_privdata; + + if (field_set_from_string(privdata->fieldset->fields[privdata->cur_field], + privdata->user_value, strlen(privdata->user_value)) == false) + { + ui_show_alert(app, "Invalid value", 1500); + } + + free(privdata->user_value); + privdata->user_value = NULL; + ui_dismiss_keyboard(app); +} + +/* Handles the effects of < and > keys in field editing mode. + * Instead of force the user to enter the text input mode, delete + * the old value, enter the one, we allow to increment and + * decrement the current field in a much simpler way. + * + * The current filed is changed by 'incr' amount. */ +static bool increment_current_field(ProtoViewApp *app, int incr) { + BuildViewPrivData *privdata = app->view_privdata; + ProtoViewFieldSet *fs = privdata->fieldset; + ProtoViewField *f = fs->fields[privdata->cur_field]; + return field_incr_value(f,incr); +} + +/* Handle input for fields editing mode. */ +static void process_input_set_fields(ProtoViewApp *app, InputEvent input) { + BuildViewPrivData *privdata = app->view_privdata; + ProtoViewFieldSet *fs = privdata->fieldset; + + if (input.type == InputTypeShort && input.key == InputKeyOk) { + /* Show the keyboard to let the user type the new + * value. */ + if (privdata->user_value == NULL) + privdata->user_value = malloc(USER_VALUE_LEN); + field_to_string(privdata->user_value, USER_VALUE_LEN, + fs->fields[privdata->cur_field]); + ui_show_keyboard(app, privdata->user_value, USER_VALUE_LEN, + text_input_done_callback); + } else if (input.type == InputTypeShort && input.key == InputKeyDown) { + privdata->cur_field = (privdata->cur_field+1) % fs->numfields; + } else if (input.type == InputTypeShort && input.key == InputKeyUp) { + if (privdata->cur_field == 0) + privdata->cur_field = fs->numfields-1; + else + privdata->cur_field--; + } else if (input.type == InputTypeShort && input.key == InputKeyRight) { + increment_current_field(app,1); + } else if (input.type == InputTypeShort && input.key == InputKeyLeft) { + increment_current_field(app,-1); + } else if (input.type == InputTypeRepeat && input.key == InputKeyRight) { + // The reason why we don't use a large increment directly + // is that certain field types only support +1 -1 increments. + int times = 10; + while(times--) increment_current_field(app,1); + } else if (input.type == InputTypeRepeat && input.key == InputKeyLeft) { + int times = 10; + while(times--) increment_current_field(app,-1); + } else if (input.type == InputTypeLong && input.key == InputKeyOk) { + // Build the message in a fresh raw buffer. + if (privdata->decoder->build_message) { + RawSamplesBuffer *rs = raw_samples_alloc(); + privdata->decoder->build_message(rs,privdata->fieldset); + app->signal_decoded = false; // So that the new signal will be + // accepted as the current signal. + scan_for_signal(app,rs); + raw_samples_free(rs); + ui_show_alert(app,"Done: press back key",3000); + } + } +} + +/* Handle input for the build message view. */ +void process_input_build_message(ProtoViewApp *app, InputEvent input) { + BuildViewPrivData *privdata = app->view_privdata; + if (privdata->decoder) + process_input_set_fields(app,input); + else + process_input_select_decoder(app,input); +} + +/* Enter view callback. */ +void view_enter_build_message(ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + + // When we enter the view, the current decoder is just set to zero. + // Seek the next valid if needed. + if (Decoders[privdata->cur_decoder]->get_fields == NULL) { + select_next_decoder(app); + } + + // However if there is currently a decoded message, and the + // decoder of such message supports message building, let's + // select it. + if (app->signal_decoded && + app->msg_info->decoder->get_fields && + app->msg_info->decoder->build_message) + { + while(Decoders[privdata->cur_decoder] != app->msg_info->decoder) + select_next_decoder(app); + } +} + +/* Called on exit for cleanup. */ +void view_exit_build_message(ProtoViewApp *app) { + BuildViewPrivData *privdata = app->view_privdata; + if (privdata->fieldset) fieldset_free(privdata->fieldset); + if (privdata->user_value) free(privdata->user_value); +} diff --git a/applications/plugins/protoview/view_info.c b/applications/plugins/protoview/view_info.c index 775c8abc2..6aa69739c 100644 --- a/applications/plugins/protoview/view_info.c +++ b/applications/plugins/protoview/view_info.c @@ -2,8 +2,122 @@ * See the LICENSE file for information about the license. */ #include "app.h" +#include +#include -/* Renders the view with the detected message information. */ +/* This view has subviews accessible navigating up/down. This + * enumaration is used to track the currently active subview. */ +enum { + SubViewInfoMain, + SubViewInfoSave, + SubViewInfoLast, /* Just a sentinel. */ +}; + +/* Our view private data. */ +#define SAVE_FILENAME_LEN 64 +typedef struct { + /* Our save view displays an oscilloscope-alike resampled signal, + * so that the user can see what they are saving. With left/right + * you can move to next rows. Here we store where we are. */ + uint32_t signal_display_start_row; + char *filename; + uint8_t cur_info_page; // Info page to display. Useful when there are + // too many fields populated by the decoder that + // a single page is not enough. +} InfoViewPrivData; + +/* Draw the text label and value of the specified info field at x,y. */ +static void render_info_field(Canvas *const canvas, + ProtoViewField *f, uint8_t x, uint8_t y) +{ + char buf[64]; + char strval[32]; + + field_to_string(strval,sizeof(strval),f); + snprintf(buf,sizeof(buf),"%s: %s", f->name, strval); + canvas_set_font(canvas, FontSecondary); + canvas_draw_str(canvas, x, y, buf); +} + +/* Render the view with the detected message information. */ +#define INFO_LINES_PER_PAGE 5 +static void render_subview_main(Canvas *const canvas, ProtoViewApp *app) { + InfoViewPrivData *privdata = app->view_privdata; + uint8_t pages = (app->msg_info->fieldset->numfields + +(INFO_LINES_PER_PAGE-1)) / INFO_LINES_PER_PAGE; + privdata->cur_info_page %= pages; + uint8_t current_page = privdata->cur_info_page; + char buf[32]; + + /* Protocol name as title. */ + canvas_set_font(canvas, FontPrimary); + uint8_t y = 8, lineheight = 10; + + if (pages > 1) { + snprintf(buf,sizeof(buf),"%s %u/%u", app->msg_info->decoder->name, + current_page+1, pages); + canvas_draw_str(canvas, 0, y, buf); + } else { + canvas_draw_str(canvas, 0, y, app->msg_info->decoder->name); + } + y += lineheight; + + /* Draw the info fields. */ + uint8_t max_lines = INFO_LINES_PER_PAGE; + uint32_t j = current_page*max_lines; + while (j < app->msg_info->fieldset->numfields) { + render_info_field(canvas,app->msg_info->fieldset->fields[j++],0,y); + y += lineheight; + if (--max_lines == 0) break; + } + + /* Draw a vertical "save" label. Temporary solution, to switch to + * something better ASAP. */ + y = 37; + lineheight = 7; + canvas_draw_str(canvas, 119, y, "s"); y += lineheight; + canvas_draw_str(canvas, 119, y, "a"); y += lineheight; + canvas_draw_str(canvas, 119, y, "v"); y += lineheight; + canvas_draw_str(canvas, 119, y, "e"); y += lineheight; +} + +/* Render view with save option. */ +static void render_subview_save(Canvas *const canvas, ProtoViewApp *app) { + InfoViewPrivData *privdata = app->view_privdata; + + /* Display our signal in digital form: here we don't show the + * signal with the exact timing of the received samples, but as it + * is in its logic form, in exact multiples of the short pulse length. */ + uint8_t rows = 6; + uint8_t rowheight = 11; + uint8_t bitwidth = 4; + uint8_t bitheight = 5; + uint32_t idx = privdata->signal_display_start_row * (128/4); + bool prevbit = false; + for (uint8_t y = bitheight+12; y <= rows*rowheight; y += rowheight) { + for (uint8_t x = 0; x < 128; x += 4) { + bool bit = bitmap_get(app->msg_info->bits, + app->msg_info->bits_bytes,idx); + uint8_t prevy = y + prevbit*(bitheight*-1) - 1; + uint8_t thisy = y + bit*(bitheight*-1) - 1; + canvas_draw_line(canvas,x,prevy,x,thisy); + canvas_draw_line(canvas,x,thisy,x+bitwidth-1,thisy); + prevbit = bit; + if (idx >= app->msg_info->pulses_count) { + canvas_set_color(canvas, ColorWhite); + canvas_draw_dot(canvas, x+1,thisy); + canvas_draw_dot(canvas, x+3,thisy); + canvas_set_color(canvas, ColorBlack); + } + idx++; // Draw next bit + } + } + + canvas_set_font(canvas, FontSecondary); + canvas_draw_str(canvas, 0, 6, "ok: send, long ok: save"); +} + +/* Render the selected subview of this view. */ void render_view_info(Canvas *const canvas, ProtoViewApp *app) { if (app->signal_decoded == false) { canvas_set_font(canvas, FontSecondary); @@ -11,32 +125,211 @@ void render_view_info(Canvas *const canvas, ProtoViewApp *app) { return; } - /* Protocol name as title. */ - canvas_set_font(canvas, FontPrimary); - uint8_t y = 8, lineheight = 10; - canvas_draw_str(canvas, 0, y, app->signal_info.name); - y += lineheight; - - /* Info fields. */ - char buf[128]; - canvas_set_font(canvas, FontSecondary); - if (app->signal_info.raw[0]) { - snprintf(buf,sizeof(buf),"Raw: %s", app->signal_info.raw); - canvas_draw_str(canvas, 0, y, buf); - y += lineheight; + ui_show_available_subviews(canvas,app,SubViewInfoLast); + switch(app->current_subview[app->current_view]) { + case SubViewInfoMain: render_subview_main(canvas,app); break; + case SubViewInfoSave: render_subview_save(canvas,app); break; } - canvas_draw_str(canvas, 0, y, app->signal_info.info1); y += lineheight; - canvas_draw_str(canvas, 0, y, app->signal_info.info2); y += lineheight; - canvas_draw_str(canvas, 0, y, app->signal_info.info3); y += lineheight; - canvas_draw_str(canvas, 0, y, app->signal_info.info4); y += lineheight; +} + +/* The user typed the file name. Let's save it and remove the keyboard + * view. */ +static void text_input_done_callback(void* context) { + ProtoViewApp *app = context; + InfoViewPrivData *privdata = app->view_privdata; + + FuriString *save_path = furi_string_alloc_printf( + "%s/%s.sub", EXT_PATH("subghz"), privdata->filename); + save_signal(app, furi_string_get_cstr(save_path)); + furi_string_free(save_path); + + free(privdata->filename); + privdata->filename = NULL; // Don't free it again on view exit + ui_dismiss_keyboard(app); + ui_show_alert(app, "Signal saved", 1500); +} + +/* Replace all the occurrences of character c1 with c2 in the specified + * string. */ +void str_replace(char *buf, char c1, char c2) { + char *p = buf; + while(*p) { + if (*p == c1) *p = c2; + p++; + } +} + +/* Set a random filename the user can edit. */ +void set_signal_random_filename(ProtoViewApp *app, char *buf, size_t buflen) { + char suffix[6]; + set_random_name(suffix,sizeof(suffix)); + snprintf(buf,buflen,"%.10s-%s-%d",app->msg_info->decoder->name,suffix,rand()%1000); + str_replace(buf,' ','_'); + str_replace(buf,'-','_'); + str_replace(buf,'/','_'); +} + +/* ========================== Signal transmission =========================== */ + +/* This is the context we pass to the data yield callback for + * asynchronous tx. */ +typedef enum { + SendSignalSendStartGap, + SendSignalSendBits, + SendSignalSendEndGap, + SendSignalEndTransmission +} SendSignalState; + +#define PROTOVIEW_SENDSIGNAL_START_GAP 10000 /* microseconds. */ +#define PROTOVIEW_SENDSIGNAL_END_GAP 10000 /* microseconds. */ + +typedef struct { + SendSignalState state; // Current state. + uint32_t curpos; // Current bit position of data to send. + ProtoViewApp *app; // App reference. + uint32_t start_gap_dur; // Gap to send at the start. + uint32_t end_gap_dur; // Gap to send at the end. +} SendSignalCtx; + +/* Setup the state context for the callback responsible to feed data + * to the subghz async tx system. */ +static void send_signal_init(SendSignalCtx *ss, ProtoViewApp *app) { + ss->state = SendSignalSendStartGap; + ss->curpos = 0; + ss->app = app; + ss->start_gap_dur = PROTOVIEW_SENDSIGNAL_START_GAP; + ss->end_gap_dur = PROTOVIEW_SENDSIGNAL_END_GAP; +} + +/* Send signal data feeder callback. When the asynchronous transmission is + * active, this function is called to return new samples from the currently + * decoded signal in app->msg_info. The subghz subsystem aspects this function, + * that is the data feeder, to return LevelDuration types (that is a structure + * with level, that is pulse or gap, and duration in microseconds). + * + * The position into the transmission is stored in the context 'ctx', that + * references a SendSignalCtx structure. + * + * In the SendSignalCtx structure 'ss' we remember at which bit of the + * message we are, in ss->curoff. We also send a start and end gap in order + * to make sure the transmission is clear. + */ +LevelDuration radio_tx_feed_data(void *ctx) { + SendSignalCtx *ss = ctx; + + /* Send start gap. */ + if (ss->state == SendSignalSendStartGap) { + ss->state = SendSignalSendBits; + return level_duration_make(0,ss->start_gap_dur); + } + + /* Send data. */ + if (ss->state == SendSignalSendBits) { + uint32_t dur = 0, j; + uint32_t level = 0; + + /* Let's see how many consecutive bits we have with the same + * level. */ + for (j = 0; ss->curpos+j < ss->app->msg_info->pulses_count; j++) { + uint32_t l = bitmap_get(ss->app->msg_info->bits, + ss->app->msg_info->bits_bytes, + ss->curpos+j); + if (j == 0) { + /* At the first bit of this sequence, we store the + * level of the sequence. */ + level = l; + dur += ss->app->msg_info->short_pulse_dur; + continue; + } + + /* As long as the level is the same, we update the duration. + * Otherwise stop the loop and return this sample. */ + if (l != level) break; + dur += ss->app->msg_info->short_pulse_dur; + } + ss->curpos += j; + + /* If this was the last set of bits, change the state to + * send the final gap. */ + if (ss->curpos >= ss->app->msg_info->pulses_count) + ss->state = SendSignalSendEndGap; + return level_duration_make(level, dur); + } + + /* Send end gap. */ + if (ss->state == SendSignalSendEndGap) { + ss->state = SendSignalEndTransmission; + return level_duration_make(0,ss->end_gap_dur); + } + + /* End transmission. Here state is guaranteed + * to be SendSignalEndTransmission */ + return level_duration_reset(); +} + +/* Vibrate and produce a click sound when a signal is sent. */ +void notify_signal_sent(ProtoViewApp *app) { + static const NotificationSequence sent_seq = { + &message_blue_255, + &message_vibro_on, + &message_note_g1, + &message_delay_10, + &message_sound_off, + &message_vibro_off, + &message_blue_0, + NULL + }; + notification_message(app->notification, &sent_seq); } /* Handle input for the info view. */ void process_input_info(ProtoViewApp *app, InputEvent input) { - if (input.type == InputTypeShort) { - if (input.key == InputKeyOk) { + /* If we don't have a decoded signal, we don't allow to go up/down + * in the subviews: they are only useful when a loaded signal. */ + if (app->signal_decoded && + ui_process_subview_updown(app,input,SubViewInfoLast)) return; + + InfoViewPrivData *privdata = app->view_privdata; + int subview = ui_get_current_subview(app); + + /* Main subview. */ + if (subview == SubViewInfoMain) { + if (input.type == InputTypeLong && input.key == InputKeyOk) { /* Reset the current sample to capture the next. */ reset_current_signal(app); + } else if (input.type == InputTypeShort && input.key == InputKeyOk) { + /* Show next info page. */ + privdata->cur_info_page++; + } + } else if (subview == SubViewInfoSave) { + /* Save subview. */ + if (input.type == InputTypePress && input.key == InputKeyRight) { + privdata->signal_display_start_row++; + } else if (input.type == InputTypePress && input.key == InputKeyLeft) { + if (privdata->signal_display_start_row != 0) + privdata->signal_display_start_row--; + } else if (input.type == InputTypeLong && input.key == InputKeyOk) + { + // We have have the buffer already allocated, in case the + // user aborted with BACK a previous saving. + if (privdata->filename == NULL) + privdata->filename = malloc(SAVE_FILENAME_LEN); + set_signal_random_filename(app,privdata->filename,SAVE_FILENAME_LEN); + ui_show_keyboard(app, privdata->filename, SAVE_FILENAME_LEN, + text_input_done_callback); + } else if (input.type == InputTypeShort && input.key == InputKeyOk) { + SendSignalCtx send_state; + send_signal_init(&send_state,app); + radio_tx_signal(app,radio_tx_feed_data,&send_state); + notify_signal_sent(app); } } } + +/* Called on view exit. */ +void view_exit_info(ProtoViewApp *app) { + InfoViewPrivData *privdata = app->view_privdata; + // When the user aborts the keyboard input, we are left with the + // filename buffer allocated. + if (privdata->filename) free(privdata->filename); +} diff --git a/applications/plugins/protoview/view_raw_signal.c b/applications/plugins/protoview/view_raw_signal.c index 58d23e8ee..023e986f9 100644 --- a/applications/plugins/protoview/view_raw_signal.c +++ b/applications/plugins/protoview/view_raw_signal.c @@ -65,7 +65,7 @@ void render_view_raw_pulses(Canvas *const canvas, ProtoViewApp *app) { canvas_draw_str_with_border(canvas, 97, 63, buf, ColorWhite, ColorBlack); if (app->signal_decoded) { canvas_set_font(canvas, FontPrimary); - canvas_draw_str_with_border(canvas, 1, 61, app->signal_info.name, ColorWhite, ColorBlack); + canvas_draw_str_with_border(canvas, 1, 61, app->msg_info->decoder->name, ColorWhite, ColorBlack); } } @@ -77,14 +77,15 @@ void process_input_raw_pulses(ProtoViewApp *app, InputEvent input) { * previous samples. */ if (input.key == InputKeyRight) app->signal_offset++; else if (input.key == InputKeyLeft) app->signal_offset--; - else if (input.key == InputKeyOk) { - app->signal_offset = 0; - app->us_scale = PROTOVIEW_RAW_VIEW_DEFAULT_SCALE; - } - } else if (input.type == InputTypeShort) { + } else if (input.type == InputTypeLong) { if (input.key == InputKeyOk) { /* Reset the current sample to capture the next. */ reset_current_signal(app); + } + } else if (input.type == InputTypeShort) { + if (input.key == InputKeyOk) { + app->signal_offset = 0; + adjust_raw_view_scale(app,DetectedSamples->short_pulse_dur); } else if (input.key == InputKeyDown) { /* Rescaling. The set becomes finer under 50us per pixel. */ uint32_t scale_step = app->us_scale >= 50 ? 50 : 10; @@ -95,3 +96,19 @@ void process_input_raw_pulses(ProtoViewApp *app, InputEvent input) { } } } + +/* Adjust raw view scale depending on short pulse duration. */ +void adjust_raw_view_scale(ProtoViewApp *app, uint32_t short_pulse_dur) { + if (short_pulse_dur == 0) + app->us_scale = PROTOVIEW_RAW_VIEW_DEFAULT_SCALE; + else if (short_pulse_dur < 75) + app->us_scale = 10; + else if (short_pulse_dur < 145) + app->us_scale = 30; + else if (short_pulse_dur < 400) + app->us_scale = 100; + else if (short_pulse_dur < 1000) + app->us_scale = 200; + else + app->us_scale = PROTOVIEW_RAW_VIEW_DEFAULT_SCALE; +}