[Sigurd] manage to obtain an old vending machine from his dorm. The only problem was that the micocontroller on the main board was broken. He and his friend decided they could most likely get the machine back into working order, but they also knew they could probably give it a few upgrades.

This system uses two Arduino Pro Minis and an Electric Imp to cram in all of the new features. One Arduino is connected to the machine’s original main board. The Arduino interfaces with some of the shift registers, relays, and voltage regulators. This microcontroller also lights up the buttons on the machine as long as that particular beverage is not empty. It controls the seven segment LED display, as well as reading the coin validator.

The team had to reverse engineer the original coin validator in order to figure out how the machine detected and counted the coins. Once they figured out how to read the state of the coins, they also built a custom driver board to drive the solenoids.

A second Arduino is used to read NFC and RFID cards using a Mifare RC522 reader. The system uses its own credit system, so a user can be issued a card with a certain amount of pre-paid credit. It will then deduct credit appropriately once a beverage is vended. The two Arduinos communicate via Serial.

The team also wanted this machine to have the ability to communicate with the outside world. In this case, that meant sending cheeky tweets. They originally used a Raspberry Pi for this, but found that the SD card kept getting corrupted. They eventually switched to an Electric Imp, which worked well. The Arduino sends a status update to the Imp every minute. If the status changes, for example if a beverage was dispensed, then the Imp will send a tweet to let the world know. It will also send a tweet to the maintenance person if there is a jam or if a particular slot becomes empty.

Read more on MAKE

After almost two years “in the making” we’re thrilled to announce the availability of the Arduino IDE 1.6.0. The latest version of the development environment used by millions of people across the globe brings about a lot of improvements.

Since the day we started developing the first 1.5 version we have received a lot of feedback, suggestions and contributions from our vibrant community and we would like to thank you all for your passion and good will: thank you everyone, you rock!

We are glad to say that 1.6.0 includes a lot of new features. Here is a not so brief list of them:

• Support for multiple platforms
• Boards are detected and listed on “ports list” menu together with the serial port
• Drivers and IDE are now signed for Windows and MacOSX
• Improved speed of build process
• Autosave when compiling/uploading sketch
• A lot of improvements of the serial monitor (faster, backed by modern JSSC serial library instead of old RXTX)
• Find/replace over multiple tabs
• Improved lots of Arduino API libraries (String, Serial, Print, etc.)
• Tools & toolchains upgrades (avr-gcc, arm-gcc, avrdude, bossac)
• Command line interface
• IDE reports both sketch size and static RAM usage
• Editor shows line numbers
• Scrollable menus when many entries are listed
• Upload via network (Yún)
• HardwareSerial has been improved
• USB has got some stability and performance improvements
• SPI library now supports “transactions” for better interoperability when using multiple SPI devices at the same time
• Better support to 3rd party hardware vendors with configuration files (platform.txt and boards.txt)
• Submenus with board configuration can now be defined
• Fix for upload problems on Leonardo, Micro and Yún.
• Libraries bundled with Arduino have been improved and bugfixed, in particular: Bridge, TFT, Ethernet, Robot_Control, SoftwareSerial, GSM
• A lot of minor bugs of the user interface have been fixed

There is still lots of room for improvement, of course. Don’t forget to report any issue you find, either on Github or on the Arduino forum: your help is very much appreciated. It doesn’t matter if you are not a tech specialist: every feedback adds value.

We are already working on release 1.6.1, with some very cool features we will announce in the coming weeks.

The IDE is available from the newly redesigned Download page.

Network Analyzers are frequently used for measuring filters, making them extremely valuable for building radios and general mucking about with RF. They are, however, extremely expensive. You can, however, build one in an Altoids tin with an Arduino Nano, a small screen, and an AD9850 frequency synthesis module picked up on eBay.

The basic idea behind a network analyzer is to feed a frequency into a device, and measure the amplitude coming out of the device, and plot this relationship over a frequency. [Bill Meara] has been a human network analyzer before, changing frequencies and plotting the output of devices under test by hand. [DuWayne] (KV4QB) build a device to automate the entire process.

The block diagram is easy enough – an AD9850 sends a signal to the device, and this is measured by the Arduino with a small amplifier. The signal is measured again when it comes back from the device under test, and all this is plotted on a small display. Simple, and [DuWayne] is getting some very good readings with a lowpass filter and crystal filter made on a small solderless breadboard.

[Bob’s] Pac-Man clock is sure to appeal to the retro geek inside of us all. With a tiny display for the time, it’s clear that this project is more about the art piece than it is about keeping the time. Pac-Man periodically opens and closes his mouth at random intervals. The EL wire adds a nice glowing touch as well.

The project runs off of a Teensy 2.0. It’s a small and inexpensive microcontroller that’s compatible with Arduino. The Teensy uses an external real-time clock module to keep accurate time. It also connects to a seven segment display board via Serial. This kept the wiring simple and made the display easy to mount. The last major component is the servo. It’s just a standard servo, mounted to a customized 3D printed mounting bracket. When the servo rotates in one direction the mouth opens, and visa versa. The frame is also outlined with blue EL wire, giving that classic Pac-Man look a little something extra.

The physical clock itself is made almost entirely from wood. [Bob] is clearly a skilled wood worker as evidenced in the build video below. The Pac-Man and ghosts are all cut on a scroll saw, although [Bob] mentions that he would have 3D printed them if his printer was large enough. Many of the components are hot glued together. The electronics are also hot glued in place. This is often a convenient mounting solution because it’s relatively strong but only semi-permanent.

[Bob] mentions that he can’t have the EL wire and the servo running at the same time. If he tries this, the Teensy ends up “running haywire” after a few minutes. He’s looking for suggestions, so if you have one be sure to leave a comment.

