AVR GCC - AVR-LIBC

//Commentaire

/*Commentaire*/

Sur plusieurs lignes :

/*
Commentaire
sur
plusieures 
lignes
*/

#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
}

DDRx Impose la direction des ports.
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.
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.
z=PINA La valeur du port A est mise dans la variable z.

Voir l'exemple : Utiliser les entrées sorties

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 et 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 

Voir l'exemple : Temporisation avec delay.h (Chenillard)

L'intérêt de cette librairie est de pouvoir indiquer clairement la taille de la variable que l'on souhaite.

#include <stdint.h>

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
  

#define PI 3.1415926

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

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

Entieres non-signées : suffixe U ex:1000U

Entieres longues : suffixe L ex: 99L

Entieres non-signées et longues : suffixe UL ex: 99UL

Caractères : entre apostrophes (') ex: 'a'

#include <avr/eeprom.h>

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)

Ecrit 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)

Ecrit un mot (16bits) value à l'adresse addr

Voir l'exemple : Utiliser l'EEPROM

#include <avr/interrupt.h>

La fonction ISR() est executé 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 interresse.

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.

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

Voir l'exemple : Utiliser les Interruptions externes

• Utilisez un type de variable approprié à son contenu. Ayez, par exemple, le reflexe 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

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

• Manuel d'AVR-LIBC v2.0.0