DEV Community: Daniel Elias Diamon Vazquez

EEPROM Flasher: Android Native TL866 / T48 / T56 Programmer via USB-OTG without Root

Daniel Elias Diamon Vazquez — Tue, 20 Oct 2026 20:47:20 +0000

EEPROM Flasher: Flashing Chips with TL866 / T48 / T56 Programmers from Android (minipro Engine)

When servicing arcade boards, vintage computers, automotive ECUs, or motherboard BIOS chips, universal programmers like the Xgecu TL866II+, TL866A, TL866CS, T48, and T56 are essential bench tools. However, they traditionally bind engineers to a Windows PC or Linux desktop.

To make chip dumping and flashing completely mobile, I developed EEPROM Flasher, an open-source native Android application that runs the open-source minipro engine directly over USB-OTG without requiring root access.

🛠️ Architecture: Porting minipro & libusb to Android

Running hardware programmers on Android without root requires overcoming strict kernel permissions on /dev/bus/usb.

EEPROM Flasher solves this with a custom JNI bridge:

  ┌────────────────────────────────────────┐
  │         Android Application (Java)     │
  │    (UI, Hex Viewer, Diff Comparator)   │
  └───────────────────┬────────────────────┘
                      │ Requests USB Permission via Android SDK
                      ▼
  ┌────────────────────────────────────────┐
  │   Android USB Host API (UsbDeviceConnection) │
  │        (Obtains native File Descriptor)│
  └───────────────────┬────────────────────┘
                      │ Passes raw FD via JNI
                      ▼
  ┌────────────────────────────────────────┐
  │       Custom libusb Native Layer       │
  │ (libusb_wrap_sys_device / C++ ARM64)   │
  └───────────────────┬────────────────────┘
                      │ Direct USB Bulk / Control Transfers
                      ▼
  ┌────────────────────────────────────────┐
  │         minipro Engine (Native)        │
  │ (Chip ID, Read, Write, Erase, Verify)  │
  └───────────────────┬────────────────────┘
                      │ USB-OTG Cable
                      ▼
  ┌────────────────────────────────────────┐
  │ Hardware Programmer (TL866 / T48 / T56)│
  │             [ ZIF40 Socket ]           │
  │                   ▼                    │
  │   Target Chip (24C, 25Q, 27C, 93C...)  │
  └────────────────────────────────────────┘

✨ Key Features & Capabilities

Broad Programmer Support: 100% compatible with TL866II Plus, TL866A, TL866CS, T48 (TL866-3G), T56, and T76 programmers.
Auto-Detect Chip: Automatically queries silicon signatures and device IDs.
Interactive Pinout Viewer: Custom canvas-rendered pinout schematics for ZIF40, SOIC8, 24Cxx, 93Cxx, DIP32, ICSP, AVR ISP, and PLCC32 sockets.
Hex Viewer & Diff Comparator: Real-time hex inspection and side-by-side binary comparison with change percentage metrics.
Storage Access Framework (SAF): Directly load and save .bin, .hex, and .rom dumps to internal storage, SD cards, or cloud drives.
Interactive Virtual Terminal: Real-time console output displaying low-level minipro logs and status registers.

📥 Downloads & Source Code

🌐 Personal Portfolio & Web: todoandroid.42web.io
💻 GitHub Repository: Danielk10/Lector-De-Memorias
📦 Download Releases (APK): v1.0.0-pre Release on GitHub

Feedback, bug reports, and chip tests on T48/T56 hardware are warmly welcomed on the GitHub repository!

Universal I2C & SPI EEPROM Flasher using Android and PIC16F628A

Daniel Elias Diamon Vazquez — Tue, 20 Oct 2026 20:39:12 +0000

Universal I2C & SPI EEPROM Flasher on Android using a PIC16F628A Bridge

Reading and writing configuration EEPROMs (such as automotive modules, TV motherboards, or industrial sensors) is a routine task in electronics repair.

