AVR microcontrollers: Difference between revisions

Revision as of 09:32, 25 July 2024

Latest revision as of 03:58, 10 August 2025

(39 intermediate revisions by 21 users not shown)

Line 1:

{{Short description|Family of microcontrollers}}

{{About|the series of AVR microcontrollers|the AVR instruction set|Atmel AVR instruction set}}

{{Confuse|automatic voltage regulator}}

[[File:Avr_logo.svg|right|thumb|AVR logo]]

[[File:AVR_group.jpg|right|thumb|Various older AVR microcontrollers: ATmega8 in 28-pin narrow dual in-line package ([[Dual in-line package|DIP]]-28N), ATxmega128A1 in 100-pin thin quad flat pack ([[TQFP]]-100) package, ATtiny45 in 8-pin small outline ([[Small Outline Integrated Circuit|SO]]-8) package.]]

[[File:ATMEGA328P-PU.jpg|right|thumb|[[ATmega328]]P in 28-pin narrow dual in-line package ([[Dual in-line package|DIP]]-28N). It is commonly found on [[Arduino]] boards.]]

'''AVR''' is a family of [[microcontrollers]] developed since 1996 by [[Atmel]], acquired by [[Microchip Technology]] in 2016. TheseThey are [[modified Harvard architecture]] [[8-bit]] [[Reduced instruction set computer|RISC]] single-chip microcontrollers based on a modified Harvard architecture. AVR was one of the first microcontroller families to use on-chip [[flash memory]] for program storage, as opposed to [[Programmable read-only memory|one-time programmable ROM]], [[EPROM]], or [[EEPROM]] used by other microcontrollers at the time.

AVR microcontrollers findare manyused applicationsnumerously as [[embedded system]]s. They are especially common in hobbyist and educational embedded applications, popularized by their inclusion in many of the [[Arduino]] line of [[open hardware]] development boards.

