Skip navigation

Arduino Projects

8 Posts authored by: Cabe Atwell


Just in time for Halloween and Fall, a pumpkin… But not just an ordinary pumpkin. This one will stand out of all the other pumpkins sitting on people's porches…. Just sitting there. This pumpkin is about to fly away. Yes, a UFO pumpkin with lights. Ideal for the front porch of a house you want to catch people's eye as they pass by. If Christmas lights and decorations weren’t enough, we are bringing the decorative house lights earlier into the season. Now you can annoy your neighbors with flashing lights before Christmas.


Project by sections:

For this project, I carved a pumpkin using a UFO stencil and wrapped it in a 16.4ft WS2812B, individually addressable, LED strip controlled by an Arduino UNO and powered by a 5V 10A power supply.  A 3rd of the LED strip is inside the pumpkin, another 3rd is wrapped around the stem, and the last is wrapped around the outside. The strip is fed through the top lid with a rectangular hole. This 16.4ft strip has a total of 150 Individually addressable LEDs.I created my own lighting sequences and put them one after the other for a UFO-like show.



1x Arduino UNO R3

1x 16.4ft WS2812B Waterproof LED Strip

1x 5V 10A AC to DC Power Supply

1x 5V 500mA AC to DC Power Supply for Arduino

1x Large Pumpkin

1x Pumpkin Carving Kit


Schematic and design:



The code starts off in the main loop and calls each lighting function. The timing and number of cycles for each lighting sequence is passed into the function by the parameters entered in the function call. For example, color of LED section and timing. The first lighting sequence is called “spaceShipStart” which shows the inside blink green 8 times and goes solid, then the outside flashes a quick orange/pumpkin color. The inside and outside increase in brightness until max. Once at max, the top turns on to green to represent the stem. The second sequence keeps the top lit as the green stem, inside as purple and the outside shoots orange around the pumpkin. The third sequence is a rainbow, where the whole strip cycles through every color at different places on the strip. The fourth is called a cascade where 1 LED is lit and moves position very fast. This looks like a 1 color wrapping around the pumpkin till it goes inside and makes a faint blinking. The last sequences, blink the top, outside, and inside as their respective colors, this turns into a fade in and out, where the brightness cycles from minimum to maximum. The “spaceShipStart” then starts again being on a loop.      



The code was developed using the Adafruit NeoPixel library. This library lets you control the color, brightness, and which pixels are on or off. This library has some examples of lighting sequences to help get started. The code splits up the leds by section, for each of the lighting sequences, the LEDs for the outside, inside, and top get set. The programmer sets which lights are ON and what color, then is displayed to the strip using The sections of the strip are addressed by knowing what LED is lit in each section. There are 150 LEDs, the inside of the pumpkin had 39 LEDs from the end of the strip, so to address the colors and sequences of the inside of the pumpkin you would start from the end of the strip in your for loop and assign the color of the lights from the end decrementing the variable until you’ve reached your last inside LED from the beginning, since we are going backwards in assignment. So the for loop starts at 150 and decrements until it reaches LED 111, this means the LEDs 111 through 150, represent the inside of the pumpkin.



Assigning the brightness was difficult because the brightness function provided by the library was a global brightness. Which means that the whole strip always has the same brightness. So if you want to make one part of the strip a different brightness from another at the same time, you have to come up with a more clever way to do it then using the library’s function, “leds.setbrightness()” before 


Other uses of the system:

This strip can be used in a variety of different applications, after this project, I already have some ideas to use this on something else. Bar lighting, room lighting, custom Christmas lights, you can tell your neighbors you did it yourself when they ask where you bought that from. The individually addressable lights make a good indicator of something. You could strand this up on your garage wall and make a parking indicator reflect where your car is with the individual LEDs. There are a lot of possibilities.    


If I had more money/time:

More lighting sequences, remote/trip sensor to start, sunlight sensor to turn on at night. The LED strip was waterproof, but my Arduino was not, so a waterproof case for the power and control electronics would make it last longer outside.  


