À LED

par dolivier

À led

L’objet de ce qui est présenté ici est la réalisation d’un petit montage utilisant un arduino ou un clone. Puisque c’est bientôt Noël, ce dernier devrait vous permettre de faire clignoter une led, on pourra essayer néanmoins de faire mieux par la suite.

Tout ceci n’est bien sur qu’un prétexte afin de décrire les différents éléments et les différentes étapes pour pouvoir se lancer dans des projets plus ambitieux. Le web regorge de présentation de ce type et je ne peux que vous encouragez dans vos procrastinations à aller butiner sur d’autre sites web, pour enrichir vos connaissances et trouver de nouvelles idées.

Le matériel

Je ne vais pas me lancer dans une description complète du matériel, mais simplement vous donner quelques éléments concernant la carte électronique de type arduino. J’ai à ma disposition un clone une RedBoard fabriquée par SparkFun qui est compatible avec l’arduino uno.

Carte RedBoard fabriquée par SparkFun

DO à D13
Pins pouvant être configurés soit comme des entrées ou des sorties. Le voltage mesuré ne peut avoir que 2 valeurs 0v ou 5v.D0 et D1 offrent des fonctionnalités supplémentaires
A0 à A5
Entrées analogiques. Elles admettent une tension analogique comprise entre 0 et 5 Volts. Cette tension est ensuite convertie en une valeur comprise entre 0 et 1023.
Bouton reset
Interrompt le programme et le redémarre.
Connecteur USB
Port USB permettant de connecter la carte à un PC. C’est par ce port qu’un programme peut être chargé dans le microcontrôleur. Il sert également à alimenter la carte.
LED de test 13
Connectée à l’E/S D13, si la LED est allumée le voltage sur D13=5V sinon 0V. Utile pour déverminer.
LED x 2 Rx et Tx
Indique le trafic respectivement sur D0 et D1 ou par le port USB. La communication se fait de façon série.

Plaque de câblage rapide En plus de votre carte Arduino ou clone, il vous faut également une plaque de câblage rapide (breadboard) qui vous permet de réaliser des montages provisoires facilement.

La plaque est divisée verticalement en deux, l’alimentation se fait donc sur une unique moitié. Tous les + d’une même colonne sont connectés, de la même façon pour le -. Une ligne i (de 1 à 30) est également connecté ceci toujours sur la demi-plaque (ex Ligne 4 de a à e).

Installation de l’environnement de développement

Commencer par télécharger l’environnement de programmation correspondant à votre PC. Je vais développer cela sous Linux, mais il y a peu de différence sous MacOSX ou windows. Pour archlinux c’est dans le dépot AUR.

% yaourt arduino

Branchez votre carte grâce à un câble USB et lancez le programme arduino

% arduino &

Le programme devrait détecter le type de votre carte et vous devez désigner le bon port USB. dmesg peut vous aider en cas de doute.

% dmesg | tail

[65373.194664] usb 1-3.4: new full-speed USB device number 12 using xhci_hcd
[65373.297140] ftdi_sio 1-3.4:1.0: FTDI USB Serial Device converter detected
[65373.297170] usb 1-3.4: Detected FT232RL
[65373.297498] usb 1-3.4: FTDI USB Serial Device converter now attached to ttyUSB0

On constate donc qu’après avoir connecté la carte j’ai un nouveau port série attaché à ttyUSB0. C’est donc avec celui-ci que nous allons dialoguer avec la RedBoard.

Pour pouvoir écrire sur le port, il faut appartenir au groupe uucp. N’oubliez pas de remplacer damien par votre login.

% sudo usermod -a -G uucp damien

Pour que cela soit actif, le plus simple est de se déconnecter et se reconnecter.

Configuration du port série utilisé.

Utiliser l’environnement de programmation

