What will this Arduino Photodiode Tutorial cover?

This tutorial will guide you step-by-step through setting up a photodiode circuit with Arduino, understanding the necessary code, and obtaining accurate light intensity readings.

What are the main differences between a photodiode and an LDR for Arduino projects?

The tutorial will explore the crucial differences in the 'Photodiode vs LDR Arduino' debate, helping you understand their distinct characteristics and best uses.

Will an Arduino Photodiode Circuit Diagram be provided?

Yes, a clear Arduino Photodiode Circuit Diagram will be provided to assist you with the setup and connection of the components.

Is the 2N3904 transistor suitable for high-stability RF oscillator circuits, such as an SSB Local Oscillator?

Yes, despite being a low-cost component, the 2N3904 can achieve excellent stability and performance in critical applications like SSB Local Oscillators when designed with proper component selection.

What types of Ham Radio projects can utilize a 2N3904-based oscillator?

The 2N3904 is highly versatile for DIY Ham Radio oscillator circuits, including QRP rigs, SSB receivers, and even general test bench signal sources.

Why is the 2N3904 considered a good choice for DIY RF oscillator projects?

The 2N3904 is valued for its versatility, reliability, and cost-effectiveness, earning it the title 'Swiss Army Knife' of RF components, making it ideal for accessible DIY builds.

ee-diary

Q: Can I build a light intensity sensor using an Arduino and a photodiode with this guide?

Yes, the tutorial will show you how to transform a simple photodiode into a powerful light intensity sensor for Arduino applications.

How to Design 12V DC to 220V AC Inverter Circuit

2026-04-17T17:12:00.003+05:45

Previously I wrote about TL494 based inverter designed for low frequency(50/60Hz) intended for large and heavy iron-core transformer. After revisiting it and thought I should make another TL494 based inverter which is more advanced high frequency (SMPS) inverter. The previous TL494 inverter was a simple one which used complementary power transistors TIP41 and TIP42 with fixed 50% duty cycle. Here I will be showing a professional 12V DC to 220V AC inverter designed with two BC327 driver stage and four IRFZ44N MOSFETs based output power stage.

Circuit Diagram

The following shows the circuit diagram of 12V DC to 220V AC inverter using TL494 PWM controller IC.

The design step is as follows:

Setting up the TL494 PWM Controller

Begin by placing the TL494 IC, the heart of the PWM controller. Connect Pin 1 (1IN+) and Pin 2 (1IN-) to the common rail. Place a 15nF timing capacitor (C1) between Pin 5 (CT) and Ground to set the switching frequency. Finally, add a 5k Variable Resistor (RV1) and a 1k resistor (R1) to Pin 6 (RT); this allows for fine-tuning the frequency specifically for the ferrite transformer.

Power and Ground Railing

Connect the input connector J1 and bridge Pin 7 (GND) to the negative rail. Ensure Pin 12 (VCC) and Pin 11 (C2) are tied to the 12V supply rail. For proper push-pull operation, connect Pin 13 (OCTRL) directly to Pin 14 (REF).

Driver Stage with BC327

Place two 1k pull-down resistors (R2, R3) on the output lines from Pins 9 and 10. Add two BC327 PNP transistors (Q1, Q2) and two 1N4148 diodes (D1, D2) to act as the gate drivers. The emitters of these transistors will drive the MOSFET gates through 47-ohm resistors (R4, R5).

MOSFET Power Bank

Add the power MOSFETs using four IRFZ44N units (Q3, Q4, Q5, Q6) arranged in two parallel pairs. Each MOSFET gate must have its own 47-ohm resistor to ensure balanced switching and prevent overheating. Complete this stage by joining the sources of all MOSFETs to the common ground rail.

Final Transformer Assembly

Place the Step-Up Transformer (TR1). The center tap of the primary winding connects directly to the +12V DC input. Connect the drains of one MOSFET pair to one side of the primary, and the other pair to the opposite side. Finally, add a large 1000uF electrolytic capacitor (C2) across the power lines to filter out switching noise and stabilize the voltage.

🛠️ Components Used in This Design:

Battery 12V DC

Oscillator IC TL494

MOSFETs IRFZ44N (x4)

BJT BC327(x2)

Transformer High-Frequency Ferrite Core Transformer

Diodes 1N4148(x2)

Capacitors 1000µF, 15nF

Resistors 1k (2), 47Ω(x4)

How to Design 12V DC to 220V AC Inverter Circuit Schematic in Proteus

The following video shows how to design the inverter circuit in Proteus

Related resources:

TL494 IC pinout explorer - Free interactive tool

2026-04-17T17:11:00.006+05:45

TL494 PWM PWM Controller IC ● DIP-16 ● 16 pins

DIP-16

○ PIN EXPLORER

□ DESIGN FILES

☍ DATASHEET

TL494 PWM CONTROLLER

←

Click any pin on the IC
to see full specifications

◆ Highlight by Function

PIN LIST ▼ SHOW

Explore TL494 PWM Controller: pins, internal block diagram, and expert design tips to optimize power supply circuits

Simple Super Regenerative FM Receiver Circuit Design

2026-04-16T02:20:00.002+05:45

Build Your Own Simple Super Regenerative FM Receiver: A Beginner's Guide to DIY Radio

Have you ever dreamed of building your own radio? The idea of capturing invisible waves from the air and transforming them into sound can seem like magic, but with a little electronics know-how, it's a completely achievable and incredibly rewarding project. For beginners diving into the fascinating world of radio frequency (RF) electronics, the super regenerative FM receiver is an excellent starting point. It’s known for its simplicity, low component count, and impressive sensitivity for such a straightforward design.

In this comprehensive guide, we’re going to demystify the "Simple Super Regenerative FM Receiver Circuit Design." We’ll walk you through the core principles, introduce you to the essential components, detail the circuit's operation, and provide a step-by-step construction plan. By the end of this post, you'll have the knowledge and confidence to assemble your very own FM receiver, pulling local radio stations right out of the ether. Get ready to transform theory into a tangible, working piece of technology!

What is a Super Regenerative Receiver? A Beginner's Overview

Before we delve into the specifics of circuit design, let's understand the heart of our project: the super regenerative receiver. Unlike more complex superheterodyne receivers found in commercial radios, the super regenerative design is a marvel of simplicity and efficiency, especially for receiving Frequency Modulated (FM) signals.

The Magic of Regeneration

At its core, a super regenerative receiver uses a single transistor (or vacuum tube in older designs) to perform multiple tasks: RF amplification, detection (demodulation), and even some degree of selectivity. The "regenerative" part comes from feeding a portion of the amplified signal back to the input in a controlled positive feedback loop. This feedback significantly increases the circuit's sensitivity and gain, allowing it to pick up very weak signals. Imagine a microphone picking up its own sound from a speaker, but controlled just enough to amplify, not to create a runaway screech!

The "Super" Part: Quenching

The "super" in super regenerative refers to a clever technique called "quenching." If the regeneration were left unchecked, the circuit would oscillate continuously, becoming a radio transmitter rather than a receiver. To prevent this, the super regenerative receiver periodically switches its oscillation on and off at a frequency much lower than the incoming radio signal (the "quenching frequency"). This rapid on-off cycling allows the circuit to build up oscillations due to weak incoming signals, detect them, and then "reset" before the oscillations become unstable. This process makes the circuit incredibly sensitive and efficient at detecting FM signals by sensing changes in the oscillation amplitude caused by the incoming FM carrier.

Circuit Design Principles: How It All Works Together

Let's look at the conceptual breakdown of our simple super regenerative FM receiver. Understanding the flow of the signal will make the component-level discussion clearer.

Block Diagram Concept:

Antenna: Captures the electromagnetic waves (radio signals) from the air.

Tuning & RF Stage (Super-Regenerative Oscillator): This is where the magic happens. The incoming RF signal is fed into a transistor-based oscillator circuit. This circuit is designed to oscillate at the frequency of the desired FM station. Through regeneration and quenching, it amplifies the weak incoming signal and, simultaneously, acts as a detector.

Demodulation/Detection: Within the super-regenerative oscillator itself, the frequency variations of the incoming FM signal are converted into amplitude variations. These amplitude changes, which represent the original audio information, are then extracted.

Audio Amplification: The extracted audio signal is typically very weak. It needs to be boosted by an audio amplifier stage (like one built around an LM386 IC) to drive a speaker or headphones.

Output (Speaker/Headphones): The amplified audio signal is converted into sound waves that you can hear.

The beauty of the super regenerative design is how steps 2 and 3 are often combined into a single, elegant stage. The transistor handles both the high-frequency amplification and the demodulation, simplifying the overall circuit considerably.

The Simple Super Regenerative FM Receiver Circuit

Now, let's visualize the actual circuit and understand its sections. We'll examine a common and effective design that beginners can easily replicate.

This simple FM receiver circuit uses a minimum number of components for local FM reception. Transistor BF495 (T2), together with a 10k resistor (R1), coil L, a 22pF variable capacitor (VC), and the internal capacitances of transistor BF494 (T1), forms a Colpitts oscillator. The trimmer capacitor VC sets the oscillator's resonant frequency to match that of the desired transmitting station—in other words, it must be tunable across the FM band from 88 to 108 MHz. The information signal (the modulation from the transmitter) is extracted across resistor R1 and fed to the audio amplifier through a 220nF coupling capacitor (C1).

The variable capacitor should have a capacitance range from a few picofarads up to about 20 pF. A 22pF trimmer capacitor is therefore a suitable choice for VC and is readily available. If you use a capacitor with a larger value and find that you cannot cover the full FM bandwidth (88–108 MHz), try adjusting the value of VC experimentally to find the optimal capacitance.

The self-supporting coil L is made from four turns of 22 SWG enamelled copper wire wound on an air core with an internal diameter of 4 mm. It can be wound on any cylindrical object with a 4 mm diameter, such as a pencil or pen. After winding the required number of turns, remove the coil from the cylinder and gently stretch it slightly to prevent adjacent turns from touching each other.

Capacitors C3 (100nF) and C10 (100µF, 25V), together with resistor R3 (1k), form a very low-frequency band-pass filter that separates the low-frequency (audio) signal from the high-frequency components in the receiver.

For the antenna, you can reuse the telescopic antenna from an unused device. Alternatively, a good reception can be achieved with a piece of insulated copper wire about 60 cm long. The optimal length of copper wire can be found experimentally. For more information, you can also read: Different Types of Antennas. The performance of this tiny receiver depends on several factors, including the quality and number of turns of coil L, the type of antenna used, and the distance from the FM transmitter.

IC LM386 is an audio power amplifier designed for low-voltage consumer applications. It delivers 1 to 2 watts of output power, sufficient to drive any small loudspeaker. A 22k logarithmic potentiometer (VR) is connected to pin 3 for volume control, and the amplified output is taken from pin 5 of the IC. The receiver can be powered by a 6V to 9V battery.

Further Exploration and Enhancements

Your journey doesn't have to end with a basic working receiver! Here are some ideas for improving your design or exploring related projects:

Add an RF Amplifier Stage: A dedicated RF pre-amplifier stage before the super-regenerative detector can boost weak signals, improving overall sensitivity without affecting selectivity too much.

Better Filtering: Experiment with different audio filter designs after the detector to reduce noise and improve sound quality.

Shielding: Enclosing your circuit in a metal box can reduce RF radiation and protect it from external interference.

Experiment with Different Transistors: Try different RF transistors to see how they impact performance.

Explore FM Transmitters: Once you've mastered receiving, why not try transmitting? Building a simple FM transmitter can be a great complementary project. You can learn more about related concepts by checking out these resources:

Closed-loop Temperature Controller with Arduino

2026-04-15T22:25:00.002+05:45

Here I am redesigning the closed loop temperature controller with Arduino that I had I designed and illustrated in Building an Automatic Temperature Controller Using Arduino and a PID Algorithm. While the circuit works, I wanted to make some improvements.

Circuit Diagram/Hardware

Following shows the circuit diagram of the improved version of the closed loop temperature controller with Arduino Uno.

The following shows the previous circuit that was working fine but needed improvements.

In my previous design shown above, I relied on a simple 9V battery to power the Arduino, which was a weak point for long-term use. To solve this, I integrated an LM2595 Buck Converter to pull power directly from the main 12V supply. By stepping this down to 5V, I eliminated the need for a second battery and improved the overall efficiency of the system.

I also upgraded the switching stage. While the IRF540N used previously is powerful, it isn't a "Logic Level" MOSFET and doesn't fully activate at the 5V provided by the Arduino. I swapped it for an IRLZ44N, which is designed specifically for 5V logic. This change ensures the MOSFET conducts fully and stays cool, allowing the bulb to receive maximum power.

To clean up the power delivery, I added a filtering network using 220µF and 120µF capacitors. These smooth out voltage spikes and ripples from the regulator. I also included a 1N5822 Schottky diode—a critical addition because its fast-switching speed and low forward voltage are essential for the high-frequency operation of the buck converter.

Finally, I stabilized the temperature sensing by powering the LM35 directly from the regulated 5V output. In the older version, the sensor shared a rail with a fluctuating battery; now, it has a rock-solid reference voltage for more accurate readings. I also added a gate resistor network (R1 and R2) to ensure the MOSFET gate discharges properly, preventing the load from staying partially active.

Code for the Temperature Controller

Below is the code for the PID-based temperature controller. This will measure the temperature from the LM35 sensor and adjust the power to the heating element to maintain a set temperature (25°C) using a relay.

// Pin Definitions
const int tempSensorPin = A0; // LM35 Temperature Sensor connected to A0
const int heaterPin = 9;      // Heater connected to PWM pin 9

// Parameters for optimal control
float Kp = 2.5; // Proportional gain
float Ki = 0.5; // Integral gain
float Kd = 0.1; // Derivative gain

// Variables for control
float setPoint = 30.0; // Desired temperature in °C
float currentTemp = 0.0; // Current temperature reading
float error = 0.0;       // Error value
float previousError = 0.0; // Previous error for derivative term
float integral = 0.0;    // Integral accumulator
float output = 0.0;      // Output PWM value

void setup() {
  Serial.begin(9600);
  pinMode(heaterPin, OUTPUT);
  Serial.println("Automatic Temperature Controller");
}

void loop() {
  // Read temperature from LM35 sensor
  int sensorValue = analogRead(tempSensorPin);
  currentTemp = (sensorValue * 5.0 / 1023.0) * 100.0; // Convert to Celsius

  // Calculate error
  error = setPoint - currentTemp;

  // Calculate integral term
  integral += error;

  // Calculate derivative term
  float derivative = error - previousError;

  // Compute control output
  output = Kp * error + Ki * integral + Kd * derivative;

  // Limit output to PWM range (0-255)
  output = constrain(output, 0, 255);

  // Apply control to heater
  analogWrite(heaterPin, output);

  // Update previous error
  previousError = error;

  // Print for monitoring
  Serial.print("Temperature: ");
  Serial.print(currentTemp);
  Serial.print(" °C, Output: ");
  Serial.println(output);

  // Delay for stability
  delay(1000);
}

