Tag Archives: 8-bit Microcontroller

8- or 32-bit, that is the question…

Writing for Electronic DesignAtmel’s Ingar Fredriksen and Paal Kastnes recently explored the latest market trends for both 8- and 32-bit microcontrollers (MCUs). While the 32-bit MCU devices continue to rise in popularity throughout the embedded community, 8-bit MCUs are still experiencing a CAGR close to that of their bigger cousins.

These 32-bit, function-rich devices suit an array of different applications, which explains why many embedded developers select them for their next designs. Designers recognize that such complex devices offer everything they need in terms of raw compute power, a rich peripheral set, and easy access to a wide range of development tools and libraries.

Many of these 32-bit devices — which are members of the Atmel | SMART family — are based on the highly-successful ARM cores. Thus, developers feel confident in having access to second source devices and a comprehensive set of development, test and validation tools being available in the market.

However, taking a closer look at recent MCU market trends has revealed that 32-bit devices aren’t the only ones experiencing strong growth. The surging 8-bit MCU market boasts a CAGR (6.4%) close to that of 32-bit (6.9%). Meanwhile, a number of other industry analysts forecast identical growth rates for 8- and 32-bit microcontrollers.

The upswing in 8-bit devices, like the incredibly popular Atmel AVR lineup, clearly highlights that there must be some compelling reasons to use an 8-bit device in place of a 32-bit MCU. The recently-published Electronic Design article looks to shed some insight as to why 8-bit devices are retaining market share.

Essential Differences

The principle differences between 8- and 32-bit MCUs are cost and price structure, CPU performance, ease of use, efficiency in hardware near functions, and static power consumption. When embarking on a new design, developers need to carefully scope out the requirements for an MCU based on the amount of processing capability required, the degree of interfacing needed, and, for battery-powered designs, the all-important power consumption profiles. There’s no doubt that a 32-bit MCU delivers higher performance than an 8-bit device, but the engineer faces the traditional decision of choosing between the best available device in the market versus an application’s actual needs.

Table-1-big

Of course, these decisions will greatly influence the likely bill of materials (BOM) cost. With a lower gate count, a less complex 8-bit device will certainly be cheaper than a 32-bit device. When comparing 8- and 32-bit MCUs from leading vendors, each with a similar amount of flash memory, pin-out etc., 8-bit devices typically cost about 20% less. But this is only the first of many considerations. Another aspect relates to the ease in setting up for a new development.

Ease of Development

MCU suppliers tend to add more features and functionality to their 32-bit devices as opposed to 8-bit products. Consequently, far more setup considerations emerge with a more complex device. While some 32-bit MCUs can run with a limited setup similar to that of an 8-bit device, you’re unable to take advantage of the more powerful device’s additional features.

For example, a typical 32-bit ARM device will have independent clock settings for the core itself, the AHB bus, the APBA bus, and the APBB bus. They all can be set to different frequencies. Typically, you will also have to switch to the clock you want to use because it’s set in software, not in hardware like most 8-bit parts. Furthermore, changing the clock means you must set up the wait states for flash, possibly predicated on measured VCCvoltage.

Such a setup can be much simpler with an 8-bit MCU, though. For example, Atmel’stinyAVR and megaAVR products only require initialization of the stack pointer, which typically takes four lines of code, prior to coding the application. The choice of clock, brownout detector, reset pin function, etc., is all pre-programmed into the device.

The architecture is also much more straightforward than a 32-bit device with internal registers, peripherals, and SRAM all mapped on the same data bus. The peripherals and CPU would normally run at the same frequency, so no peripheral bus configuration is necessary. Moreover, designers can avoid being concerned about latency in synchronizing between different clock domains.

Performance

When it comes to desired CPU performance, the engineer should consider all use cases. The reality is that many embedded designs don’t have high compute requirements. Often, very little manipulation of data is required, so balancing those needs against power-consumption and peripheral-interfacing requirements becomes crucial.

For instance, a simple thermostat application will spend most of its life in a sleep mode. Every so often, it will wake up and measure the temperature and then make a decision to turn a relay on/off or send an instruction to a host controller. Then it will resume sleep. The compute and interface requirements of this application are small, but many other applications such as fire detectors, power tools, flow meters, and appliance controls have a similar use profile, too.

Efficiency of Hardware Near Functions

