move base pack here

Author: xMasterX

LICENSE

@@ -0,0 +1,44 @@
+# 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

README.md

@@ -0,0 +1,15 @@
+App(
+    appid="i2ctools",
+    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.1",
+    fap_description="Set of i2c tools",
+)

application.fam

@@ -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);
+}

i2cscanner.c

@@ -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);

i2cscanner.h

@@ -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);
+}

i2csender.c

@@ -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);

i2csender.h

@@ -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);
+}

i2csniffer.c

@@ -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);