[Tuto] Pilotage de moteur triphasé à faible vitesse

Cet article est inspiré du travail de BerryJam -> http://www.berryjam.eu/2015/04/driving-bldc-gimbals-at-super-slow-speeds-with-arduino/

L’objectif de cet article est de piloter un moteur triphasé à l’aide du module driver L6234 conçu par Letmeknow avec un Arduino Uno. Coté câblage, rien de plus simple:

Module Driver L6234Arduino
GNDGND
IN1D9
IN2D10
IN3D11
EN1D5
EN2D6
EN3D7
PWRVIN

Pour le moteur, on relie simplement les 3 phases sur les 3 broches P1, P2 et P3.

Coté logiciel, on va rester sur le code proposé par BerryJam:


//
// Slow and precise BLDC motor driver using SPWM and SVPWM modulation
// Part of code used from http://elabz.com/
// (c) 2015 Ignas Gramba www.berryjam.eu
//
 
 
const int EN1 = 5;
const int EN2 = 6;
const int EN3 = 7;
 
const int IN1 = 9;
const int IN2 = 10;
const int IN3 = 11;
 
 
// SPWM (Sine Wave)
//const int pwmSin[] = {127, 138, 149, 160, 170, 181, 191, 200, 209, 217, 224, 231, 237, 242, 246, 250, 252, 254, 254, 254, 252, 250, 246, 242, 237, 231, 224, 217, 209, 200, 191, 181, 170, 160, 149, 138, 127, 116, 105, 94, 84, 73, 64, 54, 45, 37, 30, 23, 17, 12, 8, 4, 2, 0, 0, 0, 2, 4, 8, 12, 17, 23, 30, 37, 45, 54, 64, 73, 84, 94, 105, 116 };
 
 
/// SVPWM (Space Vector Wave)
//const int pwmSin[] = {128, 147, 166, 185, 203, 221, 238, 243, 248, 251, 253, 255, 255, 255, 253, 251, 248, 243, 238, 243, 248, 251, 253, 255, 255, 255, 253, 251, 248, 243, 238, 221, 203, 185, 166, 147, 128, 109, 90, 71, 53, 35, 18, 13, 8, 5, 3, 1, 1, 1, 3, 5, 8, 13, 18, 13, 8, 5, 3, 1, 1, 1, 3, 5, 8, 13, 18, 35, 53, 71, 90, 109};
const int pwmSin[] = {128, 132, 136, 140, 143, 147, 151, 155, 159, 162, 166, 170, 174, 178, 181, 185, 189, 192, 196, 200, 203, 207, 211, 214, 218, 221, 225, 228, 232, 235, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 249, 250, 250, 251, 252, 252, 253, 253, 253, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 254, 254, 253, 253, 253, 252, 252, 251, 250, 250, 249, 248, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 249, 250, 250, 251, 252, 252, 253, 253, 253, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 254, 254, 253, 253, 253, 252, 252, 251, 250, 250, 249, 248, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 235, 232, 228, 225, 221, 218, 214, 211, 207, 203, 200, 196, 192, 189, 185, 181, 178, 174, 170, 166, 162, 159, 155, 151, 147, 143, 140, 136, 132, 128, 124, 120, 116, 113, 109, 105, 101, 97, 94, 90, 86, 82, 78, 75, 71, 67, 64, 60, 56, 53, 49, 45, 42, 38, 35, 31, 28, 24, 21, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 8, 7, 6, 6, 5, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 8, 7, 6, 6, 5, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 21, 24, 28, 31, 35, 38, 42, 45, 49, 53, 56, 60, 64, 67, 71, 75, 78, 82, 86, 90, 94, 97, 101, 105, 109, 113, 116, 120, 124};
 
int currentStepA;
int currentStepB;
int currentStepC;
int sineArraySize;
int increment = 0;
boolean direct = 1; // direction true=forward, false=backward
 
//////////////////////////////////////////////////////////////////////////////
 