Many modern microcontrollers incorporate some hardware functions that serve to help the CPU operate as efficiently as possible. In Atmel’s case, both the 8-bit AVR and 32-bit ARM-based MCU families feature the Peripheral Event System. An event system is a set of hardware-based features that allows peripherals to interact without intervention from the CPU. It allows peripherals to send signals directly to other peripherals, ensuring a short and 100% predictable response time.

When fully using the capabilities of the event system, the chip can be configured to do complex operations with very little intervention from the CPU, saving both valuable program memory and execution time. In the case of detecting a hardware event, it’s important to first detect the event and then switch control to the desired interrupt service routine (ISR).

In these situations, CPU speed isn’t the single determining factor. It’s a question of how long, in terms of cycles, does it take to respond to the interrupt, run the ISR, and return. As the following example will show, 8-bit devices can be more efficient in handling hardware near actions.

Table-2-big

Consider receiving one byte on the SPI, using an interrupt to detect it, and then running a simple ISR routine to read the byte from the SPI peripheral and store it in SRAM. Using this scenario, table above draws comparisons between an Atmel 8-bit AVR device and an Atmel ARM Cortex M0+based 32-bit MCU. Calculated with information available, the results are based on minimum implementations. However, engineers should check with their own applications since the interrupt detection and return from interrupt could take more cycles than shown in the table. Requiring 12 cycles versus 33 cycles equates to having a theoretical maximum SPI bandwidth of 1.67 MB/s for the 8-bit CPU and a 606 kB/s bandwidth for a 32-bit CPU when running at 20 MHz.

The degree of numeric processing can also have an impact on the stack and required memory. Applying the Fibonacci algorithm is one particularly good method for testing memory requirements. Since it only uses a local variable, everything needs to be pushed to the stack.

When making a comparison between an 8-bit AVR and an ARM 32-bit CM0+-based device, and using a recursive 15-stage Fibonacci algorithm, the AVR uses a total of 70 bytes of stack, including 30 for return stack (15 calls deep). The ARM-based device uses 192 bytes (60 should be return stack). This means the CSTACK is more than three times the size of the 8-bit solution. In typical C code, more of the variables on the stack often come in a packed format, so this is an extreme corner. However, saying 1.5 to 3 times more SRAM is needed for the same 8-bit-centric application on a 32-bit (versus a native 8-bit) device is a fair estimation.

Power Consumption

No MCU article would be complete without investigating static power consumption. This alone may be a key factor in choosing between an 8- or 32-bit device, especially for battery-powered applications. The table below illustrates power-consumption differences between 8- and 32-bit devices in both active and static modes.

Table-3-big

Aggressive manufacturing technologies increase transistor leakage current, which roughly doubles with each process generation, and is proportional to the number of gates. Leakage current increases exponentially at higher temperatures, which can be easily overlooked when designing a consumer design. Mobile phones and personal media players are transported everywhere, and as we have all found out, temperatures experienced during the summer inside a car can easily climb above 40°C.

The amount of time the microcontroller will spend in active mode versus static mode contributes significantly to the overall application power budget.

Naturally, the ratio between active and static modes will vary depending on the application requirements. Taking the previous SPI interrupt example (second table from above) and assuming a SPI data bandwidth of 80 kb/s, the 8-bit CPU will spend 1.2% of its time in active mode compared to that of the 32-bit, which will spend 3.3% in active mode (table below).

Table-4

Conclusion

Contemplating whether to use an 8- or 32-bit microcontroller for a future design may involve an Internet of things (IoT) application. How IoT actually takes shape provokes lots of debate, but it will certainly challenge engineers to make a detailed appraisal of the MCU requirement. Wireless connectivity, especially ZigBee, will also be an essential component, but that doesn’t automatically mean that it will need a higher power device.

A number of available 8-bit microcontroller products satisfy the need for low levels of processing and wireless connectivity. One such example is the Atmel ATmegaRFR2 series, which provides an IEEE 802.15.4-compliant, single-chip, 2.4-GHz wireless microcontroller solution that suits battery-powered, low-cost IoT designs.

Interested in reading more? Be sure to check out the original article from Electronic Design here.

This ‘ICONIC’ coffee table book is powered by AVR

Just in time for the holiday season, Jonathan Zufi’s coffee table book entitled “ICONIC: A Photographic Tribute to Apple Innovation” recounts the past 30 years of Apple design, exploring some of the most visually appealing and significant products ever created by the Cupertino-based company. The book — which features a number of new photos paying special attention to original prototypes — dons an updated look and comes in a few special editions.

1416888727052

