[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] 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] Dépannage station de soudure à air chaud

Les stations de soudure à air chaud sont devenues un indispensable pour assembler des composants CMS. Parmi les nombreuses références disponibles sur le marché des modèles entrée de gamme à 700/800W sont très présents sur le marché. Aujourd’hui nous vous expliquons comment les dépanner.

Les symptômes de pannes sont généralement au niveau du pistolet:

  • Non démarrage lors du retrait du socle
  • Problème de chauffe
  • Problème de flux d’air

Les modèles étant assez variés dans les connexions entre pistolet et station, voici la démarche que nous suivons pour le dépannage de nos modèles (YOUYUE 8586 et SAIKE 898D):

  • Ouvrir le pistolet
  • Réaliser le mapping
Sur le YOUYUE 8586:
1Temp sensor
2Commun sensor
3Capteur reed
4Masse
5GND fan
6VCC fan
7Blanc cartouche chauffe
8Rouge cartouche de chauffe
  • Remplacer le composant défectueux
  • Remonter le tout

[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

[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.

L’antenne externe est disponible en boutique et sur notre site:

https://letmeknow.fr/shop/fr/home/1658-antenne-nfc-externe.html

[Tuto] Trianguler la position avec le SIM800L (Arduino)

Pour voir le montage et la prise en main de ce module SIM800L, vous pouvez suivre le tuto sur cette page: Tuto SIM800L – Montage et prise en main 

Le programme suivant affiche dans le moniteur série la position du module SIM800L (latitude,longitude),ainsi que l’heure GMT ,grâce à des commandes AT :

//Importation des librairies
#include <SoftwareSerial.h>
#include <String.h>
#define AT_DELAY  3000    // Delai après envoi commande AT

SoftwareSerial sim800l(9, 10);// RX, TX

String Message, tampon;
String Latitude, Longitude, Time;
//stockage des differentes commandes // Configure le mode positionnement
String AT_COMMAND[9] = {"AT+CGATT =1", "AT+SAPBR =3,1,\"CONTYPE\",\"GPRS\"", "AT+SAPBR =3,1,\"APN\",\"orange.m2m.spec\"",
                        "AT+SAPBR =3,1,\"USER\",\"orange\"", "AT+SAPBR =3,1,\"PWD\",\"orange\"",
                        "AT+SAPBR=1,1", "AT+SAPBR=2,1", "AT+CIPGSMLOC=1,1"
                       };
void setup() {      // début du setup
  sim800l.begin(9600);// Démarrage du modem
  Serial.begin(9600);// Initialisation de la communication série
  Serial.println("start ...");
}

void loop() {    // Début du loop
  delay(2000);
  for (int k = 0; k < 9; k++)
  {
    sim800l.println(AT_COMMAND[k]);//envoie de la commande AT
    delay(650);//délai de réponse
    Message = sim800l.readString();//lecture du retour du sim800l
    Serial.println(Message);// affichage dans le moniteur série des commandes AT + réponse
    if (k == 8)
    {
      Serial.println("##############################################################");
      
      Serial.print("Time: "); 
      //récupération des chaines de caractère correspondant à l'heure
      Time = Message.substring(Message.indexOf('/') + 7, Message.indexOf('/') + 15);
      //affichage dans le moniteur série
      Serial.println(Time);
      
      Serial.println("##############################################################");
      
      Serial.print("Latitude: ");
      Latitude = Message.substring(Message.indexOf("0,") + 11, Message.indexOf(',') + 19);
      Serial.println(Latitude);
      
      Longitude = Message.substring(Message.indexOf(':') + 4, Message.indexOf(',') + 9);
      Serial.print("Longitude: ");
      Serial.println(Longitude);
      
      Serial.println("##############################################################");
    }
  }
  sim800l.println( "AT+SAPBR =0,1");

exit(0);
}


Récapitulatif des AT commandes utilisées pour la localisation:

CommandesRéponsesInfo
AT+CGATTOK
Connexion au service GPRS
AT+SAPBR =3,1, »CONTYPE », »GPRS »OKConfiguration du support en GPRS
AT+SAPBR =3,1, »APN », »orange.m2m.spec »OKConfiguration de l’APN
AT+SAPBR =3,1, »USER », »orange »OKUser de l’APN
AT+SAPBR =3,1, »PWD », »orange »OKMot de passe de l’APN
AT+SAPBR=1,1OKOuverture du support
AT+SAPBR=2,1+SAPBR: 1,1, »IP »
OK
Vérification de la connexion
AT+CIPGSMLOC=1,1+CIPGSMLOC: 0,Longitude,Latitude,AAAA/MM/JJ,H:MIN:SECRécupération de la localisation et de l’heure
AT+SAPBR =0,1OKFermeture du support
  1. Bonjour , le travail s’arrête en cours de travail sur ma cnc sans message d’erreur et ceci malgré différents…

[TUTO] – Fabriquer un compteur de likes Facebook, Twitter et Instagram

Aujourd’hui, nous réalisons un compteur de likes Facebook, Instagram et Twitter connecté en wifi. Il vous permettra d’afficher votre nombre de likes depuis votre page facebook, ainsi que votre nombre de followers instagram et twitter.

1. Matériel utilisé

Afin de réaliser votre compteur de likes, il vous faudra :

2. Montage

Connectez les 5 fils de la manière suivante : 

Matrice LEDLinkNode D1
5v5v
GNDGND
CS1D2
WRD3
DATAD4

Si vous disposez d’une imprimante 3D, vous pouvez télécharger le fichier d’impression 3D afin de fabriquer le boîtier. Visser l’écran ainsi que le LinkNode D1 de la manière suivante :

3. Le code

  1. Téléchargez la dernière version de l’IDE Arduino.
  2. Si vous utilisez le LinkNode D1, 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 » ajouter le lien suivant :


    http://arduino.esp8266.com/stable/package_esp8266com_index.json

  3. Vous pouvez télécharger le code du compteur de likes sur github.
  4. Déplacer les librairies téléchargées avec le compteur de likes dans votre répertoire Arduino /librairies
  5. Votre répertoire Arduino devrait ressembler à cela
  6. Raccordez votre compteur de likes grâce à un câble USB/microUSB  vers votre ordinateur.
  7. Ouvrez votre IDE Arduino et modifiez les lignes 23-24 par le nom de votre réseau wifi ainsi que le mot de passe.

3.a Facebook

  1. Pour lier votre compte Facebook, vous devez vous rendre sur l’API Facebook et vous identifier. (Afin de pouvoir afficher le nombre de likes sur votre page vous devez en être administrateur).
  2. Sélectionnez « Mes applications » → « Ajouter une application », nommez votre application et faites « Créer un ID d’app ».
  3. Sélectionnez « Outils » → « Explorateur de l’API Graph », puis récupérez le token d’accès (Ctrl+C).
  4. Toujours dans “Outils”, sélectionnez “Outils de débug de tokens d’accès”, coller (Ctrl+v) le dans la barre associée, puis cliquez sur “Débuguer“. Des informations sur le token d’accès devrait s’afficher dont sa durée d’expiration. Par défaut il expire au bout d’une heure, pour éviter cela cliquez sur “étendre le token d’accès”. Un nouveau token d’accès vous est donné, copiez le.
  5. Afin de récupérer l’ID de votre page, copiez l’url de votre page sur ce site puis cliquez sur “Find numeric ID”.
  6. Ajoutez le token d’accès et votre ID de page dans le fichier like_counter.ino à la ligne 25-26.

3.b Instagram

  1. Afin de lier votre compte Instagram, commencez par vous identifier sur la plateforme dédiée ici.
  2. Cliquez sur « Manage Clients ».
  3. Puis remplissez les champs de la manière suivante.
  4. Dans l’onglet « Security », décochez « Disable implicit OAuth ». Puis cliquez sur « Register ».
  5. Une fois enregistré, vous devriez pouvoir voir votre application comme ceci, et trouver votre Client ID.
  6. Copier / coller l’URL suivante en remplaçant “[CLIENT_ID]” par le votre dans un navigateur web :

    https://instagram.com/oauth/authorize/?client_id=[CLIENT_ID]&redirect_uri=http://localhost&response_type=token

  7. vous devriez récupérer une URL de ce type : http://localhost/#access_token=********** , avec votre access token à la fin.
  8. Il ne vous restera plus qu’à l’ajouter dans le code, ligne 29.

3.c Twitter

  1. Pour lier votre compte Twitter, rien de plus simple. Récupérez votre nom de page dans l’url. (ex: https://twitter.com/letmeknowfr?lang=fr → le nom de notre Twitter est « letmeknowfr »)
  2. Puis ajoutez le dans le programme du compteur ligne 27.

3.d Téléverser le code

  1. Afin de téléverser le code sur votre carte, commencez par sélectionner votre carte. Dans “Outils” → “Type de carte”, sélectionner “WeMos D1 (Retired)” si vous utilisez le LinkNode D1. Puis paramétrer le de la manière suivante :
  2. Sélectionnez le port COM sur lequel votre carte est connectée.
  3. Et enfin, cliquez sur Téléverser.

[Tutoriel] Créer un système de commande vocale avec Orange Pi

(Le son émis par Snips n’est pas disponible car il n’y a pas de haut-parleur)

Sur la base du système Open Source Snips, il est possible de créer un système de commande vocale hors ligne. Afin de le créer, il est nécessaire d’avoir un PC, une carte Orange Pi Zéro Plus 2 H3, son shield et une carte SD dont la capacité est d’au moins 4Go. La carte est conçue par Xunlong.

Etape 1: Faire un setup du PC

Sous Linux :
La plateforme Snips est basée sur Linux terminal. Il n’est pas nécessaire de faire un setup.

Sous Windows :
Il faut quelques étapes préparatoires pour simuler l’environnement Linux afin d’utiliser Snips.

  1. Ouvrez Windows PowerShell en tant qu’administrateur (touche Win + x, a) et tapez la commande suivante :

    > Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

  2. Choisissez la distribution de Linux depuis le Microsoft Store

  3. Tapez « bash » dans un barre d’adresse.

  4. Changez le mot de passe pour utiliser la commande sudo :

    Cf. https://docs.microsoft.com/en-us/windows/wsl/user-support

(Source : https://docs.microsoft.com/en-us/windows/wsl/install-win10)

Etape 2: Faire un setup de la carte

La première tâche est d’installer un système d’exploitation dans la carte Orange Pi. Puis, formatez la carte SD.

Sous Windows 10, utilisez le logiciel SD Memory Card Formatter fourni par SD Association pour formater la carte puis Win32DiskImager  pour écrire l’image fourni ci-dessous:
OPi_Snips.img (4Go)

Sous Linux, utilisez gparted pour formater la carte en format FAT32 puis saisissez:
dd if=/[CHEMIN]/OPi_Snips.img of= /dev/sdX
« /dev/sdX » est votre carte SD. Identifiez-la avec la commande « sudo fdisk -l« .

Actuellement, il n’y a que Armbian Stretch dans laquelle plateforme Snips fonctionne correctement.

Etape 3: Utilisation de l’assistant vocal :

Dites Hey Snips”. Après un bip sonore ou un peu de temps, dites « Allumer la lumière » ou « Eteindre la lumière » et le pin GPIO 12(PA12) sera allumé (3.3V) ou éteint.

Pour modifier l’action,
Modifiez :
/var/lib/snips/skills/Snips-ContactSec-Opi/action-contact.sec.py

Puis,
lancez :
$ sudo service snips-skill-server restart

Pour manipuler des pins multiples,
Ajoutez dans le script :
OPiGPIO.gpio_config([NUMERO_PIN])
pour allumer un pin GPIO :
OPiGPIO.gpio_on([NUMERO_PIN])
ou
pour éteindre un pin GPIO :
OPiGPIO.gpio_off([NUMERO_PIN])
OPiGPIO.gpio_unexport([NUMERO_PIN])

Example:
#Pour allumer un pin GPIO 7
OPiGPIO.gpio_config(7)
OPiGPIO.gpio_on(7)
OPiGPIO.gpio_unexport(7)

 
Source : https://stackoverflow.com/questions/46463724/accessing-gpio-on-orangepi-pc-plus-h3-on-armbian-3-4-113-and-newer

NUMERO_PIN : (la position d’une lettre – 1) * 32 + le numéro de pin.

Par exemple, le NUMERO_PIN de PA12 est calculé dans la manière suivante :

A = 1ère position

Le numéro de pin = 12

Alors, NUMERO_PIN = (1 – 1) * 32 + 12 = 12

Pour aller plus loin, vous pouvez regarder la documentation sur notre Github.