The Identified Plush Object Network is one of a few bigger projects that I want to work on this year. The idea is to create a network of small plush animals that interact with users, each other, and the Internet. I called it “Identified” because as a separate project I’m working with an RFID reader/writer module I want to create a simpler interface for, and once that piece is working each object in the network will be tagged as well.

The motivation for the project is non-profit work I want to do in the future with at-risk teenagers here in Orange County, CA. I want to create something that can be built in phases that get increasingly complex as the students learn, but that starts simple enough to enable hands-on participation from day one. Software improvements will be made in each iteration.

Each plush animal will house electronics that will be “surgically” implanted. While the project is being designed I’m thinking of using soft circuits or even cardboard circuits wired with EFT tape instead of stripboards to make it easy to modify them while I’m still making decisions.

Cost Considerations

One of my requirements – due to the non-profit nature of this project – is to try to keep cost as low as possible, but maintaining simplicity. For example, even though the cheapest possible Arduino may be a homebrew version, I decided I will be using the Ardweeny (it is cheap enough and simpler to put together).

Another example of the cost x simplicity trade-off is the Internet of Things aspect of the project. The WiFi RedBack costs $63 at the time of this writing (but includes the Arduino), versus $24 for the barebones WiFi module (the MRF24WB0MA by MicroChip). I’m just not sure if the savings are worth the added complexity. (Here’s an example that uses this module). I also have to consider only one of the nodes/objects needs to have WiFi capability. Communication within the networked objects will happen over XBee.

Power Requirements

Another factor that will drive design decisions is power – I want to learn how to design for lower power, and I’m aware this may be a whole subject all on its own given the many choices of battery types and cost considerations as well. Baby steps. I’ll get there.

Phases of the Project

As of yet the IPON project is not defined on a detailed level, except for Phase 0. From a high-level perspective I have envisioned the following phases in small increments over the previous one (with each going through several iterations and refinements):

Phase 0 (current):

• Breadboard circuit and rough sketch for Phase 1

Phase 1:

• Semi-permanent circuit
• 1 plush object with implanted electronics
• Interacts with user

Phase 2:

• Semi-permanent circuit
• 1 plush object
• Interacts with user
• Interacts with the Internet

Phase 3:

• Semi-permanent circuit
• 2 plush objects
• Interact with user
• Interact with each other

Phase 4:

• Semi-permanent circuit
• 3+ objects
• Interact with user
• Interact with each other
• Interact with the Internet

Phase 5:

• Permanent circuit
• 3+ objects
• Interact with user
• Interact with each other
• Interact with the Internet
• RFID tags

IPON project, the big picture:

On the next post I will share the current state of the project, Phase 0 as described above, including circuit and Arduino sketch. Stay tuned!

No related posts.

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.

Back in April I posted about a goal I had for this year: setting up a decent workbench for myself in a corner of my (minuscule) home office. As the year comes to an end, I think it’s time for an update.

Did it happen exactly as planned? No…

Did I make progress? Yes!

So what happened?

We’re in limbo right now. We live in a rented apartment, which the owner has put on the market for sale. That means at any given day we may get a 30-day notice to vacate. I simply didn’t feel it was worth it to go all the way with getting rid of stuff to make room for a bigger table (it will inevitably happen when we have to move) and buying the table/bench (that would have to fit the exact dimensions of the space available here, possibly not being the ideal size for the next place) just yet.

I did make some improvements: I doubled my work area (with an additional table – another dinner tray table! – I use when I’m working on something) and I added a few items to my set of equipment. I got a digital multimeter (my old one is analog, which I still keep as I read it can be useful to show changes in values) a bench-top power supply, hot glue gun, several large breadboards, much needed tools and a myriad of parts.

All in all I don’t have the workbench I had envisioned (yet), but I have a bigger workspace, much needed new equipment and a lot more parts to play with!

On a related note, I came up with ideas for two bigger projects I want to work on which will be ongoing, in addition to the small stuff I build for learning purposes. I’ve placed quite a few orders from DigiKey, Jameco clearance center and CuteDigi lately, that I’m sure my husband now fears I have a shopping addiction… I am excited to start working on these projects and sharing them here. Stay tuned!