How the Code Works

This code implements a PID (Proportional-Integral-Derivative) control algorithm to maintain a target temperature of 30°C. It begins by reading the analog signal from the LM35 sensor, converting that value into a Celsius temperature, and calculating the error—the difference between the desired setpoint and the actual reading. The script then computes three distinct terms: the Proportional term reacts to the current error, the Integral term accounts for accumulated past errors to eliminate steady state offset, and the Derivative term predicts future error trends to prevent overshoot. These components are summed to generate a control signal, which is constrained to a 0–255 PWM range and sent to the heater via pin 9, effectively adjusting the heat output in real-time to achieve a stable temperature.

Video : How I made the circuit in Proteus

Related:

How to Design Amplitude Modulator (AM) using Differential Amplifier - Improved Version

2026-04-14T22:45:00.003+05:45

I had designed a Differential Amplifier AM Modulator previously and found that I should make some correction to the circuit as an improvement. The differential amplifier AM (Amplitude Modulation) is also called "Long-Tailed Pair" modulator. Here I will write about the flaws in the previous differential amplifier based AM modulator for AM transmitter and the correctness I have done.

The circuit is shown below.

The differential amplifier-based AM modulator is much better and linear than a diode-based AM modulator. In the above circuit, the transistor Q3 acts as a voltage-controlled current source that "feeds" the differential pair (Q1 and Q2). This circuit is actually a Gilbert mixer that multiplies the carrier ( $V_c$ ) and the modulating audio ( $V_m$ ) and results in much lower harmonic distortion. Also, by using BAT1 and BAT2 (±3.7V) gives the circuit good "headroom," which helps keep the transistors in their linear region.

Problems & Solutions

While the circuit topology is ok, there are a few errors in the wiring and component values that might cause it to fail.

The Output Tank (C1): I had set $C1$ set to $0.1\mu F$.

The Problem: At any RF frequency (like 1MHz), a $0.1\mu F$ capacitor has almost zero impedance. It will short your entire output signal directly to ground. If the inductor $L1$ is $25.36\mu H$ and we want to it working in the AM band (~1MHz), $C1$ should be changed to around $1000pF$ ( $1nF$ ). The LC then resonant at 1MHz(AM band)
The Fix: However, I changed both the values of L1 and C1. I opted for L1=100uH and C1=250pF which is standard values used in actual radios.

The Math:

f = \frac{1}{2\pi\sqrt{100\mu\text{H} \times 250\text{pF}}} \approx 1.006\text{ MHz}

f = \frac{1}{2\pi\sqrt{100\mu\text{H} \times 250\text{pF}}} \approx 1.006\text{ MHz}

Transistor Biasing (Q3): At the carrier input there is the diode (D1) and a resistor (R3) connected at the base of $Q3$ , but the base is also connected directly to the $V_c$ input.

The Fix: We need a coupling capacitor (e.g., 100nF) between your $V_c$ source and the base of $Q3$ . Without it, the DC offset from the signal generator will fight with the biasing of $D1/R3$ . Similarly, I added coupling capacitor C3 of 10uF at the audio signal input for not disturbing the biasing circuit that follows it.

Diode(D1) Orientation: In the original circuit, the diode D1 was oriented downwards (Cathode to Ground, Anode to Base). I changed the orientation (Anode to Ground, Cathode to Base). The diode acts as a DC voltage reference that sets the "idle" current for the entire circuit by clamping the base of the tail transistor ( $Q3$ ). In the original orientation, it held the base at $+0.7\text{V}$, forcing excessive current that pushed the signal against the supply rail and caused top-side clipping. By reversing the diode to clamp the base at $-0.7\text{V}$, you reduced the total current and shifted the signal’s operating point into the center of your $7.4\text{V}$ window, providing equal headroom for the waveform to swing both up and down symmetrically.

Emitter Resistor: I changed the emitter resistor (previously labelled R5 now R1) value from 10k to 470ohm. R1 sets the "gain" of your modulator. By reducing it, you shifted the circuit from a "stiff," low-current mode to a high-sensitivity, high-gain mode, making it much more efficient at translating your carrier signal into a strong AM wave.

Load Balancing: $R2$ and $R6$ are $4.7k\Omega$ . This is a bit high for high-frequency RF if you have any parasitic capacitance. Dropping them to $1k\Omega$ will give you a "sharper" response at the cost of a little gain.
Transistors: I replaced the 2N5550 BJT transistor with 2N3904 for better RF speed. When choosing a transistor for RF (Radio Frequency), the most important specification is the Transition Frequency ( $f_T$ ). This is the frequency at which the transistor's gain drops to 1. To get good performance, you want an $f_T$ that is much higher than your operating frequency (1 MHz to 4 MHz).
Practical Values: In the circuit I have used exact values but for practical build, I replaced them with real world actually available 220uH inductor and capacitor (100) values.

Below is the correct differential amplifier AM modulator circuit diagram designed to work at 1MHz carrier frequency.

The below picture shows message signal, the carrier signal, the AM signal on an oscilloscope.

Below is the setting for audio and carrier signal.

Below picture shows the spectrum showing 1MHz AM signal.

The following video shows the Differential Amplifier AM Modulator circuit in action.

Related Tutorials

Improving AM modulator using MC1496 modulator

2026-04-13T20:38:00.001+05:45

I wrote about AM modulator using MC1496 modulator for AM generation four year ago in 2022. While the circuit works as I have demonstrated in video which is provided below, there is room for improvements. Here I want to write down note on how to improve this AM generation circuit.

Below is the circuit diagram that I posted years ago.

The circuit is a standard, technically sound application of the MC1496 for balanced modulation. The connections match the classic datasheet configurations for a dual-supply setup.

However, "correctness" in RF circuits often depends on your specific goals (DSB-SC vs. AM) and the frequencies you are handling. Here are an evaluation and some practical advice for improving the circuit:

1. Functional Review

Biasing: Your use of +12V and -8V is excellent. The MC1496 performs much better with dual supplies than single-supply biasing, as it provides better carrier suppression and simpler input interfacing.
Impedance Matching: You have 51Ω resistors ( $R10, R1, R12$ ) at the inputs. This is correct for interfacing with standard 50Ω lab instrumentation (like signal generators). If your source is high impedance (like a guitar or simple oscillator), these will load the signal heavily.

2. Practical Advice & Improvements

Carrier Nulling (The 10k Pot):
The 10k potentiometer ( $R13/R14$ network) is highly sensitive. For a professional build, use a multi-turn (cermet) trimmer. A standard single-turn pot will make it very frustrating to "null" the carrier signal perfectly.
Output Filtering:
The output ( $V_o$ ) at $C3$ will contain the sum and difference frequencies ( $f_c \pm f_s$ ), but also potentially some high-frequency harmonics. If you are using this for a transmitter, you should add a Band-Pass Filter (BPF) or a Low-Pass Filter (LPF) after $C3$ to clean up the waveform.
Gain Control ( $R2$ ):
You have $1k\Omega$ for $R2$ . If you find the output signal is clipping or distorted, you can increase this value (e.g., $2.2k\Omega$ ) to reduce the gain and improve linearity.
Decoupling is Key:
The MC1496 is sensitive to power supply noise. While you have $C2$ on the bias line, I strongly recommend adding 100nF ceramic capacitors as close as possible to the IC pins:
- One from Pin 12 (+12V) to Ground.
- One from Pin 14 (-8V) to Ground.

3. Verification Steps

If you are testing this on a breadboard or PCB:

Check DC Quiescent Volts: Before applying signals, ensure Pin 12 is sitting at a higher voltage than Pin 14.
Nulling: Apply only the Carrier ( $V_c$ ). Adjust the 10k pot until the signal at $V_o$ is at its minimum on an oscilloscope.
Modulation: Apply the modulating signal ( $V_s$ ) and observe the "envelope" or the suppressed carrier "butterfly" pattern.

The schematic is correct and ready for prototyping. It's a solid design for a technical blog or a hardware demonstration.

Arduino Nano Overheating Problem & Solutions

2026-04-13T17:58:00.002+05:45

Lately, my working Arduino Nano started to overheat, and the ICs on it became very hot when connected via USB. I don’t know the reason. In fact, I now have two Arduino Nanos that are not working anymore. The other one does not have the overheating problem, but it simply will not connect.

My first guess was that the voltage regulator AMS1117 was the problem. I unplugged it from the USB and checked it with a multimeter in continuity mode. There was a continuity beep between pin 1, which is the ground pin, and the middle pin 2, which is the output pin. This means that the AMS1117 IC was shorted. I removed it by desoldering it from the Arduino Nano PCB, since the Arduino Nano can also work without the voltage regulator when powered via USB or by applying 5V to the +5V pin.

After removing and reinserting the USB, the problem was not resolved — it still became hot. I was afraid that the PCB USB port might get damaged, so I unplugged it immediately. Then I inserted the Arduino into a breadboard and applied +5V to the +5V pin. I touched the chips on the Arduino to check whether they were heating up or not, and they weren’t. But soon afterward, I realized that the breadboard power supply voltage regulator LM7805 was heating up. As you perhaps know the LM7805 is a linear voltage regulator which heats up quickly.

At this point, I now have to check the other ICs as well, which is difficult. Even if I check and confirm that the ATmega328P or another IC is the problem, I have no replacement IC. Though I could desolder the same IC from another Arduino Nano that is also not working, this will take time.

So I started to look for solution on the internet. I found many reports of overheating problem with Arduino nano but no one actually solved or repaired it.

Here’s a consolidated summary of how the Arduino Nano overheating problems started across all the forum and help pages I reviewed:

🔥 Arduino nano Overheating Causes Reported

Arduino Forum (Nano overheats on USB)
- Board became very hot immediately when connected via USB.
- Likely cause: damaged ATmega328P microcontroller or shorted voltage regulator.
- Resolution: not repaired, replacement chip suggested.
Reddit Discussion (Nano overheats, LEDs all on)
- User powered Nano with both USB and ~12 V battery pack simultaneously.
- Result: regulator and microcontroller fried.
- Resolution: consensus was the board was dead, no repair.
Electronics Stack Exchange (Nano overheats after spark)
- Spark occurred while connecting motor driver; Nano overheated even with Blink sketch.
- Cause: suspected overvoltage damage.
- Resolution: not solved, advice was to discard and replace.
Electronics Forum (Uno overheats with motor shield)
- Uno overheated when powered with 12 V and motor shield attached.
- Cause: regulator overstressed, unclear shield wiring.
- Resolution: thread ended unresolved.
Adafruit Forum (Uno R3 overheats)
- Uno’s ATmega328P DIP chip reached ~170°F even with simple sketches.
- Cause: defective chip and regulator heating from 12 V input.
- Resolution: Adafruit replaced the board, not repaired.
Arduino Forum (Nano clone overheats only on USB)
- Nano clone overheated when powered via USB, but worked with external 5 V.
- Cause: USB interface or regulator failure.
- Resolution: not solved, board remained unusable.
General Guide Article (“10 Fixes for Overheating”)
- Listed common causes: excessive current draw, short circuits, wrong supply voltage, poor heat dissipation, faulty regulators, etc.
- Resolution: general advice only, no specific case solved.

✅ Overall Pattern

Most overheating started from power supply issues: using USB + external power simultaneously, applying 12 V to VIN, or faulty regulators.
Regulators (AMS1117, LM7805) and ATmega328P chips were the common failure points.
Few cases were actually repaired — most ended with replacement boards or advice to discard.

Simulation of Bluepill (STM32F103C8T6) LED blinking circuit in Proteus

2026-04-13T04:59:00.002+05:45

I just made a Bluepill (STM32F103C8T6) simulation part in Proteus and wanted to show this here. The circuit is simple a hello world circuit, that it is a LED blinking circuit. I used the proteus default Arduino for STM32 compiler which is arm-none-eabi-gcc. The program code is simple and one can use the same Arduino programing language.

Below shows the circuit diagram.

As you can see the LED is connected to port pin PC13. The code for led blink is very simple and provided below.


/*
 * Bluepill Blink for STM32 Official Core
 * Onboard LED is connected to PC13
 */

void setup() {
  // Initialize PC13 as an output
  pinMode(PC13, OUTPUT);
}

void loop() {
  // On the Bluepill, the LED is ACTIVE LOW
  digitalWrite(PC13, LOW);  // Turn the LED ON
  delay(500);               // Wait 500ms
  
  digitalWrite(PC13, HIGH); // Turn the LED OFF
  delay(500);               // Wait 500ms
}

This is the same programming code like in standard Arduino. Nothing really to explain.

The following video shows how I built the Bluepill(STM32F103C8T6) LED blinking circuit in Proteus.

Bluepill uses STM32F103C8T6 microcontroller, see the STM32F103C8T6 chip pinout explorer for faster building of circuit.

Fixing My DIY Arduino PCB Design Mistakes After 3 Years

2026-04-11T19:39:00.002+05:45

About three years ago, I built and manufactured a DIY Arduino board with a custom PCB design. I created the schematic and PCB layout myself and had it fabricated by NextPCB. They were generous enough to manufacture and provide the board free of charge.

After receiving it, I assembled the components onto the board, but unfortunately, it didn’t work. That was disappointing, and despite my efforts, I couldn’t identify the fault. I had always wanted to figure out what went wrong, but between being busy and uncertain whether repair was even possible, I left it aside. At the time, everything looked fine to me, yet the problem remained hidden.

This week, I finally had the chance to revisit the board. I investigated thoroughly, discovered the issues, and repaired it. Now, it works perfectly.

The problems were in my design—I had made a couple of mistakes in the schematic. NextPCB had manufactured the board exactly as I had designed and submitted the files, so the errors were entirely on my end. Actually, NexPCB did a fantastic job. Their tools were easy to use, process of uploading pcb design files, finding possible layout error was also fantastic. The NextPCB DFM tool, better known as HQDFM, is a free online Gerber viewer and Design for Manufacture (DFM) tool that helps analyze PCB production files. You can also download the HQDFM tool for free.

Actually, this time around, it did not take long to find and solve the problems on the PCB board. I began troubleshooting by checking all the pins of the ATmega328P to the headers with a continuity checker. There was nothing wrong with the connection between the IC pins to the header pins. This was a bit of a relief, but at the same time it was also scary since the problem could be far more serious, possibly beyond repair. I think I did this continuity check back when I first realized the board was not working.

There were several mistakes in my circuit and PCB design, and I wanted to record here my hands on experience repairing the board. The main problem was the power supply connection to the Vcc pin, incorrect use of one of the resistor value, used a capacitor which was not needed at all, connection to the Vref pin.

