Ryan Bates has built a miniaturized vending machine from scratch using an Arduino Uno, four continuous rotation servos, and a Nokia 5110 LCD. The device, dubbed “Venduino,” includes four input buttons to make a selection, an LED indicator, and a 12V light strips to illuminate the inside of the cabinet. Whether it’s candies, toiletries, game cartridges, or miscellaneous items you’re looking to dispense, the possibilities are endless. Simply insert a coin, choose a product, and repeat.

Sound like something you’d like in your dorm room or cubicle? Bates has shared his code and schematics, and provided a detailed breakdown of his build below.

Anyone who has ever watched Ghostbusters is surely familiar with the iconic proton pack–the combination of a handheld wand and backpack-sized particle accelerator that’s the weapon of choice for weakening ghosts and aiding in capturing them. And with a remake of the ‘80s flick coming out in a few days, what better time for a DIY prop equipped with full-featured user control and Hollywood-like effects?

That’s exactly what John Fin has done using a bunch of household items, including a five gallon bucket for the cyclotron, a garlic powder container for the N-Filter, a hairbrush for the PKE meter, as well as spark plug wire, cardboard tubes, pill bottles, handles from power tool cases, and a couple electrical boxes and miscellaneous parts.

The proton pack is based on an Arduino Uno along with a Seeed Studio SD card shield containing .WAV files. The Arduino supplies all of the sound and light effects, except for the cyclotron lights which use a 555 timer and 4017 decade counter. The sound is amplified through an old computer speaker board, while two homemade boards control the lights.

The red lights on the cyclotron area are supposed to be asymmetrical. This project took two weekends to make, one for the pack and one for the gun. It is attached to a homemade  PVC “ALICE” frame. I tried to make it as light as possible, the whole unit weighs just 13 lbs. Its not fully “screen accurate” but more like a “Model 3″ version. The addition of a bunch of actual electronic components make it look more like it is a  functional unit instead of a prop.

The power meter on the gun and pack are synced to show an accumulating “charge” while a generator sound plays. When armed, the lights on the gun blink and the generator sound intensifies. When it’s fired, the barrel lights and the blast sound plays as the charge meter decreases to zero. It then shuts off and recharges.

As part of their final project at EDN – Navàs, robotics students Rafart Jordi and Marc Thomas recently built an impressive Arduino simulator that captures video from a camera-equipped RC vehicle and displays it on a TV screen, making it feel as though you’re in the driver’s seat of a shrunken-down car.

The simulator is driven by an Arduino Uno along with an IBT-2 H-Bridge to control the 24V motors, and wirelessly communicates with the modified toy car via an XBee module.

You have to see it in action below!

The Da Vinci system is one of the most popular surgical robots around, which allows surgeons to perform operations through only a few small incisions. The device works by translating a doctor’s hand movements into smaller, precise movements of tiny instruments inside the patient’s body. As ubiquitous as they may be in hospitals, chances are it’s never been operated quite like this before.

That’s because Julien Schuermans has managed to connect the robotic surgical tool’s hardware up to a LeapMotion controller, making its small forceps gesture-controlled. You can see how it all works in the video below.

As The Verge explains, four Arduino Uno-controlled servos are fitted to the pulleys and cables that handle the rotation, angle and gripping mechanism. Gesture input is captured by the Leap Motion’s infrared cameras, which is then converted into instructions for these servos, enabling the user to command the endoscopic device with just a wave of the hand.

Richard Garsthagen recently became the proud owner of a Razor Crazy Cart. Seeing as though he only had one, racing against others was a bit out of the question for now. Being the Maker that he is, he came up with a solution instead: an Arduino Uno-based lap timer.

The lap timer uses an infrared light bridge to detect when something crosses the line, an Adafruit 7-segment display to show the time and lap count, as well as a SparkFun thermal printer that spits out the final results. The frame itself is constructed out of MakerBeam components, while power is supplied through an 11.2V LiPo battery.

Meanwhile, the Arduino software has two modes:

Race mode: This is started by clicking the left “race” button. This will start the laptimer. It uses a “flying start” principle. So there is no count down, just start racing, when the first time you cross the line, the timer will start. It will display the amount of laps still to go on the top 7-segment display and the time on the second 7-segment display.

Setup mode: When you click on the “menu,” 2nd button, you can setup how many laps you want to race. By turning the pot-meter you can select between one and nine laps.

While he may be using his timer for Crazy Cart, the system can come in handy whenever you’re unable to directly race someone else — whether that’s running or cycling around the house. Want one of your own? Race on over to its project page. In the meantime, check it out in the video below. (We gotta say, the 8-bit chiptunes were a nice touch!)

Developed as part of a semester project, BINARY IO is a nifty little MIDI controller capable of counting from one to 15 using only four buttons. The device, which uses binary code as an input mechanism, is powered by an Arduino Uno and Max/MSP.

With a little practice, BINARY IO becomes quite intuitive and fun to play. As demonstrated by its creators Benjamin Weber and Jeremy Ondrey, users can piece together new music with sounds ranging from the piano to the xylophone to the drums.

Nixie tubes have a lot of fans because of their retro style. They are neon valve tubes, where 10 cathodes shaped like numbers from 0 to 9 are switched on by plasma when high voltage flows through them. Patented in the 1930s by H.P. Boswau, they were wildly popular in the ‘60s and remained so until LEDs became cheaper to manufacture in the ‘70s. Many Makers today are creating vintage-look clocks using, now rare, Nixies bought on eBay with the help of an Arduino or Genuino Uno to control them.

