EZcontrol.IT simplifies home automation

EZboard is an Atmel-based platform designed to facilitate home automation projects for Makers and developers. Powered by Atmel’s versatile ATmega328P microcontroller (MCU), the board is equipped with an onboard Ethernet controller, microSD card socket, temperature sensor and power relay.

“Everything on the EZboard has been designed to minimize power consumption. For this reason Atmel’s ATmega328P is configured to work a 3.3V and 8MHz of speed. While this [may] sound like a limit, we have verified that it is more than enough for home automation applications,” an EZboard rep explained in a recent Indiegogo post.

“The power source could be a microUSB adapter, but the EZboard was designed to receive power mostly by batteries. [Indeed], the EZboard has a dedicated input that uses 0.1″ pitch connectors like the common JST or even direct soldering of a battery pack to the board.”

Aside from Atmel’s ATmega328P MCU, key technical specs include:

• Operating Voltage: 3.3V (5V tolerant on I/Os)
• Input Voltage: 3.7 – 9V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 8 (of which 2 are used from onboard sensors)
• Flash Memory: 32 KB – SRAM: 2 KB, – EEPROM: 1 KB
• Additional Memory: microSD (TF) socket
• Clock Speed: 8MHz
• USB Controller: FTDI FT232RL
• Ethernet Controller: MIcrochip ENC28J60
• Max Ethernet Speed: 10Mbps
• Temperature sensor: TMP36
• Relay Rating: 1A at 30VDC or 2A at 110/250VAC
• Footprint: compatible with the Atmel-powered Arduino UNO R3

On the software side, the EZcontrol.IT is optimized for the cloud-based Lelylan, a simple and open API designed for building a connected IoT home.

“[Lelylan allows] Makers to focus on the hardware and design process, while developers can create new apps for the web and mobile,” the rep added.

“You [can] interact with lights, appliances, alarms, cooling and heating systems, gas sensors, rolling shutters, windows, irrigation, video surveillance, gates and multimedia (audio and video).”

Interested in learning more about the Atmel-based EZcontrol.IT? You can check out the board’s official Indiegogo page here.

Video: Interactive m!Qbe redefines lighting

The Atmel-powered m!Qbe is an intuitive, interactive platform that allows users to easily control multiple lights. The system comprises a number of components, including the m!Qbe (central) module, m!base, m!charger and WiFi.

The m!Qbe is designed to be used in one room with an m!Base and should, depending on the layout, cover a circle with a diameter of 20 meters.

“Just flip it and switch to the suitable lighting situation for your current activity such as low yellowish light to relax on the couch, bright white light to read the newspaper or different colors for your birthday party,” an m!Qbe rep explained in a recent Indiegogo post.

“Use it in everyday life with many more possibilities than a traditional light switch and much faster than manual control on a mobile device.”

Indeed, the m!Qbe’s three faces, or sides, are designed to “memorize” specific settings.

“You predefine them once and recall them whenever you like,” said the rep.

“In addition, you can add a delay on every favorite. So you can go to bed or leave your home in bright light for instance. The m!Qbe [will] automatically turn off all your [lights] after a while.”

As you can see in the video above, the m!Qbe can be rotated to manually change color or brightness, while a brief touch on the icon switches from one light to another, allowing the user to easily select and adjust specific fixtures.

So, how does the platform work?

 Essentially, the m!Base component communicates with the m!Qbe and the network of lights.

“It converts the detected motion into lighting situations and provides access to the settings of the m!Qbe,” the rep continued.

“The installation of the m!Base is a plug and play solution. In its standard configuration you connect the m!Base with a cable to your network. If you want to connect it wirelessly, please order the WiFi option.”

As noted above, the m!Qbe is built around an Atmel 8-bit microcontroller (MCU), which uses data generated from a three-axis acceleration sensor and a three-axis gyro sensor to precisely calculate motion.

“Additionally on each of the two manual faces, a capacitive touch sensor is integrated and allows to detect touch actions of different lengths. In the m!Base a Linux system transfers the commands received via bluetooth from the m!Qbe to commands for every single lamp in the network,” the rep added.

“For the configuration of this transfer and to read out statistical information a web interface is implemented. If you want to extend the functions of the m!Qbe the easiest way is to modify the software of the m!Base.”

Last, but certainly not least, m!Qbe supports the Philips Hue system that includes not only the connected bulbs but also Friends of Hue such as LightStrips and LivingColors Bloom, along with dimming plugs for more traditional lamps.

Interested in learning more? You can check out the official m!Qbe page on Indiegogo here.

Atmel-powered Printoo featured on Gigaom, EDN

Printoo – powered by Atmel’s ATmega328 microcontroller (MCU) – is a lineup of paper-thin, low-power boards and modules that offer Makers and devs new levels of creative flexibility.

The open source platform, created by the Ynvisible crew, made its official Kickstarter debut last week and has already been covered by a number of prominent publications, including EDN, Gigaom and Quartz.

“A spin-out from YDreams, Ynvisible was founded in 2010 with the goal to bring more interactivity to everyday objects and surfaces, mostly through the use of flexible and printed electronics including the company’s fully transparent electrochromic display. The paper-thin display, which only becomes visible when activated can easily be integrated with different background graphics,” writes EDN’s Julien Happich.

“Running Arduino software, the first Printoo packs include novel printed modules including LED light strips from VTT lab, 1.5V printed batteries from Blue Spark and Enfucell, 0.350mm thin organic photodetectors from ISORG, printed polymer solar cells from Mekoprint, and Ynvisible’s own transparent printed displays running from 1.5V. Also included are modules like Bluetooth LE, DC motor control, flexible LED matrixes, and a variety of sensors. The Printoo core is powered by the Atmel ATmega328 microcontroller.”

As Gigaom’s Signe Brewster notes, printed circuits are currently being considered for everything from shipping labels to tiny spacecraft NASA might send to Mars.

“Ynvisible expects Printoo to find a home among 3D printer owners and DIYers already familiar with Arduino,” Brewster explains.

“The modules are small enough to slip into a 3D printed object, opening up ways to easily create robots and other moving or connected devices. They could also be worn as a bracelet or sewn into clothes.”

Meanwhile, Lio Mirani of Quartz points out that bendable electronics could be the future of the rapidly evolving Internet of Things (IoT).

“When the first Harry Potter movie came out in 2001 the idea of the Daily Prophet, a newspaper that contains moving pictures, qualified as magic. A Kickstarter campaign by Ynvisible, a Lisbon-based technology firm, is bringing that magic to life with its displays, held together with paper-thin circuitry,” writes Mirani.

“Ynvisible’s ‘vision’ is to ‘bring everyday objects to life.’ For that to happen, it isn’t just processing power that needs to get cheaper and smaller, which it has, but the input and output mechanisms also need to be smaller and easily adaptable. Ynvisible is betting there is a broad market for such technology. The roaring success of its Kickstarter campaign is an early validation of that belief.”

Indeed, Ynvisible has already raised close to $36,000 – with support from almost 300 backers. Interested in learning more? You can check out the project’s official Kickstarter page here.

The Stargate-Arduino (Chappa’ai) connection

A Stargate is a portal device within the fictional SG universe that facilitates practical, rapid travel between two distant locations.

According to Wikipedia, the devices first appear in the 1994 Roland Emmerich film Stargate – and subsequently in the television series Stargate SG-1 Stargate Atlantis and Stargate Universe. 

The stargates – created millions of years ago by an alien civilization known as the Ancients – typically measures 4.6 m (15 ft) in diameter and weighs in at 29 metric tons (64,000 pounds).

Since a “proper” sized stargate may be a little too big for the average living room, den or basement, a Maker by the name of Shlonkin is working to create a smaller replica, (19cm in diameter), complete with a dialing computer.

“It will move and light up just like the version in SG-1. When a proper address is dialed, a connection will be opened up via the Internet to a corresponding device or computer,” Shlonkin explained in a recent HackADay blog post.

“Exactly what will be transmitted has not yet been decided. The hardware/Internet interface will be via [an Atmel-based] Arduino Uno (ATmega328 MCU). One team member, myself, will design and build the physical device. Another member, Dkopta, will create the software.”

Aside from the Atmel-based Uno, key project components include:

• Two 1.2mm polypropylene sheet
• Two 3mm polypropylene cutting board
• One wireless 10-key (IR)
• One stepper motor
• One SN754410 H-Bridge for the motor
• 7 red SMD LEDs and 1k resistors
• One plastic food container
• Assorted paints

“I will definitely post all the build details, but not until I make a little more progress. The parts are made with hand tools. I’ll probably use some thin(5mm) HDPE boards that are really easy to carve. I’ve never done anything this detailed with HDPE, so it will be a learning experience,” he added.

“We will go as far as we can get before the end of the contest. I would love it if the top chevron moved like in SG-1, but since it is so small(about 2cm) I don’t know if I will be able to pull it off, [but] I’ll think [about] it.”

Interested in learning more? You can check out the project’s official HackADay page here.

Getting started with Adafruit’s Atmel-powered FLORA

Adafruit’s Becky Stern and Tyler Cooper have penned a new book about the company’s popular Atmel-powered FLORA platform.

Titled “Make: Getting Started with Adafruit FLORA,” the upcoming book details various wearable electronics projects that can be designed and built using the device.

Indeed, FLORA weighs in at 4.4 grams and measures only 1.75 inches in diameter. Featuring Arduino compatibility, the platform is one of the most beginner-friendly way to create wearable projects.

“This book shows you how to plan your wearable circuits, sew with electronics and write programs that run on the FLORA to control the electronics,” Stern explained in a recent blog post.

“The FLORA family includes an assortment of sensors, as well as RGB LEDs that let you add lighting to your wearable projects.”

As we’ve previously discussed on Bits & Pieces, Adafruit’s wearable electronics platform is built around Atmel’s versatile Atmega32u4 microcontroller (MCU).

The microcontroller boasts built-in USB support, eliminating the need for pesky special cables and extra parts.

According to Adafruit’s Limor Fried, FLORA is extremely “beginner-friendly.” Indeed, the device is difficult to accidentally destroy by connecting a battery backwards, thanks to a polarized connector and protection diodes.

Meanwhile, an onboard regulator ensures even connecting a 9V battery won’t result in damage.

Interested in learning more about Adafruit’s Atmel-powered FLORA? You can check out the platform’s official page on Adafruit here and sign up for book updates here.

Making your own ATtiny (model) police light

Jan Henrik has designed a multi-functional police light for model cars using Atmel’s ATtiny tinyAVR (25/45/85) microcontroller (MCU).

The project – which recently surfaced on Instructables – features several “animations” or sequences that can be easily changed by simply pressing a button on the circuit board.

“It has two channels, which can be controlled with PWM,” Henrik explained.

“This allows us to add serval animations or police light flashing sequences. The maximum rated current per channel is 500mA, [enabling] us to control high power LEDs, LED stripes or old light bulbs.”

Aside from Atmel’s ATtiny MCU, key project components include:

• Two buttons (off/on)
• Two resistors (1kOHM)
• Two resistors (220kOHM)
• Two resistors (450OHM)
• Two diodes (1N4007 or Equal)
• Terminals with screws
• One 8 pin IC holder
• Two BC548 (or Equal)
• Un-isolated wire
• One circuit board

As you can see in the circuit board layout above, the two output channels are on pins 0 and 1 (PWM outputs), while pins 3 and 4 are designated as input pins for the buttons.

To program the ATtiny, Henrik used an Arduino Uno with a shield, although as he points out, a simple breadboard will suffice.