Most notably, the Ultimate Edition includes a special white clamshell case along with a custom PCB designed to pulse embedded LEDs like that of a sleeping older generation Apple notebook when moved.

According to its description, “The circuit is powered by the high-performance, low-power Atmel 8-bit AVR RISC-based microcontroller which combines 1KB ISP flash memory, 32B SRAM, 4 general purpose I/O lines, 16 general purpose working registers, a 16-bit timer/counter with two PWM channels, internal and external interrupts, programmable watchdog timer with internal oscillator, an internal calibrated oscillator, and 4 software selectable power saving modes.”

Clamshell_Half_Open_grande

“The board and clamshell were designed to make removal of the board easy for the purpose of enabling and replacing the battery. The battery is a standard watch cell CR2032. Based on our calculations, the LED should pulse approximately 9,000 times during the life of an average CR2032. Since the LED pulses three times on each movement cycle, that means that it unless you plan on picking up the book more than 3000 times, the battery should last a long time. But because it’s so cool, we think that you might actually reach that number — so we made it very easy to swap out the battery.”

An ideal gift for any Apple buff, those interested in learning more or buying the AVR powered book for a loved one can do so here.

This $11 robot can teach kids how to program

A group of Harvard University researchers — Michael Rubenstein, Bo Cimino, and Radhika Nagpal — have developed an $11 tool to educate young Makers on the fundamentals of robotics. Dubbed AERobot (short for Affordable Education Robot), the team hopes that it will one day help inspire more kids to explore STEM disciplines.

robot-kids-inline1

Fueled by the recent emergence of the Maker Movement, robots are becoming increasingly popular throughout schools in an effort to spur interest in programming and artificial intelligence among students.

The idea behind this particular project was conceived following the 2014 AFRON ellenge, which encouraged researchers to design low-cost robotic systems for education in Third World countries. As Wired’s Davey Alba notes, Rubenstein’s vast experience in swarm robotics led to him modding one of his existing systems to construct the so-called AERobot. While it may not be a swarm bot, the single machine possesses a number of the same inexpensive components.

So, what is the AERobot capable of doing?

  • Moving forward and backward on flat, smooth surfaces
  • Turning in place in both directions
  • Detecting the direction of incoming light
  • Identifying distances using reflected infrared light
  • Following lines and edges

With a megaAVR 8-bit microcontroller as its brains, the team assembled most of its other electronic parts with a pick-and-place machine, and to reduce costs some more, used vibration motors for locomotion and omitted chassis. AERobot is equipped with a built-in USB plug that also enables it to be directly inserted into any computer with a USB port — unlike a number of other bots.

“Using this USB connection, it can recharge its lithium-ion battery and be reprogrammed all without any additional hardware. AERobot has holonomic 2D motion; using two low-cost vibration motors, it can move forward, backwards, and turn in place on a flat, smooth surface such as a table or whiteboard. It also has three pairs of outward-pointing infrared transmitters and phototransistors, allowing it to detect distance to obstacles using reflected infrared light, and passively detect light sources using just the phototransistors.”

usb

In addition, the bot features one downward-pointing infrared transmitter along with a trio of infrared receivers to detect the reflectivity of the surface below, which is useful for line following. To aid in learning programs and debugging, AERobot also boasts an RGB LED.

On the software side, AERobot uses a graphical programming environment, which makes reprogramming easy for beginners. By modifying the minibloqs programming language, Rubenstein says you don’t really need to type code, instead you just drag pictures. He went on to tell Wired, “Say I wanted an LED on the robot to turn green. I would just drag over an image of an LED, and pick the green color.”

Interested in learning more? You can scroll on over to the project’s official page or read its entire Wired feature here.

 

Introducing the next-generation of 8-bit megaAVR MCUs

Since its initial launch in 2002, megaAVR microcontrollers (MCUs) have become the go-to choice of Makers everywhere. Ranging from the uber-popular ATmega328 to ATmega32U4, the chips can be found at the heart of millions of gadgets and gizmos, including an entire lineup of Arduino boards, 3D printers like RepRap and MakerBot, and innovative DIY platforms such as littleBits, Bare Conductive and MaKey MaKey. Heck, they’ve even captured the hearts of celebrity creator Sir Mix-A-Lot!

avr_campaign_simplyavr_980x352

Designed for engineers of all levels from the professional developers to the Maker community, the 8-bit megaAVR MCUs are ideal for applications in a variety of markets — automotive, industrial, consumer and white goods.

