Tim's DC Dual Curve Tracer

🧪 Types of Curve Tracers

There are several kinds of curve tracers, each suited to different tasks:

1. DC Curve Tracers: Use a ramp or sawtooth voltage sweep to test static I-V characteristics. Ideal for diodes, BJTs, and basic silicon junctions.
2. AC Curve Tracers: Use sine wave or triangle waveforms to analyze reactive components like capacitors and inductors.
3. Pulse-Based Tracers: Designed for high-speed switching devices (MOSFETs, IGBTs), simulating real-world load conditions.
4. Oscilloscope-Driven Tracers: Use X-Y plotting to visualize live waveforms, often with external signal generators.

Each type has its strengths — but many require complex setups, expensive gear, or deep technical knowledge.

🔧 What This Project Is

This build is a Basic (Limited) Dual-Probe Curve Tracer, designed to be:

1. Simple: Uses a basic circuit with an ADC and microcontroller
2. Accessible: Runs entirely in-browser via a Wi-Fi-enabled microcontroller
3. Teachable: Includes ghost trace overlays, save/load/export logic, and a clean UI
4. Limited: Focuses on DC analysis of small components like diodes and BJTs — not designed for reactive parts or high-voltage breakdown

It’s powered by an ESP8266, uses an ADS1115 ADC, and communicates via a built-in web server. The goal is to make curve tracing approachable for makers, students, and hobbyists — without needing an oscilloscope or lab bench.

🧠 Why I Built It This Way

I wanted a tool that could:

1. Run on low-cost hardware
2. Be used wirelessly from any browser
3. Teach core diagnostic principles without overwhelming complexity

This version is intentionally limited — but it’s a solid foundation for future extensions like bipolar sweeps, ghost trace comparison, and batch validation.

🔧 Upgradable by Design

While this version focuses on basic DC analysis, the setup is intentionally designed to be expandable. For example, future upgrades could include:

1. H-Bridge integration for automatic polarity switching
2. Bipolar sweep logic to capture full I-V curves in both directions
3. Reverse breakdown testing with current limiting
4. Batch trace comparison for anomaly detection

These enhancements build on the same core architecture — a microcontroller, ADC, and browser-native UI — making it easy to evolve the tool without starting from scratch.

Supplies for Tim’s Basic (Limited) Dual-Probe Curve Tracer

Core Components

1. ESP8266 microcontroller (NodeMCU Module) → Handles Wi-Fi, web server, and UI logic.
2. ADS1115 16-bit ADC module → Measures voltage drop across the shunt with high precision.

Measurement Circuit

1. 2 × Shunt resistors (10Ω) → One for each probe, enabling current sensing via voltage drop.
2. 2 × 1kΩ resistors → Isolate each probe from the sweep voltage supply.
3. 2 × Test probes or jumper wires → Connect to the DUT (Device Under Test).
4. 1 × Power supply (Power will be from the 3.3v Linear regulator on the NodeMCU Module) → Drives the sweep voltage across the DUT.

Signal Conditioning & Filtering

1. 1 × NPN transistor (e.g., 2N3904 or BC547) → For sweep control.
2. 1 × 1kΩ resistor → Current limiter from the NPN transistor.
3. 1 × RC filter:
4. 1 × resistor (1kΩ)
5. 1 × capacitor (1µF ceramic) → Smooths PWM or sweep signal before reaching the DUT
6. 2 × 4.7kΩ resistors → I²C pull-up resistors for SDA and SCL lines (required for stable communication with ADS1115).

Breadboarding & Connectivity

1. 1 × Solderless breadboard → For prototyping the entire circuit.
2. Jumper wires (male-male and male-female) → For flexible connections between modules.
3. USB cable (for ESP8266 power and programming)

️ ️Software & UI

1. Web browser (Chrome, Firefox, etc.) → Displays the curve tracer UI.
2. Serial monitor or uploader (Arduino IDE) → For flashing the ESP8266 and debugging.

I’ve created the circuit using Fritzing, so you can easily build this project on a solderless breadboard. The schematic shows all connections between the ESP8266, ADS1115, shunt resistors, RC filter, and I²C pull-ups — making it simple to follow and replicate.

You’ll find the following files attached:

1. .fzz — editable Fritzing project file
2. .png — breadboard layout image for quick reference
3. .pdf — printable schematic for offline use or documentation

This layout is designed to be:

1. Compact — fits on a standard breadboard
2. Modular — easy to upgrade later (e.g., H-bridge, bipolar sweep)
3. Teachable — with clear labeling and intuitive signal flow

If you're new to Fritzing, you can open the .fzz file in the Fritzing app to explore the circuit interactively or modify it for your own experiments.

