Pichon Julien

Pilotage d'un afficheur 7 segments

2009-11-22T11:53:00.043+01:00

Un afficheur 7 segments est un composant qui permet d'afficher les chiffres de 0 à 9. Ils sont encore utilisés aujourd'hui malgrè l'importante présence du LCD sur le marché de l'affichage électronique. Les 7 segments sont adaptés lorsqu'un large affichage numérique est requis comme pour les écrans dans les gares, les montres/horloges digitales, calculatrices, multimètres ... En plus de cela ils sont économiques, robustes et fiables comparés aux LCD.

Comment ça fonctionne

Un segment est en fait une LED, et les 7 sont arrangées en forme de huit. Pour disposer les chiffres il faut allumer certains segments, et en laisser d'autres éteints. Ces segments pour être identifiés facilement sont associés à des lettres:

Si l'on s'intéresse de plus prés au brochage, on s'aperçoit que chaque LED possède une de ses extrémités connectée à une broche commune. Lorsque toutes les anodes des LED sont mises en commun on parle d'un 7 segments à anode commune (Common anode), et cathode commune (Common cathode) lorsque les LED ont leur cathode en commun. Les boitiers de ces équipements sont donc équipés de 10 broches (8 broches + 1 commune + alimentation + masse).
Pour allumer un segment sur un "Common cathode", il faut utiliser les pin d'un des ports de l'ATtiny2313. Les configurer en sortie, puis passer certaines au niveau HAUT pour pouvoir afficher le chiffre désiré. Pour un "Common anode" c'est différent, il faut configurer certaines pin en entrée pour pouvior les mettre à la masse et ainsi laisser passer le courant.

Montage

Voici le composant:

C'est un afficheur 7 segments que j'ai récupéré, et dont j'ignore le modèle/la marque. J'ai donc avec tatonnement et un peu de chance réussit à découvrir que c'est un "Common anode" dont voici le brochage:

Il possède en réalité 8 segments, un segment supplémentaire nommé dp (pour decimal point) permet comme son nom l'indique d'afficher un point pour faire la séparation entre les chiffres avant la virgule et après. Une chose assez surprenante c'est que le dp est à gauche, contrairement à la majorité des 7 segments où il est à droite. Ca m'apprendra à faire de la récup' dans le grenier tiens :/. De plus j'ignore l'utilité des broches 3, 5, 8.

Comme on peut le voir sur le schéma, piloter ce 7seg demande 8 broches. Une résistance est placée entre chaque masse des segments et la pin du microcontrôleur. J'aurais très bien pu mettre une résistance entre Vcc et la broche d'alimentation du 7seg, mais l'éclairage des LED n'aurait pas été uniforme comme expliqué dans cet article.

Le montage réalisé sur ma platine d'essai:

Oui je sais ça fait un peu fouillis avec les câbles :), plus tard quand j'aurais le matériel je réaliserai des circuits imprimés.

Tournons nous à présent vers le code nécessaire pour faire fonctionner l'afficheur.

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

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

#include "7segment.h"

/**
 * We use Timer1 to trigger an interrupt
 * at 1Hz
 */
void init_timer()
{
    TCNT1 = 0;

    /* Clear Timer on Compare Mode */
    TCCR1B |= (1<<WGM12);

    /* TOP for the counter */
    OCR1A = 15624;

    /* Enable interrupt when for CTC */
    TIMSK |= (1<<OCIE1A);

    /* start the timer with a prescaler of 64 */
    TCCR1B |= (1<<CS10) | (1<<CS11);
}

int main(int argc, char *argv[])
{
    init_timer();
    sei();

    while(1) {

    }

    return 0;
}

ISR(TIMER1_COMPA_vect)
{
    static unsigned char i = 0;

    put_number(i);

    if(i < 10)
        i++;
    else
        i = 0;
}

Je commence par initialiser le timer1 de manière qu'il déclenche une interruption toute les secondes (1Hz). Ensuite dans le gestionnaire d'interruption j'appel une fonction: put_number, à laquelle on envoi un paramètre: le chiffre que l'on souhait afficher. Celle-ci se charge de piloter correctement les pin de l'ATtiny2313 pour afficher le chiffre donné en paramètre sur le 7seg. La fonction est définie dans 7segment.c et ressemble à ceci:

int put_number(int num)
{
    clear_display();
    if(num > 10) {
        return -1;
    }

    switch(num) {
        case 0:
            NUM0;
            break;
  ...
        case 9:
            NUM9;
            break;
    }

    return 1;
}

J'utilise un jeu de macro NUM0 NUM1 ... NUM9 pour simplifier la réutilisation du code, si le brochage change. NUM0 est définit tel que:

#define NUM0 ({ \
    DDR_a |= a; \
    DDR_b |= b; \
    DDR_c |= c; \
    DDR_d |= d; \
    DDR_e |= e; \
    DDR_f |= f; \
})

DDR_a est définit dans l'en-tête 7segment.h, il correspond au Data Direction Register du port auquel est connecté le segment "a". "a" quant à lui est aussi définit dans 7segment.h et il correspond à une pin du microcontrôleur (PB0, PD2 ...). Ainsi on peut utiliser cette bibliothèque indépendemment du brochage fait, il faut juste renseigner correctement dans 7segment.h quel segment est connecté à quel broche, et aussi indiquer à quel port le segment est connecté.
Pour le montage que j'ai effectué voici comment sont renseignées ces informations.

