[Tuto] Programmer votre particle photon ou electron via USB

Vous êtes nombreux à vouloir programmer votre Particle photon ou electron via l’USB sans avoir à compiler régulièrement votre programme dans le cloud particle. Ici je vais vous montrer comment effectuer cela avec l’exemple « Blink an LED ».

Ce dont vous aurez pour suivre les étapes suivantes c’est de compiler votre programme sur le webIDE et de télécharger le fichier binaire en cliquant comme sur l’image suivante:

bouton_bin

1-Préparation de l’environnement Windows

a. Nodejs

  • Télécharger la dernière version nodejs sur https://nodejs.org/en/download/
download_nodejs
  • Installer en suivant les instructions, pour le dossier d’installation laisser celui par défaut
download_nodejs_2
  • Redémarrer votre ordinateur

b. Driver Particle

  • Télécharger les drivers sur https://s3.amazonaws.com/spark-website/Particle.zip
  • Décompresser le dossier dans « Téléchargement »
  • Raccorder le photon en USB
  • En bas à droite, vous verrez que l’ordinateur cherche un pilote pour ce périphérique, attendre qu’il notifie « Aucun pilote n’a été trouvé »
driver_update
  • Aller dans Panneau de configuration -> Matériel et audio -> Gestionnaire de périphériques
gestionnaire_peripherique
  • Dans « Autres périphériques », double-cliquer sur le périphérique photon
  • Cliquer sur « Mettre à jour le pilote … »
mettre_a_jour
  • Cliquer sur « rechercher un pilote sur mon ordinateur »
  • Naviguer jusqu’au dossier décompresser précédemment situé dans « Téléchargement »
recherche_pilote
  • Suivre les étapes d’installation
  • mise_a_jour_termine
  • Redémarrer votre ordinateur

c. Particle CLI

  • Ouvrir l’invite de commandes
invite_commande
  • Taper : npm install –g particle-cli
cli_install

d. DFU Driver

  • Mettre le photon en DFU mode:

o Presser les deux boutons « setup » et « reset »
o Relâcher le bouton reset
o Relâcher le bouton « setup » dès que la LED clignote jaune

  • Raccorder en USB le photon
  • Télécharger ZADIG sur http://zadig.akeo.ie/ en cliquant sur « Zadig for Windows Vista or later »
  • Exécuter Zadig
zadig_execution
  • Cliquer sur Options-> List all devices
  • Sélectionner le photon DFU, dans la case driver : (NONE) ; libusbk(v3.0.6.0)
  • Cliquer sur « Install Driver »
  • Suivre les étapes d’installation
driver_zadig

e. dfu-util

dossier_dfu_util
  • Renommer dfu-uti-static.exe en « dfu-util.exe »
  • Aller dans Ordinateur-> Propriétés système -> Paramètres système avancés -> Variables d’environnement
variable_environnement
  • Double-cliquer sur « Path »
  • Dans la case Valeur de la variable, ajouter à la suite le chemin du fichier dfu-util.exe, ex :  «;C:\dfu-util\ ; »
path_dfu_util
  • Redémarrer votre ordinateur

2-Programmation du photon ou electron

  • Aller dans le dossier où se situe votre fichier .bin via l’invite de commande et les commandes cd et ls
  • Taper la commande particle login, connecter vous avec les identifiants auquel est attaché votre particle
login_particle
  • Taper la commande suivante : particle flash –usb firmware.bin 
    particle_flash
  • Votre particle est maintenant prêt a fonctionner!

[Tuto] Configurer un module iBeacon avec un smartphone

Le iBeacon est un objet electronique basse consommation qui va permettre d’emettre en bluetooth trois valeurs en permanence. Un UUID qui identifie  l’iBeacon et deux autres valeurs : major et minor. Le iBeacon peut avoir de nombreuses utilités comme un système de positionnement.

Ici va être décrit la méthode de configuration du module iBeacon  via une application Apple.

