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.

A while ago I purchased an Ardweeny kit, but hadn’t put it together and tested it until now. The Ardweeny is a small, breadboard friendly Arduino clone. In fact, it is the smallest Arduino clone that I know of, and the tiny board is backpacked on top of the ATMega chip.

Here are the parts laid out before I put the Ardweeny together: PCB, ATMega, headers and 7 parts. Tip: double check that you received the correct parts; I received a 470K Ohm resistor (yellow-violet-yellow) instead of a 470 Ohm (yellow-violet-brown) one.

The assembly manual that comes with the Ardweeny is illustrated in color, and explains how to put it together in great detail, step-by-step. It is a very easy kit to put together, perfect for a beginner. There isn’t a lot of soldering involved, either. (There are only 7 parts after all!)

Here is the final product, assembled and ready to go! Isn’t it tiny? The Ardweeny comes preloaded with the “Blink” sketch. In order to program it you will need an FTDI breakout board and USB miniB cable. Upon hooking it up for the first time the green LED should blink.

To test it I put together a simple circuit connecting a LED bar graph display and a variable resistor to the Ardweeny. Turning the dial on the trimpot lights the LEDs on the bar graph display accordingly. Here’s the setup:

Here’s the schematic showing how the circuit was wired:

Here’s a quick video of the Ardweeny in action.

And here’s the sketch:

// www.TheElectronicsHobbyist.com/blog
// Natalia Fargasch Norman
// Trimpot display using LED bar graph

// loop variables and trimpot reading
int i, j, val;

void setup() {
  for (i = 0; i < 10; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop() {
  for (i = 0; i < 10; i++) {
    digitalWrite(i, HIGH);
  }
  // trimpot connected to analog pin 0
  val = analogRead(0);
  // analogRead returns number
  // between 0 and 1023, scaling
  // for the 10 LEDs in the bar graph
  j = val / 100;
  for (i = 0; i < j; i++) {
    // LED bar graph is common anode, LOW is on
    digitalWrite(i, LOW);
  }
}

No related posts.

If you’ve read Getting Started with Arduino (click on link to read my review of the book) you must have noticed that the circuit on page 43 uses a 10K Ohm resistor in series with the pushbutton. (If you haven’t read it yet, the example in the schematic on the right is similar to the setup featured on the book).

Consider a microcontroller with a digital input pin connected to a switch. When the switch is closed, the pin is connected to GND. When the switch is open, the signal is not connected to anything and is left at an unknown state. The signal is in this case said to be “floating”. This is pictured in circuit (1).

To remedy this problem we pull the signal up to VCC, as shown in circuit (2). Now when the switch is open the signal is connected directly to VCC and is at a known state. But notice that when the switch is closed, VCC and GND are connected, creating a short.

To prevent the short we place a resistor between the input pin and VCC, as shown in circuit (3). This resistor is called a “pull up” resistor.

Pull down resistors work almost in the same way, except the circuit is connected so that when the switch is closed the input pin is connected to VCC, and when switch is open the pin is connected to GND using a “pull down” resistor, as shown in circuit (4).

A common value for pull up resistors is 10K Ohm. Higher resistance may be necessary for circuits that sink greater currents. We can use Ohm’s Law to determine the appropriate value for the resistor.

You might also enjoy:

1. Basic Hobby Electronics Vocabulary Part 3 of 4 (I-R)
2. Arduino LED Control Using DIP Switch: Schematic | Part 2

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

1. Solder wires to motor terminals and cover with heat-shrink tubing
2. Using a knife or sharp scissors, puncture a small hole (to fit the motor shaft snugly) on the center of the jar lid
3. Solder motor shaft to jar lid (if necessary use hot glue or super glue, as some surfaces won’t “catch” the solder easily)
4. Solder the RGB LED leads to long wires and cover the connections with heat-shrink tubing
5. Build the circuit on the mini breadboard using the schematic as your guide
6. Prepare the paper diffuser (use a hole puncher and punch a few holes to allow some light to shine through) and tape it around the jar lid using mounting tape




7. Mount the motor to the side of the breadboard using mounting tape
8. Tie the LED wires together and secure the wire bundle using a stick as prop (I used a lollipop stick in one of the holes on the breadboard); split the stick tip shaping it as a “Y” to help secure the LED wires in place(show finished picture)

Check the previous post if you need to see the sketch for the Arduino RGB LED night light again.

You might also enjoy:

1. Arduino RGB LED Spinning Night Light | Part 1
2. Arduino Motor Control for the Spinning Night Light | Part 3
3. Arduino RGB LED Control for the Spinning Night Light | Part 4
4. Arduino 2-Digit 7-Segment Display Counter: Circuit | 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