void setup() {
 
  setPwmFrequency(IN1); // Increase PWM frequency to 32 kHz  (make unaudible)
  setPwmFrequency(IN2);
  setPwmFrequency(IN3);
 
  pinMode(IN1, OUTPUT); 
  pinMode(IN2, OUTPUT); 
  pinMode(IN3, OUTPUT); 
  
  pinMode(EN1, OUTPUT); 
  pinMode(EN2, OUTPUT); 
  pinMode(EN3, OUTPUT); 
 
 
  digitalWrite(EN1, HIGH);
  digitalWrite(EN2, HIGH);
  digitalWrite(EN3, HIGH);
  
 
  sineArraySize = sizeof(pwmSin)/sizeof(int); // Find lookup table size
  int phaseShift = sineArraySize / 3;         // Find phase shift and initial A, B C phase values
  currentStepA = 0;
  currentStepB = currentStepA + phaseShift;
  currentStepC = currentStepB + phaseShift;
 
  sineArraySize--; // Convert from array Size to last PWM array number
}
 
//////////////////////////////////////////////////////////////////////////////
 
void loop() {
 
  analogWrite(IN1, pwmSin[currentStepA]);
  analogWrite(IN2, pwmSin[currentStepB]);
  analogWrite(IN3, pwmSin[currentStepC]);  
  
  if (direct==true) increment = 1;
  else increment = -1;     
 
  currentStepA = currentStepA + increment;
  currentStepB = currentStepB + increment;
  currentStepC = currentStepC + increment;
 
  //Check for lookup table overflow and return to opposite end if necessary
  if(currentStepA > sineArraySize)  currentStepA = 0;
  if(currentStepA < 0)  currentStepA = sineArraySize;
 
  if(currentStepB > sineArraySize)  currentStepB = 0;
  if(currentStepB < 0)  currentStepB = sineArraySize;
 
  if(currentStepC > sineArraySize)  currentStepC = 0;
  if(currentStepC < 0) currentStepC = sineArraySize; 
  
  /// Control speed by this delay
  delay(10);
 
}
 
 
void setPwmFrequency(int pin) {
  if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {
    if(pin == 5 || pin == 6) {
      TCCR0B = TCCR0B & 0b11111000 | 0x01;
    } else {
      TCCR1B = TCCR1B & 0b11111000 | 0x01;
    }
  }
  else if(pin == 3 || pin == 11) {
    TCCR2B = TCCR2B & 0b11111000 | 0x01;
  }
}

Pour aller plus loin, vous pouvez joué sur le SVPWM comme dans ce tuto https://electronics-project-hub.com/3-phase-sine-wave-generator-code-arduino/ et piloter la vitesse de votre moteur par un potentiomètre.

//-------www<electronics-project-hub>com--------//
#include <math.h>
int Output1 = 9;
int Output2 = 10;
int Output3 = 11;
const int EN1 = 5;
const int EN2 = 6;
const int EN3 = 7;
int potVal = 0;
float A = 0;
float B = 0.104;
int Freq_IN = A0;
int var1 = 0;
int var2 = 0;
int var3 = 0;
int var4 = 0;
int var5 = 0;
int var6 = 0;
float Phase1 = 2 * PI / 3;
float Phase2 = 4 * PI / 3;
float Phase3 = 2 * PI;
boolean toggle = true; // true = Enabling Serial Plotter Output
void setup()
{
  Serial.begin(9600);
  pinMode(Output1, OUTPUT);
  pinMode(Output2, OUTPUT);
  pinMode(Output3, OUTPUT);
  pinMode(Freq_IN, INPUT);
  pinMode(EN1, OUTPUT); 
  pinMode(EN2, OUTPUT); 
  pinMode(EN3, OUTPUT); 
  digitalWrite(EN1, HIGH);
  digitalWrite(EN2, HIGH);
  digitalWrite(EN3, HIGH);
}
void loop()
{
  A += B;
  analogWrite(Output1, var1);
  analogWrite(Output2, var2);
  analogWrite(Output3, var3);
  if (toggle == true)
  {
    Serial.print(var1);
    Serial.print(" ");
    Serial.print(var2);
    Serial.print(" ");
    Serial.println(var3);
  }
  var4 = 126 * sin(A + Phase1);
  var1 = var4 + 128;
  var5 = 126 * sin(A + Phase2);
  var2 = var5 + 128;
  var6 = 126 * sin(A + Phase3);
  var3 = var6 + 128;
  if (A >= 2 * PI)
  {
    A = 0;
  }
  potVal = analogRead(Freq_IN);
  delay(potVal);
}
//-------www<electronics-project-hub>com--------//

[Tuto] : Les sleep modes de l’ESP32

Les sleep modes sont des états qui permettent de mettre en sommeil l’ESP 32. On éteint alors certains périphériques et les données sont conservées dans la RAM.