Matériels nécessaire:

  • Module iBeacon programmable
  • Pile bouton CR2032
  • Application BeaconGo disponible sur Appstore
  1. Télécharger l’application BeaconGo sur l’Appstore
  2. Brancher la pile sur le module iBeacon
  3. Lancer l’application BeaconGo
  4. Appuyer sur BeaconGo Manager 
    img_0002
  5. Appuyer sur BeaconGO USB
    img_0003
  6. Appuyer sur Search
    img_0004
  7. Dans la liste des périphérique vous devriez voir apparaître votre iBeacon dans le cas où vous ne savez pas lequel est le votre débrancher votre iBeacon recommencer et procédez par élimination
  8. Sélectionner votre iBeacon vous devriez voir apparaître « Connecting » pendant plusieurs secondes
  9. Vous arrivez maintenant dans « Settings », vous pouvez configurer UUID, Major, Minor la puissance d’émission et d’autre paramètres qui pourraient vous intéresser.
    img_0001
  10. Votre Ibeacon est maintenant paramétré et prêt à être utilisé.

[Tuto] Hacker un detecteur de fumée et recevoir un mail en cas de début d’incendie

Beaucoup d’entre vous laisse imprimante 3D ou autre machine fonctionner dans vos logements pendant que vous êtes à l’extérieur. Même si c’est pour un court instant, nous ne sommes pas à l’abri d’accident c’est pourquoi dans cet article il va être question de rendre votre détecteur de fumée connecté. Connecté dans le sens où à la moindre détection de fumée votre appareil vous enverra un mail immédiatement.

