[FL-3168] Add one_wire lib to f18, separate ibutton (#2509)
* Separate ibutton to its own module, add one_wire to f18 * Move onewire cli to a separate app Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
This commit is contained in:
Georgii Surkov
GitHub
@@ -11,9 +11,6 @@ env.Append(
|
||||
File("one_wire_host_timing.h"),
|
||||
File("one_wire_host.h"),
|
||||
File("one_wire_slave.h"),
|
||||
File("ibutton/ibutton_key.h"),
|
||||
File("ibutton/ibutton_worker.h"),
|
||||
File("ibutton/ibutton_protocols.h"),
|
||||
File("maxim_crc.h"),
|
||||
],
|
||||
)
|
||||
|
||||
@@ -1,43 +0,0 @@
|
||||
#include "ibutton_key_i.h"
|
||||
|
||||
struct iButtonKey {
|
||||
iButtonProtocolId protocol_id;
|
||||
iButtonProtocolData* protocol_data;
|
||||
size_t protocol_data_size;
|
||||
};
|
||||
|
||||
iButtonKey* ibutton_key_alloc(size_t data_size) {
|
||||
iButtonKey* key = malloc(sizeof(iButtonKey));
|
||||
|
||||
key->protocol_id = iButtonProtocolIdInvalid;
|
||||
key->protocol_data = malloc(data_size);
|
||||
key->protocol_data_size = data_size;
|
||||
|
||||
return key;
|
||||
}
|
||||
|
||||
void ibutton_key_free(iButtonKey* key) {
|
||||
free(key->protocol_data);
|
||||
free(key);
|
||||
}
|
||||
|
||||
void ibutton_key_reset(iButtonKey* key) {
|
||||
key->protocol_id = iButtonProtocolIdInvalid;
|
||||
memset(key->protocol_data, 0, key->protocol_data_size);
|
||||
}
|
||||
|
||||
iButtonProtocolId ibutton_key_get_protocol_id(const iButtonKey* key) {
|
||||
return key->protocol_id;
|
||||
}
|
||||
|
||||
void ibutton_key_set_protocol_id(iButtonKey* key, iButtonProtocolId protocol_id) {
|
||||
key->protocol_id = protocol_id;
|
||||
}
|
||||
|
||||
iButtonProtocolData* ibutton_key_get_protocol_data(const iButtonKey* key) {
|
||||
return key->protocol_data;
|
||||
}
|
||||
|
||||
size_t ibutton_key_get_protocol_data_size(const iButtonKey* key) {
|
||||
return key->protocol_data_size;
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
/**
|
||||
* @file ibutton_key.h
|
||||
*
|
||||
* iButton key data holder
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <core/string.h>
|
||||
|
||||
#include "protocols/protocol_common.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct iButtonKey iButtonKey;
|
||||
|
||||
/**
|
||||
* Allocate a key object
|
||||
* @param [in] data_size maximum data size held by the key
|
||||
* @return pointer to the key object
|
||||
*/
|
||||
iButtonKey* ibutton_key_alloc(size_t data_size);
|
||||
|
||||
/**
|
||||
* Destroy the key object, free resources
|
||||
* @param [in] key pointer to the key object
|
||||
*/
|
||||
void ibutton_key_free(iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Get the protocol id held by the key
|
||||
* @param [in] key pointer to the key object
|
||||
* @return protocol id held by the key
|
||||
*/
|
||||
iButtonProtocolId ibutton_key_get_protocol_id(const iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Set the protocol id held by the key
|
||||
* @param [in] key pointer to the key object
|
||||
* @param [in] protocol_id new protocol id
|
||||
*/
|
||||
void ibutton_key_set_protocol_id(iButtonKey* key, iButtonProtocolId protocol_id);
|
||||
|
||||
/**
|
||||
* Reset the protocol id and data held by the key
|
||||
* @param [in] key pointer to the key object
|
||||
*/
|
||||
void ibutton_key_reset(iButtonKey* key);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,9 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "ibutton_key.h"
|
||||
|
||||
#include "protocols/protocol_common_i.h"
|
||||
|
||||
iButtonProtocolData* ibutton_key_get_protocol_data(const iButtonKey* key);
|
||||
|
||||
size_t ibutton_key_get_protocol_data_size(const iButtonKey* key);
|
||||
@@ -1,309 +0,0 @@
|
||||
#include "ibutton_protocols.h"
|
||||
|
||||
#include <storage/storage.h>
|
||||
|
||||
#include "ibutton_key_i.h"
|
||||
|
||||
#include "protocols/protocol_group_defs.h"
|
||||
|
||||
#define IBUTTON_FILE_TYPE "Flipper iButton key"
|
||||
|
||||
#define IBUTTON_PROTOCOL_KEY_V1 "Key type"
|
||||
#define IBUTTON_PROTOCOL_KEY_V2 "Protocol"
|
||||
|
||||
#define IBUTTON_CURRENT_FORMAT_VERSION 2U
|
||||
|
||||
#define GET_PROTOCOL_GROUP(id) \
|
||||
iButtonProtocolGroupInfo info; \
|
||||
ibutton_protocols_get_group_by_id(protocols, (id), &info);
|
||||
|
||||
#define GROUP_BASE (info.base)
|
||||
#define GROUP_DATA (info.group)
|
||||
#define PROTOCOL_ID (info.id)
|
||||
|
||||
struct iButtonProtocols {
|
||||
iButtonProtocolGroupData** group_datas;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
const iButtonProtocolGroupBase* base;
|
||||
iButtonProtocolGroupData* group;
|
||||
iButtonProtocolLocalId id;
|
||||
} iButtonProtocolGroupInfo;
|
||||
|
||||
static void ibutton_protocols_get_group_by_id(
|
||||
iButtonProtocols* protocols,
|
||||
iButtonProtocolId id,
|
||||
iButtonProtocolGroupInfo* info) {
|
||||
iButtonProtocolLocalId local_id = id;
|
||||
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
if(local_id < (signed)ibutton_protocol_groups[i]->protocol_count) {
|
||||
info->base = ibutton_protocol_groups[i];
|
||||
info->group = protocols->group_datas[i];
|
||||
info->id = local_id;
|
||||
return;
|
||||
|
||||
} else {
|
||||
local_id -= ibutton_protocol_groups[i]->protocol_count;
|
||||
}
|
||||
}
|
||||
furi_crash(NULL);
|
||||
}
|
||||
|
||||
iButtonProtocols* ibutton_protocols_alloc() {
|
||||
iButtonProtocols* protocols = malloc(sizeof(iButtonProtocols*));
|
||||
|
||||
protocols->group_datas = malloc(sizeof(iButtonProtocolGroupData*) * iButtonProtocolGroupMax);
|
||||
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
protocols->group_datas[i] = ibutton_protocol_groups[i]->alloc();
|
||||
}
|
||||
|
||||
return protocols;
|
||||
}
|
||||
|
||||
void ibutton_protocols_free(iButtonProtocols* protocols) {
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
ibutton_protocol_groups[i]->free(protocols->group_datas[i]);
|
||||
}
|
||||
|
||||
free(protocols->group_datas);
|
||||
free(protocols);
|
||||
}
|
||||
|
||||
uint32_t ibutton_protocols_get_protocol_count() {
|
||||
uint32_t count = 0;
|
||||
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
count += ibutton_protocol_groups[i]->protocol_count;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
iButtonProtocolId ibutton_protocols_get_id_by_name(iButtonProtocols* protocols, const char* name) {
|
||||
iButtonProtocolLocalId offset = 0;
|
||||
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
iButtonProtocolLocalId local_id;
|
||||
if(ibutton_protocol_groups[i]->get_id_by_name(protocols->group_datas[i], &local_id, name)) {
|
||||
return local_id + offset;
|
||||
}
|
||||
offset += ibutton_protocol_groups[i]->protocol_count;
|
||||
}
|
||||
return iButtonProtocolIdInvalid;
|
||||
}
|
||||
|
||||
uint32_t ibutton_protocols_get_features(iButtonProtocols* protocols, iButtonProtocolId id) {
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
return GROUP_BASE->get_features(GROUP_DATA, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
size_t ibutton_protocols_get_max_data_size(iButtonProtocols* protocols) {
|
||||
size_t max_size = 0;
|
||||
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
const size_t current_max_size =
|
||||
ibutton_protocol_groups[i]->get_max_data_size(protocols->group_datas[i]);
|
||||
if(current_max_size > max_size) {
|
||||
max_size = current_max_size;
|
||||
}
|
||||
}
|
||||
|
||||
return max_size;
|
||||
}
|
||||
|
||||
const char* ibutton_protocols_get_manufacturer(iButtonProtocols* protocols, iButtonProtocolId id) {
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
return GROUP_BASE->get_manufacturer(GROUP_DATA, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
const char* ibutton_protocols_get_name(iButtonProtocols* protocols, iButtonProtocolId id) {
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
return GROUP_BASE->get_name(GROUP_DATA, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
bool ibutton_protocols_read(iButtonProtocols* protocols, iButtonKey* key) {
|
||||
iButtonProtocolLocalId id = iButtonProtocolIdInvalid;
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
iButtonProtocolLocalId offset = 0;
|
||||
for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
|
||||
if(ibutton_protocol_groups[i]->read(protocols->group_datas[i], data, &id)) {
|
||||
id += offset;
|
||||
break;
|
||||
}
|
||||
offset += ibutton_protocol_groups[i]->protocol_count;
|
||||
}
|
||||
|
||||
ibutton_key_set_protocol_id(key, id);
|
||||
return id != iButtonProtocolIdInvalid;
|
||||
}
|
||||
|
||||
bool ibutton_protocols_write_blank(iButtonProtocols* protocols, iButtonKey* key) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
return GROUP_BASE->write_blank(GROUP_DATA, data, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
bool ibutton_protocols_write_copy(iButtonProtocols* protocols, iButtonKey* key) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
return GROUP_BASE->write_copy(GROUP_DATA, data, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
void ibutton_protocols_emulate_start(iButtonProtocols* protocols, iButtonKey* key) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->emulate_start(GROUP_DATA, data, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
void ibutton_protocols_emulate_stop(iButtonProtocols* protocols, iButtonKey* key) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->emulate_stop(GROUP_DATA, data, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
bool ibutton_protocols_save(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
const char* file_name) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
bool success = false;
|
||||
Storage* storage = furi_record_open(RECORD_STORAGE);
|
||||
|
||||
FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
|
||||
|
||||
do {
|
||||
const char* protocol_name = ibutton_protocols_get_name(protocols, id);
|
||||
|
||||
if(!flipper_format_buffered_file_open_always(ff, file_name)) break;
|
||||
|
||||
if(!flipper_format_write_header_cstr(ff, IBUTTON_FILE_TYPE, IBUTTON_CURRENT_FORMAT_VERSION))
|
||||
break;
|
||||
if(!flipper_format_write_string_cstr(ff, IBUTTON_PROTOCOL_KEY_V2, protocol_name)) break;
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
if(!GROUP_BASE->save(GROUP_DATA, data, PROTOCOL_ID, ff)) break;
|
||||
|
||||
success = true;
|
||||
} while(false);
|
||||
|
||||
flipper_format_free(ff);
|
||||
furi_record_close(RECORD_STORAGE);
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
bool ibutton_protocols_load(iButtonProtocols* protocols, iButtonKey* key, const char* file_name) {
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
bool success = false;
|
||||
Storage* storage = furi_record_open(RECORD_STORAGE);
|
||||
|
||||
FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
|
||||
FuriString* tmp = furi_string_alloc();
|
||||
|
||||
do {
|
||||
if(!flipper_format_buffered_file_open_existing(ff, file_name)) break;
|
||||
|
||||
uint32_t version;
|
||||
|
||||
if(!flipper_format_read_header(ff, tmp, &version)) break;
|
||||
if(!furi_string_equal(tmp, IBUTTON_FILE_TYPE)) break;
|
||||
|
||||
if(version == 1) {
|
||||
if(!flipper_format_read_string(ff, IBUTTON_PROTOCOL_KEY_V1, tmp)) break;
|
||||
} else if(version == 2) {
|
||||
if(!flipper_format_read_string(ff, IBUTTON_PROTOCOL_KEY_V2, tmp)) break;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
|
||||
const iButtonProtocolId id =
|
||||
ibutton_protocols_get_id_by_name(protocols, furi_string_get_cstr(tmp));
|
||||
ibutton_key_set_protocol_id(key, id);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
if(!GROUP_BASE->load(GROUP_DATA, data, PROTOCOL_ID, version, ff)) break;
|
||||
|
||||
success = true;
|
||||
} while(false);
|
||||
|
||||
flipper_format_free(ff);
|
||||
furi_string_free(tmp);
|
||||
furi_record_close(RECORD_STORAGE);
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
void ibutton_protocols_render_data(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
FuriString* result) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->render_data(GROUP_DATA, data, PROTOCOL_ID, result);
|
||||
}
|
||||
|
||||
void ibutton_protocols_render_brief_data(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
FuriString* result) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->render_brief_data(GROUP_DATA, data, PROTOCOL_ID, result);
|
||||
}
|
||||
|
||||
void ibutton_protocols_render_error(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
FuriString* result) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->render_error(GROUP_DATA, data, PROTOCOL_ID, result);
|
||||
}
|
||||
|
||||
bool ibutton_protocols_is_valid(iButtonProtocols* protocols, const iButtonKey* key) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
return GROUP_BASE->is_valid(GROUP_DATA, data, PROTOCOL_ID);
|
||||
}
|
||||
|
||||
void ibutton_protocols_get_editable_data(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
iButtonEditableData* editable) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->get_editable_data(GROUP_DATA, data, PROTOCOL_ID, editable);
|
||||
}
|
||||
|
||||
void ibutton_protocols_apply_edits(iButtonProtocols* protocols, const iButtonKey* key) {
|
||||
const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
|
||||
iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
|
||||
|
||||
GET_PROTOCOL_GROUP(id);
|
||||
GROUP_BASE->apply_edits(GROUP_DATA, data, PROTOCOL_ID);
|
||||
}
|
||||
@@ -1,197 +0,0 @@
|
||||
/**
|
||||
* @file ibutton_protocols.h
|
||||
*
|
||||
* Common interface for accessing various iButton protocols
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include "protocols/protocol_common.h"
|
||||
|
||||
#include "ibutton_key.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct iButtonProtocols iButtonProtocols;
|
||||
|
||||
/**
|
||||
* Allocate an iButtonProtocols object
|
||||
* @return pointer to an iButtonProtocols object
|
||||
*/
|
||||
iButtonProtocols* ibutton_protocols_alloc();
|
||||
|
||||
/**
|
||||
* Destroy an iButtonProtocols object, free resources
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
*/
|
||||
void ibutton_protocols_free(iButtonProtocols* protocols);
|
||||
|
||||
/**
|
||||
* Get the total number of available protocols
|
||||
*/
|
||||
uint32_t ibutton_protocols_get_protocol_count();
|
||||
|
||||
/**
|
||||
* Get maximum data size out of all protocols available
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @return maximum data size in bytes
|
||||
*/
|
||||
size_t ibutton_protocols_get_max_data_size(iButtonProtocols* protocols);
|
||||
|
||||
/**
|
||||
* Get the protocol id based on its name
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] name pointer to a string containing the name
|
||||
* @return protocol id on success on iButtonProtocolIdInvalid on failure
|
||||
*/
|
||||
iButtonProtocolId ibutton_protocols_get_id_by_name(iButtonProtocols* protocols, const char* name);
|
||||
|
||||
/**
|
||||
* Get the manufacturer name based on the protocol id
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] id id of the protocol in question
|
||||
* @return pointer to a statically allocated string with manufacturer name
|
||||
*/
|
||||
const char* ibutton_protocols_get_manufacturer(iButtonProtocols* protocols, iButtonProtocolId id);
|
||||
|
||||
/**
|
||||
* Get the protocol name based on the protocol id
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] id id of the protocol in question
|
||||
* @return pointer to a statically allocated string with protocol name
|
||||
*/
|
||||
const char* ibutton_protocols_get_name(iButtonProtocols* protocols, iButtonProtocolId id);
|
||||
|
||||
/**
|
||||
* Get protocol features bitmask by protocol id
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] id id of the protocol in question
|
||||
*/
|
||||
uint32_t ibutton_protocols_get_features(iButtonProtocols* protocols, iButtonProtocolId id);
|
||||
|
||||
/**
|
||||
* Read a physical device (a key or an emulator)
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [out] key pointer to the key to read into (must be allocated before)
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool ibutton_protocols_read(iButtonProtocols* protocols, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Write the key to a blank
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be written
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool ibutton_protocols_write_blank(iButtonProtocols* protocols, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Write the key to another one of the same type
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be written
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool ibutton_protocols_write_copy(iButtonProtocols* protocols, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Start emulating the key
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be emulated
|
||||
*/
|
||||
void ibutton_protocols_emulate_start(iButtonProtocols* protocols, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Stop emulating the key
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be emulated
|
||||
*/
|
||||
void ibutton_protocols_emulate_stop(iButtonProtocols* protocols, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Save the key data to a file.
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be saved
|
||||
* @param [in] file_name full absolute path to the file name
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool ibutton_protocols_save(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
const char* file_name);
|
||||
|
||||
/**
|
||||
* Load the key from a file.
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [out] key pointer to the key to load into (must be allocated before)
|
||||
* @param [in] file_name full absolute path to the file name
|
||||
* @return true on success, false on failure
|
||||
*/
|
||||
bool ibutton_protocols_load(iButtonProtocols* protocols, iButtonKey* key, const char* file_name);
|
||||
|
||||
/**
|
||||
* Format a string containing device full data
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be rendered
|
||||
* @param [out] result pointer to the FuriString instance (must be initialized)
|
||||
*/
|
||||
void ibutton_protocols_render_data(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
FuriString* result);
|
||||
|
||||
/**
|
||||
* Format a string containing device brief data
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be rendered
|
||||
* @param [out] result pointer to the FuriString instance (must be initialized)
|
||||
*/
|
||||
void ibutton_protocols_render_brief_data(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
FuriString* result);
|
||||
|
||||
/**
|
||||
* Format a string containing error message (for invalid keys)
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be rendered
|
||||
* @param [out] result pointer to the FuriString instance (must be initialized)
|
||||
*/
|
||||
void ibutton_protocols_render_error(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
FuriString* result);
|
||||
|
||||
/**
|
||||
* Check whether the key data is valid
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be checked
|
||||
* @return true if data is valid, false otherwise
|
||||
*/
|
||||
bool ibutton_protocols_is_valid(iButtonProtocols* protocols, const iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Get a pointer to the key's editable data (for in-place editing)
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in] key pointer to the key to be checked
|
||||
* @param [out] editable pointer to a structure to contain the editable data
|
||||
*/
|
||||
void ibutton_protocols_get_editable_data(
|
||||
iButtonProtocols* protocols,
|
||||
const iButtonKey* key,
|
||||
iButtonEditableData* editable);
|
||||
|
||||
/**
|
||||
* Make all necessary internal adjustments after editing the key
|
||||
* @param [in] protocols pointer to an iButtonProtocols object
|
||||
* @param [in,out] key pointer to the key to be adjusted
|
||||
*/
|
||||
void ibutton_protocols_apply_edits(iButtonProtocols* protocols, const iButtonKey* key);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,182 +0,0 @@
|
||||
#include "ibutton_worker_i.h"
|
||||
#include "ibutton_protocols.h"
|
||||
|
||||
#include <core/check.h>
|
||||
|
||||
typedef enum {
|
||||
iButtonMessageEnd,
|
||||
iButtonMessageStop,
|
||||
iButtonMessageRead,
|
||||
iButtonMessageWriteBlank,
|
||||
iButtonMessageWriteCopy,
|
||||
iButtonMessageEmulate,
|
||||
iButtonMessageNotifyEmulate,
|
||||
} iButtonMessageType;
|
||||
|
||||
typedef struct {
|
||||
iButtonMessageType type;
|
||||
union {
|
||||
iButtonKey* key;
|
||||
} data;
|
||||
} iButtonMessage;
|
||||
|
||||
static int32_t ibutton_worker_thread(void* thread_context);
|
||||
|
||||
iButtonWorker* ibutton_worker_alloc(iButtonProtocols* protocols) {
|
||||
iButtonWorker* worker = malloc(sizeof(iButtonWorker));
|
||||
|
||||
worker->protocols = protocols;
|
||||
worker->messages = furi_message_queue_alloc(1, sizeof(iButtonMessage));
|
||||
|
||||
worker->mode_index = iButtonWorkerModeIdle;
|
||||
worker->thread = furi_thread_alloc_ex("iButtonWorker", 2048, ibutton_worker_thread, worker);
|
||||
|
||||
return worker;
|
||||
}
|
||||
|
||||
void ibutton_worker_read_set_callback(
|
||||
iButtonWorker* worker,
|
||||
iButtonWorkerReadCallback callback,
|
||||
void* context) {
|
||||
furi_check(worker->mode_index == iButtonWorkerModeIdle);
|
||||
worker->read_cb = callback;
|
||||
worker->cb_ctx = context;
|
||||
}
|
||||
|
||||
void ibutton_worker_write_set_callback(
|
||||
iButtonWorker* worker,
|
||||
iButtonWorkerWriteCallback callback,
|
||||
void* context) {
|
||||
furi_check(worker->mode_index == iButtonWorkerModeIdle);
|
||||
worker->write_cb = callback;
|
||||
worker->cb_ctx = context;
|
||||
}
|
||||
|
||||
void ibutton_worker_emulate_set_callback(
|
||||
iButtonWorker* worker,
|
||||
iButtonWorkerEmulateCallback callback,
|
||||
void* context) {
|
||||
furi_check(worker->mode_index == iButtonWorkerModeIdle);
|
||||
worker->emulate_cb = callback;
|
||||
worker->cb_ctx = context;
|
||||
}
|
||||
|
||||
void ibutton_worker_read_start(iButtonWorker* worker, iButtonKey* key) {
|
||||
iButtonMessage message = {.type = iButtonMessageRead, .data.key = key};
|
||||
furi_check(
|
||||
furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
|
||||
}
|
||||
|
||||
void ibutton_worker_write_blank_start(iButtonWorker* worker, iButtonKey* key) {
|
||||
iButtonMessage message = {.type = iButtonMessageWriteBlank, .data.key = key};
|
||||
furi_check(
|
||||
furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
|
||||
}
|
||||
|
||||
void ibutton_worker_write_copy_start(iButtonWorker* worker, iButtonKey* key) {
|
||||
iButtonMessage message = {.type = iButtonMessageWriteCopy, .data.key = key};
|
||||
furi_check(
|
||||
furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
|
||||
}
|
||||
|
||||
void ibutton_worker_emulate_start(iButtonWorker* worker, iButtonKey* key) {
|
||||
iButtonMessage message = {.type = iButtonMessageEmulate, .data.key = key};
|
||||
furi_check(
|
||||
furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
|
||||
}
|
||||
|
||||
void ibutton_worker_stop(iButtonWorker* worker) {
|
||||
iButtonMessage message = {.type = iButtonMessageStop};
|
||||
furi_check(
|
||||
furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
|
||||
}
|
||||
|
||||
void ibutton_worker_free(iButtonWorker* worker) {
|
||||
furi_message_queue_free(worker->messages);
|
||||
furi_thread_free(worker->thread);
|
||||
free(worker);
|
||||
}
|
||||
|
||||
void ibutton_worker_start_thread(iButtonWorker* worker) {
|
||||
furi_thread_start(worker->thread);
|
||||
}
|
||||
|
||||
void ibutton_worker_stop_thread(iButtonWorker* worker) {
|
||||
iButtonMessage message = {.type = iButtonMessageEnd};
|
||||
furi_check(
|
||||
furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
|
||||
furi_thread_join(worker->thread);
|
||||
}
|
||||
|
||||
void ibutton_worker_switch_mode(iButtonWorker* worker, iButtonWorkerMode mode) {
|
||||
ibutton_worker_modes[worker->mode_index].stop(worker);
|
||||
worker->mode_index = mode;
|
||||
ibutton_worker_modes[worker->mode_index].start(worker);
|
||||
}
|
||||
|
||||
void ibutton_worker_notify_emulate(iButtonWorker* worker) {
|
||||
iButtonMessage message = {.type = iButtonMessageNotifyEmulate};
|
||||
// we're running in an interrupt context, so we can't wait
|
||||
// and we can drop message if queue is full, that's ok for that message
|
||||
furi_message_queue_put(worker->messages, &message, 0);
|
||||
}
|
||||
|
||||
void ibutton_worker_set_key_p(iButtonWorker* worker, iButtonKey* key) {
|
||||
worker->key = key;
|
||||
}
|
||||
|
||||
static int32_t ibutton_worker_thread(void* thread_context) {
|
||||
iButtonWorker* worker = thread_context;
|
||||
bool running = true;
|
||||
iButtonMessage message;
|
||||
FuriStatus status;
|
||||
|
||||
ibutton_worker_modes[worker->mode_index].start(worker);
|
||||
|
||||
while(running) {
|
||||
status = furi_message_queue_get(
|
||||
worker->messages, &message, ibutton_worker_modes[worker->mode_index].quant);
|
||||
if(status == FuriStatusOk) {
|
||||
switch(message.type) {
|
||||
case iButtonMessageEnd:
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeIdle);
|
||||
ibutton_worker_set_key_p(worker, NULL);
|
||||
running = false;
|
||||
break;
|
||||
case iButtonMessageStop:
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeIdle);
|
||||
ibutton_worker_set_key_p(worker, NULL);
|
||||
break;
|
||||
case iButtonMessageRead:
|
||||
ibutton_worker_set_key_p(worker, message.data.key);
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeRead);
|
||||
break;
|
||||
case iButtonMessageWriteBlank:
|
||||
ibutton_worker_set_key_p(worker, message.data.key);
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeWriteBlank);
|
||||
break;
|
||||
case iButtonMessageWriteCopy:
|
||||
ibutton_worker_set_key_p(worker, message.data.key);
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeWriteCopy);
|
||||
break;
|
||||
case iButtonMessageEmulate:
|
||||
ibutton_worker_set_key_p(worker, message.data.key);
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeEmulate);
|
||||
break;
|
||||
case iButtonMessageNotifyEmulate:
|
||||
if(worker->emulate_cb) {
|
||||
worker->emulate_cb(worker->cb_ctx, true);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else if(status == FuriStatusErrorTimeout) {
|
||||
ibutton_worker_modes[worker->mode_index].tick(worker);
|
||||
} else {
|
||||
furi_crash("iButton worker error");
|
||||
}
|
||||
}
|
||||
|
||||
ibutton_worker_modes[worker->mode_index].stop(worker);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
/**
|
||||
* @file ibutton_worker.h
|
||||
*
|
||||
* iButton worker
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ibutton_key.h"
|
||||
#include "ibutton_protocols.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
iButtonWorkerWriteOK,
|
||||
iButtonWorkerWriteSameKey,
|
||||
iButtonWorkerWriteNoDetect,
|
||||
iButtonWorkerWriteCannotWrite,
|
||||
} iButtonWorkerWriteResult;
|
||||
|
||||
typedef void (*iButtonWorkerReadCallback)(void* context);
|
||||
typedef void (*iButtonWorkerWriteCallback)(void* context, iButtonWorkerWriteResult result);
|
||||
typedef void (*iButtonWorkerEmulateCallback)(void* context, bool emulated);
|
||||
|
||||
typedef struct iButtonWorker iButtonWorker;
|
||||
|
||||
/**
|
||||
* Allocate ibutton worker
|
||||
* @return iButtonWorker*
|
||||
*/
|
||||
iButtonWorker* ibutton_worker_alloc(iButtonProtocols* protocols);
|
||||
|
||||
/**
|
||||
* Free ibutton worker
|
||||
* @param worker
|
||||
*/
|
||||
void ibutton_worker_free(iButtonWorker* worker);
|
||||
|
||||
/**
|
||||
* Start ibutton worker thread
|
||||
* @param worker
|
||||
*/
|
||||
void ibutton_worker_start_thread(iButtonWorker* worker);
|
||||
|
||||
/**
|
||||
* Stop ibutton worker thread
|
||||
* @param worker
|
||||
*/
|
||||
void ibutton_worker_stop_thread(iButtonWorker* worker);
|
||||
|
||||
/**
|
||||
* Set "read success" callback
|
||||
* @param worker
|
||||
* @param callback
|
||||
* @param context
|
||||
*/
|
||||
void ibutton_worker_read_set_callback(
|
||||
iButtonWorker* worker,
|
||||
iButtonWorkerReadCallback callback,
|
||||
void* context);
|
||||
|
||||
/**
|
||||
* Start read mode
|
||||
* @param worker
|
||||
* @param key
|
||||
*/
|
||||
void ibutton_worker_read_start(iButtonWorker* worker, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Set "write event" callback
|
||||
* @param worker
|
||||
* @param callback
|
||||
* @param context
|
||||
*/
|
||||
void ibutton_worker_write_set_callback(
|
||||
iButtonWorker* worker,
|
||||
iButtonWorkerWriteCallback callback,
|
||||
void* context);
|
||||
|
||||
/**
|
||||
* Start write blank mode
|
||||
* @param worker
|
||||
* @param key
|
||||
*/
|
||||
void ibutton_worker_write_blank_start(iButtonWorker* worker, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Start write copy mode
|
||||
* @param worker
|
||||
* @param key
|
||||
*/
|
||||
void ibutton_worker_write_copy_start(iButtonWorker* worker, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Set "emulate success" callback
|
||||
* @param worker
|
||||
* @param callback
|
||||
* @param context
|
||||
*/
|
||||
void ibutton_worker_emulate_set_callback(
|
||||
iButtonWorker* worker,
|
||||
iButtonWorkerEmulateCallback callback,
|
||||
void* context);
|
||||
|
||||
/**
|
||||
* Start emulate mode
|
||||
* @param worker
|
||||
* @param key
|
||||
*/
|
||||
void ibutton_worker_emulate_start(iButtonWorker* worker, iButtonKey* key);
|
||||
|
||||
/**
|
||||
* Stop all modes
|
||||
* @param worker
|
||||
*/
|
||||
void ibutton_worker_stop(iButtonWorker* worker);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,54 +0,0 @@
|
||||
/**
|
||||
* @file ibutton_worker_i.h
|
||||
*
|
||||
* iButton worker, internal definitions
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <core/thread.h>
|
||||
#include <core/message_queue.h>
|
||||
|
||||
#include "ibutton_worker.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
const uint32_t quant;
|
||||
void (*const start)(iButtonWorker* worker);
|
||||
void (*const tick)(iButtonWorker* worker);
|
||||
void (*const stop)(iButtonWorker* worker);
|
||||
} iButtonWorkerModeType;
|
||||
|
||||
typedef enum {
|
||||
iButtonWorkerModeIdle,
|
||||
iButtonWorkerModeRead,
|
||||
iButtonWorkerModeWriteBlank,
|
||||
iButtonWorkerModeWriteCopy,
|
||||
iButtonWorkerModeEmulate,
|
||||
} iButtonWorkerMode;
|
||||
|
||||
struct iButtonWorker {
|
||||
iButtonKey* key;
|
||||
iButtonProtocols* protocols;
|
||||
iButtonWorkerMode mode_index;
|
||||
FuriMessageQueue* messages;
|
||||
FuriThread* thread;
|
||||
|
||||
iButtonWorkerReadCallback read_cb;
|
||||
iButtonWorkerWriteCallback write_cb;
|
||||
iButtonWorkerEmulateCallback emulate_cb;
|
||||
|
||||
void* cb_ctx;
|
||||
};
|
||||
|
||||
extern const iButtonWorkerModeType ibutton_worker_modes[];
|
||||
|
||||
void ibutton_worker_switch_mode(iButtonWorker* worker, iButtonWorkerMode mode);
|
||||
void ibutton_worker_notify_emulate(iButtonWorker* worker);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,153 +0,0 @@
|
||||
#include "ibutton_worker_i.h"
|
||||
|
||||
#include <core/check.h>
|
||||
|
||||
#include <furi_hal_rfid.h>
|
||||
#include <furi_hal_power.h>
|
||||
|
||||
#include "ibutton_protocols.h"
|
||||
|
||||
static void ibutton_worker_mode_idle_start(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_idle_tick(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_idle_stop(iButtonWorker* worker);
|
||||
|
||||
static void ibutton_worker_mode_emulate_start(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_emulate_tick(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_emulate_stop(iButtonWorker* worker);
|
||||
|
||||
static void ibutton_worker_mode_read_start(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_read_tick(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_read_stop(iButtonWorker* worker);
|
||||
|
||||
static void ibutton_worker_mode_write_common_start(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_write_blank_tick(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_write_copy_tick(iButtonWorker* worker);
|
||||
static void ibutton_worker_mode_write_common_stop(iButtonWorker* worker);
|
||||
|
||||
const iButtonWorkerModeType ibutton_worker_modes[] = {
|
||||
{
|
||||
.quant = FuriWaitForever,
|
||||
.start = ibutton_worker_mode_idle_start,
|
||||
.tick = ibutton_worker_mode_idle_tick,
|
||||
.stop = ibutton_worker_mode_idle_stop,
|
||||
},
|
||||
{
|
||||
.quant = 100,
|
||||
.start = ibutton_worker_mode_read_start,
|
||||
.tick = ibutton_worker_mode_read_tick,
|
||||
.stop = ibutton_worker_mode_read_stop,
|
||||
},
|
||||
{
|
||||
.quant = 1000,
|
||||
.start = ibutton_worker_mode_write_common_start,
|
||||
.tick = ibutton_worker_mode_write_blank_tick,
|
||||
.stop = ibutton_worker_mode_write_common_stop,
|
||||
},
|
||||
{
|
||||
.quant = 1000,
|
||||
.start = ibutton_worker_mode_write_common_start,
|
||||
.tick = ibutton_worker_mode_write_copy_tick,
|
||||
.stop = ibutton_worker_mode_write_common_stop,
|
||||
},
|
||||
{
|
||||
.quant = 1000,
|
||||
.start = ibutton_worker_mode_emulate_start,
|
||||
.tick = ibutton_worker_mode_emulate_tick,
|
||||
.stop = ibutton_worker_mode_emulate_stop,
|
||||
},
|
||||
};
|
||||
|
||||
/*********************** IDLE ***********************/
|
||||
|
||||
void ibutton_worker_mode_idle_start(iButtonWorker* worker) {
|
||||
UNUSED(worker);
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_idle_tick(iButtonWorker* worker) {
|
||||
UNUSED(worker);
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_idle_stop(iButtonWorker* worker) {
|
||||
UNUSED(worker);
|
||||
}
|
||||
|
||||
/*********************** READ ***********************/
|
||||
|
||||
void ibutton_worker_mode_read_start(iButtonWorker* worker) {
|
||||
UNUSED(worker);
|
||||
furi_hal_power_enable_otg();
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_read_tick(iButtonWorker* worker) {
|
||||
if(ibutton_protocols_read(worker->protocols, worker->key)) {
|
||||
if(worker->read_cb != NULL) {
|
||||
worker->read_cb(worker->cb_ctx);
|
||||
}
|
||||
|
||||
ibutton_worker_switch_mode(worker, iButtonWorkerModeIdle);
|
||||
}
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_read_stop(iButtonWorker* worker) {
|
||||
UNUSED(worker);
|
||||
furi_hal_power_disable_otg();
|
||||
}
|
||||
|
||||
/*********************** EMULATE ***********************/
|
||||
|
||||
void ibutton_worker_mode_emulate_start(iButtonWorker* worker) {
|
||||
furi_assert(worker->key);
|
||||
|
||||
furi_hal_rfid_pins_reset();
|
||||
furi_hal_rfid_pin_pull_pulldown();
|
||||
|
||||
ibutton_protocols_emulate_start(worker->protocols, worker->key);
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_emulate_tick(iButtonWorker* worker) {
|
||||
UNUSED(worker);
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_emulate_stop(iButtonWorker* worker) {
|
||||
furi_assert(worker->key);
|
||||
|
||||
ibutton_protocols_emulate_stop(worker->protocols, worker->key);
|
||||
|
||||
furi_hal_rfid_pins_reset();
|
||||
}
|
||||
|
||||
/*********************** WRITE ***********************/
|
||||
|
||||
void ibutton_worker_mode_write_common_start(iButtonWorker* worker) { //-V524
|
||||
UNUSED(worker);
|
||||
furi_hal_power_enable_otg();
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_write_blank_tick(iButtonWorker* worker) {
|
||||
furi_assert(worker->key);
|
||||
|
||||
const bool success = ibutton_protocols_write_blank(worker->protocols, worker->key);
|
||||
// TODO: pass a proper result to the callback
|
||||
const iButtonWorkerWriteResult result = success ? iButtonWorkerWriteOK :
|
||||
iButtonWorkerWriteNoDetect;
|
||||
if(worker->write_cb != NULL) {
|
||||
worker->write_cb(worker->cb_ctx, result);
|
||||
}
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_write_copy_tick(iButtonWorker* worker) {
|
||||
furi_assert(worker->key);
|
||||
|
||||
const bool success = ibutton_protocols_write_copy(worker->protocols, worker->key);
|
||||
// TODO: pass a proper result to the callback
|
||||
const iButtonWorkerWriteResult result = success ? iButtonWorkerWriteOK :
|
||||
iButtonWorkerWriteNoDetect;
|
||||
if(worker->write_cb != NULL) {
|
||||
worker->write_cb(worker->cb_ctx, result);
|
||||
}
|
||||
}
|
||||
|
||||
void ibutton_worker_mode_write_common_stop(iButtonWorker* worker) { //-V524
|
||||
UNUSED(worker);
|
||||
furi_hal_power_disable_otg();
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
#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);
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
#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);
|
||||
@@ -1,42 +0,0 @@
|
||||
#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;
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
#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);
|
||||
@@ -1,261 +0,0 @@
|
||||
#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
|
||||
#define BITS_IN_MBIT (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, ®s, 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, ®s, 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, ®s, 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* mem_data,
|
||||
size_t mem_size,
|
||||
const char* mem_name) {
|
||||
for(size_t i = 0; i < sizeof(rom_data->bytes); ++i) {
|
||||
furi_string_cat_printf(result, "%02X ", rom_data->bytes[i]);
|
||||
}
|
||||
|
||||
const char* size_prefix = "";
|
||||
size_t mem_size_bits = mem_size * BITS_IN_BYTE;
|
||||
|
||||
if(mem_size_bits >= BITS_IN_MBIT) {
|
||||
size_prefix = "M";
|
||||
mem_size_bits /= BITS_IN_MBIT;
|
||||
} else if(mem_size_bits >= BITS_IN_KBIT) {
|
||||
size_prefix = "K";
|
||||
mem_size_bits /= BITS_IN_KBIT;
|
||||
}
|
||||
|
||||
furi_string_cat_printf(
|
||||
result, "\nInternal %s: %zu %sbit\n", mem_name, mem_size_bits, size_prefix);
|
||||
|
||||
for(size_t i = 0; i < DALLAS_COMMON_BRIEF_HEAD_COUNT; ++i) {
|
||||
furi_string_cat_printf(result, "%02X ", mem_data[i]);
|
||||
}
|
||||
|
||||
furi_string_cat_printf(result, "[ . . . ]");
|
||||
|
||||
for(size_t i = mem_size - DALLAS_COMMON_BRIEF_TAIL_COUNT; i < mem_size; ++i) {
|
||||
furi_string_cat_printf(result, " %02X", mem_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;
|
||||
}
|
||||
@@ -1,108 +0,0 @@
|
||||
#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* mem_data,
|
||||
size_t mem_size,
|
||||
const char* mem_name);
|
||||
|
||||
void dallas_common_render_crc_error(FuriString* result, const DallasCommonRomData* rom_data);
|
||||
|
||||
void dallas_common_apply_edits(DallasCommonRomData* rom_data, uint8_t family_code);
|
||||
@@ -1,39 +0,0 @@
|
||||
#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;
|
||||
@@ -1,270 +0,0 @@
|
||||
#include "protocol_ds1971.h"
|
||||
|
||||
#include <core/core_defines.h>
|
||||
#include <toolbox/pretty_format.h>
|
||||
|
||||
#include "dallas_common.h"
|
||||
|
||||
#define DS1971_FAMILY_CODE 0x14U
|
||||
#define DS1971_FAMILY_NAME "DS1971"
|
||||
|
||||
#define DS1971_EEPROM_DATA_SIZE 32U
|
||||
#define DS1971_SRAM_PAGE_SIZE 32U
|
||||
#define DS1971_COPY_SCRATCH_DELAY_US 250U
|
||||
|
||||
#define DS1971_DATA_BYTE_COUNT 4U
|
||||
|
||||
#define DS1971_EEPROM_DATA_KEY "Eeprom Data"
|
||||
#define DS1971_MEMORY_TYPE "EEPROM"
|
||||
|
||||
#define DS1971_CMD_FINALIZATION 0xA5
|
||||
|
||||
typedef struct {
|
||||
OneWireSlave* bus;
|
||||
DallasCommonCommandState command_state;
|
||||
} DS1971ProtocolState;
|
||||
|
||||
typedef struct {
|
||||
DallasCommonRomData rom_data;
|
||||
uint8_t eeprom_data[DS1971_EEPROM_DATA_SIZE];
|
||||
DS1971ProtocolState state;
|
||||
} DS1971ProtocolData;
|
||||
|
||||
static bool dallas_ds1971_read(OneWireHost*, void*);
|
||||
static bool dallas_ds1971_write_copy(OneWireHost*, iButtonProtocolData*);
|
||||
static void dallas_ds1971_emulate(OneWireSlave*, iButtonProtocolData*);
|
||||
static bool dallas_ds1971_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
|
||||
static bool dallas_ds1971_save(FlipperFormat*, const iButtonProtocolData*);
|
||||
static void dallas_ds1971_render_data(FuriString*, const iButtonProtocolData*);
|
||||
static void dallas_ds1971_render_brief_data(FuriString*, const iButtonProtocolData*);
|
||||
static void dallas_ds1971_render_error(FuriString*, const iButtonProtocolData*);
|
||||
static bool dallas_ds1971_is_data_valid(const iButtonProtocolData*);
|
||||
static void dallas_ds1971_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
|
||||
static void dallas_ds1971_apply_edits(iButtonProtocolData*);
|
||||
static bool
|
||||
dallas_ds1971_read_mem(OneWireHost* host, uint8_t address, uint8_t* data, size_t data_size);
|
||||
static bool ds1971_emulate_read_mem(OneWireSlave* bus, const uint8_t* data, size_t data_size);
|
||||
|
||||
const iButtonProtocolDallasBase ibutton_protocol_ds1971 = {
|
||||
.family_code = DS1971_FAMILY_CODE,
|
||||
.features = iButtonProtocolFeatureExtData | iButtonProtocolFeatureWriteCopy,
|
||||
.data_size = sizeof(DS1971ProtocolData),
|
||||
.manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
|
||||
.name = DS1971_FAMILY_NAME,
|
||||
|
||||
.read = dallas_ds1971_read,
|
||||
.write_blank = NULL, /* No data to write a blank */
|
||||
.write_copy = dallas_ds1971_write_copy,
|
||||
.emulate = dallas_ds1971_emulate,
|
||||
.save = dallas_ds1971_save,
|
||||
.load = dallas_ds1971_load,
|
||||
.render_data = dallas_ds1971_render_data,
|
||||
.render_brief_data = dallas_ds1971_render_brief_data,
|
||||
.render_error = dallas_ds1971_render_error,
|
||||
.is_valid = dallas_ds1971_is_data_valid,
|
||||
.get_editable_data = dallas_ds1971_get_editable_data,
|
||||
.apply_edits = dallas_ds1971_apply_edits,
|
||||
};
|
||||
|
||||
bool dallas_ds1971_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
|
||||
DS1971ProtocolData* data = protocol_data;
|
||||
return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data) &&
|
||||
dallas_ds1971_read_mem(host, 0, data->eeprom_data, DS1971_EEPROM_DATA_SIZE);
|
||||
}
|
||||
|
||||
bool dallas_ds1971_write_copy(OneWireHost* host, iButtonProtocolData* protocol_data) {
|
||||
DS1971ProtocolData* data = protocol_data;
|
||||
|
||||
onewire_host_reset(host);
|
||||
onewire_host_skip(host);
|
||||
// Starting writing from address 0x0000
|
||||
onewire_host_write(host, DALLAS_COMMON_CMD_WRITE_SCRATCH);
|
||||
onewire_host_write(host, 0x00);
|
||||
// Write data to scratchpad
|
||||
onewire_host_write_bytes(host, data->eeprom_data, DS1971_EEPROM_DATA_SIZE);
|
||||
|
||||
// Read data from scratchpad and verify
|
||||
bool pad_valid = false;
|
||||
if(onewire_host_reset(host)) {
|
||||
pad_valid = true;
|
||||
onewire_host_skip(host);
|
||||
onewire_host_write(host, DALLAS_COMMON_CMD_READ_SCRATCH);
|
||||
onewire_host_write(host, 0x00);
|
||||
|
||||
for(size_t i = 0; i < DS1971_EEPROM_DATA_SIZE; ++i) {
|
||||
uint8_t scratch = onewire_host_read(host);
|
||||
if(data->eeprom_data[i] != scratch) {
|
||||
pad_valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Copy scratchpad to memory and confirm
|
||||
if(pad_valid) {
|
||||
if(onewire_host_reset(host)) {
|
||||
onewire_host_skip(host);
|
||||
onewire_host_write(host, DALLAS_COMMON_CMD_COPY_SCRATCH);
|
||||
onewire_host_write(host, DS1971_CMD_FINALIZATION);
|
||||
|
||||
furi_delay_us(DS1971_COPY_SCRATCH_DELAY_US);
|
||||
}
|
||||
}
|
||||
|
||||
return pad_valid;
|
||||
}
|
||||
|
||||
static void dallas_ds1971_reset_callback(void* context) {
|
||||
furi_assert(context);
|
||||
DS1971ProtocolData* data = context;
|
||||
data->state.command_state = DallasCommonCommandStateIdle;
|
||||
}
|
||||
|
||||
static bool dallas_ds1971_command_callback(uint8_t command, void* context) {
|
||||
furi_assert(context);
|
||||
DS1971ProtocolData* 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;
|
||||
ds1971_emulate_read_mem(bus, data->eeprom_data, DS1971_EEPROM_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_ds1971_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
|
||||
DS1971ProtocolData* data = protocol_data;
|
||||
data->state.bus = bus;
|
||||
|
||||
onewire_slave_set_reset_callback(bus, dallas_ds1971_reset_callback, protocol_data);
|
||||
onewire_slave_set_command_callback(bus, dallas_ds1971_command_callback, protocol_data);
|
||||
}
|
||||
|
||||
bool dallas_ds1971_load(
|
||||
FlipperFormat* ff,
|
||||
uint32_t format_version,
|
||||
iButtonProtocolData* protocol_data) {
|
||||
DS1971ProtocolData* 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, DS1971_EEPROM_DATA_KEY, data->eeprom_data, DS1971_EEPROM_DATA_SIZE))
|
||||
break;
|
||||
success = true;
|
||||
} while(false);
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
bool dallas_ds1971_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
|
||||
const DS1971ProtocolData* data = protocol_data;
|
||||
bool success = false;
|
||||
|
||||
do {
|
||||
if(!dallas_common_save_rom_data(ff, &data->rom_data)) break;
|
||||
if(!flipper_format_write_hex(
|
||||
ff, DS1971_EEPROM_DATA_KEY, data->eeprom_data, DS1971_EEPROM_DATA_SIZE))
|
||||
break;
|
||||
success = true;
|
||||
} while(false);
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
void dallas_ds1971_render_data(FuriString* result, const iButtonProtocolData* protocol_data) {
|
||||
const DS1971ProtocolData* data = protocol_data;
|
||||
pretty_format_bytes_hex_canonical(
|
||||
result,
|
||||
DS1971_DATA_BYTE_COUNT,
|
||||
PRETTY_FORMAT_FONT_MONOSPACE,
|
||||
data->eeprom_data,
|
||||
DS1971_EEPROM_DATA_SIZE);
|
||||
}
|
||||
|
||||
void dallas_ds1971_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
|
||||
const DS1971ProtocolData* data = protocol_data;
|
||||
dallas_common_render_brief_data(
|
||||
result, &data->rom_data, data->eeprom_data, DS1971_EEPROM_DATA_SIZE, DS1971_MEMORY_TYPE);
|
||||
}
|
||||
|
||||
void dallas_ds1971_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
|
||||
const DS1971ProtocolData* data = protocol_data;
|
||||
|
||||
if(!dallas_common_is_valid_crc(&data->rom_data)) {
|
||||
dallas_common_render_crc_error(result, &data->rom_data);
|
||||
}
|
||||
}
|
||||
|
||||
bool dallas_ds1971_is_data_valid(const iButtonProtocolData* protocol_data) {
|
||||
const DS1971ProtocolData* data = protocol_data;
|
||||
return dallas_common_is_valid_crc(&data->rom_data);
|
||||
}
|
||||
|
||||
void dallas_ds1971_get_editable_data(
|
||||
iButtonEditableData* editable_data,
|
||||
iButtonProtocolData* protocol_data) {
|
||||
DS1971ProtocolData* data = protocol_data;
|
||||
editable_data->ptr = data->rom_data.bytes;
|
||||
editable_data->size = sizeof(DallasCommonRomData);
|
||||
}
|
||||
|
||||
void dallas_ds1971_apply_edits(iButtonProtocolData* protocol_data) {
|
||||
DS1971ProtocolData* data = protocol_data;
|
||||
dallas_common_apply_edits(&data->rom_data, DS1971_FAMILY_CODE);
|
||||
}
|
||||
|
||||
bool dallas_ds1971_read_mem(OneWireHost* host, uint8_t address, uint8_t* data, size_t data_size) {
|
||||
onewire_host_write(host, DALLAS_COMMON_CMD_READ_MEM);
|
||||
|
||||
onewire_host_write(host, address);
|
||||
onewire_host_read_bytes(host, data, (uint8_t)data_size);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ds1971_emulate_read_mem(OneWireSlave* bus, const uint8_t* data, size_t data_size) {
|
||||
bool success = false;
|
||||
|
||||
do {
|
||||
uint8_t address;
|
||||
if(!onewire_slave_receive(bus, &address, sizeof(address))) break;
|
||||
if(address >= data_size) break;
|
||||
if(!onewire_slave_send(bus, data + address, data_size - address)) break;
|
||||
|
||||
success = true;
|
||||
} while(false);
|
||||
|
||||
return success;
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_dallas_base.h"
|
||||
|
||||
extern const iButtonProtocolDallasBase ibutton_protocol_ds1971;
|
||||
@@ -1,144 +0,0 @@
|
||||
#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);
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_dallas_base.h"
|
||||
|
||||
extern const iButtonProtocolDallasBase ibutton_protocol_ds1990;
|
||||
@@ -1,219 +0,0 @@
|
||||
#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"
|
||||
#define DS1992_MEMORY_TYPE "SRAM"
|
||||
|
||||
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, DS1992_MEMORY_TYPE);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_dallas_base.h"
|
||||
|
||||
extern const iButtonProtocolDallasBase ibutton_protocol_ds1992;
|
||||
@@ -1,213 +0,0 @@
|
||||
#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"
|
||||
#define DS1996_MEMORY_TYPE "SRAM"
|
||||
|
||||
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, DS1996_MEMORY_TYPE);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_dallas_base.h"
|
||||
|
||||
extern const iButtonProtocolDallasBase ibutton_protocol_ds1996;
|
||||
@@ -1,133 +0,0 @@
|
||||
#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);
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_dallas_base.h"
|
||||
|
||||
extern const iButtonProtocolDallasBase ibutton_protocol_ds_generic;
|
||||
@@ -1,310 +0,0 @@
|
||||
#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,
|
||||
};
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "../protocol_group_base.h"
|
||||
|
||||
extern const iButtonProtocolGroupBase ibutton_protocol_group_dallas;
|
||||
@@ -1,18 +0,0 @@
|
||||
#include "protocol_group_dallas_defs.h"
|
||||
|
||||
#include "protocol_ds1990.h"
|
||||
#include "protocol_ds1992.h"
|
||||
#include "protocol_ds1996.h"
|
||||
#include "protocol_ds1971.h"
|
||||
#include "protocol_ds_generic.h"
|
||||
|
||||
const iButtonProtocolDallasBase* ibutton_protocols_dallas[] = {
|
||||
[iButtonProtocolDS1990] = &ibutton_protocol_ds1990,
|
||||
[iButtonProtocolDS1992] = &ibutton_protocol_ds1992,
|
||||
[iButtonProtocolDS1996] = &ibutton_protocol_ds1996,
|
||||
[iButtonProtocolDS1971] = &ibutton_protocol_ds1971,
|
||||
/* Add new 1-Wire protocols here */
|
||||
|
||||
/* Default catch-all 1-Wire protocol */
|
||||
[iButtonProtocolDSGeneric] = &ibutton_protocol_ds_generic,
|
||||
};
|
||||
@@ -1,17 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_dallas_base.h"
|
||||
|
||||
typedef enum {
|
||||
iButtonProtocolDS1990,
|
||||
iButtonProtocolDS1992,
|
||||
iButtonProtocolDS1996,
|
||||
iButtonProtocolDS1971,
|
||||
/* Add new 1-Wire protocols here */
|
||||
|
||||
/* Default catch-all 1-Wire protocol */
|
||||
iButtonProtocolDSGeneric,
|
||||
iButtonProtocolDSMax,
|
||||
} iButtonProtocolDallas;
|
||||
|
||||
extern const iButtonProtocolDallasBase* ibutton_protocols_dallas[];
|
||||
@@ -1,352 +0,0 @@
|
||||
#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,
|
||||
};
|
||||
@@ -1,4 +0,0 @@
|
||||
#pragma once
|
||||
#include "toolbox/protocols/protocol.h"
|
||||
|
||||
extern const ProtocolBase ibutton_protocol_misc_cyfral;
|
||||
@@ -1,295 +0,0 @@
|
||||
#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,
|
||||
};
|
||||
@@ -1,5 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "../protocol_group_base.h"
|
||||
|
||||
extern const iButtonProtocolGroupBase ibutton_protocol_group_misc;
|
||||
@@ -1,10 +0,0 @@
|
||||
#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 */
|
||||
};
|
||||
@@ -1,11 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <toolbox/protocols/protocol.h>
|
||||
|
||||
typedef enum {
|
||||
iButtonProtocolMiscCyfral,
|
||||
iButtonProtocolMiscMetakom,
|
||||
iButtonProtocolMiscMax,
|
||||
} iButtonProtocolMisc;
|
||||
|
||||
extern const ProtocolBase* ibutton_protocols_misc[];
|
||||
@@ -1,328 +0,0 @@
|
||||
#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,
|
||||
};
|
||||
@@ -1,4 +0,0 @@
|
||||
#pragma once
|
||||
#include "toolbox/protocols/protocol.h"
|
||||
|
||||
extern const ProtocolBase ibutton_protocol_misc_metakom;
|
||||
@@ -1,21 +0,0 @@
|
||||
#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;
|
||||
@@ -1,6 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_common.h"
|
||||
|
||||
typedef void iButtonProtocolData;
|
||||
typedef int32_t iButtonProtocolLocalId;
|
||||
@@ -1,104 +0,0 @@
|
||||
#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;
|
||||
@@ -1,9 +0,0 @@
|
||||
#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,
|
||||
};
|
||||
@@ -1,11 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "protocol_group_base.h"
|
||||
|
||||
typedef enum {
|
||||
iButtonProtocolGroupDallas,
|
||||
iButtonProtocolGroupMisc,
|
||||
iButtonProtocolGroupMax
|
||||
} iButtonProtocolGroup;
|
||||
|
||||
extern const iButtonProtocolGroupBase* ibutton_protocol_groups[];
|
||||
Reference in New Issue
Block a user