Today, we are excited to announce the next generation of this incredibly-popular family, with the debut of new 8-bit megaAVR MCUs. Spanning from 4KB to 16KB Flash memory, the new devices provide next-generation enhancements including additional analog functionality and features for the latest low-power consumer, industrial, white goods and Internet of Things (IoT) applications.

IMG_5056

This expansion of megaAVR family will deliver all the benefits of previous generations including a simple, easy-to-use interface for a seamless upgrade and binary compatibility with existing 8-bit megaAVR MCUs.

“With over 20 years of MCU experience, we are proud to launch our third generation of 8-bit megaAVR MCUs to the market today—a family that has been highly recognized by a variety of communities from the professional designers using our Atmel Studio ecosystem to the hobbyist and Maker in the AVR Freaks and Arduino communities,” explained Oyvind Strom, Atmel Senior Marketing Director. “As the leader in the 8-bit MCU market, Atmel continues to add easy-to-use, innovative products to our broad portfolio of MCUs.”

IMG_5058

Key features of megaAVR MCUs include:

  • Simple, easy-to-use
  • Low power
  • Wide selection of development tools including free Atmel Studio IDE
  • Extensive set of peripherals, including ADC, Analog Comparator, SPI, I2C and USART
  • Single-cycle instructions running 1MIPS per MHz
  • Designed for high-level languages with minimal code space
  • Real-time performance with single cycle I/O access

Among a number of other new attributes:

  • Unique ID for every device enabling a more secure device for IoT applications and wireless networks
  • Improved accuracy of internal oscillators for UART serial communications
  • Enhanced accuracy of internal voltage reference for better analog-to-digital conversion results

IMG_5059

Makers seeking to accelerate their design are encouraged to check out our ultra-low cost Xplained Mini development platform, which is currently available for only $8.88 USD (see what we did there?) in the Atmel Store and fully compatible with 8-bit megaAVR MCUs. The new boards can easily be connected to any Arduino board making it ideal for a variety of projects and prototypes using an Arduino board.

The megaAVR 8-bit MCUs are fully supported by Atmel’s development eco-system including Atmel Studio 6.2, the integrated development environment (IDE) for developing and debugging Atmel | SMART Cortex-M and Atmel AVR MCU-based applications. Atmel Studio 6.2 gives designers a seamless and easy-to-use environment to write, build, simulate, program and debug their applications to write, build, simulate, program and debug your applications written in C/C++ or assembly code using the integrated GCC compiler and AVR assembler. With Atmel’s broad portfolio of AVR products and easy-to-use development software, designers can quickly bring their 8-bit MCU to market. Additionally, designers have access to the company’s embedded software including the Atmel Software Framework and application notes, and the Atmel Gallery app store.

Currently on display at Electronica 2014, the Atmel mega168PB, mega88PB and mega48PB are now available in 32-pin QFN and QFP packages with additional devices slated for later this year. All devices are sampling now. Production quantities for the mega168PB devices are available now while the mega88PB and ATmega48PB devices will be available in February 2015.

Want to explore the AVR microcontrollers a bit further? Head on over to the official page. Those wishing to learn more about the backstory and inspiration of the Maker Movement’s favorite 8-bit MCU can do so from the co-inventor himself here.

Tutorial: Building cool projects with MCUs (Part 2)

I’ve always found microcontrollers really cool. After learning how to use MCUs, along with a few other electronics skills – I can’t really think of anything I am NOT able to build.

Okay, maybe not a time machine…

But when it comes to the electronics part of a project, knowing microcontrollers gives you the ability to build A LOT of different things.

Microcontroller circuit

In the previous part of this tutorial, we looked into the basics, and we established that a microcontroller is kind of like a tiny computer. You can connect things like a display, buttons or Wi-Fi, not to mention put programs onto it and run them.

In this segment, we are going to choose the microcontroller to use in our circuit. There are a gazillion options, so we’re going to use a tool to make things easier. But first, we need to figure out our requirements. Choosing a microcontroller becomes much easier once we know what we actually need.

Differences Between Microcontrollers

8-bit, 16-bit and 32-bit

A microcontroller comes in several bit sizes. You can find microcontrollers with 8-, 16- and 32-bit. This size refers to the size of the databus. With a larger databus, you can do more heavy calculations. In the hobbyist world, the 8-bit microcontroller is probably the most common of them all.

Usually, the 8-bit MCUs have fewer pins, and is therefore easier to solder onto a circuit board. In this microcontroller tutorial series, we’ll be keeping it as simple as possible, so we’re going to use an 8-bit.

