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

95
lib/one_wire/ibutton/protocols/blanks/rw1990.c Normal file
View File

@@ -0,0 +1,95 @@
#include "rw1990.h"
#include <core/kernel.h>
#define RW1990_1_CMD_WRITE_RECORD_FLAG 0xD1
#define RW1990_1_CMD_READ_RECORD_FLAG 0xB5
#define RW1990_1_CMD_WRITE_ROM 0xD5
#define RW1990_2_CMD_WRITE_RECORD_FLAG 0x1D
#define RW1990_2_CMD_READ_RECORD_FLAG 0x1E
#define RW1990_2_CMD_WRITE_ROM 0xD5
#define DS1990_CMD_READ_ROM 0x33
static void rw1990_write_byte(OneWireHost* host, uint8_t value) {
for(uint8_t bitMask = 0x01; bitMask; bitMask <<= 1) {
onewire_host_write_bit(host, (bool)(bitMask & value));
furi_delay_us(5000);
}
}
static bool rw1990_read_and_compare(OneWireHost* host, const uint8_t* data, size_t data_size) {
bool success = false;
if(onewire_host_reset(host)) {
success = true;
onewire_host_write(host, DS1990_CMD_READ_ROM);
for(size_t i = 0; i < data_size; ++i) {
if(data[i] != onewire_host_read(host)) {
success = false;
break;
}
}
}
return success;
}
bool rw1990_write_v1(OneWireHost* host, const uint8_t* data, size_t data_size) {
// Unlock sequence
onewire_host_reset(host);
onewire_host_write(host, RW1990_1_CMD_WRITE_RECORD_FLAG);
furi_delay_us(10);
onewire_host_write_bit(host, false);
furi_delay_us(5000);
// Write data
onewire_host_reset(host);
onewire_host_write(host, RW1990_1_CMD_WRITE_ROM);
for(size_t i = 0; i < data_size; ++i) {
// inverted key for RW1990.1
rw1990_write_byte(host, ~(data[i]));
furi_delay_us(30000);
}
// Lock sequence
onewire_host_write(host, RW1990_1_CMD_WRITE_RECORD_FLAG);
onewire_host_write_bit(host, true);
furi_delay_us(10000);
// TODO: Better error handling
return rw1990_read_and_compare(host, data, data_size);
}
bool rw1990_write_v2(OneWireHost* host, const uint8_t* data, size_t data_size) {
// Unlock sequence
onewire_host_reset(host);
onewire_host_write(host, RW1990_2_CMD_WRITE_RECORD_FLAG);
furi_delay_us(10);
onewire_host_write_bit(host, true);
furi_delay_us(5000);
// Write data
onewire_host_reset(host);
onewire_host_write(host, RW1990_2_CMD_WRITE_ROM);
for(size_t i = 0; i < data_size; ++i) {
rw1990_write_byte(host, data[i]);
furi_delay_us(30000);
}
// Lock sequence
onewire_host_write(host, RW1990_2_CMD_WRITE_RECORD_FLAG);
onewire_host_write_bit(host, false);
furi_delay_us(10000);
// TODO: Better error handling
return rw1990_read_and_compare(host, data, data_size);
}

9
lib/one_wire/ibutton/protocols/blanks/rw1990.h Normal file
View File

@@ -0,0 +1,9 @@
#pragma once
#include <stddef.h>
#include <one_wire/one_wire_host.h>
bool rw1990_write_v1(OneWireHost* host, const uint8_t* data, size_t data_size);
bool rw1990_write_v2(OneWireHost* host, const uint8_t* data, size_t data_size);

42
lib/one_wire/ibutton/protocols/blanks/tm2004.c Normal file
View File

@@ -0,0 +1,42 @@
#include "tm2004.h"
#include <core/kernel.h>
#define TM2004_CMD_READ_STATUS 0xAA
#define TM2004_CMD_READ_MEMORY 0xF0
#define TM2004_CMD_WRITE_ROM 0x3C
#define TM2004_CMD_FINALIZATION 0x35
#define TM2004_ANSWER_READ_MEMORY 0xF5
bool tm2004_write(OneWireHost* host, const uint8_t* data, size_t data_size) {
onewire_host_reset(host);
onewire_host_write(host, TM2004_CMD_WRITE_ROM);
// Starting writing from address 0x0000
onewire_host_write(host, 0x00);
onewire_host_write(host, 0x00);
size_t i;
for(i = 0; i < data_size; ++i) {
uint8_t answer;
onewire_host_write(host, data[i]);
answer = onewire_host_read(host);
// TODO: check answer CRC
// pulse indicating that data is correct
furi_delay_us(600);
onewire_host_write_bit(host, true);
furi_delay_us(50000);
// read written key byte
answer = onewire_host_read(host); //-V519
// check that written and read are same
if(data[i] != answer) {
break;
}
}
// TODO: Better error handling
return i == data_size;
}

7
lib/one_wire/ibutton/protocols/blanks/tm2004.h Normal file
View File

@@ -0,0 +1,7 @@
#pragma once
#include <stddef.h>
#include <one_wire/one_wire_host.h>
bool tm2004_write(OneWireHost* host, const uint8_t* data, size_t data_size);

250
lib/one_wire/ibutton/protocols/dallas/dallas_common.c Normal file
View File

