Programmation du microcontrôleur

PROCESSEUR=atmega328p
CC=avr-gcc
OBJCOPY=avr-objcopy
CCFLAGS=-mmcu=$(PROCESSEUR)  -Wall -MD -MT
LDFLAGS=-mmcu=$(PROCESSEUR) -Wl,--undefined=_mmcu,--section-start=.mmcu=0x910000
OBJCOPYFLAGS=-O ihex -R .eeprom 

TEMPSIMULATION=#remplacer par le temps de simulation en ns
SIMULAVR=simulavr
SIMULAVRFLAGS= -d atmega328 -F 16000000 -m $(TEMPSIMULATION)

PERIPHERIQUESERIE=#remplacer par le descripteur série pour le programmateur
PROGRAMMATEUR=#remplacer par le nom du programmateur
AVRDUDE=avrdude 
AVRDUDEFLAGS= -p $(PROCESSEUR) -c $(PROGRAMMATEUR) -b 19200 -P $(PERIPHERIQUESERIE) 

DIRBUILD=.
SRC=hello.c
OBJ= $(SRC:.c=.o)
ELF= $(SRC:.c=.elf)
HEX= $(DIRBUILD)/$(SRC:.c=.hex)
DFILE= $(SRC:.c=.d)
VCD=$(SRC:.c=.vcd)
TXT=$(SRC:.c=.txt)

all:
	$(CC) $(CCFLAGS) $(OBJ) -c $(SRC)
	$(CC) $(LDFLAGS)  -o $(ELF) $(OBJ)
	$(OBJCOPY) $(OBJCOPYFLAGS) $(ELF) $(HEX)
	
upload:
	$(AVRDUDE) $(AVRDUDEFLAGS) -U flash:w:$(HEX)	

simule: 
	$(CC) -DSIMULATION $(CCFLAGS)  $(OBJ) -c $(SRC)
	$(CC) $(LDFLAGS) -o $(ELF) $(OBJ)
	$(SIMULAVR) $(SIMULAVRFLAGS) -f $(ELF) -o $(TXT)
	$(SIMULAVR) $(SIMULAVRFLAGS) -f $(ELF) -c vcd:$(TXT):$(VCD)
	
clean:
	rm  -f $(DFILE) $(MAP) $(OBJ) $(ELF) $(HEX) $(TXT) $(VCD)
					

Fichier Makefile générique

La commande make par défaut (all) permet de créer le fichier hex pour le programmateur. Elle comprend la phase de compilation qui crée le fichier objet, la phase d'édition de lien qui crée un fichier au format elf, puis la phase de création du fichier hex pour l'outil de programmation.

La commande make upload programme le circuit cible à partir du fichier hex.

La commande make simule effectue les phases de compilation, édition de lien pour fournir le ficher elf pour l'outil de simulation, qui commence par créer le fichier txt qui contient les différents éléments du processeur pour, ensuite, créer le fichier vcd qui peut être visualiser par gtkwave.

Pour utiliser ce Makefile, il faut changer le nom du fichier source et il faut définir les valeurs des variables suivantes :

• TEMPSIMULATION avec le temps de simulation en ns
• PERIPHERIQUESERIE avec le descripteur série qui peut être, par exemple, /dev/ttyUSBO, dev/ttyACM0, ...
• PROGRAMMATEUR avec Le nom du programmateur, la liste acceptée par avrdude est obtenu avec la commande avrdude -c ?

Afin de paramétrer les temps dans le code source, le fichier Makefile définit une valeur SIMULATION, qui peut être testée avec une commande de préprocesseur de type #ifdef ou #ifndef.

Code soure chenillard.c

#include <avr/io.h>
#define F_CPU 16000000L
#include <util/delay.h>

#ifdef SIMULATION
#define DELAI_MS 1
#else
#define DELAI_MS 500
#endif

int main(void) {
	unsigned char octet = 1;	
	DDRD = 0xff;
	while(1) {
		PORTD = octet ;
		if (octet == 0x80) {
			octet = 1 ;
		}
		else {
			octet <<= 1;
		}
		_delay_ms(DELAI_MS);
	}
	return 0;
}
					