Oddities and observations:

The LED strip came with mounting brackets that made it very convenient to attach to the pumpkin in the back. Also, the camera couldn’t keep up with adjusting the brightness for the LEDs at night ─ so you might see some effect from that. At night it was very bright and definitely will catch the attention of people walking by. As you can see in the zoomed picture below, how bright it is.


Pumpkin Making:


{gallery} Making the pumpkin




Thanks for reading!


#ShareTheScare this Halloween

Visit our Halloween space and find out how to win one of two Cel Robox 3D Printers. There are two ways to win:

Share your Project and Win
#ShareTheScare Competition
The Ben Heck Show Episodes


Disclaimer: I’m an engineer, not a pro film maker. Be advised.

Disclaimer: I’m an engineer, not a pro film maker. Be advised.



This was a project in the making some years ago… See more about it here.


In this evening’s project, I want to evoke one of the most primal fears… eyes in the darkness.


It’s rooted in a real scary threat, some sort of wild animal. Rat, dog, flying squirrel, wolverine… whatever is the wild thing from where you’re from. Usually those eyes in the weeds/darkness are following by slow backing away or full blown running.


Just imagine, you’re alone in a forest. The evening is washing through the trees, dragging darkness with it. Before you know it, your vision shortens to half, maybe less of a distance in front of you. Light is almost gone. But there… somewhere between the foliage.. a pair of eyes appear. Maybe more. Maybe a whole lot more. The creatures of the forest are closing in. At least… that is the effect I was going for.


In this project, we are going to start out with one pair of eyes. I’ll show you how to add blinking for more realism. For the ambitious, I will show how to chain a bunch of eyes together for a greater effect.



The project by sections:


This project could easily be done without a microcontroller. Even the “blinking.” But, for a greater amount of control, I decided to use an Arduino Nano. It’s more about future proofing than anything, more this in the “If I had more time and money” section below.


The “eyes” are simply a pair of LEDs. I chose red for a classic evil monster look. I also use orange for a closer to an animal’s eyes in the darkness. However, any eye color is cool, I suppose. Perhaps blue for a “Game of Thrones” zombie.


I added a Light Dependent Resistor (LDR), or photoresistor, as a sensor for the Arduino Nano. I wanted to detect the ambient light conditions and turn on the “eyes” only when it is dark enough. Nothing ruins scary eyes like the daylight! As light disappears, the resistance of the LDR shoots through the roof, for those who are wondering. This is how the light level is detected, based on a resistance value.


In the circuit, I added a few potentiometers to adjust various aspects of the scary eyes. First, the brightness of the eyes – real eyes in the dark don’t look like a pair of headlights. The frequency of the blinking effect is also adjustable.



1x Arduino Nano

1x Full-size breadboard

2x Small breadboards

1x Photoresistor

1x 10kOhm resistor

2x 1K Ohm resistor

4x 220 Ohm resistor

3x Potentiometer 100kOhm (I used these types, but you could use others)

2x NPN transistors (PN2222)

2 pairs of LEDs (Red)

Project wires


Schematic and design:



It is this simple. The complexity comes in the code.


This is the actual build. I strung an extra pair of eyes off of one of the mini breadboards - I stuffed the LEDs into a yarn ball. Also pictured is the 9V power supply I used to power it.





If you connect the Arduino to a PC, I put in an option to output serial data.

In the Scary Eyes project, I output the states of the three potentiometers. I label them as well, Threshold, Brightness level, and Blink duration.



Suggestions on the build:


You do not need to use breadboards for your “eyes.” You could just make a harness to string out the eyes where you see fit. Just run them back to the Arduino Nano.


I thought this system would be used indoors. Rain would be a huge issue to running it outside. Here are some suggestions about if you want to use this outside.


- First and foremost, run the system off of a battery to make it portable. The types you charge cell phones with would work.

- Put the Arduino Nano and its support components inside a water-tight enclosure with the battery.

