Restored Infrared and RFID CLI

applications/services/application.fam

@@ -10,6 +10,8 @@ App(
         "loader",
         "power",
 		"ibuttonsrv",
+		"infraredsrv",
+		"lfrfidsrv",
         "namechangersrv",
     ],
 )

applications/services/infraredsrv/application.fam

@@ -0,0 +1,7 @@
+App(
+    appid="infraredsrv",
+    apptype=FlipperAppType.STARTUP,
+    entry_point="infrared_on_system_start",
+    requires=["infrared"],
+    order=20,
+)

applications/services/infraredsrv/infrared_brute_force.c

@@ -0,0 +1,158 @@
+#include "infrared_brute_force.h"
+
+#include <stdlib.h>
+#include <m-dict.h>
+#include <flipper_format/flipper_format.h>
+
+#include "infrared_signal.h"
+
+typedef struct {
+    uint32_t index;
+    uint32_t count;
+} InfraredBruteForceRecord;
+
+DICT_DEF2(
+    InfraredBruteForceRecordDict,
+    FuriString*,
+    FURI_STRING_OPLIST,
+    InfraredBruteForceRecord,
+    M_POD_OPLIST);
+
+struct InfraredBruteForce {
+    FlipperFormat* ff;
+    const char* db_filename;
+    FuriString* current_record_name;
+    InfraredSignal* current_signal;
+    InfraredBruteForceRecordDict_t records;
+    bool is_started;
+};
+
+InfraredBruteForce* infrared_brute_force_alloc() {
+    InfraredBruteForce* brute_force = malloc(sizeof(InfraredBruteForce));
+    brute_force->ff = NULL;
+    brute_force->db_filename = NULL;
+    brute_force->current_signal = NULL;
+    brute_force->is_started = false;
+    brute_force->current_record_name = furi_string_alloc();
+    InfraredBruteForceRecordDict_init(brute_force->records);
+    return brute_force;
+}
+
+void infrared_brute_force_clear_records(InfraredBruteForce* brute_force) {
+    furi_assert(!brute_force->is_started);
+    InfraredBruteForceRecordDict_reset(brute_force->records);
+}
+
+void infrared_brute_force_free(InfraredBruteForce* brute_force) {
+    furi_assert(!brute_force->is_started);
+    InfraredBruteForceRecordDict_clear(brute_force->records);
+    furi_string_free(brute_force->current_record_name);
+    free(brute_force);
+}
+
+void infrared_brute_force_set_db_filename(InfraredBruteForce* brute_force, const char* db_filename) {
+    furi_assert(!brute_force->is_started);
+    brute_force->db_filename = db_filename;
+}
+
+bool infrared_brute_force_calculate_messages(InfraredBruteForce* brute_force) {
+    furi_assert(!brute_force->is_started);
+    furi_assert(brute_force->db_filename);
+    bool success = false;
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
+
+    success = flipper_format_buffered_file_open_existing(ff, brute_force->db_filename);
+    if(success) {
+        FuriString* signal_name;
+        signal_name = furi_string_alloc();
+        while(flipper_format_read_string(ff, "name", signal_name)) {
+            InfraredBruteForceRecord* record =
+                InfraredBruteForceRecordDict_get(brute_force->records, signal_name);
+            if(record) {
+                ++(record->count);
+            }
+        }
+        furi_string_free(signal_name);
+    }
+
+    flipper_format_free(ff);
+    furi_record_close(RECORD_STORAGE);
+    return success;
+}
+
+bool infrared_brute_force_start(
+    InfraredBruteForce* brute_force,
+    uint32_t index,
+    uint32_t* record_count) {
+    furi_assert(!brute_force->is_started);
+    bool success = false;
+    *record_count = 0;
+
+    InfraredBruteForceRecordDict_it_t it;
+    for(InfraredBruteForceRecordDict_it(it, brute_force->records);
+        !InfraredBruteForceRecordDict_end_p(it);
+        InfraredBruteForceRecordDict_next(it)) {
+        const InfraredBruteForceRecordDict_itref_t* record = InfraredBruteForceRecordDict_cref(it);
+        if(record->value.index == index) {
+            *record_count = record->value.count;
+            if(*record_count) {
+                furi_string_set(brute_force->current_record_name, record->key);
+            }
+            break;
+        }
+    }
+
+    if(*record_count) {
+        Storage* storage = furi_record_open(RECORD_STORAGE);
+        brute_force->ff = flipper_format_buffered_file_alloc(storage);
+        brute_force->current_signal = infrared_signal_alloc();
+        brute_force->is_started = true;
+        success =
+            flipper_format_buffered_file_open_existing(brute_force->ff, brute_force->db_filename);
+        if(!success) infrared_brute_force_stop(brute_force);
+    }
+    return success;
+}
+
+bool infrared_brute_force_is_started(InfraredBruteForce* brute_force) {
+    return brute_force->is_started;
+}
+
+void infrared_brute_force_stop(InfraredBruteForce* brute_force) {
+    furi_assert(brute_force->is_started);
+    furi_string_reset(brute_force->current_record_name);
+    infrared_signal_free(brute_force->current_signal);
+    flipper_format_free(brute_force->ff);
+    brute_force->current_signal = NULL;
+    brute_force->ff = NULL;
+    brute_force->is_started = false;
+    furi_record_close(RECORD_STORAGE);
+}
+
+bool infrared_brute_force_send_next(InfraredBruteForce* brute_force) {
+    furi_assert(brute_force->is_started);
+    const bool success = infrared_signal_search_and_read(
+        brute_force->current_signal, brute_force->ff, brute_force->current_record_name);
+    if(success) {
+        infrared_signal_transmit(brute_force->current_signal);
+    }
+    return success;
+}
+
+void infrared_brute_force_add_record(
+    InfraredBruteForce* brute_force,
+    uint32_t index,
+    const char* name) {
+    InfraredBruteForceRecord value = {.index = index, .count = 0};
+    FuriString* key;
+    key = furi_string_alloc_set(name);
+    InfraredBruteForceRecordDict_set_at(brute_force->records, key, value);
+    furi_string_free(key);
+}
+
+void infrared_brute_force_reset(InfraredBruteForce* brute_force) {
+    furi_assert(!brute_force->is_started);
+    InfraredBruteForceRecordDict_reset(brute_force->records);
+}

applications/services/infraredsrv/infrared_brute_force.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct InfraredBruteForce InfraredBruteForce;
+
+InfraredBruteForce* infrared_brute_force_alloc();
+void infrared_brute_force_free(InfraredBruteForce* brute_force);
+void infrared_brute_force_set_db_filename(InfraredBruteForce* brute_force, const char* db_filename);
+bool infrared_brute_force_calculate_messages(InfraredBruteForce* brute_force);
+bool infrared_brute_force_start(
+    InfraredBruteForce* brute_force,
+    uint32_t index,
+    uint32_t* record_count);
+bool infrared_brute_force_is_started(InfraredBruteForce* brute_force);
+void infrared_brute_force_stop(InfraredBruteForce* brute_force);
+bool infrared_brute_force_send_next(InfraredBruteForce* brute_force);
+void infrared_brute_force_clear_records(InfraredBruteForce* brute_force);
+void infrared_brute_force_add_record(
+    InfraredBruteForce* brute_force,
+    uint32_t index,
+    const char* name);

applications/services/infraredsrv/infrared_signal.c