/* Specify the pin-out */
#define a    (1<<PB0)
#define b    (1<<PB3)
#define c    (1<<PB2)
#define d    (1<<PD5)
#define e    (1<<PD4)
#define f    (1<<PD3)
#define g    (1<<PB4)
#define dp    (1<<PD2)

#define DDR_a    DDRB
#define DDR_b    DDRB
#define DDR_c    DDRB
#define DDR_d    DDRD
#define DDR_e    DDRD
#define DDR_f    DDRD
#define DDR_g    DDRB
#define DDR_dp    DDRD

Le code source complet se situe ici.

Aller plus loin

Le montange que je vous ai présenté est simple. Mais qu'arrive-t-il si l'on souhaite piloter plusieurs 7 segments avec un seul ATtiny2313 ? Toutes les broches des ports sont vite consommées. Il existe pour cela plusieurs solutions pour pallier le problème:

Binary Coded Decimal

Le BCD est un composant électronique qui convertit une entrée décimale codée en binaire, en un ensemble de signaux qui active les bon segments de l'afficheur pour afficher le nombre décimale codé en binaire donné en entrée.

L'intérêt de ce composant est l'économie des broches utilisées par le microcontrôleur, mais aussi l'économie du code qui doit piloter l'afficheur 7 segments, en effet en utilisant le 4511 on lui délègue la gestion de l'afficheur. On lui soumet juste en entrée un nombre décimal codé en binaire sur les 4 entrées ABCD.

Le multiplexage temporel

Cette technique est basée sur le phénomène de la persistance rétinienne, qui consiste à disposer plusieurs afficheurs 7 segments branchés sur un même bus, puis les sélectionner tour à tour pour afficher un chiffre sur chaque afficheur (à la manière d'un signal chipselect). Un seul 7seg affiche un chiffre pendant que les autres n'affichent rien. Si le rafraichissement des 7-segments est assez rapide, on arrive à tromper l'oeil et lui faire croire qu'ils sont tous allumés simultanément et affiche bien un nombre, alors qu'en réalité un seul est allumé.

Illustrons cela par l'exemple. Deux 7-segments sont branchés sur un même bus, qui lui même est branché sur le port D de l'ATtiny2313 (PD0 à PD6). Puis on utilise une partie du port B pour sélectionner l'afficheur qui va recevoir les données via le port D et donc les afficher, cette sélection se fait grâce à un transistor qui agit comme un bouton poussoir.

Avec un peu de folie on pourrait même penser à ajouter un 4511 entre le bus et la série de signaux sur le PORTD:

AVR et IRQ

2009-11-08T14:47:00.006+01:00

Le principe des IRQ

Tout comme les processeurs "normaux", les AVR peuvent être interrompu pendant leur fonctionnement normal (exécution du code/firmware) par un équipement externe grâce au moyen des IRQ (Interrupt ReQuest), ou interruptions matérielles en Français. Une IRQ implémentée grâce a une ligne d'interruption, n'est en fait qu'une simple ligne physique qui relie un périphérique à une broche du microcontrôleur. Cette ligne est toujours dans un état stable (Haut ou Bas), mais change d'état quand quelque chose de spécial se produit: une interruption générée par le périphérique. Cette interruption peut correspondre à une myriade (oui j'essaye d'étendre mon vocabulaire ;)) de choses: quelqu'un a appuyé sur un bouton, un périphérique a fini un travail qu'on lui avait demandé ...
Ce type de fonctionnement s'oppose au polling. Le Polling consiste à vérifier en permanence qu'un évènement ne s'est pas produit. Par exemple, le microcontrôleur va regarder toute les 20ms si une broche n'a pas changé d'état. Ce type de fonctionnement est moins performant car il consomme plus de temps et de ressources, comparé aux IRQ.

Le montage

Dans le montage suivant, j'ai réutilisé le code du PWM de l'article précédent. Sauf que le duty cycle n'est plus augmenté au moyen d'une boucle for, mais lorsqu'une interruption survient. Cette interruption est générée par l'appui sur un bouton poussoir. Une fois que le duty cycle atteint son maximum (255 sur un Timer 8 bits), il retombe à 0, pour ensuite remonter jusqu'à 255 ...

Voici le schéma:

Il ne change pas énormément du montage précédent, si ce n'est que j'ai utilisé le seul bouton que j'avais dans ma boîte à gouter pour générer une IRQ, au lieu de continuer à l'utiliser pour mettre sur ON/OFF l'alimentation du montage. Fini les petites folies.
A noté que j'ai mis une résistance de forte valeur entre INT0 et GND. Cela s'appel une pull down et permet lorsque le circuit est ouvert (boutton poussoir non pressé), de garder INT0 à l'état BAS car sinon l'entrée serait flottante, et des comportements non souhaités pourraient survenir.

Le montage en photo:

Le code:

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

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