Memory, Pins and Peripherals

Even an 8-bit microcontroller comes in a lot of different versions. Some have more memory. Some have more input and output pins. Some have USB interface. Some have analog to digital conversion. Some have SPI communication.

These extra functions – like USB or SPI – are called peripherals.

Chip on finger

Finding a Microcontroller for Our Circuit

My goal with this tutorial is to show you how to build a super simple microcontroller circuit.

One thing that affects how simple it is going to be is the programming method. How are we going to get the program we make onto the chip?

Often times, people use an external programmer or debugger that they connect to their microcontroller circuit, but I don’t want you to have to buy an extra tool for this. I want us to be able to just connect the circuit to a USB port on a computer and program it directly.

This leaves us with the following requirements:

  • Can be programmed through USB
  • Few components necessary
  • Possible to solder at home

We can make our circuit programmable through USB in a few different ways. For example, we can do this by adding a USB-to-serial chip onto our circuit – like they do on some of the Arduino boards.

However, since this will increase the number of components, a better solution is to find an MCU with USB interface included. It would also need a bootloader that can accept programming through USB.

Conveniently, some of Atmel’s microcontrollers come pre-loaded with a bootloader called USB DFU Bootloader.

To be able to solder the circuit at home, we want a chip with few pins. The fewer pins a microcontroller has, the easier it is to solder it. So let’s look for a chip with as few pins as possible.

The Microcontroller Selector

With our requirements in place, we can start looking for the perfect microcontroller. The Microcontroller Selector is a very useful tool that Atmel made to help you choose a microcontroller.

Using this tool, we can select what we need from our microcontroller, and it will show us which models that fit our criteria.

Using the Microcontroller Selector

We decided earlier to use an 8-bit MCU, so we select «8-bit AVR» under the «CPU» option.

Also, we want a USB interface. Specifically, we want a USB device interface. So under «USB» we select all the options that include «device».

Since we also want as few pins as possible, we’ll sort the results by number of pins.

Microcontroller Selector Tool

Doing this leaves us with five options that have 32 pins. No microcontroller matching our criteria has fewer than 32 pins., while a few options have more than 32 pins, so we can discard those.

One more criteria we are seeking is if the chip comes preloaded with the DFU bootloader. Unfortunately, we can’t select this criteria in the tool; yet, by looking into the documentation for the DFU bootloader, we can find a list of which microcontrollers are preloaded with this feature.

Here, we can see that one of our options, the ATmega8U2, does not have the bootloader. That leaves us with 4 options:

All of these match our requirements, so let’s just choose the one with the most amount of flash. The more flash we have, the bigger programs we can load onto the chip.

So, we’ll choose the ATmega32U2.

Designing the Circuit

Next, we will be designing the circuit. With the chip selected, I believe this will be pretty straightforward. Not too many components are necessary. Nevertheless, I am writing this as I am doing it – and I’ve never used this chip before – so there is always a chance of some surprises..

Stay tuned for Parts 3-5 in the coming days…

Deadline for Simply AVR Design Contest extended

Back in March, Atmel launched the second stage of its Simply AVR Design Contest, which challenged Makers, designers and engineers to develop clever, ground-breaking microcontroller-based designs using its popular AVR MCUs. After seeing a number of amazing designs come through over the last few months, we have decided to extend the deadline by two weeks — giving Makers inspired from Maker Faire New York and Rome a final chance to submit their 8-bit ideas!

simplyavrinfographic1

The Simply AVR first prize winner will receive $1,500 in cash, as well as some social media stardom across each of Atmel’s industry-leading channels. Each of the four runner-ups will claim a $500 cash prize, along with some coverage as well. Not too shabby!

So, why AVR? Atmel’s 8-bit microcontrollers offer Makers ease-of-use, low power consumption, and high level of integration all at their fingertips. Based on a single-cycle RISC engine that combines a rich instruction set, the incredibly-popular MCUs deliver close to 1 MIPS per megahertz and are optimized for minimum code size and maximum computing performance. Ideal for a broad range of applications — including industrial control, ZigBee and RF, medical and utility metering, communication gateways, sensor control, white goods and portable battery-powered products — AVR accelerates the time it takes to bring an idea to life.

Looking for some last-minute inspiration? This video from Analog Aficionado Paul Rako may help do the trick.

Whether you’re in the process of completing or still brainstorming your next design, don’t forget to enter your project today! Deadline is October 17, 2014.

The Arduino Yún turns one