Pour utiliser la fonction _delay_ms il faut définir la fréquence du processeur avant d'inclure le fichier util/delay.h.

Avec le Makefile présenté précédemment, #ifdef ... #endif permet de définir le temps de 1ms en simulation et 500ms sur le processeur réel.

Résultat de la simulation

Code soure pwm.c

#include <avr/io.h>

#define CONTROLA  (( 1 << COM1A1) | ( 1 << COM1A0) | (1 << WGM10))
#define CONTROLB  (1 << WGM12)
#ifdef SIMULATION
#define CONTROLBS  ((1 << WGM12) | (1 << CS10))
#else
#define CONTROLBS  ((1 << WGM12) | (1 << CS12) | (1 << CS10))
#endif

int main(void) {
	TCCR1A = CONTROLA;
	TCCR1B = CONTROLB;
	OCR1AH = 0 ;
	OCR1AL = 200;
	DDRB = 2;
	TCCR1B = CONTROLBS;
	while (1) {
	}	
	return 0;
}
					

On remarque que la boucle infinie ne fait rien, en effet le signal pwm est uniquement matériel. Ceci permet de ne pas occuper le processeur pour le signal pwm et de le laisser libre pour d'autres tâches.

En plus de l'initialisation du timer, on n'oublie pas de définir la broche 1 du port B en sortie.

Calcul de la période et du rapport cyclique

La fréquence de l'horloge est de 16MHz, en mode simulation l'horloge du timer est divisée par 1 et en fonctionnement sur le microcontrôleur l'horloge du timer est divisée par 1024, soit environ 15.8us

Le rapport cyclique est de (255-200)/255 ≈ 0,21. Sur le graphe (visualisé avec gtkwave) on trouve 3,4us pour l'état 1 ce qui donne 3,4/15.8 ≈ 0,21

Résultat de la simulation

Code soure chenillard.c

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 16000000L
#include <util/delay.h>

#define CONTROLA  0
#define CONTROLB  (1 << WGM12)

#ifdef SIMULATION
#define DELAI_MS 1
#define CONTROLBS  ((1 << WGM12)  | (1 << CS10))
#else
#define DELAI_MS 500
#define CONTROLBS  ((1 << WGM12)  | (1 <<  CS12) | (1 << CS10))
#endif

#define DIVISEUR 7812
#define DIVMSB ((DIVISEUR >> 8)& 0xff)
#define DIVLSB (DIVISEUR & 0xff)

int main(void) {
	TIMSK1 = 0;
	TCCR1A = CONTROLA;
	TCCR1B = CONTROLB;
	TCCR1C = 0 ;
	OCR1AH = DIVMSB ;
	OCR1AL = DIVLSB;
	DDRD = 0xff;
	PORTD = 1 ;
	DDRB = 2;
	PORTB = 2 ;
	TIMSK1 = ( 1 << OCIE1A);
	sei();
	TCCR1B = CONTROLBS;
	while (1) {
		_delay_ms(DELAI_MS);
		PORTB ^= 2;
	}	
	return 0;
}

ISR(TIMER1_COMPA_vect) {
	PORTD <<= 1;
	if (PORTD == 0) {
		PORTD=1;
	}
}
					

Le calcul de la période du chenillard est défini par la fréquence de l'horloge 16Mz, la configuration du diviseur du timer (1024 en réel, 1 en simulation) ainsi que de la valeur des registres OCR1AH et OCR1AL. On a donc une horloge de 16MHz divisée par 7812 qui donne ≈ 2048Hz, cela donne une période d'environ 488us en simulation et 0,5s en réalité.

La demi-période de clignotement de la neuvième LED est de 1ms en simulation et 0.5s en réalité.

Le chenillard est donc décalé par rapport au clignotement de la LED.

Afin de répartir la valeur du diviseur sur les registres de poids fort et poids faible, on fait effectuer le calcul des octets de poids forts et faibles par le préprocesseur à l'aide de directives define.

La fonction sei autorise la prise en compte d'interruptions par le processeur.

Résultat de la simulation