I would have attached all the source code files directly to this Instructable, but not all file types are accepted due to upload restrictions on the site (yes, I’ve asked!). So instead, I’ve included the full source code by creating a dedicated step for each file. This way, you can view and copy the code directly without needing external downloads.

The only exception is the favicon.ico file, which isn’t shown due to file type restrictions.

To use the code:

1. Just create a new file in your project folder
2. Name it the same as the step title
3. Paste the code from that step into the file
4. ⚠️ You may need to enable “View file extensions” in your operating system to ensure the file gets the correct extension (e.g., .html, .css, .js, .ino). This is especially important if your system hides extensions by default — otherwise, you might accidentally save files as .txt instead.

📦 What Is LittleFS?

LittleFS is a lightweight filesystem for ESP8266 and ESP32 boards. It allows you to store and serve files (like HTML, CSS, JavaScript, and trace data) directly from the microcontroller’s flash memory — perfect for browser-based UI projects like this curve tracer.

🛠️ How to Install LittleFS in Arduino IDE

1. Open the Arduino IDE
2. Go to Tools → Board → Boards Manager
3. Search for ESP8266 and install the platform (if not already installed)
4. Once installed, go to Tools → ESP8266 Sketch Data Upload
5. If you don’t see this option, install the ESP8266FS tool:
6. Download it from GitHub
7. Place it in your Arduino IDE’s tools folder
8. Restart the IDE

📁 What Gets Uploaded

When you compile and upload the project, two things happen:

1. Sketch Upload

1. Your main .ino file (ESP8266 logic, ADC sampling, sweep control, etc.)

2. LittleFS Upload

1. All files inside the /data folder:
2. index.html → The browser-based UI
3. style.css → UI styling
4. script.js → Sweep logic, ghost trace overlays, and user interaction
5. Any trace data or configuration files you want to preload

To upload these files:

1. Go to Tools → ESP8266 Sketch Data Upload
2. This flashes the /data folder contents into the ESP8266’s flash memory using LittleFS
3. 
   

📄 Tims_Curve_Tracer.ino

Create a new file named Tims_Curve_Tracer.ino, then paste the following code into it and save.

💡 Important: All project files must be placed inside a folder named exactly Tims_Curve_Tracer — this matches the .ino filename and is required by the Arduino IDE.

Inside this folder, create a sub-folder named data. Place all the LittleFS files (like index.html, style.css, script.js) inside the data folder. This ensures they’re correctly uploaded to the ESP8266’s flash memory using the ESP8266 Sketch Data Upload tool.

💡 Tip: Make sure your system is set to “View file extensions” so you can confirm each file is saved with the correct extension (e.g., .ino, .html, .css, .js).

This .ino file contains the core logic for:

1. Sweep generation
2. ADC sampling
3. Serial and web communication
4. UI status feedback

Once uploaded, it coordinates the entire curve tracing workflow.

📄 Credentials.h

Create a new file named Credentials.h, then paste the following code into it and save. You’ll then need to edit this file depending on your preferred Wi-Fi connection mode. It controls how the ESP8266 connects to a network — either by creating its own (Access Point mode) or joining your existing Wi-Fi (Station mode).

There are three options, but you should only enable one at a time by uncommenting the corresponding line:

🔹 Access Point (AP) Mode

1. ESP8266 creates its own Wi-Fi network
2. You connect directly to it (e.g., from your phone)
3. No internet required — great for portable use
4. Set #define ACCESS_POINT

🔹 Access Point with Password

1. Same as AP mode, but requires a password
2. Set #define ACCESS_POINT_PW

🔹 Station (STA) Mode — Recommended

1. ESP8266 connects to your existing home Wi-Fi
2. You access the curve tracer from any device on your network
3. Set #define ACCESS_POINT_STA

✏️ What to Edit

If you choose Station (STA) mode, you must enter your Wi-Fi credentials:

#define LOCAL_SSID_STA "Your Network Name Here"

#define LOCAL_PASSWORD_STA "Your Network Password Here"

Replace the placeholder text with your actual Wi-Fi name and password.

🖥️ Serial Monitor Tip

Make sure #define ENABLE_SERIAL stays defined. This allows the ESP8266 to print its assigned IP address to the serial monitor when it boots — especially useful in STA mode, where the IP is assigned by your router.

📄 index.html

Create a new file named index.html, then paste the following code into it and save.

📁 Important: This file must be placed inside the data folder, which lives inside your main project folder (Tims_Curve_Tracer/data). This ensures it gets uploaded correctly to the ESP8266’s flash memory using LittleFS.

This file is the heart of the browser-based UI — it defines the layout, buttons, and structure of the curve tracer interface.

📄 style.css

Create a new file named style.css, then paste the following code into it and save.

📁 Important: This file must be placed inside the data folder, located within your main project folder (Tims_Curve_Tracer/data). This ensures it gets uploaded correctly to the ESP8266’s flash memory using LittleFS.

