Programming Arduino Compatible Using Sound Card. Category: Arduino, Interfacing, Miscellaneous, Project. Audioino is neat way to program an Arduino compatible. 555 accelerometer Analog Arduino AT90S2313 ATmega8 ATmega16 ATmega32 AtMega48 ATmega88 ATMega168 ATmega169 ATMega328 Atmega644 ATtiny2313 Audio Automotive AVR Bascom AVR. How to Program ATtiny2313 ATtiny4313 using Arduino. Share this: Facebook. I have not got a ATtiny4313 yet so I can’t test this Arduino programming method on it. But they seems to be very similar as they appear on the same datasheet. 8 thoughts on “ How to Program ATtiny2313 ATtiny4313 using Arduino ” Adam 1st September 2015 at 6. Arduino UNO as in circuit programmer for AVR. I find out a way to use Arduino programmer to program Atmega Micro controllers. So start with Arduino and slowly switch down to atmega. You don't need a stand alone programmer. This blog awesome and i learn a lot about programming from here.The best thing about this blog is that you.

AVR logo

Various older AVR microcontrollers: ATmega8 in 28-pin narrow dual in-line package (DIP-28N), ATxmega128A1 in 100-pin thin quad flat pack (TQFP-100) package, ATtiny45 in 8-pin small outline (SO-8) package.

ATmega328P in 28-pin narrow dual in-line package (DIP-28N). It is commonly found on older Arduino boards.

AVR is a family of microcontrollers developed since 1996 by Atmel, acquired by Microchip Technology in 2016. These are modified Harvard architecture8-bitRISC single-chip microcontrollers. AVR was one of the first microcontroller families to use on-chip flash memory for program storage, as opposed to one-time programmable ROM, EPROM, or EEPROM used by other microcontrollers at the time.

AVR microcontrollers find many applications as embedded systems. 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.

2Device overview
- 2.2Device architecture
3Programming interfaces
4Debugging interfaces
5Development tools and evaluation kits

Brief history[edit]

The AVR architecture was conceived by two students at the Norwegian Institute of Technology (NTH),^[1] Alf-Egil Bogen^[2] and Vegard Wollan.^[3]

The original AVR MCU was developed at a local ASIC house in Trondheim, Norway, called Nordic VLSI at the time, now Nordic Semiconductor, where Bogen and Wollan were working as students.^{[citation needed]} It was known as a μRISC (Micro RISC)^[4] and was available as silicon IP/building block from Nordic VLSI.^[5] When the technology was sold to Atmel from Nordic 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 compilation of high-level languages.^[6]

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.^[3] However, it is commonly accepted that AVR stands for Alf and Vegard's RISC processor.^[7] Note that the use of 'AVR' in this article generally refers to the 8-bit RISC line of Atmel AVR Microcontrollers.

Among the first of the AVR line was the AT90S8515, which in a 40-pin DIP package has the same pinout as an 8051 microcontroller, including the external multiplexed address and data bus. The polarity of the RESET line was opposite (8051's having an active-high RESET, while the AVR has an active-low RESET), 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.^[8] The Arduino platform, developed for simple electronics projects, was released in 2005 and featured ATmega8 AVR microcontrollers.

Device overview[edit]

The AVR is a modified Harvard architecture machine, where program and data are stored in separate physical memory systems that appear in different address spaces, but having the ability to read data items from program memory using special instructions.

Basic families[edit]

AVRs are generally classified into following:

tinyAVR – the ATtiny series
- 0.5–32 KB program memory
- 6–32-pin package
- Limited peripheral set
megaAVR – the ATmega series
- 4–256 KB program memory
- 28–100-pin package
- Extended instruction set (multiply instructions and instructions for handling larger program memories)
- Extensive peripheral set
XMEGA – the ATxmega series
- 16–384 KB program memory
- 44–64–100-pin package (A4, A3, A1)
- 32-pin package: XMEGA-E (XMEGA8E5)
- Extended performance features, such as DMA, 'Event System', and cryptography support
- Extensive peripheral set with ADCs
Application-specific AVR
- megaAVRs with special features not found on the other members of the AVR family, such as LCD controller, USB controller, advanced PWM, CAN, etc.
FPSLIC (AVR with FPGA)
- FPGA 5k to 40k gates
- SRAM for the AVR program code, unlike all other AVRs
- AVR core can run at up to 50 MHz^[9]
32-bit AVRs

In 2006, Atmel released microcontrollers based on the 32-bit AVR32 architecture. This was a completely different architecture unrelated to the 8-bit AVR, intended to compete with the ARM-based processors. It had a 32-bit data path, SIMD and DSP instructions, along with other audio- and video-processing features. The instruction set was similar to other RISC cores, but it was not compatible with the original AVR (nor any of the various ARM cores). Since then support for AVR32 has been dropped from Linux as of kernel 4.12; Atmel has switched mostly to M variants of the ARM architecture.

Device architecture[edit]

Flash, EEPROM, and SRAM are all integrated onto a single chip, removing the need for external memory in most applications. Some devices have a parallel external bus option to allow adding additional data memory or memory-mapped devices. Almost all devices (except the smallest TinyAVR chips) have serial interfaces, which can be used to connect larger serial EEPROMs or flash chips.

Program memory[edit]

Program instructions are stored in non-volatileflash memory. Although the MCUs are 8-bit, each instruction takes one or two 16-bit words.

The size of the program memory is usually indicated in the naming of the device itself (e.g., the ATmega64x line has 64 KB of flash, while the ATmega32x line has 32 KB).

There is no provision for off-chip program memory; all code executed by the AVR core must reside in the on-chip flash. However, this limitation does not apply to the AT94 FPSLIC AVR/FPGA chips.

Internal data memory[edit]

The data address space consists of the register file, I/O registers, and SRAM. Some small models also map the program ROM into the data address space, but larger models do not.

Internal registers[edit]

Atmel ATxmega128A1 in 100-pin TQFP package

The AVRs have 32 single-byteregisters and are classified as 8-bit RISC devices.

In the tinyAVR and megaAVR variants of the AVR architecture, the working registers are mapped in as the first 32 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₁₆).

Actual SRAM starts after these register sections, at address 0060₁₆ o

Program At90s2313 With Arduino Programming