- Run the cables outside the enclosure for the LEDs. This may require drilling and hot glue to seal the and potential leak points you create.

- Waterproofing the LEDs is the hard part. You could use a similar principle as the Nano’s enclosure. You could also put the LED inside a clear enclosure.



Other uses of the system:


- This is a prefect system to put inside the carved pumpkins. It will even turn on in the dark!

- You could also use them as eyes for the pumpkin too.

- Or, how about an overly complex nightlight?


Oddities and observations:


I found no real change in brightness when running off of a 5V USB connection. I didn’t string more than 3 sets of eyes though.


If I had more money/time:


- Originally, I wanted to add sound that would play as people approach the eyes. However, adding that would have cost too much in terms of logistics for the devices.

- My big plan for this was to make 100 pairs of eyes that would turn on in waves as people went through a wooded path. First a few, then a lot. Coupled with sound, that would be terrifying…. I thought.




#ShareTheScare this Halloween

Visit our Halloween space and find out how to win one of two Cel Robox 3D Printers. There are two ways to win:

Share your Project and Win
#ShareTheScare Competition
The Ben Heck Show Episodes



Disclaimer: I’m an engineer, not a pro film maker. Be advised.

Disclaimer: I’m an engineer, not a pro film maker. Be advised.



Tonight’s Halloween project is another effect as old as time… Scary Shadows.


Shadows are obscure, raise suspicion, we can only imagine what creates them. The fear of the unknown is one of the basic, most natural fears. Even when a shadow is clearly defined, we still have a hard time gathering what it is exactly. Depending on the light source, the shadow of an object can be distorted and disorienting.


A shadow can be a monster, an entity, or just someone creeping up behind you. Young and old can get scared of a shadow.


To create a simple shadow casting project, I went about creating an Arduino stepper motor control system. Simply put, the stepper motor will move cutouts into a light source, casting shadows, for a few different effects.



The project by sections:


The concept is simple, cast shadows and control their movement.


To accomplish this, I used a stepper motor to turn a special 3D printed hub holding paper cutouts of various “monster” shapes. Placing a strong light source behind the cutouts will make a shadow on a surface.


I used a 1000lm LED flashlight for the light source. However, I found that removing the lens from the end of the flashlight produced a wider spread of light. With the cutout close to the LED in the flashlight, the shadows were large and distorted at times. Which was a cool effect.


Since I was controlling a stepper, I could control the direction and speed fairly easily. So, I had three modes of movement.


- Constant, clockwise

- Constant, counter clockwise

- Bounce between the two directions with a single button push. Like hitting limits.


A single potentiometer on the breadboard controlled the speed. Although I was in single-step mode, meaning the stepper moved one step per pulse, it was fairly smooth across most speeds.





1x Arduino Nano

1x Full-size breadboard

1x DRV8825 stepper driver

1x Low current Stepper motor

2x Momentary Push buttons

1x Potentiometer 100kOhm (I used these types, but you could use others)

1x 9V power supply. (I used a switching power supply from an old device.)

Project wires

1x Light source of choice. I used an LED flashlight


Schematic and design:


Not pictured is the 5V USB connection you also need on the Arduino Nano.


The actual build. The stepper motor bub is a custom 3D printed part. I could have just used tape and the paper.







If you connect the Arduino to a PC, I put in an option to output serial data.

In the Scary Shadow project, it will display the direction data.




-The paper cutouts were a pain to make a use, to be honest.



Other uses of the system:


- This is a prefect system to put inside the carved pumpkins. It will even turn on in the dark!

- You could also use them as eyes for the pumpkin too.

- Or, how about an overly complex nightlight?



If I had more money/time:


- First and foremost… 3D print the silhouettes as opposed to paper cutouts.

- I would like to explore digital shadow casting. Using an opaque screen, I could “turn on” pixels that could block light, hypothetically. I could animate the shadows! Now, that would be awesome.

- Sound is always good to add to effects.