I will break the problem and explain individually how I repaired them.

1. Reset Pin 1 direct connection to Vcc pin 7

This was one of the main blunders. I connected the reset pin 1 directly to the Vcc pin 7. This was a fatal connection. The $V_{CC}$ pin 7 is connected to power supply +5V via the $R_1$ $10 k\Omega$ resistor. That is the $R_1$ $10 k\Omega$ resistor is sitting between the $V_{CC}$ pin 7 and +5V power supply. This is shown in the circuit schematic and on the PCB layout.

The fix:

To remedy this, I had to physically cutoff the trace between the reset pin 1 and $V_{CC}$ pin 7.

2. AVCC pin 20 was left unconnected.

Another blunder was that the $AV_{CC}$ pin 20 was left unconnected. It was just routed to the header pin as shown in the picture below. The thing is even if we aren't using the ADC, $AV_{CC}$ must be powered for the chip to function reliably. The ATmega328P uses this pin to power the internal ADC and some of the Port C I/O. If left floating, I might get erratic behavior on those pins.

The Fix:

I solved this by connecting the ( $AV_{CC}$ 20 to $V_{CC}$ added a small jumper wire between Pin 7 ( $V_{CC}$ ) and Pin 20 ( $AV_{CC}$ ).

V_{CC}

3. Capacitor removed

$0.1\mu\text{F}$ capacitor ( $C_6$ ) was connected from one end of the $R_3$ $10 k\Omega$ $10\text{k}\Omega$ resistor to the header pin. In Arduino-compatible designs, a $0.1\mu\text{F}$ capacitor is used for Auto-Reset.

The Fix:

$C_6$ was removed from that position. Perhaps at the time when I made the circuit it was intended for DTR/Auto-Reset (for programming via USB-to-Serial). It should sit between an external "DTR" pin and Pin 1 if that were the case. But for now, I just cut off the capacitor as I was more interested in running the board and so I simply bridged or joined its legs as shown in the picture below.

4. AREF Cap:

I came to know that while it is not strictly "critical" for the chip to boot, adding a

0.1\mu\text{F}

cap on Pin 21 to Ground is standard practice to keep your analog readings stable. So, I connected one as shown in the picture below.

5. The Resistor $R_2$ value

When I measured the voltage at the output of the LM317 voltage regulator and at the reset pin 1 of the ATmega328P IC, I got 5.6V. In my original design, I used 3.3 $k \Omega$ resistor for $R_2$. I had used LM317 voltage regulator (I know there are better IC for this) and the output voltage was set by the $R_1$ and $R_2$ resistors value.

Since I used

R_1 = 1\text{k}\Omega

and

R_2 = 3.3\text{k}\Omega

, the math for a LM317 adjustable regulator is:

V_{out} = 1.25 \times \left(1 + \frac{3300}{1000}\right) = 5.375\text{V}

When one adds in the Adjustment Pin Current (usually about $50\mu\text{A}$ to $100\mu\text{A}$ ) that flows through $R_2$ , the voltage climbs even further. On the board, that current adds roughly another $0.2\text{V}$ to $0.3\text{V}$ :

5.375\text{V} + (100\mu\text{A} \times 3300\Omega) \approx \mathbf{5.7\text{V}}

The Fix:

I replaced the $3.3\text{k}\Omega$ resistor with a $2.7\text{k}\Omega$ resistor. Using $ R_1=1\text{k}\Omega$ and $R_2=2.7\text{k}\Omega$ I got roughly

5.1\text{V}

, which is perfect.

So, these are the fixes I made. Below is picture that shows the bottom side of the PCB board where I made the various changes.

The board size is comparable to the standard Arduino Uno as shown in the picture below.

I inserted a pre-programmed Atmega328P programmed to blink a LED connected to PD2 pin to test the board. As soon as I inserted the chip into the IC holder, it turned on and started blinking. This was a big relief for me. Since I have 5 or more of these boards, I can now reuse them in various projects.

I recorded all the repair work, soldering and what not if you wish to know how I did that.

Special thanks to NextPCB for the excellent PCB board and the support. I highly recommend their HQDFM tool which is a free online Gerber viewer and Design for Manufacture (DFM) tool that helps analyze PCB production files.

Running Out of Pins? I2C alternative to Control a 16x2 LCD with Arduino 3 Pins

2026-04-10T17:18:00.004+05:45

In complex project using Arduino that requires 16x2 LCD for display it can be problematic. Because using a 16x2 requires at least 6 digital pin (RS, EN, D4, D5, D6, and D7). Your digital pins and analog pins maybe exhausted because you have potentiometer and other sensors already connected. So in large projects with Arduino I/O pins quickly runs out. One may use a I2C LCD as inArduino Nano I2C LCD Interfacing & Programming, but you may have already used it for connecting other peripheals to the available I2C pins. Such problem forces hobbyists to either upgrade to boars like Arduino Mega or sacrifice features to keep the LCD display.

The problem of I/O pin exhaustion can be solved using the 74HC595 shift register. By using the 74HC595 "Serial-In, Parallel-Out" (SIPO) architecture, you can control all the data and control lines of the display using only 3 digital pins (Data, Clock, and Latch). You can send the data like Analog sensor data to the 74HC595 in a serial stream and the shift register unpacks and sends out in parallel data to the 16x2 LCD. This effectively frees up three additional pins for other sensors or actuators while maintaining a fast, responsive interface for real-time data visualization.

An example circuit is shown below. Here Arduino Nano is used to read the POT value and sends the data to shift register IC serially. The Arduino 3 pins D2,D3 and D4 is connected to the shift register DS,STCP and SHCP pins respectively. The LCD16x2 pins D7 to D4 are connected to the shift register Q1 to A4 pins, the EN and RS pins are connected to the Q5 and Q6 respectively.

In the above circuit, a 10k POT is connected to Arduino A0 pin to read analog values which are then send serially to shift register 74HC595 which processes the serial data and sends them in parallel to the LCD.

In this way you can save the pins on Arduino and use it for other important connections.

Below is the program code that reads analog signal and display the analog voltage values on the 16x2 LCD.


#include <LiquidCrystal_74HC595.h>

// Shift Register Pins
const int dataPin  = 2; 
const int latchPin = 3; 
const int clockPin = 4; 

// Potentiometer Pin
const int potPin = A0;

// Mapping: (data, clock, latch, RS, E, D4, D5, D6, D7)
// RS=6, E=5, D4=4, D5=3, D6=2, D7=1
LiquidCrystal_74HC595 lcd(dataPin, clockPin, latchPin, 6, 5, 4, 3, 2, 1);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Voltage Meter");
  delay(1000);
  lcd.clear();
}

void loop() {
  // Read the raw value (0 to 1023)
  int rawValue = analogRead(potPin);
  
  // Convert raw value to voltage (0.0 to 5.0)
  // Formula: (Raw Value * Input Voltage) / Max Resolution
  float voltage = (rawValue * 5.0) / 1023.0;

  // Display on LCD
  lcd.setCursor(0, 0);
  lcd.print("Raw: ");
  lcd.print(rawValue);
  lcd.print("   "); // Clear trailing digits

  lcd.setCursor(0, 1);
  lcd.print("Volt: ");
  lcd.print(voltage, 2); // Display with 2 decimal places
  lcd.print(" V  ");

  delay(200); // Small delay to make the screen readable
}

This code creates a digital voltmeter using an Arduino. It reads an analog signal from a potentiometer and displays both the raw digital value and the calculated voltage on an LCD screen.

Because standard LCDs use many pins, this code uses a 74HC595 Shift Register to control the screen using only three digital pins from the Arduino.

1. Library and Pin Configuration

The code starts by including the specific library needed to talk to an LCD through a shift register.

Shift Register Pins: dataPin, latchPin, and clockPin are the three wires that send data from the Arduino to the 74HC595 chip.
The Constructor: The line LiquidCrystal_74HC595 lcd(...) tells the library exactly how the shift register pins are wired to the LCD's pins (RS, Enable, and Data lines).

2. The Setup Phase

The setup() function runs once when the Arduino powers on:

lcd.begin(16, 2): Initializes the screen size (16 columns, 2 rows).
Splash Screen: It prints "Voltage Meter" for one second before clearing the screen to start measurements.

3. Reading and Converting Data

Inside the loop(), the Arduino performs the math required to turn electricity into numbers.

analogRead(potPin): The Arduino's Analog-to-Digital Converter (ADC) converts the voltage (0V to 5V) into a whole number between 0 and 1023.
The Math: To get the actual voltage back, we use this formula:
$V_{out} = \frac{\text{Raw Value} \times 5.0}{1023}$
Using float ensures the result includes decimal points (e.g., 3.45V) rather than just rounding to the nearest whole number.

4. Updating the Display

The code updates the screen every 200 milliseconds:

setCursor(0, 0): Moves the "typing cursor" to the top-left.
print(voltage, 2): The 2 tells the Arduino to show exactly two digits after the decimal point.
Trailing Spaces: You’ll notice lcd.print(" "). This is a clever trick to "erase" old characters. For example, if the value drops from "1000" to "99", the extra spaces ensure the "0" from the old number isn't left behind on the screen.

Watch the following circuit demo in the following video:

Related

Redesigned Arduino Based Buck Converter : N-Channel vs. P-Channel Buck Converter:

2026-04-09T05:03:00.000+05:45

I wrote about how N-channel MOSFET on the high side in buck converter design and why it will not work in my previous note Why High-Side N-Channel Buck Converters Fail. Although there is advantage to using n-channel on the side which is that the n-channel are fasters and cheaper than p-channel MOSFET, with additional circuit such as using charge pump or bootstrap circuit, it won't work as expected.

The main hurdle with n-channel MOSFET on the high side (connected between the source and load) is that, to to fully turn on an N-channel MOSFET, the Gate voltage ( $V_G$ ) must be significantly higher than the Source voltage ( $V_S$ ). So, when the MOSFET turns on, the Source voltage rises to nearly the supply voltage ( $V_{CC}$ ). And to stay "on," we required that the gate voltage be higher than the power supply voltage plus the gate to source voltage threshold:$$V_G > V_{CC} + V_{GS(th)}$$The result is that we can't just use the supply voltage to toggle the gate; you need a voltage higher than the supply itself.

The following shows the circuit diagram of buck converter with N-channel MOSFET on the high side that will not work.

The detailed reasons why N-channel MOSFET on high side in buck converter is not suitable is explained in detail in my previous blog post Why High-Side N-Channel Buck Converters Fail.

There are couples of solutions we could use here to fix the problem. These solutions are:

Charge Pumps: Small circuits that "pump up" a voltage higher than the rail.
Bootstrap Circuits: Frequently used in PWM applications (like motor drivers or buck converters). It uses a capacitor and a diode to "lift" the gate voltage above the rail every time the MOSFET switches.
High-Side Gate Driver ICs: Dedicated chips (like the IR2110 or similar) that handle all this headache for you.
P-channel MOSFET: Replace the n-channel MOSFE with p-channel MOSFET.

I used the 4th solution; I replaced the n-channel MOSFET with p-channel MOSFET. This is the most direct way to simplify a high-side switch because it eliminates the need for voltages higher than the supply rail.

Circuit Schematic

The circuit diagram below shows n-channel MOSFET replaced by p-channel MOSFET on the high side of the Arduino based buck converter.

This circuit is a DC-to-DC Buck Converter designed to step down a higher DC voltage (12V) to a lower, regulated DC voltage (like 5V). It uses PWM (Pulse Width Modulation) from an Arduino to control a high-speed electronic switch.

Here is the step-by-step breakdown of how the hardware works together:

1. The Switching Stage (Control)

The Arduino (at Pin 9) generates a PWM signal. However, an Arduino pin cannot handle 12V or the high current needed for the MOSFET.

Q1 (2N2222A Transistor): Acts as a level-shifter. When Pin 9 goes HIGH, Q1 turns on and pulls the Gate of the MOSFET to Ground.
Q2 (IRF4905 P-Channel MOSFET): This is the main "Power Switch." Because it’s a P-Channel, it turns ON when its gate is pulled low (0V) and OFF when the gate is pulled high (12V via resistor R2).
Result: The 12V input is "chopped" into high-frequency square pulses.

2. The Power Stage (Conversion)

The chopped 12V signal is not usable DC yet. This is where the filter components come in:

L1 (Inductor): When the MOSFET is ON, current flows through the inductor, storing energy in a magnetic field. When the MOSFET turns OFF, the magnetic field collapses, and the inductor continues to push current toward the load.
D1 (1N5822 Schottky Diode): This is the "Flyback" or "Freewheeling" diode. When the MOSFET turns off, the inductor needs a path to pull current from Ground to keep the loop complete.
C1 (Output Capacitor): This acts as a reservoir. It charges during the "ON" cycle and discharges during the "OFF" cycle, smoothing out the voltage pulses into a steady DC line.

3. The Feedback Stage (Monitoring)

To ensure the output is correct, the Arduino needs to measure the voltage, but its pins can only handle up to 5V.

R3 & R4 (Voltage Divider): These resistors (14k and 10k) scale the output voltage down. For example, if the output is 12V, the Arduino sees roughly 5V at Pin A1.
C2 (Feedback Filter): This small capacitor filters out high-frequency switching noise from the divider, ensuring the Arduino gets a clean, "rock-solid" reading for its calculations.
RV1 (Potentiometer): This allows the user to manually set the target voltage. The Arduino reads this value and adjusts the PWM duty cycle accordingly to reach the desired output.

Summary Table: Component Roles

Component	Function
MOSFET (Q2)	The high-speed switch that "chops" the 12V input.
Inductor (L1)	Smooths current and stores energy during the "OFF" cycle.
Capacitor (C1)	Smooths voltage ripple to provide steady DC.
Diode (D1)	Provides a return path for current when the switch is open.
Resistors (R3/R4)	Protect the Arduino by scaling the voltage down for measurement.

Some additional notes on the resistors $R_1$ and $R_2$.

Base Resistor ( $R1$ ): In the previous buck converter design I used base resistor of $1 k\Omega$. Here I increased to something to $2.2 k\Omega$. Increasing the base resistor reduces the strain on the Arduino pin while still providing plenty of switching speed.
Pull-Up Resistor ( $R2$ ): To achieve the high-speed 31.25 kHz switching rates I lowered Gate pull-up resistor from 10k from previous buck converter design down to $1 k\Omega$. This helps the MOSFET turn OFF faster, which reduces heat

Tip: Use the online Buck Converter Calculator to calculate the inductor and capacitors value for given switching frequency. Also see the Arduino Interactive Pinout Web Tool for planning pins. Both are free web tools on my blog.

Program Code

/*
 * BUCK CONVERTER MANUAL CONTROL (32.25kHz)
 * Developed for: ee-diary.net
 * Schematic: P-Channel IRF4905 with NPN Driver
 */

