Just Don’t Call It An Old Remote

October 4, 2015 by Al Williams 12 Comments

[Hari Wiguna’s] father is ninety years young. He started having trouble pushing the buttons on his TV remote, so [Hari] decided to build a custom remote that just has the buttons his dad needs. Oh, and the buttons are big.

There are a few interesting things about this project. [Hari] wanted to maximize battery life, so he went through a good bit of effort to keep the processor asleep and minimize power consumption. The remote is programmable, but [Hari] didn’t have access to his dad’s remotes. His answer was elegant. He used his Android phone to mimic the required remotes and provided a way for the remote to learn from another remote (in this case, the phone).
Continue reading “Just Don’t Call It An Old Remote” →

Arduino’s Long-Awaited Improved WiFi Shield

October 1, 2015 by Brian Benchoff 45 Comments

Announced at the 2014 Maker Faire in New York, the latest Arduino WiFi shield is finally available. This shield replaces the old Arduino WiFi shield, while providing a few neat features that will come in very handy for the yet-to-be-developed Internet of Things.

While the WiFi Shield 101 was announced a year ago, the feature set was interesting. The new WiFi shield supports 802.11n, and thanks to a few of Atmel’s crypto chip offerings, this shield is the first official Arduino offering to support SSL.

The new Arduino WiFi Shield 101 features an Atmel ATWINC1500 module for 802.11 b/g/n WiFi connectivity. This module, like a dozen or so other WiFi modules, handles the heavy lifting of the WiFi protocol, including TCP and UDP protocols, leaving the rest of the Arduino free to do the actual work. While the addition of 802.11n will be increasingly appreciated as these networks become more commonplace, the speed offered by ~n isn’t really applicable; you’re not going to be pushing bits out of an Arduino at 300 Mbps.

Also included on the WiFi shield is an ATECC508A CryptoAuthentication chip. This is perhaps the most interesting improvement over the old Arduino WiFi shield, and allows for greater security for the upcoming Internet of Things. WiFi modules already in the space have their own support for SSL, including TI’s CC3200 series of modules, Particle‘s Internet of Things modules, and some support for the ESP8266.

Arduino Development; There’s A Makefile For That

October 1, 2015 by Sonya Vasquez 32 Comments

Hardware and software combined, Arduino does many things right. It lowers the entry level into embedded systems development with a nifty hardware abstraction layer. It aims for cross-platform compatibility by supporting Windows, Mac OSX, and Linux operation systems. It throws out the need for an external programmer to get you up-and-blinkin’ those LEDs quickly.

One thing most of us never cease to curse about, though, is the IDE. Many have cried out wildly against the Java-based text-editor for its cryptic compiling-and-linking process, its inability to accommodate bare C or C++ source files, and (shh!) its lack of Vim keybindings. Fortunately, our cries have been heard, and the like many community-based projects, the community fights back with a custom solution.

Calling all Grumpy Engineers: The Arduino-Makefile

Enter the Arduino Makefile.

What began as [Sudar’s] lightweight program to escape the IDE has become a fully-blown, feature rich Makefile that has evolved and adapted to grow with the changes of Arduino. With a community of 47 contributors, the Makefile enables you to escape from the IDE entirely by writing code in the cushy text editor of your choice and compiling with a simple incantation of make into your terminal, be you in Linux, Mac, or Windows.

Without further ado, let’s take a walking tour of the project’s highlights.

Continue reading “Arduino Development; There’s A Makefile For That” →

KIM-1 Clock

September 29, 2015 by Al Williams 24 Comments

Over on hackaday.io, [Arduino Enigma] posted the code for his clock that runs on a KIM Uno (the KIM-1 clone we mentioned late last year). Although the KIM Uno has a few demos preloaded (including Microchess and a scientific calculator), all of them take some interaction. The clock makes the KIM Uno a more dynamic desk display since it does something useful without any user interaction (once you set the clock, of course).

The project shows the code stored in ROM, but you can’t directly enter the program into ROM (which is really EEPROM on the host Arduino). The trick is to enter the address (that is press AD and then 0, 4, 0, 0) and then mash down the reset button for about a second. Then you can press DA and enter the hex codes provided (pressing + after each byte). Since the code is in nonvolatile storage, you can start it at any time by setting the time in RAM and executing the code at address 400.

Continue reading “KIM-1 Clock” →

Sending The Internet From An LED Lightbulb

September 27, 2015 by Richard Baguley 46 Comments

The number of things that can carry Internet traffic is always increasing. Now, you can add LED light bulbs to this list, as engineers in Disney Research have just demonstrated a system that transmits Internet traffic using an LED light bulb. This method of communication isn’t new: Visible Light Communication (VLC) has been demonstrated before by Disney and others, but this project puts it into a standard LED light bulb. This bulb has been modified to include an Atheros AR9331 SoC running OpenWRT and an Atmel ATmega328p that controls the LED elements and sensors that send and receive the data. So, the device is acting as a gateway between a WiFi network and a VLC one.

Disney’s new test system (PDF link) isn’t especially fast: it can only carry about 380 to 400 bits per second, so it won’t be streaming video anytime soon. That is definitely fast enough, though to send control data to a toy, or to send a continual stream of updated data to a device in the room, such as an ebook reader with a continually updated encyclopaedia. This being Disney, the authors coin a new phrase to end their paper: The Internet of Toys.

Demonstrating Baudot Code

September 27, 2015 by Rud Merriam 20 Comments

Visualizing how electronic signals work can be difficult. A physical model can be darn useful in overcoming that difficulty. At a recent workshop entitled “Unboxing Black Boxes” [Julian Hespenheide’s] group created a device to show Baudot Code in operation. This amalgam of wood and Arduino they dubbed émile in honor of Émile Baudot (1845-1903).

Baudot developed his code to transmit telegraph signals from one machine to another, in contrast to Morse code which was principally for human communication. Both codes were used throughout the 20th century. For example, those big clattering, mechanical teletype machines use a minor variation of Baudot code.

Baudot is a fixed length code of 5 bits, as opposed to Morse’s variable length code. Morse has a separate code for each characters while Baudot uses “shift’ codes to change between alphabet and figure characters. For instance, a binary 11 would represent either an ‘A’ or a ‘-‘ depending on the shift state. If the shift code was missed the receiver would get gibberish.

In émile the Baudot code is sent by marbles. That’s right, marbles. There are five marbles, one for each bit in the Baudot code. Each marble rolls in a track toward the Arduino. How does the machine know which marbles to send? “Punch cards”! These are a marvelous aspect of the design.

Each card represents a code. Each position in the card has a gap to allow a marble to pass ( a set bit), or no gap to block the marble (an unset bit). The operator loads 5 marbles and a punch card and launches the marbles via a spring mechanism.

[Julian’s] really created a great visualization of Baudot code with this project! Take a look at émile in action after the break. Continue reading “Demonstrating Baudot Code” →

School Of Friends Use Thought Control On A Shark

September 26, 2015 by Al Williams 3 Comments

[Chip Audette] owns (at least) two gadgets: one of those remote control helium-filled flying shark (an Air Swimmer), and an OpenBCI EEG system that can read brain waves and feed the data to a PC. Given that information, it can hardly surprise you that [Chip] decided to control his flying fish with his brain.

Before you get too excited, you have to (like [Chip]) alter your expectations. While an EEG has a lot of information, your direct thoughts are (probably) not readable. However, certain actions create easily identifiable patterns in the EEG data. In particular, closing your eyes creates a strong 10Hz signal across the back of the head.

Continue reading “School Of Friends Use Thought Control On A Shark” →