# Complete Beginner's Guide

**[🇷🇺 Русская версия](Beginners-Guide-RU.md)**

---

> **This guide is for people who have never used a flash programmer before.**
> No electronics experience required. We'll explain everything from scratch.

---

## 🤔 What is this all about?

### What is flash memory?

Flash memory is a type of storage that keeps data even when power is off. It's inside:

- 📶 **Routers** — stores firmware and settings
- 📷 **IP cameras** — stores firmware and recordings
- 🎮 **Game consoles** — stores games and saves
- 📱 **Phones/tablets** — stores everything (eMMC)
- 💾 **USB drives** — that's literally flash memory
- 🖥️ **SSDs** — fast flash storage
- 🏠 **Smart home devices** — firmware and configs
- 🚗 **Car electronics** — ECU firmware

### What is a flash programmer?

A flash programmer is a device that can:
- **Read** data from flash chips (make a copy)
- **Write** data to flash chips (restore or modify)
- **Erase** flash chips (wipe everything)

### Why would I need this?

| Situation | What OpenFlash does |
|-----------|---------------------|
| Bricked router | Read working firmware from another router, write to broken one |
| Forgot password | Read flash, find/reset password in config |
| Data recovery | Read raw data from damaged device |
| Curiosity | See what's inside your devices |
| Security research | Analyze firmware for vulnerabilities |
| Repair | Clone working chip to replace dead one |

### Why is OpenFlash special?

**Commercial programmers cost $200-2000.** They're bulky, Windows-only, and have terrible software.

**OpenFlash uses a $4 microcontroller** (Raspberry Pi Pico) and free software that runs on Windows, Mac, and Linux.

```
Commercial programmer:     OpenFlash:
┌─────────────────────┐    ┌─────────────────────┐
│ $500 device         │    │ $4 Raspberry Pi Pico│
│ Windows XP software │    │ Modern app          │
│ Proprietary         │    │ Open source         │
│ Limited chips       │    │ 230+ chips          │
└─────────────────────┘    └─────────────────────┘
```

---

## 🛒 What do I need to buy?

### Minimum shopping list (~$5-10)

| Item | Price | Where to buy |
|------|-------|--------------|
| **Raspberry Pi Pico** | ~$4 | Amazon, AliExpress, Adafruit, local electronics store |
| **Jumper wires (female-female)** | ~$2 | Same places, get a pack of 40 |
| **Micro USB cable** | ~$1 | You probably have one already |

That's it! Total: **~$5-10**

### Optional but helpful

| Item | Price | Why |
|------|-------|-----|
| Breadboard | ~$3 | Makes wiring easier |
| TSOP-48 adapter | ~$5 | For desoldered chips |
| Multimeter | ~$10 | For troubleshooting |
| Soldering iron | ~$15 | If you need to desolder chips |

### Which Raspberry Pi Pico?

There are several versions:

| Model | Price | Speed | Recommendation |
|-------|-------|-------|----------------|
| **Pico** (RP2040) | ~$4 | Good | ✅ Best for beginners |
| **Pico W** (RP2040 + WiFi) | ~$6 | Good | WiFi not used, save money |
| **Pico 2** (RP2350) | ~$5 | Better | ✅ Slightly faster |

**Get the regular Pico or Pico 2.** The WiFi version doesn't help here.

---

## 📥 Step 1: Install the software

### Download OpenFlash