My current setup:

The work area:

And storage:

How about you? What is your workbench setup like? Are you planning any improvements and/or additions in 2012?

You might also enjoy:

1. The 2011 Workbench Challenge

When I posted the “LED Control Using DIP Switch” sketch last year (a simple setup the turned on the LED corresponding to that switch position), I also had a slightly modified version of it in which the DIP switch controlled six different light patterns on the LEDs (scroll right, left, in, out, back and forth and random). It presented a “cleaned-up” version of the code using for loops and compared it to the “long-hand” version, showing the trade-off between ease of understanding and conciseness. Except that… I forgot to post it.

Last week someone contacted me asking a question about a similar project he is working on and when I wanted to refer him to this modified sketch I realized it wasn’t on the blog. (Here’s the original sketch and schematic for reference).

What follows below is the missing blog post (not anymore), a comparison between the more readable sketch (easier for beginners to understand) and the more concise version, in a series of snippets showing the main differences between the two versions of the sketch.

The concise version generates a binary sketch that occupies approximately 25% less memory and is almost half as long in lines of code. The entire source code listings are at the very bottom of this post.

Note: the line above each snippet reflects the modification that shortened the sketch.

1) not using #define directives for the LED and switch pins on the Arduino in order to use for loops:

    } else {
     // default: off
     digitalWrite(LED1, LOW);
     digitalWrite(LED2, LOW);
     digitalWrite(LED3, LOW);
     digitalWrite(LED4, LOW);
     digitalWrite(LED5, LOW);
     digitalWrite(LED6, LOW);
   }

    } else {
     // default: off
     for (i = 13; i >= 8; i--) {
       digitalWrite(i, LOW);
     }

2) using a state variable array (and consequently a for loop) as opposed to individual state variables:

   s1state = digitalRead(S1);
   s2state = digitalRead(S2);
   s3state = digitalRead(S3);
   s4state = digitalRead(S4);
   s5state = digitalRead(S5);
   s6state = digitalRead(S6);

   for (i = 0, j = 7; i < 6, j >= 2; i++, j--) {
     state[i] = digitalRead(j);
   }

3) if (x) versus if (x == 1) (when x is either 0 or 1, then the (x == 1) expression can be written as simply (x)):

    } else if (s5state == 1) {
     // scroll back and forth

    } else if (state[4]) {
     // scroll back and forth

4) long, repetitive code to randomly turn on or not each LED (for a random duration up to 300 milliseconds) replaced with for loop:

    } else if (s6state == 1) {
     // random
     randomSeed(analogRead(3));
     onoroff = random(0, 2);
     millisecs = random(0, 301);
     digitalWrite(LED1, onoroff);
     delay(millisecs);
     randomSeed(analogRead(3));
     onoroff = random(0, 2);
     millisecs = random(0, 301);
     digitalWrite(LED2, onoroff);
     delay(millisecs);
     randomSeed(analogRead(3));
     onoroff = random(0, 2);
     millisecs = random(0, 301);
     digitalWrite(LED3, onoroff);
     delay(millisecs);
     randomSeed(analogRead(3));
     onoroff = random(0, 2);
     millisecs = random(0, 301);
     digitalWrite(LED4, onoroff);
     delay(millisecs);
     randomSeed(analogRead(3));
     onoroff = random(0, 2);
     millisecs = random(0, 301);
     digitalWrite(LED5, onoroff);
     delay(millisecs);
     randomSeed(analogRead(3));
     onoroff = random(0, 2);
     millisecs = random(0, 301);
     digitalWrite(LED6, onoroff);
     delay(millisecs);
   }

    } else if (state[5]) {
     // random
     for (i = 13; i >= 8; i--) {
       randomSeed(analogRead(i - 8));
       onoroff = random(0, 2);
       millisecs = random(0, 301);
       digitalWrite(i, onoroff);
       delay(millisecs);
     }
   }

Here’s the full long version:

• Binary sketch size: 3654 bytes
• Code size was sacrificed in order to improve readability for beginners
• Sketch length: 205 lines

  // www.TheElectronicsHobbyist.com/blog
  // Natalia Fargasch Norman
  // LED control via DIP switches

  // Arduino pins used for the LEDs
  #define LED1 13
  #define LED2 12
  #define LED3 11
  #define LED4 10
  #define LED5 9
  #define LED6 8

  // Arduino pins used for the switches
  #define S1 7
  #define S2 6
  #define S3 5
  #define S4 4
  #define S5 3
  #define S6 2

  // State of each switch (0 or 1)
  int s1state;
  int s2state;
  int s3state;
  int s4state;
  int s5state;
  int s6state;

  // Random values for LED state and delay
  long onoroff;
  long millisecs;

  void setup() {
    // pins for LEDs are outputs
    pinMode(LED1, OUTPUT);
    pinMode(LED2, OUTPUT);
    pinMode(LED3, OUTPUT);
    pinMode(LED4, OUTPUT);
    pinMode(LED5, OUTPUT);
    pinMode(LED6, OUTPUT);
    // pins for switches are inputs
    pinMode(S1, INPUT);
    pinMode(S2, INPUT);
    pinMode(S3, INPUT);
    pinMode(S4, INPUT);
    pinMode(S5, INPUT);
    pinMode(S6, INPUT);
  }

  void loop() {
    s1state = digitalRead(S1);
    s2state = digitalRead(S2);
    s3state = digitalRead(S3);
    s4state = digitalRead(S4);
    s5state = digitalRead(S5);
    s6state = digitalRead(S6);
    if (s1state == 1) {
      // scroll right
      digitalWrite(LED1, HIGH);
      delay(250);
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, HIGH);
      delay(250);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, HIGH);
      delay(250);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, HIGH);
      delay(250);
      digitalWrite(LED4, LOW);
      digitalWrite(LED5, HIGH);
      delay(250);
      digitalWrite(LED5, LOW);
      digitalWrite(LED6, HIGH);
      delay(250);
      digitalWrite(LED6, LOW);
    } else if (s2state == 1) {
      // scroll left
      digitalWrite(LED6, HIGH);
      delay(250);
      digitalWrite(LED6, LOW);
      digitalWrite(LED5, HIGH);
      delay(250);
      digitalWrite(LED5, LOW);
      digitalWrite(LED4, HIGH);
      delay(250);
      digitalWrite(LED4, LOW);
      digitalWrite(LED3, HIGH);
      delay(250);
      digitalWrite(LED3, LOW);
      digitalWrite(LED2, HIGH);
      delay(250);
      digitalWrite(LED2, LOW);
      digitalWrite(LED1, HIGH);
      delay(250);
      digitalWrite(LED1, LOW);
    } else if (s3state == 1) {
      // scroll in
      digitalWrite(LED1, HIGH);
      digitalWrite(LED6, HIGH);
      delay(250);
      digitalWrite(LED1, LOW);
      digitalWrite(LED6, LOW);
      digitalWrite(LED2, HIGH);
      digitalWrite(LED5, HIGH);
      delay(250);
      digitalWrite(LED2, LOW);
      digitalWrite(LED5, LOW);
      digitalWrite(LED3, HIGH);
      digitalWrite(LED4, HIGH);
      delay(250);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, LOW);
    } else if (s4state == 1) {
      // scroll out
      digitalWrite(LED3, HIGH);
      digitalWrite(LED4, HIGH);
      delay(250);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, LOW);
      digitalWrite(LED2, HIGH);
      digitalWrite(LED5, HIGH);
      delay(250);
      digitalWrite(LED2, LOW);
      digitalWrite(LED5, LOW);
      digitalWrite(LED1, HIGH);
      digitalWrite(LED6, HIGH);
      delay(250);
      digitalWrite(LED1, LOW);
      digitalWrite(LED6, LOW);
    } else if (s5state == 1) {
      // scroll back and forth
      digitalWrite(LED1, HIGH);
      delay(250);
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, HIGH);
      delay(250);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, HIGH);
      delay(250);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, HIGH);
      delay(250);
      digitalWrite(LED4, LOW);
      digitalWrite(LED5, HIGH);
      delay(250);
      digitalWrite(LED5, LOW);
      digitalWrite(LED6, HIGH);
      delay(250);
      digitalWrite(LED6, LOW);
      digitalWrite(LED5, HIGH);
      delay(250);
      digitalWrite(LED5, LOW);
      digitalWrite(LED4, HIGH);
      delay(250);
      digitalWrite(LED4, LOW);
      digitalWrite(LED3, HIGH);
      delay(250);
      digitalWrite(LED3, LOW);
      digitalWrite(LED2, HIGH);
      delay(250);
      digitalWrite(LED2, LOW);
    } else if (s6state == 1) {
      // random
      randomSeed(analogRead(3));
      onoroff = random(0, 2);
      millisecs = random(0, 301);
      digitalWrite(LED1, onoroff);
      delay(millisecs);
      randomSeed(analogRead(3));
      onoroff = random(0, 2);
      millisecs = random(0, 301);
      digitalWrite(LED2, onoroff);
      delay(millisecs);
      randomSeed(analogRead(3));
      onoroff = random(0, 2);
      millisecs = random(0, 301);
      digitalWrite(LED3, onoroff);
      delay(millisecs);
      randomSeed(analogRead(3));
      onoroff = random(0, 2);
      millisecs = random(0, 301);
      digitalWrite(LED4, onoroff);
      delay(millisecs);
      randomSeed(analogRead(3));
      onoroff = random(0, 2);
      millisecs = random(0, 301);
      digitalWrite(LED5, onoroff);
      delay(millisecs);
      randomSeed(analogRead(3));
      onoroff = random(0, 2);
      millisecs = random(0, 301);
      digitalWrite(LED6, onoroff);
      delay(millisecs);
    } else {
      // default: off
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, LOW);
      digitalWrite(LED5, LOW);
      digitalWrite(LED6, LOW);
    }
  }

