[Tuto] Mode sommeil sur Trinket

Les modes sommeil permettent de réduire énormément la consommation des cartes électroniques. Sur le Trinket d’Adafruit, il est souvent recommandé de passer par les librairies Adafruit_sleepydog dans cet exemple nous allons passer par l’utilisation d’une librairie plus bas niveau.

 

Le cœur de l’Adafruit Trinket est un microcontrôleur Attiny 85. Celui-ci est basé sur une architecture de type AVR. Nous allons donc passer dans notre cas par les librairies pour Arduino avr/sleep.h et avr/interrupt.h

Pour faire nos essais, nous allons nous baser sur le sketch exemple « Button » inclue dans l’IDE Arduino. Après quelques modifications de pinout, il est compatible avec le Trinket:

const int buttonPin = 0;     // the number of the pushbutton pin
const int ledPin =  1;      // the number of the LED pin</em></p>
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed. If it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
     // turn LED on:
     digitalWrite(ledPin, HIGH);
   } else {
     // turn LED off:
     digitalWrite(ledPin, LOW);
   }
 }

Le mode sleep va fonctionner comme ceci:

  • Lorsque le bouton n’est pas pressé
  • La LED s’allume 3 secondes
  • Le mode sleep s’enclenche avec la LED qui reste allumée
  • Lors de l’appuie sur le bouton le Trinket sort du mode sleep

Voici le code que cela donne:

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT_PULLUP);
}

void sleep() {

    GIMSK |= _BV(PCIE);                     // Enable Pin Change Interrupts
    PCMSK |= _BV(PCINT0);                   // Use PB0 as interrupt pin 0
    ADCSRA &= ~_BV(ADEN);                   // ADC off
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);    // replaces above statement

    sleep_enable();                         // Sets the Sleep Enable bit in the MCUCR Register (SE BIT)
    sei();                                  // Enable interrupts
    sleep_cpu();                            // sleep

    cli();                                  // Disable interrupts
    PCMSK &= ~_BV(PCINT0);                  // Turn off PB0 as interrupt pin
    sleep_disable();                        // Clear SE bit
    ADCSRA |= _BV(ADEN);                    // ADC on

    sei();                                  // Enable interrupts
    } // sleep

ISR(PCINT0_vect) {
    // This is called when the interrupt occurs, but I don't need to do anything in it
    }

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
    delay(3000);
    sleep();
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
  }
}

A titre de comparaison, sans le mode sleep LED allumée le Trinket consomme 22mA sous 12V avec le mode sleep cela tombe à 13mA soit une économie de 9mA

[Tuto] Mise en marche de l’Ultimate GPS FeatherWing via le HUZZAH ESP8266 Wifi

Comment lire les coordonnées lue par le GPS à travers le HUZZAH ESP8266 Wifi?

1.Montage

Le but de ce montage est de tester le featherwing GPS via le Feather HUZZAH ESP8266 Wifi. Les cartes ne sont pas directement compatibles en mode shield, il est donc nécessaire de simuler un nouveau couple de ports RX/TX.


Effectuer les connexions suivantes :

  • le pin 3V du GPS au pin 3V de l’ESP
  • le pin GND du GPS au pin GND de l’ESP
  • Pin 12 de l’ESP au pin TX du GPS
  • Pin 14 de l’ESP au pin RX du GPS
  • Brancher l’ESP à un pc avec un câble USB

2. Programme

Le Programme permet de lire les données envoyées par le GPS, sur le serial monitor de l’IDE Arduino.

Avant de mettre le programme sous Arduino IDE, vous devez ajouter des types de cartes supplémentaires.

  1. Pour cela, aller dans Fichier/Préférence puis coller le lien suivant : http://arduino.esp8266.com/stable/package_esp8266com_index.json
  2. Coller le dans le champ texte “URL de gestionnaire des cartes supplémentaires”.
  3. Valider l’entrée en appuyant sur “OK”.
  4. Ensuite,aller dans Outils/Type de carte et choisir Generic ESP8266 module.
  5. Choisir nodemcu dans Outils/Reset Method
  6. Copier/Coller le programme suivant :