Voici le matériel nécessaire:

  • Détecteur de fumée
  • Pile 9V
  • Photon
  • Relais 5V
  1. Démonter le detecteur de fumée et repérage

    Dans un premier temps démonter votre detecteur de fumée le plus proprement possible si vous voulez réutilisez votre boitier. Vous y trouverez trois parties, celle avec le coupleur de pile 9V, la partie électronique avec le composant qui détecte ou non la fumée et une partie avec un buzzer.

    img_20160913_174955
    img_20160913_175039
    img_20160913_175030

    Une fois que vous avez repéré la broche reliant la partie électronique avec le buzzer, prenez un voltmètre, mesuré la tension dans les deux cas suivant:

    * lorsque le detecteur de fumée ne détecte rien, normalement 0V (Led rouge clignote lentement)
    * lorsque vous enclenchez l’alarme manuellement (via le bouton de test) (Led rouge clignote rapidement)
    Noter cette valeur de tension, elle devrait se situer entre 5V et 9V. Pour pouvoir utiliser cette broche avec le photon vous allez devoir diviser cette tension pour qu’elle soit d’un maximum de 3V3. Pour cela il faudra faire un pont diviseur de tension à l’aide de deux résistances qu’on nommera R1 et R2.

  2. Montage sur breadboard

     

     

     

    detecteur

    Le rôle du relais ici est de permettre une vérification par deux fois en éteignant le detecteur de fumée puis en le rallumant pour attendre de nouveau le signal si il a bien lieu.

  3. Programmation du Particle Photon

    Configuré votre Photon avec le wifi du lieu où sera installé votre detecteur de fumée, téléverser le code suivant et vous pourrez le tester.

    #define ALIM_PIN A4            // pin de mesure d'alimentation du detecteur de fumee
    #define SEUIL_FUMEE_VALUE 1000 // seuil de mesure sur la pin analogique FUMEE_PIN
    #define RELAY_PIN D6           // pin pour allumage/extinction du relais pour l'alimentation du detecteur de fumee
    
    int fumee_value = 0;    // valeur mesuree sur la pin de detection de fumee
    int alim_value = 0;     // valeur mesuree sur la pin d'alimentation du detecteur de fumee
    
    byte compteur_detection_1 = 0; // Valeur incremente a chaque mesure de fumee_value supérieur au seuil de detection : premiere verification
    byte compteur_detection_2 = 0; // Valeur incremente a chaque "detection d'incendie", : deuxieme verification
    
    unsigned long m_second;
    unsigned long last_serial = 0; // Variable pour affichage sur le serial
    unsigned long last_mesure = 0; // Variable pour mesure periodique des PINs
    unsigned long last_count = 0;  // Variable pour remettre à zero le comptage des detection sur la PIN FUMEE_PIN, compteur_detection_1
    unsigned long last_detection = 0; // Variable pour remettre à zero le comptage des detection d'incendie, compteur_detection_2
    
    void setup() {
        Serial.begin(9600);
        pinMode(RELAY_PIN, OUTPUT);
        //pinMode(FUMEE_PIN, INPUT_PULLDOWN);
        pinMode(ALIM_PIN, INPUT_PULLDOWN);
        
        digitalWrite(RELAY_PIN, HIGH); // Extinction du detecteur de fumee
        delay(2000);
        digitalWrite(RELAY_PIN, LOW); // Allumage du detecteur de fumee
        delay(2000);
        digitalWrite(RELAY_PIN, HIGH); // Extinction du detecteur de fumee
        delay(2000);
        digitalWrite(RELAY_PIN, LOW); // Allumage du detecteur de fumee
        
        Particle.publish("Incendie", "Non");
    }
    
    void loop() {
        m_second = millis();
        
        //Lecture analogique des tensions provenant du detecteur de fumee toute les 500ms
        if(m_second - last_mesure >= 100){
            fumee_value = analogRead(FUMEE_PIN);
            //Serial.println(fumee_value);
            if(fumee_value > SEUIL_FUMEE_VALUE){
                if(compteur_detection_1 == 0){
                    last_count = m_second;
                }
                compteur_detection_1++;
            }
            last_mesure = m_second;
        }
        
        //Remise à zero du compteur de detection toute les 15secondes
        if(m_second - last_count >= 5000){
            
            compteur_detection_1 = 0;
            Serial.println("Remise a zero du compteur de detection 1");
            digitalWrite(RELAY_PIN, LOW); // Allumage ou laisser ON le detecteur de fumee
            last_count = m_second;
        }
        
        // Premiere verification de detection incendie
        if(compteur_detection_1 >= 10){
            Serial.println("detection incendie");
            digitalWrite(RELAY_PIN, HIGH); // Extinction du detecteur de fumee
            if(compteur_detection_2 == 0){
                last_detection = m_second;
            }
            compteur_detection_1 = 0;
            compteur_detection_2++;
            last_count = m_second;
        }
        
        //Remise à zero du compteur de detection d'incendie, compteur_detection_2
        if(m_second - last_detection >= 300000){
            if(compteur_detection_2 < 10){ Particle.publish("Incendie", "Non"); } compteur_detection_2 = 0; Serial.println("Remise a zero du compteur de detection 2"); last_count = m_second; } // Seconde verification de detection incendie if(compteur_detection_2 >= 2){
            Serial.println("Incendie validé!");
            Particle.publish("Incendie", "Oui");
            compteur_detection_2 = 0;
            last_count = m_second;
        }
    }
  4. Ajouter la fonctionnalité envoi de mail en cas de detection de fumée

    Pour configuré l’envoi de mail nous utiliserons la plateforme IFTT: inscrivez vous et recherchez particle photon, sélectionner un des « if then » qui apparaît avec GMAIL et compléter comme cela:

    detecteur_b

  5. Tester

Pour tester appuyer sur le bouton de test assez longtemps jusqu’à la réception du mail.

[Tuto] Gobot framework avec Arduino, Raspberry et de nombreuses autres plateformes

Gobot est un framework spécialisé dans les objets connectés (IOT). Il permet, à partir d’une machine hôte, de contrôler plusieurs plateformes tels qu’Arduino et de les lier les uns aux autres à l’aide d’un seul langage le « Golang » (langage de programmation crée par Google en 2009)

Voici l’architecture de Gobot:

Capture

Ainsi dans cette architecture seul l’hôte est programmé en Golang, au niveau des microcontrôleurs ils auront un programme initial indépendant de l’hôte et des capteurs/ actionneurs qui lui sont connectés.