const int pwmPin = 9;      
const int potPin = A0;     
const int feedbackPin = A1; 

// Resistor values matching your Proteus Schematic (1.png)
const float R3 = 14000.0; // 14k Top Resistor
const float R4 = 10000.0; // 10k Bottom Resistor
const float dividerRatio = (R3 + R4) / R4; 

void setup() {
  Serial.begin(115200);
  pinMode(pwmPin, OUTPUT);

  // Set Timer 1 to 31.25kHz (Prescaler 1)
  TCCR1B = (TCCR1B & 0b11111000) | 0x01;

  Serial.println("--- BUCK CONVERTER: ee-diary.net ---");
  Serial.println("Adjust Potentiometer to reach target voltage");
  Serial.println("-----------------------------------------");
}

void loop() {
  // Read the potentiometer (0 to 1023)
  int potValue = analogRead(potPin);

  // Map to standard 8-bit PWM range (0 to 255)
  // At 1kHz, 255 = 100% Duty Cycle (Full Battery Voltage)
  int pwmValue = map(potValue, 0, 1023, 0, 255); 

  // Output the PWM to the MOSFET driver
  analogWrite(pwmPin, pwmValue);

  // Non-blocking timer for Serial monitoring
  static unsigned long lastPrint = 0;
  if (millis() - lastPrint > 400) { 
    
    // Read output voltage via the voltage divider
    float vRaw = analogRead(feedbackPin) * (5.0 / 1023.0);
    float actualVolts = vRaw * dividerRatio;

    // Display data for debugging
    Serial.print("POT: ");     Serial.print(potValue);
    Serial.print(" | PWM: ");  Serial.print(pwmValue);
    Serial.print(" | OUTPUT Voltage: "); Serial.print(actualVolts, 2);
    Serial.println("V");
    
    lastPrint = millis();
  }
}

The code is a bridge between the physical hardware and the logic needed to regulate power. It handles three main tasks: High-speed switching, User Input handling, and Real-time Voltage Math.

Here is the breakdown of the code:

1. Configuration & Calibration

const float R3 = 14000.0; 
const float R4 = 10000.0; 
const float dividerRatio = (R3 + R4) / R4; 

The Math: Since the Arduino cannot "read" 12V directly, your schematic uses a voltage divider. This dividerRatio (which is 2.4) tells the code how to "magnify" the small 0-5V signal back up to the real 0-12V value for the Serial Monitor.

2. The High-Speed Heart (Timer Setup)

TCCR1B = (TCCR1B & 0b11111000) | 0x01;

The "Overclock": By default, Arduino PWM is very slow (about 490Hz). This line modifies the Timer 1 hardware register.
By setting the prescaler to 0x01, you are pushing the frequency to 31.25kHz. This high speed is what allows you to use that small 155µH inductor instead of a massive one.

3. The Control Loop (The "Brain")

int potValue = analogRead(potPin);
int pwmValue = map(potValue, 0, 1023, 0, 255); 
analogWrite(pwmPin, pwmValue);

Input: It reads the 10k Potentiometer position.
Translation: It maps that position to a 0-255 "Duty Cycle" value.
Action: analogWrite tells the MOSFET how long to stay open.
- PWM 0: MOSFET always OFF (0V Output).
- PWM 255: MOSFET always ON (12V Output).
- PWM 127: MOSFET ON 50% of the time (~6V Output).

4. Serial Monitor

if (millis() - lastPrint > 400) { 
    float vRaw = analogRead(feedbackPin) * (5.0 / 1023.0);
    float actualVolts = vRaw * dividerRatio;
}

Non-Blocking Delay: Using millis() instead of delay() is crucial. It allows the Arduino to keep switching the MOSFET perfectly while only pausing to print text to your screen every 400 milliseconds.
Precision Math: It converts the raw binary data (0-1023) back into Volts, then applies the dividerRatio so you see the actual output voltage on your Serial Monitor.

Video

The following video shows how the Arduino buck converter woks, explains the circuit and circuit components in details.

Related

Why High-Side N-Channel Buck Converters Fail

2026-04-08T02:19:00.001+05:45

I posted about an open loop, non-synchronous, high side N-MOSFET diy Arduino based buck converter design earlier. But after researching, I came to know that it will not work. I need to rewrite that blog post. But before doing that I wanted to write a new one and record what was wrong in that buck converter circuit.

Here is the circuit design of the buck converter that was failing.

There are several design errors in this circuit. The main problem with this buck converter circuit design is that I used N-channel MOSFET IRFZ44N on the high side (between the power supply and the load). The reason this will fail or will generate heat is that, when the output PWM signal coming from Arduino is high, the transistor BD139 will turn ON, and the Gate of the N-channel MOSFET is pulled low to ground turning off the N-channel MOSFET. Now as soon as the n-channel MOSFET turns on, the source terminal of the MOSFET rises to 12V. But to keep the MOSFET ON the gate voltage requires gate to source voltage of 10V(for IRFZ44N the $V_{GS}$ >10V) which means the gate voltage must be 15V $V_{GS}$ ) if we want 5V supplied to the load since $V_{GS} = V_{Gate} - V_{Source}$, that is,$V_{Gate} = V_{Source} + V_{GS}$=$V_{Gate} = 5\text{V} + 10\text{V} = \mathbf{15\text{V}}$. But the circuit only has 12V available from the battery. When the Gate reaches 12V, and the Source tries to reach 5V, the $V_{GS}$ is only 7V. This is enough to turn the MOSFET partially on, but not fully.Because the MOSFET isn't fully "ON," it acts like a resistor. It will "eat" the missing voltage and turn it into heat. Similarly, and this is the second reasons why this circuit will fail is that when the PWM signal is low(0V) then the transistor BD139 is turned off. In this case, the 10kohm resistor pulls up the gate voltage to the +12V power supply and $V_{GS}$ becomes 0V because the source voltage is same as gate voltage. This implies that the N-channel MOSFET is turned off cutting off the path between the 12V power supply and the rest of the circuit. Though the power supply is completely cut off, current does not stop immediately. The current stored in the inductor L1 tries to flow in the same direction and to do this it reverses its polarity. So, the junction where the diode, inductor and the MOSFET meet becomes now negative. This in turn forward biases the Schottky diode 1N4148. Now the current flows in a loop, from inductor to capacitor/bulb to ground, to diode and back to the inductor. In this case the diode is stressed. The 1N4148 diode is now doing 100% of the work to keep the bulb lit using the energy stored in the inductor. And here is another mistake in the circuit. The 1N4148 diode is 200mA rated and so if the bulb wants, say 1A, the diode cannot keep up and will most likely burn out during this situation.

So, the fixes to this wrongly designed Arduino based buck converter design is not to use N-Channel MOSFET on the high side but use P-channel MOSFET like an IRF9540 MOSFET. Using p-channel MOSFET at the high side the current driver BD139 Q2 will correctly pull the gate to ground to turn it on.

Another fix is about the diode. The 1N4148 is small signal switching diode rated only 200mA. The buck converter inductor "kicks back" significant current through this diode every time the MOSFET switches off and therefore burn out. The solution to this is to use schotty diode that is at least $3\text{A}$ to $5\text{A}$ , such as a 1N5822 or SR540. Schottky diodes are necessary because they switch fast enough for PWM.

Another modification in the circuit that should be done is about the high-frequency noise on the 12V input line. Switching circuit like buck converter circuit produces massive high-frequency noise. The remedy for this is to use a large electrolytic capacitor (e.g., $470\mu\text{F}$ ) in parallel with the battery, as close to the MOSFET as possible, to stabilize the input voltage.

The corrected circuit schematic along with result is in the next article, Arduino Buck Converter Design - Open-Loop, Non-Synchronous, High-Side P-MOSFET.

Related

Testing Attiny45 ADC functionality in Proteus

2026-04-07T20:18:00.002+05:45

Here I want to share simple Attiny45 ADC circuit. The Attiny has is 10-bit ADC hardware internally. To test this ADC functionality, I have connected a $10 k \Omega$ potentiometer to the pin PB4 and connected a LED to pin PB0. The Attiny45 microcontroller has 4 ADC pins which are PB2,PB3,PB4 and PB5.

ATtiny45 ADC Pin Mapping

ADC Channel	Physical Pin	Port Pin
ADC0	Pin 1	PB5 (Also the Reset Pin*)
ADC1	Pin 7	PB2
ADC2	Pin 3	PB4
ADC3	Pin 2	PB3

This can be visualized using the ATtiny45 IC pinout explorer.

Remember that PB5 is also the Reset pin so usually it is not used.

So the test is to use the potentiometer to input analog signal to the Attiny45 via PB4 and if the voltage is above 2.5V then the LED connected to pin PB0 is turned on.

The following is the circuit diagram for testing the ADC functionality of ADC of Attiny45.

The following is program code to test the functionality of Attiny45 ADC.


#include <avr/io.h>
#include <util/delay.h>

void adc_setup() {
    // 1. Set Voltage Reference to VCC (leave REFS0 at 0)
    // 2. Select Input Channel ADC2 (PB4) by setting MUX1 bit
    ADMUX |= (1 << MUX1);

    // 3. Set ADC Prescaler to 128 (ADPS0, ADPS1, ADPS2 = 1)
    // This scales the 9.6MHz or 1.2MHz clock down to a usable range (50-200kHz)
    ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

    // 4. Enable the ADC
    ADCSRA |= (1 << ADEN);
}

uint16_t adc_read() {
    // Start the conversion
    ADCSRA |= (1 << ADSC);

    // Wait for conversion to finish (ADSC bit returns to 0)
    while (ADCSRA & (1 << ADSC));

    // Return the 10-bit result (ADCL + ADCH)
    return ADC;
}

int main(void) {
    // Set PB0 as an output (for an LED)
    DDRB |= (1 << DDB0);
    
    adc_setup();

    while (1) {
        uint16_t val = adc_read();

        // If input > ~2.5V (assuming 5V VCC, 512 is half of 1024)
        if (val > 512) {
            PORTB |= (1 << PB0);  // LED ON
        } else {
            PORTB &= ~(1 << PB0); // LED OFF
        }
        
        _delay_ms(50);
    }
}

This code is a classic "Threshold Switch." It translates an analog voltage into a digital action (turning an LED on or off). Because the ATtiny45 and ATtiny13 share very similar register structures for the ADC, this specific code works almost identically on both.

Here is the breakdown of what each section is doing:

1. The Configuration (`adc_setup`)

This function wakes up the ADC and tells it how to behave.

ADMUX |= (1 << MUX1); The ADMUX register (ADC Multiplexer Selection) acts like a rotary switch. Setting MUX1 to 1 connects the ADC hardware to PB4 (Pin 3). Note: By leaving the REFS bits at 0, you are telling the chip to use VCC as the "yardstick" for measurement.
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); The ADC needs a clock speed between 50kHz and 200kHz to be accurate.
- ADPS (Prescaler bits): Setting all three to 1 creates a division factor of 128.
- If your chip is at 9.6MHz, the ADC runs at 75kHz.
- If your chip is at 1.2MHz, the ADC runs at 9.3kHz (which is actually a bit slow for the ATtiny45, but it will still function).
ADCSRA |= (1 << ADEN); This is the "Power Button" for the ADC. Without setting the ADC Enable bit, the converter stays off to save power.

2. The Measurement (`adc_read`)

This function handles the "Sample and Hold" process.

ADCSRA |= (1 << ADSC); The Start Conversion bit tells the ADC to take a "snapshot" of the voltage on the pin right now.
while (ADCSRA & (1 << ADSC)); This is a "blocking" loop. The ADSC bit stays 1 as long as the chip is busy calculating. As soon as it finishes, the hardware flips the bit back to 0 and the code moves on.
return ADC; This returns a 10-bit number (0 to 1023). Even though the result is split into two 8-bit registers (ADCL and ADCH), the compiler allows you to just read ADC to get the full 10-bit value at once.

3. The Logic (`main`)

DDRB |= (1 << DDB0); Configures PB0 (Pin 5) as an Output so it can drive the LED.
if (val > 512) Since the maximum value is 1023, 512 is the halfway point.
- If the pin sees more than half of the supply voltage (> 2.5V on a 5V system), the LED turns on.
- If it sees less, the LED turns off.
_delay_ms(50); This prevents the chip from running at full speed, which saves power and reduces "jitter" if the voltage is hovering right at 2.5V.

I like to add that while this code works, the ATtiny45 has a feature the ATtiny13 lacks: Internal Voltage References. If your battery voltage drops, your "2.5V threshold" will actually shift because the reference (VCC) is changing. On the ATtiny45, you could change ADMUX to use the Internal 1.1V or 2.56V reference, which stays steady even if your power supply fluctuates.

The following is how to create and simulate the circuit.

Related

Ubiquiti Radio Hardware Repair: A Comprehensive Service Guide

2026-04-06T21:04:00.005+05:45

In my earlier Ubiquiti radio antenna repair note repairing Ubiquiti Lite AP 120 I said that I checked the various components on the PCB board. I checked the voltage regulator IC, the capacitors and inductors for any short circuit. I also posted Ubiquiti Lite AP 120 repair video on YouTube, but that video only showed how I checked the various components on the PCB board. There was comment asking where the actual repair was. I did not have time to upload and write about it but today I wanted to share how I repaired it.

After I checked, I found that one of the capacitors was short circuit. So, I knew it is something there.

But closer check of the capacitor alone it was reading fine. Then I realized that one of the IC connected to that short-circuited capacitor might be actual fault component. At first, I did not know what kind of IC that was or what the function of that IC was. I also did not know the name of the IC otherwise I would have checked online. One thing I learned is that checking the capacitor for short-circuit tells that the IC to which it is connected to or rather is part of the IC supporting component

However, I managed to find out what that IC was. It was a voltage regulator, more specifically a buck converter. Once I was sure it was a buck converter IC I searched for suitable replacement. After researching for a while I concluded that I could use the MP1548 buck converter IC.

Although I found it, it was difficult to find the IC to buy where I live. So, thinking for a while, I searched for the IC that comes in module. The solution was to use the MP1584 DC to DC Buck Converter module.

Then I had to figure out how to connect and what is the input and output which was easy because of the internet. I used the MP1584 IC pinout explorer to get to know the IC. This free interactive IC explorer makes easy to learn about any IC rather than reading large complex datasheet. There were only the input and output which I had to consider.

Here are some useful details about it.

🔧 MP1584EN DC-DC Buck Converter Module Overview

Input Voltage Range: 4.5V to 28V DC
Output Voltage Range: Adjustable from 0.8V to 20V DC
Key Components:
- MP1584EN Buck IC: Core switching regulator for voltage step-down
- SS34 Diode: Provides overload current protection
- Potentiometer: Allows manual adjustment of output voltage

⚡ Pin Configuration