The location of the Casa Jasmina apartment will officially be inaugurated here in Torino (Italy) on the 20th of February, together with the celebration of  the 3rd birthday of local Officine Arduino and Fablab Torino.

The two following days (21-22 of February) we’re going to start producing the first connected things for the apartment in a workshop with the support of Jesse Howard, a designer focusing on new systems of making.

He’ll fly in from Amsterdam and run a 2-day session together with Lorenzo Romagnoli (Casa Jasmina Project Manager) and Stefano Paradiso (Fablab Torino Coordinator) with the goal of designing and manufacturing an Open Source Connected Lamp (OSCOLA).

The workshop is suitable for designers, artists, hackers, and everyone interested in Arduino and open source design and in order to stress the idea of open design, participants will be asked to reinterpret, modify and redesign an open source lamp proposed by Jesse Howard.
A minimum familiarity with of CAD drawings, digital fabrication techniques and Arduino are recommended but not strictly necessary.

By changing materials, shape, use cases, mechanics, and interaction, we are going to create a family of open source lamps.
Arduino Yún will be used to make the lamp interactive, enabling the user to turn it on or off remotely; change the light color; use the light to visualize data etc, or connect one lamp to an other.

The OSCOLA workshop (book your participation!)  consists of 16 hours of class taking place at Fablab Torino and a ticket is valid for two people.  At the end of the workshop, each couple of participants will bring home their IoT open-source lamp and a copy will be reproduced to stay at Casa Jasmina!

[Hunter] wanted to do something a bit more interesting for his holiday lights display last year. Rather than just animated lights, he wanted something that was driven by data. In this case, his display was based on the mood of people in his city. We’ve seen a very similar project in the past, but this one has a few notable differences.

The display runs off of an Arduino. [Hunter] is using an Ethernet shield to connect the Arduino to the Internet. It then monitors all of the latest tweets from users within a 15 mile radius of his area. The tweets are then forwarded to the Alchemy Sentiment API for analysis. The API uses various algorithms and detection methods to identify the overall sentiment within a body of text. [Hunter] is using it to determine the general mood indicated by the text of a given tweet.

Next [Hunter] needed a way to somehow display this information. He opted to use an LED strip. Since the range of sentiments is rather small, [Hunter] didn’t want to display the overall average sentiment. This value doesn’t change much over short periods of time, so it’s not very interesting to see. Instead, he plots the change made since the last sample. This results in a more obvious change to the LED display.

Another interesting thing to note about this project is that [Hunter] is using the snow in his yard to diffuse the light from the LEDs. He’s actually buried the strip under a layer of snow. This has the result of hiding the electronics, but blurring the light enough so you can’t see the individual LEDs. The effect is rather nice, and it’s something different to add to your holiday lights display. Be sure to check out the video below for a demonstration.

Circular Knitic is an open hardware project created for DOERS, an exhibition curated by Arduino co-founder David Cuartielles, which takes place at Etopia Center for Art & Technology in Zaragoza, Spain.

It consists of an exhibition and a series of presentations, workshops and seminars focusing on the world of open creation, invention and personal fabrication. It aims to unveil a variety of extraordinary creations, ideas that are transforming the world, but mostly show visitors a group of people: “the DOERS, constantly looking for new projects that surprise us”.

During a period of eight months, 5 knitting machines will be knitting slowly and produce enough tubulars so that the ceiling of the art centre will be covered with knitted scarves.

Using digital fabrication and maker tools like 3D printing, laser cutting, makerbeam, and Arduino Uno— Knitic duo designed a replicable circular knitting machine. It’s not the first time they experiment on knitting techniques. A couple of years ago I interviewed them on this blog for their previous project focused on giving a new brain to old knitting machines using Arduino Due.

Various designers are experimenting with 3D printing in fashion but this doesn’t mean  to 3d print garments directly. Knitic approach shows how digital fabrication could have greater impact on the way clothes are prototyped and produced, especially on producing new concepts of machines:

In maker culture, production of textiles is often overlooked. Circular Knitic demonstrates that beautiful textiles can be produced with digital fabrication tools.

Most of Circular Knitic parts are made with  RepRap 3D printers, some others are made of plexiglass that can be easily lasercut in a fablab. Instructions and all the stl files for the components are available for download on the project’s GitHub page.

The videos below shows the building of the machines and when they are in action.

Read more on MAKE

[Jordan] managed to cobble together his own version of a low resolution digital camera using just a few components. The image generated is pretty low resolution and is only in grey scale, but it’s pretty impressive what can be done with some basic hardware.

The heart of the camera is the image sensor. Most consumer digital cameras have tons of tiny receptors all jammed into the sensor. This allows for a larger resolution image, capturing more detail in a smaller space. Unfortunately this also usually means a higher price tag. [Jordan’s] sensor includes just a single pixel. The sensor is really just an infrared photodiode inside of a tube. The diode is connected to an analog input pin on an Arduino. The sensor can be pointed at an object, and the Arduino can sense the brightness of that one point.

In order to compile an actual image, [Jordan] needs to obtain readings of multiple points. Most cameras do this using the large array of pixels. Since [Jordan’s] camera only has a single pixel, he has to move it around and take each reading one at a time. To accomplish this, the Arduino is hooked up to two servo motors. This allows the sensor to be aimed horizontally and vertically. The Arduino slowly scans the sensor in a grid, taking readings along the way. A Processing application then takes each reading and compiles the final image.

Since this camera compiles an image so slowly, it sometimes has a problem with varying brightness. [Jordan] noticed this issue when clouds would pass over while he was taking an image. To fix this problem, he added an ambient light sensor. The Arduino can detect the amount of overall ambient light and then adjust each reading to compensate. He says it’s not perfect but the results are still an improvement. Maybe next time he can try it in color.