[FL-85][FL-446][FL-720] Dallas key blanks and OneWire lib rework (#313)

* sepate one wire class
* TM2004 writer
* app mode write ds1990
* test another blanks protocol
* new ibutton slave
* one wire states
* tim1 capture compare and update interrupts
* interrupt mgr, new timers IRQ
* discard HAL_TIM_PeriodElapsedCallback from main
* add exti_14 line
* add external interrupt callback
* use int mgr in input
* better interrupt managment
* add interrupt callback enable and disable fns
* properly init app
* changed timings
* rename one wire classes
* use new owb classes
* properly remove interrupts
* new blanks writer
* remove unused tests
* new core includes
* extern c guard
* fix api_interrupt_remove usage
* remove debug info, new way to detect blanks writing
* remove copy constructor
* change keys template
* fix app sources recipe

applications/ibutton/blanks_writer.cpp

@@ -0,0 +1,319 @@
+#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>
+
+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();
+}

applications/ibutton/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();
+};

applications/ibutton/ibutton.cpp

@@ -1,6 +1,7 @@
 #include "ibutton.h"
 #include "ibutton_mode_dallas_read.h"
 #include "ibutton_mode_dallas_emulate.h"
+#include "ibutton_mode_dallas_write.h"
 #include "ibutton_mode_cyfral_read.h"
 #include "ibutton_mode_cyfral_emulate.h"
 
