new iButton app (#328)

* rename old ibutton app to ibutton-test * more renames * updated onewire library compilation condition * add submenu_clean subroutine * add index for submenu callback * c++ guard for gui modules * add released ibutton app * fix the position of the submenu window if there are too few items * iButton app basis * negative icon position info * fix submenu_clean subroutine * add ibutton app to applications makefile * add onewire key read routine to read mode * rename mode to scene * rename files and folder (mode to scene) * rename ibutton view to view manager * rename get_view to get_view_manager * cpp guards * key read, store and notify features * syntax fix * make iButtonScene functions pure virtual * fix syntax * add text store, add new scene (crc error) * not a key scene * syntax fix * read success scene * app, switching to the previous scene with the number of scenes to be skipped * scene whith menu when key is readed * fix font height calculation, fix offsets * add key write scene * view_dispatcher_remove_view subroutine * generic pause/resume os methods * fix furi_assert usage * key store, worker * fix pointer comparsion * saved keys, saved key action scenes * key delete/confirm delete scenes and routines * use last input subsystem changes * fix syntax * fix new model usage in submenu * fix includes * use vibro pin * use stored key name if valid * emulate scene * random name generator * name and save readed key scenes, new icon * fix icon position * fix text scene exit * fix naming, fix text placement, new info scene * state-driven cyfral decoder * better cyfral decoder * better cyfral decoder * one wire: search command set * metakom decoder * more key types * add next scene to error scenes * universal key reader * use new key reader * syntax fix * warning fix * byte input module template * new thread and insomnia api usage * New element: slightly rounded frame * Use elements_slightly_rounded_frame in text input * Gui test app: byte input usage * Byte input module: data drawing and selection * Byte input: comment currently unused fns * remove volatile qualifier * base byte input realisation * App gui test: remove internal fns visibility * Byne input, final version * test install gcc-arm-none-eabi-10-2020-q4-major * test install gcc-arm-none-eabi-10-2020-q4-major * App iButton: byte input view managment * App iButton: add key manually scenes * App iButton: rename scenes, add popup timeout * App iButton: use new scenes, new fn for rollback to specific prevous scene. * App iButton: remove byte input view on app exit * App iButton: edit key scene * Module byte input: reduce swintch value to uint8_t * Module byte input: switch from switch-case to if, unfortunately we need compile-time constants to use with switch * Icons: new small arrows * Module byte input: new arrangement of elements * OneWire slave lib: fix deattach sequence * App iButton: pulse sequencer * App iButton: add more keys to store * App iButton: split key worker to separate read/write/emulate entitys * App iButton: use new read/emulate entities * fix callback pointer saving * App iButton: use KeyReader error enum instead of KeyWorker error list handling * App iButton: do not use insomnia fns in pulse sequencer * App iButton: use KeyReader error enum in read scene * OneWire slave lib: more READ ROM command variants, call callback only if positive result * GPIO resources: add external gpio * App SD/NFC: removed application * App iButton-test: update to new light api * App iButton: update to new light-api * Outdated apps: add api-light-usage * Gpio: update SD card CS pin settings * API-power: added fns to disable/enable external 3v3 dc-dc * API-gpio: separated SD card detect routines * Resources: removed sd cs pin * SD card: low level init now resets card power supply * App SD-filesystem: use new card detect fns * SD card: fix low level init headers * SD card: more realilable low level init, power reset, exit from command read cycle conditionally * App SD-filesystem: led notifiers, init cycling * SD card: backport to F4 * Api PWM: add c++ guards * App iButton: yellow blink in emulate scene, vibro on * App iButton: one wire keys command set * App iButton: successful write scene * App iButton: key writer * App iButton: syntax fix * App iButton: notify write success * App iButton: fix double scene change * SD card: handle eject in init sequence * SD card: api to set level on detect gpio * SPI: api to set state on bus pins * SD card: set low state on bus pins while power reset * File select: init * File select: fix input consuming * SD Card: fixed dir open api error * SD-card: replace strncpy by strlcpy. Fix buffer overflow error. * API HAL OS: replace CMP based ticks with ARR based one, hard reset lptimer on reconfiguration. * GUI: More stack size for (temporary, wee need to implement sd card api in separate thread) * GUI: File select module. * App iButton-test: remove obsolete app Co-authored-by: rusdacent <rusdacentx0x08@gmail.com> Co-authored-by: coreglitch <mail@s3f.ru> Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
2021-03-12 15:45:18 +03:00
parent fc12f91a64
commit 1daef3d025
99 changed files with 5341 additions and 653 deletions
--- a/lib/onewire/blanks_writer.cpp
+++ b/lib/onewire/blanks_writer.cpp
@@ -0,0 +1,320 @@
+#include "blanks_writer.h"
+
+class RW1990_1 {
+public:
+    constexpr static const uint8_t CMD_WRITE_RECORD_FLAG = 0xD1;
+    constexpr static const uint8_t CMD_READ_RECORD_FLAG = 0xB5;
+    constexpr static const uint8_t CMD_WRITE_ROM = 0xD5;
+};
+
+class RW1990_2 {
+public:
+    constexpr static const uint8_t CMD_WRITE_RECORD_FLAG = 0x1D;
+    constexpr static const uint8_t CMD_READ_RECORD_FLAG = 0x1E;
+    constexpr static const uint8_t CMD_WRITE_ROM = 0xD5;
+};
+
+class TM2004 {
+public:
+    constexpr static const uint8_t CMD_READ_STATUS = 0xAA;
+    constexpr static const uint8_t CMD_READ_MEMORY = 0xF0;
+    constexpr static const uint8_t CMD_WRITE_ROM = 0x3C;
+    constexpr static const uint8_t CMD_FINALIZATION = 0x35;
+
+    constexpr static const uint8_t ANSWER_READ_MEMORY = 0xF5;
+};
+
+class TM01 {
+public:
+    constexpr static const uint8_t CMD_WRITE_RECORD_FLAG = 0xC1;
+    constexpr static const uint8_t CMD_WRITE_ROM = 0xC5;
+    constexpr static const uint8_t CMD_SWITCH_TO_CYFRAL = 0xCA;
+    constexpr static const uint8_t CMD_SWITCH_TO_METAKOM = 0xCB;
+};
+
+class DS1990 {
+public:
+    constexpr static const uint8_t CMD_READ_ROM = 0x33;
+};
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <api-hal.h>
+
+void BlanksWriter::onewire_release(void) {
+    gpio_write(gpio, true);
+}
+
+void BlanksWriter::onewire_write_one_bit(bool value, uint32_t delay = 10000) {
+    onewire->write_bit(value);
+    delay_us(delay);
+    onewire_release();
+}
+
+BlanksWriter::BlanksWriter(const GpioPin* one_wire_gpio) {
+    gpio = one_wire_gpio;
+    onewire = new OneWireMaster(gpio);
+}
+
+BlanksWriter::~BlanksWriter() {
+    free(onewire);
+}
+
+WriterResult BlanksWriter::write(KeyType type, const uint8_t* key, uint8_t key_length) {
+    uint8_t write_result = -1;
+    WriterResult result = WR_ERROR;
+
+    bool same_key = false;
+
+    osKernelLock();
+    bool presence = onewire->reset();
+    osKernelUnlock();
+
+    if(presence) {
+        switch(type) {
+        case KeyType::KEY_DS1990:
+            same_key = compare_key_ds1990(key, key_length);
+
+            if(!same_key) {
+                // currently we can write:
+                // RW1990, TM08v2, TM08vi-2 by write_1990_1()
+                // RW2004, RW2004 with EEPROM by write_TM2004();
+
+                if(write_result != 1) {
+                    write_result = write_1990_1(key, key_length);
+                }
+                if(write_result != 1) {
+                    write_result = write_1990_2(key, key_length);
+                }
+                if(write_result != 1) {
+                    write_result = write_TM2004(key, key_length);
+                }
+
+                if(write_result == 1) {
+                    result = WR_OK;
+                } else if(write_result == 0) {
+                    result = WR_ERROR;
+                }
+            } else {
+                write_result = 0;
+                result = WR_SAME_KEY;
+            }
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return result;
+}
+
+bool BlanksWriter::write_TM2004(const uint8_t* key, uint8_t key_length) {
+    uint8_t answer;
+    bool result = true;
+
+    osKernelLock();
+    __disable_irq();
+
+    // write rom, addr is 0x0000
+    onewire->reset();
+    onewire->write(TM2004::CMD_WRITE_ROM);
+    onewire->write(0x00);
+    onewire->write(0x00);
+
+    // write key
+    for(uint8_t i = 0; i < key_length; i++) {
+        // write key byte
+        onewire->write(key[i]);
+        answer = onewire->read();
+        // TODO: check answer CRC
+
+        // pulse indicating that data is correct
+        delay_us(600);
+        onewire_write_one_bit(1, 50000);
+
+        // read writed key byte
+        answer = onewire->read();
+
+        // check that writed and readed are same
+        if(key[i] != answer) {
+            result = false;
+            break;
+        }
+    }
+
+    onewire->reset();
+
+    __enable_irq();
+    osKernelUnlock();
+
+    return result;
+}
+
+bool BlanksWriter::write_1990_1(const uint8_t* key, uint8_t key_length) {
+    bool result = true;
+
+    osKernelLock();
+    __disable_irq();
+
+    // unlock
+    onewire->reset();
+    onewire->write(RW1990_1::CMD_WRITE_RECORD_FLAG);
+    delay_us(10);
+    onewire_write_one_bit(0, 5000);
+
+    // write key
+    onewire->reset();
+    onewire->write(RW1990_1::CMD_WRITE_ROM);
+    for(uint8_t i = 0; i < key_length; i++) {
+        // inverted key for RW1990.1
+        write_byte_ds1990(~key[i]);
+        delay_us(30000);
+    }
+
+    // lock
+    onewire->write(RW1990_1::CMD_WRITE_RECORD_FLAG);
+    onewire_write_one_bit(1);
+
+    __enable_irq();
+    osKernelUnlock();
+
+    if(!compare_key_ds1990(key, key_length)) {
+        result = false;
+    }
+
+    return result;
+}
+
+bool BlanksWriter::write_1990_2(const uint8_t* key, uint8_t key_length) {
+    bool result = true;
+
+    osKernelLock();
+    __disable_irq();
+
+    // unlock
+    onewire->reset();
+    onewire->write(RW1990_2::CMD_WRITE_RECORD_FLAG);
+    delay_us(10);
+    onewire_write_one_bit(1, 5000);
+
+    // write key
+    onewire->reset();
+    onewire->write(RW1990_2::CMD_WRITE_ROM);
+    for(uint8_t i = 0; i < key_length; i++) {
+        write_byte_ds1990(key[i]);
+        delay_us(30000);
+    }
+
+    // lock
+    onewire->write(RW1990_2::CMD_WRITE_RECORD_FLAG);
+    onewire_write_one_bit(0);
+
+    __enable_irq();
+    osKernelUnlock();
+
+    if(!compare_key_ds1990(key, key_length)) {
+        result = false;
+    }
+
+    return result;
+}
+
+// TODO: untested
+bool BlanksWriter::write_TM01(KeyType type, const uint8_t* key, uint8_t key_length) {
+    bool result = true;
+
+    osKernelLock();
+    __disable_irq();
+
+    // unlock
+    onewire->reset();
+    onewire->write(TM01::CMD_WRITE_RECORD_FLAG);
+    onewire_write_one_bit(1, 10000);
+
+    // write key
+    onewire->reset();
+    onewire->write(TM01::CMD_WRITE_ROM);
+
+    // TODO: key types
+    //if(type == KEY_METAKOM || type == KEY_CYFRAL) {
+    //} else {
+    for(uint8_t i = 0; i < key_length; i++) {
+        write_byte_ds1990(key[i]);
+        delay_us(10000);
+    }
+    //}
+
+    // lock
+    onewire->write(TM01::CMD_WRITE_RECORD_FLAG);
+    onewire_write_one_bit(0, 10000);
+
+    __enable_irq();
+    osKernelUnlock();
+
+    if(!compare_key_ds1990(key, key_length)) {
+        result = false;
+    }
+
+    osKernelLock();
+    __disable_irq();
+
+    if(type == KEY_METAKOM || type == KEY_CYFRAL) {
+        onewire->reset();
+        if(type == KEY_CYFRAL)
+            onewire->write(TM01::CMD_SWITCH_TO_CYFRAL);
+        else
+            onewire->write(TM01::CMD_SWITCH_TO_METAKOM);
+        onewire_write_one_bit(1);
+    }
+
+    __enable_irq();
+    osKernelUnlock();
+
+    return result;
+}
+
+void BlanksWriter::write_byte_ds1990(uint8_t data) {
+    for(uint8_t n_bit = 0; n_bit < 8; n_bit++) {
+        onewire->write_bit(data & 1);
+        onewire_release();
+        delay_us(5000);
+        data = data >> 1;
+    }
+}
+
+bool BlanksWriter::compare_key_ds1990(const uint8_t* key, uint8_t key_length) {
+    uint8_t buff[key_length];
+    bool result = false;
+
+    osKernelLock();
+    bool presence = onewire->reset();
+    osKernelUnlock();
+
+    if(presence) {
+        osKernelLock();
+        __disable_irq();
+        onewire->write(DS1990::CMD_READ_ROM);
+        onewire->read_bytes(buff, key_length);
+        __enable_irq();
+        osKernelUnlock();
+
+        result = true;
+        for(uint8_t i = 0; i < 8; i++) {
+            if(key[i] != buff[i]) {
+                result = false;
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+void BlanksWriter::start() {
+    onewire->start();
+}
+
+void BlanksWriter::stop() {
+    onewire->stop();
+}
--- a/lib/onewire/blanks_writer.h
+++ b/lib/onewire/blanks_writer.h
@@ -0,0 +1,40 @@
+#pragma once
+#include "one_wire_master.h"
+#include "maxim_crc.h"
+
+typedef enum {
+    KEY_DS1990, /**< DS1990 */
+    KEY_CYFRAL, /**< CYFRAL*/
+    KEY_METAKOM, /**< METAKOM */
+} KeyType;
+
+typedef enum {
+    WR_OK,
+    WR_SAME_KEY,
+    WR_ERROR,
+} WriterResult;
+
+class BlanksWriter {
+private:
+    const GpioPin* gpio;
+    OneWireMaster* onewire;
+
+    void onewire_release(void);
+    void onewire_write_one_bit(bool value, uint32_t delay);
+
+    bool write_TM2004(const uint8_t* key, uint8_t key_length);
+    bool write_1990_1(const uint8_t* key, uint8_t key_length);
+    bool write_1990_2(const uint8_t* key, uint8_t key_length);
+    bool write_TM01(KeyType type, const uint8_t* key, uint8_t key_length);
+
+    void write_byte_ds1990(uint8_t data);
+    bool compare_key_ds1990(const uint8_t* key, uint8_t key_length);
+
+public:
+    BlanksWriter(const GpioPin* one_wire_gpio);
+    ~BlanksWriter();
+
+    WriterResult write(KeyType type, const uint8_t* key, uint8_t key_length);
+    void start();
+    void stop();
+};
--- a/lib/onewire/one_wire_master.cpp
+++ b/lib/onewire/one_wire_master.cpp
@@ -3,6 +3,7 @@

 OneWireMaster::OneWireMaster(const GpioPin* one_wire_gpio) {
    gpio = one_wire_gpio;
+    reset_search();
 }

 OneWireMaster::~OneWireMaster() {
@@ -17,6 +18,137 @@ void OneWireMaster::stop(void) {
    gpio_init(gpio, GpioModeAnalog);
 }

+void OneWireMaster::reset_search() {
+    // reset the search state
+    last_discrepancy = 0;
+    last_device_flag = false;
+    last_family_discrepancy = 0;
+    for(int i = 7;; i--) {
+        saved_rom[i] = 0;
+        if(i == 0) break;
+    }
+}
+
+void OneWireMaster::target_search(uint8_t family_code) {
+    // set the search state to find SearchFamily type devices
+    saved_rom[0] = family_code;
+    for(uint8_t i = 1; i < 8; i++) saved_rom[i] = 0;
+    last_discrepancy = 64;
+    last_family_discrepancy = 0;
+    last_device_flag = false;
+}
+
+uint8_t OneWireMaster::search(uint8_t* newAddr, bool search_mode) {
+    uint8_t id_bit_number;
+    uint8_t last_zero, rom_byte_number, search_result;
+    uint8_t id_bit, cmp_id_bit;
+
+    unsigned char rom_byte_mask, search_direction;
+
+    // initialize for search
+    id_bit_number = 1;
+    last_zero = 0;
+    rom_byte_number = 0;
+    rom_byte_mask = 1;
+    search_result = 0;
+
+    // if the last call was not the last one
+    if(!last_device_flag) {
+        // 1-Wire reset
+        if(!reset()) {
+            // reset the search
+            last_discrepancy = 0;
+            last_device_flag = false;
+            last_family_discrepancy = 0;
+            return false;
+        }
+
+        // issue the search command
+        if(search_mode == true) {
+            write(0xF0); // NORMAL SEARCH
+        } else {
+            write(0xEC); // CONDITIONAL SEARCH
+        }
+
+        // loop to do the search
+        do {
+            // read a bit and its complement
+            id_bit = read_bit();
+            cmp_id_bit = read_bit();
+
+            // check for no devices on 1-wire
+            if((id_bit == 1) && (cmp_id_bit == 1))
+                break;
+            else {
+                // all devices coupled have 0 or 1
+                if(id_bit != cmp_id_bit)
+                    search_direction = id_bit; // bit write value for search
+                else {
+                    // if this discrepancy if before the Last Discrepancy
+                    // on a previous next then pick the same as last time
+                    if(id_bit_number < last_discrepancy)
+                        search_direction = ((saved_rom[rom_byte_number] & rom_byte_mask) > 0);
+                    else
+                        // if equal to last pick 1, if not then pick 0
+                        search_direction = (id_bit_number == last_discrepancy);
+
+                    // if 0 was picked then record its position in LastZero
+                    if(search_direction == 0) {
+                        last_zero = id_bit_number;
+
+                        // check for Last discrepancy in family
+                        if(last_zero < 9) last_family_discrepancy = last_zero;
+                    }
+                }
+
+                // set or clear the bit in the ROM byte rom_byte_number
+                // with mask rom_byte_mask
+                if(search_direction == 1)
+                    saved_rom[rom_byte_number] |= rom_byte_mask;
+                else
+                    saved_rom[rom_byte_number] &= ~rom_byte_mask;
+
+                // serial number search direction write bit
+                write_bit(search_direction);
+
+                // increment the byte counter id_bit_number
+                // and shift the mask rom_byte_mask
+                id_bit_number++;
+                rom_byte_mask <<= 1;
+
+                // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
+                if(rom_byte_mask == 0) {
+                    rom_byte_number++;
+                    rom_byte_mask = 1;
+                }
+            }
+        } while(rom_byte_number < 8); // loop until through all ROM bytes 0-7
+
+        // if the search was successful then
+        if(!(id_bit_number < 65)) {
+            // search successful so set last_Discrepancy, last_device_flag, search_result
+            last_discrepancy = last_zero;
+
+            // check for last device
+            if(last_discrepancy == 0) last_device_flag = true;
+
+            search_result = true;
+        }
+    }
+
+    // if no device found then reset counters so next 'search' will be like a first
+    if(!search_result || !saved_rom[0]) {
+        last_discrepancy = 0;
+        last_device_flag = false;
+        last_family_discrepancy = 0;
+        search_result = false;
+    } else {
+        for(int i = 0; i < 8; i++) newAddr[i] = saved_rom[i];
+    }
+
+    return search_result;
+}
+
 bool OneWireMaster::reset(void) {
    uint8_t r;
    uint8_t retries = 125;
--- a/lib/onewire/one_wire_master.h
+++ b/lib/onewire/one_wire_master.h
@@ -7,6 +7,12 @@ class OneWireMaster {
 private:
    const GpioPin* gpio;

+    // global search state
+    unsigned char saved_rom[8];
+    uint8_t last_discrepancy;
+    uint8_t last_family_discrepancy;
+    bool last_device_flag;
+
 public:
    OneWireMaster(const GpioPin* one_wire_gpio);
    ~OneWireMaster();
@@ -19,4 +25,8 @@ public:
    void skip(void);
    void start(void);
    void stop(void);
+
+    void reset_search();
+    void target_search(uint8_t family_code);
+    uint8_t search(uint8_t* newAddr, bool search_mode = true);
 };
--- a/lib/onewire/one_wire_slave.cpp
+++ b/lib/onewire/one_wire_slave.cpp
@@ -43,8 +43,10 @@ void OneWireSlave::attach(OneWireDevice* attached_device) {
 }

 void OneWireSlave::deattach(void) {
+    if(device != nullptr) {
+        device->deattach();
+    }
    device = nullptr;
-    device->deattach();
 }

 void OneWireSlave::set_result_callback(OneWireSlaveResultCallback result_cb, void* ctx) {
@@ -237,10 +239,11 @@ bool OneWireSlave::receive_and_process_cmd(void) {
        cmd_search_rom();
        return true;

+    case 0x0F:
    case 0x33:
        // READ ROM
        device->send_id();
-        return false;
+        return true;

    default: // Unknown command
        error = OneWireSlaveError::INCORRECT_ONEWIRE_CMD;
@@ -293,8 +296,7 @@ void OneWireSlave::exti_callback(void* _pin, void* _ctx) {
                if(pulse_length <= OWET::RESET_MAX) {
                    // reset cycle ok
                    bool result = _this->bus_start();
-
-                    if(_this->result_cb != nullptr) {
+                    if(result && _this->result_cb != nullptr) {
                        _this->result_cb(result, _this->result_cb_ctx);
                    }
                } else {