Circuit Playground Classic, la carte tout-en-un d’Adafruit

Aujourd’hui, nous vous parlons de la carte tout-en-un d’Adafruit, la Circuit Playground Classic. Cette petite carte ronde de 5cm de diamètre, analogue à l’Arduino du point de vue programmation, intègre en plus des capteurs, des boutons, des LEDs RVB et un mini haut-parleur. Ce qui va vous permettre de faire d’innombrables applications sans besoin de soudure ni de module complémentaire !

Vous découvrirez ici un résumé du contenu de la carte, puis apprendrez à la programmer avec le logiciel Arduino IDE.

Contenu de la Circuit Playground Classic

Passons donc en revue les éléments intégrés dans la Circuit Playground:

  • Le microcontrôleur est un ATmega32u4, le même qu’on retrouve sur les Arduino Leonardo, Micro, Yun, etc.
  • L’alimentation se fait soit avec le 5V du port usb, soit via le port d’alimentation externe qui permet d’utiliser vos batteries à piles, LiPo, etc. avec une tension admissible de 3.5V à 6.5V.
  • Du côté des capteurs, et c’est là que ça devient intéressant, on trouve :
    • Un microphone,
    • Un capteur de lumière,
    • Un capteur de température,
    • Et même un accéléromètre !
  • Pour finir :
    • 10 LEDs RVB
    • 8 pads pouvant au choix:
      • accueillir des pinces crocodiles et servir de GPIOs
      • agir comme des touches tactiles capacitives
    • Un mini haut-parleur (tonalité uniquement)
    • Un interrupteur
    • 2 boutons poussoirs

Rien que ça !

Maintenant que les présentations sont faites, voyons comment la prendre en main. Nous allons commencer par vérifier la carte fraîchement sortie de son emballage, puis nous allons mettre en place l’interface de programmation Arduino IDE pour enfin s’essayer à la programmation.

Première mise sous tension

Nous commençons par vérifier le bon fonctionnement de la carte en faisant les manipulations suivantes:

  1. Mettez la carte sous tension, et vérifiez que la LED verte ON s’allume (à côté du port usb). Il est possible qu’une séquence d’allumage des LEDs RVB préprogrammée en usine se lance, c’est normal.

  2. On va maintenant vérifier que le bootloader est bien chargé en appuyant 2 fois sur le bouton Reset de la carte. Si la LED rouge #13 clignote une dizaine de fois environ 1 fois par seconde, c’est bon !

Mise en place d’Arduino IDE

On va supposer que vous avez déjà Arduino IDE installé sur votre ordinateur. Si ce n’est pas le cas, vous le trouverez sur le site officiel Arduino. Il sera plus pratique d’utiliser la dernière version d’Arduino IDE, puisque la carte et la librairie dont nous aurons besoin y sont déjà présentes.

La mise en place va se faire en 3 étapes :

  1. Vérifier que la carte est bien reconnue sur le port USB
  2. Ajouter la carte Circuit Playground dans Arduino IDE
  3. Ajouter la librairie Adafruit dédiée à la carte (optionnel)

1. Ouvrez Arduino IDE et vérifiez que la Circuit Playground est bien reconnue dans la liste des ports. Si ce n’est pas le cas, téléchargez et installez Windows Driver Software sur le site de Adafruit.

2. Ajoutez la carte Circuit Playground comme suit :

  • Allez dans Outils / Type de carte / Gestionnaire de carte,
  • Cherchez le package « Adafruit AVR Boards » et installez le,
  • Si le package n’est pas présent (ancienne version de l’IDE),
    • Ouvrez les préférences (Fichier / Préférences)
    • Ajoutez l’URL suivante au gestionnaire de cartes supplémentaires
      https://adafruit.github.io/arduino-board-index/package_adafruit_index.json
    • Fermez et relancer Arduino IDE, et retourner dans le gestionnaire de carte
  • Vous pouvez maintenant sélectionner la carte Adafruit Circuit Playground dans le menu Outils / Type de carte

