mirrors/flipperzero-firmware
1
Fork 0
mirror of https://github.com/flipperdevices/flipperzero-firmware.git synced 2025-12-12 12:51:22 +04:00
Code Issues Activity

Added protocol for Dickert MAHS garage door remote control (#3826)

Browse Source 
* Added Dickert MAHS protocol
* Update protocol_items.c
* Added Dickert MAHS protocol reference
* Update protocol_items.h
* Removed logging and some defines
* Reworked the send code to properly adhere to Dickert timings
* Added subghz unit test for Dickert MAHS
* Minor fix in encoding length
* Added Dickert Decoder Test to subghz unit tests and set repeat=10
* SubGhz: cleanup dickert mahs code and documentation
* SubGhz: correct type in for statement in dickert mahs

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
daubsi
2024-08-09 10:24:57 +02:00
committed by GitHub
parent d2ff2825ca
commit 4f75d92747
7 changed files with 536 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
applications/debug/unit_tests/resources/unit_tests/subghz/dickert_mahs.sub Normal file
View File

@@ -0,0 +1,7 @@
Filetype: Flipper SubGhz Key File
Version: 1
Frequency: 433920000
Preset: FuriHalSubGhzPresetOok650Async
Protocol: Dickert_MAHS
Bit: 36
Key: 00 00 00 01 55 57 55 15

7
applications/debug/unit_tests/resources/unit_tests/subghz/dickert_raw.sub Normal file
View File

@@ -0,0 +1,7 @@
Filetype: Flipper SubGhz RAW File
Version: 1
Frequency: 433920000
Preset: FuriHalSubGhzPresetOok650Async
Protocol: RAW
RAW_Data: 112254 -62882 64 -8912 798 -844 416 -418 806 -850 396 -45206 440 -428 794 -442 804 -422 822 -810 414 -414 824 -832 412 -416 808 -848 376 -446 792 -846 382 -448 816 -828 410 -416 810 -844 382 -416 834 -818 410 -414 810 -856 408 -810 412 -836 384 -442 808 -814 402 -844 414 -834 378 -436 808 -844 396 -422 798 -844 416 -416 814 -404 812 -440 810 -842 396 -422 798 -840 414 -414 806 -850 398 -45210 450 -420 796 -436 780 -446 802 -848 380 -434 806 -846 400 -422 800 -840 410 -408 836 -812 414 -410 826 -840 378 -440 804 -848 396 -426 812 -810 426 -394 826 -844 414 -810 420 -834 378 -442 808 -832 412 -812 416 -830 410 -406 810 -844 400 -420 832 -810 414 -416 800 -446 798 -440 812 -808 426 -410 800 -836 412 -414 806 -836 412 -45216 450 -420 798 -434 806 -414 802 -846 382 -438 814 -832 410 -410 838 -834 396 -430 810 -842 394 -392 826 -840 414 -414 802 -850 396 -428 812 -842 394 -394 828 -842 414 -810 424 -812 392 -434 812 -844 398 -848 380 -844 408 -416 820 -810 414 -406 816 -836 412 -416 836 -414 816 -398 816 -840 420 -410 802 -844 416 -416 804 -824 410 -45232 446 -400 802 -442 810 -432 804 -842 396 -392 826 -842 410 -410 834 -818 378 -442 804 -854 406 -408 806 -838 408 -428 804 -844 396 -392 826 -840 410 -410 834 -810 414 -832 408 -834 380 -440 802 -826 410 -836 412 -838 396 -424 796 -842 414 -414 804 -848 396 -426 812 -412 814 -414 824 -832 410 -416 806 -848 382 -420 834 -814 422 -45228 416 -422 802 -446 810 -420 790 -846 382 -448 818 -828 408 -416 808 -848 382 -418 830 -816 410 -412 812 -856 410 -382 834 -846 382 -418 832 -818 408 -412 812 -856 408 -814 414 -838 396 -428 810 -808 424 -836 380 -844 404 -416 802 -840 424 -394 826 -840 414 -382 836 -412 822 -436 812 -806 424 -394 826 -844 416 -382 838 -816 402 -45228 438 -430 796 -444 806 -424 822 -810 412 -416 822 -832 412 -416 804 -844 408 -414 824 -812 412 -408 812 -834 410 -414 804 -848 408 -412 802 -840 424 -412 802 -834 412 -842 384 -848 396 -426 814 -808 424 -816 392 -866 382 -414 838 -816 414 -428 792 -846 380 -440 810 -438 812 -412 802 -846 380 -438 826 -840 380 -416 838 -814 404 -45226 450 -404 820 -408 806 -452 792 -848 382 -440 814 -832 410 -416 810 -846 378 -450 792 -846 380 -446 816 -830 410 -386 836 -846 376 -410 828 -846 380 -446 814 -828 410 -814 414 -836 396 -428 810 -842 394 -816 410 -836 406 -430 812 -810 426 -394 826 -838
RAW_Data: 414 -414 808 -416 826 -438 814 -816 420 -414 834 -814 418 -418 808 -848 398 -45218 412 -438 824 -412 812 -418 832 -852 378 -446 782 -862 410 -386 838 -848 384 -420 836 -820 418 -414 814 -854 408 -388 838 -814 418 -422 836 -816 394 -434 812 -846 398 -850 380 -848 410 -418 822 -812 416 -850 368 -854 412 -418 810 -850 384 -422 834 -820 416 -414 812 -428 836 -412 804 -848 382 -450 818 -828 412 -418 808 -850 380 -45228 452 -420 798 -434 806 -416 834 -818 384 -440 810 -820 404 -420 834 -814 416 -418 834 -824 386 -442 810 -818 404 -420 834 -814 416 -418 834 -820 410 -414 810 -850 406 -812 414 -816 404 -420 818 -838 386 -848 394 -828 414 -414 838 -814 406 -420 820 -842 384 -446 794 -438 810 -412 802 -848 394 -432 812 -842 394 -392 830 -842 414 -105578 64 -1760 130 -196 130 -832 160 -128 62 -1278 194 -1316 230 -96 362 -64 64 -398

15
applications/debug/unit_tests/tests/subghz/subghz_test.c
View File

@@ -665,6 +665,13 @@ MU_TEST(subghz_decoder_mastercode_test) {
"Test decoder " SUBGHZ_PROTOCOL_MASTERCODE_NAME " error\r\n"); "Test decoder " SUBGHZ_PROTOCOL_MASTERCODE_NAME " error\r\n");
} }
MU_TEST(subghz_decoder_dickert_test) {
mu_assert(
subghz_decoder_test(
EXT_PATH("unit_tests/subghz/dickert_raw.sub"), SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME),
"Test decoder " SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME " error\r\n");
}
//test encoders //test encoders
MU_TEST(subghz_encoder_princeton_test) { MU_TEST(subghz_encoder_princeton_test) {
mu_assert( mu_assert(
@@ -822,6 +829,12 @@ MU_TEST(subghz_encoder_mastercode_test) {
"Test encoder " SUBGHZ_PROTOCOL_MASTERCODE_NAME " error\r\n"); "Test encoder " SUBGHZ_PROTOCOL_MASTERCODE_NAME " error\r\n");
} }
MU_TEST(subghz_encoder_dickert_test) {
mu_assert(
subghz_encoder_test(EXT_PATH("unit_tests/subghz/dickert_mahs.sub")),
"Test encoder " SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME " error\r\n");
}
MU_TEST(subghz_random_test) { MU_TEST(subghz_random_test) {
mu_assert(subghz_decode_random_test(TEST_RANDOM_DIR_NAME), "Random test error\r\n"); mu_assert(subghz_decode_random_test(TEST_RANDOM_DIR_NAME), "Random test error\r\n");
} }
@@ -873,6 +886,7 @@ MU_TEST_SUITE(subghz) {
MU_RUN_TEST(subghz_decoder_nice_one_test); MU_RUN_TEST(subghz_decoder_nice_one_test);
MU_RUN_TEST(subghz_decoder_kinggates_stylo4k_test); MU_RUN_TEST(subghz_decoder_kinggates_stylo4k_test);
MU_RUN_TEST(subghz_decoder_mastercode_test); MU_RUN_TEST(subghz_decoder_mastercode_test);
MU_RUN_TEST(subghz_decoder_dickert_test);
MU_RUN_TEST(subghz_encoder_princeton_test); MU_RUN_TEST(subghz_encoder_princeton_test);
MU_RUN_TEST(subghz_encoder_came_test); MU_RUN_TEST(subghz_encoder_came_test);
@@ -900,6 +914,7 @@ MU_TEST_SUITE(subghz) {
MU_RUN_TEST(subghz_encoder_holtek_ht12x_test); MU_RUN_TEST(subghz_encoder_holtek_ht12x_test);
MU_RUN_TEST(subghz_encoder_dooya_test); MU_RUN_TEST(subghz_encoder_dooya_test);
MU_RUN_TEST(subghz_encoder_mastercode_test); MU_RUN_TEST(subghz_encoder_mastercode_test);
MU_RUN_TEST(subghz_encoder_dickert_test);
MU_RUN_TEST(subghz_random_test); MU_RUN_TEST(subghz_random_test);
subghz_test_deinit(); subghz_test_deinit();

385
lib/subghz/protocols/dickert_mahs.c Normal file
View File

@@ -0,0 +1,385 @@
#include "dickert_mahs.h"
#include "../blocks/const.h"
#include "../blocks/decoder.h"
#include "../blocks/encoder.h"
#include "../blocks/generic.h"
#include "../blocks/math.h"
#include <furi.h>
#include <furi_hal.h>
#include <furi_hal_rtc.h>
#define TAG "SubGhzProtocolDicketMAHS"
static const SubGhzBlockConst subghz_protocol_dickert_mahs_const = {
.te_short = 400,
.te_long = 800,
.te_delta = 100,
.min_count_bit_for_found = 36,
};
struct SubGhzProtocolDecoderDickertMAHS {
SubGhzProtocolDecoderBase base;
SubGhzBlockDecoder decoder;
SubGhzBlockGeneric generic;
uint32_t tmp[2];
uint8_t tmp_cnt;
};
struct SubGhzProtocolEncoderDickertMAHS {
SubGhzProtocolEncoderBase base;
SubGhzProtocolBlockEncoder encoder;
SubGhzBlockGeneric generic;
};
typedef enum {
DickertMAHSDecoderStepReset = 0,
DickertMAHSDecoderStepInitial,
DickertMAHSDecoderStepRecording,
} DickertMAHSDecoderStep;
const SubGhzProtocolDecoder subghz_protocol_dickert_mahs_decoder = {
.alloc = subghz_protocol_decoder_dickert_mahs_alloc,
.free = subghz_protocol_decoder_dickert_mahs_free,
.feed = subghz_protocol_decoder_dickert_mahs_feed,
.reset = subghz_protocol_decoder_dickert_mahs_reset,
.get_hash_data = subghz_protocol_decoder_dickert_mahs_get_hash_data,
.serialize = subghz_protocol_decoder_dickert_mahs_serialize,
.deserialize = subghz_protocol_decoder_dickert_mahs_deserialize,
.get_string = subghz_protocol_decoder_dickert_mahs_get_string,
};
const SubGhzProtocolEncoder subghz_protocol_dickert_mahs_encoder = {
.alloc = subghz_protocol_encoder_dickert_mahs_alloc,
.free = subghz_protocol_encoder_dickert_mahs_free,
.deserialize = subghz_protocol_encoder_dickert_mahs_deserialize,
.stop = subghz_protocol_encoder_dickert_mahs_stop,
.yield = subghz_protocol_encoder_dickert_mahs_yield,
};
const SubGhzProtocol subghz_protocol_dickert_mahs = {
.name = SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME,
.type = SubGhzProtocolTypeStatic,
.flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
.decoder = &subghz_protocol_dickert_mahs_decoder,
.encoder = &subghz_protocol_dickert_mahs_encoder,
};
static void subghz_protocol_encoder_dickert_mahs_parse_buffer(
SubGhzProtocolDecoderDickertMAHS* instance,
FuriString* output) {
// We assume we have only decodes < 64 bit!
uint64_t data = instance->generic.data;
uint8_t bits[36] = {};
// Convert uint64_t into bit array
for(int i = 35; i >= 0; i--) {
if(data & 1) {
bits[i] = 1;
}
data >>= 1;
}
// Decode symbols
FuriString* code = furi_string_alloc();
for(size_t i = 0; i < 35; i += 2) {
uint8_t dip = (bits[i] << 1) + bits[i + 1];
// PLUS = 3, // 0b11
// ZERO = 1, // 0b01
// MINUS = 0, // 0x00
if(dip == 0x01) {
furi_string_cat(code, "0");
} else if(dip == 0x00) {
furi_string_cat(code, "-");
} else if(dip == 0x03) {
furi_string_cat(code, "+");
} else {
furi_string_cat(code, "?");
}
}
FuriString* user_dips = furi_string_alloc();
FuriString* fact_dips = furi_string_alloc();
furi_string_set_n(user_dips, code, 0, 10);
furi_string_set_n(fact_dips, code, 10, 8);
furi_string_cat_printf(
output,
"%s\r\n"
"User-Dips:\t%s\r\n"
"Fac-Code:\t%s\r\n",
instance->generic.protocol_name,
furi_string_get_cstr(user_dips),
furi_string_get_cstr(fact_dips));
furi_string_free(user_dips);
furi_string_free(fact_dips);
furi_string_free(code);
}
void* subghz_protocol_encoder_dickert_mahs_alloc(SubGhzEnvironment* environment) {
UNUSED(environment);
SubGhzProtocolEncoderDickertMAHS* instance = malloc(sizeof(SubGhzProtocolEncoderDickertMAHS));
instance->base.protocol = &subghz_protocol_dickert_mahs;
instance->generic.protocol_name = instance->base.protocol->name;
instance->encoder.repeat = 10;
instance->encoder.size_upload = 128;
instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
instance->encoder.is_running = false;
return instance;
}
void subghz_protocol_encoder_dickert_mahs_free(void* context) {
furi_assert(context);
SubGhzProtocolEncoderDickertMAHS* instance = context;
free(instance->encoder.upload);
free(instance);
}
/**
* Generating an upload from data.
* @param instance Pointer to a SubGhzProtocolEncoderDickertMAHS instance
* @return true On success
*/
static bool
subghz_protocol_encoder_dickert_mahs_get_upload(SubGhzProtocolEncoderDickertMAHS* instance) {
furi_assert(instance);
size_t index = 0;
size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
if(size_upload > instance->encoder.size_upload) {
FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
return false;
} else {
instance->encoder.size_upload = size_upload;
}
instance->encoder.upload[index++] =
level_duration_make(false, (uint32_t)subghz_protocol_dickert_mahs_const.te_short * 112);
// Send start bit
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_dickert_mahs_const.te_short);
//Send key data
for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
if(bit_read(instance->generic.data, i - 1)) {
//send bit 1
instance->encoder.upload[index++] =
level_duration_make(false, (uint32_t)subghz_protocol_dickert_mahs_const.te_long);
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_dickert_mahs_const.te_short);
} else {
//send bit 0
instance->encoder.upload[index++] =
level_duration_make(false, (uint32_t)subghz_protocol_dickert_mahs_const.te_short);
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_dickert_mahs_const.te_long);
}
}
return true;
}
SubGhzProtocolStatus
subghz_protocol_encoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format) {
furi_assert(context);
SubGhzProtocolEncoderDickertMAHS* instance = context;
SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
do {
ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
if(ret != SubGhzProtocolStatusOk) {
break;
}
// Allow for longer keys (<) instead of !=
if((instance->generic.data_count_bit <
subghz_protocol_dickert_mahs_const.min_count_bit_for_found)) {
FURI_LOG_E(TAG, "Wrong number of bits in key");
ret = SubGhzProtocolStatusErrorValueBitCount;
break;
}
//optional parameter parameter
flipper_format_read_uint32(
flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
if(!subghz_protocol_encoder_dickert_mahs_get_upload(instance)) {
ret = SubGhzProtocolStatusErrorEncoderGetUpload;
break;
}
instance->encoder.is_running = true;
} while(false);
return ret;
}
void subghz_protocol_encoder_dickert_mahs_stop(void* context) {
SubGhzProtocolEncoderDickertMAHS* instance = context;
instance->encoder.is_running = false;
}
LevelDuration subghz_protocol_encoder_dickert_mahs_yield(void* context) {
SubGhzProtocolEncoderDickertMAHS* instance = context;
if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
instance->encoder.is_running = false;
return level_duration_reset();
}
LevelDuration ret = instance->encoder.upload[instance->encoder.front];
if(++instance->encoder.front == instance->encoder.size_upload) {
instance->encoder.repeat--;
instance->encoder.front = 0;
}
return ret;
}
void* subghz_protocol_decoder_dickert_mahs_alloc(SubGhzEnvironment* environment) {
UNUSED(environment);
SubGhzProtocolDecoderDickertMAHS* instance = malloc(sizeof(SubGhzProtocolDecoderDickertMAHS));
instance->base.protocol = &subghz_protocol_dickert_mahs;
instance->generic.protocol_name = instance->base.protocol->name;
instance->tmp_cnt = 0;
return instance;
}
void subghz_protocol_decoder_dickert_mahs_free(void* context) {
furi_assert(context);
SubGhzProtocolDecoderDickertMAHS* instance = context;
free(instance);
}
void subghz_protocol_decoder_dickert_mahs_reset(void* context) {
furi_assert(context);
SubGhzProtocolDecoderDickertMAHS* instance = context;
instance->decoder.parser_step = DickertMAHSDecoderStepReset;
}
void subghz_protocol_decoder_dickert_mahs_feed(void* context, bool level, uint32_t duration) {
furi_assert(context);
SubGhzProtocolDecoderDickertMAHS* instance = context;
switch(instance->decoder.parser_step) {
case DickertMAHSDecoderStepReset:
// Check if done
if(instance->decoder.decode_count_bit >=
subghz_protocol_dickert_mahs_const.min_count_bit_for_found) {
instance->generic.serial = 0x0;
instance->generic.btn = 0x0;
instance->generic.data = instance->decoder.decode_data;
instance->generic.data_count_bit = instance->decoder.decode_count_bit;
if(instance->base.callback)
instance->base.callback(&instance->base, instance->base.context);
instance->decoder.decode_data = 0;
instance->decoder.decode_count_bit = 0;
}
if((!level) && (duration > 10 * subghz_protocol_dickert_mahs_const.te_short)) {
//Found header DICKERT_MAHS
instance->decoder.parser_step = DickertMAHSDecoderStepInitial;
}
break;
case DickertMAHSDecoderStepInitial:
if(!level) {
break;
} else if(
DURATION_DIFF(duration, subghz_protocol_dickert_mahs_const.te_short) <
subghz_protocol_dickert_mahs_const.te_delta) {
//Found start bit DICKERT_MAHS
instance->decoder.parser_step = DickertMAHSDecoderStepRecording;
instance->decoder.decode_data = 0;
instance->decoder.decode_count_bit = 0;
} else {
instance->decoder.parser_step = DickertMAHSDecoderStepReset;
}
break;
case DickertMAHSDecoderStepRecording:
if((!level && instance->tmp_cnt == 0) || (level && instance->tmp_cnt == 1)) {
instance->tmp[instance->tmp_cnt] = duration;
instance->tmp_cnt++;
if(instance->tmp_cnt == 2) {
if(DURATION_DIFF(instance->tmp[0] + instance->tmp[1], 1200) <
subghz_protocol_dickert_mahs_const.te_delta) {
if(DURATION_DIFF(instance->tmp[0], subghz_protocol_dickert_mahs_const.te_long) <
subghz_protocol_dickert_mahs_const.te_delta) {
subghz_protocol_blocks_add_bit(&instance->decoder, 1);
} else if(
DURATION_DIFF(
instance->tmp[0], subghz_protocol_dickert_mahs_const.te_short) <
subghz_protocol_dickert_mahs_const.te_delta) {
subghz_protocol_blocks_add_bit(&instance->decoder, 0);
}
instance->tmp_cnt = 0;
} else {
instance->tmp_cnt = 0;
instance->decoder.parser_step = DickertMAHSDecoderStepReset;
}
}
} else {
instance->tmp_cnt = 0;
instance->decoder.parser_step = DickertMAHSDecoderStepReset;
}
break;
}
}
uint8_t subghz_protocol_decoder_dickert_mahs_get_hash_data(void* context) {
furi_assert(context);
SubGhzProtocolDecoderDickertMAHS* instance = context;
return subghz_protocol_blocks_get_hash_data(
&instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
}
SubGhzProtocolStatus subghz_protocol_decoder_dickert_mahs_serialize(
void* context,
FlipperFormat* flipper_format,
SubGhzRadioPreset* preset) {
furi_assert(context);
SubGhzProtocolDecoderDickertMAHS* instance = context;
return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
}
SubGhzProtocolStatus
subghz_protocol_decoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format) {
furi_assert(context);
SubGhzProtocolDecoderDickertMAHS* instance = context;
SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
do {
ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
if(ret != SubGhzProtocolStatusOk) {
break;
}
// Allow for longer keys (<) instead of !=
if((instance->generic.data_count_bit <
subghz_protocol_dickert_mahs_const.min_count_bit_for_found)) {
FURI_LOG_E(TAG, "Wrong number of bits in key");
ret = SubGhzProtocolStatusErrorValueBitCount;
break;
}
} while(false);
return ret;
}
void subghz_protocol_decoder_dickert_mahs_get_string(void* context, FuriString* output) {
furi_assert(context);
subghz_protocol_encoder_dickert_mahs_parse_buffer(context, output);
}