Il faut savoir que certaines plateformes ont à la fois la possibilité d’être en hôte (ex: Pc sous windows) mais aussi certaine intègre une partie microcontrôleurs qui leur permet d’être reliés directement au capteurs/actionneurs (ex: Raspberry, CHIP) ainsi vous pourrez programmer votre carte en Golang pour communiquer avec ces capteurs/actionneurs.

Exemple de plateforme:

A partir d’ici il va être décrit une méthode qui permet de configurer votre ordinateur sous Windows en tant qu’hôte pour ensuite exécuter un programme en Golang, l’exemple qui suit consiste à faire clignoter la LED 13 de l’Arduino Uno mais bien entendu une fois que vous aurez pris en main ce langage vous pourrez faire de nombreuse choses.

Matériels nécessaire:

1 – Téléchargement des sources nécessaires

2 – Procédure d’installation

Gort

  • Décompresser Gort dans un dossier que vous nommerez Go
  • Ouvrir votre invite de commande en administrateur
  • Aller dans le dossier Go avec les commande « CD » et « LS »
  • Taper la commande, « gort arduino install »
  • Vous devriez voir apparaître une fenêtre d’installation, finalisez l’installation

Git

  • Installer GITHUB

Configuration du PC

  • Aller dans « panneau de configuration -> système et sécurité -> système -> Paramètre système avancés » ajouter la variable d’environnement suivante : nom de la variable :GOPATH , valeur de la variable: mettre le chemin jusqu’au dossier GO
  • Ouvrir l’invite de commande :
  • Taper : go get github.com/tarm/goserial
  • Taper go get -u github.com/hybridgroup/gobot && go install github.com/hybridgroup/gobot/platform/firmata

Configuration de l’arduino

  • Ouvrez l’IDE arduino
  • Aller dans fichier -> exemples -> firmata -> StandardFirmata
  • Téléverser le programme dans l’arduino Mega
  • Relever le numéro de port COM de votre arduino nécessaire pour la suite

3 – Exécution du programme Go

  • Ouvrez le fichier firmata_blink.go
  • Modifiez à la ligne 14 « /dev/ttyACM0 » par le port « COMX »relevé dans l’étape précédente
  • Ouvrir l’invité de commande
  • Taper : go run firmata_blink.go
  • Vous pouvez maintenant observer la LED L de l’Arduino clignoter

Maintenant à vous de réaliser de superbes projets.

Ressources:

GOBOT IO

[Tuto] Graver un bootloader sur ATMEGA328 sans oscillateur et le programmer via ICSP

Ici nous allons voir comment graver un bootloader sur ATMEGA328P sans ocillateur.
Pour cela, il vous faudra:

  • Un Arduino
  • Un Microcontrôleur ATMEGA328P
  • Jumper male-male
  • Breadboard

1- Programmer l’arduino UNO en tant que programmateur

  • Brancher l’Arduino Uno à l’ordinateur puis ouvrer l’IDE
  • Dans « Outils » => « Type de carte », sélectionner « Arduino Uno »
  • Dans « Outils » => « Port », sélectionner le port COM correspondant à l’Arduino
  • Dans « Outils » => « Programmateur », sélectionner « AVRISP mkII »
  • Dans « Fichier » => « Exemple » puis cliquez sur « ArduinoISP »
  • Téléverser le programme

2- Ajouter la board ATMEGA328 Standalone 8Mhz Internal Clock

  • Dans « Fichier » => « Préférences » aller dans le champ « Additional Boards Manager URLs“ et copier http://oranginam.free.fr/download/package_oranginam_atmega328_index.json
  • Dans « Outils » => « Type de carte », cliquer sur « Boards Manager »
  • Cliquer dans la section « Atmega328 Standalone » puis cliquez sur « Install »
  • Redémarrer l’ide, vous verrez apparaitre dans le type de carte « Atmega328 Standalone 8Mhz Internal Clock »

3- Câblage entre ATMEGA328 et Arduino UNO