The Arduino Yún – which was designed in collaboration with Dog Hunter – is based on Atmel’s ATmega32u4 microcontroller (MCU) and also features the Atheros AR9331, an SoC running Linino, a customized version of OpenWRT. Now, one year later, the Yún celebrates its one-year anniversary! With over 9,200 forum posts, 8 OpenWrt-Yún releases and 492,000 search results, the AVR based board has become quite a hit for Makers. We think this deserves an Arduino high-five, for sure!

Made available last September, the Yún was a somewhat unique addition to the existing Arduino line-up, as it boasts a lightweight Linux distribution to complement the traditional MCU interface.

Yún, which means “cloud” in Chinese, aspired to make it simple to connect to complex web services directly from Arduino. The board features WiFi and Ethernet connections, therefore enabling the board to communicate with networks out of the box. Additionally, the Yún’s Linux and Arduino processors link through the Bridge library, enabling Arduino sketches to send commands to the command line interface of Linux.

“The Arduino Yún has the same footprint as an Arduino Uno but combines an ATmega32u4 microcontroller (the same as the Leonardo) and a Linux system based on the Atheros AR9331 chipset,” Arduino’s Federico Vanzati explained. “Additionally, there are built-in Ethernet and WiFi capabilities. The combination of the classic Arduino programming experience and advanced internet capabilities afforded by a Linux system make the Yún a powerful tool for communicating with the internet of things (IoT).”

According to Vanzati, the Yún’s layout keeps the I/O pins the same as the Leonardo and is therefore compatible with the most shields designed for Arduino.

“With the Yún’s auto-discovery system, your computer can recognize boards connected to the same network. This enables you to upload sketches wirelessly to the Yún,” he continued. “You can still upload sketches to the Yún through the micro-USB connector just as you would with the Leonardo.”

On the connectivity side, the Yún is equipped with two separate network interfaces, a 10/100 Mbit/s Fast Ethernet port and a IEEE 802.11 b/g/n standard compliant 2.4GHz WiFi interface, supporting WEP, WPA and WPA2 encryption. As expected, the WiFi interface can also operate as an access point (AP). In AP mode any WiFi enabled device can connect directly to the network created on the Yún. While a Yún in this mode can’t connect to the internet, it could act as a hub for a group of WiFi enabled sensors.

YunResetIllustrations.png

As Vanzati notes, interfacing Arduino with web services has historically been rather challenging due to memory restrictions.

“[However], the Yun’s Linux environment simplifies the means to access internet services by using many of the same tools you would use on your computer,” he said. “You can run several applications as complex as you need, without stressing the ATmega microcontroller.”

To help engineers and Makers develop applications that can connect to popular web services, Arduini has partnered with Temboo, a service that simplifies accessing hundreds of the web’s most popular APIs. In fact, a Temboo library is packaged with the Yún, making it easy to connect to a large variety of online tools.

Facilitating a seamless connection between the two processors is achieved via the Yún’s Bridge library, which connects the hardware serial port of the AR9331 to Serial1 on the 32U4 (digital pins 0 & 1).

“The serial port of the AR9331 exposes the Linux console (aka, the command line interface, or CLI) for communication with the 32U4,” Vanzati confirmed. “The console is a means for the Linux kernel and other processes to output messages to the user and receive input from the user. File and system management tools are installed by default. It’s also possible to install and run your own applications using Bridge.”

Of course, the ATmega32u4 can also be programmed from the AR9331 by uploading a sketch through the Yún’s WiFi interface. When connected to the same WiFi network as your computer, the board will appear under the “Port” menu of the Arduino IDE. The sketch will be transferred to the AR9331 and the Linux distribution will program the ATmega32u4 through the SPI bus, emulating an AVR ISP programmer.

Last, but certainly not least, the Yún can be powered through the micro-USB connector, the Vin pin, or the optional Power Over Ethernet (POE) module. When powering the board though the Vin pin, users must supply a regulated 5VDC, as there is no on-board regulator for higher voltages.

As we come together to celebrate the Yún’s birthday, feel free to browse the latest projects powered by the board or access more information on the board’s official page here.

Don’t forget to join the Atmel team in Queens later this week for the 5th Annual World Maker Faire. Undoubtedly, this year will be amazing as an expected 750+ Makers and 85,000+ attendees head to the New York Hall of Science to see the latest DIY gizmos and gadgets, as well as AVR Man in the flesh. Once again a Silversmith Sponsor of the event, Atmel will put the spotlight on everything from Arduino to Arduino-related projects. See you soon!