3. Adafruit met à disposition une librairie dédiée aux Circuits Playgrounds permettant de « prémâcher » le travail de programmation. Elle est déjà installée sur les dernières versions de l’IDE, mais sinon il suffit d’aller dans Croquis / Inclure une bibliothèque / Gérer les bibliothèques, puis de chercher la librairie « Adafruit Circuit Playgound » et enfin de l’installer.

Un 1er programme: demo

Nous allons téléverser un premier programme qui permet de démontrer les possiblités de la carte:

  • Connectez la carte sur l’ordinateur en USB
  • Allez dans Fichier / Exemples / Adafruit Circuit Playground et ouvrez l’exemple « demo »
  • Vérifiez que le type de carte et le port série sont bien réglés sur « Adafruit Circuit Playground » dans le menu Outils
  • Cliquez sur « Téléverser »
  • Ouvrez le moniteur série et ajustez la fréquence à 9600 baud

Vous devriez voir l’écran ci-dessous.

Vous pouvez maintenant manipuler la carte et observer ses réactions sur le moniteur série. Par exemple:

  • Éclairez la carte : la valeur « light sensor » augmente,
  • Posez le doigt sur la thermistance A0 : c’est la valeur « Temperature » qui augmente,
  • Posez le doigt sur les pads : les valeurs « Capsense » correspondantes augmentent,
  • Inclinez la carte à la verticale, les valeurs de l’accéléromètre vont varier et vous pourriez ainsi estimer l’axe d’inclinaison de la carte,
  • Testez l’interrupteur,

Bref ! Vous pouvez testez les capteurs, les boutons, les LEDs et il est très facile d’aller voir dans le code la commande qui permet de lire telle ou telle valeur et de gérer les LEDs ou le son.

Un 2ème programme: Lumière de bougie

Ici, nous allons écrire un programme dont le but est de commander les LEDs RVB de manière à simuler un éclairage de bougie.

Le programme consiste simplement à affecter à chaque cycle, une intensité lumineuse aléatoire pendant une durée aléatoire.

Si vous voulez l’essayer, il suffit de copier/coller le code ci-après dans une nouvelle fenêtre Arduino IDE et de téléverser le programme. Et … c’est tout ! Pas de breadboard, ni branchement, ni soudure. CQFD 😉


// mode debug
#define DEBUG 0 // Affiche des infos sur le port série si décommentée

// Ajout de la librairie dédiée
#include "Adafruit_CircuitPlayground.h"

// Variables d'intensité lumineuse
byte intensite = 128; // valeur initiale
byte intensiteMin = 10; // minimum
byte intensiteMax = 210; // maximum

// Variables temporelles
unsigned long temps = 0;
int delai = 100; // valeur initiale
int delaiMin = 100; // minimum
int delaiMax = 300; // maximum

// Couleur LED
uint32_t color = 0xFF2500; // valeur RVB en hexadécimal

// Initialisation de la carte
void setup() {
#ifdef DEBUG
    Serial.begin(9600);
#endif
    CircuitPlayground.begin();
    CircuitPlayground.setBrightness(intensite);
}

// Boucle principal
void loop() {
#ifdef DEBUG
    Serial.print("intensité = "); Serial.println(intensite);
    Serial.print("delai     = "); Serial.println(delai);
#endif
    // Si le délai est dépasser, on change l'éclairage
    if (millis() - temps >= delai) {
        // On règle la couleur sur les 10 LEDs
        for(int i=0; i<10; i++) {
            CircuitPlayground.setPixelColor(i, color);
        }
        // On ajuste la luminosité
        CircuitPlayground.setBrightness(intensite);
        // On change les variables luminosité et délai aléatoirement
        intensite = random(intensiteMin, intensiteMax);
        delai = random(delaiMin, delaiMax);
        // On met le nouveau temps en mémoire
        temps = millis();
    }
    // On attend un peu avant de reboucler
    delay(5);
}

Voilà ce que ça donne …

Et pour aller plus loin :

  • Vous pouvez améliorer la simulation d’une bougie en vous basant sur le principe mathématique des fractales avec le code du Jack o’ lantern. Le réalisme obtenu est vraiment bluffant !
  • Pour développer vos propres applications, n’hésitez pas à vous servir des exemples de code disponible dans Fichier / Exemples. Vous pouvez aussi vous référer au guide d’Adafruit et à la documentation publiée par caternuson en attendant qu’Adafruit publie sa version officielle.