- I wanted to create an effect of a crowd rushing behind someone. But, I think I would need more elaborate shadow casting apparatus. Perhaps a linear stage along with this rotary option.

- Add micro-stepping for a smoother turn



Oddities and observations:


- At the slowest speeds, there was a lot of vibration created by the single stepping.

- At high speeds, the stepper would slip. Which simply means that it was getting pulse faster than it could react. There is a maximum speed.



Disclaimer: I’m an engineer, not a pro film maker. Be advised.

Disclaimer: I’m an engineer, not a pro film maker. Be advised.






motion detection system 1.jpg

The wireless motion detector project. Three drop-modules report to the monitor in the foreground.



Motion detectors are cool but running wires out to them is a drag. We wanted to secure an area quickly and conveniently and without sirens or bells letting intruders know that we know that they are trespassing. That means no wires.

And so, it was decided, a wireless motion detecting system would be built.


We could picture it in our minds, a portable, self-contained system that would let us know when our parents got home or when Derek was breaching the perimeter around our couch-cushion fort. Derek doesn’t respect perimeters.


Design considerations – selecting components

We started with Arduino Micros and went from there. We chose these because they are small and have an on-board USB controller. This allows them to be programmed simply by plugging them into a USB port, just like the UNO. No FTDI adaptors would be needed like as is necessary for compact boards like the Arduino NANO. The version of the Micro used came without pin headers soldered on. This for ease of assembly and to conserve space. The pins would have been harder to solder to and would have taken up a lot more room.


nRF24 1.jpg  

For the wireless bit, we selected the nRF24L01+ radios. Note the + at the end of the name. The “plus” models that have a male SMA connector for an external antenna and they have an alleged open-air range of 1000 meters when operated at maximum power.


nRF24 adapter 1.jpg

nRF24 radios are extremely finicky when it comes to their power. They do not tolerate supply noise at all. To put the stop to any issues of this sort before they start, we used an adapter board like this. They come with an AMS1117 linear regulator to keep the voltage to the radio at a steady 3.3 volts. They also have a few noise filtering capacitors to keep the power clean.


OLED screen 1.jpg 

An 128x64 i2c OLED screen was used to display the status of the sensors. An i2c connection was chosen on purpose. The nRF24 radio communicates via SPI. So, to prevent any conflicts that might arise from having the screen and radio on the same data bus, it was decided use i2c for the screen. Yes, theoretically there should be no problem with putting the two devices on the same data bus. But all too often, reality swings in to ruin your day and you are left screaming about how everything worked fine on paper. To minimize any handholds for Murphy’s and Sod’s Law, communications to the screen and the radio were kept completely separate.


PIR sensor 1.jpg

This is the PIR motion sensor used for the drop-modules. The potentiometers on the side control how sensitive the device is and how long the output stays high after motion is detected.


battery 1.jpg 

Lithium-polymer battery in the shape of 9-volt batteries was chosen as a power source for the drop-modules and the monitor. Originally, the intention was to use disposable alkaline or lithium 9-volt batteries. However, these types of batteries will not meet the power demands of the nRF24 radios. This point demands a bit of explanation. nRF24 radios draw very little “on” but quiescent. During the short period that they are transmitting their power requirement spikes abruptly. A typical 9-volt battery cannot provide the energy fast enough for the nRF24. This problem can sometimes be mitigated by installing a fairly large capacitor (100uF) in parallel with the battery. Another solution is to do what we did, use a lithium-polymer battery. The particular batteries we chose are very convenient for projects because they combine a lithium-polymer battery with a battery management circuit, a battery protection circuit, and a boost converter. They also have a micro USB port for charging. It’s like five components packed into the shape of a 9-volt battery. Note the tiny hole in the bottom of the battery. This is for a red LED that lights up when charging. The LED shuts-off when the battery is fully charged.


Monitor BOM


Drop-module BOM



The Code (Attached to this article)