120
lib/subghz/protocols/dickert_mahs.h Normal file
View File

@@ -0,0 +1,120 @@
#pragma once
#include "base.h"
#define SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME "Dickert_MAHS"
typedef struct SubGhzProtocolDecoderDickertMAHS SubGhzProtocolDecoderDickertMAHS;
typedef struct SubGhzProtocolEncoderDickertMAHS SubGhzProtocolEncoderDickertMAHS;
extern const SubGhzProtocolDecoder subghz_protocol_dickert_mahs_decoder;
extern const SubGhzProtocolEncoder subghz_protocol_dickert_mahs_encoder;
extern const SubGhzProtocol subghz_protocol_dickert_mahs;
/** Allocate SubGhzProtocolEncoderDickertMAHS.
*
* @param environment Pointer to a SubGhzEnvironment instance
*
* @return pointer to a SubGhzProtocolEncoderDickertMAHS instance
*/
void* subghz_protocol_encoder_dickert_mahs_alloc(SubGhzEnvironment* environment);
/** Free SubGhzProtocolEncoderDickertMAHS.
*
* @param context Pointer to a SubGhzProtocolEncoderDickertMAHS instance
*/
void subghz_protocol_encoder_dickert_mahs_free(void* context);
/** Deserialize and generating an upload to send.
*
* @param context Pointer to a SubGhzProtocolEncoderDickertMAHS
* instance
* @param flipper_format Pointer to a FlipperFormat instance
*
* @return status
*/
SubGhzProtocolStatus
subghz_protocol_encoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format);
/** Forced transmission stop.
*
* @param context Pointer to a SubGhzProtocolEncoderDickertMAHS instance
*/
void subghz_protocol_encoder_dickert_mahs_stop(void* context);
/** Getting the level and duration of the upload to be loaded into DMA.
*
* @param context Pointer to a SubGhzProtocolEncoderDickertMAHS instance
*
* @return LevelDuration
*/
LevelDuration subghz_protocol_encoder_dickert_mahs_yield(void* context);
/** Allocate SubGhzProtocolDecoderDickertMAHS.
*
* @param environment Pointer to a SubGhzEnvironment instance
*
* @return pointer to a SubGhzProtocolDecoderDickertMAHS instance
*/
void* subghz_protocol_decoder_dickert_mahs_alloc(SubGhzEnvironment* environment);
/** Free SubGhzProtocolDecoderDickertMAHS.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS instance
*/
void subghz_protocol_decoder_dickert_mahs_free(void* context);
/** Reset decoder SubGhzProtocolDecoderDickertMAHS.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS instance
*/
void subghz_protocol_decoder_dickert_mahs_reset(void* context);
/** Parse a raw sequence of levels and durations received from the air.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS instance
* @param level Signal level true-high false-low
* @param duration Duration of this level in, us
*/
void subghz_protocol_decoder_dickert_mahs_feed(void* context, bool level, uint32_t duration);
/** Getting the hash sum of the last randomly received parcel.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS instance
*
* @return hash Hash sum
*/
uint8_t subghz_protocol_decoder_dickert_mahs_get_hash_data(void* context);
/** Serialize data SubGhzProtocolDecoderDickertMAHS.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS
* instance
* @param flipper_format Pointer to a FlipperFormat instance
* @param preset The modulation on which the signal was received,
* SubGhzRadioPreset
*
* @return status
*/
SubGhzProtocolStatus subghz_protocol_decoder_dickert_mahs_serialize(
void* context,
FlipperFormat* flipper_format,
SubGhzRadioPreset* preset);
/** Deserialize data SubGhzProtocolDecoderDickertMAHS.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS
* instance
* @param flipper_format Pointer to a FlipperFormat instance
*
* @return status
*/
SubGhzProtocolStatus
subghz_protocol_decoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format);
/** Getting a textual representation of the received data.
*
* @param context Pointer to a SubGhzProtocolDecoderDickertMAHS instance
* @param output Resulting text
*/
void subghz_protocol_decoder_dickert_mahs_get_string(void* context, FuriString* output);

1
lib/subghz/protocols/protocol_items.c
View File

@@ -44,6 +44,7 @@ const SubGhzProtocol* subghz_protocol_registry_items[] = {
&subghz_protocol_kinggates_stylo_4k, &subghz_protocol_kinggates_stylo_4k,
&subghz_protocol_bin_raw, &subghz_protocol_bin_raw,
&subghz_protocol_mastercode, &subghz_protocol_mastercode,
&subghz_protocol_dickert_mahs,
}; };
const SubGhzProtocolRegistry subghz_protocol_registry = { const SubGhzProtocolRegistry subghz_protocol_registry = {

1
lib/subghz/protocols/protocol_items.h
View File

@@ -45,3 +45,4 @@
#include "kinggates_stylo_4k.h" #include "kinggates_stylo_4k.h"
#include "bin_raw.h" #include "bin_raw.h"
#include "mastercode.h" #include "mastercode.h"
#include "dickert_mahs.h"