Plusieurs étapes sont nécessaires :

  1. Concevoir d’abord son programme avec l’environnement de programmation ;
  2. Vérifier ce programme avec le logiciel grâce à la compilation ;
  3. Des messages d’erreur apparaissent éventuellement… on corrige puis vérifie à nouveau en retournant au point 2 ;
  4. On réinitialise la carte en appuyant sur le bouton reset ;
  5. On téléverse le programme sur la carte ;
  6. L’exécution du programme sur la carte est automatique.

Compilation et téléversement

La compilation consiste à vérifier que l’on a respecté les règles de syntaxe du langage et traduire le programme dans un langage exécutable par le processeur.

Structure d’un programme

Le langage utilisé est structuré autrement dit il est organisé et s’exécute de façon séquentielle, c’est-à-dire ligne par ligne. Le langage est un langage propre proche de C/C++ mais de plus haut niveau avec des fonctions spécialisées pour votre arduino. La structure de votre programme doit comporter trois parties :

  1. La définition des constantes et des variables ;
  2. La configuration des entrées et des sorties void setup();
  3. La programmation des interactions et comportement void loop().

Vous pouvez remarquer que votre environnement de programmation crée d’ailleurs par défaut cette structure.

Voila un exemple que nous reprendrons par la suite respectant cette structure. // sont des commentaires, ils n’ont pas d’effet sur le programme et permettent de documenter le programme. Il se termine à la fin de la ligne. /* ouvre également un commentaire qui est fermé par */.

/*
 * Ce programme fait clignoter la LED sur la broche 13
 * et donc la LED de test de la carte
 */

//
// La définition des constantes et des variables
//
const int ledBroche = 13;                // LED connectée à la broche 13
const int attente = 1000;                // En ms

//
// Initialisations
//
// Initialisation des ressources de la carte.
// Configuration des entrées/sorties.
// Définition de la vitesse de fonctionnement du port série, etc.
// La fonction setup() n'est exécutée qu'une seule fois.
//
void setup() {
  pinMode(ledBroche, OUTPUT);       // Configure ledBroche comme une sortie
}


//
// Programmation des interactions et comportement.
//
// C'est une boucle "infinie". Elle peut être interrompue que par coupure de
// l'alimentation de la carte ou un appui sur Reset
//
void loop() {
  digitalWrite(ledBroche, HIGH);    // Met la sortie à l'état haut, LED allumée
  delay(attente);                   // durant attente.
  digitalWrite(ledBroche, LOW);     // Met la sortie à l'état bas, LED éteinte
  delay(attente/3);                 // durant attente/3 (division entière)
}
  • pinmode(broche, état) : configuration des broches. état vaut INPUT ou OUTPUT ;
  • digitalWrite(broche, état) : écrire un état sur une broche numérique. état vaut HIGH pour 1 ou LOW pour 0 ;
  • delay(attente) : attente en millisecondes.

Syntaxe

Il y a les commentaires, les variables et les constantes, les structures et les fonctions. Je ne vais pas tout détailler ici, mais donner simplement quelques éléments de compréhension si vous n’êtes pas habitués. Vous trouverez toutes les informations nécessaires ici.

Concernant les commentaires il n’est pas nécessaire de revenir dessus nous l’avons vu précédemment. Examinons donc maintenant le cas des variables et des constantes.

Qu’est ce qu’une variable ?
Une variable est un espace de stockage référencé par un identificateur, le nom de la variable. Cet espace permet de stocker une valeur utilisable et modifiable dans le programme. Cela peut être des données lues ou envoyées sur un des ports analogiques ou numériques, une étape de calcul pour associer ou traiter des données. Si l’on souhaite que la valeur ne puisse pas variée, on en fait une constante, c’est le cas pas exemple d’un numéro de broche. Les variables et les constantes sont typées, c’est-à-dire que l’on définit la représentation de l’information et les opérations permises.
Les structures ?
Le langage arduino considère les instructions conditionnelles et les boucles comme des structures de contrôles (if, for, …) mais aussi les opérateurs permettant d’écrire des expressions arithmétiques, booléennes ou d’affectation sans oublier l’opérateur de référenciation (*).
Les fonctions ?
Elles servent à regrouper des instructions, on peut leur transmettre des paramètres et elles retournent éventuellement un résultat.