Pin Label	Function
INPUT +	Positive DC input (4.5V–28V)
INPUT –	Negative DC input (ground)
OUTPUT +	Positive DC output (0.8V–20V)
OUTPUT –	Negative DC output (ground)

This module is ideal for powering lower-voltage devices from a higher-voltage source, commonly used in DIY electronics and embedded systems.

After figuring these out, I desoldered the damaged voltage regulator IC from the Ubiquiti radio PCB board and soldered the MP1584 voltage regulator. After a bit of researching, I found out that the input terminal of the MP1548 buck converter should be connected to Vin (input pin) or the 7th pin of the desoldered IC. The output terminal of the MP1584 should be connected to the SMD capacitor terminal. This is as shown in the picture below.

The -ve terminals of the input and output of the MP1584, the black wires should be connected to the common ground as shown below.

For comparison purpose, I am showing below both the repaired and working condition Ubiquiti LAP120 radio PCB board.

After that I checked it and it was working.

So, in this way I checked for the Ubiquiti radio faulty component and replaced the voltage regulator/buck converter and successfully repaired it. This guide is not only applicable to Ubiquiti LAP 120 radio hardware but should be applicable to any Ubiquiti radio and most likely other radio and equipment.

Watch the complete Ubiquiti radio hardware repair video.

I hope this repair guide will help you and if you have any problem, please leave your comment or contact me via the contact page.

Automated Sound-Triggered Alarm with ATmega328P External Interrupts

2026-04-06T00:04:00.004+05:45

I built a circuit that detects sound and sound a buzzer using ATmega328P external interrupt. It can be used in application like automated library noise alert system for school or college. Silence is critical in libraries, and this circuit monitors ambient sound levels in real time. So, when students begin talking too loudly and noise exceed a pre-set threshold then ATmega328P interrupt is triggered instantly which actives a buzzer to provide an immediate reminder to maintain silence. This is only one of many applications that can be built around it. It can be used to monitor baby is crying or detect thief. Other applications include automated clap switch, which turns on/off a light with clap sound, in industrial factories to detect thud or bang sound indicating machinery failure or jamming conveyor belt, voice activated automated system for home, automated photo camera trigger when some sound is produced etc.

The automated sound detector and triggering is enabled using ATmega328P external interrupt feature. I had written about how the external interrupt of ATmega328P works where I showed what external interrupt is and how to use it and how to write external interrupt program with code example. This time a real-world application example is provided with explanation of how the automated sound based triggering system using ATmega328P external interrupt works.

Below is the circuit diagram.

How the Circuit Works

The circuit operates in three distinct stages:

Stage 1: Detection (The Mic & Comparator): The electret microphone converts sound waves into a tiny AC voltage. The LM393 comparator compares this "wiggling" voltage against a reference voltage set by your 10kΩ potentiometer.
Stage 2: Logic (The ATmega328P): When the sound voltage crosses the threshold, the LM393 output drops Low. This "Falling Edge" triggers the INT1 (PD3) interrupt on the ATmega328P. The CPU pauses its current task and jumps to the Interrupt Service Routine (ISR).
Stage 3: Output (The Transistor & Buzzer): The ISR sets PC5 High. This sends current through the 1kΩ resistor into the base of the 2N3904 transistor. The transistor acts as a high-speed switch, connecting the buzzer to Ground and completing the circuit to make it sound.

The transistor 2N3904 is critical in the circuit, because it decouples the electrical noise from the buzzer to the ground and saves the microcontroller from being damaged. Similarly, the 1k resistor connected between PC5 pin and base of the transistor is important. Without it the ATmega328p will try to push as much as it can through the base to emitter which is forward biased and this can damage the ATmega328P IC internal circuitry. Also, the output of the LM393 op-amp is open collector and therefore a 10k pullup resistor is used.

Programming and Code

The following is the program code for the automated sound detection and triggering using the ATmega328P external interrupt feature.


#ifndef F_CPU
#define F_CPU 16000000UL // Set to 1000000UL if using internal 1MHz clock
#endif

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define BUZZER PC0
#define MIC_INPUT PD3

void init_system() {
    // Set PC5 as Output for Transistor Base
    DDRC |= (1 << BUZZER);
    
    // Set PD3 as Input (LM393 with physical 10k pull-up)
    DDRD &= ~(1 << MIC_INPUT);
    
    // Configure INT1 for Falling Edge (LM393 output goes Low on sound)
    EICRA |= (1 << ISC11);
    EICRA &= ~(1 << ISC10);

    // Enable INT1
    EIMSK |= (1 << INT1);

    sei(); // Global Interrupts Enabled
}

ISR(INT1_vect) {
    // Sound detected! 
    PORTC |= (1 << BUZZER);  // PC5 High -> Transistor ON -> Buzzer Beeps
    _delay_ms(300);          // Duration of beep
    PORTC &= ~(1 << BUZZER); // PC5 Low -> Transistor OFF -> Buzzer Quiet
}

int main(void) {
    init_system();
    while (1) {
        // Idle
    }
}

This code makes use of external interrupt and is thus a event-driven program. What it means is that instead of the CPU constantly checking the sensor, polling, it "sleeps" until the hardware tells it to act.

Here is what the code does:

1. Configuration & Setup (`init_system`)

F_CPU: Tells the compiler your clock speed (16MHz) so the _delay_ms functions are accurate.
DDRC & DDRD: Sets the Data Direction. PC0 (Buzzer) is set as an Output, and PD3 (Mic) is set as an Input.
EICRA (External Interrupt Control Register A): This is the "trigger" setting. By setting ISC11, you configure INT1 to trigger on a Falling Edge (when the LM393 output drops from 5V to 0V).
EIMSK & sei(): These "turn on the lights." EIMSK enables the specific INT1 interrupt, and sei() enables interrupts globally across the chip.

2. The Interrupt Service Routine (`ISR`)

ISR function a special function used for external interrupt that causes ATmega328P CPU to execute immediately when sound is detected, pausing whatever else it was doing.

PORTC |= (1 << BUZZER): Sends 5V to the transistor base to start the beep.
_delay_ms(300): Keeps the buzzer active for a short burst so it is audible to the human ear.
PORTC &= ~(1 << BUZZER): Turns the signal off, resetting the circuit for the next sound.

3. The Main Loop (`main`)

while(1): This loop is empty! Because the hardware handles the detection via interrupts, the main CPU doesn't have to do any work. This makes the code extremely power efficient.

Video Demonstration

The following video demonstrates how the above circuit works.

Related

How to Build a Pure Sine Wave Inverter using Arduino SPWM

2026-04-05T15:37:00.014+05:45

It's early morning, 4:30 AM, and I just completed Arduino based pure sine wave inverter design. This inverter design is actually an improvement over the previous Arduino SPWM inverter design. The previous build Arduino inverter used simple transistor that has direct connection between the MOSFETs and Arduino PWM controller. It worked but the problem is the slow switching of the push pull MOSFETs. Slower switching of MOSFETs leads to heat generation because the energy gets trapped in the gate capacitance of the MOSFET. That is the reason why most diy inverter fails.

This version includes symmetrical totem pole driver using BC547/BC557 for the MOSFETs. By adding totem pole driver to drive the MOSFETs, the MOSFET gate capacitance gets discharged quicker resulting in faster operating, less heat generation and the MOSFETs operates in linear region. Most DIY inverters fail because of this. Furthermore, improvement has also been made in the software that generates the SPWM signal. The previous Arduino inverter code used Fast PWM whereas this improved version use Phase Correct PWM. Thus, the improvements are in both hardware and software.

Circuit Diagram

Below is the circuit diagram of the improved SPWM Arduino sine wave inverter.

This circuit diagam shows the revised Pure Sine Wave Inverter that uses SPWM (Sinusoidal Pulse Width Modulation) to convert $12\text{V}$ DC into AC power. It operates on a Push-Pull topology.

Here is the step-by-step breakdown of how it works:

1. The Control Brain (Arduino Nano)

The Arduino generates high frequency $10\text{kHz}$ SPWM signals from pins D9 and D10.

Instead of a simple square wave, the width of these pulses varies according to a sine lookup table.
D9 handles the positive half-cycle of the AC wave.
D10 handles the negative half-cycle.

2. The Gate Driver (Totem-Pole)

Arduino pins cannot provide enough current to rapidly charge and discharge the large internal capacitance of power MOSFETs.

Q1/Q5 and Q3/Q4 form Totem-Pole drivers.
The NPN transistor (top) quickly "pushes" current into the MOSFET gate to turn it ON.
The PNP transistor (bottom) quickly "pulls" current out to ground to turn it OFF.
The $10\text{k}\Omega$ resistors (R5/R6) ensure the gates stay at $0\text{V}$ during startup to prevent accidental shorts.

3. The Switching Stage (MOSFETs)

The MOSFETs (Q2 and Q6) act as high-speed electronic switches. They alternate at $50\text{Hz}$ , but while they are "ON," they are actually pulsing at the high carrier frequency $10\text{kHz}$ . This "chops" the $12\text{V}$ DC into a high-frequency SPWM signal.

4. The Transformer (Push-Pull)

The transformer has a Center-Tapped Primary.

When Q2 is active, current flows through the top half of the primary.
When Q6 is active, current flows through the bottom half in the opposite direction.
This alternating current (AC) in the primary induces a high-voltage AC signal in the secondary (e.g. $220\text{V}$ ).

5. The Output Filter (LC Filter)

The output from the transformer is still a "chopped" high-frequency signal.

The Inductor (L1) $2mH$ and Capacitor (C1) $2.2 \mu H$
form a low-pass filter.
They block the high-frequency switching noise and smooth out the pulses.
The result is a clean $50\text{Hz}$ Pure Sine Wave that powers the bulb (B1) just like a standard wall outlet.

Program Code

The Arduino program code for the above SPWM inverter is below.


/*
 * Pure Sine Wave SPWM Generator
 * Carrier Frequency: 20kHz (Silent Operation)
 * Output Frequency: 50Hz
 * Board: Arduino Nano / Uno (ATmega328P)
 */

#include <avr/pgmspace.h>

// 200-sample Sine Look-Up Table (Half-wave)
// Values scaled to 400 to match the ICR1 TOP value
const uint16_t sineTable[] PROGMEM = {
  0, 6, 12, 18, 25, 31, 37, 43, 50, 56, 62, 68, 74, 80, 86, 92, 98, 104, 110, 116, 
  122, 128, 134, 140, 146, 151, 157, 163, 168, 174, 179, 185, 190, 195, 200, 205, 210, 215, 220, 225, 
  229, 234, 238, 243, 247, 251, 255, 259, 263, 267, 271, 275, 278, 282, 285, 288, 292, 295, 298, 301, 
  304, 307, 309, 312, 315, 317, 320, 322, 324, 327, 329, 331, 333, 335, 337, 338, 340, 342, 343, 345, 
  346, 347, 349, 350, 351, 352, 353, 354, 354, 355, 356, 356, 357, 357, 358, 358, 358, 359, 359, 359, 
  359, 359, 359, 359, 358, 358, 358, 357, 357, 356, 356, 355, 354, 354, 353, 352, 351, 350, 349, 347, 
  346, 345, 343, 342, 340, 338, 337, 335, 333, 331, 329, 327, 324, 322, 320, 317, 315, 312, 309, 307, 
  304, 301, 298, 295, 292, 288, 285, 282, 278, 275, 271, 267, 263, 259, 255, 251, 247, 243, 238, 234, 
  229, 225, 220, 215, 210, 205, 200, 195, 190, 185, 179, 174, 168, 163, 157, 151, 146, 140, 134, 128, 
  122, 116, 110, 104, 98, 92, 86, 80, 74, 68, 62, 56, 50, 43, 37, 31, 25, 18, 12, 6
};

volatile uint16_t sampleIndex = 0;
volatile bool phase = 0; // 0 = Positive Half, 1 = Negative Half

void setup() {
  pinMode(9, OUTPUT);  // High Side MOSFET Drive
  pinMode(10, OUTPUT); // Low Side MOSFET Drive
  noInterrupts();

  // Mode 10: Phase Correct PWM, TOP = ICR1
  TCCR1A = _BV(WGM11);
  TCCR1B = _BV(WGM13) | _BV(CS10); // Prescaler = 1
  
  // ICR1 = 400 sets carrier frequency to 20kHz
  // Formula: 16MHz / (2 * 1 * 400) = 20,000 Hz
  ICR1 = 400; 

  TIMSK1 = _BV(TOIE1); // Enable Overflow Interrupt
  interrupts();
}

ISR(TIMER1_OVF_vect) {
  uint16_t dutyCycle = pgm_read_word(&sineTable[sampleIndex]);

  if (phase == 0) {
    // Positive half-cycle: D9 pulses, D10 stays OFF
    OCR1A = dutyCycle; 
    OCR1B = 0;
    TCCR1A |= _BV(COM1A1);  // Enable PWM on D9
    TCCR1A &= ~_BV(COM1B1); // Disable PWM on D10
  } else {
    // Negative half-cycle: D10 pulses, D9 stays OFF
    OCR1A = 0; 
    OCR1B = dutyCycle;
    TCCR1A &= ~_BV(COM1A1); // Disable PWM on D9
    TCCR1A |= _BV(COM1B1);  // Enable PWM on D10
  }

  sampleIndex++;

  // 200 samples at 20kHz = 10ms (one half-cycle)
  if (sampleIndex >= 200) { 
    sampleIndex = 0;
    phase = !phase; // Swap sides to create AC direction change
  }
}

void loop() {
  // Main loop remains empty; all timing is handled by Timer 1
}

This code is a high-speed SPWM generator that uses the Arduino's internal hardware timer to create a precise $50\text{Hz}$ sine wave.

Here is the breakdown of the logic:

1. The Sine Look-Up Table (The Map)

The sineTable contains 200 pre-calculated values representing a half-circle (sine wave).
The values range from 0 to 359. These tell the Arduino how long to keep the MOSFET "ON" at any given microsecond to mimic a sine wave's shape.

2. Timer 1 Configuration (The Engine)

Mode 10 (Phase Correct PWM): This is the most stable mode for power electronics. The timer counts up to a "TOP" value and then back down to zero.
ICR1 = 400: This sets the "TOP" limit. At a $16\text{MHz}$ clock speed, counting up and down to 400 creates exactly a $20\text{kHz}$ carrier frequency.
No Prescaler: This runs the timer at the full speed of the Arduino $16\text{MHz}$ for maximum precision.

Note: use the Arduino PWM online calculator.

3. The Interrupt Service Routine (The Brain)

The ISR(TIMER1_OVF_vect) is a special function that runs 20,000 times per second. Each time it runs, it performs three tasks:

Duty Cycle Update: It grabs the next value from the sine Table and loads it into the Pulse Width registers (OCR1A or OCR1B).
Phase Switching: It manages the Push-Pull logic.
- Phase 0: It sends the pulses to Pin 9 and keeps Pin 10 at $0\text{V}$ .
- Phase 1: It sends the pulses to Pin 10 and keeps Pin 9 at $0\text{V}$ .
Timing Control: It counts the samples. After 200 samples, it knows that $10\text{ms}$ has passed (half of a $50\text{Hz}$ , so it flips the phase to the other MOSFET.

4. Why This Works for an Inverter

By rapidly switching the MOSFETs on and off at $20\text{kHz}$ with varying "ON" times (the SPWM), the transformer "sees" an average voltage that looks like a sine wave.

Video Demonstraion

The following video demonstrates how this Arduino based SPWM Inverter circuit works. It shows charging and discharging of the MOSFET gate capacitance that reduces loss due to high frequency operation of the MOSFET by the totem pole driver.

Related

What is Bootstrapped Emitter Follower: Real-World Audio Example

2026-04-03T20:06:00.003+05:45

Here I redesigned the class AB audio amplifier that I had posted many years ago. In the original design, the microphone signal had to fight against the relatively low resistance of the biasing network. This often resulted in a muffled sound, lost treble, and a signal that was weak before it even reached the amplification stage. By adding the bootstrapped emitter follower $Q_1$ , we create an 'invisible' bridge for the audio. Let's first look at the circuit diagram.

Circuit Diagram

Below is the circuit diagram.

Bootstrap Circuit

In the above schematic, the bootstrap circuit is formed by the Q1 (the emitter follower transistor) together with the bootstrap capacitor (C2) and the biasing resistors R1 and R2. The R1 and R2 provides the DC bis to the Q1 base. The BJT transistor Q2 buffers the audio signal from the microphone and the capacitor C2 connects emitter signal back the R1 and R2 junction.

When the audio signal swings, C2 feeds part of the emitter voltage back into the bias divider. This makes the voltage across R1–R2 “follow” the signal, so from the microphone’s perspective those resistors appear to have a much higher impedance.

To clarify, the microphone is a high impedance source. It produces voltage signal but little current. Without the bootstrap circuit, the microphone or the source sees the 100KOhm load formed by the biasing resistors R1 and R2. The microphone or source tries to drive that load but fails and the result is drop of signal volume and loss of high frequency details of the audio signal coming from the microphone. So, this is impedance mismatch problem.

The solution to impedance mismatch is to use the bootstrap circuit. The bootstrap capacitor C2 feeds back the signal back to the junction of the biasing resistors R1 and R2. The voltage on both sides of the resistor moves together. Since there is almost no voltage difference across the resistor, almost no current flows. The result is the audio source, microphone, sees and input impedance of 1Mohm or more. The result is no or less loss of signal energy and no loss of frequency content of the audio signal and audio without muffled sound; lost treble is produced.

The following video shows via simulation how the bootstrapping circuit works.

In the video, we revisit a classic Class AB audio amplifier design and show how adding a bootstrapped emitter follower dramatically improves sound quality.

Related articles:

How to Expand ATtiny13 Outputs with 74HC595 Shift Register

2026-04-03T09:58:00.002+05:45

Attiny13 microcontroller have many unique advantage- low price, small size, versatile functionalities. Although it has small memory size or flash memory, it can be used in sensor and automation circuits. Some of the functionalities it has includes timers, external and interrupt support, PWM, SPI, ADC etc. but it lacks USART/UART hardware support. I used the Atiny13 IC pinout explorer and 74HC595 IC pinout explorer, datasheet alternative free web tool, to know pins functions and capabilities instantly. But as soon as one begins working with it problems start to emerge. The main limitations of Attiny13 MCU is the flash memory size and the I/O pins. Limited flash memory means, many of the Arduino libraries cannot be used. Many of the short coming can be handled such as for USART, we can implement serial communication via software. Other short coming like the flash memory size and limited I/O pins can be addressed too. For memory one can use external EEPROM IC.

Here I wanted to show my experiment with the ATtiny13 and the 74HC595 shift register to expand its output capability and increase the number of controllable pins. Since the ATtiny13 provides only six I/O pins, it quickly reaches its limit when driving multiple devices. The 74HC595, a serial‑to‑parallel converter, can be controlled using just three signals: data, clock, and latch. By dedicating three of the ATtiny13’s pins to these signals, the microcontroller can drive eight outputs through the shift register. In other words, although we sacrifice three pins to control the 74HC595, we gain eight additional outputs — a net expansion that makes the tiny ATtiny13 far more versatile in practical applications.

Circuit Diagram

Shown below is the circuit diagram to connect 74HC595 with Attiny13 to increase output capability.

The circuit is a Serial-to-Parallel Output Expansion system. It allows the ATtiny13 (which has very few pins) to control 8 separate outputs (though only 4 are used here) using only 3 digital lines.

1. The Controller: ATtiny13 (U1)

The ATtiny13 acts as the "brain." It manages two distinct tasks:

Input Sensing: Pins PB3 (3) and PB4 (4) are connected to tactile buttons. These buttons are wired to Ground (GND). When a button is pressed, it completes the circuit, pulling the voltage on that pin to 0V.
Serial Communication: Pins PB0 (5), PB1 (6), and PB2 (7) are used as the control bus for the shift register.

2. The Expander: 74HC595 (U2)

This IC is an 8-bit shift register. It takes data in "serial" (one bit at a time) and outputs it in "parallel" (all 8 bits at once).

Control Interface (The Input Side)

DS (Pin 14 - Data): This receives the 1s and 0s from the ATtiny13.
SH_CP (Pin 11 - Shift Clock): Every time this pin pulses, the 74HC595 "shifts" the bit currently on the Data pin into its internal memory.
ST_CP (Pin 12 - Latch/Storage Clock): Once all bits are shifted in, a pulse on this pin "latches" the data, making it appear on the output pins (Q0–Q7) simultaneously.

Configuration Pins

VCC (16) & GND (8): Power supply (typically 5V).
OE (Pin 13 - Output Enable): Tied to GND. This ensures the outputs are always active.
MR (Pin 10 - Master Reset): Tied to VCC. This prevents the chip from clearing its memory unexpectedly.

3. The Load: LEDs (D1–D4)

The LEDs represent the devices being controlled.

Connection: They are connected to outputs Q1, Q2, Q3, and Q4 (Pins 1, 2, 3, and 4).
Current Limiting: Each LED has a 270Ω resistor (R1–R4) in series. This is critical to prevent the LEDs and the 74HC595 from drawing too much current and burning out.
Common Ground: The cathodes (short legs) of all LEDs are tied to the common Ground rail.

4. Signal Flow Summary

Input: You press a button connected to PB3 or PB4.
Processing: The ATtiny13 detects the Ground signal and decides which LED should be on.
Transmission: The ATtiny13 sends a sequence of pulses (Data and Clock) to the 74HC595.
Output: The 74HC595 "latches" that data, and the corresponding pin ( $Q_1$ – $Q_4$ ) goes High (5V), pushing current through the resistor and lighting the LED.

You can see that the Q0 (Pin 15) and $Q_5$ – $Q_7$ are currently unused in this diagram, so one could use them to control 4 additional LEDs or components without needing any extra pins from the ATtiny13.

Program Code

The program code to achieve this is below.

#include <avr/io.h>
#include <util/delay.h>

// Pin definitions
#define DS   PB0   // Data (Pin 14 on 595)
#define STCP PB1   // Latch (Pin 12 on 595)
#define SHCP PB2   // Clock (Pin 11 on 595)

// Helper to pulse the clock
void pulseClock() {
    PORTB |= (1 << SHCP);
    _delay_us(5);
    PORTB &= ~(1 << SHCP);
}

// Helper to pulse the latch
void pulseLatch() {
    PORTB |= (1 << STCP);
    _delay_us(5);
    PORTB &= ~(1 << STCP);
}

// Shift out 8-bit data (C90 compatible)
void shiftOut(unsigned char data) {
    signed char i;
    for (i = 7; i >= 0; i--) {
        if (data & (1 << i))
            PORTB |= (1 << DS);
        else
            PORTB &= ~(1 << DS);

        pulseClock();
    }
}

void sendData(unsigned char data) {
    shiftOut(data);
    pulseLatch();
}

int main(void) {
    // Set PB0, PB1, PB2 as outputs
    DDRB |= (1 << DS) | (1 << STCP) | (1 << SHCP);

    // Set PB3, PB4 as inputs
    DDRB &= ~((1 << PB3) | (1 << PB4));

    // Enable internal pull-ups for the buttons
    PORTB |= (1 << PB3) | (1 << PB4);

    unsigned char input;
    unsigned char ledData;

    while (1) {
        input = 0;

        // Read buttons (Inverted logic: 0 when pressed)
        if (!(PINB & (1 << PB3))) input |= (1 << 0);
        if (!(PINB & (1 << PB4))) input |= (1 << 1);

        // Logic adjusted for LEDs on Q1, Q2, Q3, Q4
        switch (input) {
            case 0: // No buttons pressed
                ledData = 0b00000010; // Q1 (D1)
                break;

            case 1: // PB3 pressed
                ledData = 0b00000100; // Q2 (D2)
                break;

            case 2: // PB4 pressed
                ledData = 0b00001000; // Q3 (D3)
                break;

            case 3: // Both pressed
                ledData = 0b00010000; // Q4 (D4)
                break;

            default:
                ledData = 0x00;
                break;
        }

        sendData(ledData);
        _delay_ms(50); // Debounce delay
    }

    return 0;
}

The program works are follows: The program manages I/O expansion by using a "bit-banging" serial protocol to communicate with the 74HC595 shift register. After initializing the control pins as outputs and the button pins as inputs with internal pull-up resistors, the main loop constantly monitors the state of PB3 and PB4; because these pins are pulled high by default, the code uses inverted logic to detect a button press when a pin is grounded. Based on the combination of buttons pressed, a switch statement assigns a specific bit pattern to the ledData variable, which is then passed to the shiftOut function. This function iterates through each bit of the byte, setting the Data Serial (DS) pin accordingly and pulsing the Shift Clock (SHCP) to move the bit into the register. Finally, a pulse to the Storage Clock (STCP) latches the completed byte to the 74HC595's output pins (

Q_0

–

Q_7

), updating the LEDs to reflect the current button state while a small delay provides basic software debouncing.

The video below demonstrates how this circuit works.

So, in this way you can easily expand the I/O capabilities of Attiny13 if you are short of pins. If you are not familiar with Attiny13 and WinAVR/AVR-GCC compiler, I suggest starting with Attiny13 LED blink tutorial. Let me know if any help is needed.

ATtiny13 LED Blink Simulation in Proteus

2026-04-01T22:19:00.005+05:45

I have heard of ATtiny13 micrcontroller for a while now and today I simulated a hello world program with ATtiny13 microcontroller in Proteus. As you might know Hello world program in micrcontroller programming means to blink a LED. So, this is a AVR Microcontroller Programming for Beginners guide. I used winavr compiler which can be downloaded for free. The advantages of using ATtiny microcontrollers are that they are small, cheap, energy-efficient, and easy to program via ISP, making them ideal for simple embedded projects, battery-powered devices, and space-constrained designs. They’re often chosen as a lightweight alternative to larger Arduino boards when only a few pins or basic functionality are needed.

However, many beginners start programming the ATtiny13 using the Arduino language because it feels familiar and easy. While there are many advantages of using ATtiny13 microcontroller, there is also downside of using Arduino with Attiny. Most beginners might now know that you cannot use most of the Arduino libraries because they are too large for Attiny13 1KB flash memory.

Compared to Arduino, it’s equally straightforward to use the WinAVR toolchain, which gives you direct control over registers and efficient C code compilation, write pure C code, compiled directly for AVR, Full control over registers, fuses, and optimization.

Step by step guide to install WinAVR is as follows.

📥 How to Download and Install WinAVR

1. Download WinAVR

Visit the official SourceForge page: WinAVR on SourceForge
Download the latest stable release (WinAVR-20100110 is commonly used).

2. Install WinAVR

Run the installer and follow the prompts.
By default, it installs to C:\WinAVR-20100110.
It sets up environment variables so you can use avr-gcc, avr-libc, and avrdude from the command line.

3. Verify Installation

Open Command Prompt.
Type:
```
avr-gcc --version
```
If it shows the compiler version, installation is successful.

After installation of WinAVR compiler, you also most likely want to use IDE for writing and uploading the code into the ATtiny13 chip. So here are some free IDE(Integrated Development Environment) for Attiny microcontroller.

🖥️ IDEs You Can Use with WinAVR

Programmer’s Notepad (bundled with WinAVR) – lightweight editor with build integration.
Eclipse CDT with AVR plugin – more advanced, supports projects and debugging.
Atmel Studio (Microchip Studio) – official IDE, integrates with AVR-GCC toolchain.
VS Code – with AVR extensions, modern and customizable.

After you have downloaded WinAVR compiler and IDE, you need to write program and upload it. Here is the workflow for this step.

Workflow

1. Write your C code (e.g., LED blink).
2. Compile with avr-gcc.
3. Generate .hex file.
4. Upload to ATtiny13 using avrdude and an ISP programmer (many use Arduino Uno as ISP).

ISP stands for In-System Programming.

It’s a method used to program microcontrollers (like the ATtiny13) directly while they are mounted in the circuit, without needing to remove the chip. Instead of using a separate programmer socket, you connect to the chip’s programming pins (MISO, MOSI, SCK, RESET, VCC, GND) and upload code via an external programmer such as an Arduino Uno running the ArduinoISP sketch.

So, if you are using the Arduino as ISP programmer then you have to interconnet Arduino and Attiny13 mcu in the following way.

ATtiny13 Pin	Function	Arduino Uno ISP Pin
Pin 1 (RESET)	RESET	D10
Pin 4 (GND)	Ground	GND
Pin 5 (PB0)	MOSI	D11
Pin 6 (PB1)	MISO	D12
Pin 7 (PB2)	SCK	D13
Pin 8 (VCC)	+5V	5V

The circuit diagram shows how to interface Arduino and ATtiny13.

🛠️ Notes

RESET must be pulled low by the programmer to enter programming mode.
MOSI/MISO/SCK are the SPI lines used for communication.
VCC/GND provide power.
Add a 10 µF capacitor between RESET and GND on the Arduino Uno (when using it as ISP) to prevent auto-reset during programming.

In this work, try the ATtiny13 chip interactive pinout explorer which is free web tool that help you in pin planning such as the SPI pins.

Circuit Diagram

For this tutorial, the circuit for led blink is pretty simple. A LED with 270Ohm resistor is connected to the pin 5 of ATtiny13 microcontroller.

As you can see the Attiny is powered with 3.3V ans so this is a low power LED flasher with ATtiny13 micrcontroller.

ATtiny13 LED Blink Code,

The ATtiny13 LED Blink Code using winavr compiler is below.