@@ -0,0 +1,300 @@
+#include "infrared_signal.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <core/check.h>
+#include <infrared_worker.h>
+#include <infrared_transmit.h>
+
+#define TAG "InfraredSignal"
+
+struct InfraredSignal {
+    bool is_raw;
+    union {
+        InfraredMessage message;
+        InfraredRawSignal raw;
+    } payload;
+};
+
+static void infrared_signal_clear_timings(InfraredSignal* signal) {
+    if(signal->is_raw) {
+        free(signal->payload.raw.timings);
+        signal->payload.raw.timings_size = 0;
+        signal->payload.raw.timings = NULL;
+    }
+}
+
+static bool infrared_signal_is_message_valid(InfraredMessage* message) {
+    if(!infrared_is_protocol_valid(message->protocol)) {
+        FURI_LOG_E(TAG, "Unknown protocol");
+        return false;
+    }
+
+    uint32_t address_length = infrared_get_protocol_address_length(message->protocol);
+    uint32_t address_mask = (1UL << address_length) - 1;
+
+    if(message->address != (message->address & address_mask)) {
+        FURI_LOG_E(
+            TAG,
+            "Address is out of range (mask 0x%08lX): 0x%lX\r\n",
+            address_mask,
+            message->address);
+        return false;
+    }
+
+    uint32_t command_length = infrared_get_protocol_command_length(message->protocol);
+    uint32_t command_mask = (1UL << command_length) - 1;
+
+    if(message->command != (message->command & command_mask)) {
+        FURI_LOG_E(
+            TAG,
+            "Command is out of range (mask 0x%08lX): 0x%lX\r\n",
+            command_mask,
+            message->command);
+        return false;
+    }
+
+    return true;
+}
+
+static bool infrared_signal_is_raw_valid(InfraredRawSignal* raw) {
+    if((raw->frequency > INFRARED_MAX_FREQUENCY) || (raw->frequency < INFRARED_MIN_FREQUENCY)) {
+        FURI_LOG_E(
+            TAG,
+            "Frequency is out of range (%X - %X): %lX",
+            INFRARED_MIN_FREQUENCY,
+            INFRARED_MAX_FREQUENCY,
+            raw->frequency);
+        return false;
+
+    } else if((raw->duty_cycle <= 0) || (raw->duty_cycle > 1)) {
+        FURI_LOG_E(TAG, "Duty cycle is out of range (0 - 1): %f", (double)raw->duty_cycle);
+        return false;
+
+    } else if((raw->timings_size <= 0) || (raw->timings_size > MAX_TIMINGS_AMOUNT)) {
+        FURI_LOG_E(
+            TAG,
+            "Timings amount is out of range (0 - %X): %X",
+            MAX_TIMINGS_AMOUNT,
+            raw->timings_size);
+        return false;
+    }
+
+    return true;
+}
+
+static inline bool infrared_signal_save_message(InfraredMessage* message, FlipperFormat* ff) {
+    const char* protocol_name = infrared_get_protocol_name(message->protocol);
+    return flipper_format_write_string_cstr(ff, "type", "parsed") &&
+           flipper_format_write_string_cstr(ff, "protocol", protocol_name) &&
+           flipper_format_write_hex(ff, "address", (uint8_t*)&message->address, 4) &&
+           flipper_format_write_hex(ff, "command", (uint8_t*)&message->command, 4);
+}
+
+static inline bool infrared_signal_save_raw(InfraredRawSignal* raw, FlipperFormat* ff) {
+    furi_assert(raw->timings_size <= MAX_TIMINGS_AMOUNT);
+    return flipper_format_write_string_cstr(ff, "type", "raw") &&
+           flipper_format_write_uint32(ff, "frequency", &raw->frequency, 1) &&
+           flipper_format_write_float(ff, "duty_cycle", &raw->duty_cycle, 1) &&
+           flipper_format_write_uint32(ff, "data", raw->timings, raw->timings_size);
+}
+
+static inline bool infrared_signal_read_message(InfraredSignal* signal, FlipperFormat* ff) {
+    FuriString* buf;
+    buf = furi_string_alloc();
+    bool success = false;
+
+    do {
+        if(!flipper_format_read_string(ff, "protocol", buf)) break;
+
+        InfraredMessage message;
+        message.protocol = infrared_get_protocol_by_name(furi_string_get_cstr(buf));
+
+        success = flipper_format_read_hex(ff, "address", (uint8_t*)&message.address, 4) &&
+                  flipper_format_read_hex(ff, "command", (uint8_t*)&message.command, 4) &&
+                  infrared_signal_is_message_valid(&message);
+
+        if(!success) break;
+
+        infrared_signal_set_message(signal, &message);
+    } while(0);
+
+    furi_string_free(buf);
+    return success;
+}
+
+static inline bool infrared_signal_read_raw(InfraredSignal* signal, FlipperFormat* ff) {
+    uint32_t timings_size, frequency;
+    float duty_cycle;
+
+    bool success = flipper_format_read_uint32(ff, "frequency", &frequency, 1) &&
+                   flipper_format_read_float(ff, "duty_cycle", &duty_cycle, 1) &&
+                   flipper_format_get_value_count(ff, "data", &timings_size);
+
+    if(!success || timings_size > MAX_TIMINGS_AMOUNT) {
+        return false;
+    }
+
+    uint32_t* timings = malloc(sizeof(uint32_t) * timings_size);
+    success = flipper_format_read_uint32(ff, "data", timings, timings_size);
+
+    if(success) {
+        infrared_signal_set_raw_signal(signal, timings, timings_size, frequency, duty_cycle);
+    }
+
+    free(timings);
+    return success;
+}
+
+static bool infrared_signal_read_body(InfraredSignal* signal, FlipperFormat* ff) {
+    FuriString* tmp = furi_string_alloc();
+
+    bool success = false;
+
+    do {
+        if(!flipper_format_read_string(ff, "type", tmp)) break;
+        if(furi_string_equal(tmp, "raw")) {
+            success = infrared_signal_read_raw(signal, ff);
+        } else if(furi_string_equal(tmp, "parsed")) {
+            success = infrared_signal_read_message(signal, ff);
+        } else {
+            FURI_LOG_E(TAG, "Unknown signal type");
+        }
+    } while(false);
+
+    furi_string_free(tmp);
+    return success;
+}
+
+InfraredSignal* infrared_signal_alloc() {
+    InfraredSignal* signal = malloc(sizeof(InfraredSignal));
+
+    signal->is_raw = false;
+    signal->payload.message.protocol = InfraredProtocolUnknown;
+
+    return signal;
+}
+
+void infrared_signal_free(InfraredSignal* signal) {
+    infrared_signal_clear_timings(signal);
+    free(signal);
+}
+
+bool infrared_signal_is_raw(InfraredSignal* signal) {
+    return signal->is_raw;
+}
+
+bool infrared_signal_is_valid(InfraredSignal* signal) {
+    return signal->is_raw ? infrared_signal_is_raw_valid(&signal->payload.raw) :
+                            infrared_signal_is_message_valid(&signal->payload.message);
+}
+
+void infrared_signal_set_signal(InfraredSignal* signal, const InfraredSignal* other) {
+    if(other->is_raw) {
+        const InfraredRawSignal* raw = &other->payload.raw;
+        infrared_signal_set_raw_signal(
+            signal, raw->timings, raw->timings_size, raw->frequency, raw->duty_cycle);
+    } else {
+        const InfraredMessage* message = &other->payload.message;
+        infrared_signal_set_message(signal, message);
+    }
+}
+
+void infrared_signal_set_raw_signal(
+    InfraredSignal* signal,
+    const uint32_t* timings,
+    size_t timings_size,
+    uint32_t frequency,
+    float duty_cycle) {
+    infrared_signal_clear_timings(signal);
+
+    signal->is_raw = true;
+
+    signal->payload.raw.timings_size = timings_size;
+    signal->payload.raw.frequency = frequency;
+    signal->payload.raw.duty_cycle = duty_cycle;
+
+    signal->payload.raw.timings = malloc(timings_size * sizeof(uint32_t));
+    memcpy(signal->payload.raw.timings, timings, timings_size * sizeof(uint32_t));
+}
+
+InfraredRawSignal* infrared_signal_get_raw_signal(InfraredSignal* signal) {
+    furi_assert(signal->is_raw);
+    return &signal->payload.raw;
+}
+
+void infrared_signal_set_message(InfraredSignal* signal, const InfraredMessage* message) {
+    infrared_signal_clear_timings(signal);
+
+    signal->is_raw = false;
+    signal->payload.message = *message;
+}
+
+InfraredMessage* infrared_signal_get_message(InfraredSignal* signal) {
+    furi_assert(!signal->is_raw);
+    return &signal->payload.message;
+}
+
+bool infrared_signal_save(InfraredSignal* signal, FlipperFormat* ff, const char* name) {
+    if(!flipper_format_write_comment_cstr(ff, "") ||
+       !flipper_format_write_string_cstr(ff, "name", name)) {
+        return false;
+    } else if(signal->is_raw) {
+        return infrared_signal_save_raw(&signal->payload.raw, ff);
+    } else {
+        return infrared_signal_save_message(&signal->payload.message, ff);
+    }
+}
+
+bool infrared_signal_read(InfraredSignal* signal, FlipperFormat* ff, FuriString* name) {
+    FuriString* tmp = furi_string_alloc();
+
+    bool success = false;
+
+    do {
+        if(!flipper_format_read_string(ff, "name", tmp)) break;
+        furi_string_set(name, tmp);
+        if(!infrared_signal_read_body(signal, ff)) break;
+        success = true;
+    } while(0);
+
+    furi_string_free(tmp);
+    return success;
+}
+
+bool infrared_signal_search_and_read(
+    InfraredSignal* signal,
+    FlipperFormat* ff,
+    const FuriString* name) {
+    bool success = false;
+    FuriString* tmp = furi_string_alloc();
+
+    do {
+        bool is_name_found = false;
+        while(flipper_format_read_string(ff, "name", tmp)) {
+            is_name_found = furi_string_equal(name, tmp);
+            if(is_name_found) break;
+        }
+        if(!is_name_found) break;
+        if(!infrared_signal_read_body(signal, ff)) break;
+        success = true;
+    } while(false);
+
+    furi_string_free(tmp);
+    return success;
+}
+
+void infrared_signal_transmit(InfraredSignal* signal) {
+    if(signal->is_raw) {
+        InfraredRawSignal* raw_signal = &signal->payload.raw;
+        infrared_send_raw_ext(
+            raw_signal->timings,
+            raw_signal->timings_size,
+            true,
+            raw_signal->frequency,
+            raw_signal->duty_cycle);
+    } else {
+        InfraredMessage* message = &signal->payload.message;
+        infrared_send(message, 1);
+    }
+}