LED qui clignote

Avant de proposer un problème un peu plus complet reprenons notre fil rouge. Vous avez peut-être déjà triché et testé le programme sur votre carte et vous avez du constater que la LED de test clignotait. Je vous propose maintenant de réaliser le montage.

Il vous faut :

  • 1 LED ;
  • 1 résistance de 330Ω (orange-orange-brun) ;
  • 3 cables.

Il faut faire un schéma du montage tout d’abord pour documenter, mais aussi vous permettre de vérifier votre conception. Fritzing offre un environnement intéressant pour les montages simples. Vous pouvez également utiliser eagle qui est plus puissant et propose une version “libre”.

Schéma de montage.

La patte + de votre diode est la plus longue, elle correspond à l’anode. La cathode à la patte -. Sur le schéma la cathode est donc sur la même ligne que la patte de la résistance qui est directement sur le - Vous pouvez enlever le fil rouge, il ne sert à rien, mais c’est une bonne habitude me semble t-il à prendre pour des montages plus complexes. Peut-être vous interrogez vous également sur la présence de la résistance ? Elle est là pour éviter les surtension. On la câble en série avec une résistance, dont la valeur (ordre de grandeur) se calcule de la manière suivante :

c’est les 5V de votre carte et c’est la tension de seuil, alors que I c’est le courant consommé.

Couleur Tension de seuil en V Courant en mA Longueur d’onde en nm
rouge 1,6 à 2 6 à 20 650 à 660
jaune 1,8 à 2 6 à 20 565 à 570
vert 1,8 à 2 6 à 20 585 à 590
bleu 2,7 à 3,2 6 à 20 470

Pour une led jaune :

La broche 13 est en principe déjà munie d’une résistance ce qui permet de brancher une led directement.

Dans les bonnes habitudes alimenter votre carte avec une alimentation indépendante est également une bonne idée, cela vous évitera de griller votre port USB de votre PC lors d’un montage foireux.

Faire pulser la LED

Il faut changer le fil vert et le mettre sur la broche 3 qui vous permet de convertir des données numériques en grandeur analogique et donc commander la luminosité de la LED. Les E/S qui permettent cela sont repérées par un ~. C’est pourquoi j’ai choisi la 3. Ces broches sont dites PWM. Ce qu’il faut retenir est que la Pulse Width Modulation (PWM), est une technique pour obtenir des effets d’allure analogique avec des broches numériques.

/*
 * Ce programme fait pulser la LED sur la broche 3
 */


//
// La définition des constantes et des variables
//
const int ledBroche = 3;                // LED connectée à la broche 3
const unsigned int attente = 1000;      // En ms

//
// Initialisation(s)
//
void setup() {
  pinMode(ledBroche, OUTPUT);       // Configure ledBroche comme une sortie
}


//
// Programmation des interactions et comportement.
//
void loop() {
 const float delta = 0.001;
 float entree, sortie;

 for (entree = 0; entree < 2 * PI; entree = entree + delta)
  {
    sortie = sin(entree) * 127.5 + 127.5;  // La valeur doit être comprise entre 0 et 255
    analogWrite(ledBroche,sortie);
    delay(3);
  }
  delay(attente);
}
  • analogWrite(broche, valeur) : écrit une valeur analogique sur une broche PWM (notée ~).

Allumer la LED automatiquement

Nous allons avoir besoin en plus d’une photorésistance qui est une résistance qui varie en fonction de la lumière qu’elle capte. Je vous propose donc de tester son utilisation, pour commencer.

Elle doit être branchée à une entrée analogique et elle nécessite un diviseur de tension. Ce dernier est constitué de deux résistances (fixes ou variables) en série. La tension mesurée au nœud entre les deux résistances varie alors selon la valeur de chaque résistance.

Quelques éléments d’explication :