simplebreadboardavr

4- Graver la séquence d’initialisation (bootloader)

  • Brancher l’Arduino Uno à l’ordinateur puis ouvrer l’IDE
  • Dans « Outils » => « Type de carte », sélectionner « ATmega328 Standalone 8Mhz Internal Clock »
  • Dans « Outils » => « Port », sélectionner le port COM correspondant à l’arduino
  • Dans « Outils » => « Programmateur », Sélectionner « Arduino As ISP »
  • Cliquez sur  »Graver la séquence d’initialisation »

C’est fini vous avez le bootloader de gravé il est prêt à être programmé.

4- Programmer votre ATMEGA328 avec le programme de votre choix
Nous allons ici programmer l’ATMEGA en laissant le même câblage que précédemment.

  • Lancer l’IDE Arduino
  • Ouvrir le programme à téléverser
  • Dans  »Outils » =>  »Type de carte » => sélectionner  »ATmega328 on a breadboard 8 MHz internal clock »
  • Dans  »Outils » =>  »Programmateur » => sélectionner  »Arduino as ISP »
  • Dans  »Croquis » => Téléverser avec un programmateur

Ressources:
http://oranginam.free.fr/index.php?option=com_content&view=article&id=45:atmega328-standalone&catid=31:arduino&Itemid=57

[Tuto] Accéléromètre ADXL 345

Ici sera présenté l’utilisation de l’accéléromètre ADXL 345
Pour cela, il vous faudra:

  • Un Arduino
  • Un Accéléromètre ADXL345
  • Jumper male-femelle

Cette accéléromètre présent en boutique est le suivant:

accelerometre-adxl345

Étape câblage:

La communication entre l’accéléromètre et l’arduino se fait via le bus I2C situé sur les broches A4 et A5 de l’arduino avec une vitesse par défaut de 100kHz.

  • GND (ADXL 345) ⇒ Arduino GND
  • 3V3 (ADXL 345) ⇒ Arduino 3V3
  • SDA (ADXL 345) ⇒ Arduino A4
  • SCL (ADXL 345) ⇒ Arduino A5

Étape logiciel:

Le programme qui suit n’a besoin d’aucune librairie, nous allons lire dans les registres les valeurs d’accélération selon X, Y et Z pour ensuite les afficher sur le terminal.

 

#include <Wire.h>

// Broche d'Arduino pour communication I2C avec accéléromètre LG-ADXL345.
const int ACCELEROMETRE_1_SCL = A5;
const int ACCELEROMETRE_1_SDA = A4;

//*****************************************************************************
// Déclaration des variables globales.
//*****************************************************************************

// Adresses de communication I2C avec accéléromètre ADXL345.
const char Accellerometre3AxesAdresse = 0x53;
byte Accellerometre3AxesMemoire [6];
const char POWER_CTL = 0x2D;// Registre "Power Control".
const char DATA_FORMAT = 0x31;// Registre "Data Format".
const char DATAX0 = 0x32;//X-Axis Data 0
const char DATAX1 = 0x33;//X-Axis Data 1
const char DATAY0 = 0x34;//Y-Axis Data 0
const char DATAY1 = 0x35;//Y-Axis Data 1
const char DATAZ0 = 0x36;//Z-Axis Data 0
const char DATAZ1 = 0x37;//Z-Axis Data 1

const char Accellerometre_1_Precision2G  = 0x00;
const char Accellerometre_1_Precision4G  = 0x01;
const char Accellerometre_1_Precision8G  = 0x02;
const char Accellerometre_1_Precision16G = 0x03;
const char Accellerometre_1_ModeMesure   = 0x08;

// Pour recevoir les valeurs des 3 axes de l'accéléromètre.
int Accelerometre1_AxeX = 0;
int Accelerometre1_AxeY = 0;
int Accelerometre1_AxeZ = 0;

//*****************************************************************************


//*****************************************************************************
// FONCTION SETUP = Code d'initialisation.
//*****************************************************************************

