mirror of
https://github.com/DarkFlippers/unleashed-firmware.git
synced 2024-11-23 19:00:43 +03:00
MX
parent
7aaecd9278
commit
6aad6840f6
@ -128,6 +128,7 @@ You can support us by using links or addresses below:
|
||||
- POCSAG Pager [(by xMasterX & Shmuma)](https://github.com/xMasterX/flipper-pager)
|
||||
- Text Viewer [(by kowalski7cc & kyhwana)](https://github.com/kowalski7cc/flipper-zero-text-viewer/tree/refactor-text-app)
|
||||
- **UART Terminal** [(by cool4uma)](https://github.com/cool4uma/UART_Terminal/tree/main)
|
||||
- **ProtoView** [(by antirez)](https://github.com/antirez/protoview)
|
||||
|
||||
Games:
|
||||
- DOOM (fixed) [(by p4nic4ttack)](https://github.com/p4nic4ttack/doom-flipper-zero/)
|
||||
|
||||
24
applications/plugins/protoview/LICENSE
Normal file
24
applications/plugins/protoview/LICENSE
Normal file
@ -0,0 +1,24 @@
|
||||
Copyright (c) 2022-2023 Salvatore Sanfilippo <antirez at gmail dot com>
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
130
applications/plugins/protoview/README.md
Normal file
130
applications/plugins/protoview/README.md
Normal file
@ -0,0 +1,130 @@
|
||||
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):
|
||||
|
||||
|
||||
|
||||
This is often enough to make an initial idea about the encoding used
|
||||
and if the selected modulation is correct.
|
||||
|
||||
Other than that, ProtoView is able to decode a few interesting protocols:
|
||||
|
||||
* TPMS sensors: Renault, Toyota, Schrader, Citroen, Ford.
|
||||
* Microchip HSC200/300/301 Keeloq protocol.
|
||||
* Oregon thermometer protocol 2.
|
||||
* PT2262, SC5262 based remotes.
|
||||
* ... more will be implemented soon, hopefully. Send PRs :)
|
||||
|
||||
|
||||
|
||||
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.
|
||||
|
||||
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).
|
||||
|
||||
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.
|
||||
|
||||
# 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
|
||||
or low, and with different duration in microseconds) look like belonging to
|
||||
a legitimate signal, and aren't just noise.
|
||||
|
||||
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
|
||||
three classes of pulse lengths.
|
||||
|
||||
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.
|
||||
|
||||
# Usage
|
||||
|
||||
The application shows the longest coherent signal detected so far.
|
||||
|
||||
* 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.
|
||||
|
||||
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.
|
||||
|
||||
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
|
||||
with the right arrow will show information about the decoded signal.
|
||||
|
||||
In the bottom-right corner the application displays an amount of time
|
||||
in microseconds. This is the average length of the shortest pulse length
|
||||
detected among the three classes. Usually the *data rate* of the protocol
|
||||
is something like `1000000/this-number*2`, but it depends on the encoding
|
||||
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:
|
||||
|
||||
* 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).
|
||||
|
||||
# Installing the app from source
|
||||
|
||||
* Download the Flipper Zero dev kit and build it:
|
||||
```
|
||||
mkdir -p ~/flipperZero/official/
|
||||
cd ~/flipperZero/official/
|
||||
git clone --recursive https://github.com/flipperdevices/flipperzero-firmware.git ./
|
||||
./fbt
|
||||
```
|
||||
* Copy this application folder in `official/applications_user`.
|
||||
* Connect your Flipper via USB.
|
||||
* Build and install with: `./fbt launch_app APPSRC=protoview`.
|
||||
|
||||
# Installing the binary file (no build needed)
|
||||
|
||||
Drop the `protoview.fap` file you can find in the `binaries` folder into the
|
||||
following Flipper Zero location:
|
||||
|
||||
/ext/apps/Tools
|
||||
|
||||
The `ext` part means that we are in the SD card. So if you don't want
|
||||
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.
|
||||
|
||||
# License
|
||||
|
||||
The code is released under the BSD license.
|
||||
|
||||
# Disclaimer
|
||||
|
||||
This application is only provided as an educational tool. The author is not liable in case the application is used to reverse engineer protocols protected by IP or for any other illegal purpose.
|
||||
|
||||
# Credits
|
||||
|
||||
A big thank you to the RTL433 author, [Benjamin Larsson](https://github.com/merbanan). I used the code and tools he developed in many ways:
|
||||
* To capture TPMS data with rtl433 and save to a file, to later play the IQ files and speedup the development.
|
||||
* As a sourve of documentation for protocols.
|
||||
* As an awesome way to visualize and understand protocols, via [these great web tools](https://triq.org/).
|
||||
* To have tons of fun with RTLSDR in general, now and in the past.
|
||||
362
applications/plugins/protoview/app.c
Normal file
362
applications/plugins/protoview/app.c
Normal file
@ -0,0 +1,362 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
|
||||
/* If this define is enabled, ProtoView is going to mess with the
|
||||
* otherwise opaque SubGhzWorker structure in order to disable
|
||||
* its filter for samples shorter than a given amount (30us at the
|
||||
* time I'm writing this comment).
|
||||
*
|
||||
* This structure must be taken in sync with the one of the firmware. */
|
||||
#define PROTOVIEW_DISABLE_SUBGHZ_FILTER 0
|
||||
|
||||
#ifdef PROTOVIEW_DISABLE_SUBGHZ_FILTER
|
||||
struct SubGhzWorker {
|
||||
FuriThread* thread;
|
||||
FuriStreamBuffer* stream;
|
||||
|
||||
volatile bool running;
|
||||
volatile bool overrun;
|
||||
|
||||
LevelDuration filter_level_duration;
|
||||
bool filter_running;
|
||||
uint16_t filter_duration;
|
||||
|
||||
SubGhzWorkerOverrunCallback overrun_callback;
|
||||
SubGhzWorkerPairCallback pair_callback;
|
||||
void* context;
|
||||
};
|
||||
#endif
|
||||
|
||||
RawSamplesBuffer *RawSamples, *DetectedSamples;
|
||||
extern const SubGhzProtocolRegistry protoview_protocol_registry;
|
||||
|
||||
/* Draw some text with a border. If the outside color is black and the inside
|
||||
* color is white, it just writes the border of the text, but the function can
|
||||
* also be used to write a bold variation of the font setting both the
|
||||
* colors to black, or alternatively to write a black text with a white
|
||||
* border so that it is visible if there are black stuff on the background. */
|
||||
/* The callback actually just passes the control to the actual active
|
||||
* view callback, after setting up basic stuff like cleaning the screen
|
||||
* and setting color to black. */
|
||||
static void render_callback(Canvas *const canvas, void *ctx) {
|
||||
ProtoViewApp *app = ctx;
|
||||
|
||||
/* Clear screen. */
|
||||
canvas_set_color(canvas, ColorWhite);
|
||||
canvas_draw_box(canvas, 0, 0, 127, 63);
|
||||
canvas_set_color(canvas, ColorBlack);
|
||||
canvas_set_font(canvas, FontPrimary);
|
||||
|
||||
/* Call who is in charge right now. */
|
||||
switch(app->current_view) {
|
||||
case ViewRawPulses: render_view_raw_pulses(canvas,app); break;
|
||||
case ViewInfo: render_view_info(canvas,app); break;
|
||||
case ViewFrequencySettings:
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/* Here all we do is putting the events into the queue that will be handled
|
||||
* in the while() loop of the app entry point function. */
|
||||
static void input_callback(InputEvent* input_event, void* ctx)
|
||||
{
|
||||
ProtoViewApp *app = ctx;
|
||||
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) {
|
||||
ProtoViewCurrentView old = app->current_view;
|
||||
if (dir == AppNextView) {
|
||||
app->current_view++;
|
||||
if (app->current_view == ViewLast) app->current_view = 0;
|
||||
} else if (dir == AppPrevView) {
|
||||
if (app->current_view == 0)
|
||||
app->current_view = ViewLast-1;
|
||||
else
|
||||
app->current_view--;
|
||||
}
|
||||
ProtoViewCurrentView new = app->current_view;
|
||||
|
||||
/* Call the enter/exit view callbacks if needed. */
|
||||
if (old == ViewDirectSampling) view_exit_direct_sampling(app);
|
||||
if (new == ViewDirectSampling) view_enter_direct_sampling(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);
|
||||
|
||||
/* Set the current subview of the view we just left to zero, that is
|
||||
* the main subview of the view. When re re-enter it we want to see
|
||||
* the main thing. */
|
||||
app->current_subview[old] = 0;
|
||||
memset(app->view_privdata,0,PROTOVIEW_VIEW_PRIVDATA_LEN);
|
||||
}
|
||||
|
||||
/* Allocate the application state and initialize a number of stuff.
|
||||
* This is called in the entry point to create the application state. */
|
||||
ProtoViewApp* protoview_app_alloc() {
|
||||
ProtoViewApp *app = malloc(sizeof(ProtoViewApp));
|
||||
|
||||
// Init shared data structures
|
||||
RawSamples = raw_samples_alloc();
|
||||
DetectedSamples = raw_samples_alloc();
|
||||
|
||||
//init setting
|
||||
app->setting = subghz_setting_alloc();
|
||||
subghz_setting_load(app->setting, EXT_PATH("subghz/assets/setting_user"));
|
||||
|
||||
// GUI
|
||||
app->gui = furi_record_open(RECORD_GUI);
|
||||
app->view_port = view_port_alloc();
|
||||
view_port_draw_callback_set(app->view_port, render_callback, app);
|
||||
view_port_input_callback_set(app->view_port, input_callback, app);
|
||||
gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen);
|
||||
app->event_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
|
||||
app->view_dispatcher = NULL;
|
||||
app->text_input = NULL;
|
||||
app->show_text_input = false;
|
||||
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;
|
||||
app->signal_last_scan_idx = 0;
|
||||
app->signal_decoded = false;
|
||||
app->us_scale = PROTOVIEW_RAW_VIEW_DEFAULT_SCALE;
|
||||
app->signal_offset = 0;
|
||||
app->msg_info = NULL;
|
||||
|
||||
// Init Worker & Protocol
|
||||
app->txrx = malloc(sizeof(ProtoViewTxRx));
|
||||
|
||||
/* Setup rx worker and environment. */
|
||||
app->txrx->freq_mod_changed = false;
|
||||
app->txrx->debug_timer_sampling = false;
|
||||
app->txrx->last_g0_change_time = DWT->CYCCNT;
|
||||
app->txrx->last_g0_value = false;
|
||||
app->txrx->worker = subghz_worker_alloc();
|
||||
#ifdef PROTOVIEW_DISABLE_SUBGHZ_FILTER
|
||||
app->txrx->worker->filter_running = 0;
|
||||
#endif
|
||||
app->txrx->environment = subghz_environment_alloc();
|
||||
subghz_environment_set_protocol_registry(
|
||||
app->txrx->environment, (void*)&protoview_protocol_registry);
|
||||
app->txrx->receiver =
|
||||
subghz_receiver_alloc_init(app->txrx->environment);
|
||||
subghz_receiver_set_filter(app->txrx->receiver,
|
||||
SubGhzProtocolFlag_Decodable);
|
||||
subghz_worker_set_overrun_callback(
|
||||
app->txrx->worker,
|
||||
(SubGhzWorkerOverrunCallback)subghz_receiver_reset);
|
||||
subghz_worker_set_pair_callback(
|
||||
app->txrx->worker, (SubGhzWorkerPairCallback)subghz_receiver_decode);
|
||||
subghz_worker_set_context(app->txrx->worker, app->txrx->receiver);
|
||||
|
||||
app->frequency = subghz_setting_get_default_frequency(app->setting);
|
||||
app->modulation = 0; /* Defaults to ProtoViewModulations[0]. */
|
||||
|
||||
furi_hal_power_suppress_charge_enter();
|
||||
app->running = 1;
|
||||
|
||||
return app;
|
||||
}
|
||||
|
||||
/* Free what the application allocated. It is not clear to me if the
|
||||
* Flipper OS, once the application exits, will be able to reclaim space
|
||||
* even if we forget to free something here. */
|
||||
void protoview_app_free(ProtoViewApp *app) {
|
||||
furi_assert(app);
|
||||
|
||||
// Put CC1101 on sleep.
|
||||
radio_sleep(app);
|
||||
|
||||
// View related.
|
||||
view_port_enabled_set(app->view_port, false);
|
||||
gui_remove_view_port(app->gui, app->view_port);
|
||||
view_port_free(app->view_port);
|
||||
furi_record_close(RECORD_GUI);
|
||||
furi_message_queue_free(app->event_queue);
|
||||
app->gui = NULL;
|
||||
|
||||
// Frequency setting.
|
||||
subghz_setting_free(app->setting);
|
||||
|
||||
// Worker stuff.
|
||||
if (!app->txrx->debug_timer_sampling) {
|
||||
subghz_receiver_free(app->txrx->receiver);
|
||||
subghz_environment_free(app->txrx->environment);
|
||||
subghz_worker_free(app->txrx->worker);
|
||||
}
|
||||
free(app->txrx);
|
||||
|
||||
// Raw samples buffers.
|
||||
raw_samples_free(RawSamples);
|
||||
raw_samples_free(DetectedSamples);
|
||||
furi_hal_power_suppress_charge_exit();
|
||||
|
||||
free(app);
|
||||
}
|
||||
|
||||
/* Called periodically. Do signal processing here. Data we process here
|
||||
* will be later displayed by the render callback. The side effect of this
|
||||
* function is to scan for signals and set DetectedSamples. */
|
||||
static void timer_callback(void *ctx) {
|
||||
ProtoViewApp *app = ctx;
|
||||
uint32_t delta, lastidx = app->signal_last_scan_idx;
|
||||
|
||||
/* scan_for_signal(), called by this function, deals with a
|
||||
* circular buffer. To never miss anything, even if a signal spawns
|
||||
* cross-boundaries, it is enough if we scan each time the buffer fills
|
||||
* for 50% more compared to the last scan. Thanks to this check we
|
||||
* can avoid scanning too many times to just find the same data. */
|
||||
if (lastidx < RawSamples->idx) {
|
||||
delta = RawSamples->idx - lastidx;
|
||||
} else {
|
||||
delta = RawSamples->total - lastidx + RawSamples->idx;
|
||||
}
|
||||
if (delta < RawSamples->total/2) return;
|
||||
app->signal_last_scan_idx = RawSamples->idx;
|
||||
scan_for_signal(app);
|
||||
}
|
||||
|
||||
int32_t protoview_app_entry(void* p) {
|
||||
UNUSED(p);
|
||||
ProtoViewApp *app = protoview_app_alloc();
|
||||
|
||||
/* Create a timer. We do data analysis in the callback. */
|
||||
FuriTimer *timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, app);
|
||||
furi_timer_start(timer, furi_kernel_get_tick_frequency() / 8);
|
||||
|
||||
/* Start listening to signals immediately. */
|
||||
radio_begin(app);
|
||||
radio_rx(app);
|
||||
|
||||
/* This is the main event loop: here we get the events that are pushed
|
||||
* in the queue by input_callback(), and process them one after the
|
||||
* other. The timeout is 100 milliseconds, so if not input is received
|
||||
* before such time, we exit the queue_get() function and call
|
||||
* view_port_update() in order to refresh our screen content. */
|
||||
InputEvent input;
|
||||
while(app->running) {
|
||||
FuriStatus qstat = furi_message_queue_get(app->event_queue, &input, 100);
|
||||
if (qstat == FuriStatusOk) {
|
||||
if (DEBUG_MSG) FURI_LOG_E(TAG, "Main Loop - Input: type %d key %u",
|
||||
input.type, input.key);
|
||||
|
||||
/* Handle navigation here. Then handle view-specific inputs
|
||||
* in the view specific handling function. */
|
||||
if (input.type == InputTypeShort &&
|
||||
input.key == InputKeyBack)
|
||||
{
|
||||
/* Exit the app. */
|
||||
app->running = 0;
|
||||
} else if (input.type == InputTypeShort &&
|
||||
input.key == InputKeyRight &&
|
||||
get_current_subview(app) == 0)
|
||||
{
|
||||
/* Go to the next view. */
|
||||
app_switch_view(app,AppNextView);
|
||||
} else if (input.type == InputTypeShort &&
|
||||
input.key == InputKeyLeft &&
|
||||
get_current_subview(app) == 0)
|
||||
{
|
||||
/* Go to the previous view. */
|
||||
app_switch_view(app,AppPrevView);
|
||||
} else {
|
||||
/* This is where we pass the control to the currently
|
||||
* active view input processing. */
|
||||
switch(app->current_view) {
|
||||
case ViewRawPulses:
|
||||
process_input_raw_pulses(app,input);
|
||||
break;
|
||||
case ViewInfo:
|
||||
process_input_info(app,input);
|
||||
break;
|
||||
case ViewFrequencySettings:
|
||||
case ViewModulationSettings:
|
||||
process_input_settings(app,input);
|
||||
break;
|
||||
case ViewDirectSampling:
|
||||
process_input_direct_sampling(app,input);
|
||||
break;
|
||||
case ViewLast: furi_crash(TAG " ViewLast selected"); break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Useful to understand if the app is still alive when it
|
||||
* does not respond because of bugs. */
|
||||
if (DEBUG_MSG) {
|
||||
static int c = 0; c++;
|
||||
if (!(c % 20)) FURI_LOG_E(TAG, "Loop timeout");
|
||||
}
|
||||
}
|
||||
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);
|
||||
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. */
|
||||
if (app->txrx->txrx_state == TxRxStateRx) {
|
||||
FURI_LOG_E(TAG, "Putting CC1101 to sleep before exiting.");
|
||||
radio_rx_end(app);
|
||||
radio_sleep(app);
|
||||
}
|
||||
|
||||
furi_timer_free(timer);
|
||||
protoview_app_free(app);
|
||||
return 0;
|
||||
}
|
||||
|
||||
231
applications/plugins/protoview/app.h
Normal file
231
applications/plugins/protoview/app.h
Normal file
@ -0,0 +1,231 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <furi.h>
|
||||
#include <furi_hal.h>
|
||||
#include <input/input.h>
|
||||
#include <gui/gui.h>
|
||||
#include <stdlib.h>
|
||||
#include <gui/gui.h>
|
||||
#include <gui/view_dispatcher.h>
|
||||
#include <gui/scene_manager.h>
|
||||
#include <gui/modules/submenu.h>
|
||||
#include <gui/modules/variable_item_list.h>
|
||||
#include <gui/modules/widget.h>
|
||||
#include <gui/modules/text_input.h>
|
||||
#include <notification/notification_messages.h>
|
||||
#include <lib/subghz/subghz_setting.h>
|
||||
#include <lib/subghz/subghz_worker.h>
|
||||
#include <lib/subghz/receiver.h>
|
||||
#include <lib/subghz/transmitter.h>
|
||||
#include <lib/subghz/registry.h>
|
||||
#include "app_buffer.h"
|
||||
|
||||
#define TAG "ProtoView"
|
||||
#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
|
||||
|
||||
typedef struct ProtoViewApp ProtoViewApp;
|
||||
|
||||
/* Subghz system state */
|
||||
typedef enum {
|
||||
TxRxStateIDLE,
|
||||
TxRxStateRx,
|
||||
TxRxStateSleep,
|
||||
} TxRxState;
|
||||
|
||||
/* Currently active view. */
|
||||
typedef enum {
|
||||
ViewRawPulses,
|
||||
ViewInfo,
|
||||
ViewFrequencySettings,
|
||||
ViewModulationSettings,
|
||||
ViewDirectSampling,
|
||||
ViewLast, /* Just a sentinel to wrap around. */
|
||||
} ProtoViewCurrentView;
|
||||
|
||||
/* Used by app_switch_view() */
|
||||
typedef enum {
|
||||
AppNextView,
|
||||
AppPrevView
|
||||
} SwitchViewDirection;
|
||||
|
||||
typedef struct {
|
||||
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 */
|
||||
|
||||
/* This is the context of our subghz worker and associated thread.
|
||||
* It receives data and we get our protocol "feed" callback called
|
||||
* with the level (1 or 0) and duration. */
|
||||
struct ProtoViewTxRx {
|
||||
bool freq_mod_changed; /* The user changed frequency and/or modulation
|
||||
from the interface. There is to restart the
|
||||
radio with the right parameters. */
|
||||
SubGhzWorker* worker; /* Our background worker. */
|
||||
SubGhzEnvironment* environment;
|
||||
SubGhzReceiver* receiver;
|
||||
TxRxState txrx_state; /* Receiving, idle or sleeping? */
|
||||
|
||||
/* Timer sampling mode state. */
|
||||
bool debug_timer_sampling; /* Read data from GDO0 in a busy loop. Only
|
||||
for testing. */
|
||||
uint32_t last_g0_change_time; /* Last high->low (or reverse) switch. */
|
||||
bool last_g0_value; /* Current value (high or low): we are
|
||||
checking the duration in the timer
|
||||
handler. */
|
||||
};
|
||||
|
||||
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. */
|
||||
/* 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;
|
||||
|
||||
struct ProtoViewApp {
|
||||
/* GUI */
|
||||
Gui *gui;
|
||||
ViewPort *view_port; /* We just use a raw viewport and we render
|
||||
everything into the low level canvas. */
|
||||
ProtoViewCurrentView current_view; /* Active left-right view ID. */
|
||||
int current_subview[ViewLast]; /* Active up-down subview ID. */
|
||||
FuriMessageQueue *event_queue; /* Keypress events go here. */
|
||||
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*);
|
||||
|
||||
/* Radio related. */
|
||||
ProtoViewTxRx *txrx; /* Radio state. */
|
||||
SubGhzSetting *setting; /* A list of valid frequencies. */
|
||||
|
||||
/* Generic app state. */
|
||||
int running; /* Once false exists the app. */
|
||||
uint32_t signal_bestlen; /* Longest coherent signal observed so far. */
|
||||
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 *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. */
|
||||
uint32_t signal_offset; /* Long press left/right panning in raw view. */
|
||||
|
||||
/* Configuration view app state. */
|
||||
uint32_t frequency; /* Current frequency. */
|
||||
uint8_t modulation; /* Current modulation ID, array index in the
|
||||
ProtoViewModulations table. */
|
||||
};
|
||||
|
||||
typedef struct ProtoViewDecoder {
|
||||
const char *name; /* Protocol name. */
|
||||
/* The decode function takes a buffer that is actually a bitmap, with
|
||||
* high and low levels represented as 0 and 1. The number of high/low
|
||||
* pulses represented by the bitmap is passed as the 'numbits' argument,
|
||||
* while 'numbytes' represents the total size of the bitmap pointed by
|
||||
* 'bits'. So 'numbytes' is mainly useful to pass as argument to other
|
||||
* 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);
|
||||
} ProtoViewDecoder;
|
||||
|
||||
extern RawSamplesBuffer *RawSamples, *DetectedSamples;
|
||||
|
||||
/* app_radio.c */
|
||||
void radio_begin(ProtoViewApp* app);
|
||||
uint32_t radio_rx(ProtoViewApp* app);
|
||||
void radio_idle(ProtoViewApp* app);
|
||||
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);
|
||||
|
||||
/* signal.c */
|
||||
uint32_t duration_delta(uint32_t a, uint32_t b);
|
||||
void reset_current_signal(ProtoViewApp *app);
|
||||
void scan_for_signal(ProtoViewApp *app);
|
||||
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_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(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);
|
||||
void process_input_raw_pulses(ProtoViewApp *app, InputEvent input);
|
||||
void render_view_settings(Canvas *const canvas, ProtoViewApp *app);
|
||||
void process_input_settings(ProtoViewApp *app, InputEvent input);
|
||||
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 view_enter_direct_sampling(ProtoViewApp *app);
|
||||
void view_exit_direct_sampling(ProtoViewApp *app);
|
||||
void view_exit_settings(ProtoViewApp *app);
|
||||
|
||||
/* ui.c */
|
||||
int get_current_subview(ProtoViewApp *app);
|
||||
void show_available_subviews(Canvas *canvas, ProtoViewApp *app, int last_subview);
|
||||
bool process_subview_updown(ProtoViewApp *app, InputEvent input, int last_subview);
|
||||
void canvas_draw_str_with_border(Canvas* canvas, uint8_t x, uint8_t y, const char* str, Color text_color, Color border_color);
|
||||
void show_keyboard(ProtoViewApp *app, char *buffer, uint32_t buflen,
|
||||
void (*done_callback)(void*));
|
||||
void dismiss_keyboard(ProtoViewApp *app);
|
||||
|
||||
/* crc.c */
|
||||
uint8_t crc8(const uint8_t *data, size_t len, uint8_t init, uint8_t poly);
|
||||
71
applications/plugins/protoview/app_buffer.c
Normal file
71
applications/plugins/protoview/app_buffer.c
Normal file
@ -0,0 +1,71 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <furi/core/string.h>
|
||||
#include <furi.h>
|
||||
#include <furi_hal.h>
|
||||
#include "app_buffer.h"
|
||||
|
||||
/* Allocate and initialize a samples buffer. */
|
||||
RawSamplesBuffer *raw_samples_alloc(void) {
|
||||
RawSamplesBuffer *buf = malloc(sizeof(*buf));
|
||||
buf->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
|
||||
raw_samples_reset(buf);
|
||||
return buf;
|
||||
}
|
||||
|
||||
/* Free a sample buffer. Should be called when the mutex is released. */
|
||||
void raw_samples_free(RawSamplesBuffer *s) {
|
||||
furi_mutex_free(s->mutex);
|
||||
free(s);
|
||||
}
|
||||
|
||||
/* This just set all the samples to zero and also resets the internal
|
||||
* index. There is no need to call it after raw_samples_alloc(), but only
|
||||
* when one wants to reset the whole buffer of samples. */
|
||||
void raw_samples_reset(RawSamplesBuffer *s) {
|
||||
furi_mutex_acquire(s->mutex,FuriWaitForever);
|
||||
s->total = RAW_SAMPLES_NUM;
|
||||
s->idx = 0;
|
||||
s->short_pulse_dur = 0;
|
||||
memset(s->samples,0,sizeof(s->samples));
|
||||
furi_mutex_release(s->mutex);
|
||||
}
|
||||
|
||||
/* Set the raw sample internal index so that what is currently at
|
||||
* offset 'offset', will appear to be at 0 index. */
|
||||
void raw_samples_center(RawSamplesBuffer *s, uint32_t offset) {
|
||||
s->idx = (s->idx+offset) % RAW_SAMPLES_NUM;
|
||||
}
|
||||
|
||||
/* Add the specified sample in the circular buffer. */
|
||||
void raw_samples_add(RawSamplesBuffer *s, bool level, uint32_t dur) {
|
||||
furi_mutex_acquire(s->mutex,FuriWaitForever);
|
||||
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)
|
||||
{
|
||||
furi_mutex_acquire(s->mutex,FuriWaitForever);
|
||||
idx = (s->idx + idx) % RAW_SAMPLES_NUM;
|
||||
*level = s->samples[idx].level;
|
||||
*dur = s->samples[idx].dur;
|
||||
furi_mutex_release(s->mutex);
|
||||
}
|
||||
|
||||
/* Copy one buffer to the other, including current index. */
|
||||
void raw_samples_copy(RawSamplesBuffer *dst, RawSamplesBuffer *src) {
|
||||
furi_mutex_acquire(src->mutex,FuriWaitForever);
|
||||
furi_mutex_acquire(dst->mutex,FuriWaitForever);
|
||||
dst->idx = src->idx;
|
||||
dst->short_pulse_dur = src->short_pulse_dur;
|
||||
memcpy(dst->samples,src->samples,sizeof(dst->samples));
|
||||
furi_mutex_release(src->mutex);
|
||||
furi_mutex_release(dst->mutex);
|
||||
}
|
||||
31
applications/plugins/protoview/app_buffer.h
Normal file
31
applications/plugins/protoview/app_buffer.h
Normal file
@ -0,0 +1,31 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
/* Our circular buffer of raw samples, used in order to display
|
||||
* the signal. */
|
||||
|
||||
#define RAW_SAMPLES_NUM 2048 /* Use a power of two: we take the modulo
|
||||
of the index quite often to normalize inside
|
||||
the range, and division is slow. */
|
||||
typedef struct RawSamplesBuffer {
|
||||
FuriMutex *mutex;
|
||||
struct {
|
||||
uint16_t level:1;
|
||||
uint16_t dur:15;
|
||||
} samples[RAW_SAMPLES_NUM];
|
||||
uint32_t idx; /* Current idx (next to write). */
|
||||
uint32_t total; /* Total samples: same as RAW_SAMPLES_NUM, we provide
|
||||
this field for a cleaner interface with the user, but
|
||||
we always use RAW_SAMPLES_NUM when taking the modulo so
|
||||
the compiler can optimize % as bit masking. */
|
||||
/* Signal features. */
|
||||
uint32_t short_pulse_dur; /* Duration of the shortest pulse. */
|
||||
} RawSamplesBuffer;
|
||||
|
||||
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_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);
|
||||
157
applications/plugins/protoview/app_subghz.c
Normal file
157
applications/plugins/protoview/app_subghz.c
Normal file
@ -0,0 +1,157 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
#include "custom_presets.h"
|
||||
|
||||
#include <flipper_format/flipper_format_i.h>
|
||||
#include <furi_hal_rtc.h>
|
||||
#include <furi_hal_spi.h>
|
||||
#include <furi_hal_interrupt.h>
|
||||
|
||||
void raw_sampling_worker_start(ProtoViewApp *app);
|
||||
void raw_sampling_worker_stop(ProtoViewApp *app);
|
||||
|
||||
ProtoViewModulation ProtoViewModulations[] = {
|
||||
{"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
|
||||
* subghz system and put it into idle state. If the user wants to start
|
||||
* receiving we will call radio_rx() to start a receiving worker and
|
||||
* associated thread. */
|
||||
void radio_begin(ProtoViewApp* app) {
|
||||
furi_assert(app);
|
||||
furi_hal_subghz_reset();
|
||||
furi_hal_subghz_idle();
|
||||
|
||||
/* 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);
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
|
||||
app->txrx->txrx_state = TxRxStateIDLE;
|
||||
}
|
||||
|
||||
/* Setup subghz to start receiving using a background worker. */
|
||||
uint32_t radio_rx(ProtoViewApp* app) {
|
||||
furi_assert(app);
|
||||
if(!furi_hal_subghz_is_frequency_valid(app->frequency)) {
|
||||
furi_crash(TAG" Incorrect RX frequency.");
|
||||
}
|
||||
|
||||
if (app->txrx->txrx_state == TxRxStateRx) return app->frequency;
|
||||
|
||||
furi_hal_subghz_idle(); /* Put it into idle state in case it is sleeping. */
|
||||
uint32_t value = furi_hal_subghz_set_frequency_and_path(app->frequency);
|
||||
FURI_LOG_E(TAG, "Switched to frequency: %lu", value);
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_subghz_flush_rx();
|
||||
furi_hal_subghz_rx();
|
||||
if (!app->txrx->debug_timer_sampling) {
|
||||
|
||||
furi_hal_subghz_start_async_rx(subghz_worker_rx_callback,
|
||||
app->txrx->worker);
|
||||
subghz_worker_start(app->txrx->worker);
|
||||
} else {
|
||||
raw_sampling_worker_start(app);
|
||||
}
|
||||
app->txrx->txrx_state = TxRxStateRx;
|
||||
return value;
|
||||
}
|
||||
|
||||
/* 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)) {
|
||||
subghz_worker_stop(app->txrx->worker);
|
||||
furi_hal_subghz_stop_async_rx();
|
||||
}
|
||||
} else {
|
||||
raw_sampling_worker_stop(app);
|
||||
}
|
||||
}
|
||||
furi_hal_subghz_idle();
|
||||
app->txrx->txrx_state = TxRxStateIDLE;
|
||||
}
|
||||
|
||||
/* Put radio on sleep. */
|
||||
void radio_sleep(ProtoViewApp* app) {
|
||||
furi_assert(app);
|
||||
if (app->txrx->txrx_state == TxRxStateRx) {
|
||||
/* We can't go from having an active RX worker to sleeping.
|
||||
* Stop the RX subsystems first. */
|
||||
radio_rx_end(app);
|
||||
}
|
||||
furi_hal_subghz_sleep();
|
||||
app->txrx->txrx_state = TxRxStateSleep;
|
||||
}
|
||||
|
||||
/* ============================= Raw sampling mode =============================
|
||||
* This is a special mode that uses a high frequency timer to sample the
|
||||
* CC1101 pin directly. It's useful for debugging purposes when we want
|
||||
* to get the raw data from the chip and completely bypass the subghz
|
||||
* Flipper system.
|
||||
* ===========================================================================*/
|
||||
|
||||
void protoview_timer_isr(void *ctx) {
|
||||
ProtoViewApp *app = ctx;
|
||||
|
||||
bool level = furi_hal_gpio_read(&gpio_cc1101_g0);
|
||||
if (app->txrx->last_g0_value != level) {
|
||||
uint32_t now = DWT->CYCCNT;
|
||||
uint32_t dur = now - app->txrx->last_g0_change_time;
|
||||
dur /= furi_hal_cortex_instructions_per_microsecond();
|
||||
if (dur > 15000) dur = 15000;
|
||||
raw_samples_add(RawSamples, app->txrx->last_g0_value, dur);
|
||||
app->txrx->last_g0_value = level;
|
||||
app->txrx->last_g0_change_time = now;
|
||||
}
|
||||
LL_TIM_ClearFlag_UPDATE(TIM2);
|
||||
}
|
||||
|
||||
void raw_sampling_worker_start(ProtoViewApp *app) {
|
||||
UNUSED(app);
|
||||
|
||||
LL_TIM_InitTypeDef tim_init = {
|
||||
.Prescaler = 63, /* CPU frequency is ~64Mhz. */
|
||||
.CounterMode = LL_TIM_COUNTERMODE_UP,
|
||||
.Autoreload = 5, /* Sample every 5 us */
|
||||
};
|
||||
|
||||
LL_TIM_Init(TIM2, &tim_init);
|
||||
LL_TIM_SetClockSource(TIM2, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_DisableCounter(TIM2);
|
||||
LL_TIM_SetCounter(TIM2, 0);
|
||||
furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, protoview_timer_isr, app);
|
||||
LL_TIM_EnableIT_UPDATE(TIM2);
|
||||
LL_TIM_EnableCounter(TIM2);
|
||||
FURI_LOG_E(TAG, "Timer enabled");
|
||||
}
|
||||
|
||||
void raw_sampling_worker_stop(ProtoViewApp *app) {
|
||||
UNUSED(app);
|
||||
FURI_CRITICAL_ENTER();
|
||||
LL_TIM_DisableCounter(TIM2);
|
||||
LL_TIM_DisableIT_UPDATE(TIM2);
|
||||
furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, NULL, NULL);
|
||||
LL_TIM_DeInit(TIM2);
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
BIN
applications/plugins/protoview/appicon.png
Normal file
BIN
applications/plugins/protoview/appicon.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 116 B |
12
applications/plugins/protoview/application.fam
Normal file
12
applications/plugins/protoview/application.fam
Normal file
@ -0,0 +1,12 @@
|
||||
App(
|
||||
appid="protoview",
|
||||
name="ProtoView",
|
||||
apptype=FlipperAppType.EXTERNAL,
|
||||
entry_point="protoview_app_entry",
|
||||
cdefines=["APP_PROTOVIEW"],
|
||||
requires=["gui"],
|
||||
stack_size=8*1024,
|
||||
order=50,
|
||||
fap_icon="appicon.png",
|
||||
fap_category="Tools",
|
||||
)
|
||||
10
applications/plugins/protoview/binaries/README.md
Normal file
10
applications/plugins/protoview/binaries/README.md
Normal file
@ -0,0 +1,10 @@
|
||||
This is the binary distribution of the application. If you don't want
|
||||
to build it from source, just take `protoview.fap` file and drop it into the
|
||||
following Flipper Zero location:
|
||||
|
||||
/ext/apps/Tools
|
||||
|
||||
The `ext` part means that we are in the SD card. So if you don't want
|
||||
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.
|
||||
BIN
applications/plugins/protoview/binaries/protoview.fap
Normal file
BIN
applications/plugins/protoview/binaries/protoview.fap
Normal file
Binary file not shown.
4
applications/plugins/protoview/binaries/update.sh
Executable file
4
applications/plugins/protoview/binaries/update.sh
Executable file
@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
BINPATH="/Users/antirez/hack/flipper/official/build/f7-firmware-D/.extapps/protoview.fap"
|
||||
cp $BINPATH .
|
||||
git commit -a -m 'Binary file updated.'
|
||||
20
applications/plugins/protoview/crc.c
Normal file
20
applications/plugins/protoview/crc.c
Normal file
@ -0,0 +1,20 @@
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
/* CRC8 with the specified initialization value 'init' and
|
||||
* polynomial 'poly'. */
|
||||
uint8_t crc8(const uint8_t *data, size_t len, uint8_t init, uint8_t poly)
|
||||
{
|
||||
uint8_t crc = init;
|
||||
size_t i, j;
|
||||
for (i = 0; i < len; i++) {
|
||||
crc ^= data[i];
|
||||
for (j = 0; j < 8; j++) {
|
||||
if ((crc & 0x80) != 0)
|
||||
crc = (uint8_t)((crc << 1) ^ poly);
|
||||
else
|
||||
crc <<= 1;
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
}
|
||||
244
applications/plugins/protoview/custom_presets.h
Normal file
244
applications/plugins/protoview/custom_presets.h
Normal file
@ -0,0 +1,244 @@
|
||||
#include <cc1101.h>
|
||||
|
||||
/* ========================== DATA RATE SETTINGS ===============================
|
||||
*
|
||||
* This is how to configure registers MDMCFG3 and MDMCFG4.
|
||||
*
|
||||
* MDMCFG3 is the data rate mantissa, the exponent is in MDMCFG4,
|
||||
* last 4 bits of the register.
|
||||
*
|
||||
* The rate (assuming 26Mhz crystal) is calculated as follows:
|
||||
*
|
||||
* ((256+MDMCFG3)*(2^MDMCFG4:0..3bits)) / 2^28 * 26000000.
|
||||
*
|
||||
* For instance for the default values of MDMCFG3[0..3] (34) and MDMCFG4 (12):
|
||||
*
|
||||
* ((256+34)*(2^12))/(2^28)*26000000 = 115051.2688000000, that is 115KBaud
|
||||
*
|
||||
* ============================ BANDWIDTH FILTER ===============================
|
||||
*
|
||||
* Bandwidth filter setting:
|
||||
*
|
||||
* BW filter as just 16 possibilities depending on how the first nibble
|
||||
* (first 4 bits) of the MDMCFG4 bits are set. Instead of providing the
|
||||
* formula, it is simpler to show all the values of the nibble and the
|
||||
* corresponding bandwidth filter.
|
||||
*
|
||||
* 0 812khz
|
||||
* 1 650khz
|
||||
* 2 541khz
|
||||
* 3 464khz
|
||||
* 4 406khz
|
||||
* 5 325khz
|
||||
* 6 270khz
|
||||
* 7 232khz
|
||||
* 8 203khz
|
||||
* 9 162khz
|
||||
* a 135khz
|
||||
* b 116khz
|
||||
* c 102khz
|
||||
* d 82 khz
|
||||
* e 68 khz
|
||||
* f 58 khz
|
||||
*
|
||||
* ============================== FSK DEVIATION ================================
|
||||
*
|
||||
* FSK deviation is controlled by the DEVIATION register. In Ruby:
|
||||
*
|
||||
* dev = (26000000.0/2**17)*(8+(deviation&7))*(2**(deviation>>4&7))
|
||||
*
|
||||
* deviation&7 (last three bits) is the deviation mantissa, while
|
||||
* deviation>>4&7 (bits 6,5,4) are the exponent.
|
||||
*
|
||||
* Deviations values according to certain configuration of DEVIATION:
|
||||
*
|
||||
* 0x04 -> 2.380371 kHz
|
||||
* 0x24 -> 9.521484 kHz
|
||||
* 0x34 -> 19.042969 Khz
|
||||
* 0x40 -> 25.390625 Khz
|
||||
* 0x43 -> 34.912109 Khz
|
||||
* 0x45 -> 41.259765 Khz
|
||||
* 0x47 -> 47.607422 kHz
|
||||
*/
|
||||
|
||||
/* 20 KBaud, 2FSK, 28.56 kHz deviation, 325 Khz bandwidth filter. */
|
||||
static uint8_t protoview_subghz_tpms1_fsk_async_regs[][2] = {
|
||||
/* GPIO GD0 */
|
||||
{CC1101_IOCFG0, 0x0D}, // GD0 as async serial data output/input
|
||||
|
||||
/* Frequency Synthesizer Control */
|
||||
{CC1101_FSCTRL1, 0x06}, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
|
||||
|
||||
/* Packet engine */
|
||||
{CC1101_PKTCTRL0, 0x32}, // Async, continious, no whitening
|
||||
{CC1101_PKTCTRL1, 0x04},
|
||||
|
||||
// // Modem Configuration
|
||||
{CC1101_MDMCFG0, 0x00},
|
||||
{CC1101_MDMCFG1, 0x02},
|
||||
{CC1101_MDMCFG2, 0x04}, // Format 2-FSK/FM, No preamble/sync, Disable (current optimized). Other code reading TPMS uses GFSK, but should be the same when in RX mode.
|
||||
{CC1101_MDMCFG3, 0x93}, // Data rate is 20kBaud
|
||||
{CC1101_MDMCFG4, 0x59}, // Rx bandwidth filter is 325 kHz
|
||||
{CC1101_DEVIATN, 0x41}, // Deviation 28.56 kHz
|
||||
|
||||
/* Main Radio Control State Machine */
|
||||
{CC1101_MCSM0, 0x18}, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
|
||||
|
||||
/* Frequency Offset Compensation Configuration */
|
||||
{CC1101_FOCCFG,
|
||||
0x16}, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
|
||||
|
||||
/* Automatic Gain Control */
|
||||
{CC1101_AGCCTRL0,
|
||||
0x91}, //10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
|
||||
{CC1101_AGCCTRL1,
|
||||
0x00}, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
|
||||
{CC1101_AGCCTRL2, 0x07}, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
|
||||
|
||||
/* Wake on radio and timeouts control */
|
||||
{CC1101_WORCTRL, 0xFB}, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
|
||||
|
||||
/* Frontend configuration */
|
||||
{CC1101_FREND0, 0x10}, // Adjusts current TX LO buffer
|
||||
{CC1101_FREND1, 0x56},
|
||||
|
||||
/* End */
|
||||
{0, 0},
|
||||
};
|
||||
|
||||
/* This is like the default Flipper OOK 640Khz bandwidth preset, but
|
||||
* the bandwidth is changed to 10kBaud to accomodate TPMS frequency. */
|
||||
static const uint8_t protoview_subghz_tpms2_ook_async_regs[][2] = {
|
||||
/* GPIO GD0 */
|
||||
{CC1101_IOCFG0, 0x0D}, // GD0 as async serial data output/input
|
||||
|
||||
/* FIFO and internals */
|
||||
{CC1101_FIFOTHR, 0x07}, // The only important bit is ADC_RETENTION
|
||||
|
||||
/* Packet engine */
|
||||
{CC1101_PKTCTRL0, 0x32}, // Async, continious, no whitening
|
||||
|
||||
/* Frequency Synthesizer Control */
|
||||
{CC1101_FSCTRL1, 0x06}, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
|
||||
|
||||
// Modem Configuration
|
||||
{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
|
||||
|
||||
/* Main Radio Control State Machine */
|
||||
{CC1101_MCSM0, 0x18}, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
|
||||
|
||||
/* Frequency Offset Compensation Configuration */
|
||||
{CC1101_FOCCFG,
|
||||
0x18}, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
|
||||
|
||||
/* Automatic Gain Control */
|
||||
{CC1101_AGCCTRL0,
|
||||
0x91}, // 10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
|
||||
{CC1101_AGCCTRL1,
|
||||
0x0}, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
|
||||
{CC1101_AGCCTRL2, 0x07}, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
|
||||
|
||||
/* Wake on radio and timeouts control */
|
||||
{CC1101_WORCTRL, 0xFB}, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
|
||||
|
||||
/* Frontend configuration */
|
||||
{CC1101_FREND0, 0x11}, // Adjusts current TX LO buffer + high is PATABLE[1]
|
||||
{CC1101_FREND1, 0xB6}, //
|
||||
|
||||
/* End */
|
||||
{0, 0},
|
||||
};
|
||||
|
||||
/* 40 KBaud, 2FSK, 28 kHz deviation, 270 Khz bandwidth filter. */
|
||||
static uint8_t protoview_subghz_tpms3_fsk_async_regs[][2] = {
|
||||
/* GPIO GD0 */
|
||||
{CC1101_IOCFG0, 0x0D}, // GD0 as async serial data output/input
|
||||
|
||||
/* Frequency Synthesizer Control */
|
||||
{CC1101_FSCTRL1, 0x06}, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
|
||||
|
||||
/* Packet engine */
|
||||
{CC1101_PKTCTRL0, 0x32}, // Async, continious, no whitening
|
||||
{CC1101_PKTCTRL1, 0x04},
|
||||
|
||||
// // Modem Configuration
|
||||
{CC1101_MDMCFG0, 0x00},
|
||||
{CC1101_MDMCFG1, 0x02},
|
||||
{CC1101_MDMCFG2, 0x04}, // Format 2-FSK/FM, No preamble/sync, Disable (current optimized). Other code reading TPMS uses GFSK, but should be the same when in RX mode.
|
||||
{CC1101_MDMCFG3, 0x93}, // Data rate is 40kBaud
|
||||
{CC1101_MDMCFG4, 0x6A}, // 6 = BW filter 270kHz, A = Data rate exp
|
||||
{CC1101_DEVIATN, 0x41}, // Deviation 28kHz
|
||||
|
||||
/* Main Radio Control State Machine */
|
||||
{CC1101_MCSM0, 0x18}, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
|
||||
|
||||
/* Frequency Offset Compensation Configuration */
|
||||
{CC1101_FOCCFG,
|
||||
0x16}, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
|
||||
|
||||
/* Automatic Gain Control */
|
||||
{CC1101_AGCCTRL0,
|
||||
0x91}, //10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
|
||||
{CC1101_AGCCTRL1,
|
||||
0x00}, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
|
||||
{CC1101_AGCCTRL2, 0x07}, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
|
||||
|
||||
/* Wake on radio and timeouts control */
|
||||
{CC1101_WORCTRL, 0xFB}, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
|
||||
|
||||
/* Frontend configuration */
|
||||
{CC1101_FREND0, 0x10}, // Adjusts current TX LO buffer
|
||||
{CC1101_FREND1, 0x56},
|
||||
|
||||
/* End */
|
||||
{0, 0},
|
||||
};
|
||||
|
||||
/* FSK 19k dev, 325 Khz filter, 20kBaud. Works well with Toyota. */
|
||||
static uint8_t protoview_subghz_tpms4_fsk_async_regs[][2] = {
|
||||
/* GPIO GD0 */
|
||||
{CC1101_IOCFG0, 0x0D}, // GD0 as async serial data output/input
|
||||
|
||||
/* Frequency Synthesizer Control */
|
||||
{CC1101_FSCTRL1, 0x06}, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
|
||||
|
||||
/* Packet engine */
|
||||
{CC1101_PKTCTRL0, 0x32}, // Async, continious, no whitening
|
||||
{CC1101_PKTCTRL1, 0x04},
|
||||
|
||||
// // Modem Configuration
|
||||
{CC1101_MDMCFG0, 0x00},
|
||||
{CC1101_MDMCFG1, 0x02}, // 2 is the channel spacing exponet: not used
|
||||
{CC1101_MDMCFG2, 0x10}, // GFSK without any other check
|
||||
{CC1101_MDMCFG3, 0x93}, // Data rate is 20kBaud
|
||||
{CC1101_MDMCFG4, 0x59}, // Rx bandwidth filter is 325 kHz
|
||||
{CC1101_DEVIATN, 0x34}, // Deviation 19.04 Khz.
|
||||
|
||||
/* Main Radio Control State Machine */
|
||||
{CC1101_MCSM0, 0x18}, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
|
||||
|
||||
/* Frequency Offset Compensation Configuration */
|
||||
{CC1101_FOCCFG,
|
||||
0x16}, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
|
||||
|
||||
/* Automatic Gain Control */
|
||||
{CC1101_AGCCTRL0, 0x80},
|
||||
{CC1101_AGCCTRL1, 0x58},
|
||||
{CC1101_AGCCTRL2, 0x87},
|
||||
|
||||
/* Wake on radio and timeouts control */
|
||||
{CC1101_WORCTRL, 0xFB}, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
|
||||
|
||||
/* Frontend configuration */
|
||||
{CC1101_FREND0, 0x10}, // Adjusts current TX LO buffer
|
||||
{CC1101_FREND1, 0x56},
|
||||
|
||||
/* End */
|
||||
{0, 0},
|
||||
};
|
||||
|
||||
|
||||
120
applications/plugins/protoview/data_feed.c
Normal file
120
applications/plugins/protoview/data_feed.c
Normal file
@ -0,0 +1,120 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <lib/flipper_format/flipper_format_i.h>
|
||||
#include <furi/core/string.h>
|
||||
#include <lib/subghz/registry.h>
|
||||
#include <lib/subghz/protocols/base.h>
|
||||
#include "app_buffer.h"
|
||||
|
||||
#define TAG "PROTOVIEW-protocol"
|
||||
|
||||
const SubGhzProtocol subghz_protocol_protoview;
|
||||
|
||||
/* The feed() method puts data in the RawSamples global (protected by
|
||||
* a mutex). */
|
||||
extern RawSamplesBuffer *RawSamples;
|
||||
|
||||
/* This is totally dummy: we just define the decoder base for the async
|
||||
* system to work but we don't really use it if not to collect raw
|
||||
* data via the feed() method. */
|
||||
typedef struct SubGhzProtocolDecoderprotoview {
|
||||
SubGhzProtocolDecoderBase base;
|
||||
} SubGhzProtocolDecoderprotoview;
|
||||
|
||||
void* subghz_protocol_decoder_protoview_alloc(SubGhzEnvironment* environment) {
|
||||
UNUSED(environment);
|
||||
|
||||
SubGhzProtocolDecoderprotoview* instance =
|
||||
malloc(sizeof(SubGhzProtocolDecoderprotoview));
|
||||
instance->base.protocol = &subghz_protocol_protoview;
|
||||
return instance;
|
||||
}
|
||||
|
||||
void subghz_protocol_decoder_protoview_free(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderprotoview* instance = context;
|
||||
free(instance);
|
||||
}
|
||||
|
||||
void subghz_protocol_decoder_protoview_reset(void* context) {
|
||||
furi_assert(context);
|
||||
}
|
||||
|
||||
/* That's the only thig we really use of the protocol decoder
|
||||
* implementation. We avoid the subghz provided abstractions and put
|
||||
* the data in our simple abstraction: the RawSamples circular buffer. */
|
||||
void subghz_protocol_decoder_protoview_feed(void* context, bool level, uint32_t duration) {
|
||||
furi_assert(context);
|
||||
UNUSED(context);
|
||||
|
||||
/* Add data to the circular buffer. */
|
||||
raw_samples_add(RawSamples, level, duration);
|
||||
// FURI_LOG_E(TAG, "FEED: %d %d", (int)level, (int)duration);
|
||||
return;
|
||||
}
|
||||
|
||||
/* The only scope of this method is to avoid duplicated messages in the
|
||||
* Subghz history, which we don't use. */
|
||||
uint8_t subghz_protocol_decoder_protoview_get_hash_data(void* context) {
|
||||
furi_assert(context);
|
||||
return 123;
|
||||
}
|
||||
|
||||
/* Not used. */
|
||||
bool subghz_protocol_decoder_protoview_serialize(
|
||||
void* context,
|
||||
FlipperFormat* flipper_format,
|
||||
SubGhzRadioPreset* preset)
|
||||
{
|
||||
UNUSED(context);
|
||||
UNUSED(flipper_format);
|
||||
UNUSED(preset);
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Not used. */
|
||||
bool subghz_protocol_decoder_protoview_deserialize(void* context, FlipperFormat* flipper_format)
|
||||
{
|
||||
UNUSED(context);
|
||||
UNUSED(flipper_format);
|
||||
return false;
|
||||
}
|
||||
|
||||
void subhz_protocol_decoder_protoview_get_string(void* context, FuriString* output)
|
||||
{
|
||||
furi_assert(context);
|
||||
furi_string_cat_printf(output, "Protoview");
|
||||
}
|
||||
|
||||
const SubGhzProtocolDecoder subghz_protocol_protoview_decoder = {
|
||||
.alloc = subghz_protocol_decoder_protoview_alloc,
|
||||
.free = subghz_protocol_decoder_protoview_free,
|
||||
.reset = subghz_protocol_decoder_protoview_reset,
|
||||
.feed = subghz_protocol_decoder_protoview_feed,
|
||||
.get_hash_data = subghz_protocol_decoder_protoview_get_hash_data,
|
||||
.serialize = subghz_protocol_decoder_protoview_serialize,
|
||||
.deserialize = subghz_protocol_decoder_protoview_deserialize,
|
||||
.get_string = subhz_protocol_decoder_protoview_get_string,
|
||||
};
|
||||
|
||||
/* Well, we don't really target a specific protocol. So let's put flags
|
||||
* that make sense. */
|
||||
const SubGhzProtocol subghz_protocol_protoview = {
|
||||
.name = "Protoview",
|
||||
.type = SubGhzProtocolTypeStatic,
|
||||
.flag = SubGhzProtocolFlag_AM | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable,
|
||||
.decoder = &subghz_protocol_protoview_decoder,
|
||||
};
|
||||
|
||||
/* Our table has just the single dummy protocol we defined for the
|
||||
* sake of data collection. */
|
||||
const SubGhzProtocol* protoview_protocol_registry_items[] = {
|
||||
&subghz_protocol_protoview,
|
||||
};
|
||||
|
||||
const SubGhzProtocolRegistry protoview_protocol_registry = {
|
||||
.items = protoview_protocol_registry_items,
|
||||
.size = COUNT_OF(protoview_protocol_registry_items)
|
||||
};
|
||||
BIN
applications/plugins/protoview/images/ProtoViewSignal.jpg
Normal file
BIN
applications/plugins/protoview/images/ProtoViewSignal.jpg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 84 KiB |
BIN
applications/plugins/protoview/images/protoview_1.jpg
Normal file
BIN
applications/plugins/protoview/images/protoview_1.jpg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 65 KiB |
BIN
applications/plugins/protoview/images/protoview_2.jpg
Normal file
BIN
applications/plugins/protoview/images/protoview_2.jpg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 63 KiB |
50
applications/plugins/protoview/protocols/b4b1.c
Normal file
50
applications/plugins/protoview/protocols/b4b1.c
Normal file
@ -0,0 +1,50 @@
|
||||
/* PT/SC remotes. Usually 443.92 Mhz OOK.
|
||||
*
|
||||
* This line code is used in many remotes such as Princeton chips
|
||||
* named PT2262, Silian Microelectronics SC5262 and others.
|
||||
* Basically every 4 pulsee represent a bit, where 1000 means 0, and
|
||||
* 1110 means 1. Usually we can read 24 bits of data.
|
||||
* In this specific implementation we check for a prelude that is
|
||||
* 1 bit high, 31 bits low, but the check is relaxed. */
|
||||
|
||||
#include "../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
if (numbits < 30) return false;
|
||||
const char *sync_patterns[3] = {
|
||||
"10000000000000000000000000000001", /* 30 zero bits. */
|
||||
"100000000000000000000000000000001", /* 31 zero bits. */
|
||||
"1000000000000000000000000000000001", /* 32 zero bits. */
|
||||
};
|
||||
|
||||
uint32_t off;
|
||||
int j;
|
||||
for (j = 0; j < 3; j++) {
|
||||
off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_patterns[j]);
|
||||
if (off != BITMAP_SEEK_NOT_FOUND) break;
|
||||
}
|
||||
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. */
|
||||
uint32_t decoded =
|
||||
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;
|
||||
|
||||
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;
|
||||
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]);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder B4B1Decoder = {
|
||||
"B4B1", decode
|
||||
};
|
||||
91
applications/plugins/protoview/protocols/keeloq.c
Normal file
91
applications/plugins/protoview/protocols/keeloq.c
Normal file
@ -0,0 +1,91 @@
|
||||
/* Microchip HCS200/HCS300/HSC301 KeeLoq, rolling code remotes.
|
||||
*
|
||||
* Usually 443.92 Mhz OOK, ~200us or ~400us pulse len, depending
|
||||
* on the configuration.
|
||||
*
|
||||
* Preamble: 12 pairs of alternating pulse/gap.
|
||||
* Sync: long gap of around 10 times the duration of the short-pulse.
|
||||
* Data: pulse width encoded data. Each bit takes three cycles:
|
||||
*
|
||||
* 0 = 110
|
||||
* 1 = 100
|
||||
*
|
||||
* There are a total of 66 bits transmitted.
|
||||
* 0..31: 32 bits of encrypted rolling code.
|
||||
* 32..59: Remote ID, 28 bits
|
||||
* 60..63: Buttons pressed
|
||||
* 64..64: Low battery if set
|
||||
* 65..65: Always set to 1
|
||||
*
|
||||
* Bits in bytes are inverted: least significant bit is first.
|
||||
* For some reason there is no checksum whatsoever, so we only decode
|
||||
* if we find everything well formed.
|
||||
*/
|
||||
|
||||
#include "../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
|
||||
/* In the sync pattern, we require the 12 high/low pulses and at least
|
||||
* half the gap we expect (5 pulses times, one is the final zero in the
|
||||
* 24 symbols high/low sequence, then other 4). */
|
||||
const char *sync_pattern = "101010101010101010101010" "0000";
|
||||
uint8_t sync_len = 24+4;
|
||||
if (numbits-sync_len+sync_len < 3*66) return false;
|
||||
uint32_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
if (off == BITMAP_SEEK_NOT_FOUND) return false;
|
||||
|
||||
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
|
||||
* timing. */
|
||||
uint8_t gap_len = 0;
|
||||
while(gap_len <= 7 && bitmap_get(bits,numbytes,off+gap_len) == 0)
|
||||
gap_len++;
|
||||
if (gap_len < 3 || gap_len > 7) return false;
|
||||
|
||||
off += gap_len;
|
||||
FURI_LOG_E(TAG, "Keeloq preamble+sync found");
|
||||
|
||||
uint8_t raw[9] = {0};
|
||||
uint32_t decoded =
|
||||
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. */
|
||||
|
||||
info->pulses_count = (off+66*3) - info->start_off;
|
||||
|
||||
bitmap_reverse_bytes(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 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");
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder KeeloqDecoder = {
|
||||
"Keeloq", decode
|
||||
};
|
||||
67
applications/plugins/protoview/protocols/oregon2.c
Normal file
67
applications/plugins/protoview/protocols/oregon2.c
Normal file
@ -0,0 +1,67 @@
|
||||
/* Oregon remote termometers. Usually 443.92 Mhz OOK.
|
||||
*
|
||||
* The protocol is described here:
|
||||
* https://wmrx00.sourceforge.net/Arduino/OregonScientific-RF-Protocols.pdf
|
||||
* This implementation is not very complete. */
|
||||
|
||||
#include "../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
if (numbits < 32) return false;
|
||||
const char *sync_pattern = "01100110" "01100110" "10010110" "10010110";
|
||||
uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
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};
|
||||
uint32_t decoded =
|
||||
convert_from_line_code(buffer,sizeof(buffer),bits,numbytes,off,"1001","0110");
|
||||
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};
|
||||
for (int j = 0; j < 64; j += 4) {
|
||||
uint8_t nib[1];
|
||||
nib[0] = (bitmap_get(buffer,8,j+0) |
|
||||
bitmap_get(buffer,8,j+1) << 1 |
|
||||
bitmap_get(buffer,8,j+2) << 2 |
|
||||
bitmap_get(buffer,8,j+3) << 3);
|
||||
if (DEBUG_MSG) FURI_LOG_E(TAG, "Not inverted nibble[%d]: %x", j/4, (unsigned int)nib[0]);
|
||||
raw[j/8] |= nib[0] << (4-(j%4));
|
||||
switch(j/4) {
|
||||
case 1: deviceid[0] |= nib[0]; break;
|
||||
case 0: deviceid[0] |= nib[0] << 4; break;
|
||||
case 3: deviceid[1] |= nib[0]; break;
|
||||
case 2: deviceid[1] |= nib[0] << 4; break;
|
||||
case 10: temp[0] = nib[0]; break;
|
||||
/* Fixme: take the temperature sign from nibble 11. */
|
||||
case 9: temp[1] = nib[0]; break;
|
||||
case 8: temp[2] = nib[0]; break;
|
||||
case 13: hum[0] = nib[0]; break;
|
||||
case 12: hum[1] = nib[0]; break;
|
||||
}
|
||||
}
|
||||
|
||||
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]);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder Oregon2Decoder = {
|
||||
"Oregon2", decode
|
||||
};
|
||||
63
applications/plugins/protoview/protocols/tpms/citroen.c
Normal file
63
applications/plugins/protoview/protocols/tpms/citroen.c
Normal file
@ -0,0 +1,63 @@
|
||||
/* Citroen TPMS. Usually 443.92 Mhz FSK.
|
||||
*
|
||||
* Preamble of ~14 high/low 52 us pulses
|
||||
* Sync of high 100us pulse then 50us low
|
||||
* Then Manchester bits, 10 bytes total.
|
||||
* Simple XOR checksum. */
|
||||
|
||||
#include "../../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
|
||||
/* We consider a preamble of 17 symbols. They are more, but the decoding
|
||||
* is more likely to happen if we don't pretend to receive from the
|
||||
* very start of the message. */
|
||||
uint32_t sync_len = 17;
|
||||
const char *sync_pattern = "10101010101010110";
|
||||
if (numbits-sync_len < 8*10) return false; /* Expect 10 bytes. */
|
||||
|
||||
uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
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];
|
||||
uint32_t decoded =
|
||||
convert_from_line_code(raw,sizeof(raw),bits,numbytes,off,
|
||||
"01","10"); /* Manchester. */
|
||||
FURI_LOG_E(TAG, "Citroen TPMS decoded bits: %lu", decoded);
|
||||
|
||||
if (decoded < 8*10) return false; /* Require the full 10 bytes. */
|
||||
|
||||
/* Check the CRC. It's a simple XOR of bytes 1-9, the first byte
|
||||
* is not included. The meaning of the first byte is unknown and
|
||||
* we don't display it. */
|
||||
uint8_t crc = 0;
|
||||
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);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder CitroenTPMSDecoder = {
|
||||
"Citroen TPMS", decode
|
||||
};
|
||||
67
applications/plugins/protoview/protocols/tpms/ford.c
Normal file
67
applications/plugins/protoview/protocols/tpms/ford.c
Normal file
@ -0,0 +1,67 @@
|
||||
/* Ford tires TPMS. Usually 443.92 Mhz FSK (in Europe).
|
||||
*
|
||||
* 52 us short pules
|
||||
* Preamble: 0101010101010101010101010101
|
||||
* Sync: 0110 (that is 52 us gap + 104 us pulse + 52 us gap)
|
||||
* Data: 8 bytes Manchester encoded
|
||||
* 01 = zero
|
||||
* 10 = one
|
||||
*/
|
||||
|
||||
#include "../../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
|
||||
const char *sync_pattern = "010101010101" "0110";
|
||||
uint8_t sync_len = 12+4; /* We just use 12 preamble symbols + sync. */
|
||||
if (numbits-sync_len < 8*8) return false;
|
||||
|
||||
uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
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];
|
||||
uint32_t decoded =
|
||||
convert_from_line_code(raw,sizeof(raw),bits,numbytes,off,
|
||||
"01","10"); /* Manchester. */
|
||||
FURI_LOG_E(TAG, "Ford TPMS decoded bits: %lu", decoded);
|
||||
|
||||
if (decoded < 8*8) return false; /* Require the full 8 bytes. */
|
||||
|
||||
/* CRC is just the sum of the first 7 bytes MOD 256. */
|
||||
uint8_t crc = 0;
|
||||
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
|
||||
* bit of the value is not set. Otherwise its meaning is unknown.
|
||||
* Likely useful to alternatively send temperature or other info. */
|
||||
int temp = raw[5] & 0x80 ? 0 : raw[5]-56;
|
||||
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");
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder FordTPMSDecoder = {
|
||||
"Ford TPMS", decode
|
||||
};
|
||||
69
applications/plugins/protoview/protocols/tpms/renault.c
Normal file
69
applications/plugins/protoview/protocols/tpms/renault.c
Normal file
@ -0,0 +1,69 @@
|
||||
/* Renault tires TPMS. Usually 443.92 Mhz FSK.
|
||||
*
|
||||
* Preamble + sync + Manchester bits. ~48us short pulse.
|
||||
* 9 Bytes in total not counting the preamble. */
|
||||
|
||||
#include "../../app.h"
|
||||
|
||||
#define USE_TEST_VECTOR 0
|
||||
static const char *test_vector =
|
||||
"...01010101010101010110" // Preamble + sync
|
||||
|
||||
/* The following is Marshal encoded, so each two characters are
|
||||
* actaully one bit. 01 = 0, 10 = 1. */
|
||||
"010110010110" // Flags.
|
||||
"10011001101010011001" // Pressure, multiply by 0.75 to obtain kpa.
|
||||
// 244 kpa here.
|
||||
"1010010110011010" // Temperature, subtract 30 to obtain celsius. 22C here.
|
||||
"1001010101101001"
|
||||
"0101100110010101"
|
||||
"1001010101100110" // Tire ID. 0x7AD779 here.
|
||||
"0101010101010101"
|
||||
"0101010101010101" // Two FF bytes (usually). Unknown.
|
||||
"0110010101010101"; // CRC8 with (poly 7, initialization 0).
|
||||
|
||||
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,0,test_vector);
|
||||
numbits = strlen(test_vector);
|
||||
}
|
||||
|
||||
if (numbits-12 < 9*8) return false;
|
||||
|
||||
const char *sync_pattern = "01010101010101010110";
|
||||
uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
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];
|
||||
uint32_t decoded =
|
||||
convert_from_line_code(raw,sizeof(raw),bits,numbytes,off,
|
||||
"01","10"); /* Manchester. */
|
||||
FURI_LOG_E(TAG, "Renault TPMS decoded bits: %lu", decoded);
|
||||
|
||||
if (decoded < 8*9) return false; /* Require the full 9 bytes. */
|
||||
if (crc8(raw,8,0,7) != raw[8]) return false; /* Require sane CRC. */
|
||||
|
||||
info->pulses_count = (off+8*9*2) - info->start_off;
|
||||
|
||||
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);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder RenaultTPMSDecoder = {
|
||||
"Renault TPMS", decode
|
||||
};
|
||||
68
applications/plugins/protoview/protocols/tpms/schrader.c
Normal file
68
applications/plugins/protoview/protocols/tpms/schrader.c
Normal file
@ -0,0 +1,68 @@
|
||||
/* Schrader TPMS. Usually 443.92 Mhz OOK, 120us pulse len.
|
||||
*
|
||||
* 500us high pulse + Preamble + Manchester coded bits where:
|
||||
* 1 = 10
|
||||
* 0 = 01
|
||||
*
|
||||
* 60 bits of data total (first 4 nibbles is the preamble, 0xF).
|
||||
*
|
||||
* Used in FIAT-Chrysler, Mercedes, ... */
|
||||
|
||||
#include "../../app.h"
|
||||
|
||||
#define USE_TEST_VECTOR 0
|
||||
static const char *test_vector = "000000111101010101011010010110010110101001010110100110011001100101010101011010100110100110011010101010101010101010101010101010101010101010101010";
|
||||
|
||||
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,0,test_vector);
|
||||
numbits = strlen(test_vector);
|
||||
}
|
||||
|
||||
if (numbits < 64) return false; /* Preamble + data. */
|
||||
|
||||
const char *sync_pattern = "1111010101" "01011010";
|
||||
uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
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];
|
||||
uint32_t decoded =
|
||||
convert_from_line_code(raw,sizeof(raw),bits,numbytes,off,
|
||||
"01","10"); /* Manchester code. */
|
||||
FURI_LOG_E(TAG, "Schrader TPMS decoded bits: %lu", decoded);
|
||||
|
||||
if (decoded < 64) return false; /* Require the full 8 bytes. */
|
||||
|
||||
raw[0] |= 0xf0; // Fix the preamble nibble for checksum computation.
|
||||
uint8_t cksum = crc8(raw,sizeof(raw)-1,0xf0,0x7);
|
||||
if (cksum != raw[7]) {
|
||||
FURI_LOG_E(TAG, "Schrader TPMS checksum mismatch");
|
||||
return false;
|
||||
}
|
||||
|
||||
info->pulses_count = (off+8*8*2) - info->start_off;
|
||||
|
||||
float kpa = (float)raw[5]*2.5;
|
||||
int temp = raw[6]-50;
|
||||
|
||||
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);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder SchraderTPMSDecoder = {
|
||||
"Schrader TPMS", decode
|
||||
};
|
||||
@ -0,0 +1,66 @@
|
||||
/* Schrader variant EG53MA4 TPMS.
|
||||
* Usually 443.92 Mhz OOK, 100us pulse len.
|
||||
*
|
||||
* Preamble: alternating pulse/gap, 100us.
|
||||
* Sync (as pulses and gaps): "01100101", already part of the data stream
|
||||
* (first nibble) corresponding to 0x4
|
||||
*
|
||||
* A total of 10 bytes payload, Manchester encoded.
|
||||
*
|
||||
* 0 = 01
|
||||
* 1 = 10
|
||||
*
|
||||
* Used in certain Open cars and others.
|
||||
*/
|
||||
|
||||
#include "../../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
|
||||
const char *sync_pattern = "010101010101" "01100101";
|
||||
uint8_t sync_len = 12+8; /* We just use 12 preamble symbols + sync. */
|
||||
if (numbits-sync_len+8 < 8*10) return false;
|
||||
|
||||
uint64_t off = bitmap_seek_bits(bits,numbytes,0,numbits,sync_pattern);
|
||||
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];
|
||||
uint32_t decoded =
|
||||
convert_from_line_code(raw,sizeof(raw),bits,numbytes,off,
|
||||
"01","10"); /* Manchester code. */
|
||||
FURI_LOG_E(TAG, "Schrader EG53MA4 TPMS decoded bits: %lu", decoded);
|
||||
|
||||
if (decoded < 10*8) return false; /* Require the full 10 bytes. */
|
||||
|
||||
/* CRC is just all bytes added mod 256. */
|
||||
uint8_t crc = 0;
|
||||
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. */
|
||||
float kpa = (float)raw[7]*2.75;
|
||||
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);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder SchraderEG53MA4TPMSDecoder = {
|
||||
"Schrader EG53MA4 TPMS", decode
|
||||
};
|
||||
91
applications/plugins/protoview/protocols/tpms/toyota.c
Normal file
91
applications/plugins/protoview/protocols/tpms/toyota.c
Normal file
@ -0,0 +1,91 @@
|
||||
/* Toyota tires TPMS. Usually 443.92 Mhz FSK (In Europe).
|
||||
*
|
||||
* Preamble + sync + 64 bits of data. ~48us short pulse length.
|
||||
*
|
||||
* The preamble + sync is something like:
|
||||
*
|
||||
* 10101010101 (preamble) + 001111[1] (sync)
|
||||
*
|
||||
* Note: the final [1] means that sometimes it is four 1s, sometimes
|
||||
* five, depending on the short pulse length detection and the exact
|
||||
* duration of the high long pulse. After the sync, a differential
|
||||
* Manchester encoded payload follows. However the Flipper's CC1101
|
||||
* often can't decode correctly the initial alternating pattern 101010101,
|
||||
* so what we do is to seek just the sync, that is "001111" or "0011111",
|
||||
* however we now that it must be followed by one differenitally encoded
|
||||
* bit, so we can use also the first symbol of data to force a more robust
|
||||
* detection, and look for one of the following:
|
||||
*
|
||||
* [001111]00
|
||||
* [0011111]00
|
||||
* [001111]01
|
||||
* [0011111]01
|
||||
*/
|
||||
|
||||
#include "../../app.h"
|
||||
|
||||
static bool decode(uint8_t *bits, uint32_t numbytes, uint32_t numbits, ProtoViewMsgInfo *info) {
|
||||
|
||||
if (numbits-6 < 64*2) return false; /* Ask for 64 bit of data (each bit
|
||||
is two symbols in the bitmap). */
|
||||
|
||||
char *sync[] = {
|
||||
"00111100",
|
||||
"001111100",
|
||||
"00111101",
|
||||
"001111101",
|
||||
NULL
|
||||
};
|
||||
|
||||
int j;
|
||||
uint32_t off = 0;
|
||||
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;
|
||||
}
|
||||
}
|
||||
if (off == BITMAP_SEEK_NOT_FOUND) return false;
|
||||
|
||||
FURI_LOG_E(TAG, "Toyota TPMS sync[%s] found", sync[j]);
|
||||
|
||||
uint8_t raw[9];
|
||||
uint32_t decoded =
|
||||
convert_from_diff_manchester(raw,sizeof(raw),bits,numbytes,off,true);
|
||||
FURI_LOG_E(TAG, "Toyota TPMS decoded bits: %lu", decoded);
|
||||
|
||||
if (decoded < 8*9) return false; /* Require the full 8 bytes. */
|
||||
if (crc8(raw,8,0x80,7) != raw[8]) return false; /* Require sane CRC. */
|
||||
|
||||
/* 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 kpa = (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->info2,sizeof(info->info2),"Pressure %.2f psi", (double)kpa);
|
||||
snprintf(info->info3,sizeof(info->info3),"Temperature %d C", temp);
|
||||
return true;
|
||||
}
|
||||
|
||||
ProtoViewDecoder ToyotaTPMSDecoder = {
|
||||
"Toyota TPMS", decode
|
||||
};
|
||||
593
applications/plugins/protoview/signal.c
Normal file
593
applications/plugins/protoview/signal.c
Normal file
@ -0,0 +1,593 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
|
||||
bool decode_signal(RawSamplesBuffer *s, uint64_t len, ProtoViewMsgInfo *info);
|
||||
|
||||
/* =============================================================================
|
||||
* Raw signal detection
|
||||
* ===========================================================================*/
|
||||
|
||||
/* Return the time difference between a and b, always >= 0 since
|
||||
* the absolute value is returned. */
|
||||
uint32_t duration_delta(uint32_t a, uint32_t b) {
|
||||
return a > b ? a - b : b - a;
|
||||
}
|
||||
|
||||
/* Reset the current signal, so that a new one can be detected. */
|
||||
void reset_current_signal(ProtoViewApp *app) {
|
||||
app->signal_bestlen = 0;
|
||||
app->signal_offset = 0;
|
||||
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
|
||||
* longest run of pulses, either high or low, that are not much different
|
||||
* from each other, for a maximum of three duration classes.
|
||||
* So for instance 50 successive pulses that are roughly long 340us or 670us
|
||||
* will be sensed as a coherent signal (example: 312, 361, 700, 334, 667, ...)
|
||||
*
|
||||
* The classes are counted separtely for high and low signals (RF on / off)
|
||||
* because many devices tend to have different pulse lenghts depending on
|
||||
* the level of the pulse.
|
||||
*
|
||||
* For instance Oregon2 sensors, in the case of protocol 2.1 will send
|
||||
* pulses of ~400us (RF on) VS ~580us (RF off). */
|
||||
#define SEARCH_CLASSES 3
|
||||
uint32_t search_coherent_signal(RawSamplesBuffer *s, uint32_t idx) {
|
||||
struct {
|
||||
uint32_t dur[2]; /* dur[0] = low, dur[1] = high */
|
||||
uint32_t count[2]; /* Associated observed frequency. */
|
||||
} classes[SEARCH_CLASSES];
|
||||
|
||||
memset(classes,0,sizeof(classes));
|
||||
uint32_t minlen = 30, maxlen = 4000; /* Depends on data rate, here we
|
||||
allow for high and low. */
|
||||
uint32_t len = 0; /* Observed len of coherent samples. */
|
||||
s->short_pulse_dur = 0;
|
||||
for (uint32_t j = idx; j < idx+500; j++) {
|
||||
bool level;
|
||||
uint32_t dur;
|
||||
raw_samples_get(s, j, &level, &dur);
|
||||
|
||||
if (dur < minlen || dur > maxlen) break; /* return. */
|
||||
|
||||
/* Let's see if it matches a class we already have or if we
|
||||
* can populate a new (yet empty) class. */
|
||||
uint32_t k;
|
||||
for (k = 0; k < SEARCH_CLASSES; k++) {
|
||||
if (classes[k].count[level] == 0) {
|
||||
classes[k].dur[level] = dur;
|
||||
classes[k].count[level] = 1;
|
||||
break; /* Sample accepted. */
|
||||
} else {
|
||||
uint32_t classavg = classes[k].dur[level];
|
||||
uint32_t count = classes[k].count[level];
|
||||
uint32_t delta = duration_delta(dur,classavg);
|
||||
/* Is the difference in duration between this signal and
|
||||
* the class we are inspecting less than a given percentage?
|
||||
* If so, accept this signal. */
|
||||
if (delta < classavg/5) { /* 100%/5 = 20%. */
|
||||
/* It is useful to compute the average of the class
|
||||
* we are observing. We know how many samples we got so
|
||||
* far, so we can recompute the average easily.
|
||||
* By always having a better estimate of the pulse len
|
||||
* we can avoid missing next samples in case the first
|
||||
* observed samples are too off. */
|
||||
classavg = ((classavg * count) + dur) / (count+1);
|
||||
classes[k].dur[level] = classavg;
|
||||
classes[k].count[level]++;
|
||||
break; /* Sample accepted. */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (k == SEARCH_CLASSES) break; /* No match, return. */
|
||||
|
||||
/* If we are here, we accepted this sample. Try with the next
|
||||
* one. */
|
||||
len++;
|
||||
}
|
||||
|
||||
/* Update the buffer setting the shortest pulse we found
|
||||
* among the three classes. This will be used when scaling
|
||||
* for visualization. */
|
||||
uint32_t short_dur[2] = {0,0};
|
||||
for (int j = 0; j < SEARCH_CLASSES; j++) {
|
||||
for (int level = 0; level < 2; level++) {
|
||||
if (classes[j].dur[level] == 0) continue;
|
||||
if (classes[j].count[level] < 3) continue;
|
||||
if (short_dur[level] == 0 ||
|
||||
short_dur[level] > classes[j].dur[level])
|
||||
{
|
||||
short_dur[level] = classes[j].dur[level];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Use the average between high and low short pulses duration.
|
||||
* Often they are a bit different, and using the average is more robust
|
||||
* when we do decoding sampling at short_pulse_dur intervals. */
|
||||
if (short_dur[0] == 0) short_dur[0] = short_dur[1];
|
||||
if (short_dur[1] == 0) short_dur[1] = short_dur[0];
|
||||
s->short_pulse_dur = (short_dur[0]+short_dur[1])/2;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
/* Search the buffer with the stored signal (last N samples received)
|
||||
* in order to find a coherent signal. If a signal that does not appear to
|
||||
* be just noise is found, it is set in DetectedSamples global signal
|
||||
* buffer, that is what is rendered on the screen. */
|
||||
void scan_for_signal(ProtoViewApp *app) {
|
||||
/* We need to work on a copy: the RawSamples buffer is populated
|
||||
* by the background thread receiving data. */
|
||||
RawSamplesBuffer *copy = raw_samples_alloc();
|
||||
raw_samples_copy(copy,RawSamples);
|
||||
|
||||
/* Try to seek on data that looks to have a regular high low high low
|
||||
* pattern. */
|
||||
uint32_t minlen = 18; /* Min run of coherent samples. With less
|
||||
than a few samples it's very easy to
|
||||
mistake noise for signal. */
|
||||
|
||||
uint32_t i = 0;
|
||||
|
||||
while (i < copy->total-1) {
|
||||
uint32_t thislen = search_coherent_signal(copy,i);
|
||||
|
||||
/* For messages that are long enough, attempt decoding. */
|
||||
if (thislen > minlen) {
|
||||
/* 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 zero .*/
|
||||
raw_samples_center(copy,i);
|
||||
bool decoded = decode_signal(copy,thislen,info);
|
||||
copy->idx = saved_idx; /* Restore the index as we are scanning
|
||||
the signal in the loop. */
|
||||
|
||||
/* Accept this signal as the new signal if either it's longer
|
||||
* than the previous undecoded one, or the previous one was
|
||||
* unknown and this is decoded. */
|
||||
if ((thislen > app->signal_bestlen && app->signal_decoded == false)
|
||||
|| (app->signal_decoded == false && decoded))
|
||||
{
|
||||
free_msg_info(app->msg_info);
|
||||
app->msg_info = info;
|
||||
app->signal_bestlen = thislen;
|
||||
app->signal_decoded = decoded;
|
||||
raw_samples_copy(DetectedSamples,copy);
|
||||
raw_samples_center(DetectedSamples,i);
|
||||
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;
|
||||
} 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);
|
||||
}
|
||||
|
||||
/* =============================================================================
|
||||
* Decoding
|
||||
*
|
||||
* The following code will translates the raw singals as received by
|
||||
* the CC1101 into logical signals: a bitmap of 0s and 1s sampled at
|
||||
* the detected data clock interval.
|
||||
*
|
||||
* Then the converted signal is passed to the protocols decoders, that look
|
||||
* for protocol-specific information. We stop at the first decoder that is
|
||||
* able to decode the data, so protocols here should be registered in
|
||||
* order of complexity and specificity, with the generic ones at the end.
|
||||
* ===========================================================================*/
|
||||
|
||||
/* Set the 'bitpos' bit to value 'val', in the specified bitmap
|
||||
* 'b' of len 'blen'.
|
||||
* Out of range bits will silently be discarded. */
|
||||
void bitmap_set(uint8_t *b, uint32_t blen, uint32_t bitpos, bool val) {
|
||||
uint32_t byte = bitpos/8;
|
||||
uint32_t bit = 7-(bitpos&7);
|
||||
if (byte >= blen) return;
|
||||
if (val)
|
||||
b[byte] |= 1<<bit;
|
||||
else
|
||||
b[byte] &= ~(1<<bit);
|
||||
}
|
||||
|
||||
/* Get the bit 'bitpos' of the bitmap 'b' of 'blen' bytes.
|
||||
* Out of range bits return false (not bit set). */
|
||||
bool bitmap_get(uint8_t *b, uint32_t blen, uint32_t bitpos) {
|
||||
uint32_t byte = bitpos/8;
|
||||
uint32_t bit = 7-(bitpos&7);
|
||||
if (byte >= blen) return 0;
|
||||
return (b[byte] & (1<<bit)) != 0;
|
||||
}
|
||||
|
||||
/* Copy 'count' bits from the bitmap 's' of 'slen' total bytes, to the
|
||||
* bitmap 'd' of 'dlen' total bytes. The bits are copied starting from
|
||||
* offset 'soff' of the source bitmap to the offset 'doff' of the
|
||||
* destination bitmap. */
|
||||
void bitmap_copy(uint8_t *d, uint32_t dlen, uint32_t doff,
|
||||
uint8_t *s, uint32_t slen, uint32_t soff,
|
||||
uint32_t count)
|
||||
{
|
||||
/* If we are byte-aligned in both source and destination, use a fast
|
||||
* path for the number of bytes we can consume this way. */
|
||||
if ((doff & 7) == 0 && (soff & 7) == 0) {
|
||||
uint32_t didx = doff/8;
|
||||
uint32_t sidx = soff/8;
|
||||
while(count > 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) {
|
||||
for (uint32_t j = 0; j < len; j++) {
|
||||
uint32_t b = p[j];
|
||||
/* Step 1: swap the two nibbles: 12345678 -> 56781234 */
|
||||
b = (b&0xf0)>>4 | (b&0x0f)<<4;
|
||||
/* Step 2: swap adjacent pairs : 56781234 -> 78563412 */
|
||||
b = (b&0xcc)>>2 | (b&0x33)<<2;
|
||||
/* Step 3: swap adjacent bits : 78563412 -> 87654321 */
|
||||
b = (b&0xaa)>>1 | (b&0x55)<<1;
|
||||
p[j] = b;
|
||||
}
|
||||
}
|
||||
|
||||
/* Return true if the specified sequence of bits, provided as a string in the
|
||||
* form "11010110..." is found in the 'b' bitmap of 'blen' bits at 'bitpos'
|
||||
* position. */
|
||||
bool bitmap_match_bits(uint8_t *b, uint32_t blen, uint32_t bitpos, const char *bits) {
|
||||
for (size_t j = 0; bits[j]; j++) {
|
||||
bool expected = (bits[j] == '1') ? true : false;
|
||||
if (bitmap_get(b,blen,bitpos+j) != expected) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Search for the specified bit sequence (see bitmap_match_bits() for details)
|
||||
* in the bitmap 'b' of 'blen' bytes, looking forward at most 'maxbits' ahead.
|
||||
* Returns the offset (in bits) of the match, or BITMAP_SEEK_NOT_FOUND if not
|
||||
* found.
|
||||
*
|
||||
* Note: there are better algorithms, such as Boyer-Moore. Here we hope that
|
||||
* for the kind of patterns we search we'll have a lot of early stops so
|
||||
* we use a vanilla approach. */
|
||||
uint32_t bitmap_seek_bits(uint8_t *b, uint32_t blen, uint32_t startpos, uint32_t maxbits, const char *bits) {
|
||||
uint32_t endpos = startpos+blen*8;
|
||||
uint32_t end2 = startpos+maxbits;
|
||||
if (end2 < endpos) endpos = end2;
|
||||
for (uint32_t j = startpos; j < endpos; j++)
|
||||
if (bitmap_match_bits(b,blen,j,bits)) return j;
|
||||
return BITMAP_SEEK_NOT_FOUND;
|
||||
}
|
||||
|
||||
/* 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, uint32_t off, const char *pat) {
|
||||
uint32_t i = 0;
|
||||
while(pat[i]) {
|
||||
bitmap_set(b,blen,i+off,pat[i] == '1');
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
/* Take the raw signal and turn it into a sequence of bits inside the
|
||||
* buffer 'b'. Note that such 0s and 1s are NOT the actual data in the
|
||||
* signal, but is just a low level representation of the line code. Basically
|
||||
* if the short pulse we find in the signal is 320us, we convert high and
|
||||
* low levels in the raw sample in this way:
|
||||
*
|
||||
* If for instance we see a high level lasting ~600 us, we will add
|
||||
* two 1s bit. If then the signal goes down for 330us, we will add one zero,
|
||||
* and so forth. So for each period of high and low we find the closest
|
||||
* multiple and set the relevant number of bits.
|
||||
*
|
||||
* In case of a short pulse of 320us detected, 320*2 is the closest to a
|
||||
* high pulse of 600us, so 2 bits will be set.
|
||||
*
|
||||
* In other terms what this function does is sampling the signal at
|
||||
* fixed 'rate' intervals.
|
||||
*
|
||||
* This representation makes it simple to decode the signal at a higher
|
||||
* level later, translating it from Marshal coding or other line codes
|
||||
* to the actual bits/bytes.
|
||||
*
|
||||
* The 'idx' argument marks the detected signal start index into the
|
||||
* raw samples buffer. The 'count' tells the function how many raw
|
||||
* samples to convert into bits. The function returns the number of
|
||||
* bits set into the buffer 'b'. The 'rate' argument, in microseconds, is
|
||||
* the detected short-pulse duration. We expect the line code to be
|
||||
* meaningful when interpreted at multiples of 'rate'. */
|
||||
uint32_t convert_signal_to_bits(uint8_t *b, uint32_t blen, RawSamplesBuffer *s, uint32_t idx, uint32_t count, uint32_t rate) {
|
||||
if (rate == 0) return 0; /* We can't perform the conversion. */
|
||||
uint32_t bitpos = 0;
|
||||
for (uint32_t j = 0; j < count; j++) {
|
||||
uint32_t dur;
|
||||
bool level;
|
||||
raw_samples_get(s, j+idx, &level, &dur);
|
||||
|
||||
uint32_t numbits = dur / rate; /* full bits that surely fit. */
|
||||
uint32_t rest = dur % rate; /* How much we are left with. */
|
||||
if (rest > rate/2) numbits++; /* There is another one. */
|
||||
|
||||
/* Limit how much a single sample can spawn. There are likely no
|
||||
* protocols doing such long pulses when the rate is low. */
|
||||
if (numbits > 1024) numbits = 1024;
|
||||
|
||||
if (0) /* Super verbose, so not under the DEBUG_MSG define. */
|
||||
FURI_LOG_E(TAG, "%lu converted into %lu (%d) bits",
|
||||
dur,numbits,(int)level);
|
||||
|
||||
/* If the signal is too short, let's claim it an interference
|
||||
* and ignore it completely. */
|
||||
if (numbits == 0) continue;
|
||||
|
||||
while(numbits--) bitmap_set(b,blen,bitpos++,level);
|
||||
}
|
||||
return bitpos;
|
||||
}
|
||||
|
||||
/* This function converts the line code used to the final data representation.
|
||||
* The representation is put inside 'buf', for up to 'buflen' bytes of total
|
||||
* data. For instance in order to convert manchester you can use "10" and "01"
|
||||
* as zero and one patterns. However this function does not handle differential
|
||||
* encodings. See below for convert_from_diff_manchester().
|
||||
*
|
||||
* The function returns the number of bits converted. It will stop as soon
|
||||
* as it finds a pattern that does not match zero or one patterns, or when
|
||||
* the end of the bitmap pointed by 'bits' is reached (the length is
|
||||
* specified in bytes by the caller, via the 'len' parameters).
|
||||
*
|
||||
* The decoding starts at the specified offset (in bits) 'off'. */
|
||||
uint32_t convert_from_line_code(uint8_t *buf, uint64_t buflen, uint8_t *bits, uint32_t len, uint32_t off, const char *zero_pattern, const char *one_pattern)
|
||||
{
|
||||
uint32_t decoded = 0; /* Number of bits extracted. */
|
||||
len *= 8; /* Convert bytes to bits. */
|
||||
while(off < len) {
|
||||
bool bitval;
|
||||
if (bitmap_match_bits(bits,len,off,zero_pattern)) {
|
||||
bitval = false;
|
||||
off += strlen(zero_pattern);
|
||||
} else if (bitmap_match_bits(bits,len,off,one_pattern)) {
|
||||
bitval = true;
|
||||
off += strlen(one_pattern);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
bitmap_set(buf,buflen,decoded++,bitval);
|
||||
if (decoded/8 == buflen) break; /* No space left on target buffer. */
|
||||
}
|
||||
return decoded;
|
||||
}
|
||||
|
||||
/* Convert the differential Manchester code to bits. This is similar to
|
||||
* convert_from_line_code() but specific for Manchester. The user must
|
||||
* supply the value of the previous symbol before this stream, since
|
||||
* in differential codings the next bits depend on the previous one.
|
||||
*
|
||||
* Parameters and return values are like convert_from_line_code(). */
|
||||
uint32_t convert_from_diff_manchester(uint8_t *buf, uint64_t buflen, uint8_t *bits, uint32_t len, uint32_t off, bool previous)
|
||||
{
|
||||
uint32_t decoded = 0;
|
||||
len *= 8; /* Conver to bits. */
|
||||
for (uint32_t j = off; j < len; j += 2) {
|
||||
bool b0 = bitmap_get(bits,len,j);
|
||||
bool b1 = bitmap_get(bits,len,j+1);
|
||||
if (b0 == previous) break; /* Each new bit must switch value. */
|
||||
bitmap_set(buf,buflen,decoded++,b0 == b1);
|
||||
previous = b1;
|
||||
if (decoded/8 == buflen) break; /* No space left on target buffer. */
|
||||
}
|
||||
return decoded;
|
||||
}
|
||||
|
||||
/* Supported protocols go here, with the relevant implementation inside
|
||||
* protocols/<name>.c */
|
||||
|
||||
extern ProtoViewDecoder Oregon2Decoder;
|
||||
extern ProtoViewDecoder B4B1Decoder;
|
||||
extern ProtoViewDecoder RenaultTPMSDecoder;
|
||||
extern ProtoViewDecoder ToyotaTPMSDecoder;
|
||||
extern ProtoViewDecoder SchraderTPMSDecoder;
|
||||
extern ProtoViewDecoder SchraderEG53MA4TPMSDecoder;
|
||||
extern ProtoViewDecoder CitroenTPMSDecoder;
|
||||
extern ProtoViewDecoder FordTPMSDecoder;
|
||||
extern ProtoViewDecoder KeeloqDecoder;
|
||||
|
||||
ProtoViewDecoder *Decoders[] = {
|
||||
&Oregon2Decoder, /* Oregon sensors v2.1 protocol. */
|
||||
&B4B1Decoder, /* PT, SC, ... 24 bits remotes. */
|
||||
&RenaultTPMSDecoder, /* Renault TPMS. */
|
||||
&ToyotaTPMSDecoder, /* Toyota TPMS. */
|
||||
&SchraderTPMSDecoder, /* Schrader TPMS. */
|
||||
&SchraderEG53MA4TPMSDecoder, /* Schrader EG53MA4 TPMS. */
|
||||
&CitroenTPMSDecoder, /* Citroen TPMS. */
|
||||
&FordTPMSDecoder, /* Ford TPMS. */
|
||||
&KeeloqDecoder, /* Keeloq remote. */
|
||||
NULL
|
||||
};
|
||||
|
||||
/* Free the message info and allocated data. */
|
||||
void free_msg_info(ProtoViewMsgInfo *i) {
|
||||
if (i == NULL) return;
|
||||
free(i->bits);
|
||||
free(i);
|
||||
}
|
||||
|
||||
/* Reset the message info structure before passing it to the decoding
|
||||
* functions. */
|
||||
void init_msg_info(ProtoViewMsgInfo *i, ProtoViewApp *app) {
|
||||
UNUSED(app);
|
||||
memset(i,0,sizeof(ProtoViewMsgInfo));
|
||||
i->bits = NULL;
|
||||
}
|
||||
|
||||
/* This function is called when a new signal is detected. It converts it
|
||||
* to a bitstream, and the calls the protocol specific functions for
|
||||
* decoding. If the signal was decoded correctly by some protocol, true
|
||||
* is returned. Otherwise false is returned. */
|
||||
bool decode_signal(RawSamplesBuffer *s, uint64_t len, ProtoViewMsgInfo *info) {
|
||||
uint32_t bitmap_bits_size = 4096*8;
|
||||
uint32_t bitmap_size = bitmap_bits_size/8;
|
||||
|
||||
/* 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 = 32;
|
||||
uint32_t after_samples = 100;
|
||||
|
||||
uint8_t *bitmap = malloc(bitmap_size);
|
||||
uint32_t bits = convert_signal_to_bits(bitmap,bitmap_size,s,-before_samples,len+before_samples+after_samples,s->short_pulse_dur);
|
||||
|
||||
if (DEBUG_MSG) { /* Useful for debugging purposes. Don't remove. */
|
||||
char *str = malloc(1024);
|
||||
uint32_t j;
|
||||
for (j = 0; j < bits && j < 1023; j++) {
|
||||
str[j] = bitmap_get(bitmap,bitmap_size,j) ? '1' : '0';
|
||||
}
|
||||
str[j] = 0;
|
||||
FURI_LOG_E(TAG, "%lu bits sampled: %s", bits, str);
|
||||
free(str);
|
||||
}
|
||||
|
||||
/* Try all the decoders available. */
|
||||
int j = 0;
|
||||
|
||||
bool decoded = false;
|
||||
while(Decoders[j]) {
|
||||
uint32_t start_time = furi_get_tick();
|
||||
decoded = Decoders[j]->decode(bitmap,bitmap_size,bits,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;
|
||||
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);
|
||||
/* 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;
|
||||
}
|
||||
141
applications/plugins/protoview/signal_file.c
Normal file
141
applications/plugins/protoview/signal_file.c
Normal file
@ -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 <stream/stream.h>
|
||||
#include <flipper_format/flipper_format_i.h>
|
||||
|
||||
/* ========================= 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;
|
||||
}
|
||||
104
applications/plugins/protoview/ui.c
Normal file
104
applications/plugins/protoview/ui.c
Normal file
@ -0,0 +1,104 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#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 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 show_available_subviews(Canvas *canvas, ProtoViewApp *app,
|
||||
int last_subview)
|
||||
{
|
||||
int subview = 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 process_subview_updown(ProtoViewApp *app, InputEvent input, int last_subview) {
|
||||
int subview = 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 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 dismiss_keyboard(ProtoViewApp *app) {
|
||||
view_dispatcher_stop(app->view_dispatcher);
|
||||
}
|
||||
|
||||
/* =========================== 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 {
|
||||
uint8_t x; uint8_t y;
|
||||
} dir[8] = {
|
||||
{-1,-1},
|
||||
{0,-1},
|
||||
{1,-1},
|
||||
{1,0},
|
||||
{1,1},
|
||||
{0,1},
|
||||
{-1,1},
|
||||
{-1,0}
|
||||
};
|
||||
|
||||
/* Rotate in all the directions writing the same string to create a
|
||||
* border, then write the actual string in the other color in the
|
||||
* middle. */
|
||||
canvas_set_color(canvas, border_color);
|
||||
for (int j = 0; j < 8; j++)
|
||||
canvas_draw_str(canvas,x+dir[j].x,y+dir[j].y,str);
|
||||
canvas_set_color(canvas, text_color);
|
||||
canvas_draw_str(canvas,x,y,str);
|
||||
canvas_set_color(canvas, ColorBlack);
|
||||
}
|
||||
67
applications/plugins/protoview/view_direct_sampling.c
Normal file
67
applications/plugins/protoview/view_direct_sampling.c
Normal file
@ -0,0 +1,67 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
|
||||
#include <cc1101.h>
|
||||
|
||||
/* Read directly from the G0 CC1101 pin, and draw a black or white
|
||||
* dot depending on the level. */
|
||||
void render_view_direct_sampling(Canvas *const canvas, ProtoViewApp *app) {
|
||||
if (!app->direct_sampling_enabled) {
|
||||
canvas_set_font(canvas, FontSecondary);
|
||||
canvas_draw_str(canvas,2,9,"Direct sampling is a special");
|
||||
canvas_draw_str(canvas,2,18,"mode that displays the signal");
|
||||
canvas_draw_str(canvas,2,27,"captured in real time. Like in");
|
||||
canvas_draw_str(canvas,2,36,"a old CRT TV. It's very slow.");
|
||||
canvas_draw_str(canvas,2,45,"Can crash your Flipper.");
|
||||
canvas_set_font(canvas, FontPrimary);
|
||||
canvas_draw_str(canvas,14,60,"To enable press OK");
|
||||
return;
|
||||
}
|
||||
|
||||
for (int y = 0; y < 64; y++) {
|
||||
for (int x = 0; x < 128; x++) {
|
||||
bool level = furi_hal_gpio_read(&gpio_cc1101_g0);
|
||||
if (level) canvas_draw_dot(canvas,x,y);
|
||||
/* Busy loop: this is a terrible approach as it blocks
|
||||
* everything else, but for now it's the best we can do
|
||||
* to obtain direct data with some spacing. */
|
||||
uint32_t x = 250; while(x--);
|
||||
}
|
||||
}
|
||||
canvas_set_font(canvas, FontSecondary);
|
||||
canvas_draw_str_with_border(canvas,36,60,"Direct sampling",
|
||||
ColorWhite,ColorBlack);
|
||||
}
|
||||
|
||||
/* Handle input */
|
||||
void process_input_direct_sampling(ProtoViewApp *app, InputEvent input) {
|
||||
if (input.type == InputTypePress && input.key == InputKeyOk) {
|
||||
app->direct_sampling_enabled = !app->direct_sampling_enabled;
|
||||
}
|
||||
}
|
||||
|
||||
/* Enter view. Stop the subghz thread to prevent access as we read
|
||||
* the CC1101 data directly. */
|
||||
void view_enter_direct_sampling(ProtoViewApp *app) {
|
||||
if (app->txrx->txrx_state == TxRxStateRx &&
|
||||
!app->txrx->debug_timer_sampling)
|
||||
{
|
||||
subghz_worker_stop(app->txrx->worker);
|
||||
} else {
|
||||
raw_sampling_worker_stop(app);
|
||||
}
|
||||
}
|
||||
|
||||
/* Exit view. Restore the subghz thread. */
|
||||
void view_exit_direct_sampling(ProtoViewApp *app) {
|
||||
if (app->txrx->txrx_state == TxRxStateRx &&
|
||||
!app->txrx->debug_timer_sampling)
|
||||
{
|
||||
subghz_worker_start(app->txrx->worker);
|
||||
} else {
|
||||
raw_sampling_worker_start(app);
|
||||
}
|
||||
app->direct_sampling_enabled = false;
|
||||
}
|
||||
165
applications/plugins/protoview/view_info.c
Normal file
165
applications/plugins/protoview/view_info.c
Normal file
@ -0,0 +1,165 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
#include <gui/view_i.h>
|
||||
#include <lib/toolbox/random_name.h>
|
||||
|
||||
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;
|
||||
} InfoViewPrivData;
|
||||
|
||||
/* Render the view with the detected message information. */
|
||||
static void render_subview_main(Canvas *const canvas, ProtoViewApp *app) {
|
||||
/* Protocol name as title. */
|
||||
canvas_set_font(canvas, FontPrimary);
|
||||
uint8_t y = 8, lineheight = 10;
|
||||
canvas_draw_str(canvas, 0, y, app->msg_info->name);
|
||||
y += lineheight;
|
||||
|
||||
/* Info fields. */
|
||||
char buf[128];
|
||||
canvas_set_font(canvas, FontSecondary);
|
||||
if (app->msg_info->raw[0]) {
|
||||
snprintf(buf,sizeof(buf),"Raw: %s", app->msg_info->raw);
|
||||
canvas_draw_str(canvas, 0, y, buf);
|
||||
y += lineheight;
|
||||
}
|
||||
canvas_draw_str(canvas, 0, y, app->msg_info->info1); y += lineheight;
|
||||
canvas_draw_str(canvas, 0, y, app->msg_info->info2); y += lineheight;
|
||||
canvas_draw_str(canvas, 0, y, app->msg_info->info3); y += lineheight;
|
||||
canvas_draw_str(canvas, 0, y, app->msg_info->info4); y += lineheight;
|
||||
|
||||
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: save, < >: slide rows");
|
||||
}
|
||||
|
||||
/* 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);
|
||||
canvas_draw_str(canvas, 30,36,"No signal decoded");
|
||||
return;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/* The user typed the file name. Let's save it and remove the keyboard
|
||||
* view. */
|
||||
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);
|
||||
dismiss_keyboard(app);
|
||||
}
|
||||
|
||||
/* 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->name,suffix,rand()%1000);
|
||||
str_replace(buf,' ','_');
|
||||
str_replace(buf,'-','_');
|
||||
str_replace(buf,'/','_');
|
||||
}
|
||||
|
||||
/* Handle input for the info view. */
|
||||
void process_input_info(ProtoViewApp *app, InputEvent input) {
|
||||
if (process_subview_updown(app,input,SubViewInfoLast)) return;
|
||||
InfoViewPrivData *privdata = app->view_privdata;
|
||||
int subview = get_current_subview(app);
|
||||
|
||||
/* Main subview. */
|
||||
if (subview == SubViewInfoMain) {
|
||||
if (input.type == InputTypeShort && input.key == InputKeyOk) {
|
||||
/* Reset the current sample to capture the next. */
|
||||
reset_current_signal(app);
|
||||
}
|
||||
} 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 == InputTypePress && input.key == InputKeyOk) {
|
||||
privdata->filename = malloc(SAVE_FILENAME_LEN);
|
||||
set_signal_random_filename(app,privdata->filename,SAVE_FILENAME_LEN);
|
||||
show_keyboard(app, privdata->filename, SAVE_FILENAME_LEN,
|
||||
text_input_done_callback);
|
||||
}
|
||||
}
|
||||
}
|
||||
97
applications/plugins/protoview/view_raw_signal.c
Normal file
97
applications/plugins/protoview/view_raw_signal.c
Normal file
@ -0,0 +1,97 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
|
||||
/* Render the received signal.
|
||||
*
|
||||
* The screen of the flipper is 128 x 64. Even using 4 pixels per line
|
||||
* (where low level signal is one pixel high, high level is 4 pixels
|
||||
* high) and 4 pixels of spacing between the different lines, we can
|
||||
* plot comfortably 8 lines.
|
||||
*
|
||||
* The 'idx' argument is the first sample to render in the circular
|
||||
* buffer. */
|
||||
void render_signal(ProtoViewApp *app, Canvas *const canvas, RawSamplesBuffer *buf, uint32_t idx) {
|
||||
canvas_set_color(canvas, ColorBlack);
|
||||
|
||||
int rows = 8;
|
||||
uint32_t time_per_pixel = app->us_scale;
|
||||
uint32_t start_idx = idx;
|
||||
bool level = 0;
|
||||
uint32_t dur = 0, sample_num = 0;
|
||||
for (int row = 0; row < rows ; row++) {
|
||||
for (int x = 0; x < 128; x++) {
|
||||
int y = 3 + row*8;
|
||||
if (dur < time_per_pixel/2) {
|
||||
/* Get more data. */
|
||||
raw_samples_get(buf, idx++, &level, &dur);
|
||||
sample_num++;
|
||||
}
|
||||
|
||||
canvas_draw_line(canvas, x,y,x,y-(level*3));
|
||||
|
||||
/* Write a small triangle under the last sample detected. */
|
||||
if (app->signal_bestlen != 0 &&
|
||||
sample_num+start_idx == app->signal_bestlen+1)
|
||||
{
|
||||
canvas_draw_dot(canvas,x,y+2);
|
||||
canvas_draw_dot(canvas,x-1,y+3);
|
||||
canvas_draw_dot(canvas,x,y+3);
|
||||
canvas_draw_dot(canvas,x+1,y+3);
|
||||
sample_num++; /* Make sure we don't mark the next, too. */
|
||||
}
|
||||
|
||||
/* Remove from the current level duration the time we
|
||||
* just plot. */
|
||||
if (dur > time_per_pixel)
|
||||
dur -= time_per_pixel;
|
||||
else
|
||||
dur = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Raw pulses rendering. This is our default view. */
|
||||
void render_view_raw_pulses(Canvas *const canvas, ProtoViewApp *app) {
|
||||
/* Show signal. */
|
||||
render_signal(app, canvas, DetectedSamples, app->signal_offset);
|
||||
|
||||
/* Show signal information. */
|
||||
char buf[64];
|
||||
snprintf(buf,sizeof(buf),"%luus",
|
||||
(unsigned long)DetectedSamples->short_pulse_dur);
|
||||
canvas_set_font(canvas, FontSecondary);
|
||||
canvas_draw_str_with_border(canvas, 97, 63, buf, ColorWhite, ColorBlack);
|
||||
if (app->signal_decoded) {
|
||||
canvas_set_font(canvas, FontPrimary);
|
||||
canvas_draw_str_with_border(canvas, 1, 61, app->msg_info->name, ColorWhite, ColorBlack);
|
||||
}
|
||||
}
|
||||
|
||||
/* Handle input for the raw pulses view. */
|
||||
void process_input_raw_pulses(ProtoViewApp *app, InputEvent input) {
|
||||
if (input.type == InputTypeRepeat) {
|
||||
/* Handle panning of the signal window. Long pressing
|
||||
* right will show successive samples, long pressing left
|
||||
* 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) {
|
||||
if (input.key == InputKeyOk) {
|
||||
/* Reset the current sample to capture the next. */
|
||||
reset_current_signal(app);
|
||||
} else if (input.key == InputKeyDown) {
|
||||
/* Rescaling. The set becomes finer under 50us per pixel. */
|
||||
uint32_t scale_step = app->us_scale >= 50 ? 50 : 10;
|
||||
if (app->us_scale < 500) app->us_scale += scale_step;
|
||||
} else if (input.key == InputKeyUp) {
|
||||
uint32_t scale_step = app->us_scale > 50 ? 50 : 10;
|
||||
if (app->us_scale > 10) app->us_scale -= scale_step;
|
||||
}
|
||||
}
|
||||
}
|
||||
117
applications/plugins/protoview/view_settings.c
Normal file
117
applications/plugins/protoview/view_settings.c
Normal file
@ -0,0 +1,117 @@
|
||||
/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
|
||||
* See the LICENSE file for information about the license. */
|
||||
|
||||
#include "app.h"
|
||||
|
||||
/* Renders a single view with frequency and modulation setting. However
|
||||
* this are logically two different views, and only one of the settings
|
||||
* will be highlighted. */
|
||||
void render_view_settings(Canvas *const canvas, ProtoViewApp *app) {
|
||||
canvas_set_font(canvas, FontPrimary);
|
||||
if (app->current_view == ViewFrequencySettings)
|
||||
canvas_draw_str_with_border(canvas,1,10,"Frequency",ColorWhite,ColorBlack);
|
||||
else
|
||||
canvas_draw_str(canvas,1,10,"Frequency");
|
||||
|
||||
if (app->current_view == ViewModulationSettings)
|
||||
canvas_draw_str_with_border(canvas,70,10,"Modulation",ColorWhite,ColorBlack);
|
||||
else
|
||||
canvas_draw_str(canvas,70,10,"Modulation");
|
||||
canvas_set_font(canvas, FontSecondary);
|
||||
canvas_draw_str(canvas,10,61,"Use up and down to modify");
|
||||
|
||||
if (app->txrx->debug_timer_sampling)
|
||||
canvas_draw_str(canvas,3,52,"(DEBUG timer sampling is ON)");
|
||||
|
||||
/* Show frequency. We can use big numbers font since it's just a number. */
|
||||
if (app->current_view == ViewFrequencySettings) {
|
||||
char buf[16];
|
||||
snprintf(buf,sizeof(buf),"%.2f",(double)app->frequency/1000000);
|
||||
canvas_set_font(canvas, FontBigNumbers);
|
||||
canvas_draw_str(canvas, 30, 40, buf);
|
||||
} else if (app->current_view == ViewModulationSettings) {
|
||||
int current = app->modulation;
|
||||
canvas_set_font(canvas, FontPrimary);
|
||||
canvas_draw_str(canvas, 33, 39, ProtoViewModulations[current].name);
|
||||
}
|
||||
}
|
||||
|
||||
/* Handle input for the settings view. */
|
||||
void process_input_settings(ProtoViewApp *app, InputEvent input) {
|
||||
if (input.type == InputTypeLong && input.key == InputKeyOk) {
|
||||
/* Long pressing to OK sets the default frequency and
|
||||
* modulation. */
|
||||
app->frequency = subghz_setting_get_default_frequency(app->setting);
|
||||
app->modulation = 0;
|
||||
} else if (0 && input.type == InputTypeLong && input.key == InputKeyDown) {
|
||||
/* Long pressing to down switches between normal and debug
|
||||
* timer sampling mode. NOTE: this feature is disabled for users,
|
||||
* only useful for devs (if useful at all). */
|
||||
|
||||
/* We have to stop the previous sampling system. */
|
||||
radio_rx_end(app);
|
||||
|
||||
/* Then switch mode and start the new one. */
|
||||
app->txrx->debug_timer_sampling = !app->txrx->debug_timer_sampling;
|
||||
radio_begin(app);
|
||||
radio_rx(app);
|
||||
} else if (input.type == InputTypePress &&
|
||||
(input.key != InputKeyDown || input.key != InputKeyUp))
|
||||
{
|
||||
/* Handle up and down to change frequency or modulation. */
|
||||
if (app->current_view == ViewFrequencySettings) {
|
||||
size_t curidx = 0, i;
|
||||
size_t count = subghz_setting_get_frequency_count(app->setting);
|
||||
|
||||
/* Scan the list of frequencies to check for the index of the
|
||||
* currently set frequency. */
|
||||
for(i = 0; i < count; i++) {
|
||||
uint32_t freq = subghz_setting_get_frequency(app->setting,i);
|
||||
if (freq == app->frequency) {
|
||||
curidx = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == count) return; /* Should never happen. */
|
||||
|
||||
if (input.key == InputKeyUp) {
|
||||
curidx = curidx == 0 ? count-1 : curidx-1;
|
||||
} else if (input.key == InputKeyDown) {
|
||||
curidx = (curidx+1) % count;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
app->frequency = subghz_setting_get_frequency(app->setting,curidx);
|
||||
} else if (app->current_view == ViewModulationSettings) {
|
||||
uint32_t count = 0;
|
||||
uint32_t modid = app->modulation;
|
||||
|
||||
while(ProtoViewModulations[count].name != NULL) count++;
|
||||
if (input.key == InputKeyUp) {
|
||||
modid = modid == 0 ? count-1 : modid-1;
|
||||
} else if (input.key == InputKeyDown) {
|
||||
modid = (modid+1) % count;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
app->modulation = modid;
|
||||
}
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
/* Apply changes when switching to other views. */
|
||||
app->txrx->freq_mod_changed = true;
|
||||
}
|
||||
|
||||
/* When the user switches to some other view, if they changed the parameters
|
||||
* we need to restart the radio with the right frequency and modulation. */
|
||||
void view_exit_settings(ProtoViewApp *app) {
|
||||
if (app->txrx->freq_mod_changed) {
|
||||
FURI_LOG_E(TAG, "Setting view, setting frequency/modulation to %lu %s", app->frequency, ProtoViewModulations[app->modulation].name);
|
||||
radio_rx_end(app);
|
||||
radio_begin(app);
|
||||
radio_rx(app);
|
||||
app->txrx->freq_mod_changed = false;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user