La photorésistance a une résistance qui varie en fonction de la lumière. L’Arduino ou la RedBoard sont capables de mesurer des voltages et non des résistances. Le montage en diviseur de tension transforme alors la résistance variable en un voltage variable. Si la photorésistance est alimentée directement en 5V sans diviseur de tension, son voltage sera toujours 5V quelque soit la valeur de sa résistance variable. Si maintenant on la met en série avec une résistance fixe et qu’on les alimente en 5V, le voltage entre la photorésistance et la résistance fixe variera en même temps que la résistance du capteur et c’est cette valeur qui sera sur l’entrée analogique du RedBoard.

Un petit schéma pour illustrer peut aider à comprendre :

Diviseur de tension

Il suffit de mesurer la tension :

Cela nous donne le montage suivant. En considérant qu’il nous faut :

  • 1 photoresistance ;
  • 1 résistance de 10kΩ (brun-noir-orange);
  • 5 cables.

Montage

/*
 * Ce programme teste une photoresistance
 */

const unsigned long intervalle = 20;
const float divise = 1023.; // Le . pour éviter une division entière

void setup() {
  Serial.begin(57600);    // On intialise la liaison série à 57600 bauds
}                         // Pensez à configurer le moniteur série en conséquence

void loop() {
  unsigned long previousMillisecondes;
  int valeur;

  // On regarde le temps passé pour ne pas relire trop vite
  if ( millis() - previousMillisecondes >= intervalle ) {
    previousMillisecondes = millis();

    // Lire la tension sur  l'entrée analogique 0.
    valeur = analogRead(0);

    // La donnée est envoyée dans le moniteur série
    Serial.print("A0 = ");
    Serial.print(valeur / divise);
    Serial.println("V");
  }
}
  • La librairie/classe Serial est utilisée pour les communications par le biais du port série entre la carte Arduino et votre PC ou tout autre équipement possédant un port série. Les cartes Arduino et les clones ont toutes un port série (désigné sous le nom de UART ou USART). Cela correspond aux broches D0 (RX) et D1 (TX), lorsque vous utilisez cette classe vous ne pouvez pas utiliser les broches 0 et 1 en tant qu’entrées ou sorties numériques.
  • Serial.begin(int vitesse) : fixe le débit en bauds pour la communication série ( 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, ou 115200).
  • Serial.println(b) affiche b en tant que nombre décimal sous la forme d’une chaîne de caractères ASCII suivi d’un retour de chariot et d’un saut de ligne. Serial.println(b, DEC) affiche b en tant que nombre décimal sous la forme d’une chaîne de caractères ASCII suivi d’un retour de chariot et d’un saut de ligne.
  • Serial.println(b, HEX) affiche b en tant que nombre hexadécimal sous la forme d’une chaîne de caractères ASCII suivi d’un retour de chariot et d’un saut de ligne.
  • Serial.println(b, OCT) affiche b en tant que nombre octal sous la forme d’une chaîne de caractères ASCII suivi d’un retour de chariot et d’un saut de ligne.
  • Serial.println(b, BIN) affiche b en tant que nombre binaire sous la forme d’une chaîne de caractères ASCII suivi d’un retour de chariot et d’un saut de ligne. Serial.println(b, BYTE) affiche b en tant qu’octet simple suivi d’un retour de chariot et d’un saut de ligne.
  • Serial.println(str) si str est une chaîne de caractère ou un tableau de caractère, affiche la chaîne de caractère suivie d’un retour de chariot et d’un saut de ligne. Serial.println() affiche un retour de chariot et un saut de ligne.
  • Serial.print(b,XX) et Serial.print(b) produisent la même chose que Serial.println(b,XX) et Serial.println(b).
  • int analogRead(broche_analogique) lit la valeur de la tension présente sur la broche analogique spécifiée. La valeur est une valeur entière comprise entre 0 et 1023.
  • unsigned long millis() retourne en millisecondes le temps écoulé depuis le début d’exécution du programme courant.

Vous pouvez remarquer que nous avons utilisé une instruction conditionnelle du type :

if <condition> { <instructions> }