Il existe 5 modes d’économie d’énergies différents, nous allons les étudier un à un :

  • mode actif ( par défaut)
  • mode modem
  • mode light speed
  • mode sommeil profond
  • mode hibernation

Le mode actif : normal

Tout est allumé.

Le mode modem : WiFi, Bluetooth et radio désactivés

Pour maintenir les connexions WiFi / Bluetooth vivantes, le processeur, le Wi-Fi, Bluetooth et la radio sont réactivés à des intervalles prédéfinis. Ces modules sont responsables de la majeure partie de la consommation de la carte, c’est pourquoi nous allons chercher à les désactiver.

Pendant ce mode de veille, le mode d’alimentation bascule entre le mode actif et le mode veille du modem.

L’ESP32 peut entrer en mode veille du modem uniquement lorsqu’il se connecte au routeur en mode station ( connexion sans fil).

L’ESP 32 reçoit à intervalle régulier des message DTIM (Delivery Traffic Indication Message) du routeur pour l’informer que la communication avec celui ci est possible.

Entre deux messages DTIM, les échanges de données  avec le routeur sont impossibles, le WiFi et le Bluetooth sont donc désactivés durant ce laps de temps pour économiser de la batterie. Le temps de sommeil est généralement compris entre 100 et 1000 ms.


Light Sleep mode

Il comporte toutes les fonctionnalités du mode modem et plus encore. Ce mode permet d’économiser encore plus de batterie en utilisant le procédé de “Clock-Gating”.

Ce phénomène est à l’oeuvre dans la RAM et le CPU où des parties du circuit sont mises hors tension pour empêcher les bascules flip-flop qui composent le circuit de changer d’état.

Ces bascules sont synchronisées par l’horloge interne de la carte (RTC). En mode actif, elles changent d’état (effectuent une action), à chaque coup d’horloge. En mode light sleep, ce n’est plus le cas, elles restent dans le même état.

C’est  uniquement durant le changement d’état qu’il y a consommation, le clock gating permet donc d’économiser de la batterie.

Avant d’entrer en mode light sleep, L’ESP garde en mémoire les données et reprendra l’exécution du code là ou il s’est arrêté. L’avantage de ce mode est qu’il permet un réveil rapide tout en économisant de la batterie. 

Pour observer le fonctionnement du mode light sleep, je vous propose de téléverser le code suivant et d’ouvrir le moniteur série. 


void setup() {
    Serial.begin(115200);
    Serial.println("setup");
}

void loop() {
    esp_sleep_enable_timer_wakeup(5000000); //5 seconds
    int ret = esp_light_sleep_start();
    Serial.print("light_sleep:");
    Serial.println(ret);
}

Vous observerez que la carte ne reboot pas en sortie de sommeil et qu’elle reprend l’exécution du programme toutes les 5 secondes là où elle s’était arrêtée.

Deep Sleep

Pendant le deep sleep mode la majeure partie de la RAM et tous les périphériques numériques sont mis hors tension. Les seules parties de la puce qui restent sous tension sont les suivantes :

  • contrôleur RTC
  • périphériques RTC (y compris le processeur ULP)
  • mémoires RTC (lentes et rapides).

Nous allons réaliser un montage visant à montrer que même en plongeant notre carte en sommeil profond, il est possible de sauvegarder des données.

Vous aurez besoin de :

Montage à réaliser

Pour sauvegarder une variable même après avoir mis l’ESP en deep sleep mode il faut l’enregistrer dans la mémoire RTC en déclarant la variable en globale avec le type :

RTC_DATA_ATTR

par exemple :

RTC_DATA_ATTR int bootCount = 0;

copiez collez le code et téléversez le à l’aide de l’IDE arduino.


#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  3        /* Time ESP32 will go to sleep (in seconds) */

RTC_DATA_ATTR int bootCount = 0;

int GREEN_LED_PIN = 25;
int YELLOW_LED_PIN = 26;

void setup(){

  pinMode(GREEN_LED_PIN,OUTPUT);
  pinMode(YELLOW_LED_PIN,OUTPUT);
  delay(500);
  
  if(bootCount == 0) //Run this only the first time
  {
      digitalWrite(YELLOW_LED_PIN,HIGH);
      bootCount = bootCount+1;
  }else
  {
      digitalWrite(GREEN_LED_PIN,HIGH);
  }
  
  delay(3000);

  digitalWrite(GREEN_LED_PIN,LOW);
  digitalWrite(YELLOW_LED_PIN,LOW);

  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  esp_deep_sleep_start();
}

