Posts | Comments

Planet Arduino

Archive for the ‘blinky’ Category

[James Bruton], from the XRobots YouTube channel is known for his multipart robot and cosplay builds. Occasionally, though, he creates a one-off build. Recently, he created a video showing how to build a LED ball that changes color depending on its movement.

The project is built around a series of 3D printed “arms” around a hollow core, each loaded with a strip of APA102 RGB LEDs. An Arduino Mega reads orientation data from an MPU6050 and changes the color of the LEDs based on that input. Two buttons attached to the Mega modify the way that the LEDs change color. The Mega, MPU6050, battery and power circuitry are mounted in the middle of the ball. The DotStar strips are stuck to the outside of the curved arms and the wiring goes from one end of the DotStar strip, up through the middle column of the ball to the top of the next arm. This means more complicated wiring but allows for easier programming of the LEDs.

Unlike [James’] other projects, this one is a quickie, but it works as a great introduction to programming DotStar LEDs with an Arduino, as well as using an accelerometer and gyro chip. The code and the CAD is up on Github if you want to create your own. [James] has had a few of his projects on the site before; check out his Open Dog project, but there’s also another blinky ball project as well.

We recently started selling pre-assembled Blinky kits. As part of the manufacturing process, we really want to test out the optical programming process, to ensure that all the parts are working correctly. It would be inconvenient to dedicate a computer just to run the Blinky Programmer webpage to test each kit, so we decided to build a dedicated Blinky Flasher using an Arduino and two LEDs.

Here’s the simple sketch that transmits the pre-loaded data through the two LEDs. The code is also posted to our GitHub repository too.

/* Blinky Flasher
 * This sketch runs on an Arduino or compatible, with two LEDs.
 * It outputs the optical Clock / Data flashes to reprogram a blinky kit.
 * Comment/uncomment one of the bytes[] definitions below to choose between:
 * 1. Original messages loaded into a Blinky Grid kit
 * 2. Original messages loaded into a Blinky POV kit
 * 3. Some other byte stream from the Blinky Programmer webpage:
 *    Press 'Go' and then copy/paste the numbers from the `xmit_data` box
 *    into the bytes[] array below.
 * The bytes are flashed-out once at power-up, then it stops until reset.
 * When it's done, the Arduino's built-in LED will start flashing.
 * Press the reset button to reset the Arduino and retransmit.
 * More details about the Blinky message structure, framing, and transmission:
 * Written by Matthew Beckler and Adam Wolf, for Wayne and Layne, LLC.
 * To the extent possible under law, Wayne and Layne, LLC has waived all
 * copyright and related or neighboring rights to Blinky Flasher.
 * This work is published from: United States.
 * More details:

/* Adjust these defines to match your LED connections.
 * This sketch assumes that HIGH output turns on each LED. */
#define PIN_CLOCK 14
#define PIN_DATA 16

/* Adjust this define to change the delay between LED state changes.
 * We've had reliable transmission with this set to 20. */
#define DELAY_MS 20

