The build relies on the classic Arduino Uno microcontroller, which talks to a HC-SR04 ultrasonic sensor module and two infrared sensors in order to track a human target and follow it around. Drive is thanks to four DC gear motors, driven by a L293D motor driver, with a two-cell lithium battery providing power for everything onboard.
The robot works in a simple manner, following a hand placed in front of the robot’s sensors. First, the robot checks for the presence of an object in front using the ultrasonic sensor. If something is detected, the twin infrared sensors mounted left and right are used to guide the robot, following the hand.
It’s not a sophisticated algorithm, and it won’t really let your robot follow you down a crowded street. However, it’s a great project to learn on for beginners and could serve as a great entry into more advanced projects using face tracking or other techniques. Video after the break.
Are you completely over the idea of the keyboard in any flattish form and looking for something completely different for inputting your data? Or do you want a mega macropad for 3D design, GIMP or Inkscape work, or to use while relaxing with a nice first-person shooter? Then this ergonomic, double-fistable keyboard/controller mashup named CAT may be what you’re looking for.
Inside each of these slinky felines is pretty much what you’d expect to find — 25 or so switches and an Arduino Pro Micro. Interestingly enough, the switches are all lever-action and not push buttons. There are two breeds of CAT available to build or buy: one has 25 buttons, and the other has a joystick or trackball on the thumb between two upper and two lower buttons. You could have one type for each hand!
More information is available on the Lynx Workshop site, which is where you’ll also find tutorials and instructions for everything from the 3D printing to the electronics to the assembly and coding. There is even a bonus 3D modeling tutorial. Don’t want to invest the time to make your own CAT? These kitties are also available for pre-order. Claw past the break to check them out in action.
Every time one of us flashes an Arduino’s internal memory, a nagging thought in the backs of our minds reminds us that, although everything in life is impermanent, nonvolatile re-writable memory is even more temporary. With a fixed number of writes until any EEPROM module fails, are we wasting writes every time we upload code with a mistake? The short answer is that most of us shouldn’t really be concerned with this unless we do what [AnotherMaker] has done and continually write data until the memory in an Arduino finally fails.
The software for this is fairly simple. He simply writes the first 256 ints with all zeros, reads them to make sure they are all there, and then repeats the process with ones. After iterating this for literally millions of times continuously over the course of about a month he was finally able to get his first read failure. Further writes past this point only accelerated the demise of the memory module. With this method he was able to get nearly three million writes before the device failed, which is far beyond the tens or hundreds of thousands typically estimated for a device of this type.
To prove this wasn’t an outlier, [AnotherMaker] repeated the test, and did a few others while writing to a much smaller amount of memory. With this he was able to push the number of cycles to over five million. Assuming the Arduino Nano clone isn’t using an amazingly high-quality EEPROM we can safely assume that most of us have nothing to worry about and our Arduinos will be functional for decades to come. Unless a bad Windows driver accidentally bricks your device.
Building a clock from parts is a right of passage for makers, and often represents a sensible introduction into the world of electronics. It’s also hard to beat the warm glow of Nixie tubes in a desktop clock, as [Joshua Coleman] discovered when building a Nixie tube clock for a friend.
The original decision to upcycle the chassis from an unrepairable Heathkit function generator came a little undone after some misaligned cutting, so the front panel ended up being redesigned and 3D printed. This ended up being serendipitous, as the redesigned front panel allowed the Nixie tubes to be inset within the metal chassis. This effect looks great, and it also better protects the tubes from impact damage.
Sourcing clones of the 74141 Nixie driver ICs ended up being easier than anticipated, and the rest of the electronics came together quickly. The decoders are driven by an Arduino, and the IN-4 Nixie tubes are powered by a bespoke 170 volt DC power supply.
Unfortunately four of the tubes were damaged during installation, however replacements were readily available online. The gorgeous IN-4 Nixie tube has a reputation for breaking easily, but is priced accordingly on auction sites and relatively easy to source.
The build video after the break should get any aspiring Nixie clock makers started, but the video description is also full of extra information and links for those needing help getting started.
We’re not short on clock hacks here at Hackaday, so why not check out a couple more? This retro-inspired LED clock looks like its right out of a parallel universe, or maybe this stunning Nixie clock driven by relays will strike your fancy.
From the smallest 60% keyboards for those with no desk space to keyboards with number pads for those doing data entry all day, there’s a keyboard size and shape for just about everyone. The only problem, even with the largest keyboards, is that they’re still fairly limited in what they can do. If you find yourself wishing for even more functionality, you might want to build something like this custom macro keyboard with built-in LED backlighting.
Rather than go with a standard mechanical keyboard switch like a Cherry MX, this build is based around TS26-2 pushbuttons with built-in LED lighting. [atkaper] only really needed one button for managing the mute button on MS Teams, but still built a total of eight switches into this keyboard which can all be individually programmed with different functions. The controller is an Arduino Leonardo and the enclosure was 3D printed.
Paired with the classic IBM Model M keyboard, this new macro keyboard adds plenty of functionality while also having control over LED backlighting. Macro keyboards are incredibly useful, especially with their ability to easily change function with control over the software that runs on them. The key to most builds is the 32U4 chip found in some Atmel microcontrollers which allows it to easily pass keyboard (and mouse) functionality to any computer its plugged in to.
From the smallest 60% keyboards for those with no desk space to keyboards with number pads for those doing data entry all day, there’s a keyboard size and shape for just about everyone. The only problem, even with the largest keyboards, is that they’re still fairly limited in what they can do. If you find yourself wishing for even more functionality, you might want to build something like this custom macro keyboard with built-in LED backlighting.
Rather than go with a standard mechanical keyboard switch like a Cherry MX, this build is based around TS26-2 pushbuttons with built-in LED lighting. [atkaper] only really needed one button for managing the mute button on MS Teams, but still built a total of eight switches into this keyboard which can all be individually programmed with different functions. The controller is an Arduino Leonardo and the enclosure was 3D printed.
Paired with the classic IBM Model M keyboard, this new macro keyboard adds plenty of functionality while also having control over LED backlighting. Macro keyboards are incredibly useful, especially with their ability to easily change function with control over the software that runs on them. The key to most builds is the 32U4 chip found in some Atmel microcontrollers which allows it to easily pass keyboard (and mouse) functionality to any computer its plugged in to.
We enjoy access to cheap stuff because of the mass market for things like mice, keyboards, and cell phones. But if you need a device that doesn’t have mass appeal, you will have to pay a lot more if you can find it at all. However, with modern techniques like 3D printing and Arduino-like microcontrollers being cheap and simple to use, you now have the option to build that special one-of-a-kind device. Case in point: [Davy’s] mouse for people who have brain or nervous system disorders. This particular device is helping a 6-year-old who can’t manipulate a normal mouse.
The device uses an Arduino Pro and an MPU-6050 accelerometer and gyroscope. The original design uses machined aluminum, but 3D printing should work, too. There’s something wrong with the link to the design files in the post, but it is easy to find the correct link.
There are, of course, many ways you could make this work, and besides, every special user will be a little different. But what a great feeling to help someone be able to do what most people take for granted.
This is a rewrite of a project I created in 2010 which brought me a lot of joy, so I hope you enjoy it too.Please read the entire article before starting your own. You can still make it today, the parts are easily available.
I’ve always enjoyed making Arduino-powered clocks, however over time they tended to become increasingly complex. So to counter this, allow me to introduce you to “Blinky” the one-eyed clock:
It reminds me of the giant killer orb “Rover” from “The Prisoner“… Using a minimal Arduino bootrom system, a DS1307 real time clock IC and an RGB diffused LED, you can make a clock that blinks the time, using the colours of the LED to note different numerical values.
For example, if the time is 12:45, the clock will blink red 12 times, then show blue for a second (think of this as the colon on a digital clock) then blink four times in green (for forty minutes), then blink three times in red for the individual minutes.
If there is a zero, blink blue quickly. Then the clock will not display anything for around forty seconds, then repeat the process. Here he (she, it?) is blinking the time:
Setting the clock is simple. It is set to start at 12:00 upon power up. So for the first use you have to wait until about five seconds before midday or midnight, then power it up. To save cost it doesn’t use a backup lithium battery on the real-time clock IC, but you could add one if required. So let’s get started.
The first thing to do was test the RGB LED for brightness levels, so I just connected it to the digital output pins of my Arduino-compatible board via suitable current-limiting resistors. Red, green and blue to D9, D10 and D11 respectively. Each LED is going to be different, so to ensure maximum brightness without causing any damage you need to calculate the appropriate resistor values.
This is quite easy, the formula is: resistor (ohms) = voltage drop / LED current So if you have a 5V supply, and LED that needs only 2 volts, and draws 20 milliamps (0.2 amps) , the calculation will be: resistor = (5-2)/0.02 = 150 ohms. To be safe I used 180 ohm resistors. The LED was tested with this simple sketch:
/*
blinky LED test
*/
int red = 2;
int green = 3;
int blue = 4;
int d = 300;
void setup()
{
pinMode(red, OUTPUT);
pinMode(green, OUTPUT);
pinMode(blue, OUTPUT);
}
void loop()
{
digitalWrite(red, HIGH);
delay(d);
digitalWrite(red, LOW);
delay(d);
digitalWrite(green, HIGH);
delay(d);
digitalWrite(green, LOW);
delay(d);
digitalWrite(blue, HIGH);
delay(d);
digitalWrite(blue, LOW);
delay(d);
}
It was interesting to alter the value of d, the delay variable, to get an idea for an appropriate blinking speed. Originally the plan was to have the LED in a photo frame, but it was decided to mount a ping-pong ball over the LED for a retro-style look. Here is a short video of the result of the test:
If you are going to use a ping-pong ball, please be careful when cutting into it with a knife, initially it may require a lot of force, but once the knife cuts through it does so very quickly.
Now it was time to develop the sketch to convert time into blinks. The sketch itself is quite simple. Read the hours and minutes from the DS1307 timer IC; convert the hours to 12 hour time; then blink an LED for the number of hours, display another colour for the colon; divide the minutes by ten and blink that in another colour; then the modulus of minutes and ten to find the individual minutes, and blink those out. Here is the first test sketch:
/*
"blinky" the one-eyed clock
Version beta 1
John Boxall August 2010/6th April 2022 - http://tronixstuff.com
DS1307/i2c timekeeping based on code by Maurice Ribble 17-4-2008 - http://www.glacialwanderer.com/hobbyrobotics
*/
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
int red = 9; // LEDs connected to these pins as you might want to PWM them to alter brightness
int green = 10;
int blue = 11;
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
return ( (val / 10 * 16) + (val % 10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
return ( (val / 16 * 10) + (val % 16) );
}
void setDateDs1307(byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-28/29/30/31
byte month, // 1-12
byte year) // 0-99
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.write(decToBcd(second)); // 0 to bit 7 starts the clock
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour));
Wire.write(decToBcd(dayOfWeek));
Wire.write(decToBcd(dayOfMonth));
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave
Wire.endTransmission();
}
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Reset the register pointer
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
*second = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() & 0x3f); // Need to change this if 12 hour am/pm
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}
void blinkLED(int colour, int ondelay, int offdelay, int blinks)
// blinks LED on pin 'colour' for 'blinks' times with on and off delay of 'ondelay', 'offdelay'
// colour: 9 is red, 10 is green, 11 is blue
{
for (int a = 0; a < blinks; a++) {
digitalWrite(colour, HIGH); delay(ondelay); digitalWrite(colour, LOW); delay(offdelay);
}
}
void blinkTime() // blinks the time
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
float aa;
int bb;
getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
// convert hours from 24 to 12 hour time
if (hour == 0)
{
hour = 12;
}
if (hour > 12)
{
hour = hour - 12;
}
blinkLED(9, 500, 500, hour); // blink hours in red
blinkLED(11, 1000, 500, 1); // show blue for one second
aa = minute;
aa = aa / 10;
bb = int(aa); // find the value of tens of minutes (0~5)
if (bb > 0)
{
blinkLED(10, 500, 500, bb); // blink tens of minutes
}
if (bb == 0) // but if the time is something like 03:02?
{
blinkLED(11, 200, 200, 1); // blink blue quickly for zero
}
aa = minute % 10; // find modulo of minutes to get single minutes
if (bb > 0)
{
blinkLED(9, 500, 500, bb);
}
if (bb == 0)
{
blinkLED(11, 200, 200, 1); // blink blue quickly for zero
}
}
void setup()
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.begin();
second = 0;
minute = 17;
hour = 4;
dayOfWeek = 6; // these values are moot, but need to store something
dayOfMonth = 28;
month = 5;
year = 10;
setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
pinMode(red, OUTPUT);
pinMode(green, OUTPUT);
pinMode(blue, OUTPUT);
}
void loop()
{
blinkTime();
delay(5000);
}
Finally, the code was tested using the Arduino-compatible board and my home-made DS1307 real time clock shield (hey it was 2010, DS32xx were expensive). It is best to use existing hardware while testing, before committing to purchasing new hardware and so on. So here it is on the breadboard:
Here is the prototype in action:
If you’re wondering why the videos are potato-cam quality, smartphones couldn’t record using 4K Ultra HD in 2010.
But perhaps the first version was a little bland. By using analogWrite() we can control the brightness of the LED segments. So I’ve added two more functions, whiteGlow() and blueGlow(); whose purpose is to make the display “glow” by increasing then decreasing the brightness.
And I’ve scaled back the amount of blinking, to make blinky less obvious. So now the display will glow white to announce the forthcoming display of time, wait a second, blink the time (with a blue glowing colon) then stay dark for ten seconds before repeating the process. Here is a quick demonstration of this display style:
Here is the sketch for the above demonstration, and the final one I will use with the hardware prototype:
/*
"blinky" the one-eyed clock - Version 2.1
John Boxall 04 August 2010/6th April 2022
IDGAF licence
DS1307/i2c timekeeping based on code by Maurice Ribble
17-4-2008 - http://www.glacialwanderer.com/hobbyrobotics
*/
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
int red = 9; // LEDs connected to these pins as you might want to PWM them to alter brightness
int green = 10;
int blue = 11;
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
return ( (val / 10 * 16) + (val % 10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
return ( (val / 16 * 10) + (val % 16) );
}
void setDateDs1307(byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-28/29/30/31
byte month, // 1-12
byte year) // 0-99
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.write(decToBcd(second)); // 0 to bit 7 starts the clock
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour));
Wire.write(decToBcd(dayOfWeek));
Wire.write(decToBcd(dayOfMonth));
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave
Wire.endTransmission();
}
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Reset the register pointer
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
*second = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() & 0x3f); // Need to change this if 12 hour am/pm
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}
void blinkLED(int colour, int ondelay, int offdelay, int blinks)
// blinks LED on pin 'colour' for 'blinks' times with on and off delay of 'ondelay', 'offdelay'
// colour: 9 is red, 10 is green, 11 is blue
{
for (int a = 0; a < blinks; a++)
{
digitalWrite(colour, HIGH);
delay(ondelay);
digitalWrite(colour, LOW);
delay(offdelay);
}
}
void blinkTime()
// blinks the time
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
float aa;
int bb;
getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
// convert hours from 24 to 12 hour time
if (hour == 0)
{
hour = 12;
}
if (hour > 12)
{
hour = hour - 12;
}
blinkLED(9, 500, 500, hour); // blink hours in red
blueGlow(1, 10);
aa = minute;
aa = aa / 10;
bb = int(aa); // find the value of tens of minutes (0~5)
if (bb > 0)
{
blinkLED(10, 500, 500, bb); // blink tens of minutes
}
if (bb == 0) // but if the time is something like 03:02?
{
blinkLED(11, 200, 200, 1); // blink blue quickly for zero
}
aa = minute % 10; // find modulo of minutes to get single minutes
bb = aa;
if (bb > 0)
{
blinkLED(9, 500, 500, bb); // blink tens of minutes
}
if (bb == 0)
{
blinkLED(11, 200, 200, 1); // blink blue quickly for zero
}
}
void whiteGlow(int n, int d)
{
for (int nn = 0; nn < n; nn++)
{
for (int a = 0; a <= 255; a++)
{
analogWrite(red, a);
analogWrite(green, a);
analogWrite(blue, a);
delay(d);
}
for (int a = 255; a >= 0; --a)
{
analogWrite(red, a);
analogWrite(green, a);
analogWrite(blue, a);
delay(d);
}
}
}
void blueGlow(int n, int d)
{
for (int nn = 0; nn < n; nn++)
{
for (int a = 0; a <= 255; a++)
{
analogWrite(blue, a);
delay(d);
}
for (int a = 255; a >= 0; --a)
{
analogWrite(blue, a);
delay(d);
}
}
}
void setup()
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.begin();
second = 0;
minute = 17;
hour = 4;
dayOfWeek = 6; // these values are moot, but need to store something
dayOfMonth = 28;
month = 5;
year = 10;
setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year); // every time blinky has new batteries, it will start from midnight/midday
pinMode(red, OUTPUT);
pinMode(green, OUTPUT);
pinMode(blue, OUTPUT);
}
void loop()
{
whiteGlow(1, 10); // glow white - announces that the time will now be shown
delay(1000); // give people a second to focus on blinky
blinkTime();
delay(50000); // wait 50 seconds
}
Once happy with the sketch, I put a fresh ATmega328P-PU with Arduino bootloader in the board and programmed it with the sketch, to be used in the final version. The next step is to build my own hardware. The last hardware unknown is the amount of current the circuit draws. Once I know this the correct voltage regulator and power supply can be decided upon.
I had a fair idea it would be less than 100 milliamps, so I put a 6V battery onto supply duty via a 78L05 5V regulator (data sheet), and recorded the result:
So it varies, between 20.5 and 46 mA. As it only reaches 46 mA for a short time, we could consider the constant draw to be averaged out at 30 mA. I really want this to be able to run from a battery, but without having an external lead-acid battery lurking around, it will need a plug-pack with an output voltage greater than 7V DC.
Another alternative would be to run it from a USB socket, a nice source of 5V. If doing so, there wouldn’t be a need for the 78L05 regulator. Which brings us to the circuit diagram, which includes the power regulator. I’ve also altered the resistors to suit the RGB LED used, your values may be different:
And since it’s 2022, not 2010 – I’ve replaced the DS1307 circuit with a RTC module. Y1 is a three pin 16MHz ceramic resonator, we used those in 2010 as they were cheaper and easier than a crystal and two 22pF capacitors.
The circuit does not allow for uploading code, so you will need to program the microcontroller on another Arduino or compatible board, then transfer it to the blinky circuit board as described above. At this stage you should test it again – but using a solderless breadboard. In doing so you can make final hardware checks, and generally make sure everything works as it should. This is also a good stage to double-check you are happy with the display behaviour, default time and so on.
Used the Duemilanove as a lazy 5V for testing.
Time to solder up the circuit on some stripboard. Blank stripboard varies, but luckily I found this and a nice box to hold it in:
Stripboard does vary between retailers and so on, so you will need to work out the layout with your own board. In doing so, please double-check your work – follow the layout against the schematic and so on.
Have a break, then check it again. There is nothing worse than soldering away to realise you are one strip too far over or something. My hand-eye coordination is not the best, therefore my soldering isn’t pretty, but it works:
Note that the images above are using the 2010 circuit – which had a DS1307 sub-circuit.
One would say that there is a good argument for making your own PCBs… and I would agree with that. In 2010 it wasn’t that easy or inexpensive. Now you have KiCAD and Chinese PCB fabs tripping over themselves to give you cheap boards.
The LED is soldered to some short leads to give it a bit of play, and some heatshrink over the legs to keep them isolated:
And finally, to add a DC socket to feed blinky some power:
The last thing was to check the soldering once more under natural light, to check for bridges or shorts, then have a cup of tea. Upon my return I drilled out a hole in the enclosure lid for the LED, and one one the side for the DC socket, and fitted the lot together… and success! It worked.
I hope you enjoyed making this or at least reading about it. If you find this sort of thing interesting, please consider ordering one or both of my books from No Starch Press, or other book sellers:
[Hal Rodriguez] and [Sahrye Cohen] of Amped Atelier focus on creating interactive wearable garments with some fairly high standards. Every garment must be pretty, and has to either be controllable by the wearer, through a set of sensors, or even by the audience via Bluetooth. Among their past creations are a dress with color sensors and 3D-printed scales on the front that change color, and a flowing pantsuit designed for a dancer using an accelerometer to make light patterns based on her movements.
Conductive Melody — a wearable musical instrument that is the focus of [Sahrye] and [Hal]’s Remoticon 2021 talk — was created for a presentation at Beakerhead Festival, a multi-day STEAM-based gathering in Calgary. [Sahrye] and [Hal] truly joined forces for this one, because [Sahrye] is all about electronics and costuming, and [Hal] is into synths and electronic music. You can see the demo in the video after the break.
The dress’s form is inspired by classical instruments and the types of clothing that they in turn inspired, such as long, generous sleeves for harp players and pianists. So [Hal] and [Sahrye] dreamed up a dress with a single large playable sleeve that hangs down from the mid- and upper arm. The sleeve is covered with laser-cut conductive fabric curlicues that look like a baroque interpretation of harp strings. Play a note by touching one of these traces, and the lights on the front of the dress will move in sync with the music.
[Sahrye] started the dress portion of Conductive Melody with a sketch of the garment’s broad strokes, then painted a more final drawing with lots of detail. Then she made a muslin, which is kind of the breadboard version of a project in garment-making where thin cotton fabric is used to help visualize the end result. Once satisfied with the fit, [Sahrye] then made the final dress out of good fabric. And we mean really good fabric — silk, in this case. Because as [Sahrye] says, if you’re going to make a one-off, why not make as nicely as possible? We can totally get behind that.
[Sahrye] says she is always thinking about how a wearable will be worn, and how it will be washed or otherwise cared for. That sequined and semi-sheer section of the bodice hides the LEDs and their wiring quite well, while still being comfortable for the wearer.
Inside the sleeve is an MPRP121 capacitive touch sensor and an Arduino that controls the LEDs and sends the signals to a Raspberry Pi hidden among the ruffles in the back of the dress.
The Pi is running Piano Genie, which can turn eight inputs into an 88-key piano in real time. When no one is playing the sleeve, the lights have a standby mode of mellow yellows and whites that fade in and out slowly compared to the more upbeat rainbow of musical mode.
We love to see wearable projects — especially such fancy creations! — but we know how finicky they can be. Among the lessons learned by [Sahrye] and [Hal]: don’t make your conductive fabric traces too thin, and silver conductive materials may tarnish irreparably. We just hope they didn’t have to waste too much conductive fabric or that nice blue silk to find this out.
The classic arcade game Cyclone has attracted many players, along with their coins, thanks to its simple yet addictive gameplay. In its most basic form it consists of a light racing around a circular track, which the player then has to stop at exactly the right place. Arduino enthusiast [mircemk] made a home version of this game, which allows addicts to keep playing forever without running out of quarters.
Instead of an arcade cabinet, this smaller version has an upright 3D-printed ring that holds 60 WS2812 LEDs. A further six in the center of the ring act as a score counter. An Arduino in the base drives the LEDs and runs the game, which is based on an earlier iteration built by [oKeeg]. An interesting addition is a large homemade “arcade button”, which is large and sturdy enough to withstand any abuse inflicted on it by a frustrated player.
Retro-style sound effects and flashing light sequences give the game a bit of an arcade vibe, even without a big cabinet and piles of coins. Simple LED games like this are always great eye-catchers in any home or office; if you like this one, be sure to check out other LED games like the handheld LEDBOY, the one-dimensional dungeon crawler TWANG, and this LED racing game.
