Page bloquée

Cette page est actuellement bloquée pour modification par un autre utilisateur. Vous devez attendre que cet utilisateur ait terminé ou que le blocage de la page expire.

Actuellement bloqué par :
Le blocage expire à : 2026/03/14 17:01 (15 min)

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-1.4.4.pdf|Manuel d'AVR-LIBC v1.4.4]]

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é