void loop(){
  
}

Contrairement au mode light sleep, la carte redémarre à chaque réveil et effectue donc à nouveau le setup.  

Dans ce code, on instancie une variable bootcount qu’on stocke dans la mémoire RTC. La première fois que le setup est effectué, la led jaune doit s’allumer car bountcount est égale à 0.

En sortie de sommeil profond, Bountcount est égale à 1 car la variable a été incrémentée au tour d’avant. Cette fois ci, seul la led verte s’allume. La valeur de notre variable est conservée, la led jaune ne s’allume donc qu’une seule fois. 

Mode Hibernation

Il désactive les mêmes fonctionnalités désactivées par le mode sommeil profond. A cela s’ajoute le fait que la mémoire RTC est aussi privée d’alimentation. Il en résulte qu’il est impossible de sauvegarder des données en utilisant ce mode d’économie d’énergie. 

La consommation durant ce mode est censée être extrêmement faible (seulement quelques micro ampères)

Les façons de réveiller l’ESP32 :

Une fois mis en sommeil, il existe différentes façons de réveiller un ESP32. La déclaration de ces fonctions doit toujours se faire avant l’appel de la fonction provoquant le mode sleep. Cependant, vous pouvez toujours réveiller votre ESP32 en appuyant sur le bouton EN. Cela le redémarrera.  

Timer :

Cette méthode peut être utilisée quelque soit le mode d’économie d’énergie activé. La carte se met en sommeil durant un temps défini par l’utilisateur et se réveille ensuite. 

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP)// temps en micro seconde;

C’est cette méthode qui a été utilisée dans les exemples ci dessus.

Réveil externe :

Il est possible de réveiller un ESP32 après lui avoir envoyé un signal  digital sur une de ces pin.

void setup() {
    Serial.begin(115200);
    Serial.println("setup");
}

void loop() {
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_27,HIGH);
    int ret = esp_light_sleep_start();
    Serial.print("light_sleep:");
    Serial.println(ret);
}

Ce code permet de sortir du mode light sleep dès que la pin 27 reçoit un 1 logique. Si le signal repasse à 0, la carte retombera en mode sommeil. 

Avec certains ajustements, il est aussi possible d’utiliser une interruption externe pour sortir du mode sommeil profond : 

void setup() {
    Serial.begin(115200);
    Serial.println("setup");
}
void loop() {
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_27,LOW);
     esp_deep_sleep_start();// la fonction ne retourne rien
}

On est plongé dans le mode sommeil profond tant que la valeur sur la pin 27 est à HIGH.  

Vous êtes maintenant en mesure de comprendre comment les différents sleep modes de l’ESP32 fonctionnent et vous pouvez désormais les utiliser.

[Tuto] Programmation d’un ESP32 Basic Over The Air (OTA) avec l’IDE arduino

Le but de ce tutoriel est de programmer un esp32 pour pouvoir téléverser du code sans être relié physiquement à la carte. 

Ce tutoriel repose sur l’utilisation du code fourni dans la bibliothèque esp32 : Basic OTA, ainsi l’ordinateur avec lequel le code sera téléversé doit être connecté au même réseau WiFi que notre carte. 

tutoriel réalisé à l’aide du tutoriel de last minute engineers 

Matériel :

1 carte esp 32 (modèle Node32s)

Installation de Python 2.7.15

  1. Cliquez ici et téléchargez la version  qui correspond à votre système d’exploitation. Pour windows, favorisez la version MSI installer 
  2. cochez la case ‘install for all users’
  3. Dans la partie  “ Customise Python 2.7.15”, activez l’option add Python.exe to path : 

Initialisation :

1.Téléchargez la dernière version de l’IDE Arduino.

2. Si vous utilisez la carte mentionnée ci dessus, vous allez devoir ajouter la carte dans la liste des cartes prises en charge par l’IDE Arduino. Ouvrez l’IDE, « Fichier » → « Préférences » et dans « URL de gestionnaire de cartes supplémentaires » ajoutez le lien suivant : https://dl.espressif.com/dl/package_esp32_index.json

3. Allez ensuite dans le gestionnaire de carte et tapez esp 32 : téléchargez la version 1.0.0 de esp by Espressif system. Cela peut prendre quelques minutes. A la fin vous devez avoir le résultat ci contre :