applications/services/infraredsrv/infrared_signal.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <infrared.h>
+#include <flipper_format/flipper_format.h>
+
+typedef struct InfraredSignal InfraredSignal;
+
+typedef struct {
+    size_t timings_size;
+    uint32_t* timings;
+    uint32_t frequency;
+    float duty_cycle;
+} InfraredRawSignal;
+
+InfraredSignal* infrared_signal_alloc();
+void infrared_signal_free(InfraredSignal* signal);
+
+bool infrared_signal_is_raw(InfraredSignal* signal);
+bool infrared_signal_is_valid(InfraredSignal* signal);
+
+void infrared_signal_set_signal(InfraredSignal* signal, const InfraredSignal* other);
+
+void infrared_signal_set_raw_signal(
+    InfraredSignal* signal,
+    const uint32_t* timings,
+    size_t timings_size,
+    uint32_t frequency,
+    float duty_cycle);
+InfraredRawSignal* infrared_signal_get_raw_signal(InfraredSignal* signal);
+
+void infrared_signal_set_message(InfraredSignal* signal, const InfraredMessage* message);
+InfraredMessage* infrared_signal_get_message(InfraredSignal* signal);
+
+bool infrared_signal_save(InfraredSignal* signal, FlipperFormat* ff, const char* name);
+bool infrared_signal_read(InfraredSignal* signal, FlipperFormat* ff, FuriString* name);
+bool infrared_signal_search_and_read(
+    InfraredSignal* signal,
+    FlipperFormat* ff,
+    const FuriString* name);
+
+void infrared_signal_transmit(InfraredSignal* signal);

applications/services/infraredsrv/infraredsrv_cli.c

