WikiElectronique

Vous affichez une ancienne révision du document ! Si vous l'enregistrez, vous créerez une nouvelle version avec ce contenu.

====== AVR GCC - AVR-LIBC ======

===== Commentaire =====

<code C>//Commentaire</code>

<code C>/*Commentaire*/</code>

Sur plusieurs lignes :

<code C>
/*
Commentaire
sur
plusieures 
lignes
*/</code>

===== Structure d'un programme =====
<code C>
#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
}
</code>

===== Entrées Sorties =====

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.

[[winavr:Les entrées sorties|Voir l'exemple : 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 :
<code C>
#define F_CPU 1000000UL // 1 MHz
#include <util/delay.h>
</code>

<code C>void _delay_us (double __us) //double __us détermine le nombre de microsecondes </code>

<code C>void _delay_ms (double __ms) //double __ms détermine le nombre de millisecondes </code>

[[winavr:Temporisation avec delay.h|Voir l'exemple : Temporisation avec delay.h (Chenillard)]]

===== Les types de variables =====

^  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 est de pouvoir indiquer clairement la taille de la variable que l'on souhaite.

=== Librairie utilisée  ===
<code C>#include <stdint.h></code>

Quand vous utilisez une variable qui aura **au moins** une taille de //x_bit// vous pouvez déclarer votre variable en :\\
  * **int_least**//x_bit//**_t** : Si vous souhaitez optimiser la taille prise par la variable. Utilisé pour les structures de données\\
  * **int_fast**//x_bit//**_t** : Si vous souhaitez optimiser la vitesse. Utilisé pour les variables locales\\

===== Les constantes =====

==== Déclaration ====
<code C>#define PI 3.1415926</code>

==== Types ====

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'

===== EEPROM =====

==== Librairie utilisée  ====

<code C>#include <avr/eeprom.h></code>

==== Fonctions  ====

<code C>eeprom_is_ready()</code>

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.

<code C>uint8_t eeprom_read_byte (const uint8_t * addr)</code>

Lit un octet (8bits) à l'adresse //addr//

<code C>void eeprom_write_byte (uint8_t * addr, uint8_t value)</code>

Ecrit un octet (8bits) //value// à l'adresse //addr//

<code C>uint16_t eeprom_read_word (const uint16_t * addr)</code>

Lit un mot (16bits) à l'adresse //addr//

<code C>void eeprom_write_word (uint16_t * addr, uint16_t value)</code>

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

[[winavr:L'EEPROM|Voir l'exemple : Utiliser l'EEPROM]]

===== Timer =====

===== USART =====

===== Interruption =====

==== Librairie utilisée  ====
<code C>#include <avr/interrupt.h></code>

==== Fonctions  ====

La fonction ISR() est executé lors de l'activation de l'interruption _vect_
<code C>
ISR(_vect_)
{
	// Votre code à exécuter lors de l'interruption
}</code>

//_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.//

=== Liste des vecteurs d'interruption ===

Voir [[http://download.savannah.gnu.org/releases/avr-libc/avr-libc-user-manual-1.4.4.pdf|Manuel d'AVR-LIBC v1.4.4]], chapitre //<avr/interrupt.h>: Interrupts// page 127

==== Interruption externe ====

[[winavr:Interruption externe|Voir l'exemple : Utiliser les Interruptions externes]]

===== Optimisez votre programme =====

==== Code ====
=== Variables ===
  * 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//

==== Compilation ====

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

===== Documentation indispensable =====
  * [[http://download.savannah.gnu.org/releases/avr-libc/avr-libc-user-manual-2.0.0.pdf.bz2|Manuel d'AVR-LIBC v2.0.0]]

Question de sécurité : Après le mois d'avril, il y a le mois de ? ma.... Merci de laisser ce champ vide :

Résumé