User Tools

Site Tools


wiki.jelectronique.com_avr-gcc

Bonjour, cette page est un backup de la page wiki.jelectronique.com/avr_gcc. Page qui ne fonctionne plus (ou du moins, qui ne fonctionnait pas). Je n'ai donc modifié que peu de choses (petites fautes d'orthographe notamment).

Version archivée: http://web.archive.org/web/20080608001212/http://wiki.jelectronique.com/avr-gcc

AVR GCC - AVR-LIBC

Commentaires

Les commentaires sont les mêmes que le C, C++, PHP:

//Commentaire sur une ligne
/*
Commentaire
sur
plusieurs 
lignes
*/

Structure d'un programme

#include <avr/io.h> 	// Librairie utilisée par le programme
 
int main (void) 	// Fonction principale
{
 
	DDRB = 0xFF; 	//Met le port B en sortie
	PORTB = 0xFF; 	//Met le port B à l'état haut
 
	return 1;	//Valeur de retour de la fonction
}

Entrées/Sorties

DDRx Impose la direction des ports.<br> DDRA=0xF0 ; les bits 0 à 3 du portA sont configurés en entrée et de 4 à 7 en sortie.

PORTx Impose l’état logique des bits sur le port.<br> PORTA=0xF0 ; les bits 0 à 3 du portA passent à l’état bas et de 4 à 7 à l’état haut.

PINx récupère l’état du port x. i=PINA La valeur du port A est mise dans la variable z.

Utiliser les entrées sorties

Temporisation

La librairie delay permet de créer des tempos facilement grâce à une boucle programme. Avantage : Très facile à utiliser Inconvénient : Pendant la tempo, le micro est bloqué dans sa boucle est ne peut rien faire d’autre.

A Rajouter dans le programme pour utiliser les fonctions :

#define F_CPU 1000000UL // 1 MHz
#include <util/delay.h>
void _delay_us (double __us) //double __us détermine le nombre de microsecondes  
void _delay_ms (double __ms) //double __ms détermine le nombre de millisecondes  

Temporisation avec delay.h

Les types de variables

Voici les types de variables qui existent avec AVR-GCC:

Type courant Taille en bits Valeur
char 8 -128 à 127
unsigned char 8 0 à 255
signed char 8 -128 à 127
int 16 -32768 à 32767
unsigned int 16 0 à 65535
long int 32 -2147483648 à 2147483647
unsigned long int 32 0 à 4294967295
float 32 3.402e-38 à 3.402e38
double 32 1.7e-308 à 1.7e308

stdint.h

L’intérêt de cette librairie et de pouvoir indiquer clairement la taille de la variable que l’on souhaite. Librairie utilisée

#include <stdint.h> 
Variable stdint équivalent taille en bit
int8_t signed char 8
uint8_t unsigned char 8
int16_t signed int 16
uint16_t unsigned int 16
int32_t signed long int 32
uint32_t unsigned long int 32
int64_t signed long long int 64
uint64_t unsigned long long int 64

Quand vous utilisez une variable qui aura au moins une taille de x_bit vous pouvez déclarer votre variable en :

  • int_leastx_bit_t : Si vous souhaitez optimiser la taille prise par la variable. Utilisé pour les structures de données
  • int_fastx_bit_t : Si vous souhaitez optimiser la vitesse. Utilisé pour les variables locales

Les constantes

Déclaration

Ex:

#define PI 3.1415926 

Types

Décimales: pas de préfixe ex: 255

Hexadécimales: préfixe 0x ex: 0x0F

Entières non-signées : suffixe U ex:1000U

Entières longues : suffixe L ex: 99L

Entières non-signées et longues : suffixe UL ex: 99UL

Caractères : entre ' ex : a

EEPROM

Librairie utilisée

#include <avr/eeprom.h> 

Fonctions

eeprom_is_ready()

Retourne 1 si l’EEPROM est prête sinon 0

Il est conseillé de désactiver les interruptions pendant les phases de lecture et d’écriture.

uint8_t eeprom_read_byte (const uint8_t * addr)

Lit un octet (8bits) à l’adresse addr

void eeprom_write_byte (uint8_t * addr, uint8_t value)

Écrit un octet (8bits) value à l’adresse addr

uint16_t eeprom_read_word (const uint16_t * addr)

Lit un mot (16bits) à l’adresse addr

void eeprom_write_word (uint16_t * addr, uint16_t value)

Écrit un mot (16bits) value à l’adresse addr

Utiliser l'EEPROM

Interruption

Librairie utilisée

#include <avr/interrupt.h> 

Fonctions

La fonction ISR() est executée lors de l’activation de l’interruption _vect_

ISR(_vect_)
{
	// Votre code à exécuter lors de l'interruption
}

_vect_ doit être remplacé par le nom attribué au vecteur d’interruption qui vous intéresse.

Les interruptions (bit I de SREG) sont désactivées lors de l’appel de la fonction ISR puis réactivés une fois la fonction exécutée.

Pour ceux qui utilisaient une ancienne version d’AVRlibC, SIGNAL et INTERRUPT sont maintenant remplacés par ISR et ne doivent plus être utilisés.

Liste des vecteurs d'interruption

Voir Manuel d'AVR-LIBC v1.4.4, chapitre <avr/interrupt.h>: Interrupts page 123

Interruption externe

Optimisez votre programme

Code

Variables

  • Utilisez un type de variable approprié à son contenu. Ayez, par exemple, le réflexe registre 8bits → variable sur 8bit → type unsigned char ou uint8_t
  • Utilisez le plus souvent possible des variables non signées. Les multiplications et divisions par des puissances de 2 se font par un simple décalage à gauche ou à droite.
  • N’initialisez vos variables que si elles sont différentes de 0.
  • Déclarez vos variables globales avec le prefix static

Compilation

  • Utilisez la directive de compilation -Os qui permettra de générer un code plus petit et donc plus rapide.

Documentation indispensable

  • Manuel d'AVR-LIBC v1.4.4

Discussion

Enter your comment. Wiki syntax is allowed:
JFONJ
 
wiki.jelectronique.com_avr-gcc.txt · Last modified: 2011/12/26 20:51 (external edit)