#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    // Set PB0 (pin 5 on ATtiny13 DIP) as output
    DDRB |= (1 << PB0);

    while (1)
    {
        // Turn LED on
        PORTB |= (1 << PB0);
        _delay_ms(500);

        // Turn LED off
        PORTB &= ~(1 << PB0);
        _delay_ms(500);
    }

    return 0;
}

Below is video demo on simulation of ATtiny in Proteus:

In short, while Arduino IDE makes ATtiny programming beginner-friendly, WinAVR is equally easy and often more efficient for small chips like ATtiny13. It gives you direct control and avoids the overhead of Arduino libraries.

How to fix high frequency simulation error in Proteus

2026-03-31T21:31:00.000+05:45

I do many circuits design and simulations in Proteus and it is a great software but with complex circuits such as RF circuits, power electronics circuit and other high-speed switching circuits at configured at high frequency, it just crashes. Actually, I think proteus was not targeted for high frequency circuit simulation such as AM or FM circuits. For example, when I tried to simulate the AM Transmitter with Arduino and MC1496 RF Mixer circuit or the Buck Converter design with Arduino circuit, the proteus software simply crashed. The error or warning is mostly the "Timestep too small" and "GMIN stepping" errors. I tried by changing simulation setting many times but could not find optimized settings that works all the time. Now I think I have found the solutions, the right setting for high-speed switching circuit, high frequency complex circuit simulation in Proteus. So, I am writing this note as a record so that I can always come back and look at the setting it worked for me.

There are two simulation configuration setting windows, the Animation and Simulation (SPICE) shown below.

The Simulation Settings (SPICE) are the "brain" calculating the physics, but the Animation Settings are the "lens" through which you are watching. If the lens is blurry or too slow, you won't see the real behavior of circuit behavior, for example a PID loop. So, we have to adjust both the settings.

Animation Setting

On the Animation setting, look for the followings.

1. Preventing "Visual Lag"

If your Frames per Second (FPS) is set too low (e.g., 10 or 15), but your Arduino code is updating the Serial Monitor every 500ms, the numbers might appear to jump or stutter.

Recommended: Keep FPS at 20 or 25. This makes the voltage meter and Serial Monitor feel "real-time."

2. The "Timestep per Frame" vs. Real Time

If your Timestep per Frame is too large (like 50ms in certain circuit simulation), Proteus tries to "skip ahead" to keep up with real-world time. In a high-speed switching circuit:

If the "skipped" time contains a massive PWM change, the simulation might suddenly "teleport" the voltage from 4V to 8V.
The Fix: If the simulation feels "choppy," try reducing Timestep per Frame to 10m or 20m. This forces the animation to be smoother, though it might make the simulation run slower than real life (e.g., 1 second of simulation takes 2 seconds of real time).

3. Optimize the Timestep (The Most Important Part)

The "Max. SPICE Timestep" is currently at 25ms. This is way too slow for a circuit switching, for example, simulation of Arduino buck converter at ~31kHz. The simulation is likely skipping thousands of PWM cycles between calculations.

Change "Max. SPICE Timestep" to: 10u (10 microseconds) or at least 100u.
Why: A high frequency signal like 31kHz PWM cycle happens every 32 microseconds. If your timestep is 25ms, the simulator is "blind" to what the MOSFET is doing most of the time.

Simulation (SPICE) setting

The simulation setting window is the "Engine Room" of the simulator. Changing these values can make the simulation much more "forgiving" so it doesn't crash when your MOSFET switches.

1. Relax the Tolerances

[RELTOL] (Relative error tolerance): Change from 0.001 to 0.01.
- Why: This allows for a 1% margin of error in calculations instead of 0.1%, which stops the simulator from panicking over tiny spikes.
[ABSTOL] (Absolute current error): Change from 1e-012 to 1e-006.
[VNTOL] (Absolute voltage error): Change from 1e-006 to 1e-003.

2. Stability Boosters

[GMIN] (Minimum conductance): Change from 1e-012 to 1e-009.
- Why: This places a very high-value "invisible resistor" across every node to prevent the math from reaching "infinity" when a switch opens.
[TRANGMIN] (Minimum transient conductance): Change from 1e-009 to 1e-007.

3. The "Transient" Tab

However, we can fix your "Timestep too small" error right here on the screen you just shared.

Change these two values to stop the "Panic" crashes:

[TRTOL] (Truncation error over-estimation): Change from 7 to 15.
- Why: This tells the simulator to be less "strict" when it sees a sudden voltage spike from your MOSFET.
[TMIN] (Minimum Analogue Timestep): Change from 1e-018 to 1e-012.
- Why: This is the most important fix. Your error message said the timestep was getting too small. By setting a "floor" at $10^{-12}$ , you stop the simulator from trying to calculate "impossible" numbers.

4. Boost the Iteration Limits

Go to Iteration tab and make sure GEAR method is selected as integration method. GEAR method is much better for power electronics like your Buck converter because it suppresses the "ringing" (oscillation) that usually crashes the simulator.

That is change

[ITL4] (Upper transient iteration limit): Change from 10 to 40.

Summary of the "Stable Proteus" Setup

Here is the "Golden Ratio" of settings for your project:

1. Simulation (SPICE) Settings

Access these via System -> Set Simulator Options.

Category	Parameter	Recommended Value	Why?
Tolerances	RELTOL	0.01	Allows 1% error; prevents crashing on tiny spikes.
Tolerances	VNTOL	1m	1mV precision is plenty for a 12V system.
Tolerances	GMIN	1e-9	Prevents "infinite resistance" math errors.
Iteration	METHOD	GEAR	Critical. Handles switching circuits better than TRAPEZ.
Iteration	ITL4	40	Gives the solver more "tries" to fix a complex step.
Transient	TRTOL	15	Reduces sensitivity to rapid voltage changes.
Transient	TMIN	1e-12	Prevents the "Timestep too small" panic error.

2. Animation Settings

Access these via System -> Set Animation Options.

Parameter	Recommended Value	Effect
Frames per Second	20	Standard "smooth" video speed for meters/Serial.
Timestep per Frame	10m to 20m	Forces the solver to calculate more steps per visual frame.
Single Step Time	1m	Allows you to "advance" time in 1ms increments.
Max. SPICE Timestep	10u	Crucial. Must be smaller than your PWM period (32us).

I hope this will be useful to others who want to do simulation of high speed, high frequency circuit.

How FM Transmitter work – Electret Mic, Pre-Amp & Colpitts Oscillator Explained

2026-03-30T21:21:00.003+05:45

It's been long time I haven't done any radio communication circuits. I spent lots of time in building AM transmitter and FM transmitter circuit. When I was engineering student, we didn't had enough time to do the practical implementation of the radio. During the college time, I spent lot of time reading communication related theories but not how to actually build one. I remember Simon Hykin books which was our textbook but really the book was too much theoretical. No practical example circuits, just block diagram representing modulators, mixers, VCO, PLL etc. For example in the analog modulation chapters, like amplitude modulation, frequency modulation, there was no actual schematic of modulation and mixing and the RF filters etc. The book explained with block diagram like a square law modulator was drawn in boxes. No inside of how actually the circuit works. After my engineering degree, I searched internet and studied the communication circuits like modulator, mixers and I have built few of them.

Here I wanted to write a new diary note on a FM transmitter that uses two BJT transistors. The circuit schematic diagram of the FM transmitter is shown below.

Here the input is the audio signal using the electret microphone as shown in the FM transmitter schematic diagram above. The resistor R1 is for turning on the electret mic, without voltage applied to it via the resistor R1, the mic won't function. The audio from the mic enters into the self biased pre-amplifier circuit made up of the BC547 Q1 transistor, R2 and R3. The resistors R2 and R3 are biasing resistors and the biasing method used for the pre-amplifier is called self biasing. The collector output is fed back into the base of the Q1 transistor in order to put the Q1 transistor in active region. The capacitors C1 and C2 are just coupling capacitors, which blocks dc signal and allows low frequency audio signal to pass through it. R3 resistor is the load of the pre-amplifier circuit and we can call it audio load. After amplification of the microphone audio signal, the amplified signal is passed into the actual oscillator with frequency modulator which is made up of the another BC547 BJT transistor Q2. The RF oscillator circuit comprises of Q1, R4, R5, C4,C5,C6 and the LC tank circuit made up of variable capacitor VC1(wrong symbol in the schematic, i forgot to put the variable capacitor symbol) and inductor L1. Their LC values depends upon the frequency of the carrier signal it will generate. The formula for LC circuit is,

$f = \frac{1}{2 \pi \sqrt(L,C)}$

The oscillator circuit is a Colpitt oscillator variant, where C5 and C6 forms the feedback network structure like in standard Colpitts oscillator which are required for sustained oscillation. As you can see, part of the signal at the collector of Q2 goes back to its emitter via the C5 and C6 feedback circuit. This feedback signal is required for continuous oscillation to occur. The capacitor C4 is important to provide stability to the RF colpitts oscillator circuit. C2 capacitor is just coupling capacitor that couples the amplified audio signal from the pre-amplifier circuit to the base of the oscillator circuit so that the DC operating point is not disturbed.

The RFC(Radio Frequency Choke) inductor is used to prevent loss of ac signal in the oscillator while providing the DC voltage to the RF oscillator.

This video below explains in much greater details how the two transistors FM transmitter works.

Related Articles
ssb demodulation
bipolar transistor based pierce crystal
AM transmitter with crystal oscillator
FM Transmitter Circuit
FM Transmitter Simulation
Band Pass Filter Design

Photodiode with Arduino Mega 2560: Light Detection Circuit + Proteus Simulation

2026-03-30T05:59:00.002+05:45

I had bought this black photodiodes years ago I think but still haven't used it. So while I was surfing my old blog posts, I came across my old Photodiode Light Detector with Arduino blog post. So I wanted to test the photodiode before I can use it in actual implementation. In the previous test when I wrote the blog post on photodiode with arduino, I use another kind of photodiode. And the black photodiode are the ones that are used in IR sensor modules and in the blog post build simple IR sensor based alarm circuit. But these were IR sensor module which has the black light sensor photodiode and the IR emitting photodiode. To test the black light sensing photodiode, I used Arduino mega board this time. Previously I used Arduino Nano and right now my two Arduino Nanos are defective. I don't know why. I could be power surges damaging the voltage regulator something like that. So I am Arduino Mega 2560 with a black photodiode to sense whether the room is dark is not and if it is then turn a LED on.

Another thing I liked to do is to simulate the circuit in Proteus. What I did was create the Arduino, photodiode, LED functional circuit and wrote a program to test the circuit. Here I have first created a sensor circuit with the black photodiode, resistor, led with the Arduino. So the objective was to turn on the led connected to pin 9 of Arduino Mega, if there is darkness in the room. This circuit is not that hard and so I don't needed to use the Arduino Mega board explorer that I had recently built.

The circuit diagram of photodiode with Arduino is below.

I simulated it and it was working meaning that the code is ok.

Photodiode with Arduino Code


// Define pins
int photodiodePin = A1;
int ledPin = 9;

void setup() {
  Serial.begin(9600); // Set Serial output baud rate
  
  pinMode(ledPin, OUTPUT); // Set LED pin as output

  // For output format
  Serial.println("Outputs:");
  Serial.println("Voltage(V):");
  Serial.println("-------------------------------------------------------------\n");
}

void loop() {
  float anaValue = analogRead(photodiodePin); // Read analog value

  float voltage = (anaValue / 1024.0) * 5.0; // Convert to voltage
  
  Serial.println(String(voltage, 2) + "V");

  // Check if voltage is less than 1V
  if (voltage < 1) {
    digitalWrite(ledPin, HIGH); // Turn LED ON
  } else {
    digitalWrite(ledPin, LOW);  // Turn LED OFF
  }

  delay(200); // Small delay
}

Then I uploaded the firmware into Arduino Mega 2560 using the Proteus firmware uploading program. I had program Arduino Uno using this Proteus firmware uploading tool but not the Arduino Mega. So I tried to achieve, test and accomplish not just one but multiple testing. First I was testing the photodiode with Arduino, then I also wanted the photodiode with arduino circuit simulation, another testing task was to test the Arduino Mega 2560 board in Proteus. Then I also tested serial data transfer from arduino into Proteus using the DP9 COM port connector. The incoming data was then connected to the virtual terminal to see the data. The data is light intensity captured by the ADC pin A1 of Arduino Mega and then converted to voltage and then sampled voltages value was sent from Arduino into Proteus virtual terminal for data display. So in short the virtual terminal is the serial monitor in Arduino IDE. So instead of opening and viewing data in serial monitor, I used the virtual terminal in proteus.

I have video recorded this work which I have shared on youtube. Watch the video below.

Photodiode with Arduino: Faster, More Precise Light Sensing

2026-03-29T18:33:00.003+05:45

📖 7 min read

I wrote long ago about building photodiode light detector with arduino and today I am revisiting this circuit. When I first experimented with photodiode sensor I used lamp to shine onto the photodiode to turn on a LED. This is the simplest circuit experiment you can do to learn photodiode and how to interface and interact with microcontroller board like Arduino.

Here in this Arduino Photodiode Tutorial we will guide you step-by-step through setting up a circuit, understanding the code, and getting accurate light intensity readings. We'll explore how to transform a simple photodiode into a powerful Light Intensity Sensor Arduino, discuss the crucial differences in the Photodiode vs LDR Arduino debate, and provide a clear Arduino Photodiode Circuit Diagram.

I remember when I first started experimenting with light sensors. It felt like magic to see a circuit react to ambient light! This guide aims to demystify that magic, making it accessible for everyone from beginners to intermediate hobbyists. We'll get hands-on and build a practical light sensing project together.

What is a Photodiode, and How Does It Work?

At its core, a photodiode is a semiconductor device that converts light into an electrical current. Think of it as a specialized diode designed to detect light. When photons (light particles) strike the photodiode's depletion region, they create electron-hole pairs. These charge carriers are then swept across the junction by an electric field, generating a current proportional to the intensity of the incident light. The brighter the light, the more photons hit the diode, and the larger the current produced. This makes it an excellent choice for a precise light detector.

Unlike a regular LED, which emits light when current flows, a photodiode produces current when exposed to light. It's often operated in "reverse bias," meaning a voltage is applied across it in the non-conducting direction. This increases the width of the depletion region, making it more sensitive to light and allowing for a faster response. For our Arduino project, we'll use a simple setup that converts this current change into a measurable voltage.

Photodiode vs. LDR: Which Light Sensor is Right for Your Arduino Project?

This is a common question, and it's essential to understand the distinctions. You've probably encountered the light dependent resistor ldr light sensor, also known as a photoresistor. While both photodiodes and LDRs detect light, they do so in fundamentally different ways and offer distinct advantages.