Code was written up for the drop modules and the monitor. The code for each of the drop modules is identical. During the drop-module’s setup routine, the address selection pins are polled to see what the modules address is. Two modules cannot have the same address. If they did, the monitor will interpret all the received data as coming from the same drop-module, and the system will not work as intended.


An ad-hoc protocol was developed for communicating drop-module status back to the monitor. The drop-modules encapsulate all of their data into an unsigned long variable. Each byte of this variable would represent a specific alarm code or the status of the battery. Then, the entire unsigned long variable is sent to the monitor.


At the monitor, this variable is broken back down into bytes, and the data is used to determine what drop-modules are active, what its status is and if the signal from any module is dropped.


The code for the drop-modules and the monitor share a number of details. They both us the RF24.h library to handle interactions with the radios. Also, they both use the TimerOne.h library. Timer one is used to make sure events like transmitting status and updating the OLED display happen at regular intervals.


The monitor uses the U8g2 library to control the OLED.  This library is very easy to use, and it is loaded with easy to use functions for drawing lines and shapes and placing text on the screen. There is a huge selection of fonts to choose from too.


At a glance, the code, especially the monitor code looks complicated but don’t let it scare you. It is lengthy, but you have a couple things going for you. It is commented extensively, and it is written out in a longhand of sorts. This makes the code take up a lot more space than it needs to, but it is also easier to understand for the less experienced coder. Oh, and the bulk of the monitor code is subroutines used to refresh the OLED display.



The mechanical design (Files needed for 3D printing, attached to this article)

All the parts that we knew were going into the project were mocked-up in SolidWorks. The Arduino Micro, the nRF24, the 9-volt battery, the OLED screen. These mock-ups are mostly rough geometric approximations of the real parts. We don’t need a high level of detail to effectively design enclosures for the project.


SW monitor 1.png  

From here the enclosure for the monitor was drawn up. The enclosure takes style cues from sources like the Aliens movies and the short videos of Neill Blomkamp.


SW drop module 1.png 

Then the drop-module was drawn up. It is designed around a clear plastic toothpick container. The container is clear and just the right size to house all the parts.


Putting it all together

The monitor enclosure and the parts for the drop-modules were 3D printed in a pleasing dark blue color. There was nothing very complicated about the build. The components were wired together with short leads, soldered and then covered with heat-shrink tubing. The notable points of the build are illustrated in the pictures below.



The monitor

schematic - monitor .JPG

The monitor wiring diagram. Start here.





{gallery:autoplay=false} Monitor Assembly

monitor module 5 - nRF24 radio.pngHere is the radio installed in the monitor. Notice the two spacers around the SMA connector.

These keep the radio square to the interior surface when the antenna is threaded on - they were made by trimming an old credit card into washer shape with a hobby knife.

monitor module 2 - nRF24 adapter.pngThe pins and headers were de-soldered from the adapter board; this was done to conserve space.

Then, wires were soldered to the adapter and then the whole board was covered with a big piece of heat-shrink tubing.

monitor module 3 - power button.png

The on-off switch slides into the pocket designed to hold it.

monitor module 4 - resistor bridge 1.pngThe voltage divider network for monitoring the battery status was constructed with a pair of 10k resistors.

The entire assembly was covered in heat-shrink - the yellow wire runs to and ADC input on the Arduino MICRO.

monitor module 6.JPG

The reset buttons are pressed into their slots. Friction keeps them in place.

screen & bezel 2.jpg

The conserve space, the OLED screen sits in a 3D printed bezel.

screen & bezel 3.jpg

The screen drops right into the rear of the bezel.

screen & bezel 1.JPG

The screen installed on the outside of the monitor enclosure.

monitor module 8.jpg

Fold everything into the enclosure - be careful not to break anything.

monitor module 7.jpg

Once everything is tucked inside the monitor, fasten the rear covers down with #2 machine screws.

monitor module 1.jpg

Completed monitor - human hand for scale.





Building the drop-modules


schematic - drop module.JPG

The schematic for the drop modules. Notice the address selection pins 8, 9, and 10. To set the address of the module, a single pin must be connected to ground. Modules cannot share addresses.