Si condition est vraie on effectue les instructions entre les { }. La condition s’exprime de la façon suivante :

  • x == y (x est égal à y), attention à ne pas écrire x=y qui modifie la variable x
  • x != y (x est différent de y)
  • x < y (x est inférieur à y)
  • x > y (x est supérieur à y)
  • x <= y (x est inférieur ou égal à y)
  • x >= y (x est supérieur ou égal à y)

Vous pouvez également utiliser les connecteurs logiques && pour le ET et || pour le OU.

Montage
Environnement avec la console. Notez la configuration de la vitesse en bas à droite.

Éclairage public

Je vous propose que l’on se prenne maintenant pour l’éclairage public. La led va être asservie à la photorésistance et s’allumer quand la luminosité est trop faible et s’éteindre sinon. Il faut donc ajouter une led et celle-ci s’allumera lorsque la valeur de la tension mesurée sur l’entrée analogique est inférieure à un seuil et éteinte sinon. Il faut donc compléter notre montage précédent avec le premier montage avec la led. Cette dernière sera alimentée en + par la broche D8 par exemple et l’on remet une résistance pour la protéger la led. Cela nous donne le schéma suivant :

Montage : led asservie par une photorésistance.

Pour réaliser le montage, il faut :

  • 1 photorésistance ;
  • 1 led ;
  • 2 résistances (220Ω orange-orange-brun) et (10kΩ brun-noir-orange) ;
  • 6 câbles.

Maintenant, il nous faut écrire le petit programme qui définira le comportement du montage. Si l’on reprend la structure d’un programme telle que je l’ai présenté précédemment, il faut définir les variables et les constantes, la configuration si nécessaire des entrées et des sorties et enfin le traitement. La présentation de la démarche est ici séquentielle, mais souvent des allers et retours sont effectués lors de l’élaboration d’un programme.

Les variables et les constantes

Commençons donc par fixer les différentes broches avec lesquelles nous allons travailler. Il s’agit tout d’abord de la broche analogique A0 sur laquelle nous lirons la tension pour déterminer le niveau de luminosité et ensuite de la broche D9 servant à alimenter notre led. Cela nous donne quelque chose comme cela :

 const unsigned int BrocheAna = 0; // Broche analogique sur laquelle nous lisons la tension
 const unsigned int BrocheLed = 9; // Led connectée à la broche 9  

Nous allons également stocker dans une variable la valeur lue sur la broche analogique.

unsigned int valeurLuminosite;   
/*
 * Ce programme utilise une photoresistance et allume une diode
 * lorsque la luminosité est trop basse et l'éteint sinon
 */

//
// Les variables et constantes globales
//
// Les broches
const unsigned int BrocheAna = 0; // Broche analogique sur laquelle nous lisons la tension
const unsigned int BrocheLed = 9; // Led connectée à la broche 9

const boolean debug = true;


void setup() {
  // Pensez à configurer le moniteur série en conséquence
  if (debug) Serial.begin(57600); // On intialise la liaison série à 57600 bauds
  pinMode(BrocheLed, OUTPUT);
}



void loop() {
  unsigned int valeurLuminosite;
  const int luminositeMini = 500;

  valeurLuminosite = analogRead(BrocheAna);    // On lit la valeur mesurée par la photorésistance
  if (debug) Serial.println(valeurLuminosite); // On affiche la valeur lue dans la console si on "devermine"
  if (valeurLuminosite < luminositeMini)n      // SI la valeur lue est inférieure à une valeur fixée
    digitalWrite(BrocheLed, HIGH);             // ALORS on allume la diode
  else
    digitalWrite(BrocheLed, LOW);              // SINON on éteint la diode.

  delay(1000);
}

Vous pouvez modifier ce programme afin que l’intensité lumineuse de la diode soit inversement proportionnelle à la valeur mesurée par la photorésistance sachant que vous êtes sur la boche 9 de type pwm.

Environ toutes les secondes on envoie un changement d’état à notre diode alors que parfois c’est pas nécessaire (allumé->allumé ou éteinte->éteinte). On peut donc modifier notre programme de façon à ne le faire que dans les cas (allumé <-> éteinte). On introduit donc une nouvelle variable booléenne.

 boolean eteinte;