On the software side, Henrik wrote two separate programs for the police light. The first is easier to understand and alter, while the second features German and American police light sequences, along with a more responsive menu.

Interested in learning more? You can check out the DIY ATtiny police light official Instructables page here.

Self-learning ‘copter navigates with an ATmega644 MCU

Akshay Dhawan and Sergio Biagioni of Cornell University have designed a self-learning (RC) helicopter powered by an advanced machine learning algorithm paired with Atmel’s ATmega644 microcontroller (MCU).

Aside from Atmel’s ATmega644 MCU, key project components include:

• Syma S107 Micro Helicopter
• Custom PC Board (for MCU)
• RS232 UART connector
• Max233CP
• Power Supply
• Infrared Emitter 365-1056-ND
• Infrared Receiver 160-1030-ND
• Wooden platform
• Balsa wood 24 inch dowel
• White board (holds phototransistor circuit)

As HackADay’s Will Sweatman reports, the ‘copter is attached to a boom which restricts its movement down to one degree of motion. Meaning, the helicopter can only move up from the ground, rather than side to side or front to back.

“The goal is for the helicopter to teach itself how to get to a specific height in the quickest amount of time. A handful of IR sensors are used to tell the ATmega644 how high the helicopter is,” writes Sweatman.

“The genius of this though, is in the firmware. Akshay and [Sergio] are using an evolutionary algorithm adopted from Floreano et al, a noted author on biological inspired artificial intelligences.”

Essentially, the ‘copter creates random “runs” and then check the data. The runs that are closer to the goal are refined, while the others are eliminated in a process that emulates evolution via natural selection. In short, the project’s goal is for the ‘copter to start at Point A, go to Point C and hover. The allotted time is 10 seconds per run, with the helicopter expected to teach itself the routine as quickly as possible.

“A neural network is used to determine at what level the throttle should be at to achieve the highest Fitness Value. This network is a part of the Evolutionary Algorithm that runs in the firmware. Basically, it starts off with random values that generate random levels of throttle,” Sweatman explains.

“The values that achieve the highest Fitness Value get ‘mutated’, while the others are discarded. The mutations in the values are done at random and the process repeats. In the end, the firmware learns the best throttle levels to achieve the goal of being at Point C for the longest time in the allotted 10 seconds.”

Interested in learning more about the self-learning ‘copter? You can check out the project’s official Cornell page here.

This geiger counter is powered by Adafruit & Atmel

The Geiger–Müller counter, also known as a Geiger counter, is an instrument used for measuring ionizing radiation. According to Wikipedia, the device detects radiation such as alpha particles, beta particles and gamma rays using the ionization produced in a Geiger–Müller tube.

Recently, Johan of dynode.nl designed geiger counter powered by Adafruit’s Atmel-based (ATtiny85 MCU) Trinket.

“Lately I have been messing around a bit with microprocessor powered geiger counters. One smart guy came up with the idea of generating high voltage using PWM signals from the microprocessor itself,” Johan explained in a detailed blog post.

“With some additional external parts a HV supply and negative going pulse suitable for microprocessors is easy to make.”

So, how does the circuit work? Simply put, a ~1 Khz squarewave turns the MPSA44 high voltage transistor on and off – generating high voltage when the inductors current is shut off.

As Johan notes, the specific voltage is contingent upon the pulse width of the square wave which can be tweaked on a software level.

“The 1N4007 diode rectifies this voltage, and the HV cap removes most of the ripple on this voltage. The resistor limits current to the GM tube,” he continued.

 “The current pulses from the tube generate a voltage drop over the 100K resistor which turns on the BC546. When this happens, the voltage [via] the 10K resistor is pulled to ground, generating a negative going pulse each time the GM tube detects an ionizing ray or particle.”

It should also be noted that Johan’s design supports serial logging capability using a tx only software serial library tasked with outputting the measurements in CPM every 10 seconds on pin 4.