This file controls the visual styling of the curve tracer UI — including layout, colors, fonts, and spacing — to make the interface clean and user-friendly.

📄 script.js

Create a new file named script.js, then paste the following code into it and save.

📁 Important: This file must be placed inside the data folder, located within your main project folder (Tims_Curve_Tracer/data). This ensures it gets uploaded correctly to the ESP8266’s flash memory using LittleFS.

This file handles the interactive logic of the curve tracer UI — including sweep control, ghost trace overlays, and user interactions with the browser interface.

📄 favicon.ico

Web browsers use a favicon to display a small icon in the tab next to your page title — it’s a nice touch for polish and branding.

Above is an image you can use to create your own favicon. To do this:

1. Save the image above as favicon.png
2. Go to any online favicon generator (e.g., favicon.io, realfavicongenerator.net, or similar)
3. Upload the saved image
4. Download the generated .ico file
5. Rename it (if needed) to favicon.ico
6. Place it inside the data folder (Tims_Curve_Tracer/data)

📁 Once uploaded using the ESP8266 Sketch Data Upload tool, the favicon will be served by the web server and shown in your browser’s tab when you access the curve tracer UI.

Now that you’ve created all the required files and placed them in the correct folders, it’s time to upload everything to your ESP8266 and launch the curve tracer UI.

🧭 Step-by-Step

1. Open the Arduino IDE
2. Make sure your board is set to ESP8266 and your project folder is named Tims_Curve_Tracer.
3. Upload the Firmware
4. Click the Upload button to flash the Tims_Curve_Tracer.ino sketch to your ESP8266 (see image with arrow pointing to the Upload button)
5. Upload the Filesystem (LittleFS)
6. Go to Tools → ESP8266 LittleFS Data Upload to flash the contents of the /data folder (see image with arrow pointing to the LittleFS button)
7. Open the Serial Monitor
8. Set the baud rate to 115200
9. Reset the ESP8266 and watch for the IP address assigned by your router (see image showing the Serial Monitor output)

🌐 Launch the Curve Tracer UI

Once you have the IP address, open a web browser on any device connected to the same network and enter the IP in the address bar (e.g., http://192.168.50.11 or whatever your router assigned).

You should now see the curve tracer interface in action! (see browser screenshots showing the UI)

🖥️ Serial Monitor Tip

Depending on the USB-to-Serial chip used in your ESP8266 module, the Serial Monitor may not show any output when you press the reset button manually. If that happens, the best workaround is to:

1. Keep the Serial Monitor open while uploading the firmware
2. The ESP8266 will perform a hard reset during upload and reconnect to the network
3. You should then see the assigned IP address printed in the Serial Monitor as part of the boot sequence

This IP address is what you’ll use to access the curve tracer UI in your browser.

I’ve recorded a video where I walk through the circuit and the code in detail.

It’s a bit long, so feel free to skip around and focus on the parts you’re less familiar with — whether that’s the wiring, the firmware, or how the browser-based UI ties it all together.

A curve tracer helps you visualize how a component (like a diode or transistor) responds to different voltages — by plotting its current vs. voltage characteristics in real time.

Here’s how my version works, step by step:

⚡ 1. Sweep Voltage Is Generated

The ESP8266 creates a ramp or sweep voltage using PWM (Pulse Width Modulation) and filtering. This voltage is applied across the component under test — typically between the collector and emitter of a transistor or across a diode.

1. The sweep goes from 0V up to a set maximum (e.g., 3.3V), then resets.
2. This simulates a range of operating conditions.

🔍 2. Current Is Measured

A shunt resistor is placed in series with the component. As current flows, a small voltage drop appears across the shunt.

1. The ESP8266 reads this voltage using its ADC (Analog-to-Digital Converter).
2. This lets us calculate the current flowing through the component at each sweep point.

🧠 3. Data Is Captured and Sent

The ESP8266 samples both:

1. The sweep voltage (what’s being applied)
2. The shunt voltage (which tells us the current)

It packages this data and sends it via WebSocket to the browser-based UI.

🌐 4. Browser UI Plots the Curve

Your browser receives the data and plots it in real time:

1. X-axis: Sweep voltage
2. Y-axis: Calculated current

You’ll see the curve update live as the sweep runs — just like classic Tektronix curve tracers, but all in-browser!

👻 5. Ghost Traces and Overlays

You can save a trace as a ghost overlay to compare multiple components or see how a part behaves under different conditions.

1. Ghost traces are stored in the browser and can be exported or reloaded.
2. This makes it easy to spot anomalies or validate consistency across batches.

🧰 Summary

1. The ESP8266 generates a sweep
2. Measures current via a shunt resistor
3. Sends data to the browser
4. The browser plots the curve in real time
5. You can save and compare traces