Microcontroleurs Atmel AVR

De MicElectroLinGenMet.

Sommaire

Description

(Source: Wikipedia)


AVR est le terme utilisé par Atmel pour désigner le cœur du processeur et la famille de microcontrôleurs les implémentant.

Le cœur AVR possède les caractéristiques suivantes :

  • architecture Harvard 8 bits RISC
  • 32 registres de calcul divisés en 2 sous-ensembles :
    • les registres r0 à r15 ne permettant pas de travailler avec les valeurs immédiates
    • et les registres r16 à r31 le permettant.
  • jeu de 90 à 135 instructions (selon le composant)
  • la plupart des instructions (hors instructions de saut) s'exécutent en un seul cycle d'horloge interne. L'horloge interne est à la même fréquence que l'horloge externe. Le cœur AVR atteint donc environ 1 Mips/MHz.
  • Le cœur AVR a été optimisé pour exécuter du code généré à partir d'un compilateur C.
  • Le cœur AVR possède 3 pointeurs 16 bits X, Y et Z mappés sur les registres 8 bits r26 à r31 (X=r26+r27, Y=r28+r29 et Z=r30+r31). Les 3 pointeurs permettent différents types d'indexation (indirecte, indirecte avec déplacement) avec ou sans pré ou post incrémentation.
  • Les périphériques sont accessibles dans un espace d'adressage placé entre les registres et la SRAM (accessible entre autres par les instructions ld et st). Toutefois, un ensemble d'instructions spécialisées permet un accès plus pratique aux périphériques (instructions in et out) avec en particulier les instructions SBI (Set Bit in I/O) et CBI (Clear Bit in I/O) permettant respectivement de mettre à 1 et à 0 un bit dans les 32 premiers registres d'entrées/sorties.
  • les registres r0 à r31 sont mappés sur l'espace RAM (adresse 0 à 31) ce qui permet de les accéder par l'intermédiaire de X, Y et Z.
  • les branchements sont nombreux et permettent de réaliser tous les cas de figure.
  • le jeu d'instructions est conçu de telle manière que, bien que le cœur soit 8 bits, il est très aisé de réaliser des calculs sur 16, 24 ou 32 bits (etc.)
  • selon les composants, un multiplieur hardware (2 cycles) est implémenté.
  • la plupart des composants AVR sont fully static, c’est-à-dire qu'il n'y a pas de limite basse de la fréquence d'horloge nécessaire à un fonctionnement correct.
  • les composant AVR possèdent en moyenne une quinzaine d'interruptions (selon les périphériques embarqués) de priorité fixe.
  • le cœur AVR possède un pointeur de pile 16 bits (pour les composants équipés de SRAM (95% des composants)).

Les microcontrôleurs AVR embarquent dans un même boîtier un cœur AVR (microprocesseur), de la mémoire flash (espace programme), de la SRAM (espace données), de l'EEPROM (espace données de sauvegarde) et des périphériques divers.

Chaque périphérique possède son(ses) registre(s) associé(s) (accessible(s) via les instructions in et out) afin de les contrôler.

Voici à titre indicatif les périphériques existants dans la famille de microcontrôleur AVR :

  • mémoire EEPROM (elle est gérée comme un périphérique).
  • timers 8 et 16 bits avec "compare match" (interruption lorsque qu'une valeur choisie est atteinte) et mode PWM.
  • interface sérielle asynchrone UART (rxd, txd).
  • interface sérielle synchrone SPI (miso, mosi, sck, SS).
  • interface sérielle TWI (compatible I2C (2 fils))
  • interface sérielle 1-wire (1 fil)
  • ports d'entrée/sorties (PIO) avec résistances de pull-up intégrées.
  • oscillateur interne
  • oscillateur séparé pour l'horloge RTC
  • convertisseur analogique/numérique 10 bits
  • comparateur analogique


Développement sous Linux

Packages sous Debian:

$ dpkg -l|grep avr
ii  avr-libc                                 1:1.6.2.cvs20080610-2        Standard C library for Atmel AVR development
ii  avrdude                                  5.6-1                        software for programming Atmel AVR microcont
ii  avrdude-doc                              5.6-1                        documentation for avrdude
ii  binutils-avr                             2.18-4                       Binary utilities supporting Atmel's AVR targ
ii  gcc-avr                                  1:4.3.3-1                    The GNU C compiler (cross compiler for avr)

Compilateur C et Assembleur

En environnement GNU/Linux:


Exemple d'utilisation pour un programme C sur ATtiny13:

$ avr-gcc -Wall -g -Os -mmcu=attiny13 -c main.c
$ avr-gcc -g -mmcu=attiny13 -o main.elf main.o
$ avr-objdump -h -S main.elf > main.lst 				(pour générer listing assembleur)
$ avr-objcopy -j .text -j .data -O ihex main.elf main.hex


  • avra, Assembleur pour les microcontrôleurs AVR d'Atmel (existe en package Debian)

Voir exemple assembleur Coder pour Atmel ATtiny avec l'ATtiny15L sur UnixGarden:


Programmateurs

Logiciels

Deux programmes connus sous Linux:


Exemple d'utilisation pour un ATtiny13:

$ avrdude -p t13 -c dapa -P /dev/parport0 -i 5 -e					(effacement)
$ avrdude -p t13 -c dapa -P /dev/parport0 -i 5 -U flash:w:main.hex			(écriture et vérification)


Matériel

Les AVR se programmant in situ (ICSP), il n'y a pas besoin de programmateur complexe.

  • Programmateur économique sur port parallèle: DAPA


  • Starter kit Atmel: STK200, STK300, STK500


  • Programmeurs ISP USB pour AVR

Disponibles sur Devtronic site dédié aux AVR.

Autre programmateur: http://www.planete-domotique.com/programmeur-isp-usb-pour-avr.html fonctionnant sous Linux (Avec AVRDUDE type programmateur STK500):

Fichier:AVR-USB-STK500.jpg Fichier:AVR-USB-STK500_2.png


Tests des uC AVR

Tests personnels suites aux articles de Linux Magazine:

  • Découverte du micro-controleur AVR (Linux Mag HS23), Voir article sur UnixGarden
  • Développez vos phériphériques série, ATtiny2313 (Linux Mag HS38)
  • L'ATtiny13, tout petit mais costaud (Linux Mag HS38)
  • Coder pour Atmel ATtiny15L (Linux Mag 84), Voir article sur UnixGarden
  • Plus loin avec l’ATtiny15L, Voir article sur UnixGarden



L'ATtiny13

Microcontroleur économique de 8 broches (1,50€ chez gotronic)

Fonctionnalités

Mémoires:

  • 1Ko de mémoire Flash
  • 64 octets d'EEPROM
  • 64 octets de SRAM

Périphériques:

  • 6 GPIOs
  • 1 Timer/Compteur 8-bit avec diviseur (Prescaler)
  • 2 canaux PWM
  • 4 convertisseurs analogique 10-bit avec tension de référence interne.
  • Chien de garde (Watchdog) programmable avec son horloge interne.
  • Comparateur analogique.

Tensions de fonctionnement:

  • 1.8 - 5.5V pour ATtiny13V
  • 2.7 - 5.5V pour ATtiny13

Voir datasheet pour plus de détail: attiny13.pdf


Brochages

Fichier:attiny13_br.jpg


Shéma électronique de test

Exemple simple montrant un clignotement de 2 LEDs sur ports PB3 et PB4 en opposition.


Programme

Voir ci-dessous le source C du programme.
Pour le compiler (avec avr-gcc) et le transférer (avec avrdude) sur l'AVR voici le Makefile associé.
L'ATtiny13 utilise dans ce programme sont oscillateur interne avec les "fuses" laissés aux valeurs par defaut.


Exemple:

$ make && make prog
avr-gcc -Os -g -Wall -I.  -mmcu=attiny13 -c -o main.o main.c
avr-gcc -g -mmcu=attiny13 -o main.elf main.o                
avr-objcopy -j .text -j .data -O ihex main.elf main.hex     
avrdude -p t13 -c dapa -P /dev/parport0 -i5 -U flash:w:main.hex

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.                        
avrdude: erasing chip                                                           
avrdude: reading input file "main.hex"                                          
avrdude: input file main.hex auto detected as Intel Hex                         
avrdude: writing flash (528 bytes):                                             

Writing | ################################################## | 100% 0.53s

avrdude: 528 bytes of flash written
avrdude: verifying flash memory against main.hex:
avrdude: load data flash data from input file main.hex:
avrdude: input file main.hex auto detected as Intel Hex
avrdude: input file main.hex contains 528 bytes        
avrdude: reading on-chip flash data:                   

Reading | ################################################## | 100% 0.50s

avrdude: verifying ...
avrdude: 528 bytes of flash verified

avrdude: safemode: Fuses OK

avrdude done.  Thank you.


/*-----------------------------------------------------------------------------------------------*/
/* Test ATtiny13 (29/12/2008)					*/
/* Par domos78 at free point fr					*/
/* Fait clignoter 2 leds sur ports PB3 et PB4 en opposition	*/
/* Utilisation de "util/delay.h" pour la tempo			*/
 
#include <avr/io.h>
 
// ATTiny13's internal oscillator defaults to 9.6 MHz. Prescaler set to divide by 8 (9.6/8=1.2MHz).
#define F_CPU 1200000UL
#include <util/delay.h>
 
int main(void) 
{
	DDRB |= _BV(PB3) ;			// PB3 en sortie.
	DDRB |= _BV(PB4) ;			// PB4 en sortie.
	while (1) 
	{
		PORTB &= ~_BV(PB3) ;		// PB3 à 0.
		PORTB |= _BV(PB4) ;		// PB4 à 1.
		_delay_ms (1000) ;		// Tempo. en ms depend de F_CPU.
		PORTB |= _BV(PB3) ;		// PB3 à 1.
		PORTB &= ~_BV(PB4) ;		// PB4 à 0.
		_delay_ms (1000) ;
	}
}
/*-----------------------------------------------------------------------------------------------*/


Photos du montage

Vu du montage avec le connecteur parallèle pour programmation
Vu de l'ATtiny13 (il y a une LED en plus sur le montage)


Autre exemple de programme pour l'ATtiny13

Voir page: Generation signaux X10-RF avec un AVR



L'ATtiny2313

Fonctionnalités

Mémoires:

  • 2Ko de mémoire Flash
  • 128 octets d'EEPROM
  • 128 octets de SRAM

Périphériques:

  • 18 GPIOs
  • 1 Timer/Compteur 8-bit avec diviseur (Prescaler)
  • 1 Timer/Compteur 16-bit avec diviseur (Prescaler)
  • 4 canaux PWM
  • Comparateur analogique.
  • Chien de garde (Watchdog) programmable avec son horloge interne.
  • USI – Universal Serial Interface
  • Full Duplex USART

Tensions de fonctionnement:

  • 1.8 - 5.5V

Voir datasheet pour plus de détail: attiny2313.pdf


Brochages


Shéma électronique de test


Programme

Exemple simple pour test du port série avec quartz externe de 11.0592MHz.
Aprés envoi d'une message sur le port série ("Test série ATtiny2313"), l'AVR attend une réception d'un caratère et retourne ce caratère incrémenté de 1. La LED clignote aprés réception


Ne pas oublier de programmer le "fuse" pour l'utilisation d'un quartz externe:

$ avrdude -p t2313 -c dapa -P /dev/parport0 -i 8 -U lfuse:w:0xFF:m
=> Ecriture 0xFF dans lfuse car quartz externe > 8MHz


Aprés compilation/programmation avec ce Makefile de l'AVR, voici ci-dessous une vue de son fonctionnement avec picocom (Ctrl-A + CTRL-X pour quitter) comme terminal série..

$ picocom -b 19200 -d 8 -f n -p n /dev/ttyUSBcyan
picocom v1.4

port is        : /dev/ttyUSBcyan
flowcontrol    : none
baudrate is    : 19200
parity is      : none
databits are   : 8
escape is      : C-a
noinit is      : no
noreset is     : no
nolock is      : no
send_cmd is    : ascii_xfr -s -v -l10
receive_cmd is : rz -vv

Terminal ready
Test série ATtiny2313
1234579:b{fsuzjq


/*-----------------------------------------------------------------------------------------------*/
/* Test ATtiny2313 (17/1/2009 )								*/
/* Par domos78 at free point fr								*/
/* Test du port série	avec quartz externe de 11.0592MHz				*/
/* Max232 connecter aux ports rsx/txd de l'ATtiny2313					*/
/* Connexion au PC et test avec: picocom -b 19200 -d 8 /dev/ttyS1			*/
/* Inspiré de l'article "Développez vos périphériques série" dans "Linux magazine HS38"	*/
 
 
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
 
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
 
// UL (unsigned long)
#define F_CPU 11059200UL
#include <util/delay.h>
 
// 19200 avec Qz 11,0592MHz. 
// Voir tableau dans datasheet à partir page 135 pour correspondance avec quartz.
#define BAURATEVAL 35 
 
volatile char rxbuff ;
 
void initUART(unsigned char baudrate)
{
	UBRRL = baudrate ;
	UCSRB = (1 << RXEN) | (1 << TXEN) ;
	UCSRC = (1 << UCSZ1) | (1 << UCSZ0) ;	// 8N1
}
 
unsigned char ReceiveByte(void)
{
	while ( ! (UCSRA & (1 << RXC)) ) ;
	return	UDR ;
}
 
static void TransmitByte(unsigned char data)
{
	loop_until_bit_is_set(UCSRA, UDRE) ;
	UDR = data ;
}
 
static void TransmitTxt(const char *s)
{
	char c;
	for ( c = pgm_read_byte(s); c; ++s, c = pgm_read_byte(s) )
	{
		TransmitByte(c) ;
	}
}
 
int main(void) 
{
	DDRB |= _BV(PB2) ;			// PB2 en sortie.
	PORTB &= ~_BV(PB2) ;			// Led ON sur PB2.
 
	initUART(BAURATEVAL) ;			// 19200,8N1 avec Qz 11,0592MHz.
	TransmitTxt( PSTR("Test série ATtiny2313\n\r") ) ;
 
	while (1)
	{
		PORTB &= ~_BV(PB2) ;		// Led ON sur PB2.
		rxbuff = ReceiveByte() ;	// Attend réception.
		TransmitByte(rxbuff + 1) ;
		PORTB |= _BV(PB2) ;		// Led OFF sur PB2.
		_delay_ms(500) ;		// Pause.
	}
}
 
/*-----------------------------------------------------------------------------------------------*/


Photos du montage

Vu du montage avec le connecteur parallèle et module Max232
Vu de l'ATtiny2313 et de son quartz


Autre exemple de programme pour l'ATtiny2313

Voir page: Generation signaux Chacon-RF avec un AVR


Ressources Internet

Resources UnixGarden (Articles Linux Magazine)

Nombreux articles sur les AVR sur le site de lefinnois:



14/06/2009