@@ -8,8 +9,9 @@
 void AppiButton::run() {
     mode[0] = new AppiButtonModeDallasRead(this);
     mode[1] = new AppiButtonModeDallasEmulate(this);
-    mode[2] = new AppiButtonModeCyfralRead(this);
-    mode[3] = new AppiButtonModeCyfralEmulate(this);
+    mode[2] = new AppiButtonModeDallasWrite(this);
+    mode[3] = new AppiButtonModeCyfralRead(this);
+    mode[4] = new AppiButtonModeCyfralEmulate(this);
 
     switch_to_mode(0);
 
@@ -21,6 +23,7 @@ void AppiButton::run() {
     gpio_init(red_led_record, GpioModeOutputOpenDrain);
     gpio_init(green_led_record, GpioModeOutputOpenDrain);
 
+    api_hal_timebase_insomnia_enter();
     app_ready();
 
     AppiButtonEvent event;
@@ -29,9 +32,10 @@ void AppiButton::run() {
             if(event.type == AppiButtonEvent::EventTypeKey) {
                 // press events
                 if(event.value.input.state && event.value.input.input == InputBack) {
-                    printf("[ibutton] bye!\n");
-                    // TODO remove all widgets create by app
                     widget_enabled_set(widget, false);
+                    gui_remove_widget(gui, widget);
+                    api_hal_timebase_insomnia_exit();
+
                     osThreadExit();
                 }
 

applications/ibutton/ibutton.h

@@ -56,7 +56,7 @@ public:
     const GpioPin* red_led_record;
     const GpioPin* green_led_record;
 
-    static const uint8_t modes_count = 4;
+    static const uint8_t modes_count = 5;
     AppTemplateMode<AppiButtonState, AppiButtonEvent>* mode[modes_count];
 
     void run();

applications/ibutton/ibutton_mode_dallas_emulate.h

@@ -1,38 +1,50 @@
 #pragma once
 #include "ibutton.h"
-#include "one_wire_slave_gpio.h"
+#include "one_wire_slave.h"
 #include "one_wire_device_ds_1990.h"
+#include "callback-connector.h"
+#include <atomic>
 
 class AppiButtonModeDallasEmulate : public AppTemplateMode<AppiButtonState, AppiButtonEvent> {
+private:
+    void result_callback(bool success, void* ctx);
+
 public:
     const char* name = "dallas emulate";
     AppiButton* app;
-    OneWireGpioSlave* onewire_slave;
     DS1990 key;
+    OneWireSlave* onewire_slave;
 
     void event(AppiButtonEvent* event, AppiButtonState* state);
     void render(Canvas* canvas, AppiButtonState* state);
     void acquire();
     void release();
 
+    std::atomic<bool> emulated_result{false};
+
     AppiButtonModeDallasEmulate(AppiButton* parent_app)
         : key(1, 2, 3, 4, 5, 6, 7) {
         app = parent_app;
 
         // TODO open record
         const GpioPin* one_wire_pin_record = &ibutton_gpio;
-        onewire_slave = new OneWireGpioSlave(one_wire_pin_record);
-        onewire_slave->attach(key);
+        onewire_slave = new OneWireSlave(one_wire_pin_record);
+        onewire_slave->attach(&key);
+
+        auto cb = cbc::obtain_connector(this, &AppiButtonModeDallasEmulate::result_callback);
+        onewire_slave->set_result_callback(cb, this);
     };
 };
 
+void AppiButtonModeDallasEmulate::result_callback(bool success, void* ctx) {
+    AppiButtonModeDallasEmulate* _this = static_cast<AppiButtonModeDallasEmulate*>(ctx);
+    _this->emulated_result = success;
+}
+
 void AppiButtonModeDallasEmulate::event(AppiButtonEvent* event, AppiButtonState* state) {
     if(event->type == AppiButtonEvent::EventTypeTick) {
-        onewire_slave->detach(key);
-        memcpy(key.id_storage, state->dallas_address[state->dallas_address_index], 8);
-        onewire_slave->attach(key);
-
-        if(onewire_slave->emulate()) {
+        if(emulated_result) {
+            emulated_result = false;
             app->blink_green();
         }
     } else if(event->type == AppiButtonEvent::EventTypeKey) {
@@ -44,6 +56,10 @@ void AppiButtonModeDallasEmulate::event(AppiButtonEvent* event, AppiButtonState*
             app->increase_dallas_address();
         }
     }
+
+    onewire_slave->deattach();
+    memcpy(key.id_storage, state->dallas_address[state->dallas_address_index], 8);
+    onewire_slave->attach(&key);
 }
 
 void AppiButtonModeDallasEmulate::render(Canvas* canvas, AppiButtonState* state) {

applications/ibutton/ibutton_mode_dallas_read.h

@@ -1,13 +1,13 @@
 #pragma once
 #include "ibutton.h"
-#include "one_wire_gpio.h"
+#include "one_wire_master.h"
 #include "maxim_crc.h"
 
 class AppiButtonModeDallasRead : public AppTemplateMode<AppiButtonState, AppiButtonEvent> {
 public:
     const char* name = "dallas read";
     AppiButton* app;
-    OneWireGpio* onewire;
+    OneWireMaster* onewire;
 
     void event(AppiButtonEvent* event, AppiButtonState* state);
     void render(Canvas* canvas, AppiButtonState* state);
@@ -19,7 +19,7 @@ public:
 
         // TODO open record
         const GpioPin* one_wire_pin_record = &ibutton_gpio;
-        onewire = new OneWireGpio(one_wire_pin_record);
+        onewire = new OneWireMaster(one_wire_pin_record);
     };
 };
 
@@ -33,30 +33,17 @@ void AppiButtonModeDallasRead::event(AppiButtonEvent* event, AppiButtonState* st
         osKernelUnlock();
 
         if(result) {
-            printf("device on line\n");
-
-            delay(50);
             osKernelLock();
+            __disable_irq();
             onewire->write(0x33);
             onewire->read_bytes(address, 8);
+            __enable_irq();
             osKernelUnlock();
 
-            printf("address: %x", address[0]);
-            for(uint8_t i = 1; i < 8; i++) {
-                printf(":%x", address[i]);
-            }
-            printf("\n");
-
-            printf("crc8: %x\n", maxim_crc8(address, 7));
-
             if(maxim_crc8(address, 8) == 0) {
-                printf("CRC valid\n");
                 memcpy(app->state.dallas_address[app->state.dallas_address_index], address, 8);
                 app->blink_green();
-            } else {
-                printf("CRC invalid\n");
             }
-        } else {
         }
     } else if(event->type == AppiButtonEvent::EventTypeKey) {
         if(event->value.input.state && event->value.input.input == InputUp) {

applications/ibutton/ibutton_mode_dallas_write.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "ibutton.h"
+#include "blanks_writer.h"
+#include "maxim_crc.h"
+
+class AppiButtonModeDallasWrite : public AppTemplateMode<AppiButtonState, AppiButtonEvent> {
+public:
+    const char* name = "dallas read";
+    AppiButton* app;
+    BlanksWriter* writer;
+
+    void event(AppiButtonEvent* event, AppiButtonState* state);
+    void render(Canvas* canvas, AppiButtonState* state);
+    void acquire();
+    void release();
+
+    const GpioPin* one_wire_pin_record;
+
+    AppiButtonModeDallasWrite(AppiButton* parent_app) {
+        app = parent_app;
+
+        // TODO open record
+        one_wire_pin_record = &ibutton_gpio;
+        writer = new BlanksWriter(one_wire_pin_record);
+    };
+};
+
+void AppiButtonModeDallasWrite::event(AppiButtonEvent* event, AppiButtonState* state) {
+    if(event->type == AppiButtonEvent::EventTypeTick) {
+        WriterResult result =
+            writer->write(KEY_DS1990, state->dallas_address[state->dallas_address_index], 8);
+
+        if(result == WR_SAME_KEY) {
+            app->blink_green();
+        }
+
+        if(result == WR_OK) {
+            app->blink_red();
+        }
+
+    } else if(event->type == AppiButtonEvent::EventTypeKey) {
+        if(event->value.input.state && event->value.input.input == InputUp) {
+            app->decrease_dallas_address();
+        }
+
+        if(event->value.input.state && event->value.input.input == InputDown) {
+            app->increase_dallas_address();
+        }
+    }
+}
+
+void AppiButtonModeDallasWrite::render(Canvas* canvas, AppiButtonState* state) {
+    canvas_set_font(canvas, FontSecondary);
+    canvas_draw_str(canvas, 2, 25, "< Dallas write >");
+    app->render_dallas_list(canvas, state);
+}
+
+void AppiButtonModeDallasWrite::acquire() {
+    writer->start();
+}
+
+void AppiButtonModeDallasWrite::release() {
+    writer->stop();
+}