Posts with «led matrix» label

Cakeday Countdown Clock is a Sweet Little Scroller

If you want strangers to give you well wishes on your birthday out in the real world, you have call attention to the occasion by wearing a pointy hat or a button that says ‘today is my birthday, gimme presents’. But on your reddit cakeday, aka the day you joined, you’re automatically singled out with the addition of a slice of 8-bit cake next to your username. The great thing about your cakeday is that you’re almost guaranteed to get some karma for once, especially if you make something cakeday related like [ScottyD]’s cakeday countdown clock. But plenty of people forget what their cakeday is and miss out on the fun.

This countdown clock works like you might expect — every day that isn’t your cakeday, a message scrolls by with the number of days remaining until your next one. When the big day comes, the message becomes TODAY IS YOUR CAKE DAY. Both messages are bookended by cute little pixelated cake slices that we would apply liberally to the day-of message if we made one of these.

This simple but fun project shouldn’t put too big of a dent in your parts box, since it’s essentially an Arduino, a real-time clock module, and a 32×8 LED matrix to display the text. We love the uni-body design of the enclosure because it creates a shelf for the Arduino and gives easy access for gluing in the display from the rear. If for some reason you don’t reddit, then make one anyway and use it to count down to your IRL birthday or something. We’ve got the build video cut and plated for you to consume after the break.

We would understand if 2020 is supplying you with enough existential crises, but if not, consider building a clock that counts down the rest of your life expectancy.

Via r/duino

Arduino Drives a 600-Character Display

[Peterthinks] admits he’s no cabinet maker, so his projects use a lot of hot glue. He also admits he’s no video editor. However, his latest video uses some a MAX7219 to create a 600 character scrolling LED sign. You can see a video of the thing, below. Spoiler alert: not all characters are visible at once.

The heart of the project is a MAX7219 4-in-1 LED display that costs well under $10. The board has four LED arrays resulting in a display of 8×32 LEDs. The MAX7219 takes a 16-bit data word over a 10 MHz serial bus, so programming is pretty easy.

The MAX chip can decode for seven-segment displays or just allow you to light up the outputs directly, which is what the code here does. You can cascade the chips, so it is possible to string more than one of these modules together.

The code is available on Dropbox. The code is extremely simple due to the use of the Parola library and a MAX72XX library. We’ve seen a number of projects based around this chip. Some of the uses are pretty novel.

LED matrix made touch sensitive with infrared control

If you’d like to integrate touch functionality to your LED matrix project, then tuenhidiy may have just the thing for you

The setup uses 16 pairs of IR emitter and receivers arranged down the length of the bi-color 16×32 matrix to tell when one has inserted a finger or other object into an area. When sensed, it changes the corresponding column on the display from red to green or back again.

An Arduino Mega is used for overall control of the device, along with shift registers and multiplexers/demultiplexers to account for the massive amount of IO needed. 

Code for the build is available on GitHub, and you can see it demonstrated in the video below.

Use an LED matrix as a scanner

Consider that a digital camera uses an array of sensors to capture light from an object. Maker Marcio T, however, decided to turn this idea on its head and instead use an array of lights that are detected by a single sensor.

The way it works is that as each LED in a 32×32 matrix illuminates, a phototransistor picks up light if the path is clear or sees no change if the path is blocked. So when you put an object on the matrix, the sensor is able to get an accurate picture of it, enabling its Arduino Uno controller to then generate its silhouette. 

It’s a simple yet very clever hack, and if you pay close attention in the video below, you can see the lights scanning from the bottom to top before the image is produced.

Ordinary digital cameras work by using a large array of light sensors to capture light as it is reflected from an object. In this experiment, I wanted to see whether I could build a backwards camera: instead of having an array of light sensors, I have just a single sensor; but I control each of 1,024 individual light sources in a 32 x 32 LED matrix.

The way it works is that the Arduino illuminates one LED at a time, while using the analog input to monitor changes in the light sensor. This allows the Arduino to test whether the sensor can “see” a particular LED. This process is repeated for each of the 1,024 individual LEDs rapidly to generate a map of visible pixels.

If an object is placed between the LED matrix and the sensor, the Arduino is able to capture the silhouette of that object, which is lit up as a “shadow” once the capture is complete.

Arduino Blog 01 May 18:55

Making an LED matrix out of glue sticks

Glue sticks are great for attaching electronics and other bits to projects, but as Jon Bumstead shows in his latest work, they can also make pretty cool light diffusers. 

His project takes the form of a wooden box with plexiglass panels, allowing observers to see 64 vertical illuminated glue sticks inside. Hidden within the cube are 128 WS2811 LED modules, melted into the top and bottom of each stick. 

Everything is built around an Arduino Nano, using only a pair of its outputs to control each LED. User interface is provided by a button and knob to adjust speed, color, and patterns.

In this project, I created a “fiber optic” LED matrix using WS2801 LED strip and glue sticks. The light displays have a different look than similar LED cubes and a few advantages. First, you can’t see the actual LEDs in the display because the glue sticks guide the light away from the LEDs. Second, the device requires much fewer LEDs to make up the volume. Because the top and bottom have different LED strips, the fiber optic cables can take on two different colors that mix in the center. There are tons of different color displays that can be achieved with the device. I also added a button and knob for controlling the speed, color, and type of light display.

Petduino Is the DIY Tamagotchi You Can Hack

The Tamagotchi is a thing of the past. Bring your virtual pet into the 21st century with LEDs and an Arduino-compatible processor.

Read more on MAKE

The post Petduino Is the DIY Tamagotchi You Can Hack appeared first on Make: DIY Projects, How-Tos, Electronics, Crafts and Ideas for Makers.

New Project: LED Matrix Dessert Tray

Everyone loves dessert, but what if they could light up and play animations? I'll show you how to make a dessert tray with a built-in LED matrix.

Read more on MAKE

The post LED Matrix Dessert Tray appeared first on Make: DIY Projects, How-Tos, Electronics, Crafts and Ideas for Makers.

Prototype 14-segment-display shield

There are many ways (*) to drive the 6-digit 14-segment common cathode display from Seeed Studio.
This time I chose to multiplex two MAX7221, a method described here (but used to drive a bi-color 8x8 LED matrix).


The code is based on LedControl library, which I extended to cover the definition and display of 14-segment characters (digits, upper case letters, and a few specials). Below is a relevant fragment of the code I added:

/*
* Segment names in the 14-segment (plus DP) display:
*
*     -     A
*   |\|/|   F,I,J,K,B
*    - -    G,H
*   |/|\|   E,N,M,L,C
*     -  .  D,P
*/
// my wiring:
//            GFEDCBAx
// 1st byte: B11111111
//
//            NHJIKMLP
// 2nd byte: B11111111

const static byte charTable14Seg[43][2] = {
    {B01111110,B10001000},  // 0
    {B00001100,B00001000},  // 1
    {B10110110,B01000000},  // 2
    {B00011110,B01000000},  // 3
    {B11001100,B01000000},  // 4
    {B11010010,B00000010},  // 5
    {B11111010,B01000000},  // 6
    {B00000010,B00001100},  // 7
    {B11111110,B01000000},  // 8
    {B11011110,B01000000},  // 9
    {B00000000,B01000000},  // :
    {B00000000,B01000000},  // ;
    {B00000000,B01000000},  // <
    {B00000000,B01000000},  // =
    {B00000000,B01000000},  // >
    {B00000000,B01000000},  // ?
    {B00000000,B01000000},  // @
    {B11101110,B01000000},  // A
    {B00011110,B01100100},  // B
    {B01110010,B00000000},  // C
    {B00011110,B00100100},  // D
    {B11110010,B01000000},  // E
    {B11100010,B01000000},  // F
    {B01111010,B01000000},  // G
    {B11101100,B01000000},  // H
    {B00000000,B00100100},  // I
    {B00111100,B00000000},  // J
    {B11100000,B00001010},  // K
    {B01110000,B00000000},  // L
    {B01101100,B00011000},  // M
    {B01101100,B000100L0},  // N
    {B01111110,B00000000},  // 0
    {B11100110,B01000000},  // P
    {B01111110,B00000010},  // Q
    {B11100110,B01000010},  // R
    {B11011010,B01000000},  // S
    {B00000010,B00100100},  // T
    {B01111100,B00000000},  // U
    {B01100000,B10001000},  // V
    {B01101100,B10000010},  // W
    {B00000000,B10011010},  // X
    {B00000000,B00011100},  // Y
    {B00010010,B10001000},  // Z
};
...
void setChar14Seg(byte pos, byte ascii)
{
  if (pos>7)
    return;

  if (ascii>90 || ascii<48)
    return;

  byte index = ascii - 48;
  for(byte seg=0; seg < 8; seg++)
  {
    SetLed(SEG_AG, pos, seg, charTable14Seg[index][0] & 1 << seg);
    SetLed(SEG_GN, pos, seg, charTable14Seg[index][1] & 1 << seg);
  }
}

This method (hardware and software) can be used for up to 8 14/16-segment displays.


(*) Should be the topic of a future post.


An Introduction To Individually Addressable LED Matrices

The most fascinating project you can build is something with a bunch of blinky hypnotic LEDs, and the easiest way to build this is with a bunch of individually addressable RGB LEDs. [Ole] has a great introduction to driving RGB LED matrices using only five data pins on a microcontroller.

The one thing that is most often forgotten in a project involving gigantic matrices of RGB LEDs is how to mount them. The enclosure for these LEDs should probably be light and non-conductive. If you’re really clever, each individual LED should be in a light-proof box with a translucent cover on it. [Ole] isn’t doing that here; this matrix is just a bit of wood with some WS2812s glued down to it.

To drive the LEDs, [Ole] is using an Arduino. Even though the WS2812s are individually addressable and only one data pin is needed, [Ole] is using five individual data lines for this matrix. It works okay, and the entire setup can be changed at some point in the future. It’s still a great introduction to individually addressable LED matrices.

If you’d like to see what can be done with a whole bunch of individually addressable LEDs, here’s the FLED that will probably be at our LA meetup in two weeks. There are some crazy engineering challenges and several pounds of solder in the FLED. For the writeup on that, here you go.


Filed under: Arduino Hacks, led hacks
Hack a Day 27 Apr 06:00

Kill Time Making Flappy Bird, Not Playing It

With all the Flappy Bird clones floating around in the ether after the game’s unexpected success, there are some that are better than others. And by better, we mean, hacked together from misc hardware. If you’ve got an Arduino on hand, then you’re half way to making your own:

The “Minimalist” Version

[aron.bordin] created his own Flappy Bird game with a short list of parts some of us likely have lying around on our bench. An Arduino loaded with the appropriate code is wired to a 16×16 LED matrix, which apparently displays the minimal amount of visual information you’d need to play the game. The only other parts required are a single pushbutton and resistor tethered on a breadboard to control your flapping. With the wire hookup laid out by convenient diagrams and the libraries required for the code all found on the same page, this is easily something one could bang out in an afternoon. If afterwards you still find yourself with more time to kill than you can stand to play Flappy Birds, there is always the option of fashioning a humorously-sized cell phone case to squeeze it all into… which we’d like to see.

The “Fancy” Version

If you want more resolution than solid colored LEDs, or you just have a fondness for the terrifying bird abstraction the game is known for, you can switch out the 16×16 matrix for a Nokia LCD screen. [Huy’s] rendition of this build over on Hackaday.io will deliver a “more detailed” graphic for the game, and is still roughly just as easy to assemble. Similarly, an Ardunio is loaded with the smarts required to generate the game, along with a single pushbutton tacked on for control. The code and the daunting (/sarcasm) two steps needed to wire the Arduino to the screen can be found on his project’s page.

If you must kill boredom playing Flappy Bird, there is no excuse not to do so on something you made yourself.


Filed under: Arduino Hacks