@@ -0,0 +1,250 @@
#include "dallas_common.h"
#include <core/common_defines.h>
#include <one_wire/maxim_crc.h>
#define BITS_IN_BYTE 8U
#define DALLAS_COMMON_ROM_DATA_KEY_V1 "Data"
#define DALLAS_COMMON_ROM_DATA_KEY_V2 "Rom Data"
#define DALLAS_COMMON_COPY_SCRATCH_MIN_TIMEOUT_US 5U
#define DALLAS_COMMON_COPY_SCRATCH_POLL_COUNT 20U
#define DALLAS_COMMON_END_ADDRESS_MASK 0x01F
#define DALLAS_COMMON_STATUS_FLAG_PF (1U << 5)
#define DALLAS_COMMON_STATUS_FLAG_OF (1U << 6)
#define DALLAS_COMMON_STATUS_FLAG_AA (1U << 7)
#define DALLAS_COMMON_BRIEF_HEAD_COUNT 4U
#define DALLAS_COMMON_BRIEF_TAIL_COUNT 3U
#define BITS_IN_BYTE 8U
#define BITS_IN_KBIT 1024U
bool dallas_common_skip_rom(OneWireHost* host) {
onewire_host_write(host, DALLAS_COMMON_CMD_SKIP_ROM);
return true;
}
bool dallas_common_read_rom(OneWireHost* host, DallasCommonRomData* rom_data) {
onewire_host_write(host, DALLAS_COMMON_CMD_READ_ROM);
onewire_host_read_bytes(host, rom_data->bytes, sizeof(DallasCommonRomData));
return dallas_common_is_valid_crc(rom_data);
}
bool dallas_common_write_scratchpad(
OneWireHost* host,
uint16_t address,
const uint8_t* data,
size_t data_size) {
onewire_host_write(host, DALLAS_COMMON_CMD_WRITE_SCRATCH);
onewire_host_write(host, (uint8_t)address);
onewire_host_write(host, (uint8_t)(address >> BITS_IN_BYTE));
onewire_host_write_bytes(host, data, data_size);
return true;
}
bool dallas_common_read_scratchpad(
OneWireHost* host,
DallasCommonAddressRegs* regs,
uint8_t* data,
size_t data_size) {
onewire_host_write(host, DALLAS_COMMON_CMD_READ_SCRATCH);
onewire_host_read_bytes(host, regs->bytes, sizeof(DallasCommonAddressRegs));
onewire_host_read_bytes(host, data, data_size);
return true;
}
bool dallas_common_copy_scratchpad(
OneWireHost* host,
const DallasCommonAddressRegs* regs,
uint32_t timeout_us) {
onewire_host_write(host, DALLAS_COMMON_CMD_COPY_SCRATCH);
onewire_host_write_bytes(host, regs->bytes, sizeof(DallasCommonAddressRegs));
const uint32_t poll_delay =
MAX(timeout_us / DALLAS_COMMON_COPY_SCRATCH_POLL_COUNT,
DALLAS_COMMON_COPY_SCRATCH_MIN_TIMEOUT_US);
uint32_t time_elapsed;
for(time_elapsed = 0; time_elapsed < timeout_us; time_elapsed += poll_delay) {
if(!onewire_host_read_bit(host)) break;
furi_delay_us(poll_delay);
}
return time_elapsed < timeout_us;
}
bool dallas_common_read_mem(OneWireHost* host, uint16_t address, uint8_t* data, size_t data_size) {
onewire_host_write(host, DALLAS_COMMON_CMD_READ_MEM);
onewire_host_write(host, (uint8_t)address);
onewire_host_write(host, (uint8_t)(address > BITS_IN_BYTE));
onewire_host_read_bytes(host, data, (uint16_t)data_size);
return true;
}
bool dallas_common_write_mem(
OneWireHost* host,
uint32_t timeout_us,
size_t page_size,
const uint8_t* data,
size_t data_size) {
// Data size must be a multiple of page size
furi_check(data_size % page_size == 0);
DallasCommonAddressRegs regs;
uint8_t* scratch = malloc(page_size);
size_t i;
for(i = 0; i < data_size; i += page_size) {
const uint8_t* data_ptr = data + i;
// Write scratchpad with the next page value
if(!onewire_host_reset(host)) break;
if(!dallas_common_skip_rom(host)) break;
if(!dallas_common_write_scratchpad(host, i, data_ptr, page_size)) break;
// Read back the scratchpad contents and address registers
if(!onewire_host_reset(host)) break;
if(!dallas_common_skip_rom(host)) break;
if(!dallas_common_read_scratchpad(host, &regs, scratch, page_size)) break;
// Verify scratchpad contents
if(memcmp(data_ptr, scratch, page_size) != 0) break;
// Write scratchpad to internal memory
if(!onewire_host_reset(host)) break;
if(!dallas_common_skip_rom(host)) break;
if(!dallas_common_copy_scratchpad(host, &regs, timeout_us)) break;
// Read back the address registers again
if(!onewire_host_reset(host)) break;
if(!dallas_common_skip_rom(host)) break;
if(!dallas_common_read_scratchpad(host, &regs, scratch, 0)) break;
// Check if AA flag is set
if(!(regs.fields.status & DALLAS_COMMON_STATUS_FLAG_AA)) break;
}
free(scratch);
return i == data_size;
}
bool dallas_common_emulate_search_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data) {
for(size_t i = 0; i < sizeof(DallasCommonRomData); i++) {
for(size_t j = 0; j < BITS_IN_BYTE; j++) {
bool bit = (rom_data->bytes[i] >> j) & 0x01;
if(!onewire_slave_send_bit(bus, bit)) return false;
if(!onewire_slave_send_bit(bus, !bit)) return false;
onewire_slave_receive_bit(bus);
// TODO: check for errors and return if any
}
}
return true;
}
bool dallas_common_emulate_read_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data) {
return onewire_slave_send(bus, rom_data->bytes, sizeof(DallasCommonRomData));
}
bool dallas_common_emulate_read_mem(OneWireSlave* bus, const uint8_t* data, size_t data_size) {
bool success = false;
union {
uint8_t bytes[sizeof(uint16_t)];
uint16_t word;
} address;
do {
if(!onewire_slave_receive(bus, address.bytes, sizeof(address))) break;
if(address.word >= data_size) break;
if(!onewire_slave_send(bus, data + address.word, data_size - address.word)) break;
success = true;
} while(false);
return success;
}
bool dallas_common_save_rom_data(FlipperFormat* ff, const DallasCommonRomData* rom_data) {
return flipper_format_write_hex(
ff, DALLAS_COMMON_ROM_DATA_KEY_V2, rom_data->bytes, sizeof(DallasCommonRomData));
}
bool dallas_common_load_rom_data(
FlipperFormat* ff,
uint32_t format_version,
DallasCommonRomData* rom_data) {
switch(format_version) {
case 1:
return flipper_format_read_hex(
ff, DALLAS_COMMON_ROM_DATA_KEY_V1, rom_data->bytes, sizeof(DallasCommonRomData));
case 2:
return flipper_format_read_hex(
ff, DALLAS_COMMON_ROM_DATA_KEY_V2, rom_data->bytes, sizeof(DallasCommonRomData));
default:
return false;
}
}
bool dallas_common_is_valid_crc(const DallasCommonRomData* rom_data) {
const uint8_t crc_calculated =
maxim_crc8(rom_data->bytes, sizeof(DallasCommonRomData) - 1, MAXIM_CRC8_INIT);
const uint8_t crc_received = rom_data->fields.checksum;
return crc_calculated == crc_received;
}
void dallas_common_render_brief_data(
FuriString* result,
const DallasCommonRomData* rom_data,
const uint8_t* sram_data,
size_t sram_data_size) {
for(size_t i = 0; i < sizeof(rom_data->bytes); ++i) {
furi_string_cat_printf(result, "%02X ", rom_data->bytes[i]);
}
furi_string_cat_printf(
result,
"\nInternal SRAM: %zu Kbit\n",
(size_t)(sram_data_size * BITS_IN_BYTE / BITS_IN_KBIT));
for(size_t i = 0; i < DALLAS_COMMON_BRIEF_HEAD_COUNT; ++i) {
furi_string_cat_printf(result, "%02X ", sram_data[i]);
}
furi_string_cat_printf(result, "[ . . . ]");
for(size_t i = sram_data_size - DALLAS_COMMON_BRIEF_TAIL_COUNT; i < sram_data_size; ++i) {
furi_string_cat_printf(result, " %02X", sram_data[i]);
}
}
void dallas_common_render_crc_error(FuriString* result, const DallasCommonRomData* rom_data) {
furi_string_set(result, "CRC Error\n");
const size_t data_size = sizeof(DallasCommonRomData);
for(size_t i = 0; i < data_size; ++i) {
furi_string_cat_printf(result, (i < data_size - 1) ? "%02X " : "%02X", rom_data->bytes[i]);
}
}
void dallas_common_apply_edits(DallasCommonRomData* rom_data, uint8_t family_code) {
rom_data->fields.family_code = family_code;
const uint8_t crc =
maxim_crc8(rom_data->bytes, sizeof(DallasCommonRomData) - 1, MAXIM_CRC8_INIT);
rom_data->fields.checksum = crc;
}

107
lib/one_wire/ibutton/protocols/dallas/dallas_common.h Normal file
View File

