I have recently received the following question from a reader:

I’m looking for a circuit board design that will need to turn on an array of LEDs when motion is detected during the day time, and also stay on continuously during the night time; using the Arduino would be nice. The project that I am working on is just a picture frame with my artwork in it. The art is actually an embossed piece. The light that I am placing within the frame will shine across the embossed art, and reflect off the raised areas of paper and make the picture appear more three-dimensional. So, the picture acts as a night light when it’s dark, and then turns on for a moment during the day time when some approaches the picture.

I suspected there had to be a simple circuit to accomplish this without having to program a microcontroller to take care of triggering the light. I could see that was overkill; after all, it is just a way to switch lights on/off. Still, I had no idea how to do it, if not from a software point of view.

Well, he mentioned the Arduino in his email, and I wanted to give him a quick response, so I put together a prototype to achieve the effect he desired. I properly warned him that might not be the best solution, but since he wanted to tinker with the Arduino, that would be a simple sketch.

I suggested the use of a compact Arduino clone like the Ardweeny (check out “Testing the Ardweeny” to see how tiny it is!)

Then, soldering everything onto a stripboard should result in a small footprint that would not detract from his art piece.

Anyway, here’s a Fritzing diagram that shows how to wire the circuit:

You can see the Arduino, LDR (light sensor, the component with the “squiggly” line), LED and PIR (motion sensor, the black “mystery” component to the right — the Fritzing version I’m using has no PIR component and I still don’t know how to add a custom component the proper way).

Here’s an excellent tutorial on the use of PIRs, from Ladyada who did create her own component on Fritzing.

And here’s a picture of the setup:

Bill of Materials (include parts used for both Arduino and non-Arduino* versions):

• Breadboard
• Power* (I used this breakout board connected to my USB; power pins only)
• 1 photocell (light dependent resistor/LDR)
• 1 motion sensor (passive infrared sensor/PIR)
• Arduino (any flavor)
• 1 NPN transistor* (BC548B) (for the PIR)
• 1 PNP transistor* (2N3906) (for the LDR)
• 2 10K Ohm resistors* (Arduino version uses only 1)
• 2 diodes (1N914A)*
• 1 10K trimpot*
• Jumper wire (male-to-male, assorted lengths)
• 1 LED
• 2 180 Ohm resistors* (Arduino version uses only 1) (200 Ohm will work, too)
• Multimeter (optional, but helpful)
• Logic probe (optional, but helpful)

Here’s a video showing the concept:

(On a side note I have now acquired a HD flip camera so I don’t have to use my phone to record videos anymore).

OK, here’s the Arduino sketch:

/* www.TheElectronicsHobbyist.com/blog
 * Natalia Fargasch Norman
 * Motion detection using Arduino
 */

#define LDR 0
#define PIR 2
#define LED 3

int pirState;
int ldrValue;

void setup() {
  //Serial.begin(9600);
  pinMode(LED, OUTPUT);
  pinMode(PIR, INPUT);
  digitalWrite(LED, LOW);
}

void loop(){
  ldrValue = analogRead(LDR);
  //Serial.print("Analog reading = ");
  //Serial.println(ldrValue);

  if (ldrValue <= 512) { // dark
    digitalWrite(LED, HIGH);
  } 
  else { // ldrValue > 512
    pirState = digitalRead(PIR);
    if (pirState == HIGH) {
      digitalWrite(LED, HIGH);
      delay(5000);
      digitalWrite(LED, LOW);
      delay(1000);
    } 
    else { // pirState == LOW
      digitalWrite(LED, LOW);
    }
  }
  // The processing in the Arduino occurs faster
  // than the response from the PIR, and adding this delay
  // eliminated a flickering on the LED
  delay(1000);
}

The idea is to trigger the light when it’s dark; otherwise, trigger it for a short duration if motion is detected. This simple Arduino sketch does just that. A light dependent resistor is connected to an analog pin on the Arduino, and reading from it will either trigger the light (if it’s dark) or have the Arduino check for motion by reading from the motion sensor connected to a digital pin (if it’s not dark).

And finally… a non-Arduino version!

A few days and a couple of aha! moments later, I finally figured out how to accomplish the same behavior without using a microcontroller.

I knew an OR gate could be used to trigger the LED (output) on either (or both, doesn’t matter) condition: darkness or motion detected. The PIR outputs either 0 (no motion detected) or 1 (motion detected). But what about the light detection piece of the circuit? The LDR gives me an analog reading, and I needed a 0 or a 1 as inputs to the OR gate.

When later reading about transistors in Forrest Mims’ “Getting Started in Electronics” it occurred to me that I could use one as a switch on the LDR part of the circuit to generate the second input to the OR gate.

So I excitedly went to Marvac (my trusty local electronics shop) to buy OR gates; unfortunately, they were out of stock…

But then, again courtesy of Forrest Mims, I learned how to build my own OR gate using two rectifier diodes. (And I had the necessary parts!)

Here’s how it’s wired:

Now on to the complete circuit…

First I hooked up the LED to the OR circuit to test that it worked. Check.

Then I connected the PIR to the LED to make sure that it woks, i.e. LED lights up when there is motion detected. Check.

Then I connected the PIR to be the first input of the OR gate… and it didn’t work.

I hooked up the LDR as the second input to the OR gate and that part… “kind of” worked. (LED off when dark and on when light; should be the other way around). I had used an NPN transistor, so I just switched to a PNP instead and it worked. Makes sense!

This is how it was hooked up: Emitter to ground, Collector to load (the LED) and Base to LDR. The LDR was connected to a 10K pull-up resistor and a potentiometer (to fine tune the amount of darkness it takes to trigger the LED).