OTG Flash EEPROM turns an Android smartphone into a universal memory reader and writer, utilizing a Microchip PIC16F628A as an intelligent USB-to-I2C/SPI hardware bridge.

💡 Capabilities

I2C EEPROM Support: 24C01 through 24C512 (128 bytes to 256 KB / 2 Mbit).
SPI Flash Support: 25LC series (128 bytes to 4 MB).
Mobile Hex Viewer: Inspect data in real-time as bytes are read off the memory chip.
File Export: Save memory dumps directly to .bin and .hex files on the device storage for easy backup and firmware editing.

📂 Source Code & Schematics

🌐 Personal Web & Portfolio: todoandroid.42web.io
💻 GitHub Repository: Danielk10/Comunicador-OTG-TTL-Android

Check out the pinouts, firmware code, and Android app source on GitHub!

C PIC Compiler: Native Multi-Architecture C & ASM Development on Android

Daniel Elias Diamon Vazquez — Tue, 20 Oct 2026 20:34:06 +0000

C PIC Compiler: Compile Microcontroller C and ASM Firmware on Android

Writing and compiling embedded firmware on mobile devices is usually limited by complex cloud dependencies or lack of toolchains.

C PIC Compiler is a standalone, offline mobile development environment designed for embedded engineers, makers, and students to write, build, and simulate Microchip PIC firmware directly on Android devices.

⚙️ Built on Industry-Standard Compilers

The toolchain packages native ARM64 binaries compiled directly for Android:

SDCC 4.5.0: Small Device C Compiler targeting 8-bit and 16-bit architectures.
GPUTILS 1.5.2: Complete GNU PIC Utilities suite (gpasm, gplink, gplib).
ucSim: Integrated simulation engine to debug registers and logic before burning to silicon.
Generates Standard Outputs: Builds .hex, .ihx, .bin, .map, and .lst files completely offline without an internet connection.

🔗 Links and Documentation

🌐 Portfolio & Web: todoandroid.42web.io
💻 GitHub Repository: Danielk10/C-PIC

Feedback on supported chip architectures and compiler optimization flags is warmly welcomed!

Turn Android into a Physical USB Keyboard for PC BIOS / UEFI with Arduino

Daniel Elias Diamon Vazquez — Tue, 20 Oct 2026 20:34:05 +0000

Turn Your Android Phone into a Physical USB Keyboard for PC BIOS / UEFI Setup

Have you ever worked on a headless server, mining rig, or a PC with a damaged keyboard, only to find yourself stuck at the "Press DEL to enter UEFI Setup" screen without a spare USB keyboard?

Teclado BIOS Arduino is an open-source Android tool that converts any smartphone into a genuine hardware USB keyboard recognized at the lowest firmware boot stage.

⚡ System Architecture

Smartphones cannot directly act as low-speed USB HID keyboards for legacy BIOS setups due to USB controller protocol differences. To solve this, an inexpensive Arduino (Uno, Nano, or Pro Micro) acts as the hardware interface bridge:

 [ Android Device ] ──(USB-OTG)──► [ Arduino Board ] ──(USB HID)──► [ Target PC / Server ]
 (Virtual Touch Console)            (V-USB / HID Core)               (BIOS / UEFI Level)

Android Side: Touch interface featuring dedicated BIOS hotkeys: DEL, F2, F10, F11, F12, ESC, Enter, and Arrow navigation keys.
Serial / OTG Layer: Commands are sent over USB-OTG serial to the Arduino.
Hardware Emulation: The Arduino emulates a true 1.5 Mbps USB Low-Speed HID keyboard, fully recognized by BIOS/UEFI before any operating system loads.

📌 Project Resources

🌐 Website & Portfolio: todoandroid.42web.io
💻 GitHub Repo (Android Source & Arduino Ino Sketch): Danielk10/Teclado-BIOS-Arduino

Tested on multiple motherboards and server racks. Schematics and connection diagrams are available in the repository!

Flash SPI Tool: Flashing BIOS and SPI EEPROMs from Android with flashrom

Daniel Elias Diamon Vazquez — Tue, 20 Oct 2026 20:28:22 +0000