@@ -0,0 +1,107 @@
#pragma once
#include <flipper_format.h>
#include <one_wire/one_wire_host.h>
#include <one_wire/one_wire_slave.h>
#define DALLAS_COMMON_MANUFACTURER_NAME "Dallas"
#define DALLAS_COMMON_CMD_READ_ROM 0x33U
#define DALLAS_COMMON_CMD_MATCH_ROM 0x55U
#define DALLAS_COMMON_CMD_SKIP_ROM 0xCCU
#define DALLAS_COMMON_CMD_COND_SEARCH 0xECU
#define DALLAS_COMMON_CMD_SEARCH_ROM 0xF0U
#define DALLAS_COMMON_CMD_READ_SCRATCH 0xAAU
#define DALLAS_COMMON_CMD_WRITE_SCRATCH 0x0FU
#define DALLAS_COMMON_CMD_COPY_SCRATCH 0x55U
#define DALLAS_COMMON_CMD_READ_MEM 0xF0U
#define DALLAS_COMMON_CMD_OVERDRIVE_SKIP_ROM 0x3CU
#define DALLAS_COMMON_CMD_OVERDRIVE_MATCH_ROM 0x69U
typedef enum {
DallasCommonCommandStateIdle,
DallasCommonCommandStateRomCmd,
DallasCommonCommandStateMemCmd,
} DallasCommonCommandState;
typedef union {
struct {
uint8_t family_code;
uint8_t serial_number[6];
uint8_t checksum;
} fields;
uint8_t bytes[8];
} DallasCommonRomData;
typedef union {
struct {
uint8_t address_lo;
uint8_t address_hi;
uint8_t status;
} fields;
uint8_t bytes[3];
} DallasCommonAddressRegs;
/* Standard(ish) iButton commands */
bool dallas_common_skip_rom(OneWireHost* host);
bool dallas_common_read_rom(OneWireHost* host, DallasCommonRomData* rom_data);
bool dallas_common_write_scratchpad(
OneWireHost* host,
uint16_t address,
const uint8_t* data,
size_t data_size);
bool dallas_common_read_scratchpad(
OneWireHost* host,
DallasCommonAddressRegs* regs,
uint8_t* data,
size_t data_size);
bool dallas_common_copy_scratchpad(
OneWireHost* host,
const DallasCommonAddressRegs* regs,
uint32_t timeout_us);
bool dallas_common_read_mem(OneWireHost* host, uint16_t address, uint8_t* data, size_t data_size);
/* Combined operations */
bool dallas_common_write_mem(
OneWireHost* host,
uint32_t timeout_us,
size_t page_size,
const uint8_t* data,
size_t data_size);
/* Emulation */
bool dallas_common_emulate_search_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data);
bool dallas_common_emulate_read_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data);
bool dallas_common_emulate_read_mem(OneWireSlave* bus, const uint8_t* data, size_t data_size);
/* Save & Load */
bool dallas_common_save_rom_data(FlipperFormat* ff, const DallasCommonRomData* rom_data);
bool dallas_common_load_rom_data(
FlipperFormat* ff,
uint32_t format_version,
DallasCommonRomData* rom_data);
/* Miscellaneous */
bool dallas_common_is_valid_crc(const DallasCommonRomData* rom_data);
void dallas_common_render_brief_data(
FuriString* result,
const DallasCommonRomData* rom_data,
const uint8_t* sram_data,
size_t sram_data_size);
void dallas_common_render_crc_error(FuriString* result, const DallasCommonRomData* rom_data);
void dallas_common_apply_edits(DallasCommonRomData* rom_data, uint8_t family_code);

39
lib/one_wire/ibutton/protocols/dallas/protocol_dallas_base.h Normal file
View File

@@ -0,0 +1,39 @@
#pragma once
#include "../protocol_common_i.h"
#include <flipper_format.h>
#include <one_wire/one_wire_host.h>
#include <one_wire/one_wire_slave.h>
typedef bool (*iButtonProtocolDallasReadWriteFunc)(OneWireHost*, iButtonProtocolData*);
typedef void (*iButtonProtocolDallasEmulateFunc)(OneWireSlave*, iButtonProtocolData*);
typedef bool (*iButtonProtocolDallasSaveFunc)(FlipperFormat*, const iButtonProtocolData*);
typedef bool (*iButtonProtocolDallasLoadFunc)(FlipperFormat*, uint32_t, iButtonProtocolData*);
typedef void (*iButtonProtocolDallasRenderDataFunc)(FuriString*, const iButtonProtocolData*);
typedef bool (*iButtonProtocolDallasIsValidFunc)(const iButtonProtocolData*);
typedef void (
*iButtonProtocolDallasGetEditableDataFunc)(iButtonEditableData*, iButtonProtocolData*);
typedef void (*iButtonProtocolDallasApplyEditsFunc)(iButtonProtocolData*);
typedef struct {
const uint8_t family_code;
const uint32_t features;
const size_t data_size;
const char* manufacturer;
const char* name;
iButtonProtocolDallasReadWriteFunc read;
iButtonProtocolDallasReadWriteFunc write_blank;
iButtonProtocolDallasReadWriteFunc write_copy;
iButtonProtocolDallasEmulateFunc emulate;
iButtonProtocolDallasSaveFunc save;
iButtonProtocolDallasLoadFunc load;
iButtonProtocolDallasRenderDataFunc render_data;
iButtonProtocolDallasRenderDataFunc render_brief_data;
iButtonProtocolDallasRenderDataFunc render_error;
iButtonProtocolDallasIsValidFunc is_valid;
iButtonProtocolDallasGetEditableDataFunc get_editable_data;
iButtonProtocolDallasApplyEditsFunc apply_edits;
} iButtonProtocolDallasBase;

144
lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.c Normal file
View File

@@ -0,0 +1,144 @@
#include "protocol_ds1990.h"
#include <core/string.h>
#include <core/core_defines.h>
#include "dallas_common.h"
#include "../blanks/rw1990.h"
#include "../blanks/tm2004.h"
#define DS1990_FAMILY_CODE 0x01U
#define DS1990_FAMILY_NAME "DS1990"
#define DS1990_CMD_READ_ROM 0x0FU
typedef struct {
OneWireSlave* bus;
} DS1990ProtocolState;
typedef struct {
DallasCommonRomData rom_data;
DS1990ProtocolState state;
} DS1990ProtocolData;
static bool dallas_ds1990_read(OneWireHost*, iButtonProtocolData*);
static bool dallas_ds1990_write_blank(OneWireHost*, iButtonProtocolData*);
static void dallas_ds1990_emulate(OneWireSlave*, iButtonProtocolData*);
static bool dallas_ds1990_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
static bool dallas_ds1990_save(FlipperFormat*, const iButtonProtocolData*);
static void dallas_ds1990_render_brief_data(FuriString*, const iButtonProtocolData*);
static void dallas_ds1990_render_error(FuriString*, const iButtonProtocolData*);
static bool dallas_ds1990_is_data_valid(const iButtonProtocolData*);
static void dallas_ds1990_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
static void dallas_ds1990_apply_edits(iButtonProtocolData*);
const iButtonProtocolDallasBase ibutton_protocol_ds1990 = {
.family_code = DS1990_FAMILY_CODE,
.features = iButtonProtocolFeatureWriteBlank,
.data_size = sizeof(DS1990ProtocolData),
.manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
.name = DS1990_FAMILY_NAME,
.read = dallas_ds1990_read,
.write_blank = dallas_ds1990_write_blank,
.write_copy = NULL, /* No data to write a copy */
.emulate = dallas_ds1990_emulate,
.save = dallas_ds1990_save,
.load = dallas_ds1990_load,
.render_data = NULL, /* No data to render */
.render_brief_data = dallas_ds1990_render_brief_data,
.render_error = dallas_ds1990_render_error,
.is_valid = dallas_ds1990_is_data_valid,
.get_editable_data = dallas_ds1990_get_editable_data,
.apply_edits = dallas_ds1990_apply_edits,
};
bool dallas_ds1990_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1990ProtocolData* data = protocol_data;
return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data);
}
bool dallas_ds1990_write_blank(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1990ProtocolData* data = protocol_data;
return rw1990_write_v1(host, data->rom_data.bytes, sizeof(DallasCommonRomData)) ||
rw1990_write_v2(host, data->rom_data.bytes, sizeof(DallasCommonRomData)) ||
tm2004_write(host, data->rom_data.bytes, sizeof(DallasCommonRomData));
}
static bool dallas_ds1990_command_callback(uint8_t command, void* context) {
furi_assert(context);
DS1990ProtocolData* data = context;
OneWireSlave* bus = data->state.bus;
switch(command) {
case DALLAS_COMMON_CMD_SEARCH_ROM:
dallas_common_emulate_search_rom(bus, &data->rom_data);
break;
case DALLAS_COMMON_CMD_READ_ROM:
case DS1990_CMD_READ_ROM:
dallas_common_emulate_read_rom(bus, &data->rom_data);
break;
default:
break;
}
// No support for multiple consecutive commands
return false;
}
void dallas_ds1990_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
DS1990ProtocolData* data = protocol_data;
data->state.bus = bus;
onewire_slave_set_reset_callback(bus, NULL, NULL);
onewire_slave_set_command_callback(bus, dallas_ds1990_command_callback, protocol_data);
}
bool dallas_ds1990_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
const DS1990ProtocolData* data = protocol_data;
return dallas_common_save_rom_data(ff, &data->rom_data);
}
bool dallas_ds1990_load(
FlipperFormat* ff,
uint32_t format_version,
iButtonProtocolData* protocol_data) {
DS1990ProtocolData* data = protocol_data;
return dallas_common_load_rom_data(ff, format_version, &data->rom_data);
}
void dallas_ds1990_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1990ProtocolData* data = protocol_data;
for(size_t i = 0; i < sizeof(DallasCommonRomData); ++i) {
furi_string_cat_printf(result, "%02X ", data->rom_data.bytes[i]);
}
}
void dallas_ds1990_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1990ProtocolData* data = protocol_data;
if(!dallas_common_is_valid_crc(&data->rom_data)) {
dallas_common_render_crc_error(result, &data->rom_data);
}
}
bool dallas_ds1990_is_data_valid(const iButtonProtocolData* protocol_data) {
const DS1990ProtocolData* data = protocol_data;
return dallas_common_is_valid_crc(&data->rom_data);
}
void dallas_ds1990_get_editable_data(
iButtonEditableData* editable_data,
iButtonProtocolData* protocol_data) {
DS1990ProtocolData* data = protocol_data;
editable_data->ptr = data->rom_data.bytes;
editable_data->size = sizeof(DallasCommonRomData);
}
void dallas_ds1990_apply_edits(iButtonProtocolData* protocol_data) {
DS1990ProtocolData* data = protocol_data;
dallas_common_apply_edits(&data->rom_data, DS1990_FAMILY_CODE);
}