Code :

 
#include <Adafruit_GPS.h>// https://github.com/adafruit/Adafruit_GPS.git
#include <SoftwareSerial.h>// déjà intégré à Arduino
#define BAUD_RATE 115200 // vitesse de communication de l’USB
#define BAUD_RATE_GPS 9600 // vitesse de communication entre le GPS et ESP8266 généralement 9600 baud

SoftwareSerial swSer(12, 14, false, 256); // Crée une sortie (RX, TX) dans la variable swSer
void setup()  // Programme d’initialisation
{
 Serial.begin(BAUD_RATE); // Initiation de la sortie UART de HUZZAH
 swSer.begin(BAUD_RATE_GPS); // Initiation de la sortie UART du gps
 pinMode(0, OUTPUT); // Initialise le PIN 0 en sortie
 Serial.print("\nEntering Setup"); // Affiche sur le moniteur “Entering Setup”
 Serial.println("\nSoftware serial test started"); // Affiche sur le moniteur “Software serial test started"

 for (char ch = ' '; ch <= 'z'; ch++) { //test pour afficher tous les caractères à la suite
   swSer.write(ch);
   Serial.write(ch);
   swSer.println("");
   }
 Serial.println("\nSoftware serial test done");// Affiche sur le moniteur “Software serial test done"
}

void clignot() {  // sous-programme qui fait clignoter la led rouge
 for (int i =0; i<= 10; i++) {
   digitalWrite(0, HIGH);  // Allume la LED
   delay(500);  // Attend 500ms
   digitalWrite(0, LOW);  // Eteint la LED
   delay(500);
   }
}

void loop() {
//  clignot(); //test si HUZZAH répond
//affiche ce que le GPS envoie
 if (swSer.available()) {    // regarde si la sortie est “libre”
char c = swSer.read(); // mets ce que envoie le GPS dans la variable caractère c
   Serial.write(c); // Affiche ce que contient la variable c
 }    
}

Le programme ci dessus affiche dans le Moniteur série:


$GPGGA,001336.799,,,,,0,00,,,M,,M,,*78
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPRMC,001336.799,V,,,,,0.00,0.00,060180,,,N*42
$GPVTG,0.00,T,,M,0.00,N,0.00,K,N*32

GPRMC et GPGGA sont les lignes qui contiennent les coordonnées qui nous intéressent. Le GPRMC est une trame d’information (souvent utilisée dans la navigation maritime). Le GPGGA est une trame d’information couramment utilisée pour connaître la position courante du récepteur GPS.

EX:$GPGGA,064036.289,4836.5375,N,00740.9373,E,1,04,3.2,200.2,M,,,,0000*0E

  • 064036.289: Heure exprimée en hhmmss.ms (06H40min36s et 289ms).
  • 4836.5375,N,00740.9373,E : Coordonnées liées à la position.
    1. Latitude 48 degré et  36,5375 minutes Nord (N = Nord / S =Sud).
    2. Longitude -74 degré  et 40,9373 minutes Ouest (W = Ouest / E = Est).
  • 1: Type de positionnement ( 1 = positionnement GPS).
  • 04: Nombre de satellites utilisés pour calculer les coordonnées.
  • 3.2: Précision Horizontale.
  • 200.2,M: Altitude en mètres.
  • ,,,,0000 : D’autres données peuvent être inscrite.
  • *0E : Contrôle de parité de la trame au format hexadécimal.

Pour une meilleure réception des données  du GPS, il est conseillé de l’utiliser en extérieur.

Source:

https://fr.wikipedia.org/wiki/NMEA_0183

https://www.uni-weimar.de/projekte/costumes-and-environment/2017/05/19/tutorial-connecting

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 !