void setup ()
{
  // Ici les instructions à exécuter au démarrage.

  // IMPORTANT : régler le terminal côté PC avec la même valeur de
  // transmission. Ici c'est 115200.
  Serial.begin (115200);

  // Initialisation de la communication I2C bus pour le capteur d’accélération.
  Wire.begin ();
  // Mettre le ADXL345 à plage +/-4G en écrivant la valeur 0x01 dans le
  // registre DATA_FORMAT.
  AccellerometreConfigure (DATA_FORMAT, Accellerometre_1_Precision4G);
  // Mettre le ADXL345 en mode de mesure en écrivant 0x08 dans le registre
  // POWER_CTL.
  AccellerometreConfigure (POWER_CTL, Accellerometre_1_ModeMesure);
}

void loop()
{
  
    // Pour affichage dans le moniteur série de l'éditeur Arduino.
    AccellerometreLecture ();
    Serial.print (" AxeX:");
    Serial.print (Accelerometre1_AxeX);
    Serial.println ();
    Serial.print (" AxeY:");
    Serial.print (Accelerometre1_AxeY);
    Serial.println ();
    Serial.print (" AxeZ:");
    Serial.print (Accelerometre1_AxeZ);
    Serial.println ();
  
}

//*****************************************************************************
// FONCTION AccellerometreConfigure
//*****************************************************************************
void AccellerometreConfigure (byte address, byte val)
{
  // Commencer la transmission à trois axes accéléromètre
  Wire.beginTransmission (Accellerometre3AxesAdresse);
  // Envoyer l'adresse de registre
  Wire.write (address);
  // Envoyer la valeur à écrire.
  Wire.write (val);
  // Fin de la transmission.
  Wire.endTransmission ();
}

//*****************************************************************************
// FONCTION AccellerometreLecture ()
//*****************************************************************************
void AccellerometreLecture ()
{
  uint8_t NombreOctets_a_Lire = 6;
  // Lire les données d'accélération à partir du module ADXL345.
  AccellerometreLectureMemoire (DATAX0, NombreOctets_a_Lire,
                                Accellerometre3AxesMemoire);

  // Chaque lecture de l'axe vient dans une résolution de 10 bits, soit 2 octets.
  // Première Octet significatif !
  // Donc nous convertissons les deux octets pour un « int ».
  Accelerometre1_AxeX = (((int)Accellerometre3AxesMemoire[1]) << 8) |
      Accellerometre3AxesMemoire[0];
  Accelerometre1_AxeY = (((int)Accellerometre3AxesMemoire[3]) << 8) |
      Accellerometre3AxesMemoire[2];
  Accelerometre1_AxeZ = (((int)Accellerometre3AxesMemoire[5]) << 8) |
      Accellerometre3AxesMemoire[4];
}

//*****************************************************************************
// FONCTION AccellerometreLectureMemoire
//*****************************************************************************
void AccellerometreLectureMemoire (byte address, int num, byte
                                   Accellerometre3AxesMemoire[])
{
  // Démarrer la transmission à accéléromètre.
  Wire.beginTransmission (Accellerometre3AxesAdresse);
  // Envoie l'adresse de lire.
  Wire.write (address);
  // Fin de la transmission.
  Wire.endTransmission ();
  // Démarrer la transmission à accéléromètre.
  Wire.beginTransmission (Accellerometre3AxesAdresse);
  // Demande 6 octets à l'accéléromètre.
  Wire.requestFrom (Accellerometre3AxesAdresse, num);

  int i = 0;
  // L'accéléromètre peut envoyer moins que demandé, c'est anormal, mais...
  while (Wire.available())
  {
    // Recevoir un octet.
    Accellerometre3AxesMemoire[i] = Wire.read ();
    i++;
  }
    // Fin de la transmission.
  Wire.endTransmission ();
}

Les résultats sur le terminal arduino ide:

adxl345_results

Ressources:
http://playground.arduino.cc/French/TutorielsCodeSourceAutonome-Capteur-Accelerometre-LG-ADXL345-I2C-LCD1602Shield