Bonne récréation !

Arduino Yun datalogger

Nous allons aujourd’hui réaliser un montage nous permettant de remonter de manière simple la valeur d’un capteur qu’il soit analogique ou numérique avec un Arduino Yun. La lecture d’un capteur analogique avec un Arduino permet de transformer sa valeur lue entre 0 et 5V en un nombre de 0 à 1023.  Le capteur numérique quand à lui est à l’état 0 ou 1.

Notre montage va s’inspirer du tutorial http://arduino.cc/en/Tutorial/YunDatalogger

Le script adapter va scanner chaque entrée analogique puis chaque entrée numérique, puis les envoyer vers emoncms.

Pour commencer, inscrivez vous sur http://emoncms.org/

Voici le script que nous utilisons:

#include <FileIO.h>

#define attente 15000 // Temps entre 2 lectures en millisecondes

String debuturl = "http://emoncms.org/input/post.json?node="; // Debut url
String milieuurl = "&csv="; // Milieu url
String finurl = "&apikey=cdd97ca9046074128405636bb14fb479"; // Fin url

void setup() {
  // Initialisation des communications
  Bridge.begin();
  FileSystem.begin();
}


void loop () {
  // Lecture des capteurs analogiques
  for (int analogPin = 0; analogPin <= 5; analogPin++) {
    String url = debuturl; // Début de l'url
    url += String(analogPin); // Node
    url += milieuurl; // milieu d'url
    int sensor = analogRead(analogPin); // Lecture du capteur
    url += String(sensor); // Insertion dans l'url
    url += finurl; // Fin de l'url
    Process emoncms; // Process
    emoncms.begin("curl"); // Commande curl
    emoncms.addParameter(url); // Création de la requéte
    emoncms.run(); // Envoi de la requéte
  }
  
  delay(attente);// Attente entre 2 lectures
}

L’API key est à personnaliser avec celle que vous récupérer sur emoncms.

Une fois ceci prêt, téléverser le script sur le Arduino.

Maintenant, il faut connecter le Arduino Yun au Wifi. Voici le tutoriel officiel http://arduino.cc/en/Guide/ArduinoYun#toc13. En résumé:

  • Connectez vous à ArduinoYun-XXXXXXXXXXXX
  • Dans votre navigateur, allez dans http://arduino.local ou 192.168.240.1
  • Entrez le mot de passe (par défaut c’est arduino)
  • Cliquez sur Configure
  • Sélectionnez votre réseau Wifi puis entrez la clé WPA et validez
  • Au redémarrage le Arduino est sur le réseau

Les lectures de capteurs vont commencer automatiquement. Vous les verrez sur http://emoncms.org/input/view

Vous pouvez désormais personnaliser le nom des flux (node).

Capture de emoncms

Codebender une alternative à l’IDE Arduino