void initialize_pin()
{
/* Pin change mask register
 * enable interrupt for INT0 */
PCMSK |= (1<<INT0);

/* Rise interrupt on falling edge of INT0 */
MCUCR |= (1<<ISC01);

/* Enable Interrupt */
GIMSK |= (1<<INT0);

/* Set PB2 as input */
DDRB |= (1<<PB2);
}

void init_timer()
{
/* Set Fast PWM mode. */
TCCR0A |= (1<<WGM00) | (1<<WGM01);

/* Clear 0C0A on compare. */
TCCR0A |= (1<<COM0A1);

/* Start timer, no prescaling. */
TCCR0B |= (1<<CS00);

/* Duty cycle 0% */
OCR0A = 0;
}

int main(int argc, char *argv[])
{
initialize_pin();
init_timer();
sei();

while(1) {
  ;
}
return 0;
}

ISR(INT0_vect)
{
if(OCR0A >= 255)
  OCR0A = 0;
else
  OCR0A += 10;
}

La fonction initialize_pin se charge d'écrire les valeurs dans les registres adéquats, pour que l'interruption INT0 soit déclenchée lorsqu'un front descendant est détecté sur la broche INT0. En effet nous pouvons configurer le changement d'état qui fait que l'interruption est déclenchée:

Un niveau bas est détecté sur la broche.
Lorsque d'un changement d'état de la broche (que la transition se fasse de Haut vers Bas ou Bas vers Haut).
Lors d'un front montant.
Lors d'un front descendant.

L'ISR (Interrupt Service Routine) INT0_vect est exécutée donc lorsqu'une interruption est générée (appui sur le bouton). Elle se charge juste d'augmenter d'environ 4% la valeur du duty cycle, par conséquent l'éclairage de la LED paraît de plus en plus puissant au fur et à mesure que l'on appui sur le bouton. Lorsque le duty cycle atteint 100% il est remis à 0.

Je ne reviens pas sur la fonction init_timer vu auparavant.

La vidéo:

Désolé pour la qualité, c'est tourné avec un appareil photo. En vrai on voit bien la nuance de la puissance d'éclairage qui varie jusqu'à son extinction.

Rendez-vous au prochain montage, qui je pense concernera un afficheur 7 segments.

PWM avec un ATTiny2313

2009-10-30T23:08:00.024+01:00

Salut à tous,

Ca se voit que c'est les vacances, je poste beaucoup :D. Ce billet décrit ce qu'est le PWM, à quoi il sert, son implémentation dans les AVR. Et enfin je finis par un montage qui illustre cette technique, avec l'éclairage progressif d'une LED.

Le PWM, qu'est-ce ?

Le Pulse Width Modulation est une technique de modulation comme son nom l'indique, qui permet de faire varier la durée d'une impulsion électrique. Ici on ne module pas la fréquence qui reste la même, mais plutôt la durée d'une impulsion.

Comme le microcontrôleur fait partie d'un monde numérique (digital), il ne peut fournir qu'une sortie haute (5V par exemple), ou basse (0V toujours par exemple :p). Le problème c'est que son environnement est analogique (ensemble infini de valeurs). Un moteur ne peut pas se contenter d'être allumé ou éteint, pareil pour une LED, il faut donc que le microcontrôleur puisse fournir une sortie analogique.

Certains AVR disposent d'un module ADC (Analog to Digital Converter), l'inverse de ce que l'on veut. On prend en entrée une valeur analogique, que l'on convertie par la suite au format numérique. Mais aucun ne contient de DAC. Il existe cependant un moyen d'obtenir cette fonctionnalité, vous l'aurez deviné: le PWM.

En mettant de façon répétitive une broche de l'AVR à une sortie haute, puis basse, le résultat produit est la moyenne du temps que la sortie est haute.

Pour une LED si nous prenons une échelle de temps très petite, on observe que le courant qui la traverse, possède un délai non nul. Lorsque l'on met une sortie haute sur une LED, puis que nous la mettons basse, il y a un temps de latence avant que la LED ne s'éteigne. Ainsi en mettant ON/OFF de façon répétitive, on obtient une puissance d'éclairage différente. Plus le temps la LED est à ON, plus l'éclairage paraîtra puissant.

Le FAST PWM chez les AVR

Le PWM dans les micro-contrôleurs d'Atmel repose sur l'utilisation des TIMERS. Pour se familiariser avec, voici un tuto, et un autre sur AVRFreaks. Pour résumer, sur AVR un timer est un composant hardware configurable qui va compter de 0 jusqu'à une valeur configurable, à une certaine fréquence elle aussi configurable. Ensuite on peut utiliser ce compteur de plusieurs façon:
* Déclencher une interruption lorsque la valeur max du compteur est atteinte.
* Comparer la valeur du compteur à une valeur que l'on désire, et déclencher une interruption lorsqu'elles sont égales (Match), ou "setter" un flag.
...

Plein d'utilisation sont possibles avec les timers, dont le PWM. Il existe aussi plusieurs mode de PWM, ici je ne presente que le FAST PWM.

Le FAST PWM utilise un modèle en dents de scie:

La courbe représente la valeur du compteur qui monte de BOTTOM à TOP. Subitement elle recommence à BOTTOM pour remonter à TOP etc ... Le seuil ("compare" sur le graphique) est une valeur qui lorsqu'elle est dépassée par le compteur change la valeur de la sortie. Le compteur part de BOTTOM, la sortie est basse, il dépasse le seuil, la valeur sortie et passe à haut, le compteur déborde et retombe à 0, la sortie redevient basse. En jouant sur le seuil, on joue sur le temps pendant lequel la sortie reste HAUTE. Un seuil à la moitié du compteur, représente une sortie haute 50% du temps. Un seuil égal à BOTTOM représente une sortie haute 100% du temps. Et inversement un seuil égal à TOP représente une sortie tout le temps basse.

Le montage

Le schéma du montage ressemble à celui de cet article, sauf que la LED est sur la broche OC0A:

Je me suis permis le même genre de folie que la dernière fois: un bouton pour laisser le montage branché sans qu'il soit tout le temps alimenté.

Le code:

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <avr/io.h>

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

void init_timer()
{
/* Set Fast PWM mode. */
TCCR0A |= (1<<WGM00) | (1<<WGM01);

/* Clear 0C0A on compare. */
TCCR0A |= (1<<COM0A1);

/* Start timer, no prescaling. */
TCCR0B |= (1<<CS00);

/* Duty cycle 0% */
OCR0A = 0;
}

void init_led()
{
DDRB |= (1<<PB2);
}

int main(int argc, char *argv[])
{
int i;

init_led();
init_timer();

while(1) {
  for(i=0; i < 255; i++) {
      OCR0A = i;
      _delay_ms(10);
  }

  for(i=255; i > 0; i--) {
      OCR0A = i;
      _delay_ms(10);
  }
}

return 0;
}

Ci-dessus on commence par configurer la broche OC0A (PB2) en sortie. Ensuite le Timer0 de 8bits est mis en mode Fast PWM, et sort le résultat sur la broche OC0A.
Ensuite dans la boucle infinie, le premier for se charge de modifier le "duty cycle" (% de temps pendant lequel la LED est allumée, autrement dit la puissance d'éclairage) en l'incrémentant. On modifie le duty cycle tout simplement en changeant la valeur dans OCR0A, i=0 représente 0% et i=255 (car nous sommes sur un timer 8bits) représente 100% de la puissance de la LED. Ensuite la deuxième boucle for diminue la puissance de la LED, en décrémentant le duty cycle.

Le code est flashé de la même façon que dans l'article "Hello World AVR":

avr-gcc -Os -g -Wall -mmcu=attiny2313 -o main.elf main.c
avr-objcopy -j .text -j .data -O ihex main.elf main.hex
sudo avrdude -c usbtiny -p t2313 -i 8 -U flash:w:main.hex

Enfin finissons par une vidéo réalisée sans trucage :)

Livres de chevet

2009-10-29T12:25:00.006+01:00

Bonjour,

Aujourd'hui petite parenthèse entre deux articles sur les AVR. Je vais vous présenter mes livres de chevet actuels. Le premier s'intitule "Beautiful Code" et a été écrit par Andy Oram et Greg Wilson.

C'est en fait une compilation de plusieurs morceaux de code, de descriptoin d'architecture de systèmes, avec des commentaires de leur auteur respectif, mais aussi des auteurs du livre. On découvre au fil des différents cas que la notion de beauté du code est subjective, et varie d'une personne à l'autre. Par exemple au Chapitre 1, pour Brian Kernighan (qui au passage a énormément participé au développement d'UNIX dans les laboratoires Bells, et est considéré comme un demi-dieu par beaucoup d'adorateurs), avec son "Regular Expression Matcher", nous explique que la beauté du code réside dans le fait que celui-ci doit être compact et puissant. Tandis que pour Kargel Fogel, qui nous parle de l'architecture du moteur de comparaison de code de Subversion, la beauté du code réside dans une architecture bien pensée et évolutive.

Ensuite le deuxième livre que je lis c'est "Code Reading The Open Source Perspective", écrit par Diomidis Spinellis.

Dans ce livre l'auteur nous explique que dans le monde de la programmation, nous éprouvons des difficultés à produire du code de bonne qualité. Ceci est dû en partie au fait que le programmeur ne lit pas le code d'autrui pour s'inspirer et s'améliorer. Pour lui la solution réside dans la lecture de code open source. Il nous apprend donc à naviguer dans le code d'autres personnes, de comprendre son architecture, de se focaliser sur l'utile et faire abstraction du reste, et aussi de faire la différence entre du code de mauvaise qualité, et du code de bonne qualité.

Hello world AVR

2009-10-28T16:16:00.015+01:00

J'enchaîne avec ce deuxième article sur l'électronique et l'embarqué pour présenter le montage de base qui permet de programmer la mémoire flash de l'ATTiny2313. Une LED a été ajouté au montage pour pouvoir attester de son bon foncionnment : un Hello World sans printf autrement dit ;).