And here’s the full “cleaned-up” version:

• Binary sketch size: 2826 bytes
• Sketch length: 119 lines

  // www.TheElectronicsHobbyist.com/blog
  // Natalia Fargasch Norman
  // LED control via DIP switches

  // Arduino pins used for the LEDs
  // LED1 13
  // LED2 12
  // LED3 11
  // LED4 10
  // LED5 9
  // LED6 8

  // Arduino pins used for the switches
  // S1 7
  // S2 6
  // S3 5
  // S4 4
  // S5 3
  // S6 2

  // State of each switch (0 or 1)
  int state[6];

  // Random values for LED state and delay
  long onoroff;
  long millisecs;

  // loop counters
  int i, j;

  // delay
  int d = 250;

  void setup() {
    // pins for LEDs are outputs
    // LEDs 1-6 on pins 13-8
    for (i = 13; i >= 8; i--) {
      pinMode(i, OUTPUT);
    }
    // pins for switches are inputs
    // switches 1-6 on pins 7-2
    for (i = 7; i >= 2; i--) {
      pinMode(i, INPUT);
    }
  }

  void loop() {
    for (i = 0, j = 7; i < 6, j >= 2; i++, j--) {
      state[i] = digitalRead(j);
    }

    if (state[0]) {
      // scroll right
      for (i = 13; i >= 8; i--) {
        digitalWrite(i, HIGH);
        delay(d);
        digitalWrite(i, LOW);
      }

    } else if (state[1]) {
      // scroll left
      for (i = 8; i <= 13; i++) {
         digitalWrite(i, HIGH);
         delay(d);
         digitalWrite(i, LOW);
       }

   } else if (state[2]) {
       // scroll in
       // light up LEDs on pins i and 8+(13-i)
       for (i = 13; i >= 11; i--) {
        digitalWrite(i, HIGH);
        digitalWrite(21 - i, HIGH);
        delay(d);
        digitalWrite(i, LOW);
        digitalWrite(21 - i, LOW);
      }

    } else if (state[3]) {
      // scroll out
      // light up LEDs on pins i and 8+(13-i)
      for (i = 11; i <= 13; i++) {
         digitalWrite(i, HIGH);
         digitalWrite(21 - i, HIGH);
         delay(d);
         digitalWrite(i, LOW);
         digitalWrite(21 - i, LOW);
       }

    } else if (state[4]) {
       // scroll back and forth
       for (i = 13; i >= 8; i--) {
        digitalWrite(i, HIGH);
        delay(d);
        digitalWrite(i, LOW);
      }
      for (i = 9; i <= 12; i++) {
        digitalWrite(i, HIGH);
        delay(d);
        digitalWrite(i, LOW);
      }

    } else if (state[5]) {
       // random
       for (i = 13; i >= 8; i--) {
        randomSeed(analogRead(i - 8));
        onoroff = random(0, 2);
        millisecs = random(0, 301);
        digitalWrite(i, onoroff);
        delay(millisecs);
      }      

    } else {
      // default: off
      for (i = 13; i >= 8; i--) {
        digitalWrite(i, LOW);
      }
    }
  }