Speed: Photodiodes are significantly faster. Their response time is in nanoseconds, making them ideal for applications requiring rapid light detection, like optical communication or bar code scanners. LDRs, on the other hand, have response times in milliseconds, which can be too slow for certain projects.
Linearity: Photodiodes offer a much more linear response to light intensity. This means the output current is directly proportional to the light hitting it, making calibration and accurate measurements easier. LDRs have a highly non-linear response, which can be tricky to work with for precise measurements.
Sensitivity & Spectral Response: Photodiodes can be designed to be sensitive to specific wavelengths (e.g., UV, visible, IR). LDRs typically have a broad spectral response, similar to the human eye. For a precise Light Intensity Sensor Arduino that needs to differentiate light sources or operate in specific spectra, photodiodes are superior.
Cost & Complexity: LDRs are generally cheaper and simpler to integrate into basic circuits. Photodiodes, especially high-performance ones, can be more expensive and sometimes require more complex circuitry (like a transimpedance amplifier) for optimal performance, though we'll use a simpler setup for our tutorial.

For simple ambient light detection where speed and precision aren't critical, an LDR might suffice. But if you need accurate, fast, or spectrally specific light measurement, a photodiode is the clear winner. In my experience, when building anything that needs to react quickly or provide truly quantitative light data, I always reach for a photodiode.

Building Your Arduino Photodiode Circuit: Step-by-Step

Let's get our hands dirty and build the circuit. This section will walk you through the Arduino Photodiode Circuit Diagram and connections. We'll use a simple reverse-biased configuration that's easy to implement and provides good results for general light intensity sensing.

Hardware List:

Arduino Uno (or compatible board)
Photodiode (e.g., BPW34 or similar general-purpose photodiode)
10k Ohm Resistor
Breadboard
Jumper Wires
USB Cable for Arduino

Circuit Diagram Explanation & Connections:

Below is circuit diagram for connecting photodiode sensor with the Arduino analog pin.

Here's how to connect your photodiode to the Arduino. Remember, photodiodes are typically polarized, so pay attention to the anode (positive) and cathode (negative) leads. Often, the shorter lead is the cathode, or there might be a flat edge on the body indicating the cathode side.

Connect the Photodiode: Insert your photodiode into the breadboard.
Reverse Bias Connection:
- Connect the anode (positive lead) of the photodiode to the 5V pin on your Arduino.
- Connect the cathode (negative lead) of the photodiode to one end of the 10k Ohm resistor.
Ground Connection: Connect the other end of the 10k Ohm resistor to the GND pin on your Arduino.
Analog Input Connection: This is where we read the voltage. Connect a jumper wire from the point where the photodiode's cathode meets the 10k Ohm resistor to an analog input pin on your Arduino (e.g., A0).

What we've created is a voltage divider. When light hits the photodiode, its internal resistance changes, causing the voltage at pin A0 to fluctuate. The Arduino then reads this voltage.

Arduino Code for Light Intensity Measurement

Now that our hardware is ready, let's upload the code to make our Arduino understand and display the light intensity. This sketch will read the analog voltage from the photodiode and print it to the Serial Monitor.


// Define pins
int photodiodePin = A1;
int ledPin = 9;

void setup() {
  Serial.begin(9600); // Set Serial output baud rate
  
  pinMode(ledPin, OUTPUT); // Set LED pin as output

  // For output format
  Serial.println("Outputs:");
  Serial.println("Voltage(V):");
  Serial.println("-------------------------------------------------------------\n");
}

void loop() {
  float anaValue = analogRead(photodiodePin); // Read analog value

  float voltage = (anaValue / 1024.0) * 5.0; // Convert to voltage
  
  Serial.println(String(voltage, 2) + "V");

  // Check if voltage exceeds 1V
  if (voltage > 0.05) {
    digitalWrite(ledPin, HIGH); // Turn LED ON
  } else {
    digitalWrite(ledPin, LOW);  // Turn LED OFF
  }

  delay(200); // Small delay
}

Code Explanation:

const int photodiodePin = A0;: We define which analog pin is connected to our photodiode circuit.
Serial.begin(9600);: This line initializes serial communication, allowing your Arduino to send data to your computer's Serial Monitor.
int lightValue = analogRead(photodiodePin);: This is the core of our light sensing. The analogRead() function reads the voltage on the specified analog pin. It returns an integer value from 0 to 1023, where 0 typically corresponds to 0V and 1023 to 5V (for a 5V Arduino).
map(lightValue, 0, 1023, 0, 100);: This optional line provides a simple way to convert the raw 0-1023 reading into a more human-readable percentage. Remember, actual light intensity measurement often requires calibration with a known light source.
delay(100);: A short delay ensures we don't flood the Serial Monitor with too many readings, making it easier to observe changes.

Upload this code to your Arduino. Open the Serial Monitor (Tools -> Serial Monitor) in the Arduino

I Need to Memorize Github Pages and git commands

2026-03-29T03:54:00.002+05:45

It's 3:30AM and I am doing this chip explorer and IC explorer project and because the various coding AI model won't run, and they won't solve my coding task I gave them, it took me so long time to finally have the files for testing(testing only). Had a tea and fried rice before I came to know that my files were finally made ready by one of my favorite free AI model for coding. Tea is getting cold while I am writing this. So next I had to upload the files to Github. So I remember that large files cannot be uploaded with the provided default uploading process and so back then, a week ago, I had used git for the first time to upload the files. I wanted to learn Github and git commands because they are so normal for coders and professionals and I think learning it now would be smartest step. By getting comfortable with Git and GitHub early, I can avoid confusion later and build habits that professionals rely on every day.

And so, this time I wanted to record the git command to upload files so that I don't forget the commands to create a git repository and then upload the file using git command:

git clone https://github.com/YOUR_USERNAME/ic-explorer-assets.git
cd ic-explorer-assets
# Copy your files here
git add ic-explorer-core.css ic-explorer-engine.js
git commit -m "Initial upload"
git push origin main

After that I had to create Github Page and the way to do it I have taken a screen shot which is below. Basically we have to turn on the main branch, that is turn on so that main branch is enabled because the files that were uploaded previously resides in that main branch under the newly created repository. This is how I am understanding, correct me if I am wrong, if anybody is reading this.

This is actually I think my 2nd time I am doing this but I forget, I have habit not to think too much when I am following tutorial or when I am trying to reach my aim fast. So that is why I am recording this note in this diary.

DIY Ham Radio Oscillator Circuits: Build Stable VXO, Colpitts & SSB Local Oscillators

2026-03-28T23:15:44.466+05:45

The 2N3904 transistor is humble, yet incredibly versatile bipolar transistor that can be used in RF projects like building oscillator for SSB AM transmitter. Often overlooked in favor of more specialized (and expensive) components, the 2N3904 truly earns its title as the "Swiss Army Knife" of RF, especially when it comes to building stable DIY Ham Radio Oscillator Circuits. Here we look at the useful application of the 2N3904 transistor is in SSB AM transmitter.

If you're looking for a reliable, cost-effective circuit you can build tonight for your QRP rig, SSB receiver, or even a simple test bench signal source, you've come to the right place.

Many ask if a low-cost transistor like the 2N3904 is "good enough" for a critical application like an SSB Local Oscillator (LO) compared to a fancy crystal oscillator module. The answer is a resounding yes, with proper design and component selection. We'll show you how to achieve excellent stability and performance, making the 2N3904 an indispensable part of your workbench.

Here's the circuit diagram we'll be building and discussing:

Why the 2N3904 is Your Go-To Transistor for RF Oscillators

You might wonder why we'd pick a general-purpose NPN transistor like the 2N3904 over a 2N2222 or even a JFET for an RF oscillator. The reasons are compelling: availability, cost, and surprisingly good performance. The 2N3904 boasts a typical fT(transition frequency) of 300 MHz or more, making it perfectly capable of oscillating well into the VHF range, let alone the HF bands common for ham radio. It's inexpensive, widely available, and its TO-92 package is easy to work with on both breadboards and PCBs.

While a 2N2222 is also an excellent choice, the 2N3904 often exhibits slightly better noise figures and higher fT characteristics for similar cost, making it marginally superior for high-frequency low-power applications. JFETs like the 2N3819 are fantastic for oscillators due to their high input impedance, but they can be harder to source consistently and sometimes require more careful biasing. MOSFETs, while versatile, can introduce gate capacitance issues that complicate frequency stability in high-Q oscillator designs. For a straightforward, reliable Bipolar Transistor RF Oscillator that's easy to implement, the 2N3904 truly shines.

The Pierce Oscillator: Theory of Operation

The Pierce oscillator is a classic crystal oscillator configuration, renowned for its simplicity and stability. At its heart, it uses a crystal operating in its series resonant mode, coupled with a transistor that provides the necessary gain and 180-degree phase shift. The crystal itself, along with the feedback capacitors (C1 and C2 in our schematic), provides the additional 180-degree phase shift required for sustained oscillation.

In essence, the crystal acts as a highly selective filter, allowing only its resonant frequency to pass through with minimal loss. The transistor amplifies this signal, and the phase shift network (C1, C2, and the crystal) feeds it back to the input in phase, thus reinforcing the oscillation. For a deeper dive into how pierce crystal oscillator works, you can explore our detailed article. This robust and straightforward Crystal Oscillator Design is why it's a popular choice for everything from microcontrollers to ham radio transceivers. If you're new to the concept, our introduction to crystal oscillators provides an excellent foundation.

Component Selection for High Stability VXO Design

Achieving a stable frequency output, especially for an SSB Local Oscillator Circuit, is paramount. The circuit diagram of an oscillator that can be used in SSB AM transmitter is shown below.

Here's a breakdown of critical component choices:

Crystal (XTAL1): Select a fundamental mode crystal for your desired frequency. For QRP SSB applications, common frequencies might be 3.579 MHz (colorburst crystal, easy to find) or crystals around 7 MHz, 10 MHz, or 14 MHz. The VXO (Variable Crystal Oscillator) concept allows you to "pull" the crystal's frequency slightly (typically a few kHz) by adding a small inductor or variable capacitor in series or parallel with it.
Feedback Capacitors (C1, C2): These are perhaps the most critical components for frequency stability. You absolutely must use (Negative-Positive-Zero) or ceramic capacitors. Why? Their capacitance value is extremely stable across temperature changes. Standard ceramic capacitors (X7R, Z5U) drift significantly with temperature, causing your oscillator frequency to wander – a nightmare for SSB reception or transmission. Typical values range from 47pF to 100pF, depending on your crystal's characteristics and desired pulling range. For VXO operation, you might replace C1 or C2 with a small variable capacitor (trimmer or polyvaricon) in series with a fixed NPO cap.
Biasing Resistors (R1, R2, R3, R4):
- R1 (100kΩ) and R2 (10kΩ): Form a voltage divider to bias the base of the 2N3904. These values set the operating point.
- R3 (1kΩ): Emitter resistor, provides stability and current feedback.
- R4 (10kΩ): Collector resistor, sets the collector current and provides the output impedance.
Output Capacitor (C3, 0.1µF): A DC blocking capacitor to isolate the oscillator from subsequent stages. Use a ceramic or Mylar capacitor.
Power Supply (9V-12
Related Articles

ssb demodulation

bipolar transistor based pierce crystal

AM transmitter with crystal oscillator

FM Transmitter Circuit

FM Transmitter Simulation

Band Pass Filter Design

RC Snubber Circuit

ee-diary

How to Design 12V DC to 220V AC Inverter Circuit

Circuit Diagram

Setting up the TL494 PWM Controller

Power and Ground Railing

Driver Stage with BC327

MOSFET Power Bank

Final Transformer Assembly

🛠️ Components Used in This Design:

How to Design 12V DC to 220V AC Inverter Circuit Schematic in Proteus

TL494 IC pinout explorer - Free interactive tool

Simple Super Regenerative FM Receiver Circuit Design

Build Your Own Simple Super Regenerative FM Receiver: A Beginner's Guide to DIY Radio

What is a Super Regenerative Receiver? A Beginner's Overview

The Magic of Regeneration

The "Super" Part: Quenching

Circuit Design Principles: How It All Works Together

Block Diagram Concept:

The Simple Super Regenerative FM Receiver Circuit

Further Exploration and Enhancements

Closed-loop Temperature Controller with Arduino

Circuit Diagram/Hardware

Code for the Temperature Controller

How the Code Works

How to Design Amplitude Modulator (AM) using Differential Amplifier - Improved Version

Improving AM modulator using MC1496 modulator

1. Functional Review

2. Practical Advice & Improvements

3. Verification Steps

Arduino Nano Overheating Problem & Solutions

🔥 Arduino nano Overheating Causes Reported

✅ Overall Pattern

Simulation of Bluepill (STM32F103C8T6) LED blinking circuit in Proteus

Fixing My DIY Arduino PCB Design Mistakes After 3 Years

Running Out of Pins? I2C alternative to Control a 16x2 LCD with Arduino 3 Pins

1. Library and Pin Configuration

2. The Setup Phase

3. Reading and Converting Data

4. Updating the Display

Redesigned Arduino Based Buck Converter : N-Channel vs. P-Channel Buck Converter:

Circuit Schematic

1. The Switching Stage (Control)

2. The Power Stage (Conversion)

3. The Feedback Stage (Monitoring)

Summary Table: Component Roles

Program Code

1. Configuration & Calibration

2. The High-Speed Heart (Timer Setup)

3. The Control Loop (The "Brain")

4. Serial Monitor

Video

Why High-Side N-Channel Buck Converters Fail

Testing Attiny45 ADC functionality in Proteus

ATtiny45 ADC Pin Mapping

1. The Configuration (adc_setup)

2. The Measurement (adc_read)

3. The Logic (main)

Ubiquiti Radio Hardware Repair: A Comprehensive Service Guide

Automated Sound-Triggered Alarm with ATmega328P External Interrupts

How the Circuit Works

Programming and Code

1. Configuration & Setup (init_system)

2. The Interrupt Service Routine (ISR)

3. The Main Loop (main)

Video Demonstration

How to Build a Pure Sine Wave Inverter using Arduino SPWM

Circuit Diagram

1. The Control Brain (Arduino Nano)

2. The Gate Driver (Totem-Pole)

3. The Switching Stage (MOSFETs)

4. The Transformer (Push-Pull)

5. The Output Filter (LC Filter)

Program Code

1. The Sine Look-Up Table (The Map)

2. Timer 1 Configuration (The Engine)

3. The Interrupt Service Routine (The Brain)

4. Why This Works for an Inverter

Video Demonstraion

What is Bootstrapped Emitter Follower: Real-World Audio Example

Circuit Diagram

1. The Configuration (`adc_setup`)

2. The Measurement (`adc_read`)

3. The Logic (`main`)

1. Configuration & Setup (`init_system`)

2. The Interrupt Service Routine (`ISR`)

3. The Main Loop (`main`)