Un AVR se programme d'une façon particulière: la programmation ICSP (In-Circuit Serial Programming). Comme son nom l'indique ce type de programmation permet de flasher un firmware dans un AVR déjà monté dans son circuit final. Il faut cependant prévoir la connectique adéquate (4 pins supplémentaires). Un des avantages de cette solution est le fait de pouvoir faire un upgrade du firmware de la puce, sans avoir à la dessouder, la placer sur un circuit pour la flasher et la ressouder.

L'ICSP utilise un bus série SPI (Serial Peripheral Interface). Concrètement c'est un bus (ensemble de lignes) série, synchrone (qui utilise une horloge) multi-esclaves. Il se présente sous la forme de 4 câbles (MISO/MOSI/SCK/SS). La signal Slave Select (SS) n'est pas utilisé ici, car dans notre cas il y a un maître (le programmeur), et un esclave (l'ATTiny). SS devient utilse lorsque plusieurs esclaves sont reliés sur le même bus SPI.

Voici le schéma de mise en oeuvre:

La résistance de 10k sur RESET permet de maintenir le signal au niveau haut (donc inactif car la barre au dessus du mot RESET indique que le signal n'est actif qu'au niveau bas), on évite ainsi une entrée flottante, grâce à cette résistance de rappel.

L'alimentation est fournie par le programmeur (AVR Pocket Programmer de chez Sparkfun). Attention, je ne sais pour quelle raison, pour que le sparkfun puisse fournir le courant au montage, il faut que celui-ci soit bien entendu branché en usb sur la PC, mais via un HUB usb:

Voici un schéma qui montre la disposition des pins du "6-pin female ICSP header":

Et une photo du montage:

Sur le montage je me suis permis une petite folie: l'ajout d'un bouton poussoir pour couper l'alimentation du circuit lorsque je ne m'en sert pas. Notez que lors de la phase de programmation de l'avr il faut pousser le bouton !

Pour faire clignoter la LED il faut jouer avec les ports de la puce. Je vous envoie vers ce tuto bien fait.

Après avoir lu le tutoriel, le code est assez explicite. La ligne 11 met la pin PB0 en sortie. La ligne 14 place au niveau haut PB0, la ligne 17 la place au niveau bas. La fonction _delay_ms provient de la bibliothèqe avr-libc ainsi que les macro tel que PORTB, PB0 etc ... Qui facilite grandemment le développement.

Pour compiler ce programme et flasher ce programme il faut disposer d'AVRDude, et de gcc pour avr (paquets gcc-avr & avrdude sous debian).


avr-gcc -Os -g -Wall -mmcu=attiny2313 -o main.elf main.c
avr-objcopy -j .text -j .data -O ihex main.elf main.hex
sudo avrdude -c usbtiny -p t2313 -i 8 -U flash:w:main.hex

La première ligne cross compile au format ELF le programme. La deuxième convertit le format ELF en HEX, compréhensible par avrdude. La dernière demande à AVRDude de flasher l'exécutable (fichier HEX) dans l'ATTiny2313.