Check out the video of this sketch in action.

You might also enjoy:

1. Arduino LED Control Using DIP Switch | Part 1
2. Controlling a Seven-Segment Display Using Arduino Part 3
3. Arduino 2-Digit 7-Segment Display with Buttons | Part 4
4. Controlling a Seven-Segment Display Using Arduino Part 2

This is a review of the Lumex LCR-U12864GSF-WH which was recently sent to me by Newark as part of their Product Road Testing program.

The Lumex LCR-U12864GSF-WH is a graphic LCD display (pardon the redundancy) with white backlighting and screen measuring 128 pixels in width and 64 pixels in height. It uses the standard KS0108 chip by Samsung, and a well documented Arduino library is available for download.

The viewing area is 38.8mm x 70mm (1.5″ x 2.75″) and the entire display fits the palm of your hand.

Here’s the top view:

And here’s the bottom view:

To use it you have to solder headers to the LCD first; you can use male headers (great for using the display on a breadboard) or you can use female headers, if you just intend to connect the jumpers directly to it. You still will need a breadboard (easiest way) to keep your project organized — two power sources and a trimmer potentiometer are necessary — although the library documentation shows how you can make these connections using a small stripboard (recommended for permanent projects). I may use it this way in the future once I decide on a cool project to use it on.

The Lumex LCR-U12864GSF-WH is a very good choice for a beginner as it has a well documented library for the Arduino, and wiring of the unit is straightforward. You can use the information on the datasheet, but the library documentation offers an illustrated guide on how to wire the unit properly.

The logic can be powered by the Arduino board (5V), but the LED backlight and heater are powered by a bench top power supply at 12V, with a current limiting resistor being used on the LED. Once you have a permanent setup you may use batteries to power your project.

Links:

• Newark.com electronic component distributor
• Lumex LCR-U12864GSF-WH page where you can purchase the display
• Graphic LCD displays page on Newark.com where you can see all graphic LCDs available for purchase

Here is the connection diagram made with Fritzing:

And a picture of the setup:

No related posts.

The GLO-216 2×16 Multifont Serial OLED allows you to translate 9600bps serial data into bright, high-contrast text on a compact screen. This low cost, low power serial display comes in two font colors (yellow and green) and is made and sold by seetron.com, owned by Scott Edwards of Electronics Now and Nuts & Volts fame.

Think of the GLO-216 as a “mini terminal” that displays text and custom characters and responds to control characters such as tabs, linefeeds, carriage returns, backspace, etc. It is compatible with RS-232, Stamps, PICs and Arduino; pretty much any serial out, really.

The display uses less than 50mA, so it can be connected straight to the Arduino’s power supply.

The GLO-216 can store startup text and custom characters in EEPROM and there are instructions to save and recall this information. The simple sketch created to test the display creates and saves a new heart shaped custom character, then displays it on the screen along with some text.

Seetron.com has set up a special offer for theelectronicshobbyist.com/blog readers: you can save 20% off a GLO-216 if you use promo code “HOBBYIST” upon check out. For more information and to purchase, see the GLO-216 product page.

Here’s the GLO-216G just out of the box:

And here’s the view from the back, notice the small board that brings out the pins nicely to a 5-pin header and saves you some soldering work:

This is what it looks like when you first power it on:

And here’s the result of running the sketch I included in this post, that defines and prints a custom character:

The sketch to drive the display uses the “newsoftserial” library, which can be found here: http://arduiniana.org/libraries/newsoftserial

A few nice features of the newsoftserial library compared to the original softserial are more accurate timing, smaller code size, but best of all the ability to output “inverted” serial (the Arduino documentation states that their serial output is not RS-232 compatible, but newsoftserial permits the Arduino to output inverted serial).

Sketch:

// Test of the GLO-216G serial OLED display
// Natalia Fargasch Norman @ theelectronicshobbyist.com/blog

// GLO-216Y/G information: http://www.seetron.com/glo216.html
// Programming reference: http://seetron.com/glo216/glo216prog.html

#include <SoftwareSerial.h>
#include <GLO216.h>

#define rxPin 255
#define txPin 3
#define NULL 0x00

int inverted = 1;

SoftwareSerial mySerial = SoftwareSerial(rxPin, txPin, inverted);

void setup() {
  pinMode(txPin, OUTPUT);
  digitalWrite(txPin, LOW);
  mySerial.begin(9600);
  delay(10);

  // clears the screen and select font size and style
  char instr1[] = {
    clearScreen(),
    defaultSize(),
    selectSize(), // tall
    selectSize(), // wide
    selectSize(), // big
    textStyle(),
    NULL
  };
  const char message[] = "Hi GLO!";
  mySerial.print(instr1);
  // print message according to prior instructions
  mySerial.print(message);

  // defines a new custom heart shaped character
  char instr2[] = {
    // escape sequence to receive new custom character
    escape(),'D','0',
    // heart pattern using tool at http://seetron.com/apps/app_cceditor.html
    0x80,0x8A,0x95,0x91,0x8A,0x84,0x80,0x80,
    NULL
  };
  // print character 0x80, the newly defined heart
  const char msg[] = {0x80, NULL};
  mySerial.print(instr2);
  // print message according to prior instructions
  mySerial.print(msg);

/*  delay(3000);

  char instr3[] = {
    clearScreen(),
    NULL
  };
  mySerial.print(instr3);*/
}

void loop() {
  // ...
}

GLO216 functions:

// GLO-216G serial OLED display
// Natalia Fargasch Norman @ theelectronicshobbyist.com/blog

// GLO-216Y/G information: http://www.seetron.com/glo216.html
// Programming reference: http://seetron.com/glo216/glo216prog.html

/*
Parameters for setPosition and rightAlign instructions:
setPosition: position + 0x40
rightAlign: '0'-'7'
*/

/*
Parameters for escape instructions:
Define lower custom character: 'D', '0'-'7'
Define upper custom character: 'd', '0'-'7'
Recall saved text: 'E', '0'
Restore custom character set: 'e', '0'
Save text since last clearScreen: 'X', '0'
Store custom character set: 'x', '0'
*/

// Moves printing position to the first character of top line
char homeCursor() {
  return 0x01;
}

// Cycles the font size: normal -> tall -> wide -> big -> normal -> ...
char selectSize() {
  return 0x02;
}

// Sets font size to default of small on two lines of 16 characters
char defaultSize() {
  return 0x03;
}

// Behaves like the backspace key
char backspace() {
  return 0x08;
}

// Moves printing position to the next multiple of 4 location
char tab() {
  return 0x09;
}

// Moves the printing position down a line
char linefeed() {
  return 0x0A;
}

// Moves the printing position up a line
char verticalTab() {
  return 0x0B;
}

// Clears the screen and moves printing position to 0
char clearScreen() {
  return 0x0C;
}

// Moves to the first printing position of the next line
char carriageReturn() {
  return 0x0D;
}

// Turns on the OLED driver circuitry when it has been previously turned off
char turnOn() {
  return 0x0E;
}

// Turns off the OLED driver circuitry to save power
char turnOff() {
  return 0x0F;
}