The AVR 8-bit microcontroller architecture was introduced in 1997. By 2003, Atmel had shipped 500 million AVR flash microcontrollers.<ref>Atmel press release. [http://www.prnewswire.com/news-releases/atmels-avr-microcontroller-ships-500-million-units-72278687.html "Atmel's AVR Microcontroller Ships 500 Million Units"].</ref>

== History ==

Line 15 ⟶ 18:

Atmel says that the name AVR is not an acronym and does not stand for anything in particular. The creators of the AVR give no definitive answer as to what the term "AVR" stands for.<ref name="storyofavr" /> However, it is commonly accepted that AVR stands for '''A'''lf and '''V'''egard's '''R'''ISC processor.<ref>{{cite web|title=UNSW School of Computer Science and Engineering - General AVR Info|url=http://www.cse.unsw.edu.au/~pcb/avr/avr.html|url-status=dead|archive-url=https://web.archive.org/web/20120623131604/http://www.cse.unsw.edu.au/~pcb/avr/avr.html|archive-date=2012-06-23|access-date=2012-09-19|publisher=Cse.unsw.edu.au}}</ref> Note that the use of "AVR" in this article generally refers to the 8-bit RISC line of Atmel AVR microcontrollers.

The original AVR MCU was developed at a local [[Application-specific integrated circuit|ASIC]] house{{Clarify|reason=Meaningdesign of the phrase is unclear.|date=January 2023}}company in [[Trondheim, Norway]], called Nordic VLSI at the time, now [[Nordic Semiconductor]], where Bogen and Wollan were working as students.{{Citation needed|date=December 2010}} It was known as a μRISC (Micro RISC)<ref name="NTNU">[https://www.itk.ntnu.no/fag/TTK4155/2004/foiler_forelesninger/Atmel_AVR_Forelesning.pdf An introduction to Atmel and the AVR microcontroller]{{Dead link|date=February 2023 |bot=InternetArchiveBot |fix-attempted=yes }}</ref> and was available as silicon IP/building block from Nordic VLSI.<ref>{{Cite web |url=http://www.idi.ntnu.no/~dam/fag/digdat/DigDat301002.pdf |title=Embedded Systems and Microcontrollers |access-date=2018-10-01 |archive-url=https://web.archive.org/web/20041224014455/http://www.idi.ntnu.no/~dam/fag/digdat/DigDat301002.pdf |archive-date=2004-12-24 |url-status=dead }}</ref> When the technology was sold to Atmel from Nordic [[Very-large-scale integration|VLSI]], the internal architecture was further developed by Bogen and Wollan at Atmel Norway, a subsidiary of Atmel. The designers worked closely with compiler writers at [[IAR Systems]] to ensure that the AVR instruction set provided efficient [[Compiler|compilation]] of [[High-level programming language|high-level languages]].<ref name="codesign">{{cite book|url=http://www.atmel.com/dyn/resources/prod_documents/COMPILER.pdf|title=The AVR Microcontroller and C Compiler Co-Design|last=Myklebust|first=Gaute|publisher=Atmel Norway|citeseerx=10.1.1.63.1447|access-date=2012-09-19}}</ref>

Among the first of the AVR line was the AT90S8515, which in a 40-pin DIP package has the same pinout as an [[Intel 8051|8051]] microcontroller, including the external multiplexed address and data bus. The polarity of the <span style="text-decoration: overline">RESET</span> line was opposite (8051's having an active-high RESET, while the AVR has an active-low <span style="text-decoration: overline">RESET</span>), but other than that the pinout was identical.

The AVR 8-bit microcontroller architecture was introduced in 1997. By 2003, Atmel had shipped 500 million AVR flash microcontrollers.<ref>Atmel press release. [http://www.prnewswire.com/news-releases/atmels-avr-microcontroller-ships-500-million-units-72278687.html "Atmel's AVR Microcontroller Ships 500 Million Units"].</ref> The [[Arduino]] platform, developed for simple electronics projects, was released in 2005 and featured ATmega8 AVR microcontrollers.

== Device overview ==

Line 47 ⟶ 50:

* Peripherals equal to or exceed megaAVR 0-series

* Event System

* Improved AVRxt instruction set (improved timing of calls), hardware multiply

'''megaAVR''' – the ATmega series

Line 68 ⟶ 71:

* Event system

* New peripherals with enhanced functionality

* Improved AVRxt instruction set (improved timing of calls)

'''AVR Dx''' – The AVR Dx family is featuringfeatures multiple microcontroller series, focused on [[human–computer interaction|HCI]], analog signal conditioning and functional safety.

{| class="wikitable"

Line 92 ⟶ 95:

* 12-bit ADC

* 10-bit DAC

* '''AVR DA-series''' (early 2020) – The high memory density makes these MCUs well suited for both wired and wireless communication-stack-intensive functions.

** integrated sensors for capacitative touch measurement ([[Human–computer interaction|HCI]])

** offersupdated thecore latestindependent peripherals ([[Autonomous peripheral operation|CIPs]]) and a robust integrated analog portfolioperipherals

** no external high frequency crystal

* '''AVR DB-series''' (mid-late 2020) – inherits many features from the DA-family, while adding its own:

** 2 or 3 on-chip opamps

** MultiVoltage IO (MVIO) on PORTC

** Supports external HF crystal

* '''AVR DD-series'''

** 16–64 KiB Flash

* '''AVR DD-series''' (not yet released {{As of|2021|September}}) – small package microcontrollers designed to bring real-time control and multi-voltage operation to applications industrial control, home appliance products, automotive, and Internet of Things (IoT).

** 2–8 KiB SRAM

** MVIO support on 3 or 4 pins

** 14–32-pin package

** internal 24&nbsp;MHz oscillator

* '''AVR EA-series''' (not yet released {{As of|2021|September}})

** 7–23-channel 130 kS/s 12-bit differential Analog-to-Digital Converter (ADC)

** 8–64k flash

** no amplifiers

** 1 analog comparator

** Two USARTs, one SPI, one dual-mode TWI

** Multi-Voltage Input/Output (MVIO) support on 3 or 4 pins on Port C

** 4 Configurable Custom Logic (CCL) cells, 6 Event System channels

* '''AVR EA-series'''

** 8–64 KiB Flash

** 28–48-pin package

** internal 20&nbsp;MHz oscillator

** 24–32-channel 130 kS/s 12-bit differential Analog-to-Digital Converter (ADC)

** Programmable Gain Amplifier (PGA) with up to 16x gain

** 2 analog comparators

** Three USARTs, one SPI, one dual-mode TWI

** no Multi-Voltage Input/Output (MVIO)

** 4 Configurable Custom Logic (CCL) cells, 6 Event System channels

'''XMEGA'''

Line 157 ⟶ 172:

==== Internal registers ====

In the tinyAVR and megaAVR variants of the [[Atmel AVR instruction set|AVR architecture]], the working registers are mapped in as the first 32 data memory addresses (0000₁₆–001F₁₆), followed by 64 I/O registers (0020₁₆–005F₁₆). In devices with many peripherals, these registers are followed by 160 “extended I/O” registers, only accessible as [[memory-mapped I/O]] (0060₁₆–00FF₁₆).

Line 168 ⟶ 182:

In the XMEGA variant, the working register file is not mapped into the data address space; as such, it is not possible to treat any of the XMEGA's working registers as though they were SRAM. Instead, the I/O registers are mapped into the data address space starting at the very beginning of the address space. Additionally, the amount of data address space dedicated to I/O registers has grown substantially to 4096 bytes (0000₁₆–0FFF₁₆). As with previous generations, however, the fast I/O manipulation instructions can only reach the first 64 I/O register locations (the first 32 locations for bitwise instructions). Following the I/O registers, the XMEGA series sets aside a 4096 byte range of the data address space, which can be used optionally for mapping the internal EEPROM to the data address space (1000₁₆–1FFF₁₆). The actual SRAM is located after these ranges, starting at 2000₁₆.

==== General-purpose input/output (GPIO) ports ====

Each [[GPIO]] port on a tiny or mega AVR drives up to eight pins and is controlled by three 8-bit registers: DDR''x'', PORT''x'' and PIN''x'', where ''x'' is the port identifier.

Line 175 ⟶ 189:

* PIN''x'': Input register, used to read an input signal. On some devices, this register can be used for pin toggling: writing a logic one to a PIN''x'' bit toggles the corresponding bit in PORT''x'', irrespective of the setting of the DDR''x'' bit.<ref>[http://www.atmel.com/Images/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet.pdf atmel.com]</ref>

Newer ATtiny AVR'sAVRs, like ATtiny817 and its siblings, have their port control registers somewhat differently defined.

xmegaAVR have additional registers for push/pull, totem-pole and pullup configurations.

Line 188 ⟶ 202:

=== Program execution ===

Atmel's AVRs have a two-stage, single-level [[Pipeline (computing)|pipeline]] design., Thismeaning meansthat the next machine instruction is fetched as the current one is executing. Most instructions take just one or two clock cycles, making AVRs relatively fast among [[eight-bit]] microcontrollers.

The AVR processors were designed with the efficient execution of [[Compiler|compiled]] [[C (programming language)|C]] code in mind and have several built-in pointers for the task.

Line 194 ⟶ 208:

=== Instruction set ===

{{Main|Atmel AVR instruction set}}

The [[Atmel AVR instruction set|AVR instruction set]] is more [[Orthogonal instruction set|orthogonal]] than those of most eight-bit microcontrollers, in particular the [[Intel 8051|8051 clones]] and [[PIC microcontroller]]s with which AVR competeshas todaycompeted. However, it is not completely regular:

* [[Pointer register]]s X, Y, and Z have addressing capabilities that are different from each other.

Line 202 ⟶ 216:

* Accessing read-only data stored in the program memory (flash) requires special LPM instructions; the flash bus is otherwise reserved for instruction memory.

Additionally, someSome chip-specific differences affect code generation. Code pointers (including return addresses on the stack) are two bytes long on chips with up to 128&nbsp;KB of flash memory, but three bytes long on larger chips; not all chips have hardware multipliers; chips with over 8&nbsp;KB of flash have branch and call instructions with longer ranges; and so forth.

The mostly regular instruction set makes C (and even Ada) compilers fairly straightforward and efficient. [[GNU Compiler Collection|GCC]] has included AVR support for quite some time, and that support is widely used. [[LLVM]] also has rudimentary AVR support. In fact, Atmel solicited input from major developers of compilers for small microcontrollers, to determine the instruction set features that were most useful in a compiler for high-level languages.<ref name="codesign" />

Line 213 ⟶ 227:

=== Development ===

AVRs have a large following due to the free and inexpensive development tools available, including reasonably priced development boards and free development software. The AVRs are sold under various names that share the same basic core, but with different peripheral and memory combinations. Compatibility between chips in each family is fairly good, although I/O controller features may vary.

The Atmel AVR GNU C/C++ [[cross compiler]], "avr-gcc" and "avr-g++", is used in both WinAVR and Atmel Studio.<ref>

Microchip.

[https://www.microchip.com/en-us/tools-resources/develop/microchip-studio/gcc-compilers "Toolchains for AVR Microcontrollers (MCUs)"].

</ref><ref>

Timothy S Margush.

"Some Assembly Required: Assembly Language Programming with the AVR Microcontroller".

2016.

[https://www.google.com/books/edition/Some_Assembly_Required/n5E3EQAAQBAJ?gbpv=1&pg=PA539 "Chapter 14: Programming the AVR in C"].

p. 539

</ref><ref>

J. M. Hughes.

[https://www.google.com/books/edition/Arduino_A_Technical_Reference/7oMpDAAAQBAJ "Arduino: A Technical Reference"].

2016.

p. 127-131.

</ref><ref>

Joe Pardue.

[https://www.google.com/books/edition/C_Programming_for_Microcontrollers/jAzuNAAACAAJ "C Programming for Microcontrollers: Featuring ATMEL's AVR Butterfly and the Free WinAVR Compiler"].

2005.

</ref><ref>

Elliot Williams.

[https://www.google.com/books/edition/AVR_Programming/y7C2AgAAQBAJ "AVR Programming"].

2014.

</ref>

The Arduino team borrowed from WinAVR for the Windows version of the [[Arduino Software|Arduino software]].<ref>

Dale Wheat.

[https://www.google.com/books/edition/Arduino_Internals/U6EtJwBzY1oC "Arduino Internals"].

2011.

p. 227.

</ref>

See [[#External links|external links]] for sites relating to AVR development.

Line 225 ⟶ 269:

** Optional boot code section with independent lock bits for protection

* On-chip debugging (OCD) support through JTAG or [[debugWIRE]] on most devices

** The JTAG signals (TMS, TDI, TDO, and TCK) are multiplexed on [[General Purpose Input/Output|GPIOs]]. These pins can be configured to function as JTAG or GPIO depending on the setting of a [[fuse bit]], which can be programmed via [[in-system programming]] (ISP) or HVSP. By default, AVRs with JTAG come with the JTAG interface enabled.

** [[debugWIRE]] uses the /RESET pin as a bi-directional communication channel to access on-chip debug circuitry. It is present on devices with lower pin counts, as it only requires one pin.

* Internal data [[EEPROM]] up to 4&nbsp;KB

Line 235 ⟶ 279:

** [[Pulse-width modulation|PWM]] output (some devices have an enhanced PWM peripheral which includes a dead-time generator)

** Input capture that record a time stamp triggered by a signal edge

* Analoganalog comparator

* 10 or 12-bit [[Analog-to-digital converter|A/D converters]], with multiplex of up to 16 channels

* 12-bit [[Digital-to-analog converter|D/A converters]]

Line 274 ⟶ 318:

=== UPDI ===

The Unified Program and Debug Interface (UPDI) is a one-wire interface for external programming and on-chip debugging of newer ATtiny and ATmega devices. TheUPDI Atmel-ICEchips andcan PICkitbe 4programmed areby capablean ofAtmel-ICE, programminga UPDIPICkit chips. It is also possible to use4, an Arduino thanks(flashed towith jtag2updi),<ref>{{Cite web|url=https://github.com/ElTangas/jtag2updi|title = GitHub - ElTangas/Jtag2updi: UPDI programmer software for Arduino (Targets Tiny AVR-0/1/2, Mega AVR-0 and AVR-DA/DB MCUs)|website = [[GitHub]]|date = 17 December 2021}}</ref> or athough standarda USB-UART adapter (with a {{nowrap|1 kΩ}} resistor between the TX and RX pinpins) shortedcontrolled by aMicrochip's 1[[Python kΩ(programming resistorlanguage)|Python]] and theutility pymcuprog utility provided by Microchip.<ref>{{cite web |title=pymcuprog - Python MCU programmer |url=https://github.com/microchip-pic-avr-tools/pymcuprog#serial-port-updi-pyupdi |website=Github |publisher=Microchip PIC&AVR Tools |access-date=18 November 2022 |date=13 November 2022}}</ref>

=== High-voltage serial ===

High-voltage serial programming (HVSP)<ref>{{cite web|url=http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/AVRDragon/AVRDragon_HVSP_Description.htm|title=HVSP_Description|publisher=Support.atmel.no|url-status=dead|archive-url=https://web.archive.org/web/20091012094540/http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/AVRDragon/AVRDragon_HVSP_Description.htm|archive-date=2009-10-12|access-date=2012-09-19}}</ref> is mostly the backup mode on smaller AVRs. An 8-pin AVR package does not leave many unique signal combinations to place the AVR into a programming mode. A 12-volt signal, however, is something the AVR should only see during programming and never during normal operation. The high voltage mode can also be used in some devices where the reset pin has beenwas disabled by fuses.

=== High-voltage parallel ===

Line 286 ⟶ 330:

=== ROM ===

The AT90SC series of AVRs are available with a factory mask-ROM rather than flash for program memory, instead of flash.<ref>{{cite web|url=https://pdfslide.net/reader/f/atmel-avr-wikipedia-the-free-encyclopediapdf|title=Atmel's Self-Programming Flash Microcontrollers|format=PDF|access-date=12 March 2020}}</ref> Because of the large up-front cost and minimum order quantity, a mask-ROM is only cost-effective for high-production runs.

=== aWire ===

Line 297 ⟶ 341:

=== debugWIRE ===

{{Main|debugWIRE}}

[[debugWIRE]] is Atmel's solution for providing on-chip debug capabilities via a single microcontroller pin. It is particularly useful for lower pin -count parts which cannot provide the four "spare" pins needed for JTAG. The JTAGICE mkII, mkIII and the AVR Dragon support debugWIRE. debugWIRE was developed after the original JTAGICE release, and now clones support it.

=== JTAG ===

Line 307 ⟶ 351:

# The JTAGICE 3<ref>{{cite web|url=http://www.atmel.com/dyn/products/tools_card.asp?tool_id=17213&category_id=163&family_id=607&subfamily_id=2138|title=JTAGICE 3- Atmel Corporation|publisher=Atmel.com|access-date=2012-09-19}}</ref> is a midrange debugger in the JTAGICE family (JTAGICE mkIII). It supports JTAG, aWire, SPI, and PDI interfaces.

# The JTAGICE mkII<ref>{{cite web|url=http://qaswww.atmel.com/tools/avrjtagicemkii.aspx|title=AVR JTAGICE mkII|work=Atmel|url-status=dead|archive-url=https://archive.today/20130215133712/http://qaswww.atmel.com/tools/avrjtagicemkii.aspx|archive-date=15 February 2013|access-date=13 January 2013}}</ref> replaces the JTAGICE and is similarly priced. The JTAGICE mkII interfaces to the PC via USB, and supports both JTAG and the newer debugWIRE interface. Numerous third-party clones of the Atmel JTAGICE mkII device started shipping after Atmel released the communication protocol.<ref>{{cite web|url=http://www.atmel.com/dyn/resources/prod_documents/doc2587.pdf |archive-url=https://web.archive.org/web/20050516182708/http://www.atmel.com/dyn/resources/prod_documents/doc2587.pdf |archive-date=2005-05-16 |url-status=live|title=JTAGICE mkII Communication Protocol|access-date=2012-09-19}}</ref>

# The AVR Dragon<ref>{{cite web|url=http://www.atmel.com/tools/avrdragon.aspx|title=AVR Dragon|work=Atmel|access-date=13 January 2013}}</ref> is a low-cost (approximately $50) substitute for the JTAGICE mkII for certain target parts. The AVR Dragon provides in-system serial programming, high-voltage serial programming and parallel programming, as well as JTAG or debugWIRE emulation for parts with 32&nbsp;KB of program memory or less. ATMEL changed the debugging feature of AVR Dragon with the latest firmware of AVR Studio 4 -– AVR Studio 5 and now it supports devices over 32&nbsp;KB of program memory.

# The JTAGICE adapter interfaces to the PC via a standard serial port.<ref>{{Cite web|url=http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42710-AVR-JTAGICE-mkII_UserGuide.pdf |archive-url=https://web.archive.org/web/20170702215107/http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42710-AVR-JTAGICE-mkII_UserGuide.pdf |archive-date=2017-07-02 |url-status=live|title=AVR JTAGICE mkII User's Guide|website=microchip.com|access-date=25 March 2020}}</ref> Although the JTAGICE adapter has been declared "[[End-of-life (product)|end-of-life]]" by Atmel, it is still supported in AVR Studio and other tools.

Line 449 ⟶ 493:

=== JTAGICE ===

The [[JTAG]] In Circuit Emulator (JTAGICE) debugging tool supports on-chip debugging (OCD) of AVRs with a JTAG interface. The original JTAGICE (sometimes retroactively referred to as JTAGICE mkI) uses an RS-232 interface to a PC and can only program AVR'sAVRs with a JTAG interface. The JTAGICE mkI is no longer in production, however it has been replaced by the JTAGICE mkII.

=== JTAGICE mkII ===

Line 485 ⟶ 529:

The RAVEN kit supports wireless development using Atmel's [[IEEE 802.15.4]] chipsets, for [[Zigbee]] and other wireless stacks. It resembles a pair of wireless more-powerful Butterfly cards, plus a wireless USBKey; and costing about that much (under $US100). All these boards support JTAG-based development.

The kit includes two AVR Raven boards, each with a 2.4&nbsp;GHz transceiver supporting IEEE 802.15.4 (and a freely licensed Zigbee stack). The radios are driven with ATmega1284p processors, which are supported by a custom [[segmented LCD display]] driven by an ATmega3290p processor. Raven peripherals resemble the Butterfly: piezo speaker, DataFlash (bigger), external EEPROM, sensors, 32&nbsp;kHz crystal for [[Real-time clock|RTC]], and so on. These are intended for use in developing remote sensor nodes, to control relays, or whatever is needed.

The USB stick uses an AT90USB1287 for connections to a USB host and to the 2.4&nbsp;GHz wireless links. These are intended to monitor and control the remote nodes, relying on host power rather than local batteries.

Line 502 ⟶ 546:

USB-based AVRs have been used in the Microsoft Xbox hand controllers. The link between the controllers and Xbox is USB.

Numerous companies produce AVR-based microcontroller boards intended for use by hobbyists, robot builders, experimenters and small system developers including: Cubloc,<ref>{{cite web|url=http://www.cubloc.com/|title=Comfile Technology|publisher=Comfile Technology, Inc.|access-date=13 January 2013|archive-date=17 January 2013|archive-url=https://web.archive.org/web/20130117112843/http://www.cubloc.com/|url-status=dead}}</ref> gnusb,<ref>{{cite web|url=httphttps://gnusb.sourceforge.net/|title=gnusb: Open Source USB Sensor Box|access-date=13 January 2013}}</ref> [[BasicX]],<ref>{{cite web|url=http://www.basicx.com/|title=BasicX|publisher=NetMedia, Inc.|access-date=13 January 2013|archive-url=https://web.archive.org/web/20130523182113/http://basicx.com/|archive-date=23 May 2013|url-status=dead}}</ref> Oak Micros,<ref>{{cite web|url=http://oakmicros.com/content/index.php|title=Welcome to Oak Micros|work=Oak Micros|publisher=Oak Micros|url-status=dead|archive-url=https://web.archive.org/web/20121025082936/http://oakmicros.com/content/index.php|archive-date=2012-10-25|access-date=13 January 2013}}</ref> ZX Microcontrollers,<ref>{{cite web|url=http://www.zbasic.net/|title=ZBasic|access-date=13 January 2013}}</ref> and myAVR.<ref>{{cite web|url=http://www.myavr.com/|title=myAVR|publisher=Laser & Co. Solutions GmbH|access-date=13 January 2013}}</ref> There is also a large community of [[Arduino-compatible boards]] supporting similar users.

[[Schneider Electric]] used to produce the M3000 Motor and Motion Control Chip, incorporating an Atmel AVR Core and an advanced motion controller for use in a variety of motion applications but this has been discontinued.<ref>{{cite web|url=http://www.imshome.com/products/m3000.html|title=M3000 Motion controller on a chip|work=imshome.com|publisher=Schneider Electric Motion USA|url-status=dead|archive-url=https://web.archive.org/web/20091202120117/http://www.imshome.com/products/m3000.html|archive-date=2009-12-02|access-date=2011-08-02}}</ref>

Line 512 ⟶ 556:

* avr_core,<ref>{{cite web|url=http://opencores.org/project,avr_core|title=AVR Core :: Overview|publisher=OpenCores|access-date=2012-09-19}}</ref> written in [[VHDL]], is a clone aimed at being as close as possible to the ATmega103.

* Navré,<ref>{{cite web|url=http://opencores.org/project,navre|title=Navré AVR clone (8-bit RISC) Overview|publisher=OpenCores|access-date=2012-09-19}}</ref> written in [[Verilog]], implements all [[Atmel AVR instruction set|Classic Core]] instructions and is aimed at high performance and low resource usage. It does not support [[interrupt]]s.

* softavrcore,<ref>{{cite web|url=https://opencores.org/projects/softavrcore|title=Soft AVR Core + Interfaces Overview|publisher=OpenCores|access-date=2020-06-16}}</ref> written in [[Verilog]], implements the [[AVR instruction set]] up to AVR5, supports interrupts along with optional automatic interrupt acknowledgement, power saving via [[Idle (CPU)|sleep mode]] plus some peripheral interfaces and [[Hardware_accelerationHardware acceleration|hardware accelerators]] (such as [[UART]], [[Serial_Peripheral_InterfaceSerial Peripheral Interface|SPI]], [[cyclic redundancy check]] calculation unit and [[Programmable_interval_timerProgrammable interval timer|system timers]]). These peripherals demonstrate how could these be attached to and configured for this core. Within the package, a full-featured [[FreeRTOS]] port is also available as an example for the core + peripheral utilization.

* The opencores project CPU lecture<ref>{{cite web|url=http://opencores.org/project,cpu_lecture|title=CPU lecture|publisher=OpenCores|access-date=2015-02-16}}</ref> written in [[VHDL]] by Dr. Jürgen Sauermann explains in detail how to design a complete AVR-based [[system on a chip]] (SoC).

== Other vendors ==

In addition to the chips manufactured by Atmel, clones are available from LogicGreen Technologies.<ref>{{cite web|url=http://www.lgt-semi.com/?page_id=5267&lang=en|title=LGT8F88A FLASH Microcontroller|publisher=LogicGreen Technologies|url-status=dead|archive-url=https://web.archive.org/web/20170829052145/http://www.lgt-semi.com/?page_id=5267&lang=en|archive-date=2017-08-29|access-date=2019-01-18|postscript=,}} a clone of the ATmega88.</ref> These parts are not exact clones -– they have a few features not found in the chips they are "clones" of, and higher maximum clock speeds, but use SWD ([[Serial Wire Debug]], a variant of [[JTAG]] from [[ARM architecture family|ARM]]) instead of ISP for programming, so different programming tools must be used.

Microcontrollers using the ATmega architecture are being manufactured by NIIET in [[Voronesh|Voronezh]], Russia, as part of the 1887 series of integrated circuits. This includes an [[ATmega128]] under the [[Soviet integrated circuit designation|designation]] 1887VE7T ({{lang-langx|ru|1887ВЕ7Т|italic=yes}}).<ref name="niiet">{{cite web|url=http://niiet.ru/goods/chips/microcont|title=Микроконтроллеры|publisher=OAO "NIIET"|language=ru|trans-title=Microcontrollers|archive-url=https://web.archive.org/web/20170822175635/http://niiet.ru/goods/chips/microcont|archive-date=22 August 2017|access-date=22 August 2017|place=Voronezh}}</ref>

== References ==

Line 532 ⟶ 576:

== External links ==

{{Commons category|Atmel AVR}}

{{Wikibooks|Embedded Systems|Atmel AVR}}

{{Portal|Electronics}}