{gallery} Building the drop module

drop module 1.png

The drop modules are assembled with the same methods as the monitor - you can see here that all the components are wired up and protected with heat-shrink tubing.

drop module 2.png

You can see here where the headers and pins have been de-soldered from the adapter board and the nRF24 and wire leads have been soldered in their place - the assembly is covered in heat-shrink after soldering.

drop module 3.png

The PIR sensor is hot-glued into its 3D printed shell.

drop module 4.png

To finish, carefully fold the everything into the containers and seat the tops. Then Slide the retaining ring over the bottom of the containers. Finally, fasten everything together with the long #6-32 screws and nuts. It is a good idea to label the drop-modules too.




How to use it all







There were a lot of different ways we could have come at this project. We could have used a mesh network that would have allowed for dozens or over a hundred drop-modules, but instead, we went with three. Also, the code could have been written far more efficiently. Especially the monitor code. For anyone who attempts this project we strongly suggest having a go at optimizing the code.


We used 3D printed parts and toothpick containers to house our project, but you don’t have to do any of that. Use breadboards and cardboard. Or use plastic food containers. It doesn’t matter. The code and the hardware are oblivious to how good (or bad) they look. Also, for your version of this project, you can use different sensors. You don’t have to use PIR motion detectors. You could use the drop-modules to keep an eye on anything. Use photoresistors to see if someone turns on a light. Replace the PIR sensor with a momentary pushbutton or a pressure sensitive doormat to make a wireless doorbell. Maybe you could use a drop-module with just a tilt sensor to let you know if someone is messing with your bike. Whatever you ultimately decide to do, this project gives you a solid basis to work from.


But for now, Derek won’t know what hit him.




Have a story tip? Message me at: cabe(at)element14(dot)com

Project build Index:

Arduino Project : Three-Finger Ring - Part 1 Getting started and 3D Printing

Arduino Project : Three-Finger Ring - Part 2 Code & the Circuit

Arduino Project : Three-Finger Ring - Part 3 Assemble the Ring!




Step 6: Assemble the ring and install the components.

At this point, disassemble the breadboarded circuit and begin installing it into the ring. Glue and a hobby knife are essentials in this step. Unless you got lucky or have a printer that fabricates with a nigh-zero deviation from mathematical perfection, you will need to use a hobby knife to trim the printed parts.


The power pack is made by sandwiching the batteries together with a positive and negative wire and wrapping the whole affair tightly with electrical tape (Figure 5).


Hot glue was used to fasten the parts in place (Figure 6).


The #4 screws are used as pins for the hinge and to fasten the ring’s lid down (Figure 7).


battery pack.jpg  

Figure 5: The ring battery pack. It is a bit inelegant, but it works.


assembling 1.JPG

Figure 6: Glue the parts into the ring.


screw it together 1.jpg 

Figure 7: The #4 screws fasten the ring together.





Step 7: Power it up and show it off.

You might want to create some fresh images for your ring. Our pics didn’t increase our popularity quite as much as was hoped. Here are a few examples.



element 14 (12).JPG

danger (9).JPG

eulers relation (3).JPG

konami code (12).JPG

i 8 sum pi (8).JPG

max power (4).JPG

nerd life (8).JPG

ohms law (5).JPG

QT pi (6).JPG

stud muffin (28).JPG

final form (9).JPG





Final Notes:

We used a 128x64 OLED screen with that goofy yellow and blue background color. You can use whatever screen you want (almost whatever screen) as long as you adhere to a few guidelines. Make sure that the screen communicates via I2C.


The circuit and code do not use the RESET line. If the screen you get does have a RESET line, pull it HIGH by wiring it to the 5V output on the Trinket Pro.


If the resolution of the screen is anything other than 128x64 pixels, you will have to:

  • Size your images appropriately using a picture editor. You will not be able to use the CPP arrays in the provided code. You will have to create new arrays for your screens exact resolution.
  • You will have to adjust the U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NO_ACK) line in the code so that the U8glib library knows what screen size to work with. There are no provisions in the code or the hardware for detecting any information on the screen, so you have to tell it what is going on.