On modifie en conséquence le programme. On allume la diode que quand elle est éteinte et on bascule la variable eteinte.

/*
 * Ce programme utilise une photoresistance et allume une diode
 * lorsque la luminosité est trop basse
 */

//
// Les variables et constantes globales
//
// Les broches
const unsigned int BrocheAna = 0; // Broche analogique sur laquelle nous lisons la tension
const unsigned int BrocheLed = 9; // Led connectée à la broche 9

const boolean debug = false;

// Pour savoir si la led est éteinte ou pas
boolean eteinte;


void setup() {
  // Pensez à configurer le moniteur série en conséquence
  if (debug) Serial.begin(57600);    // On intialise la liaison série à 57600 bauds
  pinMode(BrocheLed, OUTPUT);
  eteinte = true;
}



void loop() {
const int luminositeMini = 500;
  unsigned int valeurLuminosite;

  valeurLuminosite = analogRead(BrocheAna);
  if (debug) Serial.println(valeurLuminosite);
  if (valeurLuminosite < luminositeMini) {
    if (eteinte) {
      digitalWrite(BrocheLed, HIGH);
      eteinte = !eteinte;
    }
  } else {
    if (! eteinte) {
      digitalWrite(BrocheLed, LOW);
      eteinte = !eteinte ;
    }
  }
  delay(1000);
}

LEDs qui clignotent

aplapo Cela vous a peut-être échappé mais c’est bientôt Noël. Nous allons donc faire clignoter une série de leds sur un sapin. Je vous propose même de faire un chenillard. Si vos leds sont placées en ligne vous allumez la plus à gauche, par exemple, puis ensuite celle immédiatement à sa gauche etc. Vous pouvez également faire des choses plus sophistiquées comme décaler un motif. Avant de faire le sapin de Noël, je vous propose d’utiliser la plaque de câblage rapide sur laquelle je vais me contenter de placer 6 leds sur les broches 8 à 13. Le montage se fait simplement, il va falloir :

  • 6 diodes ;
  • 6 résistances de (220Ω orange-orange-brun) ;
  • 7 câbles.

Le montage est le suivant :

Montage : chenillard avec 6 leds.

/*
 * Ce programme réalise un chenillard
 */

//
// Les variables et constantes globales
//
const unsigned int nbLeds = 6;
const unsigned brochesLeds[] = {8, 9, 10, 11, 12, 13};

void setup() {
  unsigned int i;
  for(i = 0; i < nbLeds; i++)
    pinMode(brochesLeds[i], OUTPUT);
}

void loop() {
  unsigned int i;
  for(i = 0; i < nbLeds; i++)
  {
    digitalWrite(brochesLeds[i], LOW);
    delay(1000);
  }
    for(i = 0; i < nbLeds; i++)
  {
    digitalWrite(brochesLeds[i], HIGH);
    delay(1000);
  }
  delay(2000);
}
  • brochesLeds[i] est un tableau, on accède à un élément en lui donnant sa position dans l’énumération.
  • for (<initialisation>; <condition>; <incrementation>) { <instruction(s)> } répéte l’exécution d’un bloc d’instructions.

Si cela vous dit, maintenant un peu de cambouis ! Si vous voulez garder les mains propres passez à la suite. On garde le même montage mais je vais essayer de déplacer un motif. Pour cela il peut s’avérer plus facile de descendre dans les entrailles de la bête. En effet, au niveau du microcontrôleur existent des registres, c’est une mémoire qui lui est directement associée. Ils servent à gérer les entrées et les sorties et on dialogue avec en binaire.