5
lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include "protocol_dallas_base.h"
extern const iButtonProtocolDallasBase ibutton_protocol_ds1990;

218
lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.c Normal file
View File

@@ -0,0 +1,218 @@
#include "protocol_ds1992.h"
#include <core/core_defines.h>
#include <toolbox/pretty_format.h>
#include "dallas_common.h"
#include "../blanks/tm2004.h"
#define DS1992_FAMILY_CODE 0x08U
#define DS1992_FAMILY_NAME "DS1992"
#define DS1992_SRAM_DATA_SIZE 128U
#define DS1992_SRAM_PAGE_SIZE 4U
#define DS1992_COPY_SCRATCH_TIMEOUT_US 100U
#define DS1992_DATA_BYTE_COUNT 4U
#define DS1992_SRAM_DATA_KEY "Sram Data"
typedef struct {
OneWireSlave* bus;
DallasCommonCommandState command_state;
} DS1992ProtocolState;
typedef struct {
DallasCommonRomData rom_data;
uint8_t sram_data[DS1992_SRAM_DATA_SIZE];
DS1992ProtocolState state;
} DS1992ProtocolData;
static bool dallas_ds1992_read(OneWireHost*, void*);
static bool dallas_ds1992_write_blank(OneWireHost*, iButtonProtocolData*);
static bool dallas_ds1992_write_copy(OneWireHost*, iButtonProtocolData*);
static void dallas_ds1992_emulate(OneWireSlave*, iButtonProtocolData*);
static bool dallas_ds1992_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
static bool dallas_ds1992_save(FlipperFormat*, const iButtonProtocolData*);
static void dallas_ds1992_render_data(FuriString*, const iButtonProtocolData*);
static void dallas_ds1992_render_brief_data(FuriString*, const iButtonProtocolData*);
static void dallas_ds1992_render_error(FuriString*, const iButtonProtocolData*);
static bool dallas_ds1992_is_data_valid(const iButtonProtocolData*);
static void dallas_ds1992_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
static void dallas_ds1992_apply_edits(iButtonProtocolData*);
const iButtonProtocolDallasBase ibutton_protocol_ds1992 = {
.family_code = DS1992_FAMILY_CODE,
.features = iButtonProtocolFeatureExtData | iButtonProtocolFeatureWriteBlank |
iButtonProtocolFeatureWriteCopy,
.data_size = sizeof(DS1992ProtocolData),
.manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
.name = DS1992_FAMILY_NAME,
.read = dallas_ds1992_read,
.write_blank = dallas_ds1992_write_blank,
.write_copy = dallas_ds1992_write_copy,
.emulate = dallas_ds1992_emulate,
.save = dallas_ds1992_save,
.load = dallas_ds1992_load,
.render_data = dallas_ds1992_render_data,
.render_brief_data = dallas_ds1992_render_brief_data,
.render_error = dallas_ds1992_render_error,
.is_valid = dallas_ds1992_is_data_valid,
.get_editable_data = dallas_ds1992_get_editable_data,
.apply_edits = dallas_ds1992_apply_edits,
};
bool dallas_ds1992_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data) &&
dallas_common_read_mem(host, 0, data->sram_data, DS1992_SRAM_DATA_SIZE);
}
bool dallas_ds1992_write_blank(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
// TODO: Make this work, currently broken
return tm2004_write(host, (uint8_t*)data, sizeof(DallasCommonRomData) + DS1992_SRAM_DATA_SIZE);
}
bool dallas_ds1992_write_copy(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
return dallas_common_write_mem(
host,
DS1992_COPY_SCRATCH_TIMEOUT_US,
DS1992_SRAM_PAGE_SIZE,
data->sram_data,
DS1992_SRAM_DATA_SIZE);
}
static void dallas_ds1992_reset_callback(void* context) {
furi_assert(context);
DS1992ProtocolData* data = context;
data->state.command_state = DallasCommonCommandStateIdle;
}
static bool dallas_ds1992_command_callback(uint8_t command, void* context) {
furi_assert(context);
DS1992ProtocolData* data = context;
OneWireSlave* bus = data->state.bus;
switch(command) {
case DALLAS_COMMON_CMD_SEARCH_ROM:
if(data->state.command_state == DallasCommonCommandStateIdle) {
data->state.command_state = DallasCommonCommandStateRomCmd;
return dallas_common_emulate_search_rom(bus, &data->rom_data);
} else if(data->state.command_state == DallasCommonCommandStateRomCmd) {
data->state.command_state = DallasCommonCommandStateMemCmd;
dallas_common_emulate_read_mem(bus, data->sram_data, DS1992_SRAM_DATA_SIZE);
return false;
} else {
return false;
}
case DALLAS_COMMON_CMD_READ_ROM:
if(data->state.command_state == DallasCommonCommandStateIdle) {
data->state.command_state = DallasCommonCommandStateRomCmd;
return dallas_common_emulate_read_rom(bus, &data->rom_data);
} else {
return false;
}
case DALLAS_COMMON_CMD_SKIP_ROM:
if(data->state.command_state == DallasCommonCommandStateIdle) {
data->state.command_state = DallasCommonCommandStateRomCmd;
return true;
} else {
return false;
}
default:
return false;
}
}
void dallas_ds1992_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
data->state.bus = bus;
onewire_slave_set_reset_callback(bus, dallas_ds1992_reset_callback, protocol_data);
onewire_slave_set_command_callback(bus, dallas_ds1992_command_callback, protocol_data);
}
bool dallas_ds1992_load(
FlipperFormat* ff,
uint32_t format_version,
iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
bool success = false;
do {
if(format_version < 2) break;
if(!dallas_common_load_rom_data(ff, format_version, &data->rom_data)) break;
if(!flipper_format_read_hex(
ff, DS1992_SRAM_DATA_KEY, data->sram_data, DS1992_SRAM_DATA_SIZE))
break;
success = true;
} while(false);
return success;
}
bool dallas_ds1992_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
const DS1992ProtocolData* data = protocol_data;
bool success = false;
do {
if(!dallas_common_save_rom_data(ff, &data->rom_data)) break;
if(!flipper_format_write_hex(
ff, DS1992_SRAM_DATA_KEY, data->sram_data, DS1992_SRAM_DATA_SIZE))
break;
success = true;
} while(false);
return success;
}
void dallas_ds1992_render_data(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1992ProtocolData* data = protocol_data;
pretty_format_bytes_hex_canonical(
result,
DS1992_DATA_BYTE_COUNT,
PRETTY_FORMAT_FONT_MONOSPACE,
data->sram_data,
DS1992_SRAM_DATA_SIZE);
}
void dallas_ds1992_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1992ProtocolData* data = protocol_data;
dallas_common_render_brief_data(
result, &data->rom_data, data->sram_data, DS1992_SRAM_DATA_SIZE);
}
void dallas_ds1992_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1992ProtocolData* data = protocol_data;
if(!dallas_common_is_valid_crc(&data->rom_data)) {
dallas_common_render_crc_error(result, &data->rom_data);
}
}
bool dallas_ds1992_is_data_valid(const iButtonProtocolData* protocol_data) {
const DS1992ProtocolData* data = protocol_data;
return dallas_common_is_valid_crc(&data->rom_data);
}
void dallas_ds1992_get_editable_data(
iButtonEditableData* editable_data,
iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
editable_data->ptr = data->rom_data.bytes;
editable_data->size = sizeof(DallasCommonRomData);
}
void dallas_ds1992_apply_edits(iButtonProtocolData* protocol_data) {
DS1992ProtocolData* data = protocol_data;
dallas_common_apply_edits(&data->rom_data, DS1992_FAMILY_CODE);
}