So, what’s next for the Trinket-powered geiger counter? Well, Johan says the platform still requires some tweaking, as the circuit is quite susceptible to electromagnetic interference which causes erroneous counts.

Interested in learning more? You can check out the project’s official page here.

Video: Atmega328p MCU drives LINBUS signal injector

Zapta has created a LINBUS signal injector powered by Atmel’s Atmega328p microcontroller (MCU) to simulate an automatic “Sport Mode” button press in his vehicle.

Essentially, the Atmel-powered signal injector connects on a LIN Bus between the master and slave – observing and manipulating the data flowing on the line. 

The device is also equipped with a 115kbs serial interface for programming and logging bus activity on a standard computer, along with two LIN bus ports.

“One acts as a slave and should be connected to the LIN bus master and another that acts as a master and should be connected to the LIN bus slave,” Zapta explained in a recent blog post.

“The firmware includes a set of files named with the prefix custom_ that implements an application specific logic (simulating pressing the Sport Mode button of my car whenever the ignition is turned) and should be modified to match the target logic and behavior.”

In addition, the USB/Serial port is also compatible with the Arduino IDE (emulating an Atmel-powered Arduino Mini Pro) which can be used to edit/compile/download software updates.

“The serial output of the injector can be viewed directly with a terminal emulation software or using the provided script that adds timestamp,” Zapta added. 

”The injector provided sample application is configured for 19,200bps linbus that uses LIN V2 checksum but can be configured for busses with different speeds and checksum formula.”

Interested in learning more? You can check out the project’s official page and relevant files here.

Making music with the open source Kyub

The Kyub is a Maker friendly, open source MIDI keyboard kit that can be easily assembled by just about anyone.

“Capacitive sensing gives the Kyub extremely sensitive action, [while] an internal accelerometer allows the volume of each note to be precisely controlled for versatile musical expression,” a Kyub rep explained in a recent Kickstarter post.

“You can attach multiple Kyubs to a computer synthesizer or digital audio workstation for solo play, jamming with friends, or composition.”

Key Kyub features include:

• One Teensy 2.0 AVR-based board (ATmega32u4 MCU) with native USB MIDI support.
• 11 fully programmable feather touch keypads on five surfaces of a 3-inch wooden cube.
• Three-axis 3G accelerometer controls note volume, after touch or pitch bending.
• Three open source programs for immediate experimentation and playing.
• Compatible with most software synthesizers, including Propellerhead Reason.
• Provides access to hundreds of high quality synthesized instruments.
• Easy to assemble laser cut wood housing accepts a variety of finishes.

So, how does the Kyub work?

Well, the internal circuitry monitors each of the keypads to immediately detect even the lightest finger touch reflected in a capacitive disturbance. 

Meanwhile, acceleration of the Kyub housing associated with a finger touch is converted to a note loudness, which, together with a pitch determined by the keypad, is transmitted over a USB cable in standard MIDI format. It should also be noted that the Kyub offers low latency (on the order of 3 ms), providing a highly responsive musical experience.

On the software side, Kyub can be easily modified in various ways, including changing the notes assigned to each pad, altering the MIDI channel, changing chords assigned to the chord pads, moving notes to make them easy to play, swapping an instrument from guitar to klaxon and playing almost any chord progression.

“We give you super-documented source code using the popular Arduino programming environment (simple C personalized for the Teensy) that will let you set the scale, tweak the note velocity curves, even map different instruments to different pads (say, drums and fife) to get exactly the musical experience you’re looking for,” added the Kyub rep.

“[Plus], our hyper commented source code should give you the tools you need to completely change the Kyub DNA. Make a loop recorder, a drum machine, an arpeggiator, assign pads to play musical phrases, tap into the accelerometer for after touch, pitch bending, or scale changes, squeeze the final bit of latency out.”

Interested in learning more? You can check out Kyub’s official Kickstarter page here.