4. Modifiez l’onglet outils pour qu’il corresponde à l’image ci dessous : 

Vous pouvez connaître le port COM de votre carte à l’aide d’un gestionnaire de périphérique. 

5. Copiez collez le code fourni

// Code exemple fournit dans la bibliothèque esp 32 espressif
// Ajout d'un programme pour vérifier le fonctionnement du téléversement à distance.
#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "-----";
const char* password = "-----";

//variabls for blinking an LED with Millis
/*const int led = 2; 
// ESP32 Pin to which onboard LED is connected
unsigned long previousMillis = 0;  // will store last time LED was updated
const long interval = 1000;  // interval at which to blink (milliseconds)
int ledState = LOW;*/ // ledState used to set the LED

void setup() {

//pinMode(led, OUTPUT);  
  Serial.begin(115200);
  Serial.println("Booting");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("Connection Failed! Rebooting...");
    delay(5000);
    ESP.restart();
  }

  // Port defaults to 3232
  // ArduinoOTA.setPort(3232);

  // Hostname defaults to esp3232-[MAC]
  // ArduinoOTA.setHostname("myesp32");

  // No authentication by default
  // ArduinoOTA.setPassword("admin");

  // Password can be set with it's md5 value as well
  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");

  ArduinoOTA
    .onStart([]() {
      String type;
      if (ArduinoOTA.getCommand() == U_FLASH)
        type = "sketch";
      else // U_SPIFFS
        type = "filesystem";

      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
      Serial.println("Start updating " + type);
    })
    .onEnd([]() {
      Serial.println("\nEnd");
    })
    .onProgress([](unsigned int progress, unsigned int total) {
      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
    })
    .onError([](ota_error_t error) {
      Serial.printf("Error[%u]: ", error);
      if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
      else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
      else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
      else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
      else if (error == OTA_END_ERROR) Serial.println("End Failed");
    });

  ArduinoOTA.begin();

  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  ArduinoOTA.handle();
  //loop to blink without delay
 /*unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
  // save the last time you blinked the LED
  previousMillis = currentMillis;
  // if the LED is off turn it on and vice-versa:
  ledState = not(ledState);
  // set the LED with the ledState of the variable:
  digitalWrite(led,  ledState);
  }*/
}

6. Renseignez votre identifiant WiFi et votre mot de passe : 

const char* ssid = "-----"; // nom du réseau
const char* password = "-----";// mot de passe

7.Téléversez le code. Il peut être nécessaire de maintenir le bouton Boot  de la carte enfoncé durant cette étape. 

8. Ouvrez le moniteur série ( en appuyant sur la petite loupe en haut à gauche) et appuyez sur le bouton EN de la carte. 

Voici l’affichage que vous devez obtenir. Sur la dernière ligne, vous pourrez observer votre adresse IP, notez la car vous en aurez besoin pour la suite. 

Si l’affichage du moniteur série ne correspond pas à l’image ci dessus, veuillez à nouveau appuyer sur le bouton EN. 

Téléversement d’un nouveau croquis Over-The-Air

Pour permettre le téléversement OTA, la séquence d’initialisation que nous venons de compiler doit toujours être présente. Ainsi, pour des questions de simplicité, nous allons rajouter du code dans notre exemple. 

Pour s’assurer que le téléversement sans fil fonctionne, nous allons  réaliser un programme faisant clignoter la led interne de notre carte. 

1.Décommentez  les lignes 14 à 17, la ligne 21 ainsi que les lignes 83 à 91. 

Les plus observateur d’entre vous auront remarqué que le code dans la fonction loop() est un peu plus compliqué que nécessaire. Cela est dû au fait qu’en programmation OTA, il est déconseillé d’utiliser la fonction delay(). En effet, lorsque cette fonction est utilisée sur un ESP32, la carte se met en pause. Si la prochaine requête OTA est générée pendant que notre carte est en pause, le programme va manquer la requête et ne pourra s’exécuter correctement. 

2. Changez le port dans l’onglet Outils de l’IDE. Une nouvelle catégorie intitulée port réseau devrait être disponible.

L’adresse IP doit correspondre à celle qui était affichée lors de la phase d’initiation.  Si vous ne trouvez pas le port, il peut être nécessaire de redémarrer l’IDE.

