Salutations!

Deuxième article de la série "Bidouiller le badge de la NDH2K11". Ce soir, on va... Programmer!!!!!

Comme le veut la tradition, nous allons coder un "HelloWorld", en utilisant le principe de base du badge: Afficher une série de caractères sur une ligne de 7bits.

Pourquoi 7bits? Le code ASCII, dans sa version non-étendue, est codé sur 7bits. --> Moins de LEDs, moins cher.

Alors tout d'abord, quelque explications. Ceux qui ont déjà reversé son simplissime schéma l'auront remarqué, le mappage des leds est obscure:

Il n'est pas question ici de vous filer un cours de programmation/électronique... D'autre le font déjà ailleurs. C'est pourquoi je vous encourage à aller faire un tour sur le net!

On voit sur le schéma que les LEDs ne sont pas mappées sur un seul port (comme on l'aurait fait le plus simplement...) mais sur deux port. Pourquoi? Bien, pour pouvoir sortir l'USART et l'ICSP de l'AVR facilement. Et voilà, c'est aussi simple que ça!
Nous devrons donc créer une fonction qui re-mappera un octet (paramètre) sur les deux ports.

Notre fonction d'écriture...

C'est à ce moment que je dois remercier le mystérieux ste7an, qui à mis en lumière LE bug du badge. Raison? --> Mauvaise fonction de re-mappage. Je prendrai compte de sa correction dans la suite de l'article. Merci encore à lui!

La fonction de mappage utilisée dans les badges (fonction corrigée, hein) peut sembler un peu ésotérique. Mais il n'en est rien! Je ferai mon possible pour dégrossir le truc.

#define _BV(bit) (1 << (bit)) 

void copy2array(char value)
{
	char byte=0;
		PORTB=0;
		PORTD=0;
		PORTB |= (((value^42)&_BV(0))?_BV(1):0);
		PORTB |= (((value^42)&_BV(1))?_BV(0):0);
		PORTD |= (((value^42)&_BV(2))?_BV(6):0);
		PORTD |= (((value^42)&_BV(3))?_BV(2):0);
		PORTD |= (((value^42)&_BV(4))?_BV(3):0);
		PORTD |= (((value^42)&_BV(5))?_BV(4):0);
		PORTD |= (((value^42)&_BV(6))?_BV(5):0); 
}

Vous remarquerez sans doutes le "value^42" qui traine au milieu du code. En fait, le code n'est pas stoqué "en claire" dans la mémoire du composant (ce qui évite aux petits malins de dumper simplement le code, pour en extraire la solus du chall). C'est un faible cryptage (XOR) permettant de décrypter "à la volée" les données présentes en mémoire. On l'utilisera aussi dans l'exemple de cet article.

La macro _BV(), très utilisée dans pleins de fonctions diverses et variées, à tous les niveaux, dans tous les programmes, permet de "sélectionner" un bit. Ici, on reprend chaque bit (suivant son mappage) et on lui affecte la valeur d'un bit de l'octet "value". Une petite analyse de la fonction devrait vous faire comprendre le cheminement.

Notre fonction principale...

Notre fonction principale, ici encore, dérivée du firmware "officiel" du badge, est suffisamment simple pour qu'on ne s'y attarde pas trop.

int main(void)
{
	char EasterMSG[20]="Nothing there N00b!";
	char CHALL[23]={0x62,0x4f,0x46,0x46,0x45,0xa,0x7d,0x45,0x58,0x46,0x4e,0xa,0x4c,0x45,0x58,0xa,0x64,0x6e,0x62,0x18,0x61,0x1b,0x1b}, i=0;
	
	DDRD=0xff;
	DDRB=0xff;
	PORTB=EasterMSG[2];
	while(1==1)
	{
		i=0;
		EasterMSG[0]=*(CHALL+i);
		while(*(CHALL+i))
		{
			copy2array(*(CHALL+i));
			_delay_ms(40);
			i++;
		}

	}
	return 0;
}

La variable "EasterMSG" est un petit message à l'attention de ceux qui auraient essayé de chopper le code en dumpant la flash du composant. Comme il n'est pas utilisé par le programme, il devrait etre scratché par le précompilateur. En effet, une des principales mission des pré-compilateur, c'est de faire le ménage (variables statiques, macros, defines...) en remplaçant chaque expression par son équivalent le plus astucieux. C'est pourquoi on voit la ligne "PORTB=EasterMSG[2];" qui sert à faire entrer la chaine de caractère dans la flash de l'AVR. En fait, ça reviens à faire un "volatile" (Je vulgarise pas mal, mais, vous devriez comprendre)

Élaboration du code.

Bigre! Passons à la pratique. Déjà, on va virer tout ce qui ne nous sert pas --> cryptage, message d'accueil des dumperz, etc...


#define F_CPU 1000000 // Suivant le prescaling de l'oscillateur
#include <avr/io.h>
#include <util/delay.h>

void copy2array(char value);
int main(void)
{
   char Hello[]="Hello World!", i=0;
   // Initialisation des ports B et D en entrées ou sorties.
   DDRD=0xff;
   DDRB=0xff;
   // Boucle infinie --> Répetition du message.
   while(1==1)
   {
      i=0;
      // Tant que *CHALL + i tappe dans le bon segment, ça roule
      while(*(Hello+i))
      {
         copy2array(*(Hello+i));
         // On attends un peut (base de temps fausse)
         _delay_ms(1000);
         // Caractère suivant!
         i++;
      }

   }
}

void copy2array(char value)
{
      // Initialise les ports
      PORTB=0;
      PORTD=0;
      PORTB |= ((value&_BV(0))?_BV(1):0);
      PORTB |= ((value&_BV(1))?_BV(0):0);
      PORTD |= ((value&_BV(2))?_BV(6):0);
      PORTD |= ((value&_BV(3))?_BV(5):0);
      PORTD |= ((value&_BV(4))?_BV(4):0);
      PORTD |= ((value&_BV(5))?_BV(3):0);
      PORTD |= ((value&_BV(6))?_BV(2):0);
      //                   ^       ^
      // Bit         "MÉMOIRE"    "PHYSIQUE"
}

Voilà notre code!

Compilation

La compilation se fait avec AVR-Gcc. Excellente toolchain libre, et extrêmement fonctionnelle. Pour flasher le firmware de tous les badges (il y en avait 120, que les mecs de la NDH ont soudés A LA MAIN O___O), j'ai utilisé un makefile qui réduisait le temps de flashage à 2/3s par badge. Il est disponible dans l'archive complète, en bas de page.

Premièrement, vous avez besoin des programmes suivants:

  • gcc-avr
  • binutils-avr
  • gdb-avr
  • avr-libc
  • avrdude
Sur une Debian/Ubuntu, tapez simplement:
sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc avrdude

Tout d'abord, copiez le code source dans un fichier, ouvrez une console, et placez vous dans le bon dossier. Ceci fait, on peut alors appeler avr-gcc, comme un gcc normal, tout en lui fournissant des informations sur le type de binaire à générer, le type de composant, etc...

La liste des options d'avr-gcc est longue comme le bras. Je vous encourage à lire le man pour en avoir un avant-goût, et faire les choses dans les règles de l'art (pas comme moi, donc).

avr-gcc -Os -g -Wall -I.  -mmcu=attiny2313 -c -o main.o main.c
avr-gcc -g -mmcu=attiny2313 -o main.elf main.o
avr-objcopy -j .text -j .data -O ihex main.elf main.hex

avr-gcc, c'est le compilo. Pour le reste:

    Première ligne : avr-gcc -Os -g -Wall -I. -mmcu=attiny2313 -c -o main.o main.c
  • -Os : Optimisation de la taille
  • -g : Inclure les données de debug
  • -Wall : Afficher tous les avertissements.
  • -mmcu : Type de composant (jeu d'instruction)
  • -I : Dossier à inclure pour les headers
  • -o : Fichier de sortie (obj)
  • Deuxième ligne : avr-gcc -g -mmcu=attiny2313 -o main.elf main.o
  • -g : Inclure les données de debug
  • -mmcu : Type de composant (jeu d'instruction)
  • -o : Fichier de sortie (elf)
  • Troisième ligne : avr-objcopy -j .text -j .data -O ihex main.elf main.hex (avr-objcopy permet de mixer la ratatouille, et, par conséquent, de récupérer des bouts des "bin" compilés, pour les incorporer au ".hex" final.)
  • -j : Section(s) à importer -->
  • -mmcu : Type de composant (jeu d'instruction)
  • -O : Type de binaire généré.

Flashââââge de badge

Et c'est tout.... Concernant la compilation. Pour faire tourner notre code sur le badge, il faut le flasher! Le flashage consiste à écrire le code compilé (.hex) dans la flash. Ainsi, le composant exécutera les premières instructions qu'il aura sous la dent, et notre badge clignotera. Pour se faire, on va utiliser avrdude:

# avrdude -p t2313 -c usbasp -U flash:w:main.hex

Si vous utilisez un programmateur USB, et que vous n'avez pas bien réglé votre udev, il vous faudra exécuter cette commande en root. En théorie, vous devriez voir un truc dans ce genre:

avrdude -p t2313 -c usbasp -U flash:w:main.hex

avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e910a
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: reading input file "main.hex"
avrdude: input file main.hex auto detected as Intel Hex
avrdude: writing flash (336 bytes):

Writing | ################################################## | 100% 0.28s



avrdude: 336 bytes of flash written
avrdude: verifying flash memory against main.hex:
avrdude: load data flash data from input file main.hex:
avrdude: input file main.hex auto detected as Intel Hex
avrdude: input file main.hex contains 336 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.17s



avrdude: verifying ...
avrdude: 336 bytes of flash verified

avrdude: safemode: Fuses OK

avrdude done.  Thank you.

Et voilà! Vous avez codé votre premier HelloWorld sur un badge de la NDH2k11 (ou tout autre support AVR... Question d'addaptation!) Mais, ce n'est pas fini. En effet, la programmation d'un AVR induit la configuration de plein de choses... comme les fuses, que l'on verra dans la prochaine partie, ainsi que la partie "makefile" du badge :)

Place à la joie simple qui déchire les yeux:

Youpppiiii!
++ Tixlegeek.