Reorg, added more sources

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/README.md

@@ -0,0 +1,43 @@
+# flipperzero-i2ctools
+
+Set of i2c tools for Flipper Zero
+
+![Preview](i2ctools.gif)
+
+## Wiring
+
+C0 -> SCL
+
+C1 -> SDA
+
+GND -> GND
+
+>/!\ Target must use 3v3 logic levels. If you not sure use an i2c isolator like ISO1541
+
+## Tools
+
+### Scanner
+
+Look for i2c peripherals adresses
+
+### Sniffer
+
+Spy i2c traffic
+
+### Sender
+
+Send command to i2c peripherals and read result 
+
+## TODO
+
+- [ ] Read more than 2 bytes in sender mode
+- [ ] Add 10-bits adresses support
+- [ ] Test with rate > 100khz
+- [ ] Save records
+- [ ] Play from files
+- [ ] Kicad module
+- [ ] Improve UI
+- [ ] Refactor Event Management Code
+- [ ] Add Documentation
+- [ ] Remove max data size
+- [ ] Remove max frames read size

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/application.fam

@@ -0,0 +1,13 @@
+App(
+    appid="I2C_Tools",
+    name="i2c Tools",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="i2ctools_app",
+    cdefines=["APP_I2CTOOLS"],
+    requires=["gui"],
+    stack_size=2 * 1024,
+    order=175,
+    fap_icon="i2ctools.png",
+    fap_category="GPIO",
+    fap_icon_assets="images",
+)

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2cscanner.c

