Logiciels pour le développement AVR

Bonjour à tous,

Voici quelques informations relatives aux logiciels nécessaires pour le développement de progarmmes pour la famille AVR.

Windows
L'environnement s'appelle WinAVR, il est gratuit et est téléchargeable depuis plusieurs sites, par exemple:

http://www.qweas.com/downloads/development/c-c-c/overview-winavr.html

Je l'ai utilisé pour mes tous premiers essais, avant de passer sous Linux.

Linux
Il faut installer les paquets suivants, disponibles dans la plupart des distributions (testé sous Fedora, puis Ubuntu):

gcc-avr: compilateur C, WinAVR utilise le même en version Windows.
binutils-avr: utilitaires divers tels que linker, assembleur.
avr-libc: librairie de symboles et fonctions de base: noms des registres, fonctions de délais, etc.
avrdude: outil pour le téléchargement.

En plus, il est utile d'installer gcc pour simuler le programme sur le PC.

L'appel au compilateur et à avrdude sont définis dans le makefile, récupéré de l'environnement WinAVR, puis adapté. Ensuite, l'éditeur de texte gedit de Gnome sous Linux permet d'appeler des fonctions externes, j'ai donc défini les diverses commandes pour compiler le programme en mode PC ou AVR, l'exécuter sur PC ou le télécharger dans l'AVR avec avrdude.

J'utilise un programmateur branché sur le port parallèle, compatible STK500, développé par un ami. Il faudra que j'envisage de passer à un programmateur USB, car le port parallèle est en voie de disparition sur les PCs récents.

Pour faciliter la mise au point du programme, je le compile avec gcc et l'exécute sur le PC avec une multitude d'instructions d'affichage à l'écran. Des directives de compilation conditionnelle permettent de séparer le code spécifique à l'AVR du code spécifique au PC. Cela permet de tester la logique du programme sans se préoccuper des aspects spécifiques à l'AVR. Voir l'exemple ci-après:

Code:: //
// Maquette.c
//
// Programme de contrôle de la maquette "Savigny Express".
//
// Directives de compilation: PC ou AVR.
//

#ifdef AVR
#include <inttypes.h>
#include <avr/io.h>

#define F_CPU 1000000UL
#include <util/delay.h>

// Période en ms.
#define PERIODE 50

// Boutons poussoirs.
#define BOUTONS PINB
#define B_A1 _BV(PD6)
#define B_A2 _BV(PB0)
#define B_B1 _BV(PB1)
#define B_B2 _BV(PB2)
#define B_B3 _BV(PB3)
#define B_C3 _BV(PB4)
#define P_A1 (!(PIND & B_A1))
#define P_A2 (!(PINB & B_A2))
#define P_B1 (!(PINB & B_B1))
#define P_B2 (!(PINB & B_B2))
#define P_B3 (!(PINB & B_B3))
#define P_C3 (!(PINB & B_C3))

// Sorties.
#define SetTJD_D (PORTD |= _BV(PD0))
#define ClrTJD_D (PORTD &= ~_BV(PD0))
#define SetTJD_N (PORTD |= _BV(PD1))
#define ClrTJD_N (PORTD &= ~_BV(PD1))

#define SetAIG_D (PORTA |= _BV(PA1))
#define ClrAIG_D (PORTA &= ~_BV(PA1))
#define SetAIG_N (PORTA |= _BV(PA0))
#define ClrAIG_N (PORTA &= ~_BV(PA0))

#define SetSelAB (PORTD |= _BV(PD2))
#define ClrSelAB (PORTD &= ~_BV(PD2))
#define SetSel12 (PORTD |= _BV(PD3))
#define ClrSel12 (PORTD &= ~_BV(PD3))
#define SetSel3 (PORTD |= _BV(PD4))
#define ClrSel3 (PORTD &= ~_BV(PD4))
#define SetSela12 (PORTD |= _BV(PD5))
#define ClrSela12 (PORTD &= ~_BV(PD5))

// Configuration des ports
#define CONFIG_DDRA (_BV(PA0)|_BV(PA1))

#define CONFIG_DDRB ~(B_A2|B_B1|B_B2|B_B3|B_C3);
#define CONFIG_PULLUPB (B_A2|B_B1|B_B2|B_B3|B_C3);