But the PIR part of the circuit was still “kaputt”… I checked with the logic probe and found out that there was a signal coming to the LED. I replaced it with a diffused LED and could see that it was actually on, just veeeery faint.

Using a multimeter I measured the voltage between the LED leads and it was 2.3V. My power source was 4.92V. It seems that the PIR causes a voltage drop…

Then I looked at the datasheet for the Parallax PIR I have (note to self: that should definitely NOT be an afterthought), and learned that there are two versions, and that mine requires a transistor or a MOSFET to drive external loads.

I hooked up a random (I’m no EE!) transistor (a 2N2222) and now the LED is brighter. But still not as bright as when I cover the LDR.

Looking at the current values, my multimeter read:

Current through the LED when the LDR portion of the circuit is active: 4.2mA
Current through the LED when the PIR portion of the circuit is active: 0.8mA

The only other transistors I had were 2N3904, so I decided to try that one. The LED was much brighter and the current read 2.4mA. With a base current of 0.02mA I was getting a gain of 40 with the 2N2222 and 120 with the 2N3904.

I checked the datasheets for these two transistors, and these gain values were consistent. After some research it seems the BC548B is a better amplifier transistor for this application, and has a minimum gain of 200.

Here’s what the circuit looks like on Fritzing:

And here’s a picture of the real thing:

By the way, I heard back from my reader; he bought the Boarduino from Adafruit, not the Ardweeny, and successfully built his “darkness-or-motion-triggered artwork illumination” project.

Keep sending me your questions; I love to see what you are working on, and it helps me on my learning journey as well. (Explaining something to somebody else is the best way to learn). I will also from time to time publish some of your questions here. (If you have an electronics blog let me know and I will include it here).

No related posts.

Most motor control applications can be accomplished with a simple single-transistor circuit. This type of circuit controls the basic operation of turning the motor on and off, and allows very fast switching of the motor, which makes it possible to control the speed of the motor using pulse width modulation (PWM).

The basic problem with this circuit is that the direction of the motor cannot be reversed. For our simple application in this RGB LED night light, spinning the motor in one direction is enough. In the future we will use motors in applications which require us to reverse the direction as well, and for that we will be using the type of motor control circuit called H-bridge circuit.

Note that a diode has been used in this circuit. The core of all types of motors is the inductor (or coil). When the amount of current (which can be moderate to high) passing through the inductor is changed, it produces large voltage spikes (“kickback” ) .

The diode used in motor control circuits is called a kickback diode and its purpose is to absorb the voltage that is produced when the transistor is turned on and off. When you are developing motor control applications using a bipolar transistor you should always put in the kickback diode in order to protect the other parts of your circuit.

Here’s the sketch for the spinning night light.

You might also enjoy:

1. Arduino RGB LED Spinning Night Light: Assembly | Part 2
2. Arduino RGB LED Spinning Night Light | Part 1
3. Arduino RGB LED Control for the Spinning Night Light | Part 4
4. Arduino LED Control Using DIP Switch: Schematic | Part 2

This week we’ll look at the circuit for the 2-digit 7-segment display counter using the Arduino.

There are a few options to control multiple displays:

• employing multiple controllers;
• using a 7-segment driver chip like the 7447;
• using a multi-display controller such as the MAXIM MAX7219;
• sequencing through the displays, which is what we have done in our example, as it requires no added hardware.

When we were using a single-digit display, we connected the common anode pin to our Vdd supply, but with two digits we have to drive them independently if we want them to display different digits!

A natural reaction would be to try to use two Arduino I/O pins, each driving a digit of the display. The problem with this scenario is that it is not possible to drive the common anode or cathode pin using Arduino I/O pins, as they cannot source or sink enough current to light all seven segments.

The solution is then to use bipolar junction transistors (NPN for common cathode and PNP for common anode displays) in order to sink or drive the required current. The controlling interface outputs the value for a specific display by enabling only its common pin transistor, and the digit driven by that common pin becomes active.

To give the impression that both displays are active at the same time and avoid flickering we cycle through the digits in quick succession and keep each of them lit for 5ms. We will see how that was implemented when we go over the sketch next week.

Here is the schematic for the circuit (click for larger image):

You might also enjoy:

1. Arduino 2-Digit 7-Segment Display Counter: Sketch | Part 3
2. Arduino 2-Digit 7-Segment Display Counter | Part 1
3. Arduino 2-Digit 7-Segment Display with Buttons | Part 4
4. Controlling a Seven-Segment Display Using Arduino Part 1

Schematic: A diagram of an electrical circuit that uses standardized symbols for the components.

Semiconductor: A material of electrical resistance between that of a conductor and an insulator. It is used to construct diodes, transistors, and integrated circuits.

Solder: A tin-lead alloy that becomes liquid when heated to above 360 degrees. It has low resistance, like other metals, and provides a strong mounting.

Switch: A device used to connect or disconnect the wires in an electric circuit, turning it on or off.

Transistor: A three-terminal, solid-state electronic device designed to amplify, oscillate, or switch the flow of current between two terminals.

Voltage: The measure of difference of electric potential across a material or between two points in a circuit.

Volts (V): The unit of measure for voltage.

You might also enjoy:

1. Basic Hobby Electronics Vocabulary Part 1 of 4 (A-C)
2. Basic Hobby Electronics Vocabulary Part 3 of 4 (I-R)
3. Basic Hobby Electronics Vocabulary Part 2 of 4 (D-G)
4. Starting Out on an Electronics Hobby – Resources