Je finis sur une vidéo du montage en action (par contre la fréquence du clignotement ne correspond pas à 500ms, je l'avais changé):

Sur la vidéo j'ai laissé les fils pour l'ICSP, mais on peut les retirer, et juste mettre sous tension le montage ATTiny2313 + résistance 320 Ohms + LED, et cela fonctionne parfaitement.

A bientôt pour le prochain article qui portera sur le Pulse Width Modulation (PWM), qui permet entre autres de jouer sur la luminosité de la LED.

Electronique et AVR

2009-10-28T11:31:00.015+01:00

Bonjour, ajourd'hui je vais vous parler d'une chose à laquelle je m'intéresse de plus en plus: l'Electronique. Sans pour autant aller jusqu'à la compréhension chimique et physique des composants, je me penche sur les microcontroleurs et leur programmation. C'est sûrement une des conséquences de mon envie de comprendre le fonctionnement d'un système dans son ensemble.
Au début j'ai commencé l'informatique sur un système windows à coder des applications en userland diverses et variées, pour ensuite passer sur un Linux, qui m'attirait parce que le fait qu'il soit Open Source, et donc décorticable pour le comprendre m'intéressait. Je me suis donc intéressé au fonctionnement des systèmes d'exploitations de type UNIX. Pour enfin m'intéresser ajourd'hui à l'électronique et aux microprocesseurs, éléments qui sont au plus bas niveau.

Je ne suis pas le seul dans ce cas là, le constat suivant est souvent fait: certaines personnes de formation informatique "haut-niveau", qui descendent vers le "bas niveau". Et on observe que l'inverse se produit aussi souvent: les personnes de formation "bas niveau" montent vers le "haut niveau".

Voilà pour l'histoire de ma vie et le soupçon de philosophie ethnologique. A présent je vais vous présenter le matos que j'ai commandé pour m'introduire au monde des microcontroleurs.

J'ai tout d'abord commandé une platine d'essai, qui permet de poser les composants sans les souder. Elément très pratique pour le prototypage des circuits.

En même temps j'ai commandé un package contenant des fils conducteurs facilement enfichables dans cette platine d'essai:

Ensuite vint la reception des microcontroleurs ATTiny2313. J'ai choisit la marque atmel, car d'abord on peut coder en C (très légèrement modifié) ces petites bêtes. De plus il existe une toolchain très performante sous UNIX pour pouvoir développer sur microcontroleur AVR d'Atmel. Deux choses qui m'ont plus et m'ont fait choisir ces microcontroleurs.

Mes pupuces en séance de shooting:

Après j'ai commandé un programmeur, qui permet de flasher les programmes
dans à peu près tous les AVR (ATMega, ATTiny). J'ai ce modèle commandé sur sparkfun:

C'est en fait un clone du kit de programmation officiel distribué par ATMEL: le STK500. Celui que j'ai commandé est compatible et implémente le protocole de programmation du kit STK500. La raison de ce choix c'est qu'il est moins cher.

Et enfin pour tous les consommables tels que résistances, condensateurs, boutons, led ... J'ai récupéré cela dans le grenier de mes parents, car mon père faisait quelques petits montages il y a longtemps. J'ai tout confiné dans ce que j'appel la boîte à gouter:

Pour conclure, voici des photos de mon environnement de travail:

Dans un prochain article je ferai un how to sur le montage de base pour flasher l'ATTiny2313 avec un code qui fait clignoter une LED, le fameux Hello World en électronique.

pmBSD

2009-07-26T19:28:00.004+02:00

Bonjour à tous ceux qui me lisent (si il y en a :/),

J'ai rejoint un projet Open Source il y a quelques temps, mais j'ai attendu ma première contribution à celui-ci pour en parler.

pmBSD, c'est son nom. C'est un OS de type Unix qui est développé ex nihilo et comme l'indique le BSD dans le nom, il aura une philosophie et une façon de fonctionner similaire à la famille BSD.

pmBSD est pour l'instant embryonnaire, le kernel a un système de gestion de mémoire virtuelle, initialise la gdt, l'idt ... Mais ne fait pas encore du multitâche, ni ne possède un VFS.
Mais pmBSD n'est pas qu'un kernel en effet comme tous les BSD il vient avec son bootloader; et c'est dessus que j'ai effectué ma première contribution. Je décrit ce que j'y aie fait dans cet article (en Anglais).

L'Octree: une structure de données pour accélérer les calculs

2009-07-14T13:23:00.024+02:00

Ca faisait un bout de temps que je n'avais pas posté. Pour quelqu'un qui commence à rediger un blog c'est pô terrible. Donc je m'y remet en vous parlant des octrees, et plus précisemment d'une bibliothèque qui permet de les mettre en oeuvre: Etree library.

C'est quoi d'abord un octree ? (Wikipedia, vous n'y échapperez pas !). Je vous la fait court quand même: c'est une technique de partitionnement spatiale. On prend un cube qui représente un bout d'espace (à l'échelle que vous voulez, le cube peut représenter 1cm3 comme 1000km3, tout dépend de l'usage), découpez le en 4 (suivant deux axes perpendiculaires donc :p), pour obtenir 8 sous-cubes égaux. Ces sous-cubes sont appelés octants. Ensuite vous découpez à nouveau ces sous-cubes en 8 ... Voilà en très gros le principe de l'algo. A savoir que pour leur représentation interne la structure de donnée utilisée est un arbre. Il faut aussi savoir que lorsque l'on edécoupe, on fait ce que l'on veut: on peut ne redécouper q'un seul octant sur les 8, ou 2, ou 3 encore une fois c'est en fonction des besoins. L'octree ne signifie juste qu'un noeud de l'arbre a au maximum 8 fils.

Humm, mokay, mais à quoi ça sert ? On utilise ce genre de chose pour réduire les temps de calcul. Par exemple dans les jeux vidéos, et tout ce qui touche à la 3D en général, on représente une scène avec des objets contenus à l'intérieur de celle-ci, par un octree. Le découpage de celui-ci se fait de façon régulière, en ne subdivisant que la où c'est nécessaire (on a un niveau de profondeur élevé que là où il y a beaucoup d'objets). Avec la scène représentée de cette façon lorsque l'on doit calculer son rendu, il est facile de déterminer quelle est la partie visible de la scène, qui nécessite des calculs pour son affichage, et quelle partie est invisible et donc ne nécessite aucun calcul.
L'algorithme est aussi utilisé lors des calculs de collision, chaque objet est contenu dans un cube les plus petit possible. Ainsi dans un espace pour calculer les collisions, on ne test pas chaque objet pour savoir si il entre en collision avec un autre (LONG!), on ne test que ceux qui sont dans un même octants, ou dans des octants adjacents.

On voit alors que quelque soit l'application faite le plus important c'est de dimensionner correctement les octants, et jouer habilement avec la profondeur de certains.

Exemple d'octree sur un modèle 3D pour optimiser le rendu des textures:

Mais pourquoi j'ai dû les utiliser ces octrees !?
Actuellement en stage, une partie de l'application que je dois faire, doit stocker la position de certains satellites qui tournent autour de la terre. Parmis les différentes utilisations de cette base de données de satellites, une est de fournir en entrée les coordonnées d'un cube représentant une partie de l'espace, une date, et de récupérer tous les satellites qui se trouvent dans ce
cube à la date donnée.
L'une des premières approche a été de prendre tous les satellites présents dans la base, et pour chacun d'entre eux calculer leur orbite (à l'aide d'une fonction qui m'est fourni), et de regarder si à la date donnée ils sont dans le cube ou pas. A part disposer d'un super calculateur, les temps de réponse seraient extrêmement longs, car en effet la base de données des satellites contient des millions de corps. C'est à ce niveau là qu'entre en jeu les octree. Un octree représente une période de temps, et contient les orbites des différents satellites.
Ce qui fait que lorsque l'utilisateur soumet une date et un cube, je sélectionne l'octree adéquat, je regarde l'octant qui se rapproche le plus du cube soumis en paramètre. J'obtiens ainsi la liste des corps qui se situe dans la zone désirée.

ETREE
C'est une bibliothèque écrit en C, créée à la base pour faire des simulations de tremblement de terre. En plus de créer les octree et les stocker en mémoire, elle a la particularité de rendre les octree persistants sur disque. De plus elle accélère les accès aux octrees grâce à un cache. Autant de critères qui font que je l'ai choisi pour implémenter la solution que j'ai décrit dans le paragraphe précédent.

Je finis sur quelques exemples d'utilisation de l'Etree library:


etree_t *ep = NULL;
ep = etree_open("filename", O_CREAT | O_RDWR, 0, sizeof(payload_t), 3);

Ce que j'ai fait au dessus c'est créer un octree qui sera stocké dans le fichier "filename". Chaque octant de l'octree contient une instance de structure payload_t nous aurons défini plus tôt:


struct payload_t {
 int32_t data;
};

Avant de pouvoir utiliser cet octree il va falloir lui associer un schema.
Le schéma permet d'assurer la portabilité de la structure payload_t entre les plateformes, en effet un entier n'a pas la même taille sur un x86 et un Sparc.


const char *schema = "int32_t data";
etree_registerschema(ep, schema);

Ensuite la bibliothèque permet de faire des trucs bien sympas comme la recherche d'octant en fonction de son niveau, récupérer un voisin etc ... Pour cela je vous laisse creuser la documentation.

NetBSD et Virtualisation

2009-04-23T14:57:00.010+02:00

Comme je l'avais dit dans l'article précédent, j'ai décidé de me mettre à NetBSD. Ici je vais détailler le périlleux chemin que j'ai parcouru pour arriver à installer l'OS par dessus mon Ubuntu sur un vaio VGN-CR11S (le fait que ce soit un vaio est important pour la suite ... oopa :)).

Tout d'abord je sors mon VirtualBox et le lance, avec dans le lecteur virtuel le CDROM de NetBSD que l'on m'a donné sur le salon. Je configure l'installation, et l'écriture sur le disque dur virtuel commence, pour se vautrer lamentablement avec un "Bad Address ...". Bon, je recommence encore une fois et j'obtiens la même erreur. Après un tour sur les forums, je m'aperçois que l'on est plusieurs dans ce cas, et qu'il faut configurer VirtualBox ainsi:

Disable "Enable ACPI"
Disable "Enable IO APIC"
Enable "Enable VT-x/AMD-V"
Set "IDE controller type" to "PIIX4"

Je le fais, mais je me demande si la VT (Virtualization Techonlogies), un jeu d'instruction intel qui améliore la prise en charge de la virtualisation, de mon processeur (Intel Core 2 Duo T7100) est présent et/ou activée sur mon pc. Je retourne faire un tour sur les forums de sony et j'apprends que Sony a bloqué cette feature du processeur pour des raisons de sécurité. Hum mokay, cool. Pas grave je tente quand même l'installation avec les configurations citées au dessus, mais sans la VT activée au niveau hardware, et bim toujours la même erreur.

Tanpis je passe donc sur qemu, me crée un disque dur virtuel:

qemu-img create -f qcow netbsd.img 4G

et lance l'émulateur ensuite:

qemu -hda netbsd.img -cdrom netbsd-iso.img -boot d

L'installation se passe correctement, ouf. Mais au reboot ensuite j'ai un soucis, car l'OS freeze. Je cherche un peu et me rend compte qu'il faut lancer avec l'acpi désactivée:

qemu -hda netbsd.img -no-acpi -localtime

Tout se passe bien, il démarre correctment et je me log en root. Tiens j'ai oublié quelque chose ... mais qu'est ce que c'est ? Ah oui ! La connexion. Je suis en wifi sur mon interface eth1, je créé donc un bridge:

brctl addbr br0

Auquel j'ajoute mes interfaces eth1 et tap0 comme expliqué ici. Ainsi je lance qemu avec une nic et la tap0:

qemu -hda netbsd.img -net nic,macaddr=00:56:01:02:03:04 -net  tap,ifname=tap0,script=/etc/qemu-ifup -no-acpi -localtime

On note ici qu'au démarrage le script qemu-ifup est utilisé pour automatiser l'ajout de tap0 dans le bridge.

Tout ça a l'air cool, mais ça ne marche pas. Après quelques recherches (bien longues à vrai dire), d'autres personnes ont déjà essayé, et ont eut des problèmes. Il faut utiliser une astuce pour pouvoir faire fonctionner un
bridge avec une interface wifi, celle-ci s'appelle l'interface DUMMY. Et avec c'est bon, ça fonctionne.

Je ne suis quand même qu'à moitié satisfait car j'aimerais pouvoir utiliser kvm, qui nécessite l'activation de VT. Il existe des opérations plutôt périlleuses pour y parvenir, et je me tâte à les essayer pour l'instant.

Solution Linux 2009

2009-04-02T08:01:00.004+02:00

Je vais vous parler aujourd'hui de la journée du Mercredi 1 avril 2009 du salon SL 2009, où j'étais présent en tant qu'exposant. Arrivé le matin j'en ai profité pour commencer par faire un petit tour du salon par curiosité. Celui-ci se divise en deux parties, les professionnels et le village association. Chez les pros il y avait du monde (Zend, Talend, Symphony, l'OW2 consortium, Oracle, Mozilla ...), et on a bien remarqué dans le village associatif la présence du GCU-squad et des *BSD. Ensuite le reste de la journée je suis allé m'installer sur le stand d'epsinux pour exposer et présenter l'asso.

Cette journée a été assez riche, j'ai découvert le projet Globull (de Bull), qui est un petit device dont le contenu est crypté à l'aide d'un processeur dédié (on peut rapporcher cela aux TPM). Le projet n'en n'est qu'à ses débuts, mais apparemment les possibilités en matière d'utilisation seraient importantes (SSO ...). On a aussi tenté de me convertir à NetBSD (promis je m'y mets).

L'après midi j'ai été surpris de voir un terroriste poursuivi par des bouchers pendant le salon :). On devait cette animation au GCU-squad (leurs banderoles et slogans que j'avais aperçu le matin sur leur stand, aurait dû me mettre la puce à l'oreille), qui protestait contre la loi Hadopi. Le terroriste représentait un téléchargeur anonyme, et les bouchers armés de couteaux sanguinolent la loi Hadopi.

Bien sûr on avait les deux réactions: "Ouais, puérilité, honte de l'open source toussa ..." et "Trop fort, ces mecs gèrent". Je pense qu'ils ont raison de faire du bruit comme ils le font, en effet j'étais passé sur leur stand pour connaître l'asso et leurs convictions. Le but de l'asso est de proumovoir les Unices libres, mais aussi de rappeler que si des SSII, des Entreprises qui vivent du libre existent, c'est en premier grâce aux développeurs, et contributeurs volontaires qui ont créés ces projets (Linux, *BSD, etc ...) et les font évoluer. Chose à laquelle j'adhère complètement.

edit: hop un lien avec les 'tofs et vidz

Minimal OS

2009-02-20T16:31:00.001+01:00

Bonjour à tous,

J'inaugure mon blog en vous parlant un peu du kernel que je développe.
Bien entendu je le fais à titre purement éducatif et je n'ai en aucun cas l'intention de concurrencer les OS du marché.

Son petit nom c'est MinimalOS (il ne fait vraiment pas grand chose en effet) et il possèdera les caractéristiques principales finales:

Kernel monolithique (je ne pense pas le faire modulaire, car la flemme de développer
tout le système de résolution de dépendance (link) dynamique)
Boot avec Grub (je n'ai pas codé de bootloader)
C'est un clone UNIX (tout est fichier, et supporte donc les opérations POSIX (open, close, read, write, ioctl ...))
L'architecture cible est x86
Allocateur de mémoire très simple (kernel et userland), je verrais pour porter SLAB plus tard
Gestion des IRQ (avec le 8254) et des Exceptions (Notamment le swap).
Une mini pile IP (UDP)

Ce qui est fait actuellement:

Le boot, j'utilise donc GRUB pour m'éviter de faire un bootloader et de batailler avec le mode réel de notre processeur intel préféré (je verrais quand même plus tard pour en faire un). Ainsi pour que Grub puisse reconnaître le kernel, il faut que celui-ci contienne dans ses tout premiers octets une structure spéciale (mboot dans mon code). L'image binaire du kernel doit être dans un format spécial (ELF qui est du binaire produit par GCC de base), je dispose les sections code bss data comme je veux (au niveau des adresses) grâce à un script que je fournis à linker ld (link.ld dans mes sources).

J'ai mis en place la gdt et l'idt. La segmentation (gdt) est de type flat segment comme indiqué dans les manuels intel c'est à dire que je mets deux segments en ring 0 (1 Data, 1 Code) deux autres en ring 3 (1 Data, 1 Code). L'idt a été faite d'une façon qui nous permet de changer et d'ajouter facilement des handlers. De plus j'ai "programmé" le contrôleur d'interruption l'i8254 pour qu'il me fournisse des interrupt vectors correct.

J'attaque prochainement la pagination et je la ferais fonctionner comme dans linux je pense (je mappe le kernel juste au dessus des 3G, et je fais un identity mapping des zones comme le BIOS, VGA display ...)

Je m'inspire fortement de deux tutos franchement bien fait:
http://sos.enix.org
http://jamesmolloy.co.uk/tutorial_html/index.html

Lien temporaire (j'utilise le sourceforge d'un autre projet perso, j'updaterai quand j'aurai une
nouvelle forge): https://sourceforge.net/projects/epsinuxtl/