Nous allons aujourd’hui nous intérresser à l’environnement de programmation du Arduino (l’IDE). Dans nos tutoriels nous présentons toujours des programmes réalisés avec le logiciel officiel du Arduino (http://arduino.cc/en/Main/Software) mais des logiciels alternatifs existent.

Le site officiel posséde une liste de logiciel alternatif http://playground.arduino.cc/Main/DevelopmentTools. Comme vous pouvez le voir cette liste est très longue, nous allons vous présenter aujourd’hui codebender.cc

Code Bender se présente sous la forme d’une application Web qui vous permet de programmer votre Arduino directement dans votre navigateur.

Pour l’utiliser, il faut vous inscrire sur http://codebender.cc/ vous recevrez ensuite un mail d’activation et ensuite vous pouvez commencer à coder.

codebender - home

De nombreux exemples sont disponibles dans « examples & librairies » (Menu à gauche de l’écran). Une fois dans la partie programmation, l’interface ressemble beaucoup à celle de l’IDE officiel.

codebender - prog
codebender - prog 2

Un message sur le menu de gauche vous invite à installer le pluggin de Codebeder. Une fois ce pluggin installer vous allez pouvoir télécharger vos programmes via l’USB dans votre carte Arduino.

Le programme exemple avec un PC sous Windows 7 avec un explorateur Chrome connecté en USB à une carte Arduino Uno, la programmation via CodeBender a parfaitement fonctionné!

Si vous voulez allez plus loin voici d’autres articles sur le sujet:

[Tuto] Utiliser un shield LCD

Lire la valeur d’un capteur

Le but de ce montage est de mettre en place un montage rapide avec un shield (= carte d’extension) comprend un écran LCD et des boutons poussoirs. Le programme sera simple, il affichera sur l’écran le nom du bouton pressé.

Ce montage est une adaptation de http://www.dfrobot.com/wiki/index.php?title=Arduino_LCD_KeyPad_Shield_(SKU:_DFR0009)

Composants nécessaires :

Principe du montage :

Le montage de shield est très simple. Il suffit de poser le shield directement sur le Arduino.

Composants

 

Réalisation du montage :

Pour réaliser le montage poser le shield sur le Arduino (Attention au sens). Guidez vous en fonction des bornes A0 à A5.

Montage 1
Montage 2
Montage 4
Montage 3

Remarque : Le potentiomètre (composant bleu avec une vis) permet le réglage du contraste.

Fonctionnement du shield :

Voici comment est réellement câblé le shield :

Bornes

Fonction

Analog 0

Bouton (select, up, right, down and left)

Digital 4

DB4

Digital 5

DB5

Digital 6

DB6

Digital 7

DB7

Digital 8

RS (données ou sélection du signal)

Digital 9

Activation (Enable)

Digital 10

Contrôle du rétroéclairage

Programmation du montage :

Le programme va nous afficher sur l’écran le nom des boutons appuyés. Pour cela il va utiliser une librairie spécific au LCD, la librairie « LiquidCrystal.h ». Cette librairie comprend de très nombreuses fonctions pour en avoir la liste complète et la description, je vous invite à aller visiter le site officiel http://arduino.cc/en/Reference/LiquidCrystal?from=Tutorial.LCDLibrary

// Charger la librairie LiquidCrystal
#include <LiquidCrystal.h>

// Définir les pins utilisées par le LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Définir les variables globales
int lcd_key = 0;
int adc_key_in = 0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5

// Fonction lire les boutons
int read_LCD_buttons()
{
adc_key_in = analogRead(0); // Lire les valeurs du capteurs
// Les valeurs renvoyées sont sensés être: 0, 144, 329, 504, 741
// Il y a une erreur possible de 50
if (adc_key_in > 1000) return btnNONE; // Nous découpons les valeurs possibles en zone pour chaque bouton
if (adc_key_in < 50) return btnRIGHT;
if (adc_key_in < 250) return btnUP;
if (adc_key_in < 450) return btnDOWN;
if (adc_key_in < 650) return btnLEFT;
if (adc_key_in < 850) return btnSELECT;
return btnNONE; // On renvoie cela si l'on est au dessus de 850
}

void setup() // Initialisation
{
lcd.begin(16, 2); // Démarrer la librairie
lcd.setCursor(0,0);
lcd.print("Appuyer"); // Afficher un message simple
}

void loop() // Fonction principale
{
lcd.setCursor(0,1); // Placer le curseur au début de la seconde ligne
lcd_key = read_LCD_buttons(); // Lire les boutons

switch (lcd_key) // Selon le bouton appuyer
{
case btnRIGHT: // Pour le bouton "Right"
{
lcd.print("RIGHT "); // Afficher "Right"
break;
}
case btnLEFT: // Pour le bouton "left"
{
lcd.print("LEFT "); // Afficher "Left"
break;
}
case btnUP: // Pour le bouton "Up"
{
lcd.print("UP "); // Afficher "Up"
break;
}
case btnDOWN: // Pour le bouton "Down"
{
lcd.print("DOWN "); // Afficher "Down"
break;
}
case btnSELECT: // Pour le bouton "Select"
{
lcd.print("SELECT"); // Afficher "Select"
break;
}
case btnNONE: // Sinon
{
lcd.print("NONE "); // Afficher "None"
break;
}
}

}

Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne :

NONE
LEFT
RIGHT

 Pour aller plus loin :

On peut à partir de là afficher tout ce que l’on veut. Les possibilités sont très grande.