3. Téléversez le nouveau code; Une led bleue doit clignoter à une fréquence de 1Hz. Si tel est le cas, le programme a été téléversé à distance, vous avez réussi. 


[TUTO] Mettre en oeuvre une antenne NFC externe sur un module PN532

Vous êtes sans doute déjà familiarisé avec les lecteurs permettant de lire des informations stockées sur un tag RFID. La technologie NFC est une extension de ces modules RFID : le NFC vous permet d’échanger des informations entre deux téléphones placés l’un à côté de l’autre, ou entre n’importe quels appareils équipés de cette technologie.
Le module NFC PN352 possède donc une double casquette : il s’agit à la fois d’un lecteur NFC et RFID, capable de décrypter les données issues de ces deux technologies.

Si vous souhaitez déporter l’antenne, il vous faudra malheureusement déporter tout le module vu que l’antenne est directement sur la carte électronique.

Mais grâce à l’antenne NFC, vous souderez seulement deux fils à la longueur que vous souhaiterez au condensateurs représentez ci-dessous

Le module PN532 est capable de communiquer avec 3 bus :

  • I2C
  • SPI
  • HSI

Pour cette exemple, nous utiliserons le bus I2C.

Pour le bus I2C, il faudra le channel 1 en position ON. L’adresse I2C est 0x24.

Ensuite, il vous faudra une librairie pour compiler le code de test. Vous pouvez cliquez ci-dessous pour télécharger la librairie.

PN532

Une fois télécharger, vous devez extraire le contenu, puis le mettre dans votre dossier Arduino, (Mes documents / Arduino / librairies)

Démarrez le logiciel Arduino IDE
Dans Fichier => Exemples => PN532, ouvrez iso14443a_uid

Téléverser le code vers votre carte Arduino préalablement sélectionné

Votre code téléverser, ouvrez le moniteur série, vous devriez voir :

Si vous passez une carte sur le module PN532 ou sur l’antenne NFC sur laquelle vous avez soudez les fils, vous devriez voir l’UID de votre carte.

[Debug] Convertisseur USB UART

Les convertisseurs USB UART les plus répandus pour Arduino sont sur base de PL2303. Ce composant est conçu par Prolific. De très nombreuses versions existent sur internet, voici le process que l’on a validé sur nos postes.

Etape 1: Installer le driver

Le driver en question est disponible ici: Driver Prolific

Installez le sur votre ordinateur.

Etape 2: Forcer l’installation de ce Driver

Ouvrez le gestionnaire de périphériques (Sous Windows, cliquez sur Démarrer puis écrivez « Gestionnaire » il devrait apparaître).

Vous devriez avoir quelque chose comme cela:

Cliquez droit sur « USB-Serial Controller » puis « Mettre à jour le pilote »

Choisissez « Parcourir mon ordinateur à la recherche du logiciel de pilote ».

Cliquez ensuite sur « Choisir parmi une liste de pilotes disponibles sur mon ordinateur »

Dans la liste, choisissez « Ports (COM et LPT) »

Vous pouvez ensuite avoir plusieurs versions de pilote. Il faut choisir le 3.3.2.105

L’installation se lance puis votre module est fonctionnel.

[TUTO] Update Firmware SIM8XX

Il existe plusieurs modules GSM de la série SIM800 de chez SIMCOM possédant chacun des spécificités propres : taille, interfaces, fonctions supplémentaires (GNSS, Bluetooth)… etc. Les firmwares de ces modules sont souvent mis à jour, intégrant alors de nouvelles fonctionnalités (ajout de nouvelles commandes, fix de bugs…). Cet article vous présente comment mettre à jour vos modules SIMCOM de la série SIM8XX et ainsi exploiter tout le potentiel de votre matériel.

Ce tutoriel utilise un flashage du firmware par la liaison série du module (RX / TX). Un Arduino en MultiSerial ou convertisseur UART – USB peuvent être utilisés afin d’interfacer le module avec votre ordinateur.

Le module utilisé pour la démonstration est un SIM800L de chez SIMCOM.

Téléchargement de l’outil :

Télécharger la dernière version du firmware du module sur le site officiel de SIMCOM : http://simcom.ee/documents/?dir

Lancer l’exécutable :

Entrer les configurations de la carte :

  • Target : type de carte utilisé (ici un SIM800L)
  • PortType : type de transfert, via liaison USB ou UART (RX / TX)
  • Com : port COM utilisé
  • Baud rate : vitesse de transmission (souvent 9600 ou 115200 par défaut)
  • Image Folder : sélection du firmware à flasher dans le module