Il y a 3 ports : B, C et D. Chaque port possède un registre de direction DDRx x, est remplacé par B, C ou D. Lorsque le bit correspondant à la broche est à 0 celle-ci est en entrée et à 1 en sortie. Deux autres registres PINx servent respectivement à lire ou à ecrire PORTx. B sert pour les broches numériques 8 à 13, C pour les broches analogiques et D pour les broches 0 à 7. Un nombre en binaire dans le langage de l’arduino s’écrit OxBBBBBBBB avec B = 1 ou 0 suivant la valeur du bit. Il existe également des opérateurs de manipulation des bits (~, &, |, ^, >>, <<) qui peuvent être combinés avec l’opérateur d’affectation (|=).

/*
 * On définit un motif et on le fait tourner en "rond"
 */


byte motif = 0b00110101; // Les leds sont allumées
                         // quand le bit correspondant
                         // est à 0.


void setup() {
  DDRB = 0b00111111 ; // 8 (poids faible) vers 13 (poids fort)
  PORTB = motif;      // 9 et 11 allumées
  delay(1000);
}


void loop()
{ // bit x veut dire ici le bit correspondant à la broche x du port B
  if (motif & 0b00000001) // Vrai lorsque le bit 8 à 1 va sortir lors du prochain décalage
    motif |= 0b01000000 ; // On le met en position 14  
  motif >>= 1 ;           // On décale à droite
  motif &= 0b00111111 ;   // On force les bits 14 et 15 à 0 les autres inchangés
  PORTB = motif ;
  delay (1000) ;
}
  • ~ est l’opérateur de négation. Il inverse les bits. Attention au type de votre variable. Je vous conseille dans la mesure du possible de travailler avec des byte.
  • & C’est le ET, cela permet de forcer des bits à 0. Il suffit de définir son masque (une constante en binaire). C’est ce que j’ai fait avec motif &= 0b00111111. L’opérateur est combiné avec l’affectation cela correspond à motif = motif & 0b00111111 ;
  • | C’est le OU, cela permet de forcer des bits à 1. Il suffit de définir son masque (une constante en binaire). C’est ce que j’ai fait avec motif |= 0b01000000@@.
  • ^ C’est le OU exclusif, cela permet d’inverser des bits. 11110000 ^ 01010101 = 10100101, soit l’un, soit l’autre mais pas les deux.
  • << décalage à gauche, les bits qui sortent sont perdus, ceux qui rentrent sont nuls.
  • >> décalage à droite, les bits qui sortent sont perdus. Ceux qui rentrent auront la valeur du bit le plus à gauche si la variable est signée, sinon c’est des zéros.

Mon beau sapin roi des forêts

On s’inscrit plus dans l’esprit DIY ici. Je vous propose de réaliser quelques chose de complétement inutile, merci à Stefan qui nous a soufflé l’idée. Cela consiste à réaliser un petit sapin de Noël en carton ou en mélaminé avec des leds qui clignotent. Pour la réalisation le plus simple est de partir de la vue schématique :

Schéma de principe.

Il vous faut :

Vous devez découper votre sapin de Noël dans du carton ou du médium.

Mon beau sapin.

Il vous reste maintenant à tracer le circuit et coller vos résistances et leds.

L’expérience montre que ce n’est pas gagné avec l’encre car on mesure une résistivité très grande ! De ce fait, le sapin pour l’atelier a été câblé avec des fils directement >:). Dès que j’aurai plus de temps, j’essaierai de voir pour une autre solution, la cause pouvant être le support ???

Pour le moment, nous avons câblé cela en dur avec des fils et le montage est alimenté par une pile rechargeable 9V et un contact à pression et une fiche mâle que j’ai récupérée sur un vieux chargeur. Si vous faites cela, attention aux polarités. Vous trouverez également des solutions peu onéreuses sur le net.

Alimentation indépendante 9V.
Alimentation indépendante 9V.

Références

En plus du site arduino, j’ai utilisé deux sources :

[1]
Le blog d’Eskimon. Tutoriels Arduino (ou pas) et articles divers. Consulté le 1/12/2015.
[2]
Jean-Noël Montagné. Livret pédagogique sur les bases de l’arduino, novembre 2006 (5 Mo).

Nous contacter

Vous pouvez nous contacter à cette adresse ou utiliser le formulaire ci-dessous.