#define CONFIG_DDRD ~(B_A1)
#define CONFIG_PULLUPD B_A1
#endif

#ifdef PC
#include <stdio.h>
#endif

#define NB_PERIODES 4

// Etats: nommés à partir de l'état
// des voies de gares 1, 2 et 3.
enum tEtat {AXB, XAB, AXC, XAC, BXC, XBC};
enum tEtat eEtat;

// Evénements: nommés à partir de la source à connecter à chaque voie.
enum tEvt {A1, B1, A2, B2, B3, C3};

// Commandes des relais.
short bSelAB;
short bSel12;
short bSel3;
short bSela12;

// Positions et commandes des aiguillages.
enum tPosition {NORMAL, DEVIE};
enum tPosition ePosJonctions;
enum tPosition ePosAiguillages;

enum tCommandeAig {IDLE, TJD, AIG} eCommandeAig;
short nNbPeriodes;

// Pour compter les tests en mode PC.
#ifdef PC
int nTest;
#endif

char *GetTexteEvt(enum tEvt xEvt)
{
#ifdef PC
switch(xEvt)
{
case A1: return("A1");
case B1: return("B1");
case A2: return("A2");
case B2: return("B2");
case B3: return("B3");
case C3: return("C3");
} // switch
#endif
} // GetTexteEvt

char *GetTexteEtat(enum tEtat xEtat, short xVoie)
{
#ifdef PC
switch(xEtat)
{
case AXB:
if(xVoie == 1)
return("A");
if(xVoie == 2)
return("X");
if(xVoie == 3)
return("B");

case XAB:
if(xVoie == 1)
return("X");
if(xVoie == 2)
return("A");
if(xVoie == 3)
return("B");

case AXC:
if(xVoie == 1)
return("A");
if(xVoie == 2)
return("X");
if(xVoie == 3)
return("C");

case XAC:
if(xVoie == 1)
return("X");
if(xVoie == 2)
return("A");
if(xVoie == 3)
return("C");

case BXC:
if(xVoie == 1)
return("B");
if(xVoie == 2)
return("X");
if(xVoie == 3)
return("C");

case XBC:
if(xVoie == 1)
return("X");
if(xVoie == 2)
return("B");
if(xVoie == 3)
return("C");
} // switch
#endif
} // GetTexteEtat

char *GetTexteAiguillage(enum tPosition xPos)
{
#ifdef PC
switch (xPos)
{
case NORMAL: return("N");
case DEVIE: return("D");
} // switch
#endif
} // GetTexteAiguillage

void AfficherEtat(void)
{
#ifdef PC
#define V1 GetTexteEtat(eEtat, 1)
#define V2 GetTexteEtat(eEtat, 2)
#define V3 GetTexteEtat(eEtat, 3)
#define J (bSelAB ? "B" : "A")
#define A (bSela12 ? "X" : "B")
#define P2 (bSelAB ? "X" : "A")
#define P3 (bSel3 ? "X" : "B")
#define PJ GetTexteAiguillage(ePosJonctions)
#define PA GetTexteAiguillage(ePosAiguillages)
#define FA (bSelAB ? "R" : "V")
#define FB (bSela12 ? "R" : "V")

printf(" /------%s------\\ \n", V1);
printf("%s----%s--%s%s-------%s------%s%s--%s--%s\n", FA, P2, J, PJ, V2, PJ, J, P2, FA);
printf("%s------%s%s%s-------%s-------%s%s%s---%s\n", FB, A, PA, P3, V3, P3, PA, A, FB);
#if 0
printf("Rel selAB: %d : %s\n", bSelAB, (bSelAB ? "B" : "A"));
printf("Rel sel12: %d : %s\n", bSel12, (bSel12 ? "1" : "2"));
printf("Rel sel3: %d : %s\n", bSel3, (bSel3 ? "X" : "B"));
printf("Rel sela12: %d : %s\n", bSela12, (bSela12 ? "X" : "B"));
#endif
printf("\n");
#endif
} // AfficherEtat