Flash SPI Tool: Native Android GUI for BIOS and EEPROM Flashing (flashrom Engine)

When repairing computer motherboards, laptops, or game consoles with corrupted BIOS / UEFI firmware, technicians typically rely on an external programmer (like the CH341A) connected to a desktop computer.

Flash SPI Tool brings the full power of the industry-standard flashrom engine to Android devices over USB-OTG, eliminating the need for a PC during bench repairs.

🔬 How It Works

Flash SPI Tool bridges the gap between low-level hardware flashing and Android's sandboxed environment:

Custom Native flashrom Engine: Compiled for arm64-v8a with 16KB page-size alignment for compatibility with modern Android versions (Android 7.0 up to Android 17).
Zero-OOM C++ Transport Layer: Implemented via a high-performance native USB bridge (usb_bridge.cpp) communicating through Android USB Host APIs without root permissions.
Supported Memories: SPI Flash (25-series, W25Qxx), I2C EEPROMs (24-series), and LPC/FWH chips using SOIC8 test clips or DIP sockets.

 [ Android Phone / Tablet ]
            │ (USB-OTG Host API - Non-Root)
            ▼
    [ Native C++ USB Bridge ]
            │
            ▼
    [ flashrom Core Engine ]
            │
            ▼
   [ SPI Programmer: CH341A / FT2232 ]
            │ (SOIC8 Clip)
            ▼
 [ Target BIOS / SPI Flash Chip (25Q64 / 25Q128) ]

🚀 Repositories and Links

🌐 Project Home & Portfolio: todoandroid.42web.io
💻 GitHub Repository: Danielk10/Flash-EEPROM-Tool

Feel free to check out the project, file issues, or suggest new chip definitions!

Programming PIC Microcontrollers on Android via USB-OTG (PIC k150 Protocol)

Daniel Elias Diamon Vazquez — Tue, 20 Oct 2026 20:27:35 +0000

Programming PIC Microcontrollers on Android via USB-OTG without a PC

Flashing classic microcontrollers like the Microchip PIC16F628A typically requires a desktop PC running legacy Windows software and serial drivers. For field technicians, embedded developers, and hardware hobbyists, carrying a laptop to the workbench or installation site is often inconvenient.

To solve this, I developed PIC k150 Programming, an open-source Android tool that enables full read, write, blank-check, and fuse configuration directly from an Android smartphone or tablet over USB-OTG.

🛠️ Technical Architecture

The application communicates directly with the popular K150 programmer hardware using the KITSRUS P018 / P18A Programmer Firmware Protocol.

 ┌──────────────────────┐         USB-OTG Cable         ┌──────────────────────┐
 │   Android Device     │ ════════════════════════════► │  K150 Programmer HW  │
 │ (USB Host Controller)│       (P018 / P18A Protocol)  │ (FTDI / CH340 + PIC) │
 └──────────────────────┘                               └──────────┬───────────┘
                                                                   │ ZIF Socket
                                                                   ▼
                                                        ┌──────────────────────┐
                                                        │ Microchip PIC (DUT)  │
                                                        │ (e.g. PIC16F628A)    │
                                                        └──────────────────────┘

Key Engineering Features:

No Root Required: Uses the native Android USB Host API (android.hardware.usb).
Hardware-Validated Protocol: Validated in laboratory conditions on real silicon (PIC16F628A) and backed by virtual C++/Python emulation suites with PTY ports.
Diagnostic Controls: Real-time 13V VPP / 5V VDD diagnostic switching, baudrate echo testing, and ZIF socket status indicators.
Multi-Protocol Support: Clean runtime selection between P18A, P018, P016, and P014 protocols.

📦 Source Code, Downloads & Web

🌐 Personal Website & Portfolio: todoandroid.42web.io
💻 GitHub Repository (Code & Schematics): Danielk10/PIC-k150-Programing
📱 Google Play Store: PIC k150 Programming

Contributions, chip requests, and issues are warmly welcomed on GitHub!