// The setup function runs once when you press reset or power the board
void setup() {
    // initialize digital pin LED_BUILTIN as an output.

    pinMode(PIN_CLOCK, OUTPUT);
    pinMode(PIN_DATA, OUTPUT);

    digitalWrite(PIN_CLOCK, LOW);
    digitalWrite(PIN_DATA, LOW);


// These are not message_data, they are xmit_data (including intel hex record framing)

// grid:
byte bytes[] = {16,0,0,6,8,230,14,170,85,170,85,170,85,170,85,170,85,170,85,170,74,16,0,16,6,85,10,11,17,14,21,21,24,41,32,24,27,21,13,234,7,128,16,0,32,6,4,98,97,9,97,98,4,10,11,32,10,34,23,14,38,21,114,16,0,48,6,10,34,23,14,222,14,48,72,68,34,68,72,48,48,120,124,191,16,0,64,6,62,124,120,48,10,34,11,21,18,23,20,34,41,16,27,18,55,16,0,80,6,13,41,18,28,41,10,41,28,22,10,27,29,41,21,14,13,13,16,0,96,6,41,22,10,29,27,18,33,37,10,40,11,21,18,23,20,34,0,16,0,112,6,41,16,27,18,13,41,32,10,28,41,22,10,13,14,41,11,0,16,0,128,6,34,41,32,10,34,23,14,41,10,23,13,41,21,10,34,23,214,16,0,144,6,14,37,10,60,11,21,18,23,20,34,41,16,27,18,13,41,198,16,0,160,6,18,28,41,27,14,25,27,24,16,27,10,22,22,14,13,41,217,16,0,176,6,11,34,41,17,24,21,13,18,23,16,41,18,29,41,30,25,168,16,0,192,6,41,29,24,41,34,24,30,27,41,28,12,27,14,14,23,37,108,0,0,0,1,255};

// pov:
//byte bytes[] = {16,0,0,6,6,145,16,24,60,62,31,62,60,24,0,96,240,248,124,248,68,16,0,16,6,240,96,0,33,10,11,21,18,23,20,34,41,25,24,31,145,214,16,0,32,6,14,128,64,32,16,8,4,2,1,2,4,8,16,32,64,17,46,16,0,48,6,7,17,14,21,21,24,41,41,253,14,170,85,170,85,170,85,248,11,0,64,6,170,85,170,85,170,85,170,85,211,1,170,53,0,0,0,1,255};

// other:
//byte bytes[] = {8,0,0,6,1,30,5,17,14,21,21,24,109,0,0,0,1,255};

// the loop function runs over and over again forever
void loop() {
    for (unsigned int byix = 0; byix < sizeof(bytes); byix++) {
	Serial.print(bytes[byix], HEX);
	Serial.print("  ");
	for (signed int btix = 7; btix >= 0; btix--) {
	    // set data to black/white
	    if (bytes[byix] & (1 < < btix)) {
		digitalWrite(PIN_DATA, HIGH);
	    } else {
		digitalWrite(PIN_DATA, LOW);

	    // delay a few ms

	    // change clock state
	    digitalWrite(PIN_CLOCK, !digitalRead(PIN_CLOCK));

	    // delay a few ms

    // all done
    digitalWrite(PIN_CLOCK, LOW);
    digitalWrite(PIN_DATA, LOW);

    while (1) {
	digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
	digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW

We recently had to assemble a few Blinky kits and found a quick and easy method of soldering the optical sensors.

The best way appears to be to first bend the leads by 90 degrees. Use a pliers and pinch the leads directly below the sensor body. Use the fingers of your non-pliers hand to bend the leads by 90 degrees. Be sure that you’re bending them the correct way, as the two sensors have different orientation (C sensor has longer lead on left, while D sensor has longer lead on right).

After the two sensors have been bent, drop them into their corresponding holes in the printed circuit board (PCB). If you suspend the PCB using a vice, then the sensors should stay in place, oriented so they are pointing away from the circuit board. Use a soldering iron to carefully solder each pin. If the sensor gets crooked while soldering, use the solder to gently nudge it back into place (while continuing to heat the soldered pad).

Wayne and Layne is proud to announce that we are now selling pre-assembled Blinky Grid SMT kits!

A few years ago we purchased some “panelized” circuit boards of the Blinky Grid SMT design, which means that there are several copies (16 in this case) of the same circuit board design connected together in a snap-apart panel. This makes it easier (and quicker!) to assemble the boards in bulk.

The first step in bulk assembly is to apply solderpaste to all the exposed pads on the circuit board. We purchased a stainless steel stencil that matches the 16-board panels, then used a squeegee to apply lead-free solder paste through the holes in the stencil.

After all the pads have solder paste, the next step is to place each part on the board, stuck down into the solder paste. To place the parts, we use a machine called a Pick-‘n-Place (PnP). This is a desktop computer-controlled robot with a small vacuum nozzle that can pick up a part, optionally rotate it, and place it down in a precise location on the circuit board. Here’s a two-minute video of the PnP machine in action:

After the parts have been placed on the board, we need to heat it up to melt the solder to attach the parts. We use a small soldering oven to do this.

After the boards have been baked, the solder has melted and connected all the parts to the circuit board. The remaining steps include:

  • Solder the through-hole parts, like the pushbutton and sensors
  • Program the microcontroller with the Blinky Grid program code
  • Test that everything works correctly, including programming
  • Package and label each kit for sale

You can now find the pre-assembled Blinky Grid SMT kits in the Wayne and Layne Store.

This blog post is a short introduction to a pair of useful modes of operation for the Blinky Programmer webpage.

The standard Blinky Programmer webpage is a decent way to interactively create and program new messages into a Blinky Grid or Blinky POV kit. However, there are two main requests that we’ve received for new functionality for the programmer:

1. “How can I restore the original messages that were on the Blinky kit?”
2. “Is there any way I can save and restore the messages that I set up in the programmer webpage?”

Now, we have a way to do both of these!

First, a little background. The programmer webpage converts the messages that are created using the visual interface into a series of numbers, that are then optically transmitted to the Blinky kit. Details of the message formatting and transmission are available here.

The enhancements we’ve added are two-fold: First, we added a way to see “under the hood” of the blinky programmer webpage, so you can see the underlying data stream that is generated from the visual editor. This is a debug mode, enabled by adding “?debug” to the end of the website address, like this:

When the debug mode is enabled, a few new text boxes appear at the bottom of the page. These boxes are initially blank, but are populated as soon as you press the Go button. The first two boxes show the raw message data as a series of bytes, separated by columns (first box is decimal, second box is hex). These are the bytes that we want to store into the Blinky kit (first byte indicates how many messages are included, followed by the bytes of each message in turn). The second set of boxes show the “packaged” data to transmit (“xmit”), which surrounds the message data with some meta-data about where the message data should go inside the chip, and adds a checksum to protect against transmission mistakes (basically, we are packing the message data into the Intel HEX file format. The final text box shows the raw binary equivalent of the packed xmit data, which is the string of ones and zeros that are actually flashed out by the webpage. The most useful box here is the “message_data:” text box.

The second enhancement is a new version of the Blinky programmer webpage that enables “raw” programming. The new raw programmer is located here: “Raw” simply means that instead of using the visual editor to create text-based or pixel-based messages, you can simply type-in or copy-paste the message data into a text box, which will then be transmitted. This enables restoring the original set of messages, as well as being able to save your creations (by copying the contents of the “message_data” text box) and then pasting it into the raw programmer.

Back to the list of requested features, this time with some answers!

1. “How can I restore the original messages that were on the Blinky kit?”

Easy to do:

  1. Go to the raw programmer webpage.
  2. Copy-paste one of these long lists of numbers into the upper text field:
    6, 145, 16, 24, 60, 62, 31, 62, 60, 24, 0, 96, 240, 248, 124, 248, 240, 96, 00, 33, 10, 11, 21, 18, 23, 20, 34, 41, 25, 24, 31, 145, 14, 128, 64, 32, 16, 8, 4, 2, 1, 2, 4, 8, 16, 32, 64, 17, 7, 17, 14, 21, 21, 24, 41, 41, 253, 14, 170, 85, 170, 85, 170, 85, 170, 85, 170, 85, 170, 85, 170, 85, 211, 01, 170
    8, 230, 14, 170, 85, 170, 85, 170, 85, 170, 85, 170, 85, 170, 85, 170, 85, 10, 11, 17, 14, 21, 21, 24, 41, 32, 24, 27, 21, 13, 234, 7, 4, 98, 97, 9, 97, 98, 4, 10, 11, 32, 10, 34, 23, 14, 38, 21, 10, 34, 23, 14, 222, 14, 48, 72, 68, 34, 68, 72, 48, 48, 120, 124, 62, 124, 120, 48, 10, 34, 11, 21, 18, 23, 20, 34, 41, 16, 27, 18, 13, 41, 18, 28, 41, 10, 41, 28, 22, 10, 27, 29, 41, 21, 14, 13, 41, 22, 10, 29, 27, 18, 33, 37, 10, 40, 11, 21, 18, 23, 20, 34, 41, 16, 27, 18, 13, 41, 32, 10, 28, 41, 22, 10, 13, 14, 41, 11, 34, 41, 32, 10, 34, 23, 14, 41, 10, 23, 13, 41, 21, 10, 34, 23, 14, 37, 10, 60, 11, 21, 18, 23, 20, 34, 41, 16, 27, 18, 13, 41, 18, 28, 41, 27, 14, 25, 27, 24, 16, 27, 10, 22, 22, 14, 13, 41, 11, 34, 41, 17, 24, 21, 13, 18, 23, 16, 41, 18, 29, 41, 30, 25, 41, 29, 24, 41, 34, 24, 30, 27, 41, 28, 12, 27, 14, 14, 23, 37
  3. Scroll down and press the Go button to begin transmission.

2. “Is there any way I can save and restore the messages that I set up in the programmer webpage?”

Definitely possible:

  1. Using the normal Blinky Programmer webpage, but add “?debug” to the end of the address, like this:
  2. Create your text-based or pixel-based messages like normal. Transmit them into your Blinky kit to double-check that the message is correct.
  3. Select all the text in the “message_data” text box and copy-paste it into a separate document on your computer that you can save and access later.
  4. When you’re ready to program one of your old saved messages, go to the raw programmer webpage.
  5. Copy-paste one of your saved messages into the upper text box.
  6. Scroll down and press the Go button to begin transmission.

Hope that helps! If you have any questions, please ask in the forum or contact us.


Nice review of Blinky POV from BigMessO’Wires

blinky, kitbiz, review Commenti disabilitati su Nice review of Blinky POV from BigMessO’Wires 

Steve over at Big Mess O’ Wires wrote up a nice review of our Blinky POV kit. A few excerpts are below, you can read the whole thing at the Big Mess O’ Wires blog post.

My oldest daughter Alice has an occasional interest in electronics, and as her dad I try to encourage her without becoming too annoying. We’ve done some past projects like Snap Circuits experiments, building a Drawdio pen, and constructing an animated Halloween LED display. Recently we had a chance to build a Blinky POV from Wayne and Lane. Or more accurately I should say she had a chance to build it, since my role was limited to talking her through the steps and taking photos. It’s impressive what an 11-year-old can do with a soldering iron!

The main reason I selected Wayne and Lane’s Blinky POV instead of another similar one was the novel method used to program it. Instead of a PIC programmer, a serial connection, or some other conventional interface, it uses a pair of photo sensors to program new messages using flashes of light. Go to the Blinky Programmer web page, design some pixel or text-based messages, and click “go”. A clever bit of javascript flashes two squares on the screen, and when the Blinky POV is held near these flashing squares, it reprograms the stored messages in about 30-60 seconds. In our experience this method was very reliable, and much less hassle than dealing with virtual serial ports or other wired interfaces. And it actually made programming fun – like magic! The web page interface is surprisingly versatile, too. You can design pixel art or text messages, adjust the scrolling speed, switch between multiple stored messages, and define what should happen at the end of each message.

Reprogramming using photo sensors

This is starting to sound like a Wayne and Lane commercial, so I should probably add that I have no affiliation with them other than being a satisfied customer. If there’s a young builder in your life who might enjoy a simple but fun-filled electronics project, give Blinky POV a try.

Read more:


Nice review of Blinky POV SMT kit by MobileWill

blinky, kitbiz, review, SMT Commenti disabilitati su Nice review of Blinky POV SMT kit by MobileWill 

MobileWill posted a great review of our Blinky POV SMT kit!


The Blinky POV SMT is similar to the Blinky GRID but it only has one row of LEDs. By waving the Blinky in the air you can see the design/text due to the effect of persistence of vision. This happens because your retina sees the image slightly longer than it is being displayed. Read more about persistence of vision.

Last Thursday I came home and there it was, waiting for me to rip it open! Since I was leaving for a weekend trip, I decided I would assemble it that night so I could show it off. So at 10:30pm I got started.


Read more: MobileWill: Blinky POV SMT


Blinky Grid SMT featured in Adafruit Holiday Gift Guide: Blinky

adafruit, blinky, blinky grid, blinky smt, distributors Commenti disabilitati su Blinky Grid SMT featured in Adafruit Holiday Gift Guide: Blinky 

Our friends at Adafruit started releasing their yearly Holiday Gift Guides this week, and the Blinky Grid SMT was featured in their Adafruit Holiday Gift Guide 2012 – Blinky:

Blinky Grid Red SMT from Wayne and Layne: This is the surface-mount version of their Blinky Grid kit, and is a great way to learn and practice surface-mount soldering. While W&L won’t say that everyone can successfully solder surface-mount, you do not need extreme dexterity or super eagle vision. They have built a bunch of these with people who have never soldered surface mount before, between seven and fifty or so years of age – and everyone has been successful!

Read more: Adafruit Holiday Gift Guide 2012 – Blinky


Warm fuzzies about the Blinky Grid SMT

blinky, blinky smt, blinkygrid, customers, feedback, kitbiz, warm fuzzies Commenti disabilitati su Warm fuzzies about the Blinky Grid SMT 

Thomas wrote in with some kind words about the Blinky Grid SMT kit he purchased at Radio Shack:

Thank you so much for the high quality kits and excellent documentation! I recently purchased your Blinky Grid SMT kit for a teaching engagement – mostly because of the novel programming method! To say the least, everything worked out great. Building the kit was a breeze, programming and demo went well, and the kids I was working with walked away with an increased interest in electronics and programming!

Next up – Video Game Shield! Just need a free weekend! Again, keep up the great work and please, more SMT kits!!

The Blinky Grid SMT (and all the other Blinky kits) are available in the Wayne and Layne Store and also the Maker Shed store.


Nice review of the Blinky POV SMT kit by tronixstuff

blinky, review Commenti disabilitati su Nice review of the Blinky POV SMT kit by tronixstuff 

John from Tronixstuff recently reviewed our Blinky POV SMT kit, and really liked it! Here are some highlights from his review:

after my last attempt at working with hand soldering surface-mount components couldn’t really be called a success, I was looking for something to start again with. After a little searching around I found the subject for today’s review and ordered it post-haste.

you’ll want to put your own messages into the POV – and the process for doing so is very clever. Visit the programming page, and follow the instructions. Basically you enter the text into the form, set the POV to programming mode – and hold it up against two squares on your monitor. The website will then blink the data which is received by the light-sensitive LEDs. Once completed, the POV will inform you of success or failure. This method of programming is much simpler than having to flash the microcontroller every time – well done Wayne and Layne.

We had a lot of fun with this simple little kit, and learned a thing or two about hand-soldering SMT. It can be done with components that aren’t too small – however doing so was an interesting challenge and the results were quite fun. So it met our needs very well. Anyone can do it with some patience and a clean soldering iron.

Continue reading… Adventures with SMT and a POV SMT Kit

Photos by John Boxall

  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook