Posts with «led» label

Dad Scores Big with DIY Indoor Hockey Game

We suppose it’s a bit early to call it just yet, but we definitely have a solid contender for Father of the Year. [DIY_Maxwell] made a light-up hockey game for his young son that looks like fun for all ages. Whenever the puck is hit with the accompanying DIY hockey stick (or anything else), it lights up and produces different sounds based on its acceleration.

Inside the printed puck is an Arduino Nano running an MPU6050 accelerometer, a 12-NeoPixel ring, and a piezo buzzer. [DIY_Maxell] reused a power bank charging circuit to charge up the small LiPo battery.

The original circuit used a pair of coin cells, but the Arduino was randomly freezing up, probably because of the LEDs’ current draw. Be sure to check out the video after the break, which begins with a little stop motion and features a solder stand in the shape of a 3D printer.

Got a house full of carpet or breakables? You could always build an air hockey table instead.

Tiny Circuit Sculpture Keeps the Night Watch

If you’re planning to get into circuit sculpture one of these days, it would probably be best to start with something small and simple, instead of trying to make a crazy light-up spaceship or something with a lot of curves on the first go. A small form factor doesn’t necessarily mean it can’t also be useful. Why not start by making a small automatic night light?

The circuit itself is quite simple, especially because it uses an Arduino. You could accomplish the same thing with a 555, but that’s going to complicate the circuit sculpture part of things a bit. As long as the ambient light level coming in from the light-dependent resistor is low enough, then the two LEDs will be lit.

We love the frosted acrylic panels that [akshar1101] connected together with what looks like right angle header pins. If you wanted to expose the electronics, localize the light diffusion with a little acrylic cover that slips over the LEDs. Check it out in the demo after the break.

There’s more than one way to build a glowing cuboid night light. The Rubik’s way, for instance.

RGB Kitchen Uses Pots to Stir Up Color

Anyone who has done anything with RGB LEDs knows that their ability to display pretty much any color is somehow both the best and worst thing about them. How do you get it right? How do you make your results repeatable? [Thomas] has the answer. He dug around in the ol’ parts cupboard, found a few pots, and got to work making this stay-home stew of a project — an on-demand RGB LED color mixer.

Three cleverly color-coded potentiometers and an Arduino let [Thomas] step through 0-255 to mix various values of red, blue, and green. The shade that gets made is displayed live on a set of 10 individual NeoPixels that are laid out under a frosty diffusing panel. Each of the RGB values are also shown on an 16×2 LCD.

This is one of those projects that hits a sweet spot of being simple, useful, and fun. It’s even nice-looking and compact. What more could you want from a project cobbled together from ingredients on hand? [Thomas] is even giving away the code recipe.

Once you dial in your ideal colors, why not make a gesture-controlled lamp?

NeoPixel Matrix Simulation Lets You Virtually Groove to the Lights

You are stuck at home quarantined and you want to do some Arduino projects. The problem is you don’t have all the cool devices you want to use. Sure, you can order them, but the stores are slow shipping things that aren’t essential these days. If you want to get a headstart while you are waiting for the postman, check out Wokwi’s Playground. For example, you can write code to drive a virtual NeoPixel 16×16 matrix. There’s even example code to get you started.

There are quite a few other choices in the playground including Charlieplexed LEDs, a keypad, and an LCD. There are also challenges. For example, in the traffic light challenge, you are given code that uses a task scheduler library to implement a traffic light. You have to add a turn signal to the code.

In addition to LEDs in various configurations, the site has some serial bus components, an LCD, a keypad, and a NeoPixel strip. There are also a few tools including an EasyEDA to KiCad converter and a way to share sourcecode similar to Pastebin.

Of course, simulations only get you so far, but the site is a fun way to play with some different I/O devices. It would be very nice if you could compose for the different components together, but you could work your code in sections, if necessary. You can do similar things with TinkerCad circuits. If you want to install software, there’s a simulator for you, too.

Hack a Day 04 Apr 21:00

Handwashing Timer Makes Sure the Suds Stay On Long Enough

“Twinkle, Twinkle, Little Star”? How we wonder why you’d resort to singing a ditty to time your handwashing when you can use your social isolation time to build a touch-free electronic handwash timer that the kids — and you — might actually use.

Over the last few months, pretty much everyone on the planet has been thrust into strange, new, and oftentimes scary practices to limit the spread of the SARS-CoV-2virus and the disease it causes, COVID-19. Judging by the number of people we’ve seen leaving public restrooms without a visit to the washbasin before the outbreak began — and sadly all too often since — we collectively have a lot of work to do in tightening up our handwashing regimens. Time on target and plenty of friction are the keys to that, and [Denis Hennessy]’s “WashTimer” aims to at least help you out with the former. His build is as simple as can be: an Arduino driving an LED matrix when a proximity sensor fires. Wave your dirty paws in front of the unit as you start to scrub up, and the display goes through a nicely animated 20-second countdown, at which time it’s safe to rinse off.

[Denis] purposely made this design as simple and as customizable as possible. Perhaps you’ve got a Neopixel ring lying about rather than the LED matrix, or maybe an ultrasonic sensor would work better for you. Be creative and take this design where it needs to go to suit your needs. We can’t stress enough that handwashing is your number one defense; if you don’t need to moisturize your hands at least three times a day, you’re probably not washing often or long enough. And 20 seconds is way longer than you think it is without a prompt.

Matrix and Joystick

For the original tutorial, please visit: https://arduinobasics.blogspot.com

 
 

Project Description

In this project, we will use a little joystick to move a pixel around an 8x8 LED matrix. The joystick has a built-in button, such that when you press down onto the joystick, the colour of the pixel will change from red to blue to green. This is a very simple project, however, controlling the matrix adds a certain level of complexity. You will need to understand binary notation and bit-shifting techniques to grasp the concept of this tutorial.

All of the parts used in this project can be obtained from digitspace.com

 
 
 
 

Libraries

The SPI library is required for this project. However, this library is built into the current version of the Arduino IDE. No additional download is required. Just make sure to include it at the top of the sketch.

 
 

Arduino Code

The Arduino IDE can be downloaded from the official Arduino website: here.
Copy and paste the following code into your Arduino IDE and upload it to the Arduino UNO.

 
 

Connections

 
 

Project Video

As you can see from the video above, the pixel changes colour when the button is pressed. The position of the pixel relates to the position of the joystick. The lag between the joystick movement and pixel movement is minimal, and very satisfying.

 
 

Conclusion

This was a very fun and satisfying project that showcases the interaction between a joystick and a 8x8 LED matrix with the help of an Arduino UNO. This project was sponsored by the kind people at digitspace. Without their sponsorship, this tutorial would not have been possible. Please visit their website for some nice deals on Arduino related products.

If you found this tutorial helpful, please consider supporting me by buying me a virtual coffee/beer.

$3.00 AUD only

Social Media

You can find me on various social networks:

Follow me on Twitter: ScottC @ArduinoBasics.
I can also be found on Instagram, Pinterest, and YouTube.
And if all else fails, I have a server on Discord.


ScottC 09 Mar 07:41
8x8  arduino  ce  clk  fun  joystick  led  matrix  module  mosi  pixel  programming  spi  sw  tutorial  uno  x  y  

Dinural Reef Control Realistically Insolates Your Aquarium

[Phillip]’s project is not just great for learning new words, it also shows just how complex natural systems can be. 

As we know from news around the word, reefs are delicate systems prone to damage from just about any imaginable threat. Escaped aquarium fish, sunscreen, and the wayward feet of well meaning tourists to name a few. So it’s no wonder that aquarium hobbyists sometimes go to incredible lengths to simulate the natural environments these creatures live in.

While [Phillip] is still tinkering with his designs for this project, we found the data he included really interesting. His goal is to be able to plug in any coordinate on the earth and have the lights replicate the location. That includes not just the sun, but also the light from the moon as many corals seem to only spawn during certain tides. Of course no LED is perfect so he’s even experimenting with putting light sensors under the water to provide a feedback loop to make it perfect.

We really like the ambition of this project and we hope he continues.

Hack a Day 04 Jan 06:00
arduino  coral  led  led hacks  light  reef  simulate  tide  

Create your own Arduino Library

Project Description

In this short tutorial I will show you how to create your own Arduino Library. Making your own library seems daunting at first, but I will show you that it is not much harder than writing your own script/sketch. I would advise that you comment you code clearly, because when you come back to it in 5 years time, it will help to navigate you through your code at this time in history. Here we go, let's go through the process of creating a very simple Arduino library.

Parts Required

  • Arduino UNO or compatible board

Project Steps

Before we begin, there are a few questions you must ask yourself:

  1. What will the library be called ?
  2. What will the library do ?
  3. What are you trying to simplify?

For our library, these are the answers to the questions above:

  1. BlinkMe
  2. It will blink an LED attached to one of the digital pins
  3. The aim is to reduce the blink commands to a single line

Create a Folder

Create a folder on your computer which will be used to house all of the files in this project. Name the folder the same name as the library. In this case we will name it "BlinkMe". Make sure you use consistent naming throughout the tutorial. Capital and lowercase letters do matter.

Create the files

Using any text based editor (eg. notepad++, PSPad, Notepad2 etc), you will need to create 3 blank files:

  • The C++ file (BlinkMe.cpp) : Library code containing all of the functions
  • The Header file (BlinkMe.h): Contains the library function declarations
  • keywords.txt : Used for syntax highlighting within the Arduino IDE

I will tell you what you need to write inside each of these files, but make sure you have the blank BlinkMe.cpp, BlinkMe.h and keywords.txt files inside of the BlinkMe folder. Some people start by creating the header file first, but I personally like to start with the CPP file.
We will now look to populate the BlinkMe C++ file:

The C++ file (.cpp)

This file will contain all of the functions in your new library.
The first thing you will need to do is include the Arduino.h file. This will drag in all of the relevant Arduino code necessary for your library to function with an Arduino. And while we haven't yet created the header file (BlinkMe.h), we need to import that also. So the first two lines should be:

#include <Arduino.h>
 #include <BlinkMe.h>

The next section of code is the "constructor". This will be responsible for constructing the BlinkMe object. The BlinkMe object will allow you to call any of the public functions within the BlinkMe library. The constructor will allow us to define the default variables or constants.

BlinkMe::BlinkMe(){
    _dPin = 13;
 }

Sometimes we will want to blink an LED on a different pin. So we will create a function to set the pin that we would like use.

void setOUTPUT(int dPin){
    _dPin = dPin;
    pinMode(_dPin, OUTPUT);
 }

The only thing left is to create the useful part of the code. We will create a simple function that will blink the LED for a set duration. The function will have a parameter, which will be used to set the blink duration.

void blink(unsigned long delay_1){
    _delay_1 = delay_1;
    digitalWrite(_dPin, HIGH);
    delay(_delay_1);
    digitalWrite(_dPin, LOW);
    delay(_delay_1);
 }

Here is the complete "BlinkMe.cpp" file:

The Header file (.h)

The header file will be used to create the library function declarations. Open the "BlinkMe.h" file.
The first step is to check to make sure that the library is NOT already defined:

#ifndef BlinkMe_h

If it is not defined, then we must define the library:

#define BlinkMe_h

We then need to provide access to the standard Arduino types and constants

#include "Arduino.h"

And finally create the BlinkMe class:

//Create the class BlinkMe
class BlinkMe{
    public:
        BlinkMe();
        void setOUTPUT(int dPin);
        void blink(unsigned long delay_1);
    private:
        int _dPin;
        unsigned long _delay_1;
 };
#endif

Here is the complete header file:

keywords.txt (optional)