5
lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include "protocol_dallas_base.h"
extern const iButtonProtocolDallasBase ibutton_protocol_ds1992;

212
lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.c Normal file
View File

@@ -0,0 +1,212 @@
#include "protocol_ds1996.h"
#include <core/core_defines.h>
#include <toolbox/pretty_format.h>
#include "dallas_common.h"
#define DS1996_FAMILY_CODE 0x0CU
#define DS1996_FAMILY_NAME "DS1996"
#define DS1996_SRAM_DATA_SIZE 8192U
#define DS1996_SRAM_PAGE_SIZE 32U
#define DS1996_COPY_SCRATCH_TIMEOUT_US 100U
#define DS1996_DATA_BYTE_COUNT 4U
#define DS1996_SRAM_DATA_KEY "Sram Data"
typedef struct {
OneWireSlave* bus;
DallasCommonCommandState command_state;
} DS1996ProtocolState;
typedef struct {
DallasCommonRomData rom_data;
uint8_t sram_data[DS1996_SRAM_DATA_SIZE];
DS1996ProtocolState state;
} DS1996ProtocolData;
static bool dallas_ds1996_read(OneWireHost*, void*);
static bool dallas_ds1996_write_copy(OneWireHost*, iButtonProtocolData*);
static void dallas_ds1996_emulate(OneWireSlave*, iButtonProtocolData*);
static bool dallas_ds1996_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
static bool dallas_ds1996_save(FlipperFormat*, const iButtonProtocolData*);
static void dallas_ds1996_render_data(FuriString*, const iButtonProtocolData*);
static void dallas_ds1996_render_brief_data(FuriString*, const iButtonProtocolData*);
static void dallas_ds1996_render_error(FuriString*, const iButtonProtocolData*);
static bool dallas_ds1996_is_data_valid(const iButtonProtocolData*);
static void dallas_ds1996_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
static void dallas_ds1996_apply_edits(iButtonProtocolData*);
const iButtonProtocolDallasBase ibutton_protocol_ds1996 = {
.family_code = DS1996_FAMILY_CODE,
.features = iButtonProtocolFeatureExtData | iButtonProtocolFeatureWriteCopy,
.data_size = sizeof(DS1996ProtocolData),
.manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
.name = DS1996_FAMILY_NAME,
.read = dallas_ds1996_read,
.write_blank = NULL, /* Data too big for known blanks */
.write_copy = dallas_ds1996_write_copy,
.emulate = dallas_ds1996_emulate,
.save = dallas_ds1996_save,
.load = dallas_ds1996_load,
.render_data = dallas_ds1996_render_data,
.render_brief_data = dallas_ds1996_render_brief_data,
.render_error = dallas_ds1996_render_error,
.is_valid = dallas_ds1996_is_data_valid,
.get_editable_data = dallas_ds1996_get_editable_data,
.apply_edits = dallas_ds1996_apply_edits,
};
bool dallas_ds1996_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1996ProtocolData* data = protocol_data;
return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data) &&
dallas_common_read_mem(host, 0, data->sram_data, DS1996_SRAM_DATA_SIZE);
}
bool dallas_ds1996_write_copy(OneWireHost* host, iButtonProtocolData* protocol_data) {
DS1996ProtocolData* data = protocol_data;
return dallas_common_write_mem(
host,
DS1996_COPY_SCRATCH_TIMEOUT_US,
DS1996_SRAM_PAGE_SIZE,
data->sram_data,
DS1996_SRAM_DATA_SIZE);
}
static void dallas_ds1996_reset_callback(void* context) {
furi_assert(context);
DS1996ProtocolData* data = context;
data->state.command_state = DallasCommonCommandStateIdle;
}
static bool dallas_ds1996_command_callback(uint8_t command, void* context) {
furi_assert(context);
DS1996ProtocolData* data = context;
OneWireSlave* bus = data->state.bus;
switch(command) {
case DALLAS_COMMON_CMD_SEARCH_ROM:
if(data->state.command_state == DallasCommonCommandStateIdle) {
data->state.command_state = DallasCommonCommandStateRomCmd;
return dallas_common_emulate_search_rom(bus, &data->rom_data);
} else if(data->state.command_state == DallasCommonCommandStateRomCmd) {
data->state.command_state = DallasCommonCommandStateMemCmd;
dallas_common_emulate_read_mem(bus, data->sram_data, DS1996_SRAM_DATA_SIZE);
return false;
} else {
return false;
}
case DALLAS_COMMON_CMD_READ_ROM:
if(data->state.command_state == DallasCommonCommandStateIdle) {
data->state.command_state = DallasCommonCommandStateRomCmd;
return dallas_common_emulate_read_rom(bus, &data->rom_data);
} else {
return false;
}
case DALLAS_COMMON_CMD_SKIP_ROM:
if(data->state.command_state == DallasCommonCommandStateIdle) {
data->state.command_state = DallasCommonCommandStateRomCmd;
return true;
} else {
return false;
}
case DALLAS_COMMON_CMD_OVERDRIVE_SKIP_ROM:
case DALLAS_COMMON_CMD_OVERDRIVE_MATCH_ROM:
/* TODO: Overdrive mode support */
default:
return false;
}
}
void dallas_ds1996_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
DS1996ProtocolData* data = protocol_data;
data->state.bus = bus;
onewire_slave_set_reset_callback(bus, dallas_ds1996_reset_callback, protocol_data);
onewire_slave_set_command_callback(bus, dallas_ds1996_command_callback, protocol_data);
}
bool dallas_ds1996_load(
FlipperFormat* ff,
uint32_t format_version,
iButtonProtocolData* protocol_data) {
DS1996ProtocolData* data = protocol_data;
bool success = false;
do {
if(format_version < 2) break;
if(!dallas_common_load_rom_data(ff, format_version, &data->rom_data)) break;
if(!flipper_format_read_hex(
ff, DS1996_SRAM_DATA_KEY, data->sram_data, DS1996_SRAM_DATA_SIZE))
break;
success = true;
} while(false);
return success;
}
bool dallas_ds1996_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
const DS1996ProtocolData* data = protocol_data;
bool success = false;
do {
if(!dallas_common_save_rom_data(ff, &data->rom_data)) break;
if(!flipper_format_write_hex(
ff, DS1996_SRAM_DATA_KEY, data->sram_data, DS1996_SRAM_DATA_SIZE))
break;
success = true;
} while(false);
return success;
}
void dallas_ds1996_render_data(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1996ProtocolData* data = protocol_data;
pretty_format_bytes_hex_canonical(
result,
DS1996_DATA_BYTE_COUNT,
PRETTY_FORMAT_FONT_MONOSPACE,
data->sram_data,
DS1996_SRAM_DATA_SIZE);
}
void dallas_ds1996_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1996ProtocolData* data = protocol_data;
dallas_common_render_brief_data(
result, &data->rom_data, data->sram_data, DS1996_SRAM_DATA_SIZE);
}
void dallas_ds1996_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
const DS1996ProtocolData* data = protocol_data;
if(!dallas_common_is_valid_crc(&data->rom_data)) {
dallas_common_render_crc_error(result, &data->rom_data);
}
}
bool dallas_ds1996_is_data_valid(const iButtonProtocolData* protocol_data) {
const DS1996ProtocolData* data = protocol_data;
return dallas_common_is_valid_crc(&data->rom_data);
}
void dallas_ds1996_get_editable_data(
iButtonEditableData* editable_data,
iButtonProtocolData* protocol_data) {
DS1996ProtocolData* data = protocol_data;
editable_data->ptr = data->rom_data.bytes;
editable_data->size = sizeof(DallasCommonRomData);
}
void dallas_ds1996_apply_edits(iButtonProtocolData* protocol_data) {
DS1996ProtocolData* data = protocol_data;
dallas_common_apply_edits(&data->rom_data, DS1996_FAMILY_CODE);
}