You are not obligated to use two CR2032 batteries to power your ring. Use a Li-Po battery back, an AAA with a boost converter, whatever. It doesn’t matter. The Trinket Pro can be powered by anything from 5.5-16 volts. If you wanted, there is no reason why a tiny Lithium-polymer battery and a battery management board couldn’t be used in place of the coin cells. Or a solar cell in conjunction with a super-cap or rechargeable battery.


Thanks for reading! Good luck with you own ring project!

Project build Index:

Arduino Project : Three-Finger Ring - Part 1 Getting started and 3D Printing

Arduino Project : Three-Finger Ring - Part 2 Code & the Circuit

Arduino Project : Three-Finger Ring - Part 3 Assemble the Ring!




You have everything ready from Part 1 right? Good. Now it's time to program and get images on that screen.


Step 4: Breadboard the circuit.


Before installing anything, test it on a breadboard. That way, it will be so much easier to troubleshoot. See the electrical schematic in Figure 4.



Figure 3: Breadboard the circuit before installing it.



Figure 4: The electrical schematic for the Screen Ring.



Step 5: Upload the code to the Trinket.


There are a few special considerations for using the Adafruit Trinket. The IDE available from the Arduino site does not natively support it. You will need to either download a special version of the IDE from Adafruit with the board data pre-loaded, or you will have to follow the instructions on the Adafruit website detailing how to load the board data into the IDE. Either way, you will need to start HERE at the Adafruit introduction to the Trinket.


The cornerstone of the Screen Ring code is the U8glib library. It takes care of all the heavy lifting regarding control of the screen. The specifics of this library are well beyond the scope of this article but, if you want to learn more about it, start HERE.



Step 5-2: Create some sweet bitmaps for the ring.

The Arduino code cannot read PNGs or JPGs and the like. It requires BMP images to be converted into data arrays which are then pasted into the code. One of the easiest ways to accomplish this is to use the online image2cpp converter. Just upload a BMP, convert it and then copy the generated code into the Arduino sketch (Figure 5).


There are some rules for getting the converted images to display properly. This can all be done in Windows Paint.

  • Images must be in black and white.
  • Images must be created with a size of 128x64 pixels.


start of Array.JPG

Figure 5: The beginning of an array pasted into the sketch.



Resources: The CODE.


Attached to this post is code used in the Three Finger Ring.


In it, you can change the code to for any images you convert.

Project build Index:

Arduino Project : Three-Finger Ring - Part 1 Getting started and 3D Printing

Arduino Project : Three-Finger Ring - Part 2 Code & the Circuit

Arduino Project : Three-Finger Ring - Part 3 Assemble the Ring!






I already teased this project back on "Geek Day," June 9th 2017. It's now completely finished!


This writeup will go over all the steps taken to build the screen ring. However, you dear reader won’t have to personally execute every step. You have the option of skipping steps because we will provide the 3D models for the ring and the accompanying code. You can procure the parts and print the ring without any of the design work. The one aspect of the design that you may have to change is the size of the holes in the ring to accommodate finger size.


In this section, we are going over all the mechanical aspects of the ring. What parts to gather. And how to get the ring 3D-Printed. (Part 2 is where we will cover the circuit design and code.)


Step 1: Decide on the parts to use.


For the dangerous end of the ring, we used a 128 x 64 pixel 0.96-inch OLED screen, very similar to this screen here. The exact screen we used is permanently blue with a yellow band across the top third. The yellow top third was probably originally intended to display data like the time and the battery charge.

An Adafruit Trinket Pro 5V provided the brains. It has far more IO than is needed but that’s OK. All those extra pins and features can be used on the next version of the Screen Ring.