The keywords.txt file will contain the keywords for the library which will allow appropriate syntax highlighting. This file is optional, however it will highlight your classes or functions based on the keyword mapping.

  • LITERAL1: specifies constants (eg. HIGH, LOW,
  • KEYWORD1: specifies classes (eg. Serial)
  • KEYWORD2: specifies methods and functions (eg. analogRead, digitalWrite, delay)
  • KEYWORD3: specifies structures (eg. if, while, loop)
You need to make sure you use a single tab between the keyword and the "KEYWORD" mapping. In our example, BlinkMe is a class, so that would be a KEYWORD1. On the other hand, "blink" is a function, so that would be a KEYWORD2. So the keywords.txt file will contain the following text:

BlinkMe     KEYWORD1
setOUTPUT   KEYWORD2
blink       KEYWORD2

Example Sketch (optional)

It is often useful to include an sketch that provides an example of the library in use. It provides some context. If you plan to include the sketch in your library, then you must follow these simple rules:

  1. Create an "examples" folder.
  2. Create an example sketch, an place it within a folder of the same name as the sketch
  3. Place the sketch folder inside of the examples folder
You will end up with something like: examples/example_sketch/example_sketch.ino
In our case it will be: examples/blinkTest/blinkTest.ino

Here is the example sketch for this library (Save as blinkTest.ino):


The library

Here is a picture of the library contents:

And now the only thing left is to zip up the library folder and import it into the Arduino IDE. Use whatever program you want to zip up the BlinkMe folder, and note the location of the zip file. You need to import the zip file into the Arduino IDE:

  • Arduino IDE > Sketch > Include Library > Add .ZIP Library...
  • Select the library zip file you just created, and select "Open".
  • You can now use your library in the Arduino IDE.
  • Test it by running your example sketch: File > Examples > BlinkMe > blinkTest

Download

You can download the entire library here:
BlinkMe Library

Conclusion

In this tutorial, I showed you how to create a simple Arduino library. If you would like so see another example, have a look at my ToggleTimer library, which is very useful when trying to blink an LED without using a delay.You don't have to limit yourself to LEDs, you can use it for other projects where delay gets in the way. ToggleTimer is a non-blocking timer that toggles between two states.


If you found this tutorial helpful, please consider supporting me by buying me a virtual coffee/beer.

$3.00 AUD only

Social Media

You can find me on various social networks:

Follow me on Twitter: ScottC @ArduinoBasics.
I can also be found on Instagram, Pinterest, and YouTube.
And if all else fails, I have a server on Discord.


ScottC 29 Dec 10:09
arduino  blink  diy  led  library  tutorial  

Optical Communication Using LEDs Alone

We’re all used to the humble LED as a ubiquitous source of light, but how many of us are aware that these components can also be used as photodiodes? It’s something [Giovanni Blu Mitolo] takes us through as he demonstrates a simple data link using just a pair of LEDs and a couple of Arduinos. It’s a showing off his PJON networking layer, and while you’d need a bit more than a couple of LEDs on breadboards for a real-world application, we still think it’s a neat demonstration.

PJON itself is very much worth a look, being an implementation of a robust and error-tolerant network for Arduinos and other small microcontroller platforms. It has a variety of communication strategies for various different media, and as this LED demonstration shows, its strength is that it’s capable of working through media that other networks would balk at. Whether it’s controlling home automation through metal heating ducts or providing an alternative to LoRa at 433 MHz, it’s definitely worth a second look. We’ve mentioned it before, but remain surprised that we haven’t seen it more often since. Take a look, the video is below the break.

Hack a Day 22 Dec 09:00

Interactive Core Memory Shield Helps Explains The Past

[Andy Geppert] sends in his incredibly clever interactive core memory shield. 

In a great display of one hacker’s work being the base for another’s, [Andy] started out with [Jussi Kilpelainen]’s core memory shield for Arduino.  As he was playing with the shield he had a desire to “see” the core memory flipping and got the idea to add an LED matrix aligned behind the individual cores.

The first iteration worked, but it only showed the state that the Arduino believed the core memory to be in. What he really wanted was a live read on the actual state. He realized that an Adafruit Featherwing 8×8 matrix display also fits behind the core memory. Now the LEDs update based on the read state of the core memory. This allows him to flip the individual bits with a magnetic stylus and see the result. Very cool.

You can see a video of it working after the break.