5
lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include "protocol_dallas_base.h"
extern const iButtonProtocolDallasBase ibutton_protocol_ds1996;

133
lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.c Normal file
View File

@@ -0,0 +1,133 @@
#include "protocol_ds_generic.h"
#include <core/string.h>
#include <core/core_defines.h>
#include "dallas_common.h"
#include "../blanks/tm2004.h"
#define DALLAS_GENERIC_FAMILY_CODE 0x00U
#define DALLAS_GENERIC_FAMILY_NAME "DSGeneric"
typedef struct {
OneWireSlave* bus;
} DallasGenericProtocolState;
typedef struct {
DallasCommonRomData rom_data;
DallasGenericProtocolState state;
} DallasGenericProtocolData;
static bool ds_generic_read(OneWireHost*, iButtonProtocolData*);
static bool ds_generic_write_blank(OneWireHost*, iButtonProtocolData*);
static void ds_generic_emulate(OneWireSlave*, iButtonProtocolData*);
static bool ds_generic_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
static bool ds_generic_save(FlipperFormat*, const iButtonProtocolData*);
static void ds_generic_render_brief_data(FuriString*, const iButtonProtocolData*);
static void ds_generic_render_error(FuriString*, const iButtonProtocolData*);
static bool ds_generic_is_data_valid(const iButtonProtocolData*);
static void ds_generic_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
static void ds_generic_apply_edits(iButtonProtocolData*);
const iButtonProtocolDallasBase ibutton_protocol_ds_generic = {
.family_code = DALLAS_GENERIC_FAMILY_CODE,
.features = iButtonProtocolFeatureWriteBlank,
.data_size = sizeof(DallasGenericProtocolData),
.manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
.name = DALLAS_GENERIC_FAMILY_NAME,
.read = ds_generic_read,
.write_blank = ds_generic_write_blank,
.write_copy = NULL, /* No data to write a copy */
.emulate = ds_generic_emulate,
.save = ds_generic_save,
.load = ds_generic_load,
.render_data = NULL, /* No data to render */
.render_brief_data = ds_generic_render_brief_data,
.render_error = ds_generic_render_error,
.is_valid = ds_generic_is_data_valid,
.get_editable_data = ds_generic_get_editable_data,
.apply_edits = ds_generic_apply_edits,
};
bool ds_generic_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
DallasGenericProtocolData* data = protocol_data;
return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data);
}
bool ds_generic_write_blank(OneWireHost* host, iButtonProtocolData* protocol_data) {
DallasGenericProtocolData* data = protocol_data;
return tm2004_write(host, data->rom_data.bytes, sizeof(DallasCommonRomData));
}
static bool ds_generic_command_callback(uint8_t command, void* context) {
furi_assert(context);
DallasGenericProtocolData* data = context;
OneWireSlave* bus = data->state.bus;
switch(command) {
case DALLAS_COMMON_CMD_SEARCH_ROM:
dallas_common_emulate_search_rom(bus, &data->rom_data);
break;
case DALLAS_COMMON_CMD_READ_ROM:
dallas_common_emulate_read_rom(bus, &data->rom_data);
break;
default:
break;
}
// No support for multiple consecutive commands
return false;
}
void ds_generic_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
DallasGenericProtocolData* data = protocol_data;
data->state.bus = bus;
onewire_slave_set_reset_callback(bus, NULL, NULL);
onewire_slave_set_command_callback(bus, ds_generic_command_callback, protocol_data);
}
bool ds_generic_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
const DallasGenericProtocolData* data = protocol_data;
return dallas_common_save_rom_data(ff, &data->rom_data);
}
bool ds_generic_load(
FlipperFormat* ff,
uint32_t format_version,
iButtonProtocolData* protocol_data) {
DallasGenericProtocolData* data = protocol_data;
return dallas_common_load_rom_data(ff, format_version, &data->rom_data);
}
void ds_generic_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
const DallasGenericProtocolData* data = protocol_data;
for(size_t i = 0; i < sizeof(DallasCommonRomData); ++i) {
furi_string_cat_printf(result, "%02X ", data->rom_data.bytes[i]);
}
}
void ds_generic_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
UNUSED(result);
UNUSED(protocol_data);
}
bool ds_generic_is_data_valid(const iButtonProtocolData* protocol_data) {
UNUSED(protocol_data);
return true;
}
void ds_generic_get_editable_data(
iButtonEditableData* editable_data,
iButtonProtocolData* protocol_data) {
DallasGenericProtocolData* data = protocol_data;
editable_data->ptr = data->rom_data.bytes;
editable_data->size = sizeof(DallasCommonRomData);
}
void ds_generic_apply_edits(iButtonProtocolData* protocol_data) {
UNUSED(protocol_data);
}

5
lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include "protocol_dallas_base.h"
extern const iButtonProtocolDallasBase ibutton_protocol_ds_generic;

310
lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.c Normal file
View File