// Sets the printing position according to value of next byte
char setPosition() {
  return 0x10;
}

// Prints text at the righthand end of a field of defined size from 2-8
char rightAlign() {
  return 0x12;
}

// Sets seven segment style font for large characters
char sevenSeg() {
  return 0x13;
}

// Sets text style font for large characters
char textStyle() {
  return 0x14;
}

// Begin multi-part instruction
char escape() {
  return 0x1B;
}

// See http://seetron.com/glo216/bpigloupgg.html
char bpkInstr() {
  return 0xFE;
}

Header file:

// GLO-216G serial OLED display
// Natalia Fargasch Norman @ theelectronicshobbyist.com/blog

// GLO-216Y/G information: http://www.seetron.com/glo216.html
// Programming reference: http://seetron.com/glo216/glo216prog.html

#ifndef GLO216_h
#define GLO216_h

// Moves printing position to the first character of top line
char homeCursor();

// Cycles the font size: normal -> tall -> wide -> big -> normal -> ...
char selectSize();

// Sets font size to default of small on two lines of 16 characters
char defaultSize();

// Behaves like the backspace key
char backspace();

// Moves printing position to the next multiple of 4 location
char tab();

// Moves the printing position down a line
char linefeed();

// Moves the printing position up a line
char verticalTab();

// Clears the screen and moves printing position to 0
char clearScreen();

// Moves to the first printing position of the next line
char carriageReturn();

// Turns on the OLED driver circuitry when it has been previously turned off
char turnOn();

// Turns off the OLED driver circuitry to save power
char turnOff();

// Sets the printing position according to value of next byte
char setPosition();

// Prints text at the righthand end of a field of defined size from 2-8
char rightAlign();

// Sets seven segment style font for large characters
char sevenSeg();

// Sets text style font for large characters
char textStyle();

// Begin multi-part instruction
char escape();

// See http://seetron.com/glo216/bpigloupgg.html
char bpkInstr();

#endif

Keywords file:

#######################################
# Syntax Coloring Map for GLO216
#######################################

#######################################
# Datatypes (KEYWORD1)
#######################################

GLO216	KEYWORD1

#######################################
# Methods and Functions (KEYWORD2)
#######################################

homeCursor	KEYWORD2
selectSize	KEYWORD2
defaultSize	KEYWORD2
backspace	KEYWORD2
tab	KEYWORD2
linefeed	KEYWORD2
verticalTab	KEYWORD2
clearScreen	KEYWORD2
carriageReturn	KEYWORD2
turnOn	KEYWORD2
turnOff	KEYWORD2
setPosition	KEYWORD2
rightAlign	KEYWORD2
sevenSeg	KEYWORD2
textStyle	KEYWORD2
escape	KEYWORD2
bpkInstr	KEYWORD2

#######################################
# Constants (LITERAL1)
#######################################

Download these four files in an archive here: GLO216.zip

You might also enjoy:

1. Arduino Serial Communication
2. LED Patterns Using DIP Switch and Arduino
3. Controlling a Seven-Segment Display Using Arduino Part 3
4. Controlling a Seven-Segment Display Using Arduino Part 2

As a computer scientist turned electronics hobbyist trying to fill the gaps in my knowledge of electronics I find myself visiting the electronics forums over at EEWeb quite a lot these days. They are a community of EEs eager to help others, sharing tons of online resources, news, projects and general electronics expertise. Whether you don’t know what a microcontroller is, or are looking for an affordable used oscilloscope on eBay, you are sure to benefit from the information on their forums. Ready for a break? Check out their comic strip.

No related posts.

Since I started playing with hobby electronics I’ve been making do with somewhat of a makeshift workbench, which consists of some space of my desk combined with a tray table that I stole from my husband. The table is small and wobbly. The space on the desk is not permanent, so I have to put things away when I’m done working with them, and take them out again when I’m ready to work. I need easier access to my parts: some are stored in plastic bins that sit on a bookshelf, some are scattered throughout the room.