void CommanderTjdAig(void)
{
#if 0
printf ("CommanderTjdAig, periodes: %d\n", nNbPeriodes);
#endif

switch (eCommandeAig)
{
case TJD:
if (nNbPeriodes == 0)
{
#ifdef AVR
ClrTJD_D;
ClrTJD_N;
ClrAIG_D;
ClrAIG_N;
(ePosJonctions == DEVIE ? SetTJD_D : SetTJD_N);
#endif

#ifdef PC
(ePosJonctions == DEVIE ? printf("\tTJD DEV\n") : printf("\tTJD NOR\n"));
#endif
}
else if (nNbPeriodes == (NB_PERIODES / 2))
{
#ifdef AVR
ClrTJD_D;
ClrTJD_N;
(ePosAiguillages == DEVIE ? SetAIG_D : SetAIG_N);
#endif

#ifdef PC
printf("\tTJD --\n");
(ePosAiguillages == DEVIE ? printf("\tAIG DEV\n") : printf("\tAIG NOR\n"));
#endif

eCommandeAig = AIG;
} // if
nNbPeriodes++;
break;

case AIG:
if (nNbPeriodes == NB_PERIODES)
{
#ifdef AVR
ClrTJD_D;
ClrTJD_N;
ClrAIG_D;
ClrAIG_N;
#endif

eCommandeAig = IDLE;

#ifdef PC
printf("\tAIG --\n");
#endif

nNbPeriodes = 0;
}
else
nNbPeriodes++;
break;

case IDLE:
break;
} // switch
} // CommanderTjdAig

void DefinirSorties(void)
{
switch(eEtat)
{
case AXB:
bSelAB = 0;
bSel12 = 1;
bSela12 = 0;
bSel3 = 0;
ePosJonctions = DEVIE;
ePosAiguillages = NORMAL;
break;

case XAB:
bSelAB = 0;
bSel12 = 0;
bSela12 = 0;
bSel3 = 0;
ePosJonctions = NORMAL;
ePosAiguillages = NORMAL;
break;

case AXC:
bSelAB = 0;
bSel12 = 1;
bSela12 = 1;
bSel3 = 1;
ePosJonctions = DEVIE;
ePosAiguillages = NORMAL;
break;

case XAC:
bSelAB = 0;
bSel12 = 0;
bSela12 = 1;
bSel3 = 1;
ePosJonctions = NORMAL;
ePosAiguillages = NORMAL;
break;

case BXC:
bSelAB = 1;
bSel12 = 1;
bSela12 = 0;
bSel3 = 1;
ePosJonctions = NORMAL;
ePosAiguillages = DEVIE;
break;

case XBC:
bSelAB = 1;
bSel12 = 0;
bSela12 = 0;
bSel3 = 1;
ePosJonctions = DEVIE;
ePosAiguillages = DEVIE;
break;
} // switch

#ifdef AVR
(bSelAB ? SetSelAB : ClrSelAB);
(bSel12 ? SetSel12 : ClrSel12);
(bSel3 ? SetSel3 : ClrSel3);
(bSela12 ? SetSela12 : ClrSela12);
#endif
eCommandeAig = TJD;
} // DefinirSorties

void SimulerTimeouts(void)
{
#ifdef PC
int nNbTimeouts;

// On simule quelques timeouts
for(nNbTimeouts = 0; nNbTimeouts < 8; nNbTimeouts++)
CommanderTjdAig();
#endif
} // SimulerTimeouts