@@ -0,0 +1,517 @@
+#include <cli/cli.h>
+#include <cli/cli_i.h>
+#include <infrared.h>
+#include <infrared_worker.h>
+#include <furi_hal_infrared.h>
+#include <flipper_format.h>
+#include <toolbox/args.h>
+#include <m-dict.h>
+
+#include "infrared_signal.h"
+#include "infrared_brute_force.h"
+
+#define INFRARED_CLI_BUF_SIZE 10
+#define INFRARED_ASSETS_FOLDER "infrared/assets"
+#define INFRARED_BRUTE_FORCE_DUMMY_INDEX 0
+
+DICT_DEF2(dict_signals, FuriString*, FURI_STRING_OPLIST, int, M_DEFAULT_OPLIST)
+
+static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args);
+static void infrared_cli_start_ir_tx(Cli* cli, FuriString* args);
+static void infrared_cli_process_decode(Cli* cli, FuriString* args);
+static void infrared_cli_process_universal(Cli* cli, FuriString* args);
+
+static const struct {
+    const char* cmd;
+    void (*process_function)(Cli* cli, FuriString* args);
+} infrared_cli_commands[] = {
+    {.cmd = "rx", .process_function = infrared_cli_start_ir_rx},
+    {.cmd = "tx", .process_function = infrared_cli_start_ir_tx},
+    {.cmd = "decode", .process_function = infrared_cli_process_decode},
+    {.cmd = "universal", .process_function = infrared_cli_process_universal},
+};
+
+static void signal_received_callback(void* context, InfraredWorkerSignal* received_signal) {
+    furi_assert(received_signal);
+    char buf[100];
+    size_t buf_cnt;
+    Cli* cli = (Cli*)context;
+
+    if(infrared_worker_signal_is_decoded(received_signal)) {
+        const InfraredMessage* message = infrared_worker_get_decoded_signal(received_signal);
+        buf_cnt = snprintf(
+            buf,
+            sizeof(buf),
+            "%s, A:0x%0*lX, C:0x%0*lX%s\r\n",
+            infrared_get_protocol_name(message->protocol),
+            ROUND_UP_TO(infrared_get_protocol_address_length(message->protocol), 4),
+            message->address,
+            ROUND_UP_TO(infrared_get_protocol_command_length(message->protocol), 4),
+            message->command,
+            message->repeat ? " R" : "");
+        cli_write(cli, (uint8_t*)buf, buf_cnt);
+    } else {
+        const uint32_t* timings;
+        size_t timings_cnt;
+        infrared_worker_get_raw_signal(received_signal, &timings, &timings_cnt);
+
+        buf_cnt = snprintf(buf, sizeof(buf), "RAW, %d samples:\r\n", timings_cnt);
+        cli_write(cli, (uint8_t*)buf, buf_cnt);
+        for(size_t i = 0; i < timings_cnt; ++i) {
+            buf_cnt = snprintf(buf, sizeof(buf), "%lu ", timings[i]);
+            cli_write(cli, (uint8_t*)buf, buf_cnt);
+        }
+        buf_cnt = snprintf(buf, sizeof(buf), "\r\n");
+        cli_write(cli, (uint8_t*)buf, buf_cnt);
+    }
+}
+
+static void infrared_cli_print_usage(void) {
+    printf("Usage:\r\n");
+    printf("\tir rx [raw]\r\n");
+    printf("\tir tx <protocol> <address> <command>\r\n");
+    printf("\t<command> and <address> are hex-formatted\r\n");
+    printf("\tAvailable protocols:");
+    for(int i = 0; infrared_is_protocol_valid((InfraredProtocol)i); ++i) {
+        printf(" %s", infrared_get_protocol_name((InfraredProtocol)i));
+    }
+    printf("\r\n");
+    printf("\tRaw format:\r\n");
+    printf("\tir tx RAW F:<frequency> DC:<duty_cycle> <sample0> <sample1>...\r\n");
+    printf(
+        "\tFrequency (%d - %d), Duty cycle (0 - 100), max 512 samples\r\n",
+        INFRARED_MIN_FREQUENCY,
+        INFRARED_MAX_FREQUENCY);
+    printf("\tir decode <input_file> [<output_file>]\r\n");
+    printf("\tir universal <remote_name> <signal_name>\r\n");
+    printf("\tir universal list <remote_name>\r\n");
+    // TODO: Do not hardcode universal remote names
+    printf("\tAvailable universal remotes: tv audio ac\r\n");
+}
+
+static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args) {
+    UNUSED(cli);
+
+    bool enable_decoding = true;
+
+    if(!furi_string_empty(args)) {
+        if(!furi_string_cmp_str(args, "raw")) {
+            enable_decoding = false;
+        } else {
+            printf("Wrong arguments.\r\n");
+            infrared_cli_print_usage();
+            return;
+        }
+    }
+
+    InfraredWorker* worker = infrared_worker_alloc();
+    infrared_worker_rx_enable_signal_decoding(worker, enable_decoding);
+    infrared_worker_rx_start(worker);
+    infrared_worker_rx_set_received_signal_callback(worker, signal_received_callback, cli);
+
+    printf("Receiving %s INFRARED...\r\nPress Ctrl+C to abort\r\n", enable_decoding ? "" : "RAW");
+    while(!cli_cmd_interrupt_received(cli)) {
+        furi_delay_ms(50);
+    }
+
+    infrared_worker_rx_stop(worker);
+    infrared_worker_free(worker);
+}
+
+static bool infrared_cli_parse_message(const char* str, InfraredSignal* signal) {
+    char protocol_name[32];
+    InfraredMessage message;
+    int parsed = sscanf(str, "%31s %lX %lX", protocol_name, &message.address, &message.command);
+
+    if(parsed != 3) {
+        return false;
+    }
+
+    message.protocol = infrared_get_protocol_by_name(protocol_name);
+    message.repeat = false;
+    infrared_signal_set_message(signal, &message);
+    return infrared_signal_is_valid(signal);
+}
+
+static bool infrared_cli_parse_raw(const char* str, InfraredSignal* signal) {
+    char frequency_str[INFRARED_CLI_BUF_SIZE];
+    char duty_cycle_str[INFRARED_CLI_BUF_SIZE];
+    int parsed = sscanf(str, "RAW F:%9s DC:%9s", frequency_str, duty_cycle_str);
+
+    if(parsed != 2) {
+        return false;
+    }
+
+    uint32_t* timings = malloc(sizeof(uint32_t) * MAX_TIMINGS_AMOUNT);
+    uint32_t frequency = atoi(frequency_str);
+    float duty_cycle = (float)atoi(duty_cycle_str) / 100;
+
+    str += strlen(frequency_str) + strlen(duty_cycle_str) + INFRARED_CLI_BUF_SIZE;
+
+    size_t timings_size = 0;
+    while(1) {
+        while(*str == ' ') {
+            ++str;
+        }
+
+        char timing_str[INFRARED_CLI_BUF_SIZE];
+        if(sscanf(str, "%9s", timing_str) != 1) {
+            break;
+        }
+
+        str += strlen(timing_str);
+        uint32_t timing = atoi(timing_str);
+
+        if((timing <= 0) || (timings_size >= MAX_TIMINGS_AMOUNT)) {
+            break;
+        }
+
+        timings[timings_size] = timing;
+        ++timings_size;
+    }
+
+    infrared_signal_set_raw_signal(signal, timings, timings_size, frequency, duty_cycle);
+    free(timings);
+
+    return infrared_signal_is_valid(signal);
+}
+
+static void infrared_cli_start_ir_tx(Cli* cli, FuriString* args) {
+    UNUSED(cli);
+    const char* str = furi_string_get_cstr(args);
+    InfraredSignal* signal = infrared_signal_alloc();
+
+    bool success = infrared_cli_parse_message(str, signal) || infrared_cli_parse_raw(str, signal);
+    if(success) {
+        infrared_signal_transmit(signal);
+    } else {
+        printf("Wrong arguments.\r\n");
+        infrared_cli_print_usage();
+    }
+
+    infrared_signal_free(signal);
+}
+
+static bool
+    infrared_cli_save_signal(InfraredSignal* signal, FlipperFormat* file, const char* name) {
+    bool ret = infrared_signal_save(signal, file, name);
+    if(!ret) {
+        printf("Failed to save signal: \"%s\"\r\n", name);
+    }
+    return ret;
+}
+
+static bool infrared_cli_decode_raw_signal(
+    InfraredRawSignal* raw_signal,
+    InfraredDecoderHandler* decoder,
+    FlipperFormat* output_file,
+    const char* signal_name) {
+    InfraredSignal* signal = infrared_signal_alloc();
+    bool ret = false, level = true, is_decoded = false;
+
+    size_t i;
+    for(i = 0; i < raw_signal->timings_size; ++i) {
+        // TODO: Any infrared_check_decoder_ready() magic?
+        const InfraredMessage* message = infrared_decode(decoder, level, raw_signal->timings[i]);
+
+        if(message) {
+            is_decoded = true;
+            printf(
+                "Protocol: %s address: 0x%lX command: 0x%lX %s\r\n",
+                infrared_get_protocol_name(message->protocol),
+                message->address,
+                message->command,
+                (message->repeat ? "R" : ""));
+            if(output_file && !message->repeat) {
+                infrared_signal_set_message(signal, message);
+                if(!infrared_cli_save_signal(signal, output_file, signal_name)) break;
+            }
+        }
+
+        level = !level;
+    }
+
+    if(i == raw_signal->timings_size) {
+        if(!is_decoded && output_file) {
+            infrared_signal_set_raw_signal(
+                signal,
+                raw_signal->timings,
+                raw_signal->timings_size,
+                raw_signal->frequency,
+                raw_signal->duty_cycle);
+            ret = infrared_cli_save_signal(signal, output_file, signal_name);
+        } else {
+            ret = true;
+        }
+    }
+
+    infrared_reset_decoder(decoder);
+    infrared_signal_free(signal);
+    return ret;
+}
+
+static bool infrared_cli_decode_file(FlipperFormat* input_file, FlipperFormat* output_file) {
+    bool ret = false;
+
+    InfraredSignal* signal = infrared_signal_alloc();
+    InfraredDecoderHandler* decoder = infrared_alloc_decoder();
+
+    FuriString* tmp;
+    tmp = furi_string_alloc();
+
+    while(infrared_signal_read(signal, input_file, tmp)) {
+        ret = false;
+        if(!infrared_signal_is_valid(signal)) {
+            printf("Invalid signal\r\n");
+            break;
+        }
+        if(!infrared_signal_is_raw(signal)) {
+            if(output_file &&
+               !infrared_cli_save_signal(signal, output_file, furi_string_get_cstr(tmp))) {
+                break;
+            } else {
+                printf("Skipping decoded signal\r\n");
+                continue;
+            }
+        }
+        InfraredRawSignal* raw_signal = infrared_signal_get_raw_signal(signal);
+        printf(
+            "Raw signal: %s, %u samples\r\n", furi_string_get_cstr(tmp), raw_signal->timings_size);
+        if(!infrared_cli_decode_raw_signal(
+               raw_signal, decoder, output_file, furi_string_get_cstr(tmp)))
+            break;
+        ret = true;
+    }
+
+    infrared_free_decoder(decoder);
+    infrared_signal_free(signal);
+    furi_string_free(tmp);
+
+    return ret;
+}
+
+static void infrared_cli_process_decode(Cli* cli, FuriString* args) {
+    UNUSED(cli);
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FlipperFormat* input_file = flipper_format_buffered_file_alloc(storage);
+    FlipperFormat* output_file = NULL;
+
+    uint32_t version;
+    FuriString *tmp, *header, *input_path, *output_path;
+    tmp = furi_string_alloc();
+    header = furi_string_alloc();
+    input_path = furi_string_alloc();
+    output_path = furi_string_alloc();
+
+    do {
+        if(!args_read_probably_quoted_string_and_trim(args, input_path)) {
+            printf("Wrong arguments.\r\n");
+            infrared_cli_print_usage();
+            break;
+        }
+        args_read_probably_quoted_string_and_trim(args, output_path);
+        if(!flipper_format_buffered_file_open_existing(
+               input_file, furi_string_get_cstr(input_path))) {
+            printf(
+                "Failed to open file for reading: \"%s\"\r\n", furi_string_get_cstr(input_path));
+            break;
+        }
+        if(!flipper_format_read_header(input_file, header, &version) ||
+           (!furi_string_start_with_str(header, "IR")) || version != 1) {
+            printf(
+                "Invalid or corrupted input file: \"%s\"\r\n", furi_string_get_cstr(input_path));
+            break;
+        }
+        if(!furi_string_empty(output_path)) {
+            printf("Writing output to file: \"%s\"\r\n", furi_string_get_cstr(output_path));
+            output_file = flipper_format_file_alloc(storage);
+        }
+        if(output_file &&
+           !flipper_format_file_open_always(output_file, furi_string_get_cstr(output_path))) {
+            printf(
+                "Failed to open file for writing: \"%s\"\r\n", furi_string_get_cstr(output_path));
+            break;
+        }
+        if(output_file && !flipper_format_write_header(output_file, header, version)) {
+            printf(
+                "Failed to write to the output file: \"%s\"\r\n",
+                furi_string_get_cstr(output_path));
+            break;
+        }
+        if(!infrared_cli_decode_file(input_file, output_file)) {
+            break;
+        }
+        printf("File successfully decoded.\r\n");
+    } while(false);
+
+    furi_string_free(tmp);
+    furi_string_free(header);
+    furi_string_free(input_path);
+    furi_string_free(output_path);
+
+    flipper_format_free(input_file);
+    if(output_file) flipper_format_free(output_file);
+    furi_record_close(RECORD_STORAGE);
+}
+
+static void infrared_cli_list_remote_signals(FuriString* remote_name) {
+    if(furi_string_empty(remote_name)) {
+        printf("Missing remote name.\r\n");
+        return;
+    }
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
+    FuriString* remote_path = furi_string_alloc_printf(
+        "%s/%s.ir", EXT_PATH(INFRARED_ASSETS_FOLDER), furi_string_get_cstr(remote_name));
+
+    do {
+        if(!flipper_format_buffered_file_open_existing(ff, furi_string_get_cstr(remote_path))) {
+            printf("Invalid remote name.\r\n");
+            break;
+        }
+
+        dict_signals_t signals_dict;
+        dict_signals_init(signals_dict);
+
+        FuriString* key = furi_string_alloc();
+        FuriString* signal_name = furi_string_alloc();
+
+        printf("Valid signals:\r\n");
+        int max = 1;
+        while(flipper_format_read_string(ff, "name", signal_name)) {
+            furi_string_set_str(key, furi_string_get_cstr(signal_name));
+            int* v = dict_signals_get(signals_dict, key);
+            if(v != NULL) {
+                (*v)++;
+                max = M_MAX(*v, max);
+            } else {
+                dict_signals_set_at(signals_dict, key, 1);
+            }
+        }
+
+        dict_signals_it_t it;
+        for(dict_signals_it(it, signals_dict); !dict_signals_end_p(it); dict_signals_next(it)) {
+            const struct dict_signals_pair_s* pair = dict_signals_cref(it);
+            printf("\t%s\r\n", furi_string_get_cstr(pair->key));
+        }
+
+        furi_string_free(key);
+        furi_string_free(signal_name);
+        dict_signals_clear(signals_dict);
+
+    } while(false);
+
+    flipper_format_free(ff);
+    furi_string_free(remote_path);
+    furi_record_close(RECORD_STORAGE);
+}
+
+static void
+    infrared_cli_brute_force_signals(Cli* cli, FuriString* remote_name, FuriString* signal_name) {
+    InfraredBruteForce* brute_force = infrared_brute_force_alloc();
+    FuriString* remote_path = furi_string_alloc_printf(
+        "%s/%s.ir", EXT_PATH(INFRARED_ASSETS_FOLDER), furi_string_get_cstr(remote_name));
+
+    infrared_brute_force_set_db_filename(brute_force, furi_string_get_cstr(remote_path));
+    infrared_brute_force_add_record(
+        brute_force, INFRARED_BRUTE_FORCE_DUMMY_INDEX, furi_string_get_cstr(signal_name));
+
+    do {
+        if(furi_string_empty(signal_name)) {
+            printf("Missing signal name.\r\n");
+            break;
+        }
+        if(!infrared_brute_force_calculate_messages(brute_force)) {
+            printf("Invalid remote name.\r\n");
+            break;
+        }
+
+        uint32_t record_count;
+        bool running = infrared_brute_force_start(
+            brute_force, INFRARED_BRUTE_FORCE_DUMMY_INDEX, &record_count);
+
+        if(record_count <= 0) {
+            printf("Invalid signal name.\r\n");
+            break;
+        }
+
+        printf("Sending %ld signal(s)...\r\n", record_count);
+        printf("Press Ctrl-C to stop.\r\n");
+
+        int records_sent = 0;
+        while(running) {
+            running = infrared_brute_force_send_next(brute_force);
+
+            if(cli_cmd_interrupt_received(cli)) break;
+
+            printf("\r%d%% complete.", (int)((float)records_sent++ / (float)record_count * 100));
+            fflush(stdout);
+        }
+
+        infrared_brute_force_stop(brute_force);
+    } while(false);
+
+    furi_string_free(remote_path);
+    infrared_brute_force_clear_records(brute_force);
+    infrared_brute_force_free(brute_force);
+}
+
+static void infrared_cli_process_universal(Cli* cli, FuriString* args) {
+    FuriString* arg1 = furi_string_alloc();
+    FuriString* arg2 = furi_string_alloc();
+
+    do {
+        if(!args_read_string_and_trim(args, arg1)) break;
+        if(!args_read_string_and_trim(args, arg2)) break;
+    } while(false);
+
+    if(furi_string_empty(arg1)) {
+        printf("Wrong arguments.\r\n");
+        infrared_cli_print_usage();
+    } else if(furi_string_equal_str(arg1, "list")) {
+        infrared_cli_list_remote_signals(arg2);
+    } else {
+        infrared_cli_brute_force_signals(cli, arg1, arg2);
+    }
+
+    furi_string_free(arg1);
+    furi_string_free(arg2);
+}
+
+static void infrared_cli_start_ir(Cli* cli, FuriString* args, void* context) {
+    UNUSED(context);
+    if(furi_hal_infrared_is_busy()) {
+        printf("INFRARED is busy. Exiting.");
+        return;
+    }
+
+    FuriString* command;
+    command = furi_string_alloc();
+    args_read_string_and_trim(args, command);
+
+    size_t i = 0;
+    for(; i < COUNT_OF(infrared_cli_commands); ++i) {
+        size_t cmd_len = strlen(infrared_cli_commands[i].cmd);
+        if(!strncmp(furi_string_get_cstr(command), infrared_cli_commands[i].cmd, cmd_len)) {
+            break;
+        }
+    }
+
+    if(i < COUNT_OF(infrared_cli_commands)) {
+        infrared_cli_commands[i].process_function(cli, args);
+    } else {
+        infrared_cli_print_usage();
+    }
+
+    furi_string_free(command);
+}
+void infrared_on_system_start() {
+#ifdef SRV_CLI
+    Cli* cli = (Cli*)furi_record_open(RECORD_CLI);
+    cli_add_command(cli, "ir", CliCommandFlagDefault, infrared_cli_start_ir, NULL);
+    furi_record_close(RECORD_CLI);
+#else
+    UNUSED(infrared_cli_start_ir);
+#endif
+}