Cliquer sur Image Folder afin de sélectionner le .cfg du firmware à flasher :

Vérifier que le module est bien ETEINT puis cliquer sur Start Download. Le module doit être éteint afin que le logiciel puisse flasher le module avant son démarrage complet. Une indication (waiting) apparait, attendant le démarrage du module.

Allumer le module. La barre de téléchargement doit alors se lancer.

Une fois le download correctement effectué, une fenêtre apparaît indiquant le bon déroulement du processus.

Sources d’erreurs possibles :

  • Mauvais port COM sélectionné
  • Erreur de branchement des signaux RX/TX
  • Ordre d’allumage du module
  • Mauvais firmware

nb : pour le cas du SIM800L, deux versions de firmwares existent. Selon la version du module il faut choisir l’une ou l’autre. La commande AT+GMR retourne la version du firmware dans le module :
1308B0XSIM800L16 = mettre la version de firmware disponible sur le site SIMCOM
1418B0XSIM800L24 = mettre la version de firmware suivante : 1418B05SIM800L24

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 !

[Tuto] Le capteur Pulse Sensor

Dans ce tutoriel, je vais vous expliquer comment mettre facilement en place votre capteur Pulse Sensor.

Matériel nécessaires:
– 1 Arduino Uno
– 1 Capteur Pulse Sensor
– Du scotch occultant

1. Branchement

20160921_163044

Branchez:
– Le fil marron (+) sur la pin +5v de l’arduino.
– Le fil noir (-) sur la pin gnd.
– Le fil rouge (data) sur la pin A0.

Si tout a bien été fait, la led du capteur devrait s’allumer en vert.

2. Mise en place Logiciel

Téléchargez le logiciel du capteur ICI.

Démarrez Arduino et lancez le programme  » PulseSensorAmped_Arduino_1dot4.ino ».

Afin d’avoir quelque chose de cohérent dans notre moniteur Serial il vous faudra modifier la ligne 30 du programme:  » static boolean serialVisual = false;  » en  » static boolean serialVisual = true; « .

Afin d’activer la visualisation ASCII (comme le mentionne le commentaire).

Téléversez le programme dans votre Arduino.

3. Tests

Placez votre pouce sur le capteur à l’aide du scotch occultant afin que la led puisse mesurer correctement.

20160921_174047

N’oubliez pas de paramétrer votre moniteur Serial en 115200 Bauds.

Voici le résultat :

untitled-3

4. Bonus

Il est possible d’avoir un retour graphique !

Pour cela, téléchargez :
Le logiciel Processing
Le programme PulseSensor pour Processing

Il vous faudra aussi reprogrammer votre Arduino en changeant la ligne 30 à nouveau :  » static boolean serialVisual = true;  » en  » static boolean serialVisual = false;

Lancez Processing.

Ouvrez le programme PulseSensor pour Processing que vous avez téléchargé précédemment ( » PulseSensorAmpd_Processing_1dot4.pde « ) via Fichier > Ouvrir.

Lancez le programme grâce au bouton Play en haut à gauche.

untitled-2

Le logiciel vous demandera alors  quel port com il doit analyser.

untitled-3

Il ne reste plus qu’a admirer votre poux !

untitled-5

[Tuto] Commander une led via l’application Blynk

Dans ce tutoriel je vais vous introduire le fonctionnement de l’application Blynk. Ici, je vais vous montrer comment commander une led via son smartphone en toute simplicité.

Matériel nécessaire :
– 1 Arduino YUN
– 1 LED
– 1 Smartphone avec l’application Blynk

1. Mise en place de l’application

screenshot_20160919-145605

Tout d’abord, allez télécharger l’application Blynk sur le store de votre smartphone.

Démarrez l’application et créez-vous un compte :

screenshot_20160919-144235

Créez un nouveau projet:

screenshot_20160919-144409

Choisissez un nom de projet (ici: « Led Blinkin »), le modèle de microcontrôleur utilisé (ici: Arduino Yun) et envoyez-vous par e-mail le token généré, il sera utile pour la liaison entre l’arduino et votre smartphone.

screenshot_20160919-144440

