liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-3070] iButton system and app refactoring (#2388)

Browse Source 
* Add 1-wire thermometer example app stub
* Working 1-wire thermometer app
* Refactor app to use threads
* Clean up code, add comments
* Add CRC checking
* Increase update period
* Fix error in fbt
* Revert the old update period
* Use settable pin in onewire_host
* Use settable pin for onewire_slave
* Clear EXTI flag after callback, make private methods static in onewire_slave
* Do not hardcode GPIO pin number
* Remove iButton hal from furi_hal_rfid
* Remove most of furi_hal_ibutton
* Add some of furi_hal_ibutton back
* Slightly neater code
* Update CODEOWNERS
* Add furi_hal_gpio_get_ext_pin_number
* Create README.md
* Temporary get Metakom and Cyfral keys out of the way
* Better enum name
* Syncing work, does not compile
* Syncing work, now compiles
* Working read impl for DS1990 and DS1992
* Add the ability to display extended key data
* Get rid of DialogEx
* Add save and load API
* Better iButtonKey encapsulation
* Fix crash
* Load key code boilerplate
* More load key code boilerplate
* Minor code cleanup
* Implement loading and saving DS1990 keys
* Implement the Info scene
* Implement loading & saving for DS1992
* Implement read error scene stub
* Implement delete confirmation screen
* Better error messages (protocol-dependent)
* Minor old code cleanup
* Remove iButtonDevice, add command callback to iButtonSlave
* Implement draft emulation for DS1990
* Better emulation for DS1990
* Initial emulation implementation for DS1992
* Better common command definitions
* Use common submenu callback, add protocol list
* Improve ViewData screen
* Improve scene_add_type
* Add stubs for write functionality
* Improve naming consistency
* Implement writing a DS1992 onto another one
* Improve DS1992 write code
* Improve DS1992 write code once more
* Prepare write_blank for DS1990, delete ibutton_writer
* Implement writing DS1990 onto blanks
* Fix reading DS1990
* Partially implement writing DS1992 onto blanks
* Implement GUI for writing keys
* Implement GUI for emulating keys
* Reduce memory usage for pretty_format
* Automatically truncate data more than 256 bytes
* Initial implementation of DS1996 (not tested)
* Fix crash due to missing virtual function
* Improve emulation code
* Improve DS1992 emulation code
* Correct return value for onewire_slave_send
* Correct return value for onewire_slave_receive
* Implement emulation for DS1992 & DS1996
* Better constant names
* Simplify & optimise the emulation code
* Remove duplicate code
* Add skip rom command emulation
* Show loading animation for large keys
* Implement manual adding & editing of keys
* Use buffered file streams to speed up saving & loading
* Reset key name before adding a new one
* Sync a buffered file stream before saving
* Use the DSGeneric protocol as a fallback option
* Implement emulation via RPC
* Refactor iButton code in preparation for comparator keys
* Refactor iButton code in preparation for comparator keys once more
* Make some functions static
* Make protocols not rely on one_wire classes
* Improve ProtocolDict usage
* Improve ProtocolDict usage more
* Implement reading Metakom & Cyfral keys
* Rename some files
* Better file structure
* Implement a unified interface for misc protocols
* Implement a unified interface for dallas protocols
* Concrete types for Dallas protocols
* Implement a unified interface for all key types
* Improved type naming
* Improved private types
* Proper types in protocol definitions
* Implement emulation for Cyfral & Metakom keys
* Implement save&load for Metakom & Cyfral keys
* Better type names
* Rename files, better names
* Allocate iButtonProtocols like a normal class
* Reset the key each time the start scene is selected
* Improve comments and constants
* Add ibutton_protocols to SDK headers
* Add ibutton_key to SDK headers
* Add ibutton_key to SDK headers
* Implement reading via cli
* Implement emulation via cli
* Implement writing Dallas blanks via cli
* Correctly revert the editing if cancelled by the user
* Correct committing mishap
* Elide the long text on the info screen
* Change key name for data in Misc keys
* Update iButtonFileFormat.md
* Remember the key's folder
* Save menu position in ReadKeyMenu and SavedKeyMenu
* Correct use of preselected path in file browser

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
This commit is contained in:
Georgii Surkov
2023-03-02 16:23:33 +03:00
committed by GitHub
parent 4359e2eaa9
commit 806428efeb
91 changed files with 3826 additions and 2166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

352
lib/one_wire/ibutton/protocols/misc/protocol_cyfral.c Normal file
View File

@@ -0,0 +1,352 @@
#include <furi.h>
#include <furi_hal.h>
#include "protocol_cyfral.h"
#define CYFRAL_DATA_SIZE sizeof(uint16_t)
#define CYFRAL_PERIOD (125 * furi_hal_cortex_instructions_per_microsecond())
#define CYFRAL_0_LOW (CYFRAL_PERIOD * 0.66f)
#define CYFRAL_0_HI (CYFRAL_PERIOD * 0.33f)
#define CYFRAL_1_LOW (CYFRAL_PERIOD * 0.33f)
#define CYFRAL_1_HI (CYFRAL_PERIOD * 0.66f)
#define CYFRAL_MAX_PERIOD_US 230
typedef enum {
CYFRAL_BIT_WAIT_FRONT_HIGH,
CYFRAL_BIT_WAIT_FRONT_LOW,
} CyfralBitState;
typedef enum {
CYFRAL_WAIT_START_NIBBLE,
CYFRAL_READ_NIBBLE,
CYFRAL_READ_STOP_NIBBLE,
} CyfralState;
typedef struct {
CyfralState state;
CyfralBitState bit_state;
// high + low period time
uint32_t period_time;
// temporary nibble storage
uint8_t nibble;
// data valid flag
// MUST be checked only in READ_STOP_NIBBLE state
bool data_valid;
// nibble index, we expect 8 nibbles
uint8_t index;
// bit index in nibble, 4 bit per nibble
uint8_t bit_index;
// max period, 230us x clock per us
uint32_t max_period;
} ProtocolCyfralDecoder;
typedef struct {
uint32_t data;
uint32_t index;
} ProtocolCyfralEncoder;
typedef struct {
uint16_t data;
ProtocolCyfralDecoder decoder;
ProtocolCyfralEncoder encoder;
} ProtocolCyfral;
static void* protocol_cyfral_alloc(void) {
ProtocolCyfral* proto = malloc(sizeof(ProtocolCyfral));
return (void*)proto;
}
static void protocol_cyfral_free(ProtocolCyfral* proto) {
free(proto);
}
static uint8_t* protocol_cyfral_get_data(ProtocolCyfral* proto) {
return (uint8_t*)&proto->data;
}
static void protocol_cyfral_decoder_start(ProtocolCyfral* proto) {
ProtocolCyfralDecoder* cyfral = &proto->decoder;
cyfral->state = CYFRAL_WAIT_START_NIBBLE;
cyfral->bit_state = CYFRAL_BIT_WAIT_FRONT_LOW;
cyfral->period_time = 0;
cyfral->bit_index = 0;
cyfral->index = 0;
cyfral->nibble = 0;
cyfral->data_valid = true;
cyfral->max_period = CYFRAL_MAX_PERIOD_US * furi_hal_cortex_instructions_per_microsecond();
proto->data = 0;
}
static bool protocol_cyfral_decoder_process_bit(
ProtocolCyfralDecoder* cyfral,
bool polarity,
uint32_t length,
bool* bit_ready,
bool* bit_value) {
bool result = true;
*bit_ready = false;
// bit start from low
switch(cyfral->bit_state) {
case CYFRAL_BIT_WAIT_FRONT_LOW:
if(polarity == true) {
cyfral->period_time += length;
*bit_ready = true;
if(cyfral->period_time <= cyfral->max_period) {
if((cyfral->period_time / 2) > length) {
*bit_value = false;
} else {
*bit_value = true;
}
} else {
result = false;
}
cyfral->bit_state = CYFRAL_BIT_WAIT_FRONT_HIGH;
} else {
result = false;
}
break;
case CYFRAL_BIT_WAIT_FRONT_HIGH:
if(polarity == false) {
cyfral->period_time = length;
cyfral->bit_state = CYFRAL_BIT_WAIT_FRONT_LOW;
} else {
result = false;
}
break;
}
return result;
}
static bool protocol_cyfral_decoder_feed(ProtocolCyfral* proto, bool level, uint32_t duration) {
ProtocolCyfralDecoder* cyfral = &proto->decoder;
bool bit_ready;
bool bit_value;
bool decoded = false;
switch(cyfral->state) {
case CYFRAL_WAIT_START_NIBBLE:
// wait for start word
if(protocol_cyfral_decoder_process_bit(cyfral, level, duration, &bit_ready, &bit_value)) {
if(bit_ready) {
cyfral->nibble = ((cyfral->nibble << 1) | bit_value) & 0x0F;
if(cyfral->nibble == 0b0001) {
cyfral->nibble = 0;
cyfral->state = CYFRAL_READ_NIBBLE;
}
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
case CYFRAL_READ_NIBBLE:
// read nibbles
if(protocol_cyfral_decoder_process_bit(cyfral, level, duration, &bit_ready, &bit_value)) {
if(bit_ready) {
cyfral->nibble = (cyfral->nibble << 1) | bit_value;
cyfral->bit_index++;
//convert every nibble to 2-bit index
if(cyfral->bit_index == 4) {
switch(cyfral->nibble) {
case 0b1110:
proto->data = (proto->data << 2) | 0b11;
break;
case 0b1101:
proto->data = (proto->data << 2) | 0b10;
break;
case 0b1011:
proto->data = (proto->data << 2) | 0b01;
break;
case 0b0111:
proto->data = (proto->data << 2) | 0b00;
break;
default:
cyfral->data_valid = false;
break;
}
cyfral->nibble = 0;
cyfral->bit_index = 0;
cyfral->index++;
}
// successfully read 8 nibbles
if(cyfral->index == 8) {
cyfral->state = CYFRAL_READ_STOP_NIBBLE;
}
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
case CYFRAL_READ_STOP_NIBBLE:
// read stop nibble
if(protocol_cyfral_decoder_process_bit(cyfral, level, duration, &bit_ready, &bit_value)) {
if(bit_ready) {
cyfral->nibble = ((cyfral->nibble << 1) | bit_value) & 0x0F;
cyfral->bit_index++;
switch(cyfral->bit_index) {
case 0:
case 1:
case 2:
case 3:
break;
case 4:
if(cyfral->nibble == 0b0001) {
// validate data
if(cyfral->data_valid) {
decoded = true;
} else {
protocol_cyfral_decoder_start(proto);
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
default:
protocol_cyfral_decoder_start(proto);
break;
}
}
} else {
protocol_cyfral_decoder_start(proto);
}
break;
}
return decoded;
}
static uint32_t protocol_cyfral_encoder_encode(const uint16_t data) {
uint32_t value = 0;
for(int8_t i = 0; i <= 7; i++) {
switch((data >> (i * 2)) & 0b00000011) {
case 0b11:
value = value << 4;
value += 0b00000111;
break;
case 0b10:
value = value << 4;
value += 0b00001011;
break;
case 0b01:
value = value << 4;
value += 0b00001101;
break;
case 0b00:
value = value << 4;
value += 0b00001110;
break;
default:
break;
}
}
return value;
}
static bool protocol_cyfral_encoder_start(ProtocolCyfral* proto) {
proto->encoder.index = 0;
proto->encoder.data = protocol_cyfral_encoder_encode(proto->data);
return true;
}
static LevelDuration protocol_cyfral_encoder_yield(ProtocolCyfral* proto) {
LevelDuration result;
if(proto->encoder.index < 8) {
// start word (0b0001)
switch(proto->encoder.index) {
case 0:
result = level_duration_make(false, CYFRAL_0_LOW); //-V1037
break;
case 1:
result = level_duration_make(true, CYFRAL_0_HI); //-V1037
break;
case 2:
result = level_duration_make(false, CYFRAL_0_LOW);
break;
case 3:
result = level_duration_make(true, CYFRAL_0_HI);
break;
case 4:
result = level_duration_make(false, CYFRAL_0_LOW);
break;
case 5:
result = level_duration_make(true, CYFRAL_0_HI);
break;
case 6:
result = level_duration_make(false, CYFRAL_1_LOW);
break;
case 7:
result = level_duration_make(true, CYFRAL_1_HI);
break;
}
} else {
// data
uint8_t data_start_index = proto->encoder.index - 8;
bool clock_polarity = (data_start_index) % 2;
uint8_t bit_index = (data_start_index) / 2;
bool bit_value = ((proto->encoder.data >> bit_index) & 1);
if(!clock_polarity) {
if(bit_value) {
result = level_duration_make(false, CYFRAL_1_LOW);
} else {
result = level_duration_make(false, CYFRAL_0_LOW);
}
} else {
if(bit_value) {
result = level_duration_make(true, CYFRAL_1_HI);
} else {
result = level_duration_make(true, CYFRAL_0_HI);
}
}
}
proto->encoder.index++;
if(proto->encoder.index >= (9 * 4 * 2)) {
proto->encoder.index = 0;
}
return result;
}
static void protocol_cyfral_render_brief_data(ProtocolCyfral* proto, FuriString* result) {
for(size_t i = 0; i < CYFRAL_DATA_SIZE; ++i) {
furi_string_cat_printf(result, "%02X ", ((uint8_t*)&proto->data)[i]);
}
}
const ProtocolBase ibutton_protocol_misc_cyfral = {
.name = "Cyfral",
.manufacturer = "Cyfral",
.data_size = CYFRAL_DATA_SIZE,
.alloc = (ProtocolAlloc)protocol_cyfral_alloc,
.free = (ProtocolFree)protocol_cyfral_free,
.get_data = (ProtocolGetData)protocol_cyfral_get_data,
.decoder =
{
.start = (ProtocolDecoderStart)protocol_cyfral_decoder_start,
.feed = (ProtocolDecoderFeed)protocol_cyfral_decoder_feed,
},
.encoder =
{
.start = (ProtocolEncoderStart)protocol_cyfral_encoder_start,
.yield = (ProtocolEncoderYield)protocol_cyfral_encoder_yield,
},
.render_brief_data = (ProtocolRenderData)protocol_cyfral_render_brief_data,
};

4
lib/one_wire/ibutton/protocols/misc/protocol_cyfral.h Normal file
View File

@@ -0,0 +1,4 @@
#pragma once
#include "toolbox/protocols/protocol.h"
extern const ProtocolBase ibutton_protocol_misc_cyfral;

295
lib/one_wire/ibutton/protocols/misc/protocol_group_misc.c Normal file
View File

@@ -0,0 +1,295 @@
#include "protocol_group_misc.h"
#include <furi_hal_rfid.h>
#include <furi_hal_ibutton.h>
#include <toolbox/protocols/protocol_dict.h>
#include "protocol_group_misc_defs.h"
#define IBUTTON_MISC_READ_TIMEOUT 100
#define IBUTTON_MISC_DATA_KEY_KEY_COMMON "Data"
typedef struct {
ProtocolDict* dict;
ProtocolId emulate_id;
} iButtonProtocolGroupMisc;
static iButtonProtocolGroupMisc* ibutton_protocol_group_misc_alloc() {
iButtonProtocolGroupMisc* group = malloc(sizeof(iButtonProtocolGroupMisc));
group->dict = protocol_dict_alloc(ibutton_protocols_misc, iButtonProtocolMiscMax);
group->emulate_id = PROTOCOL_NO;
return group;
}
static void ibutton_protocol_group_misc_free(iButtonProtocolGroupMisc* group) {
protocol_dict_free(group->dict);
free(group);
}
static size_t ibutton_protocol_group_misc_get_max_data_size(iButtonProtocolGroupMisc* group) {
return protocol_dict_get_max_data_size(group->dict);
}
static bool ibutton_protocol_group_misc_get_id_by_name(
iButtonProtocolGroupMisc* group,
iButtonProtocolLocalId* id,
const char* name) {
const ProtocolId found_id = protocol_dict_get_protocol_by_name(group->dict, name);
if(found_id != PROTOCOL_NO) {
*id = found_id;
return true;
}
return false;
}
static uint32_t ibutton_protocol_group_misc_get_features(
iButtonProtocolGroupMisc* group,
iButtonProtocolLocalId id) {
UNUSED(group);
UNUSED(id);
return 0;
}
static const char* ibutton_protocol_group_misc_get_manufacturer(
iButtonProtocolGroupMisc* group,
iButtonProtocolLocalId id) {
return protocol_dict_get_manufacturer(group->dict, id);
}
static const char* ibutton_protocol_group_misc_get_name(
iButtonProtocolGroupMisc* group,
iButtonProtocolLocalId id) {
return protocol_dict_get_name(group->dict, id);
}
typedef struct {
uint32_t last_dwt_value;
FuriStreamBuffer* stream;
} iButtonReadContext;
static void ibutton_protocols_comparator_callback(bool level, void* context) {
iButtonReadContext* read_context = context;
uint32_t current_dwt_value = DWT->CYCCNT;
LevelDuration data =
level_duration_make(level, current_dwt_value - read_context->last_dwt_value);
furi_stream_buffer_send(read_context->stream, &data, sizeof(LevelDuration), 0);
read_context->last_dwt_value = current_dwt_value;
}
static bool ibutton_protocol_group_misc_read(
iButtonProtocolGroupMisc* group,
iButtonProtocolData* data,
iButtonProtocolLocalId* id) {
bool result = false;
protocol_dict_decoders_start(group->dict);
furi_hal_rfid_pins_reset();
// pulldown pull pin, we sense the signal through the analog part of the RFID schematic
furi_hal_rfid_pin_pull_pulldown();
iButtonReadContext read_context = {
.last_dwt_value = DWT->CYCCNT,
.stream = furi_stream_buffer_alloc(sizeof(LevelDuration) * 512, 1),
};
furi_hal_rfid_comp_set_callback(ibutton_protocols_comparator_callback, &read_context);
furi_hal_rfid_comp_start();
const uint32_t tick_start = furi_get_tick();
for(;;) {
LevelDuration level;
size_t ret = furi_stream_buffer_receive(
read_context.stream, &level, sizeof(LevelDuration), IBUTTON_MISC_READ_TIMEOUT);
if((furi_get_tick() - tick_start) > IBUTTON_MISC_READ_TIMEOUT) {
break;
}
if(ret > 0) {
ProtocolId decoded_index = protocol_dict_decoders_feed(
group->dict, level_duration_get_level(level), level_duration_get_duration(level));
if(decoded_index == PROTOCOL_NO) continue;
*id = decoded_index;
protocol_dict_get_data(
group->dict,
decoded_index,
data,
protocol_dict_get_data_size(group->dict, decoded_index));
result = true;
}
}
furi_hal_rfid_comp_stop();
furi_hal_rfid_comp_set_callback(NULL, NULL);
furi_hal_rfid_pins_reset();
furi_stream_buffer_free(read_context.stream);
return result;
}
static void ibutton_protocol_group_misc_emulate_callback(void* context) {
iButtonProtocolGroupMisc* group = context;
const LevelDuration level_duration =
protocol_dict_encoder_yield(group->dict, group->emulate_id);
furi_hal_ibutton_emulate_set_next(level_duration_get_duration(level_duration));
furi_hal_ibutton_pin_write(level_duration_get_level(level_duration));
}
static void ibutton_protocol_group_misc_emulate_start(
iButtonProtocolGroupMisc* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
group->emulate_id = id;
protocol_dict_set_data(group->dict, id, data, protocol_dict_get_data_size(group->dict, id));
protocol_dict_encoder_start(group->dict, group->emulate_id);
furi_hal_ibutton_pin_configure();
furi_hal_ibutton_emulate_start(0, ibutton_protocol_group_misc_emulate_callback, group);
}
static void ibutton_protocol_group_misc_emulate_stop(
iButtonProtocolGroupMisc* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
UNUSED(group);
UNUSED(data);
UNUSED(id);
furi_hal_ibutton_emulate_stop();
furi_hal_ibutton_pin_reset();
}
static bool ibutton_protocol_group_misc_save(
iButtonProtocolGroupMisc* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FlipperFormat* ff) {
const size_t data_size = protocol_dict_get_data_size(group->dict, id);
return flipper_format_write_hex(ff, IBUTTON_MISC_DATA_KEY_KEY_COMMON, data, data_size);
}
static bool ibutton_protocol_group_misc_load(
iButtonProtocolGroupMisc* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id,
uint32_t version,
FlipperFormat* ff) {
const size_t data_size = protocol_dict_get_data_size(group->dict, id);
switch(version) {
case 1:
case 2:
return flipper_format_read_hex(ff, IBUTTON_MISC_DATA_KEY_KEY_COMMON, data, data_size);
default:
return false;
}
}
static void ibutton_protocol_group_misc_render_data(
iButtonProtocolGroupMisc* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FuriString* result) {
const size_t data_size = protocol_dict_get_data_size(group->dict, id);
protocol_dict_set_data(group->dict, id, data, data_size);
protocol_dict_render_data(group->dict, result, id);
}
static void ibutton_protocol_group_misc_render_brief_data(
iButtonProtocolGroupMisc* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FuriString* result) {
const size_t data_size = protocol_dict_get_data_size(group->dict, id);
protocol_dict_set_data(group->dict, id, data, data_size);
protocol_dict_render_brief_data(group->dict, result, id);
}
static void ibutton_protocol_group_misc_render_error(
iButtonProtocolGroupMisc* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FuriString* result) {
UNUSED(group);
UNUSED(data);
UNUSED(id);
UNUSED(result);
}
static bool ibutton_protocol_group_misc_is_valid(
iButtonProtocolGroupMisc* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id) {
UNUSED(group);
UNUSED(data);
UNUSED(id);
return true;
}
static void ibutton_protocol_group_misc_get_editable_data(
iButtonProtocolGroupMisc* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id,
iButtonEditableData* editable) {
editable->ptr = data;
editable->size = protocol_dict_get_data_size(group->dict, id);
}
static void ibutton_protocol_group_misc_apply_edits(
iButtonProtocolGroupMisc* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
const size_t data_size = protocol_dict_get_data_size(group->dict, id);
protocol_dict_set_data(group->dict, id, data, data_size);
}
const iButtonProtocolGroupBase ibutton_protocol_group_misc = {
.protocol_count = iButtonProtocolMiscMax,
.alloc = (iButtonProtocolGroupAllocFunc)ibutton_protocol_group_misc_alloc,
.free = (iButtonProtocolGroupFreeFunc)ibutton_protocol_group_misc_free,
.get_max_data_size =
(iButtonProtocolGropuGetSizeFunc)ibutton_protocol_group_misc_get_max_data_size,
.get_id_by_name = (iButtonProtocolGroupGetIdFunc)ibutton_protocol_group_misc_get_id_by_name,
.get_features = (iButtonProtocolGroupGetFeaturesFunc)ibutton_protocol_group_misc_get_features,
.get_manufacturer =
(iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_misc_get_manufacturer,
.get_name = (iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_misc_get_name,
.read = (iButtonProtocolGroupReadFunc)ibutton_protocol_group_misc_read,
.write_blank = NULL,
.write_copy = NULL,
.emulate_start = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_misc_emulate_start,
.emulate_stop = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_misc_emulate_stop,
.save = (iButtonProtocolGroupSaveFunc)ibutton_protocol_group_misc_save,
.load = (iButtonProtocolGroupLoadFunc)ibutton_protocol_group_misc_load,
.render_data = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_misc_render_data,
.render_brief_data =
(iButtonProtocolGroupRenderFunc)ibutton_protocol_group_misc_render_brief_data,
.render_error = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_misc_render_error,
.is_valid = (iButtonProtocolGroupIsValidFunc)ibutton_protocol_group_misc_is_valid,
.get_editable_data =
(iButtonProtocolGroupGetDataFunc)ibutton_protocol_group_misc_get_editable_data,
.apply_edits = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_misc_apply_edits,
};

5
lib/one_wire/ibutton/protocols/misc/protocol_group_misc.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include "../protocol_group_base.h"
extern const iButtonProtocolGroupBase ibutton_protocol_group_misc;

10
lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.c Normal file
View File

@@ -0,0 +1,10 @@
#include "protocol_group_misc_defs.h"
#include "protocol_cyfral.h"
#include "protocol_metakom.h"
const ProtocolBase* ibutton_protocols_misc[] = {
[iButtonProtocolMiscCyfral] = &ibutton_protocol_misc_cyfral,
[iButtonProtocolMiscMetakom] = &ibutton_protocol_misc_metakom,
/* Add new misc protocols here */
};

11
lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.h Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
#include <toolbox/protocols/protocol.h>
typedef enum {
iButtonProtocolMiscCyfral,
iButtonProtocolMiscMetakom,
iButtonProtocolMiscMax,
} iButtonProtocolMisc;
extern const ProtocolBase* ibutton_protocols_misc[];

328
lib/one_wire/ibutton/protocols/misc/protocol_metakom.c Normal file
View File

@@ -0,0 +1,328 @@
#include <furi.h>
#include <furi_hal.h>
#include "protocol_metakom.h"
#define METAKOM_DATA_SIZE sizeof(uint32_t)
#define METAKOM_PERIOD (125 * furi_hal_cortex_instructions_per_microsecond())
#define METAKOM_0_LOW (METAKOM_PERIOD * 0.33f)
#define METAKOM_0_HI (METAKOM_PERIOD * 0.66f)
#define METAKOM_1_LOW (METAKOM_PERIOD * 0.66f)
#define METAKOM_1_HI (METAKOM_PERIOD * 0.33f)
#define METAKOM_PERIOD_SAMPLE_COUNT 10
typedef enum {
METAKOM_WAIT_PERIOD_SYNC,
METAKOM_WAIT_START_BIT,
METAKOM_WAIT_START_WORD,
METAKOM_READ_WORD,
METAKOM_READ_STOP_WORD,
} MetakomState;
typedef enum {
METAKOM_BIT_WAIT_FRONT_HIGH,
METAKOM_BIT_WAIT_FRONT_LOW,
} MetakomBitState;
typedef struct {
// high + low period time
uint32_t period_time;
uint32_t low_time_storage;
uint8_t period_sample_index;
uint32_t period_sample_data[METAKOM_PERIOD_SAMPLE_COUNT];
uint8_t tmp_data;
uint8_t tmp_counter;
uint8_t key_data_index;
MetakomBitState bit_state;
MetakomState state;
} ProtocolMetakomDecoder;
typedef struct {
uint32_t index;
} ProtocolMetakomEncoder;
typedef struct {
uint32_t data;
ProtocolMetakomDecoder decoder;
ProtocolMetakomEncoder encoder;
} ProtocolMetakom;
static ProtocolMetakom* protocol_metakom_alloc(void) {
ProtocolMetakom* proto = malloc(sizeof(ProtocolMetakom));
return (void*)proto;
}
static void protocol_metakom_free(ProtocolMetakom* proto) {
free(proto);
}
static uint8_t* protocol_metakom_get_data(ProtocolMetakom* proto) {
return (uint8_t*)&proto->data;
}
static void protocol_metakom_decoder_start(ProtocolMetakom* proto) {
ProtocolMetakomDecoder* metakom = &proto->decoder;
metakom->period_sample_index = 0;
metakom->period_time = 0;
metakom->tmp_counter = 0;
metakom->tmp_data = 0;
for(uint8_t i = 0; i < METAKOM_PERIOD_SAMPLE_COUNT; i++) {
metakom->period_sample_data[i] = 0;
};
metakom->state = METAKOM_WAIT_PERIOD_SYNC;
metakom->bit_state = METAKOM_BIT_WAIT_FRONT_LOW;
metakom->key_data_index = 0;
metakom->low_time_storage = 0;
proto->data = 0;
}
static bool metakom_parity_check(uint8_t data) {
uint8_t ones_count = 0;
bool result;
for(uint8_t i = 0; i < 8; i++) {
if((data >> i) & 0b00000001) {
ones_count++;
}
}
result = (ones_count % 2 == 0);
return result;
}
static bool metakom_process_bit(
ProtocolMetakomDecoder* metakom,
bool polarity,
uint32_t time,
uint32_t* high_time,
uint32_t* low_time) {
bool result = false;
switch(metakom->bit_state) {
case METAKOM_BIT_WAIT_FRONT_LOW:
if(polarity == false) {
*low_time = metakom->low_time_storage;
*high_time = time;
result = true;
metakom->bit_state = METAKOM_BIT_WAIT_FRONT_HIGH;
}
break;
case METAKOM_BIT_WAIT_FRONT_HIGH:
if(polarity == true) {
metakom->low_time_storage = time;
metakom->bit_state = METAKOM_BIT_WAIT_FRONT_LOW;
}
break;
}
return result;
}
static bool protocol_metakom_decoder_feed(ProtocolMetakom* proto, bool level, uint32_t duration) {
ProtocolMetakomDecoder* metakom = &proto->decoder;
bool ready = false;
uint32_t high_time = 0;
uint32_t low_time = 0;
switch(metakom->state) {
case METAKOM_WAIT_PERIOD_SYNC:
if(metakom_process_bit(metakom, level, duration, &high_time, &low_time)) {
metakom->period_sample_data[metakom->period_sample_index] = high_time + low_time;
metakom->period_sample_index++;
if(metakom->period_sample_index == METAKOM_PERIOD_SAMPLE_COUNT) {
for(uint8_t i = 0; i < METAKOM_PERIOD_SAMPLE_COUNT; i++) {
metakom->period_time += metakom->period_sample_data[i];
};
metakom->period_time /= METAKOM_PERIOD_SAMPLE_COUNT;
metakom->state = METAKOM_WAIT_START_BIT;
}
}
break;
case METAKOM_WAIT_START_BIT:
if(metakom_process_bit(metakom, level, duration, &high_time, &low_time)) {
metakom->tmp_counter++;
if(high_time > metakom->period_time) {
metakom->tmp_counter = 0;
metakom->state = METAKOM_WAIT_START_WORD;
}
if(metakom->tmp_counter > 40) {
protocol_metakom_decoder_start(proto);
}
}
break;
case METAKOM_WAIT_START_WORD:
if(metakom_process_bit(metakom, level, duration, &high_time, &low_time)) {
if(low_time < (metakom->period_time / 2)) {
metakom->tmp_data = (metakom->tmp_data << 1) | 0b0;
} else {
metakom->tmp_data = (metakom->tmp_data << 1) | 0b1;
}
metakom->tmp_counter++;
if(metakom->tmp_counter == 3) {
if(metakom->tmp_data == 0b010) {
metakom->tmp_counter = 0;
metakom->tmp_data = 0;
metakom->state = METAKOM_READ_WORD;
} else {
protocol_metakom_decoder_start(proto);
}
}
}
break;
case METAKOM_READ_WORD:
if(metakom_process_bit(metakom, level, duration, &high_time, &low_time)) {
if(low_time < (metakom->period_time / 2)) {
metakom->tmp_data = (metakom->tmp_data << 1) | 0b0;
} else {
metakom->tmp_data = (metakom->tmp_data << 1) | 0b1;
}
metakom->tmp_counter++;
if(metakom->tmp_counter == 8) {
if(metakom_parity_check(metakom->tmp_data)) {
proto->data = (proto->data << 8) | metakom->tmp_data;
metakom->key_data_index++;
metakom->tmp_data = 0;
metakom->tmp_counter = 0;
if(metakom->key_data_index == 4) {
// check for stop bit
if(high_time > metakom->period_time) {
metakom->state = METAKOM_READ_STOP_WORD;
} else {
protocol_metakom_decoder_start(proto);
}
}
} else {
protocol_metakom_decoder_start(proto);
}
}
}
break;
case METAKOM_READ_STOP_WORD:
if(metakom_process_bit(metakom, level, duration, &high_time, &low_time)) {
if(low_time < (metakom->period_time / 2)) {
metakom->tmp_data = (metakom->tmp_data << 1) | 0b0;
} else {
metakom->tmp_data = (metakom->tmp_data << 1) | 0b1;
}
metakom->tmp_counter++;
if(metakom->tmp_counter == 3) {
if(metakom->tmp_data == 0b010) {
ready = true;
} else {
protocol_metakom_decoder_start(proto);
}
}
}
break;
}
return ready;
}
static bool protocol_metakom_encoder_start(ProtocolMetakom* proto) {
proto->encoder.index = 0;
return true;
}
static LevelDuration protocol_metakom_encoder_yield(ProtocolMetakom* proto) {
LevelDuration result;
if(proto->encoder.index == 0) {
// sync bit
result = level_duration_make(false, METAKOM_PERIOD);
} else if(proto->encoder.index <= 6) {
// start word (0b010)
switch(proto->encoder.index) {
case 1:
result = level_duration_make(true, METAKOM_0_LOW); //-V1037
break;
case 2:
result = level_duration_make(false, METAKOM_0_HI); //-V1037
break;
case 3:
result = level_duration_make(true, METAKOM_1_LOW);
break;
case 4:
result = level_duration_make(false, METAKOM_1_HI);
break;
case 5:
result = level_duration_make(true, METAKOM_0_LOW);
break;
case 6:
result = level_duration_make(false, METAKOM_0_HI);
break;
}
} else {
// data
uint8_t data_start_index = proto->encoder.index - 7;
bool clock_polarity = (data_start_index) % 2;
uint8_t bit_index = (data_start_index) / 2;
bool bit_value = (proto->data >> (32 - 1 - bit_index)) & 1;
if(!clock_polarity) {
if(bit_value) {
result = level_duration_make(true, METAKOM_1_LOW);
} else {
result = level_duration_make(true, METAKOM_0_LOW);
}
} else {
if(bit_value) {
result = level_duration_make(false, METAKOM_1_HI);
} else {
result = level_duration_make(false, METAKOM_0_HI);
}
}
}
proto->encoder.index++;
if(proto->encoder.index >= (1 + 3 * 2 + 32 * 2)) {
proto->encoder.index = 0;
}
return result;
}
static void protocol_metakom_render_brief_data(ProtocolMetakom* proto, FuriString* result) {
for(size_t i = 0; i < METAKOM_DATA_SIZE; ++i) {
furi_string_cat_printf(result, "%02X ", ((uint8_t*)&proto->data)[i]);
}
}
const ProtocolBase ibutton_protocol_misc_metakom = {
.name = "Metakom",
.manufacturer = "Metakom",
.data_size = METAKOM_DATA_SIZE,
.alloc = (ProtocolAlloc)protocol_metakom_alloc,
.free = (ProtocolFree)protocol_metakom_free,
.get_data = (ProtocolGetData)protocol_metakom_get_data,
.decoder =
{
.start = (ProtocolDecoderStart)protocol_metakom_decoder_start,
.feed = (ProtocolDecoderFeed)protocol_metakom_decoder_feed,
},
.encoder =
{
.start = (ProtocolEncoderStart)protocol_metakom_encoder_start,
.yield = (ProtocolEncoderYield)protocol_metakom_encoder_yield,
},
.render_brief_data = (ProtocolRenderData)protocol_metakom_render_brief_data,
};

4
lib/one_wire/ibutton/protocols/misc/protocol_metakom.h Normal file
View File

@@ -0,0 +1,4 @@
#pragma once
#include "toolbox/protocols/protocol.h"
extern const ProtocolBase ibutton_protocol_misc_metakom;