applications/services/lfrfidsrv/application.fam

@@ -0,0 +1,7 @@
+App(
+    appid="lfrfidsrv",
+    apptype=FlipperAppType.STARTUP,
+    entry_point="lfrfid_on_system_start",
+    requires=["lfrfid"],
+    order=50,
+)

applications/services/lfrfidsrv/lfrfid_cli.c

@@ -0,0 +1,577 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <stdarg.h>
+#include <cli/cli.h>
+#include <lib/toolbox/args.h>
+#include <lib/lfrfid/lfrfid_worker.h>
+#include <storage/storage.h>
+#include <toolbox/stream/file_stream.h>
+
+#include <toolbox/varint.h>
+
+#include <toolbox/protocols/protocol_dict.h>
+#include <lfrfid/protocols/lfrfid_protocols.h>
+#include <lfrfid/lfrfid_raw_file.h>
+#include <toolbox/pulse_protocols/pulse_glue.h>
+
+static void lfrfid_cli(Cli* cli, FuriString* args, void* context);
+
+// app cli function
+void lfrfid_on_system_start() {
+    Cli* cli = furi_record_open(RECORD_CLI);
+    cli_add_command(cli, "rfid", CliCommandFlagDefault, lfrfid_cli, NULL);
+    furi_record_close(RECORD_CLI);
+}
+
+static void lfrfid_cli_print_usage() {
+    printf("Usage:\r\n");
+    printf("rfid read <optional: normal | indala>\r\n");
+    printf("rfid <write | emulate> <key_type> <key_data>\r\n");
+    printf("rfid raw_read <ask | psk> <filename>\r\n");
+    printf("rfid raw_emulate <filename>\r\n");
+    printf("rfid raw_analyze <filename>\r\n");
+};
+
+typedef struct {
+    ProtocolId protocol;
+    FuriEventFlag* event;
+} LFRFIDCliReadContext;
+
+static void lfrfid_cli_read_callback(LFRFIDWorkerReadResult result, ProtocolId proto, void* ctx) {
+    furi_assert(ctx);
+    LFRFIDCliReadContext* context = ctx;
+    if(result == LFRFIDWorkerReadDone) {
+        context->protocol = proto;
+        FURI_SW_MEMBARRIER();
+    }
+    furi_event_flag_set(context->event, 1 << result);
+}
+
+static void lfrfid_cli_read(Cli* cli, FuriString* args) {
+    FuriString* type_string;
+    type_string = furi_string_alloc();
+    LFRFIDWorkerReadType type = LFRFIDWorkerReadTypeAuto;
+
+    if(args_read_string_and_trim(args, type_string)) {
+        if(furi_string_cmp_str(type_string, "normal") == 0 ||
+           furi_string_cmp_str(type_string, "ask") == 0) {
+            // ask
+            type = LFRFIDWorkerReadTypeASKOnly;
+        } else if(
+            furi_string_cmp_str(type_string, "indala") == 0 ||
+            furi_string_cmp_str(type_string, "psk") == 0) {
+            // psk
+            type = LFRFIDWorkerReadTypePSKOnly;
+        } else {
+            lfrfid_cli_print_usage();
+            furi_string_free(type_string);
+            return;
+        }
+    }
+    furi_string_free(type_string);
+
+    ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+    LFRFIDWorker* worker = lfrfid_worker_alloc(dict);
+    LFRFIDCliReadContext context;
+    context.protocol = PROTOCOL_NO;
+    context.event = furi_event_flag_alloc();
+
+    lfrfid_worker_start_thread(worker);
+
+    printf("Reading RFID...\r\nPress Ctrl+C to abort\r\n");
+
+    const uint32_t available_flags = (1 << LFRFIDWorkerReadDone);
+
+    lfrfid_worker_read_start(worker, type, lfrfid_cli_read_callback, &context);
+
+    while(true) {
+        uint32_t flags =
+            furi_event_flag_wait(context.event, available_flags, FuriFlagWaitAny, 100);
+
+        if(flags != FuriFlagErrorTimeout) {
+            if(FURI_BIT(flags, LFRFIDWorkerReadDone)) {
+                break;
+            }
+        }
+
+        if(cli_cmd_interrupt_received(cli)) break;
+    }
+
+    lfrfid_worker_stop(worker);
+    lfrfid_worker_stop_thread(worker);
+    lfrfid_worker_free(worker);
+
+    if(context.protocol != PROTOCOL_NO) {
+        printf("%s ", protocol_dict_get_name(dict, context.protocol));
+
+        size_t size = protocol_dict_get_data_size(dict, context.protocol);
+        uint8_t* data = malloc(size);
+        protocol_dict_get_data(dict, context.protocol, data, size);
+        for(size_t i = 0; i < size; i++) {
+            printf("%02X", data[i]);
+        }
+        printf("\r\n");
+        free(data);
+
+        FuriString* info;
+        info = furi_string_alloc();
+        protocol_dict_render_data(dict, info, context.protocol);
+        if(!furi_string_empty(info)) {
+            printf("%s\r\n", furi_string_get_cstr(info));
+        }
+        furi_string_free(info);
+    }
+
+    printf("Reading stopped\r\n");
+    protocol_dict_free(dict);
+
+    furi_event_flag_free(context.event);
+}
+
+static bool lfrfid_cli_parse_args(FuriString* args, ProtocolDict* dict, ProtocolId* protocol) {
+    bool result = false;
+    FuriString *protocol_name, *data_text;
+    protocol_name = furi_string_alloc();
+    data_text = furi_string_alloc();
+    size_t data_size = protocol_dict_get_max_data_size(dict);
+    uint8_t* data = malloc(data_size);
+
+    do {
+        // load args
+        if(!args_read_string_and_trim(args, protocol_name) ||
+           !args_read_string_and_trim(args, data_text)) {
+            lfrfid_cli_print_usage();
+            break;
+        }
+
+        // check protocol arg
+        *protocol = protocol_dict_get_protocol_by_name(dict, furi_string_get_cstr(protocol_name));
+        if(*protocol == PROTOCOL_NO) {
+            printf(
+                "Unknown protocol: %s\r\n"
+                "Available protocols:\r\n",
+                furi_string_get_cstr(protocol_name));
+
+            for(ProtocolId i = 0; i < LFRFIDProtocolMax; i++) {
+                printf(
+                    "\t%s, %d bytes long\r\n",
+                    protocol_dict_get_name(dict, i),
+                    protocol_dict_get_data_size(dict, i));
+            }
+            break;
+        }
+
+        data_size = protocol_dict_get_data_size(dict, *protocol);
+
+        // check data arg
+        if(!args_read_hex_bytes(data_text, data, data_size)) {
+            printf(
+                "%s data needs to be %d bytes long\r\n",
+                protocol_dict_get_name(dict, *protocol),
+                data_size);
+            break;
+        }
+
+        // load data to protocol
+        protocol_dict_set_data(dict, *protocol, data, data_size);
+
+        result = true;
+    } while(false);
+
+    free(data);
+    furi_string_free(protocol_name);
+    furi_string_free(data_text);
+    return result;
+}
+
+static void lfrfid_cli_write_callback(LFRFIDWorkerWriteResult result, void* ctx) {
+    furi_assert(ctx);
+    FuriEventFlag* events = ctx;
+    furi_event_flag_set(events, 1 << result);
+}
+
+static void lfrfid_cli_write(Cli* cli, FuriString* args) {
+    ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+    ProtocolId protocol;
+
+    if(!lfrfid_cli_parse_args(args, dict, &protocol)) {
+        protocol_dict_free(dict);
+        return;
+    }
+
+    LFRFIDWorker* worker = lfrfid_worker_alloc(dict);
+    FuriEventFlag* event = furi_event_flag_alloc();
+
+    lfrfid_worker_start_thread(worker);
+    lfrfid_worker_write_start(worker, protocol, lfrfid_cli_write_callback, event);
+
+    printf("Writing RFID...\r\nPress Ctrl+C to abort\r\n");
+    const uint32_t available_flags = (1 << LFRFIDWorkerWriteOK) |
+                                     (1 << LFRFIDWorkerWriteProtocolCannotBeWritten) |
+                                     (1 << LFRFIDWorkerWriteFobCannotBeWritten);
+
+    while(!cli_cmd_interrupt_received(cli)) {
+        uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
+        if(flags != FuriFlagErrorTimeout) {
+            if(FURI_BIT(flags, LFRFIDWorkerWriteOK)) {
+                printf("Written!\r\n");
+                break;
+            }
+
+            if(FURI_BIT(flags, LFRFIDWorkerWriteProtocolCannotBeWritten)) {
+                printf("This protocol cannot be written.\r\n");
+                break;
+            }
+
+            if(FURI_BIT(flags, LFRFIDWorkerWriteFobCannotBeWritten)) {
+                printf("Seems this fob cannot be written.\r\n");
+            }
+        }
+    }
+    printf("Writing stopped\r\n");
+
+    lfrfid_worker_stop(worker);
+    lfrfid_worker_stop_thread(worker);
+    lfrfid_worker_free(worker);
+    protocol_dict_free(dict);
+    furi_event_flag_free(event);
+}
+
+static void lfrfid_cli_emulate(Cli* cli, FuriString* args) {
+    ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+    ProtocolId protocol;
+
+    if(!lfrfid_cli_parse_args(args, dict, &protocol)) {
+        protocol_dict_free(dict);
+        return;
+    }
+
+    LFRFIDWorker* worker = lfrfid_worker_alloc(dict);
+
+    lfrfid_worker_start_thread(worker);
+    lfrfid_worker_emulate_start(worker, protocol);
+
+    printf("Emulating RFID...\r\nPress Ctrl+C to abort\r\n");
+    while(!cli_cmd_interrupt_received(cli)) {
+        furi_delay_ms(100);
+    }
+    printf("Emulation stopped\r\n");
+
+    lfrfid_worker_stop(worker);
+    lfrfid_worker_stop_thread(worker);
+    lfrfid_worker_free(worker);
+    protocol_dict_free(dict);
+}
+
+static void lfrfid_cli_raw_analyze(Cli* cli, FuriString* args) {
+    UNUSED(cli);
+    FuriString *filepath, *info_string;
+    filepath = furi_string_alloc();
+    info_string = furi_string_alloc();
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    LFRFIDRawFile* file = lfrfid_raw_file_alloc(storage);
+
+    do {
+        float frequency = 0;
+        float duty_cycle = 0;
+
+        if(!args_read_probably_quoted_string_and_trim(args, filepath)) {
+            lfrfid_cli_print_usage();
+            break;
+        }
+
+        if(!lfrfid_raw_file_open_read(file, furi_string_get_cstr(filepath))) {
+            printf("Failed to open file\r\n");
+            break;
+        }
+
+        if(!lfrfid_raw_file_read_header(file, &frequency, &duty_cycle)) {
+            printf("Invalid header\r\n");
+            break;
+        }
+
+        bool file_end = false;
+        uint32_t total_warns = 0;
+        uint32_t total_duration = 0;
+        uint32_t total_pulse = 0;
+        ProtocolId total_protocol = PROTOCOL_NO;
+
+        ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+        protocol_dict_decoders_start(dict);
+
+        while(!file_end) {
+            uint32_t pulse = 0;
+            uint32_t duration = 0;
+            if(lfrfid_raw_file_read_pair(file, &duration, &pulse, &file_end)) {
+                bool warn = false;
+
+                if(pulse > duration || pulse <= 0 || duration <= 0) {
+                    total_warns += 1;
+                    warn = true;
+                }
+
+                furi_string_printf(info_string, "[%ld %ld]", pulse, duration);
+                printf("%-16s", furi_string_get_cstr(info_string));
+                furi_string_printf(info_string, "[%ld %ld]", pulse, duration - pulse);
+                printf("%-16s", furi_string_get_cstr(info_string));
+
+                if(warn) {
+                    printf(" <<----");
+                }
+
+                if(total_protocol == PROTOCOL_NO) {
+                    total_protocol = protocol_dict_decoders_feed(dict, true, pulse);
+                    if(total_protocol == PROTOCOL_NO) {
+                        total_protocol =
+                            protocol_dict_decoders_feed(dict, false, duration - pulse);
+                    }
+
+                    if(total_protocol != PROTOCOL_NO) {
+                        printf(" <FOUND %s>", protocol_dict_get_name(dict, total_protocol));
+                    }
+                }
+
+                printf("\r\n");
+
+                total_pulse += pulse;
+                total_duration += duration;
+
+                if(total_protocol != PROTOCOL_NO) {
+                    break;
+                }
+            } else {
+                printf("Failed to read pair\r\n");
+                break;
+            }
+        }
+
+        printf("   Frequency: %f\r\n", (double)frequency);
+        printf("  Duty Cycle: %f\r\n", (double)duty_cycle);
+        printf("       Warns: %ld\r\n", total_warns);
+        printf("   Pulse sum: %ld\r\n", total_pulse);
+        printf("Duration sum: %ld\r\n", total_duration);
+        printf("     Average: %f\r\n", (double)((float)total_pulse / (float)total_duration));
+        printf("    Protocol: ");
+
+        if(total_protocol != PROTOCOL_NO) {
+            size_t data_size = protocol_dict_get_data_size(dict, total_protocol);
+            uint8_t* data = malloc(data_size);
+            protocol_dict_get_data(dict, total_protocol, data, data_size);
+
+            printf("%s [", protocol_dict_get_name(dict, total_protocol));
+            for(size_t i = 0; i < data_size; i++) {
+                printf("%02X", data[i]);
+                if(i < data_size - 1) {
+                    printf(" ");
+                }
+            }
+            printf("]\r\n");
+
+            protocol_dict_render_data(dict, info_string, total_protocol);
+            printf("%s\r\n", furi_string_get_cstr(info_string));
+
+            free(data);
+        } else {
+            printf("not found\r\n");
+        }
+
+        protocol_dict_free(dict);
+    } while(false);
+
+    furi_string_free(filepath);
+    furi_string_free(info_string);
+    lfrfid_raw_file_free(file);
+    furi_record_close(RECORD_STORAGE);
+}
+
+static void lfrfid_cli_raw_read_callback(LFRFIDWorkerReadRawResult result, void* context) {
+    furi_assert(context);
+    FuriEventFlag* event = context;
+    furi_event_flag_set(event, 1 << result);
+}
+
+static void lfrfid_cli_raw_read(Cli* cli, FuriString* args) {
+    UNUSED(cli);
+
+    FuriString *filepath, *type_string;
+    filepath = furi_string_alloc();
+    type_string = furi_string_alloc();
+    LFRFIDWorkerReadType type = LFRFIDWorkerReadTypeAuto;
+
+    do {
+        if(args_read_string_and_trim(args, type_string)) {
+            if(furi_string_cmp_str(type_string, "normal") == 0 ||
+               furi_string_cmp_str(type_string, "ask") == 0) {
+                // ask
+                type = LFRFIDWorkerReadTypeASKOnly;
+            } else if(
+                furi_string_cmp_str(type_string, "indala") == 0 ||
+                furi_string_cmp_str(type_string, "psk") == 0) {
+                // psk
+                type = LFRFIDWorkerReadTypePSKOnly;
+            } else {
+                lfrfid_cli_print_usage();
+                break;
+            }
+        }
+
+        if(!args_read_probably_quoted_string_and_trim(args, filepath)) {
+            lfrfid_cli_print_usage();
+            break;
+        }
+
+        ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+        LFRFIDWorker* worker = lfrfid_worker_alloc(dict);
+        FuriEventFlag* event = furi_event_flag_alloc();
+
+        lfrfid_worker_start_thread(worker);
+
+        bool overrun = false;
+
+        const uint32_t available_flags = (1 << LFRFIDWorkerReadRawFileError) |
+                                         (1 << LFRFIDWorkerReadRawOverrun);
+
+        lfrfid_worker_read_raw_start(
+            worker, furi_string_get_cstr(filepath), type, lfrfid_cli_raw_read_callback, event);
+        while(true) {
+            uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
+
+            if(flags != FuriFlagErrorTimeout) {
+                if(FURI_BIT(flags, LFRFIDWorkerReadRawFileError)) {
+                    printf("File is not RFID raw file\r\n");
+                    break;
+                }
+
+                if(FURI_BIT(flags, LFRFIDWorkerReadRawOverrun)) {
+                    if(!overrun) {
+                        printf("Overrun\r\n");
+                        overrun = true;
+                    }
+                }
+            }
+
+            if(cli_cmd_interrupt_received(cli)) break;
+        }
+
+        if(overrun) {
+            printf("An overrun occurred during read\r\n");
+        }
+
+        lfrfid_worker_stop(worker);
+
+        lfrfid_worker_stop_thread(worker);
+        lfrfid_worker_free(worker);
+        protocol_dict_free(dict);
+
+        furi_event_flag_free(event);
+
+    } while(false);
+
+    furi_string_free(filepath);
+    furi_string_free(type_string);
+}
+
+static void lfrfid_cli_raw_emulate_callback(LFRFIDWorkerEmulateRawResult result, void* context) {
+    furi_assert(context);
+    FuriEventFlag* event = context;
+    furi_event_flag_set(event, 1 << result);
+}
+
+static void lfrfid_cli_raw_emulate(Cli* cli, FuriString* args) {
+    UNUSED(cli);
+
+    FuriString* filepath;
+    filepath = furi_string_alloc();
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    do {
+        if(!args_read_probably_quoted_string_and_trim(args, filepath)) {
+            lfrfid_cli_print_usage();
+            break;
+        }
+
+        if(!storage_file_exists(storage, furi_string_get_cstr(filepath))) {
+            printf("File not found: \"%s\"\r\n", furi_string_get_cstr(filepath));
+            break;
+        }
+
+        ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+        LFRFIDWorker* worker = lfrfid_worker_alloc(dict);
+        FuriEventFlag* event = furi_event_flag_alloc();
+
+        lfrfid_worker_start_thread(worker);
+
+        bool overrun = false;
+
+        const uint32_t available_flags = (1 << LFRFIDWorkerEmulateRawFileError) |
+                                         (1 << LFRFIDWorkerEmulateRawOverrun);
+
+        lfrfid_worker_emulate_raw_start(
+            worker, furi_string_get_cstr(filepath), lfrfid_cli_raw_emulate_callback, event);
+        while(true) {
+            uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
+
+            if(flags != FuriFlagErrorTimeout) {
+                if(FURI_BIT(flags, LFRFIDWorkerEmulateRawFileError)) {
+                    printf("File is not RFID raw file\r\n");
+                    break;
+                }
+
+                if(FURI_BIT(flags, LFRFIDWorkerEmulateRawOverrun)) {
+                    if(!overrun) {
+                        printf("Overrun\r\n");
+                        overrun = true;
+                    }
+                }
+            }
+
+            if(cli_cmd_interrupt_received(cli)) break;
+        }
+
+        if(overrun) {
+            printf("An overrun occurred during emulation\r\n");
+        }
+
+        lfrfid_worker_stop(worker);
+
+        lfrfid_worker_stop_thread(worker);
+        lfrfid_worker_free(worker);
+        protocol_dict_free(dict);
+
+        furi_event_flag_free(event);
+
+    } while(false);
+
+    furi_record_close(RECORD_STORAGE);
+    furi_string_free(filepath);
+}
+
+static void lfrfid_cli(Cli* cli, FuriString* args, void* context) {
+    UNUSED(context);
+    FuriString* cmd;
+    cmd = furi_string_alloc();
+
+    if(!args_read_string_and_trim(args, cmd)) {
+        furi_string_free(cmd);
+        lfrfid_cli_print_usage();
+        return;
+    }
+
+    if(furi_string_cmp_str(cmd, "read") == 0) {
+        lfrfid_cli_read(cli, args);
+    } else if(furi_string_cmp_str(cmd, "write") == 0) {
+        lfrfid_cli_write(cli, args);
+    } else if(furi_string_cmp_str(cmd, "emulate") == 0) {
+        lfrfid_cli_emulate(cli, args);
+    } else if(furi_string_cmp_str(cmd, "raw_read") == 0) {
+        lfrfid_cli_raw_read(cli, args);
+    } else if(furi_string_cmp_str(cmd, "raw_emulate") == 0) {
+        lfrfid_cli_raw_emulate(cli, args);
+    } else if(furi_string_cmp_str(cmd, "raw_analyze") == 0) {
+        lfrfid_cli_raw_analyze(cli, args);
+    } else {
+        lfrfid_cli_print_usage();
+    }
+
+    furi_string_free(cmd);
+}