throw away already in catalog app

main_apps_sources/flipper_i2ctools/README.md

@@ -1,44 +0,0 @@
-# flipperzero-i2ctools
-
-[Original link](https://github.com/NaejEL/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

main_apps_sources/flipper_i2ctools/application.fam

@@ -1,15 +0,0 @@
-App(
-    appid="i2c_tools",
-    name="[GPIO] i2c Tools",
-    apptype=FlipperAppType.EXTERNAL,
-    entry_point="i2ctools_app",
-    requires=["gui"],
-    stack_size=2 * 1024,
-    order=175,
-    fap_icon="i2ctools.png",
-    fap_category="GPIO",
-    fap_icon_assets="images",
-    fap_author="@NaejEL",
-    fap_version="1.0",
-    fap_description="Set of i2c tools",
-)

main_apps_sources/flipper_i2ctools/i2cscanner.c

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

main_apps_sources/flipper_i2ctools/i2cscanner.h

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

main_apps_sources/flipper_i2ctools/i2csender.c

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

main_apps_sources/flipper_i2ctools/i2csender.h

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

main_apps_sources/flipper_i2ctools/i2csniffer.c

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

main_apps_sources/flipper_i2ctools/i2csniffer.h

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

main_apps_sources/flipper_i2ctools/i2ctools.c

@@ -1,225 +0,0 @@
-#include "i2ctools_i.h"
-
-void i2ctools_draw_callback(Canvas* canvas, void* ctx) {
-    furi_assert(ctx);
-    i2cTools* i2ctools = ctx;
-    furi_mutex_acquire(i2ctools->mutex, FuriWaitForever);
-
-    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;
-    }
-    furi_mutex_release(i2ctools->mutex);
-}
-
-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));
-    i2ctools->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-    if(!i2ctools->mutex) {
-        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);
-    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);
-    furi_mutex_free(i2ctools->mutex);
-    free(i2ctools);
-    furi_record_close(RECORD_GUI);
-    return 0;
-}

main_apps_sources/flipper_i2ctools/i2ctools_i.h

@@ -1,23 +0,0 @@
-#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 {
-    FuriMutex* mutex;
-    ViewPort* view_port;
-    i2cMainView* main_view;
-
-    i2cScanner* scanner;
-    i2cSniffer* sniffer;
-    i2cSender* sender;
-} i2cTools;

main_apps_sources/flipper_i2ctools/views/main_view.c

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

main_apps_sources/flipper_i2ctools/views/main_view.h

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

main_apps_sources/flipper_i2ctools/views/scanner_view.c

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

main_apps_sources/flipper_i2ctools/views/scanner_view.h

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

main_apps_sources/flipper_i2ctools/views/sender_view.c

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

main_apps_sources/flipper_i2ctools/views/sender_view.h

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

main_apps_sources/flipper_i2ctools/views/sniffer_view.c

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

main_apps_sources/flipper_i2ctools/views/sniffer_view.h

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