Ici nous voulons interagir sur une Pin de l’arduino afin d’allumer ou non une LED. Il nous faut donc ajouter un bouton qui simulera l’état de sortie de la Pin en question. Pour cela, cliquez sur le petit « + » encerclé, cela vous donnera accès à une multitude de widgets. Nous choisirons dans notre cas le bouton du haut.

screenshot_20160919-144449
screenshot_20160919-144520

Le voilà maintenant placé ! Nous allons le configurer : cliquez dessus.

screenshot_20160919-144534

Donnez lui le nom que vous voulez (ici: Led Button) avec une couleur associée. Ensuite il nous faut choisir la pin sur laquelle l’application va interagir (ici: D13). Nous voulons que le bouton se comporte comme un switch et vous pouvez également personnaliser le message affiché en fonction de l’état du bouton (ici: Light ON/Light OFF).

screenshot_20160919-144635
screenshot_20160919-144645

Nous voilà prêt du côté smartphone. Allons maintenant du côté Arduino.

2. Mise en place du montage Arduino

Dans mon cas je vais utiliser un Arduino YUN connecté en WIFI. Nous allons également utiliser la pin 13 de l’arduino. Branchez la LED entre la pin 13 et le GND.

20160919_144739

Installez la librairie « Blynk » (lien de téléchargement) dans l’IDE Arduino (Tuto disponible ICI). Une fois fait, il va falloir programmé l’Arduino Yun avec le programme dédié trouvable dans les exemples de la librairie.

untitled-2

Dans le programme veillez bien à remplacer à la ligne 28, le « YourAuthToken » par celui que vous vous êtes envoyé par mail auparavant. Téléversez le programme dans l’Arduino et c’est parti !

3. Test

Allez dans votre application Blynk et démarrez votre projet « Led Blinkin » en appuyant sur le bouton start (représenté par une flèche) en haut à droite.

Un message s’affichera en bas, dans le cas ou votre Arduino n’est pas connecté à un réseau.

screenshot_20160919-144534

Si vous appuyer sur le bouton la LED s’allume, si vous appuyez à nouveau la LED s’éteint !

untitled-3

Maintenant c’est à vous. Laissez libre cours à votre imagination !

[Tuto] Programmation d’un Attiny84 avec Arduino

Dans ce tutoriel je vais vous expliquer comment programmer un Attiny84 grâce à un Arduino Uno.

Matériel nécessaire :
– 1 Arduino UNO 
– 1 Attiny84
– 6 jumpers mâle-mâle
– 1 condensateur 1µF
– 1 breadboard

1. Arduino as ISP

Nous allons utiliser l’Arduino Uno comme intermédiaire entre le PC et l’attiny84. Pour pouvoir utiliser de tel manière il faut le programmer pour, grâce au programme « ArduinoISP » (disponible dans Fichiers / Exemples). Uploader le dans votre Arduino grâce au bouton téléverser.

1
Exemple
2
Programmation

2. Installation de la board

Pour pouvoir programmer un Attiny84 il faut que le logiciel puisse interpreter le code pour celui ci. C’est pourquoi il faut installer la « board » correspondante à l’Attiny84.

Allez dans Fichier > Préférences et cliquez sur le bouton entouré en rouge ci dessous.

Préférences
Préférences

Une fenêtre va s’ouvrir. Collez  » http://drazzy.com/package_drazzy.com_index.json  » puis cliquez  sur « OK » et fermer la fenêtre des préférences en cliquant sur « OK » à nouveau.

Json importation
Json importation

Redémarrez le logiciel pour que les modifications soient prises en comptes.

Allez ensuite dans Outils > Boards > Boards Manager…
Tappez « attiny » dans la barre de recherche et normalement deux résultats devraient apparaître. Installez la premiere grâce au bouton « install ». Une barre de progression vous indiquera l’avancement de l’installation.

Redémarrez votre logiciel.

Board manager
Board manager
Installation
Installation

3. Câblage

Suivez simplement le schéma ci-dessous. N’oubliez pas le condensateur de 10µF entre le reset et le gnd de l’arduino afin d’empêcher le reset automatique lors de la programmation de l’attiny84.

Schéma de branchement
Schéma de branchement

4. Programmation

Tout d’abord prenez votre programme. Configurez maintenant l’IDE afin qu’il comprenne qu’il doit programmer un Attiny84 comme ci dessous.

untitled-12

Téléversez votre programme grâce à la petite flèche et le tour est joué !

Voilà ! Vous pouvez maintenant programmer votre Attiny !