1. Go to [github.com/openflash/openflash/releases](https://github.com/openflash/openflash/releases)
2. Download for your system:
   - **Windows**: `OpenFlash-3.x.x-x64.msi` — double-click to install
   - **Mac**: `OpenFlash-3.x.x.dmg` — drag to Applications
   - **Linux**: `OpenFlash-3.x.x.AppImage` — make executable and run

### Try it without hardware (Mock mode)

Before connecting anything, let's make sure the app works:

1. Open OpenFlash
2. Click the **"Mock"** button (top left)
3. Click **"Scan"**
4. You'll see "OpenFlash Mock Device" — click **"Connect"**
5. Click **"Detect Chip"** — it will show a simulated chip
6. Click **"Dump NAND"** — watch it "read" fake data
7. Explore the tabs: **Hex View**, **Bitmap**, **Analysis**, **AI**

If this works, your software is ready!

---

## 🔌 Step 2: Flash the firmware to Pico

The Pico needs special firmware to work as a flash programmer.

### Download firmware

1. Go to [github.com/openflash/openflash/releases](https://github.com/openflash/openflash/releases)
2. Download `openflash-rp2040.uf2` (or `openflash-rp2350.uf2` for Pico 2)

### Flash it

1. **Hold the BOOTSEL button** on the Pico (the only button on the board)
2. **While holding**, plug the USB cable into your computer
3. **Release the button** — Pico appears as a USB drive called "RPI-RP2"
4. **Drag and drop** the `.uf2` file onto that drive
5. Pico will reboot automatically — the drive disappears, that's normal!

### Verify it worked

1. Open OpenFlash
2. Make sure "Mock" is NOT selected
3. Click **"Scan"**
4. You should see "OpenFlash Device" — success!

If you don't see it:
- Try a different USB cable (some are charge-only)
- Try a different USB port
- Re-flash the firmware

---

## 🔗 Step 3: Understand the connections

### Types of flash memory

There are different types of flash chips, each with different connections:

| Type | Wires needed | Common in |
|------|--------------|-----------|
| **SPI NAND** | 4-6 | Routers, IoT devices |
| **SPI NOR** | 4-6 | BIOS chips, small devices |
| **Parallel NAND** | 14+ | Older devices, large storage |
| **eMMC** | 4-6 | Phones, tablets, newer devices |

**Start with SPI (4 wires) — it's easiest!**

### SPI connection (easiest)

SPI flash chips have 8 pins and need only 4 connections:

```
SPI Flash Chip (8-pin)
┌────────────────┐
│ 1 CS#    VCC 8 │  ← Power (3.3V)
│ 2 DO    HOLD 7 │
│ 3 WP#    CLK 6 │  ← Clock
│ 4 GND     DI 5 │  ← Ground
└────────────────┘

Connect to Pico:
• Pin 1 (CS#) → Pico GP17
• Pin 2 (DO)  → Pico GP16
• Pin 4 (GND) → Pico GND
• Pin 5 (DI)  → Pico GP19
• Pin 6 (CLK) → Pico GP18
• Pin 8 (VCC) → Pico 3V3
```

### ⚠️ CRITICAL: Voltage warning

**Flash chips run on 3.3V. Never connect 5V — it will destroy the chip!**

The Pico runs on 3.3V, so direct connection is safe. But:
- Don't use Arduino Uno (5V logic)
- Don't connect to 5V pin on Pico
- Always double-check before powering on

---

## 🔧 Step 4: Connect your first chip

Let's do a simple SPI NOR flash read. These chips are common and easy.

### Find a chip to practice on

Good practice targets:
- **Old router** you don't need
- **USB drive** (has SPI NOR inside)
- **Arduino board** (has SPI flash for bootloader)
- **Any dead electronics** with 8-pin chip

### Identify the chip

Look for an 8-pin chip with markings like:
- W25Q... (Winbond)
- MX25L... (Macronix)
- GD25Q... (GigaDevice)
- IS25LP... (ISSI)

Write down the full part number!

### Wire it up

**If chip is still on a board (in-circuit reading):**

⚠️ This is tricky! The chip might be connected to other components. It's safer to desolder, but you can try:

1. Power off the device completely
2. Connect wires to chip pins (use test clips or careful soldering)
3. Don't power the original device — only power from Pico

**If chip is desoldered:**

Use a breadboard or SOIC-8 adapter:

```
Pico                    SPI Flash
┌─────────────┐        ┌─────────┐
│ GP16 ───────┼────────┼─ DO     │
│ GP17 ───────┼────────┼─ CS#    │
│ GP18 ───────┼────────┼─ CLK    │
│ GP19 ───────┼────────┼─ DI     │
│ 3V3  ───────┼────────┼─ VCC    │
│ GND  ───────┼────────┼─ GND    │
└─────────────┘        └─────────┘
```

### Read the chip

1. Open OpenFlash
2. Click **"Scan"** → select your device → **"Connect"**
3. Select interface: **"SPI NOR"** (dropdown at top)
4. Click **"Detect Chip"**
   - If it shows chip info → great!
   - If "Unknown" → check wiring, try again
5. Click **"Dump"**
6. Choose where to save the file
7. Wait for it to complete
8. You now have a backup of the chip!

### Verify the dump

1. Go to **"Hex View"** tab — you should see data (not all FF or 00)
2. Go to **"Analysis"** tab — it will identify what's inside
3. Go to **"AI"** tab — get intelligent analysis

---

## 🎯 Step 5: What to do with the dump

### View the contents

The **Hex View** shows raw bytes. Look for:
- Text strings (readable words)
- Repeating patterns
- All `FF` = empty/erased areas

### Analyze automatically

The **Analysis** and **AI** tabs will tell you:
- What filesystems are inside (SquashFS, JFFS2, etc.)
- Where different sections are (bootloader, kernel, rootfs)
- If data is compressed or encrypted
- Potential issues (bad blocks, corruption)

### Extract files

If OpenFlash detects a filesystem, you can often extract files using external tools:
- **binwalk** — `binwalk -e dump.bin`
- **jefferson** — for JFFS2
- **ubireader** — for UBIFS
- **sasquatch** — for SquashFS

### Modify and write back

⚠️ **Be careful!** Writing wrong data can permanently brick devices.

1. Make your changes to the dump file
2. In OpenFlash, click **"Write"**
3. Select your modified file
4. Enable **"Verify after write"**
5. Wait for completion

---

## ❓ Common questions

### "Chip not detected"

1. Check all 6 wires are connected
2. Make sure VCC goes to 3V3 (not 5V!)
3. Try swapping DI and DO (easy to mix up)
4. Check for cold solder joints
5. The chip might be dead

### "Dump is all FF"

- Chip might be empty (erased)
- Chip might be dead
- Wiring issue — check connections

### "Dump is all 00"

- Definitely a wiring issue
- Check GND connection
- Check data lines (DO)

### "Can I read the chip without desoldering?"

Sometimes yes (in-circuit reading), but:
- Other components might interfere
- You need to power off the original device
- It's more reliable to desolder

### "I don't know how to solder"

Options:
- Use test clips (SOIC-8 clip) — no soldering needed
- Practice on junk electronics first
- Watch YouTube tutorials
- Ask a friend who knows electronics

### "Will this void my warranty?"

Probably yes. Only do this on:
- Devices you own
- Devices out of warranty
- Devices you're willing to risk

---

## 📚 Next steps

Now that you understand the basics:

1. **[Hardware Setup](Hardware-Setup.md)** — detailed wiring for all chip types
2. **[Supported Chips](Supported-Chips.md)** — check if your chip is in the database
3. **[Troubleshooting](Troubleshooting.md)** — when things don't work
4. **[FAQ](FAQ.md)** — more questions answered

---

## 🎓 Glossary

| Term | Meaning |
|------|---------|
| **Flash** | Type of memory that keeps data without power |
| **NAND** | Type of flash, used for large storage |
| **NOR** | Type of flash, used for small storage and code execution |
| **SPI** | Serial interface, uses 4 wires |
| **Parallel** | Interface using 8+ data wires simultaneously |
| **eMMC** | Flash + controller in one package (like in phones) |
| **Dump** | A copy of all data from a chip |
| **Firmware** | Software stored in flash that runs the device |
| **Brick** | Device that won't boot (like a brick — useless) |
| **ECC** | Error correction — fixes bit errors in flash |
| **Bad block** | Section of flash that's damaged and unusable |

---

<div align="center">

**You've got this! Start simple, learn as you go.**

Questions? [GitHub Discussions](https://github.com/openflash/openflash/discussions)

</div>