My goal for 2011 is to create a decent dedicated working area, a workbench of sorts where I can leave my unfinished projects even when I’m not actively working on them. In order to do that I need to buy a long narrow table that will serve as the workbench. The problem is that the space where I envision the table to go is currently occupied by a shelf with tons on books and other junk. The plan is to get rid of the books and the junk, get rid of the shelf, and clear the area around it to accommodate the table.

I’ve started getting rid of the books: I’ve bought a Kindle to be my new library and donated a few bags full to the local library. There are still quite a few books left, and a lot of junk. It is April already and I seem to be a long way to go until I can make room for the bench and storage area.

So I thought maybe if I post pictures here and make my goal public, I’ll feel compelled to take action on it and actually get this accomplished before the end of the year. The pictures on this post are of the wobbly table and desk area currently used as workbench and the book shelf that serves as storage. There are plastic bins with parts all over the room, and the goal is to consolidate everything in one area for easy access to everything I need when I’m working.

I would like to have the table, some shelves (those that attach to the wall) and room for the plastic bins, as well as easy access to my tools and parts.

I will post updates when I make any sort of progress toward my goal. Ha! Maybe when I’m done I’ll submit my all new and improved workbench to The Amp Hour’s Workbench of the Week!

You might also enjoy:

1. Workbench Challenge Update

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

This is an addendum to the LED control using DIP switch post, to include the schematic to the project circuit:

You might also enjoy:

1. Arduino LED Control Using DIP Switch | Part 1
2. LED Patterns Using DIP Switch and Arduino
3. Pull Up Resistors
4. Arduino Motor Control for the Spinning Night Light | Part 3

This is a very simple project that controls a set of LEDs using a DIP switch. The purpose of the sketch is to show the use of some Arduino serial communication functions, and to increase familiarity interfacing with digital I/O pins.

Two LEDs were connected to the RX and TX pins on the Arduino (digital pins 0 and 1), but remember to disconnect these pins while the sketch is being uploaded.

Parts list:

• Arduino Duemilanove
• Breadboard
• 8 LEDs, assorted colors
• Jumper wire, assorted lengths
• DIP switch
• 6 10K Ohm resistors (pull up)
• 8 100 Ohm resistors (current limiting)

Sketch:

// www.TheElectronicsHobbyist.com/blog
// Natalia Fargasch Norman
// LED control via DIP switches

// Arduino pins used for the LEDs
#define LED1 13
#define LED2 12
#define LED3 11
#define LED4 10
#define LED5 9
#define LED6 8

// Arduino pins used for the switches
#define S1 7
#define S2 6
#define S3 5
#define S4 4
#define S5 3
#define S6 2

// State of each switch (0 or 1)
int s1state;
int s2state;
int s3state;
int s4state;
int s5state;
int s6state;

void setup() {
  // pins for LEDs are outputs
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  // pins for switches are inputs
  pinMode(S1, INPUT);
  pinMode(S2, INPUT);
  pinMode(S3, INPUT);
  pinMode(S4, INPUT);
  pinMode(S5, INPUT);
  pinMode(S6, INPUT);
  // setup serial port
  Serial.begin(9600);
  Serial.println("Serial port open");
}

void loop() {
  s1state = digitalRead(S1);
  digitalWrite(LED1, s1state);
  s2state = digitalRead(S2);
  digitalWrite(LED2, s2state);
  s3state = digitalRead(S3);
  digitalWrite(LED3, s3state);
  s4state = digitalRead(S4);
  digitalWrite(LED4, s4state);
  s5state = digitalRead(S5);
  digitalWrite(LED5, s5state);
  s6state = digitalRead(S6);
  digitalWrite(LED6, s6state);
  Serial.print(s1state);
  Serial.print(s2state);
  Serial.print(s3state);
  Serial.print(s4state);
  Serial.print(s5state);
  Serial.print(s6state);
  Serial.println();
}

A video of the project in action.

You might also enjoy:

1. LED Patterns Using DIP Switch and Arduino
2. Controlling a Seven-Segment Display Using Arduino Part 3
3. Controlling a Seven-Segment Display Using Arduino Part 4
4. Arduino 2-Digit 7-Segment Display with Buttons | Part 4