@@ -0,0 +1,35 @@
+#include "i2cscanner.h"
+
+void scan_i2c_bus(i2cScanner* i2c_scanner) {
+    i2c_scanner->nb_found = 0;
+    i2c_scanner->scanned = true;
+    // Get the bus
+    furi_hal_i2c_acquire(I2C_BUS);
+    // scan
+    for(uint8_t addr = 0x01; addr <= MAX_I2C_ADDR << 1; addr++) {
+        // Check for peripherals
+        if(furi_hal_i2c_is_device_ready(I2C_BUS, addr, I2C_TIMEOUT)) {
+            // skip even 8-bit addr
+            if(addr % 2 != 0) {
+                continue;
+            }
+            // convert addr to 7-bits
+            i2c_scanner->addresses[i2c_scanner->nb_found] = addr >> 1;
+            i2c_scanner->nb_found++;
+        }
+    }
+    furi_hal_i2c_release(I2C_BUS);
+}
+
+i2cScanner* i2c_scanner_alloc() {
+    i2cScanner* i2c_scanner = malloc(sizeof(i2cScanner));
+    i2c_scanner->nb_found = 0;
+    i2c_scanner->menu_index = 0;
+    i2c_scanner->scanned = false;
+    return i2c_scanner;
+}
+
+void i2c_scanner_free(i2cScanner* i2c_scanner) {
+    furi_assert(i2c_scanner);
+    free(i2c_scanner);
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2cscanner.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <furi.h>
+#include <furi_hal.h>
+
+// I2C BUS
+#define I2C_BUS &furi_hal_i2c_handle_external
+#define I2C_TIMEOUT 3
+
+// 7 bits addresses
+#define MAX_I2C_ADDR 0x7F
+
+typedef struct {
+    uint8_t addresses[MAX_I2C_ADDR + 1];
+    uint8_t nb_found;
+    uint8_t menu_index;
+    bool scanned;
+} i2cScanner;
+
+void scan_i2c_bus(i2cScanner* i2c_scanner);
+
+i2cScanner* i2c_scanner_alloc();
+void i2c_scanner_free(i2cScanner* i2c_scanner);

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2csender.c

@@ -0,0 +1,29 @@
+#include "i2csender.h"
+
+void i2c_send(i2cSender* i2c_sender) {
+    furi_hal_i2c_acquire(I2C_BUS);
+    uint8_t adress = i2c_sender->scanner->addresses[i2c_sender->address_idx] << 1;
+    i2c_sender->error = furi_hal_i2c_trx(
+        I2C_BUS,
+        adress,
+        &i2c_sender->value,
+        sizeof(i2c_sender->value),
+        i2c_sender->recv,
+        sizeof(i2c_sender->recv),
+        I2C_TIMEOUT);
+    furi_hal_i2c_release(I2C_BUS);
+    i2c_sender->must_send = false;
+    i2c_sender->sended = true;
+}
+
+i2cSender* i2c_sender_alloc() {
+    i2cSender* i2c_sender = malloc(sizeof(i2cSender));
+    i2c_sender->must_send = false;
+    i2c_sender->sended = false;
+    return i2c_sender;
+}
+
+void i2c_sender_free(i2cSender* i2c_sender) {
+    furi_assert(i2c_sender);
+    free(i2c_sender);
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2csender.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <furi.h>
+#include <furi_hal.h>
+#include "i2cscanner.h"
+
+typedef struct {
+    uint8_t address_idx;
+    uint8_t value;
+    uint8_t recv[2];
+    bool must_send;
+    bool sended;
+    bool error;
+
+    i2cScanner* scanner;
+} i2cSender;
+
+void i2c_send();
+
+i2cSender* i2c_sender_alloc();
+void i2c_sender_free(i2cSender* i2c_sender);

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2csniffer.c

@@ -0,0 +1,101 @@
+#include "i2csniffer.h"
+
+void clear_sniffer_buffers(i2cSniffer* i2c_sniffer) {
+    furi_assert(i2c_sniffer);
+    for(uint8_t i = 0; i < MAX_RECORDS; i++) {
+        for(uint8_t j = 0; j < MAX_MESSAGE_SIZE; j++) {
+            i2c_sniffer->frames[i].ack[j] = false;
+            i2c_sniffer->frames[i].data[j] = 0;
+        }
+        i2c_sniffer->frames[i].bit_index = 0;
+        i2c_sniffer->frames[i].data_index = 0;
+    }
+    i2c_sniffer->frame_index = 0;
+    i2c_sniffer->state = I2C_BUS_FREE;
+    i2c_sniffer->first = true;
+}
+
+void start_interrupts(i2cSniffer* i2c_sniffer) {
+    furi_assert(i2c_sniffer);
+    furi_hal_gpio_init(pinSCL, GpioModeInterruptRise, GpioPullNo, GpioSpeedHigh);
+    furi_hal_gpio_add_int_callback(pinSCL, SCLcallback, i2c_sniffer);
+
+    // Add Rise and Fall Interrupt on SDA pin
+    furi_hal_gpio_init(pinSDA, GpioModeInterruptRiseFall, GpioPullNo, GpioSpeedHigh);
+    furi_hal_gpio_add_int_callback(pinSDA, SDAcallback, i2c_sniffer);
+}
+
+void stop_interrupts() {
+    furi_hal_gpio_remove_int_callback(pinSCL);
+    furi_hal_gpio_remove_int_callback(pinSDA);
+    // Reset GPIO pins to default state
+    furi_hal_gpio_init(pinSCL, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_init(pinSDA, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+}
+
+// Called on Fallin/Rising SDA
+// Used to monitor i2c bus state
+void SDAcallback(void* _i2c_sniffer) {
+    i2cSniffer* i2c_sniffer = _i2c_sniffer;
+    // SCL is low maybe cclock strecching
+    if(furi_hal_gpio_read(pinSCL) == false) {
+        return;
+    }
+    // Check for stop condition: SDA rising while SCL is High
+    if(i2c_sniffer->state == I2C_BUS_STARTED) {
+        if(furi_hal_gpio_read(pinSDA) == true) {
+            i2c_sniffer->state = I2C_BUS_FREE;
+        }
+    }
+    // Check for start condition: SDA falling while SCL is high
+    else if(furi_hal_gpio_read(pinSDA) == false) {
+        i2c_sniffer->state = I2C_BUS_STARTED;
+        if(i2c_sniffer->first) {
+            i2c_sniffer->first = false;
+            return;
+        }
+        i2c_sniffer->frame_index++;
+        if(i2c_sniffer->frame_index >= MAX_RECORDS) {
+            clear_sniffer_buffers(i2c_sniffer);
+        }
+    }
+    return;
+}
+
+// Called on Rising SCL
+// Used to read bus datas
+void SCLcallback(void* _i2c_sniffer) {
+    i2cSniffer* i2c_sniffer = _i2c_sniffer;
+    if(i2c_sniffer->state == I2C_BUS_FREE) {
+        return;
+    }
+    uint8_t frame = i2c_sniffer->frame_index;
+    uint8_t bit = i2c_sniffer->frames[frame].bit_index;
+    uint8_t data_idx = i2c_sniffer->frames[frame].data_index;
+    if(bit < 8) {
+        i2c_sniffer->frames[frame].data[data_idx] <<= 1;
+        i2c_sniffer->frames[frame].data[data_idx] |= (int)furi_hal_gpio_read(pinSDA);
+        i2c_sniffer->frames[frame].bit_index++;
+    } else {
+        i2c_sniffer->frames[frame].ack[data_idx] = !furi_hal_gpio_read(pinSDA);
+        i2c_sniffer->frames[frame].data_index++;
+        i2c_sniffer->frames[frame].bit_index = 0;
+    }
+}
+
+i2cSniffer* i2c_sniffer_alloc() {
+    i2cSniffer* i2c_sniffer = malloc(sizeof(i2cSniffer));
+    i2c_sniffer->started = false;
+    i2c_sniffer->row_index = 0;
+    i2c_sniffer->menu_index = 0;
+    clear_sniffer_buffers(i2c_sniffer);
+    return i2c_sniffer;
+}
+
+void i2c_sniffer_free(i2cSniffer* i2c_sniffer) {
+    furi_assert(i2c_sniffer);
+    if(i2c_sniffer->started) {
+        stop_interrupts();
+    }
+    free(i2c_sniffer);
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2csniffer.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <furi.h>
+#include <furi_hal.h>
+
+// I2C Pins
+#define pinSCL &gpio_ext_pc0
+#define pinSDA &gpio_ext_pc1
+
+// Bus States
+typedef enum { I2C_BUS_FREE, I2C_BUS_STARTED } i2cBusStates;
+
+// Max read size of i2c frame by message
+// Arbitraly defined
+// They're not real limit to maximum frames send
+#define MAX_MESSAGE_SIZE 128
+
+// Nb of records
+#define MAX_RECORDS 128
+
+/// @brief Struct used to store our reads
+typedef struct {
+    uint8_t data[MAX_MESSAGE_SIZE];
+    bool ack[MAX_MESSAGE_SIZE];
+    uint8_t bit_index;
+    uint8_t data_index;
+} i2cFrame;
+
+typedef struct {
+    bool started;
+    bool first;
+    i2cBusStates state;
+    i2cFrame frames[MAX_RECORDS];
+    uint8_t frame_index;
+    uint8_t menu_index;
+    uint8_t row_index;
+} i2cSniffer;
+
+void clear_sniffer_buffers(i2cSniffer* i2c_sniffer);
+void start_interrupts(i2cSniffer* i2c_sniffer);
+void stop_interrupts();
+void SDAcallback(void* _i2c_sniffer);
+void SCLcallback(void* _i2c_sniffer);
+
+i2cSniffer* i2c_sniffer_alloc();
+void i2c_sniffer_free(i2cSniffer* i2c_sniffer);

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2ctools.c

@@ -0,0 +1,222 @@
+#include "i2ctools_i.h"
+
+void i2ctools_draw_callback(Canvas* canvas, void* ctx) {
+    i2cTools* i2ctools = acquire_mutex((ValueMutex*)ctx, 25);
+
+    switch(i2ctools->main_view->current_view) {
+    case MAIN_VIEW:
+        draw_main_view(canvas, i2ctools->main_view);
+        break;
+
+    case SCAN_VIEW:
+        draw_scanner_view(canvas, i2ctools->scanner);
+        break;
+
+    case SNIFF_VIEW:
+        draw_sniffer_view(canvas, i2ctools->sniffer);
+        break;
+
+    case SEND_VIEW:
+        draw_sender_view(canvas, i2ctools->sender);
+        break;
+
+    default:
+        break;
+    }
+    release_mutex((ValueMutex*)ctx, i2ctools);
+}
+
+void i2ctools_input_callback(InputEvent* input_event, void* ctx) {
+    furi_assert(ctx);
+    FuriMessageQueue* event_queue = ctx;
+    furi_message_queue_put(event_queue, input_event, FuriWaitForever);
+}
+
+int32_t i2ctools_app(void* p) {
+    UNUSED(p);
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
+
+    // Alloc i2ctools
+    i2cTools* i2ctools = malloc(sizeof(i2cTools));
+    ValueMutex i2ctools_mutex;
+    if(!init_mutex(&i2ctools_mutex, i2ctools, sizeof(i2cTools))) {
+        FURI_LOG_E(APP_NAME, "cannot create mutex\r\n");
+        free(i2ctools);
+        return -1;
+    }
+
+    // Alloc viewport
+    i2ctools->view_port = view_port_alloc();
+    view_port_draw_callback_set(i2ctools->view_port, i2ctools_draw_callback, &i2ctools_mutex);
+    view_port_input_callback_set(i2ctools->view_port, i2ctools_input_callback, event_queue);
+
+    // Register view port in GUI
+    Gui* gui = furi_record_open(RECORD_GUI);
+    gui_add_view_port(gui, i2ctools->view_port, GuiLayerFullscreen);
+
+    InputEvent event;
+
+    i2ctools->main_view = i2c_main_view_alloc();
+
+    i2ctools->sniffer = i2c_sniffer_alloc();
+    i2ctools->sniffer->menu_index = 0;
+
+    i2ctools->scanner = i2c_scanner_alloc();
+
+    i2ctools->sender = i2c_sender_alloc();
+    // Share scanner with sender
+    i2ctools->sender->scanner = i2ctools->scanner;
+
+    while(furi_message_queue_get(event_queue, &event, FuriWaitForever) == FuriStatusOk) {
+        // Back
+        if(event.key == InputKeyBack && event.type == InputTypeRelease) {
+            if(i2ctools->main_view->current_view == MAIN_VIEW) {
+                break;
+            } else {
+                if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                    stop_interrupts();
+                    i2ctools->sniffer->started = false;
+                    i2ctools->sniffer->state = I2C_BUS_FREE;
+                }
+                i2ctools->main_view->current_view = MAIN_VIEW;
+            }
+        }
+        // Up
+        else if(event.key == InputKeyUp && event.type == InputTypeRelease) {
+            if(i2ctools->main_view->current_view == MAIN_VIEW) {
+                if((i2ctools->main_view->menu_index > SCAN_VIEW)) {
+                    i2ctools->main_view->menu_index--;
+                }
+            } else if(i2ctools->main_view->current_view == SCAN_VIEW) {
+                if(i2ctools->scanner->menu_index > 0) {
+                    i2ctools->scanner->menu_index--;
+                }
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if(i2ctools->sniffer->row_index > 0) {
+                    i2ctools->sniffer->row_index--;
+                }
+            } else if(i2ctools->main_view->current_view == SEND_VIEW) {
+                if(i2ctools->sender->value < 0xFF) {
+                    i2ctools->sender->value++;
+                    i2ctools->sender->sended = false;
+                }
+            }
+        }
+        // Long Up
+        else if(
+            event.key == InputKeyUp &&
+            (event.type == InputTypeLong || event.type == InputTypeRepeat)) {
+            if(i2ctools->main_view->current_view == SCAN_VIEW) {
+                if(i2ctools->scanner->menu_index > 5) {
+                    i2ctools->scanner->menu_index -= 5;
+                }
+            } else if(i2ctools->main_view->current_view == SEND_VIEW) {
+                if(i2ctools->sender->value < 0xF9) {
+                    i2ctools->sender->value += 5;
+                    i2ctools->sender->sended = false;
+                }
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if(i2ctools->sniffer->row_index > 5) {
+                    i2ctools->sniffer->row_index -= 5;
+                } else {
+                    i2ctools->sniffer->row_index = 0;
+                }
+            }
+        }
+        // Down
+        else if(event.key == InputKeyDown && event.type == InputTypeRelease) {
+            if(i2ctools->main_view->current_view == MAIN_VIEW) {
+                if(i2ctools->main_view->menu_index < MENU_SIZE - 1) {
+                    i2ctools->main_view->menu_index++;
+                }
+            } else if(i2ctools->main_view->current_view == SCAN_VIEW) {
+                if(i2ctools->scanner->menu_index < ((int)i2ctools->scanner->nb_found / 3)) {
+                    i2ctools->scanner->menu_index++;
+                }
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if((i2ctools->sniffer->row_index + 3) <
+                   (int)i2ctools->sniffer->frames[i2ctools->sniffer->menu_index].data_index) {
+                    i2ctools->sniffer->row_index++;
+                }
+            } else if(i2ctools->main_view->current_view == SEND_VIEW) {
+                if(i2ctools->sender->value > 0x00) {
+                    i2ctools->sender->value--;
+                    i2ctools->sender->sended = false;
+                }
+            }
+        }
+        // Long Down
+        else if(
+            event.key == InputKeyDown &&
+            (event.type == InputTypeLong || event.type == InputTypeRepeat)) {
+            if(i2ctools->main_view->current_view == SEND_VIEW) {
+                if(i2ctools->sender->value > 0x05) {
+                    i2ctools->sender->value -= 5;
+                    i2ctools->sender->sended = false;
+                } else {
+                    i2ctools->sender->value = 0;
+                    i2ctools->sender->sended = false;
+                }
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if((i2ctools->sniffer->row_index + 8) <
+                   (int)i2ctools->sniffer->frames[i2ctools->sniffer->menu_index].data_index) {
+                    i2ctools->sniffer->row_index += 5;
+                }
+            }
+
+        } else if(event.key == InputKeyOk && event.type == InputTypeRelease) {
+            if(i2ctools->main_view->current_view == MAIN_VIEW) {
+                i2ctools->main_view->current_view = i2ctools->main_view->menu_index;
+            } else if(i2ctools->main_view->current_view == SCAN_VIEW) {
+                scan_i2c_bus(i2ctools->scanner);
+            } else if(i2ctools->main_view->current_view == SEND_VIEW) {
+                i2ctools->sender->must_send = true;
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if(i2ctools->sniffer->started) {
+                    stop_interrupts();
+                    i2ctools->sniffer->started = false;
+                    i2ctools->sniffer->state = I2C_BUS_FREE;
+                } else {
+                    start_interrupts(i2ctools->sniffer);
+                    i2ctools->sniffer->started = true;
+                    i2ctools->sniffer->state = I2C_BUS_FREE;
+                }
+            }
+        } else if(event.key == InputKeyRight && event.type == InputTypeRelease) {
+            if(i2ctools->main_view->current_view == SEND_VIEW) {
+                if(i2ctools->sender->address_idx < (i2ctools->scanner->nb_found - 1)) {
+                    i2ctools->sender->address_idx++;
+                    i2ctools->sender->sended = false;
+                }
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if(i2ctools->sniffer->menu_index < i2ctools->sniffer->frame_index) {
+                    i2ctools->sniffer->menu_index++;
+                    i2ctools->sniffer->row_index = 0;
+                }
+            }
+        } else if(event.key == InputKeyLeft && event.type == InputTypeRelease) {
+            if(i2ctools->main_view->current_view == SEND_VIEW) {
+                if(i2ctools->sender->address_idx > 0) {
+                    i2ctools->sender->address_idx--;
+                    i2ctools->sender->sended = false;
+                }
+            } else if(i2ctools->main_view->current_view == SNIFF_VIEW) {
+                if(i2ctools->sniffer->menu_index > 0) {
+                    i2ctools->sniffer->menu_index--;
+                    i2ctools->sniffer->row_index = 0;
+                }
+            }
+        }
+        view_port_update(i2ctools->view_port);
+    }
+    gui_remove_view_port(gui, i2ctools->view_port);
+    view_port_free(i2ctools->view_port);
+    furi_message_queue_free(event_queue);
+    i2c_sniffer_free(i2ctools->sniffer);
+    i2c_scanner_free(i2ctools->scanner);
+    i2c_sender_free(i2ctools->sender);
+    i2c_main_view_free(i2ctools->main_view);
+    free(i2ctools);
+    furi_record_close(RECORD_GUI);
+    return 0;
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/i2ctools_i.h

@@ -0,0 +1,22 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+
+#include "i2csniffer.h"
+#include "i2cscanner.h"
+#include "i2csender.h"
+#include "views/main_view.h"
+#include "views/sniffer_view.h"
+#include "views/scanner_view.h"
+#include "views/sender_view.h"
+
+// App datas
+typedef struct {
+    ViewPort* view_port;
+    i2cMainView* main_view;
+
+    i2cScanner* scanner;
+    i2cSniffer* sniffer;
+    i2cSender* sender;
+} i2cTools;

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/main_view.c

@@ -0,0 +1,62 @@
+#include "main_view.h"
+
+void draw_main_view(Canvas* canvas, i2cMainView* main_view) {
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_rframe(canvas, 0, 0, 128, 64, 3);
+    canvas_draw_icon(canvas, 2, 2, &I_i2ctools_main_76x59);
+    canvas_set_font(canvas, FontPrimary);
+
+    switch(main_view->menu_index) {
+    case SCAN_VIEW:
+        canvas_set_color(canvas, ColorBlack);
+        canvas_draw_str_aligned(
+            canvas, SNIFF_MENU_X, SNIFF_MENU_Y, AlignLeft, AlignTop, SNIFF_MENU_TEXT);
+        canvas_draw_str_aligned(
+            canvas, SEND_MENU_X, SEND_MENU_Y, AlignLeft, AlignTop, SEND_MENU_TEXT);
+        canvas_draw_rbox(canvas, 80, SCAN_MENU_Y - 2, 43, 13, 3);
+        canvas_set_color(canvas, ColorWhite);
+        canvas_draw_str_aligned(
+            canvas, SCAN_MENU_X, SCAN_MENU_Y, AlignLeft, AlignTop, SCAN_MENU_TEXT);
+        break;
+
+    case SNIFF_VIEW:
+        canvas_set_color(canvas, ColorBlack);
+        canvas_draw_str_aligned(
+            canvas, SCAN_MENU_X, SCAN_MENU_Y, AlignLeft, AlignTop, SCAN_MENU_TEXT);
+        canvas_draw_str_aligned(
+            canvas, SEND_MENU_X, SEND_MENU_Y, AlignLeft, AlignTop, SEND_MENU_TEXT);
+        canvas_draw_rbox(canvas, 80, SNIFF_MENU_Y - 2, 43, 13, 3);
+        canvas_set_color(canvas, ColorWhite);
+        canvas_draw_str_aligned(
+            canvas, SNIFF_MENU_X, SNIFF_MENU_Y, AlignLeft, AlignTop, SNIFF_MENU_TEXT);
+        break;
+
+    case SEND_VIEW:
+        canvas_set_color(canvas, ColorBlack);
+        canvas_draw_str_aligned(
+            canvas, SCAN_MENU_X, SCAN_MENU_Y, AlignLeft, AlignTop, SCAN_MENU_TEXT);
+        canvas_draw_str_aligned(
+            canvas, SNIFF_MENU_X, SNIFF_MENU_Y, AlignLeft, AlignTop, SNIFF_MENU_TEXT);
+        canvas_draw_rbox(canvas, 80, SEND_MENU_Y - 2, 43, 13, 3);
+        canvas_set_color(canvas, ColorWhite);
+        canvas_draw_str_aligned(
+            canvas, SEND_MENU_X, SEND_MENU_Y, AlignLeft, AlignTop, SEND_MENU_TEXT);
+        break;
+
+    default:
+        break;
+    }
+}
+
+i2cMainView* i2c_main_view_alloc() {
+    i2cMainView* main_view = malloc(sizeof(i2cMainView));
+    main_view->menu_index = SCAN_VIEW;
+    main_view->current_view = MAIN_VIEW;
+    return main_view;
+}
+
+void i2c_main_view_free(i2cMainView* main_view) {
+    furi_assert(main_view);
+    free(main_view);
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/main_view.h

@@ -0,0 +1,38 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <I2C_Tools_icons.h>
+#define APP_NAME "I2C Tools"
+
+#define SCAN_MENU_TEXT "Scan"
+#define SCAN_MENU_X 90
+#define SCAN_MENU_Y 13
+
+#define SNIFF_MENU_TEXT "Sniff"
+#define SNIFF_MENU_X 90
+#define SNIFF_MENU_Y 27
+
+#define SEND_MENU_TEXT "Send"
+#define SEND_MENU_X 90
+#define SEND_MENU_Y 41
+
+// Menu
+typedef enum {
+    MAIN_VIEW,
+    SCAN_VIEW,
+    SNIFF_VIEW,
+    SEND_VIEW,
+
+    /* Know menu Size*/
+    MENU_SIZE
+} i2cToolsViews;
+
+typedef struct {
+    i2cToolsViews current_view;
+    i2cToolsViews menu_index;
+} i2cMainView;
+
+void draw_main_view(Canvas* canvas, i2cMainView* main_view);
+
+i2cMainView* i2c_main_view_alloc();
+void i2c_main_view_free(i2cMainView* main_view);

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/scanner_view.c

@@ -0,0 +1,47 @@
+#include "scanner_view.h"
+
+void draw_scanner_view(Canvas* canvas, i2cScanner* i2c_scanner) {
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_rframe(canvas, 0, 0, 128, 64, 3);
+
+    char count_text[46];
+    char count_text_fmt[] = "Peripherals Found: %d";
+    canvas_set_font(canvas, FontSecondary);
+    snprintf(count_text, sizeof(count_text), count_text_fmt, (int)i2c_scanner->nb_found);
+    canvas_draw_str_aligned(canvas, 3, 3, AlignLeft, AlignTop, count_text);
+    uint8_t x_pos = 0;
+    uint8_t y_pos = 0;
+    uint8_t idx_to_print = 0;
+    for(uint8_t i = 0; i < (int)i2c_scanner->nb_found; i++) {
+        idx_to_print = i + i2c_scanner->menu_index * 3;
+        if(idx_to_print >= MAX_I2C_ADDR) {
+            break;
+        }
+        snprintf(
+            count_text, sizeof(count_text), "0x%02x ", (int)i2c_scanner->addresses[idx_to_print]);
+        const uint8_t x_start = 3;
+        if(i < 4) {
+            x_pos = x_start + (i * 26);
+            y_pos = 15;
+        } else if(i < 8) {
+            x_pos = x_start + ((i - 4) * 26);
+            y_pos = 25;
+        } else if(i < 12) {
+            x_pos = x_start + ((i - 8) * 26);
+            y_pos = 35;
+        } else {
+            break;
+        }
+        canvas_draw_str_aligned(canvas, x_pos, y_pos, AlignLeft, AlignTop, count_text);
+    }
+    // Right cursor
+    y_pos = 14 + i2c_scanner->menu_index;
+    canvas_draw_rbox(canvas, 125, y_pos, 3, 10, 1);
+
+    // Button
+    canvas_draw_rbox(canvas, 45, 48, 45, 13, 3);
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_icon(canvas, 50, 50, &I_Ok_btn_9x9);
+    canvas_draw_str_aligned(canvas, 62, 51, AlignLeft, AlignTop, "Scan");
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/scanner_view.h

@@ -0,0 +1,9 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <I2C_Tools_icons.h>
+#include "../i2cscanner.h"
+
+#define SCAN_TEXT "SCAN"
+
+void draw_scanner_view(Canvas* canvas, i2cScanner* i2c_scanner);

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/sender_view.c

@@ -0,0 +1,70 @@
+#include "sender_view.h"
+
+void draw_sender_view(Canvas* canvas, i2cSender* i2c_sender) {
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_rframe(canvas, 0, 0, 128, 64, 3);
+
+    if(!i2c_sender->scanner->scanned) {
+        scan_i2c_bus(i2c_sender->scanner);
+    }
+
+    canvas_set_font(canvas, FontSecondary);
+    if(i2c_sender->scanner->nb_found <= 0) {
+        canvas_draw_str_aligned(canvas, 20, 5, AlignLeft, AlignTop, "No peripherals found");
+        return;
+    }
+    // Send Button
+    canvas_draw_rbox(canvas, 45, 48, 45, 13, 3);
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_icon(canvas, 50, 50, &I_Ok_btn_9x9);
+    canvas_draw_str_aligned(canvas, 62, 51, AlignLeft, AlignTop, "Send");
+    // Addr
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_str_aligned(canvas, 3, 5, AlignLeft, AlignTop, "Addr: ");
+    canvas_draw_icon(canvas, 33, 5, &I_ButtonLeft_4x7);
+    canvas_draw_icon(canvas, 68, 5, &I_ButtonRight_4x7);
+    char addr_text[8];
+    snprintf(
+        addr_text,
+        sizeof(addr_text),
+        "0x%02x",
+        (int)i2c_sender->scanner->addresses[i2c_sender->address_idx]);
+    canvas_draw_str_aligned(canvas, 43, 5, AlignLeft, AlignTop, addr_text);
+    // Value
+    canvas_draw_str_aligned(canvas, 3, 15, AlignLeft, AlignTop, "Value: ");
+    canvas_draw_icon(canvas, 33, 17, &I_ButtonUp_7x4);
+    canvas_draw_icon(canvas, 68, 17, &I_ButtonDown_7x4);
+    snprintf(addr_text, sizeof(addr_text), "0x%02x", (int)i2c_sender->value);
+    canvas_draw_str_aligned(canvas, 43, 15, AlignLeft, AlignTop, addr_text);
+    if(i2c_sender->must_send) {
+        i2c_send(i2c_sender);
+    }
+    // Result
+    canvas_draw_str_aligned(canvas, 3, 25, AlignLeft, AlignTop, "Result: ");
+    if(i2c_sender->sended) {
+        uint8_t row = 1;
+        uint8_t column = 1;
+        const uint8_t x_min = 3;
+        const uint8_t y_min = 25;
+        uint8_t x_pos = 0;
+        uint8_t y_pos = 0;
+        for(uint8_t i = 0; i < sizeof(i2c_sender->recv); i++) {
+            x_pos = x_min + (column - 1) * 35;
+            if(row == 1) {
+                x_pos += 40;
+            }
+            y_pos = y_min + (row - 1) * 10;
+            snprintf(addr_text, sizeof(addr_text), "0x%02x", (int)i2c_sender->recv[i]);
+            canvas_draw_str_aligned(canvas, x_pos, y_pos, AlignLeft, AlignTop, addr_text);
+            column++;
+            if((row > 1 && column > 3) || (row == 1 && column > 2)) {
+                column = 1;
+                row++;
+            }
+            if(row > 2) {
+                break;
+            }
+        }
+    }
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/sender_view.h

@@ -0,0 +1,9 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <I2C_Tools_icons.h>
+#include "../i2csender.h"
+
+#define SEND_TEXT "SEND"
+
+void draw_sender_view(Canvas* canvas, i2cSender* i2c_sender);

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/sniffer_view.c

@@ -0,0 +1,92 @@
+#include "sniffer_view.h"
+
+void draw_sniffer_view(Canvas* canvas, i2cSniffer* i2c_sniffer) {
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_rframe(canvas, 0, 0, 128, 64, 3);
+    canvas_set_font(canvas, FontSecondary);
+
+    // Button
+    canvas_draw_rbox(canvas, 40, 48, 45, 13, 3);
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_icon(canvas, 45, 50, &I_Ok_btn_9x9);
+    if(!i2c_sniffer->started) {
+        canvas_draw_str_aligned(canvas, 57, 51, AlignLeft, AlignTop, "Start");
+    } else {
+        canvas_draw_str_aligned(canvas, 57, 51, AlignLeft, AlignTop, "Stop");
+    }
+    canvas_set_color(canvas, ColorBlack);
+    if(i2c_sniffer->first) {
+        canvas_draw_str_aligned(canvas, 30, 3, AlignLeft, AlignTop, "Nothing Recorded");
+        return;
+    }
+    char text_buffer[10];
+    // nbFrame text
+    canvas_draw_str_aligned(canvas, 3, 3, AlignLeft, AlignTop, "Frame: ");
+    snprintf(
+        text_buffer,
+        sizeof(text_buffer),
+        "%d/%d",
+        (int)i2c_sniffer->menu_index + 1,
+        (int)i2c_sniffer->frame_index + 1);
+    canvas_draw_str_aligned(canvas, 38, 3, AlignLeft, AlignTop, text_buffer);
+    // Address text
+    snprintf(
+        text_buffer,
+        sizeof(text_buffer),
+        "0x%02x",
+        (int)(i2c_sniffer->frames[i2c_sniffer->menu_index].data[0] >> 1));
+    canvas_draw_str_aligned(canvas, 3, 13, AlignLeft, AlignTop, "Addr: ");
+    canvas_draw_str_aligned(canvas, 30, 13, AlignLeft, AlignTop, text_buffer);
+    // R/W
+    if((int)(i2c_sniffer->frames[i2c_sniffer->menu_index].data[0]) % 2 == 0) {
+        canvas_draw_str_aligned(canvas, 58, 13, AlignLeft, AlignTop, "Write");
+    } else {
+        canvas_draw_str_aligned(canvas, 58, 13, AlignLeft, AlignTop, "Read");
+    }
+    // ACK
+    if(i2c_sniffer->frames[i2c_sniffer->menu_index].ack[0]) {
+        canvas_draw_str_aligned(canvas, 90, 13, AlignLeft, AlignTop, "ACK");
+    } else {
+        canvas_draw_str_aligned(canvas, 90, 13, AlignLeft, AlignTop, "NACK");
+    }
+    // Frames content
+    const uint8_t x_min = 3;
+    const uint8_t y_min = 23;
+    uint8_t x_pos = 0;
+    uint8_t y_pos = 0;
+    uint8_t row = 1;
+    uint8_t column = 1;
+    uint8_t frame_size = i2c_sniffer->frames[i2c_sniffer->menu_index].data_index;
+    uint8_t offset = i2c_sniffer->row_index;
+    if(i2c_sniffer->row_index > 0) {
+        offset += 1;
+    }
+    canvas_draw_str_aligned(canvas, x_min, y_min, AlignLeft, AlignTop, "Data:");
+    for(uint8_t i = 1 + offset; i < frame_size; i++) {
+        snprintf(
+            text_buffer,
+            sizeof(text_buffer),
+            "0x%02x",
+            (int)i2c_sniffer->frames[i2c_sniffer->menu_index].data[i]);
+        x_pos = x_min + (column - 1) * 35;
+        if(row == 1) {
+            x_pos += 30;
+        }
+        y_pos = y_min + (row - 1) * 10;
+        canvas_draw_str_aligned(canvas, x_pos, y_pos, AlignLeft, AlignTop, text_buffer);
+        if(i2c_sniffer->frames[i2c_sniffer->menu_index].ack[i]) {
+            canvas_draw_str_aligned(canvas, x_pos + 24, y_pos, AlignLeft, AlignTop, "A");
+        } else {
+            canvas_draw_str_aligned(canvas, x_pos + 24, y_pos, AlignLeft, AlignTop, "N");
+        }
+        column++;
+        if((row > 1 && column > 3) || (row == 1 && column > 2)) {
+            column = 1;
+            row++;
+        }
+        if(row > 2) {
+            break;
+        }
+    }
+}

Applications/Official/DEV_FW/source/grnch/flipper_i2ctools/views/sniffer_view.h

@@ -0,0 +1,9 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <I2C_Tools_icons.h>
+#include "../i2csniffer.h"
+
+#define SNIFF_TEXT "SNIFF"
+
+void draw_sniffer_view(Canvas* canvas, i2cSniffer* i2c_sniffer);