The Arduino Uno is one of the most popular microcontroller boards used by hobbyists, engineers, and makers around the world. With its easy-to-use hardware and software, ability to interface with a wide variety of sensors and devices, and large community support, the Arduino Uno has become the go-to option for many projects requiring a programmable microcontroller.
But what type of microcontroller and processor architecture does the Arduino Uno use? Is it based on ARM or something else?
The simple answer is no, the Arduino Uno is not ARM-based. It uses the ATmega328P 8-bit AVR microcontroller which has an AVR RISC architecture developed by Atmel (now Microchip).
The Microcontroller Inside the Arduino Uno
The microcontroller is the brain of any Arduino board. It’s the chip that actually runs the user’s sketch or program. In the case of the Arduino Uno, the microcontroller is the ATmega328P.
The ATmega328P is an 8-bit microcontroller based on AVR RISC architecture. It has:
- 32KB of flash memory for storing code
- 2KB of SRAM for storing variables
- 1KB of EEPROM for storing long-term data
- 23 general purpose I/O pins
- 32 general purpose registers
- Three types of internal timers
- Internal and external interrupts
- SPI and I2C communication interfaces
- 6 channel ADC
- Programmable watchdog timer
- 16MHz maximum clock speed
The ATmega328P runs on a 16MHz crystal oscillator mounted on the Arduino Uno board. It can be powered from an external supply (6-20V) or via USB connection. The operating voltage is 5V.
The ATmega328P is based on AVR 8-bit RISC architecture originally developed by Atmel in 1996. AVR stands for Alf and Vegard’s RISC processor, named after the two Norwegian developers who created it.
Some key features of AVR architecture:
- Uses 8-bit data model and 16-bit address space
- Has 32 general purpose 8-bit registers
- Single-cycle execution for most instructions
- On-chip flash memory for storing code
- In-system programmable using serial/parallel interface
- Rich instruction set optimized for controller applications
- Extensive peripheral features like timers, ADC, etc
The RISC (Reduced Instruction Set Computing) design of AVR architecture gives it several advantages like high performance, low power consumption, and ease of programming. AVR chips have been used in various applications including automotive systems, IoT devices, audio/video processing, handheld meters, robotics, and of course development boards like the Arduino Uno.
Differences from ARM Architecture
ARM and AVR represent two completely different processor architectures with their own strengths and weaknesses.
Some key differences between ARM and AVR:
- ARM is 32-bit, AVR is 8-bit
- ARM has reduced instruction set (RISC), AVR has denser instruction set
- ARM has load-store architecture, AVR can work directly on registers
- ARM has more general purpose registers (13-32), AVR has fewer (32)
- ARM focuses on performance, AVR focuses on code density
- ARM has advanced features like multi-core, AVR is single-core
- ARM has memory protection units, AVR does not
- AVR chips are generally lower power and cost compared to many ARM chips
Due to its 8-bit architecture and smaller size, AVR microcontrollers like the ATmega328P tend to be low cost, low power processors aimed at simple embedded applications. They excel in lower-end control systems, basic measurement systems, motor control, etc.
In comparison, ARM processors are much more full-featured and suitable for advanced applications like smartphones, tablets, IoT devices, automotive systems, robotics, etc. But ARM cores are more complex to program at lower levels.
Why Arduino Uses AVR and Not ARM
The creators of Arduino – Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis – began the project in 2005 as a simple and accessible open-source microcontroller platform for hobbyists and non-engineers. The goal was to make it easier for normal people to create interactive projects.
They chose the AVR architecture because:
- AVR chips were inexpensive and readily available at the time
- AVR architecture was well-documented
- AVR instruction set allowed high-level languages like C to be used
- AVR chips were easy to program and prototype with
- Wide range of AVR chip options to choose from for different needs
ARM chips at that time were not as easily accessible to hobbyists. They were also more expensive, complex, and designed for advanced applications that required operating systems.
The AVR-based Arduino boards became very successful among hobbyists and makers. AVR chips continue to be used on current Arduino boards because of their simplicity, ease-of-use, low cost, and large community support.
Arduino Boards That Use ARM
While the original Arduino Uno and Mega boards use AVR chips, several official Arduino boards have been released in recent years that use ARM processors. Some examples are:
- Arduino Due – Uses Atmel SAM3X8E ARM Cortex-M3 CPU
- Arduino Zero – Has Atmel ATSAMD21G18 ARM Cortex-M0+ processor
- Arduino MKR1000 – Runs on Microchip ATSAMW25 SoC with ARM Cortex-M0+ core
- Arduino Portenta H7 – STM32H747XI dual-core ARM Cortex-M7 and -M4 chips
These boards offer significantly better performance compared to 8-bit AVR, with features like faster clock speeds, more memory, floating point support, digital signal processing, and better connectivity options. They are great for more complex projects involving audio, video, graphics, computer vision, machine learning, etc.
However, for many basic Arduino projects the 8-bit AVR boards like Uno and Mega provide enough capabilities at lower cost and easier usage. The large existing software libraries for AVR also make them convenient to get started with.
The Arduino Uno uses an 8-bit AVR RISC microcontroller and not an ARM-based processor. The ATmega328P AVR chip provides a good combination of simplicity, low cost, and large community support for hobbyists and educational use.
However, for applications requiring more processing power, connectivity, and advanced features, ARM-based Arduino boards like Due, Zero, and Portenta are available. But ARM comes with its own higher complexity and cost.
So in summary: Arduino Uno is AVR-based, more advanced Arduinos use ARM, and each architecture has its own pros and cons for different types of projects.