void TraiterEtat(enum tEvt xEvt)
{
enum tEtat eProchEtat;

#ifdef PC
printf("%02d: Evénement: %s\n", ++nTest, GetTexteEvt(xEvt));
#endif

switch(eEtat)
{
case AXB:
if (xEvt == A1) eProchEtat = AXB;
if (xEvt == B1) eProchEtat = BXC;
if (xEvt == A2) eProchEtat = XAB;
if (xEvt == B2) eProchEtat = XBC;
if (xEvt == B3) eProchEtat = AXB;
if (xEvt == C3) eProchEtat = AXC;
break;

case XAB:
if (xEvt == A1) eProchEtat = AXB;
if (xEvt == B1) eProchEtat = BXC;
if (xEvt == A2) eProchEtat = XAB;
if (xEvt == B2) eProchEtat = XBC;
if (xEvt == B3) eProchEtat = XAB;
if (xEvt == C3) eProchEtat = XAC;
break;

case AXC:
if (xEvt == A1) eProchEtat = AXC;
if (xEvt == B1) eProchEtat = BXC;
if (xEvt == A2) eProchEtat = XAC;
if (xEvt == B2) eProchEtat = XBC;
if (xEvt == B3) eProchEtat = AXB;
if (xEvt == C3) eProchEtat = AXC;
break;

case XAC:
if (xEvt == A1) eProchEtat = AXC;
if (xEvt == B1) eProchEtat = BXC;
if (xEvt == A2) eProchEtat = XAC;
if (xEvt == B2) eProchEtat = XBC;
if (xEvt == B3) eProchEtat = XAB;
if (xEvt == C3) eProchEtat = XAC;
break;

case BXC:
if (xEvt == A1) eProchEtat = AXC;
if (xEvt == B1) eProchEtat = BXC;
if (xEvt == A2) eProchEtat = XAC;
if (xEvt == B2) eProchEtat = XBC;
if (xEvt == B3) eProchEtat = AXB;
if (xEvt == C3) eProchEtat = BXC;
break;

case XBC:
if (xEvt == A1) eProchEtat = AXC;
if (xEvt == B1) eProchEtat = BXC;
if (xEvt == A2) eProchEtat = XAC;
if (xEvt == B2) eProchEtat = XBC;
if (xEvt == B3) eProchEtat = XAB;
if (xEvt == C3) eProchEtat = XBC;
break;

default:
break;
} // switch

// Ne changer les sorties que si l'état a changé.
if (eProchEtat != eEtat)
{
eEtat = eProchEtat;
DefinirSorties();
} // if

AfficherEtat();
SimulerTimeouts();
} // TraiterEtat

void main(void)
{
eEtat = XAB;
eCommandeAig = IDLE;
nNbPeriodes = 0;
DefinirSorties();

#ifdef AVR
// Entrées à droite du chip avec pull-ups.
// Sorties à gauche du chip.
DDRA = CONFIG_DDRA;
DDRB = CONFIG_DDRB;
PORTB = CONFIG_PULLUPB;
DDRD = CONFIG_DDRD;
PORTD = CONFIG_PULLUPD;

while (1)
{
if (P_A1) TraiterEtat(A1);
if (P_A2) TraiterEtat(A2);
if (P_B1) TraiterEtat(B1);
if (P_B2) TraiterEtat(B2);
if (P_B3) TraiterEtat(B3);
if (P_C3) TraiterEtat(C3);

CommanderTjdAig();
_delay_ms(PERIODE);
} // while
#endif

#ifdef PC
nTest = 0;
printf("*** Etat initial ***\n");
AfficherEtat();
SimulerTimeouts();

TraiterEtat(C3);
TraiterEtat(A1);
TraiterEtat(B1);
TraiterEtat(B2);
TraiterEtat(B3);
TraiterEtat(A1);
TraiterEtat(B1);
TraiterEtat(B3);
TraiterEtat(B2);
TraiterEtat(A1);
TraiterEtat(A2);
TraiterEtat(B3);
TraiterEtat(B1);
TraiterEtat(A2);
TraiterEtat(B3);
TraiterEtat(A1);
TraiterEtat(C3);
TraiterEtat(B3);
TraiterEtat(A2);
TraiterEtat(C3);
TraiterEtat(B1);
TraiterEtat(B3);
#endif
} // main

moi je me contente de "MikroBasic Pro for AVR" , la licence m'a coûté 150€ mais les mises-à-jour sont régulières et gratuites, avec le basic, je me sens chez moi. et je travaille actuellement sous W7

Jean-Louis

Salut,

Dans ton code, il doit y avoir un caractère qui n'est pas passé sur le forum après tes #include Smile

Si je me déniche un programmateur, j'essayerai.

NeoTheSpy a écrit:: Dans ton code, il doit y avoir un caractère qui n'est pas passé sur le forum après tes #include

Oui, le copier-coller a l'air d'avoir supprimé les noms des .h inclus. Je viens de ré-éditer le listing et c'est maintenant complet.

» Logiciels pour GNU/Linux
» Choix d'une plaque de développement pour la programmation de PIC
» [Réalisation] Carte de développement PIC pour breadboard
» [problème] module CDI
» PIC pour PICKIT2