@@ -0,0 +1,310 @@
#include "protocol_group_dallas.h"
#include <furi_hal_resources.h>
#include "protocol_group_dallas_defs.h"
#define IBUTTON_ONEWIRE_ROM_SIZE 8U
typedef struct {
OneWireHost* host;
OneWireSlave* bus;
} iButtonProtocolGroupDallas;
static iButtonProtocolGroupDallas* ibutton_protocol_group_dallas_alloc() {
iButtonProtocolGroupDallas* group = malloc(sizeof(iButtonProtocolGroupDallas));
group->host = onewire_host_alloc(&ibutton_gpio);
group->bus = onewire_slave_alloc(&ibutton_gpio);
return group;
}
static void ibutton_protocol_group_dallas_free(iButtonProtocolGroupDallas* group) {
onewire_slave_free(group->bus);
onewire_host_free(group->host);
free(group);
}
static size_t ibutton_protocol_group_dallas_get_max_data_size(iButtonProtocolGroupDallas* group) {
UNUSED(group);
size_t max_data_size = 0;
for(iButtonProtocolLocalId i = 0; i < iButtonProtocolDSMax; ++i) {
const size_t current_rom_size = ibutton_protocols_dallas[i]->data_size;
if(current_rom_size > max_data_size) {
max_data_size = current_rom_size;
}
}
return max_data_size;
}
static bool ibutton_protocol_group_dallas_get_id_by_name(
iButtonProtocolGroupDallas* group,
iButtonProtocolLocalId* id,
const char* name) {
UNUSED(group);
// Handle older key files which refer to DS1990 as just "Dallas"
if(strcmp(name, "Dallas") == 0) {
*id = iButtonProtocolDS1990;
return true;
}
for(iButtonProtocolLocalId i = 0; i < iButtonProtocolDSMax; ++i) {
if(strcmp(ibutton_protocols_dallas[i]->name, name) == 0) {
*id = i;
return true;
}
}
return false;
}
static uint32_t ibutton_protocol_group_dallas_get_features(
iButtonProtocolGroupDallas* group,
iButtonProtocolLocalId id) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
return ibutton_protocols_dallas[id]->features;
}
static const char* ibutton_protocol_group_dallas_get_manufacturer(
iButtonProtocolGroupDallas* group,
iButtonProtocolLocalId id) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
return ibutton_protocols_dallas[id]->manufacturer;
}
static const char* ibutton_protocol_group_dallas_get_name(
iButtonProtocolGroupDallas* group,
iButtonProtocolLocalId id) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
return ibutton_protocols_dallas[id]->name;
}
static iButtonProtocolLocalId
ibutton_protocol_group_dallas_get_id_by_family_code(uint8_t family_code) {
iButtonProtocolLocalId id;
for(id = 0; id < iButtonProtocolDSGeneric; ++id) {
if(ibutton_protocols_dallas[id]->family_code == family_code) break;
}
return id;
}
static bool ibutton_protocol_group_dallas_read(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId* id) {
bool success = false;
uint8_t rom_data[IBUTTON_ONEWIRE_ROM_SIZE];
OneWireHost* host = group->host;
onewire_host_start(host);
furi_delay_ms(100);
FURI_CRITICAL_ENTER();
if(onewire_host_search(host, rom_data, OneWireHostSearchModeNormal)) {
/* Considering any found 1-Wire device a success.
* It can be checked later with ibutton_key_is_valid(). */
success = true;
/* If a 1-Wire device was found, id is guaranteed to be
* one of the known keys or DSGeneric. */
*id = ibutton_protocol_group_dallas_get_id_by_family_code(rom_data[0]);
ibutton_protocols_dallas[*id]->read(host, data);
}
onewire_host_reset_search(host);
onewire_host_stop(host);
FURI_CRITICAL_EXIT();
return success;
}
static bool ibutton_protocol_group_dallas_write_blank(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
furi_assert(id < iButtonProtocolDSMax);
const iButtonProtocolDallasBase* protocol = ibutton_protocols_dallas[id];
furi_assert(protocol->features & iButtonProtocolFeatureWriteBlank);
OneWireHost* host = group->host;
onewire_host_start(host);
furi_delay_ms(100);
FURI_CRITICAL_ENTER();
const bool success = protocol->write_blank(host, data);
onewire_host_stop(host);
FURI_CRITICAL_EXIT();
return success;
}
static bool ibutton_protocol_group_dallas_write_copy(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
furi_assert(id < iButtonProtocolDSMax);
const iButtonProtocolDallasBase* protocol = ibutton_protocols_dallas[id];
furi_assert(protocol->features & iButtonProtocolFeatureWriteCopy);
OneWireHost* host = group->host;
onewire_host_start(host);
furi_delay_ms(100);
FURI_CRITICAL_ENTER();
const bool success = protocol->write_copy(host, data);
onewire_host_stop(host);
FURI_CRITICAL_EXIT();
return success;
}
static void ibutton_protocol_group_dallas_emulate_start(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
furi_assert(id < iButtonProtocolDSMax);
OneWireSlave* bus = group->bus;
ibutton_protocols_dallas[id]->emulate(bus, data);
onewire_slave_start(bus);
}
static void ibutton_protocol_group_dallas_emulate_stop(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
furi_assert(id < iButtonProtocolDSMax);
UNUSED(data);
onewire_slave_stop(group->bus);
}
static bool ibutton_protocol_group_dallas_save(
iButtonProtocolGroupDallas* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FlipperFormat* ff) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
return ibutton_protocols_dallas[id]->save(ff, data);
}
static bool ibutton_protocol_group_dallas_load(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id,
uint32_t version,
FlipperFormat* ff) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
return ibutton_protocols_dallas[id]->load(ff, version, data);
}
static void ibutton_protocol_group_dallas_render_data(
iButtonProtocolGroupDallas* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FuriString* result) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
const iButtonProtocolDallasBase* protocol = ibutton_protocols_dallas[id];
furi_assert(protocol->render_data);
protocol->render_data(result, data);
}
static void ibutton_protocol_group_dallas_render_brief_data(
iButtonProtocolGroupDallas* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FuriString* result) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
ibutton_protocols_dallas[id]->render_brief_data(result, data);
}
static void ibutton_protocol_group_dallas_render_error(
iButtonProtocolGroupDallas* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id,
FuriString* result) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
ibutton_protocols_dallas[id]->render_error(result, data);
}
static bool ibutton_protocol_group_dallas_is_valid(
iButtonProtocolGroupDallas* group,
const iButtonProtocolData* data,
iButtonProtocolLocalId id) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
return ibutton_protocols_dallas[id]->is_valid(data);
}
static void ibutton_protocol_group_dallas_get_editable_data(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id,
iButtonEditableData* editable) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
ibutton_protocols_dallas[id]->get_editable_data(editable, data);
}
static void ibutton_protocol_group_dallas_apply_edits(
iButtonProtocolGroupDallas* group,
iButtonProtocolData* data,
iButtonProtocolLocalId id) {
UNUSED(group);
furi_assert(id < iButtonProtocolDSMax);
ibutton_protocols_dallas[id]->apply_edits(data);
}
const iButtonProtocolGroupBase ibutton_protocol_group_dallas = {
.protocol_count = iButtonProtocolDSMax,
.alloc = (iButtonProtocolGroupAllocFunc)ibutton_protocol_group_dallas_alloc,
.free = (iButtonProtocolGroupFreeFunc)ibutton_protocol_group_dallas_free,
.get_max_data_size =
(iButtonProtocolGropuGetSizeFunc)ibutton_protocol_group_dallas_get_max_data_size,
.get_id_by_name = (iButtonProtocolGroupGetIdFunc)ibutton_protocol_group_dallas_get_id_by_name,
.get_features =
(iButtonProtocolGroupGetFeaturesFunc)ibutton_protocol_group_dallas_get_features,
.get_manufacturer =
(iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_dallas_get_manufacturer,
.get_name = (iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_dallas_get_name,
.read = (iButtonProtocolGroupReadFunc)ibutton_protocol_group_dallas_read,
.write_blank = (iButtonProtocolGroupWriteFunc)ibutton_protocol_group_dallas_write_blank,
.write_copy = (iButtonProtocolGroupWriteFunc)ibutton_protocol_group_dallas_write_copy,
.emulate_start = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_dallas_emulate_start,
.emulate_stop = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_dallas_emulate_stop,
.save = (iButtonProtocolGroupSaveFunc)ibutton_protocol_group_dallas_save,
.load = (iButtonProtocolGroupLoadFunc)ibutton_protocol_group_dallas_load,
.render_data = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_dallas_render_data,
.render_brief_data =
(iButtonProtocolGroupRenderFunc)ibutton_protocol_group_dallas_render_brief_data,
.render_error = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_dallas_render_error,
.is_valid = (iButtonProtocolGroupIsValidFunc)ibutton_protocol_group_dallas_is_valid,
.get_editable_data =
(iButtonProtocolGroupGetDataFunc)ibutton_protocol_group_dallas_get_editable_data,
.apply_edits = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_dallas_apply_edits,
};

5
lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.h Normal file
View File

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

16
lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.c Normal file
View File

@@ -0,0 +1,16 @@
#include "protocol_group_dallas_defs.h"
#include "protocol_ds1990.h"
#include "protocol_ds1992.h"
#include "protocol_ds1996.h"
#include "protocol_ds_generic.h"
const iButtonProtocolDallasBase* ibutton_protocols_dallas[] = {
[iButtonProtocolDS1990] = &ibutton_protocol_ds1990,
[iButtonProtocolDS1992] = &ibutton_protocol_ds1992,
[iButtonProtocolDS1996] = &ibutton_protocol_ds1996,
/* Add new 1-Wire protocols here */
/* Default catch-all 1-Wire protocol */
[iButtonProtocolDSGeneric] = &ibutton_protocol_ds_generic,
};

16
lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
#include "protocol_dallas_base.h"
typedef enum {
iButtonProtocolDS1990,
iButtonProtocolDS1992,
iButtonProtocolDS1996,
/* Add new 1-Wire protocols here */
/* Default catch-all 1-Wire protocol */
iButtonProtocolDSGeneric,
iButtonProtocolDSMax,
} iButtonProtocolDallas;
extern const iButtonProtocolDallasBase* ibutton_protocols_dallas[];

8
lib/one_wire/ibutton/protocols/ibutton_protocols.c
View File

@@ -1,8 +0,0 @@
#include "ibutton_protocols.h"
#include "protocol_cyfral.h"
#include "protocol_metakom.h"
const ProtocolBase* ibutton_protocols[] = {
[iButtonProtocolCyfral] = &protocol_cyfral,
[iButtonProtocolMetakom] = &protocol_metakom,
};

11
lib/one_wire/ibutton/protocols/ibutton_protocols.h
View File

@@ -1,11 +0,0 @@
#pragma once
#include "toolbox/protocols/protocol.h"
typedef enum {
iButtonProtocolCyfral,
iButtonProtocolMetakom,
iButtonProtocolMax,
} iButtonProtocol;
extern const ProtocolBase* ibutton_protocols[];

10
lib/one_wire/ibutton/protocols/protocol_cyfral.c → lib/one_wire/ibutton/protocols/misc/protocol_cyfral.c
View File

@@ -1,5 +1,6 @@
#include <furi.h>
#include <furi_hal.h>
#include "protocol_cyfral.h"
#define CYFRAL_DATA_SIZE sizeof(uint16_t)
@@ -324,7 +325,13 @@ static LevelDuration protocol_cyfral_encoder_yield(ProtocolCyfral* proto) {
return result;
}
const ProtocolBase protocol_cyfral = {
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,
@@ -341,4 +348,5 @@ const ProtocolBase protocol_cyfral = {
.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[];

10
lib/one_wire/ibutton/protocols/protocol_metakom.c → lib/one_wire/ibutton/protocols/misc/protocol_metakom.c
View File

@@ -1,5 +1,6 @@
#include <furi.h>
#include <furi_hal.h>
#include "protocol_metakom.h"
#define METAKOM_DATA_SIZE sizeof(uint32_t)
@@ -300,7 +301,13 @@ static LevelDuration protocol_metakom_encoder_yield(ProtocolMetakom* proto) {
return result;
}
const ProtocolBase protocol_metakom = {
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,
@@ -317,4 +324,5 @@ const ProtocolBase protocol_metakom = {
.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;

21
lib/one_wire/ibutton/protocols/protocol_common.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include <stdint.h>
#include <stddef.h>
typedef int32_t iButtonProtocolId;
enum {
iButtonProtocolIdInvalid = -1,
};
typedef enum {
iButtonProtocolFeatureExtData = (1U << 0),
iButtonProtocolFeatureWriteBlank = (1U << 1),
iButtonProtocolFeatureWriteCopy = (1U << 2),
} iButtonProtocolFeature;
typedef struct {
uint8_t* ptr;
size_t size;
} iButtonEditableData;

6
lib/one_wire/ibutton/protocols/protocol_common_i.h Normal file
View File

@@ -0,0 +1,6 @@
#pragma once
#include "protocol_common.h"
typedef void iButtonProtocolData;
typedef int32_t iButtonProtocolLocalId;

4
lib/one_wire/ibutton/protocols/protocol_cyfral.h
View File

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

104
lib/one_wire/ibutton/protocols/protocol_group_base.h Normal file
View File

@@ -0,0 +1,104 @@
#pragma once
#include <stdbool.h>
#include <flipper_format.h>
#include "protocol_common_i.h"
typedef void iButtonProtocolGroupData;
typedef int32_t iButtonProtocolGroupId;
typedef iButtonProtocolGroupData* (*iButtonProtocolGroupAllocFunc)(void);
typedef void (*iButtonProtocolGroupFreeFunc)(iButtonProtocolGroupData*);
typedef void (*iButtonProtocolGroupRenderFunc)(
iButtonProtocolGroupData*,
const iButtonProtocolData*,
iButtonProtocolLocalId,
FuriString*);
typedef bool (*iButtonProtocolGroupIsValidFunc)(
iButtonProtocolGroupData*,
const iButtonProtocolData*,
iButtonProtocolLocalId);
typedef void (*iButtonProtocolGroupGetDataFunc)(
iButtonProtocolGroupData*,
iButtonProtocolData*,
iButtonProtocolLocalId,
iButtonEditableData*);
typedef void (*iButtonProtocolGroupApplyFunc)(
iButtonProtocolGroupData*,
iButtonProtocolData*,
iButtonProtocolLocalId);
typedef size_t (*iButtonProtocolGropuGetSizeFunc)(iButtonProtocolGroupData*);
typedef uint32_t (
*iButtonProtocolGroupGetFeaturesFunc)(iButtonProtocolGroupData*, iButtonProtocolLocalId);
typedef const char* (
*iButtonProtocolGroupGetStringFunc)(iButtonProtocolGroupData*, iButtonProtocolLocalId);
typedef bool (*iButtonProtocolGroupGetIdFunc)(
iButtonProtocolGroupData*,
iButtonProtocolLocalId*,
const char*);
typedef bool (*iButtonProtocolGroupReadFunc)(
iButtonProtocolGroupData*,
iButtonProtocolData*,
iButtonProtocolLocalId*);
typedef bool (*iButtonProtocolGroupWriteFunc)(
iButtonProtocolGroupData*,
iButtonProtocolData*,
iButtonProtocolLocalId);
typedef bool (*iButtonProtocolGroupSaveFunc)(
iButtonProtocolGroupData*,
const iButtonProtocolData*,
iButtonProtocolLocalId,
FlipperFormat*);
typedef bool (*iButtonProtocolGroupLoadFunc)(
iButtonProtocolGroupData*,
iButtonProtocolData*,
iButtonProtocolLocalId,
uint32_t,
FlipperFormat*);
typedef struct {
const uint32_t protocol_count;
iButtonProtocolGroupAllocFunc alloc;
iButtonProtocolGroupFreeFunc free;
iButtonProtocolGropuGetSizeFunc get_max_data_size;
iButtonProtocolGroupGetIdFunc get_id_by_name;
iButtonProtocolGroupGetFeaturesFunc get_features;
iButtonProtocolGroupGetStringFunc get_manufacturer;
iButtonProtocolGroupGetStringFunc get_name;
iButtonProtocolGroupReadFunc read;
iButtonProtocolGroupWriteFunc write_blank;
iButtonProtocolGroupWriteFunc write_copy;
iButtonProtocolGroupApplyFunc emulate_start;
iButtonProtocolGroupApplyFunc emulate_stop;
iButtonProtocolGroupSaveFunc save;
iButtonProtocolGroupLoadFunc load;
iButtonProtocolGroupRenderFunc render_data;
iButtonProtocolGroupRenderFunc render_brief_data;
iButtonProtocolGroupRenderFunc render_error;
iButtonProtocolGroupIsValidFunc is_valid;
iButtonProtocolGroupGetDataFunc get_editable_data;
iButtonProtocolGroupApplyFunc apply_edits;
} iButtonProtocolGroupBase;

9
lib/one_wire/ibutton/protocols/protocol_group_defs.c Normal file
View File

@@ -0,0 +1,9 @@
#include "protocol_group_defs.h"
#include "dallas/protocol_group_dallas.h"
#include "misc/protocol_group_misc.h"
const iButtonProtocolGroupBase* ibutton_protocol_groups[] = {
[iButtonProtocolGroupDallas] = &ibutton_protocol_group_dallas,
[iButtonProtocolGroupMisc] = &ibutton_protocol_group_misc,
};

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

@@ -0,0 +1,11 @@
#pragma once
#include "protocol_group_base.h"
typedef enum {
iButtonProtocolGroupDallas,
iButtonProtocolGroupMisc,
iButtonProtocolGroupMax
} iButtonProtocolGroup;
extern const iButtonProtocolGroupBase* ibutton_protocol_groups[];

4
lib/one_wire/ibutton/protocols/protocol_metakom.h
View File

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