In the video below, Jozsef Kovecses built a Nixie clock with NTP time syncronization using a Genuino Uno, a Geeetech IduinoShield, DS1307 RTC, DC-to-DC converter, and Nixie tube modules to drive the tubes directly.

Longtime artist Jeff Leonard has built a pair of Arduino-driven CNC painting machines with the motivation to grow his toolbox and expand the kinds of marks he could make simply by hand. By pairing the formal elements of painting with modern-day computing, the Brooklyn-based Maker now has the ability to create things that otherwise would’ve never been possible.

Machine #1 consists of a 5’ x 7’ table and is capable of producing pieces of art up to 4’ x 5’ in size. The device features a variety of tools, including a Beugler pinstriping paint wheel, a brush with a peristaltic pump syringe feed, an airbrush with a five-color paint feed system and five peristaltic pumps from Adafruit, a squeegee, and pencils, pens, markers and other utensils.

In terms of hardware, it’s equipped with three NEMA 23 stepper motors, three Big Easy Drivers, as well as an Arduino Mega and an Uno. There are two servos and five peristaltic pumps on the carriage–the first servo raises and lowers the tool, while the second presses the trigger on the airbrush. An Adafruit motor shield on the Uno controls the pumps, and the AccelStepper library is used for the Big Easy Drivers.

According to Leonard:

I am coding directly into the Arduino. There are many different codes that I call and overlap and use as a painter overlaps techniques and ideas. There is a lot of random built into the code, I don’t know what the end result will be when I start. Typically on any kind of CNC machining the end result has been made in the computer and the machine executes the instructions. I am building a kind of visual synthesizer that I can control in real-time. There are many buttons and potentiometers that I am controlling while the routines are running. I take any marks or accidents that happen and learn how to incorporate them into a painting.

I am learning Processing now and how to incorporate it into the image making.

Machine #2, however, is a bit different. This one is actually a standup XY unit that was made as a concept project. It paints using water on magic paper that becomes black when wet and disappears as it dries, used mainly as a way to practice calligraphy or Chinese brush painting. Not only does it look great, there’s no clean up either!

In terms of tools, the machine has a brush and an airbrush. Two NEMA 17 stepper motors are tasked with the XY motion. There are also three servos–one servo lifts and lowers the armature away from the paper since there is no Z-axis, another controls the angle of the brush, and the third presses the trigger of the airbrush. A peristaltic pump helps to refill the water cup, along with a small fan. The system is powered by an Arduino Uno with an Adafruit Motor Shield using the Adafruit Motor Shield Library v2.

As awesome as it all sounds, you really have to see these gadgets in action and their finished works (many of which can be found on Instagram).

A video posted by Jeff Leonard (@jeffleonardarts) on Jun 5, 2016 at 7:56pm PDT

A video posted by Jeff Leonard (@jeffleonardarts) on May 27, 2016 at 8:07pm PDT

A video posted by Jeff Leonard (@jeffleonardarts) on May 22, 2016 at 8:27pm PDT

A video posted by Jeff Leonard (@jeffleonardarts) on Apr 24, 2016 at 8:11pm PDT

A video posted by Jeff Leonard (@jeffleonardarts) on May 1, 2016 at 8:48pm PDT

A video posted by Jeff Leonard (@jeffleonardarts) on Apr 13, 2016 at 7:36pm PDT

A video posted by Jeff Leonard (@jeffleonardarts) on May 5, 2016 at 7:52pm PDT

Connor Nishijima has devised a neat trick to give the standard Arduino Tone() function 256 smooth volume levels using PWM at an ultrasonic frequency, without any extra components. This allows for programmatic control of square waves with nothing other than a speaker connected to an Arduino Uno.

Normally to simulate an analog voltage with a digital-only pin of a microcontroller you’d use Pulse Width Modulation. This works great for LEDs because your eyes can’t the 490 / 976Hz flicker of the standard analogWrite() function. But for audio things are a bit more difficult. Because your ears can easily detect frequencies between 20 – 20,000Hz, any PWM with a frequency in this range is out.

Luckily, the ATmega328P allows you to change the clock prescalers for ultrasonic PWM! We need to use Timer0, because it can drive PWM at a max frequency of 62,500Hz, which even if you cut that in half would still be above your hearing range. Now that we have ultrasonic PWM on Pins 5 & 6, we configure Timer1 to fire an Interrupt Service Routine at a rate of “desired frequency” * 2.

Finally, inside the Timer1 ISR routine, we incorporate our volume trick. Instead of digitalWrite()’ing the pin HIGH and LOW like the normal Tone() function does, we analogWrite() “HIGH” with our volume value (0 – 255) and analogWrite(0) for “LOW”. Because of how fast the PWM is running, the user doesn’t hear the 62.5KHz PWM frequency, and instead perceives a 50% percent duty cycle as a speaker driven with only 2.5 volts! While a few volume levels do produce subtle artifacts to the sound, it mostly delivers quality 8-bit volume control to replace the standard Tone() function.

When all is said and done, you’ll be able to customize your project with unique loudness as you play anything from the iconic Nintendo sound to R2-D2’s beeps and bops. In Nishijima’s case, he developed this Arduino volume-control scheme to make an incessant, inconsistent artificial cricket to hide in a friend’s vent for the next few months… You can read more on its Hackaday.io page, as well as find documentation and ready-to-use example sketches GitHub.