While the options for powering the ring are many, we went with a couple of CR2032 coin cells. Each coin cell outputs 3V so stacking two of them in series yields a handy 6 volts. This is just enough to power the Trinket and for the Trinket’s onboard MIC5225 to regulate the voltage down to 5V for the OLED screen.


Bill of Materials

Quantity 1 - OLED Display, 128x64, I2C

Quantity 1 - Tactile Switch or something roughly equivalent

Quantity 2 - Adafruit Trinket Pro 5V

Quantity 2 - CR2032 coin cells

Quantity 3 - 10k resistor

Quantity 4 – #4 x 0.5” (12.7mm) machine screws


Step 2: Design the ring.


The ring was designed in SolidWorks, but any 3D CAD software like LIBRECAD or FREECAD will work. Again, you don’t have to design anything if you don’t want to. However, for the those who would attempt it, here is a bit of design advice.

  • It always helps to have at least a nebulous concept in mind.
  • Start by creating 3D models of the parts you know will be used. In this case, the screen, the batteries, the button and the Trinket. The level of detail applied to each of these models is up to you. You may not need to model the Trinket down to the point where all of the components on the board are represented. However, it would be a good idea to at least make the model large enough to fill the immediate space around the Trinket.
  • Start with a box big enough to hold all of these.
  • Position your parts inside the box where you think you would like them.
  • Start removing material where you don’t need it and adding it where necessary. For example, you might add bosses or studs for holding parts.


Once this "box full of parts" was designed, it was obvious that a single finger wasn’t going to be enough support it. For stability and coolness, it was decided that three rings bridged together would do the job. To get the size just right, a few of the ring-only sections were printed up and tested on actual hands.


3D modeling in progress.jpg

Figure 1: 3D modeling in progress. (NOTE: This image is far from the final design)



Step 3: Print the ring.


The 3D models can be sent off to a service like Shapeways or you can print them up yourself if you have access to a printer. For the ring seen here, we used our MakerGear M2. A quick shout out to MakerGear, the M2 deserves all the approbation it gets. It really is a workhorse.


We used this particular blue color (Figure 2) because it’s cool and kind of makes things look like they’re from the future. Oh, and because we had several rolls of that color already on hand.


the printed bits.jpg

Figure 2: This blue color is so rad.



Resources: 3D Models.


Attached to this post is a collection of the 3D models used in the Three Finger Ring.


You could use this as a starting point for your custom design too.


A new Arduino Gameboy called Arduboy. Nostalgia is fun, and nostalgic games are even more fun. Arduboy is a new and cheap ‘gameboy’ that allows you to play games old-school. (via Arduboy)

I can't believe I missed out on this cute little gameboy-ish system powered by Arduino, with a heaping dose of nostalgia along with it. The creator, Kevin Bates, is calling it an Arduboy and he quit his full time job over a year ago to develop this creation. He even moved to China to get the production line all set up and have his product in the making. Now, that is definitely commitment.


The Arduboy is the size of a credit card and has an 8 hour battery life, meaning that waiting for your friend to get out of the bathroom at Starbucks just got way more fun. The Arduboy is powered by Arduino, a black and white 1.3 inch OLED screen, and two piezo speakers. Basically, it has everything you need to game in vintage style.


It also had... a great price point, at $29. You can get one for $39 direct from them. The Kickstarter campaign ended with over $433,000 in funding. This is over 17x their original pledge goal.


arduboy games.JPG

Arduboy games from the community.


The Arduboy is also open source so you can code it to do whatever you’d like. Bates has also sent over 100 developer copies to ensure that there are at least 100 free and open source games available for the Arduboy by the time it gets to you. Some of the games include knock-offs of popular games like Oregon Trail, Flappy Bird, and Ardumon.


Bates told the peeps at Engadget that he eventually wants to sell the Arduboy for $10 and have it available for companies to brand and giveaway as conference swag. If that ever happens, I will attend way more conferences. 

If anything, I take away a little inspiration from the Arduboy. The creator took a simple design all the way, committed to the project, and won out in the end. It's time for everyone to do the same...


See more news at: